//***************************************************************
//******************* INTERRUPT FUNCTIONS ***********************
//***************************************************************
void Interrupt_Init(void)
{
//PUSH BUTTON INTERRUPT
/* Code */
XIntc_Initialize(&Intc, INTC_DEVICE_ID);
XGpio_Initialize(&Gpio, GPIO_DEVICE_ID);
XIntc_Connect(&Intc, INTR_ID, GpioIsr, &Gpio);
/* Buttons are all inputs */
XGpio_SetDataDirection(&Gpio, BUTTON_CHANNEL, GPIO_ALL_BUTTONS);
XGpio_InterruptEnable(&Gpio, BUTTON_INTERRUPT);
XGpio_InterruptGlobalEnable(&Gpio);
/* Enable the Interrupt vector at the interrupt controller */
XIntc_Enable(&Intc, INTR_ID);
XExc_Init();
/*****************************************************************
* Initialize the PPC405 exception table and register the interrupt
* controller handler with the exception table
******************************************************************/
XExc_RegisterHandler(XEXC_ID_NON_CRITICAL_INT, (XExceptionHandler)XIntc_InterruptHandler, &Intc);
/* Now Register Timer Interrupt */
XExc_RegisterHandler(XEXC_ID_PIT_INT, (XExceptionHandler)TimerIsr, (void *)0);
/* Enable non-critical exceptions in the PowerPC */
XExc_mEnableExceptions(XEXC_NON_CRITICAL);
/*******************************************************************
* Start the interrput controller such that interrupts are recognized
* and handled by the processor.
********************************************************************/
XIntc_Start(&Intc, XIN_REAL_MODE);
//TIMER INTERRUPT
/* Set Timer Interval (1 Sec) */
XTime_PITSetInterval(0x0F000000);
/* Automatically Restarts Timer */
XTime_PITEnableAutoReload();
/* Clear Timer Reg */
XTime_TSRClearStatusBits(XREG_TSR_CLEAR_ALL);
/* Clear Queued Timer Interrupts */
XTime_PITClearInterrupt();
/* Enable Interrupt */
XTime_PITEnableInterrupt();
}
XStatus GpioSetupIntrSystem(XIntc* IntcInstancePtr,
XGpio* InstancePtr,
Xuint16 DeviceId,
Xuint16 IntrId,
Xuint16 IntrMask)
{
XStatus Result;
GlobalIntrMask = IntrMask;
#ifndef TESTAPP_GEN
/*
* Initialize the interrupt controller driver so that it's ready to use.
* specify the device ID that was generated in xparameters.h
*/
Result = XIntc_Initialize(IntcInstancePtr, INTC_DEVICE_ID);
if (Result != XST_SUCCESS)
{
return Result;
}
#endif
/* Hook up simple interrupt service routine for TestApp*/
Result = XIntc_Connect(IntcInstancePtr, IntrId,
(XInterruptHandler)GpioDriverHandler,
InstancePtr);
/*
* Enable the GPIO channel interrupts so that push button can be detected
* and enable interrupts for the GPIO device
*/
XGpio_InterruptEnable(InstancePtr, IntrMask);
XGpio_InterruptGlobalEnable(InstancePtr);
/* Enable the interrupt vector at the interrupt controller */
XIntc_Enable(IntcInstancePtr, IntrId);
#ifndef TESTAPP_GEN
/*
* Initialize the PPC405 exception table and register the interrupt
* controller handler with the exception table
*/
XExc_Init();
XExc_RegisterHandler(XEXC_ID_NON_CRITICAL_INT,
(XExceptionHandler)XIntc_InterruptHandler,IntcInstancePtr);
/* Enable non-critical exceptions in the PowerPC */
XExc_mEnableExceptions(XEXC_NON_CRITICAL);
/*
* Start the interrupt controller such that interrupts are recognized
* and handled by the processor.
*/
Result = XIntc_Start(IntcInstancePtr, XIN_REAL_MODE);
#endif
if (Result != XST_SUCCESS)
{
return Result;
}
return XST_SUCCESS;
}
void InitInterrupts() {
// Initialize wireless uart
XUartLite_Initialize(&(wireless.uart), XPAR_WIRELESS_UART_DEVICE_ID);
XUartLite_ResetFifos(&(wireless.uart));
Wireless_Init(&wireless);
// Initialize gameboard uart
XUartLite_Initialize(&gameboard_uart, XPAR_GAMEBOARD_UART_DEVICE_ID);
XUartLite_ResetFifos(&gameboard_uart);
// Initialize the interrupt controller
XIntc_Initialize(&InterruptController, XPAR_INTC_0_DEVICE_ID);
// Connect the wireless uart to the interrupt controller
XIntc_Connect(&InterruptController, XPAR_XPS_INTC_0_WIRELESS_UART_INTERRUPT_INTR,
(XInterruptHandler)XUartLite_InterruptHandler,
(void *)&(wireless.uart));
// Connect the gameboard uart to the interrupt controller
XIntc_Connect(&InterruptController, XPAR_XPS_INTC_0_GAMEBOARD_UART_INTERRUPT_INTR,
(XInterruptHandler)XUartLite_InterruptHandler,
(void *)&gameboard_uart);
//XIntc_Connect(&InterruptController, XPAR_INTC_0_GPIO_0_VEC_ID,
// (Xil_ExceptionHandler)GpioHandler, &Gpio);
XIntc_Start(&InterruptController, XIN_REAL_MODE);
// Enable interrupts for serial controllers
XIntc_Enable(&InterruptController, XPAR_XPS_INTC_0_WIRELESS_UART_INTERRUPT_INTR);
XIntc_Enable(&InterruptController, XPAR_XPS_INTC_0_GAMEBOARD_UART_INTERRUPT_INTR);
// Enable interrupts for the GPIO
//XIntc_Enable(&InterruptController, XPAR_INTC_0_GPIO_0_VEC_ID);
Xil_ExceptionInit();
Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
(Xil_ExceptionHandler)XIntc_InterruptHandler,
&InterruptController);
Xil_ExceptionEnable();
// Set up send/receive handlers for wireless uart
XUartLite_SetSendHandler(&(wireless.uart), WirelessSendHandler, &(wireless.uart));
XUartLite_SetRecvHandler(&(wireless.uart), WirelessRecvHandler, &(wireless.uart));
//XUartLite_SetRecvHandler(&(wireless.uart), WirelessRecvHandlerNonBlocking, &(wireless.uart));
Wireless_Debug("Wireless should be set up now");
// Set up send/receive handlers for gameboard uart
XUartLite_SetSendHandler(&gameboard_uart, GameboardSendHandler, &gameboard_uart);
XUartLite_SetRecvHandler(&gameboard_uart, GameboardRecvHandler, &gameboard_uart);
XUartLite_EnableInterrupt(&(wireless.uart));
XUartLite_EnableInterrupt(&gameboard_uart);
// Enable interrupts for GPIO
//XGpio_InterruptEnable(&Gpio, XGPIO_IR_CH2_MASK);
//XGpio_InterruptGlobalEnable(&Gpio);
// Set up PIT
XExceptionHandler pithandler = &my_pitHandler;
XExc_RegisterHandler(XEXC_ID_PIT_INT, pithandler,
0);
XTime_PITEnableAutoReload();
// PIT should be set to 1ms
XTime_PITSetInterval(300000);
XExc_mEnableExceptions(XEXC_ALL);
XTime_PITEnableInterrupt();
XTime_PITClearInterrupt();
}
/**
*
* This function setups the interrupt system so interrupts can occur for the
* TEMAC. This function is application-specific since the actual system may or
* may not have an interrupt controller. The TEMAC could be directly connected
* to a processor without an interrupt controller. The user should modify this
* function to fit the application.
*
* @param IntcInstancePtr is a pointer to the instance of the Intc component.
* @param TemacInstancePtr is a pointer to the instance of the Temac
* component.
* @param TemacIntrId is the Interrupt ID and is typically
* XPAR_<INTC_instance>_<TEMAC_instance>_IP2INTC_IRPT_INTR
* value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note None.
*
******************************************************************************/
static int TemacSetupIntrSystem(XIntc *IntcInstancePtr,
XLlTemac *TemacInstancePtr,
XLlDma *DmaInstancePtr,
u16 TemacIntrId,
u16 DmaRxIntrId,
u16 DmaTxIntrId)
{
XLlDma_BdRing * TxRingPtr = &XLlDma_GetTxRing(DmaInstancePtr);
XLlDma_BdRing * RxRingPtr = &XLlDma_GetRxRing(DmaInstancePtr);
int Status;
#ifndef TESTAPP_GEN
/*
* Initialize the interrupt controller and connect the ISR
*/
Status = XIntc_Initialize(IntcInstancePtr, INTC_DEVICE_ID);
if (Status != XST_SUCCESS) {
TemacUtilErrorTrap("Unable to intialize the interrupt controller");
return XST_FAILURE;
}
#endif
Status = XIntc_Connect(IntcInstancePtr, TemacIntrId,
(XInterruptHandler)
TemacErrorHandler,
TemacInstancePtr);
Status |= XIntc_Connect(IntcInstancePtr, DmaTxIntrId,
(XInterruptHandler) TxIntrHandler,
TxRingPtr);
Status |= XIntc_Connect(IntcInstancePtr, DmaRxIntrId,
(XInterruptHandler) RxIntrHandler,
RxRingPtr);
if (Status != XST_SUCCESS) {
TemacUtilErrorTrap("Unable to connect ISR to interrupt controller");
return XST_FAILURE;
}
#ifndef TESTAPP_GEN
/*
* Start the interrupt controller
*/
Status = XIntc_Start(IntcInstancePtr, XIN_REAL_MODE);
if (Status != XST_SUCCESS) {
TemacUtilErrorTrap("Error starting intc");
return XST_FAILURE;
}
#endif
/*
* Enable interrupts from the hardware
*/
XIntc_Enable(IntcInstancePtr, TemacIntrId);
XIntc_Enable(IntcInstancePtr, DmaTxIntrId);
XIntc_Enable(IntcInstancePtr, DmaRxIntrId);
#ifndef TESTAPP_GEN
#ifdef __PPC__
/*
* Initialize the PPC exception table
*/
XExc_Init();
/*
* Register the interrupt controller with the exception table
*/
XExc_RegisterHandler(XEXC_ID_NON_CRITICAL_INT,
(XExceptionHandler)
XIntc_InterruptHandler,
IntcInstancePtr);
/*
* Enable non-critical exceptions
*/
XExc_mEnableExceptions(XEXC_NON_CRITICAL);
#else
/*
* Connect the interrupt controller interrupt handler to the hardware
* interrupt handling logic in the microblaze processor.
*/
microblaze_register_handler((XInterruptHandler)
XIntc_InterruptHandler, IntcInstancePtr);
/*
* Enable interrupts in the Microblaze
*/
microblaze_enable_interrupts();
#endif
#endif
return XST_SUCCESS;
}
/**
*
* This function setups the interrupt system such that interrupts can occur
* for the UART. This function is application specific since the actual
* system may or may not have an interrupt controller. The UART could be
* directly connected to a processor without an interrupt controller. The
* user should modify this function to fit the application.
*
* @param IntcInstancePtr is a pointer to the instance of the INTC component.
* @param UartInstancePtr is a pointer to the instance of the UART component.
* @param UartIntrId is the interrupt Id and is typically
* XPAR_<INTC_instance>_<UARTNS550_instance>_IP2INTC_IRPT_INTR
* value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE
*
*
* @note None
*
*******************************************************************************/
static XStatus UartNs550SetupIntrSystem(XIntc *IntcInstancePtr,
XUartNs550 *UartInstancePtr,
Xuint16 UartIntrId)
{
XStatus Status;
#ifndef TESTAPP_GEN
/*
* Initialize the interrupt controller driver so that it is ready to use.
*/
Status = XIntc_Initialize(IntcInstancePtr, INTC_DEVICE_ID);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
#endif
/*
* Connect a device driver handler that will be called when an interrupt
* for the device occurs, the device driver handler performs the specific
* interrupt processing for the device.
*/
Status = XIntc_Connect(IntcInstancePtr, UartIntrId,
(XInterruptHandler)XUartNs550_InterruptHandler,
(void *)UartInstancePtr);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
#ifndef TESTAPP_GEN
/*
* Start the interrupt controller such that interrupts are enabled for
* all devices that cause interrupts, specific real mode so that
* the UART can cause interrupts thru the interrupt controller.
*/
Status = XIntc_Start(IntcInstancePtr, XIN_REAL_MODE);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
#endif
/*
* Enable the interrupt for the UartNs550.
*/
XIntc_Enable(IntcInstancePtr, UartIntrId);
#ifndef TESTAPP_GEN
/*
* Initialize the PPC exception table.
*/
XExc_Init();
/*
* Register the interrupt controller handler with the exception table.
*/
XExc_RegisterHandler(XEXC_ID_NON_CRITICAL_INT,
(XExceptionHandler)XIntc_InterruptHandler,
IntcInstancePtr);
/*
* Enable non-critical exceptions.
*/
XExc_mEnableExceptions(XEXC_NON_CRITICAL);
#endif /* TESTAPP_GEN */
return XST_SUCCESS;
}
