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;
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;
*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_sync_fd(int fd, int handle_fd)
{
struct ion_fd_data data = {
.fd = handle_fd,
};
return ion_ioctl(fd, ION_IOC_SYNC, &data);
}
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_sync_fd(int fd, int handle_fd)
{
#ifdef OLD_ION_API
return 0;
#else
struct ion_fd_data data = {
.fd = handle_fd,
};
return ion_ioctl(fd, ION_IOC_SYNC, &data);
#endif
}
int ion_phys(int fd, ion_user_handle_t handle, unsigned long *phys)
{
int ret;
struct owl_ion_phys_data phys_data = {
.handle = handle,
};
struct ion_custom_data data = {
.cmd = OWL_ION_GET_PHY,
.arg = (unsigned long)&phys_data,
};
ret = ion_ioctl(fd, ION_IOC_CUSTOM, &data);
if (ret < 0)
return ret;
*phys = phys_data.phys_addr;
return ret;
}
#endif
int ion_count = 0;
/*利用ion分配内存，成功返回0*/
int sys_mem_allocate(unsigned int size, void **vir_addr, ion_user_handle_t * p_ion_handle)
{
int ret;
if (!ion_count)
{
ion_fd = ion_open();
if(ion_fd < 0){
printf("ion_open failed\n");
return -1;
}
printf("ion_open ok ion_fd = %d \n",ion_fd);
}
ret = ion_alloc(ion_fd, size, 0, 1,0, &ion_handle_t);
if(ret)
{
printf("%s failed: %s\n", __func__, strerror(ret));
return -1;
}
*p_ion_handle = ion_handle_t;
ret = ion_map(ion_fd, ion_handle_t, size, PROT_READ | PROT_WRITE, MAP_SHARED, 0, (unsigned char **)vir_addr, &ion_map_fd);
if (ret){
printf("ion_map error \n");
return -1 ;
}
printf("ion_map ok \n");
ion_count++;
return 0;
}
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_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_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;
if (!ion_is_legacy(fd)) {
struct ion_new_allocation_data data = {
.len = len,
.heap_id_mask = heap_mask,
.flags = flags,
};
ret = ion_ioctl(fd, ION_IOC_NEW_ALLOC, &data);
if (ret < 0) return ret;
*handle_fd = data.fd;
} else {
int ion_share(int fd, ion_user_handle_t 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) {
LOGE("map ioctl returned negative fd\n");
return -EINVAL;
}
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 = 0;
if ((handle == NULL) || (!ion_is_legacy(fd))) return -EINVAL;
struct ion_allocation_data data = {
.len = len, .align = align, .heap_id_mask = heap_mask, .flags = flags,
};
ret = ion_ioctl(fd, ION_IOC_ALLOC, &data);
if (ret < 0) return ret;
*handle = data.handle;
return ret;
}
int ion_alloc(int fd, size_t len, size_t align, unsigned int flags,
ion_user_handle_t *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;
printf("ion_alloc ok data.handle = %p \n",data.handle);
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 (!ion_is_legacy(fd)) return -EINVAL;
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");
return -EINVAL;
}
*share_fd = data.fd;
return ret;
}
int ion_alloc(int fd, size_t len, size_t align, unsigned int heap_mask,
unsigned int flags, struct ion_user_handle_t *handle)
{
int ret;
struct ion_allocation_data data = {
.len = len,
.align = align,
#ifndef OLD_ION_API
.heap_id_mask = heap_mask,
#endif
.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,
};
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) {
LOGE("map ioctl returned negative fd\n");
return -EINVAL;
}
*ptr = mmap(NULL, length, prot, flags, *map_fd, offset);
if (*ptr == MAP_FAILED) {
LOGE("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) {
LOGE("map ioctl returned negative fd\n");
return -EINVAL;
}
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);
}
