Exception Types

●
Exceptions are numbered:
1 to 15 for system exceptions.
16 and above for external interrupt inputs.
●
Most of the exceptions have programmable
priority, and a few have fixed priority.
●
Support 1-240 interrupt.
 List of System Exceptions
Note: There is no exception number 0
 List of External Interrupts
Need to check the chip manufacturer's datasheets to determine the numbering of the interrupts.

●
When an enabled exception occurs but cannot be carried out
immediately,it will be pended.
(a higher-priority interrupt service routine is running or
if the interrupt mask register is set)
●
This means that a register in the NVIC (pending status) will
hold the exception request until the exception can be carried
out.
●
This is different from traditional ARM processors.
CPSR->SPSR
Switch to ARM mode and Disable IRQ
...
NVIC registers

Interrupt Set Pending Registers and

Interrupt Clear Pending Registers
 Definitions of Priority(1)

Bit 7,6,5,4 Bit 3,2,1,0 Value

0000 0000 0x00
0010 0000 0x20
0100 0000 0x40
0110 0000 0x60
1000 0000 0x80
1010 0000 0xA0
1100 0000 0xC0
1110 0000 0xE0
A Priority Level Register with 3-bit Implemented

Available Priority Levels with 3-Bit or 4-Bit Priority Width A Priority Level Register with 4-bit Implemented
 Definitions of Priority(2)
●
Supports three fixed highest-priority levels.(-3,-2,-1)
●
Up to 256 levels of programmable priority.
(a maximum of 128 levels of preemption)
●
More priority bits can also increase gate counts and
hence power consumption.
●
The minimum number of implemented priority register
widths is 3 bits. (eight levels)
●
This reduction of levels is implemented by cutting out
the LSB part of the priority cofiguration registers.
The reason for removing the LSB of the register instead of the MSB
is to make it easier to port software from one Cortex-M3 device to
another.
Definitions of Priority(3)
Bit 7 6 5 4 3 2 1 0
IRQ #0 0 0 0 0 0 1 0 1 0x05
IRQ #1 0 0 0 0 0 0 1 1 0x03

Bit 7 6 5 4 3 2 1 0
IRQ #0 0 0 0 0 0 0 0 1 0x01
IRQ #1 0 0 0 0 0 0 1 1 0x03

MSB LSB
Bit 7 6 5 4 3 2 1 0
IRQ #0 0 1 0 1 0 0 0 0 0x50
IRQ #1 0 0 1 1 0 0 0 0 0x30

Bit 7 6 5 4 3 2 1 0
IRQ #0 0 1 0 0 0 0 0 0 0x40
IRQ #1 0 0 1 0 0 0 0 0 0x10
Definitions of Priority(4)

Available Priority Levels for Devices with 3-bit, 5-bit, and 8-bit Priority Level Registers

Q: If the priority level configuration registers are 8 bits wide,

why there are only 128 preemption levels?

A: 8-bit register is further divided into two parts:

preempt priority and subpriority
 Definitions of Priority(5)

Definition of Preempt Priority Field and

Subpriority Field in a Priority Level Register in
Different Priority Group Settings

●
Using a configuration register in the NVIC called Priority Group.
●
The priority-level configuration registers for each exception
with programmable priority levels is divided into two halves.
●
The upper half (left bits) is the preempt priority.
●
The lower half (right bits) is the subpriority.
Definitions of Priority(6)

The Define of priority group 5

Bit Bit Bit

Preempt Subpriority
7,6 5 4,3,2,1,0
0 0x00
00 0 0000 0x00
1 0x20
0 0x40
01 0 0000 0x40
1 0x60
0 0x80
10 0 0000 0x80
1 0xA0
0 0xC0
11 0 0000 0xC0
1 0xE0
Definitions of Priority(7)
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0

Preempt Preempt priority Subpriority

priority[5:7] bit[4:2] (always 0) (always 0)

The Define of priority group 1

Bit
Bit 7,6,5 Preempt Subpriority
4,3,2,1,0
000 0 0000 0x00 0x00

001 0 0000 0x20 0x20

010 0 0000 0x40 0x40

011 0 0000 0x60 0x60

100 0 0000 0x80 0x80

101 0 0000 0xA0 0xA0

110 0 0000 0xC0 0xC0

111 0 0000 0xE0 0xE0

 Vector Tables

By default, the vector table starts at address zero,

and the vector address is arranged according to the exception number times 4.

●
Since the address 0x0 should be boot code, usually it will either be
Flash memory or ROM devices, and the value cannot be changed at run
time.
●
However, the vector table can be relocated to other memory locations
in the Code or RAM region where the RAM is so that we can change the
handlers during run time.
This is done by setting a register in the NVIC called the vector
table offset register (address 0xE000ED08).
 Vector Tables

●
The address offset should be aligned to the vector table size,
extended to the power of 2.
●
For example, if there are 32 IRQ inputs, the total number of exceptions will be
32 + 16 (system exceptions) = 48.
Extending it to the power of 2 makes it 64. (2,4,8,16,32,64)
Multiplying it by 4 makes it 256 (0x100). (64 * 4 = 256)
Therefore, the vector table offset can be programmed as 0x0, 0x100, 0x200, and
so on.
 Interrupt Inputs and Pending Behavior(1)

Interrupt Pending

●
When an interrupt input is asserted, it will be pended.
Even if the interrupt source de-asserts the interrupt,
the pended interrupt status will still cause the
interrupt handler to be executed when the priority is
allowed.
 Interrupt Inputs and Pending Behavior(2)

Interrupt Pending Cleared Before Processor Takes Action

●
If the pending status is cleared before the processor
starts responding to the pended interrupt,the interrupt
can be canceled.(for example, because pending status
register is cleared while PRIMASK/FAULTMASK is set to 1)
●
The pending status of the interrupt can be accessed in
the NVIC and is writable, so you can clear a pending
interrupt or use software to pend a new interrupt by
setting the pending register.
 Interrupt Inputs and Pending Behavior(3)

Interrupt Active Status Set as Processor Enters Handler

●
When the processor starts to execute an interrupt,the interrupt
becomes active and the pending bit will be cleared automatically.
●
When an interrupt is active, you cannot start processing the same
interrupt again until the interrupt service routine is terminated
with an interrupt return (also called an exception exit).
●
Then the active status is cleared and the interrupt can be
processed again if the pending status is 1.
 Interrupt Inputs and Pending Behavior(4)

Continuous Interrupt Request Pends Again After Interrupt Exit

●
If an interrupt source continues to hold the interrupt
request signal active, the interrupt will be pended
again at the end of the interrupt service routine.
●
This is just like the traditional ARM7TDMI.
 Interrupt Inputs and Pending Behavior(5)

Interrupt Pending Only Once, Even with Multiple Pulses Before the Handler

●
If an interrupt is pulsed several times before the
processor starts processing it, it will be treated as
one single interrupt request.
 Interrupt Inputs and Pending Behavior(6)

Interrupt Pending Occurs Again During the Handler

●
If an interrupt is de-asserted and then pulsed again
during the interrupt service routine, it will be pended
again.
 Fault Exceptions
●
A number of system exceptions are useful for
fault handling.

There are several categories of faults:

• Bus faults
• Memory management faults
• Usage faults
• Hard faults
 SVC and PendSV

SVC as a Gateway for OS Functions

●
SVC (System Service Call) and PendSV (Pended System Call)
are two exceptions targeted at software and operating
systems.
●
SVC is for generating system function calls.
●
Which can provide a more robust system by preventing the
user applications from directly accessing hardware.
●
The actual hardware-level programming is handled by
device drivers.
 SVC and PendSV(1)
●
PendSV (Pended System Call) works with SVC in the OS.
Although SVC (by SVC instruction) cannot be pended (an
application calling SVC will expect the required task to be
done immediately), PendSV can be pended and is useful for an
OS to pend an exception so that an action can be performed
after other important tasks are completed.
●
PendSV is generated by writing 1 to the NVIC PendSV pending
register.

A Simple Scenario Using SYSTICK to Switch Between Two Tasks

Problem with Context Switching at the IRQ
 SVC and PendSV(2)

Example Context Switching with PendSV

1. Task A calls SVC for task switching (for example, waiting for some work to complete).
2. The OS receives the request, prepares for context switching, and pends the PendSV exception.
3. When the CPU exits SVC, it enters PendSV immediately and does the context switch.
4. When PendSV finishes and returns to Thread level, it executes Task B.
5. An interrupt occurs and the interrupt handler is entered.
6. While running the interrupt handler routine, a SYSTICK exception (for OS tick) takes place.
7. The OS carries out the essential operation, then pends the PendSV exception and gets ready
for the context switch.
8. When the SYSTICK exception exits, it returns to the interrupt service routine.
9. When the interrupt service routine completes, the PendSV starts and does the actual context
switch operations.
10. When PendSV is complete, the program returns to Thread level;
this time it returns to Task A and continues the processing.
 SVC and SWI (ARM7)
●
If you have used traditional ARM processors
(such as the ARM7), you might know that they
have a software interrupt instruction (SWI).
●
The SVC has a similar function, and in fact
the binary encoding of SVC instructions is
the same as SWI in ARM7.
However, since the exception model has
changed, this instruction is renamed to make
sure that programmers will properly port
software code from ARM7 to the Cortex-M3.
The NVIC and Interrupt Control
 NVIC Overview
●
NVIC - Nested Vectored Interrupt Controller.
●
An integrated part of the Cortex-M3 processor.
●
Its control registers are accessible as memory-mapped
devices.
●
NVIC also contains control registers for the MPU, the
SYSTICK Timer, and debugging controls.
●
The NVIC supports 1 to 240 external interrupt inputs
(IRQs).
●
NVIC also has a Nonmaskable Interrupt (NMI) input.
●
NVIC can be accessed as memory location 0xE000E000.
 NVIC
The Basic Interrupt Configuration
●
Each external interrupt has several registers associated
with it:
•Enable and clear enable registers
•Set-pending and clear-pending registers
•Priority level
•Active status
●
A number of other registers can also affect the interrupt
processing:
•Exception-masking registers. (PRIMASK, FAULTMASK, and BASEPRI)
•Vector Table Offset register
•Software Trigger Interrupt register
•Priority Group
 NVIC
Interrupt Enable and Clear Enable
●
The SETENA/CLRENA registers are 32 bits wide;
each bit represents one interrupt input.
●
Since the first 16 exception types are system
exceptions, external interrupt #0 has a start exception
number of 16.

Interrupt Set Enable Registers and Interrupt Clear Enable Registers

(0xE000E100-0xE000E11C, 0xE000E180-0xE000E19C)
 NVIC
Interrupt Pending and Clear Pending
●
If an interrupt takes place but cannot be executed
immediately, it will be pended.
For instance, if another higher-priority interrupt
handler is running.

Interrupt Set Enable Registers and Interrupt Clear Enable Registers

(0xE000E100-0xE000E11C, 0xE000E180-0xE000E19C)
 NVIC - Priority Levels
●
Each register can be further divided into preempt
priority level and subpriority level based on priority
group settings.
(Maximum width of 8 bits and a minimum width of 3 bits.)

Interrupt Priority-Level Registers (0xE000E400-0xE000E4EF)

System Exceptions Priority-Level Register

(0xE000ED18–0xE000ED23; Listed as Byte Addresses)
 NVIC - Active Status
●
Each external interrupt has an active status bit.
●
When the processor starts the interrupt handler,
the bit is set to 1 and cleared when the interrupt
return is executed.

Interrupt Active Status Registers (0xE000E300-0xE000E31C)

 NVIC
Example Procedures in Setting Up
an Interrupt
1.When the system boots up, the priority group register might
need to be set up. By default the priority group 0 is used.
2.Copy the hard fault and NMI handlers to a new vector table
location if vector table relocation is required.
3.The Vector Table Offset register should also be set up to get
the vector table ready.
4.Set up the interrupt vector for the interrupt.
Since the vector table could have been relocated, you might
need to read the Vector Table Offset register, then calculate
the correct memory location for your interrupt handler.
5.Set up the priority level for the interrupt.
6.Enable the interrupt.
Make sure that you have enough stack memory if you allow a
large number of nested interrupt levels.
Interrupt Behavior
 Interrupt/Exception Sequences
●
When an exception takes place, a number of things happen:
• Stacking (pushing eight registers contents to stack)
• Vector fetch (reading the exception handler starting
address from the vector table)
• Update of the stack pointer(SP), link register(LR),
and program counter(PC)
 Stacking(1)
●
When an exception takes place, the registers PC, PSR,
R0 - R3, R12, and LR are pushed to the stack.
●
If the code that is running uses the PSP, the process stack
will be used.
If the code that is running uses the MSP, the main stack
will be used.
●
Afterward, the main stack will always be used during the
handler,so all nested interrupts will use the main stack.
●
The reason the registers R0–R3, R12, LR, PC, and PSR are
stacked is that these are caller saved registers,
according to C standards. (C/C++ standard Procedure Call
Standard for the ARM Architecture, AAPCS, Ref 5)
●
The general registers (R0–R3, R12) are located at the end
of the stack frame so that they can be easily accessed
using SP-related addressing.
 Stacking(2)
(assuming that the SP value is N before the exception)

Stacking Sequence

Stack Memory Content After Stacking and Stacking Order

 Vector Fetches
●
While the data bus is busy stacking the registers, the
instruction bus carries out another important task of
the interrupt sequence.
●
It fetches the exception vector from the vector table.
●
Since the stacking and vector fetch are performed on
separate bus interfaces, they can be carried out at the
same time.
 Register Updates
●
After the stacking and vector fetch are completed, the
exception vector will start to execute. On entry of the
exception handler, a number of registers will be updated:
•SP: The Stack Pointer (either the MSP or the PSP) will be updated
to the new location during stacking.
During execution of the interrupt service routine, the MSP will
be used if the stack is accessed.
•PSR: The IPSR (the lowest part of the PSR) will be updated to the
new exception number.
•PC: This will change to the vector handler as the vector fetch
completes and starts fetching instructions from the exception
vector.
•LR: The LR will be updated to a special value called EXC_RETURN.
This special value drives the interrupt return operation. The
last 4 bits of the LR have a special meaning.
●
A number of other NVIC registers will also be updated.
 Exception Exits
●
At the end of the exception handler, an exception exit
(known as an interrupt return in some processors) is
required to restore the system status so that the
interrupted program can resume normal execution.
●
When the interrupt return instruction is executed,
the following processes are carried out:
1. Unstacking:
The registers pushed to the stack will be restored.
2. NVIC register update:
The active bit of the exception will be cleared.
 Tail-Chaining Interrupts

Tail Chaining of Exceptions

●
When an exception takes place but the processor is
handling another exception of the same or higher priority,
the exception will be pended.
●
Skipping the unstacking and the stacking.
●
The timing gap between the two exception handlers is
greatly reduced.
 Late Arrivals

Late Arrival Exception Behavior

●
When an exception takes place and the processor has started
the stacking process, and if during this delay a new
exception arrives with higher preemption priority, the late
arrival exception will be processed first.
 More on the Exception Return Value(1)
●
When entering an exception handler, the LR is updated to
a special value called EXC_RETURN, with the upper 28
bits all set to 1.
●
When loaded into the PC at the end of the exception
handler execution, will cause the processor to perform
an exception return sequence.
●
The EXC_RETURN value has bit [31:4] all set to 1, and
bit[3:0] provides information required by the exception
return operation.
●
When the exception handler is entered, the LR value is
updated automatically, so there is no need to generate
these values manually.

Description of Bit Fields in EXC_RETURN Value

Allowed EXC_RETURN Values on Cortex-M3

 More on the Exception Return Value(2)

LR Set to EXC_RETURN at Exception (Main Stack Used in Thread Mode)

●
If the thread is using the MSP (main stack), the value
of LR will be set to 0xFFFFFFF9 when it enters an
exception, and 0xFFFFFFF1 when a nested exception is
entered.
 More on the Exception Return Value(3)

LR Set to EXC_RETURN at Exception (Process Stack Used in Thread Mode)

●
If the thread is using PSP (process stack), the value of
LR would be 0xFFFFFFFD when entering the first exception
and 0xFFFFFFF1 for entering a nested exception.