1 /* Copyright (c) 2013-2014, 2016, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above
9 * copyright notice, this list of conditions and the following
10 * disclaimer in the documentation and/or other materials provided
11 * with the distribution.
12 * * Neither the name of The Linux Foundation nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30 // System dependencies
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <linux/msm_ion.h>
36 #define MMAN_H <SYSTEM_HEADER_PREFIX/mman.h>
37 #include MMAN_H
38
39 // JPEG dependencies
40 #include "mm_jpeg_ionbuf.h"
41
42 /** buffer_allocate:
43 *
44 * Arguments:
45 * @p_buffer: ION buffer
46 *
47 * Return:
48 * buffer address
49 *
50 * Description:
51 * allocates ION buffer
52 *
53 **/
buffer_allocate(buffer_t * p_buffer,int cached)54 void *buffer_allocate(buffer_t *p_buffer, int cached)
55 {
56 void *l_buffer = NULL;
57
58 int lrc = 0;
59 struct ion_handle_data lhandle_data;
60
61 p_buffer->alloc.len = p_buffer->size;
62 p_buffer->alloc.align = 4096;
63 p_buffer->alloc.flags = (cached) ? ION_FLAG_CACHED : 0;
64 p_buffer->alloc.heap_id_mask = 0x1 << ION_IOMMU_HEAP_ID;
65
66 p_buffer->ion_fd = open("/dev/ion", O_RDONLY);
67 if(p_buffer->ion_fd < 0) {
68 LOGE("Ion open failed");
69 goto ION_ALLOC_FAILED;
70 }
71
72 /* Make it page size aligned */
73 p_buffer->alloc.len = (p_buffer->alloc.len + 4095U) & (~4095U);
74 lrc = ioctl(p_buffer->ion_fd, ION_IOC_ALLOC, &p_buffer->alloc);
75 if (lrc < 0) {
76 LOGE("ION allocation failed len %zu",
77 p_buffer->alloc.len);
78 goto ION_ALLOC_FAILED;
79 }
80
81 p_buffer->ion_info_fd.handle = p_buffer->alloc.handle;
82 lrc = ioctl(p_buffer->ion_fd, ION_IOC_SHARE,
83 &p_buffer->ion_info_fd);
84 if (lrc < 0) {
85 LOGE("ION map failed %s", strerror(errno));
86 goto ION_MAP_FAILED;
87 }
88
89 p_buffer->p_pmem_fd = p_buffer->ion_info_fd.fd;
90
91 l_buffer = mmap(NULL, p_buffer->alloc.len, PROT_READ | PROT_WRITE,
92 MAP_SHARED,p_buffer->p_pmem_fd, 0);
93
94 if (l_buffer == MAP_FAILED) {
95 LOGE("ION_MMAP_FAILED: %s (%d)",
96 strerror(errno), errno);
97 goto ION_MAP_FAILED;
98 }
99
100 return l_buffer;
101
102 ION_MAP_FAILED:
103 lhandle_data.handle = p_buffer->ion_info_fd.handle;
104 ioctl(p_buffer->ion_fd, ION_IOC_FREE, &lhandle_data);
105 return NULL;
106 ION_ALLOC_FAILED:
107 return NULL;
108
109 }
110
111 /** buffer_deallocate:
112 *
113 * Arguments:
114 * @p_buffer: ION buffer
115 *
116 * Return:
117 * buffer address
118 *
119 * Description:
120 * deallocates ION buffer
121 *
122 **/
buffer_deallocate(buffer_t * p_buffer)123 int buffer_deallocate(buffer_t *p_buffer)
124 {
125 int lrc = 0;
126 size_t lsize = (p_buffer->size + 4095U) & (~4095U);
127
128 struct ion_handle_data lhandle_data;
129 lrc = munmap(p_buffer->addr, lsize);
130
131 close(p_buffer->ion_info_fd.fd);
132
133 lhandle_data.handle = p_buffer->ion_info_fd.handle;
134 ioctl(p_buffer->ion_fd, ION_IOC_FREE, &lhandle_data);
135
136 close(p_buffer->ion_fd);
137 return lrc;
138 }
139
140 /** buffer_invalidate:
141 *
142 * Arguments:
143 * @p_buffer: ION buffer
144 *
145 * Return:
146 * error val
147 *
148 * Description:
149 * Invalidates the cached buffer
150 *
151 **/
buffer_invalidate(buffer_t * p_buffer)152 int buffer_invalidate(buffer_t *p_buffer)
153 {
154 int lrc = 0;
155 struct ion_flush_data cache_inv_data;
156 struct ion_custom_data custom_data;
157
158 memset(&cache_inv_data, 0, sizeof(cache_inv_data));
159 memset(&custom_data, 0, sizeof(custom_data));
160 cache_inv_data.vaddr = p_buffer->addr;
161 cache_inv_data.fd = p_buffer->ion_info_fd.fd;
162 cache_inv_data.handle = p_buffer->ion_info_fd.handle;
163 cache_inv_data.length = (unsigned int)p_buffer->size;
164 custom_data.cmd = (unsigned int)ION_IOC_INV_CACHES;
165 custom_data.arg = (unsigned long)&cache_inv_data;
166
167 lrc = ioctl(p_buffer->ion_fd, ION_IOC_CUSTOM, &custom_data);
168 if (lrc < 0)
169 LOGW("Cache Invalidate failed: %s\n", strerror(errno));
170
171 return lrc;
172 }
173
174 /** buffer_clean:
175 *
176 * Arguments:
177 * @p_buffer: ION buffer
178 *
179 * Return:
180 * error val
181 *
182 * Description:
183 * Clean the cached buffer
184 *
185 **/
buffer_clean(buffer_t * p_buffer)186 int buffer_clean(buffer_t *p_buffer)
187 {
188 int lrc = 0;
189 struct ion_flush_data cache_clean_data;
190 struct ion_custom_data custom_data;
191
192 memset(&cache_clean_data, 0, sizeof(cache_clean_data));
193 memset(&custom_data, 0, sizeof(custom_data));
194 cache_clean_data.vaddr = p_buffer->addr;
195 cache_clean_data.fd = p_buffer->ion_info_fd.fd;
196 cache_clean_data.handle = p_buffer->ion_info_fd.handle;
197 cache_clean_data.length = (unsigned int)p_buffer->size;
198 custom_data.cmd = (unsigned int)ION_IOC_CLEAN_CACHES;
199 custom_data.arg = (unsigned long)&cache_clean_data;
200
201 lrc = ioctl(p_buffer->ion_fd, ION_IOC_CUSTOM, &custom_data);
202 if (lrc < 0)
203 LOGW("Cache clean failed: %s\n", strerror(errno));
204
205 return lrc;
206 }
207