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