diff options
Diffstat (limited to 'gralloc960/alloc_ion.cpp')
| -rw-r--r-- | gralloc960/alloc_ion.cpp | 365 |
1 files changed, 365 insertions, 0 deletions
diff --git a/gralloc960/alloc_ion.cpp b/gralloc960/alloc_ion.cpp new file mode 100644 index 00000000..2f9efc05 --- /dev/null +++ b/gralloc960/alloc_ion.cpp @@ -0,0 +1,365 @@ +/* + * Copyright (C) 2013 ARM Limited. All rights reserved. + * + * 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 <string.h> +#include <errno.h> +#include <inttypes.h> +#include <pthread.h> + +#include <cutils/log.h> +#include <cutils/atomic.h> +#include <hardware/hardware.h> +#include <hardware/gralloc.h> + +#include <sys/ioctl.h> + +#include "alloc_device.h" +#include "gralloc_priv.h" +#include "gralloc_helper.h" +#include "framebuffer_device.h" + +#include "mali_gralloc_formats.h" + +#include <linux/ion.h> +#include <ion/ion.h> + +static void init_afbc(uint8_t *buf, uint64_t internal_format, int w, int h) +{ + uint32_t n_headers = (w * h) / 64; + uint32_t body_offset = n_headers * 16; + uint32_t headers[][4] = { {body_offset, 0x1, 0x0, 0x0}, /* Layouts 0, 3, 4 */ + {(body_offset + (1 << 28)), 0x200040, 0x4000, 0x80} /* Layouts 1, 5 */ + }; + uint32_t i, layout; + + /* map format if necessary (also removes internal extension bits) */ + uint64_t base_format = internal_format & MALI_GRALLOC_INTFMT_FMT_MASK; + + switch (base_format) + { + case MALI_GRALLOC_FORMAT_INTERNAL_RGBA_8888: + case MALI_GRALLOC_FORMAT_INTERNAL_RGBX_8888: + case MALI_GRALLOC_FORMAT_INTERNAL_RGB_888: + case MALI_GRALLOC_FORMAT_INTERNAL_RGB_565: + case MALI_GRALLOC_FORMAT_INTERNAL_BGRA_8888: + layout = 0; + break; + + case MALI_GRALLOC_FORMAT_INTERNAL_YV12: + case MALI_GRALLOC_FORMAT_INTERNAL_NV12: + case MALI_GRALLOC_FORMAT_INTERNAL_NV21: + layout = 1; + break; + default: + layout = 0; + } + + ALOGV("Writing AFBC header layout %d for format %" PRIu64, layout, base_format); + + for (i = 0; i < n_headers; i++) + { + memcpy(buf, headers[layout], sizeof(headers[layout])); + buf += sizeof(headers[layout]); + } + +} + +static ion_user_handle_t alloc_from_ion_heap(int ion_fd, size_t size, unsigned int heap_mask, + unsigned int flags, int *min_pgsz) +{ + ion_user_handle_t ion_hnd = -1; + int ret; + + if ((ion_fd < 0) || (size <= 0) || (heap_mask == 0) || (min_pgsz == NULL)) + return -1; + + ret = ion_alloc(ion_fd, size, 0, heap_mask, flags, &ion_hnd); + if (ret < 0) + { +#if defined(ION_HEAP_SECURE_MASK) + if (heap_mask == ION_HEAP_SECURE_MASK) + { + return -1; + } + else +#endif + { + /* If everything else failed try system heap */ + flags = 0; /* Fallback option flags are not longer valid */ + heap_mask = ION_HEAP_SYSTEM_MASK; + ret = ion_alloc(ion_fd, size, 0, heap_mask, flags, &ion_hnd); + } + } + + if (ret >= 0) + { + switch (heap_mask) + { + case ION_HEAP_SYSTEM_MASK: + *min_pgsz = SZ_4K; + break; + case ION_HEAP_SYSTEM_CONTIG_MASK: + case ION_HEAP_CARVEOUT_MASK: +#ifdef ION_HEAP_TYPE_DMA_MASK + case ION_HEAP_TYPE_DMA_MASK: +#endif + *min_pgsz = size; + break; +#ifdef ION_HEAP_CHUNK_MASK + /* NOTE: if have this heap make sure your ION chunk size is 2M*/ + case ION_HEAP_CHUNK_MASK: + *min_pgsz = SZ_2M; + break; +#endif +#ifdef ION_HEAP_COMPOUND_PAGE_MASK + case ION_HEAP_COMPOUND_PAGE_MASK: + *min_pgsz = SZ_2M; + break; +#endif + /* If have customized heap please set the suitable pg type according to + * the customized ION implementation + */ +#ifdef ION_HEAP_CUSTOM_MASK + case ION_HEAP_CUSTOM_MASK: + *min_pgsz = SZ_4K; + break; +#endif + default: + *min_pgsz = SZ_4K; + break; + } + } + + return ion_hnd; +} + +unsigned int pick_ion_heap(int usage) +{ + unsigned int heap_mask; + + if(usage & GRALLOC_USAGE_PROTECTED) + { +#if defined(ION_HEAP_SECURE_MASK) + heap_mask = ION_HEAP_SECURE_MASK; +#else + AERR("Protected ION memory is not supported on this platform."); + return 0; +#endif + } +#if defined(ION_HEAP_TYPE_COMPOUND_PAGE_MASK) && GRALLOC_USE_ION_COMPOUND_PAGE_HEAP + else if(!(usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) && (usage & (GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_HW_COMPOSER))) + { + heap_mask = ION_HEAP_TYPE_COMPOUND_PAGE_MASK; + } +#elif defined(ION_HEAP_TYPE_DMA_MASK) && GRALLOC_USE_ION_DMA_HEAP + else if(!(usage & GRALLOC_USAGE_HW_VIDEO_ENCODER) && (usage & (GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_HW_COMPOSER))) + { + heap_mask = ION_HEAP_TYPE_DMA_MASK; + } +#endif + else + { + heap_mask = ION_HEAP_SYSTEM_MASK; + } + + return heap_mask; +} + +void set_ion_flags(unsigned int heap_mask, int usage, unsigned int *priv_heap_flag, int *ion_flags) +{ +#if !GRALLOC_USE_ION_DMA_HEAP + GRALLOC_UNUSED(heap_mask); +#endif + + if (priv_heap_flag) + { +#if defined(ION_HEAP_TYPE_DMA_MASK) && GRALLOC_USE_ION_DMA_HEAP + if (heap_mask == ION_HEAP_TYPE_DMA_MASK) + { + *priv_heap_flag = private_handle_t::PRIV_FLAGS_USES_ION_DMA_HEAP; + } +#endif + } + + if (ion_flags) + { +#if defined(ION_HEAP_TYPE_DMA_MASK) && GRALLOC_USE_ION_DMA_HEAP + if(heap_mask != ION_HEAP_TYPE_DMA_MASK) + { +#endif + if ( (usage & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN ) + { + *ion_flags = ION_FLAG_CACHED | ION_FLAG_CACHED_NEEDS_SYNC; + } +#if defined(ION_HEAP_TYPE_DMA_MASK) && GRALLOC_USE_ION_DMA_HEAP + } +#endif + } +} + +int alloc_backend_alloc(alloc_device_t* dev, size_t size, int usage, buffer_handle_t* pHandle, uint64_t fmt, int w, int h) +{ + private_module_t* m = reinterpret_cast<private_module_t*>(dev->common.module); + ion_user_handle_t ion_hnd; + unsigned char *cpu_ptr = NULL; + int shared_fd; + int ret; + unsigned int heap_mask, priv_heap_flag = 0; + int ion_flags = 0; + static int support_protected = 1; /* initially, assume we support protected memory */ + int lock_state = 0; + int min_pgsz = 0; + + heap_mask = pick_ion_heap(usage); + if(heap_mask == 0) + { + AERR("Failed to find an appropriate ion heap"); + return -1; + } + set_ion_flags(heap_mask, usage, &priv_heap_flag, &ion_flags); + + ion_hnd = alloc_from_ion_heap(m->ion_client, size, heap_mask, ion_flags, &min_pgsz); + if (ion_hnd < 0) + { + AERR("Failed to ion_alloc from ion_client:%d", m->ion_client); + return -1; + } + + ret = ion_share( m->ion_client, ion_hnd, &shared_fd ); + if ( ret != 0 ) + { + AERR( "ion_share( %d ) failed", m->ion_client ); + if ( 0 != ion_free( m->ion_client, ion_hnd ) ) AERR( "ion_free( %d ) failed", m->ion_client ); + return -1; + } + + if (!(usage & GRALLOC_USAGE_PROTECTED)) + { + cpu_ptr = (unsigned char*)mmap( NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, shared_fd, 0 ); + + if ( MAP_FAILED == cpu_ptr ) + { + AERR( "ion_map( %d ) failed", m->ion_client ); + if ( 0 != ion_free( m->ion_client, ion_hnd ) ) AERR( "ion_free( %d ) failed", m->ion_client ); + close( shared_fd ); + return -1; + } + lock_state = private_handle_t::LOCK_STATE_MAPPED; + +#if GRALLOC_INIT_AFBC == 1 + if (fmt & MALI_GRALLOC_INTFMT_AFBCENABLE_MASK) + { + init_afbc(cpu_ptr, fmt, w, h); + } +#else + GRALLOC_UNUSED(fmt); + GRALLOC_UNUSED(w); + GRALLOC_UNUSED(h); + +#endif /* GRALLOC_INIT_AFBC == 1 */ + } + + private_handle_t *hnd = new private_handle_t( private_handle_t::PRIV_FLAGS_USES_ION | priv_heap_flag, usage, size, cpu_ptr, + lock_state, -1, 0); + + if ( NULL != hnd ) + { + hnd->share_fd = shared_fd; + hnd->ion_hnd = ion_hnd; + hnd->min_pgsz = min_pgsz; + *pHandle = hnd; + return 0; + } + else + { + AERR( "Gralloc out of mem for ion_client:%d", m->ion_client ); + } + + close( shared_fd ); + + if(!(usage & GRALLOC_USAGE_PROTECTED)) + { + ret = munmap( cpu_ptr, size ); + if ( 0 != ret ) AERR( "munmap failed for base:%p size: %zd", cpu_ptr, size ); + } + + ret = ion_free( m->ion_client, ion_hnd ); + if ( 0 != ret ) AERR( "ion_free( %d ) failed", m->ion_client ); + return -1; +} + +int alloc_backend_alloc_framebuffer(private_module_t* m, private_handle_t* hnd) +{ + struct fb_dmabuf_export fb_dma_buf; + int res; + res = ioctl( m->framebuffer->fd, FBIOGET_DMABUF, &fb_dma_buf ); + if(res == 0) + { + hnd->share_fd = fb_dma_buf.fd; + return 0; + } + else + { + AINF("FBIOGET_DMABUF ioctl failed(%d). See gralloc_priv.h and the integration manual for vendor framebuffer integration", res); + return -1; + } +} + +void alloc_backend_alloc_free(private_handle_t const* hnd, private_module_t* m) +{ + if (hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) + { + return; + } + else if ( hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION ) + { + /* Buffer might be unregistered already so we need to assure we have a valid handle*/ + if ( 0 != hnd->base ) + { + if ( 0 != munmap( (void*)hnd->base, hnd->size ) ) AERR( "Failed to munmap handle %p", hnd ); + } + close( hnd->share_fd ); + if ( 0 != ion_free( m->ion_client, hnd->ion_hnd ) ) AERR( "Failed to ion_free( ion_client: %d ion_hnd: %d )", m->ion_client, hnd->ion_hnd ); + memset( (void*)hnd, 0, sizeof( *hnd ) ); + } +} + +int alloc_backend_open(alloc_device_t *dev) +{ + private_module_t *m = reinterpret_cast<private_module_t *>(dev->common.module); + m->ion_client = ion_open(); + if ( m->ion_client < 0 ) + { + AERR( "ion_open failed with %s", strerror(errno) ); + return -1; + } + + return 0; +} + +int alloc_backend_close(struct hw_device_t *device) +{ + alloc_device_t* dev = reinterpret_cast<alloc_device_t*>(device); + if (dev) + { + private_module_t *m = reinterpret_cast<private_module_t*>(dev->common.module); + if ( 0 != ion_close(m->ion_client) ) AERR( "Failed to close ion_client: %d err=%s", m->ion_client , strerror(errno)); + delete dev; + } + return 0; +} |