1 /* 2 * Copyright (c) 2013-2016, ARM Limited and Contributors. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * 7 * Redistributions of source code must retain the above copyright notice, this 8 * list of conditions and the following disclaimer. 9 * 10 * Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 14 * Neither the name of ARM nor the names of its contributors may be used 15 * to endorse or promote products derived from this software without specific 16 * prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #ifndef __CONTEXT_H__ 32 #define __CONTEXT_H__ 33 34 /******************************************************************************* 35 * Constants that allow assembler code to access members of and the 'gp_regs' 36 * structure at their correct offsets. 37 ******************************************************************************/ 38 #define CTX_GPREGS_OFFSET 0x0 39 #define CTX_GPREG_X0 0x0 40 #define CTX_GPREG_X1 0x8 41 #define CTX_GPREG_X2 0x10 42 #define CTX_GPREG_X3 0x18 43 #define CTX_GPREG_X4 0x20 44 #define CTX_GPREG_X5 0x28 45 #define CTX_GPREG_X6 0x30 46 #define CTX_GPREG_X7 0x38 47 #define CTX_GPREG_X8 0x40 48 #define CTX_GPREG_X9 0x48 49 #define CTX_GPREG_X10 0x50 50 #define CTX_GPREG_X11 0x58 51 #define CTX_GPREG_X12 0x60 52 #define CTX_GPREG_X13 0x68 53 #define CTX_GPREG_X14 0x70 54 #define CTX_GPREG_X15 0x78 55 #define CTX_GPREG_X16 0x80 56 #define CTX_GPREG_X17 0x88 57 #define CTX_GPREG_X18 0x90 58 #define CTX_GPREG_X19 0x98 59 #define CTX_GPREG_X20 0xa0 60 #define CTX_GPREG_X21 0xa8 61 #define CTX_GPREG_X22 0xb0 62 #define CTX_GPREG_X23 0xb8 63 #define CTX_GPREG_X24 0xc0 64 #define CTX_GPREG_X25 0xc8 65 #define CTX_GPREG_X26 0xd0 66 #define CTX_GPREG_X27 0xd8 67 #define CTX_GPREG_X28 0xe0 68 #define CTX_GPREG_X29 0xe8 69 #define CTX_GPREG_LR 0xf0 70 #define CTX_GPREG_SP_EL0 0xf8 71 #define CTX_GPREGS_END 0x100 72 73 /******************************************************************************* 74 * Constants that allow assembler code to access members of and the 'el3_state' 75 * structure at their correct offsets. Note that some of the registers are only 76 * 32-bits wide but are stored as 64-bit values for convenience 77 ******************************************************************************/ 78 #define CTX_EL3STATE_OFFSET (CTX_GPREGS_OFFSET + CTX_GPREGS_END) 79 #define CTX_SCR_EL3 0x0 80 #define CTX_RUNTIME_SP 0x8 81 #define CTX_SPSR_EL3 0x10 82 #define CTX_ELR_EL3 0x18 83 #define CTX_EL3STATE_END 0x20 84 85 /******************************************************************************* 86 * Constants that allow assembler code to access members of and the 87 * 'el1_sys_regs' structure at their correct offsets. Note that some of the 88 * registers are only 32-bits wide but are stored as 64-bit values for 89 * convenience 90 ******************************************************************************/ 91 #define CTX_SYSREGS_OFFSET (CTX_EL3STATE_OFFSET + CTX_EL3STATE_END) 92 #define CTX_SPSR_EL1 0x0 93 #define CTX_ELR_EL1 0x8 94 #define CTX_SCTLR_EL1 0x10 95 #define CTX_ACTLR_EL1 0x18 96 #define CTX_CPACR_EL1 0x20 97 #define CTX_CSSELR_EL1 0x28 98 #define CTX_SP_EL1 0x30 99 #define CTX_ESR_EL1 0x38 100 #define CTX_TTBR0_EL1 0x40 101 #define CTX_TTBR1_EL1 0x48 102 #define CTX_MAIR_EL1 0x50 103 #define CTX_AMAIR_EL1 0x58 104 #define CTX_TCR_EL1 0x60 105 #define CTX_TPIDR_EL1 0x68 106 #define CTX_TPIDR_EL0 0x70 107 #define CTX_TPIDRRO_EL0 0x78 108 #define CTX_PAR_EL1 0x80 109 #define CTX_FAR_EL1 0x88 110 #define CTX_AFSR0_EL1 0x90 111 #define CTX_AFSR1_EL1 0x98 112 #define CTX_CONTEXTIDR_EL1 0xa0 113 #define CTX_VBAR_EL1 0xa8 114 115 /* 116 * If the platform is AArch64-only, there is no need to save and restore these 117 * AArch32 registers. 118 */ 119 #if CTX_INCLUDE_AARCH32_REGS 120 #define CTX_SPSR_ABT 0xb0 121 #define CTX_SPSR_UND 0xb8 122 #define CTX_SPSR_IRQ 0xc0 123 #define CTX_SPSR_FIQ 0xc8 124 #define CTX_DACR32_EL2 0xd0 125 #define CTX_IFSR32_EL2 0xd8 126 #define CTX_FP_FPEXC32_EL2 0xe0 127 #define CTX_TIMER_SYSREGS_OFF 0xf0 /* Align to the next 16 byte boundary */ 128 #else 129 #define CTX_TIMER_SYSREGS_OFF 0xb0 130 #endif /* __CTX_INCLUDE_AARCH32_REGS__ */ 131 132 /* 133 * If the timer registers aren't saved and restored, we don't have to reserve 134 * space for them in the context 135 */ 136 #if NS_TIMER_SWITCH 137 #define CTX_CNTP_CTL_EL0 (CTX_TIMER_SYSREGS_OFF + 0x0) 138 #define CTX_CNTP_CVAL_EL0 (CTX_TIMER_SYSREGS_OFF + 0x8) 139 #define CTX_CNTV_CTL_EL0 (CTX_TIMER_SYSREGS_OFF + 0x10) 140 #define CTX_CNTV_CVAL_EL0 (CTX_TIMER_SYSREGS_OFF + 0x18) 141 #define CTX_CNTKCTL_EL1 (CTX_TIMER_SYSREGS_OFF + 0x20) 142 #define CTX_SYSREGS_END (CTX_TIMER_SYSREGS_OFF + 0x30) /* Align to the next 16 byte boundary */ 143 #else 144 #define CTX_SYSREGS_END CTX_TIMER_SYSREGS_OFF 145 #endif /* __NS_TIMER_SWITCH__ */ 146 147 /******************************************************************************* 148 * Constants that allow assembler code to access members of and the 'fp_regs' 149 * structure at their correct offsets. 150 ******************************************************************************/ 151 #if CTX_INCLUDE_FPREGS 152 #define CTX_FPREGS_OFFSET (CTX_SYSREGS_OFFSET + CTX_SYSREGS_END) 153 #define CTX_FP_Q0 0x0 154 #define CTX_FP_Q1 0x10 155 #define CTX_FP_Q2 0x20 156 #define CTX_FP_Q3 0x30 157 #define CTX_FP_Q4 0x40 158 #define CTX_FP_Q5 0x50 159 #define CTX_FP_Q6 0x60 160 #define CTX_FP_Q7 0x70 161 #define CTX_FP_Q8 0x80 162 #define CTX_FP_Q9 0x90 163 #define CTX_FP_Q10 0xa0 164 #define CTX_FP_Q11 0xb0 165 #define CTX_FP_Q12 0xc0 166 #define CTX_FP_Q13 0xd0 167 #define CTX_FP_Q14 0xe0 168 #define CTX_FP_Q15 0xf0 169 #define CTX_FP_Q16 0x100 170 #define CTX_FP_Q17 0x110 171 #define CTX_FP_Q18 0x120 172 #define CTX_FP_Q19 0x130 173 #define CTX_FP_Q20 0x140 174 #define CTX_FP_Q21 0x150 175 #define CTX_FP_Q22 0x160 176 #define CTX_FP_Q23 0x170 177 #define CTX_FP_Q24 0x180 178 #define CTX_FP_Q25 0x190 179 #define CTX_FP_Q26 0x1a0 180 #define CTX_FP_Q27 0x1b0 181 #define CTX_FP_Q28 0x1c0 182 #define CTX_FP_Q29 0x1d0 183 #define CTX_FP_Q30 0x1e0 184 #define CTX_FP_Q31 0x1f0 185 #define CTX_FP_FPSR 0x200 186 #define CTX_FP_FPCR 0x208 187 #define CTX_FPREGS_END 0x210 188 #endif 189 190 #ifndef __ASSEMBLY__ 191 192 #include <cassert.h> 193 #include <platform_def.h> /* for CACHE_WRITEBACK_GRANULE */ 194 #include <stdint.h> 195 196 /* 197 * Common constants to help define the 'cpu_context' structure and its 198 * members below. 199 */ 200 #define DWORD_SHIFT 3 201 #define DEFINE_REG_STRUCT(name, num_regs) \ 202 typedef struct name { \ 203 uint64_t _regs[num_regs]; \ 204 } __aligned(16) name##_t 205 206 /* Constants to determine the size of individual context structures */ 207 #define CTX_GPREG_ALL (CTX_GPREGS_END >> DWORD_SHIFT) 208 #define CTX_SYSREG_ALL (CTX_SYSREGS_END >> DWORD_SHIFT) 209 #if CTX_INCLUDE_FPREGS 210 #define CTX_FPREG_ALL (CTX_FPREGS_END >> DWORD_SHIFT) 211 #endif 212 #define CTX_EL3STATE_ALL (CTX_EL3STATE_END >> DWORD_SHIFT) 213 214 /* 215 * AArch64 general purpose register context structure. Usually x0-x18, 216 * lr are saved as the compiler is expected to preserve the remaining 217 * callee saved registers if used by the C runtime and the assembler 218 * does not touch the remaining. But in case of world switch during 219 * exception handling, we need to save the callee registers too. 220 */ 221 DEFINE_REG_STRUCT(gp_regs, CTX_GPREG_ALL); 222 223 /* 224 * AArch64 EL1 system register context structure for preserving the 225 * architectural state during switches from one security state to 226 * another in EL1. 227 */ 228 DEFINE_REG_STRUCT(el1_sys_regs, CTX_SYSREG_ALL); 229 230 /* 231 * AArch64 floating point register context structure for preserving 232 * the floating point state during switches from one security state to 233 * another. 234 */ 235 #if CTX_INCLUDE_FPREGS 236 DEFINE_REG_STRUCT(fp_regs, CTX_FPREG_ALL); 237 #endif 238 239 /* 240 * Miscellaneous registers used by EL3 firmware to maintain its state 241 * across exception entries and exits 242 */ 243 DEFINE_REG_STRUCT(el3_state, CTX_EL3STATE_ALL); 244 245 /* 246 * Macros to access members of any of the above structures using their 247 * offsets 248 */ 249 #define read_ctx_reg(ctx, offset) ((ctx)->_regs[offset >> DWORD_SHIFT]) 250 #define write_ctx_reg(ctx, offset, val) (((ctx)->_regs[offset >> DWORD_SHIFT]) \ 251 = val) 252 253 /* 254 * Top-level context structure which is used by EL3 firmware to 255 * preserve the state of a core at EL1 in one of the two security 256 * states and save enough EL3 meta data to be able to return to that 257 * EL and security state. The context management library will be used 258 * to ensure that SP_EL3 always points to an instance of this 259 * structure at exception entry and exit. Each instance will 260 * correspond to either the secure or the non-secure state. 261 */ 262 typedef struct cpu_context { 263 gp_regs_t gpregs_ctx; 264 el3_state_t el3state_ctx; 265 el1_sys_regs_t sysregs_ctx; 266 #if CTX_INCLUDE_FPREGS 267 fp_regs_t fpregs_ctx; 268 #endif 269 } cpu_context_t; 270 271 /* Macros to access members of the 'cpu_context_t' structure */ 272 #define get_el3state_ctx(h) (&((cpu_context_t *) h)->el3state_ctx) 273 #if CTX_INCLUDE_FPREGS 274 #define get_fpregs_ctx(h) (&((cpu_context_t *) h)->fpregs_ctx) 275 #endif 276 #define get_sysregs_ctx(h) (&((cpu_context_t *) h)->sysregs_ctx) 277 #define get_gpregs_ctx(h) (&((cpu_context_t *) h)->gpregs_ctx) 278 279 /* 280 * Compile time assertions related to the 'cpu_context' structure to 281 * ensure that the assembler and the compiler view of the offsets of 282 * the structure members is the same. 283 */ 284 CASSERT(CTX_GPREGS_OFFSET == __builtin_offsetof(cpu_context_t, gpregs_ctx), \ 285 assert_core_context_gp_offset_mismatch); 286 CASSERT(CTX_SYSREGS_OFFSET == __builtin_offsetof(cpu_context_t, sysregs_ctx), \ 287 assert_core_context_sys_offset_mismatch); 288 #if CTX_INCLUDE_FPREGS 289 CASSERT(CTX_FPREGS_OFFSET == __builtin_offsetof(cpu_context_t, fpregs_ctx), \ 290 assert_core_context_fp_offset_mismatch); 291 #endif 292 CASSERT(CTX_EL3STATE_OFFSET == __builtin_offsetof(cpu_context_t, el3state_ctx), \ 293 assert_core_context_el3state_offset_mismatch); 294 295 /* 296 * Helper macro to set the general purpose registers that correspond to 297 * parameters in an aapcs_64 call i.e. x0-x7 298 */ 299 #define set_aapcs_args0(ctx, x0) do { \ 300 write_ctx_reg(get_gpregs_ctx(ctx), CTX_GPREG_X0, x0); \ 301 } while (0) 302 #define set_aapcs_args1(ctx, x0, x1) do { \ 303 write_ctx_reg(get_gpregs_ctx(ctx), CTX_GPREG_X1, x1); \ 304 set_aapcs_args0(ctx, x0); \ 305 } while (0) 306 #define set_aapcs_args2(ctx, x0, x1, x2) do { \ 307 write_ctx_reg(get_gpregs_ctx(ctx), CTX_GPREG_X2, x2); \ 308 set_aapcs_args1(ctx, x0, x1); \ 309 } while (0) 310 #define set_aapcs_args3(ctx, x0, x1, x2, x3) do { \ 311 write_ctx_reg(get_gpregs_ctx(ctx), CTX_GPREG_X3, x3); \ 312 set_aapcs_args2(ctx, x0, x1, x2); \ 313 } while (0) 314 #define set_aapcs_args4(ctx, x0, x1, x2, x3, x4) do { \ 315 write_ctx_reg(get_gpregs_ctx(ctx), CTX_GPREG_X4, x4); \ 316 set_aapcs_args3(ctx, x0, x1, x2, x3); \ 317 } while (0) 318 #define set_aapcs_args5(ctx, x0, x1, x2, x3, x4, x5) do { \ 319 write_ctx_reg(get_gpregs_ctx(ctx), CTX_GPREG_X5, x5); \ 320 set_aapcs_args4(ctx, x0, x1, x2, x3, x4); \ 321 } while (0) 322 #define set_aapcs_args6(ctx, x0, x1, x2, x3, x4, x5, x6) do { \ 323 write_ctx_reg(get_gpregs_ctx(ctx), CTX_GPREG_X6, x6); \ 324 set_aapcs_args5(ctx, x0, x1, x2, x3, x4, x5); \ 325 } while (0) 326 #define set_aapcs_args7(ctx, x0, x1, x2, x3, x4, x5, x6, x7) do { \ 327 write_ctx_reg(get_gpregs_ctx(ctx), CTX_GPREG_X7, x7); \ 328 set_aapcs_args6(ctx, x0, x1, x2, x3, x4, x5, x6); \ 329 } while (0) 330 331 /******************************************************************************* 332 * Function prototypes 333 ******************************************************************************/ 334 void el1_sysregs_context_save(el1_sys_regs_t *regs); 335 void el1_sysregs_context_restore(el1_sys_regs_t *regs); 336 #if CTX_INCLUDE_FPREGS 337 void fpregs_context_save(fp_regs_t *regs); 338 void fpregs_context_restore(fp_regs_t *regs); 339 #endif 340 341 342 #undef CTX_SYSREG_ALL 343 #if CTX_INCLUDE_FPREGS 344 #undef CTX_FPREG_ALL 345 #endif 346 #undef CTX_GPREG_ALL 347 #undef CTX_EL3STATE_ALL 348 349 #endif /* __ASSEMBLY__ */ 350 351 #endif /* __CONTEXT_H__ */ 352