blob: 07692260ec0baeed00f3edfe9510ba4bb2ed1add [file] [log] [blame]
Yatharth Kochar3345a8d2016-09-12 16:08:41 +01001/*
Zelaleme8dadb12020-02-05 14:12:39 -06002 * Copyright (c) 2016-2020, ARM Limited and Contributors. All rights reserved.
Yatharth Kochar3345a8d2016-09-12 16:08:41 +01003 *
dp-armfa3cf0b2017-05-03 09:38:09 +01004 * SPDX-License-Identifier: BSD-3-Clause
Yatharth Kochar3345a8d2016-09-12 16:08:41 +01005 */
6
Yatharth Kochar3345a8d2016-09-12 16:08:41 +01007#include <assert.h>
Yatharth Kochar3345a8d2016-09-12 16:08:41 +01008
Antonio Nino Diaze0f90632018-12-14 00:18:21 +00009#include <arch_helpers.h>
10#include <common/bl_common.h>
11#include <common/desc_image_load.h>
Julius Wernera0574842019-05-29 17:01:46 -070012#include <common/tbbr/tbbr_img_def.h>
Yatharth Kochar3345a8d2016-09-12 16:08:41 +010013
14static bl_load_info_t bl_load_info;
15static 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 ******************************************************************************/
22void flush_bl_params_desc(void)
23{
Sathees Balya90950092018-11-15 14:22:30 +000024 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 ******************************************************************************/
33void 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);
Dan Handley09c97c92017-04-18 14:46:23 +010043
Sathees Balya90950092018-11-15 14:22:30 +000044 flush_dcache_range((uintptr_t)next_bl_params_ptr,
45 sizeof(*next_bl_params_ptr));
Yatharth Kochar3345a8d2016-09-12 16:08:41 +010046}
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 ******************************************************************************/
53int get_bl_params_node_index(unsigned int image_id)
54{
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +010055 unsigned int index;
Yatharth Kochar3345a8d2016-09-12 16:08:41 +010056 assert(image_id != INVALID_IMAGE_ID);
57
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +010058 for (index = 0U; index < bl_mem_params_desc_num; index++) {
Yatharth Kochar3345a8d2016-09-12 16:08:41 +010059 if (bl_mem_params_desc_ptr[index].image_id == image_id)
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +010060 return (int)index;
Yatharth Kochar3345a8d2016-09-12 16:08:41 +010061 }
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 ******************************************************************************/
71bl_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 ******************************************************************************/
90bl_load_info_t *get_bl_load_info_from_mem_params_desc(void)
91{
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +010092 unsigned int index = 0;
Yatharth Kochar3345a8d2016-09-12 16:08:41 +010093
94 /* If there is no image to start with, return NULL */
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +010095 if (bl_mem_params_desc_num == 0U)
Yatharth Kochar3345a8d2016-09-12 16:08:41 +010096 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;
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100102 SET_PARAM_HEAD(&bl_load_info, PARAM_BL_LOAD_INFO, VERSION_2, 0U);
Yatharth Kochar3345a8d2016-09-12 16:08:41 +0100103
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 */
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100112 if ((index + 1U) < bl_mem_params_desc_num) {
Yatharth Kochar3345a8d2016-09-12 16:08:41 +0100113 /* Get the memory and link the next node */
114 bl_node_info->next_load_info =
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100115 &bl_mem_params_desc_ptr[index + 1U].load_node_mem;
Yatharth Kochar3345a8d2016-09-12 16:08:41 +0100116 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 ******************************************************************************/
130bl_params_t *get_next_bl_params_from_mem_params_desc(void)
131{
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100132 unsigned int count;
133 unsigned int img_id = 0U;
134 unsigned int link_index = 0U;
Yatharth Kochar3345a8d2016-09-12 16:08:41 +0100135 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 */
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100140 if (bl_mem_params_desc_num == 0U)
Yatharth Kochar3345a8d2016-09-12 16:08:41 +0100141 return NULL;
142
143 /* Get the list HEAD */
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100144 for (count = 0U; count < bl_mem_params_desc_num; count++) {
Yatharth Kochar3345a8d2016-09-12 16:08:41 +0100145
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 */
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100160 SET_PARAM_HEAD(&next_bl_params, PARAM_BL_PARAMS, VERSION_2, 0U);
Yatharth Kochar3345a8d2016-09-12 16:08:41 +0100161
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 */
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100166 for (count = 0U; count < bl_mem_params_desc_num; count++) {
Yatharth Kochar3345a8d2016-09-12 16:08:41 +0100167
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
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100181 if (bl_last_exec_node != NULL) {
Yatharth Kochar3345a8d2016-09-12 16:08:41 +0100182 /* 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);
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100199 assert((link_index > 0U) &&
Yatharth Kochar3345a8d2016-09-12 16:08:41 +0100200 (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
Yatharth Kochar3345a8d2016-09-12 16:08:41 +0100206 return &next_bl_params;
207}
Soby Mathew96a1c6b2018-01-15 14:45:33 +0000208
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 ******************************************************************************/
213void 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 uintptr_t hw_config_base = 0, fw_config_base;
Achin Guptada6ef0e2019-10-11 14:54:48 +0100218#if defined(SPD_spmd)
219 uint32_t fw_config_size = 0;
220#endif
Soby Mathew96a1c6b2018-01-15 14:45:33 +0000221 bl_mem_params_node_t *mem_params;
222
Soby Mathewcc364842018-02-21 01:16:39 +0000223 assert(bl2_to_next_bl_params != NULL);
Soby Mathew96a1c6b2018-01-15 14:45:33 +0000224
225 /*
226 * Get the `bl_mem_params_node_t` corresponding to HW_CONFIG
227 * if available.
228 */
229 mem_params = get_bl_mem_params_node(HW_CONFIG_ID);
230 if (mem_params != NULL)
231 hw_config_base = mem_params->image_info.image_base;
232
233 for (params_node = bl2_to_next_bl_params->head; params_node != NULL;
234 params_node = params_node->next_params_info) {
235
236 fw_config_base = 0;
237
238 switch (params_node->image_id) {
239 case BL31_IMAGE_ID:
240 fw_config_id = SOC_FW_CONFIG_ID;
241 break;
242 case BL32_IMAGE_ID:
243 fw_config_id = TOS_FW_CONFIG_ID;
244 break;
245 case BL33_IMAGE_ID:
246 fw_config_id = NT_FW_CONFIG_ID;
247 break;
248 default:
249 fw_config_id = INVALID_IMAGE_ID;
250 break;
251 }
252
253 if (fw_config_id != INVALID_IMAGE_ID) {
254 mem_params = get_bl_mem_params_node(fw_config_id);
Achin Guptada6ef0e2019-10-11 14:54:48 +0100255 if (mem_params != NULL) {
Soby Mathew96a1c6b2018-01-15 14:45:33 +0000256 fw_config_base = mem_params->image_info.image_base;
Achin Guptada6ef0e2019-10-11 14:54:48 +0100257#if defined(SPD_spmd)
258 fw_config_size =
259 mem_params->image_info.image_size;
260#endif
261 }
Soby Mathew96a1c6b2018-01-15 14:45:33 +0000262 }
Soby Mathew96a1c6b2018-01-15 14:45:33 +0000263 /*
264 * Pass hw and tb_fw config addresses to next images. NOTE - for
265 * EL3 runtime images (BL31 for AArch64 and BL32 for AArch32),
Amit Daniel Kachhap4a3bc082018-03-02 18:47:55 +0530266 * arg0 is already used by generic code. Take care of not
267 * overwriting the previous initialisations.
Soby Mathew96a1c6b2018-01-15 14:45:33 +0000268 */
269 if (params_node == bl2_to_next_bl_params->head) {
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100270 if (params_node->ep_info->args.arg1 == 0U)
Amit Daniel Kachhap4a3bc082018-03-02 18:47:55 +0530271 params_node->ep_info->args.arg1 =
272 fw_config_base;
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100273 if (params_node->ep_info->args.arg2 == 0U)
Amit Daniel Kachhap4a3bc082018-03-02 18:47:55 +0530274 params_node->ep_info->args.arg2 =
275 hw_config_base;
Soby Mathew96a1c6b2018-01-15 14:45:33 +0000276 } else {
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100277 if (params_node->ep_info->args.arg0 == 0U)
Amit Daniel Kachhap4a3bc082018-03-02 18:47:55 +0530278 params_node->ep_info->args.arg0 =
279 fw_config_base;
Antonio Nino Diazf0b14cf2018-10-04 09:55:23 +0100280 if (params_node->ep_info->args.arg1 == 0U)
Amit Daniel Kachhap4a3bc082018-03-02 18:47:55 +0530281 params_node->ep_info->args.arg1 =
282 hw_config_base;
Achin Guptada6ef0e2019-10-11 14:54:48 +0100283#if defined(SPD_spmd)
284 if (params_node->ep_info->args.arg2 == 0U)
285 params_node->ep_info->args.arg2 =
286 fw_config_size;
287#endif
Soby Mathew96a1c6b2018-01-15 14:45:33 +0000288 }
289 }
290}
Julius Wernera0574842019-05-29 17:01:46 -0700291
292/*******************************************************************************
293 * Helper to extract BL32/BL33 entry point info from arg0 passed to BL31, for
294 * platforms that are only interested in those. Platforms that need to extract
295 * more information can parse the structures themselves.
296 ******************************************************************************/
297
298void bl31_params_parse_helper(u_register_t param,
299 entry_point_info_t *bl32_ep_info_out,
300 entry_point_info_t *bl33_ep_info_out)
301{
302 bl_params_node_t *node;
303 bl_params_t *v2 = (void *)(uintptr_t)param;
304
305#if !ERROR_DEPRECATED
306 if (v2->h.version == PARAM_VERSION_1) {
307 struct { /* Deprecated version 1 parameter structure. */
308 param_header_t h;
309 image_info_t *bl31_image_info;
310 entry_point_info_t *bl32_ep_info;
311 image_info_t *bl32_image_info;
312 entry_point_info_t *bl33_ep_info;
313 image_info_t *bl33_image_info;
314 } *v1 = (void *)(uintptr_t)param;
315 assert(v1->h.type == PARAM_BL31);
Zelaleme8dadb12020-02-05 14:12:39 -0600316 if (bl32_ep_info_out != NULL)
Julius Wernera0574842019-05-29 17:01:46 -0700317 *bl32_ep_info_out = *v1->bl32_ep_info;
Zelaleme8dadb12020-02-05 14:12:39 -0600318 if (bl33_ep_info_out != NULL)
Julius Wernera0574842019-05-29 17:01:46 -0700319 *bl33_ep_info_out = *v1->bl33_ep_info;
320 return;
321 }
322#endif /* !ERROR_DEPRECATED */
323
324 assert(v2->h.version == PARAM_VERSION_2);
325 assert(v2->h.type == PARAM_BL_PARAMS);
Zelaleme8dadb12020-02-05 14:12:39 -0600326 for (node = v2->head; node != NULL; node = node->next_params_info) {
Julius Wernera0574842019-05-29 17:01:46 -0700327 if (node->image_id == BL32_IMAGE_ID)
Zelaleme8dadb12020-02-05 14:12:39 -0600328 if (bl32_ep_info_out != NULL)
Julius Wernera0574842019-05-29 17:01:46 -0700329 *bl32_ep_info_out = *node->ep_info;
330 if (node->image_id == BL33_IMAGE_ID)
Zelaleme8dadb12020-02-05 14:12:39 -0600331 if (bl33_ep_info_out != NULL)
Julius Wernera0574842019-05-29 17:01:46 -0700332 *bl33_ep_info_out = *node->ep_info;
333 }
334}