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 #include "loader.h"
  48
  49 /* For importing wl_buffer */
  50 #if HAVE_WAYLAND_PLATFORM
  51 #include "../../../egl/wayland/wayland-drm/wayland-drm.h"
  52 #endif
  53
  54 static __DRIimage *
  55 dri_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
  56 {
  57    struct gbm_dri_device *dri = data;
  58
  59    if (dri->lookup_image == NULL)
  60       return NULL;
  61
  62    return dri->lookup_image(screen, image, dri->lookup_user_data);
  63 }
  64
  65 static __DRIbuffer *
  66 dri_get_buffers(__DRIdrawable * driDrawable,
  67                  int *width, int *height,
  68                  unsigned int *attachments, int count,
  69                  int *out_count, void *data)
  70 {
  71    struct gbm_dri_surface *surf = data;
  72    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
  73
  74    if (dri->get_buffers == NULL)
  75       return NULL;
  76
  77    return dri->get_buffers(driDrawable, width, height, attachments,
  78                            count, out_count, surf->dri_private);
  79 }
  80
  81 static void
  82 dri_flush_front_buffer(__DRIdrawable * driDrawable, void *data)
  83 {
  84    struct gbm_dri_surface *surf = data;
  85    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
  86
  87    if (dri->flush_front_buffer != NULL)
  88       dri->flush_front_buffer(driDrawable, surf->dri_private);
  89 }
  90
  91 static __DRIbuffer *
  92 dri_get_buffers_with_format(__DRIdrawable * driDrawable,
  93                             int *width, int *height,
  94                             unsigned int *attachments, int count,
  95                             int *out_count, void *data)
  96 {
  97    struct gbm_dri_surface *surf = data;
  98    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
  99
 100    if (dri->get_buffers_with_format == NULL)
 101       return NULL;
 102
 103    return
 104       dri->get_buffers_with_format(driDrawable, width, height, attachments,
 105                                    count, out_count, surf->dri_private);
 106 }
 107
 108 static int
 109 image_get_buffers(__DRIdrawable *driDrawable,
 110                   unsigned int format,
 111                   uint32_t *stamp,
 112                   void *loaderPrivate,
 113                   uint32_t buffer_mask,
 114                   struct __DRIimageList *buffers)
 115 {
 116    struct gbm_dri_surface *surf = loaderPrivate;
 117    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 118
 119    if (dri->image_get_buffers == NULL)
 120       return 0;
 121
 122    return dri->image_get_buffers(driDrawable, format, stamp,
 123                                  surf->dri_private, buffer_mask, buffers);
 124 }
 125
 126 static const __DRIuseInvalidateExtension use_invalidate = {
 127    { __DRI_USE_INVALIDATE, 1 }
 128 };
 129
 130 static const __DRIimageLookupExtension image_lookup_extension = {
 131    { __DRI_IMAGE_LOOKUP, 1 },
 132    dri_lookup_egl_image
 133 };
 134
 135 static const __DRIdri2LoaderExtension dri2_loader_extension = {
 136    .base = { __DRI_DRI2_LOADER, 3 },
 137
 138    .getBuffers              = dri_get_buffers,
 139    .flushFrontBuffer        = dri_flush_front_buffer,
 140    .getBuffersWithFormat    = dri_get_buffers_with_format,
 141 };
 142
 143 static const __DRIimageLoaderExtension image_loader_extension = {
 144    { __DRI_IMAGE_LOADER, 1 },
 145    image_get_buffers,
 146    dri_flush_front_buffer,
 147 };
 148
 149
 150 struct dri_extension_match {
 151    const char *name;
 152    int version;
 153    int offset;
 154 };
 155
 156 static struct dri_extension_match dri_core_extensions[] = {
 157    { __DRI2_FLUSH, 1, offsetof(struct gbm_dri_device, flush) },
 158    { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) },
 159    { NULL, 0, 0 }
 160 };
 161
 162 static struct dri_extension_match gbm_dri_device_extensions[] = {
 163    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) },
 164    { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) },
 165    { NULL, 0, 0 }
 166 };
 167
 168 static int
 169 dri_bind_extensions(struct gbm_dri_device *dri,
 170                     struct dri_extension_match *matches,
 171                     const __DRIextension **extensions)
 172 {
 173    int i, j, ret = 0;
 174    void *field;
 175
 176    for (i = 0; extensions[i]; i++) {
 177       for (j = 0; matches[j].name; j++) {
 178          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
 179              extensions[i]->version >= matches[j].version) {
 180             field = ((char *) dri + matches[j].offset);
 181             *(const __DRIextension **) field = extensions[i];
 182          }
 183       }
 184    }
 185
 186    for (j = 0; matches[j].name; j++) {
 187       field = ((char *) dri + matches[j].offset);
 188       if (*(const __DRIextension **) field == NULL) {
 189          ret = -1;
 190       }
 191    }
 192
 193    return ret;
 194 }
 195
 196 static int
 197 dri_load_driver(struct gbm_dri_device *dri)
 198 {
 199    const __DRIextension **extensions = NULL;
 200    char path[PATH_MAX], *search_paths, *p, *next, *end;
 201    char *get_extensions_name;
 202
 203    search_paths = NULL;
 204    if (geteuid() == getuid()) {
 205       /* don't allow setuid apps to use GBM_DRIVERS_PATH */
 206       search_paths = getenv("GBM_DRIVERS_PATH");
 207    }
 208    if (search_paths == NULL)
 209       search_paths = DEFAULT_DRIVER_DIR;
 210
 211    dri->driver = NULL;
 212    end = search_paths + strlen(search_paths);
 213    for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) {
 214       int len;
 215       next = strchr(p, ':');
 216       if (next == NULL)
 217          next = end;
 218
 219       len = next - p;
 220 #if GLX_USE_TLS
 221       snprintf(path, sizeof path,
 222                "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name);
 223       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 224 #endif
 225       if (dri->driver == NULL) {
 226          snprintf(path, sizeof path,
 227                   "%.*s/%s_dri.so", len, p, dri->base.driver_name);
 228          dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 229       }
 230       /* not need continue to loop all paths once the driver is found */
 231       if (dri->driver != NULL)
 232          break;
 233    }
 234
 235    if (dri->driver == NULL) {
 236       fprintf(stderr, "gbm: failed to open any driver (search paths %s)",
 237               search_paths);
 238       return -1;
 239    }
 240
 241    if (asprintf(&get_extensions_name, "%s_%s",
 242                 __DRI_DRIVER_GET_EXTENSIONS, dri->base.driver_name) != -1) {
 243       const __DRIextension **(*get_extensions)(void);
 244
 245       get_extensions = dlsym(dri->driver, get_extensions_name);
 246       free(get_extensions_name);
 247
 248       if (get_extensions)
 249          extensions = get_extensions();
 250    }
 251
 252    if (!extensions)
 253       extensions = dlsym(dri->driver, __DRI_DRIVER_EXTENSIONS);
 254    if (extensions == NULL) {
 255       fprintf(stderr, "gbm: driver exports no extensions (%s)", dlerror());
 256       dlclose(dri->driver);
 257       return -1;
 258    }
 259    dri->driver_extensions = extensions;
 260
 261    if (dri_bind_extensions(dri, gbm_dri_device_extensions, extensions) < 0) {
 262       dlclose(dri->driver);
 263       fprintf(stderr, "failed to bind extensions\n");
 264       return -1;
 265    }
 266
 267    return 0;
 268 }
 269
 270 static int
 271 dri_screen_create(struct gbm_dri_device *dri)
 272 {
 273    const __DRIextension **extensions;
 274    int ret = 0;
 275
 276    dri->base.driver_name = loader_get_driver_for_fd(dri->base.base.fd, 0);
 277    if (dri->base.driver_name == NULL)
 278       return -1;
 279
 280    ret = dri_load_driver(dri);
 281    if (ret) {
 282       fprintf(stderr, "failed to load driver: %s\n", dri->base.driver_name);
 283       return ret;
 284    };
 285
 286    dri->extensions[0] = &image_lookup_extension.base;
 287    dri->extensions[1] = &use_invalidate.base;
 288    dri->extensions[2] = &dri2_loader_extension.base;
 289    dri->extensions[3] = &image_loader_extension.base;
 290    dri->extensions[4] = NULL;
 291
 292    if (dri->dri2 == NULL)
 293       return -1;
 294
 295    if (dri->dri2->base.version >= 4) {
 296       dri->screen = dri->dri2->createNewScreen2(0, dri->base.base.fd,
 297                                                 dri->extensions,
 298                                                 dri->driver_extensions,
 299                                                 &dri->driver_configs, dri);
 300    } else {
 301       dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd,
 302                                                dri->extensions,
 303                                                &dri->driver_configs, dri);
 304    }
 305    if (dri->screen == NULL)
 306       return -1;
 307
 308    extensions = dri->core->getExtensions(dri->screen);
 309    if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) {
 310       ret = -1;
 311       goto free_screen;
 312    }
 313
 314    dri->lookup_image = NULL;
 315    dri->lookup_user_data = NULL;
 316
 317    return 0;
 318
 319 free_screen:
 320    dri->core->destroyScreen(dri->screen);
 321
 322    return ret;
 323 }
 324
 325 static int
 326 gbm_dri_is_format_supported(struct gbm_device *gbm,
 327                             uint32_t format,
 328                             uint32_t usage)
 329 {
 330    switch (format) {
 331    case GBM_BO_FORMAT_XRGB8888:
 332    case GBM_FORMAT_XRGB8888:
 333       break;
 334    case GBM_BO_FORMAT_ARGB8888:
 335    case GBM_FORMAT_ARGB8888:
 336       if (usage & GBM_BO_USE_SCANOUT)
 337          return 0;
 338       break;
 339    default:
 340       return 0;
 341    }
 342
 343    if (usage & GBM_BO_USE_CURSOR_64X64 &&
 344        usage & GBM_BO_USE_RENDERING)
 345       return 0;
 346
 347    return 1;
 348 }
 349
 350 static int
 351 gbm_dri_bo_write(struct gbm_bo *_bo, const void *buf, size_t count)
 352 {
 353    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 354
 355    if (bo->image != NULL)
 356       return -1;
 357
 358    memcpy(bo->map, buf, count);
 359
 360    return 0;
 361 }
 362
 363 static void
 364 gbm_dri_bo_destroy(struct gbm_bo *_bo)
 365 {
 366    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 367    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 368    struct drm_mode_destroy_dumb arg;
 369
 370    if (bo->image != NULL) {
 371       dri->image->destroyImage(bo->image);
 372    } else {
 373       munmap(bo->map, bo->size);
 374       memset(&arg, 0, sizeof(arg));
 375       arg.handle = bo->handle;
 376       drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
 377    }
 378
 379    free(bo);
 380 }
 381
 382 static uint32_t
 383 gbm_dri_to_gbm_format(uint32_t dri_format)
 384 {
 385    uint32_t ret = 0;
 386
 387    switch (dri_format) {
 388    case __DRI_IMAGE_FORMAT_RGB565:
 389       ret = GBM_FORMAT_RGB565;
 390       break;
 391    case __DRI_IMAGE_FORMAT_XRGB8888:
 392       ret = GBM_FORMAT_XRGB8888;
 393       break;
 394    case __DRI_IMAGE_FORMAT_ARGB8888:
 395       ret = GBM_FORMAT_ARGB8888;
 396       break;
 397    case __DRI_IMAGE_FORMAT_ABGR8888:
 398       ret = GBM_FORMAT_ABGR8888;
 399       break;
 400    default:
 401       ret = 0;
 402       break;
 403    }
 404
 405    return ret;
 406 }
 407
 408 static struct gbm_bo *
 409 gbm_dri_bo_import(struct gbm_device *gbm,
 410                   uint32_t type, void *buffer, uint32_t usage)
 411 {
 412    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 413    struct gbm_dri_bo *bo;
 414    __DRIimage *image;
 415    unsigned dri_use = 0;
 416    int gbm_format;
 417
 418    /* Required for query image WIDTH & HEIGHT */
 419    if (dri->image->base.version < 4)
 420       return NULL;
 421
 422    switch (type) {
 423 #if HAVE_WAYLAND_PLATFORM
 424    case GBM_BO_IMPORT_WL_BUFFER:
 425    {
 426       struct wl_drm_buffer *wb;
 427
 428       if (!dri->wl_drm)
 429          return NULL;
 430
 431       wb = wayland_drm_buffer_get(dri->wl_drm, (struct wl_resource *) buffer);
 432       if (!wb)
 433          return NULL;
 434
 435       image = wb->driver_buffer;
 436
 437       switch (wb->format) {
 438       case WL_DRM_FORMAT_XRGB8888:
 439          gbm_format = GBM_FORMAT_XRGB8888;
 440          break;
 441       case WL_DRM_FORMAT_ARGB8888:
 442          gbm_format = GBM_FORMAT_ARGB8888;
 443          break;
 444       case WL_DRM_FORMAT_RGB565:
 445          gbm_format = GBM_FORMAT_RGB565;
 446          break;
 447       case WL_DRM_FORMAT_YUYV:
 448          gbm_format = GBM_FORMAT_YUYV;
 449          break;
 450       default:
 451          return NULL;
 452       }
 453       break;
 454    }
 455 #endif
 456
 457    case GBM_BO_IMPORT_EGL_IMAGE:
 458    {
 459       int dri_format;
 460       if (dri->lookup_image == NULL)
 461          return NULL;
 462
 463       image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data);
 464       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format);
 465       gbm_format = gbm_dri_to_gbm_format(dri_format);
 466       if (gbm_format == 0)
 467          return NULL;
 468       break;
 469    }
 470
 471    default:
 472       return NULL;
 473    }
 474
 475
 476    bo = calloc(1, sizeof *bo);
 477    if (bo == NULL)
 478       return NULL;
 479
 480    bo->image = dri->image->dupImage(image, NULL);
 481
 482    if (usage & GBM_BO_USE_SCANOUT)
 483       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 484    if (usage & GBM_BO_USE_CURSOR_64X64)
 485       dri_use |= __DRI_IMAGE_USE_CURSOR;
 486    if (dri->image->base.version >= 2 &&
 487        !dri->image->validateUsage(bo->image, dri_use)) {
 488       free(bo);
 489       return NULL;
 490    }
 491
 492    bo->base.base.gbm = gbm;
 493    bo->base.base.format = gbm_format;
 494
 495    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH,
 496                           (int*)&bo->base.base.width);
 497    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT,
 498                           (int*)&bo->base.base.height);
 499    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 500                           (int*)&bo->base.base.stride);
 501    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 502                           &bo->base.base.handle.s32);
 503
 504    return &bo->base.base;
 505 }
 506
 507 static struct gbm_bo *
 508 create_dumb(struct gbm_device *gbm,
 509                   uint32_t width, uint32_t height,
 510                   uint32_t format, uint32_t usage)
 511 {
 512    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 513    struct drm_mode_create_dumb create_arg;
 514    struct drm_mode_map_dumb map_arg;
 515    struct gbm_dri_bo *bo;
 516    struct drm_mode_destroy_dumb destroy_arg;
 517    int ret;
 518
 519    if (!(usage & GBM_BO_USE_CURSOR_64X64))
 520       return NULL;
 521    if (format != GBM_FORMAT_ARGB8888)
 522       return NULL;
 523
 524    bo = calloc(1, sizeof *bo);
 525    if (bo == NULL)
 526       return NULL;
 527
 528    create_arg.bpp = 32;
 529    create_arg.width = width;
 530    create_arg.height = height;
 531
 532    ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
 533    if (ret)
 534       goto free_bo;
 535
 536    bo->base.base.gbm = gbm;
 537    bo->base.base.width = width;
 538    bo->base.base.height = height;
 539    bo->base.base.stride = create_arg.pitch;
 540    bo->base.base.format = format;
 541    bo->base.base.handle.u32 = create_arg.handle;
 542    bo->handle = create_arg.handle;
 543    bo->size = create_arg.size;
 544
 545    memset(&map_arg, 0, sizeof(map_arg));
 546    map_arg.handle = bo->handle;
 547
 548    ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_MAP_DUMB, &map_arg);
 549    if (ret)
 550       goto destroy_dumb;
 551
 552    bo->map = mmap(0, bo->size, PROT_WRITE,
 553                   MAP_SHARED, dri->base.base.fd, map_arg.offset);
 554    if (bo->map == MAP_FAILED)
 555       goto destroy_dumb;
 556
 557    return &bo->base.base;
 558
 559 destroy_dumb:
 560    memset(&destroy_arg, 0, sizeof destroy_arg);
 561    destroy_arg.handle = create_arg.handle;
 562    drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
 563 free_bo:
 564    free(bo);
 565
 566    return NULL;
 567 }
 568
 569 static struct gbm_bo *
 570 gbm_dri_bo_create(struct gbm_device *gbm,
 571                   uint32_t width, uint32_t height,
 572                   uint32_t format, uint32_t usage)
 573 {
 574    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 575    struct gbm_dri_bo *bo;
 576    int dri_format;
 577    unsigned dri_use = 0;
 578
 579    if (usage & GBM_BO_USE_WRITE)
 580       return create_dumb(gbm, width, height, format, usage);
 581
 582    bo = calloc(1, sizeof *bo);
 583    if (bo == NULL)
 584       return NULL;
 585
 586    bo->base.base.gbm = gbm;
 587    bo->base.base.width = width;
 588    bo->base.base.height = height;
 589    bo->base.base.format = format;
 590
 591    switch (format) {
 592    case GBM_FORMAT_RGB565:
 593       dri_format =__DRI_IMAGE_FORMAT_RGB565;
 594       break;
 595    case GBM_FORMAT_XRGB8888:
 596    case GBM_BO_FORMAT_XRGB8888:
 597       dri_format = __DRI_IMAGE_FORMAT_XRGB8888;
 598       break;
 599    case GBM_FORMAT_ARGB8888:
 600    case GBM_BO_FORMAT_ARGB8888:
 601       dri_format = __DRI_IMAGE_FORMAT_ARGB8888;
 602       break;
 603    case GBM_FORMAT_ABGR8888:
 604       dri_format = __DRI_IMAGE_FORMAT_ABGR8888;
 605       break;
 606    case GBM_FORMAT_ARGB2101010:
 607       dri_format = __DRI_IMAGE_FORMAT_ARGB2101010;
 608       break;
 609    case GBM_FORMAT_XRGB2101010:
 610       dri_format = __DRI_IMAGE_FORMAT_XRGB2101010;
 611       break;
 612    default:
 613       return NULL;
 614    }
 615
 616    if (usage & GBM_BO_USE_SCANOUT)
 617       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 618    if (usage & GBM_BO_USE_CURSOR_64X64)
 619       dri_use |= __DRI_IMAGE_USE_CURSOR;
 620
 621    /* Gallium drivers requires shared in order to get the handle/stride */
 622    dri_use |= __DRI_IMAGE_USE_SHARE;
 623
 624    bo->image =
 625       dri->image->createImage(dri->screen,
 626                               width, height,
 627                               dri_format, dri_use,
 628                               bo);
 629    if (bo->image == NULL)
 630       return NULL;
 631
 632    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 633                           &bo->base.base.handle.s32);
 634    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 635                           (int *) &bo->base.base.stride);
 636
 637    return &bo->base.base;
 638 }
 639
 640 static struct gbm_surface *
 641 gbm_dri_surface_create(struct gbm_device *gbm,
 642                        uint32_t width, uint32_t height,
 643                        uint32_t format, uint32_t flags)
 644 {
 645    struct gbm_dri_surface *surf;
 646
 647    surf = calloc(1, sizeof *surf);
 648    if (surf == NULL)
 649       return NULL;
 650
 651    surf->base.gbm = gbm;
 652    surf->base.width = width;
 653    surf->base.height = height;
 654    surf->base.format = format;
 655    surf->base.flags = flags;
 656
 657    return &surf->base;
 658 }
 659
 660 static void
 661 gbm_dri_surface_destroy(struct gbm_surface *_surf)
 662 {
 663    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
 664
 665    free(surf);
 666 }
 667
 668 static void
 669 dri_destroy(struct gbm_device *gbm)
 670 {
 671    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 672
 673    dri->core->destroyScreen(dri->screen);
 674    free(dri->driver_configs);
 675    dlclose(dri->driver);
 676    free(dri->base.driver_name);
 677
 678    free(dri);
 679 }
 680
 681 static struct gbm_device *
 682 dri_device_create(int fd)
 683 {
 684    struct gbm_dri_device *dri;
 685    int ret;
 686
 687    dri = calloc(1, sizeof *dri);
 688
 689    dri->base.base.fd = fd;
 690    dri->base.base.bo_create = gbm_dri_bo_create;
 691    dri->base.base.bo_import = gbm_dri_bo_import;
 692    dri->base.base.is_format_supported = gbm_dri_is_format_supported;
 693    dri->base.base.bo_write = gbm_dri_bo_write;
 694    dri->base.base.bo_destroy = gbm_dri_bo_destroy;
 695    dri->base.base.destroy = dri_destroy;
 696    dri->base.base.surface_create = gbm_dri_surface_create;
 697    dri->base.base.surface_destroy = gbm_dri_surface_destroy;
 698
 699    dri->base.type = GBM_DRM_DRIVER_TYPE_DRI;
 700    dri->base.base.name = "drm";
 701
 702    ret = dri_screen_create(dri);
 703    if (ret)
 704       goto err_dri;
 705
 706    return &dri->base.base;
 707
 708 err_dri:
 709    free(dri);
 710
 711    return NULL;
 712 }
 713
 714 struct gbm_backend gbm_dri_backend = {
 715    .backend_name = "dri",
 716    .create_device = dri_device_create,
 717 };