hw/vfio/display.c

   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
  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
  27 static 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
  42 static 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             /* found in list, move to head, return it */
  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
  94 static 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
 102 static 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
 118 static 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
 172 static const GraphicHwOps vfio_display_dmabuf_ops = {
 173     .gfx_update = vfio_display_dmabuf_update,
 174 };
 175
 176 static 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
 193 static 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 /* ---------------------------------------------------------------------- */
 207 void 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
 219 static 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         /* region changed */
 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         /* size changed */
 260         dpy->region.surface = NULL;
 261     }
 262
 263     if (!dpy->region.buffer.size) {
 264         /* mmap region */
 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         /* create surface */
 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     /* full screen update */
 292     dpy_gfx_update(dpy->con, 0, 0,
 293                    surface_width(dpy->region.surface),
 294                    surface_height(dpy->region.surface));
 295     return;
 296
 297 err:
 298     vfio_region_exit(&dpy->region.buffer);
 299     vfio_region_finalize(&dpy->region.buffer);
 300 }
 301
 302 static const GraphicHwOps vfio_display_region_ops = {
 303     .gfx_update = vfio_display_region_update,
 304 };
 305
 306 static 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
 318 static 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
 330 int 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         /* not an error in automatic mode */
 353         return 0;
 354     }
 355
 356     error_setg(errp, "vfio: device doesn't support any (known) display method");
 357     return -1;
 358 }
 359
 360 void 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 }