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 <limits.h>
  34
  35 #include <sys/types.h>
  36 #include <unistd.h>
  37 #include <dlfcn.h>
  38
  39 #include <GL/gl.h> /* dri_interface needs GL types */
  40 #include <GL/internal/dri_interface.h>
  41
  42 #include "gbm_driint.h"
  43
  44 #include "gbmint.h"
  45
  46 static __DRIimage *
  47 dri_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
  48 {
  49    struct gbm_dri_device *dri = data;
  50
  51    if (dri->lookup_image == NULL)
  52       return NULL;
  53
  54    return dri->lookup_image(screen, image, dri->lookup_user_data);
  55 }
  56
  57 const __DRIuseInvalidateExtension use_invalidate = {
  58    { __DRI_USE_INVALIDATE, 1 }
  59 };
  60
  61 const __DRIimageLookupExtension image_lookup_extension = {
  62    { __DRI_IMAGE_LOOKUP, 1 },
  63    dri_lookup_egl_image
  64 };
  65
  66 struct dri_extension_match {
  67    const char *name;
  68    int version;
  69    int offset;
  70 };
  71
  72 static struct dri_extension_match dri_core_extensions[] = {
  73    { __DRI_IMAGE, 1, offsetof(struct gbm_dri_device, image) },
  74    { NULL, 0, 0 }
  75 };
  76
  77 static struct dri_extension_match gbm_dri_device_extensions[] = {
  78    { __DRI_CORE, 1, offsetof(struct gbm_dri_device, core) },
  79    { __DRI_DRI2, 1, offsetof(struct gbm_dri_device, dri2) },
  80    { NULL, 0, 0 }
  81 };
  82
  83 static int
  84 dri_bind_extensions(struct gbm_dri_device *dri,
  85                     struct dri_extension_match *matches,
  86                     const __DRIextension **extensions)
  87 {
  88    int i, j, ret = 0;
  89    void *field;
  90
  91    for (i = 0; extensions[i]; i++) {
  92       for (j = 0; matches[j].name; j++) {
  93          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
  94              extensions[i]->version >= matches[j].version) {
  95             field = ((char *) dri + matches[j].offset);
  96             *(const __DRIextension **) field = extensions[i];
  97          }
  98       }
  99    }
 100
 101    for (j = 0; matches[j].name; j++) {
 102       field = ((char *) dri + matches[j].offset);
 103       if (*(const __DRIextension **) field == NULL) {
 104          ret = -1;
 105       }
 106    }
 107
 108    return ret;
 109 }
 110
 111 static int
 112 dri_load_driver(struct gbm_dri_device *dri)
 113 {
 114    const __DRIextension **extensions;
 115    char path[PATH_MAX], *search_paths, *p, *next, *end;
 116
 117    search_paths = NULL;
 118    if (geteuid() == getuid()) {
 119       /* don't allow setuid apps to use GBM_DRIVERS_PATH */
 120       search_paths = getenv("GBM_DRIVERS_PATH");
 121    }
 122    if (search_paths == NULL)
 123       search_paths = DEFAULT_DRIVER_DIR;
 124
 125    dri->driver = NULL;
 126    end = search_paths + strlen(search_paths);
 127    for (p = search_paths; p < end && dri->driver == NULL; p = next + 1) {
 128       int len;
 129       next = strchr(p, ':');
 130       if (next == NULL)
 131          next = end;
 132
 133       len = next - p;
 134 #if GLX_USE_TLS
 135       snprintf(path, sizeof path,
 136                "%.*s/tls/%s_dri.so", len, p, dri->base.driver_name);
 137       dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 138 #endif
 139       if (dri->driver == NULL) {
 140          snprintf(path, sizeof path,
 141                   "%.*s/%s_dri.so", len, p, dri->base.driver_name);
 142          dri->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 143          if (dri->driver == NULL)
 144             fprintf(stderr, "failed to open %s: %s\n", path, dlerror());
 145       }
 146    }
 147
 148    if (dri->driver == NULL) {
 149       fprintf(stderr, "gbm: failed to open any driver (search paths %s)",
 150               search_paths);
 151       return -1;
 152    }
 153
 154    extensions = dlsym(dri->driver, __DRI_DRIVER_EXTENSIONS);
 155    if (extensions == NULL) {
 156       fprintf(stderr, "gbm: driver exports no extensions (%s)", dlerror());
 157       dlclose(dri->driver);
 158       return -1;
 159    }
 160
 161
 162    if (dri_bind_extensions(dri, gbm_dri_device_extensions, extensions) < 0) {
 163       dlclose(dri->driver);
 164       fprintf(stderr, "failed to bind extensions\n");
 165       return -1;
 166    }
 167
 168    return 0;
 169 }
 170
 171 static int
 172 dri_screen_create(struct gbm_dri_device *dri)
 173 {
 174    const __DRIextension **extensions;
 175    int ret = 0;
 176
 177    dri->base.driver_name = dri_fd_get_driver_name(dri->base.base.fd);
 178    if (dri->base.driver_name == NULL)
 179       return -1;
 180
 181    ret = dri_load_driver(dri);
 182    if (ret) {
 183       fprintf(stderr, "failed to load driver: %s\n", dri->base.driver_name);
 184       return ret;
 185    };
 186
 187    dri->extensions[0] = &image_lookup_extension.base;
 188    dri->extensions[1] = &use_invalidate.base;
 189    dri->extensions[2] = NULL;
 190
 191    if (dri->dri2 == NULL)
 192       return -1;
 193
 194    dri->screen = dri->dri2->createNewScreen(0, dri->base.base.fd,
 195                                             dri->extensions,
 196                                             &dri->driver_configs, dri);
 197    if (dri->screen == NULL)
 198       return -1;
 199
 200    extensions = dri->core->getExtensions(dri->screen);
 201    if (dri_bind_extensions(dri, dri_core_extensions, extensions) < 0) {
 202       ret = -1;
 203       goto free_screen;
 204    }
 205
 206    dri->lookup_image = NULL;
 207    dri->lookup_user_data = NULL;
 208
 209    return 0;
 210
 211 free_screen:
 212    dri->core->destroyScreen(dri->screen);
 213
 214    return ret;
 215 }
 216
 217 static int
 218 gbm_dri_is_format_supported(struct gbm_device *gbm,
 219                             uint32_t format,
 220                             uint32_t usage)
 221 {
 222    switch (format) {
 223    case GBM_BO_FORMAT_XRGB8888:
 224    case GBM_FORMAT_XRGB8888:
 225       break;
 226    case GBM_BO_FORMAT_ARGB8888:
 227    case GBM_FORMAT_ARGB8888:
 228       if (usage & GBM_BO_USE_SCANOUT)
 229          return 0;
 230       break;
 231    default:
 232       return 0;
 233    }
 234
 235    if (usage & GBM_BO_USE_CURSOR_64X64 &&
 236        usage & GBM_BO_USE_RENDERING)
 237       return 0;
 238
 239    return 1;
 240 }
 241
 242 static void
 243 gbm_dri_bo_destroy(struct gbm_bo *_bo)
 244 {
 245    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 246    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 247
 248    dri->image->destroyImage(bo->image);
 249    free(bo);
 250 }
 251
 252 static uint32_t
 253 gbm_dri_to_gbm_format(uint32_t dri_format)
 254 {
 255    uint32_t ret = 0;
 256
 257    switch (dri_format) {
 258    case __DRI_IMAGE_FORMAT_RGB565:
 259       ret = GBM_FORMAT_RGB565;
 260       break;
 261    case __DRI_IMAGE_FORMAT_XRGB8888:
 262       ret = GBM_FORMAT_XRGB8888;
 263       break;
 264    case __DRI_IMAGE_FORMAT_ARGB8888:
 265       ret = GBM_FORMAT_ARGB8888;
 266       break;
 267    case __DRI_IMAGE_FORMAT_ABGR8888:
 268       ret = GBM_FORMAT_ABGR8888;
 269       break;
 270    default:
 271       ret = 0;
 272       break;
 273    }
 274
 275    return ret;
 276 }
 277
 278 static struct gbm_bo *
 279 gbm_dri_bo_create_from_egl_image(struct gbm_device *gbm,
 280                                  void *egl_dpy, void *egl_img,
 281                                  uint32_t width, uint32_t height,
 282                                  uint32_t usage)
 283 {
 284    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 285    struct gbm_dri_bo *bo;
 286    int dri_format;
 287    unsigned dri_use = 0;
 288
 289    (void) egl_dpy;
 290
 291    if (dri->lookup_image == NULL)
 292       return NULL;
 293
 294    bo = calloc(1, sizeof *bo);
 295    if (bo == NULL)
 296       return NULL;
 297
 298    bo->base.base.gbm = gbm;
 299    bo->base.base.width = width;
 300    bo->base.base.height = height;
 301
 302    __DRIimage *tmp = dri->lookup_image(dri->screen, egl_img,
 303                                        dri->lookup_user_data);
 304
 305    bo->image = dri->image->dupImage(tmp, bo);
 306    if (bo->image == NULL)
 307       return NULL;
 308
 309    if (usage & GBM_BO_USE_SCANOUT)
 310       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 311    if (usage & GBM_BO_USE_CURSOR_64X64)
 312       dri_use |= __DRI_IMAGE_USE_CURSOR;
 313    if (dri->image->base.version >= 2 &&
 314        !dri->image->validateUsage(bo->image, dri_use)) {
 315       free(bo);
 316       return NULL;
 317    }
 318
 319    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 320                           &bo->base.base.handle.s32);
 321    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 322                           (int *) &bo->base.base.pitch);
 323    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_FORMAT,
 324                           &dri_format);
 325
 326    bo->base.base.format = gbm_dri_to_gbm_format(dri_format);
 327
 328    return &bo->base.base;
 329 }
 330
 331 static struct gbm_bo *
 332 gbm_dri_bo_create(struct gbm_device *gbm,
 333                   uint32_t width, uint32_t height,
 334                   uint32_t format, uint32_t usage)
 335 {
 336    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 337    struct gbm_dri_bo *bo;
 338    int dri_format;
 339    unsigned dri_use = 0;
 340
 341    bo = calloc(1, sizeof *bo);
 342    if (bo == NULL)
 343       return NULL;
 344
 345    bo->base.base.gbm = gbm;
 346    bo->base.base.width = width;
 347    bo->base.base.height = height;
 348
 349    switch (format) {
 350    case GBM_FORMAT_RGB565:
 351       dri_format =__DRI_IMAGE_FORMAT_RGB565;
 352       break;
 353    case GBM_FORMAT_XRGB8888:
 354    case GBM_BO_FORMAT_XRGB8888:
 355       dri_format = __DRI_IMAGE_FORMAT_XRGB8888;
 356       break;
 357    case GBM_FORMAT_ARGB8888:
 358    case GBM_BO_FORMAT_ARGB8888:
 359       dri_format = __DRI_IMAGE_FORMAT_ARGB8888;
 360       break;
 361    case GBM_FORMAT_ABGR8888:
 362       dri_format = __DRI_IMAGE_FORMAT_ABGR8888;
 363       break;
 364    default:
 365       return NULL;
 366    }
 367
 368    if (usage & GBM_BO_USE_SCANOUT)
 369       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 370    if (usage & GBM_BO_USE_CURSOR_64X64)
 371       dri_use |= __DRI_IMAGE_USE_CURSOR;
 372
 373    bo->image =
 374       dri->image->createImage(dri->screen,
 375                               width, height,
 376                               dri_format, dri_use,
 377                               bo);
 378    if (bo->image == NULL)
 379       return NULL;
 380
 381    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 382                           &bo->base.base.handle.s32);
 383    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 384                           (int *) &bo->base.base.pitch);
 385
 386    return &bo->base.base;
 387 }
 388
 389 static void
 390 dri_destroy(struct gbm_device *gbm)
 391 {
 392    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 393
 394    dri->core->destroyScreen(dri->screen);
 395    free(dri->driver_configs);
 396    dlclose(dri->driver);
 397    free(dri->base.driver_name);
 398
 399    free(dri);
 400 }
 401
 402 static struct gbm_device *
 403 dri_device_create(int fd)
 404 {
 405    struct gbm_dri_device *dri;
 406    int ret;
 407
 408    dri = calloc(1, sizeof *dri);
 409
 410    dri->base.base.fd = fd;
 411    dri->base.base.bo_create = gbm_dri_bo_create;
 412    dri->base.base.bo_create_from_egl_image = gbm_dri_bo_create_from_egl_image;
 413    dri->base.base.is_format_supported = gbm_dri_is_format_supported;
 414    dri->base.base.bo_destroy = gbm_dri_bo_destroy;
 415    dri->base.base.destroy = dri_destroy;
 416
 417    dri->base.type = GBM_DRM_DRIVER_TYPE_DRI;
 418    dri->base.base.name = "drm";
 419
 420    ret = dri_screen_create(dri);
 421    if (ret) {
 422       free(dri);
 423       return NULL;
 424    }
 425
 426    return &dri->base.base;
 427 }
 428
 429 struct gbm_backend gbm_dri_backend = {
 430    .backend_name = "dri",
 431    .create_device = dri_device_create,
 432 };