1
2
3
4
5
6
7
8
9
10
11
12
13#include "qemu/osdep.h"
14#include <linux/vfio.h>
15#include <sys/ioctl.h>
16
17#include "sysemu/sysemu.h"
18#include "ui/console.h"
19#include "qapi/error.h"
20#include "pci.h"
21
22#ifndef DRM_PLANE_TYPE_PRIMARY
23# define DRM_PLANE_TYPE_PRIMARY 1
24# define DRM_PLANE_TYPE_CURSOR 2
25#endif
26
27static void vfio_display_update_cursor(VFIODMABuf *dmabuf,
28 struct vfio_device_gfx_plane_info *plane)
29{
30 if (dmabuf->pos_x != plane->x_pos || dmabuf->pos_y != plane->y_pos) {
31 dmabuf->pos_x = plane->x_pos;
32 dmabuf->pos_y = plane->y_pos;
33 dmabuf->pos_updates++;
34 }
35 if (dmabuf->hot_x != plane->x_hot || dmabuf->hot_y != plane->y_hot) {
36 dmabuf->hot_x = plane->x_hot;
37 dmabuf->hot_y = plane->y_hot;
38 dmabuf->hot_updates++;
39 }
40}
41
42static VFIODMABuf *vfio_display_get_dmabuf(VFIOPCIDevice *vdev,
43 uint32_t plane_type)
44{
45 VFIODisplay *dpy = vdev->dpy;
46 struct vfio_device_gfx_plane_info plane;
47 VFIODMABuf *dmabuf;
48 int fd, ret;
49
50 memset(&plane, 0, sizeof(plane));
51 plane.argsz = sizeof(plane);
52 plane.flags = VFIO_GFX_PLANE_TYPE_DMABUF;
53 plane.drm_plane_type = plane_type;
54 ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &plane);
55 if (ret < 0) {
56 return NULL;
57 }
58 if (!plane.drm_format || !plane.size) {
59 return NULL;
60 }
61
62 QTAILQ_FOREACH(dmabuf, &dpy->dmabuf.bufs, next) {
63 if (dmabuf->dmabuf_id == plane.dmabuf_id) {
64
65 QTAILQ_REMOVE(&dpy->dmabuf.bufs, dmabuf, next);
66 QTAILQ_INSERT_HEAD(&dpy->dmabuf.bufs, dmabuf, next);
67 if (plane_type == DRM_PLANE_TYPE_CURSOR) {
68 vfio_display_update_cursor(dmabuf, &plane);
69 }
70 return dmabuf;
71 }
72 }
73
74 fd = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_GET_GFX_DMABUF, &plane.dmabuf_id);
75 if (fd < 0) {
76 return NULL;
77 }
78
79 dmabuf = g_new0(VFIODMABuf, 1);
80 dmabuf->dmabuf_id = plane.dmabuf_id;
81 dmabuf->buf.width = plane.width;
82 dmabuf->buf.height = plane.height;
83 dmabuf->buf.stride = plane.stride;
84 dmabuf->buf.fourcc = plane.drm_format;
85 dmabuf->buf.fd = fd;
86 if (plane_type == DRM_PLANE_TYPE_CURSOR) {
87 vfio_display_update_cursor(dmabuf, &plane);
88 }
89
90 QTAILQ_INSERT_HEAD(&dpy->dmabuf.bufs, dmabuf, next);
91 return dmabuf;
92}
93
94static void vfio_display_free_one_dmabuf(VFIODisplay *dpy, VFIODMABuf *dmabuf)
95{
96 QTAILQ_REMOVE(&dpy->dmabuf.bufs, dmabuf, next);
97 dpy_gl_release_dmabuf(dpy->con, &dmabuf->buf);
98 close(dmabuf->buf.fd);
99 g_free(dmabuf);
100}
101
102static void vfio_display_free_dmabufs(VFIOPCIDevice *vdev)
103{
104 VFIODisplay *dpy = vdev->dpy;
105 VFIODMABuf *dmabuf, *tmp;
106 uint32_t keep = 5;
107
108 QTAILQ_FOREACH_SAFE(dmabuf, &dpy->dmabuf.bufs, next, tmp) {
109 if (keep > 0) {
110 keep--;
111 continue;
112 }
113 assert(dmabuf != dpy->dmabuf.primary);
114 vfio_display_free_one_dmabuf(dpy, dmabuf);
115 }
116}
117
118static void vfio_display_dmabuf_update(void *opaque)
119{
120 VFIOPCIDevice *vdev = opaque;
121 VFIODisplay *dpy = vdev->dpy;
122 VFIODMABuf *primary, *cursor;
123 bool free_bufs = false, new_cursor = false;;
124
125 primary = vfio_display_get_dmabuf(vdev, DRM_PLANE_TYPE_PRIMARY);
126 if (primary == NULL) {
127 if (dpy->ramfb) {
128 ramfb_display_update(dpy->con, dpy->ramfb);
129 }
130 return;
131 }
132
133 if (dpy->dmabuf.primary != primary) {
134 dpy->dmabuf.primary = primary;
135 qemu_console_resize(dpy->con,
136 primary->buf.width, primary->buf.height);
137 dpy_gl_scanout_dmabuf(dpy->con, &primary->buf);
138 free_bufs = true;
139 }
140
141 cursor = vfio_display_get_dmabuf(vdev, DRM_PLANE_TYPE_CURSOR);
142 if (dpy->dmabuf.cursor != cursor) {
143 dpy->dmabuf.cursor = cursor;
144 new_cursor = true;
145 free_bufs = true;
146 }
147
148 if (cursor && (new_cursor || cursor->hot_updates)) {
149 bool have_hot = (cursor->hot_x != 0xffffffff &&
150 cursor->hot_y != 0xffffffff);
151 dpy_gl_cursor_dmabuf(dpy->con, &cursor->buf, have_hot,
152 cursor->hot_x, cursor->hot_y);
153 cursor->hot_updates = 0;
154 } else if (!cursor && new_cursor) {
155 dpy_gl_cursor_dmabuf(dpy->con, NULL, false, 0, 0);
156 }
157
158 if (cursor && cursor->pos_updates) {
159 dpy_gl_cursor_position(dpy->con,
160 cursor->pos_x,
161 cursor->pos_y);
162 cursor->pos_updates = 0;
163 }
164
165 dpy_gl_update(dpy->con, 0, 0, primary->buf.width, primary->buf.height);
166
167 if (free_bufs) {
168 vfio_display_free_dmabufs(vdev);
169 }
170}
171
172static const GraphicHwOps vfio_display_dmabuf_ops = {
173 .gfx_update = vfio_display_dmabuf_update,
174};
175
176static int vfio_display_dmabuf_init(VFIOPCIDevice *vdev, Error **errp)
177{
178 if (!display_opengl) {
179 error_setg(errp, "vfio-display-dmabuf: opengl not available");
180 return -1;
181 }
182
183 vdev->dpy = g_new0(VFIODisplay, 1);
184 vdev->dpy->con = graphic_console_init(DEVICE(vdev), 0,
185 &vfio_display_dmabuf_ops,
186 vdev);
187 if (vdev->enable_ramfb) {
188 vdev->dpy->ramfb = ramfb_setup(errp);
189 }
190 return 0;
191}
192
193static void vfio_display_dmabuf_exit(VFIODisplay *dpy)
194{
195 VFIODMABuf *dmabuf;
196
197 if (QTAILQ_EMPTY(&dpy->dmabuf.bufs)) {
198 return;
199 }
200
201 while ((dmabuf = QTAILQ_FIRST(&dpy->dmabuf.bufs)) != NULL) {
202 vfio_display_free_one_dmabuf(dpy, dmabuf);
203 }
204}
205
206
207void vfio_display_reset(VFIOPCIDevice *vdev)
208{
209 if (!vdev || !vdev->dpy || !vdev->dpy->con ||
210 !vdev->dpy->dmabuf.primary) {
211 return;
212 }
213
214 dpy_gl_scanout_disable(vdev->dpy->con);
215 vfio_display_dmabuf_exit(vdev->dpy);
216 dpy_gfx_update_full(vdev->dpy->con);
217}
218
219static void vfio_display_region_update(void *opaque)
220{
221 VFIOPCIDevice *vdev = opaque;
222 VFIODisplay *dpy = vdev->dpy;
223 struct vfio_device_gfx_plane_info plane = {
224 .argsz = sizeof(plane),
225 .flags = VFIO_GFX_PLANE_TYPE_REGION
226 };
227 pixman_format_code_t format;
228 int ret;
229
230 ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &plane);
231 if (ret < 0) {
232 error_report("ioctl VFIO_DEVICE_QUERY_GFX_PLANE: %s",
233 strerror(errno));
234 return;
235 }
236 if (!plane.drm_format || !plane.size) {
237 if (dpy->ramfb) {
238 ramfb_display_update(dpy->con, dpy->ramfb);
239 }
240 return;
241 }
242 format = qemu_drm_format_to_pixman(plane.drm_format);
243 if (!format) {
244 return;
245 }
246
247 if (dpy->region.buffer.size &&
248 dpy->region.buffer.nr != plane.region_index) {
249
250 vfio_region_exit(&dpy->region.buffer);
251 vfio_region_finalize(&dpy->region.buffer);
252 dpy->region.surface = NULL;
253 }
254
255 if (dpy->region.surface &&
256 (surface_width(dpy->region.surface) != plane.width ||
257 surface_height(dpy->region.surface) != plane.height ||
258 surface_format(dpy->region.surface) != format)) {
259
260 dpy->region.surface = NULL;
261 }
262
263 if (!dpy->region.buffer.size) {
264
265 ret = vfio_region_setup(OBJECT(vdev), &vdev->vbasedev,
266 &dpy->region.buffer,
267 plane.region_index,
268 "display");
269 if (ret != 0) {
270 error_report("%s: vfio_region_setup(%d): %s",
271 __func__, plane.region_index, strerror(-ret));
272 goto err;
273 }
274 ret = vfio_region_mmap(&dpy->region.buffer);
275 if (ret != 0) {
276 error_report("%s: vfio_region_mmap(%d): %s", __func__,
277 plane.region_index, strerror(-ret));
278 goto err;
279 }
280 assert(dpy->region.buffer.mmaps[0].mmap != NULL);
281 }
282
283 if (dpy->region.surface == NULL) {
284
285 dpy->region.surface = qemu_create_displaysurface_from
286 (plane.width, plane.height, format,
287 plane.stride, dpy->region.buffer.mmaps[0].mmap);
288 dpy_gfx_replace_surface(dpy->con, dpy->region.surface);
289 }
290
291
292 dpy_gfx_update(dpy->con, 0, 0,
293 surface_width(dpy->region.surface),
294 surface_height(dpy->region.surface));
295 return;
296
297err:
298 vfio_region_exit(&dpy->region.buffer);
299 vfio_region_finalize(&dpy->region.buffer);
300}
301
302static const GraphicHwOps vfio_display_region_ops = {
303 .gfx_update = vfio_display_region_update,
304};
305
306static int vfio_display_region_init(VFIOPCIDevice *vdev, Error **errp)
307{
308 vdev->dpy = g_new0(VFIODisplay, 1);
309 vdev->dpy->con = graphic_console_init(DEVICE(vdev), 0,
310 &vfio_display_region_ops,
311 vdev);
312 if (vdev->enable_ramfb) {
313 vdev->dpy->ramfb = ramfb_setup(errp);
314 }
315 return 0;
316}
317
318static void vfio_display_region_exit(VFIODisplay *dpy)
319{
320 if (!dpy->region.buffer.size) {
321 return;
322 }
323
324 vfio_region_exit(&dpy->region.buffer);
325 vfio_region_finalize(&dpy->region.buffer);
326}
327
328
329
330int vfio_display_probe(VFIOPCIDevice *vdev, Error **errp)
331{
332 struct vfio_device_gfx_plane_info probe;
333 int ret;
334
335 memset(&probe, 0, sizeof(probe));
336 probe.argsz = sizeof(probe);
337 probe.flags = VFIO_GFX_PLANE_TYPE_PROBE | VFIO_GFX_PLANE_TYPE_DMABUF;
338 ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &probe);
339 if (ret == 0) {
340 return vfio_display_dmabuf_init(vdev, errp);
341 }
342
343 memset(&probe, 0, sizeof(probe));
344 probe.argsz = sizeof(probe);
345 probe.flags = VFIO_GFX_PLANE_TYPE_PROBE | VFIO_GFX_PLANE_TYPE_REGION;
346 ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_QUERY_GFX_PLANE, &probe);
347 if (ret == 0) {
348 return vfio_display_region_init(vdev, errp);
349 }
350
351 if (vdev->display == ON_OFF_AUTO_AUTO) {
352
353 return 0;
354 }
355
356 error_setg(errp, "vfio: device doesn't support any (known) display method");
357 return -1;
358}
359
360void vfio_display_finalize(VFIOPCIDevice *vdev)
361{
362 if (!vdev->dpy) {
363 return;
364 }
365
366 graphic_console_close(vdev->dpy->con);
367 vfio_display_dmabuf_exit(vdev->dpy);
368 vfio_display_region_exit(vdev->dpy);
369 g_free(vdev->dpy);
370}
371
