src/egl/drivers/dri2/platform_x11.c

   1 /*
   2  * Copyright © 2011 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  19  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  20  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Kristian Høgsberg <krh@bitplanet.net>
  26  */
  27
  28 #include <stdbool.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <stdio.h>
  32 #include <limits.h>
  33 #include <dlfcn.h>
  34 #include <fcntl.h>
  35 #include <errno.h>
  36 #include <unistd.h>
  37 #ifdef HAVE_LIBDRM
  38 #include <xf86drm.h>
  39 #endif
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42
  43 #include "egl_dri2.h"
  44 #include "egl_dri2_fallbacks.h"
  45
  46 static EGLBoolean
  47 dri2_x11_swap_interval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
  48                        EGLint interval);
  49
  50 static void
  51 swrastCreateDrawable(struct dri2_egl_display * dri2_dpy,
  52                      struct dri2_egl_surface * dri2_surf,
  53                      int depth)
  54 {
  55    uint32_t           mask;
  56    const uint32_t     function = GXcopy;
  57    uint32_t           valgc[2];
  58
  59    /* create GC's */
  60    dri2_surf->gc = xcb_generate_id(dri2_dpy->conn);
  61    mask = XCB_GC_FUNCTION;
  62    xcb_create_gc(dri2_dpy->conn, dri2_surf->gc, dri2_surf->drawable, mask, &function);
  63
  64    dri2_surf->swapgc = xcb_generate_id(dri2_dpy->conn);
  65    mask = XCB_GC_FUNCTION | XCB_GC_GRAPHICS_EXPOSURES;
  66    valgc[0] = function;
  67    valgc[1] = False;
  68    xcb_create_gc(dri2_dpy->conn, dri2_surf->swapgc, dri2_surf->drawable, mask, valgc);
  69    dri2_surf->depth = depth;
  70    switch (depth) {
  71       case 32:
  72       case 24:
  73          dri2_surf->bytes_per_pixel = 4;
  74          break;
  75       case 16:
  76          dri2_surf->bytes_per_pixel = 2;
  77          break;
  78       case 8:
  79          dri2_surf->bytes_per_pixel = 1;
  80          break;
  81       case 0:
  82          dri2_surf->bytes_per_pixel = 0;
  83          break;
  84       default:
  85          _eglLog(_EGL_WARNING, "unsupported depth %d", depth);
  86    }
  87 }
  88
  89 static void
  90 swrastDestroyDrawable(struct dri2_egl_display * dri2_dpy,
  91                       struct dri2_egl_surface * dri2_surf)
  92 {
  93    xcb_free_gc(dri2_dpy->conn, dri2_surf->gc);
  94    xcb_free_gc(dri2_dpy->conn, dri2_surf->swapgc);
  95 }
  96
  97 static void
  98 swrastGetDrawableInfo(__DRIdrawable * draw,
  99                       int *x, int *y, int *w, int *h,
 100                       void *loaderPrivate)
 101 {
 102    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 103    struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display);
 104
 105    xcb_get_geometry_cookie_t cookie;
 106    xcb_get_geometry_reply_t *reply;
 107    xcb_generic_error_t *error;
 108
 109    *w = *h = 0;
 110    cookie = xcb_get_geometry (dri2_dpy->conn, dri2_surf->drawable);
 111    reply = xcb_get_geometry_reply (dri2_dpy->conn, cookie, &error);
 112    if (reply == NULL)
 113       return;
 114
 115    if (error != NULL) {
 116       _eglLog(_EGL_WARNING, "error in xcb_get_geometry");
 117       free(error);
 118    } else {
 119       *w = reply->width;
 120       *h = reply->height;
 121    }
 122    free(reply);
 123 }
 124
 125 static void
 126 swrastPutImage(__DRIdrawable * draw, int op,
 127                int x, int y, int w, int h,
 128                char *data, void *loaderPrivate)
 129 {
 130    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 131    struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display);
 132
 133    xcb_gcontext_t gc;
 134
 135    switch (op) {
 136    case __DRI_SWRAST_IMAGE_OP_DRAW:
 137       gc = dri2_surf->gc;
 138       break;
 139    case __DRI_SWRAST_IMAGE_OP_SWAP:
 140       gc = dri2_surf->swapgc;
 141       break;
 142    default:
 143       return;
 144    }
 145
 146    xcb_put_image(dri2_dpy->conn, XCB_IMAGE_FORMAT_Z_PIXMAP, dri2_surf->drawable,
 147                  gc, w, h, x, y, 0, dri2_surf->depth,
 148                  w*h*dri2_surf->bytes_per_pixel, (const uint8_t *)data);
 149 }
 150
 151 static void
 152 swrastGetImage(__DRIdrawable * read,
 153                int x, int y, int w, int h,
 154                char *data, void *loaderPrivate)
 155 {
 156    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 157    struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display);
 158
 159    xcb_get_image_cookie_t cookie;
 160    xcb_get_image_reply_t *reply;
 161    xcb_generic_error_t *error;
 162
 163    cookie = xcb_get_image (dri2_dpy->conn, XCB_IMAGE_FORMAT_Z_PIXMAP,
 164                            dri2_surf->drawable, x, y, w, h, ~0);
 165    reply = xcb_get_image_reply (dri2_dpy->conn, cookie, &error);
 166    if (reply == NULL)
 167       return;
 168
 169    if (error != NULL) {
 170       _eglLog(_EGL_WARNING, "error in xcb_get_image");
 171       free(error);
 172    } else {
 173       uint32_t bytes = xcb_get_image_data_length(reply);
 174       uint8_t *idata = xcb_get_image_data(reply);
 175       memcpy(data, idata, bytes);
 176    }
 177    free(reply);
 178 }
 179
 180
 181 /**
 182  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
 183  */
 184 static _EGLSurface *
 185 dri2_x11_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
 186                         _EGLConfig *conf, void *native_surface,
 187                         const EGLint *attrib_list)
 188 {
 189    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 190    struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
 191    struct dri2_egl_surface *dri2_surf;
 192    xcb_get_geometry_cookie_t cookie;
 193    xcb_get_geometry_reply_t *reply;
 194    xcb_screen_iterator_t s;
 195    xcb_generic_error_t *error;
 196    xcb_drawable_t drawable;
 197
 198    STATIC_ASSERT(sizeof(uintptr_t) == sizeof(native_surface));
 199    drawable = (uintptr_t) native_surface;
 200
 201    (void) drv;
 202
 203    dri2_surf = malloc(sizeof *dri2_surf);
 204    if (!dri2_surf) {
 205       _eglError(EGL_BAD_ALLOC, "dri2_create_surface");
 206       return NULL;
 207    }
 208
 209    if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list))
 210       goto cleanup_surf;
 211
 212    dri2_surf->region = XCB_NONE;
 213    if (type == EGL_PBUFFER_BIT) {
 214       dri2_surf->drawable = xcb_generate_id(dri2_dpy->conn);
 215       s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
 216       xcb_create_pixmap(dri2_dpy->conn, conf->BufferSize,
 217                         dri2_surf->drawable, s.data->root,
 218                         dri2_surf->base.Width, dri2_surf->base.Height);
 219    } else {
 220       dri2_surf->drawable = drawable;
 221    }
 222
 223    if (dri2_dpy->dri2) {
 224       dri2_surf->dri_drawable =
 225          (*dri2_dpy->dri2->createNewDrawable) (dri2_dpy->dri_screen,
 226                                                type == EGL_WINDOW_BIT ?
 227                                                dri2_conf->dri_double_config :
 228                                                dri2_conf->dri_single_config,
 229                                                dri2_surf);
 230    } else {
 231       assert(dri2_dpy->swrast);
 232       dri2_surf->dri_drawable =
 233          (*dri2_dpy->swrast->createNewDrawable) (dri2_dpy->dri_screen,
 234                                                  dri2_conf->dri_double_config,
 235                                                  dri2_surf);
 236    }
 237
 238    if (dri2_surf->dri_drawable == NULL) {
 239       _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable");
 240       goto cleanup_pixmap;
 241    }
 242
 243    if (dri2_dpy->dri2) {
 244       xcb_dri2_create_drawable (dri2_dpy->conn, dri2_surf->drawable);
 245    } else {
 246       swrastCreateDrawable(dri2_dpy, dri2_surf, _eglGetConfigKey(conf, EGL_BUFFER_SIZE));
 247    }
 248
 249    if (type != EGL_PBUFFER_BIT) {
 250       cookie = xcb_get_geometry (dri2_dpy->conn, dri2_surf->drawable);
 251       reply = xcb_get_geometry_reply (dri2_dpy->conn, cookie, &error);
 252       if (reply == NULL || error != NULL) {
 253          _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
 254          free(error);
 255          goto cleanup_dri_drawable;
 256       }
 257
 258       dri2_surf->base.Width = reply->width;
 259       dri2_surf->base.Height = reply->height;
 260       free(reply);
 261    }
 262
 263    /* we always copy the back buffer to front */
 264    dri2_surf->base.PostSubBufferSupportedNV = EGL_TRUE;
 265
 266    return &dri2_surf->base;
 267
 268  cleanup_dri_drawable:
 269    dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
 270  cleanup_pixmap:
 271    if (type == EGL_PBUFFER_BIT)
 272       xcb_free_pixmap(dri2_dpy->conn, dri2_surf->drawable);
 273  cleanup_surf:
 274    free(dri2_surf);
 275
 276    return NULL;
 277 }
 278
 279 /**
 280  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
 281  */
 282 static _EGLSurface *
 283 dri2_x11_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
 284                                _EGLConfig *conf, void *native_window,
 285                                const EGLint *attrib_list)
 286 {
 287    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 288    _EGLSurface *surf;
 289
 290    surf = dri2_x11_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
 291                                   native_window, attrib_list);
 292    if (surf != NULL) {
 293       /* When we first create the DRI2 drawable, its swap interval on the
 294        * server side is 1.
 295        */
 296       surf->SwapInterval = 1;
 297
 298       /* Override that with a driconf-set value. */
 299       dri2_x11_swap_interval(drv, disp, surf, dri2_dpy->default_swap_interval);
 300    }
 301
 302    return surf;
 303 }
 304
 305 static _EGLSurface *
 306 dri2_x11_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
 307                                _EGLConfig *conf, void *native_pixmap,
 308                                const EGLint *attrib_list)
 309 {
 310    return dri2_x11_create_surface(drv, disp, EGL_PIXMAP_BIT, conf,
 311                                   native_pixmap, attrib_list);
 312 }
 313
 314 static _EGLSurface *
 315 dri2_x11_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
 316                                 _EGLConfig *conf, const EGLint *attrib_list)
 317 {
 318    return dri2_x11_create_surface(drv, disp, EGL_PBUFFER_BIT, conf,
 319                                   XCB_WINDOW_NONE, attrib_list);
 320 }
 321
 322 static EGLBoolean
 323 dri2_x11_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
 324 {
 325    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 326    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
 327
 328    (void) drv;
 329
 330    if (!_eglPutSurface(surf))
 331       return EGL_TRUE;
 332
 333    (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
 334
 335    if (dri2_dpy->dri2) {
 336       xcb_dri2_destroy_drawable (dri2_dpy->conn, dri2_surf->drawable);
 337    } else {
 338       assert(dri2_dpy->swrast);
 339       swrastDestroyDrawable(dri2_dpy, dri2_surf);
 340    }
 341
 342    if (surf->Type == EGL_PBUFFER_BIT)
 343       xcb_free_pixmap (dri2_dpy->conn, dri2_surf->drawable);
 344
 345    free(surf);
 346
 347    return EGL_TRUE;
 348 }
 349
 350 /**
 351  * Process list of buffer received from the server
 352  *
 353  * Processes the list of buffers received in a reply from the server to either
 354  * \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat.
 355  */
 356 static void
 357 dri2_x11_process_buffers(struct dri2_egl_surface *dri2_surf,
 358                          xcb_dri2_dri2_buffer_t *buffers, unsigned count)
 359 {
 360    struct dri2_egl_display *dri2_dpy =
 361       dri2_egl_display(dri2_surf->base.Resource.Display);
 362    xcb_rectangle_t rectangle;
 363    unsigned i;
 364
 365    dri2_surf->buffer_count = count;
 366    dri2_surf->have_fake_front = 0;
 367
 368    /* This assumes the DRI2 buffer attachment tokens matches the
 369     * __DRIbuffer tokens. */
 370    for (i = 0; i < count; i++) {
 371       dri2_surf->buffers[i].attachment = buffers[i].attachment;
 372       dri2_surf->buffers[i].name = buffers[i].name;
 373       dri2_surf->buffers[i].pitch = buffers[i].pitch;
 374       dri2_surf->buffers[i].cpp = buffers[i].cpp;
 375       dri2_surf->buffers[i].flags = buffers[i].flags;
 376
 377       /* We only use the DRI drivers single buffer configs.  This
 378        * means that if we try to render to a window, DRI2 will give us
 379        * the fake front buffer, which we'll use as a back buffer.
 380        * Note that EGL doesn't require that several clients rendering
 381        * to the same window must see the same aux buffers. */
 382       if (dri2_surf->buffers[i].attachment == __DRI_BUFFER_FAKE_FRONT_LEFT)
 383          dri2_surf->have_fake_front = 1;
 384    }
 385
 386    if (dri2_surf->region != XCB_NONE)
 387       xcb_xfixes_destroy_region(dri2_dpy->conn, dri2_surf->region);
 388
 389    rectangle.x = 0;
 390    rectangle.y = 0;
 391    rectangle.width = dri2_surf->base.Width;
 392    rectangle.height = dri2_surf->base.Height;
 393    dri2_surf->region = xcb_generate_id(dri2_dpy->conn);
 394    xcb_xfixes_create_region(dri2_dpy->conn, dri2_surf->region, 1, &rectangle);
 395 }
 396
 397 static __DRIbuffer *
 398 dri2_x11_get_buffers(__DRIdrawable * driDrawable,
 399                      int *width, int *height,
 400                      unsigned int *attachments, int count,
 401                      int *out_count, void *loaderPrivate)
 402 {
 403    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 404    struct dri2_egl_display *dri2_dpy =
 405       dri2_egl_display(dri2_surf->base.Resource.Display);
 406    xcb_dri2_dri2_buffer_t *buffers;
 407    xcb_dri2_get_buffers_reply_t *reply;
 408    xcb_dri2_get_buffers_cookie_t cookie;
 409
 410    (void) driDrawable;
 411
 412    cookie = xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
 413                                             dri2_surf->drawable,
 414                                             count, count, attachments);
 415    reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn, cookie, NULL);
 416    buffers = xcb_dri2_get_buffers_buffers (reply);
 417    if (buffers == NULL)
 418       return NULL;
 419
 420    *out_count = reply->count;
 421    dri2_surf->base.Width = *width = reply->width;
 422    dri2_surf->base.Height = *height = reply->height;
 423    dri2_x11_process_buffers(dri2_surf, buffers, *out_count);
 424
 425    free(reply);
 426
 427    return dri2_surf->buffers;
 428 }
 429
 430 static __DRIbuffer *
 431 dri2_x11_get_buffers_with_format(__DRIdrawable * driDrawable,
 432                                  int *width, int *height,
 433                                  unsigned int *attachments, int count,
 434                                  int *out_count, void *loaderPrivate)
 435 {
 436    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 437    struct dri2_egl_display *dri2_dpy =
 438       dri2_egl_display(dri2_surf->base.Resource.Display);
 439    xcb_dri2_dri2_buffer_t *buffers;
 440    xcb_dri2_get_buffers_with_format_reply_t *reply;
 441    xcb_dri2_get_buffers_with_format_cookie_t cookie;
 442    xcb_dri2_attach_format_t *format_attachments;
 443
 444    (void) driDrawable;
 445
 446    format_attachments = (xcb_dri2_attach_format_t *) attachments;
 447    cookie = xcb_dri2_get_buffers_with_format_unchecked (dri2_dpy->conn,
 448                                                         dri2_surf->drawable,
 449                                                         count, count,
 450                                                         format_attachments);
 451
 452    reply = xcb_dri2_get_buffers_with_format_reply (dri2_dpy->conn,
 453                                                    cookie, NULL);
 454    if (reply == NULL)
 455       return NULL;
 456
 457    buffers = xcb_dri2_get_buffers_with_format_buffers (reply);
 458    dri2_surf->base.Width = *width = reply->width;
 459    dri2_surf->base.Height = *height = reply->height;
 460    *out_count = reply->count;
 461    dri2_x11_process_buffers(dri2_surf, buffers, *out_count);
 462
 463    free(reply);
 464
 465    return dri2_surf->buffers;
 466 }
 467
 468 static void
 469 dri2_x11_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
 470 {
 471    (void) driDrawable;
 472
 473    /* FIXME: Does EGL support front buffer rendering at all? */
 474
 475 #if 0
 476    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 477
 478    dri2WaitGL(dri2_surf);
 479 #else
 480    (void) loaderPrivate;
 481 #endif
 482 }
 483
 484 static EGLBoolean
 485 dri2_x11_connect(struct dri2_egl_display *dri2_dpy)
 486 {
 487    xcb_xfixes_query_version_reply_t *xfixes_query;
 488    xcb_xfixes_query_version_cookie_t xfixes_query_cookie;
 489    xcb_dri2_query_version_reply_t *dri2_query;
 490    xcb_dri2_query_version_cookie_t dri2_query_cookie;
 491    xcb_dri2_connect_reply_t *connect;
 492    xcb_dri2_connect_cookie_t connect_cookie;
 493    xcb_generic_error_t *error;
 494    xcb_screen_iterator_t s;
 495    char *driver_name, *device_name;
 496    const xcb_query_extension_reply_t *extension;
 497
 498    xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_xfixes_id);
 499    xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_dri2_id);
 500
 501    extension = xcb_get_extension_data(dri2_dpy->conn, &xcb_xfixes_id);
 502    if (!(extension && extension->present))
 503       return EGL_FALSE;
 504
 505    extension = xcb_get_extension_data(dri2_dpy->conn, &xcb_dri2_id);
 506    if (!(extension && extension->present))
 507       return EGL_FALSE;
 508
 509    xfixes_query_cookie = xcb_xfixes_query_version(dri2_dpy->conn,
 510                                                   XCB_XFIXES_MAJOR_VERSION,
 511                                                   XCB_XFIXES_MINOR_VERSION);
 512
 513    dri2_query_cookie = xcb_dri2_query_version (dri2_dpy->conn,
 514                                                XCB_DRI2_MAJOR_VERSION,
 515                                                XCB_DRI2_MINOR_VERSION);
 516
 517    s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
 518    connect_cookie = xcb_dri2_connect_unchecked (dri2_dpy->conn,
 519                                                 s.data->root,
 520                                                 XCB_DRI2_DRIVER_TYPE_DRI);
 521
 522    xfixes_query =
 523       xcb_xfixes_query_version_reply (dri2_dpy->conn,
 524                                       xfixes_query_cookie, &error);
 525    if (xfixes_query == NULL ||
 526        error != NULL || xfixes_query->major_version < 2) {
 527       _eglLog(_EGL_WARNING, "DRI2: failed to query xfixes version");
 528       free(error);
 529       return EGL_FALSE;
 530    }
 531    free(xfixes_query);
 532
 533    dri2_query =
 534       xcb_dri2_query_version_reply (dri2_dpy->conn, dri2_query_cookie, &error);
 535    if (dri2_query == NULL || error != NULL) {
 536       _eglLog(_EGL_WARNING, "DRI2: failed to query version");
 537       free(error);
 538       return EGL_FALSE;
 539    }
 540    dri2_dpy->dri2_major = dri2_query->major_version;
 541    dri2_dpy->dri2_minor = dri2_query->minor_version;
 542    free(dri2_query);
 543
 544    connect = xcb_dri2_connect_reply (dri2_dpy->conn, connect_cookie, NULL);
 545    if (connect == NULL ||
 546        connect->driver_name_length + connect->device_name_length == 0) {
 547       _eglLog(_EGL_WARNING, "DRI2: failed to authenticate");
 548       return EGL_FALSE;
 549    }
 550
 551    driver_name = xcb_dri2_connect_driver_name (connect);
 552    dri2_dpy->driver_name =
 553       strndup(driver_name,
 554               xcb_dri2_connect_driver_name_length(connect));
 555
 556    device_name = xcb_dri2_connect_device_name (connect);
 557
 558    dri2_dpy->device_name =
 559       strndup(device_name,
 560               xcb_dri2_connect_device_name_length(connect));
 561
 562    if (dri2_dpy->device_name == NULL || dri2_dpy->driver_name == NULL) {
 563       free(dri2_dpy->device_name);
 564       free(dri2_dpy->driver_name);
 565       free(connect);
 566       return EGL_FALSE;
 567    }
 568    free(connect);
 569
 570    return EGL_TRUE;
 571 }
 572
 573 static int
 574 dri2_x11_authenticate(_EGLDisplay *disp, uint32_t id)
 575 {
 576    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 577    xcb_dri2_authenticate_reply_t *authenticate;
 578    xcb_dri2_authenticate_cookie_t authenticate_cookie;
 579    xcb_screen_iterator_t s;
 580    int ret = 0;
 581
 582    s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
 583    authenticate_cookie =
 584       xcb_dri2_authenticate_unchecked(dri2_dpy->conn, s.data->root, id);
 585    authenticate =
 586       xcb_dri2_authenticate_reply(dri2_dpy->conn, authenticate_cookie, NULL);
 587
 588    if (authenticate == NULL || !authenticate->authenticated)
 589       ret = -1;
 590
 591    free(authenticate);
 592
 593    return ret;
 594 }
 595
 596 static EGLBoolean
 597 dri2_x11_local_authenticate(_EGLDisplay *disp)
 598 {
 599 #ifdef HAVE_LIBDRM
 600    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 601    drm_magic_t magic;
 602
 603    if (drmGetMagic(dri2_dpy->fd, &magic)) {
 604       _eglLog(_EGL_WARNING, "DRI2: failed to get drm magic");
 605       return EGL_FALSE;
 606    }
 607
 608    if (dri2_x11_authenticate(disp, magic) < 0) {
 609       _eglLog(_EGL_WARNING, "DRI2: failed to authenticate");
 610       return EGL_FALSE;
 611    }
 612 #endif
 613    return EGL_TRUE;
 614 }
 615
 616 static EGLBoolean
 617 dri2_x11_add_configs_for_visuals(struct dri2_egl_display *dri2_dpy,
 618                                  _EGLDisplay *disp)
 619 {
 620    xcb_screen_iterator_t s;
 621    xcb_depth_iterator_t d;
 622    xcb_visualtype_t *visuals;
 623    int i, j, id;
 624    unsigned int rgba_masks[4];
 625    EGLint surface_type;
 626    EGLint config_attrs[] = {
 627            EGL_NATIVE_VISUAL_ID,   0,
 628            EGL_NATIVE_VISUAL_TYPE, 0,
 629            EGL_NONE
 630    };
 631
 632    s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
 633    d = xcb_screen_allowed_depths_iterator(s.data);
 634    id = 1;
 635
 636    surface_type =
 637       EGL_WINDOW_BIT |
 638       EGL_PIXMAP_BIT |
 639       EGL_PBUFFER_BIT |
 640       EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
 641
 642    while (d.rem > 0) {
 643       EGLBoolean class_added[6] = { 0, };
 644
 645       visuals = xcb_depth_visuals(d.data);
 646       for (i = 0; i < xcb_depth_visuals_length(d.data); i++) {
 647          if (class_added[visuals[i]._class])
 648             continue;
 649
 650          class_added[visuals[i]._class] = EGL_TRUE;
 651          for (j = 0; dri2_dpy->driver_configs[j]; j++) {
 652             config_attrs[1] = visuals[i].visual_id;
 653             config_attrs[3] = visuals[i]._class;
 654
 655             rgba_masks[0] = visuals[i].red_mask;
 656             rgba_masks[1] = visuals[i].green_mask;
 657             rgba_masks[2] = visuals[i].blue_mask;
 658             rgba_masks[3] = 0;
 659             dri2_add_config(disp, dri2_dpy->driver_configs[j], id++,
 660                             surface_type, config_attrs, rgba_masks);
 661
 662             /* Allow a 24-bit RGB visual to match a 32-bit RGBA EGLConfig.
 663              * Otherwise it will only match a 32-bit RGBA visual.  On a
 664              * composited window manager on X11, this will make all of the
 665              * EGLConfigs with destination alpha get blended by the
 666              * compositor.  This is probably not what the application
 667              * wants... especially on drivers that only have 32-bit RGBA
 668              * EGLConfigs! */
 669             if (d.data->depth == 24) {
 670                rgba_masks[3] =
 671                   ~(rgba_masks[0] | rgba_masks[1] | rgba_masks[2]);
 672                dri2_add_config(disp, dri2_dpy->driver_configs[j], id++,
 673                                surface_type, config_attrs, rgba_masks);
 674             }
 675          }
 676       }
 677
 678       xcb_depth_next(&d);
 679    }
 680
 681    if (!_eglGetArraySize(disp->Configs)) {
 682       _eglLog(_EGL_WARNING, "DRI2: failed to create any config");
 683       return EGL_FALSE;
 684    }
 685
 686    return EGL_TRUE;
 687 }
 688
 689 static EGLBoolean
 690 dri2_copy_region(_EGLDriver *drv, _EGLDisplay *disp,
 691                  _EGLSurface *draw, xcb_xfixes_region_t region)
 692 {
 693    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 694    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
 695    enum xcb_dri2_attachment_t render_attachment;
 696    xcb_dri2_copy_region_cookie_t cookie;
 697
 698    /* No-op for a pixmap or pbuffer surface */
 699    if (draw->Type == EGL_PIXMAP_BIT || draw->Type == EGL_PBUFFER_BIT)
 700       return EGL_TRUE;
 701
 702    if (dri2_dpy->flush)
 703       (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
 704
 705    if (dri2_surf->have_fake_front)
 706       render_attachment = XCB_DRI2_ATTACHMENT_BUFFER_FAKE_FRONT_LEFT;
 707    else
 708       render_attachment = XCB_DRI2_ATTACHMENT_BUFFER_BACK_LEFT;
 709
 710    cookie = xcb_dri2_copy_region_unchecked(dri2_dpy->conn,
 711                                            dri2_surf->drawable,
 712                                            region,
 713                                            XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT,
 714                                            render_attachment);
 715    free(xcb_dri2_copy_region_reply(dri2_dpy->conn, cookie, NULL));
 716
 717    return EGL_TRUE;
 718 }
 719
 720 static int64_t
 721 dri2_x11_swap_buffers_msc(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
 722                           int64_t msc, int64_t divisor, int64_t remainder)
 723 {
 724    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 725    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
 726    uint32_t msc_hi = msc >> 32;
 727    uint32_t msc_lo = msc & 0xffffffff;
 728    uint32_t divisor_hi = divisor >> 32;
 729    uint32_t divisor_lo = divisor & 0xffffffff;
 730    uint32_t remainder_hi = remainder >> 32;
 731    uint32_t remainder_lo = remainder & 0xffffffff;
 732    xcb_dri2_swap_buffers_cookie_t cookie;
 733    xcb_dri2_swap_buffers_reply_t *reply;
 734    int64_t swap_count = -1;
 735
 736    /* No-op for a pixmap or pbuffer surface */
 737    if (draw->Type == EGL_PIXMAP_BIT || draw->Type == EGL_PBUFFER_BIT)
 738       return 0;
 739
 740    if (draw->SwapBehavior == EGL_BUFFER_PRESERVED || !dri2_dpy->swap_available)
 741       return dri2_copy_region(drv, disp, draw, dri2_surf->region) ? 0 : -1;
 742
 743    if (dri2_dpy->flush)
 744       (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
 745
 746    cookie = xcb_dri2_swap_buffers_unchecked(dri2_dpy->conn, dri2_surf->drawable,
 747                   msc_hi, msc_lo, divisor_hi, divisor_lo, remainder_hi, remainder_lo);
 748
 749    reply = xcb_dri2_swap_buffers_reply(dri2_dpy->conn, cookie, NULL);
 750
 751    if (reply) {
 752       swap_count = (((int64_t)reply->swap_hi) << 32) | reply->swap_lo;
 753       free(reply);
 754    }
 755
 756    /* Since we aren't watching for the server's invalidate events like we're
 757     * supposed to (due to XCB providing no mechanism for filtering the events
 758     * the way xlib does), and SwapBuffers is a common cause of invalidate
 759     * events, just shove one down to the driver, even though we haven't told
 760     * the driver that we're the kind of loader that provides reliable
 761     * invalidate events.  This causes the driver to request buffers again at
 762     * its next draw, so that we get the correct buffers if a pageflip
 763     * happened.  The driver should still be using the viewport hack to catch
 764     * window resizes.
 765     */
 766    if (dri2_dpy->flush &&
 767        dri2_dpy->flush->base.version >= 3 && dri2_dpy->flush->invalidate)
 768       (*dri2_dpy->flush->invalidate)(dri2_surf->dri_drawable);
 769
 770    return swap_count;
 771 }
 772
 773 static EGLBoolean
 774 dri2_x11_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
 775 {
 776    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 777    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
 778
 779    if (dri2_dpy->dri2) {
 780       return dri2_x11_swap_buffers_msc(drv, disp, draw, 0, 0, 0) != -1;
 781    } else {
 782       assert(dri2_dpy->swrast);
 783
 784       dri2_dpy->core->swapBuffers(dri2_surf->dri_drawable);
 785       return EGL_TRUE;
 786    }
 787 }
 788
 789 static EGLBoolean
 790 dri2_x11_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp,
 791                              _EGLSurface *draw,
 792                              EGLint numRects, const EGLint *rects)
 793 {
 794    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 795    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
 796    EGLBoolean ret;
 797    xcb_xfixes_region_t region;
 798    xcb_rectangle_t rectangles[16];
 799    int i;
 800
 801    if (numRects > (int)ARRAY_SIZE(rectangles))
 802       return dri2_copy_region(drv, disp, draw, dri2_surf->region);
 803
 804    for (i = 0; i < numRects; i++) {
 805       rectangles[i].x = rects[i * 4];
 806       rectangles[i].y = dri2_surf->base.Height - rects[i * 4 + 1] - rects[i * 4 + 3];
 807       rectangles[i].width = rects[i * 4 + 2];
 808       rectangles[i].height = rects[i * 4 + 3];
 809    }
 810
 811    region = xcb_generate_id(dri2_dpy->conn);
 812    xcb_xfixes_create_region(dri2_dpy->conn, region, numRects, rectangles);
 813    ret = dri2_copy_region(drv, disp, draw, region);
 814    xcb_xfixes_destroy_region(dri2_dpy->conn, region);
 815
 816    return ret;
 817 }
 818
 819 static EGLBoolean
 820 dri2_x11_post_sub_buffer(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
 821                      EGLint x, EGLint y, EGLint width, EGLint height)
 822 {
 823    const EGLint rect[4] = { x, y, width, height };
 824
 825    if (x < 0 || y < 0 || width < 0 || height < 0)
 826       _eglError(EGL_BAD_PARAMETER, "eglPostSubBufferNV");
 827
 828    return dri2_x11_swap_buffers_region(drv, disp, draw, 1, rect);
 829 }
 830
 831 static EGLBoolean
 832 dri2_x11_swap_interval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
 833                        EGLint interval)
 834 {
 835    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 836    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
 837
 838    if (interval > surf->Config->MaxSwapInterval)
 839       interval = surf->Config->MaxSwapInterval;
 840    else if (interval < surf->Config->MinSwapInterval)
 841       interval = surf->Config->MinSwapInterval;
 842
 843    if (interval != surf->SwapInterval && dri2_dpy->swap_available)
 844       xcb_dri2_swap_interval(dri2_dpy->conn, dri2_surf->drawable, interval);
 845
 846    surf->SwapInterval = interval;
 847
 848    return EGL_TRUE;
 849 }
 850
 851 static EGLBoolean
 852 dri2_x11_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
 853                       void *native_pixmap_target)
 854 {
 855    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 856    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
 857    xcb_gcontext_t gc;
 858    xcb_pixmap_t target;
 859
 860    STATIC_ASSERT(sizeof(uintptr_t) == sizeof(native_pixmap_target));
 861    target = (uintptr_t) native_pixmap_target;
 862
 863    (void) drv;
 864
 865    (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
 866
 867    gc = xcb_generate_id(dri2_dpy->conn);
 868    xcb_create_gc(dri2_dpy->conn, gc, target, 0, NULL);
 869    xcb_copy_area(dri2_dpy->conn,
 870                   dri2_surf->drawable,
 871                   target,
 872                   gc,
 873                   0, 0,
 874                   0, 0,
 875                   dri2_surf->base.Width,
 876                   dri2_surf->base.Height);
 877    xcb_free_gc(dri2_dpy->conn, gc);
 878
 879    return EGL_TRUE;
 880 }
 881
 882 static _EGLImage *
 883 dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx,
 884                              EGLClientBuffer buffer, const EGLint *attr_list)
 885 {
 886    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 887    struct dri2_egl_image *dri2_img;
 888    unsigned int attachments[1];
 889    xcb_drawable_t drawable;
 890    xcb_dri2_get_buffers_cookie_t buffers_cookie;
 891    xcb_dri2_get_buffers_reply_t *buffers_reply;
 892    xcb_dri2_dri2_buffer_t *buffers;
 893    xcb_get_geometry_cookie_t geometry_cookie;
 894    xcb_get_geometry_reply_t *geometry_reply;
 895    xcb_generic_error_t *error;
 896    int stride, format;
 897
 898    (void) ctx;
 899
 900    drawable = (xcb_drawable_t) (uintptr_t) buffer;
 901    xcb_dri2_create_drawable (dri2_dpy->conn, drawable);
 902    attachments[0] = XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT;
 903    buffers_cookie =
 904       xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
 905                                       drawable, 1, 1, attachments);
 906    geometry_cookie = xcb_get_geometry (dri2_dpy->conn, drawable);
 907    buffers_reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn,
 908                                                buffers_cookie, NULL);
 909    buffers = xcb_dri2_get_buffers_buffers (buffers_reply);
 910    if (buffers == NULL) {
 911       return NULL;
 912    }
 913
 914    geometry_reply = xcb_get_geometry_reply (dri2_dpy->conn,
 915                                             geometry_cookie, &error);
 916    if (geometry_reply == NULL || error != NULL) {
 917       _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
 918       free(error);
 919       free(buffers_reply);
 920       return NULL;
 921    }
 922
 923    switch (geometry_reply->depth) {
 924    case 16:
 925       format = __DRI_IMAGE_FORMAT_RGB565;
 926       break;
 927    case 24:
 928       format = __DRI_IMAGE_FORMAT_XRGB8888;
 929       break;
 930    case 32:
 931       format = __DRI_IMAGE_FORMAT_ARGB8888;
 932       break;
 933    default:
 934       _eglError(EGL_BAD_PARAMETER,
 935                 "dri2_create_image_khr: unsupported pixmap depth");
 936       free(buffers_reply);
 937       free(geometry_reply);
 938       return NULL;
 939    }
 940
 941    dri2_img = malloc(sizeof *dri2_img);
 942    if (!dri2_img) {
 943       free(buffers_reply);
 944       free(geometry_reply);
 945       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
 946       return EGL_NO_IMAGE_KHR;
 947    }
 948
 949    if (!_eglInitImage(&dri2_img->base, disp)) {
 950       free(buffers_reply);
 951       free(geometry_reply);
 952       free(dri2_img);
 953       return EGL_NO_IMAGE_KHR;
 954    }
 955
 956    stride = buffers[0].pitch / buffers[0].cpp;
 957    dri2_img->dri_image =
 958       dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
 959                                            buffers_reply->width,
 960                                            buffers_reply->height,
 961                                            format,
 962                                            buffers[0].name,
 963                                            stride,
 964                                            dri2_img);
 965
 966    free(buffers_reply);
 967    free(geometry_reply);
 968
 969    return &dri2_img->base;
 970 }
 971
 972 static _EGLImage *
 973 dri2_x11_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
 974                           _EGLContext *ctx, EGLenum target,
 975                           EGLClientBuffer buffer, const EGLint *attr_list)
 976 {
 977    (void) drv;
 978
 979    switch (target) {
 980    case EGL_NATIVE_PIXMAP_KHR:
 981       return dri2_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
 982    default:
 983       return dri2_create_image_khr(drv, disp, ctx, target, buffer, attr_list);
 984    }
 985 }
 986
 987 static _EGLImage*
 988 dri2_x11_swrast_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
 989                                  _EGLContext *ctx, EGLenum target,
 990                                  EGLClientBuffer buffer,
 991                                  const EGLint *attr_list)
 992 {
 993    return NULL;
 994 }
 995
 996 static EGLBoolean
 997 dri2_x11_get_sync_values(_EGLDisplay *display, _EGLSurface *surface,
 998                          EGLuint64KHR *ust, EGLuint64KHR *msc,
 999                          EGLuint64KHR *sbc)
1000 {
1001    struct dri2_egl_display *dri2_dpy = dri2_egl_display(display);
1002    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surface);
1003    xcb_dri2_get_msc_cookie_t cookie;
1004    xcb_dri2_get_msc_reply_t *reply;
1005
1006    cookie = xcb_dri2_get_msc(dri2_dpy->conn, dri2_surf->drawable);
1007    reply = xcb_dri2_get_msc_reply(dri2_dpy->conn, cookie, NULL);
1008
1009    if (!reply) {
1010       _eglError(EGL_BAD_ACCESS, __func__);
1011       return EGL_FALSE;
1012    }
1013
1014    *ust = ((EGLuint64KHR) reply->ust_hi << 32) | reply->ust_lo;
1015    *msc = ((EGLuint64KHR) reply->msc_hi << 32) | reply->msc_lo;
1016    *sbc = ((EGLuint64KHR) reply->sbc_hi << 32) | reply->sbc_lo;
1017    free(reply);
1018
1019    return EGL_TRUE;
1020 }
1021
1022 static struct dri2_egl_display_vtbl dri2_x11_swrast_display_vtbl = {
1023    .authenticate = NULL,
1024    .create_window_surface = dri2_x11_create_window_surface,
1025    .create_pixmap_surface = dri2_x11_create_pixmap_surface,
1026    .create_pbuffer_surface = dri2_x11_create_pbuffer_surface,
1027    .destroy_surface = dri2_x11_destroy_surface,
1028    .create_image = dri2_x11_swrast_create_image_khr,
1029    .swap_interval = dri2_fallback_swap_interval,
1030    .swap_buffers = dri2_x11_swap_buffers,
1031    .swap_buffers_region = dri2_fallback_swap_buffers_region,
1032    .post_sub_buffer = dri2_fallback_post_sub_buffer,
1033    .copy_buffers = dri2_x11_copy_buffers,
1034    .query_buffer_age = dri2_fallback_query_buffer_age,
1035    .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
1036    .get_sync_values = dri2_fallback_get_sync_values,
1037 };
1038
1039 static struct dri2_egl_display_vtbl dri2_x11_display_vtbl = {
1040    .authenticate = dri2_x11_authenticate,
1041    .create_window_surface = dri2_x11_create_window_surface,
1042    .create_pixmap_surface = dri2_x11_create_pixmap_surface,
1043    .create_pbuffer_surface = dri2_x11_create_pbuffer_surface,
1044    .destroy_surface = dri2_x11_destroy_surface,
1045    .create_image = dri2_x11_create_image_khr,
1046    .swap_interval = dri2_x11_swap_interval,
1047    .swap_buffers = dri2_x11_swap_buffers,
1048    .swap_buffers_with_damage = dri2_fallback_swap_buffers_with_damage,
1049    .swap_buffers_region = dri2_x11_swap_buffers_region,
1050    .post_sub_buffer = dri2_x11_post_sub_buffer,
1051    .copy_buffers = dri2_x11_copy_buffers,
1052    .query_buffer_age = dri2_fallback_query_buffer_age,
1053    .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
1054    .get_sync_values = dri2_x11_get_sync_values,
1055 };
1056
1057 static EGLBoolean
1058 dri2_initialize_x11_swrast(_EGLDriver *drv, _EGLDisplay *disp)
1059 {
1060    struct dri2_egl_display *dri2_dpy;
1061
1062    dri2_dpy = calloc(1, sizeof *dri2_dpy);
1063    if (!dri2_dpy)
1064       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1065
1066    disp->DriverData = (void *) dri2_dpy;
1067    if (disp->PlatformDisplay == NULL) {
1068       dri2_dpy->conn = xcb_connect(0, 0);
1069       dri2_dpy->own_device = true;
1070    } else {
1071       dri2_dpy->conn = XGetXCBConnection((Display *) disp->PlatformDisplay);
1072    }
1073
1074    if (xcb_connection_has_error(dri2_dpy->conn)) {
1075       _eglLog(_EGL_WARNING, "DRI2: xcb_connect failed");
1076       goto cleanup_dpy;
1077    }
1078
1079    /*
1080     * Every hardware driver_name is set using strdup. Doing the same in
1081     * here will allow is to simply free the memory at dri2_terminate().
1082     */
1083    dri2_dpy->driver_name = strdup("swrast");
1084    if (!dri2_load_driver_swrast(disp))
1085       goto cleanup_conn;
1086
1087    dri2_dpy->swrast_loader_extension.base.name = __DRI_SWRAST_LOADER;
1088    dri2_dpy->swrast_loader_extension.base.version = __DRI_SWRAST_LOADER_VERSION;
1089    dri2_dpy->swrast_loader_extension.getDrawableInfo = swrastGetDrawableInfo;
1090    dri2_dpy->swrast_loader_extension.putImage = swrastPutImage;
1091    dri2_dpy->swrast_loader_extension.getImage = swrastGetImage;
1092
1093    dri2_dpy->extensions[0] = &dri2_dpy->swrast_loader_extension.base;
1094    dri2_dpy->extensions[1] = NULL;
1095    dri2_dpy->extensions[2] = NULL;
1096
1097    if (!dri2_create_screen(disp))
1098       goto cleanup_driver;
1099
1100    if (dri2_dpy->conn) {
1101       if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp))
1102          goto cleanup_configs;
1103    }
1104
1105    /* we're supporting EGL 1.4 */
1106    disp->VersionMajor = 1;
1107    disp->VersionMinor = 4;
1108
1109    /* Fill vtbl last to prevent accidentally calling virtual function during
1110     * initialization.
1111     */
1112    dri2_dpy->vtbl = &dri2_x11_swrast_display_vtbl;
1113
1114    return EGL_TRUE;
1115
1116  cleanup_configs:
1117    _eglCleanupDisplay(disp);
1118    dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
1119  cleanup_driver:
1120    dlclose(dri2_dpy->driver);
1121  cleanup_conn:
1122    free(dri2_dpy->driver_name);
1123    if (disp->PlatformDisplay == NULL)
1124       xcb_disconnect(dri2_dpy->conn);
1125  cleanup_dpy:
1126    free(dri2_dpy);
1127
1128    return EGL_FALSE;
1129 }
1130
1131 static void
1132 dri2_x11_setup_swap_interval(struct dri2_egl_display *dri2_dpy)
1133 {
1134    GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
1135    int arbitrary_max_interval = 1000;
1136
1137    /* default behavior for no SwapBuffers support: no vblank syncing
1138     * either.
1139     */
1140    dri2_dpy->min_swap_interval = 0;
1141    dri2_dpy->max_swap_interval = 0;
1142
1143    if (!dri2_dpy->swap_available)
1144       return;
1145
1146    /* If we do have swapbuffers, then we can support pretty much any swap
1147     * interval, but we allow driconf to override applications.
1148     */
1149    if (dri2_dpy->config)
1150       dri2_dpy->config->configQueryi(dri2_dpy->dri_screen,
1151                                      "vblank_mode", &vblank_mode);
1152    switch (vblank_mode) {
1153    case DRI_CONF_VBLANK_NEVER:
1154       dri2_dpy->min_swap_interval = 0;
1155       dri2_dpy->max_swap_interval = 0;
1156       dri2_dpy->default_swap_interval = 0;
1157       break;
1158    case DRI_CONF_VBLANK_ALWAYS_SYNC:
1159       dri2_dpy->min_swap_interval = 1;
1160       dri2_dpy->max_swap_interval = arbitrary_max_interval;
1161       dri2_dpy->default_swap_interval = 1;
1162       break;
1163    case DRI_CONF_VBLANK_DEF_INTERVAL_0:
1164       dri2_dpy->min_swap_interval = 0;
1165       dri2_dpy->max_swap_interval = arbitrary_max_interval;
1166       dri2_dpy->default_swap_interval = 0;
1167       break;
1168    default:
1169    case DRI_CONF_VBLANK_DEF_INTERVAL_1:
1170       dri2_dpy->min_swap_interval = 0;
1171       dri2_dpy->max_swap_interval = arbitrary_max_interval;
1172       dri2_dpy->default_swap_interval = 1;
1173       break;
1174    }
1175 }
1176
1177 static EGLBoolean
1178 dri2_initialize_x11_dri2(_EGLDriver *drv, _EGLDisplay *disp)
1179 {
1180    struct dri2_egl_display *dri2_dpy;
1181
1182    dri2_dpy = calloc(1, sizeof *dri2_dpy);
1183    if (!dri2_dpy)
1184       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1185
1186    disp->DriverData = (void *) dri2_dpy;
1187    if (disp->PlatformDisplay == NULL) {
1188       dri2_dpy->conn = xcb_connect(0, 0);
1189       dri2_dpy->own_device = true;
1190    } else {
1191       dri2_dpy->conn = XGetXCBConnection((Display *) disp->PlatformDisplay);
1192    }
1193
1194    if (xcb_connection_has_error(dri2_dpy->conn)) {
1195       _eglLog(_EGL_WARNING, "DRI2: xcb_connect failed");
1196       goto cleanup_dpy;
1197    }
1198
1199    if (dri2_dpy->conn) {
1200       if (!dri2_x11_connect(dri2_dpy))
1201          goto cleanup_conn;
1202    }
1203
1204    if (!dri2_load_driver(disp))
1205       goto cleanup_conn;
1206
1207 #ifdef O_CLOEXEC
1208    dri2_dpy->fd = open(dri2_dpy->device_name, O_RDWR | O_CLOEXEC);
1209    if (dri2_dpy->fd == -1 && errno == EINVAL)
1210 #endif
1211    {
1212       dri2_dpy->fd = open(dri2_dpy->device_name, O_RDWR);
1213       if (dri2_dpy->fd != -1)
1214          fcntl(dri2_dpy->fd, F_SETFD, fcntl(dri2_dpy->fd, F_GETFD) |
1215             FD_CLOEXEC);
1216    }
1217    if (dri2_dpy->fd == -1) {
1218       _eglLog(_EGL_WARNING,
1219               "DRI2: could not open %s (%s)", dri2_dpy->device_name,
1220               strerror(errno));
1221       goto cleanup_driver;
1222    }
1223
1224    if (dri2_dpy->conn) {
1225       if (!dri2_x11_local_authenticate(disp))
1226          goto cleanup_fd;
1227    }
1228
1229    if (dri2_dpy->dri2_minor >= 1) {
1230       dri2_dpy->dri2_loader_extension.base.name = __DRI_DRI2_LOADER;
1231       dri2_dpy->dri2_loader_extension.base.version = 3;
1232       dri2_dpy->dri2_loader_extension.getBuffers = dri2_x11_get_buffers;
1233       dri2_dpy->dri2_loader_extension.flushFrontBuffer = dri2_x11_flush_front_buffer;
1234       dri2_dpy->dri2_loader_extension.getBuffersWithFormat =
1235          dri2_x11_get_buffers_with_format;
1236    } else {
1237       dri2_dpy->dri2_loader_extension.base.name = __DRI_DRI2_LOADER;
1238       dri2_dpy->dri2_loader_extension.base.version = 2;
1239       dri2_dpy->dri2_loader_extension.getBuffers = dri2_x11_get_buffers;
1240       dri2_dpy->dri2_loader_extension.flushFrontBuffer = dri2_x11_flush_front_buffer;
1241       dri2_dpy->dri2_loader_extension.getBuffersWithFormat = NULL;
1242    }
1243
1244    dri2_dpy->extensions[0] = &dri2_dpy->dri2_loader_extension.base;
1245    dri2_dpy->extensions[1] = &image_lookup_extension.base;
1246    dri2_dpy->extensions[2] = NULL;
1247
1248    dri2_dpy->swap_available = (dri2_dpy->dri2_minor >= 2);
1249    dri2_dpy->invalidate_available = (dri2_dpy->dri2_minor >= 3);
1250
1251    if (!dri2_create_screen(disp))
1252       goto cleanup_fd;
1253
1254    dri2_x11_setup_swap_interval(dri2_dpy);
1255
1256    if (dri2_dpy->conn) {
1257       if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp))
1258          goto cleanup_configs;
1259    }
1260
1261    disp->Extensions.KHR_image_pixmap = EGL_TRUE;
1262    disp->Extensions.NOK_swap_region = EGL_TRUE;
1263    disp->Extensions.NOK_texture_from_pixmap = EGL_TRUE;
1264    disp->Extensions.NV_post_sub_buffer = EGL_TRUE;
1265    disp->Extensions.CHROMIUM_sync_control = EGL_TRUE;
1266
1267 #ifdef HAVE_WAYLAND_PLATFORM
1268    disp->Extensions.WL_bind_wayland_display = EGL_TRUE;
1269 #endif
1270
1271    if (dri2_dpy->conn) {
1272       if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp))
1273          goto cleanup_configs;
1274    }
1275
1276    /* we're supporting EGL 1.4 */
1277    disp->VersionMajor = 1;
1278    disp->VersionMinor = 4;
1279
1280    /* Fill vtbl last to prevent accidentally calling virtual function during
1281     * initialization.
1282     */
1283    dri2_dpy->vtbl = &dri2_x11_display_vtbl;
1284
1285    return EGL_TRUE;
1286
1287  cleanup_configs:
1288    _eglCleanupDisplay(disp);
1289    dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
1290  cleanup_fd:
1291    close(dri2_dpy->fd);
1292  cleanup_driver:
1293    dlclose(dri2_dpy->driver);
1294  cleanup_conn:
1295    if (disp->PlatformDisplay == NULL)
1296       xcb_disconnect(dri2_dpy->conn);
1297  cleanup_dpy:
1298    free(dri2_dpy);
1299
1300    return EGL_FALSE;
1301 }
1302
1303 EGLBoolean
1304 dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp)
1305 {
1306    EGLBoolean initialized = EGL_TRUE;
1307
1308    int x11_dri2_accel = (getenv("LIBGL_ALWAYS_SOFTWARE") == NULL);
1309
1310    if (x11_dri2_accel) {
1311       if (!dri2_initialize_x11_dri2(drv, disp)) {
1312          initialized = dri2_initialize_x11_swrast(drv, disp);
1313       }
1314    } else {
1315       initialized = dri2_initialize_x11_swrast(drv, disp);
1316    }
1317
1318    return initialized;
1319 }
1320