PciExpressLib.c

Go to the documentation of this file.

 
#include <Base.h>
 
#include <Library/BaseLib.h>
#include <Library/PciExpressLib.h>
#include <Library/IoLib.h>
#include <Library/DebugLib.h>
#include <Library/PcdLib.h>
 
#define ASSERT_INVALID_PCI_ADDRESS(A) \
  ASSERT (((A) & ~0xfffffff) == 0)
 
RETURN_STATUS
EFIAPI
PciExpressRegisterForRuntimeAccess (
  IN UINTN  Address
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  return RETURN_UNSUPPORTED;
}
 
VOID *
GetPciExpressBaseAddress (
  VOID
  )
{
  return (VOID *)(UINTN)PcdGet64 (PcdPciExpressBaseAddress);
}
 
STATIC
UINTN
PcdPciExpressBaseSize (
  VOID
  )
{
  return (UINTN)PcdGet64 (PcdPciExpressBaseSize);
}
 
UINT8
EFIAPI
PciExpressRead8 (
  IN      UINTN  Address
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT8)-1;
  }
 
  return MmioRead8 ((UINTN)GetPciExpressBaseAddress () + Address);
}
 
UINT8
EFIAPI
PciExpressWrite8 (
  IN      UINTN  Address,
  IN      UINT8  Value
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT8)-1;
  }
 
  return MmioWrite8 ((UINTN)GetPciExpressBaseAddress () + Address, Value);
}
 
UINT8
EFIAPI
PciExpressOr8 (
  IN      UINTN  Address,
  IN      UINT8  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT8)-1;
  }
 
  return MmioOr8 ((UINTN)GetPciExpressBaseAddress () + Address, OrData);
}
 
UINT8
EFIAPI
PciExpressAnd8 (
  IN      UINTN  Address,
  IN      UINT8  AndData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT8)-1;
  }
 
  return MmioAnd8 ((UINTN)GetPciExpressBaseAddress () + Address, AndData);
}
 
UINT8
EFIAPI
PciExpressAndThenOr8 (
  IN      UINTN  Address,
  IN      UINT8  AndData,
  IN      UINT8  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT8)-1;
  }
 
  return MmioAndThenOr8 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           AndData,
           OrData
           );
}
 
UINT8
EFIAPI
PciExpressBitFieldRead8 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT8)-1;
  }
 
  return MmioBitFieldRead8 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit
           );
}
 
UINT8
EFIAPI
PciExpressBitFieldWrite8 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  Value
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT8)-1;
  }
 
  return MmioBitFieldWrite8 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           Value
           );
}
 
UINT8
EFIAPI
PciExpressBitFieldOr8 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT8)-1;
  }
 
  return MmioBitFieldOr8 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           OrData
           );
}
 
UINT8
EFIAPI
PciExpressBitFieldAnd8 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  AndData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT8)-1;
  }
 
  return MmioBitFieldAnd8 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           AndData
           );
}
 
UINT8
EFIAPI
PciExpressBitFieldAndThenOr8 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  AndData,
  IN      UINT8  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT8)-1;
  }
 
  return MmioBitFieldAndThenOr8 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           AndData,
           OrData
           );
}
 
UINT16
EFIAPI
PciExpressRead16 (
  IN      UINTN  Address
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT16)-1;
  }
 
  return MmioRead16 ((UINTN)GetPciExpressBaseAddress () + Address);
}
 
UINT16
EFIAPI
PciExpressWrite16 (
  IN      UINTN   Address,
  IN      UINT16  Value
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT16)-1;
  }
 
  return MmioWrite16 ((UINTN)GetPciExpressBaseAddress () + Address, Value);
}
 
UINT16
EFIAPI
PciExpressOr16 (
  IN      UINTN   Address,
  IN      UINT16  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT16)-1;
  }
 
  return MmioOr16 ((UINTN)GetPciExpressBaseAddress () + Address, OrData);
}
 
UINT16
EFIAPI
PciExpressAnd16 (
  IN      UINTN   Address,
  IN      UINT16  AndData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT16)-1;
  }
 
  return MmioAnd16 ((UINTN)GetPciExpressBaseAddress () + Address, AndData);
}
 
UINT16
EFIAPI
PciExpressAndThenOr16 (
  IN      UINTN   Address,
  IN      UINT16  AndData,
  IN      UINT16  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT16)-1;
  }
 
  return MmioAndThenOr16 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           AndData,
           OrData
           );
}
 
UINT16
EFIAPI
PciExpressBitFieldRead16 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT16)-1;
  }
 
  return MmioBitFieldRead16 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit
           );
}
 
UINT16
EFIAPI
PciExpressBitFieldWrite16 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  Value
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT16)-1;
  }
 
  return MmioBitFieldWrite16 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           Value
           );
}
 
UINT16
EFIAPI
PciExpressBitFieldOr16 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT16)-1;
  }
 
  return MmioBitFieldOr16 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           OrData
           );
}
 
UINT16
EFIAPI
PciExpressBitFieldAnd16 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  AndData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT16)-1;
  }
 
  return MmioBitFieldAnd16 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           AndData
           );
}
 
UINT16
EFIAPI
PciExpressBitFieldAndThenOr16 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  AndData,
  IN      UINT16  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT16)-1;
  }
 
  return MmioBitFieldAndThenOr16 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           AndData,
           OrData
           );
}
 
UINT32
EFIAPI
PciExpressRead32 (
  IN      UINTN  Address
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT32)-1;
  }
 
  return MmioRead32 ((UINTN)GetPciExpressBaseAddress () + Address);
}
 
UINT32
EFIAPI
PciExpressWrite32 (
  IN      UINTN   Address,
  IN      UINT32  Value
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT32)-1;
  }
 
  return MmioWrite32 ((UINTN)GetPciExpressBaseAddress () + Address, Value);
}
 
UINT32
EFIAPI
PciExpressOr32 (
  IN      UINTN   Address,
  IN      UINT32  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT32)-1;
  }
 
  return MmioOr32 ((UINTN)GetPciExpressBaseAddress () + Address, OrData);
}
 
UINT32
EFIAPI
PciExpressAnd32 (
  IN      UINTN   Address,
  IN      UINT32  AndData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT32)-1;
  }
 
  return MmioAnd32 ((UINTN)GetPciExpressBaseAddress () + Address, AndData);
}
 
UINT32
EFIAPI
PciExpressAndThenOr32 (
  IN      UINTN   Address,
  IN      UINT32  AndData,
  IN      UINT32  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT32)-1;
  }
 
  return MmioAndThenOr32 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           AndData,
           OrData
           );
}
 
UINT32
EFIAPI
PciExpressBitFieldRead32 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT32)-1;
  }
 
  return MmioBitFieldRead32 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit
           );
}
 
UINT32
EFIAPI
PciExpressBitFieldWrite32 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  Value
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT32)-1;
  }
 
  return MmioBitFieldWrite32 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           Value
           );
}
 
UINT32
EFIAPI
PciExpressBitFieldOr32 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT32)-1;
  }
 
  return MmioBitFieldOr32 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           OrData
           );
}
 
UINT32
EFIAPI
PciExpressBitFieldAnd32 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  AndData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT32)-1;
  }
 
  return MmioBitFieldAnd32 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           AndData
           );
}
 
UINT32
EFIAPI
PciExpressBitFieldAndThenOr32 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  AndData,
  IN      UINT32  OrData
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= PcdPciExpressBaseSize ()) {
    return (UINT32)-1;
  }
 
  return MmioBitFieldAndThenOr32 (
           (UINTN)GetPciExpressBaseAddress () + Address,
           StartBit,
           EndBit,
           AndData,
           OrData
           );
}
 
UINTN
EFIAPI
PciExpressReadBuffer (
  IN      UINTN  StartAddress,
  IN      UINTN  Size,
  OUT     VOID   *Buffer
  )
{
  UINTN  ReturnValue;
 
  ASSERT_INVALID_PCI_ADDRESS (StartAddress);
  if (StartAddress >= PcdPciExpressBaseSize ()) {
    return (UINTN)-1;
  }
 
  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
 
  if (Size == 0) {
    return Size;
  }
 
  ASSERT (Buffer != NULL);
 
  //
  // Save Size for return
  //
  ReturnValue = Size;
 
  if ((StartAddress & 1) != 0) {
    //
    // Read a byte if StartAddress is byte aligned
    //
    *(volatile UINT8 *)Buffer = PciExpressRead8 (StartAddress);
    StartAddress             += sizeof (UINT8);
    Size                     -= sizeof (UINT8);
    Buffer                    = (UINT8 *)Buffer + 1;
  }
 
  if ((Size >= sizeof (UINT16)) && ((StartAddress & 2) != 0)) {
    //
    // Read a word if StartAddress is word aligned
    //
    WriteUnaligned16 ((UINT16 *)Buffer, (UINT16)PciExpressRead16 (StartAddress));
 
    StartAddress += sizeof (UINT16);
    Size         -= sizeof (UINT16);
    Buffer        = (UINT16 *)Buffer + 1;
  }
 
  while (Size >= sizeof (UINT32)) {
    //
    // Read as many double words as possible
    //
    WriteUnaligned32 ((UINT32 *)Buffer, (UINT32)PciExpressRead32 (StartAddress));
 
    StartAddress += sizeof (UINT32);
    Size         -= sizeof (UINT32);
    Buffer        = (UINT32 *)Buffer + 1;
  }
 
  if (Size >= sizeof (UINT16)) {
    //
    // Read the last remaining word if exist
    //
    WriteUnaligned16 ((UINT16 *)Buffer, (UINT16)PciExpressRead16 (StartAddress));
    StartAddress += sizeof (UINT16);
    Size         -= sizeof (UINT16);
    Buffer        = (UINT16 *)Buffer + 1;
  }
 
  if (Size >= sizeof (UINT8)) {
    //
    // Read the last remaining byte if exist
    //
    *(volatile UINT8 *)Buffer = PciExpressRead8 (StartAddress);
  }
 
  return ReturnValue;
}
 
UINTN
EFIAPI
PciExpressWriteBuffer (
  IN      UINTN  StartAddress,
  IN      UINTN  Size,
  IN      VOID   *Buffer
  )
{
  UINTN  ReturnValue;
 
  ASSERT_INVALID_PCI_ADDRESS (StartAddress);
  if (StartAddress >= PcdPciExpressBaseSize ()) {
    return (UINTN)-1;
  }
 
  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
 
  if (Size == 0) {
    return 0;
  }
 
  ASSERT (Buffer != NULL);
 
  //
  // Save Size for return
  //
  ReturnValue = Size;
 
  if ((StartAddress & 1) != 0) {
    //
    // Write a byte if StartAddress is byte aligned
    //
    PciExpressWrite8 (StartAddress, *(UINT8 *)Buffer);
    StartAddress += sizeof (UINT8);
    Size         -= sizeof (UINT8);
    Buffer        = (UINT8 *)Buffer + 1;
  }
 
  if ((Size >= sizeof (UINT16)) && ((StartAddress & 2) != 0)) {
    //
    // Write a word if StartAddress is word aligned
    //
    PciExpressWrite16 (StartAddress, ReadUnaligned16 ((UINT16 *)Buffer));
    StartAddress += sizeof (UINT16);
    Size         -= sizeof (UINT16);
    Buffer        = (UINT16 *)Buffer + 1;
  }
 
  while (Size >= sizeof (UINT32)) {
    //
    // Write as many double words as possible
    //
    PciExpressWrite32 (StartAddress, ReadUnaligned32 ((UINT32 *)Buffer));
    StartAddress += sizeof (UINT32);
    Size         -= sizeof (UINT32);
    Buffer        = (UINT32 *)Buffer + 1;
  }
 
  if (Size >= sizeof (UINT16)) {
    //
    // Write the last remaining word if exist
    //
    PciExpressWrite16 (StartAddress, ReadUnaligned16 ((UINT16 *)Buffer));
    StartAddress += sizeof (UINT16);
    Size         -= sizeof (UINT16);
    Buffer        = (UINT16 *)Buffer + 1;
  }
 
  if (Size >= sizeof (UINT8)) {
    //
    // Write the last remaining byte if exist
    //
    PciExpressWrite8 (StartAddress, *(UINT8 *)Buffer);
  }
 
  return ReturnValue;
}