| /****************************************************************************** |
| * |
| * Module Name: dmtbdump2 - Dump ACPI data tables that contain no AML code |
| * |
| *****************************************************************************/ |
| |
| /* |
| * Copyright (C) 2000 - 2020, Intel Corp. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions, and the following disclaimer, |
| * without modification. |
| * 2. Redistributions in binary form must reproduce at minimum a disclaimer |
| * substantially similar to the "NO WARRANTY" disclaimer below |
| * ("Disclaimer") and any redistribution must be conditioned upon |
| * including a substantially similar Disclaimer requirement for further |
| * binary redistribution. |
| * 3. Neither the names of the above-listed copyright holders nor the names |
| * of any contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * NO WARRANTY |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING |
| * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGES. |
| */ |
| |
| #include "acpi.h" |
| #include "accommon.h" |
| #include "acdisasm.h" |
| #include "actables.h" |
| |
| /* This module used for application-level code only */ |
| |
| #define _COMPONENT ACPI_CA_DISASSEMBLER |
| ACPI_MODULE_NAME ("dmtbdump2") |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpIort |
| * |
| * PARAMETERS: Table - A IORT table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a IORT |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpIort ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| ACPI_TABLE_IORT *Iort; |
| ACPI_IORT_NODE *IortNode; |
| ACPI_IORT_ITS_GROUP *IortItsGroup = NULL; |
| ACPI_IORT_SMMU *IortSmmu = NULL; |
| UINT32 Offset; |
| UINT32 NodeOffset; |
| UINT32 Length; |
| ACPI_DMTABLE_INFO *InfoTable; |
| char *String; |
| UINT32 i; |
| UINT32 MappingByteLength; |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table); |
| Offset = sizeof (ACPI_TABLE_IORT); |
| |
| /* Dump the OptionalPadding (optional) */ |
| |
| if (Iort->NodeOffset > Offset) |
| { |
| Status = AcpiDmDumpTable (Table->Length, Offset, Table, |
| Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| } |
| |
| Offset = Iort->NodeOffset; |
| while (Offset < Table->Length) |
| { |
| /* Common subtable header */ |
| |
| IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset); |
| AcpiOsPrintf ("\n"); |
| Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData); |
| Status = AcpiDmDumpTable (Table->Length, Offset, |
| IortNode, Length, AcpiDmTableInfoIortHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| NodeOffset = Length; |
| |
| switch (IortNode->Type) |
| { |
| case ACPI_IORT_NODE_ITS_GROUP: |
| |
| InfoTable = AcpiDmTableInfoIort0; |
| Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers); |
| IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset); |
| break; |
| |
| case ACPI_IORT_NODE_NAMED_COMPONENT: |
| |
| InfoTable = AcpiDmTableInfoIort1; |
| Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName); |
| String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length); |
| Length += strlen (String) + 1; |
| break; |
| |
| case ACPI_IORT_NODE_PCI_ROOT_COMPLEX: |
| |
| InfoTable = AcpiDmTableInfoIort2; |
| Length = IortNode->Length - NodeOffset; |
| break; |
| |
| case ACPI_IORT_NODE_SMMU: |
| |
| InfoTable = AcpiDmTableInfoIort3; |
| Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts); |
| IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset); |
| break; |
| |
| case ACPI_IORT_NODE_SMMU_V3: |
| |
| InfoTable = AcpiDmTableInfoIort4; |
| Length = IortNode->Length - NodeOffset; |
| break; |
| |
| case ACPI_IORT_NODE_PMCG: |
| |
| InfoTable = AcpiDmTableInfoIort5; |
| Length = IortNode->Length - NodeOffset; |
| break; |
| |
| default: |
| |
| AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n", |
| IortNode->Type); |
| |
| /* Attempt to continue */ |
| |
| if (!IortNode->Length) |
| { |
| AcpiOsPrintf ("Invalid zero length IORT node\n"); |
| return; |
| } |
| goto NextSubtable; |
| } |
| |
| /* Dump the node subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, |
| ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), |
| Length, InfoTable); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| NodeOffset += Length; |
| |
| /* Dump the node specific data */ |
| |
| switch (IortNode->Type) |
| { |
| case ACPI_IORT_NODE_ITS_GROUP: |
| |
| /* Validate IortItsGroup to avoid compiler warnings */ |
| |
| if (IortItsGroup) |
| { |
| for (i = 0; i < IortItsGroup->ItsCount; i++) |
| { |
| Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, |
| ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), |
| 4, AcpiDmTableInfoIort0a); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| NodeOffset += 4; |
| } |
| } |
| break; |
| |
| case ACPI_IORT_NODE_NAMED_COMPONENT: |
| |
| /* Dump the Padding (optional) */ |
| |
| if (IortNode->Length > NodeOffset) |
| { |
| MappingByteLength = |
| IortNode->MappingCount * sizeof (ACPI_IORT_ID_MAPPING); |
| Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, |
| Table, IortNode->Length - NodeOffset - MappingByteLength, |
| AcpiDmTableInfoIort1a); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| } |
| break; |
| |
| case ACPI_IORT_NODE_SMMU: |
| |
| AcpiOsPrintf ("\n"); |
| |
| /* Validate IortSmmu to avoid compiler warnings */ |
| |
| if (IortSmmu) |
| { |
| Length = 2 * sizeof (UINT64); |
| NodeOffset = IortSmmu->GlobalInterruptOffset; |
| Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, |
| ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), |
| Length, AcpiDmTableInfoIort3a); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| NodeOffset = IortSmmu->ContextInterruptOffset; |
| for (i = 0; i < IortSmmu->ContextInterruptCount; i++) |
| { |
| Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, |
| ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), |
| 8, AcpiDmTableInfoIort3b); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| NodeOffset += 8; |
| } |
| |
| NodeOffset = IortSmmu->PmuInterruptOffset; |
| for (i = 0; i < IortSmmu->PmuInterruptCount; i++) |
| { |
| Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, |
| ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), |
| 8, AcpiDmTableInfoIort3c); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| NodeOffset += 8; |
| } |
| } |
| break; |
| |
| default: |
| |
| break; |
| } |
| |
| /* Dump the ID mappings */ |
| |
| NodeOffset = IortNode->MappingOffset; |
| for (i = 0; i < IortNode->MappingCount; i++) |
| { |
| AcpiOsPrintf ("\n"); |
| Length = sizeof (ACPI_IORT_ID_MAPPING); |
| Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, |
| ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), |
| Length, AcpiDmTableInfoIortMap); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| NodeOffset += Length; |
| } |
| |
| NextSubtable: |
| /* Point to next node subtable */ |
| |
| Offset += IortNode->Length; |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpIvrs |
| * |
| * PARAMETERS: Table - A IVRS table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a IVRS |
| * |
| ******************************************************************************/ |
| |
| static UINT8 EntrySizes[] = {4,8,16,32}; |
| |
| void |
| AcpiDmDumpIvrs ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| UINT32 Offset = sizeof (ACPI_TABLE_IVRS); |
| UINT32 EntryOffset; |
| UINT32 EntryLength; |
| UINT32 EntryType; |
| ACPI_IVRS_DE_HEADER *DeviceEntry; |
| ACPI_IVRS_HEADER *Subtable; |
| ACPI_DMTABLE_INFO *InfoTable; |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Subtables */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); |
| while (Offset < Table->Length) |
| { |
| /* Common subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, |
| Subtable->Length, AcpiDmTableInfoIvrsHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| switch (Subtable->Type) |
| { |
| case ACPI_IVRS_TYPE_HARDWARE: |
| |
| InfoTable = AcpiDmTableInfoIvrs0; |
| break; |
| |
| case ACPI_IVRS_TYPE_MEMORY1: |
| case ACPI_IVRS_TYPE_MEMORY2: |
| case ACPI_IVRS_TYPE_MEMORY3: |
| |
| InfoTable = AcpiDmTableInfoIvrs1; |
| break; |
| |
| default: |
| |
| AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n", |
| Subtable->Type); |
| |
| /* Attempt to continue */ |
| |
| if (!Subtable->Length) |
| { |
| AcpiOsPrintf ("Invalid zero length subtable\n"); |
| return; |
| } |
| goto NextSubtable; |
| } |
| |
| /* Dump the subtable */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, |
| Subtable->Length, InfoTable); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* The hardware subtable can contain multiple device entries */ |
| |
| if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE) |
| { |
| EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE); |
| DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable, |
| sizeof (ACPI_IVRS_HARDWARE)); |
| |
| while (EntryOffset < (Offset + Subtable->Length)) |
| { |
| AcpiOsPrintf ("\n"); |
| /* |
| * Upper 2 bits of Type encode the length of the device entry |
| * |
| * 00 = 4 byte |
| * 01 = 8 byte |
| * 10 = 16 byte - currently no entries defined |
| * 11 = 32 byte - currently no entries defined |
| */ |
| EntryType = DeviceEntry->Type; |
| EntryLength = EntrySizes [EntryType >> 6]; |
| |
| switch (EntryType) |
| { |
| /* 4-byte device entries */ |
| |
| case ACPI_IVRS_TYPE_PAD4: |
| case ACPI_IVRS_TYPE_ALL: |
| case ACPI_IVRS_TYPE_SELECT: |
| case ACPI_IVRS_TYPE_START: |
| case ACPI_IVRS_TYPE_END: |
| |
| InfoTable = AcpiDmTableInfoIvrs4; |
| break; |
| |
| /* 8-byte entries, type A */ |
| |
| case ACPI_IVRS_TYPE_ALIAS_SELECT: |
| case ACPI_IVRS_TYPE_ALIAS_START: |
| |
| InfoTable = AcpiDmTableInfoIvrs8a; |
| break; |
| |
| /* 8-byte entries, type B */ |
| |
| case ACPI_IVRS_TYPE_PAD8: |
| case ACPI_IVRS_TYPE_EXT_SELECT: |
| case ACPI_IVRS_TYPE_EXT_START: |
| |
| InfoTable = AcpiDmTableInfoIvrs8b; |
| break; |
| |
| /* 8-byte entries, type C */ |
| |
| case ACPI_IVRS_TYPE_SPECIAL: |
| |
| InfoTable = AcpiDmTableInfoIvrs8c; |
| break; |
| |
| default: |
| InfoTable = AcpiDmTableInfoIvrs4; |
| AcpiOsPrintf ( |
| "\n**** Unknown IVRS device entry type/length: " |
| "0x%.2X/0x%X at offset 0x%.4X: (header below)\n", |
| EntryType, EntryLength, EntryOffset); |
| break; |
| } |
| |
| /* Dump the Device Entry */ |
| |
| Status = AcpiDmDumpTable (Table->Length, EntryOffset, |
| DeviceEntry, EntryLength, InfoTable); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| EntryOffset += EntryLength; |
| DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry, |
| EntryLength); |
| } |
| } |
| |
| NextSubtable: |
| /* Point to next subtable */ |
| |
| Offset += Subtable->Length; |
| Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Subtable, Subtable->Length); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpLpit |
| * |
| * PARAMETERS: Table - A LPIT table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a LPIT. This table type consists |
| * of an open-ended number of subtables. Note: There are no |
| * entries in the main table. An LPIT consists of the table |
| * header and then subtables only. |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpLpit ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| ACPI_LPIT_HEADER *Subtable; |
| UINT32 Length = Table->Length; |
| UINT32 Offset = sizeof (ACPI_TABLE_LPIT); |
| ACPI_DMTABLE_INFO *InfoTable; |
| UINT32 SubtableLength; |
| |
| |
| /* Subtables */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset); |
| while (Offset < Table->Length) |
| { |
| /* Common subtable header */ |
| |
| Status = AcpiDmDumpTable (Length, Offset, Subtable, |
| sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| switch (Subtable->Type) |
| { |
| case ACPI_LPIT_TYPE_NATIVE_CSTATE: |
| |
| InfoTable = AcpiDmTableInfoLpit0; |
| SubtableLength = sizeof (ACPI_LPIT_NATIVE); |
| break; |
| |
| default: |
| |
| /* Cannot continue on unknown type - no length */ |
| |
| AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n", |
| Subtable->Type); |
| return; |
| } |
| |
| Status = AcpiDmDumpTable (Length, Offset, Subtable, |
| SubtableLength, InfoTable); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| AcpiOsPrintf ("\n"); |
| |
| /* Point to next subtable */ |
| |
| Offset += SubtableLength; |
| Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Subtable, SubtableLength); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpMadt |
| * |
| * PARAMETERS: Table - A MADT table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a MADT. This table type consists |
| * of an open-ended number of subtables. |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpMadt ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| ACPI_SUBTABLE_HEADER *Subtable; |
| UINT32 Length = Table->Length; |
| UINT32 Offset = sizeof (ACPI_TABLE_MADT); |
| ACPI_DMTABLE_INFO *InfoTable; |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Subtables */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); |
| while (Offset < Table->Length) |
| { |
| /* Common subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Length, Offset, Subtable, |
| Subtable->Length, AcpiDmTableInfoMadtHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| switch (Subtable->Type) |
| { |
| case ACPI_MADT_TYPE_LOCAL_APIC: |
| |
| InfoTable = AcpiDmTableInfoMadt0; |
| break; |
| |
| case ACPI_MADT_TYPE_IO_APIC: |
| |
| InfoTable = AcpiDmTableInfoMadt1; |
| break; |
| |
| case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: |
| |
| InfoTable = AcpiDmTableInfoMadt2; |
| break; |
| |
| case ACPI_MADT_TYPE_NMI_SOURCE: |
| |
| InfoTable = AcpiDmTableInfoMadt3; |
| break; |
| |
| case ACPI_MADT_TYPE_LOCAL_APIC_NMI: |
| |
| InfoTable = AcpiDmTableInfoMadt4; |
| break; |
| |
| case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: |
| |
| InfoTable = AcpiDmTableInfoMadt5; |
| break; |
| |
| case ACPI_MADT_TYPE_IO_SAPIC: |
| |
| InfoTable = AcpiDmTableInfoMadt6; |
| break; |
| |
| case ACPI_MADT_TYPE_LOCAL_SAPIC: |
| |
| InfoTable = AcpiDmTableInfoMadt7; |
| break; |
| |
| case ACPI_MADT_TYPE_INTERRUPT_SOURCE: |
| |
| InfoTable = AcpiDmTableInfoMadt8; |
| break; |
| |
| case ACPI_MADT_TYPE_LOCAL_X2APIC: |
| |
| InfoTable = AcpiDmTableInfoMadt9; |
| break; |
| |
| case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: |
| |
| InfoTable = AcpiDmTableInfoMadt10; |
| break; |
| |
| case ACPI_MADT_TYPE_GENERIC_INTERRUPT: |
| |
| InfoTable = AcpiDmTableInfoMadt11; |
| break; |
| |
| case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: |
| |
| InfoTable = AcpiDmTableInfoMadt12; |
| break; |
| |
| case ACPI_MADT_TYPE_GENERIC_MSI_FRAME: |
| |
| InfoTable = AcpiDmTableInfoMadt13; |
| break; |
| |
| case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR: |
| |
| InfoTable = AcpiDmTableInfoMadt14; |
| break; |
| |
| case ACPI_MADT_TYPE_GENERIC_TRANSLATOR: |
| |
| InfoTable = AcpiDmTableInfoMadt15; |
| break; |
| |
| default: |
| |
| AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n", |
| Subtable->Type); |
| |
| /* Attempt to continue */ |
| |
| if (!Subtable->Length) |
| { |
| AcpiOsPrintf ("Invalid zero length subtable\n"); |
| return; |
| } |
| |
| goto NextSubtable; |
| } |
| |
| Status = AcpiDmDumpTable (Length, Offset, Subtable, |
| Subtable->Length, InfoTable); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| NextSubtable: |
| /* Point to next subtable */ |
| |
| Offset += Subtable->Length; |
| Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, |
| Subtable->Length); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpMcfg |
| * |
| * PARAMETERS: Table - A MCFG Table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a MCFG table |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpMcfg ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| UINT32 Offset = sizeof (ACPI_TABLE_MCFG); |
| ACPI_MCFG_ALLOCATION *Subtable; |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Subtables */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); |
| while (Offset < Table->Length) |
| { |
| if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) |
| { |
| AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", |
| (UINT32) sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); |
| return; |
| } |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, |
| sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Point to next subtable (each subtable is of fixed length) */ |
| |
| Offset += sizeof (ACPI_MCFG_ALLOCATION); |
| Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Subtable, |
| sizeof (ACPI_MCFG_ALLOCATION)); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpMpst |
| * |
| * PARAMETERS: Table - A MPST Table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a MPST table |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpMpst ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| UINT32 Offset = sizeof (ACPI_TABLE_MPST); |
| ACPI_MPST_POWER_NODE *Subtable0; |
| ACPI_MPST_POWER_STATE *Subtable0A; |
| ACPI_MPST_COMPONENT *Subtable0B; |
| ACPI_MPST_DATA_HDR *Subtable1; |
| ACPI_MPST_POWER_DATA *Subtable2; |
| UINT16 SubtableCount; |
| UINT32 PowerStateCount; |
| UINT32 ComponentCount; |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Subtable: Memory Power Node(s) */ |
| |
| SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; |
| Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); |
| |
| while ((Offset < Table->Length) && SubtableCount) |
| { |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0, |
| sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Extract the sub-subtable counts */ |
| |
| PowerStateCount = Subtable0->NumPowerStates; |
| ComponentCount = Subtable0->NumPhysicalComponents; |
| Offset += sizeof (ACPI_MPST_POWER_NODE); |
| |
| /* Sub-subtables - Memory Power State Structure(s) */ |
| |
| Subtable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, Subtable0, |
| sizeof (ACPI_MPST_POWER_NODE)); |
| |
| while (PowerStateCount) |
| { |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0A, |
| sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| Subtable0A++; |
| PowerStateCount--; |
| Offset += sizeof (ACPI_MPST_POWER_STATE); |
| } |
| |
| /* Sub-subtables - Physical Component ID Structure(s) */ |
| |
| Subtable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, Subtable0A); |
| |
| if (ComponentCount) |
| { |
| AcpiOsPrintf ("\n"); |
| } |
| |
| while (ComponentCount) |
| { |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0B, |
| sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| Subtable0B++; |
| ComponentCount--; |
| Offset += sizeof (ACPI_MPST_COMPONENT); |
| } |
| |
| /* Point to next Memory Power Node subtable */ |
| |
| SubtableCount--; |
| Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Subtable0, |
| sizeof (ACPI_MPST_POWER_NODE) + |
| (sizeof (ACPI_MPST_POWER_STATE) * Subtable0->NumPowerStates) + |
| (sizeof (ACPI_MPST_COMPONENT) * Subtable0->NumPhysicalComponents)); |
| } |
| |
| /* Subtable: Count of Memory Power State Characteristic structures */ |
| |
| AcpiOsPrintf ("\n"); |
| Subtable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable0); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable1, |
| sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| SubtableCount = Subtable1->CharacteristicsCount; |
| Offset += sizeof (ACPI_MPST_DATA_HDR); |
| |
| /* Subtable: Memory Power State Characteristics structure(s) */ |
| |
| Subtable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, Subtable1, |
| sizeof (ACPI_MPST_DATA_HDR)); |
| |
| while ((Offset < Table->Length) && SubtableCount) |
| { |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable2, |
| sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| Subtable2++; |
| SubtableCount--; |
| Offset += sizeof (ACPI_MPST_POWER_DATA); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpMsct |
| * |
| * PARAMETERS: Table - A MSCT table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a MSCT |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpMsct ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| UINT32 Offset = sizeof (ACPI_TABLE_MSCT); |
| ACPI_MSCT_PROXIMITY *Subtable; |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Subtables */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); |
| while (Offset < Table->Length) |
| { |
| /* Common subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, |
| sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Point to next subtable */ |
| |
| Offset += sizeof (ACPI_MSCT_PROXIMITY); |
| Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Subtable, |
| sizeof (ACPI_MSCT_PROXIMITY)); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpMtmr |
| * |
| * PARAMETERS: Table - A MTMR table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a MTMR |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpMtmr ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| UINT32 Offset = sizeof (ACPI_TABLE_MTMR); |
| ACPI_MTMR_ENTRY *Subtable; |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Subtables */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset); |
| while (Offset < Table->Length) |
| { |
| /* Common subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, |
| sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Point to next subtable */ |
| |
| Offset += sizeof (ACPI_MTMR_ENTRY); |
| Subtable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Subtable, |
| sizeof (ACPI_MTMR_ENTRY)); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpNfit |
| * |
| * PARAMETERS: Table - A NFIT table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of an NFIT. |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpNfit ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| UINT32 Offset = sizeof (ACPI_TABLE_NFIT); |
| UINT32 FieldOffset = 0; |
| UINT32 Length; |
| ACPI_NFIT_HEADER *Subtable; |
| ACPI_DMTABLE_INFO *InfoTable; |
| ACPI_NFIT_INTERLEAVE *Interleave = NULL; |
| ACPI_NFIT_SMBIOS *SmbiosInfo = NULL; |
| ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; |
| UINT32 i; |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Subtables */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset); |
| while (Offset < Table->Length) |
| { |
| /* NFIT subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, |
| Subtable->Length, AcpiDmTableInfoNfitHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| switch (Subtable->Type) |
| { |
| case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: |
| |
| InfoTable = AcpiDmTableInfoNfit0; |
| break; |
| |
| case ACPI_NFIT_TYPE_MEMORY_MAP: |
| |
| InfoTable = AcpiDmTableInfoNfit1; |
| break; |
| |
| case ACPI_NFIT_TYPE_INTERLEAVE: |
| |
| /* Has a variable number of 32-bit values at the end */ |
| |
| InfoTable = AcpiDmTableInfoNfit2; |
| FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE); |
| break; |
| |
| case ACPI_NFIT_TYPE_SMBIOS: |
| |
| SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, Subtable); |
| InfoTable = AcpiDmTableInfoNfit3; |
| break; |
| |
| case ACPI_NFIT_TYPE_CONTROL_REGION: |
| |
| InfoTable = AcpiDmTableInfoNfit4; |
| break; |
| |
| case ACPI_NFIT_TYPE_DATA_REGION: |
| |
| InfoTable = AcpiDmTableInfoNfit5; |
| break; |
| |
| case ACPI_NFIT_TYPE_FLUSH_ADDRESS: |
| |
| /* Has a variable number of 64-bit addresses at the end */ |
| |
| InfoTable = AcpiDmTableInfoNfit6; |
| FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64); |
| break; |
| |
| case ACPI_NFIT_TYPE_CAPABILITIES: /* ACPI 6.0A */ |
| |
| InfoTable = AcpiDmTableInfoNfit7; |
| break; |
| |
| default: |
| AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n", |
| Subtable->Type); |
| |
| /* Attempt to continue */ |
| |
| if (!Subtable->Length) |
| { |
| AcpiOsPrintf ("Invalid zero length subtable\n"); |
| return; |
| } |
| goto NextSubtable; |
| } |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, |
| Subtable->Length, InfoTable); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Per-subtable variable-length fields */ |
| |
| switch (Subtable->Type) |
| { |
| case ACPI_NFIT_TYPE_INTERLEAVE: |
| |
| Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable); |
| for (i = 0; i < Interleave->LineCount; i++) |
| { |
| Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, |
| &Interleave->LineOffset[i], |
| sizeof (UINT32), AcpiDmTableInfoNfit2a); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| FieldOffset += sizeof (UINT32); |
| } |
| break; |
| |
| case ACPI_NFIT_TYPE_SMBIOS: |
| |
| Length = Subtable->Length - |
| sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8); |
| |
| if (Length) |
| { |
| Status = AcpiDmDumpTable (Table->Length, |
| sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8), |
| SmbiosInfo, |
| Length, AcpiDmTableInfoNfit3a); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| } |
| |
| break; |
| |
| case ACPI_NFIT_TYPE_FLUSH_ADDRESS: |
| |
| Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable); |
| for (i = 0; i < Hint->HintCount; i++) |
| { |
| Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, |
| &Hint->HintAddress[i], |
| sizeof (UINT64), AcpiDmTableInfoNfit6a); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| FieldOffset += sizeof (UINT64); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| NextSubtable: |
| /* Point to next subtable */ |
| |
| Offset += Subtable->Length; |
| Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Subtable, Subtable->Length); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpPcct |
| * |
| * PARAMETERS: Table - A PCCT table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a PCCT. This table type consists |
| * of an open-ended number of subtables. |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpPcct ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| ACPI_PCCT_SUBSPACE *Subtable; |
| ACPI_DMTABLE_INFO *InfoTable; |
| UINT32 Length = Table->Length; |
| UINT32 Offset = sizeof (ACPI_TABLE_PCCT); |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Subtables */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); |
| while (Offset < Table->Length) |
| { |
| /* Common subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Length, Offset, Subtable, |
| Subtable->Header.Length, AcpiDmTableInfoPcctHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| switch (Subtable->Header.Type) |
| { |
| case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: |
| |
| InfoTable = AcpiDmTableInfoPcct0; |
| break; |
| |
| case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: |
| |
| InfoTable = AcpiDmTableInfoPcct1; |
| break; |
| |
| case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2: |
| |
| InfoTable = AcpiDmTableInfoPcct2; |
| break; |
| |
| case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE: |
| |
| InfoTable = AcpiDmTableInfoPcct3; |
| break; |
| |
| case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE: |
| |
| InfoTable = AcpiDmTableInfoPcct4; |
| break; |
| |
| default: |
| |
| AcpiOsPrintf ( |
| "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n", |
| Subtable->Header.Type); |
| return; |
| } |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Length, Offset, Subtable, |
| Subtable->Header.Length, InfoTable); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Point to next subtable */ |
| |
| Offset += Subtable->Header.Length; |
| Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Subtable, |
| Subtable->Header.Length); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpPdtt |
| * |
| * PARAMETERS: Table - A PDTT table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a Pdtt. This is a variable-length |
| * table that contains an open-ended number of IDs |
| * at the end of the table. |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpPdtt ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| ACPI_PDTT_CHANNEL *Subtable; |
| UINT32 Length = Table->Length; |
| UINT32 Offset = sizeof (ACPI_TABLE_PDTT); |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPdtt); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Subtables. Currently there is only one type, but can be multiples */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Table, Offset); |
| while (Offset < Table->Length) |
| { |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Length, Offset, Subtable, |
| sizeof (ACPI_PDTT_CHANNEL), AcpiDmTableInfoPdtt0); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Point to next subtable */ |
| |
| Offset += sizeof (ACPI_PDTT_CHANNEL); |
| Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Subtable, |
| sizeof (ACPI_PDTT_CHANNEL)); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpPmtt |
| * |
| * PARAMETERS: Table - A PMTT table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a PMTT. This table type consists |
| * of an open-ended number of subtables. |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpPmtt ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| ACPI_PMTT_HEADER *Subtable; |
| ACPI_PMTT_HEADER *MemSubtable; |
| ACPI_PMTT_HEADER *DimmSubtable; |
| ACPI_PMTT_DOMAIN *DomainArray; |
| UINT32 Length = Table->Length; |
| UINT32 Offset = sizeof (ACPI_TABLE_PMTT); |
| UINT32 MemOffset; |
| UINT32 DimmOffset; |
| UINT32 DomainOffset; |
| UINT32 DomainCount; |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Subtables */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); |
| while (Offset < Table->Length) |
| { |
| /* Common subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Length, Offset, Subtable, |
| Subtable->Length, AcpiDmTableInfoPmttHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Only Socket subtables are expected at this level */ |
| |
| if (Subtable->Type != ACPI_PMTT_TYPE_SOCKET) |
| { |
| AcpiOsPrintf ( |
| "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", |
| Subtable->Type); |
| return; |
| } |
| |
| /* Dump the fixed-length portion of the subtable */ |
| |
| Status = AcpiDmDumpTable (Length, Offset, Subtable, |
| Subtable->Length, AcpiDmTableInfoPmtt0); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Walk the memory controller subtables */ |
| |
| MemOffset = sizeof (ACPI_PMTT_SOCKET); |
| MemSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Subtable, |
| sizeof (ACPI_PMTT_SOCKET)); |
| |
| while (((Offset + MemOffset) < Table->Length) && |
| (MemOffset < Subtable->Length)) |
| { |
| /* Common subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Length, |
| Offset + MemOffset, MemSubtable, |
| MemSubtable->Length, AcpiDmTableInfoPmttHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Only memory controller subtables are expected at this level */ |
| |
| if (MemSubtable->Type != ACPI_PMTT_TYPE_CONTROLLER) |
| { |
| AcpiOsPrintf ( |
| "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", |
| MemSubtable->Type); |
| return; |
| } |
| |
| /* Dump the fixed-length portion of the controller subtable */ |
| |
| Status = AcpiDmDumpTable (Length, |
| Offset + MemOffset, MemSubtable, |
| MemSubtable->Length, AcpiDmTableInfoPmtt1); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Walk the variable count of proximity domains */ |
| |
| DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubtable)->DomainCount; |
| DomainOffset = sizeof (ACPI_PMTT_CONTROLLER); |
| DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubtable, |
| sizeof (ACPI_PMTT_CONTROLLER)); |
| |
| while (((Offset + MemOffset + DomainOffset) < Table->Length) && |
| ((MemOffset + DomainOffset) < Subtable->Length) && |
| DomainCount) |
| { |
| Status = AcpiDmDumpTable (Length, |
| Offset + MemOffset + DomainOffset, DomainArray, |
| sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| DomainOffset += sizeof (ACPI_PMTT_DOMAIN); |
| DomainArray++; |
| DomainCount--; |
| } |
| |
| if (DomainCount) |
| { |
| AcpiOsPrintf ( |
| "\n**** DomainCount exceeds subtable length\n\n"); |
| } |
| |
| /* Walk the physical component (DIMM) subtables */ |
| |
| DimmOffset = DomainOffset; |
| DimmSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubtable, |
| DomainOffset); |
| |
| while (((Offset + MemOffset + DimmOffset) < Table->Length) && |
| (DimmOffset < MemSubtable->Length)) |
| { |
| /* Common subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Length, |
| Offset + MemOffset + DimmOffset, DimmSubtable, |
| DimmSubtable->Length, AcpiDmTableInfoPmttHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Only DIMM subtables are expected at this level */ |
| |
| if (DimmSubtable->Type != ACPI_PMTT_TYPE_DIMM) |
| { |
| AcpiOsPrintf ( |
| "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", |
| DimmSubtable->Type); |
| return; |
| } |
| |
| /* Dump the fixed-length DIMM subtable */ |
| |
| Status = AcpiDmDumpTable (Length, |
| Offset + MemOffset + DimmOffset, DimmSubtable, |
| DimmSubtable->Length, AcpiDmTableInfoPmtt2); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Point to next DIMM subtable */ |
| |
| DimmOffset += DimmSubtable->Length; |
| DimmSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, |
| DimmSubtable, DimmSubtable->Length); |
| } |
| |
| /* Point to next Controller subtable */ |
| |
| MemOffset += MemSubtable->Length; |
| MemSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, |
| MemSubtable, MemSubtable->Length); |
| } |
| |
| /* Point to next Socket subtable */ |
| |
| Offset += Subtable->Length; |
| Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, |
| Subtable, Subtable->Length); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpPptt |
| * |
| * PARAMETERS: Table - A PMTT table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a PPTT. This table type consists |
| * of an open-ended number of subtables. |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpPptt ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| ACPI_SUBTABLE_HEADER *Subtable; |
| ACPI_PPTT_PROCESSOR *PpttProcessor; |
| UINT8 Length; |
| UINT8 SubtableOffset; |
| UINT32 Offset = sizeof (ACPI_TABLE_FPDT); |
| ACPI_DMTABLE_INFO *InfoTable; |
| UINT32 i; |
| |
| |
| /* There is no main table (other than the standard ACPI header) */ |
| |
| /* Subtables */ |
| |
| Offset = sizeof (ACPI_TABLE_HEADER); |
| while (Offset < Table->Length) |
| { |
| AcpiOsPrintf ("\n"); |
| |
| /* Common subtable header */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); |
| if (Subtable->Length < sizeof (ACPI_SUBTABLE_HEADER)) |
| { |
| AcpiOsPrintf ("Invalid subtable length\n"); |
| return; |
| } |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, |
| Subtable->Length, AcpiDmTableInfoPpttHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| switch (Subtable->Type) |
| { |
| case ACPI_PPTT_TYPE_PROCESSOR: |
| |
| InfoTable = AcpiDmTableInfoPptt0; |
| Length = sizeof (ACPI_PPTT_PROCESSOR); |
| break; |
| |
| case ACPI_PPTT_TYPE_CACHE: |
| |
| InfoTable = AcpiDmTableInfoPptt1; |
| Length = sizeof (ACPI_PPTT_CACHE); |
| break; |
| |
| case ACPI_PPTT_TYPE_ID: |
| |
| InfoTable = AcpiDmTableInfoPptt2; |
| Length = sizeof (ACPI_PPTT_ID); |
| break; |
| |
| default: |
| |
| AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n", |
| Subtable->Type); |
| |
| /* Attempt to continue */ |
| |
| goto NextSubtable; |
| } |
| |
| if (Subtable->Length < Length) |
| { |
| AcpiOsPrintf ("Invalid subtable length\n"); |
| return; |
| } |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, |
| Subtable->Length, InfoTable); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| SubtableOffset = Length; |
| |
| switch (Subtable->Type) |
| { |
| case ACPI_PPTT_TYPE_PROCESSOR: |
| |
| PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, Subtable); |
| |
| /* Dump SMBIOS handles */ |
| |
| if ((UINT8)(Subtable->Length - SubtableOffset) < |
| (UINT8)(PpttProcessor->NumberOfPrivResources * 4)) |
| { |
| AcpiOsPrintf ("Invalid private resource number\n"); |
| return; |
| } |
| for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++) |
| { |
| Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, |
| ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset), |
| 4, AcpiDmTableInfoPptt0a); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| SubtableOffset += 4; |
| } |
| break; |
| |
| default: |
| |
| break; |
| } |
| |
| NextSubtable: |
| /* Point to next subtable */ |
| |
| Offset += Subtable->Length; |
| } |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpS3pt |
| * |
| * PARAMETERS: Table - A S3PT table |
| * |
| * RETURN: Length of the table |
| * |
| * DESCRIPTION: Format the contents of a S3PT |
| * |
| ******************************************************************************/ |
| |
| UINT32 |
| AcpiDmDumpS3pt ( |
| ACPI_TABLE_HEADER *Tables) |
| { |
| ACPI_STATUS Status; |
| UINT32 Offset = sizeof (ACPI_TABLE_S3PT); |
| ACPI_FPDT_HEADER *Subtable; |
| ACPI_DMTABLE_INFO *InfoTable; |
| ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt); |
| if (ACPI_FAILURE (Status)) |
| { |
| return 0; |
| } |
| |
| Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset); |
| while (Offset < S3ptTable->Length) |
| { |
| /* Common subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable, |
| Subtable->Length, AcpiDmTableInfoS3ptHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return 0; |
| } |
| |
| switch (Subtable->Type) |
| { |
| case ACPI_S3PT_TYPE_RESUME: |
| |
| InfoTable = AcpiDmTableInfoS3pt0; |
| break; |
| |
| case ACPI_S3PT_TYPE_SUSPEND: |
| |
| InfoTable = AcpiDmTableInfoS3pt1; |
| break; |
| |
| default: |
| |
| AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", |
| Subtable->Type); |
| |
| /* Attempt to continue */ |
| |
| if (!Subtable->Length) |
| { |
| AcpiOsPrintf ("Invalid zero length subtable\n"); |
| return 0; |
| } |
| goto NextSubtable; |
| } |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable, |
| Subtable->Length, InfoTable); |
| if (ACPI_FAILURE (Status)) |
| { |
| return 0; |
| } |
| |
| NextSubtable: |
| /* Point to next subtable */ |
| |
| Offset += Subtable->Length; |
| Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, Subtable->Length); |
| } |
| |
| return (S3ptTable->Length); |
| } |
| |
| |
| /******************************************************************************* |
| * |
| * FUNCTION: AcpiDmDumpSdev |
| * |
| * PARAMETERS: Table - A SDEV table |
| * |
| * RETURN: None |
| * |
| * DESCRIPTION: Format the contents of a SDEV. This is a variable-length |
| * table that contains variable strings and vendor data. |
| * |
| ******************************************************************************/ |
| |
| void |
| AcpiDmDumpSdev ( |
| ACPI_TABLE_HEADER *Table) |
| { |
| ACPI_STATUS Status; |
| ACPI_SDEV_HEADER *Subtable; |
| ACPI_SDEV_PCIE *Pcie; |
| ACPI_SDEV_NAMESPACE *Namesp; |
| ACPI_DMTABLE_INFO *InfoTable; |
| UINT32 Length = Table->Length; |
| UINT32 Offset = sizeof (ACPI_TABLE_SDEV); |
| UINT16 PathOffset; |
| UINT16 PathLength; |
| UINT16 VendorDataOffset; |
| UINT16 VendorDataLength; |
| |
| |
| /* Main table */ |
| |
| Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSdev); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| /* Subtables */ |
| |
| Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Table, Offset); |
| while (Offset < Table->Length) |
| { |
| /* Common subtable header */ |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, |
| Subtable->Length, AcpiDmTableInfoSdevHdr); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| switch (Subtable->Type) |
| { |
| case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: |
| |
| InfoTable = AcpiDmTableInfoSdev0; |
| break; |
| |
| case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: |
| |
| InfoTable = AcpiDmTableInfoSdev1; |
| break; |
| |
| default: |
| goto NextSubtable; |
| } |
| |
| AcpiOsPrintf ("\n"); |
| Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, |
| Subtable->Length, InfoTable); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| switch (Subtable->Type) |
| { |
| case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: |
| |
| /* Dump the PCIe device ID(s) */ |
| |
| Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable); |
| PathOffset = Namesp->DeviceIdOffset; |
| PathLength = Namesp->DeviceIdLength; |
| |
| if (PathLength) |
| { |
| Status = AcpiDmDumpTable (Table->Length, 0, |
| ACPI_ADD_PTR (UINT8, Namesp, PathOffset), |
| PathLength, AcpiDmTableInfoSdev0a); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| } |
| |
| /* Dump the vendor-specific data */ |
| |
| VendorDataLength = |
| Namesp->VendorDataLength; |
| VendorDataOffset = |
| Namesp->DeviceIdOffset + Namesp->DeviceIdLength; |
| |
| if (VendorDataLength) |
| { |
| Status = AcpiDmDumpTable (Table->Length, 0, |
| ACPI_ADD_PTR (UINT8, Namesp, VendorDataOffset), |
| VendorDataLength, AcpiDmTableInfoSdev1b); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| } |
| break; |
| |
| case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: |
| |
| /* PCI path substructures */ |
| |
| Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable); |
| PathOffset = Pcie->PathOffset; |
| PathLength = Pcie->PathLength; |
| |
| while (PathLength) |
| { |
| Status = AcpiDmDumpTable (Table->Length, |
| PathOffset + Offset, |
| ACPI_ADD_PTR (UINT8, Pcie, PathOffset), |
| sizeof (ACPI_SDEV_PCIE_PATH), AcpiDmTableInfoSdev1a); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| |
| PathOffset += sizeof (ACPI_SDEV_PCIE_PATH); |
| PathLength -= sizeof (ACPI_SDEV_PCIE_PATH); |
| } |
| |
| /* VendorData */ |
| |
| VendorDataLength = Pcie->VendorDataLength; |
| VendorDataOffset = Pcie->PathOffset + Pcie->PathLength; |
| |
| if (VendorDataLength) |
| { |
| Status = AcpiDmDumpTable (Table->Length, 0, |
| ACPI_ADD_PTR (UINT8, Pcie, VendorDataOffset), |
| VendorDataLength, AcpiDmTableInfoSdev1b); |
| if (ACPI_FAILURE (Status)) |
| { |
| return; |
| } |
| } |
| break; |
| |
| default: |
| goto NextSubtable; |
| } |
| |
| NextSubtable: |
| /* Point to next subtable */ |
| |
| Offset += Subtable->Length; |
| Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Subtable, |
| Subtable->Length); |
| } |
| } |
