1 /* SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) */
2 /*
3 * Copyright (c) 2015-2021, Linaro Limited
4 */
5 #ifndef OPTEE_SMC_H
6 #define OPTEE_SMC_H
7
8 #include <linux/arm-smccc.h>
9 #include <linux/bitops.h>
10
11 #define OPTEE_SMC_STD_CALL_VAL(func_num) \
12 ARM_SMCCC_CALL_VAL(ARM_SMCCC_STD_CALL, ARM_SMCCC_SMC_32, \
13 ARM_SMCCC_OWNER_TRUSTED_OS, (func_num))
14 #define OPTEE_SMC_FAST_CALL_VAL(func_num) \
15 ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, ARM_SMCCC_SMC_32, \
16 ARM_SMCCC_OWNER_TRUSTED_OS, (func_num))
17
18 /*
19 * Function specified by SMC Calling convention.
20 */
21 #define OPTEE_SMC_FUNCID_CALLS_COUNT 0xFF00
22 #define OPTEE_SMC_CALLS_COUNT \
23 ARM_SMCCC_CALL_VAL(OPTEE_SMC_FAST_CALL, SMCCC_SMC_32, \
24 SMCCC_OWNER_TRUSTED_OS_END, \
25 OPTEE_SMC_FUNCID_CALLS_COUNT)
26
27 /*
28 * Normal cached memory (write-back), shareable for SMP systems and not
29 * shareable for UP systems.
30 */
31 #define OPTEE_SMC_SHM_CACHED 1
32
33 /*
34 * a0..a7 is used as register names in the descriptions below, on arm32
35 * that translates to r0..r7 and on arm64 to w0..w7. In both cases it's
36 * 32-bit registers.
37 */
38
39 /*
40 * Function specified by SMC Calling convention
41 *
42 * Return the following UID if using API specified in this file
43 * without further extensions:
44 * 384fb3e0-e7f8-11e3-af63-0002a5d5c51b.
45 * see also OPTEE_MSG_UID_* in optee_msg.h
46 */
47 #define OPTEE_SMC_FUNCID_CALLS_UID OPTEE_MSG_FUNCID_CALLS_UID
48 #define OPTEE_SMC_CALLS_UID \
49 ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, ARM_SMCCC_SMC_32, \
50 ARM_SMCCC_OWNER_TRUSTED_OS_END, \
51 OPTEE_SMC_FUNCID_CALLS_UID)
52
53 /*
54 * Function specified by SMC Calling convention
55 *
56 * Returns 2.0 if using API specified in this file without further extensions.
57 * see also OPTEE_MSG_REVISION_* in optee_msg.h
58 */
59 #define OPTEE_SMC_FUNCID_CALLS_REVISION OPTEE_MSG_FUNCID_CALLS_REVISION
60 #define OPTEE_SMC_CALLS_REVISION \
61 ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, ARM_SMCCC_SMC_32, \
62 ARM_SMCCC_OWNER_TRUSTED_OS_END, \
63 OPTEE_SMC_FUNCID_CALLS_REVISION)
64
65 struct optee_smc_calls_revision_result {
66 unsigned long major;
67 unsigned long minor;
68 unsigned long reserved0;
69 unsigned long reserved1;
70 };
71
72 /*
73 * Get UUID of Trusted OS.
74 *
75 * Used by non-secure world to figure out which Trusted OS is installed.
76 * Note that returned UUID is the UUID of the Trusted OS, not of the API.
77 *
78 * Returns UUID in a0-4 in the same way as OPTEE_SMC_CALLS_UID
79 * described above.
80 */
81 #define OPTEE_SMC_FUNCID_GET_OS_UUID OPTEE_MSG_FUNCID_GET_OS_UUID
82 #define OPTEE_SMC_CALL_GET_OS_UUID \
83 OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_OS_UUID)
84
85 /*
86 * Get revision of Trusted OS.
87 *
88 * Used by non-secure world to figure out which version of the Trusted OS
89 * is installed. Note that the returned revision is the revision of the
90 * Trusted OS, not of the API.
91 *
92 * Returns revision in a0-1 in the same way as OPTEE_SMC_CALLS_REVISION
93 * described above. May optionally return a 32-bit build identifier in a2,
94 * with zero meaning unspecified.
95 */
96 #define OPTEE_SMC_FUNCID_GET_OS_REVISION OPTEE_MSG_FUNCID_GET_OS_REVISION
97 #define OPTEE_SMC_CALL_GET_OS_REVISION \
98 OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_OS_REVISION)
99
100 struct optee_smc_call_get_os_revision_result {
101 unsigned long major;
102 unsigned long minor;
103 unsigned long build_id;
104 unsigned long reserved1;
105 };
106
107 /*
108 * Call with struct optee_msg_arg as argument
109 *
110 * When called with OPTEE_SMC_CALL_WITH_RPC_ARG or
111 * OPTEE_SMC_CALL_WITH_REGD_ARG in a0 there is one RPC struct optee_msg_arg
112 * following after the first struct optee_msg_arg. The RPC struct
113 * optee_msg_arg has reserved space for the number of RPC parameters as
114 * returned by OPTEE_SMC_EXCHANGE_CAPABILITIES.
115 *
116 * When calling these functions, normal world has a few responsibilities:
117 * 1. It must be able to handle eventual RPCs
118 * 2. Non-secure interrupts should not be masked
119 * 3. If asynchronous notifications has been negotiated successfully, then
120 * the interrupt for asynchronous notifications should be unmasked
121 * during this call.
122 *
123 * Call register usage, OPTEE_SMC_CALL_WITH_ARG and
124 * OPTEE_SMC_CALL_WITH_RPC_ARG:
125 * a0 SMC Function ID, OPTEE_SMC_CALL_WITH_ARG or OPTEE_SMC_CALL_WITH_RPC_ARG
126 * a1 Upper 32 bits of a 64-bit physical pointer to a struct optee_msg_arg
127 * a2 Lower 32 bits of a 64-bit physical pointer to a struct optee_msg_arg
128 * a3 Cache settings, not used if physical pointer is in a predefined shared
129 * memory area else per OPTEE_SMC_SHM_*
130 * a4-6 Not used
131 * a7 Hypervisor Client ID register
132 *
133 * Call register usage, OPTEE_SMC_CALL_WITH_REGD_ARG:
134 * a0 SMC Function ID, OPTEE_SMC_CALL_WITH_REGD_ARG
135 * a1 Upper 32 bits of a 64-bit shared memory cookie
136 * a2 Lower 32 bits of a 64-bit shared memory cookie
137 * a3 Offset of the struct optee_msg_arg in the shared memory with the
138 * supplied cookie
139 * a4-6 Not used
140 * a7 Hypervisor Client ID register
141 *
142 * Normal return register usage:
143 * a0 Return value, OPTEE_SMC_RETURN_*
144 * a1-3 Not used
145 * a4-7 Preserved
146 *
147 * OPTEE_SMC_RETURN_ETHREAD_LIMIT return register usage:
148 * a0 Return value, OPTEE_SMC_RETURN_ETHREAD_LIMIT
149 * a1-3 Preserved
150 * a4-7 Preserved
151 *
152 * RPC return register usage:
153 * a0 Return value, OPTEE_SMC_RETURN_IS_RPC(val)
154 * a1-2 RPC parameters
155 * a3-7 Resume information, must be preserved
156 *
157 * Possible return values:
158 * OPTEE_SMC_RETURN_UNKNOWN_FUNCTION Trusted OS does not recognize this
159 * function.
160 * OPTEE_SMC_RETURN_OK Call completed, result updated in
161 * the previously supplied struct
162 * optee_msg_arg.
163 * OPTEE_SMC_RETURN_ETHREAD_LIMIT Number of Trusted OS threads exceeded,
164 * try again later.
165 * OPTEE_SMC_RETURN_EBADADDR Bad physical pointer to struct
166 * optee_msg_arg.
167 * OPTEE_SMC_RETURN_EBADCMD Bad/unknown cmd in struct optee_msg_arg
168 * OPTEE_SMC_RETURN_IS_RPC() Call suspended by RPC call to normal
169 * world.
170 */
171 #define OPTEE_SMC_FUNCID_CALL_WITH_ARG OPTEE_MSG_FUNCID_CALL_WITH_ARG
172 #define OPTEE_SMC_CALL_WITH_ARG \
173 OPTEE_SMC_STD_CALL_VAL(OPTEE_SMC_FUNCID_CALL_WITH_ARG)
174 #define OPTEE_SMC_CALL_WITH_RPC_ARG \
175 OPTEE_SMC_STD_CALL_VAL(OPTEE_SMC_FUNCID_CALL_WITH_RPC_ARG)
176 #define OPTEE_SMC_CALL_WITH_REGD_ARG \
177 OPTEE_SMC_STD_CALL_VAL(OPTEE_SMC_FUNCID_CALL_WITH_REGD_ARG)
178
179 /*
180 * Get Shared Memory Config
181 *
182 * Returns the Secure/Non-secure shared memory config.
183 *
184 * Call register usage:
185 * a0 SMC Function ID, OPTEE_SMC_GET_SHM_CONFIG
186 * a1-6 Not used
187 * a7 Hypervisor Client ID register
188 *
189 * Have config return register usage:
190 * a0 OPTEE_SMC_RETURN_OK
191 * a1 Physical address of start of SHM
192 * a2 Size of SHM
193 * a3 Cache settings of memory, as defined by the
194 * OPTEE_SMC_SHM_* values above
195 * a4-7 Preserved
196 *
197 * Not available register usage:
198 * a0 OPTEE_SMC_RETURN_ENOTAVAIL
199 * a1-3 Not used
200 * a4-7 Preserved
201 */
202 #define OPTEE_SMC_FUNCID_GET_SHM_CONFIG 7
203 #define OPTEE_SMC_GET_SHM_CONFIG \
204 OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_SHM_CONFIG)
205
206 struct optee_smc_get_shm_config_result {
207 unsigned long status;
208 unsigned long start;
209 unsigned long size;
210 unsigned long settings;
211 };
212
213 /*
214 * Exchanges capabilities between normal world and secure world
215 *
216 * Call register usage:
217 * a0 SMC Function ID, OPTEE_SMC_EXCHANGE_CAPABILITIES
218 * a1 bitfield of normal world capabilities OPTEE_SMC_NSEC_CAP_*
219 * a2-6 Not used
220 * a7 Hypervisor Client ID register
221 *
222 * Normal return register usage:
223 * a0 OPTEE_SMC_RETURN_OK
224 * a1 bitfield of secure world capabilities OPTEE_SMC_SEC_CAP_*
225 * a2 The maximum secure world notification number
226 * a3 Bit[7:0]: Number of parameters needed for RPC to be supplied
227 * as the second MSG arg struct for
228 * OPTEE_SMC_CALL_WITH_ARG
229 * Bit[31:8]: Reserved (MBZ)
230 * a4-7 Preserved
231 *
232 * Error return register usage:
233 * a0 OPTEE_SMC_RETURN_ENOTAVAIL, can't use the capabilities from normal world
234 * a1 bitfield of secure world capabilities OPTEE_SMC_SEC_CAP_*
235 * a2-7 Preserved
236 */
237 /* Normal world works as a uniprocessor system */
238 #define OPTEE_SMC_NSEC_CAP_UNIPROCESSOR BIT(0)
239 /* Secure world has reserved shared memory for normal world to use */
240 #define OPTEE_SMC_SEC_CAP_HAVE_RESERVED_SHM BIT(0)
241 /* Secure world can communicate via previously unregistered shared memory */
242 #define OPTEE_SMC_SEC_CAP_UNREGISTERED_SHM BIT(1)
243
244 /*
245 * Secure world supports commands "register/unregister shared memory",
246 * secure world accepts command buffers located in any parts of non-secure RAM
247 */
248 #define OPTEE_SMC_SEC_CAP_DYNAMIC_SHM BIT(2)
249 /* Secure world is built with virtualization support */
250 #define OPTEE_SMC_SEC_CAP_VIRTUALIZATION BIT(3)
251 /* Secure world supports Shared Memory with a NULL reference */
252 #define OPTEE_SMC_SEC_CAP_MEMREF_NULL BIT(4)
253 /* Secure world supports asynchronous notification of normal world */
254 #define OPTEE_SMC_SEC_CAP_ASYNC_NOTIF BIT(5)
255 /* Secure world supports pre-allocating RPC arg struct */
256 #define OPTEE_SMC_SEC_CAP_RPC_ARG BIT(6)
257
258 #define OPTEE_SMC_FUNCID_EXCHANGE_CAPABILITIES 9
259 #define OPTEE_SMC_EXCHANGE_CAPABILITIES \
260 OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_EXCHANGE_CAPABILITIES)
261
262 struct optee_smc_exchange_capabilities_result {
263 unsigned long status;
264 unsigned long capabilities;
265 unsigned long max_notif_value;
266 unsigned long data;
267 };
268
269 /*
270 * Disable and empties cache of shared memory objects
271 *
272 * Secure world can cache frequently used shared memory objects, for
273 * example objects used as RPC arguments. When secure world is idle this
274 * function returns one shared memory reference to free. To disable the
275 * cache and free all cached objects this function has to be called until
276 * it returns OPTEE_SMC_RETURN_ENOTAVAIL.
277 *
278 * Call register usage:
279 * a0 SMC Function ID, OPTEE_SMC_DISABLE_SHM_CACHE
280 * a1-6 Not used
281 * a7 Hypervisor Client ID register
282 *
283 * Normal return register usage:
284 * a0 OPTEE_SMC_RETURN_OK
285 * a1 Upper 32 bits of a 64-bit Shared memory cookie
286 * a2 Lower 32 bits of a 64-bit Shared memory cookie
287 * a3-7 Preserved
288 *
289 * Cache empty return register usage:
290 * a0 OPTEE_SMC_RETURN_ENOTAVAIL
291 * a1-7 Preserved
292 *
293 * Not idle return register usage:
294 * a0 OPTEE_SMC_RETURN_EBUSY
295 * a1-7 Preserved
296 */
297 #define OPTEE_SMC_FUNCID_DISABLE_SHM_CACHE 10
298 #define OPTEE_SMC_DISABLE_SHM_CACHE \
299 OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_DISABLE_SHM_CACHE)
300
301 struct optee_smc_disable_shm_cache_result {
302 unsigned long status;
303 unsigned long shm_upper32;
304 unsigned long shm_lower32;
305 unsigned long reserved0;
306 };
307
308 /*
309 * Enable cache of shared memory objects
310 *
311 * Secure world can cache frequently used shared memory objects, for
312 * example objects used as RPC arguments. When secure world is idle this
313 * function returns OPTEE_SMC_RETURN_OK and the cache is enabled. If
314 * secure world isn't idle OPTEE_SMC_RETURN_EBUSY is returned.
315 *
316 * Call register usage:
317 * a0 SMC Function ID, OPTEE_SMC_ENABLE_SHM_CACHE
318 * a1-6 Not used
319 * a7 Hypervisor Client ID register
320 *
321 * Normal return register usage:
322 * a0 OPTEE_SMC_RETURN_OK
323 * a1-7 Preserved
324 *
325 * Not idle return register usage:
326 * a0 OPTEE_SMC_RETURN_EBUSY
327 * a1-7 Preserved
328 */
329 #define OPTEE_SMC_FUNCID_ENABLE_SHM_CACHE 11
330 #define OPTEE_SMC_ENABLE_SHM_CACHE \
331 OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_ENABLE_SHM_CACHE)
332
333 /*
334 * Query OP-TEE about number of supported threads
335 *
336 * Normal World OS or Hypervisor issues this call to find out how many
337 * threads OP-TEE supports. That is how many standard calls can be issued
338 * in parallel before OP-TEE will return OPTEE_SMC_RETURN_ETHREAD_LIMIT.
339 *
340 * Call requests usage:
341 * a0 SMC Function ID, OPTEE_SMC_GET_THREAD_COUNT
342 * a1-6 Not used
343 * a7 Hypervisor Client ID register
344 *
345 * Normal return register usage:
346 * a0 OPTEE_SMC_RETURN_OK
347 * a1 Number of threads
348 * a2-7 Preserved
349 *
350 * Error return:
351 * a0 OPTEE_SMC_RETURN_UNKNOWN_FUNCTION Requested call is not implemented
352 * a1-7 Preserved
353 */
354 #define OPTEE_SMC_FUNCID_GET_THREAD_COUNT 15
355 #define OPTEE_SMC_GET_THREAD_COUNT \
356 OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_THREAD_COUNT)
357
358 /*
359 * Inform OP-TEE that normal world is able to receive asynchronous
360 * notifications.
361 *
362 * Call requests usage:
363 * a0 SMC Function ID, OPTEE_SMC_ENABLE_ASYNC_NOTIF
364 * a1-6 Not used
365 * a7 Hypervisor Client ID register
366 *
367 * Normal return register usage:
368 * a0 OPTEE_SMC_RETURN_OK
369 * a1-7 Preserved
370 *
371 * Not supported return register usage:
372 * a0 OPTEE_SMC_RETURN_ENOTAVAIL
373 * a1-7 Preserved
374 */
375 #define OPTEE_SMC_FUNCID_ENABLE_ASYNC_NOTIF 16
376 #define OPTEE_SMC_ENABLE_ASYNC_NOTIF \
377 OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_ENABLE_ASYNC_NOTIF)
378
379 /*
380 * Retrieve a value of notifications pending since the last call of this
381 * function.
382 *
383 * OP-TEE keeps a record of all posted values. When an interrupt is
384 * received which indicates that there are posted values this function
385 * should be called until all pended values have been retrieved. When a
386 * value is retrieved, it's cleared from the record in secure world.
387 *
388 * It is expected that this function is called from an interrupt handler
389 * in normal world.
390 *
391 * Call requests usage:
392 * a0 SMC Function ID, OPTEE_SMC_GET_ASYNC_NOTIF_VALUE
393 * a1-6 Not used
394 * a7 Hypervisor Client ID register
395 *
396 * Normal return register usage:
397 * a0 OPTEE_SMC_RETURN_OK
398 * a1 value
399 * a2 Bit[0]: OPTEE_SMC_ASYNC_NOTIF_VALUE_VALID if the value in a1 is
400 * valid, else 0 if no values where pending
401 * a2 Bit[1]: OPTEE_SMC_ASYNC_NOTIF_VALUE_PENDING if another value is
402 * pending, else 0.
403 * Bit[31:2]: MBZ
404 * a3-7 Preserved
405 *
406 * Not supported return register usage:
407 * a0 OPTEE_SMC_RETURN_ENOTAVAIL
408 * a1-7 Preserved
409 */
410 #define OPTEE_SMC_ASYNC_NOTIF_VALUE_VALID BIT(0)
411 #define OPTEE_SMC_ASYNC_NOTIF_VALUE_PENDING BIT(1)
412
413 /*
414 * Notification that OP-TEE expects a yielding call to do some bottom half
415 * work in a driver.
416 */
417 #define OPTEE_SMC_ASYNC_NOTIF_VALUE_DO_BOTTOM_HALF 0
418
419 #define OPTEE_SMC_FUNCID_GET_ASYNC_NOTIF_VALUE 17
420 #define OPTEE_SMC_GET_ASYNC_NOTIF_VALUE \
421 OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_ASYNC_NOTIF_VALUE)
422
423 /* See OPTEE_SMC_CALL_WITH_RPC_ARG above */
424 #define OPTEE_SMC_FUNCID_CALL_WITH_RPC_ARG 18
425
426 /* See OPTEE_SMC_CALL_WITH_REGD_ARG above */
427 #define OPTEE_SMC_FUNCID_CALL_WITH_REGD_ARG 19
428
429 /*
430 * Resume from RPC (for example after processing a foreign interrupt)
431 *
432 * Call register usage:
433 * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC
434 * a1-3 Value of a1-3 when OPTEE_SMC_CALL_WITH_ARG returned
435 * OPTEE_SMC_RETURN_RPC in a0
436 *
437 * Return register usage is the same as for OPTEE_SMC_*CALL_WITH_ARG above.
438 *
439 * Possible return values
440 * OPTEE_SMC_RETURN_UNKNOWN_FUNCTION Trusted OS does not recognize this
441 * function.
442 * OPTEE_SMC_RETURN_OK Original call completed, result
443 * updated in the previously supplied.
444 * struct optee_msg_arg
445 * OPTEE_SMC_RETURN_RPC Call suspended by RPC call to normal
446 * world.
447 * OPTEE_SMC_RETURN_ERESUME Resume failed, the opaque resume
448 * information was corrupt.
449 */
450 #define OPTEE_SMC_FUNCID_RETURN_FROM_RPC 3
451 #define OPTEE_SMC_CALL_RETURN_FROM_RPC \
452 OPTEE_SMC_STD_CALL_VAL(OPTEE_SMC_FUNCID_RETURN_FROM_RPC)
453
454 #define OPTEE_SMC_RETURN_RPC_PREFIX_MASK 0xFFFF0000
455 #define OPTEE_SMC_RETURN_RPC_PREFIX 0xFFFF0000
456 #define OPTEE_SMC_RETURN_RPC_FUNC_MASK 0x0000FFFF
457
458 #define OPTEE_SMC_RETURN_GET_RPC_FUNC(ret) \
459 ((ret) & OPTEE_SMC_RETURN_RPC_FUNC_MASK)
460
461 #define OPTEE_SMC_RPC_VAL(func) ((func) | OPTEE_SMC_RETURN_RPC_PREFIX)
462
463 /*
464 * Allocate memory for RPC parameter passing. The memory is used to hold a
465 * struct optee_msg_arg.
466 *
467 * "Call" register usage:
468 * a0 This value, OPTEE_SMC_RETURN_RPC_ALLOC
469 * a1 Size in bytes of required argument memory
470 * a2 Not used
471 * a3 Resume information, must be preserved
472 * a4-5 Not used
473 * a6-7 Resume information, must be preserved
474 *
475 * "Return" register usage:
476 * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC.
477 * a1 Upper 32 bits of 64-bit physical pointer to allocated
478 * memory, (a1 == 0 && a2 == 0) if size was 0 or if memory can't
479 * be allocated.
480 * a2 Lower 32 bits of 64-bit physical pointer to allocated
481 * memory, (a1 == 0 && a2 == 0) if size was 0 or if memory can't
482 * be allocated
483 * a3 Preserved
484 * a4 Upper 32 bits of 64-bit Shared memory cookie used when freeing
485 * the memory or doing an RPC
486 * a5 Lower 32 bits of 64-bit Shared memory cookie used when freeing
487 * the memory or doing an RPC
488 * a6-7 Preserved
489 */
490 #define OPTEE_SMC_RPC_FUNC_ALLOC 0
491 #define OPTEE_SMC_RETURN_RPC_ALLOC \
492 OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_ALLOC)
493
494 /*
495 * Free memory previously allocated by OPTEE_SMC_RETURN_RPC_ALLOC
496 *
497 * "Call" register usage:
498 * a0 This value, OPTEE_SMC_RETURN_RPC_FREE
499 * a1 Upper 32 bits of 64-bit shared memory cookie belonging to this
500 * argument memory
501 * a2 Lower 32 bits of 64-bit shared memory cookie belonging to this
502 * argument memory
503 * a3-7 Resume information, must be preserved
504 *
505 * "Return" register usage:
506 * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC.
507 * a1-2 Not used
508 * a3-7 Preserved
509 */
510 #define OPTEE_SMC_RPC_FUNC_FREE 2
511 #define OPTEE_SMC_RETURN_RPC_FREE \
512 OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_FREE)
513
514 /*
515 * Deliver a foreign interrupt in normal world.
516 *
517 * "Call" register usage:
518 * a0 OPTEE_SMC_RETURN_RPC_FOREIGN_INTR
519 * a1-7 Resume information, must be preserved
520 *
521 * "Return" register usage:
522 * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC.
523 * a1-7 Preserved
524 */
525 #define OPTEE_SMC_RPC_FUNC_FOREIGN_INTR 4
526 #define OPTEE_SMC_RETURN_RPC_FOREIGN_INTR \
527 OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_FOREIGN_INTR)
528
529 /*
530 * Do an RPC request. The supplied struct optee_msg_arg tells which
531 * request to do and the parameters for the request. The following fields
532 * are used (the rest are unused):
533 * - cmd the Request ID
534 * - ret return value of the request, filled in by normal world
535 * - num_params number of parameters for the request
536 * - params the parameters
537 * - param_attrs attributes of the parameters
538 *
539 * "Call" register usage:
540 * a0 OPTEE_SMC_RETURN_RPC_CMD
541 * a1 Upper 32 bits of a 64-bit Shared memory cookie holding a
542 * struct optee_msg_arg, must be preserved, only the data should
543 * be updated
544 * a2 Lower 32 bits of a 64-bit Shared memory cookie holding a
545 * struct optee_msg_arg, must be preserved, only the data should
546 * be updated
547 * a3-7 Resume information, must be preserved
548 *
549 * "Return" register usage:
550 * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC.
551 * a1-2 Not used
552 * a3-7 Preserved
553 */
554 #define OPTEE_SMC_RPC_FUNC_CMD 5
555 #define OPTEE_SMC_RETURN_RPC_CMD \
556 OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_CMD)
557
558 /* Returned in a0 */
559 #define OPTEE_SMC_RETURN_UNKNOWN_FUNCTION 0xFFFFFFFF
560
561 /* Returned in a0 only from Trusted OS functions */
562 #define OPTEE_SMC_RETURN_OK 0x0
563 #define OPTEE_SMC_RETURN_ETHREAD_LIMIT 0x1
564 #define OPTEE_SMC_RETURN_EBUSY 0x2
565 #define OPTEE_SMC_RETURN_ERESUME 0x3
566 #define OPTEE_SMC_RETURN_EBADADDR 0x4
567 #define OPTEE_SMC_RETURN_EBADCMD 0x5
568 #define OPTEE_SMC_RETURN_ENOMEM 0x6
569 #define OPTEE_SMC_RETURN_ENOTAVAIL 0x7
570 #define OPTEE_SMC_RETURN_IS_RPC(ret) __optee_smc_return_is_rpc((ret))
571
__optee_smc_return_is_rpc(u32 ret)572 static inline bool __optee_smc_return_is_rpc(u32 ret)
573 {
574 return ret != OPTEE_SMC_RETURN_UNKNOWN_FUNCTION &&
575 (ret & OPTEE_SMC_RETURN_RPC_PREFIX_MASK) ==
576 OPTEE_SMC_RETURN_RPC_PREFIX;
577 }
578
579 #endif /* OPTEE_SMC_H */
580