| /** @file | |
| PPTT Table Generator | |
| Copyright (c) 2021, ARM Limited. All rights reserved. | |
| SPDX-License-Identifier: BSD-2-Clause-Patent | |
| @par Reference(s): | |
| - ACPI 6.4 Specification, January 2021 | |
| @par Glossary: | |
| - Cm or CM - Configuration Manager | |
| - Obj or OBJ - Object | |
| **/ | |
| #include <Library/AcpiLib.h> | |
| #include <Library/BaseLib.h> | |
| #include <Library/DebugLib.h> | |
| #include <Library/MemoryAllocationLib.h> | |
| #include <Protocol/AcpiTable.h> | |
| // Module specific include files. | |
| #include <AcpiTableGenerator.h> | |
| #include <ConfigurationManagerObject.h> | |
| #include <ConfigurationManagerHelper.h> | |
| #include <Library/TableHelperLib.h> | |
| #include <Protocol/ConfigurationManagerProtocol.h> | |
| #include "PpttGenerator.h" | |
| /** | |
| ARM standard PPTT Generator | |
| Requirements: | |
| The following Configuration Manager Object(s) are used by this Generator: | |
| - EArmObjProcHierarchyInfo (REQUIRED) | |
| - EArmObjCacheInfo | |
| - EArmObjCmRef | |
| - EArmObjGicCInfo (REQUIRED) | |
| */ | |
| /** | |
| This macro expands to a function that retrieves the Processor Hierarchy | |
| information from the Configuration Manager. | |
| */ | |
| GET_OBJECT_LIST ( | |
| EObjNameSpaceArm, | |
| EArmObjProcHierarchyInfo, | |
| CM_ARM_PROC_HIERARCHY_INFO | |
| ); | |
| /** | |
| This macro expands to a function that retrieves the cache information | |
| from the Configuration Manager. | |
| */ | |
| GET_OBJECT_LIST ( | |
| EObjNameSpaceArm, | |
| EArmObjCacheInfo, | |
| CM_ARM_CACHE_INFO | |
| ); | |
| /** | |
| This macro expands to a function that retrieves the cross-CM-object- | |
| reference information from the Configuration Manager. | |
| */ | |
| GET_OBJECT_LIST ( | |
| EObjNameSpaceArm, | |
| EArmObjCmRef, | |
| CM_ARM_OBJ_REF | |
| ); | |
| /** | |
| This macro expands to a function that retrieves the GIC CPU interface | |
| information from the Configuration Manager. | |
| */ | |
| GET_OBJECT_LIST ( | |
| EObjNameSpaceArm, | |
| EArmObjGicCInfo, | |
| CM_ARM_GICC_INFO | |
| ); | |
| /** | |
| Returns the size of the PPTT Processor Hierarchy Node (Type 0) given a | |
| Processor Hierarchy Info CM object. | |
| @param [in] Node Pointer to Processor Hierarchy Info CM object which | |
| represents the Processor Hierarchy Node to be generated. | |
| @retval Size of the Processor Hierarchy Node in bytes. | |
| **/ | |
| STATIC | |
| UINT32 | |
| GetProcHierarchyNodeSize ( | |
| IN CONST CM_ARM_PROC_HIERARCHY_INFO *Node | |
| ) | |
| { | |
| ASSERT (Node != NULL); | |
| // <size of Processor Hierarchy Node> + <size of Private Resources array> | |
| return sizeof (EFI_ACPI_6_4_PPTT_STRUCTURE_PROCESSOR) + | |
| (Node->NoOfPrivateResources * sizeof (UINT32)); | |
| } | |
| /** | |
| This macro expands to a function that retrieves the amount of memory required | |
| to store the Processor Hierarchy Nodes (Type 0) and updates the Node Indexer. | |
| */ | |
| GET_SIZE_OF_PPTT_STRUCTS ( | |
| ProcHierarchyNodes, | |
| GetProcHierarchyNodeSize (NodesToIndex), | |
| CM_ARM_PROC_HIERARCHY_INFO | |
| ); | |
| /** | |
| This macro expands to a function that retrieves the amount of memory required | |
| to store the Cache Type Structures (Type 1) and updates the Node Indexer. | |
| */ | |
| GET_SIZE_OF_PPTT_STRUCTS ( | |
| CacheTypeStructs, | |
| sizeof (EFI_ACPI_6_4_PPTT_STRUCTURE_CACHE), | |
| CM_ARM_CACHE_INFO | |
| ); | |
| /** | |
| Search the Node Indexer and return the indexed PPTT node with the given | |
| Token. | |
| @param [in] NodeIndexer Pointer to the Node Indexer array. | |
| @param [in] NodeCount Number of elements in Node Indexer. | |
| @param [in] SearchToken Token used for Node Indexer lookup. | |
| @param [out] IndexedNodeFound Pointer to the Node Indexer array element | |
| with the given Token. | |
| @retval EFI_SUCCESS Success. | |
| @retval EFI_NOT_FOUND No element with a matching token was | |
| found in the Node Indexer array. | |
| **/ | |
| STATIC | |
| EFI_STATUS | |
| GetPpttNodeReferencedByToken ( | |
| IN PPTT_NODE_INDEXER *NodeIndexer, | |
| IN UINT32 NodeCount, | |
| IN CONST CM_OBJECT_TOKEN SearchToken, | |
| OUT PPTT_NODE_INDEXER **IndexedNodeFound | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| ASSERT (NodeIndexer != NULL); | |
| DEBUG (( | |
| DEBUG_INFO, | |
| "PPTT: Node Indexer: SearchToken = %p\n", | |
| SearchToken | |
| )); | |
| while (NodeCount-- != 0) { | |
| DEBUG (( | |
| DEBUG_INFO, | |
| "PPTT: Node Indexer: NodeIndexer->Token = %p. Offset = %d\n", | |
| NodeIndexer->Token, | |
| NodeIndexer->Offset | |
| )); | |
| if (NodeIndexer->Token == SearchToken) { | |
| *IndexedNodeFound = NodeIndexer; | |
| Status = EFI_SUCCESS; | |
| DEBUG (( | |
| DEBUG_INFO, | |
| "PPTT: Node Indexer: Token = %p. Found, Status = %r\n", | |
| SearchToken, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| NodeIndexer++; | |
| } | |
| Status = EFI_NOT_FOUND; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "PPTT: Node Indexer: SearchToken = %p. Status = %r\n", | |
| SearchToken, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| /** | |
| Detect cycles in the processor and cache topology graph represented in | |
| the PPTT table. | |
| @param [in] Generator Pointer to the PPTT Generator. | |
| @retval EFI_SUCCESS There are no cyclic references in the graph. | |
| @retval EFI_INVALID_PARAMETER Processor or cache references form a cycle. | |
| **/ | |
| STATIC | |
| EFI_STATUS | |
| DetectCyclesInTopology ( | |
| IN CONST ACPI_PPTT_GENERATOR *CONST Generator | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| PPTT_NODE_INDEXER *Iterator; | |
| PPTT_NODE_INDEXER *CycleDetector; | |
| UINT32 NodesRemaining; | |
| ASSERT (Generator != NULL); | |
| Iterator = Generator->NodeIndexer; | |
| NodesRemaining = Generator->ProcTopologyStructCount; | |
| while (NodesRemaining != 0) { | |
| DEBUG (( | |
| DEBUG_INFO, | |
| "INFO: PPTT: Cycle detection for element with index %d\n", | |
| Generator->ProcTopologyStructCount - NodesRemaining | |
| )); | |
| CycleDetector = Iterator; | |
| // Walk the topology tree | |
| while (CycleDetector->TopologyParent != NULL) { | |
| DEBUG (( | |
| DEBUG_INFO, | |
| "INFO: PPTT: %p -> %p\n", | |
| CycleDetector->Token, | |
| CycleDetector->TopologyParent->Token | |
| )); | |
| // Check if we have already visited this node | |
| if (CycleDetector->CycleDetectionStamp == NodesRemaining) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Cycle in processor and cache topology detected for " \ | |
| "a chain of references originating from a node with: Token = %p " \ | |
| "Status = %r\n", | |
| Iterator->Token, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| // Stamp the visited node | |
| CycleDetector->CycleDetectionStamp = NodesRemaining; | |
| CycleDetector = CycleDetector->TopologyParent; | |
| } // Continue topology tree walk | |
| Iterator++; | |
| NodesRemaining--; | |
| } // Next Node Indexer | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Update the array of private resources for a given Processor Hierarchy Node. | |
| @param [in] Generator Pointer to the PPTT Generator. | |
| @param [in] CfgMgrProtocol Pointer to the Configuration Manager | |
| Protocol Interface. | |
| @param [in] PrivResArray Pointer to the array of private resources. | |
| @param [in] PrivResCount Number of private resources. | |
| @param [in] PrivResArrayToken Reference Token for the CM_ARM_OBJ_REF | |
| array describing node's private resources. | |
| @retval EFI_SUCCESS Array updated successfully. | |
| @retval EFI_INVALID_PARAMETER A parameter is invalid. | |
| @retval EFI_NOT_FOUND A private resource was not found. | |
| **/ | |
| STATIC | |
| EFI_STATUS | |
| AddPrivateResources ( | |
| IN CONST ACPI_PPTT_GENERATOR *CONST Generator, | |
| IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL *CONST CfgMgrProtocol, | |
| IN UINT32 *PrivResArray, | |
| IN UINT32 PrivResCount, | |
| IN CONST CM_OBJECT_TOKEN PrivResArrayToken | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| CM_ARM_OBJ_REF *CmObjRefs; | |
| UINT32 CmObjRefCount; | |
| PPTT_NODE_INDEXER *PpttNodeFound; | |
| ASSERT ( | |
| (Generator != NULL) && | |
| (CfgMgrProtocol != NULL) && | |
| (PrivResArray != NULL) && | |
| (PrivResCount != 0) | |
| ); | |
| // Validate input arguments | |
| if (PrivResArrayToken == CM_NULL_TOKEN) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: The number of private resources is %d while " \ | |
| "PrivResToken = CM_NULL_TOKEN. Status = %r\n", | |
| PrivResCount, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| CmObjRefCount = 0; | |
| // Get the CM Object References | |
| Status = GetEArmObjCmRef ( | |
| CfgMgrProtocol, | |
| PrivResArrayToken, | |
| &CmObjRefs, | |
| &CmObjRefCount | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to get CM Object References. " \ | |
| "PrivResToken = %p. Status = %r\n", | |
| PrivResArrayToken, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| if (CmObjRefCount != PrivResCount) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: The number of CM Object References retrieved and the " \ | |
| "number of private resources don't match. CmObjRefCount = %d. " \ | |
| "PrivResourceCount = %d. PrivResToken = %p. Status = %r\n", | |
| CmObjRefCount, | |
| PrivResCount, | |
| PrivResArrayToken, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| while (PrivResCount-- != 0) { | |
| if (CmObjRefs->ReferenceToken == CM_NULL_TOKEN) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: CM_NULL_TOKEN provided as reference token for a " \ | |
| "private resource. Status = %r\n", | |
| Status | |
| )); | |
| return Status; | |
| } | |
| // The Node indexer has the Processor hierarchy nodes at the begining | |
| // followed by the cache structs. Therefore we can skip the Processor | |
| // hierarchy nodes in the node indexer search. | |
| Status = GetPpttNodeReferencedByToken ( | |
| Generator->CacheStructIndexedList, | |
| (Generator->ProcTopologyStructCount - | |
| Generator->ProcHierarchyNodeCount), | |
| CmObjRefs->ReferenceToken, | |
| &PpttNodeFound | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to get a private resource with Token = %p from " \ | |
| "Node Indexer. Status = %r\n", | |
| CmObjRefs->ReferenceToken, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| // Update the offset of the private resources in the Processor | |
| // Hierarchy Node structure | |
| *(PrivResArray++) = PpttNodeFound->Offset; | |
| CmObjRefs++; | |
| } | |
| return EFI_SUCCESS; | |
| } | |
| /** | |
| Function to test if two indexed Processor Hierarchy Info objects map to the | |
| same GIC CPU Interface Info object. | |
| This is a callback function that can be invoked by FindDuplicateValue (). | |
| @param [in] Object1 Pointer to the first indexed Processor Hierarchy | |
| Info object. | |
| @param [in] Object2 Pointer to the second indexed Processor Hierarchy | |
| Info object. | |
| @param [in] Index1 Index of Object1 to be displayed for debugging | |
| purposes. | |
| @param [in] Index2 Index of Object2 to be displayed for debugging | |
| purposes. | |
| @retval TRUE Object1 and Object2 have the same GicCToken. | |
| @retval FALSE Object1 and Object2 have different GicCTokens. | |
| **/ | |
| BOOLEAN | |
| EFIAPI | |
| IsGicCTokenEqual ( | |
| IN CONST VOID *Object1, | |
| IN CONST VOID *Object2, | |
| IN UINTN Index1, | |
| IN UINTN Index2 | |
| ) | |
| { | |
| PPTT_NODE_INDEXER *IndexedObject1; | |
| PPTT_NODE_INDEXER *IndexedObject2; | |
| CM_ARM_PROC_HIERARCHY_INFO *ProcNode1; | |
| CM_ARM_PROC_HIERARCHY_INFO *ProcNode2; | |
| ASSERT ( | |
| (Object1 != NULL) && | |
| (Object2 != NULL) | |
| ); | |
| IndexedObject1 = (PPTT_NODE_INDEXER *)Object1; | |
| IndexedObject2 = (PPTT_NODE_INDEXER *)Object2; | |
| ProcNode1 = (CM_ARM_PROC_HIERARCHY_INFO *)IndexedObject1->Object; | |
| ProcNode2 = (CM_ARM_PROC_HIERARCHY_INFO *)IndexedObject2->Object; | |
| if (IS_ACPI_PROC_ID_VALID (ProcNode1) && | |
| IS_ACPI_PROC_ID_VALID (ProcNode2) && | |
| (ProcNode1->GicCToken != CM_NULL_TOKEN) && | |
| (ProcNode2->GicCToken != CM_NULL_TOKEN) && | |
| (ProcNode1->GicCToken == ProcNode2->GicCToken)) | |
| { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Two Processor Hierarchy Info objects (%d and %d) map to " \ | |
| "the same GICC Info object. ACPI Processor IDs are not unique. " \ | |
| "GicCToken = %p.\n", | |
| Index1, | |
| Index2, | |
| ProcNode1->GicCToken | |
| )); | |
| return TRUE; | |
| } | |
| return FALSE; | |
| } | |
| /** | |
| Update the Processor Hierarchy Node (Type 0) information. | |
| This function populates the Processor Hierarchy Nodes with information from | |
| the Configuration Manager and adds this information to the PPTT table. | |
| @param [in] Generator Pointer to the PPTT Generator. | |
| @param [in] CfgMgrProtocol Pointer to the Configuration Manager | |
| Protocol Interface. | |
| @param [in] Pptt Pointer to PPTT table structure. | |
| @param [in] NodesStartOffset Offset from the start of PPTT table to the | |
| start of Processor Hierarchy Nodes. | |
| @retval EFI_SUCCESS Node updated successfully. | |
| @retval EFI_INVALID_PARAMETER A parameter is invalid. | |
| @retval EFI_NOT_FOUND The required object was not found. | |
| **/ | |
| STATIC | |
| EFI_STATUS | |
| AddProcHierarchyNodes ( | |
| IN CONST ACPI_PPTT_GENERATOR *CONST Generator, | |
| IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL *CONST CfgMgrProtocol, | |
| IN CONST EFI_ACPI_6_4_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER *Pptt, | |
| IN CONST UINT32 NodesStartOffset | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_ACPI_6_4_PPTT_STRUCTURE_PROCESSOR *ProcStruct; | |
| UINT32 *PrivateResources; | |
| BOOLEAN IsGicCTokenDuplicated; | |
| CM_ARM_GICC_INFO *GicCInfoList; | |
| UINT32 GicCInfoCount; | |
| UINT32 UniqueGicCRefCount; | |
| PPTT_NODE_INDEXER *PpttNodeFound; | |
| CM_ARM_PROC_HIERARCHY_INFO *ProcInfoNode; | |
| PPTT_NODE_INDEXER *ProcNodeIterator; | |
| UINT32 NodeCount; | |
| UINT32 Length; | |
| ASSERT ( | |
| (Generator != NULL) && | |
| (CfgMgrProtocol != NULL) && | |
| (Pptt != NULL) | |
| ); | |
| ProcStruct = (EFI_ACPI_6_4_PPTT_STRUCTURE_PROCESSOR *)((UINT8 *)Pptt + | |
| NodesStartOffset); | |
| ProcNodeIterator = Generator->ProcHierarchyNodeIndexedList; | |
| NodeCount = Generator->ProcHierarchyNodeCount; | |
| // Check if every GICC Object is referenced by onlu one Proc Node | |
| IsGicCTokenDuplicated = FindDuplicateValue ( | |
| ProcNodeIterator, | |
| NodeCount, | |
| sizeof (PPTT_NODE_INDEXER), | |
| IsGicCTokenEqual | |
| ); | |
| // Duplicate GIC CPU Interface Token was found so two PPTT Processor Hierarchy | |
| // Nodes map to the same MADT GICC structure | |
| if (IsGicCTokenDuplicated) { | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| UniqueGicCRefCount = 0; | |
| while (NodeCount-- != 0) { | |
| ProcInfoNode = (CM_ARM_PROC_HIERARCHY_INFO *)ProcNodeIterator->Object; | |
| // Check if the private resource count is within the size limit | |
| // imposed on the Processor Hierarchy node by the specification. | |
| // Note: The length field is 8 bit wide while the number of private | |
| // resource field is 32 bit wide. | |
| Length = GetProcHierarchyNodeSize (ProcInfoNode); | |
| if (Length > MAX_UINT8) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Too many private resources. Count = %d. " \ | |
| "Maximum supported Processor Node size exceeded. " \ | |
| "Token = %p. Status = %r\n", | |
| ProcInfoNode->NoOfPrivateResources, | |
| ProcInfoNode->ParentToken, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| // Populate the node header | |
| ProcStruct->Type = EFI_ACPI_6_4_PPTT_TYPE_PROCESSOR; | |
| ProcStruct->Length = (UINT8)Length; | |
| ProcStruct->Reserved[0] = EFI_ACPI_RESERVED_BYTE; | |
| ProcStruct->Reserved[1] = EFI_ACPI_RESERVED_BYTE; | |
| // Populate the flags | |
| ProcStruct->Flags.PhysicalPackage = ProcInfoNode->Flags & BIT0; | |
| ProcStruct->Flags.AcpiProcessorIdValid = (ProcInfoNode->Flags & BIT1) >> 1; | |
| ProcStruct->Flags.ProcessorIsAThread = (ProcInfoNode->Flags & BIT2) >> 2; | |
| ProcStruct->Flags.NodeIsALeaf = (ProcInfoNode->Flags & BIT3) >> 3; | |
| ProcStruct->Flags.IdenticalImplementation = | |
| (ProcInfoNode->Flags & BIT4) >> 4; | |
| ProcStruct->Flags.Reserved = 0; | |
| // Populate the parent reference | |
| if (ProcInfoNode->ParentToken == CM_NULL_TOKEN) { | |
| ProcStruct->Parent = 0; | |
| } else { | |
| Status = GetPpttNodeReferencedByToken ( | |
| Generator->ProcHierarchyNodeIndexedList, | |
| Generator->ProcHierarchyNodeCount, | |
| ProcInfoNode->ParentToken, | |
| &PpttNodeFound | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to get parent processor hierarchy node " \ | |
| "reference. ParentToken = %p. ChildToken = %p. Status = %r\n", | |
| ProcInfoNode->ParentToken, | |
| ProcInfoNode->Token, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| // Test if the reference is to a 'leaf' node | |
| if (IS_PROC_NODE_LEAF ( | |
| ((CM_ARM_PROC_HIERARCHY_INFO *)PpttNodeFound->Object) | |
| )) | |
| { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Reference to a leaf Processor Hierarchy Node. " \ | |
| "ParentToken = %p. ChildToken = %p. Status = %r\n", | |
| ProcInfoNode->ParentToken, | |
| ProcInfoNode->Token, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| // Update Proc Structure with the offset of the parent node | |
| ProcStruct->Parent = PpttNodeFound->Offset; | |
| // Store the reference for the parent node in the Node Indexer | |
| // so that this can be used later for cycle detection | |
| ProcNodeIterator->TopologyParent = PpttNodeFound; | |
| } | |
| // Populate ACPI Processor ID | |
| if (!IS_ACPI_PROC_ID_VALID (ProcInfoNode)) { | |
| // Default invalid ACPI Processor ID to 0 | |
| ProcStruct->AcpiProcessorId = 0; | |
| } else if (ProcInfoNode->GicCToken == CM_NULL_TOKEN) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: The 'ACPI Processor ID valid' flag is set but no GICC " \ | |
| "structure token was provided. GicCToken = %p. RequestorToken = %p. " \ | |
| "Status = %r\n", | |
| ProcInfoNode->GicCToken, | |
| ProcInfoNode->Token, | |
| Status | |
| )); | |
| return Status; | |
| } else { | |
| Status = GetEArmObjGicCInfo ( | |
| CfgMgrProtocol, | |
| ProcInfoNode->GicCToken, | |
| &GicCInfoList, | |
| &GicCInfoCount | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to get GICC structure. ACPI Processor ID " \ | |
| "can't be populated. GicCToken = %p. RequestorToken = %p. " \ | |
| "Status = %r\n", | |
| ProcInfoNode->GicCToken, | |
| ProcInfoNode->Token, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| if (GicCInfoCount != 1) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to find a unique GICC structure. " \ | |
| "ACPI Processor ID can't be populated. " \ | |
| "GICC Structure Count = %d. GicCToken = %p. RequestorToken = %p " \ | |
| "Status = %r\n", | |
| GicCInfoCount, | |
| ProcInfoNode->GicCToken, | |
| ProcInfoNode->Token, | |
| Status | |
| )); | |
| return Status; | |
| } | |
| // Update the ACPI Processor Id | |
| ProcStruct->AcpiProcessorId = GicCInfoList->AcpiProcessorUid; | |
| // Increment the reference count for the number of | |
| // Unique GICC objects that were retrieved. | |
| UniqueGicCRefCount++; | |
| } | |
| ProcStruct->NumberOfPrivateResources = ProcInfoNode->NoOfPrivateResources; | |
| PrivateResources = (UINT32 *)((UINT8 *)ProcStruct + | |
| sizeof (EFI_ACPI_6_4_PPTT_STRUCTURE_PROCESSOR)); | |
| if (ProcStruct->NumberOfPrivateResources != 0) { | |
| // Populate the private resources array | |
| Status = AddPrivateResources ( | |
| Generator, | |
| CfgMgrProtocol, | |
| PrivateResources, | |
| ProcStruct->NumberOfPrivateResources, | |
| ProcInfoNode->PrivateResourcesArrayToken | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to populate the private resources array. " \ | |
| "Status = %r\n", | |
| Status | |
| )); | |
| return Status; | |
| } | |
| } | |
| // Next Processor Hierarchy Node | |
| ProcStruct = (EFI_ACPI_6_4_PPTT_STRUCTURE_PROCESSOR *)((UINT8 *)ProcStruct + | |
| ProcStruct->Length); | |
| ProcNodeIterator++; | |
| } // Processor Hierarchy Node | |
| // Knowing the total number of GICC references made and that all GICC Token | |
| // references are unique, we can test if no GICC instances have been left out. | |
| Status = GetEArmObjGicCInfo ( | |
| CfgMgrProtocol, | |
| CM_NULL_TOKEN, | |
| &GicCInfoList, | |
| &GicCInfoCount | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to get GICC Info. Status = %r\n", | |
| Status | |
| )); | |
| return Status; | |
| } | |
| // MADT - PPTT cross validation | |
| // This checks that one and only one GICC structure is referenced by a | |
| // Processor Hierarchy Node in the PPTT. | |
| // Since we have already checked that the GICC objects referenced by the | |
| // Proc Nodes are unique, the UniqueGicCRefCount cannot be greater than | |
| // the total number of GICC objects in the platform. | |
| if (GicCInfoCount > UniqueGicCRefCount) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: %d GICC structure(s) exposed by MADT don't have " \ | |
| "a corresponding Processor Hierarchy Node. Status = %r\n", | |
| GicCInfoCount - UniqueGicCRefCount, | |
| Status | |
| )); | |
| } | |
| return Status; | |
| } | |
| /** | |
| Test whether CacheId is unique among the CacheIdList. | |
| @param [in] CacheId Cache ID to check. | |
| @param [in] CacheIdList List of already existing cache IDs. | |
| @param [in] CacheIdListSize Size of CacheIdList. | |
| @retval TRUE CacheId does not exist in CacheIdList. | |
| @retval FALSE CacheId already exists in CacheIdList. | |
| **/ | |
| STATIC | |
| BOOLEAN | |
| IsCacheIdUnique ( | |
| IN CONST UINT32 CacheId, | |
| IN CONST UINT32 *CacheIdList, | |
| IN CONST UINT32 CacheIdListSize | |
| ) | |
| { | |
| UINT32 Index; | |
| for (Index = 0; Index < CacheIdListSize; Index++) { | |
| if (CacheIdList[Index] == CacheId) { | |
| return FALSE; | |
| } | |
| } | |
| return TRUE; | |
| } | |
| /** | |
| Update the Cache Type Structure (Type 1) information. | |
| This function populates the Cache Type Structures with information from | |
| the Configuration Manager and adds this information to the PPTT table. | |
| @param [in] Generator Pointer to the PPTT Generator. | |
| @param [in] CfgMgrProtocol Pointer to the Configuration Manager | |
| Protocol Interface. | |
| @param [in] Pptt Pointer to PPTT table structure. | |
| @param [in] NodesStartOffset Offset from the start of PPTT table to the | |
| start of Cache Type Structures. | |
| @param [in] Revision Revision of the PPTT table being requested. | |
| @retval EFI_SUCCESS Structures updated successfully. | |
| @retval EFI_INVALID_PARAMETER A parameter is invalid. | |
| @retval EFI_NOT_FOUND A required object was not found. | |
| @retval EFI_OUT_OF_RESOURCES Out of resources. | |
| **/ | |
| STATIC | |
| EFI_STATUS | |
| AddCacheTypeStructures ( | |
| IN CONST ACPI_PPTT_GENERATOR *CONST Generator, | |
| IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL *CONST CfgMgrProtocol, | |
| IN CONST EFI_ACPI_6_4_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER *Pptt, | |
| IN CONST UINT32 NodesStartOffset, | |
| IN CONST UINT32 Revision | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| EFI_ACPI_6_4_PPTT_STRUCTURE_CACHE *CacheStruct; | |
| PPTT_NODE_INDEXER *PpttNodeFound; | |
| CM_ARM_CACHE_INFO *CacheInfoNode; | |
| PPTT_NODE_INDEXER *CacheNodeIterator; | |
| UINT32 NodeCount; | |
| BOOLEAN CacheIdUnique; | |
| UINT32 NodeIndex; | |
| UINT32 *FoundCacheIds; | |
| ASSERT ( | |
| (Generator != NULL) && | |
| (CfgMgrProtocol != NULL) && | |
| (Pptt != NULL) | |
| ); | |
| CacheStruct = (EFI_ACPI_6_4_PPTT_STRUCTURE_CACHE *)((UINT8 *)Pptt + | |
| NodesStartOffset); | |
| CacheNodeIterator = Generator->CacheStructIndexedList; | |
| NodeCount = Generator->CacheStructCount; | |
| FoundCacheIds = AllocateZeroPool (NodeCount * sizeof (*FoundCacheIds)); | |
| if (FoundCacheIds == NULL) { | |
| DEBUG ((DEBUG_ERROR, "ERROR: PPTT: Failed to allocate resources.\n")); | |
| return EFI_OUT_OF_RESOURCES; | |
| } | |
| for (NodeIndex = 0; NodeIndex < NodeCount; NodeIndex++) { | |
| CacheInfoNode = (CM_ARM_CACHE_INFO *)CacheNodeIterator->Object; | |
| // Populate the node header | |
| CacheStruct->Type = EFI_ACPI_6_4_PPTT_TYPE_CACHE; | |
| CacheStruct->Length = sizeof (EFI_ACPI_6_4_PPTT_STRUCTURE_CACHE); | |
| CacheStruct->Reserved[0] = EFI_ACPI_RESERVED_BYTE; | |
| CacheStruct->Reserved[1] = EFI_ACPI_RESERVED_BYTE; | |
| // "On Arm-based systems, all cache properties must be provided in the | |
| // table." (ACPI 6.4, Section 5.2.29.2) | |
| CacheStruct->Flags.SizePropertyValid = 1; | |
| CacheStruct->Flags.NumberOfSetsValid = 1; | |
| CacheStruct->Flags.AssociativityValid = 1; | |
| CacheStruct->Flags.AllocationTypeValid = 1; | |
| CacheStruct->Flags.CacheTypeValid = 1; | |
| CacheStruct->Flags.WritePolicyValid = 1; | |
| CacheStruct->Flags.LineSizeValid = 1; | |
| CacheStruct->Flags.CacheIdValid = 1; | |
| CacheStruct->Flags.Reserved = 0; | |
| // Populate the reference to the next level of cache | |
| if (CacheInfoNode->NextLevelOfCacheToken == CM_NULL_TOKEN) { | |
| CacheStruct->NextLevelOfCache = 0; | |
| } else { | |
| Status = GetPpttNodeReferencedByToken ( | |
| Generator->CacheStructIndexedList, | |
| Generator->CacheStructCount, | |
| CacheInfoNode->NextLevelOfCacheToken, | |
| &PpttNodeFound | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to get the reference to the Next Level of " \ | |
| "Cache. NextLevelOfCacheToken = %p. RequestorToken = %p. " \ | |
| "Status = %r\n", | |
| CacheInfoNode->NextLevelOfCacheToken, | |
| CacheInfoNode->Token, | |
| Status | |
| )); | |
| goto cleanup; | |
| } | |
| // Update Cache Structure with the offset for the next level of cache | |
| CacheStruct->NextLevelOfCache = PpttNodeFound->Offset; | |
| // Store the next level of cache information in the Node Indexer | |
| // so that this can be used later for cycle detection | |
| CacheNodeIterator->TopologyParent = PpttNodeFound; | |
| } | |
| CacheStruct->Size = CacheInfoNode->Size; | |
| // Validate and populate the 'Number of sets' field | |
| if (CacheInfoNode->NumberOfSets > PPTT_ARM_CCIDX_CACHE_NUMBER_OF_SETS_MAX) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: When ARMv8.3-CCIDX is implemented the maximum number " \ | |
| "of sets can be %d. NumberOfSets = %d. Status = %r\n", | |
| PPTT_ARM_CCIDX_CACHE_NUMBER_OF_SETS_MAX, | |
| CacheInfoNode->NumberOfSets, | |
| Status | |
| )); | |
| goto cleanup; | |
| } | |
| if (CacheInfoNode->NumberOfSets > PPTT_ARM_CACHE_NUMBER_OF_SETS_MAX) { | |
| DEBUG (( | |
| DEBUG_INFO, | |
| "INFO: PPTT: When ARMv8.3-CCIDX is not implemented the maximum " \ | |
| "number of sets can be %d. NumberOfSets = %d\n", | |
| PPTT_ARM_CACHE_NUMBER_OF_SETS_MAX, | |
| CacheInfoNode->NumberOfSets | |
| )); | |
| } | |
| CacheStruct->NumberOfSets = CacheInfoNode->NumberOfSets; | |
| // Validate Associativity field based on maximum associativity | |
| // supported by ACPI Cache type structure. | |
| if (CacheInfoNode->Associativity > MAX_UINT8) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: The maximum associativity supported by ACPI " \ | |
| "Cache type structure is %d. Associativity = %d, Status = %r\n", | |
| MAX_UINT8, | |
| CacheInfoNode->Associativity, | |
| Status | |
| )); | |
| goto cleanup; | |
| } | |
| // Validate the Associativity field based on the architecture specification | |
| // The architecture supports much larger associativity values than the | |
| // current ACPI specification. | |
| // These checks will be needed in the future when the ACPI specification | |
| // is extended. Disabling this code for now. | |
| #if 0 | |
| if (CacheInfoNode->Associativity > PPTT_ARM_CCIDX_CACHE_ASSOCIATIVITY_MAX) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: When ARMv8.3-CCIDX is implemented the maximum cache " \ | |
| "associativity can be %d. Associativity = %d. Status = %r\n", | |
| PPTT_ARM_CCIDX_CACHE_ASSOCIATIVITY_MAX, | |
| CacheInfoNode->Associativity, | |
| Status | |
| )); | |
| goto cleanup; | |
| } | |
| if (CacheInfoNode->Associativity > PPTT_ARM_CACHE_ASSOCIATIVITY_MAX) { | |
| DEBUG (( | |
| DEBUG_INFO, | |
| "INFO: PPTT: When ARMv8.3-CCIDX is not implemented the maximum " \ | |
| "cache associativity can be %d. Associativity = %d\n", | |
| PPTT_ARM_CACHE_ASSOCIATIVITY_MAX, | |
| CacheInfoNode->Associativity | |
| )); | |
| } | |
| #endif | |
| // Note a typecast is needed as the maximum associativity | |
| // supported by ACPI Cache type structure is MAX_UINT8. | |
| CacheStruct->Associativity = (UINT8)CacheInfoNode->Associativity; | |
| // Populate cache attributes | |
| CacheStruct->Attributes.AllocationType = | |
| CacheInfoNode->Attributes & (BIT0 | BIT1); | |
| CacheStruct->Attributes.CacheType = | |
| (CacheInfoNode->Attributes & (BIT2 | BIT3)) >> 2; | |
| CacheStruct->Attributes.WritePolicy = | |
| (CacheInfoNode->Attributes & BIT4) >> 4; | |
| CacheStruct->Attributes.Reserved = 0; | |
| // Validate and populate cache line size | |
| if ((CacheInfoNode->LineSize < PPTT_ARM_CACHE_LINE_SIZE_MIN) || | |
| (CacheInfoNode->LineSize > PPTT_ARM_CACHE_LINE_SIZE_MAX)) | |
| { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: The cache line size must be between %d and %d bytes " \ | |
| "on ARM Platforms. LineSize = %d. Status = %r\n", | |
| PPTT_ARM_CACHE_LINE_SIZE_MIN, | |
| PPTT_ARM_CACHE_LINE_SIZE_MAX, | |
| CacheInfoNode->LineSize, | |
| Status | |
| )); | |
| goto cleanup; | |
| } | |
| if ((CacheInfoNode->LineSize & (CacheInfoNode->LineSize - 1)) != 0) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: The cache line size is not a power of 2. " \ | |
| "LineSize = %d. Status = %r\n", | |
| CacheInfoNode->LineSize, | |
| Status | |
| )); | |
| goto cleanup; | |
| } | |
| CacheStruct->LineSize = CacheInfoNode->LineSize; | |
| if (Revision >= 3) { | |
| // Validate and populate cache id | |
| if (CacheInfoNode->CacheId == 0) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: The cache id cannot be zero. Status = %r\n", | |
| Status | |
| )); | |
| goto cleanup; | |
| } | |
| CacheIdUnique = IsCacheIdUnique ( | |
| CacheInfoNode->CacheId, | |
| FoundCacheIds, | |
| NodeIndex | |
| ); | |
| if (!CacheIdUnique) { | |
| Status = EFI_INVALID_PARAMETER; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: The cache id is not unique. " \ | |
| "CacheId = %d. Status = %r\n", | |
| CacheInfoNode->CacheId, | |
| Status | |
| )); | |
| goto cleanup; | |
| } | |
| // Store the cache id so we can check future cache ids for uniqueness | |
| FoundCacheIds[NodeIndex] = CacheInfoNode->CacheId; | |
| CacheStruct->CacheId = CacheInfoNode->CacheId; | |
| } | |
| // Next Cache Type Structure | |
| CacheStruct = (EFI_ACPI_6_4_PPTT_STRUCTURE_CACHE *)((UINT8 *)CacheStruct + | |
| CacheStruct->Length); | |
| CacheNodeIterator++; | |
| } // for Cache Type Structure | |
| Status = EFI_SUCCESS; | |
| cleanup: | |
| FreePool (FoundCacheIds); | |
| return Status; | |
| } | |
| /** | |
| Construct the PPTT ACPI table. | |
| This function invokes the Configuration Manager protocol interface | |
| to get the required hardware information for generating the ACPI | |
| table. | |
| If this function allocates any resources then they must be freed | |
| in the FreeXXXXTableResources function. | |
| @param [in] This Pointer to the table generator. | |
| @param [in] AcpiTableInfo Pointer to the ACPI table generator to be used. | |
| @param [in] CfgMgrProtocol Pointer to the Configuration Manager | |
| Protocol Interface. | |
| @param [out] Table Pointer to the constructed ACPI Table. | |
| @retval EFI_SUCCESS Table generated successfully. | |
| @retval EFI_INVALID_PARAMETER A parameter is invalid. | |
| @retval EFI_NOT_FOUND The required object was not found. | |
| @retval EFI_BAD_BUFFER_SIZE The size returned by the Configuration | |
| Manager is less than the Object size for | |
| the requested object. | |
| **/ | |
| STATIC | |
| EFI_STATUS | |
| EFIAPI | |
| BuildPpttTable ( | |
| IN CONST ACPI_TABLE_GENERATOR *CONST This, | |
| IN CONST CM_STD_OBJ_ACPI_TABLE_INFO *CONST AcpiTableInfo, | |
| IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL *CONST CfgMgrProtocol, | |
| OUT EFI_ACPI_DESCRIPTION_HEADER **CONST Table | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| UINT32 TableSize; | |
| UINT32 ProcTopologyStructCount; | |
| UINT32 ProcHierarchyNodeCount; | |
| UINT32 CacheStructCount; | |
| UINT32 ProcHierarchyNodeOffset; | |
| UINT32 CacheStructOffset; | |
| CM_ARM_PROC_HIERARCHY_INFO *ProcHierarchyNodeList; | |
| CM_ARM_CACHE_INFO *CacheStructList; | |
| ACPI_PPTT_GENERATOR *Generator; | |
| // Pointer to the Node Indexer array | |
| PPTT_NODE_INDEXER *NodeIndexer; | |
| EFI_ACPI_6_4_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER *Pptt; | |
| ASSERT ( | |
| (This != NULL) && | |
| (AcpiTableInfo != NULL) && | |
| (CfgMgrProtocol != NULL) && | |
| (Table != NULL) && | |
| (AcpiTableInfo->TableGeneratorId == This->GeneratorID) && | |
| (AcpiTableInfo->AcpiTableSignature == This->AcpiTableSignature) | |
| ); | |
| if ((AcpiTableInfo->AcpiTableRevision < This->MinAcpiTableRevision) || | |
| (AcpiTableInfo->AcpiTableRevision > This->AcpiTableRevision)) | |
| { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Requested table revision = %d is not supported. " | |
| "Supported table revisions: Minimum = %d. Maximum = %d\n", | |
| AcpiTableInfo->AcpiTableRevision, | |
| This->MinAcpiTableRevision, | |
| This->AcpiTableRevision | |
| )); | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| Generator = (ACPI_PPTT_GENERATOR *)This; | |
| *Table = NULL; | |
| // Get the processor hierarchy info and update the processor topology | |
| // structure count with Processor Hierarchy Nodes (Type 0) | |
| Status = GetEArmObjProcHierarchyInfo ( | |
| CfgMgrProtocol, | |
| CM_NULL_TOKEN, | |
| &ProcHierarchyNodeList, | |
| &ProcHierarchyNodeCount | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to get processor hierarchy info. Status = %r\n", | |
| Status | |
| )); | |
| goto error_handler; | |
| } | |
| ProcTopologyStructCount = ProcHierarchyNodeCount; | |
| Generator->ProcHierarchyNodeCount = ProcHierarchyNodeCount; | |
| // Get the cache info and update the processor topology structure count with | |
| // Cache Type Structures (Type 1) | |
| Status = GetEArmObjCacheInfo ( | |
| CfgMgrProtocol, | |
| CM_NULL_TOKEN, | |
| &CacheStructList, | |
| &CacheStructCount | |
| ); | |
| if (EFI_ERROR (Status) && (Status != EFI_NOT_FOUND)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to get cache info. Status = %r\n", | |
| Status | |
| )); | |
| goto error_handler; | |
| } | |
| ProcTopologyStructCount += CacheStructCount; | |
| Generator->CacheStructCount = CacheStructCount; | |
| // Allocate Node Indexer array | |
| NodeIndexer = (PPTT_NODE_INDEXER *)AllocateZeroPool ( | |
| sizeof (PPTT_NODE_INDEXER) * | |
| ProcTopologyStructCount | |
| ); | |
| if (NodeIndexer == NULL) { | |
| Status = EFI_OUT_OF_RESOURCES; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to allocate memory for Node Indexer. Status = %r\n ", | |
| Status | |
| )); | |
| goto error_handler; | |
| } | |
| DEBUG ((DEBUG_INFO, "INFO: NodeIndexer = %p\n", NodeIndexer)); | |
| Generator->ProcTopologyStructCount = ProcTopologyStructCount; | |
| Generator->NodeIndexer = NodeIndexer; | |
| // Calculate the size of the PPTT table | |
| TableSize = sizeof (EFI_ACPI_6_4_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER); | |
| // Include the size of Processor Hierarchy Nodes and index them | |
| if (Generator->ProcHierarchyNodeCount != 0) { | |
| ProcHierarchyNodeOffset = TableSize; | |
| Generator->ProcHierarchyNodeIndexedList = NodeIndexer; | |
| TableSize += GetSizeofProcHierarchyNodes ( | |
| ProcHierarchyNodeOffset, | |
| ProcHierarchyNodeList, | |
| Generator->ProcHierarchyNodeCount, | |
| &NodeIndexer | |
| ); | |
| DEBUG (( | |
| DEBUG_INFO, | |
| " ProcHierarchyNodeCount = %d\n" \ | |
| " ProcHierarchyNodeOffset = 0x%x\n" \ | |
| " ProcHierarchyNodeIndexedList = 0x%p\n", | |
| Generator->ProcHierarchyNodeCount, | |
| ProcHierarchyNodeOffset, | |
| Generator->ProcHierarchyNodeIndexedList | |
| )); | |
| } | |
| // Include the size of Cache Type Structures and index them | |
| if (Generator->CacheStructCount != 0) { | |
| CacheStructOffset = TableSize; | |
| Generator->CacheStructIndexedList = NodeIndexer; | |
| TableSize += GetSizeofCacheTypeStructs ( | |
| CacheStructOffset, | |
| CacheStructList, | |
| Generator->CacheStructCount, | |
| &NodeIndexer | |
| ); | |
| DEBUG (( | |
| DEBUG_INFO, | |
| " CacheStructCount = %d\n" \ | |
| " CacheStructOffset = 0x%x\n" \ | |
| " CacheStructIndexedList = 0x%p\n", | |
| Generator->CacheStructCount, | |
| CacheStructOffset, | |
| Generator->CacheStructIndexedList | |
| )); | |
| } | |
| DEBUG (( | |
| DEBUG_INFO, | |
| "INFO: PPTT:\n" \ | |
| " ProcTopologyStructCount = %d\n" \ | |
| " TableSize = %d\n", | |
| ProcTopologyStructCount, | |
| TableSize | |
| )); | |
| // Allocate the Buffer for the PPTT table | |
| *Table = (EFI_ACPI_DESCRIPTION_HEADER *)AllocateZeroPool (TableSize); | |
| if (*Table == NULL) { | |
| Status = EFI_OUT_OF_RESOURCES; | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to allocate memory for PPTT Table. " \ | |
| "Size = %d. Status = %r\n", | |
| TableSize, | |
| Status | |
| )); | |
| goto error_handler; | |
| } | |
| Pptt = (EFI_ACPI_6_4_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_HEADER *)*Table; | |
| DEBUG (( | |
| DEBUG_INFO, | |
| "PPTT: Pptt = 0x%p. TableSize = 0x%x\n", | |
| Pptt, | |
| TableSize | |
| )); | |
| // Add ACPI header | |
| Status = AddAcpiHeader ( | |
| CfgMgrProtocol, | |
| This, | |
| &Pptt->Header, | |
| AcpiTableInfo, | |
| TableSize | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to add ACPI header. Status = %r\n", | |
| Status | |
| )); | |
| goto error_handler; | |
| } | |
| // Add Processor Hierarchy Nodes (Type 0) to the generated table | |
| if (Generator->ProcHierarchyNodeCount != 0) { | |
| Status = AddProcHierarchyNodes ( | |
| Generator, | |
| CfgMgrProtocol, | |
| Pptt, | |
| ProcHierarchyNodeOffset | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to add Processor Hierarchy Nodes. Status = %r\n", | |
| Status | |
| )); | |
| goto error_handler; | |
| } | |
| } | |
| // Add Cache Type Structures (Type 1) to the generated table | |
| if (Generator->CacheStructCount != 0) { | |
| Status = AddCacheTypeStructures ( | |
| Generator, | |
| CfgMgrProtocol, | |
| Pptt, | |
| CacheStructOffset, | |
| AcpiTableInfo->AcpiTableRevision | |
| ); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Failed to add Cache Type Structures. Status = %r\n", | |
| Status | |
| )); | |
| goto error_handler; | |
| } | |
| } | |
| // Validate CM object cross-references in PPTT | |
| Status = DetectCyclesInTopology (Generator); | |
| if (EFI_ERROR (Status)) { | |
| DEBUG (( | |
| DEBUG_ERROR, | |
| "ERROR: PPTT: Invalid processor and cache topology. Status = %r\n", | |
| Status | |
| )); | |
| goto error_handler; | |
| } | |
| return Status; | |
| error_handler: | |
| if (Generator->NodeIndexer != NULL) { | |
| FreePool (Generator->NodeIndexer); | |
| Generator->NodeIndexer = NULL; | |
| } | |
| if (*Table != NULL) { | |
| FreePool (*Table); | |
| *Table = NULL; | |
| } | |
| return Status; | |
| } | |
| /** | |
| Free any resources allocated for constructing the PPTT | |
| @param [in] This Pointer to the table generator. | |
| @param [in] AcpiTableInfo Pointer to the ACPI Table Info. | |
| @param [in] CfgMgrProtocol Pointer to the Configuration Manager | |
| Protocol Interface. | |
| @param [in, out] Table Pointer to the ACPI Table. | |
| @retval EFI_SUCCESS The resources were freed successfully. | |
| @retval EFI_INVALID_PARAMETER The table pointer is NULL or invalid. | |
| **/ | |
| STATIC | |
| EFI_STATUS | |
| FreePpttTableResources ( | |
| IN CONST ACPI_TABLE_GENERATOR *CONST This, | |
| IN CONST CM_STD_OBJ_ACPI_TABLE_INFO *CONST AcpiTableInfo, | |
| IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL *CONST CfgMgrProtocol, | |
| IN OUT EFI_ACPI_DESCRIPTION_HEADER **CONST Table | |
| ) | |
| { | |
| ACPI_PPTT_GENERATOR *Generator; | |
| ASSERT ( | |
| (This != NULL) && | |
| (AcpiTableInfo != NULL) && | |
| (CfgMgrProtocol != NULL) && | |
| (AcpiTableInfo->TableGeneratorId == This->GeneratorID) && | |
| (AcpiTableInfo->AcpiTableSignature == This->AcpiTableSignature) | |
| ); | |
| Generator = (ACPI_PPTT_GENERATOR *)This; | |
| // Free any memory allocated by the generator | |
| if (Generator->NodeIndexer != NULL) { | |
| FreePool (Generator->NodeIndexer); | |
| Generator->NodeIndexer = NULL; | |
| } | |
| if ((Table == NULL) || (*Table == NULL)) { | |
| DEBUG ((DEBUG_ERROR, "ERROR: PPTT: Invalid Table Pointer\n")); | |
| ASSERT ( | |
| (Table != NULL) && | |
| (*Table != NULL) | |
| ); | |
| return EFI_INVALID_PARAMETER; | |
| } | |
| FreePool (*Table); | |
| *Table = NULL; | |
| return EFI_SUCCESS; | |
| } | |
| /** The PPTT Table Generator revision. | |
| */ | |
| #define PPTT_GENERATOR_REVISION CREATE_REVISION (1, 0) | |
| /** The interface for the PPTT Table Generator. | |
| */ | |
| STATIC | |
| ACPI_PPTT_GENERATOR PpttGenerator = { | |
| // ACPI table generator header | |
| { | |
| // Generator ID | |
| CREATE_STD_ACPI_TABLE_GEN_ID (EStdAcpiTableIdPptt), | |
| // Generator Description | |
| L"ACPI.STD.PPTT.GENERATOR", | |
| // ACPI Table Signature | |
| EFI_ACPI_6_4_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_STRUCTURE_SIGNATURE, | |
| // ACPI Table Revision supported by this Generator | |
| EFI_ACPI_6_4_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_REVISION, | |
| // Minimum supported ACPI Table Revision | |
| EFI_ACPI_6_3_PROCESSOR_PROPERTIES_TOPOLOGY_TABLE_REVISION, | |
| // Creator ID | |
| TABLE_GENERATOR_CREATOR_ID_ARM, | |
| // Creator Revision | |
| PPTT_GENERATOR_REVISION, | |
| // Build Table function | |
| BuildPpttTable, | |
| // Free Resource function | |
| FreePpttTableResources, | |
| // Extended build function not needed | |
| NULL, | |
| // Extended build function not implemented by the generator. | |
| // Hence extended free resource function is not required. | |
| NULL | |
| }, | |
| // PPTT Generator private data | |
| // Processor topology node count | |
| 0, | |
| // Count of Processor Hierarchy Nodes | |
| 0, | |
| // Count of Cache Structures | |
| 0, | |
| // Pointer to PPTT Node Indexer | |
| NULL | |
| }; | |
| /** | |
| Register the Generator with the ACPI Table Factory. | |
| @param [in] ImageHandle The handle to the image. | |
| @param [in] SystemTable Pointer to the System Table. | |
| @retval EFI_SUCCESS The Generator is registered. | |
| @retval EFI_INVALID_PARAMETER A parameter is invalid. | |
| @retval EFI_ALREADY_STARTED The Generator for the Table ID | |
| is already registered. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| AcpiPpttLibConstructor ( | |
| IN EFI_HANDLE ImageHandle, | |
| IN EFI_SYSTEM_TABLE *SystemTable | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| Status = RegisterAcpiTableGenerator (&PpttGenerator.Header); | |
| DEBUG ((DEBUG_INFO, "PPTT: Register Generator. Status = %r\n", Status)); | |
| ASSERT_EFI_ERROR (Status); | |
| return Status; | |
| } | |
| /** | |
| Deregister the Generator from the ACPI Table Factory. | |
| @param [in] ImageHandle The handle to the image. | |
| @param [in] SystemTable Pointer to the System Table. | |
| @retval EFI_SUCCESS The Generator is deregistered. | |
| @retval EFI_INVALID_PARAMETER A parameter is invalid. | |
| @retval EFI_NOT_FOUND The Generator is not registered. | |
| **/ | |
| EFI_STATUS | |
| EFIAPI | |
| AcpiPpttLibDestructor ( | |
| IN EFI_HANDLE ImageHandle, | |
| IN EFI_SYSTEM_TABLE *SystemTable | |
| ) | |
| { | |
| EFI_STATUS Status; | |
| Status = DeregisterAcpiTableGenerator (&PpttGenerator.Header); | |
| DEBUG ((DEBUG_INFO, "PPTT: Deregister Generator. Status = %r\n", Status)); | |
| ASSERT_EFI_ERROR (Status); | |
| return Status; | |
| } |