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 <stdbool.h>
  33 #include <string.h>
  34 #include <errno.h>
  35 #include <limits.h>
  36 #include <assert.h>
  37
  38 #include <sys/types.h>
  39 #include <unistd.h>
  40 #include <dlfcn.h>
  41 #include <xf86drm.h>
  42 #include <drm_fourcc.h>
  43
  44 #include <GL/gl.h> /* dri_interface needs GL types */
  45 #include <GL/internal/dri_interface.h>
  46
  47 #include "gbm_driint.h"
  48
  49 #include "gbmint.h"
  50 #include "loader.h"
  51 #include "util/debug.h"
  52 #include "util/macros.h"
  53
  54 /* For importing wl_buffer */
  55 #if HAVE_WAYLAND_PLATFORM
  56 #include "wayland-drm.h"
  57 #endif
  58
  59 #ifndef DRM_FORMAT_MOD_INVALID
  60 #define DRM_FORMAT_MOD_INVALID ((1ULL<<56) - 1)
  61 #endif
  62
  63 #ifndef DRM_FORMAT_MOD_LINEAR
  64 #define DRM_FORMAT_MOD_LINEAR 0
  65 #endif
  66
  67 static __DRIimage *
  68 dri_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
  69 {
  70    struct gbm_dri_device *dri = data;
  71
  72    if (dri->lookup_image == NULL)
  73       return NULL;
  74
  75    return dri->lookup_image(screen, image, dri->lookup_user_data);
  76 }
  77
  78 static __DRIbuffer *
  79 dri_get_buffers(__DRIdrawable * driDrawable,
  80                  int *width, int *height,
  81                  unsigned int *attachments, int count,
  82                  int *out_count, 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->get_buffers == NULL)
  88       return NULL;
  89
  90    return dri->get_buffers(driDrawable, width, height, attachments,
  91                            count, out_count, surf->dri_private);
  92 }
  93
  94 static void
  95 dri_flush_front_buffer(__DRIdrawable * driDrawable, 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->flush_front_buffer != NULL)
 101       dri->flush_front_buffer(driDrawable, surf->dri_private);
 102 }
 103
 104 static __DRIbuffer *
 105 dri_get_buffers_with_format(__DRIdrawable * driDrawable,
 106                             int *width, int *height,
 107                             unsigned int *attachments, int count,
 108                             int *out_count, void *data)
 109 {
 110    struct gbm_dri_surface *surf = data;
 111    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 112
 113    if (dri->get_buffers_with_format == NULL)
 114       return NULL;
 115
 116    return
 117       dri->get_buffers_with_format(driDrawable, width, height, attachments,
 118                                    count, out_count, surf->dri_private);
 119 }
 120
 121 static int
 122 image_get_buffers(__DRIdrawable *driDrawable,
 123                   unsigned int format,
 124                   uint32_t *stamp,
 125                   void *loaderPrivate,
 126                   uint32_t buffer_mask,
 127                   struct __DRIimageList *buffers)
 128 {
 129    struct gbm_dri_surface *surf = loaderPrivate;
 130    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 131
 132    if (dri->image_get_buffers == NULL)
 133       return 0;
 134
 135    return dri->image_get_buffers(driDrawable, format, stamp,
 136                                  surf->dri_private, buffer_mask, buffers);
 137 }
 138
 139 static void
 140 swrast_get_drawable_info(__DRIdrawable *driDrawable,
 141                          int           *x,
 142                          int           *y,
 143                          int           *width,
 144                          int           *height,
 145                          void          *loaderPrivate)
 146 {
 147    struct gbm_dri_surface *surf = loaderPrivate;
 148
 149    *x = 0;
 150    *y = 0;
 151    *width = surf->base.width;
 152    *height = surf->base.height;
 153 }
 154
 155 static void
 156 swrast_put_image2(__DRIdrawable *driDrawable,
 157                   int            op,
 158                   int            x,
 159                   int            y,
 160                   int            width,
 161                   int            height,
 162                   int            stride,
 163                   char          *data,
 164                   void          *loaderPrivate)
 165 {
 166    struct gbm_dri_surface *surf = loaderPrivate;
 167    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 168
 169    dri->swrast_put_image2(driDrawable,
 170                           op, x, y,
 171                           width, height, stride,
 172                           data, surf->dri_private);
 173 }
 174
 175 static void
 176 swrast_put_image(__DRIdrawable *driDrawable,
 177                  int            op,
 178                  int            x,
 179                  int            y,
 180                  int            width,
 181                  int            height,
 182                  char          *data,
 183                  void          *loaderPrivate)
 184 {
 185    return swrast_put_image2(driDrawable, op, x, y, width, height,
 186                             width * 4, data, loaderPrivate);
 187 }
 188
 189 static void
 190 swrast_get_image(__DRIdrawable *driDrawable,
 191                  int            x,
 192                  int            y,
 193                  int            width,
 194                  int            height,
 195                  char          *data,
 196                  void          *loaderPrivate)
 197 {
 198    struct gbm_dri_surface *surf = loaderPrivate;
 199    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 200
 201    dri->swrast_get_image(driDrawable,
 202                          x, y,
 203                          width, height,
 204                          data, surf->dri_private);
 205 }
 206
 207 static const __DRIuseInvalidateExtension use_invalidate = {
 208    .base = { __DRI_USE_INVALIDATE, 1 }
 209 };
 210
 211 static const __DRIimageLookupExtension image_lookup_extension = {
 212    .base = { __DRI_IMAGE_LOOKUP, 1 },
 213
 214    .lookupEGLImage          = dri_lookup_egl_image
 215 };
 216
 217 static const __DRIdri2LoaderExtension dri2_loader_extension = {
 218    .base = { __DRI_DRI2_LOADER, 3 },
 219
 220    .getBuffers              = dri_get_buffers,
 221    .flushFrontBuffer        = dri_flush_front_buffer,
 222    .getBuffersWithFormat    = dri_get_buffers_with_format,
 223 };
 224
 225 static const __DRIimageLoaderExtension image_loader_extension = {
 226    .base = { __DRI_IMAGE_LOADER, 1 },
 227
 228    .getBuffers          = image_get_buffers,
 229    .flushFrontBuffer    = dri_flush_front_buffer,
 230 };
 231
 232 static const __DRIswrastLoaderExtension swrast_loader_extension = {
 233    .base = { __DRI_SWRAST_LOADER, 2 },
 234
 235    .getDrawableInfo = swrast_get_drawable_info,
 236    .putImage        = swrast_put_image,
 237    .getImage        = swrast_get_image,
 238    .putImage2       = swrast_put_image2
 239 };
 240
 241 static const __DRIextension *gbm_dri_screen_extensions[] = {
 242    &image_lookup_extension.base,
 243    &use_invalidate.base,
 244    &dri2_loader_extension.base,
 245    &image_loader_extension.base,
 246    &swrast_loader_extension.base,
 247    NULL,
 248 };
 249
 250 struct dri_extension_match {
 251    const char *name;
 252    int version;
 253    int offset;
 254    int optional;
 255 };
 256
 257 static struct dri_extension_match dri_core_extensions[] = {
 258    { __DRI2_FLUSH, 1, offsetof(struct gbm_dri_device, flush) },
 259    { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) },
 260    { __DRI2_FENCE, 1, offsetof(struct gbm_dri_device, fence), 1 },
 261    { NULL, 0, 0 }
 262 };
 263
 264 static struct dri_extension_match gbm_dri_device_extensions[] = {
 265    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) },
 266    { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) },
 267    { NULL, 0, 0 }
 268 };
 269
 270 static struct dri_extension_match gbm_swrast_device_extensions[] = {
 271    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core), },
 272    { __DRI_SWRAST, 1, offsetof(struct gbm_dri_device, swrast) },
 273    { NULL, 0, 0 }
 274 };
 275
 276 static int
 277 dri_bind_extensions(struct gbm_dri_device *dri,
 278                     struct dri_extension_match *matches,
 279                     const __DRIextension **extensions)
 280 {
 281    int i, j, ret = 0;
 282    void *field;
 283
 284    for (i = 0; extensions[i]; i++) {
 285       for (j = 0; matches[j].name; j++) {
 286          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
 287              extensions[i]->version >= matches[j].version) {
 288             field = ((char *) dri + matches[j].offset);
 289             *(const __DRIextension **) field = extensions[i];
 290          }
 291       }
 292    }
 293
 294    for (j = 0; matches[j].name; j++) {
 295       field = ((char *) dri + matches[j].offset);
 296       if ((*(const __DRIextension **) field == NULL) && !matches[j].optional) {
 297          ret = -1;
 298       }
 299    }
 300
 301    return ret;
 302 }
 303
 304 static const __DRIextension **
 305 dri_open_driver(struct gbm_dri_device *dri)
 306 {
 307    const __DRIextension **extensions = NULL;
 308    char path[PATH_MAX], *search_paths, *p, *next, *end;
 309    char *get_extensions_name;
 310
 311    search_paths = NULL;
 312    /* don't allow setuid apps to use LIBGL_DRIVERS_PATH or GBM_DRIVERS_PATH */
 313    if (geteuid() == getuid()) {
 314       /* Read GBM_DRIVERS_PATH first for compatibility, but LIBGL_DRIVERS_PATH
 315        * is recommended over GBM_DRIVERS_PATH.
 316        */
 317       search_paths = getenv("GBM_DRIVERS_PATH");
 318
 319       /* Read LIBGL_DRIVERS_PATH if GBM_DRIVERS_PATH was not set.
 320        * LIBGL_DRIVERS_PATH is recommended over GBM_DRIVERS_PATH.
 321        */
 322       if (search_paths == NULL) {
 323          search_paths = getenv("LIBGL_DRIVERS_PATH");
 324       }
 325    }
 326    if (search_paths == NULL)
 327       search_paths = DEFAULT_DRIVER_DIR;
 328
 329    /* Temporarily work around dri driver libs that need symbols in libglapi
 330     * but don't automatically link it in.
 331     */
 332    /* XXX: Library name differs on per platforms basis. Update this as
 333     * osx/cygwin/windows/bsd gets support for GBM..
 334     */
 335    dlopen("libglapi.so.0", RTLD_LAZY | RTLD_GLOBAL);
 336
 337    dri->driver = NULL;
 338    end = search_paths + strlen(search_paths);
 339    for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) {
 340       int len;
 341       next = strchr(p, ':');
 342       if (next == NULL)
 343          next = end;
 344
 345       len = next - p;
 346 #if GLX_USE_TLS
 347       snprintf(path, sizeof path,
 348                "%.*s/tls/%s_dri.so", len, p, dri->driver_name);
 349       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 350 #endif
 351       if (dri->driver == NULL) {
 352          snprintf(path, sizeof path,
 353                   "%.*s/%s_dri.so", len, p, dri->driver_name);
 354          dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 355       }
 356       /* not need continue to loop all paths once the driver is found */
 357       if (dri->driver != NULL)
 358          break;
 359    }
 360
 361    if (dri->driver == NULL) {
 362       fprintf(stderr, "gbm: failed to open any driver (search paths %s)\n",
 363               search_paths);
 364       fprintf(stderr, "gbm: Last dlopen error: %s\n", dlerror());
 365       return NULL;
 366    }
 367
 368    get_extensions_name = loader_get_extensions_name(dri->driver_name);
 369    if (get_extensions_name) {
 370       const __DRIextension **(*get_extensions)(void);
 371
 372       get_extensions = dlsym(dri->driver, get_extensions_name);
 373       free(get_extensions_name);
 374
 375       if (get_extensions)
 376          extensions = get_extensions();
 377    }
 378
 379    if (!extensions)
 380       extensions = dlsym(dri->driver, __DRI_DRIVER_EXTENSIONS);
 381    if (extensions == NULL) {
 382       fprintf(stderr, "gbm: driver exports no extensions (%s)", dlerror());
 383       dlclose(dri->driver);
 384    }
 385
 386    return extensions;
 387 }
 388
 389 static int
 390 dri_load_driver(struct gbm_dri_device *dri)
 391 {
 392    const __DRIextension **extensions;
 393
 394    extensions = dri_open_driver(dri);
 395    if (!extensions)
 396       return -1;
 397
 398    if (dri_bind_extensions(dri, gbm_dri_device_extensions, extensions) < 0) {
 399       dlclose(dri->driver);
 400       fprintf(stderr, "failed to bind extensions\n");
 401       return -1;
 402    }
 403
 404    dri->driver_extensions = extensions;
 405
 406    return 0;
 407 }
 408
 409 static int
 410 dri_load_driver_swrast(struct gbm_dri_device *dri)
 411 {
 412    const __DRIextension **extensions;
 413
 414    extensions = dri_open_driver(dri);
 415    if (!extensions)
 416       return -1;
 417
 418    if (dri_bind_extensions(dri, gbm_swrast_device_extensions, extensions) < 0) {
 419       dlclose(dri->driver);
 420       fprintf(stderr, "failed to bind extensions\n");
 421       return -1;
 422    }
 423
 424    dri->driver_extensions = extensions;
 425
 426    return 0;
 427 }
 428
 429 static int
 430 dri_screen_create_dri2(struct gbm_dri_device *dri, char *driver_name)
 431 {
 432    const __DRIextension **extensions;
 433    int ret = 0;
 434
 435    dri->driver_name = driver_name;
 436    if (dri->driver_name == NULL)
 437       return -1;
 438
 439    ret = dri_load_driver(dri);
 440    if (ret) {
 441       fprintf(stderr, "failed to load driver: %s\n", dri->driver_name);
 442       return ret;
 443    }
 444
 445    dri->loader_extensions = gbm_dri_screen_extensions;
 446
 447    if (dri->dri2 == NULL)
 448       return -1;
 449
 450    if (dri->dri2->base.version >= 4) {
 451       dri->screen = dri->dri2->createNewScreen2(0, dri->base.fd,
 452                                                 dri->loader_extensions,
 453                                                 dri->driver_extensions,
 454                                                 &dri->driver_configs, dri);
 455    } else {
 456       dri->screen = dri->dri2->createNewScreen(0, dri->base.fd,
 457                                                dri->loader_extensions,
 458                                                &dri->driver_configs, dri);
 459    }
 460    if (dri->screen == NULL)
 461       return -1;
 462
 463    extensions = dri->core->getExtensions(dri->screen);
 464    if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) {
 465       ret = -1;
 466       goto free_screen;
 467    }
 468
 469    dri->lookup_image = NULL;
 470    dri->lookup_user_data = NULL;
 471
 472    return 0;
 473
 474 free_screen:
 475    dri->core->destroyScreen(dri->screen);
 476
 477    return ret;
 478 }
 479
 480 static int
 481 dri_screen_create_swrast(struct gbm_dri_device *dri)
 482 {
 483    int ret;
 484
 485    dri->driver_name = strdup("swrast");
 486    if (dri->driver_name == NULL)
 487       return -1;
 488
 489    ret = dri_load_driver_swrast(dri);
 490    if (ret) {
 491       fprintf(stderr, "failed to load swrast driver\n");
 492       return ret;
 493    }
 494
 495    dri->loader_extensions = gbm_dri_screen_extensions;
 496
 497    if (dri->swrast == NULL)
 498       return -1;
 499
 500    if (dri->swrast->base.version >= 4) {
 501       dri->screen = dri->swrast->createNewScreen2(0, dri->loader_extensions,
 502                                                   dri->driver_extensions,
 503                                                   &dri->driver_configs, dri);
 504    } else {
 505       dri->screen = dri->swrast->createNewScreen(0, dri->loader_extensions,
 506                                                  &dri->driver_configs, dri);
 507    }
 508    if (dri->screen == NULL)
 509       return -1;
 510
 511    dri->lookup_image = NULL;
 512    dri->lookup_user_data = NULL;
 513
 514    return 0;
 515 }
 516
 517 static int
 518 dri_screen_create(struct gbm_dri_device *dri)
 519 {
 520    char *driver_name;
 521
 522    driver_name = loader_get_driver_for_fd(dri->base.fd);
 523    if (!driver_name)
 524       return -1;
 525
 526    return dri_screen_create_dri2(dri, driver_name);
 527 }
 528
 529 static int
 530 dri_screen_create_sw(struct gbm_dri_device *dri)
 531 {
 532    char *driver_name;
 533    int ret;
 534
 535    driver_name = strdup("kms_swrast");
 536    if (!driver_name)
 537       return -errno;
 538
 539    ret = dri_screen_create_dri2(dri, driver_name);
 540    if (ret == 0)
 541       return ret;
 542
 543    return dri_screen_create_swrast(dri);
 544 }
 545
 546 static const struct gbm_dri_visual gbm_dri_visuals_table[] = {
 547    {
 548      GBM_FORMAT_R8, __DRI_IMAGE_FORMAT_R8,
 549      { 0x000000ff, 0x00000000, 0x00000000, 0x00000000 },
 550    },
 551    {
 552      GBM_FORMAT_GR88, __DRI_IMAGE_FORMAT_GR88,
 553      { 0x000000ff, 0x0000ff00, 0x00000000, 0x00000000 },
 554    },
 555    {
 556      GBM_FORMAT_RGB565, __DRI_IMAGE_FORMAT_RGB565,
 557      { 0x0000f800, 0x000007e0, 0x0000001f, 0x00000000 },
 558    },
 559    {
 560      GBM_FORMAT_XRGB8888, __DRI_IMAGE_FORMAT_XRGB8888,
 561      { 0x00ff0000, 0x0000ff00, 0x000000ff, 0x00000000 },
 562    },
 563    {
 564      GBM_FORMAT_ARGB8888, __DRI_IMAGE_FORMAT_ARGB8888,
 565      { 0x00ff0000, 0x0000ff00, 0x000000ff, 0x000000ff },
 566    },
 567    {
 568      GBM_FORMAT_XBGR8888, __DRI_IMAGE_FORMAT_XBGR8888,
 569      { 0x000000ff, 0x0000ff00, 0x00ff0000, 0x00000000 },
 570    },
 571    {
 572      GBM_FORMAT_ABGR8888, __DRI_IMAGE_FORMAT_ABGR8888,
 573      { 0x000000ff, 0x0000ff00, 0x00ff0000, 0x000000ff },
 574    },
 575    {
 576      GBM_FORMAT_XRGB2101010, __DRI_IMAGE_FORMAT_XRGB2101010,
 577      { 0x3ff00000, 0x000ffc00, 0x000003ff, 0x00000000 },
 578    },
 579    {
 580      GBM_FORMAT_ARGB2101010, __DRI_IMAGE_FORMAT_ARGB2101010,
 581      { 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000 },
 582    },
 583 };
 584
 585 /* The two GBM_BO_FORMAT_[XA]RGB8888 formats alias the GBM_FORMAT_*
 586  * formats of the same name. We want to accept them whenever someone
 587  * has a GBM format, but never return them to the user. */
 588 static int
 589 gbm_format_canonicalize(uint32_t gbm_format)
 590 {
 591    switch (gbm_format) {
 592    case GBM_BO_FORMAT_XRGB8888:
 593       return GBM_FORMAT_XRGB8888;
 594    case GBM_BO_FORMAT_ARGB8888:
 595       return GBM_FORMAT_ARGB8888;
 596    default:
 597       return gbm_format;
 598    }
 599 }
 600
 601 static int
 602 gbm_format_to_dri_format(uint32_t gbm_format)
 603 {
 604    int i;
 605
 606    gbm_format = gbm_format_canonicalize(gbm_format);
 607    for (i = 0; i < ARRAY_SIZE(gbm_dri_visuals_table); i++) {
 608       if (gbm_dri_visuals_table[i].gbm_format == gbm_format)
 609          return gbm_dri_visuals_table[i].dri_image_format;
 610    }
 611
 612    return 0;
 613 }
 614
 615 static uint32_t
 616 gbm_dri_to_gbm_format(int dri_format)
 617 {
 618    int i;
 619
 620    for (i = 0; i < ARRAY_SIZE(gbm_dri_visuals_table); i++) {
 621       if (gbm_dri_visuals_table[i].dri_image_format == dri_format)
 622          return gbm_dri_visuals_table[i].gbm_format;
 623    }
 624
 625    return 0;
 626 }
 627
 628 static int
 629 gbm_dri_is_format_supported(struct gbm_device *gbm,
 630                             uint32_t format,
 631                             uint32_t usage)
 632 {
 633    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 634    int count;
 635
 636    if ((usage & GBM_BO_USE_CURSOR) && (usage & GBM_BO_USE_RENDERING))
 637       return 0;
 638
 639    format = gbm_format_canonicalize(format);
 640    if (gbm_format_to_dri_format(format) == 0)
 641       return 0;
 642
 643    /* If there is no query, fall back to the small table which was originally
 644     * here. */
 645    if (dri->image->base.version <= 15 || !dri->image->queryDmaBufModifiers) {
 646       switch (format) {
 647       case GBM_FORMAT_XRGB8888:
 648       case GBM_FORMAT_ARGB8888:
 649       case GBM_FORMAT_XBGR8888:
 650          return 1;
 651       default:
 652          return 0;
 653       }
 654    }
 655
 656    /* Check if the driver returns any modifiers for this format; since linear
 657     * is counted as a modifier, we will have at least one modifier for any
 658     * supported format. */
 659    if (!dri->image->queryDmaBufModifiers(dri->screen, format, 0, NULL, NULL,
 660                                          &count))
 661       return 0;
 662
 663    return (count > 0);
 664 }
 665
 666 static int
 667 gbm_dri_get_format_modifier_plane_count(struct gbm_device *gbm,
 668                                         uint32_t format,
 669                                         uint64_t modifier)
 670 {
 671    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 672    uint64_t plane_count;
 673
 674    if (dri->image->base.version < 16 ||
 675        !dri->image->queryDmaBufFormatModifierAttribs)
 676       return -1;
 677
 678    format = gbm_format_canonicalize(format);
 679    if (gbm_format_to_dri_format(format) == 0)
 680       return -1;
 681
 682    if (!dri->image->queryDmaBufFormatModifierAttribs(
 683          dri->screen, format, modifier,
 684          __DRI_IMAGE_FORMAT_MODIFIER_ATTRIB_PLANE_COUNT, &plane_count))
 685       return -1;
 686
 687    return plane_count;
 688 }
 689
 690 static int
 691 gbm_dri_bo_write(struct gbm_bo *_bo, const void *buf, size_t count)
 692 {
 693    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 694
 695    if (bo->image != NULL) {
 696       errno = EINVAL;
 697       return -1;
 698    }
 699
 700    memcpy(bo->map, buf, count);
 701
 702    return 0;
 703 }
 704
 705 static int
 706 gbm_dri_bo_get_fd(struct gbm_bo *_bo)
 707 {
 708    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 709    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 710    int fd;
 711
 712    if (bo->image == NULL)
 713       return -1;
 714
 715    if (!dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_FD, &fd))
 716       return -1;
 717
 718    return fd;
 719 }
 720
 721 static int
 722 get_number_planes(struct gbm_dri_device *dri, __DRIimage *image)
 723 {
 724    int num_planes = 0;
 725
 726    /* Dumb buffers are single-plane only. */
 727    if (!image)
 728       return 1;
 729
 730    dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_NUM_PLANES, &num_planes);
 731
 732    if (num_planes <= 0)
 733       num_planes = 1;
 734
 735    return num_planes;
 736 }
 737
 738 static int
 739 gbm_dri_bo_get_planes(struct gbm_bo *_bo)
 740 {
 741    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 742    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 743
 744    return get_number_planes(dri, bo->image);
 745 }
 746
 747 static union gbm_bo_handle
 748 gbm_dri_bo_get_handle_for_plane(struct gbm_bo *_bo, int plane)
 749 {
 750    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 751    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 752    union gbm_bo_handle ret;
 753    ret.s32 = -1;
 754
 755    if (!dri->image || dri->image->base.version < 13 || !dri->image->fromPlanar) {
 756       errno = ENOSYS;
 757       return ret;
 758    }
 759
 760    if (plane >= get_number_planes(dri, bo->image)) {
 761       errno = EINVAL;
 762       return ret;
 763    }
 764
 765    /* dumb BOs can only utilize non-planar formats */
 766    if (!bo->image) {
 767       assert(plane == 0);
 768       ret.s32 = bo->handle;
 769       return ret;
 770    }
 771
 772    __DRIimage *image = dri->image->fromPlanar(bo->image, plane, NULL);
 773    if (image) {
 774       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_HANDLE, &ret.s32);
 775       dri->image->destroyImage(image);
 776    } else {
 777       assert(plane == 0);
 778       dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE, &ret.s32);
 779    }
 780
 781    return ret;
 782 }
 783
 784 static uint32_t
 785 gbm_dri_bo_get_stride(struct gbm_bo *_bo, int plane)
 786 {
 787    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 788    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 789    __DRIimage *image;
 790    int stride = 0;
 791
 792    if (!dri->image || dri->image->base.version < 11 || !dri->image->fromPlanar) {
 793       /* Preserve legacy behavior if plane is 0 */
 794       if (plane == 0)
 795          return _bo->stride;
 796
 797       errno = ENOSYS;
 798       return 0;
 799    }
 800
 801    if (plane >= get_number_planes(dri, bo->image)) {
 802       errno = EINVAL;
 803       return 0;
 804    }
 805
 806    if (bo->image == NULL) {
 807       assert(plane == 0);
 808       return _bo->stride;
 809    }
 810
 811    image = dri->image->fromPlanar(bo->image, plane, NULL);
 812    if (image) {
 813       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_STRIDE, &stride);
 814       dri->image->destroyImage(image);
 815    } else {
 816       assert(plane == 0);
 817       dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, &stride);
 818    }
 819
 820    return (uint32_t)stride;
 821 }
 822
 823 static uint32_t
 824 gbm_dri_bo_get_offset(struct gbm_bo *_bo, int plane)
 825 {
 826    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 827    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 828    int offset = 0;
 829
 830    /* These error cases do not actually return an error code, as the user
 831     * will also fail to obtain the handle/FD from the BO. In that case, the
 832     * offset is irrelevant, as they have no buffer to offset into, so
 833     * returning 0 is harmless.
 834     */
 835    if (!dri->image || dri->image->base.version < 13 || !dri->image->fromPlanar)
 836       return 0;
 837
 838    if (plane >= get_number_planes(dri, bo->image))
 839       return 0;
 840
 841     /* Dumb images have no offset */
 842    if (bo->image == NULL) {
 843       assert(plane == 0);
 844       return 0;
 845    }
 846
 847    __DRIimage *image = dri->image->fromPlanar(bo->image, plane, NULL);
 848    if (image) {
 849       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_OFFSET, &offset);
 850       dri->image->destroyImage(image);
 851    } else {
 852       assert(plane == 0);
 853       dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_OFFSET, &offset);
 854    }
 855
 856    return (uint32_t)offset;
 857 }
 858
 859 static uint64_t
 860 gbm_dri_bo_get_modifier(struct gbm_bo *_bo)
 861 {
 862    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 863    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 864
 865    if (!dri->image || dri->image->base.version < 14) {
 866       errno = ENOSYS;
 867       return DRM_FORMAT_MOD_INVALID;
 868    }
 869
 870    /* Dumb buffers have no modifiers */
 871    if (!bo->image)
 872       return DRM_FORMAT_MOD_LINEAR;
 873
 874    uint64_t ret = 0;
 875    int mod;
 876    if (!dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_MODIFIER_UPPER,
 877                                &mod))
 878       return DRM_FORMAT_MOD_INVALID;
 879
 880    ret = (uint64_t)mod << 32;
 881
 882    if (!dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_MODIFIER_LOWER,
 883                                &mod))
 884       return DRM_FORMAT_MOD_INVALID;
 885
 886    ret |= (uint64_t)(mod & 0xffffffff);
 887
 888    return ret;
 889 }
 890
 891 static void
 892 gbm_dri_bo_destroy(struct gbm_bo *_bo)
 893 {
 894    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 895    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 896    struct drm_mode_destroy_dumb arg;
 897
 898    if (bo->image != NULL) {
 899       dri->image->destroyImage(bo->image);
 900    } else {
 901       gbm_dri_bo_unmap_dumb(bo);
 902       memset(&arg, 0, sizeof(arg));
 903       arg.handle = bo->handle;
 904       drmIoctl(dri->base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
 905    }
 906
 907    free(bo);
 908 }
 909
 910 static struct gbm_bo *
 911 gbm_dri_bo_import(struct gbm_device *gbm,
 912                   uint32_t type, void *buffer, uint32_t usage)
 913 {
 914    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 915    struct gbm_dri_bo *bo;
 916    __DRIimage *image;
 917    unsigned dri_use = 0;
 918    int gbm_format;
 919
 920    /* Required for query image WIDTH & HEIGHT */
 921    if (dri->image == NULL || dri->image->base.version < 4) {
 922       errno = ENOSYS;
 923       return NULL;
 924    }
 925
 926    switch (type) {
 927 #if HAVE_WAYLAND_PLATFORM
 928    case GBM_BO_IMPORT_WL_BUFFER:
 929    {
 930       struct wl_drm_buffer *wb;
 931
 932       if (!dri->wl_drm) {
 933          errno = EINVAL;
 934          return NULL;
 935       }
 936
 937       wb = wayland_drm_buffer_get(dri->wl_drm, (struct wl_resource *) buffer);
 938       if (!wb) {
 939          errno = EINVAL;
 940          return NULL;
 941       }
 942
 943       image = dri->image->dupImage(wb->driver_buffer, NULL);
 944
 945       /* GBM_FORMAT_* is identical to WL_DRM_FORMAT_*, so no conversion
 946        * required. */
 947       gbm_format = wb->format;
 948       break;
 949    }
 950 #endif
 951
 952    case GBM_BO_IMPORT_EGL_IMAGE:
 953    {
 954       int dri_format;
 955       if (dri->lookup_image == NULL) {
 956          errno = EINVAL;
 957          return NULL;
 958       }
 959
 960       image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data);
 961       image = dri->image->dupImage(image, NULL);
 962       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format);
 963       gbm_format = gbm_dri_to_gbm_format(dri_format);
 964       if (gbm_format == 0) {
 965          errno = EINVAL;
 966          dri->image->destroyImage(image);
 967          return NULL;
 968       }
 969       break;
 970    }
 971
 972    case GBM_BO_IMPORT_FD:
 973    {
 974       struct gbm_import_fd_data *fd_data = buffer;
 975       int stride = fd_data->stride, offset = 0;
 976       int fourcc;
 977
 978       /* GBM's GBM_FORMAT_* tokens are a strict superset of the DRI FourCC
 979        * tokens accepted by createImageFromFds, except for not supporting
 980        * the sARGB format. */
 981       fourcc = gbm_format_canonicalize(fd_data->format);
 982
 983       image = dri->image->createImageFromFds(dri->screen,
 984                                              fd_data->width,
 985                                              fd_data->height,
 986                                              fourcc,
 987                                              &fd_data->fd, 1,
 988                                              &stride, &offset,
 989                                              NULL);
 990       if (image == NULL) {
 991          errno = EINVAL;
 992          return NULL;
 993       }
 994       gbm_format = fd_data->format;
 995       break;
 996    }
 997
 998    case GBM_BO_IMPORT_FD_MODIFIER:
 999    {
1000       struct gbm_import_fd_modifier_data *fd_data = buffer;
1001       unsigned int error;
1002       int fourcc;
1003
1004       /* Import with modifier requires createImageFromDmaBufs2 */
1005       if (dri->image == NULL || dri->image->base.version < 15 ||
1006           dri->image->createImageFromDmaBufs2 == NULL) {
1007          errno = ENOSYS;
1008          return NULL;
1009       }
1010
1011       /* GBM's GBM_FORMAT_* tokens are a strict superset of the DRI FourCC
1012        * tokens accepted by createImageFromDmaBufs2, except for not supporting
1013        * the sARGB format. */
1014       fourcc = gbm_format_canonicalize(fd_data->format);
1015
1016       image = dri->image->createImageFromDmaBufs2(dri->screen, fd_data->width,
1017                                                   fd_data->height, fourcc,
1018                                                   fd_data->modifier,
1019                                                   fd_data->fds,
1020                                                   fd_data->num_fds,
1021                                                   fd_data->strides,
1022                                                   fd_data->offsets,
1023                                                   0, 0, 0, 0,
1024                                                   &error, NULL);
1025       if (image == NULL) {
1026          errno = ENOSYS;
1027          return NULL;
1028       }
1029
1030       gbm_format = fourcc;
1031       break;
1032    }
1033
1034    default:
1035       errno = ENOSYS;
1036       return NULL;
1037    }
1038
1039
1040    bo = calloc(1, sizeof *bo);
1041    if (bo == NULL) {
1042       dri->image->destroyImage(image);
1043       return NULL;
1044    }
1045
1046    bo->image = image;
1047
1048    if (usage & GBM_BO_USE_SCANOUT)
1049       dri_use |= __DRI_IMAGE_USE_SCANOUT;
1050    if (usage & GBM_BO_USE_CURSOR)
1051       dri_use |= __DRI_IMAGE_USE_CURSOR;
1052    if (dri->image->base.version >= 2 &&
1053        !dri->image->validateUsage(bo->image, dri_use)) {
1054       errno = EINVAL;
1055       dri->image->destroyImage(bo->image);
1056       free(bo);
1057       return NULL;
1058    }
1059
1060    bo->base.gbm = gbm;
1061    bo->base.format = gbm_format;
1062
1063    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH,
1064                           (int*)&bo->base.width);
1065    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT,
1066                           (int*)&bo->base.height);
1067    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
1068                           (int*)&bo->base.stride);
1069    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
1070                           &bo->base.handle.s32);
1071
1072    return &bo->base;
1073 }
1074
1075 static struct gbm_bo *
1076 create_dumb(struct gbm_device *gbm,
1077                   uint32_t width, uint32_t height,
1078                   uint32_t format, uint32_t usage)
1079 {
1080    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1081    struct drm_mode_create_dumb create_arg;
1082    struct gbm_dri_bo *bo;
1083    struct drm_mode_destroy_dumb destroy_arg;
1084    int ret;
1085    int is_cursor, is_scanout;
1086
1087    is_cursor = (usage & GBM_BO_USE_CURSOR) != 0 &&
1088       format == GBM_FORMAT_ARGB8888;
1089    is_scanout = (usage & GBM_BO_USE_SCANOUT) != 0 &&
1090       (format == GBM_FORMAT_XRGB8888 || format == GBM_FORMAT_XBGR8888);
1091    if (!is_cursor && !is_scanout) {
1092       errno = EINVAL;
1093       return NULL;
1094    }
1095
1096    bo = calloc(1, sizeof *bo);
1097    if (bo == NULL)
1098       return NULL;
1099
1100    memset(&create_arg, 0, sizeof(create_arg));
1101    create_arg.bpp = 32;
1102    create_arg.width = width;
1103    create_arg.height = height;
1104
1105    ret = drmIoctl(dri->base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
1106    if (ret)
1107       goto free_bo;
1108
1109    bo->base.gbm = gbm;
1110    bo->base.width = width;
1111    bo->base.height = height;
1112    bo->base.stride = create_arg.pitch;
1113    bo->base.format = format;
1114    bo->base.handle.u32 = create_arg.handle;
1115    bo->handle = create_arg.handle;
1116    bo->size = create_arg.size;
1117
1118    if (gbm_dri_bo_map_dumb(bo) == NULL)
1119       goto destroy_dumb;
1120
1121    return &bo->base;
1122
1123 destroy_dumb:
1124    memset(&destroy_arg, 0, sizeof destroy_arg);
1125    destroy_arg.handle = create_arg.handle;
1126    drmIoctl(dri->base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
1127 free_bo:
1128    free(bo);
1129
1130    return NULL;
1131 }
1132
1133 static struct gbm_bo *
1134 gbm_dri_bo_create(struct gbm_device *gbm,
1135                   uint32_t width, uint32_t height,
1136                   uint32_t format, uint32_t usage,
1137                   const uint64_t *modifiers,
1138                   const unsigned int count)
1139 {
1140    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1141    struct gbm_dri_bo *bo;
1142    int dri_format;
1143    unsigned dri_use = 0;
1144
1145    /* Callers of this may specify a modifier, or a dri usage, but not both. The
1146     * newer modifier interface deprecates the older usage flags.
1147     */
1148    assert(!(usage && count));
1149
1150    format = gbm_format_canonicalize(format);
1151
1152    if (usage & GBM_BO_USE_WRITE || dri->image == NULL)
1153       return create_dumb(gbm, width, height, format, usage);
1154
1155    bo = calloc(1, sizeof *bo);
1156    if (bo == NULL)
1157       return NULL;
1158
1159    bo->base.gbm = gbm;
1160    bo->base.width = width;
1161    bo->base.height = height;
1162    bo->base.format = format;
1163
1164    dri_format = gbm_format_to_dri_format(format);
1165    if (dri_format == 0) {
1166       errno = EINVAL;
1167       goto failed;
1168    }
1169
1170    if (usage & GBM_BO_USE_SCANOUT)
1171       dri_use |= __DRI_IMAGE_USE_SCANOUT;
1172    if (usage & GBM_BO_USE_CURSOR)
1173       dri_use |= __DRI_IMAGE_USE_CURSOR;
1174    if (usage & GBM_BO_USE_LINEAR)
1175       dri_use |= __DRI_IMAGE_USE_LINEAR;
1176
1177    /* Gallium drivers requires shared in order to get the handle/stride */
1178    dri_use |= __DRI_IMAGE_USE_SHARE;
1179
1180    if (modifiers) {
1181       if (!dri->image || dri->image->base.version < 14 ||
1182           !dri->image->createImageWithModifiers) {
1183          fprintf(stderr, "Modifiers specified, but DRI is too old\n");
1184          errno = ENOSYS;
1185          goto failed;
1186       }
1187
1188       /* It's acceptable to create an image with INVALID modifier in the list,
1189        * but it cannot be on the only modifier (since it will certainly fail
1190        * later). While we could easily catch this after modifier creation, doing
1191        * the check here is a convenient debug check likely pointing at whatever
1192        * interface the client is using to build its modifier list.
1193        */
1194       if (count == 1 && modifiers[0] == DRM_FORMAT_MOD_INVALID) {
1195          fprintf(stderr, "Only invalid modifier specified\n");
1196          errno = EINVAL;
1197          goto failed;
1198       }
1199
1200       bo->image =
1201          dri->image->createImageWithModifiers(dri->screen,
1202                                               width, height,
1203                                               dri_format,
1204                                               modifiers, count,
1205                                               bo);
1206
1207       if (bo->image) {
1208          /* The client passed in a list of invalid modifiers */
1209          assert(gbm_dri_bo_get_modifier(&bo->base) != DRM_FORMAT_MOD_INVALID);
1210       }
1211    } else {
1212       bo->image = dri->image->createImage(dri->screen, width, height,
1213                                           dri_format, dri_use, bo);
1214    }
1215
1216    if (bo->image == NULL)
1217       goto failed;
1218
1219    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
1220                           &bo->base.handle.s32);
1221    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
1222                           (int *) &bo->base.stride);
1223
1224    return &bo->base;
1225
1226 failed:
1227    free(bo);
1228    return NULL;
1229 }
1230
1231 static void *
1232 gbm_dri_bo_map(struct gbm_bo *_bo,
1233               uint32_t x, uint32_t y,
1234               uint32_t width, uint32_t height,
1235               uint32_t flags, uint32_t *stride, void **map_data)
1236 {
1237    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
1238    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
1239
1240    /* If it's a dumb buffer, we already have a mapping */
1241    if (bo->map) {
1242       *map_data = (char *)bo->map + (bo->base.stride * y) + (x * 4);
1243       *stride = bo->base.stride;
1244       return *map_data;
1245    }
1246
1247    if (!dri->image || dri->image->base.version < 12 || !dri->image->mapImage) {
1248       errno = ENOSYS;
1249       return NULL;
1250    }
1251
1252    mtx_lock(&dri->mutex);
1253    if (!dri->context)
1254       dri->context = dri->dri2->createNewContext(dri->screen, NULL,
1255                                                  NULL, NULL);
1256    assert(dri->context);
1257    mtx_unlock(&dri->mutex);
1258
1259    /* GBM flags and DRI flags are the same, so just pass them on */
1260    return dri->image->mapImage(dri->context, bo->image, x, y,
1261                                width, height, flags, (int *)stride,
1262                                map_data);
1263 }
1264
1265 static void
1266 gbm_dri_bo_unmap(struct gbm_bo *_bo, void *map_data)
1267 {
1268    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
1269    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
1270
1271    /* Check if it's a dumb buffer and check the pointer is in range */
1272    if (bo->map) {
1273       assert(map_data >= bo->map);
1274       assert(map_data < (bo->map + bo->size));
1275       return;
1276    }
1277
1278    if (!dri->context || !dri->image ||
1279        dri->image->base.version < 12 || !dri->image->unmapImage)
1280       return;
1281
1282    dri->image->unmapImage(dri->context, bo->image, map_data);
1283
1284    /*
1285     * Not all DRI drivers use direct maps. They may queue up DMA operations
1286     * on the mapping context. Since there is no explicit gbm flush
1287     * mechanism, we need to flush here.
1288     */
1289    if (dri->flush->base.version >= 4)
1290       dri->flush->flush_with_flags(dri->context, NULL, __DRI2_FLUSH_CONTEXT, 0);
1291 }
1292
1293
1294 static struct gbm_surface *
1295 gbm_dri_surface_create(struct gbm_device *gbm,
1296                        uint32_t width, uint32_t height,
1297                        uint32_t format, uint32_t flags,
1298                        const uint64_t *modifiers, const unsigned count)
1299 {
1300    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1301    struct gbm_dri_surface *surf;
1302
1303    if (modifiers &&
1304        (!dri->image || dri->image->base.version < 14 ||
1305         !dri->image->createImageWithModifiers)) {
1306       errno = ENOSYS;
1307       return NULL;
1308    }
1309
1310    if (count)
1311       assert(modifiers);
1312
1313    /* It's acceptable to create an image with INVALID modifier in the list,
1314     * but it cannot be on the only modifier (since it will certainly fail
1315     * later). While we could easily catch this after modifier creation, doing
1316     * the check here is a convenient debug check likely pointing at whatever
1317     * interface the client is using to build its modifier list.
1318     */
1319    if (count == 1 && modifiers[0] == DRM_FORMAT_MOD_INVALID) {
1320       fprintf(stderr, "Only invalid modifier specified\n");
1321       errno = EINVAL;
1322    }
1323
1324    surf = calloc(1, sizeof *surf);
1325    if (surf == NULL) {
1326       errno = ENOMEM;
1327       return NULL;
1328    }
1329
1330    surf->base.gbm = gbm;
1331    surf->base.width = width;
1332    surf->base.height = height;
1333    surf->base.format = gbm_format_canonicalize(format);
1334    surf->base.flags = flags;
1335    if (!modifiers) {
1336       assert(!count);
1337       return &surf->base;
1338    }
1339
1340    surf->base.modifiers = calloc(count, sizeof(*modifiers));
1341    if (count && !surf->base.modifiers) {
1342       errno = ENOMEM;
1343       free(surf);
1344       return NULL;
1345    }
1346
1347    /* TODO: We are deferring validation of modifiers until the image is actually
1348     * created. This deferred creation can fail due to a modifier-format
1349     * mismatch. The result is the client has a surface but no object to back it.
1350     */
1351    surf->base.count = count;
1352    memcpy(surf->base.modifiers, modifiers, count * sizeof(*modifiers));
1353
1354    return &surf->base;
1355 }
1356
1357 static void
1358 gbm_dri_surface_destroy(struct gbm_surface *_surf)
1359 {
1360    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
1361
1362    free(surf->base.modifiers);
1363    free(surf);
1364 }
1365
1366 static void
1367 dri_destroy(struct gbm_device *gbm)
1368 {
1369    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1370    unsigned i;
1371
1372    if (dri->context)
1373       dri->core->destroyContext(dri->context);
1374
1375    dri->core->destroyScreen(dri->screen);
1376    for (i = 0; dri->driver_configs[i]; i++)
1377       free((__DRIconfig *) dri->driver_configs[i]);
1378    free(dri->driver_configs);
1379    dlclose(dri->driver);
1380    free(dri->driver_name);
1381
1382    free(dri);
1383 }
1384
1385 static struct gbm_device *
1386 dri_device_create(int fd)
1387 {
1388    struct gbm_dri_device *dri;
1389    int ret;
1390    bool force_sw;
1391
1392    dri = calloc(1, sizeof *dri);
1393    if (!dri)
1394       return NULL;
1395
1396    dri->base.fd = fd;
1397    dri->base.bo_create = gbm_dri_bo_create;
1398    dri->base.bo_import = gbm_dri_bo_import;
1399    dri->base.bo_map = gbm_dri_bo_map;
1400    dri->base.bo_unmap = gbm_dri_bo_unmap;
1401    dri->base.is_format_supported = gbm_dri_is_format_supported;
1402    dri->base.get_format_modifier_plane_count =
1403       gbm_dri_get_format_modifier_plane_count;
1404    dri->base.bo_write = gbm_dri_bo_write;
1405    dri->base.bo_get_fd = gbm_dri_bo_get_fd;
1406    dri->base.bo_get_planes = gbm_dri_bo_get_planes;
1407    dri->base.bo_get_handle = gbm_dri_bo_get_handle_for_plane;
1408    dri->base.bo_get_stride = gbm_dri_bo_get_stride;
1409    dri->base.bo_get_offset = gbm_dri_bo_get_offset;
1410    dri->base.bo_get_modifier = gbm_dri_bo_get_modifier;
1411    dri->base.bo_destroy = gbm_dri_bo_destroy;
1412    dri->base.destroy = dri_destroy;
1413    dri->base.surface_create = gbm_dri_surface_create;
1414    dri->base.surface_destroy = gbm_dri_surface_destroy;
1415
1416    dri->base.name = "drm";
1417
1418    dri->visual_table = gbm_dri_visuals_table;
1419    dri->num_visuals = ARRAY_SIZE(gbm_dri_visuals_table);
1420
1421    mtx_init(&dri->mutex, mtx_plain);
1422
1423    force_sw = env_var_as_boolean("GBM_ALWAYS_SOFTWARE", false);
1424    if (!force_sw) {
1425       ret = dri_screen_create(dri);
1426       if (ret)
1427          ret = dri_screen_create_sw(dri);
1428    } else {
1429       ret = dri_screen_create_sw(dri);
1430    }
1431
1432    if (ret)
1433       goto err_dri;
1434
1435    return &dri->base;
1436
1437 err_dri:
1438    free(dri);
1439
1440    return NULL;
1441 }
1442
1443 struct gbm_backend gbm_dri_backend = {
1444    .backend_name = "dri",
1445    .create_device = dri_device_create,
1446 };