git.sur5r.net Git - freertos/blob

   1 /******************************************************************************
   2 *
   3 * Copyright (C) 2010 - 2014 Xilinx, Inc.  All rights reserved.
   4 *
   5 * Permission is hereby granted, free of charge, to any person obtaining a copy
   6 * of this software and associated documentation files (the "Software"), to deal
   7 * in the Software without restriction, including without limitation the rights
   8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 * copies of the Software, and to permit persons to whom the Software is
  10 * furnished to do so, subject to the following conditions:
  11 *
  12 * The above copyright notice and this permission notice shall be included in
  13 * all copies or substantial portions of the Software.
  14 *
  15 * Use of the Software is limited solely to applications:
  16 * (a) running on a Xilinx device, or
  17 * (b) that interact with a Xilinx device through a bus or interconnect.
  18 *
  19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  22 * XILINX  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  24 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25 * SOFTWARE.
  26 *
  27 * Except as contained in this notice, the name of the Xilinx shall not be used
  28 * in advertising or otherwise to promote the sale, use or other dealings in
  29 * this Software without prior written authorization from Xilinx.
  30 *
  31 ******************************************************************************/
  32 /****************************************************************************/
  33 /**
  34 *
  35 * @file xdevcfg_intr.c
  36 *
  37 * Contains the implementation of interrupt related functions of the XDcfg
  38 * driver.
  39 *
  40 * <pre>
  41 * MODIFICATION HISTORY:
  42 *
  43 * Ver   Who Date     Changes
  44 * ----- --- -------- ---------------------------------------------
  45 * 1.00a hvm 02/07/11 First release
  46 * 2.01a nm  07/07/12 Updated the XDcfg_IntrClear function to directly
  47 *                    set the mask instead of oring it with the
  48 *                    value read from the interrupt status register
  49 * </pre>
  50 *
  51 ******************************************************************************/
  52
  53 /***************************** Include Files *********************************/
  54
  55 #include "xdevcfg.h"
  56
  57 /************************** Constant Definitions *****************************/
  58
  59 /**************************** Type Definitions *******************************/
  60
  61 /***************** Macros (Inline Functions) Definitions *********************/
  62
  63 /************************** Function Prototypes ******************************/
  64
  65 /************************** Variable Definitions *****************************/
  66
  67 /****************************************************************************/
  68 /**
  69 *
  70 * This function enables the specified interrupts in the device.
  71 *
  72 * @param        InstancePtr is a pointer to the XDcfg instance.
  73 * @param        Mask is the bit-mask of the interrupts to be enabled.
  74 *               Bit positions of 1 will be enabled. Bit positions of 0 will
  75 *               keep the previous setting. This mask is formed by OR'ing
  76 *               XDCFG_INT_* bits defined in xdevcfg_hw.h.
  77 *
  78 * @return       None.
  79 *
  80 * @note         None.
  81 *
  82 *****************************************************************************/
  83 void XDcfg_IntrEnable(XDcfg *InstancePtr, u32 Mask)
  84 {
  85         u32 RegValue;
  86
  87         /*
  88          * Assert the arguments.
  89          */
  90         Xil_AssertVoid(InstancePtr != NULL);
  91         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
  92
  93         /*
  94          * Enable the specified interrupts in the Interrupt Mask Register.
  95          */
  96         RegValue = XDcfg_ReadReg(InstancePtr->Config.BaseAddr,
  97                                     XDCFG_INT_MASK_OFFSET);
  98         RegValue &= ~(Mask & XDCFG_IXR_ALL_MASK);
  99         XDcfg_WriteReg(InstancePtr->Config.BaseAddr,
 100                                 XDCFG_INT_MASK_OFFSET,
 101                                 RegValue);
 102 }
 103
 104
 105 /****************************************************************************/
 106 /**
 107 *
 108 * This function disables the specified interrupts in the device.
 109 *
 110 * @param        InstancePtr is a pointer to the XDcfg instance.
 111 * @param        Mask is the bit-mask of the interrupts to be disabled.
 112 *               Bit positions of 1 will be disabled. Bit positions of 0 will
 113 *               keep the previous setting. This mask is formed by OR'ing
 114 *               XDCFG_INT_* bits defined in xdevcfg_hw.h.
 115 *
 116 * @return       None.
 117 *
 118 * @note         None.
 119 *
 120 *****************************************************************************/
 121 void XDcfg_IntrDisable(XDcfg *InstancePtr, u32 Mask)
 122 {
 123         u32 RegValue;
 124
 125         /*
 126          * Assert the arguments.
 127          */
 128         Xil_AssertVoid(InstancePtr != NULL);
 129         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 130
 131         /*
 132          * Disable the specified interrupts in the Interrupt Mask Register.
 133          */
 134         RegValue = XDcfg_ReadReg(InstancePtr->Config.BaseAddr,
 135                                     XDCFG_INT_MASK_OFFSET);
 136         RegValue |= (Mask & XDCFG_IXR_ALL_MASK);
 137         XDcfg_WriteReg(InstancePtr->Config.BaseAddr,
 138                                 XDCFG_INT_MASK_OFFSET,
 139                                 RegValue);
 140 }
 141 /****************************************************************************/
 142 /**
 143 *
 144 * This function returns the enabled interrupts read from the Interrupt Mask
 145 * Register. Use the XDCFG_INT_* constants defined in xdevcfg_hw.h
 146 * to interpret the returned value.
 147 *
 148 * @param        InstancePtr is a pointer to the XDcfg instance.
 149 *
 150 * @return       A 32-bit value representing the contents of the IMR.
 151 *
 152 * @note         None.
 153 *
 154 *****************************************************************************/
 155 u32 XDcfg_IntrGetEnabled(XDcfg *InstancePtr)
 156 {
 157         /*
 158          * Assert the arguments.
 159          */
 160         Xil_AssertNonvoid(InstancePtr != NULL);
 161         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 162
 163         /*
 164          * Return the value read from the Interrupt Mask Register.
 165          */
 166         return (~ XDcfg_ReadReg(InstancePtr->Config.BaseAddr,
 167                                 XDCFG_INT_MASK_OFFSET));
 168 }
 169
 170 /****************************************************************************/
 171 /**
 172 *
 173 * This function returns the interrupt status read from Interrupt Status
 174 * Register. Use the XDCFG_INT_* constants defined in xdevcfg_hw.h
 175 * to interpret the returned value.
 176 *
 177 * @param        InstancePtr is a pointer to the XDcfg instance.
 178 *
 179 * @return       A 32-bit value representing the contents of the Interrupt
 180 *               Status register.
 181 *
 182 * @note         None.
 183 *
 184 *****************************************************************************/
 185 u32 XDcfg_IntrGetStatus(XDcfg *InstancePtr)
 186 {
 187         /*
 188          * Assert the arguments.
 189          */
 190         Xil_AssertNonvoid(InstancePtr != NULL);
 191         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 192
 193         /*
 194          * Return the value read from the Interrupt Status register.
 195          */
 196         return XDcfg_ReadReg(InstancePtr->Config.BaseAddr,
 197                                 XDCFG_INT_STS_OFFSET);
 198 }
 199
 200 /****************************************************************************/
 201 /**
 202 *
 203 * This function clears the specified interrupts in the Interrupt Status
 204 * Register.
 205 *
 206 * @param        InstancePtr is a pointer to the XDcfg instance.
 207 * @param        Mask is the bit-mask of the interrupts to be cleared.
 208 *               Bit positions of 1 will be cleared. Bit positions of 0 will not
 209 *               change the previous interrupt status. This mask is formed by
 210 *               OR'ing XDCFG_INT_* bits which are defined in xdevcfg_hw.h.
 211 *
 212 * @return       None.
 213 *
 214 * @note         None.
 215 *
 216 *****************************************************************************/
 217 void XDcfg_IntrClear(XDcfg *InstancePtr, u32 Mask)
 218 {
 219         /*
 220          * Assert the arguments.
 221          */
 222         Xil_AssertVoid(InstancePtr != NULL);
 223         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 224
 225         XDcfg_WriteReg(InstancePtr->Config.BaseAddr,
 226                                 XDCFG_INT_STS_OFFSET,
 227                                 Mask);
 228
 229 }
 230
 231 /*****************************************************************************/
 232 /**
 233 * The interrupt handler for the Device Config Interface.
 234 *
 235 * Events are signaled to upper layer for proper handling.
 236 *
 237 *
 238 * @param        InstancePtr is a pointer to the XDcfg instance.
 239 *
 240 * @return       None.
 241 *
 242 * @note         None.
 243 *
 244 ****************************************************************************/
 245 void XDcfg_InterruptHandler(XDcfg *InstancePtr)
 246 {
 247         u32 IntrStatusReg;
 248
 249         /*
 250          * Assert validates the input arguments.
 251          */
 252         Xil_AssertVoid(InstancePtr != NULL);
 253         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 254
 255         /*
 256          * Read the Interrupt status register.
 257          */
 258         IntrStatusReg = XDcfg_ReadReg(InstancePtr->Config.BaseAddr,
 259                                          XDCFG_INT_STS_OFFSET);
 260
 261         /*
 262          * Write the status back to clear the interrupts so that no
 263          * subsequent interrupts are missed while processing this interrupt.
 264          * This also does the DMA acknowledgment automatically.
 265          */
 266         XDcfg_WriteReg(InstancePtr->Config.BaseAddr,
 267                                 XDCFG_INT_STS_OFFSET, IntrStatusReg);
 268
 269         /*
 270          * Signal application that there are events to handle.
 271          */
 272         InstancePtr->StatusHandler(InstancePtr->CallBackRef,
 273                                            IntrStatusReg);
 274
 275 }
 276
 277 /****************************************************************************/
 278 /**
 279 *
 280 * This function sets the handler that will be called when an event (interrupt)
 281 * occurs that needs application's attention.
 282 *
 283 * @param        InstancePtr is a pointer to the XDcfg instance
 284 * @param        CallBackFunc is the address of the callback function.
 285 * @param        CallBackRef is a user data item that will be passed to the
 286 *               callback function when it is invoked.
 287 *
 288 * @return       None.
 289 *
 290 * @note         None.
 291 *
 292 *
 293 *****************************************************************************/
 294 void XDcfg_SetHandler(XDcfg *InstancePtr, void *CallBackFunc,
 295                                 void *CallBackRef)
 296 {
 297         /*
 298          * Asserts validate the input arguments
 299          * CallBackRef not checked, no way to know what is valid
 300          */
 301         Xil_AssertVoid(InstancePtr != NULL);
 302         Xil_AssertVoid(CallBackFunc != NULL);
 303         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 304
 305         InstancePtr->StatusHandler = (XDcfg_IntrHandler) CallBackFunc;
 306         InstancePtr->CallBackRef = CallBackRef;
 307 }