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                             enum gbm_bo_format format,
 220                             uint32_t usage)
 221 {
 222    switch (format) {
 223    case GBM_BO_FORMAT_XRGB8888:
 224       break;
 225    case GBM_BO_FORMAT_ARGB8888:
 226       if (usage & GBM_BO_USE_SCANOUT)
 227          return 0;
 228       break;
 229    default:
 230       return 0;
 231    }
 232
 233    if (usage & GBM_BO_USE_CURSOR_64X64 &&
 234        usage & GBM_BO_USE_RENDERING)
 235       return 0;
 236
 237    return 1;
 238 }
 239
 240 static void
 241 gbm_dri_bo_destroy(struct gbm_bo *_bo)
 242 {
 243    struct gbm_dri_device *dri = gbm_dri_device(_bo->gbm);
 244    struct gbm_dri_bo *bo = gbm_dri_bo(_bo);
 245
 246    dri->image->destroyImage(bo->image);
 247    free(bo);
 248 }
 249
 250 static struct gbm_bo *
 251 gbm_dri_bo_create_from_egl_image(struct gbm_device *gbm,
 252                                  void *egl_dpy, void *egl_img,
 253                                  uint32_t width, uint32_t height,
 254                                  uint32_t usage)
 255 {
 256    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 257    struct gbm_dri_bo *bo;
 258
 259    (void) egl_dpy;
 260
 261    if (dri->lookup_image == NULL)
 262       return NULL;
 263
 264    bo = calloc(1, sizeof *bo);
 265    if (bo == NULL)
 266       return NULL;
 267
 268    bo->base.base.gbm = gbm;
 269    bo->base.base.width = width;
 270    bo->base.base.height = height;
 271
 272    __DRIimage *tmp = dri->lookup_image(dri->screen, egl_img,
 273                                        dri->lookup_user_data);
 274
 275    bo->image = dri->image->dupImage(tmp, bo);
 276    if (bo->image == NULL)
 277       return NULL;
 278
 279    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 280                           &bo->base.base.handle.s32);
 281    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 282                           (int *) &bo->base.base.pitch);
 283
 284    return &bo->base.base;
 285 }
 286
 287 static struct gbm_bo *
 288 gbm_dri_bo_create(struct gbm_device *gbm,
 289                   uint32_t width, uint32_t height,
 290                   enum gbm_bo_format format, uint32_t usage)
 291 {
 292    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 293    struct gbm_dri_bo *bo;
 294    int dri_format;
 295    unsigned dri_use = 0;
 296
 297    bo = calloc(1, sizeof *bo);
 298    if (bo == NULL)
 299       return NULL;
 300
 301    bo->base.base.gbm = gbm;
 302    bo->base.base.width = width;
 303    bo->base.base.height = height;
 304
 305    switch (format) {
 306    case GBM_BO_FORMAT_XRGB8888:
 307       dri_format = __DRI_IMAGE_FORMAT_XRGB8888;
 308       break;
 309    case GBM_BO_FORMAT_ARGB8888:
 310       dri_format = __DRI_IMAGE_FORMAT_ARGB8888;
 311       break;
 312    default:
 313       return NULL;
 314    }
 315
 316    if (usage & GBM_BO_USE_SCANOUT)
 317       dri_use |= __DRI_IMAGE_USE_SCANOUT;
 318    if (usage & GBM_BO_USE_CURSOR_64X64)
 319       dri_use |= __DRI_IMAGE_USE_CURSOR;
 320
 321    bo->image =
 322       dri->image->createImage(dri->screen,
 323                               width, height,
 324                               dri_format, dri_use,
 325                               bo);
 326    if (bo->image == NULL)
 327       return NULL;
 328
 329    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_HANDLE,
 330                           &bo->base.base.handle.s32);
 331    dri->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE,
 332                           (int *) &bo->base.base.pitch);
 333
 334    return &bo->base.base;
 335 }
 336
 337 static void
 338 dri_destroy(struct gbm_device *gbm)
 339 {
 340    struct gbm_dri_device *dri = gbm_dri_device(gbm);
 341
 342    dri->core->destroyScreen(dri->screen);
 343    free(dri->driver_configs);
 344    dlclose(dri->driver);
 345    free(dri->base.driver_name);
 346
 347    free(dri);
 348 }
 349
 350 static struct gbm_device *
 351 dri_device_create(int fd)
 352 {
 353    struct gbm_dri_device *dri;
 354    int ret;
 355
 356    dri = calloc(1, sizeof *dri);
 357
 358    dri->base.base.fd = fd;
 359    dri->base.base.bo_create = gbm_dri_bo_create;
 360    dri->base.base.bo_create_from_egl_image = gbm_dri_bo_create_from_egl_image;
 361    dri->base.base.is_format_supported = gbm_dri_is_format_supported;
 362    dri->base.base.bo_destroy = gbm_dri_bo_destroy;
 363    dri->base.base.destroy = dri_destroy;
 364
 365    dri->base.type = GBM_DRM_DRIVER_TYPE_DRI;
 366    dri->base.base.name = "drm";
 367
 368    ret = dri_screen_create(dri);
 369    if (ret) {
 370       free(dri);
 371       return NULL;
 372    }
 373
 374    return &dri->base.base;
 375 }
 376
 377 struct gbm_backend gbm_dri_backend = {
 378    .backend_name = "dri",
 379    .create_device = dri_device_create,
 380 };