1 /* 2 * Copyright (c) 2016-2023, Arm Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #ifndef SMCCC_H 8 #define SMCCC_H 9 10 #include <lib/utils_def.h> 11 12 #define SMCCC_VERSION_MAJOR_SHIFT U(16) 13 #define SMCCC_VERSION_MAJOR_MASK U(0x7FFF) 14 #define SMCCC_VERSION_MINOR_SHIFT U(0) 15 #define SMCCC_VERSION_MINOR_MASK U(0xFFFF) 16 #define MAKE_SMCCC_VERSION(_major, _minor) \ 17 ((((uint32_t)(_major) & SMCCC_VERSION_MAJOR_MASK) << \ 18 SMCCC_VERSION_MAJOR_SHIFT) \ 19 | (((uint32_t)(_minor) & SMCCC_VERSION_MINOR_MASK) << \ 20 SMCCC_VERSION_MINOR_SHIFT)) 21 22 #define SMCCC_MAJOR_VERSION U(1) 23 #define SMCCC_MINOR_VERSION U(4) 24 25 /******************************************************************************* 26 * Bit definitions inside the function id as per the SMC calling convention 27 ******************************************************************************/ 28 #define FUNCID_TYPE_SHIFT U(31) 29 #define FUNCID_TYPE_MASK U(0x1) 30 #define FUNCID_TYPE_WIDTH U(1) 31 32 #define FUNCID_CC_SHIFT U(30) 33 #define FUNCID_CC_MASK U(0x1) 34 #define FUNCID_CC_WIDTH U(1) 35 36 #define FUNCID_OEN_SHIFT U(24) 37 #define FUNCID_OEN_MASK U(0x3f) 38 #define FUNCID_OEN_WIDTH U(6) 39 40 #define FUNCID_FC_RESERVED_SHIFT U(17) 41 #define FUNCID_FC_RESERVED_MASK U(0x7f) 42 #define FUNCID_FC_RESERVED_WIDTH U(7) 43 44 #define FUNCID_SVE_HINT_SHIFT U(16) 45 #define FUNCID_SVE_HINT_MASK U(1) 46 #define FUNCID_SVE_HINT_WIDTH U(1) 47 48 #define FUNCID_NUM_SHIFT U(0) 49 #define FUNCID_NUM_MASK U(0xffff) 50 #define FUNCID_NUM_WIDTH U(16) 51 52 #define FUNCID_MASK U(0xffffffff) 53 54 #define GET_SMC_NUM(id) (((id) >> FUNCID_NUM_SHIFT) & \ 55 FUNCID_NUM_MASK) 56 #define GET_SMC_TYPE(id) (((id) >> FUNCID_TYPE_SHIFT) & \ 57 FUNCID_TYPE_MASK) 58 #define GET_SMC_CC(id) (((id) >> FUNCID_CC_SHIFT) & \ 59 FUNCID_CC_MASK) 60 #define GET_SMC_OEN(id) (((id) >> FUNCID_OEN_SHIFT) & \ 61 FUNCID_OEN_MASK) 62 63 /******************************************************************************* 64 * SMCCC_ARCH_SOC_ID SoC version & revision bit definition 65 ******************************************************************************/ 66 #define SOC_ID_JEP_106_BANK_IDX_MASK GENMASK_32(30, 24) 67 #define SOC_ID_JEP_106_BANK_IDX_SHIFT U(24) 68 #define SOC_ID_JEP_106_ID_CODE_MASK GENMASK_32(23, 16) 69 #define SOC_ID_JEP_106_ID_CODE_SHIFT U(16) 70 #define SOC_ID_IMPL_DEF_MASK GENMASK_32(15, 0) 71 #define SOC_ID_IMPL_DEF_SHIFT U(0) 72 #define SOC_ID_SET_JEP_106(bkid, mfid) ((((bkid) << SOC_ID_JEP_106_BANK_IDX_SHIFT) & \ 73 SOC_ID_JEP_106_BANK_IDX_MASK) | \ 74 (((mfid) << SOC_ID_JEP_106_ID_CODE_SHIFT) & \ 75 SOC_ID_JEP_106_ID_CODE_MASK)) 76 77 #define SOC_ID_REV_MASK GENMASK_32(30, 0) 78 #define SOC_ID_REV_SHIFT U(0) 79 80 /******************************************************************************* 81 * Owning entity number definitions inside the function id as per the SMC 82 * calling convention 83 ******************************************************************************/ 84 #define OEN_ARM_START U(0) 85 #define OEN_ARM_END U(0) 86 #define OEN_CPU_START U(1) 87 #define OEN_CPU_END U(1) 88 #define OEN_SIP_START U(2) 89 #define OEN_SIP_END U(2) 90 #define OEN_OEM_START U(3) 91 #define OEN_OEM_END U(3) 92 #define OEN_STD_START U(4) /* Standard Service Calls */ 93 #define OEN_STD_END U(4) 94 #define OEN_STD_HYP_START U(5) /* Standard Hypervisor Service calls */ 95 #define OEN_STD_HYP_END U(5) 96 #define OEN_VEN_HYP_START U(6) /* Vendor Hypervisor Service calls */ 97 #define OEN_VEN_HYP_END U(6) 98 #define OEN_TAP_START U(48) /* Trusted Applications */ 99 #define OEN_TAP_END U(49) 100 #define OEN_TOS_START U(50) /* Trusted OS */ 101 #define OEN_TOS_END U(63) 102 #define OEN_LIMIT U(64) 103 104 /* Flags and error codes */ 105 #define SMC_64 U(1) 106 #define SMC_32 U(0) 107 108 #define SMC_TYPE_FAST UL(1) 109 #define SMC_TYPE_YIELD UL(0) 110 111 #define SMC_OK ULL(0) 112 #define SMC_UNK -1 113 #define SMC_PREEMPTED -2 /* Not defined by the SMCCC */ 114 #define SMC_DENIED -3 /* Not defined by the SMCCC */ 115 #define SMC_INVALID_PARAM -4 /* Not defined by the SMCCC */ 116 117 /* Return codes for Arm Architecture Service SMC calls */ 118 #define SMC_ARCH_CALL_SUCCESS 0 119 #define SMC_ARCH_CALL_NOT_SUPPORTED -1 120 #define SMC_ARCH_CALL_NOT_REQUIRED -2 121 #define SMC_ARCH_CALL_INVAL_PARAM -3 122 123 /* 124 * Various flags passed to SMC handlers 125 * 126 * Bit 5 and bit 0 of the flag are used to 127 * determine the source security state as 128 * follows: 129 * --------------------------------- 130 * Bit 5 | Bit 0 | Security state 131 * --------------------------------- 132 * 0 0 SMC_FROM_SECURE 133 * 0 1 SMC_FROM_NON_SECURE 134 * 1 1 SMC_FROM_REALM 135 * 136 * Bit 16 of flags records the caller's SMC 137 * SVE hint bit according to SMCCCv1.3. 138 * It can be consumed by dispatchers using 139 * is_sve_hint_set macro. 140 * 141 */ 142 143 #define SMC_FROM_SECURE (U(0) << 0) 144 #define SMC_FROM_NON_SECURE (U(1) << 0) 145 #define SMC_FROM_REALM U(0x21) 146 #define SMC_FROM_MASK U(0x21) 147 148 #ifndef __ASSEMBLER__ 149 150 #include <stdint.h> 151 152 #include <lib/cassert.h> 153 154 #if ENABLE_RME 155 #define is_caller_non_secure(_f) (((_f) & SMC_FROM_MASK) \ 156 == SMC_FROM_NON_SECURE) 157 #define is_caller_secure(_f) (((_f) & SMC_FROM_MASK) \ 158 == SMC_FROM_SECURE) 159 #define is_caller_realm(_f) (((_f) & SMC_FROM_MASK) \ 160 == SMC_FROM_REALM) 161 #define caller_sec_state(_f) ((_f) & SMC_FROM_MASK) 162 #else /* ENABLE_RME */ 163 #define is_caller_non_secure(_f) (((_f) & SMC_FROM_NON_SECURE) != U(0)) 164 #define is_caller_secure(_f) (!is_caller_non_secure(_f)) 165 #endif /* ENABLE_RME */ 166 167 #define is_sve_hint_set(_f) (((_f) & (FUNCID_SVE_HINT_MASK \ 168 << FUNCID_SVE_HINT_SHIFT)) != U(0)) 169 170 /* The macro below is used to identify a Standard Service SMC call */ 171 #define is_std_svc_call(_fid) (GET_SMC_OEN(_fid) == OEN_STD_START) 172 173 /* The macro below is used to identify a Arm Architectural Service SMC call */ 174 #define is_arm_arch_svc_call(_fid) (GET_SMC_OEN(_fid) == OEN_ARM_START) 175 176 /* The macro below is used to identify a valid Fast SMC call */ 177 #define is_valid_fast_smc(_fid) ((!(((_fid) >> 16) & U(0xff))) && \ 178 (GET_SMC_TYPE(_fid) \ 179 == (uint32_t)SMC_TYPE_FAST)) 180 181 /* 182 * Macro to define UUID for services. Apart from defining and initializing a 183 * uuid_t structure, this macro verifies that the first word of the defined UUID 184 * does not equal SMC_UNK. This is to ensure that the caller won't mistake the 185 * returned UUID in x0 for an invalid SMC error return 186 */ 187 #define DEFINE_SVC_UUID2(_name, _tl, _tm, _th, _cl, _ch, \ 188 _n0, _n1, _n2, _n3, _n4, _n5) \ 189 CASSERT((uint32_t)(_tl) != (uint32_t)SMC_UNK, \ 190 invalid_svc_uuid_##_name); \ 191 static const uuid_t _name = { \ 192 {((_tl) >> 24) & 0xFF, \ 193 ((_tl) >> 16) & 0xFF, \ 194 ((_tl) >> 8) & 0xFF, \ 195 ((_tl) & 0xFF)}, \ 196 {((_tm) >> 8) & 0xFF, \ 197 ((_tm) & 0xFF)}, \ 198 {((_th) >> 8) & 0xFF, \ 199 ((_th) & 0xFF)}, \ 200 (_cl), (_ch), \ 201 { (_n0), (_n1), (_n2), (_n3), (_n4), (_n5) } \ 202 } 203 204 /* 205 * Return a UUID in the SMC return registers. 206 * 207 * Acccording to section 5.3 of the SMCCC, UUIDs are returned as a single 208 * 128-bit value using the SMC32 calling convention. This value is mapped to 209 * argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0 for example 210 * shall hold bytes 0 to 3, with byte 0 in the low-order bits. 211 */ 212 static inline uint32_t smc_uuid_word(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3) 213 { 214 return ((uint32_t) b0) | (((uint32_t) b1) << 8) | 215 (((uint32_t) b2) << 16) | (((uint32_t) b3) << 24); 216 } 217 218 #define SMC_UUID_RET(_h, _uuid) \ 219 SMC_RET4(handle, \ 220 smc_uuid_word((_uuid).time_low[0], (_uuid).time_low[1], \ 221 (_uuid).time_low[2], (_uuid).time_low[3]), \ 222 smc_uuid_word((_uuid).time_mid[0], (_uuid).time_mid[1], \ 223 (_uuid).time_hi_and_version[0], \ 224 (_uuid).time_hi_and_version[1]), \ 225 smc_uuid_word((_uuid).clock_seq_hi_and_reserved, \ 226 (_uuid).clock_seq_low, (_uuid).node[0], \ 227 (_uuid).node[1]), \ 228 smc_uuid_word((_uuid).node[2], (_uuid).node[3], \ 229 (_uuid).node[4], (_uuid).node[5])) 230 231 #endif /*__ASSEMBLER__*/ 232 #endif /* SMCCC_H */ 233