src/egl/drivers/dri2/platform_wayland.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  *    Benjamin Franzke <benjaminfranzke@googlemail.com>
  27  */
  28
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <limits.h>
  32 #include <dlfcn.h>
  33 #include <errno.h>
  34 #include <unistd.h>
  35 #include <fcntl.h>
  36 #include <xf86drm.h>
  37
  38 #include "egl_dri2.h"
  39
  40 #include <wayland-client.h>
  41 #include "wayland-drm-client-protocol.h"
  42
  43 static void
  44 wl_buffer_release(void *data, struct wl_buffer *buffer)
  45 {
  46    struct dri2_egl_surface *dri2_surf = data;
  47    int i;
  48
  49    for (i = 0; i < WL_BUFFER_COUNT; ++i)
  50       if (dri2_surf->wl_drm_buffer[i] == buffer)
  51          break;
  52
  53    assert(i <= WL_BUFFER_COUNT);
  54
  55    /* not found? */
  56    if (i == WL_BUFFER_COUNT)
  57       return;
  58
  59    dri2_surf->wl_buffer_lock[i] = 0;
  60
  61 }
  62
  63 static struct wl_buffer_listener wl_buffer_listener = {
  64    wl_buffer_release
  65 };
  66
  67 /**
  68  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
  69  */
  70 static _EGLSurface *
  71 dri2_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
  72                     _EGLConfig *conf, EGLNativeWindowType window,
  73                     const EGLint *attrib_list)
  74 {
  75    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
  76    struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
  77    struct dri2_egl_surface *dri2_surf;
  78    struct dri2_egl_buffer *dri2_buf;
  79    int i;
  80
  81    (void) drv;
  82
  83    dri2_surf = malloc(sizeof *dri2_surf);
  84    if (!dri2_surf) {
  85       _eglError(EGL_BAD_ALLOC, "dri2_create_surface");
  86       return NULL;
  87    }
  88
  89    if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list))
  90       goto cleanup_surf;
  91
  92    for (i = 0; i < WL_BUFFER_COUNT; ++i) {
  93       dri2_surf->wl_drm_buffer[i] = NULL;
  94       dri2_surf->wl_buffer_lock[i] = 0;
  95    }
  96
  97    for (i = 0; i < __DRI_BUFFER_COUNT; ++i)
  98       dri2_surf->dri_buffers[i] = NULL;
  99
 100    dri2_surf->pending_buffer = NULL;
 101    dri2_surf->third_buffer = NULL;
 102    dri2_surf->block_swap_buffers = EGL_FALSE;
 103
 104    switch (type) {
 105    case EGL_WINDOW_BIT:
 106       dri2_surf->wl_win = (struct wl_egl_window *) window;
 107
 108       dri2_surf->base.Width =  -1;
 109       dri2_surf->base.Height = -1;
 110       break;
 111    case EGL_PIXMAP_BIT:
 112       dri2_surf->wl_pix = (struct wl_egl_pixmap *) window;
 113
 114       dri2_surf->base.Width  = dri2_surf->wl_pix->width;
 115       dri2_surf->base.Height = dri2_surf->wl_pix->height;
 116
 117       if (dri2_surf->wl_pix->driver_private) {
 118          dri2_buf = dri2_surf->wl_pix->driver_private;
 119          dri2_surf->dri_buffers[__DRI_BUFFER_FRONT_LEFT] = dri2_buf->dri_buffer;
 120       }
 121       break;
 122    default:
 123       goto cleanup_surf;
 124    }
 125
 126    dri2_surf->dri_drawable =
 127       (*dri2_dpy->dri2->createNewDrawable) (dri2_dpy->dri_screen,
 128                                             type == EGL_WINDOW_BIT ?
 129                                             dri2_conf->dri_double_config :
 130                                             dri2_conf->dri_single_config,
 131                                             dri2_surf);
 132    if (dri2_surf->dri_drawable == NULL) {
 133       _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable");
 134       goto cleanup_dri_drawable;
 135    }
 136
 137    return &dri2_surf->base;
 138
 139  cleanup_dri_drawable:
 140    dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
 141  cleanup_surf:
 142    free(dri2_surf);
 143
 144    return NULL;
 145 }
 146
 147 /**
 148  * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
 149  */
 150 static _EGLSurface *
 151 dri2_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
 152                            _EGLConfig *conf, EGLNativeWindowType window,
 153                            const EGLint *attrib_list)
 154 {
 155    return dri2_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
 156                               window, attrib_list);
 157 }
 158
 159 static _EGLSurface *
 160 dri2_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
 161                            _EGLConfig *conf, EGLNativePixmapType pixmap,
 162                            const EGLint *attrib_list)
 163 {
 164    return dri2_create_surface(drv, disp, EGL_PIXMAP_BIT, conf,
 165                               pixmap, attrib_list);
 166 }
 167
 168 /**
 169  * Called via eglDestroySurface(), drv->API.DestroySurface().
 170  */
 171 static EGLBoolean
 172 dri2_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
 173 {
 174    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 175    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
 176    int i;
 177
 178    (void) drv;
 179
 180    if (!_eglPutSurface(surf))
 181       return EGL_TRUE;
 182
 183    (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
 184
 185    for (i = 0; i < WL_BUFFER_COUNT; ++i)
 186       if (dri2_surf->wl_drm_buffer[i])
 187          wl_buffer_destroy(dri2_surf->wl_drm_buffer[i]);
 188
 189    for (i = 0; i < __DRI_BUFFER_COUNT; ++i)
 190       if (dri2_surf->dri_buffers[i] && !(i == __DRI_BUFFER_FRONT_LEFT &&
 191           dri2_surf->base.Type == EGL_PIXMAP_BIT))
 192          dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
 193                                        dri2_surf->dri_buffers[i]);
 194
 195    if (dri2_surf->third_buffer) {
 196       dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
 197                                     dri2_surf->third_buffer);
 198    }
 199
 200    free(surf);
 201
 202    return EGL_TRUE;
 203 }
 204
 205 static void
 206 dri2_wl_egl_pixmap_destroy(struct wl_egl_pixmap *egl_pixmap)
 207 {
 208    struct dri2_egl_buffer *dri2_buf = egl_pixmap->driver_private;
 209
 210    assert(dri2_buf);
 211
 212    dri2_buf->dri2_dpy->dri2->releaseBuffer(dri2_buf->dri2_dpy->dri_screen,
 213                                            dri2_buf->dri_buffer);
 214
 215    free(dri2_buf);
 216
 217    egl_pixmap->driver_private = NULL;
 218    egl_pixmap->destroy = NULL;
 219 }
 220
 221 static struct wl_buffer *
 222 wayland_create_buffer(struct dri2_egl_surface *dri2_surf,
 223                       __DRIbuffer *buffer,
 224                       struct wl_visual *visual)
 225 {
 226    struct dri2_egl_display *dri2_dpy =
 227       dri2_egl_display(dri2_surf->base.Resource.Display);
 228    struct wl_buffer *buf;
 229
 230    buf = wl_drm_create_buffer(dri2_dpy->wl_drm, buffer->name,
 231                               dri2_surf->base.Width, dri2_surf->base.Height,
 232                               buffer->pitch, visual);
 233    wl_buffer_add_listener(buf, &wl_buffer_listener, dri2_surf);
 234
 235    return buf;
 236 }
 237
 238 static void
 239 dri2_process_back_buffer(struct dri2_egl_surface *dri2_surf, unsigned format)
 240 {
 241    struct dri2_egl_display *dri2_dpy =
 242       dri2_egl_display(dri2_surf->base.Resource.Display);
 243
 244    (void) format;
 245
 246    switch (dri2_surf->base.Type) {
 247    case EGL_WINDOW_BIT:
 248       /* allocate a front buffer for our double-buffered window*/
 249       if (dri2_surf->dri_buffers[__DRI_BUFFER_FRONT_LEFT] != NULL)
 250          break;
 251       dri2_surf->dri_buffers[__DRI_BUFFER_FRONT_LEFT] =
 252          dri2_dpy->dri2->allocateBuffer(dri2_dpy->dri_screen,
 253                __DRI_BUFFER_FRONT_LEFT, format,
 254                dri2_surf->base.Width, dri2_surf->base.Height);
 255       break;
 256    default:
 257       break;
 258    }
 259 }
 260
 261 static void
 262 dri2_process_front_buffer(struct dri2_egl_surface *dri2_surf, unsigned format)
 263 {
 264    struct dri2_egl_display *dri2_dpy =
 265       dri2_egl_display(dri2_surf->base.Resource.Display);
 266    struct dri2_egl_buffer *dri2_buf;
 267
 268    switch (dri2_surf->base.Type) {
 269    case EGL_PIXMAP_BIT:
 270       dri2_buf = malloc(sizeof *dri2_buf);
 271       if (!dri2_buf)
 272          return;
 273
 274       dri2_buf->dri_buffer = dri2_surf->dri_buffers[__DRI_BUFFER_FRONT_LEFT];
 275       dri2_buf->dri2_dpy   = dri2_dpy;
 276
 277       dri2_surf->wl_pix->driver_private = dri2_buf;
 278       dri2_surf->wl_pix->destroy        = dri2_wl_egl_pixmap_destroy;
 279       break;
 280    default:
 281       break;
 282    }
 283 }
 284
 285 static void
 286 dri2_release_pending_buffer(void *data,
 287                             struct wl_callback *callback, uint32_t time)
 288 {
 289    struct dri2_egl_surface *dri2_surf = data;
 290    struct dri2_egl_display *dri2_dpy =
 291       dri2_egl_display(dri2_surf->base.Resource.Display);
 292
 293    /* FIXME: print internal error */
 294    if (!dri2_surf->pending_buffer)
 295       return;
 296
 297    dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
 298                                  dri2_surf->pending_buffer);
 299    dri2_surf->pending_buffer = NULL;
 300 }
 301
 302 static const struct wl_callback_listener release_buffer_listener = {
 303    dri2_release_pending_buffer
 304 };
 305
 306 static void
 307 dri2_release_buffers(struct dri2_egl_surface *dri2_surf)
 308 {
 309    struct dri2_egl_display *dri2_dpy =
 310       dri2_egl_display(dri2_surf->base.Resource.Display);
 311    struct wl_callback *callback;
 312    int i;
 313
 314    if (dri2_surf->third_buffer) {
 315       dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
 316                                     dri2_surf->third_buffer);
 317       dri2_surf->third_buffer = NULL;
 318    }
 319
 320    for (i = 0; i < __DRI_BUFFER_COUNT; ++i) {
 321       if (dri2_surf->dri_buffers[i]) {
 322          switch (i) {
 323          case __DRI_BUFFER_FRONT_LEFT:
 324             if (dri2_surf->pending_buffer)
 325               wl_display_roundtrip(dri2_dpy->wl_dpy);
 326             dri2_surf->pending_buffer = dri2_surf->dri_buffers[i];
 327             callback = wl_display_sync(dri2_dpy->wl_dpy);
 328             wl_callback_add_listener(callback,
 329                                      &release_buffer_listener, dri2_surf);
 330             break;
 331          default:
 332             dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
 333                                           dri2_surf->dri_buffers[i]);
 334             break;
 335          }
 336          dri2_surf->dri_buffers[i] = NULL;
 337       }
 338    }
 339 }
 340
 341 static inline void
 342 pointer_swap(const void **p1, const void **p2)
 343 {
 344    const void *tmp = *p1;
 345    *p1 = *p2;
 346    *p2 = tmp;
 347 }
 348
 349 static void
 350 destroy_third_buffer(struct dri2_egl_surface *dri2_surf)
 351 {
 352    struct dri2_egl_display *dri2_dpy =
 353       dri2_egl_display(dri2_surf->base.Resource.Display);
 354
 355    if (dri2_surf->third_buffer == NULL)
 356       return;
 357
 358    dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
 359                                  dri2_surf->third_buffer);
 360    dri2_surf->third_buffer = NULL;
 361
 362    if (dri2_surf->wl_drm_buffer[WL_BUFFER_THIRD])
 363       wl_buffer_destroy(dri2_surf->wl_drm_buffer[WL_BUFFER_THIRD]);
 364    dri2_surf->wl_drm_buffer[WL_BUFFER_THIRD] = NULL;
 365    dri2_surf->wl_buffer_lock[WL_BUFFER_THIRD] = 0;
 366 }
 367
 368 static void
 369 swap_wl_buffers(struct dri2_egl_surface *dri2_surf,
 370                 enum wayland_buffer_type a, enum wayland_buffer_type b)
 371 {
 372    int tmp;
 373
 374    tmp = dri2_surf->wl_buffer_lock[a];
 375    dri2_surf->wl_buffer_lock[a] = dri2_surf->wl_buffer_lock[b];
 376    dri2_surf->wl_buffer_lock[b] = tmp;
 377
 378    pointer_swap((const void **) &dri2_surf->wl_drm_buffer[a],
 379                 (const void **) &dri2_surf->wl_drm_buffer[b]);
 380 }
 381
 382 static void
 383 swap_back_and_third(struct dri2_egl_surface *dri2_surf)
 384 {
 385    if (dri2_surf->wl_buffer_lock[WL_BUFFER_THIRD])
 386       destroy_third_buffer(dri2_surf);
 387
 388    pointer_swap((const void **) &dri2_surf->dri_buffers[__DRI_BUFFER_BACK_LEFT],
 389                 (const void **) &dri2_surf->third_buffer);
 390
 391    swap_wl_buffers(dri2_surf, WL_BUFFER_BACK, WL_BUFFER_THIRD);
 392 }
 393
 394 static void
 395 dri2_prior_buffer_creation(struct dri2_egl_surface *dri2_surf,
 396                            unsigned int type)
 397 {
 398    switch (type) {
 399    case __DRI_BUFFER_BACK_LEFT:
 400          if (dri2_surf->wl_buffer_lock[WL_BUFFER_BACK])
 401             swap_back_and_third(dri2_surf);
 402          else if (dri2_surf->third_buffer)
 403             destroy_third_buffer(dri2_surf);
 404          break;
 405    default:
 406          break;
 407
 408    }
 409 }
 410
 411 static __DRIbuffer *
 412 dri2_get_buffers_with_format(__DRIdrawable * driDrawable,
 413                              int *width, int *height,
 414                              unsigned int *attachments, int count,
 415                              int *out_count, void *loaderPrivate)
 416 {
 417    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 418    struct dri2_egl_display *dri2_dpy =
 419       dri2_egl_display(dri2_surf->base.Resource.Display);
 420    int i;
 421
 422    if (dri2_surf->base.Type == EGL_WINDOW_BIT &&
 423        (dri2_surf->base.Width != dri2_surf->wl_win->width ||
 424         dri2_surf->base.Height != dri2_surf->wl_win->height)) {
 425
 426       dri2_release_buffers(dri2_surf);
 427
 428       dri2_surf->base.Width  = dri2_surf->wl_win->width;
 429       dri2_surf->base.Height = dri2_surf->wl_win->height;
 430       dri2_surf->dx = dri2_surf->wl_win->dx;
 431       dri2_surf->dy = dri2_surf->wl_win->dy;
 432
 433       for (i = 0; i < WL_BUFFER_COUNT; ++i) {
 434          if (dri2_surf->wl_drm_buffer[i])
 435             wl_buffer_destroy(dri2_surf->wl_drm_buffer[i]);
 436          dri2_surf->wl_drm_buffer[i]  = NULL;
 437          dri2_surf->wl_buffer_lock[i] = 0;
 438       }
 439    }
 440
 441    dri2_surf->buffer_count = 0;
 442    for (i = 0; i < 2*count; i+=2) {
 443       assert(attachments[i] < __DRI_BUFFER_COUNT);
 444       assert(dri2_surf->buffer_count < 5);
 445
 446       dri2_prior_buffer_creation(dri2_surf, attachments[i]);
 447
 448       if (dri2_surf->dri_buffers[attachments[i]] == NULL) {
 449
 450          dri2_surf->dri_buffers[attachments[i]] =
 451             dri2_dpy->dri2->allocateBuffer(dri2_dpy->dri_screen,
 452                   attachments[i], attachments[i+1],
 453                   dri2_surf->base.Width, dri2_surf->base.Height);
 454
 455          if (!dri2_surf->dri_buffers[attachments[i]])
 456             continue;
 457
 458          if (attachments[i] == __DRI_BUFFER_FRONT_LEFT)
 459             dri2_process_front_buffer(dri2_surf, attachments[i+1]);
 460          else if (attachments[i] == __DRI_BUFFER_BACK_LEFT)
 461             dri2_process_back_buffer(dri2_surf, attachments[i+1]);
 462       }
 463
 464       memcpy(&dri2_surf->buffers[dri2_surf->buffer_count],
 465              dri2_surf->dri_buffers[attachments[i]],
 466              sizeof(__DRIbuffer));
 467
 468       dri2_surf->buffer_count++;
 469    }
 470
 471    assert(dri2_surf->base.Type == EGL_PIXMAP_BIT ||
 472           dri2_surf->dri_buffers[__DRI_BUFFER_BACK_LEFT]);
 473
 474    if (dri2_surf->base.Type == EGL_PIXMAP_BIT && !dri2_surf->wl_pix->buffer)
 475       dri2_surf->wl_pix->buffer =
 476          wayland_create_buffer(dri2_surf,
 477                                dri2_surf->dri_buffers[__DRI_BUFFER_FRONT_LEFT],
 478                                dri2_surf->wl_pix->visual);
 479
 480    *out_count = dri2_surf->buffer_count;
 481    if (dri2_surf->buffer_count == 0)
 482            return NULL;
 483
 484    *width = dri2_surf->base.Width;
 485    *height = dri2_surf->base.Height;
 486
 487    return dri2_surf->buffers;
 488 }
 489
 490 static __DRIbuffer *
 491 dri2_get_buffers(__DRIdrawable * driDrawable,
 492                  int *width, int *height,
 493                  unsigned int *attachments, int count,
 494                  int *out_count, void *loaderPrivate)
 495 {
 496    unsigned int *attachments_with_format;
 497    __DRIbuffer *buffer;
 498    const unsigned int format = 32;
 499    int i;
 500
 501    attachments_with_format = calloc(count * 2, sizeof(unsigned int));
 502    if (!attachments_with_format) {
 503       *out_count = 0;
 504       return NULL;
 505    }
 506
 507    for (i = 0; i < count; ++i) {
 508       attachments_with_format[2*i] = attachments[i];
 509       attachments_with_format[2*i + 1] = format;
 510    }
 511
 512    buffer =
 513       dri2_get_buffers_with_format(driDrawable,
 514                                    width, height,
 515                                    attachments_with_format, count,
 516                                    out_count, loaderPrivate);
 517
 518    free(attachments_with_format);
 519
 520    return buffer;
 521 }
 522
 523
 524 static void
 525 dri2_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
 526 {
 527    (void) driDrawable;
 528
 529    /* FIXME: Does EGL support front buffer rendering at all? */
 530
 531 #if 0
 532    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 533
 534    dri2WaitGL(dri2_surf);
 535 #else
 536    (void) loaderPrivate;
 537 #endif
 538 }
 539
 540 static void
 541 wayland_frame_callback(void *data, struct wl_callback *callback, uint32_t time)
 542 {
 543    struct dri2_egl_surface *dri2_surf = data;
 544
 545    dri2_surf->block_swap_buffers = EGL_FALSE;
 546    wl_callback_destroy(callback);
 547 }
 548
 549 static const struct wl_callback_listener frame_listener = {
 550         wayland_frame_callback
 551 };
 552
 553 /**
 554  * Called via eglSwapBuffers(), drv->API.SwapBuffers().
 555  */
 556 static EGLBoolean
 557 dri2_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
 558 {
 559    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 560    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
 561    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
 562    struct wl_callback *callback;
 563
 564    while (dri2_surf->block_swap_buffers)
 565       wl_display_iterate(dri2_dpy->wl_dpy, WL_DISPLAY_READABLE);
 566
 567    dri2_surf->block_swap_buffers = EGL_TRUE;
 568    callback = wl_surface_frame(dri2_surf->wl_win->surface);
 569    wl_callback_add_listener(callback, &frame_listener, dri2_surf);
 570
 571    if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
 572       pointer_swap(
 573             (const void **) &dri2_surf->dri_buffers[__DRI_BUFFER_FRONT_LEFT],
 574             (const void **) &dri2_surf->dri_buffers[__DRI_BUFFER_BACK_LEFT]);
 575
 576       dri2_surf->dri_buffers[__DRI_BUFFER_FRONT_LEFT]->attachment =
 577          __DRI_BUFFER_FRONT_LEFT;
 578       dri2_surf->dri_buffers[__DRI_BUFFER_BACK_LEFT]->attachment =
 579          __DRI_BUFFER_BACK_LEFT;
 580
 581       swap_wl_buffers(dri2_surf, WL_BUFFER_FRONT, WL_BUFFER_BACK);
 582
 583       if (!dri2_surf->wl_drm_buffer[WL_BUFFER_FRONT])
 584          dri2_surf->wl_drm_buffer[WL_BUFFER_FRONT] =
 585             wayland_create_buffer(dri2_surf,
 586                   dri2_surf->dri_buffers[__DRI_BUFFER_FRONT_LEFT],
 587                   dri2_surf->wl_win->visual);
 588
 589       wl_buffer_damage(dri2_surf->wl_drm_buffer[WL_BUFFER_FRONT], 0, 0,
 590                        dri2_surf->base.Width, dri2_surf->base.Height);
 591       wl_surface_attach(dri2_surf->wl_win->surface,
 592             dri2_surf->wl_drm_buffer[WL_BUFFER_FRONT],
 593             dri2_surf->dx, dri2_surf->dy);
 594       dri2_surf->wl_buffer_lock[WL_BUFFER_FRONT] = 1;
 595
 596       dri2_surf->wl_win->attached_width  = dri2_surf->base.Width;
 597       dri2_surf->wl_win->attached_height = dri2_surf->base.Height;
 598       /* reset resize growing parameters */
 599       dri2_surf->dx = 0;
 600       dri2_surf->dy = 0;
 601
 602       wl_surface_damage(dri2_surf->wl_win->surface, 0, 0,
 603             dri2_surf->base.Width, dri2_surf->base.Height);
 604    }
 605
 606    _EGLContext *ctx;
 607    if (dri2_drv->glFlush) {
 608       ctx = _eglGetCurrentContext();
 609       if (ctx && ctx->DrawSurface == &dri2_surf->base)
 610          dri2_drv->glFlush();
 611    }
 612
 613    (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
 614    (*dri2_dpy->flush->invalidate)(dri2_surf->dri_drawable);
 615
 616    return EGL_TRUE;
 617 }
 618
 619 /**
 620  * Called via eglCreateImageKHR(), drv->API.CreateImageKHR().
 621  */
 622 static _EGLImage *
 623 dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx,
 624                              EGLClientBuffer buffer, const EGLint *attr_list)
 625 {
 626    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 627    struct wl_egl_pixmap *wl_egl_pixmap = (struct wl_egl_pixmap *) buffer;
 628    struct dri2_egl_buffer *dri2_buf;
 629    EGLint wl_attr_list[] = {
 630                 EGL_WIDTH,              0,
 631                 EGL_HEIGHT,             0,
 632                 EGL_DRM_BUFFER_STRIDE_MESA,     0,
 633                 EGL_DRM_BUFFER_FORMAT_MESA,     EGL_DRM_BUFFER_FORMAT_ARGB32_MESA,
 634                 EGL_NONE
 635    };
 636
 637    dri2_buf = malloc(sizeof *dri2_buf);
 638    if (!dri2_buf)
 639            return NULL;
 640
 641    dri2_buf->dri2_dpy = dri2_dpy;
 642    dri2_buf->dri_buffer =
 643       dri2_dpy->dri2->allocateBuffer(dri2_dpy->dri_screen,
 644                                      __DRI_BUFFER_FRONT_LEFT, 32,
 645                                      wl_egl_pixmap->width,
 646                                      wl_egl_pixmap->height);
 647
 648    wl_egl_pixmap->destroy = dri2_wl_egl_pixmap_destroy;
 649    wl_egl_pixmap->driver_private = dri2_buf;
 650
 651    wl_egl_pixmap->buffer =
 652       wl_drm_create_buffer(dri2_dpy->wl_drm,
 653                            dri2_buf->dri_buffer->name,
 654                            wl_egl_pixmap->width,
 655                            wl_egl_pixmap->height,
 656                            dri2_buf->dri_buffer->pitch,
 657                            wl_egl_pixmap->visual);
 658
 659    wl_attr_list[1] = wl_egl_pixmap->width;
 660    wl_attr_list[3] = wl_egl_pixmap->height;
 661    wl_attr_list[5] = dri2_buf->dri_buffer->pitch / 4;
 662
 663    return dri2_create_image_khr(disp->Driver, disp, ctx, EGL_DRM_BUFFER_MESA,
 664         (EGLClientBuffer)(intptr_t) dri2_buf->dri_buffer->name, wl_attr_list);
 665 }
 666
 667 static _EGLImage *
 668 dri2_wayland_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
 669                               _EGLContext *ctx, EGLenum target,
 670                               EGLClientBuffer buffer, const EGLint *attr_list)
 671 {
 672    (void) drv;
 673
 674    switch (target) {
 675    case EGL_NATIVE_PIXMAP_KHR:
 676       return dri2_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
 677    default:
 678       return dri2_create_image_khr(drv, disp, ctx, target, buffer, attr_list);
 679    }
 680 }
 681
 682 static int
 683 dri2_wayland_authenticate(_EGLDisplay *disp, uint32_t id)
 684 {
 685    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 686    int ret = 0;
 687
 688    dri2_dpy->authenticated = 0;
 689
 690    wl_drm_authenticate(dri2_dpy->wl_drm, id);
 691    wl_display_roundtrip(dri2_dpy->wl_dpy);
 692
 693    if (!dri2_dpy->authenticated)
 694       ret = -1;
 695
 696    /* reset authenticated */
 697    dri2_dpy->authenticated = 1;
 698
 699    return ret;
 700 }
 701
 702 /**
 703  * Called via eglTerminate(), drv->API.Terminate().
 704  */
 705 static EGLBoolean
 706 dri2_terminate(_EGLDriver *drv, _EGLDisplay *disp)
 707 {
 708    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 709
 710    _eglReleaseDisplayResources(drv, disp);
 711    _eglCleanupDisplay(disp);
 712
 713    dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
 714    close(dri2_dpy->fd);
 715    dlclose(dri2_dpy->driver);
 716    free(dri2_dpy->driver_name);
 717    free(dri2_dpy);
 718    disp->DriverData = NULL;
 719
 720    return EGL_TRUE;
 721 }
 722
 723 static void
 724 drm_handle_device(void *data, struct wl_drm *drm, const char *device)
 725 {
 726    struct dri2_egl_display *dri2_dpy = data;
 727    drm_magic_t magic;
 728
 729    dri2_dpy->device_name = strdup(device);
 730    if (!dri2_dpy->device_name)
 731       return;
 732
 733    dri2_dpy->fd = open(dri2_dpy->device_name, O_RDWR);
 734    if (dri2_dpy->fd == -1) {
 735       _eglLog(_EGL_WARNING, "wayland-egl: could not open %s (%s)",
 736               dri2_dpy->device_name, strerror(errno));
 737       return;
 738    }
 739
 740    drmGetMagic(dri2_dpy->fd, &magic);
 741    wl_drm_authenticate(dri2_dpy->wl_drm, magic);
 742 }
 743
 744 static void
 745 drm_handle_authenticated(void *data, struct wl_drm *drm)
 746 {
 747    struct dri2_egl_display *dri2_dpy = data;
 748
 749    dri2_dpy->authenticated = 1;
 750 }
 751
 752 static const struct wl_drm_listener drm_listener = {
 753         drm_handle_device,
 754         drm_handle_authenticated
 755 };
 756
 757 EGLBoolean
 758 dri2_initialize_wayland(_EGLDriver *drv, _EGLDisplay *disp)
 759 {
 760    struct dri2_egl_display *dri2_dpy;
 761    uint32_t id;
 762    int i;
 763
 764    drv->API.CreateWindowSurface = dri2_create_window_surface;
 765    drv->API.CreatePixmapSurface = dri2_create_pixmap_surface;
 766    drv->API.DestroySurface = dri2_destroy_surface;
 767    drv->API.SwapBuffers = dri2_swap_buffers;
 768    drv->API.CreateImageKHR = dri2_wayland_create_image_khr;
 769    drv->API.Terminate = dri2_terminate;
 770
 771    dri2_dpy = malloc(sizeof *dri2_dpy);
 772    if (!dri2_dpy)
 773       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
 774
 775    memset(dri2_dpy, 0, sizeof *dri2_dpy);
 776
 777    disp->DriverData = (void *) dri2_dpy;
 778    if (disp->PlatformDisplay == NULL) {
 779       dri2_dpy->wl_dpy = wl_display_connect(NULL);
 780       if (dri2_dpy->wl_dpy == NULL)
 781          goto cleanup_dpy;
 782    } else {
 783       dri2_dpy->wl_dpy = disp->PlatformDisplay;
 784    }
 785
 786    id = wl_display_get_global(dri2_dpy->wl_dpy, "wl_drm", 1);
 787    if (id == 0)
 788       wl_display_roundtrip(dri2_dpy->wl_dpy);
 789    id = wl_display_get_global(dri2_dpy->wl_dpy, "wl_drm", 1);
 790    if (id == 0)
 791       goto cleanup_dpy;
 792    dri2_dpy->wl_drm = wl_drm_create(dri2_dpy->wl_dpy, id, 1);
 793    if (!dri2_dpy->wl_drm)
 794       goto cleanup_dpy;
 795    wl_drm_add_listener(dri2_dpy->wl_drm, &drm_listener, dri2_dpy);
 796    wl_display_roundtrip(dri2_dpy->wl_dpy);
 797    if (dri2_dpy->fd == -1)
 798       goto cleanup_drm;
 799
 800    wl_display_roundtrip(dri2_dpy->wl_dpy);
 801    if (!dri2_dpy->authenticated)
 802       goto cleanup_fd;
 803
 804    dri2_dpy->driver_name = dri2_get_driver_for_fd(dri2_dpy->fd);
 805    if (dri2_dpy->driver_name == NULL) {
 806       _eglError(EGL_BAD_ALLOC, "DRI2: failed to get driver name");
 807       goto cleanup_fd;
 808    }
 809
 810    if (!dri2_load_driver(disp))
 811       goto cleanup_driver_name;
 812
 813    dri2_dpy->dri2_loader_extension.base.name = __DRI_DRI2_LOADER;
 814    dri2_dpy->dri2_loader_extension.base.version = 3;
 815    dri2_dpy->dri2_loader_extension.getBuffers = dri2_get_buffers;
 816    dri2_dpy->dri2_loader_extension.flushFrontBuffer = dri2_flush_front_buffer;
 817    dri2_dpy->dri2_loader_extension.getBuffersWithFormat =
 818       dri2_get_buffers_with_format;
 819
 820    dri2_dpy->extensions[0] = &dri2_dpy->dri2_loader_extension.base;
 821    dri2_dpy->extensions[1] = &image_lookup_extension.base;
 822    dri2_dpy->extensions[2] = &use_invalidate.base;
 823    dri2_dpy->extensions[3] = NULL;
 824
 825    if (!dri2_create_screen(disp))
 826       goto cleanup_driver;
 827
 828    for (i = 0; dri2_dpy->driver_configs[i]; i++)
 829       dri2_add_config(disp, dri2_dpy->driver_configs[i], i + 1, 0,
 830                       EGL_WINDOW_BIT | EGL_PIXMAP_BIT, NULL, NULL);
 831
 832
 833    disp->Extensions.KHR_image_pixmap = EGL_TRUE;
 834
 835    disp->Extensions.WL_bind_wayland_display = EGL_TRUE;
 836    dri2_dpy->authenticate = dri2_wayland_authenticate;
 837
 838    /* we're supporting EGL 1.4 */
 839    disp->VersionMajor = 1;
 840    disp->VersionMinor = 4;
 841
 842    return EGL_TRUE;
 843
 844  cleanup_driver:
 845    dlclose(dri2_dpy->driver);
 846  cleanup_driver_name:
 847    free(dri2_dpy->driver_name);
 848  cleanup_fd:
 849    close(dri2_dpy->fd);
 850  cleanup_drm:
 851    free(dri2_dpy->device_name);
 852    wl_drm_destroy(dri2_dpy->wl_drm);
 853  cleanup_dpy:
 854    free(dri2_dpy);
 855
 856    return EGL_FALSE;
 857 }