From 222b794ae146b4e0d61958c55a518396e293e6d7 Mon Sep 17 00:00:00 2001 From: codeworkx Date: Mon, 11 Feb 2013 17:29:55 +0000 Subject: initial commit sources from http://omapzoom.org --- libion_ti/Android.mk | 23 +++ libion_ti/ion.c | 201 +++++++++++++++++++++ libion_ti/ion.h | 49 +++++ libion_ti/ion_test.c | 319 ++++++++++++++++++++++++++++++++ libion_ti/ion_test_2.c | 479 +++++++++++++++++++++++++++++++++++++++++++++++++ libion_ti/linux_ion.h | 76 ++++++++ libion_ti/omap_ion.h | 61 +++++++ 7 files changed, 1208 insertions(+) create mode 100644 libion_ti/Android.mk create mode 100644 libion_ti/ion.c create mode 100644 libion_ti/ion.h create mode 100644 libion_ti/ion_test.c create mode 100644 libion_ti/ion_test_2.c create mode 100644 libion_ti/linux_ion.h create mode 100644 libion_ti/omap_ion.h (limited to 'libion_ti') diff --git a/libion_ti/Android.mk b/libion_ti/Android.mk new file mode 100644 index 0000000..032408d --- /dev/null +++ b/libion_ti/Android.mk @@ -0,0 +1,23 @@ +LOCAL_PATH:= $(call my-dir) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := ion.c +LOCAL_MODULE := libion_ti +LOCAL_MODULE_TAGS := optional +LOCAL_SHARED_LIBRARIES := liblog +include $(BUILD_SHARED_LIBRARY) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := ion.c ion_test.c +LOCAL_MODULE := ion_ti_test +LOCAL_MODULE_TAGS := optional tests +LOCAL_SHARED_LIBRARIES := liblog +include $(BUILD_EXECUTABLE) + +include $(CLEAR_VARS) +LOCAL_SRC_FILES := ion.c ion_test_2.c +LOCAL_MODULE := ion_ti_test2 +LOCAL_MODULE_TAGS := optional tests +LOCAL_SHARED_LIBRARIES := liblog +include $(BUILD_EXECUTABLE) + diff --git a/libion_ti/ion.c b/libion_ti/ion.c new file mode 100644 index 0000000..01459ab --- /dev/null +++ b/libion_ti/ion.c @@ -0,0 +1,201 @@ +/* + * 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. + */ +#include +#include +#include +#include +#include +#include + +#define LOG_TAG "ion" +#include + +#include "ion.h" + +int ion_open() +{ + int fd = open("/dev/ion", O_RDWR); + if (fd < 0) + ALOGE("open /dev/ion failed!\n"); + return fd; +} + +int ion_close(int fd) +{ + return close(fd); +} + +static int ion_ioctl(int fd, int req, void *arg) +{ + int ret = ioctl(fd, req, arg); + if (ret < 0) { + ALOGE("ioctl %d 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 flags, + struct ion_handle **handle) +{ + int ret; + struct ion_allocation_data data = { + .len = len, + .align = align, + .flags = flags, + }; + + ret = ion_ioctl(fd, ION_IOC_ALLOC, &data); + if (ret < 0) + return ret; + *handle = data.handle; + return ret; +} + +int ion_alloc_tiler(int fd, size_t w, size_t h, int fmt, unsigned int flags, + struct ion_handle **handle, size_t *stride) +{ + int ret; + struct omap_ion_tiler_alloc_data alloc_data = { + .w = w, + .h = h, + .fmt = fmt, + .flags = flags, + .out_align = PAGE_SIZE, + .token = 0, + }; + + struct ion_custom_data custom_data = { + .cmd = OMAP_ION_TILER_ALLOC, + .arg = (unsigned long)(&alloc_data), + }; + + ret = ion_ioctl(fd, ION_IOC_CUSTOM, &custom_data); + if (ret < 0) + return ret; + *stride = alloc_data.stride; + *handle = alloc_data.handle; + return ret; +} + +int ion_free(int fd, struct ion_handle *handle) +{ + struct ion_handle_data data = { + .handle = handle, + }; + return ion_ioctl(fd, ION_IOC_FREE, &data); +} + +int ion_map(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, + }; + 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_share(int fd, struct ion_handle *handle, int *share_fd) +{ + int map_fd; + struct ion_fd_data data = { + .handle = handle, + }; + int ret = ion_ioctl(fd, ION_IOC_SHARE, &data); + if (ret < 0) + return ret; + *share_fd = data.fd; + if (*share_fd < 0) { + ALOGE("map ioctl returned negative fd\n"); + return -EINVAL; + } + return ret; +} + +int ion_import(int fd, int share_fd, struct ion_handle **handle) +{ + struct ion_fd_data data = { + .fd = share_fd, + }; + int ret = ion_ioctl(fd, ION_IOC_IMPORT, &data); + if (ret < 0) + return ret; + *handle = data.handle; + return ret; +} + +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/libion_ti/ion.h b/libion_ti/ion.h new file mode 100644 index 0000000..05fe1ec --- /dev/null +++ b/libion_ti/ion.h @@ -0,0 +1,49 @@ +/* + * 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. + */ + +#ifndef __TI_ION_H +#define __TI_ION_H + +#include "linux_ion.h" +#include "omap_ion.h" + +__BEGIN_DECLS + +int ion_open(); +int ion_close(int fd); +int ion_alloc(int fd, size_t len, size_t align, unsigned int flags, + struct ion_handle **handle); +int ion_alloc_tiler(int fd, size_t w, size_t h, int fmt, unsigned int flags, + struct ion_handle **handle, size_t *stride); +int ion_free(int fd, struct ion_handle *handle); +int ion_map(int fd, struct ion_handle *handle, size_t length, int prot, + int flags, off_t offset, unsigned char **ptr, int *map_fd); +int ion_share(int fd, struct ion_handle *handle, int *share_fd); +int ion_import(int fd, int share_fd, struct ion_handle **handle); +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); +int ion_flush_cached(int fd, struct ion_handle *handle, size_t length, + unsigned char *ptr); +int ion_inval_cached(int fd, struct ion_handle *handle, size_t length, + unsigned char *ptr); + +__END_DECLS + +#endif /* __TI_ION_H */ diff --git a/libion_ti/ion_test.c b/libion_ti/ion_test.c new file mode 100644 index 0000000..ae7dead --- /dev/null +++ b/libion_ti/ion_test.c @@ -0,0 +1,319 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "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; + + *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'}, + {"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:stw:", 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/libion_ti/ion_test_2.c b/libion_ti/ion_test_2.c new file mode 100644 index 0000000..5c19102 --- /dev/null +++ b/libion_ti/ion_test_2.c @@ -0,0 +1,479 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "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; +} diff --git a/libion_ti/linux_ion.h b/libion_ti/linux_ion.h new file mode 100644 index 0000000..300853a --- /dev/null +++ b/libion_ti/linux_ion.h @@ -0,0 +1,76 @@ +/**************************************************************************** + **************************************************************************** + *** + *** This header was automatically generated from a Linux kernel header + *** of the same name, to make information necessary for userspace to + *** call into the kernel available to libc. It contains only constants, + *** structures, and macros generated from the original header, and thus, + *** contains no copyrightable information. + *** + *** To edit the content of this header, modify the corresponding + *** source file (e.g. under external/kernel-headers/original/) then + *** run bionic/libc/kernel/tools/update_all.py + *** + *** Any manual change here will be lost the next time this script will + *** be run. You've been warned! + *** + **************************************************************************** + ****************************************************************************/ +#ifndef _LINUX_ION_H +#define _LINUX_ION_H +#include +struct ion_handle; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +enum ion_heap_type { + ION_HEAP_TYPE_SYSTEM, + ION_HEAP_TYPE_SYSTEM_CONTIG, + ION_HEAP_TYPE_CARVEOUT, +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + ION_HEAP_TYPE_CUSTOM, + ION_NUM_HEAPS, +}; +#define ION_HEAP_SYSTEM_MASK (1 << ION_HEAP_TYPE_SYSTEM) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define ION_HEAP_SYSTEM_CONTIG_MASK (1 << ION_HEAP_TYPE_SYSTEM_CONTIG) +#define ION_HEAP_CARVEOUT_MASK (1 << ION_HEAP_TYPE_CARVEOUT) +struct ion_allocation_data { + size_t len; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + size_t align; + unsigned int flags; + struct ion_handle *handle; +}; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +struct ion_fd_data { + struct ion_handle *handle; + int fd; + unsigned char cacheable; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +}; +struct ion_handle_data { + struct ion_handle *handle; +}; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +struct ion_custom_data { + unsigned int cmd; + unsigned long arg; +}; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +struct ion_cached_user_buf_data { + struct ion_handle *handle; + unsigned long vaddr; + size_t size; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +}; +#define ION_IOC_MAGIC 'I' +#define ION_IOC_ALLOC _IOWR(ION_IOC_MAGIC, 0, struct ion_allocation_data) +#define ION_IOC_FREE _IOWR(ION_IOC_MAGIC, 1, struct ion_handle_data) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define ION_IOC_MAP _IOWR(ION_IOC_MAGIC, 2, struct ion_fd_data) +#define ION_IOC_SHARE _IOWR(ION_IOC_MAGIC, 4, struct ion_fd_data) +#define ION_IOC_IMPORT _IOWR(ION_IOC_MAGIC, 5, int) +#define ION_IOC_CUSTOM _IOWR(ION_IOC_MAGIC, 6, struct ion_custom_data) +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define ION_IOC_FLUSH_CACHED _IOWR(ION_IOC_MAGIC, 7, struct ion_cached_user_buf_data) +#define ION_IOC_INVAL_CACHED _IOWR(ION_IOC_MAGIC, 8, struct ion_cached_user_buf_data) +#endif diff --git a/libion_ti/omap_ion.h b/libion_ti/omap_ion.h new file mode 100644 index 0000000..b8a6228 --- /dev/null +++ b/libion_ti/omap_ion.h @@ -0,0 +1,61 @@ +/**************************************************************************** + **************************************************************************** + *** + *** This header was automatically generated from a Linux kernel header + *** of the same name, to make information necessary for userspace to + *** call into the kernel available to libc. It contains only constants, + *** structures, and macros generated from the original header, and thus, + *** contains no copyrightable information. + *** + *** To edit the content of this header, modify the corresponding + *** source file (e.g. under external/kernel-headers/original/) then + *** run bionic/libc/kernel/tools/update_all.py + *** + *** Any manual change here will be lost the next time this script will + *** be run. You've been warned! + *** + **************************************************************************** + ****************************************************************************/ +#ifndef _LINUX_OMAP_ION_H +#define _LINUX_OMAP_ION_H +#include +struct omap_ion_tiler_alloc_data { +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + size_t w; + size_t h; + int fmt; + unsigned int flags; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + struct ion_handle *handle; + size_t stride; + size_t offset; + unsigned int out_align; +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + unsigned int token; +}; +enum { + OMAP_ION_HEAP_TYPE_TILER = ION_HEAP_TYPE_CUSTOM + 1, +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +}; +#define OMAP_ION_HEAP_TILER_MASK (1 << OMAP_ION_HEAP_TYPE_TILER) +enum { + OMAP_ION_TILER_ALLOC, +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +}; +enum { + TILER_PIXEL_FMT_MIN = 0, + TILER_PIXEL_FMT_8BIT = 0, +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + TILER_PIXEL_FMT_16BIT = 1, + TILER_PIXEL_FMT_32BIT = 2, + TILER_PIXEL_FMT_PAGE = 3, + TILER_PIXEL_FMT_MAX = 3 +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +}; +enum { + OMAP_ION_HEAP_LARGE_SURFACES, + OMAP_ION_HEAP_TILER, +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ + OMAP_ION_HEAP_SECURE_INPUT, +}; +#endif -- cgit v1.1