src/egl/drivers/dri2/platform_android.c

   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 #if ANDROID_VERSION >= 0x402
  35 #include <sync/sync.h>
  36 #endif
  37
  38 /* for droid_get_pci_id */
  39 #include <xf86drm.h>
  40 #include <i915_drm.h>
  41 #include <radeon_drm.h>
  42
  43 #include "egl_dri2.h"
  44 #include "gralloc_drm.h"
  45
  46 static int
  47 get_format_bpp(int native)
  48 {
  49    int bpp;
  50
  51    switch (native) {
  52    case HAL_PIXEL_FORMAT_RGBA_8888:
  53    case HAL_PIXEL_FORMAT_RGBX_8888:
  54    case HAL_PIXEL_FORMAT_BGRA_8888:
  55       bpp = 4;
  56       break;
  57    case HAL_PIXEL_FORMAT_RGB_888:
  58       bpp = 3;
  59       break;
  60    case HAL_PIXEL_FORMAT_RGB_565:
  61    case HAL_PIXEL_FORMAT_RGBA_5551:
  62    case HAL_PIXEL_FORMAT_RGBA_4444:
  63       bpp = 2;
  64       break;
  65    default:
  66       bpp = 0;
  67       break;
  68    }
  69
  70    return bpp;
  71 }
  72
  73 static int
  74 get_native_buffer_name(struct ANativeWindowBuffer *buf)
  75 {
  76    return gralloc_drm_get_gem_handle(buf->handle);
  77 }
  78
  79 static EGLBoolean
  80 droid_window_dequeue_buffer(struct dri2_egl_surface *dri2_surf)
  81 {
  82 #if ANDROID_VERSION >= 0x0402
  83    int fence_fd;
  84
  85    if (dri2_surf->window->dequeueBuffer(dri2_surf->window, &dri2_surf->buffer,
  86                                         &fence_fd))
  87       return EGL_FALSE;
  88
  89    /* If access to the buffer is controlled by a sync fence, then block on the
  90     * fence.
  91     *
  92     * It may be more performant to postpone blocking until there is an
  93     * immediate need to write to the buffer. But doing so would require adding
  94     * hooks to the DRI2 loader.
  95     *
  96     * From the ANativeWindow::dequeueBuffer documentation:
  97     *
  98     *    The libsync fence file descriptor returned in the int pointed to by
  99     *    the fenceFd argument will refer to the fence that must signal
 100     *    before the dequeued buffer may be written to.  A value of -1
 101     *    indicates that the caller may access the buffer immediately without
 102     *    waiting on a fence.  If a valid file descriptor is returned (i.e.
 103     *    any value except -1) then the caller is responsible for closing the
 104     *    file descriptor.
 105     */
 106     if (fence_fd >= 0) {
 107        /* From the SYNC_IOC_WAIT documentation in <linux/sync.h>:
 108         *
 109         *    Waits indefinitely if timeout < 0.
 110         */
 111         int timeout = -1;
 112         sync_wait(fence_fd, timeout);
 113         close(fence_fd);
 114    }
 115
 116    dri2_surf->buffer->common.incRef(&dri2_surf->buffer->common);
 117 #else
 118    if (dri2_surf->window->dequeueBuffer(dri2_surf->window, &dri2_surf->buffer))
 119       return EGL_FALSE;
 120
 121    dri2_surf->buffer->common.incRef(&dri2_surf->buffer->common);
 122    dri2_surf->window->lockBuffer(dri2_surf->window, dri2_surf->buffer);
 123 #endif
 124
 125    return EGL_TRUE;
 126 }
 127
 128 static EGLBoolean
 129 droid_window_enqueue_buffer(struct dri2_egl_surface *dri2_surf)
 130 {
 131 #if ANDROID_VERSION >= 0x0402
 132    /* Queue the buffer without a sync fence. This informs the ANativeWindow
 133     * that it may access the buffer immediately.
 134     *
 135     * From ANativeWindow::dequeueBuffer:
 136     *
 137     *    The fenceFd argument specifies a libsync fence file descriptor for
 138     *    a fence that must signal before the buffer can be accessed.  If
 139     *    the buffer can be accessed immediately then a value of -1 should
 140     *    be used.  The caller must not use the file descriptor after it
 141     *    is passed to queueBuffer, and the ANativeWindow implementation
 142     *    is responsible for closing it.
 143     */
 144    int fence_fd = -1;
 145    dri2_surf->window->queueBuffer(dri2_surf->window, dri2_surf->buffer,
 146                                   fence_fd);
 147 #else
 148    dri2_surf->window->queueBuffer(dri2_surf->window, dri2_surf->buffer);
 149 #endif
 150
 151    dri2_surf->buffer->common.decRef(&dri2_surf->buffer->common);
 152    dri2_surf->buffer = NULL;
 153
 154    return EGL_TRUE;
 155 }
 156
 157 static void
 158 droid_window_cancel_buffer(struct dri2_egl_surface *dri2_surf)
 159 {
 160    /* no cancel buffer? */
 161    droid_window_enqueue_buffer(dri2_surf);
 162 }
 163
 164 static __DRIbuffer *
 165 droid_alloc_local_buffer(struct dri2_egl_surface *dri2_surf,
 166                          unsigned int att, unsigned int format)
 167 {
 168    struct dri2_egl_display *dri2_dpy =
 169       dri2_egl_display(dri2_surf->base.Resource.Display);
 170
 171    if (att >= ARRAY_SIZE(dri2_surf->local_buffers))
 172       return NULL;
 173
 174    if (!dri2_surf->local_buffers[att]) {
 175       dri2_surf->local_buffers[att] =
 176          dri2_dpy->dri2->allocateBuffer(dri2_dpy->dri_screen, att, format,
 177                dri2_surf->base.Width, dri2_surf->base.Height);
 178    }
 179
 180    return dri2_surf->local_buffers[att];
 181 }
 182
 183 static void
 184 droid_free_local_buffers(struct dri2_egl_surface *dri2_surf)
 185 {
 186    struct dri2_egl_display *dri2_dpy =
 187       dri2_egl_display(dri2_surf->base.Resource.Display);
 188    int i;
 189
 190    for (i = 0; i < ARRAY_SIZE(dri2_surf->local_buffers); i++) {
 191       if (dri2_surf->local_buffers[i]) {
 192          dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
 193                dri2_surf->local_buffers[i]);
 194          dri2_surf->local_buffers[i] = NULL;
 195       }
 196    }
 197 }
 198
 199 static _EGLSurface *
 200 droid_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
 201                     _EGLConfig *conf, EGLNativeWindowType window,
 202                     const EGLint *attrib_list)
 203 {
 204    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 205    struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
 206    struct dri2_egl_surface *dri2_surf;
 207    dri2_surf = calloc(1, sizeof *dri2_surf);
 208    if (!dri2_surf) {
 209       _eglError(EGL_BAD_ALLOC, "droid_create_surface");
 210       return NULL;
 211    }
 212
 213    if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list))
 214       goto cleanup_surface;
 215
 216    if (type == EGL_WINDOW_BIT) {
 217       int format;
 218
 219       if (!window || window->common.magic != ANDROID_NATIVE_WINDOW_MAGIC) {
 220          _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface");
 221          goto cleanup_surface;
 222       }
 223       if (window->query(window, NATIVE_WINDOW_FORMAT, &format)) {
 224          _eglError(EGL_BAD_NATIVE_WINDOW, "droid_create_surface");
 225          goto cleanup_surface;
 226       }
 227
 228       if (format != dri2_conf->base.NativeVisualID) {
 229          _eglLog(_EGL_WARNING, "Native format mismatch: 0x%x != 0x%x",
 230                format, dri2_conf->base.NativeVisualID);
 231       }
 232
 233       window->query(window, NATIVE_WINDOW_WIDTH, &dri2_surf->base.Width);
 234       window->query(window, NATIVE_WINDOW_HEIGHT, &dri2_surf->base.Height);
 235    }
 236
 237    dri2_surf->dri_drawable =
 238       (*dri2_dpy->dri2->createNewDrawable)(dri2_dpy->dri_screen,
 239                                            dri2_conf->dri_double_config,
 240                                            dri2_surf);
 241    if (dri2_surf->dri_drawable == NULL) {
 242       _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable");
 243       goto cleanup_surface;
 244    }
 245
 246    if (window) {
 247       window->common.incRef(&window->common);
 248       dri2_surf->window = window;
 249    }
 250
 251    return &dri2_surf->base;
 252
 253 cleanup_surface:
 254    free(dri2_surf);
 255
 256    return NULL;
 257 }
 258
 259 static _EGLSurface *
 260 droid_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
 261                            _EGLConfig *conf, EGLNativeWindowType window,
 262                            const EGLint *attrib_list)
 263 {
 264    return droid_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
 265                               window, attrib_list);
 266 }
 267
 268 static _EGLSurface *
 269 droid_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
 270                            _EGLConfig *conf, EGLNativePixmapType pixmap,
 271                            const EGLint *attrib_list)
 272 {
 273    return NULL;
 274 }
 275
 276 static _EGLSurface *
 277 droid_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
 278                             _EGLConfig *conf, const EGLint *attrib_list)
 279 {
 280    return droid_create_surface(drv, disp, EGL_PBUFFER_BIT, conf,
 281                               NULL, attrib_list);
 282 }
 283
 284 static EGLBoolean
 285 droid_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
 286 {
 287    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 288    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
 289
 290    if (!_eglPutSurface(surf))
 291       return EGL_TRUE;
 292
 293    droid_free_local_buffers(dri2_surf);
 294
 295    if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
 296       if (dri2_surf->buffer)
 297          droid_window_cancel_buffer(dri2_surf);
 298
 299       dri2_surf->window->common.decRef(&dri2_surf->window->common);
 300    }
 301
 302    (*dri2_dpy->core->destroyDrawable)(dri2_surf->dri_drawable);
 303
 304    free(dri2_surf);
 305
 306    return EGL_TRUE;
 307 }
 308
 309 static EGLBoolean
 310 droid_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
 311 {
 312    struct dri2_egl_driver *dri2_drv = dri2_egl_driver(drv);
 313    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 314    struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
 315    _EGLContext *ctx;
 316
 317    if (dri2_surf->base.Type != EGL_WINDOW_BIT)
 318       return EGL_TRUE;
 319
 320    if (dri2_drv->glFlush) {
 321       ctx = _eglGetCurrentContext();
 322       if (ctx && ctx->DrawSurface == &dri2_surf->base)
 323          dri2_drv->glFlush();
 324    }
 325
 326    (*dri2_dpy->flush->flush)(dri2_surf->dri_drawable);
 327
 328    if (dri2_surf->buffer)
 329       droid_window_enqueue_buffer(dri2_surf);
 330
 331    (*dri2_dpy->flush->invalidate)(dri2_surf->dri_drawable);
 332
 333    return EGL_TRUE;
 334 }
 335
 336 static _EGLImage *
 337 dri2_create_image_android_native_buffer(_EGLDisplay *disp, _EGLContext *ctx,
 338                                         struct ANativeWindowBuffer *buf)
 339 {
 340    struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
 341    struct dri2_egl_image *dri2_img;
 342    int name;
 343    EGLint format;
 344
 345    if (ctx != NULL) {
 346       /* From the EGL_ANDROID_image_native_buffer spec:
 347        *
 348        *     * If <target> is EGL_NATIVE_BUFFER_ANDROID and <ctx> is not
 349        *       EGL_NO_CONTEXT, the error EGL_BAD_CONTEXT is generated.
 350        */
 351       _eglError(EGL_BAD_CONTEXT, "eglCreateEGLImageKHR: for "
 352                 "EGL_NATIVE_BUFFER_ANDROID, the context must be "
 353                 "EGL_NO_CONTEXT");
 354       return NULL;
 355    }
 356
 357    if (!buf || buf->common.magic != ANDROID_NATIVE_BUFFER_MAGIC ||
 358        buf->common.version != sizeof(*buf)) {
 359       _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
 360       return NULL;
 361    }
 362
 363    name = get_native_buffer_name(buf);
 364    if (!name) {
 365       _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
 366       return NULL;
 367    }
 368
 369    /* see the table in droid_add_configs_for_visuals */
 370    switch (buf->format) {
 371    case HAL_PIXEL_FORMAT_BGRA_8888:
 372       format = __DRI_IMAGE_FORMAT_ARGB8888;
 373       break;
 374    case HAL_PIXEL_FORMAT_RGB_565:
 375       format = __DRI_IMAGE_FORMAT_RGB565;
 376       break;
 377    case HAL_PIXEL_FORMAT_RGBA_8888:
 378       format = __DRI_IMAGE_FORMAT_ABGR8888;
 379       break;
 380    case HAL_PIXEL_FORMAT_RGBX_8888:
 381       format = __DRI_IMAGE_FORMAT_XBGR8888;
 382       break;
 383    case HAL_PIXEL_FORMAT_RGB_888:
 384    case HAL_PIXEL_FORMAT_RGBA_5551:
 385    case HAL_PIXEL_FORMAT_RGBA_4444:
 386       /* unsupported */
 387    default:
 388       _eglLog(_EGL_WARNING, "unsupported native buffer format 0x%x", buf->format);
 389       return NULL;
 390       break;
 391    }
 392
 393    dri2_img = calloc(1, sizeof(*dri2_img));
 394    if (!dri2_img) {
 395       _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm");
 396       return NULL;
 397    }
 398
 399    if (!_eglInitImage(&dri2_img->base, disp)) {
 400       free(dri2_img);
 401       return NULL;
 402    }
 403
 404    dri2_img->dri_image =
 405       dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
 406                                            buf->width,
 407                                            buf->height,
 408                                            format,
 409                                            name,
 410                                            buf->stride,
 411                                            dri2_img);
 412    if (!dri2_img->dri_image) {
 413       free(dri2_img);
 414       _eglError(EGL_BAD_ALLOC, "droid_create_image_mesa_drm");
 415       return NULL;
 416    }
 417
 418    return &dri2_img->base;
 419 }
 420
 421 static _EGLImage *
 422 droid_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
 423                        _EGLContext *ctx, EGLenum target,
 424                        EGLClientBuffer buffer, const EGLint *attr_list)
 425 {
 426    switch (target) {
 427    case EGL_NATIVE_BUFFER_ANDROID:
 428       return dri2_create_image_android_native_buffer(disp, ctx,
 429             (struct ANativeWindowBuffer *) buffer);
 430    default:
 431       return dri2_create_image_khr(drv, disp, ctx, target, buffer, attr_list);
 432    }
 433 }
 434
 435 static void
 436 droid_init_driver_functions(_EGLDriver *drv)
 437 {
 438    drv->API.CreateWindowSurface = droid_create_window_surface;
 439    drv->API.CreatePixmapSurface = droid_create_pixmap_surface;
 440    drv->API.CreatePbufferSurface = droid_create_pbuffer_surface;
 441    drv->API.DestroySurface = droid_destroy_surface;
 442    drv->API.SwapBuffers = droid_swap_buffers;
 443
 444    drv->API.CreateImageKHR = droid_create_image_khr;
 445 }
 446
 447 static void
 448 droid_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
 449 {
 450 }
 451
 452 static int
 453 droid_get_buffers_parse_attachments(struct dri2_egl_surface *dri2_surf,
 454                                     unsigned int *attachments, int count)
 455 {
 456    int num_buffers = 0, i;
 457
 458    /* fill dri2_surf->buffers */
 459    for (i = 0; i < count * 2; i += 2) {
 460       __DRIbuffer *buf, *local;
 461
 462       assert(num_buffers < ARRAY_SIZE(dri2_surf->buffers));
 463       buf = &dri2_surf->buffers[num_buffers];
 464
 465       switch (attachments[i]) {
 466       case __DRI_BUFFER_BACK_LEFT:
 467          if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
 468             buf->attachment = attachments[i];
 469             buf->name = get_native_buffer_name(dri2_surf->buffer);
 470             buf->cpp = get_format_bpp(dri2_surf->buffer->format);
 471             buf->pitch = dri2_surf->buffer->stride * buf->cpp;
 472             buf->flags = 0;
 473
 474             if (buf->name)
 475                num_buffers++;
 476
 477             break;
 478          }
 479          /* fall through for pbuffers */
 480       case __DRI_BUFFER_DEPTH:
 481       case __DRI_BUFFER_STENCIL:
 482       case __DRI_BUFFER_ACCUM:
 483       case __DRI_BUFFER_DEPTH_STENCIL:
 484       case __DRI_BUFFER_HIZ:
 485          local = droid_alloc_local_buffer(dri2_surf,
 486                attachments[i], attachments[i + 1]);
 487
 488          if (local) {
 489             *buf = *local;
 490             num_buffers++;
 491          }
 492          break;
 493       case __DRI_BUFFER_FRONT_LEFT:
 494       case __DRI_BUFFER_FRONT_RIGHT:
 495       case __DRI_BUFFER_FAKE_FRONT_LEFT:
 496       case __DRI_BUFFER_FAKE_FRONT_RIGHT:
 497       case __DRI_BUFFER_BACK_RIGHT:
 498       default:
 499          /* no front or right buffers */
 500          break;
 501       }
 502    }
 503
 504    return num_buffers;
 505 }
 506
 507 static __DRIbuffer *
 508 droid_get_buffers_with_format(__DRIdrawable * driDrawable,
 509                              int *width, int *height,
 510                              unsigned int *attachments, int count,
 511                              int *out_count, void *loaderPrivate)
 512 {
 513    struct dri2_egl_surface *dri2_surf = loaderPrivate;
 514    struct dri2_egl_display *dri2_dpy =
 515       dri2_egl_display(dri2_surf->base.Resource.Display);
 516    int i;
 517
 518    if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
 519       /* try to dequeue the next back buffer */
 520       if (!dri2_surf->buffer && !droid_window_dequeue_buffer(dri2_surf))
 521          return NULL;
 522
 523       /* free outdated buffers and update the surface size */
 524       if (dri2_surf->base.Width != dri2_surf->buffer->width ||
 525           dri2_surf->base.Height != dri2_surf->buffer->height) {
 526          droid_free_local_buffers(dri2_surf);
 527          dri2_surf->base.Width = dri2_surf->buffer->width;
 528          dri2_surf->base.Height = dri2_surf->buffer->height;
 529       }
 530    }
 531
 532    dri2_surf->buffer_count =
 533       droid_get_buffers_parse_attachments(dri2_surf, attachments, count);
 534
 535    if (width)
 536       *width = dri2_surf->base.Width;
 537    if (height)
 538       *height = dri2_surf->base.Height;
 539
 540    *out_count = dri2_surf->buffer_count;;
 541
 542    return dri2_surf->buffers;
 543 }
 544
 545 static EGLBoolean
 546 droid_add_configs_for_visuals(_EGLDriver *drv, _EGLDisplay *dpy)
 547 {
 548    struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy);
 549    const struct {
 550       int format;
 551       int size;
 552       unsigned int rgba_masks[4];
 553    } visuals[] = {
 554       { HAL_PIXEL_FORMAT_RGBA_8888, 32, { 0xff, 0xff00, 0xff0000, 0xff000000 } },
 555       { HAL_PIXEL_FORMAT_RGBX_8888, 32, { 0xff, 0xff00, 0xff0000, 0x0 } },
 556       { HAL_PIXEL_FORMAT_RGB_888,   24, { 0xff, 0xff00, 0xff0000, 0x0 } },
 557       { HAL_PIXEL_FORMAT_RGB_565,   16, { 0xf800, 0x7e0, 0x1f, 0x0 } },
 558       { HAL_PIXEL_FORMAT_BGRA_8888, 32, { 0xff0000, 0xff00, 0xff, 0xff000000 } },
 559       { 0, 0, { 0, 0, 0, 0 } }
 560    };
 561    int count, i, j;
 562
 563    count = 0;
 564    for (i = 0; visuals[i].format; i++) {
 565       int format_count = 0;
 566
 567       for (j = 0; dri2_dpy->driver_configs[j]; j++) {
 568          const EGLint surface_type = EGL_WINDOW_BIT | EGL_PBUFFER_BIT;
 569          struct dri2_egl_config *dri2_conf;
 570          unsigned int double_buffered = 0;
 571
 572          dri2_dpy->core->getConfigAttrib(dri2_dpy->driver_configs[j],
 573             __DRI_ATTRIB_DOUBLE_BUFFER, &double_buffered);
 574
 575          /* support only double buffered configs */
 576          if (!double_buffered)
 577             continue;
 578
 579          dri2_conf = dri2_add_config(dpy, dri2_dpy->driver_configs[j],
 580                count + 1, visuals[i].size, surface_type, NULL,
 581                visuals[i].rgba_masks);
 582          if (dri2_conf) {
 583             dri2_conf->base.NativeVisualID = visuals[i].format;
 584             dri2_conf->base.NativeVisualType = visuals[i].format;
 585             count++;
 586             format_count++;
 587          }
 588       }
 589
 590       if (!format_count) {
 591          _eglLog(_EGL_DEBUG, "No DRI config supports native format 0x%x",
 592                visuals[i].format);
 593       }
 594    }
 595
 596    /* post-process configs */
 597    for (i = 0; i < dpy->Configs->Size; i++) {
 598       struct dri2_egl_config *dri2_conf = dri2_egl_config(dpy->Configs->Elements[i]);
 599
 600       /* there is no front buffer so no OpenGL */
 601       dri2_conf->base.RenderableType &= ~EGL_OPENGL_BIT;
 602       dri2_conf->base.Conformant &= ~EGL_OPENGL_BIT;
 603    }
 604
 605    return (count != 0);
 606 }
 607
 608 static EGLBoolean
 609 droid_get_pci_id(int fd, int *vendor_id, int *chip_id)
 610 {
 611    drmVersionPtr version;
 612
 613    *chip_id = -1;
 614
 615    version = drmGetVersion(fd);
 616    if (!version) {
 617       _eglLog(_EGL_WARNING, "invalid drm fd");
 618       return EGL_FALSE;
 619    }
 620    if (!version->name) {
 621       _eglLog(_EGL_WARNING, "unable to determine the driver name");
 622       drmFreeVersion(version);
 623       return EGL_FALSE;
 624    }
 625
 626    if (strcmp(version->name, "i915") == 0) {
 627       struct drm_i915_getparam gp;
 628       int ret;
 629
 630       *vendor_id = 0x8086;
 631
 632       memset(&gp, 0, sizeof(gp));
 633       gp.param = I915_PARAM_CHIPSET_ID;
 634       gp.value = chip_id;
 635       ret = drmCommandWriteRead(fd, DRM_I915_GETPARAM, &gp, sizeof(gp));
 636       if (ret) {
 637          _eglLog(_EGL_WARNING, "failed to get param for i915");
 638          *chip_id = -1;
 639       }
 640    }
 641    else if (strcmp(version->name, "radeon") == 0) {
 642       struct drm_radeon_info info;
 643       int ret;
 644
 645       *vendor_id = 0x1002;
 646
 647       memset(&info, 0, sizeof(info));
 648       info.request = RADEON_INFO_DEVICE_ID;
 649       info.value = (unsigned long) chip_id;
 650       ret = drmCommandWriteRead(fd, DRM_RADEON_INFO, &info, sizeof(info));
 651       if (ret) {
 652          _eglLog(_EGL_WARNING, "failed to get info for radeon");
 653          *chip_id = -1;
 654       }
 655    }
 656    else if (strcmp(version->name, "nouveau") == 0) {
 657       *vendor_id = 0x10de;
 658       /* not used */
 659       *chip_id = 0;
 660    }
 661    else if (strcmp(version->name, "vmwgfx") == 0) {
 662       *vendor_id = 0x15ad;
 663       /* assume SVGA II */
 664       *chip_id = 0x0405;
 665    }
 666
 667    drmFreeVersion(version);
 668
 669    return (*chip_id >= 0);
 670 }
 671
 672 #define DRIVER_MAP_DRI2_ONLY
 673 #include "pci_ids/pci_id_driver_map.h"
 674 static const char *
 675 droid_get_driver_name(int fd)
 676 {
 677    int vendor_id = -1, chip_id = -1;
 678    int idx, i;
 679    char *name;
 680
 681    if (!droid_get_pci_id(fd, &vendor_id, &chip_id))
 682       return NULL;
 683
 684    for (idx = 0; driver_map[idx].driver; idx++) {
 685       if (vendor_id != driver_map[idx].vendor_id)
 686          continue;
 687
 688       if (driver_map[idx].num_chips_ids == -1)
 689          break;
 690
 691       for (i = 0; i < driver_map[idx].num_chips_ids; i++) {
 692          if (driver_map[idx].chip_ids[i] == chip_id)
 693             break;
 694       }
 695       if (i < driver_map[idx].num_chips_ids)
 696               break;
 697    }
 698
 699    _eglLog(_EGL_INFO, "pci id for fd %d: %04x:%04x, driver %s",
 700          fd, vendor_id, chip_id, driver_map[idx].driver);
 701
 702    return driver_map[idx].driver;
 703 }
 704
 705 static int
 706 droid_open_device(void)
 707 {
 708    const hw_module_t *mod;
 709    int fd = -1, err;
 710
 711    err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &mod);
 712    if (!err) {
 713       const gralloc_module_t *gr = (gralloc_module_t *) mod;
 714
 715       err = -EINVAL;
 716       if (gr->perform)
 717          err = gr->perform(gr, GRALLOC_MODULE_PERFORM_GET_DRM_FD, &fd);
 718    }
 719    if (err || fd < 0) {
 720       _eglLog(_EGL_WARNING, "fail to get drm fd");
 721       fd = -1;
 722    }
 723
 724    return (fd >= 0) ? dup(fd) : -1;
 725 }
 726
 727 /* support versions < JellyBean */
 728 #ifndef ALOGW
 729 #define ALOGW LOGW
 730 #endif
 731 #ifndef ALOGD
 732 #define ALOGD LOGD
 733 #endif
 734 #ifndef ALOGI
 735 #define ALOGI LOGI
 736 #endif
 737
 738 static void
 739 droid_log(EGLint level, const char *msg)
 740 {
 741    switch (level) {
 742    case _EGL_DEBUG:
 743       ALOGD("%s", msg);
 744       break;
 745    case _EGL_INFO:
 746       ALOGI("%s", msg);
 747       break;
 748    case _EGL_WARNING:
 749       ALOGW("%s", msg);
 750       break;
 751    case _EGL_FATAL:
 752       LOG_FATAL("%s", msg);
 753       break;
 754    default:
 755       break;
 756    }
 757 }
 758
 759 EGLBoolean
 760 dri2_initialize_android(_EGLDriver *drv, _EGLDisplay *dpy)
 761 {
 762    struct dri2_egl_display *dri2_dpy;
 763    const char *err;
 764
 765    _eglSetLogProc(droid_log);
 766
 767    dri2_dpy = calloc(1, sizeof(*dri2_dpy));
 768    if (!dri2_dpy)
 769       return _eglError(EGL_BAD_ALLOC, "eglInitialize");
 770
 771    dpy->DriverData = (void *) dri2_dpy;
 772
 773    dri2_dpy->fd = droid_open_device();
 774    if (dri2_dpy->fd < 0) {
 775       err = "DRI2: failed to open device";
 776       goto cleanup_display;
 777    }
 778
 779    dri2_dpy->driver_name = (char *) droid_get_driver_name(dri2_dpy->fd);
 780    if (dri2_dpy->driver_name == NULL) {
 781       err = "DRI2: failed to get driver name";
 782       goto cleanup_device;
 783    }
 784
 785    if (!dri2_load_driver(dpy)) {
 786       err = "DRI2: failed to load driver";
 787       goto cleanup_device;
 788    }
 789
 790    dri2_dpy->dri2_loader_extension.base.name = __DRI_DRI2_LOADER;
 791    dri2_dpy->dri2_loader_extension.base.version = 3;
 792    dri2_dpy->dri2_loader_extension.getBuffers = NULL;
 793    dri2_dpy->dri2_loader_extension.flushFrontBuffer = droid_flush_front_buffer;
 794    dri2_dpy->dri2_loader_extension.getBuffersWithFormat =
 795       droid_get_buffers_with_format;
 796
 797    dri2_dpy->extensions[0] = &dri2_dpy->dri2_loader_extension.base;
 798    dri2_dpy->extensions[1] = &image_lookup_extension.base;
 799    dri2_dpy->extensions[2] = &use_invalidate.base;
 800    dri2_dpy->extensions[3] = NULL;
 801
 802    if (!dri2_create_screen(dpy)) {
 803       err = "DRI2: failed to create screen";
 804       goto cleanup_driver;
 805    }
 806
 807    if (!droid_add_configs_for_visuals(drv, dpy)) {
 808       err = "DRI2: failed to add configs";
 809       goto cleanup_screen;
 810    }
 811
 812    dpy->Extensions.ANDROID_image_native_buffer = EGL_TRUE;
 813    dpy->Extensions.KHR_image_base = EGL_TRUE;
 814
 815    /* we're supporting EGL 1.4 */
 816    dpy->VersionMajor = 1;
 817    dpy->VersionMinor = 4;
 818
 819    droid_init_driver_functions(drv);
 820
 821    return EGL_TRUE;
 822
 823 cleanup_screen:
 824    dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
 825 cleanup_driver:
 826    dlclose(dri2_dpy->driver);
 827 cleanup_device:
 828    close(dri2_dpy->fd);
 829 cleanup_display:
 830    free(dri2_dpy);
 831
 832    return _eglError(EGL_NOT_INITIALIZED, err);
 833 }