j3d1/esp-open-rtos
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
esp-open-rtos/core/exception_vectors.S

505 lines
16 KiB
ArmAsm
Raw Normal View History

Add exception vectors & low-level handlers At the moment these are almost bit-for-bit copies of the vector behaviour in the RTOS SDK, but hopefully that will start to change. Progress towards #2
2015-07-28 01:01:57 +00:00
/* Xtensa Exception (ie interrupt) Vectors & low-level handler code
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
*
* Core exception handler code is placed in the .vecbase section, which gets
* picked up specially in the linker script and placed at beginning of IRAM.
*
* The actual VecBase symbol should be the first thing in .vecbase (this is not
* strictly important as it gets set by symbol lookup not by hardcoded address,
* but having it at 0x40100000 means that the exception vectors have memorable
* offsets, which match the default Boot ROM vector offsets. So convenient for
* human understanding.
*
* Part of esp-open-rtos
* Original vector contents Copyright (C) 2014-2015 Espressif Systems
* Additions Copyright (C) Superhouse Automation Pty Ltd and Angus Gratton
* BSD Licensed as described in the file LICENSE
*/
Extended unaligned load support to work from DoubleExceptionVector Allows handling bad loads that occur inside level 1 exception handlers.
2015-09-10 05:02:47 +00:00
Use GPIO2 for led_debug.S
2015-09-14 07:19:09 +00:00
#include "led_debug.s"
Extended unaligned load support to work from DoubleExceptionVector Allows handling bad loads that occur inside level 1 exception handlers.
2015-09-10 05:02:47 +00:00
/* Some UserException causes, see table Table 4–64 in ISA reference */
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
Extended unaligned load support to work from DoubleExceptionVector Allows handling bad loads that occur inside level 1 exception handlers.
2015-09-10 05:02:47 +00:00
#define CAUSE_SYSCALL 1
#define CAUSE_LOADSTORE 3
#define CAUSE_LVL1INT 4
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.section .bss
NMIHandlerStack: # stack space for NMI handler
.skip 4*0x100
NMIExceptionHandler: Clean up, refactor to use excsave3 for stack pointer
2015-09-29 04:37:33 +00:00
.NMIHandlerStackTop:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
LoadStoreErrorHandlerStack:
.word 0 # a0
.word 0 # (unused)
.word 0 # a2
.word 0 # a3
.word 0 # a4
/***************************** Exception Vectors *****************************/
.section .vecbase.text, "x"
/* Note: Exception vectors must be aligned on a 256-byte (0x100) boundary or
* they will not function properly. (This is taken care of in the linker
* script by ensuring .vecbase.text is aligned properly, and putting VecBase
* right at the beginning of .vecbase.text) */
.org 0
Add exception vectors & low-level handlers At the moment these are almost bit-for-bit copies of the vector behaviour in the RTOS SDK, but hopefully that will start to change. Progress towards #2
2015-07-28 01:01:57 +00:00
VecBase:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.global VecBase
/* IMPORTANT: exception vector literals will go here, but we
* can't have more than 4 otherwise we push DebugExceptionVector past
* offset 0x10 relative to VecBase. There should be ways to avoid this,
* and also keep the VecBase offsets easy to read, but this works for
* now. */
.literal_position
.org VecBase + 0x10
Add exception vectors & low-level handlers At the moment these are almost bit-for-bit copies of the vector behaviour in the RTOS SDK, but hopefully that will start to change. Progress towards #2
2015-07-28 01:01:57 +00:00
DebugExceptionVector:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.type DebugExceptionVector, @function
Exception vectors: Rearrange to use absolute offets instead of .align hacks
2015-09-10 11:35:18 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
wsr a0, excsave2
call0 sdk_user_fatal_exception_handler
rfi 2
.org VecBase + 0x20
Add exception vectors & low-level handlers At the moment these are almost bit-for-bit copies of the vector behaviour in the RTOS SDK, but hopefully that will start to change. Progress towards #2
2015-07-28 01:01:57 +00:00
NMIExceptionVector:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.type NMIExceptionVector, @function
NMIExceptionHandler: Clean up, refactor to use excsave3 for stack pointer
2015-09-29 04:37:33 +00:00
j NMIExceptionHandler
Exception vectors: Rearrange to use absolute offets instead of .align hacks
2015-09-10 11:35:18 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.org VecBase + 0x30
Add exception vectors & low-level handlers At the moment these are almost bit-for-bit copies of the vector behaviour in the RTOS SDK, but hopefully that will start to change. Progress towards #2
2015-07-28 01:01:57 +00:00
KernelExceptionVector:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.type KernelExceptionVector, @function
Exception vectors: Rearrange to use absolute offets instead of .align hacks
2015-09-10 11:35:18 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
break 1, 0
call0 sdk_user_fatal_exception_handler
rfe
.org VecBase + 0x50
Add exception vectors & low-level handlers At the moment these are almost bit-for-bit copies of the vector behaviour in the RTOS SDK, but hopefully that will start to change. Progress towards #2
2015-07-28 01:01:57 +00:00
UserExceptionVector:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.type UserExceptionVector, @function
Exception vectors: Rearrange to use absolute offets instead of .align hacks
2015-09-10 11:35:18 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
wsr a1, excsave1
rsr a1, exccause
beqi a1, CAUSE_LOADSTORE, LoadStoreErrorHandler
j UserExceptionHandler
Exception vectors: Rearrange to use absolute offets instead of .align hacks
2015-09-10 11:35:18 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.org VecBase + 0x70
DoubleExceptionVector:
.type DoubleExceptionVector, @function
Exception vectors: Rearrange to use absolute offets instead of .align hacks
2015-09-10 11:35:18 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
break 1, 4
call0 sdk_user_fatal_exception_handler
Add exception vectors & low-level handlers At the moment these are almost bit-for-bit copies of the vector behaviour in the RTOS SDK, but hopefully that will start to change. Progress towards #2
2015-07-28 01:01:57 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
/* Reset vector at offset 0x80 is unused, as vecbase gets reset to mask ROM
* vectors on chip reset. */
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
/*************************** LoadStoreError Handler **************************/
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.section .vecbase.text, "x"
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
/* Xtensa "Load/Store Exception" handler:
* Completes L8/L16 load instructions from Instruction address space, for which
* the architecture only supports 32-bit reads.
*
* Called from UserExceptionVector if EXCCAUSE is LoadStoreErrorCause
*
* (Fast path (no branches) is for L8UI)
*/
.literal_position
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.balign 4
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
LoadStoreErrorHandler:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.type LoadStoreErrorHandler, @function
/* Registers are saved in the address corresponding to their register
* number times 4. This allows a quick and easy mapping later on when
* needing to store the value to a particular register number. */
movi sp, LoadStoreErrorHandlerStack
s32i a0, sp, 0
s32i a2, sp, 0x08
s32i a3, sp, 0x0c
s32i a4, sp, 0x10
rsr a0, sar # Save SAR in a0 to restore later
/* Examine the opcode which generated the exception */
/* Note: Instructions are in this order to avoid pipeline stalls. */
rsr a2, epc1
movi a3, ~3
ssa8l a2 # sar is now correct shift for aligned read
and a2, a2, a3 # a2 now 4-byte aligned address of instruction
l32i a4, a2, 0
l32i a2, a2, 4
movi a3, 0x00700F # opcode mask for l8ui/l16si/l16ui
src a2, a2, a4 # a2 now instruction that failed
and a3, a2, a3 # a3 is masked instruction
bnei a3, 0x000002, .LSE_check_l16
/* Note: At this point, opcode could technically be one of two things:
* xx0xx2 (L8UI)
* xx8xx2 (Reserved (invalid) opcode)
* It is assumed that we'll never get to this point from an illegal
* opcode, so we don't bother to check for that case and presume this
* is always an L8UI. */
movi a4, ~3
rsr a3, excvaddr # read faulting address
and a4, a3, a4 # a4 now word aligned read address
l32i a4, a4, 0 # perform the actual read
ssa8l a3 # sar is now shift to extract a3's byte
srl a3, a4 # shift right correct distance
extui a4, a3, 0, 8 # mask off bits we need for an l8
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
.LSE_post_fetch:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
/* We jump back here after either the L8UI or the L16*I routines do the
* necessary work to read the value from memory.
* At this point, a2 holds the faulting instruction and a4 holds the
* correctly read value.
* Restore original SAR value (saved in a0) and update EPC so we'll
* return back to the instruction following the one we just emulated */
/* Note: Instructions are in this order to avoid pipeline stalls */
rsr a3, epc1
wsr a0, sar
addi a3, a3, 0x3
wsr a3, epc1
/* Stupid opcode tricks: The jumptable we use later on needs 16 bytes
* per entry (so we can avoid a second jump by just doing a RFE inside
* each entry). Unfortunately, however, Xtensa doesn't have an addx16
* operation to make that easy for us. Luckily, all of the faulting
* opcodes we're processing are guaranteed to have bit 3 be zero, which
* means if we just shift the register bits of the opcode down by 3
* instead of 4, we will get the register number multiplied by 2. This
* combined with an addx8 will give us an effective addx16 without
* needing any extra shift operations. */
extui a2, a2, 3, 5 # a2 is now destination register 0-15 times 2
bgei a2, 10, .LSE_assign_reg # a5..a15 use jumptable
beqi a2, 2, .LSE_assign_a1 # a1 uses a special routine
/* We're storing into a0 or a2..a4, which are all saved in our "stack"
* area. Calculate the correct address and stick the value in there,
* then just do our normal restore and RFE (no jumps required, which
* actually makes a0..a4 substantially faster). */
addx2 a2, a2, sp
s32i a4, a2, 0
/* Restore all regs and return */
l32i a0, sp, 0
l32i a2, sp, 0x08
l32i a3, sp, 0x0c
l32i a4, sp, 0x10
rsr a1, excsave1 # restore a1 saved by UserExceptionVector
rfe
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
.LSE_assign_reg:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
/* At this point, a2 contains the register number times 2, a4 is the
* read value. */
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
/* Calculate the jumptable address, and restore all regs except a2 and
* a4 so we have less to do after jumping. */
/* Note: Instructions are in this order to avoid pipeline stalls. */
movi a3, .LSE_jumptable_base
l32i a0, sp, 0
addx8 a2, a2, a3 # a2 is now the address to jump to
l32i a3, sp, 0x0c
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
jx a2
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.balign 4
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
.LSE_check_l16:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
/* At this point, a2 contains the opcode, a3 is masked opcode */
movi a4, 0x001002 # l16si or l16ui opcode after masking
bne a3, a4, .LSE_wrong_opcode
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
/* Note: At this point, the opcode could be one of two things:
* xx1xx2 (L16UI)
* xx9xx2 (L16SI)
* Both of these we can handle. */
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
movi a4, ~3
rsr a3, excvaddr # read faulting address
and a4, a3, a4 # a4 now word aligned read address
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
l32i a4, a4, 0 # perform the actual read
ssa8l a3 # sar is now shift to extract a3's bytes
srl a3, a4 # shift right correct distance
extui a4, a3, 0, 16 # mask off bits we need for an l16
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
bbci a2, 15, .LSE_post_fetch # Not a signed op
bbci a4, 15, .LSE_post_fetch # Value does not need sign-extension
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
movi a3, 0xFFFF0000
or a4, a3, a4 # set 32-bit sign bits
j .LSE_post_fetch
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
.LSE_wrong_opcode:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
/* If we got here it's not an opcode we can try to fix, so bomb out.
* Restore registers so any dump the fatal exception routine produces
* will have correct values */
wsr a0, sar
l32i a0, sp, 0
l32i a2, sp, 0x08
l32i a3, sp, 0x0c
l32i a4, sp, 0x10
rsr a1, excsave1
call0 sdk_user_fatal_exception_handler
.balign 4
More LoadStoreErrorHandler performance improvements
2015-09-23 15:51:36 +00:00
.LSE_assign_a1:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
/* a1 is saved in excsave1, so just update that with the value, */
wsr a4, excsave1
/* Then restore all regs and return */
l32i a0, sp, 0
l32i a2, sp, 0x08
l32i a3, sp, 0x0c
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
.balign 4
More LoadStoreErrorHandler performance improvements
2015-09-23 15:51:36 +00:00
.LSE_jumptable:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
/* The first 5 entries (80 bytes) of this table are unused (registers
* a0..a4 are handled separately above). Rather than have a whole bunch
* of wasted space, we just pretend that the table starts 80 bytes
* earlier in memory. */
.set .LSE_jumptable_base, .LSE_jumptable - (16 * 5)
.org .LSE_jumptable_base + (16 * 5)
mov a5, a4
l32i a2, sp, 0x08
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
.org .LSE_jumptable_base + (16 * 6)
mov a6, a4
l32i a2, sp, 0x08
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
.org .LSE_jumptable_base + (16 * 7)
mov a7, a4
l32i a2, sp, 0x08
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
.org .LSE_jumptable_base + (16 * 8)
mov a8, a4
l32i a2, sp, 0x08
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
.org .LSE_jumptable_base + (16 * 9)
mov a9, a4
l32i a2, sp, 0x08
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
.org .LSE_jumptable_base + (16 * 10)
mov a10, a4
l32i a2, sp, 0x08
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
.org .LSE_jumptable_base + (16 * 11)
mov a11, a4
l32i a2, sp, 0x08
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
.org .LSE_jumptable_base + (16 * 12)
mov a12, a4
l32i a2, sp, 0x08
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
.org .LSE_jumptable_base + (16 * 13)
mov a13, a4
l32i a2, sp, 0x08
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
.org .LSE_jumptable_base + (16 * 14)
mov a14, a4
l32i a2, sp, 0x08
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
.org .LSE_jumptable_base + (16 * 15)
mov a15, a4
l32i a2, sp, 0x08
l32i a4, sp, 0x10
rsr a1, excsave1
rfe
/****************************** call_user_start ******************************/
.section .vecbase.text, "x"
/* This is the first entrypoint called from the ROM after loading the image
* into IRAM. It just sets up the VECBASE register to point at our own
* exception vectors and then calls sdk_user_start() */
.literal_position
.balign 4
call_user_start:
.global call_user_start
.type call_user_start, @function
Add exception vectors & low-level handlers At the moment these are almost bit-for-bit copies of the vector behaviour in the RTOS SDK, but hopefully that will start to change. Progress towards #2
2015-07-28 01:01:57 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
movi a2, VecBase
wsr a2, vecbase
call0 sdk_user_start
/*************************** NMI Exception Handler ***************************/
.section .vecbase.text, "x"
Further optimizations for LoadStoreErrorHandler
2015-09-22 05:13:14 +00:00
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.literal_position
.balign 16
NMIExceptionHandler: Clean up, refactor to use excsave3 for stack pointer
2015-09-29 04:37:33 +00:00
NMIExceptionHandler:
.type NMIExceptionHandler, @function
wsr sp, excsave3 # excsave3 holds user stack
movi sp, .NMIHandlerStackTop - 0x54
s32i a0, sp, 0x00
s32i a2, sp, 0x08
s32i a3, sp, 0x0c
s32i a4, sp, 0x10
s32i a5, sp, 0x14
s32i a6, sp, 0x18
s32i a7, sp, 0x1c
s32i a8, sp, 0x20
s32i a9, sp, 0x24
s32i a10, sp, 0x28
s32i a11, sp, 0x2c
s32i a12, sp, 0x30
s32i a13, sp, 0x34
s32i a14, sp, 0x38
s32i a15, sp, 0x3c
rsr a0, epc1
s32i a0, sp, 0x40
rsr a0, exccause
s32i a0, sp, 0x44
rsr a0, excsave1
s32i a0, sp, 0x48
rsr a0, excvaddr
s32i a0, sp, 0x4c
rsr a0, sar
s32i a0, sp, 0x50
movi a0, 0x23 # Override PS for NMI handler
wsr a0, ps
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
rsync
call0 sdk_wDev_ProcessFiq
NMIExceptionHandler: Clean up, refactor to use excsave3 for stack pointer
2015-09-29 04:37:33 +00:00
l32i a0, sp, 0x50
wsr a0, sar
l32i a0, sp, 0x4c
wsr a0, excvaddr
l32i a0, sp, 0x48
wsr a0, excsave1
l32i a0, sp, 0x44
wsr a0, exccause
l32i a0, sp, 0x40
wsr a0, epc1
l32i a15, sp, 0x3c
l32i a14, sp, 0x38
l32i a13, sp, 0x34
l32i a12, sp, 0x30
l32i a11, sp, 0x2c
l32i a10, sp, 0x28
l32i a9, sp, 0x24
l32i a8, sp, 0x20
l32i a7, sp, 0x1c
l32i a6, sp, 0x18
l32i a5, sp, 0x14
l32i a4, sp, 0x10
l32i a3, sp, 0x0c
movi a0, 0x33 # Reset PS
wsr a0, ps
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
rsync
NMIExceptionHandler: Clean up, refactor to use excsave3 for stack pointer
2015-09-29 04:37:33 +00:00
/* set dport nmi status to 1 (wDev_ProcessFiq clears bit 0 and verifies it
* stays cleared, see
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
* http://esp8266-re.foogod.com/wiki/WDev_ProcessFiq_%28IoT_RTOS_SDK_0.9.9%29)
*/
NMIExceptionHandler: Clean up, refactor to use excsave3 for stack pointer
2015-09-29 04:37:33 +00:00
movi a0, 0x3ff00000
movi a2, 0x1
s32i a2, a0, 0
l32i a2, sp, 0x08
l32i a0, sp, 0x00
movi a1, 0x0
xsr a1, excsave3 # Load stack back from excsave3, clear excsave3
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
rfi 3
/*********************** General UserException Handler ***********************/
.section .vecbase.text, "x"
/* Called by UserExceptionVector if EXCCAUSE is anything other than
* LoadStoreCause. */
.literal_position
.balign 4
Extended unaligned load support to work from DoubleExceptionVector Allows handling bad loads that occur inside level 1 exception handlers.
2015-09-10 05:02:47 +00:00
UserExceptionHandler:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.type UserExceptionHandler, @function
xsr a0, excsave1 # a0 now contains sp
mov sp, a0
addi sp, sp, -0x50
s32i a0, sp, 0x10
rsr a0, ps
s32i a0, sp, 0x08
rsr a0, epc1
s32i a0, sp, 0x04
rsr a0, excsave1
s32i a0, sp, 0x0c
movi a0, _xt_user_exit
s32i a0, sp, 0x0
call0 sdk__xt_int_enter
movi a0, 0x23
wsr a0, ps
rsync
rsr a2, exccause
Simplify interrupt and RTOS timer tick handlers RTOS Timer tick handler is now the same as any other ISR. This causes a few subtle behaviour changes that seem OK but are worth noting: * RTOS tick handler sdk__xt_timer_int() is now called from one stack frame deeper (inside _xt_isr_handler()), whereas before it was called from the level above in UserHandleInterrupt. I can't see any way that the extra ~40 bytes of stack use here hurt, though. * sdk__xt_timer_int() was previous called after all other interrupts flagged in the handler, now it's called before the TIMER FRC1 & FRC2 handlers. The tick handler doesn't appear to do anything particularly timing intensive, though. * GPIO interrupt (value 3) is now lower priority than the SPI interrupt (value 2), whereas before it would have been called before SPI if both interrupts triggered at once.
2015-09-24 00:17:07 +00:00
/* Any UserException cause other than a level 1 interrupt is fatal */
bnei a2, CAUSE_LVL1INT, .UserFailOtherExceptionCause
.UserHandleInterrupt:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
rsil a0, 1
rsr a2, intenable
rsr a3, interrupt
movi a4, 0x3fff
and a2, a2, a3
Simplify interrupt and RTOS timer tick handlers RTOS Timer tick handler is now the same as any other ISR. This causes a few subtle behaviour changes that seem OK but are worth noting: * RTOS tick handler sdk__xt_timer_int() is now called from one stack frame deeper (inside _xt_isr_handler()), whereas before it was called from the level above in UserHandleInterrupt. I can't see any way that the extra ~40 bytes of stack use here hurt, though. * sdk__xt_timer_int() was previous called after all other interrupts flagged in the handler, now it's called before the TIMER FRC1 & FRC2 handlers. The tick handler doesn't appear to do anything particularly timing intensive, though. * GPIO interrupt (value 3) is now lower priority than the SPI interrupt (value 2), whereas before it would have been called before SPI if both interrupts triggered at once.
2015-09-24 00:17:07 +00:00
and a2, a2, a4 # a2 = 0x3FFF & INTENABLE & INTERRUPT
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
call0 _xt_isr_handler
Simplify interrupt and RTOS timer tick handlers RTOS Timer tick handler is now the same as any other ISR. This causes a few subtle behaviour changes that seem OK but are worth noting: * RTOS tick handler sdk__xt_timer_int() is now called from one stack frame deeper (inside _xt_isr_handler()), whereas before it was called from the level above in UserHandleInterrupt. I can't see any way that the extra ~40 bytes of stack use here hurt, though. * sdk__xt_timer_int() was previous called after all other interrupts flagged in the handler, now it's called before the TIMER FRC1 & FRC2 handlers. The tick handler doesn't appear to do anything particularly timing intensive, though. * GPIO interrupt (value 3) is now lower priority than the SPI interrupt (value 2), whereas before it would have been called before SPI if both interrupts triggered at once.
2015-09-24 00:17:07 +00:00
j sdk__xt_int_exit # once finished, jumps to _xt_user_exit via stack
.literal_position
.UserFailOtherExceptionCause:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
break 1, 1
call0 sdk_user_fatal_exception_handler
Simplify interrupt and RTOS timer tick handlers RTOS Timer tick handler is now the same as any other ISR. This causes a few subtle behaviour changes that seem OK but are worth noting: * RTOS tick handler sdk__xt_timer_int() is now called from one stack frame deeper (inside _xt_isr_handler()), whereas before it was called from the level above in UserHandleInterrupt. I can't see any way that the extra ~40 bytes of stack use here hurt, though. * sdk__xt_timer_int() was previous called after all other interrupts flagged in the handler, now it's called before the TIMER FRC1 & FRC2 handlers. The tick handler doesn't appear to do anything particularly timing intensive, though. * GPIO interrupt (value 3) is now lower priority than the SPI interrupt (value 2), whereas before it would have been called before SPI if both interrupts triggered at once.
2015-09-24 00:17:07 +00:00
/* _xt_user_exit is pushed onto the stack as part of the user exception handler,
restores same set registers which were saved there and returns from exception */
Add exception vectors & low-level handlers At the moment these are almost bit-for-bit copies of the vector behaviour in the RTOS SDK, but hopefully that will start to change. Progress towards #2
2015-07-28 01:01:57 +00:00
_xt_user_exit:
Code reformat/cleanup of exception_vectors.S
2015-09-25 05:43:29 +00:00
.global _xt_user_exit
.type _xt_user_exit, @function
l32i a0, sp, 0x8
wsr a0, ps
l32i a0, sp, 0x4
wsr a0, epc1
l32i a0, sp, 0xc
l32i sp, sp, 0x10
rsync
rfe
Reference in a new issue Copy permalink