IoLibNoIo.c

Go to the documentation of this file.

 
//
// Include common header file for this module.
//
#include "BaseIoLibIntrinsicInternal.h"
 
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 = *(volatile UINT8 *)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) {
    *(volatile UINT8 *)Address = Value;
  }
 
  FilterAfterMmIoWrite (FilterWidth8, Address, &Value);
 
  return Value;
}
 
UINT16
EFIAPI
MmioRead16 (
  IN      UINTN  Address
  )
{
  UINT16   Value;
  BOOLEAN  Flag;
 
  ASSERT ((Address & 1) == 0);
 
  Flag = FilterBeforeMmIoRead (FilterWidth16, Address, &Value);
  if (Flag) {
    Value = *(volatile UINT16 *)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) {
    *(volatile UINT16 *)Address = Value;
  }
 
  FilterAfterMmIoWrite (FilterWidth16, Address, &Value);
 
  return Value;
}
 
UINT32
EFIAPI
MmioRead32 (
  IN      UINTN  Address
  )
{
  UINT32   Value;
  BOOLEAN  Flag;
 
  ASSERT ((Address & 3) == 0);
 
  Flag = FilterBeforeMmIoRead (FilterWidth32, Address, &Value);
  if (Flag) {
    Value = *(volatile UINT32 *)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) {
    *(volatile UINT32 *)Address = Value;
  }
 
  FilterAfterMmIoWrite (FilterWidth32, Address, &Value);
 
  return Value;
}
 
UINT64
EFIAPI
MmioRead64 (
  IN      UINTN  Address
  )
{
  UINT64   Value;
  BOOLEAN  Flag;
 
  ASSERT ((Address & 7) == 0);
 
  Flag = FilterBeforeMmIoRead (FilterWidth64, Address, &Value);
  if (Flag) {
    Value = *(volatile UINT64 *)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) {
    *(volatile UINT64 *)Address = Value;
  }
 
  FilterAfterMmIoWrite (FilterWidth64, Address, &Value);
 
  return Value;
}