1 /* 2 * Copyright (c) 2016-2019, 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(1) 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_NUM_SHIFT U(0) 41 #define FUNCID_NUM_MASK U(0xffff) 42 #define FUNCID_NUM_WIDTH U(16) 43 44 #define GET_SMC_TYPE(id) (((id) >> FUNCID_TYPE_SHIFT) & \ 45 FUNCID_TYPE_MASK) 46 #define GET_SMC_CC(id) (((id) >> FUNCID_CC_SHIFT) & \ 47 FUNCID_CC_MASK) 48 #define GET_SMC_OEN(id) (((id) >> FUNCID_OEN_SHIFT) & \ 49 FUNCID_OEN_MASK) 50 51 /******************************************************************************* 52 * Owning entity number definitions inside the function id as per the SMC 53 * calling convention 54 ******************************************************************************/ 55 #define OEN_ARM_START U(0) 56 #define OEN_ARM_END U(0) 57 #define OEN_CPU_START U(1) 58 #define OEN_CPU_END U(1) 59 #define OEN_SIP_START U(2) 60 #define OEN_SIP_END U(2) 61 #define OEN_OEM_START U(3) 62 #define OEN_OEM_END U(3) 63 #define OEN_STD_START U(4) /* Standard Service Calls */ 64 #define OEN_STD_END U(4) 65 #define OEN_STD_HYP_START U(5) /* Standard Hypervisor Service calls */ 66 #define OEN_STD_HYP_END U(5) 67 #define OEN_VEN_HYP_START U(6) /* Vendor Hypervisor Service calls */ 68 #define OEN_VEN_HYP_END U(6) 69 #define OEN_TAP_START U(48) /* Trusted Applications */ 70 #define OEN_TAP_END U(49) 71 #define OEN_TOS_START U(50) /* Trusted OS */ 72 #define OEN_TOS_END U(63) 73 #define OEN_LIMIT U(64) 74 75 /* Flags and error codes */ 76 #define SMC_64 U(1) 77 #define SMC_32 U(0) 78 79 #define SMC_TYPE_FAST ULL(1) 80 #define SMC_TYPE_YIELD ULL(0) 81 82 #define SMC_OK ULL(0) 83 #define SMC_UNK -1 84 #define SMC_PREEMPTED -2 /* Not defined by the SMCCC */ 85 86 /* Various flags passed to SMC handlers */ 87 #define SMC_FROM_SECURE (U(0) << 0) 88 #define SMC_FROM_NON_SECURE (U(1) << 0) 89 90 #ifndef __ASSEMBLY__ 91 92 #include <stdint.h> 93 94 #include <lib/cassert.h> 95 96 #define is_caller_non_secure(_f) (((_f) & SMC_FROM_NON_SECURE) != U(0)) 97 #define is_caller_secure(_f) (!is_caller_non_secure(_f)) 98 99 /* The macro below is used to identify a Standard Service SMC call */ 100 #define is_std_svc_call(_fid) (GET_SMC_OEN(_fid) == OEN_STD_START) 101 102 /* The macro below is used to identify a Arm Architectural Service SMC call */ 103 #define is_arm_arch_svc_call(_fid) (GET_SMC_OEN(_fid) == OEN_ARM_START) 104 105 /* The macro below is used to identify a valid Fast SMC call */ 106 #define is_valid_fast_smc(_fid) ((!(((_fid) >> 16) & U(0xff))) && \ 107 (GET_SMC_TYPE(_fid) == SMC_TYPE_FAST)) 108 109 /* 110 * Macro to define UUID for services. Apart from defining and initializing a 111 * uuid_t structure, this macro verifies that the first word of the defined UUID 112 * does not equal SMC_UNK. This is to ensure that the caller won't mistake the 113 * returned UUID in x0 for an invalid SMC error return 114 */ 115 #define DEFINE_SVC_UUID2(_name, _tl, _tm, _th, _cl, _ch, \ 116 _n0, _n1, _n2, _n3, _n4, _n5) \ 117 CASSERT((uint32_t)(_tl) != (uint32_t) SMC_UNK, invalid_svc_uuid);\ 118 static const uuid_t _name = { \ 119 {(_tl >> 24) & 0xFF, \ 120 (_tl >> 16) & 0xFF, \ 121 (_tl >> 8) & 0xFF, \ 122 (_tl & 0xFF)}, \ 123 {(_tm >> 8) & 0xFF, \ 124 (_tm & 0xFF)}, \ 125 {(_th >> 8) & 0xFF, \ 126 (_th & 0xFF)}, \ 127 _cl, _ch, \ 128 { _n0, _n1, _n2, _n3, _n4, _n5 } \ 129 } 130 131 /* 132 * Return a UUID in the SMC return registers. 133 * 134 * Acccording to section 5.3 of the SMCCC, UUIDs are returned as a single 135 * 128-bit value using the SMC32 calling convention. This value is mapped to 136 * argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0 for example 137 * shall hold bytes 0 to 3, with byte 0 in the low-order bits. 138 */ 139 static inline uint32_t smc_uuid_word(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3) 140 { 141 return ((uint32_t) b0) | (((uint32_t) b1) << 8) | 142 (((uint32_t) b2) << 16) | (((uint32_t) b3) << 24); 143 } 144 145 #define SMC_UUID_RET(_h, _uuid) \ 146 SMC_RET4(handle, \ 147 smc_uuid_word((_uuid).time_low[0], (_uuid).time_low[1], \ 148 (_uuid).time_low[2], (_uuid).time_low[3]), \ 149 smc_uuid_word((_uuid).time_mid[0], (_uuid).time_mid[1], \ 150 (_uuid).time_hi_and_version[0], \ 151 (_uuid).time_hi_and_version[1]), \ 152 smc_uuid_word((_uuid).clock_seq_hi_and_reserved, \ 153 (_uuid).clock_seq_low, (_uuid).node[0], \ 154 (_uuid).node[1]), \ 155 smc_uuid_word((_uuid).node[2], (_uuid).node[3], \ 156 (_uuid).node[4], (_uuid).node[5])) 157 158 #endif /*__ASSEMBLY__*/ 159 #endif /* SMCCC_H */ 160