source: Documentation/ReferenceDesigns/InterruptRef_xps_8_2/src/interruptTester.c

/*
 *  interruptTester.c
 *  
 *  This source describes the proper way to handle multiple interrupts with a PowerPC.
 *  The code assumes a properly configured base system containing an opb_timer,
 *  opb_gpio push buttons, a RS232 opb_uartlite, and finally and opb_intc interrupt
 *  controller.
 *
 *  The code will periodically start a timer. By default, this timer will expire every
 *  6 seconds. Before the timer expires, the user can depress push buttons and see confirmation
 *  of those events on a terminal connected to the board via the RS232 serial port.
 *  Upon the expiration of the timer, the "timer_a_int_handler" ISR is called by the
 *  interrupt controller driver.
 *
 *  In this ISR, the program will block for three seconds. This effectively simulates a
 *  long operation. During this time, users will not be able to trigger interrupts with
 *  push buttons.
 *
 *  When the ISR returns, push buttons become operational again. Pressing the left button
 *  will disable the periodic timer at the interrupt controller level (i.e. the timer
 *  itself is still generating interrupt signals). Pressing the right button will re-enable
 *  the interrupts, returning the system to its normal state.
 *
 *  Created by Chris Hunter on 1/24/07.
 *
 */


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


// Driver instances
static XGpio myGpio;
static XTmrCtr myTimer;
static XIntc myIntc;


// Push Button ISR: function is called upon the depression of ANY of the 4
// buttons. Which button is determined within the ISR.
void pb_int_handler(void *baseaddr_p) {
    Xuint32 dsr;
    XStatus stat;
    char lock;
    
    //DSR contains the information of which button was depressed, so we can switch
    //on its value.
    dsr = XGpio_mGetDataReg(XPAR_PUSH_BUTTONS_4BIT_BASEADDR, 2);
    switch(dsr) {
        
        case 0x01:
            xil_printf("Middle\r\n");
            break;
            
        case 0x02:
            xil_printf("Right: Enabling Timer interrupts\r\n");
            XIntc_Enable(&myIntc, XPAR_OPB_INTC_0_OPB_TIMER_0_INTERRUPT_INTR);
            
            break;
            
        case 0x08:
            xil_printf("Up\r\n");
            break;
            
        case 0x04:
            xil_printf("Left: Disabling Timer interrupts\r\n");
            XIntc_Disable(&myIntc, XPAR_OPB_INTC_0_OPB_TIMER_0_INTERRUPT_INTR);
            break;
            
        default : {
        }
                    
    }
    //Clear the interrupt both in the Gpio instance as well as the interrupt controller
    XGpio_InterruptClear(&myGpio, 0x3);
    XIntc_Acknowledge(&myIntc,XPAR_OPB_INTC_0_PUSH_BUTTONS_4BIT_IP2INTC_IRPT_INTR);
}

// Timer ISR: function is called upon the expiration of either of two timers in a 
// single instance of the opb_timer peripheral. For the purposes of this demonstration,
// we are only using timer 0.
void timer_a_int_handler(void *CallBackRef, Xuint8 TmrCtrNumber) {

        if (TmrCtrNumber==0) {
            xil_printf("In timer interrupt handler... waiting for 3 seconds\r\n");
            usleep(3000000);
            xil_printf("Leaving timer interrupt handler ...\r\n");
        }
    //Clear the interrupt
    XIntc_Acknowledge(&myIntc,XPAR_OPB_INTC_0_OPB_TIMER_0_INTERRUPT_INTR);
    }
    
// Main: this is the function that is executed at the start of the program. 
int main(){
    
    /*There are three phases of set-up to get interrupts to work:
        1) Device initialization and configuration
        2) Interrupt controller initialization and configuration
        3) PowerPC exception initialization
    */

    
    //********************** 1. Device initialization and configuration *************************
    xil_printf("Setting up peripherals...\r\n");
    
    //Initialize and configuring the timer
    XTmrCtr_Initialize(&myTimer, XPAR_OPB_TIMER_0_DEVICE_ID);
    XTmrCtr_SelfTest(&myTimer, 0);
    XTmrCtr_SetOptions(&myTimer,(Xuint8)0,XTC_INT_MODE_OPTION | XTC_DOWN_COUNT_OPTION | XTC_AUTO_RELOAD_OPTION);
    XTmrCtr_SetHandler(&myTimer,(XTmrCtr_Handler)timer_a_int_handler,NULL); 
    
    //Initialize and configure the push buttons
    XGpio_Initialize(&myGpio, XPAR_PUSH_BUTTONS_4BIT_DEVICE_ID);
    XGpio_mSetDataDirection(XPAR_PUSH_BUTTONS_4BIT_BASEADDR, 1, 0x3);
    XGpio_InterruptEnable(&myGpio, XGPIO_IR_CH1_MASK);
    XGpio_InterruptGlobalEnable(&myGpio);
    //*******************************************************************************************

    
    
    //*************** 2. Interrupt controller initialization and configuration ******************
    xil_printf("Setting up interrupt controller...\r\n");
    XIntc_Initialize(&myIntc, XPAR_OPB_INTC_0_DEVICE_ID);
    
    //Attach the ISRs to the interrupt controller driver.
    //NOTE: The timer is weird. You have to attach "XTmrCtr_InterruptHandler," which is nested
    //deep within the timer driver. It in turn calls the callback you provide during the
    //configuration above.
    XIntc_Connect(&myIntc, XPAR_OPB_INTC_0_PUSH_BUTTONS_4BIT_IP2INTC_IRPT_INTR,
                           (XInterruptHandler)pb_int_handler,
                           &myGpio);
    XIntc_Connect(&myIntc, XPAR_OPB_INTC_0_OPB_TIMER_0_INTERRUPT_INTR,
                           (XInterruptHandler)XTmrCtr_InterruptHandler,
                           &myTimer);                                   
                                    
    XIntc_Start(&myIntc, XIN_REAL_MODE);
    XIntc_Enable(&myIntc, XPAR_OPB_INTC_0_PUSH_BUTTONS_4BIT_IP2INTC_IRPT_INTR);
    XIntc_Enable(&myIntc, XPAR_OPB_INTC_0_OPB_TIMER_0_INTERRUPT_INTR);
    //*******************************************************************************************



    //************************ 3. PowerPC exception initialization ******************************
    xil_printf("Setting up exceptions...\r\n");     
    XExc_Init();
    XExc_RegisterHandler(XEXC_ID_NON_CRITICAL_INT,
                        (XExceptionHandler)XIntc_InterruptHandler,
                         &myIntc);
    XExc_mEnableExceptions(XEXC_NON_CRITICAL);
    //*******************************************************************************************

    
    //Set the timer to expire every 6 seconds
    XTmrCtr_SetResetValue(&myTimer, (Xuint8)0, 6 * 50000000);
    XTmrCtr_Start(&myTimer, (Xuint8)0);
    
    
    xil_printf("Entering loop...\r\n");
    while(1){
    }
    
}