Resolving Hanging GPIO Interrupts in Xilinx MicroBlaze Designs

Comprehensive strategies using timer interrupts and optimized interrupt vector configurations

Key Takeaways

• Implementing a timer-based monitoring system ensures system resilience against ISR hangs.
• Proper configuration of interrupt vector tables allows efficient handling of multiple interrupt sources.
• Prioritizing interrupts and establishing robust recovery mechanisms are critical for system stability.

Understanding the Issue

GPIO Interrupt Service Routine (ISR) Hanging

In embedded systems utilizing the Xilinx MicroBlaze processor, the GPIO (General Purpose Input/Output) interrupt service routine plays a crucial role in handling external events. However, scenarios may arise where the GPIO ISR becomes unresponsive or "hangs," leading to system instability. This hanging can occur due to various reasons, such as infinite loops within the ISR, improper acknowledgment of interrupts, or hardware malfunctions.

Implications of a Hanging ISR

When a GPIO ISR hangs, it monopolizes the processor's attention, preventing the main program from executing and other critical ISRs from being serviced. This results in system sluggishness, unresponsiveness to further interrupts, and potential failure in handling real-time events. Addressing this issue is paramount to maintaining the robustness and reliability of the embedded system.

Utilizing Timer Interrupts to Mitigate ISR Hang

Role of Timer Interrupts

Timer interrupts serve as watchdog mechanisms that periodically monitor the status of various system components, including other ISRs like the GPIO ISR. By integrating timer interrupts into the system, it's possible to detect and recover from situations where an ISR becomes unresponsive.

Implementation Steps

1. Configure a Hardware Timer

Begin by setting up a hardware timer within your MicroBlaze system. This timer should be configured to generate interrupts at regular, predefined intervals. Utilizing the XTmrCtr driver from the Xilinx libraries is recommended for this purpose.

2. Initialize the Timer

Initialize the timer and configure its control status register to enable the timer and its interrupts. This involves setting the timer period and ensuring that the timer is active.

3. Register the Timer ISR

Use functions such as XIntc_RegisterHandler to associate the timer's interrupt with a dedicated interrupt handler. This handler will contain the logic to monitor and manage the GPIO ISR's state.

4. Implement Monitoring Logic

Within the timer ISR, implement mechanisms to check the status of the GPIO ISR. This can include verifying if the GPIO ISR has completed its execution or if it's stuck in an infinite loop. If a hang is detected, the timer ISR can initiate corrective actions such as resetting the GPIO peripheral, clearing interrupt flags, or even triggering a system reset if necessary.

5. Prioritize Timer Interrupts

Ensure that the timer interrupt has a higher priority compared to the GPIO interrupt. This prioritization allows the timer ISR to preempt the GPIO ISR if it's hanging, thus maintaining system responsiveness.

Best Practices

• Keep the timer ISR concise to prevent it from becoming a bottleneck.
• Use flags or state variables to communicate between the timer ISR and the main application loop.
• Implement logging within the timer ISR for debugging and monitoring purposes.

Example Implementation

#include "xparameters.h"
#include "xintc.h"
#include "xtmrctr.h"

// Timer interrupt handler
void timer_int_handler(void *baseaddr_p) {
    // Check GPIO ISR status
    if (gpio_is_hanging()) {
        reset_gpio_interrupt();
        log_error("GPIO ISR has been reset due to a hang.");
    }
}

// Main function
int main() {
    XIntc interrupt_controller;
    XTmrCtr timer;
    
    // Initialize interrupt controller
    XIntc_Initialize(&interrupt_controller, XPAR_XPS_INTC_0_DEVICE_ID);
    XIntc_Start(&interrupt_controller, XIN_REAL_MODE);
    
    // Register timer ISR
    XIntc_RegisterHandler(&interrupt_controller, XPAR_XPS_INTC_0_TMRCTR_0_INTERRUPT_INTR,
                          (XInterruptHandler)timer_int_handler, (void *)&timer);
    
    // Enable timer interrupt
    XIntc_Enable(&interrupt_controller, XPAR_XPS_INTC_0_TMRCTR_0_INTERRUPT_INTR);
    
    // Initialize and start timer
    XTmrCtr_Initialize(&timer, XPAR_TMRCTR_0_DEVICE_ID);
    XTmrCtr_SetOptions(&timer, 0, XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION);
    XTmrCtr_SetResetValue(&timer, 0, TIMER_PERIOD);
    XTmrCtr_Start(&timer, 0);
    
    // Enable global interrupts
    microblaze_enable_interrupts();
    
    while (1) {
        // Main application loop
    }
    
    return 0;
}

Configuring Multiple Interrupt Vectors

Understanding Interrupt Vector Tables

An interrupt vector table maps various interrupt sources to their corresponding handler functions. By default, MicroBlaze configurations may have a limited number of interrupt vectors, which can be insufficient for designs requiring multiple interrupt sources. Adjusting the MB_INTERRUPT_VECTOR_TABLE_ENTRIES parameter allows for an expanded and more flexible interrupt handling mechanism.

Steps to Modify MB_INTERRUPT_VECTOR_TABLE_ENTRIES

1. Access MicroBlaze Configuration in Vivado

Open your MicroBlaze project in Vivado and navigate to the MicroBlaze IP configuration settings. This can typically be done through the IP Integrator or by directly editing the IP block.

2. Adjust the Interrupt Vector Table Entries

Locate the Interrupt & Reset section within the MicroBlaze configuration wizard. Here, you will find the MB_INTERRUPT_VECTOR_TABLE_ENTRIES parameter. Modify this value to match the number of distinct interrupt sources your design requires. For instance, if you need to handle both GPIO and timer interrupts, ensure that the table has at least two entries.

3. Update Software Configuration

After adjusting the hardware configuration, update your software to accommodate the new interrupt vectors. This involves:

• Modifying the xparameters.h file to reflect the new number of interrupt entries.
• Registering each ISR with the correct vector index using functions like XIntc_Connect or XScuGic_Connect.
• Ensuring that each interrupt source has a unique handler function mapped appropriately.

4. Rebuild and Deploy the Design

After making the necessary changes, regenerate the bitstream and reprogram the FPGA to apply the updated interrupt configurations. Ensure that all ISRs are correctly mapped and that the system behaves as expected under various interrupt conditions.

Sample Configuration

Best Practices for Multiple Interrupt Handling

• Ensure that each interrupt source has a dedicated and uniquely assigned ISR.
• Maintain clear and organized code structures to manage multiple ISRs effectively.
• Test each ISR individually and in conjunction to verify correct behavior under various interrupt scenarios.

Prioritizing Interrupts and System Recovery

Interrupt Prioritization

Properly prioritizing interrupts ensures that critical tasks are serviced promptly, while less critical ones do not hinder system performance. In the context of handling a hanging GPIO ISR, setting a higher priority for the timer interrupt allows it to preempt the GPIO ISR, enabling timely recovery actions.

Recovery Mechanisms

Establishing robust recovery mechanisms is essential for maintaining system stability. When an ISR hang is detected, the system should be capable of:

• Resetting the affected peripheral to clear the hang.
• Clearing pending interrupt flags to prevent repeated hangs.
• Logging the error for diagnostic purposes.
• Initiating a system reset if the hang cannot be resolved through peripheral resets.

Implementing System Recovery

Within the timer ISR, implement logic that assesses the state of the GPIO ISR. If a hang is detected, execute the necessary steps to recover, such as resetting the GPIO module or reevaluating the ISR's execution path. Additionally, consider incorporating watchdog timers or software flags to enhance the reliability of the monitoring system.

Comprehensive Example: Integrating Timer and GPIO ISRs

The following example demonstrates how to integrate a timer ISR to monitor and recover from a hanging GPIO ISR in a Xilinx MicroBlaze design. It also showcases how to configure multiple interrupt vectors to handle both timer and GPIO interrupts effectively.

#include "xparameters.h"
#include "xintc.h"
#include "xtmrctr.h"
#include "xgpio.h"

// Define device IDs
#define INTC_DEVICE_ID      XPAR_INTC_0_DEVICE_ID
#define TMRCTR_DEVICE_ID    XPAR_TMRCTR_0_DEVICE_ID
#define GPIO_DEVICE_ID      XPAR_GPIO_0_DEVICE_ID

// Define interrupt vectors
#define TMRCTR_INTERRUPT_ID XPAR_INTC_0_TMRCTR_0_VEC_ID
#define GPIO_INTERRUPT_ID   XPAR_INTC_0_GPIO_0_VEC_ID

// Global instances
XIntc InterruptController;
XTmrCtr Timer;
XGpio Gpio;

// Flags
volatile int gpio_is_running = 0;

// Timer ISR Handler
void TimerISR(void *InstancePtr) {
    if (!gpio_is_running) {
        // GPIO ISR is not running, no action needed
        return;
    }
    
    // GPIO ISR is hanging, attempt recovery
    XGpio_DiscreteClear(&Gpio, 1, 0xFFFFFFFF); // Clear GPIO interrupt
    gpio_is_running = 0;
    // Optionally log the recovery action
}

// GPIO ISR Handler
void GpioISR(void *InstancePtr) {
    gpio_is_running = 1;
    // Handle GPIO interrupt
    // ...
    // Clear interrupt
    XGpio_InterruptClear(&Gpio, 1);
    gpio_is_running = 0;
}

int main() {
    int status;
    
    // Initialize Interrupt Controller
    status = XIntc_Initialize(&InterruptController, INTC_DEVICE_ID);
    if (status != XST_SUCCESS) return XST_FAILURE;
    
    // Initialize Timer
    status = XTmrCtr_Initialize(&Timer, TMRCTR_DEVICE_ID);
    if (status != XST_SUCCESS) return XST_FAILURE;
    
    // Initialize GPIO
    status = XGpio_Initialize(&Gpio, GPIO_DEVICE_ID);
    if (status != XST_SUCCESS) return XST_FAILURE;
    XGpio_SetDataDirection(&Gpio, 1, 0xFFFFFFFF); // Set as input
    
    // Connect ISRs to Interrupt Controller
    XIntc_Connect(&InterruptController, TMRCTR_INTERRUPT_ID,
                 (XInterruptHandler)TimerISR, &Timer);
    XIntc_Connect(&InterruptController, GPIO_INTERRUPT_ID,
                 (XInterruptHandler)GpioISR, &Gpio);
    
    // Start Interrupt Controller in real mode
    XIntc_Start(&InterruptController, XIN_REAL_MODE);
    
    // Enable interrupts in MicroBlaze
    XIntc_Enable(&InterruptController, TMRCTR_INTERRUPT_ID);
    XIntc_Enable(&InterruptController, GPIO_INTERRUPT_ID);
    microblaze_enable_interrupts();
    
    // Configure Timer
    XTmrCtr_SetOptions(&Timer, 0, XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION);
    XTmrCtr_SetResetValue(&Timer, 0, TIMER_PERIOD); // Define TIMER_PERIOD as needed
    XTmrCtr_Start(&Timer, 0);
    
    while (1) {
        // Main application loop
    }
    
    return 0;
}

Conclusion

Addressing a hanging GPIO ISR in Xilinx MicroBlaze designs requires a multifaceted approach that combines vigilant monitoring with robust interrupt handling configurations. By integrating timer interrupts as watchdogs, developers can ensure that the system remains responsive even in the face of ISR anomalies. Additionally, properly configuring the MB_INTERRUPT_VECTOR_TABLE_ENTRIES allows for efficient management of multiple interrupt sources, enhancing the overall reliability and scalability of the embedded system. Adhering to best practices in interrupt prioritization and recovery mechanisms further solidifies system stability, making these strategies indispensable for complex MicroBlaze-based applications.

References

adaptivesupport.amd.com

Handling MicroBlaze GPIO and Timer Interrupts

docs.amd.com

Vivado MicroBlaze Interrupt Reference

stackoverflow.com

Branch to Interrupt Handler on MicroBlaze CPU

so-logic.net

Embedded Interrupts and Booting Guide