include/lib/smccc.h

   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 */