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 230 static inline int msm_ion_secure_heap(int heap_id) 231 { 232 return -ENODEV; 233 234 } 235 236 static inline int msm_ion_unsecure_heap(int heap_id) 237 { 238 return -ENODEV; 239 } 240 241 static inline int msm_ion_secure_heap_2_0(int heap_id, enum cp_mem_usage usage) 242 { 243 return -ENODEV; 244 } 245 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
