git.sur5r.net Git - freertos/blob

   1 /******************************************************************************
   2 *
   3 * (c) Copyright 2010-14 Xilinx, Inc. All rights reserved.
   4 *
   5 * This file contains confidential and proprietary information of Xilinx, Inc.
   6 * and is protected under U.S. and international copyright and other
   7 * intellectual property laws.
   8 *
   9 * DISCLAIMER
  10 * This disclaimer is not a license and does not grant any rights to the
  11 * materials distributed herewith. Except as otherwise provided in a valid
  12 * license issued to you by Xilinx, and to the maximum extent permitted by
  13 * applicable law: (1) THESE MATERIALS ARE MADE AVAILABLE "AS IS" AND WITH ALL
  14 * FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS, EXPRESS,
  15 * IMPLIED, OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF
  16 * MERCHANTABILITY, NON-INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE;
  17 * and (2) Xilinx shall not be liable (whether in contract or tort, including
  18 * negligence, or under any other theory of liability) for any loss or damage
  19 * of any kind or nature related to, arising under or in connection with these
  20 * materials, including for any direct, or any indirect, special, incidental,
  21 * or consequential loss or damage (including loss of data, profits, goodwill,
  22 * or any type of loss or damage suffered as a result of any action brought by
  23 * a third party) even if such damage or loss was reasonably foreseeable or
  24 * Xilinx had been advised of the possibility of the same.
  25 *
  26 * CRITICAL APPLICATIONS
  27 * Xilinx products are not designed or intended to be fail-safe, or for use in
  28 * any application requiring fail-safe performance, such as life-support or
  29 * safety devices or systems, Class III medical devices, nuclear facilities,
  30 * applications related to the deployment of airbags, or any other applications
  31 * that could lead to death, personal injury, or severe property or
  32 * environmental damage (individually and collectively, "Critical
  33 * Applications"). Customer assumes the sole risk and liability of any use of
  34 * Xilinx products in Critical Applications, subject only to applicable laws
  35 * and regulations governing limitations on product liability.
  36 *
  37 * THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS PART OF THIS FILE
  38 * AT ALL TIMES.
  39 *
  40 ******************************************************************************/
  41 /****************************************************************************/
  42 /**
  43 *
  44 * @file xdevcfg_intr.c
  45 *
  46 * Contains the implementation of interrupt related functions of the XDcfg
  47 * driver.
  48 *
  49 * <pre>
  50 * MODIFICATION HISTORY:
  51 *
  52 * Ver   Who Date     Changes
  53 * ----- --- -------- ---------------------------------------------
  54 * 1.00a hvm 02/07/11 First release
  55 * 2.01a nm  07/07/12 Updated the XDcfg_IntrClear function to directly
  56 *                    set the mask instead of oring it with the
  57 *                    value read from the interrupt status register
  58 * </pre>
  59 *
  60 ******************************************************************************/
  61
  62 /***************************** Include Files *********************************/
  63
  64 #include "xdevcfg.h"
  65
  66 /************************** Constant Definitions *****************************/
  67
  68 /**************************** Type Definitions *******************************/
  69
  70 /***************** Macros (Inline Functions) Definitions *********************/
  71
  72 /************************** Function Prototypes ******************************/
  73
  74 /************************** Variable Definitions *****************************/
  75
  76 /****************************************************************************/
  77 /**
  78 *
  79 * This function enables the specified interrupts in the device.
  80 *
  81 * @param        InstancePtr is a pointer to the XDcfg instance.
  82 * @param        Mask is the bit-mask of the interrupts to be enabled.
  83 *               Bit positions of 1 will be enabled. Bit positions of 0 will
  84 *               keep the previous setting. This mask is formed by OR'ing
  85 *               XDCFG_INT_* bits defined in xdevcfg_hw.h.
  86 *
  87 * @return       None.
  88 *
  89 * @note         None.
  90 *
  91 *****************************************************************************/
  92 void XDcfg_IntrEnable(XDcfg *InstancePtr, u32 Mask)
  93 {
  94         u32 RegValue;
  95
  96         /*
  97          * Assert the arguments.
  98          */
  99         Xil_AssertVoid(InstancePtr != NULL);
 100         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 101
 102         /*
 103          * Enable the specified interrupts in the Interrupt Mask Register.
 104          */
 105         RegValue = XDcfg_ReadReg(InstancePtr->Config.BaseAddr,
 106                                     XDCFG_INT_MASK_OFFSET);
 107         RegValue &= ~(Mask & XDCFG_IXR_ALL_MASK);
 108         XDcfg_WriteReg(InstancePtr->Config.BaseAddr,
 109                                 XDCFG_INT_MASK_OFFSET,
 110                                 RegValue);
 111 }
 112
 113
 114 /****************************************************************************/
 115 /**
 116 *
 117 * This function disables the specified interrupts in the device.
 118 *
 119 * @param        InstancePtr is a pointer to the XDcfg instance.
 120 * @param        Mask is the bit-mask of the interrupts to be disabled.
 121 *               Bit positions of 1 will be disabled. Bit positions of 0 will
 122 *               keep the previous setting. This mask is formed by OR'ing
 123 *               XDCFG_INT_* bits defined in xdevcfg_hw.h.
 124 *
 125 * @return       None.
 126 *
 127 * @note         None.
 128 *
 129 *****************************************************************************/
 130 void XDcfg_IntrDisable(XDcfg *InstancePtr, u32 Mask)
 131 {
 132         u32 RegValue;
 133
 134         /*
 135          * Assert the arguments.
 136          */
 137         Xil_AssertVoid(InstancePtr != NULL);
 138         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 139
 140         /*
 141          * Disable the specified interrupts in the Interrupt Mask Register.
 142          */
 143         RegValue = XDcfg_ReadReg(InstancePtr->Config.BaseAddr,
 144                                     XDCFG_INT_MASK_OFFSET);
 145         RegValue |= (Mask & XDCFG_IXR_ALL_MASK);
 146         XDcfg_WriteReg(InstancePtr->Config.BaseAddr,
 147                                 XDCFG_INT_MASK_OFFSET,
 148                                 RegValue);
 149 }
 150 /****************************************************************************/
 151 /**
 152 *
 153 * This function returns the enabled interrupts read from the Interrupt Mask
 154 * Register. Use the XDCFG_INT_* constants defined in xdevcfg_hw.h
 155 * to interpret the returned value.
 156 *
 157 * @param        InstancePtr is a pointer to the XDcfg instance.
 158 *
 159 * @return       A 32-bit value representing the contents of the IMR.
 160 *
 161 * @note         None.
 162 *
 163 *****************************************************************************/
 164 u32 XDcfg_IntrGetEnabled(XDcfg *InstancePtr)
 165 {
 166         /*
 167          * Assert the arguments.
 168          */
 169         Xil_AssertNonvoid(InstancePtr != NULL);
 170         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 171
 172         /*
 173          * Return the value read from the Interrupt Mask Register.
 174          */
 175         return (~ XDcfg_ReadReg(InstancePtr->Config.BaseAddr,
 176                                 XDCFG_INT_MASK_OFFSET));
 177 }
 178
 179 /****************************************************************************/
 180 /**
 181 *
 182 * This function returns the interrupt status read from Interrupt Status
 183 * Register. Use the XDCFG_INT_* constants defined in xdevcfg_hw.h
 184 * to interpret the returned value.
 185 *
 186 * @param        InstancePtr is a pointer to the XDcfg instance.
 187 *
 188 * @return       A 32-bit value representing the contents of the Interrupt
 189 *               Status register.
 190 *
 191 * @note         None.
 192 *
 193 *****************************************************************************/
 194 u32 XDcfg_IntrGetStatus(XDcfg *InstancePtr)
 195 {
 196         /*
 197          * Assert the arguments.
 198          */
 199         Xil_AssertNonvoid(InstancePtr != NULL);
 200         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 201
 202         /*
 203          * Return the value read from the Interrupt Status register.
 204          */
 205         return XDcfg_ReadReg(InstancePtr->Config.BaseAddr,
 206                                 XDCFG_INT_STS_OFFSET);
 207 }
 208
 209 /****************************************************************************/
 210 /**
 211 *
 212 * This function clears the specified interrupts in the Interrupt Status
 213 * Register.
 214 *
 215 * @param        InstancePtr is a pointer to the XDcfg instance.
 216 * @param        Mask is the bit-mask of the interrupts to be cleared.
 217 *               Bit positions of 1 will be cleared. Bit positions of 0 will not
 218 *               change the previous interrupt status. This mask is formed by
 219 *               OR'ing XDCFG_INT_* bits which are defined in xdevcfg_hw.h.
 220 *
 221 * @return       None.
 222 *
 223 * @note         None.
 224 *
 225 *****************************************************************************/
 226 void XDcfg_IntrClear(XDcfg *InstancePtr, u32 Mask)
 227 {
 228         /*
 229          * Assert the arguments.
 230          */
 231         Xil_AssertVoid(InstancePtr != NULL);
 232         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 233
 234         XDcfg_WriteReg(InstancePtr->Config.BaseAddr,
 235                                 XDCFG_INT_STS_OFFSET,
 236                                 Mask);
 237
 238 }
 239
 240 /*****************************************************************************/
 241 /**
 242 * The interrupt handler for the Device Config Interface.
 243 *
 244 * Events are signaled to upper layer for proper handling.
 245 *
 246 *
 247 * @param        InstancePtr is a pointer to the XDcfg instance.
 248 *
 249 * @return       None.
 250 *
 251 * @note         None.
 252 *
 253 ****************************************************************************/
 254 void XDcfg_InterruptHandler(XDcfg *InstancePtr)
 255 {
 256         u32 IntrStatusReg;
 257
 258         /*
 259          * Assert validates the input arguments.
 260          */
 261         Xil_AssertVoid(InstancePtr != NULL);
 262         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 263
 264         /*
 265          * Read the Interrupt status register.
 266          */
 267         IntrStatusReg = XDcfg_ReadReg(InstancePtr->Config.BaseAddr,
 268                                          XDCFG_INT_STS_OFFSET);
 269
 270         /*
 271          * Write the status back to clear the interrupts so that no
 272          * subsequent interrupts are missed while processing this interrupt.
 273          * This also does the DMA acknowledgment automatically.
 274          */
 275         XDcfg_WriteReg(InstancePtr->Config.BaseAddr,
 276                                 XDCFG_INT_STS_OFFSET, IntrStatusReg);
 277
 278         /*
 279          * Signal application that there are events to handle.
 280          */
 281         InstancePtr->StatusHandler(InstancePtr->CallBackRef,
 282                                            IntrStatusReg);
 283
 284 }
 285
 286 /****************************************************************************/
 287 /**
 288 *
 289 * This function sets the handler that will be called when an event (interrupt)
 290 * occurs that needs application's attention.
 291 *
 292 * @param        InstancePtr is a pointer to the XDcfg instance
 293 * @param        CallBackFunc is the address of the callback function.
 294 * @param        CallBackRef is a user data item that will be passed to the
 295 *               callback function when it is invoked.
 296 *
 297 * @return       None.
 298 *
 299 * @note         None.
 300 *
 301 *
 302 *****************************************************************************/
 303 void XDcfg_SetHandler(XDcfg *InstancePtr, void *CallBackFunc,
 304                                 void *CallBackRef)
 305 {
 306         /*
 307          * Asserts validate the input arguments
 308          * CallBackRef not checked, no way to know what is valid
 309          */
 310         Xil_AssertVoid(InstancePtr != NULL);
 311         Xil_AssertVoid(CallBackFunc != NULL);
 312         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 313
 314         InstancePtr->StatusHandler = (XDcfg_IntrHandler) CallBackFunc;
 315         InstancePtr->CallBackRef = CallBackRef;
 316 }