1 /******************************************************************************
3 * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2011, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
44 #include <contrib/dev/acpica/include/acpi.h>
45 #include <contrib/dev/acpica/include/accommon.h>
46 #include <contrib/dev/acpica/include/acdisasm.h>
47 #include <contrib/dev/acpica/include/actables.h>
49 /* This module used for application-level code only */
51 #define _COMPONENT ACPI_CA_DISASSEMBLER
52 ACPI_MODULE_NAME ("dmtbdump")
56 AcpiDmValidateFadtLength (
61 /*******************************************************************************
63 * FUNCTION: AcpiDmDumpRsdp
65 * PARAMETERS: Table - A RSDP
67 * RETURN: Length of the table (there is not always a length field,
68 * use revision or length if available (ACPI 2.0+))
70 * DESCRIPTION: Format the contents of a RSDP
72 ******************************************************************************/
76 ACPI_TABLE_HEADER *Table)
78 ACPI_TABLE_RSDP *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
79 UINT32 Length = sizeof (ACPI_RSDP_COMMON);
83 /* Dump the common ACPI 1.0 portion */
85 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
87 /* Validate the first checksum */
89 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON),
91 if (Checksum != Rsdp->Checksum)
93 AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n",
97 /* The RSDP for ACPI 2.0+ contains more data and has a Length field */
99 if (Rsdp->Revision > 0)
101 Length = Rsdp->Length;
102 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
104 /* Validate the extended checksum over entire RSDP */
106 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP),
107 Rsdp->ExtendedChecksum);
108 if (Checksum != Rsdp->ExtendedChecksum)
111 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n",
120 /*******************************************************************************
122 * FUNCTION: AcpiDmDumpRsdt
124 * PARAMETERS: Table - A RSDT
128 * DESCRIPTION: Format the contents of a RSDT
130 ******************************************************************************/
134 ACPI_TABLE_HEADER *Table)
142 /* Point to start of table pointer array */
144 Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry;
145 Offset = sizeof (ACPI_TABLE_HEADER);
147 /* RSDT uses 32-bit pointers */
149 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
151 for (i = 0; i < Entries; i++)
153 AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i);
154 AcpiOsPrintf ("%8.8X\n", Array[i]);
155 Offset += sizeof (UINT32);
160 /*******************************************************************************
162 * FUNCTION: AcpiDmDumpXsdt
164 * PARAMETERS: Table - A XSDT
168 * DESCRIPTION: Format the contents of a XSDT
170 ******************************************************************************/
174 ACPI_TABLE_HEADER *Table)
182 /* Point to start of table pointer array */
184 Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry;
185 Offset = sizeof (ACPI_TABLE_HEADER);
187 /* XSDT uses 64-bit pointers */
189 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
191 for (i = 0; i < Entries; i++)
193 AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i);
194 AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i]));
195 Offset += sizeof (UINT64);
200 /*******************************************************************************
202 * FUNCTION: AcpiDmDumpFadt
204 * PARAMETERS: Table - A FADT
208 * DESCRIPTION: Format the contents of a FADT
210 * NOTE: We cannot depend on the FADT version to indicate the actual
211 * contents of the FADT because of BIOS bugs. The table length
212 * is the only reliable indicator.
214 ******************************************************************************/
218 ACPI_TABLE_HEADER *Table)
221 /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */
223 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1);
225 /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */
227 if ((Table->Length > ACPI_FADT_V1_SIZE) &&
228 (Table->Length <= ACPI_FADT_V2_SIZE))
230 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2);
233 /* Check for FADT revision 3 fields and up (ACPI 2.0+ extended data) */
235 else if (Table->Length > ACPI_FADT_V2_SIZE)
237 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3);
240 /* Validate various fields in the FADT, including length */
242 AcpiTbCreateLocalFadt (Table, Table->Length);
244 /* Validate FADT length against the revision */
246 AcpiDmValidateFadtLength (Table->Revision, Table->Length);
250 /*******************************************************************************
252 * FUNCTION: AcpiDmValidateFadtLength
254 * PARAMETERS: Revision - FADT revision (Header->Revision)
255 * Length - FADT length (Header->Length
259 * DESCRIPTION: Check the FADT revision against the expected table length for
260 * that revision. Issue a warning if the length is not what was
261 * expected. This seems to be such a common BIOS bug that the
262 * FADT revision has been rendered virtually meaningless.
264 ******************************************************************************/
267 AcpiDmValidateFadtLength (
271 UINT32 ExpectedLength;
277 AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n");
281 ExpectedLength = ACPI_FADT_V1_SIZE;
285 ExpectedLength = ACPI_FADT_V2_SIZE;
290 ExpectedLength = ACPI_FADT_V3_SIZE;
297 if (Length == ExpectedLength)
303 "\n// ACPI Warning: FADT revision %X does not match length: found %X expected %X\n",
304 Revision, Length, ExpectedLength);
308 /*******************************************************************************
310 * FUNCTION: AcpiDmDumpAsf
312 * PARAMETERS: Table - A ASF table
316 * DESCRIPTION: Format the contents of a ASF table
318 ******************************************************************************/
322 ACPI_TABLE_HEADER *Table)
325 UINT32 Offset = sizeof (ACPI_TABLE_HEADER);
326 ACPI_ASF_INFO *SubTable;
327 ACPI_DMTABLE_INFO *InfoTable;
328 ACPI_DMTABLE_INFO *DataInfoTable = NULL;
329 UINT8 *DataTable = NULL;
330 UINT32 DataCount = 0;
331 UINT32 DataLength = 0;
332 UINT32 DataOffset = 0;
337 /* No main table, only sub-tables */
339 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
340 while (Offset < Table->Length)
342 /* Common sub-table header */
344 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
345 SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
346 if (ACPI_FAILURE (Status))
351 /* The actual type is the lower 7 bits of Type */
353 Type = (UINT8) (SubTable->Header.Type & 0x7F);
357 case ACPI_ASF_TYPE_INFO:
358 InfoTable = AcpiDmTableInfoAsf0;
361 case ACPI_ASF_TYPE_ALERT:
362 InfoTable = AcpiDmTableInfoAsf1;
363 DataInfoTable = AcpiDmTableInfoAsf1a;
364 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT));
365 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts;
366 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength;
367 DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
370 case ACPI_ASF_TYPE_CONTROL:
371 InfoTable = AcpiDmTableInfoAsf2;
372 DataInfoTable = AcpiDmTableInfoAsf2a;
373 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE));
374 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls;
375 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength;
376 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
379 case ACPI_ASF_TYPE_BOOT:
380 InfoTable = AcpiDmTableInfoAsf3;
383 case ACPI_ASF_TYPE_ADDRESS:
384 InfoTable = AcpiDmTableInfoAsf4;
385 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS));
386 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices;
387 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
391 AcpiOsPrintf ("\n**** Unknown ASF sub-table type 0x%X\n", SubTable->Header.Type);
395 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
396 SubTable->Header.Length, InfoTable);
397 if (ACPI_FAILURE (Status))
402 /* Dump variable-length extra data */
406 case ACPI_ASF_TYPE_ALERT:
407 case ACPI_ASF_TYPE_CONTROL:
409 for (i = 0; i < DataCount; i++)
412 Status = AcpiDmDumpTable (Table->Length, DataOffset,
413 DataTable, DataLength, DataInfoTable);
414 if (ACPI_FAILURE (Status))
419 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
420 DataOffset += DataLength;
424 case ACPI_ASF_TYPE_ADDRESS:
426 for (i = 0; i < DataLength; i++)
430 AcpiDmLineHeader (DataOffset, 1, "Addresses");
433 AcpiOsPrintf ("%2.2X ", *DataTable);
436 if (DataOffset > Table->Length)
438 AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
452 /* Point to next sub-table */
454 if (!SubTable->Header.Length)
456 AcpiOsPrintf ("Invalid zero subtable header length\n");
460 Offset += SubTable->Header.Length;
461 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length);
466 /*******************************************************************************
468 * FUNCTION: AcpiDmDumpCpep
470 * PARAMETERS: Table - A CPEP table
474 * DESCRIPTION: Format the contents of a CPEP. This table type consists
475 * of an open-ended number of subtables.
477 ******************************************************************************/
481 ACPI_TABLE_HEADER *Table)
484 ACPI_CPEP_POLLING *SubTable;
485 UINT32 Length = Table->Length;
486 UINT32 Offset = sizeof (ACPI_TABLE_CPEP);
491 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
492 if (ACPI_FAILURE (Status))
499 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
500 while (Offset < Table->Length)
503 Status = AcpiDmDumpTable (Length, Offset, SubTable,
504 SubTable->Header.Length, AcpiDmTableInfoCpep0);
505 if (ACPI_FAILURE (Status))
510 /* Point to next sub-table */
512 Offset += SubTable->Header.Length;
513 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable,
514 SubTable->Header.Length);
519 /*******************************************************************************
521 * FUNCTION: AcpiDmDumpDmar
523 * PARAMETERS: Table - A DMAR table
527 * DESCRIPTION: Format the contents of a DMAR. This table type consists
528 * of an open-ended number of subtables.
530 ******************************************************************************/
534 ACPI_TABLE_HEADER *Table)
537 ACPI_DMAR_HEADER *SubTable;
538 UINT32 Length = Table->Length;
539 UINT32 Offset = sizeof (ACPI_TABLE_DMAR);
540 ACPI_DMTABLE_INFO *InfoTable;
541 ACPI_DMAR_DEVICE_SCOPE *ScopeTable;
549 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
550 if (ACPI_FAILURE (Status))
557 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
558 while (Offset < Table->Length)
560 /* Common sub-table header */
563 Status = AcpiDmDumpTable (Length, Offset, SubTable,
564 SubTable->Length, AcpiDmTableInfoDmarHdr);
565 if (ACPI_FAILURE (Status))
570 switch (SubTable->Type)
572 case ACPI_DMAR_TYPE_HARDWARE_UNIT:
573 InfoTable = AcpiDmTableInfoDmar0;
574 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
576 case ACPI_DMAR_TYPE_RESERVED_MEMORY:
577 InfoTable = AcpiDmTableInfoDmar1;
578 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
580 case ACPI_DMAR_TYPE_ATSR:
581 InfoTable = AcpiDmTableInfoDmar2;
582 ScopeOffset = sizeof (ACPI_DMAR_ATSR);
584 case ACPI_DMAR_HARDWARE_AFFINITY:
585 InfoTable = AcpiDmTableInfoDmar3;
586 ScopeOffset = sizeof (ACPI_DMAR_RHSA);
589 AcpiOsPrintf ("\n**** Unknown DMAR sub-table type 0x%X\n\n", SubTable->Type);
593 Status = AcpiDmDumpTable (Length, Offset, SubTable,
594 SubTable->Length, InfoTable);
595 if (ACPI_FAILURE (Status))
600 /* Dump the device scope entries (if any) */
602 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
603 while (ScopeOffset < SubTable->Length)
606 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
607 ScopeTable->Length, AcpiDmTableInfoDmarScope);
608 if (ACPI_FAILURE (Status))
613 /* Dump the PCI Path entries for this device scope */
615 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
617 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
618 sizeof (ACPI_DMAR_DEVICE_SCOPE));
620 while (PathOffset < ScopeTable->Length)
622 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path");
623 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
625 /* Point to next PCI Path entry */
631 /* Point to next device scope entry */
633 ScopeOffset += ScopeTable->Length;
634 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
635 ScopeTable, ScopeTable->Length);
638 /* Point to next sub-table */
640 Offset += SubTable->Length;
641 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length);
646 /*******************************************************************************
648 * FUNCTION: AcpiDmDumpEinj
650 * PARAMETERS: Table - A EINJ table
654 * DESCRIPTION: Format the contents of a EINJ. This table type consists
655 * of an open-ended number of subtables.
657 ******************************************************************************/
661 ACPI_TABLE_HEADER *Table)
664 ACPI_WHEA_HEADER *SubTable;
665 UINT32 Length = Table->Length;
666 UINT32 Offset = sizeof (ACPI_TABLE_EINJ);
671 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
672 if (ACPI_FAILURE (Status))
679 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
680 while (Offset < Table->Length)
683 Status = AcpiDmDumpTable (Length, Offset, SubTable,
684 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
685 if (ACPI_FAILURE (Status))
690 /* Point to next sub-table (each subtable is of fixed length) */
692 Offset += sizeof (ACPI_WHEA_HEADER);
693 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
694 sizeof (ACPI_WHEA_HEADER));
699 /*******************************************************************************
701 * FUNCTION: AcpiDmDumpErst
703 * PARAMETERS: Table - A ERST table
707 * DESCRIPTION: Format the contents of a ERST. This table type consists
708 * of an open-ended number of subtables.
710 ******************************************************************************/
714 ACPI_TABLE_HEADER *Table)
717 ACPI_WHEA_HEADER *SubTable;
718 UINT32 Length = Table->Length;
719 UINT32 Offset = sizeof (ACPI_TABLE_ERST);
724 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
725 if (ACPI_FAILURE (Status))
732 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
733 while (Offset < Table->Length)
736 Status = AcpiDmDumpTable (Length, Offset, SubTable,
737 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
738 if (ACPI_FAILURE (Status))
743 /* Point to next sub-table (each subtable is of fixed length) */
745 Offset += sizeof (ACPI_WHEA_HEADER);
746 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
747 sizeof (ACPI_WHEA_HEADER));
752 /*******************************************************************************
754 * FUNCTION: AcpiDmDumpHest
756 * PARAMETERS: Table - A HEST table
760 * DESCRIPTION: Format the contents of a HEST. This table type consists
761 * of an open-ended number of subtables.
763 ******************************************************************************/
767 ACPI_TABLE_HEADER *Table)
770 ACPI_HEST_HEADER *SubTable;
771 UINT32 Length = Table->Length;
772 UINT32 Offset = sizeof (ACPI_TABLE_HEST);
773 ACPI_DMTABLE_INFO *InfoTable;
774 UINT32 SubTableLength;
776 ACPI_HEST_IA_ERROR_BANK *BankTable;
781 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
782 if (ACPI_FAILURE (Status))
789 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
790 while (Offset < Table->Length)
793 switch (SubTable->Type)
795 case ACPI_HEST_TYPE_IA32_CHECK:
796 InfoTable = AcpiDmTableInfoHest0;
797 SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
798 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
799 SubTable))->NumHardwareBanks;
802 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
803 InfoTable = AcpiDmTableInfoHest1;
804 SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED);
805 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
806 SubTable))->NumHardwareBanks;
809 case ACPI_HEST_TYPE_IA32_NMI:
810 InfoTable = AcpiDmTableInfoHest2;
811 SubTableLength = sizeof (ACPI_HEST_IA_NMI);
814 case ACPI_HEST_TYPE_AER_ROOT_PORT:
815 InfoTable = AcpiDmTableInfoHest6;
816 SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
819 case ACPI_HEST_TYPE_AER_ENDPOINT:
820 InfoTable = AcpiDmTableInfoHest7;
821 SubTableLength = sizeof (ACPI_HEST_AER);
824 case ACPI_HEST_TYPE_AER_BRIDGE:
825 InfoTable = AcpiDmTableInfoHest8;
826 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
829 case ACPI_HEST_TYPE_GENERIC_ERROR:
830 InfoTable = AcpiDmTableInfoHest9;
831 SubTableLength = sizeof (ACPI_HEST_GENERIC);
835 /* Cannot continue on unknown type - no length */
837 AcpiOsPrintf ("\n**** Unknown HEST sub-table type 0x%X\n", SubTable->Type);
842 Status = AcpiDmDumpTable (Length, Offset, SubTable,
843 SubTableLength, InfoTable);
844 if (ACPI_FAILURE (Status))
849 /* Point to end of current subtable (each subtable above is of fixed length) */
851 Offset += SubTableLength;
853 /* If there are any (fixed-length) Error Banks from above, dump them now */
857 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength);
858 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
863 Status = AcpiDmDumpTable (Length, Offset, BankTable,
864 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
865 if (ACPI_FAILURE (Status))
869 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
875 /* Point to next sub-table */
877 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
882 /*******************************************************************************
884 * FUNCTION: AcpiDmDumpIvrs
886 * PARAMETERS: Table - A IVRS table
890 * DESCRIPTION: Format the contents of a IVRS
892 ******************************************************************************/
894 static UINT8 EntrySizes[] = {4,8,16,32};
898 ACPI_TABLE_HEADER *Table)
901 UINT32 Offset = sizeof (ACPI_TABLE_IVRS);
905 ACPI_IVRS_DE_HEADER *DeviceEntry;
906 ACPI_IVRS_HEADER *SubTable;
907 ACPI_DMTABLE_INFO *InfoTable;
912 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
913 if (ACPI_FAILURE (Status))
920 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
921 while (Offset < Table->Length)
923 /* Common sub-table header */
926 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
927 SubTable->Length, AcpiDmTableInfoIvrsHdr);
928 if (ACPI_FAILURE (Status))
933 switch (SubTable->Type)
935 case ACPI_IVRS_TYPE_HARDWARE:
936 InfoTable = AcpiDmTableInfoIvrs0;
938 case ACPI_IVRS_TYPE_MEMORY1:
939 case ACPI_IVRS_TYPE_MEMORY2:
940 case ACPI_IVRS_TYPE_MEMORY3:
941 InfoTable = AcpiDmTableInfoIvrs1;
944 AcpiOsPrintf ("\n**** Unknown IVRS sub-table type 0x%X\n",
947 /* Attempt to continue */
949 if (!SubTable->Length)
951 AcpiOsPrintf ("Invalid zero length subtable\n");
957 /* Dump the subtable */
960 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
961 SubTable->Length, InfoTable);
962 if (ACPI_FAILURE (Status))
967 /* The hardware subtable can contain multiple device entries */
969 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
971 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
972 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
973 sizeof (ACPI_IVRS_HARDWARE));
975 while (EntryOffset < (Offset + SubTable->Length))
979 * Upper 2 bits of Type encode the length of the device entry
983 * 10 = 16 byte - currently no entries defined
984 * 11 = 32 byte - currently no entries defined
986 EntryType = DeviceEntry->Type;
987 EntryLength = EntrySizes [EntryType >> 6];
991 /* 4-byte device entries */
993 case ACPI_IVRS_TYPE_PAD4:
994 case ACPI_IVRS_TYPE_ALL:
995 case ACPI_IVRS_TYPE_SELECT:
996 case ACPI_IVRS_TYPE_START:
997 case ACPI_IVRS_TYPE_END:
999 InfoTable = AcpiDmTableInfoIvrs4;
1002 /* 8-byte entries, type A */
1004 case ACPI_IVRS_TYPE_ALIAS_SELECT:
1005 case ACPI_IVRS_TYPE_ALIAS_START:
1007 InfoTable = AcpiDmTableInfoIvrs8a;
1010 /* 8-byte entries, type B */
1012 case ACPI_IVRS_TYPE_PAD8:
1013 case ACPI_IVRS_TYPE_EXT_SELECT:
1014 case ACPI_IVRS_TYPE_EXT_START:
1016 InfoTable = AcpiDmTableInfoIvrs8b;
1019 /* 8-byte entries, type C */
1021 case ACPI_IVRS_TYPE_SPECIAL:
1023 InfoTable = AcpiDmTableInfoIvrs8c;
1027 InfoTable = AcpiDmTableInfoIvrs4;
1029 "\n**** Unknown IVRS device entry type/length: "
1030 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
1031 EntryType, EntryLength, EntryOffset);
1035 /* Dump the Device Entry */
1037 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
1038 DeviceEntry, EntryLength, InfoTable);
1040 EntryOffset += EntryLength;
1041 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
1047 /* Point to next sub-table */
1049 Offset += SubTable->Length;
1050 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
1055 /*******************************************************************************
1057 * FUNCTION: AcpiDmDumpMadt
1059 * PARAMETERS: Table - A MADT table
1063 * DESCRIPTION: Format the contents of a MADT. This table type consists
1064 * of an open-ended number of subtables.
1066 ******************************************************************************/
1070 ACPI_TABLE_HEADER *Table)
1073 ACPI_SUBTABLE_HEADER *SubTable;
1074 UINT32 Length = Table->Length;
1075 UINT32 Offset = sizeof (ACPI_TABLE_MADT);
1076 ACPI_DMTABLE_INFO *InfoTable;
1081 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
1082 if (ACPI_FAILURE (Status))
1089 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1090 while (Offset < Table->Length)
1092 /* Common sub-table header */
1094 AcpiOsPrintf ("\n");
1095 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1096 SubTable->Length, AcpiDmTableInfoMadtHdr);
1097 if (ACPI_FAILURE (Status))
1102 switch (SubTable->Type)
1104 case ACPI_MADT_TYPE_LOCAL_APIC:
1105 InfoTable = AcpiDmTableInfoMadt0;
1107 case ACPI_MADT_TYPE_IO_APIC:
1108 InfoTable = AcpiDmTableInfoMadt1;
1110 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
1111 InfoTable = AcpiDmTableInfoMadt2;
1113 case ACPI_MADT_TYPE_NMI_SOURCE:
1114 InfoTable = AcpiDmTableInfoMadt3;
1116 case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
1117 InfoTable = AcpiDmTableInfoMadt4;
1119 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
1120 InfoTable = AcpiDmTableInfoMadt5;
1122 case ACPI_MADT_TYPE_IO_SAPIC:
1123 InfoTable = AcpiDmTableInfoMadt6;
1125 case ACPI_MADT_TYPE_LOCAL_SAPIC:
1126 InfoTable = AcpiDmTableInfoMadt7;
1128 case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
1129 InfoTable = AcpiDmTableInfoMadt8;
1131 case ACPI_MADT_TYPE_LOCAL_X2APIC:
1132 InfoTable = AcpiDmTableInfoMadt9;
1134 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
1135 InfoTable = AcpiDmTableInfoMadt10;
1138 AcpiOsPrintf ("\n**** Unknown MADT sub-table type 0x%X\n\n", SubTable->Type);
1140 /* Attempt to continue */
1142 if (!SubTable->Length)
1144 AcpiOsPrintf ("Invalid zero length subtable\n");
1150 Status = AcpiDmDumpTable (Length, Offset, SubTable,
1151 SubTable->Length, InfoTable);
1152 if (ACPI_FAILURE (Status))
1158 /* Point to next sub-table */
1160 Offset += SubTable->Length;
1161 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1166 /*******************************************************************************
1168 * FUNCTION: AcpiDmDumpMcfg
1170 * PARAMETERS: Table - A MCFG Table
1174 * DESCRIPTION: Format the contents of a MCFG table
1176 ******************************************************************************/
1180 ACPI_TABLE_HEADER *Table)
1183 UINT32 Offset = sizeof (ACPI_TABLE_MCFG);
1184 ACPI_MCFG_ALLOCATION *SubTable;
1189 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
1190 if (ACPI_FAILURE (Status))
1197 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
1198 while (Offset < Table->Length)
1200 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
1202 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
1203 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
1207 AcpiOsPrintf ("\n");
1208 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1209 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
1210 if (ACPI_FAILURE (Status))
1215 /* Point to next sub-table (each subtable is of fixed length) */
1217 Offset += sizeof (ACPI_MCFG_ALLOCATION);
1218 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
1219 sizeof (ACPI_MCFG_ALLOCATION));
1224 /*******************************************************************************
1226 * FUNCTION: AcpiDmDumpMsct
1228 * PARAMETERS: Table - A MSCT table
1232 * DESCRIPTION: Format the contents of a MSCT
1234 ******************************************************************************/
1238 ACPI_TABLE_HEADER *Table)
1241 UINT32 Offset = sizeof (ACPI_TABLE_MSCT);
1242 ACPI_MSCT_PROXIMITY *SubTable;
1247 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1248 if (ACPI_FAILURE (Status))
1255 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1256 while (Offset < Table->Length)
1258 /* Common sub-table header */
1260 AcpiOsPrintf ("\n");
1261 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1262 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1263 if (ACPI_FAILURE (Status))
1268 /* Point to next sub-table */
1270 Offset += sizeof (ACPI_MSCT_PROXIMITY);
1271 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY));
1276 /*******************************************************************************
1278 * FUNCTION: AcpiDmDumpSlic
1280 * PARAMETERS: Table - A SLIC table
1284 * DESCRIPTION: Format the contents of a SLIC
1286 ******************************************************************************/
1290 ACPI_TABLE_HEADER *Table)
1293 UINT32 Offset = sizeof (ACPI_TABLE_SLIC);
1294 ACPI_SLIC_HEADER *SubTable;
1295 ACPI_DMTABLE_INFO *InfoTable;
1298 /* There is no main SLIC table, only subtables */
1300 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, Table, Offset);
1301 while (Offset < Table->Length)
1303 /* Common sub-table header */
1305 AcpiOsPrintf ("\n");
1306 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1307 SubTable->Length, AcpiDmTableInfoSlicHdr);
1308 if (ACPI_FAILURE (Status))
1313 switch (SubTable->Type)
1315 case ACPI_SLIC_TYPE_PUBLIC_KEY:
1316 InfoTable = AcpiDmTableInfoSlic0;
1318 case ACPI_SLIC_TYPE_WINDOWS_MARKER:
1319 InfoTable = AcpiDmTableInfoSlic1;
1322 AcpiOsPrintf ("\n**** Unknown SLIC sub-table type 0x%X\n", SubTable->Type);
1324 /* Attempt to continue */
1326 if (!SubTable->Length)
1328 AcpiOsPrintf ("Invalid zero length subtable\n");
1334 AcpiOsPrintf ("\n");
1335 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1336 SubTable->Length, InfoTable);
1337 if (ACPI_FAILURE (Status))
1343 /* Point to next sub-table */
1345 Offset += SubTable->Length;
1346 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, SubTable, SubTable->Length);
1351 /*******************************************************************************
1353 * FUNCTION: AcpiDmDumpSlit
1355 * PARAMETERS: Table - An SLIT
1359 * DESCRIPTION: Format the contents of a SLIT
1361 ******************************************************************************/
1365 ACPI_TABLE_HEADER *Table)
1377 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
1378 if (ACPI_FAILURE (Status))
1383 /* Display the Locality NxN Matrix */
1385 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
1386 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
1387 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
1389 for (i = 0; i < Localities; i++)
1391 /* Display one row of the matrix */
1393 AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
1394 for (j = 0; j < Localities; j++)
1396 /* Check for beyond EOT */
1398 if (Offset >= Table->Length)
1400 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n");
1404 AcpiOsPrintf ("%2.2X", Row[j]);
1407 /* Display up to 16 bytes per output row */
1409 if ((j+1) < Localities)
1413 if (j && (((j+1) % 16) == 0))
1415 AcpiOsPrintf ("\\\n"); /* With line continuation char */
1416 AcpiDmLineHeader (Offset, 0, NULL);
1421 /* Point to next row */
1423 AcpiOsPrintf ("\n");
1429 /*******************************************************************************
1431 * FUNCTION: AcpiDmDumpSrat
1433 * PARAMETERS: Table - A SRAT table
1437 * DESCRIPTION: Format the contents of a SRAT
1439 ******************************************************************************/
1443 ACPI_TABLE_HEADER *Table)
1446 UINT32 Offset = sizeof (ACPI_TABLE_SRAT);
1447 ACPI_SUBTABLE_HEADER *SubTable;
1448 ACPI_DMTABLE_INFO *InfoTable;
1453 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
1454 if (ACPI_FAILURE (Status))
1461 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1462 while (Offset < Table->Length)
1464 /* Common sub-table header */
1466 AcpiOsPrintf ("\n");
1467 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1468 SubTable->Length, AcpiDmTableInfoSratHdr);
1469 if (ACPI_FAILURE (Status))
1474 switch (SubTable->Type)
1476 case ACPI_SRAT_TYPE_CPU_AFFINITY:
1477 InfoTable = AcpiDmTableInfoSrat0;
1479 case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
1480 InfoTable = AcpiDmTableInfoSrat1;
1482 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
1483 InfoTable = AcpiDmTableInfoSrat2;
1486 AcpiOsPrintf ("\n**** Unknown SRAT sub-table type 0x%X\n", SubTable->Type);
1488 /* Attempt to continue */
1490 if (!SubTable->Length)
1492 AcpiOsPrintf ("Invalid zero length subtable\n");
1498 AcpiOsPrintf ("\n");
1499 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1500 SubTable->Length, InfoTable);
1501 if (ACPI_FAILURE (Status))
1507 /* Point to next sub-table */
1509 Offset += SubTable->Length;
1510 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1515 /*******************************************************************************
1517 * FUNCTION: AcpiDmDumpWdat
1519 * PARAMETERS: Table - A WDAT table
1523 * DESCRIPTION: Format the contents of a WDAT
1525 ******************************************************************************/
1529 ACPI_TABLE_HEADER *Table)
1532 UINT32 Offset = sizeof (ACPI_TABLE_WDAT);
1533 ACPI_WDAT_ENTRY *SubTable;
1538 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
1539 if (ACPI_FAILURE (Status))
1546 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
1547 while (Offset < Table->Length)
1549 /* Common sub-table header */
1551 AcpiOsPrintf ("\n");
1552 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1553 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
1554 if (ACPI_FAILURE (Status))
1559 /* Point to next sub-table */
1561 Offset += sizeof (ACPI_WDAT_ENTRY);
1562 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY));