1 /*
2 *
3 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
4 *
5 * This software is licensed under the terms of the GNU General Public
6 * License version 2, as published by the Free Software Foundation, and
7 * may be copied, distributed, and modified under those terms.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 */
15
16 #ifndef _LINUX_MSM_ION_H
17 #define _LINUX_MSM_ION_H
18
19 #include <linux/ion.h>
20
21 #define ION_HEAP_TYPE_MSM_START (ION_HEAP_TYPE_CUSTOM + 1)
22 #define ION_HEAP_TYPE_IOMMU (ION_HEAP_TYPE_MSM_START)
23 #define ION_HEAP_TYPE_CP (ION_HEAP_TYPE_IOMMU + 1)
24
25 /**
26 * These are the only ids that should be used for Ion heap ids.
27 * The ids listed are the order in which allocation will be attempted
28 * if specified. Don't swap the order of heap ids unless you know what
29 * you are doing!
30 * Id's are spaced by purpose to allow new Id's to be inserted in-between (for
31 * possible fallbacks)
32 */
33
34 enum ion_heap_ids {
35 INVALID_HEAP_ID = -1,
36 ION_CP_MM_HEAP_ID = 8,
37 ION_CP_MFC_HEAP_ID = 12,
38 ION_CP_WB_HEAP_ID = 16, /* 8660 only */
39 ION_CAMERA_HEAP_ID = 20, /* 8660 only */
40 ION_ADSP_HEAP_ID = 22,
41 ION_SF_HEAP_ID = 24,
42 ION_IOMMU_HEAP_ID = 25,
43 ION_QSECOM_HEAP_ID = 27,
44 ION_AUDIO_HEAP_ID = 28,
45
46 ION_MM_FIRMWARE_HEAP_ID = 29,
47 ION_SYSTEM_HEAP_ID = 30,
48
49 ION_HEAP_ID_RESERVED = 31 /** Bit reserved for ION_SECURE flag */
50 };
51
52 enum ion_fixed_position {
53 NOT_FIXED,
54 FIXED_LOW,
55 FIXED_MIDDLE,
56 FIXED_HIGH,
57 };
58
59 enum cp_mem_usage {
60 VIDEO_BITSTREAM = 0x1,
61 VIDEO_PIXEL = 0x2,
62 VIDEO_NONPIXEL = 0x3,
63 MAX_USAGE = 0x4,
64 UNKNOWN = 0x7FFFFFFF,
65 };
66
67 #define ION_HEAP_CP_MASK (1 << ION_HEAP_TYPE_CP)
68
69 /**
70 * Flag to use when allocating to indicate that a heap is secure.
71 */
72 #define ION_SECURE (1 << ION_HEAP_ID_RESERVED)
73
74 /**
75 * Flag for clients to force contiguous memort allocation
76 *
77 * Use of this flag is carefully monitored!
78 */
79 #define ION_FORCE_CONTIGUOUS (1 << 30)
80
81 /**
82 * Macro should be used with ion_heap_ids defined above.
83 */
84 #define ION_HEAP(bit) (1 << (bit))
85
86 #define ION_ADSP_HEAP_NAME "adsp"
87 #define ION_VMALLOC_HEAP_NAME "vmalloc"
88 #define ION_AUDIO_HEAP_NAME "audio"
89 #define ION_SF_HEAP_NAME "sf"
90 #define ION_MM_HEAP_NAME "mm"
91 #define ION_CAMERA_HEAP_NAME "camera_preview"
92 #define ION_IOMMU_HEAP_NAME "iommu"
93 #define ION_MFC_HEAP_NAME "mfc"
94 #define ION_WB_HEAP_NAME "wb"
95 #define ION_MM_FIRMWARE_HEAP_NAME "mm_fw"
96 #define ION_QSECOM_HEAP_NAME "qsecom"
97 #define ION_FMEM_HEAP_NAME "fmem"
98
99 #define ION_SET_CACHED(__cache) (__cache | ION_FLAG_CACHED)
100 #define ION_SET_UNCACHED(__cache) (__cache & ~ION_FLAG_CACHED)
101
102 #define ION_IS_CACHED(__flags) ((__flags) & ION_FLAG_CACHED)
103
104 #ifdef __KERNEL__
105
106 /*
107 * This flag allows clients when mapping into the IOMMU to specify to
108 * defer un-mapping from the IOMMU until the buffer memory is freed.
109 */
110 #define ION_IOMMU_UNMAP_DELAYED 1
111
112 /**
113 * struct ion_cp_heap_pdata - defines a content protection heap in the given
114 * platform
115 * @permission_type: Memory ID used to identify the memory to TZ
116 * @align: Alignment requirement for the memory
117 * @secure_base: Base address for securing the heap.
118 * Note: This might be different from actual base address
119 * of this heap in the case of a shared heap.
120 * @secure_size: Memory size for securing the heap.
121 * Note: This might be different from actual size
122 * of this heap in the case of a shared heap.
123 * @reusable Flag indicating whether this heap is reusable of not.
124 * (see FMEM)
125 * @mem_is_fmem Flag indicating whether this memory is coming from fmem
126 * or not.
127 * @fixed_position If nonzero, position in the fixed area.
128 * @virt_addr: Virtual address used when using fmem.
129 * @iommu_map_all: Indicates whether we should map whole heap into IOMMU.
130 * @iommu_2x_map_domain: Indicates the domain to use for overmapping.
131 * @request_region: function to be called when the number of allocations
132 * goes from 0 -> 1
133 * @release_region: function to be called when the number of allocations
134 * goes from 1 -> 0
135 * @setup_region: function to be called upon ion registration
136 * @memory_type:Memory type used for the heap
137 * @no_nonsecure_alloc: don't allow non-secure allocations from this heap
138 *
139 */
140 struct ion_cp_heap_pdata {
141 enum ion_permission_type permission_type;
142 unsigned int align;
143 ion_phys_addr_t secure_base; /* Base addr used when heap is shared */
144 size_t secure_size; /* Size used for securing heap when heap is shared*/
145 int reusable;
146 int mem_is_fmem;
147 int is_cma;
148 enum ion_fixed_position fixed_position;
149 int iommu_map_all;
150 int iommu_2x_map_domain;
151 ion_virt_addr_t *virt_addr;
152 int (*request_region)(void *);
153 int (*release_region)(void *);
154 void *(*setup_region)(void);
155 enum ion_memory_types memory_type;
156 int no_nonsecure_alloc;
157 };
158
159 /**
160 * struct ion_co_heap_pdata - defines a carveout heap in the given platform
161 * @adjacent_mem_id: Id of heap that this heap must be adjacent to.
162 * @align: Alignment requirement for the memory
163 * @mem_is_fmem Flag indicating whether this memory is coming from fmem
164 * or not.
165 * @fixed_position If nonzero, position in the fixed area.
166 * @request_region: function to be called when the number of allocations
167 * goes from 0 -> 1
168 * @release_region: function to be called when the number of allocations
169 * goes from 1 -> 0
170 * @setup_region: function to be called upon ion registration
171 * @memory_type:Memory type used for the heap
172 *
173 */
174 struct ion_co_heap_pdata {
175 int adjacent_mem_id;
176 unsigned int align;
177 int mem_is_fmem;
178 enum ion_fixed_position fixed_position;
179 int (*request_region)(void *);
180 int (*release_region)(void *);
181 void *(*setup_region)(void);
182 enum ion_memory_types memory_type;
183 };
184
185 #ifdef CONFIG_ION
186 /**
187 * msm_ion_secure_heap - secure a heap. Wrapper around ion_secure_heap.
188 *
189 * @heap_id - heap id to secure.
190 *
191 * Secure a heap
192 * Returns 0 on success
193 */
194 int msm_ion_secure_heap(int heap_id);
195
196 /**
197 * msm_ion_unsecure_heap - unsecure a heap. Wrapper around ion_unsecure_heap.
198 *
199 * @heap_id - heap id to secure.
200 *
201 * Un-secure a heap
202 * Returns 0 on success
203 */
204 int msm_ion_unsecure_heap(int heap_id);
205
206 /**
207 * msm_ion_secure_heap_2_0 - secure a heap using 2.0 APIs
208 * Wrapper around ion_secure_heap.
209 *
210 * @heap_id - heap id to secure.
211 * @usage - usage hint to TZ
212 *
213 * Secure a heap
214 * Returns 0 on success
215 */
216 int msm_ion_secure_heap_2_0(int heap_id, enum cp_mem_usage usage);
217
218 /**
219 * msm_ion_unsecure_heap - unsecure a heap secured with 3.0 APIs.
220 * Wrapper around ion_unsecure_heap.
221 *
222 * @heap_id - heap id to secure.
223 * @usage - usage hint to TZ
224 *
225 * Un-secure a heap
226 * Returns 0 on success
227 */
228 int msm_ion_unsecure_heap_2_0(int heap_id, enum cp_mem_usage usage);
229 #else
msm_ion_secure_heap(int heap_id)230 static inline int msm_ion_secure_heap(int heap_id)
231 {
232 return -ENODEV;
233
234 }
235
msm_ion_unsecure_heap(int heap_id)236 static inline int msm_ion_unsecure_heap(int heap_id)
237 {
238 return -ENODEV;
239 }
240
msm_ion_secure_heap_2_0(int heap_id,enum cp_mem_usage usage)241 static inline int msm_ion_secure_heap_2_0(int heap_id, enum cp_mem_usage usage)
242 {
243 return -ENODEV;
244 }
245
msm_ion_unsecure_heap_2_0(int heap_id,enum cp_mem_usage usage)246 static inline int msm_ion_unsecure_heap_2_0(int heap_id,
247 enum cp_mem_usage usage)
248 {
249 return -ENODEV;
250 }
251 #endif /* CONFIG_ION */
252
253 #endif /* __KERNEL */
254
255 /* struct ion_flush_data - data passed to ion for flushing caches
256 *
257 * @handle: handle with data to flush
258 * @fd: fd to flush
259 * @vaddr: userspace virtual address mapped with mmap
260 * @offset: offset into the handle to flush
261 * @length: length of handle to flush
262 *
263 * Performs cache operations on the handle. If p is the start address
264 * of the handle, p + offset through p + offset + length will have
265 * the cache operations performed
266 */
267 struct ion_flush_data {
268 struct ion_handle *handle;
269 int fd;
270 void *vaddr;
271 unsigned int offset;
272 unsigned int length;
273 };
274
275 /* struct ion_flag_data - information about flags for this buffer
276 *
277 * @handle: handle to get flags from
278 * @flags: flags of this handle
279 *
280 * Takes handle as an input and outputs the flags from the handle
281 * in the flag field.
282 */
283 struct ion_flag_data {
284 struct ion_handle *handle;
285 unsigned long flags;
286 };
287
288 #define ION_IOC_MSM_MAGIC 'M'
289
290 /**
291 * DOC: ION_IOC_CLEAN_CACHES - clean the caches
292 *
293 * Clean the caches of the handle specified.
294 */
295 #define ION_IOC_CLEAN_CACHES _IOWR(ION_IOC_MSM_MAGIC, 0, \
296 struct ion_flush_data)
297 /**
298 * DOC: ION_IOC_INV_CACHES - invalidate the caches
299 *
300 * Invalidate the caches of the handle specified.
301 */
302 #define ION_IOC_INV_CACHES _IOWR(ION_IOC_MSM_MAGIC, 1, \
303 struct ion_flush_data)
304 /**
305 * DOC: ION_IOC_CLEAN_INV_CACHES - clean and invalidate the caches
306 *
307 * Clean and invalidate the caches of the handle specified.
308 */
309 #define ION_IOC_CLEAN_INV_CACHES _IOWR(ION_IOC_MSM_MAGIC, 2, \
310 struct ion_flush_data)
311
312 /**
313 * DOC: ION_IOC_GET_FLAGS - get the flags of the handle
314 *
315 * Gets the flags of the current handle which indicate cachability,
316 * secure state etc.
317 */
318 #define ION_IOC_GET_FLAGS _IOWR(ION_IOC_MSM_MAGIC, 3, \
319 struct ion_flag_data)
320
321 #endif
322