src/egl/drivers/dri2/platform_drm.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 <stdint.h>
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <xf86drm.h>
  33 #include <dlfcn.h>
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <fcntl.h>
  37 #include <unistd.h>
  38
  39 #include "egl_dri2.h"
  40 #include "egl_dri2_fallbacks.h"
  41 #include "loader.h"
  42
  43 static struct gbm_bo *
  44 lock_front_buffer(struct gbm_surface *_surf)
  45 {
  46    struct gbm_dri_surface *surf = (struct gbm_dri_surface *) _surf;
  47    struct dri2_egl_surface *dri2_surf = surf->dri_private;
  48    struct gbm_dri_device *device = (struct gbm_dri_device *) _surf->gbm;
  49    struct gbm_bo *bo;
  50
  51    if (dri2_surf->current == NULL) {
  52       _eglError(EGL_BAD_SURFACE, "no front buffer");
  53       return NULL;
  54    }
  55
  56    bo = dri2_surf->current->bo;
  57
  58    if (device->dri2) {
  59       dri2_surf->current->locked = 1;
  60       dri2_surf->current = NULL;
  61    }
  62
  63    return bo;
  64 }
  65
  66 static void
  67 release_buffer(struct gbm_surface *_surf, struct gbm_bo *bo)
  68 {
  69    struct gbm_dri_surface *surf = (struct gbm_dri_surface *) _surf;
  70    struct dri2_egl_surface *dri2_surf = surf->dri_private;
  71    unsigned i;
  72
  73    for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
  74       if (dri2_surf->color_buffers[i].bo == bo) {
  75          dri2_surf->color_buffers[i].locked = 0;
  76       }
  77    }
  78 }
  79
  80 static int
  81 has_free_buffers(struct gbm_surface *_surf)
  82 {
  83    struct gbm_dri_surface *surf = (struct gbm_dri_surface *) _surf;
  84    struct dri2_egl_surface *dri2_surf = surf->dri_private;
  85    unsigned i;
  86
  87    for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++)
  88       if (!dri2_surf->color_buffers[i].locked)
  89          return 1;
  90
  91    return 0;
  92 }
  93
  94 static _EGLSurface *
  95 dri2_drm_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
  96                         _EGLConfig *conf, void *native_window,
  97                         const EGLint *attrib_list)
  98 {
  99    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 100    struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
 101    struct dri2_egl_surface *dri2_surf;
 102    struct gbm_surface *window = native_window;
 103    struct gbm_dri_surface *surf;
 104
 105    (void) drv;
 106
 107    dri2_surf = calloc(1, sizeof *dri2_surf);
 108    if (!dri2_surf) {
 109       _eglError(EGL_BAD_ALLOC, "dri2_create_surface");
 110       return NULL;
 111    }
 112
 113    if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list))
 114       goto cleanup_surf;
 115
 116    switch (type) {
 117    case EGL_WINDOW_BIT:
 118       if (!window) {
 119          _eglError(EGL_BAD_NATIVE_WINDOW, "dri2_create_surface");
 120          goto cleanup_surf;
 121       }
 122
 123       surf = gbm_dri_surface(window);
 124       dri2_surf->gbm_surf = surf;
 125       dri2_surf->base.Width =  surf->base.width;
 126       dri2_surf->base.Height = surf->base.height;
 127       surf->dri_private = dri2_surf;
 128       break;
 129    default:
 130       goto cleanup_surf;
 131    }
 132
 133    if (dri2_dpy->dri2) {
 134       const __DRIconfig *config =
 135          dri2_get_dri_config(dri2_conf, EGL_WINDOW_BIT,
 136                              dri2_surf->base.GLColorspace);
 137
 138       dri2_surf->dri_drawable =
 139          (*dri2_dpy->dri2->createNewDrawable)(dri2_dpy->dri_screen, config,
 140                                               dri2_surf->gbm_surf);
 141
 142    } else {
 143       assert(dri2_dpy->swrast != NULL);
 144       dri2_surf->dri_drawable =
 145          (*dri2_dpy->swrast->createNewDrawable) (dri2_dpy->dri_screen,
 146                                                  dri2_conf->dri_double_config,
 147                                                  dri2_surf->gbm_surf);
 148
 149    }
 150    if (dri2_surf->dri_drawable == NULL) {
 151       _eglError(EGL_BAD_ALLOC, "createNewDrawable()");
 152       goto cleanup_surf;
 153    }
 154
 155    return &dri2_surf->base;
 156
 157  cleanup_surf:
 158    free(dri2_surf);
 159
 160    return NULL;
 161 }
 162
 163 static _EGLSurface *
 164 dri2_drm_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
 165                                _EGLConfig *conf, void *native_window,
 166                                const EGLint *attrib_list)
 167 {
 168    return dri2_drm_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
 169                                   native_window, attrib_list);
 170 }
 171
 172 static _EGLSurface *
 173 dri2_drm_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
 174                                _EGLConfig *conf, void *native_window,
 175                                const EGLint *attrib_list)
 176 {
 177    /* From the EGL_MESA_platform_gbm spec, version 5:
 178     *
 179     *  It is not valid to call eglCreatePlatformPixmapSurfaceEXT with a <dpy>
 180     *  that belongs to the GBM platform. Any such call fails and generates
 181     *  EGL_BAD_PARAMETER.
 182     */
 183    _eglError(EGL_BAD_PARAMETER, "cannot create EGL pixmap surfaces on GBM");
 184    return NULL;
 185 }
 186
 187 static EGLBoolean
 188 dri2_drm_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
 189 {
 190    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 191    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
 192    unsigned i;
 193
 194    if (!_eglPutSurface(surf))
 195       return EGL_TRUE;
 196
 197    (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
 198
 199    for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
 200       if (dri2_surf->color_buffers[i].bo)
 201          gbm_bo_destroy(dri2_surf->color_buffers[i].bo);
 202    }
 203
 204    for (i = 0; i < __DRI_BUFFER_COUNT; i++) {
 205       if (dri2_surf->dri_buffers[i])
 206          dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
 207                                        dri2_surf->dri_buffers[i]);
 208    }
 209
 210    free(surf);
 211
 212    return EGL_TRUE;
 213 }
 214
 215 static int
 216 get_back_bo(struct dri2_egl_surface *dri2_surf)
 217 {
 218    struct dri2_egl_display *dri2_dpy =
 219       dri2_egl_display(dri2_surf->base.Resource.Display);
 220    struct gbm_dri_surface *surf = dri2_surf->gbm_surf;
 221    unsigned i;
 222
 223    if (dri2_surf->back == NULL) {
 224       for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
 225          if (!dri2_surf->color_buffers[i].locked) {
 226             dri2_surf->back = &dri2_surf->color_buffers[i];
 227             break;
 228          }
 229       }
 230    }
 231
 232    if (dri2_surf->back == NULL)
 233       return -1;
 234    if (dri2_surf->back->bo == NULL)
 235       dri2_surf->back->bo = gbm_bo_create(&dri2_dpy->gbm_dri->base.base,
 236                                           surf->base.width, surf->base.height,
 237                                           surf->base.format, surf->base.flags);
 238    if (dri2_surf->back->bo == NULL)
 239       return -1;
 240
 241    return 0;
 242 }
 243
 244 static int
 245 get_swrast_front_bo(struct dri2_egl_surface *dri2_surf)
 246 {
 247    struct dri2_egl_display *dri2_dpy =
 248       dri2_egl_display(dri2_surf->base.Resource.Display);
 249    struct gbm_dri_surface *surf = dri2_surf->gbm_surf;
 250
 251    if (dri2_surf->current == NULL) {
 252       assert(!dri2_surf->color_buffers[0].locked);
 253       dri2_surf->current = &dri2_surf->color_buffers[0];
 254    }
 255
 256    if (dri2_surf->current->bo == NULL)
 257       dri2_surf->current->bo = gbm_bo_create(&dri2_dpy->gbm_dri->base.base,
 258                                              surf->base.width, surf->base.height,
 259                                              surf->base.format, surf->base.flags);
 260    if (dri2_surf->current->bo == NULL)
 261       return -1;
 262
 263    return 0;
 264 }
 265
 266 static void
 267 back_bo_to_dri_buffer(struct dri2_egl_surface *dri2_surf, __DRIbuffer *buffer)
 268 {
 269    struct dri2_egl_display *dri2_dpy =
 270       dri2_egl_display(dri2_surf->base.Resource.Display);
 271    struct gbm_dri_bo *bo;
 272    int name, pitch;
 273
 274    bo = (struct gbm_dri_bo *) dri2_surf->back->bo;
 275
 276    dri2_dpy->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_NAME, &name);
 277    dri2_dpy->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, &pitch);
 278
 279    buffer->attachment = __DRI_BUFFER_BACK_LEFT;
 280    buffer->name = name;
 281    buffer->pitch = pitch;
 282    buffer->cpp = 4;
 283    buffer->flags = 0;
 284 }
 285
 286 static int
 287 get_aux_bo(struct dri2_egl_surface *dri2_surf,
 288            unsigned int attachment, unsigned int format, __DRIbuffer *buffer)
 289 {
 290    struct dri2_egl_display *dri2_dpy =
 291       dri2_egl_display(dri2_surf->base.Resource.Display);
 292    __DRIbuffer *b = dri2_surf->dri_buffers[attachment];
 293
 294    if (b == NULL) {
 295       b = dri2_dpy->dri2->allocateBuffer(dri2_dpy->dri_screen,
 296                                          attachment, format,
 297                                          dri2_surf->base.Width,
 298                                          dri2_surf->base.Height);
 299       dri2_surf->dri_buffers[attachment] = b;
 300    }
 301    if (b == NULL)
 302       return -1;
 303
 304    memcpy(buffer, b, sizeof *buffer);
 305
 306    return 0;
 307 }
 308
 309 static __DRIbuffer *
 310 dri2_drm_get_buffers_with_format(__DRIdrawable *driDrawable,
 311                              int *width, int *height,
 312                              unsigned int *attachments, int count,
 313                              int *out_count, void *loaderPrivate)
 314 {
 315    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 316    int i, j;
 317
 318    dri2_surf->buffer_count = 0;
 319    for (i = 0, j = 0; i < 2 * count; i += 2, j++) {
 320       assert(attachments[i] < __DRI_BUFFER_COUNT);
 321       assert(dri2_surf->buffer_count < 5);
 322
 323       switch (attachments[i]) {
 324       case __DRI_BUFFER_BACK_LEFT:
 325          if (get_back_bo(dri2_surf) < 0) {
 326             _eglError(EGL_BAD_ALLOC, "failed to allocate color buffer");
 327             return NULL;
 328          }
 329          back_bo_to_dri_buffer(dri2_surf, &dri2_surf->buffers[j]);
 330          break;
 331       default:
 332          if (get_aux_bo(dri2_surf, attachments[i], attachments[i + 1],
 333                         &dri2_surf->buffers[j]) < 0) {
 334             _eglError(EGL_BAD_ALLOC, "failed to allocate aux buffer");
 335             return NULL;
 336          }
 337          break;
 338       }
 339    }
 340
 341    *out_count = j;
 342    if (j == 0)
 343       return NULL;
 344
 345    *width = dri2_surf->base.Width;
 346    *height = dri2_surf->base.Height;
 347
 348    return dri2_surf->buffers;
 349 }
 350
 351 static __DRIbuffer *
 352 dri2_drm_get_buffers(__DRIdrawable * driDrawable,
 353                      int *width, int *height,
 354                      unsigned int *attachments, int count,
 355                      int *out_count, void *loaderPrivate)
 356 {
 357    unsigned int *attachments_with_format;
 358    __DRIbuffer *buffer;
 359    const unsigned int format = 32;
 360    int i;
 361
 362    attachments_with_format = calloc(count, 2 * sizeof(unsigned int));
 363    if (!attachments_with_format) {
 364       *out_count = 0;
 365       return NULL;
 366    }
 367
 368    for (i = 0; i < count; ++i) {
 369       attachments_with_format[2*i] = attachments[i];
 370       attachments_with_format[2*i + 1] = format;
 371    }
 372
 373    buffer =
 374       dri2_drm_get_buffers_with_format(driDrawable,
 375                                        width, height,
 376                                        attachments_with_format, count,
 377                                        out_count, loaderPrivate);
 378
 379    free(attachments_with_format);
 380
 381    return buffer;
 382 }
 383
 384 static int
 385 dri2_drm_image_get_buffers(__DRIdrawable *driDrawable,
 386                            unsigned int format,
 387                            uint32_t *stamp,
 388                            void *loaderPrivate,
 389                            uint32_t buffer_mask,
 390                            struct __DRIimageList *buffers)
 391 {
 392    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 393    struct gbm_dri_bo *bo;
 394
 395    if (get_back_bo(dri2_surf) < 0)
 396       return 0;
 397
 398    bo = (struct gbm_dri_bo *) dri2_surf->back->bo;
 399    buffers->image_mask = __DRI_IMAGE_BUFFER_BACK;
 400    buffers->back = bo->image;
 401
 402    return 1;
 403 }
 404
 405 static void
 406 dri2_drm_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
 407 {
 408    (void) driDrawable;
 409    (void) loaderPrivate;
 410 }
 411
 412 static EGLBoolean
 413 dri2_drm_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
 414 {
 415    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 416    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
 417    unsigned i;
 418
 419    if (dri2_dpy->swrast) {
 420       (*dri2_dpy->core->swapBuffers)(dri2_surf->dri_drawable);
 421    } else {
 422       if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
 423          if (dri2_surf->current)
 424             _eglError(EGL_BAD_SURFACE, "dri2_swap_buffers");
 425          for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++)
 426             if (dri2_surf->color_buffers[i].age > 0)
 427                dri2_surf->color_buffers[i].age++;
 428
 429          /* Make sure we have a back buffer in case we're swapping without
 430           * ever rendering. */
 431          if (get_back_bo(dri2_surf) < 0) {
 432             _eglError(EGL_BAD_ALLOC, "dri2_swap_buffers");
 433             return EGL_FALSE;
 434          }
 435
 436          dri2_surf->current = dri2_surf->back;
 437          dri2_surf->current->age = 1;
 438          dri2_surf->back = NULL;
 439       }
 440
 441       dri2_flush_drawable_for_swapbuffers(disp, draw);
 442       (*dri2_dpy->flush->invalidate)(dri2_surf->dri_drawable);
 443    }
 444
 445    return EGL_TRUE;
 446 }
 447
 448 static EGLint
 449 dri2_drm_query_buffer_age(_EGLDriver *drv,
 450                           _EGLDisplay *disp, _EGLSurface *surface)
 451 {
 452    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surface);
 453
 454    if (get_back_bo(dri2_surf) < 0) {
 455       _eglError(EGL_BAD_ALLOC, "dri2_query_buffer_age");
 456       return 0;
 457    }
 458
 459    return dri2_surf->back->age;
 460 }
 461
 462 static _EGLImage *
 463 dri2_drm_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx,
 464                                  EGLClientBuffer buffer, const EGLint *attr_list)
 465 {
 466    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 467    struct gbm_dri_bo *dri_bo = gbm_dri_bo((struct gbm_bo *) buffer);
 468    struct dri2_egl_image *dri2_img;
 469
 470    dri2_img = malloc(sizeof *dri2_img);
 471    if (!dri2_img) {
 472       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr_pixmap");
 473       return NULL;
 474    }
 475
 476    if (!_eglInitImage(&dri2_img->base, disp)) {
 477       free(dri2_img);
 478       return NULL;
 479    }
 480
 481    dri2_img->dri_image = dri2_dpy->image->dupImage(dri_bo->image, dri2_img);
 482    if (dri2_img->dri_image == NULL) {
 483       free(dri2_img);
 484       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr_pixmap");
 485       return NULL;
 486    }
 487
 488    return &dri2_img->base;
 489 }
 490
 491 static _EGLImage *
 492 dri2_drm_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
 493                           _EGLContext *ctx, EGLenum target,
 494                           EGLClientBuffer buffer, const EGLint *attr_list)
 495 {
 496    (void) drv;
 497
 498    switch (target) {
 499    case EGL_NATIVE_PIXMAP_KHR:
 500       return dri2_drm_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
 501    default:
 502       return dri2_create_image_khr(drv, disp, ctx, target, buffer, attr_list);
 503    }
 504 }
 505
 506 static int
 507 dri2_drm_authenticate(_EGLDisplay *disp, uint32_t id)
 508 {
 509    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 510
 511    return drmAuthMagic(dri2_dpy->fd, id);
 512 }
 513
 514 static void
 515 swrast_put_image2(__DRIdrawable *driDrawable,
 516                   int            op,
 517                   int            x,
 518                   int            y,
 519                   int            width,
 520                   int            height,
 521                   int            stride,
 522                   char          *data,
 523                   void          *loaderPrivate)
 524 {
 525    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 526    int internal_stride, i;
 527    struct gbm_dri_bo *bo;
 528
 529    if (op != __DRI_SWRAST_IMAGE_OP_DRAW &&
 530        op != __DRI_SWRAST_IMAGE_OP_SWAP)
 531       return;
 532
 533    if (get_swrast_front_bo(dri2_surf) < 0)
 534       return;
 535
 536    bo = gbm_dri_bo(dri2_surf->current->bo);
 537    if (gbm_dri_bo_map(bo) == NULL)
 538       return;
 539
 540    internal_stride = bo->base.base.stride;
 541
 542    for (i = 0; i < height; i++) {
 543       memcpy(bo->map + (x + i) * internal_stride + y,
 544              data + i * stride, stride);
 545    }
 546
 547    gbm_dri_bo_unmap(bo);
 548 }
 549
 550 static void
 551 swrast_get_image(__DRIdrawable *driDrawable,
 552                  int            x,
 553                  int            y,
 554                  int            width,
 555                  int            height,
 556                  char          *data,
 557                  void          *loaderPrivate)
 558 {
 559    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 560    int internal_stride, stride, i;
 561    struct gbm_dri_bo *bo;
 562
 563    if (get_swrast_front_bo(dri2_surf) < 0)
 564       return;
 565
 566    bo = gbm_dri_bo(dri2_surf->current->bo);
 567    if (gbm_dri_bo_map(bo) == NULL)
 568       return;
 569
 570    internal_stride = bo->base.base.stride;
 571    stride = width * 4;
 572
 573    for (i = 0; i < height; i++) {
 574       memcpy(data + i * stride,
 575              bo->map + (x + i) * internal_stride + y, stride);
 576    }
 577
 578    gbm_dri_bo_unmap(bo);
 579 }
 580
 581 static struct dri2_egl_display_vtbl dri2_drm_display_vtbl = {
 582    .authenticate = dri2_drm_authenticate,
 583    .create_window_surface = dri2_drm_create_window_surface,
 584    .create_pixmap_surface = dri2_drm_create_pixmap_surface,
 585    .create_pbuffer_surface = dri2_fallback_create_pbuffer_surface,
 586    .destroy_surface = dri2_drm_destroy_surface,
 587    .create_image = dri2_drm_create_image_khr,
 588    .swap_interval = dri2_fallback_swap_interval,
 589    .swap_buffers = dri2_drm_swap_buffers,
 590    .swap_buffers_with_damage = dri2_fallback_swap_buffers_with_damage,
 591    .swap_buffers_region = dri2_fallback_swap_buffers_region,
 592    .post_sub_buffer = dri2_fallback_post_sub_buffer,
 593    .copy_buffers = dri2_fallback_copy_buffers,
 594    .query_buffer_age = dri2_drm_query_buffer_age,
 595    .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
 596    .get_sync_values = dri2_fallback_get_sync_values,
 597 };
 598
 599 EGLBoolean
 600 dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp)
 601 {
 602    struct dri2_egl_display *dri2_dpy;
 603    struct gbm_device *gbm;
 604    int fd = -1;
 605    int i;
 606
 607    loader_set_logger(_eglLog);
 608
 609    dri2_dpy = calloc(1, sizeof *dri2_dpy);
 610    if (!dri2_dpy)
 611       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
 612
 613    disp->DriverData = (void *) dri2_dpy;
 614
 615    gbm = disp->PlatformDisplay;
 616    if (gbm == NULL) {
 617       char buf[64];
 618       int n = snprintf(buf, sizeof(buf), DRM_DEV_NAME, DRM_DIR_NAME, 0);
 619       if (n != -1 && n < sizeof(buf))
 620          fd = loader_open_device(buf);
 621       if (fd < 0)
 622          fd = loader_open_device("/dev/dri/card0");
 623       dri2_dpy->own_device = 1;
 624       gbm = gbm_create_device(fd);
 625       if (gbm == NULL)
 626          return EGL_FALSE;
 627    }
 628
 629    if (strcmp(gbm_device_get_backend_name(gbm), "drm") != 0) {
 630       free(dri2_dpy);
 631       return EGL_FALSE;
 632    }
 633
 634    dri2_dpy->gbm_dri = gbm_dri_device(gbm);
 635    if (dri2_dpy->gbm_dri->base.type != GBM_DRM_DRIVER_TYPE_DRI) {
 636       free(dri2_dpy);
 637       return EGL_FALSE;
 638    }
 639
 640    if (fd < 0) {
 641       fd = fcntl(gbm_device_get_fd(gbm), F_DUPFD_CLOEXEC, 3);
 642       if (fd < 0) {
 643          free(dri2_dpy);
 644          return EGL_FALSE;
 645       }
 646    }
 647
 648    dri2_dpy->fd = fd;
 649    dri2_dpy->device_name = loader_get_device_name_for_fd(dri2_dpy->fd);
 650    dri2_dpy->driver_name = strdup(dri2_dpy->gbm_dri->base.driver_name);
 651
 652    dri2_dpy->dri_screen = dri2_dpy->gbm_dri->screen;
 653    dri2_dpy->core = dri2_dpy->gbm_dri->core;
 654    dri2_dpy->dri2 = dri2_dpy->gbm_dri->dri2;
 655    dri2_dpy->image = dri2_dpy->gbm_dri->image;
 656    dri2_dpy->flush = dri2_dpy->gbm_dri->flush;
 657    dri2_dpy->swrast = dri2_dpy->gbm_dri->swrast;
 658    dri2_dpy->driver_configs = dri2_dpy->gbm_dri->driver_configs;
 659
 660    dri2_dpy->gbm_dri->lookup_image = dri2_lookup_egl_image;
 661    dri2_dpy->gbm_dri->lookup_user_data = disp;
 662
 663    dri2_dpy->gbm_dri->get_buffers = dri2_drm_get_buffers;
 664    dri2_dpy->gbm_dri->flush_front_buffer = dri2_drm_flush_front_buffer;
 665    dri2_dpy->gbm_dri->get_buffers_with_format = dri2_drm_get_buffers_with_format;
 666    dri2_dpy->gbm_dri->image_get_buffers = dri2_drm_image_get_buffers;
 667    dri2_dpy->gbm_dri->swrast_put_image2 = swrast_put_image2;
 668    dri2_dpy->gbm_dri->swrast_get_image = swrast_get_image;
 669
 670    dri2_dpy->gbm_dri->base.base.surface_lock_front_buffer = lock_front_buffer;
 671    dri2_dpy->gbm_dri->base.base.surface_release_buffer = release_buffer;
 672    dri2_dpy->gbm_dri->base.base.surface_has_free_buffers = has_free_buffers;
 673
 674    dri2_setup_screen(disp);
 675
 676    for (i = 0; dri2_dpy->driver_configs[i]; i++) {
 677       EGLint format, attr_list[3];
 678       unsigned int red, alpha;
 679
 680       dri2_dpy->core->getConfigAttrib(dri2_dpy->driver_configs[i],
 681                                        __DRI_ATTRIB_RED_MASK, &red);
 682       dri2_dpy->core->getConfigAttrib(dri2_dpy->driver_configs[i],
 683                                        __DRI_ATTRIB_ALPHA_MASK, &alpha);
 684       if (red == 0x3ff00000 && alpha == 0x00000000)
 685          format = GBM_FORMAT_XRGB2101010;
 686       else if (red == 0x3ff00000 && alpha == 0xc0000000)
 687          format = GBM_FORMAT_ARGB2101010;
 688       else if (red == 0x00ff0000 && alpha == 0x00000000)
 689          format = GBM_FORMAT_XRGB8888;
 690       else if (red == 0x00ff0000 && alpha == 0xff000000)
 691          format = GBM_FORMAT_ARGB8888;
 692       else if (red == 0xf800)
 693          format = GBM_FORMAT_RGB565;
 694       else
 695          continue;
 696
 697       attr_list[0] = EGL_NATIVE_VISUAL_ID;
 698       attr_list[1] = format;
 699       attr_list[2] = EGL_NONE;
 700
 701       dri2_add_config(disp, dri2_dpy->driver_configs[i],
 702                       i + 1, EGL_WINDOW_BIT, attr_list, NULL);
 703    }
 704
 705    disp->Extensions.KHR_image_pixmap = EGL_TRUE;
 706    if (dri2_dpy->dri2)
 707       disp->Extensions.EXT_buffer_age = EGL_TRUE;
 708
 709 #ifdef HAVE_WAYLAND_PLATFORM
 710    if (dri2_dpy->image) {
 711        if (dri2_dpy->image->base.version >= 10 &&
 712            dri2_dpy->image->getCapabilities != NULL) {
 713            int capabilities;
 714
 715            capabilities =
 716                dri2_dpy->image->getCapabilities(dri2_dpy->dri_screen);
 717            disp->Extensions.WL_bind_wayland_display =
 718                (capabilities & __DRI_IMAGE_CAP_GLOBAL_NAMES) != 0;
 719        } else
 720            disp->Extensions.WL_bind_wayland_display = EGL_TRUE;
 721    }
 722 #endif
 723
 724    /* Fill vtbl last to prevent accidentally calling virtual function during
 725     * initialization.
 726     */
 727    dri2_dpy->vtbl = &dri2_drm_display_vtbl;
 728
 729    return EGL_TRUE;
 730 }