sys/contrib/dev/acpica/common/dmtbdump.c

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