]>
Commit | Line | Data |
---|---|---|
a9994687 GH |
1 | /* |
2 | * display support for mdev based vgpu devices | |
3 | * | |
4 | * Copyright Red Hat, Inc. 2017 | |
5 | * | |
6 | * Authors: | |
7 | * Gerd Hoffmann | |
8 | * | |
9 | * This work is licensed under the terms of the GNU GPL, version 2. See | |
10 | * the COPYING file in the top-level directory. | |
11 | */ | |
12 | ||
13 | #include "qemu/osdep.h" | |
14 | #include <linux/vfio.h> | |
15 | #include <sys/ioctl.h> | |
16 | ||
cc37d98b | 17 | #include "qemu/error-report.h" |
08479114 | 18 | #include "hw/display/edid.h" |
a9994687 GH |
19 | #include "ui/console.h" |
20 | #include "qapi/error.h" | |
21 | #include "pci.h" | |
08479114 | 22 | #include "trace.h" |
a9994687 | 23 | |
8b818e05 GH |
24 | #ifndef DRM_PLANE_TYPE_PRIMARY |
25 | # define DRM_PLANE_TYPE_PRIMARY 1 | |
26 | # define DRM_PLANE_TYPE_CURSOR 2 | |
27 | #endif | |
28 | ||
08479114 GH |
29 | #define pread_field(_fd, _reg, _ptr, _fld) \ |
30 | (sizeof(_ptr->_fld) != \ | |
31 | pread(_fd, &(_ptr->_fld), sizeof(_ptr->_fld), \ | |
32 | _reg->offset + offsetof(typeof(*_ptr), _fld))) | |
33 | ||
34 | #define pwrite_field(_fd, _reg, _ptr, _fld) \ | |
35 | (sizeof(_ptr->_fld) != \ | |
36 | pwrite(_fd, &(_ptr->_fld), sizeof(_ptr->_fld), \ | |
37 | _reg->offset + offsetof(typeof(*_ptr), _fld))) | |
38 | ||
39 | ||
8781c701 GH |
40 | static void vfio_display_edid_link_up(void *opaque) |
41 | { | |
42 | VFIOPCIDevice *vdev = opaque; | |
43 | VFIODisplay *dpy = vdev->dpy; | |
44 | int fd = vdev->vbasedev.fd; | |
45 | ||
46 | dpy->edid_regs->link_state = VFIO_DEVICE_GFX_LINK_STATE_UP; | |
47 | if (pwrite_field(fd, dpy->edid_info, dpy->edid_regs, link_state)) { | |
48 | goto err; | |
49 | } | |
50 | trace_vfio_display_edid_link_up(); | |
51 | return; | |
52 | ||
53 | err: | |
54 | trace_vfio_display_edid_write_error(); | |
55 | } | |
56 | ||
08479114 GH |
57 | static void vfio_display_edid_update(VFIOPCIDevice *vdev, bool enabled, |
58 | int prefx, int prefy) | |
59 | { | |
60 | VFIODisplay *dpy = vdev->dpy; | |
61 | int fd = vdev->vbasedev.fd; | |
62 | qemu_edid_info edid = { | |
63 | .maxx = dpy->edid_regs->max_xres, | |
64 | .maxy = dpy->edid_regs->max_yres, | |
c62a0c7c GH |
65 | .prefx = prefx ?: vdev->display_xres, |
66 | .prefy = prefy ?: vdev->display_yres, | |
08479114 GH |
67 | }; |
68 | ||
8781c701 | 69 | timer_del(dpy->edid_link_timer); |
08479114 GH |
70 | dpy->edid_regs->link_state = VFIO_DEVICE_GFX_LINK_STATE_DOWN; |
71 | if (pwrite_field(fd, dpy->edid_info, dpy->edid_regs, link_state)) { | |
72 | goto err; | |
73 | } | |
74 | trace_vfio_display_edid_link_down(); | |
75 | ||
76 | if (!enabled) { | |
77 | return; | |
78 | } | |
79 | ||
80 | if (edid.maxx && edid.prefx > edid.maxx) { | |
81 | edid.prefx = edid.maxx; | |
82 | } | |
83 | if (edid.maxy && edid.prefy > edid.maxy) { | |
84 | edid.prefy = edid.maxy; | |
85 | } | |
86 | qemu_edid_generate(dpy->edid_blob, | |
87 | dpy->edid_regs->edid_max_size, | |
88 | &edid); | |
89 | trace_vfio_display_edid_update(edid.prefx, edid.prefy); | |
90 | ||
91 | dpy->edid_regs->edid_size = qemu_edid_size(dpy->edid_blob); | |
92 | if (pwrite_field(fd, dpy->edid_info, dpy->edid_regs, edid_size)) { | |
93 | goto err; | |
94 | } | |
95 | if (pwrite(fd, dpy->edid_blob, dpy->edid_regs->edid_size, | |
96 | dpy->edid_info->offset + dpy->edid_regs->edid_offset) | |
97 | != dpy->edid_regs->edid_size) { | |
98 | goto err; | |
99 | } | |
100 | ||
8781c701 GH |
101 | timer_mod(dpy->edid_link_timer, |
102 | qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + 100); | |
08479114 GH |
103 | return; |
104 | ||
105 | err: | |
106 | trace_vfio_display_edid_write_error(); | |
107 | return; | |
108 | } | |
109 | ||
362239c0 AO |
110 | static void vfio_display_edid_ui_info(void *opaque, uint32_t idx, |
111 | QemuUIInfo *info) | |
08479114 GH |
112 | { |
113 | VFIOPCIDevice *vdev = opaque; | |
114 | VFIODisplay *dpy = vdev->dpy; | |
115 | ||
116 | if (!dpy->edid_regs) { | |
362239c0 | 117 | return; |
08479114 GH |
118 | } |
119 | ||
120 | if (info->width && info->height) { | |
121 | vfio_display_edid_update(vdev, true, info->width, info->height); | |
122 | } else { | |
123 | vfio_display_edid_update(vdev, false, 0, 0); | |
124 | } | |
08479114 GH |
125 | } |
126 | ||
127 | static void vfio_display_edid_init(VFIOPCIDevice *vdev) | |
128 | { | |
129 | VFIODisplay *dpy = vdev->dpy; | |
130 | int fd = vdev->vbasedev.fd; | |
131 | int ret; | |
132 | ||
133 | ret = vfio_get_dev_region_info(&vdev->vbasedev, | |
134 | VFIO_REGION_TYPE_GFX, | |
135 | VFIO_REGION_SUBTYPE_GFX_EDID, | |
136 | &dpy->edid_info); | |
137 | if (ret) { | |
138 | return; | |
139 | } | |
140 | ||
141 | trace_vfio_display_edid_available(); | |
142 | dpy->edid_regs = g_new0(struct vfio_region_gfx_edid, 1); | |
143 | if (pread_field(fd, dpy->edid_info, dpy->edid_regs, edid_offset)) { | |
144 | goto err; | |
145 | } | |
146 | if (pread_field(fd, dpy->edid_info, dpy->edid_regs, edid_max_size)) { | |
147 | goto err; | |
148 | } | |
149 | if (pread_field(fd, dpy->edid_info, dpy->edid_regs, max_xres)) { | |
150 | goto err; | |
151 | } | |
152 | if (pread_field(fd, dpy->edid_info, dpy->edid_regs, max_yres)) { | |
153 | goto err; | |
154 | } | |
155 | ||
156 | dpy->edid_blob = g_malloc0(dpy->edid_regs->edid_max_size); | |
157 | ||
c62a0c7c GH |
158 | /* if xres + yres properties are unset use the maximum resolution */ |
159 | if (!vdev->display_xres) { | |
160 | vdev->display_xres = dpy->edid_regs->max_xres; | |
161 | } | |
162 | if (!vdev->display_yres) { | |
163 | vdev->display_yres = dpy->edid_regs->max_yres; | |
164 | } | |
165 | ||
8781c701 GH |
166 | dpy->edid_link_timer = timer_new_ms(QEMU_CLOCK_REALTIME, |
167 | vfio_display_edid_link_up, vdev); | |
168 | ||
08479114 GH |
169 | vfio_display_edid_update(vdev, true, 0, 0); |
170 | return; | |
171 | ||
172 | err: | |
173 | trace_vfio_display_edid_write_error(); | |
174 | g_free(dpy->edid_regs); | |
175 | dpy->edid_regs = NULL; | |
176 | return; | |
177 | } | |
178 | ||
179 | static void vfio_display_edid_exit(VFIODisplay *dpy) | |
180 | { | |
181 | if (!dpy->edid_regs) { | |
182 | return; | |
183 | } | |
184 | ||
185 | g_free(dpy->edid_regs); | |
186 | g_free(dpy->edid_blob); | |
8781c701 | 187 | timer_free(dpy->edid_link_timer); |
08479114 GH |
188 | } |
189 | ||
8b818e05 GH |
190 | static void vfio_display_update_cursor(VFIODMABuf *dmabuf, |
191 | struct vfio_device_gfx_plane_info *plane) | |
192 | { | |
193 | if (dmabuf->pos_x != plane->x_pos || dmabuf->pos_y != plane->y_pos) { | |
194 | dmabuf->pos_x = plane->x_pos; | |
195 | dmabuf->pos_y = plane->y_pos; | |
196 | dmabuf->pos_updates++; | |
197 | } | |
198 | if (dmabuf->hot_x != plane->x_hot || dmabuf->hot_y != plane->y_hot) { | |
199 | dmabuf->hot_x = plane->x_hot; | |
200 | dmabuf->hot_y = plane->y_hot; | |
201 | dmabuf->hot_updates++; | |
202 | } | |
203 | } | |
204 | ||
205 | static VFIODMABuf *vfio_display_get_dmabuf(VFIOPCIDevice *vdev, | |
206 | uint32_t plane_type) | |
207 | { | |
208 | VFIODisplay *dpy = vdev->dpy; | |
209 | struct vfio_device_gfx_plane_info plane; | |
210 | VFIODMABuf *dmabuf; | |
211 | int fd, ret; | |
212 | ||
213 | memset(&plane, 0, sizeof(plane)); | |
214 | plane.argsz = sizeof(plane); | |
215 | plane.flags = VFIO_GFX_PLANE_TYPE_DMABUF; | |
216 | plane.drm_plane_type = plane_type; | |
217 | ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &plane); | |
218 | if (ret < 0) { | |
219 | return NULL; | |
220 | } | |
221 | if (!plane.drm_format || !plane.size) { | |
222 | return NULL; | |
223 | } | |
224 | ||
225 | QTAILQ_FOREACH(dmabuf, &dpy->dmabuf.bufs, next) { | |
226 | if (dmabuf->dmabuf_id == plane.dmabuf_id) { | |
227 | /* found in list, move to head, return it */ | |
228 | QTAILQ_REMOVE(&dpy->dmabuf.bufs, dmabuf, next); | |
229 | QTAILQ_INSERT_HEAD(&dpy->dmabuf.bufs, dmabuf, next); | |
230 | if (plane_type == DRM_PLANE_TYPE_CURSOR) { | |
231 | vfio_display_update_cursor(dmabuf, &plane); | |
232 | } | |
233 | return dmabuf; | |
234 | } | |
235 | } | |
236 | ||
237 | fd = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_GET_GFX_DMABUF, &plane.dmabuf_id); | |
238 | if (fd < 0) { | |
239 | return NULL; | |
240 | } | |
241 | ||
242 | dmabuf = g_new0(VFIODMABuf, 1); | |
243 | dmabuf->dmabuf_id = plane.dmabuf_id; | |
244 | dmabuf->buf.width = plane.width; | |
245 | dmabuf->buf.height = plane.height; | |
931150e5 AW |
246 | dmabuf->buf.backing_width = plane.width; |
247 | dmabuf->buf.backing_height = plane.height; | |
8b818e05 GH |
248 | dmabuf->buf.stride = plane.stride; |
249 | dmabuf->buf.fourcc = plane.drm_format; | |
a6c9d5da | 250 | dmabuf->buf.modifier = plane.drm_format_mod; |
8b818e05 GH |
251 | dmabuf->buf.fd = fd; |
252 | if (plane_type == DRM_PLANE_TYPE_CURSOR) { | |
253 | vfio_display_update_cursor(dmabuf, &plane); | |
254 | } | |
255 | ||
256 | QTAILQ_INSERT_HEAD(&dpy->dmabuf.bufs, dmabuf, next); | |
257 | return dmabuf; | |
258 | } | |
259 | ||
260 | static void vfio_display_free_one_dmabuf(VFIODisplay *dpy, VFIODMABuf *dmabuf) | |
261 | { | |
262 | QTAILQ_REMOVE(&dpy->dmabuf.bufs, dmabuf, next); | |
263 | dpy_gl_release_dmabuf(dpy->con, &dmabuf->buf); | |
264 | close(dmabuf->buf.fd); | |
265 | g_free(dmabuf); | |
266 | } | |
267 | ||
268 | static void vfio_display_free_dmabufs(VFIOPCIDevice *vdev) | |
269 | { | |
270 | VFIODisplay *dpy = vdev->dpy; | |
271 | VFIODMABuf *dmabuf, *tmp; | |
272 | uint32_t keep = 5; | |
273 | ||
274 | QTAILQ_FOREACH_SAFE(dmabuf, &dpy->dmabuf.bufs, next, tmp) { | |
275 | if (keep > 0) { | |
276 | keep--; | |
277 | continue; | |
278 | } | |
279 | assert(dmabuf != dpy->dmabuf.primary); | |
280 | vfio_display_free_one_dmabuf(dpy, dmabuf); | |
281 | } | |
282 | } | |
283 | ||
284 | static void vfio_display_dmabuf_update(void *opaque) | |
285 | { | |
286 | VFIOPCIDevice *vdev = opaque; | |
287 | VFIODisplay *dpy = vdev->dpy; | |
288 | VFIODMABuf *primary, *cursor; | |
180f3fd2 | 289 | bool free_bufs = false, new_cursor = false; |
8b818e05 GH |
290 | |
291 | primary = vfio_display_get_dmabuf(vdev, DRM_PLANE_TYPE_PRIMARY); | |
292 | if (primary == NULL) { | |
b290659f GH |
293 | if (dpy->ramfb) { |
294 | ramfb_display_update(dpy->con, dpy->ramfb); | |
295 | } | |
8b818e05 GH |
296 | return; |
297 | } | |
298 | ||
299 | if (dpy->dmabuf.primary != primary) { | |
300 | dpy->dmabuf.primary = primary; | |
301 | qemu_console_resize(dpy->con, | |
302 | primary->buf.width, primary->buf.height); | |
303 | dpy_gl_scanout_dmabuf(dpy->con, &primary->buf); | |
304 | free_bufs = true; | |
305 | } | |
306 | ||
307 | cursor = vfio_display_get_dmabuf(vdev, DRM_PLANE_TYPE_CURSOR); | |
308 | if (dpy->dmabuf.cursor != cursor) { | |
309 | dpy->dmabuf.cursor = cursor; | |
310 | new_cursor = true; | |
311 | free_bufs = true; | |
312 | } | |
313 | ||
314 | if (cursor && (new_cursor || cursor->hot_updates)) { | |
315 | bool have_hot = (cursor->hot_x != 0xffffffff && | |
316 | cursor->hot_y != 0xffffffff); | |
317 | dpy_gl_cursor_dmabuf(dpy->con, &cursor->buf, have_hot, | |
318 | cursor->hot_x, cursor->hot_y); | |
319 | cursor->hot_updates = 0; | |
320 | } else if (!cursor && new_cursor) { | |
321 | dpy_gl_cursor_dmabuf(dpy->con, NULL, false, 0, 0); | |
322 | } | |
323 | ||
324 | if (cursor && cursor->pos_updates) { | |
325 | dpy_gl_cursor_position(dpy->con, | |
326 | cursor->pos_x, | |
327 | cursor->pos_y); | |
328 | cursor->pos_updates = 0; | |
329 | } | |
330 | ||
331 | dpy_gl_update(dpy->con, 0, 0, primary->buf.width, primary->buf.height); | |
332 | ||
333 | if (free_bufs) { | |
334 | vfio_display_free_dmabufs(vdev); | |
335 | } | |
336 | } | |
337 | ||
a7dfbe28 MAL |
338 | static int vfio_display_get_flags(void *opaque) |
339 | { | |
340 | return GRAPHIC_FLAGS_GL | GRAPHIC_FLAGS_DMABUF; | |
341 | } | |
342 | ||
8b818e05 | 343 | static const GraphicHwOps vfio_display_dmabuf_ops = { |
a7dfbe28 | 344 | .get_flags = vfio_display_get_flags, |
8b818e05 | 345 | .gfx_update = vfio_display_dmabuf_update, |
08479114 | 346 | .ui_info = vfio_display_edid_ui_info, |
8b818e05 GH |
347 | }; |
348 | ||
349 | static int vfio_display_dmabuf_init(VFIOPCIDevice *vdev, Error **errp) | |
350 | { | |
351 | if (!display_opengl) { | |
352 | error_setg(errp, "vfio-display-dmabuf: opengl not available"); | |
353 | return -1; | |
354 | } | |
355 | ||
356 | vdev->dpy = g_new0(VFIODisplay, 1); | |
357 | vdev->dpy->con = graphic_console_init(DEVICE(vdev), 0, | |
358 | &vfio_display_dmabuf_ops, | |
359 | vdev); | |
b290659f | 360 | if (vdev->enable_ramfb) { |
2fc979cb | 361 | vdev->dpy->ramfb = ramfb_setup(errp); |
b290659f | 362 | } |
08479114 | 363 | vfio_display_edid_init(vdev); |
8b818e05 GH |
364 | return 0; |
365 | } | |
366 | ||
367 | static void vfio_display_dmabuf_exit(VFIODisplay *dpy) | |
368 | { | |
369 | VFIODMABuf *dmabuf; | |
370 | ||
371 | if (QTAILQ_EMPTY(&dpy->dmabuf.bufs)) { | |
372 | return; | |
373 | } | |
374 | ||
375 | while ((dmabuf = QTAILQ_FIRST(&dpy->dmabuf.bufs)) != NULL) { | |
376 | vfio_display_free_one_dmabuf(dpy, dmabuf); | |
377 | } | |
378 | } | |
379 | ||
00195ba7 | 380 | /* ---------------------------------------------------------------------- */ |
8983e3e3 TZ |
381 | void vfio_display_reset(VFIOPCIDevice *vdev) |
382 | { | |
383 | if (!vdev || !vdev->dpy || !vdev->dpy->con || | |
384 | !vdev->dpy->dmabuf.primary) { | |
385 | return; | |
386 | } | |
387 | ||
388 | dpy_gl_scanout_disable(vdev->dpy->con); | |
389 | vfio_display_dmabuf_exit(vdev->dpy); | |
390 | dpy_gfx_update_full(vdev->dpy->con); | |
391 | } | |
00195ba7 GH |
392 | |
393 | static void vfio_display_region_update(void *opaque) | |
394 | { | |
395 | VFIOPCIDevice *vdev = opaque; | |
396 | VFIODisplay *dpy = vdev->dpy; | |
397 | struct vfio_device_gfx_plane_info plane = { | |
398 | .argsz = sizeof(plane), | |
399 | .flags = VFIO_GFX_PLANE_TYPE_REGION | |
400 | }; | |
401 | pixman_format_code_t format; | |
402 | int ret; | |
403 | ||
404 | ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &plane); | |
405 | if (ret < 0) { | |
406 | error_report("ioctl VFIO_DEVICE_QUERY_GFX_PLANE: %s", | |
407 | strerror(errno)); | |
408 | return; | |
409 | } | |
410 | if (!plane.drm_format || !plane.size) { | |
b290659f GH |
411 | if (dpy->ramfb) { |
412 | ramfb_display_update(dpy->con, dpy->ramfb); | |
8ec14159 | 413 | dpy->region.surface = NULL; |
b290659f | 414 | } |
00195ba7 GH |
415 | return; |
416 | } | |
417 | format = qemu_drm_format_to_pixman(plane.drm_format); | |
418 | if (!format) { | |
419 | return; | |
420 | } | |
421 | ||
422 | if (dpy->region.buffer.size && | |
423 | dpy->region.buffer.nr != plane.region_index) { | |
424 | /* region changed */ | |
425 | vfio_region_exit(&dpy->region.buffer); | |
426 | vfio_region_finalize(&dpy->region.buffer); | |
427 | dpy->region.surface = NULL; | |
428 | } | |
429 | ||
430 | if (dpy->region.surface && | |
431 | (surface_width(dpy->region.surface) != plane.width || | |
432 | surface_height(dpy->region.surface) != plane.height || | |
433 | surface_format(dpy->region.surface) != format)) { | |
434 | /* size changed */ | |
435 | dpy->region.surface = NULL; | |
436 | } | |
437 | ||
438 | if (!dpy->region.buffer.size) { | |
439 | /* mmap region */ | |
440 | ret = vfio_region_setup(OBJECT(vdev), &vdev->vbasedev, | |
441 | &dpy->region.buffer, | |
442 | plane.region_index, | |
443 | "display"); | |
444 | if (ret != 0) { | |
445 | error_report("%s: vfio_region_setup(%d): %s", | |
446 | __func__, plane.region_index, strerror(-ret)); | |
447 | goto err; | |
448 | } | |
449 | ret = vfio_region_mmap(&dpy->region.buffer); | |
450 | if (ret != 0) { | |
451 | error_report("%s: vfio_region_mmap(%d): %s", __func__, | |
452 | plane.region_index, strerror(-ret)); | |
453 | goto err; | |
454 | } | |
455 | assert(dpy->region.buffer.mmaps[0].mmap != NULL); | |
456 | } | |
457 | ||
458 | if (dpy->region.surface == NULL) { | |
459 | /* create surface */ | |
460 | dpy->region.surface = qemu_create_displaysurface_from | |
461 | (plane.width, plane.height, format, | |
462 | plane.stride, dpy->region.buffer.mmaps[0].mmap); | |
463 | dpy_gfx_replace_surface(dpy->con, dpy->region.surface); | |
464 | } | |
465 | ||
466 | /* full screen update */ | |
467 | dpy_gfx_update(dpy->con, 0, 0, | |
468 | surface_width(dpy->region.surface), | |
469 | surface_height(dpy->region.surface)); | |
470 | return; | |
471 | ||
472 | err: | |
473 | vfio_region_exit(&dpy->region.buffer); | |
474 | vfio_region_finalize(&dpy->region.buffer); | |
475 | } | |
476 | ||
477 | static const GraphicHwOps vfio_display_region_ops = { | |
478 | .gfx_update = vfio_display_region_update, | |
479 | }; | |
480 | ||
481 | static int vfio_display_region_init(VFIOPCIDevice *vdev, Error **errp) | |
482 | { | |
483 | vdev->dpy = g_new0(VFIODisplay, 1); | |
484 | vdev->dpy->con = graphic_console_init(DEVICE(vdev), 0, | |
485 | &vfio_display_region_ops, | |
486 | vdev); | |
b290659f | 487 | if (vdev->enable_ramfb) { |
2fc979cb | 488 | vdev->dpy->ramfb = ramfb_setup(errp); |
b290659f | 489 | } |
00195ba7 GH |
490 | return 0; |
491 | } | |
492 | ||
493 | static void vfio_display_region_exit(VFIODisplay *dpy) | |
494 | { | |
495 | if (!dpy->region.buffer.size) { | |
496 | return; | |
497 | } | |
498 | ||
499 | vfio_region_exit(&dpy->region.buffer); | |
500 | vfio_region_finalize(&dpy->region.buffer); | |
501 | } | |
502 | ||
503 | /* ---------------------------------------------------------------------- */ | |
504 | ||
a9994687 GH |
505 | int vfio_display_probe(VFIOPCIDevice *vdev, Error **errp) |
506 | { | |
507 | struct vfio_device_gfx_plane_info probe; | |
508 | int ret; | |
509 | ||
510 | memset(&probe, 0, sizeof(probe)); | |
511 | probe.argsz = sizeof(probe); | |
512 | probe.flags = VFIO_GFX_PLANE_TYPE_PROBE | VFIO_GFX_PLANE_TYPE_DMABUF; | |
513 | ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &probe); | |
514 | if (ret == 0) { | |
8b818e05 | 515 | return vfio_display_dmabuf_init(vdev, errp); |
a9994687 GH |
516 | } |
517 | ||
518 | memset(&probe, 0, sizeof(probe)); | |
519 | probe.argsz = sizeof(probe); | |
520 | probe.flags = VFIO_GFX_PLANE_TYPE_PROBE | VFIO_GFX_PLANE_TYPE_REGION; | |
521 | ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &probe); | |
522 | if (ret == 0) { | |
00195ba7 | 523 | return vfio_display_region_init(vdev, errp); |
a9994687 GH |
524 | } |
525 | ||
526 | if (vdev->display == ON_OFF_AUTO_AUTO) { | |
527 | /* not an error in automatic mode */ | |
528 | return 0; | |
529 | } | |
530 | ||
531 | error_setg(errp, "vfio: device doesn't support any (known) display method"); | |
532 | return -1; | |
533 | } | |
534 | ||
535 | void vfio_display_finalize(VFIOPCIDevice *vdev) | |
536 | { | |
00195ba7 GH |
537 | if (!vdev->dpy) { |
538 | return; | |
539 | } | |
540 | ||
541 | graphic_console_close(vdev->dpy->con); | |
8b818e05 | 542 | vfio_display_dmabuf_exit(vdev->dpy); |
00195ba7 | 543 | vfio_display_region_exit(vdev->dpy); |
08479114 | 544 | vfio_display_edid_exit(vdev->dpy); |
00195ba7 | 545 | g_free(vdev->dpy); |
a9994687 | 546 | } |
87417811 MAL |
547 | |
548 | static bool migrate_needed(void *opaque) | |
549 | { | |
550 | VFIODisplay *dpy = opaque; | |
551 | bool ramfb_exists = dpy->ramfb != NULL; | |
552 | ||
553 | /* see vfio_display_migration_needed() */ | |
554 | assert(ramfb_exists); | |
555 | return ramfb_exists; | |
556 | } | |
557 | ||
558 | const VMStateDescription vfio_display_vmstate = { | |
559 | .name = "VFIODisplay", | |
560 | .version_id = 1, | |
561 | .minimum_version_id = 1, | |
562 | .needed = migrate_needed, | |
65bd53e8 | 563 | .fields = (const VMStateField[]) { |
87417811 MAL |
564 | VMSTATE_STRUCT_POINTER(ramfb, VFIODisplay, ramfb_vmstate, RAMFBState), |
565 | VMSTATE_END_OF_LIST(), | |
566 | } | |
567 | }; |