1 /* 2 * Copyright (c) 2016-2020, ARM Limited and Contributors. All rights reserved. 3 * 4 * SPDX-License-Identifier: BSD-3-Clause 5 */ 6 7 #include <assert.h> 8 9 #include <arch_helpers.h> 10 #include <common/bl_common.h> 11 #include <common/desc_image_load.h> 12 #include <common/tbbr/tbbr_img_def.h> 13 14 static bl_load_info_t bl_load_info; 15 static bl_params_t next_bl_params; 16 17 18 /******************************************************************************* 19 * This function flushes the data structures so that they are visible 20 * in memory for the next BL image. 21 ******************************************************************************/ 22 void flush_bl_params_desc(void) 23 { 24 flush_bl_params_desc_args(bl_mem_params_desc_ptr, 25 bl_mem_params_desc_num, 26 &next_bl_params); 27 } 28 29 /******************************************************************************* 30 * This function flushes the data structures specified as arguments so that they 31 * are visible in memory for the next BL image. 32 ******************************************************************************/ 33 void flush_bl_params_desc_args(bl_mem_params_node_t *mem_params_desc_ptr, 34 unsigned int mem_params_desc_num, 35 bl_params_t *next_bl_params_ptr) 36 { 37 assert(mem_params_desc_ptr != NULL); 38 assert(mem_params_desc_num != 0U); 39 assert(next_bl_params_ptr != NULL); 40 41 flush_dcache_range((uintptr_t)mem_params_desc_ptr, 42 sizeof(*mem_params_desc_ptr) * mem_params_desc_num); 43 44 flush_dcache_range((uintptr_t)next_bl_params_ptr, 45 sizeof(*next_bl_params_ptr)); 46 } 47 48 /******************************************************************************* 49 * This function returns the index for given image_id, within the 50 * image descriptor array provided by bl_image_info_descs_ptr, if the 51 * image is found else it returns -1. 52 ******************************************************************************/ 53 int get_bl_params_node_index(unsigned int image_id) 54 { 55 unsigned int index; 56 assert(image_id != INVALID_IMAGE_ID); 57 58 for (index = 0U; index < bl_mem_params_desc_num; index++) { 59 if (bl_mem_params_desc_ptr[index].image_id == image_id) 60 return (int)index; 61 } 62 63 return -1; 64 } 65 66 /******************************************************************************* 67 * This function returns the pointer to `bl_mem_params_node_t` object for 68 * given image_id, within the image descriptor array provided by 69 * bl_mem_params_desc_ptr, if the image is found else it returns NULL. 70 ******************************************************************************/ 71 bl_mem_params_node_t *get_bl_mem_params_node(unsigned int image_id) 72 { 73 int index; 74 assert(image_id != INVALID_IMAGE_ID); 75 76 index = get_bl_params_node_index(image_id); 77 if (index >= 0) 78 return &bl_mem_params_desc_ptr[index]; 79 else 80 return NULL; 81 } 82 83 /******************************************************************************* 84 * This function creates the list of loadable images, by populating and 85 * linking each `bl_load_info_node_t` type node, using the internal array 86 * of image descriptor provided by bl_mem_params_desc_ptr. It also populates 87 * and returns `bl_load_info_t` type structure that contains head of the list 88 * of loadable images. 89 ******************************************************************************/ 90 bl_load_info_t *get_bl_load_info_from_mem_params_desc(void) 91 { 92 unsigned int index = 0; 93 94 /* If there is no image to start with, return NULL */ 95 if (bl_mem_params_desc_num == 0U) 96 return NULL; 97 98 /* Assign initial data structures */ 99 bl_load_info_node_t *bl_node_info = 100 &bl_mem_params_desc_ptr[index].load_node_mem; 101 bl_load_info.head = bl_node_info; 102 SET_PARAM_HEAD(&bl_load_info, PARAM_BL_LOAD_INFO, VERSION_2, 0U); 103 104 /* Go through the image descriptor array and create the list */ 105 for (; index < bl_mem_params_desc_num; index++) { 106 107 /* Populate the image information */ 108 bl_node_info->image_id = bl_mem_params_desc_ptr[index].image_id; 109 bl_node_info->image_info = &bl_mem_params_desc_ptr[index].image_info; 110 111 /* Link next image if present */ 112 if ((index + 1U) < bl_mem_params_desc_num) { 113 /* Get the memory and link the next node */ 114 bl_node_info->next_load_info = 115 &bl_mem_params_desc_ptr[index + 1U].load_node_mem; 116 bl_node_info = bl_node_info->next_load_info; 117 } 118 } 119 120 return &bl_load_info; 121 } 122 123 /******************************************************************************* 124 * This function creates the list of executable images, by populating and 125 * linking each `bl_params_node_t` type node, using the internal array of 126 * image descriptor provided by bl_mem_params_desc_ptr. It also populates 127 * and returns `bl_params_t` type structure that contains head of the list 128 * of executable images. 129 ******************************************************************************/ 130 bl_params_t *get_next_bl_params_from_mem_params_desc(void) 131 { 132 unsigned int count; 133 unsigned int img_id = 0U; 134 unsigned int link_index = 0U; 135 bl_params_node_t *bl_current_exec_node = NULL; 136 bl_params_node_t *bl_last_exec_node = NULL; 137 bl_mem_params_node_t *desc_ptr; 138 139 /* If there is no image to start with, return NULL */ 140 if (bl_mem_params_desc_num == 0U) 141 return NULL; 142 143 /* Get the list HEAD */ 144 for (count = 0U; count < bl_mem_params_desc_num; count++) { 145 146 desc_ptr = &bl_mem_params_desc_ptr[count]; 147 148 if ((EP_GET_EXE(desc_ptr->ep_info.h.attr) == EXECUTABLE) && 149 (EP_GET_FIRST_EXE(desc_ptr->ep_info.h.attr) == EP_FIRST_EXE)) { 150 next_bl_params.head = &desc_ptr->params_node_mem; 151 link_index = count; 152 break; 153 } 154 } 155 156 /* Make sure we have a HEAD node */ 157 assert(next_bl_params.head != NULL); 158 159 /* Populate the HEAD information */ 160 SET_PARAM_HEAD(&next_bl_params, PARAM_BL_PARAMS, VERSION_2, 0U); 161 162 /* 163 * Go through the image descriptor array and create the list. 164 * This bounded loop is to make sure that we are not looping forever. 165 */ 166 for (count = 0U; count < bl_mem_params_desc_num; count++) { 167 168 desc_ptr = &bl_mem_params_desc_ptr[link_index]; 169 170 /* Make sure the image is executable */ 171 assert(EP_GET_EXE(desc_ptr->ep_info.h.attr) == EXECUTABLE); 172 173 /* Get the memory for current node */ 174 bl_current_exec_node = &desc_ptr->params_node_mem; 175 176 /* Populate the image information */ 177 bl_current_exec_node->image_id = desc_ptr->image_id; 178 bl_current_exec_node->image_info = &desc_ptr->image_info; 179 bl_current_exec_node->ep_info = &desc_ptr->ep_info; 180 181 if (bl_last_exec_node != NULL) { 182 /* Assert if loop detected */ 183 assert(bl_last_exec_node->next_params_info == NULL); 184 185 /* Link the previous node to the current one */ 186 bl_last_exec_node->next_params_info = bl_current_exec_node; 187 } 188 189 /* Update the last node */ 190 bl_last_exec_node = bl_current_exec_node; 191 192 /* If no next hand-off image then break out */ 193 img_id = desc_ptr->next_handoff_image_id; 194 if (img_id == INVALID_IMAGE_ID) 195 break; 196 197 /* Get the index for the next hand-off image */ 198 link_index = get_bl_params_node_index(img_id); 199 assert((link_index > 0U) && 200 (link_index < bl_mem_params_desc_num)); 201 } 202 203 /* Invalid image is expected to terminate the loop */ 204 assert(img_id == INVALID_IMAGE_ID); 205 206 return &next_bl_params; 207 } 208 209 /******************************************************************************* 210 * This function populates the entry point information with the corresponding 211 * config file for all executable BL images described in bl_params. 212 ******************************************************************************/ 213 void populate_next_bl_params_config(bl_params_t *bl2_to_next_bl_params) 214 { 215 bl_params_node_t *params_node; 216 unsigned int fw_config_id; 217 #ifdef SPD_spmd 218 uint32_t fw_config_size = 0; 219 #endif 220 uintptr_t fw_config_base; 221 bl_mem_params_node_t *mem_params; 222 uintptr_t hw_config_base = 0; 223 224 assert(bl2_to_next_bl_params != NULL); 225 226 /* 227 * Get the `bl_mem_params_node_t` corresponding to HW_CONFIG 228 * if available. 229 */ 230 mem_params = get_bl_mem_params_node(HW_CONFIG_ID); 231 232 if (mem_params != NULL) 233 hw_config_base = mem_params->image_info.image_base; 234 235 for (params_node = bl2_to_next_bl_params->head; params_node != NULL; 236 params_node = params_node->next_params_info) { 237 238 fw_config_base = 0; 239 240 switch (params_node->image_id) { 241 case BL31_IMAGE_ID: 242 fw_config_id = SOC_FW_CONFIG_ID; 243 break; 244 case BL32_IMAGE_ID: 245 /* 246 * At the moment, OPTEE cannot accept a DTB in secure memory, 247 * so fall back and use NT_FW_CONFIG instead. 248 * This MUST be fixed as soon as OPTEE has support to 249 * receive DTBs in secure memory. 250 */ 251 #ifndef SPD_opteed 252 fw_config_id = TOS_FW_CONFIG_ID; 253 break; 254 #endif 255 case BL33_IMAGE_ID: 256 fw_config_id = NT_FW_CONFIG_ID; 257 break; 258 default: 259 fw_config_id = INVALID_IMAGE_ID; 260 break; 261 } 262 263 if (fw_config_id != INVALID_IMAGE_ID) { 264 mem_params = get_bl_mem_params_node(fw_config_id); 265 if (mem_params != NULL) { 266 fw_config_base = mem_params->image_info.image_base; 267 #ifdef SPD_spmd 268 fw_config_size = 269 mem_params->image_info.image_size; 270 #endif 271 } 272 } 273 274 #ifdef SPD_opteed 275 /* 276 * If SPD_opteed is enabled, arg[0,2] are populated by 277 * parse_optee_header(), which is called by 278 * arm_bl2_handle_post_image_load(). The meaning of the 279 * arguments are: 280 * arg0 <-- MODE_RW 281 * arg1 <-- Paged image base 282 * arg2 <-- Paged image size 283 */ 284 if (params_node->image_id == BL32_IMAGE_ID) { 285 params_node->ep_info->args.arg3 = fw_config_base; 286 } else { 287 #endif 288 /* 289 * Pass hw and tb_fw config addresses to next images. 290 * NOTE - for EL3 runtime images (BL31 for AArch64 291 * and BL32 for AArch32), arg0 is already used by 292 * generic code. Take care of not overwriting the 293 * previous initialisations. 294 */ 295 if (params_node == bl2_to_next_bl_params->head) { 296 if (params_node->ep_info->args.arg1 == 0U) 297 params_node->ep_info->args.arg1 = 298 fw_config_base; 299 if (params_node->ep_info->args.arg2 == 0U) 300 params_node->ep_info->args.arg2 = 301 hw_config_base; 302 } else { 303 if (params_node->ep_info->args.arg0 == 0U) 304 params_node->ep_info->args.arg0 = 305 fw_config_base; 306 if (params_node->ep_info->args.arg1 == 0U) 307 params_node->ep_info->args.arg1 = 308 hw_config_base; 309 #ifdef SPD_spmd 310 if (params_node->ep_info->args.arg2 == 0U) 311 params_node->ep_info->args.arg2 = 312 fw_config_size; 313 #endif 314 } 315 #ifdef SPD_opteed 316 } 317 #endif 318 } 319 } 320 321 /******************************************************************************* 322 * Helper to extract BL32/BL33 entry point info from arg0 passed to BL31, for 323 * platforms that are only interested in those. Platforms that need to extract 324 * more information can parse the structures themselves. 325 ******************************************************************************/ 326 327 void bl31_params_parse_helper(u_register_t param, 328 entry_point_info_t *bl32_ep_info_out, 329 entry_point_info_t *bl33_ep_info_out) 330 { 331 bl_params_node_t *node; 332 bl_params_t *v2 = (void *)(uintptr_t)param; 333 334 #if !ERROR_DEPRECATED 335 if (v2->h.version == PARAM_VERSION_1) { 336 struct { /* Deprecated version 1 parameter structure. */ 337 param_header_t h; 338 image_info_t *bl31_image_info; 339 entry_point_info_t *bl32_ep_info; 340 image_info_t *bl32_image_info; 341 entry_point_info_t *bl33_ep_info; 342 image_info_t *bl33_image_info; 343 } *v1 = (void *)(uintptr_t)param; 344 assert(v1->h.type == PARAM_BL31); 345 if (bl32_ep_info_out != NULL) 346 *bl32_ep_info_out = *v1->bl32_ep_info; 347 if (bl33_ep_info_out != NULL) 348 *bl33_ep_info_out = *v1->bl33_ep_info; 349 return; 350 } 351 #endif /* !ERROR_DEPRECATED */ 352 353 assert(v2->h.version == PARAM_VERSION_2); 354 assert(v2->h.type == PARAM_BL_PARAMS); 355 for (node = v2->head; node != NULL; node = node->next_params_info) { 356 if (node->image_id == BL32_IMAGE_ID) 357 if (bl32_ep_info_out != NULL) 358 *bl32_ep_info_out = *node->ep_info; 359 if (node->image_id == BL33_IMAGE_ID) 360 if (bl33_ep_info_out != NULL) 361 *bl33_ep_info_out = *node->ep_info; 362 } 363 } 364