xref: /qemu/include/hw/virtio/virtio-gpu.h (revision 70ce076fa6dff60585c229a4b641b13e64bf03cf) 
1 /*
2  * Virtio GPU Device
3  *
4  * Copyright Red Hat, Inc. 2013-2014
5  *
6  * Authors:
7  *     Dave Airlie <airlied@redhat.com>
8  *     Gerd Hoffmann <kraxel@redhat.com>
9  *
10  * This work is licensed under the terms of the GNU GPL, version 2.
11  * See the COPYING file in the top-level directory.
12  */
13 
14 #ifndef HW_VIRTIO_GPU_H
15 #define HW_VIRTIO_GPU_H
16 
17 #include "qemu/queue.h"
18 #include "ui/qemu-pixman.h"
19 #include "ui/console.h"
20 #include "hw/virtio/virtio.h"
21 #include "qemu/log.h"
22 #include "system/vhost-user-backend.h"
23 
24 #include "standard-headers/linux/virtio_gpu.h"
25 #include "standard-headers/linux/virtio_ids.h"
26 #include "qom/object.h"
27 
28 #define TYPE_VIRTIO_GPU_BASE "virtio-gpu-base"
29 OBJECT_DECLARE_TYPE(VirtIOGPUBase, VirtIOGPUBaseClass,
30                     VIRTIO_GPU_BASE)
31 
32 #define TYPE_VIRTIO_GPU "virtio-gpu-device"
33 OBJECT_DECLARE_TYPE(VirtIOGPU, VirtIOGPUClass, VIRTIO_GPU)
34 
35 #define TYPE_VIRTIO_GPU_GL "virtio-gpu-gl-device"
36 OBJECT_DECLARE_SIMPLE_TYPE(VirtIOGPUGL, VIRTIO_GPU_GL)
37 
38 #define TYPE_VHOST_USER_GPU "vhost-user-gpu"
39 OBJECT_DECLARE_SIMPLE_TYPE(VhostUserGPU, VHOST_USER_GPU)
40 
41 #define TYPE_VIRTIO_GPU_RUTABAGA "virtio-gpu-rutabaga-device"
42 OBJECT_DECLARE_SIMPLE_TYPE(VirtIOGPURutabaga, VIRTIO_GPU_RUTABAGA)
43 
44 struct virtio_gpu_simple_resource {
45     uint32_t resource_id;
46     uint32_t width;
47     uint32_t height;
48     uint32_t format;
49     uint64_t *addrs;
50     struct iovec *iov;
51     unsigned int iov_cnt;
52     uint32_t scanout_bitmask;
53     pixman_image_t *image;
54     qemu_pixman_shareable share_handle;
55     uint64_t hostmem;
56 
57     uint64_t blob_size;
58     void *blob;
59     int dmabuf_fd;
60     uint8_t *remapped;
61 
62     QTAILQ_ENTRY(virtio_gpu_simple_resource) next;
63 };
64 
65 struct virtio_gpu_framebuffer {
66     pixman_format_code_t format;
67     uint32_t bytes_pp;
68     uint32_t width, height;
69     uint32_t stride;
70     uint32_t offset;
71 };
72 
73 struct virtio_gpu_scanout {
74     QemuConsole *con;
75     DisplaySurface *ds;
76     uint32_t width, height;
77     int x, y;
78     int invalidate;
79     uint32_t resource_id;
80     struct virtio_gpu_update_cursor cursor;
81     QEMUCursor *current_cursor;
82     struct virtio_gpu_framebuffer fb;
83 };
84 
85 struct virtio_gpu_requested_state {
86     uint16_t width_mm, height_mm;
87     uint32_t width, height;
88     uint32_t refresh_rate;
89     int x, y;
90 };
91 
92 enum virtio_gpu_base_conf_flags {
93     VIRTIO_GPU_FLAG_VIRGL_ENABLED = 1,
94     VIRTIO_GPU_FLAG_STATS_ENABLED,
95     VIRTIO_GPU_FLAG_EDID_ENABLED,
96     VIRTIO_GPU_FLAG_DMABUF_ENABLED,
97     VIRTIO_GPU_FLAG_BLOB_ENABLED,
98     VIRTIO_GPU_FLAG_CONTEXT_INIT_ENABLED,
99     VIRTIO_GPU_FLAG_RUTABAGA_ENABLED,
100     VIRTIO_GPU_FLAG_VENUS_ENABLED,
101     VIRTIO_GPU_FLAG_RESOURCE_UUID_ENABLED,
102 };
103 
104 #define virtio_gpu_virgl_enabled(_cfg) \
105     (_cfg.flags & (1 << VIRTIO_GPU_FLAG_VIRGL_ENABLED))
106 #define virtio_gpu_stats_enabled(_cfg) \
107     (_cfg.flags & (1 << VIRTIO_GPU_FLAG_STATS_ENABLED))
108 #define virtio_gpu_edid_enabled(_cfg) \
109     (_cfg.flags & (1 << VIRTIO_GPU_FLAG_EDID_ENABLED))
110 #define virtio_gpu_dmabuf_enabled(_cfg) \
111     (_cfg.flags & (1 << VIRTIO_GPU_FLAG_DMABUF_ENABLED))
112 #define virtio_gpu_blob_enabled(_cfg) \
113     (_cfg.flags & (1 << VIRTIO_GPU_FLAG_BLOB_ENABLED))
114 #define virtio_gpu_context_init_enabled(_cfg) \
115     (_cfg.flags & (1 << VIRTIO_GPU_FLAG_CONTEXT_INIT_ENABLED))
116 #define virtio_gpu_rutabaga_enabled(_cfg) \
117     (_cfg.flags & (1 << VIRTIO_GPU_FLAG_RUTABAGA_ENABLED))
118 #define virtio_gpu_resource_uuid_enabled(_cfg) \
119     (_cfg.flags & (1 << VIRTIO_GPU_FLAG_RESOURCE_UUID_ENABLED))
120 #define virtio_gpu_hostmem_enabled(_cfg) \
121     (_cfg.hostmem > 0)
122 #define virtio_gpu_venus_enabled(_cfg) \
123     (_cfg.flags & (1 << VIRTIO_GPU_FLAG_VENUS_ENABLED))
124 
125 struct virtio_gpu_base_conf {
126     uint32_t max_outputs;
127     uint32_t flags;
128     uint32_t xres;
129     uint32_t yres;
130     uint64_t hostmem;
131 };
132 
133 struct virtio_gpu_ctrl_command {
134     VirtQueueElement elem;
135     VirtQueue *vq;
136     struct virtio_gpu_ctrl_hdr cmd_hdr;
137     uint32_t error;
138     bool finished;
139     QTAILQ_ENTRY(virtio_gpu_ctrl_command) next;
140 };
141 
142 struct VirtIOGPUBase {
143     VirtIODevice parent_obj;
144 
145     Error *migration_blocker;
146 
147     struct virtio_gpu_base_conf conf;
148     struct virtio_gpu_config virtio_config;
149     const GraphicHwOps *hw_ops;
150 
151     int renderer_blocked;
152     int enable;
153 
154     MemoryRegion hostmem;
155 
156     struct virtio_gpu_scanout scanout[VIRTIO_GPU_MAX_SCANOUTS];
157 
158     int enabled_output_bitmask;
159     struct virtio_gpu_requested_state req_state[VIRTIO_GPU_MAX_SCANOUTS];
160 };
161 
162 struct VirtIOGPUBaseClass {
163     VirtioDeviceClass parent;
164 
165     void (*gl_flushed)(VirtIOGPUBase *g);
166 };
167 
168 #define VIRTIO_GPU_BASE_PROPERTIES(_state, _conf)                       \
169     DEFINE_PROP_UINT32("max_outputs", _state, _conf.max_outputs, 1),    \
170     DEFINE_PROP_BIT("edid", _state, _conf.flags, \
171                     VIRTIO_GPU_FLAG_EDID_ENABLED, true), \
172     DEFINE_PROP_UINT32("xres", _state, _conf.xres, 1280), \
173     DEFINE_PROP_UINT32("yres", _state, _conf.yres, 800)
174 
175 typedef struct VGPUDMABuf {
176     QemuDmaBuf *buf;
177     uint32_t scanout_id;
178     QTAILQ_ENTRY(VGPUDMABuf) next;
179 } VGPUDMABuf;
180 
181 struct VirtIOGPU {
182     VirtIOGPUBase parent_obj;
183 
184     uint8_t scanout_vmstate_version;
185     uint64_t conf_max_hostmem;
186 
187     VirtQueue *ctrl_vq;
188     VirtQueue *cursor_vq;
189 
190     QEMUBH *ctrl_bh;
191     QEMUBH *cursor_bh;
192     QEMUBH *reset_bh;
193     QemuCond reset_cond;
194     bool reset_finished;
195 
196     QTAILQ_HEAD(, virtio_gpu_simple_resource) reslist;
197     QTAILQ_HEAD(, virtio_gpu_ctrl_command) cmdq;
198     QTAILQ_HEAD(, virtio_gpu_ctrl_command) fenceq;
199 
200     uint64_t hostmem;
201 
202     bool processing_cmdq;
203 
204     uint32_t inflight;
205     struct {
206         uint32_t max_inflight;
207         uint32_t requests;
208         uint32_t req_3d;
209         uint32_t bytes_3d;
210     } stats;
211 
212     struct {
213         QTAILQ_HEAD(, VGPUDMABuf) bufs;
214         VGPUDMABuf *primary[VIRTIO_GPU_MAX_SCANOUTS];
215     } dmabuf;
216 
217     GArray *capset_ids;
218 };
219 
220 struct VirtIOGPUClass {
221     VirtIOGPUBaseClass parent;
222 
223     void (*handle_ctrl)(VirtIODevice *vdev, VirtQueue *vq);
224     void (*process_cmd)(VirtIOGPU *g, struct virtio_gpu_ctrl_command *cmd);
225     void (*update_cursor_data)(VirtIOGPU *g,
226                                struct virtio_gpu_scanout *s,
227                                uint32_t resource_id);
228     void (*resource_destroy)(VirtIOGPU *g,
229                              struct virtio_gpu_simple_resource *res,
230                              Error **errp);
231 };
232 
233 /* VirtIOGPUGL renderer states */
234 typedef enum {
235     RS_START,       /* starting state */
236     RS_INIT_FAILED, /* failed initialisation */
237     RS_INITED,      /* initialised and working */
238     RS_RESET,       /* inited and reset pending, moves to start after reset */
239 } RenderState;
240 
241 struct VirtIOGPUGL {
242     struct VirtIOGPU parent_obj;
243 
244     RenderState renderer_state;
245 
246     QEMUTimer *fence_poll;
247     QEMUTimer *print_stats;
248 
249     QEMUBH *cmdq_resume_bh;
250 };
251 
252 struct VhostUserGPU {
253     VirtIOGPUBase parent_obj;
254 
255     VhostUserBackend *vhost;
256     int vhost_gpu_fd; /* closed by the chardev */
257     CharBackend vhost_chr;
258     QemuDmaBuf *dmabuf[VIRTIO_GPU_MAX_SCANOUTS];
259     bool backend_blocked;
260 };
261 
262 #define MAX_SLOTS 4096
263 
264 struct MemoryRegionInfo {
265     int used;
266     MemoryRegion mr;
267     uint32_t resource_id;
268 };
269 
270 struct rutabaga;
271 
272 struct VirtIOGPURutabaga {
273     VirtIOGPU parent_obj;
274     struct MemoryRegionInfo memory_regions[MAX_SLOTS];
275     uint64_t capset_mask;
276     char *wayland_socket_path;
277     char *wsi;
278     bool headless;
279     uint32_t num_capsets;
280     struct rutabaga *rutabaga;
281 };
282 
283 #define VIRTIO_GPU_FILL_CMD(out) do {                                   \
284         size_t virtiogpufillcmd_s_ =                                    \
285             iov_to_buf(cmd->elem.out_sg, cmd->elem.out_num, 0,          \
286                        &out, sizeof(out));                              \
287         if (virtiogpufillcmd_s_ != sizeof(out)) {                       \
288             qemu_log_mask(LOG_GUEST_ERROR,                              \
289                           "%s: command size incorrect %zu vs %zu\n",    \
290                           __func__, virtiogpufillcmd_s_, sizeof(out));  \
291             return;                                                     \
292         }                                                               \
293     } while (0)
294 
295 /* virtio-gpu-base.c */
296 bool virtio_gpu_base_device_realize(DeviceState *qdev,
297                                     VirtIOHandleOutput ctrl_cb,
298                                     VirtIOHandleOutput cursor_cb,
299                                     Error **errp);
300 void virtio_gpu_base_device_unrealize(DeviceState *qdev);
301 void virtio_gpu_base_reset(VirtIOGPUBase *g);
302 void virtio_gpu_base_fill_display_info(VirtIOGPUBase *g,
303                         struct virtio_gpu_resp_display_info *dpy_info);
304 
305 void virtio_gpu_base_generate_edid(VirtIOGPUBase *g, int scanout,
306                                    struct virtio_gpu_resp_edid *edid);
307 /* virtio-gpu.c */
308 struct virtio_gpu_simple_resource *
309 virtio_gpu_find_resource(VirtIOGPU *g, uint32_t resource_id);
310 
311 void virtio_gpu_ctrl_response(VirtIOGPU *g,
312                               struct virtio_gpu_ctrl_command *cmd,
313                               struct virtio_gpu_ctrl_hdr *resp,
314                               size_t resp_len);
315 void virtio_gpu_ctrl_response_nodata(VirtIOGPU *g,
316                                      struct virtio_gpu_ctrl_command *cmd,
317                                      enum virtio_gpu_ctrl_type type);
318 void virtio_gpu_get_display_info(VirtIOGPU *g,
319                                  struct virtio_gpu_ctrl_command *cmd);
320 void virtio_gpu_get_edid(VirtIOGPU *g,
321                          struct virtio_gpu_ctrl_command *cmd);
322 int virtio_gpu_create_mapping_iov(VirtIOGPU *g,
323                                   uint32_t nr_entries, uint32_t offset,
324                                   struct virtio_gpu_ctrl_command *cmd,
325                                   uint64_t **addr, struct iovec **iov,
326                                   uint32_t *niov);
327 void virtio_gpu_cleanup_mapping_iov(VirtIOGPU *g,
328                                     struct iovec *iov, uint32_t count);
329 void virtio_gpu_cleanup_mapping(VirtIOGPU *g,
330                                 struct virtio_gpu_simple_resource *res);
331 void virtio_gpu_process_cmdq(VirtIOGPU *g);
332 void virtio_gpu_device_realize(DeviceState *qdev, Error **errp);
333 void virtio_gpu_reset(VirtIODevice *vdev);
334 void virtio_gpu_simple_process_cmd(VirtIOGPU *g, struct virtio_gpu_ctrl_command *cmd);
335 void virtio_gpu_update_cursor_data(VirtIOGPU *g,
336                                    struct virtio_gpu_scanout *s,
337                                    uint32_t resource_id);
338 
339 /**
340  * virtio_gpu_scanout_blob_to_fb() - fill out fb based on scanout data
341  * fb: the frame-buffer descriptor to fill out
342  * ss: the scanout blob data
343  * blob_size: size of scanout blob data
344  *
345  * This will check we have enough space for the frame taking into
346  * account that stride.
347  *
348  * Returns true on success, otherwise logs guest error and returns false
349  */
350 bool virtio_gpu_scanout_blob_to_fb(struct virtio_gpu_framebuffer *fb,
351                                    struct virtio_gpu_set_scanout_blob *ss,
352                                    uint64_t blob_size);
353 
354 /* virtio-gpu-udmabuf.c */
355 bool virtio_gpu_have_udmabuf(void);
356 void virtio_gpu_init_udmabuf(struct virtio_gpu_simple_resource *res);
357 void virtio_gpu_fini_udmabuf(struct virtio_gpu_simple_resource *res);
358 int virtio_gpu_update_dmabuf(VirtIOGPU *g,
359                              uint32_t scanout_id,
360                              struct virtio_gpu_simple_resource *res,
361                              struct virtio_gpu_framebuffer *fb,
362                              struct virtio_gpu_rect *r);
363 
364 void virtio_gpu_update_scanout(VirtIOGPU *g,
365                                uint32_t scanout_id,
366                                struct virtio_gpu_simple_resource *res,
367                                struct virtio_gpu_framebuffer *fb,
368                                struct virtio_gpu_rect *r);
369 void virtio_gpu_disable_scanout(VirtIOGPU *g, int scanout_id);
370 
371 /* virtio-gpu-3d.c */
372 void virtio_gpu_virgl_process_cmd(VirtIOGPU *g,
373                                   struct virtio_gpu_ctrl_command *cmd);
374 void virtio_gpu_virgl_fence_poll(VirtIOGPU *g);
375 void virtio_gpu_virgl_reset_scanout(VirtIOGPU *g);
376 void virtio_gpu_virgl_reset(VirtIOGPU *g);
377 int virtio_gpu_virgl_init(VirtIOGPU *g);
378 GArray *virtio_gpu_virgl_get_capsets(VirtIOGPU *g);
379 
380 #endif
381