Zynq GPIO 中断

/*
 * Copyright (c) 2009-2012 Xilinx, Inc.  All rights reserved.
 *
 * Xilinx, Inc.
 * XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" AS A
 * COURTESY TO YOU.  BY PROVIDING THIS DESIGN, CODE, OR INFORMATION AS
 * ONE POSSIBLE   IMPLEMENTATION OF THIS FEATURE, APPLICATION OR
 * STANDARD, XILINX IS MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION
 * IS FREE FROM ANY CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE
 * FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION.
 * XILINX EXPRESSLY DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO
 * THE ADEQUACY OF THE IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO
 * ANY WARRANTIES OR REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE
 * FROM CLAIMS OF INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 */

/*
 * helloworld.c: simple test application
 *
 * This application configures UART 16550 to baud rate 9600.
 * PS7 UART (Zynq) is not initialized by this application, since
 * bootrom/bsp configures it to baud rate 115200
 *
 * ------------------------------------------------
 * | UART TYPE   BAUD RATE                        |
 * ------------------------------------------------
 *   uartns550   9600
 *   uartlite    Configurable only in HW design
 *   ps7_uart    115200 (configured by bootrom/bsp)
 */

#include <stdio.h>
#include "platform.h"
#include "xgpiops.h"

#include "xparameters.h"
#include "xstatus.h"
#include "xscugic.h"
#include "xil_exception.h"

//void print(char *str);

#define GPIO_DIR    0x0000            /*All work in input mode*/
#define GPIO_DEVICE_ID        XPAR_XGPIOPS_0_DEVICE_ID        // 0
#define INTC_DEVICE_ID        XPAR_SCUGIC_SINGLE_DEVICE_ID    // 0
#define GPIO_INTERRUPT_ID    XPAR_XGPIOPS_0_INTR    // All gpio in four banks  to one output (IRQ ID#52) to interrupt controller


/************************** Function Prototypes ******************************/

static void IntrHandler(void *CallBackRef, int Bank, u32 Status);
static int SetupInterruptSystem(XScuGic *Intc, XGpioPs *Gpio, u16 GpioIntrId);
int ScuGicInterruptSetup(XScuGic *IntcInstancePtr, u16 DeviceId);

/************************** Variable Definitions *****************************/

/*
 * The following are declared globally so they are zeroed and so they are
 * easily accessible from a debugger.
 */
static XGpioPs Gpio; /* The Instance of the GPIO Driver */

XScuGic IntcInstance; /* The Instance of the Interrupt Controller Driver */

int main()
{
    init_platform();

    print("Hello World

");

    /*****************************************************************/
    //Set GPIO Interrupt
    /*****************************************************************/
    XGpioPs_Config *ConfigPtr;
    int Status = 0;
    XGpioPs Gpio;
    /*
     * Initialize the Gpio driver.
     */
    //printf("Initialize the Gpio driver.

");
    ConfigPtr = XGpioPs_LookupConfig(GPIO_DEVICE_ID);
    if (ConfigPtr == NULL) {
        return XST_FAILURE;
    }

    XGpioPs_CfgInitialize(&Gpio, ConfigPtr, ConfigPtr->BaseAddr);

    /*
     * Setup direction register of bank2, so that all the pins are configured as inputs.
     */
    //printf("Set gpio direction.

");
    XGpioPs_SetDirection(&Gpio, 2, GPIO_DIR);    // bank2 set to all input

#ifdef GPIOIOTEST
    //printf("GPIO bank2 value is 0x%x 

",i);
    // set gpio direction output,'1' for output
    XGpioPs_SetDirection(&Gpio, 2, 0xff);
    // set gpio output enable
    XGpioPs_SetOutputEnable(&Gpio, 2, 0xff);
    // write value
    XGpioPs_Write(&Gpio, 2, 0xff);
#endif

    /***********************************************************************/
    /* How to Set Interrupt                                                */
    /***********************************************************************/

    IntCtl_Init();

    // GPIO is Num.52 interrupt
    Status = SetupInterruptSystem(&IntcInstance, &Gpio, GPIO_INTERRUPT_ID);

    if (Status != XST_SUCCESS) {
        print("Set GPIO interrupt Failure 

");
        }
    else{
        print("Set GPIO interrupt Successful 

");
        }

    /***********************************************************************/

    while(1)
    {
        sleep(5);
        print("While(1) ing  

");
    }

    return 0;
}





/*****************************************************************************/
/**
*
* This function is used by the TestAppGen generated application to setup
* the interrupt controller.
*
* @param    IntcInstancePtr is the reference to the Interrupt Controller
*        instance.
* @param    DeviceId is device ID of the Interrupt Controller Device,
*        typically XPAR_<INTC_instance>_DEVICE_ID value from
*        xparameters.h.
*
* @return    XST_SUCCESS to indicate success, otherwise XST_FAILURE.
*
* @note        None.
*
******************************************************************************/
int IntCtl_Init(void)
{
    int Status;

    Status = ScuGicInterruptSetup(&IntcInstance, XPAR_PS7_SCUGIC_0_DEVICE_ID);
    if (Status == 0) {
        print("ScuGic Interrupt Setup PASSED
");
    }
    else {
        print("ScuGic Interrupt Setup FAILED
");
    }
}



/*****************************************************************************/
/**
*
* This function is used by the TestAppGen generated application to setup
* the interrupt controller.
*
* @param    IntcInstancePtr is the reference to the Interrupt Controller
*        instance.
* @param    DeviceId is device ID of the Interrupt Controller Device,
*        typically XPAR_<INTC_instance>_DEVICE_ID value from
*        xparameters.h.
*
* @return    XST_SUCCESS to indicate success, otherwise XST_FAILURE.
*
* @note        None.
*
******************************************************************************/
int ScuGicInterruptSetup(XScuGic *IntcInstancePtr, u16 DeviceId)
{

    int Status;
    static XScuGic_Config *GicConfig;

    /*
     * Initialize the interrupt controller driver so that it is ready to
     * use.
     */
    GicConfig = XScuGic_LookupConfig(DeviceId);
    if (NULL == GicConfig) {
        return XST_FAILURE;
    }

    Status = XScuGic_CfgInitialize(IntcInstancePtr, GicConfig, GicConfig->CpuBaseAddress);
        if (Status != XST_SUCCESS) {
            return XST_FAILURE;
        }

    /*
     * Initialize the exception table.
     */
    Xil_ExceptionInit();


    /*
     * Connect the interrupt controller interrupt handler to the hardware
     * interrupt handling logic in the processor.
     */
    Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_IRQ_INT,
                (Xil_ExceptionHandler)XScuGic_InterruptHandler,
                IntcInstancePtr);

    /*
     * Enable exceptions.
     */
    Xil_ExceptionEnable();


    return XST_SUCCESS;

}
/*****************************************************************************/
/**
*
* This function sets up the interrupt system for the example. It enables rasing
* edge interrupts for all the pins of bank 2 in the GPIO device.
*
* @param    GicInstancePtr is a pointer to the XScuGic driver Instance.
* @param    GpioInstancePtr contains a pointer to the instance of the GPIO
*        component which is going to be connected to the interrupt
*        controller.
* @param    GpioIntrId is the interrupt Id and is typically
*        XPAR_<GICPS>_<GPIOPS_instance>_VEC_ID value from
*        xparameters.h.
*
* @return    XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note        None.
*
****************************************************************************/
static int SetupInterruptSystem(XScuGic *GicInstancePtr, XGpioPs *Gpio, u16 GpioIntrId)
{
    int Status;

    XScuGic_Config *IntcConfig; /* Instance of the interrupt controller */

    /*
     * Connect the device driver handler that will be called when an
     * interrupt for the device occurs, the handler defined above performs
     * the specific interrupt processing for the device.
     *
     *
     */
    printf("Connect the device driver handler to interrupt processing 

");
    Status = XScuGic_Connect(GicInstancePtr, GpioIntrId,
                (Xil_ExceptionHandler)XGpioPs_IntrHandler,
                (void *)Gpio);
    if (Status != XST_SUCCESS) {
        return Status;
    }

    /*
     * @param GpioInstancePtr contains a pointer to the instance of the GPIO
     *          component which is going to be connected to the interrupt
     *          controller.
     * @param set Interrupt Type     0 level ,1 edge
     * @param Interrupt Polarity    1 rising or high level ,0 falling or low level
     * @param Interrupt Any Edge Sensitive    0 single edge, 1 both edge
     * Enable rising edge interrupts for all the pins in bank 2.
     */

    XGpioPs_SetIntrType(Gpio, 2, 0xffffffff, 0xFFFFFFFF, 0x00);    // rising edge only

    /*
     * Set the handler for gpio interrupts.
     */
    printf("Set the handler for gpio interrupts.

");
    XGpioPs_SetCallbackHandler(Gpio, (void *)Gpio, IntrHandler);


    /*
     * Enable the GPIO interrupts of Bank 2.
     */
    printf("Enable the GPIO interrupts of Bank 2.

");
    XGpioPs_IntrEnable(Gpio, 2, 0xffffffff);


    /*
     * Enable the interrupt for the GPIO device.
     */
    printf("Enable the interrupt for the GPIO device. 

");
    XScuGic_Enable(GicInstancePtr, GpioIntrId);


    /*
     * Enable interrupts in the Processor.
     */
    printf("Enable interrupts in the Processor 

");
    Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ);

    return XST_SUCCESS;
}


/****************************************************************************/
/**
* This function is the user layer callback function for the bank 0 interrupts of
* the GPIO device. It checks if all the switches have been pressed to stop the
* interrupt processing and exit from the example.
*
* @param    CallBackRef is a pointer to the upper layer callback reference.
* @param    Status is the Interrupt status of the GPIO bank.
*
* @return    None.
*
* @note        None.
*
******************************************************************************/
static void IntrHandler(void *CallBackRef, int Bank, u32 Status)
{
    // Is it necessary to close interrupt ?
    printf("Enter interrupt 

");

    /*
     * Do nothing if the intr is generated for a different bank.
     */
    if (Bank == 2) {

        switch (Status)
        {
        // Get interrupt source
            case 1:
                printf("The trigger is EMIO GPIO 0 of bank %d 

", Bank);
                break;

        }
    } else {
        return;
    }
}