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
 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    dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd,
 267                                             dri->extensions,
 268                                             &dri->driver_configs, dri);
 269    if (dri->screen == NULL)
 270       return -1;
 271
 272    extensions = dri->core->getExtensions(dri->screen);
 273    if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) {
 274       ret = -1;
 275       goto free_screen;
 276    }
 277
 278    dri->lookup_image = NULL;
 279    dri->lookup_user_data = NULL;
 280
 281    return 0;
 282
 283 free_screen:
 284    dri->core->destroyScreen(dri->screen);
 285
 286    return ret;
 287 }
 288
 289 static int
 290 gbm_dri_is_format_supported(struct gbm_device *gbm,
 291                             uint32_t format,
 292                             uint32_t usage)
 293 {
 294    switch (format) {
 295    case GBM_BO_FORMAT_XRGB8888:
 296    case GBM_FORMAT_XRGB8888:
 297       break;
 298    case GBM_BO_FORMAT_ARGB8888:
 299    case GBM_FORMAT_ARGB8888:
 300       if (usage & GBM_BO_USE_SCANOUT)
 301          return 0;
 302       break;
 303    default:
 304       return 0;
 305    }
 306
 307    if (usage & GBM_BO_USE_CURSOR_64X64 &&
 308        usage & GBM_BO_USE_RENDERING)
 309       return 0;
 310
 311    return 1;
 312 }
 313
 314 static int
 315 gbm_dri_bo_write(struct gbm_bo *_bo, const void *buf, size_t count)
 316 {
 317    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 318
 319    if (bo->image != NULL)
 320       return -1;
 321
 322    memcpy(bo->map, buf, count);
 323
 324    return 0;
 325 }
 326
 327 static void
 328 gbm_dri_bo_destroy(struct gbm_bo *_bo)
 329 {
 330    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 331    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 332    struct drm_mode_destroy_dumb arg;
 333
 334    if (bo->image != NULL) {
 335       dri->image->destroyImage(bo->image);
 336    } else {
 337       munmap(bo->map, bo->size);
 338       memset(&arg, 0, sizeof(arg));
 339       arg.handle = bo->handle;
 340       drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
 341    }
 342
 343    free(bo);
 344 }
 345
 346 static uint32_t
 347 gbm_dri_to_gbm_format(uint32_t dri_format)
 348 {
 349    uint32_t ret = 0;
 350
 351    switch (dri_format) {
 352    case __DRI_IMAGE_FORMAT_RGB565:
 353       ret = GBM_FORMAT_RGB565;
 354       break;
 355    case __DRI_IMAGE_FORMAT_XRGB8888:
 356       ret = GBM_FORMAT_XRGB8888;
 357       break;
 358    case __DRI_IMAGE_FORMAT_ARGB8888:
 359       ret = GBM_FORMAT_ARGB8888;
 360       break;
 361    case __DRI_IMAGE_FORMAT_ABGR8888:
 362       ret = GBM_FORMAT_ABGR8888;
 363       break;
 364    default:
 365       ret = 0;
 366       break;
 367    }
 368
 369    return ret;
 370 }
 371
 372 static struct gbm_bo *
 373 gbm_dri_bo_import(struct gbm_device *gbm,
 374                   uint32_t type, void *buffer, uint32_t usage)
 375 {
 376    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 377    struct gbm_dri_bo *bo;
 378    __DRIimage *image;
 379    unsigned dri_use = 0;
 380    int gbm_format;
 381
 382    /* Required for query image WIDTH & HEIGHT */
 383    if (dri->image->base.version < 4)
 384       return NULL;
 385
 386    switch (type) {
 387 #if HAVE_WAYLAND_PLATFORM
 388    case GBM_BO_IMPORT_WL_BUFFER:
 389    {
 390       struct wl_drm_buffer *wb;
 391
 392       if (!dri->wl_drm)
 393          return NULL;
 394
 395       wb = wayland_drm_buffer_get(dri->wl_drm, (struct wl_resource *) buffer);
 396       if (!wb)
 397          return NULL;
 398
 399       image = wb->driver_buffer;
 400
 401       switch (wb->format) {
 402       case WL_DRM_FORMAT_XRGB8888:
 403          gbm_format = GBM_FORMAT_XRGB8888;
 404          break;
 405       case WL_DRM_FORMAT_ARGB8888:
 406          gbm_format = GBM_FORMAT_ARGB8888;
 407          break;
 408       case WL_DRM_FORMAT_RGB565:
 409          gbm_format = GBM_FORMAT_RGB565;
 410          break;
 411       case WL_DRM_FORMAT_YUYV:
 412          gbm_format = GBM_FORMAT_YUYV;
 413          break;
 414       default:
 415          return NULL;
 416       }
 417       break;
 418    }
 419 #endif
 420
 421    case GBM_BO_IMPORT_EGL_IMAGE:
 422    {
 423       int dri_format;
 424       if (dri->lookup_image == NULL)
 425          return NULL;
 426
 427       image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data);
 428       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format);
 429       gbm_format = gbm_dri_to_gbm_format(dri_format);
 430       if (gbm_format == 0)
 431          return NULL;
 432       break;
 433    }
 434
 435    default:
 436       return NULL;
 437    }
 438
 439
 440    bo = calloc(1, sizeof *bo);
 441    if (bo == NULL)
 442       return NULL;
 443
 444    bo->image = dri->image->dupImage(image, NULL);
 445
 446    if (usage & GBM_BO_USE_SCANOUT)
 447       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 448    if (usage & GBM_BO_USE_CURSOR_64X64)
 449       dri_use |= __DRI_IMAGE_USE_CURSOR;
 450    if (dri->image->base.version >= 2 &&
 451        !dri->image->validateUsage(bo->image, dri_use)) {
 452       free(bo);
 453       return NULL;
 454    }
 455
 456    bo->base.base.gbm = gbm;
 457    bo->base.base.format = gbm_format;
 458
 459    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH,
 460                           (int*)&bo->base.base.width);
 461    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT,
 462                           (int*)&bo->base.base.height);
 463    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 464                           (int*)&bo->base.base.stride);
 465    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 466                           &bo->base.base.handle.s32);
 467
 468    return &bo->base.base;
 469 }
 470
 471 static struct gbm_bo *
 472 create_dumb(struct gbm_device *gbm,
 473                   uint32_t width, uint32_t height,
 474                   uint32_t format, uint32_t usage)
 475 {
 476    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 477    struct drm_mode_create_dumb create_arg;
 478    struct drm_mode_map_dumb map_arg;
 479    struct gbm_dri_bo *bo;
 480    struct drm_mode_destroy_dumb destroy_arg;
 481    int ret;
 482
 483    if (!(usage & GBM_BO_USE_CURSOR_64X64))
 484       return NULL;
 485    if (format != GBM_FORMAT_ARGB8888)
 486       return NULL;
 487
 488    bo = calloc(1, sizeof *bo);
 489    if (bo == NULL)
 490       return NULL;
 491
 492    create_arg.bpp = 32;
 493    create_arg.width = width;
 494    create_arg.height = height;
 495
 496    ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
 497    if (ret)
 498       goto free_bo;
 499
 500    bo->base.base.gbm = gbm;
 501    bo->base.base.width = width;
 502    bo->base.base.height = height;
 503    bo->base.base.stride = create_arg.pitch;
 504    bo->base.base.format = format;
 505    bo->base.base.handle.u32 = create_arg.handle;
 506    bo->handle = create_arg.handle;
 507    bo->size = create_arg.size;
 508
 509    memset(&map_arg, 0, sizeof(map_arg));
 510    map_arg.handle = bo->handle;
 511
 512    ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_MAP_DUMB, &map_arg);
 513    if (ret)
 514       goto destroy_dumb;
 515
 516    bo->map = mmap(0, bo->size, PROT_WRITE,
 517                   MAP_SHARED, dri->base.base.fd, map_arg.offset);
 518    if (bo->map == MAP_FAILED)
 519       goto destroy_dumb;
 520
 521    return &bo->base.base;
 522
 523 destroy_dumb:
 524    memset(&destroy_arg, 0, sizeof destroy_arg);
 525    destroy_arg.handle = create_arg.handle;
 526    drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
 527 free_bo:
 528    free(bo);
 529
 530    return NULL;
 531 }
 532
 533 static struct gbm_bo *
 534 gbm_dri_bo_create(struct gbm_device *gbm,
 535                   uint32_t width, uint32_t height,
 536                   uint32_t format, uint32_t usage)
 537 {
 538    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 539    struct gbm_dri_bo *bo;
 540    int dri_format;
 541    unsigned dri_use = 0;
 542
 543    if (usage & GBM_BO_USE_WRITE)
 544       return create_dumb(gbm, width, height, format, usage);
 545
 546    bo = calloc(1, sizeof *bo);
 547    if (bo == NULL)
 548       return NULL;
 549
 550    bo->base.base.gbm = gbm;
 551    bo->base.base.width = width;
 552    bo->base.base.height = height;
 553    bo->base.base.format = format;
 554
 555    switch (format) {
 556    case GBM_FORMAT_RGB565:
 557       dri_format =__DRI_IMAGE_FORMAT_RGB565;
 558       break;
 559    case GBM_FORMAT_XRGB8888:
 560    case GBM_BO_FORMAT_XRGB8888:
 561       dri_format = __DRI_IMAGE_FORMAT_XRGB8888;
 562       break;
 563    case GBM_FORMAT_ARGB8888:
 564    case GBM_BO_FORMAT_ARGB8888:
 565       dri_format = __DRI_IMAGE_FORMAT_ARGB8888;
 566       break;
 567    case GBM_FORMAT_ABGR8888:
 568       dri_format = __DRI_IMAGE_FORMAT_ABGR8888;
 569       break;
 570    case GBM_FORMAT_ARGB2101010:
 571       dri_format = __DRI_IMAGE_FORMAT_ARGB2101010;
 572       break;
 573    case GBM_FORMAT_XRGB2101010:
 574       dri_format = __DRI_IMAGE_FORMAT_XRGB2101010;
 575       break;
 576    default:
 577       return NULL;
 578    }
 579
 580    if (usage & GBM_BO_USE_SCANOUT)
 581       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 582    if (usage & GBM_BO_USE_CURSOR_64X64)
 583       dri_use |= __DRI_IMAGE_USE_CURSOR;
 584
 585    /* Gallium drivers requires shared in order to get the handle/stride */
 586    dri_use |= __DRI_IMAGE_USE_SHARE;
 587
 588    bo->image =
 589       dri->image->createImage(dri->screen,
 590                               width, height,
 591                               dri_format, dri_use,
 592                               bo);
 593    if (bo->image == NULL)
 594       return NULL;
 595
 596    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 597                           &bo->base.base.handle.s32);
 598    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 599                           (int *) &bo->base.base.stride);
 600
 601    return &bo->base.base;
 602 }
 603
 604 static struct gbm_surface *
 605 gbm_dri_surface_create(struct gbm_device *gbm,
 606                        uint32_t width, uint32_t height,
 607                        uint32_t format, uint32_t flags)
 608 {
 609    struct gbm_dri_surface *surf;
 610
 611    surf = calloc(1, sizeof *surf);
 612    if (surf == NULL)
 613       return NULL;
 614
 615    surf->base.gbm = gbm;
 616    surf->base.width = width;
 617    surf->base.height = height;
 618    surf->base.format = format;
 619    surf->base.flags = flags;
 620
 621    return &surf->base;
 622 }
 623
 624 static void
 625 gbm_dri_surface_destroy(struct gbm_surface *_surf)
 626 {
 627    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
 628
 629    free(surf);
 630 }
 631
 632 static void
 633 dri_destroy(struct gbm_device *gbm)
 634 {
 635    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 636
 637    dri->core->destroyScreen(dri->screen);
 638    free(dri->driver_configs);
 639    dlclose(dri->driver);
 640    free(dri->base.driver_name);
 641
 642    free(dri);
 643 }
 644
 645 static struct gbm_device *
 646 dri_device_create(int fd)
 647 {
 648    struct gbm_dri_device *dri;
 649    int ret;
 650
 651    dri = calloc(1, sizeof *dri);
 652
 653    dri->base.base.fd = fd;
 654    dri->base.base.bo_create = gbm_dri_bo_create;
 655    dri->base.base.bo_import = gbm_dri_bo_import;
 656    dri->base.base.is_format_supported = gbm_dri_is_format_supported;
 657    dri->base.base.bo_write = gbm_dri_bo_write;
 658    dri->base.base.bo_destroy = gbm_dri_bo_destroy;
 659    dri->base.base.destroy = dri_destroy;
 660    dri->base.base.surface_create = gbm_dri_surface_create;
 661    dri->base.base.surface_destroy = gbm_dri_surface_destroy;
 662
 663    dri->base.type = GBM_DRM_DRIVER_TYPE_DRI;
 664    dri->base.base.name = "drm";
 665
 666    ret = dri_screen_create(dri);
 667    if (ret)
 668       goto err_dri;
 669
 670    return &dri->base.base;
 671
 672 err_dri:
 673    free(dri);
 674
 675    return NULL;
 676 }
 677
 678 struct gbm_backend gbm_dri_backend = {
 679    .backend_name = "dri",
 680    .create_device = dri_device_create,
 681 };