PciHotPlugSupport.c

Go to the documentation of this file.

 
#include "PciBus.h"
 
EFI_PCI_HOT_PLUG_INIT_PROTOCOL  *gPciHotPlugInit = NULL;
EFI_HPC_LOCATION                *gPciRootHpcPool = NULL;
UINTN                           gPciRootHpcCount = 0;
ROOT_HPC_DATA                   *gPciRootHpcData = NULL;
 
VOID
EFIAPI
PciHPCInitialized (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  ROOT_HPC_DATA  *HpcData;
 
  HpcData              = (ROOT_HPC_DATA *)Context;
  HpcData->Initialized = TRUE;
}
 
BOOLEAN
EfiCompareDevicePath (
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath1,
  IN EFI_DEVICE_PATH_PROTOCOL  *DevicePath2
  )
{
  UINTN  Size1;
  UINTN  Size2;
 
  Size1 = GetDevicePathSize (DevicePath1);
  Size2 = GetDevicePathSize (DevicePath2);
 
  if (Size1 != Size2) {
    return FALSE;
  }
 
  if (CompareMem (DevicePath1, DevicePath2, Size1) != 0) {
    return FALSE;
  }
 
  return TRUE;
}
 
EFI_STATUS
InitializeHotPlugSupport (
  VOID
  )
{
  EFI_STATUS        Status;
  EFI_HPC_LOCATION  *HpcList;
  UINTN             HpcCount;
 
  //
  // Locate the PciHotPlugInit Protocol
  // If it doesn't exist, that means there is no
  // hot plug controller supported on the platform
  // the PCI Bus driver is running on. HotPlug Support
  // is an optional feature, so absence of the protocol
  // won't incur the penalty.
  //
  Status = gBS->LocateProtocol (
                  &gEfiPciHotPlugInitProtocolGuid,
                  NULL,
                  (VOID **)&gPciHotPlugInit
                  );
 
  if (EFI_ERROR (Status)) {
    return EFI_UNSUPPORTED;
  }
 
  Status = gPciHotPlugInit->GetRootHpcList (
                              gPciHotPlugInit,
                              &HpcCount,
                              &HpcList
                              );
 
  if (!EFI_ERROR (Status)) {
    gPciRootHpcPool  = HpcList;
    gPciRootHpcCount = HpcCount;
    gPciRootHpcData  = AllocateZeroPool (sizeof (ROOT_HPC_DATA) * gPciRootHpcCount);
    if (gPciRootHpcData == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
  }
 
  return EFI_SUCCESS;
}
 
BOOLEAN
IsRootPciHotPlugBus (
  IN  EFI_DEVICE_PATH_PROTOCOL  *HpbDevicePath,
  OUT UINTN                     *HpIndex    OPTIONAL
  )
{
  UINTN  Index;
 
  for (Index = 0; Index < gPciRootHpcCount; Index++) {
    if (EfiCompareDevicePath (gPciRootHpcPool[Index].HpbDevicePath, HpbDevicePath)) {
      if (HpIndex != NULL) {
        *HpIndex = Index;
      }
 
      return TRUE;
    }
  }
 
  return FALSE;
}
 
BOOLEAN
IsRootPciHotPlugController (
  IN EFI_DEVICE_PATH_PROTOCOL  *HpcDevicePath,
  OUT UINTN                    *HpIndex
  )
{
  UINTN  Index;
 
  for (Index = 0; Index < gPciRootHpcCount; Index++) {
    if (EfiCompareDevicePath (gPciRootHpcPool[Index].HpcDevicePath, HpcDevicePath)) {
      if (HpIndex != NULL) {
        *HpIndex = Index;
      }
 
      return TRUE;
    }
  }
 
  return FALSE;
}
 
EFI_STATUS
CreateEventForHpc (
  IN  UINTN      HpIndex,
  OUT EFI_EVENT  *Event
  )
{
  EFI_STATUS  Status;
 
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  PciHPCInitialized,
                  gPciRootHpcData + HpIndex,
                  &((gPciRootHpcData + HpIndex)->Event)
                  );
 
  if (!EFI_ERROR (Status)) {
    *Event = (gPciRootHpcData + HpIndex)->Event;
  }
 
  return Status;
}
 
EFI_STATUS
AllRootHPCInitialized (
  IN  UINTN  TimeoutInMicroSeconds
  )
{
  UINT32  Delay;
  UINTN   Index;
 
  Delay = (UINT32)((TimeoutInMicroSeconds / 30) + 1);
 
  do {
    for (Index = 0; Index < gPciRootHpcCount; Index++) {
      if (gPciRootHpcData[Index].Found && !gPciRootHpcData[Index].Initialized) {
        break;
      }
    }
 
    if (Index == gPciRootHpcCount) {
      return EFI_SUCCESS;
    }
 
    //
    // Stall for 30 microseconds..
    //
    gBS->Stall (30);
 
    Delay--;
  } while (Delay > 0);
 
  return EFI_TIMEOUT;
}
 
BOOLEAN
IsSHPC (
  IN PCI_IO_DEVICE  *PciIoDevice
  )
{
  EFI_STATUS  Status;
  UINT8       Offset;
 
  if (PciIoDevice == NULL) {
    return FALSE;
  }
 
  Offset = 0;
  Status = LocateCapabilityRegBlock (
             PciIoDevice,
             EFI_PCI_CAPABILITY_ID_SHPC,
             &Offset,
             NULL
             );
 
  //
  // If the PCI-PCI bridge has the hot plug controller build-in,
  // then return TRUE;
  //
  if (!EFI_ERROR (Status)) {
    return TRUE;
  }
 
  return FALSE;
}
 
BOOLEAN
SupportsPcieHotplug (
  IN PCI_IO_DEVICE  *PciIoDevice
  )
{
  UINT32                        Offset;
  EFI_STATUS                    Status;
  PCI_REG_PCIE_CAPABILITY       Capability;
  PCI_REG_PCIE_SLOT_CAPABILITY  SlotCapability;
 
  if (PciIoDevice == NULL) {
    return FALSE;
  }
 
  //
  // Read the PCI Express Capabilities Register
  //
  if (!PciIoDevice->IsPciExp) {
    return FALSE;
  }
 
  Offset = PciIoDevice->PciExpressCapabilityOffset +
           OFFSET_OF (PCI_CAPABILITY_PCIEXP, Capability);
  Status = PciIoDevice->PciIo.Pci.Read (
                                    &PciIoDevice->PciIo,
                                    EfiPciIoWidthUint16,
                                    Offset,
                                    1,
                                    &Capability
                                    );
  if (EFI_ERROR (Status)) {
    return FALSE;
  }
 
  //
  // Check the contents of the register
  //
  switch (Capability.Bits.DevicePortType) {
    case PCIE_DEVICE_PORT_TYPE_ROOT_PORT:
    case PCIE_DEVICE_PORT_TYPE_DOWNSTREAM_PORT:
      break;
    default:
      return FALSE;
  }
 
  if (!Capability.Bits.SlotImplemented) {
    return FALSE;
  }
 
  //
  // Read the Slot Capabilities Register
  //
  Offset = PciIoDevice->PciExpressCapabilityOffset +
           OFFSET_OF (PCI_CAPABILITY_PCIEXP, SlotCapability);
  Status = PciIoDevice->PciIo.Pci.Read (
                                    &PciIoDevice->PciIo,
                                    EfiPciIoWidthUint32,
                                    Offset,
                                    1,
                                    &SlotCapability
                                    );
  if (EFI_ERROR (Status)) {
    return FALSE;
  }
 
  //
  // Check the contents of the register
  //
  if (SlotCapability.Bits.HotPlugCapable) {
    return TRUE;
  }
 
  return FALSE;
}
 
VOID
GetResourcePaddingForHpb (
  IN PCI_IO_DEVICE  *PciIoDevice
  )
{
  EFI_STATUS                         Status;
  EFI_HPC_STATE                      State;
  UINT64                             PciAddress;
  EFI_HPC_PADDING_ATTRIBUTES         Attributes;
  EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR  *Descriptors;
 
  if (IsPciHotPlugBus (PciIoDevice)) {
    //
    // If PCI-PCI bridge device is PCI Hot Plug bus.
    //
    PciAddress = EFI_PCI_ADDRESS (PciIoDevice->BusNumber, PciIoDevice->DeviceNumber, PciIoDevice->FunctionNumber, 0);
    Status     = gPciHotPlugInit->GetResourcePadding (
                                    gPciHotPlugInit,
                                    PciIoDevice->DevicePath,
                                    PciAddress,
                                    &State,
                                    (VOID **)&Descriptors,
                                    &Attributes
                                    );
 
    if (EFI_ERROR (Status)) {
      return;
    }
 
    if (((State & EFI_HPC_STATE_ENABLED) != 0) && ((State & EFI_HPC_STATE_INITIALIZED) != 0)) {
      PciIoDevice->ResourcePaddingDescriptors = Descriptors;
      PciIoDevice->PaddingAttributes          = Attributes;
    }
 
    return;
  }
}
 
BOOLEAN
IsPciHotPlugBus (
  PCI_IO_DEVICE  *PciIoDevice
  )
{
  if (IsSHPC (PciIoDevice)) {
    //
    // If the PPB has the hot plug controller build-in,
    // then return TRUE;
    //
    return TRUE;
  }
 
  if (SupportsPcieHotplug (PciIoDevice)) {
    //
    // If the PPB is a PCIe root complex port or a switch downstream port, and
    // implements a hot-plug capable slot, then also return TRUE.
    //
    return TRUE;
  }
 
  //
  // Otherwise, see if it is a Root HPC
  //
  if (IsRootPciHotPlugBus (PciIoDevice->DevicePath, NULL)) {
    return TRUE;
  }
 
  return FALSE;
}