Interrupt Services

Concepts

ISRs are execution threads that run in response to a hardware or software interrupt. They are used to preempt the execution of the task or fiber running at the time of the interrupt, allowing the response to occur with very low overhead. When an ISR completes its normal task and fiber execution resumes.

Any number of ISRs can be utilized in a Zephyr project, subject to any hardware constraints imposed by the underlying hardware. Each ISR has the following properties:

• The IRQ signal that triggers the ISR.
• The priority level associated with the IRQ.
• The address of the function that is invoked to handle the interrupt.
• The argument value that is passed to that function.

An IDT is used to associate a given interrupt source with a given ISR. Only a single ISR can be associated with a specific IRQ at any given time. An ISR can be incorporated into the IDT when the Zephyr project is built (a “static ISR”) or bound to the IDT when the system is up and running (a “dynamic ISR”).

Multiple ISRs can utilize the same function to process interrupts, allowing a single function to service a device that generates multiple types of interrupts or to service multiple devices (usually of the same type). The argument value passed to an ISR’s function can be used to allow the function to determine which interrupt has been signaled.

The Zephyr kernel provides a default ISR for all unused IDT entries. This ISR generates a fatal system error if an unexpected interrupt is signaled.

The kernel supports interrupt nesting. This allows an ISR to be preempted in mid-execution if a higher priority interrupt is signaled. The lower priority ISR resumes execution once the higher priority ISR has completed its processing.

The kernel allows a task or fiber to temporarily lock out the execution of ISRs, either individually or collectively, should the need arise. The collective lock can be applied repeatedly; that is, the lock can be applied when it is already in effect. The collective lock must be unlocked an equal number of times before interrupts are again processed by the kernel.

Purpose

Use an ISR to perform interrupt processing that requires a very rapid response, and which can be done quickly and without blocking.

Installing an ISR

Use one of the following procedures to install an ISR:

• Installing a Static ISR
• Installing a Dynamic ISR

#define MY_DEV_IRQ  24       /* device uses IRQ 24 */
#define MY_DEV_PRIO  2       /* device uses interrupt priority 2 */
/* argument passed to my_isr(), in this case a pointer to the device */
#define MY_ISR_ARG  DEVICE_GET(my_device)
#define MY_IRQ_FLAGS 0       /* IRQ flags. Unused on non-x86 */

void my_isr(void *arg)
{
   ... /* ISR code */
}

void my_isr_installer(void)
{
   ...
   IRQ_CONNECT(MY_DEV_IRQ, MY_DEV_PRIO, my_isr, MY_ISR_ARG, MY_IRQ_FLAGS);
   irq_enable(MY_DEV_IRQ);            /* enable IRQ */
   ...
}

#define MY_DEV_IRQ 24        /* device uses IRQ 24 */
#define MY_DEV_PRIO 2        /* device uses interrupt priority 2 */
#define MY_ISR_ARG 17        /* argument passed to my_isr() */
/* IRQ flags. Interrupt is triggered by low level signal */
#define MY_IRQ_FLAGS (IOAPIC_LEVEL | IOAPIC_LOW)

void my_isr(void *arg)
{
   ... /* ISR code */
}

void my_isr_installer(void)
{
    ...
    irq_connect_dynamic(MY_DEV_IRQ, MY_DEV_PRIO, my_isr, MY_ISR_ARG,
                        MY_IRQ_FLAGS);
    ...
    irq_enable(MY_DEV_IRQ);
    ...
}

Working with Interrupts

Use the following:

• Offloading ISR Work
• IDT Security

APIs

These are the interrupt-related Application Program Interfaces.

irq_connect_dynamic()

Registers a dynamic ISR with the IDT and interrupt controller.

irq_enable()

Enables interrupts from a specific IRQ.

irq_disable()

Disables interrupts from a specific IRQ.

irq_lock()

Locks out interrupts from all sources.

irq_unlock()

Removes lock on interrupts from all sources.

Macros

These are the macros used to install a static ISR.

IRQ_CONNECT()

Registers a static ISR with the IDT.