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       dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_OFFSET, &offset);
 853    }
 854
 855    return (uint32_t)offset;
 856 }
 857
 858 static uint64_t
 859 gbm_dri_bo_get_modifier(struct gbm_bo *_bo)
 860 {
 861    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 862    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 863
 864    if (!dri->image || dri->image->base.version < 14) {
 865       errno = ENOSYS;
 866       return DRM_FORMAT_MOD_INVALID;
 867    }
 868
 869    /* Dumb buffers have no modifiers */
 870    if (!bo->image)
 871       return DRM_FORMAT_MOD_LINEAR;
 872
 873    uint64_t ret = 0;
 874    int mod;
 875    if (!dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_MODIFIER_UPPER,
 876                                &mod))
 877       return DRM_FORMAT_MOD_INVALID;
 878
 879    ret = (uint64_t)mod << 32;
 880
 881    if (!dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_MODIFIER_LOWER,
 882                                &mod))
 883       return DRM_FORMAT_MOD_INVALID;
 884
 885    ret |= (uint64_t)(mod & 0xffffffff);
 886
 887    return ret;
 888 }
 889
 890 static void
 891 gbm_dri_bo_destroy(struct gbm_bo *_bo)
 892 {
 893    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 894    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 895    struct drm_mode_destroy_dumb arg;
 896
 897    if (bo->image != NULL) {
 898       dri->image->destroyImage(bo->image);
 899    } else {
 900       gbm_dri_bo_unmap_dumb(bo);
 901       memset(&arg, 0, sizeof(arg));
 902       arg.handle = bo->handle;
 903       drmIoctl(dri->base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
 904    }
 905
 906    free(bo);
 907 }
 908
 909 static struct gbm_bo *
 910 gbm_dri_bo_import(struct gbm_device *gbm,
 911                   uint32_t type, void *buffer, uint32_t usage)
 912 {
 913    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 914    struct gbm_dri_bo *bo;
 915    __DRIimage *image;
 916    unsigned dri_use = 0;
 917    int gbm_format;
 918
 919    /* Required for query image WIDTH & HEIGHT */
 920    if (dri->image == NULL || dri->image->base.version < 4) {
 921       errno = ENOSYS;
 922       return NULL;
 923    }
 924
 925    switch (type) {
 926 #if HAVE_WAYLAND_PLATFORM
 927    case GBM_BO_IMPORT_WL_BUFFER:
 928    {
 929       struct wl_drm_buffer *wb;
 930
 931       if (!dri->wl_drm) {
 932          errno = EINVAL;
 933          return NULL;
 934       }
 935
 936       wb = wayland_drm_buffer_get(dri->wl_drm, (struct wl_resource *) buffer);
 937       if (!wb) {
 938          errno = EINVAL;
 939          return NULL;
 940       }
 941
 942       image = dri->image->dupImage(wb->driver_buffer, NULL);
 943
 944       /* GBM_FORMAT_* is identical to WL_DRM_FORMAT_*, so no conversion
 945        * required. */
 946       gbm_format = wb->format;
 947       break;
 948    }
 949 #endif
 950
 951    case GBM_BO_IMPORT_EGL_IMAGE:
 952    {
 953       int dri_format;
 954       if (dri->lookup_image == NULL) {
 955          errno = EINVAL;
 956          return NULL;
 957       }
 958
 959       image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data);
 960       image = dri->image->dupImage(image, NULL);
 961       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format);
 962       gbm_format = gbm_dri_to_gbm_format(dri_format);
 963       if (gbm_format == 0) {
 964          errno = EINVAL;
 965          dri->image->destroyImage(image);
 966          return NULL;
 967       }
 968       break;
 969    }
 970
 971    case GBM_BO_IMPORT_FD:
 972    {
 973       struct gbm_import_fd_data *fd_data = buffer;
 974       int stride = fd_data->stride, offset = 0;
 975       int fourcc;
 976
 977       /* GBM's GBM_FORMAT_* tokens are a strict superset of the DRI FourCC
 978        * tokens accepted by createImageFromFds, except for not supporting
 979        * the sARGB format. */
 980       fourcc = gbm_format_canonicalize(fd_data->format);
 981
 982       image = dri->image->createImageFromFds(dri->screen,
 983                                              fd_data->width,
 984                                              fd_data->height,
 985                                              fourcc,
 986                                              &fd_data->fd, 1,
 987                                              &stride, &offset,
 988                                              NULL);
 989       if (image == NULL) {
 990          errno = EINVAL;
 991          return NULL;
 992       }
 993       gbm_format = fd_data->format;
 994       break;
 995    }
 996
 997    case GBM_BO_IMPORT_FD_MODIFIER:
 998    {
 999       struct gbm_import_fd_modifier_data *fd_data = buffer;
1000       unsigned int error;
1001       int fourcc;
1002
1003       /* Import with modifier requires createImageFromDmaBufs2 */
1004       if (dri->image == NULL || dri->image->base.version < 15 ||
1005           dri->image->createImageFromDmaBufs2 == NULL) {
1006          errno = ENOSYS;
1007          return NULL;
1008       }
1009
1010       /* GBM's GBM_FORMAT_* tokens are a strict superset of the DRI FourCC
1011        * tokens accepted by createImageFromDmaBufs2, except for not supporting
1012        * the sARGB format. */
1013       fourcc = gbm_format_canonicalize(fd_data->format);
1014
1015       image = dri->image->createImageFromDmaBufs2(dri->screen, fd_data->width,
1016                                                   fd_data->height, fourcc,
1017                                                   fd_data->modifier,
1018                                                   fd_data->fds,
1019                                                   fd_data->num_fds,
1020                                                   fd_data->strides,
1021                                                   fd_data->offsets,
1022                                                   0, 0, 0, 0,
1023                                                   &error, NULL);
1024       if (image == NULL) {
1025          errno = ENOSYS;
1026          return NULL;
1027       }
1028
1029       gbm_format = fourcc;
1030       break;
1031    }
1032
1033    default:
1034       errno = ENOSYS;
1035       return NULL;
1036    }
1037
1038
1039    bo = calloc(1, sizeof *bo);
1040    if (bo == NULL) {
1041       dri->image->destroyImage(image);
1042       return NULL;
1043    }
1044
1045    bo->image = image;
1046
1047    if (usage & GBM_BO_USE_SCANOUT)
1048       dri_use |= __DRI_IMAGE_USE_SCANOUT;
1049    if (usage & GBM_BO_USE_CURSOR)
1050       dri_use |= __DRI_IMAGE_USE_CURSOR;
1051    if (dri->image->base.version >= 2 &&
1052        !dri->image->validateUsage(bo->image, dri_use)) {
1053       errno = EINVAL;
1054       dri->image->destroyImage(bo->image);
1055       free(bo);
1056       return NULL;
1057    }
1058
1059    bo->base.gbm = gbm;
1060    bo->base.format = gbm_format;
1061
1062    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH,
1063                           (int*)&bo->base.width);
1064    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT,
1065                           (int*)&bo->base.height);
1066    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
1067                           (int*)&bo->base.stride);
1068    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
1069                           &bo->base.handle.s32);
1070
1071    return &bo->base;
1072 }
1073
1074 static struct gbm_bo *
1075 create_dumb(struct gbm_device *gbm,
1076                   uint32_t width, uint32_t height,
1077                   uint32_t format, uint32_t usage)
1078 {
1079    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1080    struct drm_mode_create_dumb create_arg;
1081    struct gbm_dri_bo *bo;
1082    struct drm_mode_destroy_dumb destroy_arg;
1083    int ret;
1084    int is_cursor, is_scanout;
1085
1086    is_cursor = (usage & GBM_BO_USE_CURSOR) != 0 &&
1087       format == GBM_FORMAT_ARGB8888;
1088    is_scanout = (usage & GBM_BO_USE_SCANOUT) != 0 &&
1089       (format == GBM_FORMAT_XRGB8888 || format == GBM_FORMAT_XBGR8888);
1090    if (!is_cursor && !is_scanout) {
1091       errno = EINVAL;
1092       return NULL;
1093    }
1094
1095    bo = calloc(1, sizeof *bo);
1096    if (bo == NULL)
1097       return NULL;
1098
1099    memset(&create_arg, 0, sizeof(create_arg));
1100    create_arg.bpp = 32;
1101    create_arg.width = width;
1102    create_arg.height = height;
1103
1104    ret = drmIoctl(dri->base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
1105    if (ret)
1106       goto free_bo;
1107
1108    bo->base.gbm = gbm;
1109    bo->base.width = width;
1110    bo->base.height = height;
1111    bo->base.stride = create_arg.pitch;
1112    bo->base.format = format;
1113    bo->base.handle.u32 = create_arg.handle;
1114    bo->handle = create_arg.handle;
1115    bo->size = create_arg.size;
1116
1117    if (gbm_dri_bo_map_dumb(bo) == NULL)
1118       goto destroy_dumb;
1119
1120    return &bo->base;
1121
1122 destroy_dumb:
1123    memset(&destroy_arg, 0, sizeof destroy_arg);
1124    destroy_arg.handle = create_arg.handle;
1125    drmIoctl(dri->base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
1126 free_bo:
1127    free(bo);
1128
1129    return NULL;
1130 }
1131
1132 static struct gbm_bo *
1133 gbm_dri_bo_create(struct gbm_device *gbm,
1134                   uint32_t width, uint32_t height,
1135                   uint32_t format, uint32_t usage,
1136                   const uint64_t *modifiers,
1137                   const unsigned int count)
1138 {
1139    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1140    struct gbm_dri_bo *bo;
1141    int dri_format;
1142    unsigned dri_use = 0;
1143
1144    /* Callers of this may specify a modifier, or a dri usage, but not both. The
1145     * newer modifier interface deprecates the older usage flags.
1146     */
1147    assert(!(usage && count));
1148
1149    format = gbm_format_canonicalize(format);
1150
1151    if (usage & GBM_BO_USE_WRITE || dri->image == NULL)
1152       return create_dumb(gbm, width, height, format, usage);
1153
1154    bo = calloc(1, sizeof *bo);
1155    if (bo == NULL)
1156       return NULL;
1157
1158    bo->base.gbm = gbm;
1159    bo->base.width = width;
1160    bo->base.height = height;
1161    bo->base.format = format;
1162
1163    dri_format = gbm_format_to_dri_format(format);
1164    if (dri_format == 0) {
1165       errno = EINVAL;
1166       goto failed;
1167    }
1168
1169    if (usage & GBM_BO_USE_SCANOUT)
1170       dri_use |= __DRI_IMAGE_USE_SCANOUT;
1171    if (usage & GBM_BO_USE_CURSOR)
1172       dri_use |= __DRI_IMAGE_USE_CURSOR;
1173    if (usage & GBM_BO_USE_LINEAR)
1174       dri_use |= __DRI_IMAGE_USE_LINEAR;
1175
1176    /* Gallium drivers requires shared in order to get the handle/stride */
1177    dri_use |= __DRI_IMAGE_USE_SHARE;
1178
1179    if (modifiers) {
1180       if (!dri->image || dri->image->base.version < 14 ||
1181           !dri->image->createImageWithModifiers) {
1182          fprintf(stderr, "Modifiers specified, but DRI is too old\n");
1183          errno = ENOSYS;
1184          goto failed;
1185       }
1186
1187       /* It's acceptable to create an image with INVALID modifier in the list,
1188        * but it cannot be on the only modifier (since it will certainly fail
1189        * later). While we could easily catch this after modifier creation, doing
1190        * the check here is a convenient debug check likely pointing at whatever
1191        * interface the client is using to build its modifier list.
1192        */
1193       if (count == 1 && modifiers[0] == DRM_FORMAT_MOD_INVALID) {
1194          fprintf(stderr, "Only invalid modifier specified\n");
1195          errno = EINVAL;
1196          goto failed;
1197       }
1198
1199       bo->image =
1200          dri->image->createImageWithModifiers(dri->screen,
1201                                               width, height,
1202                                               dri_format,
1203                                               modifiers, count,
1204                                               bo);
1205
1206       if (bo->image) {
1207          /* The client passed in a list of invalid modifiers */
1208          assert(gbm_dri_bo_get_modifier(&bo->base) != DRM_FORMAT_MOD_INVALID);
1209       }
1210    } else {
1211       bo->image = dri->image->createImage(dri->screen, width, height,
1212                                           dri_format, dri_use, bo);
1213    }
1214
1215    if (bo->image == NULL)
1216       goto failed;
1217
1218    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
1219                           &bo->base.handle.s32);
1220    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
1221                           (int *) &bo->base.stride);
1222
1223    return &bo->base;
1224
1225 failed:
1226    free(bo);
1227    return NULL;
1228 }
1229
1230 static void *
1231 gbm_dri_bo_map(struct gbm_bo *_bo,
1232               uint32_t x, uint32_t y,
1233               uint32_t width, uint32_t height,
1234               uint32_t flags, uint32_t *stride, void **map_data)
1235 {
1236    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
1237    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
1238
1239    /* If it's a dumb buffer, we already have a mapping */
1240    if (bo->map) {
1241       *map_data = (char *)bo->map + (bo->base.stride * y) + (x * 4);
1242       *stride = bo->base.stride;
1243       return *map_data;
1244    }
1245
1246    if (!dri->image || dri->image->base.version < 12 || !dri->image->mapImage) {
1247       errno = ENOSYS;
1248       return NULL;
1249    }
1250
1251    mtx_lock(&dri->mutex);
1252    if (!dri->context)
1253       dri->context = dri->dri2->createNewContext(dri->screen, NULL,
1254                                                  NULL, NULL);
1255    assert(dri->context);
1256    mtx_unlock(&dri->mutex);
1257
1258    /* GBM flags and DRI flags are the same, so just pass them on */
1259    return dri->image->mapImage(dri->context, bo->image, x, y,
1260                                width, height, flags, (int *)stride,
1261                                map_data);
1262 }
1263
1264 static void
1265 gbm_dri_bo_unmap(struct gbm_bo *_bo, void *map_data)
1266 {
1267    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
1268    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
1269
1270    /* Check if it's a dumb buffer and check the pointer is in range */
1271    if (bo->map) {
1272       assert(map_data >= bo->map);
1273       assert(map_data < (bo->map + bo->size));
1274       return;
1275    }
1276
1277    if (!dri->context || !dri->image ||
1278        dri->image->base.version < 12 || !dri->image->unmapImage)
1279       return;
1280
1281    dri->image->unmapImage(dri->context, bo->image, map_data);
1282
1283    /*
1284     * Not all DRI drivers use direct maps. They may queue up DMA operations
1285     * on the mapping context. Since there is no explicit gbm flush
1286     * mechanism, we need to flush here.
1287     */
1288    if (dri->flush->base.version >= 4)
1289       dri->flush->flush_with_flags(dri->context, NULL, __DRI2_FLUSH_CONTEXT, 0);
1290 }
1291
1292
1293 static struct gbm_surface *
1294 gbm_dri_surface_create(struct gbm_device *gbm,
1295                        uint32_t width, uint32_t height,
1296                        uint32_t format, uint32_t flags,
1297                        const uint64_t *modifiers, const unsigned count)
1298 {
1299    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1300    struct gbm_dri_surface *surf;
1301
1302    if (modifiers &&
1303        (!dri->image || dri->image->base.version < 14 ||
1304         !dri->image->createImageWithModifiers)) {
1305       errno = ENOSYS;
1306       return NULL;
1307    }
1308
1309    if (count)
1310       assert(modifiers);
1311
1312    /* It's acceptable to create an image with INVALID modifier in the list,
1313     * but it cannot be on the only modifier (since it will certainly fail
1314     * later). While we could easily catch this after modifier creation, doing
1315     * the check here is a convenient debug check likely pointing at whatever
1316     * interface the client is using to build its modifier list.
1317     */
1318    if (count == 1 && modifiers[0] == DRM_FORMAT_MOD_INVALID) {
1319       fprintf(stderr, "Only invalid modifier specified\n");
1320       errno = EINVAL;
1321    }
1322
1323    surf = calloc(1, sizeof *surf);
1324    if (surf == NULL) {
1325       errno = ENOMEM;
1326       return NULL;
1327    }
1328
1329    surf->base.gbm = gbm;
1330    surf->base.width = width;
1331    surf->base.height = height;
1332    surf->base.format = gbm_format_canonicalize(format);
1333    surf->base.flags = flags;
1334    if (!modifiers) {
1335       assert(!count);
1336       return &surf->base;
1337    }
1338
1339    surf->base.modifiers = calloc(count, sizeof(*modifiers));
1340    if (count && !surf->base.modifiers) {
1341       errno = ENOMEM;
1342       free(surf);
1343       return NULL;
1344    }
1345
1346    /* TODO: We are deferring validation of modifiers until the image is actually
1347     * created. This deferred creation can fail due to a modifier-format
1348     * mismatch. The result is the client has a surface but no object to back it.
1349     */
1350    surf->base.count = count;
1351    memcpy(surf->base.modifiers, modifiers, count * sizeof(*modifiers));
1352
1353    return &surf->base;
1354 }
1355
1356 static void
1357 gbm_dri_surface_destroy(struct gbm_surface *_surf)
1358 {
1359    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
1360
1361    free(surf->base.modifiers);
1362    free(surf);
1363 }
1364
1365 static void
1366 dri_destroy(struct gbm_device *gbm)
1367 {
1368    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1369    unsigned i;
1370
1371    if (dri->context)
1372       dri->core->destroyContext(dri->context);
1373
1374    dri->core->destroyScreen(dri->screen);
1375    for (i = 0; dri->driver_configs[i]; i++)
1376       free((__DRIconfig *) dri->driver_configs[i]);
1377    free(dri->driver_configs);
1378    dlclose(dri->driver);
1379    free(dri->driver_name);
1380
1381    free(dri);
1382 }
1383
1384 static struct gbm_device *
1385 dri_device_create(int fd)
1386 {
1387    struct gbm_dri_device *dri;
1388    int ret;
1389    bool force_sw;
1390
1391    dri = calloc(1, sizeof *dri);
1392    if (!dri)
1393       return NULL;
1394
1395    dri->base.fd = fd;
1396    dri->base.bo_create = gbm_dri_bo_create;
1397    dri->base.bo_import = gbm_dri_bo_import;
1398    dri->base.bo_map = gbm_dri_bo_map;
1399    dri->base.bo_unmap = gbm_dri_bo_unmap;
1400    dri->base.is_format_supported = gbm_dri_is_format_supported;
1401    dri->base.get_format_modifier_plane_count =
1402       gbm_dri_get_format_modifier_plane_count;
1403    dri->base.bo_write = gbm_dri_bo_write;
1404    dri->base.bo_get_fd = gbm_dri_bo_get_fd;
1405    dri->base.bo_get_planes = gbm_dri_bo_get_planes;
1406    dri->base.bo_get_handle = gbm_dri_bo_get_handle_for_plane;
1407    dri->base.bo_get_stride = gbm_dri_bo_get_stride;
1408    dri->base.bo_get_offset = gbm_dri_bo_get_offset;
1409    dri->base.bo_get_modifier = gbm_dri_bo_get_modifier;
1410    dri->base.bo_destroy = gbm_dri_bo_destroy;
1411    dri->base.destroy = dri_destroy;
1412    dri->base.surface_create = gbm_dri_surface_create;
1413    dri->base.surface_destroy = gbm_dri_surface_destroy;
1414
1415    dri->base.name = "drm";
1416
1417    dri->visual_table = gbm_dri_visuals_table;
1418    dri->num_visuals = ARRAY_SIZE(gbm_dri_visuals_table);
1419
1420    mtx_init(&dri->mutex, mtx_plain);
1421
1422    force_sw = env_var_as_boolean("GBM_ALWAYS_SOFTWARE", false);
1423    if (!force_sw) {
1424       ret = dri_screen_create(dri);
1425       if (ret)
1426          ret = dri_screen_create_sw(dri);
1427    } else {
1428       ret = dri_screen_create_sw(dri);
1429    }
1430
1431    if (ret)
1432       goto err_dri;
1433
1434    return &dri->base;
1435
1436 err_dri:
1437    free(dri);
1438
1439    return NULL;
1440 }
1441
1442 struct gbm_backend gbm_dri_backend = {
1443    .backend_name = "dri",
1444    .create_device = dri_device_create,
1445 };