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