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