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);
1735 /* Cannot continue on unknown type - no length */
1737 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n",
1742 AcpiOsPrintf ("\n");
1743 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1744 SubTableLength, InfoTable);
1745 if (ACPI_FAILURE (Status))
1750 /* Point to end of current subtable (each subtable above is of fixed length) */
1752 Offset += SubTableLength;
1754 /* If there are any (fixed-length) Error Banks from above, dump them now */
1758 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable,
1760 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
1764 AcpiOsPrintf ("\n");
1765 Status = AcpiDmDumpTable (Length, Offset, BankTable,
1766 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
1767 if (ACPI_FAILURE (Status))
1772 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
1778 /* Point to next subtable */
1780 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
1785 /*******************************************************************************
1787 * FUNCTION: AcpiDmDumpIort
1789 * PARAMETERS: Table - A IORT table
1793 * DESCRIPTION: Format the contents of a IORT
1795 ******************************************************************************/
1799 ACPI_TABLE_HEADER *Table)
1802 ACPI_TABLE_IORT *Iort;
1803 ACPI_IORT_NODE *IortNode;
1804 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL;
1805 ACPI_IORT_SMMU *IortSmmu = NULL;
1809 ACPI_DMTABLE_INFO *InfoTable;
1816 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort);
1817 if (ACPI_FAILURE (Status))
1822 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table);
1823 Offset = sizeof (ACPI_TABLE_IORT);
1825 /* Dump the OptionalPadding (optional) */
1827 if (Iort->NodeOffset > Offset)
1829 Status = AcpiDmDumpTable (Table->Length, Offset, Table,
1830 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad);
1831 if (ACPI_FAILURE (Status))
1837 Offset = Iort->NodeOffset;
1838 while (Offset < Table->Length)
1840 /* Common subtable header */
1842 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset);
1843 AcpiOsPrintf ("\n");
1844 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
1845 Status = AcpiDmDumpTable (Table->Length, Offset,
1846 IortNode, Length, AcpiDmTableInfoIortHdr);
1847 if (ACPI_FAILURE (Status))
1852 NodeOffset = Length;
1854 switch (IortNode->Type)
1856 case ACPI_IORT_NODE_ITS_GROUP:
1858 InfoTable = AcpiDmTableInfoIort0;
1859 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers);
1860 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset);
1863 case ACPI_IORT_NODE_NAMED_COMPONENT:
1865 InfoTable = AcpiDmTableInfoIort1;
1866 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName);
1867 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length);
1868 Length += strlen (String) + 1;
1871 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
1873 InfoTable = AcpiDmTableInfoIort2;
1874 Length = IortNode->Length - NodeOffset;
1877 case ACPI_IORT_NODE_SMMU:
1879 InfoTable = AcpiDmTableInfoIort3;
1880 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts);
1881 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset);
1884 case ACPI_IORT_NODE_SMMU_V3:
1886 InfoTable = AcpiDmTableInfoIort4;
1887 Length = IortNode->Length - NodeOffset;
1892 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n",
1895 /* Attempt to continue */
1897 if (!IortNode->Length)
1899 AcpiOsPrintf ("Invalid zero length IORT node\n");
1905 /* Dump the node subtable header */
1907 AcpiOsPrintf ("\n");
1908 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1909 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
1911 if (ACPI_FAILURE (Status))
1916 NodeOffset += Length;
1918 /* Dump the node specific data */
1920 switch (IortNode->Type)
1922 case ACPI_IORT_NODE_ITS_GROUP:
1924 /* Validate IortItsGroup to avoid compiler warnings */
1928 for (i = 0; i < IortItsGroup->ItsCount; i++)
1930 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1931 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
1932 4, AcpiDmTableInfoIort0a);
1938 case ACPI_IORT_NODE_NAMED_COMPONENT:
1940 /* Dump the Padding (optional) */
1942 if (IortNode->Length > NodeOffset)
1944 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1945 Table, IortNode->Length - NodeOffset,
1946 AcpiDmTableInfoIort1a);
1947 if (ACPI_FAILURE (Status))
1954 case ACPI_IORT_NODE_SMMU:
1956 AcpiOsPrintf ("\n");
1958 /* Validate IortSmmu to avoid compiler warnings */
1962 Length = 2 * sizeof (UINT64);
1963 NodeOffset = IortSmmu->GlobalInterruptOffset;
1964 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1965 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
1966 Length, AcpiDmTableInfoIort3a);
1967 if (ACPI_FAILURE (Status))
1972 NodeOffset = IortSmmu->ContextInterruptOffset;
1973 for (i = 0; i < IortSmmu->ContextInterruptCount; i++)
1975 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1976 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
1977 8, AcpiDmTableInfoIort3b);
1978 if (ACPI_FAILURE (Status))
1986 NodeOffset = IortSmmu->PmuInterruptOffset;
1987 for (i = 0; i < IortSmmu->PmuInterruptCount; i++)
1989 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
1990 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
1991 8, AcpiDmTableInfoIort3c);
1992 if (ACPI_FAILURE (Status))
2007 /* Dump the ID mappings */
2009 NodeOffset = IortNode->MappingOffset;
2010 for (i = 0; i < IortNode->MappingCount; i++)
2012 AcpiOsPrintf ("\n");
2013 Length = sizeof (ACPI_IORT_ID_MAPPING);
2014 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
2015 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
2016 Length, AcpiDmTableInfoIortMap);
2017 if (ACPI_FAILURE (Status))
2022 NodeOffset += Length;
2026 /* Point to next node subtable */
2028 Offset += IortNode->Length;
2029 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length);
2034 /*******************************************************************************
2036 * FUNCTION: AcpiDmDumpIvrs
2038 * PARAMETERS: Table - A IVRS table
2042 * DESCRIPTION: Format the contents of a IVRS
2044 ******************************************************************************/
2046 static UINT8 EntrySizes[] = {4,8,16,32};
2050 ACPI_TABLE_HEADER *Table)
2053 UINT32 Offset = sizeof (ACPI_TABLE_IVRS);
2057 ACPI_IVRS_DE_HEADER *DeviceEntry;
2058 ACPI_IVRS_HEADER *SubTable;
2059 ACPI_DMTABLE_INFO *InfoTable;
2064 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
2065 if (ACPI_FAILURE (Status))
2072 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
2073 while (Offset < Table->Length)
2075 /* Common subtable header */
2077 AcpiOsPrintf ("\n");
2078 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2079 SubTable->Length, AcpiDmTableInfoIvrsHdr);
2080 if (ACPI_FAILURE (Status))
2085 switch (SubTable->Type)
2087 case ACPI_IVRS_TYPE_HARDWARE:
2089 InfoTable = AcpiDmTableInfoIvrs0;
2092 case ACPI_IVRS_TYPE_MEMORY1:
2093 case ACPI_IVRS_TYPE_MEMORY2:
2094 case ACPI_IVRS_TYPE_MEMORY3:
2096 InfoTable = AcpiDmTableInfoIvrs1;
2101 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n",
2104 /* Attempt to continue */
2106 if (!SubTable->Length)
2108 AcpiOsPrintf ("Invalid zero length subtable\n");
2114 /* Dump the subtable */
2116 AcpiOsPrintf ("\n");
2117 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2118 SubTable->Length, InfoTable);
2119 if (ACPI_FAILURE (Status))
2124 /* The hardware subtable can contain multiple device entries */
2126 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
2128 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
2129 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
2130 sizeof (ACPI_IVRS_HARDWARE));
2132 while (EntryOffset < (Offset + SubTable->Length))
2134 AcpiOsPrintf ("\n");
2136 * Upper 2 bits of Type encode the length of the device entry
2140 * 10 = 16 byte - currently no entries defined
2141 * 11 = 32 byte - currently no entries defined
2143 EntryType = DeviceEntry->Type;
2144 EntryLength = EntrySizes [EntryType >> 6];
2148 /* 4-byte device entries */
2150 case ACPI_IVRS_TYPE_PAD4:
2151 case ACPI_IVRS_TYPE_ALL:
2152 case ACPI_IVRS_TYPE_SELECT:
2153 case ACPI_IVRS_TYPE_START:
2154 case ACPI_IVRS_TYPE_END:
2156 InfoTable = AcpiDmTableInfoIvrs4;
2159 /* 8-byte entries, type A */
2161 case ACPI_IVRS_TYPE_ALIAS_SELECT:
2162 case ACPI_IVRS_TYPE_ALIAS_START:
2164 InfoTable = AcpiDmTableInfoIvrs8a;
2167 /* 8-byte entries, type B */
2169 case ACPI_IVRS_TYPE_PAD8:
2170 case ACPI_IVRS_TYPE_EXT_SELECT:
2171 case ACPI_IVRS_TYPE_EXT_START:
2173 InfoTable = AcpiDmTableInfoIvrs8b;
2176 /* 8-byte entries, type C */
2178 case ACPI_IVRS_TYPE_SPECIAL:
2180 InfoTable = AcpiDmTableInfoIvrs8c;
2184 InfoTable = AcpiDmTableInfoIvrs4;
2186 "\n**** Unknown IVRS device entry type/length: "
2187 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
2188 EntryType, EntryLength, EntryOffset);
2192 /* Dump the Device Entry */
2194 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
2195 DeviceEntry, EntryLength, InfoTable);
2196 if (ACPI_FAILURE (Status))
2201 EntryOffset += EntryLength;
2202 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
2208 /* Point to next subtable */
2210 Offset += SubTable->Length;
2211 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
2216 /*******************************************************************************
2218 * FUNCTION: AcpiDmDumpLpit
2220 * PARAMETERS: Table - A LPIT table
2224 * DESCRIPTION: Format the contents of a LPIT. This table type consists
2225 * of an open-ended number of subtables. Note: There are no
2226 * entries in the main table. An LPIT consists of the table
2227 * header and then subtables only.
2229 ******************************************************************************/
2233 ACPI_TABLE_HEADER *Table)
2236 ACPI_LPIT_HEADER *SubTable;
2237 UINT32 Length = Table->Length;
2238 UINT32 Offset = sizeof (ACPI_TABLE_LPIT);
2239 ACPI_DMTABLE_INFO *InfoTable;
2240 UINT32 SubTableLength;
2245 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset);
2246 while (Offset < Table->Length)
2248 /* Common subtable header */
2250 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2251 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);
2252 if (ACPI_FAILURE (Status))
2257 switch (SubTable->Type)
2259 case ACPI_LPIT_TYPE_NATIVE_CSTATE:
2261 InfoTable = AcpiDmTableInfoLpit0;
2262 SubTableLength = sizeof (ACPI_LPIT_NATIVE);
2267 /* Cannot continue on unknown type - no length */
2269 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n",
2274 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2275 SubTableLength, InfoTable);
2276 if (ACPI_FAILURE (Status))
2281 AcpiOsPrintf ("\n");
2283 /* Point to next subtable */
2285 Offset += SubTableLength;
2286 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, SubTable, SubTableLength);
2291 /*******************************************************************************
2293 * FUNCTION: AcpiDmDumpMadt
2295 * PARAMETERS: Table - A MADT table
2299 * DESCRIPTION: Format the contents of a MADT. This table type consists
2300 * of an open-ended number of subtables.
2302 ******************************************************************************/
2306 ACPI_TABLE_HEADER *Table)
2309 ACPI_SUBTABLE_HEADER *SubTable;
2310 UINT32 Length = Table->Length;
2311 UINT32 Offset = sizeof (ACPI_TABLE_MADT);
2312 ACPI_DMTABLE_INFO *InfoTable;
2317 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
2318 if (ACPI_FAILURE (Status))
2325 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
2326 while (Offset < Table->Length)
2328 /* Common subtable header */
2330 AcpiOsPrintf ("\n");
2331 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2332 SubTable->Length, AcpiDmTableInfoMadtHdr);
2333 if (ACPI_FAILURE (Status))
2338 switch (SubTable->Type)
2340 case ACPI_MADT_TYPE_LOCAL_APIC:
2342 InfoTable = AcpiDmTableInfoMadt0;
2345 case ACPI_MADT_TYPE_IO_APIC:
2347 InfoTable = AcpiDmTableInfoMadt1;
2350 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
2352 InfoTable = AcpiDmTableInfoMadt2;
2355 case ACPI_MADT_TYPE_NMI_SOURCE:
2357 InfoTable = AcpiDmTableInfoMadt3;
2360 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
2362 InfoTable = AcpiDmTableInfoMadt4;
2365 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
2367 InfoTable = AcpiDmTableInfoMadt5;
2370 case ACPI_MADT_TYPE_IO_SAPIC:
2372 InfoTable = AcpiDmTableInfoMadt6;
2375 case ACPI_MADT_TYPE_LOCAL_SAPIC:
2377 InfoTable = AcpiDmTableInfoMadt7;
2380 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
2382 InfoTable = AcpiDmTableInfoMadt8;
2385 case ACPI_MADT_TYPE_LOCAL_X2APIC:
2387 InfoTable = AcpiDmTableInfoMadt9;
2390 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
2392 InfoTable = AcpiDmTableInfoMadt10;
2395 case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
2397 InfoTable = AcpiDmTableInfoMadt11;
2400 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
2402 InfoTable = AcpiDmTableInfoMadt12;
2405 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
2407 InfoTable = AcpiDmTableInfoMadt13;
2410 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
2412 InfoTable = AcpiDmTableInfoMadt14;
2415 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
2417 InfoTable = AcpiDmTableInfoMadt15;
2422 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n",
2425 /* Attempt to continue */
2427 if (!SubTable->Length)
2429 AcpiOsPrintf ("Invalid zero length subtable\n");
2436 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2437 SubTable->Length, InfoTable);
2438 if (ACPI_FAILURE (Status))
2444 /* Point to next subtable */
2446 Offset += SubTable->Length;
2447 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable,
2453 /*******************************************************************************
2455 * FUNCTION: AcpiDmDumpMcfg
2457 * PARAMETERS: Table - A MCFG Table
2461 * DESCRIPTION: Format the contents of a MCFG table
2463 ******************************************************************************/
2467 ACPI_TABLE_HEADER *Table)
2470 UINT32 Offset = sizeof (ACPI_TABLE_MCFG);
2471 ACPI_MCFG_ALLOCATION *SubTable;
2476 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
2477 if (ACPI_FAILURE (Status))
2484 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
2485 while (Offset < Table->Length)
2487 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
2489 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
2490 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
2494 AcpiOsPrintf ("\n");
2495 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2496 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
2497 if (ACPI_FAILURE (Status))
2502 /* Point to next subtable (each subtable is of fixed length) */
2504 Offset += sizeof (ACPI_MCFG_ALLOCATION);
2505 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
2506 sizeof (ACPI_MCFG_ALLOCATION));
2511 /*******************************************************************************
2513 * FUNCTION: AcpiDmDumpMpst
2515 * PARAMETERS: Table - A MPST Table
2519 * DESCRIPTION: Format the contents of a MPST table
2521 ******************************************************************************/
2525 ACPI_TABLE_HEADER *Table)
2528 UINT32 Offset = sizeof (ACPI_TABLE_MPST);
2529 ACPI_MPST_POWER_NODE *SubTable0;
2530 ACPI_MPST_POWER_STATE *SubTable0A;
2531 ACPI_MPST_COMPONENT *SubTable0B;
2532 ACPI_MPST_DATA_HDR *SubTable1;
2533 ACPI_MPST_POWER_DATA *SubTable2;
2534 UINT16 SubtableCount;
2535 UINT32 PowerStateCount;
2536 UINT32 ComponentCount;
2541 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
2542 if (ACPI_FAILURE (Status))
2547 /* Subtable: Memory Power Node(s) */
2549 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
2550 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
2552 while ((Offset < Table->Length) && SubtableCount)
2554 AcpiOsPrintf ("\n");
2555 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0,
2556 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
2557 if (ACPI_FAILURE (Status))
2562 /* Extract the sub-subtable counts */
2564 PowerStateCount = SubTable0->NumPowerStates;
2565 ComponentCount = SubTable0->NumPhysicalComponents;
2566 Offset += sizeof (ACPI_MPST_POWER_NODE);
2568 /* Sub-subtables - Memory Power State Structure(s) */
2570 SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0,
2571 sizeof (ACPI_MPST_POWER_NODE));
2573 while (PowerStateCount)
2575 AcpiOsPrintf ("\n");
2576 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A,
2577 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
2578 if (ACPI_FAILURE (Status))
2585 Offset += sizeof (ACPI_MPST_POWER_STATE);
2588 /* Sub-subtables - Physical Component ID Structure(s) */
2590 SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A);
2594 AcpiOsPrintf ("\n");
2597 while (ComponentCount)
2599 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B,
2600 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
2601 if (ACPI_FAILURE (Status))
2608 Offset += sizeof (ACPI_MPST_COMPONENT);
2611 /* Point to next Memory Power Node subtable */
2614 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0,
2615 sizeof (ACPI_MPST_POWER_NODE) +
2616 (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) +
2617 (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents));
2620 /* Subtable: Count of Memory Power State Characteristic structures */
2622 AcpiOsPrintf ("\n");
2623 SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0);
2624 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1,
2625 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
2626 if (ACPI_FAILURE (Status))
2631 SubtableCount = SubTable1->CharacteristicsCount;
2632 Offset += sizeof (ACPI_MPST_DATA_HDR);
2634 /* Subtable: Memory Power State Characteristics structure(s) */
2636 SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1,
2637 sizeof (ACPI_MPST_DATA_HDR));
2639 while ((Offset < Table->Length) && SubtableCount)
2641 AcpiOsPrintf ("\n");
2642 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2,
2643 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
2644 if (ACPI_FAILURE (Status))
2651 Offset += sizeof (ACPI_MPST_POWER_DATA);
2656 /*******************************************************************************
2658 * FUNCTION: AcpiDmDumpMsct
2660 * PARAMETERS: Table - A MSCT table
2664 * DESCRIPTION: Format the contents of a MSCT
2666 ******************************************************************************/
2670 ACPI_TABLE_HEADER *Table)
2673 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
2674 ACPI_MSCT_PROXIMITY *SubTable;
2679 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
2680 if (ACPI_FAILURE (Status))
2687 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
2688 while (Offset < Table->Length)
2690 /* Common subtable header */
2692 AcpiOsPrintf ("\n");
2693 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2694 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
2695 if (ACPI_FAILURE (Status))
2700 /* Point to next subtable */
2702 Offset += sizeof (ACPI_MSCT_PROXIMITY);
2703 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable,
2704 sizeof (ACPI_MSCT_PROXIMITY));
2709 /*******************************************************************************
2711 * FUNCTION: AcpiDmDumpMtmr
2713 * PARAMETERS: Table - A MTMR table
2717 * DESCRIPTION: Format the contents of a MTMR
2719 ******************************************************************************/
2723 ACPI_TABLE_HEADER *Table)
2726 UINT32 Offset = sizeof (ACPI_TABLE_MTMR);
2727 ACPI_MTMR_ENTRY *SubTable;
2732 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr);
2733 if (ACPI_FAILURE (Status))
2740 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset);
2741 while (Offset < Table->Length)
2743 /* Common subtable header */
2745 AcpiOsPrintf ("\n");
2746 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2747 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0);
2748 if (ACPI_FAILURE (Status))
2753 /* Point to next subtable */
2755 Offset += sizeof (ACPI_MTMR_ENTRY);
2756 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable,
2757 sizeof (ACPI_MTMR_ENTRY));
2762 /*******************************************************************************
2764 * FUNCTION: AcpiDmDumpNfit
2766 * PARAMETERS: Table - A NFIT table
2770 * DESCRIPTION: Format the contents of an NFIT.
2772 ******************************************************************************/
2776 ACPI_TABLE_HEADER *Table)
2779 UINT32 Offset = sizeof (ACPI_TABLE_NFIT);
2780 UINT32 FieldOffset = 0;
2782 ACPI_NFIT_HEADER *SubTable;
2783 ACPI_DMTABLE_INFO *InfoTable;
2784 ACPI_NFIT_INTERLEAVE *Interleave = NULL;
2785 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL;
2786 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
2792 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit);
2793 if (ACPI_FAILURE (Status))
2800 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset);
2801 while (Offset < Table->Length)
2803 /* NFIT subtable header */
2805 AcpiOsPrintf ("\n");
2806 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2807 SubTable->Length, AcpiDmTableInfoNfitHdr);
2808 if (ACPI_FAILURE (Status))
2813 switch (SubTable->Type)
2815 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
2817 InfoTable = AcpiDmTableInfoNfit0;
2820 case ACPI_NFIT_TYPE_MEMORY_MAP:
2822 InfoTable = AcpiDmTableInfoNfit1;
2825 case ACPI_NFIT_TYPE_INTERLEAVE:
2827 /* Has a variable number of 32-bit values at the end */
2829 InfoTable = AcpiDmTableInfoNfit2;
2830 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, SubTable);
2831 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE);
2834 case ACPI_NFIT_TYPE_SMBIOS:
2836 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, SubTable);
2837 InfoTable = AcpiDmTableInfoNfit3;
2840 case ACPI_NFIT_TYPE_CONTROL_REGION:
2842 InfoTable = AcpiDmTableInfoNfit4;
2845 case ACPI_NFIT_TYPE_DATA_REGION:
2847 InfoTable = AcpiDmTableInfoNfit5;
2850 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
2852 /* Has a variable number of 64-bit addresses at the end */
2854 InfoTable = AcpiDmTableInfoNfit6;
2855 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, SubTable);
2856 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64);
2860 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n",
2863 /* Attempt to continue */
2865 if (!SubTable->Length)
2867 AcpiOsPrintf ("Invalid zero length subtable\n");
2873 AcpiOsPrintf ("\n");
2874 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2875 SubTable->Length, InfoTable);
2876 if (ACPI_FAILURE (Status))
2881 /* Per-subtable variable-length fields */
2883 switch (SubTable->Type)
2885 case ACPI_NFIT_TYPE_INTERLEAVE:
2887 for (i = 0; i < Interleave->LineCount; i++)
2889 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
2890 &Interleave->LineOffset[i],
2891 sizeof (UINT32), AcpiDmTableInfoNfit2a);
2892 if (ACPI_FAILURE (Status))
2897 FieldOffset += sizeof (UINT32);
2901 case ACPI_NFIT_TYPE_SMBIOS:
2903 Length = SubTable->Length -
2904 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8);
2908 Status = AcpiDmDumpTable (Table->Length,
2909 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8),
2911 Length, AcpiDmTableInfoNfit3a);
2912 if (ACPI_FAILURE (Status))
2920 case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
2922 for (i = 0; i < Hint->HintCount; i++)
2924 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
2925 &Hint->HintAddress[i],
2926 sizeof (UINT64), AcpiDmTableInfoNfit6a);
2927 if (ACPI_FAILURE (Status))
2932 FieldOffset += sizeof (UINT64);
2941 /* Point to next subtable */
2943 Offset += SubTable->Length;
2944 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubTable->Length);
2949 /*******************************************************************************
2951 * FUNCTION: AcpiDmDumpPcct
2953 * PARAMETERS: Table - A PCCT table
2957 * DESCRIPTION: Format the contents of a PCCT. This table type consists
2958 * of an open-ended number of subtables.
2960 ******************************************************************************/
2964 ACPI_TABLE_HEADER *Table)
2967 ACPI_PCCT_SUBSPACE *SubTable;
2968 ACPI_DMTABLE_INFO *InfoTable;
2969 UINT32 Length = Table->Length;
2970 UINT32 Offset = sizeof (ACPI_TABLE_PCCT);
2975 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
2976 if (ACPI_FAILURE (Status))
2983 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
2984 while (Offset < Table->Length)
2986 /* Common subtable header */
2988 AcpiOsPrintf ("\n");
2989 Status = AcpiDmDumpTable (Length, Offset, SubTable,
2990 SubTable->Header.Length, AcpiDmTableInfoPcctHdr);
2991 if (ACPI_FAILURE (Status))
2996 switch (SubTable->Header.Type)
2998 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
3000 InfoTable = AcpiDmTableInfoPcct0;
3003 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
3005 InfoTable = AcpiDmTableInfoPcct1;
3008 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
3010 InfoTable = AcpiDmTableInfoPcct2;
3016 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n",
3017 SubTable->Header.Type);
3021 AcpiOsPrintf ("\n");
3022 Status = AcpiDmDumpTable (Length, Offset, SubTable,
3023 SubTable->Header.Length, InfoTable);
3024 if (ACPI_FAILURE (Status))
3029 /* Point to next subtable */
3031 Offset += SubTable->Header.Length;
3032 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable,
3033 SubTable->Header.Length);
3038 /*******************************************************************************
3040 * FUNCTION: AcpiDmDumpPmtt
3042 * PARAMETERS: Table - A PMTT table
3046 * DESCRIPTION: Format the contents of a PMTT. This table type consists
3047 * of an open-ended number of subtables.
3049 ******************************************************************************/
3053 ACPI_TABLE_HEADER *Table)
3056 ACPI_PMTT_HEADER *SubTable;
3057 ACPI_PMTT_HEADER *MemSubTable;
3058 ACPI_PMTT_HEADER *DimmSubTable;
3059 ACPI_PMTT_DOMAIN *DomainArray;
3060 UINT32 Length = Table->Length;
3061 UINT32 Offset = sizeof (ACPI_TABLE_PMTT);
3064 UINT32 DomainOffset;
3070 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
3071 if (ACPI_FAILURE (Status))
3078 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
3079 while (Offset < Table->Length)
3081 /* Common subtable header */
3083 AcpiOsPrintf ("\n");
3084 Status = AcpiDmDumpTable (Length, Offset, SubTable,
3085 SubTable->Length, AcpiDmTableInfoPmttHdr);
3086 if (ACPI_FAILURE (Status))
3091 /* Only Socket subtables are expected at this level */
3093 if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET)
3096 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
3101 /* Dump the fixed-length portion of the subtable */
3103 Status = AcpiDmDumpTable (Length, Offset, SubTable,
3104 SubTable->Length, AcpiDmTableInfoPmtt0);
3105 if (ACPI_FAILURE (Status))
3110 /* Walk the memory controller subtables */
3112 MemOffset = sizeof (ACPI_PMTT_SOCKET);
3113 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable,
3114 sizeof (ACPI_PMTT_SOCKET));
3116 while (((Offset + MemOffset) < Table->Length) &&
3117 (MemOffset < SubTable->Length))
3119 /* Common subtable header */
3121 AcpiOsPrintf ("\n");
3122 Status = AcpiDmDumpTable (Length,
3123 Offset + MemOffset, MemSubTable,
3124 MemSubTable->Length, AcpiDmTableInfoPmttHdr);
3125 if (ACPI_FAILURE (Status))
3130 /* Only memory controller subtables are expected at this level */
3132 if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER)
3135 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
3140 /* Dump the fixed-length portion of the controller subtable */
3142 Status = AcpiDmDumpTable (Length,
3143 Offset + MemOffset, MemSubTable,
3144 MemSubTable->Length, AcpiDmTableInfoPmtt1);
3145 if (ACPI_FAILURE (Status))
3150 /* Walk the variable count of proximity domains */
3152 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount;
3153 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER);
3154 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable,
3155 sizeof (ACPI_PMTT_CONTROLLER));
3157 while (((Offset + MemOffset + DomainOffset) < Table->Length) &&
3158 ((MemOffset + DomainOffset) < SubTable->Length) &&
3161 Status = AcpiDmDumpTable (Length,
3162 Offset + MemOffset + DomainOffset, DomainArray,
3163 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
3164 if (ACPI_FAILURE (Status))
3169 DomainOffset += sizeof (ACPI_PMTT_DOMAIN);
3177 "\n**** DomainCount exceeds subtable length\n\n");
3180 /* Walk the physical component (DIMM) subtables */
3182 DimmOffset = DomainOffset;
3183 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable,
3186 while (((Offset + MemOffset + DimmOffset) < Table->Length) &&
3187 (DimmOffset < MemSubTable->Length))
3189 /* Common subtable header */
3191 AcpiOsPrintf ("\n");
3192 Status = AcpiDmDumpTable (Length,
3193 Offset + MemOffset + DimmOffset, DimmSubTable,
3194 DimmSubTable->Length, AcpiDmTableInfoPmttHdr);
3195 if (ACPI_FAILURE (Status))
3200 /* Only DIMM subtables are expected at this level */
3202 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM)
3205 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
3206 DimmSubTable->Type);
3210 /* Dump the fixed-length DIMM subtable */
3212 Status = AcpiDmDumpTable (Length,
3213 Offset + MemOffset + DimmOffset, DimmSubTable,
3214 DimmSubTable->Length, AcpiDmTableInfoPmtt2);
3215 if (ACPI_FAILURE (Status))
3220 /* Point to next DIMM subtable */
3222 DimmOffset += DimmSubTable->Length;
3223 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
3224 DimmSubTable, DimmSubTable->Length);
3227 /* Point to next Controller subtable */
3229 MemOffset += MemSubTable->Length;
3230 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
3231 MemSubTable, MemSubTable->Length);
3234 /* Point to next Socket subtable */
3236 Offset += SubTable->Length;
3237 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
3238 SubTable, SubTable->Length);
3243 /*******************************************************************************
3245 * FUNCTION: AcpiDmDumpS3pt
3247 * PARAMETERS: Table - A S3PT table
3249 * RETURN: Length of the table
3251 * DESCRIPTION: Format the contents of a S3PT
3253 ******************************************************************************/
3257 ACPI_TABLE_HEADER *Tables)
3260 UINT32 Offset = sizeof (ACPI_TABLE_S3PT);
3261 ACPI_FPDT_HEADER *SubTable;
3262 ACPI_DMTABLE_INFO *InfoTable;
3263 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
3268 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
3269 if (ACPI_FAILURE (Status))
3274 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset);
3275 while (Offset < S3ptTable->Length)
3277 /* Common subtable header */
3279 AcpiOsPrintf ("\n");
3280 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
3281 SubTable->Length, AcpiDmTableInfoS3ptHdr);
3282 if (ACPI_FAILURE (Status))
3287 switch (SubTable->Type)
3289 case ACPI_S3PT_TYPE_RESUME:
3291 InfoTable = AcpiDmTableInfoS3pt0;
3294 case ACPI_S3PT_TYPE_SUSPEND:
3296 InfoTable = AcpiDmTableInfoS3pt1;
3301 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
3304 /* Attempt to continue */
3306 if (!SubTable->Length)
3308 AcpiOsPrintf ("Invalid zero length subtable\n");
3314 AcpiOsPrintf ("\n");
3315 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
3316 SubTable->Length, InfoTable);
3317 if (ACPI_FAILURE (Status))
3323 /* Point to next subtable */
3325 Offset += SubTable->Length;
3326 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length);
3329 return (S3ptTable->Length);
3333 /*******************************************************************************
3335 * FUNCTION: AcpiDmDumpSlic
3337 * PARAMETERS: Table - A SLIC table
3341 * DESCRIPTION: Format the contents of a SLIC
3343 ******************************************************************************/
3347 ACPI_TABLE_HEADER *Table)
3350 (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table,
3351 Table->Length - sizeof (*Table), AcpiDmTableInfoSlic);
3355 /*******************************************************************************
3357 * FUNCTION: AcpiDmDumpSlit
3359 * PARAMETERS: Table - An SLIT
3363 * DESCRIPTION: Format the contents of a SLIT
3365 ******************************************************************************/
3369 ACPI_TABLE_HEADER *Table)
3381 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
3382 if (ACPI_FAILURE (Status))
3387 /* Display the Locality NxN Matrix */
3389 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
3390 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
3391 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
3393 for (i = 0; i < Localities; i++)
3395 /* Display one row of the matrix */
3397 AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
3398 for (j = 0; j < Localities; j++)
3400 /* Check for beyond EOT */
3402 if (Offset >= Table->Length)
3405 "\n**** Not enough room in table for all localities\n");
3409 AcpiOsPrintf ("%2.2X", Row[j]);
3412 /* Display up to 16 bytes per output row */
3414 if ((j+1) < Localities)
3418 if (j && (((j+1) % 16) == 0))
3420 AcpiOsPrintf ("\\\n"); /* With line continuation char */
3421 AcpiDmLineHeader (Offset, 0, NULL);
3426 /* Point to next row */
3428 AcpiOsPrintf ("\n");
3434 /*******************************************************************************
3436 * FUNCTION: AcpiDmDumpSrat
3438 * PARAMETERS: Table - A SRAT table
3442 * DESCRIPTION: Format the contents of a SRAT
3444 ******************************************************************************/
3448 ACPI_TABLE_HEADER *Table)
3451 UINT32 Offset = sizeof (ACPI_TABLE_SRAT);
3452 ACPI_SUBTABLE_HEADER *SubTable;
3453 ACPI_DMTABLE_INFO *InfoTable;
3458 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
3459 if (ACPI_FAILURE (Status))
3466 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
3467 while (Offset < Table->Length)
3469 /* Common subtable header */
3471 AcpiOsPrintf ("\n");
3472 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3473 SubTable->Length, AcpiDmTableInfoSratHdr);
3474 if (ACPI_FAILURE (Status))
3479 switch (SubTable->Type)
3481 case ACPI_SRAT_TYPE_CPU_AFFINITY:
3483 InfoTable = AcpiDmTableInfoSrat0;
3486 case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
3488 InfoTable = AcpiDmTableInfoSrat1;
3491 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
3493 InfoTable = AcpiDmTableInfoSrat2;
3496 case ACPI_SRAT_TYPE_GICC_AFFINITY:
3498 InfoTable = AcpiDmTableInfoSrat3;
3502 AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n",
3505 /* Attempt to continue */
3507 if (!SubTable->Length)
3509 AcpiOsPrintf ("Invalid zero length subtable\n");
3515 AcpiOsPrintf ("\n");
3516 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3517 SubTable->Length, InfoTable);
3518 if (ACPI_FAILURE (Status))
3524 /* Point to next subtable */
3526 Offset += SubTable->Length;
3527 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable,
3533 /*******************************************************************************
3535 * FUNCTION: AcpiDmDumpStao
3537 * PARAMETERS: Table - A STAO table
3541 * DESCRIPTION: Format the contents of a STAO. This is a variable-length
3542 * table that contains an open-ended number of ASCII strings
3543 * at the end of the table.
3545 ******************************************************************************/
3549 ACPI_TABLE_HEADER *Table)
3553 UINT32 Length = Table->Length;
3554 UINT32 StringLength;
3555 UINT32 Offset = sizeof (ACPI_TABLE_STAO);
3560 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoStao);
3561 if (ACPI_FAILURE (Status))
3566 /* The rest of the table consists of Namepath strings */
3568 while (Offset < Table->Length)
3570 Namepath = ACPI_ADD_PTR (char, Table, Offset);
3571 StringLength = strlen (Namepath) + 1;
3573 AcpiDmLineHeader (Offset, StringLength, "Namestring");
3574 AcpiOsPrintf ("\"%s\"\n", Namepath);
3576 /* Point to next namepath */
3578 Offset += StringLength;
3583 /*******************************************************************************
3585 * FUNCTION: AcpiDmDumpTcpa
3587 * PARAMETERS: Table - A TCPA table
3591 * DESCRIPTION: Format the contents of a TCPA.
3593 * NOTE: There are two versions of the table with the same signature:
3594 * the client version and the server version. The common
3595 * PlatformClass field is used to differentiate the two types of
3598 ******************************************************************************/
3602 ACPI_TABLE_HEADER *Table)
3604 UINT32 Offset = sizeof (ACPI_TABLE_TCPA_HDR);
3605 ACPI_TABLE_TCPA_HDR *CommonHeader = ACPI_CAST_PTR (
3606 ACPI_TABLE_TCPA_HDR, Table);
3607 ACPI_TABLE_TCPA_HDR *SubTable = ACPI_ADD_PTR (
3608 ACPI_TABLE_TCPA_HDR, Table, Offset);
3614 Status = AcpiDmDumpTable (Table->Length, 0, Table,
3615 0, AcpiDmTableInfoTcpaHdr);
3616 if (ACPI_FAILURE (Status))
3622 * Examine the PlatformClass field to determine the table type.
3623 * Either a client or server table. Only one.
3625 switch (CommonHeader->PlatformClass)
3627 case ACPI_TCPA_CLIENT_TABLE:
3629 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3630 Table->Length - Offset, AcpiDmTableInfoTcpaClient);
3633 case ACPI_TCPA_SERVER_TABLE:
3635 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3636 Table->Length - Offset, AcpiDmTableInfoTcpaServer);
3641 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
3642 CommonHeader->PlatformClass);
3647 if (ACPI_FAILURE (Status))
3649 AcpiOsPrintf ("\n**** Cannot disassemble TCPA table\n");
3654 /*******************************************************************************
3656 * FUNCTION: AcpiDmDumpVrtc
3658 * PARAMETERS: Table - A VRTC table
3662 * DESCRIPTION: Format the contents of a VRTC
3664 ******************************************************************************/
3668 ACPI_TABLE_HEADER *Table)
3671 UINT32 Offset = sizeof (ACPI_TABLE_VRTC);
3672 ACPI_VRTC_ENTRY *SubTable;
3677 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc);
3678 if (ACPI_FAILURE (Status))
3685 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset);
3686 while (Offset < Table->Length)
3688 /* Common subtable header */
3690 AcpiOsPrintf ("\n");
3691 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3692 sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0);
3693 if (ACPI_FAILURE (Status))
3698 /* Point to next subtable */
3700 Offset += sizeof (ACPI_VRTC_ENTRY);
3701 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable,
3702 sizeof (ACPI_VRTC_ENTRY));
3707 /*******************************************************************************
3709 * FUNCTION: AcpiDmDumpWdat
3711 * PARAMETERS: Table - A WDAT table
3715 * DESCRIPTION: Format the contents of a WDAT
3717 ******************************************************************************/
3721 ACPI_TABLE_HEADER *Table)
3724 UINT32 Offset = sizeof (ACPI_TABLE_WDAT);
3725 ACPI_WDAT_ENTRY *SubTable;
3730 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
3731 if (ACPI_FAILURE (Status))
3738 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
3739 while (Offset < Table->Length)
3741 /* Common subtable header */
3743 AcpiOsPrintf ("\n");
3744 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
3745 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
3746 if (ACPI_FAILURE (Status))
3751 /* Point to next subtable */
3753 Offset += sizeof (ACPI_WDAT_ENTRY);
3754 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable,
3755 sizeof (ACPI_WDAT_ENTRY));
3760 /*******************************************************************************
3762 * FUNCTION: AcpiDmDumpWpbt
3764 * PARAMETERS: Table - A WPBT table
3768 * DESCRIPTION: Format the contents of a WPBT. This table type consists
3769 * of an open-ended arguments buffer at the end of the table.
3771 ******************************************************************************/
3775 ACPI_TABLE_HEADER *Table)
3778 ACPI_TABLE_WPBT *SubTable;
3779 UINT32 Length = Table->Length;
3780 UINT16 ArgumentsLength;
3783 /* Dump the main table */
3785 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt);
3786 if (ACPI_FAILURE (Status))
3791 /* Extract the arguments buffer length from the main table */
3793 SubTable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table);
3794 ArgumentsLength = SubTable->ArgumentsLength;
3796 /* Dump the arguments buffer */
3798 (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength,
3799 AcpiDmTableInfoWpbt0);