ExtraRootBusMap.c

Go to the documentation of this file.

 
#include <Library/DebugLib.h>
#include <Library/DevicePathLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/OrderedCollectionLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Protocol/DevicePath.h>
#include <Protocol/PciRootBridgeIo.h>
 
#include "ExtraRootBusMap.h"
 
//
// The BusNumbers field is an array with Count elements. The elements increase
// strictry monotonically. Zero is not an element (because the zero bus number
// belongs to the "main" root bus, never to an extra root bus). Offset N in the
// array maps the extra root bus with position (N+1) to its bus number (because
// the root bus with position 0 is always the main root bus, therefore we don't
// store it).
//
// If there are no extra root buses in the system, then Count is 0, and
// BusNumbers is NULL.
//
struct EXTRA_ROOT_BUS_MAP_STRUCT {
  UINT32    *BusNumbers;
  UINTN     Count;
};
 
STATIC
INTN
EFIAPI
RootBridgePathCompare (
  IN CONST VOID  *UserStruct1,
  IN CONST VOID  *UserStruct2
  )
{
  CONST ACPI_HID_DEVICE_PATH  *Acpi1;
  CONST ACPI_HID_DEVICE_PATH  *Acpi2;
 
  Acpi1 = UserStruct1;
  Acpi2 = UserStruct2;
 
  return Acpi1->UID < Acpi2->UID ? -1 :
         Acpi1->UID > Acpi2->UID ?  1 :
         0;
}
 
STATIC
INTN
EFIAPI
RootBridgePathKeyCompare (
  IN CONST VOID  *StandaloneKey,
  IN CONST VOID  *UserStruct
  )
{
  CONST UINT32                *Uid;
  CONST ACPI_HID_DEVICE_PATH  *Acpi;
 
  Uid  = StandaloneKey;
  Acpi = UserStruct;
 
  return *Uid < Acpi->UID ? -1 :
         *Uid > Acpi->UID ?  1 :
         0;
}
 
EFI_STATUS
CreateExtraRootBusMap (
  OUT EXTRA_ROOT_BUS_MAP  **ExtraRootBusMap
  )
{
  EFI_STATUS                Status;
  UINTN                     NumHandles;
  EFI_HANDLE                *Handles;
  ORDERED_COLLECTION        *Collection;
  EXTRA_ROOT_BUS_MAP        *Map;
  UINTN                     Idx;
  ORDERED_COLLECTION_ENTRY  *Entry, *Entry2;
 
  //
  // Handles and Collection are temporary / helper variables, while in Map we
  // build the return value.
  //
 
  Status = gBS->LocateHandleBuffer (
                  ByProtocol,
                  &gEfiPciRootBridgeIoProtocolGuid,
                  NULL /* SearchKey */,
                  &NumHandles,
                  &Handles
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Collection = OrderedCollectionInit (
                 RootBridgePathCompare,
                 RootBridgePathKeyCompare
                 );
  if (Collection == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto FreeHandles;
  }
 
  Map = AllocateZeroPool (sizeof *Map);
  if (Map == NULL) {
    Status = EFI_OUT_OF_RESOURCES;
    goto FreeCollection;
  }
 
  //
  // Collect the ACPI device path protocols of the root bridges.
  //
  for (Idx = 0; Idx < NumHandles; ++Idx) {
    EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 
    Status = gBS->HandleProtocol (
                    Handles[Idx],
                    &gEfiDevicePathProtocolGuid,
                    (VOID **)&DevicePath
                    );
    if (EFI_ERROR (Status)) {
      goto FreeMap;
    }
 
    //
    // Examine if the device path is an ACPI HID one, and if so, if UID is
    // nonzero (ie. the root bridge that the bus number belongs to is "extra",
    // not the main one). In that case, link the device path into Collection.
    //
    if ((DevicePathType (DevicePath) == ACPI_DEVICE_PATH) &&
        (DevicePathSubType (DevicePath) == ACPI_DP) &&
        (((ACPI_HID_DEVICE_PATH *)DevicePath)->HID == EISA_PNP_ID (0x0A03)) &&
        (((ACPI_HID_DEVICE_PATH *)DevicePath)->UID > 0))
    {
      Status = OrderedCollectionInsert (Collection, NULL, DevicePath);
      if (EFI_ERROR (Status)) {
        goto FreeMap;
      }
 
      ++Map->Count;
    }
  }
 
  if (Map->Count > 0) {
    //
    // At least one extra PCI root bus exists.
    //
    Map->BusNumbers = AllocatePool (Map->Count * sizeof *Map->BusNumbers);
    if (Map->BusNumbers == NULL) {
      Status = EFI_OUT_OF_RESOURCES;
      goto FreeMap;
    }
  }
 
  //
  // Now collect the bus numbers of the extra PCI root buses into Map.
  //
  Idx   = 0;
  Entry = OrderedCollectionMin (Collection);
  while (Idx < Map->Count) {
    ACPI_HID_DEVICE_PATH  *Acpi;
 
    ASSERT (Entry != NULL);
    Acpi                 = OrderedCollectionUserStruct (Entry);
    Map->BusNumbers[Idx] = Acpi->UID;
    DEBUG ((
      DEBUG_VERBOSE,
      "%a: extra bus position 0x%Lx maps to bus number (UID) 0x%x\n",
      __func__,
      (UINT64)(Idx + 1),
      Acpi->UID
      ));
    ++Idx;
    Entry = OrderedCollectionNext (Entry);
  }
 
  ASSERT (Entry == NULL);
 
  *ExtraRootBusMap = Map;
  Status           = EFI_SUCCESS;
 
  //
  // Fall through in order to release temporaries.
  //
 
FreeMap:
  if (EFI_ERROR (Status)) {
    if (Map->BusNumbers != NULL) {
      FreePool (Map->BusNumbers);
    }
 
    FreePool (Map);
  }
 
FreeCollection:
  for (Entry = OrderedCollectionMin (Collection); Entry != NULL;
       Entry = Entry2)
  {
    Entry2 = OrderedCollectionNext (Entry);
    OrderedCollectionDelete (Collection, Entry, NULL);
  }
 
  OrderedCollectionUninit (Collection);
 
FreeHandles:
  FreePool (Handles);
 
  return Status;
}
 
VOID
DestroyExtraRootBusMap (
  IN EXTRA_ROOT_BUS_MAP  *ExtraRootBusMap
  )
{
  if (ExtraRootBusMap->BusNumbers != NULL) {
    FreePool (ExtraRootBusMap->BusNumbers);
  }
 
  FreePool (ExtraRootBusMap);
}
 
EFI_STATUS
MapRootBusPosToBusNr (
  IN  CONST EXTRA_ROOT_BUS_MAP  *ExtraRootBusMap,
  IN  UINT64                    RootBusPos,
  OUT UINT32                    *RootBusNr
  )
{
  if (RootBusPos == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (RootBusPos > ExtraRootBusMap->Count) {
    return EFI_NOT_FOUND;
  }
 
  *RootBusNr = ExtraRootBusMap->BusNumbers[(UINTN)RootBusPos - 1];
  return EFI_SUCCESS;
}