Subversion Repositories Kolibri OS

Rev

Rev 1498 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /******************************************************************************
  2.  *
  3.  * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code
  4.  *
  5.  *****************************************************************************/
  6.  
  7. /******************************************************************************
  8.  *
  9.  * 1. Copyright Notice
  10.  *
  11.  * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
  12.  * All rights reserved.
  13.  *
  14.  * 2. License
  15.  *
  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
  19.  * property rights.
  20.  *
  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
  27.  *
  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;
  36.  *
  37.  * The above copyright and patent license is granted only if the following
  38.  * conditions are met:
  39.  *
  40.  * 3. Conditions
  41.  *
  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.
  53.  *
  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
  64.  * make.
  65.  *
  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
  70.  * distribution.
  71.  *
  72.  * 3.4. Intel retains all right, title, and interest in and to the Original
  73.  * Intel Code.
  74.  *
  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.
  79.  *
  80.  * 4. Disclaimer and Export Compliance
  81.  *
  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
  88.  * PARTICULAR PURPOSE.
  89.  *
  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
  97.  * LIMITED REMEDY.
  98.  *
  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.
  113.  *
  114.  *****************************************************************************/
  115.  
  116. #include "acpi.h"
  117. #include "accommon.h"
  118. #include "acdisasm.h"
  119. #include "actables.h"
  120.  
  121. /* This module used for application-level code only */
  122.  
  123. #define _COMPONENT          ACPI_CA_DISASSEMBLER
  124.         ACPI_MODULE_NAME    ("dmtbdump")
  125.  
  126.  
  127. static void
  128. AcpiDmValidateFadtLength (
  129.     UINT32                  Revision,
  130.     UINT32                  Length);
  131.  
  132.  
  133. /*******************************************************************************
  134.  *
  135.  * FUNCTION:    AcpiDmDumpRsdp
  136.  *
  137.  * PARAMETERS:  Table               - A RSDP
  138.  *
  139.  * RETURN:      Length of the table (there is not always a length field,
  140.  *              use revision or length if available (ACPI 2.0+))
  141.  *
  142.  * DESCRIPTION: Format the contents of a RSDP
  143.  *
  144.  ******************************************************************************/
  145.  
  146. UINT32
  147. AcpiDmDumpRsdp (
  148.     ACPI_TABLE_HEADER       *Table)
  149. {
  150.     ACPI_TABLE_RSDP         *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
  151.     UINT32                  Length = sizeof (ACPI_RSDP_COMMON);
  152.     UINT8                   Checksum;
  153.  
  154.  
  155.     /* Dump the common ACPI 1.0 portion */
  156.  
  157.     AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
  158.  
  159.     /* Validate the first checksum */
  160.  
  161.     Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON),
  162.                 Rsdp->Checksum);
  163.     if (Checksum != Rsdp->Checksum)
  164.     {
  165.         AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n",
  166.             Checksum);
  167.     }
  168.  
  169.     /* The RSDP for ACPI 2.0+ contains more data and has a Length field */
  170.  
  171.     if (Rsdp->Revision > 0)
  172.     {
  173.         Length = Rsdp->Length;
  174.         AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
  175.  
  176.         /* Validate the extended checksum over entire RSDP */
  177.  
  178.         Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP),
  179.                     Rsdp->ExtendedChecksum);
  180.         if (Checksum != Rsdp->ExtendedChecksum)
  181.         {
  182.             AcpiOsPrintf (
  183.                 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n",
  184.                 Checksum);
  185.         }
  186.     }
  187.  
  188.     return (Length);
  189. }
  190.  
  191.  
  192. /*******************************************************************************
  193.  *
  194.  * FUNCTION:    AcpiDmDumpRsdt
  195.  *
  196.  * PARAMETERS:  Table               - A RSDT
  197.  *
  198.  * RETURN:      None
  199.  *
  200.  * DESCRIPTION: Format the contents of a RSDT
  201.  *
  202.  ******************************************************************************/
  203.  
  204. void
  205. AcpiDmDumpRsdt (
  206.     ACPI_TABLE_HEADER       *Table)
  207. {
  208.     UINT32                  *Array;
  209.     UINT32                  Entries;
  210.     UINT32                  Offset;
  211.     UINT32                  i;
  212.  
  213.  
  214.     /* Point to start of table pointer array */
  215.  
  216.     Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry;
  217.     Offset = sizeof (ACPI_TABLE_HEADER);
  218.  
  219.     /* RSDT uses 32-bit pointers */
  220.  
  221.     Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
  222.  
  223.     for (i = 0; i < Entries; i++)
  224.     {
  225.         AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i);
  226.         AcpiOsPrintf ("%8.8X\n", Array[i]);
  227.         Offset += sizeof (UINT32);
  228.     }
  229. }
  230.  
  231.  
  232. /*******************************************************************************
  233.  *
  234.  * FUNCTION:    AcpiDmDumpXsdt
  235.  *
  236.  * PARAMETERS:  Table               - A XSDT
  237.  *
  238.  * RETURN:      None
  239.  *
  240.  * DESCRIPTION: Format the contents of a XSDT
  241.  *
  242.  ******************************************************************************/
  243.  
  244. void
  245. AcpiDmDumpXsdt (
  246.     ACPI_TABLE_HEADER       *Table)
  247. {
  248.     UINT64                  *Array;
  249.     UINT32                  Entries;
  250.     UINT32                  Offset;
  251.     UINT32                  i;
  252.  
  253.  
  254.     /* Point to start of table pointer array */
  255.  
  256.     Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry;
  257.     Offset = sizeof (ACPI_TABLE_HEADER);
  258.  
  259.     /* XSDT uses 64-bit pointers */
  260.  
  261.     Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
  262.  
  263.     for (i = 0; i < Entries; i++)
  264.     {
  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);
  268.     }
  269. }
  270.  
  271.  
  272. /*******************************************************************************
  273.  *
  274.  * FUNCTION:    AcpiDmDumpFadt
  275.  *
  276.  * PARAMETERS:  Table               - A FADT
  277.  *
  278.  * RETURN:      None
  279.  *
  280.  * DESCRIPTION: Format the contents of a FADT
  281.  *
  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.
  285.  *
  286.  ******************************************************************************/
  287.  
  288. void
  289. AcpiDmDumpFadt (
  290.     ACPI_TABLE_HEADER       *Table)
  291. {
  292.  
  293.     /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */
  294.  
  295.     AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1);
  296.  
  297.     /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */
  298.  
  299.     if ((Table->Length > ACPI_FADT_V1_SIZE) &&
  300.         (Table->Length <= ACPI_FADT_V2_SIZE))
  301.     {
  302.         AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2);
  303.     }
  304.  
  305.     /* Check for FADT revision 3 fields and up (ACPI 2.0+ extended data) */
  306.  
  307.     else if (Table->Length > ACPI_FADT_V2_SIZE)
  308.     {
  309.         AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3);
  310.     }
  311.  
  312.     /* Validate various fields in the FADT, including length */
  313.  
  314.     AcpiTbCreateLocalFadt (Table, Table->Length);
  315.  
  316.     /* Validate FADT length against the revision */
  317.  
  318.     AcpiDmValidateFadtLength (Table->Revision, Table->Length);
  319. }
  320.  
  321.  
  322. /*******************************************************************************
  323.  *
  324.  * FUNCTION:    AcpiDmValidateFadtLength
  325.  *
  326.  * PARAMETERS:  Revision            - FADT revision (Header->Revision)
  327.  *              Length              - FADT length (Header->Length
  328.  *
  329.  * RETURN:      None
  330.  *
  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.
  335.  *
  336.  ******************************************************************************/
  337.  
  338. static void
  339. AcpiDmValidateFadtLength (
  340.     UINT32                  Revision,
  341.     UINT32                  Length)
  342. {
  343.     UINT32                  ExpectedLength;
  344.  
  345.  
  346.     switch (Revision)
  347.     {
  348.     case 0:
  349.         AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n");
  350.         return;
  351.  
  352.     case 1:
  353.         ExpectedLength = ACPI_FADT_V1_SIZE;
  354.         break;
  355.  
  356.     case 2:
  357.         ExpectedLength = ACPI_FADT_V2_SIZE;
  358.         break;
  359.  
  360.     case 3:
  361.     case 4:
  362.         ExpectedLength = ACPI_FADT_V3_SIZE;
  363.         break;
  364.  
  365.     default:
  366.         return;
  367.     }
  368.  
  369.     if (Length == ExpectedLength)
  370.     {
  371.         return;
  372.     }
  373.  
  374.     AcpiOsPrintf (
  375.         "\n// ACPI Warning: FADT revision %X does not match length: found %X expected %X\n",
  376.         Revision, Length, ExpectedLength);
  377. }
  378.  
  379.  
  380. /*******************************************************************************
  381.  *
  382.  * FUNCTION:    AcpiDmDumpAsf
  383.  *
  384.  * PARAMETERS:  Table               - A ASF table
  385.  *
  386.  * RETURN:      None
  387.  *
  388.  * DESCRIPTION: Format the contents of a ASF table
  389.  *
  390.  ******************************************************************************/
  391.  
  392. void
  393. AcpiDmDumpAsf (
  394.     ACPI_TABLE_HEADER       *Table)
  395. {
  396.     ACPI_STATUS             Status;
  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;
  405.     UINT32                  i;
  406.     UINT8                   Type;
  407.  
  408.  
  409.     /* No main table, only sub-tables */
  410.  
  411.     SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
  412.     while (Offset < Table->Length)
  413.     {
  414.         /* Common sub-table header */
  415.  
  416.         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
  417.                     SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
  418.         if (ACPI_FAILURE (Status))
  419.         {
  420.             return;
  421.         }
  422.  
  423.         /* The actual type is the lower 7 bits of Type */
  424.  
  425.         Type = (UINT8) (SubTable->Header.Type & 0x7F);
  426.  
  427.         switch (Type)
  428.         {
  429.         case ACPI_ASF_TYPE_INFO:
  430.             InfoTable = AcpiDmTableInfoAsf0;
  431.             break;
  432.  
  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);
  440.             break;
  441.  
  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);
  449.             break;
  450.  
  451.         case ACPI_ASF_TYPE_BOOT:
  452.             InfoTable = AcpiDmTableInfoAsf3;
  453.             break;
  454.  
  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);
  460.             break;
  461.  
  462.         default:
  463.             AcpiOsPrintf ("\n**** Unknown ASF sub-table type 0x%X\n", SubTable->Header.Type);
  464.             return;
  465.         }
  466.  
  467.         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
  468.                     SubTable->Header.Length, InfoTable);
  469.         if (ACPI_FAILURE (Status))
  470.         {
  471.             return;
  472.         }
  473.  
  474.         /* Dump variable-length extra data */
  475.  
  476.         switch (Type)
  477.         {
  478.         case ACPI_ASF_TYPE_ALERT:
  479.         case ACPI_ASF_TYPE_CONTROL:
  480.  
  481.             for (i = 0; i < DataCount; i++)
  482.             {
  483.                 AcpiOsPrintf ("\n");
  484.                 Status = AcpiDmDumpTable (Table->Length, DataOffset,
  485.                             DataTable, DataLength, DataInfoTable);
  486.                 if (ACPI_FAILURE (Status))
  487.                 {
  488.                     return;
  489.                 }
  490.  
  491.                 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
  492.                 DataOffset += DataLength;
  493.             }
  494.             break;
  495.  
  496.         case ACPI_ASF_TYPE_ADDRESS:
  497.  
  498.             for (i = 0; i < DataLength; i++)
  499.             {
  500.                 if (!(i % 16))
  501.                 {
  502.                     AcpiDmLineHeader (DataOffset, 1, "Addresses");
  503.                 }
  504.  
  505.                 AcpiOsPrintf ("%2.2X ", *DataTable);
  506.                 DataTable++;
  507.                 DataOffset++;
  508.                 if (DataOffset > Table->Length)
  509.                 {
  510.                     AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
  511.                     return;
  512.                 }
  513.             }
  514.  
  515.             AcpiOsPrintf ("\n");
  516.             break;
  517.  
  518.         default:
  519.             break;
  520.         }
  521.  
  522.         AcpiOsPrintf ("\n");
  523.  
  524.         /* Point to next sub-table */
  525.  
  526.         if (!SubTable->Header.Length)
  527.         {
  528.             AcpiOsPrintf ("Invalid zero subtable header length\n");
  529.             return;
  530.         }
  531.  
  532.         Offset += SubTable->Header.Length;
  533.         SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length);
  534.     }
  535. }
  536.  
  537.  
  538. /*******************************************************************************
  539.  *
  540.  * FUNCTION:    AcpiDmDumpCpep
  541.  *
  542.  * PARAMETERS:  Table               - A CPEP table
  543.  *
  544.  * RETURN:      None
  545.  *
  546.  * DESCRIPTION: Format the contents of a CPEP. This table type consists
  547.  *              of an open-ended number of subtables.
  548.  *
  549.  ******************************************************************************/
  550.  
  551. void
  552. AcpiDmDumpCpep (
  553.     ACPI_TABLE_HEADER       *Table)
  554. {
  555.     ACPI_STATUS             Status;
  556.     ACPI_CPEP_POLLING       *SubTable;
  557.     UINT32                  Length = Table->Length;
  558.     UINT32                  Offset = sizeof (ACPI_TABLE_CPEP);
  559.  
  560.  
  561.     /* Main table */
  562.  
  563.     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
  564.     if (ACPI_FAILURE (Status))
  565.     {
  566.         return;
  567.     }
  568.  
  569.     /* Sub-tables */
  570.  
  571.     SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
  572.     while (Offset < Table->Length)
  573.     {
  574.         AcpiOsPrintf ("\n");
  575.         Status = AcpiDmDumpTable (Length, Offset, SubTable,
  576.                     SubTable->Header.Length, AcpiDmTableInfoCpep0);
  577.         if (ACPI_FAILURE (Status))
  578.         {
  579.             return;
  580.         }
  581.  
  582.         /* Point to next sub-table */
  583.  
  584.         Offset += SubTable->Header.Length;
  585.         SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable,
  586.                     SubTable->Header.Length);
  587.     }
  588. }
  589.  
  590.  
  591. /*******************************************************************************
  592.  *
  593.  * FUNCTION:    AcpiDmDumpDmar
  594.  *
  595.  * PARAMETERS:  Table               - A DMAR table
  596.  *
  597.  * RETURN:      None
  598.  *
  599.  * DESCRIPTION: Format the contents of a DMAR. This table type consists
  600.  *              of an open-ended number of subtables.
  601.  *
  602.  ******************************************************************************/
  603.  
  604. void
  605. AcpiDmDumpDmar (
  606.     ACPI_TABLE_HEADER       *Table)
  607. {
  608.     ACPI_STATUS             Status;
  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;
  614.     UINT32                  ScopeOffset;
  615.     UINT8                   *PciPath;
  616.     UINT32                  PathOffset;
  617.  
  618.  
  619.     /* Main table */
  620.  
  621.     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
  622.     if (ACPI_FAILURE (Status))
  623.     {
  624.         return;
  625.     }
  626.  
  627.     /* Sub-tables */
  628.  
  629.     SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
  630.     while (Offset < Table->Length)
  631.     {
  632.         /* Common sub-table header */
  633.  
  634.         AcpiOsPrintf ("\n");
  635.         Status = AcpiDmDumpTable (Length, Offset, SubTable,
  636.                     SubTable->Length, AcpiDmTableInfoDmarHdr);
  637.         if (ACPI_FAILURE (Status))
  638.         {
  639.             return;
  640.         }
  641.  
  642.         switch (SubTable->Type)
  643.         {
  644.         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
  645.             InfoTable = AcpiDmTableInfoDmar0;
  646.             ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
  647.             break;
  648.         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
  649.             InfoTable = AcpiDmTableInfoDmar1;
  650.             ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
  651.             break;
  652.         case ACPI_DMAR_TYPE_ATSR:
  653.             InfoTable = AcpiDmTableInfoDmar2;
  654.             ScopeOffset = sizeof (ACPI_DMAR_ATSR);
  655.             break;
  656.         case ACPI_DMAR_HARDWARE_AFFINITY:
  657.             InfoTable = AcpiDmTableInfoDmar3;
  658.             ScopeOffset = sizeof (ACPI_DMAR_RHSA);
  659.             break;
  660.         default:
  661.             AcpiOsPrintf ("\n**** Unknown DMAR sub-table type 0x%X\n\n", SubTable->Type);
  662.             return;
  663.         }
  664.  
  665.         Status = AcpiDmDumpTable (Length, Offset, SubTable,
  666.                     SubTable->Length, InfoTable);
  667.         if (ACPI_FAILURE (Status))
  668.         {
  669.             return;
  670.         }
  671.  
  672.         /* Dump the device scope entries (if any) */
  673.  
  674.         ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
  675.         while (ScopeOffset < SubTable->Length)
  676.         {
  677.             AcpiOsPrintf ("\n");
  678.             Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
  679.                         ScopeTable->Length, AcpiDmTableInfoDmarScope);
  680.             if (ACPI_FAILURE (Status))
  681.             {
  682.                 return;
  683.             }
  684.  
  685.             /* Dump the PCI Path entries for this device scope */
  686.  
  687.             PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
  688.  
  689.             PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
  690.                 sizeof (ACPI_DMAR_DEVICE_SCOPE));
  691.  
  692.             while (PathOffset < ScopeTable->Length)
  693.             {
  694.                 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path");
  695.                 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
  696.  
  697.                 /* Point to next PCI Path entry */
  698.  
  699.                 PathOffset += 2;
  700.                 PciPath += 2;
  701.             }
  702.  
  703.             /* Point to next device scope entry */
  704.  
  705.             ScopeOffset += ScopeTable->Length;
  706.             ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
  707.                 ScopeTable, ScopeTable->Length);
  708.         }
  709.  
  710.         /* Point to next sub-table */
  711.  
  712.         Offset += SubTable->Length;
  713.         SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length);
  714.     }
  715. }
  716.  
  717.  
  718. /*******************************************************************************
  719.  *
  720.  * FUNCTION:    AcpiDmDumpEinj
  721.  *
  722.  * PARAMETERS:  Table               - A EINJ table
  723.  *
  724.  * RETURN:      None
  725.  *
  726.  * DESCRIPTION: Format the contents of a EINJ. This table type consists
  727.  *              of an open-ended number of subtables.
  728.  *
  729.  ******************************************************************************/
  730.  
  731. void
  732. AcpiDmDumpEinj (
  733.     ACPI_TABLE_HEADER       *Table)
  734. {
  735.     ACPI_STATUS             Status;
  736.     ACPI_WHEA_HEADER        *SubTable;
  737.     UINT32                  Length = Table->Length;
  738.     UINT32                  Offset = sizeof (ACPI_TABLE_EINJ);
  739.  
  740.  
  741.     /* Main table */
  742.  
  743.     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
  744.     if (ACPI_FAILURE (Status))
  745.     {
  746.         return;
  747.     }
  748.  
  749.     /* Sub-tables */
  750.  
  751.     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
  752.     while (Offset < Table->Length)
  753.     {
  754.         AcpiOsPrintf ("\n");
  755.         Status = AcpiDmDumpTable (Length, Offset, SubTable,
  756.                     sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
  757.         if (ACPI_FAILURE (Status))
  758.         {
  759.             return;
  760.         }
  761.  
  762.         /* Point to next sub-table (each subtable is of fixed length) */
  763.  
  764.         Offset += sizeof (ACPI_WHEA_HEADER);
  765.         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
  766.                         sizeof (ACPI_WHEA_HEADER));
  767.     }
  768. }
  769.  
  770.  
  771. /*******************************************************************************
  772.  *
  773.  * FUNCTION:    AcpiDmDumpErst
  774.  *
  775.  * PARAMETERS:  Table               - A ERST table
  776.  *
  777.  * RETURN:      None
  778.  *
  779.  * DESCRIPTION: Format the contents of a ERST. This table type consists
  780.  *              of an open-ended number of subtables.
  781.  *
  782.  ******************************************************************************/
  783.  
  784. void
  785. AcpiDmDumpErst (
  786.     ACPI_TABLE_HEADER       *Table)
  787. {
  788.     ACPI_STATUS             Status;
  789.     ACPI_WHEA_HEADER        *SubTable;
  790.     UINT32                  Length = Table->Length;
  791.     UINT32                  Offset = sizeof (ACPI_TABLE_ERST);
  792.  
  793.  
  794.     /* Main table */
  795.  
  796.     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
  797.     if (ACPI_FAILURE (Status))
  798.     {
  799.         return;
  800.     }
  801.  
  802.     /* Sub-tables */
  803.  
  804.     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
  805.     while (Offset < Table->Length)
  806.     {
  807.         AcpiOsPrintf ("\n");
  808.         Status = AcpiDmDumpTable (Length, Offset, SubTable,
  809.                     sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
  810.         if (ACPI_FAILURE (Status))
  811.         {
  812.             return;
  813.         }
  814.  
  815.         /* Point to next sub-table (each subtable is of fixed length) */
  816.  
  817.         Offset += sizeof (ACPI_WHEA_HEADER);
  818.         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
  819.                         sizeof (ACPI_WHEA_HEADER));
  820.     }
  821. }
  822.  
  823.  
  824. /*******************************************************************************
  825.  *
  826.  * FUNCTION:    AcpiDmDumpHest
  827.  *
  828.  * PARAMETERS:  Table               - A HEST table
  829.  *
  830.  * RETURN:      None
  831.  *
  832.  * DESCRIPTION: Format the contents of a HEST. This table type consists
  833.  *              of an open-ended number of subtables.
  834.  *
  835.  ******************************************************************************/
  836.  
  837. void
  838. AcpiDmDumpHest (
  839.     ACPI_TABLE_HEADER       *Table)
  840. {
  841.     ACPI_STATUS             Status;
  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;
  847.     UINT32                  BankCount;
  848.     ACPI_HEST_IA_ERROR_BANK *BankTable;
  849.  
  850.  
  851.     /* Main table */
  852.  
  853.     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
  854.     if (ACPI_FAILURE (Status))
  855.     {
  856.         return;
  857.     }
  858.  
  859.     /* Sub-tables */
  860.  
  861.     SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
  862.     while (Offset < Table->Length)
  863.     {
  864.         BankCount = 0;
  865.         switch (SubTable->Type)
  866.         {
  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;
  872.             break;
  873.  
  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;
  879.             break;
  880.  
  881.         case ACPI_HEST_TYPE_IA32_NMI:
  882.             InfoTable = AcpiDmTableInfoHest2;
  883.             SubTableLength = sizeof (ACPI_HEST_IA_NMI);
  884.             break;
  885.  
  886.         case ACPI_HEST_TYPE_AER_ROOT_PORT:
  887.             InfoTable = AcpiDmTableInfoHest6;
  888.             SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
  889.             break;
  890.  
  891.         case ACPI_HEST_TYPE_AER_ENDPOINT:
  892.             InfoTable = AcpiDmTableInfoHest7;
  893.             SubTableLength = sizeof (ACPI_HEST_AER);
  894.             break;
  895.  
  896.         case ACPI_HEST_TYPE_AER_BRIDGE:
  897.             InfoTable = AcpiDmTableInfoHest8;
  898.             SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
  899.             break;
  900.  
  901.         case ACPI_HEST_TYPE_GENERIC_ERROR:
  902.             InfoTable = AcpiDmTableInfoHest9;
  903.             SubTableLength = sizeof (ACPI_HEST_GENERIC);
  904.             break;
  905.  
  906.         default:
  907.             /* Cannot continue on unknown type - no length */
  908.  
  909.             AcpiOsPrintf ("\n**** Unknown HEST sub-table type 0x%X\n", SubTable->Type);
  910.             return;
  911.         }
  912.  
  913.         AcpiOsPrintf ("\n");
  914.         Status = AcpiDmDumpTable (Length, Offset, SubTable,
  915.                     SubTableLength, InfoTable);
  916.         if (ACPI_FAILURE (Status))
  917.         {
  918.             return;
  919.         }
  920.  
  921.         /* Point to end of current subtable (each subtable above is of fixed length) */
  922.  
  923.         Offset += SubTableLength;
  924.  
  925.         /* If there are any (fixed-length) Error Banks from above, dump them now */
  926.  
  927.         if (BankCount)
  928.         {
  929.             BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength);
  930.             SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
  931.  
  932.             while (BankCount)
  933.             {
  934.                 AcpiOsPrintf ("\n");
  935.                 Status = AcpiDmDumpTable (Length, Offset, BankTable,
  936.                             sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
  937.                 if (ACPI_FAILURE (Status))
  938.                 {
  939.                     return;
  940.                 }
  941.                 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
  942.                 BankTable++;
  943.                 BankCount--;
  944.             }
  945.         }
  946.  
  947.         /* Point to next sub-table */
  948.  
  949.         SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
  950.     }
  951. }
  952.  
  953.  
  954. /*******************************************************************************
  955.  *
  956.  * FUNCTION:    AcpiDmDumpIvrs
  957.  *
  958.  * PARAMETERS:  Table               - A IVRS table
  959.  *
  960.  * RETURN:      None
  961.  *
  962.  * DESCRIPTION: Format the contents of a IVRS
  963.  *
  964.  ******************************************************************************/
  965.  
  966. static UINT8 EntrySizes[] = {4,8,16,32};
  967.  
  968. void
  969. AcpiDmDumpIvrs (
  970.     ACPI_TABLE_HEADER       *Table)
  971. {
  972.     ACPI_STATUS             Status;
  973.     UINT32                  Offset = sizeof (ACPI_TABLE_IVRS);
  974.     UINT32                  EntryOffset;
  975.     UINT32                  EntryLength;
  976.     UINT32                  EntryType;
  977.     ACPI_IVRS_DE_HEADER     *DeviceEntry;
  978.     ACPI_IVRS_HEADER        *SubTable;
  979.     ACPI_DMTABLE_INFO       *InfoTable;
  980.  
  981.  
  982.     /* Main table */
  983.  
  984.     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
  985.     if (ACPI_FAILURE (Status))
  986.     {
  987.         return;
  988.     }
  989.  
  990.     /* Sub-tables */
  991.  
  992.     SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
  993.     while (Offset < Table->Length)
  994.     {
  995.         /* Common sub-table header */
  996.  
  997.         AcpiOsPrintf ("\n");
  998.         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
  999.                     SubTable->Length, AcpiDmTableInfoIvrsHdr);
  1000.         if (ACPI_FAILURE (Status))
  1001.         {
  1002.             return;
  1003.         }
  1004.  
  1005.         switch (SubTable->Type)
  1006.         {
  1007.         case ACPI_IVRS_TYPE_HARDWARE:
  1008.             InfoTable = AcpiDmTableInfoIvrs0;
  1009.             break;
  1010.         case ACPI_IVRS_TYPE_MEMORY1:
  1011.         case ACPI_IVRS_TYPE_MEMORY2:
  1012.         case ACPI_IVRS_TYPE_MEMORY3:
  1013.             InfoTable = AcpiDmTableInfoIvrs1;
  1014.             break;
  1015.         default:
  1016.             AcpiOsPrintf ("\n**** Unknown IVRS sub-table type 0x%X\n",
  1017.                 SubTable->Type);
  1018.  
  1019.             /* Attempt to continue */
  1020.  
  1021.             if (!SubTable->Length)
  1022.             {
  1023.                 AcpiOsPrintf ("Invalid zero length subtable\n");
  1024.                 return;
  1025.             }
  1026.             goto NextSubTable;
  1027.         }
  1028.  
  1029.         /* Dump the subtable */
  1030.  
  1031.         AcpiOsPrintf ("\n");
  1032.         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
  1033.                     SubTable->Length, InfoTable);
  1034.         if (ACPI_FAILURE (Status))
  1035.         {
  1036.             return;
  1037.         }
  1038.  
  1039.         /* The hardware subtable can contain multiple device entries */
  1040.  
  1041.         if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
  1042.         {
  1043.             EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
  1044.             DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
  1045.                             sizeof (ACPI_IVRS_HARDWARE));
  1046.  
  1047.             while (EntryOffset < (Offset + SubTable->Length))
  1048.             {
  1049.                 AcpiOsPrintf ("\n");
  1050.                 /*
  1051.                  * Upper 2 bits of Type encode the length of the device entry
  1052.                  *
  1053.                  * 00 = 4 byte
  1054.                  * 01 = 8 byte
  1055.                  * 10 = 16 byte - currently no entries defined
  1056.                  * 11 = 32 byte - currently no entries defined
  1057.                  */
  1058.                 EntryType = DeviceEntry->Type;
  1059.                 EntryLength = EntrySizes [EntryType >> 6];
  1060.  
  1061.                 switch (EntryType)
  1062.                 {
  1063.                 /* 4-byte device entries */
  1064.  
  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:
  1070.  
  1071.                     InfoTable = AcpiDmTableInfoIvrs4;
  1072.                     break;
  1073.  
  1074.                 /* 8-byte entries, type A */
  1075.  
  1076.                 case ACPI_IVRS_TYPE_ALIAS_SELECT:
  1077.                 case ACPI_IVRS_TYPE_ALIAS_START:
  1078.  
  1079.                     InfoTable = AcpiDmTableInfoIvrs8a;
  1080.                     break;
  1081.  
  1082.                 /* 8-byte entries, type B */
  1083.  
  1084.                 case ACPI_IVRS_TYPE_PAD8:
  1085.                 case ACPI_IVRS_TYPE_EXT_SELECT:
  1086.                 case ACPI_IVRS_TYPE_EXT_START:
  1087.  
  1088.                     InfoTable = AcpiDmTableInfoIvrs8b;
  1089.                     break;
  1090.  
  1091.                 /* 8-byte entries, type C */
  1092.  
  1093.                 case ACPI_IVRS_TYPE_SPECIAL:
  1094.  
  1095.                     InfoTable = AcpiDmTableInfoIvrs8c;
  1096.                     break;
  1097.  
  1098.                 default:
  1099.                     InfoTable = AcpiDmTableInfoIvrs4;
  1100.                     AcpiOsPrintf (
  1101.                         "\n**** Unknown IVRS device entry type/length: "
  1102.                         "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
  1103.                         EntryType, EntryLength, EntryOffset);
  1104.                     break;
  1105.                 }
  1106.  
  1107.                 /* Dump the Device Entry */
  1108.  
  1109.                 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
  1110.                             DeviceEntry, EntryLength, InfoTable);
  1111.  
  1112.                 EntryOffset += EntryLength;
  1113.                 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
  1114.                                 EntryLength);
  1115.             }
  1116.         }
  1117.  
  1118. NextSubTable:
  1119.         /* Point to next sub-table */
  1120.  
  1121.         Offset += SubTable->Length;
  1122.         SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
  1123.     }
  1124. }
  1125.  
  1126.  
  1127. /*******************************************************************************
  1128.  *
  1129.  * FUNCTION:    AcpiDmDumpMadt
  1130.  *
  1131.  * PARAMETERS:  Table               - A MADT table
  1132.  *
  1133.  * RETURN:      None
  1134.  *
  1135.  * DESCRIPTION: Format the contents of a MADT. This table type consists
  1136.  *              of an open-ended number of subtables.
  1137.  *
  1138.  ******************************************************************************/
  1139.  
  1140. void
  1141. AcpiDmDumpMadt (
  1142.     ACPI_TABLE_HEADER       *Table)
  1143. {
  1144.     ACPI_STATUS             Status;
  1145.     ACPI_SUBTABLE_HEADER    *SubTable;
  1146.     UINT32                  Length = Table->Length;
  1147.     UINT32                  Offset = sizeof (ACPI_TABLE_MADT);
  1148.     ACPI_DMTABLE_INFO       *InfoTable;
  1149.  
  1150.  
  1151.     /* Main table */
  1152.  
  1153.     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
  1154.     if (ACPI_FAILURE (Status))
  1155.     {
  1156.         return;
  1157.     }
  1158.  
  1159.     /* Sub-tables */
  1160.  
  1161.     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
  1162.     while (Offset < Table->Length)
  1163.     {
  1164.         /* Common sub-table header */
  1165.  
  1166.         AcpiOsPrintf ("\n");
  1167.         Status = AcpiDmDumpTable (Length, Offset, SubTable,
  1168.                     SubTable->Length, AcpiDmTableInfoMadtHdr);
  1169.         if (ACPI_FAILURE (Status))
  1170.         {
  1171.             return;
  1172.         }
  1173.  
  1174.         switch (SubTable->Type)
  1175.         {
  1176.         case ACPI_MADT_TYPE_LOCAL_APIC:
  1177.             InfoTable = AcpiDmTableInfoMadt0;
  1178.             break;
  1179.         case ACPI_MADT_TYPE_IO_APIC:
  1180.             InfoTable = AcpiDmTableInfoMadt1;
  1181.             break;
  1182.         case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
  1183.             InfoTable = AcpiDmTableInfoMadt2;
  1184.             break;
  1185.         case ACPI_MADT_TYPE_NMI_SOURCE:
  1186.             InfoTable = AcpiDmTableInfoMadt3;
  1187.             break;
  1188.         case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
  1189.             InfoTable = AcpiDmTableInfoMadt4;
  1190.             break;
  1191.         case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
  1192.             InfoTable = AcpiDmTableInfoMadt5;
  1193.             break;
  1194.         case ACPI_MADT_TYPE_IO_SAPIC:
  1195.             InfoTable = AcpiDmTableInfoMadt6;
  1196.             break;
  1197.         case ACPI_MADT_TYPE_LOCAL_SAPIC:
  1198.             InfoTable = AcpiDmTableInfoMadt7;
  1199.             break;
  1200.         case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
  1201.             InfoTable = AcpiDmTableInfoMadt8;
  1202.             break;
  1203.         case ACPI_MADT_TYPE_LOCAL_X2APIC:
  1204.             InfoTable = AcpiDmTableInfoMadt9;
  1205.             break;
  1206.         case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
  1207.             InfoTable = AcpiDmTableInfoMadt10;
  1208.             break;
  1209.         default:
  1210.             AcpiOsPrintf ("\n**** Unknown MADT sub-table type 0x%X\n\n", SubTable->Type);
  1211.  
  1212.             /* Attempt to continue */
  1213.  
  1214.             if (!SubTable->Length)
  1215.             {
  1216.                 AcpiOsPrintf ("Invalid zero length subtable\n");
  1217.                 return;
  1218.             }
  1219.             goto NextSubTable;
  1220.         }
  1221.  
  1222.         Status = AcpiDmDumpTable (Length, Offset, SubTable,
  1223.                     SubTable->Length, InfoTable);
  1224.         if (ACPI_FAILURE (Status))
  1225.         {
  1226.             return;
  1227.         }
  1228.  
  1229. NextSubTable:
  1230.         /* Point to next sub-table */
  1231.  
  1232.         Offset += SubTable->Length;
  1233.         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
  1234.     }
  1235. }
  1236.  
  1237.  
  1238. /*******************************************************************************
  1239.  *
  1240.  * FUNCTION:    AcpiDmDumpMcfg
  1241.  *
  1242.  * PARAMETERS:  Table               - A MCFG Table
  1243.  *
  1244.  * RETURN:      None
  1245.  *
  1246.  * DESCRIPTION: Format the contents of a MCFG table
  1247.  *
  1248.  ******************************************************************************/
  1249.  
  1250. void
  1251. AcpiDmDumpMcfg (
  1252.     ACPI_TABLE_HEADER       *Table)
  1253. {
  1254.     ACPI_STATUS             Status;
  1255.     UINT32                  Offset = sizeof (ACPI_TABLE_MCFG);
  1256.     ACPI_MCFG_ALLOCATION    *SubTable;
  1257.  
  1258.  
  1259.     /* Main table */
  1260.  
  1261.     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
  1262.     if (ACPI_FAILURE (Status))
  1263.     {
  1264.         return;
  1265.     }
  1266.  
  1267.     /* Sub-tables */
  1268.  
  1269.     SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
  1270.     while (Offset < Table->Length)
  1271.     {
  1272.         if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
  1273.         {
  1274.             AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
  1275.                 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
  1276.             return;
  1277.         }
  1278.  
  1279.         AcpiOsPrintf ("\n");
  1280.         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
  1281.                     sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
  1282.         if (ACPI_FAILURE (Status))
  1283.         {
  1284.             return;
  1285.         }
  1286.  
  1287.         /* Point to next sub-table (each subtable is of fixed length) */
  1288.  
  1289.         Offset += sizeof (ACPI_MCFG_ALLOCATION);
  1290.         SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
  1291.                         sizeof (ACPI_MCFG_ALLOCATION));
  1292.     }
  1293. }
  1294.  
  1295.  
  1296. /*******************************************************************************
  1297.  *
  1298.  * FUNCTION:    AcpiDmDumpMsct
  1299.  *
  1300.  * PARAMETERS:  Table               - A MSCT table
  1301.  *
  1302.  * RETURN:      None
  1303.  *
  1304.  * DESCRIPTION: Format the contents of a MSCT
  1305.  *
  1306.  ******************************************************************************/
  1307.  
  1308. void
  1309. AcpiDmDumpMsct (
  1310.     ACPI_TABLE_HEADER       *Table)
  1311. {
  1312.     ACPI_STATUS             Status;
  1313.     UINT32                  Offset = sizeof (ACPI_TABLE_MSCT);
  1314.     ACPI_MSCT_PROXIMITY     *SubTable;
  1315.  
  1316.  
  1317.     /* Main table */
  1318.  
  1319.     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
  1320.     if (ACPI_FAILURE (Status))
  1321.     {
  1322.         return;
  1323.     }
  1324.  
  1325.     /* Sub-tables */
  1326.  
  1327.     SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
  1328.     while (Offset < Table->Length)
  1329.     {
  1330.         /* Common sub-table header */
  1331.  
  1332.         AcpiOsPrintf ("\n");
  1333.         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
  1334.                     sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
  1335.         if (ACPI_FAILURE (Status))
  1336.         {
  1337.             return;
  1338.         }
  1339.  
  1340.         /* Point to next sub-table */
  1341.  
  1342.         Offset += sizeof (ACPI_MSCT_PROXIMITY);
  1343.         SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY));
  1344.     }
  1345. }
  1346.  
  1347.  
  1348. /*******************************************************************************
  1349.  *
  1350.  * FUNCTION:    AcpiDmDumpSlic
  1351.  *
  1352.  * PARAMETERS:  Table               - A SLIC table
  1353.  *
  1354.  * RETURN:      None
  1355.  *
  1356.  * DESCRIPTION: Format the contents of a SLIC
  1357.  *
  1358.  ******************************************************************************/
  1359.  
  1360. void
  1361. AcpiDmDumpSlic (
  1362.     ACPI_TABLE_HEADER       *Table)
  1363. {
  1364.     ACPI_STATUS             Status;
  1365.     UINT32                  Offset = sizeof (ACPI_TABLE_SLIC);
  1366.     ACPI_SLIC_HEADER        *SubTable;
  1367.     ACPI_DMTABLE_INFO       *InfoTable;
  1368.  
  1369.  
  1370.     /* There is no main SLIC table, only subtables */
  1371.  
  1372.     SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, Table, Offset);
  1373.     while (Offset < Table->Length)
  1374.     {
  1375.         /* Common sub-table header */
  1376.  
  1377.         AcpiOsPrintf ("\n");
  1378.         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
  1379.                     SubTable->Length, AcpiDmTableInfoSlicHdr);
  1380.         if (ACPI_FAILURE (Status))
  1381.         {
  1382.             return;
  1383.         }
  1384.  
  1385.         switch (SubTable->Type)
  1386.         {
  1387.         case ACPI_SLIC_TYPE_PUBLIC_KEY:
  1388.             InfoTable = AcpiDmTableInfoSlic0;
  1389.             break;
  1390.         case ACPI_SLIC_TYPE_WINDOWS_MARKER:
  1391.             InfoTable = AcpiDmTableInfoSlic1;
  1392.             break;
  1393.         default:
  1394.             AcpiOsPrintf ("\n**** Unknown SLIC sub-table type 0x%X\n", SubTable->Type);
  1395.  
  1396.             /* Attempt to continue */
  1397.  
  1398.             if (!SubTable->Length)
  1399.             {
  1400.                 AcpiOsPrintf ("Invalid zero length subtable\n");
  1401.                 return;
  1402.             }
  1403.             goto NextSubTable;
  1404.         }
  1405.  
  1406.         AcpiOsPrintf ("\n");
  1407.         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
  1408.                     SubTable->Length, InfoTable);
  1409.         if (ACPI_FAILURE (Status))
  1410.         {
  1411.             return;
  1412.         }
  1413.  
  1414. NextSubTable:
  1415.         /* Point to next sub-table */
  1416.  
  1417.         Offset += SubTable->Length;
  1418.         SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, SubTable, SubTable->Length);
  1419.     }
  1420. }
  1421.  
  1422.  
  1423. /*******************************************************************************
  1424.  *
  1425.  * FUNCTION:    AcpiDmDumpSlit
  1426.  *
  1427.  * PARAMETERS:  Table               - An SLIT
  1428.  *
  1429.  * RETURN:      None
  1430.  *
  1431.  * DESCRIPTION: Format the contents of a SLIT
  1432.  *
  1433.  ******************************************************************************/
  1434.  
  1435. void
  1436. AcpiDmDumpSlit (
  1437.     ACPI_TABLE_HEADER       *Table)
  1438. {
  1439.     ACPI_STATUS             Status;
  1440.     UINT32                  Offset;
  1441.     UINT8                   *Row;
  1442.     UINT32                  Localities;
  1443.     UINT32                  i;
  1444.     UINT32                  j;
  1445.  
  1446.  
  1447.     /* Main table */
  1448.  
  1449.     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
  1450.     if (ACPI_FAILURE (Status))
  1451.     {
  1452.         return;
  1453.     }
  1454.  
  1455.     /* Display the Locality NxN Matrix */
  1456.  
  1457.     Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
  1458.     Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
  1459.     Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
  1460.  
  1461.     for (i = 0; i < Localities; i++)
  1462.     {
  1463.         /* Display one row of the matrix */
  1464.  
  1465.         AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
  1466.         for  (j = 0; j < Localities; j++)
  1467.         {
  1468.             /* Check for beyond EOT */
  1469.  
  1470.             if (Offset >= Table->Length)
  1471.             {
  1472.                 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n");
  1473.                 return;
  1474.             }
  1475.  
  1476.             AcpiOsPrintf ("%2.2X", Row[j]);
  1477.             Offset++;
  1478.  
  1479.             /* Display up to 16 bytes per output row */
  1480.  
  1481.             if ((j+1) < Localities)
  1482.             {
  1483.                 AcpiOsPrintf (" ");
  1484.  
  1485.                 if (j && (((j+1) % 16) == 0))
  1486.                 {
  1487.                     AcpiOsPrintf ("\\\n"); /* With line continuation char */
  1488.                     AcpiDmLineHeader (Offset, 0, NULL);
  1489.                 }
  1490.             }
  1491.         }
  1492.  
  1493.         /* Point to next row */
  1494.  
  1495.         AcpiOsPrintf ("\n");
  1496.         Row += Localities;
  1497.     }
  1498. }
  1499.  
  1500.  
  1501. /*******************************************************************************
  1502.  *
  1503.  * FUNCTION:    AcpiDmDumpSrat
  1504.  *
  1505.  * PARAMETERS:  Table               - A SRAT table
  1506.  *
  1507.  * RETURN:      None
  1508.  *
  1509.  * DESCRIPTION: Format the contents of a SRAT
  1510.  *
  1511.  ******************************************************************************/
  1512.  
  1513. void
  1514. AcpiDmDumpSrat (
  1515.     ACPI_TABLE_HEADER       *Table)
  1516. {
  1517.     ACPI_STATUS             Status;
  1518.     UINT32                  Offset = sizeof (ACPI_TABLE_SRAT);
  1519.     ACPI_SUBTABLE_HEADER    *SubTable;
  1520.     ACPI_DMTABLE_INFO       *InfoTable;
  1521.  
  1522.  
  1523.     /* Main table */
  1524.  
  1525.     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
  1526.     if (ACPI_FAILURE (Status))
  1527.     {
  1528.         return;
  1529.     }
  1530.  
  1531.     /* Sub-tables */
  1532.  
  1533.     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
  1534.     while (Offset < Table->Length)
  1535.     {
  1536.         /* Common sub-table header */
  1537.  
  1538.         AcpiOsPrintf ("\n");
  1539.         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
  1540.                     SubTable->Length, AcpiDmTableInfoSratHdr);
  1541.         if (ACPI_FAILURE (Status))
  1542.         {
  1543.             return;
  1544.         }
  1545.  
  1546.         switch (SubTable->Type)
  1547.         {
  1548.         case ACPI_SRAT_TYPE_CPU_AFFINITY:
  1549.             InfoTable = AcpiDmTableInfoSrat0;
  1550.             break;
  1551.         case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
  1552.             InfoTable = AcpiDmTableInfoSrat1;
  1553.             break;
  1554.         case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
  1555.             InfoTable = AcpiDmTableInfoSrat2;
  1556.             break;
  1557.         default:
  1558.             AcpiOsPrintf ("\n**** Unknown SRAT sub-table type 0x%X\n", SubTable->Type);
  1559.  
  1560.             /* Attempt to continue */
  1561.  
  1562.             if (!SubTable->Length)
  1563.             {
  1564.                 AcpiOsPrintf ("Invalid zero length subtable\n");
  1565.                 return;
  1566.             }
  1567.             goto NextSubTable;
  1568.         }
  1569.  
  1570.         AcpiOsPrintf ("\n");
  1571.         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
  1572.                     SubTable->Length, InfoTable);
  1573.         if (ACPI_FAILURE (Status))
  1574.         {
  1575.             return;
  1576.         }
  1577.  
  1578. NextSubTable:
  1579.         /* Point to next sub-table */
  1580.  
  1581.         Offset += SubTable->Length;
  1582.         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
  1583.     }
  1584. }
  1585.  
  1586.  
  1587. /*******************************************************************************
  1588.  *
  1589.  * FUNCTION:    AcpiDmDumpWdat
  1590.  *
  1591.  * PARAMETERS:  Table               - A WDAT table
  1592.  *
  1593.  * RETURN:      None
  1594.  *
  1595.  * DESCRIPTION: Format the contents of a WDAT
  1596.  *
  1597.  ******************************************************************************/
  1598.  
  1599. void
  1600. AcpiDmDumpWdat (
  1601.     ACPI_TABLE_HEADER       *Table)
  1602. {
  1603.     ACPI_STATUS             Status;
  1604.     UINT32                  Offset = sizeof (ACPI_TABLE_WDAT);
  1605.     ACPI_WDAT_ENTRY         *SubTable;
  1606.  
  1607.  
  1608.     /* Main table */
  1609.  
  1610.     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
  1611.     if (ACPI_FAILURE (Status))
  1612.     {
  1613.         return;
  1614.     }
  1615.  
  1616.     /* Sub-tables */
  1617.  
  1618.     SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
  1619.     while (Offset < Table->Length)
  1620.     {
  1621.         /* Common sub-table header */
  1622.  
  1623.         AcpiOsPrintf ("\n");
  1624.         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
  1625.                     sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
  1626.         if (ACPI_FAILURE (Status))
  1627.         {
  1628.             return;
  1629.         }
  1630.  
  1631.         /* Point to next sub-table */
  1632.  
  1633.         Offset += sizeof (ACPI_WDAT_ENTRY);
  1634.         SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY));
  1635.     }
  1636. }
  1637.