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