DynamicTablesPkg/Library/Common/TableHelperLib/ConfigurationManagerObjectParser.c

   1 /** @file
   2   Configuration Manager Object parser.
   3
   4   Copyright (c) 2021, ARM Limited. All rights reserved.<BR>
   5   SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9 #include <Library/BaseLib.h>
  10 #include <Library/DebugLib.h>
  11 #include <ConfigurationManagerObject.h>
  12 #include "ConfigurationManagerObjectParser.h"
  13
  14 STATIC
  15 VOID
  16 EFIAPI
  17 PrintOemId (
  18   CONST CHAR8  *Format,
  19   UINT8        *Ptr
  20   );
  21
  22 /** A parser for EArmObjBootArchInfo.
  23 */
  24 STATIC CONST CM_OBJ_PARSER  CmArmBootArchInfoParser[] = {
  25   { "BootArchFlags", 2, "0x%x", NULL }
  26 };
  27
  28 /** A parser for EArmObjPowerManagementProfileInfo.
  29 */
  30 STATIC CONST CM_OBJ_PARSER  CmArmPowerManagementProfileInfoParser[] = {
  31   { "PowerManagementProfile", 1, "0x%x", NULL }
  32 };
  33
  34 /** A parser for EArmObjGicCInfo.
  35 */
  36 STATIC CONST CM_OBJ_PARSER  CmArmGicCInfoParser[] = {
  37   { "CPUInterfaceNumber",            4, "0x%x",   NULL },
  38   { "AcpiProcessorUid",              4, "0x%x",   NULL },
  39   { "Flags",                         4, "0x%x",   NULL },
  40   { "ParkingProtocolVersion",        4, "0x%x",   NULL },
  41   { "PerformanceInterruptGsiv",      4, "0x%x",   NULL },
  42   { "ParkedAddress",                 8, "0x%llx", NULL },
  43   { "PhysicalBaseAddress",           8, "0x%llx", NULL },
  44   { "GICV",                          8, "0x%llx", NULL },
  45   { "GICH",                          8, "0x%llx", NULL },
  46   { "VGICMaintenanceInterrupt",      4, "0x%x",   NULL },
  47   { "GICRBaseAddress",               8, "0x%llx", NULL },
  48   { "MPIDR",                         8, "0x%llx", NULL },
  49   { "ProcessorPowerEfficiencyClass", 1, "0x%x",   NULL },
  50   { "SpeOverflowInterrupt",          2, "0x%x",   NULL },
  51   { "ProximityDomain",               4, "0x%x",   NULL },
  52   { "ClockDomain",                   4, "0x%x",   NULL },
  53   { "AffinityFlags",                 4, "0x%x",   NULL }
  54 };
  55
  56 /** A parser for EArmObjGicDInfo.
  57 */
  58 STATIC CONST CM_OBJ_PARSER  CmArmGicDInfoParser[] = {
  59   { "PhysicalBaseAddress", 8, "0x%llx", NULL },
  60   { "SystemVectorBase",    4, "0x%x",   NULL },
  61   { "GicVersion",          1, "0x%x",   NULL },
  62 };
  63
  64 /** A parser for EArmObjGicMsiFrameInfo.
  65 */
  66 STATIC CONST CM_OBJ_PARSER  CmArmGicMsiFrameInfoParser[] = {
  67   { "GicMsiFrameId",       4, "0x%x",   NULL },
  68   { "PhysicalBaseAddress", 8, "0x%llx", NULL },
  69   { "Flags",               4, "0x%x",   NULL },
  70   { "SPICount",            2, "0x%x",   NULL },
  71   { "SPIBase",             2, "0x%x",   NULL }
  72 };
  73
  74 /** A parser for EArmObjGicRedistributorInfo.
  75 */
  76 STATIC CONST CM_OBJ_PARSER  CmArmGicRedistInfoParser[] = {
  77   { "DiscoveryRangeBaseAddress", 8, "0x%llx", NULL },
  78   { "DiscoveryRangeLength",      4, "0x%x",   NULL }
  79 };
  80
  81 /** A parser for EArmObjGicItsInfo.
  82 */
  83 STATIC CONST CM_OBJ_PARSER  CmArmGicItsInfoParser[] = {
  84   { "GicItsId",            4, "0x%x",   NULL },
  85   { "PhysicalBaseAddress", 8, "0x%llx", NULL },
  86   { "ProximityDomain",     4, "0x%x",   NULL }
  87 };
  88
  89 /** A parser for EArmObjSerialConsolePortInfo,
  90     EArmObjSerialDebugPortInfo and EArmObjSerialPortInfo.
  91 */
  92 STATIC CONST CM_OBJ_PARSER  CmArmSerialPortInfoParser[] = {
  93   { "BaseAddress",       8, "0x%llx", NULL },
  94   { "Interrupt",         4, "0x%x",   NULL },
  95   { "BaudRate",          8, "0x%llx", NULL },
  96   { "Clock",             4, "0x%x",   NULL },
  97   { "PortSubtype",       2, "0x%x",   NULL },
  98   { "BaseAddressLength", 8, "0x%llx", NULL },
  99   { "AccessSize",        1, "0x%d",   NULL }
 100 };
 101
 102 /** A parser for EArmObjGenericTimerInfo.
 103 */
 104 STATIC CONST CM_OBJ_PARSER  CmArmGenericTimerInfoParser[] = {
 105   { "CounterControlBaseAddress", 8, "0x%llx", NULL },
 106   { "CounterReadBaseAddress",    8, "0x%llx", NULL },
 107   { "SecurePL1TimerGSIV",        4, "0x%x",   NULL },
 108   { "SecurePL1TimerFlags",       4, "0x%x",   NULL },
 109   { "NonSecurePL1TimerGSIV",     4, "0x%x",   NULL },
 110   { "NonSecurePL1TimerFlags",    4, "0x%x",   NULL },
 111   { "VirtualTimerGSIV",          4, "0x%x",   NULL },
 112   { "VirtualTimerFlags",         4, "0x%x",   NULL },
 113   { "NonSecurePL2TimerGSIV",     4, "0x%x",   NULL },
 114   { "NonSecurePL2TimerFlags",    4, "0x%x",   NULL },
 115   { "VirtualPL2TimerGSIV",       4, "0x%x",   NULL },
 116   { "VirtualPL2TimerFlags",      4, "0x%x",   NULL }
 117 };
 118
 119 /** A parser for EArmObjPlatformGTBlockInfo.
 120 */
 121 STATIC CONST CM_OBJ_PARSER  CmArmGTBlockTimerFrameInfoParser[] = {
 122   { "FrameNumber",               1, "0x%x",   NULL },
 123   { "PhysicalAddressCntBase",    8, "0x%llx", NULL },
 124   { "PhysicalAddressCntEL0Base", 8, "0x%llx", NULL },
 125   { "PhysicalTimerGSIV",         4, "0x%x",   NULL },
 126   { "PhysicalTimerFlags",        4, "0x%x",   NULL },
 127   { "VirtualTimerGSIV",          4, "0x%x",   NULL },
 128   { "VirtualTimerFlags",         4, "0x%x",   NULL },
 129   { "CommonFlags",               4, "0x%x",   NULL }
 130 };
 131
 132 /** A parser for EArmObjGTBlockTimerFrameInfo.
 133 */
 134 STATIC CONST CM_OBJ_PARSER  CmArmGTBlockInfoParser[] = {
 135   { "GTBlockPhysicalAddress", 8,                        "0x%llx", NULL },
 136   { "GTBlockTimerFrameCount", 4,                        "0x%x",   NULL },
 137   { "GTBlockTimerFrameToken", sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL }
 138 };
 139
 140 /** A parser for EArmObjPlatformGenericWatchdogInfo.
 141 */
 142 STATIC CONST CM_OBJ_PARSER  CmArmGenericWatchdogInfoParser[] = {
 143   { "ControlFrameAddress", 8, "0x%llx", NULL },
 144   { "RefreshFrameAddress", 8, "0x%llx", NULL },
 145   { "TimerGSIV",           4, "0x%x",   NULL },
 146   { "Flags",               4, "0x%x",   NULL }
 147 };
 148
 149 /** A parser for EArmObjPciConfigSpaceInfo.
 150 */
 151 STATIC CONST CM_OBJ_PARSER  CmArmPciConfigSpaceInfoParser[] = {
 152   { "BaseAddress",           8, "0x%llx", NULL },
 153   { "PciSegmentGroupNumber", 2, "0x%x",   NULL },
 154   { "StartBusNumber",        1, "0x%x",   NULL },
 155   { "EndBusNumber",          1, "0x%x",   NULL }
 156 };
 157
 158 /** A parser for EArmObjHypervisorVendorIdentity.
 159 */
 160 STATIC CONST CM_OBJ_PARSER  CmArmHypervisorVendorIdParser[] = {
 161   { "HypervisorVendorId", 8, "0x%llx", NULL }
 162 };
 163
 164 /** A parser for EArmObjFixedFeatureFlags.
 165 */
 166 STATIC CONST CM_OBJ_PARSER  CmArmFixedFeatureFlagsParser[] = {
 167   { "Flags", 4, "0x%x", NULL }
 168 };
 169
 170 /** A parser for EArmObjItsGroup.
 171 */
 172 STATIC CONST CM_OBJ_PARSER  CmArmItsGroupNodeParser[] = {
 173   { "Token",      sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 174   { "ItsIdCount", 4,                        "0x%x", NULL },
 175   { "ItsIdToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL }
 176 };
 177
 178 /** A parser for EArmObjNamedComponent.
 179 */
 180 STATIC CONST CM_OBJ_PARSER  CmArmNamedComponentNodeParser[] = {
 181   { "Token",             sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 182   { "IdMappingCount",    4,                        "0x%x", NULL },
 183   { "IdMappingToken",    sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 184   { "Flags",             4,                        "0x%x", NULL },
 185   { "CacheCoherent",     4,                        "0x%x", NULL },
 186   { "AllocationHints",   1,                        "0x%x", NULL },
 187   { "MemoryAccessFlags", 1,                        "0x%x", NULL },
 188   { "AddressSizeLimit",  1,                        "0x%x", NULL },
 189   { "ObjectName",        sizeof (CHAR8 *),         "%a",   NULL }
 190 };
 191
 192 /** A parser for EArmObjRootComplex.
 193 */
 194 STATIC CONST CM_OBJ_PARSER  CmArmRootComplexNodeParser[] = {
 195   { "Token",             sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 196   { "IdMappingCount",    4,                        "0x%x", NULL },
 197   { "IdMappingToken",    sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 198   { "CacheCoherent",     4,                        "0x%x", NULL },
 199   { "AllocationHints",   1,                        "0x%x", NULL },
 200   { "MemoryAccessFlags", 1,                        "0x%x", NULL },
 201   { "AtsAttribute",      4,                        "0x%x", NULL },
 202   { "PciSegmentNumber",  4,                        "0x%x", NULL },
 203   { "MemoryAddressSize", 1,                        "0x%x", NULL }
 204 };
 205
 206 /** A parser for EArmObjSmmuV1SmmuV2.
 207 */
 208 STATIC CONST CM_OBJ_PARSER  CmArmSmmuV1SmmuV2NodeParser[] = {
 209   { "Token",                 sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 210   { "IdMappingCount",        4,                        "0x%x",   NULL },
 211   { "IdMappingToken",        sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 212   { "BaseAddress",           8,                        "0x%llx", NULL },
 213   { "Span",                  8,                        "0x%llx", NULL },
 214   { "Model",                 4,                        "0x%x",   NULL },
 215   { "Flags",                 4,                        "0x%x",   NULL },
 216   { "ContextInterruptCount", 4,                        "0x%x",   NULL },
 217   { "ContextInterruptToken", sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 218   { "PmuInterruptCount",     4,                        "0x%x",   NULL },
 219   { "PmuInterruptToken",     sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 220   { "SMMU_NSgIrpt",          4,                        "0x%x",   NULL },
 221   { "SMMU_NSgIrptFlags",     4,                        "0x%x",   NULL },
 222   { "SMMU_NSgCfgIrpt",       4,                        "0x%x",   NULL },
 223   { "SMMU_NSgCfgIrptFlags",  4,                        "0x%x",   NULL }
 224 };
 225
 226 /** A parser for EArmObjSmmuV3.
 227 */
 228 STATIC CONST CM_OBJ_PARSER  CmArmSmmuV3NodeParser[] = {
 229   { "Token",                sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 230   { "IdMappingCount",       4,                        "0x%x",   NULL },
 231   { "IdMappingToken",       sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 232   { "BaseAddress",          8,                        "0x%llx", NULL },
 233   { "Flags",                4,                        "0x%x",   NULL },
 234   { "VatosAddress",         8,                        "0x%llx", NULL },
 235   { "Model",                4,                        "0x%x",   NULL },
 236   { "EventInterrupt",       4,                        "0x%x",   NULL },
 237   { "PriInterrupt",         4,                        "0x%x",   NULL },
 238   { "GerrInterrupt",        4,                        "0x%x",   NULL },
 239   { "SyncInterrupt",        4,                        "0x%x",   NULL },
 240   { "ProximityDomain",      4,                        "0x%x",   NULL },
 241   { "DeviceIdMappingIndex", 4,                        "0x%x",   NULL }
 242 };
 243
 244 /** A parser for EArmObjPmcg.
 245 */
 246 STATIC CONST CM_OBJ_PARSER  CmArmPmcgNodeParser[] = {
 247   { "Token",             sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 248   { "IdMappingCount",    4,                        "0x%x",   NULL },
 249   { "IdMappingToken",    sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 250   { "BaseAddress",       8,                        "0x%llx", NULL },
 251   { "OverflowInterrupt", 4,                        "0x%x",   NULL },
 252   { "Page1BaseAddress",  8,                        "0x%llx", NULL },
 253   { "ReferenceToken",    sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL }
 254 };
 255
 256 /** A parser for EArmObjGicItsIdentifierArray.
 257 */
 258 STATIC CONST CM_OBJ_PARSER  CmArmGicItsIdentifierParser[] = {
 259   { "ItsId", 4, "0x%x", NULL }
 260 };
 261
 262 /** A parser for EArmObjIdMappingArray.
 263 */
 264 STATIC CONST CM_OBJ_PARSER  CmArmIdMappingParser[] = {
 265   { "InputBase",            4,                        "0x%x", NULL },
 266   { "NumIds",               4,                        "0x%x", NULL },
 267   { "OutputBase",           4,                        "0x%x", NULL },
 268   { "OutputReferenceToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 269   { "Flags",                4,                        "0x%x", NULL }
 270 };
 271
 272 /** A parser for EArmObjSmmuInterruptArray.
 273 */
 274 STATIC CONST CM_OBJ_PARSER  CmArmGenericInterruptParser[] = {
 275   { "Interrupt", 4, "0x%x", NULL },
 276   { "Flags",     4, "0x%x", NULL }
 277 };
 278
 279 /** A parser for EArmObjProcHierarchyInfo.
 280 */
 281 STATIC CONST CM_OBJ_PARSER  CmArmProcHierarchyInfoParser[] = {
 282   { "Token",                      sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 283   { "Flags",                      4,                        "0x%x", NULL },
 284   { "ParentToken",                sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 285   { "GicCToken",                  sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 286   { "NoOfPrivateResources",       4,                        "0x%x", NULL },
 287   { "PrivateResourcesArrayToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL }
 288 };
 289
 290 /** A parser for EArmObjCacheInfo.
 291 */
 292 STATIC CONST CM_OBJ_PARSER  CmArmCacheInfoParser[] = {
 293   { "Token",                 sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 294   { "NextLevelOfCacheToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 295   { "Size",                  4,                        "0x%x", NULL },
 296   { "NumberOfSets",          4,                        "0x%x", NULL },
 297   { "Associativity",         4,                        "0x%x", NULL },
 298   { "Attributes",            1,                        "0x%x", NULL },
 299   { "LineSize",              2,                        "0x%x", NULL }
 300 };
 301
 302 /** A parser for EArmObjProcNodeIdInfo.
 303 */
 304 STATIC CONST CM_OBJ_PARSER  CmArmProcNodeIdInfoParser[] = {
 305   { "Token",    sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 306   { "VendorId", 4,                        "0x%p", NULL },
 307   { "Level1Id", 8,                        "0x%x", NULL },
 308   { "Level2Id", 8,                        "0x%x", NULL },
 309   { "MajorRev", 2,                        "0x%x", NULL },
 310   { "MinorRev", 2,                        "0x%x", NULL },
 311   { "SpinRev",  2,                        "0x%x", NULL }
 312 };
 313
 314 /** A parser for EArmObjCmRef.
 315 */
 316 STATIC CONST CM_OBJ_PARSER  CmArmObjRefParser[] = {
 317   { "ReferenceToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL }
 318 };
 319
 320 /** A parser for EArmObjMemoryAffinityInfo.
 321 */
 322 STATIC CONST CM_OBJ_PARSER  CmArmMemoryAffinityInfoParser[] = {
 323   { "ProximityDomain", 4, "0x%x",   NULL },
 324   { "BaseAddress",     8, "0x%llx", NULL },
 325   { "Length",          8, "0x%llx", NULL },
 326   { "Flags",           4, "0x%x",   NULL }
 327 };
 328
 329 /** A parser for EArmObjDeviceHandleAcpi.
 330 */
 331 STATIC CONST CM_OBJ_PARSER  CmArmDeviceHandleAcpiParser[] = {
 332   { "Hid", 8, "0x%llx", NULL },
 333   { "Uid", 4, "0x%x",   NULL }
 334 };
 335
 336 /** A parser for EArmObjDeviceHandlePci.
 337 */
 338 STATIC CONST CM_OBJ_PARSER  CmArmDeviceHandlePciParser[] = {
 339   { "SegmentNumber",  2, "0x%x", NULL },
 340   { "BusNumber",      1, "0x%x", NULL },
 341   { "DeviceNumber",   1, "0x%x", NULL },
 342   { "FunctionNumber", 1, "0x%x", NULL }
 343 };
 344
 345 /** A parser for EArmObjGenericInitiatorAffinityInfo.
 346 */
 347 STATIC CONST CM_OBJ_PARSER  CmArmGenericInitiatorAffinityInfoParser[] = {
 348   { "ProximityDomain",   4,                        "0x%x", NULL },
 349   { "Flags",             4,                        "0x%x", NULL },
 350   { "DeviceHandleType",  1,                        "0x%x", NULL },
 351   { "DeviceHandleToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL }
 352 };
 353
 354 /** A parser for EArmObjCmn600Info.
 355 */
 356 STATIC CONST CM_OBJ_PARSER  CmArmCmn600InfoParser[] = {
 357   { "PeriphBaseAddress",       8, "0x%llx", NULL },
 358   { "PeriphBaseAddressLength", 8, "0x%llx", NULL },
 359   { "RootNodeBaseAddress",     8, "0x%llx", NULL },
 360   { "DtcCount",                1, "0x%x",   NULL },
 361   { "DtcInterrupt[0]",         4, "0x%x",   NULL },
 362   { "DtcFlags[0]",             4, "0x%x",   NULL },
 363   { "DtcInterrupt[1]",         4, "0x%x",   NULL },
 364   { "DtcFlags[1]",             4, "0x%x",   NULL },
 365   { "DtcInterrupt[2]",         4, "0x%x",   NULL },
 366   { "DtcFlags[2]",             4, "0x%x",   NULL },
 367   { "DtcInterrupt[3]",         4, "0x%x",   NULL },
 368   { "DtcFlags[3]",             4, "0x%x",   NULL }
 369 };
 370
 371 /** A parser for the EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE structure.
 372 */
 373 STATIC CONST CM_OBJ_PARSER  AcpiGenericAddressParser[] = {
 374   { "AddressSpaceId",    1, "%d",     NULL },
 375   { "RegisterBitWidth",  1, "%d",     NULL },
 376   { "RegisterBitOffset", 1, "%d",     NULL },
 377   { "AccessSize",        1, "%d",     NULL },
 378   { "Address",           8, "0x%llx", NULL },
 379 };
 380
 381 /** A parser for EArmObjLpiInfo.
 382 */
 383 STATIC CONST CM_OBJ_PARSER  CmArmLpiInfoParser[] = {
 384   { "MinResidency",             4,                                               "0x%llx", NULL },
 385   { "WorstCaseWakeLatency",     4,                                               "0x%llx", NULL },
 386   { "Flags",                    4,                                               "0x%llx", NULL },
 387   { "ArchFlags",                4,                                               "0x%llx", NULL },
 388   { "ResCntFreq",               4,                                               "0x%llx", NULL },
 389   { "EnableParentState",        4,                                               "0x%llx", NULL },
 390   { "IsInteger",                1,                                               "%d",     NULL },
 391   { "IntegerEntryMethod",       8,                                               "0x%llx", NULL },
 392   { "RegisterEntryMethod",      sizeof (EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE),
 393     NULL, NULL, AcpiGenericAddressParser,
 394     ARRAY_SIZE (AcpiGenericAddressParser) },
 395   { "ResidencyCounterRegister", sizeof (EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE),
 396     NULL, NULL, AcpiGenericAddressParser,
 397     ARRAY_SIZE (AcpiGenericAddressParser) },
 398   { "UsageCounterRegister",     sizeof (EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE),
 399     NULL, NULL, AcpiGenericAddressParser,
 400     ARRAY_SIZE (AcpiGenericAddressParser) },
 401   { "StateName",                16,                                              "0x%a",   NULL },
 402 };
 403
 404 /** A parser for Arm namespace objects.
 405 */
 406 STATIC CONST CM_OBJ_PARSER_ARRAY  ArmNamespaceObjectParser[] = {
 407   { "EArmObjReserved",                     NULL,                                  0                                },
 408   { "EArmObjBootArchInfo",                 CmArmBootArchInfoParser,
 409     ARRAY_SIZE (CmArmBootArchInfoParser) },
 410   { "EArmObjCpuInfo",                      NULL,                                  0                                },
 411   { "EArmObjPowerManagementProfileInfo",   CmArmPowerManagementProfileInfoParser,
 412     ARRAY_SIZE (CmArmPowerManagementProfileInfoParser) },
 413   { "EArmObjGicCInfo",                     CmArmGicCInfoParser,                   ARRAY_SIZE (CmArmGicCInfoParser) },
 414   { "EArmObjGicDInfo",                     CmArmGicDInfoParser,                   ARRAY_SIZE (CmArmGicDInfoParser) },
 415   { "EArmObjGicMsiFrameInfo",              CmArmGicMsiFrameInfoParser,
 416     ARRAY_SIZE (CmArmGicMsiFrameInfoParser) },
 417   { "EArmObjGicRedistributorInfo",         CmArmGicRedistInfoParser,
 418     ARRAY_SIZE (CmArmGicRedistInfoParser) },
 419   { "EArmObjGicItsInfo",                   CmArmGicItsInfoParser,
 420     ARRAY_SIZE (CmArmGicItsInfoParser) },
 421   { "EArmObjSerialConsolePortInfo",        CmArmSerialPortInfoParser,
 422     ARRAY_SIZE (CmArmSerialPortInfoParser) },
 423   { "EArmObjSerialDebugPortInfo",          CmArmSerialPortInfoParser,
 424     ARRAY_SIZE (CmArmSerialPortInfoParser) },
 425   { "EArmObjGenericTimerInfo",             CmArmGenericTimerInfoParser,
 426     ARRAY_SIZE (CmArmGenericTimerInfoParser) },
 427   { "EArmObjPlatformGTBlockInfo",          CmArmGTBlockTimerFrameInfoParser,
 428     ARRAY_SIZE (CmArmGTBlockTimerFrameInfoParser) },
 429   { "EArmObjGTBlockTimerFrameInfo",        CmArmGTBlockInfoParser,
 430     ARRAY_SIZE (CmArmGTBlockInfoParser) },
 431   { "EArmObjPlatformGenericWatchdogInfo",  CmArmGenericWatchdogInfoParser,
 432     ARRAY_SIZE (CmArmGenericWatchdogInfoParser) },
 433   { "EArmObjPciConfigSpaceInfo",           CmArmPciConfigSpaceInfoParser,
 434     ARRAY_SIZE (CmArmPciConfigSpaceInfoParser) },
 435   { "EArmObjHypervisorVendorIdentity",     CmArmHypervisorVendorIdParser,
 436     ARRAY_SIZE (CmArmHypervisorVendorIdParser) },
 437   { "EArmObjFixedFeatureFlags",            CmArmFixedFeatureFlagsParser,
 438     ARRAY_SIZE (CmArmFixedFeatureFlagsParser) },
 439   { "EArmObjItsGroup",                     CmArmItsGroupNodeParser,
 440     ARRAY_SIZE (CmArmItsGroupNodeParser) },
 441   { "EArmObjNamedComponent",               CmArmNamedComponentNodeParser,
 442     ARRAY_SIZE (CmArmNamedComponentNodeParser) },
 443   { "EArmObjRootComplex",                  CmArmRootComplexNodeParser,
 444     ARRAY_SIZE (CmArmRootComplexNodeParser) },
 445   { "EArmObjSmmuV1SmmuV2",                 CmArmSmmuV1SmmuV2NodeParser,
 446     ARRAY_SIZE (CmArmSmmuV1SmmuV2NodeParser) },
 447   { "EArmObjSmmuV3",                       CmArmSmmuV3NodeParser,
 448     ARRAY_SIZE (CmArmSmmuV3NodeParser) },
 449   { "EArmObjPmcg",                         CmArmPmcgNodeParser,                   ARRAY_SIZE (CmArmPmcgNodeParser) },
 450   { "EArmObjGicItsIdentifierArray",        CmArmGicItsIdentifierParser,
 451     ARRAY_SIZE (CmArmGicItsIdentifierParser) },
 452   { "EArmObjIdMappingArray",               CmArmIdMappingParser,
 453     ARRAY_SIZE (CmArmIdMappingParser) },
 454   { "EArmObjSmmuInterruptArray",           CmArmGenericInterruptParser,
 455     ARRAY_SIZE (CmArmGenericInterruptParser) },
 456   { "EArmObjProcHierarchyInfo",            CmArmProcHierarchyInfoParser,
 457     ARRAY_SIZE (CmArmProcHierarchyInfoParser) },
 458   { "EArmObjCacheInfo",                    CmArmCacheInfoParser,
 459     ARRAY_SIZE (CmArmCacheInfoParser) },
 460   { "EArmObjProcNodeIdInfo",               CmArmProcNodeIdInfoParser,
 461     ARRAY_SIZE (CmArmProcNodeIdInfoParser) },
 462   { "EArmObjCmRef",                        CmArmObjRefParser,                     ARRAY_SIZE (CmArmObjRefParser)   },
 463   { "EArmObjMemoryAffinityInfo",           CmArmMemoryAffinityInfoParser,
 464     ARRAY_SIZE (CmArmMemoryAffinityInfoParser) },
 465   { "EArmObjDeviceHandleAcpi",             CmArmDeviceHandleAcpiParser,
 466     ARRAY_SIZE (CmArmDeviceHandleAcpiParser) },
 467   { "EArmObjDeviceHandlePci",              CmArmDeviceHandlePciParser,
 468     ARRAY_SIZE (CmArmDeviceHandlePciParser) },
 469   { "EArmObjGenericInitiatorAffinityInfo",
 470     CmArmGenericInitiatorAffinityInfoParser,
 471     ARRAY_SIZE (CmArmGenericInitiatorAffinityInfoParser) },
 472   { "EArmObjSerialPortInfo",               CmArmSerialPortInfoParser,
 473     ARRAY_SIZE (CmArmSerialPortInfoParser) },
 474   { "EArmObjCmn600Info",                   CmArmCmn600InfoParser,
 475     ARRAY_SIZE (CmArmCmn600InfoParser) },
 476   { "EArmObjLpiInfo",                      CmArmLpiInfoParser,
 477     ARRAY_SIZE (CmArmLpiInfoParser) },
 478   { "EArmObjMax",                          NULL,                                  0                                },
 479 };
 480
 481 /** A parser for EStdObjCfgMgrInfo.
 482 */
 483 STATIC CONST CM_OBJ_PARSER  StdObjCfgMgrInfoParser[] = {
 484   { "Revision", 4, "0x%x",         NULL       },
 485   { "OemId[6]", 6, "%C%C%C%C%C%C", PrintOemId }
 486 };
 487
 488 /** A parser for EStdObjAcpiTableList.
 489 */
 490 STATIC CONST CM_OBJ_PARSER  StdObjAcpiTableInfoParser[] = {
 491   { "AcpiTableSignature", 4,                                      "0x%x",   NULL },
 492   { "AcpiTableRevision",  1,                                      "%d",     NULL },
 493   { "TableGeneratorId",   sizeof (ACPI_TABLE_GENERATOR_ID),       "0x%x",   NULL },
 494   { "AcpiTableData",      sizeof (EFI_ACPI_DESCRIPTION_HEADER *), "0x%p",   NULL },
 495   { "OemTableId",         8,                                      "0x%LLX", NULL },
 496   { "OemRevision",        4,                                      "0x%x",   NULL }
 497 };
 498
 499 /** A parser for EStdObjSmbiosTableList.
 500 */
 501 STATIC CONST CM_OBJ_PARSER  StdObjSmbiosTableInfoParser[] = {
 502   { "TableGeneratorId", sizeof (SMBIOS_TABLE_GENERATOR_ID), "0x%x", NULL },
 503   { "SmbiosTableData",  sizeof (SMBIOS_STRUCTURE *),        "0x%p", NULL }
 504 };
 505
 506 /** A parser for Standard namespace objects.
 507 */
 508 STATIC CONST CM_OBJ_PARSER_ARRAY  StdNamespaceObjectParser[] = {
 509   { "EStdObjCfgMgrInfo",      StdObjCfgMgrInfoParser,
 510     ARRAY_SIZE (StdObjCfgMgrInfoParser) },
 511   { "EStdObjAcpiTableList",   StdObjAcpiTableInfoParser,
 512     ARRAY_SIZE (StdObjAcpiTableInfoParser) },
 513   { "EStdObjSmbiosTableList", StdObjSmbiosTableInfoParser,
 514     ARRAY_SIZE (StdObjSmbiosTableInfoParser) },
 515 };
 516
 517 /** Print OEM Id.
 518
 519   @param [in]  Format  Format to print the Ptr.
 520   @param [in]  Ptr     Pointer to the OEM Id.
 521 **/
 522 STATIC
 523 VOID
 524 EFIAPI
 525 PrintOemId (
 526   IN  CONST CHAR8  *Format,
 527   IN  UINT8        *Ptr
 528   )
 529 {
 530   DEBUG ((
 531     DEBUG_ERROR,
 532     (Format != NULL) ? Format : "%C%C%C%C%C%C",
 533     Ptr[0],
 534     Ptr[1],
 535     Ptr[2],
 536     Ptr[3],
 537     Ptr[4],
 538     Ptr[5]
 539     ));
 540 }
 541
 542 /** Print fields of the objects.
 543
 544   @param [in]  Data           Pointer to the object to print.
 545   @param [in]  Parser         Parser containing the object fields.
 546   @param [in]  ItemCount      Number of entries/fields in the Parser.
 547   @param [in]  RemainingSize  Parse at most *RemainingSize bytes.
 548                               This function decrements the value
 549                               from the number bytes consumed.
 550   @param [in]  IndentLevel    Indentation to use when printing.
 551 **/
 552 STATIC
 553 VOID
 554 PrintCmObjDesc (
 555   IN        VOID           *Data,
 556   IN  CONST CM_OBJ_PARSER  *Parser,
 557   IN        UINTN          ItemCount,
 558   IN        INTN           *RemainingSize,
 559   IN        UINT32         IndentLevel
 560   )
 561 {
 562   UINT32  Index;
 563   UINT32  IndentIndex;
 564   INTN    SubStructSize;
 565
 566   if ((Data == NULL)    ||
 567       (Parser == NULL)  ||
 568       (ItemCount == 0)  ||
 569       (RemainingSize == NULL))
 570   {
 571     ASSERT (0);
 572     return;
 573   }
 574
 575   // Print each field.
 576   for (Index = 0; Index < ItemCount; Index++) {
 577     // Check there is enough space in left.
 578     *RemainingSize -= Parser[Index].Length;
 579     if (*RemainingSize < 0) {
 580       DEBUG ((
 581         DEBUG_ERROR,
 582         "\nERROR: %a: Buffer overrun\n",
 583         Parser[Index].NameStr
 584         ));
 585       ASSERT (0);
 586       return;
 587     }
 588
 589     // Indentation
 590     for (IndentIndex = 0; IndentIndex < IndentLevel; IndentIndex++) {
 591       DEBUG ((DEBUG_ERROR, "  "));
 592     }
 593
 594     DEBUG ((
 595       DEBUG_ERROR,
 596       "%-*a :",
 597       OUTPUT_FIELD_COLUMN_WIDTH - 2 * IndentLevel,
 598       Parser[Index].NameStr
 599       ));
 600     if (Parser[Index].PrintFormatter != NULL) {
 601       Parser[Index].PrintFormatter (Parser[Index].Format, Data);
 602     } else if (Parser[Index].Format != NULL) {
 603       switch (Parser[Index].Length) {
 604         case 1:
 605           DEBUG ((DEBUG_ERROR, Parser[Index].Format, *(UINT8 *)Data));
 606           break;
 607         case 2:
 608           DEBUG ((DEBUG_ERROR, Parser[Index].Format, *(UINT16 *)Data));
 609           break;
 610         case 4:
 611           DEBUG ((DEBUG_ERROR, Parser[Index].Format, *(UINT32 *)Data));
 612           break;
 613         case 8:
 614           DEBUG ((DEBUG_ERROR, Parser[Index].Format, ReadUnaligned64 (Data)));
 615           break;
 616         default:
 617           DEBUG ((
 618             DEBUG_ERROR,
 619             "\nERROR: %a: CANNOT PARSE THIS FIELD, Field Length = %d\n",
 620             Parser[Index].NameStr,
 621             Parser[Index].Length
 622             ));
 623       } // switch
 624     } else if (Parser[Index].SubObjParser != NULL) {
 625       SubStructSize = Parser[Index].Length;
 626
 627       DEBUG ((DEBUG_ERROR, "\n"));
 628       PrintCmObjDesc (
 629         Data,
 630         Parser[Index].SubObjParser,
 631         Parser[Index].SubObjItemCount,
 632         &SubStructSize,
 633         IndentLevel + 1
 634         );
 635     } else {
 636       ASSERT (0);
 637       DEBUG ((
 638         DEBUG_ERROR,
 639         "\nERROR: %a: CANNOT PARSE THIS FIELD, Field Length = %d\n",
 640         Parser[Index].NameStr,
 641         Parser[Index].Length
 642         ));
 643     }
 644
 645     DEBUG ((DEBUG_ERROR, "\n"));
 646     Data = (UINT8 *)Data + Parser[Index].Length;
 647   } // for
 648 }
 649
 650 /** Parse and print a CmObjDesc.
 651
 652   @param [in]  CmObjDesc  The CmObjDesc to parse and print.
 653 **/
 654 VOID
 655 EFIAPI
 656 ParseCmObjDesc (
 657   IN  CONST CM_OBJ_DESCRIPTOR  *CmObjDesc
 658   )
 659 {
 660   UINTN                       ObjId;
 661   UINTN                       NameSpaceId;
 662   UINT32                      ObjIndex;
 663   UINT32                      ObjectCount;
 664   INTN                        RemainingSize;
 665   CONST  CM_OBJ_PARSER_ARRAY  *ParserArray;
 666
 667   if ((CmObjDesc == NULL) || (CmObjDesc->Data == NULL)) {
 668     return;
 669   }
 670
 671   NameSpaceId = GET_CM_NAMESPACE_ID (CmObjDesc->ObjectId);
 672   ObjId       = GET_CM_OBJECT_ID (CmObjDesc->ObjectId);
 673
 674   switch (NameSpaceId) {
 675     case EObjNameSpaceStandard:
 676       if (ObjId >= EStdObjMax) {
 677         ASSERT (0);
 678         return;
 679       }
 680
 681       ParserArray = &StdNamespaceObjectParser[ObjId];
 682       break;
 683     case EObjNameSpaceArm:
 684       if (ObjId >= EArmObjMax) {
 685         ASSERT (0);
 686         return;
 687       }
 688
 689       ParserArray = &ArmNamespaceObjectParser[ObjId];
 690       break;
 691     default:
 692       // Not supported
 693       ASSERT (0);
 694       return;
 695   } // switch
 696
 697   ObjectCount   = CmObjDesc->Count;
 698   RemainingSize = CmObjDesc->Size;
 699
 700   for (ObjIndex = 0; ObjIndex < ObjectCount; ObjIndex++) {
 701     DEBUG ((
 702       DEBUG_ERROR,
 703       "\n%-*a [%d/%d]:\n",
 704       OUTPUT_FIELD_COLUMN_WIDTH,
 705       ParserArray->ObjectName,
 706       ObjIndex + 1,
 707       ObjectCount
 708       ));
 709     PrintCmObjDesc (
 710       CmObjDesc->Data,
 711       ParserArray->Parser,
 712       ParserArray->ItemCount,
 713       &RemainingSize,
 714       1
 715       );
 716   } // for
 717 }