1/* 2 * arch/xtensa/kernel/vectors.S 3 * 4 * This file contains all exception vectors (user, kernel, and double), 5 * as well as the window vectors (overflow and underflow), and the debug 6 * vector. These are the primary vectors executed by the processor if an 7 * exception occurs. 8 * 9 * This file is subject to the terms and conditions of the GNU General 10 * Public License. See the file "COPYING" in the main directory of 11 * this archive for more details. 12 * 13 * Copyright (C) 2005 Tensilica, Inc. 14 * 15 * Chris Zankel <chris@zankel.net> 16 * 17 */ 18 19/* 20 * We use a two-level table approach. The user and kernel exception vectors 21 * use a first-level dispatch table to dispatch the exception to a registered 22 * fast handler or the default handler, if no fast handler was registered. 23 * The default handler sets up a C-stack and dispatches the exception to a 24 * registerd C handler in the second-level dispatch table. 25 * 26 * Fast handler entry condition: 27 * 28 * a0: trashed, original value saved on stack (PT_AREG0) 29 * a1: a1 30 * a2: new stack pointer, original value in depc 31 * a3: dispatch table 32 * depc: a2, original value saved on stack (PT_DEPC) 33 * excsave_1: a3 34 * 35 * The value for PT_DEPC saved to stack also functions as a boolean to 36 * indicate that the exception is either a double or a regular exception: 37 * 38 * PT_DEPC >= VALID_DOUBLE_EXCEPTION_ADDRESS: double exception 39 * < VALID_DOUBLE_EXCEPTION_ADDRESS: regular exception 40 * 41 * Note: Neither the kernel nor the user exception handler generate literals. 42 * 43 */ 44 45#include <linux/linkage.h> 46#include <asm/ptrace.h> 47#include <asm/ptrace.h> 48#include <asm/current.h> 49#include <asm/asm-offsets.h> 50#include <asm/pgtable.h> 51#include <asm/processor.h> 52#include <asm/page.h> 53#include <asm/thread_info.h> 54#include <asm/processor.h> 55 56#define WINDOW_VECTORS_SIZE 0x180 57 58 59/* 60 * User exception vector. (Exceptions with PS.UM == 1, PS.EXCM == 0) 61 * 62 * We get here when an exception occurred while we were in userland. 63 * We switch to the kernel stack and jump to the first level handler 64 * associated to the exception cause. 65 * 66 * Note: the saved kernel stack pointer (EXC_TABLE_KSTK) is already 67 * decremented by PT_USER_SIZE. 68 */ 69 70 .section .UserExceptionVector.text, "ax" 71 72ENTRY(_UserExceptionVector) 73 74 xsr a3, EXCSAVE_1 # save a3 and get dispatch table 75 wsr a2, DEPC # save a2 76 l32i a2, a3, EXC_TABLE_KSTK # load kernel stack to a2 77 s32i a0, a2, PT_AREG0 # save a0 to ESF 78 rsr a0, EXCCAUSE # retrieve exception cause 79 s32i a0, a2, PT_DEPC # mark it as a regular exception 80 addx4 a0, a0, a3 # find entry in table 81 l32i a0, a0, EXC_TABLE_FAST_USER # load handler 82 jx a0 83 84/* 85 * Kernel exception vector. (Exceptions with PS.UM == 0, PS.EXCM == 0) 86 * 87 * We get this exception when we were already in kernel space. 88 * We decrement the current stack pointer (kernel) by PT_SIZE and 89 * jump to the first-level handler associated with the exception cause. 90 * 91 * Note: we need to preserve space for the spill region. 92 */ 93 94 .section .KernelExceptionVector.text, "ax" 95 96ENTRY(_KernelExceptionVector) 97 98 xsr a3, EXCSAVE_1 # save a3, and get dispatch table 99 wsr a2, DEPC # save a2 100 addi a2, a1, -16-PT_SIZE # adjust stack pointer 101 s32i a0, a2, PT_AREG0 # save a0 to ESF 102 rsr a0, EXCCAUSE # retrieve exception cause 103 s32i a0, a2, PT_DEPC # mark it as a regular exception 104 addx4 a0, a0, a3 # find entry in table 105 l32i a0, a0, EXC_TABLE_FAST_KERNEL # load handler address 106 jx a0 107 108 109/* 110 * Double exception vector (Exceptions with PS.EXCM == 1) 111 * We get this exception when another exception occurs while were are 112 * already in an exception, such as window overflow/underflow exception, 113 * or 'expected' exceptions, for example memory exception when we were trying 114 * to read data from an invalid address in user space. 115 * 116 * Note that this vector is never invoked for level-1 interrupts, because such 117 * interrupts are disabled (masked) when PS.EXCM is set. 118 * 119 * We decode the exception and take the appropriate action. However, the 120 * double exception vector is much more careful, because a lot more error 121 * cases go through the double exception vector than through the user and 122 * kernel exception vectors. 123 * 124 * Occasionally, the kernel expects a double exception to occur. This usually 125 * happens when accessing user-space memory with the user's permissions 126 * (l32e/s32e instructions). The kernel state, though, is not always suitable 127 * for immediate transfer of control to handle_double, where "normal" exception 128 * processing occurs. Also in kernel mode, TLB misses can occur if accessing 129 * vmalloc memory, possibly requiring repair in a double exception handler. 130 * 131 * The variable at TABLE_FIXUP offset from the pointer in EXCSAVE_1 doubles as 132 * a boolean variable and a pointer to a fixup routine. If the variable 133 * EXC_TABLE_FIXUP is non-zero, this handler jumps to that address. A value of 134 * zero indicates to use the default kernel/user exception handler. 135 * There is only one exception, when the value is identical to the exc_table 136 * label, the kernel is in trouble. This mechanism is used to protect critical 137 * sections, mainly when the handler writes to the stack to assert the stack 138 * pointer is valid. Once the fixup/default handler leaves that area, the 139 * EXC_TABLE_FIXUP variable is reset to the fixup handler or zero. 140 * 141 * Procedures wishing to use this mechanism should set EXC_TABLE_FIXUP to the 142 * nonzero address of a fixup routine before it could cause a double exception 143 * and reset it before it returns. 144 * 145 * Some other things to take care of when a fast exception handler doesn't 146 * specify a particular fixup handler but wants to use the default handlers: 147 * 148 * - The original stack pointer (in a1) must not be modified. The fast 149 * exception handler should only use a2 as the stack pointer. 150 * 151 * - If the fast handler manipulates the stack pointer (in a2), it has to 152 * register a valid fixup handler and cannot use the default handlers. 153 * 154 * - The handler can use any other generic register from a3 to a15, but it 155 * must save the content of these registers to stack (PT_AREG3...PT_AREGx) 156 * 157 * - These registers must be saved before a double exception can occur. 158 * 159 * - If we ever implement handling signals while in double exceptions, the 160 * number of registers a fast handler has saved (excluding a0 and a1) must 161 * be written to PT_AREG1. (1 if only a3 is used, 2 for a3 and a4, etc. ) 162 * 163 * The fixup handlers are special handlers: 164 * 165 * - Fixup entry conditions differ from regular exceptions: 166 * 167 * a0: DEPC 168 * a1: a1 169 * a2: trashed, original value in EXC_TABLE_DOUBLE_A2 170 * a3: exctable 171 * depc: a0 172 * excsave_1: a3 173 * 174 * - When the kernel enters the fixup handler, it still assumes it is in a 175 * critical section, so EXC_TABLE_FIXUP variable is set to exc_table. 176 * The fixup handler, therefore, has to re-register itself as the fixup 177 * handler before it returns from the double exception. 178 * 179 * - Fixup handler can share the same exception frame with the fast handler. 180 * The kernel stack pointer is not changed when entering the fixup handler. 181 * 182 * - Fixup handlers can jump to the default kernel and user exception 183 * handlers. Before it jumps, though, it has to setup a exception frame 184 * on stack. Because the default handler resets the register fixup handler 185 * the fixup handler must make sure that the default handler returns to 186 * it instead of the exception address, so it can re-register itself as 187 * the fixup handler. 188 * 189 * In case of a critical condition where the kernel cannot recover, we jump 190 * to unrecoverable_exception with the following entry conditions. 191 * All registers a0...a15 are unchanged from the last exception, except: 192 * 193 * a0: last address before we jumped to the unrecoverable_exception. 194 * excsave_1: a0 195 * 196 * 197 * See the handle_alloca_user and spill_registers routines for example clients. 198 * 199 * FIXME: Note: we currently don't allow signal handling coming from a double 200 * exception, so the item markt with (*) is not required. 201 */ 202 203 .section .DoubleExceptionVector.text, "ax" 204 .begin literal_prefix .DoubleExceptionVector 205 206ENTRY(_DoubleExceptionVector) 207 208 /* Deliberately destroy excsave (don't assume it's value was valid). */ 209 210 wsr a3, EXCSAVE_1 # save a3 211 212 /* Check for kernel double exception (usually fatal). */ 213 214 rsr a3, PS 215 _bbci.l a3, PS_UM_BIT, .Lksp 216 217 /* Check if we are currently handling a window exception. */ 218 /* Note: We don't need to indicate that we enter a critical section. */ 219 220 xsr a0, DEPC # get DEPC, save a0 221 222 movi a3, XCHAL_WINDOW_VECTORS_VADDR 223 _bltu a0, a3, .Lfixup 224 addi a3, a3, WINDOW_VECTORS_SIZE 225 _bgeu a0, a3, .Lfixup 226 227 /* Window overflow/underflow exception. Get stack pointer. */ 228 229 mov a3, a2 230 movi a2, exc_table 231 l32i a2, a2, EXC_TABLE_KSTK 232 233 /* Check for overflow/underflow exception, jump if overflow. */ 234 235 _bbci.l a0, 6, .Lovfl 236 237 /* a0: depc, a1: a1, a2: kstk, a3: a2, depc: a0, excsave: a3 */ 238 239 /* Restart window underflow exception. 240 * We return to the instruction in user space that caused the window 241 * underflow exception. Therefore, we change window base to the value 242 * before we entered the window underflow exception and prepare the 243 * registers to return as if we were coming from a regular exception 244 * by changing depc (in a0). 245 * Note: We can trash the current window frame (a0...a3) and depc! 246 */ 247 248 wsr a2, DEPC # save stack pointer temporarily 249 rsr a0, PS 250 extui a0, a0, PS_OWB_SHIFT, 4 251 wsr a0, WINDOWBASE 252 rsync 253 254 /* We are now in the previous window frame. Save registers again. */ 255 256 xsr a2, DEPC # save a2 and get stack pointer 257 s32i a0, a2, PT_AREG0 258 259 wsr a3, EXCSAVE_1 # save a3 260 movi a3, exc_table 261 262 rsr a0, EXCCAUSE 263 s32i a0, a2, PT_DEPC # mark it as a regular exception 264 addx4 a0, a0, a3 265 l32i a0, a0, EXC_TABLE_FAST_USER 266 jx a0 267 268.Lfixup:/* Check for a fixup handler or if we were in a critical section. */ 269 270 /* a0: depc, a1: a1, a2: a2, a3: trashed, depc: a0, excsave1: a3 */ 271 272 movi a3, exc_table 273 s32i a2, a3, EXC_TABLE_DOUBLE_SAVE # temporary variable 274 275 /* Enter critical section. */ 276 277 l32i a2, a3, EXC_TABLE_FIXUP 278 s32i a3, a3, EXC_TABLE_FIXUP 279 beq a2, a3, .Lunrecoverable_fixup # critical! 280 beqz a2, .Ldflt # no handler was registered 281 282 /* a0: depc, a1: a1, a2: trash, a3: exctable, depc: a0, excsave: a3 */ 283 284 jx a2 285 286.Ldflt: /* Get stack pointer. */ 287 288 l32i a3, a3, EXC_TABLE_DOUBLE_SAVE 289 addi a2, a3, -PT_USER_SIZE 290 291.Lovfl: /* Jump to default handlers. */ 292 293 /* a0: depc, a1: a1, a2: kstk, a3: a2, depc: a0, excsave: a3 */ 294 295 xsr a3, DEPC 296 s32i a0, a2, PT_DEPC 297 s32i a3, a2, PT_AREG0 298 299 /* a0: avail, a1: a1, a2: kstk, a3: avail, depc: a2, excsave: a3 */ 300 301 movi a3, exc_table 302 rsr a0, EXCCAUSE 303 addx4 a0, a0, a3 304 l32i a0, a0, EXC_TABLE_FAST_USER 305 jx a0 306 307 /* 308 * We only allow the ITLB miss exception if we are in kernel space. 309 * All other exceptions are unexpected and thus unrecoverable! 310 */ 311 312#ifdef CONFIG_MMU 313 .extern fast_second_level_miss_double_kernel 314 315.Lksp: /* a0: a0, a1: a1, a2: a2, a3: trashed, depc: depc, excsave: a3 */ 316 317 rsr a3, EXCCAUSE 318 beqi a3, EXCCAUSE_ITLB_MISS, 1f 319 addi a3, a3, -EXCCAUSE_DTLB_MISS 320 bnez a3, .Lunrecoverable 3211: movi a3, fast_second_level_miss_double_kernel 322 jx a3 323#else 324.equ .Lksp, .Lunrecoverable 325#endif 326 327 /* Critical! We can't handle this situation. PANIC! */ 328 329 .extern unrecoverable_exception 330 331.Lunrecoverable_fixup: 332 l32i a2, a3, EXC_TABLE_DOUBLE_SAVE 333 xsr a0, DEPC 334 335.Lunrecoverable: 336 rsr a3, EXCSAVE_1 337 wsr a0, EXCSAVE_1 338 movi a0, unrecoverable_exception 339 callx0 a0 340 341 .end literal_prefix 342 343 344/* 345 * Debug interrupt vector 346 * 347 * There is not much space here, so simply jump to another handler. 348 * EXCSAVE[DEBUGLEVEL] has been set to that handler. 349 */ 350 351 .section .DebugInterruptVector.text, "ax" 352 353ENTRY(_DebugInterruptVector) 354 xsr a0, EXCSAVE + XCHAL_DEBUGLEVEL 355 jx a0 356 357 358 359/* Window overflow and underflow handlers. 360 * The handlers must be 64 bytes apart, first starting with the underflow 361 * handlers underflow-4 to underflow-12, then the overflow handlers 362 * overflow-4 to overflow-12. 363 * 364 * Note: We rerun the underflow handlers if we hit an exception, so 365 * we try to access any page that would cause a page fault early. 366 */ 367 368 .section .WindowVectors.text, "ax" 369 370 371/* 4-Register Window Overflow Vector (Handler) */ 372 373 .align 64 374.global _WindowOverflow4 375_WindowOverflow4: 376 s32e a0, a5, -16 377 s32e a1, a5, -12 378 s32e a2, a5, -8 379 s32e a3, a5, -4 380 rfwo 381 382 383/* 4-Register Window Underflow Vector (Handler) */ 384 385 .align 64 386.global _WindowUnderflow4 387_WindowUnderflow4: 388 l32e a0, a5, -16 389 l32e a1, a5, -12 390 l32e a2, a5, -8 391 l32e a3, a5, -4 392 rfwu 393 394 395/* 8-Register Window Overflow Vector (Handler) */ 396 397 .align 64 398.global _WindowOverflow8 399_WindowOverflow8: 400 s32e a0, a9, -16 401 l32e a0, a1, -12 402 s32e a2, a9, -8 403 s32e a1, a9, -12 404 s32e a3, a9, -4 405 s32e a4, a0, -32 406 s32e a5, a0, -28 407 s32e a6, a0, -24 408 s32e a7, a0, -20 409 rfwo 410 411/* 8-Register Window Underflow Vector (Handler) */ 412 413 .align 64 414.global _WindowUnderflow8 415_WindowUnderflow8: 416 l32e a1, a9, -12 417 l32e a0, a9, -16 418 l32e a7, a1, -12 419 l32e a2, a9, -8 420 l32e a4, a7, -32 421 l32e a3, a9, -4 422 l32e a5, a7, -28 423 l32e a6, a7, -24 424 l32e a7, a7, -20 425 rfwu 426 427 428/* 12-Register Window Overflow Vector (Handler) */ 429 430 .align 64 431.global _WindowOverflow12 432_WindowOverflow12: 433 s32e a0, a13, -16 434 l32e a0, a1, -12 435 s32e a1, a13, -12 436 s32e a2, a13, -8 437 s32e a3, a13, -4 438 s32e a4, a0, -48 439 s32e a5, a0, -44 440 s32e a6, a0, -40 441 s32e a7, a0, -36 442 s32e a8, a0, -32 443 s32e a9, a0, -28 444 s32e a10, a0, -24 445 s32e a11, a0, -20 446 rfwo 447 448/* 12-Register Window Underflow Vector (Handler) */ 449 450 .align 64 451.global _WindowUnderflow12 452_WindowUnderflow12: 453 l32e a1, a13, -12 454 l32e a0, a13, -16 455 l32e a11, a1, -12 456 l32e a2, a13, -8 457 l32e a4, a11, -48 458 l32e a8, a11, -32 459 l32e a3, a13, -4 460 l32e a5, a11, -44 461 l32e a6, a11, -40 462 l32e a7, a11, -36 463 l32e a9, a11, -28 464 l32e a10, a11, -24 465 l32e a11, a11, -20 466 rfwu 467 468 .text 469 470 471