The interrupt controller API provides a set of functions for dealing with the Nested Vectored Interrupt Controller (NVIC). Functions are provided to enable and disable interrupts, set the priority of interrupts.
The NVIC provides global interrupt masking, prioritization, and handler dispatching. Devices within the Tiva family support up to 154 interrupt sources and eight priority levels. Individual interrupt sources can be masked, and the processor interrupt can be globally masked as well (without affecting the individual source masks).
The NVIC is tightly coupled with the Cortex-M microprocessor. When the processor responds to an interrupt, the NVIC supplies the address of the function to handle the interrupt directly to the processor. This action eliminates the need for a global interrupt handler that queries the interrupt controller to determine the cause of the interrupt and branch to the appropriate handler, reducing interrupt response time.
The interrupt prioritization in the NVIC allows higher priority interrupts to be handled before lower priority interrupts, as well as allowing preemption of lower priority interrupt handlers by higher priority interrupts. Again, this helps reduce interrupt response time (for example, a 1 ms system control interrupt is not held off by the execution of a lower priority 1 second housekeeping interrupt handler).
Sub-prioritization is also possible; instead of having N bits of preemptable prioritization, the NVIC can be configured (via software) for N - M bits of preemptable prioritization and M bits of sub-priority. In this scheme, two interrupts with the same preemptable prioritization but different sub-priorities do not cause a preemption; tail chaining is used instead to process the two interrupts back-to-back.
If two interrupts with the same priority (and sub-priority if so configured) are asserted at the same time, the one with the lower interrupt number is processed first. The NVIC keeps track of the nesting of interrupt handlers, allowing the processor to return from interrupt context only once all nested and pending interrupts have been handled.
Interrupt handlers can be configured in one of two ways; statically at compile time or dynamically at run time. Static configuration of interrupt handlers is accomplished by editing the interrupt handler table in the application’s startup code. When statically configured, the interrupts must be explicitly enabled in the NVIC via cm_enable_interrupts() before the processor can respond to the interrupt (in addition to any interrupt enabling required within the peripheral itself). Statically configuring the interrupt table provides the fastest interrupt response time because the stacking operation (a write to SRAM) can be performed in parallel with the interrupt handler table fetch (a read from Flash), as well as the prefetch of the interrupt handler itself (assuming it is also in Flash).
- void nvic_enable_irq(uint8_t irqn)
- NVIC Enable Interrupt. More...
- void nvic_disable_irq(uint8_t irqn)
- NVIC Disable Interrupt. More...
- uint8_t nvic_get_pending_irq(uint8_t irqn)
- NVIC Return Pending Interrupt. More...
- void nvic_set_pending_irq(uint8_t irqn)
- NVIC Set Pending Interrupt. More...
- void nvic_clear_pending_irq(uint8_t irqn)
- NVIC Clear Pending Interrupt. More...
- uint8_t nvic_get_irq_enabled(uint8_t irqn)
- NVIC Return Enabled Interrupt. More...
- void nvic_set_priority(uint8_t irqn, uint8_t priority)
- NVIC Set Interrupt Priority. More...