blob: e6d34f8613933be7773a937ecde088a57de87627 [file] [log] [blame]
Iliyan Malchev202a77d2012-06-11 14:41:12 -07001/*
Arun Kumar K.R6c85f052014-01-21 21:47:41 -08002 * Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
Iliyan Malchev202a77d2012-06-11 14:41:12 -07003
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.
Duy Truong73d36df2013-02-09 20:33:23 -080013 * * Neither the name of The Linux Foundation nor the names of its
Iliyan Malchev202a77d2012-06-11 14:41:12 -070014 * 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
Naseer Ahmed01d3fd32012-07-14 21:08:13 -070030#define DEBUG 0
Arun Kumar K.Ra6f91872014-03-20 16:05:28 -070031#include <sys/ioctl.h>
Iliyan Malchev202a77d2012-06-11 14:41:12 -070032#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
40using gralloc::IonAlloc;
41
42#define ION_DEVICE "/dev/ion"
43
44int 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",
Naseer Ahmed29a26812012-06-14 00:56:20 -070051 __FUNCTION__, strerror(errno));
Iliyan Malchev202a77d2012-06-11 14:41:12 -070052 mIonFd = FD_INIT;
53 return -errno;
54 }
55 return 0;
56}
57
58void IonAlloc::close_device()
59{
60 if(mIonFd >= 0)
61 close(mIonFd);
62 mIonFd = FD_INIT;
63}
64
65int IonAlloc::alloc_buffer(alloc_data& data)
66{
Naseer Ahmed29a26812012-06-14 00:56:20 -070067 Locker::Autolock _l(mLock);
Iliyan Malchev202a77d2012-06-11 14:41:12 -070068 int err = 0;
Iliyan Malchev202a77d2012-06-11 14:41:12 -070069 struct ion_handle_data handle_data;
70 struct ion_fd_data fd_data;
71 struct ion_allocation_data ionAllocData;
Iliyan Malchev202a77d2012-06-11 14:41:12 -070072 void *base = 0;
73
74 ionAllocData.len = data.size;
75 ionAllocData.align = data.align;
Naseer Ahmed68ee7c02014-04-11 19:59:39 -040076#ifdef QCOM_BSP
Amara Venkata Mastan Manoj Kumarc180c4e2012-10-09 10:13:55 -070077 ionAllocData.heap_mask = data.flags & ~ION_SECURE;
Naseer Ahmed68ee7c02014-04-11 19:59:39 -040078#else
79 ionAllocData.heap_id_mask = data.flags & ~ION_SECURE;
80#endif
Saurabh Shahd95c4082012-09-14 14:18:21 -070081 ionAllocData.flags = data.uncached ? 0 : ION_FLAG_CACHED;
Amara Venkata Mastan Manoj Kumarc180c4e2012-10-09 10:13:55 -070082 // ToDo: replace usage of alloc data structure with
83 // ionallocdata structure.
84 if (data.flags & ION_SECURE)
85 ionAllocData.flags |= ION_SECURE;
86
Iliyan Malchev202a77d2012-06-11 14:41:12 -070087 err = open_device();
88 if (err)
89 return err;
Saurabh Shahd95c4082012-09-14 14:18:21 -070090 if(ioctl(mIonFd, ION_IOC_ALLOC, &ionAllocData)) {
Iliyan Malchev202a77d2012-06-11 14:41:12 -070091 err = -errno;
92 ALOGE("ION_IOC_ALLOC failed with error - %s", strerror(errno));
Iliyan Malchev202a77d2012-06-11 14:41:12 -070093 return err;
94 }
95
96 fd_data.handle = ionAllocData.handle;
97 handle_data.handle = ionAllocData.handle;
Saurabh Shahd95c4082012-09-14 14:18:21 -070098 if(ioctl(mIonFd, ION_IOC_MAP, &fd_data)) {
Iliyan Malchev202a77d2012-06-11 14:41:12 -070099 err = -errno;
100 ALOGE("%s: ION_IOC_MAP failed with error - %s",
Naseer Ahmed29a26812012-06-14 00:56:20 -0700101 __FUNCTION__, strerror(errno));
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700102 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700103 return err;
104 }
105
Naseer Ahmed01d3fd32012-07-14 21:08:13 -0700106 if(!(data.flags & ION_SECURE)) {
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700107 base = mmap(0, ionAllocData.len, PROT_READ|PROT_WRITE,
Naseer Ahmed29a26812012-06-14 00:56:20 -0700108 MAP_SHARED, fd_data.fd, 0);
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700109 if(base == MAP_FAILED) {
110 err = -errno;
111 ALOGE("%s: Failed to map the allocated memory: %s",
Naseer Ahmed29a26812012-06-14 00:56:20 -0700112 __FUNCTION__, strerror(errno));
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700113 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700114 return err;
115 }
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700116 }
117
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700118 data.base = base;
119 data.fd = fd_data.fd;
120 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
Saurabh Shah8f0ea6f2014-05-19 16:48:53 -0700121 ALOGD_IF(DEBUG, "ion: Allocated buffer base:%p size:%u fd:%d",
Naseer Ahmed29a26812012-06-14 00:56:20 -0700122 data.base, ionAllocData.len, data.fd);
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700123 return 0;
124}
125
126
Saurabh Shah8f0ea6f2014-05-19 16:48:53 -0700127int IonAlloc::free_buffer(void* base, unsigned int size, unsigned int offset,
128 int fd)
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700129{
Naseer Ahmed29a26812012-06-14 00:56:20 -0700130 Locker::Autolock _l(mLock);
Saurabh Shah8f0ea6f2014-05-19 16:48:53 -0700131 ALOGD_IF(DEBUG, "ion: Freeing buffer base:%p size:%u fd:%d",
Naseer Ahmed29a26812012-06-14 00:56:20 -0700132 base, size, fd);
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700133 int err = 0;
134 err = open_device();
135 if (err)
136 return err;
137
138 if(base)
139 err = unmap_buffer(base, size, offset);
140 close(fd);
141 return err;
142}
143
Saurabh Shah8f0ea6f2014-05-19 16:48:53 -0700144int IonAlloc::map_buffer(void **pBase, unsigned int size, unsigned int offset,
145 int fd)
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700146{
147 int err = 0;
148 void *base = 0;
149 // It is a (quirky) requirement of ION to have opened the
150 // ion fd in the process that is doing the mapping
151 err = open_device();
152 if (err)
153 return err;
154
155 base = mmap(0, size, PROT_READ| PROT_WRITE,
Naseer Ahmed29a26812012-06-14 00:56:20 -0700156 MAP_SHARED, fd, 0);
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700157 *pBase = base;
158 if(base == MAP_FAILED) {
159 err = -errno;
Naseer Ahmed01d3fd32012-07-14 21:08:13 -0700160 ALOGE("ion: Failed to map memory in the client: %s",
Naseer Ahmed29a26812012-06-14 00:56:20 -0700161 strerror(errno));
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700162 } else {
Saurabh Shah8f0ea6f2014-05-19 16:48:53 -0700163 ALOGD_IF(DEBUG, "ion: Mapped buffer base:%p size:%u offset:%u fd:%d",
Naseer Ahmed29a26812012-06-14 00:56:20 -0700164 base, size, offset, fd);
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700165 }
166 return err;
167}
168
Saurabh Shah8f0ea6f2014-05-19 16:48:53 -0700169int IonAlloc::unmap_buffer(void *base, unsigned int size,
170 unsigned int /*offset*/)
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700171{
Saurabh Shah8f0ea6f2014-05-19 16:48:53 -0700172 ALOGD_IF(DEBUG, "ion: Unmapping buffer base:%p size:%u", base, size);
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700173 int err = 0;
174 if(munmap(base, size)) {
175 err = -errno;
176 ALOGE("ion: Failed to unmap memory at %p : %s",
Naseer Ahmed29a26812012-06-14 00:56:20 -0700177 base, strerror(errno));
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700178 }
179 return err;
180
181}
Saurabh Shah8f0ea6f2014-05-19 16:48:53 -0700182int IonAlloc::clean_buffer(void *base, unsigned int size, unsigned int offset,
183 int fd, int op)
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700184{
185 struct ion_flush_data flush_data;
186 struct ion_fd_data fd_data;
187 struct ion_handle_data handle_data;
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700188 int err = 0;
189
190 err = open_device();
191 if (err)
192 return err;
193
194 fd_data.fd = fd;
195 if (ioctl(mIonFd, ION_IOC_IMPORT, &fd_data)) {
196 err = -errno;
197 ALOGE("%s: ION_IOC_IMPORT failed with error - %s",
Naseer Ahmed29a26812012-06-14 00:56:20 -0700198 __FUNCTION__, strerror(errno));
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700199 return err;
200 }
201
202 handle_data.handle = fd_data.handle;
203 flush_data.handle = fd_data.handle;
204 flush_data.vaddr = base;
Saurabh Shah8f0ea6f2014-05-19 16:48:53 -0700205 // offset and length are unsigned int
206 flush_data.offset = offset;
207 flush_data.length = size;
Saurabh Shahece296e2012-09-11 13:33:44 -0700208
209 struct ion_custom_data d;
Naseer Ahmedaeab91f2013-03-20 21:01:19 -0400210 switch(op) {
211 case CACHE_CLEAN:
212 d.cmd = ION_IOC_CLEAN_CACHES;
213 break;
214 case CACHE_INVALIDATE:
215 d.cmd = ION_IOC_INV_CACHES;
216 break;
217 case CACHE_CLEAN_AND_INVALIDATE:
218 default:
219 d.cmd = ION_IOC_CLEAN_INV_CACHES;
220 }
221
Saurabh Shahece296e2012-09-11 13:33:44 -0700222 d.arg = (unsigned long int)&flush_data;
223
224 if(ioctl(mIonFd, ION_IOC_CUSTOM, &d)) {
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700225 err = -errno;
226 ALOGE("%s: ION_IOC_CLEAN_INV_CACHES failed with error - %s",
Saurabh Shahece296e2012-09-11 13:33:44 -0700227
Naseer Ahmed29a26812012-06-14 00:56:20 -0700228 __FUNCTION__, strerror(errno));
Iliyan Malchev202a77d2012-06-11 14:41:12 -0700229 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
230 return err;
231 }
232 ioctl(mIonFd, ION_IOC_FREE, &handle_data);
233 return 0;
234}
235