projects / mesa.git / blob
? search:


a635c758da122c8079005f57e24600232a7385bd
[mesa.git] / src / egl / drivers / dri2 / platform_wayland.c
1 /*
2 * Copyright © 2011-2012 Intel Corporation
3 * Copyright © 2012 Collabora, Ltd.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 * DEALINGS IN THE SOFTWARE.
24 *
25 * Authors:
26 * Kristian Høgsberg <krh@bitplanet.net>
27 * Benjamin Franzke <benjaminfranzke@googlemail.com>
28 */
29
30 #include <stdint.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <limits.h>
34 #include <dlfcn.h>
35 #include <errno.h>
36 #include <unistd.h>
37 #include <fcntl.h>
38 #include <xf86drm.h>
39 #include <sys/mman.h>
40
41 #include "egl_dri2.h"
42 #include "egl_dri2_fallbacks.h"
43 #include "loader.h"
44
45 #include <wayland-client.h>
46 #include "wayland-drm-client-protocol.h"
47
48 enum wl_drm_format_flags {
49 HAS_ARGB8888 = 1,
50 HAS_XRGB8888 = 2,
51 HAS_RGB565 = 4,
52 };
53
54 static EGLBoolean
55 dri2_wl_swap_interval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
56 EGLint interval);
57
58 static void
59 sync_callback(void *data, struct wl_callback *callback, uint32_t serial)
60 {
61 int *done = data;
62
63 *done = 1;
64 wl_callback_destroy(callback);
65 }
66
67 static const struct wl_callback_listener sync_listener = {
68 .done = sync_callback
69 };
70
71 static int
72 roundtrip(struct dri2_egl_display *dri2_dpy)
73 {
74 struct wl_callback *callback;
75 int done = 0, ret = 0;
76
77 callback = wl_display_sync(dri2_dpy->wl_dpy);
78 wl_callback_add_listener(callback, &sync_listener, &done);
79 wl_proxy_set_queue((struct wl_proxy *) callback, dri2_dpy->wl_queue);
80 while (ret != -1 && !done)
81 ret = wl_display_dispatch_queue(dri2_dpy->wl_dpy, dri2_dpy->wl_queue);
82
83 if (!done)
84 wl_callback_destroy(callback);
85
86 return ret;
87 }
88
89 static void
90 wl_buffer_release(void *data, struct wl_buffer *buffer)
91 {
92 struct dri2_egl_surface *dri2_surf = data;
93 int i;
94
95 for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); ++i)
96 if (dri2_surf->color_buffers[i].wl_buffer == buffer)
97 break;
98
99 if (i == ARRAY_SIZE(dri2_surf->color_buffers)) {
100 wl_buffer_destroy(buffer);
101 return;
102 }
103
104 dri2_surf->color_buffers[i].locked = 0;
105 }
106
107 static const struct wl_buffer_listener wl_buffer_listener = {
108 .release = wl_buffer_release
109 };
110
111 static void
112 resize_callback(struct wl_egl_window *wl_win, void *data)
113 {
114 struct dri2_egl_surface *dri2_surf = data;
115 struct dri2_egl_display *dri2_dpy =
116 dri2_egl_display(dri2_surf->base.Resource.Display);
117
118 (*dri2_dpy->flush->invalidate)(dri2_surf->dri_drawable);
119 }
120
121 /**
122 * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
123 */
124 static _EGLSurface *
125 dri2_wl_create_surface(_EGLDriver *drv, _EGLDisplay *disp,
126 _EGLConfig *conf, void *native_window,
127 const EGLint *attrib_list)
128 {
129 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
130 struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
131 struct wl_egl_window *window = native_window;
132 struct dri2_egl_surface *dri2_surf;
133 const __DRIconfig *config;
134
135 (void) drv;
136
137 dri2_surf = calloc(1, sizeof *dri2_surf);
138 if (!dri2_surf) {
139 _eglError(EGL_BAD_ALLOC, "dri2_create_surface");
140 return NULL;
141 }
142
143 if (!_eglInitSurface(&dri2_surf->base, disp, EGL_WINDOW_BIT, conf, attrib_list))
144 goto cleanup_surf;
145
146 if (conf->RedSize == 5)
147 dri2_surf->format = WL_DRM_FORMAT_RGB565;
148 else if (conf->AlphaSize == 0)
149 dri2_surf->format = WL_DRM_FORMAT_XRGB8888;
150 else
151 dri2_surf->format = WL_DRM_FORMAT_ARGB8888;
152
153 if (!window) {
154 _eglError(EGL_BAD_NATIVE_WINDOW, "dri2_create_surface");
155 goto cleanup_surf;
156 }
157
158 dri2_surf->wl_win = window;
159
160 dri2_surf->wl_win->private = dri2_surf;
161 dri2_surf->wl_win->resize_callback = resize_callback;
162
163 dri2_surf->base.Width = -1;
164 dri2_surf->base.Height = -1;
165
166 config = dri2_get_dri_config(dri2_conf, EGL_WINDOW_BIT,
167 dri2_surf->base.GLColorspace);
168
169 dri2_surf->dri_drawable =
170 (*dri2_dpy->dri2->createNewDrawable)(dri2_dpy->dri_screen, config,
171 dri2_surf);
172 if (dri2_surf->dri_drawable == NULL) {
173 _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable");
174 goto cleanup_surf;
175 }
176
177 return &dri2_surf->base;
178
179 cleanup_surf:
180 free(dri2_surf);
181
182 return NULL;
183 }
184
185 /**
186 * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
187 */
188 static _EGLSurface *
189 dri2_wl_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
190 _EGLConfig *conf, void *native_window,
191 const EGLint *attrib_list)
192 {
193 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
194 _EGLSurface *surf;
195
196 surf = dri2_wl_create_surface(drv, disp, conf, native_window, attrib_list);
197
198 if (surf != NULL)
199 dri2_wl_swap_interval(drv, disp, surf, dri2_dpy->default_swap_interval);
200
201 return surf;
202 }
203
204 static _EGLSurface *
205 dri2_wl_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
206 _EGLConfig *conf, void *native_window,
207 const EGLint *attrib_list)
208 {
209 /* From the EGL_EXT_platform_wayland spec, version 3:
210 *
211 * It is not valid to call eglCreatePlatformPixmapSurfaceEXT with a <dpy>
212 * that belongs to Wayland. Any such call fails and generates
213 * EGL_BAD_PARAMETER.
214 */
215 _eglError(EGL_BAD_PARAMETER, "cannot create EGL pixmap surfaces on "
216 "Wayland");
217 return NULL;
218 }
219
220 /**
221 * Called via eglDestroySurface(), drv->API.DestroySurface().
222 */
223 static EGLBoolean
224 dri2_wl_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
225 {
226 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
227 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
228 int i;
229
230 (void) drv;
231
232 if (!_eglPutSurface(surf))
233 return EGL_TRUE;
234
235 (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
236
237 for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
238 if (dri2_surf->color_buffers[i].wl_buffer)
239 wl_buffer_destroy(dri2_surf->color_buffers[i].wl_buffer);
240 if (dri2_surf->color_buffers[i].dri_image)
241 dri2_dpy->image->destroyImage(dri2_surf->color_buffers[i].dri_image);
242 if (dri2_surf->color_buffers[i].linear_copy)
243 dri2_dpy->image->destroyImage(dri2_surf->color_buffers[i].linear_copy);
244 if (dri2_surf->color_buffers[i].data)
245 munmap(dri2_surf->color_buffers[i].data,
246 dri2_surf->color_buffers[i].data_size);
247 }
248
249 if (dri2_dpy->dri2) {
250 for (i = 0; i < __DRI_BUFFER_COUNT; i++)
251 if (dri2_surf->dri_buffers[i] &&
252 dri2_surf->dri_buffers[i]->attachment != __DRI_BUFFER_BACK_LEFT)
253 dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
254 dri2_surf->dri_buffers[i]);
255 }
256
257 if (dri2_surf->throttle_callback)
258 wl_callback_destroy(dri2_surf->throttle_callback);
259
260 dri2_surf->wl_win->private = NULL;
261 dri2_surf->wl_win->resize_callback = NULL;
262
263 free(surf);
264
265 return EGL_TRUE;
266 }
267
268 static void
269 dri2_wl_release_buffers(struct dri2_egl_surface *dri2_surf)
270 {
271 struct dri2_egl_display *dri2_dpy =
272 dri2_egl_display(dri2_surf->base.Resource.Display);
273 int i;
274
275 for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
276 if (dri2_surf->color_buffers[i].wl_buffer &&
277 !dri2_surf->color_buffers[i].locked)
278 wl_buffer_destroy(dri2_surf->color_buffers[i].wl_buffer);
279 if (dri2_surf->color_buffers[i].dri_image)
280 dri2_dpy->image->destroyImage(dri2_surf->color_buffers[i].dri_image);
281 if (dri2_surf->color_buffers[i].linear_copy)
282 dri2_dpy->image->destroyImage(dri2_surf->color_buffers[i].linear_copy);
283 if (dri2_surf->color_buffers[i].data)
284 munmap(dri2_surf->color_buffers[i].data,
285 dri2_surf->color_buffers[i].data_size);
286
287 dri2_surf->color_buffers[i].wl_buffer = NULL;
288 dri2_surf->color_buffers[i].dri_image = NULL;
289 dri2_surf->color_buffers[i].linear_copy = NULL;
290 dri2_surf->color_buffers[i].data = NULL;
291 dri2_surf->color_buffers[i].locked = 0;
292 }
293
294 if (dri2_dpy->dri2) {
295 for (i = 0; i < __DRI_BUFFER_COUNT; i++)
296 if (dri2_surf->dri_buffers[i] &&
297 dri2_surf->dri_buffers[i]->attachment != __DRI_BUFFER_BACK_LEFT)
298 dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
299 dri2_surf->dri_buffers[i]);
300 }
301 }
302
303 static int
304 get_back_bo(struct dri2_egl_surface *dri2_surf)
305 {
306 struct dri2_egl_display *dri2_dpy =
307 dri2_egl_display(dri2_surf->base.Resource.Display);
308 int i;
309 unsigned int dri_image_format;
310
311 /* currently supports three WL DRM formats,
312 * WL_DRM_FORMAT_ARGB8888, WL_DRM_FORMAT_XRGB8888,
313 * and WL_DRM_FORMAT_RGB565
314 */
315 switch (dri2_surf->format) {
316 case WL_DRM_FORMAT_ARGB8888:
317 dri_image_format = __DRI_IMAGE_FORMAT_ARGB8888;
318 break;
319 case WL_DRM_FORMAT_XRGB8888:
320 dri_image_format = __DRI_IMAGE_FORMAT_XRGB8888;
321 break;
322 case WL_DRM_FORMAT_RGB565:
323 dri_image_format = __DRI_IMAGE_FORMAT_RGB565;
324 break;
325 default:
326 /* format is not supported */
327 return -1;
328 }
329
330 /* We always want to throttle to some event (either a frame callback or
331 * a sync request) after the commit so that we can be sure the
332 * compositor has had a chance to handle it and send us a release event
333 * before we look for a free buffer */
334 while (dri2_surf->throttle_callback != NULL)
335 if (wl_display_dispatch_queue(dri2_dpy->wl_dpy,
336 dri2_dpy->wl_queue) == -1)
337 return -1;
338
339 if (dri2_surf->back == NULL) {
340 for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
341 /* Get an unlocked buffer, preferrably one with a dri_buffer
342 * already allocated. */
343 if (dri2_surf->color_buffers[i].locked)
344 continue;
345 if (dri2_surf->back == NULL)
346 dri2_surf->back = &dri2_surf->color_buffers[i];
347 else if (dri2_surf->back->dri_image == NULL)
348 dri2_surf->back = &dri2_surf->color_buffers[i];
349 }
350 }
351
352 if (dri2_surf->back == NULL)
353 return -1;
354
355 if (dri2_dpy->is_different_gpu &&
356 dri2_surf->back->linear_copy == NULL) {
357 dri2_surf->back->linear_copy =
358 dri2_dpy->image->createImage(dri2_dpy->dri_screen,
359 dri2_surf->base.Width,
360 dri2_surf->base.Height,
361 dri_image_format,
362 __DRI_IMAGE_USE_SHARE |
363 __DRI_IMAGE_USE_LINEAR,
364 NULL);
365 if (dri2_surf->back->linear_copy == NULL)
366 return -1;
367 }
368
369 if (dri2_surf->back->dri_image == NULL) {
370 dri2_surf->back->dri_image =
371 dri2_dpy->image->createImage(dri2_dpy->dri_screen,
372 dri2_surf->base.Width,
373 dri2_surf->base.Height,
374 dri_image_format,
375 dri2_dpy->is_different_gpu ?
376 0 : __DRI_IMAGE_USE_SHARE,
377 NULL);
378 dri2_surf->back->age = 0;
379 }
380 if (dri2_surf->back->dri_image == NULL)
381 return -1;
382
383 dri2_surf->back->locked = 1;
384
385 return 0;
386 }
387
388
389 static void
390 back_bo_to_dri_buffer(struct dri2_egl_surface *dri2_surf, __DRIbuffer *buffer)
391 {
392 struct dri2_egl_display *dri2_dpy =
393 dri2_egl_display(dri2_surf->base.Resource.Display);
394 __DRIimage *image;
395 int name, pitch;
396
397 image = dri2_surf->back->dri_image;
398
399 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_NAME, &name);
400 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_STRIDE, &pitch);
401
402 buffer->attachment = __DRI_BUFFER_BACK_LEFT;
403 buffer->name = name;
404 buffer->pitch = pitch;
405 buffer->cpp = 4;
406 buffer->flags = 0;
407 }
408
409 static int
410 get_aux_bo(struct dri2_egl_surface *dri2_surf,
411 unsigned int attachment, unsigned int format, __DRIbuffer *buffer)
412 {
413 struct dri2_egl_display *dri2_dpy =
414 dri2_egl_display(dri2_surf->base.Resource.Display);
415 __DRIbuffer *b = dri2_surf->dri_buffers[attachment];
416
417 if (b == NULL) {
418 b = dri2_dpy->dri2->allocateBuffer(dri2_dpy->dri_screen,
419 attachment, format,
420 dri2_surf->base.Width,
421 dri2_surf->base.Height);
422 dri2_surf->dri_buffers[attachment] = b;
423 }
424 if (b == NULL)
425 return -1;
426
427 memcpy(buffer, b, sizeof *buffer);
428
429 return 0;
430 }
431
432 static int
433 update_buffers(struct dri2_egl_surface *dri2_surf)
434 {
435 struct dri2_egl_display *dri2_dpy =
436 dri2_egl_display(dri2_surf->base.Resource.Display);
437 int i;
438
439 if (dri2_surf->base.Width != dri2_surf->wl_win->width ||
440 dri2_surf->base.Height != dri2_surf->wl_win->height) {
441
442 dri2_wl_release_buffers(dri2_surf);
443
444 dri2_surf->base.Width = dri2_surf->wl_win->width;
445 dri2_surf->base.Height = dri2_surf->wl_win->height;
446 dri2_surf->dx = dri2_surf->wl_win->dx;
447 dri2_surf->dy = dri2_surf->wl_win->dy;
448 }
449
450 if (get_back_bo(dri2_surf) < 0) {
451 _eglError(EGL_BAD_ALLOC, "failed to allocate color buffer");
452 return -1;
453 }
454
455 /* If we have an extra unlocked buffer at this point, we had to do triple
456 * buffering for a while, but now can go back to just double buffering.
457 * That means we can free any unlocked buffer now. */
458 for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
459 if (!dri2_surf->color_buffers[i].locked &&
460 dri2_surf->color_buffers[i].wl_buffer) {
461 wl_buffer_destroy(dri2_surf->color_buffers[i].wl_buffer);
462 dri2_dpy->image->destroyImage(dri2_surf->color_buffers[i].dri_image);
463 if (dri2_dpy->is_different_gpu)
464 dri2_dpy->image->destroyImage(dri2_surf->color_buffers[i].linear_copy);
465 dri2_surf->color_buffers[i].wl_buffer = NULL;
466 dri2_surf->color_buffers[i].dri_image = NULL;
467 dri2_surf->color_buffers[i].linear_copy = NULL;
468 }
469 }
470
471 return 0;
472 }
473
474 static __DRIbuffer *
475 dri2_wl_get_buffers_with_format(__DRIdrawable * driDrawable,
476 int *width, int *height,
477 unsigned int *attachments, int count,
478 int *out_count, void *loaderPrivate)
479 {
480 struct dri2_egl_surface *dri2_surf = loaderPrivate;
481 int i, j;
482
483 if (update_buffers(dri2_surf) < 0)
484 return NULL;
485
486 for (i = 0, j = 0; i < 2 * count; i += 2, j++) {
487 switch (attachments[i]) {
488 case __DRI_BUFFER_BACK_LEFT:
489 back_bo_to_dri_buffer(dri2_surf, &dri2_surf->buffers[j]);
490 break;
491 default:
492 if (get_aux_bo(dri2_surf, attachments[i], attachments[i + 1],
493 &dri2_surf->buffers[j]) < 0) {
494 _eglError(EGL_BAD_ALLOC, "failed to allocate aux buffer");
495 return NULL;
496 }
497 break;
498 }
499 }
500
501 *out_count = j;
502 if (j == 0)
503 return NULL;
504
505 *width = dri2_surf->base.Width;
506 *height = dri2_surf->base.Height;
507
508 return dri2_surf->buffers;
509 }
510
511 static __DRIbuffer *
512 dri2_wl_get_buffers(__DRIdrawable * driDrawable,
513 int *width, int *height,
514 unsigned int *attachments, int count,
515 int *out_count, void *loaderPrivate)
516 {
517 struct dri2_egl_surface *dri2_surf = loaderPrivate;
518 unsigned int *attachments_with_format;
519 __DRIbuffer *buffer;
520 unsigned int bpp;
521
522 int i;
523
524 switch (dri2_surf->format) {
525 case WL_DRM_FORMAT_ARGB8888:
526 case WL_DRM_FORMAT_XRGB8888:
527 bpp = 32;
528 break;
529 case WL_DRM_FORMAT_RGB565:
530 bpp = 16;
531 break;
532 default:
533 /* format is not supported */
534 return NULL;
535 }
536
537 attachments_with_format = calloc(count, 2 * sizeof(unsigned int));
538 if (!attachments_with_format) {
539 *out_count = 0;
540 return NULL;
541 }
542
543 for (i = 0; i < count; ++i) {
544 attachments_with_format[2*i] = attachments[i];
545 attachments_with_format[2*i + 1] = bpp;
546 }
547
548 buffer =
549 dri2_wl_get_buffers_with_format(driDrawable,
550 width, height,
551 attachments_with_format, count,
552 out_count, loaderPrivate);
553
554 free(attachments_with_format);
555
556 return buffer;
557 }
558
559 static int
560 image_get_buffers(__DRIdrawable *driDrawable,
561 unsigned int format,
562 uint32_t *stamp,
563 void *loaderPrivate,
564 uint32_t buffer_mask,
565 struct __DRIimageList *buffers)
566 {
567 struct dri2_egl_surface *dri2_surf = loaderPrivate;
568
569 if (update_buffers(dri2_surf) < 0)
570 return 0;
571
572 buffers->image_mask = __DRI_IMAGE_BUFFER_BACK;
573 buffers->back = dri2_surf->back->dri_image;
574
575 return 1;
576 }
577
578 static void
579 dri2_wl_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
580 {
581 (void) driDrawable;
582 (void) loaderPrivate;
583 }
584
585 static const __DRIimageLoaderExtension image_loader_extension = {
586 .base = { __DRI_IMAGE_LOADER, 1 },
587
588 .getBuffers = image_get_buffers,
589 .flushFrontBuffer = dri2_wl_flush_front_buffer,
590 };
591
592 static void
593 wayland_throttle_callback(void *data,
594 struct wl_callback *callback,
595 uint32_t time)
596 {
597 struct dri2_egl_surface *dri2_surf = data;
598
599 dri2_surf->throttle_callback = NULL;
600 wl_callback_destroy(callback);
601 }
602
603 static const struct wl_callback_listener throttle_listener = {
604 .done = wayland_throttle_callback
605 };
606
607 static void
608 create_wl_buffer(struct dri2_egl_surface *dri2_surf)
609 {
610 struct dri2_egl_display *dri2_dpy =
611 dri2_egl_display(dri2_surf->base.Resource.Display);
612 __DRIimage *image;
613 int fd, stride, name;
614
615 if (dri2_surf->current->wl_buffer != NULL)
616 return;
617
618 if (dri2_dpy->is_different_gpu) {
619 image = dri2_surf->current->linear_copy;
620 } else {
621 image = dri2_surf->current->dri_image;
622 }
623 if (dri2_dpy->capabilities & WL_DRM_CAPABILITY_PRIME) {
624 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_FD, &fd);
625 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_STRIDE, &stride);
626
627 dri2_surf->current->wl_buffer =
628 wl_drm_create_prime_buffer(dri2_dpy->wl_drm,
629 fd,
630 dri2_surf->base.Width,
631 dri2_surf->base.Height,
632 dri2_surf->format,
633 0, stride,
634 0, 0,
635 0, 0);
636 close(fd);
637 } else {
638 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_NAME, &name);
639 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_STRIDE, &stride);
640
641 dri2_surf->current->wl_buffer =
642 wl_drm_create_buffer(dri2_dpy->wl_drm,
643 name,
644 dri2_surf->base.Width,
645 dri2_surf->base.Height,
646 stride,
647 dri2_surf->format);
648 }
649
650 wl_proxy_set_queue((struct wl_proxy *) dri2_surf->current->wl_buffer,
651 dri2_dpy->wl_queue);
652 wl_buffer_add_listener(dri2_surf->current->wl_buffer,
653 &wl_buffer_listener, dri2_surf);
654 }
655
656 /**
657 * Called via eglSwapBuffers(), drv->API.SwapBuffers().
658 */
659 static EGLBoolean
660 dri2_wl_swap_buffers_with_damage(_EGLDriver *drv,
661 _EGLDisplay *disp,
662 _EGLSurface *draw,
663 const EGLint *rects,
664 EGLint n_rects)
665 {
666 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
667 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
668 int i;
669
670 for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++)
671 if (dri2_surf->color_buffers[i].age > 0)
672 dri2_surf->color_buffers[i].age++;
673
674 /* Make sure we have a back buffer in case we're swapping without ever
675 * rendering. */
676 if (get_back_bo(dri2_surf) < 0) {
677 _eglError(EGL_BAD_ALLOC, "dri2_swap_buffers");
678 return EGL_FALSE;
679 }
680
681 if (draw->SwapInterval > 0) {
682 dri2_surf->throttle_callback =
683 wl_surface_frame(dri2_surf->wl_win->surface);
684 wl_callback_add_listener(dri2_surf->throttle_callback,
685 &throttle_listener, dri2_surf);
686 wl_proxy_set_queue((struct wl_proxy *) dri2_surf->throttle_callback,
687 dri2_dpy->wl_queue);
688 }
689
690 dri2_surf->back->age = 1;
691 dri2_surf->current = dri2_surf->back;
692 dri2_surf->back = NULL;
693
694 create_wl_buffer(dri2_surf);
695
696 wl_surface_attach(dri2_surf->wl_win->surface,
697 dri2_surf->current->wl_buffer,
698 dri2_surf->dx, dri2_surf->dy);
699
700 dri2_surf->wl_win->attached_width = dri2_surf->base.Width;
701 dri2_surf->wl_win->attached_height = dri2_surf->base.Height;
702 /* reset resize growing parameters */
703 dri2_surf->dx = 0;
704 dri2_surf->dy = 0;
705
706 /* We deliberately ignore the damage region and post maximum damage, due to
707 * https://bugs.freedesktop.org/78190 */
708 wl_surface_damage(dri2_surf->wl_win->surface,
709 0, 0, INT32_MAX, INT32_MAX);
710
711 if (dri2_dpy->is_different_gpu) {
712 _EGLContext *ctx = _eglGetCurrentContext();
713 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
714 dri2_dpy->image->blitImage(dri2_ctx->dri_context,
715 dri2_surf->current->linear_copy,
716 dri2_surf->current->dri_image,
717 0, 0, dri2_surf->base.Width,
718 dri2_surf->base.Height,
719 0, 0, dri2_surf->base.Width,
720 dri2_surf->base.Height, 0);
721 }
722
723 dri2_flush_drawable_for_swapbuffers(disp, draw);
724 (*dri2_dpy->flush->invalidate)(dri2_surf->dri_drawable);
725
726 wl_surface_commit(dri2_surf->wl_win->surface);
727
728 /* If we're not waiting for a frame callback then we'll at least throttle
729 * to a sync callback so that we always give a chance for the compositor to
730 * handle the commit and send a release event before checking for a free
731 * buffer */
732 if (dri2_surf->throttle_callback == NULL) {
733 dri2_surf->throttle_callback = wl_display_sync(dri2_dpy->wl_dpy);
734 wl_callback_add_listener(dri2_surf->throttle_callback,
735 &throttle_listener, dri2_surf);
736 wl_proxy_set_queue((struct wl_proxy *) dri2_surf->throttle_callback,
737 dri2_dpy->wl_queue);
738 }
739
740 wl_display_flush(dri2_dpy->wl_dpy);
741
742 return EGL_TRUE;
743 }
744
745 static EGLint
746 dri2_wl_query_buffer_age(_EGLDriver *drv,
747 _EGLDisplay *disp, _EGLSurface *surface)
748 {
749 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surface);
750
751 if (get_back_bo(dri2_surf) < 0) {
752 _eglError(EGL_BAD_ALLOC, "dri2_query_buffer_age");
753 return 0;
754 }
755
756 return dri2_surf->back->age;
757 }
758
759 static EGLBoolean
760 dri2_wl_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
761 {
762 return dri2_wl_swap_buffers_with_damage (drv, disp, draw, NULL, 0);
763 }
764
765 static struct wl_buffer *
766 dri2_wl_create_wayland_buffer_from_image(_EGLDriver *drv,
767 _EGLDisplay *disp,
768 _EGLImage *img)
769 {
770 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
771 struct dri2_egl_image *dri2_img = dri2_egl_image(img);
772 __DRIimage *image = dri2_img->dri_image;
773 struct wl_buffer *buffer;
774 int width, height, format, pitch;
775 enum wl_drm_format wl_format;
776
777 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_FORMAT, &format);
778
779 switch (format) {
780 case __DRI_IMAGE_FORMAT_ARGB8888:
781 if (!(dri2_dpy->formats & HAS_ARGB8888))
782 goto bad_format;
783 wl_format = WL_DRM_FORMAT_ARGB8888;
784 break;
785 case __DRI_IMAGE_FORMAT_XRGB8888:
786 if (!(dri2_dpy->formats & HAS_XRGB8888))
787 goto bad_format;
788 wl_format = WL_DRM_FORMAT_XRGB8888;
789 break;
790 default:
791 goto bad_format;
792 }
793
794 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_WIDTH, &width);
795 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_HEIGHT, &height);
796 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_STRIDE, &pitch);
797
798 if (dri2_dpy->capabilities & WL_DRM_CAPABILITY_PRIME) {
799 int fd;
800
801 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_FD, &fd);
802
803 buffer =
804 wl_drm_create_prime_buffer(dri2_dpy->wl_drm,
805 fd,
806 width, height,
807 wl_format,
808 0, pitch,
809 0, 0,
810 0, 0);
811
812 close(fd);
813 } else {
814 int name;
815
816 dri2_dpy->image->queryImage(image, __DRI_IMAGE_ATTRIB_NAME, &name);
817
818 buffer =
819 wl_drm_create_buffer(dri2_dpy->wl_drm,
820 name,
821 width, height,
822 pitch,
823 wl_format);
824 }
825
826 /* The buffer object will have been created with our internal event queue
827 * because it is using the wl_drm object as a proxy factory. We want the
828 * buffer to be used by the application so we'll reset it to the display's
829 * default event queue */
830 if (buffer)
831 wl_proxy_set_queue((struct wl_proxy *) buffer, NULL);
832
833 return buffer;
834
835 bad_format:
836 _eglError(EGL_BAD_MATCH, "unsupported image format");
837 return NULL;
838 }
839
840 static int
841 dri2_wl_authenticate(_EGLDisplay *disp, uint32_t id)
842 {
843 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
844 int ret = 0;
845
846 if (dri2_dpy->is_render_node) {
847 _eglLog(_EGL_WARNING, "wayland-egl: client asks server to "
848 "authenticate for render-nodes");
849 return 0;
850 }
851 dri2_dpy->authenticated = 0;
852
853 wl_drm_authenticate(dri2_dpy->wl_drm, id);
854 if (roundtrip(dri2_dpy) < 0)
855 ret = -1;
856
857 if (!dri2_dpy->authenticated)
858 ret = -1;
859
860 /* reset authenticated */
861 dri2_dpy->authenticated = 1;
862
863 return ret;
864 }
865
866 static void
867 drm_handle_device(void *data, struct wl_drm *drm, const char *device)
868 {
869 struct dri2_egl_display *dri2_dpy = data;
870 drm_magic_t magic;
871
872 dri2_dpy->device_name = strdup(device);
873 if (!dri2_dpy->device_name)
874 return;
875
876 dri2_dpy->fd = loader_open_device(dri2_dpy->device_name);
877 if (dri2_dpy->fd == -1) {
878 _eglLog(_EGL_WARNING, "wayland-egl: could not open %s (%s)",
879 dri2_dpy->device_name, strerror(errno));
880 return;
881 }
882
883 if (drmGetNodeTypeFromFd(dri2_dpy->fd) == DRM_NODE_RENDER) {
884 dri2_dpy->authenticated = 1;
885 } else {
886 drmGetMagic(dri2_dpy->fd, &magic);
887 wl_drm_authenticate(dri2_dpy->wl_drm, magic);
888 }
889 }
890
891 static void
892 drm_handle_format(void *data, struct wl_drm *drm, uint32_t format)
893 {
894 struct dri2_egl_display *dri2_dpy = data;
895
896 switch (format) {
897 case WL_DRM_FORMAT_ARGB8888:
898 dri2_dpy->formats |= HAS_ARGB8888;
899 break;
900 case WL_DRM_FORMAT_XRGB8888:
901 dri2_dpy->formats |= HAS_XRGB8888;
902 break;
903 case WL_DRM_FORMAT_RGB565:
904 dri2_dpy->formats |= HAS_RGB565;
905 break;
906 }
907 }
908
909 static void
910 drm_handle_capabilities(void *data, struct wl_drm *drm, uint32_t value)
911 {
912 struct dri2_egl_display *dri2_dpy = data;
913
914 dri2_dpy->capabilities = value;
915 }
916
917 static void
918 drm_handle_authenticated(void *data, struct wl_drm *drm)
919 {
920 struct dri2_egl_display *dri2_dpy = data;
921
922 dri2_dpy->authenticated = 1;
923 }
924
925 static const struct wl_drm_listener drm_listener = {
926 .device = drm_handle_device,
927 .format = drm_handle_format,
928 .authenticated = drm_handle_authenticated,
929 .capabilities = drm_handle_capabilities
930 };
931
932 static void
933 registry_handle_global_drm(void *data, struct wl_registry *registry, uint32_t name,
934 const char *interface, uint32_t version)
935 {
936 struct dri2_egl_display *dri2_dpy = data;
937
938 if (version > 1)
939 version = 2;
940 if (strcmp(interface, "wl_drm") == 0) {
941 dri2_dpy->wl_drm =
942 wl_registry_bind(registry, name, &wl_drm_interface, version);
943 wl_drm_add_listener(dri2_dpy->wl_drm, &drm_listener, dri2_dpy);
944 }
945 }
946
947 static void
948 registry_handle_global_remove(void *data, struct wl_registry *registry,
949 uint32_t name)
950 {
951 }
952
953 static const struct wl_registry_listener registry_listener_drm = {
954 .global = registry_handle_global_drm,
955 .global_remove = registry_handle_global_remove
956 };
957
958 static EGLBoolean
959 dri2_wl_swap_interval(_EGLDriver *drv,
960 _EGLDisplay *disp,
961 _EGLSurface *surf,
962 EGLint interval)
963 {
964 if (interval > surf->Config->MaxSwapInterval)
965 interval = surf->Config->MaxSwapInterval;
966 else if (interval < surf->Config->MinSwapInterval)
967 interval = surf->Config->MinSwapInterval;
968
969 surf->SwapInterval = interval;
970
971 return EGL_TRUE;
972 }
973
974 static void
975 dri2_wl_setup_swap_interval(struct dri2_egl_display *dri2_dpy)
976 {
977 GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
978
979 /* We can't use values greater than 1 on Wayland because we are using the
980 * frame callback to synchronise the frame and the only way we be sure to
981 * get a frame callback is to attach a new buffer. Therefore we can't just
982 * sit drawing nothing to wait until the next ‘n’ frame callbacks */
983
984 if (dri2_dpy->config)
985 dri2_dpy->config->configQueryi(dri2_dpy->dri_screen,
986 "vblank_mode", &vblank_mode);
987 switch (vblank_mode) {
988 case DRI_CONF_VBLANK_NEVER:
989 dri2_dpy->min_swap_interval = 0;
990 dri2_dpy->max_swap_interval = 0;
991 dri2_dpy->default_swap_interval = 0;
992 break;
993 case DRI_CONF_VBLANK_ALWAYS_SYNC:
994 dri2_dpy->min_swap_interval = 1;
995 dri2_dpy->max_swap_interval = 1;
996 dri2_dpy->default_swap_interval = 1;
997 break;
998 case DRI_CONF_VBLANK_DEF_INTERVAL_0:
999 dri2_dpy->min_swap_interval = 0;
1000 dri2_dpy->max_swap_interval = 1;
1001 dri2_dpy->default_swap_interval = 0;
1002 break;
1003 default:
1004 case DRI_CONF_VBLANK_DEF_INTERVAL_1:
1005 dri2_dpy->min_swap_interval = 0;
1006 dri2_dpy->max_swap_interval = 1;
1007 dri2_dpy->default_swap_interval = 1;
1008 break;
1009 }
1010 }
1011
1012 static struct dri2_egl_display_vtbl dri2_wl_display_vtbl = {
1013 .authenticate = dri2_wl_authenticate,
1014 .create_window_surface = dri2_wl_create_window_surface,
1015 .create_pixmap_surface = dri2_wl_create_pixmap_surface,
1016 .create_pbuffer_surface = dri2_fallback_create_pbuffer_surface,
1017 .destroy_surface = dri2_wl_destroy_surface,
1018 .create_image = dri2_create_image_khr,
1019 .swap_interval = dri2_wl_swap_interval,
1020 .swap_buffers = dri2_wl_swap_buffers,
1021 .swap_buffers_with_damage = dri2_wl_swap_buffers_with_damage,
1022 .swap_buffers_region = dri2_fallback_swap_buffers_region,
1023 .post_sub_buffer = dri2_fallback_post_sub_buffer,
1024 .copy_buffers = dri2_fallback_copy_buffers,
1025 .query_buffer_age = dri2_wl_query_buffer_age,
1026 .create_wayland_buffer_from_image = dri2_wl_create_wayland_buffer_from_image,
1027 .get_sync_values = dri2_fallback_get_sync_values,
1028 };
1029
1030 static EGLBoolean
1031 dri2_initialize_wayland_drm(_EGLDriver *drv, _EGLDisplay *disp)
1032 {
1033 struct dri2_egl_display *dri2_dpy;
1034 const __DRIconfig *config;
1035 uint32_t types;
1036 int i;
1037 static const unsigned int argb_masks[4] =
1038 { 0xff0000, 0xff00, 0xff, 0xff000000 };
1039 static const unsigned int rgb_masks[4] = { 0xff0000, 0xff00, 0xff, 0 };
1040 static const unsigned int rgb565_masks[4] = { 0xf800, 0x07e0, 0x001f, 0 };
1041
1042 loader_set_logger(_eglLog);
1043
1044 dri2_dpy = calloc(1, sizeof *dri2_dpy);
1045 if (!dri2_dpy)
1046 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1047
1048 disp->DriverData = (void *) dri2_dpy;
1049 if (disp->PlatformDisplay == NULL) {
1050 dri2_dpy->wl_dpy = wl_display_connect(NULL);
1051 if (dri2_dpy->wl_dpy == NULL)
1052 goto cleanup_dpy;
1053 dri2_dpy->own_device = 1;
1054 } else {
1055 dri2_dpy->wl_dpy = disp->PlatformDisplay;
1056 }
1057
1058 dri2_dpy->wl_queue = wl_display_create_queue(dri2_dpy->wl_dpy);
1059
1060 if (dri2_dpy->own_device)
1061 wl_display_dispatch_pending(dri2_dpy->wl_dpy);
1062
1063 dri2_dpy->wl_registry = wl_display_get_registry(dri2_dpy->wl_dpy);
1064 wl_proxy_set_queue((struct wl_proxy *) dri2_dpy->wl_registry,
1065 dri2_dpy->wl_queue);
1066 wl_registry_add_listener(dri2_dpy->wl_registry,
1067 &registry_listener_drm, dri2_dpy);
1068 if (roundtrip(dri2_dpy) < 0 || dri2_dpy->wl_drm == NULL)
1069 goto cleanup_registry;
1070
1071 if (roundtrip(dri2_dpy) < 0 || dri2_dpy->fd == -1)
1072 goto cleanup_drm;
1073
1074 if (roundtrip(dri2_dpy) < 0 || !dri2_dpy->authenticated)
1075 goto cleanup_fd;
1076
1077 dri2_dpy->fd = loader_get_user_preferred_fd(dri2_dpy->fd,
1078 &dri2_dpy->is_different_gpu);
1079 if (dri2_dpy->is_different_gpu) {
1080 free(dri2_dpy->device_name);
1081 dri2_dpy->device_name = loader_get_device_name_for_fd(dri2_dpy->fd);
1082 if (!dri2_dpy->device_name) {
1083 _eglError(EGL_BAD_ALLOC, "wayland-egl: failed to get device name "
1084 "for requested GPU");
1085 goto cleanup_fd;
1086 }
1087 }
1088
1089 /* we have to do the check now, because loader_get_user_preferred_fd
1090 * will return a render-node when the requested gpu is different
1091 * to the server, but also if the client asks for the same gpu than
1092 * the server by requesting its pci-id */
1093 dri2_dpy->is_render_node = drmGetNodeTypeFromFd(dri2_dpy->fd) == DRM_NODE_RENDER;
1094
1095 dri2_dpy->driver_name = loader_get_driver_for_fd(dri2_dpy->fd, 0);
1096 if (dri2_dpy->driver_name == NULL) {
1097 _eglError(EGL_BAD_ALLOC, "DRI2: failed to get driver name");
1098 goto cleanup_fd;
1099 }
1100
1101 if (!dri2_load_driver(disp))
1102 goto cleanup_driver_name;
1103
1104 dri2_dpy->extensions[0] = &image_loader_extension.base;
1105 dri2_dpy->extensions[1] = &image_lookup_extension.base;
1106 dri2_dpy->extensions[2] = &use_invalidate.base;
1107
1108 /* render nodes cannot use Gem names, and thus do not support
1109 * the __DRI_DRI2_LOADER extension */
1110 if (!dri2_dpy->is_render_node) {
1111 dri2_dpy->dri2_loader_extension.base.name = __DRI_DRI2_LOADER;
1112 dri2_dpy->dri2_loader_extension.base.version = 3;
1113 dri2_dpy->dri2_loader_extension.getBuffers = dri2_wl_get_buffers;
1114 dri2_dpy->dri2_loader_extension.flushFrontBuffer = dri2_wl_flush_front_buffer;
1115 dri2_dpy->dri2_loader_extension.getBuffersWithFormat =
1116 dri2_wl_get_buffers_with_format;
1117 dri2_dpy->extensions[3] = &dri2_dpy->dri2_loader_extension.base;
1118 dri2_dpy->extensions[4] = NULL;
1119 } else
1120 dri2_dpy->extensions[3] = NULL;
1121
1122 dri2_dpy->swap_available = EGL_TRUE;
1123
1124 if (!dri2_create_screen(disp))
1125 goto cleanup_driver;
1126
1127 dri2_wl_setup_swap_interval(dri2_dpy);
1128
1129 /* To use Prime, we must have _DRI_IMAGE v7 at least.
1130 * createImageFromFds support indicates that Prime export/import
1131 * is supported by the driver. Fall back to
1132 * gem names if we don't have Prime support. */
1133
1134 if (dri2_dpy->image->base.version < 7 ||
1135 dri2_dpy->image->createImageFromFds == NULL)
1136 dri2_dpy->capabilities &= ~WL_DRM_CAPABILITY_PRIME;
1137
1138 /* We cannot use Gem names with render-nodes, only prime fds (dma-buf).
1139 * The server needs to accept them */
1140 if (dri2_dpy->is_render_node &&
1141 !(dri2_dpy->capabilities & WL_DRM_CAPABILITY_PRIME)) {
1142 _eglLog(_EGL_WARNING, "wayland-egl: display is not render-node capable");
1143 goto cleanup_screen;
1144 }
1145
1146 if (dri2_dpy->is_different_gpu &&
1147 (dri2_dpy->image->base.version < 9 ||
1148 dri2_dpy->image->blitImage == NULL)) {
1149 _eglLog(_EGL_WARNING, "wayland-egl: Different GPU selected, but the "
1150 "Image extension in the driver is not "
1151 "compatible. Version 9 or later and blitImage() "
1152 "are required");
1153 goto cleanup_screen;
1154 }
1155
1156 types = EGL_WINDOW_BIT;
1157 for (i = 0; dri2_dpy->driver_configs[i]; i++) {
1158 config = dri2_dpy->driver_configs[i];
1159 if (dri2_dpy->formats & HAS_XRGB8888)
1160 dri2_add_config(disp, config, i + 1, types, NULL, rgb_masks);
1161 if (dri2_dpy->formats & HAS_ARGB8888)
1162 dri2_add_config(disp, config, i + 1, types, NULL, argb_masks);
1163 if (dri2_dpy->formats & HAS_RGB565)
1164 dri2_add_config(disp, config, i + 1, types, NULL, rgb565_masks);
1165 }
1166
1167 disp->Extensions.WL_bind_wayland_display = EGL_TRUE;
1168 /* When cannot convert EGLImage to wl_buffer when on a different gpu,
1169 * because the buffer of the EGLImage has likely a tiling mode the server
1170 * gpu won't support. These is no way to check for now. Thus do not support the
1171 * extension */
1172 if (!dri2_dpy->is_different_gpu) {
1173 disp->Extensions.WL_create_wayland_buffer_from_image = EGL_TRUE;
1174 } else {
1175 dri2_wl_display_vtbl.create_wayland_buffer_from_image =
1176 dri2_fallback_create_wayland_buffer_from_image;
1177 }
1178 disp->Extensions.EXT_buffer_age = EGL_TRUE;
1179
1180 disp->Extensions.EXT_swap_buffers_with_damage = EGL_TRUE;
1181
1182 /* Fill vtbl last to prevent accidentally calling virtual function during
1183 * initialization.
1184 */
1185 dri2_dpy->vtbl = &dri2_wl_display_vtbl;
1186
1187 return EGL_TRUE;
1188
1189 cleanup_screen:
1190 dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
1191 cleanup_driver:
1192 dlclose(dri2_dpy->driver);
1193 cleanup_driver_name:
1194 free(dri2_dpy->driver_name);
1195 cleanup_fd:
1196 close(dri2_dpy->fd);
1197 cleanup_drm:
1198 free(dri2_dpy->device_name);
1199 wl_drm_destroy(dri2_dpy->wl_drm);
1200 cleanup_registry:
1201 wl_registry_destroy(dri2_dpy->wl_registry);
1202 wl_event_queue_destroy(dri2_dpy->wl_queue);
1203 cleanup_dpy:
1204 free(dri2_dpy);
1205
1206 return EGL_FALSE;
1207 }
1208
1209 static int
1210 dri2_wl_swrast_get_stride_for_format(int format, int w)
1211 {
1212 if (format == WL_SHM_FORMAT_RGB565)
1213 return 2 * w;
1214 else /* ARGB8888 || XRGB8888 */
1215 return 4 * w;
1216 }
1217
1218 /*
1219 * Taken from weston shared/os-compatibility.c
1220 */
1221
1222 #ifndef HAVE_MKOSTEMP
1223
1224 static int
1225 set_cloexec_or_close(int fd)
1226 {
1227 long flags;
1228
1229 if (fd == -1)
1230 return -1;
1231
1232 flags = fcntl(fd, F_GETFD);
1233 if (flags == -1)
1234 goto err;
1235
1236 if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1)
1237 goto err;
1238
1239 return fd;
1240
1241 err:
1242 close(fd);
1243 return -1;
1244 }
1245
1246 #endif
1247
1248 /*
1249 * Taken from weston shared/os-compatibility.c
1250 */
1251
1252 static int
1253 create_tmpfile_cloexec(char *tmpname)
1254 {
1255 int fd;
1256
1257 #ifdef HAVE_MKOSTEMP
1258 fd = mkostemp(tmpname, O_CLOEXEC);
1259 if (fd >= 0)
1260 unlink(tmpname);
1261 #else
1262 fd = mkstemp(tmpname);
1263 if (fd >= 0) {
1264 fd = set_cloexec_or_close(fd);
1265 unlink(tmpname);
1266 }
1267 #endif
1268
1269 return fd;
1270 }
1271
1272 /*
1273 * Taken from weston shared/os-compatibility.c
1274 *
1275 * Create a new, unique, anonymous file of the given size, and
1276 * return the file descriptor for it. The file descriptor is set
1277 * CLOEXEC. The file is immediately suitable for mmap()'ing
1278 * the given size at offset zero.
1279 *
1280 * The file should not have a permanent backing store like a disk,
1281 * but may have if XDG_RUNTIME_DIR is not properly implemented in OS.
1282 *
1283 * The file name is deleted from the file system.
1284 *
1285 * The file is suitable for buffer sharing between processes by
1286 * transmitting the file descriptor over Unix sockets using the
1287 * SCM_RIGHTS methods.
1288 *
1289 * If the C library implements posix_fallocate(), it is used to
1290 * guarantee that disk space is available for the file at the
1291 * given size. If disk space is insufficent, errno is set to ENOSPC.
1292 * If posix_fallocate() is not supported, program may receive
1293 * SIGBUS on accessing mmap()'ed file contents instead.
1294 */
1295 static int
1296 os_create_anonymous_file(off_t size)
1297 {
1298 static const char template[] = "/mesa-shared-XXXXXX";
1299 const char *path;
1300 char *name;
1301 int fd;
1302 int ret;
1303
1304 path = getenv("XDG_RUNTIME_DIR");
1305 if (!path) {
1306 errno = ENOENT;
1307 return -1;
1308 }
1309
1310 name = malloc(strlen(path) + sizeof(template));
1311 if (!name)
1312 return -1;
1313
1314 strcpy(name, path);
1315 strcat(name, template);
1316
1317 fd = create_tmpfile_cloexec(name);
1318
1319 free(name);
1320
1321 if (fd < 0)
1322 return -1;
1323
1324 ret = ftruncate(fd, size);
1325 if (ret < 0) {
1326 close(fd);
1327 return -1;
1328 }
1329
1330 return fd;
1331 }
1332
1333
1334 static EGLBoolean
1335 dri2_wl_swrast_allocate_buffer(struct dri2_egl_display *dri2_dpy,
1336 int format, int w, int h,
1337 void **data, int *size,
1338 struct wl_buffer **buffer)
1339 {
1340 struct wl_shm_pool *pool;
1341 int fd, stride, size_map;
1342 void *data_map;
1343
1344 stride = dri2_wl_swrast_get_stride_for_format(format, w);
1345 size_map = h * stride;
1346
1347 /* Create a sharable buffer */
1348 fd = os_create_anonymous_file(size_map);
1349 if (fd < 0)
1350 return EGL_FALSE;
1351
1352 data_map = mmap(NULL, size_map, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1353 if (data_map == MAP_FAILED) {
1354 close(fd);
1355 return EGL_FALSE;
1356 }
1357
1358 /* Share it in a wl_buffer */
1359 pool = wl_shm_create_pool(dri2_dpy->wl_shm, fd, size_map);
1360 *buffer = wl_shm_pool_create_buffer(pool, 0, w, h, stride, format);
1361 wl_shm_pool_destroy(pool);
1362 close(fd);
1363
1364 *data = data_map;
1365 *size = size_map;
1366 return EGL_TRUE;
1367 }
1368
1369 static int
1370 swrast_update_buffers(struct dri2_egl_surface *dri2_surf)
1371 {
1372 struct dri2_egl_display *dri2_dpy =
1373 dri2_egl_display(dri2_surf->base.Resource.Display);
1374 int i;
1375
1376 /* we need to do the following operations only once per frame */
1377 if (dri2_surf->back)
1378 return 0;
1379
1380 if (dri2_surf->base.Width != dri2_surf->wl_win->width ||
1381 dri2_surf->base.Height != dri2_surf->wl_win->height) {
1382
1383 dri2_wl_release_buffers(dri2_surf);
1384
1385 dri2_surf->base.Width = dri2_surf->wl_win->width;
1386 dri2_surf->base.Height = dri2_surf->wl_win->height;
1387 dri2_surf->dx = dri2_surf->wl_win->dx;
1388 dri2_surf->dy = dri2_surf->wl_win->dy;
1389 dri2_surf->current = NULL;
1390 }
1391
1392 /* find back buffer */
1393
1394 /* We always want to throttle to some event (either a frame callback or
1395 * a sync request) after the commit so that we can be sure the
1396 * compositor has had a chance to handle it and send us a release event
1397 * before we look for a free buffer */
1398 while (dri2_surf->throttle_callback != NULL)
1399 if (wl_display_dispatch_queue(dri2_dpy->wl_dpy,
1400 dri2_dpy->wl_queue) == -1)
1401 return -1;
1402
1403 /* try get free buffer already created */
1404 for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
1405 if (!dri2_surf->color_buffers[i].locked &&
1406 dri2_surf->color_buffers[i].wl_buffer) {
1407 dri2_surf->back = &dri2_surf->color_buffers[i];
1408 break;
1409 }
1410 }
1411
1412 /* else choose any another free location */
1413 if (!dri2_surf->back) {
1414 for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
1415 if (!dri2_surf->color_buffers[i].locked) {
1416 dri2_surf->back = &dri2_surf->color_buffers[i];
1417 if (!dri2_wl_swrast_allocate_buffer(dri2_dpy,
1418 dri2_surf->format,
1419 dri2_surf->base.Width,
1420 dri2_surf->base.Height,
1421 &dri2_surf->back->data,
1422 &dri2_surf->back->data_size,
1423 &dri2_surf->back->wl_buffer)) {
1424 _eglError(EGL_BAD_ALLOC, "failed to allocate color buffer");
1425 return -1;
1426 }
1427 wl_proxy_set_queue((struct wl_proxy *) dri2_surf->back->wl_buffer,
1428 dri2_dpy->wl_queue);
1429 wl_buffer_add_listener(dri2_surf->back->wl_buffer,
1430 &wl_buffer_listener, dri2_surf);
1431 break;
1432 }
1433 }
1434 }
1435
1436 if (!dri2_surf->back) {
1437 _eglError(EGL_BAD_ALLOC, "failed to find free buffer");
1438 return -1;
1439 }
1440
1441 dri2_surf->back->locked = 1;
1442
1443 /* If we have an extra unlocked buffer at this point, we had to do triple
1444 * buffering for a while, but now can go back to just double buffering.
1445 * That means we can free any unlocked buffer now. */
1446 for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
1447 if (!dri2_surf->color_buffers[i].locked &&
1448 dri2_surf->color_buffers[i].wl_buffer) {
1449 wl_buffer_destroy(dri2_surf->color_buffers[i].wl_buffer);
1450 munmap(dri2_surf->color_buffers[i].data,
1451 dri2_surf->color_buffers[i].data_size);
1452 dri2_surf->color_buffers[i].wl_buffer = NULL;
1453 dri2_surf->color_buffers[i].data = NULL;
1454 }
1455 }
1456
1457 return 0;
1458 }
1459
1460 static void*
1461 dri2_wl_swrast_get_frontbuffer_data(struct dri2_egl_surface *dri2_surf)
1462 {
1463 /* if there has been a resize: */
1464 if (!dri2_surf->current)
1465 return NULL;
1466
1467 return dri2_surf->current->data;
1468 }
1469
1470 static void*
1471 dri2_wl_swrast_get_backbuffer_data(struct dri2_egl_surface *dri2_surf)
1472 {
1473 assert(dri2_surf->back);
1474 return dri2_surf->back->data;
1475 }
1476
1477 static void
1478 dri2_wl_swrast_commit_backbuffer(struct dri2_egl_surface *dri2_surf)
1479 {
1480 struct dri2_egl_display *dri2_dpy = dri2_egl_display(dri2_surf->base.Resource.Display);
1481
1482 if (dri2_surf->base.SwapInterval > 0) {
1483 dri2_surf->throttle_callback =
1484 wl_surface_frame(dri2_surf->wl_win->surface);
1485 wl_callback_add_listener(dri2_surf->throttle_callback,
1486 &throttle_listener, dri2_surf);
1487 wl_proxy_set_queue((struct wl_proxy *) dri2_surf->throttle_callback,
1488 dri2_dpy->wl_queue);
1489 }
1490
1491 dri2_surf->current = dri2_surf->back;
1492 dri2_surf->back = NULL;
1493
1494 wl_surface_attach(dri2_surf->wl_win->surface,
1495 dri2_surf->current->wl_buffer,
1496 dri2_surf->dx, dri2_surf->dy);
1497
1498 dri2_surf->wl_win->attached_width = dri2_surf->base.Width;
1499 dri2_surf->wl_win->attached_height = dri2_surf->base.Height;
1500 /* reset resize growing parameters */
1501 dri2_surf->dx = 0;
1502 dri2_surf->dy = 0;
1503
1504 wl_surface_damage(dri2_surf->wl_win->surface,
1505 0, 0, INT32_MAX, INT32_MAX);
1506 wl_surface_commit(dri2_surf->wl_win->surface);
1507
1508 /* If we're not waiting for a frame callback then we'll at least throttle
1509 * to a sync callback so that we always give a chance for the compositor to
1510 * handle the commit and send a release event before checking for a free
1511 * buffer */
1512 if (dri2_surf->throttle_callback == NULL) {
1513 dri2_surf->throttle_callback = wl_display_sync(dri2_dpy->wl_dpy);
1514 wl_callback_add_listener(dri2_surf->throttle_callback,
1515 &throttle_listener, dri2_surf);
1516 wl_proxy_set_queue((struct wl_proxy *) dri2_surf->throttle_callback,
1517 dri2_dpy->wl_queue);
1518 }
1519
1520 wl_display_flush(dri2_dpy->wl_dpy);
1521 }
1522
1523 static void
1524 dri2_wl_swrast_get_drawable_info(__DRIdrawable * draw,
1525 int *x, int *y, int *w, int *h,
1526 void *loaderPrivate)
1527 {
1528 struct dri2_egl_surface *dri2_surf = loaderPrivate;
1529
1530 (void) swrast_update_buffers(dri2_surf);
1531 *x = 0;
1532 *y = 0;
1533 *w = dri2_surf->base.Width;
1534 *h = dri2_surf->base.Height;
1535 }
1536
1537 static void
1538 dri2_wl_swrast_get_image(__DRIdrawable * read,
1539 int x, int y, int w, int h,
1540 char *data, void *loaderPrivate)
1541 {
1542 struct dri2_egl_surface *dri2_surf = loaderPrivate;
1543 int copy_width = dri2_wl_swrast_get_stride_for_format(dri2_surf->format, w);
1544 int x_offset = dri2_wl_swrast_get_stride_for_format(dri2_surf->format, x);
1545 int src_stride = dri2_wl_swrast_get_stride_for_format(dri2_surf->format, dri2_surf->base.Width);
1546 int dst_stride = copy_width;
1547 char *src, *dst;
1548
1549 src = dri2_wl_swrast_get_frontbuffer_data(dri2_surf);
1550 if (!src) {
1551 memset(data, 0, copy_width * h);
1552 return;
1553 }
1554
1555 assert(data != src);
1556 assert(copy_width <= src_stride);
1557
1558 src += x_offset;
1559 src += y * src_stride;
1560 dst = data;
1561
1562 if (copy_width > src_stride-x_offset)
1563 copy_width = src_stride-x_offset;
1564 if (h > dri2_surf->base.Height-y)
1565 h = dri2_surf->base.Height-y;
1566
1567 for (; h>0; h--) {
1568 memcpy(dst, src, copy_width);
1569 src += src_stride;
1570 dst += dst_stride;
1571 }
1572 }
1573
1574 static void
1575 dri2_wl_swrast_put_image2(__DRIdrawable * draw, int op,
1576 int x, int y, int w, int h, int stride,
1577 char *data, void *loaderPrivate)
1578 {
1579 struct dri2_egl_surface *dri2_surf = loaderPrivate;
1580 int copy_width = dri2_wl_swrast_get_stride_for_format(dri2_surf->format, w);
1581 int dst_stride = dri2_wl_swrast_get_stride_for_format(dri2_surf->format, dri2_surf->base.Width);
1582 int x_offset = dri2_wl_swrast_get_stride_for_format(dri2_surf->format, x);
1583 char *src, *dst;
1584
1585 assert(copy_width <= stride);
1586
1587 (void) swrast_update_buffers(dri2_surf);
1588 dst = dri2_wl_swrast_get_backbuffer_data(dri2_surf);
1589
1590 /* partial copy, copy old content */
1591 if (copy_width < dst_stride)
1592 dri2_wl_swrast_get_image(draw, 0, 0,
1593 dri2_surf->base.Width, dri2_surf->base.Height,
1594 dst, loaderPrivate);
1595
1596 dst += x_offset;
1597 dst += y * dst_stride;
1598
1599 src = data;
1600
1601 /* drivers expect we do these checks (and some rely on it) */
1602 if (copy_width > dst_stride-x_offset)
1603 copy_width = dst_stride-x_offset;
1604 if (h > dri2_surf->base.Height-y)
1605 h = dri2_surf->base.Height-y;
1606
1607 for (; h>0; h--) {
1608 memcpy(dst, src, copy_width);
1609 src += stride;
1610 dst += dst_stride;
1611 }
1612 dri2_wl_swrast_commit_backbuffer(dri2_surf);
1613 }
1614
1615 static void
1616 dri2_wl_swrast_put_image(__DRIdrawable * draw, int op,
1617 int x, int y, int w, int h,
1618 char *data, void *loaderPrivate)
1619 {
1620 struct dri2_egl_surface *dri2_surf = loaderPrivate;
1621 int stride;
1622
1623 stride = dri2_wl_swrast_get_stride_for_format(dri2_surf->format, w);
1624 dri2_wl_swrast_put_image2(draw, op, x, y, w, h,
1625 stride, data, loaderPrivate);
1626 }
1627
1628 /**
1629 * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
1630 */
1631 static _EGLSurface *
1632 dri2_wl_swrast_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
1633 _EGLConfig *conf, void *native_window,
1634 const EGLint *attrib_list)
1635 {
1636 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1637 struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
1638 struct wl_egl_window *window = native_window;
1639 struct dri2_egl_surface *dri2_surf;
1640 const __DRIconfig *config;
1641
1642 (void) drv;
1643
1644 dri2_surf = calloc(1, sizeof *dri2_surf);
1645 if (!dri2_surf) {
1646 _eglError(EGL_BAD_ALLOC, "dri2_create_surface");
1647 return NULL;
1648 }
1649
1650 if (!_eglInitSurface(&dri2_surf->base, disp, EGL_WINDOW_BIT, conf, attrib_list))
1651 goto cleanup_surf;
1652
1653 if (conf->RedSize == 5)
1654 dri2_surf->format = WL_SHM_FORMAT_RGB565;
1655 else if (conf->AlphaSize == 0)
1656 dri2_surf->format = WL_SHM_FORMAT_XRGB8888;
1657 else
1658 dri2_surf->format = WL_SHM_FORMAT_ARGB8888;
1659
1660 dri2_surf->wl_win = window;
1661
1662 dri2_surf->base.Width = -1;
1663 dri2_surf->base.Height = -1;
1664
1665 config = dri2_get_dri_config(dri2_conf, EGL_WINDOW_BIT,
1666 dri2_surf->base.GLColorspace);
1667
1668 dri2_surf->dri_drawable =
1669 (*dri2_dpy->swrast->createNewDrawable)(dri2_dpy->dri_screen,
1670 config, dri2_surf);
1671 if (dri2_surf->dri_drawable == NULL) {
1672 _eglError(EGL_BAD_ALLOC, "swrast->createNewDrawable");
1673 goto cleanup_dri_drawable;
1674 }
1675
1676 dri2_wl_swap_interval(drv, disp, &dri2_surf->base,
1677 dri2_dpy->default_swap_interval);
1678
1679 return &dri2_surf->base;
1680
1681 cleanup_dri_drawable:
1682 dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
1683 cleanup_surf:
1684 free(dri2_surf);
1685
1686 return NULL;
1687 }
1688
1689 static EGLBoolean
1690 dri2_wl_swrast_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
1691 {
1692 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1693 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1694
1695 dri2_dpy->core->swapBuffers(dri2_surf->dri_drawable);
1696 return EGL_TRUE;
1697 }
1698
1699 static void
1700 shm_handle_format(void *data, struct wl_shm *shm, uint32_t format)
1701 {
1702 struct dri2_egl_display *dri2_dpy = data;
1703
1704 switch (format) {
1705 case WL_SHM_FORMAT_ARGB8888:
1706 dri2_dpy->formats |= HAS_ARGB8888;
1707 break;
1708 case WL_SHM_FORMAT_XRGB8888:
1709 dri2_dpy->formats |= HAS_XRGB8888;
1710 break;
1711 case WL_SHM_FORMAT_RGB565:
1712 dri2_dpy->formats |= HAS_RGB565;
1713 break;
1714 }
1715 }
1716
1717 static const struct wl_shm_listener shm_listener = {
1718 .format = shm_handle_format
1719 };
1720
1721 static void
1722 registry_handle_global_swrast(void *data, struct wl_registry *registry, uint32_t name,
1723 const char *interface, uint32_t version)
1724 {
1725 struct dri2_egl_display *dri2_dpy = data;
1726
1727 if (strcmp(interface, "wl_shm") == 0) {
1728 dri2_dpy->wl_shm =
1729 wl_registry_bind(registry, name, &wl_shm_interface, 1);
1730 wl_shm_add_listener(dri2_dpy->wl_shm, &shm_listener, dri2_dpy);
1731 }
1732 }
1733
1734 static const struct wl_registry_listener registry_listener_swrast = {
1735 .global = registry_handle_global_swrast,
1736 .global_remove = registry_handle_global_remove
1737 };
1738
1739 static struct dri2_egl_display_vtbl dri2_wl_swrast_display_vtbl = {
1740 .authenticate = NULL,
1741 .create_window_surface = dri2_wl_swrast_create_window_surface,
1742 .create_pixmap_surface = dri2_wl_create_pixmap_surface,
1743 .create_pbuffer_surface = dri2_fallback_create_pbuffer_surface,
1744 .destroy_surface = dri2_wl_destroy_surface,
1745 .create_image = dri2_fallback_create_image_khr,
1746 .swap_interval = dri2_wl_swap_interval,
1747 .swap_buffers = dri2_wl_swrast_swap_buffers,
1748 .swap_buffers_with_damage = dri2_fallback_swap_buffers_with_damage,
1749 .swap_buffers_region = dri2_fallback_swap_buffers_region,
1750 .post_sub_buffer = dri2_fallback_post_sub_buffer,
1751 .copy_buffers = dri2_fallback_copy_buffers,
1752 .query_buffer_age = dri2_fallback_query_buffer_age,
1753 .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
1754 .get_sync_values = dri2_fallback_get_sync_values,
1755 };
1756
1757 static EGLBoolean
1758 dri2_initialize_wayland_swrast(_EGLDriver *drv, _EGLDisplay *disp)
1759 {
1760 struct dri2_egl_display *dri2_dpy;
1761 const __DRIconfig *config;
1762 uint32_t types;
1763 int i;
1764 static const unsigned int argb_masks[4] =
1765 { 0xff0000, 0xff00, 0xff, 0xff000000 };
1766 static const unsigned int rgb_masks[4] = { 0xff0000, 0xff00, 0xff, 0 };
1767 static const unsigned int rgb565_masks[4] = { 0xf800, 0x07e0, 0x001f, 0 };
1768
1769 loader_set_logger(_eglLog);
1770
1771 dri2_dpy = calloc(1, sizeof *dri2_dpy);
1772 if (!dri2_dpy)
1773 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1774
1775 disp->DriverData = (void *) dri2_dpy;
1776 if (disp->PlatformDisplay == NULL) {
1777 dri2_dpy->wl_dpy = wl_display_connect(NULL);
1778 if (dri2_dpy->wl_dpy == NULL)
1779 goto cleanup_dpy;
1780 dri2_dpy->own_device = 1;
1781 } else {
1782 dri2_dpy->wl_dpy = disp->PlatformDisplay;
1783 }
1784
1785 dri2_dpy->wl_queue = wl_display_create_queue(dri2_dpy->wl_dpy);
1786
1787 if (dri2_dpy->own_device)
1788 wl_display_dispatch_pending(dri2_dpy->wl_dpy);
1789
1790 dri2_dpy->wl_registry = wl_display_get_registry(dri2_dpy->wl_dpy);
1791 wl_proxy_set_queue((struct wl_proxy *) dri2_dpy->wl_registry,
1792 dri2_dpy->wl_queue);
1793 wl_registry_add_listener(dri2_dpy->wl_registry,
1794 &registry_listener_swrast, dri2_dpy);
1795
1796 if (roundtrip(dri2_dpy) < 0 || dri2_dpy->wl_shm == NULL)
1797 goto cleanup_registry;
1798
1799 if (roundtrip(dri2_dpy) < 0 || dri2_dpy->formats == 0)
1800 goto cleanup_shm;
1801
1802 dri2_dpy->fd = -1;
1803 dri2_dpy->driver_name = strdup("swrast");
1804 if (!dri2_load_driver_swrast(disp))
1805 goto cleanup_shm;
1806
1807 dri2_dpy->swrast_loader_extension.base.name = __DRI_SWRAST_LOADER;
1808 dri2_dpy->swrast_loader_extension.base.version = 2;
1809 dri2_dpy->swrast_loader_extension.getDrawableInfo = dri2_wl_swrast_get_drawable_info;
1810 dri2_dpy->swrast_loader_extension.putImage = dri2_wl_swrast_put_image;
1811 dri2_dpy->swrast_loader_extension.getImage = dri2_wl_swrast_get_image;
1812 dri2_dpy->swrast_loader_extension.putImage2 = dri2_wl_swrast_put_image2;
1813
1814 dri2_dpy->extensions[0] = &dri2_dpy->swrast_loader_extension.base;
1815 dri2_dpy->extensions[1] = NULL;
1816
1817 if (!dri2_create_screen(disp))
1818 goto cleanup_driver;
1819
1820 dri2_wl_setup_swap_interval(dri2_dpy);
1821
1822 types = EGL_WINDOW_BIT;
1823 for (i = 0; dri2_dpy->driver_configs[i]; i++) {
1824 config = dri2_dpy->driver_configs[i];
1825 if (dri2_dpy->formats & HAS_XRGB8888)
1826 dri2_add_config(disp, config, i + 1, types, NULL, rgb_masks);
1827 if (dri2_dpy->formats & HAS_ARGB8888)
1828 dri2_add_config(disp, config, i + 1, types, NULL, argb_masks);
1829 if (dri2_dpy->formats & HAS_RGB565)
1830 dri2_add_config(disp, config, i + 1, types, NULL, rgb565_masks);
1831 }
1832
1833 /* Fill vtbl last to prevent accidentally calling virtual function during
1834 * initialization.
1835 */
1836 dri2_dpy->vtbl = &dri2_wl_swrast_display_vtbl;
1837
1838 return EGL_TRUE;
1839
1840 cleanup_driver:
1841 dlclose(dri2_dpy->driver);
1842 cleanup_shm:
1843 wl_shm_destroy(dri2_dpy->wl_shm);
1844 cleanup_registry:
1845 wl_registry_destroy(dri2_dpy->wl_registry);
1846 wl_event_queue_destroy(dri2_dpy->wl_queue);
1847 cleanup_dpy:
1848 free(dri2_dpy);
1849
1850 return EGL_FALSE;
1851 }
1852
1853 EGLBoolean
1854 dri2_initialize_wayland(_EGLDriver *drv, _EGLDisplay *disp)
1855 {
1856 EGLBoolean initialized = EGL_TRUE;
1857
1858 int hw_accel = (getenv("LIBGL_ALWAYS_SOFTWARE") == NULL);
1859
1860 if (hw_accel) {
1861 if (!dri2_initialize_wayland_drm(drv, disp)) {
1862 initialized = dri2_initialize_wayland_swrast(drv, disp);
1863 }
1864 } else {
1865 initialized = dri2_initialize_wayland_swrast(drv, disp);
1866 }
1867
1868 return initialized;
1869
1870 }