1 /* 2 * Copyright (c) 2016-2018, 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 <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 #if SMCCC_MAJOR_VERSION == 1 23 # define SMCCC_MINOR_VERSION U(1) 24 # include <smccc_v1.h> 25 #elif SMCCC_MAJOR_VERSION == 2 26 # define SMCCC_MINOR_VERSION U(0) 27 # include <smccc_v2.h> 28 #else 29 # error "Unsupported version of SMCCC." 30 #endif 31 32 /* Various flags passed to SMC handlers */ 33 #define SMC_FROM_SECURE (U(0) << 0) 34 #define SMC_FROM_NON_SECURE (U(1) << 0) 35 36 #ifndef __ASSEMBLY__ 37 38 #include <cassert.h> 39 #include <stdint.h> 40 41 #define is_caller_non_secure(_f) (((_f) & SMC_FROM_NON_SECURE) != U(0)) 42 #define is_caller_secure(_f) (!is_caller_non_secure(_f)) 43 44 /* The macro below is used to identify a Standard Service SMC call */ 45 #define is_std_svc_call(_fid) (GET_SMC_OEN(_fid) == OEN_STD_START) 46 47 /* The macro below is used to identify a Arm Architectural Service SMC call */ 48 #define is_arm_arch_svc_call(_fid) (GET_SMC_OEN(_fid) == OEN_ARM_START) 49 50 /* The macro below is used to identify a valid Fast SMC call */ 51 #define is_valid_fast_smc(_fid) ((!(((_fid) >> 16) & U(0xff))) && \ 52 (GET_SMC_TYPE(_fid) == SMC_TYPE_FAST)) 53 54 /* 55 * Macro to define UUID for services. Apart from defining and initializing a 56 * uuid_t structure, this macro verifies that the first word of the defined UUID 57 * does not equal SMC_UNK. This is to ensure that the caller won't mistake the 58 * returned UUID in x0 for an invalid SMC error return 59 */ 60 #if !ERROR_DEPRECATED 61 #define DEFINE_SVC_UUID(_name, _tl, _tm, _th, _cl, _ch, \ 62 _n0, _n1, _n2, _n3, _n4, _n5) \ 63 CASSERT((uint32_t)(_tl) != (uint32_t) SMC_UNK, invalid_svc_uuid);\ 64 static const uuid_t _name = { \ 65 _tl, _tm, _th, _cl, _ch, \ 66 { _n0, _n1, _n2, _n3, _n4, _n5 } \ 67 } 68 #endif 69 70 71 #define DEFINE_SVC_UUID2(_name, _tl, _tm, _th, _cl, _ch, \ 72 _n0, _n1, _n2, _n3, _n4, _n5) \ 73 CASSERT((uint32_t)(_tl) != (uint32_t) SMC_UNK, invalid_svc_uuid);\ 74 static const uuid_t _name = { \ 75 {(_tl >> 24) & 0xFF, \ 76 (_tl >> 16) & 0xFF, \ 77 (_tl >> 8) & 0xFF, \ 78 (_tl & 0xFF)}, \ 79 {(_tm >> 8) & 0xFF, \ 80 (_tm & 0xFF)}, \ 81 {(_th >> 8) & 0xFF, \ 82 (_th & 0xFF)}, \ 83 _cl, _ch, \ 84 { _n0, _n1, _n2, _n3, _n4, _n5 } \ 85 } 86 87 /* 88 * Return a UUID in the SMC return registers. 89 * 90 * Acccording to section 5.3 of the SMCCC, UUIDs are returned as a single 91 * 128-bit value using the SMC32 calling convention. This value is mapped to 92 * argument registers x0-x3 on AArch64 (resp. r0-r3 on AArch32). x0 for example 93 * shall hold bytes 0 to 3, with byte 0 in the low-order bits. 94 */ 95 static inline uint32_t smc_uuid_word(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3) 96 { 97 return ((uint32_t) b0) | (((uint32_t) b1) << 8) | 98 (((uint32_t) b2) << 16) | (((uint32_t) b3) << 24); 99 } 100 101 #define SMC_UUID_RET(_h, _uuid) \ 102 SMC_RET4(handle, \ 103 smc_uuid_word((_uuid).time_low[0], (_uuid).time_low[1], \ 104 (_uuid).time_low[2], (_uuid).time_low[3]), \ 105 smc_uuid_word((_uuid).time_mid[0], (_uuid).time_mid[1], \ 106 (_uuid).time_hi_and_version[0], \ 107 (_uuid).time_hi_and_version[1]), \ 108 smc_uuid_word((_uuid).clock_seq_hi_and_reserved, \ 109 (_uuid).clock_seq_low, (_uuid).node[0], \ 110 (_uuid).node[1]), \ 111 smc_uuid_word((_uuid).node[2], (_uuid).node[3], \ 112 (_uuid).node[4], (_uuid).node[5])) 113 114 #endif /*__ASSEMBLY__*/ 115 #endif /* __SMCCC_H__ */ 116