1 /* 2 * Copyright (c) 2022, ARM Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #ifndef SPMC_H 8 #define SPMC_H 9 10 #include <stdint.h> 11 12 #include <lib/psci/psci.h> 13 #include <lib/spinlock.h> 14 #include <services/el3_spmc_logical_sp.h> 15 #include "spm_common.h" 16 17 /* 18 * Ranges of FF-A IDs for Normal world and Secure world components. The 19 * convention matches that used by other SPMCs i.e. Hafnium and OP-TEE. 20 */ 21 #define FFA_NWD_ID_BASE 0x0 22 #define FFA_NWD_ID_LIMIT 0x7FFF 23 #define FFA_SWD_ID_BASE 0x8000 24 #define FFA_SWD_ID_LIMIT SPMD_DIRECT_MSG_ENDPOINT_ID - 1 25 #define FFA_SWD_ID_MASK 0x8000 26 27 /* ID 0 is reserved for the normal world entity, (Hypervisor or OS Kernel). */ 28 #define FFA_NWD_ID U(0) 29 /* First ID is reserved for the SPMC */ 30 #define FFA_SPMC_ID U(FFA_SWD_ID_BASE) 31 /* SP IDs are allocated after the SPMC ID */ 32 #define FFA_SP_ID_BASE (FFA_SPMC_ID + 1) 33 /* Align with Hafnium implementation */ 34 #define INV_SP_ID 0x7FFF 35 36 /* FF-A warm boot types. */ 37 #define FFA_WB_TYPE_S2RAM 0 38 #define FFA_WB_TYPE_NOTS2RAM 1 39 40 /* FF-A Related helper macros. */ 41 #define FFA_FEATURES_BIT31_MASK U(0x1u << 31) 42 43 #define FFA_PAGE_SIZE (4096) 44 #define FFA_RXTX_PAGE_COUNT_MASK 0x1F 45 46 /* Ensure that the page size used by TF-A is 4k aligned. */ 47 CASSERT((PAGE_SIZE % FFA_PAGE_SIZE) == 0, assert_aligned_page_size); 48 49 /* 50 * Runtime states of an execution context as per the FF-A v1.1 specification. 51 */ 52 enum sp_runtime_states { 53 RT_STATE_WAITING, 54 RT_STATE_RUNNING, 55 RT_STATE_PREEMPTED, 56 RT_STATE_BLOCKED 57 }; 58 59 /* 60 * Runtime model of an execution context as per the FF-A v1.1 specification. Its 61 * value is valid only if the execution context is not in the waiting state. 62 */ 63 enum sp_runtime_model { 64 RT_MODEL_DIR_REQ, 65 RT_MODEL_RUN, 66 RT_MODEL_INIT, 67 RT_MODEL_INTR 68 }; 69 70 enum sp_runtime_el { 71 EL1 = 0, 72 S_EL0, 73 S_EL1 74 }; 75 76 enum sp_execution_state { 77 SP_STATE_AARCH64 = 0, 78 SP_STATE_AARCH32 79 }; 80 81 enum mailbox_state { 82 /* There is no message in the mailbox. */ 83 MAILBOX_STATE_EMPTY, 84 85 /* There is a message that has been populated in the mailbox. */ 86 MAILBOX_STATE_FULL, 87 }; 88 89 struct mailbox { 90 enum mailbox_state state; 91 92 /* RX/TX Buffers. */ 93 void *rx_buffer; 94 const void *tx_buffer; 95 96 /* Size of RX/TX Buffer. */ 97 uint32_t rxtx_page_count; 98 99 /* Lock access to mailbox. */ 100 spinlock_t lock; 101 }; 102 103 /* 104 * Execution context members for an SP. This is a bit like struct 105 * vcpu in a hypervisor. 106 */ 107 struct sp_exec_ctx { 108 /* 109 * Store the stack address to restore C runtime context from after 110 * returning from a synchronous entry into the SP. 111 */ 112 uint64_t c_rt_ctx; 113 114 /* Space to maintain the architectural state of an SP. */ 115 cpu_context_t cpu_ctx; 116 117 /* Track the current runtime state of the SP. */ 118 enum sp_runtime_states rt_state; 119 120 /* Track the current runtime model of the SP. */ 121 enum sp_runtime_model rt_model; 122 }; 123 124 /* 125 * Structure to describe the cumulative properties of an SP. 126 */ 127 struct secure_partition_desc { 128 /* 129 * Execution contexts allocated to this endpoint. Ideally, 130 * we need as many contexts as there are physical cpus only 131 * for a S-EL1 SP which is MP-pinned. 132 */ 133 struct sp_exec_ctx ec[PLATFORM_CORE_COUNT]; 134 135 /* ID of the Secure Partition. */ 136 uint16_t sp_id; 137 138 /* Runtime EL. */ 139 enum sp_runtime_el runtime_el; 140 141 /* Partition UUID. */ 142 uint32_t uuid[4]; 143 144 /* Partition Properties. */ 145 uint32_t properties; 146 147 /* Supported FF-A Version. */ 148 uint32_t ffa_version; 149 150 /* Execution State. */ 151 enum sp_execution_state execution_state; 152 153 /* Mailbox tracking. */ 154 struct mailbox mailbox; 155 156 /* Secondary entrypoint. Only valid for a S-EL1 SP. */ 157 uintptr_t secondary_ep; 158 }; 159 160 /* 161 * This define identifies the only SP that will be initialised and participate 162 * in FF-A communication. The implementation leaves the door open for more SPs 163 * to be managed in future but for now it is reasonable to assume that either a 164 * single S-EL0 or a single S-EL1 SP will be supported. This define will be used 165 * to identify which SP descriptor to initialise and manage during SP runtime. 166 */ 167 #define ACTIVE_SP_DESC_INDEX 0 168 169 /* 170 * Structure to describe the cumulative properties of the Hypervisor and 171 * NS-Endpoints. 172 */ 173 struct ns_endpoint_desc { 174 /* 175 * ID of the NS-Endpoint or Hypervisor. 176 */ 177 uint16_t ns_ep_id; 178 179 /* 180 * Mailbox tracking. 181 */ 182 struct mailbox mailbox; 183 184 /* 185 * Supported FF-A Version 186 */ 187 uint32_t ffa_version; 188 }; 189 190 /** 191 * Holds information returned for each partition by the FFA_PARTITION_INFO_GET 192 * interface. 193 */ 194 struct ffa_partition_info_v1_0 { 195 uint16_t ep_id; 196 uint16_t execution_ctx_count; 197 uint32_t properties; 198 }; 199 200 /* Extended structure for v1.1. */ 201 struct ffa_partition_info_v1_1 { 202 uint16_t ep_id; 203 uint16_t execution_ctx_count; 204 uint32_t properties; 205 uint32_t uuid[4]; 206 }; 207 208 /* Setup Function for different SP types. */ 209 void spmc_sp_common_setup(struct secure_partition_desc *sp, 210 entry_point_info_t *ep_info); 211 void spmc_el1_sp_setup(struct secure_partition_desc *sp, 212 entry_point_info_t *ep_info); 213 void spmc_sp_common_ep_commit(struct secure_partition_desc *sp, 214 entry_point_info_t *ep_info); 215 216 /* 217 * Helper function to perform a synchronous entry into a SP. 218 */ 219 uint64_t spmc_sp_synchronous_entry(struct sp_exec_ctx *ec); 220 221 /* 222 * Helper function to obtain the descriptor of the current SP on a physical cpu. 223 */ 224 struct secure_partition_desc *spmc_get_current_sp_ctx(void); 225 226 /* 227 * Helper function to obtain the execution context of an SP on a 228 * physical cpu. 229 */ 230 struct sp_exec_ctx *spmc_get_sp_ec(struct secure_partition_desc *sp); 231 232 /* 233 * Helper function to obtain the index of the execution context of an SP on a 234 * physical cpu. 235 */ 236 unsigned int get_ec_index(struct secure_partition_desc *sp); 237 238 uint64_t spmc_ffa_error_return(void *handle, int error_code); 239 240 /* 241 * Ensure a partition ID does not clash and follows the secure world convention. 242 */ 243 bool is_ffa_secure_id_valid(uint16_t partition_id); 244 245 /* 246 * Helper function to obtain the array storing the EL3 247 * Logical Partition descriptors. 248 */ 249 struct el3_lp_desc *get_el3_lp_array(void); 250 251 /* 252 * Helper function to obtain the RX/TX buffer pair descriptor of the Hypervisor 253 * or OS kernel in the normal world or the last SP that was run. 254 */ 255 struct mailbox *spmc_get_mbox_desc(bool secure_origin); 256 257 #endif /* SPMC_H */ 258