| /* |
| * Copyright (c) 2016 Cadence Design Systems, Inc. |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| /* XTENSA VECTORS AND LOW LEVEL HANDLERS FOR AN RTOS |
| * |
| * FIXME: A lot of this is not applicable to Zephyr, remove. In particular, |
| * we do not support installing interrupt or exception handlers at runtime. |
| * |
| * Xtensa low level exception and interrupt vectors and handlers for an RTOS. |
| * |
| * Interrupt handlers and user exception handlers support interaction with the |
| * RTOS by calling XT_RTOS_INT_ENTER and XT_RTOS_INT_EXIT before and after |
| * user's specific interrupt handlers. These macros are defined in |
| * xtensa_<rtos>.h to call suitable functions in a specific RTOS. |
| * |
| * Users can install application-specific interrupt handlers for low and medium |
| * level interrupts, by calling _xt_set_interrupt_handler(). These handlers can |
| * be written in C, and must obey C calling convention. The handler table is |
| * indexed by the interrupt number. Each handler may be provided with an |
| * argument. |
| * |
| * Note that the system timer interrupt is handled specially, and is dispatched |
| * to the RTOS-specific handler. This timer cannot be hooked by application |
| * code. |
| * |
| * Optional hooks are also provided to install a handler per level at run-time, |
| * made available by compiling this source file with '-DXT_INTEXC_HOOKS' |
| * (useful for automated testing). |
| * |
| * NOTE: This file is a template that usually needs to be modified to handle |
| * application specific interrupts. Search USER_EDIT for helpful comments on |
| * where to insert handlers and how to write them. |
| * |
| * Users can also install application-specific exception handlers in the same |
| * way, by calling _xt_set_exception_handler(). One handler slot is provided |
| * for each exception type. Note that some exceptions are handled by the |
| * porting layer itself, and cannot be taken over by application code in this |
| * manner. These are the alloca, syscall, and coprocessor exceptions. |
| * |
| * The exception handlers can be written in C, and must follow C calling |
| * convention. Each handler is passed a pointer to an exception frame as its |
| * single argument. The exception frame is created on the stack, and holds the |
| * saved context of the thread that took the exception. If the handler returns, |
| * the context will be restored and the instruction that caused the exception |
| * will be retried. If the handler makes any changes to the saved state in the |
| * exception frame, the changes will be applied when restoring the context. |
| * |
| * Because Xtensa is a configurable architecture, this port supports all user |
| * generated configurations (except restrictions stated in the release notes). |
| * This is accomplished by conditional compilation using macros and functions |
| * defined in the Xtensa HAL (hardware adaptation layer) for your |
| * configuration. Only the relevant parts of this file will be included in your |
| * RTOS build. For example, this file provides interrupt vector templates for |
| * all types and all priority levels, but only the ones in your configuration |
| * are built. |
| * |
| * NOTES on the use of 'call0' for long jumps instead of 'j': |
| * |
| * 1. This file should be assembled with the -mlongcalls option to xt-xcc. |
| * |
| * 2. The -mlongcalls compiler option causes 'call0 dest' to be expanded to |
| * a sequence 'l32r a0, dest' 'callx0 a0' which works regardless of the |
| * distance from the call to the destination. The linker then relaxes |
| * it back to 'call0 dest' if it determines that dest is within range. |
| * This allows more flexibility in locating code without the performance |
| * overhead of the 'l32r' literal data load in cases where the destination |
| * is in range of 'call0'. There is an additional benefit in that 'call0' |
| * has a longer range than 'j' due to the target being word-aligned, so |
| * the 'l32r' sequence is less likely needed. |
| * |
| * 3. The use of 'call0' with -mlongcalls requires that register a0 not be |
| * live at the time of the call, which is always the case for a function |
| * call but needs to be ensured if 'call0' is used as a jump in lieu of 'j'. |
| * |
| * 4. This use of 'call0' is independent of the C function call ABI. |
| */ |
| |
| #include <offsets_short.h> |
| #include "xtensa_rtos.h" |
| |
| /* |
| * Defines used to access _xtos_interrupt_table. |
| */ |
| /** |
| * Zephyr has its own SW interrupt service routines table. |
| * Xtensa's table is made an alias of it. |
| **/ |
| #define _xt_interrupt_table _sw_isr_table |
| #define XIE_ARG 0 |
| #define XIE_HANDLER 4 |
| #define XIE_SIZE 8 |
| |
| /* Macro extract_msb - return the input with only the highest bit set. |
| * |
| * Input : "ain" - Input value, clobbered. |
| * Output : "aout" - Output value, has only one bit set, MSB of "ain". |
| * |
| * The two arguments must be different AR registers. |
| */ |
| |
| .macro extract_msb aout ain |
| 1: |
| addi \aout, \ain, -1 /* aout = ain - 1 */ |
| and \ain, \ain, \aout /* ain = ain & aout */ |
| bnez \ain, 1b /* repeat until ain == 0 */ |
| addi \aout, \aout, 1 /* return aout + 1 */ |
| .endm |
| |
| /* Macro dispatch_c_isr - dispatch interrupts to user ISRs. |
| * This will dispatch to user handlers (if any) that are registered in the |
| * XTOS dispatch table (_xtos_interrupt_table). These handlers would have |
| * been registered by calling _xtos_set_interrupt_handler(). There is one |
| * exception - the timer interrupt used by the OS will not be dispatched |
| * to a user handler - this must be handled by the caller of this macro. |
| * |
| * Level triggered and software interrupts are automatically deasserted by |
| * this code. |
| * |
| * ASSUMPTIONS: |
| * -- PS.INTLEVEL is set to "level" at entry |
| * -- PS.EXCM = 0, C calling enabled |
| * |
| * NOTE: For CALL0 ABI, a12-a15 have not yet been saved. |
| * |
| * NOTE: This macro will use registers a0 and a2-a6. The arguments are: |
| * level -- interrupt level |
| * mask -- interrupt bitmask for this level |
| */ |
| .extern _kernel |
| .extern _sys_power_save_idle_exit |
| |
| .macro dispatch_c_isr level mask |
| |
| /* Get mask of pending, enabled interrupts at this level into a2. */ |
| |
| .L_xt_user_int_&level&: |
| rsr a2, INTENABLE |
| rsr a3, INTERRUPT |
| movi a4, \mask |
| and a2, a2, a3 |
| and a2, a2, a4 |
| beqz a2, 9f /* nothing to do */ |
| |
| /* This bit of code provides a nice debug backtrace in the debugger. |
| It does take a few more instructions, so undef XT_DEBUG_BACKTRACE |
| if you want to save the cycles. |
| */ |
| #if XT_DEBUG_BACKTRACE |
| #ifndef __XTENSA_CALL0_ABI__ |
| rsr a0, EPC_1 + \level - 1 /* return address */ |
| movi a4, 0xC0000000 /* constant with top 2 bits set (call size) */ |
| or a0, a0, a4 /* set top 2 bits */ |
| addx2 a0, a4, a0 /* clear top bit -- simulating call4 size */ |
| #endif |
| #endif |
| |
| #ifdef CONFIG_KERNEL_EVENT_LOGGER_INTERRUPT |
| /* |
| * Register the interrupt. |
| * We just saved all registers. |
| */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| call0 _sys_k_event_logger_interrupt |
| #else |
| call4 _sys_k_event_logger_interrupt |
| #endif |
| #endif |
| |
| #ifdef CONFIG_KERNEL_EVENT_LOGGER_SLEEP |
| /* |
| * Register the sleep enter. |
| * We just saved all registers. |
| */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| call0 _sys_k_event_logger_exit_sleep |
| #else |
| call4 _sys_k_event_logger_exit_sleep |
| #endif |
| #endif |
| #ifdef XT_INTEXC_HOOKS |
| /* Call interrupt hook if present to (pre)handle interrupts. */ |
| movi a4, _xt_intexc_hooks |
| l32i a4, a4, \level << 2 |
| beqz a4, 2f |
| #ifdef __XTENSA_CALL0_ABI__ |
| callx0 a4 |
| beqz a2, 9f |
| #else |
| mov a6, a2 |
| callx4 a4 |
| beqz a6, 9f |
| mov a2, a6 |
| #endif |
| 2: |
| #endif |
| |
| #ifdef CONFIG_SYS_POWER_MANAGEMENT |
| movi a3, _kernel |
| #ifdef __XTENSA_CALL0_ABI__ |
| mov a12, a2 |
| l32i a2, a3, _kernel_offset_to_idle |
| beqz a2, 10f |
| xor a4, a2, a2 |
| s32i a4, a3, _kernel_offset_to_idle |
| call0 _sys_power_save_idle_exit |
| mov a2, a12 |
| #else |
| l32i a6, a3, _kernel_offset_to_idle |
| beqz a6, 10f |
| xor a4, a6, a6 |
| s32i a4, a3, _kernel_offset_to_idle |
| call4 _sys_power_save_idle_exit |
| #endif /* __XTENSA_CALL0_ABI__ */ |
| 10: |
| #endif /* CONFIG_SYS_POWER_MANAGEMENT */ |
| |
| /* Now look up in the dispatch table and call user ISR if any. */ |
| /* If multiple bits are set then MSB has highest priority. */ |
| |
| extract_msb a4, a2 /* a4 = MSB of a2, a2 trashed */ |
| |
| #ifdef XT_USE_SWPRI |
| /* Enable all interrupts at this level that are numerically highe |
| * than the one we just selected, since they are treated as higher |
| * priority. |
| * */ |
| movi a3, \mask /* a3 = all interrupts at this level */ |
| add a2, a4, a4 /* a2 = a4 << 1 */ |
| addi a2, a2, -1 /* a2 = mask of 1's <= a4 bit */ |
| and a2, a2, a3 /* a2 = mask of all bits <= a4 at this level */ |
| movi a3, _xt_intdata |
| l32i a6, a3, 4 /* a6 = _xt_vpri_mask */ |
| neg a2, a2 |
| addi a2, a2, -1 /* a2 = mask to apply */ |
| and a5, a6, a2 /* mask off all bits <= a4 bit */ |
| s32i a5, a3, 4 /* update _xt_vpri_mask */ |
| rsr a3, INTENABLE |
| and a3, a3, a2 /* mask off all bits <= a4 bit */ |
| wsr a3, INTENABLE |
| rsil a3, \level - 1 /* lower interrupt level by 1 */ |
| #endif |
| |
| movi a3, XT_TIMER_INTEN /* a3 = timer interrupt bit */ |
| wsr a4, INTCLEAR /* clear sw or edge-triggered interrupt */ |
| beq a3, a4, 7f /* if timer interrupt then skip table */ |
| |
| find_ms_setbit a3, a4, a3, 0 /* a3 = interrupt number */ |
| |
| movi a4, _xt_interrupt_table |
| addx8 a3, a3, a4 /* a3 = address of interrupt table entry */ |
| l32i a4, a3, XIE_HANDLER /* a4 = handler address */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| mov a12, a6 /* save in callee-saved reg */ |
| l32i a2, a3, XIE_ARG /* a2 = handler arg */ |
| callx0 a4 /* call handler */ |
| mov a2, a12 |
| #else |
| mov a2, a6 /* save in windowed reg */ |
| l32i a6, a3, XIE_ARG /* a6 = handler arg */ |
| callx4 a4 /* call handler */ |
| #endif |
| |
| #ifdef XT_USE_SWPRI |
| j 8f |
| #else |
| j .L_xt_user_int_&level& /* check for more interrupts */ |
| #endif |
| |
| 7: |
| |
| .ifeq XT_TIMER_INTPRI - \level |
| .L_xt_user_int_timer_&level&: |
| /* |
| * Interrupt handler for the RTOS tick timer if at this level. |
| * We'll be reading the interrupt state again after this call |
| * so no need to preserve any registers except a6 (vpri_mask). |
| */ |
| |
| #ifdef __XTENSA_CALL0_ABI__ |
| mov a12, a6 |
| call0 XT_RTOS_TIMER_INT |
| mov a2, a12 |
| #else |
| mov a2, a6 |
| call4 XT_RTOS_TIMER_INT |
| #endif |
| .endif |
| |
| #ifdef XT_USE_SWPRI |
| j 8f |
| #else |
| j .L_xt_user_int_&level& /* check for more interrupts */ |
| #endif |
| |
| #ifdef XT_USE_SWPRI |
| 8: |
| /* Restore old value of _xt_vpri_mask from a2. Also update INTENABLE |
| * from virtual _xt_intenable which _could_ have changed during |
| * interrupt processing. |
| */ |
| movi a3, _xt_intdata |
| l32i a4, a3, 0 /* a4 = _xt_intenable */ |
| s32i a2, a3, 4 /* update _xt_vpri_mask */ |
| and a4, a4, a2 /* a4 = masked intenable */ |
| wsr a4, INTENABLE /* update INTENABLE */ |
| #endif |
| |
| 9: |
| /* done */ |
| |
| .endm |
| |
| |
| /* Panic handler. |
| * |
| * Should be reached by call0 (preferable) or jump only. If call0, a0 says |
| * where from. If on simulator, display panic message and abort, else loop |
| * indefinitely. |
| */ |
| |
| .text |
| .global _xt_panic |
| .type _xt_panic,@function |
| .align 4 |
| |
| _xt_panic: |
| #ifdef XT_SIMULATOR |
| addi a4, a0, -3 /* point to call0 */ |
| movi a3, _xt_panic_message |
| movi a2, SYS_log_msg |
| simcall |
| movi a2, SYS_gdb_abort |
| simcall |
| #else |
| rsil a2, XCHAL_EXCM_LEVEL /* disable all low & med ints */ |
| 1: j 1b /* loop infinitely */ |
| #endif |
| |
| .section .rodata, "a" |
| .align 4 |
| |
| _xt_panic_message: |
| .string "\n*** _xt_panic() was called from 0x%08x or jumped to. ***\n" |
| |
| |
| /* Hooks to dynamically install handlers for exceptions and interrupts. Allows |
| * automated regression frameworks to install handlers per test. Consists of |
| * an array of function pointers indexed by interrupt level, with index 0 |
| * containing the entry for user exceptions. Initialized with all 0s, meaning |
| * no handler is installed at each level. See comment in xtensa_rtos.h for |
| * more details. |
| */ |
| |
| #ifdef XT_INTEXC_HOOKS |
| .data |
| .global _xt_intexc_hooks |
| .type _xt_intexc_hooks,@object |
| .align 4 |
| |
| _xt_intexc_hooks: |
| .fill XT_INTEXC_HOOK_NUM, 4, 0 |
| #endif |
| |
| |
| /* EXCEPTION AND LEVEL 1 INTERRUPT VECTORS AND LOW LEVEL HANDLERS (except |
| * window exception vectors). |
| * |
| * Each vector goes at a predetermined location according to the Xtensa |
| * hardware configuration, which is ensured by its placement in a special |
| * section known to the Xtensa linker support package (LSP). It performs the |
| * minimum necessary before jumping to the handler in the .text section. |
| * |
| * The corresponding handler goes in the normal .text section. It sets up the |
| * appropriate stack frame, saves a few vector-specific registers and calls |
| * XT_RTOS_INT_ENTER to save the rest of the interrupted context and enter the |
| * RTOS, then sets up a C environment. It then calls the user's interrupt |
| * handler code (which may be coded in C) and finally calls XT_RTOS_INT_EXIT to |
| * transfer control to the RTOS for scheduling. |
| * |
| * While XT_RTOS_INT_EXIT does not return directly to the interruptee, |
| * eventually the RTOS scheduler will want to dispatch the interrupted task or |
| * handler. The scheduler will return to the exit point that was saved in the |
| * interrupt stack frame at XT_STK_EXIT. |
| */ |
| |
| /* |
| * Debug Exception. |
| */ |
| |
| #if XCHAL_HAVE_DEBUG |
| |
| .begin literal_prefix .DebugExceptionVector |
| .section .DebugExceptionVector.text, "ax" |
| .global _DebugExceptionVector |
| .align 4 |
| |
| _DebugExceptionVector: |
| |
| #ifdef XT_SIMULATOR |
| /* In the simulator, let the debugger (if any) handle the debug |
| * exception, or simply stop the simulation: |
| */ |
| wsr a2, EXCSAVE+XCHAL_DEBUGLEVEL /* save a2 where sim expects it */ |
| movi a2, SYS_gdb_enter_sktloop |
| simcall /* have ISS handle debug exc. */ |
| #elif 0 /* change condition to 1 to use the HAL minimal debug handler */ |
| wsr a3, EXCSAVE+XCHAL_DEBUGLEVEL |
| movi a3, xthal_debugexc_defhndlr_nw /* use default debug handler */ |
| jx a3 |
| #else |
| wsr a0, EXCSAVE+XCHAL_DEBUGLEVEL /* save original a0 somewhere */ |
| call0 _xt_panic /* does not return */ |
| rfi XCHAL_DEBUGLEVEL /* make a0 point here not later */ |
| #endif |
| |
| .end literal_prefix |
| |
| #endif |
| |
| /* Double Exception. |
| * |
| * Double exceptions are not a normal occurrence. They indicate a bug of some |
| * kind. |
| */ |
| |
| #ifdef XCHAL_DOUBLEEXC_VECTOR_VADDR |
| |
| .begin literal_prefix .DoubleExceptionVector |
| .section .DoubleExceptionVector.text, "ax" |
| .global _DoubleExceptionVector |
| .align 4 |
| |
| _DoubleExceptionVector: |
| |
| #if XCHAL_HAVE_DEBUG |
| break 1, 4 /* unhandled double exception */ |
| #endif |
| call0 _xt_panic /* does not return */ |
| rfde /* make a0 point here not later */ |
| |
| .end literal_prefix |
| |
| #endif /* XCHAL_DOUBLEEXC_VECTOR_VADDR */ |
| |
| /* |
| * Kernel Exception (including Level 1 Interrupt from kernel mode). |
| */ |
| |
| .begin literal_prefix .KernelExceptionVector |
| .section .KernelExceptionVector.text, "ax" |
| .global _KernelExceptionVector |
| .align 4 |
| |
| _KernelExceptionVector: |
| |
| wsr a0, EXCSAVE_1 /* preserve a0 */ |
| call0 _xt_kernel_exc /* kernel exception handler */ |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| |
| .end literal_prefix |
| |
| .text |
| .align 4 |
| |
| _xt_kernel_exc: |
| #if XCHAL_HAVE_DEBUG |
| break 1, 0 /* unhandled kernel exception */ |
| #endif |
| call0 _xt_panic /* does not return */ |
| rfe /* make a0 point here not there */ |
| |
| |
| /* User Exception (including Level 1 Interrupt from user mode). */ |
| |
| .begin literal_prefix .UserExceptionVector |
| .section .UserExceptionVector.text, "ax" |
| .global _UserExceptionVector |
| .type _UserExceptionVector,@function |
| .align 4 |
| |
| _UserExceptionVector: |
| |
| wsr a0, EXCSAVE_1 /* preserve a0 */ |
| call0 _xt_user_exc /* user exception handler */ |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| |
| .end literal_prefix |
| |
| /* Insert some waypoints for jumping beyond the signed 8-bit range of |
| * conditional branch instructions, so the conditional branchces to specific |
| * exception handlers are not taken in the mainline. Saves some cycles in the |
| * mainline. |
| */ |
| .text |
| |
| #if XCHAL_HAVE_WINDOWED |
| .align 4 |
| _xt_to_alloca_exc: |
| call0 _xt_alloca_exc /* in window vectors section */ |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| #endif |
| |
| .align 4 |
| _xt_to_syscall_exc: |
| call0 _xt_syscall_exc |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| |
| #if XCHAL_CP_NUM > 0 |
| .align 4 |
| _xt_to_coproc_exc: |
| call0 _xt_coproc_exc |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| #endif |
| |
| |
| /* |
| * User exception handler. |
| */ |
| |
| .type _xt_user_exc,@function |
| .align 4 |
| |
| _xt_user_exc: |
| |
| /* If level 1 interrupt then jump to the dispatcher */ |
| rsr a0, EXCCAUSE |
| beqi a0, EXCCAUSE_LEVEL1INTERRUPT, _xt_lowint1 |
| |
| /* Handle any coprocessor exceptions. Rely on the fact that exception |
| * numbers above EXCCAUSE_CP0_DISABLED all relate to the coprocessors. |
| */ |
| #if XCHAL_CP_NUM > 0 |
| bgeui a0, EXCCAUSE_CP0_DISABLED, _xt_to_coproc_exc |
| #endif |
| |
| /* Handle alloca and syscall exceptions */ |
| #if XCHAL_HAVE_WINDOWED |
| beqi a0, EXCCAUSE_ALLOCA, _xt_to_alloca_exc |
| #endif |
| beqi a0, EXCCAUSE_SYSCALL, _xt_to_syscall_exc |
| |
| /* Handle all other exceptions. All can have user-defined handlers. */ |
| /* NOTE: we'll stay on the user stack for exception handling. */ |
| |
| /* Allocate exception frame and save minimal context. */ |
| mov a0, sp |
| addi sp, sp, -XT_STK_FRMSZ |
| s32i a0, sp, XT_STK_a1 |
| #if XCHAL_HAVE_WINDOWED |
| s32e a0, sp, -12 /* for debug backtrace */ |
| #endif |
| rsr a0, PS /* save interruptee's PS */ |
| s32i a0, sp, XT_STK_ps |
| rsr a0, EPC_1 /* save interruptee's PC */ |
| s32i a0, sp, XT_STK_pc |
| rsr a0, EXCSAVE_1 /* save interruptee's a0 */ |
| s32i a0, sp, XT_STK_a0 |
| #if XCHAL_HAVE_WINDOWED |
| s32e a0, sp, -16 /* for debug backtrace */ |
| #endif |
| s32i a12, sp, XT_STK_a12 /* _xt_context_save requires A12- */ |
| s32i a13, sp, XT_STK_a13 /* A13 to have already been saved */ |
| call0 _xt_context_save |
| |
| /* Save exc cause and vaddr into exception frame */ |
| rsr a0, EXCCAUSE |
| s32i a0, sp, XT_STK_exccause |
| rsr a0, EXCVADDR |
| s32i a0, sp, XT_STK_excvaddr |
| |
| /* Set up PS for C, reenable hi-pri interrupts, and clear EXCM. */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| movi a0, PS_INTLEVEL(XCHAL_EXCM_LEVEL) | PS_UM |
| #else |
| movi a0, PS_INTLEVEL(XCHAL_EXCM_LEVEL) | PS_UM | PS_WOE |
| #endif |
| wsr a0, PS |
| |
| #ifdef XT_DEBUG_BACKTRACE |
| #ifndef __XTENSA_CALL0_ABI__ |
| rsr a0, EPC_1 /* return address for debug backtrace */ |
| /* constant with top 2 bits set (call size) */ |
| movi a5, 0xC0000000 |
| rsync /* wait for WSR.PS to complete */ |
| or a0, a0, a5 /* set top 2 bits */ |
| addx2 a0, a5, a0 /* clear top bit, simulating call4 size */ |
| #else |
| rsync /* wait for WSR.PS to complete */ |
| #endif |
| #endif |
| |
| rsr a2, EXCCAUSE /* recover exc cause */ |
| |
| #ifdef XT_INTEXC_HOOKS |
| /* Call exception hook to pre-handle exceptions (if installed). |
| * Pass EXCCAUSE in a2, and check result in a2 (if -1, skip default |
| * handling). |
| */ |
| movi a4, _xt_intexc_hooks |
| l32i a4, a4, 0 /* user exception hook index 0 */ |
| beqz a4, 1f |
| .Ln_xt_user_exc_call_hook: |
| #ifdef __XTENSA_CALL0_ABI__ |
| callx0 a4 |
| beqi a2, -1, .L_xt_user_done |
| #else |
| mov a6, a2 |
| callx4 a4 |
| beqi a6, -1, .L_xt_user_done |
| mov a2, a6 |
| #endif |
| 1: |
| #endif |
| |
| rsr a2, EXCCAUSE /* recover exc cause */ |
| movi a3, _xt_exception_table |
| addx4 a4, a2, a3 /* a4 = address of exception table entry */ |
| l32i a4, a4, 0 /* a4 = handler address */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| mov a2, sp /* a2 = pointer to exc frame */ |
| callx0 a4 /* call handler */ |
| #else |
| mov a6, sp /* a6 = pointer to exc frame */ |
| callx4 a4 /* call handler */ |
| #endif |
| |
| .L_xt_user_done: |
| |
| /* Restore context and return */ |
| call0 _xt_context_restore |
| l32i a0, sp, XT_STK_ps /* retrieve interruptee's PS */ |
| wsr a0, PS |
| l32i a0, sp, XT_STK_pc /* retrieve interruptee's PC */ |
| wsr a0, EPC_1 |
| l32i a0, sp, XT_STK_a0 /* retrieve interruptee's A0 */ |
| l32i sp, sp, XT_STK_a1 /* remove exception frame */ |
| rsync /* ensure PS and EPC written */ |
| rfe /* PS.EXCM is cleared */ |
| |
| |
| /* |
| * Exit point for dispatch. Saved in interrupt stack frame at XT_STK_EXIT |
| * on entry and used to return to a thread or interrupted interrupt handler. |
| */ |
| |
| .global _xt_user_exit |
| .type _xt_user_exit,@function |
| .align 4 |
| _xt_user_exit: |
| l32i a0, sp, XT_STK_ps /* retrieve interruptee's PS */ |
| wsr a0, PS |
| l32i a0, sp, XT_STK_pc /* retrieve interruptee's PC */ |
| wsr a0, EPC_1 |
| l32i a0, sp, XT_STK_a0 /* retrieve interruptee's A0 */ |
| l32i sp, sp, XT_STK_a1 /* remove interrupt stack frame */ |
| rsync /* ensure PS and EPC written */ |
| rfe /* PS.EXCM is cleared */ |
| |
| |
| /* Syscall Exception Handler (jumped to from User Exception Handler). |
| * |
| * Syscall 0 is required to spill the register windows (no-op in Call 0 ABI). |
| * Only syscall 0 is handled here. Other syscalls return -1 to caller in a2. |
| */ |
| |
| .text |
| .type _xt_syscall_exc,@function |
| .align 4 |
| _xt_syscall_exc: |
| #ifdef __XTENSA_CALL0_ABI__ |
| /* Save minimal regs for scratch. Syscall 0 does nothing in Call0 ABI. |
| * Use a minimal stack frame (16B) to save A2 & A3 for scratch. |
| * PS.EXCM could be cleared here, but unlikely to improve worst-case |
| * latency. |
| */ |
| addi sp, sp, -16 |
| s32i a2, sp, 8 |
| s32i a3, sp, 12 |
| #else /* Windowed ABI */ |
| /* Save necessary context and spill the register windows. PS.EXCM is |
| * still set and must remain set until after the spill. Reuse context |
| * save function though it saves more than necessary. For this reason, |
| * a full interrupt stack frame is allocated. |
| */ |
| addi sp, sp, -XT_STK_FRMSZ /* allocate interrupt stack frame */ |
| s32i a12, sp, XT_STK_a12 /* _xt_context_save requires A12- */ |
| s32i a13, sp, XT_STK_a13 /* A13 to have already been saved */ |
| call0 _xt_context_save |
| #endif |
| |
| /* Grab the interruptee's PC and skip over the 'syscall' instruction. |
| * If it's at the end of a zero-overhead loop and it's not on the last |
| * iteration, decrement loop counter and skip to beginning of loop. |
| */ |
| rsr a2, EPC_1 /* a2 = PC of 'syscall' */ |
| addi a3, a2, 3 /* ++PC */ |
| #if XCHAL_HAVE_LOOPS |
| rsr a0, LEND /* if (PC == LEND */ |
| bne a3, a0, 1f |
| rsr a0, LCOUNT /* && LCOUNT != 0) */ |
| beqz a0, 1f /* { */ |
| addi a0, a0, -1 /* --LCOUNT */ |
| rsr a3, LBEG /* PC = LBEG */ |
| wsr a0, LCOUNT /* } */ |
| #endif |
| 1: wsr a3, EPC_1 /* update PC */ |
| |
| /* Restore interruptee's context and return from exception. */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| l32i a2, sp, 8 |
| l32i a3, sp, 12 |
| addi sp, sp, 16 |
| #else |
| call0 _xt_context_restore |
| addi sp, sp, XT_STK_FRMSZ |
| #endif |
| movi a0, -1 |
| movnez a2, a0, a2 /* return -1 if not syscall 0 */ |
| rsr a0, EXCSAVE_1 |
| rfe |
| |
| /* |
| * Co-Processor Exception Handler (jumped to from User Exception Handler). |
| * |
| * These exceptions are generated by co-processor instructions, which are only |
| * allowed in thread code (not in interrupts or kernel code). This restriction |
| * is deliberately imposed to reduce the burden of state-save/restore in |
| * interrupts. |
| */ |
| #if XCHAL_CP_NUM > 0 |
| |
| .section .rodata, "a" |
| |
| /* Offset to CP n save area in thread's CP save area. */ |
| .global _xt_coproc_sa_offset |
| .type _xt_coproc_sa_offset,@object |
| .align 16 /* minimize crossing cache boundaries */ |
| _xt_coproc_sa_offset: |
| .word XT_CP0_SA, XT_CP1_SA, XT_CP2_SA, XT_CP3_SA |
| .word XT_CP4_SA, XT_CP5_SA, XT_CP6_SA, XT_CP7_SA |
| |
| /* Bitmask for CP n's CPENABLE bit. */ |
| .type _xt_coproc_mask,@object |
| .align 16,,8 /* try to keep it all in one cache line */ |
| .set i, 0 |
| _xt_coproc_mask: |
| .rept XCHAL_CP_MAX |
| .long (i<<16) | (1<<i) /* upper 16-bits = i, lower = bitmask */ |
| .set i, i+1 |
| .endr |
| |
| .data |
| |
| /* Owner thread of CP n, identified by thread's CP save area (0 = unowned). */ |
| .global _xt_coproc_owner_sa |
| .type _xt_coproc_owner_sa,@object |
| .align 16,,XCHAL_CP_MAX<<2 /* minimize crossing cache boundaries */ |
| _xt_coproc_owner_sa: |
| .space XCHAL_CP_MAX << 2 |
| |
| .text |
| |
| |
| .align 4 |
| .L_goto_invalid: |
| j .L_xt_coproc_invalid /* not in a thread (invalid) */ |
| .align 4 |
| .L_goto_done: |
| j .L_xt_coproc_done |
| |
| |
| /* |
| * Coprocessor exception handler. |
| * |
| * At entry, only a0 has been saved (in EXCSAVE_1). |
| */ |
| |
| .type _xt_coproc_exc,@function |
| .align 4 |
| |
| _xt_coproc_exc: |
| |
| /* Allocate interrupt stack frame and save minimal context. */ |
| mov a0, sp /* sp == a1 */ |
| addi sp, sp, -XT_STK_FRMSZ /* allocate interrupt stack frame */ |
| s32i a0, sp, XT_STK_a1 /* save pre-interrupt SP */ |
| #if XCHAL_HAVE_WINDOWED |
| s32e a0, sp, -12 /* for debug backtrace */ |
| #endif |
| rsr a0, PS /* save interruptee's PS */ |
| s32i a0, sp, XT_STK_ps |
| rsr a0, EPC_1 /* save interruptee's PC */ |
| s32i a0, sp, XT_STK_pc |
| rsr a0, EXCSAVE_1 /* save interruptee's a0 */ |
| s32i a0, sp, XT_STK_a0 |
| #if XCHAL_HAVE_WINDOWED |
| s32e a0, sp, -16 /* for debug backtrace */ |
| #endif |
| movi a0, _xt_user_exit /* save exit point for dispatch */ |
| s32i a0, sp, XT_STK_exit |
| |
| rsr a0, EXCCAUSE |
| s32i a5, sp, XT_STK_a5 /* save a5 */ |
| addi a5, a0, -EXCCAUSE_CP0_DISABLED /* a5 = CP index */ |
| |
| /* Save a few more of interruptee's registers (a5 was already saved). */ |
| s32i a2, sp, XT_STK_a2 |
| s32i a3, sp, XT_STK_a3 |
| s32i a4, sp, XT_STK_a4 |
| s32i a15, sp, XT_STK_a15 |
| |
| /* Get co-processor state save area of new owner thread. */ |
| call0 XT_RTOS_CP_STATE /* a15 = new owner's save area */ |
| beqz a15, .L_goto_invalid /* not in a thread (invalid) */ |
| |
| /* Enable the co-processor's bit in CPENABLE. */ |
| movi a0, _xt_coproc_mask |
| rsr a4, CPENABLE /* a4 = CPENABLE */ |
| addx4 a0, a5, a0 /* a0 = &_xt_coproc_mask[n] */ |
| l32i a0, a0, 0 /* a0 = (n << 16) | (1 << n) */ |
| movi a3, _xt_coproc_owner_sa /* (placed here for load slot) */ |
| extui a2, a0, 0, 16 /* coprocessor bitmask portion */ |
| or a4, a4, a2 /* a4 = CPENABLE | (1 << n) */ |
| wsr a4, CPENABLE |
| |
| /* Get old coprocessor owner thread (save area ptr) and assign new |
| * one. |
| */ |
| addx4 a3, a5, a3 /* a3 = &_xt_coproc_owner_sa[n] */ |
| l32i a2, a3, 0 /* a2 = old owner's save area */ |
| s32i a15, a3, 0 /* _xt_coproc_owner_sa[n] = new */ |
| rsync /* ensure wsr.CPENABLE is complete */ |
| |
| /* Only need to context switch if new owner != old owner. */ |
| beq a15, a2, .L_goto_done /* new owner == old, we're done */ |
| |
| /* If no old owner then nothing to save. */ |
| beqz a2, .L_check_new |
| |
| /* If old owner not actively using CP then nothing to save. */ |
| l16ui a4, a2, XT_CPENABLE /* a4 = old owner's CPENABLE */ |
| bnone a4, a0, .L_check_new /* old owner not using CP */ |
| |
| .L_save_old: |
| /* Save old owner's coprocessor state. */ |
| |
| movi a5, _xt_coproc_sa_offset |
| |
| /* Mark old owner state as no longer active (CPENABLE bit n clear). */ |
| xor a4, a4, a0 /* clear CP bit in CPENABLE */ |
| s16i a4, a2, XT_CPENABLE /* update old owner's CPENABLE */ |
| |
| extui a4, a0, 16, 5 /* a4 = CP index = n */ |
| addx4 a5, a4, a5 /* a5 = &_xt_coproc_sa_offset[n] */ |
| |
| /* Mark old owner state as saved (CPSTORED bit n set). */ |
| l16ui a4, a2, XT_CPSTORED /* a4 = old owner's CPSTORED */ |
| l32i a5, a5, 0 /* a5 = XT_CP[n]_SA offset */ |
| or a4, a4, a0 /* set CP in old owner's CPSTORED */ |
| s16i a4, a2, XT_CPSTORED /* update old owner's CPSTORED */ |
| l32i a2, a2, XT_CP_ASA /* ptr to actual (aligned) save area */ |
| extui a3, a0, 16, 5 /* a3 = CP index = n */ |
| add a2, a2, a5 /* a2 = old owner's area for CP n */ |
| |
| /* The config-specific HAL macro invoked below destroys a2-5, preserves |
| * a0-1. It is theoretically possible for Xtensa processor designers to |
| * write TIE that causes more address registers to be affected, but it |
| * is generally unlikely. If that ever happens, more registers needs to |
| * be saved/restored around this macro invocation, and the value in a15 |
| * needs to be recomputed. |
| */ |
| xchal_cpi_store_funcbody |
| |
| .L_check_new: |
| /* Check if any state has to be restored for new owner. */ |
| /* NOTE: a15 = new owner's save area, cannot be zero when we get |
| * here. */ |
| |
| l16ui a3, a15, XT_CPSTORED /* a3 = new owner's CPSTORED */ |
| movi a4, _xt_coproc_sa_offset |
| /* full CP not saved, check callee-saved */ |
| bnone a3, a0, .L_check_cs |
| xor a3, a3, a0 /* CPSTORED bit is set, clear it */ |
| s16i a3, a15, XT_CPSTORED /* update new owner's CPSTORED */ |
| |
| /* Adjust new owner's save area pointers to area for CP n. */ |
| extui a3, a0, 16, 5 /* a3 = CP index = n */ |
| addx4 a4, a3, a4 /* a4 = &_xt_coproc_sa_offset[n] */ |
| l32i a4, a4, 0 /* a4 = XT_CP[n]_SA */ |
| l32i a5, a15, XT_CP_ASA /* ptr to actual (aligned) save area */ |
| add a2, a4, a5 /* a2 = new owner's area for CP */ |
| |
| /* The config-specific HAL macro invoked below destroys a2-5, preserves |
| * a0-1. It is theoretically possible for Xtensa processor designers to |
| * write TIE that causes more address registers to be affected, but it |
| * is generally unlikely. If that ever happens, more registers needs to |
| * be saved/restored around this macro invocation. |
| */ |
| xchal_cpi_load_funcbody |
| |
| /* Restore interruptee's saved registers. */ |
| /* Can omit rsync for wsr.CPENABLE here because _xt_user_exit does |
| * it. |
| */ |
| .L_xt_coproc_done: |
| l32i a15, sp, XT_STK_a15 |
| l32i a5, sp, XT_STK_a5 |
| l32i a4, sp, XT_STK_a4 |
| l32i a3, sp, XT_STK_a3 |
| l32i a2, sp, XT_STK_a2 |
| call0 _xt_user_exit /* return via exit dispatcher */ |
| /* Never returns here - call0 is used as a jump (see note at top) */ |
| |
| .L_check_cs: |
| /* a0 = CP mask in low bits, a15 = new owner's save area */ |
| l16ui a2, a15, XT_CP_CS_ST /* a2 = mask of CPs saved */ |
| bnone a2, a0, .L_xt_coproc_done /* if no match then done */ |
| and a2, a2, a0 /* a2 = which CPs to restore */ |
| extui a2, a2, 0, 8 /* extract low 8 bits */ |
| s32i a6, sp, XT_STK_a6 /* save extra needed regs */ |
| s32i a7, sp, XT_STK_a7 |
| s32i a13, sp, XT_STK_a13 |
| s32i a14, sp, XT_STK_a14 |
| call0 _xt_coproc_restorecs /* restore CP registers */ |
| l32i a6, sp, XT_STK_a6 /* restore saved registers */ |
| l32i a7, sp, XT_STK_a7 |
| l32i a13, sp, XT_STK_a13 |
| l32i a14, sp, XT_STK_a14 |
| j .L_xt_coproc_done |
| |
| /* Co-processor exception occurred outside a thread (not supported). */ |
| .L_xt_coproc_invalid: |
| #if XCHAL_HAVE_DEBUG |
| break 1, 1 /* unhandled user exception */ |
| #endif |
| call0 _xt_panic /* not in a thread (invalid) */ |
| /* never returns */ |
| |
| |
| #endif /* XCHAL_CP_NUM */ |
| |
| |
| /* |
| * Level 1 interrupt dispatch. Assumes stack frame has not been allocated yet. |
| */ |
| |
| .text |
| .type _xt_lowint1,@function |
| .align 4 |
| |
| _xt_lowint1: |
| mov a0, sp /* sp == a1 */ |
| addi sp, sp, -XT_STK_FRMSZ /* allocate interrupt stack frame */ |
| s32i a0, sp, XT_STK_a1 /* save pre-interrupt SP */ |
| rsr a0, PS /* save interruptee's PS */ |
| s32i a0, sp, XT_STK_ps |
| rsr a0, EPC_1 /* save interruptee's PC */ |
| s32i a0, sp, XT_STK_pc |
| rsr a0, EXCSAVE_1 /* save interruptee's a0 */ |
| s32i a0, sp, XT_STK_a0 |
| movi a0, _xt_user_exit /* save exit point for dispatch */ |
| s32i a0, sp, XT_STK_exit |
| |
| /* Save rest of interrupt context and enter RTOS. */ |
| call0 XT_RTOS_INT_ENTER /* common RTOS interrupt entry */ |
| |
| /* !! We are now on the RTOS system stack !! */ |
| |
| /* Set up PS for C, enable interrupts above this level and clear |
| * EXCM. |
| */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| movi a0, PS_INTLEVEL(1) | PS_UM |
| #else |
| movi a0, PS_INTLEVEL(1) | PS_UM | PS_WOE |
| #endif |
| wsr a0, PS |
| rsync |
| |
| /* OK to call C code at this point, dispatch user ISRs */ |
| |
| dispatch_c_isr 1 XCHAL_INTLEVEL1_MASK |
| |
| /* Done handling interrupts, transfer control to OS. */ |
| call0 XT_RTOS_INT_EXIT /* does not return directly here */ |
| |
| |
| /* MEDIUM PRIORITY (LEVEL 2+) INTERRUPT VECTORS AND LOW LEVEL HANDLERS. |
| * |
| * Medium priority interrupts are by definition those with priority greater |
| * than 1 and not greater than XCHAL_EXCM_LEVEL. These are disabled by setting |
| * PS.EXCM and therefore can easily support a C environment for handlers in C, |
| * and interact safely with an RTOS. |
| * |
| * Each vector goes at a predetermined location according to the Xtensa |
| * hardware configuration, which is ensured by its placement in a special |
| * section known to the Xtensa linker support package (LSP). It performs the |
| * minimum necessary before jumping to the handler in the .text section. |
| * |
| * The corresponding handler goes in the normal .text section. It sets up the |
| * appropriate stack frame, saves a few vector-specific registers and calls |
| * XT_RTOS_INT_ENTER to save the rest of the interrupted context and enter the |
| * RTOS, then sets up a C environment. It then calls the user's interrupt |
| * handler code (which may be coded in C) and finally calls XT_RTOS_INT_EXIT to |
| * transfer control to the RTOS for scheduling. |
| * |
| * While XT_RTOS_INT_EXIT does not return directly to the interruptee, |
| * eventually the RTOS scheduler will want to dispatch the interrupted task or |
| * handler. The scheduler will return to the exit point that was saved in the |
| * interrupt stack frame at XT_STK_EXIT. |
| * |
| * FIXME: Make this a macro or something so almost-identical code isn't |
| * repeated 5 times!! |
| */ |
| |
| #if XCHAL_EXCM_LEVEL >= 2 |
| |
| .begin literal_prefix .Level2InterruptVector |
| .section .Level2InterruptVector.text, "ax" |
| .global _Level2Vector |
| .type _Level2Vector,@function |
| .align 4 |
| _Level2Vector: |
| wsr a0, EXCSAVE_2 /* preserve a0 */ |
| call0 _xt_medint2 /* load interrupt handler */ |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| |
| .end literal_prefix |
| |
| .text |
| .type _xt_medint2,@function |
| .align 4 |
| _xt_medint2: |
| mov a0, sp /* sp == a1 */ |
| addi sp, sp, -XT_STK_FRMSZ /* allocate interrupt stack frame */ |
| s32i a0, sp, XT_STK_a1 /* save pre-interrupt SP */ |
| rsr a0, EPS_2 /* save interruptee's PS */ |
| s32i a0, sp, XT_STK_ps |
| rsr a0, EPC_2 /* save interruptee's PC */ |
| s32i a0, sp, XT_STK_pc |
| rsr a0, EXCSAVE_2 /* save interruptee's a0 */ |
| s32i a0, sp, XT_STK_a0 |
| movi a0, _xt_medint2_exit /* save exit point for dispatch */ |
| s32i a0, sp, XT_STK_exit |
| |
| /* Save rest of interrupt context and enter RTOS. */ |
| call0 XT_RTOS_INT_ENTER /* common RTOS interrupt entry */ |
| |
| /* !! We are now on the RTOS system stack !! */ |
| |
| /* Set up PS for C, enable interrupts above this level and clear |
| * EXCM. |
| */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| movi a0, PS_INTLEVEL(2) | PS_UM |
| #else |
| movi a0, PS_INTLEVEL(2) | PS_UM | PS_WOE |
| #endif |
| wsr a0, PS |
| rsync |
| |
| /* OK to call C code at this point, dispatch user ISRs */ |
| |
| dispatch_c_isr 2 XCHAL_INTLEVEL2_MASK |
| |
| /* Done handling interrupts, transfer control to OS */ |
| call0 XT_RTOS_INT_EXIT /* does not return directly here */ |
| |
| /* Exit point for dispatch. Saved in interrupt stack frame at |
| * XT_STK_EXIT on entry and used to return to a thread or interrupted |
| * interrupt handler. |
| */ |
| .global _xt_medint2_exit |
| .type _xt_medint2_exit,@function |
| .align 4 |
| _xt_medint2_exit: |
| /* Restore only level-specific regs (the rest were already restored) */ |
| l32i a0, sp, XT_STK_ps /* retrieve interruptee's PS */ |
| wsr a0, EPS_2 |
| l32i a0, sp, XT_STK_pc /* retrieve interruptee's PC */ |
| wsr a0, EPC_2 |
| l32i a0, sp, XT_STK_a0 /* retrieve interruptee's A0 */ |
| l32i sp, sp, XT_STK_a1 /* remove interrupt stack frame */ |
| rsync /* ensure EPS and EPC written */ |
| rfi 2 |
| |
| #endif /* Level 2 */ |
| |
| #if XCHAL_EXCM_LEVEL >= 3 |
| |
| .begin literal_prefix .Level3InterruptVector |
| .section .Level3InterruptVector.text, "ax" |
| .global _Level3Vector |
| .type _Level3Vector,@function |
| .align 4 |
| _Level3Vector: |
| wsr a0, EXCSAVE_3 /* preserve a0 */ |
| call0 _xt_medint3 /* load interrupt handler */ |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| |
| .end literal_prefix |
| |
| .text |
| .type _xt_medint3,@function |
| .align 4 |
| _xt_medint3: |
| mov a0, sp /* sp == a1 */ |
| addi sp, sp, -XT_STK_FRMSZ /* allocate interrupt stack frame */ |
| s32i a0, sp, XT_STK_a1 /* save pre-interrupt SP */ |
| rsr a0, EPS_3 /* save interruptee's PS */ |
| s32i a0, sp, XT_STK_ps |
| rsr a0, EPC_3 /* save interruptee's PC */ |
| s32i a0, sp, XT_STK_pc |
| rsr a0, EXCSAVE_3 /* save interruptee's a0 */ |
| s32i a0, sp, XT_STK_a0 |
| movi a0, _xt_medint3_exit /* save exit point for dispatch */ |
| s32i a0, sp, XT_STK_exit |
| |
| /* Save rest of interrupt context and enter RTOS. */ |
| call0 XT_RTOS_INT_ENTER /* common RTOS interrupt entry */ |
| |
| /* !! We are now on the RTOS system stack !! */ |
| |
| /* Set up PS for C, enable interrupts above this level and clear |
| * EXCM. |
| */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| movi a0, PS_INTLEVEL(3) | PS_UM |
| #else |
| movi a0, PS_INTLEVEL(3) | PS_UM | PS_WOE |
| #endif |
| wsr a0, PS |
| rsync |
| |
| /* OK to call C code at this point, dispatch user ISRs */ |
| |
| dispatch_c_isr 3 XCHAL_INTLEVEL3_MASK |
| |
| /* Done handling interrupts, transfer control to OS */ |
| call0 XT_RTOS_INT_EXIT /* does not return directly here */ |
| |
| /* Exit point for dispatch. Saved in interrupt stack frame at |
| * XT_STK_EXITon entry and used to return to a thread or interrupted |
| * interrupt handler. |
| */ |
| .global _xt_medint3_exit |
| .type _xt_medint3_exit,@function |
| .align 4 |
| _xt_medint3_exit: |
| /* Restore only level-specific regs (the rest were already restored) */ |
| l32i a0, sp, XT_STK_ps /* retrieve interruptee's PS */ |
| wsr a0, EPS_3 |
| l32i a0, sp, XT_STK_pc /* retrieve interruptee's PC */ |
| wsr a0, EPC_3 |
| l32i a0, sp, XT_STK_a0 /* retrieve interruptee's A0 */ |
| l32i sp, sp, XT_STK_a1 /* remove interrupt stack frame */ |
| rsync /* ensure EPS and EPC written */ |
| rfi 3 |
| |
| #endif /* Level 3 */ |
| |
| /* FIXME: For some reason, the HAL provided by the ESP32 port of FreeRTOS, |
| * that Zephyr uses, defines XCHAL_EXCM_LEVEL to 3. That essentially |
| * enables the other _Level4Vector routine, that doesn't work on ESP32. |
| * This is tracked by: https://jira.zephyrproject.org/browse/ZEP-2570 |
| */ |
| #if defined(CONFIG_SOC_ESP32) || (XCHAL_EXCM_LEVEL >= 4) |
| |
| .begin literal_prefix .Level4InterruptVector |
| .section .Level4InterruptVector.text, "ax" |
| .global _Level4Vector |
| .type _Level4Vector,@function |
| .align 4 |
| _Level4Vector: |
| wsr a0, EXCSAVE_4 /* preserve a0 */ |
| call0 _xt_medint4 /* load interrupt handler */ |
| |
| .end literal_prefix |
| |
| .text |
| .type _xt_medint4,@function |
| .align 4 |
| _xt_medint4: |
| mov a0, sp /* sp == a1 */ |
| addi sp, sp, -XT_STK_FRMSZ /* allocate interrupt stack frame */ |
| s32i a0, sp, XT_STK_a1 /* save pre-interrupt SP */ |
| rsr a0, EPS_4 /* save interruptee's PS */ |
| s32i a0, sp, XT_STK_ps |
| rsr a0, EPC_4 /* save interruptee's PC */ |
| s32i a0, sp, XT_STK_pc |
| rsr a0, EXCSAVE_4 /* save interruptee's a0 */ |
| s32i a0, sp, XT_STK_a0 |
| movi a0, _xt_medint4_exit /* save exit point for dispatch */ |
| s32i a0, sp, XT_STK_exit |
| |
| /* Save rest of interrupt context and enter RTOS. */ |
| call0 XT_RTOS_INT_ENTER /* common RTOS interrupt entry */ |
| |
| /* !! We are now on the RTOS system stack !! */ |
| |
| /* Set up PS for C, enable interrupts above this level and clear |
| * EXCM. |
| */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| movi a0, PS_INTLEVEL(4) | PS_UM |
| #else |
| movi a0, PS_INTLEVEL(4) | PS_UM | PS_WOE |
| #endif |
| wsr a0, PS |
| rsync |
| |
| /* OK to call C code at this point, dispatch user ISRs */ |
| |
| dispatch_c_isr 4 XCHAL_INTLEVEL4_MASK |
| |
| /* Done handling interrupts, transfer control to OS */ |
| call0 XT_RTOS_INT_EXIT /* does not return directly here */ |
| |
| /* Exit point for dispatch. Saved in interrupt stack frame at |
| * XT_STK_EXIT on entry and used to return to a thread or interrupted |
| * interrupt handler. |
| */ |
| .global _xt_medint4_exit |
| .type _xt_medint4_exit,@function |
| .align 4 |
| _xt_medint4_exit: |
| /* Restore only level-specific regs (the rest were already restored) */ |
| l32i a0, sp, XT_STK_ps /* retrieve interruptee's PS */ |
| wsr a0, EPS_4 |
| l32i a0, sp, XT_STK_pc /* retrieve interruptee's PC */ |
| wsr a0, EPC_4 |
| l32i a0, sp, XT_STK_a0 /* retrieve interruptee's A0 */ |
| l32i sp, sp, XT_STK_a1 /* remove interrupt stack frame */ |
| rsync /* ensure EPS and EPC written */ |
| rfi 4 |
| |
| #endif /* Level 4 */ |
| |
| #if XCHAL_EXCM_LEVEL >= 5 |
| |
| .begin literal_prefix .Level5InterruptVector |
| .section .Level5InterruptVector.text, "ax" |
| .global _Level5Vector |
| .type _Level5Vector,@function |
| .align 4 |
| _Level5Vector: |
| wsr a0, EXCSAVE_5 /* preserve a0 */ |
| call0 _xt_medint5 /* load interrupt handler */ |
| |
| .end literal_prefix |
| |
| .text |
| .type _xt_medint5,@function |
| .align 4 |
| _xt_medint5: |
| mov a0, sp /* sp == a1 */ |
| addi sp, sp, -XT_STK_FRMSZ /* allocate interrupt stack frame */ |
| s32i a0, sp, XT_STK_a1 /* save pre-interrupt SP */ |
| rsr a0, EPS_5 /* save interruptee's PS */ |
| s32i a0, sp, XT_STK_ps |
| rsr a0, EPC_5 /* save interruptee's PC */ |
| s32i a0, sp, XT_STK_pc |
| rsr a0, EXCSAVE_5 /* save interruptee's a0 */ |
| s32i a0, sp, XT_STK_a0 |
| movi a0, _xt_medint5_exit /* save exit point for dispatch */ |
| s32i a0, sp, XT_STK_exit |
| |
| /* Save rest of interrupt context and enter RTOS. */ |
| call0 XT_RTOS_INT_ENTER /* common RTOS interrupt entry */ |
| |
| /* !! We are now on the RTOS system stack !! */ |
| |
| /* Set up PS for C, enable interrupts above this level and clear |
| * EXCM. |
| */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| movi a0, PS_INTLEVEL(5) | PS_UM |
| #else |
| movi a0, PS_INTLEVEL(5) | PS_UM | PS_WOE |
| #endif |
| wsr a0, PS |
| rsync |
| |
| /* OK to call C code at this point, dispatch user ISRs */ |
| |
| dispatch_c_isr 5 XCHAL_INTLEVEL5_MASK |
| |
| /* Done handling interrupts, transfer control to OS */ |
| call0 XT_RTOS_INT_EXIT /* does not return directly here */ |
| |
| /* Exit point for dispatch. Saved in interrupt stack frame at |
| * XT_STK_EXITon entry and used to return to a thread or interrupted |
| * interrupt handler. |
| */ |
| .global _xt_medint5_exit |
| .type _xt_medint5_exit,@function |
| .align 4 |
| _xt_medint5_exit: |
| /* Restore only level-specific regs (the rest were already restored) */ |
| l32i a0, sp, XT_STK_ps /* retrieve interruptee's PS */ |
| wsr a0, EPS_5 |
| l32i a0, sp, XT_STK_pc /* retrieve interruptee's PC */ |
| wsr a0, EPC_5 |
| l32i a0, sp, XT_STK_a0 /* retrieve interruptee's A0 */ |
| l32i sp, sp, XT_STK_a1 /* remove interrupt stack frame */ |
| rsync /* ensure EPS and EPC written */ |
| rfi 5 |
| |
| #endif /* Level 5 */ |
| |
| #if XCHAL_EXCM_LEVEL >= 6 |
| |
| .begin literal_prefix .Level6InterruptVector |
| .section .Level6InterruptVector.text, "ax" |
| .global _Level6Vector |
| .type _Level6Vector,@function |
| .align 4 |
| _Level6Vector: |
| wsr a0, EXCSAVE_6 /* preserve a0 */ |
| call0 _xt_medint6 /* load interrupt handler */ |
| |
| .end literal_prefix |
| |
| .text |
| .type _xt_medint6,@function |
| .align 4 |
| _xt_medint6: |
| mov a0, sp /* sp == a1 */ |
| addi sp, sp, -XT_STK_FRMSZ /* allocate interrupt stack frame */ |
| s32i a0, sp, XT_STK_a1 /* save pre-interrupt SP */ |
| rsr a0, EPS_6 /* save interruptee's PS */ |
| s32i a0, sp, XT_STK_ps |
| rsr a0, EPC_6 /* save interruptee's PC */ |
| s32i a0, sp, XT_STK_pc |
| rsr a0, EXCSAVE_6 /* save interruptee's a0 */ |
| s32i a0, sp, XT_STK_a0 |
| movi a0, _xt_medint6_exit /* save exit point for dispatch */ |
| s32i a0, sp, XT_STK_exit |
| |
| /* Save rest of interrupt context and enter RTOS. */ |
| call0 XT_RTOS_INT_ENTER /* common RTOS interrupt entry */ |
| |
| /* !! We are now on the RTOS system stack !! */ |
| |
| /* Set up PS for C, enable interrupts above this level and clear |
| * EXCM. |
| */ |
| #ifdef __XTENSA_CALL0_ABI__ |
| movi a0, PS_INTLEVEL(6) | PS_UM |
| #else |
| movi a0, PS_INTLEVEL(6) | PS_UM | PS_WOE |
| #endif |
| wsr a0, PS |
| rsync |
| |
| /* OK to call C code at this point, dispatch user ISRs */ |
| |
| dispatch_c_isr 6 XCHAL_INTLEVEL6_MASK |
| |
| /* Done handling interrupts, transfer control to OS */ |
| call0 XT_RTOS_INT_EXIT /* does not return directly here */ |
| |
| /* Exit point for dispatch. Saved in interrupt stack frame at |
| * XT_STK_EXIT on entry and used to return to a thread or interrupted |
| * interrupt handler. |
| */ |
| .global _xt_medint6_exit |
| .type _xt_medint6_exit,@function |
| .align 4 |
| _xt_medint6_exit: |
| /* Restore only level-specific regs (the rest were already restored) */ |
| l32i a0, sp, XT_STK_ps /* retrieve interruptee's PS */ |
| wsr a0, EPS_6 |
| l32i a0, sp, XT_STK_pc /* retrieve interruptee's PC */ |
| wsr a0, EPC_6 |
| l32i a0, sp, XT_STK_a0 /* retrieve interruptee's A0 */ |
| l32i sp, sp, XT_STK_a1 /* remove interrupt stack frame */ |
| rsync /* ensure EPS and EPC written */ |
| rfi 6 |
| |
| #endif /* Level 6 */ |
| |
| |
| /* |
| * HIGH PRIORITY (LEVEL > XCHAL_EXCM_LEVEL) INTERRUPT VECTORS AND HANDLERS |
| * |
| * High priority interrupts are by definition those with priorities greater |
| * than XCHAL_EXCM_LEVEL. This includes non-maskable (NMI). High priority |
| * interrupts cannot interact with the RTOS, that is they must save all regs |
| * they use and not call any RTOS function. |
| * |
| * A further restriction imposed by the Xtensa windowed architecture is that |
| * high priority interrupts must not modify the stack area even logically |
| * "above" the top of the interrupted stack (they need to provide their own |
| * stack or static save area). |
| * |
| * Cadence Design Systems recommends high priority interrupt handlers be coded |
| * in assembly and used for purposes requiring very short service times. |
| * |
| * Here are templates for high priority (level 2+) interrupt vectors. They |
| * assume only one interrupt per level to avoid the burden of identifying which |
| * interrupts at this level are pending and enabled. This allows for minimum |
| * latency and avoids having to save/restore a2 in addition to a0. If more than |
| * one interrupt per high priority level is configured, this burden is on the |
| * handler which in any case must provide a way to save and restore registers |
| * it uses without touching the interrupted stack. |
| * |
| * Each vector goes at a predetermined location according to the Xtensa |
| * hardware configuration, which is ensured by its placement in a special |
| * section known to the Xtensa linker support package (LSP). It performs the |
| * minimum necessary before jumping to the handler in the .text section. |
| */ |
| |
| /* Currently only shells for high priority interrupt handlers are provided |
| * here. However a template and example can be found in the Cadence Design |
| * Systems tools documentation: "Microprocessor Programmer's Guide". |
| */ |
| |
| #if XCHAL_NUM_INTLEVELS >=2 && XCHAL_EXCM_LEVEL <2 && XCHAL_DEBUGLEVEL !=2 |
| |
| .begin literal_prefix .Level2InterruptVector |
| .section .Level2InterruptVector.text, "ax" |
| .global _Level2Vector |
| .type _Level2Vector,@function |
| .align 4 |
| _Level2Vector: |
| wsr a0, EXCSAVE_2 /* preserve a0 */ |
| call0 _xt_highint2 /* load interrupt handler */ |
| |
| .end literal_prefix |
| |
| .text |
| .type _xt_highint2,@function |
| .align 4 |
| _xt_highint2: |
| |
| #ifdef XT_INTEXC_HOOKS |
| /* Call interrupt hook if present to (pre)handle interrupts. */ |
| movi a0, _xt_intexc_hooks |
| l32i a0, a0, 2<<2 |
| beqz a0, 1f |
| .Ln_xt_highint2_call_hook: |
| callx0 a0 /* must NOT disturb stack! */ |
| 1: |
| #endif |
| |
| /* USER_EDIT: ADD HIGH PRIORITY LEVEL 2 INTERRUPT HANDLER CODE HERE. */ |
| |
| .align 4 |
| .L_xt_highint2_exit: |
| rsr a0, EXCSAVE_2 /* restore a0 */ |
| rfi 2 |
| |
| #endif /* Level 2 */ |
| |
| #if XCHAL_NUM_INTLEVELS >=3 && XCHAL_EXCM_LEVEL <3 && XCHAL_DEBUGLEVEL !=3 |
| |
| .begin literal_prefix .Level3InterruptVector |
| .section .Level3InterruptVector.text, "ax" |
| .global _Level3Vector |
| .type _Level3Vector,@function |
| .align 4 |
| _Level3Vector: |
| wsr a0, EXCSAVE_3 /* preserve a0 */ |
| call0 _xt_highint3 /* load interrupt handler */ |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| |
| .end literal_prefix |
| |
| .text |
| .type _xt_highint3,@function |
| .align 4 |
| _xt_highint3: |
| |
| #ifdef XT_INTEXC_HOOKS |
| /* Call interrupt hook if present to (pre)handle interrupts. */ |
| movi a0, _xt_intexc_hooks |
| l32i a0, a0, 3<<2 |
| beqz a0, 1f |
| .Ln_xt_highint3_call_hook: |
| callx0 a0 /* must NOT disturb stack! */ |
| 1: |
| #endif |
| |
| /* USER_EDIT: ADD HIGH PRIORITY LEVEL 3 INTERRUPT HANDLER CODE HERE. */ |
| |
| .align 4 |
| .L_xt_highint3_exit: |
| rsr a0, EXCSAVE_3 /* restore a0 */ |
| rfi 3 |
| |
| #endif /* Level 3 */ |
| |
| #if !defined(CONFIG_SOC_ESP32) && XCHAL_NUM_INTLEVELS >=4 && XCHAL_EXCM_LEVEL <4 && XCHAL_DEBUGLEVEL !=4 |
| |
| .begin literal_prefix .Level4InterruptVector |
| .section .Level4InterruptVector.text, "ax" |
| .global _Level4Vector |
| .type _Level4Vector,@function |
| .align 4 |
| _Level4Vector: |
| wsr a0, EXCSAVE_4 /* preserve a0 */ |
| call0 _xt_highint4 /* load interrupt handler */ |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| |
| .end literal_prefix |
| |
| .text |
| .type _xt_highint4,@function |
| .align 4 |
| _xt_highint4: |
| |
| #ifdef XT_INTEXC_HOOKS |
| /* Call interrupt hook if present to (pre)handle interrupts. */ |
| movi a0, _xt_intexc_hooks |
| l32i a0, a0, 4<<2 |
| beqz a0, 1f |
| .Ln_xt_highint4_call_hook: |
| callx0 a0 /* must NOT disturb stack! */ |
| 1: |
| #endif |
| |
| /* USER_EDIT: ADD HIGH PRIORITY LEVEL 4 INTERRUPT HANDLER CODE HERE. */ |
| |
| .align 4 |
| .L_xt_highint4_exit: |
| rsr a0, EXCSAVE_4 /* restore a0 */ |
| rfi 4 |
| |
| #endif /* Level 4 */ |
| |
| #if XCHAL_NUM_INTLEVELS >=5 && XCHAL_EXCM_LEVEL <5 && XCHAL_DEBUGLEVEL !=5 |
| |
| .begin literal_prefix .Level5InterruptVector |
| .section .Level5InterruptVector.text, "ax" |
| .global _Level5Vector |
| .type _Level5Vector,@function |
| .align 4 |
| _Level5Vector: |
| wsr a0, EXCSAVE_5 /* preserve a0 */ |
| call0 _xt_highint5 /* load interrupt handler */ |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| |
| .end literal_prefix |
| |
| .text |
| .type _xt_highint5,@function |
| .align 4 |
| _xt_highint5: |
| |
| #ifdef XT_INTEXC_HOOKS |
| /* Call interrupt hook if present to (pre)handle interrupts. */ |
| movi a0, _xt_intexc_hooks |
| l32i a0, a0, 5<<2 |
| beqz a0, 1f |
| .Ln_xt_highint5_call_hook: |
| callx0 a0 /* must NOT disturb stack! */ |
| 1: |
| #endif |
| |
| /* USER_EDIT: |
| * ADD HIGH PRIORITY LEVEL 5 INTERRUPT HANDLER CODE HERE. |
| */ |
| |
| .align 4 |
| .L_xt_highint5_exit: |
| rsr a0, EXCSAVE_5 /* restore a0 */ |
| rfi 5 |
| |
| #endif /* Level 5 */ |
| |
| #if XCHAL_NUM_INTLEVELS >=6 && XCHAL_EXCM_LEVEL <6 && XCHAL_DEBUGLEVEL !=6 |
| |
| .begin literal_prefix .Level6InterruptVector |
| .section .Level6InterruptVector.text, "ax" |
| .global _Level6Vector |
| .type _Level6Vector,@function |
| .align 4 |
| _Level6Vector: |
| wsr a0, EXCSAVE_6 /* preserve a0 */ |
| call0 _xt_highint6 /* load interrupt handler */ |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| |
| .end literal_prefix |
| |
| .text |
| .type _xt_highint6,@function |
| .align 4 |
| _xt_highint6: |
| |
| #ifdef XT_INTEXC_HOOKS |
| /* Call interrupt hook if present to (pre)handle interrupts. */ |
| movi a0, _xt_intexc_hooks |
| l32i a0, a0, 6<<2 |
| beqz a0, 1f |
| .Ln_xt_highint6_call_hook: |
| callx0 a0 /* must NOT disturb stack! */ |
| 1: |
| #endif |
| |
| /* USER_EDIT: |
| * ADD HIGH PRIORITY LEVEL 6 INTERRUPT HANDLER CODE HERE. |
| */ |
| |
| .align 4 |
| .L_xt_highint6_exit: |
| rsr a0, EXCSAVE_6 /* restore a0 */ |
| rfi 6 |
| |
| #endif /* Level 6 */ |
| |
| #if XCHAL_HAVE_NMI |
| |
| .begin literal_prefix .NMIExceptionVector |
| .section .NMIExceptionVector.text, "ax" |
| .global _NMIExceptionVector |
| .type _NMIExceptionVector,@function |
| .align 4 |
| _NMIExceptionVector: |
| wsr a0, EXCSAVE + XCHAL_NMILEVEL _ /* preserve a0 */ |
| call0 _xt_nmi /* load interrupt handler */ |
| /* never returns here - call0 is used as a jump (see note at top) */ |
| |
| .end literal_prefix |
| |
| .text |
| .type _xt_nmi,@function |
| .align 4 |
| _xt_nmi: |
| |
| #ifdef XT_INTEXC_HOOKS |
| /* Call interrupt hook if present to (pre)handle interrupts. */ |
| movi a0, _xt_intexc_hooks |
| l32i a0, a0, XCHAL_NMILEVEL<<2 |
| beqz a0, 1f |
| .Ln_xt_nmi_call_hook: |
| callx0 a0 /* must NOT disturb stack! */ |
| 1: |
| #endif |
| |
| /* USER_EDIT: |
| * ADD HIGH PRIORITY NON-MASKABLE INTERRUPT (NMI) HANDLER CODE HERE. |
| */ |
| |
| .align 4 |
| .L_xt_nmi_exit: |
| rsr a0, EXCSAVE + XCHAL_NMILEVEL /* restore a0 */ |
| rfi XCHAL_NMILEVEL |
| |
| #endif /* NMI */ |
| |
| |
| /* WINDOW OVERFLOW AND UNDERFLOW EXCEPTION VECTORS AND ALLOCA EXCEPTION |
| * HANDLER |
| * |
| * Here is the code for each window overflow/underflow exception vector and |
| * (interspersed) efficient code for handling the alloca exception cause. |
| * Window exceptions are handled entirely in the vector area and are very tight |
| * for performance. The alloca exception is also handled entirely in the window |
| * vector area so comes at essentially no cost in code size. Users should never |
| * need to modify them and Cadence Design Systems recommends they do not. |
| * |
| * Window handlers go at predetermined vector locations according to the Xtensa |
| * hardware configuration, which is ensured by their placement in a special |
| * section known to the Xtensa linker support package (LSP). Since their |
| * offsets in that section are always the same, the LSPs do not define a |
| * section per vector. |
| * |
| * These things are coded for XEA2 only (XEA1 is not supported). |
| * |
| * Note on Underflow Handlers: |
| * |
| * The underflow handler for returning from call[i+1] to call[i] must preserve |
| * all the registers from call[i+1]'s window. In particular, a0 and a1 must be |
| * preserved because the RETW instruction will be reexecuted (and may even |
| * underflow if an intervening exception has flushed call[i]'s registers). |
| * Registers a2 and up may contain return values. |
| */ |
| |
| #if XCHAL_HAVE_WINDOWED |
| |
| .section .WindowVectors.text, "ax" |
| |
| /* Window Overflow Exception for Call4. |
| * |
| * Invoked if a call[i] referenced a register (a4-a15) |
| * that contains data from ancestor call[j]; |
| * call[j] had done a call4 to call[j+1]. |
| * On entry here: |
| * window rotated to call[j] start point; |
| * a0-a3 are registers to be saved; |
| * a4-a15 must be preserved; |
| * a5 is call[j+1]'s stack pointer. |
| */ |
| |
| .org 0x0 |
| .global _WindowOverflow4 |
| _WindowOverflow4: |
| |
| s32e a0, a5, -16 /* save a0 to call[j+1]'s stack frame */ |
| s32e a1, a5, -12 /* save a1 to call[j+1]'s stack frame */ |
| s32e a2, a5, -8 /* save a2 to call[j+1]'s stack frame */ |
| s32e a3, a5, -4 /* save a3 to call[j+1]'s stack frame */ |
| rfwo /* rotates back to call[i] position */ |
| |
| /* Window Underflow Exception for Call4 |
| * |
| * Invoked by RETW returning from call[i+1] to call[i] |
| * where call[i]'s registers must be reloaded (not live in ARs); |
| * where call[i] had done a call4 to call[i+1]. |
| * On entry here: |
| * window rotated to call[i] start point; |
| * a0-a3 are undefined, must be reloaded with call[i].reg[0..3]; |
| * a4-a15 must be preserved (they are call[i+1].reg[0..11]); |
| * a5 is call[i+1]'s stack pointer. |
| */ |
| |
| .org 0x40 |
| .global _WindowUnderflow4 |
| _WindowUnderflow4: |
| |
| l32e a0, a5, -16 /* restore a0 from call[i+1]'s stack frame */ |
| l32e a1, a5, -12 /* restore a1 from call[i+1]'s stack frame */ |
| l32e a2, a5, -8 /* restore a2 from call[i+1]'s stack frame */ |
| l32e a3, a5, -4 /* restore a3 from call[i+1]'s stack frame */ |
| rfwu |
| |
| /* Handle alloca exception generated by interruptee executing 'movsp'. |
| * This uses space between the window vectors, so is essentially "free". |
| * All interruptee's regs are intact except a0 which is saved in EXCSAVE_1, |
| * and PS.EXCM has been set by the exception hardware (can't be interrupted). |
| * The fact the alloca exception was taken means the registers associated with |
| * the base-save area have been spilled and will be restored by the underflow |
| * handler, so those 4 registers are available for scratch. |
| * The code is optimized to avoid unaligned branches and minimize cache misses. |
| */ |
| |
| .align 4 |
| .global _xt_alloca_exc |
| _xt_alloca_exc: |
| |
| rsr a0, WINDOWBASE /* grab WINDOWBASE before rotw changes it */ |
| rotw -1 /* WINDOWBASE goes to a4, new a0-a3 are scratch */ |
| rsr a2, PS |
| extui a3, a2, XCHAL_PS_OWB_SHIFT, XCHAL_PS_OWB_BITS |
| xor a3, a3, a4 /* bits changed from old to current windowbase */ |
| rsr a4, EXCSAVE_1 /* restore original a0 (now in a4) */ |
| slli a3, a3, XCHAL_PS_OWB_SHIFT |
| xor a2, a2, a3 /* flip changed bits in old window base */ |
| wsr a2, PS /* update PS.OWB to new window base */ |
| rsync |
| |
| _bbci.l a4, 31, _WindowUnderflow4 |
| rotw -1 /* original a0 goes to a8 */ |
| _bbci.l a8, 30, _WindowUnderflow8 |
| rotw -1 |
| j _WindowUnderflow12 |
| |
| /* Window Overflow Exception for Call8 |
| * |
| * Invoked if a call[i] referenced a register (a4-a15) |
| * that contains data from ancestor call[j]; |
| * call[j] had done a call8 to call[j+1]. |
| * On entry here: |
| * window rotated to call[j] start point; |
| * a0-a7 are registers to be saved; |
| * a8-a15 must be preserved; |
| * a9 is call[j+1]'s stack pointer. |
| */ |
| |
| .org 0x80 |
| .global _WindowOverflow8 |
| _WindowOverflow8: |
| |
| s32e a0, a9, -16 /* save a0 to call[j+1]'s stack frame */ |
| l32e a0, a1, -12 /* a0 <- call[j-1]'s sp |
| (used to find end of call[j]'s frame) */ |
| s32e a1, a9, -12 /* save a1 to call[j+1]'s stack frame */ |
| s32e a2, a9, -8 /* save a2 to call[j+1]'s stack frame */ |
| s32e a3, a9, -4 /* save a3 to call[j+1]'s stack frame */ |
| s32e a4, a0, -32 /* save a4 to call[j]'s stack frame */ |
| s32e a5, a0, -28 /* save a5 to call[j]'s stack frame */ |
| s32e a6, a0, -24 /* save a6 to call[j]'s stack frame */ |
| s32e a7, a0, -20 /* save a7 to call[j]'s stack frame */ |
| rfwo /* rotates back to call[i] position */ |
| |
| /* |
| * Window Underflow Exception for Call8 |
| * |
| * Invoked by RETW returning from call[i+1] to call[i] |
| * where call[i]'s registers must be reloaded (not live in ARs); |
| * where call[i] had done a call8 to call[i+1]. |
| * On entry here: |
| * window rotated to call[i] start point; |
| * a0-a7 are undefined, must be reloaded with call[i].reg[0..7]; |
| * a8-a15 must be preserved (they are call[i+1].reg[0..7]); |
| * a9 is call[i+1]'s stack pointer. |
| */ |
| |
| .org 0xC0 |
| .global _WindowUnderflow8 |
| _WindowUnderflow8: |
| |
| l32e a0, a9, -16 /* restore a0 from call[i+1]'s stack frame */ |
| l32e a1, a9, -12 /* restore a1 from call[i+1]'s stack frame */ |
| l32e a2, a9, -8 /* restore a2 from call[i+1]'s stack frame */ |
| l32e a7, a1, -12 /* a7 <- call[i-1]'s sp |
| (used to find end of call[i]'s frame) */ |
| l32e a3, a9, -4 /* restore a3 from call[i+1]'s stack frame */ |
| l32e a4, a7, -32 /* restore a4 from call[i]'s stack frame */ |
| l32e a5, a7, -28 /* restore a5 from call[i]'s stack frame */ |
| l32e a6, a7, -24 /* restore a6 from call[i]'s stack frame */ |
| l32e a7, a7, -20 /* restore a7 from call[i]'s stack frame */ |
| rfwu |
| |
| /* |
| * Window Overflow Exception for Call12 |
| * |
| * Invoked if a call[i] referenced a register (a4-a15) |
| * that contains data from ancestor call[j]; |
| * call[j] had done a call12 to call[j+1]. |
| * On entry here: |
| * window rotated to call[j] start point; |
| * a0-a11 are registers to be saved; |
| * a12-a15 must be preserved; |
| * a13 is call[j+1]'s stack pointer. |
| */ |
| |
| .org 0x100 |
| .global _WindowOverflow12 |
| _WindowOverflow12: |
| |
| s32e a0, a13, -16 /* save a0 to call[j+1]'s stack frame */ |
| l32e a0, a1, -12 /* a0 <- call[j-1]'s sp |
| (used to find end of call[j]'s frame) */ |
| s32e a1, a13, -12 /* save a1 to call[j+1]'s stack frame */ |
| s32e a2, a13, -8 /* save a2 to call[j+1]'s stack frame */ |
| s32e a3, a13, -4 /* save a3 to call[j+1]'s stack frame */ |
| s32e a4, a0, -48 /* save a4 to end of call[j]'s stack frame */ |
| s32e a5, a0, -44 /* save a5 to end of call[j]'s stack frame */ |
| s32e a6, a0, -40 /* save a6 to end of call[j]'s stack frame */ |
| s32e a7, a0, -36 /* save a7 to end of call[j]'s stack frame */ |
| s32e a8, a0, -32 /* save a8 to end of call[j]'s stack frame */ |
| s32e a9, a0, -28 /* save a9 to end of call[j]'s stack frame */ |
| s32e a10, a0, -24 /* save a10 to end of call[j]'s stack frame */ |
| s32e a11, a0, -20 /* save a11 to end of call[j]'s stack frame */ |
| rfwo /* rotates back to call[i] position */ |
| |
| /* |
| * Window Underflow Exception for Call12 |
| * |
| * Invoked by RETW returning from call[i+1] to call[i] |
| * where call[i]'s registers must be reloaded (not live in ARs); |
| * where call[i] had done a call12 to call[i+1]. |
| * On entry here: |
| * window rotated to call[i] start point; |
| * a0-a11 are undefined, must be reloaded with call[i].reg[0..11]; |
| * a12-a15 must be preserved (they are call[i+1].reg[0..3]); |
| * a13 is call[i+1]'s stack pointer. |
| */ |
| |
| .org 0x140 |
| .global _WindowUnderflow12 |
| _WindowUnderflow12: |
| |
| l32e a0, a13, -16 /* restore a0 from call[i+1]'s stack frame */ |
| l32e a1, a13, -12 /* restore a1 from call[i+1]'s stack frame */ |
| l32e a2, a13, -8 /* restore a2 from call[i+1]'s stack frame */ |
| l32e a11, a1, -12 /* a11 <- call[i-1]'s sp |
| * (used to find end of call[i]'s frame) */ |
| l32e a3, a13, -4 /* restore a3 from call[i+1]'s stack frame */ |
| l32e a4, a11, -48 /* restore a4 from end of call[i]'s stack frame */ |
| l32e a5, a11, -44 /* restore a5 from end of call[i]'s stack frame */ |
| l32e a6, a11, -40 /* restore a6 from end of call[i]'s stack frame */ |
| l32e a7, a11, -36 /* restore a7 from end of call[i]'s stack frame */ |
| l32e a8, a11, -32 /* restore a8 from end of call[i]'s stack frame */ |
| l32e a9, a11, -28 /* restore a9 from end of call[i]'s stack frame */ |
| l32e a10, a11, -24 /* restore a10 from end of call[i]'s stack |
| * frame */ |
| l32e a11, a11, -20 /* restore a11 from end of call[i]'s stack |
| * frame */ |
| rfwu |
| |
| #endif /* XCHAL_HAVE_WINDOWED */ |
| |
