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 <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 void
 127 swrast_get_drawable_info(__DRIdrawable *driDrawable,
 128                          int           *x,
 129                          int           *y,
 130                          int           *width,
 131                          int           *height,
 132                          void          *loaderPrivate)
 133 {
 134    struct gbm_dri_surface *surf = loaderPrivate;
 135
 136    *x = 0;
 137    *y = 0;
 138    *width = surf->base.width;
 139    *height = surf->base.height;
 140 }
 141
 142 static void
 143 swrast_put_image2(__DRIdrawable *driDrawable,
 144                   int            op,
 145                   int            x,
 146                   int            y,
 147                   int            width,
 148                   int            height,
 149                   int            stride,
 150                   char          *data,
 151                   void          *loaderPrivate)
 152 {
 153    struct gbm_dri_surface *surf = loaderPrivate;
 154    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 155
 156    dri->swrast_put_image2(driDrawable,
 157                           op, x, y,
 158                           width, height, stride,
 159                           data, surf->dri_private);
 160 }
 161
 162 static void
 163 swrast_put_image(__DRIdrawable *driDrawable,
 164                  int            op,
 165                  int            x,
 166                  int            y,
 167                  int            width,
 168                  int            height,
 169                  char          *data,
 170                  void          *loaderPrivate)
 171 {
 172    return swrast_put_image2(driDrawable, op, x, y, width, height,
 173                             width * 4, data, loaderPrivate);
 174 }
 175
 176 static void
 177 swrast_get_image(__DRIdrawable *driDrawable,
 178                  int            x,
 179                  int            y,
 180                  int            width,
 181                  int            height,
 182                  char          *data,
 183                  void          *loaderPrivate)
 184 {
 185    struct gbm_dri_surface *surf = loaderPrivate;
 186    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 187
 188    dri->swrast_get_image(driDrawable,
 189                          x, y,
 190                          width, height,
 191                          data, surf->dri_private);
 192 }
 193
 194 static const __DRIuseInvalidateExtension use_invalidate = {
 195    .base = { __DRI_USE_INVALIDATE, 1 }
 196 };
 197
 198 static const __DRIimageLookupExtension image_lookup_extension = {
 199    .base = { __DRI_IMAGE_LOOKUP, 1 },
 200
 201    .lookupEGLImage          = dri_lookup_egl_image
 202 };
 203
 204 static const __DRIdri2LoaderExtension dri2_loader_extension = {
 205    .base = { __DRI_DRI2_LOADER, 3 },
 206
 207    .getBuffers              = dri_get_buffers,
 208    .flushFrontBuffer        = dri_flush_front_buffer,
 209    .getBuffersWithFormat    = dri_get_buffers_with_format,
 210 };
 211
 212 static const __DRIimageLoaderExtension image_loader_extension = {
 213    .base = { __DRI_IMAGE_LOADER, 1 },
 214
 215    .getBuffers          = image_get_buffers,
 216    .flushFrontBuffer    = dri_flush_front_buffer,
 217 };
 218
 219 static const __DRIswrastLoaderExtension swrast_loader_extension = {
 220    .base = { __DRI_SWRAST_LOADER, 2 },
 221
 222    .getDrawableInfo = swrast_get_drawable_info,
 223    .putImage        = swrast_put_image,
 224    .getImage        = swrast_get_image,
 225    .putImage2       = swrast_put_image2
 226 };
 227
 228 static const __DRIextension *gbm_dri_screen_extensions[] = {
 229    &image_lookup_extension.base,
 230    &use_invalidate.base,
 231    &dri2_loader_extension.base,
 232    &image_loader_extension.base,
 233    &swrast_loader_extension.base,
 234    NULL,
 235 };
 236
 237 struct dri_extension_match {
 238    const char *name;
 239    int version;
 240    int offset;
 241 };
 242
 243 static struct dri_extension_match dri_core_extensions[] = {
 244    { __DRI2_FLUSH, 1, offsetof(struct gbm_dri_device, flush) },
 245    { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) },
 246    { NULL, 0, 0 }
 247 };
 248
 249 static struct dri_extension_match gbm_dri_device_extensions[] = {
 250    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) },
 251    { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) },
 252    { NULL, 0, 0 }
 253 };
 254
 255 static struct dri_extension_match gbm_swrast_device_extensions[] = {
 256    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core), },
 257    { __DRI_SWRAST, 1, offsetof(struct gbm_dri_device, swrast) },
 258    { NULL, 0, 0 }
 259 };
 260
 261 static int
 262 dri_bind_extensions(struct gbm_dri_device *dri,
 263                     struct dri_extension_match *matches,
 264                     const __DRIextension **extensions)
 265 {
 266    int i, j, ret = 0;
 267    void *field;
 268
 269    for (i = 0; extensions[i]; i++) {
 270       for (j = 0; matches[j].name; j++) {
 271          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
 272              extensions[i]->version >= matches[j].version) {
 273             field = ((char *) dri + matches[j].offset);
 274             *(const __DRIextension **) field = extensions[i];
 275          }
 276       }
 277    }
 278
 279    for (j = 0; matches[j].name; j++) {
 280       field = ((char *) dri + matches[j].offset);
 281       if (*(const __DRIextension **) field == NULL) {
 282          ret = -1;
 283       }
 284    }
 285
 286    return ret;
 287 }
 288
 289 static const __DRIextension **
 290 dri_open_driver(struct gbm_dri_device *dri)
 291 {
 292    const __DRIextension **extensions = NULL;
 293    char path[PATH_MAX], *search_paths, *p, *next, *end;
 294    char *get_extensions_name;
 295
 296    search_paths = NULL;
 297    /* don't allow setuid apps to use LIBGL_DRIVERS_PATH or GBM_DRIVERS_PATH */
 298    if (geteuid() == getuid()) {
 299       /* Read GBM_DRIVERS_PATH first for compatibility, but LIBGL_DRIVERS_PATH
 300        * is recommended over GBM_DRIVERS_PATH.
 301        */
 302       search_paths = getenv("GBM_DRIVERS_PATH");
 303
 304       /* Read LIBGL_DRIVERS_PATH if GBM_DRIVERS_PATH was not set.
 305        * LIBGL_DRIVERS_PATH is recommended over GBM_DRIVERS_PATH.
 306        */
 307       if (search_paths == NULL) {
 308          search_paths = getenv("LIBGL_DRIVERS_PATH");
 309       }
 310    }
 311    if (search_paths == NULL)
 312       search_paths = DEFAULT_DRIVER_DIR;
 313
 314    dri->driver = NULL;
 315    end = search_paths + strlen(search_paths);
 316    for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) {
 317       int len;
 318       next = strchr(p, ':');
 319       if (next == NULL)
 320          next = end;
 321
 322       len = next - p;
 323 #if GLX_USE_TLS
 324       snprintf(path, sizeof path,
 325                "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name);
 326       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 327 #endif
 328       if (dri->driver == NULL) {
 329          snprintf(path, sizeof path,
 330                   "%.*s/%s_dri.so", len, p, dri->base.driver_name);
 331          dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 332       }
 333       /* not need continue to loop all paths once the driver is found */
 334       if (dri->driver != NULL)
 335          break;
 336    }
 337
 338    if (dri->driver == NULL) {
 339       fprintf(stderr, "gbm: failed to open any driver (search paths %s)",
 340               search_paths);
 341       return NULL;
 342    }
 343
 344    if (asprintf(&get_extensions_name, "%s_%s",
 345                 __DRI_DRIVER_GET_EXTENSIONS, dri->base.driver_name) != -1) {
 346       const __DRIextension **(*get_extensions)(void);
 347
 348       get_extensions = dlsym(dri->driver, get_extensions_name);
 349       free(get_extensions_name);
 350
 351       if (get_extensions)
 352          extensions = get_extensions();
 353    }
 354
 355    if (!extensions)
 356       extensions = dlsym(dri->driver, __DRI_DRIVER_EXTENSIONS);
 357    if (extensions == NULL) {
 358       fprintf(stderr, "gbm: driver exports no extensions (%s)", dlerror());
 359       dlclose(dri->driver);
 360    }
 361
 362    return extensions;
 363 }
 364
 365 static int
 366 dri_load_driver(struct gbm_dri_device *dri)
 367 {
 368    const __DRIextension **extensions;
 369
 370    extensions = dri_open_driver(dri);
 371    if (!extensions)
 372       return -1;
 373
 374    if (dri_bind_extensions(dri, gbm_dri_device_extensions, extensions) < 0) {
 375       dlclose(dri->driver);
 376       fprintf(stderr, "failed to bind extensions\n");
 377       return -1;
 378    }
 379
 380    dri->driver_extensions = extensions;
 381
 382    return 0;
 383 }
 384
 385 static int
 386 dri_load_driver_swrast(struct gbm_dri_device *dri)
 387 {
 388    const __DRIextension **extensions;
 389
 390    extensions = dri_open_driver(dri);
 391    if (!extensions)
 392       return -1;
 393
 394    if (dri_bind_extensions(dri, gbm_swrast_device_extensions, extensions) < 0) {
 395       dlclose(dri->driver);
 396       fprintf(stderr, "failed to bind extensions\n");
 397       return -1;
 398    }
 399
 400    dri->driver_extensions = extensions;
 401
 402    return 0;
 403 }
 404
 405 static int
 406 dri_screen_create(struct gbm_dri_device *dri)
 407 {
 408    const __DRIextension **extensions;
 409    int ret = 0;
 410
 411    dri->base.driver_name = loader_get_driver_for_fd(dri->base.base.fd, 0);
 412    if (dri->base.driver_name == NULL)
 413       return -1;
 414
 415    ret = dri_load_driver(dri);
 416    if (ret) {
 417       fprintf(stderr, "failed to load driver: %s\n", dri->base.driver_name);
 418       return ret;
 419    };
 420
 421    dri->extensions = gbm_dri_screen_extensions;
 422
 423    if (dri->dri2 == NULL)
 424       return -1;
 425
 426    if (dri->dri2->base.version >= 4) {
 427       dri->screen = dri->dri2->createNewScreen2(0, dri->base.base.fd,
 428                                                 dri->extensions,
 429                                                 dri->driver_extensions,
 430                                                 &dri->driver_configs, dri);
 431    } else {
 432       dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd,
 433                                                dri->extensions,
 434                                                &dri->driver_configs, dri);
 435    }
 436    if (dri->screen == NULL)
 437       return -1;
 438
 439    extensions = dri->core->getExtensions(dri->screen);
 440    if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) {
 441       ret = -1;
 442       goto free_screen;
 443    }
 444
 445    dri->lookup_image = NULL;
 446    dri->lookup_user_data = NULL;
 447
 448    return 0;
 449
 450 free_screen:
 451    dri->core->destroyScreen(dri->screen);
 452
 453    return ret;
 454 }
 455
 456 static int
 457 dri_screen_create_swrast(struct gbm_dri_device *dri)
 458 {
 459    int ret;
 460
 461    dri->base.driver_name = strdup("swrast");
 462    if (dri->base.driver_name == NULL)
 463       return -1;
 464
 465    ret = dri_load_driver_swrast(dri);
 466    if (ret) {
 467       fprintf(stderr, "failed to load swrast driver\n");
 468       return ret;
 469    }
 470
 471    dri->extensions = gbm_dri_screen_extensions;
 472
 473    if (dri->swrast == NULL)
 474       return -1;
 475
 476    if (dri->swrast->base.version >= 4) {
 477       dri->screen = dri->swrast->createNewScreen2(0, dri->extensions,
 478                                                   dri->driver_extensions,
 479                                                   &dri->driver_configs, dri);
 480    } else {
 481       dri->screen = dri->swrast->createNewScreen(0, dri->extensions,
 482                                                  &dri->driver_configs, dri);
 483    }
 484    if (dri->screen == NULL)
 485       return -1;
 486
 487    dri->lookup_image = NULL;
 488    dri->lookup_user_data = NULL;
 489
 490    return 0;
 491 }
 492
 493 static int
 494 gbm_dri_is_format_supported(struct gbm_device *gbm,
 495                             uint32_t format,
 496                             uint32_t usage)
 497 {
 498    switch (format) {
 499    case GBM_BO_FORMAT_XRGB8888:
 500    case GBM_FORMAT_XRGB8888:
 501       break;
 502    case GBM_BO_FORMAT_ARGB8888:
 503    case GBM_FORMAT_ARGB8888:
 504       if (usage & GBM_BO_USE_SCANOUT)
 505          return 0;
 506       break;
 507    default:
 508       return 0;
 509    }
 510
 511    if (usage & GBM_BO_USE_CURSOR &&
 512        usage & GBM_BO_USE_RENDERING)
 513       return 0;
 514
 515    return 1;
 516 }
 517
 518 static int
 519 gbm_dri_bo_write(struct gbm_bo *_bo, const void *buf, size_t count)
 520 {
 521    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 522
 523    if (bo->image != NULL) {
 524       errno = EINVAL;
 525       return -1;
 526    }
 527
 528    memcpy(bo->map, buf, count);
 529
 530    return 0;
 531 }
 532
 533 static int
 534 gbm_dri_bo_get_fd(struct gbm_bo *_bo)
 535 {
 536    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 537    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 538    int fd;
 539
 540    if (bo->image == NULL)
 541       return -1;
 542
 543    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_FD, &fd);
 544
 545    return fd;
 546 }
 547
 548 static void
 549 gbm_dri_bo_destroy(struct gbm_bo *_bo)
 550 {
 551    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 552    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 553    struct drm_mode_destroy_dumb arg;
 554
 555    if (bo->image != NULL) {
 556       dri->image->destroyImage(bo->image);
 557    } else {
 558       gbm_dri_bo_unmap(bo);
 559       memset(&arg, 0, sizeof(arg));
 560       arg.handle = bo->handle;
 561       drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
 562    }
 563
 564    free(bo);
 565 }
 566
 567 static uint32_t
 568 gbm_dri_to_gbm_format(uint32_t dri_format)
 569 {
 570    uint32_t ret = 0;
 571
 572    switch (dri_format) {
 573    case __DRI_IMAGE_FORMAT_RGB565:
 574       ret = GBM_FORMAT_RGB565;
 575       break;
 576    case __DRI_IMAGE_FORMAT_XRGB8888:
 577       ret = GBM_FORMAT_XRGB8888;
 578       break;
 579    case __DRI_IMAGE_FORMAT_ARGB8888:
 580       ret = GBM_FORMAT_ARGB8888;
 581       break;
 582    case __DRI_IMAGE_FORMAT_ABGR8888:
 583       ret = GBM_FORMAT_ABGR8888;
 584       break;
 585    default:
 586       ret = 0;
 587       break;
 588    }
 589
 590    return ret;
 591 }
 592
 593 static struct gbm_bo *
 594 gbm_dri_bo_import(struct gbm_device *gbm,
 595                   uint32_t type, void *buffer, uint32_t usage)
 596 {
 597    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 598    struct gbm_dri_bo *bo;
 599    __DRIimage *image;
 600    unsigned dri_use = 0;
 601    int gbm_format;
 602
 603    /* Required for query image WIDTH & HEIGHT */
 604    if (dri->image == NULL || dri->image->base.version < 4) {
 605       errno = ENOSYS;
 606       return NULL;
 607    }
 608
 609    switch (type) {
 610 #if HAVE_WAYLAND_PLATFORM
 611    case GBM_BO_IMPORT_WL_BUFFER:
 612    {
 613       struct wl_drm_buffer *wb;
 614
 615       if (!dri->wl_drm) {
 616          errno = EINVAL;
 617          return NULL;
 618       }
 619
 620       wb = wayland_drm_buffer_get(dri->wl_drm, (struct wl_resource *) buffer);
 621       if (!wb) {
 622          errno = EINVAL;
 623          return NULL;
 624       }
 625
 626       image = dri->image->dupImage(wb->driver_buffer, NULL);
 627
 628       switch (wb->format) {
 629       case WL_DRM_FORMAT_XRGB8888:
 630          gbm_format = GBM_FORMAT_XRGB8888;
 631          break;
 632       case WL_DRM_FORMAT_ARGB8888:
 633          gbm_format = GBM_FORMAT_ARGB8888;
 634          break;
 635       case WL_DRM_FORMAT_RGB565:
 636          gbm_format = GBM_FORMAT_RGB565;
 637          break;
 638       case WL_DRM_FORMAT_YUYV:
 639          gbm_format = GBM_FORMAT_YUYV;
 640          break;
 641       default:
 642          return NULL;
 643       }
 644       break;
 645    }
 646 #endif
 647
 648    case GBM_BO_IMPORT_EGL_IMAGE:
 649    {
 650       int dri_format;
 651       if (dri->lookup_image == NULL) {
 652          errno = EINVAL;
 653          return NULL;
 654       }
 655
 656       image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data);
 657       image = dri->image->dupImage(image, NULL);
 658       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format);
 659       gbm_format = gbm_dri_to_gbm_format(dri_format);
 660       if (gbm_format == 0) {
 661          errno = EINVAL;
 662          return NULL;
 663       }
 664       break;
 665    }
 666
 667    case GBM_BO_IMPORT_FD:
 668    {
 669       struct gbm_import_fd_data *fd_data = buffer;
 670       int stride = fd_data->stride, offset = 0;
 671
 672       image = dri->image->createImageFromFds(dri->screen,
 673                                              fd_data->width,
 674                                              fd_data->height,
 675                                              fd_data->format,
 676                                              &fd_data->fd, 1,
 677                                              &stride, &offset,
 678                                              NULL);
 679       gbm_format = fd_data->format;
 680       break;
 681    }
 682
 683    default:
 684       errno = ENOSYS;
 685       return NULL;
 686    }
 687
 688
 689    bo = calloc(1, sizeof *bo);
 690    if (bo == NULL)
 691       return NULL;
 692
 693    bo->image = image;
 694
 695    if (usage & GBM_BO_USE_SCANOUT)
 696       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 697    if (usage & GBM_BO_USE_CURSOR)
 698       dri_use |= __DRI_IMAGE_USE_CURSOR;
 699    if (dri->image->base.version >= 2 &&
 700        !dri->image->validateUsage(bo->image, dri_use)) {
 701       errno = EINVAL;
 702       free(bo);
 703       return NULL;
 704    }
 705
 706    bo->base.base.gbm = gbm;
 707    bo->base.base.format = gbm_format;
 708
 709    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH,
 710                           (int*)&bo->base.base.width);
 711    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT,
 712                           (int*)&bo->base.base.height);
 713    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 714                           (int*)&bo->base.base.stride);
 715    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 716                           &bo->base.base.handle.s32);
 717
 718    return &bo->base.base;
 719 }
 720
 721 static struct gbm_bo *
 722 create_dumb(struct gbm_device *gbm,
 723                   uint32_t width, uint32_t height,
 724                   uint32_t format, uint32_t usage)
 725 {
 726    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 727    struct drm_mode_create_dumb create_arg;
 728    struct gbm_dri_bo *bo;
 729    struct drm_mode_destroy_dumb destroy_arg;
 730    int ret;
 731    int is_cursor, is_scanout;
 732
 733    is_cursor = (usage & GBM_BO_USE_CURSOR) != 0 &&
 734       format == GBM_FORMAT_ARGB8888;
 735    is_scanout = (usage & GBM_BO_USE_SCANOUT) != 0 &&
 736       format == GBM_FORMAT_XRGB8888;
 737    if (!is_cursor && !is_scanout) {
 738       errno = EINVAL;
 739       return NULL;
 740    }
 741
 742    bo = calloc(1, sizeof *bo);
 743    if (bo == NULL)
 744       return NULL;
 745
 746    create_arg.bpp = 32;
 747    create_arg.width = width;
 748    create_arg.height = height;
 749
 750    ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
 751    if (ret)
 752       goto free_bo;
 753
 754    bo->base.base.gbm = gbm;
 755    bo->base.base.width = width;
 756    bo->base.base.height = height;
 757    bo->base.base.stride = create_arg.pitch;
 758    bo->base.base.format = format;
 759    bo->base.base.handle.u32 = create_arg.handle;
 760    bo->handle = create_arg.handle;
 761    bo->size = create_arg.size;
 762
 763    if (gbm_dri_bo_map(bo) == NULL)
 764       goto destroy_dumb;
 765
 766    return &bo->base.base;
 767
 768 destroy_dumb:
 769    memset(&destroy_arg, 0, sizeof destroy_arg);
 770    destroy_arg.handle = create_arg.handle;
 771    drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
 772 free_bo:
 773    free(bo);
 774
 775    return NULL;
 776 }
 777
 778 static struct gbm_bo *
 779 gbm_dri_bo_create(struct gbm_device *gbm,
 780                   uint32_t width, uint32_t height,
 781                   uint32_t format, uint32_t usage)
 782 {
 783    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 784    struct gbm_dri_bo *bo;
 785    int dri_format;
 786    unsigned dri_use = 0;
 787
 788    if (usage & GBM_BO_USE_WRITE || dri->image == NULL)
 789       return create_dumb(gbm, width, height, format, usage);
 790
 791    bo = calloc(1, sizeof *bo);
 792    if (bo == NULL)
 793       return NULL;
 794
 795    bo->base.base.gbm = gbm;
 796    bo->base.base.width = width;
 797    bo->base.base.height = height;
 798    bo->base.base.format = format;
 799
 800    switch (format) {
 801    case GBM_FORMAT_RGB565:
 802       dri_format =__DRI_IMAGE_FORMAT_RGB565;
 803       break;
 804    case GBM_FORMAT_XRGB8888:
 805    case GBM_BO_FORMAT_XRGB8888:
 806       dri_format = __DRI_IMAGE_FORMAT_XRGB8888;
 807       break;
 808    case GBM_FORMAT_ARGB8888:
 809    case GBM_BO_FORMAT_ARGB8888:
 810       dri_format = __DRI_IMAGE_FORMAT_ARGB8888;
 811       break;
 812    case GBM_FORMAT_ABGR8888:
 813       dri_format = __DRI_IMAGE_FORMAT_ABGR8888;
 814       break;
 815    case GBM_FORMAT_ARGB2101010:
 816       dri_format = __DRI_IMAGE_FORMAT_ARGB2101010;
 817       break;
 818    case GBM_FORMAT_XRGB2101010:
 819       dri_format = __DRI_IMAGE_FORMAT_XRGB2101010;
 820       break;
 821    default:
 822       errno = EINVAL;
 823       goto failed;
 824    }
 825
 826    if (usage & GBM_BO_USE_SCANOUT)
 827       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 828    if (usage & GBM_BO_USE_CURSOR)
 829       dri_use |= __DRI_IMAGE_USE_CURSOR;
 830
 831    /* Gallium drivers requires shared in order to get the handle/stride */
 832    dri_use |= __DRI_IMAGE_USE_SHARE;
 833
 834    bo->image =
 835       dri->image->createImage(dri->screen,
 836                               width, height,
 837                               dri_format, dri_use,
 838                               bo);
 839    if (bo->image == NULL)
 840       goto failed;
 841
 842    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 843                           &bo->base.base.handle.s32);
 844    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 845                           (int *) &bo->base.base.stride);
 846
 847    return &bo->base.base;
 848
 849 failed:
 850    free(bo);
 851    return NULL;
 852 }
 853
 854 static struct gbm_surface *
 855 gbm_dri_surface_create(struct gbm_device *gbm,
 856                        uint32_t width, uint32_t height,
 857                        uint32_t format, uint32_t flags)
 858 {
 859    struct gbm_dri_surface *surf;
 860
 861    surf = calloc(1, sizeof *surf);
 862    if (surf == NULL)
 863       return NULL;
 864
 865    surf->base.gbm = gbm;
 866    surf->base.width = width;
 867    surf->base.height = height;
 868    surf->base.format = format;
 869    surf->base.flags = flags;
 870
 871    return &surf->base;
 872 }
 873
 874 static void
 875 gbm_dri_surface_destroy(struct gbm_surface *_surf)
 876 {
 877    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
 878
 879    free(surf);
 880 }
 881
 882 static void
 883 dri_destroy(struct gbm_device *gbm)
 884 {
 885    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 886
 887    dri->core->destroyScreen(dri->screen);
 888    free(dri->driver_configs);
 889    dlclose(dri->driver);
 890    free(dri->base.driver_name);
 891
 892    free(dri);
 893 }
 894
 895 static struct gbm_device *
 896 dri_device_create(int fd)
 897 {
 898    struct gbm_dri_device *dri;
 899    int ret, force_sw;
 900
 901    dri = calloc(1, sizeof *dri);
 902    if (!dri)
 903       return NULL;
 904
 905    dri->base.base.fd = fd;
 906    dri->base.base.bo_create = gbm_dri_bo_create;
 907    dri->base.base.bo_import = gbm_dri_bo_import;
 908    dri->base.base.is_format_supported = gbm_dri_is_format_supported;
 909    dri->base.base.bo_write = gbm_dri_bo_write;
 910    dri->base.base.bo_get_fd = gbm_dri_bo_get_fd;
 911    dri->base.base.bo_destroy = gbm_dri_bo_destroy;
 912    dri->base.base.destroy = dri_destroy;
 913    dri->base.base.surface_create = gbm_dri_surface_create;
 914    dri->base.base.surface_destroy = gbm_dri_surface_destroy;
 915
 916    dri->base.type = GBM_DRM_DRIVER_TYPE_DRI;
 917    dri->base.base.name = "drm";
 918
 919    force_sw = getenv("GBM_ALWAYS_SOFTWARE") != NULL;
 920    if (!force_sw) {
 921       ret = dri_screen_create(dri);
 922       if (ret)
 923          ret = dri_screen_create_swrast(dri);
 924    } else {
 925       ret = dri_screen_create_swrast(dri);
 926    }
 927
 928    if (ret)
 929       goto err_dri;
 930
 931    return &dri->base.base;
 932
 933 err_dri:
 934    free(dri);
 935
 936    return NULL;
 937 }
 938
 939 struct gbm_backend gbm_dri_backend = {
 940    .backend_name = "dri",
 941    .create_device = dri_device_create,
 942 };