platform_android.c revision 2a69de60bf9d8a4b35a115a0b1ac115301dd954d 
1/*
2 * Mesa 3-D graphics library
3 * Version:  7.12
4 *
5 * Copyright (C) 2010-2011 Chia-I Wu <olvaffe@gmail.com>
6 * Copyright (C) 2010-2011 LunarG Inc.
7 *
8 * Based on platform_x11, which has
9 *
10 * Copyright © 2011 Intel Corporation
11 *
12 * Permission is hereby granted, free of charge, to any person obtaining a
13 * copy of this software and associated documentation files (the "Software"),
14 * to deal in the Software without restriction, including without limitation
15 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
16 * and/or sell copies of the Software, and to permit persons to whom the
17 * Software is furnished to do so, subject to the following conditions:
18 *
19 * The above copyright notice and this permission notice shall be included
20 * in all copies or substantial portions of the Software.
21 *
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
25 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28 * DEALINGS IN THE SOFTWARE.
29 */
30
31#include <errno.h>
32#include <dlfcn.h>
33
34/* for droid_get_pci_id */
35#include <xf86drm.h>
36#include <i915_drm.h>
37#include <radeon_drm.h>
38
39#include "egl_dri2.h"
40
41static int
42get_format_bpp(int native)
43{
44   int bpp;
45
46   switch (native) {
47   case HAL_PIXEL_FORMAT_RGBA_8888:
48   case HAL_PIXEL_FORMAT_RGBX_8888:
49   case HAL_PIXEL_FORMAT_BGRA_8888:
50      bpp = 4;
51      break;
52   case HAL_PIXEL_FORMAT_RGB_888:
53      bpp = 3;
54      break;
55   case HAL_PIXEL_FORMAT_RGB_565:
56   case HAL_PIXEL_FORMAT_RGBA_5551:
57   case HAL_PIXEL_FORMAT_RGBA_4444:
58      bpp = 2;
59      break;
60   default:
61      bpp = 0;
62      break;
63   }
64
65   return bpp;
66}
67
68static int
69get_native_buffer_name(struct ANativeWindowBuffer *buf)
70{
71   struct gralloc_drm_handle_t *handle;
72
73   /* check that the buffer is allocated by drm_gralloc and cast */
74   handle = gralloc_drm_handle(buf->handle);
75
76   return (handle) ? handle->name : 0;
77}
78
79static EGLBoolean
80droid_window_dequeue_buffer(struct dri2_egl_surface *dri2_surf)
81{
82   if (dri2_surf->window->dequeueBuffer(dri2_surf->window, &dri2_surf->buffer))
83      return EGL_FALSE;
84
85   dri2_surf->buffer->common.incRef(&dri2_surf->buffer->common);
86   dri2_surf->window->lockBuffer(dri2_surf->window, dri2_surf->buffer);
87
88   return EGL_TRUE;
89}
90
91static EGLBoolean
92droid_window_enqueue_buffer(struct dri2_egl_surface *dri2_surf)
93{
94   dri2_surf->window->queueBuffer(dri2_surf->window, dri2_surf->buffer);
95
96   dri2_surf->buffer->common.decRef(&dri2_surf->buffer->common);
97   dri2_surf->buffer = NULL;
98
99   return EGL_TRUE;
100}
101
102static void
103droid_window_cancel_buffer(struct dri2_egl_surface *dri2_surf)
104{
105   /* no cancel buffer? */
106   droid_window_enqueue_buffer(dri2_surf);
107}
108
109static __DRIbuffer *
110droid_alloc_local_buffer(struct dri2_egl_surface *dri2_surf,
111                         unsigned int att, unsigned int format)
112{
113   struct dri2_egl_display *dri2_dpy =
114      dri2_egl_display(dri2_surf->base.Resource.Display);
115
116   if (att >= ARRAY_SIZE(dri2_surf->local_buffers))
117      return NULL;
118
119   if (!dri2_surf->local_buffers[att]) {
120      dri2_surf->local_buffers[att] =
121         dri2_dpy->dri2->allocateBuffer(dri2_dpy->dri_screen, att, format,
122               dri2_surf->base.Width, dri2_surf->base.Height);
123   }
124
125   return dri2_surf->local_buffers[att];
126}
127
128static void
129droid_free_local_buffers(struct dri2_egl_surface *dri2_surf)
130{
131   struct dri2_egl_display *dri2_dpy =
132      dri2_egl_display(dri2_surf->base.Resource.Display);
133   int i;
134
135   for (i = 0; i < ARRAY_SIZE(dri2_surf->local_buffers); i++) {
136      if (dri2_surf->local_buffers[i]) {
137         dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
138               dri2_surf->local_buffers[i]);
139         dri2_surf->local_buffers[i] = NULL;
140      }
141   }
142}
143
144static _EGLSurface *
145droid_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
146		    _EGLConfig *conf, EGLNativeWindowType window,
147		    const EGLint *attrib_list)
148{
149   struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
150   struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
151   struct dri2_egl_surface *dri2_surf;
152   dri2_surf = calloc(1, sizeof *dri2_surf);
153   if (!dri2_surf) {
154      _eglError(EGL_BAD_ALLOC, "droid_create_surface");
155      return NULL;
156   }
157
158   if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list))
159      goto cleanup_surface;
160
161   if (type == EGL_WINDOW_BIT) {
162      int format;
163
164      if (!window || window->common.magic != ANDROID_NATIVE_WINDOW_MAGIC) {
165         _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface");
166         goto cleanup_surface;
167      }
168      if (window->query(window, NATIVE_WINDOW_FORMAT, &format)) {
169         _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface");
170         goto cleanup_surface;
171      }
172
173      if (format != dri2_conf->base.NativeVisualID) {
174         _eglLog(_EGL_WARNING, "Native format mismatch: 0x%x != 0x%x",
175               format, dri2_conf->base.NativeVisualID);
176      }
177
178      window->query(window, NATIVE_WINDOW_WIDTH, &dri2_surf->base.Width);
179      window->query(window, NATIVE_WINDOW_HEIGHT, &dri2_surf->base.Height);
180   }
181
182   dri2_surf->dri_drawable =
183      (*dri2_dpy->dri2->createNewDrawable)(dri2_dpy->dri_screen,
184					   dri2_conf->dri_double_config,
185                                           dri2_surf);
186   if (dri2_surf->dri_drawable == NULL) {
187      _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable");
188      goto cleanup_surface;
189   }
190
191   if (window) {
192      window->common.incRef(&window->common);
193      dri2_surf->window = window;
194   }
195
196   return &dri2_surf->base;
197
198cleanup_surface:
199   free(dri2_surf);
200
201   return NULL;
202}
203
204static _EGLSurface *
205droid_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
206			   _EGLConfig *conf, EGLNativeWindowType window,
207			   const EGLint *attrib_list)
208{
209   return droid_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
210			      window, attrib_list);
211}
212
213static _EGLSurface *
214droid_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
215			   _EGLConfig *conf, EGLNativePixmapType pixmap,
216			   const EGLint *attrib_list)
217{
218   return NULL;
219}
220
221static _EGLSurface *
222droid_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
223			    _EGLConfig *conf, const EGLint *attrib_list)
224{
225   return droid_create_surface(drv, disp, EGL_PBUFFER_BIT, conf,
226			      NULL, attrib_list);
227}
228
229static EGLBoolean
230droid_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
231{
232   struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
233   struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
234
235   if (!_eglPutSurface(surf))
236      return EGL_TRUE;
237
238   droid_free_local_buffers(dri2_surf);
239
240   if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
241      if (dri2_surf->buffer)
242         droid_window_cancel_buffer(dri2_surf);
243
244      dri2_surf->window->common.decRef(&dri2_surf->window->common);
245   }
246
247   (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
248
249   free(dri2_surf);
250
251   return EGL_TRUE;
252}
253
254static EGLBoolean
255droid_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
256{
257   struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
258   struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
259   struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
260   _EGLContext *ctx;
261
262   if (dri2_surf->base.Type != EGL_WINDOW_BIT)
263      return EGL_TRUE;
264
265   if (dri2_drv->glFlush) {
266      ctx = _eglGetCurrentContext();
267      if (ctx && ctx->DrawSurface == &dri2_surf->base)
268         dri2_drv->glFlush();
269   }
270
271   (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
272
273   if (dri2_surf->buffer)
274      droid_window_enqueue_buffer(dri2_surf);
275
276   (*dri2_dpy->flush->invalidate)(dri2_surf->dri_drawable);
277
278   return EGL_TRUE;
279}
280
281static _EGLImage *
282dri2_create_image_android_native_buffer(_EGLDisplay *disp,
283                                        struct ANativeWindowBuffer *buf)
284{
285   struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
286   struct dri2_egl_image *dri2_img;
287   int name;
288   EGLint format;
289
290   if (!buf || buf->common.magic != ANDROID_NATIVE_BUFFER_MAGIC ||
291       buf->common.version != sizeof(*buf)) {
292      _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
293      return NULL;
294   }
295
296   name = get_native_buffer_name(buf);
297   if (!name) {
298      _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
299      return NULL;
300   }
301
302   /* see the table in droid_add_configs_for_visuals */
303   switch (buf->format) {
304   case HAL_PIXEL_FORMAT_BGRA_8888:
305      format = __DRI_IMAGE_FORMAT_ARGB8888;
306      break;
307   case HAL_PIXEL_FORMAT_RGB_565:
308      format = __DRI_IMAGE_FORMAT_RGB565;
309      break;
310   case HAL_PIXEL_FORMAT_RGBA_8888:
311      format = __DRI_IMAGE_FORMAT_ABGR8888;
312      break;
313   case HAL_PIXEL_FORMAT_RGBX_8888:
314      format = __DRI_IMAGE_FORMAT_XBGR8888;
315      break;
316   case HAL_PIXEL_FORMAT_RGB_888:
317   case HAL_PIXEL_FORMAT_RGBA_5551:
318   case HAL_PIXEL_FORMAT_RGBA_4444:
319      /* unsupported */
320   default:
321      _eglLog(_EGL_WARNING, "unsupported native buffer format 0x%x", buf->format);
322      return NULL;
323      break;
324   }
325
326   dri2_img = calloc(1, sizeof(*dri2_img));
327   if (!dri2_img) {
328      _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm");
329      return NULL;
330   }
331
332   if (!_eglInitImage(&dri2_img->base, disp)) {
333      free(dri2_img);
334      return NULL;
335   }
336
337   dri2_img->dri_image =
338      dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
339					   buf->width,
340					   buf->height,
341					   format,
342					   name,
343					   buf->stride,
344					   dri2_img);
345   if (!dri2_img->dri_image) {
346      free(dri2_img);
347      _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm");
348      return NULL;
349   }
350
351   return &dri2_img->base;
352}
353
354static _EGLImage *
355droid_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
356		       _EGLContext *ctx, EGLenum target,
357		       EGLClientBuffer buffer, const EGLint *attr_list)
358{
359   switch (target) {
360   case EGL_NATIVE_BUFFER_ANDROID:
361      return dri2_create_image_android_native_buffer(disp,
362            (struct ANativeWindowBuffer *) buffer);
363   default:
364      return dri2_create_image_khr(drv, disp, ctx, target, buffer, attr_list);
365   }
366}
367
368static void
369droid_init_driver_functions(_EGLDriver *drv)
370{
371   drv->API.CreateWindowSurface = droid_create_window_surface;
372   drv->API.CreatePixmapSurface = droid_create_pixmap_surface;
373   drv->API.CreatePbufferSurface = droid_create_pbuffer_surface;
374   drv->API.DestroySurface = droid_destroy_surface;
375   drv->API.SwapBuffers = droid_swap_buffers;
376
377   drv->API.CreateImageKHR = droid_create_image_khr;
378}
379
380static void
381droid_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
382{
383}
384
385static int
386droid_get_buffers_parse_attachments(struct dri2_egl_surface *dri2_surf,
387                                    unsigned int *attachments, int count)
388{
389   int num_buffers = 0, i;
390
391   /* fill dri2_surf->buffers */
392   for (i = 0; i < count * 2; i += 2) {
393      __DRIbuffer *buf, *local;
394
395      assert(num_buffers < ARRAY_SIZE(dri2_surf->buffers));
396      buf = &dri2_surf->buffers[num_buffers];
397
398      switch (attachments[i]) {
399      case __DRI_BUFFER_BACK_LEFT:
400         if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
401            buf->attachment = attachments[i];
402            buf->name = get_native_buffer_name(dri2_surf->buffer);
403            buf->cpp = get_format_bpp(dri2_surf->buffer->format);
404            buf->pitch = dri2_surf->buffer->stride * buf->cpp;
405            buf->flags = 0;
406
407            if (buf->name)
408               num_buffers++;
409
410            break;
411         }
412         /* fall through for pbuffers */
413      case __DRI_BUFFER_DEPTH:
414      case __DRI_BUFFER_STENCIL:
415      case __DRI_BUFFER_ACCUM:
416      case __DRI_BUFFER_DEPTH_STENCIL:
417      case __DRI_BUFFER_HIZ:
418         local = droid_alloc_local_buffer(dri2_surf,
419               attachments[i], attachments[i + 1]);
420
421         if (local) {
422            *buf = *local;
423            num_buffers++;
424         }
425         break;
426      case __DRI_BUFFER_FRONT_LEFT:
427      case __DRI_BUFFER_FRONT_RIGHT:
428      case __DRI_BUFFER_FAKE_FRONT_LEFT:
429      case __DRI_BUFFER_FAKE_FRONT_RIGHT:
430      case __DRI_BUFFER_BACK_RIGHT:
431      default:
432         /* no front or right buffers */
433         break;
434      }
435   }
436
437   return num_buffers;
438}
439
440static __DRIbuffer *
441droid_get_buffers_with_format(__DRIdrawable * driDrawable,
442			     int *width, int *height,
443			     unsigned int *attachments, int count,
444			     int *out_count, void *loaderPrivate)
445{
446   struct dri2_egl_surface *dri2_surf = loaderPrivate;
447   struct dri2_egl_display *dri2_dpy =
448      dri2_egl_display(dri2_surf->base.Resource.Display);
449   int i;
450
451   if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
452      /* try to dequeue the next back buffer */
453      if (!dri2_surf->buffer && !droid_window_dequeue_buffer(dri2_surf))
454         return NULL;
455
456      /* free outdated buffers and update the surface size */
457      if (dri2_surf->base.Width != dri2_surf->buffer->width ||
458          dri2_surf->base.Height != dri2_surf->buffer->height) {
459         droid_free_local_buffers(dri2_surf);
460         dri2_surf->base.Width = dri2_surf->buffer->width;
461         dri2_surf->base.Height = dri2_surf->buffer->height;
462      }
463   }
464
465   dri2_surf->buffer_count =
466      droid_get_buffers_parse_attachments(dri2_surf, attachments, count);
467
468   if (width)
469      *width = dri2_surf->base.Width;
470   if (height)
471      *height = dri2_surf->base.Height;
472
473   *out_count = dri2_surf->buffer_count;;
474
475   return dri2_surf->buffers;
476}
477
478static EGLBoolean
479droid_add_configs_for_visuals(_EGLDriver *drv, _EGLDisplay *dpy)
480{
481   struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
482   const struct {
483      int format;
484      int size;
485      unsigned int rgba_masks[4];
486   } visuals[] = {
487      { HAL_PIXEL_FORMAT_RGBA_8888, 32, { 0xff, 0xff00, 0xff0000, 0xff000000 } },
488      { HAL_PIXEL_FORMAT_RGBX_8888, 32, { 0xff, 0xff00, 0xff0000, 0x0 } },
489      { HAL_PIXEL_FORMAT_RGB_888,   24, { 0xff, 0xff00, 0xff0000, 0x0 } },
490      { HAL_PIXEL_FORMAT_RGB_565,   16, { 0xf800, 0x7e0, 0x1f, 0x0 } },
491      { HAL_PIXEL_FORMAT_BGRA_8888, 32, { 0xff0000, 0xff00, 0xff, 0xff000000 } },
492      { 0, 0, { 0, 0, 0, 0 } }
493   };
494   int count, i, j;
495
496   count = 0;
497   for (i = 0; visuals[i].format; i++) {
498      int format_count = 0;
499
500      for (j = 0; dri2_dpy->driver_configs[j]; j++) {
501         const EGLint surface_type = EGL_WINDOW_BIT | EGL_PBUFFER_BIT;
502         struct dri2_egl_config *dri2_conf;
503
504         dri2_conf = dri2_add_config(dpy, dri2_dpy->driver_configs[j],
505               count + 1, visuals[i].size, surface_type, NULL,
506               visuals[i].rgba_masks);
507         if (dri2_conf) {
508            dri2_conf->base.NativeVisualID = visuals[i].format;
509            dri2_conf->base.NativeVisualType = visuals[i].format;
510            count++;
511            format_count++;
512         }
513      }
514
515      if (!format_count) {
516         _eglLog(_EGL_DEBUG, "No DRI config supports native format 0x%x",
517               visuals[i].format);
518      }
519   }
520
521   /* post-process configs */
522   for (i = 0; i < dpy->Configs->Size; i++) {
523      struct dri2_egl_config *dri2_conf = dri2_egl_config(dpy->Configs->Elements[i]);
524
525      /* there is no front buffer so no OpenGL */
526      dri2_conf->base.RenderableType &= ~EGL_OPENGL_BIT;
527      dri2_conf->base.Conformant &= ~EGL_OPENGL_BIT;
528
529      /*
530       * We want to make sure GL_DRAW_BUFFER for windows or pbuffers is always
531       * GL_BACK.  For EGL configs that do not have a double DRI config, clear
532       * the surface type.
533       *
534       * This is just to be on the safe side.  dri2_add_config never sets
535       * EGL_WINDOW_BIT or EGL_PBUFFER_BIT for such configs.
536       */
537      if (!dri2_conf->dri_double_config)
538         dri2_conf->base.SurfaceType = 0;
539   }
540
541   return (count != 0);
542}
543
544static EGLBoolean
545droid_get_pci_id(int fd, int *vendor_id, int *chip_id)
546{
547   drmVersionPtr version;
548
549   *chip_id = -1;
550
551   version = drmGetVersion(fd);
552   if (!version) {
553      _eglLog(_EGL_WARNING, "invalid drm fd");
554      return EGL_FALSE;
555   }
556   if (!version->name) {
557      _eglLog(_EGL_WARNING, "unable to determine the driver name");
558      drmFreeVersion(version);
559      return EGL_FALSE;
560   }
561
562   if (strcmp(version->name, "i915") == 0) {
563      struct drm_i915_getparam gp;
564      int ret;
565
566      *vendor_id = 0x8086;
567
568      memset(&gp, 0, sizeof(gp));
569      gp.param = I915_PARAM_CHIPSET_ID;
570      gp.value = chip_id;
571      ret = drmCommandWriteRead(fd, DRM_I915_GETPARAM, &gp, sizeof(gp));
572      if (ret) {
573         _eglLog(_EGL_WARNING, "failed to get param for i915");
574	 *chip_id = -1;
575      }
576   }
577   else if (strcmp(version->name, "radeon") == 0) {
578      struct drm_radeon_info info;
579      int ret;
580
581      *vendor_id = 0x1002;
582
583      memset(&info, 0, sizeof(info));
584      info.request = RADEON_INFO_DEVICE_ID;
585      info.value = (unsigned long) chip_id;
586      ret = drmCommandWriteRead(fd, DRM_RADEON_INFO, &info, sizeof(info));
587      if (ret) {
588         _eglLog(_EGL_WARNING, "failed to get info for radeon");
589	 *chip_id = -1;
590      }
591   }
592   else if (strcmp(version->name, "nouveau") == 0) {
593      *vendor_id = 0x10de;
594      /* not used */
595      *chip_id = 0;
596   }
597   else if (strcmp(version->name, "vmwgfx") == 0) {
598      *vendor_id = 0x15ad;
599      /* assume SVGA II */
600      *chip_id = 0x0405;
601   }
602
603   drmFreeVersion(version);
604
605   return (*chip_id >= 0);
606}
607
608#define DRIVER_MAP_DRI2_ONLY
609#include "pci_ids/pci_id_driver_map.h"
610static const char *
611droid_get_driver_name(int fd)
612{
613   int vendor_id = -1, chip_id = -1;
614   int idx, i;
615   char *name;
616
617   if (!droid_get_pci_id(fd, &vendor_id, &chip_id))
618      return NULL;
619
620   for (idx = 0; driver_map[idx].driver; idx++) {
621      if (vendor_id != driver_map[idx].vendor_id)
622         continue;
623
624      if (driver_map[idx].num_chips_ids == -1)
625         break;
626
627      for (i = 0; i < driver_map[idx].num_chips_ids; i++) {
628         if (driver_map[idx].chip_ids[i] == chip_id)
629            break;
630      }
631      if (i < driver_map[idx].num_chips_ids)
632	      break;
633   }
634
635   _eglLog(_EGL_INFO, "pci id for fd %d: %04x:%04x, driver %s",
636         fd, vendor_id, chip_id, driver_map[idx].driver);
637
638   return driver_map[idx].driver;
639}
640
641static int
642droid_open_device(void)
643{
644   const hw_module_t *mod;
645   int fd = -1, err;
646
647   err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &mod);
648   if (!err) {
649      const gralloc_module_t *gr = (gralloc_module_t *) mod;
650
651      err = -EINVAL;
652      if (gr->perform)
653         err = gr->perform(gr, GRALLOC_MODULE_PERFORM_GET_DRM_FD, &fd);
654   }
655   if (err || fd < 0) {
656      _eglLog(_EGL_WARNING, "fail to get drm fd");
657      fd = -1;
658   }
659
660   return (fd >= 0) ? dup(fd) : -1;
661}
662
663/* support versions < JellyBean */
664#ifndef ALOGW
665#define ALOGW LOGW
666#endif
667#ifndef ALOGD
668#define ALOGD LOGD
669#endif
670#ifndef ALOGI
671#define ALOGI LOGI
672#endif
673
674static void
675droid_log(EGLint level, const char *msg)
676{
677   switch (level) {
678   case _EGL_DEBUG:
679      ALOGD("%s", msg);
680      break;
681   case _EGL_INFO:
682      ALOGI("%s", msg);
683      break;
684   case _EGL_WARNING:
685      ALOGW("%s", msg);
686      break;
687   case _EGL_FATAL:
688      LOG_FATAL("%s", msg);
689      break;
690   default:
691      break;
692   }
693}
694
695EGLBoolean
696dri2_initialize_android(_EGLDriver *drv, _EGLDisplay *dpy)
697{
698   struct dri2_egl_display *dri2_dpy;
699   const char *err;
700
701   _eglSetLogProc(droid_log);
702
703   dri2_dpy = calloc(1, sizeof(*dri2_dpy));
704   if (!dri2_dpy)
705      return _eglError(EGL_BAD_ALLOC, "eglInitialize");
706
707   dpy->DriverData = (void *) dri2_dpy;
708
709   dri2_dpy->fd = droid_open_device();
710   if (dri2_dpy->fd < 0) {
711      err = "DRI2: failed to open device";
712      goto cleanup_display;
713   }
714
715   dri2_dpy->driver_name = (char *) droid_get_driver_name(dri2_dpy->fd);
716   if (dri2_dpy->driver_name == NULL) {
717      err = "DRI2: failed to get driver name";
718      goto cleanup_device;
719   }
720
721   if (!dri2_load_driver(dpy)) {
722      err = "DRI2: failed to load driver";
723      goto cleanup_device;
724   }
725
726   dri2_dpy->dri2_loader_extension.base.name = __DRI_DRI2_LOADER;
727   dri2_dpy->dri2_loader_extension.base.version = 3;
728   dri2_dpy->dri2_loader_extension.getBuffers = NULL;
729   dri2_dpy->dri2_loader_extension.flushFrontBuffer = droid_flush_front_buffer;
730   dri2_dpy->dri2_loader_extension.getBuffersWithFormat =
731      droid_get_buffers_with_format;
732
733   dri2_dpy->extensions[0] = &dri2_dpy->dri2_loader_extension.base;
734   dri2_dpy->extensions[1] = &image_lookup_extension.base;
735   dri2_dpy->extensions[2] = &use_invalidate.base;
736   dri2_dpy->extensions[3] = NULL;
737
738   if (!dri2_create_screen(dpy)) {
739      err = "DRI2: failed to create screen";
740      goto cleanup_driver;
741   }
742
743   if (!droid_add_configs_for_visuals(drv, dpy)) {
744      err = "DRI2: failed to add configs";
745      goto cleanup_screen;
746   }
747
748   dpy->Extensions.ANDROID_image_native_buffer = EGL_TRUE;
749   dpy->Extensions.KHR_image_base = EGL_TRUE;
750
751   /* we're supporting EGL 1.4 */
752   dpy->VersionMajor = 1;
753   dpy->VersionMinor = 4;
754
755   droid_init_driver_functions(drv);
756
757   return EGL_TRUE;
758
759cleanup_screen:
760   dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
761cleanup_driver:
762   dlclose(dri2_dpy->driver);
763cleanup_device:
764   close(dri2_dpy->fd);
765cleanup_display:
766   free(dri2_dpy);
767
768   return _eglError(EGL_NOT_INITIALIZED, err);
769}
770