DynamicTablesPkg/Library/Common/TableHelperLib/ConfigurationManagerObjectParser.c

   1 /** @file
   2   Configuration Manager Object parser.
   3
   4   Copyright (c) 2021 - 2022, 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 STATIC
  23 VOID
  24 EFIAPI
  25 PrintString (
  26   CONST CHAR8  *Format,
  27   UINT8        *Ptr
  28   );
  29
  30 /** A parser for EArmObjBootArchInfo.
  31 */
  32 STATIC CONST CM_OBJ_PARSER  CmArmBootArchInfoParser[] = {
  33   { "BootArchFlags", 2, "0x%x", NULL }
  34 };
  35
  36 /** A parser for EArmObjPowerManagementProfileInfo.
  37 */
  38 STATIC CONST CM_OBJ_PARSER  CmArmPowerManagementProfileInfoParser[] = {
  39   { "PowerManagementProfile", 1, "0x%x", NULL }
  40 };
  41
  42 /** A parser for EArmObjGicCInfo.
  43 */
  44 STATIC CONST CM_OBJ_PARSER  CmArmGicCInfoParser[] = {
  45   { "CPUInterfaceNumber",            4,                        "0x%x",   NULL },
  46   { "AcpiProcessorUid",              4,                        "0x%x",   NULL },
  47   { "Flags",                         4,                        "0x%x",   NULL },
  48   { "ParkingProtocolVersion",        4,                        "0x%x",   NULL },
  49   { "PerformanceInterruptGsiv",      4,                        "0x%x",   NULL },
  50   { "ParkedAddress",                 8,                        "0x%llx", NULL },
  51   { "PhysicalBaseAddress",           8,                        "0x%llx", NULL },
  52   { "GICV",                          8,                        "0x%llx", NULL },
  53   { "GICH",                          8,                        "0x%llx", NULL },
  54   { "VGICMaintenanceInterrupt",      4,                        "0x%x",   NULL },
  55   { "GICRBaseAddress",               8,                        "0x%llx", NULL },
  56   { "MPIDR",                         8,                        "0x%llx", NULL },
  57   { "ProcessorPowerEfficiencyClass", 1,                        "0x%x",   NULL },
  58   { "SpeOverflowInterrupt",          2,                        "0x%x",   NULL },
  59   { "ProximityDomain",               4,                        "0x%x",   NULL },
  60   { "ClockDomain",                   4,                        "0x%x",   NULL },
  61   { "AffinityFlags",                 4,                        "0x%x",   NULL },
  62   { "CpcToken",                      sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL }
  63 };
  64
  65 /** A parser for EArmObjGicDInfo.
  66 */
  67 STATIC CONST CM_OBJ_PARSER  CmArmGicDInfoParser[] = {
  68   { "PhysicalBaseAddress", 8, "0x%llx", NULL },
  69   { "SystemVectorBase",    4, "0x%x",   NULL },
  70   { "GicVersion",          1, "0x%x",   NULL },
  71 };
  72
  73 /** A parser for EArmObjGicMsiFrameInfo.
  74 */
  75 STATIC CONST CM_OBJ_PARSER  CmArmGicMsiFrameInfoParser[] = {
  76   { "GicMsiFrameId",       4, "0x%x",   NULL },
  77   { "PhysicalBaseAddress", 8, "0x%llx", NULL },
  78   { "Flags",               4, "0x%x",   NULL },
  79   { "SPICount",            2, "0x%x",   NULL },
  80   { "SPIBase",             2, "0x%x",   NULL }
  81 };
  82
  83 /** A parser for EArmObjGicRedistributorInfo.
  84 */
  85 STATIC CONST CM_OBJ_PARSER  CmArmGicRedistInfoParser[] = {
  86   { "DiscoveryRangeBaseAddress", 8, "0x%llx", NULL },
  87   { "DiscoveryRangeLength",      4, "0x%x",   NULL }
  88 };
  89
  90 /** A parser for EArmObjGicItsInfo.
  91 */
  92 STATIC CONST CM_OBJ_PARSER  CmArmGicItsInfoParser[] = {
  93   { "GicItsId",            4, "0x%x",   NULL },
  94   { "PhysicalBaseAddress", 8, "0x%llx", NULL },
  95   { "ProximityDomain",     4, "0x%x",   NULL }
  96 };
  97
  98 /** A parser for EArmObjSerialConsolePortInfo,
  99     EArmObjSerialDebugPortInfo and EArmObjSerialPortInfo.
 100 */
 101 STATIC CONST CM_OBJ_PARSER  CmArmSerialPortInfoParser[] = {
 102   { "BaseAddress",       8, "0x%llx", NULL },
 103   { "Interrupt",         4, "0x%x",   NULL },
 104   { "BaudRate",          8, "0x%llx", NULL },
 105   { "Clock",             4, "0x%x",   NULL },
 106   { "PortSubtype",       2, "0x%x",   NULL },
 107   { "BaseAddressLength", 8, "0x%llx", NULL },
 108   { "AccessSize",        1, "0x%d",   NULL }
 109 };
 110
 111 /** A parser for EArmObjGenericTimerInfo.
 112 */
 113 STATIC CONST CM_OBJ_PARSER  CmArmGenericTimerInfoParser[] = {
 114   { "CounterControlBaseAddress", 8, "0x%llx", NULL },
 115   { "CounterReadBaseAddress",    8, "0x%llx", NULL },
 116   { "SecurePL1TimerGSIV",        4, "0x%x",   NULL },
 117   { "SecurePL1TimerFlags",       4, "0x%x",   NULL },
 118   { "NonSecurePL1TimerGSIV",     4, "0x%x",   NULL },
 119   { "NonSecurePL1TimerFlags",    4, "0x%x",   NULL },
 120   { "VirtualTimerGSIV",          4, "0x%x",   NULL },
 121   { "VirtualTimerFlags",         4, "0x%x",   NULL },
 122   { "NonSecurePL2TimerGSIV",     4, "0x%x",   NULL },
 123   { "NonSecurePL2TimerFlags",    4, "0x%x",   NULL },
 124   { "VirtualPL2TimerGSIV",       4, "0x%x",   NULL },
 125   { "VirtualPL2TimerFlags",      4, "0x%x",   NULL }
 126 };
 127
 128 /** A parser for EArmObjPlatformGTBlockInfo.
 129 */
 130 STATIC CONST CM_OBJ_PARSER  CmArmGTBlockInfoParser[] = {
 131   { "GTBlockPhysicalAddress", 8,                        "0x%llx", NULL },
 132   { "GTBlockTimerFrameCount", 4,                        "0x%x",   NULL },
 133   { "GTBlockTimerFrameToken", sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL }
 134 };
 135
 136 /** A parser for EArmObjGTBlockTimerFrameInfo.
 137 */
 138 STATIC CONST CM_OBJ_PARSER  CmArmGTBlockTimerFrameInfoParser[] = {
 139   { "FrameNumber",               1, "0x%x",   NULL },
 140   { "PhysicalAddressCntBase",    8, "0x%llx", NULL },
 141   { "PhysicalAddressCntEL0Base", 8, "0x%llx", NULL },
 142   { "PhysicalTimerGSIV",         4, "0x%x",   NULL },
 143   { "PhysicalTimerFlags",        4, "0x%x",   NULL },
 144   { "VirtualTimerGSIV",          4, "0x%x",   NULL },
 145   { "VirtualTimerFlags",         4, "0x%x",   NULL },
 146   { "CommonFlags",               4, "0x%x",   NULL }
 147 };
 148
 149 /** A parser for EArmObjPlatformGenericWatchdogInfo.
 150 */
 151 STATIC CONST CM_OBJ_PARSER  CmArmGenericWatchdogInfoParser[] = {
 152   { "ControlFrameAddress", 8, "0x%llx", NULL },
 153   { "RefreshFrameAddress", 8, "0x%llx", NULL },
 154   { "TimerGSIV",           4, "0x%x",   NULL },
 155   { "Flags",               4, "0x%x",   NULL }
 156 };
 157
 158 /** A parser for EArmObjPciConfigSpaceInfo.
 159 */
 160 STATIC CONST CM_OBJ_PARSER  CmArmPciConfigSpaceInfoParser[] = {
 161   { "BaseAddress",           8,                        "0x%llx", NULL },
 162   { "PciSegmentGroupNumber", 2,                        "0x%x",   NULL },
 163   { "StartBusNumber",        1,                        "0x%x",   NULL },
 164   { "EndBusNumber",          1,                        "0x%x",   NULL },
 165   { "AddressMapToken",       sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 166   { "InterruptMapToken",     sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 167 };
 168
 169 /** A parser for EArmObjHypervisorVendorIdentity.
 170 */
 171 STATIC CONST CM_OBJ_PARSER  CmArmHypervisorVendorIdParser[] = {
 172   { "HypervisorVendorId", 8, "0x%llx", NULL }
 173 };
 174
 175 /** A parser for EArmObjFixedFeatureFlags.
 176 */
 177 STATIC CONST CM_OBJ_PARSER  CmArmFixedFeatureFlagsParser[] = {
 178   { "Flags", 4, "0x%x", NULL }
 179 };
 180
 181 /** A parser for EArmObjItsGroup.
 182 */
 183 STATIC CONST CM_OBJ_PARSER  CmArmItsGroupNodeParser[] = {
 184   { "Token",      sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 185   { "ItsIdCount", 4,                        "0x%x", NULL },
 186   { "ItsIdToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 187   { "Identifier", 4,                        "0x%x", NULL },
 188 };
 189
 190 /** A parser for EArmObjNamedComponent.
 191 */
 192 STATIC CONST CM_OBJ_PARSER  CmArmNamedComponentNodeParser[] = {
 193   { "Token",             sizeof (CM_OBJECT_TOKEN), "0x%p", NULL        },
 194   { "IdMappingCount",    4,                        "0x%x", NULL        },
 195   { "IdMappingToken",    sizeof (CM_OBJECT_TOKEN), "0x%p", NULL        },
 196   { "Flags",             4,                        "0x%x", NULL        },
 197   { "CacheCoherent",     4,                        "0x%x", NULL        },
 198   { "AllocationHints",   1,                        "0x%x", NULL        },
 199   { "MemoryAccessFlags", 1,                        "0x%x", NULL        },
 200   { "AddressSizeLimit",  1,                        "0x%x", NULL        },
 201   { "ObjectName",        sizeof (CHAR8 *),         NULL,   PrintString },
 202   { "Identifier",        4,                        "0x%x", NULL        },
 203 };
 204
 205 /** A parser for EArmObjRootComplex.
 206 */
 207 STATIC CONST CM_OBJ_PARSER  CmArmRootComplexNodeParser[] = {
 208   { "Token",             sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 209   { "IdMappingCount",    4,                        "0x%x", NULL },
 210   { "IdMappingToken",    sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 211   { "CacheCoherent",     4,                        "0x%x", NULL },
 212   { "AllocationHints",   1,                        "0x%x", NULL },
 213   { "MemoryAccessFlags", 1,                        "0x%x", NULL },
 214   { "AtsAttribute",      4,                        "0x%x", NULL },
 215   { "PciSegmentNumber",  4,                        "0x%x", NULL },
 216   { "MemoryAddressSize", 1,                        "0x%x", NULL },
 217   { "PasidCapabilities", 2,                        "0x%x", NULL },
 218   { "Flags",             4,                        "0x%x", NULL },
 219   { "Identifier",        4,                        "0x%x", NULL },
 220 };
 221
 222 /** A parser for EArmObjSmmuV1SmmuV2.
 223 */
 224 STATIC CONST CM_OBJ_PARSER  CmArmSmmuV1SmmuV2NodeParser[] = {
 225   { "Token",                 sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 226   { "IdMappingCount",        4,                        "0x%x",   NULL },
 227   { "IdMappingToken",        sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 228   { "BaseAddress",           8,                        "0x%llx", NULL },
 229   { "Span",                  8,                        "0x%llx", NULL },
 230   { "Model",                 4,                        "0x%x",   NULL },
 231   { "Flags",                 4,                        "0x%x",   NULL },
 232   { "ContextInterruptCount", 4,                        "0x%x",   NULL },
 233   { "ContextInterruptToken", sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 234   { "PmuInterruptCount",     4,                        "0x%x",   NULL },
 235   { "PmuInterruptToken",     sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 236   { "SMMU_NSgIrpt",          4,                        "0x%x",   NULL },
 237   { "SMMU_NSgIrptFlags",     4,                        "0x%x",   NULL },
 238   { "SMMU_NSgCfgIrpt",       4,                        "0x%x",   NULL },
 239   { "SMMU_NSgCfgIrptFlags",  4,                        "0x%x",   NULL },
 240   { "Identifier",            4,                        "0x%x",   NULL },
 241 };
 242
 243 /** A parser for EArmObjSmmuV3.
 244 */
 245 STATIC CONST CM_OBJ_PARSER  CmArmSmmuV3NodeParser[] = {
 246   { "Token",                sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 247   { "IdMappingCount",       4,                        "0x%x",   NULL },
 248   { "IdMappingToken",       sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 249   { "BaseAddress",          8,                        "0x%llx", NULL },
 250   { "Flags",                4,                        "0x%x",   NULL },
 251   { "VatosAddress",         8,                        "0x%llx", NULL },
 252   { "Model",                4,                        "0x%x",   NULL },
 253   { "EventInterrupt",       4,                        "0x%x",   NULL },
 254   { "PriInterrupt",         4,                        "0x%x",   NULL },
 255   { "GerrInterrupt",        4,                        "0x%x",   NULL },
 256   { "SyncInterrupt",        4,                        "0x%x",   NULL },
 257   { "ProximityDomain",      4,                        "0x%x",   NULL },
 258   { "DeviceIdMappingIndex", 4,                        "0x%x",   NULL },
 259   { "Identifier",           4,                        "0x%x",   NULL },
 260 };
 261
 262 /** A parser for EArmObjPmcg.
 263 */
 264 STATIC CONST CM_OBJ_PARSER  CmArmPmcgNodeParser[] = {
 265   { "Token",             sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 266   { "IdMappingCount",    4,                        "0x%x",   NULL },
 267   { "IdMappingToken",    sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 268   { "BaseAddress",       8,                        "0x%llx", NULL },
 269   { "OverflowInterrupt", 4,                        "0x%x",   NULL },
 270   { "Page1BaseAddress",  8,                        "0x%llx", NULL },
 271   { "ReferenceToken",    sizeof (CM_OBJECT_TOKEN), "0x%p",   NULL },
 272   { "Identifier",        4,                        "0x%x",   NULL },
 273 };
 274
 275 /** A parser for EArmObjGicItsIdentifierArray.
 276 */
 277 STATIC CONST CM_OBJ_PARSER  CmArmGicItsIdentifierParser[] = {
 278   { "ItsId", 4, "0x%x", NULL }
 279 };
 280
 281 /** A parser for EArmObjIdMappingArray.
 282 */
 283 STATIC CONST CM_OBJ_PARSER  CmArmIdMappingParser[] = {
 284   { "InputBase",            4,                        "0x%x", NULL },
 285   { "NumIds",               4,                        "0x%x", NULL },
 286   { "OutputBase",           4,                        "0x%x", NULL },
 287   { "OutputReferenceToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 288   { "Flags",                4,                        "0x%x", NULL }
 289 };
 290
 291 /** A parser for EArmObjSmmuInterruptArray.
 292 */
 293 STATIC CONST CM_OBJ_PARSER  CmArmGenericInterruptParser[] = {
 294   { "Interrupt", 4, "0x%x", NULL },
 295   { "Flags",     4, "0x%x", NULL }
 296 };
 297
 298 /** A parser for EArmObjProcHierarchyInfo.
 299 */
 300 STATIC CONST CM_OBJ_PARSER  CmArmProcHierarchyInfoParser[] = {
 301   { "Token",                      sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 302   { "Flags",                      4,                        "0x%x", NULL },
 303   { "ParentToken",                sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 304   { "GicCToken",                  sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 305   { "NoOfPrivateResources",       4,                        "0x%x", NULL },
 306   { "PrivateResourcesArrayToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 307   { "LpiToken",                   sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 308   { "OverrideNameUidEnabled",     1,                        "%d",   NULL },
 309   { "OverrideName",               2,                        "0x%x", NULL },
 310   { "OverrideUid",                4,                        "0x%x", NULL }
 311 };
 312
 313 /** A parser for EArmObjCacheInfo.
 314 */
 315 STATIC CONST CM_OBJ_PARSER  CmArmCacheInfoParser[] = {
 316   { "Token",                 sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 317   { "NextLevelOfCacheToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 318   { "Size",                  4,                        "0x%x", NULL },
 319   { "NumberOfSets",          4,                        "0x%x", NULL },
 320   { "Associativity",         4,                        "0x%x", NULL },
 321   { "Attributes",            1,                        "0x%x", NULL },
 322   { "LineSize",              2,                        "0x%x", NULL },
 323   { "CacheId",               4,                        "0x%x", NULL },
 324 };
 325
 326 /** A parser for EArmObjProcNodeIdInfo.
 327 */
 328 STATIC CONST CM_OBJ_PARSER  CmArmProcNodeIdInfoParser[] = {
 329   { "Token",    sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 330   { "VendorId", 4,                        "0x%p", NULL },
 331   { "Level1Id", 8,                        "0x%x", NULL },
 332   { "Level2Id", 8,                        "0x%x", NULL },
 333   { "MajorRev", 2,                        "0x%x", NULL },
 334   { "MinorRev", 2,                        "0x%x", NULL },
 335   { "SpinRev",  2,                        "0x%x", NULL }
 336 };
 337
 338 /** A parser for EArmObjCmRef.
 339 */
 340 STATIC CONST CM_OBJ_PARSER  CmArmObjRefParser[] = {
 341   { "ReferenceToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL }
 342 };
 343
 344 /** A parser for EArmObjMemoryAffinityInfo.
 345 */
 346 STATIC CONST CM_OBJ_PARSER  CmArmMemoryAffinityInfoParser[] = {
 347   { "ProximityDomain", 4, "0x%x",   NULL },
 348   { "BaseAddress",     8, "0x%llx", NULL },
 349   { "Length",          8, "0x%llx", NULL },
 350   { "Flags",           4, "0x%x",   NULL }
 351 };
 352
 353 /** A parser for EArmObjDeviceHandleAcpi.
 354 */
 355 STATIC CONST CM_OBJ_PARSER  CmArmDeviceHandleAcpiParser[] = {
 356   { "Hid", 8, "0x%llx", NULL },
 357   { "Uid", 4, "0x%x",   NULL }
 358 };
 359
 360 /** A parser for EArmObjDeviceHandlePci.
 361 */
 362 STATIC CONST CM_OBJ_PARSER  CmArmDeviceHandlePciParser[] = {
 363   { "SegmentNumber",  2, "0x%x", NULL },
 364   { "BusNumber",      1, "0x%x", NULL },
 365   { "DeviceNumber",   1, "0x%x", NULL },
 366   { "FunctionNumber", 1, "0x%x", NULL }
 367 };
 368
 369 /** A parser for EArmObjGenericInitiatorAffinityInfo.
 370 */
 371 STATIC CONST CM_OBJ_PARSER  CmArmGenericInitiatorAffinityInfoParser[] = {
 372   { "ProximityDomain",   4,                        "0x%x", NULL },
 373   { "Flags",             4,                        "0x%x", NULL },
 374   { "DeviceHandleType",  1,                        "0x%x", NULL },
 375   { "DeviceHandleToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL }
 376 };
 377
 378 /** A parser for EArmObjCmn600Info.
 379 */
 380 STATIC CONST CM_OBJ_PARSER  CmArmCmn600InfoParser[] = {
 381   { "PeriphBaseAddress",       8, "0x%llx", NULL },
 382   { "PeriphBaseAddressLength", 8, "0x%llx", NULL },
 383   { "RootNodeBaseAddress",     8, "0x%llx", NULL },
 384   { "DtcCount",                1, "0x%x",   NULL },
 385   { "DtcInterrupt[0]",         4, "0x%x",   NULL },
 386   { "DtcFlags[0]",             4, "0x%x",   NULL },
 387   { "DtcInterrupt[1]",         4, "0x%x",   NULL },
 388   { "DtcFlags[1]",             4, "0x%x",   NULL },
 389   { "DtcInterrupt[2]",         4, "0x%x",   NULL },
 390   { "DtcFlags[2]",             4, "0x%x",   NULL },
 391   { "DtcInterrupt[3]",         4, "0x%x",   NULL },
 392   { "DtcFlags[3]",             4, "0x%x",   NULL }
 393 };
 394
 395 /** A parser for the EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE structure.
 396 */
 397 STATIC CONST CM_OBJ_PARSER  AcpiGenericAddressParser[] = {
 398   { "AddressSpaceId",    1, "%d",     NULL },
 399   { "RegisterBitWidth",  1, "%d",     NULL },
 400   { "RegisterBitOffset", 1, "%d",     NULL },
 401   { "AccessSize",        1, "%d",     NULL },
 402   { "Address",           8, "0x%llx", NULL },
 403 };
 404
 405 /** A parser for EArmObjLpiInfo.
 406 */
 407 STATIC CONST CM_OBJ_PARSER  CmArmLpiInfoParser[] = {
 408   { "MinResidency",             4,                                               "0x%x",   NULL        },
 409   { "WorstCaseWakeLatency",     4,                                               "0x%x",   NULL        },
 410   { "Flags",                    4,                                               "0x%x",   NULL        },
 411   { "ArchFlags",                4,                                               "0x%x",   NULL        },
 412   { "ResCntFreq",               4,                                               "0x%x",   NULL        },
 413   { "EnableParentState",        4,                                               "0x%x",   NULL        },
 414   { "IsInteger",                1,                                               "%d",     NULL        },
 415   { "IntegerEntryMethod",       8,                                               "0x%llx", NULL        },
 416   { "RegisterEntryMethod",      sizeof (EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE),
 417     NULL, NULL, AcpiGenericAddressParser,
 418     ARRAY_SIZE (AcpiGenericAddressParser) },
 419   { "ResidencyCounterRegister", sizeof (EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE),
 420     NULL, NULL, AcpiGenericAddressParser,
 421     ARRAY_SIZE (AcpiGenericAddressParser) },
 422   { "UsageCounterRegister",     sizeof (EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE),
 423     NULL, NULL, AcpiGenericAddressParser,
 424     ARRAY_SIZE (AcpiGenericAddressParser) },
 425   { "StateName",                16,                                              NULL,     PrintString },
 426 };
 427
 428 /** A parser for EArmObjPciAddressMapInfo.
 429 */
 430 STATIC CONST CM_OBJ_PARSER  CmArmPciAddressMapInfoParser[] = {
 431   { "SpaceCode",   1, "%d",     NULL },
 432   { "PciAddress",  8, "0x%llx", NULL },
 433   { "CpuAddress",  8, "0x%llx", NULL },
 434   { "AddressSize", 8, "0x%llx", NULL },
 435 };
 436
 437 /** A parser for EArmObjPciInterruptMapInfo.
 438 */
 439 STATIC CONST CM_OBJ_PARSER  CmPciInterruptMapInfoParser[] = {
 440   { "PciBus",        1,                                 "0x%x", NULL },
 441   { "PciDevice",     1,                                 "0x%x", NULL },
 442   { "PciInterrupt",  1,                                 "0x%x", NULL },
 443   { "IntcInterrupt", sizeof (CM_ARM_GENERIC_INTERRUPT),
 444     NULL, NULL, CmArmGenericInterruptParser,
 445     ARRAY_SIZE (CmArmGenericInterruptParser) },
 446 };
 447
 448 /** A parser for EArmObjRmr.
 449 */
 450 STATIC CONST CM_OBJ_PARSER  CmArmRmrInfoParser[] = {
 451   { "Token",             sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 452   { "IdMappingCount",    4,                        "0x%x", NULL },
 453   { "IdMappingToken",    sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 454   { "Identifier",        4,                        "0x%x", NULL },
 455   { "Flags",             4,                        "0x%x", NULL },
 456   { "MemRangeDescCount", 4,                        "0x%x", NULL },
 457   { "MemRangeDescToken", sizeof (CM_OBJECT_TOKEN), "0x%p", NULL },
 458 };
 459
 460 /** A parser for EArmObjMemoryRangeDescriptor.
 461 */
 462 STATIC CONST CM_OBJ_PARSER  CmArmMemoryRangeDescriptorInfoParser[] = {
 463   { "BaseAddress", 8, "0x%llx", NULL },
 464   { "Length",      8, "0x%llx", NULL },
 465 };
 466
 467 /** A parser for EArmObjCpcInfo.
 468 */
 469 STATIC CONST CM_OBJ_PARSER  CmArmCpcInfoParser[] = {
 470   { "Revision",                              4,                                               "0x%lx", NULL },
 471   { "HighestPerformanceBuffer",              sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 472     NULL, NULL, AcpiGenericAddressParser,
 473     ARRAY_SIZE (AcpiGenericAddressParser) },
 474   { "HighestPerformanceInteger",             4,                                               "0x%lx", NULL },
 475   { "NominalPerformanceBuffer",              sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 476     NULL, NULL, AcpiGenericAddressParser,
 477     ARRAY_SIZE (AcpiGenericAddressParser) },
 478   { "NominalPerformanceInteger",             4,                                               "0x%lx", NULL },
 479   { "LowestNonlinearPerformanceBuffer",      sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 480     NULL, NULL, AcpiGenericAddressParser,
 481     ARRAY_SIZE (AcpiGenericAddressParser) },
 482   { "LowestNonlinearPerformanceInteger",     4,                                               "0x%lx", NULL },
 483   { "LowestPerformanceBuffer",               sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 484     NULL, NULL, AcpiGenericAddressParser,
 485     ARRAY_SIZE (AcpiGenericAddressParser) },
 486   { "LowestPerformanceInteger",              4,                                               "0x%lx", NULL },
 487   { "GuaranteedPerformanceRegister",         sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 488     NULL, NULL, AcpiGenericAddressParser,
 489     ARRAY_SIZE (AcpiGenericAddressParser) },
 490   { "DesiredPerformanceRegister",            sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 491     NULL, NULL, AcpiGenericAddressParser,
 492     ARRAY_SIZE (AcpiGenericAddressParser) },
 493   { "MinimumPerformanceRegister",            sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 494     NULL, NULL, AcpiGenericAddressParser,
 495     ARRAY_SIZE (AcpiGenericAddressParser) },
 496   { "MaximumPerformanceRegister",            sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 497     NULL, NULL, AcpiGenericAddressParser,
 498     ARRAY_SIZE (AcpiGenericAddressParser) },
 499   { "PerformanceReductionToleranceRegister", sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 500     NULL, NULL, AcpiGenericAddressParser,
 501     ARRAY_SIZE (AcpiGenericAddressParser) },
 502   { "TimeWindowRegister",                    sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 503     NULL, NULL, AcpiGenericAddressParser,
 504     ARRAY_SIZE (AcpiGenericAddressParser) },
 505   { "CounterWraparoundTimeBuffer",           sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 506     NULL, NULL, AcpiGenericAddressParser,
 507     ARRAY_SIZE (AcpiGenericAddressParser) },
 508   { "CounterWraparoundTimeInteger",          4,                                               "0x%lx", NULL },
 509   { "ReferencePerformanceCounterRegister",   sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 510     NULL, NULL, AcpiGenericAddressParser,
 511     ARRAY_SIZE (AcpiGenericAddressParser) },
 512   { "DeliveredPerformanceCounterRegister",   sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 513     NULL, NULL, AcpiGenericAddressParser,
 514     ARRAY_SIZE (AcpiGenericAddressParser) },
 515   { "PerformanceLimitedRegister",            sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 516     NULL, NULL, AcpiGenericAddressParser,
 517     ARRAY_SIZE (AcpiGenericAddressParser) },
 518   { "CPPCEnableRegister",                    sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 519     NULL, NULL, AcpiGenericAddressParser,
 520     ARRAY_SIZE (AcpiGenericAddressParser) },
 521   { "AutonomousSelectionEnableBuffer",       sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 522     NULL, NULL, AcpiGenericAddressParser,
 523     ARRAY_SIZE (AcpiGenericAddressParser) },
 524   { "AutonomousSelectionEnableInteger",      4,                                               "0x%lx", NULL },
 525   { "AutonomousActivityWindowRegister",      sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 526     NULL, NULL, AcpiGenericAddressParser,
 527     ARRAY_SIZE (AcpiGenericAddressParser) },
 528   { "EnergyPerformancePreferenceRegister",   sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 529     NULL, NULL, AcpiGenericAddressParser,
 530     ARRAY_SIZE (AcpiGenericAddressParser) },
 531   { "ReferencePerformanceBuffer",            sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 532     NULL, NULL, AcpiGenericAddressParser,
 533     ARRAY_SIZE (AcpiGenericAddressParser) },
 534   { "ReferencePerformanceInteger",           4,                                               "0x%lx", NULL },
 535   { "LowestFrequencyBuffer",                 sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 536     NULL, NULL, AcpiGenericAddressParser,
 537     ARRAY_SIZE (AcpiGenericAddressParser) },
 538   { "LowestFrequencyInteger",                4,                                               "0x%lx", NULL },
 539   { "NominalFrequencyBuffer",                sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE),
 540     NULL, NULL, AcpiGenericAddressParser,
 541     ARRAY_SIZE (AcpiGenericAddressParser) },
 542   { "NominalFrequencyInteger",               4,                                               "0x%lx", NULL },
 543 };
 544
 545 /** A parser for the PCC_MAILBOX_REGISTER_INFO struct.
 546 */
 547 STATIC CONST CM_OBJ_PARSER  CmArmMailboxRegisterInfoParser[] = {
 548   { "Register",     sizeof (EFI_ACPI_6_4_GENERIC_ADDRESS_STRUCTURE), NULL,     NULL,
 549     AcpiGenericAddressParser, ARRAY_SIZE (AcpiGenericAddressParser) },
 550   { "PreserveMask", 8,                                               "0x%llx", NULL },
 551   { "WriteMask",    8,                                               "0x%llx", NULL },
 552 };
 553
 554 /** A parser for the PCC_SUBSPACE_CHANNEL_TIMING_INFO struct.
 555 */
 556 STATIC CONST CM_OBJ_PARSER  CmArmPccSubspaceChannelTimingInfoParser[] = {
 557   { "NominalLatency",           4, "0x%x", NULL },
 558   { "MaxPeriodicAccessRate",    4, "0x%x", NULL },
 559   { "MinRequestTurnaroundTime", 2, "0x%x", NULL },
 560 };
 561
 562 /** A parser for EArmObjPccSubspaceType0Info.
 563 */
 564 STATIC CONST CM_OBJ_PARSER  CmArmPccSubspaceType0InfoParser[] = {
 565   { "SubspaceId",    1,                                         "0x%x",   NULL },
 566   { "Type",          1,                                         "0x%x",   NULL },
 567   { "BaseAddress",   8,                                         "0x%llx", NULL },
 568   { "AddressLength", 8,                                         "0x%llx", NULL },
 569   { "DoorbellReg",   sizeof (PCC_MAILBOX_REGISTER_INFO),
 570     NULL, NULL, CmArmMailboxRegisterInfoParser,
 571     ARRAY_SIZE (CmArmMailboxRegisterInfoParser) },
 572   { "ChannelTiming", sizeof (PCC_SUBSPACE_CHANNEL_TIMING_INFO),
 573     NULL, NULL, CmArmPccSubspaceChannelTimingInfoParser,
 574     ARRAY_SIZE (CmArmPccSubspaceChannelTimingInfoParser) },
 575 };
 576
 577 /** A parser for EArmObjPccSubspaceType1Info.
 578 */
 579 STATIC CONST CM_OBJ_PARSER  CmArmPccSubspaceType1InfoParser[] = {
 580   { "GenericPccInfo", sizeof (PCC_SUBSPACE_GENERIC_INFO),
 581     NULL, NULL, CmArmPccSubspaceType0InfoParser,
 582     ARRAY_SIZE (CmArmPccSubspaceType0InfoParser) },
 583   { "PlatIrq",        sizeof (CM_ARM_GENERIC_INTERRUPT),
 584     NULL, NULL, CmArmGenericInterruptParser,
 585     ARRAY_SIZE (CmArmGenericInterruptParser) },
 586 };
 587
 588 /** A parser for EArmObjPccSubspaceType2Info.
 589 */
 590 STATIC CONST CM_OBJ_PARSER  CmArmPccSubspaceType2InfoParser[] = {
 591   { "GenericPccInfo", sizeof (PCC_SUBSPACE_GENERIC_INFO),
 592     NULL, NULL, CmArmPccSubspaceType0InfoParser,
 593     ARRAY_SIZE (CmArmPccSubspaceType0InfoParser) },
 594   { "PlatIrq",        sizeof (CM_ARM_GENERIC_INTERRUPT), NULL,NULL,
 595     CmArmGenericInterruptParser, ARRAY_SIZE (CmArmGenericInterruptParser) },
 596   { "PlatIrqAckReg",  sizeof (PCC_MAILBOX_REGISTER_INFO),
 597     NULL, NULL, CmArmMailboxRegisterInfoParser,
 598     ARRAY_SIZE (CmArmMailboxRegisterInfoParser) },
 599 };
 600
 601 /** A parser for EArmObjPccSubspaceType3Info or EArmObjPccSubspaceType4Info.
 602 */
 603 STATIC CONST CM_OBJ_PARSER  CmArmPccSubspaceType34InfoParser[] = {
 604   { "GenericPccInfo",       sizeof (PCC_SUBSPACE_GENERIC_INFO),
 605     NULL, NULL, CmArmPccSubspaceType0InfoParser,
 606     ARRAY_SIZE (CmArmPccSubspaceType0InfoParser) },
 607   { "PlatIrq",              sizeof (CM_ARM_GENERIC_INTERRUPT), NULL,NULL,
 608     CmArmGenericInterruptParser, ARRAY_SIZE (CmArmGenericInterruptParser) },
 609   { "PlatIrqAckReg",        sizeof (PCC_MAILBOX_REGISTER_INFO),
 610     NULL, NULL, CmArmMailboxRegisterInfoParser,
 611     ARRAY_SIZE (CmArmMailboxRegisterInfoParser) },
 612   { "CmdCompleteCheckReg",  sizeof (PCC_MAILBOX_REGISTER_INFO),
 613     NULL, NULL, CmArmMailboxRegisterInfoParser,
 614     ARRAY_SIZE (CmArmMailboxRegisterInfoParser) },
 615   { "CmdCompleteUpdateReg", sizeof (PCC_MAILBOX_REGISTER_INFO),
 616     NULL, NULL, CmArmMailboxRegisterInfoParser,
 617     ARRAY_SIZE (CmArmMailboxRegisterInfoParser) },
 618   { "ErrorStatusReg",       sizeof (PCC_MAILBOX_REGISTER_INFO),
 619     NULL, NULL, CmArmMailboxRegisterInfoParser,
 620     ARRAY_SIZE (CmArmMailboxRegisterInfoParser) },
 621 };
 622
 623 /** A parser for EArmObjPccSubspaceType5Info.
 624 */
 625 STATIC CONST CM_OBJ_PARSER  CmArmPccSubspaceType5InfoParser[] = {
 626   { "GenericPccInfo",      sizeof (PCC_SUBSPACE_GENERIC_INFO),
 627     NULL, NULL, CmArmPccSubspaceType0InfoParser,
 628     ARRAY_SIZE (CmArmPccSubspaceType0InfoParser) },
 629   { "Version",             2,                                 "0x%x",NULL },
 630   { "PlatIrq",             sizeof (CM_ARM_GENERIC_INTERRUPT), NULL,  NULL,
 631     CmArmGenericInterruptParser, ARRAY_SIZE (CmArmGenericInterruptParser) },
 632   { "CmdCompleteCheckReg", sizeof (PCC_MAILBOX_REGISTER_INFO),
 633     NULL, NULL, CmArmMailboxRegisterInfoParser,
 634     ARRAY_SIZE (CmArmMailboxRegisterInfoParser) },
 635   { "ErrorStatusReg",      sizeof (PCC_MAILBOX_REGISTER_INFO),
 636     NULL, NULL, CmArmMailboxRegisterInfoParser,
 637     ARRAY_SIZE (CmArmMailboxRegisterInfoParser) },
 638 };
 639
 640 /** A parser for Arm namespace objects.
 641 */
 642 STATIC CONST CM_OBJ_PARSER_ARRAY  ArmNamespaceObjectParser[] = {
 643   { "EArmObjReserved",                     NULL,                                  0                                },
 644   { "EArmObjBootArchInfo",                 CmArmBootArchInfoParser,
 645     ARRAY_SIZE (CmArmBootArchInfoParser) },
 646   { "EArmObjCpuInfo",                      NULL,                                  0                                },
 647   { "EArmObjPowerManagementProfileInfo",   CmArmPowerManagementProfileInfoParser,
 648     ARRAY_SIZE (CmArmPowerManagementProfileInfoParser) },
 649   { "EArmObjGicCInfo",                     CmArmGicCInfoParser,                   ARRAY_SIZE (CmArmGicCInfoParser) },
 650   { "EArmObjGicDInfo",                     CmArmGicDInfoParser,                   ARRAY_SIZE (CmArmGicDInfoParser) },
 651   { "EArmObjGicMsiFrameInfo",              CmArmGicMsiFrameInfoParser,
 652     ARRAY_SIZE (CmArmGicMsiFrameInfoParser) },
 653   { "EArmObjGicRedistributorInfo",         CmArmGicRedistInfoParser,
 654     ARRAY_SIZE (CmArmGicRedistInfoParser) },
 655   { "EArmObjGicItsInfo",                   CmArmGicItsInfoParser,
 656     ARRAY_SIZE (CmArmGicItsInfoParser) },
 657   { "EArmObjSerialConsolePortInfo",        CmArmSerialPortInfoParser,
 658     ARRAY_SIZE (CmArmSerialPortInfoParser) },
 659   { "EArmObjSerialDebugPortInfo",          CmArmSerialPortInfoParser,
 660     ARRAY_SIZE (CmArmSerialPortInfoParser) },
 661   { "EArmObjGenericTimerInfo",             CmArmGenericTimerInfoParser,
 662     ARRAY_SIZE (CmArmGenericTimerInfoParser) },
 663   { "EArmObjPlatformGTBlockInfo",          CmArmGTBlockInfoParser,
 664     ARRAY_SIZE (CmArmGTBlockInfoParser) },
 665   { "EArmObjGTBlockTimerFrameInfo",        CmArmGTBlockTimerFrameInfoParser,
 666     ARRAY_SIZE (CmArmGTBlockTimerFrameInfoParser) },
 667   { "EArmObjPlatformGenericWatchdogInfo",  CmArmGenericWatchdogInfoParser,
 668     ARRAY_SIZE (CmArmGenericWatchdogInfoParser) },
 669   { "EArmObjPciConfigSpaceInfo",           CmArmPciConfigSpaceInfoParser,
 670     ARRAY_SIZE (CmArmPciConfigSpaceInfoParser) },
 671   { "EArmObjHypervisorVendorIdentity",     CmArmHypervisorVendorIdParser,
 672     ARRAY_SIZE (CmArmHypervisorVendorIdParser) },
 673   { "EArmObjFixedFeatureFlags",            CmArmFixedFeatureFlagsParser,
 674     ARRAY_SIZE (CmArmFixedFeatureFlagsParser) },
 675   { "EArmObjItsGroup",                     CmArmItsGroupNodeParser,
 676     ARRAY_SIZE (CmArmItsGroupNodeParser) },
 677   { "EArmObjNamedComponent",               CmArmNamedComponentNodeParser,
 678     ARRAY_SIZE (CmArmNamedComponentNodeParser) },
 679   { "EArmObjRootComplex",                  CmArmRootComplexNodeParser,
 680     ARRAY_SIZE (CmArmRootComplexNodeParser) },
 681   { "EArmObjSmmuV1SmmuV2",                 CmArmSmmuV1SmmuV2NodeParser,
 682     ARRAY_SIZE (CmArmSmmuV1SmmuV2NodeParser) },
 683   { "EArmObjSmmuV3",                       CmArmSmmuV3NodeParser,
 684     ARRAY_SIZE (CmArmSmmuV3NodeParser) },
 685   { "EArmObjPmcg",                         CmArmPmcgNodeParser,                   ARRAY_SIZE (CmArmPmcgNodeParser) },
 686   { "EArmObjGicItsIdentifierArray",        CmArmGicItsIdentifierParser,
 687     ARRAY_SIZE (CmArmGicItsIdentifierParser) },
 688   { "EArmObjIdMappingArray",               CmArmIdMappingParser,
 689     ARRAY_SIZE (CmArmIdMappingParser) },
 690   { "EArmObjSmmuInterruptArray",           CmArmGenericInterruptParser,
 691     ARRAY_SIZE (CmArmGenericInterruptParser) },
 692   { "EArmObjProcHierarchyInfo",            CmArmProcHierarchyInfoParser,
 693     ARRAY_SIZE (CmArmProcHierarchyInfoParser) },
 694   { "EArmObjCacheInfo",                    CmArmCacheInfoParser,
 695     ARRAY_SIZE (CmArmCacheInfoParser) },
 696   { "EArmObjProcNodeIdInfo",               CmArmProcNodeIdInfoParser,
 697     ARRAY_SIZE (CmArmProcNodeIdInfoParser) },
 698   { "EArmObjCmRef",                        CmArmObjRefParser,                     ARRAY_SIZE (CmArmObjRefParser)   },
 699   { "EArmObjMemoryAffinityInfo",           CmArmMemoryAffinityInfoParser,
 700     ARRAY_SIZE (CmArmMemoryAffinityInfoParser) },
 701   { "EArmObjDeviceHandleAcpi",             CmArmDeviceHandleAcpiParser,
 702     ARRAY_SIZE (CmArmDeviceHandleAcpiParser) },
 703   { "EArmObjDeviceHandlePci",              CmArmDeviceHandlePciParser,
 704     ARRAY_SIZE (CmArmDeviceHandlePciParser) },
 705   { "EArmObjGenericInitiatorAffinityInfo",
 706     CmArmGenericInitiatorAffinityInfoParser,
 707     ARRAY_SIZE (CmArmGenericInitiatorAffinityInfoParser) },
 708   { "EArmObjSerialPortInfo",               CmArmSerialPortInfoParser,
 709     ARRAY_SIZE (CmArmSerialPortInfoParser) },
 710   { "EArmObjCmn600Info",                   CmArmCmn600InfoParser,
 711     ARRAY_SIZE (CmArmCmn600InfoParser) },
 712   { "EArmObjLpiInfo",                      CmArmLpiInfoParser,
 713     ARRAY_SIZE (CmArmLpiInfoParser) },
 714   { "EArmObjPciAddressMapInfo",            CmArmPciAddressMapInfoParser,
 715     ARRAY_SIZE (CmArmPciAddressMapInfoParser) },
 716   { "EArmObjPciInterruptMapInfo",          CmPciInterruptMapInfoParser,
 717     ARRAY_SIZE (CmPciInterruptMapInfoParser) },
 718   { "EArmObjRmr",                          CmArmRmrInfoParser,
 719     ARRAY_SIZE (CmArmRmrInfoParser) },
 720   { "EArmObjMemoryRangeDescriptor",        CmArmMemoryRangeDescriptorInfoParser,
 721     ARRAY_SIZE (CmArmMemoryRangeDescriptorInfoParser) },
 722   { "EArmObjCpcInfo",                      CmArmCpcInfoParser,
 723     ARRAY_SIZE (CmArmCpcInfoParser) },
 724   { "EArmObjPccSubspaceType0Info",         CmArmPccSubspaceType0InfoParser,
 725     ARRAY_SIZE (CmArmPccSubspaceType0InfoParser) },
 726   { "EArmObjPccSubspaceType1Info",         CmArmPccSubspaceType1InfoParser,
 727     ARRAY_SIZE (CmArmPccSubspaceType1InfoParser) },
 728   { "EArmObjPccSubspaceType2Info",         CmArmPccSubspaceType2InfoParser,
 729     ARRAY_SIZE (CmArmPccSubspaceType2InfoParser) },
 730   { "EArmObjPccSubspaceType3Info",         CmArmPccSubspaceType34InfoParser,
 731     ARRAY_SIZE (CmArmPccSubspaceType34InfoParser) },
 732   { "EArmObjPccSubspaceType4Info",         CmArmPccSubspaceType34InfoParser,
 733     ARRAY_SIZE (CmArmPccSubspaceType34InfoParser) },
 734   { "EArmObjPccSubspaceType5Info",         CmArmPccSubspaceType5InfoParser,
 735     ARRAY_SIZE (CmArmPccSubspaceType5InfoParser) },
 736   { "EArmObjMax",                          NULL,                                  0                                },
 737 };
 738
 739 /** A parser for EStdObjCfgMgrInfo.
 740 */
 741 STATIC CONST CM_OBJ_PARSER  StdObjCfgMgrInfoParser[] = {
 742   { "Revision", 4, "0x%x",         NULL       },
 743   { "OemId[6]", 6, "%C%C%C%C%C%C", PrintOemId }
 744 };
 745
 746 /** A parser for EStdObjAcpiTableList.
 747 */
 748 STATIC CONST CM_OBJ_PARSER  StdObjAcpiTableInfoParser[] = {
 749   { "AcpiTableSignature", 4,                                      "0x%x",   NULL },
 750   { "AcpiTableRevision",  1,                                      "%d",     NULL },
 751   { "TableGeneratorId",   sizeof (ACPI_TABLE_GENERATOR_ID),       "0x%x",   NULL },
 752   { "AcpiTableData",      sizeof (EFI_ACPI_DESCRIPTION_HEADER *), "0x%p",   NULL },
 753   { "OemTableId",         8,                                      "0x%LLX", NULL },
 754   { "OemRevision",        4,                                      "0x%x",   NULL },
 755   { "MinorRevision",      1,                                      "0x%x",   NULL },
 756 };
 757
 758 /** A parser for EStdObjSmbiosTableList.
 759 */
 760 STATIC CONST CM_OBJ_PARSER  StdObjSmbiosTableInfoParser[] = {
 761   { "TableGeneratorId", sizeof (SMBIOS_TABLE_GENERATOR_ID), "0x%x", NULL },
 762   { "SmbiosTableData",  sizeof (SMBIOS_STRUCTURE *),        "0x%p", NULL }
 763 };
 764
 765 /** A parser for Standard namespace objects.
 766 */
 767 STATIC CONST CM_OBJ_PARSER_ARRAY  StdNamespaceObjectParser[] = {
 768   { "EStdObjCfgMgrInfo",      StdObjCfgMgrInfoParser,
 769     ARRAY_SIZE (StdObjCfgMgrInfoParser) },
 770   { "EStdObjAcpiTableList",   StdObjAcpiTableInfoParser,
 771     ARRAY_SIZE (StdObjAcpiTableInfoParser) },
 772   { "EStdObjSmbiosTableList", StdObjSmbiosTableInfoParser,
 773     ARRAY_SIZE (StdObjSmbiosTableInfoParser) },
 774 };
 775
 776 /** Print OEM Id.
 777
 778   @param [in]  Format  Format to print the Ptr.
 779   @param [in]  Ptr     Pointer to the OEM Id.
 780 **/
 781 STATIC
 782 VOID
 783 EFIAPI
 784 PrintOemId (
 785   IN  CONST CHAR8  *Format,
 786   IN  UINT8        *Ptr
 787   )
 788 {
 789   DEBUG ((
 790     DEBUG_ERROR,
 791     (Format != NULL) ? Format : "%C%C%C%C%C%C",
 792     Ptr[0],
 793     Ptr[1],
 794     Ptr[2],
 795     Ptr[3],
 796     Ptr[4],
 797     Ptr[5]
 798     ));
 799 }
 800
 801 /** Print string.
 802
 803   The string must be NULL terminated.
 804
 805   @param [in]  Format  Format to print the Ptr.
 806   @param [in]  Ptr     Pointer to the string.
 807 **/
 808 STATIC
 809 VOID
 810 EFIAPI
 811 PrintString (
 812   CONST CHAR8  *Format,
 813   UINT8        *Ptr
 814   )
 815 {
 816   DEBUG ((DEBUG_ERROR, "%a", Ptr));
 817 }
 818
 819 /** Print fields of the objects.
 820
 821   @param [in]  Data           Pointer to the object to print.
 822   @param [in]  Parser         Parser containing the object fields.
 823   @param [in]  ItemCount      Number of entries/fields in the Parser.
 824   @param [in]  RemainingSize  Parse at most *RemainingSize bytes.
 825                               This function decrements the value
 826                               from the number bytes consumed.
 827   @param [in]  IndentLevel    Indentation to use when printing.
 828 **/
 829 STATIC
 830 VOID
 831 PrintCmObjDesc (
 832   IN        VOID           *Data,
 833   IN  CONST CM_OBJ_PARSER  *Parser,
 834   IN        UINTN          ItemCount,
 835   IN        INTN           *RemainingSize,
 836   IN        UINT32         IndentLevel
 837   )
 838 {
 839   UINT32  Index;
 840   UINT32  IndentIndex;
 841   INTN    SubStructSize;
 842
 843   if ((Data == NULL)    ||
 844       (Parser == NULL)  ||
 845       (ItemCount == 0)  ||
 846       (RemainingSize == NULL))
 847   {
 848     ASSERT (0);
 849     return;
 850   }
 851
 852   // Print each field.
 853   for (Index = 0; Index < ItemCount; Index++) {
 854     // Check there is enough space in left.
 855     *RemainingSize -= Parser[Index].Length;
 856     if (*RemainingSize < 0) {
 857       DEBUG ((
 858         DEBUG_ERROR,
 859         "\nERROR: %a: Buffer overrun\n",
 860         Parser[Index].NameStr
 861         ));
 862       ASSERT (0);
 863       return;
 864     }
 865
 866     // Indentation
 867     for (IndentIndex = 0; IndentIndex < IndentLevel; IndentIndex++) {
 868       DEBUG ((DEBUG_ERROR, "  "));
 869     }
 870
 871     DEBUG ((
 872       DEBUG_ERROR,
 873       "%-*a :",
 874       OUTPUT_FIELD_COLUMN_WIDTH - 2 * IndentLevel,
 875       Parser[Index].NameStr
 876       ));
 877     if (Parser[Index].PrintFormatter != NULL) {
 878       Parser[Index].PrintFormatter (Parser[Index].Format, Data);
 879     } else if (Parser[Index].Format != NULL) {
 880       switch (Parser[Index].Length) {
 881         case 1:
 882           DEBUG ((DEBUG_ERROR, Parser[Index].Format, *(UINT8 *)Data));
 883           break;
 884         case 2:
 885           DEBUG ((DEBUG_ERROR, Parser[Index].Format, *(UINT16 *)Data));
 886           break;
 887         case 4:
 888           DEBUG ((DEBUG_ERROR, Parser[Index].Format, *(UINT32 *)Data));
 889           break;
 890         case 8:
 891           DEBUG ((DEBUG_ERROR, Parser[Index].Format, ReadUnaligned64 (Data)));
 892           break;
 893         default:
 894           DEBUG ((
 895             DEBUG_ERROR,
 896             "\nERROR: %a: CANNOT PARSE THIS FIELD, Field Length = %d\n",
 897             Parser[Index].NameStr,
 898             Parser[Index].Length
 899             ));
 900       } // switch
 901     } else if (Parser[Index].SubObjParser != NULL) {
 902       SubStructSize = Parser[Index].Length;
 903
 904       DEBUG ((DEBUG_ERROR, "\n"));
 905       PrintCmObjDesc (
 906         Data,
 907         Parser[Index].SubObjParser,
 908         Parser[Index].SubObjItemCount,
 909         &SubStructSize,
 910         IndentLevel + 1
 911         );
 912     } else {
 913       ASSERT (0);
 914       DEBUG ((
 915         DEBUG_ERROR,
 916         "\nERROR: %a: CANNOT PARSE THIS FIELD, Field Length = %d\n",
 917         Parser[Index].NameStr,
 918         Parser[Index].Length
 919         ));
 920     }
 921
 922     DEBUG ((DEBUG_ERROR, "\n"));
 923     Data = (UINT8 *)Data + Parser[Index].Length;
 924   } // for
 925 }
 926
 927 /** Parse and print a CmObjDesc.
 928
 929   @param [in]  CmObjDesc  The CmObjDesc to parse and print.
 930 **/
 931 VOID
 932 EFIAPI
 933 ParseCmObjDesc (
 934   IN  CONST CM_OBJ_DESCRIPTOR  *CmObjDesc
 935   )
 936 {
 937   UINTN                       ObjId;
 938   UINTN                       NameSpaceId;
 939   UINT32                      ObjIndex;
 940   UINT32                      ObjectCount;
 941   INTN                        RemainingSize;
 942   INTN                        Offset;
 943   CONST  CM_OBJ_PARSER_ARRAY  *ParserArray;
 944
 945   if ((CmObjDesc == NULL) || (CmObjDesc->Data == NULL)) {
 946     return;
 947   }
 948
 949   NameSpaceId = GET_CM_NAMESPACE_ID (CmObjDesc->ObjectId);
 950   ObjId       = GET_CM_OBJECT_ID (CmObjDesc->ObjectId);
 951
 952   switch (NameSpaceId) {
 953     case EObjNameSpaceStandard:
 954       if (ObjId >= EStdObjMax) {
 955         ASSERT (0);
 956         return;
 957       }
 958
 959       ParserArray = &StdNamespaceObjectParser[ObjId];
 960       break;
 961     case EObjNameSpaceArm:
 962       if (ObjId >= EArmObjMax) {
 963         ASSERT (0);
 964         return;
 965       }
 966
 967       ParserArray = &ArmNamespaceObjectParser[ObjId];
 968       break;
 969     default:
 970       // Not supported
 971       ASSERT (0);
 972       return;
 973   } // switch
 974
 975   ObjectCount   = CmObjDesc->Count;
 976   RemainingSize = CmObjDesc->Size;
 977   Offset        = 0;
 978
 979   for (ObjIndex = 0; ObjIndex < ObjectCount; ObjIndex++) {
 980     DEBUG ((
 981       DEBUG_ERROR,
 982       "\n%-*a [%d/%d]:\n",
 983       OUTPUT_FIELD_COLUMN_WIDTH,
 984       ParserArray->ObjectName,
 985       ObjIndex + 1,
 986       ObjectCount
 987       ));
 988     PrintCmObjDesc (
 989       (VOID *)((UINTN)CmObjDesc->Data + Offset),
 990       ParserArray->Parser,
 991       ParserArray->ItemCount,
 992       &RemainingSize,
 993       1
 994       );
 995     if ((RemainingSize > CmObjDesc->Size) ||
 996         (RemainingSize < 0))
 997     {
 998       ASSERT (0);
 999       return;
1000     }
1001
1002     Offset = CmObjDesc->Size - RemainingSize;
1003   } // for
1004
1005   ASSERT (RemainingSize == 0);
1006 }