2c8f92039d
Added initial support Xilinx Embedded Software. Signed-off-by: Jagannadha Sutradharudu Teki <jaganna@xilinx.com>
303 lines
11 KiB
C
Executable file
303 lines
11 KiB
C
Executable file
/******************************************************************************
|
|
*
|
|
* Copyright (C) 2011 - 2014 Xilinx, Inc. All rights reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* Use of the Software is limited solely to applications:
|
|
* (a) running on a Xilinx device, or
|
|
* (b) that interact with a Xilinx device through a bus or interconnect.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
|
|
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
* Except as contained in this notice, the name of the Xilinx shall not be used
|
|
* in advertising or otherwise to promote the sale, use or other dealings in
|
|
* this Software without prior written authorization from Xilinx.
|
|
*
|
|
******************************************************************************/
|
|
/*****************************************************************************/
|
|
/**
|
|
*
|
|
* @file xiomodule_intr.c
|
|
*
|
|
* This file contains the interrupt processing for the XIOModule component
|
|
* which is the driver for the Xilinx IO Module interrupt. The interrupt
|
|
* processing is partitioned seperately such that users are not required to
|
|
* use the provided interrupt processing. This file requires other files of
|
|
* the driver to be linked in also.
|
|
*
|
|
* Two different interrupt handlers are provided for this driver such that the
|
|
* user must select the appropriate handler for the application. The first
|
|
* interrupt handler, XIOModule_VoidInterruptHandler, is provided for
|
|
* systems which use only a single interrupt controller or for systems that
|
|
* cannot otherwise provide an argument to the XIOModule interrupt handler
|
|
* (e.g., the RTOS interrupt vector handler may not provide such a facility).
|
|
* The constant XPAR_IOMODULE_SINGLE_DEVICE_ID must be defined for this
|
|
* handler to be included in the driver. The second interrupt handler,
|
|
* XIOModule_InterruptHandler, uses an input argument which is an instance
|
|
* pointer to an interrupt controller driver such that multiple interrupt
|
|
* controllers can be supported. This handler requires the calling function
|
|
* to pass it the appropriate argument, so another level of indirection may be
|
|
* required.
|
|
*
|
|
* Note that both of these handlers are now only provided for backward
|
|
* compatibility. The handler defined in xiomodule_l.c is the recommended
|
|
* handler.
|
|
*
|
|
* The interrupt processing may be used by connecting one of the interrupt
|
|
* handlers to the interrupt system. These handlers do not save and restore
|
|
* the processor context but only handle the processing of the Interrupt
|
|
* Controller. The two handlers are provided as working examples. The user is
|
|
* encouraged to supply their own interrupt handler when performance tuning is
|
|
* deemed necessary.
|
|
*
|
|
* <pre>
|
|
* MODIFICATION HISTORY:
|
|
*
|
|
* Ver Who Date Changes
|
|
* ----- ---- -------- ---------------------------------------------------------
|
|
* 1.00a sa 07/15/11 First release
|
|
* 1.02a sa 07/25/12 Added UART interrupt related functions
|
|
* 1.03a sa 10/16/12 Moved UART interrupt related functions to separate file
|
|
* </pre>
|
|
*
|
|
* @internal
|
|
*
|
|
* This driver assumes that the context of the processor has been saved prior to
|
|
* the calling of the IO Module interrupt handler and then restored
|
|
* after the handler returns. This requires either the running RTOS to save the
|
|
* state of the machine or that a wrapper be used as the destination of the
|
|
* interrupt vector to save the state of the processor and restore the state
|
|
* after the interrupt handler returns.
|
|
*
|
|
******************************************************************************/
|
|
|
|
/***************************** Include Files *********************************/
|
|
|
|
|
|
#include "xparameters.h"
|
|
#include "xiomodule.h"
|
|
#include "xil_types.h"
|
|
#include "xil_assert.h"
|
|
|
|
/************************** Constant Definitions *****************************/
|
|
|
|
/*
|
|
* Array of masks associated with the bit position, improves performance
|
|
* in the ISR, this table is shared between all instances of the driver
|
|
*/
|
|
u32 XIOModule_TimerBitPosMask[XTC_DEVICE_TIMER_COUNT] = {
|
|
1 << XIN_IOMODULE_PIT_1_INTERRUPT_INTR,
|
|
1 << XIN_IOMODULE_PIT_2_INTERRUPT_INTR,
|
|
1 << XIN_IOMODULE_PIT_3_INTERRUPT_INTR,
|
|
1 << XIN_IOMODULE_PIT_4_INTERRUPT_INTR
|
|
};
|
|
|
|
|
|
/**************************** Type Definitions *******************************/
|
|
|
|
|
|
/***************** Macros (Inline Functions) Definitions *********************/
|
|
|
|
|
|
/************************** Function Prototypes ******************************/
|
|
|
|
|
|
/************************** Variable Definitions *****************************/
|
|
|
|
|
|
/*****************************************************************************/
|
|
/**
|
|
*
|
|
* Interrupt handler for the driver used when there can be no argument passed
|
|
* to the handler. This function is provided mostly for backward compatibility.
|
|
* The user should use XIOModule_DeviceInterruptHandler(), defined in
|
|
* xiomodule_l.c, if possible.
|
|
*
|
|
* The user must connect this function to the interrupt system such that it is
|
|
* called whenever the devices which are connected to it cause an interrupt.
|
|
*
|
|
* @return None.
|
|
*
|
|
* @note
|
|
*
|
|
* The constant XPAR_IOMODULE_SINGLE_DEVICE_ID must be defined for this handler
|
|
* to be included in the driver compilation.
|
|
*
|
|
******************************************************************************/
|
|
#ifdef XPAR_IOMODULE_SINGLE_DEVICE_ID
|
|
void XIOModule_VoidInterruptHandler()
|
|
{
|
|
/* Use the single instance to call the main interrupt handler */
|
|
XIOModule_DeviceInterruptHandler(
|
|
(void *) XPAR_IOMODULE_SINGLE_DEVICE_ID);
|
|
}
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
/**
|
|
*
|
|
* The interrupt handler for the driver. This function is provided mostly for
|
|
* backward compatibility. The user should use
|
|
* XIOModule_DeviceInterruptHandler(), defined in xiomodule_l.c when
|
|
* possible and pass the device ID of the interrupt controller device as its
|
|
* argument.
|
|
*
|
|
* The user must connect this function to the interrupt system such that it is
|
|
* called whenever the devices which are connected to it cause an interrupt.
|
|
*
|
|
* @param InstancePtr is a pointer to the XIOModule instance to be
|
|
* worked on.
|
|
*
|
|
* @return None.
|
|
*
|
|
* @note None.
|
|
*
|
|
******************************************************************************/
|
|
void XIOModule_InterruptHandler(XIOModule * InstancePtr)
|
|
{
|
|
/* Assert that the pointer to the instance is valid
|
|
*/
|
|
Xil_AssertVoid(InstancePtr != NULL);
|
|
|
|
/* Use the instance's device ID to call the main interrupt handler.
|
|
* (the casts are to avoid a compiler warning)
|
|
*/
|
|
XIOModule_DeviceInterruptHandler((void *)
|
|
((u32) (InstancePtr->CfgPtr->DeviceId)));
|
|
}
|
|
|
|
|
|
/*****************************************************************************/
|
|
/**
|
|
*
|
|
* Sets the timer callback function, which the driver calls when the specified
|
|
* timer times out.
|
|
*
|
|
* @param InstancePtr is a pointer to the XIOModule instance.
|
|
* @param CallBackRef is the upper layer callback reference passed back
|
|
* when the callback function is invoked.
|
|
* @param FuncPtr is the pointer to the callback function.
|
|
*
|
|
* @return None.
|
|
*
|
|
* @note
|
|
*
|
|
* The handler is called within interrupt context so the function that is
|
|
* called should either be short or pass the more extensive processing off
|
|
* to another task to allow the interrupt to return and normal processing
|
|
* to continue.
|
|
*
|
|
* This function is provided for compatibility, and only allows setting a
|
|
* single handler for all Programmable Interval Timers.
|
|
*
|
|
******************************************************************************/
|
|
void XIOModule_SetHandler(XIOModule * InstancePtr,
|
|
XIOModule_Timer_Handler FuncPtr,
|
|
void *CallBackRef)
|
|
{
|
|
u8 Index;
|
|
|
|
Xil_AssertVoid(InstancePtr != NULL);
|
|
Xil_AssertVoid(FuncPtr != NULL);
|
|
Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
|
|
|
|
InstancePtr->Handler = FuncPtr;
|
|
InstancePtr->CallBackRef = CallBackRef;
|
|
|
|
for (Index = XIN_IOMODULE_PIT_1_INTERRUPT_INTR;
|
|
Index <= XIN_IOMODULE_PIT_4_INTERRUPT_INTR; Index++) {
|
|
InstancePtr->CfgPtr->HandlerTable[Index].Handler =
|
|
XIOModule_Timer_InterruptHandler;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/**
|
|
*
|
|
* Interrupt Service Routine (ISR) for the driver. This function only performs
|
|
* processing for the Programmable Interval Timere and does not save and restore
|
|
* the interrupt context.
|
|
*
|
|
* @param InstancePtr contains a pointer to the IO Module instance for
|
|
* the interrupt.
|
|
*
|
|
* @return None.
|
|
*
|
|
* @note None.
|
|
*
|
|
******************************************************************************/
|
|
void XIOModule_Timer_InterruptHandler(void *InstancePtr)
|
|
{
|
|
XIOModule *IOModulePtr = NULL;
|
|
u8 Index;
|
|
u32 IntPendingReg, ModeMask;
|
|
|
|
/*
|
|
* Verify that each of the inputs are valid.
|
|
*/
|
|
Xil_AssertVoid(InstancePtr != NULL);
|
|
|
|
/*
|
|
* Convert the non-typed pointer to an IO Module instance pointer
|
|
* such that there is access to the IO Module
|
|
*/
|
|
IOModulePtr = (XIOModule *) InstancePtr;
|
|
|
|
/*
|
|
* Read the pending interrupts to be able to check if interrupt occurred
|
|
*/
|
|
IntPendingReg = XIOModule_ReadReg(IOModulePtr->BaseAddress,
|
|
XIN_IPR_OFFSET);
|
|
|
|
ModeMask = ~IOModulePtr->CurrentIMR;
|
|
|
|
/*
|
|
* Loop thru each timer in the device and call the callback function
|
|
* for each timer which has caused an interrupt, but only if not fast
|
|
*/
|
|
for (Index = 0; Index < XTC_DEVICE_TIMER_COUNT; Index++) {
|
|
/*
|
|
* Check if timer is enabled
|
|
*/
|
|
if (IOModulePtr->CfgPtr->PitUsed[Index]) {
|
|
|
|
/*
|
|
* Check if timer expired and interrupt occured,
|
|
* but only if it is not a fast interrupt
|
|
*/
|
|
if (IntPendingReg & ModeMask & XIOModule_TimerBitPosMask[Index]) {
|
|
|
|
/*
|
|
* Increment statistics for the number of interrupts and call
|
|
* the callback to handle any application specific processing
|
|
*/
|
|
IOModulePtr->Timer_Stats[Index].Interrupts++;
|
|
|
|
IOModulePtr->Handler(IOModulePtr->CallBackRef, Index);
|
|
|
|
/*
|
|
* Acknowledge the interrupt in the interrupt controller
|
|
* acknowledge register to mark it as handled
|
|
*/
|
|
XIOModule_WriteReg(IOModulePtr->BaseAddress,
|
|
XIN_IAR_OFFSET,
|
|
XIOModule_TimerBitPosMask[Index]);
|
|
}
|
|
}
|
|
}
|
|
}
|