gralloc: use built-in ion implement instead of libion. [3/12]

PD# 156770

for android o requirement, IMapper interface cant use libion.

Change-Id: I745da095fc5c75fde3339480b52e47f39856fcb6

3 files changed, 199 insertions, 12 deletions

diff --git a/Android.mk b/Android.mk
index d080227..8e21d29 100644
--- a/Android.mk
+++ b/Android.mk
@@ -85,8 +85,12 @@ ifeq ($(MALI_ARCHITECTURE_UTGARD),1)
 	GRALLOC_FB_SWAP_RED_BLUE?=0
 	MALI_DDK_INCLUDES=$(MALI_LOCAL_PATH)/include $(MALI_LOCAL_PATH)/src/ump/include
 	ifeq ($(MALI_ION),1)
-		ALLOCATION_LIB := libion
 		ALLOCATOR_SPECIFIC_FILES := alloc_ion.cpp gralloc_module_ion.cpp
+		ifeq ($(shell test $(PLATFORM_SDK_VERSION) -ge 26 && echo OK),OK)
+			ALLOCATOR_SPECIFIC_FILES += ion_wrapper.cpp
+		else
+			ALLOCATION_LIB := libion
+		endif
 	else
 		ALLOCATION_LIB := libUMP
 		ALLOCATOR_SPECIFIC_FILES := alloc_ump.cpp gralloc_module_ump.cpp
@@ -98,13 +102,17 @@ else
 	GRALLOC_DEPTH?=GRALLOC_32_BITS
 	GRALLOC_FB_SWAP_RED_BLUE?=0
 	MALI_DDK_INCLUDES=$(MALI_LOCAL_PATH)/include $(MALI_LOCAL_PATH)/kernel/include
-  ifeq ($(MALI_ION),1)
-		ALLOCATION_LIB := libion
+	ifeq ($(MALI_ION),1)
 		ALLOCATOR_SPECIFIC_FILES := alloc_ion.cpp gralloc_module_ion.cpp
-  else
+		ifeq ($(shell test $(PLATFORM_SDK_VERSION) -ge 26 && echo OK),OK)
+			ALLOCATOR_SPECIFIC_FILES += ion_wrapper.cpp
+		else
+			ALLOCATION_LIB := libion
+		endif
+	else
 		ALLOCATION_LIB := libGLES_mali
 		ALLOCATOR_SPECIFIC_FILES := alloc_ump.cpp gralloc_module_ump.cpp
-  endif
+	endif
 $(info GRALLOC_FB_SWAP_RED_BLUE1 is $(GRALLOC_FB_SWAP_RED_BLUE))
 endif
 #MALI_AFBC_GRALLOC?=1
diff --git a/alloc_ion.cpp b/alloc_ion.cpp
index f92104c..a7f5c38 100644
--- a/alloc_ion.cpp
+++ b/alloc_ion.cpp
@@ -48,12 +48,12 @@ int alloc_backend_alloc(alloc_device_t* dev, size_t size, int usage, buffer_hand
 	unsigned char *cpu_ptr = NULL;
 	int shared_fd;
 	int ret = -1;
-	unsigned int heap_mask;
+	unsigned int heap_type;
 	int ion_flags = 0;
 	static int support_protected = 1; /* initially, assume we support protected memory */
 	int lock_state = 0;
 
-#define ION_HEAP_SECURE_MASK 1
+#define ION_HEAP_TYPE_SECURE ION_HEAP_TYPE_SYSTEM
 
 	bool secureOrProtectedLayer = false;
 #ifdef GRALLOC_ENABLE_SECURE_LAYER
@@ -71,8 +71,8 @@ int alloc_backend_alloc(alloc_device_t* dev, size_t size, int usage, buffer_hand
 	/* Select heap type based on usage hints */
 	if (usage & GRALLOC_USAGE_PROTECTED)
 	{
-#if defined(ION_HEAP_SECURE_MASK)
-		heap_mask = ION_HEAP_SECURE_MASK;
+#if defined(ION_HEAP_TYPE_SECURE)
+		heap_type = ION_HEAP_TYPE_SECURE;
 #else
 		AERR("Protected ION memory is not supported on this platform.");
 		return -1;
@@ -80,7 +80,7 @@ int alloc_backend_alloc(alloc_device_t* dev, size_t size, int usage, buffer_hand
 	}
 	else
 	{
-		heap_mask = ION_HEAP_SYSTEM_MASK;
+		heap_type = ION_HEAP_TYPE_SYSTEM;
 	}
 
 	if ( (usage & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN )
@@ -144,14 +144,14 @@ int alloc_backend_alloc(alloc_device_t* dev, size_t size, int usage, buffer_hand
 		if (ret != 0) {
 			layerAllocContinousBuf = false;
 			ALOGV("(%d) Failed to alloc ion cma|chunk mem, alloc from system ion buffer.", ret);
-			ret = ion_alloc(m->ion_client, size, 0, heap_mask,
+			ret = ion_alloc(m->ion_client, size, 0, 1<<heap_type,
 										ion_flags, &ion_hnd);
 		}
 	}
 #endif
 	else
 	{
-		ret = ion_alloc(m->ion_client, size, 0, heap_mask,
+		ret = ion_alloc(m->ion_client, size, 0, 1<<heap_type,
 									ion_flags, &ion_hnd);
 	}
 
diff --git a/ion_wrapper.cpp b/ion_wrapper.cpp
new file mode 100644
index 0000000..951e122
--- a/dev/null
+++ b/ion_wrapper.cpp
@@ -0,0 +1,179 @@
+/*
+ *  ion.c
+ *
+ * Memory Allocator functions for ion
+ *
+ *   Copyright 2011 Google, Inc
+ *
+ *  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.
+ */
+#define LOG_TAG "gralloc_ion"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/ion.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <ion/ion.h>
+#include <log/log.h>
+
+int ion_open()
+{
+    int fd = open("/dev/ion", O_RDONLY | O_CLOEXEC);
+    if (fd < 0)
+        ALOGE("open /dev/ion failed!\n");
+    return fd;
+}
+
+int ion_close(int fd)
+{
+    int ret = close(fd);
+    if (ret < 0)
+        return -errno;
+    return ret;
+}
+
+static int ion_ioctl(int fd, int req, void *arg)
+{
+    int ret = ioctl(fd, req, arg);
+    if (ret < 0) {
+        ALOGE("ioctl %x failed with code %d: %s\n", req,
+              ret, strerror(errno));
+        return -errno;
+    }
+    return ret;
+}
+
+int ion_alloc(int fd, size_t len, size_t align, unsigned int heap_mask,
+              unsigned int flags, ion_user_handle_t *handle)
+{
+    int ret;
+    struct ion_allocation_data data = {
+        .len = len,
+        .align = align,
+        .heap_id_mask = heap_mask,
+        .flags = flags,
+    };
+
+    if (handle == NULL)
+        return -EINVAL;
+
+    ret = ion_ioctl(fd, ION_IOC_ALLOC, &data);
+    if (ret < 0)
+        return ret;
+    *handle = data.handle;
+    return ret;
+}
+
+int ion_free(int fd, ion_user_handle_t handle)
+{
+    struct ion_handle_data data = {
+        .handle = handle,
+    };
+    return ion_ioctl(fd, ION_IOC_FREE, &data);
+}
+
+int ion_map(int fd, ion_user_handle_t handle, size_t length, int prot,
+            int flags, off_t offset, unsigned char **ptr, int *map_fd)
+{
+    int ret;
+    unsigned char *tmp_ptr;
+    struct ion_fd_data data = {
+        .handle = handle,
+    };
+
+    if (map_fd == NULL)
+        return -EINVAL;
+    if (ptr == NULL)
+        return -EINVAL;
+
+    ret = ion_ioctl(fd, ION_IOC_MAP, &data);
+    if (ret < 0)
+        return ret;
+    if (data.fd < 0) {
+        ALOGE("map ioctl returned negative fd\n");
+        return -EINVAL;
+    }
+    tmp_ptr = (unsigned char *)mmap(NULL, length, prot, flags, data.fd, offset);
+    if (tmp_ptr == MAP_FAILED) {
+        ALOGE("mmap failed: %s\n", strerror(errno));
+        return -errno;
+    }
+    *map_fd = data.fd;
+    *ptr = tmp_ptr;
+    return ret;
+}
+
+int ion_share(int fd, ion_user_handle_t handle, int *share_fd)
+{
+    int ret;
+    struct ion_fd_data data = {
+        .handle = handle,
+    };
+
+    if (share_fd == NULL)
+        return -EINVAL;
+
+    ret = ion_ioctl(fd, ION_IOC_SHARE, &data);
+    if (ret < 0)
+        return ret;
+    if (data.fd < 0) {
+        ALOGE("share ioctl returned negative fd\n");
+        return -EINVAL;
+    }
+    *share_fd = data.fd;
+    return ret;
+}
+
+int ion_alloc_fd(int fd, size_t len, size_t align, unsigned int heap_mask,
+                 unsigned int flags, int *handle_fd) {
+    ion_user_handle_t handle;
+    int ret;
+
+    ret = ion_alloc(fd, len, align, heap_mask, flags, &handle);
+    if (ret < 0)
+        return ret;
+    ret = ion_share(fd, handle, handle_fd);
+    ion_free(fd, handle);
+    return ret;
+}
+
+int ion_import(int fd, int share_fd, ion_user_handle_t *handle)
+{
+    int ret;
+    struct ion_fd_data data = {
+        .fd = share_fd,
+    };
+
+    if (handle == NULL)
+        return -EINVAL;
+
+    ret = ion_ioctl(fd, ION_IOC_IMPORT, &data);
+    if (ret < 0)
+        return ret;
+    *handle = data.handle;
+    return ret;
+}
+
+int ion_sync_fd(int fd, int handle_fd)
+{
+    struct ion_fd_data data = {
+        .fd = handle_fd,
+    };
+    return ion_ioctl(fd, ION_IOC_SYNC, &data);
+}