1 /*
2  * Copyright (c) 2011-2012,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 #include <sys/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     }
113 
114     data.base = base;
115     data.fd = fd_data.fd;
116     ioctl(mIonFd, ION_IOC_FREE, &handle_data);
117     ALOGD_IF(DEBUG, "ion: Allocated buffer base:%p size:%zu fd:%d",
118           data.base, ionAllocData.len, data.fd);
119     return 0;
120 }
121 
122 
free_buffer(void * base,unsigned int size,unsigned int offset,int fd)123 int IonAlloc::free_buffer(void* base, unsigned int size, unsigned int offset,
124         int fd)
125 {
126     Locker::Autolock _l(mLock);
127     ALOGD_IF(DEBUG, "ion: Freeing buffer base:%p size:%u fd:%d",
128           base, size, fd);
129     int err = 0;
130     err = open_device();
131     if (err)
132         return err;
133 
134     if(base)
135         err = unmap_buffer(base, size, offset);
136     close(fd);
137     return err;
138 }
139 
map_buffer(void ** pBase,unsigned int size,unsigned int offset,int fd)140 int IonAlloc::map_buffer(void **pBase, unsigned int size, unsigned int offset,
141         int fd)
142 {
143     int err = 0;
144     void *base = 0;
145     // It is a (quirky) requirement of ION to have opened the
146     // ion fd in the process that is doing the mapping
147     err = open_device();
148     if (err)
149         return err;
150 
151     base = mmap(0, size, PROT_READ| PROT_WRITE,
152                 MAP_SHARED, fd, 0);
153     *pBase = base;
154     if(base == MAP_FAILED) {
155         err = -errno;
156         ALOGE("ion: Failed to map memory in the client: %s",
157               strerror(errno));
158     } else {
159         ALOGD_IF(DEBUG, "ion: Mapped buffer base:%p size:%u offset:%u fd:%d",
160               base, size, offset, fd);
161     }
162     return err;
163 }
164 
unmap_buffer(void * base,unsigned int size,unsigned int)165 int IonAlloc::unmap_buffer(void *base, unsigned int size,
166         unsigned int /*offset*/)
167 {
168     ALOGD_IF(DEBUG, "ion: Unmapping buffer  base:%p size:%u", base, size);
169     int err = 0;
170     if(munmap(base, size)) {
171         err = -errno;
172         ALOGE("ion: Failed to unmap memory at %p : %s",
173               base, strerror(errno));
174     }
175     return err;
176 
177 }
clean_buffer(void * base,unsigned int size,unsigned int offset,int fd,int op)178 int IonAlloc::clean_buffer(void *base, unsigned int size, unsigned int offset,
179         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     // offset and length are unsigned int
202     flush_data.offset  = offset;
203     flush_data.length  = size;
204 
205     struct ion_custom_data d;
206     switch(op) {
207     case CACHE_CLEAN:
208         d.cmd = ION_IOC_CLEAN_CACHES;
209         break;
210     case CACHE_INVALIDATE:
211             d.cmd = ION_IOC_INV_CACHES;
212         break;
213     case CACHE_CLEAN_AND_INVALIDATE:
214     default:
215         d.cmd = ION_IOC_CLEAN_INV_CACHES;
216     }
217 
218     d.arg = (unsigned long int)&flush_data;
219 
220     if(ioctl(mIonFd, ION_IOC_CUSTOM, &d)) {
221         err = -errno;
222         ALOGE("%s: ION_IOC_CLEAN_INV_CACHES failed with error - %s",
223 
224               __FUNCTION__, strerror(errno));
225         ioctl(mIonFd, ION_IOC_FREE, &handle_data);
226         return err;
227     }
228     ioctl(mIonFd, ION_IOC_FREE, &handle_data);
229     return 0;
230 }
231 
232