1 /* 2 * Copyright (c) 2013-2024, Arm Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #ifndef PLATFORM_H 8 #define PLATFORM_H 9 10 #include <stdint.h> 11 12 #include <lib/psci/psci.h> 13 #if defined(SPD_spmd) 14 #include <services/spm_core_manifest.h> 15 #endif 16 #if ENABLE_RME 17 #include <services/rmm_core_manifest.h> 18 #include <services/rmm_el3_token_sign.h> 19 #endif 20 #include <drivers/fwu/fwu_metadata.h> 21 #if TRNG_SUPPORT 22 #include "plat_trng.h" 23 #endif /* TRNG_SUPPORT */ 24 #if DRTM_SUPPORT 25 #include "plat_drtm.h" 26 #endif /* DRTM_SUPPORT */ 27 28 /******************************************************************************* 29 * Forward declarations 30 ******************************************************************************/ 31 struct auth_img_desc_s; 32 struct meminfo; 33 struct image_info; 34 struct entry_point_info; 35 struct image_desc; 36 struct bl_load_info; 37 struct bl_params; 38 struct mmap_region; 39 struct spm_mm_boot_info; 40 struct sp_res_desc; 41 struct rmm_manifest; 42 enum fw_enc_status_t; 43 44 /******************************************************************************* 45 * Structure populated by platform specific code to export routines which 46 * perform load images functions, and associated pointer to platform ops 47 ******************************************************************************/ 48 struct plat_try_images_ops { 49 int (*next_instance)(unsigned int image_id); 50 }; 51 52 extern const struct plat_try_images_ops *plat_try_img_ops; 53 54 /******************************************************************************* 55 * plat_get_rotpk_info() flags 56 ******************************************************************************/ 57 #define ROTPK_IS_HASH (1 << 0) 58 59 /* Flag used to skip verification of the certificate ROTPK while the platform 60 ROTPK is not deployed */ 61 #define ROTPK_NOT_DEPLOYED (1 << 1) 62 63 static inline bool is_rotpk_flags_valid(unsigned int flags) 64 { 65 unsigned int valid_flags = ROTPK_IS_HASH; 66 return (flags == ROTPK_NOT_DEPLOYED) || ((flags & ~valid_flags) == 0); 67 } 68 69 /******************************************************************************* 70 * plat_get_enc_key_info() flags 71 ******************************************************************************/ 72 /* 73 * Flag used to notify caller that information provided in key buffer is an 74 * identifier rather than an actual key. 75 */ 76 #define ENC_KEY_IS_IDENTIFIER (1 << 0) 77 78 /******************************************************************************* 79 * Function declarations 80 ******************************************************************************/ 81 /******************************************************************************* 82 * Mandatory common functions 83 ******************************************************************************/ 84 unsigned int plat_get_syscnt_freq2(void); 85 86 int plat_get_image_source(unsigned int image_id, 87 uintptr_t *dev_handle, 88 uintptr_t *image_spec); 89 uintptr_t plat_get_ns_image_entrypoint(void); 90 unsigned int plat_my_core_pos(void); 91 int plat_core_pos_by_mpidr(u_register_t mpidr); 92 int plat_get_mbedtls_heap(void **heap_addr, size_t *heap_size); 93 94 /******************************************************************************* 95 * Simple routine to determine whether a mpidr is valid or not. 96 ******************************************************************************/ 97 static inline bool is_valid_mpidr(u_register_t mpidr) 98 { 99 int pos = plat_core_pos_by_mpidr(mpidr); 100 101 if ((pos < 0) || ((unsigned int)pos >= PLATFORM_CORE_COUNT)) { 102 return false; 103 } 104 105 return true; 106 } 107 108 #if STACK_PROTECTOR_ENABLED 109 /* 110 * Return a new value to be used for the stack protection's canary. 111 * 112 * Ideally, this value is a random number that is impossible to predict by an 113 * attacker. 114 */ 115 u_register_t plat_get_stack_protector_canary(void); 116 #endif /* STACK_PROTECTOR_ENABLED */ 117 118 /******************************************************************************* 119 * Mandatory interrupt management functions 120 ******************************************************************************/ 121 uint32_t plat_ic_get_pending_interrupt_id(void); 122 uint32_t plat_ic_get_pending_interrupt_type(void); 123 uint32_t plat_ic_acknowledge_interrupt(void); 124 uint32_t plat_ic_get_interrupt_type(uint32_t id); 125 void plat_ic_end_of_interrupt(uint32_t id); 126 uint32_t plat_interrupt_type_to_line(uint32_t type, 127 uint32_t security_state); 128 129 /******************************************************************************* 130 * Optional interrupt management functions, depending on chosen EL3 components. 131 ******************************************************************************/ 132 unsigned int plat_ic_get_running_priority(void); 133 int plat_ic_is_spi(unsigned int id); 134 int plat_ic_is_ppi(unsigned int id); 135 int plat_ic_is_sgi(unsigned int id); 136 unsigned int plat_ic_get_interrupt_active(unsigned int id); 137 void plat_ic_disable_interrupt(unsigned int id); 138 void plat_ic_enable_interrupt(unsigned int id); 139 bool plat_ic_has_interrupt_type(unsigned int type); 140 void plat_ic_set_interrupt_type(unsigned int id, unsigned int type); 141 void plat_ic_set_interrupt_priority(unsigned int id, unsigned int priority); 142 void plat_ic_raise_el3_sgi(int sgi_num, u_register_t target); 143 void plat_ic_raise_ns_sgi(int sgi_num, u_register_t target); 144 void plat_ic_raise_s_el1_sgi(int sgi_num, u_register_t target); 145 void plat_ic_set_spi_routing(unsigned int id, unsigned int routing_mode, 146 u_register_t mpidr); 147 void plat_ic_set_interrupt_pending(unsigned int id); 148 void plat_ic_clear_interrupt_pending(unsigned int id); 149 unsigned int plat_ic_set_priority_mask(unsigned int mask); 150 unsigned int plat_ic_deactivate_priority(unsigned int mask); 151 unsigned int plat_ic_get_interrupt_id(unsigned int raw); 152 153 /******************************************************************************* 154 * Optional common functions (may be overridden) 155 ******************************************************************************/ 156 uintptr_t plat_get_my_stack(void); 157 void plat_report_exception(unsigned int exception_type); 158 void plat_report_prefetch_abort(unsigned int fault_address); 159 void plat_report_data_abort(unsigned int fault_address); 160 int plat_crash_console_init(void); 161 int plat_crash_console_putc(int c); 162 void plat_crash_console_flush(void); 163 void plat_error_handler(int err) __dead2; 164 void plat_panic_handler(void) __dead2; 165 void plat_system_reset(void) __dead2; 166 const char *plat_log_get_prefix(unsigned int log_level); 167 void bl2_plat_preload_setup(void); 168 void plat_setup_try_img_ops(const struct plat_try_images_ops *plat_try_ops); 169 170 #if MEASURED_BOOT 171 int plat_mboot_measure_image(unsigned int image_id, image_info_t *image_data); 172 int plat_mboot_measure_critical_data(unsigned int critical_data_id, 173 const void *base, 174 size_t size); 175 int plat_mboot_measure_key(const void *pk_oid, const void *pk_ptr, 176 size_t pk_len); 177 #else 178 static inline int plat_mboot_measure_image(unsigned int image_id __unused, 179 image_info_t *image_data __unused) 180 { 181 return 0; 182 } 183 static inline int plat_mboot_measure_critical_data( 184 unsigned int critical_data_id __unused, 185 const void *base __unused, 186 size_t size __unused) 187 { 188 return 0; 189 } 190 static inline int plat_mboot_measure_key(const void *pk_oid __unused, 191 const void *pk_ptr __unused, 192 size_t pk_len __unused) 193 { 194 return 0; 195 } 196 #endif /* MEASURED_BOOT */ 197 198 #if EARLY_CONSOLE 199 void plat_setup_early_console(void); 200 #else 201 static inline void plat_setup_early_console(void) 202 { 203 } 204 #endif /* EARLY_CONSOLE */ 205 206 /******************************************************************************* 207 * Mandatory BL1 functions 208 ******************************************************************************/ 209 void bl1_early_platform_setup(void); 210 void bl1_plat_arch_setup(void); 211 void bl1_platform_setup(void); 212 struct meminfo *bl1_plat_sec_mem_layout(void); 213 214 /******************************************************************************* 215 * Optional EL3 component functions in BL31 216 ******************************************************************************/ 217 218 /* SDEI platform functions */ 219 #if SDEI_SUPPORT 220 void plat_sdei_setup(void); 221 int plat_sdei_validate_entry_point(uintptr_t ep, unsigned int client_mode); 222 void plat_sdei_handle_masked_trigger(uint64_t mpidr, unsigned int intr); 223 #endif 224 225 void plat_default_ea_handler(unsigned int ea_reason, uint64_t syndrome, void *cookie, 226 void *handle, uint64_t flags); 227 void plat_ea_handler(unsigned int ea_reason, uint64_t syndrome, void *cookie, 228 void *handle, uint64_t flags); 229 230 /* 231 * The following function is mandatory when the 232 * firmware update feature is used. 233 */ 234 int bl1_plat_mem_check(uintptr_t mem_base, unsigned int mem_size, 235 unsigned int flags); 236 237 /******************************************************************************* 238 * Optional BL1 functions (may be overridden) 239 ******************************************************************************/ 240 /* 241 * The following functions are used for image loading process in BL1. 242 */ 243 void bl1_plat_set_ep_info(unsigned int image_id, 244 struct entry_point_info *ep_info); 245 /* 246 * The following functions are mandatory when firmware update 247 * feature is used and optional otherwise. 248 */ 249 unsigned int bl1_plat_get_next_image_id(void); 250 struct image_desc *bl1_plat_get_image_desc(unsigned int image_id); 251 252 /* 253 * The following functions are used by firmware update 254 * feature and may optionally be overridden. 255 */ 256 __dead2 void bl1_plat_fwu_done(void *client_cookie, void *reserved); 257 258 /* 259 * This BL1 function can be used by the platforms to update/use image 260 * information for a given `image_id`. 261 */ 262 int bl1_plat_handle_pre_image_load(unsigned int image_id); 263 int bl1_plat_handle_post_image_load(unsigned int image_id); 264 265 /* Utility functions */ 266 void bl1_plat_calc_bl2_layout(const meminfo_t *bl1_mem_layout, 267 meminfo_t *bl2_mem_layout); 268 269 #if MEASURED_BOOT 270 void bl1_plat_mboot_init(void); 271 void bl1_plat_mboot_finish(void); 272 #else 273 static inline void bl1_plat_mboot_init(void) 274 { 275 } 276 static inline void bl1_plat_mboot_finish(void) 277 { 278 } 279 #endif /* MEASURED_BOOT || DICE_PROTECTION_ENVIRONMENT */ 280 281 /******************************************************************************* 282 * Mandatory BL2 functions 283 ******************************************************************************/ 284 void bl2_early_platform_setup2(u_register_t arg0, u_register_t arg1, u_register_t arg2, u_register_t arg3); 285 void bl2_plat_arch_setup(void); 286 void bl2_platform_setup(void); 287 struct meminfo *bl2_plat_sec_mem_layout(void); 288 289 /* 290 * This function can be used by the platforms to update/use image 291 * information for given `image_id`. 292 */ 293 int bl2_plat_handle_pre_image_load(unsigned int image_id); 294 int bl2_plat_handle_post_image_load(unsigned int image_id); 295 296 /******************************************************************************* 297 * Optional BL2 functions (may be overridden) 298 ******************************************************************************/ 299 #if (MEASURED_BOOT || DICE_PROTECTION_ENVIRONMENT) 300 void bl2_plat_mboot_init(void); 301 void bl2_plat_mboot_finish(void); 302 #if TRANSFER_LIST 303 int plat_handoff_mboot(const void *data, uint32_t data_size, void *tl_base); 304 #else 305 static inline int 306 plat_handoff_mboot(__unused const void *data, __unused uint32_t data_size, 307 __unused void *tl_base) 308 { 309 return -1; 310 } 311 #endif 312 #else 313 static inline void bl2_plat_mboot_init(void) 314 { 315 } 316 static inline void bl2_plat_mboot_finish(void) 317 { 318 } 319 #endif /* MEASURED_BOOT || DICE_PROTECTION_ENVIRONMENTs */ 320 321 /******************************************************************************* 322 * Mandatory BL2 at EL3 functions: Must be implemented 323 * if RESET_TO_BL2 image is supported 324 ******************************************************************************/ 325 void bl2_el3_early_platform_setup(u_register_t arg0, u_register_t arg1, 326 u_register_t arg2, u_register_t arg3); 327 void bl2_el3_plat_arch_setup(void); 328 329 /******************************************************************************* 330 * Optional BL2 at EL3 functions (may be overridden) 331 ******************************************************************************/ 332 void bl2_el3_plat_prepare_exit(void); 333 334 /******************************************************************************* 335 * Mandatory BL2U functions. 336 ******************************************************************************/ 337 void bl2u_early_platform_setup(struct meminfo *mem_layout, 338 void *plat_info); 339 void bl2u_plat_arch_setup(void); 340 void bl2u_platform_setup(void); 341 342 /******************************************************************************* 343 * Conditionally mandatory BL2U functions for CSS platforms. 344 ******************************************************************************/ 345 /* 346 * This function is used to perform any platform-specific actions required to 347 * handle the BL2U_SCP firmware. 348 */ 349 int bl2u_plat_handle_scp_bl2u(void); 350 351 /******************************************************************************* 352 * Mandatory BL31 functions 353 ******************************************************************************/ 354 void bl31_early_platform_setup2(u_register_t arg0, u_register_t arg1, 355 u_register_t arg2, u_register_t arg3); 356 void bl31_plat_arch_setup(void); 357 void bl31_platform_setup(void); 358 void bl31_plat_runtime_setup(void); 359 struct entry_point_info *bl31_plat_get_next_image_ep_info(uint32_t type); 360 361 /******************************************************************************* 362 * Mandatory PSCI functions (BL31) 363 ******************************************************************************/ 364 int plat_setup_psci_ops(uintptr_t sec_entrypoint, 365 const struct plat_psci_ops **psci_ops); 366 const unsigned char *plat_get_power_domain_tree_desc(void); 367 368 /******************************************************************************* 369 * Optional PSCI functions (BL31). 370 ******************************************************************************/ 371 void plat_psci_stat_accounting_start(const psci_power_state_t *state_info); 372 void plat_psci_stat_accounting_stop(const psci_power_state_t *state_info); 373 u_register_t plat_psci_stat_get_residency(unsigned int lvl, 374 const psci_power_state_t *state_info, 375 unsigned int last_cpu_idx); 376 plat_local_state_t plat_get_target_pwr_state(unsigned int lvl, 377 const plat_local_state_t *states, 378 unsigned int ncpu); 379 380 /******************************************************************************* 381 * Mandatory BL31 functions when ENABLE_RME=1 382 ******************************************************************************/ 383 #if ENABLE_RME 384 385 int plat_rmmd_get_cca_attest_token(uintptr_t buf, size_t *len, 386 uintptr_t hash, size_t hash_size, 387 uint64_t *remaining_len); 388 int plat_rmmd_get_cca_realm_attest_key(uintptr_t buf, size_t *len, 389 unsigned int type); 390 /* The following 3 functions are to be implement if 391 * RMMD_ENABLE_EL3_TOKEN_SIGN=1. 392 * The following three functions are expected to return E_RMM_* error codes. 393 */ 394 int plat_rmmd_el3_token_sign_get_rak_pub(uintptr_t buf, size_t *len, 395 unsigned int type); 396 int plat_rmmd_el3_token_sign_push_req( 397 const struct el3_token_sign_request *req); 398 int plat_rmmd_el3_token_sign_pull_resp(struct el3_token_sign_response *resp); 399 size_t plat_rmmd_get_el3_rmm_shared_mem(uintptr_t *shared); 400 int plat_rmmd_load_manifest(struct rmm_manifest *manifest); 401 #endif 402 403 /******************************************************************************* 404 * Optional BL31 functions (may be overridden) 405 ******************************************************************************/ 406 void bl31_plat_enable_mmu(uint32_t flags); 407 408 /******************************************************************************* 409 * Optional BL32 functions (may be overridden) 410 ******************************************************************************/ 411 void bl32_plat_enable_mmu(uint32_t flags); 412 413 /******************************************************************************* 414 * Trusted Board Boot functions 415 ******************************************************************************/ 416 int plat_get_rotpk_info(void *cookie, void **key_ptr, unsigned int *key_len, 417 unsigned int *flags); 418 int plat_get_nv_ctr(void *cookie, unsigned int *nv_ctr); 419 int plat_set_nv_ctr(void *cookie, unsigned int nv_ctr); 420 int plat_set_nv_ctr2(void *cookie, const struct auth_img_desc_s *img_desc, 421 unsigned int nv_ctr); 422 int get_mbedtls_heap_helper(void **heap_addr, size_t *heap_size); 423 int plat_get_enc_key_info(enum fw_enc_status_t fw_enc_status, uint8_t *key, 424 size_t *key_len, unsigned int *flags, 425 const uint8_t *img_id, size_t img_id_len); 426 427 /******************************************************************************* 428 * Secure Partitions functions 429 ******************************************************************************/ 430 const struct mmap_region *plat_get_secure_partition_mmap(void *cookie); 431 const struct spm_mm_boot_info *plat_get_secure_partition_boot_info( 432 void *cookie); 433 int plat_spm_sp_rd_load(struct sp_res_desc *rd, const void *ptr, size_t size); 434 int plat_spm_sp_get_next_address(void **sp_base, size_t *sp_size, 435 void **rd_base, size_t *rd_size); 436 #if defined(SPD_spmd) 437 int plat_spm_core_manifest_load(spmc_manifest_attribute_t *manifest, 438 const void *pm_addr); 439 #endif 440 #if defined(SPMC_AT_EL3) 441 int plat_spmc_shmem_datastore_get(uint8_t **datastore, size_t *size); 442 #endif 443 444 /******************************************************************************* 445 * Mandatory BL image load functions(may be overridden). 446 ******************************************************************************/ 447 /* 448 * This function returns pointer to the list of images that the 449 * platform has populated to load. 450 */ 451 struct bl_load_info *plat_get_bl_image_load_info(void); 452 453 /* 454 * This function returns a pointer to the shared memory that the 455 * platform has kept aside to pass trusted firmware related 456 * information that next BL image could need. 457 */ 458 struct bl_params *plat_get_next_bl_params(void); 459 460 /* 461 * This function flushes to main memory all the params that are 462 * passed to next image. 463 */ 464 void plat_flush_next_bl_params(void); 465 466 /* 467 * The below function enable Trusted Firmware components like SPDs which 468 * haven't migrated to the new platform API to compile on platforms which 469 * have the compatibility layer disabled. 470 */ 471 unsigned int platform_core_pos_helper(unsigned long mpidr); 472 473 /* 474 * Optional function to get SOC version 475 */ 476 int32_t plat_get_soc_version(void); 477 478 /* 479 * Optional function to get SOC revision 480 */ 481 int32_t plat_get_soc_revision(void); 482 483 /* 484 * Optional function to check for SMCCC function availability for platform 485 */ 486 int32_t plat_is_smccc_feature_available(u_register_t fid); 487 488 /******************************************************************************* 489 * FWU platform specific functions 490 ******************************************************************************/ 491 int plat_fwu_set_metadata_image_source(unsigned int image_id, 492 uintptr_t *dev_handle, 493 uintptr_t *image_spec); 494 void plat_fwu_set_images_source(const struct fwu_metadata *metadata); 495 uint32_t plat_fwu_get_boot_idx(void); 496 497 /* 498 * Optional function to indicate if cache management operations can be 499 * performed. 500 */ 501 #if CONDITIONAL_CMO 502 uint64_t plat_can_cmo(void); 503 #else 504 static inline uint64_t plat_can_cmo(void) 505 { 506 return 1; 507 } 508 #endif /* CONDITIONAL_CMO */ 509 510 #endif /* PLATFORM_H */ 511