TI mainline's libion

Change-Id: I4b65db028d9f53635f193c74662a765408379e65
Signed-off-by: Mike J. Chen <mjchen@google.com>

4 files changed, 888 insertions, 8 deletions

diff --git a/ion/Android.mk b/ion/Android.mk
index 58fc9f9..3f36032 100644
--- a/ion/Android.mk
+++ b/ion/Android.mk
@@ -4,10 +4,30 @@ ifeq ($(TARGET_BOARD_PLATFORM),omap4)
 LOCAL_PATH:= $(call my-dir)
 
 include $(CLEAR_VARS)
+LOCAL_C_INCLUDES += $(HARDWARE_TI_OMAP4_BASE)/kernel-headers-ti
+LOCAL_C_INCLUDES += $(HARDWARE_TI_OMAP4_BASE)/system-core-headers-ti
 LOCAL_SRC_FILES := ion.c
 LOCAL_MODULE := libion_ti
 LOCAL_MODULE_TAGS := optional
 LOCAL_SHARED_LIBRARIES := liblog
 include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
 
+include $(CLEAR_VARS)
+LOCAL_C_INCLUDES += $(HARDWARE_TI_OMAP4_BASE)/kernel-headers-ti
+LOCAL_C_INCLUDES += $(HARDWARE_TI_OMAP4_BASE)/system-core-headers-ti
+LOCAL_SRC_FILES := ion.c ion_test.c
+LOCAL_MODULE := iontest_ti
+LOCAL_MODULE_TAGS := optional tests
+LOCAL_SHARED_LIBRARIES := liblog
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_C_INCLUDES += $(HARDWARE_TI_OMAP4_BASE)/kernel-headers-ti
+LOCAL_C_INCLUDES += $(HARDWARE_TI_OMAP4_BASE)/system-core-headers-ti
+LOCAL_SRC_FILES := ion.c ion_test_2.c
+LOCAL_MODULE := iontest2_ti
+LOCAL_MODULE_TAGS := optional tests
+LOCAL_SHARED_LIBRARIES := liblog
+include $(BUILD_HEAPTRACKED_SHARED_LIBRARY)
+
 endif
diff --git a/ion/ion.c b/ion/ion.c
index 54579db..2ecf697 100644
--- a/ion/ion.c
+++ b/ion/ion.c
@@ -17,6 +17,9 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
+#define LOG_TAG "ion"
+
+#include <cutils/log.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
@@ -24,12 +27,8 @@
 #include <sys/mman.h>
 #include <sys/types.h>
 
-#define LOG_TAG "ion"
-#include <cutils/log.h>
-
-#include "linux_ion.h"
-#include "omap_ion.h"
-#include "ion.h"
+#include <linux/ion.h>
+#include <ion/ion.h>
 
 int ion_open()
 {
@@ -55,8 +54,8 @@ static int ion_ioctl(int fd, int req, void *arg)
         return ret;
 }
 
-int ion_alloc(int fd, size_t len, size_t align, unsigned int flags,
-              struct ion_handle **handle)
+int ion_alloc(int fd, size_t len, size_t align,
+	      unsigned int flags, struct ion_handle **handle)
 {
         int ret;
         struct ion_allocation_data data = {
@@ -81,6 +80,8 @@ int ion_alloc_tiler(int fd, size_t w, size_t h, int fmt, unsigned int flags,
                 .h = h,
                 .fmt = fmt,
                 .flags = flags,
+                .out_align = PAGE_SIZE,
+                .token = 0,
         };
 
         struct ion_custom_data custom_data = {
@@ -154,3 +155,58 @@ int ion_import(int fd, int share_fd, struct ion_handle **handle)
         *handle = data.handle;
         return ret;
 }
+
+#if 0
+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);
+}
+#endif
+
+int ion_map_cacheable(int fd, struct ion_handle *handle, size_t length, int prot,
+            int flags, off_t offset, unsigned char **ptr, int *map_fd)
+{
+        struct ion_fd_data data = {
+                .handle = handle,
+                .cacheable = 1,
+        };
+        int ret = ion_ioctl(fd, ION_IOC_MAP, &data);
+        if (ret < 0)
+                return ret;
+        *map_fd = data.fd;
+        if (*map_fd < 0) {
+                ALOGE("map ioctl returned negative fd\n");
+                return -EINVAL;
+        }
+        *ptr = mmap(NULL, length, prot, flags, *map_fd, offset);
+        if (*ptr == MAP_FAILED) {
+                ALOGE("mmap failed: %s\n", strerror(errno));
+                return -errno;
+        }
+        return ret;
+}
+
+int ion_flush_cached(int fd, struct ion_handle *handle, size_t length,
+            unsigned char *ptr)
+{
+        struct ion_cached_user_buf_data data = {
+                .handle = handle,
+                .vaddr = (unsigned long)ptr,
+                .size = length,
+        };
+        return ion_ioctl(fd, ION_IOC_FLUSH_CACHED, &data);
+}
+
+int ion_inval_cached(int fd, struct ion_handle *handle, size_t length,
+            unsigned char *ptr)
+{
+        struct ion_cached_user_buf_data data = {
+                .handle = handle,
+                .vaddr = (unsigned long)ptr,
+                .size = length,
+        };
+        return ion_ioctl(fd, ION_IOC_INVAL_CACHED, &data);
+}
diff --git a/ion/ion_test.c b/ion/ion_test.c
new file mode 100644
index 0000000..945062f
--- /dev/null
+++ b/ion/ion_test.c
@@ -0,0 +1,323 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <ion/ion.h>
+#include <linux/ion.h>
+#include <linux/omap_ion.h>
+
+size_t len = 1024*1024, align = 0;
+int prot = PROT_READ | PROT_WRITE;
+int map_flags = MAP_SHARED;
+int alloc_flags = 0;
+int heap_mask = 1;
+int test = -1;
+size_t width = 1024*1024, height = 1024*1024;
+int fmt = TILER_PIXEL_FMT_32BIT;
+int tiler_test = 0;
+size_t stride;
+
+int _ion_alloc_test(int *fd, struct ion_handle **handle)
+{
+	int ret;
+
+	*fd = ion_open();
+	if (*fd < 0)
+		return *fd;
+
+	if (tiler_test)
+		ret = ion_alloc_tiler(*fd, width, height, fmt, alloc_flags,
+					  handle, &stride);
+	else
+		ret = ion_alloc(*fd, len, align, alloc_flags, handle);
+
+	if (ret)
+		printf("%s failed: %s\n", __func__, strerror(ret));
+	return ret;
+}
+
+void ion_alloc_test()
+{
+	int fd, ret;
+	struct ion_handle *handle;
+
+	if(_ion_alloc_test(&fd, &handle))
+			return;
+
+	ret = ion_free(fd, handle);
+	if (ret) {
+		printf("%s failed: %s %p\n", __func__, strerror(ret), handle);
+		return;
+	}
+	ion_close(fd);
+	printf("ion alloc test: passed\n");
+}
+
+void _ion_tiler_map_test(unsigned char *ptr)
+{
+	size_t row, col;
+
+	for (row = 0; row < height; row++)
+		for (col = 0; col < width; col++) {
+			int i = (row * stride) + col;
+			ptr[i] = (unsigned char)i;
+		}
+	for (row = 0; row < height; row++)
+		for (col = 0; col < width; col++) {
+			int i = (row * stride) + col;
+			if (ptr[i] != (unsigned char)i)
+				printf("%s failed wrote %d read %d from mapped "
+					   "memory\n", __func__, i, ptr[i]);
+		}
+}
+
+
+void ion_map_test()
+{
+	int fd, map_fd, ret;
+	size_t i;
+	struct ion_handle *handle;
+	unsigned char *ptr;
+
+	if(_ion_alloc_test(&fd, &handle))
+		return;
+
+	if (tiler_test)
+		len = height * stride;
+	ret = ion_map(fd, handle, len, prot, map_flags, 0, &ptr, &map_fd);
+	if (ret)
+		return;
+
+	if (tiler_test)
+		_ion_tiler_map_test(ptr);
+	else {
+		for (i = 0; i < len; i++) {
+			ptr[i] = (unsigned char)i;
+		}
+		for (i = 0; i < len; i++)
+			if (ptr[i] != (unsigned char)i)
+				printf("%s failed wrote %d read %d from mapped "
+					   "memory\n", __func__, i, ptr[i]);
+	}
+	/* clean up properly */
+	ret = ion_free(fd, handle);
+	ion_close(fd);
+	munmap(ptr, len);
+	close(map_fd);
+
+	_ion_alloc_test(&fd, &handle);
+	close(fd);
+
+#if 0
+	munmap(ptr, len);
+	close(map_fd);
+	ion_close(fd);
+
+	_ion_alloc_test(len, align, flags, &fd, &handle);
+	close(map_fd);
+	ret = ion_map(fd, handle, len, prot, flags, 0, &ptr, &map_fd);
+	/* don't clean up */
+#endif
+}
+
+void ion_share_test()
+
+{
+	struct ion_handle *handle;
+	int sd[2];
+	int num_fd = 1;
+	struct iovec count_vec = {
+		.iov_base = &num_fd,
+		.iov_len = sizeof num_fd,
+	};
+	char buf[CMSG_SPACE(sizeof(int))];
+	socketpair(AF_UNIX, SOCK_STREAM, 0, sd);
+	if (fork()) {
+		struct msghdr msg = {
+			.msg_control = buf,
+			.msg_controllen = sizeof buf,
+			.msg_iov = &count_vec,
+			.msg_iovlen = 1,
+		};
+
+		struct cmsghdr *cmsg;
+		int fd, share_fd, ret;
+		char *ptr;
+		/* parent */
+		if(_ion_alloc_test(&fd, &handle))
+			return;
+		ret = ion_share(fd, handle, &share_fd);
+		if (ret)
+			printf("share failed %s\n", strerror(errno));
+		ptr = mmap(NULL, len, prot, map_flags, share_fd, 0);
+		if (ptr == MAP_FAILED) {
+			return;
+		}
+		strcpy(ptr, "master");
+		cmsg = CMSG_FIRSTHDR(&msg);
+		cmsg->cmsg_level = SOL_SOCKET;
+		cmsg->cmsg_type = SCM_RIGHTS;
+		cmsg->cmsg_len = CMSG_LEN(sizeof(int));
+		*(int *)CMSG_DATA(cmsg) = share_fd;
+		/* send the fd */
+		printf("master? [%10s] should be [master]\n", ptr);
+		printf("master sending msg 1\n");
+		sendmsg(sd[0], &msg, 0);
+		if (recvmsg(sd[0], &msg, 0) < 0)
+			perror("master recv msg 2");
+		printf("master? [%10s] should be [child]\n", ptr);
+
+		/* send ping */
+		sendmsg(sd[0], &msg, 0);
+		printf("master->master? [%10s]\n", ptr);
+		if (recvmsg(sd[0], &msg, 0) < 0)
+			perror("master recv 1");
+	} else {
+		struct msghdr msg;
+		struct cmsghdr *cmsg;
+		char* ptr;
+		int fd, recv_fd;
+		char* child_buf[100];
+		/* child */
+		struct iovec count_vec = {
+			.iov_base = child_buf,
+			.iov_len = sizeof child_buf,
+		};
+
+		struct msghdr child_msg = {
+			.msg_control = buf,
+			.msg_controllen = sizeof buf,
+			.msg_iov = &count_vec,
+			.msg_iovlen = 1,
+		};
+
+		if (recvmsg(sd[1], &child_msg, 0) < 0)
+			perror("child recv msg 1");
+		cmsg = CMSG_FIRSTHDR(&child_msg);
+		if (cmsg == NULL) {
+			printf("no cmsg rcvd in child");
+			return;
+		}
+		recv_fd = *(int*)CMSG_DATA(cmsg);
+		if (recv_fd < 0) {
+			printf("could not get recv_fd from socket");
+			return;
+		}
+		printf("child %d\n", recv_fd);
+		fd = ion_open();
+		ptr = mmap(NULL, len, prot, map_flags, recv_fd, 0);
+		if (ptr == MAP_FAILED) {
+			return;
+		}
+		printf("child? [%10s] should be [master]\n", ptr);
+		strcpy(ptr, "child");
+		printf("child sending msg 2\n");
+		sendmsg(sd[1], &child_msg, 0);
+	}
+}
+
+int main(int argc, char* argv[]) {
+	int c;
+	enum tests {
+		ALLOC_TEST = 0, MAP_TEST, SHARE_TEST,
+	};
+
+	while (1) {
+		static struct option opts[] = {
+			{"alloc", no_argument, 0, 'a'},
+			{"alloc_flags", required_argument, 0, 'f'},
+			{"heap_mask", required_argument, 0, 'h'},
+			{"map", no_argument, 0, 'm'},
+			{"share", no_argument, 0, 's'},
+			{"len", required_argument, 0, 'l'},
+			{"align", required_argument, 0, 'g'},
+			{"map_flags", required_argument, 0, 'z'},
+			{"prot", required_argument, 0, 'p'},
+			{"alloc_tiler", no_argument, 0, 't'},
+			{"width", required_argument, 0, 'w'},
+			{"height", required_argument, 0, 'h'},
+			{"fmt", required_argument, 0, 'r'},
+		};
+		int i = 0;
+		c = getopt_long(argc, argv, "af:h:l:mr:st", opts, &i);
+		if (c == -1)
+			break;
+
+		switch (c) {
+		case 'l':
+			len = atol(optarg);
+			break;
+		case 'g':
+			align = atol(optarg);
+			break;
+		case 'z':
+			map_flags = 0;
+			map_flags |= strstr(optarg, "PROT_EXEC") ?
+				PROT_EXEC : 0;
+			map_flags |= strstr(optarg, "PROT_READ") ?
+				PROT_READ: 0;
+			map_flags |= strstr(optarg, "PROT_WRITE") ?
+				PROT_WRITE: 0;
+			map_flags |= strstr(optarg, "PROT_NONE") ?
+				PROT_NONE: 0;
+			break;
+		case 'p':
+			prot = 0;
+			prot |= strstr(optarg, "MAP_PRIVATE") ?
+				MAP_PRIVATE	 : 0;
+			prot |= strstr(optarg, "MAP_SHARED") ?
+				MAP_PRIVATE	 : 0;
+			break;
+		case 'f':
+			alloc_flags = atol(optarg);
+			break;
+		case 'a':
+			test = ALLOC_TEST;
+			break;
+		case 'm':
+			test = MAP_TEST;
+			break;
+		case 'r':
+			fmt = atol(optarg);
+			break;
+		case 's':
+			test = SHARE_TEST;
+			break;
+		case 'w':
+			width = atol(optarg);
+			break;
+		case 'h':
+			height = atol(optarg);
+			break;
+		case 't':
+			tiler_test = 1;
+			break;
+		}
+	}
+	printf("test %d, len %u, width %u, height %u fmt %u align %u, "
+		   "map_flags %d, prot %d, alloc_flags %d\n", test, len, width,
+		   height, fmt, align, map_flags, prot, alloc_flags);
+	switch (test) {
+		case ALLOC_TEST:
+			ion_alloc_test();
+			break;
+		case MAP_TEST:
+			ion_map_test();
+			break;
+		case SHARE_TEST:
+			ion_share_test();
+			break;
+		default:
+			printf("must specify a test (alloc, map, share)\n");
+	}
+	return 0;
+}
diff --git a/ion/ion_test_2.c b/ion/ion_test_2.c
new file mode 100644
index 0000000..9d7ae46
--- /dev/null
+++ b/ion/ion_test_2.c
@@ -0,0 +1,481 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * 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.
+ */
+
+/*
+ * Test case to test ION Memory Allocator module
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <ion/ion.h>
+#include <linux/ion.h>
+#include <linux/omap_ion.h>
+
+size_t len = 1024*1024, align = 0;
+int prot = PROT_READ | PROT_WRITE;
+int map_flags = MAP_SHARED;
+int alloc_flags = 0;
+int test = -1;
+size_t width = 1024*1024, height = 1024*1024;
+int fmt = TILER_PIXEL_FMT_32BIT;
+int tiler_test = 0;
+size_t stride;
+
+int _ion_alloc_test(int fd, struct ion_handle **handle)
+{
+	int ret;
+
+	if (tiler_test)
+		ret = ion_alloc_tiler(fd, width, height, fmt, alloc_flags,
+					  handle, &stride);
+	else
+		ret = ion_alloc(fd, len, align, alloc_flags, handle);
+
+	if (ret)
+		printf("%s() failed: %s\n", __func__, strerror(ret));
+	return ret;
+}
+
+int ion_alloc_test(int count)
+{
+	int fd, ret = 0, i, count_alloc;
+	struct ion_handle **handle;
+
+	fd = ion_open();
+	if (fd < 0) {
+		printf("%s(): FAILED to open ion device\n",	__func__);
+		return -1;
+	}
+
+	handle = (struct ion_handle **)malloc(count * sizeof(struct ion_handle *));
+	if(handle == NULL) {
+		printf("%s() : FAILED to allocate memory for ion_handles\n", __func__);
+		return -ENOMEM;
+	}
+
+	/* Allocate ion_handles */
+	count_alloc = count;
+	for(i = 0; i < count; i++) {
+		ret = _ion_alloc_test(fd, &(handle[i]));
+		printf("%s(): Alloc handle[%d]=%p\n", __func__, i, handle[i]);
+		if(ret || ((int)handle[i]  == -ENOMEM)) {
+			printf("%s(): Alloc handle[%d]=%p FAILED, err:%s\n",
+					__func__, i, handle[i], strerror(ret));
+			count_alloc = i;
+			goto err_alloc;
+		}
+	}
+
+	err_alloc:
+	/* Free ion_handles */
+	for (i = 0; i < count_alloc; i++) {
+		printf("%s(): Free  handle[%d]=%p\n", __func__, i, handle[i]);
+		ret = ion_free(fd, handle[i]);
+		if (ret) {
+			printf("%s(): Free handle[%d]=%p FAILED, err:%s\n",
+					__func__, i, handle[i], strerror(ret));
+		}
+	}
+
+	ion_close(fd);
+	free(handle);
+	handle = NULL;
+
+	if(ret || (count_alloc != count)) {
+		printf("\nion alloc test: FAILED\n\n");
+		if(count_alloc != count)
+			ret = -ENOMEM;
+	}
+	else
+		printf("\nion alloc test: PASSED\n\n");
+
+	return ret;
+}
+
+void _ion_tiler_map_test(unsigned char *ptr)
+{
+	size_t row, col;
+
+	for (row = 0; row < height; row++)
+		for (col = 0; col < width; col++) {
+			int i = (row * stride) + col;
+			ptr[i] = (unsigned char)i;
+		}
+	for (row = 0; row < height; row++)
+		for (col = 0; col < width; col++) {
+			int i = (row * stride) + col;
+			if (ptr[i] != (unsigned char)i)
+				printf("%s(): FAILED, wrote %d read %d from mapped "
+					   "memory\n", __func__, i, ptr[i]);
+		}
+}
+
+void _ion_map_test(unsigned char *ptr)
+{
+	size_t i;
+
+	for (i = 0; i < len; i++) {
+		ptr[i] = (unsigned char)i;
+	}
+	for (i = 0; i < len; i++) {
+		if (ptr[i] != (unsigned char)i)
+			printf("%s(): failed wrote %d read %d from mapped "
+				   "memory\n", __func__, i, ptr[i]);
+	}
+}
+
+int ion_map_test(int count)
+{
+	int fd, ret = 0, i, count_alloc, count_map;
+	struct ion_handle **handle;
+	unsigned char **ptr;
+	int *map_fd;
+
+	fd = ion_open();
+	if (fd < 0) {
+		printf("%s(): FAILED to open ion device\n",	__func__);
+		return -1;
+	}
+
+	handle = (struct ion_handle **)malloc(count * sizeof(struct ion_handle *));
+	if(handle == NULL) {
+		printf("%s(): FAILED to allocate memory for ion_handles\n", __func__);
+		return -ENOMEM;
+	}
+
+	count_alloc = count;
+	count_map = count;
+
+	/* Allocate ion_handles */
+	for(i = 0; i < count; i++) {
+		ret = _ion_alloc_test(fd, &(handle[i]));
+		printf("%s(): Alloc handle[%d]=%p\n", __func__, i, handle[i]);
+		if(ret || ((int)handle[i]  == -ENOMEM)) {
+			printf("%s(): Alloc handle[%d]=%p FAILED, err:%s\n",
+					__func__, i, handle[i], strerror(ret));
+			count_alloc = i;
+			goto err_alloc;
+		}
+	}
+
+	/* Map ion_handles and validate */
+	if (tiler_test)
+		len = height * stride;
+
+	ptr = (unsigned char **)malloc(count * sizeof(unsigned char **));
+	map_fd = (int *)malloc(count * sizeof(int *));
+
+	for(i = 0; i < count; i++) {
+		/* Map ion_handle on userside */
+		ret = ion_map(fd, handle[i], len, prot, map_flags, 0, &(ptr[i]), &(map_fd[i]));
+		printf("%s(): Map handle[%d]=%p, map_fd=%d, ptr=%p\n",
+				__func__, i, handle[i], map_fd[i], ptr[i]);
+		if(ret) {
+			printf("%s Map handle[%d]=%p FAILED, err:%s\n",
+					__func__, i, handle[i], strerror(ret));
+			count_map = i;
+			goto err_map;
+		}
+
+		/* Validate mapping by writing the data and reading it back */
+		if (tiler_test)
+			_ion_tiler_map_test(ptr[i]);
+		else
+			_ion_map_test(ptr[i]);
+	}
+
+	/* clean up properly */
+	err_map:
+	for(i = 0; i < count_map; i++) {
+		/* Unmap ion_handles */
+		ret = munmap(ptr[i], len);
+		printf("%s(): Unmap handle[%d]=%p, map_fd=%d, ptr=%p\n",
+				__func__, i, handle[i], map_fd[i], ptr[i]);
+		if(ret) {
+			printf("%s(): Unmap handle[%d]=%p FAILED, err:%s\n",
+					__func__, i, handle[i], strerror(ret));
+			goto err_map;
+		}
+		/* Close fds */
+		close(map_fd[i]);
+	}
+	free(map_fd);
+	free(ptr);
+
+	err_alloc:
+	/* Free ion_handles */
+	for (i = 0; i < count_alloc; i++) {
+		printf("%s(): Free handle[%d]=%p\n", __func__, i, handle[i]);
+		ret = ion_free(fd, handle[i]);
+		if (ret) {
+			printf("%s(): Free handle[%d]=%p FAILED, err:%s\n",
+					__func__, i, handle[i], strerror(ret));
+		}
+	}
+
+	ion_close(fd);
+	free(handle);
+	handle = NULL;
+
+	if(ret || (count_alloc != count) || (count_map != count))
+	{
+		printf("\nion map test: FAILED\n\n");
+		if((count_alloc != count) || (count_map != count))
+			ret = -ENOMEM;
+	}	else
+		printf("\nion map test: PASSED\n");
+
+	return ret;
+}
+
+/**
+ * Go on allocating buffers of specified size & type, untill the allocation fails.
+ * Then free 10 buffers and allocate 10 buffers again.
+ */
+int ion_alloc_fail_alloc_test()
+{
+	int fd, ret = 0, i;
+	struct ion_handle **handle;
+	const int  COUNT_ALLOC_MAX = 200;
+	const int  COUNT_REALLOC_MAX = 10;
+	int count_alloc = COUNT_ALLOC_MAX, count_realloc = COUNT_ALLOC_MAX;
+
+	fd = ion_open();
+	if (fd < 0) {
+		printf("%s(): FAILED to open ion device\n", __func__);
+		return -1;
+	}
+
+	handle = (struct ion_handle **)malloc(COUNT_ALLOC_MAX * sizeof(struct ion_handle *));
+	if(handle == NULL) {
+		printf("%s(): FAILED to allocate memory for ion_handles\n", __func__);
+		return -ENOMEM;
+	}
+
+	/* Allocate ion_handles as much as possible */
+	for(i = 0; i < COUNT_ALLOC_MAX; i++) {
+		ret = _ion_alloc_test(fd, &(handle[i]));
+		printf("%s(): Alloc handle[%d]=%p\n", __func__, i, handle[i]);
+		if(ret || ((int)handle[i]  == -ENOMEM)) {
+			printf("%s(): Alloc handle[%d]=%p FAILED, err:%s\n\n",
+					__func__, i, handle[i], strerror(ret));
+			count_alloc = i;
+			break;
+		}
+	}
+
+	/* Free COUNT_REALLOC_MAX ion_handles */
+	for (i = count_alloc-1; i > (count_alloc-1 - COUNT_REALLOC_MAX); i--) {
+		printf("%s(): Free  handle[%d]=%p\n", __func__, i, handle[i]);
+		ret = ion_free(fd, handle[i]);
+		if (ret) {
+			printf("%s(): Free  handle[%d]=%p FAILED, err:%s\n\n",
+					__func__, i, handle[i], strerror(ret));
+		}
+	}
+
+	/* Again allocate COUNT_REALLOC_MAX ion_handles to test
+	   that we are still able to allocate */
+	for(i = (count_alloc - COUNT_REALLOC_MAX); i < count_alloc; i++) {
+		ret = _ion_alloc_test(fd, &(handle[i]));
+		printf("%s(): Alloc handle[%d]=%p\n", __func__, i, handle[i]);
+		if(ret || ((int)handle[i]  == -ENOMEM)) {
+			printf("%s(): Alloc handle[%d]=%p FAILED, err:%s\n\n",
+					__func__, i, handle[i], strerror(ret));
+			count_realloc = i;
+			goto err_alloc;
+		}
+	}
+	count_realloc = i;
+
+	err_alloc:
+	/* Free all ion_handles */
+	for (i = 0; i < count_alloc; i++) {
+		printf("%s(): Free  handle[%d]=%p\n", __func__, i, handle[i]);
+		ret = ion_free(fd, handle[i]);
+		if (ret) {
+			printf("%s(): Free  handle[%d]=%p FAILED, err:%s\n",
+					__func__, i, handle[i], strerror(ret));
+		}
+	}
+
+	ion_close(fd);
+	free(handle);
+	handle = NULL;
+
+	printf("\ncount_alloc=%d, count_realloc=%d\n",count_alloc, count_realloc);
+
+	if(ret || (count_alloc != count_realloc)) {
+		printf("\nion alloc->fail->alloc test: FAILED\n\n");
+		if(count_alloc != COUNT_ALLOC_MAX)
+			ret = -ENOMEM;
+	}
+	else
+		printf("\nion alloc->fail->alloc test: PASSED\n\n");
+
+	return ret;
+}
+
+int custom_test(int test_number)
+{
+	switch(test_number) {
+		case 1 :
+			return ion_alloc_fail_alloc_test();
+		default :
+			printf("%s(): Invalid custom_test_number=%d\n", __func__, test_number);
+			return -EINVAL;
+	}
+}
+
+int main(int argc, char* argv[]) {
+	int c, ret;
+	unsigned int count = 1, iteration = 1, j, custom_test_num = 1;
+	enum tests {
+		ALLOC_TEST = 0, MAP_TEST, CUSTOM_TEST,
+	};
+
+	while (1) {
+		static struct option opts[] = {
+			{"alloc", no_argument, 0, 'a'},
+			{"alloc_flags", required_argument, 0, 'f'},
+			{"map", no_argument, 0, 'm'},
+			{"custom", required_argument, 0, 'c'},
+			{"len", required_argument, 0, 'l'},
+			{"align", required_argument, 0, 'g'},
+			{"map_flags", required_argument, 0, 'z'},
+			{"prot", required_argument, 0, 'p'},
+			{"alloc_tiler", no_argument, 0, 't'},
+			{"width", required_argument, 0, 'w'},
+			{"height", required_argument, 0, 'h'},
+			{"fmt", required_argument, 0, 'r'},
+			{"count", required_argument, 0, 'n'},
+			{"iteration", required_argument, 0, 'i'},
+		};
+		int i = 0;
+		c = getopt_long(argc, argv, "af:h:l:mr:stw:c:n:i:", opts, &i);
+		if (c == -1)
+			break;
+
+		switch (c) {
+		case 'l':
+			len = atol(optarg);
+			break;
+		case 'g':
+			align = atol(optarg);
+			break;
+		case 'z':
+			map_flags = 0;
+			map_flags |= strstr(optarg, "PROT_EXEC") ?
+				PROT_EXEC : 0;
+			map_flags |= strstr(optarg, "PROT_READ") ?
+				PROT_READ: 0;
+			map_flags |= strstr(optarg, "PROT_WRITE") ?
+				PROT_WRITE: 0;
+			map_flags |= strstr(optarg, "PROT_NONE") ?
+				PROT_NONE: 0;
+			break;
+		case 'p':
+			prot = 0;
+			prot |= strstr(optarg, "MAP_PRIVATE") ?
+				MAP_PRIVATE	 : 0;
+			prot |= strstr(optarg, "MAP_SHARED") ?
+				MAP_PRIVATE	 : 0;
+			break;
+		case 'f':
+			alloc_flags = atol(optarg);
+			break;
+		case 'a':
+			test = ALLOC_TEST;
+			break;
+		case 'm':
+			test = MAP_TEST;
+			break;
+		case 'c':
+			test = CUSTOM_TEST;
+			printf("KALP : Case 'c'\n");
+			custom_test_num = atol(optarg);
+			break;
+		case 'r':
+			fmt = atol(optarg);
+			break;
+		case 'w':
+			width = atol(optarg);
+			break;
+		case 'h':
+			height = atol(optarg);
+			break;
+		case 't':
+			tiler_test = 1;
+			break;
+		case 'n':
+			printf("KALP : Case 'n'\n");
+			count = atol(optarg);
+			break;
+		case 'i':
+			printf("KALP : Case 'i'\n");
+			iteration = atol(optarg);
+			break;
+		}
+	}
+	printf("test %d, len %u, width %u, height %u, fmt %u, align %u, count %d, "
+		   "iteration %d, map_flags %d, prot %d, alloc_flags %d\n", test, len, width,
+		   height, fmt, align, count, iteration, map_flags, prot, alloc_flags);
+
+	switch (test) {
+		case ALLOC_TEST:
+			for(j = 0; j < iteration; j++) {
+				ret = ion_alloc_test(count);
+				if(ret) {
+					printf("\nion alloc test: FAILED at iteration-%d\n", j+1);
+					break;
+				}
+			}
+			break;
+
+		case MAP_TEST:
+			for(j = 0; j < iteration; j++) {
+				ret = ion_map_test(count);
+				if(ret) {
+					printf("\nion map test: FAILED at iteration-%d\n", j+1);
+					break;
+				}
+			}
+			break;
+
+		case CUSTOM_TEST:
+			ret = custom_test(custom_test_num);
+			if(ret) {
+				printf("\nion custom test #%d: FAILED\n", custom_test_num);
+			}
+			break;
+
+		default:
+			printf("must specify a test (alloc, map, custom)\n");
+	}
+
+	return 0;
+}