1 /* 2 * Copyright (c) 2020-2024, 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 <common/debug.h> 11 #include <common/desc_image_load.h> 12 #include <common/fdt_wrappers.h> 13 #include <drivers/io/io_storage.h> 14 #include <lib/object_pool.h> 15 #include <libfdt.h> 16 #include <plat/arm/common/arm_fconf_getter.h> 17 #include <plat/arm/common/arm_fconf_io_storage.h> 18 #include <plat/arm/common/fconf_arm_sp_getter.h> 19 #include <platform_def.h> 20 #include <tools_share/firmware_image_package.h> 21 22 #ifdef IMAGE_BL2 23 24 bl_mem_params_node_t sp_mem_params_descs[MAX_SP_IDS]; 25 26 struct arm_sp_t arm_sp; 27 28 int fconf_populate_arm_sp(uintptr_t config) 29 { 30 int sp_node, node, err; 31 struct uuid uuid; 32 unsigned int index = 0; 33 uint32_t val32; 34 const unsigned int sip_start = SP_PKG1_ID; 35 unsigned int sip_index = sip_start; 36 #if defined(ARM_COT_dualroot) 37 const unsigned int sip_end = sip_start + MAX_SP_IDS / 2; 38 /* Allocating index range for platform SPs */ 39 const unsigned int plat_start = SP_PKG5_ID; 40 unsigned int plat_index = plat_start; 41 const unsigned int plat_end = plat_start + MAX_SP_IDS / 2; 42 bool is_plat_owned = false; 43 #endif /* ARM_COT_dualroot */ 44 45 /* As libfdt use void *, we can't avoid this cast */ 46 const void *dtb = (void *)config; 47 48 /* Assert the node offset point to "arm,sp" compatible property */ 49 const char *compatible_str = "arm,sp"; 50 51 node = fdt_node_offset_by_compatible(dtb, -1, compatible_str); 52 if (node < 0) { 53 ERROR("FCONF: Can't find %s in dtb\n", compatible_str); 54 return node; 55 } 56 57 fdt_for_each_subnode(sp_node, dtb, node) { 58 if (index == MAX_SP_IDS) { 59 ERROR("FCONF: Reached max number of SPs\n"); 60 return -1; 61 } 62 63 #if defined(ARM_COT_dualroot) 64 if ((sip_index == sip_end) || (plat_index == plat_end)) { 65 ERROR("FCONF: Reached max number of plat/SiP SPs\n"); 66 return -1; 67 } 68 #endif /* ARM_COT_dualroot */ 69 70 /* Read UUID */ 71 err = fdtw_read_uuid(dtb, sp_node, "uuid", 16, 72 (uint8_t *)&uuid); 73 if (err < 0) { 74 ERROR("FCONF: cannot read SP uuid\n"); 75 return -1; 76 } 77 78 memcpy_s(&arm_sp.uuids[index].uuid_struct, sizeof(struct uuid), 79 &uuid, sizeof(struct uuid)); 80 81 /* Read Load address */ 82 err = fdt_read_uint32(dtb, sp_node, "load-address", &val32); 83 if (err < 0) { 84 ERROR("FCONF: cannot read SP load address\n"); 85 return -1; 86 } 87 arm_sp.load_addr[index] = val32; 88 89 VERBOSE("FCONF: %s UUID" 90 " %02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x" 91 " load_addr=%lx\n", 92 __func__, 93 uuid.time_low[0], uuid.time_low[1], 94 uuid.time_low[2], uuid.time_low[3], 95 uuid.time_mid[0], uuid.time_mid[1], 96 uuid.time_hi_and_version[0], 97 uuid.time_hi_and_version[1], 98 uuid.clock_seq_hi_and_reserved, 99 uuid.clock_seq_low, 100 uuid.node[0], uuid.node[1], 101 uuid.node[2], uuid.node[3], 102 uuid.node[4], uuid.node[5], 103 arm_sp.load_addr[index]); 104 105 /* Read owner field only for dualroot CoT */ 106 #if defined(ARM_COT_dualroot) 107 /* Owner is an optional field, no need to catch error */ 108 fdtw_read_string(dtb, sp_node, "owner", 109 arm_sp.owner[index], ARM_SP_OWNER_NAME_LEN); 110 111 /* If owner is empty mark it as SiP owned */ 112 if ((strncmp(arm_sp.owner[index], "SiP", 113 ARM_SP_OWNER_NAME_LEN) == 0) || 114 (strncmp(arm_sp.owner[index], "", 115 ARM_SP_OWNER_NAME_LEN) == 0)) { 116 is_plat_owned = false; 117 } else if (strcmp(arm_sp.owner[index], "Plat") == 0) { 118 is_plat_owned = true; 119 } else { 120 ERROR("FCONF: %s is not a valid SP owner\n", 121 arm_sp.owner[index]); 122 return -1; 123 } 124 /* 125 * Add SP information in mem param descriptor and IO policies 126 * structure. 127 */ 128 if (is_plat_owned) { 129 sp_mem_params_descs[index].image_id = plat_index; 130 policies[plat_index].image_spec = 131 (uintptr_t)&arm_sp.uuids[index]; 132 policies[plat_index].dev_handle = &fip_dev_handle; 133 policies[plat_index].check = open_fip; 134 plat_index++; 135 } else 136 #endif /* ARM_COT_dualroot */ 137 { 138 sp_mem_params_descs[index].image_id = sip_index; 139 policies[sip_index].image_spec = 140 (uintptr_t)&arm_sp.uuids[index]; 141 policies[sip_index].dev_handle = &fip_dev_handle; 142 policies[sip_index].check = open_fip; 143 sip_index++; 144 } 145 SET_PARAM_HEAD(&sp_mem_params_descs[index].image_info, 146 PARAM_IMAGE_BINARY, VERSION_2, 0); 147 sp_mem_params_descs[index].image_info.image_max_size = 148 ARM_SP_MAX_SIZE; 149 sp_mem_params_descs[index].next_handoff_image_id = 150 INVALID_IMAGE_ID; 151 sp_mem_params_descs[index].image_info.image_base = 152 arm_sp.load_addr[index]; 153 index++; 154 } 155 156 if ((sp_node < 0) && (sp_node != -FDT_ERR_NOTFOUND)) { 157 ERROR("%u: fdt_for_each_subnode(): %d\n", __LINE__, node); 158 return sp_node; 159 } 160 161 arm_sp.number_of_sp = index; 162 return 0; 163 } 164 165 FCONF_REGISTER_POPULATOR(TB_FW, arm_sp, fconf_populate_arm_sp); 166 167 #endif /* IMAGE_BL2 */ 168