OvmfPkg/Library/HardwareInfoLib/HardwareInfoPciHostBridgeLib.c - third_party/edk2 - Git at Google

 /**@file
   Hardware info library with types and accessors to parse information about
   PCI host bridges.

   Copyright 2021 - 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   SPDX-License-Identifier: BSD-2-Clause-Patent

 **/

 #include <Library/DebugLib.h>

 #include "HardwareInfoPciHostBridgeLib.h"

 #define IS_RANGE_INVALID(Start, Size, MaxValue)  (Start >= MaxValue || Size == 0)

 /**
   Calculate the last (inclusive) address of a range.

   @param[in] Start  First address of the range
   @param[in] Size   Size of the range
   @return Last address of the range
 **/
 STATIC
 UINT64
 GetRangeEnd (
   IN  UINT64  Start,
   IN  UINT64  Size,
   IN  UINT64  MaxValue
   )
 {
   if (IS_RANGE_INVALID (Start, Size, MaxValue)) {
     return 0;
   }

   return Start + Size - 1;
 }

 /**
   Internal helper to update LastAddress if the Limit address
   of the Mem aperture is higher than the provided value.

   @param[in]  Mem           Pointer to aperture whose limit is
                             to be compared against accumulative
                             last address.
   @param[out] LastAddress   Pointer to accumulative last address
                             to be updated if Limit is higher
 **/
 STATIC
 VOID
 UpdateLastAddressIfHigher (
   IN  PCI_ROOT_BRIDGE_APERTURE  *Mem,
   OUT UINT64                    *LastAddress
   )
 {
   if (Mem->Limit > *LastAddress) {
     *LastAddress = Mem->Limit;
   }
 }

 EFI_STATUS
 HardwareInfoPciHostBridgeLastMmioAddress (
   IN CONST  HOST_BRIDGE_INFO  *HostBridge,
   IN        UINTN             DataSize,
   IN        BOOLEAN           HighMem,
   OUT       UINT64            *LastMmioAddress
   )
 {
   EFI_STATUS                Status;
   PCI_ROOT_BRIDGE_APERTURE  Mem;
   PCI_ROOT_BRIDGE_APERTURE  MemAbove4G;
   PCI_ROOT_BRIDGE_APERTURE  PMem;
   PCI_ROOT_BRIDGE_APERTURE  PMemAbove4G;

   if (LastMmioAddress == NULL) {
     return EFI_INVALID_PARAMETER;
   }

   //
   // Set the output to the lowest possible value so that if some step fails
   // the overall outcome reflects no information found
   //
   *LastMmioAddress = 0;

   Status = HardwareInfoPciHostBridgeGetApertures (
              HostBridge,
              DataSize,
              NULL,
              &Mem,
              &MemAbove4G,
              &PMem,
              &PMemAbove4G,
              NULL
              );

   //
   // Forward error to caller but ignore warnings given that, very likely,
   // the host bridge will have a PIO aperture we are explicitly
   // ignoring here since we care only about MMIO resources.
   //
   if (EFI_ERROR (Status)) {
     return Status;
   }

   if (HighMem) {
     UpdateLastAddressIfHigher (&MemAbove4G, LastMmioAddress);
     UpdateLastAddressIfHigher (&PMemAbove4G, LastMmioAddress);
   } else {
     UpdateLastAddressIfHigher (&Mem, LastMmioAddress);
     UpdateLastAddressIfHigher (&PMem, LastMmioAddress);
   }

   return EFI_SUCCESS;
 }

 /**
   Set the boundaries of an aperture to invalid values having
   size zero and start MaxValue (yields Start > Limit which
   depicts an invalid range)

   @param[in]  MaxValue    Max value of the aperture's range (depends
                           on the data type)
   @param[out] Aperture    Aperture object to invalidate
 **/
 STATIC
 VOID
 InvalidateRootBridgeAperture (
   OUT PCI_ROOT_BRIDGE_APERTURE  *Aperture
   )
 {
   if (Aperture == NULL) {
     return;
   }

   Aperture->Base  = MAX_UINT64;
   Aperture->Limit = 0;
 }

 /**
   Fill a PCI ROOT BRIDGE APERTURE with the proper values calculated
   from the provided start and size.

   @param[in]  Start       Start address of the aperture
   @param[in]  Size        Size, in bytes, of the aperture
   @param[in]  MaxValue    Max value a valid address could take and which
                           represents an invalid start address.
   @param[out] Aperture    Pointer to the aperture to be filled

   @retval EFI_SUCCESS                 Aperture was filled successfully
   @retval EFI_INVALID_PARAMETER       Range depicted by Start and Size is
                                       valid but ignored because aperture
                                       pointer is NULL
   @retval EFI_WARN_BUFFER_TOO_SMALL   Aperture pointer is invalid but the
                                       range also is so no harm.
 **/
 STATIC
 EFI_STATUS
 FillHostBridgeAperture (
   IN  UINT64                    Start,
   IN  UINT64                    Size,
   IN  UINT64                    MaxValue,
   OUT PCI_ROOT_BRIDGE_APERTURE  *Aperture
   )
 {
   UINT64  End;

   End = GetRangeEnd (Start, Size, MaxValue);

   if (Aperture == NULL) {
     if (!IS_RANGE_INVALID (Start, Size, MaxValue)) {
       //
       // Report an error to the caller since the range specified in
       // the host bridge's resources is non-empty but the provided
       // aperture pointer is null, thus the valid range is ignored.
       //
       return EFI_INVALID_PARAMETER;
     }

     return EFI_WARN_BUFFER_TOO_SMALL;
   }

   if (IS_RANGE_INVALID (Start, Size, MaxValue)) {
     //
     // Fill Aperture with invalid range values to signal the
     // absence of an address space (empty range)
     //
     InvalidateRootBridgeAperture (Aperture);
   } else {
     Aperture->Base  = Start;
     Aperture->Limit = End;
   }

   return EFI_SUCCESS;
 }

 /**
   Merge 2 ranges (normal and prefetchable) into a single aperture
   comprehending the addresses encompassed by both of them. If both
   ranges are not empty they must be contiguous for correctness.

   @param[in]  Start       Range start address
   @param[in]  Size        Range size in bytes
   @param[in]  PStart      Prefetchable range start address
   @param[in]  PSize       Prefetchable range size in bytes
   @param[in]  MaxValue    Max value a valid address could take and which
                           represents an invalid start address.
   @param[out] Aperture    Pointer to the aperture to be filled

   @retval EFI_SUCCESS                 Aperture was filled successfully
   @retval EFI_INVALID_PARAMETER       Either range depicted by Start, Size
                                       or PStart, PSize or both are valid
                                       but ignored because aperture pointer
                                       is NULL
   @retval EFI_WARN_BUFFER_TOO_SMALL   Aperture pointer is invalid but both
                                       ranges are too so no harm.
 **/
 STATIC
 EFI_STATUS
 MergeHostBridgeApertures (
   IN  UINT64                    Start,
   IN  UINT64                    Size,
   IN  UINT64                    PStart,
   IN  UINT64                    PSize,
   IN  UINT64                    MaxValue,
   OUT PCI_ROOT_BRIDGE_APERTURE  *Aperture
   )
 {
   UINT64  PEnd;

   if (Aperture == NULL) {
     if (!IS_RANGE_INVALID (Start, Size, MaxValue) ||
         !IS_RANGE_INVALID (PStart, PSize, MaxValue))
     {
       //
       // Report an error to the caller since the range specified in
       // the host bridge's resources is non-empty but the provided
       // aperture pointer is null, thus the valid range is ignored.
       //
       return EFI_INVALID_PARAMETER;
     }

     return EFI_WARN_BUFFER_TOO_SMALL;
   }

   //
   // Start from an empty range (Limit < Base)
   //
   InvalidateRootBridgeAperture (Aperture);

   if (!IS_RANGE_INVALID (Start, Size, MaxValue)) {
     Aperture->Base  = Start;
     Aperture->Limit = Start + Size - 1;
   }

   if (!IS_RANGE_INVALID (PStart, PSize, MaxValue)) {
     PEnd = PStart + PSize - 1;

     if (PStart < Aperture->Base) {
       Aperture->Base = PStart;
     }

     if (PEnd > Aperture->Limit) {
       Aperture->Limit = PEnd;
     }
   }

   return EFI_SUCCESS;
 }

 EFI_STATUS
 HardwareInfoPciHostBridgeGetBusNrRange (
   IN CONST  HOST_BRIDGE_INFO  *HostBridge,
   IN        UINTN             DataSize,
   OUT       UINTN             *BusNrStart,
   OUT       UINTN             *BusNrLast
   )
 {
   if ((HostBridge == NULL) || (DataSize == 0) ||
       (BusNrStart == NULL) || (BusNrLast == NULL))
   {
     return EFI_INVALID_PARAMETER;
   }

   //
   // For now only version 0 is supported
   //
   if (HostBridge->Version != 0) {
     return EFI_INCOMPATIBLE_VERSION;
   }

   *BusNrStart = HostBridge->BusNrStart;
   *BusNrLast  = HostBridge->BusNrLast;

   return EFI_SUCCESS;
 }

 EFI_STATUS
 HardwareInfoPciHostBridgeGetApertures (
   IN CONST  HOST_BRIDGE_INFO          *HostBridge,
   IN        UINTN                     DataSize,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *Io,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *Mem,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *MemAbove4G,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *PMem,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *PMemAbove4G,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *PcieConfig
   )
 {
   EFI_STATUS  Status;
   BOOLEAN     StickyError;

   StickyError = FALSE;
   if ((HostBridge == NULL) || (DataSize == 0)) {
     return EFI_INVALID_PARAMETER;
   }

   //
   // For now only version 0 is supported
   //
   if (HostBridge->Version != 0) {
     return EFI_INCOMPATIBLE_VERSION;
   }

   Status = FillHostBridgeAperture (
              HostBridge->IoStart,
              HostBridge->IoSize,
              MAX_UINT32,
              Io
              );
   StickyError |= EFI_ERROR (Status);

   Status = FillHostBridgeAperture (
              HostBridge->PcieConfigStart,
              HostBridge->PcieConfigSize,
              MAX_UINT64,
              PcieConfig
              );
   StickyError |= EFI_ERROR (Status);

   if (HostBridge->Flags.Bits.CombineMemPMem) {
     Status = MergeHostBridgeApertures (
                HostBridge->MemStart,
                HostBridge->MemSize,
                HostBridge->PMemStart,
                HostBridge->PMemSize,
                MAX_UINT32,
                Mem
                );
     StickyError |= EFI_ERROR (Status);

     Status = MergeHostBridgeApertures (
                HostBridge->MemAbove4GStart,
                HostBridge->MemAbove4GSize,
                HostBridge->PMemAbove4GStart,
                HostBridge->PMemAbove4GSize,
                MAX_UINT64,
                MemAbove4G
                );
     StickyError |= EFI_ERROR (Status);

     //
     // Invalidate unused apertures
     //
     InvalidateRootBridgeAperture (PMem);
     InvalidateRootBridgeAperture (PMemAbove4G);
   } else {
     Status = FillHostBridgeAperture (
                HostBridge->MemStart,
                HostBridge->MemSize,
                MAX_UINT32,
                Mem
                );
     StickyError |= EFI_ERROR (Status);

     Status = FillHostBridgeAperture (
                HostBridge->PMemStart,
                HostBridge->PMemSize,
                MAX_UINT32,
                PMem
                );
     StickyError |= EFI_ERROR (Status);

     Status = FillHostBridgeAperture (
                HostBridge->MemAbove4GStart,
                HostBridge->MemAbove4GSize,
                MAX_UINT64,
                MemAbove4G
                );
     StickyError |= EFI_ERROR (Status);

     Status = FillHostBridgeAperture (
                HostBridge->PMemAbove4GStart,
                HostBridge->PMemAbove4GSize,
                MAX_UINT64,
                PMem
                );
     StickyError |= EFI_ERROR (Status);
   }

   if (StickyError) {
     //
     // If any function returned an error it is due to a valid range
     // specified in the host bridge that was ignored due to a NULL
     // pointer. Translate it to a warning to allow for calling with
     // only a subset of the apertures.
     //
     return EFI_WARN_STALE_DATA;
   }

   return EFI_SUCCESS;
 }

 EFI_STATUS
 HardwareInfoPciHostBridgeGetFlags (
   IN CONST  HOST_BRIDGE_INFO  *HostBridge,
   IN        UINTN             DataSize,
   OUT       UINT64            *Attributes               OPTIONAL,
   OUT       BOOLEAN           *DmaAbove4G               OPTIONAL,
   OUT       BOOLEAN           *NoExtendedConfigSpace    OPTIONAL,
   OUT       BOOLEAN           *CombineMemPMem           OPTIONAL
   )
 {
   if ((HostBridge == NULL) || (DataSize == 0)) {
     return EFI_INVALID_PARAMETER;
   }

   //
   // For now only version 0 is supported
   //
   if (HostBridge->Version != 0) {
     return EFI_INCOMPATIBLE_VERSION;
   }

   if (Attributes) {
     *Attributes = HostBridge->Attributes;
   }

   if (DmaAbove4G) {
     *DmaAbove4G = !!HostBridge->Flags.Bits.DmaAbove4G;
   }

   if (NoExtendedConfigSpace) {
     *NoExtendedConfigSpace = !!HostBridge->Flags.Bits.NoExtendedConfigSpace;
   }

   if (CombineMemPMem) {
     *CombineMemPMem = !!HostBridge->Flags.Bits.CombineMemPMem;
   }

   return EFI_SUCCESS;
 }

 EFI_STATUS
 HardwareInfoPciHostBridgeGet (
   IN CONST  HOST_BRIDGE_INFO          *HostBridge,
   IN        UINTN                     DataSize,
   OUT       UINTN                     *BusNrStart,
   OUT       UINTN                     *BusNrLast,
   OUT       UINT64                    *Attributes               OPTIONAL,
   OUT       BOOLEAN                   *DmaAbove4G               OPTIONAL,
   OUT       BOOLEAN                   *NoExtendedConfigSpace    OPTIONAL,
   OUT       BOOLEAN                   *CombineMemPMem           OPTIONAL,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *Io                       OPTIONAL,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *Mem                      OPTIONAL,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *MemAbove4G               OPTIONAL,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *PMem                     OPTIONAL,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *PMemAbove4G              OPTIONAL,
   OUT       PCI_ROOT_BRIDGE_APERTURE  *PcieConfig               OPTIONAL
   )
 {
   EFI_STATUS  Status;

   Status = HardwareInfoPciHostBridgeGetBusNrRange (
              HostBridge,
              DataSize,
              BusNrStart,
              BusNrLast
              );

   if (EFI_ERROR (Status)) {
     return Status;
   }

   Status = HardwareInfoPciHostBridgeGetFlags (
              HostBridge,
              DataSize,
              Attributes,
              DmaAbove4G,
              NoExtendedConfigSpace,
              CombineMemPMem
              );

   if (EFI_ERROR (Status)) {
     return Status;
   }

   Status = HardwareInfoPciHostBridgeGetApertures (
              HostBridge,
              DataSize,
              Io,
              Mem,
              MemAbove4G,
              PMem,
              PMemAbove4G,
              PcieConfig
              );

   return Status;
 }
	/**@file
	Hardware info library with types and accessors to parse information about
	PCI host bridges.

	Copyright 2021 - 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
	SPDX-License-Identifier: BSD-2-Clause-Patent

	**/

	#include <Library/DebugLib.h>

	#include "HardwareInfoPciHostBridgeLib.h"

	#define IS_RANGE_INVALID(Start, Size, MaxValue) (Start >= MaxValue \|\| Size == 0)

	/**
	Calculate the last (inclusive) address of a range.

	@param[in] Start First address of the range
	@param[in] Size Size of the range
	@return Last address of the range
	**/
	STATIC
	UINT64
	GetRangeEnd (
	IN UINT64 Start,
	IN UINT64 Size,
	IN UINT64 MaxValue
	)
	{
	if (IS_RANGE_INVALID (Start, Size, MaxValue)) {
	return 0;
	}

	return Start + Size - 1;
	}

	/**
	Internal helper to update LastAddress if the Limit address
	of the Mem aperture is higher than the provided value.

	@param[in] Mem Pointer to aperture whose limit is
	to be compared against accumulative
	last address.
	@param[out] LastAddress Pointer to accumulative last address
	to be updated if Limit is higher
	**/
	STATIC
	VOID
	UpdateLastAddressIfHigher (
	IN PCI_ROOT_BRIDGE_APERTURE *Mem,
	OUT UINT64 *LastAddress
	)
	{
	if (Mem->Limit > *LastAddress) {
	*LastAddress = Mem->Limit;
	}
	}

	EFI_STATUS
	HardwareInfoPciHostBridgeLastMmioAddress (
	IN CONST HOST_BRIDGE_INFO *HostBridge,
	IN UINTN DataSize,
	IN BOOLEAN HighMem,
	OUT UINT64 *LastMmioAddress
	)
	{
	EFI_STATUS Status;
	PCI_ROOT_BRIDGE_APERTURE Mem;
	PCI_ROOT_BRIDGE_APERTURE MemAbove4G;
	PCI_ROOT_BRIDGE_APERTURE PMem;
	PCI_ROOT_BRIDGE_APERTURE PMemAbove4G;

	if (LastMmioAddress == NULL) {
	return EFI_INVALID_PARAMETER;
	}

	//
	// Set the output to the lowest possible value so that if some step fails
	// the overall outcome reflects no information found
	//
	*LastMmioAddress = 0;

	Status = HardwareInfoPciHostBridgeGetApertures (
	HostBridge,
	DataSize,
	NULL,
	&Mem,
	&MemAbove4G,
	&PMem,
	&PMemAbove4G,
	NULL
	);

	//
	// Forward error to caller but ignore warnings given that, very likely,
	// the host bridge will have a PIO aperture we are explicitly
	// ignoring here since we care only about MMIO resources.
	//
	if (EFI_ERROR (Status)) {
	return Status;
	}

	if (HighMem) {
	UpdateLastAddressIfHigher (&MemAbove4G, LastMmioAddress);
	UpdateLastAddressIfHigher (&PMemAbove4G, LastMmioAddress);
	} else {
	UpdateLastAddressIfHigher (&Mem, LastMmioAddress);
	UpdateLastAddressIfHigher (&PMem, LastMmioAddress);
	}

	return EFI_SUCCESS;
	}

	/**
	Set the boundaries of an aperture to invalid values having
	size zero and start MaxValue (yields Start > Limit which
	depicts an invalid range)

	@param[in] MaxValue Max value of the aperture's range (depends
	on the data type)
	@param[out] Aperture Aperture object to invalidate
	**/
	STATIC
	VOID
	InvalidateRootBridgeAperture (
	OUT PCI_ROOT_BRIDGE_APERTURE *Aperture
	)
	{
	if (Aperture == NULL) {
	return;
	}

	Aperture->Base = MAX_UINT64;
	Aperture->Limit = 0;
	}

	/**
	Fill a PCI ROOT BRIDGE APERTURE with the proper values calculated
	from the provided start and size.

	@param[in] Start Start address of the aperture
	@param[in] Size Size, in bytes, of the aperture
	@param[in] MaxValue Max value a valid address could take and which
	represents an invalid start address.
	@param[out] Aperture Pointer to the aperture to be filled

	@retval EFI_SUCCESS Aperture was filled successfully
	@retval EFI_INVALID_PARAMETER Range depicted by Start and Size is
	valid but ignored because aperture
	pointer is NULL
	@retval EFI_WARN_BUFFER_TOO_SMALL Aperture pointer is invalid but the
	range also is so no harm.
	**/
	STATIC
	EFI_STATUS
	FillHostBridgeAperture (
	IN UINT64 Start,
	IN UINT64 Size,
	IN UINT64 MaxValue,
	OUT PCI_ROOT_BRIDGE_APERTURE *Aperture
	)
	{
	UINT64 End;

	End = GetRangeEnd (Start, Size, MaxValue);

	if (Aperture == NULL) {
	if (!IS_RANGE_INVALID (Start, Size, MaxValue)) {
	//
	// Report an error to the caller since the range specified in
	// the host bridge's resources is non-empty but the provided
	// aperture pointer is null, thus the valid range is ignored.
	//
	return EFI_INVALID_PARAMETER;
	}

	return EFI_WARN_BUFFER_TOO_SMALL;
	}

	if (IS_RANGE_INVALID (Start, Size, MaxValue)) {
	//
	// Fill Aperture with invalid range values to signal the
	// absence of an address space (empty range)
	//
	InvalidateRootBridgeAperture (Aperture);
	} else {
	Aperture->Base = Start;
	Aperture->Limit = End;
	}

	return EFI_SUCCESS;
	}

	/**
	Merge 2 ranges (normal and prefetchable) into a single aperture
	comprehending the addresses encompassed by both of them. If both
	ranges are not empty they must be contiguous for correctness.

	@param[in] Start Range start address
	@param[in] Size Range size in bytes
	@param[in] PStart Prefetchable range start address
	@param[in] PSize Prefetchable range size in bytes
	@param[in] MaxValue Max value a valid address could take and which
	represents an invalid start address.
	@param[out] Aperture Pointer to the aperture to be filled

	@retval EFI_SUCCESS Aperture was filled successfully
	@retval EFI_INVALID_PARAMETER Either range depicted by Start, Size
	or PStart, PSize or both are valid
	but ignored because aperture pointer
	is NULL
	@retval EFI_WARN_BUFFER_TOO_SMALL Aperture pointer is invalid but both
	ranges are too so no harm.
	**/
	STATIC
	EFI_STATUS
	MergeHostBridgeApertures (
	IN UINT64 Start,
	IN UINT64 Size,
	IN UINT64 PStart,
	IN UINT64 PSize,
	IN UINT64 MaxValue,
	OUT PCI_ROOT_BRIDGE_APERTURE *Aperture
	)
	{
	UINT64 PEnd;

	if (Aperture == NULL) {
	if (!IS_RANGE_INVALID (Start, Size, MaxValue) \|\|
	!IS_RANGE_INVALID (PStart, PSize, MaxValue))
	{
	//
	// Report an error to the caller since the range specified in
	// the host bridge's resources is non-empty but the provided
	// aperture pointer is null, thus the valid range is ignored.
	//
	return EFI_INVALID_PARAMETER;
	}

	return EFI_WARN_BUFFER_TOO_SMALL;
	}

	//
	// Start from an empty range (Limit < Base)
	//
	InvalidateRootBridgeAperture (Aperture);

	if (!IS_RANGE_INVALID (Start, Size, MaxValue)) {
	Aperture->Base = Start;
	Aperture->Limit = Start + Size - 1;
	}

	if (!IS_RANGE_INVALID (PStart, PSize, MaxValue)) {
	PEnd = PStart + PSize - 1;

	if (PStart < Aperture->Base) {
	Aperture->Base = PStart;
	}

	if (PEnd > Aperture->Limit) {
	Aperture->Limit = PEnd;
	}
	}

	return EFI_SUCCESS;
	}

	EFI_STATUS
	HardwareInfoPciHostBridgeGetBusNrRange (
	IN CONST HOST_BRIDGE_INFO *HostBridge,
	IN UINTN DataSize,
	OUT UINTN *BusNrStart,
	OUT UINTN *BusNrLast
	)
	{
	if ((HostBridge == NULL) \|\| (DataSize == 0) \|\|
	(BusNrStart == NULL) \|\| (BusNrLast == NULL))
	{
	return EFI_INVALID_PARAMETER;
	}

	//
	// For now only version 0 is supported
	//
	if (HostBridge->Version != 0) {
	return EFI_INCOMPATIBLE_VERSION;
	}

	*BusNrStart = HostBridge->BusNrStart;
	*BusNrLast = HostBridge->BusNrLast;

	return EFI_SUCCESS;
	}

	EFI_STATUS
	HardwareInfoPciHostBridgeGetApertures (
	IN CONST HOST_BRIDGE_INFO *HostBridge,
	IN UINTN DataSize,
	OUT PCI_ROOT_BRIDGE_APERTURE *Io,
	OUT PCI_ROOT_BRIDGE_APERTURE *Mem,
	OUT PCI_ROOT_BRIDGE_APERTURE *MemAbove4G,
	OUT PCI_ROOT_BRIDGE_APERTURE *PMem,
	OUT PCI_ROOT_BRIDGE_APERTURE *PMemAbove4G,
	OUT PCI_ROOT_BRIDGE_APERTURE *PcieConfig
	)
	{
	EFI_STATUS Status;
	BOOLEAN StickyError;

	StickyError = FALSE;
	if ((HostBridge == NULL) \|\| (DataSize == 0)) {
	return EFI_INVALID_PARAMETER;
	}

	//
	// For now only version 0 is supported
	//
	if (HostBridge->Version != 0) {
	return EFI_INCOMPATIBLE_VERSION;
	}

	Status = FillHostBridgeAperture (
	HostBridge->IoStart,
	HostBridge->IoSize,
	MAX_UINT32,
	Io
	);
	StickyError \|= EFI_ERROR (Status);

	Status = FillHostBridgeAperture (
	HostBridge->PcieConfigStart,
	HostBridge->PcieConfigSize,
	MAX_UINT64,
	PcieConfig
	);
	StickyError \|= EFI_ERROR (Status);

	if (HostBridge->Flags.Bits.CombineMemPMem) {
	Status = MergeHostBridgeApertures (
	HostBridge->MemStart,
	HostBridge->MemSize,
	HostBridge->PMemStart,
	HostBridge->PMemSize,
	MAX_UINT32,
	Mem
	);
	StickyError \|= EFI_ERROR (Status);

	Status = MergeHostBridgeApertures (
	HostBridge->MemAbove4GStart,
	HostBridge->MemAbove4GSize,
	HostBridge->PMemAbove4GStart,
	HostBridge->PMemAbove4GSize,
	MAX_UINT64,
	MemAbove4G
	);
	StickyError \|= EFI_ERROR (Status);

	//
	// Invalidate unused apertures
	//
	InvalidateRootBridgeAperture (PMem);
	InvalidateRootBridgeAperture (PMemAbove4G);
	} else {
	Status = FillHostBridgeAperture (
	HostBridge->MemStart,
	HostBridge->MemSize,
	MAX_UINT32,
	Mem
	);
	StickyError \|= EFI_ERROR (Status);

	Status = FillHostBridgeAperture (
	HostBridge->PMemStart,
	HostBridge->PMemSize,
	MAX_UINT32,
	PMem
	);
	StickyError \|= EFI_ERROR (Status);

	Status = FillHostBridgeAperture (
	HostBridge->MemAbove4GStart,
	HostBridge->MemAbove4GSize,
	MAX_UINT64,
	MemAbove4G
	);
	StickyError \|= EFI_ERROR (Status);

	Status = FillHostBridgeAperture (
	HostBridge->PMemAbove4GStart,
	HostBridge->PMemAbove4GSize,
	MAX_UINT64,
	PMem
	);
	StickyError \|= EFI_ERROR (Status);
	}

	if (StickyError) {
	//
	// If any function returned an error it is due to a valid range
	// specified in the host bridge that was ignored due to a NULL
	// pointer. Translate it to a warning to allow for calling with
	// only a subset of the apertures.
	//
	return EFI_WARN_STALE_DATA;
	}

	return EFI_SUCCESS;
	}

	EFI_STATUS
	HardwareInfoPciHostBridgeGetFlags (
	IN CONST HOST_BRIDGE_INFO *HostBridge,
	IN UINTN DataSize,
	OUT UINT64 *Attributes OPTIONAL,
	OUT BOOLEAN *DmaAbove4G OPTIONAL,
	OUT BOOLEAN *NoExtendedConfigSpace OPTIONAL,
	OUT BOOLEAN *CombineMemPMem OPTIONAL
	)
	{
	if ((HostBridge == NULL) \|\| (DataSize == 0)) {
	return EFI_INVALID_PARAMETER;
	}

	//
	// For now only version 0 is supported
	//
	if (HostBridge->Version != 0) {
	return EFI_INCOMPATIBLE_VERSION;
	}

	if (Attributes) {
	*Attributes = HostBridge->Attributes;
	}

	if (DmaAbove4G) {
	*DmaAbove4G = !!HostBridge->Flags.Bits.DmaAbove4G;
	}

	if (NoExtendedConfigSpace) {
	*NoExtendedConfigSpace = !!HostBridge->Flags.Bits.NoExtendedConfigSpace;
	}

	if (CombineMemPMem) {
	*CombineMemPMem = !!HostBridge->Flags.Bits.CombineMemPMem;
	}

	return EFI_SUCCESS;
	}

	EFI_STATUS
	HardwareInfoPciHostBridgeGet (
	IN CONST HOST_BRIDGE_INFO *HostBridge,
	IN UINTN DataSize,
	OUT UINTN *BusNrStart,
	OUT UINTN *BusNrLast,
	OUT UINT64 *Attributes OPTIONAL,
	OUT BOOLEAN *DmaAbove4G OPTIONAL,
	OUT BOOLEAN *NoExtendedConfigSpace OPTIONAL,
	OUT BOOLEAN *CombineMemPMem OPTIONAL,
	OUT PCI_ROOT_BRIDGE_APERTURE *Io OPTIONAL,
	OUT PCI_ROOT_BRIDGE_APERTURE *Mem OPTIONAL,
	OUT PCI_ROOT_BRIDGE_APERTURE *MemAbove4G OPTIONAL,
	OUT PCI_ROOT_BRIDGE_APERTURE *PMem OPTIONAL,
	OUT PCI_ROOT_BRIDGE_APERTURE *PMemAbove4G OPTIONAL,
	OUT PCI_ROOT_BRIDGE_APERTURE *PcieConfig OPTIONAL
	)
	{
	EFI_STATUS Status;

	Status = HardwareInfoPciHostBridgeGetBusNrRange (
	HostBridge,
	DataSize,
	BusNrStart,
	BusNrLast
	);

	if (EFI_ERROR (Status)) {
	return Status;
	}

	Status = HardwareInfoPciHostBridgeGetFlags (
	HostBridge,
	DataSize,
	Attributes,
	DmaAbove4G,
	NoExtendedConfigSpace,
	CombineMemPMem
	);

	if (EFI_ERROR (Status)) {
	return Status;
	}

	Status = HardwareInfoPciHostBridgeGetApertures (
	HostBridge,
	DataSize,
	Io,
	Mem,
	MemAbove4G,
	PMem,
	PMemAbove4G,
	PcieConfig
	);

	return Status;
	}