1 /******************************************************************************
3 * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code
5 *****************************************************************************/
7 /******************************************************************************
11 * Some or all of this work - Copyright (c) 1999 - 2017, 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 *****************************************************************************/
152 #include <contrib/dev/acpica/include/acpi.h>
153 #include <contrib/dev/acpica/include/accommon.h>
154 #include <contrib/dev/acpica/include/acdisasm.h>
155 #include <contrib/dev/acpica/include/actables.h>
157 /* This module used for application-level code only */
159 #define _COMPONENT ACPI_CA_DISASSEMBLER
160 ACPI_MODULE_NAME ("dmtbdump")
163 /* Local prototypes */
166 AcpiDmValidateFadtLength (
171 /*******************************************************************************
173 * FUNCTION: AcpiDmDumpBuffer
175 * PARAMETERS: Table - ACPI Table or subtable
176 * BufferOffset - Offset of buffer from Table above
177 * Length - Length of the buffer
178 * AbsoluteOffset - Offset of buffer in the main ACPI table
179 * Header - Name of the buffer field (printed on the
184 * DESCRIPTION: Format the contents of an arbitrary length data buffer (in the
185 * disassembler output format.)
187 ******************************************************************************/
194 UINT32 AbsoluteOffset,
206 Buffer = ACPI_CAST_PTR (UINT8, Table) + BufferOffset;
213 /* Insert a backslash - line continuation character */
217 AcpiOsPrintf ("\\\n ");
221 AcpiOsPrintf ("%.02X ", *Buffer);
231 /*******************************************************************************
233 * FUNCTION: AcpiDmDumpUnicode
235 * PARAMETERS: Table - ACPI Table or subtable
236 * BufferOffset - Offset of buffer from Table above
237 * ByteLength - Length of the buffer
241 * DESCRIPTION: Validate and dump the contents of a buffer that contains
242 * unicode data. The output is a standard ASCII string. If it
243 * appears that the data is not unicode, the buffer is dumped
246 ******************************************************************************/
259 Buffer = ((UINT8 *) Table) + BufferOffset;
260 Length = ByteLength - 2; /* Last two bytes are the null terminator */
262 /* Ensure all low bytes are entirely printable ASCII */
264 for (i = 0; i < Length; i += 2)
266 if (!isprint (Buffer[i]))
272 /* Ensure all high bytes are zero */
274 for (i = 1; i < Length; i += 2)
282 /* Dump the buffer as a normal string */
285 for (i = 0; i < Length; i += 2)
287 AcpiOsPrintf ("%c", Buffer[i]);
290 AcpiOsPrintf ("\"\n");
294 AcpiDmDumpBuffer (Table, BufferOffset, ByteLength,
300 /*******************************************************************************
302 * FUNCTION: AcpiDmDumpRsdp
304 * PARAMETERS: Table - A RSDP
306 * RETURN: Length of the table (there is not always a length field,
307 * use revision or length if available (ACPI 2.0+))
309 * DESCRIPTION: Format the contents of a RSDP
311 ******************************************************************************/
315 ACPI_TABLE_HEADER *Table)
317 ACPI_TABLE_RSDP *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
318 UINT32 Length = sizeof (ACPI_RSDP_COMMON);
323 /* Dump the common ACPI 1.0 portion */
325 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
326 if (ACPI_FAILURE (Status))
331 /* Validate the first checksum */
333 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON),
335 if (Checksum != Rsdp->Checksum)
337 AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n",
341 /* The RSDP for ACPI 2.0+ contains more data and has a Length field */
343 if (Rsdp->Revision > 0)
345 Length = Rsdp->Length;
346 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
347 if (ACPI_FAILURE (Status))
352 /* Validate the extended checksum over entire RSDP */
354 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP),
355 Rsdp->ExtendedChecksum);
356 if (Checksum != Rsdp->ExtendedChecksum)
359 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n",
368 /*******************************************************************************
370 * FUNCTION: AcpiDmDumpRsdt
372 * PARAMETERS: Table - A RSDT
376 * DESCRIPTION: Format the contents of a RSDT
378 ******************************************************************************/
382 ACPI_TABLE_HEADER *Table)
390 /* Point to start of table pointer array */
392 Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry;
393 Offset = sizeof (ACPI_TABLE_HEADER);
395 /* RSDT uses 32-bit pointers */
397 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
399 for (i = 0; i < Entries; i++)
401 AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i);
402 AcpiOsPrintf ("%8.8X\n", Array[i]);
403 Offset += sizeof (UINT32);
408 /*******************************************************************************
410 * FUNCTION: AcpiDmDumpXsdt
412 * PARAMETERS: Table - A XSDT
416 * DESCRIPTION: Format the contents of a XSDT
418 ******************************************************************************/
422 ACPI_TABLE_HEADER *Table)
430 /* Point to start of table pointer array */
432 Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry;
433 Offset = sizeof (ACPI_TABLE_HEADER);
435 /* XSDT uses 64-bit pointers */
437 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
439 for (i = 0; i < Entries; i++)
441 AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i);
442 AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i]));
443 Offset += sizeof (UINT64);
448 /*******************************************************************************
450 * FUNCTION: AcpiDmDumpFadt
452 * PARAMETERS: Table - A FADT
456 * DESCRIPTION: Format the contents of a FADT
458 * NOTE: We cannot depend on the FADT version to indicate the actual
459 * contents of the FADT because of BIOS bugs. The table length
460 * is the only reliable indicator.
462 ******************************************************************************/
466 ACPI_TABLE_HEADER *Table)
471 /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */
473 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
474 AcpiDmTableInfoFadt1);
475 if (ACPI_FAILURE (Status))
480 /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */
482 if ((Table->Length > ACPI_FADT_V1_SIZE) &&
483 (Table->Length <= ACPI_FADT_V2_SIZE))
485 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
486 AcpiDmTableInfoFadt2);
487 if (ACPI_FAILURE (Status))
493 /* Check for FADT revision 3/4 fields and up (ACPI 2.0+ extended data) */
495 else if (Table->Length > ACPI_FADT_V2_SIZE)
497 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
498 AcpiDmTableInfoFadt3);
499 if (ACPI_FAILURE (Status))
504 /* Check for FADT revision 5 fields and up (ACPI 5.0+) */
506 if (Table->Length > ACPI_FADT_V3_SIZE)
508 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
509 AcpiDmTableInfoFadt5);
510 if (ACPI_FAILURE (Status))
516 /* Check for FADT revision 6 fields and up (ACPI 6.0+) */
518 if (Table->Length > ACPI_FADT_V3_SIZE)
520 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
521 AcpiDmTableInfoFadt6);
522 if (ACPI_FAILURE (Status))
529 /* Validate various fields in the FADT, including length */
531 AcpiTbCreateLocalFadt (Table, Table->Length);
533 /* Validate FADT length against the revision */
535 AcpiDmValidateFadtLength (Table->Revision, Table->Length);
539 /*******************************************************************************
541 * FUNCTION: AcpiDmValidateFadtLength
543 * PARAMETERS: Revision - FADT revision (Header->Revision)
544 * Length - FADT length (Header->Length
548 * DESCRIPTION: Check the FADT revision against the expected table length for
549 * that revision. Issue a warning if the length is not what was
550 * expected. This seems to be such a common BIOS bug that the
551 * FADT revision has been rendered virtually meaningless.
553 ******************************************************************************/
556 AcpiDmValidateFadtLength (
560 UINT32 ExpectedLength;
567 AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n");
572 ExpectedLength = ACPI_FADT_V1_SIZE;
577 ExpectedLength = ACPI_FADT_V2_SIZE;
583 ExpectedLength = ACPI_FADT_V3_SIZE;
588 ExpectedLength = ACPI_FADT_V5_SIZE;
596 if (Length == ExpectedLength)
602 "\n// ACPI Warning: FADT revision %X does not match length: "
603 "found %X expected %X\n",
604 Revision, Length, ExpectedLength);
608 /*******************************************************************************
610 * FUNCTION: AcpiDmDumpAsf
612 * PARAMETERS: Table - A ASF table
616 * DESCRIPTION: Format the contents of a ASF table
618 ******************************************************************************/
622 ACPI_TABLE_HEADER *Table)
625 UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
626 ACPI_ASF_INFO *SubTable;
627 ACPI_DMTABLE_INFO *InfoTable;
628 ACPI_DMTABLE_INFO *DataInfoTable = NULL;
629 UINT8 *DataTable = NULL;
630 UINT32 DataCount = 0;
631 UINT32 DataLength = 0;
632 UINT32 DataOffset = 0;
637 /* No main table, only subtables */
639 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
640 while (Offset < Table->Length)
642 /* Common subtable header */
644 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
645 SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
646 if (ACPI_FAILURE (Status))
651 /* The actual type is the lower 7 bits of Type */
653 Type = (UINT8) (SubTable->Header.Type & 0x7F);
657 case ACPI_ASF_TYPE_INFO:
659 InfoTable = AcpiDmTableInfoAsf0;
662 case ACPI_ASF_TYPE_ALERT:
664 InfoTable = AcpiDmTableInfoAsf1;
665 DataInfoTable = AcpiDmTableInfoAsf1a;
666 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT));
667 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts;
668 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength;
669 DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
672 case ACPI_ASF_TYPE_CONTROL:
674 InfoTable = AcpiDmTableInfoAsf2;
675 DataInfoTable = AcpiDmTableInfoAsf2a;
676 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE));
677 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls;
678 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength;
679 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
682 case ACPI_ASF_TYPE_BOOT:
684 InfoTable = AcpiDmTableInfoAsf3;
687 case ACPI_ASF_TYPE_ADDRESS:
689 InfoTable = AcpiDmTableInfoAsf4;
690 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS));
691 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices;
692 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
697 AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n",
698 SubTable->Header.Type);
702 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
703 SubTable->Header.Length, InfoTable);
704 if (ACPI_FAILURE (Status))
709 /* Dump variable-length extra data */
713 case ACPI_ASF_TYPE_ALERT:
714 case ACPI_ASF_TYPE_CONTROL:
716 for (i = 0; i < DataCount; i++)
719 Status = AcpiDmDumpTable (Table->Length, DataOffset,
720 DataTable, DataLength, DataInfoTable);
721 if (ACPI_FAILURE (Status))
726 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
727 DataOffset += DataLength;
731 case ACPI_ASF_TYPE_ADDRESS:
733 for (i = 0; i < DataLength; i++)
737 AcpiDmLineHeader (DataOffset, 1, "Addresses");
740 AcpiOsPrintf ("%2.2X ", *DataTable);
744 if (DataOffset > Table->Length)
747 "**** ACPI table terminates in the middle of a "
748 "data structure! (ASF! table)\n");
763 /* Point to next subtable */
765 if (!SubTable->Header.Length)
767 AcpiOsPrintf ("Invalid zero subtable header length\n");
771 Offset += SubTable->Header.Length;
772 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable,
773 SubTable->Header.Length);
778 /*******************************************************************************
780 * FUNCTION: AcpiDmDumpCpep
782 * PARAMETERS: Table - A CPEP table
786 * DESCRIPTION: Format the contents of a CPEP. This table type consists
787 * of an open-ended number of subtables.
789 ******************************************************************************/
793 ACPI_TABLE_HEADER *Table)
796 ACPI_CPEP_POLLING *SubTable;
797 UINT32 Length = Table->Length;
798 UINT32 Offset = sizeof (ACPI_TABLE_CPEP);
803 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
804 if (ACPI_FAILURE (Status))
811 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
812 while (Offset < Table->Length)
815 Status = AcpiDmDumpTable (Length, Offset, SubTable,
816 SubTable->Header.Length, AcpiDmTableInfoCpep0);
817 if (ACPI_FAILURE (Status))
822 /* Point to next subtable */
824 Offset += SubTable->Header.Length;
825 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable,
826 SubTable->Header.Length);
831 /*******************************************************************************
833 * FUNCTION: AcpiDmDumpCsrt
835 * PARAMETERS: Table - A CSRT table
839 * DESCRIPTION: Format the contents of a CSRT. This table type consists
840 * of an open-ended number of subtables.
842 ******************************************************************************/
846 ACPI_TABLE_HEADER *Table)
849 ACPI_CSRT_GROUP *SubTable;
850 ACPI_CSRT_SHARED_INFO *SharedInfoTable;
851 ACPI_CSRT_DESCRIPTOR *SubSubTable;
852 UINT32 Length = Table->Length;
853 UINT32 Offset = sizeof (ACPI_TABLE_CSRT);
859 /* The main table only contains the ACPI header, thus already handled */
861 /* Subtables (Resource Groups) */
863 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);
864 while (Offset < Table->Length)
866 /* Resource group subtable */
869 Status = AcpiDmDumpTable (Length, Offset, SubTable,
870 SubTable->Length, AcpiDmTableInfoCsrt0);
871 if (ACPI_FAILURE (Status))
876 /* Shared info subtable (One per resource group) */
878 SubOffset = sizeof (ACPI_CSRT_GROUP);
879 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table,
883 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable,
884 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);
885 if (ACPI_FAILURE (Status))
890 SubOffset += SubTable->SharedInfoLength;
892 /* Sub-Subtables (Resource Descriptors) */
894 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,
897 while ((SubOffset < SubTable->Length) &&
898 ((Offset + SubOffset) < Table->Length))
901 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable,
902 SubSubTable->Length, AcpiDmTableInfoCsrt2);
903 if (ACPI_FAILURE (Status))
908 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR);
910 /* Resource-specific info buffer */
912 InfoLength = SubSubTable->Length - SubSubOffset;
915 Status = AcpiDmDumpTable (Length,
916 Offset + SubOffset + SubSubOffset, Table,
917 InfoLength, AcpiDmTableInfoCsrt2a);
918 if (ACPI_FAILURE (Status))
922 SubSubOffset += InfoLength;
925 /* Point to next sub-subtable */
927 SubOffset += SubSubTable->Length;
928 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable,
929 SubSubTable->Length);
932 /* Point to next subtable */
934 Offset += SubTable->Length;
935 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable,
941 /*******************************************************************************
943 * FUNCTION: AcpiDmDumpDbg2
945 * PARAMETERS: Table - A DBG2 table
949 * DESCRIPTION: Format the contents of a DBG2. This table type consists
950 * of an open-ended number of subtables.
952 ******************************************************************************/
956 ACPI_TABLE_HEADER *Table)
959 ACPI_DBG2_DEVICE *SubTable;
960 UINT32 Length = Table->Length;
961 UINT32 Offset = sizeof (ACPI_TABLE_DBG2);
964 UINT32 AbsoluteOffset;
970 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);
971 if (ACPI_FAILURE (Status))
978 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);
979 while (Offset < Table->Length)
982 Status = AcpiDmDumpTable (Length, Offset, SubTable,
983 SubTable->Length, AcpiDmTableInfoDbg2Device);
984 if (ACPI_FAILURE (Status))
989 /* Dump the BaseAddress array */
991 for (i = 0; i < SubTable->RegisterCount; i++)
993 ArrayOffset = SubTable->BaseAddressOffset +
994 (sizeof (ACPI_GENERIC_ADDRESS) * i);
995 AbsoluteOffset = Offset + ArrayOffset;
996 Array = (UINT8 *) SubTable + ArrayOffset;
998 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
999 SubTable->Length, AcpiDmTableInfoDbg2Addr);
1000 if (ACPI_FAILURE (Status))
1006 /* Dump the AddressSize array */
1008 for (i = 0; i < SubTable->RegisterCount; i++)
1010 ArrayOffset = SubTable->AddressSizeOffset +
1011 (sizeof (UINT32) * i);
1012 AbsoluteOffset = Offset + ArrayOffset;
1013 Array = (UINT8 *) SubTable + ArrayOffset;
1015 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
1016 SubTable->Length, AcpiDmTableInfoDbg2Size);
1017 if (ACPI_FAILURE (Status))
1023 /* Dump the Namestring (required) */
1025 AcpiOsPrintf ("\n");
1026 ArrayOffset = SubTable->NamepathOffset;
1027 AbsoluteOffset = Offset + ArrayOffset;
1028 Array = (UINT8 *) SubTable + ArrayOffset;
1030 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
1031 SubTable->Length, AcpiDmTableInfoDbg2Name);
1032 if (ACPI_FAILURE (Status))
1037 /* Dump the OemData (optional) */
1039 if (SubTable->OemDataOffset)
1041 Status = AcpiDmDumpTable (Length, Offset + SubTable->OemDataOffset,
1042 Table, SubTable->OemDataLength,
1043 AcpiDmTableInfoDbg2OemData);
1044 if (ACPI_FAILURE (Status))
1050 /* Point to next subtable */
1052 Offset += SubTable->Length;
1053 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable,
1059 /*******************************************************************************
1061 * FUNCTION: AcpiDmDumpDmar
1063 * PARAMETERS: Table - A DMAR table
1067 * DESCRIPTION: Format the contents of a DMAR. This table type consists
1068 * of an open-ended number of subtables.
1070 ******************************************************************************/
1074 ACPI_TABLE_HEADER *Table)
1077 ACPI_DMAR_HEADER *SubTable;
1078 UINT32 Length = Table->Length;
1079 UINT32 Offset = sizeof (ACPI_TABLE_DMAR);
1080 ACPI_DMTABLE_INFO *InfoTable;
1081 ACPI_DMAR_DEVICE_SCOPE *ScopeTable;
1089 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
1090 if (ACPI_FAILURE (Status))
1097 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
1098 while (Offset < Table->Length)
1100 /* Common subtable header */
1102 AcpiOsPrintf ("\n");
1103 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1104 SubTable->Length, AcpiDmTableInfoDmarHdr);
1105 if (ACPI_FAILURE (Status))
1110 AcpiOsPrintf ("\n");
1112 switch (SubTable->Type)
1114 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
1116 InfoTable = AcpiDmTableInfoDmar0;
1117 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
1120 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
1122 InfoTable = AcpiDmTableInfoDmar1;
1123 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
1126 case ACPI_DMAR_TYPE_ROOT_ATS:
1128 InfoTable = AcpiDmTableInfoDmar2;
1129 ScopeOffset = sizeof (ACPI_DMAR_ATSR);
1132 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
1134 InfoTable = AcpiDmTableInfoDmar3;
1135 ScopeOffset = sizeof (ACPI_DMAR_RHSA);
1138 case ACPI_DMAR_TYPE_NAMESPACE:
1140 InfoTable = AcpiDmTableInfoDmar4;
1141 ScopeOffset = sizeof (ACPI_DMAR_ANDD);
1146 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n",
1151 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1152 SubTable->Length, InfoTable);
1153 if (ACPI_FAILURE (Status))
1159 * Dump the optional device scope entries
1161 if ((SubTable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
1162 (SubTable->Type == ACPI_DMAR_TYPE_NAMESPACE))
1164 /* These types do not support device scopes */
1169 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
1170 while (ScopeOffset < SubTable->Length)
1172 AcpiOsPrintf ("\n");
1173 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
1174 ScopeTable->Length, AcpiDmTableInfoDmarScope);
1175 if (ACPI_FAILURE (Status))
1179 AcpiOsPrintf ("\n");
1181 /* Dump the PCI Path entries for this device scope */
1183 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
1185 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
1186 sizeof (ACPI_DMAR_DEVICE_SCOPE));
1188 while (PathOffset < ScopeTable->Length)
1190 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2,
1192 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
1194 /* Point to next PCI Path entry */
1198 AcpiOsPrintf ("\n");
1201 /* Point to next device scope entry */
1203 ScopeOffset += ScopeTable->Length;
1204 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
1205 ScopeTable, ScopeTable->Length);
1209 /* Point to next subtable */
1211 Offset += SubTable->Length;
1212 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable,
1218 /*******************************************************************************
1220 * FUNCTION: AcpiDmDumpDrtm
1222 * PARAMETERS: Table - A DRTM table
1226 * DESCRIPTION: Format the contents of a DRTM.
1228 ******************************************************************************/
1232 ACPI_TABLE_HEADER *Table)
1236 ACPI_DRTM_VTABLE_LIST *DrtmVtl;
1237 ACPI_DRTM_RESOURCE_LIST *DrtmRl;
1238 ACPI_DRTM_DPS_ID *DrtmDps;
1244 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
1245 AcpiDmTableInfoDrtm);
1246 if (ACPI_FAILURE (Status))
1251 Offset = sizeof (ACPI_TABLE_DRTM);
1255 /* Dump ValidatedTable length */
1257 DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset);
1258 AcpiOsPrintf ("\n");
1259 Status = AcpiDmDumpTable (Table->Length, Offset,
1260 DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables),
1261 AcpiDmTableInfoDrtm0);
1262 if (ACPI_FAILURE (Status))
1267 Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables);
1269 /* Dump Validated table addresses */
1272 while ((Offset < Table->Length) &&
1273 (DrtmVtl->ValidatedTableCount > Count))
1275 Status = AcpiDmDumpTable (Table->Length, Offset,
1276 ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64),
1277 AcpiDmTableInfoDrtm0a);
1278 if (ACPI_FAILURE (Status))
1283 Offset += sizeof (UINT64);
1287 /* Dump ResourceList length */
1289 DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset);
1290 AcpiOsPrintf ("\n");
1291 Status = AcpiDmDumpTable (Table->Length, Offset,
1292 DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources),
1293 AcpiDmTableInfoDrtm1);
1294 if (ACPI_FAILURE (Status))
1299 Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources);
1301 /* Dump the Resource List */
1304 while ((Offset < Table->Length) &&
1305 (DrtmRl->ResourceCount > Count))
1307 Status = AcpiDmDumpTable (Table->Length, Offset,
1308 ACPI_ADD_PTR (void, Table, Offset),
1309 sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a);
1310 if (ACPI_FAILURE (Status))
1315 Offset += sizeof (ACPI_DRTM_RESOURCE);
1321 DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset);
1322 AcpiOsPrintf ("\n");
1323 (void) AcpiDmDumpTable (Table->Length, Offset,
1324 DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2);
1328 /*******************************************************************************
1330 * FUNCTION: AcpiDmDumpEinj
1332 * PARAMETERS: Table - A EINJ table
1336 * DESCRIPTION: Format the contents of a EINJ. This table type consists
1337 * of an open-ended number of subtables.
1339 ******************************************************************************/
1343 ACPI_TABLE_HEADER *Table)
1346 ACPI_WHEA_HEADER *SubTable;
1347 UINT32 Length = Table->Length;
1348 UINT32 Offset = sizeof (ACPI_TABLE_EINJ);
1353 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
1354 if (ACPI_FAILURE (Status))
1361 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1362 while (Offset < Table->Length)
1364 AcpiOsPrintf ("\n");
1365 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1366 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
1367 if (ACPI_FAILURE (Status))
1372 /* Point to next subtable (each subtable is of fixed length) */
1374 Offset += sizeof (ACPI_WHEA_HEADER);
1375 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
1376 sizeof (ACPI_WHEA_HEADER));
1381 /*******************************************************************************
1383 * FUNCTION: AcpiDmDumpErst
1385 * PARAMETERS: Table - A ERST table
1389 * DESCRIPTION: Format the contents of a ERST. This table type consists
1390 * of an open-ended number of subtables.
1392 ******************************************************************************/
1396 ACPI_TABLE_HEADER *Table)
1399 ACPI_WHEA_HEADER *SubTable;
1400 UINT32 Length = Table->Length;
1401 UINT32 Offset = sizeof (ACPI_TABLE_ERST);
1406 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
1407 if (ACPI_FAILURE (Status))
1414 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1415 while (Offset < Table->Length)
1417 AcpiOsPrintf ("\n");
1418 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1419 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
1420 if (ACPI_FAILURE (Status))
1425 /* Point to next subtable (each subtable is of fixed length) */
1427 Offset += sizeof (ACPI_WHEA_HEADER);
1428 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
1429 sizeof (ACPI_WHEA_HEADER));
1434 /*******************************************************************************
1436 * FUNCTION: AcpiDmDumpFpdt
1438 * PARAMETERS: Table - A FPDT table
1442 * DESCRIPTION: Format the contents of a FPDT. This table type consists
1443 * of an open-ended number of subtables.
1445 ******************************************************************************/
1449 ACPI_TABLE_HEADER *Table)
1452 ACPI_FPDT_HEADER *SubTable;
1453 UINT32 Length = Table->Length;
1454 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
1455 ACPI_DMTABLE_INFO *InfoTable;
1458 /* There is no main table (other than the standard ACPI header) */
1462 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset);
1463 while (Offset < Table->Length)
1465 /* Common subtable header */
1467 AcpiOsPrintf ("\n");
1468 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1469 SubTable->Length, AcpiDmTableInfoFpdtHdr);
1470 if (ACPI_FAILURE (Status))
1475 switch (SubTable->Type)
1477 case ACPI_FPDT_TYPE_BOOT:
1479 InfoTable = AcpiDmTableInfoFpdt0;
1482 case ACPI_FPDT_TYPE_S3PERF:
1484 InfoTable = AcpiDmTableInfoFpdt1;
1489 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n",
1492 /* Attempt to continue */
1494 if (!SubTable->Length)
1496 AcpiOsPrintf ("Invalid zero length subtable\n");
1502 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1503 SubTable->Length, InfoTable);
1504 if (ACPI_FAILURE (Status))
1510 /* Point to next subtable */
1512 Offset += SubTable->Length;
1513 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable,
1519 /*******************************************************************************
1521 * FUNCTION: AcpiDmDumpGtdt
1523 * PARAMETERS: Table - A GTDT table
1527 * DESCRIPTION: Format the contents of a GTDT. This table type consists
1528 * of an open-ended number of subtables.
1530 ******************************************************************************/
1534 ACPI_TABLE_HEADER *Table)
1537 ACPI_GTDT_HEADER *SubTable;
1538 UINT32 Length = Table->Length;
1539 UINT32 Offset = sizeof (ACPI_TABLE_GTDT);
1540 ACPI_DMTABLE_INFO *InfoTable;
1541 UINT32 SubTableLength;
1543 ACPI_GTDT_TIMER_ENTRY *GtxTable;
1548 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt);
1549 if (ACPI_FAILURE (Status))
1556 SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
1557 while (Offset < Table->Length)
1559 /* Common subtable header */
1561 AcpiOsPrintf ("\n");
1562 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1563 SubTable->Length, AcpiDmTableInfoGtdtHdr);
1564 if (ACPI_FAILURE (Status))
1570 switch (SubTable->Type)
1572 case ACPI_GTDT_TYPE_TIMER_BLOCK:
1574 SubTableLength = sizeof (ACPI_GTDT_TIMER_BLOCK);
1575 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
1576 SubTable))->TimerCount;
1578 InfoTable = AcpiDmTableInfoGtdt0;
1581 case ACPI_GTDT_TYPE_WATCHDOG:
1583 SubTableLength = sizeof (ACPI_GTDT_WATCHDOG);
1585 InfoTable = AcpiDmTableInfoGtdt1;
1590 /* Cannot continue on unknown type - no length */
1592 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n",
1597 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1598 SubTable->Length, InfoTable);
1599 if (ACPI_FAILURE (Status))
1604 /* Point to end of current subtable (each subtable above is of fixed length) */
1606 Offset += SubTableLength;
1608 /* If there are any Gt Timer Blocks from above, dump them now */
1612 GtxTable = ACPI_ADD_PTR (
1613 ACPI_GTDT_TIMER_ENTRY, SubTable, SubTableLength);
1614 SubTableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY);
1618 AcpiOsPrintf ("\n");
1619 Status = AcpiDmDumpTable (Length, Offset, GtxTable,
1620 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a);
1621 if (ACPI_FAILURE (Status))
1625 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY);
1631 /* Point to next subtable */
1633 SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, SubTable, SubTableLength);
1638 /*******************************************************************************
1640 * FUNCTION: AcpiDmDumpHest
1642 * PARAMETERS: Table - A HEST table
1646 * DESCRIPTION: Format the contents of a HEST. This table type consists
1647 * of an open-ended number of subtables.
1649 ******************************************************************************/
1653 ACPI_TABLE_HEADER *Table)
1656 ACPI_HEST_HEADER *SubTable;
1657 UINT32 Length = Table->Length;
1658 UINT32 Offset = sizeof (ACPI_TABLE_HEST);
1659 ACPI_DMTABLE_INFO *InfoTable;
1660 UINT32 SubTableLength;
1662 ACPI_HEST_IA_ERROR_BANK *BankTable;
1667 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
1668 if (ACPI_FAILURE (Status))
1675 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
1676 while (Offset < Table->Length)
1679 switch (SubTable->Type)
1681 case ACPI_HEST_TYPE_IA32_CHECK:
1683 InfoTable = AcpiDmTableInfoHest0;
1684 SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
1685 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
1686 SubTable))->NumHardwareBanks;
1689 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1691 InfoTable = AcpiDmTableInfoHest1;
1692 SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED);
1693 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
1694 SubTable))->NumHardwareBanks;
1697 case ACPI_HEST_TYPE_IA32_NMI:
1699 InfoTable = AcpiDmTableInfoHest2;
1700 SubTableLength = sizeof (ACPI_HEST_IA_NMI);
1703 case ACPI_HEST_TYPE_AER_ROOT_PORT:
1705 InfoTable = AcpiDmTableInfoHest6;
1706 SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
1709 case ACPI_HEST_TYPE_AER_ENDPOINT:
1711 InfoTable = AcpiDmTableInfoHest7;
1712 SubTableLength = sizeof (ACPI_HEST_AER);
1715 case ACPI_HEST_TYPE_AER_BRIDGE:
1717 InfoTable = AcpiDmTableInfoHest8;
1718 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
1721 case ACPI_HEST_TYPE_GENERIC_ERROR:
1723 InfoTable = AcpiDmTableInfoHest9;
1724 SubTableLength = sizeof (ACPI_HEST_GENERIC);
1727 case ACPI_HEST_TYPE_GENERIC_ERROR_V2:
1729 InfoTable = AcpiDmTableInfoHest10;
1730 SubTableLength = sizeof (ACPI_HEST_GENERIC_V2);
1733 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK:
1735 InfoTable = AcpiDmTableInfoHest11;
1736 SubTableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK);
1737 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK,
1738 SubTable))->NumHardwareBanks;
1743 /* Cannot continue on unknown type - no length */
1745 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n",
1750 AcpiOsPrintf ("\n");
1751 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1752 SubTableLength, InfoTable);
1753 if (ACPI_FAILURE (Status))
1758 /* Point to end of current subtable (each subtable above is of fixed length) */
1760 Offset += SubTableLength;
1762 /* If there are any (fixed-length) Error Banks from above, dump them now */
1766 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable,
1768 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
1772 AcpiOsPrintf ("\n");
1773 Status = AcpiDmDumpTable (Length, Offset, BankTable,
1774 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
1775 if (ACPI_FAILURE (Status))
1780 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
1786 /* Point to next subtable */
1788 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
1793 /*******************************************************************************
1795 * FUNCTION: AcpiDmDumpHmat
1797 * PARAMETERS: Table - A HMAT table
1801 * DESCRIPTION: Format the contents of a HMAT.
1803 ******************************************************************************/
1807 ACPI_TABLE_HEADER *Table)
1810 ACPI_HMAT_STRUCTURE *HmatStruct;
1811 ACPI_HMAT_LOCALITY *HmatLocality;
1812 ACPI_HMAT_CACHE *HmatCache;
1814 UINT32 SubTableOffset;
1816 ACPI_DMTABLE_INFO *InfoTable;
1822 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat);
1823 if (ACPI_FAILURE (Status))
1827 Offset = sizeof (ACPI_TABLE_HMAT);
1829 while (Offset < Table->Length)
1831 AcpiOsPrintf ("\n");
1834 /* Dump HMAT structure header */
1836 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset);
1837 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE))
1839 AcpiOsPrintf ("Invalid HMAT structure length\n");
1842 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
1843 HmatStruct->Length, AcpiDmTableInfoHmatHdr);
1844 if (ACPI_FAILURE (Status))
1849 switch (HmatStruct->Type)
1851 case ACPI_HMAT_TYPE_ADDRESS_RANGE:
1853 InfoTable = AcpiDmTableInfoHmat0;
1854 Length = sizeof (ACPI_HMAT_ADDRESS_RANGE);
1857 case ACPI_HMAT_TYPE_LOCALITY:
1859 InfoTable = AcpiDmTableInfoHmat1;
1860 Length = sizeof (ACPI_HMAT_LOCALITY);
1863 case ACPI_HMAT_TYPE_CACHE:
1865 InfoTable = AcpiDmTableInfoHmat2;
1866 Length = sizeof (ACPI_HMAT_CACHE);
1871 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n",
1874 /* Attempt to continue */
1879 /* Dump HMAT structure body */
1881 if (HmatStruct->Length < Length)
1883 AcpiOsPrintf ("Invalid HMAT structure length\n");
1886 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
1887 HmatStruct->Length, InfoTable);
1888 if (ACPI_FAILURE (Status))
1893 /* Dump HMAT structure additionals */
1895 switch (HmatStruct->Type)
1897 case ACPI_HMAT_TYPE_LOCALITY:
1899 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct);
1900 SubTableOffset = sizeof (ACPI_HMAT_LOCALITY);
1902 /* Dump initiator proximity domains */
1904 if ((UINT32)(HmatStruct->Length - SubTableOffset) <
1905 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4))
1907 AcpiOsPrintf ("Invalid initiator proximity domain number\n");
1910 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
1912 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
1913 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
1914 4, AcpiDmTableInfoHmat1a);
1915 SubTableOffset += 4;
1918 /* Dump target proximity domains */
1920 if ((UINT32)(HmatStruct->Length - SubTableOffset) <
1921 (UINT32)(HmatLocality->NumberOfTargetPDs * 4))
1923 AcpiOsPrintf ("Invalid target proximity domain number\n");
1926 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++)
1928 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
1929 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
1930 4, AcpiDmTableInfoHmat1b);
1931 SubTableOffset += 4;
1934 /* Dump latency/bandwidth entris */
1936 if ((UINT32)(HmatStruct->Length - SubTableOffset) <
1937 (UINT32)(HmatLocality->NumberOfInitiatorPDs *
1938 HmatLocality->NumberOfTargetPDs * 2))
1940 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n");
1943 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
1945 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++)
1947 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
1948 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
1949 2, AcpiDmTableInfoHmat1c);
1950 SubTableOffset += 2;
1955 case ACPI_HMAT_TYPE_CACHE:
1957 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct);
1958 SubTableOffset = sizeof (ACPI_HMAT_CACHE);
1960 /* Dump SMBIOS handles */
1962 if ((UINT32)(HmatStruct->Length - SubTableOffset) <
1963 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2))
1965 AcpiOsPrintf ("Invalid SMBIOS handle number\n");
1968 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++)
1970 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
1971 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
1972 2, AcpiDmTableInfoHmat2a);
1973 SubTableOffset += 2;
1983 /* Point to next HMAT structure subtable */
1985 Offset += (HmatStruct->Length);
1990 /*******************************************************************************
1992 * FUNCTION: AcpiDmDumpIort
1994 * PARAMETERS: Table - A IORT table
1998 * DESCRIPTION: Format the contents of a IORT
2000 ******************************************************************************/
2004 ACPI_TABLE_HEADER *Table)
2007 ACPI_TABLE_IORT *Iort;
2008 ACPI_IORT_NODE *IortNode;
2009 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL;
2010 ACPI_IORT_SMMU *IortSmmu = NULL;
2014 ACPI_DMTABLE_INFO *InfoTable;
2021 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort);
2022 if (ACPI_FAILURE (Status))
2027 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table);
2028 Offset = sizeof (ACPI_TABLE_IORT);
2030 /* Dump the OptionalPadding (optional) */
2032 if (Iort->NodeOffset > Offset)
2034 Status = AcpiDmDumpTable (Table->Length, Offset, Table,
2035 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad);
2036 if (ACPI_FAILURE (Status))
2042 Offset = Iort->NodeOffset;
2043 while (Offset < Table->Length)
2045 /* Common subtable header */
2047 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset);
2048 AcpiOsPrintf ("\n");
2049 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
2050 Status = AcpiDmDumpTable (Table->Length, Offset,
2051 IortNode, Length, AcpiDmTableInfoIortHdr);
2052 if (ACPI_FAILURE (Status))
2057 NodeOffset = Length;
2059 switch (IortNode->Type)
2061 case ACPI_IORT_NODE_ITS_GROUP:
2063 InfoTable = AcpiDmTableInfoIort0;
2064 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers);
2065 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset);
2068 case ACPI_IORT_NODE_NAMED_COMPONENT:
2070 InfoTable = AcpiDmTableInfoIort1;
2071 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName);
2072 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length);
2073 Length += strlen (String) + 1;
2076 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
2078 InfoTable = AcpiDmTableInfoIort2;
2079 Length = IortNode->Length - NodeOffset;
2082 case ACPI_IORT_NODE_SMMU:
2084 InfoTable = AcpiDmTableInfoIort3;
2085 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts);
2086 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset);
2089 case ACPI_IORT_NODE_SMMU_V3:
2091 InfoTable = AcpiDmTableInfoIort4;
2092 Length = IortNode->Length - NodeOffset;
2097 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n",
2100 /* Attempt to continue */
2102 if (!IortNode->Length)
2104 AcpiOsPrintf ("Invalid zero length IORT node\n");
2110 /* Dump the node subtable header */
2112 AcpiOsPrintf ("\n");
2113 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2114 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2116 if (ACPI_FAILURE (Status))
2121 NodeOffset += Length;
2123 /* Dump the node specific data */
2125 switch (IortNode->Type)
2127 case ACPI_IORT_NODE_ITS_GROUP:
2129 /* Validate IortItsGroup to avoid compiler warnings */
2133 for (i = 0; i < IortItsGroup->ItsCount; i++)
2135 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2136 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2137 4, AcpiDmTableInfoIort0a);
2143 case ACPI_IORT_NODE_NAMED_COMPONENT:
2145 /* Dump the Padding (optional) */
2147 if (IortNode->Length > NodeOffset)
2149 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2150 Table, IortNode->Length - NodeOffset,
2151 AcpiDmTableInfoIort1a);
2152 if (ACPI_FAILURE (Status))
2159 case ACPI_IORT_NODE_SMMU:
2161 AcpiOsPrintf ("\n");
2163 /* Validate IortSmmu to avoid compiler warnings */
2167 Length = 2 * sizeof (UINT64);
2168 NodeOffset = IortSmmu->GlobalInterruptOffset;
2169 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2170 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2171 Length, AcpiDmTableInfoIort3a);
2172 if (ACPI_FAILURE (Status))
2177 NodeOffset = IortSmmu->ContextInterruptOffset;
2178 for (i = 0; i < IortSmmu->ContextInterruptCount; i++)
2180 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2181 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2182 8, AcpiDmTableInfoIort3b);
2183 if (ACPI_FAILURE (Status))
2191 NodeOffset = IortSmmu->PmuInterruptOffset;
2192 for (i = 0; i < IortSmmu->PmuInterruptCount; i++)
2194 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2195 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2196 8, AcpiDmTableInfoIort3c);
2197 if (ACPI_FAILURE (Status))
2212 /* Dump the ID mappings */
2214 NodeOffset = IortNode->MappingOffset;
2215 for (i = 0; i < IortNode->MappingCount; i++)
2217 AcpiOsPrintf ("\n");
2218 Length = sizeof (ACPI_IORT_ID_MAPPING);
2219 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2220 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2221 Length, AcpiDmTableInfoIortMap);
2222 if (ACPI_FAILURE (Status))
2227 NodeOffset += Length;
2231 /* Point to next node subtable */
2233 Offset += IortNode->Length;
2234 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length);
2239 /*******************************************************************************
2241 * FUNCTION: AcpiDmDumpIvrs
2243 * PARAMETERS: Table - A IVRS table
2247 * DESCRIPTION: Format the contents of a IVRS
2249 ******************************************************************************/
2251 static UINT8 EntrySizes[] = {4,8,16,32};
2255 ACPI_TABLE_HEADER *Table)
2258 UINT32 Offset = sizeof (ACPI_TABLE_IVRS);
2262 ACPI_IVRS_DE_HEADER *DeviceEntry;
2263 ACPI_IVRS_HEADER *SubTable;
2264 ACPI_DMTABLE_INFO *InfoTable;
2269 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
2270 if (ACPI_FAILURE (Status))
2277 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
2278 while (Offset < Table->Length)
2280 /* Common subtable header */
2282 AcpiOsPrintf ("\n");
2283 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2284 SubTable->Length, AcpiDmTableInfoIvrsHdr);
2285 if (ACPI_FAILURE (Status))
2290 switch (SubTable->Type)
2292 case ACPI_IVRS_TYPE_HARDWARE:
2294 InfoTable = AcpiDmTableInfoIvrs0;
2297 case ACPI_IVRS_TYPE_MEMORY1:
2298 case ACPI_IVRS_TYPE_MEMORY2:
2299 case ACPI_IVRS_TYPE_MEMORY3:
2301 InfoTable = AcpiDmTableInfoIvrs1;
2306 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n",
2309 /* Attempt to continue */
2311 if (!SubTable->Length)
2313 AcpiOsPrintf ("Invalid zero length subtable\n");
2319 /* Dump the subtable */
2321 AcpiOsPrintf ("\n");
2322 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2323 SubTable->Length, InfoTable);
2324 if (ACPI_FAILURE (Status))
2329 /* The hardware subtable can contain multiple device entries */
2331 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
2333 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
2334 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
2335 sizeof (ACPI_IVRS_HARDWARE));
2337 while (EntryOffset < (Offset + SubTable->Length))
2339 AcpiOsPrintf ("\n");
2341 * Upper 2 bits of Type encode the length of the device entry
2345 * 10 = 16 byte - currently no entries defined
2346 * 11 = 32 byte - currently no entries defined
2348 EntryType = DeviceEntry->Type;
2349 EntryLength = EntrySizes [EntryType >> 6];
2353 /* 4-byte device entries */
2355 case ACPI_IVRS_TYPE_PAD4:
2356 case ACPI_IVRS_TYPE_ALL:
2357 case ACPI_IVRS_TYPE_SELECT:
2358 case ACPI_IVRS_TYPE_START:
2359 case ACPI_IVRS_TYPE_END:
2361 InfoTable = AcpiDmTableInfoIvrs4;
2364 /* 8-byte entries, type A */
2366 case ACPI_IVRS_TYPE_ALIAS_SELECT:
2367 case ACPI_IVRS_TYPE_ALIAS_START:
2369 InfoTable = AcpiDmTableInfoIvrs8a;
2372 /* 8-byte entries, type B */
2374 case ACPI_IVRS_TYPE_PAD8:
2375 case ACPI_IVRS_TYPE_EXT_SELECT:
2376 case ACPI_IVRS_TYPE_EXT_START:
2378 InfoTable = AcpiDmTableInfoIvrs8b;
2381 /* 8-byte entries, type C */
2383 case ACPI_IVRS_TYPE_SPECIAL:
2385 InfoTable = AcpiDmTableInfoIvrs8c;
2389 InfoTable = AcpiDmTableInfoIvrs4;
2391 "\n**** Unknown IVRS device entry type/length: "
2392 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
2393 EntryType, EntryLength, EntryOffset);
2397 /* Dump the Device Entry */
2399 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
2400 DeviceEntry, EntryLength, InfoTable);
2401 if (ACPI_FAILURE (Status))
2406 EntryOffset += EntryLength;
2407 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
2413 /* Point to next subtable */
2415 Offset += SubTable->Length;
2416 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
2421 /*******************************************************************************
2423 * FUNCTION: AcpiDmDumpLpit
2425 * PARAMETERS: Table - A LPIT table
2429 * DESCRIPTION: Format the contents of a LPIT. This table type consists
2430 * of an open-ended number of subtables. Note: There are no
2431 * entries in the main table. An LPIT consists of the table
2432 * header and then subtables only.
2434 ******************************************************************************/
2438 ACPI_TABLE_HEADER *Table)
2441 ACPI_LPIT_HEADER *SubTable;
2442 UINT32 Length = Table->Length;
2443 UINT32 Offset = sizeof (ACPI_TABLE_LPIT);
2444 ACPI_DMTABLE_INFO *InfoTable;
2445 UINT32 SubTableLength;
2450 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset);
2451 while (Offset < Table->Length)
2453 /* Common subtable header */
2455 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2456 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);
2457 if (ACPI_FAILURE (Status))
2462 switch (SubTable->Type)
2464 case ACPI_LPIT_TYPE_NATIVE_CSTATE:
2466 InfoTable = AcpiDmTableInfoLpit0;
2467 SubTableLength = sizeof (ACPI_LPIT_NATIVE);
2472 /* Cannot continue on unknown type - no length */
2474 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n",
2479 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2480 SubTableLength, InfoTable);
2481 if (ACPI_FAILURE (Status))
2486 AcpiOsPrintf ("\n");
2488 /* Point to next subtable */
2490 Offset += SubTableLength;
2491 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, SubTable, SubTableLength);
2496 /*******************************************************************************
2498 * FUNCTION: AcpiDmDumpMadt
2500 * PARAMETERS: Table - A MADT table
2504 * DESCRIPTION: Format the contents of a MADT. This table type consists
2505 * of an open-ended number of subtables.
2507 ******************************************************************************/
2511 ACPI_TABLE_HEADER *Table)
2514 ACPI_SUBTABLE_HEADER *SubTable;
2515 UINT32 Length = Table->Length;
2516 UINT32 Offset = sizeof (ACPI_TABLE_MADT);
2517 ACPI_DMTABLE_INFO *InfoTable;
2522 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
2523 if (ACPI_FAILURE (Status))
2530 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
2531 while (Offset < Table->Length)
2533 /* Common subtable header */
2535 AcpiOsPrintf ("\n");
2536 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2537 SubTable->Length, AcpiDmTableInfoMadtHdr);
2538 if (ACPI_FAILURE (Status))
2543 switch (SubTable->Type)
2545 case ACPI_MADT_TYPE_LOCAL_APIC:
2547 InfoTable = AcpiDmTableInfoMadt0;
2550 case ACPI_MADT_TYPE_IO_APIC:
2552 InfoTable = AcpiDmTableInfoMadt1;
2555 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
2557 InfoTable = AcpiDmTableInfoMadt2;
2560 case ACPI_MADT_TYPE_NMI_SOURCE:
2562 InfoTable = AcpiDmTableInfoMadt3;
2565 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
2567 InfoTable = AcpiDmTableInfoMadt4;
2570 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
2572 InfoTable = AcpiDmTableInfoMadt5;
2575 case ACPI_MADT_TYPE_IO_SAPIC:
2577 InfoTable = AcpiDmTableInfoMadt6;
2580 case ACPI_MADT_TYPE_LOCAL_SAPIC:
2582 InfoTable = AcpiDmTableInfoMadt7;
2585 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
2587 InfoTable = AcpiDmTableInfoMadt8;
2590 case ACPI_MADT_TYPE_LOCAL_X2APIC:
2592 InfoTable = AcpiDmTableInfoMadt9;
2595 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
2597 InfoTable = AcpiDmTableInfoMadt10;
2600 case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
2602 InfoTable = AcpiDmTableInfoMadt11;
2605 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
2607 InfoTable = AcpiDmTableInfoMadt12;
2610 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
2612 InfoTable = AcpiDmTableInfoMadt13;
2615 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
2617 InfoTable = AcpiDmTableInfoMadt14;
2620 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
2622 InfoTable = AcpiDmTableInfoMadt15;
2627 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n",
2630 /* Attempt to continue */
2632 if (!SubTable->Length)
2634 AcpiOsPrintf ("Invalid zero length subtable\n");
2641 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2642 SubTable->Length, InfoTable);
2643 if (ACPI_FAILURE (Status))
2649 /* Point to next subtable */
2651 Offset += SubTable->Length;
2652 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable,
2658 /*******************************************************************************
2660 * FUNCTION: AcpiDmDumpMcfg
2662 * PARAMETERS: Table - A MCFG Table
2666 * DESCRIPTION: Format the contents of a MCFG table
2668 ******************************************************************************/
2672 ACPI_TABLE_HEADER *Table)
2675 UINT32 Offset = sizeof (ACPI_TABLE_MCFG);
2676 ACPI_MCFG_ALLOCATION *SubTable;
2681 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
2682 if (ACPI_FAILURE (Status))
2689 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
2690 while (Offset < Table->Length)
2692 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
2694 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
2695 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
2699 AcpiOsPrintf ("\n");
2700 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2701 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
2702 if (ACPI_FAILURE (Status))
2707 /* Point to next subtable (each subtable is of fixed length) */
2709 Offset += sizeof (ACPI_MCFG_ALLOCATION);
2710 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
2711 sizeof (ACPI_MCFG_ALLOCATION));
2716 /*******************************************************************************
2718 * FUNCTION: AcpiDmDumpMpst
2720 * PARAMETERS: Table - A MPST Table
2724 * DESCRIPTION: Format the contents of a MPST table
2726 ******************************************************************************/
2730 ACPI_TABLE_HEADER *Table)
2733 UINT32 Offset = sizeof (ACPI_TABLE_MPST);
2734 ACPI_MPST_POWER_NODE *SubTable0;
2735 ACPI_MPST_POWER_STATE *SubTable0A;
2736 ACPI_MPST_COMPONENT *SubTable0B;
2737 ACPI_MPST_DATA_HDR *SubTable1;
2738 ACPI_MPST_POWER_DATA *SubTable2;
2739 UINT16 SubtableCount;
2740 UINT32 PowerStateCount;
2741 UINT32 ComponentCount;
2746 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
2747 if (ACPI_FAILURE (Status))
2752 /* Subtable: Memory Power Node(s) */
2754 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
2755 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
2757 while ((Offset < Table->Length) && SubtableCount)
2759 AcpiOsPrintf ("\n");
2760 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0,
2761 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
2762 if (ACPI_FAILURE (Status))
2767 /* Extract the sub-subtable counts */
2769 PowerStateCount = SubTable0->NumPowerStates;
2770 ComponentCount = SubTable0->NumPhysicalComponents;
2771 Offset += sizeof (ACPI_MPST_POWER_NODE);
2773 /* Sub-subtables - Memory Power State Structure(s) */
2775 SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0,
2776 sizeof (ACPI_MPST_POWER_NODE));
2778 while (PowerStateCount)
2780 AcpiOsPrintf ("\n");
2781 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A,
2782 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
2783 if (ACPI_FAILURE (Status))
2790 Offset += sizeof (ACPI_MPST_POWER_STATE);
2793 /* Sub-subtables - Physical Component ID Structure(s) */
2795 SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A);
2799 AcpiOsPrintf ("\n");
2802 while (ComponentCount)
2804 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B,
2805 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
2806 if (ACPI_FAILURE (Status))
2813 Offset += sizeof (ACPI_MPST_COMPONENT);
2816 /* Point to next Memory Power Node subtable */
2819 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0,
2820 sizeof (ACPI_MPST_POWER_NODE) +
2821 (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) +
2822 (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents));
2825 /* Subtable: Count of Memory Power State Characteristic structures */
2827 AcpiOsPrintf ("\n");
2828 SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0);
2829 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1,
2830 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
2831 if (ACPI_FAILURE (Status))
2836 SubtableCount = SubTable1->CharacteristicsCount;
2837 Offset += sizeof (ACPI_MPST_DATA_HDR);
2839 /* Subtable: Memory Power State Characteristics structure(s) */
2841 SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1,
2842 sizeof (ACPI_MPST_DATA_HDR));
2844 while ((Offset < Table->Length) && SubtableCount)
2846 AcpiOsPrintf ("\n");
2847 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2,
2848 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
2849 if (ACPI_FAILURE (Status))
2856 Offset += sizeof (ACPI_MPST_POWER_DATA);
2861 /*******************************************************************************
2863 * FUNCTION: AcpiDmDumpMsct
2865 * PARAMETERS: Table - A MSCT table
2869 * DESCRIPTION: Format the contents of a MSCT
2871 ******************************************************************************/
2875 ACPI_TABLE_HEADER *Table)
2878 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
2879 ACPI_MSCT_PROXIMITY *SubTable;
2884 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
2885 if (ACPI_FAILURE (Status))
2892 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
2893 while (Offset < Table->Length)
2895 /* Common subtable header */
2897 AcpiOsPrintf ("\n");
2898 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2899 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
2900 if (ACPI_FAILURE (Status))
2905 /* Point to next subtable */
2907 Offset += sizeof (ACPI_MSCT_PROXIMITY);
2908 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable,
2909 sizeof (ACPI_MSCT_PROXIMITY));
2914 /*******************************************************************************
2916 * FUNCTION: AcpiDmDumpMtmr
2918 * PARAMETERS: Table - A MTMR table
2922 * DESCRIPTION: Format the contents of a MTMR
2924 ******************************************************************************/
2928 ACPI_TABLE_HEADER *Table)
2931 UINT32 Offset = sizeof (ACPI_TABLE_MTMR);
2932 ACPI_MTMR_ENTRY *SubTable;
2937 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr);
2938 if (ACPI_FAILURE (Status))
2945 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset);
2946 while (Offset < Table->Length)
2948 /* Common subtable header */
2950 AcpiOsPrintf ("\n");
2951 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2952 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0);
2953 if (ACPI_FAILURE (Status))
2958 /* Point to next subtable */
2960 Offset += sizeof (ACPI_MTMR_ENTRY);
2961 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable,
2962 sizeof (ACPI_MTMR_ENTRY));
2967 /*******************************************************************************
2969 * FUNCTION: AcpiDmDumpNfit
2971 * PARAMETERS: Table - A NFIT table
2975 * DESCRIPTION: Format the contents of an NFIT.
2977 ******************************************************************************/
2981 ACPI_TABLE_HEADER *Table)
2984 UINT32 Offset = sizeof (ACPI_TABLE_NFIT);
2985 UINT32 FieldOffset = 0;
2987 ACPI_NFIT_HEADER *SubTable;
2988 ACPI_DMTABLE_INFO *InfoTable;
2989 ACPI_NFIT_INTERLEAVE *Interleave = NULL;
2990 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL;
2991 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
2997 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit);
2998 if (ACPI_FAILURE (Status))
3005 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset);
3006 while (Offset < Table->Length)
3008 /* NFIT subtable header */
3010 AcpiOsPrintf ("\n");
3011 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3012 SubTable->Length, AcpiDmTableInfoNfitHdr);
3013 if (ACPI_FAILURE (Status))
3018 switch (SubTable->Type)
3020 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
3022 InfoTable = AcpiDmTableInfoNfit0;
3025 case ACPI_NFIT_TYPE_MEMORY_MAP:
3027 InfoTable = AcpiDmTableInfoNfit1;
3030 case ACPI_NFIT_TYPE_INTERLEAVE:
3032 /* Has a variable number of 32-bit values at the end */
3034 InfoTable = AcpiDmTableInfoNfit2;
3035 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, SubTable);
3036 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE);
3039 case ACPI_NFIT_TYPE_SMBIOS:
3041 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, SubTable);
3042 InfoTable = AcpiDmTableInfoNfit3;
3045 case ACPI_NFIT_TYPE_CONTROL_REGION:
3047 InfoTable = AcpiDmTableInfoNfit4;
3050 case ACPI_NFIT_TYPE_DATA_REGION:
3052 InfoTable = AcpiDmTableInfoNfit5;
3055 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
3057 /* Has a variable number of 64-bit addresses at the end */
3059 InfoTable = AcpiDmTableInfoNfit6;
3060 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, SubTable);
3061 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64);
3065 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n",
3068 /* Attempt to continue */
3070 if (!SubTable->Length)
3072 AcpiOsPrintf ("Invalid zero length subtable\n");
3078 AcpiOsPrintf ("\n");
3079 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3080 SubTable->Length, InfoTable);
3081 if (ACPI_FAILURE (Status))
3086 /* Per-subtable variable-length fields */
3088 switch (SubTable->Type)
3090 case ACPI_NFIT_TYPE_INTERLEAVE:
3092 for (i = 0; i < Interleave->LineCount; i++)
3094 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
3095 &Interleave->LineOffset[i],
3096 sizeof (UINT32), AcpiDmTableInfoNfit2a);
3097 if (ACPI_FAILURE (Status))
3102 FieldOffset += sizeof (UINT32);
3106 case ACPI_NFIT_TYPE_SMBIOS:
3108 Length = SubTable->Length -
3109 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8);
3113 Status = AcpiDmDumpTable (Table->Length,
3114 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8),
3116 Length, AcpiDmTableInfoNfit3a);
3117 if (ACPI_FAILURE (Status))
3125 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
3127 for (i = 0; i < Hint->HintCount; i++)
3129 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
3130 &Hint->HintAddress[i],
3131 sizeof (UINT64), AcpiDmTableInfoNfit6a);
3132 if (ACPI_FAILURE (Status))
3137 FieldOffset += sizeof (UINT64);
3146 /* Point to next subtable */
3148 Offset += SubTable->Length;
3149 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubTable->Length);
3154 /*******************************************************************************
3156 * FUNCTION: AcpiDmDumpPcct
3158 * PARAMETERS: Table - A PCCT table
3162 * DESCRIPTION: Format the contents of a PCCT. This table type consists
3163 * of an open-ended number of subtables.
3165 ******************************************************************************/
3169 ACPI_TABLE_HEADER *Table)
3172 ACPI_PCCT_SUBSPACE *SubTable;
3173 ACPI_DMTABLE_INFO *InfoTable;
3174 UINT32 Length = Table->Length;
3175 UINT32 Offset = sizeof (ACPI_TABLE_PCCT);
3180 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
3181 if (ACPI_FAILURE (Status))
3188 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
3189 while (Offset < Table->Length)
3191 /* Common subtable header */
3193 AcpiOsPrintf ("\n");
3194 Status = AcpiDmDumpTable (Length, Offset, SubTable,
3195 SubTable->Header.Length, AcpiDmTableInfoPcctHdr);
3196 if (ACPI_FAILURE (Status))
3201 switch (SubTable->Header.Type)
3203 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
3205 InfoTable = AcpiDmTableInfoPcct0;
3208 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
3210 InfoTable = AcpiDmTableInfoPcct1;
3213 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
3215 InfoTable = AcpiDmTableInfoPcct2;
3218 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE:
3220 InfoTable = AcpiDmTableInfoPcct3;
3223 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE:
3225 InfoTable = AcpiDmTableInfoPcct4;
3231 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n",
3232 SubTable->Header.Type);
3236 AcpiOsPrintf ("\n");
3237 Status = AcpiDmDumpTable (Length, Offset, SubTable,
3238 SubTable->Header.Length, InfoTable);
3239 if (ACPI_FAILURE (Status))
3244 /* Point to next subtable */
3246 Offset += SubTable->Header.Length;
3247 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable,
3248 SubTable->Header.Length);
3253 /*******************************************************************************
3255 * FUNCTION: AcpiDmDumpPmtt
3257 * PARAMETERS: Table - A PMTT table
3261 * DESCRIPTION: Format the contents of a PMTT. This table type consists
3262 * of an open-ended number of subtables.
3264 ******************************************************************************/
3268 ACPI_TABLE_HEADER *Table)
3271 ACPI_PMTT_HEADER *SubTable;
3272 ACPI_PMTT_HEADER *MemSubTable;
3273 ACPI_PMTT_HEADER *DimmSubTable;
3274 ACPI_PMTT_DOMAIN *DomainArray;
3275 UINT32 Length = Table->Length;
3276 UINT32 Offset = sizeof (ACPI_TABLE_PMTT);
3279 UINT32 DomainOffset;
3285 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
3286 if (ACPI_FAILURE (Status))
3293 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
3294 while (Offset < Table->Length)
3296 /* Common subtable header */
3298 AcpiOsPrintf ("\n");
3299 Status = AcpiDmDumpTable (Length, Offset, SubTable,
3300 SubTable->Length, AcpiDmTableInfoPmttHdr);
3301 if (ACPI_FAILURE (Status))
3306 /* Only Socket subtables are expected at this level */
3308 if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET)
3311 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
3316 /* Dump the fixed-length portion of the subtable */
3318 Status = AcpiDmDumpTable (Length, Offset, SubTable,
3319 SubTable->Length, AcpiDmTableInfoPmtt0);
3320 if (ACPI_FAILURE (Status))
3325 /* Walk the memory controller subtables */
3327 MemOffset = sizeof (ACPI_PMTT_SOCKET);
3328 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable,
3329 sizeof (ACPI_PMTT_SOCKET));
3331 while (((Offset + MemOffset) < Table->Length) &&
3332 (MemOffset < SubTable->Length))
3334 /* Common subtable header */
3336 AcpiOsPrintf ("\n");
3337 Status = AcpiDmDumpTable (Length,
3338 Offset + MemOffset, MemSubTable,
3339 MemSubTable->Length, AcpiDmTableInfoPmttHdr);
3340 if (ACPI_FAILURE (Status))
3345 /* Only memory controller subtables are expected at this level */
3347 if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER)
3350 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
3355 /* Dump the fixed-length portion of the controller subtable */
3357 Status = AcpiDmDumpTable (Length,
3358 Offset + MemOffset, MemSubTable,
3359 MemSubTable->Length, AcpiDmTableInfoPmtt1);
3360 if (ACPI_FAILURE (Status))
3365 /* Walk the variable count of proximity domains */
3367 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount;
3368 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER);
3369 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable,
3370 sizeof (ACPI_PMTT_CONTROLLER));
3372 while (((Offset + MemOffset + DomainOffset) < Table->Length) &&
3373 ((MemOffset + DomainOffset) < SubTable->Length) &&
3376 Status = AcpiDmDumpTable (Length,
3377 Offset + MemOffset + DomainOffset, DomainArray,
3378 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
3379 if (ACPI_FAILURE (Status))
3384 DomainOffset += sizeof (ACPI_PMTT_DOMAIN);
3392 "\n**** DomainCount exceeds subtable length\n\n");
3395 /* Walk the physical component (DIMM) subtables */
3397 DimmOffset = DomainOffset;
3398 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable,
3401 while (((Offset + MemOffset + DimmOffset) < Table->Length) &&
3402 (DimmOffset < MemSubTable->Length))
3404 /* Common subtable header */
3406 AcpiOsPrintf ("\n");
3407 Status = AcpiDmDumpTable (Length,
3408 Offset + MemOffset + DimmOffset, DimmSubTable,
3409 DimmSubTable->Length, AcpiDmTableInfoPmttHdr);
3410 if (ACPI_FAILURE (Status))
3415 /* Only DIMM subtables are expected at this level */
3417 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM)
3420 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
3421 DimmSubTable->Type);
3425 /* Dump the fixed-length DIMM subtable */
3427 Status = AcpiDmDumpTable (Length,
3428 Offset + MemOffset + DimmOffset, DimmSubTable,
3429 DimmSubTable->Length, AcpiDmTableInfoPmtt2);
3430 if (ACPI_FAILURE (Status))
3435 /* Point to next DIMM subtable */
3437 DimmOffset += DimmSubTable->Length;
3438 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
3439 DimmSubTable, DimmSubTable->Length);
3442 /* Point to next Controller subtable */
3444 MemOffset += MemSubTable->Length;
3445 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
3446 MemSubTable, MemSubTable->Length);
3449 /* Point to next Socket subtable */
3451 Offset += SubTable->Length;
3452 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
3453 SubTable, SubTable->Length);
3458 /*******************************************************************************
3460 * FUNCTION: AcpiDmDumpPptt
3462 * PARAMETERS: Table - A PMTT table
3466 * DESCRIPTION: Format the contents of a PPTT. This table type consists
3467 * of an open-ended number of subtables.
3469 ******************************************************************************/
3473 ACPI_TABLE_HEADER *Table)
3476 ACPI_SUBTABLE_HEADER *SubTable;
3477 ACPI_PPTT_PROCESSOR *PpttProcessor;
3479 UINT8 SubTableOffset;
3480 UINT32 Offset = sizeof (ACPI_TABLE_FPDT);
3481 ACPI_DMTABLE_INFO *InfoTable;
3485 /* There is no main table (other than the standard ACPI header) */
3489 Offset = sizeof (ACPI_TABLE_HEADER);
3490 while (Offset < Table->Length)
3492 AcpiOsPrintf ("\n");
3494 /* Common subtable header */
3496 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
3497 if (SubTable->Length < sizeof (ACPI_SUBTABLE_HEADER))
3499 AcpiOsPrintf ("Invalid subtable length\n");
3502 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3503 SubTable->Length, AcpiDmTableInfoPpttHdr);
3504 if (ACPI_FAILURE (Status))
3509 switch (SubTable->Type)
3511 case ACPI_PPTT_TYPE_PROCESSOR:
3513 InfoTable = AcpiDmTableInfoPptt0;
3514 Length = sizeof (ACPI_PPTT_PROCESSOR);
3517 case ACPI_PPTT_TYPE_CACHE:
3519 InfoTable = AcpiDmTableInfoPptt1;
3520 Length = sizeof (ACPI_PPTT_CACHE);
3523 case ACPI_PPTT_TYPE_ID:
3525 InfoTable = AcpiDmTableInfoPptt2;
3526 Length = sizeof (ACPI_PPTT_ID);
3531 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n",
3534 /* Attempt to continue */
3539 if (SubTable->Length < Length)
3541 AcpiOsPrintf ("Invalid subtable length\n");
3544 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3545 SubTable->Length, InfoTable);
3546 if (ACPI_FAILURE (Status))
3550 SubTableOffset = Length;
3552 switch (SubTable->Type)
3554 case ACPI_PPTT_TYPE_PROCESSOR:
3556 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, SubTable);
3558 /* Dump SMBIOS handles */
3560 if ((UINT8)(SubTable->Length - SubTableOffset) <
3561 (UINT8)(PpttProcessor->NumberOfPrivResources * 4))
3563 AcpiOsPrintf ("Invalid private resource number\n");
3566 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++)
3568 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
3569 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTableOffset),
3570 4, AcpiDmTableInfoPptt0a);
3571 SubTableOffset += 4;
3581 /* Point to next subtable */
3583 Offset += SubTable->Length;
3588 /*******************************************************************************
3590 * FUNCTION: AcpiDmDumpS3pt
3592 * PARAMETERS: Table - A S3PT table
3594 * RETURN: Length of the table
3596 * DESCRIPTION: Format the contents of a S3PT
3598 ******************************************************************************/
3602 ACPI_TABLE_HEADER *Tables)
3605 UINT32 Offset = sizeof (ACPI_TABLE_S3PT);
3606 ACPI_FPDT_HEADER *SubTable;
3607 ACPI_DMTABLE_INFO *InfoTable;
3608 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
3613 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
3614 if (ACPI_FAILURE (Status))
3619 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset);
3620 while (Offset < S3ptTable->Length)
3622 /* Common subtable header */
3624 AcpiOsPrintf ("\n");
3625 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
3626 SubTable->Length, AcpiDmTableInfoS3ptHdr);
3627 if (ACPI_FAILURE (Status))
3632 switch (SubTable->Type)
3634 case ACPI_S3PT_TYPE_RESUME:
3636 InfoTable = AcpiDmTableInfoS3pt0;
3639 case ACPI_S3PT_TYPE_SUSPEND:
3641 InfoTable = AcpiDmTableInfoS3pt1;
3646 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
3649 /* Attempt to continue */
3651 if (!SubTable->Length)
3653 AcpiOsPrintf ("Invalid zero length subtable\n");
3659 AcpiOsPrintf ("\n");
3660 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
3661 SubTable->Length, InfoTable);
3662 if (ACPI_FAILURE (Status))
3668 /* Point to next subtable */
3670 Offset += SubTable->Length;
3671 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length);
3674 return (S3ptTable->Length);
3678 /*******************************************************************************
3680 * FUNCTION: AcpiDmDumpSlic
3682 * PARAMETERS: Table - A SLIC table
3686 * DESCRIPTION: Format the contents of a SLIC
3688 ******************************************************************************/
3692 ACPI_TABLE_HEADER *Table)
3695 (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table,
3696 Table->Length - sizeof (*Table), AcpiDmTableInfoSlic);
3700 /*******************************************************************************
3702 * FUNCTION: AcpiDmDumpSlit
3704 * PARAMETERS: Table - An SLIT
3708 * DESCRIPTION: Format the contents of a SLIT
3710 ******************************************************************************/
3714 ACPI_TABLE_HEADER *Table)
3726 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
3727 if (ACPI_FAILURE (Status))
3732 /* Display the Locality NxN Matrix */
3734 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
3735 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
3736 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
3738 for (i = 0; i < Localities; i++)
3740 /* Display one row of the matrix */
3742 AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
3743 for (j = 0; j < Localities; j++)
3745 /* Check for beyond EOT */
3747 if (Offset >= Table->Length)
3750 "\n**** Not enough room in table for all localities\n");
3754 AcpiOsPrintf ("%2.2X", Row[j]);
3757 /* Display up to 16 bytes per output row */
3759 if ((j+1) < Localities)
3763 if (j && (((j+1) % 16) == 0))
3765 AcpiOsPrintf ("\\\n"); /* With line continuation char */
3766 AcpiDmLineHeader (Offset, 0, NULL);
3771 /* Point to next row */
3773 AcpiOsPrintf ("\n");
3779 /*******************************************************************************
3781 * FUNCTION: AcpiDmDumpSrat
3783 * PARAMETERS: Table - A SRAT table
3787 * DESCRIPTION: Format the contents of a SRAT
3789 ******************************************************************************/
3793 ACPI_TABLE_HEADER *Table)
3796 UINT32 Offset = sizeof (ACPI_TABLE_SRAT);
3797 ACPI_SUBTABLE_HEADER *SubTable;
3798 ACPI_DMTABLE_INFO *InfoTable;
3803 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
3804 if (ACPI_FAILURE (Status))
3811 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
3812 while (Offset < Table->Length)
3814 /* Common subtable header */
3816 AcpiOsPrintf ("\n");
3817 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3818 SubTable->Length, AcpiDmTableInfoSratHdr);
3819 if (ACPI_FAILURE (Status))
3824 switch (SubTable->Type)
3826 case ACPI_SRAT_TYPE_CPU_AFFINITY:
3828 InfoTable = AcpiDmTableInfoSrat0;
3831 case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
3833 InfoTable = AcpiDmTableInfoSrat1;
3836 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
3838 InfoTable = AcpiDmTableInfoSrat2;
3841 case ACPI_SRAT_TYPE_GICC_AFFINITY:
3843 InfoTable = AcpiDmTableInfoSrat3;
3846 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY:
3848 InfoTable = AcpiDmTableInfoSrat4;
3852 AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n",
3855 /* Attempt to continue */
3857 if (!SubTable->Length)
3859 AcpiOsPrintf ("Invalid zero length subtable\n");
3865 AcpiOsPrintf ("\n");
3866 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3867 SubTable->Length, InfoTable);
3868 if (ACPI_FAILURE (Status))
3874 /* Point to next subtable */
3876 Offset += SubTable->Length;
3877 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable,
3883 /*******************************************************************************
3885 * FUNCTION: AcpiDmDumpStao
3887 * PARAMETERS: Table - A STAO table
3891 * DESCRIPTION: Format the contents of a STAO. This is a variable-length
3892 * table that contains an open-ended number of ASCII strings
3893 * at the end of the table.
3895 ******************************************************************************/
3899 ACPI_TABLE_HEADER *Table)
3903 UINT32 Length = Table->Length;
3904 UINT32 StringLength;
3905 UINT32 Offset = sizeof (ACPI_TABLE_STAO);
3910 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoStao);
3911 if (ACPI_FAILURE (Status))
3916 /* The rest of the table consists of Namepath strings */
3918 while (Offset < Table->Length)
3920 Namepath = ACPI_ADD_PTR (char, Table, Offset);
3921 StringLength = strlen (Namepath) + 1;
3923 AcpiDmLineHeader (Offset, StringLength, "Namestring");
3924 AcpiOsPrintf ("\"%s\"\n", Namepath);
3926 /* Point to next namepath */
3928 Offset += StringLength;
3933 /*******************************************************************************
3935 * FUNCTION: AcpiDmDumpTcpa
3937 * PARAMETERS: Table - A TCPA table
3941 * DESCRIPTION: Format the contents of a TCPA.
3943 * NOTE: There are two versions of the table with the same signature:
3944 * the client version and the server version. The common
3945 * PlatformClass field is used to differentiate the two types of
3948 ******************************************************************************/
3952 ACPI_TABLE_HEADER *Table)
3954 UINT32 Offset = sizeof (ACPI_TABLE_TCPA_HDR);
3955 ACPI_TABLE_TCPA_HDR *CommonHeader = ACPI_CAST_PTR (
3956 ACPI_TABLE_TCPA_HDR, Table);
3957 ACPI_TABLE_TCPA_HDR *SubTable = ACPI_ADD_PTR (
3958 ACPI_TABLE_TCPA_HDR, Table, Offset);
3964 Status = AcpiDmDumpTable (Table->Length, 0, Table,
3965 0, AcpiDmTableInfoTcpaHdr);
3966 if (ACPI_FAILURE (Status))
3972 * Examine the PlatformClass field to determine the table type.
3973 * Either a client or server table. Only one.
3975 switch (CommonHeader->PlatformClass)
3977 case ACPI_TCPA_CLIENT_TABLE:
3979 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3980 Table->Length - Offset, AcpiDmTableInfoTcpaClient);
3983 case ACPI_TCPA_SERVER_TABLE:
3985 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3986 Table->Length - Offset, AcpiDmTableInfoTcpaServer);
3991 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
3992 CommonHeader->PlatformClass);
3997 if (ACPI_FAILURE (Status))
3999 AcpiOsPrintf ("\n**** Cannot disassemble TCPA table\n");
4004 /*******************************************************************************
4006 * FUNCTION: AcpiDmDumpVrtc
4008 * PARAMETERS: Table - A VRTC table
4012 * DESCRIPTION: Format the contents of a VRTC
4014 ******************************************************************************/
4018 ACPI_TABLE_HEADER *Table)
4021 UINT32 Offset = sizeof (ACPI_TABLE_VRTC);
4022 ACPI_VRTC_ENTRY *SubTable;
4027 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc);
4028 if (ACPI_FAILURE (Status))
4035 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset);
4036 while (Offset < Table->Length)
4038 /* Common subtable header */
4040 AcpiOsPrintf ("\n");
4041 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
4042 sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0);
4043 if (ACPI_FAILURE (Status))
4048 /* Point to next subtable */
4050 Offset += sizeof (ACPI_VRTC_ENTRY);
4051 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable,
4052 sizeof (ACPI_VRTC_ENTRY));
4057 /*******************************************************************************
4059 * FUNCTION: AcpiDmDumpWdat
4061 * PARAMETERS: Table - A WDAT table
4065 * DESCRIPTION: Format the contents of a WDAT
4067 ******************************************************************************/
4071 ACPI_TABLE_HEADER *Table)
4074 UINT32 Offset = sizeof (ACPI_TABLE_WDAT);
4075 ACPI_WDAT_ENTRY *SubTable;
4080 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
4081 if (ACPI_FAILURE (Status))
4088 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
4089 while (Offset < Table->Length)
4091 /* Common subtable header */
4093 AcpiOsPrintf ("\n");
4094 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
4095 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
4096 if (ACPI_FAILURE (Status))
4101 /* Point to next subtable */
4103 Offset += sizeof (ACPI_WDAT_ENTRY);
4104 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable,
4105 sizeof (ACPI_WDAT_ENTRY));
4110 /*******************************************************************************
4112 * FUNCTION: AcpiDmDumpWpbt
4114 * PARAMETERS: Table - A WPBT table
4118 * DESCRIPTION: Format the contents of a WPBT. This table type consists
4119 * of an open-ended arguments buffer at the end of the table.
4121 ******************************************************************************/
4125 ACPI_TABLE_HEADER *Table)
4128 ACPI_TABLE_WPBT *SubTable;
4129 UINT32 Length = Table->Length;
4130 UINT16 ArgumentsLength;
4133 /* Dump the main table */
4135 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt);
4136 if (ACPI_FAILURE (Status))
4141 /* Extract the arguments buffer length from the main table */
4143 SubTable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table);
4144 ArgumentsLength = SubTable->ArgumentsLength;
4146 /* Dump the arguments buffer */
4148 (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength,
4149 AcpiDmTableInfoWpbt0);