tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/DynamicTablesPkg/Library/FdtHwInfoParserLib/Pci/ArmPciConfigSpaceParser.c

814 lines
24 KiB
C
Raw Blame History

/** @file
Arm PCI Configuration Space Parser.
Copyright (c) 2021, ARM Limited. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
@par Reference(s):
- linux/Documentation/devicetree/bindings/pci/host-generic-pci.yaml
- PCI Firmware Specification - Revision 3.0
- Open Firmware Recommended Practice: Interrupt Mapping, Version 0.9
- Devicetree Specification Release v0.3
- linux kernel code
**/
#include "CmObjectDescUtility.h"
#include <Library/DebugLib.h>
#include "FdtHwInfoParser.h"
#include "Pci/ArmPciConfigSpaceParser.h"
#include "Gic/ArmGicDispatcher.h"
/** List of "compatible" property values for host PCIe bridges nodes.
Any other "compatible" value is not supported by this module.
*/
STATIC CONST COMPATIBILITY_STR PciCompatibleStr[] = {
{ "pci-host-ecam-generic" }
};
/** COMPATIBILITY_INFO structure for the PCIe.
*/
STATIC CONST COMPATIBILITY_INFO PciCompatibleInfo = {
ARRAY_SIZE (PciCompatibleStr),
PciCompatibleStr
};
/** Get the Segment group (also called: Domain Id) of a host-pci node.
kernel/Documentation/devicetree/bindings/pci/pci.txt:
"It is required to either not set this property at all or set it for all
host bridges in the system"
The function checks the "linux,pci-domain" property of the host-pci node.
Either all host-pci nodes must have this property, or none of them. If the
property is available, read it. Otherwise dynamically assign the Ids.
@param [in] Fdt Pointer to a Flattened Device Tree (Fdt).
@param [in] HostPciNode Offset of a host-pci node.
@param [out] SegGroup Segment group assigned to the host-pci controller.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED An error occurred.
@retval EFI_INVALID_PARAMETER Invalid parameter.
**/
STATIC
EFI_STATUS
EFIAPI
GetPciSegGroup (
IN CONST VOID *Fdt,
IN INT32 HostPciNode,
OUT INT32 *SegGroup
)
{
CONST UINT8 *Data;
INT32 DataSize;
STATIC INT32 LocalSegGroup = 0;
if ((Fdt == NULL) ||
(SegGroup == NULL))
{
ASSERT (0);
return EFI_INVALID_PARAMETER;
}
Data = fdt_getprop (Fdt, HostPciNode, "linux,pci-domain", &DataSize);
if ((Data == NULL) || (DataSize < 0)) {
// Did not find property, assign the DomainIds ourselves.
if (LocalSegGroup < 0) {
// "linux,pci-domain" property was defined for another node.
ASSERT (0);
return EFI_ABORTED;
}
*SegGroup = LocalSegGroup++;
return EFI_SUCCESS;
}
if ((DataSize > sizeof (UINT32)) ||
(LocalSegGroup > 0))
{
// Property on more than 1 cell or
// "linux,pci-domain" property was not defined for a node.
ASSERT (0);
return EFI_ABORTED;
}
// If one node has the "linux,pci-domain" property, then all the host-pci
// nodes must have it.
LocalSegGroup = -1;
*SegGroup = fdt32_to_cpu (*(UINT32 *)Data);
return EFI_SUCCESS;
}
/** Parse the bus-range controlled by this host-pci node.
@param [in] Fdt Pointer to a Flattened Device Tree (Fdt).
@param [in] HostPciNode Offset of a host-pci node.
@param [in, out] PciInfo PCI_PARSER_TABLE structure storing
information about the current host-pci.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED An error occurred.
@retval EFI_INVALID_PARAMETER Invalid parameter.
**/
STATIC
EFI_STATUS
EFIAPI
PopulateBusRange (
IN CONST VOID *Fdt,
IN INT32 HostPciNode,
IN OUT PCI_PARSER_TABLE *PciInfo
)
{
CONST UINT8 *Data;
INT32 DataSize;
UINT32 StartBus;
UINT32 EndBus;
if ((Fdt == NULL) ||
(PciInfo == NULL))
{
ASSERT (0);
return EFI_INVALID_PARAMETER;
}
Data = fdt_getprop (Fdt, HostPciNode, "bus-range", &DataSize);
if ((Data == NULL) || (DataSize < 0)) {
// No evidence this property is mandatory. Use default values.
StartBus = 0;
EndBus = 255;
} else if (DataSize == (2 * sizeof (UINT32))) {
// If available, the property is on two integers.
StartBus = fdt32_to_cpu (((UINT32 *)Data)[0]);
EndBus = fdt32_to_cpu (((UINT32 *)Data)[1]);
} else {
ASSERT (0);
return EFI_ABORTED;
}
PciInfo->PciConfigSpaceInfo.StartBusNumber = StartBus;
PciInfo->PciConfigSpaceInfo.EndBusNumber = EndBus;
return EFI_SUCCESS;
}
/** Parse the PCI address map.
The PCI address map is available in the "ranges" device-tree property.
@param [in] Fdt Pointer to a Flattened Device Tree (Fdt).
@param [in] HostPciNode Offset of a host-pci node.
@param [in] AddressCells # of cells used to encode an address on
the parent bus.
@param [in, out] PciInfo PCI_PARSER_TABLE structure storing
information about the current host-pci.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED An error occurred.
@retval EFI_INVALID_PARAMETER Invalid parameter.
@retval EFI_OUT_OF_RESOURCES An allocation has failed.
**/
STATIC
EFI_STATUS
EFIAPI
ParseAddressMap (
IN CONST VOID *Fdt,
IN INT32 HostPciNode,
IN INT32 AddressCells,
IN OUT PCI_PARSER_TABLE *PciInfo
)
{
CONST UINT8 *Data;
INT32 DataSize;
UINT32 Index;
UINT32 Offset;
UINT32 AddressMapSize;
UINT32 Count;
UINT32 PciAddressAttr;
CM_ARM_PCI_ADDRESS_MAP_INFO *PciAddressMapInfo;
UINT32 BufferSize;
// The mapping is done on AddressMapSize bytes.
AddressMapSize = (PCI_ADDRESS_CELLS + AddressCells + PCI_SIZE_CELLS) *
sizeof (UINT32);
Data = fdt_getprop (Fdt, HostPciNode, "ranges", &DataSize);
if ((Data == NULL) ||
(DataSize < 0) ||
((DataSize % AddressMapSize) != 0))
{
// If error or not on AddressMapSize bytes.
ASSERT (0);
return EFI_ABORTED;
}
Count = DataSize / AddressMapSize;
// Allocate a buffer to store each address mapping.
BufferSize = Count * sizeof (CM_ARM_PCI_ADDRESS_MAP_INFO);
PciAddressMapInfo = AllocateZeroPool (BufferSize);
if (PciAddressMapInfo == NULL) {
ASSERT (0);
return EFI_OUT_OF_RESOURCES;
}
for (Index = 0; Index < Count; Index++) {
Offset = Index * AddressMapSize;
// Pci address attributes
PciAddressAttr = fdt32_to_cpu (*(UINT32 *)&Data[Offset]);
PciAddressMapInfo[Index].SpaceCode = READ_PCI_SS (PciAddressAttr);
Offset += sizeof (UINT32);
// Pci address
PciAddressMapInfo[Index].PciAddress =
fdt64_to_cpu (*(UINT64 *)&Data[Offset]);
Offset += (PCI_ADDRESS_CELLS - 1) * sizeof (UINT32);
// Cpu address
if (AddressCells == 2) {
PciAddressMapInfo[Index].CpuAddress =
fdt64_to_cpu (*(UINT64 *)&Data[Offset]);
} else {
PciAddressMapInfo[Index].CpuAddress =
fdt32_to_cpu (*(UINT32 *)&Data[Offset]);
}
Offset += AddressCells * sizeof (UINT32);
// Address size
PciAddressMapInfo[Index].AddressSize =
fdt64_to_cpu (*(UINT64 *)&Data[Offset]);
Offset += PCI_SIZE_CELLS * sizeof (UINT32);
} // for
PciInfo->Mapping[PciMappingTableAddress].ObjectId =
CREATE_CM_ARM_OBJECT_ID (EArmObjPciAddressMapInfo);
PciInfo->Mapping[PciMappingTableAddress].Size =
sizeof (CM_ARM_PCI_ADDRESS_MAP_INFO) * Count;
PciInfo->Mapping[PciMappingTableAddress].Data = PciAddressMapInfo;
PciInfo->Mapping[PciMappingTableAddress].Count = Count;
return EFI_SUCCESS;
}
/** Parse the PCI interrupt map.
The PCI interrupt map is available in the "interrupt-map"
and "interrupt-map-mask" device-tree properties.
Cf Devicetree Specification Release v0.3,
s2.4.3 Interrupt Nexus Properties
An interrupt-map must be as:
interrupt-map = < [child unit address] [child interrupt specifier]
[interrupt-parent]
[parent unit address] [parent interrupt specifier] >
@param [in] Fdt Pointer to a Flattened Device Tree (Fdt).
@param [in] HostPciNode Offset of a host-pci node.
@param [in, out] PciInfo PCI_PARSER_TABLE structure storing
information about the current host-pci.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED An error occurred.
@retval EFI_INVALID_PARAMETER Invalid parameter.
@retval EFI_NOT_FOUND Not found.
@retval EFI_OUT_OF_RESOURCES An allocation has failed.
**/
STATIC
EFI_STATUS
EFIAPI
ParseIrqMap (
IN CONST VOID *Fdt,
IN INT32 HostPciNode,
IN OUT PCI_PARSER_TABLE *PciInfo
)
{
EFI_STATUS Status;
CONST UINT8 *Data;
INT32 DataSize;
UINT32 Index;
UINT32 Offset;
INT32 IntcNode;
INT32 IntcAddressCells;
INT32 IntcCells;
INT32 PciIntCells;
INT32 IntcPhandle;
INT32 IrqMapSize;
UINT32 IrqMapCount;
CONST UINT8 *IrqMapMask;
INT32 IrqMapMaskSize;
INT32 PHandleOffset;
UINT32 GicVersion;
UINT32 PciAddressAttr;
CM_ARM_PCI_INTERRUPT_MAP_INFO *PciInterruptMapInfo;
UINT32 BufferSize;
Data = fdt_getprop (Fdt, HostPciNode, "interrupt-map", &DataSize);
if ((Data == NULL) || (DataSize <= 0)) {
DEBUG ((
DEBUG_WARN,
"Fdt parser: No Legacy interrupts found for PCI configuration space at "
"address: 0x%lx, group segment: %d\n",
PciInfo->PciConfigSpaceInfo.BaseAddress,
PciInfo->PciConfigSpaceInfo.PciSegmentGroupNumber
));
return EFI_NOT_FOUND;
}
// PCI interrupts are expected to be on 1 cell. Check it.
Status = FdtGetInterruptCellsInfo (Fdt, HostPciNode, &PciIntCells);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
if (PciIntCells != PCI_INTERRUPTS_CELLS) {
ASSERT (0);
return EFI_ABORTED;
}
IrqMapMask = fdt_getprop (
Fdt,
HostPciNode,
"interrupt-map-mask",
&IrqMapMaskSize
);
if ((IrqMapMask == NULL) ||
(IrqMapMaskSize !=
(PCI_ADDRESS_CELLS + PCI_INTERRUPTS_CELLS) * sizeof (UINT32)))
{
ASSERT (0);
return EFI_ABORTED;
}
// Get the interrupt-controller of the first irq mapping.
PHandleOffset = (PCI_ADDRESS_CELLS + PciIntCells) * sizeof (UINT32);
if (PHandleOffset > DataSize) {
ASSERT (0);
return EFI_ABORTED;
}
IntcPhandle = fdt32_to_cpu (*(UINT32 *)&Data[PHandleOffset]);
IntcNode = fdt_node_offset_by_phandle (Fdt, IntcPhandle);
if (IntcNode < 0) {
ASSERT (0);
return EFI_ABORTED;
}
// Only support Gic(s) for now.
Status = GetGicVersion (Fdt, IntcNode, &GicVersion);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
// Get the "address-cells" property of the IntcNode.
Status = FdtGetAddressInfo (Fdt, IntcNode, &IntcAddressCells, NULL);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
// Get the "interrupt-cells" property of the IntcNode.
Status = FdtGetInterruptCellsInfo (Fdt, IntcNode, &IntcCells);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
// An irq mapping is done on IrqMapSize bytes
// (which includes 1 cell for the PHandle).
IrqMapSize = (PCI_ADDRESS_CELLS + PciIntCells + 1
+ IntcAddressCells + IntcCells) * sizeof (UINT32);
if ((DataSize % IrqMapSize) != 0) {
// The mapping is not done on IrqMapSize bytes.
ASSERT (0);
return EFI_ABORTED;
}
IrqMapCount = DataSize / IrqMapSize;
// We assume the same interrupt-controller is used for all the mappings.
// Check this is correct.
for (Index = 0; Index < IrqMapCount; Index++) {
if (IntcPhandle != fdt32_to_cpu (
*(UINT32 *)&Data[(Index * IrqMapSize) + PHandleOffset]
))
{
ASSERT (0);
return EFI_ABORTED;
}
}
// Allocate a buffer to store each interrupt mapping.
IrqMapCount = DataSize / IrqMapSize;
BufferSize = IrqMapCount * sizeof (CM_ARM_PCI_ADDRESS_MAP_INFO);
PciInterruptMapInfo = AllocateZeroPool (BufferSize);
if (PciInterruptMapInfo == NULL) {
ASSERT (0);
return EFI_OUT_OF_RESOURCES;
}
for (Index = 0; Index < IrqMapCount; Index++) {
Offset = Index * IrqMapSize;
// Pci address attributes
PciAddressAttr = fdt32_to_cpu (
(*(UINT32 *)&Data[Offset]) &
(*(UINT32 *)&IrqMapMask[0])
);
PciInterruptMapInfo[Index].PciBus = READ_PCI_BBBBBBBB (PciAddressAttr);
PciInterruptMapInfo[Index].PciDevice = READ_PCI_DDDDD (PciAddressAttr);
Offset += PCI_ADDRESS_CELLS * sizeof (UINT32);
// Pci irq
PciInterruptMapInfo[Index].PciInterrupt = fdt32_to_cpu (
(*(UINT32 *)&Data[Offset]) &
(*(UINT32 *)&IrqMapMask[3 * sizeof (UINT32)])
);
// -1 to translate from device-tree (INTA=1) to ACPI (INTA=0) irq IDs.
PciInterruptMapInfo[Index].PciInterrupt -= 1;
Offset += PCI_INTERRUPTS_CELLS * sizeof (UINT32);
// PHandle (skip it)
Offset += sizeof (UINT32);
// "Parent unit address" (skip it)
Offset += IntcAddressCells * sizeof (UINT32);
// Interrupt controller interrupt and flags
PciInterruptMapInfo[Index].IntcInterrupt.Interrupt =
FdtGetInterruptId ((UINT32 *)&Data[Offset]);
PciInterruptMapInfo[Index].IntcInterrupt.Flags =
FdtGetInterruptFlags ((UINT32 *)&Data[Offset]);
} // for
PciInfo->Mapping[PciMappingTableInterrupt].ObjectId =
CREATE_CM_ARM_OBJECT_ID (EArmObjPciInterruptMapInfo);
PciInfo->Mapping[PciMappingTableInterrupt].Size =
sizeof (CM_ARM_PCI_INTERRUPT_MAP_INFO) * IrqMapCount;
PciInfo->Mapping[PciMappingTableInterrupt].Data = PciInterruptMapInfo;
PciInfo->Mapping[PciMappingTableInterrupt].Count = IrqMapCount;
return Status;
}
/** Parse a Host-pci node.
@param [in] Fdt Pointer to a Flattened Device Tree (Fdt).
@param [in] HostPciNode Offset of a host-pci node.
@param [in, out] PciInfo The CM_ARM_PCI_CONFIG_SPACE_INFO to populate.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED An error occurred.
@retval EFI_INVALID_PARAMETER Invalid parameter.
@retval EFI_OUT_OF_RESOURCES An allocation has failed.
**/
STATIC
EFI_STATUS
EFIAPI
PciNodeParser (
IN CONST VOID *Fdt,
IN INT32 HostPciNode,
IN OUT PCI_PARSER_TABLE *PciInfo
)
{
EFI_STATUS Status;
INT32 AddressCells;
INT32 SizeCells;
CONST UINT8 *Data;
INT32 DataSize;
INT32 SegGroup;
if ((Fdt == NULL) ||
(PciInfo == NULL))
{
ASSERT (0);
return EFI_INVALID_PARAMETER;
}
// Segment Group / DomainId
Status = GetPciSegGroup (Fdt, HostPciNode, &SegGroup);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
PciInfo->PciConfigSpaceInfo.PciSegmentGroupNumber = SegGroup;
// Bus range
Status = PopulateBusRange (Fdt, HostPciNode, PciInfo);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
Status = FdtGetParentAddressInfo (
Fdt,
HostPciNode,
&AddressCells,
&SizeCells
);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
// Only support 32/64 bits addresses.
if ((AddressCells < 1) ||
(AddressCells > 2) ||
(SizeCells < 1) ||
(SizeCells > 2))
{
ASSERT (0);
return EFI_ABORTED;
}
Data = fdt_getprop (Fdt, HostPciNode, "reg", &DataSize);
if ((Data == NULL) ||
(DataSize != ((AddressCells + SizeCells) * sizeof (UINT32))))
{
// If error or wrong size.
ASSERT (0);
return EFI_ABORTED;
}
// Base address
if (AddressCells == 2) {
PciInfo->PciConfigSpaceInfo.BaseAddress = fdt64_to_cpu (*(UINT64 *)Data);
} else {
PciInfo->PciConfigSpaceInfo.BaseAddress = fdt32_to_cpu (*(UINT32 *)Data);
}
// Address map
Status = ParseAddressMap (
Fdt,
HostPciNode,
AddressCells,
PciInfo
);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
// Irq map
Status = ParseIrqMap (
Fdt,
HostPciNode,
PciInfo
);
if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) {
ASSERT (0);
}
return EFI_SUCCESS;
}
/** Add the parsed Pci information to the Configuration Manager.
CmObj of the following types are concerned:
- EArmObjPciConfigSpaceInfo
- EArmObjPciAddressMapInfo
- EArmObjPciInterruptMapInfo
@param [in] FdtParserHandle A handle to the parser instance.
@param [in] PciTableInfo PCI_PARSER_TABLE structure containing the
CmObjs to add.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_INVALID_PARAMETER Invalid parameter.
@retval EFI_OUT_OF_RESOURCES An allocation has failed.
**/
STATIC
EFI_STATUS
EFIAPI
PciInfoAdd (
IN CONST FDT_HW_INFO_PARSER_HANDLE FdtParserHandle,
IN PCI_PARSER_TABLE *PciTableInfo
)
{
EFI_STATUS Status;
CM_ARM_PCI_CONFIG_SPACE_INFO *PciConfigSpaceInfo;
if ((FdtParserHandle == NULL) ||
(PciTableInfo == NULL))
{
ASSERT (0);
return EFI_INVALID_PARAMETER;
}
PciConfigSpaceInfo = &PciTableInfo->PciConfigSpaceInfo;
// Add the address map space CmObj to the Configuration Manager.
Status = AddMultipleCmObjWithCmObjRef (
FdtParserHandle,
&PciTableInfo->Mapping[PciMappingTableAddress],
&PciConfigSpaceInfo->AddressMapToken
);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
// Add the interrupt map space CmObj to the Configuration Manager.
// Possible to have no legacy interrupts, or no device described and
// thus no interrupt-mapping.
if (PciTableInfo->Mapping[PciMappingTableInterrupt].Count != 0) {
Status = AddMultipleCmObjWithCmObjRef (
FdtParserHandle,
&PciTableInfo->Mapping[PciMappingTableInterrupt],
&PciConfigSpaceInfo->InterruptMapToken
);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
}
// Add the configuration space CmObj to the Configuration Manager.
Status = AddSingleCmObj (
FdtParserHandle,
CREATE_CM_ARM_OBJECT_ID (EArmObjPciConfigSpaceInfo),
&PciTableInfo->PciConfigSpaceInfo,
sizeof (CM_ARM_PCI_CONFIG_SPACE_INFO),
NULL
);
ASSERT_EFI_ERROR (Status);
return Status;
}
/** Free the CmObjDesc of the ParserTable.
@param [in] PciTableInfo PCI_PARSER_TABLE structure containing the
CmObjs to free.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_INVALID_PARAMETER Invalid parameter.
**/
STATIC
EFI_STATUS
EFIAPI
FreeParserTable (
IN PCI_PARSER_TABLE *PciTableInfo
)
{
UINT32 Index;
VOID *Data;
if (PciTableInfo == NULL) {
ASSERT (0);
return EFI_INVALID_PARAMETER;
}
for (Index = 0; Index < PciMappingTableMax; Index++) {
Data = PciTableInfo->Mapping[Index].Data;
if (Data != NULL) {
FreePool (Data);
}
}
return EFI_SUCCESS;
}
/** CM_ARM_PCI_CONFIG_SPACE_INFO parser function.
The following structure is populated:
typedef struct CmArmPciConfigSpaceInfo {
UINT64 BaseAddress; // {Populated}
UINT16 PciSegmentGroupNumber; // {Populated}
UINT8 StartBusNumber; // {Populated}
UINT8 EndBusNumber; // {Populated}
} CM_ARM_PCI_CONFIG_SPACE_INFO;
typedef struct CmArmPciAddressMapInfo {
UINT8 SpaceCode; // {Populated}
UINT64 PciAddress; // {Populated}
UINT64 CpuAddress; // {Populated}
UINT64 AddressSize; // {Populated}
} CM_ARM_PCI_ADDRESS_MAP_INFO;
typedef struct CmArmPciInterruptMapInfo {
UINT8 PciBus; // {Populated}
UINT8 PciDevice; // {Populated}
UINT8 PciInterrupt; // {Populated}
CM_ARM_GENERIC_INTERRUPT IntcInterrupt; // {Populated}
} CM_ARM_PCI_INTERRUPT_MAP_INFO;
A parser parses a Device Tree to populate a specific CmObj type. None,
one or many CmObj can be created by the parser.
The created CmObj are then handed to the parser's caller through the
HW_INFO_ADD_OBJECT interface.
This can also be a dispatcher. I.e. a function that not parsing a
Device Tree but calling other parsers.
@param [in] FdtParserHandle A handle to the parser instance.
@param [in] FdtBranch When searching for DT node name, restrict
the search to this Device Tree branch.
@retval EFI_SUCCESS The function completed successfully.
@retval EFI_ABORTED An error occurred.
@retval EFI_INVALID_PARAMETER Invalid parameter.
@retval EFI_NOT_FOUND Not found.
@retval EFI_UNSUPPORTED Unsupported.
**/
EFI_STATUS
EFIAPI
ArmPciConfigInfoParser (
IN CONST FDT_HW_INFO_PARSER_HANDLE FdtParserHandle,
IN INT32 FdtBranch
)
{
EFI_STATUS Status;
UINT32 Index;
INT32 PciNode;
UINT32 PciNodeCount;
PCI_PARSER_TABLE PciTableInfo;
VOID *Fdt;
if (FdtParserHandle == NULL) {
ASSERT (0);
return EFI_INVALID_PARAMETER;
}
Fdt = FdtParserHandle->Fdt;
// Only search host-pci devices.
// PCI Firmware Specification Revision 3.0, s4.1.2. "MCFG Table Description":
// "This table directly refers to PCI Segment Groups defined in the system
// via the _SEG object in the ACPI name space for the applicable host bridge
// device."
Status = FdtCountCompatNodeInBranch (
Fdt,
FdtBranch,
&PciCompatibleInfo,
&PciNodeCount
);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
if (PciNodeCount == 0) {
return EFI_NOT_FOUND;
}
// Parse each host-pci node in the branch.
PciNode = FdtBranch;
for (Index = 0; Index < PciNodeCount; Index++) {
ZeroMem (&PciTableInfo, sizeof (PCI_PARSER_TABLE));
Status = FdtGetNextCompatNodeInBranch (
Fdt,
FdtBranch,
&PciCompatibleInfo,
&PciNode
);
if (EFI_ERROR (Status)) {
ASSERT (0);
if (Status == EFI_NOT_FOUND) {
// Should have found the node.
Status = EFI_ABORTED;
}
return Status;
}
Status = PciNodeParser (Fdt, PciNode, &PciTableInfo);
if (EFI_ERROR (Status)) {
ASSERT (0);
goto error_handler;
}
// Add Pci information to the Configuration Manager.
Status = PciInfoAdd (FdtParserHandle, &PciTableInfo);
if (EFI_ERROR (Status)) {
ASSERT (0);
goto error_handler;
}
Status = FreeParserTable (&PciTableInfo);
if (EFI_ERROR (Status)) {
ASSERT (0);
return Status;
}
} // for
return Status;
error_handler:
FreeParserTable (&PciTableInfo);
return Status;
}
Reference in New Issue View Git Blame Copy Permalink