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 - 2011, 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 *****************************************************************************/
117 #include "accommon.h"
118 #include "acdisasm.h"
119 #include "actables.h"
121 /* This module used for application-level code only */
123 #define _COMPONENT ACPI_CA_DISASSEMBLER
124 ACPI_MODULE_NAME ("dmtbdump")
128 AcpiDmValidateFadtLength (
133 /*******************************************************************************
135 * FUNCTION: AcpiDmDumpRsdp
137 * PARAMETERS: Table - A RSDP
139 * RETURN: Length of the table (there is not always a length field,
140 * use revision or length if available (ACPI 2.0+))
142 * DESCRIPTION: Format the contents of a RSDP
144 ******************************************************************************/
148 ACPI_TABLE_HEADER *Table)
150 ACPI_TABLE_RSDP *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
151 UINT32 Length = sizeof (ACPI_RSDP_COMMON);
155 /* Dump the common ACPI 1.0 portion */
157 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
159 /* Validate the first checksum */
161 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON),
163 if (Checksum != Rsdp->Checksum)
165 AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n",
169 /* The RSDP for ACPI 2.0+ contains more data and has a Length field */
171 if (Rsdp->Revision > 0)
173 Length = Rsdp->Length;
174 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
176 /* Validate the extended checksum over entire RSDP */
178 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP),
179 Rsdp->ExtendedChecksum);
180 if (Checksum != Rsdp->ExtendedChecksum)
183 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n",
192 /*******************************************************************************
194 * FUNCTION: AcpiDmDumpRsdt
196 * PARAMETERS: Table - A RSDT
200 * DESCRIPTION: Format the contents of a RSDT
202 ******************************************************************************/
206 ACPI_TABLE_HEADER *Table)
214 /* Point to start of table pointer array */
216 Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry;
217 Offset = sizeof (ACPI_TABLE_HEADER);
219 /* RSDT uses 32-bit pointers */
221 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
223 for (i = 0; i < Entries; i++)
225 AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i);
226 AcpiOsPrintf ("%8.8X\n", Array[i]);
227 Offset += sizeof (UINT32);
232 /*******************************************************************************
234 * FUNCTION: AcpiDmDumpXsdt
236 * PARAMETERS: Table - A XSDT
240 * DESCRIPTION: Format the contents of a XSDT
242 ******************************************************************************/
246 ACPI_TABLE_HEADER *Table)
254 /* Point to start of table pointer array */
256 Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry;
257 Offset = sizeof (ACPI_TABLE_HEADER);
259 /* XSDT uses 64-bit pointers */
261 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
263 for (i = 0; i < Entries; i++)
265 AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i);
266 AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i]));
267 Offset += sizeof (UINT64);
272 /*******************************************************************************
274 * FUNCTION: AcpiDmDumpFadt
276 * PARAMETERS: Table - A FADT
280 * DESCRIPTION: Format the contents of a FADT
282 * NOTE: We cannot depend on the FADT version to indicate the actual
283 * contents of the FADT because of BIOS bugs. The table length
284 * is the only reliable indicator.
286 ******************************************************************************/
290 ACPI_TABLE_HEADER *Table)
293 /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */
295 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1);
297 /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */
299 if ((Table->Length > ACPI_FADT_V1_SIZE) &&
300 (Table->Length <= ACPI_FADT_V2_SIZE))
302 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2);
305 /* Check for FADT revision 3 fields and up (ACPI 2.0+ extended data) */
307 else if (Table->Length > ACPI_FADT_V2_SIZE)
309 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3);
312 /* Validate various fields in the FADT, including length */
314 AcpiTbCreateLocalFadt (Table, Table->Length);
316 /* Validate FADT length against the revision */
318 AcpiDmValidateFadtLength (Table->Revision, Table->Length);
322 /*******************************************************************************
324 * FUNCTION: AcpiDmValidateFadtLength
326 * PARAMETERS: Revision - FADT revision (Header->Revision)
327 * Length - FADT length (Header->Length
331 * DESCRIPTION: Check the FADT revision against the expected table length for
332 * that revision. Issue a warning if the length is not what was
333 * expected. This seems to be such a common BIOS bug that the
334 * FADT revision has been rendered virtually meaningless.
336 ******************************************************************************/
339 AcpiDmValidateFadtLength (
343 UINT32 ExpectedLength;
349 AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n");
353 ExpectedLength = ACPI_FADT_V1_SIZE;
357 ExpectedLength = ACPI_FADT_V2_SIZE;
362 ExpectedLength = ACPI_FADT_V3_SIZE;
369 if (Length == ExpectedLength)
375 "\n// ACPI Warning: FADT revision %X does not match length: found %X expected %X\n",
376 Revision, Length, ExpectedLength);
380 /*******************************************************************************
382 * FUNCTION: AcpiDmDumpAsf
384 * PARAMETERS: Table - A ASF table
388 * DESCRIPTION: Format the contents of a ASF table
390 ******************************************************************************/
394 ACPI_TABLE_HEADER *Table)
397 UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
398 ACPI_ASF_INFO *SubTable;
399 ACPI_DMTABLE_INFO *InfoTable;
400 ACPI_DMTABLE_INFO *DataInfoTable = NULL;
401 UINT8 *DataTable = NULL;
402 UINT32 DataCount = 0;
403 UINT32 DataLength = 0;
404 UINT32 DataOffset = 0;
409 /* No main table, only sub-tables */
411 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
412 while (Offset < Table->Length)
414 /* Common sub-table header */
416 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
417 SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
418 if (ACPI_FAILURE (Status))
423 /* The actual type is the lower 7 bits of Type */
425 Type = (UINT8) (SubTable->Header.Type & 0x7F);
429 case ACPI_ASF_TYPE_INFO:
430 InfoTable = AcpiDmTableInfoAsf0;
433 case ACPI_ASF_TYPE_ALERT:
434 InfoTable = AcpiDmTableInfoAsf1;
435 DataInfoTable = AcpiDmTableInfoAsf1a;
436 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT));
437 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts;
438 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength;
439 DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
442 case ACPI_ASF_TYPE_CONTROL:
443 InfoTable = AcpiDmTableInfoAsf2;
444 DataInfoTable = AcpiDmTableInfoAsf2a;
445 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE));
446 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls;
447 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength;
448 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
451 case ACPI_ASF_TYPE_BOOT:
452 InfoTable = AcpiDmTableInfoAsf3;
455 case ACPI_ASF_TYPE_ADDRESS:
456 InfoTable = AcpiDmTableInfoAsf4;
457 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS));
458 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices;
459 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
463 AcpiOsPrintf ("\n**** Unknown ASF sub-table type 0x%X\n", SubTable->Header.Type);
467 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
468 SubTable->Header.Length, InfoTable);
469 if (ACPI_FAILURE (Status))
474 /* Dump variable-length extra data */
478 case ACPI_ASF_TYPE_ALERT:
479 case ACPI_ASF_TYPE_CONTROL:
481 for (i = 0; i < DataCount; i++)
484 Status = AcpiDmDumpTable (Table->Length, DataOffset,
485 DataTable, DataLength, DataInfoTable);
486 if (ACPI_FAILURE (Status))
491 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
492 DataOffset += DataLength;
496 case ACPI_ASF_TYPE_ADDRESS:
498 for (i = 0; i < DataLength; i++)
502 AcpiDmLineHeader (DataOffset, 1, "Addresses");
505 AcpiOsPrintf ("%2.2X ", *DataTable);
508 if (DataOffset > Table->Length)
510 AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
524 /* Point to next sub-table */
526 if (!SubTable->Header.Length)
528 AcpiOsPrintf ("Invalid zero subtable header length\n");
532 Offset += SubTable->Header.Length;
533 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length);
538 /*******************************************************************************
540 * FUNCTION: AcpiDmDumpCpep
542 * PARAMETERS: Table - A CPEP table
546 * DESCRIPTION: Format the contents of a CPEP. This table type consists
547 * of an open-ended number of subtables.
549 ******************************************************************************/
553 ACPI_TABLE_HEADER *Table)
556 ACPI_CPEP_POLLING *SubTable;
557 UINT32 Length = Table->Length;
558 UINT32 Offset = sizeof (ACPI_TABLE_CPEP);
563 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
564 if (ACPI_FAILURE (Status))
571 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
572 while (Offset < Table->Length)
575 Status = AcpiDmDumpTable (Length, Offset, SubTable,
576 SubTable->Header.Length, AcpiDmTableInfoCpep0);
577 if (ACPI_FAILURE (Status))
582 /* Point to next sub-table */
584 Offset += SubTable->Header.Length;
585 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable,
586 SubTable->Header.Length);
591 /*******************************************************************************
593 * FUNCTION: AcpiDmDumpDmar
595 * PARAMETERS: Table - A DMAR table
599 * DESCRIPTION: Format the contents of a DMAR. This table type consists
600 * of an open-ended number of subtables.
602 ******************************************************************************/
606 ACPI_TABLE_HEADER *Table)
609 ACPI_DMAR_HEADER *SubTable;
610 UINT32 Length = Table->Length;
611 UINT32 Offset = sizeof (ACPI_TABLE_DMAR);
612 ACPI_DMTABLE_INFO *InfoTable;
613 ACPI_DMAR_DEVICE_SCOPE *ScopeTable;
621 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
622 if (ACPI_FAILURE (Status))
629 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
630 while (Offset < Table->Length)
632 /* Common sub-table header */
635 Status = AcpiDmDumpTable (Length, Offset, SubTable,
636 SubTable->Length, AcpiDmTableInfoDmarHdr);
637 if (ACPI_FAILURE (Status))
642 switch (SubTable->Type)
644 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
645 InfoTable = AcpiDmTableInfoDmar0;
646 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
648 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
649 InfoTable = AcpiDmTableInfoDmar1;
650 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
652 case ACPI_DMAR_TYPE_ATSR:
653 InfoTable = AcpiDmTableInfoDmar2;
654 ScopeOffset = sizeof (ACPI_DMAR_ATSR);
656 case ACPI_DMAR_HARDWARE_AFFINITY:
657 InfoTable = AcpiDmTableInfoDmar3;
658 ScopeOffset = sizeof (ACPI_DMAR_RHSA);
661 AcpiOsPrintf ("\n**** Unknown DMAR sub-table type 0x%X\n\n", SubTable->Type);
665 Status = AcpiDmDumpTable (Length, Offset, SubTable,
666 SubTable->Length, InfoTable);
667 if (ACPI_FAILURE (Status))
672 /* Dump the device scope entries (if any) */
674 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
675 while (ScopeOffset < SubTable->Length)
678 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
679 ScopeTable->Length, AcpiDmTableInfoDmarScope);
680 if (ACPI_FAILURE (Status))
685 /* Dump the PCI Path entries for this device scope */
687 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
689 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
690 sizeof (ACPI_DMAR_DEVICE_SCOPE));
692 while (PathOffset < ScopeTable->Length)
694 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path");
695 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
697 /* Point to next PCI Path entry */
703 /* Point to next device scope entry */
705 ScopeOffset += ScopeTable->Length;
706 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
707 ScopeTable, ScopeTable->Length);
710 /* Point to next sub-table */
712 Offset += SubTable->Length;
713 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length);
718 /*******************************************************************************
720 * FUNCTION: AcpiDmDumpEinj
722 * PARAMETERS: Table - A EINJ table
726 * DESCRIPTION: Format the contents of a EINJ. This table type consists
727 * of an open-ended number of subtables.
729 ******************************************************************************/
733 ACPI_TABLE_HEADER *Table)
736 ACPI_WHEA_HEADER *SubTable;
737 UINT32 Length = Table->Length;
738 UINT32 Offset = sizeof (ACPI_TABLE_EINJ);
743 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
744 if (ACPI_FAILURE (Status))
751 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
752 while (Offset < Table->Length)
755 Status = AcpiDmDumpTable (Length, Offset, SubTable,
756 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
757 if (ACPI_FAILURE (Status))
762 /* Point to next sub-table (each subtable is of fixed length) */
764 Offset += sizeof (ACPI_WHEA_HEADER);
765 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
766 sizeof (ACPI_WHEA_HEADER));
771 /*******************************************************************************
773 * FUNCTION: AcpiDmDumpErst
775 * PARAMETERS: Table - A ERST table
779 * DESCRIPTION: Format the contents of a ERST. This table type consists
780 * of an open-ended number of subtables.
782 ******************************************************************************/
786 ACPI_TABLE_HEADER *Table)
789 ACPI_WHEA_HEADER *SubTable;
790 UINT32 Length = Table->Length;
791 UINT32 Offset = sizeof (ACPI_TABLE_ERST);
796 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
797 if (ACPI_FAILURE (Status))
804 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
805 while (Offset < Table->Length)
808 Status = AcpiDmDumpTable (Length, Offset, SubTable,
809 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
810 if (ACPI_FAILURE (Status))
815 /* Point to next sub-table (each subtable is of fixed length) */
817 Offset += sizeof (ACPI_WHEA_HEADER);
818 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
819 sizeof (ACPI_WHEA_HEADER));
824 /*******************************************************************************
826 * FUNCTION: AcpiDmDumpHest
828 * PARAMETERS: Table - A HEST table
832 * DESCRIPTION: Format the contents of a HEST. This table type consists
833 * of an open-ended number of subtables.
835 ******************************************************************************/
839 ACPI_TABLE_HEADER *Table)
842 ACPI_HEST_HEADER *SubTable;
843 UINT32 Length = Table->Length;
844 UINT32 Offset = sizeof (ACPI_TABLE_HEST);
845 ACPI_DMTABLE_INFO *InfoTable;
846 UINT32 SubTableLength;
848 ACPI_HEST_IA_ERROR_BANK *BankTable;
853 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
854 if (ACPI_FAILURE (Status))
861 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
862 while (Offset < Table->Length)
865 switch (SubTable->Type)
867 case ACPI_HEST_TYPE_IA32_CHECK:
868 InfoTable = AcpiDmTableInfoHest0;
869 SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
870 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
871 SubTable))->NumHardwareBanks;
874 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
875 InfoTable = AcpiDmTableInfoHest1;
876 SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED);
877 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
878 SubTable))->NumHardwareBanks;
881 case ACPI_HEST_TYPE_IA32_NMI:
882 InfoTable = AcpiDmTableInfoHest2;
883 SubTableLength = sizeof (ACPI_HEST_IA_NMI);
886 case ACPI_HEST_TYPE_AER_ROOT_PORT:
887 InfoTable = AcpiDmTableInfoHest6;
888 SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
891 case ACPI_HEST_TYPE_AER_ENDPOINT:
892 InfoTable = AcpiDmTableInfoHest7;
893 SubTableLength = sizeof (ACPI_HEST_AER);
896 case ACPI_HEST_TYPE_AER_BRIDGE:
897 InfoTable = AcpiDmTableInfoHest8;
898 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
901 case ACPI_HEST_TYPE_GENERIC_ERROR:
902 InfoTable = AcpiDmTableInfoHest9;
903 SubTableLength = sizeof (ACPI_HEST_GENERIC);
907 /* Cannot continue on unknown type - no length */
909 AcpiOsPrintf ("\n**** Unknown HEST sub-table type 0x%X\n", SubTable->Type);
914 Status = AcpiDmDumpTable (Length, Offset, SubTable,
915 SubTableLength, InfoTable);
916 if (ACPI_FAILURE (Status))
921 /* Point to end of current subtable (each subtable above is of fixed length) */
923 Offset += SubTableLength;
925 /* If there are any (fixed-length) Error Banks from above, dump them now */
929 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength);
930 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
935 Status = AcpiDmDumpTable (Length, Offset, BankTable,
936 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
937 if (ACPI_FAILURE (Status))
941 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
947 /* Point to next sub-table */
949 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
954 /*******************************************************************************
956 * FUNCTION: AcpiDmDumpIvrs
958 * PARAMETERS: Table - A IVRS table
962 * DESCRIPTION: Format the contents of a IVRS
964 ******************************************************************************/
966 static UINT8 EntrySizes[] = {4,8,16,32};
970 ACPI_TABLE_HEADER *Table)
973 UINT32 Offset = sizeof (ACPI_TABLE_IVRS);
977 ACPI_IVRS_DE_HEADER *DeviceEntry;
978 ACPI_IVRS_HEADER *SubTable;
979 ACPI_DMTABLE_INFO *InfoTable;
984 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
985 if (ACPI_FAILURE (Status))
992 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
993 while (Offset < Table->Length)
995 /* Common sub-table header */
998 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
999 SubTable->Length, AcpiDmTableInfoIvrsHdr);
1000 if (ACPI_FAILURE (Status))
1005 switch (SubTable->Type)
1007 case ACPI_IVRS_TYPE_HARDWARE:
1008 InfoTable = AcpiDmTableInfoIvrs0;
1010 case ACPI_IVRS_TYPE_MEMORY1:
1011 case ACPI_IVRS_TYPE_MEMORY2:
1012 case ACPI_IVRS_TYPE_MEMORY3:
1013 InfoTable = AcpiDmTableInfoIvrs1;
1016 AcpiOsPrintf ("\n**** Unknown IVRS sub-table type 0x%X\n",
1019 /* Attempt to continue */
1021 if (!SubTable->Length)
1023 AcpiOsPrintf ("Invalid zero length subtable\n");
1029 /* Dump the subtable */
1031 AcpiOsPrintf ("\n");
1032 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1033 SubTable->Length, InfoTable);
1034 if (ACPI_FAILURE (Status))
1039 /* The hardware subtable can contain multiple device entries */
1041 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
1043 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
1044 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
1045 sizeof (ACPI_IVRS_HARDWARE));
1047 while (EntryOffset < (Offset + SubTable->Length))
1049 AcpiOsPrintf ("\n");
1051 * Upper 2 bits of Type encode the length of the device entry
1055 * 10 = 16 byte - currently no entries defined
1056 * 11 = 32 byte - currently no entries defined
1058 EntryType = DeviceEntry->Type;
1059 EntryLength = EntrySizes [EntryType >> 6];
1063 /* 4-byte device entries */
1065 case ACPI_IVRS_TYPE_PAD4:
1066 case ACPI_IVRS_TYPE_ALL:
1067 case ACPI_IVRS_TYPE_SELECT:
1068 case ACPI_IVRS_TYPE_START:
1069 case ACPI_IVRS_TYPE_END:
1071 InfoTable = AcpiDmTableInfoIvrs4;
1074 /* 8-byte entries, type A */
1076 case ACPI_IVRS_TYPE_ALIAS_SELECT:
1077 case ACPI_IVRS_TYPE_ALIAS_START:
1079 InfoTable = AcpiDmTableInfoIvrs8a;
1082 /* 8-byte entries, type B */
1084 case ACPI_IVRS_TYPE_PAD8:
1085 case ACPI_IVRS_TYPE_EXT_SELECT:
1086 case ACPI_IVRS_TYPE_EXT_START:
1088 InfoTable = AcpiDmTableInfoIvrs8b;
1091 /* 8-byte entries, type C */
1093 case ACPI_IVRS_TYPE_SPECIAL:
1095 InfoTable = AcpiDmTableInfoIvrs8c;
1099 InfoTable = AcpiDmTableInfoIvrs4;
1101 "\n**** Unknown IVRS device entry type/length: "
1102 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
1103 EntryType, EntryLength, EntryOffset);
1107 /* Dump the Device Entry */
1109 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
1110 DeviceEntry, EntryLength, InfoTable);
1112 EntryOffset += EntryLength;
1113 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
1119 /* Point to next sub-table */
1121 Offset += SubTable->Length;
1122 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
1127 /*******************************************************************************
1129 * FUNCTION: AcpiDmDumpMadt
1131 * PARAMETERS: Table - A MADT table
1135 * DESCRIPTION: Format the contents of a MADT. This table type consists
1136 * of an open-ended number of subtables.
1138 ******************************************************************************/
1142 ACPI_TABLE_HEADER *Table)
1145 ACPI_SUBTABLE_HEADER *SubTable;
1146 UINT32 Length = Table->Length;
1147 UINT32 Offset = sizeof (ACPI_TABLE_MADT);
1148 ACPI_DMTABLE_INFO *InfoTable;
1153 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
1154 if (ACPI_FAILURE (Status))
1161 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1162 while (Offset < Table->Length)
1164 /* Common sub-table header */
1166 AcpiOsPrintf ("\n");
1167 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1168 SubTable->Length, AcpiDmTableInfoMadtHdr);
1169 if (ACPI_FAILURE (Status))
1174 switch (SubTable->Type)
1176 case ACPI_MADT_TYPE_LOCAL_APIC:
1177 InfoTable = AcpiDmTableInfoMadt0;
1179 case ACPI_MADT_TYPE_IO_APIC:
1180 InfoTable = AcpiDmTableInfoMadt1;
1182 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
1183 InfoTable = AcpiDmTableInfoMadt2;
1185 case ACPI_MADT_TYPE_NMI_SOURCE:
1186 InfoTable = AcpiDmTableInfoMadt3;
1188 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
1189 InfoTable = AcpiDmTableInfoMadt4;
1191 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
1192 InfoTable = AcpiDmTableInfoMadt5;
1194 case ACPI_MADT_TYPE_IO_SAPIC:
1195 InfoTable = AcpiDmTableInfoMadt6;
1197 case ACPI_MADT_TYPE_LOCAL_SAPIC:
1198 InfoTable = AcpiDmTableInfoMadt7;
1200 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
1201 InfoTable = AcpiDmTableInfoMadt8;
1203 case ACPI_MADT_TYPE_LOCAL_X2APIC:
1204 InfoTable = AcpiDmTableInfoMadt9;
1206 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
1207 InfoTable = AcpiDmTableInfoMadt10;
1210 AcpiOsPrintf ("\n**** Unknown MADT sub-table type 0x%X\n\n", SubTable->Type);
1212 /* Attempt to continue */
1214 if (!SubTable->Length)
1216 AcpiOsPrintf ("Invalid zero length subtable\n");
1222 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1223 SubTable->Length, InfoTable);
1224 if (ACPI_FAILURE (Status))
1230 /* Point to next sub-table */
1232 Offset += SubTable->Length;
1233 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1238 /*******************************************************************************
1240 * FUNCTION: AcpiDmDumpMcfg
1242 * PARAMETERS: Table - A MCFG Table
1246 * DESCRIPTION: Format the contents of a MCFG table
1248 ******************************************************************************/
1252 ACPI_TABLE_HEADER *Table)
1255 UINT32 Offset = sizeof (ACPI_TABLE_MCFG);
1256 ACPI_MCFG_ALLOCATION *SubTable;
1261 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
1262 if (ACPI_FAILURE (Status))
1269 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
1270 while (Offset < Table->Length)
1272 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
1274 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
1275 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
1279 AcpiOsPrintf ("\n");
1280 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1281 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
1282 if (ACPI_FAILURE (Status))
1287 /* Point to next sub-table (each subtable is of fixed length) */
1289 Offset += sizeof (ACPI_MCFG_ALLOCATION);
1290 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
1291 sizeof (ACPI_MCFG_ALLOCATION));
1296 /*******************************************************************************
1298 * FUNCTION: AcpiDmDumpMsct
1300 * PARAMETERS: Table - A MSCT table
1304 * DESCRIPTION: Format the contents of a MSCT
1306 ******************************************************************************/
1310 ACPI_TABLE_HEADER *Table)
1313 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
1314 ACPI_MSCT_PROXIMITY *SubTable;
1319 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1320 if (ACPI_FAILURE (Status))
1327 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1328 while (Offset < Table->Length)
1330 /* Common sub-table header */
1332 AcpiOsPrintf ("\n");
1333 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1334 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1335 if (ACPI_FAILURE (Status))
1340 /* Point to next sub-table */
1342 Offset += sizeof (ACPI_MSCT_PROXIMITY);
1343 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY));
1348 /*******************************************************************************
1350 * FUNCTION: AcpiDmDumpSlit
1352 * PARAMETERS: Table - An SLIT
1356 * DESCRIPTION: Format the contents of a SLIT
1358 ******************************************************************************/
1362 ACPI_TABLE_HEADER *Table)
1374 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
1375 if (ACPI_FAILURE (Status))
1380 /* Display the Locality NxN Matrix */
1382 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
1383 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
1384 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
1386 for (i = 0; i < Localities; i++)
1388 /* Display one row of the matrix */
1390 AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
1391 for (j = 0; j < Localities; j++)
1393 /* Check for beyond EOT */
1395 if (Offset >= Table->Length)
1397 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n");
1401 AcpiOsPrintf ("%2.2X", Row[j]);
1404 /* Display up to 16 bytes per output row */
1406 if ((j+1) < Localities)
1410 if (j && (((j+1) % 16) == 0))
1412 AcpiOsPrintf ("\n");
1413 AcpiDmLineHeader (Offset, 0, "");
1418 /* Point to next row */
1420 AcpiOsPrintf ("\n");
1426 /*******************************************************************************
1428 * FUNCTION: AcpiDmDumpSrat
1430 * PARAMETERS: Table - A SRAT table
1434 * DESCRIPTION: Format the contents of a SRAT
1436 ******************************************************************************/
1440 ACPI_TABLE_HEADER *Table)
1443 UINT32 Offset = sizeof (ACPI_TABLE_SRAT);
1444 ACPI_SUBTABLE_HEADER *SubTable;
1445 ACPI_DMTABLE_INFO *InfoTable;
1450 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
1451 if (ACPI_FAILURE (Status))
1458 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1459 while (Offset < Table->Length)
1461 /* Common sub-table header */
1463 AcpiOsPrintf ("\n");
1464 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1465 SubTable->Length, AcpiDmTableInfoSratHdr);
1466 if (ACPI_FAILURE (Status))
1471 switch (SubTable->Type)
1473 case ACPI_SRAT_TYPE_CPU_AFFINITY:
1474 InfoTable = AcpiDmTableInfoSrat0;
1476 case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
1477 InfoTable = AcpiDmTableInfoSrat1;
1479 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
1480 InfoTable = AcpiDmTableInfoSrat2;
1483 AcpiOsPrintf ("\n**** Unknown SRAT sub-table type 0x%X\n", SubTable->Type);
1485 /* Attempt to continue */
1487 if (!SubTable->Length)
1489 AcpiOsPrintf ("Invalid zero length subtable\n");
1495 AcpiOsPrintf ("\n");
1496 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1497 SubTable->Length, InfoTable);
1498 if (ACPI_FAILURE (Status))
1504 /* Point to next sub-table */
1506 Offset += SubTable->Length;
1507 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1512 /*******************************************************************************
1514 * FUNCTION: AcpiDmDumpWdat
1516 * PARAMETERS: Table - A WDAT table
1520 * DESCRIPTION: Format the contents of a WDAT
1522 ******************************************************************************/
1526 ACPI_TABLE_HEADER *Table)
1529 UINT32 Offset = sizeof (ACPI_TABLE_WDAT);
1530 ACPI_WDAT_ENTRY *SubTable;
1535 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
1536 if (ACPI_FAILURE (Status))
1543 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
1544 while (Offset < Table->Length)
1546 /* Common sub-table header */
1548 AcpiOsPrintf ("\n");
1549 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1550 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
1551 if (ACPI_FAILURE (Status))
1556 /* Point to next sub-table */
1558 Offset += sizeof (ACPI_WDAT_ENTRY);
1559 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY));