1 /*
2 * Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
3
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 * * Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above
10 * copyright notice, this list of conditions and the following
11 * disclaimer in the documentation and/or other materials provided
12 * with the distribution.
13 * * Neither the name of The Linux Foundation nor the names of its
14 * contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
24 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
26 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #define DEBUG 0
31 #include <linux/ioctl.h>
32 #include <sys/mman.h>
33 #include <stdlib.h>
34 #include <fcntl.h>
35 #include <cutils/log.h>
36 #include <errno.h>
37 #include "gralloc_priv.h"
38 #include "ionalloc.h"
39
40 using gralloc::IonAlloc;
41
42 #define ION_DEVICE "/dev/ion"
43
open_device()44 int IonAlloc::open_device()
45 {
46 if(mIonFd == FD_INIT)
47 mIonFd = open(ION_DEVICE, O_RDONLY);
48
49 if(mIonFd < 0 ) {
50 ALOGE("%s: Failed to open ion device - %s",
51 __FUNCTION__, strerror(errno));
52 mIonFd = FD_INIT;
53 return -errno;
54 }
55 return 0;
56 }
57
close_device()58 void IonAlloc::close_device()
59 {
60 if(mIonFd >= 0)
61 close(mIonFd);
62 mIonFd = FD_INIT;
63 }
64
alloc_buffer(alloc_data & data)65 int IonAlloc::alloc_buffer(alloc_data& data)
66 {
67 Locker::Autolock _l(mLock);
68 int err = 0;
69 struct ion_handle_data handle_data;
70 struct ion_fd_data fd_data;
71 struct ion_allocation_data ionAllocData;
72 void *base = 0;
73
74 ionAllocData.len = data.size;
75 ionAllocData.align = data.align;
76 ionAllocData.heap_id_mask = data.flags & ~ION_SECURE;
77 ionAllocData.flags = data.uncached ? 0 : ION_FLAG_CACHED;
78 // ToDo: replace usage of alloc data structure with
79 // ionallocdata structure.
80 if (data.flags & ION_SECURE)
81 ionAllocData.flags |= ION_SECURE;
82
83 err = open_device();
84 if (err)
85 return err;
86 if(ioctl(mIonFd, ION_IOC_ALLOC, &ionAllocData)) {
87 err = -errno;
88 ALOGE("ION_IOC_ALLOC failed with error - %s", strerror(errno));
89 return err;
90 }
91
92 fd_data.handle = ionAllocData.handle;
93 handle_data.handle = ionAllocData.handle;
94 if(ioctl(mIonFd, ION_IOC_MAP, &fd_data)) {
95 err = -errno;
96 ALOGE("%s: ION_IOC_MAP failed with error - %s",
97 __FUNCTION__, strerror(errno));
98 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
99 return err;
100 }
101
102 if(!(data.flags & ION_SECURE)) {
103 base = mmap(0, ionAllocData.len, PROT_READ|PROT_WRITE,
104 MAP_SHARED, fd_data.fd, 0);
105 if(base == MAP_FAILED) {
106 err = -errno;
107 ALOGE("%s: Failed to map the allocated memory: %s",
108 __FUNCTION__, strerror(errno));
109 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
110 return err;
111 }
112 memset(base, 0, ionAllocData.len);
113 // Clean cache after memset
114 clean_buffer(base, data.size, data.offset, fd_data.fd,
115 CACHE_CLEAN_AND_INVALIDATE);
116 }
117
118 data.base = base;
119 data.fd = fd_data.fd;
120 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
121 ALOGD_IF(DEBUG, "ion: Allocated buffer base:%p size:%d fd:%d",
122 data.base, ionAllocData.len, data.fd);
123 return 0;
124 }
125
126
free_buffer(void * base,size_t size,int offset,int fd)127 int IonAlloc::free_buffer(void* base, size_t size, int offset, int fd)
128 {
129 Locker::Autolock _l(mLock);
130 ALOGD_IF(DEBUG, "ion: Freeing buffer base:%p size:%d fd:%d",
131 base, size, fd);
132 int err = 0;
133 err = open_device();
134 if (err)
135 return err;
136
137 if(base)
138 err = unmap_buffer(base, size, offset);
139 close(fd);
140 return err;
141 }
142
map_buffer(void ** pBase,size_t size,int offset,int fd)143 int IonAlloc::map_buffer(void **pBase, size_t size, int offset, int fd)
144 {
145 int err = 0;
146 void *base = 0;
147 // It is a (quirky) requirement of ION to have opened the
148 // ion fd in the process that is doing the mapping
149 err = open_device();
150 if (err)
151 return err;
152
153 base = mmap(0, size, PROT_READ| PROT_WRITE,
154 MAP_SHARED, fd, 0);
155 *pBase = base;
156 if(base == MAP_FAILED) {
157 err = -errno;
158 ALOGE("ion: Failed to map memory in the client: %s",
159 strerror(errno));
160 } else {
161 ALOGD_IF(DEBUG, "ion: Mapped buffer base:%p size:%d offset:%d fd:%d",
162 base, size, offset, fd);
163 }
164 return err;
165 }
166
unmap_buffer(void * base,size_t size,int offset)167 int IonAlloc::unmap_buffer(void *base, size_t size, int offset)
168 {
169 ALOGD_IF(DEBUG, "ion: Unmapping buffer base:%p size:%d", base, size);
170 int err = 0;
171 if(munmap(base, size)) {
172 err = -errno;
173 ALOGE("ion: Failed to unmap memory at %p : %s",
174 base, strerror(errno));
175 }
176 return err;
177
178 }
clean_buffer(void * base,size_t size,int offset,int fd,int op)179 int IonAlloc::clean_buffer(void *base, size_t size, int offset, int fd, int op)
180 {
181 struct ion_flush_data flush_data;
182 struct ion_fd_data fd_data;
183 struct ion_handle_data handle_data;
184 int err = 0;
185
186 err = open_device();
187 if (err)
188 return err;
189
190 fd_data.fd = fd;
191 if (ioctl(mIonFd, ION_IOC_IMPORT, &fd_data)) {
192 err = -errno;
193 ALOGE("%s: ION_IOC_IMPORT failed with error - %s",
194 __FUNCTION__, strerror(errno));
195 return err;
196 }
197
198 handle_data.handle = fd_data.handle;
199 flush_data.handle = fd_data.handle;
200 flush_data.vaddr = base;
201 flush_data.offset = offset;
202 flush_data.length = size;
203
204 struct ion_custom_data d;
205 switch(op) {
206 case CACHE_CLEAN:
207 d.cmd = ION_IOC_CLEAN_CACHES;
208 break;
209 case CACHE_INVALIDATE:
210 d.cmd = ION_IOC_INV_CACHES;
211 break;
212 case CACHE_CLEAN_AND_INVALIDATE:
213 default:
214 d.cmd = ION_IOC_CLEAN_INV_CACHES;
215 }
216
217 d.arg = (unsigned long int)&flush_data;
218
219 if(ioctl(mIonFd, ION_IOC_CUSTOM, &d)) {
220 err = -errno;
221 ALOGE("%s: ION_IOC_CLEAN_INV_CACHES failed with error - %s",
222
223 __FUNCTION__, strerror(errno));
224 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
225 return err;
226 }
227 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
228 return 0;
229 }
230
231