xil_io.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright (c) 2014 - 2021 Xilinx, Inc.  All rights reserved.
 * SPDX-License-Identifier: MIT
 ******************************************************************************/
 
/*****************************************************************************/
#ifndef XIL_IO_H /* prevent circular inclusions */
#define XIL_IO_H /* by using protection macros */
 
#ifdef __cplusplus
extern "C" {
#endif
 
/***************************** Include Files *********************************/
 
#include "xil_types.h"
 
/************************** Function Prototypes ******************************/
#ifdef ENABLE_SAFETY
extern u32 XStl_RegUpdate(u32 RegAddr, u32 RegVal);
#endif
 
/***************** Macros (Inline Functions) Definitions *********************/
#if defined __GNUC__
#if defined(__MICROBLAZE__)
#define INST_SYNC mbar(0)
#define DATA_SYNC mbar(1)
#else
#define SYNCHRONIZE_IO dmb()
#define INST_SYNC isb()
#define DATA_SYNC dsb()
#endif
#else
#define SYNCHRONIZE_IO
#define INST_SYNC
#define DATA_SYNC
#define INST_SYNC
#define DATA_SYNC
#endif
 
#if defined(__GNUC__) || defined(__ICCARM__) || defined(__MICROBLAZE__)
#define INLINE inline
#else
#define INLINE __inline
#endif
 
/*****************************************************************************/
static INLINE u8 Xil_In8(UINTPTR Addr) { return *(volatile u8 *)Addr; }
 
/*****************************************************************************/
static INLINE u16 Xil_In16(UINTPTR Addr) { return *(volatile u16 *)Addr; }
 
/*****************************************************************************/
static INLINE u32 Xil_In32(UINTPTR Addr) { return *(volatile u32 *)Addr; }
 
/*****************************************************************************/
static INLINE u64 Xil_In64(UINTPTR Addr) { return *(volatile u64 *)Addr; }
 
/*****************************************************************************/
static INLINE void Xil_Out8(UINTPTR Addr, u8 Value) {
  /* write 8 bit value to specified address */
  volatile u8 *LocalAddr = (volatile u8 *)Addr;
  *LocalAddr = Value;
}
 
/*****************************************************************************/
static INLINE void Xil_Out16(UINTPTR Addr, u16 Value) {
  /* write 16 bit value to specified address */
  volatile u16 *LocalAddr = (volatile u16 *)Addr;
  *LocalAddr = Value;
}
 
/*****************************************************************************/
static INLINE void Xil_Out32(UINTPTR Addr, u32 Value) {
  /* write 32 bit value to specified address */
#ifndef ENABLE_SAFETY
  volatile u32 *LocalAddr = (volatile u32 *)Addr;
  *LocalAddr = Value;
#else
  XStl_RegUpdate(Addr, Value);
#endif
}
 
/*****************************************************************************/
static INLINE void Xil_Out64(UINTPTR Addr, u64 Value) {
  /* write 64 bit value to specified address */
  volatile u64 *LocalAddr = (volatile u64 *)Addr;
  *LocalAddr = Value;
}
 
/*****************************************************************************/
static INLINE int Xil_SecureOut32(UINTPTR Addr, u32 Value) {
  int Status = XST_FAILURE;
  u32 ReadReg;
  u32 ReadRegTemp;
 
  /* writing 32 bit value to specified address */
  Xil_Out32(Addr, Value);
 
  /* verify value written to specified address with multiple reads */
  ReadReg = Xil_In32(Addr);
  ReadRegTemp = Xil_In32(Addr);
 
  if ((ReadReg == Value) && (ReadRegTemp == Value)) {
    Status = XST_SUCCESS;
  }
 
  return Status;
}
 
/*****************************************************************************/
static INLINE __attribute__((always_inline)) u16 Xil_EndianSwap16(u16 Data) {
  return (u16)(((Data & 0xFF00U) >> 8U) | ((Data & 0x00FFU) << 8U));
}
 
/*****************************************************************************/
static INLINE __attribute__((always_inline)) u32 Xil_EndianSwap32(u32 Data) {
  u16 LoWord;
  u16 HiWord;
 
  /* get each of the half words from the 32 bit word */
 
  LoWord = (u16)(Data & 0x0000FFFFU);
  HiWord = (u16)((Data & 0xFFFF0000U) >> 16U);
 
  /* byte swap each of the 16 bit half words */
 
  LoWord = (u16)(((LoWord & 0xFF00U) >> 8U) | ((LoWord & 0x00FFU) << 8U));
  HiWord = (u16)(((HiWord & 0xFF00U) >> 8U) | ((HiWord & 0x00FFU) << 8U));
 
  /* swap the half words before returning the value */
 
  return ((((u32)LoWord) << (u32)16U) | (u32)HiWord);
}
 
#if defined(__MICROBLAZE__)
#ifdef __LITTLE_ENDIAN__
#define Xil_In16LE Xil_In16
#define Xil_In32LE Xil_In32
#define Xil_Out16LE Xil_Out16
#define Xil_Out32LE Xil_Out32
#define Xil_Htons Xil_EndianSwap16
#define Xil_Htonl Xil_EndianSwap32
#define Xil_Ntohs Xil_EndianSwap16
#define Xil_Ntohl Xil_EndianSwap32
#else
#define Xil_In16BE Xil_In16
#define Xil_In32BE Xil_In32
#define Xil_Out16BE Xil_Out16
#define Xil_Out32BE Xil_Out32
#define Xil_Htons(Data) (Data)
#define Xil_Htonl(Data) (Data)
#define Xil_Ntohs(Data) (Data)
#define Xil_Ntohl(Data) (Data)
#endif
#else
#define Xil_In16LE Xil_In16
#define Xil_In32LE Xil_In32
#define Xil_Out16LE Xil_Out16
#define Xil_Out32LE Xil_Out32
#define Xil_Htons Xil_EndianSwap16
#define Xil_Htonl Xil_EndianSwap32
#define Xil_Ntohs Xil_EndianSwap16
#define Xil_Ntohl Xil_EndianSwap32
#endif
 
#if defined(__MICROBLAZE__)
#ifdef __LITTLE_ENDIAN__
static INLINE u16 Xil_In16BE(UINTPTR Addr)
#else
static INLINE u16 Xil_In16LE(UINTPTR Addr)
#endif
#else
static INLINE u16 Xil_In16BE(UINTPTR Addr)
#endif
{
  u16 value = Xil_In16(Addr);
  return Xil_EndianSwap16(value);
}
 
#if defined(__MICROBLAZE__)
#ifdef __LITTLE_ENDIAN__
static INLINE u32 Xil_In32BE(UINTPTR Addr)
#else
static INLINE u32 Xil_In32LE(UINTPTR Addr)
#endif
#else
static INLINE u32 Xil_In32BE(UINTPTR Addr)
#endif
{
  u32 value = Xil_In32(Addr);
  return Xil_EndianSwap32(value);
}
 
#if defined(__MICROBLAZE__)
#ifdef __LITTLE_ENDIAN__
static INLINE void Xil_Out16BE(UINTPTR Addr, u16 Value)
#else
static INLINE void Xil_Out16LE(UINTPTR Addr, u16 Value)
#endif
#else
static INLINE void Xil_Out16BE(UINTPTR Addr, u16 Value)
#endif
{
  Value = Xil_EndianSwap16(Value);
  Xil_Out16(Addr, Value);
}
 
#if defined(__MICROBLAZE__)
#ifdef __LITTLE_ENDIAN__
static INLINE void Xil_Out32BE(UINTPTR Addr, u32 Value)
#else
static INLINE void Xil_Out32LE(UINTPTR Addr, u32 Value)
#endif
#else
static INLINE void Xil_Out32BE(UINTPTR Addr, u32 Value)
#endif
{
  Value = Xil_EndianSwap32(Value);
  Xil_Out32(Addr, Value);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* end of protection macro */