xref: /openbmc/qemu/include/hw/virtio/virtio-gpu.h (revision 40a23ef6)
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 "sysemu/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 #ifdef WIN32
55     HANDLE handle;
56 #endif
57     uint64_t hostmem;
58 
59     uint64_t blob_size;
60     void *blob;
61     int dmabuf_fd;
62     uint8_t *remapped;
63 
64     QTAILQ_ENTRY(virtio_gpu_simple_resource) next;
65 };
66 
67 struct virtio_gpu_framebuffer {
68     pixman_format_code_t format;
69     uint32_t bytes_pp;
70     uint32_t width, height;
71     uint32_t stride;
72     uint32_t offset;
73 };
74 
75 struct virtio_gpu_scanout {
76     QemuConsole *con;
77     DisplaySurface *ds;
78     uint32_t width, height;
79     int x, y;
80     int invalidate;
81     uint32_t resource_id;
82     struct virtio_gpu_update_cursor cursor;
83     QEMUCursor *current_cursor;
84     struct virtio_gpu_framebuffer fb;
85 };
86 
87 struct virtio_gpu_requested_state {
88     uint16_t width_mm, height_mm;
89     uint32_t width, height;
90     uint32_t refresh_rate;
91     int x, y;
92 };
93 
94 enum virtio_gpu_base_conf_flags {
95     VIRTIO_GPU_FLAG_VIRGL_ENABLED = 1,
96     VIRTIO_GPU_FLAG_STATS_ENABLED,
97     VIRTIO_GPU_FLAG_EDID_ENABLED,
98     VIRTIO_GPU_FLAG_DMABUF_ENABLED,
99     VIRTIO_GPU_FLAG_BLOB_ENABLED,
100     VIRTIO_GPU_FLAG_CONTEXT_INIT_ENABLED,
101     VIRTIO_GPU_FLAG_RUTABAGA_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_hostmem_enabled(_cfg) \
119     (_cfg.hostmem > 0)
120 
121 struct virtio_gpu_base_conf {
122     uint32_t max_outputs;
123     uint32_t flags;
124     uint32_t xres;
125     uint32_t yres;
126     uint64_t hostmem;
127 };
128 
129 struct virtio_gpu_ctrl_command {
130     VirtQueueElement elem;
131     VirtQueue *vq;
132     struct virtio_gpu_ctrl_hdr cmd_hdr;
133     uint32_t error;
134     bool finished;
135     QTAILQ_ENTRY(virtio_gpu_ctrl_command) next;
136 };
137 
138 struct VirtIOGPUBase {
139     VirtIODevice parent_obj;
140 
141     Error *migration_blocker;
142 
143     struct virtio_gpu_base_conf conf;
144     struct virtio_gpu_config virtio_config;
145     const GraphicHwOps *hw_ops;
146 
147     int renderer_blocked;
148     int enable;
149 
150     MemoryRegion hostmem;
151 
152     struct virtio_gpu_scanout scanout[VIRTIO_GPU_MAX_SCANOUTS];
153 
154     int enabled_output_bitmask;
155     struct virtio_gpu_requested_state req_state[VIRTIO_GPU_MAX_SCANOUTS];
156 };
157 
158 struct VirtIOGPUBaseClass {
159     VirtioDeviceClass parent;
160 
161     void (*gl_flushed)(VirtIOGPUBase *g);
162 };
163 
164 #define VIRTIO_GPU_BASE_PROPERTIES(_state, _conf)                       \
165     DEFINE_PROP_UINT32("max_outputs", _state, _conf.max_outputs, 1),    \
166     DEFINE_PROP_BIT("edid", _state, _conf.flags, \
167                     VIRTIO_GPU_FLAG_EDID_ENABLED, true), \
168     DEFINE_PROP_UINT32("xres", _state, _conf.xres, 1280), \
169     DEFINE_PROP_UINT32("yres", _state, _conf.yres, 800)
170 
171 typedef struct VGPUDMABuf {
172     QemuDmaBuf *buf;
173     uint32_t scanout_id;
174     QTAILQ_ENTRY(VGPUDMABuf) next;
175 } VGPUDMABuf;
176 
177 struct VirtIOGPU {
178     VirtIOGPUBase parent_obj;
179 
180     uint8_t scanout_vmstate_version;
181     uint64_t conf_max_hostmem;
182 
183     VirtQueue *ctrl_vq;
184     VirtQueue *cursor_vq;
185 
186     QEMUBH *ctrl_bh;
187     QEMUBH *cursor_bh;
188     QEMUBH *reset_bh;
189     QemuCond reset_cond;
190     bool reset_finished;
191 
192     QTAILQ_HEAD(, virtio_gpu_simple_resource) reslist;
193     QTAILQ_HEAD(, virtio_gpu_ctrl_command) cmdq;
194     QTAILQ_HEAD(, virtio_gpu_ctrl_command) fenceq;
195 
196     uint64_t hostmem;
197 
198     bool processing_cmdq;
199     QEMUTimer *fence_poll;
200     QEMUTimer *print_stats;
201 
202     uint32_t inflight;
203     struct {
204         uint32_t max_inflight;
205         uint32_t requests;
206         uint32_t req_3d;
207         uint32_t bytes_3d;
208     } stats;
209 
210     struct {
211         QTAILQ_HEAD(, VGPUDMABuf) bufs;
212         VGPUDMABuf *primary[VIRTIO_GPU_MAX_SCANOUTS];
213     } dmabuf;
214 };
215 
216 struct VirtIOGPUClass {
217     VirtIOGPUBaseClass parent;
218 
219     void (*handle_ctrl)(VirtIODevice *vdev, VirtQueue *vq);
220     void (*process_cmd)(VirtIOGPU *g, struct virtio_gpu_ctrl_command *cmd);
221     void (*update_cursor_data)(VirtIOGPU *g,
222                                struct virtio_gpu_scanout *s,
223                                uint32_t resource_id);
224     void (*resource_destroy)(VirtIOGPU *g,
225                              struct virtio_gpu_simple_resource *res,
226                              Error **errp);
227 };
228 
229 struct VirtIOGPUGL {
230     struct VirtIOGPU parent_obj;
231 
232     bool renderer_inited;
233     bool renderer_reset;
234 };
235 
236 struct VhostUserGPU {
237     VirtIOGPUBase parent_obj;
238 
239     VhostUserBackend *vhost;
240     int vhost_gpu_fd; /* closed by the chardev */
241     CharBackend vhost_chr;
242     QemuDmaBuf *dmabuf[VIRTIO_GPU_MAX_SCANOUTS];
243     bool backend_blocked;
244 };
245 
246 #define MAX_SLOTS 4096
247 
248 struct MemoryRegionInfo {
249     int used;
250     MemoryRegion mr;
251     uint32_t resource_id;
252 };
253 
254 struct rutabaga;
255 
256 struct VirtIOGPURutabaga {
257     VirtIOGPU parent_obj;
258     struct MemoryRegionInfo memory_regions[MAX_SLOTS];
259     uint64_t capset_mask;
260     char *wayland_socket_path;
261     char *wsi;
262     bool headless;
263     uint32_t num_capsets;
264     struct rutabaga *rutabaga;
265 };
266 
267 #define VIRTIO_GPU_FILL_CMD(out) do {                                   \
268         size_t virtiogpufillcmd_s_ =                                    \
269             iov_to_buf(cmd->elem.out_sg, cmd->elem.out_num, 0,          \
270                        &out, sizeof(out));                              \
271         if (virtiogpufillcmd_s_ != sizeof(out)) {                       \
272             qemu_log_mask(LOG_GUEST_ERROR,                              \
273                           "%s: command size incorrect %zu vs %zu\n",    \
274                           __func__, virtiogpufillcmd_s_, sizeof(out));  \
275             return;                                                     \
276         }                                                               \
277     } while (0)
278 
279 /* virtio-gpu-base.c */
280 bool virtio_gpu_base_device_realize(DeviceState *qdev,
281                                     VirtIOHandleOutput ctrl_cb,
282                                     VirtIOHandleOutput cursor_cb,
283                                     Error **errp);
284 void virtio_gpu_base_device_unrealize(DeviceState *qdev);
285 void virtio_gpu_base_reset(VirtIOGPUBase *g);
286 void virtio_gpu_base_fill_display_info(VirtIOGPUBase *g,
287                         struct virtio_gpu_resp_display_info *dpy_info);
288 
289 void virtio_gpu_base_generate_edid(VirtIOGPUBase *g, int scanout,
290                                    struct virtio_gpu_resp_edid *edid);
291 /* virtio-gpu.c */
292 struct virtio_gpu_simple_resource *
293 virtio_gpu_find_resource(VirtIOGPU *g, uint32_t resource_id);
294 
295 void virtio_gpu_ctrl_response(VirtIOGPU *g,
296                               struct virtio_gpu_ctrl_command *cmd,
297                               struct virtio_gpu_ctrl_hdr *resp,
298                               size_t resp_len);
299 void virtio_gpu_ctrl_response_nodata(VirtIOGPU *g,
300                                      struct virtio_gpu_ctrl_command *cmd,
301                                      enum virtio_gpu_ctrl_type type);
302 void virtio_gpu_get_display_info(VirtIOGPU *g,
303                                  struct virtio_gpu_ctrl_command *cmd);
304 void virtio_gpu_get_edid(VirtIOGPU *g,
305                          struct virtio_gpu_ctrl_command *cmd);
306 int virtio_gpu_create_mapping_iov(VirtIOGPU *g,
307                                   uint32_t nr_entries, uint32_t offset,
308                                   struct virtio_gpu_ctrl_command *cmd,
309                                   uint64_t **addr, struct iovec **iov,
310                                   uint32_t *niov);
311 void virtio_gpu_cleanup_mapping_iov(VirtIOGPU *g,
312                                     struct iovec *iov, uint32_t count);
313 void virtio_gpu_cleanup_mapping(VirtIOGPU *g,
314                                 struct virtio_gpu_simple_resource *res);
315 void virtio_gpu_process_cmdq(VirtIOGPU *g);
316 void virtio_gpu_device_realize(DeviceState *qdev, Error **errp);
317 void virtio_gpu_reset(VirtIODevice *vdev);
318 void virtio_gpu_simple_process_cmd(VirtIOGPU *g, struct virtio_gpu_ctrl_command *cmd);
319 void virtio_gpu_update_cursor_data(VirtIOGPU *g,
320                                    struct virtio_gpu_scanout *s,
321                                    uint32_t resource_id);
322 
323 /* virtio-gpu-udmabuf.c */
324 bool virtio_gpu_have_udmabuf(void);
325 void virtio_gpu_init_udmabuf(struct virtio_gpu_simple_resource *res);
326 void virtio_gpu_fini_udmabuf(struct virtio_gpu_simple_resource *res);
327 int virtio_gpu_update_dmabuf(VirtIOGPU *g,
328                              uint32_t scanout_id,
329                              struct virtio_gpu_simple_resource *res,
330                              struct virtio_gpu_framebuffer *fb,
331                              struct virtio_gpu_rect *r);
332 
333 /* virtio-gpu-3d.c */
334 void virtio_gpu_virgl_process_cmd(VirtIOGPU *g,
335                                   struct virtio_gpu_ctrl_command *cmd);
336 void virtio_gpu_virgl_fence_poll(VirtIOGPU *g);
337 void virtio_gpu_virgl_reset_scanout(VirtIOGPU *g);
338 void virtio_gpu_virgl_reset(VirtIOGPU *g);
339 int virtio_gpu_virgl_init(VirtIOGPU *g);
340 int virtio_gpu_virgl_get_num_capsets(VirtIOGPU *g);
341 
342 #endif
343