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 };
 243
 244 static struct dri_extension_match dri_core_extensions[] = {
 245    { __DRI2_FLUSH, 1, offsetof(struct gbm_dri_device, flush) },
 246    { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) },
 247    { NULL, 0, 0 }
 248 };
 249
 250 static struct dri_extension_match gbm_dri_device_extensions[] = {
 251    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) },
 252    { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) },
 253    { NULL, 0, 0 }
 254 };
 255
 256 static struct dri_extension_match gbm_swrast_device_extensions[] = {
 257    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core), },
 258    { __DRI_SWRAST, 1, offsetof(struct gbm_dri_device, swrast) },
 259    { NULL, 0, 0 }
 260 };
 261
 262 static int
 263 dri_bind_extensions(struct gbm_dri_device *dri,
 264                     struct dri_extension_match *matches,
 265                     const __DRIextension **extensions)
 266 {
 267    int i, j, ret = 0;
 268    void *field;
 269
 270    for (i = 0; extensions[i]; i++) {
 271       for (j = 0; matches[j].name; j++) {
 272          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
 273              extensions[i]->version >= matches[j].version) {
 274             field = ((char *) dri + matches[j].offset);
 275             *(const __DRIextension **) field = extensions[i];
 276          }
 277       }
 278    }
 279
 280    for (j = 0; matches[j].name; j++) {
 281       field = ((char *) dri + matches[j].offset);
 282       if (*(const __DRIextension **) field == NULL) {
 283          ret = -1;
 284       }
 285    }
 286
 287    return ret;
 288 }
 289
 290 static const __DRIextension **
 291 dri_open_driver(struct gbm_dri_device *dri)
 292 {
 293    const __DRIextension **extensions = NULL;
 294    char path[PATH_MAX], *search_paths, *p, *next, *end;
 295    char *get_extensions_name;
 296
 297    search_paths = NULL;
 298    /* don't allow setuid apps to use LIBGL_DRIVERS_PATH or GBM_DRIVERS_PATH */
 299    if (geteuid() == getuid()) {
 300       /* Read GBM_DRIVERS_PATH first for compatibility, but LIBGL_DRIVERS_PATH
 301        * is recommended over GBM_DRIVERS_PATH.
 302        */
 303       search_paths = getenv("GBM_DRIVERS_PATH");
 304
 305       /* Read LIBGL_DRIVERS_PATH if GBM_DRIVERS_PATH was not set.
 306        * LIBGL_DRIVERS_PATH is recommended over GBM_DRIVERS_PATH.
 307        */
 308       if (search_paths == NULL) {
 309          search_paths = getenv("LIBGL_DRIVERS_PATH");
 310       }
 311    }
 312    if (search_paths == NULL)
 313       search_paths = DEFAULT_DRIVER_DIR;
 314
 315    /* Temporarily work around dri driver libs that need symbols in libglapi
 316     * but don't automatically link it in.
 317     */
 318    /* XXX: Library name differs on per platforms basis. Update this as
 319     * osx/cygwin/windows/bsd gets support for GBM..
 320     */
 321    dlopen("libglapi.so.0", RTLD_LAZY | RTLD_GLOBAL);
 322
 323    dri->driver = NULL;
 324    end = search_paths + strlen(search_paths);
 325    for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) {
 326       int len;
 327       next = strchr(p, ':');
 328       if (next == NULL)
 329          next = end;
 330
 331       len = next - p;
 332 #if GLX_USE_TLS
 333       snprintf(path, sizeof path,
 334                "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name);
 335       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 336 #endif
 337       if (dri->driver == NULL) {
 338          snprintf(path, sizeof path,
 339                   "%.*s/%s_dri.so", len, p, dri->base.driver_name);
 340          dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 341       }
 342       /* not need continue to loop all paths once the driver is found */
 343       if (dri->driver != NULL)
 344          break;
 345
 346 #ifdef ANDROID
 347       snprintf(path, sizeof path, "%.*s/gallium_dri.so", len, p);
 348       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 349       if (dri->driver == NULL)
 350          sprintf("failed to open %s: %s\n", path, dlerror());
 351       else
 352          break;
 353 #endif
 354    }
 355
 356    if (dri->driver == NULL) {
 357       fprintf(stderr, "gbm: failed to open any driver (search paths %s)\n",
 358               search_paths);
 359       fprintf(stderr, "gbm: Last dlopen error: %s\n", dlerror());
 360       return NULL;
 361    }
 362
 363    if (asprintf(&get_extensions_name, "%s_%s",
 364                 __DRI_DRIVER_GET_EXTENSIONS, dri->base.driver_name) != -1) {
 365       const __DRIextension **(*get_extensions)(void);
 366
 367       get_extensions = dlsym(dri->driver, get_extensions_name);
 368       free(get_extensions_name);
 369
 370       if (get_extensions)
 371          extensions = get_extensions();
 372    }
 373
 374    if (!extensions)
 375       extensions = dlsym(dri->driver, __DRI_DRIVER_EXTENSIONS);
 376    if (extensions == NULL) {
 377       fprintf(stderr, "gbm: driver exports no extensions (%s)", dlerror());
 378       dlclose(dri->driver);
 379    }
 380
 381    return extensions;
 382 }
 383
 384 static int
 385 dri_load_driver(struct gbm_dri_device *dri)
 386 {
 387    const __DRIextension **extensions;
 388
 389    extensions = dri_open_driver(dri);
 390    if (!extensions)
 391       return -1;
 392
 393    if (dri_bind_extensions(dri, gbm_dri_device_extensions, extensions) < 0) {
 394       dlclose(dri->driver);
 395       fprintf(stderr, "failed to bind extensions\n");
 396       return -1;
 397    }
 398
 399    dri->driver_extensions = extensions;
 400
 401    return 0;
 402 }
 403
 404 static int
 405 dri_load_driver_swrast(struct gbm_dri_device *dri)
 406 {
 407    const __DRIextension **extensions;
 408
 409    extensions = dri_open_driver(dri);
 410    if (!extensions)
 411       return -1;
 412
 413    if (dri_bind_extensions(dri, gbm_swrast_device_extensions, extensions) < 0) {
 414       dlclose(dri->driver);
 415       fprintf(stderr, "failed to bind extensions\n");
 416       return -1;
 417    }
 418
 419    dri->driver_extensions = extensions;
 420
 421    return 0;
 422 }
 423
 424 static int
 425 dri_screen_create_dri2(struct gbm_dri_device *dri, char *driver_name)
 426 {
 427    const __DRIextension **extensions;
 428    int ret = 0;
 429
 430    dri->base.driver_name = driver_name;
 431    if (dri->base.driver_name == NULL)
 432       return -1;
 433
 434    ret = dri_load_driver(dri);
 435    if (ret) {
 436       fprintf(stderr, "failed to load driver: %s\n", dri->base.driver_name);
 437       return ret;
 438    };
 439
 440    dri->extensions = gbm_dri_screen_extensions;
 441
 442    if (dri->dri2 == NULL)
 443       return -1;
 444
 445    if (dri->dri2->base.version >= 4) {
 446       dri->screen = dri->dri2->createNewScreen2(0, dri->base.base.fd,
 447                                                 dri->extensions,
 448                                                 dri->driver_extensions,
 449                                                 &dri->driver_configs, dri);
 450    } else {
 451       dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd,
 452                                                dri->extensions,
 453                                                &dri->driver_configs, dri);
 454    }
 455    if (dri->screen == NULL)
 456       return -1;
 457
 458    extensions = dri->core->getExtensions(dri->screen);
 459    if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) {
 460       ret = -1;
 461       goto free_screen;
 462    }
 463
 464    dri->lookup_image = NULL;
 465    dri->lookup_user_data = NULL;
 466
 467    return 0;
 468
 469 free_screen:
 470    dri->core->destroyScreen(dri->screen);
 471
 472    return ret;
 473 }
 474
 475 static int
 476 dri_screen_create_swrast(struct gbm_dri_device *dri)
 477 {
 478    int ret;
 479
 480    dri->base.driver_name = strdup("swrast");
 481    if (dri->base.driver_name == NULL)
 482       return -1;
 483
 484    ret = dri_load_driver_swrast(dri);
 485    if (ret) {
 486       fprintf(stderr, "failed to load swrast driver\n");
 487       return ret;
 488    }
 489
 490    dri->extensions = gbm_dri_screen_extensions;
 491
 492    if (dri->swrast == NULL)
 493       return -1;
 494
 495    if (dri->swrast->base.version >= 4) {
 496       dri->screen = dri->swrast->createNewScreen2(0, dri->extensions,
 497                                                   dri->driver_extensions,
 498                                                   &dri->driver_configs, dri);
 499    } else {
 500       dri->screen = dri->swrast->createNewScreen(0, dri->extensions,
 501                                                  &dri->driver_configs, dri);
 502    }
 503    if (dri->screen == NULL)
 504       return -1;
 505
 506    dri->lookup_image = NULL;
 507    dri->lookup_user_data = NULL;
 508
 509    return 0;
 510 }
 511
 512 static int
 513 dri_screen_create(struct gbm_dri_device *dri)
 514 {
 515    char *driver_name;
 516
 517    driver_name = loader_get_driver_for_fd(dri->base.base.fd, 0);
 518    if (!driver_name)
 519       return -1;
 520
 521    return dri_screen_create_dri2(dri, driver_name);
 522 }
 523
 524 static int
 525 dri_screen_create_sw(struct gbm_dri_device *dri)
 526 {
 527    char *driver_name;
 528    int ret;
 529
 530    driver_name = strdup("kms_swrast");
 531    if (!driver_name)
 532       return -errno;
 533
 534    ret = dri_screen_create_dri2(dri, driver_name);
 535    if (ret == 0)
 536       return ret;
 537
 538    return dri_screen_create_swrast(dri);
 539 }
 540
 541 static int
 542 gbm_dri_is_format_supported(struct gbm_device *gbm,
 543                             uint32_t format,
 544                             uint32_t usage)
 545 {
 546    switch (format) {
 547    case GBM_BO_FORMAT_XRGB8888:
 548    case GBM_FORMAT_XBGR8888:
 549    case GBM_FORMAT_XRGB8888:
 550       break;
 551    case GBM_BO_FORMAT_ARGB8888:
 552    case GBM_FORMAT_ARGB8888:
 553       if (usage & GBM_BO_USE_SCANOUT)
 554          return 0;
 555       break;
 556    default:
 557       return 0;
 558    }
 559
 560    if (usage & GBM_BO_USE_CURSOR &&
 561        usage & GBM_BO_USE_RENDERING)
 562       return 0;
 563
 564    return 1;
 565 }
 566
 567 static int
 568 gbm_dri_bo_write(struct gbm_bo *_bo, const void *buf, size_t count)
 569 {
 570    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 571
 572    if (bo->image != NULL) {
 573       errno = EINVAL;
 574       return -1;
 575    }
 576
 577    memcpy(bo->map, buf, count);
 578
 579    return 0;
 580 }
 581
 582 static int
 583 gbm_dri_bo_get_fd(struct gbm_bo *_bo)
 584 {
 585    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 586    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 587    int fd;
 588
 589    if (bo->image == NULL)
 590       return -1;
 591
 592    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_FD, &fd);
 593
 594    return fd;
 595 }
 596
 597 static void
 598 gbm_dri_bo_destroy(struct gbm_bo *_bo)
 599 {
 600    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 601    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 602    struct drm_mode_destroy_dumb arg;
 603
 604    if (bo->image != NULL) {
 605       dri->image->destroyImage(bo->image);
 606    } else {
 607       gbm_dri_bo_unmap_dumb(bo);
 608       memset(&arg, 0, sizeof(arg));
 609       arg.handle = bo->handle;
 610       drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
 611    }
 612
 613    free(bo);
 614 }
 615
 616 static uint32_t
 617 gbm_dri_to_gbm_format(uint32_t dri_format)
 618 {
 619    uint32_t ret = 0;
 620
 621    switch (dri_format) {
 622    case __DRI_IMAGE_FORMAT_RGB565:
 623       ret = GBM_FORMAT_RGB565;
 624       break;
 625    case __DRI_IMAGE_FORMAT_XRGB8888:
 626       ret = GBM_FORMAT_XRGB8888;
 627       break;
 628    case __DRI_IMAGE_FORMAT_ARGB8888:
 629       ret = GBM_FORMAT_ARGB8888;
 630       break;
 631    case __DRI_IMAGE_FORMAT_XBGR8888:
 632       ret = GBM_FORMAT_XBGR8888;
 633       break;
 634    case __DRI_IMAGE_FORMAT_ABGR8888:
 635       ret = GBM_FORMAT_ABGR8888;
 636       break;
 637    default:
 638       ret = 0;
 639       break;
 640    }
 641
 642    return ret;
 643 }
 644
 645 static struct gbm_bo *
 646 gbm_dri_bo_import(struct gbm_device *gbm,
 647                   uint32_t type, void *buffer, uint32_t usage)
 648 {
 649    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 650    struct gbm_dri_bo *bo;
 651    __DRIimage *image;
 652    unsigned dri_use = 0;
 653    int gbm_format;
 654
 655    /* Required for query image WIDTH & HEIGHT */
 656    if (dri->image == NULL || dri->image->base.version < 4) {
 657       errno = ENOSYS;
 658       return NULL;
 659    }
 660
 661    switch (type) {
 662 #if HAVE_WAYLAND_PLATFORM
 663    case GBM_BO_IMPORT_WL_BUFFER:
 664    {
 665       struct wl_drm_buffer *wb;
 666
 667       if (!dri->wl_drm) {
 668          errno = EINVAL;
 669          return NULL;
 670       }
 671
 672       wb = wayland_drm_buffer_get(dri->wl_drm, (struct wl_resource *) buffer);
 673       if (!wb) {
 674          errno = EINVAL;
 675          return NULL;
 676       }
 677
 678       image = dri->image->dupImage(wb->driver_buffer, NULL);
 679
 680       switch (wb->format) {
 681       case WL_DRM_FORMAT_XRGB8888:
 682          gbm_format = GBM_FORMAT_XRGB8888;
 683          break;
 684       case WL_DRM_FORMAT_ARGB8888:
 685          gbm_format = GBM_FORMAT_ARGB8888;
 686          break;
 687       case WL_DRM_FORMAT_RGB565:
 688          gbm_format = GBM_FORMAT_RGB565;
 689          break;
 690       case WL_DRM_FORMAT_YUYV:
 691          gbm_format = GBM_FORMAT_YUYV;
 692          break;
 693       default:
 694          return NULL;
 695       }
 696       break;
 697    }
 698 #endif
 699
 700    case GBM_BO_IMPORT_EGL_IMAGE:
 701    {
 702       int dri_format;
 703       if (dri->lookup_image == NULL) {
 704          errno = EINVAL;
 705          return NULL;
 706       }
 707
 708       image = dri->lookup_image(dri->screen, buffer, dri->lookup_user_data);
 709       image = dri->image->dupImage(image, NULL);
 710       dri->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &dri_format);
 711       gbm_format = gbm_dri_to_gbm_format(dri_format);
 712       if (gbm_format == 0) {
 713          errno = EINVAL;
 714          return NULL;
 715       }
 716       break;
 717    }
 718
 719    case GBM_BO_IMPORT_FD:
 720    {
 721       struct gbm_import_fd_data *fd_data = buffer;
 722       int stride = fd_data->stride, offset = 0;
 723       int dri_format;
 724
 725       switch (fd_data->format) {
 726       case GBM_BO_FORMAT_XRGB8888:
 727          dri_format = GBM_FORMAT_XRGB8888;
 728          break;
 729       case GBM_BO_FORMAT_ARGB8888:
 730          dri_format = GBM_FORMAT_ARGB8888;
 731          break;
 732       default:
 733          dri_format = fd_data->format;
 734       }
 735
 736       image = dri->image->createImageFromFds(dri->screen,
 737                                              fd_data->width,
 738                                              fd_data->height,
 739                                              dri_format,
 740                                              &fd_data->fd, 1,
 741                                              &stride, &offset,
 742                                              NULL);
 743       if (image == NULL) {
 744          errno = EINVAL;
 745          return NULL;
 746       }
 747       gbm_format = fd_data->format;
 748       break;
 749    }
 750
 751    default:
 752       errno = ENOSYS;
 753       return NULL;
 754    }
 755
 756
 757    bo = calloc(1, sizeof *bo);
 758    if (bo == NULL)
 759       return NULL;
 760
 761    bo->image = image;
 762
 763    if (usage & GBM_BO_USE_SCANOUT)
 764       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 765    if (usage & GBM_BO_USE_CURSOR)
 766       dri_use |= __DRI_IMAGE_USE_CURSOR;
 767    if (dri->image->base.version >= 2 &&
 768        !dri->image->validateUsage(bo->image, dri_use)) {
 769       errno = EINVAL;
 770       free(bo);
 771       return NULL;
 772    }
 773
 774    bo->base.base.gbm = gbm;
 775    bo->base.base.format = gbm_format;
 776
 777    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_WIDTH,
 778                           (int*)&bo->base.base.width);
 779    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HEIGHT,
 780                           (int*)&bo->base.base.height);
 781    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 782                           (int*)&bo->base.base.stride);
 783    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 784                           &bo->base.base.handle.s32);
 785
 786    return &bo->base.base;
 787 }
 788
 789 static struct gbm_bo *
 790 create_dumb(struct gbm_device *gbm,
 791                   uint32_t width, uint32_t height,
 792                   uint32_t format, uint32_t usage)
 793 {
 794    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 795    struct drm_mode_create_dumb create_arg;
 796    struct gbm_dri_bo *bo;
 797    struct drm_mode_destroy_dumb destroy_arg;
 798    int ret;
 799    int is_cursor, is_scanout;
 800
 801    is_cursor = (usage & GBM_BO_USE_CURSOR) != 0 &&
 802       format == GBM_FORMAT_ARGB8888;
 803    is_scanout = (usage & GBM_BO_USE_SCANOUT) != 0 &&
 804       format == GBM_FORMAT_XRGB8888;
 805    if (!is_cursor && !is_scanout) {
 806       errno = EINVAL;
 807       return NULL;
 808    }
 809
 810    bo = calloc(1, sizeof *bo);
 811    if (bo == NULL)
 812       return NULL;
 813
 814    memset(&create_arg, 0, sizeof(create_arg));
 815    create_arg.bpp = 32;
 816    create_arg.width = width;
 817    create_arg.height = height;
 818
 819    ret = drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_arg);
 820    if (ret)
 821       goto free_bo;
 822
 823    bo->base.base.gbm = gbm;
 824    bo->base.base.width = width;
 825    bo->base.base.height = height;
 826    bo->base.base.stride = create_arg.pitch;
 827    bo->base.base.format = format;
 828    bo->base.base.handle.u32 = create_arg.handle;
 829    bo->handle = create_arg.handle;
 830    bo->size = create_arg.size;
 831
 832    if (gbm_dri_bo_map_dumb(bo) == NULL)
 833       goto destroy_dumb;
 834
 835    return &bo->base.base;
 836
 837 destroy_dumb:
 838    memset(&destroy_arg, 0, sizeof destroy_arg);
 839    destroy_arg.handle = create_arg.handle;
 840    drmIoctl(dri->base.base.fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_arg);
 841 free_bo:
 842    free(bo);
 843
 844    return NULL;
 845 }
 846
 847 static struct gbm_bo *
 848 gbm_dri_bo_create(struct gbm_device *gbm,
 849                   uint32_t width, uint32_t height,
 850                   uint32_t format, uint32_t usage)
 851 {
 852    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 853    struct gbm_dri_bo *bo;
 854    int dri_format;
 855    unsigned dri_use = 0;
 856
 857    if (usage & GBM_BO_USE_WRITE || dri->image == NULL)
 858       return create_dumb(gbm, width, height, format, usage);
 859
 860    bo = calloc(1, sizeof *bo);
 861    if (bo == NULL)
 862       return NULL;
 863
 864    bo->base.base.gbm = gbm;
 865    bo->base.base.width = width;
 866    bo->base.base.height = height;
 867    bo->base.base.format = format;
 868
 869    switch (format) {
 870    case GBM_FORMAT_R8:
 871       dri_format = __DRI_IMAGE_FORMAT_R8;
 872       break;
 873    case GBM_FORMAT_GR88:
 874       dri_format = __DRI_IMAGE_FORMAT_GR88;
 875       break;
 876    case GBM_FORMAT_RGB565:
 877       dri_format = __DRI_IMAGE_FORMAT_RGB565;
 878       break;
 879    case GBM_FORMAT_XRGB8888:
 880    case GBM_BO_FORMAT_XRGB8888:
 881       dri_format = __DRI_IMAGE_FORMAT_XRGB8888;
 882       break;
 883    case GBM_FORMAT_ARGB8888:
 884    case GBM_BO_FORMAT_ARGB8888:
 885       dri_format = __DRI_IMAGE_FORMAT_ARGB8888;
 886       break;
 887    case GBM_FORMAT_ABGR8888:
 888       dri_format = __DRI_IMAGE_FORMAT_ABGR8888;
 889       break;
 890    case GBM_FORMAT_XBGR8888:
 891       dri_format = __DRI_IMAGE_FORMAT_XBGR8888;
 892       break;
 893    case GBM_FORMAT_ARGB2101010:
 894       dri_format = __DRI_IMAGE_FORMAT_ARGB2101010;
 895       break;
 896    case GBM_FORMAT_XRGB2101010:
 897       dri_format = __DRI_IMAGE_FORMAT_XRGB2101010;
 898       break;
 899    default:
 900       errno = EINVAL;
 901       goto failed;
 902    }
 903
 904    if (usage & GBM_BO_USE_SCANOUT)
 905       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 906    if (usage & GBM_BO_USE_CURSOR)
 907       dri_use |= __DRI_IMAGE_USE_CURSOR;
 908    if (usage & GBM_BO_USE_LINEAR)
 909       dri_use |= __DRI_IMAGE_USE_LINEAR;
 910
 911    /* Gallium drivers requires shared in order to get the handle/stride */
 912    dri_use |= __DRI_IMAGE_USE_SHARE;
 913
 914    bo->image =
 915       dri->image->createImage(dri->screen,
 916                               width, height,
 917                               dri_format, dri_use,
 918                               bo);
 919    if (bo->image == NULL)
 920       goto failed;
 921
 922    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 923                           &bo->base.base.handle.s32);
 924    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 925                           (int *) &bo->base.base.stride);
 926
 927    return &bo->base.base;
 928
 929 failed:
 930    free(bo);
 931    return NULL;
 932 }
 933
 934 static void *
 935 gbm_dri_bo_map(struct gbm_bo *_bo,
 936               uint32_t x, uint32_t y,
 937               uint32_t width, uint32_t height,
 938               uint32_t flags, uint32_t *stride, void **map_data)
 939 {
 940    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 941    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 942
 943    /* If it's a dumb buffer, we already have a mapping */
 944    if (bo->map) {
 945       *map_data = (char *)bo->map + (bo->base.base.stride * y) + (x * 4);
 946       *stride = bo->base.base.stride;
 947       return *map_data;
 948    }
 949
 950    if (!dri->image || dri->image->base.version < 12) {
 951       errno = ENOSYS;
 952       return NULL;
 953    }
 954
 955    mtx_lock(&dri->mutex);
 956    if (!dri->context)
 957       dri->context = dri->dri2->createNewContext(dri->screen, NULL,
 958                                                  NULL, NULL);
 959    assert(dri->context);
 960    mtx_unlock(&dri->mutex);
 961
 962    /* GBM flags and DRI flags are the same, so just pass them on */
 963    return dri->image->mapImage(dri->context, bo->image, x, y,
 964                                width, height, flags, (int *)stride,
 965                                map_data);
 966 }
 967
 968 static void
 969 gbm_dri_bo_unmap(struct gbm_bo *_bo, void *map_data)
 970 {
 971    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 972    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 973
 974    /* Check if it's a dumb buffer and check the pointer is in range */
 975    if (bo->map) {
 976       assert(map_data >= bo->map);
 977       assert(map_data < (bo->map + bo->size));
 978       return;
 979    }
 980
 981    if (!dri->context || !dri->image || dri->image->base.version < 12)
 982       return;
 983
 984    dri->image->unmapImage(dri->context, bo->image, map_data);
 985 }
 986
 987
 988 static struct gbm_surface *
 989 gbm_dri_surface_create(struct gbm_device *gbm,
 990                        uint32_t width, uint32_t height,
 991                        uint32_t format, uint32_t flags)
 992 {
 993    struct gbm_dri_surface *surf;
 994
 995    surf = calloc(1, sizeof *surf);
 996    if (surf == NULL)
 997       return NULL;
 998
 999    surf->base.gbm = gbm;
1000    surf->base.width = width;
1001    surf->base.height = height;
1002    surf->base.format = format;
1003    surf->base.flags = flags;
1004
1005    return &surf->base;
1006 }
1007
1008 static void
1009 gbm_dri_surface_destroy(struct gbm_surface *_surf)
1010 {
1011    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
1012
1013    free(surf);
1014 }
1015
1016 static void
1017 dri_destroy(struct gbm_device *gbm)
1018 {
1019    struct gbm_dri_device *dri = gbm_dri_device(gbm);
1020    unsigned i;
1021
1022    if (dri->context)
1023       dri->core->destroyContext(dri->context);
1024
1025    dri->core->destroyScreen(dri->screen);
1026    for (i = 0; dri->driver_configs[i]; i++)
1027       free((__DRIconfig *) dri->driver_configs[i]);
1028    free(dri->driver_configs);
1029    dlclose(dri->driver);
1030    free(dri->base.driver_name);
1031
1032    free(dri);
1033 }
1034
1035 static struct gbm_device *
1036 dri_device_create(int fd)
1037 {
1038    struct gbm_dri_device *dri;
1039    int ret, force_sw;
1040
1041    dri = calloc(1, sizeof *dri);
1042    if (!dri)
1043       return NULL;
1044
1045    dri->base.base.fd = fd;
1046    dri->base.base.bo_create = gbm_dri_bo_create;
1047    dri->base.base.bo_import = gbm_dri_bo_import;
1048    dri->base.base.bo_map = gbm_dri_bo_map;
1049    dri->base.base.bo_unmap = gbm_dri_bo_unmap;
1050    dri->base.base.is_format_supported = gbm_dri_is_format_supported;
1051    dri->base.base.bo_write = gbm_dri_bo_write;
1052    dri->base.base.bo_get_fd = gbm_dri_bo_get_fd;
1053    dri->base.base.bo_destroy = gbm_dri_bo_destroy;
1054    dri->base.base.destroy = dri_destroy;
1055    dri->base.base.surface_create = gbm_dri_surface_create;
1056    dri->base.base.surface_destroy = gbm_dri_surface_destroy;
1057
1058    dri->base.type = GBM_DRM_DRIVER_TYPE_DRI;
1059    dri->base.base.name = "drm";
1060
1061    mtx_init(&dri->mutex, mtx_plain);
1062
1063    force_sw = getenv("GBM_ALWAYS_SOFTWARE") != NULL;
1064    if (!force_sw) {
1065       ret = dri_screen_create(dri);
1066       if (ret)
1067          ret = dri_screen_create_sw(dri);
1068    } else {
1069       ret = dri_screen_create_sw(dri);
1070    }
1071
1072    if (ret)
1073       goto err_dri;
1074
1075    return &dri->base.base;
1076
1077 err_dri:
1078    free(dri);
1079
1080    return NULL;
1081 }
1082
1083 struct gbm_backend gbm_dri_backend = {
1084    .backend_name = "dri",
1085    .create_device = dri_device_create,
1086 };