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