1 /*
2 * Copyright (c) 2011-2014, 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 #define ATRACE_TAG (ATRACE_TAG_GRAPHICS | ATRACE_TAG_HAL)
32 #include <sys/ioctl.h>
33 #include <sys/mman.h>
34 #include <stdlib.h>
35 #include <fcntl.h>
36 #include <cutils/log.h>
37 #include <errno.h>
38 #include <utils/Trace.h>
39 #include "gralloc_priv.h"
40 #include "ionalloc.h"
41
42 using gralloc::IonAlloc;
43
44 #define ION_DEVICE "/dev/ion"
45
open_device()46 int IonAlloc::open_device()
47 {
48 if(mIonFd == FD_INIT)
49 mIonFd = open(ION_DEVICE, O_RDONLY);
50
51 if(mIonFd < 0 ) {
52 ALOGE("%s: Failed to open ion device - %s",
53 __FUNCTION__, strerror(errno));
54 mIonFd = FD_INIT;
55 return -errno;
56 }
57 return 0;
58 }
59
close_device()60 void IonAlloc::close_device()
61 {
62 if(mIonFd >= 0)
63 close(mIonFd);
64 mIonFd = FD_INIT;
65 }
66
alloc_buffer(alloc_data & data)67 int IonAlloc::alloc_buffer(alloc_data& data)
68 {
69 ATRACE_CALL();
70 Locker::Autolock _l(mLock);
71 int err = 0;
72 struct ion_handle_data handle_data;
73 struct ion_fd_data fd_data;
74 struct ion_allocation_data ionAllocData;
75 void *base = 0;
76
77 ionAllocData.len = data.size;
78 ionAllocData.align = data.align;
79 ionAllocData.heap_id_mask = data.flags & ~ION_SECURE;
80 #ifdef ION_FLAG_ALLOW_NON_CONTIG
81 ionAllocData.heap_id_mask &= (data.flags & ~ION_FLAG_ALLOW_NON_CONTIG);
82 #endif
83 ionAllocData.flags = data.uncached ? 0 : ION_FLAG_CACHED;
84 // ToDo: replace usage of alloc data structure with
85 // ionallocdata structure.
86 if (data.flags & ION_SECURE)
87 ionAllocData.flags |= ION_SECURE;
88 #ifdef ION_FLAG_ALLOW_NON_CONTIG
89 if (data.flags & ION_FLAG_ALLOW_NON_CONTIG)
90 ionAllocData.flags |= ION_FLAG_ALLOW_NON_CONTIG;
91 #endif
92 err = open_device();
93 if (err)
94 return err;
95 if(ioctl(mIonFd, ION_IOC_ALLOC, &ionAllocData)) {
96 err = -errno;
97 ALOGE("ION_IOC_ALLOC failed with error - %s", strerror(errno));
98 return err;
99 }
100
101 fd_data.handle = ionAllocData.handle;
102 handle_data.handle = ionAllocData.handle;
103 if(ioctl(mIonFd, ION_IOC_MAP, &fd_data)) {
104 err = -errno;
105 ALOGE("%s: ION_IOC_MAP failed with error - %s",
106 __FUNCTION__, strerror(errno));
107 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
108 return err;
109 }
110
111 if(!(data.flags & ION_SECURE)) {
112 base = mmap(0, ionAllocData.len, PROT_READ|PROT_WRITE,
113 MAP_SHARED, fd_data.fd, 0);
114 if(base == MAP_FAILED) {
115 err = -errno;
116 ALOGE("%s: Failed to map the allocated memory: %s",
117 __FUNCTION__, strerror(errno));
118 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
119 return err;
120 }
121 }
122
123 data.base = base;
124 data.fd = fd_data.fd;
125 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
126 ALOGD_IF(DEBUG, "ion: Allocated buffer base:%p size:%zu fd:%d",
127 data.base, ionAllocData.len, data.fd);
128 return 0;
129 }
130
131
free_buffer(void * base,unsigned int size,unsigned int offset,int fd)132 int IonAlloc::free_buffer(void* base, unsigned int size, unsigned int offset,
133 int fd)
134 {
135 ATRACE_CALL();
136 Locker::Autolock _l(mLock);
137 ALOGD_IF(DEBUG, "ion: Freeing buffer base:%p size:%u fd:%d",
138 base, size, fd);
139 int err = 0;
140 err = open_device();
141 if (err)
142 return err;
143
144 if(base)
145 err = unmap_buffer(base, size, offset);
146 close(fd);
147 return err;
148 }
149
map_buffer(void ** pBase,unsigned int size,unsigned int offset,int fd)150 int IonAlloc::map_buffer(void **pBase, unsigned int size, unsigned int offset,
151 int fd)
152 {
153 ATRACE_CALL();
154 int err = 0;
155 void *base = 0;
156 // It is a (quirky) requirement of ION to have opened the
157 // ion fd in the process that is doing the mapping
158 err = open_device();
159 if (err)
160 return err;
161
162 base = mmap(0, size, PROT_READ| PROT_WRITE,
163 MAP_SHARED, fd, 0);
164 *pBase = base;
165 if(base == MAP_FAILED) {
166 err = -errno;
167 ALOGE("ion: Failed to map memory in the client: %s",
168 strerror(errno));
169 } else {
170 ALOGD_IF(DEBUG, "ion: Mapped buffer base:%p size:%u offset:%u fd:%d",
171 base, size, offset, fd);
172 }
173 return err;
174 }
175
unmap_buffer(void * base,unsigned int size,unsigned int)176 int IonAlloc::unmap_buffer(void *base, unsigned int size,
177 unsigned int /*offset*/)
178 {
179 ATRACE_CALL();
180 ALOGD_IF(DEBUG, "ion: Unmapping buffer base:%p size:%u", base, size);
181 int err = 0;
182 if(munmap(base, size)) {
183 err = -errno;
184 ALOGE("ion: Failed to unmap memory at %p : %s",
185 base, strerror(errno));
186 }
187 return err;
188
189 }
clean_buffer(void * base,unsigned int size,unsigned int offset,int fd,int op)190 int IonAlloc::clean_buffer(void *base, unsigned int size, unsigned int offset,
191 int fd, int op)
192 {
193 ATRACE_CALL();
194 ATRACE_INT("operation id", op);
195 struct ion_flush_data flush_data;
196 struct ion_fd_data fd_data;
197 struct ion_handle_data handle_data;
198 int err = 0;
199
200 err = open_device();
201 if (err)
202 return err;
203
204 fd_data.fd = fd;
205 if (ioctl(mIonFd, ION_IOC_IMPORT, &fd_data)) {
206 err = -errno;
207 ALOGE("%s: ION_IOC_IMPORT failed with error - %s",
208 __FUNCTION__, strerror(errno));
209 return err;
210 }
211
212 handle_data.handle = fd_data.handle;
213 flush_data.handle = fd_data.handle;
214 flush_data.vaddr = base;
215 // offset and length are unsigned int
216 flush_data.offset = offset;
217 flush_data.length = size;
218
219 struct ion_custom_data d;
220 switch(op) {
221 case CACHE_CLEAN:
222 d.cmd = ION_IOC_CLEAN_CACHES;
223 break;
224 case CACHE_INVALIDATE:
225 d.cmd = ION_IOC_INV_CACHES;
226 break;
227 case CACHE_CLEAN_AND_INVALIDATE:
228 default:
229 d.cmd = ION_IOC_CLEAN_INV_CACHES;
230 }
231
232 d.arg = (unsigned long int)&flush_data;
233
234 if(ioctl(mIonFd, ION_IOC_CUSTOM, &d)) {
235 err = -errno;
236 ALOGE("%s: ION_IOC_CLEAN_INV_CACHES failed with error - %s",
237
238 __FUNCTION__, strerror(errno));
239 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
240 return err;
241 }
242 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
243 return 0;
244 }
245
246