]>
Commit | Line | Data |
---|---|---|
967c9cca JW |
1 | /* |
2 | * Copyright (c) 2015-2016, Linaro Limited | |
3 | * | |
4 | * This software is licensed under the terms of the GNU General Public | |
5 | * License version 2, as published by the Free Software Foundation, and | |
6 | * may be copied, distributed, and modified under those terms. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | * GNU General Public License for more details. | |
12 | * | |
13 | */ | |
14 | ||
15 | #ifndef __TEE_DRV_H | |
16 | #define __TEE_DRV_H | |
17 | ||
18 | #include <linux/types.h> | |
19 | #include <linux/idr.h> | |
20 | #include <linux/list.h> | |
21 | #include <linux/tee.h> | |
22 | ||
23 | /* | |
24 | * The file describes the API provided by the generic TEE driver to the | |
25 | * specific TEE driver. | |
26 | */ | |
27 | ||
28 | #define TEE_SHM_MAPPED 0x1 /* Memory mapped by the kernel */ | |
29 | #define TEE_SHM_DMA_BUF 0x2 /* Memory with dma-buf handle */ | |
30 | ||
999616b8 | 31 | struct device; |
967c9cca JW |
32 | struct tee_device; |
33 | struct tee_shm; | |
34 | struct tee_shm_pool; | |
35 | ||
36 | /** | |
37 | * struct tee_context - driver specific context on file pointer data | |
38 | * @teedev: pointer to this drivers struct tee_device | |
39 | * @list_shm: List of shared memory object owned by this context | |
40 | * @data: driver specific context data, managed by the driver | |
41 | */ | |
42 | struct tee_context { | |
43 | struct tee_device *teedev; | |
44 | struct list_head list_shm; | |
45 | void *data; | |
46 | }; | |
47 | ||
48 | struct tee_param_memref { | |
49 | size_t shm_offs; | |
50 | size_t size; | |
51 | struct tee_shm *shm; | |
52 | }; | |
53 | ||
54 | struct tee_param_value { | |
55 | u64 a; | |
56 | u64 b; | |
57 | u64 c; | |
58 | }; | |
59 | ||
60 | struct tee_param { | |
61 | u64 attr; | |
62 | union { | |
63 | struct tee_param_memref memref; | |
64 | struct tee_param_value value; | |
65 | } u; | |
66 | }; | |
67 | ||
68 | /** | |
69 | * struct tee_driver_ops - driver operations vtable | |
70 | * @get_version: returns version of driver | |
71 | * @open: called when the device file is opened | |
72 | * @release: release this open file | |
73 | * @open_session: open a new session | |
74 | * @close_session: close a session | |
75 | * @invoke_func: invoke a trusted function | |
76 | * @cancel_req: request cancel of an ongoing invoke or open | |
77 | * @supp_revc: called for supplicant to get a command | |
78 | * @supp_send: called for supplicant to send a response | |
79 | */ | |
80 | struct tee_driver_ops { | |
81 | void (*get_version)(struct tee_device *teedev, | |
82 | struct tee_ioctl_version_data *vers); | |
83 | int (*open)(struct tee_context *ctx); | |
84 | void (*release)(struct tee_context *ctx); | |
85 | int (*open_session)(struct tee_context *ctx, | |
86 | struct tee_ioctl_open_session_arg *arg, | |
87 | struct tee_param *param); | |
88 | int (*close_session)(struct tee_context *ctx, u32 session); | |
89 | int (*invoke_func)(struct tee_context *ctx, | |
90 | struct tee_ioctl_invoke_arg *arg, | |
91 | struct tee_param *param); | |
92 | int (*cancel_req)(struct tee_context *ctx, u32 cancel_id, u32 session); | |
93 | int (*supp_recv)(struct tee_context *ctx, u32 *func, u32 *num_params, | |
94 | struct tee_param *param); | |
95 | int (*supp_send)(struct tee_context *ctx, u32 ret, u32 num_params, | |
96 | struct tee_param *param); | |
97 | }; | |
98 | ||
99 | /** | |
100 | * struct tee_desc - Describes the TEE driver to the subsystem | |
101 | * @name: name of driver | |
102 | * @ops: driver operations vtable | |
103 | * @owner: module providing the driver | |
104 | * @flags: Extra properties of driver, defined by TEE_DESC_* below | |
105 | */ | |
106 | #define TEE_DESC_PRIVILEGED 0x1 | |
107 | struct tee_desc { | |
108 | const char *name; | |
109 | const struct tee_driver_ops *ops; | |
110 | struct module *owner; | |
111 | u32 flags; | |
112 | }; | |
113 | ||
114 | /** | |
115 | * tee_device_alloc() - Allocate a new struct tee_device instance | |
116 | * @teedesc: Descriptor for this driver | |
117 | * @dev: Parent device for this device | |
118 | * @pool: Shared memory pool, NULL if not used | |
119 | * @driver_data: Private driver data for this device | |
120 | * | |
121 | * Allocates a new struct tee_device instance. The device is | |
122 | * removed by tee_device_unregister(). | |
123 | * | |
124 | * @returns a pointer to a 'struct tee_device' or an ERR_PTR on failure | |
125 | */ | |
126 | struct tee_device *tee_device_alloc(const struct tee_desc *teedesc, | |
127 | struct device *dev, | |
128 | struct tee_shm_pool *pool, | |
129 | void *driver_data); | |
130 | ||
131 | /** | |
132 | * tee_device_register() - Registers a TEE device | |
133 | * @teedev: Device to register | |
134 | * | |
135 | * tee_device_unregister() need to be called to remove the @teedev if | |
136 | * this function fails. | |
137 | * | |
138 | * @returns < 0 on failure | |
139 | */ | |
140 | int tee_device_register(struct tee_device *teedev); | |
141 | ||
142 | /** | |
143 | * tee_device_unregister() - Removes a TEE device | |
144 | * @teedev: Device to unregister | |
145 | * | |
146 | * This function should be called to remove the @teedev even if | |
147 | * tee_device_register() hasn't been called yet. Does nothing if | |
148 | * @teedev is NULL. | |
149 | */ | |
150 | void tee_device_unregister(struct tee_device *teedev); | |
151 | ||
152 | /** | |
153 | * struct tee_shm_pool_mem_info - holds information needed to create a shared | |
154 | * memory pool | |
155 | * @vaddr: Virtual address of start of pool | |
156 | * @paddr: Physical address of start of pool | |
157 | * @size: Size in bytes of the pool | |
158 | */ | |
159 | struct tee_shm_pool_mem_info { | |
160 | unsigned long vaddr; | |
161 | phys_addr_t paddr; | |
162 | size_t size; | |
163 | }; | |
164 | ||
165 | /** | |
166 | * tee_shm_pool_alloc_res_mem() - Create a shared memory pool from reserved | |
167 | * memory range | |
168 | * @priv_info: Information for driver private shared memory pool | |
169 | * @dmabuf_info: Information for dma-buf shared memory pool | |
170 | * | |
171 | * Start and end of pools will must be page aligned. | |
172 | * | |
173 | * Allocation with the flag TEE_SHM_DMA_BUF set will use the range supplied | |
174 | * in @dmabuf, others will use the range provided by @priv. | |
175 | * | |
176 | * @returns pointer to a 'struct tee_shm_pool' or an ERR_PTR on failure. | |
177 | */ | |
178 | struct tee_shm_pool * | |
179 | tee_shm_pool_alloc_res_mem(struct tee_shm_pool_mem_info *priv_info, | |
180 | struct tee_shm_pool_mem_info *dmabuf_info); | |
181 | ||
182 | /** | |
183 | * tee_shm_pool_free() - Free a shared memory pool | |
184 | * @pool: The shared memory pool to free | |
185 | * | |
186 | * The must be no remaining shared memory allocated from this pool when | |
187 | * this function is called. | |
188 | */ | |
189 | void tee_shm_pool_free(struct tee_shm_pool *pool); | |
190 | ||
191 | /** | |
192 | * tee_get_drvdata() - Return driver_data pointer | |
193 | * @returns the driver_data pointer supplied to tee_register(). | |
194 | */ | |
195 | void *tee_get_drvdata(struct tee_device *teedev); | |
196 | ||
197 | /** | |
198 | * tee_shm_alloc() - Allocate shared memory | |
199 | * @ctx: Context that allocates the shared memory | |
200 | * @size: Requested size of shared memory | |
201 | * @flags: Flags setting properties for the requested shared memory. | |
202 | * | |
203 | * Memory allocated as global shared memory is automatically freed when the | |
204 | * TEE file pointer is closed. The @flags field uses the bits defined by | |
205 | * TEE_SHM_* above. TEE_SHM_MAPPED must currently always be set. If | |
206 | * TEE_SHM_DMA_BUF global shared memory will be allocated and associated | |
207 | * with a dma-buf handle, else driver private memory. | |
208 | * | |
209 | * @returns a pointer to 'struct tee_shm' | |
210 | */ | |
211 | struct tee_shm *tee_shm_alloc(struct tee_context *ctx, size_t size, u32 flags); | |
212 | ||
213 | /** | |
214 | * tee_shm_free() - Free shared memory | |
215 | * @shm: Handle to shared memory to free | |
216 | */ | |
217 | void tee_shm_free(struct tee_shm *shm); | |
218 | ||
219 | /** | |
220 | * tee_shm_put() - Decrease reference count on a shared memory handle | |
221 | * @shm: Shared memory handle | |
222 | */ | |
223 | void tee_shm_put(struct tee_shm *shm); | |
224 | ||
225 | /** | |
226 | * tee_shm_va2pa() - Get physical address of a virtual address | |
227 | * @shm: Shared memory handle | |
228 | * @va: Virtual address to tranlsate | |
229 | * @pa: Returned physical address | |
230 | * @returns 0 on success and < 0 on failure | |
231 | */ | |
232 | int tee_shm_va2pa(struct tee_shm *shm, void *va, phys_addr_t *pa); | |
233 | ||
234 | /** | |
235 | * tee_shm_pa2va() - Get virtual address of a physical address | |
236 | * @shm: Shared memory handle | |
237 | * @pa: Physical address to tranlsate | |
238 | * @va: Returned virtual address | |
239 | * @returns 0 on success and < 0 on failure | |
240 | */ | |
241 | int tee_shm_pa2va(struct tee_shm *shm, phys_addr_t pa, void **va); | |
242 | ||
243 | /** | |
244 | * tee_shm_get_va() - Get virtual address of a shared memory plus an offset | |
245 | * @shm: Shared memory handle | |
246 | * @offs: Offset from start of this shared memory | |
247 | * @returns virtual address of the shared memory + offs if offs is within | |
248 | * the bounds of this shared memory, else an ERR_PTR | |
249 | */ | |
250 | void *tee_shm_get_va(struct tee_shm *shm, size_t offs); | |
251 | ||
252 | /** | |
253 | * tee_shm_get_pa() - Get physical address of a shared memory plus an offset | |
254 | * @shm: Shared memory handle | |
255 | * @offs: Offset from start of this shared memory | |
256 | * @pa: Physical address to return | |
257 | * @returns 0 if offs is within the bounds of this shared memory, else an | |
258 | * error code. | |
259 | */ | |
260 | int tee_shm_get_pa(struct tee_shm *shm, size_t offs, phys_addr_t *pa); | |
261 | ||
262 | /** | |
263 | * tee_shm_get_id() - Get id of a shared memory object | |
264 | * @shm: Shared memory handle | |
265 | * @returns id | |
266 | */ | |
267 | int tee_shm_get_id(struct tee_shm *shm); | |
268 | ||
269 | /** | |
270 | * tee_shm_get_from_id() - Find shared memory object and increase reference | |
271 | * count | |
272 | * @ctx: Context owning the shared memory | |
273 | * @id: Id of shared memory object | |
274 | * @returns a pointer to 'struct tee_shm' on success or an ERR_PTR on failure | |
275 | */ | |
276 | struct tee_shm *tee_shm_get_from_id(struct tee_context *ctx, int id); | |
277 | ||
278 | #endif /*__TEE_DRV_H*/ |