HiKey960: Integrate ARM's reference gralloc for mali bifrost
This integrates the BX304L01B-SW-99005-r4p0-01rel0
mali bifrost package from ARM available here:
https://developer.arm.com/products/software/mali-drivers/android-gralloc-module
Change-Id: I737bce784d21d1a870229a16bcddd3668738405a
Signed-off-by: John Stultz <john.stultz@linaro.org>
diff --git a/gralloc960/alloc_ion.cpp b/gralloc960/alloc_ion.cpp
new file mode 100644
index 0000000..2f9efc0
--- /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;
+}