1 /* 2 * Copyright (c) 2013-2025, Arm Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <assert.h> 8 #include <string.h> 9 10 #include <arch.h> 11 #include <arch_features.h> 12 #include <arch_helpers.h> 13 #include <bl31/bl31.h> 14 #include <bl31/ehf.h> 15 #include <common/bl_common.h> 16 #include <common/build_message.h> 17 #include <common/debug.h> 18 #include <common/feat_detect.h> 19 #include <common/runtime_svc.h> 20 #include <drivers/arm/dsu.h> 21 #include <drivers/arm/gic.h> 22 #include <drivers/console.h> 23 #include <lib/bootmarker_capture.h> 24 #include <lib/el3_runtime/context_debug.h> 25 #include <lib/el3_runtime/context_mgmt.h> 26 #include <lib/pmf/pmf.h> 27 #include <lib/runtime_instr.h> 28 #include <plat/common/platform.h> 29 #include <services/std_svc.h> 30 31 #if ENABLE_RUNTIME_INSTRUMENTATION 32 PMF_REGISTER_SERVICE_SMC(rt_instr_svc, PMF_RT_INSTR_SVC_ID, 33 RT_INSTR_TOTAL_IDS, PMF_STORE_ENABLE) 34 #endif 35 36 #if ENABLE_RUNTIME_INSTRUMENTATION 37 PMF_REGISTER_SERVICE(bl_svc, PMF_RT_INSTR_SVC_ID, 38 BL_TOTAL_IDS, PMF_DUMP_ENABLE) 39 #endif 40 41 /******************************************************************************* 42 * This function pointer is used to initialise the BL32 image. It's initialized 43 * by SPD calling bl31_register_bl32_init after setting up all things necessary 44 * for SP execution. In cases where both SPD and SP are absent, or when SPD 45 * finds it impossible to execute SP, this pointer is left as NULL 46 ******************************************************************************/ 47 static int32_t (*bl32_init)(void); 48 49 /***************************************************************************** 50 * Function used to initialise RMM if RME is enabled 51 *****************************************************************************/ 52 #if ENABLE_RME 53 static int32_t (*rmm_init)(void); 54 #endif 55 56 /******************************************************************************* 57 * Variable to indicate whether next image to execute after BL31 is BL33 58 * (non-secure & default) or BL32 (secure). 59 ******************************************************************************/ 60 static uint32_t next_image_type = (uint32_t)NON_SECURE; 61 62 #ifdef SUPPORT_UNKNOWN_MPID 63 /* 64 * Flag to know whether an unsupported MPID has been detected. To avoid having it 65 * landing on the .bss section, it is initialized to a non-zero value, this way 66 * we avoid potential WAW hazards during system bring up. 67 * */ 68 volatile uint32_t unsupported_mpid_flag = 1; 69 #endif 70 71 /* 72 * Implement the ARM Standard Service function to get arguments for a 73 * particular service. 74 */ 75 uintptr_t get_arm_std_svc_args(unsigned int svc_mask) 76 { 77 /* Setup the arguments for PSCI Library */ 78 DEFINE_STATIC_PSCI_LIB_ARGS_V1(psci_args, bl31_warm_entrypoint); 79 80 /* PSCI is the only ARM Standard Service implemented */ 81 assert(svc_mask == PSCI_FID_MASK); 82 83 return (uintptr_t)&psci_args; 84 } 85 86 /******************************************************************************* 87 * Simple function to initialise all BL31 helper libraries. 88 ******************************************************************************/ 89 static void __init bl31_lib_init(void) 90 { 91 cm_init(); 92 } 93 94 /******************************************************************************* 95 * Setup function for BL31. 96 ******************************************************************************/ 97 void bl31_setup(u_register_t arg0, u_register_t arg1, u_register_t arg2, 98 u_register_t arg3) 99 { 100 #if FEATURE_DETECTION 101 /* Detect if features enabled during compilation are supported by PE. */ 102 detect_arch_features(plat_my_core_pos()); 103 #endif /* FEATURE_DETECTION */ 104 105 /* Enable early console if EARLY_CONSOLE flag is enabled */ 106 plat_setup_early_console(); 107 108 /* Perform early platform-specific setup */ 109 bl31_early_platform_setup2(arg0, arg1, arg2, arg3); 110 111 /* Perform late platform-specific setup */ 112 bl31_plat_arch_setup(); 113 114 /* Prints context_memory allocated for all the security states */ 115 report_ctx_memory_usage(); 116 } 117 118 /******************************************************************************* 119 * BL31 is responsible for setting up the runtime services for the primary cpu 120 * before passing control to the bootloader or an Operating System. This 121 * function calls runtime_svc_init() which initializes all registered runtime 122 * services. The run time services would setup enough context for the core to 123 * switch to the next exception level. When this function returns, the core will 124 * switch to the programmed exception level via an ERET. 125 ******************************************************************************/ 126 void bl31_main(void) 127 { 128 unsigned int core_pos = plat_my_core_pos(); 129 130 /* Init registers that never change for the lifetime of TF-A */ 131 cm_manage_extensions_el3(core_pos); 132 133 /* Init per-world context registers */ 134 cm_manage_extensions_per_world(); 135 136 NOTICE("BL31: %s\n", build_version_string); 137 NOTICE("BL31: %s\n", build_message); 138 139 #if ENABLE_RUNTIME_INSTRUMENTATION 140 PMF_CAPTURE_TIMESTAMP(bl_svc, BL31_ENTRY, PMF_CACHE_MAINT); 141 #endif 142 143 #ifdef SUPPORT_UNKNOWN_MPID 144 if (unsupported_mpid_flag == 0) { 145 NOTICE("Unsupported MPID detected!\n"); 146 } 147 #endif 148 149 /* Perform platform setup in BL31 */ 150 bl31_platform_setup(); 151 152 #if USE_DSU_DRIVER 153 dsu_driver_init(&plat_dsu_data); 154 #endif 155 156 #if USE_GIC_DRIVER 157 /* 158 * Initialize the GIC driver as well as per-cpu and global interfaces. 159 * Platform has had an opportunity to initialise specifics. 160 */ 161 gic_init(core_pos); 162 gic_pcpu_init(core_pos); 163 gic_cpuif_enable(core_pos); 164 #endif /* USE_GIC_DRIVER */ 165 166 /* Initialise helper libraries */ 167 bl31_lib_init(); 168 169 #if EL3_EXCEPTION_HANDLING 170 INFO("BL31: Initialising Exception Handling Framework\n"); 171 ehf_init(); 172 #endif 173 174 /* Initialize the runtime services e.g. psci. */ 175 INFO("BL31: Initializing runtime services\n"); 176 runtime_svc_init(); 177 178 /* 179 * All the cold boot actions on the primary cpu are done. We now need to 180 * decide which is the next image and how to execute it. 181 * If the SPD runtime service is present, it would want to pass control 182 * to BL32 first in S-EL1. In that case, SPD would have registered a 183 * function to initialize bl32 where it takes responsibility of entering 184 * S-EL1 and returning control back to bl31_main. Similarly, if RME is 185 * enabled and a function is registered to initialize RMM, control is 186 * transferred to RMM in R-EL2. After RMM initialization, control is 187 * returned back to bl31_main. Once this is done we can prepare entry 188 * into BL33 as normal. 189 */ 190 191 /* 192 * If SPD had registered an init hook, invoke it. 193 */ 194 if (bl32_init != NULL) { 195 INFO("BL31: Initializing BL32\n"); 196 197 console_flush(); 198 int32_t rc = (*bl32_init)(); 199 200 if (rc == 0) { 201 WARN("BL31: BL32 initialization failed\n"); 202 } 203 } 204 205 /* 206 * If RME is enabled and init hook is registered, initialize RMM 207 * in R-EL2. 208 */ 209 #if ENABLE_RME 210 if (rmm_init != NULL) { 211 INFO("BL31: Initializing RMM\n"); 212 213 console_flush(); 214 int32_t rc = (*rmm_init)(); 215 216 if (rc == 0) { 217 WARN("BL31: RMM initialization failed\n"); 218 } 219 } 220 #endif 221 222 /* 223 * We are ready to enter the next EL. Prepare entry into the image 224 * corresponding to the desired security state after the next ERET. 225 */ 226 bl31_prepare_next_image_entry(); 227 228 /* 229 * Perform any platform specific runtime setup prior to cold boot exit 230 * from BL31 231 */ 232 bl31_plat_runtime_setup(); 233 234 #if ENABLE_RUNTIME_INSTRUMENTATION 235 console_flush(); 236 PMF_CAPTURE_TIMESTAMP(bl_svc, BL31_EXIT, PMF_CACHE_MAINT); 237 #endif 238 239 console_flush(); 240 console_switch_state(CONSOLE_FLAG_RUNTIME); 241 } 242 243 /******************************************************************************* 244 * Accessor functions to help runtime services decide which image should be 245 * executed after BL31. This is BL33 or the non-secure bootloader image by 246 * default but the Secure payload dispatcher could override this by requesting 247 * an entry into BL32 (Secure payload) first. If it does so then it should use 248 * the same API to program an entry into BL33 once BL32 initialisation is 249 * complete. 250 ******************************************************************************/ 251 void bl31_set_next_image_type(uint32_t security_state) 252 { 253 assert(sec_state_is_valid(security_state)); 254 next_image_type = security_state; 255 } 256 257 static uint32_t bl31_get_next_image_type(void) 258 { 259 return next_image_type; 260 } 261 262 /******************************************************************************* 263 * This function programs EL3 registers and performs other setup to enable entry 264 * into the next image after BL31 at the next ERET. 265 ******************************************************************************/ 266 void __init bl31_prepare_next_image_entry(void) 267 { 268 const entry_point_info_t *next_image_info; 269 uint32_t image_type; 270 271 #if CTX_INCLUDE_AARCH32_REGS 272 /* 273 * Ensure that the build flag to save AArch32 system registers in CPU 274 * context is not set for AArch64-only platforms. 275 */ 276 if (el_implemented(1) == EL_IMPL_A64ONLY) { 277 ERROR("EL1 supports AArch64-only. Please set build flag " 278 "CTX_INCLUDE_AARCH32_REGS = 0\n"); 279 panic(); 280 } 281 #endif 282 283 /* Determine which image to execute next */ 284 image_type = bl31_get_next_image_type(); 285 286 /* Program EL3 registers to enable entry into the next EL */ 287 next_image_info = bl31_plat_get_next_image_ep_info(image_type); 288 assert(next_image_info != NULL); 289 assert(image_type == GET_SECURITY_STATE(next_image_info->h.attr)); 290 291 INFO("BL31: Preparing for EL3 exit to %s world\n", 292 (image_type == SECURE) ? "secure" : "normal"); 293 print_entry_point_info(next_image_info); 294 cm_init_my_context(next_image_info); 295 296 /* 297 * If we are entering the Non-secure world, use 298 * 'cm_prepare_el3_exit_ns' to exit. 299 */ 300 if (image_type == NON_SECURE) { 301 cm_prepare_el3_exit_ns(); 302 } else { 303 cm_prepare_el3_exit(image_type); 304 } 305 } 306 307 /******************************************************************************* 308 * This function initializes the pointer to BL32 init function. This is expected 309 * to be called by the SPD after it finishes all its initialization 310 ******************************************************************************/ 311 void bl31_register_bl32_init(int32_t (*func)(void)) 312 { 313 bl32_init = func; 314 } 315 316 #if ENABLE_RME 317 /******************************************************************************* 318 * This function initializes the pointer to RMM init function. This is expected 319 * to be called by the RMMD after it finishes all its initialization 320 ******************************************************************************/ 321 void bl31_register_rmm_init(int32_t (*func)(void)) 322 { 323 rmm_init = func; 324 } 325 #endif 326