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 "util/os_file.h"
  40
  41 #include "egl_dri2.h"
  42 #include "loader.h"
  43
  44 static struct gbm_bo *
  45 lock_front_buffer(struct gbm_surface *_surf)
  46 {
  47    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
  48    struct dri2_egl_surface *dri2_surf = surf->dri_private;
  49    struct gbm_dri_device *device = gbm_dri_device(_surf->gbm);
  50    struct gbm_bo *bo;
  51
  52    if (dri2_surf->current == NULL) {
  53       _eglError(EGL_BAD_SURFACE, "no front buffer");
  54       return NULL;
  55    }
  56
  57    bo = dri2_surf->current->bo;
  58
  59    if (device->dri2) {
  60       dri2_surf->current->locked = true;
  61       dri2_surf->current = NULL;
  62    }
  63
  64    return bo;
  65 }
  66
  67 static void
  68 release_buffer(struct gbm_surface *_surf, struct gbm_bo *bo)
  69 {
  70    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
  71    struct dri2_egl_surface *dri2_surf = surf->dri_private;
  72
  73    for (unsigned 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 = false;
  76          break;
  77       }
  78    }
  79 }
  80
  81 static int
  82 has_free_buffers(struct gbm_surface *_surf)
  83 {
  84    struct gbm_dri_surface *surf = gbm_dri_surface(_surf);
  85    struct dri2_egl_surface *dri2_surf = surf->dri_private;
  86
  87    for (unsigned 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 bool
  95 dri2_drm_config_is_compatible(struct dri2_egl_display *dri2_dpy,
  96                               const __DRIconfig *config,
  97                               struct gbm_surface *surface)
  98 {
  99    const struct gbm_dri_visual *visual = NULL;
 100    int shifts[4];
 101    unsigned int sizes[4];
 102    bool is_float;
 103    int i;
 104
 105    /* Check that the EGLConfig being used to render to the surface is
 106     * compatible with the surface format. Since mixing ARGB and XRGB of
 107     * otherwise-compatible formats is relatively common, explicitly allow
 108     * this.
 109     */
 110    dri2_get_shifts_and_sizes(dri2_dpy->core, config, shifts, sizes);
 111
 112    dri2_get_render_type_float(dri2_dpy->core, config, &is_float);
 113
 114    for (i = 0; i < dri2_dpy->gbm_dri->num_visuals; i++) {
 115       visual = &dri2_dpy->gbm_dri->visual_table[i];
 116       if (visual->gbm_format == surface->format)
 117          break;
 118    }
 119
 120    if (i == dri2_dpy->gbm_dri->num_visuals)
 121       return false;
 122
 123    if (shifts[0] != visual->rgba_shifts.red ||
 124        shifts[1] != visual->rgba_shifts.green ||
 125        shifts[2] != visual->rgba_shifts.blue ||
 126        (shifts[3] > -1 && visual->rgba_shifts.alpha > -1 &&
 127         shifts[3] != visual->rgba_shifts.alpha) ||
 128        sizes[0] != visual->rgba_sizes.red ||
 129        sizes[1] != visual->rgba_sizes.green ||
 130        sizes[2] != visual->rgba_sizes.blue ||
 131        (sizes[3] > 0 && visual->rgba_sizes.alpha > 0 &&
 132         sizes[3] != visual->rgba_sizes.alpha) ||
 133        is_float != visual->is_float) {
 134       return false;
 135    }
 136
 137    return true;
 138 }
 139
 140 static _EGLSurface *
 141 dri2_drm_create_window_surface(_EGLDisplay *disp, _EGLConfig *conf,
 142                                void *native_surface, const EGLint *attrib_list)
 143 {
 144    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 145    struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
 146    struct dri2_egl_surface *dri2_surf;
 147    struct gbm_surface *surface = native_surface;
 148    struct gbm_dri_surface *surf;
 149    const __DRIconfig *config;
 150
 151    dri2_surf = calloc(1, sizeof *dri2_surf);
 152    if (!dri2_surf) {
 153       _eglError(EGL_BAD_ALLOC, "dri2_create_surface");
 154       return NULL;
 155    }
 156
 157    if (!dri2_init_surface(&dri2_surf->base, disp, EGL_WINDOW_BIT, conf,
 158                           attrib_list, false, native_surface))
 159       goto cleanup_surf;
 160
 161    config = dri2_get_dri_config(dri2_conf, EGL_WINDOW_BIT,
 162                                 dri2_surf->base.GLColorspace);
 163
 164    if (!config) {
 165       _eglError(EGL_BAD_MATCH, "Unsupported surfacetype/colorspace configuration");
 166       goto cleanup_surf;
 167    }
 168
 169    if (!dri2_drm_config_is_compatible(dri2_dpy, config, surface)) {
 170       _eglError(EGL_BAD_MATCH, "EGL config not compatible with GBM format");
 171       goto cleanup_surf;
 172    }
 173
 174    surf = gbm_dri_surface(surface);
 175    dri2_surf->gbm_surf = surf;
 176    dri2_surf->base.Width =  surf->base.width;
 177    dri2_surf->base.Height = surf->base.height;
 178    surf->dri_private = dri2_surf;
 179
 180    if (!dri2_create_drawable(dri2_dpy, config, dri2_surf, dri2_surf->gbm_surf))
 181       goto cleanup_surf;
 182
 183    return &dri2_surf->base;
 184
 185  cleanup_surf:
 186    free(dri2_surf);
 187
 188    return NULL;
 189 }
 190
 191 static _EGLSurface *
 192 dri2_drm_create_pixmap_surface(_EGLDisplay *disp, _EGLConfig *conf,
 193                                void *native_window, const EGLint *attrib_list)
 194 {
 195    /* From the EGL_MESA_platform_gbm spec, version 5:
 196     *
 197     *  It is not valid to call eglCreatePlatformPixmapSurfaceEXT with a <dpy>
 198     *  that belongs to the GBM platform. Any such call fails and generates
 199     *  EGL_BAD_PARAMETER.
 200     */
 201    _eglError(EGL_BAD_PARAMETER, "cannot create EGL pixmap surfaces on GBM");
 202    return NULL;
 203 }
 204
 205 static EGLBoolean
 206 dri2_drm_destroy_surface(_EGLDisplay *disp, _EGLSurface *surf)
 207 {
 208    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 209    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
 210
 211    dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
 212
 213    for (unsigned i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
 214       if (dri2_surf->color_buffers[i].bo)
 215          gbm_bo_destroy(dri2_surf->color_buffers[i].bo);
 216    }
 217
 218    dri2_egl_surface_free_local_buffers(dri2_surf);
 219
 220    dri2_fini_surface(surf);
 221    free(surf);
 222
 223    return EGL_TRUE;
 224 }
 225
 226 static int
 227 get_back_bo(struct dri2_egl_surface *dri2_surf)
 228 {
 229    struct dri2_egl_display *dri2_dpy =
 230       dri2_egl_display(dri2_surf->base.Resource.Display);
 231    struct gbm_dri_surface *surf = dri2_surf->gbm_surf;
 232    int age = 0;
 233
 234    if (dri2_surf->back == NULL) {
 235       for (unsigned i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
 236          if (!dri2_surf->color_buffers[i].locked &&
 237               dri2_surf->color_buffers[i].age >= age) {
 238             dri2_surf->back = &dri2_surf->color_buffers[i];
 239             age = dri2_surf->color_buffers[i].age;
 240          }
 241       }
 242    }
 243
 244    if (dri2_surf->back == NULL)
 245       return -1;
 246    if (dri2_surf->back->bo == NULL) {
 247       if (surf->base.modifiers)
 248          dri2_surf->back->bo = gbm_bo_create_with_modifiers(&dri2_dpy->gbm_dri->base,
 249                                                             surf->base.width,
 250                                                             surf->base.height,
 251                                                             surf->base.format,
 252                                                             surf->base.modifiers,
 253                                                             surf->base.count);
 254       else
 255          dri2_surf->back->bo = gbm_bo_create(&dri2_dpy->gbm_dri->base,
 256                                              surf->base.width,
 257                                              surf->base.height,
 258                                              surf->base.format,
 259                                              surf->base.flags);
 260
 261    }
 262    if (dri2_surf->back->bo == NULL)
 263       return -1;
 264
 265    return 0;
 266 }
 267
 268 static int
 269 get_swrast_front_bo(struct dri2_egl_surface *dri2_surf)
 270 {
 271    struct dri2_egl_display *dri2_dpy =
 272       dri2_egl_display(dri2_surf->base.Resource.Display);
 273    struct gbm_dri_surface *surf = dri2_surf->gbm_surf;
 274
 275    if (dri2_surf->current == NULL) {
 276       assert(!dri2_surf->color_buffers[0].locked);
 277       dri2_surf->current = &dri2_surf->color_buffers[0];
 278    }
 279
 280    if (dri2_surf->current->bo == NULL)
 281       dri2_surf->current->bo = gbm_bo_create(&dri2_dpy->gbm_dri->base,
 282                                              surf->base.width, surf->base.height,
 283                                              surf->base.format, surf->base.flags);
 284    if (dri2_surf->current->bo == NULL)
 285       return -1;
 286
 287    return 0;
 288 }
 289
 290 static void
 291 back_bo_to_dri_buffer(struct dri2_egl_surface *dri2_surf, __DRIbuffer *buffer)
 292 {
 293    struct dri2_egl_display *dri2_dpy =
 294       dri2_egl_display(dri2_surf->base.Resource.Display);
 295    struct gbm_dri_bo *bo;
 296    int name, pitch;
 297
 298    bo = gbm_dri_bo(dri2_surf->back->bo);
 299
 300    dri2_dpy->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_NAME, &name);
 301    dri2_dpy->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, &pitch);
 302
 303    buffer->attachment = __DRI_BUFFER_BACK_LEFT;
 304    buffer->name = name;
 305    buffer->pitch = pitch;
 306    buffer->cpp = 4;
 307    buffer->flags = 0;
 308 }
 309
 310 static __DRIbuffer *
 311 dri2_drm_get_buffers_with_format(__DRIdrawable *driDrawable,
 312                                  int *width, int *height,
 313                                  unsigned int *attachments, int count,
 314                                  int *out_count, void *loaderPrivate)
 315 {
 316    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 317    int i, j;
 318
 319    for (i = 0, j = 0; i < 2 * count; i += 2, j++) {
 320       __DRIbuffer *local;
 321
 322       assert(attachments[i] < __DRI_BUFFER_COUNT);
 323       assert(j < ARRAY_SIZE(dri2_surf->buffers));
 324
 325       switch (attachments[i]) {
 326       case __DRI_BUFFER_BACK_LEFT:
 327          if (get_back_bo(dri2_surf) < 0) {
 328             _eglError(EGL_BAD_ALLOC, "failed to allocate color buffer");
 329             return NULL;
 330          }
 331          back_bo_to_dri_buffer(dri2_surf, &dri2_surf->buffers[j]);
 332          break;
 333       default:
 334          local = dri2_egl_surface_alloc_local_buffer(dri2_surf, attachments[i],
 335                                                      attachments[i + 1]);
 336
 337          if (!local) {
 338             _eglError(EGL_BAD_ALLOC, "failed to allocate local buffer");
 339             return NULL;
 340          }
 341          dri2_surf->buffers[j] = *local;
 342          break;
 343       }
 344    }
 345
 346    *out_count = j;
 347    if (j == 0)
 348       return NULL;
 349
 350    *width = dri2_surf->base.Width;
 351    *height = dri2_surf->base.Height;
 352
 353    return dri2_surf->buffers;
 354 }
 355
 356 static __DRIbuffer *
 357 dri2_drm_get_buffers(__DRIdrawable * driDrawable,
 358                      int *width, int *height,
 359                      unsigned int *attachments, int count,
 360                      int *out_count, void *loaderPrivate)
 361 {
 362    unsigned int *attachments_with_format;
 363    __DRIbuffer *buffer;
 364    const unsigned int format = 32;
 365
 366    attachments_with_format = calloc(count, 2 * sizeof(unsigned int));
 367    if (!attachments_with_format) {
 368       *out_count = 0;
 369       return NULL;
 370    }
 371
 372    for (int i = 0; i < count; ++i) {
 373       attachments_with_format[2*i] = attachments[i];
 374       attachments_with_format[2*i + 1] = format;
 375    }
 376
 377    buffer =
 378       dri2_drm_get_buffers_with_format(driDrawable,
 379                                        width, height,
 380                                        attachments_with_format, count,
 381                                        out_count, loaderPrivate);
 382
 383    free(attachments_with_format);
 384
 385    return buffer;
 386 }
 387
 388 static int
 389 dri2_drm_image_get_buffers(__DRIdrawable *driDrawable,
 390                            unsigned int format,
 391                            uint32_t *stamp,
 392                            void *loaderPrivate,
 393                            uint32_t buffer_mask,
 394                            struct __DRIimageList *buffers)
 395 {
 396    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 397    struct gbm_dri_bo *bo;
 398
 399    if (get_back_bo(dri2_surf) < 0)
 400       return 0;
 401
 402    bo = gbm_dri_bo(dri2_surf->back->bo);
 403    buffers->image_mask = __DRI_IMAGE_BUFFER_BACK;
 404    buffers->back = bo->image;
 405
 406    return 1;
 407 }
 408
 409 static void
 410 dri2_drm_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
 411 {
 412    (void) driDrawable;
 413    (void) loaderPrivate;
 414 }
 415
 416 static EGLBoolean
 417 dri2_drm_swap_buffers(_EGLDisplay *disp, _EGLSurface *draw)
 418 {
 419    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 420    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
 421
 422    if (!dri2_dpy->flush) {
 423       dri2_dpy->core->swapBuffers(dri2_surf->dri_drawable);
 424       return EGL_TRUE;
 425    }
 426
 427    if (dri2_surf->current)
 428       _eglError(EGL_BAD_SURFACE, "dri2_swap_buffers");
 429    for (unsigned i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++)
 430       if (dri2_surf->color_buffers[i].age > 0)
 431          dri2_surf->color_buffers[i].age++;
 432
 433    /* Make sure we have a back buffer in case we're swapping without
 434     * ever rendering. */
 435    if (get_back_bo(dri2_surf) < 0)
 436       return _eglError(EGL_BAD_ALLOC, "dri2_swap_buffers");
 437
 438    dri2_surf->current = dri2_surf->back;
 439    dri2_surf->current->age = 1;
 440    dri2_surf->back = NULL;
 441
 442    dri2_flush_drawable_for_swapbuffers(disp, draw);
 443    dri2_dpy->flush->invalidate(dri2_surf->dri_drawable);
 444
 445    return EGL_TRUE;
 446 }
 447
 448 static EGLint
 449 dri2_drm_query_buffer_age(const _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 -1;
 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    _eglInitImage(&dri2_img->base, disp);
 477
 478    dri2_img->dri_image = dri2_dpy->image->dupImage(dri_bo->image, dri2_img);
 479    if (dri2_img->dri_image == NULL) {
 480       free(dri2_img);
 481       _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr_pixmap");
 482       return NULL;
 483    }
 484
 485    return &dri2_img->base;
 486 }
 487
 488 static _EGLImage *
 489 dri2_drm_create_image_khr(_EGLDisplay *disp, _EGLContext *ctx, EGLenum target,
 490                           EGLClientBuffer buffer, const EGLint *attr_list)
 491 {
 492    switch (target) {
 493    case EGL_NATIVE_PIXMAP_KHR:
 494       return dri2_drm_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
 495    default:
 496       return dri2_create_image_khr(disp, ctx, target, buffer, attr_list);
 497    }
 498 }
 499
 500 static int
 501 dri2_drm_authenticate(_EGLDisplay *disp, uint32_t id)
 502 {
 503    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 504
 505    return drmAuthMagic(dri2_dpy->fd, id);
 506 }
 507
 508 static void
 509 swrast_put_image2(__DRIdrawable *driDrawable,
 510                   int            op,
 511                   int            x,
 512                   int            y,
 513                   int            width,
 514                   int            height,
 515                   int            stride,
 516                   char          *data,
 517                   void          *loaderPrivate)
 518 {
 519    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 520    int internal_stride;
 521    struct gbm_dri_bo *bo;
 522    uint32_t bpp;
 523    int x_bytes, width_bytes;
 524    char *src, *dst;
 525
 526    if (op != __DRI_SWRAST_IMAGE_OP_DRAW &&
 527        op != __DRI_SWRAST_IMAGE_OP_SWAP)
 528       return;
 529
 530    if (get_swrast_front_bo(dri2_surf) < 0)
 531       return;
 532
 533    bo = gbm_dri_bo(dri2_surf->current->bo);
 534
 535    bpp = gbm_bo_get_bpp(&bo->base);
 536    if (bpp == 0)
 537       return;
 538
 539    x_bytes = x * (bpp >> 3);
 540    width_bytes = width * (bpp >> 3);
 541
 542    if (gbm_dri_bo_map_dumb(bo) == NULL)
 543       return;
 544
 545    internal_stride = bo->base.stride;
 546
 547    dst = bo->map + x_bytes + (y * internal_stride);
 548    src = data;
 549
 550    for (int i = 0; i < height; i++) {
 551       memcpy(dst, src, width_bytes);
 552       dst += internal_stride;
 553       src += stride;
 554    }
 555
 556    gbm_dri_bo_unmap_dumb(bo);
 557 }
 558
 559 static void
 560 swrast_get_image(__DRIdrawable *driDrawable,
 561                  int            x,
 562                  int            y,
 563                  int            width,
 564                  int            height,
 565                  char          *data,
 566                  void          *loaderPrivate)
 567 {
 568    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 569    int internal_stride, stride;
 570    struct gbm_dri_bo *bo;
 571    uint32_t bpp;
 572    int x_bytes, width_bytes;
 573    char *src, *dst;
 574
 575    if (get_swrast_front_bo(dri2_surf) < 0)
 576       return;
 577
 578    bo = gbm_dri_bo(dri2_surf->current->bo);
 579
 580    bpp = gbm_bo_get_bpp(&bo->base);
 581    if (bpp == 0)
 582       return;
 583
 584    x_bytes = x * (bpp >> 3);
 585    width_bytes = width * (bpp >> 3);
 586
 587    internal_stride = bo->base.stride;
 588    stride = width_bytes;
 589
 590    if (gbm_dri_bo_map_dumb(bo) == NULL)
 591       return;
 592
 593    dst = data;
 594    src = bo->map + x_bytes + (y * internal_stride);
 595
 596    for (int i = 0; i < height; i++) {
 597       memcpy(dst, src, width_bytes);
 598       dst += stride;
 599       src += internal_stride;
 600    }
 601
 602    gbm_dri_bo_unmap_dumb(bo);
 603 }
 604
 605 static EGLBoolean
 606 drm_add_configs_for_visuals(_EGLDisplay *disp)
 607 {
 608    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 609    const struct gbm_dri_visual *visuals = dri2_dpy->gbm_dri->visual_table;
 610    int num_visuals = dri2_dpy->gbm_dri->num_visuals;
 611    unsigned int format_count[num_visuals];
 612    unsigned int config_count = 0;
 613
 614    memset(format_count, 0, num_visuals * sizeof(unsigned int));
 615
 616    for (unsigned i = 0; dri2_dpy->driver_configs[i]; i++) {
 617       const __DRIconfig *config = dri2_dpy->driver_configs[i];
 618       int shifts[4];
 619       unsigned int sizes[4];
 620       bool is_float;
 621
 622       dri2_get_shifts_and_sizes(dri2_dpy->core, config, shifts, sizes);
 623
 624       dri2_get_render_type_float(dri2_dpy->core, config, &is_float);
 625
 626       for (unsigned j = 0; j < num_visuals; j++) {
 627          struct dri2_egl_config *dri2_conf;
 628
 629          if (visuals[j].rgba_shifts.red != shifts[0] ||
 630              visuals[j].rgba_shifts.green != shifts[1] ||
 631              visuals[j].rgba_shifts.blue != shifts[2] ||
 632              visuals[j].rgba_shifts.alpha != shifts[3] ||
 633              visuals[j].rgba_sizes.red != sizes[0] ||
 634              visuals[j].rgba_sizes.green != sizes[1] ||
 635              visuals[j].rgba_sizes.blue != sizes[2] ||
 636              visuals[j].rgba_sizes.alpha != sizes[3] ||
 637              visuals[j].is_float != is_float)
 638             continue;
 639
 640          const EGLint attr_list[] = {
 641             EGL_NATIVE_VISUAL_ID, visuals[j].gbm_format,
 642             EGL_NONE,
 643          };
 644
 645          dri2_conf = dri2_add_config(disp, dri2_dpy->driver_configs[i],
 646                config_count + 1, EGL_WINDOW_BIT, attr_list, NULL, NULL);
 647          if (dri2_conf) {
 648             if (dri2_conf->base.ConfigID == config_count + 1)
 649                config_count++;
 650             format_count[j]++;
 651          }
 652       }
 653    }
 654
 655    for (unsigned i = 0; i < ARRAY_SIZE(format_count); i++) {
 656       if (!format_count[i]) {
 657          struct gbm_format_name_desc desc;
 658          _eglLog(_EGL_DEBUG, "No DRI config supports native format %s",
 659                  gbm_format_get_name(visuals[i].gbm_format, &desc));
 660       }
 661    }
 662
 663    return (config_count != 0);
 664 }
 665
 666 static const struct dri2_egl_display_vtbl dri2_drm_display_vtbl = {
 667    .authenticate = dri2_drm_authenticate,
 668    .create_window_surface = dri2_drm_create_window_surface,
 669    .create_pixmap_surface = dri2_drm_create_pixmap_surface,
 670    .destroy_surface = dri2_drm_destroy_surface,
 671    .create_image = dri2_drm_create_image_khr,
 672    .swap_buffers = dri2_drm_swap_buffers,
 673    .query_buffer_age = dri2_drm_query_buffer_age,
 674    .get_dri_drawable = dri2_surface_get_dri_drawable,
 675 };
 676
 677 EGLBoolean
 678 dri2_initialize_drm(_EGLDisplay *disp)
 679 {
 680    _EGLDevice *dev;
 681    struct dri2_egl_display *dri2_dpy;
 682    struct gbm_device *gbm;
 683    const char *err;
 684
 685    dri2_dpy = calloc(1, sizeof *dri2_dpy);
 686    if (!dri2_dpy)
 687       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
 688
 689    dri2_dpy->fd = -1;
 690    disp->DriverData = (void *) dri2_dpy;
 691
 692    gbm = disp->PlatformDisplay;
 693    if (gbm == NULL) {
 694       char buf[64];
 695       int n = snprintf(buf, sizeof(buf), DRM_DEV_NAME, DRM_DIR_NAME, 0);
 696       if (n != -1 && n < sizeof(buf))
 697          dri2_dpy->fd = loader_open_device(buf);
 698       gbm = gbm_create_device(dri2_dpy->fd);
 699       if (gbm == NULL) {
 700          err = "DRI2: failed to create gbm device";
 701          goto cleanup;
 702       }
 703       dri2_dpy->own_device = true;
 704    } else {
 705       dri2_dpy->fd = os_dupfd_cloexec(gbm_device_get_fd(gbm));
 706       if (dri2_dpy->fd < 0) {
 707          err = "DRI2: failed to fcntl() existing gbm device";
 708          goto cleanup;
 709       }
 710    }
 711    dri2_dpy->gbm_dri = gbm_dri_device(gbm);
 712
 713    if (strcmp(gbm_device_get_backend_name(gbm), "drm") != 0) {
 714       err = "DRI2: gbm device using incorrect/incompatible backend";
 715       goto cleanup;
 716    }
 717
 718    dev = _eglAddDevice(dri2_dpy->fd, disp->Options.ForceSoftware);
 719    if (!dev) {
 720       err = "DRI2: failed to find EGLDevice";
 721       goto cleanup;
 722    }
 723
 724    disp->Device = dev;
 725
 726    dri2_dpy->driver_name = strdup(dri2_dpy->gbm_dri->driver_name);
 727    dri2_dpy->is_render_node = drmGetNodeTypeFromFd(dri2_dpy->fd) == DRM_NODE_RENDER;
 728
 729    /* render nodes cannot use Gem names, and thus do not support
 730     * the __DRI_DRI2_LOADER extension */
 731    if (!dri2_dpy->is_render_node) {
 732       if (!dri2_load_driver(disp)) {
 733          err = "DRI2: failed to load driver";
 734          goto cleanup;
 735       }
 736    } else {
 737       if (!dri2_load_driver_dri3(disp)) {
 738          err = "DRI3: failed to load driver";
 739          goto cleanup;
 740       }
 741    }
 742
 743    dri2_dpy->dri_screen = dri2_dpy->gbm_dri->screen;
 744    dri2_dpy->core = dri2_dpy->gbm_dri->core;
 745    dri2_dpy->dri2 = dri2_dpy->gbm_dri->dri2;
 746    dri2_dpy->swrast = dri2_dpy->gbm_dri->swrast;
 747    dri2_dpy->driver_configs = dri2_dpy->gbm_dri->driver_configs;
 748
 749    dri2_dpy->gbm_dri->lookup_image = dri2_lookup_egl_image;
 750    dri2_dpy->gbm_dri->lookup_user_data = disp;
 751
 752    dri2_dpy->gbm_dri->get_buffers = dri2_drm_get_buffers;
 753    dri2_dpy->gbm_dri->flush_front_buffer = dri2_drm_flush_front_buffer;
 754    dri2_dpy->gbm_dri->get_buffers_with_format = dri2_drm_get_buffers_with_format;
 755    dri2_dpy->gbm_dri->image_get_buffers = dri2_drm_image_get_buffers;
 756    dri2_dpy->gbm_dri->swrast_put_image2 = swrast_put_image2;
 757    dri2_dpy->gbm_dri->swrast_get_image = swrast_get_image;
 758
 759    dri2_dpy->gbm_dri->base.surface_lock_front_buffer = lock_front_buffer;
 760    dri2_dpy->gbm_dri->base.surface_release_buffer = release_buffer;
 761    dri2_dpy->gbm_dri->base.surface_has_free_buffers = has_free_buffers;
 762
 763    if (!dri2_setup_extensions(disp)) {
 764       err = "DRI2: failed to find required DRI extensions";
 765       goto cleanup;
 766    }
 767
 768    dri2_setup_screen(disp);
 769
 770    if (!drm_add_configs_for_visuals(disp)) {
 771       err = "DRI2: failed to add configs";
 772       goto cleanup;
 773    }
 774
 775    disp->Extensions.KHR_image_pixmap = EGL_TRUE;
 776    if (dri2_dpy->dri2)
 777       disp->Extensions.EXT_buffer_age = EGL_TRUE;
 778
 779 #ifdef HAVE_WAYLAND_PLATFORM
 780    dri2_dpy->device_name = loader_get_device_name_for_fd(dri2_dpy->fd);
 781 #endif
 782    dri2_set_WL_bind_wayland_display(disp);
 783
 784    /* Fill vtbl last to prevent accidentally calling virtual function during
 785     * initialization.
 786     */
 787    dri2_dpy->vtbl = &dri2_drm_display_vtbl;
 788
 789    return EGL_TRUE;
 790
 791 cleanup:
 792    dri2_display_destroy(disp);
 793    return _eglError(EGL_NOT_INITIALIZED, err);
 794 }
 795
 796 void
 797 dri2_teardown_drm(struct dri2_egl_display *dri2_dpy)
 798 {
 799    if (dri2_dpy->own_device)
 800       gbm_device_destroy(&dri2_dpy->gbm_dri->base);
 801 }