Home | History | Annotate | Line # | Download | only in common
dmtbdump.c revision 1.1.1.12
      1 /******************************************************************************
      2  *
      3  * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code
      4  *
      5  *****************************************************************************/
      6 
      7 /*
      8  * Copyright (C) 2000 - 2017, Intel Corp.
      9  * All rights reserved.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions, and the following disclaimer,
     16  *    without modification.
     17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
     18  *    substantially similar to the "NO WARRANTY" disclaimer below
     19  *    ("Disclaimer") and any redistribution must be conditioned upon
     20  *    including a substantially similar Disclaimer requirement for further
     21  *    binary redistribution.
     22  * 3. Neither the names of the above-listed copyright holders nor the names
     23  *    of any contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * Alternatively, this software may be distributed under the terms of the
     27  * GNU General Public License ("GPL") version 2 as published by the Free
     28  * Software Foundation.
     29  *
     30  * NO WARRANTY
     31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
     34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
     40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     41  * POSSIBILITY OF SUCH DAMAGES.
     42  */
     43 
     44 #include "acpi.h"
     45 #include "accommon.h"
     46 #include "acdisasm.h"
     47 #include "actables.h"
     48 
     49 /* This module used for application-level code only */
     50 
     51 #define _COMPONENT          ACPI_CA_DISASSEMBLER
     52         ACPI_MODULE_NAME    ("dmtbdump")
     53 
     54 
     55 /* Local prototypes */
     56 
     57 static void
     58 AcpiDmValidateFadtLength (
     59     UINT32                  Revision,
     60     UINT32                  Length);
     61 
     62 
     63 /*******************************************************************************
     64  *
     65  * FUNCTION:    AcpiDmDumpBuffer
     66  *
     67  * PARAMETERS:  Table               - ACPI Table or subtable
     68  *              BufferOffset        - Offset of buffer from Table above
     69  *              Length              - Length of the buffer
     70  *              AbsoluteOffset      - Offset of buffer in the main ACPI table
     71  *              Header              - Name of the buffer field (printed on the
     72  *                                    first line only.)
     73  *
     74  * RETURN:      None
     75  *
     76  * DESCRIPTION: Format the contents of an arbitrary length data buffer (in the
     77  *              disassembler output format.)
     78  *
     79  ******************************************************************************/
     80 
     81 void
     82 AcpiDmDumpBuffer (
     83     void                    *Table,
     84     UINT32                  BufferOffset,
     85     UINT32                  Length,
     86     UINT32                  AbsoluteOffset,
     87     char                    *Header)
     88 {
     89     UINT8                   *Buffer;
     90     UINT32                  i;
     91 
     92 
     93     if (!Length)
     94     {
     95         return;
     96     }
     97 
     98     Buffer = ACPI_CAST_PTR (UINT8, Table) + BufferOffset;
     99     i = 0;
    100 
    101     while (i < Length)
    102     {
    103         if (!(i % 16))
    104         {
    105             /* Insert a backslash - line continuation character */
    106 
    107             if (Length > 16)
    108             {
    109                 AcpiOsPrintf ("\\\n    ");
    110             }
    111         }
    112 
    113         AcpiOsPrintf ("%.02X ", *Buffer);
    114         i++;
    115         Buffer++;
    116         AbsoluteOffset++;
    117     }
    118 
    119     AcpiOsPrintf ("\n");
    120 }
    121 
    122 
    123 /*******************************************************************************
    124  *
    125  * FUNCTION:    AcpiDmDumpUnicode
    126  *
    127  * PARAMETERS:  Table               - ACPI Table or subtable
    128  *              BufferOffset        - Offset of buffer from Table above
    129  *              ByteLength          - Length of the buffer
    130  *
    131  * RETURN:      None
    132  *
    133  * DESCRIPTION: Validate and dump the contents of a buffer that contains
    134  *              unicode data. The output is a standard ASCII string. If it
    135  *              appears that the data is not unicode, the buffer is dumped
    136  *              as hex characters.
    137  *
    138  ******************************************************************************/
    139 
    140 void
    141 AcpiDmDumpUnicode (
    142     void                    *Table,
    143     UINT32                  BufferOffset,
    144     UINT32                  ByteLength)
    145 {
    146     UINT8                   *Buffer;
    147     UINT32                  Length;
    148     UINT32                  i;
    149 
    150 
    151     Buffer = ((UINT8 *) Table) + BufferOffset;
    152     Length = ByteLength - 2; /* Last two bytes are the null terminator */
    153 
    154     /* Ensure all low bytes are entirely printable ASCII */
    155 
    156     for (i = 0; i < Length; i += 2)
    157     {
    158         if (!isprint (Buffer[i]))
    159         {
    160             goto DumpRawBuffer;
    161         }
    162     }
    163 
    164     /* Ensure all high bytes are zero */
    165 
    166     for (i = 1; i < Length; i += 2)
    167     {
    168         if (Buffer[i])
    169         {
    170             goto DumpRawBuffer;
    171         }
    172     }
    173 
    174     /* Dump the buffer as a normal string */
    175 
    176     AcpiOsPrintf ("\"");
    177     for (i = 0; i < Length; i += 2)
    178     {
    179         AcpiOsPrintf ("%c", Buffer[i]);
    180     }
    181 
    182     AcpiOsPrintf ("\"\n");
    183     return;
    184 
    185 DumpRawBuffer:
    186     AcpiDmDumpBuffer (Table, BufferOffset, ByteLength,
    187         BufferOffset, NULL);
    188     AcpiOsPrintf ("\n");
    189 }
    190 
    191 
    192 /*******************************************************************************
    193  *
    194  * FUNCTION:    AcpiDmDumpRsdp
    195  *
    196  * PARAMETERS:  Table               - A RSDP
    197  *
    198  * RETURN:      Length of the table (there is not always a length field,
    199  *              use revision or length if available (ACPI 2.0+))
    200  *
    201  * DESCRIPTION: Format the contents of a RSDP
    202  *
    203  ******************************************************************************/
    204 
    205 UINT32
    206 AcpiDmDumpRsdp (
    207     ACPI_TABLE_HEADER       *Table)
    208 {
    209     ACPI_TABLE_RSDP         *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
    210     UINT32                  Length = sizeof (ACPI_RSDP_COMMON);
    211     UINT8                   Checksum;
    212     ACPI_STATUS             Status;
    213 
    214 
    215     /* Dump the common ACPI 1.0 portion */
    216 
    217     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
    218     if (ACPI_FAILURE (Status))
    219     {
    220         return (Length);
    221     }
    222 
    223     /* Validate the first checksum */
    224 
    225     Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON),
    226         Rsdp->Checksum);
    227     if (Checksum != Rsdp->Checksum)
    228     {
    229         AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n",
    230             Checksum);
    231     }
    232 
    233     /* The RSDP for ACPI 2.0+ contains more data and has a Length field */
    234 
    235     if (Rsdp->Revision > 0)
    236     {
    237         Length = Rsdp->Length;
    238         Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
    239         if (ACPI_FAILURE (Status))
    240         {
    241             return (Length);
    242         }
    243 
    244         /* Validate the extended checksum over entire RSDP */
    245 
    246         Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP),
    247             Rsdp->ExtendedChecksum);
    248         if (Checksum != Rsdp->ExtendedChecksum)
    249         {
    250             AcpiOsPrintf (
    251                 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n",
    252                 Checksum);
    253         }
    254     }
    255 
    256     return (Length);
    257 }
    258 
    259 
    260 /*******************************************************************************
    261  *
    262  * FUNCTION:    AcpiDmDumpRsdt
    263  *
    264  * PARAMETERS:  Table               - A RSDT
    265  *
    266  * RETURN:      None
    267  *
    268  * DESCRIPTION: Format the contents of a RSDT
    269  *
    270  ******************************************************************************/
    271 
    272 void
    273 AcpiDmDumpRsdt (
    274     ACPI_TABLE_HEADER       *Table)
    275 {
    276     UINT32                  *Array;
    277     UINT32                  Entries;
    278     UINT32                  Offset;
    279     UINT32                  i;
    280 
    281 
    282     /* Point to start of table pointer array */
    283 
    284     Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry;
    285     Offset = sizeof (ACPI_TABLE_HEADER);
    286 
    287     /* RSDT uses 32-bit pointers */
    288 
    289     Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
    290 
    291     for (i = 0; i < Entries; i++)
    292     {
    293         AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i);
    294         AcpiOsPrintf ("%8.8X\n", Array[i]);
    295         Offset += sizeof (UINT32);
    296     }
    297 }
    298 
    299 
    300 /*******************************************************************************
    301  *
    302  * FUNCTION:    AcpiDmDumpXsdt
    303  *
    304  * PARAMETERS:  Table               - A XSDT
    305  *
    306  * RETURN:      None
    307  *
    308  * DESCRIPTION: Format the contents of a XSDT
    309  *
    310  ******************************************************************************/
    311 
    312 void
    313 AcpiDmDumpXsdt (
    314     ACPI_TABLE_HEADER       *Table)
    315 {
    316     UINT64                  *Array;
    317     UINT32                  Entries;
    318     UINT32                  Offset;
    319     UINT32                  i;
    320 
    321 
    322     /* Point to start of table pointer array */
    323 
    324     Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry;
    325     Offset = sizeof (ACPI_TABLE_HEADER);
    326 
    327     /* XSDT uses 64-bit pointers */
    328 
    329     Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
    330 
    331     for (i = 0; i < Entries; i++)
    332     {
    333         AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i);
    334         AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i]));
    335         Offset += sizeof (UINT64);
    336     }
    337 }
    338 
    339 
    340 /*******************************************************************************
    341  *
    342  * FUNCTION:    AcpiDmDumpFadt
    343  *
    344  * PARAMETERS:  Table               - A FADT
    345  *
    346  * RETURN:      None
    347  *
    348  * DESCRIPTION: Format the contents of a FADT
    349  *
    350  * NOTE:        We cannot depend on the FADT version to indicate the actual
    351  *              contents of the FADT because of BIOS bugs. The table length
    352  *              is the only reliable indicator.
    353  *
    354  ******************************************************************************/
    355 
    356 void
    357 AcpiDmDumpFadt (
    358     ACPI_TABLE_HEADER       *Table)
    359 {
    360     ACPI_STATUS             Status;
    361 
    362 
    363     /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */
    364 
    365     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
    366         AcpiDmTableInfoFadt1);
    367     if (ACPI_FAILURE (Status))
    368     {
    369         return;
    370     }
    371 
    372     /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */
    373 
    374     if ((Table->Length > ACPI_FADT_V1_SIZE) &&
    375         (Table->Length <= ACPI_FADT_V2_SIZE))
    376     {
    377         Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
    378             AcpiDmTableInfoFadt2);
    379         if (ACPI_FAILURE (Status))
    380         {
    381             return;
    382         }
    383     }
    384 
    385     /* Check for FADT revision 3/4 fields and up (ACPI 2.0+ extended data) */
    386 
    387     else if (Table->Length > ACPI_FADT_V2_SIZE)
    388     {
    389         Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
    390             AcpiDmTableInfoFadt3);
    391         if (ACPI_FAILURE (Status))
    392         {
    393             return;
    394         }
    395 
    396         /* Check for FADT revision 5 fields and up (ACPI 5.0+) */
    397 
    398         if (Table->Length > ACPI_FADT_V3_SIZE)
    399         {
    400             Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
    401                 AcpiDmTableInfoFadt5);
    402             if (ACPI_FAILURE (Status))
    403             {
    404                 return;
    405             }
    406         }
    407 
    408         /* Check for FADT revision 6 fields and up (ACPI 6.0+) */
    409 
    410         if (Table->Length > ACPI_FADT_V3_SIZE)
    411         {
    412             Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
    413                 AcpiDmTableInfoFadt6);
    414             if (ACPI_FAILURE (Status))
    415             {
    416                 return;
    417             }
    418         }
    419     }
    420 
    421     /* Validate various fields in the FADT, including length */
    422 
    423     AcpiTbCreateLocalFadt (Table, Table->Length);
    424 
    425     /* Validate FADT length against the revision */
    426 
    427     AcpiDmValidateFadtLength (Table->Revision, Table->Length);
    428 }
    429 
    430 
    431 /*******************************************************************************
    432  *
    433  * FUNCTION:    AcpiDmValidateFadtLength
    434  *
    435  * PARAMETERS:  Revision            - FADT revision (Header->Revision)
    436  *              Length              - FADT length (Header->Length
    437  *
    438  * RETURN:      None
    439  *
    440  * DESCRIPTION: Check the FADT revision against the expected table length for
    441  *              that revision. Issue a warning if the length is not what was
    442  *              expected. This seems to be such a common BIOS bug that the
    443  *              FADT revision has been rendered virtually meaningless.
    444  *
    445  ******************************************************************************/
    446 
    447 static void
    448 AcpiDmValidateFadtLength (
    449     UINT32                  Revision,
    450     UINT32                  Length)
    451 {
    452     UINT32                  ExpectedLength;
    453 
    454 
    455     switch (Revision)
    456     {
    457     case 0:
    458 
    459         AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n");
    460         return;
    461 
    462     case 1:
    463 
    464         ExpectedLength = ACPI_FADT_V1_SIZE;
    465         break;
    466 
    467     case 2:
    468 
    469         ExpectedLength = ACPI_FADT_V2_SIZE;
    470         break;
    471 
    472     case 3:
    473     case 4:
    474 
    475         ExpectedLength = ACPI_FADT_V3_SIZE;
    476         break;
    477 
    478     case 5:
    479 
    480         ExpectedLength = ACPI_FADT_V5_SIZE;
    481         break;
    482 
    483     default:
    484 
    485         return;
    486     }
    487 
    488     if (Length == ExpectedLength)
    489     {
    490         return;
    491     }
    492 
    493     AcpiOsPrintf (
    494         "\n// ACPI Warning: FADT revision %X does not match length: "
    495         "found %X expected %X\n",
    496         Revision, Length, ExpectedLength);
    497 }
    498 
    499 
    500 /*******************************************************************************
    501  *
    502  * FUNCTION:    AcpiDmDumpAsf
    503  *
    504  * PARAMETERS:  Table               - A ASF table
    505  *
    506  * RETURN:      None
    507  *
    508  * DESCRIPTION: Format the contents of a ASF table
    509  *
    510  ******************************************************************************/
    511 
    512 void
    513 AcpiDmDumpAsf (
    514     ACPI_TABLE_HEADER       *Table)
    515 {
    516     ACPI_STATUS             Status;
    517     UINT32                  Offset = sizeof (ACPI_TABLE_HEADER);
    518     ACPI_ASF_INFO           *SubTable;
    519     ACPI_DMTABLE_INFO       *InfoTable;
    520     ACPI_DMTABLE_INFO       *DataInfoTable = NULL;
    521     UINT8                   *DataTable = NULL;
    522     UINT32                  DataCount = 0;
    523     UINT32                  DataLength = 0;
    524     UINT32                  DataOffset = 0;
    525     UINT32                  i;
    526     UINT8                   Type;
    527 
    528 
    529     /* No main table, only subtables */
    530 
    531     SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
    532     while (Offset < Table->Length)
    533     {
    534         /* Common subtable header */
    535 
    536         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
    537             SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
    538         if (ACPI_FAILURE (Status))
    539         {
    540             return;
    541         }
    542 
    543         /* The actual type is the lower 7 bits of Type */
    544 
    545         Type = (UINT8) (SubTable->Header.Type & 0x7F);
    546 
    547         switch (Type)
    548         {
    549         case ACPI_ASF_TYPE_INFO:
    550 
    551             InfoTable = AcpiDmTableInfoAsf0;
    552             break;
    553 
    554         case ACPI_ASF_TYPE_ALERT:
    555 
    556             InfoTable = AcpiDmTableInfoAsf1;
    557             DataInfoTable = AcpiDmTableInfoAsf1a;
    558             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT));
    559             DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts;
    560             DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength;
    561             DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
    562             break;
    563 
    564         case ACPI_ASF_TYPE_CONTROL:
    565 
    566             InfoTable = AcpiDmTableInfoAsf2;
    567             DataInfoTable = AcpiDmTableInfoAsf2a;
    568             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE));
    569             DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls;
    570             DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength;
    571             DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
    572             break;
    573 
    574         case ACPI_ASF_TYPE_BOOT:
    575 
    576             InfoTable = AcpiDmTableInfoAsf3;
    577             break;
    578 
    579         case ACPI_ASF_TYPE_ADDRESS:
    580 
    581             InfoTable = AcpiDmTableInfoAsf4;
    582             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS));
    583             DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices;
    584             DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
    585             break;
    586 
    587         default:
    588 
    589             AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n",
    590                 SubTable->Header.Type);
    591             return;
    592         }
    593 
    594         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
    595             SubTable->Header.Length, InfoTable);
    596         if (ACPI_FAILURE (Status))
    597         {
    598             return;
    599         }
    600 
    601         /* Dump variable-length extra data */
    602 
    603         switch (Type)
    604         {
    605         case ACPI_ASF_TYPE_ALERT:
    606         case ACPI_ASF_TYPE_CONTROL:
    607 
    608             for (i = 0; i < DataCount; i++)
    609             {
    610                 AcpiOsPrintf ("\n");
    611                 Status = AcpiDmDumpTable (Table->Length, DataOffset,
    612                     DataTable, DataLength, DataInfoTable);
    613                 if (ACPI_FAILURE (Status))
    614                 {
    615                     return;
    616                 }
    617 
    618                 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
    619                 DataOffset += DataLength;
    620             }
    621             break;
    622 
    623         case ACPI_ASF_TYPE_ADDRESS:
    624 
    625             for (i = 0; i < DataLength; i++)
    626             {
    627                 if (!(i % 16))
    628                 {
    629                     AcpiDmLineHeader (DataOffset, 1, "Addresses");
    630                 }
    631 
    632                 AcpiOsPrintf ("%2.2X ", *DataTable);
    633                 DataTable++;
    634                 DataOffset++;
    635 
    636                 if (DataOffset > Table->Length)
    637                 {
    638                     AcpiOsPrintf (
    639                         "**** ACPI table terminates in the middle of a "
    640                         "data structure! (ASF! table)\n");
    641                     return;
    642                 }
    643             }
    644 
    645             AcpiOsPrintf ("\n");
    646             break;
    647 
    648         default:
    649 
    650             break;
    651         }
    652 
    653         AcpiOsPrintf ("\n");
    654 
    655         /* Point to next subtable */
    656 
    657         if (!SubTable->Header.Length)
    658         {
    659             AcpiOsPrintf ("Invalid zero subtable header length\n");
    660             return;
    661         }
    662 
    663         Offset += SubTable->Header.Length;
    664         SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable,
    665             SubTable->Header.Length);
    666     }
    667 }
    668 
    669 
    670 /*******************************************************************************
    671  *
    672  * FUNCTION:    AcpiDmDumpCpep
    673  *
    674  * PARAMETERS:  Table               - A CPEP table
    675  *
    676  * RETURN:      None
    677  *
    678  * DESCRIPTION: Format the contents of a CPEP. This table type consists
    679  *              of an open-ended number of subtables.
    680  *
    681  ******************************************************************************/
    682 
    683 void
    684 AcpiDmDumpCpep (
    685     ACPI_TABLE_HEADER       *Table)
    686 {
    687     ACPI_STATUS             Status;
    688     ACPI_CPEP_POLLING       *SubTable;
    689     UINT32                  Length = Table->Length;
    690     UINT32                  Offset = sizeof (ACPI_TABLE_CPEP);
    691 
    692 
    693     /* Main table */
    694 
    695     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
    696     if (ACPI_FAILURE (Status))
    697     {
    698         return;
    699     }
    700 
    701     /* Subtables */
    702 
    703     SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
    704     while (Offset < Table->Length)
    705     {
    706         AcpiOsPrintf ("\n");
    707         Status = AcpiDmDumpTable (Length, Offset, SubTable,
    708             SubTable->Header.Length, AcpiDmTableInfoCpep0);
    709         if (ACPI_FAILURE (Status))
    710         {
    711             return;
    712         }
    713 
    714         /* Point to next subtable */
    715 
    716         Offset += SubTable->Header.Length;
    717         SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable,
    718             SubTable->Header.Length);
    719     }
    720 }
    721 
    722 
    723 /*******************************************************************************
    724  *
    725  * FUNCTION:    AcpiDmDumpCsrt
    726  *
    727  * PARAMETERS:  Table               - A CSRT table
    728  *
    729  * RETURN:      None
    730  *
    731  * DESCRIPTION: Format the contents of a CSRT. This table type consists
    732  *              of an open-ended number of subtables.
    733  *
    734  ******************************************************************************/
    735 
    736 void
    737 AcpiDmDumpCsrt (
    738     ACPI_TABLE_HEADER       *Table)
    739 {
    740     ACPI_STATUS             Status;
    741     ACPI_CSRT_GROUP         *SubTable;
    742     ACPI_CSRT_SHARED_INFO   *SharedInfoTable;
    743     ACPI_CSRT_DESCRIPTOR    *SubSubTable;
    744     UINT32                  Length = Table->Length;
    745     UINT32                  Offset = sizeof (ACPI_TABLE_CSRT);
    746     UINT32                  SubOffset;
    747     UINT32                  SubSubOffset;
    748     UINT32                  InfoLength;
    749 
    750 
    751     /* The main table only contains the ACPI header, thus already handled */
    752 
    753     /* Subtables (Resource Groups) */
    754 
    755     SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);
    756     while (Offset < Table->Length)
    757     {
    758         /* Resource group subtable */
    759 
    760         AcpiOsPrintf ("\n");
    761         Status = AcpiDmDumpTable (Length, Offset, SubTable,
    762             SubTable->Length, AcpiDmTableInfoCsrt0);
    763         if (ACPI_FAILURE (Status))
    764         {
    765             return;
    766         }
    767 
    768         /* Shared info subtable (One per resource group) */
    769 
    770         SubOffset = sizeof (ACPI_CSRT_GROUP);
    771         SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table,
    772             Offset + SubOffset);
    773 
    774         AcpiOsPrintf ("\n");
    775         Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable,
    776             sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);
    777         if (ACPI_FAILURE (Status))
    778         {
    779             return;
    780         }
    781 
    782         SubOffset += SubTable->SharedInfoLength;
    783 
    784         /* Sub-Subtables (Resource Descriptors) */
    785 
    786         SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,
    787             Offset + SubOffset);
    788 
    789         while ((SubOffset < SubTable->Length) &&
    790               ((Offset + SubOffset) < Table->Length))
    791         {
    792             AcpiOsPrintf ("\n");
    793             Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable,
    794                 SubSubTable->Length, AcpiDmTableInfoCsrt2);
    795             if (ACPI_FAILURE (Status))
    796             {
    797                 return;
    798             }
    799 
    800             SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR);
    801 
    802             /* Resource-specific info buffer */
    803 
    804             InfoLength = SubSubTable->Length - SubSubOffset;
    805             if (InfoLength)
    806             {
    807                 Status = AcpiDmDumpTable (Length,
    808                     Offset + SubOffset + SubSubOffset, Table,
    809                     InfoLength, AcpiDmTableInfoCsrt2a);
    810                 if (ACPI_FAILURE (Status))
    811                 {
    812                     return;
    813                 }
    814                 SubSubOffset += InfoLength;
    815             }
    816 
    817             /* Point to next sub-subtable */
    818 
    819             SubOffset += SubSubTable->Length;
    820             SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable,
    821                 SubSubTable->Length);
    822         }
    823 
    824         /* Point to next subtable */
    825 
    826         Offset += SubTable->Length;
    827         SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable,
    828             SubTable->Length);
    829     }
    830 }
    831 
    832 
    833 /*******************************************************************************
    834  *
    835  * FUNCTION:    AcpiDmDumpDbg2
    836  *
    837  * PARAMETERS:  Table               - A DBG2 table
    838  *
    839  * RETURN:      None
    840  *
    841  * DESCRIPTION: Format the contents of a DBG2. This table type consists
    842  *              of an open-ended number of subtables.
    843  *
    844  ******************************************************************************/
    845 
    846 void
    847 AcpiDmDumpDbg2 (
    848     ACPI_TABLE_HEADER       *Table)
    849 {
    850     ACPI_STATUS             Status;
    851     ACPI_DBG2_DEVICE        *SubTable;
    852     UINT32                  Length = Table->Length;
    853     UINT32                  Offset = sizeof (ACPI_TABLE_DBG2);
    854     UINT32                  i;
    855     UINT32                  ArrayOffset;
    856     UINT32                  AbsoluteOffset;
    857     UINT8                   *Array;
    858 
    859 
    860     /* Main table */
    861 
    862     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);
    863     if (ACPI_FAILURE (Status))
    864     {
    865         return;
    866     }
    867 
    868     /* Subtables */
    869 
    870     SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);
    871     while (Offset < Table->Length)
    872     {
    873         AcpiOsPrintf ("\n");
    874         Status = AcpiDmDumpTable (Length, Offset, SubTable,
    875             SubTable->Length, AcpiDmTableInfoDbg2Device);
    876         if (ACPI_FAILURE (Status))
    877         {
    878             return;
    879         }
    880 
    881         /* Dump the BaseAddress array */
    882 
    883         for (i = 0; i < SubTable->RegisterCount; i++)
    884         {
    885             ArrayOffset = SubTable->BaseAddressOffset +
    886                 (sizeof (ACPI_GENERIC_ADDRESS) * i);
    887             AbsoluteOffset = Offset + ArrayOffset;
    888             Array = (UINT8 *) SubTable + ArrayOffset;
    889 
    890             Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
    891                 SubTable->Length, AcpiDmTableInfoDbg2Addr);
    892             if (ACPI_FAILURE (Status))
    893             {
    894                 return;
    895             }
    896         }
    897 
    898         /* Dump the AddressSize array */
    899 
    900         for (i = 0; i < SubTable->RegisterCount; i++)
    901         {
    902             ArrayOffset = SubTable->AddressSizeOffset +
    903                 (sizeof (UINT32) * i);
    904             AbsoluteOffset = Offset + ArrayOffset;
    905             Array = (UINT8 *) SubTable + ArrayOffset;
    906 
    907             Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
    908                 SubTable->Length, AcpiDmTableInfoDbg2Size);
    909             if (ACPI_FAILURE (Status))
    910             {
    911                 return;
    912             }
    913         }
    914 
    915         /* Dump the Namestring (required) */
    916 
    917         AcpiOsPrintf ("\n");
    918         ArrayOffset = SubTable->NamepathOffset;
    919         AbsoluteOffset = Offset + ArrayOffset;
    920         Array = (UINT8 *) SubTable + ArrayOffset;
    921 
    922         Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
    923             SubTable->Length, AcpiDmTableInfoDbg2Name);
    924         if (ACPI_FAILURE (Status))
    925         {
    926             return;
    927         }
    928 
    929         /* Dump the OemData (optional) */
    930 
    931         if (SubTable->OemDataOffset)
    932         {
    933             Status = AcpiDmDumpTable (Length, Offset + SubTable->OemDataOffset,
    934                 Table, SubTable->OemDataLength,
    935                 AcpiDmTableInfoDbg2OemData);
    936             if (ACPI_FAILURE (Status))
    937             {
    938                 return;
    939             }
    940         }
    941 
    942         /* Point to next subtable */
    943 
    944         Offset += SubTable->Length;
    945         SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable,
    946             SubTable->Length);
    947     }
    948 }
    949 
    950 
    951 /*******************************************************************************
    952  *
    953  * FUNCTION:    AcpiDmDumpDmar
    954  *
    955  * PARAMETERS:  Table               - A DMAR table
    956  *
    957  * RETURN:      None
    958  *
    959  * DESCRIPTION: Format the contents of a DMAR. This table type consists
    960  *              of an open-ended number of subtables.
    961  *
    962  ******************************************************************************/
    963 
    964 void
    965 AcpiDmDumpDmar (
    966     ACPI_TABLE_HEADER       *Table)
    967 {
    968     ACPI_STATUS             Status;
    969     ACPI_DMAR_HEADER        *SubTable;
    970     UINT32                  Length = Table->Length;
    971     UINT32                  Offset = sizeof (ACPI_TABLE_DMAR);
    972     ACPI_DMTABLE_INFO       *InfoTable;
    973     ACPI_DMAR_DEVICE_SCOPE  *ScopeTable;
    974     UINT32                  ScopeOffset;
    975     UINT8                   *PciPath;
    976     UINT32                  PathOffset;
    977 
    978 
    979     /* Main table */
    980 
    981     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
    982     if (ACPI_FAILURE (Status))
    983     {
    984         return;
    985     }
    986 
    987     /* Subtables */
    988 
    989     SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
    990     while (Offset < Table->Length)
    991     {
    992         /* Common subtable header */
    993 
    994         AcpiOsPrintf ("\n");
    995         Status = AcpiDmDumpTable (Length, Offset, SubTable,
    996             SubTable->Length, AcpiDmTableInfoDmarHdr);
    997         if (ACPI_FAILURE (Status))
    998         {
    999             return;
   1000         }
   1001 
   1002         AcpiOsPrintf ("\n");
   1003 
   1004         switch (SubTable->Type)
   1005         {
   1006         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
   1007 
   1008             InfoTable = AcpiDmTableInfoDmar0;
   1009             ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
   1010             break;
   1011 
   1012         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
   1013 
   1014             InfoTable = AcpiDmTableInfoDmar1;
   1015             ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
   1016             break;
   1017 
   1018         case ACPI_DMAR_TYPE_ROOT_ATS:
   1019 
   1020             InfoTable = AcpiDmTableInfoDmar2;
   1021             ScopeOffset = sizeof (ACPI_DMAR_ATSR);
   1022             break;
   1023 
   1024         case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
   1025 
   1026             InfoTable = AcpiDmTableInfoDmar3;
   1027             ScopeOffset = sizeof (ACPI_DMAR_RHSA);
   1028             break;
   1029 
   1030         case ACPI_DMAR_TYPE_NAMESPACE:
   1031 
   1032             InfoTable = AcpiDmTableInfoDmar4;
   1033             ScopeOffset = sizeof (ACPI_DMAR_ANDD);
   1034             break;
   1035 
   1036         default:
   1037 
   1038             AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n",
   1039                 SubTable->Type);
   1040             return;
   1041         }
   1042 
   1043         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   1044             SubTable->Length, InfoTable);
   1045         if (ACPI_FAILURE (Status))
   1046         {
   1047             return;
   1048         }
   1049 
   1050         /*
   1051          * Dump the optional device scope entries
   1052          */
   1053         if ((SubTable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) ||
   1054             (SubTable->Type == ACPI_DMAR_TYPE_NAMESPACE))
   1055         {
   1056             /* These types do not support device scopes */
   1057 
   1058             goto NextSubtable;
   1059         }
   1060 
   1061         ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
   1062         while (ScopeOffset < SubTable->Length)
   1063         {
   1064             AcpiOsPrintf ("\n");
   1065             Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
   1066                 ScopeTable->Length, AcpiDmTableInfoDmarScope);
   1067             if (ACPI_FAILURE (Status))
   1068             {
   1069                 return;
   1070             }
   1071             AcpiOsPrintf ("\n");
   1072 
   1073             /* Dump the PCI Path entries for this device scope */
   1074 
   1075             PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
   1076 
   1077             PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
   1078                 sizeof (ACPI_DMAR_DEVICE_SCOPE));
   1079 
   1080             while (PathOffset < ScopeTable->Length)
   1081             {
   1082                 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2,
   1083                     "PCI Path");
   1084                 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
   1085 
   1086                 /* Point to next PCI Path entry */
   1087 
   1088                 PathOffset += 2;
   1089                 PciPath += 2;
   1090                 AcpiOsPrintf ("\n");
   1091             }
   1092 
   1093             /* Point to next device scope entry */
   1094 
   1095             ScopeOffset += ScopeTable->Length;
   1096             ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
   1097                 ScopeTable, ScopeTable->Length);
   1098         }
   1099 
   1100 NextSubtable:
   1101         /* Point to next subtable */
   1102 
   1103         Offset += SubTable->Length;
   1104         SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable,
   1105             SubTable->Length);
   1106     }
   1107 }
   1108 
   1109 
   1110 /*******************************************************************************
   1111  *
   1112  * FUNCTION:    AcpiDmDumpDrtm
   1113  *
   1114  * PARAMETERS:  Table               - A DRTM table
   1115  *
   1116  * RETURN:      None
   1117  *
   1118  * DESCRIPTION: Format the contents of a DRTM.
   1119  *
   1120  ******************************************************************************/
   1121 
   1122 void
   1123 AcpiDmDumpDrtm (
   1124     ACPI_TABLE_HEADER       *Table)
   1125 {
   1126     ACPI_STATUS             Status;
   1127     UINT32                  Offset;
   1128     ACPI_DRTM_VTABLE_LIST   *DrtmVtl;
   1129     ACPI_DRTM_RESOURCE_LIST *DrtmRl;
   1130     ACPI_DRTM_DPS_ID        *DrtmDps;
   1131     UINT32                  Count;
   1132 
   1133 
   1134     /* Main table */
   1135 
   1136     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0,
   1137         AcpiDmTableInfoDrtm);
   1138     if (ACPI_FAILURE (Status))
   1139     {
   1140         return;
   1141     }
   1142 
   1143     Offset = sizeof (ACPI_TABLE_DRTM);
   1144 
   1145     /* Sub-tables */
   1146 
   1147     /* Dump ValidatedTable length */
   1148 
   1149     DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset);
   1150     AcpiOsPrintf ("\n");
   1151     Status = AcpiDmDumpTable (Table->Length, Offset,
   1152         DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables),
   1153         AcpiDmTableInfoDrtm0);
   1154     if (ACPI_FAILURE (Status))
   1155     {
   1156             return;
   1157     }
   1158 
   1159     Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables);
   1160 
   1161     /* Dump Validated table addresses */
   1162 
   1163     Count = 0;
   1164     while ((Offset < Table->Length) &&
   1165             (DrtmVtl->ValidatedTableCount > Count))
   1166     {
   1167         Status = AcpiDmDumpTable (Table->Length, Offset,
   1168             ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64),
   1169             AcpiDmTableInfoDrtm0a);
   1170         if (ACPI_FAILURE (Status))
   1171         {
   1172             return;
   1173         }
   1174 
   1175         Offset += sizeof (UINT64);
   1176         Count++;
   1177     }
   1178 
   1179     /* Dump ResourceList length */
   1180 
   1181     DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset);
   1182     AcpiOsPrintf ("\n");
   1183     Status = AcpiDmDumpTable (Table->Length, Offset,
   1184         DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources),
   1185         AcpiDmTableInfoDrtm1);
   1186     if (ACPI_FAILURE (Status))
   1187     {
   1188         return;
   1189     }
   1190 
   1191     Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources);
   1192 
   1193     /* Dump the Resource List */
   1194 
   1195     Count = 0;
   1196     while ((Offset < Table->Length) &&
   1197            (DrtmRl->ResourceCount > Count))
   1198     {
   1199         Status = AcpiDmDumpTable (Table->Length, Offset,
   1200             ACPI_ADD_PTR (void, Table, Offset),
   1201             sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a);
   1202         if (ACPI_FAILURE (Status))
   1203         {
   1204             return;
   1205         }
   1206 
   1207         Offset += sizeof (ACPI_DRTM_RESOURCE);
   1208         Count++;
   1209     }
   1210 
   1211     /* Dump DPS */
   1212 
   1213     DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset);
   1214     AcpiOsPrintf ("\n");
   1215     (void) AcpiDmDumpTable (Table->Length, Offset,
   1216         DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2);
   1217 }
   1218 
   1219 
   1220 /*******************************************************************************
   1221  *
   1222  * FUNCTION:    AcpiDmDumpEinj
   1223  *
   1224  * PARAMETERS:  Table               - A EINJ table
   1225  *
   1226  * RETURN:      None
   1227  *
   1228  * DESCRIPTION: Format the contents of a EINJ. This table type consists
   1229  *              of an open-ended number of subtables.
   1230  *
   1231  ******************************************************************************/
   1232 
   1233 void
   1234 AcpiDmDumpEinj (
   1235     ACPI_TABLE_HEADER       *Table)
   1236 {
   1237     ACPI_STATUS             Status;
   1238     ACPI_WHEA_HEADER        *SubTable;
   1239     UINT32                  Length = Table->Length;
   1240     UINT32                  Offset = sizeof (ACPI_TABLE_EINJ);
   1241 
   1242 
   1243     /* Main table */
   1244 
   1245     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
   1246     if (ACPI_FAILURE (Status))
   1247     {
   1248         return;
   1249     }
   1250 
   1251     /* Subtables */
   1252 
   1253     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
   1254     while (Offset < Table->Length)
   1255     {
   1256         AcpiOsPrintf ("\n");
   1257         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   1258             sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
   1259         if (ACPI_FAILURE (Status))
   1260         {
   1261             return;
   1262         }
   1263 
   1264         /* Point to next subtable (each subtable is of fixed length) */
   1265 
   1266         Offset += sizeof (ACPI_WHEA_HEADER);
   1267         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
   1268             sizeof (ACPI_WHEA_HEADER));
   1269     }
   1270 }
   1271 
   1272 
   1273 /*******************************************************************************
   1274  *
   1275  * FUNCTION:    AcpiDmDumpErst
   1276  *
   1277  * PARAMETERS:  Table               - A ERST table
   1278  *
   1279  * RETURN:      None
   1280  *
   1281  * DESCRIPTION: Format the contents of a ERST. This table type consists
   1282  *              of an open-ended number of subtables.
   1283  *
   1284  ******************************************************************************/
   1285 
   1286 void
   1287 AcpiDmDumpErst (
   1288     ACPI_TABLE_HEADER       *Table)
   1289 {
   1290     ACPI_STATUS             Status;
   1291     ACPI_WHEA_HEADER        *SubTable;
   1292     UINT32                  Length = Table->Length;
   1293     UINT32                  Offset = sizeof (ACPI_TABLE_ERST);
   1294 
   1295 
   1296     /* Main table */
   1297 
   1298     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
   1299     if (ACPI_FAILURE (Status))
   1300     {
   1301         return;
   1302     }
   1303 
   1304     /* Subtables */
   1305 
   1306     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
   1307     while (Offset < Table->Length)
   1308     {
   1309         AcpiOsPrintf ("\n");
   1310         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   1311             sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
   1312         if (ACPI_FAILURE (Status))
   1313         {
   1314             return;
   1315         }
   1316 
   1317         /* Point to next subtable (each subtable is of fixed length) */
   1318 
   1319         Offset += sizeof (ACPI_WHEA_HEADER);
   1320         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
   1321             sizeof (ACPI_WHEA_HEADER));
   1322     }
   1323 }
   1324 
   1325 
   1326 /*******************************************************************************
   1327  *
   1328  * FUNCTION:    AcpiDmDumpFpdt
   1329  *
   1330  * PARAMETERS:  Table               - A FPDT table
   1331  *
   1332  * RETURN:      None
   1333  *
   1334  * DESCRIPTION: Format the contents of a FPDT. This table type consists
   1335  *              of an open-ended number of subtables.
   1336  *
   1337  ******************************************************************************/
   1338 
   1339 void
   1340 AcpiDmDumpFpdt (
   1341     ACPI_TABLE_HEADER       *Table)
   1342 {
   1343     ACPI_STATUS             Status;
   1344     ACPI_FPDT_HEADER        *SubTable;
   1345     UINT32                  Length = Table->Length;
   1346     UINT32                  Offset = sizeof (ACPI_TABLE_FPDT);
   1347     ACPI_DMTABLE_INFO       *InfoTable;
   1348 
   1349 
   1350     /* There is no main table (other than the standard ACPI header) */
   1351 
   1352     /* Subtables */
   1353 
   1354     SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset);
   1355     while (Offset < Table->Length)
   1356     {
   1357         /* Common subtable header */
   1358 
   1359         AcpiOsPrintf ("\n");
   1360         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   1361             SubTable->Length, AcpiDmTableInfoFpdtHdr);
   1362         if (ACPI_FAILURE (Status))
   1363         {
   1364             return;
   1365         }
   1366 
   1367         switch (SubTable->Type)
   1368         {
   1369         case ACPI_FPDT_TYPE_BOOT:
   1370 
   1371             InfoTable = AcpiDmTableInfoFpdt0;
   1372             break;
   1373 
   1374         case ACPI_FPDT_TYPE_S3PERF:
   1375 
   1376             InfoTable = AcpiDmTableInfoFpdt1;
   1377             break;
   1378 
   1379         default:
   1380 
   1381             AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n",
   1382                 SubTable->Type);
   1383 
   1384             /* Attempt to continue */
   1385 
   1386             if (!SubTable->Length)
   1387             {
   1388                 AcpiOsPrintf ("Invalid zero length subtable\n");
   1389                 return;
   1390             }
   1391             goto NextSubTable;
   1392         }
   1393 
   1394         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   1395             SubTable->Length, InfoTable);
   1396         if (ACPI_FAILURE (Status))
   1397         {
   1398             return;
   1399         }
   1400 
   1401 NextSubTable:
   1402         /* Point to next subtable */
   1403 
   1404         Offset += SubTable->Length;
   1405         SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable,
   1406             SubTable->Length);
   1407     }
   1408 }
   1409 
   1410 
   1411 /*******************************************************************************
   1412  *
   1413  * FUNCTION:    AcpiDmDumpGtdt
   1414  *
   1415  * PARAMETERS:  Table               - A GTDT table
   1416  *
   1417  * RETURN:      None
   1418  *
   1419  * DESCRIPTION: Format the contents of a GTDT. This table type consists
   1420  *              of an open-ended number of subtables.
   1421  *
   1422  ******************************************************************************/
   1423 
   1424 void
   1425 AcpiDmDumpGtdt (
   1426     ACPI_TABLE_HEADER       *Table)
   1427 {
   1428     ACPI_STATUS             Status;
   1429     ACPI_GTDT_HEADER        *SubTable;
   1430     UINT32                  Length = Table->Length;
   1431     UINT32                  Offset = sizeof (ACPI_TABLE_GTDT);
   1432     ACPI_DMTABLE_INFO       *InfoTable;
   1433     UINT32                  SubTableLength;
   1434     UINT32                  GtCount;
   1435     ACPI_GTDT_TIMER_ENTRY   *GtxTable;
   1436 
   1437 
   1438     /* Main table */
   1439 
   1440     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt);
   1441     if (ACPI_FAILURE (Status))
   1442     {
   1443         return;
   1444     }
   1445 
   1446     /* Subtables */
   1447 
   1448     SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset);
   1449     while (Offset < Table->Length)
   1450     {
   1451         /* Common subtable header */
   1452 
   1453         AcpiOsPrintf ("\n");
   1454         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   1455             SubTable->Length, AcpiDmTableInfoGtdtHdr);
   1456         if (ACPI_FAILURE (Status))
   1457         {
   1458             return;
   1459         }
   1460 
   1461         GtCount = 0;
   1462         switch (SubTable->Type)
   1463         {
   1464         case ACPI_GTDT_TYPE_TIMER_BLOCK:
   1465 
   1466             SubTableLength = sizeof (ACPI_GTDT_TIMER_BLOCK);
   1467             GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK,
   1468                 SubTable))->TimerCount;
   1469 
   1470             InfoTable = AcpiDmTableInfoGtdt0;
   1471             break;
   1472 
   1473         case ACPI_GTDT_TYPE_WATCHDOG:
   1474 
   1475             SubTableLength = sizeof (ACPI_GTDT_WATCHDOG);
   1476 
   1477             InfoTable = AcpiDmTableInfoGtdt1;
   1478             break;
   1479 
   1480         default:
   1481 
   1482             /* Cannot continue on unknown type - no length */
   1483 
   1484             AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n",
   1485                 SubTable->Type);
   1486             return;
   1487         }
   1488 
   1489         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   1490             SubTable->Length, InfoTable);
   1491         if (ACPI_FAILURE (Status))
   1492         {
   1493             return;
   1494         }
   1495 
   1496         /* Point to end of current subtable (each subtable above is of fixed length) */
   1497 
   1498         Offset += SubTableLength;
   1499 
   1500         /* If there are any Gt Timer Blocks from above, dump them now */
   1501 
   1502         if (GtCount)
   1503         {
   1504             GtxTable = ACPI_ADD_PTR (
   1505                 ACPI_GTDT_TIMER_ENTRY, SubTable, SubTableLength);
   1506             SubTableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY);
   1507 
   1508             while (GtCount)
   1509             {
   1510                 AcpiOsPrintf ("\n");
   1511                 Status = AcpiDmDumpTable (Length, Offset, GtxTable,
   1512                     sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a);
   1513                 if (ACPI_FAILURE (Status))
   1514                 {
   1515                     return;
   1516                 }
   1517                 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY);
   1518                 GtxTable++;
   1519                 GtCount--;
   1520             }
   1521         }
   1522 
   1523         /* Point to next subtable */
   1524 
   1525         SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, SubTable, SubTableLength);
   1526     }
   1527 }
   1528 
   1529 
   1530 /*******************************************************************************
   1531  *
   1532  * FUNCTION:    AcpiDmDumpHest
   1533  *
   1534  * PARAMETERS:  Table               - A HEST table
   1535  *
   1536  * RETURN:      None
   1537  *
   1538  * DESCRIPTION: Format the contents of a HEST. This table type consists
   1539  *              of an open-ended number of subtables.
   1540  *
   1541  ******************************************************************************/
   1542 
   1543 void
   1544 AcpiDmDumpHest (
   1545     ACPI_TABLE_HEADER       *Table)
   1546 {
   1547     ACPI_STATUS             Status;
   1548     ACPI_HEST_HEADER        *SubTable;
   1549     UINT32                  Length = Table->Length;
   1550     UINT32                  Offset = sizeof (ACPI_TABLE_HEST);
   1551     ACPI_DMTABLE_INFO       *InfoTable;
   1552     UINT32                  SubTableLength;
   1553     UINT32                  BankCount;
   1554     ACPI_HEST_IA_ERROR_BANK *BankTable;
   1555 
   1556 
   1557     /* Main table */
   1558 
   1559     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
   1560     if (ACPI_FAILURE (Status))
   1561     {
   1562         return;
   1563     }
   1564 
   1565     /* Subtables */
   1566 
   1567     SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
   1568     while (Offset < Table->Length)
   1569     {
   1570         BankCount = 0;
   1571         switch (SubTable->Type)
   1572         {
   1573         case ACPI_HEST_TYPE_IA32_CHECK:
   1574 
   1575             InfoTable = AcpiDmTableInfoHest0;
   1576             SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
   1577             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
   1578                 SubTable))->NumHardwareBanks;
   1579             break;
   1580 
   1581         case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
   1582 
   1583             InfoTable = AcpiDmTableInfoHest1;
   1584             SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED);
   1585             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
   1586                 SubTable))->NumHardwareBanks;
   1587             break;
   1588 
   1589         case ACPI_HEST_TYPE_IA32_NMI:
   1590 
   1591             InfoTable = AcpiDmTableInfoHest2;
   1592             SubTableLength = sizeof (ACPI_HEST_IA_NMI);
   1593             break;
   1594 
   1595         case ACPI_HEST_TYPE_AER_ROOT_PORT:
   1596 
   1597             InfoTable = AcpiDmTableInfoHest6;
   1598             SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
   1599             break;
   1600 
   1601         case ACPI_HEST_TYPE_AER_ENDPOINT:
   1602 
   1603             InfoTable = AcpiDmTableInfoHest7;
   1604             SubTableLength = sizeof (ACPI_HEST_AER);
   1605             break;
   1606 
   1607         case ACPI_HEST_TYPE_AER_BRIDGE:
   1608 
   1609             InfoTable = AcpiDmTableInfoHest8;
   1610             SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
   1611             break;
   1612 
   1613         case ACPI_HEST_TYPE_GENERIC_ERROR:
   1614 
   1615             InfoTable = AcpiDmTableInfoHest9;
   1616             SubTableLength = sizeof (ACPI_HEST_GENERIC);
   1617             break;
   1618 
   1619         case ACPI_HEST_TYPE_GENERIC_ERROR_V2:
   1620 
   1621             InfoTable = AcpiDmTableInfoHest10;
   1622             SubTableLength = sizeof (ACPI_HEST_GENERIC_V2);
   1623             break;
   1624 
   1625         case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK:
   1626 
   1627             InfoTable = AcpiDmTableInfoHest11;
   1628             SubTableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK);
   1629             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK,
   1630                 SubTable))->NumHardwareBanks;
   1631             break;
   1632 
   1633         default:
   1634 
   1635             /* Cannot continue on unknown type - no length */
   1636 
   1637             AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n",
   1638                 SubTable->Type);
   1639             return;
   1640         }
   1641 
   1642         AcpiOsPrintf ("\n");
   1643         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   1644             SubTableLength, InfoTable);
   1645         if (ACPI_FAILURE (Status))
   1646         {
   1647             return;
   1648         }
   1649 
   1650         /* Point to end of current subtable (each subtable above is of fixed length) */
   1651 
   1652         Offset += SubTableLength;
   1653 
   1654         /* If there are any (fixed-length) Error Banks from above, dump them now */
   1655 
   1656         if (BankCount)
   1657         {
   1658             BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable,
   1659                 SubTableLength);
   1660             SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
   1661 
   1662             while (BankCount)
   1663             {
   1664                 AcpiOsPrintf ("\n");
   1665                 Status = AcpiDmDumpTable (Length, Offset, BankTable,
   1666                     sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
   1667                 if (ACPI_FAILURE (Status))
   1668                 {
   1669                     return;
   1670                 }
   1671 
   1672                 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
   1673                 BankTable++;
   1674                 BankCount--;
   1675             }
   1676         }
   1677 
   1678         /* Point to next subtable */
   1679 
   1680         SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
   1681     }
   1682 }
   1683 
   1684 
   1685 /*******************************************************************************
   1686  *
   1687  * FUNCTION:    AcpiDmDumpHmat
   1688  *
   1689  * PARAMETERS:  Table               - A HMAT table
   1690  *
   1691  * RETURN:      None
   1692  *
   1693  * DESCRIPTION: Format the contents of a HMAT.
   1694  *
   1695  ******************************************************************************/
   1696 
   1697 void
   1698 AcpiDmDumpHmat (
   1699     ACPI_TABLE_HEADER       *Table)
   1700 {
   1701     ACPI_STATUS             Status;
   1702     ACPI_HMAT_STRUCTURE     *HmatStruct;
   1703     ACPI_HMAT_LOCALITY      *HmatLocality;
   1704     ACPI_HMAT_CACHE         *HmatCache;
   1705     UINT32                  Offset;
   1706     UINT32                  SubTableOffset;
   1707     UINT32                  Length;
   1708     ACPI_DMTABLE_INFO       *InfoTable;
   1709     UINT32                  i, j;
   1710 
   1711 
   1712     /* Main table */
   1713 
   1714     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat);
   1715     if (ACPI_FAILURE (Status))
   1716     {
   1717         return;
   1718     }
   1719     Offset = sizeof (ACPI_TABLE_HMAT);
   1720 
   1721     while (Offset < Table->Length)
   1722     {
   1723         AcpiOsPrintf ("\n");
   1724         SubTableOffset = 0;
   1725 
   1726         /* Dump HMAT structure header */
   1727 
   1728         HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset);
   1729         if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE))
   1730         {
   1731             AcpiOsPrintf ("Invalid HMAT structure length\n");
   1732             return;
   1733         }
   1734         Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
   1735             HmatStruct->Length, AcpiDmTableInfoHmatHdr);
   1736         if (ACPI_FAILURE (Status))
   1737         {
   1738             return;
   1739         }
   1740 
   1741         switch (HmatStruct->Type)
   1742         {
   1743         case ACPI_HMAT_TYPE_ADDRESS_RANGE:
   1744 
   1745             InfoTable = AcpiDmTableInfoHmat0;
   1746             Length = sizeof (ACPI_HMAT_ADDRESS_RANGE);
   1747             break;
   1748 
   1749         case ACPI_HMAT_TYPE_LOCALITY:
   1750 
   1751             InfoTable = AcpiDmTableInfoHmat1;
   1752             Length = sizeof (ACPI_HMAT_LOCALITY);
   1753             break;
   1754 
   1755         case ACPI_HMAT_TYPE_CACHE:
   1756 
   1757             InfoTable = AcpiDmTableInfoHmat2;
   1758             Length = sizeof (ACPI_HMAT_CACHE);
   1759             break;
   1760 
   1761         default:
   1762 
   1763             AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n",
   1764                 HmatStruct->Type);
   1765 
   1766             /* Attempt to continue */
   1767 
   1768             goto NextSubTable;
   1769         }
   1770 
   1771         /* Dump HMAT structure body */
   1772 
   1773         if (HmatStruct->Length < Length)
   1774         {
   1775             AcpiOsPrintf ("Invalid HMAT structure length\n");
   1776             return;
   1777         }
   1778         Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct,
   1779             HmatStruct->Length, InfoTable);
   1780         if (ACPI_FAILURE (Status))
   1781         {
   1782             return;
   1783         }
   1784 
   1785         /* Dump HMAT structure additionals */
   1786 
   1787         switch (HmatStruct->Type)
   1788         {
   1789         case ACPI_HMAT_TYPE_LOCALITY:
   1790 
   1791             HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct);
   1792             SubTableOffset = sizeof (ACPI_HMAT_LOCALITY);
   1793 
   1794             /* Dump initiator proximity domains */
   1795 
   1796             if ((UINT32)(HmatStruct->Length - SubTableOffset) <
   1797                 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4))
   1798             {
   1799                 AcpiOsPrintf ("Invalid initiator proximity domain number\n");
   1800                 return;
   1801             }
   1802             for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
   1803             {
   1804                 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
   1805                     ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
   1806                     4, AcpiDmTableInfoHmat1a);
   1807                 SubTableOffset += 4;
   1808             }
   1809 
   1810             /* Dump target proximity domains */
   1811 
   1812             if ((UINT32)(HmatStruct->Length - SubTableOffset) <
   1813                 (UINT32)(HmatLocality->NumberOfTargetPDs * 4))
   1814             {
   1815                 AcpiOsPrintf ("Invalid target proximity domain number\n");
   1816                 return;
   1817             }
   1818             for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++)
   1819             {
   1820                 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
   1821                     ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
   1822                     4, AcpiDmTableInfoHmat1b);
   1823                 SubTableOffset += 4;
   1824             }
   1825 
   1826             /* Dump latency/bandwidth entris */
   1827 
   1828             if ((UINT32)(HmatStruct->Length - SubTableOffset) <
   1829                 (UINT32)(HmatLocality->NumberOfInitiatorPDs *
   1830                          HmatLocality->NumberOfTargetPDs * 2))
   1831             {
   1832                 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n");
   1833                 return;
   1834             }
   1835             for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++)
   1836             {
   1837                 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++)
   1838                 {
   1839                     Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
   1840                         ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
   1841                         2, AcpiDmTableInfoHmat1c);
   1842                     SubTableOffset += 2;
   1843                 }
   1844             }
   1845             break;
   1846 
   1847         case ACPI_HMAT_TYPE_CACHE:
   1848 
   1849             HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct);
   1850             SubTableOffset = sizeof (ACPI_HMAT_CACHE);
   1851 
   1852             /* Dump SMBIOS handles */
   1853 
   1854             if ((UINT32)(HmatStruct->Length - SubTableOffset) <
   1855                 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2))
   1856             {
   1857                 AcpiOsPrintf ("Invalid SMBIOS handle number\n");
   1858                 return;
   1859             }
   1860             for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++)
   1861             {
   1862                 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
   1863                     ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset),
   1864                     2, AcpiDmTableInfoHmat2a);
   1865                 SubTableOffset += 2;
   1866             }
   1867             break;
   1868 
   1869         default:
   1870 
   1871             break;
   1872         }
   1873 
   1874 NextSubTable:
   1875         /* Point to next HMAT structure subtable */
   1876 
   1877         Offset += (HmatStruct->Length);
   1878     }
   1879 }
   1880 
   1881 
   1882 /*******************************************************************************
   1883  *
   1884  * FUNCTION:    AcpiDmDumpIort
   1885  *
   1886  * PARAMETERS:  Table               - A IORT table
   1887  *
   1888  * RETURN:      None
   1889  *
   1890  * DESCRIPTION: Format the contents of a IORT
   1891  *
   1892  ******************************************************************************/
   1893 
   1894 void
   1895 AcpiDmDumpIort (
   1896     ACPI_TABLE_HEADER       *Table)
   1897 {
   1898     ACPI_STATUS             Status;
   1899     ACPI_TABLE_IORT         *Iort;
   1900     ACPI_IORT_NODE          *IortNode;
   1901     ACPI_IORT_ITS_GROUP     *IortItsGroup = NULL;
   1902     ACPI_IORT_SMMU          *IortSmmu = NULL;
   1903     UINT32                  Offset;
   1904     UINT32                  NodeOffset;
   1905     UINT32                  Length;
   1906     ACPI_DMTABLE_INFO       *InfoTable;
   1907     char                    *String;
   1908     UINT32                  i;
   1909 
   1910 
   1911     /* Main table */
   1912 
   1913     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort);
   1914     if (ACPI_FAILURE (Status))
   1915     {
   1916         return;
   1917     }
   1918 
   1919     Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table);
   1920     Offset = sizeof (ACPI_TABLE_IORT);
   1921 
   1922     /* Dump the OptionalPadding (optional) */
   1923 
   1924     if (Iort->NodeOffset > Offset)
   1925     {
   1926         Status = AcpiDmDumpTable (Table->Length, Offset, Table,
   1927             Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad);
   1928         if (ACPI_FAILURE (Status))
   1929         {
   1930             return;
   1931         }
   1932     }
   1933 
   1934     Offset = Iort->NodeOffset;
   1935     while (Offset < Table->Length)
   1936     {
   1937         /* Common subtable header */
   1938 
   1939         IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset);
   1940         AcpiOsPrintf ("\n");
   1941         Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
   1942         Status = AcpiDmDumpTable (Table->Length, Offset,
   1943             IortNode, Length, AcpiDmTableInfoIortHdr);
   1944         if (ACPI_FAILURE (Status))
   1945         {
   1946             return;
   1947         }
   1948 
   1949         NodeOffset = Length;
   1950 
   1951         switch (IortNode->Type)
   1952         {
   1953         case ACPI_IORT_NODE_ITS_GROUP:
   1954 
   1955             InfoTable = AcpiDmTableInfoIort0;
   1956             Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers);
   1957             IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset);
   1958             break;
   1959 
   1960         case ACPI_IORT_NODE_NAMED_COMPONENT:
   1961 
   1962             InfoTable = AcpiDmTableInfoIort1;
   1963             Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName);
   1964             String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length);
   1965             Length += strlen (String) + 1;
   1966             break;
   1967 
   1968         case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
   1969 
   1970             InfoTable = AcpiDmTableInfoIort2;
   1971             Length = IortNode->Length - NodeOffset;
   1972             break;
   1973 
   1974         case ACPI_IORT_NODE_SMMU:
   1975 
   1976             InfoTable = AcpiDmTableInfoIort3;
   1977             Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts);
   1978             IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset);
   1979             break;
   1980 
   1981         case ACPI_IORT_NODE_SMMU_V3:
   1982 
   1983             InfoTable = AcpiDmTableInfoIort4;
   1984             Length = IortNode->Length - NodeOffset;
   1985             break;
   1986 
   1987         default:
   1988 
   1989             AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n",
   1990                 IortNode->Type);
   1991 
   1992             /* Attempt to continue */
   1993 
   1994             if (!IortNode->Length)
   1995             {
   1996                 AcpiOsPrintf ("Invalid zero length IORT node\n");
   1997                 return;
   1998             }
   1999             goto NextSubTable;
   2000         }
   2001 
   2002         /* Dump the node subtable header */
   2003 
   2004         AcpiOsPrintf ("\n");
   2005         Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
   2006             ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
   2007             Length, InfoTable);
   2008         if (ACPI_FAILURE (Status))
   2009         {
   2010             return;
   2011         }
   2012 
   2013         NodeOffset += Length;
   2014 
   2015         /* Dump the node specific data */
   2016 
   2017         switch (IortNode->Type)
   2018         {
   2019         case ACPI_IORT_NODE_ITS_GROUP:
   2020 
   2021             /* Validate IortItsGroup to avoid compiler warnings */
   2022 
   2023             if (IortItsGroup)
   2024             {
   2025                 for (i = 0; i < IortItsGroup->ItsCount; i++)
   2026                 {
   2027                     Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
   2028                         ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
   2029                         4, AcpiDmTableInfoIort0a);
   2030                     NodeOffset += 4;
   2031                 }
   2032             }
   2033             break;
   2034 
   2035         case ACPI_IORT_NODE_NAMED_COMPONENT:
   2036 
   2037             /* Dump the Padding (optional) */
   2038 
   2039             if (IortNode->Length > NodeOffset)
   2040             {
   2041                 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
   2042                     Table, IortNode->Length - NodeOffset,
   2043                     AcpiDmTableInfoIort1a);
   2044                 if (ACPI_FAILURE (Status))
   2045                 {
   2046                     return;
   2047                 }
   2048             }
   2049             break;
   2050 
   2051         case ACPI_IORT_NODE_SMMU:
   2052 
   2053             AcpiOsPrintf ("\n");
   2054 
   2055             /* Validate IortSmmu to avoid compiler warnings */
   2056 
   2057             if (IortSmmu)
   2058             {
   2059                 Length = 2 * sizeof (UINT64);
   2060                 NodeOffset = IortSmmu->GlobalInterruptOffset;
   2061                 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
   2062                     ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
   2063                     Length, AcpiDmTableInfoIort3a);
   2064                 if (ACPI_FAILURE (Status))
   2065                 {
   2066                     return;
   2067                 }
   2068 
   2069                 NodeOffset = IortSmmu->ContextInterruptOffset;
   2070                 for (i = 0; i < IortSmmu->ContextInterruptCount; i++)
   2071                 {
   2072                     Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
   2073                         ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
   2074                         8, AcpiDmTableInfoIort3b);
   2075                     if (ACPI_FAILURE (Status))
   2076                     {
   2077                         return;
   2078                     }
   2079 
   2080                     NodeOffset += 8;
   2081                 }
   2082 
   2083                 NodeOffset = IortSmmu->PmuInterruptOffset;
   2084                 for (i = 0; i < IortSmmu->PmuInterruptCount; i++)
   2085                 {
   2086                     Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
   2087                         ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
   2088                         8, AcpiDmTableInfoIort3c);
   2089                     if (ACPI_FAILURE (Status))
   2090                     {
   2091                         return;
   2092                     }
   2093 
   2094                     NodeOffset += 8;
   2095                 }
   2096             }
   2097             break;
   2098 
   2099         default:
   2100 
   2101             break;
   2102         }
   2103 
   2104         /* Dump the ID mappings */
   2105 
   2106         NodeOffset = IortNode->MappingOffset;
   2107         for (i = 0; i < IortNode->MappingCount; i++)
   2108         {
   2109             AcpiOsPrintf ("\n");
   2110             Length = sizeof (ACPI_IORT_ID_MAPPING);
   2111             Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
   2112                 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
   2113                 Length, AcpiDmTableInfoIortMap);
   2114             if (ACPI_FAILURE (Status))
   2115             {
   2116                 return;
   2117             }
   2118 
   2119             NodeOffset += Length;
   2120         }
   2121 
   2122 NextSubTable:
   2123         /* Point to next node subtable */
   2124 
   2125         Offset += IortNode->Length;
   2126         IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length);
   2127     }
   2128 }
   2129 
   2130 
   2131 /*******************************************************************************
   2132  *
   2133  * FUNCTION:    AcpiDmDumpIvrs
   2134  *
   2135  * PARAMETERS:  Table               - A IVRS table
   2136  *
   2137  * RETURN:      None
   2138  *
   2139  * DESCRIPTION: Format the contents of a IVRS
   2140  *
   2141  ******************************************************************************/
   2142 
   2143 static UINT8 EntrySizes[] = {4,8,16,32};
   2144 
   2145 void
   2146 AcpiDmDumpIvrs (
   2147     ACPI_TABLE_HEADER       *Table)
   2148 {
   2149     ACPI_STATUS             Status;
   2150     UINT32                  Offset = sizeof (ACPI_TABLE_IVRS);
   2151     UINT32                  EntryOffset;
   2152     UINT32                  EntryLength;
   2153     UINT32                  EntryType;
   2154     ACPI_IVRS_DE_HEADER     *DeviceEntry;
   2155     ACPI_IVRS_HEADER        *SubTable;
   2156     ACPI_DMTABLE_INFO       *InfoTable;
   2157 
   2158 
   2159     /* Main table */
   2160 
   2161     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
   2162     if (ACPI_FAILURE (Status))
   2163     {
   2164         return;
   2165     }
   2166 
   2167     /* Subtables */
   2168 
   2169     SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
   2170     while (Offset < Table->Length)
   2171     {
   2172         /* Common subtable header */
   2173 
   2174         AcpiOsPrintf ("\n");
   2175         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   2176             SubTable->Length, AcpiDmTableInfoIvrsHdr);
   2177         if (ACPI_FAILURE (Status))
   2178         {
   2179             return;
   2180         }
   2181 
   2182         switch (SubTable->Type)
   2183         {
   2184         case ACPI_IVRS_TYPE_HARDWARE:
   2185 
   2186             InfoTable = AcpiDmTableInfoIvrs0;
   2187             break;
   2188 
   2189         case ACPI_IVRS_TYPE_MEMORY1:
   2190         case ACPI_IVRS_TYPE_MEMORY2:
   2191         case ACPI_IVRS_TYPE_MEMORY3:
   2192 
   2193             InfoTable = AcpiDmTableInfoIvrs1;
   2194             break;
   2195 
   2196         default:
   2197 
   2198             AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n",
   2199                 SubTable->Type);
   2200 
   2201             /* Attempt to continue */
   2202 
   2203             if (!SubTable->Length)
   2204             {
   2205                 AcpiOsPrintf ("Invalid zero length subtable\n");
   2206                 return;
   2207             }
   2208             goto NextSubTable;
   2209         }
   2210 
   2211         /* Dump the subtable */
   2212 
   2213         AcpiOsPrintf ("\n");
   2214         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   2215             SubTable->Length, InfoTable);
   2216         if (ACPI_FAILURE (Status))
   2217         {
   2218             return;
   2219         }
   2220 
   2221         /* The hardware subtable can contain multiple device entries */
   2222 
   2223         if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
   2224         {
   2225             EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
   2226             DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
   2227                 sizeof (ACPI_IVRS_HARDWARE));
   2228 
   2229             while (EntryOffset < (Offset + SubTable->Length))
   2230             {
   2231                 AcpiOsPrintf ("\n");
   2232                 /*
   2233                  * Upper 2 bits of Type encode the length of the device entry
   2234                  *
   2235                  * 00 = 4 byte
   2236                  * 01 = 8 byte
   2237                  * 10 = 16 byte - currently no entries defined
   2238                  * 11 = 32 byte - currently no entries defined
   2239                  */
   2240                 EntryType = DeviceEntry->Type;
   2241                 EntryLength = EntrySizes [EntryType >> 6];
   2242 
   2243                 switch (EntryType)
   2244                 {
   2245                 /* 4-byte device entries */
   2246 
   2247                 case ACPI_IVRS_TYPE_PAD4:
   2248                 case ACPI_IVRS_TYPE_ALL:
   2249                 case ACPI_IVRS_TYPE_SELECT:
   2250                 case ACPI_IVRS_TYPE_START:
   2251                 case ACPI_IVRS_TYPE_END:
   2252 
   2253                     InfoTable = AcpiDmTableInfoIvrs4;
   2254                     break;
   2255 
   2256                 /* 8-byte entries, type A */
   2257 
   2258                 case ACPI_IVRS_TYPE_ALIAS_SELECT:
   2259                 case ACPI_IVRS_TYPE_ALIAS_START:
   2260 
   2261                     InfoTable = AcpiDmTableInfoIvrs8a;
   2262                     break;
   2263 
   2264                 /* 8-byte entries, type B */
   2265 
   2266                 case ACPI_IVRS_TYPE_PAD8:
   2267                 case ACPI_IVRS_TYPE_EXT_SELECT:
   2268                 case ACPI_IVRS_TYPE_EXT_START:
   2269 
   2270                     InfoTable = AcpiDmTableInfoIvrs8b;
   2271                     break;
   2272 
   2273                 /* 8-byte entries, type C */
   2274 
   2275                 case ACPI_IVRS_TYPE_SPECIAL:
   2276 
   2277                     InfoTable = AcpiDmTableInfoIvrs8c;
   2278                     break;
   2279 
   2280                 default:
   2281                     InfoTable = AcpiDmTableInfoIvrs4;
   2282                     AcpiOsPrintf (
   2283                         "\n**** Unknown IVRS device entry type/length: "
   2284                         "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
   2285                         EntryType, EntryLength, EntryOffset);
   2286                     break;
   2287                 }
   2288 
   2289                 /* Dump the Device Entry */
   2290 
   2291                 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
   2292                     DeviceEntry, EntryLength, InfoTable);
   2293                 if (ACPI_FAILURE (Status))
   2294                 {
   2295                     return;
   2296                 }
   2297 
   2298                 EntryOffset += EntryLength;
   2299                 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
   2300                     EntryLength);
   2301             }
   2302         }
   2303 
   2304 NextSubTable:
   2305         /* Point to next subtable */
   2306 
   2307         Offset += SubTable->Length;
   2308         SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
   2309     }
   2310 }
   2311 
   2312 
   2313 /*******************************************************************************
   2314  *
   2315  * FUNCTION:    AcpiDmDumpLpit
   2316  *
   2317  * PARAMETERS:  Table               - A LPIT table
   2318  *
   2319  * RETURN:      None
   2320  *
   2321  * DESCRIPTION: Format the contents of a LPIT. This table type consists
   2322  *              of an open-ended number of subtables. Note: There are no
   2323  *              entries in the main table. An LPIT consists of the table
   2324  *              header and then subtables only.
   2325  *
   2326  ******************************************************************************/
   2327 
   2328 void
   2329 AcpiDmDumpLpit (
   2330     ACPI_TABLE_HEADER       *Table)
   2331 {
   2332     ACPI_STATUS             Status;
   2333     ACPI_LPIT_HEADER        *SubTable;
   2334     UINT32                  Length = Table->Length;
   2335     UINT32                  Offset = sizeof (ACPI_TABLE_LPIT);
   2336     ACPI_DMTABLE_INFO       *InfoTable;
   2337     UINT32                  SubTableLength;
   2338 
   2339 
   2340     /* Subtables */
   2341 
   2342     SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset);
   2343     while (Offset < Table->Length)
   2344     {
   2345         /* Common subtable header */
   2346 
   2347         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   2348             sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr);
   2349         if (ACPI_FAILURE (Status))
   2350         {
   2351             return;
   2352         }
   2353 
   2354         switch (SubTable->Type)
   2355         {
   2356         case ACPI_LPIT_TYPE_NATIVE_CSTATE:
   2357 
   2358             InfoTable = AcpiDmTableInfoLpit0;
   2359             SubTableLength = sizeof (ACPI_LPIT_NATIVE);
   2360             break;
   2361 
   2362         default:
   2363 
   2364             /* Cannot continue on unknown type - no length */
   2365 
   2366             AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n",
   2367                 SubTable->Type);
   2368             return;
   2369         }
   2370 
   2371         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   2372             SubTableLength, InfoTable);
   2373         if (ACPI_FAILURE (Status))
   2374         {
   2375             return;
   2376         }
   2377 
   2378         AcpiOsPrintf ("\n");
   2379 
   2380         /* Point to next subtable */
   2381 
   2382         Offset += SubTableLength;
   2383         SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, SubTable, SubTableLength);
   2384     }
   2385 }
   2386 
   2387 
   2388 /*******************************************************************************
   2389  *
   2390  * FUNCTION:    AcpiDmDumpMadt
   2391  *
   2392  * PARAMETERS:  Table               - A MADT table
   2393  *
   2394  * RETURN:      None
   2395  *
   2396  * DESCRIPTION: Format the contents of a MADT. This table type consists
   2397  *              of an open-ended number of subtables.
   2398  *
   2399  ******************************************************************************/
   2400 
   2401 void
   2402 AcpiDmDumpMadt (
   2403     ACPI_TABLE_HEADER       *Table)
   2404 {
   2405     ACPI_STATUS             Status;
   2406     ACPI_SUBTABLE_HEADER    *SubTable;
   2407     UINT32                  Length = Table->Length;
   2408     UINT32                  Offset = sizeof (ACPI_TABLE_MADT);
   2409     ACPI_DMTABLE_INFO       *InfoTable;
   2410 
   2411 
   2412     /* Main table */
   2413 
   2414     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
   2415     if (ACPI_FAILURE (Status))
   2416     {
   2417         return;
   2418     }
   2419 
   2420     /* Subtables */
   2421 
   2422     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
   2423     while (Offset < Table->Length)
   2424     {
   2425         /* Common subtable header */
   2426 
   2427         AcpiOsPrintf ("\n");
   2428         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   2429             SubTable->Length, AcpiDmTableInfoMadtHdr);
   2430         if (ACPI_FAILURE (Status))
   2431         {
   2432             return;
   2433         }
   2434 
   2435         switch (SubTable->Type)
   2436         {
   2437         case ACPI_MADT_TYPE_LOCAL_APIC:
   2438 
   2439             InfoTable = AcpiDmTableInfoMadt0;
   2440             break;
   2441 
   2442         case ACPI_MADT_TYPE_IO_APIC:
   2443 
   2444             InfoTable = AcpiDmTableInfoMadt1;
   2445             break;
   2446 
   2447         case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
   2448 
   2449             InfoTable = AcpiDmTableInfoMadt2;
   2450             break;
   2451 
   2452         case ACPI_MADT_TYPE_NMI_SOURCE:
   2453 
   2454             InfoTable = AcpiDmTableInfoMadt3;
   2455             break;
   2456 
   2457         case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
   2458 
   2459             InfoTable = AcpiDmTableInfoMadt4;
   2460             break;
   2461 
   2462         case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
   2463 
   2464             InfoTable = AcpiDmTableInfoMadt5;
   2465             break;
   2466 
   2467         case ACPI_MADT_TYPE_IO_SAPIC:
   2468 
   2469             InfoTable = AcpiDmTableInfoMadt6;
   2470             break;
   2471 
   2472         case ACPI_MADT_TYPE_LOCAL_SAPIC:
   2473 
   2474             InfoTable = AcpiDmTableInfoMadt7;
   2475             break;
   2476 
   2477         case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
   2478 
   2479             InfoTable = AcpiDmTableInfoMadt8;
   2480             break;
   2481 
   2482         case ACPI_MADT_TYPE_LOCAL_X2APIC:
   2483 
   2484             InfoTable = AcpiDmTableInfoMadt9;
   2485             break;
   2486 
   2487         case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
   2488 
   2489             InfoTable = AcpiDmTableInfoMadt10;
   2490             break;
   2491 
   2492         case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
   2493 
   2494             InfoTable = AcpiDmTableInfoMadt11;
   2495             break;
   2496 
   2497         case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
   2498 
   2499             InfoTable = AcpiDmTableInfoMadt12;
   2500             break;
   2501 
   2502         case ACPI_MADT_TYPE_GENERIC_MSI_FRAME:
   2503 
   2504             InfoTable = AcpiDmTableInfoMadt13;
   2505             break;
   2506 
   2507         case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
   2508 
   2509             InfoTable = AcpiDmTableInfoMadt14;
   2510             break;
   2511 
   2512         case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
   2513 
   2514             InfoTable = AcpiDmTableInfoMadt15;
   2515             break;
   2516 
   2517         default:
   2518 
   2519             AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n",
   2520                 SubTable->Type);
   2521 
   2522             /* Attempt to continue */
   2523 
   2524             if (!SubTable->Length)
   2525             {
   2526                 AcpiOsPrintf ("Invalid zero length subtable\n");
   2527                 return;
   2528             }
   2529 
   2530             goto NextSubTable;
   2531         }
   2532 
   2533         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   2534             SubTable->Length, InfoTable);
   2535         if (ACPI_FAILURE (Status))
   2536         {
   2537             return;
   2538         }
   2539 
   2540 NextSubTable:
   2541         /* Point to next subtable */
   2542 
   2543         Offset += SubTable->Length;
   2544         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable,
   2545             SubTable->Length);
   2546     }
   2547 }
   2548 
   2549 
   2550 /*******************************************************************************
   2551  *
   2552  * FUNCTION:    AcpiDmDumpMcfg
   2553  *
   2554  * PARAMETERS:  Table               - A MCFG Table
   2555  *
   2556  * RETURN:      None
   2557  *
   2558  * DESCRIPTION: Format the contents of a MCFG table
   2559  *
   2560  ******************************************************************************/
   2561 
   2562 void
   2563 AcpiDmDumpMcfg (
   2564     ACPI_TABLE_HEADER       *Table)
   2565 {
   2566     ACPI_STATUS             Status;
   2567     UINT32                  Offset = sizeof (ACPI_TABLE_MCFG);
   2568     ACPI_MCFG_ALLOCATION    *SubTable;
   2569 
   2570 
   2571     /* Main table */
   2572 
   2573     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
   2574     if (ACPI_FAILURE (Status))
   2575     {
   2576         return;
   2577     }
   2578 
   2579     /* Subtables */
   2580 
   2581     SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
   2582     while (Offset < Table->Length)
   2583     {
   2584         if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
   2585         {
   2586             AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
   2587                 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
   2588             return;
   2589         }
   2590 
   2591         AcpiOsPrintf ("\n");
   2592         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   2593             sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
   2594         if (ACPI_FAILURE (Status))
   2595         {
   2596             return;
   2597         }
   2598 
   2599         /* Point to next subtable (each subtable is of fixed length) */
   2600 
   2601         Offset += sizeof (ACPI_MCFG_ALLOCATION);
   2602         SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
   2603             sizeof (ACPI_MCFG_ALLOCATION));
   2604     }
   2605 }
   2606 
   2607 
   2608 /*******************************************************************************
   2609  *
   2610  * FUNCTION:    AcpiDmDumpMpst
   2611  *
   2612  * PARAMETERS:  Table               - A MPST Table
   2613  *
   2614  * RETURN:      None
   2615  *
   2616  * DESCRIPTION: Format the contents of a MPST table
   2617  *
   2618  ******************************************************************************/
   2619 
   2620 void
   2621 AcpiDmDumpMpst (
   2622     ACPI_TABLE_HEADER       *Table)
   2623 {
   2624     ACPI_STATUS             Status;
   2625     UINT32                  Offset = sizeof (ACPI_TABLE_MPST);
   2626     ACPI_MPST_POWER_NODE    *SubTable0;
   2627     ACPI_MPST_POWER_STATE   *SubTable0A;
   2628     ACPI_MPST_COMPONENT     *SubTable0B;
   2629     ACPI_MPST_DATA_HDR      *SubTable1;
   2630     ACPI_MPST_POWER_DATA    *SubTable2;
   2631     UINT16                  SubtableCount;
   2632     UINT32                  PowerStateCount;
   2633     UINT32                  ComponentCount;
   2634 
   2635 
   2636     /* Main table */
   2637 
   2638     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
   2639     if (ACPI_FAILURE (Status))
   2640     {
   2641         return;
   2642     }
   2643 
   2644     /* Subtable: Memory Power Node(s) */
   2645 
   2646     SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
   2647     SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
   2648 
   2649     while ((Offset < Table->Length) && SubtableCount)
   2650     {
   2651         AcpiOsPrintf ("\n");
   2652         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0,
   2653             sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
   2654         if (ACPI_FAILURE (Status))
   2655         {
   2656             return;
   2657         }
   2658 
   2659         /* Extract the sub-subtable counts */
   2660 
   2661         PowerStateCount = SubTable0->NumPowerStates;
   2662         ComponentCount = SubTable0->NumPhysicalComponents;
   2663         Offset += sizeof (ACPI_MPST_POWER_NODE);
   2664 
   2665         /* Sub-subtables - Memory Power State Structure(s) */
   2666 
   2667         SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0,
   2668             sizeof (ACPI_MPST_POWER_NODE));
   2669 
   2670         while (PowerStateCount)
   2671         {
   2672             AcpiOsPrintf ("\n");
   2673             Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A,
   2674                 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
   2675             if (ACPI_FAILURE (Status))
   2676             {
   2677                 return;
   2678             }
   2679 
   2680             SubTable0A++;
   2681             PowerStateCount--;
   2682             Offset += sizeof (ACPI_MPST_POWER_STATE);
   2683        }
   2684 
   2685         /* Sub-subtables - Physical Component ID Structure(s) */
   2686 
   2687         SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A);
   2688 
   2689         if (ComponentCount)
   2690         {
   2691             AcpiOsPrintf ("\n");
   2692         }
   2693 
   2694         while (ComponentCount)
   2695         {
   2696             Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B,
   2697                 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
   2698             if (ACPI_FAILURE (Status))
   2699             {
   2700                 return;
   2701             }
   2702 
   2703             SubTable0B++;
   2704             ComponentCount--;
   2705             Offset += sizeof (ACPI_MPST_COMPONENT);
   2706         }
   2707 
   2708         /* Point to next Memory Power Node subtable */
   2709 
   2710         SubtableCount--;
   2711         SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0,
   2712             sizeof (ACPI_MPST_POWER_NODE) +
   2713             (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) +
   2714             (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents));
   2715     }
   2716 
   2717     /* Subtable: Count of Memory Power State Characteristic structures */
   2718 
   2719     AcpiOsPrintf ("\n");
   2720     SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0);
   2721     Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1,
   2722         sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
   2723     if (ACPI_FAILURE (Status))
   2724     {
   2725         return;
   2726     }
   2727 
   2728     SubtableCount = SubTable1->CharacteristicsCount;
   2729     Offset += sizeof (ACPI_MPST_DATA_HDR);
   2730 
   2731     /* Subtable: Memory Power State Characteristics structure(s) */
   2732 
   2733     SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1,
   2734         sizeof (ACPI_MPST_DATA_HDR));
   2735 
   2736     while ((Offset < Table->Length) && SubtableCount)
   2737     {
   2738         AcpiOsPrintf ("\n");
   2739         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2,
   2740             sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
   2741         if (ACPI_FAILURE (Status))
   2742         {
   2743             return;
   2744         }
   2745 
   2746         SubTable2++;
   2747         SubtableCount--;
   2748         Offset += sizeof (ACPI_MPST_POWER_DATA);
   2749     }
   2750 }
   2751 
   2752 
   2753 /*******************************************************************************
   2754  *
   2755  * FUNCTION:    AcpiDmDumpMsct
   2756  *
   2757  * PARAMETERS:  Table               - A MSCT table
   2758  *
   2759  * RETURN:      None
   2760  *
   2761  * DESCRIPTION: Format the contents of a MSCT
   2762  *
   2763  ******************************************************************************/
   2764 
   2765 void
   2766 AcpiDmDumpMsct (
   2767     ACPI_TABLE_HEADER       *Table)
   2768 {
   2769     ACPI_STATUS             Status;
   2770     UINT32                  Offset = sizeof (ACPI_TABLE_MSCT);
   2771     ACPI_MSCT_PROXIMITY     *SubTable;
   2772 
   2773 
   2774     /* Main table */
   2775 
   2776     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
   2777     if (ACPI_FAILURE (Status))
   2778     {
   2779         return;
   2780     }
   2781 
   2782     /* Subtables */
   2783 
   2784     SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
   2785     while (Offset < Table->Length)
   2786     {
   2787         /* Common subtable header */
   2788 
   2789         AcpiOsPrintf ("\n");
   2790         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   2791             sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
   2792         if (ACPI_FAILURE (Status))
   2793         {
   2794             return;
   2795         }
   2796 
   2797         /* Point to next subtable */
   2798 
   2799         Offset += sizeof (ACPI_MSCT_PROXIMITY);
   2800         SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable,
   2801             sizeof (ACPI_MSCT_PROXIMITY));
   2802     }
   2803 }
   2804 
   2805 
   2806 /*******************************************************************************
   2807  *
   2808  * FUNCTION:    AcpiDmDumpMtmr
   2809  *
   2810  * PARAMETERS:  Table               - A MTMR table
   2811  *
   2812  * RETURN:      None
   2813  *
   2814  * DESCRIPTION: Format the contents of a MTMR
   2815  *
   2816  ******************************************************************************/
   2817 
   2818 void
   2819 AcpiDmDumpMtmr (
   2820     ACPI_TABLE_HEADER       *Table)
   2821 {
   2822     ACPI_STATUS             Status;
   2823     UINT32                  Offset = sizeof (ACPI_TABLE_MTMR);
   2824     ACPI_MTMR_ENTRY         *SubTable;
   2825 
   2826 
   2827     /* Main table */
   2828 
   2829     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr);
   2830     if (ACPI_FAILURE (Status))
   2831     {
   2832         return;
   2833     }
   2834 
   2835     /* Subtables */
   2836 
   2837     SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset);
   2838     while (Offset < Table->Length)
   2839     {
   2840         /* Common subtable header */
   2841 
   2842         AcpiOsPrintf ("\n");
   2843         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   2844             sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0);
   2845         if (ACPI_FAILURE (Status))
   2846         {
   2847             return;
   2848         }
   2849 
   2850         /* Point to next subtable */
   2851 
   2852         Offset += sizeof (ACPI_MTMR_ENTRY);
   2853         SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable,
   2854             sizeof (ACPI_MTMR_ENTRY));
   2855     }
   2856 }
   2857 
   2858 
   2859 /*******************************************************************************
   2860  *
   2861  * FUNCTION:    AcpiDmDumpNfit
   2862  *
   2863  * PARAMETERS:  Table               - A NFIT table
   2864  *
   2865  * RETURN:      None
   2866  *
   2867  * DESCRIPTION: Format the contents of an NFIT.
   2868  *
   2869  ******************************************************************************/
   2870 
   2871 void
   2872 AcpiDmDumpNfit (
   2873     ACPI_TABLE_HEADER       *Table)
   2874 {
   2875     ACPI_STATUS             Status;
   2876     UINT32                  Offset = sizeof (ACPI_TABLE_NFIT);
   2877     UINT32                  FieldOffset = 0;
   2878     UINT32                  Length;
   2879     ACPI_NFIT_HEADER        *SubTable;
   2880     ACPI_DMTABLE_INFO       *InfoTable;
   2881     ACPI_NFIT_INTERLEAVE    *Interleave = NULL;
   2882     ACPI_NFIT_SMBIOS        *SmbiosInfo = NULL;
   2883     ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL;
   2884     UINT32                  i;
   2885 
   2886 
   2887     /* Main table */
   2888 
   2889     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit);
   2890     if (ACPI_FAILURE (Status))
   2891     {
   2892         return;
   2893     }
   2894 
   2895     /* Subtables */
   2896 
   2897     SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset);
   2898     while (Offset < Table->Length)
   2899     {
   2900         /* NFIT subtable header */
   2901 
   2902         AcpiOsPrintf ("\n");
   2903         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   2904             SubTable->Length, AcpiDmTableInfoNfitHdr);
   2905         if (ACPI_FAILURE (Status))
   2906         {
   2907             return;
   2908         }
   2909 
   2910         switch (SubTable->Type)
   2911         {
   2912         case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
   2913 
   2914             InfoTable = AcpiDmTableInfoNfit0;
   2915             break;
   2916 
   2917         case ACPI_NFIT_TYPE_MEMORY_MAP:
   2918 
   2919             InfoTable = AcpiDmTableInfoNfit1;
   2920             break;
   2921 
   2922         case ACPI_NFIT_TYPE_INTERLEAVE:
   2923 
   2924             /* Has a variable number of 32-bit values at the end */
   2925 
   2926             InfoTable = AcpiDmTableInfoNfit2;
   2927             Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, SubTable);
   2928             FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE);
   2929             break;
   2930 
   2931         case ACPI_NFIT_TYPE_SMBIOS:
   2932 
   2933             SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, SubTable);
   2934             InfoTable = AcpiDmTableInfoNfit3;
   2935             break;
   2936 
   2937         case ACPI_NFIT_TYPE_CONTROL_REGION:
   2938 
   2939             InfoTable = AcpiDmTableInfoNfit4;
   2940             break;
   2941 
   2942         case ACPI_NFIT_TYPE_DATA_REGION:
   2943 
   2944             InfoTable = AcpiDmTableInfoNfit5;
   2945             break;
   2946 
   2947         case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
   2948 
   2949             /* Has a variable number of 64-bit addresses at the end */
   2950 
   2951             InfoTable = AcpiDmTableInfoNfit6;
   2952             Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, SubTable);
   2953             FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64);
   2954             break;
   2955 
   2956         default:
   2957             AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n",
   2958                 SubTable->Type);
   2959 
   2960             /* Attempt to continue */
   2961 
   2962             if (!SubTable->Length)
   2963             {
   2964                 AcpiOsPrintf ("Invalid zero length subtable\n");
   2965                 return;
   2966             }
   2967             goto NextSubTable;
   2968         }
   2969 
   2970         AcpiOsPrintf ("\n");
   2971         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   2972             SubTable->Length, InfoTable);
   2973         if (ACPI_FAILURE (Status))
   2974         {
   2975             return;
   2976         }
   2977 
   2978         /* Per-subtable variable-length fields */
   2979 
   2980         switch (SubTable->Type)
   2981         {
   2982         case ACPI_NFIT_TYPE_INTERLEAVE:
   2983 
   2984             for (i = 0; i < Interleave->LineCount; i++)
   2985             {
   2986                 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
   2987                     &Interleave->LineOffset[i],
   2988                     sizeof (UINT32), AcpiDmTableInfoNfit2a);
   2989                 if (ACPI_FAILURE (Status))
   2990                 {
   2991                     return;
   2992                 }
   2993 
   2994                 FieldOffset += sizeof (UINT32);
   2995             }
   2996             break;
   2997 
   2998         case ACPI_NFIT_TYPE_SMBIOS:
   2999 
   3000             Length = SubTable->Length -
   3001                 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8);
   3002 
   3003             if (Length)
   3004             {
   3005                 Status = AcpiDmDumpTable (Table->Length,
   3006                     sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8),
   3007                     SmbiosInfo,
   3008                     Length, AcpiDmTableInfoNfit3a);
   3009                 if (ACPI_FAILURE (Status))
   3010                 {
   3011                     return;
   3012                 }
   3013             }
   3014 
   3015             break;
   3016 
   3017         case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
   3018 
   3019             for (i = 0; i < Hint->HintCount; i++)
   3020             {
   3021                 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset,
   3022                     &Hint->HintAddress[i],
   3023                     sizeof (UINT64), AcpiDmTableInfoNfit6a);
   3024                 if (ACPI_FAILURE (Status))
   3025                 {
   3026                     return;
   3027                 }
   3028 
   3029                 FieldOffset += sizeof (UINT64);
   3030             }
   3031             break;
   3032 
   3033         default:
   3034             break;
   3035         }
   3036 
   3037 NextSubTable:
   3038         /* Point to next subtable */
   3039 
   3040         Offset += SubTable->Length;
   3041         SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubTable->Length);
   3042     }
   3043 }
   3044 
   3045 
   3046 /*******************************************************************************
   3047  *
   3048  * FUNCTION:    AcpiDmDumpPcct
   3049  *
   3050  * PARAMETERS:  Table               - A PCCT table
   3051  *
   3052  * RETURN:      None
   3053  *
   3054  * DESCRIPTION: Format the contents of a PCCT. This table type consists
   3055  *              of an open-ended number of subtables.
   3056  *
   3057  ******************************************************************************/
   3058 
   3059 void
   3060 AcpiDmDumpPcct (
   3061     ACPI_TABLE_HEADER       *Table)
   3062 {
   3063     ACPI_STATUS             Status;
   3064     ACPI_PCCT_SUBSPACE      *SubTable;
   3065     ACPI_DMTABLE_INFO       *InfoTable;
   3066     UINT32                  Length = Table->Length;
   3067     UINT32                  Offset = sizeof (ACPI_TABLE_PCCT);
   3068 
   3069 
   3070     /* Main table */
   3071 
   3072     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
   3073     if (ACPI_FAILURE (Status))
   3074     {
   3075         return;
   3076     }
   3077 
   3078     /* Subtables */
   3079 
   3080     SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
   3081     while (Offset < Table->Length)
   3082     {
   3083         /* Common subtable header */
   3084 
   3085         AcpiOsPrintf ("\n");
   3086         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   3087             SubTable->Header.Length, AcpiDmTableInfoPcctHdr);
   3088         if (ACPI_FAILURE (Status))
   3089         {
   3090             return;
   3091         }
   3092 
   3093         switch (SubTable->Header.Type)
   3094         {
   3095         case ACPI_PCCT_TYPE_GENERIC_SUBSPACE:
   3096 
   3097             InfoTable = AcpiDmTableInfoPcct0;
   3098             break;
   3099 
   3100         case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE:
   3101 
   3102             InfoTable = AcpiDmTableInfoPcct1;
   3103             break;
   3104 
   3105         case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2:
   3106 
   3107             InfoTable = AcpiDmTableInfoPcct2;
   3108             break;
   3109 
   3110         case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE:
   3111 
   3112             InfoTable = AcpiDmTableInfoPcct3;
   3113             break;
   3114 
   3115         case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE:
   3116 
   3117             InfoTable = AcpiDmTableInfoPcct4;
   3118             break;
   3119 
   3120         default:
   3121 
   3122             AcpiOsPrintf (
   3123                 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n",
   3124                 SubTable->Header.Type);
   3125             return;
   3126         }
   3127 
   3128         AcpiOsPrintf ("\n");
   3129         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   3130             SubTable->Header.Length, InfoTable);
   3131         if (ACPI_FAILURE (Status))
   3132         {
   3133             return;
   3134         }
   3135 
   3136         /* Point to next subtable */
   3137 
   3138         Offset += SubTable->Header.Length;
   3139         SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable,
   3140             SubTable->Header.Length);
   3141     }
   3142 }
   3143 
   3144 
   3145 /*******************************************************************************
   3146  *
   3147  * FUNCTION:    AcpiDmDumpPmtt
   3148  *
   3149  * PARAMETERS:  Table               - A PMTT table
   3150  *
   3151  * RETURN:      None
   3152  *
   3153  * DESCRIPTION: Format the contents of a PMTT. This table type consists
   3154  *              of an open-ended number of subtables.
   3155  *
   3156  ******************************************************************************/
   3157 
   3158 void
   3159 AcpiDmDumpPmtt (
   3160     ACPI_TABLE_HEADER       *Table)
   3161 {
   3162     ACPI_STATUS             Status;
   3163     ACPI_PMTT_HEADER        *SubTable;
   3164     ACPI_PMTT_HEADER        *MemSubTable;
   3165     ACPI_PMTT_HEADER        *DimmSubTable;
   3166     ACPI_PMTT_DOMAIN        *DomainArray;
   3167     UINT32                  Length = Table->Length;
   3168     UINT32                  Offset = sizeof (ACPI_TABLE_PMTT);
   3169     UINT32                  MemOffset;
   3170     UINT32                  DimmOffset;
   3171     UINT32                  DomainOffset;
   3172     UINT32                  DomainCount;
   3173 
   3174 
   3175     /* Main table */
   3176 
   3177     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
   3178     if (ACPI_FAILURE (Status))
   3179     {
   3180         return;
   3181     }
   3182 
   3183     /* Subtables */
   3184 
   3185     SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
   3186     while (Offset < Table->Length)
   3187     {
   3188         /* Common subtable header */
   3189 
   3190         AcpiOsPrintf ("\n");
   3191         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   3192             SubTable->Length, AcpiDmTableInfoPmttHdr);
   3193         if (ACPI_FAILURE (Status))
   3194         {
   3195             return;
   3196         }
   3197 
   3198         /* Only Socket subtables are expected at this level */
   3199 
   3200         if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET)
   3201         {
   3202             AcpiOsPrintf (
   3203                 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
   3204                 SubTable->Type);
   3205             return;
   3206         }
   3207 
   3208         /* Dump the fixed-length portion of the subtable */
   3209 
   3210         Status = AcpiDmDumpTable (Length, Offset, SubTable,
   3211             SubTable->Length, AcpiDmTableInfoPmtt0);
   3212         if (ACPI_FAILURE (Status))
   3213         {
   3214             return;
   3215         }
   3216 
   3217         /* Walk the memory controller subtables */
   3218 
   3219         MemOffset = sizeof (ACPI_PMTT_SOCKET);
   3220         MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable,
   3221             sizeof (ACPI_PMTT_SOCKET));
   3222 
   3223         while (((Offset + MemOffset) < Table->Length) &&
   3224             (MemOffset < SubTable->Length))
   3225         {
   3226             /* Common subtable header */
   3227 
   3228             AcpiOsPrintf ("\n");
   3229             Status = AcpiDmDumpTable (Length,
   3230                 Offset + MemOffset, MemSubTable,
   3231                 MemSubTable->Length, AcpiDmTableInfoPmttHdr);
   3232             if (ACPI_FAILURE (Status))
   3233             {
   3234                 return;
   3235             }
   3236 
   3237             /* Only memory controller subtables are expected at this level */
   3238 
   3239             if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER)
   3240             {
   3241                 AcpiOsPrintf (
   3242                     "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
   3243                     MemSubTable->Type);
   3244                 return;
   3245             }
   3246 
   3247             /* Dump the fixed-length portion of the controller subtable */
   3248 
   3249             Status = AcpiDmDumpTable (Length,
   3250                 Offset + MemOffset, MemSubTable,
   3251                 MemSubTable->Length, AcpiDmTableInfoPmtt1);
   3252             if (ACPI_FAILURE (Status))
   3253             {
   3254                 return;
   3255             }
   3256 
   3257             /* Walk the variable count of proximity domains */
   3258 
   3259             DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount;
   3260             DomainOffset = sizeof (ACPI_PMTT_CONTROLLER);
   3261             DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable,
   3262                 sizeof (ACPI_PMTT_CONTROLLER));
   3263 
   3264             while (((Offset + MemOffset + DomainOffset) < Table->Length) &&
   3265                 ((MemOffset + DomainOffset) < SubTable->Length) &&
   3266                 DomainCount)
   3267             {
   3268                 Status = AcpiDmDumpTable (Length,
   3269                     Offset + MemOffset + DomainOffset, DomainArray,
   3270                     sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
   3271                 if (ACPI_FAILURE (Status))
   3272                 {
   3273                     return;
   3274                 }
   3275 
   3276                 DomainOffset += sizeof (ACPI_PMTT_DOMAIN);
   3277                 DomainArray++;
   3278                 DomainCount--;
   3279             }
   3280 
   3281             if (DomainCount)
   3282             {
   3283                 AcpiOsPrintf (
   3284                     "\n**** DomainCount exceeds subtable length\n\n");
   3285             }
   3286 
   3287             /* Walk the physical component (DIMM) subtables */
   3288 
   3289             DimmOffset = DomainOffset;
   3290             DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable,
   3291                 DomainOffset);
   3292 
   3293             while (((Offset + MemOffset + DimmOffset) < Table->Length) &&
   3294                 (DimmOffset < MemSubTable->Length))
   3295             {
   3296                 /* Common subtable header */
   3297 
   3298                 AcpiOsPrintf ("\n");
   3299                 Status = AcpiDmDumpTable (Length,
   3300                     Offset + MemOffset + DimmOffset, DimmSubTable,
   3301                     DimmSubTable->Length, AcpiDmTableInfoPmttHdr);
   3302                 if (ACPI_FAILURE (Status))
   3303                 {
   3304                     return;
   3305                 }
   3306 
   3307                 /* Only DIMM subtables are expected at this level */
   3308 
   3309                 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM)
   3310                 {
   3311                     AcpiOsPrintf (
   3312                         "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
   3313                         DimmSubTable->Type);
   3314                     return;
   3315                 }
   3316 
   3317                 /* Dump the fixed-length DIMM subtable */
   3318 
   3319                 Status = AcpiDmDumpTable (Length,
   3320                     Offset + MemOffset + DimmOffset, DimmSubTable,
   3321                     DimmSubTable->Length, AcpiDmTableInfoPmtt2);
   3322                 if (ACPI_FAILURE (Status))
   3323                 {
   3324                     return;
   3325                 }
   3326 
   3327                 /* Point to next DIMM subtable */
   3328 
   3329                 DimmOffset += DimmSubTable->Length;
   3330                 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
   3331                     DimmSubTable, DimmSubTable->Length);
   3332             }
   3333 
   3334             /* Point to next Controller subtable */
   3335 
   3336             MemOffset += MemSubTable->Length;
   3337             MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
   3338                 MemSubTable, MemSubTable->Length);
   3339         }
   3340 
   3341         /* Point to next Socket subtable */
   3342 
   3343         Offset += SubTable->Length;
   3344         SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
   3345             SubTable, SubTable->Length);
   3346     }
   3347 }
   3348 
   3349 
   3350 /*******************************************************************************
   3351  *
   3352  * FUNCTION:    AcpiDmDumpPptt
   3353  *
   3354  * PARAMETERS:  Table               - A PMTT table
   3355  *
   3356  * RETURN:      None
   3357  *
   3358  * DESCRIPTION: Format the contents of a PPTT. This table type consists
   3359  *              of an open-ended number of subtables.
   3360  *
   3361  ******************************************************************************/
   3362 
   3363 void
   3364 AcpiDmDumpPptt (
   3365     ACPI_TABLE_HEADER       *Table)
   3366 {
   3367     ACPI_STATUS             Status;
   3368     ACPI_SUBTABLE_HEADER    *SubTable;
   3369     ACPI_PPTT_PROCESSOR     *PpttProcessor;
   3370     UINT8                   Length;
   3371     UINT8                   SubTableOffset;
   3372     UINT32                  Offset = sizeof (ACPI_TABLE_FPDT);
   3373     ACPI_DMTABLE_INFO       *InfoTable;
   3374     UINT32                  i;
   3375 
   3376 
   3377     /* There is no main table (other than the standard ACPI header) */
   3378 
   3379     /* Subtables */
   3380 
   3381     Offset = sizeof (ACPI_TABLE_HEADER);
   3382     while (Offset < Table->Length)
   3383     {
   3384         AcpiOsPrintf ("\n");
   3385 
   3386         /* Common subtable header */
   3387 
   3388         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
   3389         if (SubTable->Length < sizeof (ACPI_SUBTABLE_HEADER))
   3390         {
   3391             AcpiOsPrintf ("Invalid subtable length\n");
   3392             return;
   3393         }
   3394         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   3395             SubTable->Length, AcpiDmTableInfoPpttHdr);
   3396         if (ACPI_FAILURE (Status))
   3397         {
   3398             return;
   3399         }
   3400 
   3401         switch (SubTable->Type)
   3402         {
   3403         case ACPI_PPTT_TYPE_PROCESSOR:
   3404 
   3405             InfoTable = AcpiDmTableInfoPptt0;
   3406             Length = sizeof (ACPI_PPTT_PROCESSOR);
   3407             break;
   3408 
   3409         case ACPI_PPTT_TYPE_CACHE:
   3410 
   3411             InfoTable = AcpiDmTableInfoPptt1;
   3412             Length = sizeof (ACPI_PPTT_CACHE);
   3413             break;
   3414 
   3415         case ACPI_PPTT_TYPE_ID:
   3416 
   3417             InfoTable = AcpiDmTableInfoPptt2;
   3418             Length = sizeof (ACPI_PPTT_ID);
   3419             break;
   3420 
   3421         default:
   3422 
   3423             AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n",
   3424                 SubTable->Type);
   3425 
   3426             /* Attempt to continue */
   3427 
   3428             goto NextSubTable;
   3429         }
   3430 
   3431         if (SubTable->Length < Length)
   3432         {
   3433             AcpiOsPrintf ("Invalid subtable length\n");
   3434             return;
   3435         }
   3436         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   3437             SubTable->Length, InfoTable);
   3438         if (ACPI_FAILURE (Status))
   3439         {
   3440             return;
   3441         }
   3442         SubTableOffset = Length;
   3443 
   3444         switch (SubTable->Type)
   3445         {
   3446         case ACPI_PPTT_TYPE_PROCESSOR:
   3447 
   3448             PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, SubTable);
   3449 
   3450             /* Dump SMBIOS handles */
   3451 
   3452             if ((UINT8)(SubTable->Length - SubTableOffset) <
   3453                 (UINT8)(PpttProcessor->NumberOfPrivResources * 4))
   3454             {
   3455                 AcpiOsPrintf ("Invalid private resource number\n");
   3456                 return;
   3457             }
   3458             for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++)
   3459             {
   3460                 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset,
   3461                     ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTableOffset),
   3462                     4, AcpiDmTableInfoPptt0a);
   3463                 SubTableOffset += 4;
   3464             }
   3465             break;
   3466 
   3467         default:
   3468 
   3469             break;
   3470         }
   3471 
   3472 NextSubTable:
   3473         /* Point to next subtable */
   3474 
   3475         Offset += SubTable->Length;
   3476     }
   3477 }
   3478 
   3479 
   3480 /*******************************************************************************
   3481  *
   3482  * FUNCTION:    AcpiDmDumpS3pt
   3483  *
   3484  * PARAMETERS:  Table               - A S3PT table
   3485  *
   3486  * RETURN:      Length of the table
   3487  *
   3488  * DESCRIPTION: Format the contents of a S3PT
   3489  *
   3490  ******************************************************************************/
   3491 
   3492 UINT32
   3493 AcpiDmDumpS3pt (
   3494     ACPI_TABLE_HEADER       *Tables)
   3495 {
   3496     ACPI_STATUS             Status;
   3497     UINT32                  Offset = sizeof (ACPI_TABLE_S3PT);
   3498     ACPI_FPDT_HEADER        *SubTable;
   3499     ACPI_DMTABLE_INFO       *InfoTable;
   3500     ACPI_TABLE_S3PT         *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
   3501 
   3502 
   3503     /* Main table */
   3504 
   3505     Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
   3506     if (ACPI_FAILURE (Status))
   3507     {
   3508         return 0;
   3509     }
   3510 
   3511     SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset);
   3512     while (Offset < S3ptTable->Length)
   3513     {
   3514         /* Common subtable header */
   3515 
   3516         AcpiOsPrintf ("\n");
   3517         Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
   3518             SubTable->Length, AcpiDmTableInfoS3ptHdr);
   3519         if (ACPI_FAILURE (Status))
   3520         {
   3521             return 0;
   3522         }
   3523 
   3524         switch (SubTable->Type)
   3525         {
   3526         case ACPI_S3PT_TYPE_RESUME:
   3527 
   3528             InfoTable = AcpiDmTableInfoS3pt0;
   3529             break;
   3530 
   3531         case ACPI_S3PT_TYPE_SUSPEND:
   3532 
   3533             InfoTable = AcpiDmTableInfoS3pt1;
   3534             break;
   3535 
   3536         default:
   3537 
   3538             AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n",
   3539                 SubTable->Type);
   3540 
   3541             /* Attempt to continue */
   3542 
   3543             if (!SubTable->Length)
   3544             {
   3545                 AcpiOsPrintf ("Invalid zero length subtable\n");
   3546                 return 0;
   3547             }
   3548             goto NextSubTable;
   3549         }
   3550 
   3551         AcpiOsPrintf ("\n");
   3552         Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
   3553             SubTable->Length, InfoTable);
   3554         if (ACPI_FAILURE (Status))
   3555         {
   3556             return 0;
   3557         }
   3558 
   3559 NextSubTable:
   3560         /* Point to next subtable */
   3561 
   3562         Offset += SubTable->Length;
   3563         SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length);
   3564     }
   3565 
   3566     return (S3ptTable->Length);
   3567 }
   3568 
   3569 
   3570 /*******************************************************************************
   3571  *
   3572  * FUNCTION:    AcpiDmDumpSlic
   3573  *
   3574  * PARAMETERS:  Table               - A SLIC table
   3575  *
   3576  * RETURN:      None
   3577  *
   3578  * DESCRIPTION: Format the contents of a SLIC
   3579  *
   3580  ******************************************************************************/
   3581 
   3582 void
   3583 AcpiDmDumpSlic (
   3584     ACPI_TABLE_HEADER       *Table)
   3585 {
   3586 
   3587     (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table,
   3588         Table->Length - sizeof (*Table), AcpiDmTableInfoSlic);
   3589 }
   3590 
   3591 
   3592 /*******************************************************************************
   3593  *
   3594  * FUNCTION:    AcpiDmDumpSlit
   3595  *
   3596  * PARAMETERS:  Table               - An SLIT
   3597  *
   3598  * RETURN:      None
   3599  *
   3600  * DESCRIPTION: Format the contents of a SLIT
   3601  *
   3602  ******************************************************************************/
   3603 
   3604 void
   3605 AcpiDmDumpSlit (
   3606     ACPI_TABLE_HEADER       *Table)
   3607 {
   3608     ACPI_STATUS             Status;
   3609     UINT32                  Offset;
   3610     UINT8                   *Row;
   3611     UINT32                  Localities;
   3612     UINT32                  i;
   3613     UINT32                  j;
   3614 
   3615 
   3616     /* Main table */
   3617 
   3618     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
   3619     if (ACPI_FAILURE (Status))
   3620     {
   3621         return;
   3622     }
   3623 
   3624     /* Display the Locality NxN Matrix */
   3625 
   3626     Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
   3627     Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
   3628     Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
   3629 
   3630     for (i = 0; i < Localities; i++)
   3631     {
   3632         /* Display one row of the matrix */
   3633 
   3634         AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
   3635         for  (j = 0; j < Localities; j++)
   3636         {
   3637             /* Check for beyond EOT */
   3638 
   3639             if (Offset >= Table->Length)
   3640             {
   3641                 AcpiOsPrintf (
   3642                     "\n**** Not enough room in table for all localities\n");
   3643                 return;
   3644             }
   3645 
   3646             AcpiOsPrintf ("%2.2X", Row[j]);
   3647             Offset++;
   3648 
   3649             /* Display up to 16 bytes per output row */
   3650 
   3651             if ((j+1) < Localities)
   3652             {
   3653                 AcpiOsPrintf (" ");
   3654 
   3655                 if (j && (((j+1) % 16) == 0))
   3656                 {
   3657                     AcpiOsPrintf ("\\\n"); /* With line continuation char */
   3658                     AcpiDmLineHeader (Offset, 0, NULL);
   3659                 }
   3660             }
   3661         }
   3662 
   3663         /* Point to next row */
   3664 
   3665         AcpiOsPrintf ("\n");
   3666         Row += Localities;
   3667     }
   3668 }
   3669 
   3670 
   3671 /*******************************************************************************
   3672  *
   3673  * FUNCTION:    AcpiDmDumpSrat
   3674  *
   3675  * PARAMETERS:  Table               - A SRAT table
   3676  *
   3677  * RETURN:      None
   3678  *
   3679  * DESCRIPTION: Format the contents of a SRAT
   3680  *
   3681  ******************************************************************************/
   3682 
   3683 void
   3684 AcpiDmDumpSrat (
   3685     ACPI_TABLE_HEADER       *Table)
   3686 {
   3687     ACPI_STATUS             Status;
   3688     UINT32                  Offset = sizeof (ACPI_TABLE_SRAT);
   3689     ACPI_SUBTABLE_HEADER    *SubTable;
   3690     ACPI_DMTABLE_INFO       *InfoTable;
   3691 
   3692 
   3693     /* Main table */
   3694 
   3695     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
   3696     if (ACPI_FAILURE (Status))
   3697     {
   3698         return;
   3699     }
   3700 
   3701     /* Subtables */
   3702 
   3703     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
   3704     while (Offset < Table->Length)
   3705     {
   3706         /* Common subtable header */
   3707 
   3708         AcpiOsPrintf ("\n");
   3709         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   3710             SubTable->Length, AcpiDmTableInfoSratHdr);
   3711         if (ACPI_FAILURE (Status))
   3712         {
   3713             return;
   3714         }
   3715 
   3716         switch (SubTable->Type)
   3717         {
   3718         case ACPI_SRAT_TYPE_CPU_AFFINITY:
   3719 
   3720             InfoTable = AcpiDmTableInfoSrat0;
   3721             break;
   3722 
   3723         case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
   3724 
   3725             InfoTable = AcpiDmTableInfoSrat1;
   3726             break;
   3727 
   3728         case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
   3729 
   3730             InfoTable = AcpiDmTableInfoSrat2;
   3731             break;
   3732 
   3733         case ACPI_SRAT_TYPE_GICC_AFFINITY:
   3734 
   3735             InfoTable = AcpiDmTableInfoSrat3;
   3736             break;
   3737 
   3738         case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY:
   3739 
   3740             InfoTable = AcpiDmTableInfoSrat4;
   3741             break;
   3742 
   3743         default:
   3744             AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n",
   3745                 SubTable->Type);
   3746 
   3747             /* Attempt to continue */
   3748 
   3749             if (!SubTable->Length)
   3750             {
   3751                 AcpiOsPrintf ("Invalid zero length subtable\n");
   3752                 return;
   3753             }
   3754             goto NextSubTable;
   3755         }
   3756 
   3757         AcpiOsPrintf ("\n");
   3758         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   3759             SubTable->Length, InfoTable);
   3760         if (ACPI_FAILURE (Status))
   3761         {
   3762             return;
   3763         }
   3764 
   3765 NextSubTable:
   3766         /* Point to next subtable */
   3767 
   3768         Offset += SubTable->Length;
   3769         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable,
   3770             SubTable->Length);
   3771     }
   3772 }
   3773 
   3774 
   3775 /*******************************************************************************
   3776  *
   3777  * FUNCTION:    AcpiDmDumpStao
   3778  *
   3779  * PARAMETERS:  Table               - A STAO table
   3780  *
   3781  * RETURN:      None
   3782  *
   3783  * DESCRIPTION: Format the contents of a STAO. This is a variable-length
   3784  *              table that contains an open-ended number of ASCII strings
   3785  *              at the end of the table.
   3786  *
   3787  ******************************************************************************/
   3788 
   3789 void
   3790 AcpiDmDumpStao (
   3791     ACPI_TABLE_HEADER       *Table)
   3792 {
   3793     ACPI_STATUS             Status;
   3794     char                    *Namepath;
   3795     UINT32                  Length = Table->Length;
   3796     UINT32                  StringLength;
   3797     UINT32                  Offset = sizeof (ACPI_TABLE_STAO);
   3798 
   3799 
   3800     /* Main table */
   3801 
   3802     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoStao);
   3803     if (ACPI_FAILURE (Status))
   3804     {
   3805         return;
   3806     }
   3807 
   3808     /* The rest of the table consists of Namepath strings */
   3809 
   3810     while (Offset < Table->Length)
   3811     {
   3812         Namepath = ACPI_ADD_PTR (char, Table, Offset);
   3813         StringLength = strlen (Namepath) + 1;
   3814 
   3815         AcpiDmLineHeader (Offset, StringLength, "Namestring");
   3816         AcpiOsPrintf ("\"%s\"\n", Namepath);
   3817 
   3818         /* Point to next namepath */
   3819 
   3820         Offset += StringLength;
   3821     }
   3822 }
   3823 
   3824 
   3825 /*******************************************************************************
   3826  *
   3827  * FUNCTION:    AcpiDmDumpTcpa
   3828  *
   3829  * PARAMETERS:  Table               - A TCPA table
   3830  *
   3831  * RETURN:      None
   3832  *
   3833  * DESCRIPTION: Format the contents of a TCPA.
   3834  *
   3835  * NOTE:        There are two versions of the table with the same signature:
   3836  *              the client version and the server version. The common
   3837  *              PlatformClass field is used to differentiate the two types of
   3838  *              tables.
   3839  *
   3840  ******************************************************************************/
   3841 
   3842 void
   3843 AcpiDmDumpTcpa (
   3844     ACPI_TABLE_HEADER       *Table)
   3845 {
   3846     UINT32                  Offset = sizeof (ACPI_TABLE_TCPA_HDR);
   3847     ACPI_TABLE_TCPA_HDR     *CommonHeader = ACPI_CAST_PTR (
   3848                                 ACPI_TABLE_TCPA_HDR, Table);
   3849     ACPI_TABLE_TCPA_HDR     *SubTable = ACPI_ADD_PTR (
   3850                                 ACPI_TABLE_TCPA_HDR, Table, Offset);
   3851     ACPI_STATUS             Status;
   3852 
   3853 
   3854     /* Main table */
   3855 
   3856     Status = AcpiDmDumpTable (Table->Length, 0, Table,
   3857         0, AcpiDmTableInfoTcpaHdr);
   3858     if (ACPI_FAILURE (Status))
   3859     {
   3860         return;
   3861     }
   3862 
   3863     /*
   3864      * Examine the PlatformClass field to determine the table type.
   3865      * Either a client or server table. Only one.
   3866      */
   3867     switch (CommonHeader->PlatformClass)
   3868     {
   3869     case ACPI_TCPA_CLIENT_TABLE:
   3870 
   3871         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   3872             Table->Length - Offset, AcpiDmTableInfoTcpaClient);
   3873         break;
   3874 
   3875     case ACPI_TCPA_SERVER_TABLE:
   3876 
   3877         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   3878             Table->Length - Offset, AcpiDmTableInfoTcpaServer);
   3879         break;
   3880 
   3881     default:
   3882 
   3883         AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n",
   3884             CommonHeader->PlatformClass);
   3885         Status = AE_ERROR;
   3886         break;
   3887     }
   3888 
   3889     if (ACPI_FAILURE (Status))
   3890     {
   3891         AcpiOsPrintf ("\n**** Cannot disassemble TCPA table\n");
   3892     }
   3893 }
   3894 
   3895 
   3896 /*******************************************************************************
   3897  *
   3898  * FUNCTION:    AcpiDmDumpVrtc
   3899  *
   3900  * PARAMETERS:  Table               - A VRTC table
   3901  *
   3902  * RETURN:      None
   3903  *
   3904  * DESCRIPTION: Format the contents of a VRTC
   3905  *
   3906  ******************************************************************************/
   3907 
   3908 void
   3909 AcpiDmDumpVrtc (
   3910     ACPI_TABLE_HEADER       *Table)
   3911 {
   3912     ACPI_STATUS             Status;
   3913     UINT32                  Offset = sizeof (ACPI_TABLE_VRTC);
   3914     ACPI_VRTC_ENTRY         *SubTable;
   3915 
   3916 
   3917     /* Main table */
   3918 
   3919     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc);
   3920     if (ACPI_FAILURE (Status))
   3921     {
   3922         return;
   3923     }
   3924 
   3925     /* Subtables */
   3926 
   3927     SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset);
   3928     while (Offset < Table->Length)
   3929     {
   3930         /* Common subtable header */
   3931 
   3932         AcpiOsPrintf ("\n");
   3933         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   3934             sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0);
   3935         if (ACPI_FAILURE (Status))
   3936         {
   3937             return;
   3938         }
   3939 
   3940         /* Point to next subtable */
   3941 
   3942         Offset += sizeof (ACPI_VRTC_ENTRY);
   3943         SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable,
   3944             sizeof (ACPI_VRTC_ENTRY));
   3945     }
   3946 }
   3947 
   3948 
   3949 /*******************************************************************************
   3950  *
   3951  * FUNCTION:    AcpiDmDumpWdat
   3952  *
   3953  * PARAMETERS:  Table               - A WDAT table
   3954  *
   3955  * RETURN:      None
   3956  *
   3957  * DESCRIPTION: Format the contents of a WDAT
   3958  *
   3959  ******************************************************************************/
   3960 
   3961 void
   3962 AcpiDmDumpWdat (
   3963     ACPI_TABLE_HEADER       *Table)
   3964 {
   3965     ACPI_STATUS             Status;
   3966     UINT32                  Offset = sizeof (ACPI_TABLE_WDAT);
   3967     ACPI_WDAT_ENTRY         *SubTable;
   3968 
   3969 
   3970     /* Main table */
   3971 
   3972     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
   3973     if (ACPI_FAILURE (Status))
   3974     {
   3975         return;
   3976     }
   3977 
   3978     /* Subtables */
   3979 
   3980     SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
   3981     while (Offset < Table->Length)
   3982     {
   3983         /* Common subtable header */
   3984 
   3985         AcpiOsPrintf ("\n");
   3986         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
   3987             sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
   3988         if (ACPI_FAILURE (Status))
   3989         {
   3990             return;
   3991         }
   3992 
   3993         /* Point to next subtable */
   3994 
   3995         Offset += sizeof (ACPI_WDAT_ENTRY);
   3996         SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable,
   3997             sizeof (ACPI_WDAT_ENTRY));
   3998     }
   3999 }
   4000 
   4001 
   4002 /*******************************************************************************
   4003  *
   4004  * FUNCTION:    AcpiDmDumpWpbt
   4005  *
   4006  * PARAMETERS:  Table               - A WPBT table
   4007  *
   4008  * RETURN:      None
   4009  *
   4010  * DESCRIPTION: Format the contents of a WPBT. This table type consists
   4011  *              of an open-ended arguments buffer at the end of the table.
   4012  *
   4013  ******************************************************************************/
   4014 
   4015 void
   4016 AcpiDmDumpWpbt (
   4017     ACPI_TABLE_HEADER       *Table)
   4018 {
   4019     ACPI_STATUS             Status;
   4020     ACPI_TABLE_WPBT         *SubTable;
   4021     UINT32                  Length = Table->Length;
   4022     UINT16                  ArgumentsLength;
   4023 
   4024 
   4025     /* Dump the main table */
   4026 
   4027     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt);
   4028     if (ACPI_FAILURE (Status))
   4029     {
   4030         return;
   4031     }
   4032 
   4033     /* Extract the arguments buffer length from the main table */
   4034 
   4035     SubTable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table);
   4036     ArgumentsLength = SubTable->ArgumentsLength;
   4037 
   4038     /* Dump the arguments buffer */
   4039 
   4040     (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength,
   4041         AcpiDmTableInfoWpbt0);
   4042 }
   4043