IoLibArmVirt.c

Go to the documentation of this file.

 
#include "BaseIoLibIntrinsicInternal.h"
 
UINT8
EFIAPI
MmioRead8Internal (
  IN      UINTN  Address
  );
 
VOID
EFIAPI
MmioWrite8Internal (
  IN      UINTN  Address,
  IN      UINT8  Value
  );
 
UINT16
EFIAPI
MmioRead16Internal (
  IN      UINTN  Address
  );
 
VOID
EFIAPI
MmioWrite16Internal (
  IN      UINTN   Address,
  IN      UINT16  Value
  );
 
UINT32
EFIAPI
MmioRead32Internal (
  IN      UINTN  Address
  );
 
VOID
EFIAPI
MmioWrite32Internal (
  IN      UINTN   Address,
  IN      UINT32  Value
  );
 
UINT64
EFIAPI
MmioRead64Internal (
  IN      UINTN  Address
  );
 
VOID
EFIAPI
MmioWrite64Internal (
  IN      UINTN   Address,
  IN      UINT64  Value
  );
 
UINT8
EFIAPI
IoRead8 (
  IN      UINTN  Port
  )
{
  ASSERT (FALSE);
  return 0;
}
 
UINT8
EFIAPI
IoWrite8 (
  IN      UINTN  Port,
  IN      UINT8  Value
  )
{
  ASSERT (FALSE);
  return Value;
}
 
UINT16
EFIAPI
IoRead16 (
  IN      UINTN  Port
  )
{
  ASSERT (FALSE);
  return 0;
}
 
UINT16
EFIAPI
IoWrite16 (
  IN      UINTN   Port,
  IN      UINT16  Value
  )
{
  ASSERT (FALSE);
  return Value;
}
 
UINT32
EFIAPI
IoRead32 (
  IN      UINTN  Port
  )
{
  ASSERT (FALSE);
  return 0;
}
 
UINT32
EFIAPI
IoWrite32 (
  IN      UINTN   Port,
  IN      UINT32  Value
  )
{
  ASSERT (FALSE);
  return Value;
}
 
UINT64
EFIAPI
IoRead64 (
  IN      UINTN  Port
  )
{
  ASSERT (FALSE);
  return 0;
}
 
UINT64
EFIAPI
IoWrite64 (
  IN      UINTN   Port,
  IN      UINT64  Value
  )
{
  ASSERT (FALSE);
  return 0;
}
 
VOID
EFIAPI
IoReadFifo8 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  OUT     VOID   *Buffer
  )
{
  ASSERT (FALSE);
}
 
VOID
EFIAPI
IoWriteFifo8 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  IN      VOID   *Buffer
  )
{
  ASSERT (FALSE);
}
 
VOID
EFIAPI
IoReadFifo16 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  OUT     VOID   *Buffer
  )
{
  ASSERT (FALSE);
}
 
VOID
EFIAPI
IoWriteFifo16 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  IN      VOID   *Buffer
  )
{
  ASSERT (FALSE);
}
 
VOID
EFIAPI
IoReadFifo32 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  OUT     VOID   *Buffer
  )
{
  ASSERT (FALSE);
}
 
VOID
EFIAPI
IoWriteFifo32 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  IN      VOID   *Buffer
  )
{
  ASSERT (FALSE);
}
 
UINT8
EFIAPI
MmioRead8 (
  IN      UINTN  Address
  )
{
  UINT8    Value;
  BOOLEAN  Flag;
 
  Flag = FilterBeforeMmIoRead (FilterWidth8, Address, &Value);
  if (Flag) {
    Value = MmioRead8Internal (Address);
  }
 
  FilterAfterMmIoRead (FilterWidth8, Address, &Value);
 
  return Value;
}
 
UINT8
EFIAPI
MmioWrite8 (
  IN      UINTN  Address,
  IN      UINT8  Value
  )
{
  BOOLEAN  Flag;
 
  Flag = FilterBeforeMmIoWrite (FilterWidth8, Address, &Value);
  if (Flag) {
    MmioWrite8Internal (Address, Value);
  }
 
  FilterAfterMmIoWrite (FilterWidth8, Address, &Value);
 
  return Value;
}
 
UINT16
EFIAPI
MmioRead16 (
  IN      UINTN  Address
  )
{
  BOOLEAN  Flag;
  UINT16   Value;
 
  ASSERT ((Address & 1) == 0);
 
  Flag = FilterBeforeMmIoRead (FilterWidth16, Address, &Value);
  if (Flag) {
    Value = MmioRead16Internal (Address);
  }
 
  FilterAfterMmIoRead (FilterWidth16, Address, &Value);
 
  return Value;
}
 
UINT16
EFIAPI
MmioWrite16 (
  IN      UINTN   Address,
  IN      UINT16  Value
  )
{
  BOOLEAN  Flag;
 
  ASSERT ((Address & 1) == 0);
 
  Flag = FilterBeforeMmIoWrite (FilterWidth16, Address, &Value);
  if (Flag) {
    MmioWrite16Internal (Address, Value);
  }
 
  FilterAfterMmIoWrite (FilterWidth16, Address, &Value);
 
  return Value;
}
 
UINT32
EFIAPI
MmioRead32 (
  IN      UINTN  Address
  )
{
  BOOLEAN  Flag;
  UINT32   Value;
 
  ASSERT ((Address & 3) == 0);
 
  Flag = FilterBeforeMmIoRead (FilterWidth32, Address, &Value);
  if (Flag) {
    Value = MmioRead32Internal (Address);
  }
 
  FilterAfterMmIoRead (FilterWidth32, Address, &Value);
 
  return Value;
}
 
UINT32
EFIAPI
MmioWrite32 (
  IN      UINTN   Address,
  IN      UINT32  Value
  )
{
  BOOLEAN  Flag;
 
  ASSERT ((Address & 3) == 0);
 
  Flag = FilterBeforeMmIoWrite (FilterWidth32, Address, &Value);
  if (Flag) {
    MmioWrite32Internal (Address, Value);
  }
 
  FilterAfterMmIoWrite (FilterWidth32, Address, &Value);
 
  return Value;
}
 
UINT64
EFIAPI
MmioRead64 (
  IN      UINTN  Address
  )
{
  BOOLEAN  Flag;
  UINT64   Value;
 
  ASSERT ((Address & 7) == 0);
 
  Flag = FilterBeforeMmIoRead (FilterWidth64, Address, &Value);
  if (Flag) {
    Value = MmioRead64Internal (Address);
  }
 
  FilterAfterMmIoRead (FilterWidth64, Address, &Value);
 
  return Value;
}
 
UINT64
EFIAPI
MmioWrite64 (
  IN      UINTN   Address,
  IN      UINT64  Value
  )
{
  BOOLEAN  Flag;
 
  ASSERT ((Address & 7) == 0);
 
  Flag = FilterBeforeMmIoWrite (FilterWidth64, Address, &Value);
  if (Flag) {
    MmioWrite64Internal (Address, Value);
  }
 
  FilterAfterMmIoWrite (FilterWidth64, Address, &Value);
 
  return Value;
}