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 <xcb/xcb.h>
  40 #include <xcb/dri2.h>
  41 #include <xcb/xfixes.h>
  42 #include <X11/Xlib-xcb.h>
  43 #include <sys/types.h>
  44 #include <sys/stat.h>
  45
  46 #ifdef HAVE_LIBUDEV
  47 #include <libudev.h>
  48 #endif
  49
  50 #include <glapi/glapi.h>
  51 #include "eglconfig.h"
  52 #include "eglcontext.h"
  53 #include "egldisplay.h"
  54 #include "egldriver.h"
  55 #include "eglcurrent.h"
  56 #include "egllog.h"
  57 #include "eglsurface.h"
  58 #include "eglimage.h"
  59
  60 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
  61
  62 struct dri2_egl_driver
  63 {
  64    _EGLDriver base;
  65
  66    void (*glFlush)(void);
  67 };
  68
  69 struct dri2_egl_display
  70 {
  71    xcb_connection_t         *conn;
  72    int                       dri2_major;
  73    int                       dri2_minor;
  74    __DRIscreen              *dri_screen;
  75    const __DRIconfig       **driver_configs;
  76    void                     *driver;
  77    __DRIcoreExtension       *core;
  78    __DRIdri2Extension       *dri2;
  79    __DRI2flushExtension     *flush;
  80    __DRItexBufferExtension  *tex_buffer;
  81    __DRIimageExtension      *image;
  82    int                       fd;
  83
  84    char                     *device_name;
  85    char                     *driver_name;
  86
  87    __DRIdri2LoaderExtension  loader_extension;
  88    const __DRIextension     *extensions[3];
  89 };
  90
  91 struct dri2_egl_context
  92 {
  93    _EGLContext   base;
  94    __DRIcontext *dri_context;
  95 };
  96
  97 struct dri2_egl_surface
  98 {
  99    _EGLSurface          base;
 100    __DRIdrawable       *dri_drawable;
 101    xcb_drawable_t       drawable;
 102    __DRIbuffer          buffers[5];
 103    int                  buffer_count;
 104    xcb_xfixes_region_t  region;
 105    int                  have_fake_front;
 106    int                  swap_interval;
 107 };
 108
 109 struct dri2_egl_config
 110 {
 111    _EGLConfig         base;
 112    const __DRIconfig *dri_config;
 113 };
 114
 115 struct dri2_egl_image
 116 {
 117    _EGLImage   base;
 118    __DRIimage *dri_image;
 119 };
 120
 121 /* standard typecasts */
 122 _EGL_DRIVER_STANDARD_TYPECASTS(dri2_egl)
 123 _EGL_DRIVER_TYPECAST(dri2_egl_image, _EGLImage, obj)
 124
 125 static const __DRIuseInvalidateExtension use_invalidate = {
 126    { __DRI_USE_INVALIDATE, 1 }
 127 };
 128
 129 EGLint dri2_to_egl_attribute_map[] = {
 130    0,
 131    EGL_BUFFER_SIZE,             /* __DRI_ATTRIB_BUFFER_SIZE */
 132    EGL_LEVEL,                   /* __DRI_ATTRIB_LEVEL */
 133    EGL_RED_SIZE,                /* __DRI_ATTRIB_RED_SIZE */
 134    EGL_GREEN_SIZE,              /* __DRI_ATTRIB_GREEN_SIZE */
 135    EGL_BLUE_SIZE,               /* __DRI_ATTRIB_BLUE_SIZE */
 136    EGL_LUMINANCE_SIZE,          /* __DRI_ATTRIB_LUMINANCE_SIZE */
 137    EGL_ALPHA_SIZE,              /* __DRI_ATTRIB_ALPHA_SIZE */
 138    0,                           /* __DRI_ATTRIB_ALPHA_MASK_SIZE */
 139    EGL_DEPTH_SIZE,              /* __DRI_ATTRIB_DEPTH_SIZE */
 140    EGL_STENCIL_SIZE,            /* __DRI_ATTRIB_STENCIL_SIZE */
 141    0,                           /* __DRI_ATTRIB_ACCUM_RED_SIZE */
 142    0,                           /* __DRI_ATTRIB_ACCUM_GREEN_SIZE */
 143    0,                           /* __DRI_ATTRIB_ACCUM_BLUE_SIZE */
 144    0,                           /* __DRI_ATTRIB_ACCUM_ALPHA_SIZE */
 145    EGL_SAMPLE_BUFFERS,          /* __DRI_ATTRIB_SAMPLE_BUFFERS */
 146    EGL_SAMPLES,                 /* __DRI_ATTRIB_SAMPLES */
 147    0,                           /* __DRI_ATTRIB_RENDER_TYPE, */
 148    0,                           /* __DRI_ATTRIB_CONFIG_CAVEAT */
 149    0,                           /* __DRI_ATTRIB_CONFORMANT */
 150    0,                           /* __DRI_ATTRIB_DOUBLE_BUFFER */
 151    0,                           /* __DRI_ATTRIB_STEREO */
 152    0,                           /* __DRI_ATTRIB_AUX_BUFFERS */
 153    0,                           /* __DRI_ATTRIB_TRANSPARENT_TYPE */
 154    0,                           /* __DRI_ATTRIB_TRANSPARENT_INDEX_VALUE */
 155    0,                           /* __DRI_ATTRIB_TRANSPARENT_RED_VALUE */
 156    0,                           /* __DRI_ATTRIB_TRANSPARENT_GREEN_VALUE */
 157    0,                           /* __DRI_ATTRIB_TRANSPARENT_BLUE_VALUE */
 158    0,                           /* __DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE */
 159    0,                           /* __DRI_ATTRIB_FLOAT_MODE */
 160    0,                           /* __DRI_ATTRIB_RED_MASK */
 161    0,                           /* __DRI_ATTRIB_GREEN_MASK */
 162    0,                           /* __DRI_ATTRIB_BLUE_MASK */
 163    0,                           /* __DRI_ATTRIB_ALPHA_MASK */
 164    EGL_MAX_PBUFFER_WIDTH,       /* __DRI_ATTRIB_MAX_PBUFFER_WIDTH */
 165    EGL_MAX_PBUFFER_HEIGHT,      /* __DRI_ATTRIB_MAX_PBUFFER_HEIGHT */
 166    EGL_MAX_PBUFFER_PIXELS,      /* __DRI_ATTRIB_MAX_PBUFFER_PIXELS */
 167    0,                           /* __DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH */
 168    0,                           /* __DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT */
 169    0,                           /* __DRI_ATTRIB_VISUAL_SELECT_GROUP */
 170    0,                           /* __DRI_ATTRIB_SWAP_METHOD */
 171    EGL_MAX_SWAP_INTERVAL,       /* __DRI_ATTRIB_MAX_SWAP_INTERVAL */
 172    EGL_MIN_SWAP_INTERVAL,       /* __DRI_ATTRIB_MIN_SWAP_INTERVAL */
 173    0,                           /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGB */
 174    0,                           /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA */
 175    0,                           /* __DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE */
 176    0,                           /* __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS */
 177    EGL_Y_INVERTED_NOK,          /* __DRI_ATTRIB_YINVERTED */
 178 };
 179
 180 static struct dri2_egl_config *
 181 dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
 182                 int depth, EGLint surface_type)
 183 {
 184    struct dri2_egl_config *conf;
 185    struct dri2_egl_display *dri2_dpy;
 186    _EGLConfig base;
 187    unsigned int attrib, value, double_buffer;
 188    EGLint key, bind_to_texture_rgb, bind_to_texture_rgba;
 189    int i;
 190
 191    dri2_dpy = disp->DriverData;
 192    _eglInitConfig(&base, disp, id);
 193
 194    i = 0;
 195    double_buffer = 0;
 196    bind_to_texture_rgb = 0;
 197    bind_to_texture_rgba = 0;
 198
 199    while (dri2_dpy->core->indexConfigAttrib(dri_config, i++, &attrib, &value)) {
 200       switch (attrib) {
 201       case __DRI_ATTRIB_RENDER_TYPE:
 202          if (value & __DRI_ATTRIB_RGBA_BIT)
 203             value = EGL_RGB_BUFFER;
 204          else if (value & __DRI_ATTRIB_LUMINANCE_BIT)
 205             value = EGL_LUMINANCE_BUFFER;
 206          else
 207             /* not valid */;
 208          _eglSetConfigKey(&base, EGL_COLOR_BUFFER_TYPE, value);
 209          break;
 210
 211       case __DRI_ATTRIB_CONFIG_CAVEAT:
 212          if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
 213             value = EGL_NON_CONFORMANT_CONFIG;
 214          else if (value & __DRI_ATTRIB_SLOW_BIT)
 215             value = EGL_SLOW_CONFIG;
 216          else
 217             value = EGL_NONE;
 218          _eglSetConfigKey(&base, EGL_CONFIG_CAVEAT, value);
 219          break;
 220
 221       case __DRI_ATTRIB_BIND_TO_TEXTURE_RGB:
 222          bind_to_texture_rgb = value;
 223          break;
 224
 225       case __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA:
 226          bind_to_texture_rgba = value;
 227          break;
 228
 229       case __DRI_ATTRIB_DOUBLE_BUFFER:
 230          double_buffer = value;
 231          break;
 232
 233       default:
 234          key = dri2_to_egl_attribute_map[attrib];
 235          if (key != 0)
 236             _eglSetConfigKey(&base, key, value);
 237          break;
 238       }
 239    }
 240
 241    /* In EGL, double buffer or not isn't a config attribute.  Pixmaps
 242     * surfaces are always single buffered, pbuffer surfaces are always
 243     * back buffers and windows can be either, selected by passing an
 244     * attribute at window surface construction time.  To support this
 245     * we ignore all double buffer configs and manipulate the buffer we
 246     * return in the getBuffer callback to get the behaviour we want. */
 247
 248    if (double_buffer)
 249       return NULL;
 250
 251    if (depth > 0 && depth != _eglGetConfigKey(&base, EGL_BUFFER_SIZE))
 252       return NULL;
 253
 254    _eglSetConfigKey(&base, EGL_NATIVE_RENDERABLE, EGL_TRUE);
 255
 256    _eglSetConfigKey(&base, EGL_SURFACE_TYPE, surface_type);
 257    if (surface_type & (EGL_PIXMAP_BIT | EGL_PBUFFER_BIT)) {
 258       _eglSetConfigKey(&base, EGL_BIND_TO_TEXTURE_RGB, bind_to_texture_rgb);
 259       if (_eglGetConfigKey(&base, EGL_ALPHA_SIZE) > 0)
 260          _eglSetConfigKey(&base,
 261                           EGL_BIND_TO_TEXTURE_RGBA, bind_to_texture_rgba);
 262    }
 263
 264    _eglSetConfigKey(&base, EGL_RENDERABLE_TYPE, disp->ClientAPIsMask);
 265    _eglSetConfigKey(&base, EGL_CONFORMANT, disp->ClientAPIsMask);
 266
 267    if (!_eglValidateConfig(&base, EGL_FALSE)) {
 268       _eglLog(_EGL_DEBUG, "DRI2: failed to validate config %d", id);
 269       return NULL;
 270    }
 271
 272    conf = malloc(sizeof *conf);
 273    if (conf != NULL) {
 274       memcpy(&conf->base, &base, sizeof base);
 275       conf->dri_config = dri_config;
 276       _eglAddConfig(disp, &conf->base);
 277    }
 278
 279    return conf;
 280 }
 281
 282 /**
 283  * Process list of buffer received from the server
 284  *
 285  * Processes the list of buffers received in a reply from the server to either
 286  * \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat.
 287  */
 288 static void
 289 dri2_process_buffers(struct dri2_egl_surface *dri2_surf,
 290                      xcb_dri2_dri2_buffer_t *buffers, unsigned count)
 291 {
 292    struct dri2_egl_display *dri2_dpy =
 293       dri2_egl_display(dri2_surf->base.Resource.Display);
 294    xcb_rectangle_t rectangle;
 295    unsigned i;
 296
 297    dri2_surf->buffer_count = count;
 298    dri2_surf->have_fake_front = 0;
 299
 300    /* This assumes the DRI2 buffer attachment tokens matches the
 301     * __DRIbuffer tokens. */
 302    for (i = 0; i < count; i++) {
 303       dri2_surf->buffers[i].attachment = buffers[i].attachment;
 304       dri2_surf->buffers[i].name = buffers[i].name;
 305       dri2_surf->buffers[i].pitch = buffers[i].pitch;
 306       dri2_surf->buffers[i].cpp = buffers[i].cpp;
 307       dri2_surf->buffers[i].flags = buffers[i].flags;
 308
 309       /* We only use the DRI drivers single buffer configs.  This
 310        * means that if we try to render to a window, DRI2 will give us
 311        * the fake front buffer, which we'll use as a back buffer.
 312        * Note that EGL doesn't require that several clients rendering
 313        * to the same window must see the same aux buffers. */
 314       if (dri2_surf->buffers[i].attachment == __DRI_BUFFER_FAKE_FRONT_LEFT)
 315          dri2_surf->have_fake_front = 1;
 316    }
 317
 318    if (dri2_surf->region != XCB_NONE)
 319       xcb_xfixes_destroy_region(dri2_dpy->conn, dri2_surf->region);
 320
 321    rectangle.x = 0;
 322    rectangle.y = 0;
 323    rectangle.width = dri2_surf->base.Width;
 324    rectangle.height = dri2_surf->base.Height;
 325    dri2_surf->region = xcb_generate_id(dri2_dpy->conn);
 326    xcb_xfixes_create_region(dri2_dpy->conn, dri2_surf->region, 1, &rectangle);
 327 }
 328
 329 static __DRIbuffer *
 330 dri2_get_buffers(__DRIdrawable * driDrawable,
 331                 int *width, int *height,
 332                 unsigned int *attachments, int count,
 333                 int *out_count, void *loaderPrivate)
 334 {
 335    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 336    struct dri2_egl_display *dri2_dpy =
 337       dri2_egl_display(dri2_surf->base.Resource.Display);
 338    xcb_dri2_dri2_buffer_t *buffers;
 339    xcb_dri2_get_buffers_reply_t *reply;
 340    xcb_dri2_get_buffers_cookie_t cookie;
 341
 342    (void) driDrawable;
 343
 344    cookie = xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
 345                                             dri2_surf->drawable,
 346                                             count, count, attachments);
 347    reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn, cookie, NULL);
 348    buffers = xcb_dri2_get_buffers_buffers (reply);
 349    if (buffers == NULL)
 350       return NULL;
 351
 352    *out_count = reply->count;
 353    dri2_surf->base.Width = *width = reply->width;
 354    dri2_surf->base.Height = *height = reply->height;
 355    dri2_process_buffers(dri2_surf, buffers, *out_count);
 356
 357    free(reply);
 358
 359    return dri2_surf->buffers;
 360 }
 361
 362 static void
 363 dri2_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
 364 {
 365    (void) driDrawable;
 366
 367    /* FIXME: Does EGL support front buffer rendering at all? */
 368
 369 #if 0
 370    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 371
 372    dri2WaitGL(dri2_surf);
 373 #else
 374    (void) loaderPrivate;
 375 #endif
 376 }
 377
 378 static __DRIimage *
 379 dri2_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
 380 {
 381    _EGLDisplay *disp = data;
 382    struct dri2_egl_image *dri2_img;
 383    _EGLImage *img;
 384
 385    (void) screen;
 386
 387    img = _eglLookupImage(image, disp);
 388    if (img == NULL) {
 389       _eglError(EGL_BAD_PARAMETER, "dri2_lookup_egl_image");
 390       return NULL;
 391    }
 392
 393    dri2_img = dri2_egl_image(image);
 394
 395    return dri2_img->dri_image;
 396 }
 397
 398 static const __DRIimageLookupExtension image_lookup_extension = {
 399    { __DRI_IMAGE_LOOKUP, 1 },
 400    dri2_lookup_egl_image
 401 };
 402
 403 static __DRIbuffer *
 404 dri2_get_buffers_with_format(__DRIdrawable * driDrawable,
 405                              int *width, int *height,
 406                              unsigned int *attachments, int count,
 407                              int *out_count, void *loaderPrivate)
 408 {
 409    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 410    struct dri2_egl_display *dri2_dpy =
 411       dri2_egl_display(dri2_surf->base.Resource.Display);
 412    xcb_dri2_dri2_buffer_t *buffers;
 413    xcb_dri2_get_buffers_with_format_reply_t *reply;
 414    xcb_dri2_get_buffers_with_format_cookie_t cookie;
 415    xcb_dri2_attach_format_t *format_attachments;
 416
 417    (void) driDrawable;
 418
 419    format_attachments = (xcb_dri2_attach_format_t *) attachments;
 420    cookie = xcb_dri2_get_buffers_with_format_unchecked (dri2_dpy->conn,
 421                                                         dri2_surf->drawable,
 422                                                         count, count,
 423                                                         format_attachments);
 424
 425    reply = xcb_dri2_get_buffers_with_format_reply (dri2_dpy->conn,
 426                                                    cookie, NULL);
 427    if (reply == NULL)
 428       return NULL;
 429
 430    buffers = xcb_dri2_get_buffers_with_format_buffers (reply);
 431    dri2_surf->base.Width = *width = reply->width;
 432    dri2_surf->base.Height = *height = reply->height;
 433    *out_count = reply->count;
 434    dri2_process_buffers(dri2_surf, buffers, *out_count);
 435
 436    free(reply);
 437
 438    return dri2_surf->buffers;
 439 }
 440
 441 static const char dri_driver_path[] = DEFAULT_DRIVER_DIR;
 442
 443 struct dri2_extension_match {
 444    const char *name;
 445    int version;
 446    int offset;
 447 };
 448
 449 static struct dri2_extension_match dri2_driver_extensions[] = {
 450    { __DRI_CORE, 1, offsetof(struct dri2_egl_display, core) },
 451    { __DRI_DRI2, 1, offsetof(struct dri2_egl_display, dri2) },
 452    { NULL, 0, 0 }
 453 };
 454
 455 static struct dri2_extension_match dri2_core_extensions[] = {
 456    { __DRI2_FLUSH, 1, offsetof(struct dri2_egl_display, flush) },
 457    { __DRI_TEX_BUFFER, 2, offsetof(struct dri2_egl_display, tex_buffer) },
 458    { __DRI_IMAGE, 1, offsetof(struct dri2_egl_display, image) },
 459    { NULL, 0, 0 }
 460 };
 461
 462 static EGLBoolean
 463 dri2_bind_extensions(struct dri2_egl_display *dri2_dpy,
 464                      struct dri2_extension_match *matches,
 465                      const __DRIextension **extensions)
 466 {
 467    int i, j, ret = EGL_TRUE;
 468    void *field;
 469
 470    for (i = 0; extensions[i]; i++) {
 471       _eglLog(_EGL_DEBUG, "DRI2: found extension `%s'", extensions[i]->name);
 472       for (j = 0; matches[j].name; j++) {
 473          if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
 474              extensions[i]->version >= matches[j].version) {
 475             field = ((char *) dri2_dpy + matches[j].offset);
 476             *(const __DRIextension **) field = extensions[i];
 477             _eglLog(_EGL_INFO, "DRI2: found extension %s version %d",
 478                     extensions[i]->name, extensions[i]->version);
 479          }
 480       }
 481    }
 482
 483    for (j = 0; matches[j].name; j++) {
 484       field = ((char *) dri2_dpy + matches[j].offset);
 485       if (*(const __DRIextension **) field == NULL) {
 486          _eglLog(_EGL_FATAL, "DRI2: did not find extension %s version %d",
 487                  matches[j].name, matches[j].version);
 488          ret = EGL_FALSE;
 489       }
 490    }
 491
 492    return ret;
 493 }
 494
 495 static char *
 496 dri2_strndup(const char *s, int length)
 497 {
 498    char *d;
 499
 500    d = malloc(length + 1);
 501    if (d == NULL)
 502       return NULL;
 503
 504    memcpy(d, s, length);
 505    d[length] = '\0';
 506
 507    return d;
 508 }
 509
 510 static EGLBoolean
 511 dri2_connect(struct dri2_egl_display *dri2_dpy)
 512 {
 513    xcb_xfixes_query_version_reply_t *xfixes_query;
 514    xcb_xfixes_query_version_cookie_t xfixes_query_cookie;
 515    xcb_dri2_query_version_reply_t *dri2_query;
 516    xcb_dri2_query_version_cookie_t dri2_query_cookie;
 517    xcb_dri2_connect_reply_t *connect;
 518    xcb_dri2_connect_cookie_t connect_cookie;
 519    xcb_generic_error_t *error;
 520    xcb_screen_iterator_t s;
 521
 522    xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_xfixes_id);
 523    xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_dri2_id);
 524
 525    xfixes_query_cookie = xcb_xfixes_query_version(dri2_dpy->conn,
 526                                                   XCB_XFIXES_MAJOR_VERSION,
 527                                                   XCB_XFIXES_MINOR_VERSION);
 528
 529    dri2_query_cookie = xcb_dri2_query_version (dri2_dpy->conn,
 530                                                XCB_DRI2_MAJOR_VERSION,
 531                                                XCB_DRI2_MINOR_VERSION);
 532
 533    s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
 534    connect_cookie = xcb_dri2_connect_unchecked (dri2_dpy->conn,
 535                                                 s.data->root,
 536                                                 XCB_DRI2_DRIVER_TYPE_DRI);
 537
 538    xfixes_query =
 539       xcb_xfixes_query_version_reply (dri2_dpy->conn,
 540                                       xfixes_query_cookie, &error);
 541    if (xfixes_query == NULL ||
 542        error != NULL || xfixes_query->major_version < 2) {
 543       _eglLog(_EGL_FATAL, "DRI2: failed to query xfixes version");
 544       free(error);
 545       return EGL_FALSE;
 546    }
 547    free(xfixes_query);
 548
 549    dri2_query =
 550       xcb_dri2_query_version_reply (dri2_dpy->conn, dri2_query_cookie, &error);
 551    if (dri2_query == NULL || error != NULL) {
 552       _eglLog(_EGL_FATAL, "DRI2: failed to query version");
 553       free(error);
 554       return EGL_FALSE;
 555    }
 556    dri2_dpy->dri2_major = dri2_query->major_version;
 557    dri2_dpy->dri2_minor = dri2_query->minor_version;
 558    free(dri2_query);
 559
 560    connect = xcb_dri2_connect_reply (dri2_dpy->conn, connect_cookie, NULL);
 561    if (connect == NULL ||
 562        connect->driver_name_length + connect->device_name_length == 0) {
 563       _eglLog(_EGL_FATAL, "DRI2: failed to authenticate");
 564       return EGL_FALSE;
 565    }
 566
 567    dri2_dpy->device_name =
 568       dri2_strndup(xcb_dri2_connect_device_name (connect),
 569                    xcb_dri2_connect_device_name_length (connect));
 570
 571    dri2_dpy->driver_name =
 572       dri2_strndup(xcb_dri2_connect_driver_name (connect),
 573                    xcb_dri2_connect_driver_name_length (connect));
 574
 575    if (dri2_dpy->device_name == NULL || dri2_dpy->driver_name == NULL) {
 576       free(dri2_dpy->device_name);
 577       free(dri2_dpy->driver_name);
 578       free(connect);
 579       return EGL_FALSE;
 580    }
 581    free(connect);
 582
 583    return EGL_TRUE;
 584 }
 585
 586 static EGLBoolean
 587 dri2_authenticate(struct dri2_egl_display *dri2_dpy)
 588 {
 589    xcb_dri2_authenticate_reply_t *authenticate;
 590    xcb_dri2_authenticate_cookie_t authenticate_cookie;
 591    xcb_screen_iterator_t s;
 592    drm_magic_t magic;
 593
 594    if (drmGetMagic(dri2_dpy->fd, &magic)) {
 595       _eglLog(_EGL_FATAL, "DRI2: failed to get drm magic");
 596       return EGL_FALSE;
 597    }
 598
 599    s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
 600    authenticate_cookie =
 601       xcb_dri2_authenticate_unchecked(dri2_dpy->conn, s.data->root, magic);
 602    authenticate =
 603       xcb_dri2_authenticate_reply(dri2_dpy->conn, authenticate_cookie, NULL);
 604    if (authenticate == NULL || !authenticate->authenticated) {
 605       _eglLog(_EGL_FATAL, "DRI2: failed to authenticate");
 606       free(authenticate);
 607       return EGL_FALSE;
 608    }
 609
 610    free(authenticate);
 611
 612    return EGL_TRUE;
 613 }
 614
 615 static EGLBoolean
 616 dri2_add_configs_for_visuals(struct dri2_egl_display *dri2_dpy,
 617                              _EGLDisplay *disp)
 618 {
 619    xcb_screen_iterator_t s;
 620    xcb_depth_iterator_t d;
 621    xcb_visualtype_t *visuals;
 622    int i, j, id;
 623    struct dri2_egl_config *conf;
 624    EGLint surface_type;
 625
 626    s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
 627    d = xcb_screen_allowed_depths_iterator(s.data);
 628    id = 1;
 629
 630    surface_type =
 631       EGL_WINDOW_BIT |
 632       EGL_PIXMAP_BIT |
 633       EGL_PBUFFER_BIT |
 634       EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
 635
 636    while (d.rem > 0) {
 637       EGLBoolean class_added[6] = { 0, };
 638
 639       visuals = xcb_depth_visuals(d.data);
 640       for (i = 0; i < xcb_depth_visuals_length(d.data); i++) {
 641          if (class_added[visuals[i]._class])
 642             continue;
 643
 644          class_added[visuals[i]._class] = EGL_TRUE;
 645          for (j = 0; dri2_dpy->driver_configs[j]; j++) {
 646             conf = dri2_add_config(disp, dri2_dpy->driver_configs[j],
 647                                    id++, d.data->depth, surface_type);
 648             if (conf == NULL)
 649                continue;
 650             _eglSetConfigKey(&conf->base,
 651                              EGL_NATIVE_VISUAL_ID, visuals[i].visual_id);
 652             _eglSetConfigKey(&conf->base,
 653                              EGL_NATIVE_VISUAL_TYPE, visuals[i]._class);
 654          }
 655       }
 656
 657       xcb_depth_next(&d);
 658    }
 659
 660    if (!_eglGetArraySize(disp->Configs)) {
 661       _eglLog(_EGL_WARNING, "DRI2: failed to create any config");
 662       return EGL_FALSE;
 663    }
 664
 665    return EGL_TRUE;
 666 }
 667
 668 static EGLBoolean
 669 dri2_load_driver(_EGLDisplay *disp)
 670 {
 671    struct dri2_egl_display *dri2_dpy = disp->DriverData;
 672    const __DRIextension **extensions;
 673    char path[PATH_MAX], *search_paths, *p, *next, *end;
 674
 675    search_paths = NULL;
 676    if (geteuid() == getuid()) {
 677       /* don't allow setuid apps to use LIBGL_DRIVERS_PATH */
 678       search_paths = getenv("LIBGL_DRIVERS_PATH");
 679    }
 680    if (search_paths == NULL)
 681       search_paths = DEFAULT_DRIVER_DIR;
 682
 683    dri2_dpy->driver = NULL;
 684    end = search_paths + strlen(search_paths);
 685    for (p = search_paths; p < end && dri2_dpy->driver == NULL; p = next + 1) {
 686       int len;
 687       next = strchr(p, ':');
 688       if (next == NULL)
 689          next = end;
 690
 691       len = next - p;
 692 #if GLX_USE_TLS
 693       snprintf(path, sizeof path,
 694                "%.*s/tls/%s_dri.so", len, p, dri2_dpy->driver_name);
 695       dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 696 #endif
 697       if (dri2_dpy->driver == NULL) {
 698          snprintf(path, sizeof path,
 699                   "%.*s/%s_dri.so", len, p, dri2_dpy->driver_name);
 700          dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
 701          if (dri2_dpy->driver == NULL)
 702             _eglLog(_EGL_DEBUG, "failed to open %s: %s\n", path, dlerror());
 703       }
 704    }
 705
 706    if (dri2_dpy->driver == NULL) {
 707       _eglLog(_EGL_WARNING,
 708               "DRI2: failed to open any driver (search paths %s)",
 709               search_paths);
 710       return EGL_FALSE;
 711    }
 712
 713    _eglLog(_EGL_DEBUG, "DRI2: dlopen(%s)", path);
 714    extensions = dlsym(dri2_dpy->driver, __DRI_DRIVER_EXTENSIONS);
 715    if (extensions == NULL) {
 716       _eglLog(_EGL_WARNING,
 717               "DRI2: driver exports no extensions (%s)", dlerror());
 718       dlclose(dri2_dpy->driver);
 719       return EGL_FALSE;
 720    }
 721
 722    if (!dri2_bind_extensions(dri2_dpy, dri2_driver_extensions, extensions)) {
 723       dlclose(dri2_dpy->driver);
 724       return EGL_FALSE;
 725    }
 726
 727    return EGL_TRUE;
 728 }
 729
 730 static EGLBoolean
 731 dri2_create_screen(_EGLDisplay *disp)
 732 {
 733    const __DRIextension **extensions;
 734    struct dri2_egl_display *dri2_dpy;
 735    unsigned int api_mask;
 736
 737    dri2_dpy = disp->DriverData;
 738    dri2_dpy->dri_screen =
 739       dri2_dpy->dri2->createNewScreen(0, dri2_dpy->fd, dri2_dpy->extensions,
 740                                       &dri2_dpy->driver_configs, disp);
 741
 742    if (dri2_dpy->dri_screen == NULL) {
 743       _eglLog(_EGL_WARNING, "DRI2: failed to create dri screen");
 744       return EGL_FALSE;
 745    }
 746
 747    extensions = dri2_dpy->core->getExtensions(dri2_dpy->dri_screen);
 748    if (!dri2_bind_extensions(dri2_dpy, dri2_core_extensions, extensions))
 749       goto cleanup_dri_screen;
 750
 751    if (dri2_dpy->dri2->base.version >= 2)
 752       api_mask = dri2_dpy->dri2->getAPIMask(dri2_dpy->dri_screen);
 753    else
 754       api_mask = __DRI_API_OPENGL;
 755
 756    disp->ClientAPIsMask = 0;
 757    if (api_mask & (1 <<__DRI_API_OPENGL))
 758       disp->ClientAPIsMask |= EGL_OPENGL_BIT;
 759    if (api_mask & (1 <<__DRI_API_GLES))
 760       disp->ClientAPIsMask |= EGL_OPENGL_ES_BIT;
 761    if (api_mask & (1 << __DRI_API_GLES2))
 762       disp->ClientAPIsMask |= EGL_OPENGL_ES2_BIT;
 763
 764    if (dri2_dpy->dri2->base.version >= 2) {
 765       disp->Extensions.KHR_surfaceless_gles1 = EGL_TRUE;
 766       disp->Extensions.KHR_surfaceless_gles2 = EGL_TRUE;
 767       disp->Extensions.KHR_surfaceless_opengl = EGL_TRUE;
 768    }
 769
 770    return EGL_TRUE;
 771
 772  cleanup_dri_screen:
 773    dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
 774
 775    return EGL_FALSE;
 776 }
 777
 778 static EGLBoolean
 779 dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp,
 780                     EGLint *major, EGLint *minor)
 781 {
 782    struct dri2_egl_display *dri2_dpy;
 783
 784    (void) drv;
 785
 786    dri2_dpy = malloc(sizeof *dri2_dpy);
 787    if (!dri2_dpy)
 788       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
 789
 790    disp->DriverData = (void *) dri2_dpy;
 791    if (disp->PlatformDisplay == NULL) {
 792       dri2_dpy->conn = xcb_connect(0, 0);
 793    } else {
 794       dri2_dpy->conn = XGetXCBConnection((Display *) disp->PlatformDisplay);
 795    }
 796
 797    if (xcb_connection_has_error(dri2_dpy->conn)) {
 798       _eglLog(_EGL_WARNING, "DRI2: xcb_connect failed");
 799       goto cleanup_dpy;
 800    }
 801
 802    if (dri2_dpy->conn) {
 803       if (!dri2_connect(dri2_dpy))
 804          goto cleanup_conn;
 805    }
 806
 807    if (!dri2_load_driver(disp))
 808       goto cleanup_conn;
 809
 810    dri2_dpy->fd = open(dri2_dpy->device_name, O_RDWR);
 811    if (dri2_dpy->fd == -1) {
 812       _eglLog(_EGL_WARNING,
 813               "DRI2: could not open %s (%s)", dri2_dpy->device_name,
 814               strerror(errno));
 815       goto cleanup_driver;
 816    }
 817
 818    if (dri2_dpy->conn) {
 819       if (!dri2_authenticate(dri2_dpy))
 820          goto cleanup_fd;
 821    }
 822
 823    if (dri2_dpy->dri2_minor >= 1) {
 824       dri2_dpy->loader_extension.base.name = __DRI_DRI2_LOADER;
 825       dri2_dpy->loader_extension.base.version = 3;
 826       dri2_dpy->loader_extension.getBuffers = dri2_get_buffers;
 827       dri2_dpy->loader_extension.flushFrontBuffer = dri2_flush_front_buffer;
 828       dri2_dpy->loader_extension.getBuffersWithFormat =
 829          dri2_get_buffers_with_format;
 830    } else {
 831       dri2_dpy->loader_extension.base.name = __DRI_DRI2_LOADER;
 832       dri2_dpy->loader_extension.base.version = 2;
 833       dri2_dpy->loader_extension.getBuffers = dri2_get_buffers;
 834       dri2_dpy->loader_extension.flushFrontBuffer = dri2_flush_front_buffer;
 835       dri2_dpy->loader_extension.getBuffersWithFormat = NULL;
 836    }
 837
 838    dri2_dpy->extensions[0] = &dri2_dpy->loader_extension.base;
 839    dri2_dpy->extensions[1] = &image_lookup_extension.base;
 840    dri2_dpy->extensions[2] = NULL;
 841
 842    if (!dri2_create_screen(disp))
 843       goto cleanup_fd;
 844
 845    if (dri2_dpy->conn) {
 846       if (!dri2_add_configs_for_visuals(dri2_dpy, disp))
 847          goto cleanup_configs;
 848    }
 849
 850    disp->Extensions.MESA_drm_image = EGL_TRUE;
 851    disp->Extensions.KHR_image_base = EGL_TRUE;
 852    disp->Extensions.KHR_image_pixmap = EGL_TRUE;
 853    disp->Extensions.KHR_gl_renderbuffer_image = EGL_TRUE;
 854    disp->Extensions.KHR_gl_texture_2D_image = EGL_TRUE;
 855    disp->Extensions.NOK_swap_region = EGL_TRUE;
 856    disp->Extensions.NOK_texture_from_pixmap = EGL_TRUE;
 857
 858    /* we're supporting EGL 1.4 */
 859    *major = 1;
 860    *minor = 4;
 861
 862    return EGL_TRUE;
 863
 864  cleanup_configs:
 865    _eglCleanupDisplay(disp);
 866    dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
 867  cleanup_fd:
 868    close(dri2_dpy->fd);
 869  cleanup_driver:
 870    dlclose(dri2_dpy->driver);
 871  cleanup_conn:
 872    if (disp->PlatformDisplay == NULL)
 873       xcb_disconnect(dri2_dpy->conn);
 874  cleanup_dpy:
 875    free(dri2_dpy);
 876
 877    return EGL_FALSE;
 878 }
 879
 880 #ifdef HAVE_LIBUDEV
 881
 882 struct dri2_driver_map {
 883    int vendor_id;
 884    const char *driver;
 885    const int *chip_ids;
 886    int num_chips_ids;
 887 };
 888
 889 const int i915_chip_ids[] = {
 890    0x3577, /* PCI_CHIP_I830_M */
 891    0x2562, /* PCI_CHIP_845_G */
 892    0x3582, /* PCI_CHIP_I855_GM */
 893    0x2572, /* PCI_CHIP_I865_G */
 894    0x2582, /* PCI_CHIP_I915_G */
 895    0x258a, /* PCI_CHIP_E7221_G */
 896    0x2592, /* PCI_CHIP_I915_GM */
 897    0x2772, /* PCI_CHIP_I945_G */
 898    0x27a2, /* PCI_CHIP_I945_GM */
 899    0x27ae, /* PCI_CHIP_I945_GME */
 900    0x29b2, /* PCI_CHIP_Q35_G */
 901    0x29c2, /* PCI_CHIP_G33_G */
 902    0x29d2, /* PCI_CHIP_Q33_G */
 903    0xa011, /* Pineview */
 904 };
 905
 906 const int i965_chip_ids[] = {
 907    0x29a2, /* PCI_CHIP_I965_G */
 908    0x2992, /* PCI_CHIP_I965_Q */
 909    0x2982, /* PCI_CHIP_I965_G_1 */
 910    0x2972, /* PCI_CHIP_I946_GZ */
 911    0x2a02, /* PCI_CHIP_I965_GM */
 912    0x2a12, /* PCI_CHIP_I965_GME */
 913    0x2a42, /* PCI_CHIP_GM45_GM */
 914    0x2e02, /* PCI_CHIP_IGD_E_G */
 915    0x2e12, /* PCI_CHIP_Q45_G */
 916    0x2e22, /* PCI_CHIP_G45_G */
 917    0x2e32, /* PCI_CHIP_G41_G */
 918 };
 919
 920 const struct dri2_driver_map driver_map[] = {
 921    { 0x8086, "i915", i915_chip_ids, ARRAY_SIZE(i915_chip_ids) },
 922    { 0x8086, "i965", i965_chip_ids, ARRAY_SIZE(i965_chip_ids) },
 923 };
 924
 925 static char *
 926 dri2_get_driver_for_fd(int fd)
 927 {
 928    struct udev *udev;
 929    struct udev_device *device, *parent;
 930    struct stat buf;
 931    const char *pci_id;
 932    char *driver = NULL;
 933    int vendor_id, chip_id, i, j;
 934
 935    udev = udev_new();
 936    if (fstat(fd, &buf) < 0) {
 937       _eglLog(_EGL_WARNING, "EGL-DRI2: failed to stat fd %d", fd);
 938       goto out;
 939    }
 940
 941    device = udev_device_new_from_devnum(udev, 'c', buf.st_rdev);
 942    if (device == NULL) {
 943       _eglLog(_EGL_WARNING,
 944               "EGL-DRI2: could not create udev device for fd %d", fd);
 945       goto out;
 946    }
 947
 948    parent = udev_device_get_parent(device);
 949    if (parent == NULL) {
 950       _eglLog(_EGL_WARNING, "DRI2: could not get parent device");
 951       goto out;
 952    }
 953
 954    pci_id = udev_device_get_property_value(parent, "PCI_ID");
 955    if (pci_id == NULL || sscanf(pci_id, "%x:%x", &vendor_id, &chip_id) != 2) {
 956       _eglLog(_EGL_WARNING, "EGL-DRI2: malformed or no PCI ID");
 957       goto out;
 958    }
 959
 960    for (i = 0; i < ARRAY_SIZE(driver_map); i++) {
 961       if (vendor_id != driver_map[i].vendor_id)
 962          continue;
 963       for (j = 0; j < driver_map[i].num_chips_ids; j++)
 964          if (driver_map[i].chip_ids[j] == chip_id) {
 965             driver = strdup(driver_map[i].driver);
 966             _eglLog(_EGL_DEBUG, "pci id for %d: %04x:%04x, driver %s",
 967                     fd, vendor_id, chip_id, driver);
 968             goto out;
 969          }
 970    }
 971
 972  out:
 973    udev_device_unref(device);
 974    udev_unref(udev);
 975
 976    return driver;
 977 }
 978
 979 static EGLBoolean
 980 dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp,
 981                     EGLint *major, EGLint *minor)
 982 {
 983    struct dri2_egl_display *dri2_dpy;
 984    int i;
 985
 986    dri2_dpy = malloc(sizeof *dri2_dpy);
 987    if (!dri2_dpy)
 988       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
 989
 990    disp->DriverData = (void *) dri2_dpy;
 991    dri2_dpy->fd = (int) disp->PlatformDisplay;
 992
 993    dri2_dpy->driver_name = dri2_get_driver_for_fd(dri2_dpy->fd);
 994    if (dri2_dpy->driver_name == NULL)
 995       return _eglError(EGL_BAD_ALLOC, "DRI2: failed to get driver name");
 996
 997    if (!dri2_load_driver(disp))
 998       goto cleanup_driver_name;
 999
1000    dri2_dpy->extensions[0] = &image_lookup_extension.base;
1001    dri2_dpy->extensions[1] = &use_invalidate.base;
1002    dri2_dpy->extensions[2] = NULL;
1003
1004    if (!dri2_create_screen(disp))
1005       goto cleanup_driver;
1006
1007    for (i = 0; dri2_dpy->driver_configs[i]; i++)
1008       dri2_add_config(disp, dri2_dpy->driver_configs[i], i + 1, 0, 0);
1009
1010    disp->Extensions.MESA_drm_image = EGL_TRUE;
1011    disp->Extensions.KHR_image_base = EGL_TRUE;
1012    disp->Extensions.KHR_gl_renderbuffer_image = EGL_TRUE;
1013    disp->Extensions.KHR_gl_texture_2D_image = EGL_TRUE;
1014
1015    /* we're supporting EGL 1.4 */
1016    *major = 1;
1017    *minor = 4;
1018
1019    return EGL_TRUE;
1020
1021  cleanup_driver:
1022    dlclose(dri2_dpy->driver);
1023  cleanup_driver_name:
1024    free(dri2_dpy->driver_name);
1025
1026    return EGL_FALSE;
1027 }
1028
1029 #endif
1030
1031 /**
1032  * Called via eglInitialize(), GLX_drv->API.Initialize().
1033  */
1034 static EGLBoolean
1035 dri2_initialize(_EGLDriver *drv, _EGLDisplay *disp,
1036                 EGLint *major, EGLint *minor)
1037 {
1038    switch (disp->Platform) {
1039    case _EGL_PLATFORM_X11:
1040       return dri2_initialize_x11(drv, disp, major, minor);
1041
1042 #ifdef HAVE_LIBUDEV
1043    case _EGL_PLATFORM_DRM:
1044       return dri2_initialize_drm(drv, disp, major, minor);
1045 #endif
1046
1047    default:
1048       return EGL_FALSE;
1049    }
1050 }
1051
1052 /**
1053  * Called via eglTerminate(), drv->API.Terminate().
1054  */
1055 static EGLBoolean
1056 dri2_terminate(_EGLDriver *drv, _EGLDisplay *disp)
1057 {
1058    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1059
1060    _eglReleaseDisplayResources(drv, disp);
1061    _eglCleanupDisplay(disp);
1062
1063    dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
1064    close(dri2_dpy->fd);
1065    dlclose(dri2_dpy->driver);
1066    if (disp->PlatformDisplay == NULL)
1067       xcb_disconnect(dri2_dpy->conn);
1068    free(dri2_dpy);
1069    disp->DriverData = NULL;
1070
1071    return EGL_TRUE;
1072 }
1073
1074
1075 /**
1076  * Called via eglCreateContext(), drv->API.CreateContext().
1077  */
1078 static _EGLContext *
1079 dri2_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
1080                     _EGLContext *share_list, const EGLint *attrib_list)
1081 {
1082    struct dri2_egl_context *dri2_ctx;
1083    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1084    struct dri2_egl_context *dri2_ctx_shared = dri2_egl_context(share_list);
1085    struct dri2_egl_config *dri2_config = dri2_egl_config(conf);
1086    const __DRIconfig *dri_config;
1087    int api;
1088
1089    (void) drv;
1090
1091    dri2_ctx = malloc(sizeof *dri2_ctx);
1092    if (!dri2_ctx) {
1093       _eglError(EGL_BAD_ALLOC, "eglCreateContext");
1094       return NULL;
1095    }
1096
1097    if (!_eglInitContext(&dri2_ctx->base, disp, conf, attrib_list))
1098       goto cleanup;
1099
1100    switch (dri2_ctx->base.ClientAPI) {
1101    case EGL_OPENGL_ES_API:
1102       switch (dri2_ctx->base.ClientVersion) {
1103       case 1:
1104          api = __DRI_API_GLES;
1105          break;
1106       case 2:
1107          api = __DRI_API_GLES2;
1108          break;
1109       default:
1110          _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
1111          return NULL;
1112       }
1113       break;
1114    case EGL_OPENGL_API:
1115       api = __DRI_API_OPENGL;
1116       break;
1117    default:
1118       _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
1119       return NULL;
1120    }
1121
1122    if (conf != NULL)
1123       dri_config = dri2_config->dri_config;
1124    else
1125       dri_config = NULL;
1126
1127    if (dri2_dpy->dri2->base.version >= 2) {
1128       dri2_ctx->dri_context =
1129          dri2_dpy->dri2->createNewContextForAPI(dri2_dpy->dri_screen,
1130                                                 api,
1131                                                 dri_config,
1132                                                 dri2_ctx_shared ?
1133                                                 dri2_ctx_shared->dri_context : NULL,
1134                                                 dri2_ctx);
1135    } else if (api == __DRI_API_OPENGL) {
1136       dri2_ctx->dri_context =
1137          dri2_dpy->dri2->createNewContext(dri2_dpy->dri_screen,
1138                                           dri2_config->dri_config,
1139                                           dri2_ctx_shared ?
1140                                           dri2_ctx_shared->dri_context : NULL,
1141                                           dri2_ctx);
1142    } else {
1143       /* fail */
1144    }
1145
1146    if (!dri2_ctx->dri_context)
1147       goto cleanup;
1148
1149    return &dri2_ctx->base;
1150
1151  cleanup:
1152    free(dri2_ctx);
1153    return NULL;
1154 }
1155
1156 static EGLBoolean
1157 dri2_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
1158 {
1159    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1160    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1161
1162    (void) drv;
1163
1164    if (_eglIsSurfaceBound(surf))
1165       return EGL_TRUE;
1166
1167    (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
1168
1169    xcb_dri2_destroy_drawable (dri2_dpy->conn, dri2_surf->drawable);
1170
1171    if (surf->Type == EGL_PBUFFER_BIT)
1172       xcb_free_pixmap (dri2_dpy->conn, dri2_surf->drawable);
1173
1174    free(surf);
1175
1176    return EGL_TRUE;
1177 }
1178
1179 /**
1180  * Called via eglMakeCurrent(), drv->API.MakeCurrent().
1181  */
1182 static EGLBoolean
1183 dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
1184                   _EGLSurface *rsurf, _EGLContext *ctx)
1185 {
1186    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1187    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1188    struct dri2_egl_surface *dri2_dsurf = dri2_egl_surface(dsurf);
1189    struct dri2_egl_surface *dri2_rsurf = dri2_egl_surface(rsurf);
1190    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1191    __DRIdrawable *ddraw, *rdraw;
1192    __DRIcontext *cctx;
1193
1194    /* bind the new context and return the "orphaned" one */
1195    if (!_eglBindContext(&ctx, &dsurf, &rsurf))
1196       return EGL_FALSE;
1197
1198    /* flush before context switch */
1199    if (ctx && dri2_drv->glFlush)
1200       dri2_drv->glFlush();
1201
1202    ddraw = (dri2_dsurf) ? dri2_dsurf->dri_drawable : NULL;
1203    rdraw = (dri2_rsurf) ? dri2_rsurf->dri_drawable : NULL;
1204    cctx = (dri2_ctx) ? dri2_ctx->dri_context : NULL;
1205
1206    if ((cctx == NULL && ddraw == NULL && rdraw == NULL) ||
1207        dri2_dpy->core->bindContext(cctx, ddraw, rdraw)) {
1208       if (dsurf && !_eglIsSurfaceLinked(dsurf))
1209          dri2_destroy_surface(drv, disp, dsurf);
1210       if (rsurf && rsurf != dsurf && !_eglIsSurfaceLinked(dsurf))
1211          dri2_destroy_surface(drv, disp, rsurf);
1212       if (ctx != NULL && !_eglIsContextLinked(ctx))
1213          dri2_dpy->core->unbindContext(dri2_egl_context(ctx)->dri_context);
1214
1215       return EGL_TRUE;
1216    } else {
1217       _eglBindContext(&ctx, &dsurf, &rsurf);
1218
1219       return EGL_FALSE;
1220    }
1221 }
1222
1223 /**
1224  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
1225  */
1226 static _EGLSurface *
1227 dri2_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
1228                     _EGLConfig *conf, EGLNativeWindowType window,
1229                     const EGLint *attrib_list)
1230 {
1231    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1232    struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
1233    struct dri2_egl_surface *dri2_surf;
1234    xcb_get_geometry_cookie_t cookie;
1235    xcb_get_geometry_reply_t *reply;
1236    xcb_screen_iterator_t s;
1237    xcb_generic_error_t *error;
1238
1239    (void) drv;
1240
1241    dri2_surf = malloc(sizeof *dri2_surf);
1242    if (!dri2_surf) {
1243       _eglError(EGL_BAD_ALLOC, "dri2_create_surface");
1244       return NULL;
1245    }
1246
1247    if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list))
1248       goto cleanup_surf;
1249
1250    dri2_surf->region = XCB_NONE;
1251    if (type == EGL_PBUFFER_BIT) {
1252       dri2_surf->drawable = xcb_generate_id(dri2_dpy->conn);
1253       s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
1254       xcb_create_pixmap(dri2_dpy->conn,
1255                         _eglGetConfigKey(conf, EGL_BUFFER_SIZE),
1256                         dri2_surf->drawable, s.data->root,
1257                         dri2_surf->base.Width, dri2_surf->base.Height);
1258    } else {
1259       dri2_surf->drawable = window;
1260    }
1261
1262    dri2_surf->dri_drawable =
1263       (*dri2_dpy->dri2->createNewDrawable) (dri2_dpy->dri_screen,
1264                                             dri2_conf->dri_config, dri2_surf);
1265    if (dri2_surf->dri_drawable == NULL) {
1266       _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable");
1267       goto cleanup_pixmap;
1268    }
1269
1270    xcb_dri2_create_drawable (dri2_dpy->conn, dri2_surf->drawable);
1271
1272    if (type != EGL_PBUFFER_BIT) {
1273       cookie = xcb_get_geometry (dri2_dpy->conn, dri2_surf->drawable);
1274       reply = xcb_get_geometry_reply (dri2_dpy->conn, cookie, &error);
1275       if (reply == NULL || error != NULL) {
1276          _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
1277          free(error);
1278          goto cleanup_dri_drawable;
1279       }
1280
1281       dri2_surf->base.Width = reply->width;
1282       dri2_surf->base.Height = reply->height;
1283       free(reply);
1284    }
1285
1286    return &dri2_surf->base;
1287
1288  cleanup_dri_drawable:
1289    dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
1290  cleanup_pixmap:
1291    if (type == EGL_PBUFFER_BIT)
1292       xcb_free_pixmap(dri2_dpy->conn, dri2_surf->drawable);
1293  cleanup_surf:
1294    free(dri2_surf);
1295
1296    return NULL;
1297 }
1298
1299 /**
1300  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
1301  */
1302 static _EGLSurface *
1303 dri2_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
1304                            _EGLConfig *conf, EGLNativeWindowType window,
1305                            const EGLint *attrib_list)
1306 {
1307    return dri2_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
1308                               window, attrib_list);
1309 }
1310
1311 static _EGLSurface *
1312 dri2_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
1313                            _EGLConfig *conf, EGLNativePixmapType pixmap,
1314                            const EGLint *attrib_list)
1315 {
1316    return dri2_create_surface(drv, disp, EGL_PIXMAP_BIT, conf,
1317                               pixmap, attrib_list);
1318 }
1319
1320 static _EGLSurface *
1321 dri2_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
1322                             _EGLConfig *conf, const EGLint *attrib_list)
1323 {
1324    return dri2_create_surface(drv, disp, EGL_PBUFFER_BIT, conf,
1325                               XCB_WINDOW_NONE, attrib_list);
1326 }
1327
1328 static EGLBoolean
1329 dri2_copy_region(_EGLDriver *drv, _EGLDisplay *disp,
1330                  _EGLSurface *draw, xcb_xfixes_region_t region)
1331 {
1332    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1333    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1334    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1335    _EGLContext *ctx;
1336    xcb_dri2_copy_region_cookie_t cookie;
1337
1338    if (dri2_drv->glFlush) {
1339       ctx = _eglGetCurrentContext();
1340       if (ctx && ctx->DrawSurface == &dri2_surf->base)
1341          dri2_drv->glFlush();
1342    }
1343
1344    (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1345
1346 #if 0
1347    /* FIXME: Add support for dri swapbuffers, that'll give us swap
1348     * interval and page flipping (at least for fullscreen windows) as
1349     * well as the page flip event.  Unless surface->SwapBehavior is
1350     * EGL_BUFFER_PRESERVED. */
1351 #if __DRI2_FLUSH_VERSION >= 2
1352    if (pdraw->psc->f)
1353       (*pdraw->psc->f->flushInvalidate)(pdraw->driDrawable);
1354 #endif
1355 #endif
1356
1357    if (!dri2_surf->have_fake_front)
1358       return EGL_TRUE;
1359
1360    cookie = xcb_dri2_copy_region_unchecked(dri2_dpy->conn,
1361                                            dri2_surf->drawable,
1362                                            region,
1363                                            XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT,
1364                                            XCB_DRI2_ATTACHMENT_BUFFER_FAKE_FRONT_LEFT);
1365    free(xcb_dri2_copy_region_reply(dri2_dpy->conn, cookie, NULL));
1366
1367    return EGL_TRUE;
1368 }
1369
1370 static EGLBoolean
1371 dri2_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
1372 {
1373    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1374
1375    return dri2_copy_region(drv, disp, draw, dri2_surf->region);
1376 }
1377
1378 static EGLBoolean
1379 dri2_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
1380                          EGLint numRects, const EGLint *rects)
1381 {
1382    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1383    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1384    EGLBoolean ret;
1385    xcb_xfixes_region_t region;
1386    xcb_rectangle_t rectangles[16];
1387    int i;
1388
1389    if (numRects > (int)ARRAY_SIZE(rectangles))
1390       return dri2_copy_region(drv, disp, draw, dri2_surf->region);
1391
1392    /* FIXME: Invert y here? */
1393    for (i = 0; i < numRects; i++) {
1394       rectangles[i].x = rects[i * 4];
1395       rectangles[i].y = rects[i * 4 + 1];
1396       rectangles[i].width = rects[i * 4 + 2];
1397       rectangles[i].height = rects[i * 4 + 3];
1398    }
1399
1400    region = xcb_generate_id(dri2_dpy->conn);
1401    xcb_xfixes_create_region(dri2_dpy->conn, region, numRects, rectangles);
1402    ret = dri2_copy_region(drv, disp, draw, region);
1403    xcb_xfixes_destroy_region(dri2_dpy->conn, region);
1404
1405    return ret;
1406 }
1407
1408 /*
1409  * Called from eglGetProcAddress() via drv->API.GetProcAddress().
1410  */
1411 static _EGLProc
1412 dri2_get_proc_address(_EGLDriver *drv, const char *procname)
1413 {
1414    (void) drv;
1415
1416    /* FIXME: Do we need to support lookup of EGL symbols too? */
1417
1418    return (_EGLProc) _glapi_get_proc_address(procname);
1419 }
1420
1421 static EGLBoolean
1422 dri2_wait_client(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
1423 {
1424    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1425    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(ctx->DrawSurface);
1426
1427    (void) drv;
1428
1429    /* FIXME: If EGL allows frontbuffer rendering for window surfaces,
1430     * we need to copy fake to real here.*/
1431
1432    (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1433
1434    return EGL_TRUE;
1435 }
1436
1437 static EGLBoolean
1438 dri2_wait_native(_EGLDriver *drv, _EGLDisplay *disp, EGLint engine)
1439 {
1440    (void) drv;
1441    (void) disp;
1442
1443    if (engine != EGL_CORE_NATIVE_ENGINE)
1444       return _eglError(EGL_BAD_PARAMETER, "eglWaitNative");
1445    /* glXWaitX(); */
1446
1447    return EGL_TRUE;
1448 }
1449
1450 static void
1451 dri2_unload(_EGLDriver *drv)
1452 {
1453    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1454    free(dri2_drv);
1455 }
1456
1457 static EGLBoolean
1458 dri2_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
1459                   EGLNativePixmapType target)
1460 {
1461    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1462    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1463    xcb_gcontext_t gc;
1464
1465    (void) drv;
1466
1467    (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1468
1469    gc = xcb_generate_id(dri2_dpy->conn);
1470    xcb_create_gc(dri2_dpy->conn, gc, target, 0, NULL);
1471    xcb_copy_area(dri2_dpy->conn,
1472                   dri2_surf->drawable,
1473                   target,
1474                   gc,
1475                   0, 0,
1476                   0, 0,
1477                   dri2_surf->base.Width,
1478                   dri2_surf->base.Height);
1479    xcb_free_gc(dri2_dpy->conn, gc);
1480
1481    return EGL_TRUE;
1482 }
1483
1484 static EGLBoolean
1485 dri2_bind_tex_image(_EGLDriver *drv,
1486                     _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
1487 {
1488    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1489    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1490    struct dri2_egl_context *dri2_ctx;
1491    _EGLContext *ctx;
1492    GLint format, target;
1493
1494    ctx = _eglGetCurrentContext();
1495    dri2_ctx = dri2_egl_context(ctx);
1496
1497    if (!_eglBindTexImage(drv, disp, surf, buffer))
1498       return EGL_FALSE;
1499
1500    switch (dri2_surf->base.TextureFormat) {
1501    case EGL_TEXTURE_RGB:
1502       format = __DRI_TEXTURE_FORMAT_RGB;
1503       break;
1504    case EGL_TEXTURE_RGBA:
1505       format = __DRI_TEXTURE_FORMAT_RGBA;
1506       break;
1507    default:
1508       assert(0);
1509    }
1510
1511    switch (dri2_surf->base.TextureTarget) {
1512    case EGL_TEXTURE_2D:
1513       target = GL_TEXTURE_2D;
1514       break;
1515    default:
1516       assert(0);
1517    }
1518
1519    (*dri2_dpy->tex_buffer->setTexBuffer2)(dri2_ctx->dri_context,
1520                                           target, format,
1521                                           dri2_surf->dri_drawable);
1522
1523    return EGL_TRUE;
1524 }
1525
1526 static EGLBoolean
1527 dri2_release_tex_image(_EGLDriver *drv,
1528                        _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
1529 {
1530    (void) drv;
1531    (void) disp;
1532    (void) surf;
1533    (void) buffer;
1534
1535    return EGL_TRUE;
1536 }
1537
1538 static _EGLImage *
1539 dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx,
1540                              EGLClientBuffer buffer, const EGLint *attr_list)
1541 {
1542    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1543    struct dri2_egl_image *dri2_img;
1544    unsigned int attachments[1];
1545    xcb_drawable_t drawable;
1546    xcb_dri2_get_buffers_cookie_t buffers_cookie;
1547    xcb_dri2_get_buffers_reply_t *buffers_reply;
1548    xcb_dri2_dri2_buffer_t *buffers;
1549    xcb_get_geometry_cookie_t geometry_cookie;
1550    xcb_get_geometry_reply_t *geometry_reply;
1551    xcb_generic_error_t *error;
1552    int stride, format;
1553
1554    (void) ctx;
1555
1556    drawable = (xcb_drawable_t) buffer;
1557    xcb_dri2_create_drawable (dri2_dpy->conn, drawable);
1558    attachments[0] = XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT;
1559    buffers_cookie =
1560       xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
1561                                       drawable, 1, 1, attachments);
1562    geometry_cookie = xcb_get_geometry (dri2_dpy->conn, drawable);
1563    buffers_reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn,
1564                                                buffers_cookie, NULL);
1565    buffers = xcb_dri2_get_buffers_buffers (buffers_reply);
1566    if (buffers == NULL) {
1567       return NULL;
1568    }
1569
1570    geometry_reply = xcb_get_geometry_reply (dri2_dpy->conn,
1571                                             geometry_cookie, &error);
1572    if (geometry_reply == NULL || error != NULL) {
1573       _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
1574       free(error);
1575       free(buffers_reply);
1576    }
1577
1578    switch (geometry_reply->depth) {
1579    case 16:
1580       format = __DRI_IMAGE_FORMAT_RGB565;
1581       break;
1582    case 24:
1583       format = __DRI_IMAGE_FORMAT_XRGB8888;
1584       break;
1585    case 32:
1586       format = __DRI_IMAGE_FORMAT_ARGB8888;
1587       break;
1588    default:
1589       _eglError(EGL_BAD_PARAMETER,
1590                 "dri2_create_image_khr: unsupported pixmap depth");
1591       free(buffers_reply);
1592       free(geometry_reply);
1593       return NULL;
1594    }
1595
1596    dri2_img = malloc(sizeof *dri2_img);
1597    if (!dri2_img) {
1598       free(buffers_reply);
1599       free(geometry_reply);
1600       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1601       return EGL_NO_IMAGE_KHR;
1602    }
1603
1604    if (!_eglInitImage(&dri2_img->base, disp, attr_list)) {
1605       free(buffers_reply);
1606       free(geometry_reply);
1607       return EGL_NO_IMAGE_KHR;
1608    }
1609
1610    stride = buffers[0].pitch / buffers[0].cpp;
1611    dri2_img->dri_image =
1612       dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
1613                                            buffers_reply->width,
1614                                            buffers_reply->height,
1615                                            format,
1616                                            buffers[0].name,
1617                                            stride,
1618                                            dri2_img);
1619
1620    free(buffers_reply);
1621    free(geometry_reply);
1622
1623    return &dri2_img->base;
1624 }
1625
1626 static _EGLImage *
1627 dri2_create_image_khr_renderbuffer(_EGLDisplay *disp, _EGLContext *ctx,
1628                                    EGLClientBuffer buffer,
1629                                    const EGLint *attr_list)
1630 {
1631    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1632    struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1633    struct dri2_egl_image *dri2_img;
1634    GLuint renderbuffer = (GLuint) buffer;
1635
1636    if (renderbuffer == 0) {
1637       _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
1638       return EGL_NO_IMAGE_KHR;
1639    }
1640
1641    dri2_img = malloc(sizeof *dri2_img);
1642    if (!dri2_img) {
1643       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1644       return EGL_NO_IMAGE_KHR;
1645    }
1646
1647    if (!_eglInitImage(&dri2_img->base, disp, attr_list))
1648       return EGL_NO_IMAGE_KHR;
1649
1650    dri2_img->dri_image =
1651       dri2_dpy->image->createImageFromRenderbuffer(dri2_ctx->dri_context,
1652                                                    renderbuffer,
1653                                                    dri2_img);
1654
1655    return &dri2_img->base;
1656 }
1657
1658 static _EGLImage *
1659 dri2_create_image_mesa_drm_buffer(_EGLDisplay *disp, _EGLContext *ctx,
1660                                   EGLClientBuffer buffer, const EGLint *attr_list)
1661 {
1662    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1663    struct dri2_egl_image *dri2_img;
1664    EGLint width, height, format, name, stride, pitch, i, err;
1665
1666    (void) ctx;
1667
1668    name = (EGLint) buffer;
1669
1670    err = EGL_SUCCESS;
1671    width = 0;
1672    height = 0;
1673    format = 0;
1674    stride = 0;
1675
1676    for (i = 0; attr_list[i] != EGL_NONE; i++) {
1677       EGLint attr = attr_list[i++];
1678       EGLint val = attr_list[i];
1679
1680       switch (attr) {
1681       case EGL_WIDTH:
1682          width = val;
1683          break;
1684       case EGL_HEIGHT:
1685          height = val;
1686          break;
1687       case EGL_DRM_BUFFER_FORMAT_MESA:
1688          format = val;
1689          break;
1690       case EGL_DRM_BUFFER_STRIDE_MESA:
1691          stride = val;
1692          break;
1693       default:
1694          err = EGL_BAD_ATTRIBUTE;
1695          break;
1696       }
1697
1698       if (err != EGL_SUCCESS) {
1699          _eglLog(_EGL_WARNING, "bad image attribute 0x%04x", attr);
1700          return NULL;
1701       }
1702    }
1703
1704    if (width <= 0 || height <= 0 || stride <= 0) {
1705       _eglError(EGL_BAD_PARAMETER,
1706                 "bad width, height or stride");
1707       return NULL;
1708    }
1709
1710    switch (format) {
1711    case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
1712       format = __DRI_IMAGE_FORMAT_ARGB8888;
1713       pitch = stride;
1714       break;
1715    default:
1716       _eglError(EGL_BAD_PARAMETER,
1717                 "dri2_create_image_khr: unsupported pixmap depth");
1718       return NULL;
1719    }
1720
1721    dri2_img = malloc(sizeof *dri2_img);
1722    if (!dri2_img) {
1723       _eglError(EGL_BAD_ALLOC, "dri2_create_image_mesa_drm");
1724       return NULL;
1725    }
1726
1727    if (!_eglInitImage(&dri2_img->base, disp, attr_list)) {
1728       free(dri2_img);
1729       return NULL;
1730    }
1731
1732    dri2_img->dri_image =
1733       dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
1734                                            width,
1735                                            height,
1736                                            format,
1737                                            name,
1738                                            pitch,
1739                                            dri2_img);
1740    if (dri2_img->dri_image == NULL) {
1741       free(dri2_img);
1742       _eglError(EGL_BAD_ALLOC, "dri2_create_image_mesa_drm");
1743       return NULL;
1744    }
1745
1746    return &dri2_img->base;
1747 }
1748
1749 static _EGLImage *
1750 dri2_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
1751                       _EGLContext *ctx, EGLenum target,
1752                       EGLClientBuffer buffer, const EGLint *attr_list)
1753 {
1754    (void) drv;
1755
1756    switch (target) {
1757    case EGL_NATIVE_PIXMAP_KHR:
1758       return dri2_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
1759    case EGL_GL_RENDERBUFFER_KHR:
1760       return dri2_create_image_khr_renderbuffer(disp, ctx, buffer, attr_list);
1761    case EGL_DRM_BUFFER_MESA:
1762       return dri2_create_image_mesa_drm_buffer(disp, ctx, buffer, attr_list);
1763    default:
1764       _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
1765       return EGL_NO_IMAGE_KHR;
1766    }
1767 }
1768
1769 static EGLBoolean
1770 dri2_destroy_image_khr(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *image)
1771 {
1772    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1773    struct dri2_egl_image *dri2_img = dri2_egl_image(image);
1774
1775    (void) drv;
1776
1777    dri2_dpy->image->destroyImage(dri2_img->dri_image);
1778    free(dri2_img);
1779
1780    return EGL_TRUE;
1781 }
1782
1783 static _EGLImage *
1784 dri2_create_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp,
1785                            const EGLint *attr_list)
1786 {
1787    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1788    struct dri2_egl_image *dri2_img;
1789    int width, height, format, i;
1790    unsigned int use, dri_use, valid_mask;
1791    EGLint err = EGL_SUCCESS;
1792
1793    (void) drv;
1794
1795    dri2_img = malloc(sizeof *dri2_img);
1796    if (!dri2_img) {
1797       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
1798       return EGL_NO_IMAGE_KHR;
1799    }
1800
1801    if (!attr_list) {
1802       err = EGL_BAD_PARAMETER;
1803       goto cleanup_img;
1804    }
1805
1806    if (!_eglInitImage(&dri2_img->base, disp, attr_list)) {
1807       err = EGL_BAD_PARAMETER;
1808       goto cleanup_img;
1809    }
1810
1811    width = 0;
1812    height = 0;
1813    format = 0;
1814    use = 0;
1815    for (i = 0; attr_list[i] != EGL_NONE; i++) {
1816       EGLint attr = attr_list[i++];
1817       EGLint val = attr_list[i];
1818
1819       switch (attr) {
1820       case EGL_WIDTH:
1821          width = val;
1822          break;
1823       case EGL_HEIGHT:
1824          height = val;
1825          break;
1826       case EGL_DRM_BUFFER_FORMAT_MESA:
1827          format = val;
1828          break;
1829       case EGL_DRM_BUFFER_USE_MESA:
1830          use = val;
1831          break;
1832       default:
1833          err = EGL_BAD_ATTRIBUTE;
1834          break;
1835       }
1836
1837       if (err != EGL_SUCCESS) {
1838          _eglLog(_EGL_WARNING, "bad image attribute 0x%04x", attr);
1839          goto cleanup_img;
1840       }
1841    }
1842
1843    if (width <= 0 || height <= 0) {
1844       _eglLog(_EGL_WARNING, "bad width or height (%dx%d)", width, height);
1845       goto cleanup_img;
1846    }
1847
1848    switch (format) {
1849    case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
1850       format = __DRI_IMAGE_FORMAT_ARGB8888;
1851       break;
1852    default:
1853       _eglLog(_EGL_WARNING, "bad image format value 0x%04x", format);
1854       goto cleanup_img;
1855    }
1856
1857    valid_mask =
1858       EGL_DRM_BUFFER_USE_SCANOUT_MESA |
1859       EGL_DRM_BUFFER_USE_SHARE_MESA;
1860    if (use & ~valid_mask) {
1861       _eglLog(_EGL_WARNING, "bad image use bit 0x%04x", use & ~valid_mask);
1862       goto cleanup_img;
1863    }
1864
1865    dri_use = 0;
1866    if (use & EGL_DRM_BUFFER_USE_SHARE_MESA)
1867       dri_use |= __DRI_IMAGE_USE_SHARE;
1868    if (use & EGL_DRM_BUFFER_USE_SCANOUT_MESA)
1869       dri_use |= __DRI_IMAGE_USE_SCANOUT;
1870
1871    dri2_img->dri_image =
1872       dri2_dpy->image->createImage(dri2_dpy->dri_screen,
1873                                    width, height, format, dri_use, dri2_img);
1874    if (dri2_img->dri_image == NULL) {
1875       err = EGL_BAD_ALLOC;
1876       goto cleanup_img;
1877    }
1878
1879    return &dri2_img->base;
1880
1881  cleanup_img:
1882    free(dri2_img);
1883    _eglError(err, "dri2_create_drm_image_mesa");
1884
1885    return EGL_NO_IMAGE_KHR;
1886 }
1887
1888 static EGLBoolean
1889 dri2_export_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
1890                           EGLint *name, EGLint *handle, EGLint *stride)
1891 {
1892    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1893    struct dri2_egl_image *dri2_img = dri2_egl_image(img);
1894
1895    (void) drv;
1896
1897    if (name && !dri2_dpy->image->queryImage(dri2_img->dri_image,
1898                                             __DRI_IMAGE_ATTRIB_NAME, name)) {
1899       _eglError(EGL_BAD_ALLOC, "dri2_export_drm_image_mesa");
1900       return EGL_FALSE;
1901    }
1902
1903    if (handle)
1904       dri2_dpy->image->queryImage(dri2_img->dri_image,
1905                                   __DRI_IMAGE_ATTRIB_HANDLE, handle);
1906
1907    if (stride)
1908       dri2_dpy->image->queryImage(dri2_img->dri_image,
1909                                   __DRI_IMAGE_ATTRIB_STRIDE, stride);
1910
1911    return EGL_TRUE;
1912 }
1913
1914 /**
1915  * This is the main entrypoint into the driver, called by libEGL.
1916  * Create a new _EGLDriver object and init its dispatch table.
1917  */
1918 _EGLDriver *
1919 _eglMain(const char *args)
1920 {
1921    struct dri2_egl_driver *dri2_drv;
1922
1923    (void) args;
1924
1925    dri2_drv = malloc(sizeof *dri2_drv);
1926    if (!dri2_drv)
1927       return NULL;
1928
1929    memset(dri2_drv, 0, sizeof *dri2_drv);
1930    _eglInitDriverFallbacks(&dri2_drv->base);
1931    dri2_drv->base.API.Initialize = dri2_initialize;
1932    dri2_drv->base.API.Terminate = dri2_terminate;
1933    dri2_drv->base.API.CreateContext = dri2_create_context;
1934    dri2_drv->base.API.MakeCurrent = dri2_make_current;
1935    dri2_drv->base.API.CreateWindowSurface = dri2_create_window_surface;
1936    dri2_drv->base.API.CreatePixmapSurface = dri2_create_pixmap_surface;
1937    dri2_drv->base.API.CreatePbufferSurface = dri2_create_pbuffer_surface;
1938    dri2_drv->base.API.DestroySurface = dri2_destroy_surface;
1939    dri2_drv->base.API.SwapBuffers = dri2_swap_buffers;
1940    dri2_drv->base.API.GetProcAddress = dri2_get_proc_address;
1941    dri2_drv->base.API.WaitClient = dri2_wait_client;
1942    dri2_drv->base.API.WaitNative = dri2_wait_native;
1943    dri2_drv->base.API.CopyBuffers = dri2_copy_buffers;
1944    dri2_drv->base.API.BindTexImage = dri2_bind_tex_image;
1945    dri2_drv->base.API.ReleaseTexImage = dri2_release_tex_image;
1946    dri2_drv->base.API.CreateImageKHR = dri2_create_image_khr;
1947    dri2_drv->base.API.DestroyImageKHR = dri2_destroy_image_khr;
1948    dri2_drv->base.API.SwapBuffersRegionNOK = dri2_swap_buffers_region;
1949    dri2_drv->base.API.CreateDRMImageMESA = dri2_create_drm_image_mesa;
1950    dri2_drv->base.API.ExportDRMImageMESA = dri2_export_drm_image_mesa;
1951
1952    dri2_drv->base.Name = "DRI2";
1953    dri2_drv->base.Unload = dri2_unload;
1954
1955    dri2_drv->glFlush =
1956       (void (*)(void)) dri2_get_proc_address(&dri2_drv->base, "glFlush");
1957
1958    return &dri2_drv->base;
1959 }