src/gbm/backends/dri/gbm_dri.c

   1 /*
   2  * Copyright © 2011 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  19  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  20  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Benjamin Franzke <benjaminfranzke@googlemail.com>
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <stddef.h>
  31 #include <stdint.h>
  32 #include <string.h>
  33 #include <limits.h>
  34
  35 #include <sys/types.h>
  36 #include <sys/mman.h>
  37 #include <unistd.h>
  38 #include <dlfcn.h>
  39 #include <xf86drm.h>
  40
  41 #include <GL/gl.h> /* dri_interface needs GL types */
  42 #include <GL/internal/dri_interface.h>
  43
  44 #include "gbm_driint.h"
  45
  46 #include "gbmint.h"
  47
  48 /* For importing wl_buffer */
  49 #if HAVE_WAYLAND_PLATFORM
  50 #include "../../../egl/wayland/wayland-drm/wayland-drm.h"
  51 #endif
  52
  53 static __DRIimage *
  54 dri_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
  55 {
  56    struct gbm_dri_device *dri = data;
  57
  58    if (dri->lookup_image == NULL)
  59       return NULL;
  60
  61    return dri->lookup_image(screen, image, dri->lookup_user_data);
  62 }
  63
  64 static __DRIbuffer *
  65 dri_get_buffers(__DRIdrawable * driDrawable,
  66                  int *width, int *height,
  67                  unsigned int *attachments, int count,
  68                  int *out_count, void *data)
  69 {
  70    struct gbm_dri_surface *surf = data;
  71    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
  72
  73    if (dri->get_buffers == NULL)
  74       return NULL;
  75
  76    return dri->get_buffers(driDrawable, width, height, attachments,
  77                            count, out_count, surf->dri_private);
  78 }
  79
  80 static void
  81 dri_flush_front_buffer(__DRIdrawable * driDrawable, void *data)
  82 {
  83    struct gbm_dri_surface *surf = data;
  84    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
  85
  86    if (dri->flush_front_buffer != NULL)
  87       dri->flush_front_buffer(driDrawable, surf->dri_private);
  88 }
  89
  90 static __DRIbuffer *
  91 dri_get_buffers_with_format(__DRIdrawable * driDrawable,
  92                             int *width, int *height,
  93                             unsigned int *attachments, int count,
  94                             int *out_count, void *data)
  95 {
  96    struct gbm_dri_surface *surf = data;
  97    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
  98
  99    if (dri->get_buffers_with_format == NULL)
 100       return NULL;
 101
 102    return
 103       dri->get_buffers_with_format(driDrawable, width, height, attachments,
 104                                    count, out_count, surf->dri_private);
 105 }
 106
 107 static const __DRIuseInvalidateExtension use_invalidate = {
 108    { __DRI_USE_INVALIDATE, 1 }
 109 };
 110
 111 static const __DRIimageLookupExtension image_lookup_extension = {
 112    { __DRI_IMAGE_LOOKUP, 1 },
 113    dri_lookup_egl_image
 114 };
 115
 116 const __DRIdri2LoaderExtension dri2_loader_extension = {
 117    { __DRI_DRI2_LOADER, 3 },
 118    dri_get_buffers,
 119    dri_flush_front_buffer,
 120    dri_get_buffers_with_format,
 121 };
 122
 123 struct dri_extension_match {
 124    const char *name;
 125    int version;
 126    int offset;
 127 };
 128
 129 static struct dri_extension_match dri_core_extensions[] = {
 130    { __DRI2_FLUSH, 1, offsetof(struct gbm_dri_device, flush) },
 131    { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) },
 132    { NULL, 0, 0 }
 133 };
 134
 135 static struct dri_extension_match gbm_dri_device_extensions[] = {
 136    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) },
 137    { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) },
 138    { NULL, 0, 0 }
 139 };
 140
 141 static int
 142 dri_bind_extensions(struct gbm_dri_device *dri,
 143                     struct dri_extension_match *matches,
 144                     const __DRIextension **extensions)
 145 {
 146    int i, j, ret = 0;
 147    void *field;
 148
 149    for (i = 0; extensions[i]; i++) {
 150       for (j = 0; matches[j].name; j++) {
 151          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
 152              extensions[i]->version >= matches[j].version) {
 153             field = ((char *) dri + matches[j].offset);
 154             *(const __DRIextension **) field = extensions[i];
 155          }
 156       }
 157    }
 158
 159    for (j = 0; matches[j].name; j++) {
 160       field = ((char *) dri + matches[j].offset);
 161       if (*(const __DRIextension **) field == NULL) {
 162          ret = -1;
 163       }
 164    }
 165
 166    return ret;
 167 }
 168
 169 static int
 170 dri_load_driver(struct gbm_dri_device *dri)
 171 {
 172    const __DRIextension **extensions;
 173    char path[PATH_MAX], *search_paths, *p, *next, *end;
 174
 175    search_paths = NULL;
 176    if (geteuid() == getuid()) {
 177       /* don't allow setuid apps to use GBM_DRIVERS_PATH */
 178       search_paths = getenv("GBM_DRIVERS_PATH");
 179    }
 180    if (search_paths == NULL)
 181       search_paths = DEFAULT_DRIVER_DIR;
 182
 183    dri->driver = NULL;
 184    end = search_paths + strlen(search_paths);
 185    for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) {
 186       int len;
 187       next = strchr(p, ':');
 188       if (next == NULL)
 189          next = end;
 190
 191       len = next - p;
 192 #if GLX_USE_TLS
 193       snprintf(path, sizeof path,
 194                "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name);
 195       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 196 #endif
 197       if (dri->driver == NULL) {
 198          snprintf(path, sizeof path,
 199                   "%.*s/%s_dri.so", len, p, dri->base.driver_name);
 200          dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 201          if (dri->driver == NULL)
 202             fprintf(stderr, "failed to open %s: %s\n", path, dlerror());
 203       }
 204    }
 205
 206    if (dri->driver == NULL) {
 207       fprintf(stderr, "gbm: failed to open any driver (search paths %s)",
 208               search_paths);
 209       return -1;
 210    }
 211
 212    extensions = dlsym(dri->driver, __DRI_DRIVER_EXTENSIONS);
 213    if (extensions == NULL) {
 214       fprintf(stderr, "gbm: driver exports no extensions (%s)", dlerror());
 215       dlclose(dri->driver);
 216       return -1;
 217    }
 218
 219
 220    if (dri_bind_extensions(dri, gbm_dri_device_extensions, extensions) < 0) {
 221       dlclose(dri->driver);
 222       fprintf(stderr, "failed to bind extensions\n");
 223       return -1;
 224    }
 225
 226    return 0;
 227 }
 228
 229 static int
 230 dri_screen_create(struct gbm_dri_device *dri)
 231 {
 232    const __DRIextension **extensions;
 233    int ret = 0;
 234
 235    dri->base.driver_name = dri_fd_get_driver_name(dri->base.base.fd);
 236    if (dri->base.driver_name == NULL)
 237       return -1;
 238
 239    ret = dri_load_driver(dri);
 240    if (ret) {
 241       fprintf(stderr, "failed to load driver: %s\n", dri->base.driver_name);
 242       return ret;
 243    };
 244
 245    dri->extensions[0] = &image_lookup_extension.base;
 246    dri->extensions[1] = &use_invalidate.base;
 247    dri->extensions[2] = &dri2_loader_extension.base;
 248    dri->extensions[3] = NULL;
 249
 250    if (dri->dri2 == NULL)
 251       return -1;
 252
 253    dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd,
 254                                             dri->extensions,
 255                                             &dri->driver_configs, dri);
 256    if (dri->screen == NULL)
 257       return -1;
 258
 259    extensions = dri->core->getExtensions(dri->screen);
 260    if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) {
 261       ret = -1;
 262       goto free_screen;
 263    }
 264
 265    dri->lookup_image = NULL;
 266    dri->lookup_user_data = NULL;
 267
 268    return 0;
 269
 270 free_screen:
 271    dri->core->destroyScreen(dri->screen);
 272
 273    return ret;
 274 }
 275
 276 static int
 277 gbm_dri_is_format_supported(struct gbm_device *gbm,
 278                             uint32_t format,
 279                             uint32_t usage)
 280 {
 281    switch (format) {
 282    case GBM_BO_FORMAT_XRGB8888:
 283    case GBM_FORMAT_XRGB8888:
 284       break;
 285    case GBM_BO_FORMAT_ARGB8888:
 286    case GBM_FORMAT_ARGB8888:
 287       if (usage & GBM_BO_USE_SCANOUT)
 288          return 0;
 289       break;
 290    default:
 291       return 0;
 292    }
 293
 294    if (usage & GBM_BO_USE_CURSOR_64X64 &&
 295        usage & GBM_BO_USE_RENDERING)
 296       return 0;
 297
 298    return 1;
 299 }
 300
 301 static int
 302 gbm_dri_bo_write(struct gbm_bo *_bo, const void *buf, size_t count)
 303 {
 304    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 305
 306    if (bo->image != NULL)
 307       return -1;
 308
 309    memcpy(bo->map, buf, count);
 310
 311    return 0;
 312 }
 313
 314 static void
 315 gbm_dri_bo_destroy(struct gbm_bo *_bo)
 316 {
 317    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 318    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 319    struct drm_mode_destroy_dumb arg;
 320
 321    if (bo->image != NULL) {
 322       dri->image->destroyImage(bo->image);
 323    } else {
 324       munmap(bo->map, bo->size);
 325       memset(&arg, 0, sizeof(arg));
 326       arg.handle = bo->handle;
 327       drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
 328    }
 329
 330    free(bo);
 331 }
 332
 333 static uint32_t
 334 gbm_dri_to_gbm_format(uint32_t dri_format)
 335 {
 336    uint32_t ret = 0;
 337
 338    switch (dri_format) {
 339    case __DRI_IMAGE_FORMAT_RGB565:
 340       ret = GBM_FORMAT_RGB565;
 341       break;
 342    case __DRI_IMAGE_FORMAT_XRGB8888:
 343       ret = GBM_FORMAT_XRGB8888;
 344       break;
 345    case __DRI_IMAGE_FORMAT_ARGB8888:
 346       ret = GBM_FORMAT_ARGB8888;
 347       break;
 348    case __DRI_IMAGE_FORMAT_ABGR8888:
 349       ret = GBM_FORMAT_ABGR8888;
 350       break;
 351    default:
 352       ret = 0;
 353       break;
 354    }
 355
 356    return ret;
 357 }
 358
 359 static struct gbm_bo *
 360 gbm_dri_bo_import(struct gbm_device *gbm,
 361                   uint32_t type, void *buffer, uint32_t usage)
 362 {
 363    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 364    struct gbm_dri_bo *bo;
 365    __DRIimage *image;
 366    unsigned dri_use = 0;
 367    int gbm_format;
 368
 369    /* Required for query image WIDTH & HEIGHT */
 370    if (dri->image->base.version < 4)
 371       return NULL;
 372
 373    switch (type) {
 374 #if HAVE_WAYLAND_PLATFORM
 375    case GBM_BO_IMPORT_WL_BUFFER:
 376    {
 377       struct wl_drm_buffer *wb;
 378
 379       if (!dri->wl_drm)
 380          return NULL;
 381
 382       wb = wayland_drm_buffer_get(dri->wl_drm, (struct wl_resource *) buffer);
 383       if (!wb)
 384          return NULL;
 385
 386       image = wb->driver_buffer;
 387
 388       switch (wb->format) {
 389       case WL_DRM_FORMAT_XRGB8888:
 390          gbm_format = GBM_FORMAT_XRGB8888;
 391          break;
 392       case WL_DRM_FORMAT_ARGB8888:
 393          gbm_format = GBM_FORMAT_ARGB8888;
 394          break;
 395       case WL_DRM_FORMAT_RGB565:
 396          gbm_format = GBM_FORMAT_RGB565;
 397          break;
 398       case WL_DRM_FORMAT_YUYV:
 399          gbm_format = GBM_FORMAT_YUYV;
 400          break;
 401       default:
 402          return NULL;
 403       }
 404       break;
 405    }
 406 #endif
 407
 408    case GBM_BO_IMPORT_EGL_IMAGE:
 409    {
 410       int dri_format;
 411       if (dri->lookup_image == NULL)
 412          return NULL;
 413
 414       image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data);
 415       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format);
 416       gbm_format = gbm_dri_to_gbm_format(dri_format);
 417       if (gbm_format == 0)
 418          return NULL;
 419       break;
 420    }
 421
 422    default:
 423       return NULL;
 424    }
 425
 426
 427    bo = calloc(1, sizeof *bo);
 428    if (bo == NULL)
 429       return NULL;
 430
 431    bo->image = dri->image->dupImage(image, NULL);
 432
 433    if (usage & GBM_BO_USE_SCANOUT)
 434       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 435    if (usage & GBM_BO_USE_CURSOR_64X64)
 436       dri_use |= __DRI_IMAGE_USE_CURSOR;
 437    if (dri->image->base.version >= 2 &&
 438        !dri->image->validateUsage(bo->image, dri_use)) {
 439       free(bo);
 440       return NULL;
 441    }
 442
 443    bo->base.base.gbm = gbm;
 444    bo->base.base.format = gbm_format;
 445
 446    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH,
 447                           (int*)&bo->base.base.width);
 448    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT,
 449                           (int*)&bo->base.base.height);
 450    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 451                           (int*)&bo->base.base.stride);
 452    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 453                           &bo->base.base.handle.s32);
 454
 455    return &bo->base.base;
 456 }
 457
 458 static struct gbm_bo *
 459 create_dumb(struct gbm_device *gbm,
 460                   uint32_t width, uint32_t height,
 461                   uint32_t format, uint32_t usage)
 462 {
 463    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 464    struct drm_mode_create_dumb create_arg;
 465    struct drm_mode_map_dumb map_arg;
 466    struct gbm_dri_bo *bo;
 467    struct drm_mode_destroy_dumb destroy_arg;
 468    int ret;
 469
 470    if (!(usage & GBM_BO_USE_CURSOR_64X64))
 471       return NULL;
 472    if (format != GBM_FORMAT_ARGB8888)
 473       return NULL;
 474
 475    bo = calloc(1, sizeof *bo);
 476    if (bo == NULL)
 477       return NULL;
 478
 479    create_arg.bpp = 32;
 480    create_arg.width = width;
 481    create_arg.height = height;
 482
 483    ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
 484    if (ret)
 485       goto free_bo;
 486
 487    bo->base.base.gbm = gbm;
 488    bo->base.base.width = width;
 489    bo->base.base.height = height;
 490    bo->base.base.stride = create_arg.pitch;
 491    bo->base.base.format = format;
 492    bo->base.base.handle.u32 = create_arg.handle;
 493    bo->handle = create_arg.handle;
 494    bo->size = create_arg.size;
 495
 496    memset(&map_arg, 0, sizeof(map_arg));
 497    map_arg.handle = bo->handle;
 498
 499    ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_MAP_DUMB, &map_arg);
 500    if (ret)
 501       goto destroy_dumb;
 502
 503    bo->map = mmap(0, bo->size, PROT_WRITE,
 504                   MAP_SHARED, dri->base.base.fd, map_arg.offset);
 505    if (bo->map == MAP_FAILED)
 506       goto destroy_dumb;
 507
 508    return &bo->base.base;
 509
 510 destroy_dumb:
 511    memset(&destroy_arg, 0, sizeof destroy_arg);
 512    destroy_arg.handle = create_arg.handle;
 513    drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
 514 free_bo:
 515    free(bo);
 516
 517    return NULL;
 518 }
 519
 520 static struct gbm_bo *
 521 gbm_dri_bo_create(struct gbm_device *gbm,
 522                   uint32_t width, uint32_t height,
 523                   uint32_t format, uint32_t usage)
 524 {
 525    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 526    struct gbm_dri_bo *bo;
 527    int dri_format;
 528    unsigned dri_use = 0;
 529
 530    if (usage & GBM_BO_USE_WRITE)
 531       return create_dumb(gbm, width, height, format, usage);
 532
 533    bo = calloc(1, sizeof *bo);
 534    if (bo == NULL)
 535       return NULL;
 536
 537    bo->base.base.gbm = gbm;
 538    bo->base.base.width = width;
 539    bo->base.base.height = height;
 540    bo->base.base.format = format;
 541
 542    switch (format) {
 543    case GBM_FORMAT_RGB565:
 544       dri_format =__DRI_IMAGE_FORMAT_RGB565;
 545       break;
 546    case GBM_FORMAT_XRGB8888:
 547    case GBM_BO_FORMAT_XRGB8888:
 548       dri_format = __DRI_IMAGE_FORMAT_XRGB8888;
 549       break;
 550    case GBM_FORMAT_ARGB8888:
 551    case GBM_BO_FORMAT_ARGB8888:
 552       dri_format = __DRI_IMAGE_FORMAT_ARGB8888;
 553       break;
 554    case GBM_FORMAT_ABGR8888:
 555       dri_format = __DRI_IMAGE_FORMAT_ABGR8888;
 556       break;
 557    case GBM_FORMAT_ARGB2101010:
 558       dri_format = __DRI_IMAGE_FORMAT_ARGB2101010;
 559       break;
 560    case GBM_FORMAT_XRGB2101010:
 561       dri_format = __DRI_IMAGE_FORMAT_XRGB2101010;
 562       break;
 563    default:
 564       return NULL;
 565    }
 566
 567    if (usage & GBM_BO_USE_SCANOUT)
 568       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 569    if (usage & GBM_BO_USE_CURSOR_64X64)
 570       dri_use |= __DRI_IMAGE_USE_CURSOR;
 571
 572    /* Gallium drivers requires shared in order to get the handle/stride */
 573    dri_use |= __DRI_IMAGE_USE_SHARE;
 574
 575    bo->image =
 576       dri->image->createImage(dri->screen,
 577                               width, height,
 578                               dri_format, dri_use,
 579                               bo);
 580    if (bo->image == NULL)
 581       return NULL;
 582
 583    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 584                           &bo->base.base.handle.s32);
 585    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 586                           (int *) &bo->base.base.stride);
 587
 588    return &bo->base.base;
 589 }
 590
 591 static struct gbm_surface *
 592 gbm_dri_surface_create(struct gbm_device *gbm,
 593                        uint32_t width, uint32_t height,
 594                        uint32_t format, uint32_t flags)
 595 {
 596    struct gbm_dri_surface *surf;
 597
 598    surf = calloc(1, sizeof *surf);
 599    if (surf == NULL)
 600       return NULL;
 601
 602    surf->base.gbm = gbm;
 603    surf->base.width = width;
 604    surf->base.height = height;
 605    surf->base.format = format;
 606    surf->base.flags = flags;
 607
 608    return &surf->base;
 609 }
 610
 611 static void
 612 gbm_dri_surface_destroy(struct gbm_surface *_surf)
 613 {
 614    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
 615
 616    free(surf);
 617 }
 618
 619 static void
 620 dri_destroy(struct gbm_device *gbm)
 621 {
 622    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 623
 624    dri->core->destroyScreen(dri->screen);
 625    free(dri->driver_configs);
 626    dlclose(dri->driver);
 627    free(dri->base.driver_name);
 628
 629    free(dri);
 630 }
 631
 632 static struct gbm_device *
 633 dri_device_create(int fd)
 634 {
 635    struct gbm_dri_device *dri;
 636    int ret;
 637
 638    dri = calloc(1, sizeof *dri);
 639
 640    dri->base.base.fd = fd;
 641    dri->base.base.bo_create = gbm_dri_bo_create;
 642    dri->base.base.bo_import = gbm_dri_bo_import;
 643    dri->base.base.is_format_supported = gbm_dri_is_format_supported;
 644    dri->base.base.bo_write = gbm_dri_bo_write;
 645    dri->base.base.bo_destroy = gbm_dri_bo_destroy;
 646    dri->base.base.destroy = dri_destroy;
 647    dri->base.base.surface_create = gbm_dri_surface_create;
 648    dri->base.base.surface_destroy = gbm_dri_surface_destroy;
 649
 650    dri->base.type = GBM_DRM_DRIVER_TYPE_DRI;
 651    dri->base.base.name = "drm";
 652
 653    ret = dri_screen_create(dri);
 654    if (ret)
 655       goto err_dri;
 656
 657    return &dri->base.base;
 658
 659 err_dri:
 660    free(dri);
 661
 662    return NULL;
 663 }
 664
 665 struct gbm_backend gbm_dri_backend = {
 666    .backend_name = "dri",
 667    .create_device = dri_device_create,
 668 };