src/gbm/backends/dri/gbm_dri.c

   1 /*
   2  * Copyright © 2011 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  19  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  20  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Benjamin Franzke <benjaminfranzke@googlemail.com>
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <stddef.h>
  31 #include <stdint.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <limits.h>
  35 #include <assert.h>
  36
  37 #include <sys/types.h>
  38 #include <unistd.h>
  39 #include <dlfcn.h>
  40 #include <xf86drm.h>
  41
  42 #include <GL/gl.h> /* dri_interface needs GL types */
  43 #include <GL/internal/dri_interface.h>
  44
  45 #include "gbm_driint.h"
  46
  47 #include "gbmint.h"
  48 #include "loader.h"
  49
  50 /* For importing wl_buffer */
  51 #if HAVE_WAYLAND_PLATFORM
  52 #include "../../../egl/wayland/wayland-drm/wayland-drm.h"
  53 #endif
  54
  55 static __DRIimage *
  56 dri_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
  57 {
  58    struct gbm_dri_device *dri = data;
  59
  60    if (dri->lookup_image == NULL)
  61       return NULL;
  62
  63    return dri->lookup_image(screen, image, dri->lookup_user_data);
  64 }
  65
  66 static __DRIbuffer *
  67 dri_get_buffers(__DRIdrawable * driDrawable,
  68                  int *width, int *height,
  69                  unsigned int *attachments, int count,
  70                  int *out_count, void *data)
  71 {
  72    struct gbm_dri_surface *surf = data;
  73    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
  74
  75    if (dri->get_buffers == NULL)
  76       return NULL;
  77
  78    return dri->get_buffers(driDrawable, width, height, attachments,
  79                            count, out_count, surf->dri_private);
  80 }
  81
  82 static void
  83 dri_flush_front_buffer(__DRIdrawable * driDrawable, void *data)
  84 {
  85    struct gbm_dri_surface *surf = data;
  86    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
  87
  88    if (dri->flush_front_buffer != NULL)
  89       dri->flush_front_buffer(driDrawable, surf->dri_private);
  90 }
  91
  92 static __DRIbuffer *
  93 dri_get_buffers_with_format(__DRIdrawable * driDrawable,
  94                             int *width, int *height,
  95                             unsigned int *attachments, int count,
  96                             int *out_count, void *data)
  97 {
  98    struct gbm_dri_surface *surf = data;
  99    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 100
 101    if (dri->get_buffers_with_format == NULL)
 102       return NULL;
 103
 104    return
 105       dri->get_buffers_with_format(driDrawable, width, height, attachments,
 106                                    count, out_count, surf->dri_private);
 107 }
 108
 109 static int
 110 image_get_buffers(__DRIdrawable *driDrawable,
 111                   unsigned int format,
 112                   uint32_t *stamp,
 113                   void *loaderPrivate,
 114                   uint32_t buffer_mask,
 115                   struct __DRIimageList *buffers)
 116 {
 117    struct gbm_dri_surface *surf = loaderPrivate;
 118    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 119
 120    if (dri->image_get_buffers == NULL)
 121       return 0;
 122
 123    return dri->image_get_buffers(driDrawable, format, stamp,
 124                                  surf->dri_private, buffer_mask, buffers);
 125 }
 126
 127 static void
 128 swrast_get_drawable_info(__DRIdrawable *driDrawable,
 129                          int           *x,
 130                          int           *y,
 131                          int           *width,
 132                          int           *height,
 133                          void          *loaderPrivate)
 134 {
 135    struct gbm_dri_surface *surf = loaderPrivate;
 136
 137    *x = 0;
 138    *y = 0;
 139    *width = surf->base.width;
 140    *height = surf->base.height;
 141 }
 142
 143 static void
 144 swrast_put_image2(__DRIdrawable *driDrawable,
 145                   int            op,
 146                   int            x,
 147                   int            y,
 148                   int            width,
 149                   int            height,
 150                   int            stride,
 151                   char          *data,
 152                   void          *loaderPrivate)
 153 {
 154    struct gbm_dri_surface *surf = loaderPrivate;
 155    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 156
 157    dri->swrast_put_image2(driDrawable,
 158                           op, x, y,
 159                           width, height, stride,
 160                           data, surf->dri_private);
 161 }
 162
 163 static void
 164 swrast_put_image(__DRIdrawable *driDrawable,
 165                  int            op,
 166                  int            x,
 167                  int            y,
 168                  int            width,
 169                  int            height,
 170                  char          *data,
 171                  void          *loaderPrivate)
 172 {
 173    return swrast_put_image2(driDrawable, op, x, y, width, height,
 174                             width * 4, data, loaderPrivate);
 175 }
 176
 177 static void
 178 swrast_get_image(__DRIdrawable *driDrawable,
 179                  int            x,
 180                  int            y,
 181                  int            width,
 182                  int            height,
 183                  char          *data,
 184                  void          *loaderPrivate)
 185 {
 186    struct gbm_dri_surface *surf = loaderPrivate;
 187    struct gbm_dri_device *dri = gbm_dri_device(surf->base.gbm);
 188
 189    dri->swrast_get_image(driDrawable,
 190                          x, y,
 191                          width, height,
 192                          data, surf->dri_private);
 193 }
 194
 195 static const __DRIuseInvalidateExtension use_invalidate = {
 196    .base = { __DRI_USE_INVALIDATE, 1 }
 197 };
 198
 199 static const __DRIimageLookupExtension image_lookup_extension = {
 200    .base = { __DRI_IMAGE_LOOKUP, 1 },
 201
 202    .lookupEGLImage          = dri_lookup_egl_image
 203 };
 204
 205 static const __DRIdri2LoaderExtension dri2_loader_extension = {
 206    .base = { __DRI_DRI2_LOADER, 3 },
 207
 208    .getBuffers              = dri_get_buffers,
 209    .flushFrontBuffer        = dri_flush_front_buffer,
 210    .getBuffersWithFormat    = dri_get_buffers_with_format,
 211 };
 212
 213 static const __DRIimageLoaderExtension image_loader_extension = {
 214    .base = { __DRI_IMAGE_LOADER, 1 },
 215
 216    .getBuffers          = image_get_buffers,
 217    .flushFrontBuffer    = dri_flush_front_buffer,
 218 };
 219
 220 static const __DRIswrastLoaderExtension swrast_loader_extension = {
 221    .base = { __DRI_SWRAST_LOADER, 2 },
 222
 223    .getDrawableInfo = swrast_get_drawable_info,
 224    .putImage        = swrast_put_image,
 225    .getImage        = swrast_get_image,
 226    .putImage2       = swrast_put_image2
 227 };
 228
 229 static const __DRIextension *gbm_dri_screen_extensions[] = {
 230    &image_lookup_extension.base,
 231    &use_invalidate.base,
 232    &dri2_loader_extension.base,
 233    &image_loader_extension.base,
 234    &swrast_loader_extension.base,
 235    NULL,
 236 };
 237
 238 struct dri_extension_match {
 239    const char *name;
 240    int version;
 241    int offset;
 242    int optional;
 243 };
 244
 245 static struct dri_extension_match dri_core_extensions[] = {
 246    { __DRI2_FLUSH, 1, offsetof(struct gbm_dri_device, flush) },
 247    { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) },
 248    { __DRI2_FENCE, 2, offsetof(struct gbm_dri_device, fence), 1 },
 249    { __DRI2_INTEROP, 1, offsetof(struct gbm_dri_device, interop), 1 },
 250    { NULL, 0, 0 }
 251 };
 252
 253 static struct dri_extension_match gbm_dri_device_extensions[] = {
 254    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) },
 255    { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) },
 256    { NULL, 0, 0 }
 257 };
 258
 259 static struct dri_extension_match gbm_swrast_device_extensions[] = {
 260    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core), },
 261    { __DRI_SWRAST, 1, offsetof(struct gbm_dri_device, swrast) },
 262    { NULL, 0, 0 }
 263 };
 264
 265 static int
 266 dri_bind_extensions(struct gbm_dri_device *dri,
 267                     struct dri_extension_match *matches,
 268                     const __DRIextension **extensions)
 269 {
 270    int i, j, ret = 0;
 271    void *field;
 272
 273    for (i = 0; extensions[i]; i++) {
 274       for (j = 0; matches[j].name; j++) {
 275          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
 276              extensions[i]->version >= matches[j].version) {
 277             field = ((char *) dri + matches[j].offset);
 278             *(const __DRIextension **) field = extensions[i];
 279          }
 280       }
 281    }
 282
 283    for (j = 0; matches[j].name; j++) {
 284       field = ((char *) dri + matches[j].offset);
 285       if ((*(const __DRIextension **) field == NULL) && !matches[j].optional) {
 286          ret = -1;
 287       }
 288    }
 289
 290    return ret;
 291 }
 292
 293 static const __DRIextension **
 294 dri_open_driver(struct gbm_dri_device *dri)
 295 {
 296    const __DRIextension **extensions = NULL;
 297    char path[PATH_MAX], *search_paths, *p, *next, *end;
 298    char *get_extensions_name;
 299
 300    search_paths = NULL;
 301    /* don't allow setuid apps to use LIBGL_DRIVERS_PATH or GBM_DRIVERS_PATH */
 302    if (geteuid() == getuid()) {
 303       /* Read GBM_DRIVERS_PATH first for compatibility, but LIBGL_DRIVERS_PATH
 304        * is recommended over GBM_DRIVERS_PATH.
 305        */
 306       search_paths = getenv("GBM_DRIVERS_PATH");
 307
 308       /* Read LIBGL_DRIVERS_PATH if GBM_DRIVERS_PATH was not set.
 309        * LIBGL_DRIVERS_PATH is recommended over GBM_DRIVERS_PATH.
 310        */
 311       if (search_paths == NULL) {
 312          search_paths = getenv("LIBGL_DRIVERS_PATH");
 313       }
 314    }
 315    if (search_paths == NULL)
 316       search_paths = DEFAULT_DRIVER_DIR;
 317
 318    /* Temporarily work around dri driver libs that need symbols in libglapi
 319     * but don't automatically link it in.
 320     */
 321    /* XXX: Library name differs on per platforms basis. Update this as
 322     * osx/cygwin/windows/bsd gets support for GBM..
 323     */
 324    dlopen("libglapi.so.0", RTLD_LAZY | RTLD_GLOBAL);
 325
 326    dri->driver = NULL;
 327    end = search_paths + strlen(search_paths);
 328    for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) {
 329       int len;
 330       next = strchr(p, ':');
 331       if (next == NULL)
 332          next = end;
 333
 334       len = next - p;
 335 #if GLX_USE_TLS
 336       snprintf(path, sizeof path,
 337                "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name);
 338       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 339 #endif
 340       if (dri->driver == NULL) {
 341          snprintf(path, sizeof path,
 342                   "%.*s/%s_dri.so", len, p, dri->base.driver_name);
 343          dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 344       }
 345       /* not need continue to loop all paths once the driver is found */
 346       if (dri->driver != NULL)
 347          break;
 348
 349 #ifdef ANDROID
 350       snprintf(path, sizeof path, "%.*s/gallium_dri.so", len, p);
 351       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 352       if (dri->driver == NULL)
 353          sprintf("failed to open %s: %s\n", path, dlerror());
 354       else
 355          break;
 356 #endif
 357    }
 358
 359    if (dri->driver == NULL) {
 360       fprintf(stderr, "gbm: failed to open any driver (search paths %s)\n",
 361               search_paths);
 362       fprintf(stderr, "gbm: Last dlopen error: %s\n", dlerror());
 363       return NULL;
 364    }
 365
 366    get_extensions_name = dri_get_extensions_name(dri->base.driver_name);
 367
 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 void
 603 gbm_dri_bo_destroy(struct gbm_bo *_bo)
 604 {
 605    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 606    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 607    struct drm_mode_destroy_dumb arg;
 608
 609    if (bo->image != NULL) {
 610       dri->image->destroyImage(bo->image);
 611    } else {
 612       gbm_dri_bo_unmap_dumb(bo);
 613       memset(&arg, 0, sizeof(arg));
 614       arg.handle = bo->handle;
 615       drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
 616    }
 617
 618    free(bo);
 619 }
 620
 621 static uint32_t
 622 gbm_dri_to_gbm_format(uint32_t dri_format)
 623 {
 624    uint32_t ret = 0;
 625
 626    switch (dri_format) {
 627    case __DRI_IMAGE_FORMAT_RGB565:
 628       ret = GBM_FORMAT_RGB565;
 629       break;
 630    case __DRI_IMAGE_FORMAT_XRGB8888:
 631       ret = GBM_FORMAT_XRGB8888;
 632       break;
 633    case __DRI_IMAGE_FORMAT_ARGB8888:
 634       ret = GBM_FORMAT_ARGB8888;
 635       break;
 636    case __DRI_IMAGE_FORMAT_XBGR8888:
 637       ret = GBM_FORMAT_XBGR8888;
 638       break;
 639    case __DRI_IMAGE_FORMAT_ABGR8888:
 640       ret = GBM_FORMAT_ABGR8888;
 641       break;
 642    default:
 643       ret = 0;
 644       break;
 645    }
 646
 647    return ret;
 648 }
 649
 650 static struct gbm_bo *
 651 gbm_dri_bo_import(struct gbm_device *gbm,
 652                   uint32_t type, void *buffer, uint32_t usage)
 653 {
 654    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 655    struct gbm_dri_bo *bo;
 656    __DRIimage *image;
 657    unsigned dri_use = 0;
 658    int gbm_format;
 659
 660    /* Required for query image WIDTH & HEIGHT */
 661    if (dri->image == NULL || dri->image->base.version < 4) {
 662       errno = ENOSYS;
 663       return NULL;
 664    }
 665
 666    switch (type) {
 667 #if HAVE_WAYLAND_PLATFORM
 668    case GBM_BO_IMPORT_WL_BUFFER:
 669    {
 670       struct wl_drm_buffer *wb;
 671
 672       if (!dri->wl_drm) {
 673          errno = EINVAL;
 674          return NULL;
 675       }
 676
 677       wb = wayland_drm_buffer_get(dri->wl_drm, (struct wl_resource *) buffer);
 678       if (!wb) {
 679          errno = EINVAL;
 680          return NULL;
 681       }
 682
 683       image = dri->image->dupImage(wb->driver_buffer, NULL);
 684
 685       switch (wb->format) {
 686       case WL_DRM_FORMAT_XRGB8888:
 687          gbm_format = GBM_FORMAT_XRGB8888;
 688          break;
 689       case WL_DRM_FORMAT_ARGB8888:
 690          gbm_format = GBM_FORMAT_ARGB8888;
 691          break;
 692       case WL_DRM_FORMAT_RGB565:
 693          gbm_format = GBM_FORMAT_RGB565;
 694          break;
 695       case WL_DRM_FORMAT_YUYV:
 696          gbm_format = GBM_FORMAT_YUYV;
 697          break;
 698       default:
 699          return NULL;
 700       }
 701       break;
 702    }
 703 #endif
 704
 705    case GBM_BO_IMPORT_EGL_IMAGE:
 706    {
 707       int dri_format;
 708       if (dri->lookup_image == NULL) {
 709          errno = EINVAL;
 710          return NULL;
 711       }
 712
 713       image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data);
 714       image = dri->image->dupImage(image, NULL);
 715       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format);
 716       gbm_format = gbm_dri_to_gbm_format(dri_format);
 717       if (gbm_format == 0) {
 718          errno = EINVAL;
 719          return NULL;
 720       }
 721       break;
 722    }
 723
 724    case GBM_BO_IMPORT_FD:
 725    {
 726       struct gbm_import_fd_data *fd_data = buffer;
 727       int stride = fd_data->stride, offset = 0;
 728       int dri_format;
 729
 730       switch (fd_data->format) {
 731       case GBM_BO_FORMAT_XRGB8888:
 732          dri_format = GBM_FORMAT_XRGB8888;
 733          break;
 734       case GBM_BO_FORMAT_ARGB8888:
 735          dri_format = GBM_FORMAT_ARGB8888;
 736          break;
 737       default:
 738          dri_format = fd_data->format;
 739       }
 740
 741       image = dri->image->createImageFromFds(dri->screen,
 742                                              fd_data->width,
 743                                              fd_data->height,
 744                                              dri_format,
 745                                              &fd_data->fd, 1,
 746                                              &stride, &offset,
 747                                              NULL);
 748       if (image == NULL) {
 749          errno = EINVAL;
 750          return NULL;
 751       }
 752       gbm_format = fd_data->format;
 753       break;
 754    }
 755
 756    default:
 757       errno = ENOSYS;
 758       return NULL;
 759    }
 760
 761
 762    bo = calloc(1, sizeof *bo);
 763    if (bo == NULL)
 764       return NULL;
 765
 766    bo->image = image;
 767
 768    if (usage & GBM_BO_USE_SCANOUT)
 769       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 770    if (usage & GBM_BO_USE_CURSOR)
 771       dri_use |= __DRI_IMAGE_USE_CURSOR;
 772    if (dri->image->base.version >= 2 &&
 773        !dri->image->validateUsage(bo->image, dri_use)) {
 774       errno = EINVAL;
 775       free(bo);
 776       return NULL;
 777    }
 778
 779    bo->base.base.gbm = gbm;
 780    bo->base.base.format = gbm_format;
 781
 782    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH,
 783                           (int*)&bo->base.base.width);
 784    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT,
 785                           (int*)&bo->base.base.height);
 786    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 787                           (int*)&bo->base.base.stride);
 788    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 789                           &bo->base.base.handle.s32);
 790
 791    return &bo->base.base;
 792 }
 793
 794 static struct gbm_bo *
 795 create_dumb(struct gbm_device *gbm,
 796                   uint32_t width, uint32_t height,
 797                   uint32_t format, uint32_t usage)
 798 {
 799    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 800    struct drm_mode_create_dumb create_arg;
 801    struct gbm_dri_bo *bo;
 802    struct drm_mode_destroy_dumb destroy_arg;
 803    int ret;
 804    int is_cursor, is_scanout;
 805
 806    is_cursor = (usage & GBM_BO_USE_CURSOR) != 0 &&
 807       format == GBM_FORMAT_ARGB8888;
 808    is_scanout = (usage & GBM_BO_USE_SCANOUT) != 0 &&
 809       format == GBM_FORMAT_XRGB8888;
 810    if (!is_cursor && !is_scanout) {
 811       errno = EINVAL;
 812       return NULL;
 813    }
 814
 815    bo = calloc(1, sizeof *bo);
 816    if (bo == NULL)
 817       return NULL;
 818
 819    memset(&create_arg, 0, sizeof(create_arg));
 820    create_arg.bpp = 32;
 821    create_arg.width = width;
 822    create_arg.height = height;
 823
 824    ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
 825    if (ret)
 826       goto free_bo;
 827
 828    bo->base.base.gbm = gbm;
 829    bo->base.base.width = width;
 830    bo->base.base.height = height;
 831    bo->base.base.stride = create_arg.pitch;
 832    bo->base.base.format = format;
 833    bo->base.base.handle.u32 = create_arg.handle;
 834    bo->handle = create_arg.handle;
 835    bo->size = create_arg.size;
 836
 837    if (gbm_dri_bo_map_dumb(bo) == NULL)
 838       goto destroy_dumb;
 839
 840    return &bo->base.base;
 841
 842 destroy_dumb:
 843    memset(&destroy_arg, 0, sizeof destroy_arg);
 844    destroy_arg.handle = create_arg.handle;
 845    drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
 846 free_bo:
 847    free(bo);
 848
 849    return NULL;
 850 }
 851
 852 static struct gbm_bo *
 853 gbm_dri_bo_create(struct gbm_device *gbm,
 854                   uint32_t width, uint32_t height,
 855                   uint32_t format, uint32_t usage)
 856 {
 857    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 858    struct gbm_dri_bo *bo;
 859    int dri_format;
 860    unsigned dri_use = 0;
 861
 862    if (usage & GBM_BO_USE_WRITE || dri->image == NULL)
 863       return create_dumb(gbm, width, height, format, usage);
 864
 865    bo = calloc(1, sizeof *bo);
 866    if (bo == NULL)
 867       return NULL;
 868
 869    bo->base.base.gbm = gbm;
 870    bo->base.base.width = width;
 871    bo->base.base.height = height;
 872    bo->base.base.format = format;
 873
 874    switch (format) {
 875    case GBM_FORMAT_R8:
 876       dri_format = __DRI_IMAGE_FORMAT_R8;
 877       break;
 878    case GBM_FORMAT_GR88:
 879       dri_format = __DRI_IMAGE_FORMAT_GR88;
 880       break;
 881    case GBM_FORMAT_RGB565:
 882       dri_format = __DRI_IMAGE_FORMAT_RGB565;
 883       break;
 884    case GBM_FORMAT_XRGB8888:
 885    case GBM_BO_FORMAT_XRGB8888:
 886       dri_format = __DRI_IMAGE_FORMAT_XRGB8888;
 887       break;
 888    case GBM_FORMAT_ARGB8888:
 889    case GBM_BO_FORMAT_ARGB8888:
 890       dri_format = __DRI_IMAGE_FORMAT_ARGB8888;
 891       break;
 892    case GBM_FORMAT_ABGR8888:
 893       dri_format = __DRI_IMAGE_FORMAT_ABGR8888;
 894       break;
 895    case GBM_FORMAT_XBGR8888:
 896       dri_format = __DRI_IMAGE_FORMAT_XBGR8888;
 897       break;
 898    case GBM_FORMAT_ARGB2101010:
 899       dri_format = __DRI_IMAGE_FORMAT_ARGB2101010;
 900       break;
 901    case GBM_FORMAT_XRGB2101010:
 902       dri_format = __DRI_IMAGE_FORMAT_XRGB2101010;
 903       break;
 904    default:
 905       errno = EINVAL;
 906       goto failed;
 907    }
 908
 909    if (usage & GBM_BO_USE_SCANOUT)
 910       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 911    if (usage & GBM_BO_USE_CURSOR)
 912       dri_use |= __DRI_IMAGE_USE_CURSOR;
 913    if (usage & GBM_BO_USE_LINEAR)
 914       dri_use |= __DRI_IMAGE_USE_LINEAR;
 915
 916    /* Gallium drivers requires shared in order to get the handle/stride */
 917    dri_use |= __DRI_IMAGE_USE_SHARE;
 918
 919    bo->image =
 920       dri->image->createImage(dri->screen,
 921                               width, height,
 922                               dri_format, dri_use,
 923                               bo);
 924    if (bo->image == NULL)
 925       goto failed;
 926
 927    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 928                           &bo->base.base.handle.s32);
 929    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 930                           (int *) &bo->base.base.stride);
 931
 932    return &bo->base.base;
 933
 934 failed:
 935    free(bo);
 936    return NULL;
 937 }
 938
 939 static void *
 940 gbm_dri_bo_map(struct gbm_bo *_bo,
 941               uint32_t x, uint32_t y,
 942               uint32_t width, uint32_t height,
 943               uint32_t flags, uint32_t *stride, void **map_data)
 944 {
 945    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 946    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 947
 948    /* If it's a dumb buffer, we already have a mapping */
 949    if (bo->map) {
 950       *map_data = (char *)bo->map + (bo->base.base.stride * y) + (x * 4);
 951       *stride = bo->base.base.stride;
 952       return *map_data;
 953    }
 954
 955    if (!dri->image || dri->image->base.version < 12 || !dri->image->mapImage) {
 956       errno = ENOSYS;
 957       return NULL;
 958    }
 959
 960    mtx_lock(&dri->mutex);
 961    if (!dri->context)
 962       dri->context = dri->dri2->createNewContext(dri->screen, NULL,
 963                                                  NULL, NULL);
 964    assert(dri->context);
 965    mtx_unlock(&dri->mutex);
 966
 967    /* GBM flags and DRI flags are the same, so just pass them on */
 968    return dri->image->mapImage(dri->context, bo->image, x, y,
 969                                width, height, flags, (int *)stride,
 970                                map_data);
 971 }
 972
 973 static void
 974 gbm_dri_bo_unmap(struct gbm_bo *_bo, void *map_data)
 975 {
 976    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 977    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 978
 979    /* Check if it's a dumb buffer and check the pointer is in range */
 980    if (bo->map) {
 981       assert(map_data >= bo->map);
 982       assert(map_data < (bo->map + bo->size));
 983       return;
 984    }
 985
 986    if (!dri->context || !dri->image ||
 987        dri->image->base.version < 12 || !dri->image->unmapImage)
 988       return;
 989
 990    dri->image->unmapImage(dri->context, bo->image, map_data);
 991 }
 992
 993
 994 static struct gbm_surface *
 995 gbm_dri_surface_create(struct gbm_device *gbm,
 996                        uint32_t width, uint32_t height,
 997                        uint32_t format, uint32_t flags)
 998 {
 999    struct gbm_dri_surface *surf;
1000
1001    surf = calloc(1, sizeof *surf);
1002    if (surf == NULL)
1003       return NULL;
1004
1005    surf->base.gbm = gbm;
1006    surf->base.width = width;
1007    surf->base.height = height;
1008    surf->base.format = format;
1009    surf->base.flags = flags;
1010
1011    return &surf->base;
1012 }
1013
1014 static void
1015 gbm_dri_surface_destroy(struct gbm_surface *_surf)
1016 {
1017    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
1018
1019    free(surf);
1020 }
1021
1022 static void
1023 dri_destroy(struct gbm_device *gbm)
1024 {
1025    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1026    unsigned i;
1027
1028    if (dri->context)
1029       dri->core->destroyContext(dri->context);
1030
1031    dri->core->destroyScreen(dri->screen);
1032    for (i = 0; dri->driver_configs[i]; i++)
1033       free((__DRIconfig *) dri->driver_configs[i]);
1034    free(dri->driver_configs);
1035    dlclose(dri->driver);
1036    free(dri->base.driver_name);
1037
1038    free(dri);
1039 }
1040
1041 static struct gbm_device *
1042 dri_device_create(int fd)
1043 {
1044    struct gbm_dri_device *dri;
1045    int ret, force_sw;
1046
1047    dri = calloc(1, sizeof *dri);
1048    if (!dri)
1049       return NULL;
1050
1051    dri->base.base.fd = fd;
1052    dri->base.base.bo_create = gbm_dri_bo_create;
1053    dri->base.base.bo_import = gbm_dri_bo_import;
1054    dri->base.base.bo_map = gbm_dri_bo_map;
1055    dri->base.base.bo_unmap = gbm_dri_bo_unmap;
1056    dri->base.base.is_format_supported = gbm_dri_is_format_supported;
1057    dri->base.base.bo_write = gbm_dri_bo_write;
1058    dri->base.base.bo_get_fd = gbm_dri_bo_get_fd;
1059    dri->base.base.bo_destroy = gbm_dri_bo_destroy;
1060    dri->base.base.destroy = dri_destroy;
1061    dri->base.base.surface_create = gbm_dri_surface_create;
1062    dri->base.base.surface_destroy = gbm_dri_surface_destroy;
1063
1064    dri->base.type = GBM_DRM_DRIVER_TYPE_DRI;
1065    dri->base.base.name = "drm";
1066
1067    mtx_init(&dri->mutex, mtx_plain);
1068
1069    force_sw = getenv("GBM_ALWAYS_SOFTWARE") != NULL;
1070    if (!force_sw) {
1071       ret = dri_screen_create(dri);
1072       if (ret)
1073          ret = dri_screen_create_sw(dri);
1074    } else {
1075       ret = dri_screen_create_sw(dri);
1076    }
1077
1078    if (ret)
1079       goto err_dri;
1080
1081    return &dri->base.base;
1082
1083 err_dri:
1084    free(dri);
1085
1086    return NULL;
1087 }
1088
1089 struct gbm_backend gbm_dri_backend = {
1090    .backend_name = "dri",
1091    .create_device = dri_device_create,
1092 };