git.sur5r.net Git - freertos/blob

   1 /******************************************************************************
   2 *
   3 * Copyright (C) 2014 - 2015 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 xil_io.c
  36 *
  37 * Contains I/O functions for memory-mapped or non-memory-mapped I/O
  38 * architectures.  These functions encapsulate Cortex R5 architecture-specific
  39 * I/O requirements.
  40 *
  41 * @note
  42 *
  43 * This file contains architecture-dependent code.
  44 *
  45 * <pre>
  46 * MODIFICATION HISTORY:
  47 *
  48 * Ver   Who      Date     Changes
  49 * ----- -------- -------- -----------------------------------------------
  50 * 5.00  pkp      02/20/14 First release
  51 * </pre>
  52 ******************************************************************************/
  53
  54
  55 /***************************** Include Files *********************************/
  56 #include "xil_io.h"
  57 #include "xil_types.h"
  58 #include "xil_assert.h"
  59 #include "xpseudo_asm.h"
  60 #include "xreg_cortexr5.h"
  61
  62 /************************** Constant Definitions *****************************/
  63
  64 /**************************** Type Definitions *******************************/
  65
  66 /***************** Macros (Inline Functions) Definitions *********************/
  67
  68 /************************** Function Prototypes ******************************/
  69
  70 /*****************************************************************************/
  71 /**
  72 *
  73 * Performs an input operation for an 8-bit memory location by reading from the
  74 * specified address and returning the Value read from that address.
  75 *
  76 * @param        Addr contains the address to perform the input operation
  77 *               at.
  78 *
  79 * @return       The Value read from the specified input address.
  80 *
  81 * @note         None.
  82 *
  83 ******************************************************************************/
  84 u8 Xil_In8(INTPTR Addr)
  85 {
  86         return *(volatile u8 *) Addr;
  87 }
  88
  89 /*****************************************************************************/
  90 /**
  91 *
  92 * Performs an input operation for a 16-bit memory location by reading from the
  93 * specified address and returning the Value read from that address.
  94 *
  95 * @param        Addr contains the address to perform the input operation
  96 *               at.
  97 *
  98 * @return       The Value read from the specified input address.
  99 *
 100 * @note         None.
 101 *
 102 ******************************************************************************/
 103 u16 Xil_In16(INTPTR Addr)
 104 {
 105         return *(volatile u16 *) Addr;
 106 }
 107
 108 /*****************************************************************************/
 109 /**
 110 *
 111 * Performs an input operation for a 32-bit memory location by reading from the
 112 * specified address and returning the Value read from that address.
 113 *
 114 * @param        Addr contains the address to perform the input operation
 115 *               at.
 116 *
 117 * @return       The Value read from the specified input address.
 118 *
 119 * @note         None.
 120 *
 121 ******************************************************************************/
 122 u32 Xil_In32(INTPTR Addr)
 123 {
 124         return *(volatile u32 *) Addr;
 125 }
 126
 127 /*****************************************************************************/
 128 /**
 129 *
 130 * Performs an output operation for an 8-bit memory location by writing the
 131 * specified Value to the the specified address.
 132 *
 133 * @param        Addr contains the address to perform the output operation
 134 *               at.
 135 * @param        Value contains the Value to be output at the specified address.
 136 *
 137 * @return       None.
 138 *
 139 * @note         None.
 140 *
 141 ******************************************************************************/
 142 void Xil_Out8(INTPTR Addr, u8 Value)
 143 {
 144         volatile u8 *LocalAddr = (u8 *)Addr;
 145         *LocalAddr = Value;
 146 }
 147
 148 /*****************************************************************************/
 149 /**
 150 *
 151 * Performs an output operation for a 16-bit memory location by writing the
 152 * specified Value to the the specified address.
 153 *
 154 * @param        Addr contains the address to perform the output operation
 155 *               at.
 156 * @param        Value contains the Value to be output at the specified address.
 157 *
 158 * @return       None.
 159 *
 160 * @note         None.
 161 *
 162 ******************************************************************************/
 163 void Xil_Out16(INTPTR Addr, u16 Value)
 164 {
 165         volatile u16 *LocalAddr = (u16 *)Addr;
 166         *LocalAddr = Value;
 167 }
 168
 169 /*****************************************************************************/
 170 /**
 171 *
 172 * Performs an output operation for a 32-bit memory location by writing the
 173 * specified Value to the the specified address.
 174 *
 175 * @param        Addr contains the address to perform the output operation
 176 *               at.
 177 * @param        Value contains the Value to be output at the specified address.
 178 *
 179 * @return       None.
 180 *
 181 * @note         None.
 182 *
 183 ******************************************************************************/
 184 void Xil_Out32(INTPTR Addr, u32 Value)
 185 {
 186         volatile u32 *LocalAddr = (u32 *)Addr;
 187         *LocalAddr = Value;
 188 }
 189 /*****************************************************************************/
 190 /**
 191 *
 192 * Performs an output operation for a 64-bit memory location by writing the
 193 * specified Value to the the specified address.
 194 *
 195 * @param        Addr contains the address to perform the output operation
 196 *               at.
 197 * @param        Value contains the Value to be output at the specified address.
 198 *
 199 * @return       None.
 200 *
 201 * @note         None.
 202 *
 203 ******************************************************************************/
 204 void Xil_Out64(INTPTR Addr, u64 Value)
 205 {
 206         volatile u64 *LocalAddr = (u64 *)Addr;
 207         *LocalAddr = Value;
 208 }
 209
 210 /*****************************************************************************/
 211 /**
 212 *
 213 * Performs an input operation for a 64-bit memory location by reading the
 214 * specified Value to the the specified address.
 215 *
 216 * @param        Addr contains the address to perform the output operation
 217 *               at.
 218 * @param        Value contains the Value to be output at the specified address.
 219 *
 220 * @return       None.
 221 *
 222 * @note         None.
 223 *
 224 ******************************************************************************/
 225 u64 Xil_In64(INTPTR Addr)
 226 {
 227         return *(volatile u64 *) Addr;
 228 }
 229 /*****************************************************************************/
 230 /**
 231 *
 232 * Performs an input operation for a 16-bit memory location by reading from the
 233 * specified address and returning the byte-swapped Value read from that
 234 * address.
 235 *
 236 * @param        Addr contains the address to perform the input operation
 237 *               at.
 238 *
 239 * @return       The byte-swapped Value read from the specified input address.
 240 *
 241 * @note         None.
 242 *
 243 ******************************************************************************/
 244 u16 Xil_In16BE(INTPTR Addr)
 245 {
 246         u16 temp;
 247         u16 result;
 248
 249         temp = Xil_In16(Addr);
 250
 251         result = Xil_EndianSwap16(temp);
 252
 253         return result;
 254 }
 255
 256 /*****************************************************************************/
 257 /**
 258 *
 259 * Performs an input operation for a 32-bit memory location by reading from the
 260 * specified address and returning the byte-swapped Value read from that
 261 * address.
 262 *
 263 * @param        Addr contains the address to perform the input operation
 264 *               at.
 265 *
 266 * @return       The byte-swapped Value read from the specified input address.
 267 *
 268 * @note         None.
 269 *
 270 ******************************************************************************/
 271 u32 Xil_In32BE(INTPTR Addr)
 272 {
 273         u32 temp;
 274         u32 result;
 275
 276         temp = Xil_In32(Addr);
 277
 278         result = Xil_EndianSwap32(temp);
 279
 280         return result;
 281 }
 282
 283 /*****************************************************************************/
 284 /**
 285 *
 286 * Performs an output operation for a 16-bit memory location by writing the
 287 * specified Value to the the specified address. The Value is byte-swapped
 288 * before being written.
 289 *
 290 * @param        OutAddress contains the address to perform the output operation
 291 *               at.
 292 * @param        Value contains the Value to be output at the specified address.
 293 *
 294 * @return       None.
 295 *
 296 * @note         None.
 297 *
 298 ******************************************************************************/
 299 void Xil_Out16BE(INTPTR Addr, u16 Value)
 300 {
 301         u16 temp;
 302
 303         temp = Xil_EndianSwap16(Value);
 304
 305     Xil_Out16(Addr, temp);
 306 }
 307
 308 /*****************************************************************************/
 309 /**
 310 *
 311 * Performs an output operation for a 32-bit memory location by writing the
 312 * specified Value to the the specified address. The Value is byte-swapped
 313 * before being written.
 314 *
 315 * @param        OutAddress contains the address to perform the output operation
 316 *               at.
 317 * @param        Value contains the Value to be output at the specified address.
 318 *
 319 * @return       None.
 320 *
 321 * @note         None.
 322 *
 323 ******************************************************************************/
 324 void Xil_Out32BE(INTPTR Addr, u32 Value)
 325 {
 326         u32 temp;
 327
 328         temp = Xil_EndianSwap32(Value);
 329
 330     Xil_Out32(Addr, temp);
 331 }
 332
 333 /*****************************************************************************/
 334 /**
 335 *
 336 * Perform a 16-bit endian converion.
 337 *
 338 * @param        Data contains the value to be converted.
 339 *
 340 * @return       converted value.
 341 *
 342 * @note         None.
 343 *
 344 ******************************************************************************/
 345 u16 Xil_EndianSwap16(u16 Data)
 346 {
 347         return (u16) (((Data & 0xFF00U) >> 8U) | ((Data & 0x00FFU) << 8U));
 348 }
 349
 350 /*****************************************************************************/
 351 /**
 352 *
 353 * Perform a 32-bit endian converion.
 354 *
 355 * @param        Data contains the value to be converted.
 356 *
 357 * @return       converted value.
 358 *
 359 * @note         None.
 360 *
 361 ******************************************************************************/
 362 u32 Xil_EndianSwap32(u32 Data)
 363 {
 364         u16 LoWord;
 365         u16 HiWord;
 366
 367         /* get each of the half words from the 32 bit word */
 368
 369         LoWord = (u16) (Data & 0x0000FFFFU);
 370         HiWord = (u16) ((Data & 0xFFFF0000U) >> 16U);
 371
 372         /* byte swap each of the 16 bit half words */
 373
 374         LoWord = (((LoWord & 0xFF00U) >> 8U) | ((LoWord & 0x00FFU) << 8U));
 375         HiWord = (((HiWord & 0xFF00U) >> 8U) | ((HiWord & 0x00FFU) << 8U));
 376
 377         /* swap the half words before returning the value */
 378
 379         return ((((u32)LoWord) << 16U) | (u32)HiWord);
 380 }