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