1 /******************************************************************************
3 * Module Name: dmtbdump2 - Dump ACPI data tables that contain no AML code
5 *****************************************************************************/
7 /******************************************************************************
11 * Some or all of this work - Copyright (c) 1999 - 2019, Intel Corp.
12 * All rights reserved.
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
37 * The above copyright and patent license is granted only if the following
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
72 * 3.4. Intel retains all right, title, and interest in and to the Original
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
80 * 4. Disclaimer and Export Compliance
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
114 *****************************************************************************
116 * Alternatively, you may choose to be licensed under the terms of the
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
122 * 1. Redistributions of source code must retain the above copyright
123 * notice, this list of conditions, and the following disclaimer,
124 * without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 * substantially similar to the "NO WARRANTY" disclaimer below
127 * ("Disclaimer") and any redistribution must be conditioned upon
128 * including a substantially similar Disclaimer requirement for further
129 * binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 * of any contributors may be used to endorse or promote products derived
132 * from this software without specific prior written permission.
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
150 *****************************************************************************/
153 #include "accommon.h"
154 #include "acdisasm.h"
155 #include "actables.h"
157 /* This module used for application-level code only */
159 #define _COMPONENT ACPI_CA_DISASSEMBLER
160 ACPI_MODULE_NAME ("dmtbdump2")
163 /*******************************************************************************
165 * FUNCTION: AcpiDmDumpIort
167 * PARAMETERS: Table - A IORT table
171 * DESCRIPTION: Format the contents of a IORT
173 ******************************************************************************/
177 ACPI_TABLE_HEADER *Table)
180 ACPI_TABLE_IORT *Iort;
181 ACPI_IORT_NODE *IortNode;
182 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL;
183 ACPI_IORT_SMMU *IortSmmu = NULL;
187 ACPI_DMTABLE_INFO *InfoTable;
194 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort);
195 if (ACPI_FAILURE (Status))
200 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table);
201 Offset = sizeof (ACPI_TABLE_IORT);
203 /* Dump the OptionalPadding (optional) */
205 if (Iort->NodeOffset > Offset)
207 Status = AcpiDmDumpTable (Table->Length, Offset, Table,
208 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad);
209 if (ACPI_FAILURE (Status))
215 Offset = Iort->NodeOffset;
216 while (Offset < Table->Length)
218 /* Common subtable header */
220 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset);
222 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
223 Status = AcpiDmDumpTable (Table->Length, Offset,
224 IortNode, Length, AcpiDmTableInfoIortHdr);
225 if (ACPI_FAILURE (Status))
232 switch (IortNode->Type)
234 case ACPI_IORT_NODE_ITS_GROUP:
236 InfoTable = AcpiDmTableInfoIort0;
237 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers);
238 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset);
241 case ACPI_IORT_NODE_NAMED_COMPONENT:
243 InfoTable = AcpiDmTableInfoIort1;
244 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName);
245 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length);
246 Length += strlen (String) + 1;
249 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
251 InfoTable = AcpiDmTableInfoIort2;
252 Length = IortNode->Length - NodeOffset;
255 case ACPI_IORT_NODE_SMMU:
257 InfoTable = AcpiDmTableInfoIort3;
258 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts);
259 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset);
262 case ACPI_IORT_NODE_SMMU_V3:
264 InfoTable = AcpiDmTableInfoIort4;
265 Length = IortNode->Length - NodeOffset;
268 case ACPI_IORT_NODE_PMCG:
270 InfoTable = AcpiDmTableInfoIort5;
271 Length = IortNode->Length - NodeOffset;
276 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n",
279 /* Attempt to continue */
281 if (!IortNode->Length)
283 AcpiOsPrintf ("Invalid zero length IORT node\n");
289 /* Dump the node subtable header */
292 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
293 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
295 if (ACPI_FAILURE (Status))
300 NodeOffset += Length;
302 /* Dump the node specific data */
304 switch (IortNode->Type)
306 case ACPI_IORT_NODE_ITS_GROUP:
308 /* Validate IortItsGroup to avoid compiler warnings */
312 for (i = 0; i < IortItsGroup->ItsCount; i++)
314 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
315 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
316 4, AcpiDmTableInfoIort0a);
322 case ACPI_IORT_NODE_NAMED_COMPONENT:
324 /* Dump the Padding (optional) */
326 if (IortNode->Length > NodeOffset)
328 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
329 Table, IortNode->Length - NodeOffset,
330 AcpiDmTableInfoIort1a);
331 if (ACPI_FAILURE (Status))
338 case ACPI_IORT_NODE_SMMU:
342 /* Validate IortSmmu to avoid compiler warnings */
346 Length = 2 * sizeof (UINT64);
347 NodeOffset = IortSmmu->GlobalInterruptOffset;
348 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
349 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
350 Length, AcpiDmTableInfoIort3a);
351 if (ACPI_FAILURE (Status))
356 NodeOffset = IortSmmu->ContextInterruptOffset;
357 for (i = 0; i < IortSmmu->ContextInterruptCount; i++)
359 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
360 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
361 8, AcpiDmTableInfoIort3b);
362 if (ACPI_FAILURE (Status))
370 NodeOffset = IortSmmu->PmuInterruptOffset;
371 for (i = 0; i < IortSmmu->PmuInterruptCount; i++)
373 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
374 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
375 8, AcpiDmTableInfoIort3c);
376 if (ACPI_FAILURE (Status))
391 /* Dump the ID mappings */
393 NodeOffset = IortNode->MappingOffset;
394 for (i = 0; i < IortNode->MappingCount; i++)
397 Length = sizeof (ACPI_IORT_ID_MAPPING);
398 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
399 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
400 Length, AcpiDmTableInfoIortMap);
401 if (ACPI_FAILURE (Status))
406 NodeOffset += Length;
410 /* Point to next node subtable */
412 Offset += IortNode->Length;
413 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length);
418 /*******************************************************************************
420 * FUNCTION: AcpiDmDumpIvrs
422 * PARAMETERS: Table - A IVRS table
426 * DESCRIPTION: Format the contents of a IVRS
428 ******************************************************************************/
430 static UINT8 EntrySizes[] = {4,8,16,32};
434 ACPI_TABLE_HEADER *Table)
437 UINT32 Offset = sizeof (ACPI_TABLE_IVRS);
441 ACPI_IVRS_DE_HEADER *DeviceEntry;
442 ACPI_IVRS_HEADER *Subtable;
443 ACPI_DMTABLE_INFO *InfoTable;
448 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
449 if (ACPI_FAILURE (Status))
456 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
457 while (Offset < Table->Length)
459 /* Common subtable header */
462 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
463 Subtable->Length, AcpiDmTableInfoIvrsHdr);
464 if (ACPI_FAILURE (Status))
469 switch (Subtable->Type)
471 case ACPI_IVRS_TYPE_HARDWARE:
473 InfoTable = AcpiDmTableInfoIvrs0;
476 case ACPI_IVRS_TYPE_MEMORY1:
477 case ACPI_IVRS_TYPE_MEMORY2:
478 case ACPI_IVRS_TYPE_MEMORY3:
480 InfoTable = AcpiDmTableInfoIvrs1;
485 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n",
488 /* Attempt to continue */
490 if (!Subtable->Length)
492 AcpiOsPrintf ("Invalid zero length subtable\n");
498 /* Dump the subtable */
501 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
502 Subtable->Length, InfoTable);
503 if (ACPI_FAILURE (Status))
508 /* The hardware subtable can contain multiple device entries */
510 if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE)
512 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
513 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable,
514 sizeof (ACPI_IVRS_HARDWARE));
516 while (EntryOffset < (Offset + Subtable->Length))
520 * Upper 2 bits of Type encode the length of the device entry
524 * 10 = 16 byte - currently no entries defined
525 * 11 = 32 byte - currently no entries defined
527 EntryType = DeviceEntry->Type;
528 EntryLength = EntrySizes [EntryType >> 6];
532 /* 4-byte device entries */
534 case ACPI_IVRS_TYPE_PAD4:
535 case ACPI_IVRS_TYPE_ALL:
536 case ACPI_IVRS_TYPE_SELECT:
537 case ACPI_IVRS_TYPE_START:
538 case ACPI_IVRS_TYPE_END:
540 InfoTable = AcpiDmTableInfoIvrs4;
543 /* 8-byte entries, type A */
545 case ACPI_IVRS_TYPE_ALIAS_SELECT:
546 case ACPI_IVRS_TYPE_ALIAS_START:
548 InfoTable = AcpiDmTableInfoIvrs8a;
551 /* 8-byte entries, type B */
553 case ACPI_IVRS_TYPE_PAD8:
554 case ACPI_IVRS_TYPE_EXT_SELECT:
555 case ACPI_IVRS_TYPE_EXT_START:
557 InfoTable = AcpiDmTableInfoIvrs8b;
560 /* 8-byte entries, type C */
562 case ACPI_IVRS_TYPE_SPECIAL:
564 InfoTable = AcpiDmTableInfoIvrs8c;
568 InfoTable = AcpiDmTableInfoIvrs4;
570 "\n**** Unknown IVRS device entry type/length: "
571 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
572 EntryType, EntryLength, EntryOffset);
576 /* Dump the Device Entry */
578 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
579 DeviceEntry, EntryLength, InfoTable);
580 if (ACPI_FAILURE (Status))
585 EntryOffset += EntryLength;
586 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
592 /* Point to next subtable */
594 Offset += Subtable->Length;
595 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Subtable, Subtable->Length);
600 /*******************************************************************************
602 * FUNCTION: AcpiDmDumpLpit
604 * PARAMETERS: Table - A LPIT table
608 * DESCRIPTION: Format the contents of a LPIT. This table type consists
609 * of an open-ended number of subtables. Note: There are no
610 * entries in the main table. An LPIT consists of the table
611 * header and then subtables only.
613 ******************************************************************************/
617 ACPI_TABLE_HEADER *Table)
620 ACPI_LPIT_HEADER *Subtable;
621 UINT32 Length = Table->Length;
622 UINT32 Offset = sizeof (ACPI_TABLE_LPIT);
623 ACPI_DMTABLE_INFO *InfoTable;
624 UINT32 SubtableLength;
629 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset);
630 while (Offset < Table->Length)
632 /* Common subtable header */
634 Status = AcpiDmDumpTable (Length, Offset, Subtable,
635 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);
636 if (ACPI_FAILURE (Status))
641 switch (Subtable->Type)
643 case ACPI_LPIT_TYPE_NATIVE_CSTATE:
645 InfoTable = AcpiDmTableInfoLpit0;
646 SubtableLength = sizeof (ACPI_LPIT_NATIVE);
651 /* Cannot continue on unknown type - no length */
653 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n",
658 Status = AcpiDmDumpTable (Length, Offset, Subtable,
659 SubtableLength, InfoTable);
660 if (ACPI_FAILURE (Status))
667 /* Point to next subtable */
669 Offset += SubtableLength;
670 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Subtable, SubtableLength);
675 /*******************************************************************************
677 * FUNCTION: AcpiDmDumpMadt
679 * PARAMETERS: Table - A MADT table
683 * DESCRIPTION: Format the contents of a MADT. This table type consists
684 * of an open-ended number of subtables.
686 ******************************************************************************/
690 ACPI_TABLE_HEADER *Table)
693 ACPI_SUBTABLE_HEADER *Subtable;
694 UINT32 Length = Table->Length;
695 UINT32 Offset = sizeof (ACPI_TABLE_MADT);
696 ACPI_DMTABLE_INFO *InfoTable;
701 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
702 if (ACPI_FAILURE (Status))
709 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
710 while (Offset < Table->Length)
712 /* Common subtable header */
715 Status = AcpiDmDumpTable (Length, Offset, Subtable,
716 Subtable->Length, AcpiDmTableInfoMadtHdr);
717 if (ACPI_FAILURE (Status))
722 switch (Subtable->Type)
724 case ACPI_MADT_TYPE_LOCAL_APIC:
726 InfoTable = AcpiDmTableInfoMadt0;
729 case ACPI_MADT_TYPE_IO_APIC:
731 InfoTable = AcpiDmTableInfoMadt1;
734 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
736 InfoTable = AcpiDmTableInfoMadt2;
739 case ACPI_MADT_TYPE_NMI_SOURCE:
741 InfoTable = AcpiDmTableInfoMadt3;
744 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
746 InfoTable = AcpiDmTableInfoMadt4;
749 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
751 InfoTable = AcpiDmTableInfoMadt5;
754 case ACPI_MADT_TYPE_IO_SAPIC:
756 InfoTable = AcpiDmTableInfoMadt6;
759 case ACPI_MADT_TYPE_LOCAL_SAPIC:
761 InfoTable = AcpiDmTableInfoMadt7;
764 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
766 InfoTable = AcpiDmTableInfoMadt8;
769 case ACPI_MADT_TYPE_LOCAL_X2APIC:
771 InfoTable = AcpiDmTableInfoMadt9;
774 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
776 InfoTable = AcpiDmTableInfoMadt10;
779 case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
781 InfoTable = AcpiDmTableInfoMadt11;
784 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
786 InfoTable = AcpiDmTableInfoMadt12;
789 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
791 InfoTable = AcpiDmTableInfoMadt13;
794 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
796 InfoTable = AcpiDmTableInfoMadt14;
799 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
801 InfoTable = AcpiDmTableInfoMadt15;
806 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n",
809 /* Attempt to continue */
811 if (!Subtable->Length)
813 AcpiOsPrintf ("Invalid zero length subtable\n");
820 Status = AcpiDmDumpTable (Length, Offset, Subtable,
821 Subtable->Length, InfoTable);
822 if (ACPI_FAILURE (Status))
828 /* Point to next subtable */
830 Offset += Subtable->Length;
831 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable,
837 /*******************************************************************************
839 * FUNCTION: AcpiDmDumpMcfg
841 * PARAMETERS: Table - A MCFG Table
845 * DESCRIPTION: Format the contents of a MCFG table
847 ******************************************************************************/
851 ACPI_TABLE_HEADER *Table)
854 UINT32 Offset = sizeof (ACPI_TABLE_MCFG);
855 ACPI_MCFG_ALLOCATION *Subtable;
860 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
861 if (ACPI_FAILURE (Status))
868 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
869 while (Offset < Table->Length)
871 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
873 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
874 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
879 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
880 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
881 if (ACPI_FAILURE (Status))
886 /* Point to next subtable (each subtable is of fixed length) */
888 Offset += sizeof (ACPI_MCFG_ALLOCATION);
889 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Subtable,
890 sizeof (ACPI_MCFG_ALLOCATION));
895 /*******************************************************************************
897 * FUNCTION: AcpiDmDumpMpst
899 * PARAMETERS: Table - A MPST Table
903 * DESCRIPTION: Format the contents of a MPST table
905 ******************************************************************************/
909 ACPI_TABLE_HEADER *Table)
912 UINT32 Offset = sizeof (ACPI_TABLE_MPST);
913 ACPI_MPST_POWER_NODE *Subtable0;
914 ACPI_MPST_POWER_STATE *Subtable0A;
915 ACPI_MPST_COMPONENT *Subtable0B;
916 ACPI_MPST_DATA_HDR *Subtable1;
917 ACPI_MPST_POWER_DATA *Subtable2;
918 UINT16 SubtableCount;
919 UINT32 PowerStateCount;
920 UINT32 ComponentCount;
925 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
926 if (ACPI_FAILURE (Status))
931 /* Subtable: Memory Power Node(s) */
933 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
934 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
936 while ((Offset < Table->Length) && SubtableCount)
939 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0,
940 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
941 if (ACPI_FAILURE (Status))
946 /* Extract the sub-subtable counts */
948 PowerStateCount = Subtable0->NumPowerStates;
949 ComponentCount = Subtable0->NumPhysicalComponents;
950 Offset += sizeof (ACPI_MPST_POWER_NODE);
952 /* Sub-subtables - Memory Power State Structure(s) */
954 Subtable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, Subtable0,
955 sizeof (ACPI_MPST_POWER_NODE));
957 while (PowerStateCount)
960 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0A,
961 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
962 if (ACPI_FAILURE (Status))
969 Offset += sizeof (ACPI_MPST_POWER_STATE);
972 /* Sub-subtables - Physical Component ID Structure(s) */
974 Subtable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, Subtable0A);
981 while (ComponentCount)
983 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0B,
984 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
985 if (ACPI_FAILURE (Status))
992 Offset += sizeof (ACPI_MPST_COMPONENT);
995 /* Point to next Memory Power Node subtable */
998 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Subtable0,
999 sizeof (ACPI_MPST_POWER_NODE) +
1000 (sizeof (ACPI_MPST_POWER_STATE) * Subtable0->NumPowerStates) +
1001 (sizeof (ACPI_MPST_COMPONENT) * Subtable0->NumPhysicalComponents));
1004 /* Subtable: Count of Memory Power State Characteristic structures */
1006 AcpiOsPrintf ("\n");
1007 Subtable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable0);
1008 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable1,
1009 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
1010 if (ACPI_FAILURE (Status))
1015 SubtableCount = Subtable1->CharacteristicsCount;
1016 Offset += sizeof (ACPI_MPST_DATA_HDR);
1018 /* Subtable: Memory Power State Characteristics structure(s) */
1020 Subtable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, Subtable1,
1021 sizeof (ACPI_MPST_DATA_HDR));
1023 while ((Offset < Table->Length) && SubtableCount)
1025 AcpiOsPrintf ("\n");
1026 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable2,
1027 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
1028 if (ACPI_FAILURE (Status))
1035 Offset += sizeof (ACPI_MPST_POWER_DATA);
1040 /*******************************************************************************
1042 * FUNCTION: AcpiDmDumpMsct
1044 * PARAMETERS: Table - A MSCT table
1048 * DESCRIPTION: Format the contents of a MSCT
1050 ******************************************************************************/
1054 ACPI_TABLE_HEADER *Table)
1057 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
1058 ACPI_MSCT_PROXIMITY *Subtable;
1063 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1064 if (ACPI_FAILURE (Status))
1071 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1072 while (Offset < Table->Length)
1074 /* Common subtable header */
1076 AcpiOsPrintf ("\n");
1077 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1078 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1079 if (ACPI_FAILURE (Status))
1084 /* Point to next subtable */
1086 Offset += sizeof (ACPI_MSCT_PROXIMITY);
1087 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Subtable,
1088 sizeof (ACPI_MSCT_PROXIMITY));
1093 /*******************************************************************************
1095 * FUNCTION: AcpiDmDumpMtmr
1097 * PARAMETERS: Table - A MTMR table
1101 * DESCRIPTION: Format the contents of a MTMR
1103 ******************************************************************************/
1107 ACPI_TABLE_HEADER *Table)
1110 UINT32 Offset = sizeof (ACPI_TABLE_MTMR);
1111 ACPI_MTMR_ENTRY *Subtable;
1116 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr);
1117 if (ACPI_FAILURE (Status))
1124 Subtable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset);
1125 while (Offset < Table->Length)
1127 /* Common subtable header */
1129 AcpiOsPrintf ("\n");
1130 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1131 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0);
1132 if (ACPI_FAILURE (Status))
1137 /* Point to next subtable */
1139 Offset += sizeof (ACPI_MTMR_ENTRY);
1140 Subtable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Subtable,
1141 sizeof (ACPI_MTMR_ENTRY));
1146 /*******************************************************************************
1148 * FUNCTION: AcpiDmDumpNfit
1150 * PARAMETERS: Table - A NFIT table
1154 * DESCRIPTION: Format the contents of an NFIT.
1156 ******************************************************************************/
1160 ACPI_TABLE_HEADER *Table)
1163 UINT32 Offset = sizeof (ACPI_TABLE_NFIT);
1164 UINT32 FieldOffset = 0;
1166 ACPI_NFIT_HEADER *Subtable;
1167 ACPI_DMTABLE_INFO *InfoTable;
1168 ACPI_NFIT_INTERLEAVE *Interleave = NULL;
1169 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL;
1170 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
1176 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit);
1177 if (ACPI_FAILURE (Status))
1184 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset);
1185 while (Offset < Table->Length)
1187 /* NFIT subtable header */
1189 AcpiOsPrintf ("\n");
1190 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1191 Subtable->Length, AcpiDmTableInfoNfitHdr);
1192 if (ACPI_FAILURE (Status))
1197 switch (Subtable->Type)
1199 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
1201 InfoTable = AcpiDmTableInfoNfit0;
1204 case ACPI_NFIT_TYPE_MEMORY_MAP:
1206 InfoTable = AcpiDmTableInfoNfit1;
1209 case ACPI_NFIT_TYPE_INTERLEAVE:
1211 /* Has a variable number of 32-bit values at the end */
1213 InfoTable = AcpiDmTableInfoNfit2;
1214 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable);
1215 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE);
1218 case ACPI_NFIT_TYPE_SMBIOS:
1220 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, Subtable);
1221 InfoTable = AcpiDmTableInfoNfit3;
1224 case ACPI_NFIT_TYPE_CONTROL_REGION:
1226 InfoTable = AcpiDmTableInfoNfit4;
1229 case ACPI_NFIT_TYPE_DATA_REGION:
1231 InfoTable = AcpiDmTableInfoNfit5;
1234 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1236 /* Has a variable number of 64-bit addresses at the end */
1238 InfoTable = AcpiDmTableInfoNfit6;
1239 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable);
1240 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64);
1243 case ACPI_NFIT_TYPE_CAPABILITIES: /* ACPI 6.0A */
1245 InfoTable = AcpiDmTableInfoNfit7;
1249 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n",
1252 /* Attempt to continue */
1254 if (!Subtable->Length)
1256 AcpiOsPrintf ("Invalid zero length subtable\n");
1262 AcpiOsPrintf ("\n");
1263 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1264 Subtable->Length, InfoTable);
1265 if (ACPI_FAILURE (Status))
1270 /* Per-subtable variable-length fields */
1272 switch (Subtable->Type)
1274 case ACPI_NFIT_TYPE_INTERLEAVE:
1276 for (i = 0; i < Interleave->LineCount; i++)
1278 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1279 &Interleave->LineOffset[i],
1280 sizeof (UINT32), AcpiDmTableInfoNfit2a);
1281 if (ACPI_FAILURE (Status))
1286 FieldOffset += sizeof (UINT32);
1290 case ACPI_NFIT_TYPE_SMBIOS:
1292 Length = Subtable->Length -
1293 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8);
1297 Status = AcpiDmDumpTable (Table->Length,
1298 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8),
1300 Length, AcpiDmTableInfoNfit3a);
1301 if (ACPI_FAILURE (Status))
1309 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1311 for (i = 0; i < Hint->HintCount; i++)
1313 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
1314 &Hint->HintAddress[i],
1315 sizeof (UINT64), AcpiDmTableInfoNfit6a);
1316 if (ACPI_FAILURE (Status))
1321 FieldOffset += sizeof (UINT64);
1330 /* Point to next subtable */
1332 Offset += Subtable->Length;
1333 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Subtable, Subtable->Length);
1338 /*******************************************************************************
1340 * FUNCTION: AcpiDmDumpPcct
1342 * PARAMETERS: Table - A PCCT table
1346 * DESCRIPTION: Format the contents of a PCCT. This table type consists
1347 * of an open-ended number of subtables.
1349 ******************************************************************************/
1353 ACPI_TABLE_HEADER *Table)
1356 ACPI_PCCT_SUBSPACE *Subtable;
1357 ACPI_DMTABLE_INFO *InfoTable;
1358 UINT32 Length = Table->Length;
1359 UINT32 Offset = sizeof (ACPI_TABLE_PCCT);
1364 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
1365 if (ACPI_FAILURE (Status))
1372 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
1373 while (Offset < Table->Length)
1375 /* Common subtable header */
1377 AcpiOsPrintf ("\n");
1378 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1379 Subtable->Header.Length, AcpiDmTableInfoPcctHdr);
1380 if (ACPI_FAILURE (Status))
1385 switch (Subtable->Header.Type)
1387 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
1389 InfoTable = AcpiDmTableInfoPcct0;
1392 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
1394 InfoTable = AcpiDmTableInfoPcct1;
1397 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
1399 InfoTable = AcpiDmTableInfoPcct2;
1402 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE:
1404 InfoTable = AcpiDmTableInfoPcct3;
1407 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE:
1409 InfoTable = AcpiDmTableInfoPcct4;
1415 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n",
1416 Subtable->Header.Type);
1420 AcpiOsPrintf ("\n");
1421 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1422 Subtable->Header.Length, InfoTable);
1423 if (ACPI_FAILURE (Status))
1428 /* Point to next subtable */
1430 Offset += Subtable->Header.Length;
1431 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Subtable,
1432 Subtable->Header.Length);
1437 /*******************************************************************************
1439 * FUNCTION: AcpiDmDumpPdtt
1441 * PARAMETERS: Table - A PDTT table
1445 * DESCRIPTION: Format the contents of a Pdtt. This is a variable-length
1446 * table that contains an open-ended number of IDs
1447 * at the end of the table.
1449 ******************************************************************************/
1453 ACPI_TABLE_HEADER *Table)
1456 ACPI_PDTT_CHANNEL *Subtable;
1457 UINT32 Length = Table->Length;
1458 UINT32 Offset = sizeof (ACPI_TABLE_PDTT);
1463 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPdtt);
1464 if (ACPI_FAILURE (Status))
1469 /* Subtables. Currently there is only one type, but can be multiples */
1471 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Table, Offset);
1472 while (Offset < Table->Length)
1474 AcpiOsPrintf ("\n");
1475 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1476 sizeof (ACPI_PDTT_CHANNEL), AcpiDmTableInfoPdtt0);
1477 if (ACPI_FAILURE (Status))
1482 /* Point to next subtable */
1484 Offset += sizeof (ACPI_PDTT_CHANNEL);
1485 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Subtable,
1486 sizeof (ACPI_PDTT_CHANNEL));
1491 /*******************************************************************************
1493 * FUNCTION: AcpiDmDumpPmtt
1495 * PARAMETERS: Table - A PMTT table
1499 * DESCRIPTION: Format the contents of a PMTT. This table type consists
1500 * of an open-ended number of subtables.
1502 ******************************************************************************/
1506 ACPI_TABLE_HEADER *Table)
1509 ACPI_PMTT_HEADER *Subtable;
1510 ACPI_PMTT_HEADER *MemSubtable;
1511 ACPI_PMTT_HEADER *DimmSubtable;
1512 ACPI_PMTT_DOMAIN *DomainArray;
1513 UINT32 Length = Table->Length;
1514 UINT32 Offset = sizeof (ACPI_TABLE_PMTT);
1517 UINT32 DomainOffset;
1523 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
1524 if (ACPI_FAILURE (Status))
1531 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
1532 while (Offset < Table->Length)
1534 /* Common subtable header */
1536 AcpiOsPrintf ("\n");
1537 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1538 Subtable->Length, AcpiDmTableInfoPmttHdr);
1539 if (ACPI_FAILURE (Status))
1544 /* Only Socket subtables are expected at this level */
1546 if (Subtable->Type != ACPI_PMTT_TYPE_SOCKET)
1549 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
1554 /* Dump the fixed-length portion of the subtable */
1556 Status = AcpiDmDumpTable (Length, Offset, Subtable,
1557 Subtable->Length, AcpiDmTableInfoPmtt0);
1558 if (ACPI_FAILURE (Status))
1563 /* Walk the memory controller subtables */
1565 MemOffset = sizeof (ACPI_PMTT_SOCKET);
1566 MemSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Subtable,
1567 sizeof (ACPI_PMTT_SOCKET));
1569 while (((Offset + MemOffset) < Table->Length) &&
1570 (MemOffset < Subtable->Length))
1572 /* Common subtable header */
1574 AcpiOsPrintf ("\n");
1575 Status = AcpiDmDumpTable (Length,
1576 Offset + MemOffset, MemSubtable,
1577 MemSubtable->Length, AcpiDmTableInfoPmttHdr);
1578 if (ACPI_FAILURE (Status))
1583 /* Only memory controller subtables are expected at this level */
1585 if (MemSubtable->Type != ACPI_PMTT_TYPE_CONTROLLER)
1588 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
1593 /* Dump the fixed-length portion of the controller subtable */
1595 Status = AcpiDmDumpTable (Length,
1596 Offset + MemOffset, MemSubtable,
1597 MemSubtable->Length, AcpiDmTableInfoPmtt1);
1598 if (ACPI_FAILURE (Status))
1603 /* Walk the variable count of proximity domains */
1605 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubtable)->DomainCount;
1606 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER);
1607 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubtable,
1608 sizeof (ACPI_PMTT_CONTROLLER));
1610 while (((Offset + MemOffset + DomainOffset) < Table->Length) &&
1611 ((MemOffset + DomainOffset) < Subtable->Length) &&
1614 Status = AcpiDmDumpTable (Length,
1615 Offset + MemOffset + DomainOffset, DomainArray,
1616 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
1617 if (ACPI_FAILURE (Status))
1622 DomainOffset += sizeof (ACPI_PMTT_DOMAIN);
1630 "\n**** DomainCount exceeds subtable length\n\n");
1633 /* Walk the physical component (DIMM) subtables */
1635 DimmOffset = DomainOffset;
1636 DimmSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubtable,
1639 while (((Offset + MemOffset + DimmOffset) < Table->Length) &&
1640 (DimmOffset < MemSubtable->Length))
1642 /* Common subtable header */
1644 AcpiOsPrintf ("\n");
1645 Status = AcpiDmDumpTable (Length,
1646 Offset + MemOffset + DimmOffset, DimmSubtable,
1647 DimmSubtable->Length, AcpiDmTableInfoPmttHdr);
1648 if (ACPI_FAILURE (Status))
1653 /* Only DIMM subtables are expected at this level */
1655 if (DimmSubtable->Type != ACPI_PMTT_TYPE_DIMM)
1658 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
1659 DimmSubtable->Type);
1663 /* Dump the fixed-length DIMM subtable */
1665 Status = AcpiDmDumpTable (Length,
1666 Offset + MemOffset + DimmOffset, DimmSubtable,
1667 DimmSubtable->Length, AcpiDmTableInfoPmtt2);
1668 if (ACPI_FAILURE (Status))
1673 /* Point to next DIMM subtable */
1675 DimmOffset += DimmSubtable->Length;
1676 DimmSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
1677 DimmSubtable, DimmSubtable->Length);
1680 /* Point to next Controller subtable */
1682 MemOffset += MemSubtable->Length;
1683 MemSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
1684 MemSubtable, MemSubtable->Length);
1687 /* Point to next Socket subtable */
1689 Offset += Subtable->Length;
1690 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
1691 Subtable, Subtable->Length);
1696 /*******************************************************************************
1698 * FUNCTION: AcpiDmDumpPptt
1700 * PARAMETERS: Table - A PMTT table
1704 * DESCRIPTION: Format the contents of a PPTT. This table type consists
1705 * of an open-ended number of subtables.
1707 ******************************************************************************/
1711 ACPI_TABLE_HEADER *Table)
1714 ACPI_SUBTABLE_HEADER *Subtable;
1715 ACPI_PPTT_PROCESSOR *PpttProcessor;
1717 UINT8 SubtableOffset;
1718 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
1719 ACPI_DMTABLE_INFO *InfoTable;
1723 /* There is no main table (other than the standard ACPI header) */
1727 Offset = sizeof (ACPI_TABLE_HEADER);
1728 while (Offset < Table->Length)
1730 AcpiOsPrintf ("\n");
1732 /* Common subtable header */
1734 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1735 if (Subtable->Length < sizeof (ACPI_SUBTABLE_HEADER))
1737 AcpiOsPrintf ("Invalid subtable length\n");
1740 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1741 Subtable->Length, AcpiDmTableInfoPpttHdr);
1742 if (ACPI_FAILURE (Status))
1747 switch (Subtable->Type)
1749 case ACPI_PPTT_TYPE_PROCESSOR:
1751 InfoTable = AcpiDmTableInfoPptt0;
1752 Length = sizeof (ACPI_PPTT_PROCESSOR);
1755 case ACPI_PPTT_TYPE_CACHE:
1757 InfoTable = AcpiDmTableInfoPptt1;
1758 Length = sizeof (ACPI_PPTT_CACHE);
1761 case ACPI_PPTT_TYPE_ID:
1763 InfoTable = AcpiDmTableInfoPptt2;
1764 Length = sizeof (ACPI_PPTT_ID);
1769 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n",
1772 /* Attempt to continue */
1777 if (Subtable->Length < Length)
1779 AcpiOsPrintf ("Invalid subtable length\n");
1782 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1783 Subtable->Length, InfoTable);
1784 if (ACPI_FAILURE (Status))
1788 SubtableOffset = Length;
1790 switch (Subtable->Type)
1792 case ACPI_PPTT_TYPE_PROCESSOR:
1794 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, Subtable);
1796 /* Dump SMBIOS handles */
1798 if ((UINT8)(Subtable->Length - SubtableOffset) <
1799 (UINT8)(PpttProcessor->NumberOfPrivResources * 4))
1801 AcpiOsPrintf ("Invalid private resource number\n");
1804 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++)
1806 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
1807 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset),
1808 4, AcpiDmTableInfoPptt0a);
1809 SubtableOffset += 4;
1819 /* Point to next subtable */
1821 Offset += Subtable->Length;
1826 /*******************************************************************************
1828 * FUNCTION: AcpiDmDumpS3pt
1830 * PARAMETERS: Table - A S3PT table
1832 * RETURN: Length of the table
1834 * DESCRIPTION: Format the contents of a S3PT
1836 ******************************************************************************/
1840 ACPI_TABLE_HEADER *Tables)
1843 UINT32 Offset = sizeof (ACPI_TABLE_S3PT);
1844 ACPI_FPDT_HEADER *Subtable;
1845 ACPI_DMTABLE_INFO *InfoTable;
1846 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
1851 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
1852 if (ACPI_FAILURE (Status))
1857 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset);
1858 while (Offset < S3ptTable->Length)
1860 /* Common subtable header */
1862 AcpiOsPrintf ("\n");
1863 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
1864 Subtable->Length, AcpiDmTableInfoS3ptHdr);
1865 if (ACPI_FAILURE (Status))
1870 switch (Subtable->Type)
1872 case ACPI_S3PT_TYPE_RESUME:
1874 InfoTable = AcpiDmTableInfoS3pt0;
1877 case ACPI_S3PT_TYPE_SUSPEND:
1879 InfoTable = AcpiDmTableInfoS3pt1;
1884 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
1887 /* Attempt to continue */
1889 if (!Subtable->Length)
1891 AcpiOsPrintf ("Invalid zero length subtable\n");
1897 AcpiOsPrintf ("\n");
1898 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable,
1899 Subtable->Length, InfoTable);
1900 if (ACPI_FAILURE (Status))
1906 /* Point to next subtable */
1908 Offset += Subtable->Length;
1909 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, Subtable->Length);
1912 return (S3ptTable->Length);
1916 /*******************************************************************************
1918 * FUNCTION: AcpiDmDumpSdev
1920 * PARAMETERS: Table - A SDEV table
1924 * DESCRIPTION: Format the contents of a SDEV. This is a variable-length
1925 * table that contains variable strings and vendor data.
1927 ******************************************************************************/
1931 ACPI_TABLE_HEADER *Table)
1934 ACPI_SDEV_HEADER *Subtable;
1935 ACPI_SDEV_PCIE *Pcie;
1936 ACPI_SDEV_NAMESPACE *Namesp;
1937 ACPI_DMTABLE_INFO *InfoTable;
1938 UINT32 Length = Table->Length;
1939 UINT32 Offset = sizeof (ACPI_TABLE_SDEV);
1942 UINT16 VendorDataOffset;
1943 UINT16 VendorDataLength;
1948 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSdev);
1949 if (ACPI_FAILURE (Status))
1956 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Table, Offset);
1957 while (Offset < Table->Length)
1959 /* Common subtable header */
1961 AcpiOsPrintf ("\n");
1962 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1963 Subtable->Length, AcpiDmTableInfoSdevHdr);
1964 if (ACPI_FAILURE (Status))
1969 switch (Subtable->Type)
1971 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
1973 InfoTable = AcpiDmTableInfoSdev0;
1976 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
1978 InfoTable = AcpiDmTableInfoSdev1;
1985 AcpiOsPrintf ("\n");
1986 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
1987 Subtable->Length, InfoTable);
1988 if (ACPI_FAILURE (Status))
1993 switch (Subtable->Type)
1995 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
1997 /* Dump the PCIe device ID(s) */
1999 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable);
2000 PathOffset = Namesp->DeviceIdOffset;
2001 PathLength = Namesp->DeviceIdLength;
2005 Status = AcpiDmDumpTable (Table->Length, 0,
2006 ACPI_ADD_PTR (UINT8, Namesp, PathOffset),
2007 PathLength, AcpiDmTableInfoSdev0a);
2008 if (ACPI_FAILURE (Status))
2014 /* Dump the vendor-specific data */
2017 Namesp->VendorDataLength;
2019 Namesp->DeviceIdOffset + Namesp->DeviceIdLength;
2021 if (VendorDataLength)
2023 Status = AcpiDmDumpTable (Table->Length, 0,
2024 ACPI_ADD_PTR (UINT8, Namesp, VendorDataOffset),
2025 VendorDataLength, AcpiDmTableInfoSdev1b);
2026 if (ACPI_FAILURE (Status))
2033 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE:
2035 /* PCI path substructures */
2037 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable);
2038 PathOffset = Pcie->PathOffset;
2039 PathLength = Pcie->PathLength;
2043 Status = AcpiDmDumpTable (Table->Length,
2044 PathOffset + Offset,
2045 ACPI_ADD_PTR (UINT8, Pcie, PathOffset),
2046 sizeof (ACPI_SDEV_PCIE_PATH), AcpiDmTableInfoSdev1a);
2047 if (ACPI_FAILURE (Status))
2052 PathOffset += sizeof (ACPI_SDEV_PCIE_PATH);
2053 PathLength -= sizeof (ACPI_SDEV_PCIE_PATH);
2058 VendorDataLength = Pcie->VendorDataLength;
2059 VendorDataOffset = Pcie->PathOffset + Pcie->PathLength;
2061 if (VendorDataLength)
2063 Status = AcpiDmDumpTable (Table->Length, 0,
2064 ACPI_ADD_PTR (UINT8, Pcie, VendorDataOffset),
2065 VendorDataLength, AcpiDmTableInfoSdev1b);
2074 /* Point to next subtable */
2076 Offset += Subtable->Length;
2077 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Subtable,