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
  43 #include <GL/gl.h> /* dri_interface needs GL types */
  44 #include <GL/internal/dri_interface.h>
  45
  46 #include "gbm_driint.h"
  47
  48 #include "gbmint.h"
  49 #include "loader.h"
  50
  51 /* For importing wl_buffer */
  52 #if HAVE_WAYLAND_PLATFORM
  53 #include "../../../egl/wayland/wayland-drm/wayland-drm.h"
  54 #endif
  55
  56 static __DRIimage *
  57 dri_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
  58 {
  59    struct gbm_dri_device *dri = data;
  60
  61    if (dri->lookup_image == NULL)
  62       return NULL;
  63
  64    return dri->lookup_image(screen, image, dri->lookup_user_data);
  65 }
  66
  67 static __DRIbuffer *
  68 dri_get_buffers(__DRIdrawable * driDrawable,
  69                  int *width, int *height,
  70                  unsigned int *attachments, int count,
  71                  int *out_count, void *data)
  72 {
  73    struct gbm_dri_surface *surf = data;
  74    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
  75
  76    if (dri->get_buffers == NULL)
  77       return NULL;
  78
  79    return dri->get_buffers(driDrawable, width, height, attachments,
  80                            count, out_count, surf->dri_private);
  81 }
  82
  83 static void
  84 dri_flush_front_buffer(__DRIdrawable * driDrawable, void *data)
  85 {
  86    struct gbm_dri_surface *surf = data;
  87    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
  88
  89    if (dri->flush_front_buffer != NULL)
  90       dri->flush_front_buffer(driDrawable, surf->dri_private);
  91 }
  92
  93 static __DRIbuffer *
  94 dri_get_buffers_with_format(__DRIdrawable * driDrawable,
  95                             int *width, int *height,
  96                             unsigned int *attachments, int count,
  97                             int *out_count, void *data)
  98 {
  99    struct gbm_dri_surface *surf = data;
 100    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 101
 102    if (dri->get_buffers_with_format == NULL)
 103       return NULL;
 104
 105    return
 106       dri->get_buffers_with_format(driDrawable, width, height, attachments,
 107                                    count, out_count, surf->dri_private);
 108 }
 109
 110 static int
 111 image_get_buffers(__DRIdrawable *driDrawable,
 112                   unsigned int format,
 113                   uint32_t *stamp,
 114                   void *loaderPrivate,
 115                   uint32_t buffer_mask,
 116                   struct __DRIimageList *buffers)
 117 {
 118    struct gbm_dri_surface *surf = loaderPrivate;
 119    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 120
 121    if (dri->image_get_buffers == NULL)
 122       return 0;
 123
 124    return dri->image_get_buffers(driDrawable, format, stamp,
 125                                  surf->dri_private, buffer_mask, buffers);
 126 }
 127
 128 static void
 129 swrast_get_drawable_info(__DRIdrawable *driDrawable,
 130                          int           *x,
 131                          int           *y,
 132                          int           *width,
 133                          int           *height,
 134                          void          *loaderPrivate)
 135 {
 136    struct gbm_dri_surface *surf = loaderPrivate;
 137
 138    *x = 0;
 139    *y = 0;
 140    *width = surf->base.width;
 141    *height = surf->base.height;
 142 }
 143
 144 static void
 145 swrast_put_image2(__DRIdrawable *driDrawable,
 146                   int            op,
 147                   int            x,
 148                   int            y,
 149                   int            width,
 150                   int            height,
 151                   int            stride,
 152                   char          *data,
 153                   void          *loaderPrivate)
 154 {
 155    struct gbm_dri_surface *surf = loaderPrivate;
 156    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 157
 158    dri->swrast_put_image2(driDrawable,
 159                           op, x, y,
 160                           width, height, stride,
 161                           data, surf->dri_private);
 162 }
 163
 164 static void
 165 swrast_put_image(__DRIdrawable *driDrawable,
 166                  int            op,
 167                  int            x,
 168                  int            y,
 169                  int            width,
 170                  int            height,
 171                  char          *data,
 172                  void          *loaderPrivate)
 173 {
 174    return swrast_put_image2(driDrawable, op, x, y, width, height,
 175                             width * 4, data, loaderPrivate);
 176 }
 177
 178 static void
 179 swrast_get_image(__DRIdrawable *driDrawable,
 180                  int            x,
 181                  int            y,
 182                  int            width,
 183                  int            height,
 184                  char          *data,
 185                  void          *loaderPrivate)
 186 {
 187    struct gbm_dri_surface *surf = loaderPrivate;
 188    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 189
 190    dri->swrast_get_image(driDrawable,
 191                          x, y,
 192                          width, height,
 193                          data, surf->dri_private);
 194 }
 195
 196 static const __DRIuseInvalidateExtension use_invalidate = {
 197    .base = { __DRI_USE_INVALIDATE, 1 }
 198 };
 199
 200 static const __DRIimageLookupExtension image_lookup_extension = {
 201    .base = { __DRI_IMAGE_LOOKUP, 1 },
 202
 203    .lookupEGLImage          = dri_lookup_egl_image
 204 };
 205
 206 static const __DRIdri2LoaderExtension dri2_loader_extension = {
 207    .base = { __DRI_DRI2_LOADER, 3 },
 208
 209    .getBuffers              = dri_get_buffers,
 210    .flushFrontBuffer        = dri_flush_front_buffer,
 211    .getBuffersWithFormat    = dri_get_buffers_with_format,
 212 };
 213
 214 static const __DRIimageLoaderExtension image_loader_extension = {
 215    .base = { __DRI_IMAGE_LOADER, 1 },
 216
 217    .getBuffers          = image_get_buffers,
 218    .flushFrontBuffer    = dri_flush_front_buffer,
 219 };
 220
 221 static const __DRIswrastLoaderExtension swrast_loader_extension = {
 222    .base = { __DRI_SWRAST_LOADER, 2 },
 223
 224    .getDrawableInfo = swrast_get_drawable_info,
 225    .putImage        = swrast_put_image,
 226    .getImage        = swrast_get_image,
 227    .putImage2       = swrast_put_image2
 228 };
 229
 230 static const __DRIextension *gbm_dri_screen_extensions[] = {
 231    &image_lookup_extension.base,
 232    &use_invalidate.base,
 233    &dri2_loader_extension.base,
 234    &image_loader_extension.base,
 235    &swrast_loader_extension.base,
 236    NULL,
 237 };
 238
 239 struct dri_extension_match {
 240    const char *name;
 241    int version;
 242    int offset;
 243    int optional;
 244 };
 245
 246 static struct dri_extension_match dri_core_extensions[] = {
 247    { __DRI2_FLUSH, 1, offsetof(struct gbm_dri_device, flush) },
 248    { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) },
 249    { __DRI2_FENCE, 1, offsetof(struct gbm_dri_device, fence), 1 },
 250    { __DRI2_INTEROP, 1, offsetof(struct gbm_dri_device, interop), 1 },
 251    { NULL, 0, 0 }
 252 };
 253
 254 static struct dri_extension_match gbm_dri_device_extensions[] = {
 255    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) },
 256    { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) },
 257    { NULL, 0, 0 }
 258 };
 259
 260 static struct dri_extension_match gbm_swrast_device_extensions[] = {
 261    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core), },
 262    { __DRI_SWRAST, 1, offsetof(struct gbm_dri_device, swrast) },
 263    { NULL, 0, 0 }
 264 };
 265
 266 static int
 267 dri_bind_extensions(struct gbm_dri_device *dri,
 268                     struct dri_extension_match *matches,
 269                     const __DRIextension **extensions)
 270 {
 271    int i, j, ret = 0;
 272    void *field;
 273
 274    for (i = 0; extensions[i]; i++) {
 275       for (j = 0; matches[j].name; j++) {
 276          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
 277              extensions[i]->version >= matches[j].version) {
 278             field = ((char *) dri + matches[j].offset);
 279             *(const __DRIextension **) field = extensions[i];
 280          }
 281       }
 282    }
 283
 284    for (j = 0; matches[j].name; j++) {
 285       field = ((char *) dri + matches[j].offset);
 286       if ((*(const __DRIextension **) field == NULL) && !matches[j].optional) {
 287          ret = -1;
 288       }
 289    }
 290
 291    return ret;
 292 }
 293
 294 static const __DRIextension **
 295 dri_open_driver(struct gbm_dri_device *dri)
 296 {
 297    const __DRIextension **extensions = NULL;
 298    char path[PATH_MAX], *search_paths, *p, *next, *end;
 299    char *get_extensions_name;
 300
 301    search_paths = NULL;
 302    /* don't allow setuid apps to use LIBGL_DRIVERS_PATH or GBM_DRIVERS_PATH */
 303    if (geteuid() == getuid()) {
 304       /* Read GBM_DRIVERS_PATH first for compatibility, but LIBGL_DRIVERS_PATH
 305        * is recommended over GBM_DRIVERS_PATH.
 306        */
 307       search_paths = getenv("GBM_DRIVERS_PATH");
 308
 309       /* Read LIBGL_DRIVERS_PATH if GBM_DRIVERS_PATH was not set.
 310        * LIBGL_DRIVERS_PATH is recommended over GBM_DRIVERS_PATH.
 311        */
 312       if (search_paths == NULL) {
 313          search_paths = getenv("LIBGL_DRIVERS_PATH");
 314       }
 315    }
 316    if (search_paths == NULL)
 317       search_paths = DEFAULT_DRIVER_DIR;
 318
 319    /* Temporarily work around dri driver libs that need symbols in libglapi
 320     * but don't automatically link it in.
 321     */
 322    /* XXX: Library name differs on per platforms basis. Update this as
 323     * osx/cygwin/windows/bsd gets support for GBM..
 324     */
 325    dlopen("libglapi.so.0", RTLD_LAZY | RTLD_GLOBAL);
 326
 327    dri->driver = NULL;
 328    end = search_paths + strlen(search_paths);
 329    for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) {
 330       int len;
 331       next = strchr(p, ':');
 332       if (next == NULL)
 333          next = end;
 334
 335       len = next - p;
 336 #if GLX_USE_TLS
 337       snprintf(path, sizeof path,
 338                "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name);
 339       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 340 #endif
 341       if (dri->driver == NULL) {
 342          snprintf(path, sizeof path,
 343                   "%.*s/%s_dri.so", len, p, dri->base.driver_name);
 344          dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 345       }
 346       /* not need continue to loop all paths once the driver is found */
 347       if (dri->driver != NULL)
 348          break;
 349
 350 #ifdef ANDROID
 351       snprintf(path, sizeof path, "%.*s/gallium_dri.so", len, p);
 352       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 353       if (dri->driver == NULL)
 354          sprintf("failed to open %s: %s\n", path, dlerror());
 355       else
 356          break;
 357 #endif
 358    }
 359
 360    if (dri->driver == NULL) {
 361       fprintf(stderr, "gbm: failed to open any driver (search paths %s)\n",
 362               search_paths);
 363       fprintf(stderr, "gbm: Last dlopen error: %s\n", dlerror());
 364       return NULL;
 365    }
 366
 367    get_extensions_name = loader_get_extensions_name(dri->base.driver_name);
 368    if (get_extensions_name) {
 369       const __DRIextension **(*get_extensions)(void);
 370
 371       get_extensions = dlsym(dri->driver, get_extensions_name);
 372       free(get_extensions_name);
 373
 374       if (get_extensions)
 375          extensions = get_extensions();
 376    }
 377
 378    if (!extensions)
 379       extensions = dlsym(dri->driver, __DRI_DRIVER_EXTENSIONS);
 380    if (extensions == NULL) {
 381       fprintf(stderr, "gbm: driver exports no extensions (%s)", dlerror());
 382       dlclose(dri->driver);
 383    }
 384
 385    return extensions;
 386 }
 387
 388 static int
 389 dri_load_driver(struct gbm_dri_device *dri)
 390 {
 391    const __DRIextension **extensions;
 392
 393    extensions = dri_open_driver(dri);
 394    if (!extensions)
 395       return -1;
 396
 397    if (dri_bind_extensions(dri, gbm_dri_device_extensions, extensions) < 0) {
 398       dlclose(dri->driver);
 399       fprintf(stderr, "failed to bind extensions\n");
 400       return -1;
 401    }
 402
 403    dri->driver_extensions = extensions;
 404
 405    return 0;
 406 }
 407
 408 static int
 409 dri_load_driver_swrast(struct gbm_dri_device *dri)
 410 {
 411    const __DRIextension **extensions;
 412
 413    extensions = dri_open_driver(dri);
 414    if (!extensions)
 415       return -1;
 416
 417    if (dri_bind_extensions(dri, gbm_swrast_device_extensions, extensions) < 0) {
 418       dlclose(dri->driver);
 419       fprintf(stderr, "failed to bind extensions\n");
 420       return -1;
 421    }
 422
 423    dri->driver_extensions = extensions;
 424
 425    return 0;
 426 }
 427
 428 static int
 429 dri_screen_create_dri2(struct gbm_dri_device *dri, char *driver_name)
 430 {
 431    const __DRIextension **extensions;
 432    int ret = 0;
 433
 434    dri->base.driver_name = driver_name;
 435    if (dri->base.driver_name == NULL)
 436       return -1;
 437
 438    ret = dri_load_driver(dri);
 439    if (ret) {
 440       fprintf(stderr, "failed to load driver: %s\n", dri->base.driver_name);
 441       return ret;
 442    };
 443
 444    dri->loader_extensions = gbm_dri_screen_extensions;
 445
 446    if (dri->dri2 == NULL)
 447       return -1;
 448
 449    if (dri->dri2->base.version >= 4) {
 450       dri->screen = dri->dri2->createNewScreen2(0, dri->base.base.fd,
 451                                                 dri->loader_extensions,
 452                                                 dri->driver_extensions,
 453                                                 &dri->driver_configs, dri);
 454    } else {
 455       dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd,
 456                                                dri->loader_extensions,
 457                                                &dri->driver_configs, dri);
 458    }
 459    if (dri->screen == NULL)
 460       return -1;
 461
 462    extensions = dri->core->getExtensions(dri->screen);
 463    if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) {
 464       ret = -1;
 465       goto free_screen;
 466    }
 467
 468    dri->lookup_image = NULL;
 469    dri->lookup_user_data = NULL;
 470
 471    return 0;
 472
 473 free_screen:
 474    dri->core->destroyScreen(dri->screen);
 475
 476    return ret;
 477 }
 478
 479 static int
 480 dri_screen_create_swrast(struct gbm_dri_device *dri)
 481 {
 482    int ret;
 483
 484    dri->base.driver_name = strdup("swrast");
 485    if (dri->base.driver_name == NULL)
 486       return -1;
 487
 488    ret = dri_load_driver_swrast(dri);
 489    if (ret) {
 490       fprintf(stderr, "failed to load swrast driver\n");
 491       return ret;
 492    }
 493
 494    dri->loader_extensions = gbm_dri_screen_extensions;
 495
 496    if (dri->swrast == NULL)
 497       return -1;
 498
 499    if (dri->swrast->base.version >= 4) {
 500       dri->screen = dri->swrast->createNewScreen2(0, dri->loader_extensions,
 501                                                   dri->driver_extensions,
 502                                                   &dri->driver_configs, dri);
 503    } else {
 504       dri->screen = dri->swrast->createNewScreen(0, dri->loader_extensions,
 505                                                  &dri->driver_configs, dri);
 506    }
 507    if (dri->screen == NULL)
 508       return -1;
 509
 510    dri->lookup_image = NULL;
 511    dri->lookup_user_data = NULL;
 512
 513    return 0;
 514 }
 515
 516 static int
 517 dri_screen_create(struct gbm_dri_device *dri)
 518 {
 519    char *driver_name;
 520
 521    driver_name = loader_get_driver_for_fd(dri->base.base.fd);
 522    if (!driver_name)
 523       return -1;
 524
 525    return dri_screen_create_dri2(dri, driver_name);
 526 }
 527
 528 static int
 529 dri_screen_create_sw(struct gbm_dri_device *dri)
 530 {
 531    char *driver_name;
 532    int ret;
 533
 534    driver_name = strdup("kms_swrast");
 535    if (!driver_name)
 536       return -errno;
 537
 538    ret = dri_screen_create_dri2(dri, driver_name);
 539    if (ret == 0)
 540       return ret;
 541
 542    return dri_screen_create_swrast(dri);
 543 }
 544
 545 static int
 546 gbm_dri_is_format_supported(struct gbm_device *gbm,
 547                             uint32_t format,
 548                             uint32_t usage)
 549 {
 550    switch (format) {
 551    case GBM_BO_FORMAT_XRGB8888:
 552    case GBM_FORMAT_XBGR8888:
 553    case GBM_FORMAT_XRGB8888:
 554       break;
 555    case GBM_BO_FORMAT_ARGB8888:
 556    case GBM_FORMAT_ARGB8888:
 557       if (usage & GBM_BO_USE_SCANOUT)
 558          return 0;
 559       break;
 560    default:
 561       return 0;
 562    }
 563
 564    if (usage & GBM_BO_USE_CURSOR &&
 565        usage & GBM_BO_USE_RENDERING)
 566       return 0;
 567
 568    return 1;
 569 }
 570
 571 static int
 572 gbm_dri_bo_write(struct gbm_bo *_bo, const void *buf, size_t count)
 573 {
 574    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 575
 576    if (bo->image != NULL) {
 577       errno = EINVAL;
 578       return -1;
 579    }
 580
 581    memcpy(bo->map, buf, count);
 582
 583    return 0;
 584 }
 585
 586 static int
 587 gbm_dri_bo_get_fd(struct gbm_bo *_bo)
 588 {
 589    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 590    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 591    int fd;
 592
 593    if (bo->image == NULL)
 594       return -1;
 595
 596    if (!dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_FD, &fd))
 597       return -1;
 598
 599    return fd;
 600 }
 601
 602 static int
 603 get_number_planes(struct gbm_dri_device *dri, __DRIimage *image)
 604 {
 605    int num_planes = 0;
 606
 607    /* Dumb buffers are single-plane only. */
 608    if (!image)
 609       return 1;
 610
 611    dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_NUM_PLANES, &num_planes);
 612
 613    if (num_planes <= 0)
 614       num_planes = 1;
 615
 616    return num_planes;
 617 }
 618
 619 static int
 620 gbm_dri_bo_get_planes(struct gbm_bo *_bo)
 621 {
 622    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 623    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 624
 625    return get_number_planes(dri, bo->image);
 626 }
 627
 628 static union gbm_bo_handle
 629 gbm_dri_bo_get_handle_for_plane(struct gbm_bo *_bo, int plane)
 630 {
 631    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 632    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 633    union gbm_bo_handle ret;
 634    ret.s32 = -1;
 635
 636    if (!dri->image || dri->image->base.version < 13 || !dri->image->fromPlanar) {
 637       errno = ENOSYS;
 638       return ret;
 639    }
 640
 641    if (plane >= get_number_planes(dri, bo->image)) {
 642       errno = EINVAL;
 643       return ret;
 644    }
 645
 646    /* dumb BOs can only utilize non-planar formats */
 647    if (!bo->image) {
 648       assert(plane == 0);
 649       ret.s32 = bo->handle;
 650       return ret;
 651    }
 652
 653    __DRIimage *image = dri->image->fromPlanar(bo->image, plane, NULL);
 654    if (image) {
 655       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_HANDLE, &ret.s32);
 656       dri->image->destroyImage(image);
 657    } else {
 658       assert(plane == 0);
 659       dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE, &ret.s32);
 660    }
 661
 662    return ret;
 663 }
 664
 665 static uint32_t
 666 gbm_dri_bo_get_stride(struct gbm_bo *_bo, int plane)
 667 {
 668    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 669    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 670    __DRIimage *image;
 671    int stride = 0;
 672
 673    if (!dri->image || dri->image->base.version < 11 || !dri->image->fromPlanar) {
 674       /* Preserve legacy behavior if plane is 0 */
 675       if (plane == 0)
 676          return _bo->stride;
 677
 678       errno = ENOSYS;
 679       return 0;
 680    }
 681
 682    if (plane >= get_number_planes(dri, bo->image)) {
 683       errno = EINVAL;
 684       return 0;
 685    }
 686
 687    if (bo->image == NULL) {
 688       assert(plane == 0);
 689       return _bo->stride;
 690    }
 691
 692    image = dri->image->fromPlanar(bo->image, plane, NULL);
 693    if (image) {
 694       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_STRIDE, &stride);
 695       dri->image->destroyImage(image);
 696    } else {
 697       assert(plane == 0);
 698       dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, &stride);
 699    }
 700
 701    return (uint32_t)stride;
 702 }
 703
 704 static int64_t
 705 gbm_dri_bo_get_offset(struct gbm_bo *_bo, int plane)
 706 {
 707    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 708    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 709    int offset = 0;
 710
 711    if (!dri->image || dri->image->base.version < 13 || !dri->image->fromPlanar) {
 712       errno = ENOSYS;
 713       return -1;
 714    }
 715
 716    if (plane >= get_number_planes(dri, bo->image)) {
 717       errno = EINVAL;
 718       return -2;
 719    }
 720
 721     /* Dumb images have no offset */
 722    if (bo->image == NULL) {
 723       assert(plane == 0);
 724       return 0;
 725    }
 726
 727    __DRIimage *image = dri->image->fromPlanar(bo->image, plane, NULL);
 728    if (image) {
 729       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_OFFSET, &offset);
 730       dri->image->destroyImage(image);
 731    } else {
 732       dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_OFFSET, &offset);
 733    }
 734
 735    return (uint32_t)offset;
 736 }
 737
 738 static void
 739 gbm_dri_bo_destroy(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    struct drm_mode_destroy_dumb arg;
 744
 745    if (bo->image != NULL) {
 746       dri->image->destroyImage(bo->image);
 747    } else {
 748       gbm_dri_bo_unmap_dumb(bo);
 749       memset(&arg, 0, sizeof(arg));
 750       arg.handle = bo->handle;
 751       drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
 752    }
 753
 754    free(bo);
 755 }
 756
 757 static uint32_t
 758 gbm_dri_to_gbm_format(uint32_t dri_format)
 759 {
 760    uint32_t ret = 0;
 761
 762    switch (dri_format) {
 763    case __DRI_IMAGE_FORMAT_RGB565:
 764       ret = GBM_FORMAT_RGB565;
 765       break;
 766    case __DRI_IMAGE_FORMAT_XRGB8888:
 767       ret = GBM_FORMAT_XRGB8888;
 768       break;
 769    case __DRI_IMAGE_FORMAT_ARGB8888:
 770       ret = GBM_FORMAT_ARGB8888;
 771       break;
 772    case __DRI_IMAGE_FORMAT_XBGR8888:
 773       ret = GBM_FORMAT_XBGR8888;
 774       break;
 775    case __DRI_IMAGE_FORMAT_ABGR8888:
 776       ret = GBM_FORMAT_ABGR8888;
 777       break;
 778    default:
 779       ret = 0;
 780       break;
 781    }
 782
 783    return ret;
 784 }
 785
 786 static struct gbm_bo *
 787 gbm_dri_bo_import(struct gbm_device *gbm,
 788                   uint32_t type, void *buffer, uint32_t usage)
 789 {
 790    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 791    struct gbm_dri_bo *bo;
 792    __DRIimage *image;
 793    unsigned dri_use = 0;
 794    int gbm_format;
 795
 796    /* Required for query image WIDTH & HEIGHT */
 797    if (dri->image == NULL || dri->image->base.version < 4) {
 798       errno = ENOSYS;
 799       return NULL;
 800    }
 801
 802    switch (type) {
 803 #if HAVE_WAYLAND_PLATFORM
 804    case GBM_BO_IMPORT_WL_BUFFER:
 805    {
 806       struct wl_drm_buffer *wb;
 807
 808       if (!dri->wl_drm) {
 809          errno = EINVAL;
 810          return NULL;
 811       }
 812
 813       wb = wayland_drm_buffer_get(dri->wl_drm, (struct wl_resource *) buffer);
 814       if (!wb) {
 815          errno = EINVAL;
 816          return NULL;
 817       }
 818
 819       image = dri->image->dupImage(wb->driver_buffer, NULL);
 820
 821       switch (wb->format) {
 822       case WL_DRM_FORMAT_XRGB8888:
 823          gbm_format = GBM_FORMAT_XRGB8888;
 824          break;
 825       case WL_DRM_FORMAT_ARGB8888:
 826          gbm_format = GBM_FORMAT_ARGB8888;
 827          break;
 828       case WL_DRM_FORMAT_RGB565:
 829          gbm_format = GBM_FORMAT_RGB565;
 830          break;
 831       case WL_DRM_FORMAT_YUYV:
 832          gbm_format = GBM_FORMAT_YUYV;
 833          break;
 834       default:
 835          dri->image->destroyImage(image);
 836          return NULL;
 837       }
 838       break;
 839    }
 840 #endif
 841
 842    case GBM_BO_IMPORT_EGL_IMAGE:
 843    {
 844       int dri_format;
 845       if (dri->lookup_image == NULL) {
 846          errno = EINVAL;
 847          return NULL;
 848       }
 849
 850       image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data);
 851       image = dri->image->dupImage(image, NULL);
 852       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format);
 853       gbm_format = gbm_dri_to_gbm_format(dri_format);
 854       if (gbm_format == 0) {
 855          errno = EINVAL;
 856          dri->image->destroyImage(image);
 857          return NULL;
 858       }
 859       break;
 860    }
 861
 862    case GBM_BO_IMPORT_FD:
 863    {
 864       struct gbm_import_fd_data *fd_data = buffer;
 865       int stride = fd_data->stride, offset = 0;
 866       int dri_format;
 867
 868       switch (fd_data->format) {
 869       case GBM_BO_FORMAT_XRGB8888:
 870          dri_format = GBM_FORMAT_XRGB8888;
 871          break;
 872       case GBM_BO_FORMAT_ARGB8888:
 873          dri_format = GBM_FORMAT_ARGB8888;
 874          break;
 875       default:
 876          dri_format = fd_data->format;
 877       }
 878
 879       image = dri->image->createImageFromFds(dri->screen,
 880                                              fd_data->width,
 881                                              fd_data->height,
 882                                              dri_format,
 883                                              &fd_data->fd, 1,
 884                                              &stride, &offset,
 885                                              NULL);
 886       if (image == NULL) {
 887          errno = EINVAL;
 888          return NULL;
 889       }
 890       gbm_format = fd_data->format;
 891       break;
 892    }
 893
 894    default:
 895       errno = ENOSYS;
 896       return NULL;
 897    }
 898
 899
 900    bo = calloc(1, sizeof *bo);
 901    if (bo == NULL) {
 902       dri->image->destroyImage(image);
 903       return NULL;
 904    }
 905
 906    bo->image = image;
 907
 908    if (usage & GBM_BO_USE_SCANOUT)
 909       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 910    if (usage & GBM_BO_USE_CURSOR)
 911       dri_use |= __DRI_IMAGE_USE_CURSOR;
 912    if (dri->image->base.version >= 2 &&
 913        !dri->image->validateUsage(bo->image, dri_use)) {
 914       errno = EINVAL;
 915       dri->image->destroyImage(bo->image);
 916       free(bo);
 917       return NULL;
 918    }
 919
 920    bo->base.base.gbm = gbm;
 921    bo->base.base.format = gbm_format;
 922
 923    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH,
 924                           (int*)&bo->base.base.width);
 925    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT,
 926                           (int*)&bo->base.base.height);
 927    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 928                           (int*)&bo->base.base.stride);
 929    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 930                           &bo->base.base.handle.s32);
 931
 932    return &bo->base.base;
 933 }
 934
 935 static bool
 936 is_planar_format(uint32_t format)
 937 {
 938    switch (format) {
 939    case GBM_FORMAT_NV12:
 940    case GBM_FORMAT_NV21:
 941    case GBM_FORMAT_NV16:
 942    case GBM_FORMAT_NV61:
 943    case GBM_FORMAT_YUV410:
 944    case GBM_FORMAT_YVU410:
 945    case GBM_FORMAT_YUV411:
 946    case GBM_FORMAT_YVU411:
 947    case GBM_FORMAT_YUV420:
 948    case GBM_FORMAT_YVU420:
 949    case GBM_FORMAT_YUV422:
 950    case GBM_FORMAT_YVU422:
 951    case GBM_FORMAT_YUV444:
 952    case GBM_FORMAT_YVU444:
 953       return true;
 954    default:
 955       return false;
 956    }
 957
 958 }
 959
 960 static struct gbm_bo *
 961 create_dumb(struct gbm_device *gbm,
 962                   uint32_t width, uint32_t height,
 963                   uint32_t format, uint32_t usage)
 964 {
 965    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 966    struct drm_mode_create_dumb create_arg;
 967    struct gbm_dri_bo *bo;
 968    struct drm_mode_destroy_dumb destroy_arg;
 969    int ret;
 970    int is_cursor, is_scanout;
 971
 972    is_cursor = (usage & GBM_BO_USE_CURSOR) != 0 &&
 973       format == GBM_FORMAT_ARGB8888;
 974    is_scanout = (usage & GBM_BO_USE_SCANOUT) != 0 &&
 975       format == GBM_FORMAT_XRGB8888;
 976    if (!is_cursor && !is_scanout) {
 977       errno = EINVAL;
 978       return NULL;
 979    }
 980
 981    if (is_planar_format(format)) {
 982       errno = EINVAL;
 983       return NULL;
 984    }
 985
 986    bo = calloc(1, sizeof *bo);
 987    if (bo == NULL)
 988       return NULL;
 989
 990    memset(&create_arg, 0, sizeof(create_arg));
 991    create_arg.bpp = 32;
 992    create_arg.width = width;
 993    create_arg.height = height;
 994
 995    ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
 996    if (ret)
 997       goto free_bo;
 998
 999    bo->base.base.gbm = gbm;
1000    bo->base.base.width = width;
1001    bo->base.base.height = height;
1002    bo->base.base.stride = create_arg.pitch;
1003    bo->base.base.format = format;
1004    bo->base.base.handle.u32 = create_arg.handle;
1005    bo->handle = create_arg.handle;
1006    bo->size = create_arg.size;
1007
1008    if (gbm_dri_bo_map_dumb(bo) == NULL)
1009       goto destroy_dumb;
1010
1011    return &bo->base.base;
1012
1013 destroy_dumb:
1014    memset(&destroy_arg, 0, sizeof destroy_arg);
1015    destroy_arg.handle = create_arg.handle;
1016    drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
1017 free_bo:
1018    free(bo);
1019
1020    return NULL;
1021 }
1022
1023 static struct gbm_bo *
1024 gbm_dri_bo_create(struct gbm_device *gbm,
1025                   uint32_t width, uint32_t height,
1026                   uint32_t format, uint32_t usage)
1027 {
1028    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1029    struct gbm_dri_bo *bo;
1030    int dri_format;
1031    unsigned dri_use = 0;
1032
1033    if (usage & GBM_BO_USE_WRITE || dri->image == NULL)
1034       return create_dumb(gbm, width, height, format, usage);
1035
1036    bo = calloc(1, sizeof *bo);
1037    if (bo == NULL)
1038       return NULL;
1039
1040    bo->base.base.gbm = gbm;
1041    bo->base.base.width = width;
1042    bo->base.base.height = height;
1043    bo->base.base.format = format;
1044
1045    switch (format) {
1046    case GBM_FORMAT_R8:
1047       dri_format = __DRI_IMAGE_FORMAT_R8;
1048       break;
1049    case GBM_FORMAT_GR88:
1050       dri_format = __DRI_IMAGE_FORMAT_GR88;
1051       break;
1052    case GBM_FORMAT_RGB565:
1053       dri_format = __DRI_IMAGE_FORMAT_RGB565;
1054       break;
1055    case GBM_FORMAT_XRGB8888:
1056    case GBM_BO_FORMAT_XRGB8888:
1057       dri_format = __DRI_IMAGE_FORMAT_XRGB8888;
1058       break;
1059    case GBM_FORMAT_ARGB8888:
1060    case GBM_BO_FORMAT_ARGB8888:
1061       dri_format = __DRI_IMAGE_FORMAT_ARGB8888;
1062       break;
1063    case GBM_FORMAT_ABGR8888:
1064       dri_format = __DRI_IMAGE_FORMAT_ABGR8888;
1065       break;
1066    case GBM_FORMAT_XBGR8888:
1067       dri_format = __DRI_IMAGE_FORMAT_XBGR8888;
1068       break;
1069    case GBM_FORMAT_ARGB2101010:
1070       dri_format = __DRI_IMAGE_FORMAT_ARGB2101010;
1071       break;
1072    case GBM_FORMAT_XRGB2101010:
1073       dri_format = __DRI_IMAGE_FORMAT_XRGB2101010;
1074       break;
1075    default:
1076       errno = EINVAL;
1077       goto failed;
1078    }
1079
1080    if (usage & GBM_BO_USE_SCANOUT)
1081       dri_use |= __DRI_IMAGE_USE_SCANOUT;
1082    if (usage & GBM_BO_USE_CURSOR)
1083       dri_use |= __DRI_IMAGE_USE_CURSOR;
1084    if (usage & GBM_BO_USE_LINEAR)
1085       dri_use |= __DRI_IMAGE_USE_LINEAR;
1086
1087    /* Gallium drivers requires shared in order to get the handle/stride */
1088    dri_use |= __DRI_IMAGE_USE_SHARE;
1089
1090    bo->image =
1091       dri->image->createImage(dri->screen,
1092                               width, height,
1093                               dri_format, dri_use,
1094                               bo);
1095    if (bo->image == NULL)
1096       goto failed;
1097
1098    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
1099                           &bo->base.base.handle.s32);
1100    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
1101                           (int *) &bo->base.base.stride);
1102
1103    return &bo->base.base;
1104
1105 failed:
1106    free(bo);
1107    return NULL;
1108 }
1109
1110 static void *
1111 gbm_dri_bo_map(struct gbm_bo *_bo,
1112               uint32_t x, uint32_t y,
1113               uint32_t width, uint32_t height,
1114               uint32_t flags, uint32_t *stride, void **map_data)
1115 {
1116    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
1117    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
1118
1119    /* If it's a dumb buffer, we already have a mapping */
1120    if (bo->map) {
1121       *map_data = (char *)bo->map + (bo->base.base.stride * y) + (x * 4);
1122       *stride = bo->base.base.stride;
1123       return *map_data;
1124    }
1125
1126    if (!dri->image || dri->image->base.version < 12 || !dri->image->mapImage) {
1127       errno = ENOSYS;
1128       return NULL;
1129    }
1130
1131    mtx_lock(&dri->mutex);
1132    if (!dri->context)
1133       dri->context = dri->dri2->createNewContext(dri->screen, NULL,
1134                                                  NULL, NULL);
1135    assert(dri->context);
1136    mtx_unlock(&dri->mutex);
1137
1138    /* GBM flags and DRI flags are the same, so just pass them on */
1139    return dri->image->mapImage(dri->context, bo->image, x, y,
1140                                width, height, flags, (int *)stride,
1141                                map_data);
1142 }
1143
1144 static void
1145 gbm_dri_bo_unmap(struct gbm_bo *_bo, void *map_data)
1146 {
1147    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
1148    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
1149
1150    /* Check if it's a dumb buffer and check the pointer is in range */
1151    if (bo->map) {
1152       assert(map_data >= bo->map);
1153       assert(map_data < (bo->map + bo->size));
1154       return;
1155    }
1156
1157    if (!dri->context || !dri->image ||
1158        dri->image->base.version < 12 || !dri->image->unmapImage)
1159       return;
1160
1161    dri->image->unmapImage(dri->context, bo->image, map_data);
1162 }
1163
1164
1165 static struct gbm_surface *
1166 gbm_dri_surface_create(struct gbm_device *gbm,
1167                        uint32_t width, uint32_t height,
1168                        uint32_t format, uint32_t flags)
1169 {
1170    struct gbm_dri_surface *surf;
1171
1172    surf = calloc(1, sizeof *surf);
1173    if (surf == NULL)
1174       return NULL;
1175
1176    surf->base.gbm = gbm;
1177    surf->base.width = width;
1178    surf->base.height = height;
1179    surf->base.format = format;
1180    surf->base.flags = flags;
1181
1182    return &surf->base;
1183 }
1184
1185 static void
1186 gbm_dri_surface_destroy(struct gbm_surface *_surf)
1187 {
1188    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
1189
1190    free(surf);
1191 }
1192
1193 static void
1194 dri_destroy(struct gbm_device *gbm)
1195 {
1196    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1197    unsigned i;
1198
1199    if (dri->context)
1200       dri->core->destroyContext(dri->context);
1201
1202    dri->core->destroyScreen(dri->screen);
1203    for (i = 0; dri->driver_configs[i]; i++)
1204       free((__DRIconfig *) dri->driver_configs[i]);
1205    free(dri->driver_configs);
1206    dlclose(dri->driver);
1207    free(dri->base.driver_name);
1208
1209    free(dri);
1210 }
1211
1212 static struct gbm_device *
1213 dri_device_create(int fd)
1214 {
1215    struct gbm_dri_device *dri;
1216    int ret, force_sw;
1217
1218    dri = calloc(1, sizeof *dri);
1219    if (!dri)
1220       return NULL;
1221
1222    dri->base.base.fd = fd;
1223    dri->base.base.bo_create = gbm_dri_bo_create;
1224    dri->base.base.bo_import = gbm_dri_bo_import;
1225    dri->base.base.bo_map = gbm_dri_bo_map;
1226    dri->base.base.bo_unmap = gbm_dri_bo_unmap;
1227    dri->base.base.is_format_supported = gbm_dri_is_format_supported;
1228    dri->base.base.bo_write = gbm_dri_bo_write;
1229    dri->base.base.bo_get_fd = gbm_dri_bo_get_fd;
1230    dri->base.base.bo_get_planes = gbm_dri_bo_get_planes;
1231    dri->base.base.bo_get_handle = gbm_dri_bo_get_handle_for_plane;
1232    dri->base.base.bo_get_stride = gbm_dri_bo_get_stride;
1233    dri->base.base.bo_get_offset = gbm_dri_bo_get_offset;
1234    dri->base.base.bo_destroy = gbm_dri_bo_destroy;
1235    dri->base.base.destroy = dri_destroy;
1236    dri->base.base.surface_create = gbm_dri_surface_create;
1237    dri->base.base.surface_destroy = gbm_dri_surface_destroy;
1238
1239    dri->base.type = GBM_DRM_DRIVER_TYPE_DRI;
1240    dri->base.base.name = "drm";
1241
1242    mtx_init(&dri->mutex, mtx_plain);
1243
1244    force_sw = getenv("GBM_ALWAYS_SOFTWARE") != NULL;
1245    if (!force_sw) {
1246       ret = dri_screen_create(dri);
1247       if (ret)
1248          ret = dri_screen_create_sw(dri);
1249    } else {
1250       ret = dri_screen_create_sw(dri);
1251    }
1252
1253    if (ret)
1254       goto err_dri;
1255
1256    return &dri->base.base;
1257
1258 err_dri:
1259    free(dri);
1260
1261    return NULL;
1262 }
1263
1264 struct gbm_backend gbm_dri_backend = {
1265    .backend_name = "dri",
1266    .create_device = dri_device_create,
1267 };