| /* SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) */ | |
| /* | |
| * Copyright (c) 2015-2021, Linaro Limited | |
| */ | |
| #ifndef OPTEE_SMC_H | |
| #define OPTEE_SMC_H | |
| #include <linux/arm-smccc.h> | |
| #include <linux/bitops.h> | |
| #define OPTEE_SMC_STD_CALL_VAL(func_num) \ | |
| ARM_SMCCC_CALL_VAL(ARM_SMCCC_STD_CALL, ARM_SMCCC_SMC_32, \ | |
| ARM_SMCCC_OWNER_TRUSTED_OS, (func_num)) | |
| #define OPTEE_SMC_FAST_CALL_VAL(func_num) \ | |
| ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, ARM_SMCCC_SMC_32, \ | |
| ARM_SMCCC_OWNER_TRUSTED_OS, (func_num)) | |
| /* | |
| * Function specified by SMC Calling convention. | |
| */ | |
| #define OPTEE_SMC_FUNCID_CALLS_COUNT 0xFF00 | |
| #define OPTEE_SMC_CALLS_COUNT \ | |
| ARM_SMCCC_CALL_VAL(OPTEE_SMC_FAST_CALL, SMCCC_SMC_32, \ | |
| SMCCC_OWNER_TRUSTED_OS_END, \ | |
| OPTEE_SMC_FUNCID_CALLS_COUNT) | |
| /* | |
| * Normal cached memory (write-back), shareable for SMP systems and not | |
| * shareable for UP systems. | |
| */ | |
| #define OPTEE_SMC_SHM_CACHED 1 | |
| /* | |
| * a0..a7 is used as register names in the descriptions below, on arm32 | |
| * that translates to r0..r7 and on arm64 to w0..w7. In both cases it's | |
| * 32-bit registers. | |
| */ | |
| /* | |
| * Function specified by SMC Calling convention | |
| * | |
| * Return the following UID if using API specified in this file | |
| * without further extensions: | |
| * 384fb3e0-e7f8-11e3-af63-0002a5d5c51b. | |
| * see also OPTEE_MSG_UID_* in optee_msg.h | |
| */ | |
| #define OPTEE_SMC_FUNCID_CALLS_UID OPTEE_MSG_FUNCID_CALLS_UID | |
| #define OPTEE_SMC_CALLS_UID \ | |
| ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, ARM_SMCCC_SMC_32, \ | |
| ARM_SMCCC_OWNER_TRUSTED_OS_END, \ | |
| OPTEE_SMC_FUNCID_CALLS_UID) | |
| /* | |
| * Function specified by SMC Calling convention | |
| * | |
| * Returns 2.0 if using API specified in this file without further extensions. | |
| * see also OPTEE_MSG_REVISION_* in optee_msg.h | |
| */ | |
| #define OPTEE_SMC_FUNCID_CALLS_REVISION OPTEE_MSG_FUNCID_CALLS_REVISION | |
| #define OPTEE_SMC_CALLS_REVISION \ | |
| ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, ARM_SMCCC_SMC_32, \ | |
| ARM_SMCCC_OWNER_TRUSTED_OS_END, \ | |
| OPTEE_SMC_FUNCID_CALLS_REVISION) | |
| struct optee_smc_calls_revision_result { | |
| unsigned long major; | |
| unsigned long minor; | |
| unsigned long reserved0; | |
| unsigned long reserved1; | |
| }; | |
| /* | |
| * Get UUID of Trusted OS. | |
| * | |
| * Used by non-secure world to figure out which Trusted OS is installed. | |
| * Note that returned UUID is the UUID of the Trusted OS, not of the API. | |
| * | |
| * Returns UUID in a0-4 in the same way as OPTEE_SMC_CALLS_UID | |
| * described above. | |
| */ | |
| #define OPTEE_SMC_FUNCID_GET_OS_UUID OPTEE_MSG_FUNCID_GET_OS_UUID | |
| #define OPTEE_SMC_CALL_GET_OS_UUID \ | |
| OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_OS_UUID) | |
| /* | |
| * Get revision of Trusted OS. | |
| * | |
| * Used by non-secure world to figure out which version of the Trusted OS | |
| * is installed. Note that the returned revision is the revision of the | |
| * Trusted OS, not of the API. | |
| * | |
| * Returns revision in a0-1 in the same way as OPTEE_SMC_CALLS_REVISION | |
| * described above. May optionally return a 32-bit build identifier in a2, | |
| * with zero meaning unspecified. | |
| */ | |
| #define OPTEE_SMC_FUNCID_GET_OS_REVISION OPTEE_MSG_FUNCID_GET_OS_REVISION | |
| #define OPTEE_SMC_CALL_GET_OS_REVISION \ | |
| OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_OS_REVISION) | |
| struct optee_smc_call_get_os_revision_result { | |
| unsigned long major; | |
| unsigned long minor; | |
| unsigned long build_id; | |
| unsigned long reserved1; | |
| }; | |
| /* | |
| * Load Trusted OS from optee/tee.bin in the Linux firmware. | |
| * | |
| * WARNING: Use this cautiously as it could lead to insecure loading of the | |
| * Trusted OS. | |
| * This SMC instructs EL3 to load a binary and execute it as the Trusted OS. | |
| * | |
| * Call register usage: | |
| * a0 SMC Function ID, OPTEE_SMC_CALL_LOAD_IMAGE | |
| * a1 Upper 32bit of a 64bit size for the payload | |
| * a2 Lower 32bit of a 64bit size for the payload | |
| * a3 Upper 32bit of the physical address for the payload | |
| * a4 Lower 32bit of the physical address for the payload | |
| * | |
| * The payload is in the OP-TEE image format. | |
| * | |
| * Returns result in a0, 0 on success and an error code otherwise. | |
| */ | |
| #define OPTEE_SMC_FUNCID_LOAD_IMAGE 2 | |
| #define OPTEE_SMC_CALL_LOAD_IMAGE \ | |
| ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, ARM_SMCCC_SMC_32, \ | |
| ARM_SMCCC_OWNER_TRUSTED_OS_END, \ | |
| OPTEE_SMC_FUNCID_LOAD_IMAGE) | |
| /* | |
| * Call with struct optee_msg_arg as argument | |
| * | |
| * When called with OPTEE_SMC_CALL_WITH_RPC_ARG or | |
| * OPTEE_SMC_CALL_WITH_REGD_ARG in a0 there is one RPC struct optee_msg_arg | |
| * following after the first struct optee_msg_arg. The RPC struct | |
| * optee_msg_arg has reserved space for the number of RPC parameters as | |
| * returned by OPTEE_SMC_EXCHANGE_CAPABILITIES. | |
| * | |
| * When calling these functions, normal world has a few responsibilities: | |
| * 1. It must be able to handle eventual RPCs | |
| * 2. Non-secure interrupts should not be masked | |
| * 3. If asynchronous notifications has been negotiated successfully, then | |
| * the interrupt for asynchronous notifications should be unmasked | |
| * during this call. | |
| * | |
| * Call register usage, OPTEE_SMC_CALL_WITH_ARG and | |
| * OPTEE_SMC_CALL_WITH_RPC_ARG: | |
| * a0 SMC Function ID, OPTEE_SMC_CALL_WITH_ARG or OPTEE_SMC_CALL_WITH_RPC_ARG | |
| * a1 Upper 32 bits of a 64-bit physical pointer to a struct optee_msg_arg | |
| * a2 Lower 32 bits of a 64-bit physical pointer to a struct optee_msg_arg | |
| * a3 Cache settings, not used if physical pointer is in a predefined shared | |
| * memory area else per OPTEE_SMC_SHM_* | |
| * a4-6 Not used | |
| * a7 Hypervisor Client ID register | |
| * | |
| * Call register usage, OPTEE_SMC_CALL_WITH_REGD_ARG: | |
| * a0 SMC Function ID, OPTEE_SMC_CALL_WITH_REGD_ARG | |
| * a1 Upper 32 bits of a 64-bit shared memory cookie | |
| * a2 Lower 32 bits of a 64-bit shared memory cookie | |
| * a3 Offset of the struct optee_msg_arg in the shared memory with the | |
| * supplied cookie | |
| * a4-6 Not used | |
| * a7 Hypervisor Client ID register | |
| * | |
| * Normal return register usage: | |
| * a0 Return value, OPTEE_SMC_RETURN_* | |
| * a1-3 Not used | |
| * a4-7 Preserved | |
| * | |
| * OPTEE_SMC_RETURN_ETHREAD_LIMIT return register usage: | |
| * a0 Return value, OPTEE_SMC_RETURN_ETHREAD_LIMIT | |
| * a1-3 Preserved | |
| * a4-7 Preserved | |
| * | |
| * RPC return register usage: | |
| * a0 Return value, OPTEE_SMC_RETURN_IS_RPC(val) | |
| * a1-2 RPC parameters | |
| * a3-7 Resume information, must be preserved | |
| * | |
| * Possible return values: | |
| * OPTEE_SMC_RETURN_UNKNOWN_FUNCTION Trusted OS does not recognize this | |
| * function. | |
| * OPTEE_SMC_RETURN_OK Call completed, result updated in | |
| * the previously supplied struct | |
| * optee_msg_arg. | |
| * OPTEE_SMC_RETURN_ETHREAD_LIMIT Number of Trusted OS threads exceeded, | |
| * try again later. | |
| * OPTEE_SMC_RETURN_EBADADDR Bad physical pointer to struct | |
| * optee_msg_arg. | |
| * OPTEE_SMC_RETURN_EBADCMD Bad/unknown cmd in struct optee_msg_arg | |
| * OPTEE_SMC_RETURN_IS_RPC() Call suspended by RPC call to normal | |
| * world. | |
| */ | |
| #define OPTEE_SMC_FUNCID_CALL_WITH_ARG OPTEE_MSG_FUNCID_CALL_WITH_ARG | |
| #define OPTEE_SMC_CALL_WITH_ARG \ | |
| OPTEE_SMC_STD_CALL_VAL(OPTEE_SMC_FUNCID_CALL_WITH_ARG) | |
| #define OPTEE_SMC_CALL_WITH_RPC_ARG \ | |
| OPTEE_SMC_STD_CALL_VAL(OPTEE_SMC_FUNCID_CALL_WITH_RPC_ARG) | |
| #define OPTEE_SMC_CALL_WITH_REGD_ARG \ | |
| OPTEE_SMC_STD_CALL_VAL(OPTEE_SMC_FUNCID_CALL_WITH_REGD_ARG) | |
| /* | |
| * Get Shared Memory Config | |
| * | |
| * Returns the Secure/Non-secure shared memory config. | |
| * | |
| * Call register usage: | |
| * a0 SMC Function ID, OPTEE_SMC_GET_SHM_CONFIG | |
| * a1-6 Not used | |
| * a7 Hypervisor Client ID register | |
| * | |
| * Have config return register usage: | |
| * a0 OPTEE_SMC_RETURN_OK | |
| * a1 Physical address of start of SHM | |
| * a2 Size of SHM | |
| * a3 Cache settings of memory, as defined by the | |
| * OPTEE_SMC_SHM_* values above | |
| * a4-7 Preserved | |
| * | |
| * Not available register usage: | |
| * a0 OPTEE_SMC_RETURN_ENOTAVAIL | |
| * a1-3 Not used | |
| * a4-7 Preserved | |
| */ | |
| #define OPTEE_SMC_FUNCID_GET_SHM_CONFIG 7 | |
| #define OPTEE_SMC_GET_SHM_CONFIG \ | |
| OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_SHM_CONFIG) | |
| struct optee_smc_get_shm_config_result { | |
| unsigned long status; | |
| unsigned long start; | |
| unsigned long size; | |
| unsigned long settings; | |
| }; | |
| /* | |
| * Exchanges capabilities between normal world and secure world | |
| * | |
| * Call register usage: | |
| * a0 SMC Function ID, OPTEE_SMC_EXCHANGE_CAPABILITIES | |
| * a1 bitfield of normal world capabilities OPTEE_SMC_NSEC_CAP_* | |
| * a2-6 Not used | |
| * a7 Hypervisor Client ID register | |
| * | |
| * Normal return register usage: | |
| * a0 OPTEE_SMC_RETURN_OK | |
| * a1 bitfield of secure world capabilities OPTEE_SMC_SEC_CAP_* | |
| * a2 The maximum secure world notification number | |
| * a3 Bit[7:0]: Number of parameters needed for RPC to be supplied | |
| * as the second MSG arg struct for | |
| * OPTEE_SMC_CALL_WITH_ARG | |
| * Bit[31:8]: Reserved (MBZ) | |
| * a4-7 Preserved | |
| * | |
| * Error return register usage: | |
| * a0 OPTEE_SMC_RETURN_ENOTAVAIL, can't use the capabilities from normal world | |
| * a1 bitfield of secure world capabilities OPTEE_SMC_SEC_CAP_* | |
| * a2-7 Preserved | |
| */ | |
| /* Normal world works as a uniprocessor system */ | |
| #define OPTEE_SMC_NSEC_CAP_UNIPROCESSOR BIT(0) | |
| /* Secure world has reserved shared memory for normal world to use */ | |
| #define OPTEE_SMC_SEC_CAP_HAVE_RESERVED_SHM BIT(0) | |
| /* Secure world can communicate via previously unregistered shared memory */ | |
| #define OPTEE_SMC_SEC_CAP_UNREGISTERED_SHM BIT(1) | |
| /* | |
| * Secure world supports commands "register/unregister shared memory", | |
| * secure world accepts command buffers located in any parts of non-secure RAM | |
| */ | |
| #define OPTEE_SMC_SEC_CAP_DYNAMIC_SHM BIT(2) | |
| /* Secure world is built with virtualization support */ | |
| #define OPTEE_SMC_SEC_CAP_VIRTUALIZATION BIT(3) | |
| /* Secure world supports Shared Memory with a NULL reference */ | |
| #define OPTEE_SMC_SEC_CAP_MEMREF_NULL BIT(4) | |
| /* Secure world supports asynchronous notification of normal world */ | |
| #define OPTEE_SMC_SEC_CAP_ASYNC_NOTIF BIT(5) | |
| /* Secure world supports pre-allocating RPC arg struct */ | |
| #define OPTEE_SMC_SEC_CAP_RPC_ARG BIT(6) | |
| /* Secure world supports probing for RPMB device if needed */ | |
| #define OPTEE_SMC_SEC_CAP_RPMB_PROBE BIT(7) | |
| /* Secure world supports protected memory */ | |
| #define OPTEE_SMC_SEC_CAP_PROTMEM BIT(8) | |
| /* Secure world supports dynamic protected memory */ | |
| #define OPTEE_SMC_SEC_CAP_DYNAMIC_PROTMEM BIT(9) | |
| #define OPTEE_SMC_FUNCID_EXCHANGE_CAPABILITIES 9 | |
| #define OPTEE_SMC_EXCHANGE_CAPABILITIES \ | |
| OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_EXCHANGE_CAPABILITIES) | |
| struct optee_smc_exchange_capabilities_result { | |
| unsigned long status; | |
| unsigned long capabilities; | |
| unsigned long max_notif_value; | |
| unsigned long data; | |
| }; | |
| /* | |
| * Disable and empties cache of shared memory objects | |
| * | |
| * Secure world can cache frequently used shared memory objects, for | |
| * example objects used as RPC arguments. When secure world is idle this | |
| * function returns one shared memory reference to free. To disable the | |
| * cache and free all cached objects this function has to be called until | |
| * it returns OPTEE_SMC_RETURN_ENOTAVAIL. | |
| * | |
| * Call register usage: | |
| * a0 SMC Function ID, OPTEE_SMC_DISABLE_SHM_CACHE | |
| * a1-6 Not used | |
| * a7 Hypervisor Client ID register | |
| * | |
| * Normal return register usage: | |
| * a0 OPTEE_SMC_RETURN_OK | |
| * a1 Upper 32 bits of a 64-bit Shared memory cookie | |
| * a2 Lower 32 bits of a 64-bit Shared memory cookie | |
| * a3-7 Preserved | |
| * | |
| * Cache empty return register usage: | |
| * a0 OPTEE_SMC_RETURN_ENOTAVAIL | |
| * a1-7 Preserved | |
| * | |
| * Not idle return register usage: | |
| * a0 OPTEE_SMC_RETURN_EBUSY | |
| * a1-7 Preserved | |
| */ | |
| #define OPTEE_SMC_FUNCID_DISABLE_SHM_CACHE 10 | |
| #define OPTEE_SMC_DISABLE_SHM_CACHE \ | |
| OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_DISABLE_SHM_CACHE) | |
| struct optee_smc_disable_shm_cache_result { | |
| unsigned long status; | |
| unsigned long shm_upper32; | |
| unsigned long shm_lower32; | |
| unsigned long reserved0; | |
| }; | |
| /* | |
| * Enable cache of shared memory objects | |
| * | |
| * Secure world can cache frequently used shared memory objects, for | |
| * example objects used as RPC arguments. When secure world is idle this | |
| * function returns OPTEE_SMC_RETURN_OK and the cache is enabled. If | |
| * secure world isn't idle OPTEE_SMC_RETURN_EBUSY is returned. | |
| * | |
| * Call register usage: | |
| * a0 SMC Function ID, OPTEE_SMC_ENABLE_SHM_CACHE | |
| * a1-6 Not used | |
| * a7 Hypervisor Client ID register | |
| * | |
| * Normal return register usage: | |
| * a0 OPTEE_SMC_RETURN_OK | |
| * a1-7 Preserved | |
| * | |
| * Not idle return register usage: | |
| * a0 OPTEE_SMC_RETURN_EBUSY | |
| * a1-7 Preserved | |
| */ | |
| #define OPTEE_SMC_FUNCID_ENABLE_SHM_CACHE 11 | |
| #define OPTEE_SMC_ENABLE_SHM_CACHE \ | |
| OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_ENABLE_SHM_CACHE) | |
| /* | |
| * Query OP-TEE about number of supported threads | |
| * | |
| * Normal World OS or Hypervisor issues this call to find out how many | |
| * threads OP-TEE supports. That is how many standard calls can be issued | |
| * in parallel before OP-TEE will return OPTEE_SMC_RETURN_ETHREAD_LIMIT. | |
| * | |
| * Call requests usage: | |
| * a0 SMC Function ID, OPTEE_SMC_GET_THREAD_COUNT | |
| * a1-6 Not used | |
| * a7 Hypervisor Client ID register | |
| * | |
| * Normal return register usage: | |
| * a0 OPTEE_SMC_RETURN_OK | |
| * a1 Number of threads | |
| * a2-7 Preserved | |
| * | |
| * Error return: | |
| * a0 OPTEE_SMC_RETURN_UNKNOWN_FUNCTION Requested call is not implemented | |
| * a1-7 Preserved | |
| */ | |
| #define OPTEE_SMC_FUNCID_GET_THREAD_COUNT 15 | |
| #define OPTEE_SMC_GET_THREAD_COUNT \ | |
| OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_THREAD_COUNT) | |
| /* | |
| * Inform OP-TEE that normal world is able to receive asynchronous | |
| * notifications. | |
| * | |
| * Call requests usage: | |
| * a0 SMC Function ID, OPTEE_SMC_ENABLE_ASYNC_NOTIF | |
| * a1-6 Not used | |
| * a7 Hypervisor Client ID register | |
| * | |
| * Normal return register usage: | |
| * a0 OPTEE_SMC_RETURN_OK | |
| * a1-7 Preserved | |
| * | |
| * Not supported return register usage: | |
| * a0 OPTEE_SMC_RETURN_ENOTAVAIL | |
| * a1-7 Preserved | |
| */ | |
| #define OPTEE_SMC_FUNCID_ENABLE_ASYNC_NOTIF 16 | |
| #define OPTEE_SMC_ENABLE_ASYNC_NOTIF \ | |
| OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_ENABLE_ASYNC_NOTIF) | |
| /* | |
| * Retrieve a value of notifications pending since the last call of this | |
| * function. | |
| * | |
| * OP-TEE keeps a record of all posted values. When an interrupt is | |
| * received which indicates that there are posted values this function | |
| * should be called until all pended values have been retrieved. When a | |
| * value is retrieved, it's cleared from the record in secure world. | |
| * | |
| * It is expected that this function is called from an interrupt handler | |
| * in normal world. | |
| * | |
| * Call requests usage: | |
| * a0 SMC Function ID, OPTEE_SMC_GET_ASYNC_NOTIF_VALUE | |
| * a1-6 Not used | |
| * a7 Hypervisor Client ID register | |
| * | |
| * Normal return register usage: | |
| * a0 OPTEE_SMC_RETURN_OK | |
| * a1 value | |
| * a2 Bit[0]: OPTEE_SMC_ASYNC_NOTIF_VALUE_VALID if the value in a1 is | |
| * valid, else 0 if no values where pending | |
| * a2 Bit[1]: OPTEE_SMC_ASYNC_NOTIF_VALUE_PENDING if another value is | |
| * pending, else 0. | |
| * Bit[31:2]: MBZ | |
| * a3-7 Preserved | |
| * | |
| * Not supported return register usage: | |
| * a0 OPTEE_SMC_RETURN_ENOTAVAIL | |
| * a1-7 Preserved | |
| */ | |
| #define OPTEE_SMC_ASYNC_NOTIF_VALUE_VALID BIT(0) | |
| #define OPTEE_SMC_ASYNC_NOTIF_VALUE_PENDING BIT(1) | |
| /* | |
| * Notification that OP-TEE expects a yielding call to do some bottom half | |
| * work in a driver. | |
| */ | |
| #define OPTEE_SMC_ASYNC_NOTIF_VALUE_DO_BOTTOM_HALF 0 | |
| #define OPTEE_SMC_FUNCID_GET_ASYNC_NOTIF_VALUE 17 | |
| #define OPTEE_SMC_GET_ASYNC_NOTIF_VALUE \ | |
| OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_ASYNC_NOTIF_VALUE) | |
| /* See OPTEE_SMC_CALL_WITH_RPC_ARG above */ | |
| #define OPTEE_SMC_FUNCID_CALL_WITH_RPC_ARG 18 | |
| /* See OPTEE_SMC_CALL_WITH_REGD_ARG above */ | |
| #define OPTEE_SMC_FUNCID_CALL_WITH_REGD_ARG 19 | |
| /* | |
| * Get protected memory config | |
| * | |
| * Returns the protected memory config. | |
| * | |
| * Call register usage: | |
| * a0 SMC Function ID, OPTEE_SMC_GET_PROTMEM_CONFIG | |
| * a2-6 Not used, must be zero | |
| * a7 Hypervisor Client ID register | |
| * | |
| * Have config return register usage: | |
| * a0 OPTEE_SMC_RETURN_OK | |
| * a1 Physical address of start of protected memory | |
| * a2 Size of protected memory | |
| * a3 PA width, max 64 | |
| * a4-7 Preserved | |
| * | |
| * Not available register usage: | |
| * a0 OPTEE_SMC_RETURN_ENOTAVAIL | |
| * a1-3 Not used | |
| * a4-7 Preserved | |
| */ | |
| #define OPTEE_SMC_FUNCID_GET_PROTMEM_CONFIG 20 | |
| #define OPTEE_SMC_GET_PROTMEM_CONFIG \ | |
| OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_PROTMEM_CONFIG) | |
| struct optee_smc_get_protmem_config_result { | |
| unsigned long status; | |
| unsigned long start; | |
| unsigned long size; | |
| unsigned long pa_width; | |
| }; | |
| /* | |
| * Resume from RPC (for example after processing a foreign interrupt) | |
| * | |
| * Call register usage: | |
| * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC | |
| * a1-3 Value of a1-3 when OPTEE_SMC_CALL_WITH_ARG returned | |
| * OPTEE_SMC_RETURN_RPC in a0 | |
| * | |
| * Return register usage is the same as for OPTEE_SMC_*CALL_WITH_ARG above. | |
| * | |
| * Possible return values | |
| * OPTEE_SMC_RETURN_UNKNOWN_FUNCTION Trusted OS does not recognize this | |
| * function. | |
| * OPTEE_SMC_RETURN_OK Original call completed, result | |
| * updated in the previously supplied. | |
| * struct optee_msg_arg | |
| * OPTEE_SMC_RETURN_RPC Call suspended by RPC call to normal | |
| * world. | |
| * OPTEE_SMC_RETURN_ERESUME Resume failed, the opaque resume | |
| * information was corrupt. | |
| */ | |
| #define OPTEE_SMC_FUNCID_RETURN_FROM_RPC 3 | |
| #define OPTEE_SMC_CALL_RETURN_FROM_RPC \ | |
| OPTEE_SMC_STD_CALL_VAL(OPTEE_SMC_FUNCID_RETURN_FROM_RPC) | |
| #define OPTEE_SMC_RETURN_RPC_PREFIX_MASK 0xFFFF0000 | |
| #define OPTEE_SMC_RETURN_RPC_PREFIX 0xFFFF0000 | |
| #define OPTEE_SMC_RETURN_RPC_FUNC_MASK 0x0000FFFF | |
| #define OPTEE_SMC_RETURN_GET_RPC_FUNC(ret) \ | |
| ((ret) & OPTEE_SMC_RETURN_RPC_FUNC_MASK) | |
| #define OPTEE_SMC_RPC_VAL(func) ((func) | OPTEE_SMC_RETURN_RPC_PREFIX) | |
| /* | |
| * Allocate memory for RPC parameter passing. The memory is used to hold a | |
| * struct optee_msg_arg. | |
| * | |
| * "Call" register usage: | |
| * a0 This value, OPTEE_SMC_RETURN_RPC_ALLOC | |
| * a1 Size in bytes of required argument memory | |
| * a2 Not used | |
| * a3 Resume information, must be preserved | |
| * a4-5 Not used | |
| * a6-7 Resume information, must be preserved | |
| * | |
| * "Return" register usage: | |
| * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC. | |
| * a1 Upper 32 bits of 64-bit physical pointer to allocated | |
| * memory, (a1 == 0 && a2 == 0) if size was 0 or if memory can't | |
| * be allocated. | |
| * a2 Lower 32 bits of 64-bit physical pointer to allocated | |
| * memory, (a1 == 0 && a2 == 0) if size was 0 or if memory can't | |
| * be allocated | |
| * a3 Preserved | |
| * a4 Upper 32 bits of 64-bit Shared memory cookie used when freeing | |
| * the memory or doing an RPC | |
| * a5 Lower 32 bits of 64-bit Shared memory cookie used when freeing | |
| * the memory or doing an RPC | |
| * a6-7 Preserved | |
| */ | |
| #define OPTEE_SMC_RPC_FUNC_ALLOC 0 | |
| #define OPTEE_SMC_RETURN_RPC_ALLOC \ | |
| OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_ALLOC) | |
| /* | |
| * Free memory previously allocated by OPTEE_SMC_RETURN_RPC_ALLOC | |
| * | |
| * "Call" register usage: | |
| * a0 This value, OPTEE_SMC_RETURN_RPC_FREE | |
| * a1 Upper 32 bits of 64-bit shared memory cookie belonging to this | |
| * argument memory | |
| * a2 Lower 32 bits of 64-bit shared memory cookie belonging to this | |
| * argument memory | |
| * a3-7 Resume information, must be preserved | |
| * | |
| * "Return" register usage: | |
| * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC. | |
| * a1-2 Not used | |
| * a3-7 Preserved | |
| */ | |
| #define OPTEE_SMC_RPC_FUNC_FREE 2 | |
| #define OPTEE_SMC_RETURN_RPC_FREE \ | |
| OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_FREE) | |
| /* | |
| * Deliver a foreign interrupt in normal world. | |
| * | |
| * "Call" register usage: | |
| * a0 OPTEE_SMC_RETURN_RPC_FOREIGN_INTR | |
| * a1-7 Resume information, must be preserved | |
| * | |
| * "Return" register usage: | |
| * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC. | |
| * a1-7 Preserved | |
| */ | |
| #define OPTEE_SMC_RPC_FUNC_FOREIGN_INTR 4 | |
| #define OPTEE_SMC_RETURN_RPC_FOREIGN_INTR \ | |
| OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_FOREIGN_INTR) | |
| /* | |
| * Do an RPC request. The supplied struct optee_msg_arg tells which | |
| * request to do and the parameters for the request. The following fields | |
| * are used (the rest are unused): | |
| * - cmd the Request ID | |
| * - ret return value of the request, filled in by normal world | |
| * - num_params number of parameters for the request | |
| * - params the parameters | |
| * - param_attrs attributes of the parameters | |
| * | |
| * "Call" register usage: | |
| * a0 OPTEE_SMC_RETURN_RPC_CMD | |
| * a1 Upper 32 bits of a 64-bit Shared memory cookie holding a | |
| * struct optee_msg_arg, must be preserved, only the data should | |
| * be updated | |
| * a2 Lower 32 bits of a 64-bit Shared memory cookie holding a | |
| * struct optee_msg_arg, must be preserved, only the data should | |
| * be updated | |
| * a3-7 Resume information, must be preserved | |
| * | |
| * "Return" register usage: | |
| * a0 SMC Function ID, OPTEE_SMC_CALL_RETURN_FROM_RPC. | |
| * a1-2 Not used | |
| * a3-7 Preserved | |
| */ | |
| #define OPTEE_SMC_RPC_FUNC_CMD 5 | |
| #define OPTEE_SMC_RETURN_RPC_CMD \ | |
| OPTEE_SMC_RPC_VAL(OPTEE_SMC_RPC_FUNC_CMD) | |
| /* Returned in a0 */ | |
| #define OPTEE_SMC_RETURN_UNKNOWN_FUNCTION 0xFFFFFFFF | |
| /* Returned in a0 only from Trusted OS functions */ | |
| #define OPTEE_SMC_RETURN_OK 0x0 | |
| #define OPTEE_SMC_RETURN_ETHREAD_LIMIT 0x1 | |
| #define OPTEE_SMC_RETURN_EBUSY 0x2 | |
| #define OPTEE_SMC_RETURN_ERESUME 0x3 | |
| #define OPTEE_SMC_RETURN_EBADADDR 0x4 | |
| #define OPTEE_SMC_RETURN_EBADCMD 0x5 | |
| #define OPTEE_SMC_RETURN_ENOMEM 0x6 | |
| #define OPTEE_SMC_RETURN_ENOTAVAIL 0x7 | |
| #define OPTEE_SMC_RETURN_IS_RPC(ret) __optee_smc_return_is_rpc((ret)) | |
| static inline bool __optee_smc_return_is_rpc(u32 ret) | |
| { | |
| return ret != OPTEE_SMC_RETURN_UNKNOWN_FUNCTION && | |
| (ret & OPTEE_SMC_RETURN_RPC_PREFIX_MASK) == | |
| OPTEE_SMC_RETURN_RPC_PREFIX; | |
| } | |
| #endif /* OPTEE_SMC_H */ |