| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <limits.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <errno.h> |
| #include <pthread.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include <sys/mman.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <sys/ioctl.h> |
| |
| #include <ion/ion.h> |
| #include <linux/ion.h> |
| #include <cutils/log.h> |
| #include <cutils/atomic.h> |
| |
| #include <hardware/hardware.h> |
| #include <hardware/gralloc.h> |
| |
| #include "gralloc_priv.h" |
| #include "exynos_format.h" |
| |
| #define ION_HEAP_EXYNOS_CONTIG_MASK (1 << 4) |
| #define ION_EXYNOS_FIMD_VIDEO_MASK (1 << 28) |
| #define ION_EXYNOS_MFC_OUTPUT_MASK (1 << 26) |
| #define ION_EXYNOS_MFC_INPUT_MASK (1 << 25) |
| #define ION_HEAP_SYSTEM_ID 0 |
| #define ION_HEAP_EXYNOS_CONTIG_ID 4 |
| #define ION_HEAP_CHUNK_ID 6 |
| #define MB_1 (1024*1024) |
| |
| |
| /*****************************************************************************/ |
| |
| struct gralloc_context_t { |
| alloc_device_t device; |
| /* our private data here */ |
| }; |
| |
| static int gralloc_alloc_buffer(alloc_device_t* dev, |
| size_t size, int usage, buffer_handle_t* pHandle); |
| |
| /*****************************************************************************/ |
| |
| int fb_device_open(const hw_module_t* module, const char* name, |
| hw_device_t** device); |
| |
| static int gralloc_device_open(const hw_module_t* module, const char* name, |
| hw_device_t** device); |
| |
| extern int gralloc_lock(gralloc_module_t const* module, |
| buffer_handle_t handle, int usage, |
| int l, int t, int w, int h, |
| void** vaddr); |
| |
| extern int gralloc_unlock(gralloc_module_t const* module, |
| buffer_handle_t handle); |
| |
| extern int gralloc_register_buffer(gralloc_module_t const* module, |
| buffer_handle_t handle); |
| |
| extern int gralloc_unregister_buffer(gralloc_module_t const* module, |
| buffer_handle_t handle); |
| |
| /*****************************************************************************/ |
| |
| static struct hw_module_methods_t gralloc_module_methods = { |
| open: gralloc_device_open |
| }; |
| |
| struct private_module_t HAL_MODULE_INFO_SYM = { |
| base: { |
| common: { |
| tag: HARDWARE_MODULE_TAG, |
| version_major: 1, |
| version_minor: 0, |
| id: GRALLOC_HARDWARE_MODULE_ID, |
| name: "Graphics Memory Allocator Module", |
| author: "The Android Open Source Project", |
| methods: &gralloc_module_methods |
| }, |
| registerBuffer: gralloc_register_buffer, |
| unregisterBuffer: gralloc_unregister_buffer, |
| lock: gralloc_lock, |
| unlock: gralloc_unlock, |
| }, |
| framebuffer: 0, |
| flags: 0, |
| numBuffers: 0, |
| bufferMask: 0, |
| lock: PTHREAD_MUTEX_INITIALIZER, |
| refcount: 0, |
| currentBuffer: 0, |
| ionfd: -1, |
| }; |
| |
| /*****************************************************************************/ |
| |
| static unsigned int _select_heap(int usage) |
| { |
| unsigned int heap_mask; |
| |
| if (usage & GRALLOC_USAGE_PROTECTED) |
| heap_mask = (1 << ION_HEAP_EXYNOS_CONTIG_ID); |
| else |
| heap_mask = (1 << ION_HEAP_SYSTEM_ID) | (1 << ION_HEAP_CHUNK_ID); |
| |
| return heap_mask; |
| } |
| |
| static int gralloc_alloc_rgb(int ionfd, int w, int h, int format, int usage, |
| unsigned int ion_flags, private_handle_t **hnd, int *stride) |
| { |
| size_t size, bpr, alignment = 0; |
| int bpp = 0, vstride, fd, err; |
| unsigned int heap_mask = _select_heap(usage); |
| |
| if (format == HAL_PIXEL_FORMAT_RGBA_8888) { |
| bool sw_usage = !!(usage & (GRALLOC_USAGE_SW_READ_MASK | |
| GRALLOC_USAGE_SW_WRITE_MASK)); |
| |
| if (usage & GRALLOC_USAGE_HW_FB) { |
| ALOGW_IF(sw_usage, |
| "framebuffer target should not have SW usage bits; ignoring"); |
| format = HAL_PIXEL_FORMAT_BGRA_8888; |
| } else if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) { |
| if (sw_usage) |
| return -EINVAL; |
| format = HAL_PIXEL_FORMAT_BGRA_8888; |
| } |
| } |
| |
| switch (format) { |
| case HAL_PIXEL_FORMAT_RGBA_8888: |
| case HAL_PIXEL_FORMAT_RGBX_8888: |
| case HAL_PIXEL_FORMAT_BGRA_8888: |
| case HAL_PIXEL_FORMAT_sRGB_A_8888: |
| case HAL_PIXEL_FORMAT_sRGB_X_8888: |
| bpp = 4; |
| break; |
| case HAL_PIXEL_FORMAT_RGB_888: |
| bpp = 3; |
| break; |
| case HAL_PIXEL_FORMAT_RGB_565: |
| case HAL_PIXEL_FORMAT_RAW_SENSOR: |
| bpp = 2; |
| break; |
| case HAL_PIXEL_FORMAT_BLOB: |
| *stride = w; |
| vstride = h; |
| size = w * h; |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| if (format != HAL_PIXEL_FORMAT_BLOB) { |
| bpr = ALIGN(w*bpp, 64); |
| vstride = ALIGN(h, 16); |
| if (vstride < h + 2) |
| size = bpr * (h + 2); |
| else |
| size = bpr * vstride; |
| *stride = bpr / bpp; |
| size = ALIGN(size, PAGE_SIZE); |
| } |
| |
| if (usage & GRALLOC_USAGE_PROTECTED) { |
| alignment = MB_1; |
| ion_flags |= ION_EXYNOS_FIMD_VIDEO_MASK; |
| } |
| |
| err = ion_alloc_fd(ionfd, size, alignment, heap_mask, ion_flags, |
| &fd); |
| *hnd = new private_handle_t(fd, size, usage, w, h, format, *stride, |
| vstride); |
| |
| return err; |
| } |
| |
| static int gralloc_alloc_framework_yuv(int ionfd, int w, int h, int format, |
| int usage, unsigned int ion_flags, |
| private_handle_t **hnd, int *stride) |
| { |
| size_t size; |
| int err, fd; |
| unsigned int heap_mask = _select_heap(usage); |
| |
| switch (format) { |
| case HAL_PIXEL_FORMAT_YV12: |
| *stride = ALIGN(w, 16); |
| size = (*stride * h) + (ALIGN(*stride / 2, 16) * h); |
| break; |
| case HAL_PIXEL_FORMAT_YCrCb_420_SP: |
| *stride = w; |
| size = *stride * h * 3 / 2; |
| break; |
| default: |
| ALOGE("invalid yuv format %d\n", format); |
| return -EINVAL; |
| } |
| |
| err = ion_alloc_fd(ionfd, size, 0, heap_mask, ion_flags, &fd); |
| if (err) |
| return err; |
| |
| *hnd = new private_handle_t(fd, size, usage, w, h, format, *stride, h); |
| return err; |
| } |
| |
| static int gralloc_alloc_yuv(int ionfd, int w, int h, int format, |
| int usage, unsigned int ion_flags, |
| private_handle_t **hnd, int *stride) |
| { |
| size_t luma_size, chroma_size; |
| int err, planes, fd, fd1, fd2 = 0; |
| size_t luma_vstride; |
| unsigned int heap_mask = _select_heap(usage); |
| |
| *stride = ALIGN(w, 16); |
| |
| if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { |
| ALOGV("HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED : usage(%x), flags(%x)\n", usage, ion_flags); |
| if ((usage & GRALLOC_USAGE_HW_CAMERA_ZSL) == GRALLOC_USAGE_HW_CAMERA_ZSL) { |
| format = HAL_PIXEL_FORMAT_YCbCr_422_I; // YUYV |
| } else if (usage & GRALLOC_USAGE_HW_TEXTURE) { |
| format = HAL_PIXEL_FORMAT_EXYNOS_YV12; |
| } else if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) { |
| format = HAL_PIXEL_FORMAT_YCbCr_420_SP; // NV12M |
| } |
| } |
| switch (format) { |
| case HAL_PIXEL_FORMAT_EXYNOS_YV12: |
| { |
| *stride = ALIGN(w, 32); |
| luma_vstride = ALIGN(h, 16); |
| luma_size = luma_vstride * *stride; |
| chroma_size = (luma_vstride / 2) * ALIGN(*stride / 2, 16); |
| planes = 3; |
| break; |
| } |
| case HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP: |
| case HAL_PIXEL_FORMAT_YCbCr_420_SP: |
| case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED: |
| { |
| size_t chroma_vstride = ALIGN(h / 2, 32); |
| luma_vstride = ALIGN(h, 32); |
| luma_size = luma_vstride * *stride; |
| chroma_size = chroma_vstride * *stride; |
| planes = 2; |
| break; |
| } |
| case HAL_PIXEL_FORMAT_YV12: |
| case HAL_PIXEL_FORMAT_YCrCb_420_SP: |
| return gralloc_alloc_framework_yuv(ionfd, w, h, format, usage, |
| ion_flags, hnd, stride); |
| case HAL_PIXEL_FORMAT_YCbCr_422_I: |
| { |
| luma_vstride = h; |
| luma_size = luma_vstride * *stride * 2; |
| chroma_size = 0; |
| planes = 1; |
| break; |
| } |
| default: |
| ALOGE("invalid yuv format %d\n", format); |
| return -EINVAL; |
| } |
| |
| if (usage & GRALLOC_USAGE_PROTECTED) |
| ion_flags |= ION_EXYNOS_MFC_OUTPUT_MASK; |
| |
| err = ion_alloc_fd(ionfd, luma_size, 0, heap_mask, ion_flags, &fd); |
| if (err) |
| return err; |
| if (planes == 1) { |
| *hnd = new private_handle_t(fd, luma_size, usage, w, h, |
| format, *stride, luma_vstride); |
| } else { |
| err = ion_alloc_fd(ionfd, chroma_size, 0, heap_mask, ion_flags, &fd1); |
| if (err) |
| goto err1; |
| if (planes == 3) { |
| err = ion_alloc_fd(ionfd, chroma_size, 0, heap_mask, ion_flags, &fd2); |
| if (err) |
| goto err2; |
| |
| *hnd = new private_handle_t(fd, fd1, fd2, luma_size, usage, w, h, |
| format, *stride, luma_vstride); |
| } else { |
| *hnd = new private_handle_t(fd, fd1, luma_size, usage, w, h, format, |
| *stride, luma_vstride); |
| } |
| } |
| // Set chroma & gamut fields |
| if (!err && *hnd) { |
| if (usage & GRALLOC_USAGE_PRIVATE_CHROMA) { |
| (*hnd)->chroma = HAL_PIXEL_CHROMA_BT601_8; |
| (*hnd)->gamut = HAL_PIXEL_GAMUT_NARROW_8; |
| } else { |
| (*hnd)->chroma = HAL_PIXEL_CHROMA_BT709_8; |
| (*hnd)->gamut = HAL_PIXEL_GAMUT_WIDE_8; |
| } |
| } |
| return err; |
| |
| err2: |
| close(fd1); |
| err1: |
| close(fd); |
| return err; |
| } |
| |
| static int gralloc_alloc(alloc_device_t* dev, |
| int w, int h, int format, int usage, |
| buffer_handle_t* pHandle, int* pStride) |
| { |
| int stride; |
| int err; |
| unsigned int ion_flags = 0; |
| private_handle_t *hnd = NULL; |
| |
| if (!pHandle || !pStride) |
| return -EINVAL; |
| |
| if( (usage & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN ) |
| ion_flags = ION_FLAG_CACHED | ION_FLAG_CACHED_NEEDS_SYNC; |
| |
| private_module_t* m = reinterpret_cast<private_module_t*> |
| (dev->common.module); |
| gralloc_module_t* module = reinterpret_cast<gralloc_module_t*> |
| (dev->common.module); |
| |
| err = gralloc_alloc_rgb(m->ionfd, w, h, format, usage, ion_flags, &hnd, |
| &stride); |
| if (err) |
| err = gralloc_alloc_yuv(m->ionfd, w, h, format, usage, ion_flags, |
| &hnd, &stride); |
| if (err) |
| goto err; |
| |
| err = gralloc_register_buffer(module, hnd); |
| if (err) |
| goto err; |
| |
| *pHandle = hnd; |
| *pStride = stride; |
| return 0; |
| err: |
| if (!hnd) |
| return err; |
| close(hnd->fd); |
| if (hnd->fd1 >= 0) |
| close(hnd->fd1); |
| if (hnd->fd2 >= 0) |
| close(hnd->fd2); |
| return err; |
| } |
| |
| static int gralloc_free(alloc_device_t* dev, |
| buffer_handle_t handle) |
| { |
| if (private_handle_t::validate(handle) < 0) |
| return -EINVAL; |
| |
| private_handle_t const* hnd = reinterpret_cast<private_handle_t const*>(handle); |
| gralloc_module_t* module = reinterpret_cast<gralloc_module_t*>( |
| dev->common.module); |
| |
| gralloc_unregister_buffer(module, hnd); |
| |
| close(hnd->fd); |
| if (hnd->fd1 >= 0) |
| close(hnd->fd1); |
| if (hnd->fd2 >= 0) |
| close(hnd->fd2); |
| |
| delete hnd; |
| return 0; |
| } |
| |
| /*****************************************************************************/ |
| |
| static int gralloc_close(struct hw_device_t *dev) |
| { |
| gralloc_context_t* ctx = reinterpret_cast<gralloc_context_t*>(dev); |
| if (ctx) { |
| private_module_t *p = reinterpret_cast<private_module_t*>(ctx->device.common.module); |
| pthread_mutex_lock(&p->lock); |
| LOG_ALWAYS_FATAL_IF(!p->refcount); |
| p->refcount--; |
| if (!p->refcount) |
| close(p->ionfd); |
| pthread_mutex_unlock(&p->lock); |
| |
| /* TODO: keep a list of all buffer_handle_t created, and free them |
| * all here. |
| */ |
| free(ctx); |
| } |
| return 0; |
| } |
| |
| int gralloc_device_open(const hw_module_t* module, const char* name, |
| hw_device_t** device) |
| { |
| int status = -EINVAL; |
| if (!strcmp(name, GRALLOC_HARDWARE_GPU0)) { |
| gralloc_context_t *dev; |
| dev = (gralloc_context_t*)malloc(sizeof(*dev)); |
| |
| /* initialize our state here */ |
| memset(dev, 0, sizeof(*dev)); |
| |
| /* initialize the procs */ |
| dev->device.common.tag = HARDWARE_DEVICE_TAG; |
| dev->device.common.version = 0; |
| dev->device.common.module = const_cast<hw_module_t*>(module); |
| dev->device.common.close = gralloc_close; |
| |
| dev->device.alloc = gralloc_alloc; |
| dev->device.free = gralloc_free; |
| |
| private_module_t *p = reinterpret_cast<private_module_t*>(dev->device.common.module); |
| pthread_mutex_lock(&p->lock); |
| if (!p->refcount) |
| p->ionfd = ion_open(); |
| p->refcount++; |
| pthread_mutex_unlock(&p->lock); |
| |
| *device = &dev->device.common; |
| status = 0; |
| } else { |
| status = fb_device_open(module, name, device); |
| } |
| return status; |
| } |