src/egl/drivers/android/droid_intel.c

   1 /*
   2  * Copyright (C) 2009 Chia-I Wu <olvaffe@gmail.com>
   3  *
   4  * This is based on the work of eagle, by
   5  * Copyright © 2008, 2009 Kristian Høgsberg
   6  *
   7  * Permission to use, copy, modify, distribute, and sell this software and its
   8  * documentation for any purpose is hereby granted without fee, provided that
   9  * the above copyright notice appear in all copies and that both that copyright
  10  * notice and this permission notice appear in supporting documentation, and
  11  * that the name of the copyright holders not be used in advertising or
  12  * publicity pertaining to distribution of the software without specific,
  13  * written prior permission.  The copyright holders make no representations
  14  * about the suitability of this software for any purpose.  It is provided "as
  15  * is" without express or implied warranty.
  16  *
  17  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  18  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  19  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  20  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  22  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  23  * OF THIS SOFTWARE.
  24  */
  25
  26 #define LOG_TAG "DROID-INTEL"
  27 #include <utils/Log.h>
  28
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <stdint.h>
  33 #include <sys/ioctl.h>
  34 #include <sys/mman.h>
  35 #include <fcntl.h>
  36 #include <unistd.h>
  37 #include <i915_drm.h>
  38 #include <GL/gl.h> /* dri_interface.h uses some GL integer types... */
  39 #include <GL/internal/dri_interface.h>
  40 #include <EGL/egl.h>
  41
  42 #include "droid.h"
  43 #include "droid_ui.h"
  44
  45 #define INTEL_IS_I965(x) ((x) & INTEL_GEN_4)
  46 #define INTEL_IS_I915(x) ((x) & INTEL_GEN_3)
  47 #define INTEL_IS_I9xx(x) ((x) & (INTEL_GEN_3 | INTEL_GEN_4))
  48 #define INTEL_IS_I8xx(x) ((x) & (INTEL_GEN_1 | INTEL_GEN_2))
  49
  50 #define INTEL_HAS_128_BYTE_Y_TILING(x) \
  51    (((x) & (INTEL_GEN_3 | INTEL_GEN_4 | INTEL_GEN_MINOR_MASK)) > INTEL_GEN_3)
  52
  53 enum {
  54    INTEL_SURFACE_TYPE_WINDOW,
  55    INTEL_SURFACE_TYPE_IMAGE,
  56 };
  57
  58 /* Look at xf86-video-intel/src/common.h for the full horror of device
  59  * identification.
  60  */
  61 enum {
  62         INTEL_GEN_1  = 0x10,
  63         INTEL_GEN_2  = 0x20,
  64         INTEL_GEN_3  = 0x40,
  65         INTEL_GEN_31 = 0x41,
  66         INTEL_GEN_4  = 0x80,
  67
  68         INTEL_GEN_MAJOR_MASK = 0xf0,
  69         INTEL_GEN_MINOR_MASK = 0x0f,
  70 };
  71
  72 struct droid_backend_intel {
  73    struct droid_backend base;
  74    int fd;
  75    int screen_number;
  76
  77    uint32_t generation;
  78    int pitch_align;
  79    int enable_tiling;
  80 };
  81
  82 struct droid_surface_intel {
  83    int type;
  84    union {
  85       NativeWindowType win;
  86       NativePixmapType pix;
  87    } native;
  88    __DRIbuffer native_buffer;
  89    unsigned int native_width, native_height;
  90    int native_changed;
  91
  92    unsigned int attachments[20];
  93    __DRIbuffer buffers[10];
  94    uint32_t handles[10];
  95    int num_buffers;
  96    int depth_idx;
  97
  98    _EGLSurface *surf;
  99 };
 100
 101 static INLINE struct droid_backend_intel *
 102 lookup_backend(struct droid_backend *backend)
 103 {
 104    return (struct droid_backend_intel *) backend;
 105 }
 106
 107 static INLINE struct droid_surface_intel *
 108 lookup_surface(struct droid_surface *surface)
 109 {
 110    return (struct droid_surface_intel *) surface;
 111 }
 112
 113 static __DRIbuffer *
 114 intel_get_native_buffer(struct droid_backend *backend,
 115                         struct droid_surface *surf,
 116                         int *width, int *height)
 117 {
 118    struct droid_surface_intel *isurf = lookup_surface(surf);
 119
 120    /* non-window surface is single-buffered */
 121    if (isurf->type != INTEL_SURFACE_TYPE_WINDOW)
 122       return NULL;
 123
 124    if (!isurf->native_buffer.name)
 125       return NULL;
 126
 127    if (width)
 128       *width = isurf->native_width;
 129    if (height)
 130       *height = isurf->native_height;
 131
 132    return &isurf->native_buffer;
 133 }
 134
 135 static INLINE uint32_t
 136 align_to(uint32_t value, uint32_t align)
 137 {
 138    return (value + align - 1) & ~(align - 1);
 139 }
 140
 141 static INLINE int
 142 fence_pitch(struct droid_backend *backend, int pitch, int tiling)
 143 {
 144    struct droid_backend_intel *intel = lookup_backend(backend);
 145    int pitch_align, tile_width;
 146
 147    switch (tiling) {
 148    case I915_TILING_NONE:
 149    default:
 150       pitch_align = intel->pitch_align;
 151       tile_width = 1; /* not used */
 152       break;
 153    case I915_TILING_X:
 154       pitch_align = 512;
 155       tile_width = 512;
 156       break;
 157    case I915_TILING_Y:
 158       pitch_align = 512;
 159       tile_width =
 160          (INTEL_HAS_128_BYTE_Y_TILING(intel->generation)) ? 128 : 512;
 161       break;
 162    }
 163
 164    pitch = align_to(pitch, pitch_align);
 165    if (tiling == I915_TILING_NONE)
 166       return pitch;
 167
 168    /* 965+ just needs multiples of tile width */
 169    if (INTEL_IS_I965(intel->generation)) {
 170       pitch = align_to(pitch,  tile_width);
 171    }
 172    else {
 173       /* Pre-965 needs power of two tile widths */
 174       while (tile_width < pitch)
 175          tile_width <<= 1;
 176       pitch = tile_width;
 177    }
 178
 179    return pitch;
 180 }
 181
 182 static INLINE uint32_t
 183 fence_size(struct droid_backend *backend, int height, int pitch, int tiling)
 184 {
 185    struct droid_backend_intel *intel = lookup_backend(backend);
 186    int height_align;
 187    uint32_t size;
 188
 189    switch (tiling) {
 190    case I915_TILING_NONE:
 191    default:
 192       /* Round the height up so that the GPU's access to a 2x2 aligned
 193        * subspan doesn't address an invalid page offset beyond the
 194        * end of the GTT.
 195        */
 196       height_align = 2;
 197       break;
 198    case I915_TILING_X:
 199       height_align = 8;
 200       break;
 201    case I915_TILING_Y:
 202       height_align = 32;
 203       break;
 204    }
 205
 206    height = align_to(height, height_align);
 207    size = pitch * height;
 208    if (tiling == I915_TILING_NONE)
 209       return size;
 210
 211    /* The 965 can have fences at any page boundary. */
 212    if (INTEL_IS_I965(intel->generation)) {
 213       size = align_to(size, 4096);
 214    }
 215    else {
 216       uint32_t fence;
 217
 218       /* Align the size to a power of two greater than the smallest fence. */
 219       if (INTEL_IS_I9xx(intel->generation))
 220          fence = 1 << 20; /* 1 MiB */
 221       else
 222          fence = 1 << 19; /* 512 KiB */
 223
 224       while (fence < size)
 225          fence <<= 1;
 226
 227       size = fence;
 228    }
 229
 230    return size;
 231 }
 232
 233 static int
 234 create_buffer(struct droid_backend *backend, __DRIbuffer *buffer,
 235               int width, int height, int cpp, int tiling)
 236 {
 237    struct droid_backend_intel *intel = lookup_backend(backend);
 238    struct drm_i915_gem_create create;
 239    struct drm_gem_flink flink;
 240
 241    buffer->pitch = fence_pitch(backend, width * cpp, tiling);
 242    create.size = fence_size(backend, height, buffer->pitch, tiling);
 243    if (ioctl(intel->fd, DRM_IOCTL_I915_GEM_CREATE, &create)) {
 244       LOGE("failed to create buffer");
 245       return 0;
 246    }
 247
 248    if (tiling != I915_TILING_NONE) {
 249       struct drm_i915_gem_set_tiling set_tiling;
 250
 251       memset(&set_tiling, 0, sizeof(set_tiling));
 252       set_tiling.handle = create.handle;
 253       set_tiling.tiling_mode = tiling;
 254       set_tiling.stride = buffer->pitch;
 255
 256       if (ioctl(intel->fd, DRM_IOCTL_I915_GEM_SET_TILING, &set_tiling))
 257          LOGW("failed to enable tiling");
 258    }
 259
 260    flink.handle = create.handle;
 261    if (ioctl(intel->fd, DRM_IOCTL_GEM_FLINK, &flink) < 0) {
 262       LOGE("failed to flink buffer");
 263       return 0;
 264    }
 265
 266    buffer->name = flink.name;
 267    buffer->cpp = cpp;
 268    buffer->flags = 0;
 269
 270    return create.handle;
 271 }
 272
 273 static void
 274 delete_buffers(struct droid_backend *backend, struct droid_surface *surf)
 275 {
 276    struct droid_backend_intel *intel = lookup_backend(backend);
 277    struct droid_surface_intel *isurf = lookup_surface(surf);
 278    int i;
 279
 280    for (i = 0; i < isurf->num_buffers; i++) {
 281       if (isurf->handles[i]) {
 282          struct drm_gem_close close;
 283
 284          close.handle = isurf->handles[i];
 285          if (ioctl(intel->fd, DRM_IOCTL_GEM_CLOSE, &close) < 0)
 286             LOGE("failed to close bo %d", close.handle);
 287          isurf->handles[i] = 0;
 288       }
 289    }
 290
 291    isurf->num_buffers = 0;
 292 }
 293
 294 static __DRIbuffer *
 295 intel_get_surface_buffers(struct droid_backend *backend,
 296                           struct droid_surface *surf,
 297                           int *width, int *height,
 298                           unsigned int *attachments, int count,
 299                           int *out_count, int has_format)
 300 {
 301    struct droid_backend_intel *intel = lookup_backend(backend);
 302    struct droid_surface_intel *isurf = lookup_surface(surf);
 303    unsigned int att_size;
 304    __DRIbuffer buffers[10];
 305    uint32_t handles[10];
 306    int num = 0;
 307
 308    if (count > 10) {
 309       LOGW("too many buffers requested");
 310       count = 10;
 311    }
 312
 313    att_size = sizeof(attachments[0]) * count * ((has_format) ? 2 : 1);
 314
 315    if (isurf->native_changed) {
 316       delete_buffers(backend, surf);
 317       isurf->native_changed = 0;
 318    }
 319
 320    /* same buffers requested */
 321    if (isurf->num_buffers == count &&
 322        memcmp(isurf->attachments, attachments, att_size) == 0) {
 323       num = isurf->num_buffers;
 324       goto end;
 325    }
 326    memcpy(isurf->attachments, attachments, att_size);
 327
 328    while (count-- > 0) {
 329       unsigned int att = *attachments++;
 330       unsigned int format = (has_format) ? *attachments++ : 0;
 331       unsigned int cpp = (format) ? format / 8 : isurf->native_buffer.cpp;
 332       __DRIbuffer *buf = NULL;
 333       int reuse;
 334
 335       /* re-use buffer */
 336       for (reuse = 0; reuse < isurf->num_buffers; reuse++) {
 337          if (isurf->buffers[reuse].attachment == att) {
 338             if (isurf->buffers[reuse].cpp == cpp &&
 339                 isurf->handles[reuse])
 340                buf = &isurf->buffers[reuse];
 341             break;
 342          }
 343       }
 344
 345       if (0)
 346          LOGD("%s buffer %d: att %d cpp %d",
 347                (buf) ? "reuse" : "create", num, att, cpp);
 348
 349       if (buf) {
 350          buffers[num] = isurf->buffers[reuse];
 351          handles[num] = isurf->handles[reuse];
 352          isurf->handles[reuse] = 0;
 353       }
 354       else {
 355          int tiling =
 356             (intel->enable_tiling) ? I915_TILING_X : I915_TILING_NONE;
 357
 358          buffers[num].attachment = att;
 359
 360          if (isurf->type == INTEL_SURFACE_TYPE_IMAGE &&
 361              att == __DRI_BUFFER_FRONT_LEFT) {
 362             /* return native buffer */
 363             buffers[num] = isurf->native_buffer;
 364             buffers[num].attachment = att;
 365             handles[num] = 0;
 366          } else {
 367             buffers[num].attachment = att;
 368             handles[num] = create_buffer(backend, &buffers[num],
 369                                          isurf->native_width,
 370                                          isurf->native_height,
 371                                          cpp,
 372                                          tiling);
 373          }
 374       }
 375       num++;
 376    }
 377
 378    /* delete old buffers that are not re-used */
 379    delete_buffers(backend, surf);
 380
 381    memcpy(isurf->buffers, buffers, sizeof(buffers[0]) * num);
 382    memcpy(isurf->handles, handles, sizeof(handles[0]) * num);
 383    isurf->num_buffers = num;
 384
 385 end:
 386    *out_count = num;
 387    *width = isurf->native_width;
 388    *height = isurf->native_height;
 389
 390    return isurf->buffers;
 391 }
 392
 393 static void
 394 update_native_buffer(struct droid_surface *surf)
 395 {
 396    struct droid_surface_intel *isurf = lookup_surface(surf);
 397    unsigned int name, cpp, pitch, width, height;
 398
 399    switch (isurf->type) {
 400    case INTEL_SURFACE_TYPE_WINDOW:
 401       /* oem[0] always point to the buffer that a client is drawing to */
 402       name = isurf->native.win->oem[0];
 403       cpp = ui_bytes_per_pixel(isurf->native.win->format);
 404       pitch = isurf->native.win->stride * cpp;
 405       width = isurf->native.win->width;
 406       height = isurf->native.win->height;
 407       break;
 408    case INTEL_SURFACE_TYPE_IMAGE:
 409       name = isurf->native.pix->reserved;
 410       cpp = ui_bytes_per_pixel(isurf->native.pix->format);
 411       pitch = isurf->native.pix->stride * cpp;
 412       width = isurf->native.pix->width;
 413       height = isurf->native.pix->height;
 414       break;
 415    default:
 416       name = cpp = pitch = width = height = 0;
 417       break;
 418    }
 419
 420    isurf->native_buffer.attachment = __DRI_BUFFER_FRONT_LEFT;
 421    isurf->native_buffer.name = name;
 422    isurf->native_buffer.cpp = cpp;
 423    isurf->native_buffer.pitch = pitch;
 424    isurf->native_buffer.flags = 0;
 425
 426    isurf->native_width = width;
 427    isurf->native_height = height;
 428
 429    isurf->native_changed = 1;
 430 }
 431
 432 static struct droid_surface *
 433 intel_create_window_surface(struct droid_backend *backend,
 434                             _EGLSurface *surf,
 435                             NativeWindowType win)
 436 {
 437    struct droid_surface_intel *isurf;
 438
 439    if (!win) {
 440       LOGE("invalid native window");
 441       _eglError(EGL_BAD_NATIVE_WINDOW, "eglCreateWindowSurface");
 442       return NULL;
 443    }
 444
 445    /* TODO lift this limitation */
 446    if (!win->oem[0]) {
 447       LOGE("TODO support for non-gem based window");
 448       _eglError(EGL_BAD_NATIVE_WINDOW, "eglCreateWindowSurface");
 449       return NULL;
 450    }
 451
 452    isurf = calloc(1, sizeof(*isurf));
 453    if (!isurf) {
 454       _eglError(EGL_BAD_ALLOC, "eglCreateWindowSurface");
 455       return NULL;
 456    }
 457
 458    isurf->type = INTEL_SURFACE_TYPE_WINDOW;
 459    isurf->native.win = win;
 460
 461    surf->Width = win->width;
 462    surf->Height = win->height;
 463    /* always back buffer */
 464    surf->RenderBuffer = EGL_BACK_BUFFER;
 465
 466    isurf->surf = surf;
 467
 468    update_native_buffer((struct droid_surface *) isurf);
 469
 470    return (struct droid_surface *) isurf;
 471 }
 472
 473 static struct droid_surface *
 474 intel_create_image_surface(struct droid_backend *backend,
 475                            NativePixmapType pix, int *depth)
 476 {
 477    struct droid_surface_intel *isurf;
 478    int cpp;
 479
 480    if (!pix) {
 481       LOGE("invalid native pixmap");
 482       _eglError(EGL_BAD_NATIVE_PIXMAP, "eglCreateImage");
 483       return NULL;
 484    }
 485
 486    /* TODO lift this limitation */
 487    if (!pix->reserved) {
 488       LOGE("TODO support for non-gem based pixmap");
 489       _eglError(EGL_BAD_NATIVE_PIXMAP, "eglCreateImage");
 490       return NULL;
 491    }
 492
 493    cpp = ui_bytes_per_pixel(pix->format);
 494    if (cpp * 8 > DROID_MAX_IMAGE_DEPTH) {
 495       LOGE("pixmap of depth %d is not supported", cpp * 8);
 496       _eglError(EGL_BAD_NATIVE_PIXMAP, "eglCreateImage");
 497       return NULL;
 498    }
 499
 500    isurf = calloc(1, sizeof(*isurf));
 501    if (!isurf) {
 502       _eglError(EGL_BAD_ALLOC, "eglCreateWindowSurface");
 503       return NULL;
 504    }
 505
 506    isurf->type = INTEL_SURFACE_TYPE_IMAGE;
 507    isurf->native.pix = pix;
 508
 509    update_native_buffer((struct droid_surface *) isurf);
 510
 511    if (depth)
 512       *depth = cpp * 8;
 513
 514    return (struct droid_surface *) isurf;
 515 }
 516
 517 static void
 518 intel_destroy_surface(struct droid_backend *backend, struct droid_surface *surf)
 519 {
 520    struct droid_surface_intel *isurf = lookup_surface(surf);
 521    delete_buffers(backend, surf);
 522    free(isurf);
 523 }
 524
 525 static void
 526 intel_swap_native_buffers(struct droid_backend *backend,
 527                           struct droid_surface *surf)
 528 {
 529    struct droid_surface_intel *isurf = lookup_surface(surf);
 530
 531    if (isurf->type == INTEL_SURFACE_TYPE_WINDOW) {
 532       uint32_t flags;
 533
 534       flags = isurf->native.win->swapBuffers(isurf->native.win);
 535       if (flags & EGL_NATIVES_FLAG_SIZE_CHANGED) {
 536          update_native_buffer(surf);
 537       } else {
 538          /* oem[0] is changed after buffer swap */
 539          isurf->native_buffer.name = isurf->native.win->oem[0];
 540       }
 541    }
 542 }
 543
 544 static int
 545 intel_initialize(struct droid_backend *backend, int *fd, int *screen_number)
 546 {
 547    struct droid_backend_intel *intel = lookup_backend(backend);
 548    drm_auth_t auth;
 549    int err;
 550
 551    err = ioctl(intel->fd, DRM_IOCTL_GET_MAGIC, &auth);
 552    if (!err)
 553       err = ui_auth_gpu(auth.magic);
 554
 555    if (err) {
 556       LOGE("failed to authenticate");
 557       return 0;
 558    }
 559
 560    if (fd)
 561       *fd = intel->fd;
 562    if (screen_number)
 563       *screen_number = intel->screen_number;
 564
 565    return 1;
 566 }
 567
 568 static void
 569 intel_destroy(struct droid_backend *backend)
 570 {
 571    struct droid_backend_intel *intel = lookup_backend(backend);
 572    close(intel->fd);
 573    free(intel);
 574 }
 575
 576 struct droid_backend *
 577 droid_backend_create_intel(const char *dev)
 578 {
 579    struct droid_backend_intel *intel;
 580
 581    intel = calloc(1, sizeof(*intel));
 582    if (!intel)
 583       return NULL;
 584
 585    intel->fd = open(dev, O_RDWR);
 586    if (intel->fd < 0) {
 587       LOGE("failed to open %s", dev);
 588       free(intel);
 589       return NULL;
 590    }
 591
 592    intel->screen_number = 0;
 593
 594    /* XXX query using I915_GETPARAM + PARAM_CHIPSET_ID */
 595    intel->generation = INTEL_GEN_3;
 596
 597    intel->pitch_align = 64;
 598    intel->enable_tiling = 1;
 599
 600    intel->base.driver_name = "i915";
 601    intel->base.initialize = intel_initialize;
 602    intel->base.destroy = intel_destroy;
 603
 604    intel->base.get_native_buffer = intel_get_native_buffer;
 605    intel->base.get_surface_buffers = intel_get_surface_buffers;
 606
 607    intel->base.create_window_surface = intel_create_window_surface;
 608    intel->base.create_image_surface = intel_create_image_surface;
 609    intel->base.destroy_surface = intel_destroy_surface;
 610    intel->base.swap_native_buffers = intel_swap_native_buffers;
 611
 612    return &intel->base;
 613 }