| 1 |
/* |
| 2 |
* Copyright (c) 2014-2020, Arm Limited and Contributors. All rights reserved. |
| 3 |
* Copyright (c) 2023, Advanced Micro Devices, Inc. All rights reserved. |
| 4 |
* |
| 5 |
* SPDX-License-Identifier: BSD-3-Clause |
| 6 |
*/ |
| 7 |
|
| 8 |
#include <assert.h> |
| 9 |
#include <inttypes.h> |
| 10 |
#include <stdint.h> |
| 11 |
|
| 12 |
#include <arch_helpers.h> |
| 13 |
#include <common/debug.h> |
| 14 |
#include <plat_startup.h> |
| 15 |
|
| 16 |
|
| 17 |
/* |
| 18 |
* HandoffParams |
| 19 |
* Parameter bitfield encoding |
| 20 |
* ----------------------------------------------------------------------------- |
| 21 |
* Exec State 0 0 -> Aarch64, 1-> Aarch32 |
| 22 |
* endianness 1 0 -> LE, 1 -> BE |
| 23 |
* secure (TZ) 2 0 -> Non secure, 1 -> secure |
| 24 |
* EL 3:4 00 -> EL0, 01 -> EL1, 10 -> EL2, 11 -> EL3 |
| 25 |
* CPU# 5:6 00 -> A53_0, 01 -> A53_1, 10 -> A53_2, 11 -> A53_3 |
| 26 |
* Reserved 7:10 Reserved |
| 27 |
* Cluster# 11:12 00 -> Cluster 0, 01 -> Cluster 1, 10 -> Cluster 2, |
| 28 |
* 11 -> Cluster (Applicable for Versal NET only). |
| 29 |
* Reserved 13:16 Reserved |
| 30 |
*/ |
| 31 |
|
| 32 |
#define XBL_FLAGS_ESTATE_SHIFT 0U |
| 33 |
#define XBL_FLAGS_ESTATE_MASK (1U << XBL_FLAGS_ESTATE_SHIFT) |
| 34 |
#define XBL_FLAGS_ESTATE_A64 0U |
| 35 |
#define XBL_FLAGS_ESTATE_A32 1U |
| 36 |
|
| 37 |
#define XBL_FLAGS_ENDIAN_SHIFT 1U |
| 38 |
#define XBL_FLAGS_ENDIAN_MASK (1U << XBL_FLAGS_ENDIAN_SHIFT) |
| 39 |
#define XBL_FLAGS_ENDIAN_LE 0U |
| 40 |
#define XBL_FLAGS_ENDIAN_BE 1U |
| 41 |
|
| 42 |
#define XBL_FLAGS_TZ_SHIFT 2U |
| 43 |
#define XBL_FLAGS_TZ_MASK (1U << XBL_FLAGS_TZ_SHIFT) |
| 44 |
#define XBL_FLAGS_NON_SECURE 0U |
| 45 |
#define XBL_FLAGS_SECURE 1U |
| 46 |
|
| 47 |
#define XBL_FLAGS_EL_SHIFT 3U |
| 48 |
#define XBL_FLAGS_EL_MASK (3U << XBL_FLAGS_EL_SHIFT) |
| 49 |
#define XBL_FLAGS_EL0 0U |
| 50 |
#define XBL_FLAGS_EL1 1U |
| 51 |
#define XBL_FLAGS_EL2 2U |
| 52 |
#define XBL_FLAGS_EL3 3U |
| 53 |
|
| 54 |
#define XBL_FLAGS_CPU_SHIFT 5U |
| 55 |
#define XBL_FLAGS_CPU_MASK (3U << XBL_FLAGS_CPU_SHIFT) |
| 56 |
#define XBL_FLAGS_A53_0 0U |
| 57 |
#define XBL_FLAGS_A53_1 1U |
| 58 |
#define XBL_FLAGS_A53_2 2U |
| 59 |
#define XBL_FLAGS_A53_3 3U |
| 60 |
|
| 61 |
#if defined(PLAT_versal_net) |
| 62 |
#define XBL_FLAGS_CLUSTER_SHIFT 11U |
| 63 |
#define XBL_FLAGS_CLUSTER_MASK GENMASK(11, 12) |
| 64 |
|
| 65 |
#define XBL_FLAGS_CLUSTER_0 0U |
| 66 |
#endif /* PLAT_versal_net */ |
| 67 |
|
| 68 |
/** |
| 69 |
* get_xbl_cpu() - Get the target CPU for partition. |
| 70 |
* @partition: Pointer to partition struct. |
| 71 |
* |
| 72 |
* Return: XBL_FLAGS_A53_0, XBL_FLAGS_A53_1, XBL_FLAGS_A53_2 or XBL_FLAGS_A53_3. |
| 73 |
* |
| 74 |
*/ |
| 75 |
static int32_t get_xbl_cpu(const struct xbl_partition *partition) |
| 76 |
{ |
| 77 |
uint64_t flags = partition->flags & XBL_FLAGS_CPU_MASK; |
| 78 |
|
| 79 |
return flags >> XBL_FLAGS_CPU_SHIFT; |
| 80 |
} |
| 81 |
|
| 82 |
/** |
| 83 |
* get_xbl_el() - Get the target exception level for partition. |
| 84 |
* @partition: Pointer to partition struct. |
| 85 |
* |
| 86 |
* Return: XBL_FLAGS_EL0, XBL_FLAGS_EL1, XBL_FLAGS_EL2 or XBL_FLAGS_EL3. |
| 87 |
* |
| 88 |
*/ |
| 89 |
static int32_t get_xbl_el(const struct xbl_partition *partition) |
| 90 |
{ |
| 91 |
uint64_t flags = partition->flags & XBL_FLAGS_EL_MASK; |
| 92 |
|
| 93 |
return flags >> XBL_FLAGS_EL_SHIFT; |
| 94 |
} |
| 95 |
|
| 96 |
/** |
| 97 |
* get_xbl_ss() - Get the target security state for partition. |
| 98 |
* @partition: Pointer to partition struct. |
| 99 |
* |
| 100 |
* Return: XBL_FLAGS_NON_SECURE or XBL_FLAGS_SECURE. |
| 101 |
* |
| 102 |
*/ |
| 103 |
static int32_t get_xbl_ss(const struct xbl_partition *partition) |
| 104 |
{ |
| 105 |
uint64_t flags = partition->flags & XBL_FLAGS_TZ_MASK; |
| 106 |
|
| 107 |
return flags >> XBL_FLAGS_TZ_SHIFT; |
| 108 |
} |
| 109 |
|
| 110 |
/** |
| 111 |
* get_xbl_endian() - Get the target endianness for partition. |
| 112 |
* @partition: Pointer to partition struct. |
| 113 |
* |
| 114 |
* Return: SPSR_E_LITTLE or SPSR_E_BIG. |
| 115 |
* |
| 116 |
*/ |
| 117 |
static int32_t get_xbl_endian(const struct xbl_partition *partition) |
| 118 |
{ |
| 119 |
uint64_t flags = partition->flags & XBL_FLAGS_ENDIAN_MASK; |
| 120 |
|
| 121 |
flags >>= XBL_FLAGS_ENDIAN_SHIFT; |
| 122 |
|
| 123 |
if (flags == XBL_FLAGS_ENDIAN_BE) { |
| 124 |
return SPSR_E_BIG; |
| 125 |
} else { |
| 126 |
return SPSR_E_LITTLE; |
| 127 |
} |
| 128 |
} |
| 129 |
|
| 130 |
/** |
| 131 |
* get_xbl_estate() - Get the target execution state for partition. |
| 132 |
* @partition: Pointer to partition struct. |
| 133 |
* |
| 134 |
* Return: XBL_FLAGS_ESTATE_A32 or XBL_FLAGS_ESTATE_A64. |
| 135 |
* |
| 136 |
*/ |
| 137 |
static int32_t get_xbl_estate(const struct xbl_partition *partition) |
| 138 |
{ |
| 139 |
uint64_t flags = partition->flags & XBL_FLAGS_ESTATE_MASK; |
| 140 |
|
| 141 |
return flags >> XBL_FLAGS_ESTATE_SHIFT; |
| 142 |
} |
| 143 |
|
| 144 |
#if defined(PLAT_versal_net) |
| 145 |
/** |
| 146 |
* get_xbl_cluster - Get the cluster number |
| 147 |
* @partition: pointer to the partition structure. |
| 148 |
* |
| 149 |
* Return: cluster number for the partition. |
| 150 |
*/ |
| 151 |
static int32_t get_xbl_cluster(const struct xbl_partition *partition) |
| 152 |
{ |
| 153 |
uint64_t flags = partition->flags & XBL_FLAGS_CLUSTER_MASK; |
| 154 |
|
| 155 |
return (int32_t)(flags >> XBL_FLAGS_CLUSTER_SHIFT); |
| 156 |
} |
| 157 |
#endif /* PLAT_versal_net */ |
| 158 |
|
| 159 |
/** |
| 160 |
* xbl_handover() - Populates the bl32 and bl33 image info structures. |
| 161 |
* @bl32: BL32 image info structure. |
| 162 |
* @bl33: BL33 image info structure. |
| 163 |
* @handoff_addr: TF-A handoff address. |
| 164 |
* |
| 165 |
* Process the handoff parameters from the XBL and populate the BL32 and BL33 |
| 166 |
* image info structures accordingly. |
| 167 |
* |
| 168 |
* Return: Return the status of the handoff. The value will be from the |
| 169 |
* xbl_handoff enum. |
| 170 |
* |
| 171 |
*/ |
| 172 |
enum xbl_handoff xbl_handover(entry_point_info_t *bl32, |
| 173 |
entry_point_info_t *bl33, |
| 174 |
uint64_t handoff_addr) |
| 175 |
{ |
| 176 |
const struct xbl_handoff_params *HandoffParams; |
| 177 |
|
| 178 |
if (!handoff_addr) { |
| 179 |
WARN("BL31: No handoff structure passed\n"); |
| 180 |
return XBL_HANDOFF_NO_STRUCT; |
| 181 |
} |
| 182 |
|
| 183 |
HandoffParams = (struct xbl_handoff_params *)handoff_addr; |
| 184 |
if ((HandoffParams->magic[0] != 'X') || |
| 185 |
(HandoffParams->magic[1] != 'L') || |
| 186 |
(HandoffParams->magic[2] != 'N') || |
| 187 |
(HandoffParams->magic[3] != 'X')) { |
| 188 |
ERROR("BL31: invalid handoff structure at %" PRIx64 "\n", handoff_addr); |
| 189 |
return XBL_HANDOFF_INVAL_STRUCT; |
| 190 |
} |
| 191 |
|
| 192 |
VERBOSE("BL31: TF-A handoff params at:0x%" PRIx64 ", entries:%u\n", |
| 193 |
handoff_addr, HandoffParams->num_entries); |
| 194 |
if (HandoffParams->num_entries > XBL_MAX_PARTITIONS) { |
| 195 |
ERROR("BL31: TF-A handoff params: too many partitions (%u/%u)\n", |
| 196 |
HandoffParams->num_entries, XBL_MAX_PARTITIONS); |
| 197 |
return XBL_HANDOFF_TOO_MANY_PARTS; |
| 198 |
} |
| 199 |
|
| 200 |
/* |
| 201 |
* we loop over all passed entries but only populate two image structs |
| 202 |
* (bl32, bl33). I.e. the last applicable images in the handoff |
| 203 |
* structure will be used for the hand off |
| 204 |
*/ |
| 205 |
for (size_t i = 0; i < HandoffParams->num_entries; i++) { |
| 206 |
entry_point_info_t *image; |
| 207 |
int32_t target_estate, target_secure, target_cpu; |
| 208 |
uint32_t target_endianness, target_el; |
| 209 |
|
| 210 |
VERBOSE("BL31: %zd: entry:0x%" PRIx64 ", flags:0x%" PRIx64 "\n", i, |
| 211 |
HandoffParams->partition[i].entry_point, |
| 212 |
HandoffParams->partition[i].flags); |
| 213 |
|
| 214 |
#if defined(PLAT_versal_net) |
| 215 |
uint32_t target_cluster; |
| 216 |
|
| 217 |
target_cluster = get_xbl_cluster(&HandoffParams->partition[i]); |
| 218 |
if (target_cluster != XBL_FLAGS_CLUSTER_0) { |
| 219 |
WARN("BL31: invalid target Cluster (%i)\n", |
| 220 |
target_cluster); |
| 221 |
continue; |
| 222 |
} |
| 223 |
#endif /* PLAT_versal_net */ |
| 224 |
|
| 225 |
target_cpu = get_xbl_cpu(&HandoffParams->partition[i]); |
| 226 |
if (target_cpu != XBL_FLAGS_A53_0) { |
| 227 |
WARN("BL31: invalid target CPU (%i)\n", target_cpu); |
| 228 |
continue; |
| 229 |
} |
| 230 |
|
| 231 |
target_el = get_xbl_el(&HandoffParams->partition[i]); |
| 232 |
if ((target_el == XBL_FLAGS_EL3) || |
| 233 |
(target_el == XBL_FLAGS_EL0)) { |
| 234 |
WARN("BL31: invalid target exception level(%i)\n", |
| 235 |
target_el); |
| 236 |
continue; |
| 237 |
} |
| 238 |
|
| 239 |
target_secure = get_xbl_ss(&HandoffParams->partition[i]); |
| 240 |
if ((target_secure == XBL_FLAGS_SECURE) && |
| 241 |
(target_el == XBL_FLAGS_EL2)) { |
| 242 |
WARN("BL31: invalid security state (%i) for exception level (%i)\n", |
| 243 |
target_secure, target_el); |
| 244 |
continue; |
| 245 |
} |
| 246 |
|
| 247 |
target_estate = get_xbl_estate(&HandoffParams->partition[i]); |
| 248 |
target_endianness = get_xbl_endian(&HandoffParams->partition[i]); |
| 249 |
|
| 250 |
if (target_secure == XBL_FLAGS_SECURE) { |
| 251 |
image = bl32; |
| 252 |
|
| 253 |
if (target_estate == XBL_FLAGS_ESTATE_A32) { |
| 254 |
bl32->spsr = SPSR_MODE32(MODE32_svc, SPSR_T_ARM, |
| 255 |
target_endianness, |
| 256 |
DISABLE_ALL_EXCEPTIONS); |
| 257 |
} else { |
| 258 |
bl32->spsr = SPSR_64(MODE_EL1, MODE_SP_ELX, |
| 259 |
DISABLE_ALL_EXCEPTIONS); |
| 260 |
} |
| 261 |
} else { |
| 262 |
image = bl33; |
| 263 |
|
| 264 |
if (target_estate == XBL_FLAGS_ESTATE_A32) { |
| 265 |
if (target_el == XBL_FLAGS_EL2) { |
| 266 |
target_el = MODE32_hyp; |
| 267 |
} else { |
| 268 |
target_el = MODE32_sys; |
| 269 |
} |
| 270 |
|
| 271 |
bl33->spsr = SPSR_MODE32(target_el, SPSR_T_ARM, |
| 272 |
target_endianness, |
| 273 |
DISABLE_ALL_EXCEPTIONS); |
| 274 |
} else { |
| 275 |
if (target_el == XBL_FLAGS_EL2) { |
| 276 |
target_el = MODE_EL2; |
| 277 |
} else { |
| 278 |
target_el = MODE_EL1; |
| 279 |
} |
| 280 |
|
| 281 |
bl33->spsr = SPSR_64(target_el, MODE_SP_ELX, |
| 282 |
DISABLE_ALL_EXCEPTIONS); |
| 283 |
} |
| 284 |
} |
| 285 |
|
| 286 |
VERBOSE("Setting up %s entry point to:%" PRIx64 ", el:%x\n", |
| 287 |
(target_secure == XBL_FLAGS_SECURE) ? "BL32" : "BL33", |
| 288 |
HandoffParams->partition[i].entry_point, |
| 289 |
target_el); |
| 290 |
image->pc = HandoffParams->partition[i].entry_point; |
| 291 |
|
| 292 |
if (target_endianness == SPSR_E_BIG) { |
| 293 |
EP_SET_EE(image->h.attr, EP_EE_BIG); |
| 294 |
} else { |
| 295 |
EP_SET_EE(image->h.attr, EP_EE_LITTLE); |
| 296 |
} |
| 297 |
} |
| 298 |
|
| 299 |
return XBL_HANDOFF_SUCCESS; |
| 300 |
} |