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