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