IoLib.c

Go to the documentation of this file.

 
#include "DxeCpuIo2LibInternal.h"
 
//
// Global variable to cache pointer to CpuIo2 protocol.
//
EFI_CPU_IO2_PROTOCOL  *mCpuIo = NULL;
 
EFI_STATUS
EFIAPI
IoLibConstructor (
  IN      EFI_HANDLE        ImageHandle,
  IN      EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  Status = gBS->LocateProtocol (&gEfiCpuIo2ProtocolGuid, NULL, (VOID **)&mCpuIo);
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}
 
UINT64
EFIAPI
IoReadWorker (
  IN      UINTN                      Port,
  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width
  )
{
  EFI_STATUS  Status;
  UINT64      Data;
 
  Status = mCpuIo->Io.Read (mCpuIo, Width, Port, 1, &Data);
  ASSERT_EFI_ERROR (Status);
 
  return Data;
}
 
UINT64
EFIAPI
IoWriteWorker (
  IN      UINTN                      Port,
  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
  IN      UINT64                     Data
  )
{
  EFI_STATUS  Status;
 
  Status = mCpuIo->Io.Write (mCpuIo, Width, Port, 1, &Data);
  ASSERT_EFI_ERROR (Status);
 
  return Data;
}
 
VOID
EFIAPI
IoReadFifoWorker (
  IN      UINTN                      Port,
  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
  IN      UINTN                      Count,
  IN      VOID                       *Buffer
  )
{
  EFI_STATUS  Status;
 
  Status = mCpuIo->Io.Read (mCpuIo, Width, Port, Count, Buffer);
  ASSERT_EFI_ERROR (Status);
}
 
VOID
EFIAPI
IoWriteFifoWorker (
  IN      UINTN                      Port,
  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
  IN      UINTN                      Count,
  IN      VOID                       *Buffer
  )
{
  EFI_STATUS  Status;
 
  Status = mCpuIo->Io.Write (mCpuIo, Width, Port, Count, Buffer);
  ASSERT_EFI_ERROR (Status);
}
 
UINT64
EFIAPI
MmioReadWorker (
  IN      UINTN                      Address,
  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width
  )
{
  EFI_STATUS  Status;
  UINT64      Data;
 
  Status = mCpuIo->Mem.Read (mCpuIo, Width, Address, 1, &Data);
  ASSERT_EFI_ERROR (Status);
 
  return Data;
}
 
UINT64
EFIAPI
MmioWriteWorker (
  IN      UINTN                      Address,
  IN      EFI_CPU_IO_PROTOCOL_WIDTH  Width,
  IN      UINT64                     Data
  )
{
  EFI_STATUS  Status;
 
  Status = mCpuIo->Mem.Write (mCpuIo, Width, Address, 1, &Data);
  ASSERT_EFI_ERROR (Status);
 
  return Data;
}
 
UINT8
EFIAPI
IoRead8 (
  IN      UINTN  Port
  )
{
  return (UINT8)IoReadWorker (Port, EfiCpuIoWidthUint8);
}
 
UINT8
EFIAPI
IoWrite8 (
  IN      UINTN  Port,
  IN      UINT8  Value
  )
{
  return (UINT8)IoWriteWorker (Port, EfiCpuIoWidthUint8, Value);
}
 
UINT16
EFIAPI
IoRead16 (
  IN      UINTN  Port
  )
{
  //
  // Make sure Port is aligned on a 16-bit boundary.
  //
  ASSERT ((Port & 1) == 0);
  return (UINT16)IoReadWorker (Port, EfiCpuIoWidthUint16);
}
 
UINT16
EFIAPI
IoWrite16 (
  IN      UINTN   Port,
  IN      UINT16  Value
  )
{
  //
  // Make sure Port is aligned on a 16-bit boundary.
  //
  ASSERT ((Port & 1) == 0);
  return (UINT16)IoWriteWorker (Port, EfiCpuIoWidthUint16, Value);
}
 
UINT32
EFIAPI
IoRead32 (
  IN      UINTN  Port
  )
{
  //
  // Make sure Port is aligned on a 32-bit boundary.
  //
  ASSERT ((Port & 3) == 0);
  return (UINT32)IoReadWorker (Port, EfiCpuIoWidthUint32);
}
 
UINT32
EFIAPI
IoWrite32 (
  IN      UINTN   Port,
  IN      UINT32  Value
  )
{
  //
  // Make sure Port is aligned on a 32-bit boundary.
  //
  ASSERT ((Port & 3) == 0);
  return (UINT32)IoWriteWorker (Port, EfiCpuIoWidthUint32, Value);
}
 
UINT64
EFIAPI
IoRead64 (
  IN      UINTN  Port
  )
{
  //
  // Make sure Port is aligned on a 64-bit boundary.
  //
  ASSERT ((Port & 7) == 0);
  return IoReadWorker (Port, EfiCpuIoWidthUint64);
}
 
UINT64
EFIAPI
IoWrite64 (
  IN      UINTN   Port,
  IN      UINT64  Value
  )
{
  //
  // Make sure Port is aligned on a 64-bit boundary.
  //
  ASSERT ((Port & 7) == 0);
  return IoWriteWorker (Port, EfiCpuIoWidthUint64, Value);
}
 
VOID
EFIAPI
IoReadFifo8 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  OUT     VOID   *Buffer
  )
{
  IoReadFifoWorker (Port, EfiCpuIoWidthFifoUint8, Count, Buffer);
}
 
VOID
EFIAPI
IoWriteFifo8 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  IN      VOID   *Buffer
  )
{
  IoWriteFifoWorker (Port, EfiCpuIoWidthFifoUint8, Count, Buffer);
}
 
VOID
EFIAPI
IoReadFifo16 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  OUT     VOID   *Buffer
  )
{
  //
  // Make sure Port is aligned on a 16-bit boundary.
  //
  ASSERT ((Port & 1) == 0);
  IoReadFifoWorker (Port, EfiCpuIoWidthFifoUint16, Count, Buffer);
}
 
VOID
EFIAPI
IoWriteFifo16 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  IN      VOID   *Buffer
  )
{
  //
  // Make sure Port is aligned on a 16-bit boundary.
  //
  ASSERT ((Port & 1) == 0);
  IoWriteFifoWorker (Port, EfiCpuIoWidthFifoUint16, Count, Buffer);
}
 
VOID
EFIAPI
IoReadFifo32 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  OUT     VOID   *Buffer
  )
{
  //
  // Make sure Port is aligned on a 32-bit boundary.
  //
  ASSERT ((Port & 3) == 0);
  IoReadFifoWorker (Port, EfiCpuIoWidthFifoUint32, Count, Buffer);
}
 
VOID
EFIAPI
IoWriteFifo32 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  IN      VOID   *Buffer
  )
{
  //
  // Make sure Port is aligned on a 32-bit boundary.
  //
  ASSERT ((Port & 3) == 0);
  IoWriteFifoWorker (Port, EfiCpuIoWidthFifoUint32, Count, Buffer);
}
 
UINT8
EFIAPI
MmioRead8 (
  IN      UINTN  Address
  )
{
  return (UINT8)MmioReadWorker (Address, EfiCpuIoWidthUint8);
}
 
UINT8
EFIAPI
MmioWrite8 (
  IN      UINTN  Address,
  IN      UINT8  Value
  )
{
  return (UINT8)MmioWriteWorker (Address, EfiCpuIoWidthUint8, Value);
}
 
UINT16
EFIAPI
MmioRead16 (
  IN      UINTN  Address
  )
{
  //
  // Make sure Address is aligned on a 16-bit boundary.
  //
  ASSERT ((Address & 1) == 0);
  return (UINT16)MmioReadWorker (Address, EfiCpuIoWidthUint16);
}
 
UINT16
EFIAPI
MmioWrite16 (
  IN      UINTN   Address,
  IN      UINT16  Value
  )
{
  //
  // Make sure Address is aligned on a 16-bit boundary.
  //
  ASSERT ((Address & 1) == 0);
  return (UINT16)MmioWriteWorker (Address, EfiCpuIoWidthUint16, Value);
}
 
UINT32
EFIAPI
MmioRead32 (
  IN      UINTN  Address
  )
{
  //
  // Make sure Address is aligned on a 32-bit boundary.
  //
  ASSERT ((Address & 3) == 0);
  return (UINT32)MmioReadWorker (Address, EfiCpuIoWidthUint32);
}
 
UINT32
EFIAPI
MmioWrite32 (
  IN      UINTN   Address,
  IN      UINT32  Value
  )
{
  //
  // Make sure Address is aligned on a 32-bit boundary.
  //
  ASSERT ((Address & 3) == 0);
  return (UINT32)MmioWriteWorker (Address, EfiCpuIoWidthUint32, Value);
}
 
UINT64
EFIAPI
MmioRead64 (
  IN      UINTN  Address
  )
{
  //
  // Make sure Address is aligned on a 64-bit boundary.
  //
  ASSERT ((Address & 7) == 0);
  return (UINT64)MmioReadWorker (Address, EfiCpuIoWidthUint64);
}
 
UINT64
EFIAPI
MmioWrite64 (
  IN      UINTN   Address,
  IN      UINT64  Value
  )
{
  //
  // Make sure Address is aligned on a 64-bit boundary.
  //
  ASSERT ((Address & 7) == 0);
  return (UINT64)MmioWriteWorker (Address, EfiCpuIoWidthUint64, Value);
}