Debian Codegraph @

src/gfxstream/guest/platform/include/VirtGpu.h

raw
1 /*
2 * Copyright 2022 Google
3 * SPDX-License-Identifier: MIT
4 */
5 #ifndef VIRTGPU_DEVICE_H
6 #define VIRTGPU_DEVICE_H
7
8 #include <cstdint>
9 #include <memory>
10
11 #include "virtio/virtio-gpu/virtgpu_gfxstream_protocol.h"
12 #include "virtio/virtio-gpu/virgl_hw.h"
13
14 #define PIPE_BUFFER 0
15 #define PIPE_TEXTURE_2D 2
16
17 enum VirtGpuParamId : uint32_t {
18 kParam3D = 0,
19 kParamCapsetFix = 1,
20 kParamResourceBlob = 2,
21 kParamHostVisible = 3,
22 kParamCrossDevice = 4,
23 kParamContextInit = 5,
24 kParamSupportedCapsetIds = 6,
25 kParamExplicitDebugName = 7,
26 // Experimental, not in upstream Linux
27 kParamFencePassing = 8,
28 kParamCreateGuestHandle = 9,
29 kParamMax = 10,
30 };
31
32 enum VirtGpuExecBufferFlags : uint32_t {
33 kFenceIn = 0x0001,
34 kFenceOut = 0x0002,
35 kRingIdx = 0x0004,
36 kShareableIn = 0x0008,
37 kShareableOut = 0x0010,
38 };
39
40 enum VirtGpuCapset {
41 kCapsetNone = 0,
42 kCapsetVirgl = 1,
43 kCapsetVirgl2 = 2,
44 kCapsetGfxStreamVulkan = 3,
45 kCapsetVenus = 4,
46 kCapsetCrossDomain = 5,
47 kCapsetDrm = 6,
48 kCapsetGfxStreamGles = 8,
49 kCapsetGfxStreamComposer = 9,
50 };
51
52 // Try to keep aligned with vulkan-cereal / rutabaga.
53 enum VirtGpuHandleType {
54 kMemHandleOpaqueFd = 0x0001,
55 kMemHandleDmabuf = 0x0002,
56 kMemHandleOpaqueWin32 = 0x0003,
57 kMemHandleShm = 0x0004,
58 kMemHandleZircon = 0x0008,
59 kFenceHandleOpaqueFd = 0x0010,
60 kFenceHandleSyncFd = 0x0020,
61 kFenceHandleOpaqueWin32 = 0x0040,
62 kFenceHandleZircon = 0x0080,
63 };
64
65 enum VirtGpuResourceFlags : uint32_t {
66 kBlobFlagMappable = 0x0001,
67 kBlobFlagShareable = 0x0002,
68 kBlobFlagCrossDevice = 0x0004,
69 kBlobFlagCreateGuestHandle = 0x0008,
70 };
71
72 enum VirtGpuResourceMem {
73 kBlobMemGuest = 0x0001,
74 kBlobMemHost3d = 0x0002,
75 kBlobMemHost3dGuest = 0x0003,
76 };
77
78 struct VirtGpuExternalHandle {
79 int64_t osHandle;
80 enum VirtGpuHandleType type;
81 };
82
83 struct VirtGpuExecBuffer {
84 void* command;
85 uint32_t command_size;
86 uint32_t ring_idx;
87 enum VirtGpuExecBufferFlags flags;
88 struct VirtGpuExternalHandle handle;
89 };
90
91 struct VirtGpuParam {
92 uint64_t param;
93 const char* name;
94 uint64_t value;
95 };
96
97 struct VirtGpuCreateBlob {
98 uint64_t size;
99 enum VirtGpuResourceFlags flags;
100 enum VirtGpuResourceMem blobMem;
101 uint64_t blobId;
102
103 uint8_t* blobCmd;
104 uint32_t blobCmdSize;
105 };
106
107 struct VirtGpuCaps {
108 uint64_t params[kParamMax];
109 struct vulkanCapset vulkanCapset;
110 struct magmaCapset magmaCapset;
111 struct glesCapset glesCapset;
112 struct composerCapset composerCapset;
113 };
114
115 struct VirtGpuDrmInfo {
116 bool hasPrimary;
117 bool hasRender;
118 int64_t primaryMajor;
119 int64_t primaryMinor;
120 int64_t renderMajor;
121 int64_t renderMinor;
122 };
123
124 // Note: Fields match equivalent structure for Magma
125 struct VirtGpuPciBusInfo {
126 uint16_t domain;
127 uint8_t bus;
128 uint8_t device;
129 uint8_t function;
130 };
131
132 constexpr int32_t INVALID_DESCRIPTOR = -1;
133
134 class VirtGpuResourceMapping;
135 class VirtGpuResource;
136 using VirtGpuResourcePtr = std::shared_ptr<VirtGpuResource>;
137 using VirtGpuResourceMappingPtr = std::shared_ptr<VirtGpuResourceMapping>;
138
139 class VirtGpuResource {
140 public:
141 virtual ~VirtGpuResource() {}
142
143 // The `intoRaw()` function drops ownerships of the OS-handle underlying
144 // the resource. It is the responsibility of the caller to manage lifetimes
145 // of the virtio-gpu resource. This function is mostly for gfxstream EGL
146 // compatibility and shouldn't be used elsewhere.
147 virtual void intoRaw(){};
148
149 virtual uint32_t getResourceHandle() const = 0;
150 virtual uint32_t getBlobHandle() const = 0;
151 virtual uint64_t getSize() const = 0;
152 virtual int wait() = 0;
153
154 virtual VirtGpuResourceMappingPtr createMapping(void) = 0;
155 virtual int exportBlob(struct VirtGpuExternalHandle& handle) = 0;
156
157 virtual int transferFromHost(uint32_t x, uint32_t y, uint32_t w, uint32_t h) = 0;
158 virtual int transferFromHost(uint32_t offset, uint32_t size) {
159 return transferFromHost(offset, 0, size, 1);
160 }
161
162 virtual int transferToHost(uint32_t x, uint32_t y, uint32_t w, uint32_t h) = 0;
163 virtual int transferToHost(uint32_t offset, uint32_t size) {
164 return transferToHost(offset, 0, size, 1);
165 }
166 };
167
168 class VirtGpuResourceMapping {
169 public:
170 virtual ~VirtGpuResourceMapping(void) {}
171
172 virtual uint8_t* asRawPtr(void) = 0;
173 };
174
175 class VirtGpuDevice {
176 public:
177 static VirtGpuDevice* getInstance(enum VirtGpuCapset capset = kCapsetNone,
178 int32_t descriptor = INVALID_DESCRIPTOR);
179 static void resetInstance();
180
181 VirtGpuDevice(enum VirtGpuCapset capset) : mCapset(capset) {}
182 virtual ~VirtGpuDevice() {}
183
184 enum VirtGpuCapset getCapset() { return mCapset; }
185
186 virtual int64_t getDeviceHandle(void) = 0;
187
188 virtual struct VirtGpuCaps getCaps(void) = 0;
189
190 virtual VirtGpuResourcePtr createBlob(const struct VirtGpuCreateBlob& blobCreate) = 0;
191 virtual VirtGpuResourcePtr createResource(uint32_t width, uint32_t height, uint32_t stride,
192 uint32_t size, uint32_t virglFormat, uint32_t target,
193 uint32_t bind) = 0;
194 virtual VirtGpuResourcePtr importBlob(const struct VirtGpuExternalHandle& handle) = 0;
195
196 virtual int execBuffer(struct VirtGpuExecBuffer& execbuffer, const VirtGpuResource* blob) = 0;
197
198 virtual bool getDrmInfo(VirtGpuDrmInfo* /*drmInfo*/) { return false; }
199 virtual bool getPciBusInfo(VirtGpuPciBusInfo* /*pciBusInfo*/) { return false; }
200
201 private:
202 enum VirtGpuCapset mCapset;
203 };
204
205 VirtGpuDevice* kumquatCreateVirtGpuDevice(enum VirtGpuCapset capset = kCapsetNone, int fd = -1);
206 VirtGpuDevice* osCreateVirtGpuDevice(enum VirtGpuCapset capset = kCapsetNone, int fd = -1);
207
208 VirtGpuDevice* createPlatformVirtGpuDevice(enum VirtGpuCapset capset = kCapsetNone, int fd = -1);
209
210 // HACK: We can use gfxstream::guest::EnumFlags, but we'll have to do more guest
211 // refactorings to figure out our end goal. We can either depend more on base or
212 // try to transition to something else (b:202552093) [atleast for guests].
213 constexpr enum VirtGpuResourceFlags operator|(const enum VirtGpuResourceFlags self,
214 const enum VirtGpuResourceFlags other) {
215 return (enum VirtGpuResourceFlags)(uint32_t(self) | uint32_t(other));
216 }
217
218 constexpr enum VirtGpuExecBufferFlags operator |(const enum VirtGpuExecBufferFlags self,
219 const enum VirtGpuExecBufferFlags other) {
220 return (enum VirtGpuExecBufferFlags)(uint32_t(self) | uint32_t(other));
221 }
222
223 #endif