projects / mesa.git / blob
? search:


20862e41af4fe2dc065c48125e9c27474b67adcc
[mesa.git] / src / egl / drivers / dri2 / egl_dri2.c
1 /*
2 * Copyright © 2010 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 <stdlib.h>
29 #include <string.h>
30 #include <stdio.h>
31 #include <limits.h>
32 #include <dlfcn.h>
33 #include <fcntl.h>
34 #include <errno.h>
35 #include <unistd.h>
36 #include <xf86drm.h>
37 #include <GL/gl.h>
38 #include <GL/internal/dri_interface.h>
39 #include <xcb/xcb.h>
40 #include <xcb/dri2.h>
41 #include <xcb/xfixes.h>
42 #include <X11/Xlib-xcb.h>
43 #include <sys/types.h>
44 #include <sys/stat.h>
45
46 #ifdef HAVE_LIBUDEV
47 #include <libudev.h>
48 #endif
49
50 #include <glapi/glapi.h>
51 #include "eglconfig.h"
52 #include "eglcontext.h"
53 #include "egldisplay.h"
54 #include "egldriver.h"
55 #include "eglcurrent.h"
56 #include "egllog.h"
57 #include "eglsurface.h"
58 #include "eglimage.h"
59
60 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
61
62 struct dri2_egl_driver
63 {
64 _EGLDriver base;
65
66 void (*glFlush)(void);
67 };
68
69 struct dri2_egl_display
70 {
71 xcb_connection_t *conn;
72 int dri2_major;
73 int dri2_minor;
74 __DRIscreen *dri_screen;
75 const __DRIconfig **driver_configs;
76 void *driver;
77 __DRIcoreExtension *core;
78 __DRIdri2Extension *dri2;
79 __DRI2flushExtension *flush;
80 __DRItexBufferExtension *tex_buffer;
81 __DRIimageExtension *image;
82 int fd;
83
84 char *device_name;
85 char *driver_name;
86
87 __DRIdri2LoaderExtension loader_extension;
88 const __DRIextension *extensions[3];
89 };
90
91 struct dri2_egl_context
92 {
93 _EGLContext base;
94 __DRIcontext *dri_context;
95 };
96
97 struct dri2_egl_surface
98 {
99 _EGLSurface base;
100 __DRIdrawable *dri_drawable;
101 xcb_drawable_t drawable;
102 __DRIbuffer buffers[5];
103 int buffer_count;
104 xcb_xfixes_region_t region;
105 int have_fake_front;
106 int swap_interval;
107 };
108
109 struct dri2_egl_config
110 {
111 _EGLConfig base;
112 const __DRIconfig *dri_config;
113 };
114
115 struct dri2_egl_image
116 {
117 _EGLImage base;
118 __DRIimage *dri_image;
119 };
120
121 /* standard typecasts */
122 _EGL_DRIVER_STANDARD_TYPECASTS(dri2_egl)
123 _EGL_DRIVER_TYPECAST(dri2_egl_image, _EGLImage, obj)
124
125 static const __DRIuseInvalidateExtension use_invalidate = {
126 { __DRI_USE_INVALIDATE, 1 }
127 };
128
129 EGLint dri2_to_egl_attribute_map[] = {
130 0,
131 EGL_BUFFER_SIZE, /* __DRI_ATTRIB_BUFFER_SIZE */
132 EGL_LEVEL, /* __DRI_ATTRIB_LEVEL */
133 EGL_RED_SIZE, /* __DRI_ATTRIB_RED_SIZE */
134 EGL_GREEN_SIZE, /* __DRI_ATTRIB_GREEN_SIZE */
135 EGL_BLUE_SIZE, /* __DRI_ATTRIB_BLUE_SIZE */
136 EGL_LUMINANCE_SIZE, /* __DRI_ATTRIB_LUMINANCE_SIZE */
137 EGL_ALPHA_SIZE, /* __DRI_ATTRIB_ALPHA_SIZE */
138 0, /* __DRI_ATTRIB_ALPHA_MASK_SIZE */
139 EGL_DEPTH_SIZE, /* __DRI_ATTRIB_DEPTH_SIZE */
140 EGL_STENCIL_SIZE, /* __DRI_ATTRIB_STENCIL_SIZE */
141 0, /* __DRI_ATTRIB_ACCUM_RED_SIZE */
142 0, /* __DRI_ATTRIB_ACCUM_GREEN_SIZE */
143 0, /* __DRI_ATTRIB_ACCUM_BLUE_SIZE */
144 0, /* __DRI_ATTRIB_ACCUM_ALPHA_SIZE */
145 EGL_SAMPLE_BUFFERS, /* __DRI_ATTRIB_SAMPLE_BUFFERS */
146 EGL_SAMPLES, /* __DRI_ATTRIB_SAMPLES */
147 0, /* __DRI_ATTRIB_RENDER_TYPE, */
148 0, /* __DRI_ATTRIB_CONFIG_CAVEAT */
149 0, /* __DRI_ATTRIB_CONFORMANT */
150 0, /* __DRI_ATTRIB_DOUBLE_BUFFER */
151 0, /* __DRI_ATTRIB_STEREO */
152 0, /* __DRI_ATTRIB_AUX_BUFFERS */
153 0, /* __DRI_ATTRIB_TRANSPARENT_TYPE */
154 0, /* __DRI_ATTRIB_TRANSPARENT_INDEX_VALUE */
155 0, /* __DRI_ATTRIB_TRANSPARENT_RED_VALUE */
156 0, /* __DRI_ATTRIB_TRANSPARENT_GREEN_VALUE */
157 0, /* __DRI_ATTRIB_TRANSPARENT_BLUE_VALUE */
158 0, /* __DRI_ATTRIB_TRANSPARENT_ALPHA_VALUE */
159 0, /* __DRI_ATTRIB_FLOAT_MODE */
160 0, /* __DRI_ATTRIB_RED_MASK */
161 0, /* __DRI_ATTRIB_GREEN_MASK */
162 0, /* __DRI_ATTRIB_BLUE_MASK */
163 0, /* __DRI_ATTRIB_ALPHA_MASK */
164 EGL_MAX_PBUFFER_WIDTH, /* __DRI_ATTRIB_MAX_PBUFFER_WIDTH */
165 EGL_MAX_PBUFFER_HEIGHT, /* __DRI_ATTRIB_MAX_PBUFFER_HEIGHT */
166 EGL_MAX_PBUFFER_PIXELS, /* __DRI_ATTRIB_MAX_PBUFFER_PIXELS */
167 0, /* __DRI_ATTRIB_OPTIMAL_PBUFFER_WIDTH */
168 0, /* __DRI_ATTRIB_OPTIMAL_PBUFFER_HEIGHT */
169 0, /* __DRI_ATTRIB_VISUAL_SELECT_GROUP */
170 0, /* __DRI_ATTRIB_SWAP_METHOD */
171 EGL_MAX_SWAP_INTERVAL, /* __DRI_ATTRIB_MAX_SWAP_INTERVAL */
172 EGL_MIN_SWAP_INTERVAL, /* __DRI_ATTRIB_MIN_SWAP_INTERVAL */
173 0, /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGB */
174 0, /* __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA */
175 0, /* __DRI_ATTRIB_BIND_TO_MIPMAP_TEXTURE */
176 0, /* __DRI_ATTRIB_BIND_TO_TEXTURE_TARGETS */
177 EGL_Y_INVERTED_NOK, /* __DRI_ATTRIB_YINVERTED */
178 };
179
180 static struct dri2_egl_config *
181 dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
182 int depth, EGLint surface_type)
183 {
184 struct dri2_egl_config *conf;
185 struct dri2_egl_display *dri2_dpy;
186 _EGLConfig base;
187 unsigned int attrib, value, double_buffer;
188 EGLint key, bind_to_texture_rgb, bind_to_texture_rgba;
189 int i;
190
191 dri2_dpy = disp->DriverData;
192 _eglInitConfig(&base, disp, id);
193
194 i = 0;
195 double_buffer = 0;
196 bind_to_texture_rgb = 0;
197 bind_to_texture_rgba = 0;
198
199 while (dri2_dpy->core->indexConfigAttrib(dri_config, i++, &attrib, &value)) {
200 switch (attrib) {
201 case __DRI_ATTRIB_RENDER_TYPE:
202 if (value & __DRI_ATTRIB_RGBA_BIT)
203 value = EGL_RGB_BUFFER;
204 else if (value & __DRI_ATTRIB_LUMINANCE_BIT)
205 value = EGL_LUMINANCE_BUFFER;
206 else
207 /* not valid */;
208 _eglSetConfigKey(&base, EGL_COLOR_BUFFER_TYPE, value);
209 break;
210
211 case __DRI_ATTRIB_CONFIG_CAVEAT:
212 if (value & __DRI_ATTRIB_NON_CONFORMANT_CONFIG)
213 value = EGL_NON_CONFORMANT_CONFIG;
214 else if (value & __DRI_ATTRIB_SLOW_BIT)
215 value = EGL_SLOW_CONFIG;
216 else
217 value = EGL_NONE;
218 _eglSetConfigKey(&base, EGL_CONFIG_CAVEAT, value);
219 break;
220
221 case __DRI_ATTRIB_BIND_TO_TEXTURE_RGB:
222 bind_to_texture_rgb = value;
223 break;
224
225 case __DRI_ATTRIB_BIND_TO_TEXTURE_RGBA:
226 bind_to_texture_rgba = value;
227 break;
228
229 case __DRI_ATTRIB_DOUBLE_BUFFER:
230 double_buffer = value;
231 break;
232
233 default:
234 key = dri2_to_egl_attribute_map[attrib];
235 if (key != 0)
236 _eglSetConfigKey(&base, key, value);
237 break;
238 }
239 }
240
241 /* In EGL, double buffer or not isn't a config attribute. Pixmaps
242 * surfaces are always single buffered, pbuffer surfaces are always
243 * back buffers and windows can be either, selected by passing an
244 * attribute at window surface construction time. To support this
245 * we ignore all double buffer configs and manipulate the buffer we
246 * return in the getBuffer callback to get the behaviour we want. */
247
248 if (double_buffer)
249 return NULL;
250
251 if (depth > 0 && depth != base.BufferSize)
252 return NULL;
253
254 base.NativeRenderable = EGL_TRUE;
255
256 base.SurfaceType = surface_type;
257 if (surface_type & (EGL_PIXMAP_BIT | EGL_PBUFFER_BIT)) {
258 base.BindToTextureRGB = bind_to_texture_rgb;
259 if (base.AlphaSize > 0)
260 base.BindToTextureRGBA = bind_to_texture_rgba;
261 }
262
263 base.RenderableType = disp->ClientAPIsMask;
264 base.Conformant = disp->ClientAPIsMask;
265
266 if (!_eglValidateConfig(&base, EGL_FALSE)) {
267 _eglLog(_EGL_DEBUG, "DRI2: failed to validate config %d", id);
268 return NULL;
269 }
270
271 conf = malloc(sizeof *conf);
272 if (conf != NULL) {
273 memcpy(&conf->base, &base, sizeof base);
274 conf->dri_config = dri_config;
275 _eglLinkConfig(&conf->base);
276 }
277
278 return conf;
279 }
280
281 /**
282 * Process list of buffer received from the server
283 *
284 * Processes the list of buffers received in a reply from the server to either
285 * \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat.
286 */
287 static void
288 dri2_process_buffers(struct dri2_egl_surface *dri2_surf,
289 xcb_dri2_dri2_buffer_t *buffers, unsigned count)
290 {
291 struct dri2_egl_display *dri2_dpy =
292 dri2_egl_display(dri2_surf->base.Resource.Display);
293 xcb_rectangle_t rectangle;
294 unsigned i;
295
296 dri2_surf->buffer_count = count;
297 dri2_surf->have_fake_front = 0;
298
299 /* This assumes the DRI2 buffer attachment tokens matches the
300 * __DRIbuffer tokens. */
301 for (i = 0; i < count; i++) {
302 dri2_surf->buffers[i].attachment = buffers[i].attachment;
303 dri2_surf->buffers[i].name = buffers[i].name;
304 dri2_surf->buffers[i].pitch = buffers[i].pitch;
305 dri2_surf->buffers[i].cpp = buffers[i].cpp;
306 dri2_surf->buffers[i].flags = buffers[i].flags;
307
308 /* We only use the DRI drivers single buffer configs. This
309 * means that if we try to render to a window, DRI2 will give us
310 * the fake front buffer, which we'll use as a back buffer.
311 * Note that EGL doesn't require that several clients rendering
312 * to the same window must see the same aux buffers. */
313 if (dri2_surf->buffers[i].attachment == __DRI_BUFFER_FAKE_FRONT_LEFT)
314 dri2_surf->have_fake_front = 1;
315 }
316
317 if (dri2_surf->region != XCB_NONE)
318 xcb_xfixes_destroy_region(dri2_dpy->conn, dri2_surf->region);
319
320 rectangle.x = 0;
321 rectangle.y = 0;
322 rectangle.width = dri2_surf->base.Width;
323 rectangle.height = dri2_surf->base.Height;
324 dri2_surf->region = xcb_generate_id(dri2_dpy->conn);
325 xcb_xfixes_create_region(dri2_dpy->conn, dri2_surf->region, 1, &rectangle);
326 }
327
328 static __DRIbuffer *
329 dri2_get_buffers(__DRIdrawable * driDrawable,
330 int *width, int *height,
331 unsigned int *attachments, int count,
332 int *out_count, void *loaderPrivate)
333 {
334 struct dri2_egl_surface *dri2_surf = loaderPrivate;
335 struct dri2_egl_display *dri2_dpy =
336 dri2_egl_display(dri2_surf->base.Resource.Display);
337 xcb_dri2_dri2_buffer_t *buffers;
338 xcb_dri2_get_buffers_reply_t *reply;
339 xcb_dri2_get_buffers_cookie_t cookie;
340
341 (void) driDrawable;
342
343 cookie = xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
344 dri2_surf->drawable,
345 count, count, attachments);
346 reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn, cookie, NULL);
347 buffers = xcb_dri2_get_buffers_buffers (reply);
348 if (buffers == NULL)
349 return NULL;
350
351 *out_count = reply->count;
352 dri2_surf->base.Width = *width = reply->width;
353 dri2_surf->base.Height = *height = reply->height;
354 dri2_process_buffers(dri2_surf, buffers, *out_count);
355
356 free(reply);
357
358 return dri2_surf->buffers;
359 }
360
361 static void
362 dri2_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
363 {
364 (void) driDrawable;
365
366 /* FIXME: Does EGL support front buffer rendering at all? */
367
368 #if 0
369 struct dri2_egl_surface *dri2_surf = loaderPrivate;
370
371 dri2WaitGL(dri2_surf);
372 #else
373 (void) loaderPrivate;
374 #endif
375 }
376
377 static __DRIimage *
378 dri2_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
379 {
380 _EGLDisplay *disp = data;
381 struct dri2_egl_image *dri2_img;
382 _EGLImage *img;
383
384 (void) screen;
385
386 img = _eglLookupImage(image, disp);
387 if (img == NULL) {
388 _eglError(EGL_BAD_PARAMETER, "dri2_lookup_egl_image");
389 return NULL;
390 }
391
392 dri2_img = dri2_egl_image(image);
393
394 return dri2_img->dri_image;
395 }
396
397 static const __DRIimageLookupExtension image_lookup_extension = {
398 { __DRI_IMAGE_LOOKUP, 1 },
399 dri2_lookup_egl_image
400 };
401
402 static __DRIbuffer *
403 dri2_get_buffers_with_format(__DRIdrawable * driDrawable,
404 int *width, int *height,
405 unsigned int *attachments, int count,
406 int *out_count, void *loaderPrivate)
407 {
408 struct dri2_egl_surface *dri2_surf = loaderPrivate;
409 struct dri2_egl_display *dri2_dpy =
410 dri2_egl_display(dri2_surf->base.Resource.Display);
411 xcb_dri2_dri2_buffer_t *buffers;
412 xcb_dri2_get_buffers_with_format_reply_t *reply;
413 xcb_dri2_get_buffers_with_format_cookie_t cookie;
414 xcb_dri2_attach_format_t *format_attachments;
415
416 (void) driDrawable;
417
418 format_attachments = (xcb_dri2_attach_format_t *) attachments;
419 cookie = xcb_dri2_get_buffers_with_format_unchecked (dri2_dpy->conn,
420 dri2_surf->drawable,
421 count, count,
422 format_attachments);
423
424 reply = xcb_dri2_get_buffers_with_format_reply (dri2_dpy->conn,
425 cookie, NULL);
426 if (reply == NULL)
427 return NULL;
428
429 buffers = xcb_dri2_get_buffers_with_format_buffers (reply);
430 dri2_surf->base.Width = *width = reply->width;
431 dri2_surf->base.Height = *height = reply->height;
432 *out_count = reply->count;
433 dri2_process_buffers(dri2_surf, buffers, *out_count);
434
435 free(reply);
436
437 return dri2_surf->buffers;
438 }
439
440 static const char dri_driver_path[] = DEFAULT_DRIVER_DIR;
441
442 struct dri2_extension_match {
443 const char *name;
444 int version;
445 int offset;
446 };
447
448 static struct dri2_extension_match dri2_driver_extensions[] = {
449 { __DRI_CORE, 1, offsetof(struct dri2_egl_display, core) },
450 { __DRI_DRI2, 1, offsetof(struct dri2_egl_display, dri2) },
451 { NULL, 0, 0 }
452 };
453
454 static struct dri2_extension_match dri2_core_extensions[] = {
455 { __DRI2_FLUSH, 1, offsetof(struct dri2_egl_display, flush) },
456 { __DRI_TEX_BUFFER, 2, offsetof(struct dri2_egl_display, tex_buffer) },
457 { __DRI_IMAGE, 1, offsetof(struct dri2_egl_display, image) },
458 { NULL, 0, 0 }
459 };
460
461 static EGLBoolean
462 dri2_bind_extensions(struct dri2_egl_display *dri2_dpy,
463 struct dri2_extension_match *matches,
464 const __DRIextension **extensions)
465 {
466 int i, j, ret = EGL_TRUE;
467 void *field;
468
469 for (i = 0; extensions[i]; i++) {
470 _eglLog(_EGL_DEBUG, "DRI2: found extension `%s'", extensions[i]->name);
471 for (j = 0; matches[j].name; j++) {
472 if (strcmp(extensions[i]->name, matches[j].name) == 0 &&
473 extensions[i]->version >= matches[j].version) {
474 field = ((char *) dri2_dpy + matches[j].offset);
475 *(const __DRIextension **) field = extensions[i];
476 _eglLog(_EGL_INFO, "DRI2: found extension %s version %d",
477 extensions[i]->name, extensions[i]->version);
478 }
479 }
480 }
481
482 for (j = 0; matches[j].name; j++) {
483 field = ((char *) dri2_dpy + matches[j].offset);
484 if (*(const __DRIextension **) field == NULL) {
485 _eglLog(_EGL_FATAL, "DRI2: did not find extension %s version %d",
486 matches[j].name, matches[j].version);
487 ret = EGL_FALSE;
488 }
489 }
490
491 return ret;
492 }
493
494 static char *
495 dri2_strndup(const char *s, int length)
496 {
497 char *d;
498
499 d = malloc(length + 1);
500 if (d == NULL)
501 return NULL;
502
503 memcpy(d, s, length);
504 d[length] = '\0';
505
506 return d;
507 }
508
509 static EGLBoolean
510 dri2_connect(struct dri2_egl_display *dri2_dpy)
511 {
512 xcb_xfixes_query_version_reply_t *xfixes_query;
513 xcb_xfixes_query_version_cookie_t xfixes_query_cookie;
514 xcb_dri2_query_version_reply_t *dri2_query;
515 xcb_dri2_query_version_cookie_t dri2_query_cookie;
516 xcb_dri2_connect_reply_t *connect;
517 xcb_dri2_connect_cookie_t connect_cookie;
518 xcb_generic_error_t *error;
519 xcb_screen_iterator_t s;
520
521 xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_xfixes_id);
522 xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_dri2_id);
523
524 xfixes_query_cookie = xcb_xfixes_query_version(dri2_dpy->conn,
525 XCB_XFIXES_MAJOR_VERSION,
526 XCB_XFIXES_MINOR_VERSION);
527
528 dri2_query_cookie = xcb_dri2_query_version (dri2_dpy->conn,
529 XCB_DRI2_MAJOR_VERSION,
530 XCB_DRI2_MINOR_VERSION);
531
532 s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
533 connect_cookie = xcb_dri2_connect_unchecked (dri2_dpy->conn,
534 s.data->root,
535 XCB_DRI2_DRIVER_TYPE_DRI);
536
537 xfixes_query =
538 xcb_xfixes_query_version_reply (dri2_dpy->conn,
539 xfixes_query_cookie, &error);
540 if (xfixes_query == NULL ||
541 error != NULL || xfixes_query->major_version < 2) {
542 _eglLog(_EGL_FATAL, "DRI2: failed to query xfixes version");
543 free(error);
544 return EGL_FALSE;
545 }
546 free(xfixes_query);
547
548 dri2_query =
549 xcb_dri2_query_version_reply (dri2_dpy->conn, dri2_query_cookie, &error);
550 if (dri2_query == NULL || error != NULL) {
551 _eglLog(_EGL_FATAL, "DRI2: failed to query version");
552 free(error);
553 return EGL_FALSE;
554 }
555 dri2_dpy->dri2_major = dri2_query->major_version;
556 dri2_dpy->dri2_minor = dri2_query->minor_version;
557 free(dri2_query);
558
559 connect = xcb_dri2_connect_reply (dri2_dpy->conn, connect_cookie, NULL);
560 if (connect == NULL ||
561 connect->driver_name_length + connect->device_name_length == 0) {
562 _eglLog(_EGL_FATAL, "DRI2: failed to authenticate");
563 return EGL_FALSE;
564 }
565
566 dri2_dpy->device_name =
567 dri2_strndup(xcb_dri2_connect_device_name (connect),
568 xcb_dri2_connect_device_name_length (connect));
569
570 dri2_dpy->driver_name =
571 dri2_strndup(xcb_dri2_connect_driver_name (connect),
572 xcb_dri2_connect_driver_name_length (connect));
573
574 if (dri2_dpy->device_name == NULL || dri2_dpy->driver_name == NULL) {
575 free(dri2_dpy->device_name);
576 free(dri2_dpy->driver_name);
577 free(connect);
578 return EGL_FALSE;
579 }
580 free(connect);
581
582 return EGL_TRUE;
583 }
584
585 static EGLBoolean
586 dri2_authenticate(struct dri2_egl_display *dri2_dpy)
587 {
588 xcb_dri2_authenticate_reply_t *authenticate;
589 xcb_dri2_authenticate_cookie_t authenticate_cookie;
590 xcb_screen_iterator_t s;
591 drm_magic_t magic;
592
593 if (drmGetMagic(dri2_dpy->fd, &magic)) {
594 _eglLog(_EGL_FATAL, "DRI2: failed to get drm magic");
595 return EGL_FALSE;
596 }
597
598 s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
599 authenticate_cookie =
600 xcb_dri2_authenticate_unchecked(dri2_dpy->conn, s.data->root, magic);
601 authenticate =
602 xcb_dri2_authenticate_reply(dri2_dpy->conn, authenticate_cookie, NULL);
603 if (authenticate == NULL || !authenticate->authenticated) {
604 _eglLog(_EGL_FATAL, "DRI2: failed to authenticate");
605 free(authenticate);
606 return EGL_FALSE;
607 }
608
609 free(authenticate);
610
611 return EGL_TRUE;
612 }
613
614 static EGLBoolean
615 dri2_add_configs_for_visuals(struct dri2_egl_display *dri2_dpy,
616 _EGLDisplay *disp)
617 {
618 xcb_screen_iterator_t s;
619 xcb_depth_iterator_t d;
620 xcb_visualtype_t *visuals;
621 int i, j, id;
622 struct dri2_egl_config *conf;
623 EGLint surface_type;
624
625 s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
626 d = xcb_screen_allowed_depths_iterator(s.data);
627 id = 1;
628
629 surface_type =
630 EGL_WINDOW_BIT |
631 EGL_PIXMAP_BIT |
632 EGL_PBUFFER_BIT |
633 EGL_SWAP_BEHAVIOR_PRESERVED_BIT;
634
635 while (d.rem > 0) {
636 EGLBoolean class_added[6] = { 0, };
637
638 visuals = xcb_depth_visuals(d.data);
639 for (i = 0; i < xcb_depth_visuals_length(d.data); i++) {
640 if (class_added[visuals[i]._class])
641 continue;
642
643 class_added[visuals[i]._class] = EGL_TRUE;
644 for (j = 0; dri2_dpy->driver_configs[j]; j++) {
645 conf = dri2_add_config(disp, dri2_dpy->driver_configs[j],
646 id++, d.data->depth, surface_type);
647 if (conf == NULL)
648 continue;
649 _eglSetConfigKey(&conf->base,
650 EGL_NATIVE_VISUAL_ID, visuals[i].visual_id);
651 _eglSetConfigKey(&conf->base,
652 EGL_NATIVE_VISUAL_TYPE, visuals[i]._class);
653 }
654 }
655
656 xcb_depth_next(&d);
657 }
658
659 if (!_eglGetArraySize(disp->Configs)) {
660 _eglLog(_EGL_WARNING, "DRI2: failed to create any config");
661 return EGL_FALSE;
662 }
663
664 return EGL_TRUE;
665 }
666
667 static EGLBoolean
668 dri2_load_driver(_EGLDisplay *disp)
669 {
670 struct dri2_egl_display *dri2_dpy = disp->DriverData;
671 const __DRIextension **extensions;
672 char path[PATH_MAX], *search_paths, *p, *next, *end;
673
674 search_paths = NULL;
675 if (geteuid() == getuid()) {
676 /* don't allow setuid apps to use LIBGL_DRIVERS_PATH */
677 search_paths = getenv("LIBGL_DRIVERS_PATH");
678 }
679 if (search_paths == NULL)
680 search_paths = DEFAULT_DRIVER_DIR;
681
682 dri2_dpy->driver = NULL;
683 end = search_paths + strlen(search_paths);
684 for (p = search_paths; p < end && dri2_dpy->driver == NULL; p = next + 1) {
685 int len;
686 next = strchr(p, ':');
687 if (next == NULL)
688 next = end;
689
690 len = next - p;
691 #if GLX_USE_TLS
692 snprintf(path, sizeof path,
693 "%.*s/tls/%s_dri.so", len, p, dri2_dpy->driver_name);
694 dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
695 #endif
696 if (dri2_dpy->driver == NULL) {
697 snprintf(path, sizeof path,
698 "%.*s/%s_dri.so", len, p, dri2_dpy->driver_name);
699 dri2_dpy->driver = dlopen(path, RTLD_NOW | RTLD_GLOBAL);
700 if (dri2_dpy->driver == NULL)
701 _eglLog(_EGL_DEBUG, "failed to open %s: %s\n", path, dlerror());
702 }
703 }
704
705 if (dri2_dpy->driver == NULL) {
706 _eglLog(_EGL_WARNING,
707 "DRI2: failed to open any driver (search paths %s)",
708 search_paths);
709 return EGL_FALSE;
710 }
711
712 _eglLog(_EGL_DEBUG, "DRI2: dlopen(%s)", path);
713 extensions = dlsym(dri2_dpy->driver, __DRI_DRIVER_EXTENSIONS);
714 if (extensions == NULL) {
715 _eglLog(_EGL_WARNING,
716 "DRI2: driver exports no extensions (%s)", dlerror());
717 dlclose(dri2_dpy->driver);
718 return EGL_FALSE;
719 }
720
721 if (!dri2_bind_extensions(dri2_dpy, dri2_driver_extensions, extensions)) {
722 dlclose(dri2_dpy->driver);
723 return EGL_FALSE;
724 }
725
726 return EGL_TRUE;
727 }
728
729 static EGLBoolean
730 dri2_create_screen(_EGLDisplay *disp)
731 {
732 const __DRIextension **extensions;
733 struct dri2_egl_display *dri2_dpy;
734 unsigned int api_mask;
735
736 dri2_dpy = disp->DriverData;
737 dri2_dpy->dri_screen =
738 dri2_dpy->dri2->createNewScreen(0, dri2_dpy->fd, dri2_dpy->extensions,
739 &dri2_dpy->driver_configs, disp);
740
741 if (dri2_dpy->dri_screen == NULL) {
742 _eglLog(_EGL_WARNING, "DRI2: failed to create dri screen");
743 return EGL_FALSE;
744 }
745
746 extensions = dri2_dpy->core->getExtensions(dri2_dpy->dri_screen);
747 if (!dri2_bind_extensions(dri2_dpy, dri2_core_extensions, extensions))
748 goto cleanup_dri_screen;
749
750 if (dri2_dpy->dri2->base.version >= 2)
751 api_mask = dri2_dpy->dri2->getAPIMask(dri2_dpy->dri_screen);
752 else
753 api_mask = __DRI_API_OPENGL;
754
755 disp->ClientAPIsMask = 0;
756 if (api_mask & (1 <<__DRI_API_OPENGL))
757 disp->ClientAPIsMask |= EGL_OPENGL_BIT;
758 if (api_mask & (1 <<__DRI_API_GLES))
759 disp->ClientAPIsMask |= EGL_OPENGL_ES_BIT;
760 if (api_mask & (1 << __DRI_API_GLES2))
761 disp->ClientAPIsMask |= EGL_OPENGL_ES2_BIT;
762
763 if (dri2_dpy->dri2->base.version >= 2) {
764 disp->Extensions.KHR_surfaceless_gles1 = EGL_TRUE;
765 disp->Extensions.KHR_surfaceless_gles2 = EGL_TRUE;
766 disp->Extensions.KHR_surfaceless_opengl = EGL_TRUE;
767 }
768
769 return EGL_TRUE;
770
771 cleanup_dri_screen:
772 dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
773
774 return EGL_FALSE;
775 }
776
777 static EGLBoolean
778 dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp,
779 EGLint *major, EGLint *minor)
780 {
781 struct dri2_egl_display *dri2_dpy;
782
783 (void) drv;
784
785 dri2_dpy = malloc(sizeof *dri2_dpy);
786 if (!dri2_dpy)
787 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
788
789 disp->DriverData = (void *) dri2_dpy;
790 if (disp->PlatformDisplay == NULL) {
791 dri2_dpy->conn = xcb_connect(0, 0);
792 } else {
793 dri2_dpy->conn = XGetXCBConnection((Display *) disp->PlatformDisplay);
794 }
795
796 if (xcb_connection_has_error(dri2_dpy->conn)) {
797 _eglLog(_EGL_WARNING, "DRI2: xcb_connect failed");
798 goto cleanup_dpy;
799 }
800
801 if (dri2_dpy->conn) {
802 if (!dri2_connect(dri2_dpy))
803 goto cleanup_conn;
804 }
805
806 if (!dri2_load_driver(disp))
807 goto cleanup_conn;
808
809 dri2_dpy->fd = open(dri2_dpy->device_name, O_RDWR);
810 if (dri2_dpy->fd == -1) {
811 _eglLog(_EGL_WARNING,
812 "DRI2: could not open %s (%s)", dri2_dpy->device_name,
813 strerror(errno));
814 goto cleanup_driver;
815 }
816
817 if (dri2_dpy->conn) {
818 if (!dri2_authenticate(dri2_dpy))
819 goto cleanup_fd;
820 }
821
822 if (dri2_dpy->dri2_minor >= 1) {
823 dri2_dpy->loader_extension.base.name = __DRI_DRI2_LOADER;
824 dri2_dpy->loader_extension.base.version = 3;
825 dri2_dpy->loader_extension.getBuffers = dri2_get_buffers;
826 dri2_dpy->loader_extension.flushFrontBuffer = dri2_flush_front_buffer;
827 dri2_dpy->loader_extension.getBuffersWithFormat =
828 dri2_get_buffers_with_format;
829 } else {
830 dri2_dpy->loader_extension.base.name = __DRI_DRI2_LOADER;
831 dri2_dpy->loader_extension.base.version = 2;
832 dri2_dpy->loader_extension.getBuffers = dri2_get_buffers;
833 dri2_dpy->loader_extension.flushFrontBuffer = dri2_flush_front_buffer;
834 dri2_dpy->loader_extension.getBuffersWithFormat = NULL;
835 }
836
837 dri2_dpy->extensions[0] = &dri2_dpy->loader_extension.base;
838 dri2_dpy->extensions[1] = &image_lookup_extension.base;
839 dri2_dpy->extensions[2] = NULL;
840
841 if (!dri2_create_screen(disp))
842 goto cleanup_fd;
843
844 if (dri2_dpy->conn) {
845 if (!dri2_add_configs_for_visuals(dri2_dpy, disp))
846 goto cleanup_configs;
847 }
848
849 disp->Extensions.MESA_drm_image = EGL_TRUE;
850 disp->Extensions.KHR_image_base = EGL_TRUE;
851 disp->Extensions.KHR_image_pixmap = EGL_TRUE;
852 disp->Extensions.KHR_gl_renderbuffer_image = EGL_TRUE;
853 disp->Extensions.KHR_gl_texture_2D_image = EGL_TRUE;
854 disp->Extensions.NOK_swap_region = EGL_TRUE;
855 disp->Extensions.NOK_texture_from_pixmap = EGL_TRUE;
856
857 /* we're supporting EGL 1.4 */
858 *major = 1;
859 *minor = 4;
860
861 return EGL_TRUE;
862
863 cleanup_configs:
864 _eglCleanupDisplay(disp);
865 dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
866 cleanup_fd:
867 close(dri2_dpy->fd);
868 cleanup_driver:
869 dlclose(dri2_dpy->driver);
870 cleanup_conn:
871 if (disp->PlatformDisplay == NULL)
872 xcb_disconnect(dri2_dpy->conn);
873 cleanup_dpy:
874 free(dri2_dpy);
875
876 return EGL_FALSE;
877 }
878
879 #ifdef HAVE_LIBUDEV
880
881 struct dri2_driver_map {
882 int vendor_id;
883 const char *driver;
884 const int *chip_ids;
885 int num_chips_ids;
886 };
887
888 const int i915_chip_ids[] = {
889 0x3577, /* PCI_CHIP_I830_M */
890 0x2562, /* PCI_CHIP_845_G */
891 0x3582, /* PCI_CHIP_I855_GM */
892 0x2572, /* PCI_CHIP_I865_G */
893 0x2582, /* PCI_CHIP_I915_G */
894 0x258a, /* PCI_CHIP_E7221_G */
895 0x2592, /* PCI_CHIP_I915_GM */
896 0x2772, /* PCI_CHIP_I945_G */
897 0x27a2, /* PCI_CHIP_I945_GM */
898 0x27ae, /* PCI_CHIP_I945_GME */
899 0x29b2, /* PCI_CHIP_Q35_G */
900 0x29c2, /* PCI_CHIP_G33_G */
901 0x29d2, /* PCI_CHIP_Q33_G */
902 0xa011, /* Pineview */
903 };
904
905 const int i965_chip_ids[] = {
906 0x29a2, /* PCI_CHIP_I965_G */
907 0x2992, /* PCI_CHIP_I965_Q */
908 0x2982, /* PCI_CHIP_I965_G_1 */
909 0x2972, /* PCI_CHIP_I946_GZ */
910 0x2a02, /* PCI_CHIP_I965_GM */
911 0x2a12, /* PCI_CHIP_I965_GME */
912 0x2a42, /* PCI_CHIP_GM45_GM */
913 0x2e02, /* PCI_CHIP_IGD_E_G */
914 0x2e12, /* PCI_CHIP_Q45_G */
915 0x2e22, /* PCI_CHIP_G45_G */
916 0x2e32, /* PCI_CHIP_G41_G */
917 };
918
919 const int r100_chip_ids[] = {
920 0x4C57, /* PCI_CHIP_RADEON_LW */
921 0x4C58, /* PCI_CHIP_RADEON_LX */
922 0x4C59, /* PCI_CHIP_RADEON_LY */
923 0x4C5A, /* PCI_CHIP_RADEON_LZ */
924 0x5144, /* PCI_CHIP_RADEON_QD */
925 0x5145, /* PCI_CHIP_RADEON_QE */
926 0x5146, /* PCI_CHIP_RADEON_QF */
927 0x5147, /* PCI_CHIP_RADEON_QG */
928 0x5159, /* PCI_CHIP_RADEON_QY */
929 0x515A, /* PCI_CHIP_RADEON_QZ */
930 0x5157, /* PCI_CHIP_RV200_QW */
931 0x5158, /* PCI_CHIP_RV200_QX */
932 0x515E, /* PCI_CHIP_RN50_515E */
933 0x5969, /* PCI_CHIP_RN50_5969 */
934 0x4136, /* PCI_CHIP_RS100_4136 */
935 0x4336, /* PCI_CHIP_RS100_4336 */
936 0x4137, /* PCI_CHIP_RS200_4137 */
937 0x4337, /* PCI_CHIP_RS200_4337 */
938 0x4237, /* PCI_CHIP_RS250_4237 */
939 0x4437, /* PCI_CHIP_RS250_4437 */
940 };
941
942 const int r200_chip_ids[] = {
943 0x5148, /* PCI_CHIP_R200_QH */
944 0x514C, /* PCI_CHIP_R200_QL */
945 0x514D, /* PCI_CHIP_R200_QM */
946 0x4242, /* PCI_CHIP_R200_BB */
947 0x4243, /* PCI_CHIP_R200_BC */
948 0x4966, /* PCI_CHIP_RV250_If */
949 0x4967, /* PCI_CHIP_RV250_Ig */
950 0x4C64, /* PCI_CHIP_RV250_Ld */
951 0x4C66, /* PCI_CHIP_RV250_Lf */
952 0x4C67, /* PCI_CHIP_RV250_Lg */
953 0x5960, /* PCI_CHIP_RV280_5960 */
954 0x5961, /* PCI_CHIP_RV280_5961 */
955 0x5962, /* PCI_CHIP_RV280_5962 */
956 0x5964, /* PCI_CHIP_RV280_5964 */
957 0x5965, /* PCI_CHIP_RV280_5965 */
958 0x5C61, /* PCI_CHIP_RV280_5C61 */
959 0x5C63, /* PCI_CHIP_RV280_5C63 */
960 0x5834, /* PCI_CHIP_RS300_5834 */
961 0x5835, /* PCI_CHIP_RS300_5835 */
962 0x7834, /* PCI_CHIP_RS350_7834 */
963 0x7835, /* PCI_CHIP_RS350_7835 */
964 };
965
966 const int r300_chip_ids[] = {
967 0x4144, /* PCI_CHIP_R300_AD */
968 0x4145, /* PCI_CHIP_R300_AE */
969 0x4146, /* PCI_CHIP_R300_AF */
970 0x4147, /* PCI_CHIP_R300_AG */
971 0x4E44, /* PCI_CHIP_R300_ND */
972 0x4E45, /* PCI_CHIP_R300_NE */
973 0x4E46, /* PCI_CHIP_R300_NF */
974 0x4E47, /* PCI_CHIP_R300_NG */
975 0x4E48, /* PCI_CHIP_R350_NH */
976 0x4E49, /* PCI_CHIP_R350_NI */
977 0x4E4B, /* PCI_CHIP_R350_NK */
978 0x4148, /* PCI_CHIP_R350_AH */
979 0x4149, /* PCI_CHIP_R350_AI */
980 0x414A, /* PCI_CHIP_R350_AJ */
981 0x414B, /* PCI_CHIP_R350_AK */
982 0x4E4A, /* PCI_CHIP_R360_NJ */
983 0x4150, /* PCI_CHIP_RV350_AP */
984 0x4151, /* PCI_CHIP_RV350_AQ */
985 0x4152, /* PCI_CHIP_RV350_AR */
986 0x4153, /* PCI_CHIP_RV350_AS */
987 0x4154, /* PCI_CHIP_RV350_AT */
988 0x4155, /* PCI_CHIP_RV350_AU */
989 0x4156, /* PCI_CHIP_RV350_AV */
990 0x4E50, /* PCI_CHIP_RV350_NP */
991 0x4E51, /* PCI_CHIP_RV350_NQ */
992 0x4E52, /* PCI_CHIP_RV350_NR */
993 0x4E53, /* PCI_CHIP_RV350_NS */
994 0x4E54, /* PCI_CHIP_RV350_NT */
995 0x4E56, /* PCI_CHIP_RV350_NV */
996 0x5460, /* PCI_CHIP_RV370_5460 */
997 0x5462, /* PCI_CHIP_RV370_5462 */
998 0x5464, /* PCI_CHIP_RV370_5464 */
999 0x5B60, /* PCI_CHIP_RV370_5B60 */
1000 0x5B62, /* PCI_CHIP_RV370_5B62 */
1001 0x5B63, /* PCI_CHIP_RV370_5B63 */
1002 0x5B64, /* PCI_CHIP_RV370_5B64 */
1003 0x5B65, /* PCI_CHIP_RV370_5B65 */
1004 0x3150, /* PCI_CHIP_RV380_3150 */
1005 0x3152, /* PCI_CHIP_RV380_3152 */
1006 0x3154, /* PCI_CHIP_RV380_3154 */
1007 0x3155, /* PCI_CHIP_RV380_3155 */
1008 0x3E50, /* PCI_CHIP_RV380_3E50 */
1009 0x3E54, /* PCI_CHIP_RV380_3E54 */
1010 0x4A48, /* PCI_CHIP_R420_JH */
1011 0x4A49, /* PCI_CHIP_R420_JI */
1012 0x4A4A, /* PCI_CHIP_R420_JJ */
1013 0x4A4B, /* PCI_CHIP_R420_JK */
1014 0x4A4C, /* PCI_CHIP_R420_JL */
1015 0x4A4D, /* PCI_CHIP_R420_JM */
1016 0x4A4E, /* PCI_CHIP_R420_JN */
1017 0x4A4F, /* PCI_CHIP_R420_JO */
1018 0x4A50, /* PCI_CHIP_R420_JP */
1019 0x4A54, /* PCI_CHIP_R420_JT */
1020 0x5548, /* PCI_CHIP_R423_UH */
1021 0x5549, /* PCI_CHIP_R423_UI */
1022 0x554A, /* PCI_CHIP_R423_UJ */
1023 0x554B, /* PCI_CHIP_R423_UK */
1024 0x5550, /* PCI_CHIP_R423_5550 */
1025 0x5551, /* PCI_CHIP_R423_UQ */
1026 0x5552, /* PCI_CHIP_R423_UR */
1027 0x5554, /* PCI_CHIP_R423_UT */
1028 0x5D57, /* PCI_CHIP_R423_5D57 */
1029 0x554C, /* PCI_CHIP_R430_554C */
1030 0x554D, /* PCI_CHIP_R430_554D */
1031 0x554E, /* PCI_CHIP_R430_554E */
1032 0x554F, /* PCI_CHIP_R430_554F */
1033 0x5D48, /* PCI_CHIP_R430_5D48 */
1034 0x5D49, /* PCI_CHIP_R430_5D49 */
1035 0x5D4A, /* PCI_CHIP_R430_5D4A */
1036 0x5D4C, /* PCI_CHIP_R480_5D4C */
1037 0x5D4D, /* PCI_CHIP_R480_5D4D */
1038 0x5D4E, /* PCI_CHIP_R480_5D4E */
1039 0x5D4F, /* PCI_CHIP_R480_5D4F */
1040 0x5D50, /* PCI_CHIP_R480_5D50 */
1041 0x5D52, /* PCI_CHIP_R480_5D52 */
1042 0x4B49, /* PCI_CHIP_R481_4B49 */
1043 0x4B4A, /* PCI_CHIP_R481_4B4A */
1044 0x4B4B, /* PCI_CHIP_R481_4B4B */
1045 0x4B4C, /* PCI_CHIP_R481_4B4C */
1046 0x564A, /* PCI_CHIP_RV410_564A */
1047 0x564B, /* PCI_CHIP_RV410_564B */
1048 0x564F, /* PCI_CHIP_RV410_564F */
1049 0x5652, /* PCI_CHIP_RV410_5652 */
1050 0x5653, /* PCI_CHIP_RV410_5653 */
1051 0x5657, /* PCI_CHIP_RV410_5657 */
1052 0x5E48, /* PCI_CHIP_RV410_5E48 */
1053 0x5E4A, /* PCI_CHIP_RV410_5E4A */
1054 0x5E4B, /* PCI_CHIP_RV410_5E4B */
1055 0x5E4C, /* PCI_CHIP_RV410_5E4C */
1056 0x5E4D, /* PCI_CHIP_RV410_5E4D */
1057 0x5E4F, /* PCI_CHIP_RV410_5E4F */
1058 0x5A41, /* PCI_CHIP_RS400_5A41 */
1059 0x5A42, /* PCI_CHIP_RS400_5A42 */
1060 0x5A61, /* PCI_CHIP_RC410_5A61 */
1061 0x5A62, /* PCI_CHIP_RC410_5A62 */
1062 0x5954, /* PCI_CHIP_RS480_5954 */
1063 0x5955, /* PCI_CHIP_RS480_5955 */
1064 0x5974, /* PCI_CHIP_RS482_5974 */
1065 0x5975, /* PCI_CHIP_RS482_5975 */
1066 0x7100, /* PCI_CHIP_R520_7100 */
1067 0x7101, /* PCI_CHIP_R520_7101 */
1068 0x7102, /* PCI_CHIP_R520_7102 */
1069 0x7103, /* PCI_CHIP_R520_7103 */
1070 0x7104, /* PCI_CHIP_R520_7104 */
1071 0x7105, /* PCI_CHIP_R520_7105 */
1072 0x7106, /* PCI_CHIP_R520_7106 */
1073 0x7108, /* PCI_CHIP_R520_7108 */
1074 0x7109, /* PCI_CHIP_R520_7109 */
1075 0x710A, /* PCI_CHIP_R520_710A */
1076 0x710B, /* PCI_CHIP_R520_710B */
1077 0x710C, /* PCI_CHIP_R520_710C */
1078 0x710E, /* PCI_CHIP_R520_710E */
1079 0x710F, /* PCI_CHIP_R520_710F */
1080 0x7140, /* PCI_CHIP_RV515_7140 */
1081 0x7141, /* PCI_CHIP_RV515_7141 */
1082 0x7142, /* PCI_CHIP_RV515_7142 */
1083 0x7143, /* PCI_CHIP_RV515_7143 */
1084 0x7144, /* PCI_CHIP_RV515_7144 */
1085 0x7145, /* PCI_CHIP_RV515_7145 */
1086 0x7146, /* PCI_CHIP_RV515_7146 */
1087 0x7147, /* PCI_CHIP_RV515_7147 */
1088 0x7149, /* PCI_CHIP_RV515_7149 */
1089 0x714A, /* PCI_CHIP_RV515_714A */
1090 0x714B, /* PCI_CHIP_RV515_714B */
1091 0x714C, /* PCI_CHIP_RV515_714C */
1092 0x714D, /* PCI_CHIP_RV515_714D */
1093 0x714E, /* PCI_CHIP_RV515_714E */
1094 0x714F, /* PCI_CHIP_RV515_714F */
1095 0x7151, /* PCI_CHIP_RV515_7151 */
1096 0x7152, /* PCI_CHIP_RV515_7152 */
1097 0x7153, /* PCI_CHIP_RV515_7153 */
1098 0x715E, /* PCI_CHIP_RV515_715E */
1099 0x715F, /* PCI_CHIP_RV515_715F */
1100 0x7180, /* PCI_CHIP_RV515_7180 */
1101 0x7181, /* PCI_CHIP_RV515_7181 */
1102 0x7183, /* PCI_CHIP_RV515_7183 */
1103 0x7186, /* PCI_CHIP_RV515_7186 */
1104 0x7187, /* PCI_CHIP_RV515_7187 */
1105 0x7188, /* PCI_CHIP_RV515_7188 */
1106 0x718A, /* PCI_CHIP_RV515_718A */
1107 0x718B, /* PCI_CHIP_RV515_718B */
1108 0x718C, /* PCI_CHIP_RV515_718C */
1109 0x718D, /* PCI_CHIP_RV515_718D */
1110 0x718F, /* PCI_CHIP_RV515_718F */
1111 0x7193, /* PCI_CHIP_RV515_7193 */
1112 0x7196, /* PCI_CHIP_RV515_7196 */
1113 0x719B, /* PCI_CHIP_RV515_719B */
1114 0x719F, /* PCI_CHIP_RV515_719F */
1115 0x7200, /* PCI_CHIP_RV515_7200 */
1116 0x7210, /* PCI_CHIP_RV515_7210 */
1117 0x7211, /* PCI_CHIP_RV515_7211 */
1118 0x71C0, /* PCI_CHIP_RV530_71C0 */
1119 0x71C1, /* PCI_CHIP_RV530_71C1 */
1120 0x71C2, /* PCI_CHIP_RV530_71C2 */
1121 0x71C3, /* PCI_CHIP_RV530_71C3 */
1122 0x71C4, /* PCI_CHIP_RV530_71C4 */
1123 0x71C5, /* PCI_CHIP_RV530_71C5 */
1124 0x71C6, /* PCI_CHIP_RV530_71C6 */
1125 0x71C7, /* PCI_CHIP_RV530_71C7 */
1126 0x71CD, /* PCI_CHIP_RV530_71CD */
1127 0x71CE, /* PCI_CHIP_RV530_71CE */
1128 0x71D2, /* PCI_CHIP_RV530_71D2 */
1129 0x71D4, /* PCI_CHIP_RV530_71D4 */
1130 0x71D5, /* PCI_CHIP_RV530_71D5 */
1131 0x71D6, /* PCI_CHIP_RV530_71D6 */
1132 0x71DA, /* PCI_CHIP_RV530_71DA */
1133 0x71DE, /* PCI_CHIP_RV530_71DE */
1134 0x7281, /* PCI_CHIP_RV560_7281 */
1135 0x7283, /* PCI_CHIP_RV560_7283 */
1136 0x7287, /* PCI_CHIP_RV560_7287 */
1137 0x7290, /* PCI_CHIP_RV560_7290 */
1138 0x7291, /* PCI_CHIP_RV560_7291 */
1139 0x7293, /* PCI_CHIP_RV560_7293 */
1140 0x7297, /* PCI_CHIP_RV560_7297 */
1141 0x7280, /* PCI_CHIP_RV570_7280 */
1142 0x7288, /* PCI_CHIP_RV570_7288 */
1143 0x7289, /* PCI_CHIP_RV570_7289 */
1144 0x728B, /* PCI_CHIP_RV570_728B */
1145 0x728C, /* PCI_CHIP_RV570_728C */
1146 0x7240, /* PCI_CHIP_R580_7240 */
1147 0x7243, /* PCI_CHIP_R580_7243 */
1148 0x7244, /* PCI_CHIP_R580_7244 */
1149 0x7245, /* PCI_CHIP_R580_7245 */
1150 0x7246, /* PCI_CHIP_R580_7246 */
1151 0x7247, /* PCI_CHIP_R580_7247 */
1152 0x7248, /* PCI_CHIP_R580_7248 */
1153 0x7249, /* PCI_CHIP_R580_7249 */
1154 0x724A, /* PCI_CHIP_R580_724A */
1155 0x724B, /* PCI_CHIP_R580_724B */
1156 0x724C, /* PCI_CHIP_R580_724C */
1157 0x724D, /* PCI_CHIP_R580_724D */
1158 0x724E, /* PCI_CHIP_R580_724E */
1159 0x724F, /* PCI_CHIP_R580_724F */
1160 0x7284, /* PCI_CHIP_R580_7284 */
1161 0x793F, /* PCI_CHIP_RS600_793F */
1162 0x7941, /* PCI_CHIP_RS600_7941 */
1163 0x7942, /* PCI_CHIP_RS600_7942 */
1164 0x791E, /* PCI_CHIP_RS690_791E */
1165 0x791F, /* PCI_CHIP_RS690_791F */
1166 0x796C, /* PCI_CHIP_RS740_796C */
1167 0x796D, /* PCI_CHIP_RS740_796D */
1168 0x796E, /* PCI_CHIP_RS740_796E */
1169 0x796F, /* PCI_CHIP_RS740_796F */
1170 };
1171
1172 const int r600_chip_ids[] = {
1173 0x9400, /* PCI_CHIP_R600_9400 */
1174 0x9401, /* PCI_CHIP_R600_9401 */
1175 0x9402, /* PCI_CHIP_R600_9402 */
1176 0x9403, /* PCI_CHIP_R600_9403 */
1177 0x9405, /* PCI_CHIP_R600_9405 */
1178 0x940A, /* PCI_CHIP_R600_940A */
1179 0x940B, /* PCI_CHIP_R600_940B */
1180 0x940F, /* PCI_CHIP_R600_940F */
1181 0x94C0, /* PCI_CHIP_RV610_94C0 */
1182 0x94C1, /* PCI_CHIP_RV610_94C1 */
1183 0x94C3, /* PCI_CHIP_RV610_94C3 */
1184 0x94C4, /* PCI_CHIP_RV610_94C4 */
1185 0x94C5, /* PCI_CHIP_RV610_94C5 */
1186 0x94C6, /* PCI_CHIP_RV610_94C6 */
1187 0x94C7, /* PCI_CHIP_RV610_94C7 */
1188 0x94C8, /* PCI_CHIP_RV610_94C8 */
1189 0x94C9, /* PCI_CHIP_RV610_94C9 */
1190 0x94CB, /* PCI_CHIP_RV610_94CB */
1191 0x94CC, /* PCI_CHIP_RV610_94CC */
1192 0x94CD, /* PCI_CHIP_RV610_94CD */
1193 0x9580, /* PCI_CHIP_RV630_9580 */
1194 0x9581, /* PCI_CHIP_RV630_9581 */
1195 0x9583, /* PCI_CHIP_RV630_9583 */
1196 0x9586, /* PCI_CHIP_RV630_9586 */
1197 0x9587, /* PCI_CHIP_RV630_9587 */
1198 0x9588, /* PCI_CHIP_RV630_9588 */
1199 0x9589, /* PCI_CHIP_RV630_9589 */
1200 0x958A, /* PCI_CHIP_RV630_958A */
1201 0x958B, /* PCI_CHIP_RV630_958B */
1202 0x958C, /* PCI_CHIP_RV630_958C */
1203 0x958D, /* PCI_CHIP_RV630_958D */
1204 0x958E, /* PCI_CHIP_RV630_958E */
1205 0x958F, /* PCI_CHIP_RV630_958F */
1206 0x9500, /* PCI_CHIP_RV670_9500 */
1207 0x9501, /* PCI_CHIP_RV670_9501 */
1208 0x9504, /* PCI_CHIP_RV670_9504 */
1209 0x9505, /* PCI_CHIP_RV670_9505 */
1210 0x9506, /* PCI_CHIP_RV670_9506 */
1211 0x9507, /* PCI_CHIP_RV670_9507 */
1212 0x9508, /* PCI_CHIP_RV670_9508 */
1213 0x9509, /* PCI_CHIP_RV670_9509 */
1214 0x950F, /* PCI_CHIP_RV670_950F */
1215 0x9511, /* PCI_CHIP_RV670_9511 */
1216 0x9515, /* PCI_CHIP_RV670_9515 */
1217 0x9517, /* PCI_CHIP_RV670_9517 */
1218 0x9519, /* PCI_CHIP_RV670_9519 */
1219 0x95C0, /* PCI_CHIP_RV620_95C0 */
1220 0x95C2, /* PCI_CHIP_RV620_95C2 */
1221 0x95C4, /* PCI_CHIP_RV620_95C4 */
1222 0x95C5, /* PCI_CHIP_RV620_95C5 */
1223 0x95C6, /* PCI_CHIP_RV620_95C6 */
1224 0x95C7, /* PCI_CHIP_RV620_95C7 */
1225 0x95C9, /* PCI_CHIP_RV620_95C9 */
1226 0x95CC, /* PCI_CHIP_RV620_95CC */
1227 0x95CD, /* PCI_CHIP_RV620_95CD */
1228 0x95CE, /* PCI_CHIP_RV620_95CE */
1229 0x95CF, /* PCI_CHIP_RV620_95CF */
1230 0x9590, /* PCI_CHIP_RV635_9590 */
1231 0x9591, /* PCI_CHIP_RV635_9591 */
1232 0x9593, /* PCI_CHIP_RV635_9593 */
1233 0x9595, /* PCI_CHIP_RV635_9595 */
1234 0x9596, /* PCI_CHIP_RV635_9596 */
1235 0x9597, /* PCI_CHIP_RV635_9597 */
1236 0x9598, /* PCI_CHIP_RV635_9598 */
1237 0x9599, /* PCI_CHIP_RV635_9599 */
1238 0x959B, /* PCI_CHIP_RV635_959B */
1239 0x9610, /* PCI_CHIP_RS780_9610 */
1240 0x9611, /* PCI_CHIP_RS780_9611 */
1241 0x9612, /* PCI_CHIP_RS780_9612 */
1242 0x9613, /* PCI_CHIP_RS780_9613 */
1243 0x9614, /* PCI_CHIP_RS780_9614 */
1244 0x9615, /* PCI_CHIP_RS780_9615 */
1245 0x9616, /* PCI_CHIP_RS780_9616 */
1246 0x9710, /* PCI_CHIP_RS880_9710 */
1247 0x9711, /* PCI_CHIP_RS880_9711 */
1248 0x9712, /* PCI_CHIP_RS880_9712 */
1249 0x9713, /* PCI_CHIP_RS880_9713 */
1250 0x9714, /* PCI_CHIP_RS880_9714 */
1251 0x9715, /* PCI_CHIP_RS880_9715 */
1252 0x9440, /* PCI_CHIP_RV770_9440 */
1253 0x9441, /* PCI_CHIP_RV770_9441 */
1254 0x9442, /* PCI_CHIP_RV770_9442 */
1255 0x9443, /* PCI_CHIP_RV770_9443 */
1256 0x9444, /* PCI_CHIP_RV770_9444 */
1257 0x9446, /* PCI_CHIP_RV770_9446 */
1258 0x944A, /* PCI_CHIP_RV770_944A */
1259 0x944B, /* PCI_CHIP_RV770_944B */
1260 0x944C, /* PCI_CHIP_RV770_944C */
1261 0x944E, /* PCI_CHIP_RV770_944E */
1262 0x9450, /* PCI_CHIP_RV770_9450 */
1263 0x9452, /* PCI_CHIP_RV770_9452 */
1264 0x9456, /* PCI_CHIP_RV770_9456 */
1265 0x945A, /* PCI_CHIP_RV770_945A */
1266 0x945B, /* PCI_CHIP_RV770_945B */
1267 0x945E, /* PCI_CHIP_RV770_945E */
1268 0x9460, /* PCI_CHIP_RV790_9460 */
1269 0x9462, /* PCI_CHIP_RV790_9462 */
1270 0x946A, /* PCI_CHIP_RV770_946A */
1271 0x946B, /* PCI_CHIP_RV770_946B */
1272 0x947A, /* PCI_CHIP_RV770_947A */
1273 0x947B, /* PCI_CHIP_RV770_947B */
1274 0x9480, /* PCI_CHIP_RV730_9480 */
1275 0x9487, /* PCI_CHIP_RV730_9487 */
1276 0x9488, /* PCI_CHIP_RV730_9488 */
1277 0x9489, /* PCI_CHIP_RV730_9489 */
1278 0x948A, /* PCI_CHIP_RV730_948A */
1279 0x948F, /* PCI_CHIP_RV730_948F */
1280 0x9490, /* PCI_CHIP_RV730_9490 */
1281 0x9491, /* PCI_CHIP_RV730_9491 */
1282 0x9495, /* PCI_CHIP_RV730_9495 */
1283 0x9498, /* PCI_CHIP_RV730_9498 */
1284 0x949C, /* PCI_CHIP_RV730_949C */
1285 0x949E, /* PCI_CHIP_RV730_949E */
1286 0x949F, /* PCI_CHIP_RV730_949F */
1287 0x9540, /* PCI_CHIP_RV710_9540 */
1288 0x9541, /* PCI_CHIP_RV710_9541 */
1289 0x9542, /* PCI_CHIP_RV710_9542 */
1290 0x954E, /* PCI_CHIP_RV710_954E */
1291 0x954F, /* PCI_CHIP_RV710_954F */
1292 0x9552, /* PCI_CHIP_RV710_9552 */
1293 0x9553, /* PCI_CHIP_RV710_9553 */
1294 0x9555, /* PCI_CHIP_RV710_9555 */
1295 0x9557, /* PCI_CHIP_RV710_9557 */
1296 0x955F, /* PCI_CHIP_RV710_955F */
1297 0x94A0, /* PCI_CHIP_RV740_94A0 */
1298 0x94A1, /* PCI_CHIP_RV740_94A1 */
1299 0x94A3, /* PCI_CHIP_RV740_94A3 */
1300 0x94B1, /* PCI_CHIP_RV740_94B1 */
1301 0x94B3, /* PCI_CHIP_RV740_94B3 */
1302 0x94B4, /* PCI_CHIP_RV740_94B4 */
1303 0x94B5, /* PCI_CHIP_RV740_94B5 */
1304 0x94B9, /* PCI_CHIP_RV740_94B9 */
1305 0x68E0, /* PCI_CHIP_CEDAR_68E0 */
1306 0x68E1, /* PCI_CHIP_CEDAR_68E1 */
1307 0x68E4, /* PCI_CHIP_CEDAR_68E4 */
1308 0x68E5, /* PCI_CHIP_CEDAR_68E5 */
1309 0x68E8, /* PCI_CHIP_CEDAR_68E8 */
1310 0x68E9, /* PCI_CHIP_CEDAR_68E9 */
1311 0x68F1, /* PCI_CHIP_CEDAR_68F1 */
1312 0x68F8, /* PCI_CHIP_CEDAR_68F8 */
1313 0x68F9, /* PCI_CHIP_CEDAR_68F9 */
1314 0x68FE, /* PCI_CHIP_CEDAR_68FE */
1315 0x68C0, /* PCI_CHIP_REDWOOD_68C0 */
1316 0x68C1, /* PCI_CHIP_REDWOOD_68C1 */
1317 0x68C8, /* PCI_CHIP_REDWOOD_68C8 */
1318 0x68C9, /* PCI_CHIP_REDWOOD_68C9 */
1319 0x68D8, /* PCI_CHIP_REDWOOD_68D8 */
1320 0x68D9, /* PCI_CHIP_REDWOOD_68D9 */
1321 0x68DA, /* PCI_CHIP_REDWOOD_68DA */
1322 0x68DE, /* PCI_CHIP_REDWOOD_68DE */
1323 0x68A0, /* PCI_CHIP_JUNIPER_68A0 */
1324 0x68A1, /* PCI_CHIP_JUNIPER_68A1 */
1325 0x68A8, /* PCI_CHIP_JUNIPER_68A8 */
1326 0x68A9, /* PCI_CHIP_JUNIPER_68A9 */
1327 0x68B0, /* PCI_CHIP_JUNIPER_68B0 */
1328 0x68B8, /* PCI_CHIP_JUNIPER_68B8 */
1329 0x68B9, /* PCI_CHIP_JUNIPER_68B9 */
1330 0x68BE, /* PCI_CHIP_JUNIPER_68BE */
1331 0x6880, /* PCI_CHIP_CYPRESS_6880 */
1332 0x6888, /* PCI_CHIP_CYPRESS_6888 */
1333 0x6889, /* PCI_CHIP_CYPRESS_6889 */
1334 0x688A, /* PCI_CHIP_CYPRESS_688A */
1335 0x6898, /* PCI_CHIP_CYPRESS_6898 */
1336 0x6899, /* PCI_CHIP_CYPRESS_6899 */
1337 0x689E, /* PCI_CHIP_CYPRESS_689E */
1338 0x689C, /* PCI_CHIP_HEMLOCK_689C */
1339 0x689D, /* PCI_CHIP_HEMLOCK_689D */
1340 };
1341
1342 const struct dri2_driver_map driver_map[] = {
1343 { 0x8086, "i915", i915_chip_ids, ARRAY_SIZE(i915_chip_ids) },
1344 { 0x8086, "i965", i965_chip_ids, ARRAY_SIZE(i965_chip_ids) },
1345 { 0x1002, "radeon", r100_chip_ids, ARRAY_SIZE(r100_chip_ids) },
1346 { 0x1002, "r200", r200_chip_ids, ARRAY_SIZE(r200_chip_ids) },
1347 { 0x1002, "r300", r300_chip_ids, ARRAY_SIZE(r300_chip_ids) },
1348 { 0x1002, "r600", r600_chip_ids, ARRAY_SIZE(r600_chip_ids) },
1349 };
1350
1351 static char *
1352 dri2_get_driver_for_fd(int fd)
1353 {
1354 struct udev *udev;
1355 struct udev_device *device, *parent;
1356 struct stat buf;
1357 const char *pci_id;
1358 char *driver = NULL;
1359 int vendor_id, chip_id, i, j;
1360
1361 udev = udev_new();
1362 if (fstat(fd, &buf) < 0) {
1363 _eglLog(_EGL_WARNING, "EGL-DRI2: failed to stat fd %d", fd);
1364 goto out;
1365 }
1366
1367 device = udev_device_new_from_devnum(udev, 'c', buf.st_rdev);
1368 if (device == NULL) {
1369 _eglLog(_EGL_WARNING,
1370 "EGL-DRI2: could not create udev device for fd %d", fd);
1371 goto out;
1372 }
1373
1374 parent = udev_device_get_parent(device);
1375 if (parent == NULL) {
1376 _eglLog(_EGL_WARNING, "DRI2: could not get parent device");
1377 goto out;
1378 }
1379
1380 pci_id = udev_device_get_property_value(parent, "PCI_ID");
1381 if (pci_id == NULL || sscanf(pci_id, "%x:%x", &vendor_id, &chip_id) != 2) {
1382 _eglLog(_EGL_WARNING, "EGL-DRI2: malformed or no PCI ID");
1383 goto out;
1384 }
1385
1386 for (i = 0; i < ARRAY_SIZE(driver_map); i++) {
1387 if (vendor_id != driver_map[i].vendor_id)
1388 continue;
1389 for (j = 0; j < driver_map[i].num_chips_ids; j++)
1390 if (driver_map[i].chip_ids[j] == chip_id) {
1391 driver = strdup(driver_map[i].driver);
1392 _eglLog(_EGL_DEBUG, "pci id for %d: %04x:%04x, driver %s",
1393 fd, vendor_id, chip_id, driver);
1394 goto out;
1395 }
1396 }
1397
1398 out:
1399 udev_device_unref(device);
1400 udev_unref(udev);
1401
1402 return driver;
1403 }
1404
1405 static EGLBoolean
1406 dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp,
1407 EGLint *major, EGLint *minor)
1408 {
1409 struct dri2_egl_display *dri2_dpy;
1410 int i;
1411
1412 dri2_dpy = malloc(sizeof *dri2_dpy);
1413 if (!dri2_dpy)
1414 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1415
1416 disp->DriverData = (void *) dri2_dpy;
1417 dri2_dpy->fd = (int) disp->PlatformDisplay;
1418
1419 dri2_dpy->driver_name = dri2_get_driver_for_fd(dri2_dpy->fd);
1420 if (dri2_dpy->driver_name == NULL)
1421 return _eglError(EGL_BAD_ALLOC, "DRI2: failed to get driver name");
1422
1423 if (!dri2_load_driver(disp))
1424 goto cleanup_driver_name;
1425
1426 dri2_dpy->extensions[0] = &image_lookup_extension.base;
1427 dri2_dpy->extensions[1] = &use_invalidate.base;
1428 dri2_dpy->extensions[2] = NULL;
1429
1430 if (!dri2_create_screen(disp))
1431 goto cleanup_driver;
1432
1433 for (i = 0; dri2_dpy->driver_configs[i]; i++)
1434 dri2_add_config(disp, dri2_dpy->driver_configs[i], i + 1, 0, 0);
1435
1436 disp->Extensions.MESA_drm_image = EGL_TRUE;
1437 disp->Extensions.KHR_image_base = EGL_TRUE;
1438 disp->Extensions.KHR_gl_renderbuffer_image = EGL_TRUE;
1439 disp->Extensions.KHR_gl_texture_2D_image = EGL_TRUE;
1440
1441 /* we're supporting EGL 1.4 */
1442 *major = 1;
1443 *minor = 4;
1444
1445 return EGL_TRUE;
1446
1447 cleanup_driver:
1448 dlclose(dri2_dpy->driver);
1449 cleanup_driver_name:
1450 free(dri2_dpy->driver_name);
1451
1452 return EGL_FALSE;
1453 }
1454
1455 #endif
1456
1457 /**
1458 * Called via eglInitialize(), GLX_drv->API.Initialize().
1459 */
1460 static EGLBoolean
1461 dri2_initialize(_EGLDriver *drv, _EGLDisplay *disp,
1462 EGLint *major, EGLint *minor)
1463 {
1464 switch (disp->Platform) {
1465 case _EGL_PLATFORM_X11:
1466 return dri2_initialize_x11(drv, disp, major, minor);
1467
1468 #ifdef HAVE_LIBUDEV
1469 case _EGL_PLATFORM_DRM:
1470 return dri2_initialize_drm(drv, disp, major, minor);
1471 #endif
1472
1473 default:
1474 return EGL_FALSE;
1475 }
1476 }
1477
1478 /**
1479 * Called via eglTerminate(), drv->API.Terminate().
1480 */
1481 static EGLBoolean
1482 dri2_terminate(_EGLDriver *drv, _EGLDisplay *disp)
1483 {
1484 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1485
1486 _eglReleaseDisplayResources(drv, disp);
1487 _eglCleanupDisplay(disp);
1488
1489 dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
1490 close(dri2_dpy->fd);
1491 dlclose(dri2_dpy->driver);
1492 if (disp->PlatformDisplay == NULL)
1493 xcb_disconnect(dri2_dpy->conn);
1494 free(dri2_dpy);
1495 disp->DriverData = NULL;
1496
1497 return EGL_TRUE;
1498 }
1499
1500
1501 /**
1502 * Called via eglCreateContext(), drv->API.CreateContext().
1503 */
1504 static _EGLContext *
1505 dri2_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
1506 _EGLContext *share_list, const EGLint *attrib_list)
1507 {
1508 struct dri2_egl_context *dri2_ctx;
1509 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1510 struct dri2_egl_context *dri2_ctx_shared = dri2_egl_context(share_list);
1511 struct dri2_egl_config *dri2_config = dri2_egl_config(conf);
1512 const __DRIconfig *dri_config;
1513 int api;
1514
1515 (void) drv;
1516
1517 dri2_ctx = malloc(sizeof *dri2_ctx);
1518 if (!dri2_ctx) {
1519 _eglError(EGL_BAD_ALLOC, "eglCreateContext");
1520 return NULL;
1521 }
1522
1523 if (!_eglInitContext(&dri2_ctx->base, disp, conf, attrib_list))
1524 goto cleanup;
1525
1526 switch (dri2_ctx->base.ClientAPI) {
1527 case EGL_OPENGL_ES_API:
1528 switch (dri2_ctx->base.ClientVersion) {
1529 case 1:
1530 api = __DRI_API_GLES;
1531 break;
1532 case 2:
1533 api = __DRI_API_GLES2;
1534 break;
1535 default:
1536 _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
1537 return NULL;
1538 }
1539 break;
1540 case EGL_OPENGL_API:
1541 api = __DRI_API_OPENGL;
1542 break;
1543 default:
1544 _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
1545 return NULL;
1546 }
1547
1548 if (conf != NULL)
1549 dri_config = dri2_config->dri_config;
1550 else
1551 dri_config = NULL;
1552
1553 if (dri2_dpy->dri2->base.version >= 2) {
1554 dri2_ctx->dri_context =
1555 dri2_dpy->dri2->createNewContextForAPI(dri2_dpy->dri_screen,
1556 api,
1557 dri_config,
1558 dri2_ctx_shared ?
1559 dri2_ctx_shared->dri_context : NULL,
1560 dri2_ctx);
1561 } else if (api == __DRI_API_OPENGL) {
1562 dri2_ctx->dri_context =
1563 dri2_dpy->dri2->createNewContext(dri2_dpy->dri_screen,
1564 dri2_config->dri_config,
1565 dri2_ctx_shared ?
1566 dri2_ctx_shared->dri_context : NULL,
1567 dri2_ctx);
1568 } else {
1569 /* fail */
1570 }
1571
1572 if (!dri2_ctx->dri_context)
1573 goto cleanup;
1574
1575 return &dri2_ctx->base;
1576
1577 cleanup:
1578 free(dri2_ctx);
1579 return NULL;
1580 }
1581
1582 static EGLBoolean
1583 dri2_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
1584 {
1585 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1586 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1587
1588 (void) drv;
1589
1590 if (!_eglPutSurface(surf))
1591 return EGL_TRUE;
1592
1593 (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
1594
1595 xcb_dri2_destroy_drawable (dri2_dpy->conn, dri2_surf->drawable);
1596
1597 if (surf->Type == EGL_PBUFFER_BIT)
1598 xcb_free_pixmap (dri2_dpy->conn, dri2_surf->drawable);
1599
1600 free(surf);
1601
1602 return EGL_TRUE;
1603 }
1604
1605 /**
1606 * Called via eglMakeCurrent(), drv->API.MakeCurrent().
1607 */
1608 static EGLBoolean
1609 dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
1610 _EGLSurface *rsurf, _EGLContext *ctx)
1611 {
1612 struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1613 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1614 struct dri2_egl_surface *dri2_dsurf = dri2_egl_surface(dsurf);
1615 struct dri2_egl_surface *dri2_rsurf = dri2_egl_surface(rsurf);
1616 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1617 _EGLContext *old_ctx;
1618 _EGLSurface *old_dsurf, *old_rsurf;
1619 __DRIdrawable *ddraw, *rdraw;
1620 __DRIcontext *cctx;
1621
1622 /* make new bindings */
1623 if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
1624 return EGL_FALSE;
1625
1626 /* flush before context switch */
1627 if (old_ctx && dri2_drv->glFlush)
1628 dri2_drv->glFlush();
1629
1630 ddraw = (dri2_dsurf) ? dri2_dsurf->dri_drawable : NULL;
1631 rdraw = (dri2_rsurf) ? dri2_rsurf->dri_drawable : NULL;
1632 cctx = (dri2_ctx) ? dri2_ctx->dri_context : NULL;
1633
1634 if ((cctx == NULL && ddraw == NULL && rdraw == NULL) ||
1635 dri2_dpy->core->bindContext(cctx, ddraw, rdraw)) {
1636 dri2_destroy_surface(drv, disp, old_dsurf);
1637 dri2_destroy_surface(drv, disp, old_rsurf);
1638 if (old_ctx) {
1639 dri2_dpy->core->unbindContext(dri2_egl_context(old_ctx)->dri_context);
1640 /* no destroy? */
1641 _eglPutContext(old_ctx);
1642 }
1643
1644 return EGL_TRUE;
1645 } else {
1646 /* undo the previous _eglBindContext */
1647 _eglBindContext(old_ctx, old_dsurf, old_rsurf, &ctx, &dsurf, &rsurf);
1648 assert(&dri2_ctx->base == ctx &&
1649 &dri2_dsurf->base == dsurf &&
1650 &dri2_rsurf->base == rsurf);
1651
1652 _eglPutSurface(dsurf);
1653 _eglPutSurface(rsurf);
1654 _eglPutContext(ctx);
1655
1656 _eglPutSurface(old_dsurf);
1657 _eglPutSurface(old_rsurf);
1658 _eglPutContext(old_ctx);
1659
1660 return EGL_FALSE;
1661 }
1662 }
1663
1664 /**
1665 * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
1666 */
1667 static _EGLSurface *
1668 dri2_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
1669 _EGLConfig *conf, EGLNativeWindowType window,
1670 const EGLint *attrib_list)
1671 {
1672 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1673 struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
1674 struct dri2_egl_surface *dri2_surf;
1675 xcb_get_geometry_cookie_t cookie;
1676 xcb_get_geometry_reply_t *reply;
1677 xcb_screen_iterator_t s;
1678 xcb_generic_error_t *error;
1679
1680 (void) drv;
1681
1682 dri2_surf = malloc(sizeof *dri2_surf);
1683 if (!dri2_surf) {
1684 _eglError(EGL_BAD_ALLOC, "dri2_create_surface");
1685 return NULL;
1686 }
1687
1688 if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list))
1689 goto cleanup_surf;
1690
1691 dri2_surf->region = XCB_NONE;
1692 if (type == EGL_PBUFFER_BIT) {
1693 dri2_surf->drawable = xcb_generate_id(dri2_dpy->conn);
1694 s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
1695 xcb_create_pixmap(dri2_dpy->conn, conf->BufferSize,
1696 dri2_surf->drawable, s.data->root,
1697 dri2_surf->base.Width, dri2_surf->base.Height);
1698 } else {
1699 dri2_surf->drawable = window;
1700 }
1701
1702 dri2_surf->dri_drawable =
1703 (*dri2_dpy->dri2->createNewDrawable) (dri2_dpy->dri_screen,
1704 dri2_conf->dri_config, dri2_surf);
1705 if (dri2_surf->dri_drawable == NULL) {
1706 _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable");
1707 goto cleanup_pixmap;
1708 }
1709
1710 xcb_dri2_create_drawable (dri2_dpy->conn, dri2_surf->drawable);
1711
1712 if (type != EGL_PBUFFER_BIT) {
1713 cookie = xcb_get_geometry (dri2_dpy->conn, dri2_surf->drawable);
1714 reply = xcb_get_geometry_reply (dri2_dpy->conn, cookie, &error);
1715 if (reply == NULL || error != NULL) {
1716 _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
1717 free(error);
1718 goto cleanup_dri_drawable;
1719 }
1720
1721 dri2_surf->base.Width = reply->width;
1722 dri2_surf->base.Height = reply->height;
1723 free(reply);
1724 }
1725
1726 return &dri2_surf->base;
1727
1728 cleanup_dri_drawable:
1729 dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
1730 cleanup_pixmap:
1731 if (type == EGL_PBUFFER_BIT)
1732 xcb_free_pixmap(dri2_dpy->conn, dri2_surf->drawable);
1733 cleanup_surf:
1734 free(dri2_surf);
1735
1736 return NULL;
1737 }
1738
1739 /**
1740 * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
1741 */
1742 static _EGLSurface *
1743 dri2_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
1744 _EGLConfig *conf, EGLNativeWindowType window,
1745 const EGLint *attrib_list)
1746 {
1747 return dri2_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
1748 window, attrib_list);
1749 }
1750
1751 static _EGLSurface *
1752 dri2_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
1753 _EGLConfig *conf, EGLNativePixmapType pixmap,
1754 const EGLint *attrib_list)
1755 {
1756 return dri2_create_surface(drv, disp, EGL_PIXMAP_BIT, conf,
1757 pixmap, attrib_list);
1758 }
1759
1760 static _EGLSurface *
1761 dri2_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
1762 _EGLConfig *conf, const EGLint *attrib_list)
1763 {
1764 return dri2_create_surface(drv, disp, EGL_PBUFFER_BIT, conf,
1765 XCB_WINDOW_NONE, attrib_list);
1766 }
1767
1768 static EGLBoolean
1769 dri2_copy_region(_EGLDriver *drv, _EGLDisplay *disp,
1770 _EGLSurface *draw, xcb_xfixes_region_t region)
1771 {
1772 struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1773 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1774 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1775 _EGLContext *ctx;
1776 xcb_dri2_copy_region_cookie_t cookie;
1777
1778 if (dri2_drv->glFlush) {
1779 ctx = _eglGetCurrentContext();
1780 if (ctx && ctx->DrawSurface == &dri2_surf->base)
1781 dri2_drv->glFlush();
1782 }
1783
1784 (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1785
1786 #if 0
1787 /* FIXME: Add support for dri swapbuffers, that'll give us swap
1788 * interval and page flipping (at least for fullscreen windows) as
1789 * well as the page flip event. Unless surface->SwapBehavior is
1790 * EGL_BUFFER_PRESERVED. */
1791 #if __DRI2_FLUSH_VERSION >= 2
1792 if (pdraw->psc->f)
1793 (*pdraw->psc->f->flushInvalidate)(pdraw->driDrawable);
1794 #endif
1795 #endif
1796
1797 if (!dri2_surf->have_fake_front)
1798 return EGL_TRUE;
1799
1800 cookie = xcb_dri2_copy_region_unchecked(dri2_dpy->conn,
1801 dri2_surf->drawable,
1802 region,
1803 XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT,
1804 XCB_DRI2_ATTACHMENT_BUFFER_FAKE_FRONT_LEFT);
1805 free(xcb_dri2_copy_region_reply(dri2_dpy->conn, cookie, NULL));
1806
1807 return EGL_TRUE;
1808 }
1809
1810 static EGLBoolean
1811 dri2_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
1812 {
1813 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1814
1815 return dri2_copy_region(drv, disp, draw, dri2_surf->region);
1816 }
1817
1818 static EGLBoolean
1819 dri2_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
1820 EGLint numRects, const EGLint *rects)
1821 {
1822 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1823 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1824 EGLBoolean ret;
1825 xcb_xfixes_region_t region;
1826 xcb_rectangle_t rectangles[16];
1827 int i;
1828
1829 if (numRects > (int)ARRAY_SIZE(rectangles))
1830 return dri2_copy_region(drv, disp, draw, dri2_surf->region);
1831
1832 /* FIXME: Invert y here? */
1833 for (i = 0; i < numRects; i++) {
1834 rectangles[i].x = rects[i * 4];
1835 rectangles[i].y = rects[i * 4 + 1];
1836 rectangles[i].width = rects[i * 4 + 2];
1837 rectangles[i].height = rects[i * 4 + 3];
1838 }
1839
1840 region = xcb_generate_id(dri2_dpy->conn);
1841 xcb_xfixes_create_region(dri2_dpy->conn, region, numRects, rectangles);
1842 ret = dri2_copy_region(drv, disp, draw, region);
1843 xcb_xfixes_destroy_region(dri2_dpy->conn, region);
1844
1845 return ret;
1846 }
1847
1848 /*
1849 * Called from eglGetProcAddress() via drv->API.GetProcAddress().
1850 */
1851 static _EGLProc
1852 dri2_get_proc_address(_EGLDriver *drv, const char *procname)
1853 {
1854 (void) drv;
1855
1856 /* FIXME: Do we need to support lookup of EGL symbols too? */
1857
1858 return (_EGLProc) _glapi_get_proc_address(procname);
1859 }
1860
1861 static EGLBoolean
1862 dri2_wait_client(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
1863 {
1864 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1865 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(ctx->DrawSurface);
1866
1867 (void) drv;
1868
1869 /* FIXME: If EGL allows frontbuffer rendering for window surfaces,
1870 * we need to copy fake to real here.*/
1871
1872 (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1873
1874 return EGL_TRUE;
1875 }
1876
1877 static EGLBoolean
1878 dri2_wait_native(_EGLDriver *drv, _EGLDisplay *disp, EGLint engine)
1879 {
1880 (void) drv;
1881 (void) disp;
1882
1883 if (engine != EGL_CORE_NATIVE_ENGINE)
1884 return _eglError(EGL_BAD_PARAMETER, "eglWaitNative");
1885 /* glXWaitX(); */
1886
1887 return EGL_TRUE;
1888 }
1889
1890 static void
1891 dri2_unload(_EGLDriver *drv)
1892 {
1893 struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1894 free(dri2_drv);
1895 }
1896
1897 static EGLBoolean
1898 dri2_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
1899 EGLNativePixmapType target)
1900 {
1901 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1902 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1903 xcb_gcontext_t gc;
1904
1905 (void) drv;
1906
1907 (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1908
1909 gc = xcb_generate_id(dri2_dpy->conn);
1910 xcb_create_gc(dri2_dpy->conn, gc, target, 0, NULL);
1911 xcb_copy_area(dri2_dpy->conn,
1912 dri2_surf->drawable,
1913 target,
1914 gc,
1915 0, 0,
1916 0, 0,
1917 dri2_surf->base.Width,
1918 dri2_surf->base.Height);
1919 xcb_free_gc(dri2_dpy->conn, gc);
1920
1921 return EGL_TRUE;
1922 }
1923
1924 static EGLBoolean
1925 dri2_bind_tex_image(_EGLDriver *drv,
1926 _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
1927 {
1928 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1929 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1930 struct dri2_egl_context *dri2_ctx;
1931 _EGLContext *ctx;
1932 GLint format, target;
1933
1934 ctx = _eglGetCurrentContext();
1935 dri2_ctx = dri2_egl_context(ctx);
1936
1937 if (!_eglBindTexImage(drv, disp, surf, buffer))
1938 return EGL_FALSE;
1939
1940 switch (dri2_surf->base.TextureFormat) {
1941 case EGL_TEXTURE_RGB:
1942 format = __DRI_TEXTURE_FORMAT_RGB;
1943 break;
1944 case EGL_TEXTURE_RGBA:
1945 format = __DRI_TEXTURE_FORMAT_RGBA;
1946 break;
1947 default:
1948 assert(0);
1949 }
1950
1951 switch (dri2_surf->base.TextureTarget) {
1952 case EGL_TEXTURE_2D:
1953 target = GL_TEXTURE_2D;
1954 break;
1955 default:
1956 assert(0);
1957 }
1958
1959 (*dri2_dpy->tex_buffer->setTexBuffer2)(dri2_ctx->dri_context,
1960 target, format,
1961 dri2_surf->dri_drawable);
1962
1963 return EGL_TRUE;
1964 }
1965
1966 static EGLBoolean
1967 dri2_release_tex_image(_EGLDriver *drv,
1968 _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
1969 {
1970 (void) drv;
1971 (void) disp;
1972 (void) surf;
1973 (void) buffer;
1974
1975 return EGL_TRUE;
1976 }
1977
1978 static _EGLImage *
1979 dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx,
1980 EGLClientBuffer buffer, const EGLint *attr_list)
1981 {
1982 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1983 struct dri2_egl_image *dri2_img;
1984 unsigned int attachments[1];
1985 xcb_drawable_t drawable;
1986 xcb_dri2_get_buffers_cookie_t buffers_cookie;
1987 xcb_dri2_get_buffers_reply_t *buffers_reply;
1988 xcb_dri2_dri2_buffer_t *buffers;
1989 xcb_get_geometry_cookie_t geometry_cookie;
1990 xcb_get_geometry_reply_t *geometry_reply;
1991 xcb_generic_error_t *error;
1992 int stride, format;
1993
1994 (void) ctx;
1995
1996 drawable = (xcb_drawable_t) buffer;
1997 xcb_dri2_create_drawable (dri2_dpy->conn, drawable);
1998 attachments[0] = XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT;
1999 buffers_cookie =
2000 xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
2001 drawable, 1, 1, attachments);
2002 geometry_cookie = xcb_get_geometry (dri2_dpy->conn, drawable);
2003 buffers_reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn,
2004 buffers_cookie, NULL);
2005 buffers = xcb_dri2_get_buffers_buffers (buffers_reply);
2006 if (buffers == NULL) {
2007 return NULL;
2008 }
2009
2010 geometry_reply = xcb_get_geometry_reply (dri2_dpy->conn,
2011 geometry_cookie, &error);
2012 if (geometry_reply == NULL || error != NULL) {
2013 _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
2014 free(error);
2015 free(buffers_reply);
2016 }
2017
2018 switch (geometry_reply->depth) {
2019 case 16:
2020 format = __DRI_IMAGE_FORMAT_RGB565;
2021 break;
2022 case 24:
2023 format = __DRI_IMAGE_FORMAT_XRGB8888;
2024 break;
2025 case 32:
2026 format = __DRI_IMAGE_FORMAT_ARGB8888;
2027 break;
2028 default:
2029 _eglError(EGL_BAD_PARAMETER,
2030 "dri2_create_image_khr: unsupported pixmap depth");
2031 free(buffers_reply);
2032 free(geometry_reply);
2033 return NULL;
2034 }
2035
2036 dri2_img = malloc(sizeof *dri2_img);
2037 if (!dri2_img) {
2038 free(buffers_reply);
2039 free(geometry_reply);
2040 _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
2041 return EGL_NO_IMAGE_KHR;
2042 }
2043
2044 if (!_eglInitImage(&dri2_img->base, disp)) {
2045 free(buffers_reply);
2046 free(geometry_reply);
2047 return EGL_NO_IMAGE_KHR;
2048 }
2049
2050 stride = buffers[0].pitch / buffers[0].cpp;
2051 dri2_img->dri_image =
2052 dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
2053 buffers_reply->width,
2054 buffers_reply->height,
2055 format,
2056 buffers[0].name,
2057 stride,
2058 dri2_img);
2059
2060 free(buffers_reply);
2061 free(geometry_reply);
2062
2063 return &dri2_img->base;
2064 }
2065
2066 static _EGLImage *
2067 dri2_create_image_khr_renderbuffer(_EGLDisplay *disp, _EGLContext *ctx,
2068 EGLClientBuffer buffer,
2069 const EGLint *attr_list)
2070 {
2071 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2072 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
2073 struct dri2_egl_image *dri2_img;
2074 GLuint renderbuffer = (GLuint) buffer;
2075
2076 if (renderbuffer == 0) {
2077 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2078 return EGL_NO_IMAGE_KHR;
2079 }
2080
2081 dri2_img = malloc(sizeof *dri2_img);
2082 if (!dri2_img) {
2083 _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
2084 return EGL_NO_IMAGE_KHR;
2085 }
2086
2087 if (!_eglInitImage(&dri2_img->base, disp))
2088 return EGL_NO_IMAGE_KHR;
2089
2090 dri2_img->dri_image =
2091 dri2_dpy->image->createImageFromRenderbuffer(dri2_ctx->dri_context,
2092 renderbuffer,
2093 dri2_img);
2094
2095 return &dri2_img->base;
2096 }
2097
2098 static _EGLImage *
2099 dri2_create_image_mesa_drm_buffer(_EGLDisplay *disp, _EGLContext *ctx,
2100 EGLClientBuffer buffer, const EGLint *attr_list)
2101 {
2102 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2103 struct dri2_egl_image *dri2_img;
2104 EGLint format, name, pitch, err;
2105 _EGLImageAttribs attrs;
2106
2107 (void) ctx;
2108
2109 name = (EGLint) buffer;
2110
2111 err = _eglParseImageAttribList(&attrs, disp, attr_list);
2112 if (err != EGL_SUCCESS)
2113 return NULL;
2114
2115 if (attrs.Width <= 0 || attrs.Height <= 0 ||
2116 attrs.DRMBufferStrideMESA <= 0) {
2117 _eglError(EGL_BAD_PARAMETER,
2118 "bad width, height or stride");
2119 return NULL;
2120 }
2121
2122 switch (attrs.DRMBufferFormatMESA) {
2123 case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
2124 format = __DRI_IMAGE_FORMAT_ARGB8888;
2125 pitch = attrs.DRMBufferStrideMESA;
2126 break;
2127 default:
2128 _eglError(EGL_BAD_PARAMETER,
2129 "dri2_create_image_khr: unsupported pixmap depth");
2130 return NULL;
2131 }
2132
2133 dri2_img = malloc(sizeof *dri2_img);
2134 if (!dri2_img) {
2135 _eglError(EGL_BAD_ALLOC, "dri2_create_image_mesa_drm");
2136 return NULL;
2137 }
2138
2139 if (!_eglInitImage(&dri2_img->base, disp)) {
2140 free(dri2_img);
2141 return NULL;
2142 }
2143
2144 dri2_img->dri_image =
2145 dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
2146 attrs.Width,
2147 attrs.Height,
2148 format,
2149 name,
2150 pitch,
2151 dri2_img);
2152 if (dri2_img->dri_image == NULL) {
2153 free(dri2_img);
2154 _eglError(EGL_BAD_ALLOC, "dri2_create_image_mesa_drm");
2155 return NULL;
2156 }
2157
2158 return &dri2_img->base;
2159 }
2160
2161 static _EGLImage *
2162 dri2_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
2163 _EGLContext *ctx, EGLenum target,
2164 EGLClientBuffer buffer, const EGLint *attr_list)
2165 {
2166 (void) drv;
2167
2168 switch (target) {
2169 case EGL_NATIVE_PIXMAP_KHR:
2170 return dri2_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
2171 case EGL_GL_RENDERBUFFER_KHR:
2172 return dri2_create_image_khr_renderbuffer(disp, ctx, buffer, attr_list);
2173 case EGL_DRM_BUFFER_MESA:
2174 return dri2_create_image_mesa_drm_buffer(disp, ctx, buffer, attr_list);
2175 default:
2176 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2177 return EGL_NO_IMAGE_KHR;
2178 }
2179 }
2180
2181 static EGLBoolean
2182 dri2_destroy_image_khr(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *image)
2183 {
2184 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2185 struct dri2_egl_image *dri2_img = dri2_egl_image(image);
2186
2187 (void) drv;
2188
2189 dri2_dpy->image->destroyImage(dri2_img->dri_image);
2190 free(dri2_img);
2191
2192 return EGL_TRUE;
2193 }
2194
2195 static _EGLImage *
2196 dri2_create_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp,
2197 const EGLint *attr_list)
2198 {
2199 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2200 struct dri2_egl_image *dri2_img;
2201 _EGLImageAttribs attrs;
2202 unsigned int dri_use, valid_mask;
2203 int format;
2204 EGLint err = EGL_SUCCESS;
2205
2206 (void) drv;
2207
2208 dri2_img = malloc(sizeof *dri2_img);
2209 if (!dri2_img) {
2210 _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
2211 return EGL_NO_IMAGE_KHR;
2212 }
2213
2214 if (!attr_list) {
2215 err = EGL_BAD_PARAMETER;
2216 goto cleanup_img;
2217 }
2218
2219 if (!_eglInitImage(&dri2_img->base, disp)) {
2220 err = EGL_BAD_PARAMETER;
2221 goto cleanup_img;
2222 }
2223
2224 err = _eglParseImageAttribList(&attrs, disp, attr_list);
2225 if (err != EGL_SUCCESS)
2226 goto cleanup_img;
2227
2228 if (attrs.Width <= 0 || attrs.Height <= 0) {
2229 _eglLog(_EGL_WARNING, "bad width or height (%dx%d)",
2230 attrs.Width, attrs.Height);
2231 goto cleanup_img;
2232 }
2233
2234 switch (attrs.DRMBufferFormatMESA) {
2235 case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
2236 format = __DRI_IMAGE_FORMAT_ARGB8888;
2237 break;
2238 default:
2239 _eglLog(_EGL_WARNING, "bad image format value 0x%04x",
2240 attrs.DRMBufferFormatMESA);
2241 goto cleanup_img;
2242 }
2243
2244 valid_mask =
2245 EGL_DRM_BUFFER_USE_SCANOUT_MESA |
2246 EGL_DRM_BUFFER_USE_SHARE_MESA;
2247 if (attrs.DRMBufferUseMESA & ~valid_mask) {
2248 _eglLog(_EGL_WARNING, "bad image use bit 0x%04x",
2249 attrs.DRMBufferUseMESA & ~valid_mask);
2250 goto cleanup_img;
2251 }
2252
2253 dri_use = 0;
2254 if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SHARE_MESA)
2255 dri_use |= __DRI_IMAGE_USE_SHARE;
2256 if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SCANOUT_MESA)
2257 dri_use |= __DRI_IMAGE_USE_SCANOUT;
2258
2259 dri2_img->dri_image =
2260 dri2_dpy->image->createImage(dri2_dpy->dri_screen,
2261 attrs.Width, attrs.Height,
2262 format, dri_use, dri2_img);
2263 if (dri2_img->dri_image == NULL) {
2264 err = EGL_BAD_ALLOC;
2265 goto cleanup_img;
2266 }
2267
2268 return &dri2_img->base;
2269
2270 cleanup_img:
2271 free(dri2_img);
2272 _eglError(err, "dri2_create_drm_image_mesa");
2273
2274 return EGL_NO_IMAGE_KHR;
2275 }
2276
2277 static EGLBoolean
2278 dri2_export_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
2279 EGLint *name, EGLint *handle, EGLint *stride)
2280 {
2281 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2282 struct dri2_egl_image *dri2_img = dri2_egl_image(img);
2283
2284 (void) drv;
2285
2286 if (name && !dri2_dpy->image->queryImage(dri2_img->dri_image,
2287 __DRI_IMAGE_ATTRIB_NAME, name)) {
2288 _eglError(EGL_BAD_ALLOC, "dri2_export_drm_image_mesa");
2289 return EGL_FALSE;
2290 }
2291
2292 if (handle)
2293 dri2_dpy->image->queryImage(dri2_img->dri_image,
2294 __DRI_IMAGE_ATTRIB_HANDLE, handle);
2295
2296 if (stride)
2297 dri2_dpy->image->queryImage(dri2_img->dri_image,
2298 __DRI_IMAGE_ATTRIB_STRIDE, stride);
2299
2300 return EGL_TRUE;
2301 }
2302
2303 /**
2304 * This is the main entrypoint into the driver, called by libEGL.
2305 * Create a new _EGLDriver object and init its dispatch table.
2306 */
2307 _EGLDriver *
2308 _eglMain(const char *args)
2309 {
2310 struct dri2_egl_driver *dri2_drv;
2311
2312 (void) args;
2313
2314 dri2_drv = malloc(sizeof *dri2_drv);
2315 if (!dri2_drv)
2316 return NULL;
2317
2318 memset(dri2_drv, 0, sizeof *dri2_drv);
2319 _eglInitDriverFallbacks(&dri2_drv->base);
2320 dri2_drv->base.API.Initialize = dri2_initialize;
2321 dri2_drv->base.API.Terminate = dri2_terminate;
2322 dri2_drv->base.API.CreateContext = dri2_create_context;
2323 dri2_drv->base.API.MakeCurrent = dri2_make_current;
2324 dri2_drv->base.API.CreateWindowSurface = dri2_create_window_surface;
2325 dri2_drv->base.API.CreatePixmapSurface = dri2_create_pixmap_surface;
2326 dri2_drv->base.API.CreatePbufferSurface = dri2_create_pbuffer_surface;
2327 dri2_drv->base.API.DestroySurface = dri2_destroy_surface;
2328 dri2_drv->base.API.SwapBuffers = dri2_swap_buffers;
2329 dri2_drv->base.API.GetProcAddress = dri2_get_proc_address;
2330 dri2_drv->base.API.WaitClient = dri2_wait_client;
2331 dri2_drv->base.API.WaitNative = dri2_wait_native;
2332 dri2_drv->base.API.CopyBuffers = dri2_copy_buffers;
2333 dri2_drv->base.API.BindTexImage = dri2_bind_tex_image;
2334 dri2_drv->base.API.ReleaseTexImage = dri2_release_tex_image;
2335 dri2_drv->base.API.CreateImageKHR = dri2_create_image_khr;
2336 dri2_drv->base.API.DestroyImageKHR = dri2_destroy_image_khr;
2337 dri2_drv->base.API.SwapBuffersRegionNOK = dri2_swap_buffers_region;
2338 dri2_drv->base.API.CreateDRMImageMESA = dri2_create_drm_image_mesa;
2339 dri2_drv->base.API.ExportDRMImageMESA = dri2_export_drm_image_mesa;
2340
2341 dri2_drv->base.Name = "DRI2";
2342 dri2_drv->base.Unload = dri2_unload;
2343
2344 dri2_drv->glFlush =
2345 (void (*)(void)) dri2_get_proc_address(&dri2_drv->base, "glFlush");
2346
2347 return &dri2_drv->base;
2348 }