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