projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'lp-offset-twoside'
[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 = 1 << __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 0xa001, /* PCI_CHIP_IGD_G */
903 0xa011, /* Pineview */
904 };
905
906 const int i965_chip_ids[] = {
907 0x0042, /* PCI_CHIP_ILD_G */
908 0x0046, /* PCI_CHIP_ILM_G */
909 0x0102, /* PCI_CHIP_SANDYBRIDGE_GT1 */
910 0x0106, /* PCI_CHIP_SANDYBRIDGE_M_GT1 */
911 0x010a, /* PCI_CHIP_SANDYBRIDGE_S */
912 0x0112, /* PCI_CHIP_SANDYBRIDGE_GT2 */
913 0x0116, /* PCI_CHIP_SANDYBRIDGE_M_GT2 */
914 0x0122, /* PCI_CHIP_SANDYBRIDGE_GT2_PLUS */
915 0x0126, /* PCI_CHIP_SANDYBRIDGE_M_GT2_PLUS */
916 0x29a2, /* PCI_CHIP_I965_G */
917 0x2992, /* PCI_CHIP_I965_Q */
918 0x2982, /* PCI_CHIP_I965_G_1 */
919 0x2972, /* PCI_CHIP_I946_GZ */
920 0x2a02, /* PCI_CHIP_I965_GM */
921 0x2a12, /* PCI_CHIP_I965_GME */
922 0x2a42, /* PCI_CHIP_GM45_GM */
923 0x2e02, /* PCI_CHIP_IGD_E_G */
924 0x2e12, /* PCI_CHIP_Q45_G */
925 0x2e22, /* PCI_CHIP_G45_G */
926 0x2e32, /* PCI_CHIP_G41_G */
927 0x2e42, /* PCI_CHIP_B43_G */
928 0x2e92, /* PCI_CHIP_B43_G1 */
929 };
930
931 const int r100_chip_ids[] = {
932 0x4C57, /* PCI_CHIP_RADEON_LW */
933 0x4C58, /* PCI_CHIP_RADEON_LX */
934 0x4C59, /* PCI_CHIP_RADEON_LY */
935 0x4C5A, /* PCI_CHIP_RADEON_LZ */
936 0x5144, /* PCI_CHIP_RADEON_QD */
937 0x5145, /* PCI_CHIP_RADEON_QE */
938 0x5146, /* PCI_CHIP_RADEON_QF */
939 0x5147, /* PCI_CHIP_RADEON_QG */
940 0x5159, /* PCI_CHIP_RADEON_QY */
941 0x515A, /* PCI_CHIP_RADEON_QZ */
942 0x5157, /* PCI_CHIP_RV200_QW */
943 0x5158, /* PCI_CHIP_RV200_QX */
944 0x515E, /* PCI_CHIP_RN50_515E */
945 0x5969, /* PCI_CHIP_RN50_5969 */
946 0x4136, /* PCI_CHIP_RS100_4136 */
947 0x4336, /* PCI_CHIP_RS100_4336 */
948 0x4137, /* PCI_CHIP_RS200_4137 */
949 0x4337, /* PCI_CHIP_RS200_4337 */
950 0x4237, /* PCI_CHIP_RS250_4237 */
951 0x4437, /* PCI_CHIP_RS250_4437 */
952 };
953
954 const int r200_chip_ids[] = {
955 0x5148, /* PCI_CHIP_R200_QH */
956 0x514C, /* PCI_CHIP_R200_QL */
957 0x514D, /* PCI_CHIP_R200_QM */
958 0x4242, /* PCI_CHIP_R200_BB */
959 0x4243, /* PCI_CHIP_R200_BC */
960 0x4966, /* PCI_CHIP_RV250_If */
961 0x4967, /* PCI_CHIP_RV250_Ig */
962 0x4C64, /* PCI_CHIP_RV250_Ld */
963 0x4C66, /* PCI_CHIP_RV250_Lf */
964 0x4C67, /* PCI_CHIP_RV250_Lg */
965 0x5960, /* PCI_CHIP_RV280_5960 */
966 0x5961, /* PCI_CHIP_RV280_5961 */
967 0x5962, /* PCI_CHIP_RV280_5962 */
968 0x5964, /* PCI_CHIP_RV280_5964 */
969 0x5965, /* PCI_CHIP_RV280_5965 */
970 0x5C61, /* PCI_CHIP_RV280_5C61 */
971 0x5C63, /* PCI_CHIP_RV280_5C63 */
972 0x5834, /* PCI_CHIP_RS300_5834 */
973 0x5835, /* PCI_CHIP_RS300_5835 */
974 0x7834, /* PCI_CHIP_RS350_7834 */
975 0x7835, /* PCI_CHIP_RS350_7835 */
976 };
977
978 const int r300_chip_ids[] = {
979 0x4144, /* PCI_CHIP_R300_AD */
980 0x4145, /* PCI_CHIP_R300_AE */
981 0x4146, /* PCI_CHIP_R300_AF */
982 0x4147, /* PCI_CHIP_R300_AG */
983 0x4E44, /* PCI_CHIP_R300_ND */
984 0x4E45, /* PCI_CHIP_R300_NE */
985 0x4E46, /* PCI_CHIP_R300_NF */
986 0x4E47, /* PCI_CHIP_R300_NG */
987 0x4E48, /* PCI_CHIP_R350_NH */
988 0x4E49, /* PCI_CHIP_R350_NI */
989 0x4E4B, /* PCI_CHIP_R350_NK */
990 0x4148, /* PCI_CHIP_R350_AH */
991 0x4149, /* PCI_CHIP_R350_AI */
992 0x414A, /* PCI_CHIP_R350_AJ */
993 0x414B, /* PCI_CHIP_R350_AK */
994 0x4E4A, /* PCI_CHIP_R360_NJ */
995 0x4150, /* PCI_CHIP_RV350_AP */
996 0x4151, /* PCI_CHIP_RV350_AQ */
997 0x4152, /* PCI_CHIP_RV350_AR */
998 0x4153, /* PCI_CHIP_RV350_AS */
999 0x4154, /* PCI_CHIP_RV350_AT */
1000 0x4155, /* PCI_CHIP_RV350_AU */
1001 0x4156, /* PCI_CHIP_RV350_AV */
1002 0x4E50, /* PCI_CHIP_RV350_NP */
1003 0x4E51, /* PCI_CHIP_RV350_NQ */
1004 0x4E52, /* PCI_CHIP_RV350_NR */
1005 0x4E53, /* PCI_CHIP_RV350_NS */
1006 0x4E54, /* PCI_CHIP_RV350_NT */
1007 0x4E56, /* PCI_CHIP_RV350_NV */
1008 0x5460, /* PCI_CHIP_RV370_5460 */
1009 0x5462, /* PCI_CHIP_RV370_5462 */
1010 0x5464, /* PCI_CHIP_RV370_5464 */
1011 0x5B60, /* PCI_CHIP_RV370_5B60 */
1012 0x5B62, /* PCI_CHIP_RV370_5B62 */
1013 0x5B63, /* PCI_CHIP_RV370_5B63 */
1014 0x5B64, /* PCI_CHIP_RV370_5B64 */
1015 0x5B65, /* PCI_CHIP_RV370_5B65 */
1016 0x3150, /* PCI_CHIP_RV380_3150 */
1017 0x3152, /* PCI_CHIP_RV380_3152 */
1018 0x3154, /* PCI_CHIP_RV380_3154 */
1019 0x3155, /* PCI_CHIP_RV380_3155 */
1020 0x3E50, /* PCI_CHIP_RV380_3E50 */
1021 0x3E54, /* PCI_CHIP_RV380_3E54 */
1022 0x4A48, /* PCI_CHIP_R420_JH */
1023 0x4A49, /* PCI_CHIP_R420_JI */
1024 0x4A4A, /* PCI_CHIP_R420_JJ */
1025 0x4A4B, /* PCI_CHIP_R420_JK */
1026 0x4A4C, /* PCI_CHIP_R420_JL */
1027 0x4A4D, /* PCI_CHIP_R420_JM */
1028 0x4A4E, /* PCI_CHIP_R420_JN */
1029 0x4A4F, /* PCI_CHIP_R420_JO */
1030 0x4A50, /* PCI_CHIP_R420_JP */
1031 0x4A54, /* PCI_CHIP_R420_JT */
1032 0x5548, /* PCI_CHIP_R423_UH */
1033 0x5549, /* PCI_CHIP_R423_UI */
1034 0x554A, /* PCI_CHIP_R423_UJ */
1035 0x554B, /* PCI_CHIP_R423_UK */
1036 0x5550, /* PCI_CHIP_R423_5550 */
1037 0x5551, /* PCI_CHIP_R423_UQ */
1038 0x5552, /* PCI_CHIP_R423_UR */
1039 0x5554, /* PCI_CHIP_R423_UT */
1040 0x5D57, /* PCI_CHIP_R423_5D57 */
1041 0x554C, /* PCI_CHIP_R430_554C */
1042 0x554D, /* PCI_CHIP_R430_554D */
1043 0x554E, /* PCI_CHIP_R430_554E */
1044 0x554F, /* PCI_CHIP_R430_554F */
1045 0x5D48, /* PCI_CHIP_R430_5D48 */
1046 0x5D49, /* PCI_CHIP_R430_5D49 */
1047 0x5D4A, /* PCI_CHIP_R430_5D4A */
1048 0x5D4C, /* PCI_CHIP_R480_5D4C */
1049 0x5D4D, /* PCI_CHIP_R480_5D4D */
1050 0x5D4E, /* PCI_CHIP_R480_5D4E */
1051 0x5D4F, /* PCI_CHIP_R480_5D4F */
1052 0x5D50, /* PCI_CHIP_R480_5D50 */
1053 0x5D52, /* PCI_CHIP_R480_5D52 */
1054 0x4B49, /* PCI_CHIP_R481_4B49 */
1055 0x4B4A, /* PCI_CHIP_R481_4B4A */
1056 0x4B4B, /* PCI_CHIP_R481_4B4B */
1057 0x4B4C, /* PCI_CHIP_R481_4B4C */
1058 0x564A, /* PCI_CHIP_RV410_564A */
1059 0x564B, /* PCI_CHIP_RV410_564B */
1060 0x564F, /* PCI_CHIP_RV410_564F */
1061 0x5652, /* PCI_CHIP_RV410_5652 */
1062 0x5653, /* PCI_CHIP_RV410_5653 */
1063 0x5657, /* PCI_CHIP_RV410_5657 */
1064 0x5E48, /* PCI_CHIP_RV410_5E48 */
1065 0x5E4A, /* PCI_CHIP_RV410_5E4A */
1066 0x5E4B, /* PCI_CHIP_RV410_5E4B */
1067 0x5E4C, /* PCI_CHIP_RV410_5E4C */
1068 0x5E4D, /* PCI_CHIP_RV410_5E4D */
1069 0x5E4F, /* PCI_CHIP_RV410_5E4F */
1070 0x5A41, /* PCI_CHIP_RS400_5A41 */
1071 0x5A42, /* PCI_CHIP_RS400_5A42 */
1072 0x5A61, /* PCI_CHIP_RC410_5A61 */
1073 0x5A62, /* PCI_CHIP_RC410_5A62 */
1074 0x5954, /* PCI_CHIP_RS480_5954 */
1075 0x5955, /* PCI_CHIP_RS480_5955 */
1076 0x5974, /* PCI_CHIP_RS482_5974 */
1077 0x5975, /* PCI_CHIP_RS482_5975 */
1078 0x7100, /* PCI_CHIP_R520_7100 */
1079 0x7101, /* PCI_CHIP_R520_7101 */
1080 0x7102, /* PCI_CHIP_R520_7102 */
1081 0x7103, /* PCI_CHIP_R520_7103 */
1082 0x7104, /* PCI_CHIP_R520_7104 */
1083 0x7105, /* PCI_CHIP_R520_7105 */
1084 0x7106, /* PCI_CHIP_R520_7106 */
1085 0x7108, /* PCI_CHIP_R520_7108 */
1086 0x7109, /* PCI_CHIP_R520_7109 */
1087 0x710A, /* PCI_CHIP_R520_710A */
1088 0x710B, /* PCI_CHIP_R520_710B */
1089 0x710C, /* PCI_CHIP_R520_710C */
1090 0x710E, /* PCI_CHIP_R520_710E */
1091 0x710F, /* PCI_CHIP_R520_710F */
1092 0x7140, /* PCI_CHIP_RV515_7140 */
1093 0x7141, /* PCI_CHIP_RV515_7141 */
1094 0x7142, /* PCI_CHIP_RV515_7142 */
1095 0x7143, /* PCI_CHIP_RV515_7143 */
1096 0x7144, /* PCI_CHIP_RV515_7144 */
1097 0x7145, /* PCI_CHIP_RV515_7145 */
1098 0x7146, /* PCI_CHIP_RV515_7146 */
1099 0x7147, /* PCI_CHIP_RV515_7147 */
1100 0x7149, /* PCI_CHIP_RV515_7149 */
1101 0x714A, /* PCI_CHIP_RV515_714A */
1102 0x714B, /* PCI_CHIP_RV515_714B */
1103 0x714C, /* PCI_CHIP_RV515_714C */
1104 0x714D, /* PCI_CHIP_RV515_714D */
1105 0x714E, /* PCI_CHIP_RV515_714E */
1106 0x714F, /* PCI_CHIP_RV515_714F */
1107 0x7151, /* PCI_CHIP_RV515_7151 */
1108 0x7152, /* PCI_CHIP_RV515_7152 */
1109 0x7153, /* PCI_CHIP_RV515_7153 */
1110 0x715E, /* PCI_CHIP_RV515_715E */
1111 0x715F, /* PCI_CHIP_RV515_715F */
1112 0x7180, /* PCI_CHIP_RV515_7180 */
1113 0x7181, /* PCI_CHIP_RV515_7181 */
1114 0x7183, /* PCI_CHIP_RV515_7183 */
1115 0x7186, /* PCI_CHIP_RV515_7186 */
1116 0x7187, /* PCI_CHIP_RV515_7187 */
1117 0x7188, /* PCI_CHIP_RV515_7188 */
1118 0x718A, /* PCI_CHIP_RV515_718A */
1119 0x718B, /* PCI_CHIP_RV515_718B */
1120 0x718C, /* PCI_CHIP_RV515_718C */
1121 0x718D, /* PCI_CHIP_RV515_718D */
1122 0x718F, /* PCI_CHIP_RV515_718F */
1123 0x7193, /* PCI_CHIP_RV515_7193 */
1124 0x7196, /* PCI_CHIP_RV515_7196 */
1125 0x719B, /* PCI_CHIP_RV515_719B */
1126 0x719F, /* PCI_CHIP_RV515_719F */
1127 0x7200, /* PCI_CHIP_RV515_7200 */
1128 0x7210, /* PCI_CHIP_RV515_7210 */
1129 0x7211, /* PCI_CHIP_RV515_7211 */
1130 0x71C0, /* PCI_CHIP_RV530_71C0 */
1131 0x71C1, /* PCI_CHIP_RV530_71C1 */
1132 0x71C2, /* PCI_CHIP_RV530_71C2 */
1133 0x71C3, /* PCI_CHIP_RV530_71C3 */
1134 0x71C4, /* PCI_CHIP_RV530_71C4 */
1135 0x71C5, /* PCI_CHIP_RV530_71C5 */
1136 0x71C6, /* PCI_CHIP_RV530_71C6 */
1137 0x71C7, /* PCI_CHIP_RV530_71C7 */
1138 0x71CD, /* PCI_CHIP_RV530_71CD */
1139 0x71CE, /* PCI_CHIP_RV530_71CE */
1140 0x71D2, /* PCI_CHIP_RV530_71D2 */
1141 0x71D4, /* PCI_CHIP_RV530_71D4 */
1142 0x71D5, /* PCI_CHIP_RV530_71D5 */
1143 0x71D6, /* PCI_CHIP_RV530_71D6 */
1144 0x71DA, /* PCI_CHIP_RV530_71DA */
1145 0x71DE, /* PCI_CHIP_RV530_71DE */
1146 0x7281, /* PCI_CHIP_RV560_7281 */
1147 0x7283, /* PCI_CHIP_RV560_7283 */
1148 0x7287, /* PCI_CHIP_RV560_7287 */
1149 0x7290, /* PCI_CHIP_RV560_7290 */
1150 0x7291, /* PCI_CHIP_RV560_7291 */
1151 0x7293, /* PCI_CHIP_RV560_7293 */
1152 0x7297, /* PCI_CHIP_RV560_7297 */
1153 0x7280, /* PCI_CHIP_RV570_7280 */
1154 0x7288, /* PCI_CHIP_RV570_7288 */
1155 0x7289, /* PCI_CHIP_RV570_7289 */
1156 0x728B, /* PCI_CHIP_RV570_728B */
1157 0x728C, /* PCI_CHIP_RV570_728C */
1158 0x7240, /* PCI_CHIP_R580_7240 */
1159 0x7243, /* PCI_CHIP_R580_7243 */
1160 0x7244, /* PCI_CHIP_R580_7244 */
1161 0x7245, /* PCI_CHIP_R580_7245 */
1162 0x7246, /* PCI_CHIP_R580_7246 */
1163 0x7247, /* PCI_CHIP_R580_7247 */
1164 0x7248, /* PCI_CHIP_R580_7248 */
1165 0x7249, /* PCI_CHIP_R580_7249 */
1166 0x724A, /* PCI_CHIP_R580_724A */
1167 0x724B, /* PCI_CHIP_R580_724B */
1168 0x724C, /* PCI_CHIP_R580_724C */
1169 0x724D, /* PCI_CHIP_R580_724D */
1170 0x724E, /* PCI_CHIP_R580_724E */
1171 0x724F, /* PCI_CHIP_R580_724F */
1172 0x7284, /* PCI_CHIP_R580_7284 */
1173 0x793F, /* PCI_CHIP_RS600_793F */
1174 0x7941, /* PCI_CHIP_RS600_7941 */
1175 0x7942, /* PCI_CHIP_RS600_7942 */
1176 0x791E, /* PCI_CHIP_RS690_791E */
1177 0x791F, /* PCI_CHIP_RS690_791F */
1178 0x796C, /* PCI_CHIP_RS740_796C */
1179 0x796D, /* PCI_CHIP_RS740_796D */
1180 0x796E, /* PCI_CHIP_RS740_796E */
1181 0x796F, /* PCI_CHIP_RS740_796F */
1182 };
1183
1184 const int r600_chip_ids[] = {
1185 0x9400, /* PCI_CHIP_R600_9400 */
1186 0x9401, /* PCI_CHIP_R600_9401 */
1187 0x9402, /* PCI_CHIP_R600_9402 */
1188 0x9403, /* PCI_CHIP_R600_9403 */
1189 0x9405, /* PCI_CHIP_R600_9405 */
1190 0x940A, /* PCI_CHIP_R600_940A */
1191 0x940B, /* PCI_CHIP_R600_940B */
1192 0x940F, /* PCI_CHIP_R600_940F */
1193 0x94C0, /* PCI_CHIP_RV610_94C0 */
1194 0x94C1, /* PCI_CHIP_RV610_94C1 */
1195 0x94C3, /* PCI_CHIP_RV610_94C3 */
1196 0x94C4, /* PCI_CHIP_RV610_94C4 */
1197 0x94C5, /* PCI_CHIP_RV610_94C5 */
1198 0x94C6, /* PCI_CHIP_RV610_94C6 */
1199 0x94C7, /* PCI_CHIP_RV610_94C7 */
1200 0x94C8, /* PCI_CHIP_RV610_94C8 */
1201 0x94C9, /* PCI_CHIP_RV610_94C9 */
1202 0x94CB, /* PCI_CHIP_RV610_94CB */
1203 0x94CC, /* PCI_CHIP_RV610_94CC */
1204 0x94CD, /* PCI_CHIP_RV610_94CD */
1205 0x9580, /* PCI_CHIP_RV630_9580 */
1206 0x9581, /* PCI_CHIP_RV630_9581 */
1207 0x9583, /* PCI_CHIP_RV630_9583 */
1208 0x9586, /* PCI_CHIP_RV630_9586 */
1209 0x9587, /* PCI_CHIP_RV630_9587 */
1210 0x9588, /* PCI_CHIP_RV630_9588 */
1211 0x9589, /* PCI_CHIP_RV630_9589 */
1212 0x958A, /* PCI_CHIP_RV630_958A */
1213 0x958B, /* PCI_CHIP_RV630_958B */
1214 0x958C, /* PCI_CHIP_RV630_958C */
1215 0x958D, /* PCI_CHIP_RV630_958D */
1216 0x958E, /* PCI_CHIP_RV630_958E */
1217 0x958F, /* PCI_CHIP_RV630_958F */
1218 0x9500, /* PCI_CHIP_RV670_9500 */
1219 0x9501, /* PCI_CHIP_RV670_9501 */
1220 0x9504, /* PCI_CHIP_RV670_9504 */
1221 0x9505, /* PCI_CHIP_RV670_9505 */
1222 0x9506, /* PCI_CHIP_RV670_9506 */
1223 0x9507, /* PCI_CHIP_RV670_9507 */
1224 0x9508, /* PCI_CHIP_RV670_9508 */
1225 0x9509, /* PCI_CHIP_RV670_9509 */
1226 0x950F, /* PCI_CHIP_RV670_950F */
1227 0x9511, /* PCI_CHIP_RV670_9511 */
1228 0x9515, /* PCI_CHIP_RV670_9515 */
1229 0x9517, /* PCI_CHIP_RV670_9517 */
1230 0x9519, /* PCI_CHIP_RV670_9519 */
1231 0x95C0, /* PCI_CHIP_RV620_95C0 */
1232 0x95C2, /* PCI_CHIP_RV620_95C2 */
1233 0x95C4, /* PCI_CHIP_RV620_95C4 */
1234 0x95C5, /* PCI_CHIP_RV620_95C5 */
1235 0x95C6, /* PCI_CHIP_RV620_95C6 */
1236 0x95C7, /* PCI_CHIP_RV620_95C7 */
1237 0x95C9, /* PCI_CHIP_RV620_95C9 */
1238 0x95CC, /* PCI_CHIP_RV620_95CC */
1239 0x95CD, /* PCI_CHIP_RV620_95CD */
1240 0x95CE, /* PCI_CHIP_RV620_95CE */
1241 0x95CF, /* PCI_CHIP_RV620_95CF */
1242 0x9590, /* PCI_CHIP_RV635_9590 */
1243 0x9591, /* PCI_CHIP_RV635_9591 */
1244 0x9593, /* PCI_CHIP_RV635_9593 */
1245 0x9595, /* PCI_CHIP_RV635_9595 */
1246 0x9596, /* PCI_CHIP_RV635_9596 */
1247 0x9597, /* PCI_CHIP_RV635_9597 */
1248 0x9598, /* PCI_CHIP_RV635_9598 */
1249 0x9599, /* PCI_CHIP_RV635_9599 */
1250 0x959B, /* PCI_CHIP_RV635_959B */
1251 0x9610, /* PCI_CHIP_RS780_9610 */
1252 0x9611, /* PCI_CHIP_RS780_9611 */
1253 0x9612, /* PCI_CHIP_RS780_9612 */
1254 0x9613, /* PCI_CHIP_RS780_9613 */
1255 0x9614, /* PCI_CHIP_RS780_9614 */
1256 0x9615, /* PCI_CHIP_RS780_9615 */
1257 0x9616, /* PCI_CHIP_RS780_9616 */
1258 0x9710, /* PCI_CHIP_RS880_9710 */
1259 0x9711, /* PCI_CHIP_RS880_9711 */
1260 0x9712, /* PCI_CHIP_RS880_9712 */
1261 0x9713, /* PCI_CHIP_RS880_9713 */
1262 0x9714, /* PCI_CHIP_RS880_9714 */
1263 0x9715, /* PCI_CHIP_RS880_9715 */
1264 0x9440, /* PCI_CHIP_RV770_9440 */
1265 0x9441, /* PCI_CHIP_RV770_9441 */
1266 0x9442, /* PCI_CHIP_RV770_9442 */
1267 0x9443, /* PCI_CHIP_RV770_9443 */
1268 0x9444, /* PCI_CHIP_RV770_9444 */
1269 0x9446, /* PCI_CHIP_RV770_9446 */
1270 0x944A, /* PCI_CHIP_RV770_944A */
1271 0x944B, /* PCI_CHIP_RV770_944B */
1272 0x944C, /* PCI_CHIP_RV770_944C */
1273 0x944E, /* PCI_CHIP_RV770_944E */
1274 0x9450, /* PCI_CHIP_RV770_9450 */
1275 0x9452, /* PCI_CHIP_RV770_9452 */
1276 0x9456, /* PCI_CHIP_RV770_9456 */
1277 0x945A, /* PCI_CHIP_RV770_945A */
1278 0x945B, /* PCI_CHIP_RV770_945B */
1279 0x945E, /* PCI_CHIP_RV770_945E */
1280 0x9460, /* PCI_CHIP_RV790_9460 */
1281 0x9462, /* PCI_CHIP_RV790_9462 */
1282 0x946A, /* PCI_CHIP_RV770_946A */
1283 0x946B, /* PCI_CHIP_RV770_946B */
1284 0x947A, /* PCI_CHIP_RV770_947A */
1285 0x947B, /* PCI_CHIP_RV770_947B */
1286 0x9480, /* PCI_CHIP_RV730_9480 */
1287 0x9487, /* PCI_CHIP_RV730_9487 */
1288 0x9488, /* PCI_CHIP_RV730_9488 */
1289 0x9489, /* PCI_CHIP_RV730_9489 */
1290 0x948A, /* PCI_CHIP_RV730_948A */
1291 0x948F, /* PCI_CHIP_RV730_948F */
1292 0x9490, /* PCI_CHIP_RV730_9490 */
1293 0x9491, /* PCI_CHIP_RV730_9491 */
1294 0x9495, /* PCI_CHIP_RV730_9495 */
1295 0x9498, /* PCI_CHIP_RV730_9498 */
1296 0x949C, /* PCI_CHIP_RV730_949C */
1297 0x949E, /* PCI_CHIP_RV730_949E */
1298 0x949F, /* PCI_CHIP_RV730_949F */
1299 0x9540, /* PCI_CHIP_RV710_9540 */
1300 0x9541, /* PCI_CHIP_RV710_9541 */
1301 0x9542, /* PCI_CHIP_RV710_9542 */
1302 0x954E, /* PCI_CHIP_RV710_954E */
1303 0x954F, /* PCI_CHIP_RV710_954F */
1304 0x9552, /* PCI_CHIP_RV710_9552 */
1305 0x9553, /* PCI_CHIP_RV710_9553 */
1306 0x9555, /* PCI_CHIP_RV710_9555 */
1307 0x9557, /* PCI_CHIP_RV710_9557 */
1308 0x955F, /* PCI_CHIP_RV710_955F */
1309 0x94A0, /* PCI_CHIP_RV740_94A0 */
1310 0x94A1, /* PCI_CHIP_RV740_94A1 */
1311 0x94A3, /* PCI_CHIP_RV740_94A3 */
1312 0x94B1, /* PCI_CHIP_RV740_94B1 */
1313 0x94B3, /* PCI_CHIP_RV740_94B3 */
1314 0x94B4, /* PCI_CHIP_RV740_94B4 */
1315 0x94B5, /* PCI_CHIP_RV740_94B5 */
1316 0x94B9, /* PCI_CHIP_RV740_94B9 */
1317 0x68E0, /* PCI_CHIP_CEDAR_68E0 */
1318 0x68E1, /* PCI_CHIP_CEDAR_68E1 */
1319 0x68E4, /* PCI_CHIP_CEDAR_68E4 */
1320 0x68E5, /* PCI_CHIP_CEDAR_68E5 */
1321 0x68E8, /* PCI_CHIP_CEDAR_68E8 */
1322 0x68E9, /* PCI_CHIP_CEDAR_68E9 */
1323 0x68F1, /* PCI_CHIP_CEDAR_68F1 */
1324 0x68F8, /* PCI_CHIP_CEDAR_68F8 */
1325 0x68F9, /* PCI_CHIP_CEDAR_68F9 */
1326 0x68FE, /* PCI_CHIP_CEDAR_68FE */
1327 0x68C0, /* PCI_CHIP_REDWOOD_68C0 */
1328 0x68C1, /* PCI_CHIP_REDWOOD_68C1 */
1329 0x68C8, /* PCI_CHIP_REDWOOD_68C8 */
1330 0x68C9, /* PCI_CHIP_REDWOOD_68C9 */
1331 0x68D8, /* PCI_CHIP_REDWOOD_68D8 */
1332 0x68D9, /* PCI_CHIP_REDWOOD_68D9 */
1333 0x68DA, /* PCI_CHIP_REDWOOD_68DA */
1334 0x68DE, /* PCI_CHIP_REDWOOD_68DE */
1335 0x68A0, /* PCI_CHIP_JUNIPER_68A0 */
1336 0x68A1, /* PCI_CHIP_JUNIPER_68A1 */
1337 0x68A8, /* PCI_CHIP_JUNIPER_68A8 */
1338 0x68A9, /* PCI_CHIP_JUNIPER_68A9 */
1339 0x68B0, /* PCI_CHIP_JUNIPER_68B0 */
1340 0x68B8, /* PCI_CHIP_JUNIPER_68B8 */
1341 0x68B9, /* PCI_CHIP_JUNIPER_68B9 */
1342 0x68BE, /* PCI_CHIP_JUNIPER_68BE */
1343 0x6880, /* PCI_CHIP_CYPRESS_6880 */
1344 0x6888, /* PCI_CHIP_CYPRESS_6888 */
1345 0x6889, /* PCI_CHIP_CYPRESS_6889 */
1346 0x688A, /* PCI_CHIP_CYPRESS_688A */
1347 0x6898, /* PCI_CHIP_CYPRESS_6898 */
1348 0x6899, /* PCI_CHIP_CYPRESS_6899 */
1349 0x689E, /* PCI_CHIP_CYPRESS_689E */
1350 0x689C, /* PCI_CHIP_HEMLOCK_689C */
1351 0x689D, /* PCI_CHIP_HEMLOCK_689D */
1352 };
1353
1354 const struct dri2_driver_map driver_map[] = {
1355 { 0x8086, "i915", i915_chip_ids, ARRAY_SIZE(i915_chip_ids) },
1356 { 0x8086, "i965", i965_chip_ids, ARRAY_SIZE(i965_chip_ids) },
1357 { 0x1002, "radeon", r100_chip_ids, ARRAY_SIZE(r100_chip_ids) },
1358 { 0x1002, "r200", r200_chip_ids, ARRAY_SIZE(r200_chip_ids) },
1359 { 0x1002, "r300", r300_chip_ids, ARRAY_SIZE(r300_chip_ids) },
1360 { 0x1002, "r600", r600_chip_ids, ARRAY_SIZE(r600_chip_ids) },
1361 };
1362
1363 static char *
1364 dri2_get_driver_for_fd(int fd)
1365 {
1366 struct udev *udev;
1367 struct udev_device *device, *parent;
1368 struct stat buf;
1369 const char *pci_id;
1370 char *driver = NULL;
1371 int vendor_id, chip_id, i, j;
1372
1373 udev = udev_new();
1374 if (fstat(fd, &buf) < 0) {
1375 _eglLog(_EGL_WARNING, "EGL-DRI2: failed to stat fd %d", fd);
1376 goto out;
1377 }
1378
1379 device = udev_device_new_from_devnum(udev, 'c', buf.st_rdev);
1380 if (device == NULL) {
1381 _eglLog(_EGL_WARNING,
1382 "EGL-DRI2: could not create udev device for fd %d", fd);
1383 goto out;
1384 }
1385
1386 parent = udev_device_get_parent(device);
1387 if (parent == NULL) {
1388 _eglLog(_EGL_WARNING, "DRI2: could not get parent device");
1389 goto out;
1390 }
1391
1392 pci_id = udev_device_get_property_value(parent, "PCI_ID");
1393 if (pci_id == NULL || sscanf(pci_id, "%x:%x", &vendor_id, &chip_id) != 2) {
1394 _eglLog(_EGL_WARNING, "EGL-DRI2: malformed or no PCI ID");
1395 goto out;
1396 }
1397
1398 for (i = 0; i < ARRAY_SIZE(driver_map); i++) {
1399 if (vendor_id != driver_map[i].vendor_id)
1400 continue;
1401 for (j = 0; j < driver_map[i].num_chips_ids; j++)
1402 if (driver_map[i].chip_ids[j] == chip_id) {
1403 driver = strdup(driver_map[i].driver);
1404 _eglLog(_EGL_DEBUG, "pci id for %d: %04x:%04x, driver %s",
1405 fd, vendor_id, chip_id, driver);
1406 goto out;
1407 }
1408 }
1409
1410 out:
1411 udev_device_unref(device);
1412 udev_unref(udev);
1413
1414 return driver;
1415 }
1416
1417 static EGLBoolean
1418 dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp,
1419 EGLint *major, EGLint *minor)
1420 {
1421 struct dri2_egl_display *dri2_dpy;
1422 int i;
1423
1424 dri2_dpy = malloc(sizeof *dri2_dpy);
1425 if (!dri2_dpy)
1426 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
1427
1428 disp->DriverData = (void *) dri2_dpy;
1429 dri2_dpy->fd = (int) disp->PlatformDisplay;
1430
1431 dri2_dpy->driver_name = dri2_get_driver_for_fd(dri2_dpy->fd);
1432 if (dri2_dpy->driver_name == NULL)
1433 return _eglError(EGL_BAD_ALLOC, "DRI2: failed to get driver name");
1434
1435 if (!dri2_load_driver(disp))
1436 goto cleanup_driver_name;
1437
1438 dri2_dpy->extensions[0] = &image_lookup_extension.base;
1439 dri2_dpy->extensions[1] = &use_invalidate.base;
1440 dri2_dpy->extensions[2] = NULL;
1441
1442 if (!dri2_create_screen(disp))
1443 goto cleanup_driver;
1444
1445 for (i = 0; dri2_dpy->driver_configs[i]; i++)
1446 dri2_add_config(disp, dri2_dpy->driver_configs[i], i + 1, 0, 0);
1447
1448 disp->Extensions.MESA_drm_image = EGL_TRUE;
1449 disp->Extensions.KHR_image_base = EGL_TRUE;
1450 disp->Extensions.KHR_gl_renderbuffer_image = EGL_TRUE;
1451 disp->Extensions.KHR_gl_texture_2D_image = EGL_TRUE;
1452
1453 /* we're supporting EGL 1.4 */
1454 *major = 1;
1455 *minor = 4;
1456
1457 return EGL_TRUE;
1458
1459 cleanup_driver:
1460 dlclose(dri2_dpy->driver);
1461 cleanup_driver_name:
1462 free(dri2_dpy->driver_name);
1463
1464 return EGL_FALSE;
1465 }
1466
1467 #endif
1468
1469 /**
1470 * Called via eglInitialize(), GLX_drv->API.Initialize().
1471 */
1472 static EGLBoolean
1473 dri2_initialize(_EGLDriver *drv, _EGLDisplay *disp,
1474 EGLint *major, EGLint *minor)
1475 {
1476 switch (disp->Platform) {
1477 case _EGL_PLATFORM_X11:
1478 return dri2_initialize_x11(drv, disp, major, minor);
1479
1480 #ifdef HAVE_LIBUDEV
1481 case _EGL_PLATFORM_DRM:
1482 return dri2_initialize_drm(drv, disp, major, minor);
1483 #endif
1484
1485 default:
1486 return EGL_FALSE;
1487 }
1488 }
1489
1490 /**
1491 * Called via eglTerminate(), drv->API.Terminate().
1492 */
1493 static EGLBoolean
1494 dri2_terminate(_EGLDriver *drv, _EGLDisplay *disp)
1495 {
1496 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1497
1498 _eglReleaseDisplayResources(drv, disp);
1499 _eglCleanupDisplay(disp);
1500
1501 dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
1502 close(dri2_dpy->fd);
1503 dlclose(dri2_dpy->driver);
1504 if (disp->PlatformDisplay == NULL)
1505 xcb_disconnect(dri2_dpy->conn);
1506 free(dri2_dpy);
1507 disp->DriverData = NULL;
1508
1509 return EGL_TRUE;
1510 }
1511
1512
1513 /**
1514 * Called via eglCreateContext(), drv->API.CreateContext().
1515 */
1516 static _EGLContext *
1517 dri2_create_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLConfig *conf,
1518 _EGLContext *share_list, const EGLint *attrib_list)
1519 {
1520 struct dri2_egl_context *dri2_ctx;
1521 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1522 struct dri2_egl_context *dri2_ctx_shared = dri2_egl_context(share_list);
1523 struct dri2_egl_config *dri2_config = dri2_egl_config(conf);
1524 const __DRIconfig *dri_config;
1525 int api;
1526
1527 (void) drv;
1528
1529 dri2_ctx = malloc(sizeof *dri2_ctx);
1530 if (!dri2_ctx) {
1531 _eglError(EGL_BAD_ALLOC, "eglCreateContext");
1532 return NULL;
1533 }
1534
1535 if (!_eglInitContext(&dri2_ctx->base, disp, conf, attrib_list))
1536 goto cleanup;
1537
1538 switch (dri2_ctx->base.ClientAPI) {
1539 case EGL_OPENGL_ES_API:
1540 switch (dri2_ctx->base.ClientVersion) {
1541 case 1:
1542 api = __DRI_API_GLES;
1543 break;
1544 case 2:
1545 api = __DRI_API_GLES2;
1546 break;
1547 default:
1548 _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
1549 return NULL;
1550 }
1551 break;
1552 case EGL_OPENGL_API:
1553 api = __DRI_API_OPENGL;
1554 break;
1555 default:
1556 _eglError(EGL_BAD_PARAMETER, "eglCreateContext");
1557 return NULL;
1558 }
1559
1560 if (conf != NULL)
1561 dri_config = dri2_config->dri_config;
1562 else
1563 dri_config = NULL;
1564
1565 if (dri2_dpy->dri2->base.version >= 2) {
1566 dri2_ctx->dri_context =
1567 dri2_dpy->dri2->createNewContextForAPI(dri2_dpy->dri_screen,
1568 api,
1569 dri_config,
1570 dri2_ctx_shared ?
1571 dri2_ctx_shared->dri_context : NULL,
1572 dri2_ctx);
1573 } else if (api == __DRI_API_OPENGL) {
1574 dri2_ctx->dri_context =
1575 dri2_dpy->dri2->createNewContext(dri2_dpy->dri_screen,
1576 dri2_config->dri_config,
1577 dri2_ctx_shared ?
1578 dri2_ctx_shared->dri_context : NULL,
1579 dri2_ctx);
1580 } else {
1581 /* fail */
1582 }
1583
1584 if (!dri2_ctx->dri_context)
1585 goto cleanup;
1586
1587 return &dri2_ctx->base;
1588
1589 cleanup:
1590 free(dri2_ctx);
1591 return NULL;
1592 }
1593
1594 static EGLBoolean
1595 dri2_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
1596 {
1597 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1598 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1599
1600 (void) drv;
1601
1602 if (!_eglPutSurface(surf))
1603 return EGL_TRUE;
1604
1605 (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
1606
1607 xcb_dri2_destroy_drawable (dri2_dpy->conn, dri2_surf->drawable);
1608
1609 if (surf->Type == EGL_PBUFFER_BIT)
1610 xcb_free_pixmap (dri2_dpy->conn, dri2_surf->drawable);
1611
1612 free(surf);
1613
1614 return EGL_TRUE;
1615 }
1616
1617 /**
1618 * Called via eglMakeCurrent(), drv->API.MakeCurrent().
1619 */
1620 static EGLBoolean
1621 dri2_make_current(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *dsurf,
1622 _EGLSurface *rsurf, _EGLContext *ctx)
1623 {
1624 struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1625 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1626 struct dri2_egl_surface *dri2_dsurf = dri2_egl_surface(dsurf);
1627 struct dri2_egl_surface *dri2_rsurf = dri2_egl_surface(rsurf);
1628 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
1629 _EGLContext *old_ctx;
1630 _EGLSurface *old_dsurf, *old_rsurf;
1631 __DRIdrawable *ddraw, *rdraw;
1632 __DRIcontext *cctx;
1633
1634 /* make new bindings */
1635 if (!_eglBindContext(ctx, dsurf, rsurf, &old_ctx, &old_dsurf, &old_rsurf))
1636 return EGL_FALSE;
1637
1638 /* flush before context switch */
1639 if (old_ctx && dri2_drv->glFlush)
1640 dri2_drv->glFlush();
1641
1642 ddraw = (dri2_dsurf) ? dri2_dsurf->dri_drawable : NULL;
1643 rdraw = (dri2_rsurf) ? dri2_rsurf->dri_drawable : NULL;
1644 cctx = (dri2_ctx) ? dri2_ctx->dri_context : NULL;
1645
1646 if ((cctx == NULL && ddraw == NULL && rdraw == NULL) ||
1647 dri2_dpy->core->bindContext(cctx, ddraw, rdraw)) {
1648 dri2_destroy_surface(drv, disp, old_dsurf);
1649 dri2_destroy_surface(drv, disp, old_rsurf);
1650 if (old_ctx) {
1651 dri2_dpy->core->unbindContext(dri2_egl_context(old_ctx)->dri_context);
1652 /* no destroy? */
1653 _eglPutContext(old_ctx);
1654 }
1655
1656 return EGL_TRUE;
1657 } else {
1658 /* undo the previous _eglBindContext */
1659 _eglBindContext(old_ctx, old_dsurf, old_rsurf, &ctx, &dsurf, &rsurf);
1660 assert(&dri2_ctx->base == ctx &&
1661 &dri2_dsurf->base == dsurf &&
1662 &dri2_rsurf->base == rsurf);
1663
1664 _eglPutSurface(dsurf);
1665 _eglPutSurface(rsurf);
1666 _eglPutContext(ctx);
1667
1668 _eglPutSurface(old_dsurf);
1669 _eglPutSurface(old_rsurf);
1670 _eglPutContext(old_ctx);
1671
1672 return EGL_FALSE;
1673 }
1674 }
1675
1676 /**
1677 * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
1678 */
1679 static _EGLSurface *
1680 dri2_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
1681 _EGLConfig *conf, EGLNativeWindowType window,
1682 const EGLint *attrib_list)
1683 {
1684 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1685 struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
1686 struct dri2_egl_surface *dri2_surf;
1687 xcb_get_geometry_cookie_t cookie;
1688 xcb_get_geometry_reply_t *reply;
1689 xcb_screen_iterator_t s;
1690 xcb_generic_error_t *error;
1691
1692 (void) drv;
1693
1694 dri2_surf = malloc(sizeof *dri2_surf);
1695 if (!dri2_surf) {
1696 _eglError(EGL_BAD_ALLOC, "dri2_create_surface");
1697 return NULL;
1698 }
1699
1700 if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list))
1701 goto cleanup_surf;
1702
1703 dri2_surf->region = XCB_NONE;
1704 if (type == EGL_PBUFFER_BIT) {
1705 dri2_surf->drawable = xcb_generate_id(dri2_dpy->conn);
1706 s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
1707 xcb_create_pixmap(dri2_dpy->conn, conf->BufferSize,
1708 dri2_surf->drawable, s.data->root,
1709 dri2_surf->base.Width, dri2_surf->base.Height);
1710 } else {
1711 dri2_surf->drawable = window;
1712 }
1713
1714 dri2_surf->dri_drawable =
1715 (*dri2_dpy->dri2->createNewDrawable) (dri2_dpy->dri_screen,
1716 dri2_conf->dri_config, dri2_surf);
1717 if (dri2_surf->dri_drawable == NULL) {
1718 _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable");
1719 goto cleanup_pixmap;
1720 }
1721
1722 xcb_dri2_create_drawable (dri2_dpy->conn, dri2_surf->drawable);
1723
1724 if (type != EGL_PBUFFER_BIT) {
1725 cookie = xcb_get_geometry (dri2_dpy->conn, dri2_surf->drawable);
1726 reply = xcb_get_geometry_reply (dri2_dpy->conn, cookie, &error);
1727 if (reply == NULL || error != NULL) {
1728 _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
1729 free(error);
1730 goto cleanup_dri_drawable;
1731 }
1732
1733 dri2_surf->base.Width = reply->width;
1734 dri2_surf->base.Height = reply->height;
1735 free(reply);
1736 }
1737
1738 return &dri2_surf->base;
1739
1740 cleanup_dri_drawable:
1741 dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
1742 cleanup_pixmap:
1743 if (type == EGL_PBUFFER_BIT)
1744 xcb_free_pixmap(dri2_dpy->conn, dri2_surf->drawable);
1745 cleanup_surf:
1746 free(dri2_surf);
1747
1748 return NULL;
1749 }
1750
1751 /**
1752 * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
1753 */
1754 static _EGLSurface *
1755 dri2_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
1756 _EGLConfig *conf, EGLNativeWindowType window,
1757 const EGLint *attrib_list)
1758 {
1759 return dri2_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
1760 window, attrib_list);
1761 }
1762
1763 static _EGLSurface *
1764 dri2_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
1765 _EGLConfig *conf, EGLNativePixmapType pixmap,
1766 const EGLint *attrib_list)
1767 {
1768 return dri2_create_surface(drv, disp, EGL_PIXMAP_BIT, conf,
1769 pixmap, attrib_list);
1770 }
1771
1772 static _EGLSurface *
1773 dri2_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
1774 _EGLConfig *conf, const EGLint *attrib_list)
1775 {
1776 return dri2_create_surface(drv, disp, EGL_PBUFFER_BIT, conf,
1777 XCB_WINDOW_NONE, attrib_list);
1778 }
1779
1780 static EGLBoolean
1781 dri2_copy_region(_EGLDriver *drv, _EGLDisplay *disp,
1782 _EGLSurface *draw, xcb_xfixes_region_t region)
1783 {
1784 struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1785 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1786 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1787 _EGLContext *ctx;
1788 xcb_dri2_copy_region_cookie_t cookie;
1789
1790 if (dri2_drv->glFlush) {
1791 ctx = _eglGetCurrentContext();
1792 if (ctx && ctx->DrawSurface == &dri2_surf->base)
1793 dri2_drv->glFlush();
1794 }
1795
1796 (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1797
1798 #if 0
1799 /* FIXME: Add support for dri swapbuffers, that'll give us swap
1800 * interval and page flipping (at least for fullscreen windows) as
1801 * well as the page flip event. Unless surface->SwapBehavior is
1802 * EGL_BUFFER_PRESERVED. */
1803 #if __DRI2_FLUSH_VERSION >= 2
1804 if (pdraw->psc->f)
1805 (*pdraw->psc->f->flushInvalidate)(pdraw->driDrawable);
1806 #endif
1807 #endif
1808
1809 if (!dri2_surf->have_fake_front)
1810 return EGL_TRUE;
1811
1812 cookie = xcb_dri2_copy_region_unchecked(dri2_dpy->conn,
1813 dri2_surf->drawable,
1814 region,
1815 XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT,
1816 XCB_DRI2_ATTACHMENT_BUFFER_FAKE_FRONT_LEFT);
1817 free(xcb_dri2_copy_region_reply(dri2_dpy->conn, cookie, NULL));
1818
1819 return EGL_TRUE;
1820 }
1821
1822 static EGLBoolean
1823 dri2_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
1824 {
1825 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1826
1827 return dri2_copy_region(drv, disp, draw, dri2_surf->region);
1828 }
1829
1830 static EGLBoolean
1831 dri2_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw,
1832 EGLint numRects, const EGLint *rects)
1833 {
1834 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1835 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
1836 EGLBoolean ret;
1837 xcb_xfixes_region_t region;
1838 xcb_rectangle_t rectangles[16];
1839 int i;
1840
1841 if (numRects > (int)ARRAY_SIZE(rectangles))
1842 return dri2_copy_region(drv, disp, draw, dri2_surf->region);
1843
1844 /* FIXME: Invert y here? */
1845 for (i = 0; i < numRects; i++) {
1846 rectangles[i].x = rects[i * 4];
1847 rectangles[i].y = rects[i * 4 + 1];
1848 rectangles[i].width = rects[i * 4 + 2];
1849 rectangles[i].height = rects[i * 4 + 3];
1850 }
1851
1852 region = xcb_generate_id(dri2_dpy->conn);
1853 xcb_xfixes_create_region(dri2_dpy->conn, region, numRects, rectangles);
1854 ret = dri2_copy_region(drv, disp, draw, region);
1855 xcb_xfixes_destroy_region(dri2_dpy->conn, region);
1856
1857 return ret;
1858 }
1859
1860 /*
1861 * Called from eglGetProcAddress() via drv->API.GetProcAddress().
1862 */
1863 static _EGLProc
1864 dri2_get_proc_address(_EGLDriver *drv, const char *procname)
1865 {
1866 (void) drv;
1867
1868 /* FIXME: Do we need to support lookup of EGL symbols too? */
1869
1870 return (_EGLProc) _glapi_get_proc_address(procname);
1871 }
1872
1873 static EGLBoolean
1874 dri2_wait_client(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
1875 {
1876 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1877 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(ctx->DrawSurface);
1878
1879 (void) drv;
1880
1881 /* FIXME: If EGL allows frontbuffer rendering for window surfaces,
1882 * we need to copy fake to real here.*/
1883
1884 (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1885
1886 return EGL_TRUE;
1887 }
1888
1889 static EGLBoolean
1890 dri2_wait_native(_EGLDriver *drv, _EGLDisplay *disp, EGLint engine)
1891 {
1892 (void) drv;
1893 (void) disp;
1894
1895 if (engine != EGL_CORE_NATIVE_ENGINE)
1896 return _eglError(EGL_BAD_PARAMETER, "eglWaitNative");
1897 /* glXWaitX(); */
1898
1899 return EGL_TRUE;
1900 }
1901
1902 static void
1903 dri2_unload(_EGLDriver *drv)
1904 {
1905 struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
1906 free(dri2_drv);
1907 }
1908
1909 static EGLBoolean
1910 dri2_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf,
1911 EGLNativePixmapType target)
1912 {
1913 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1914 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1915 xcb_gcontext_t gc;
1916
1917 (void) drv;
1918
1919 (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
1920
1921 gc = xcb_generate_id(dri2_dpy->conn);
1922 xcb_create_gc(dri2_dpy->conn, gc, target, 0, NULL);
1923 xcb_copy_area(dri2_dpy->conn,
1924 dri2_surf->drawable,
1925 target,
1926 gc,
1927 0, 0,
1928 0, 0,
1929 dri2_surf->base.Width,
1930 dri2_surf->base.Height);
1931 xcb_free_gc(dri2_dpy->conn, gc);
1932
1933 return EGL_TRUE;
1934 }
1935
1936 static EGLBoolean
1937 dri2_bind_tex_image(_EGLDriver *drv,
1938 _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
1939 {
1940 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1941 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
1942 struct dri2_egl_context *dri2_ctx;
1943 _EGLContext *ctx;
1944 GLint format, target;
1945
1946 ctx = _eglGetCurrentContext();
1947 dri2_ctx = dri2_egl_context(ctx);
1948
1949 if (!_eglBindTexImage(drv, disp, surf, buffer))
1950 return EGL_FALSE;
1951
1952 switch (dri2_surf->base.TextureFormat) {
1953 case EGL_TEXTURE_RGB:
1954 format = __DRI_TEXTURE_FORMAT_RGB;
1955 break;
1956 case EGL_TEXTURE_RGBA:
1957 format = __DRI_TEXTURE_FORMAT_RGBA;
1958 break;
1959 default:
1960 assert(0);
1961 }
1962
1963 switch (dri2_surf->base.TextureTarget) {
1964 case EGL_TEXTURE_2D:
1965 target = GL_TEXTURE_2D;
1966 break;
1967 default:
1968 assert(0);
1969 }
1970
1971 (*dri2_dpy->tex_buffer->setTexBuffer2)(dri2_ctx->dri_context,
1972 target, format,
1973 dri2_surf->dri_drawable);
1974
1975 return EGL_TRUE;
1976 }
1977
1978 static EGLBoolean
1979 dri2_release_tex_image(_EGLDriver *drv,
1980 _EGLDisplay *disp, _EGLSurface *surf, EGLint buffer)
1981 {
1982 (void) drv;
1983 (void) disp;
1984 (void) surf;
1985 (void) buffer;
1986
1987 return EGL_TRUE;
1988 }
1989
1990 static _EGLImage *
1991 dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx,
1992 EGLClientBuffer buffer, const EGLint *attr_list)
1993 {
1994 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
1995 struct dri2_egl_image *dri2_img;
1996 unsigned int attachments[1];
1997 xcb_drawable_t drawable;
1998 xcb_dri2_get_buffers_cookie_t buffers_cookie;
1999 xcb_dri2_get_buffers_reply_t *buffers_reply;
2000 xcb_dri2_dri2_buffer_t *buffers;
2001 xcb_get_geometry_cookie_t geometry_cookie;
2002 xcb_get_geometry_reply_t *geometry_reply;
2003 xcb_generic_error_t *error;
2004 int stride, format;
2005
2006 (void) ctx;
2007
2008 drawable = (xcb_drawable_t) buffer;
2009 xcb_dri2_create_drawable (dri2_dpy->conn, drawable);
2010 attachments[0] = XCB_DRI2_ATTACHMENT_BUFFER_FRONT_LEFT;
2011 buffers_cookie =
2012 xcb_dri2_get_buffers_unchecked (dri2_dpy->conn,
2013 drawable, 1, 1, attachments);
2014 geometry_cookie = xcb_get_geometry (dri2_dpy->conn, drawable);
2015 buffers_reply = xcb_dri2_get_buffers_reply (dri2_dpy->conn,
2016 buffers_cookie, NULL);
2017 buffers = xcb_dri2_get_buffers_buffers (buffers_reply);
2018 if (buffers == NULL) {
2019 return NULL;
2020 }
2021
2022 geometry_reply = xcb_get_geometry_reply (dri2_dpy->conn,
2023 geometry_cookie, &error);
2024 if (geometry_reply == NULL || error != NULL) {
2025 _eglError(EGL_BAD_ALLOC, "xcb_get_geometry");
2026 free(error);
2027 free(buffers_reply);
2028 }
2029
2030 switch (geometry_reply->depth) {
2031 case 16:
2032 format = __DRI_IMAGE_FORMAT_RGB565;
2033 break;
2034 case 24:
2035 format = __DRI_IMAGE_FORMAT_XRGB8888;
2036 break;
2037 case 32:
2038 format = __DRI_IMAGE_FORMAT_ARGB8888;
2039 break;
2040 default:
2041 _eglError(EGL_BAD_PARAMETER,
2042 "dri2_create_image_khr: unsupported pixmap depth");
2043 free(buffers_reply);
2044 free(geometry_reply);
2045 return NULL;
2046 }
2047
2048 dri2_img = malloc(sizeof *dri2_img);
2049 if (!dri2_img) {
2050 free(buffers_reply);
2051 free(geometry_reply);
2052 _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
2053 return EGL_NO_IMAGE_KHR;
2054 }
2055
2056 if (!_eglInitImage(&dri2_img->base, disp)) {
2057 free(buffers_reply);
2058 free(geometry_reply);
2059 return EGL_NO_IMAGE_KHR;
2060 }
2061
2062 stride = buffers[0].pitch / buffers[0].cpp;
2063 dri2_img->dri_image =
2064 dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
2065 buffers_reply->width,
2066 buffers_reply->height,
2067 format,
2068 buffers[0].name,
2069 stride,
2070 dri2_img);
2071
2072 free(buffers_reply);
2073 free(geometry_reply);
2074
2075 return &dri2_img->base;
2076 }
2077
2078 static _EGLImage *
2079 dri2_create_image_khr_renderbuffer(_EGLDisplay *disp, _EGLContext *ctx,
2080 EGLClientBuffer buffer,
2081 const EGLint *attr_list)
2082 {
2083 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2084 struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
2085 struct dri2_egl_image *dri2_img;
2086 GLuint renderbuffer = (GLuint) buffer;
2087
2088 if (renderbuffer == 0) {
2089 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2090 return EGL_NO_IMAGE_KHR;
2091 }
2092
2093 dri2_img = malloc(sizeof *dri2_img);
2094 if (!dri2_img) {
2095 _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
2096 return EGL_NO_IMAGE_KHR;
2097 }
2098
2099 if (!_eglInitImage(&dri2_img->base, disp))
2100 return EGL_NO_IMAGE_KHR;
2101
2102 dri2_img->dri_image =
2103 dri2_dpy->image->createImageFromRenderbuffer(dri2_ctx->dri_context,
2104 renderbuffer,
2105 dri2_img);
2106
2107 return &dri2_img->base;
2108 }
2109
2110 static _EGLImage *
2111 dri2_create_image_mesa_drm_buffer(_EGLDisplay *disp, _EGLContext *ctx,
2112 EGLClientBuffer buffer, const EGLint *attr_list)
2113 {
2114 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2115 struct dri2_egl_image *dri2_img;
2116 EGLint format, name, pitch, err;
2117 _EGLImageAttribs attrs;
2118
2119 (void) ctx;
2120
2121 name = (EGLint) buffer;
2122
2123 err = _eglParseImageAttribList(&attrs, disp, attr_list);
2124 if (err != EGL_SUCCESS)
2125 return NULL;
2126
2127 if (attrs.Width <= 0 || attrs.Height <= 0 ||
2128 attrs.DRMBufferStrideMESA <= 0) {
2129 _eglError(EGL_BAD_PARAMETER,
2130 "bad width, height or stride");
2131 return NULL;
2132 }
2133
2134 switch (attrs.DRMBufferFormatMESA) {
2135 case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
2136 format = __DRI_IMAGE_FORMAT_ARGB8888;
2137 pitch = attrs.DRMBufferStrideMESA;
2138 break;
2139 default:
2140 _eglError(EGL_BAD_PARAMETER,
2141 "dri2_create_image_khr: unsupported pixmap depth");
2142 return NULL;
2143 }
2144
2145 dri2_img = malloc(sizeof *dri2_img);
2146 if (!dri2_img) {
2147 _eglError(EGL_BAD_ALLOC, "dri2_create_image_mesa_drm");
2148 return NULL;
2149 }
2150
2151 if (!_eglInitImage(&dri2_img->base, disp)) {
2152 free(dri2_img);
2153 return NULL;
2154 }
2155
2156 dri2_img->dri_image =
2157 dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
2158 attrs.Width,
2159 attrs.Height,
2160 format,
2161 name,
2162 pitch,
2163 dri2_img);
2164 if (dri2_img->dri_image == NULL) {
2165 free(dri2_img);
2166 _eglError(EGL_BAD_ALLOC, "dri2_create_image_mesa_drm");
2167 return NULL;
2168 }
2169
2170 return &dri2_img->base;
2171 }
2172
2173 static _EGLImage *
2174 dri2_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
2175 _EGLContext *ctx, EGLenum target,
2176 EGLClientBuffer buffer, const EGLint *attr_list)
2177 {
2178 (void) drv;
2179
2180 switch (target) {
2181 case EGL_NATIVE_PIXMAP_KHR:
2182 return dri2_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
2183 case EGL_GL_RENDERBUFFER_KHR:
2184 return dri2_create_image_khr_renderbuffer(disp, ctx, buffer, attr_list);
2185 case EGL_DRM_BUFFER_MESA:
2186 return dri2_create_image_mesa_drm_buffer(disp, ctx, buffer, attr_list);
2187 default:
2188 _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
2189 return EGL_NO_IMAGE_KHR;
2190 }
2191 }
2192
2193 static EGLBoolean
2194 dri2_destroy_image_khr(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *image)
2195 {
2196 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2197 struct dri2_egl_image *dri2_img = dri2_egl_image(image);
2198
2199 (void) drv;
2200
2201 dri2_dpy->image->destroyImage(dri2_img->dri_image);
2202 free(dri2_img);
2203
2204 return EGL_TRUE;
2205 }
2206
2207 static _EGLImage *
2208 dri2_create_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp,
2209 const EGLint *attr_list)
2210 {
2211 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2212 struct dri2_egl_image *dri2_img;
2213 _EGLImageAttribs attrs;
2214 unsigned int dri_use, valid_mask;
2215 int format;
2216 EGLint err = EGL_SUCCESS;
2217
2218 (void) drv;
2219
2220 dri2_img = malloc(sizeof *dri2_img);
2221 if (!dri2_img) {
2222 _eglError(EGL_BAD_ALLOC, "dri2_create_image_khr");
2223 return EGL_NO_IMAGE_KHR;
2224 }
2225
2226 if (!attr_list) {
2227 err = EGL_BAD_PARAMETER;
2228 goto cleanup_img;
2229 }
2230
2231 if (!_eglInitImage(&dri2_img->base, disp)) {
2232 err = EGL_BAD_PARAMETER;
2233 goto cleanup_img;
2234 }
2235
2236 err = _eglParseImageAttribList(&attrs, disp, attr_list);
2237 if (err != EGL_SUCCESS)
2238 goto cleanup_img;
2239
2240 if (attrs.Width <= 0 || attrs.Height <= 0) {
2241 _eglLog(_EGL_WARNING, "bad width or height (%dx%d)",
2242 attrs.Width, attrs.Height);
2243 goto cleanup_img;
2244 }
2245
2246 switch (attrs.DRMBufferFormatMESA) {
2247 case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
2248 format = __DRI_IMAGE_FORMAT_ARGB8888;
2249 break;
2250 default:
2251 _eglLog(_EGL_WARNING, "bad image format value 0x%04x",
2252 attrs.DRMBufferFormatMESA);
2253 goto cleanup_img;
2254 }
2255
2256 valid_mask =
2257 EGL_DRM_BUFFER_USE_SCANOUT_MESA |
2258 EGL_DRM_BUFFER_USE_SHARE_MESA;
2259 if (attrs.DRMBufferUseMESA & ~valid_mask) {
2260 _eglLog(_EGL_WARNING, "bad image use bit 0x%04x",
2261 attrs.DRMBufferUseMESA & ~valid_mask);
2262 goto cleanup_img;
2263 }
2264
2265 dri_use = 0;
2266 if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SHARE_MESA)
2267 dri_use |= __DRI_IMAGE_USE_SHARE;
2268 if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SCANOUT_MESA)
2269 dri_use |= __DRI_IMAGE_USE_SCANOUT;
2270
2271 dri2_img->dri_image =
2272 dri2_dpy->image->createImage(dri2_dpy->dri_screen,
2273 attrs.Width, attrs.Height,
2274 format, dri_use, dri2_img);
2275 if (dri2_img->dri_image == NULL) {
2276 err = EGL_BAD_ALLOC;
2277 goto cleanup_img;
2278 }
2279
2280 return &dri2_img->base;
2281
2282 cleanup_img:
2283 free(dri2_img);
2284 _eglError(err, "dri2_create_drm_image_mesa");
2285
2286 return EGL_NO_IMAGE_KHR;
2287 }
2288
2289 static EGLBoolean
2290 dri2_export_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
2291 EGLint *name, EGLint *handle, EGLint *stride)
2292 {
2293 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
2294 struct dri2_egl_image *dri2_img = dri2_egl_image(img);
2295
2296 (void) drv;
2297
2298 if (name && !dri2_dpy->image->queryImage(dri2_img->dri_image,
2299 __DRI_IMAGE_ATTRIB_NAME, name)) {
2300 _eglError(EGL_BAD_ALLOC, "dri2_export_drm_image_mesa");
2301 return EGL_FALSE;
2302 }
2303
2304 if (handle)
2305 dri2_dpy->image->queryImage(dri2_img->dri_image,
2306 __DRI_IMAGE_ATTRIB_HANDLE, handle);
2307
2308 if (stride)
2309 dri2_dpy->image->queryImage(dri2_img->dri_image,
2310 __DRI_IMAGE_ATTRIB_STRIDE, stride);
2311
2312 return EGL_TRUE;
2313 }
2314
2315 /**
2316 * This is the main entrypoint into the driver, called by libEGL.
2317 * Create a new _EGLDriver object and init its dispatch table.
2318 */
2319 _EGLDriver *
2320 _eglMain(const char *args)
2321 {
2322 struct dri2_egl_driver *dri2_drv;
2323
2324 (void) args;
2325
2326 dri2_drv = malloc(sizeof *dri2_drv);
2327 if (!dri2_drv)
2328 return NULL;
2329
2330 memset(dri2_drv, 0, sizeof *dri2_drv);
2331 _eglInitDriverFallbacks(&dri2_drv->base);
2332 dri2_drv->base.API.Initialize = dri2_initialize;
2333 dri2_drv->base.API.Terminate = dri2_terminate;
2334 dri2_drv->base.API.CreateContext = dri2_create_context;
2335 dri2_drv->base.API.MakeCurrent = dri2_make_current;
2336 dri2_drv->base.API.CreateWindowSurface = dri2_create_window_surface;
2337 dri2_drv->base.API.CreatePixmapSurface = dri2_create_pixmap_surface;
2338 dri2_drv->base.API.CreatePbufferSurface = dri2_create_pbuffer_surface;
2339 dri2_drv->base.API.DestroySurface = dri2_destroy_surface;
2340 dri2_drv->base.API.SwapBuffers = dri2_swap_buffers;
2341 dri2_drv->base.API.GetProcAddress = dri2_get_proc_address;
2342 dri2_drv->base.API.WaitClient = dri2_wait_client;
2343 dri2_drv->base.API.WaitNative = dri2_wait_native;
2344 dri2_drv->base.API.CopyBuffers = dri2_copy_buffers;
2345 dri2_drv->base.API.BindTexImage = dri2_bind_tex_image;
2346 dri2_drv->base.API.ReleaseTexImage = dri2_release_tex_image;
2347 dri2_drv->base.API.CreateImageKHR = dri2_create_image_khr;
2348 dri2_drv->base.API.DestroyImageKHR = dri2_destroy_image_khr;
2349 dri2_drv->base.API.SwapBuffersRegionNOK = dri2_swap_buffers_region;
2350 dri2_drv->base.API.CreateDRMImageMESA = dri2_create_drm_image_mesa;
2351 dri2_drv->base.API.ExportDRMImageMESA = dri2_export_drm_image_mesa;
2352
2353 dri2_drv->base.Name = "DRI2";
2354 dri2_drv->base.Unload = dri2_unload;
2355
2356 dri2_drv->glFlush =
2357 (void (*)(void)) dri2_get_proc_address(&dri2_drv->base, "glFlush");
2358
2359 return &dri2_drv->base;
2360 }