PciExpressLib.c

Go to the documentation of this file.

 
#include <PiDxe.h>
 
#include <Guid/EventGroup.h>
 
#include <Library/BaseLib.h>
#include <Library/PciExpressLib.h>
#include <Library/IoLib.h>
#include <Library/DebugLib.h>
#include <Library/PcdLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/DxeServicesTableLib.h>
#include <Library/UefiRuntimeLib.h>
 
#define ASSERT_INVALID_PCI_ADDRESS(A) \
 ASSERT (((A) & ~0xfffffff) == 0)
 
typedef struct {
  UINTN    PhysicalAddress;
  UINTN    VirtualAddress;
} PCI_EXPRESS_RUNTIME_REGISTRATION_TABLE;
 
EFI_EVENT  mDxeRuntimePciExpressLibVirtualNotifyEvent = NULL;
 
UINTN  mDxeRuntimePciExpressLibPciExpressBaseAddress = 0;
UINTN  mDxeRuntimePciExpressLibPciExpressBaseSize    = 0;
 
UINTN  mDxeRuntimePciExpressLibNumberOfRuntimeRanges = 0;
 
PCI_EXPRESS_RUNTIME_REGISTRATION_TABLE  *mDxeRuntimePciExpressLibRegistrationTable = NULL;
 
UINTN  mDxeRuntimePciExpressLibLastRuntimeRange = 0;
 
VOID
EFIAPI
DxeRuntimePciExpressLibVirtualNotify (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  UINTN  Index;
 
  //
  // If there have been no runtime registrations, then just return
  //
  if (mDxeRuntimePciExpressLibRegistrationTable == NULL) {
    return;
  }
 
  //
  // Convert physical addresses associated with the set of registered PCI devices to
  // virtual addresses.
  //
  for (Index = 0; Index < mDxeRuntimePciExpressLibNumberOfRuntimeRanges; Index++) {
    EfiConvertPointer (0, (VOID **)&(mDxeRuntimePciExpressLibRegistrationTable[Index].VirtualAddress));
  }
 
  //
  // Convert table pointer that is allocated from EfiRuntimeServicesData to a virtual address.
  //
  EfiConvertPointer (0, (VOID **)&mDxeRuntimePciExpressLibRegistrationTable);
}
 
EFI_STATUS
EFIAPI
DxeRuntimePciExpressLibConstructor (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  //
  // Cache the physical address of the PCI Express MMIO range into a module global variable
  //
  mDxeRuntimePciExpressLibPciExpressBaseAddress = (UINTN)PcdGet64 (PcdPciExpressBaseAddress);
  mDxeRuntimePciExpressLibPciExpressBaseSize    = (UINTN)PcdGet64 (PcdPciExpressBaseSize);
 
  //
  // Register SetVirtualAddressMap () notify function
  //
  Status = gBS->CreateEvent (
                  EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE,
                  TPL_NOTIFY,
                  DxeRuntimePciExpressLibVirtualNotify,
                  NULL,
                  &mDxeRuntimePciExpressLibVirtualNotifyEvent
                  );
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
DxeRuntimePciExpressLibDestructor (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  //
  // If one or more PCI devices have been registered for runtime access, then
  // free the registration table.
  //
  if (mDxeRuntimePciExpressLibRegistrationTable != NULL) {
    FreePool (mDxeRuntimePciExpressLibRegistrationTable);
  }
 
  //
  // Close the Set Virtual Address Map event
  //
  Status = gBS->CloseEvent (mDxeRuntimePciExpressLibVirtualNotifyEvent);
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}
 
UINTN
GetPciExpressAddress (
  IN UINTN  Address
  )
{
  UINTN  Index;
 
  //
  // Make sure Address is valid
  //
  ASSERT_INVALID_PCI_ADDRESS (Address);
 
  //
  // Make sure the Address is in MMCONF address space
  //
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINTN)-1;
  }
 
  //
  // Convert Address to a physical address in the MMIO PCI Express range
  //
  Address += mDxeRuntimePciExpressLibPciExpressBaseAddress;
 
  //
  // If SetVirtualAddressMap() has not been called, then just return the physical address
  //
  if (!EfiGoneVirtual ()) {
    return Address;
  }
 
  //
  // See if there is a physical address match at the exact same index as the last address match
  //
  if (mDxeRuntimePciExpressLibRegistrationTable[mDxeRuntimePciExpressLibLastRuntimeRange].PhysicalAddress == (Address & (~0x00000fff))) {
    //
    // Convert the physical address to a virtual address and return the virtual address
    //
    return (Address & 0x00000fff) + mDxeRuntimePciExpressLibRegistrationTable[mDxeRuntimePciExpressLibLastRuntimeRange].VirtualAddress;
  }
 
  //
  // Search the entire table for a physical address match
  //
  for (Index = 0; Index < mDxeRuntimePciExpressLibNumberOfRuntimeRanges; Index++) {
    if (mDxeRuntimePciExpressLibRegistrationTable[Index].PhysicalAddress == (Address & (~0x00000fff))) {
      //
      // Cache the matching index value
      //
      mDxeRuntimePciExpressLibLastRuntimeRange = Index;
      //
      // Convert the physical address to a virtual address and return the virtual address
      //
      return (Address & 0x00000fff) + mDxeRuntimePciExpressLibRegistrationTable[Index].VirtualAddress;
    }
  }
 
  //
  // No match was found.  This is a critical error at OS runtime, so ASSERT() and force a breakpoint.
  //
  CpuBreakpoint ();
 
  //
  // Return the physical address
  //
  return Address;
}
 
RETURN_STATUS
EFIAPI
PciExpressRegisterForRuntimeAccess (
  IN UINTN  Address
  )
{
  EFI_STATUS                       Status;
  EFI_GCD_MEMORY_SPACE_DESCRIPTOR  Descriptor;
  UINTN                            Index;
  VOID                             *NewTable;
 
  //
  // Return an error if this function is called after ExitBootServices().
  //
  if (EfiAtRuntime ()) {
    return RETURN_UNSUPPORTED;
  }
 
  //
  // Make sure Address is valid
  //
  ASSERT_INVALID_PCI_ADDRESS (Address);
 
  //
  // Make sure the Address is in MMCONF address space
  //
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return RETURN_UNSUPPORTED;
  }
 
  //
  // Convert Address to a physical address in the MMIO PCI Express range
  // at the beginning of the PCI Configuration header for the specified
  // PCI Bus/Dev/Func
  //
  Address = GetPciExpressAddress (Address & 0x0ffff000);
 
  //
  // See if Address has already been registered for runtime access
  //
  for (Index = 0; Index < mDxeRuntimePciExpressLibNumberOfRuntimeRanges; Index++) {
    if (mDxeRuntimePciExpressLibRegistrationTable[Index].PhysicalAddress == Address) {
      return RETURN_SUCCESS;
    }
  }
 
  //
  // Get the GCD Memory Descriptor for the PCI Express Bus/Dev/Func specified by Address
  //
  Status = gDS->GetMemorySpaceDescriptor (Address, &Descriptor);
  if (EFI_ERROR (Status)) {
    return RETURN_UNSUPPORTED;
  }
 
  //
  // Mark the 4KB region for the PCI Express Bus/Dev/Func as EFI_RUNTIME_MEMORY so the OS
  // will allocate a virtual address range for the 4KB PCI Configuration Header.
  //
  Status = gDS->SetMemorySpaceAttributes (Address, 0x1000, Descriptor.Attributes | EFI_MEMORY_RUNTIME);
  if (EFI_ERROR (Status)) {
    return RETURN_UNSUPPORTED;
  }
 
  //
  // Grow the size of the registration table
  //
  NewTable = ReallocateRuntimePool (
               (mDxeRuntimePciExpressLibNumberOfRuntimeRanges + 0) * sizeof (PCI_EXPRESS_RUNTIME_REGISTRATION_TABLE),
               (mDxeRuntimePciExpressLibNumberOfRuntimeRanges + 1) * sizeof (PCI_EXPRESS_RUNTIME_REGISTRATION_TABLE),
               mDxeRuntimePciExpressLibRegistrationTable
               );
  if (NewTable == NULL) {
    return RETURN_OUT_OF_RESOURCES;
  }
 
  mDxeRuntimePciExpressLibRegistrationTable                                                                = NewTable;
  mDxeRuntimePciExpressLibRegistrationTable[mDxeRuntimePciExpressLibNumberOfRuntimeRanges].PhysicalAddress = Address;
  mDxeRuntimePciExpressLibRegistrationTable[mDxeRuntimePciExpressLibNumberOfRuntimeRanges].VirtualAddress  = Address;
  mDxeRuntimePciExpressLibNumberOfRuntimeRanges++;
 
  return RETURN_SUCCESS;
}
 
UINT8
EFIAPI
PciExpressRead8 (
  IN      UINTN  Address
  )
{
  ASSERT_INVALID_PCI_ADDRESS (Address);
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT8)-1;
  }
 
  return MmioRead8 (GetPciExpressAddress (Address));
}
 
UINT8
EFIAPI
PciExpressWrite8 (
  IN      UINTN  Address,
  IN      UINT8  Value
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT8)-1;
  }
 
  return MmioWrite8 (GetPciExpressAddress (Address), Value);
}
 
UINT8
EFIAPI
PciExpressOr8 (
  IN      UINTN  Address,
  IN      UINT8  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT8)-1;
  }
 
  return MmioOr8 (GetPciExpressAddress (Address), OrData);
}
 
UINT8
EFIAPI
PciExpressAnd8 (
  IN      UINTN  Address,
  IN      UINT8  AndData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT8)-1;
  }
 
  return MmioAnd8 (GetPciExpressAddress (Address), AndData);
}
 
UINT8
EFIAPI
PciExpressAndThenOr8 (
  IN      UINTN  Address,
  IN      UINT8  AndData,
  IN      UINT8  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT8)-1;
  }
 
  return MmioAndThenOr8 (
           GetPciExpressAddress (Address),
           AndData,
           OrData
           );
}
 
UINT8
EFIAPI
PciExpressBitFieldRead8 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT8)-1;
  }
 
  return MmioBitFieldRead8 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit
           );
}
 
UINT8
EFIAPI
PciExpressBitFieldWrite8 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  Value
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT8)-1;
  }
 
  return MmioBitFieldWrite8 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           Value
           );
}
 
UINT8
EFIAPI
PciExpressBitFieldOr8 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT8)-1;
  }
 
  return MmioBitFieldOr8 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           OrData
           );
}
 
UINT8
EFIAPI
PciExpressBitFieldAnd8 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  AndData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT8)-1;
  }
 
  return MmioBitFieldAnd8 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           AndData
           );
}
 
UINT8
EFIAPI
PciExpressBitFieldAndThenOr8 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit,
  IN      UINT8  AndData,
  IN      UINT8  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT8)-1;
  }
 
  return MmioBitFieldAndThenOr8 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           AndData,
           OrData
           );
}
 
UINT16
EFIAPI
PciExpressRead16 (
  IN      UINTN  Address
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT16)-1;
  }
 
  return MmioRead16 (GetPciExpressAddress (Address));
}
 
UINT16
EFIAPI
PciExpressWrite16 (
  IN      UINTN   Address,
  IN      UINT16  Value
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT16)-1;
  }
 
  return MmioWrite16 (GetPciExpressAddress (Address), Value);
}
 
UINT16
EFIAPI
PciExpressOr16 (
  IN      UINTN   Address,
  IN      UINT16  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT16)-1;
  }
 
  return MmioOr16 (GetPciExpressAddress (Address), OrData);
}
 
UINT16
EFIAPI
PciExpressAnd16 (
  IN      UINTN   Address,
  IN      UINT16  AndData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT16)-1;
  }
 
  return MmioAnd16 (GetPciExpressAddress (Address), AndData);
}
 
UINT16
EFIAPI
PciExpressAndThenOr16 (
  IN      UINTN   Address,
  IN      UINT16  AndData,
  IN      UINT16  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT16)-1;
  }
 
  return MmioAndThenOr16 (
           GetPciExpressAddress (Address),
           AndData,
           OrData
           );
}
 
UINT16
EFIAPI
PciExpressBitFieldRead16 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT16)-1;
  }
 
  return MmioBitFieldRead16 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit
           );
}
 
UINT16
EFIAPI
PciExpressBitFieldWrite16 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  Value
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT16)-1;
  }
 
  return MmioBitFieldWrite16 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           Value
           );
}
 
UINT16
EFIAPI
PciExpressBitFieldOr16 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT16)-1;
  }
 
  return MmioBitFieldOr16 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           OrData
           );
}
 
UINT16
EFIAPI
PciExpressBitFieldAnd16 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  AndData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT16)-1;
  }
 
  return MmioBitFieldAnd16 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           AndData
           );
}
 
UINT16
EFIAPI
PciExpressBitFieldAndThenOr16 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT16  AndData,
  IN      UINT16  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT16)-1;
  }
 
  return MmioBitFieldAndThenOr16 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           AndData,
           OrData
           );
}
 
UINT32
EFIAPI
PciExpressRead32 (
  IN      UINTN  Address
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT32)-1;
  }
 
  return MmioRead32 (GetPciExpressAddress (Address));
}
 
UINT32
EFIAPI
PciExpressWrite32 (
  IN      UINTN   Address,
  IN      UINT32  Value
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT32)-1;
  }
 
  return MmioWrite32 (GetPciExpressAddress (Address), Value);
}
 
UINT32
EFIAPI
PciExpressOr32 (
  IN      UINTN   Address,
  IN      UINT32  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT32)-1;
  }
 
  return MmioOr32 (GetPciExpressAddress (Address), OrData);
}
 
UINT32
EFIAPI
PciExpressAnd32 (
  IN      UINTN   Address,
  IN      UINT32  AndData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT32)-1;
  }
 
  return MmioAnd32 (GetPciExpressAddress (Address), AndData);
}
 
UINT32
EFIAPI
PciExpressAndThenOr32 (
  IN      UINTN   Address,
  IN      UINT32  AndData,
  IN      UINT32  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT32)-1;
  }
 
  return MmioAndThenOr32 (
           GetPciExpressAddress (Address),
           AndData,
           OrData
           );
}
 
UINT32
EFIAPI
PciExpressBitFieldRead32 (
  IN      UINTN  Address,
  IN      UINTN  StartBit,
  IN      UINTN  EndBit
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT32)-1;
  }
 
  return MmioBitFieldRead32 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit
           );
}
 
UINT32
EFIAPI
PciExpressBitFieldWrite32 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  Value
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT32)-1;
  }
 
  return MmioBitFieldWrite32 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           Value
           );
}
 
UINT32
EFIAPI
PciExpressBitFieldOr32 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT32)-1;
  }
 
  return MmioBitFieldOr32 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           OrData
           );
}
 
UINT32
EFIAPI
PciExpressBitFieldAnd32 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  AndData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT32)-1;
  }
 
  return MmioBitFieldAnd32 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           AndData
           );
}
 
UINT32
EFIAPI
PciExpressBitFieldAndThenOr32 (
  IN      UINTN   Address,
  IN      UINTN   StartBit,
  IN      UINTN   EndBit,
  IN      UINT32  AndData,
  IN      UINT32  OrData
  )
{
  if (Address >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINT32)-1;
  }
 
  return MmioBitFieldAndThenOr32 (
           GetPciExpressAddress (Address),
           StartBit,
           EndBit,
           AndData,
           OrData
           );
}
 
UINTN
EFIAPI
PciExpressReadBuffer (
  IN      UINTN  StartAddress,
  IN      UINTN  Size,
  OUT     VOID   *Buffer
  )
{
  UINTN  ReturnValue;
 
  //
  // Make sure Address is valid
  //
  ASSERT_INVALID_PCI_ADDRESS (StartAddress);
  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
 
  //
  // Make sure the Address is in MMCONF address space
  //
  if (StartAddress >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINTN)-1;
  }
 
  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;
 
  //
  // Make sure Address is valid
  //
  ASSERT_INVALID_PCI_ADDRESS (StartAddress);
  ASSERT (((StartAddress & 0xFFF) + Size) <= 0x1000);
 
  //
  // Make sure the Address is in MMCONF address space
  //
  if (StartAddress >= mDxeRuntimePciExpressLibPciExpressBaseSize) {
    return (UINTN)-1;
  }
 
  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;
}