ARM11 exception handlers (not working yet, it fails to retrieve the data after the reboot)

Uncomment the appropriate line in firm.c to test.

exceptions/arm11/source/handlers.h

@@ -0,0 +1,14 @@
+/*
+*   handlers.h
+*       by TuxSH
+*
+*   This is part of Luma3DS, see LICENSE.txt for details
+*/
+
+#pragma once
+
+void __attribute__((noreturn)) mcuReboot(void);
+void FIQHandler(void);
+void undefinedInstructionHandler(void);
+void dataAbortHandler(void);
+void prefetchAbortHandler(void);

exceptions/arm11/source/handlers.s

@@ -0,0 +1,95 @@
+@
+@   handlers.s
+@       by TuxSH
+@
+@   This is part of Luma3DS, see LICENSE.txt for details
+@
+
+.macro GEN_HANDLER name
+    .global \name
+    .type   \name, %function
+    \name:
+        ldr sp, =#0xffff3000
+        stmfd sp!, {r0-r7}
+        mov r1, #\@         @ macro expansion counter
+        b _commonHandler
+
+    .size   \name, . - \name
+.endm
+
+.text
+.arm
+.align 4
+
+.global _commonHandler
+.type   _commonHandler, %function
+_commonHandler:
+    clrex
+    cpsid aif
+    mrs r2, spsr
+    mov r6, sp
+    mrs r3, cpsr
+    
+    ands r4, r2, #0xf       @ get the mode that triggered the exception
+    moveq r4, #0xf          @ usr => sys
+    bic r5, r3, #0xf
+    orr r5, r4
+    msr cpsr_c, r5          @ change processor mode
+    stmfd r6!, {r8-lr}
+    msr cpsr_c, r3          @ restore processor mode
+    mov sp, r6
+    vmrs r3, fpexc
+
+    cmp r1, #1
+    bne noFPUInit
+    tst r5, #0x20
+    bne noFPUInit
+    
+    ldr r4, [lr, #-4]
+    lsl r4, #4
+    sub r4, #0xc0000000
+    cmp r4, #0x30000000
+    bcs noFPUInit
+    tst r3, #0x40000000
+    bne noFPUInit
+    
+    sub lr, #4
+    srsfd sp!, #0x13
+    add sp, #28             @ restore context
+    ldmfd sp!, {r0-r7}
+    cps #0x13               @ FPU init
+    stmfd sp, {r0-r3, r11-lr}^
+    sub sp, #0x20
+    bl .                    @ will be replaced
+    ldmfd sp, {r0-r3, r11-lr}^
+    add sp, #0x20
+    rfefd sp!    
+    
+    noFPUInit:
+    stmfd sp!, {r2,lr}      @ it's a bit of a mess, but we will fix that later
+                            @ order of saved regs now: cpsr, pc + (2/4/8), r8-r14, r0-r7
+                            
+    ldr r4, =#0xdfff3ffc
+    ldr r5, =#0xffff0014
+    ldr r5, [r5]            @ 0xeafffffe
+    mov r6, #0
+    poisonLoop:
+        str r5, [r4, #4]!           @ poison exception vectors in order to hang the other threads
+        add r6, #1
+        cmp r6, #8
+        blt poisonLoop
+
+    mov r0, sp
+    mrc p15,0,r2,c0,c0,5    @ CPU ID register
+
+    b mainHandler
+
+GEN_HANDLER FIQHandler
+GEN_HANDLER undefinedInstructionHandler
+GEN_HANDLER prefetchAbortHandler
+GEN_HANDLER dataAbortHandler
+
+.global mcuReboot
+.type   mcuReboot, %function
+mcuReboot:
+    b .                     @ will be replaced

exceptions/arm11/source/mainHandler.c

@@ -0,0 +1,71 @@
+/*
+*   mainHandler.c
+*       by TuxSH
+*
+*   This is part of Luma3DS, see LICENSE.txt for details
+*/
+
+#include "types.h"
+#include "handlers.h"
+
+#define FINAL_BUFFER    0xE5000000 //0x25000000
+
+#define REG_DUMP_SIZE   (4*18)
+#define CODE_DUMP_SIZE  48
+#define STACK_DUMP_SIZE 0x2000
+#define OTHER_DATA_SIZE 0
+
+void __attribute__((noreturn)) mainHandler(u32 regs[18], u32 type, u32 cpuId, u32 fpexc)
+{
+    u32 dump[(40 + REG_DUMP_SIZE + CODE_DUMP_SIZE) / 4];
+    vu32 *final = (vu32 *)FINAL_BUFFER;
+
+    while(final[0] == 0xDEADC0DE && final[1] == 0xDEADCAFE && ((final[3] & 0xFFFF) == 9 || (final[3] & 0xFFFF) == 11));
+    
+    dump[0] = 0xDEADC0DE;                                                               //Magic
+    dump[1] = 0xDEADCAFE;                                                               //Magic
+    dump[2] = (1 << 16) | 0;                                                            //Dump format version number
+    dump[3] = ((cpuId & 0xf) << 16) | 11;                                               //Processor
+    dump[4] = type;                                                                     //Exception type
+    dump[6] = REG_DUMP_SIZE;                                                            //Register dump size (r0-r12, sp, lr, pc, cpsr, fpexc)
+    dump[7] = CODE_DUMP_SIZE;                                                           //Code dump size (10 ARM instructions, up to 20 Thumb instructions).
+    dump[8] = STACK_DUMP_SIZE;                                                          //Stack dump size
+    dump[9] = OTHER_DATA_SIZE;                                                          //Other data size
+    dump[5] = 40 + REG_DUMP_SIZE + CODE_DUMP_SIZE + STACK_DUMP_SIZE + OTHER_DATA_SIZE;  //Total size
+
+    //Dump registers
+    //Current order of saved regs: cpsr, pc, r8-r12, sp, lr, r0-r7
+    u32 *regdump = dump + 10;
+
+    u32 cpsr = regs[0];
+    u32 pc   = regs[1] - ((type < 3) ? (((cpsr & 0x20) != 0 && type == 1) ? 2 : 4) : 8);
+
+    regdump[15] = pc;
+    regdump[16] = cpsr;
+    regdump[17] = fpexc;
+
+    for(u32 i = 0; i < 7; i++)
+        regdump[8 + i] = regs[2 + i];
+
+    for(u32 i = 0; i < 8; i++)
+        regdump[i] = regs[9 + i]; 
+
+    //Dump code
+    u16 *codedump = (u16 *)(regdump + dump[6] / 4);
+    u16 *instr = (u16 *)pc - dump[7] / 2 + 1;
+    for(u32 i = 0; i < dump[7] / 2; i++)
+        codedump[i] = instr[i];
+
+    //Dump stack in place
+    vu32 *sp = (vu32 *)regdump[13];
+    vu32 *stackdump = (vu32 *)((vu8 *)FINAL_BUFFER + 40 + REG_DUMP_SIZE + CODE_DUMP_SIZE);
+    
+    for(u32 i = 0; i < dump[8] / 4; i++)
+        stackdump[i] = sp[i];
+
+    for(u32 i = 0; i < (40 + REG_DUMP_SIZE + CODE_DUMP_SIZE) / 4; i++)
+        final[i] = dump[i];
+        
+    while(final[0] != 0xDEADC0DE);
+    mcuReboot();
+}

exceptions/arm11/source/start.s

@@ -0,0 +1,11 @@
+.section .text.start
+.align 4
+.global _start
+_start:
+    add pc, r0, #(handlers - .) @ Dummy instruction to prevent compiler optimizations
+    
+handlers:
+    .word FIQHandler
+    .word undefinedInstructionHandler
+    .word prefetchAbortHandler
+    .word dataAbortHandler

exceptions/arm11/source/types.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <stdint.h>
+
+//Common data types
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+typedef volatile u8 vu8;
+typedef volatile u16 vu16;
+typedef volatile u32 vu32;
+typedef volatile u64 vu64;