gralloc/gralloc.cpp

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <limits.h>
  18 #include <unistd.h>
  19 #include <fcntl.h>
  20 #include <errno.h>
  21 #include <pthread.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <sys/mman.h>
  26 #include <sys/stat.h>
  27 #include <sys/types.h>
  28 #include <sys/ioctl.h>
  29
  30 #include <ion/ion.h>
  31 #include <linux/ion.h>
  32 #include <cutils/log.h>
  33 #include <cutils/atomic.h>
  34
  35 #include <hardware/hardware.h>
  36 #include <hardware/gralloc.h>
  37
  38 #include "gralloc_priv.h"
  39 #include "exynos_format.h"
  40
  41 #define ION_HEAP_EXYNOS_CONTIG_MASK (1 << 4)
  42 #define ION_EXYNOS_FIMD_VIDEO_MASK  (1 << 28)
  43 #define ION_EXYNOS_MFC_OUTPUT_MASK  (1 << 26)
  44 #define ION_EXYNOS_MFC_INPUT_MASK   (1 << 25)
  45 #define ION_HEAP_SYSTEM_ID          0
  46 #define ION_HEAP_EXYNOS_CONTIG_ID   4
  47 #define ION_HEAP_CHUNK_ID           6
  48 #define MB_1 (1024*1024)
  49
  50
  51 /*****************************************************************************/
  52
  53 struct gralloc_context_t {
  54     alloc_device_t  device;
  55     /* our private data here */
  56 };
  57
  58 static int gralloc_alloc_buffer(alloc_device_t* dev,
  59                                 size_t size, int usage, buffer_handle_t* pHandle);
  60
  61 /*****************************************************************************/
  62
  63 int fb_device_open(const hw_module_t* module, const char* name,
  64                    hw_device_t** device);
  65
  66 static int gralloc_device_open(const hw_module_t* module, const char* name,
  67                                hw_device_t** device);
  68
  69 extern int gralloc_lock(gralloc_module_t const* module,
  70                         buffer_handle_t handle, int usage,
  71                         int l, int t, int w, int h,
  72                         void** vaddr);
  73
  74 extern int gralloc_unlock(gralloc_module_t const* module,
  75                           buffer_handle_t handle);
  76
  77 extern int gralloc_register_buffer(gralloc_module_t const* module,
  78                                    buffer_handle_t handle);
  79
  80 extern int gralloc_unregister_buffer(gralloc_module_t const* module,
  81                                      buffer_handle_t handle);
  82
  83 /*****************************************************************************/
  84
  85 static struct hw_module_methods_t gralloc_module_methods = {
  86 open: gralloc_device_open
  87 };
  88
  89 struct private_module_t HAL_MODULE_INFO_SYM = {
  90 base: {
  91     common: {
  92         tag: HARDWARE_MODULE_TAG,
  93         version_major: 1,
  94         version_minor: 0,
  95         id: GRALLOC_HARDWARE_MODULE_ID,
  96         name: "Graphics Memory Allocator Module",
  97         author: "The Android Open Source Project",
  98         methods: &gralloc_module_methods
  99     },
 100     registerBuffer: gralloc_register_buffer,
 101     unregisterBuffer: gralloc_unregister_buffer,
 102     lock: gralloc_lock,
 103     unlock: gralloc_unlock,
 104 },
 105 framebuffer: 0,
 106 flags: 0,
 107 numBuffers: 0,
 108 bufferMask: 0,
 109 lock: PTHREAD_MUTEX_INITIALIZER,
 110 refcount: 0,
 111 currentBuffer: 0,
 112 ionfd: -1,
 113 };
 114
 115 /*****************************************************************************/
 116
 117 static unsigned int _select_heap(int usage)
 118 {
 119     unsigned int heap_mask;
 120
 121     if (usage & GRALLOC_USAGE_PROTECTED)
 122         heap_mask = (1 << ION_HEAP_EXYNOS_CONTIG_ID);
 123     else
 124         heap_mask = (1 << ION_HEAP_SYSTEM_ID) | (1 << ION_HEAP_CHUNK_ID);
 125
 126     return heap_mask;
 127 }
 128
 129 static int gralloc_alloc_rgb(int ionfd, int w, int h, int format, int usage,
 130                              unsigned int ion_flags, private_handle_t **hnd, int *stride)
 131 {
 132     size_t size, bpr, alignment = 0;
 133     int bpp = 0, vstride, fd, err;
 134     unsigned int heap_mask = _select_heap(usage);
 135
 136     if (format == HAL_PIXEL_FORMAT_RGBA_8888) {
 137         bool sw_usage = !!(usage & (GRALLOC_USAGE_SW_READ_MASK |
 138                 GRALLOC_USAGE_SW_WRITE_MASK));
 139
 140         if (usage & GRALLOC_USAGE_HW_FB) {
 141             ALOGW_IF(sw_usage,
 142                     "framebuffer target should not have SW usage bits; ignoring");
 143             format = HAL_PIXEL_FORMAT_BGRA_8888;
 144         } else if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) {
 145             if (sw_usage)
 146                 return -EINVAL;
 147             format = HAL_PIXEL_FORMAT_BGRA_8888;
 148         }
 149     }
 150
 151     switch (format) {
 152         case HAL_PIXEL_FORMAT_RGBA_8888:
 153         case HAL_PIXEL_FORMAT_RGBX_8888:
 154         case HAL_PIXEL_FORMAT_BGRA_8888:
 155         case HAL_PIXEL_FORMAT_sRGB_A_8888:
 156         case HAL_PIXEL_FORMAT_sRGB_X_8888:
 157             bpp = 4;
 158             break;
 159         case HAL_PIXEL_FORMAT_RGB_888:
 160             bpp = 3;
 161             break;
 162         case HAL_PIXEL_FORMAT_RGB_565:
 163         case HAL_PIXEL_FORMAT_RAW_SENSOR:
 164             bpp = 2;
 165             break;
 166         case HAL_PIXEL_FORMAT_BLOB:
 167             *stride = w;
 168             vstride = h;
 169             size = w * h;
 170             break;
 171         default:
 172             return -EINVAL;
 173     }
 174
 175     if (format != HAL_PIXEL_FORMAT_BLOB) {
 176         bpr = ALIGN(w*bpp, 64);
 177         vstride = ALIGN(h, 16);
 178         if (vstride < h + 2)
 179             size = bpr * (h + 2);
 180         else
 181             size = bpr * vstride;
 182         *stride = bpr / bpp;
 183         size = ALIGN(size, PAGE_SIZE);
 184     }
 185
 186     if (usage & GRALLOC_USAGE_PROTECTED) {
 187         alignment = MB_1;
 188         ion_flags |= ION_EXYNOS_FIMD_VIDEO_MASK;
 189     }
 190
 191     err = ion_alloc_fd(ionfd, size, alignment, heap_mask, ion_flags,
 192                        &fd);
 193     *hnd = new private_handle_t(fd, size, usage, w, h, format, *stride,
 194                                 vstride);
 195
 196     return err;
 197 }
 198
 199 static int gralloc_alloc_framework_yuv(int ionfd, int w, int h, int format,
 200                                        int usage, unsigned int ion_flags,
 201                                        private_handle_t **hnd, int *stride)
 202 {
 203     size_t size;
 204     int err, fd;
 205     unsigned int heap_mask = _select_heap(usage);
 206
 207     switch (format) {
 208         case HAL_PIXEL_FORMAT_YV12:
 209             *stride = ALIGN(w, 16);
 210             size = (*stride * h) + (ALIGN(*stride / 2, 16) * h);
 211             break;
 212         case HAL_PIXEL_FORMAT_YCrCb_420_SP:
 213             *stride = w;
 214             size = *stride * h * 3 / 2;
 215             break;
 216         default:
 217             ALOGE("invalid yuv format %d\n", format);
 218             return -EINVAL;
 219     }
 220
 221     err = ion_alloc_fd(ionfd, size, 0, heap_mask, ion_flags, &fd);
 222     if (err)
 223         return err;
 224
 225     *hnd = new private_handle_t(fd, size, usage, w, h, format, *stride, h);
 226     return err;
 227 }
 228
 229 static int gralloc_alloc_yuv(int ionfd, int w, int h, int format,
 230                              int usage, unsigned int ion_flags,
 231                              private_handle_t **hnd, int *stride)
 232 {
 233     size_t luma_size, chroma_size;
 234     int err, planes, fd, fd1, fd2 = 0;
 235     size_t luma_vstride;
 236     unsigned int heap_mask = _select_heap(usage);
 237
 238     *stride = ALIGN(w, 16);
 239
 240     if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) {
 241         ALOGV("HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED : usage(%x), flags(%x)\n", usage, ion_flags);
 242         if ((usage & GRALLOC_USAGE_HW_CAMERA_ZSL) == GRALLOC_USAGE_HW_CAMERA_ZSL) {
 243             format = HAL_PIXEL_FORMAT_YCbCr_422_I; // YUYV
 244         } else if (usage & GRALLOC_USAGE_HW_TEXTURE) {
 245             format = HAL_PIXEL_FORMAT_EXYNOS_YV12;
 246         } else if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) {
 247             format = HAL_PIXEL_FORMAT_YCbCr_420_SP; // NV12M
 248         }
 249     }
 250     switch (format) {
 251         case HAL_PIXEL_FORMAT_EXYNOS_YV12:
 252             {
 253                 *stride = ALIGN(w, 32);
 254                 luma_vstride = ALIGN(h, 16);
 255                 luma_size = luma_vstride * *stride;
 256                 chroma_size = (luma_vstride / 2) * ALIGN(*stride / 2, 16);
 257                 planes = 3;
 258                 break;
 259             }
 260         case HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP:
 261         case HAL_PIXEL_FORMAT_YCbCr_420_SP:
 262         case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
 263             {
 264                 size_t chroma_vstride = ALIGN(h / 2, 32);
 265                 luma_vstride = ALIGN(h, 32);
 266                 luma_size = luma_vstride * *stride;
 267                 chroma_size = chroma_vstride * *stride;
 268                 planes = 2;
 269                 break;
 270             }
 271         case HAL_PIXEL_FORMAT_YV12:
 272         case HAL_PIXEL_FORMAT_YCrCb_420_SP:
 273             return gralloc_alloc_framework_yuv(ionfd, w, h, format, usage,
 274                                                ion_flags, hnd, stride);
 275         case HAL_PIXEL_FORMAT_YCbCr_422_I:
 276             {
 277                 luma_vstride = h;
 278                 luma_size = luma_vstride * *stride * 2;
 279                 chroma_size = 0;
 280                 planes = 1;
 281                 break;
 282             }
 283         default:
 284             ALOGE("invalid yuv format %d\n", format);
 285             return -EINVAL;
 286     }
 287
 288     if (usage & GRALLOC_USAGE_PROTECTED)
 289         ion_flags |= ION_EXYNOS_MFC_OUTPUT_MASK;
 290
 291     err = ion_alloc_fd(ionfd, luma_size, 0, heap_mask, ion_flags, &fd);
 292     if (err)
 293         return err;
 294     if (planes == 1) {
 295         *hnd = new private_handle_t(fd, luma_size, usage, w, h,
 296                                     format, *stride, luma_vstride);
 297     } else {
 298         err = ion_alloc_fd(ionfd, chroma_size, 0, heap_mask, ion_flags, &fd1);
 299         if (err)
 300             goto err1;
 301         if (planes == 3) {
 302             err = ion_alloc_fd(ionfd, chroma_size, 0, heap_mask, ion_flags, &fd2);
 303             if (err)
 304                 goto err2;
 305
 306             *hnd = new private_handle_t(fd, fd1, fd2, luma_size, usage, w, h,
 307                                         format, *stride, luma_vstride);
 308         } else {
 309             *hnd = new private_handle_t(fd, fd1, luma_size, usage, w, h, format,
 310                                         *stride, luma_vstride);
 311         }
 312     }
 313     // Set chroma & gamut fields
 314     if (!err && *hnd) {
 315         if (usage & GRALLOC_USAGE_PRIVATE_CHROMA) {
 316             (*hnd)->chroma = HAL_PIXEL_CHROMA_BT601_8;
 317             (*hnd)->gamut = HAL_PIXEL_GAMUT_NARROW_8;
 318         } else {
 319             (*hnd)->chroma = HAL_PIXEL_CHROMA_BT709_8;
 320             (*hnd)->gamut = HAL_PIXEL_GAMUT_WIDE_8;
 321         }
 322     }
 323     return err;
 324
 325 err2:
 326     close(fd1);
 327 err1:
 328     close(fd);
 329     return err;
 330 }
 331
 332 static int gralloc_alloc(alloc_device_t* dev,
 333                          int w, int h, int format, int usage,
 334                          buffer_handle_t* pHandle, int* pStride)
 335 {
 336     int stride;
 337     int err;
 338     unsigned int ion_flags = 0;
 339     private_handle_t *hnd = NULL;
 340
 341     if (!pHandle || !pStride)
 342         return -EINVAL;
 343
 344     if( (usage & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN )
 345         ion_flags = ION_FLAG_CACHED | ION_FLAG_CACHED_NEEDS_SYNC;
 346
 347     private_module_t* m = reinterpret_cast<private_module_t*>
 348         (dev->common.module);
 349     gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>
 350         (dev->common.module);
 351
 352     err = gralloc_alloc_rgb(m->ionfd, w, h, format, usage, ion_flags, &hnd,
 353                             &stride);
 354     if (err)
 355         err = gralloc_alloc_yuv(m->ionfd, w, h, format, usage, ion_flags,
 356                                 &hnd, &stride);
 357     if (err)
 358         goto err;
 359
 360     err = gralloc_register_buffer(module, hnd);
 361     if (err)
 362         goto err;
 363
 364     *pHandle = hnd;
 365     *pStride = stride;
 366     return 0;
 367 err:
 368     if (!hnd)
 369         return err;
 370     close(hnd->fd);
 371     if (hnd->fd1 >= 0)
 372         close(hnd->fd1);
 373     if (hnd->fd2 >= 0)
 374         close(hnd->fd2);
 375     return err;
 376 }
 377
 378 static int gralloc_free(alloc_device_t* dev,
 379                         buffer_handle_t handle)
 380 {
 381     if (private_handle_t::validate(handle) < 0)
 382         return -EINVAL;
 383
 384     private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle);
 385     gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>(
 386                                                                    dev->common.module);
 387
 388     gralloc_unregister_buffer(module, hnd);
 389
 390     close(hnd->fd);
 391     if (hnd->fd1 >= 0)
 392         close(hnd->fd1);
 393     if (hnd->fd2 >= 0)
 394         close(hnd->fd2);
 395
 396     delete hnd;
 397     return 0;
 398 }
 399
 400 /*****************************************************************************/
 401
 402 static int gralloc_close(struct hw_device_t *dev)
 403 {
 404     gralloc_context_t* ctx = reinterpret_cast<gralloc_context_t*>(dev);
 405     if (ctx) {
 406         private_module_t *p = reinterpret_cast<private_module_t*>(ctx->device.common.module);
 407         pthread_mutex_lock(&p->lock);
 408         LOG_ALWAYS_FATAL_IF(!p->refcount);
 409         p->refcount--;
 410         if (!p->refcount)
 411             close(p->ionfd);
 412         pthread_mutex_unlock(&p->lock);
 413
 414         /* TODO: keep a list of all buffer_handle_t created, and free them
 415          * all here.
 416          */
 417         free(ctx);
 418     }
 419     return 0;
 420 }
 421
 422 int gralloc_device_open(const hw_module_t* module, const char* name,
 423                         hw_device_t** device)
 424 {
 425     int status = -EINVAL;
 426     if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) {
 427         gralloc_context_t *dev;
 428         dev = (gralloc_context_t*)malloc(sizeof(*dev));
 429
 430         /* initialize our state here */
 431         memset(dev, 0, sizeof(*dev));
 432
 433         /* initialize the procs */
 434         dev->device.common.tag = HARDWARE_DEVICE_TAG;
 435         dev->device.common.version = 0;
 436         dev->device.common.module = const_cast<hw_module_t*>(module);
 437         dev->device.common.close = gralloc_close;
 438
 439         dev->device.alloc = gralloc_alloc;
 440         dev->device.free = gralloc_free;
 441
 442         private_module_t *p = reinterpret_cast<private_module_t*>(dev->device.common.module);
 443         pthread_mutex_lock(&p->lock);
 444         if (!p->refcount)
 445             p->ionfd = ion_open();
 446         p->refcount++;
 447         pthread_mutex_unlock(&p->lock);
 448
 449         *device = &dev->device.common;
 450         status = 0;
 451     } else {
 452         status = fb_device_open(module, name, device);
 453     }
 454     return status;
 455 }