PciHotPlugInit.c

Go to the documentation of this file.

 
#include <IndustryStandard/Acpi10.h>
#include <IndustryStandard/Q35MchIch9.h>
#include <IndustryStandard/QemuPciBridgeCapabilities.h>
 
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/DevicePathLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/PciCapLib.h>
#include <Library/PciCapPciSegmentLib.h>
#include <Library/PciLib.h>
#include <Library/UefiBootServicesTableLib.h>
 
#include <Protocol/PciHotPlugInit.h>
#include <Protocol/PciRootBridgeIo.h>
 
//
// TRUE if the PCI platform supports extended config space, FALSE otherwise.
//
STATIC BOOLEAN  mPciExtConfSpaceSupported;
 
//
// The protocol interface this driver produces.
//
// Refer to 12.6 "PCI Hot Plug PCI Initialization Protocol" in the Platform
// Init 1.4a Spec, Volume 5.
//
STATIC EFI_PCI_HOT_PLUG_INIT_PROTOCOL  mPciHotPlugInit;
 
//
// Resource padding template for the GetResourcePadding() protocol member
// function.
//
// Refer to Table 8 "ACPI 2.0 & 3.0 QWORD Address Space Descriptor Usage" in
// the Platform Init 1.4a Spec, Volume 5.
//
// This structure is interpreted by the ApplyResourcePadding() function in the
// edk2 PCI Bus UEFI_DRIVER.
//
// We can request padding for at most four resource types, each of which is
// optional, independently of the others:
// (a) bus numbers,
// (b) IO space,
// (c) non-prefetchable MMIO space (32-bit only),
// (d) prefetchable MMIO space (either 32-bit or 64-bit, never both).
//
#pragma pack (1)
typedef struct {
  EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR    Padding[4];
  EFI_ACPI_END_TAG_DESCRIPTOR          EndDesc;
} RESOURCE_PADDING;
#pragma pack ()
 
STATIC
VOID
InitializeResourcePadding (
  OUT RESOURCE_PADDING  *ResourcePadding
  )
{
  UINTN  Index;
 
  ZeroMem (ResourcePadding, sizeof *ResourcePadding);
 
  //
  // Fill in the Padding fields that don't vary across resource types.
  //
  for (Index = 0; Index < ARRAY_SIZE (ResourcePadding->Padding); ++Index) {
    EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR  *Descriptor;
 
    Descriptor       = ResourcePadding->Padding + Index;
    Descriptor->Desc = ACPI_ADDRESS_SPACE_DESCRIPTOR;
    Descriptor->Len  = (UINT16)(
                                sizeof (EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR) -
                                OFFSET_OF (
                                  EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR,
                                  ResType
                                  )
                                );
  }
 
  //
  // Fill in the End Tag.
  //
  ResourcePadding->EndDesc.Desc = ACPI_END_TAG_DESCRIPTOR;
}
 
STATIC
VOID
SetIoPadding (
  IN OUT EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR  *Descriptor,
  IN     UINTN                              SizeExponent
  )
{
  Descriptor->ResType      = ACPI_ADDRESS_SPACE_TYPE_IO;
  Descriptor->AddrLen      = LShiftU64 (1, SizeExponent);
  Descriptor->AddrRangeMax = Descriptor->AddrLen - 1;
}
 
STATIC
VOID
SetMmioPadding (
  IN OUT EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR  *Descriptor,
  IN     BOOLEAN                            Prefetchable,
  IN     BOOLEAN                            ThirtyTwoBitOnly,
  IN     UINTN                              SizeExponent
  )
{
  Descriptor->ResType = ACPI_ADDRESS_SPACE_TYPE_MEM;
  if (Prefetchable) {
    Descriptor->SpecificFlag =
      EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_CACHEABLE_PREFETCHABLE;
    Descriptor->AddrSpaceGranularity = ThirtyTwoBitOnly ? 32 : 64;
  } else {
    Descriptor->SpecificFlag =
      EFI_ACPI_MEMORY_RESOURCE_SPECIFIC_FLAG_NON_CACHEABLE;
    Descriptor->AddrSpaceGranularity = 32;
  }
 
  Descriptor->AddrLen      = LShiftU64 (1, SizeExponent);
  Descriptor->AddrRangeMax = Descriptor->AddrLen - 1;
}
 
STATIC
INTN
HighBitSetRoundUp32 (
  IN UINT32  Operand
  )
{
  INTN  HighBit;
 
  HighBit = HighBitSet32 (Operand);
  if (HighBit == -1) {
    //
    // Operand is zero.
    //
    return HighBit;
  }
 
  if ((Operand & (Operand - 1)) != 0) {
    //
    // Operand is not a whole power of two.
    //
    ++HighBit;
  }
 
  return (HighBit < 32) ? HighBit : -1;
}
 
STATIC
INTN
HighBitSetRoundUp64 (
  IN UINT64  Operand
  )
{
  INTN  HighBit;
 
  HighBit = HighBitSet64 (Operand);
  if (HighBit == -1) {
    //
    // Operand is zero.
    //
    return HighBit;
  }
 
  if ((Operand & (Operand - 1)) != 0) {
    //
    // Operand is not a whole power of two.
    //
    ++HighBit;
  }
 
  return (HighBit < 64) ? HighBit : -1;
}
 
STATIC
EFI_STATUS
QueryReservationHint (
  IN  CONST EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS  *HpcPciAddress,
  OUT QEMU_PCI_BRIDGE_CAPABILITY_RESOURCE_RESERVATION    *ReservationHint
  )
{
  UINT16        PciVendorId;
  EFI_STATUS    Status;
  PCI_CAP_DEV   *PciDevice;
  PCI_CAP_LIST  *CapList;
  UINT16        VendorInstance;
  PCI_CAP       *VendorCap;
 
  //
  // Check the vendor identifier.
  //
  PciVendorId = PciRead16 (
                  PCI_LIB_ADDRESS (
                    HpcPciAddress->Bus,
                    HpcPciAddress->Device,
                    HpcPciAddress->Function,
                    PCI_VENDOR_ID_OFFSET
                    )
                  );
  if (PciVendorId != QEMU_PCI_BRIDGE_VENDOR_ID_REDHAT) {
    return EFI_NOT_FOUND;
  }
 
  //
  // Parse the capabilities lists.
  //
  Status = PciCapPciSegmentDeviceInit (
             mPciExtConfSpaceSupported ? PciCapExtended : PciCapNormal,
             0, // Segment
             HpcPciAddress->Bus,
             HpcPciAddress->Device,
             HpcPciAddress->Function,
             &PciDevice
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = PciCapListInit (PciDevice, &CapList);
  if (EFI_ERROR (Status)) {
    goto UninitPciDevice;
  }
 
  //
  // Scan the vendor capability instances for the Resource Reservation
  // capability.
  //
  VendorInstance = 0;
  for ( ; ;) {
    UINT8  VendorLength;
    UINT8  BridgeCapType;
 
    Status = PciCapListFindCap (
               CapList,
               PciCapNormal,
               EFI_PCI_CAPABILITY_ID_VENDOR,
               VendorInstance++,
               &VendorCap
               );
    if (EFI_ERROR (Status)) {
      goto UninitCapList;
    }
 
    //
    // Check the vendor capability length.
    //
    Status = PciCapRead (
               PciDevice,
               VendorCap,
               OFFSET_OF (EFI_PCI_CAPABILITY_VENDOR_HDR, Length),
               &VendorLength,
               sizeof VendorLength
               );
    if (EFI_ERROR (Status)) {
      goto UninitCapList;
    }
 
    if (VendorLength != sizeof *ReservationHint) {
      continue;
    }
 
    //
    // Check the vendor bridge capability type.
    //
    Status = PciCapRead (
               PciDevice,
               VendorCap,
               OFFSET_OF (QEMU_PCI_BRIDGE_CAPABILITY_HDR, Type),
               &BridgeCapType,
               sizeof BridgeCapType
               );
    if (EFI_ERROR (Status)) {
      goto UninitCapList;
    }
 
    if (BridgeCapType ==
        QEMU_PCI_BRIDGE_CAPABILITY_TYPE_RESOURCE_RESERVATION)
    {
      //
      // We have a match.
      //
      break;
    }
  }
 
  //
  // Populate ReservationHint.
  //
  Status = PciCapRead (
             PciDevice,
             VendorCap,
             0, // SourceOffsetInCap
             ReservationHint,
             sizeof *ReservationHint
             );
 
UninitCapList:
  PciCapListUninit (CapList);
 
UninitPciDevice:
  PciCapPciSegmentDeviceUninit (PciDevice);
 
  return Status;
}
 
STATIC
EFI_STATUS
EFIAPI
GetRootHpcList (
  IN  EFI_PCI_HOT_PLUG_INIT_PROTOCOL  *This,
  OUT UINTN                           *HpcCount,
  OUT EFI_HPC_LOCATION                **HpcList
  )
{
  if ((HpcCount == NULL) || (HpcList == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // There are no top-level (i.e., un-enumerable) hot-plug controllers in QEMU
  // that would require special initialization.
  //
  *HpcCount = 0;
  *HpcList  = NULL;
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
EFIAPI
InitializeRootHpc (
  IN  EFI_PCI_HOT_PLUG_INIT_PROTOCOL  *This,
  IN  EFI_DEVICE_PATH_PROTOCOL        *HpcDevicePath,
  IN  UINT64                          HpcPciAddress,
  IN  EFI_EVENT                       Event  OPTIONAL,
  OUT EFI_HPC_STATE                   *HpcState
  )
{
  //
  // This function should never be called, due to the information returned by
  // GetRootHpcList().
  //
  ASSERT (FALSE);
 
  if (HpcState == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  return EFI_UNSUPPORTED;
}
 
STATIC
EFI_STATUS
EFIAPI
GetResourcePadding (
  IN  EFI_PCI_HOT_PLUG_INIT_PROTOCOL  *This,
  IN  EFI_DEVICE_PATH_PROTOCOL        *HpcDevicePath,
  IN  UINT64                          HpcPciAddress,
  OUT EFI_HPC_STATE                   *HpcState,
  OUT VOID                            **Padding,
  OUT EFI_HPC_PADDING_ATTRIBUTES      *Attributes
  )
{
  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS      *Address;
  BOOLEAN                                          DefaultIo;
  BOOLEAN                                          DefaultMmio;
  BOOLEAN                                          DefaultPrefMmio;
  RESOURCE_PADDING                                 ReservationRequest;
  EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR                *FirstResource;
  EFI_STATUS                                       ReservationHintStatus;
  QEMU_PCI_BRIDGE_CAPABILITY_RESOURCE_RESERVATION  ReservationHint;
 
  Address = (EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS *)&HpcPciAddress;
 
  DEBUG_CODE_BEGIN ();
  CHAR16  *DevicePathString;
 
  DevicePathString = ConvertDevicePathToText (HpcDevicePath, FALSE, FALSE);
 
  DEBUG ((
    DEBUG_VERBOSE,
    "%a: Address=%02x:%02x.%x DevicePath=%s\n",
    __func__,
    Address->Bus,
    Address->Device,
    Address->Function,
    (DevicePathString == NULL) ? L"<unavailable>" : DevicePathString
    ));
 
  if (DevicePathString != NULL) {
    FreePool (DevicePathString);
  }
 
  DEBUG_CODE_END ();
 
  if ((HpcState == NULL) || (Padding == NULL) || (Attributes == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  DefaultIo       = FALSE;
  DefaultMmio     = TRUE;
  DefaultPrefMmio = TRUE;
 
  //
  // Init ReservationRequest, and point FirstResource one past the last
  // descriptor entry. We're going to build the entries backwards from
  // ReservationRequest.EndDesc.
  //
  InitializeResourcePadding (&ReservationRequest);
  FirstResource = ReservationRequest.Padding +
                  ARRAY_SIZE (ReservationRequest.Padding);
 
  //
  // Try to get the QEMU-specific Resource Reservation capability.
  //
  ReservationHintStatus = QueryReservationHint (Address, &ReservationHint);
  if (!EFI_ERROR (ReservationHintStatus)) {
    INTN  HighBit;
 
    DEBUG ((
      DEBUG_VERBOSE,
      "%a: BusNumbers=0x%x Io=0x%Lx NonPrefetchable32BitMmio=0x%x\n"
      "%a: Prefetchable32BitMmio=0x%x Prefetchable64BitMmio=0x%Lx\n",
      __func__,
      ReservationHint.BusNumbers,
      ReservationHint.Io,
      ReservationHint.NonPrefetchable32BitMmio,
      __func__,
      ReservationHint.Prefetchable32BitMmio,
      ReservationHint.Prefetchable64BitMmio
      ));
 
    //
    // (a) Reserve bus numbers.
    //
    switch (ReservationHint.BusNumbers) {
      case 0:
        //
        // No reservation needed.
        //
        break;
      case MAX_UINT32:
        //
        // Firmware default (unspecified). Treat it as "no reservation needed".
        //
        break;
      default:
        //
        // Request the specified amount.
        //
        --FirstResource;
        FirstResource->ResType = ACPI_ADDRESS_SPACE_TYPE_BUS;
        FirstResource->AddrLen = ReservationHint.BusNumbers;
        break;
    }
 
    //
    // (b) Reserve IO space.
    //
    switch (ReservationHint.Io) {
      case 0:
        //
        // No reservation needed, disable our built-in.
        //
        DefaultIo = FALSE;
        break;
      case MAX_UINT64:
        //
        // Firmware default (unspecified). Stick with our built-in.
        //
        break;
      default:
        //
        // Round the specified amount up to the next power of two. If rounding is
        // successful, reserve the rounded value. Fall back to the default
        // otherwise.
        //
        HighBit = HighBitSetRoundUp64 (ReservationHint.Io);
        if (HighBit != -1) {
          SetIoPadding (--FirstResource, (UINTN)HighBit);
          DefaultIo = FALSE;
        }
 
        break;
    }
 
    //
    // (c) Reserve non-prefetchable MMIO space (32-bit only).
    //
    switch (ReservationHint.NonPrefetchable32BitMmio) {
      case 0:
        //
        // No reservation needed, disable our built-in.
        //
        DefaultMmio = FALSE;
        break;
      case MAX_UINT32:
        //
        // Firmware default (unspecified). Stick with our built-in.
        //
        break;
      default:
        //
        // Round the specified amount up to the next power of two. If rounding is
        // successful, reserve the rounded value. Fall back to the default
        // otherwise.
        //
        HighBit = HighBitSetRoundUp32 (ReservationHint.NonPrefetchable32BitMmio);
        if (HighBit != -1) {
          SetMmioPadding (--FirstResource, FALSE, TRUE, (UINTN)HighBit);
          DefaultMmio = FALSE;
        }
 
        break;
    }
 
    //
    // (d) Reserve prefetchable MMIO space (either 32-bit or 64-bit, never
    // both).
    //
    // For either space, we treat 0 as "no reservation needed", and the maximum
    // value as "firmware default". The latter is unspecified, and we interpret
    // it as the former.
    //
    // Otherwise, round the specified amount up to the next power of two. If
    // rounding is successful, reserve the rounded value. Do not reserve
    // prefetchable MMIO space otherwise.
    //
    if ((ReservationHint.Prefetchable32BitMmio > 0) &&
        (ReservationHint.Prefetchable32BitMmio < MAX_UINT32))
    {
      HighBit = HighBitSetRoundUp32 (ReservationHint.Prefetchable32BitMmio);
      if (HighBit != -1) {
        SetMmioPadding (--FirstResource, TRUE, TRUE, (UINTN)HighBit);
        DefaultPrefMmio = FALSE;
      }
    } else if ((ReservationHint.Prefetchable64BitMmio > 0) &&
               (ReservationHint.Prefetchable64BitMmio < MAX_UINT64))
    {
      HighBit = HighBitSetRoundUp64 (ReservationHint.Prefetchable64BitMmio);
      if (HighBit != -1) {
        SetMmioPadding (--FirstResource, TRUE, FALSE, (UINTN)HighBit);
        DefaultPrefMmio = FALSE;
      }
    }
  }
 
  if (DefaultIo) {
    //
    // Request defaults.
    //
    SetIoPadding (--FirstResource, (UINTN)HighBitSetRoundUp64 (0x1000));
  }
 
  if (DefaultMmio) {
    //
    // Request defaults.
    //
    SetMmioPadding (
      --FirstResource,
      FALSE,
      TRUE,
      (UINTN)HighBitSetRoundUp32 (SIZE_2MB)
      );
  }
 
  if (DefaultPrefMmio) {
    UINT64  Pci64Size = PcdGet64 (PcdPciMmio64Size);
 
    if (Pci64Size > SIZE_32GB) {
      SetMmioPadding (
        --FirstResource,
        TRUE,
        FALSE,
        (UINTN)HighBitSetRoundUp64 (RShiftU64 (Pci64Size, 8))
        );
    }
  }
 
  //
  // Output a copy of ReservationRequest from the lowest-address populated
  // entry until the end of the structure (including
  // ReservationRequest.EndDesc). If no reservations are necessary, we'll only
  // output the End Tag.
  //
  *Padding = AllocateCopyPool (
               (UINT8 *)(&ReservationRequest + 1) - (UINT8 *)FirstResource,
               FirstResource
               );
  if (*Padding == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Resource padding is required.
  //
  *HpcState = EFI_HPC_STATE_INITIALIZED | EFI_HPC_STATE_ENABLED;
 
  //
  // The padding should be applied at PCI bus level, and considered by upstream
  // bridges, recursively.
  //
  *Attributes = EfiPaddingPciBus;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
DriverInitialize (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  mPciExtConfSpaceSupported = (PcdGet16 (PcdOvmfHostBridgePciDevId) ==
                               INTEL_Q35_MCH_DEVICE_ID);
  mPciHotPlugInit.GetRootHpcList     = GetRootHpcList;
  mPciHotPlugInit.InitializeRootHpc  = InitializeRootHpc;
  mPciHotPlugInit.GetResourcePadding = GetResourcePadding;
  Status                             = gBS->InstallMultipleProtocolInterfaces (
                                              &ImageHandle,
                                              &gEfiPciHotPlugInitProtocolGuid,
                                              &mPciHotPlugInit,
                                              NULL
                                              );
  return Status;
}