Subversion Repositories Kolibri OS

Rev

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