src/egl/drivers/dri2/egl_dri2.c

   1 /*
   2  * Copyright © 2010 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  *    Kristian Høgsberg <krh@bitplanet.net>
  26  */
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <stdio.h>
  31 #include <limits.h>
  32 #include <dlfcn.h>
  33 #include <fcntl.h>
  34 #include <errno.h>
  35 #include <unistd.h>
  36 #include <xf86drm.h>
  37 #include <GL/gl.h>
  38 #include <GL/internal/dri_interface.h>
  39 #include <sys/types.h>
  40 #include <sys/stat.h>
  41
  42 #include "egl_dri2.h"
  43
  44 const __DRIuseInvalidateExtension use_invalidate = {
  45    { __DRI_USE_INVALIDATE, 1 }
  46 };
  47
  48 EGLint dri2_to_egl_attribute_map[] = {
  49    0,
  50    EGL_BUFFER_SIZE,             /* __DRI_ATTRIB_BUFFER_SIZE */
  51    EGL_LEVEL,                   /* __DRI_ATTRIB_LEVEL */
  52    EGL_RED_SIZE,                /* __DRI_ATTRIB_RED_SIZE */
  53    EGL_GREEN_SIZE,              /* __DRI_ATTRIB_GREEN_SIZE */
  54    EGL_BLUE_SIZE,               /* __DRI_ATTRIB_BLUE_SIZE */
  55    EGL_LUMINANCE_SIZE,          /* __DRI_ATTRIB_LUMINANCE_SIZE */
  56    EGL_ALPHA_SIZE,              /* __DRI_ATTRIB_ALPHA_SIZE */
  57    0,                           /* __DRI_ATTRIB_ALPHA_MASK_SIZE */
  58    EGL_DEPTH_SIZE,              /* __DRI_ATTRIB_DEPTH_SIZE */
  59    EGL_STENCIL_SIZE,            /* __DRI_ATTRIB_STENCIL_SIZE */
  60    0,                           /* __DRI_ATTRIB_ACCUM_RED_SIZE */
  61    0,                           /* __DRI_ATTRIB_ACCUM_GREEN_SIZE */
  62    0,                           /* __DRI_ATTRIB_ACCUM_BLUE_SIZE */
  63    0,                           /* __DRI_ATTRIB_ACCUM_ALPHA_SIZE */
  64    EGL_SAMPLE_BUFFERS,          /* __DRI_ATTRIB_SAMPLE_BUFFERS */
  65    EGL_SAMPLES,                 /* __DRI_ATTRIB_SAMPLES */
  66    0,                           /* __DRI_ATTRIB_RENDER_TYPE, */
  67    0,                           /* __DRI_ATTRIB_CONFIG_CAVEAT */
  68    0,                           /* __DRI_ATTRIB_CONFORMANT */
  69    0,                           /* __DRI_ATTRIB_DOUBLE_BUFFER */
  70    0,                           /* __DRI_ATTRIB_STEREO */
  71    0,                           /* __DRI_ATTRIB_AUX_BUFFERS */
  72    0,                           /* __DRI_ATTRIB_TRANSPARENT_TYPE */
  73    0,                           /* __DRI_ATTRIB_TRANSPARENT_INDEX_VALUE */
  74    0,                           /* __DRI_ATTRIB_TRANSPARENT_RED_VALUE */
  75    0,                           /* __DRI_ATTRIB_TRANSPARENT_GREEN_VALUE */
  76    0,                           /* __DRI_ATTRIB_TRANSPARENT_BLUE_VALUE */
  77    0,                           /* __DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE */
  78    0,                           /* __DRI_ATTRIB_FLOAT_MODE */
  79    0,                           /* __DRI_ATTRIB_RED_MASK */
  80    0,                           /* __DRI_ATTRIB_GREEN_MASK */
  81    0,                           /* __DRI_ATTRIB_BLUE_MASK */
  82    0,                           /* __DRI_ATTRIB_ALPHA_MASK */
  83    EGL_MAX_PBUFFER_WIDTH,       /* __DRI_ATTRIB_MAX_PBUFFER_WIDTH */
  84    EGL_MAX_PBUFFER_HEIGHT,      /* __DRI_ATTRIB_MAX_PBUFFER_HEIGHT */
  85    EGL_MAX_PBUFFER_PIXELS,      /* __DRI_ATTRIB_MAX_PBUFFER_PIXELS */
  86    0,                           /* __DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH */
  87    0,                           /* __DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT */
  88    0,                           /* __DRI_ATTRIB_VISUAL_SELECT_GROUP */
  89    0,                           /* __DRI_ATTRIB_SWAP_METHOD */
  90    EGL_MAX_SWAP_INTERVAL,       /* __DRI_ATTRIB_MAX_SWAP_INTERVAL */
  91    EGL_MIN_SWAP_INTERVAL,       /* __DRI_ATTRIB_MIN_SWAP_INTERVAL */
  92    0,                           /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGB */
  93    0,                           /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA */
  94    0,                           /* __DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE */
  95    0,                           /* __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS */
  96    EGL_Y_INVERTED_NOK,          /* __DRI_ATTRIB_YINVERTED */
  97 };
  98
  99 struct dri2_egl_config *
 100 dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
 101                 int depth, EGLint surface_type, const EGLint *attr_list)
 102 {
 103    struct dri2_egl_config *conf;
 104    struct dri2_egl_display *dri2_dpy;
 105    _EGLConfig base;
 106    unsigned int attrib, value, double_buffer;
 107    EGLint key, bind_to_texture_rgb, bind_to_texture_rgba;
 108    _EGLConfig *matching_config;
 109    EGLint num_configs = 0;
 110    EGLint config_id;
 111    int i;
 112
 113    dri2_dpy = disp->DriverData;
 114    _eglInitConfig(&base, disp, id);
 115
 116    i = 0;
 117    double_buffer = 0;
 118    bind_to_texture_rgb = 0;
 119    bind_to_texture_rgba = 0;
 120
 121    while (dri2_dpy->core->indexConfigAttrib(dri_config, i++, &attrib, &value)) {
 122       switch (attrib) {
 123       case __DRI_ATTRIB_RENDER_TYPE:
 124          if (value & __DRI_ATTRIB_RGBA_BIT)
 125             value = EGL_RGB_BUFFER;
 126          else if (value & __DRI_ATTRIB_LUMINANCE_BIT)
 127             value = EGL_LUMINANCE_BUFFER;
 128          else
 129             /* not valid */;
 130          _eglSetConfigKey(&base, EGL_COLOR_BUFFER_TYPE, value);
 131          break;
 132
 133       case __DRI_ATTRIB_CONFIG_CAVEAT:
 134          if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
 135             value = EGL_NON_CONFORMANT_CONFIG;
 136          else if (value & __DRI_ATTRIB_SLOW_BIT)
 137             value = EGL_SLOW_CONFIG;
 138          else
 139             value = EGL_NONE;
 140          _eglSetConfigKey(&base, EGL_CONFIG_CAVEAT, value);
 141          break;
 142
 143       case __DRI_ATTRIB_BIND_TO_TEXTURE_RGB:
 144          bind_to_texture_rgb = value;
 145          break;
 146
 147       case __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA:
 148          bind_to_texture_rgba = value;
 149          break;
 150
 151       case __DRI_ATTRIB_DOUBLE_BUFFER:
 152          double_buffer = value;
 153          break;
 154
 155       default:
 156          key = dri2_to_egl_attribute_map[attrib];
 157          if (key != 0)
 158             _eglSetConfigKey(&base, key, value);
 159          break;
 160       }
 161    }
 162
 163    if (attr_list)
 164       for (i = 0; attr_list[i] != EGL_NONE; i += 2)
 165          _eglSetConfigKey(&base, attr_list[i], attr_list[i+1]);
 166
 167    if (depth > 0 && depth != base.BufferSize)
 168       return NULL;
 169
 170    base.NativeRenderable = EGL_TRUE;
 171
 172    base.SurfaceType = surface_type;
 173    if (surface_type & (EGL_PBUFFER_BIT |
 174        (disp->Extensions.NOK_texture_from_pixmap ? EGL_PIXMAP_BIT : 0))) {
 175       base.BindToTextureRGB = bind_to_texture_rgb;
 176       if (base.AlphaSize > 0)
 177          base.BindToTextureRGBA = bind_to_texture_rgba;
 178    }
 179
 180    base.RenderableType = disp->ClientAPIs;
 181    base.Conformant = disp->ClientAPIs;
 182
 183    if (!_eglValidateConfig(&base, EGL_FALSE)) {
 184       _eglLog(_EGL_DEBUG, "DRI2: failed to validate config %d", id);
 185       return NULL;
 186    }
 187
 188    config_id = base.ConfigID;
 189    base.ConfigID    = EGL_DONT_CARE;
 190    base.SurfaceType = EGL_DONT_CARE;
 191    num_configs = _eglFilterArray(disp->Configs, (void **) &matching_config, 1,
 192                                  (_EGLArrayForEach) _eglMatchConfig, &base);
 193
 194    if (num_configs == 1) {
 195       conf = (struct dri2_egl_config *) matching_config;
 196
 197       if (double_buffer && !conf->dri_double_config)
 198          conf->dri_double_config = dri_config;
 199       else if (!double_buffer && !conf->dri_single_config)
 200          conf->dri_single_config = dri_config;
 201       else
 202          /* a similar config type is already added
 203           * => attach it as new config
 204           */
 205          num_configs = 0;
 206    }
 207
 208    if (num_configs == 0) {
 209       conf = malloc(sizeof *conf);
 210       if (conf == NULL)
 211          return NULL;
 212
 213       memcpy(&conf->base, &base, sizeof base);
 214       if (double_buffer) {
 215          conf->dri_double_config = dri_config;
 216          conf->dri_single_config = NULL;
 217       } else {
 218          conf->dri_single_config = dri_config;
 219          conf->dri_double_config = NULL;
 220       }
 221       conf->base.SurfaceType = 0;
 222       conf->base.ConfigID = config_id;
 223
 224       _eglLinkConfig(&conf->base);
 225    }
 226
 227    conf->base.SurfaceType |= surface_type & (!double_buffer ? EGL_PIXMAP_BIT:
 228          (EGL_WINDOW_BIT | EGL_PBUFFER_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT));
 229
 230    return conf;
 231 }
 232
 233 static __DRIimage *
 234 dri2_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
 235 {
 236    _EGLDisplay *disp = data;
 237    struct dri2_egl_image *dri2_img;
 238    _EGLImage *img;
 239
 240    (void) screen;
 241
 242    img = _eglLookupImage(image, disp);
 243    if (img == NULL) {
 244       _eglError(EGL_BAD_PARAMETER, "dri2_lookup_egl_image");
 245       return NULL;
 246    }
 247
 248    dri2_img = dri2_egl_image(image);
 249
 250    return dri2_img->dri_image;
 251 }
 252
 253 const __DRIimageLookupExtension image_lookup_extension = {
 254    { __DRI_IMAGE_LOOKUP, 1 },
 255    dri2_lookup_egl_image
 256 };
 257
 258 static const char dri_driver_path[] = DEFAULT_DRIVER_DIR;
 259
 260 struct dri2_extension_match {
 261    const char *name;
 262    int version;
 263    int offset;
 264 };
 265
 266 static struct dri2_extension_match dri2_driver_extensions[] = {
 267    { __DRI_CORE, 1, offsetof(struct dri2_egl_display, core) },
 268    { __DRI_DRI2, 1, offsetof(struct dri2_egl_display, dri2) },
 269    { NULL, 0, 0 }
 270 };
 271
 272 static struct dri2_extension_match dri2_core_extensions[] = {
 273    { __DRI2_FLUSH, 1, offsetof(struct dri2_egl_display, flush) },
 274    { __DRI_TEX_BUFFER, 2, offsetof(struct dri2_egl_display, tex_buffer) },
 275    { __DRI_IMAGE, 1, offsetof(struct dri2_egl_display, image) },
 276    { NULL, 0, 0 }
 277 };
 278
 279 static struct dri2_extension_match swrast_driver_extensions[] = {
 280    { __DRI_CORE, 1, offsetof(struct dri2_egl_display, core) },
 281    { __DRI_SWRAST, 2, offsetof(struct dri2_egl_display, swrast) },
 282    { NULL }
 283 };
 284
 285 static struct dri2_extension_match swrast_core_extensions[] = {
 286    { __DRI_TEX_BUFFER, 2, offsetof(struct dri2_egl_display, tex_buffer) },
 287    { NULL }
 288 };
 289
 290 static EGLBoolean
 291 dri2_bind_extensions(struct dri2_egl_display *dri2_dpy,
 292                      struct dri2_extension_match *matches,
 293                      const __DRIextension **extensions)
 294 {
 295    int i, j, ret = EGL_TRUE;
 296    void *field;
 297
 298    for (i = 0; extensions[i]; i++) {
 299       _eglLog(_EGL_DEBUG, "DRI2: found extension `%s'", extensions[i]->name);
 300       for (j = 0; matches[j].name; j++) {
 301          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
 302              extensions[i]->version >= matches[j].version) {
 303             field = ((char *) dri2_dpy + matches[j].offset);
 304             *(const __DRIextension **) field = extensions[i];
 305             _eglLog(_EGL_INFO, "DRI2: found extension %s version %d",
 306                     extensions[i]->name, extensions[i]->version);
 307          }
 308       }
 309    }
 310
 311    for (j = 0; matches[j].name; j++) {
 312       field = ((char *) dri2_dpy + matches[j].offset);
 313       if (*(const __DRIextension **) field == NULL) {
 314          _eglLog(_EGL_FATAL, "DRI2: did not find extension %s version %d",
 315                  matches[j].name, matches[j].version);
 316          ret = EGL_FALSE;
 317       }
 318    }
 319
 320    return ret;
 321 }
 322
 323 EGLBoolean
 324 dri2_load_driver(_EGLDisplay *disp)
 325 {
 326    struct dri2_egl_display *dri2_dpy = disp->DriverData;
 327    const __DRIextension **extensions;
 328    char path[PATH_MAX], *search_paths, *p, *next, *end;
 329
 330    search_paths = NULL;
 331    if (geteuid() == getuid()) {
 332       /* don't allow setuid apps to use LIBGL_DRIVERS_PATH */
 333       search_paths = getenv("LIBGL_DRIVERS_PATH");
 334    }
 335    if (search_paths == NULL)
 336       search_paths = DEFAULT_DRIVER_DIR;
 337
 338    dri2_dpy->driver = NULL;
 339    end = search_paths + strlen(search_paths);
 340    for (p = search_paths; p < end && dri2_dpy->driver == NULL; p = next + 1) {
 341       int len;
 342       next = strchr(p, ':');
 343       if (next == NULL)
 344          next = end;
 345
 346       len = next - p;
 347 #if GLX_USE_TLS
 348       snprintf(path, sizeof path,
 349                "%.*s/tls/%s_dri.so", len, p, dri2_dpy->driver_name);
 350       dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 351 #endif
 352       if (dri2_dpy->driver == NULL) {
 353          snprintf(path, sizeof path,
 354                   "%.*s/%s_dri.so", len, p, dri2_dpy->driver_name);
 355          dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 356          if (dri2_dpy->driver == NULL)
 357             _eglLog(_EGL_DEBUG, "failed to open %s: %s\n", path, dlerror());
 358       }
 359    }
 360
 361    if (dri2_dpy->driver == NULL) {
 362       _eglLog(_EGL_WARNING,
 363               "DRI2: failed to open any driver (search paths %s)",
 364               search_paths);
 365       return EGL_FALSE;
 366    }
 367
 368    _eglLog(_EGL_DEBUG, "DRI2: dlopen(%s)", path);
 369    extensions = dlsym(dri2_dpy->driver, __DRI_DRIVER_EXTENSIONS);
 370    if (extensions == NULL) {
 371       _eglLog(_EGL_WARNING,
 372               "DRI2: driver exports no extensions (%s)", dlerror());
 373       dlclose(dri2_dpy->driver);
 374       return EGL_FALSE;
 375    }
 376
 377    if (strcmp(dri2_dpy->driver_name, "swrast") == 0) {
 378       if (!dri2_bind_extensions(dri2_dpy, swrast_driver_extensions, extensions)) {
 379          dlclose(dri2_dpy->driver);
 380          return EGL_FALSE;
 381       }
 382    } else {
 383       if (!dri2_bind_extensions(dri2_dpy, dri2_driver_extensions, extensions)) {
 384          dlclose(dri2_dpy->driver);
 385          return EGL_FALSE;
 386       }
 387    }
 388
 389    return EGL_TRUE;
 390 }
 391
 392 EGLBoolean
 393 dri2_create_screen(_EGLDisplay *disp)
 394 {
 395    const __DRIextension **extensions;
 396    struct dri2_egl_display *dri2_dpy;
 397    unsigned int api_mask;
 398
 399    dri2_dpy = disp->DriverData;
 400
 401    if (dri2_dpy->dri2) {
 402       dri2_dpy->dri_screen =
 403          dri2_dpy->dri2->createNewScreen(0, dri2_dpy->fd, dri2_dpy->extensions,
 404                                          &dri2_dpy->driver_configs, disp);
 405    } else {
 406       assert(dri2_dpy->swrast);
 407       dri2_dpy->dri_screen =
 408          dri2_dpy->swrast->createNewScreen(0, dri2_dpy->extensions,
 409                                            &dri2_dpy->driver_configs, disp);
 410    }
 411
 412    if (dri2_dpy->dri_screen == NULL) {
 413       _eglLog(_EGL_WARNING, "DRI2: failed to create dri screen");
 414       return EGL_FALSE;
 415    }
 416
 417    extensions = dri2_dpy->core->getExtensions(dri2_dpy->dri_screen);
 418
 419    if (dri2_dpy->dri2) {
 420       if (!dri2_bind_extensions(dri2_dpy, dri2_core_extensions, extensions))
 421          goto cleanup_dri_screen;
 422    } else {
 423       assert(dri2_dpy->swrast);
 424       if (!dri2_bind_extensions(dri2_dpy, swrast_core_extensions, extensions))
 425          goto cleanup_dri_screen;
 426    }
 427
 428    if (dri2_dpy->dri2) {
 429       if (dri2_dpy->dri2->base.version >= 2)
 430          api_mask = dri2_dpy->dri2->getAPIMask(dri2_dpy->dri_screen);
 431       else
 432          api_mask = 1 << __DRI_API_OPENGL;
 433    } else {
 434       assert(dri2_dpy->swrast);
 435       if (dri2_dpy->swrast->base.version >= 2)
 436          api_mask = 1 << __DRI_API_OPENGL | 1 << __DRI_API_GLES | 1 << __DRI_API_GLES2;
 437       else
 438          api_mask = 1 << __DRI_API_OPENGL;
 439    }
 440
 441    disp->ClientAPIs = 0;
 442    if (api_mask & (1 <<__DRI_API_OPENGL))
 443       disp->ClientAPIs |= EGL_OPENGL_BIT;
 444    if (api_mask & (1 <<__DRI_API_GLES))
 445       disp->ClientAPIs |= EGL_OPENGL_ES_BIT;
 446    if (api_mask & (1 << __DRI_API_GLES2))
 447       disp->ClientAPIs |= EGL_OPENGL_ES2_BIT;
 448
 449    if (dri2_dpy->dri2) {
 450       if (dri2_dpy->dri2->base.version >= 2) {
 451          disp->Extensions.KHR_surfaceless_gles1 = EGL_TRUE;
 452          disp->Extensions.KHR_surfaceless_gles2 = EGL_TRUE;
 453          disp->Extensions.KHR_surfaceless_opengl = EGL_TRUE;
 454       }
 455    } else {
 456       assert(dri2_dpy->swrast);
 457       if (dri2_dpy->swrast->base.version >= 2) {
 458          disp->Extensions.KHR_surfaceless_gles1 = EGL_TRUE;
 459          disp->Extensions.KHR_surfaceless_gles2 = EGL_TRUE;
 460          disp->Extensions.KHR_surfaceless_opengl = EGL_TRUE;
 461       }
 462    }
 463
 464    return EGL_TRUE;
 465
 466  cleanup_dri_screen:
 467    dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
 468
 469    return EGL_FALSE;
 470 }
 471
 472 /**
 473  * Called via eglInitialize(), GLX_drv->API.Initialize().
 474  */
 475 static EGLBoolean
 476 dri2_initialize(_EGLDriver *drv, _EGLDisplay *disp)
 477 {
 478    /* not until swrast_dri is supported */
 479    if (disp->Options.UseFallback)
 480       return EGL_FALSE;
 481
 482    switch (disp->Platform) {
 483    case _EGL_PLATFORM_X11:
 484       if (disp->Options.TestOnly)
 485          return EGL_TRUE;
 486       return dri2_initialize_x11(drv, disp);
 487
 488 #ifdef HAVE_LIBUDEV
 489    case _EGL_PLATFORM_DRM:
 490       if (disp->Options.TestOnly)
 491          return EGL_TRUE;
 492       return dri2_initialize_drm(drv, disp);
 493 #ifdef HAVE_WAYLAND_PLATFORM
 494    case _EGL_PLATFORM_WAYLAND:
 495       if (disp->Options.TestOnly)
 496          return EGL_TRUE;
 497       return dri2_initialize_wayland(drv, disp);
 498 #endif
 499 #endif
 500
 501    default:
 502       return EGL_FALSE;
 503    }
 504 }
 505
 506 /**
 507  * Called via eglTerminate(), drv->API.Terminate().
 508  */
 509 static EGLBoolean
 510 dri2_terminate(_EGLDriver *drv, _EGLDisplay *disp)
 511 {
 512    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 513
 514    _eglReleaseDisplayResources(drv, disp);
 515    _eglCleanupDisplay(disp);
 516
 517    dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
 518    if (dri2_dpy->fd)
 519       close(dri2_dpy->fd);
 520    dlclose(dri2_dpy->driver);
 521    if (disp->PlatformDisplay == NULL)
 522       xcb_disconnect(dri2_dpy->conn);
 523    free(dri2_dpy);
 524    disp->DriverData = NULL;
 525
 526    return EGL_TRUE;
 527 }
 528
 529
 530 /**
 531  * Called via eglCreateContext(), drv->API.CreateContext().
 532  */
 533 static _EGLContext *
 534 dri2_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
 535                     _EGLContext *share_list, const EGLint *attrib_list)
 536 {
 537    struct dri2_egl_context *dri2_ctx;
 538    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 539    struct dri2_egl_context *dri2_ctx_shared = dri2_egl_context(share_list);
 540    struct dri2_egl_config *dri2_config = dri2_egl_config(conf);
 541    const __DRIconfig *dri_config;
 542    int api;
 543
 544    (void) drv;
 545
 546    dri2_ctx = malloc(sizeof *dri2_ctx);
 547    if (!dri2_ctx) {
 548       _eglError(EGL_BAD_ALLOC, "eglCreateContext");
 549       return NULL;
 550    }
 551
 552    if (!_eglInitContext(&dri2_ctx->base, disp, conf, attrib_list))
 553       goto cleanup;
 554
 555    switch (dri2_ctx->base.ClientAPI) {
 556    case EGL_OPENGL_ES_API:
 557       switch (dri2_ctx->base.ClientVersion) {
 558       case 1:
 559          api = __DRI_API_GLES;
 560          break;
 561       case 2:
 562          api = __DRI_API_GLES2;
 563          break;
 564       default:
 565          _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
 566          return NULL;
 567       }
 568       break;
 569    case EGL_OPENGL_API:
 570       api = __DRI_API_OPENGL;
 571       break;
 572    default:
 573       _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
 574       return NULL;
 575    }
 576
 577    if (conf != NULL) {
 578       /* The config chosen here isn't necessarily
 579        * used for surfaces later.
 580        * A pixmap surface will use the single config.
 581        * This opportunity depends on disabling the
 582        * doubleBufferMode check in
 583        * src/mesa/main/context.c:check_compatible()
 584        */
 585       if (dri2_config->dri_double_config)
 586          dri_config = dri2_config->dri_double_config;
 587       else
 588          dri_config = dri2_config->dri_single_config;
 589    }
 590    else
 591       dri_config = NULL;
 592
 593    if (dri2_dpy->dri2) {
 594       if (dri2_dpy->dri2->base.version >= 2) {
 595          dri2_ctx->dri_context =
 596             dri2_dpy->dri2->createNewContextForAPI(dri2_dpy->dri_screen,
 597                                                    api,
 598                                                    dri_config,
 599                                                    dri2_ctx_shared ?
 600                                                    dri2_ctx_shared->dri_context : NULL,
 601                                                    dri2_ctx);
 602       } else if (api == __DRI_API_OPENGL) {
 603          dri2_ctx->dri_context =
 604             dri2_dpy->dri2->createNewContext(dri2_dpy->dri_screen,
 605                                              dri_config,
 606                                              dri2_ctx_shared ?
 607                                              dri2_ctx_shared->dri_context : NULL,
 608                                              dri2_ctx);
 609       } else {
 610          /* fail */
 611       }
 612    } else {
 613       assert(dri2_dpy->swrast);
 614       if (dri2_dpy->swrast->base.version >= 2) {
 615          dri2_ctx->dri_context =
 616             dri2_dpy->swrast->createNewContextForAPI(dri2_dpy->dri_screen,
 617                                                      api,
 618                                                      dri_config,
 619                                                      dri2_ctx_shared ?
 620                                                      dri2_ctx_shared->dri_context : NULL,
 621                                                      dri2_ctx);
 622       } else if (api == __DRI_API_OPENGL) {
 623          dri2_ctx->dri_context =
 624             dri2_dpy->core->createNewContext(dri2_dpy->dri_screen,
 625                                              dri_config,
 626                                              dri2_ctx_shared ?
 627                                              dri2_ctx_shared->dri_context : NULL,
 628                                              dri2_ctx);
 629       } else {
 630          /* fail */
 631       }
 632    }
 633
 634    if (!dri2_ctx->dri_context)
 635       goto cleanup;
 636
 637    return &dri2_ctx->base;
 638
 639  cleanup:
 640    free(dri2_ctx);
 641    return NULL;
 642 }
 643
 644 /**
 645  * Called via eglMakeCurrent(), drv->API.MakeCurrent().
 646  */
 647 static EGLBoolean
 648 dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
 649                   _EGLSurface *rsurf, _EGLContext *ctx)
 650 {
 651    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
 652    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 653    struct dri2_egl_surface *dri2_dsurf = dri2_egl_surface(dsurf);
 654    struct dri2_egl_surface *dri2_rsurf = dri2_egl_surface(rsurf);
 655    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
 656    _EGLContext *old_ctx;
 657    _EGLSurface *old_dsurf, *old_rsurf;
 658    __DRIdrawable *ddraw, *rdraw;
 659    __DRIcontext *cctx;
 660
 661    /* make new bindings */
 662    if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
 663       return EGL_FALSE;
 664
 665    /* flush before context switch */
 666    if (old_ctx && dri2_drv->glFlush)
 667       dri2_drv->glFlush();
 668
 669    ddraw = (dri2_dsurf) ? dri2_dsurf->dri_drawable : NULL;
 670    rdraw = (dri2_rsurf) ? dri2_rsurf->dri_drawable : NULL;
 671    cctx = (dri2_ctx) ? dri2_ctx->dri_context : NULL;
 672
 673    if (old_ctx) {
 674       __DRIcontext *old_cctx = dri2_egl_context(old_ctx)->dri_context;
 675       dri2_dpy->core->unbindContext(old_cctx);
 676    }
 677
 678    if ((cctx == NULL && ddraw == NULL && rdraw == NULL) ||
 679        dri2_dpy->core->bindContext(cctx, ddraw, rdraw)) {
 680       if (old_dsurf)
 681          drv->API.DestroySurface(drv, disp, old_dsurf);
 682       if (old_rsurf)
 683          drv->API.DestroySurface(drv, disp, old_rsurf);
 684       /* no destroy? */
 685       if (old_ctx)
 686          _eglPutContext(old_ctx);
 687
 688       return EGL_TRUE;
 689    } else {
 690       /* undo the previous _eglBindContext */
 691       _eglBindContext(old_ctx, old_dsurf, old_rsurf, &ctx, &dsurf, &rsurf);
 692       assert(&dri2_ctx->base == ctx &&
 693              &dri2_dsurf->base == dsurf &&
 694              &dri2_rsurf->base == rsurf);
 695
 696       _eglPutSurface(dsurf);
 697       _eglPutSurface(rsurf);
 698       _eglPutContext(ctx);
 699
 700       _eglPutSurface(old_dsurf);
 701       _eglPutSurface(old_rsurf);
 702       _eglPutContext(old_ctx);
 703
 704       return EGL_FALSE;
 705    }
 706 }
 707
 708 /*
 709  * Called from eglGetProcAddress() via drv->API.GetProcAddress().
 710  */
 711 static _EGLProc
 712 dri2_get_proc_address(_EGLDriver *drv, const char *procname)
 713 {
 714    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
 715
 716    return dri2_drv->get_proc_address(procname);
 717 }
 718
 719 static EGLBoolean
 720 dri2_wait_client(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
 721 {
 722    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 723    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(ctx->DrawSurface);
 724
 725    (void) drv;
 726
 727    /* FIXME: If EGL allows frontbuffer rendering for window surfaces,
 728     * we need to copy fake to real here.*/
 729
 730    (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
 731
 732    return EGL_TRUE;
 733 }
 734
 735 static EGLBoolean
 736 dri2_wait_native(_EGLDriver *drv, _EGLDisplay *disp, EGLint engine)
 737 {
 738    (void) drv;
 739    (void) disp;
 740
 741    if (engine != EGL_CORE_NATIVE_ENGINE)
 742       return _eglError(EGL_BAD_PARAMETER, "eglWaitNative");
 743    /* glXWaitX(); */
 744
 745    return EGL_TRUE;
 746 }
 747
 748 static EGLBoolean
 749 dri2_bind_tex_image(_EGLDriver *drv,
 750                     _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
 751 {
 752    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 753    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
 754    struct dri2_egl_context *dri2_ctx;
 755    _EGLContext *ctx;
 756    GLint format, target;
 757
 758    ctx = _eglGetCurrentContext();
 759    dri2_ctx = dri2_egl_context(ctx);
 760
 761    if (!_eglBindTexImage(drv, disp, surf, buffer))
 762       return EGL_FALSE;
 763
 764    switch (dri2_surf->base.TextureFormat) {
 765    case EGL_TEXTURE_RGB:
 766       format = __DRI_TEXTURE_FORMAT_RGB;
 767       break;
 768    case EGL_TEXTURE_RGBA:
 769       format = __DRI_TEXTURE_FORMAT_RGBA;
 770       break;
 771    default:
 772       assert(0);
 773    }
 774
 775    switch (dri2_surf->base.TextureTarget) {
 776    case EGL_TEXTURE_2D:
 777       target = GL_TEXTURE_2D;
 778       break;
 779    default:
 780       assert(0);
 781    }
 782
 783    (*dri2_dpy->tex_buffer->setTexBuffer2)(dri2_ctx->dri_context,
 784                                           target, format,
 785                                           dri2_surf->dri_drawable);
 786
 787    return EGL_TRUE;
 788 }
 789
 790 static EGLBoolean
 791 dri2_release_tex_image(_EGLDriver *drv,
 792                        _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
 793 {
 794 #if __DRI_TEX_BUFFER_VERSION >= 3
 795    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 796    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
 797    struct dri2_egl_context *dri2_ctx;
 798    _EGLContext *ctx;
 799    GLint  target;
 800
 801    ctx = _eglGetCurrentContext();
 802    dri2_ctx = dri2_egl_context(ctx);
 803
 804    if (!_eglReleaseTexImage(drv, disp, surf, buffer))
 805       return EGL_FALSE;
 806
 807    switch (dri2_surf->base.TextureTarget) {
 808    case EGL_TEXTURE_2D:
 809       target = GL_TEXTURE_2D;
 810       break;
 811    default:
 812       assert(0);
 813    }
 814    if (dri2_dpy->tex_buffer->releaseTexBuffer!=NULL)
 815     (*dri2_dpy->tex_buffer->releaseTexBuffer)(dri2_ctx->dri_context,
 816                                              target,
 817                                              dri2_surf->dri_drawable);
 818 #endif
 819
 820    return EGL_TRUE;
 821 }
 822
 823 static _EGLImage *
 824 dri2_create_image_khr_renderbuffer(_EGLDisplay *disp, _EGLContext *ctx,
 825                                    EGLClientBuffer buffer,
 826                                    const EGLint *attr_list)
 827 {
 828    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 829    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
 830    struct dri2_egl_image *dri2_img;
 831    GLuint renderbuffer = (GLuint) buffer;
 832
 833    if (renderbuffer == 0) {
 834       _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
 835       return EGL_NO_IMAGE_KHR;
 836    }
 837
 838    dri2_img = malloc(sizeof *dri2_img);
 839    if (!dri2_img) {
 840       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
 841       return EGL_NO_IMAGE_KHR;
 842    }
 843
 844    if (!_eglInitImage(&dri2_img->base, disp))
 845       return EGL_NO_IMAGE_KHR;
 846
 847    dri2_img->dri_image =
 848       dri2_dpy->image->createImageFromRenderbuffer(dri2_ctx->dri_context,
 849                                                    renderbuffer,
 850                                                    dri2_img);
 851
 852    return &dri2_img->base;
 853 }
 854
 855 static _EGLImage *
 856 dri2_create_image_mesa_drm_buffer(_EGLDisplay *disp, _EGLContext *ctx,
 857                                   EGLClientBuffer buffer, const EGLint *attr_list)
 858 {
 859    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 860    struct dri2_egl_image *dri2_img;
 861    EGLint format, name, pitch, err;
 862    _EGLImageAttribs attrs;
 863
 864    (void) ctx;
 865
 866    name = (EGLint) buffer;
 867
 868    err = _eglParseImageAttribList(&attrs, disp, attr_list);
 869    if (err != EGL_SUCCESS)
 870       return NULL;
 871
 872    if (attrs.Width <= 0 || attrs.Height <= 0 ||
 873        attrs.DRMBufferStrideMESA <= 0) {
 874       _eglError(EGL_BAD_PARAMETER,
 875                 "bad width, height or stride");
 876       return NULL;
 877    }
 878
 879    switch (attrs.DRMBufferFormatMESA) {
 880    case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
 881       format = __DRI_IMAGE_FORMAT_ARGB8888;
 882       pitch = attrs.DRMBufferStrideMESA;
 883       break;
 884    default:
 885       _eglError(EGL_BAD_PARAMETER,
 886                 "dri2_create_image_khr: unsupported pixmap depth");
 887       return NULL;
 888    }
 889
 890    dri2_img = malloc(sizeof *dri2_img);
 891    if (!dri2_img) {
 892       _eglError(EGL_BAD_ALLOC, "dri2_create_image_mesa_drm");
 893       return NULL;
 894    }
 895
 896    if (!_eglInitImage(&dri2_img->base, disp)) {
 897       free(dri2_img);
 898       return NULL;
 899    }
 900
 901    dri2_img->dri_image =
 902       dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
 903                                            attrs.Width,
 904                                            attrs.Height,
 905                                            format,
 906                                            name,
 907                                            pitch,
 908                                            dri2_img);
 909    if (dri2_img->dri_image == NULL) {
 910       free(dri2_img);
 911       _eglError(EGL_BAD_ALLOC, "dri2_create_image_mesa_drm");
 912       return NULL;
 913    }
 914
 915    return &dri2_img->base;
 916 }
 917
 918 static EGLBoolean
 919 dri2_export_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
 920                           EGLint *name, EGLint *handle, EGLint *stride);
 921
 922 static _EGLImage *
 923 dri2_reference_drm_image(_EGLDisplay *disp, _EGLContext *ctx,
 924                          _EGLImage *image, EGLint width, EGLint height)
 925 {
 926    EGLint attr_list[] = {
 927                 EGL_WIDTH,              0,
 928                 EGL_HEIGHT,             0,
 929                 EGL_DRM_BUFFER_STRIDE_MESA,     0,
 930                 EGL_DRM_BUFFER_FORMAT_MESA,     EGL_DRM_BUFFER_FORMAT_ARGB32_MESA,
 931                 EGL_NONE
 932    };
 933    EGLint name, stride;
 934
 935    dri2_export_drm_image_mesa(disp->Driver, disp, image,
 936                               &name, NULL, &stride);
 937
 938    attr_list[1] = width;
 939    attr_list[3] = height;
 940    attr_list[5] = stride / 4;
 941
 942    return dri2_create_image_mesa_drm_buffer(disp, ctx,
 943                                             (EGLClientBuffer)(intptr_t) name,
 944                                             attr_list);
 945 }
 946
 947 #ifdef HAVE_WAYLAND_PLATFORM
 948 static _EGLImage *
 949 dri2_create_image_wayland_wl_buffer(_EGLDisplay *disp, _EGLContext *ctx,
 950                                     EGLClientBuffer buffer,
 951                                     const EGLint *attr_list)
 952 {
 953         struct wl_drm_buffer *wl_drm_buffer = (struct wl_drm_buffer *) buffer;
 954
 955         (void) attr_list;
 956
 957         return dri2_reference_drm_image(disp, ctx, wl_drm_buffer->image,
 958                                         wl_drm_buffer->buffer.width,
 959                                         wl_drm_buffer->buffer.height);
 960 }
 961 #endif
 962
 963 _EGLImage *
 964 dri2_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
 965                       _EGLContext *ctx, EGLenum target,
 966                       EGLClientBuffer buffer, const EGLint *attr_list)
 967 {
 968    (void) drv;
 969
 970    switch (target) {
 971    case EGL_GL_RENDERBUFFER_KHR:
 972       return dri2_create_image_khr_renderbuffer(disp, ctx, buffer, attr_list);
 973    case EGL_DRM_BUFFER_MESA:
 974       return dri2_create_image_mesa_drm_buffer(disp, ctx, buffer, attr_list);
 975 #ifdef HAVE_WAYLAND_PLATFORM
 976    case EGL_WAYLAND_BUFFER_WL:
 977       return dri2_create_image_wayland_wl_buffer(disp, ctx, buffer, attr_list);
 978 #endif
 979    default:
 980       _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
 981       return EGL_NO_IMAGE_KHR;
 982    }
 983 }
 984
 985 static EGLBoolean
 986 dri2_destroy_image_khr(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *image)
 987 {
 988    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 989    struct dri2_egl_image *dri2_img = dri2_egl_image(image);
 990
 991    (void) drv;
 992
 993    dri2_dpy->image->destroyImage(dri2_img->dri_image);
 994    free(dri2_img);
 995
 996    return EGL_TRUE;
 997 }
 998
 999 static _EGLImage *
1000 dri2_create_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp,
1001                            const EGLint *attr_list)
1002 {
1003    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1004    struct dri2_egl_image *dri2_img;
1005    _EGLImageAttribs attrs;
1006    unsigned int dri_use, valid_mask;
1007    int format;
1008    EGLint err = EGL_SUCCESS;
1009
1010    (void) drv;
1011
1012    dri2_img = malloc(sizeof *dri2_img);
1013    if (!dri2_img) {
1014       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1015       return EGL_NO_IMAGE_KHR;
1016    }
1017
1018    if (!attr_list) {
1019       err = EGL_BAD_PARAMETER;
1020       goto cleanup_img;
1021    }
1022
1023    if (!_eglInitImage(&dri2_img->base, disp)) {
1024       err = EGL_BAD_PARAMETER;
1025       goto cleanup_img;
1026    }
1027
1028    err = _eglParseImageAttribList(&attrs, disp, attr_list);
1029    if (err != EGL_SUCCESS)
1030       goto cleanup_img;
1031
1032    if (attrs.Width <= 0 || attrs.Height <= 0) {
1033       _eglLog(_EGL_WARNING, "bad width or height (%dx%d)",
1034             attrs.Width, attrs.Height);
1035       goto cleanup_img;
1036    }
1037
1038    switch (attrs.DRMBufferFormatMESA) {
1039    case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
1040       format = __DRI_IMAGE_FORMAT_ARGB8888;
1041       break;
1042    default:
1043       _eglLog(_EGL_WARNING, "bad image format value 0x%04x",
1044             attrs.DRMBufferFormatMESA);
1045       goto cleanup_img;
1046    }
1047
1048    valid_mask =
1049       EGL_DRM_BUFFER_USE_SCANOUT_MESA |
1050       EGL_DRM_BUFFER_USE_SHARE_MESA;
1051    if (attrs.DRMBufferUseMESA & ~valid_mask) {
1052       _eglLog(_EGL_WARNING, "bad image use bit 0x%04x",
1053             attrs.DRMBufferUseMESA & ~valid_mask);
1054       goto cleanup_img;
1055    }
1056
1057    dri_use = 0;
1058    if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SHARE_MESA)
1059       dri_use |= __DRI_IMAGE_USE_SHARE;
1060    if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SCANOUT_MESA)
1061       dri_use |= __DRI_IMAGE_USE_SCANOUT;
1062
1063    dri2_img->dri_image =
1064       dri2_dpy->image->createImage(dri2_dpy->dri_screen,
1065                                    attrs.Width, attrs.Height,
1066                                    format, dri_use, dri2_img);
1067    if (dri2_img->dri_image == NULL) {
1068       err = EGL_BAD_ALLOC;
1069       goto cleanup_img;
1070    }
1071
1072    return &dri2_img->base;
1073
1074  cleanup_img:
1075    free(dri2_img);
1076    _eglError(err, "dri2_create_drm_image_mesa");
1077
1078    return EGL_NO_IMAGE_KHR;
1079 }
1080
1081 static EGLBoolean
1082 dri2_export_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
1083                           EGLint *name, EGLint *handle, EGLint *stride)
1084 {
1085    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1086    struct dri2_egl_image *dri2_img = dri2_egl_image(img);
1087
1088    (void) drv;
1089
1090    if (name && !dri2_dpy->image->queryImage(dri2_img->dri_image,
1091                                             __DRI_IMAGE_ATTRIB_NAME, name)) {
1092       _eglError(EGL_BAD_ALLOC, "dri2_export_drm_image_mesa");
1093       return EGL_FALSE;
1094    }
1095
1096    if (handle)
1097       dri2_dpy->image->queryImage(dri2_img->dri_image,
1098                                   __DRI_IMAGE_ATTRIB_HANDLE, handle);
1099
1100    if (stride)
1101       dri2_dpy->image->queryImage(dri2_img->dri_image,
1102                                   __DRI_IMAGE_ATTRIB_STRIDE, stride);
1103
1104    return EGL_TRUE;
1105 }
1106
1107 #ifdef HAVE_WAYLAND_PLATFORM
1108 static EGLBoolean
1109 dri2_bind_wayland_display_wl(_EGLDriver *drv, _EGLDisplay *disp,
1110                              struct wl_display *wl_dpy)
1111 {
1112    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1113
1114    (void) drv;
1115
1116    if (dri2_dpy->wl_server_drm)
1117            return EGL_FALSE;
1118
1119    dri2_dpy->wl_server_drm =
1120            wayland_drm_init(wl_dpy, disp,
1121                             dri2_dpy->authenticate,
1122                             dri2_dpy->device_name);
1123
1124    if (!dri2_dpy->wl_server_drm)
1125            return EGL_FALSE;
1126
1127    return EGL_TRUE;
1128 }
1129
1130 static EGLBoolean
1131 dri2_unbind_wayland_display_wl(_EGLDriver *drv, _EGLDisplay *disp,
1132                                struct wl_display *wl_dpy)
1133 {
1134    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1135
1136    (void) drv;
1137
1138    if (!dri2_dpy->wl_server_drm)
1139            return EGL_FALSE;
1140
1141    wayland_drm_destroy(dri2_dpy->wl_server_drm);
1142    dri2_dpy->wl_server_drm = NULL;
1143
1144    return EGL_TRUE;
1145 }
1146 #endif
1147
1148 static void
1149 dri2_unload(_EGLDriver *drv)
1150 {
1151    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1152
1153    if (dri2_drv->handle)
1154       dlclose(dri2_drv->handle);
1155    free(dri2_drv);
1156 }
1157
1158 static EGLBoolean
1159 dri2_load(_EGLDriver *drv)
1160 {
1161    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1162 #ifdef HAVE_SHARED_GLAPI
1163    const char *libname = "libglapi.so.0";
1164 #else
1165    /*
1166     * Both libGL.so and libglapi.so are glapi providers.  There is no way to
1167     * tell which one to load.
1168     */
1169    const char *libname = NULL;
1170 #endif
1171    void *handle;
1172
1173    /* RTLD_GLOBAL to make sure glapi symbols are visible to DRI drivers */
1174    handle = dlopen(libname, RTLD_LAZY | RTLD_GLOBAL);
1175    if (handle) {
1176       dri2_drv->get_proc_address = (_EGLProc (*)(const char *))
1177          dlsym(handle, "_glapi_get_proc_address");
1178       if (!dri2_drv->get_proc_address || !libname) {
1179          /* no need to keep a reference */
1180          dlclose(handle);
1181          handle = NULL;
1182       }
1183    }
1184
1185    /* if glapi is not available, loading DRI drivers will fail */
1186    if (!dri2_drv->get_proc_address) {
1187       _eglLog(_EGL_WARNING, "DRI2: failed to find _glapi_get_proc_address");
1188       return EGL_FALSE;
1189    }
1190
1191    dri2_drv->glFlush = (void (*)(void))
1192       dri2_drv->get_proc_address("glFlush");
1193
1194    dri2_drv->handle = handle;
1195
1196    return EGL_TRUE;
1197 }
1198
1199 /**
1200  * This is the main entrypoint into the driver, called by libEGL.
1201  * Create a new _EGLDriver object and init its dispatch table.
1202  */
1203 _EGLDriver *
1204 _EGL_MAIN(const char *args)
1205 {
1206    struct dri2_egl_driver *dri2_drv;
1207
1208    (void) args;
1209
1210    dri2_drv = malloc(sizeof *dri2_drv);
1211    if (!dri2_drv)
1212       return NULL;
1213
1214    memset(dri2_drv, 0, sizeof *dri2_drv);
1215
1216    if (!dri2_load(&dri2_drv->base))
1217       return NULL;
1218
1219    _eglInitDriverFallbacks(&dri2_drv->base);
1220    dri2_drv->base.API.Initialize = dri2_initialize;
1221    dri2_drv->base.API.Terminate = dri2_terminate;
1222    dri2_drv->base.API.CreateContext = dri2_create_context;
1223    dri2_drv->base.API.MakeCurrent = dri2_make_current;
1224    dri2_drv->base.API.GetProcAddress = dri2_get_proc_address;
1225    dri2_drv->base.API.WaitClient = dri2_wait_client;
1226    dri2_drv->base.API.WaitNative = dri2_wait_native;
1227    dri2_drv->base.API.BindTexImage = dri2_bind_tex_image;
1228    dri2_drv->base.API.ReleaseTexImage = dri2_release_tex_image;
1229    dri2_drv->base.API.CreateImageKHR = dri2_create_image_khr;
1230    dri2_drv->base.API.DestroyImageKHR = dri2_destroy_image_khr;
1231    dri2_drv->base.API.CreateDRMImageMESA = dri2_create_drm_image_mesa;
1232    dri2_drv->base.API.ExportDRMImageMESA = dri2_export_drm_image_mesa;
1233 #ifdef HAVE_WAYLAND_PLATFORM
1234    dri2_drv->base.API.BindWaylandDisplayWL = dri2_bind_wayland_display_wl;
1235    dri2_drv->base.API.UnbindWaylandDisplayWL = dri2_unbind_wayland_display_wl;
1236 #endif
1237
1238    dri2_drv->base.Name = "DRI2";
1239    dri2_drv->base.Unload = dri2_unload;
1240
1241    return &dri2_drv->base;
1242 }