E.2.1 Report Fault Status Registers

The most basic step of a fault handler is to report the Fault Status register values. These include the following:

E.2.2 Report Stacked PC and Other Stacked Registers

In a fault handler, the step for getting the stacked PC is similar to the SVC example in this book.

This process can be carried out in assembly language as follows:

TST LR, #0x4   ; Test EXC_RETURN number in LR bit 2

ITTEE EQ    ; if zero (equal) then

MRSEQ R0, MSP   ; Main Stack was used, put MSP in R0

LDREQ R0,[R0,#24] ; Get stacked PC from stack.

MRSNE R0, PSP   ; else, Process Stack was used, put PSP in R0

LDRNE R0,[R0,#24] ; Get stacked PC from stack.

Most Cortex-M3 developers use C for their projects. However, in C, it is difficult to locate and directly access the stack frame (stacked register values) as you cannot obtain the stack point value in C. To report the stack frame contents in your fault handler in C, you need to use a short assembly code to obtain stack point value, and then pass it to the fault reporting function in C as a parameter (see Figure E.2). The mechanism is identical to the SVC example in Chapter 12. The following example uses embedded assembler, which can work with RealView Development Suite (RVDS) and Keil RealView Microcontroller Development Kit (MDK-ARM).

The first part of the program is an assembly wrapper. The vector table should have the starting address of this wrapper code in the hard fault entry. This wrapper code copies the correct stack pointer value into R0, and passes it to the C function as a parameter.

// hard fault handler wrapper in assembly

// it extract the location of stack frame and pass it

// to handler in C as pointer.

__asm void hard_fault_handler_asm(void)

{

TST    LR, #4

ITE    EQ  

MRSEQ   R0, MSP  

MRSNE   R0, PSP  

B     __cpp(hard_fault_handler_c )

}

The second part of the handler is in C. Here, we demonstrate how the stacked register contents and the Fault Status registers can be accessed.

// hard fault handler in C,

// with stack frame location as input parameter

void hard_fault_handler_c(unsigned int * hardfault_args)

{

unsigned int stacked_r0;

unsigned int stacked_r1;

unsigned int stacked_r2;

unsigned int stacked_r3;

unsigned int stacked_r12;

unsigned int stacked_lr;

unsigned int stacked_pc;

unsigned int stacked_psr;

stacked_r0 = ((unsigned long) hardfault_args[0]);

stacked_r1 = ((unsigned long) hardfault_args[1]);

stacked_r2 = ((unsigned long) hardfault_args[2]);

stacked_r3 = ((unsigned long) hardfault_args[3]);

stacked_r12 = ((unsigned long) hardfault_args[4]);

stacked_lr = ((unsigned long) hardfault_args[5]);

stacked_pc = ((unsigned long) hardfault_args[6]);

stacked_psr = ((unsigned long) hardfault_args[7]);

printf ("[Hard fault handler]
");

printf ("R0 = %x
", stacked_r0);

printf ("R1 = %x
", stacked_r1);

printf ("R2 = %x
", stacked_r2);

printf ("R3 = %x
", stacked_r3);

printf ("R12 = %x
", stacked_r12);

printf ("LR = %x
", stacked_lr);

printf ("PC = %x
", stacked_pc);

printf ("PSR = %x
", stacked_psr);

printf ("BFAR = %x
", (*((volatile unsigned long *)(0xE000ED38))));

printf ("CFSR = %x
", (*((volatile unsigned long *)(0xE000ED28))));

printf ("HFSR = %x
", (*((volatile unsigned long *)(0xE000ED2C))));

printf ("DFSR = %x
", (*((volatile unsigned long *)(0xE000ED30))));

printf ("AFSR = %x
", (*((volatile unsigned long *)(0xE000ED3C))));

exit(0); // terminate

return;

}

Please note that this handler will not work correctly if the stack pointer is pointing to an invalid memory region (e.g., because of stack overflow). This affects all C code as stack is required in C functions in most cases.

To help with debugging, we should also create a disassembled code list file so that we can locate the problem easily.

E.2.3 Read Fault Address Register

The Fault Address register can be erased after the MMARVALID or BFARVALID is cleared. To correctly access the Fault Address register, the following procedure should be used:

The reason for this procedure instead of reading valid bits first is to prevent a fault handler being preempted by another higher-priority fault handler after the valid bit is read, which could lead to the following erroneous fault-reporting sequence:

Therefore, it is important to read the BFARVALID/MMARVALID after reading the Fault Address register to ensure that the address register content is valid.

E.2.4 Clear Fault Status Bits

After the fault reporting is done, the fault status bit in the FSR should be cleared so that next time the fault handler is executed, the previous faults will not confuse the fault handler. In addition, if the fault address valid bit is not clear, the Fault Address register will not get an update for the next fault.

E.2.5 Others

It is often necessary to save the contents of LR in the beginning of a fault handler. However, if the fault is caused by a stack error, pushing the LR to stack might just make things worst. As we know, R0–R3 and R12 should already been saved, so that we could copy LR to one of these registers before doing any function calls.