blob: d65e02d5e1da0505fada2e80805280e746001255 [file] [log] [blame]
Achin Gupta7aea9082014-02-01 07:51:28 +00001/*
Paul Beesley1fbc97b2019-01-11 18:26:51 +00002 * Copyright (c) 2013-2019, ARM Limited and Contributors. All rights reserved.
Achin Gupta7aea9082014-02-01 07:51:28 +00003 *
dp-armfa3cf0b2017-05-03 09:38:09 +01004 * SPDX-License-Identifier: BSD-3-Clause
Achin Gupta7aea9082014-02-01 07:51:28 +00005 */
6
Antonio Nino Diaze0f90632018-12-14 00:18:21 +00007#include <assert.h>
8#include <stdbool.h>
9#include <string.h>
10
11#include <platform_def.h>
12
Achin Gupta27b895e2014-05-04 18:38:28 +010013#include <arch.h>
Achin Gupta7aea9082014-02-01 07:51:28 +000014#include <arch_helpers.h>
Soby Mathew830f0ad2019-07-12 09:23:38 +010015#include <arch_features.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000016#include <bl31/interrupt_mgmt.h>
17#include <common/bl_common.h>
Dan Handley2bd4ef22014-04-09 13:14:54 +010018#include <context.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000019#include <lib/el3_runtime/context_mgmt.h>
20#include <lib/el3_runtime/pubsub_events.h>
21#include <lib/extensions/amu.h>
22#include <lib/extensions/mpam.h>
23#include <lib/extensions/spe.h>
24#include <lib/extensions/sve.h>
25#include <lib/utils.h>
26#include <plat/common/platform.h>
Antonio Nino Diaz3c817f42018-03-21 10:49:27 +000027#include <smccc_helpers.h>
Achin Gupta7aea9082014-02-01 07:51:28 +000028
Achin Gupta7aea9082014-02-01 07:51:28 +000029
30/*******************************************************************************
31 * Context management library initialisation routine. This library is used by
32 * runtime services to share pointers to 'cpu_context' structures for the secure
33 * and non-secure states. Management of the structures and their associated
34 * memory is not done by the context management library e.g. the PSCI service
35 * manages the cpu context used for entry from and exit to the non-secure state.
36 * The Secure payload dispatcher service manages the context(s) corresponding to
37 * the secure state. It also uses this library to get access to the non-secure
38 * state cpu context pointers.
39 * Lastly, this library provides the api to make SP_EL3 point to the cpu context
40 * which will used for programming an entry into a lower EL. The same context
41 * will used to save state upon exception entry from that EL.
42 ******************************************************************************/
Daniel Boulby5753e492018-09-20 14:12:46 +010043void __init cm_init(void)
Achin Gupta7aea9082014-02-01 07:51:28 +000044{
45 /*
46 * The context management library has only global data to intialize, but
47 * that will be done when the BSS is zeroed out
48 */
49}
50
51/*******************************************************************************
Soby Mathewb0082d22015-04-09 13:40:55 +010052 * The following function initializes the cpu_context 'ctx' for
Andrew Thoelke4e126072014-06-04 21:10:52 +010053 * first use, and sets the initial entrypoint state as specified by the
54 * entry_point_info structure.
55 *
56 * The security state to initialize is determined by the SECURE attribute
Antonio Nino Diaz28dce9e2018-05-22 10:09:10 +010057 * of the entry_point_info.
Andrew Thoelke4e126072014-06-04 21:10:52 +010058 *
Paul Beesley1fbc97b2019-01-11 18:26:51 +000059 * The EE and ST attributes are used to configure the endianness and secure
Soby Mathewb0082d22015-04-09 13:40:55 +010060 * timer availability for the new execution context.
Andrew Thoelke4e126072014-06-04 21:10:52 +010061 *
62 * To prepare the register state for entry call cm_prepare_el3_exit() and
63 * el3_exit(). For Secure-EL1 cm_prepare_el3_exit() is equivalent to
64 * cm_e1_sysreg_context_restore().
65 ******************************************************************************/
Antonio Nino Diaz28dce9e2018-05-22 10:09:10 +010066void cm_setup_context(cpu_context_t *ctx, const entry_point_info_t *ep)
Andrew Thoelke4e126072014-06-04 21:10:52 +010067{
Soby Mathewb0082d22015-04-09 13:40:55 +010068 unsigned int security_state;
Alexei Fedorov503bbf32019-08-13 15:17:53 +010069 uint32_t scr_el3;
Andrew Thoelke4e126072014-06-04 21:10:52 +010070 el3_state_t *state;
71 gp_regs_t *gp_regs;
Deepika Bhavnanib0f26022019-09-03 21:08:51 +030072 u_register_t sctlr_elx, actlr_elx;
Andrew Thoelke4e126072014-06-04 21:10:52 +010073
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +000074 assert(ctx != NULL);
Andrew Thoelke4e126072014-06-04 21:10:52 +010075
Soby Mathewb0082d22015-04-09 13:40:55 +010076 security_state = GET_SECURITY_STATE(ep->h.attr);
77
Andrew Thoelke4e126072014-06-04 21:10:52 +010078 /* Clear any residual register values from the context */
Douglas Raillarda8954fc2017-01-26 15:54:44 +000079 zeromem(ctx, sizeof(*ctx));
Andrew Thoelke4e126072014-06-04 21:10:52 +010080
81 /*
David Cunadofee86532017-04-13 22:38:29 +010082 * SCR_EL3 was initialised during reset sequence in macro
83 * el3_arch_init_common. This code modifies the SCR_EL3 fields that
84 * affect the next EL.
85 *
86 * The following fields are initially set to zero and then updated to
87 * the required value depending on the state of the SPSR_EL3 and the
88 * Security state and entrypoint attributes of the next EL.
Andrew Thoelke4e126072014-06-04 21:10:52 +010089 */
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +000090 scr_el3 = (uint32_t)read_scr();
Andrew Thoelke4e126072014-06-04 21:10:52 +010091 scr_el3 &= ~(SCR_NS_BIT | SCR_RW_BIT | SCR_FIQ_BIT | SCR_IRQ_BIT |
92 SCR_ST_BIT | SCR_HCE_BIT);
David Cunadofee86532017-04-13 22:38:29 +010093 /*
94 * SCR_NS: Set the security state of the next EL.
95 */
Andrew Thoelke4e126072014-06-04 21:10:52 +010096 if (security_state != SECURE)
97 scr_el3 |= SCR_NS_BIT;
David Cunadofee86532017-04-13 22:38:29 +010098 /*
99 * SCR_EL3.RW: Set the execution state, AArch32 or AArch64, for next
100 * Exception level as specified by SPSR.
101 */
Andrew Thoelke4e126072014-06-04 21:10:52 +0100102 if (GET_RW(ep->spsr) == MODE_RW_64)
103 scr_el3 |= SCR_RW_BIT;
David Cunadofee86532017-04-13 22:38:29 +0100104 /*
105 * SCR_EL3.ST: Traps Secure EL1 accesses to the Counter-timer Physical
106 * Secure timer registers to EL3, from AArch64 state only, if specified
107 * by the entrypoint attributes.
108 */
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000109 if (EP_GET_ST(ep->h.attr) != 0U)
Andrew Thoelke4e126072014-06-04 21:10:52 +0100110 scr_el3 |= SCR_ST_BIT;
111
Julius Wernerc51a2ec2018-08-28 14:45:43 -0700112#if !HANDLE_EA_EL3_FIRST
David Cunadofee86532017-04-13 22:38:29 +0100113 /*
114 * SCR_EL3.EA: Do not route External Abort and SError Interrupt External
115 * to EL3 when executing at a lower EL. When executing at EL3, External
116 * Aborts are taken to EL3.
117 */
Gerald Lejeune632d6df2016-03-22 09:29:23 +0100118 scr_el3 &= ~SCR_EA_BIT;
119#endif
120
Jeenu Viswambharanf00da742017-12-08 12:13:51 +0000121#if FAULT_INJECTION_SUPPORT
122 /* Enable fault injection from lower ELs */
123 scr_el3 |= SCR_FIEN_BIT;
124#endif
125
Antonio Nino Diaz594811b2019-01-31 11:58:00 +0000126#if !CTX_INCLUDE_PAUTH_REGS
127 /*
128 * If the pointer authentication registers aren't saved during world
129 * switches the value of the registers can be leaked from the Secure to
130 * the Non-secure world. To prevent this, rather than enabling pointer
131 * authentication everywhere, we only enable it in the Non-secure world.
132 *
133 * If the Secure world wants to use pointer authentication,
134 * CTX_INCLUDE_PAUTH_REGS must be set to 1.
135 */
136 if (security_state == NON_SECURE)
137 scr_el3 |= SCR_API_BIT | SCR_APK_BIT;
138#endif /* !CTX_INCLUDE_PAUTH_REGS */
139
Soby Mathew830f0ad2019-07-12 09:23:38 +0100140 /*
Justin Chadwell1c7c13a2019-07-18 14:25:33 +0100141 * Enable MTE support. Support is enabled unilaterally for the normal
142 * world, and only for the secure world when CTX_INCLUDE_MTE_REGS is
143 * set.
Soby Mathew830f0ad2019-07-12 09:23:38 +0100144 */
Justin Chadwell1c7c13a2019-07-18 14:25:33 +0100145#if CTX_INCLUDE_MTE_REGS
Justin Chadwell05e030e2019-09-20 09:13:14 +0100146 assert(get_armv8_5_mte_support() == MTE_IMPLEMENTED_ELX);
Justin Chadwell1c7c13a2019-07-18 14:25:33 +0100147 scr_el3 |= SCR_ATA_BIT;
148#else
Justin Chadwell05e030e2019-09-20 09:13:14 +0100149 unsigned int mte = get_armv8_5_mte_support();
Justin Chadwell1c7c13a2019-07-18 14:25:33 +0100150 if (mte == MTE_IMPLEMENTED_EL0) {
151 /*
152 * Can enable MTE across both worlds as no MTE registers are
153 * used
154 */
155 scr_el3 |= SCR_ATA_BIT;
156 } else if (mte == MTE_IMPLEMENTED_ELX && security_state == NON_SECURE) {
157 /*
158 * Can only enable MTE in Non-Secure world without register
159 * saving
160 */
161 scr_el3 |= SCR_ATA_BIT;
Soby Mathew830f0ad2019-07-12 09:23:38 +0100162 }
Justin Chadwell1c7c13a2019-07-18 14:25:33 +0100163#endif
Soby Mathew830f0ad2019-07-12 09:23:38 +0100164
Masahiro Yamada441bfdd2016-12-25 23:36:24 +0900165#ifdef IMAGE_BL31
Yatharth Kochar6c0566c2015-10-02 17:56:48 +0100166 /*
Paul Beesley1fbc97b2019-01-11 18:26:51 +0000167 * SCR_EL3.IRQ, SCR_EL3.FIQ: Enable the physical FIQ and IRQ routing as
David Cunadofee86532017-04-13 22:38:29 +0100168 * indicated by the interrupt routing model for BL31.
Yatharth Kochar6c0566c2015-10-02 17:56:48 +0100169 */
Andrew Thoelke4e126072014-06-04 21:10:52 +0100170 scr_el3 |= get_scr_el3_from_routing_model(security_state);
Yatharth Kochar6c0566c2015-10-02 17:56:48 +0100171#endif
Andrew Thoelke4e126072014-06-04 21:10:52 +0100172
173 /*
David Cunadofee86532017-04-13 22:38:29 +0100174 * SCR_EL3.HCE: Enable HVC instructions if next execution state is
175 * AArch64 and next EL is EL2, or if next execution state is AArch32 and
176 * next mode is Hyp.
177 */
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000178 if (((GET_RW(ep->spsr) == MODE_RW_64) && (GET_EL(ep->spsr) == MODE_EL2))
179 || ((GET_RW(ep->spsr) != MODE_RW_64)
180 && (GET_M32(ep->spsr) == MODE32_hyp))) {
David Cunadofee86532017-04-13 22:38:29 +0100181 scr_el3 |= SCR_HCE_BIT;
182 }
183
184 /*
185 * Initialise SCTLR_EL1 to the reset value corresponding to the target
186 * execution state setting all fields rather than relying of the hw.
187 * Some fields have architecturally UNKNOWN reset values and these are
188 * set to zero.
Andrew Thoelke4e126072014-06-04 21:10:52 +0100189 *
David Cunadofee86532017-04-13 22:38:29 +0100190 * SCTLR.EE: Endianness is taken from the entrypoint attributes.
Andrew Thoelke4e126072014-06-04 21:10:52 +0100191 *
David Cunadofee86532017-04-13 22:38:29 +0100192 * SCTLR.M, SCTLR.C and SCTLR.I: These fields must be zero (as
193 * required by PSCI specification)
Andrew Thoelke4e126072014-06-04 21:10:52 +0100194 */
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000195 sctlr_elx = (EP_GET_EE(ep->h.attr) != 0U) ? SCTLR_EE_BIT : 0U;
Jens Wiklanderc93c9df2014-09-04 10:23:27 +0200196 if (GET_RW(ep->spsr) == MODE_RW_64)
197 sctlr_elx |= SCTLR_EL1_RES1;
Soby Mathewa993c422016-09-29 14:15:57 +0100198 else {
Soby Mathewa993c422016-09-29 14:15:57 +0100199 /*
David Cunadofee86532017-04-13 22:38:29 +0100200 * If the target execution state is AArch32 then the following
201 * fields need to be set.
202 *
203 * SCTRL_EL1.nTWE: Set to one so that EL0 execution of WFE
204 * instructions are not trapped to EL1.
205 *
206 * SCTLR_EL1.nTWI: Set to one so that EL0 execution of WFI
207 * instructions are not trapped to EL1.
208 *
209 * SCTLR_EL1.CP15BEN: Set to one to enable EL0 execution of the
210 * CP15DMB, CP15DSB, and CP15ISB instructions.
Soby Mathewa993c422016-09-29 14:15:57 +0100211 */
David Cunadofee86532017-04-13 22:38:29 +0100212 sctlr_elx |= SCTLR_AARCH32_EL1_RES1 | SCTLR_CP15BEN_BIT
213 | SCTLR_NTWI_BIT | SCTLR_NTWE_BIT;
Soby Mathewa993c422016-09-29 14:15:57 +0100214 }
215
Louis Mayencourt78a0aed2019-02-20 12:11:41 +0000216#if ERRATA_A75_764081
217 /*
218 * If workaround of errata 764081 for Cortex-A75 is used then set
219 * SCTLR_EL1.IESB to enable Implicit Error Synchronization Barrier.
220 */
221 sctlr_elx |= SCTLR_IESB_BIT;
222#endif
223
David Cunadofee86532017-04-13 22:38:29 +0100224 /*
225 * Store the initialised SCTLR_EL1 value in the cpu_context - SCTLR_EL2
Paul Beesley1fbc97b2019-01-11 18:26:51 +0000226 * and other EL2 registers are set up by cm_prepare_ns_entry() as they
David Cunadofee86532017-04-13 22:38:29 +0100227 * are not part of the stored cpu_context.
228 */
Andrew Thoelke4e126072014-06-04 21:10:52 +0100229 write_ctx_reg(get_sysregs_ctx(ctx), CTX_SCTLR_EL1, sctlr_elx);
230
Varun Wadekarb6dd0b32018-05-08 10:52:36 -0700231 /*
232 * Base the context ACTLR_EL1 on the current value, as it is
233 * implementation defined. The context restore process will write
234 * the value from the context to the actual register and can cause
235 * problems for processor cores that don't expect certain bits to
236 * be zero.
237 */
238 actlr_elx = read_actlr_el1();
239 write_ctx_reg((get_sysregs_ctx(ctx)), (CTX_ACTLR_EL1), (actlr_elx));
240
Alexei Fedorov503bbf32019-08-13 15:17:53 +0100241 /*
242 * Populate EL3 state so that we've the right context
243 * before doing ERET
244 */
Andrew Thoelke4e126072014-06-04 21:10:52 +0100245 state = get_el3state_ctx(ctx);
246 write_ctx_reg(state, CTX_SCR_EL3, scr_el3);
247 write_ctx_reg(state, CTX_ELR_EL3, ep->pc);
248 write_ctx_reg(state, CTX_SPSR_EL3, ep->spsr);
249
250 /*
251 * Store the X0-X7 value from the entrypoint into the context
252 * Use memcpy as we are in control of the layout of the structures
253 */
254 gp_regs = get_gpregs_ctx(ctx);
255 memcpy(gp_regs, (void *)&ep->args, sizeof(aapcs64_params_t));
256}
257
258/*******************************************************************************
Dimitris Papastamos1e6f93e2017-11-07 09:55:29 +0000259 * Enable architecture extensions on first entry to Non-secure world.
260 * When EL2 is implemented but unused `el2_unused` is non-zero, otherwise
261 * it is zero.
262 ******************************************************************************/
Antonio Nino Diaz033b4bb2018-10-25 16:52:26 +0100263static void enable_extensions_nonsecure(bool el2_unused)
Dimitris Papastamos1e6f93e2017-11-07 09:55:29 +0000264{
265#if IMAGE_BL31
Dimitris Papastamos5bdbb472017-10-13 12:06:06 +0100266#if ENABLE_SPE_FOR_LOWER_ELS
267 spe_enable(el2_unused);
268#endif
Dimitris Papastamose08005a2017-10-12 13:02:29 +0100269
270#if ENABLE_AMU
271 amu_enable(el2_unused);
272#endif
David Cunadoce88eee2017-10-20 11:30:57 +0100273
274#if ENABLE_SVE_FOR_NS
275 sve_enable(el2_unused);
276#endif
Jeenu Viswambharan2da918c2018-07-31 16:13:33 +0100277
278#if ENABLE_MPAM_FOR_LOWER_ELS
279 mpam_enable(el2_unused);
280#endif
Dimitris Papastamos1e6f93e2017-11-07 09:55:29 +0000281#endif
282}
283
284/*******************************************************************************
Soby Mathewb0082d22015-04-09 13:40:55 +0100285 * The following function initializes the cpu_context for a CPU specified by
286 * its `cpu_idx` for first use, and sets the initial entrypoint state as
287 * specified by the entry_point_info structure.
288 ******************************************************************************/
289void cm_init_context_by_index(unsigned int cpu_idx,
290 const entry_point_info_t *ep)
291{
292 cpu_context_t *ctx;
293 ctx = cm_get_context_by_index(cpu_idx, GET_SECURITY_STATE(ep->h.attr));
Antonio Nino Diaz28dce9e2018-05-22 10:09:10 +0100294 cm_setup_context(ctx, ep);
Soby Mathewb0082d22015-04-09 13:40:55 +0100295}
296
297/*******************************************************************************
298 * The following function initializes the cpu_context for the current CPU
299 * for first use, and sets the initial entrypoint state as specified by the
300 * entry_point_info structure.
301 ******************************************************************************/
302void cm_init_my_context(const entry_point_info_t *ep)
303{
304 cpu_context_t *ctx;
305 ctx = cm_get_context(GET_SECURITY_STATE(ep->h.attr));
Antonio Nino Diaz28dce9e2018-05-22 10:09:10 +0100306 cm_setup_context(ctx, ep);
Soby Mathewb0082d22015-04-09 13:40:55 +0100307}
308
309/*******************************************************************************
Andrew Thoelke4e126072014-06-04 21:10:52 +0100310 * Prepare the CPU system registers for first entry into secure or normal world
311 *
312 * If execution is requested to EL2 or hyp mode, SCTLR_EL2 is initialized
313 * If execution is requested to non-secure EL1 or svc mode, and the CPU supports
314 * EL2 then EL2 is disabled by configuring all necessary EL2 registers.
315 * For all entries, the EL1 registers are initialized from the cpu_context
316 ******************************************************************************/
317void cm_prepare_el3_exit(uint32_t security_state)
318{
dp-armee3457b2017-05-23 09:32:49 +0100319 uint32_t sctlr_elx, scr_el3, mdcr_el2;
Andrew Thoelke4e126072014-06-04 21:10:52 +0100320 cpu_context_t *ctx = cm_get_context(security_state);
Antonio Nino Diaz033b4bb2018-10-25 16:52:26 +0100321 bool el2_unused = false;
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000322 uint64_t hcr_el2 = 0U;
Andrew Thoelke4e126072014-06-04 21:10:52 +0100323
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000324 assert(ctx != NULL);
Andrew Thoelke4e126072014-06-04 21:10:52 +0100325
326 if (security_state == NON_SECURE) {
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000327 scr_el3 = (uint32_t)read_ctx_reg(get_el3state_ctx(ctx),
328 CTX_SCR_EL3);
329 if ((scr_el3 & SCR_HCE_BIT) != 0U) {
Andrew Thoelke4e126072014-06-04 21:10:52 +0100330 /* Use SCTLR_EL1.EE value to initialise sctlr_el2 */
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000331 sctlr_elx = (uint32_t)read_ctx_reg(get_sysregs_ctx(ctx),
332 CTX_SCTLR_EL1);
Ken Kuang00eac152017-08-23 16:03:29 +0800333 sctlr_elx &= SCTLR_EE_BIT;
Andrew Thoelke4e126072014-06-04 21:10:52 +0100334 sctlr_elx |= SCTLR_EL2_RES1;
Louis Mayencourt78a0aed2019-02-20 12:11:41 +0000335#if ERRATA_A75_764081
336 /*
337 * If workaround of errata 764081 for Cortex-A75 is used
338 * then set SCTLR_EL2.IESB to enable Implicit Error
339 * Synchronization Barrier.
340 */
341 sctlr_elx |= SCTLR_IESB_BIT;
342#endif
Andrew Thoelke4e126072014-06-04 21:10:52 +0100343 write_sctlr_el2(sctlr_elx);
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000344 } else if (el_implemented(2) != EL_IMPL_NONE) {
Antonio Nino Diaz033b4bb2018-10-25 16:52:26 +0100345 el2_unused = true;
Dimitris Papastamos1e6f93e2017-11-07 09:55:29 +0000346
David Cunadofee86532017-04-13 22:38:29 +0100347 /*
348 * EL2 present but unused, need to disable safely.
349 * SCTLR_EL2 can be ignored in this case.
350 *
Jeenu Viswambharancbad6612018-08-15 14:29:29 +0100351 * Set EL2 register width appropriately: Set HCR_EL2
352 * field to match SCR_EL3.RW.
David Cunadofee86532017-04-13 22:38:29 +0100353 */
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000354 if ((scr_el3 & SCR_RW_BIT) != 0U)
Jeenu Viswambharancbad6612018-08-15 14:29:29 +0100355 hcr_el2 |= HCR_RW_BIT;
356
357 /*
358 * For Armv8.3 pointer authentication feature, disable
359 * traps to EL2 when accessing key registers or using
360 * pointer authentication instructions from lower ELs.
361 */
362 hcr_el2 |= (HCR_API_BIT | HCR_APK_BIT);
363
364 write_hcr_el2(hcr_el2);
Andrew Thoelke4e126072014-06-04 21:10:52 +0100365
David Cunadofee86532017-04-13 22:38:29 +0100366 /*
367 * Initialise CPTR_EL2 setting all fields rather than
368 * relying on the hw. All fields have architecturally
369 * UNKNOWN reset values.
370 *
371 * CPTR_EL2.TCPAC: Set to zero so that Non-secure EL1
372 * accesses to the CPACR_EL1 or CPACR from both
373 * Execution states do not trap to EL2.
374 *
375 * CPTR_EL2.TTA: Set to zero so that Non-secure System
376 * register accesses to the trace registers from both
377 * Execution states do not trap to EL2.
378 *
379 * CPTR_EL2.TFP: Set to zero so that Non-secure accesses
380 * to SIMD and floating-point functionality from both
381 * Execution states do not trap to EL2.
382 */
383 write_cptr_el2(CPTR_EL2_RESET_VAL &
384 ~(CPTR_EL2_TCPAC_BIT | CPTR_EL2_TTA_BIT
385 | CPTR_EL2_TFP_BIT));
Andrew Thoelke4e126072014-06-04 21:10:52 +0100386
David Cunadofee86532017-04-13 22:38:29 +0100387 /*
Paul Beesley1fbc97b2019-01-11 18:26:51 +0000388 * Initialise CNTHCTL_EL2. All fields are
David Cunadofee86532017-04-13 22:38:29 +0100389 * architecturally UNKNOWN on reset and are set to zero
390 * except for field(s) listed below.
391 *
392 * CNTHCTL_EL2.EL1PCEN: Set to one to disable traps to
393 * Hyp mode of Non-secure EL0 and EL1 accesses to the
394 * physical timer registers.
395 *
396 * CNTHCTL_EL2.EL1PCTEN: Set to one to disable traps to
397 * Hyp mode of Non-secure EL0 and EL1 accesses to the
398 * physical counter registers.
399 */
400 write_cnthctl_el2(CNTHCTL_RESET_VAL |
401 EL1PCEN_BIT | EL1PCTEN_BIT);
Andrew Thoelke4e126072014-06-04 21:10:52 +0100402
David Cunadofee86532017-04-13 22:38:29 +0100403 /*
404 * Initialise CNTVOFF_EL2 to zero as it resets to an
405 * architecturally UNKNOWN value.
406 */
Soby Mathewfeddfcf2014-08-29 14:41:58 +0100407 write_cntvoff_el2(0);
408
David Cunadofee86532017-04-13 22:38:29 +0100409 /*
410 * Set VPIDR_EL2 and VMPIDR_EL2 to match MIDR_EL1 and
411 * MPIDR_EL1 respectively.
412 */
Andrew Thoelke4e126072014-06-04 21:10:52 +0100413 write_vpidr_el2(read_midr_el1());
414 write_vmpidr_el2(read_mpidr_el1());
Sandrine Bailleux8b0eafe2015-11-25 17:00:44 +0000415
416 /*
David Cunadofee86532017-04-13 22:38:29 +0100417 * Initialise VTTBR_EL2. All fields are architecturally
418 * UNKNOWN on reset.
419 *
420 * VTTBR_EL2.VMID: Set to zero. Even though EL1&0 stage
421 * 2 address translation is disabled, cache maintenance
422 * operations depend on the VMID.
423 *
424 * VTTBR_EL2.BADDR: Set to zero as EL1&0 stage 2 address
425 * translation is disabled.
Sandrine Bailleux8b0eafe2015-11-25 17:00:44 +0000426 */
David Cunadofee86532017-04-13 22:38:29 +0100427 write_vttbr_el2(VTTBR_RESET_VAL &
428 ~((VTTBR_VMID_MASK << VTTBR_VMID_SHIFT)
429 | (VTTBR_BADDR_MASK << VTTBR_BADDR_SHIFT)));
430
David Cunado5f55e282016-10-31 17:37:34 +0000431 /*
David Cunadofee86532017-04-13 22:38:29 +0100432 * Initialise MDCR_EL2, setting all fields rather than
433 * relying on hw. Some fields are architecturally
434 * UNKNOWN on reset.
435 *
Alexei Fedorov503bbf32019-08-13 15:17:53 +0100436 * MDCR_EL2.HLP: Set to one so that event counter
437 * overflow, that is recorded in PMOVSCLR_EL0[0-30],
438 * occurs on the increment that changes
439 * PMEVCNTR<n>_EL0[63] from 1 to 0, when ARMv8.5-PMU is
440 * implemented. This bit is RES0 in versions of the
441 * architecture earlier than ARMv8.5, setting it to 1
442 * doesn't have any effect on them.
443 *
444 * MDCR_EL2.TTRF: Set to zero so that access to Trace
445 * Filter Control register TRFCR_EL1 at EL1 is not
446 * trapped to EL2. This bit is RES0 in versions of
447 * the architecture earlier than ARMv8.4.
448 *
449 * MDCR_EL2.HPMD: Set to one so that event counting is
450 * prohibited at EL2. This bit is RES0 in versions of
451 * the architecture earlier than ARMv8.1, setting it
452 * to 1 doesn't have any effect on them.
453 *
454 * MDCR_EL2.TPMS: Set to zero so that accesses to
455 * Statistical Profiling control registers from EL1
456 * do not trap to EL2. This bit is RES0 when SPE is
457 * not implemented.
458 *
David Cunadofee86532017-04-13 22:38:29 +0100459 * MDCR_EL2.TDRA: Set to zero so that Non-secure EL0 and
460 * EL1 System register accesses to the Debug ROM
461 * registers are not trapped to EL2.
462 *
463 * MDCR_EL2.TDOSA: Set to zero so that Non-secure EL1
464 * System register accesses to the powerdown debug
465 * registers are not trapped to EL2.
466 *
467 * MDCR_EL2.TDA: Set to zero so that System register
468 * accesses to the debug registers do not trap to EL2.
469 *
470 * MDCR_EL2.TDE: Set to zero so that debug exceptions
471 * are not routed to EL2.
472 *
473 * MDCR_EL2.HPME: Set to zero to disable EL2 Performance
474 * Monitors.
475 *
476 * MDCR_EL2.TPM: Set to zero so that Non-secure EL0 and
477 * EL1 accesses to all Performance Monitors registers
478 * are not trapped to EL2.
479 *
480 * MDCR_EL2.TPMCR: Set to zero so that Non-secure EL0
481 * and EL1 accesses to the PMCR_EL0 or PMCR are not
482 * trapped to EL2.
483 *
484 * MDCR_EL2.HPMN: Set to value of PMCR_EL0.N which is the
485 * architecturally-defined reset value.
David Cunado5f55e282016-10-31 17:37:34 +0000486 */
Alexei Fedorov503bbf32019-08-13 15:17:53 +0100487 mdcr_el2 = ((MDCR_EL2_RESET_VAL | MDCR_EL2_HLP |
488 MDCR_EL2_HPMD) |
489 ((read_pmcr_el0() & PMCR_EL0_N_BITS)
490 >> PMCR_EL0_N_SHIFT)) &
491 ~(MDCR_EL2_TTRF | MDCR_EL2_TPMS |
492 MDCR_EL2_TDRA_BIT | MDCR_EL2_TDOSA_BIT |
493 MDCR_EL2_TDA_BIT | MDCR_EL2_TDE_BIT |
494 MDCR_EL2_HPME_BIT | MDCR_EL2_TPM_BIT |
495 MDCR_EL2_TPMCR_BIT);
dp-armee3457b2017-05-23 09:32:49 +0100496
dp-armee3457b2017-05-23 09:32:49 +0100497 write_mdcr_el2(mdcr_el2);
498
David Cunadoc14b08e2016-11-25 00:21:59 +0000499 /*
David Cunadofee86532017-04-13 22:38:29 +0100500 * Initialise HSTR_EL2. All fields are architecturally
501 * UNKNOWN on reset.
502 *
503 * HSTR_EL2.T<n>: Set all these fields to zero so that
504 * Non-secure EL0 or EL1 accesses to System registers
505 * do not trap to EL2.
David Cunadoc14b08e2016-11-25 00:21:59 +0000506 */
David Cunadofee86532017-04-13 22:38:29 +0100507 write_hstr_el2(HSTR_EL2_RESET_VAL & ~(HSTR_EL2_T_MASK));
David Cunadoc14b08e2016-11-25 00:21:59 +0000508 /*
David Cunadofee86532017-04-13 22:38:29 +0100509 * Initialise CNTHP_CTL_EL2. All fields are
510 * architecturally UNKNOWN on reset.
511 *
512 * CNTHP_CTL_EL2:ENABLE: Set to zero to disable the EL2
513 * physical timer and prevent timer interrupts.
David Cunadoc14b08e2016-11-25 00:21:59 +0000514 */
David Cunadofee86532017-04-13 22:38:29 +0100515 write_cnthp_ctl_el2(CNTHP_CTL_RESET_VAL &
516 ~(CNTHP_CTL_ENABLE_BIT));
Andrew Thoelke4e126072014-06-04 21:10:52 +0100517 }
Dimitris Papastamos1e6f93e2017-11-07 09:55:29 +0000518 enable_extensions_nonsecure(el2_unused);
Andrew Thoelke4e126072014-06-04 21:10:52 +0100519 }
520
Dimitris Papastamosa7921b92017-10-13 15:27:58 +0100521 cm_el1_sysregs_context_restore(security_state);
522 cm_set_next_eret_context(security_state);
Andrew Thoelke4e126072014-06-04 21:10:52 +0100523}
524
525/*******************************************************************************
Soby Mathew2ed46e92014-07-04 16:02:26 +0100526 * The next four functions are used by runtime services to save and restore
527 * EL1 context on the 'cpu_context' structure for the specified security
Achin Gupta7aea9082014-02-01 07:51:28 +0000528 * state.
529 ******************************************************************************/
Achin Gupta7aea9082014-02-01 07:51:28 +0000530void cm_el1_sysregs_context_save(uint32_t security_state)
531{
Dan Handleye2712bc2014-04-10 15:37:22 +0100532 cpu_context_t *ctx;
Achin Gupta7aea9082014-02-01 07:51:28 +0000533
Andrew Thoelkea2f65532014-05-14 17:09:32 +0100534 ctx = cm_get_context(security_state);
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000535 assert(ctx != NULL);
Achin Gupta7aea9082014-02-01 07:51:28 +0000536
537 el1_sysregs_context_save(get_sysregs_ctx(ctx));
Dimitris Papastamosa7921b92017-10-13 15:27:58 +0100538
539#if IMAGE_BL31
540 if (security_state == SECURE)
541 PUBLISH_EVENT(cm_exited_secure_world);
542 else
543 PUBLISH_EVENT(cm_exited_normal_world);
544#endif
Achin Gupta7aea9082014-02-01 07:51:28 +0000545}
546
547void cm_el1_sysregs_context_restore(uint32_t security_state)
548{
Dan Handleye2712bc2014-04-10 15:37:22 +0100549 cpu_context_t *ctx;
Achin Gupta7aea9082014-02-01 07:51:28 +0000550
Andrew Thoelkea2f65532014-05-14 17:09:32 +0100551 ctx = cm_get_context(security_state);
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000552 assert(ctx != NULL);
Achin Gupta7aea9082014-02-01 07:51:28 +0000553
554 el1_sysregs_context_restore(get_sysregs_ctx(ctx));
Dimitris Papastamosa7921b92017-10-13 15:27:58 +0100555
556#if IMAGE_BL31
557 if (security_state == SECURE)
558 PUBLISH_EVENT(cm_entering_secure_world);
559 else
560 PUBLISH_EVENT(cm_entering_normal_world);
561#endif
Achin Gupta7aea9082014-02-01 07:51:28 +0000562}
563
564/*******************************************************************************
Andrew Thoelke4e126072014-06-04 21:10:52 +0100565 * This function populates ELR_EL3 member of 'cpu_context' pertaining to the
566 * given security state with the given entrypoint
Jeenu Viswambharancaa84932014-02-06 10:36:15 +0000567 ******************************************************************************/
Soby Mathewa0fedc42016-06-16 14:52:04 +0100568void cm_set_elr_el3(uint32_t security_state, uintptr_t entrypoint)
Jeenu Viswambharancaa84932014-02-06 10:36:15 +0000569{
Dan Handleye2712bc2014-04-10 15:37:22 +0100570 cpu_context_t *ctx;
571 el3_state_t *state;
Jeenu Viswambharancaa84932014-02-06 10:36:15 +0000572
Andrew Thoelkea2f65532014-05-14 17:09:32 +0100573 ctx = cm_get_context(security_state);
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000574 assert(ctx != NULL);
Jeenu Viswambharancaa84932014-02-06 10:36:15 +0000575
Andrew Thoelke4e126072014-06-04 21:10:52 +0100576 /* Populate EL3 state so that ERET jumps to the correct entry */
Jeenu Viswambharancaa84932014-02-06 10:36:15 +0000577 state = get_el3state_ctx(ctx);
Jeenu Viswambharancaa84932014-02-06 10:36:15 +0000578 write_ctx_reg(state, CTX_ELR_EL3, entrypoint);
Jeenu Viswambharancaa84932014-02-06 10:36:15 +0000579}
580
581/*******************************************************************************
Andrew Thoelke4e126072014-06-04 21:10:52 +0100582 * This function populates ELR_EL3 and SPSR_EL3 members of 'cpu_context'
583 * pertaining to the given security state
Achin Gupta607084e2014-02-09 18:24:19 +0000584 ******************************************************************************/
Andrew Thoelke4e126072014-06-04 21:10:52 +0100585void cm_set_elr_spsr_el3(uint32_t security_state,
Soby Mathewa0fedc42016-06-16 14:52:04 +0100586 uintptr_t entrypoint, uint32_t spsr)
Achin Gupta607084e2014-02-09 18:24:19 +0000587{
Dan Handleye2712bc2014-04-10 15:37:22 +0100588 cpu_context_t *ctx;
589 el3_state_t *state;
Achin Gupta607084e2014-02-09 18:24:19 +0000590
Andrew Thoelkea2f65532014-05-14 17:09:32 +0100591 ctx = cm_get_context(security_state);
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000592 assert(ctx != NULL);
Achin Gupta607084e2014-02-09 18:24:19 +0000593
594 /* Populate EL3 state so that ERET jumps to the correct entry */
595 state = get_el3state_ctx(ctx);
596 write_ctx_reg(state, CTX_ELR_EL3, entrypoint);
Andrew Thoelke4e126072014-06-04 21:10:52 +0100597 write_ctx_reg(state, CTX_SPSR_EL3, spsr);
Achin Gupta607084e2014-02-09 18:24:19 +0000598}
599
600/*******************************************************************************
Achin Gupta27b895e2014-05-04 18:38:28 +0100601 * This function updates a single bit in the SCR_EL3 member of the 'cpu_context'
602 * pertaining to the given security state using the value and bit position
603 * specified in the parameters. It preserves all other bits.
604 ******************************************************************************/
605void cm_write_scr_el3_bit(uint32_t security_state,
606 uint32_t bit_pos,
607 uint32_t value)
608{
609 cpu_context_t *ctx;
610 el3_state_t *state;
611 uint32_t scr_el3;
612
Andrew Thoelkea2f65532014-05-14 17:09:32 +0100613 ctx = cm_get_context(security_state);
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000614 assert(ctx != NULL);
Achin Gupta27b895e2014-05-04 18:38:28 +0100615
616 /* Ensure that the bit position is a valid one */
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000617 assert(((1U << bit_pos) & SCR_VALID_BIT_MASK) != 0U);
Achin Gupta27b895e2014-05-04 18:38:28 +0100618
619 /* Ensure that the 'value' is only a bit wide */
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000620 assert(value <= 1U);
Achin Gupta27b895e2014-05-04 18:38:28 +0100621
622 /*
623 * Get the SCR_EL3 value from the cpu context, clear the desired bit
624 * and set it to its new value.
625 */
626 state = get_el3state_ctx(ctx);
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000627 scr_el3 = (uint32_t)read_ctx_reg(state, CTX_SCR_EL3);
628 scr_el3 &= ~(1U << bit_pos);
Achin Gupta27b895e2014-05-04 18:38:28 +0100629 scr_el3 |= value << bit_pos;
630 write_ctx_reg(state, CTX_SCR_EL3, scr_el3);
631}
632
633/*******************************************************************************
634 * This function retrieves SCR_EL3 member of 'cpu_context' pertaining to the
635 * given security state.
636 ******************************************************************************/
637uint32_t cm_get_scr_el3(uint32_t security_state)
638{
639 cpu_context_t *ctx;
640 el3_state_t *state;
641
Andrew Thoelkea2f65532014-05-14 17:09:32 +0100642 ctx = cm_get_context(security_state);
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000643 assert(ctx != NULL);
Achin Gupta27b895e2014-05-04 18:38:28 +0100644
645 /* Populate EL3 state so that ERET jumps to the correct entry */
646 state = get_el3state_ctx(ctx);
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000647 return (uint32_t)read_ctx_reg(state, CTX_SCR_EL3);
Achin Gupta27b895e2014-05-04 18:38:28 +0100648}
649
650/*******************************************************************************
Jeenu Viswambharancaa84932014-02-06 10:36:15 +0000651 * This function is used to program the context that's used for exception
652 * return. This initializes the SP_EL3 to a pointer to a 'cpu_context' set for
653 * the required security state
Achin Gupta7aea9082014-02-01 07:51:28 +0000654 ******************************************************************************/
655void cm_set_next_eret_context(uint32_t security_state)
656{
Dan Handleye2712bc2014-04-10 15:37:22 +0100657 cpu_context_t *ctx;
Jeenu Viswambharancaa84932014-02-06 10:36:15 +0000658
Andrew Thoelkea2f65532014-05-14 17:09:32 +0100659 ctx = cm_get_context(security_state);
Antonio Nino Diaz864ca6f2018-10-31 15:25:35 +0000660 assert(ctx != NULL);
Achin Gupta7aea9082014-02-01 07:51:28 +0000661
Andrew Thoelke4e126072014-06-04 21:10:52 +0100662 cm_set_next_context(ctx);
Achin Gupta7aea9082014-02-01 07:51:28 +0000663}