PciSegmentLibCommon.c

Go to the documentation of this file.

 
#include "PciSegmentLibCommon.h"
 
typedef struct {
  UINT32    Register  : 12;
  UINT32    Function  : 3;
  UINT32    Device    : 5;
  UINT32    Bus       : 8;
  UINT32    Reserved1 : 4;
  UINT32    Segment   : 16;
  UINT32    Reserved2 : 16;
} PCI_SEGMENT_LIB_ADDRESS_STRUCTURE;
 
UINTN
PciSegmentLibGetEcamAddress (
  IN UINT64                  Address,
  IN CONST PCI_SEGMENT_INFO  *SegmentInfo,
  IN UINTN                   Count
  )
{
  while (Count != 0) {
    if (SegmentInfo->SegmentNumber == ((PCI_SEGMENT_LIB_ADDRESS_STRUCTURE *)&Address)->Segment) {
      break;
    }
 
    SegmentInfo++;
    Count--;
  }
 
  ASSERT (Count != 0);
  ASSERT (
    (((PCI_SEGMENT_LIB_ADDRESS_STRUCTURE *)&Address)->Reserved1 == 0) &&
    (((PCI_SEGMENT_LIB_ADDRESS_STRUCTURE *)&Address)->Reserved2 == 0)
    );
  ASSERT (((PCI_SEGMENT_LIB_ADDRESS_STRUCTURE *)&Address)->Bus >= SegmentInfo->StartBusNumber);
  ASSERT (((PCI_SEGMENT_LIB_ADDRESS_STRUCTURE *)&Address)->Bus <= SegmentInfo->EndBusNumber);
 
  Address = SegmentInfo->BaseAddress + PCI_ECAM_ADDRESS (
                                         ((PCI_SEGMENT_LIB_ADDRESS_STRUCTURE *)&Address)->Bus,
                                         ((PCI_SEGMENT_LIB_ADDRESS_STRUCTURE *)&Address)->Device,
                                         ((PCI_SEGMENT_LIB_ADDRESS_STRUCTURE *)&Address)->Function,
                                         ((PCI_SEGMENT_LIB_ADDRESS_STRUCTURE *)&Address)->Register
                                         );
 
  if (sizeof (UINTN) == sizeof (UINT32)) {
    ASSERT (Address < BASE_4GB);
  }
 
  return PciSegmentLibVirtualAddress ((UINTN)Address);
}
 
UINT8
EFIAPI
PciSegmentRead8 (
  IN UINT64  Address
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioRead8 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count));
}
 
UINT8
EFIAPI
PciSegmentWrite8 (
  IN UINT64  Address,
  IN UINT8   Value
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioWrite8 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), Value);
}
 
UINT8
EFIAPI
PciSegmentOr8 (
  IN UINT64  Address,
  IN UINT8   OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioOr8 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), OrData);
}
 
UINT8
EFIAPI
PciSegmentAnd8 (
  IN UINT64  Address,
  IN UINT8   AndData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioAnd8 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), AndData);
}
 
UINT8
EFIAPI
PciSegmentAndThenOr8 (
  IN UINT64  Address,
  IN UINT8   AndData,
  IN UINT8   OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioAndThenOr8 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), AndData, OrData);
}
 
UINT8
EFIAPI
PciSegmentBitFieldRead8 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldRead8 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit);
}
 
UINT8
EFIAPI
PciSegmentBitFieldWrite8 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT8   Value
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldWrite8 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, Value);
}
 
UINT8
EFIAPI
PciSegmentBitFieldOr8 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT8   OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldOr8 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, OrData);
}
 
UINT8
EFIAPI
PciSegmentBitFieldAnd8 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT8   AndData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldAnd8 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, AndData);
}
 
UINT8
EFIAPI
PciSegmentBitFieldAndThenOr8 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT8   AndData,
  IN UINT8   OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldAndThenOr8 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, AndData, OrData);
}
 
UINT16
EFIAPI
PciSegmentRead16 (
  IN UINT64  Address
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioRead16 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count));
}
 
UINT16
EFIAPI
PciSegmentWrite16 (
  IN UINT64  Address,
  IN UINT16  Value
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioWrite16 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), Value);
}
 
UINT16
EFIAPI
PciSegmentOr16 (
  IN UINT64  Address,
  IN UINT16  OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioOr16 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), OrData);
}
 
UINT16
EFIAPI
PciSegmentAnd16 (
  IN UINT64  Address,
  IN UINT16  AndData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioAnd16 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), AndData);
}
 
UINT16
EFIAPI
PciSegmentAndThenOr16 (
  IN UINT64  Address,
  IN UINT16  AndData,
  IN UINT16  OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioAndThenOr16 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), AndData, OrData);
}
 
UINT16
EFIAPI
PciSegmentBitFieldRead16 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldRead16 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit);
}
 
UINT16
EFIAPI
PciSegmentBitFieldWrite16 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT16  Value
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldWrite16 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, Value);
}
 
UINT16
EFIAPI
PciSegmentBitFieldOr16 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT16  OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldOr16 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, OrData);
}
 
UINT16
EFIAPI
PciSegmentBitFieldAnd16 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT16  AndData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldAnd16 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, AndData);
}
 
UINT16
EFIAPI
PciSegmentBitFieldAndThenOr16 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT16  AndData,
  IN UINT16  OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldAndThenOr16 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, AndData, OrData);
}
 
UINT32
EFIAPI
PciSegmentRead32 (
  IN UINT64  Address
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioRead32 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count));
}
 
UINT32
EFIAPI
PciSegmentWrite32 (
  IN UINT64  Address,
  IN UINT32  Value
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioWrite32 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), Value);
}
 
UINT32
EFIAPI
PciSegmentOr32 (
  IN UINT64  Address,
  IN UINT32  OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioOr32 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), OrData);
}
 
UINT32
EFIAPI
PciSegmentAnd32 (
  IN UINT64  Address,
  IN UINT32  AndData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioAnd32 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), AndData);
}
 
UINT32
EFIAPI
PciSegmentAndThenOr32 (
  IN UINT64  Address,
  IN UINT32  AndData,
  IN UINT32  OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioAndThenOr32 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), AndData, OrData);
}
 
UINT32
EFIAPI
PciSegmentBitFieldRead32 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldRead32 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit);
}
 
UINT32
EFIAPI
PciSegmentBitFieldWrite32 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT32  Value
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldWrite32 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, Value);
}
 
UINT32
EFIAPI
PciSegmentBitFieldOr32 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT32  OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldOr32 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, OrData);
}
 
UINT32
EFIAPI
PciSegmentBitFieldAnd32 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT32  AndData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldAnd32 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, AndData);
}
 
UINT32
EFIAPI
PciSegmentBitFieldAndThenOr32 (
  IN UINT64  Address,
  IN UINTN   StartBit,
  IN UINTN   EndBit,
  IN UINT32  AndData,
  IN UINT32  OrData
  )
{
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  return MmioBitFieldAndThenOr32 (PciSegmentLibGetEcamAddress (Address, SegmentInfo, Count), StartBit, EndBit, AndData, OrData);
}
 
UINTN
EFIAPI
PciSegmentReadBuffer (
  IN  UINT64  StartAddress,
  IN  UINTN   Size,
  OUT VOID    *Buffer
  )
{
  UINTN             ReturnValue;
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
  UINTN             Address;
 
  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  Address     = PciSegmentLibGetEcamAddress (StartAddress, SegmentInfo, Count);
 
  if (Size == 0) {
    return 0;
  }
 
  ASSERT (Buffer != NULL);
 
  //
  // Save Size for return
  //
  ReturnValue = Size;
 
  if ((Address & BIT0) != 0) {
    //
    // Read a byte if StartAddress is byte aligned
    //
    *(volatile UINT8 *)Buffer = MmioRead8 (Address);
    Address                  += sizeof (UINT8);
    Size                     -= sizeof (UINT8);
    Buffer                    = (UINT8 *)Buffer + 1;
  }
 
  if ((Size >= sizeof (UINT16)) && ((Address & BIT1) != 0)) {
    //
    // Read a word if StartAddress is word aligned
    //
    WriteUnaligned16 (Buffer, MmioRead16 (Address));
    Address += sizeof (UINT16);
    Size    -= sizeof (UINT16);
    Buffer   = (UINT16 *)Buffer + 1;
  }
 
  while (Size >= sizeof (UINT32)) {
    //
    // Read as many double words as possible
    //
    WriteUnaligned32 (Buffer, MmioRead32 (Address));
    Address += sizeof (UINT32);
    Size    -= sizeof (UINT32);
    Buffer   = (UINT32 *)Buffer + 1;
  }
 
  if (Size >= sizeof (UINT16)) {
    //
    // Read the last remaining word if exist
    //
    WriteUnaligned16 (Buffer, MmioRead16 (Address));
    Address += sizeof (UINT16);
    Size    -= sizeof (UINT16);
    Buffer   = (UINT16 *)Buffer + 1;
  }
 
  if (Size >= sizeof (UINT8)) {
    //
    // Read the last remaining byte if exist
    //
    *(volatile UINT8 *)Buffer = MmioRead8 (Address);
  }
 
  return ReturnValue;
}
 
UINTN
EFIAPI
PciSegmentWriteBuffer (
  IN UINT64  StartAddress,
  IN UINTN   Size,
  IN VOID    *Buffer
  )
{
  UINTN             ReturnValue;
  UINTN             Count;
  PCI_SEGMENT_INFO  *SegmentInfo;
  UINTN             Address;
 
  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
 
  SegmentInfo = GetPciSegmentInfo (&Count);
  Address     = PciSegmentLibGetEcamAddress (StartAddress, SegmentInfo, Count);
 
  if (Size == 0) {
    return 0;
  }
 
  ASSERT (Buffer != NULL);
 
  //
  // Save Size for return
  //
  ReturnValue = Size;
 
  if ((Address & BIT0) != 0) {
    //
    // Write a byte if StartAddress is byte aligned
    //
    MmioWrite8 (Address, *(UINT8 *)Buffer);
    Address += sizeof (UINT8);
    Size    -= sizeof (UINT8);
    Buffer   = (UINT8 *)Buffer + 1;
  }
 
  if ((Size >= sizeof (UINT16)) && ((Address & BIT1) != 0)) {
    //
    // Write a word if StartAddress is word aligned
    //
    MmioWrite16 (Address, ReadUnaligned16 (Buffer));
    Address += sizeof (UINT16);
    Size    -= sizeof (UINT16);
    Buffer   = (UINT16 *)Buffer + 1;
  }
 
  while (Size >= sizeof (UINT32)) {
    //
    // Write as many double words as possible
    //
    MmioWrite32 (Address, ReadUnaligned32 (Buffer));
    Address += sizeof (UINT32);
    Size    -= sizeof (UINT32);
    Buffer   = (UINT32 *)Buffer + 1;
  }
 
  if (Size >= sizeof (UINT16)) {
    //
    // Write the last remaining word if exist
    //
    MmioWrite16 (Address, ReadUnaligned16 (Buffer));
    Address += sizeof (UINT16);
    Size    -= sizeof (UINT16);
    Buffer   = (UINT16 *)Buffer + 1;
  }
 
  if (Size >= sizeof (UINT8)) {
    //
    // Write the last remaining byte if exist
    //
    MmioWrite8 (Address, *(UINT8 *)Buffer);
  }
 
  return ReturnValue;
}