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 - 2010, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights.  You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code.  No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision.  In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change.  Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee.  Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution.  In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government.  In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116 #include <contrib/dev/acpica/include/acpi.h>
 117 #include <contrib/dev/acpica/include/accommon.h>
 118 #include <contrib/dev/acpica/include/acdisasm.h>
 119 #include <contrib/dev/acpica/include/actables.h>
 120
 121 /* This module used for application-level code only */
 122
 123 #define _COMPONENT          ACPI_CA_DISASSEMBLER
 124         ACPI_MODULE_NAME    ("dmtbdump")
 125
 126
 127 /*******************************************************************************
 128  *
 129  * FUNCTION:    AcpiDmDumpRsdp
 130  *
 131  * PARAMETERS:  Table               - A RSDP
 132  *
 133  * RETURN:      Length of the table (there is not always a length field,
 134  *              use revision or length if available (ACPI 2.0+))
 135  *
 136  * DESCRIPTION: Format the contents of a RSDP
 137  *
 138  ******************************************************************************/
 139
 140 UINT32
 141 AcpiDmDumpRsdp (
 142     ACPI_TABLE_HEADER       *Table)
 143 {
 144     ACPI_TABLE_RSDP         *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
 145     UINT32                  Length = sizeof (ACPI_RSDP_COMMON);
 146     UINT8                   Checksum;
 147
 148
 149     /* Dump the common ACPI 1.0 portion */
 150
 151     AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
 152
 153     /* Validate the first checksum */
 154
 155     Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON),
 156                 Rsdp->Checksum);
 157     if (Checksum != Rsdp->Checksum)
 158     {
 159         AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n",
 160             Checksum);
 161     }
 162
 163     /* The RSDP for ACPI 2.0+ contains more data and has a Length field */
 164
 165     if (Rsdp->Revision > 0)
 166     {
 167         Length = Rsdp->Length;
 168         AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
 169
 170         /* Validate the extended checksum over entire RSDP */
 171
 172         Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP),
 173                     Rsdp->ExtendedChecksum);
 174         if (Checksum != Rsdp->ExtendedChecksum)
 175         {
 176             AcpiOsPrintf (
 177                 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n",
 178                 Checksum);
 179         }
 180     }
 181
 182     return (Length);
 183 }
 184
 185
 186 /*******************************************************************************
 187  *
 188  * FUNCTION:    AcpiDmDumpRsdt
 189  *
 190  * PARAMETERS:  Table               - A RSDT
 191  *
 192  * RETURN:      None
 193  *
 194  * DESCRIPTION: Format the contents of a RSDT
 195  *
 196  ******************************************************************************/
 197
 198 void
 199 AcpiDmDumpRsdt (
 200     ACPI_TABLE_HEADER       *Table)
 201 {
 202     UINT32                  *Array;
 203     UINT32                  Entries;
 204     UINT32                  Offset;
 205     UINT32                  i;
 206
 207
 208     /* Point to start of table pointer array */
 209
 210     Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry;
 211     Offset = sizeof (ACPI_TABLE_HEADER);
 212
 213     /* RSDT uses 32-bit pointers */
 214
 215     Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
 216
 217     for (i = 0; i < Entries; i++)
 218     {
 219         AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i);
 220         AcpiOsPrintf ("%8.8X\n", Array[i]);
 221         Offset += sizeof (UINT32);
 222     }
 223 }
 224
 225
 226 /*******************************************************************************
 227  *
 228  * FUNCTION:    AcpiDmDumpXsdt
 229  *
 230  * PARAMETERS:  Table               - A XSDT
 231  *
 232  * RETURN:      None
 233  *
 234  * DESCRIPTION: Format the contents of a XSDT
 235  *
 236  ******************************************************************************/
 237
 238 void
 239 AcpiDmDumpXsdt (
 240     ACPI_TABLE_HEADER       *Table)
 241 {
 242     UINT64                  *Array;
 243     UINT32                  Entries;
 244     UINT32                  Offset;
 245     UINT32                  i;
 246
 247
 248     /* Point to start of table pointer array */
 249
 250     Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry;
 251     Offset = sizeof (ACPI_TABLE_HEADER);
 252
 253     /* XSDT uses 64-bit pointers */
 254
 255     Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
 256
 257     for (i = 0; i < Entries; i++)
 258     {
 259         AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i);
 260         AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i]));
 261         Offset += sizeof (UINT64);
 262     }
 263 }
 264
 265
 266 /*******************************************************************************
 267  *
 268  * FUNCTION:    AcpiDmDumpFadt
 269  *
 270  * PARAMETERS:  Table               - A FADT
 271  *
 272  * RETURN:      None
 273  *
 274  * DESCRIPTION: Format the contents of a FADT
 275  *
 276  ******************************************************************************/
 277
 278 void
 279 AcpiDmDumpFadt (
 280     ACPI_TABLE_HEADER       *Table)
 281 {
 282
 283     /* Common ACPI 1.0 portion of FADT */
 284
 285     AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1);
 286
 287     /* Check for ACPI 1.0B MS extensions (FADT revision 2) */
 288
 289     if (Table->Revision == 2)
 290     {
 291         AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2);
 292     }
 293
 294     /* Check for ACPI 2.0+ extended data (FADT revision 3+) */
 295
 296     else if (Table->Length >= sizeof (ACPI_TABLE_FADT))
 297     {
 298         AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3);
 299     }
 300
 301     /* Validate various fields in the FADT, including length */
 302
 303     AcpiTbCreateLocalFadt (Table, Table->Length);
 304 }
 305
 306
 307 /*******************************************************************************
 308  *
 309  * FUNCTION:    AcpiDmDumpAsf
 310  *
 311  * PARAMETERS:  Table               - A ASF table
 312  *
 313  * RETURN:      None
 314  *
 315  * DESCRIPTION: Format the contents of a ASF table
 316  *
 317  ******************************************************************************/
 318
 319 void
 320 AcpiDmDumpAsf (
 321     ACPI_TABLE_HEADER       *Table)
 322 {
 323     ACPI_STATUS             Status;
 324     UINT32                  Offset = sizeof (ACPI_TABLE_HEADER);
 325     ACPI_ASF_INFO           *SubTable;
 326     ACPI_DMTABLE_INFO       *InfoTable;
 327     ACPI_DMTABLE_INFO       *DataInfoTable = NULL;
 328     UINT8                   *DataTable = NULL;
 329     UINT32                  DataCount = 0;
 330     UINT32                  DataLength = 0;
 331     UINT32                  DataOffset = 0;
 332     UINT32                  i;
 333     UINT8                   Type;
 334
 335
 336     /* No main table, only sub-tables */
 337
 338     SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
 339     while (Offset < Table->Length)
 340     {
 341         /* Common sub-table header */
 342
 343         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
 344                     SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
 345         if (ACPI_FAILURE (Status))
 346         {
 347             return;
 348         }
 349
 350         /* The actual type is the lower 7 bits of Type */
 351
 352         Type = (UINT8) (SubTable->Header.Type & 0x7F);
 353
 354         switch (Type)
 355         {
 356         case ACPI_ASF_TYPE_INFO:
 357             InfoTable = AcpiDmTableInfoAsf0;
 358             break;
 359
 360         case ACPI_ASF_TYPE_ALERT:
 361             InfoTable = AcpiDmTableInfoAsf1;
 362             DataInfoTable = AcpiDmTableInfoAsf1a;
 363             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT));
 364             DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts;
 365             DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength;
 366             DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
 367             break;
 368
 369         case ACPI_ASF_TYPE_CONTROL:
 370             InfoTable = AcpiDmTableInfoAsf2;
 371             DataInfoTable = AcpiDmTableInfoAsf2a;
 372             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE));
 373             DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls;
 374             DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength;
 375             DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
 376             break;
 377
 378         case ACPI_ASF_TYPE_BOOT:
 379             InfoTable = AcpiDmTableInfoAsf3;
 380             break;
 381
 382         case ACPI_ASF_TYPE_ADDRESS:
 383             InfoTable = AcpiDmTableInfoAsf4;
 384             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS));
 385             DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices;
 386             DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
 387             break;
 388
 389         default:
 390             AcpiOsPrintf ("\n**** Unknown ASF sub-table type 0x%X\n", SubTable->Header.Type);
 391             return;
 392         }
 393
 394         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
 395                     SubTable->Header.Length, InfoTable);
 396         if (ACPI_FAILURE (Status))
 397         {
 398             return;
 399         }
 400
 401         /* Dump variable-length extra data */
 402
 403         switch (Type)
 404         {
 405         case ACPI_ASF_TYPE_ALERT:
 406         case ACPI_ASF_TYPE_CONTROL:
 407
 408             for (i = 0; i < DataCount; i++)
 409             {
 410                 AcpiOsPrintf ("\n");
 411                 Status = AcpiDmDumpTable (Table->Length, DataOffset,
 412                             DataTable, DataLength, DataInfoTable);
 413                 if (ACPI_FAILURE (Status))
 414                 {
 415                     return;
 416                 }
 417
 418                 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
 419                 DataOffset += DataLength;
 420             }
 421             break;
 422
 423         case ACPI_ASF_TYPE_ADDRESS:
 424
 425             for (i = 0; i < DataLength; i++)
 426             {
 427                 if (!(i % 16))
 428                 {
 429                     AcpiDmLineHeader (DataOffset, 1, "Addresses");
 430                 }
 431
 432                 AcpiOsPrintf ("%2.2X ", *DataTable);
 433                 DataTable++;
 434                 DataOffset++;
 435                 if (DataOffset > Table->Length)
 436                 {
 437                     AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
 438                     return;
 439                 }
 440             }
 441
 442             AcpiOsPrintf ("\n");
 443             break;
 444
 445         default:
 446             break;
 447         }
 448
 449         AcpiOsPrintf ("\n");
 450
 451         /* Point to next sub-table */
 452
 453         if (!SubTable->Header.Length)
 454         {
 455             AcpiOsPrintf ("Invalid zero subtable header length\n");
 456             return;
 457         }
 458
 459         Offset += SubTable->Header.Length;
 460         SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length);
 461     }
 462 }
 463
 464
 465 /*******************************************************************************
 466  *
 467  * FUNCTION:    AcpiDmDumpCpep
 468  *
 469  * PARAMETERS:  Table               - A CPEP table
 470  *
 471  * RETURN:      None
 472  *
 473  * DESCRIPTION: Format the contents of a CPEP. This table type consists
 474  *              of an open-ended number of subtables.
 475  *
 476  ******************************************************************************/
 477
 478 void
 479 AcpiDmDumpCpep (
 480     ACPI_TABLE_HEADER       *Table)
 481 {
 482     ACPI_STATUS             Status;
 483     ACPI_CPEP_POLLING       *SubTable;
 484     UINT32                  Length = Table->Length;
 485     UINT32                  Offset = sizeof (ACPI_TABLE_CPEP);
 486
 487
 488     /* Main table */
 489
 490     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
 491     if (ACPI_FAILURE (Status))
 492     {
 493         return;
 494     }
 495
 496     /* Sub-tables */
 497
 498     SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
 499     while (Offset < Table->Length)
 500     {
 501         AcpiOsPrintf ("\n");
 502         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 503                     SubTable->Header.Length, AcpiDmTableInfoCpep0);
 504         if (ACPI_FAILURE (Status))
 505         {
 506             return;
 507         }
 508
 509         /* Point to next sub-table */
 510
 511         Offset += SubTable->Header.Length;
 512         SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable,
 513                     SubTable->Header.Length);
 514     }
 515 }
 516
 517
 518 /*******************************************************************************
 519  *
 520  * FUNCTION:    AcpiDmDumpDmar
 521  *
 522  * PARAMETERS:  Table               - A DMAR table
 523  *
 524  * RETURN:      None
 525  *
 526  * DESCRIPTION: Format the contents of a DMAR. This table type consists
 527  *              of an open-ended number of subtables.
 528  *
 529  ******************************************************************************/
 530
 531 void
 532 AcpiDmDumpDmar (
 533     ACPI_TABLE_HEADER       *Table)
 534 {
 535     ACPI_STATUS             Status;
 536     ACPI_DMAR_HEADER        *SubTable;
 537     UINT32                  Length = Table->Length;
 538     UINT32                  Offset = sizeof (ACPI_TABLE_DMAR);
 539     ACPI_DMTABLE_INFO       *InfoTable;
 540     ACPI_DMAR_DEVICE_SCOPE  *ScopeTable;
 541     UINT32                  ScopeOffset;
 542     UINT8                   *PciPath;
 543     UINT32                  PathOffset;
 544
 545
 546     /* Main table */
 547
 548     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
 549     if (ACPI_FAILURE (Status))
 550     {
 551         return;
 552     }
 553
 554     /* Sub-tables */
 555
 556     SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
 557     while (Offset < Table->Length)
 558     {
 559         /* Common sub-table header */
 560
 561         AcpiOsPrintf ("\n");
 562         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 563                     SubTable->Length, AcpiDmTableInfoDmarHdr);
 564         if (ACPI_FAILURE (Status))
 565         {
 566             return;
 567         }
 568
 569         switch (SubTable->Type)
 570         {
 571         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
 572             InfoTable = AcpiDmTableInfoDmar0;
 573             ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
 574             break;
 575         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
 576             InfoTable = AcpiDmTableInfoDmar1;
 577             ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
 578             break;
 579         case ACPI_DMAR_TYPE_ATSR:
 580             InfoTable = AcpiDmTableInfoDmar2;
 581             ScopeOffset = sizeof (ACPI_DMAR_ATSR);
 582             break;
 583         case ACPI_DMAR_HARDWARE_AFFINITY:
 584             InfoTable = AcpiDmTableInfoDmar3;
 585             ScopeOffset = sizeof (ACPI_DMAR_RHSA);
 586             break;
 587         default:
 588             AcpiOsPrintf ("\n**** Unknown DMAR sub-table type 0x%X\n\n", SubTable->Type);
 589             return;
 590         }
 591
 592         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 593                     SubTable->Length, InfoTable);
 594         if (ACPI_FAILURE (Status))
 595         {
 596             return;
 597         }
 598
 599         /* Dump the device scope entries (if any) */
 600
 601         ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
 602         while (ScopeOffset < SubTable->Length)
 603         {
 604             AcpiOsPrintf ("\n");
 605             Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
 606                         ScopeTable->Length, AcpiDmTableInfoDmarScope);
 607             if (ACPI_FAILURE (Status))
 608             {
 609                 return;
 610             }
 611
 612             /* Dump the PCI Path entries for this device scope */
 613
 614             PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
 615
 616             PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
 617                 sizeof (ACPI_DMAR_DEVICE_SCOPE));
 618
 619             while (PathOffset < ScopeTable->Length)
 620             {
 621                 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path");
 622                 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
 623
 624                 /* Point to next PCI Path entry */
 625
 626                 PathOffset += 2;
 627                 PciPath += 2;
 628             }
 629
 630             /* Point to next device scope entry */
 631
 632             ScopeOffset += ScopeTable->Length;
 633             ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
 634                 ScopeTable, ScopeTable->Length);
 635         }
 636
 637         /* Point to next sub-table */
 638
 639         Offset += SubTable->Length;
 640         SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length);
 641     }
 642 }
 643
 644
 645 /*******************************************************************************
 646  *
 647  * FUNCTION:    AcpiDmDumpEinj
 648  *
 649  * PARAMETERS:  Table               - A EINJ table
 650  *
 651  * RETURN:      None
 652  *
 653  * DESCRIPTION: Format the contents of a EINJ. This table type consists
 654  *              of an open-ended number of subtables.
 655  *
 656  ******************************************************************************/
 657
 658 void
 659 AcpiDmDumpEinj (
 660     ACPI_TABLE_HEADER       *Table)
 661 {
 662     ACPI_STATUS             Status;
 663     ACPI_WHEA_HEADER        *SubTable;
 664     UINT32                  Length = Table->Length;
 665     UINT32                  Offset = sizeof (ACPI_TABLE_EINJ);
 666
 667
 668     /* Main table */
 669
 670     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
 671     if (ACPI_FAILURE (Status))
 672     {
 673         return;
 674     }
 675
 676     /* Sub-tables */
 677
 678     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
 679     while (Offset < Table->Length)
 680     {
 681         AcpiOsPrintf ("\n");
 682         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 683                     sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
 684         if (ACPI_FAILURE (Status))
 685         {
 686             return;
 687         }
 688
 689         /* Point to next sub-table (each subtable is of fixed length) */
 690
 691         Offset += sizeof (ACPI_WHEA_HEADER);
 692         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
 693                         sizeof (ACPI_WHEA_HEADER));
 694     }
 695 }
 696
 697
 698 /*******************************************************************************
 699  *
 700  * FUNCTION:    AcpiDmDumpErst
 701  *
 702  * PARAMETERS:  Table               - A ERST table
 703  *
 704  * RETURN:      None
 705  *
 706  * DESCRIPTION: Format the contents of a ERST. This table type consists
 707  *              of an open-ended number of subtables.
 708  *
 709  ******************************************************************************/
 710
 711 void
 712 AcpiDmDumpErst (
 713     ACPI_TABLE_HEADER       *Table)
 714 {
 715     ACPI_STATUS             Status;
 716     ACPI_WHEA_HEADER        *SubTable;
 717     UINT32                  Length = Table->Length;
 718     UINT32                  Offset = sizeof (ACPI_TABLE_ERST);
 719
 720
 721     /* Main table */
 722
 723     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
 724     if (ACPI_FAILURE (Status))
 725     {
 726         return;
 727     }
 728
 729     /* Sub-tables */
 730
 731     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
 732     while (Offset < Table->Length)
 733     {
 734         AcpiOsPrintf ("\n");
 735         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 736                     sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
 737         if (ACPI_FAILURE (Status))
 738         {
 739             return;
 740         }
 741
 742         /* Point to next sub-table (each subtable is of fixed length) */
 743
 744         Offset += sizeof (ACPI_WHEA_HEADER);
 745         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
 746                         sizeof (ACPI_WHEA_HEADER));
 747     }
 748 }
 749
 750
 751 /*******************************************************************************
 752  *
 753  * FUNCTION:    AcpiDmDumpHest
 754  *
 755  * PARAMETERS:  Table               - A HEST table
 756  *
 757  * RETURN:      None
 758  *
 759  * DESCRIPTION: Format the contents of a HEST. This table type consists
 760  *              of an open-ended number of subtables.
 761  *
 762  ******************************************************************************/
 763
 764 void
 765 AcpiDmDumpHest (
 766     ACPI_TABLE_HEADER       *Table)
 767 {
 768     ACPI_STATUS             Status;
 769     ACPI_HEST_HEADER        *SubTable;
 770     UINT32                  Length = Table->Length;
 771     UINT32                  Offset = sizeof (ACPI_TABLE_HEST);
 772     ACPI_DMTABLE_INFO       *InfoTable;
 773     UINT32                  SubTableLength;
 774     UINT32                  BankCount;
 775     ACPI_HEST_IA_ERROR_BANK *BankTable;
 776
 777
 778     /* Main table */
 779
 780     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
 781     if (ACPI_FAILURE (Status))
 782     {
 783         return;
 784     }
 785
 786     /* Sub-tables */
 787
 788     SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
 789     while (Offset < Table->Length)
 790     {
 791         BankCount = 0;
 792         switch (SubTable->Type)
 793         {
 794         case ACPI_HEST_TYPE_IA32_CHECK:
 795             InfoTable = AcpiDmTableInfoHest0;
 796             SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
 797             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
 798                             SubTable))->NumHardwareBanks;
 799             break;
 800
 801         case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
 802             InfoTable = AcpiDmTableInfoHest1;
 803             SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED);
 804             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
 805                             SubTable))->NumHardwareBanks;
 806             break;
 807
 808         case ACPI_HEST_TYPE_IA32_NMI:
 809             InfoTable = AcpiDmTableInfoHest2;
 810             SubTableLength = sizeof (ACPI_HEST_IA_NMI);
 811             break;
 812
 813         case ACPI_HEST_TYPE_AER_ROOT_PORT:
 814             InfoTable = AcpiDmTableInfoHest6;
 815             SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
 816             break;
 817
 818         case ACPI_HEST_TYPE_AER_ENDPOINT:
 819             InfoTable = AcpiDmTableInfoHest7;
 820             SubTableLength = sizeof (ACPI_HEST_AER);
 821             break;
 822
 823         case ACPI_HEST_TYPE_AER_BRIDGE:
 824             InfoTable = AcpiDmTableInfoHest8;
 825             SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
 826             break;
 827
 828         case ACPI_HEST_TYPE_GENERIC_ERROR:
 829             InfoTable = AcpiDmTableInfoHest9;
 830             SubTableLength = sizeof (ACPI_HEST_GENERIC);
 831             break;
 832
 833         default:
 834             /* Cannot continue on unknown type - no length */
 835
 836             AcpiOsPrintf ("\n**** Unknown HEST sub-table type 0x%X\n", SubTable->Type);
 837             return;
 838         }
 839
 840         AcpiOsPrintf ("\n");
 841         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 842                     SubTableLength, InfoTable);
 843         if (ACPI_FAILURE (Status))
 844         {
 845             return;
 846         }
 847
 848         /* Point to end of current subtable (each subtable above is of fixed length) */
 849
 850         Offset += SubTableLength;
 851
 852         /* If there are any (fixed-length) Error Banks from above, dump them now */
 853
 854         if (BankCount)
 855         {
 856             BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength);
 857             SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
 858
 859             while (BankCount)
 860             {
 861                 AcpiOsPrintf ("\n");
 862                 Status = AcpiDmDumpTable (Length, Offset, BankTable,
 863                             sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
 864                 if (ACPI_FAILURE (Status))
 865                 {
 866                     return;
 867                 }
 868                 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
 869                 BankTable++;
 870                 BankCount--;
 871             }
 872         }
 873
 874         /* Point to next sub-table */
 875
 876         SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
 877     }
 878 }
 879
 880
 881 /*******************************************************************************
 882  *
 883  * FUNCTION:    AcpiDmDumpIvrs
 884  *
 885  * PARAMETERS:  Table               - A IVRS table
 886  *
 887  * RETURN:      None
 888  *
 889  * DESCRIPTION: Format the contents of a IVRS
 890  *
 891  ******************************************************************************/
 892
 893 static UINT8 EntrySizes[] = {4,8,16,32};
 894
 895 void
 896 AcpiDmDumpIvrs (
 897     ACPI_TABLE_HEADER       *Table)
 898 {
 899     ACPI_STATUS             Status;
 900     UINT32                  Offset = sizeof (ACPI_TABLE_IVRS);
 901     UINT32                  EntryOffset;
 902     UINT32                  EntryLength;
 903     UINT32                  EntryType;
 904     ACPI_IVRS_DE_HEADER     *DeviceEntry;
 905     ACPI_IVRS_HEADER        *SubTable;
 906     ACPI_DMTABLE_INFO       *InfoTable;
 907
 908
 909     /* Main table */
 910
 911     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
 912     if (ACPI_FAILURE (Status))
 913     {
 914         return;
 915     }
 916
 917     /* Sub-tables */
 918
 919     SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
 920     while (Offset < Table->Length)
 921     {
 922         /* Common sub-table header */
 923
 924         AcpiOsPrintf ("\n");
 925         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
 926                     SubTable->Length, AcpiDmTableInfoIvrsHdr);
 927         if (ACPI_FAILURE (Status))
 928         {
 929             return;
 930         }
 931
 932         switch (SubTable->Type)
 933         {
 934         case ACPI_IVRS_TYPE_HARDWARE:
 935             InfoTable = AcpiDmTableInfoIvrs0;
 936             break;
 937         case ACPI_IVRS_TYPE_MEMORY1:
 938         case ACPI_IVRS_TYPE_MEMORY2:
 939         case ACPI_IVRS_TYPE_MEMORY3:
 940             InfoTable = AcpiDmTableInfoIvrs1;
 941             break;
 942         default:
 943             AcpiOsPrintf ("\n**** Unknown IVRS sub-table type 0x%X\n",
 944                 SubTable->Type);
 945
 946             /* Attempt to continue */
 947
 948             if (!SubTable->Length)
 949             {
 950                 AcpiOsPrintf ("Invalid zero length subtable\n");
 951                 return;
 952             }
 953             goto NextSubTable;
 954         }
 955
 956         /* Dump the subtable */
 957
 958         AcpiOsPrintf ("\n");
 959         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
 960                     SubTable->Length, InfoTable);
 961         if (ACPI_FAILURE (Status))
 962         {
 963             return;
 964         }
 965
 966         /* The hardware subtable can contain multiple device entries */
 967
 968         if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
 969         {
 970             EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
 971             DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
 972                             sizeof (ACPI_IVRS_HARDWARE));
 973
 974             while (EntryOffset < (Offset + SubTable->Length))
 975             {
 976                 AcpiOsPrintf ("\n");
 977                 /*
 978                  * Upper 2 bits of Type encode the length of the device entry
 979                  *
 980                  * 00 = 4 byte
 981                  * 01 = 8 byte
 982                  * 10 = 16 byte - currently no entries defined
 983                  * 11 = 32 byte - currently no entries defined
 984                  */
 985                 EntryType = DeviceEntry->Type;
 986                 EntryLength = EntrySizes [EntryType >> 6];
 987
 988                 switch (EntryType)
 989                 {
 990                 /* 4-byte device entries */
 991
 992                 case ACPI_IVRS_TYPE_PAD4:
 993                 case ACPI_IVRS_TYPE_ALL:
 994                 case ACPI_IVRS_TYPE_SELECT:
 995                 case ACPI_IVRS_TYPE_START:
 996                 case ACPI_IVRS_TYPE_END:
 997
 998                     InfoTable = AcpiDmTableInfoIvrs4;
 999                     break;
1000
1001                 /* 8-byte entries, type A */
1002
1003                 case ACPI_IVRS_TYPE_ALIAS_SELECT:
1004                 case ACPI_IVRS_TYPE_ALIAS_START:
1005
1006                     InfoTable = AcpiDmTableInfoIvrs8a;
1007                     break;
1008
1009                 /* 8-byte entries, type B */
1010
1011                 case ACPI_IVRS_TYPE_PAD8:
1012                 case ACPI_IVRS_TYPE_EXT_SELECT:
1013                 case ACPI_IVRS_TYPE_EXT_START:
1014
1015                     InfoTable = AcpiDmTableInfoIvrs8b;
1016                     break;
1017
1018                 /* 8-byte entries, type C */
1019
1020                 case ACPI_IVRS_TYPE_SPECIAL:
1021
1022                     InfoTable = AcpiDmTableInfoIvrs8c;
1023                     break;
1024
1025                 default:
1026                     InfoTable = AcpiDmTableInfoIvrs4;
1027                     AcpiOsPrintf (
1028                         "\n**** Unknown IVRS device entry type/length: "
1029                         "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
1030                         EntryType, EntryLength, EntryOffset);
1031                     break;
1032                 }
1033
1034                 /* Dump the Device Entry */
1035
1036                 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
1037                             DeviceEntry, EntryLength, InfoTable);
1038
1039                 EntryOffset += EntryLength;
1040                 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
1041                                 EntryLength);
1042             }
1043         }
1044
1045 NextSubTable:
1046         /* Point to next sub-table */
1047
1048         Offset += SubTable->Length;
1049         SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
1050     }
1051 }
1052
1053
1054 /*******************************************************************************
1055  *
1056  * FUNCTION:    AcpiDmDumpMadt
1057  *
1058  * PARAMETERS:  Table               - A MADT table
1059  *
1060  * RETURN:      None
1061  *
1062  * DESCRIPTION: Format the contents of a MADT. This table type consists
1063  *              of an open-ended number of subtables.
1064  *
1065  ******************************************************************************/
1066
1067 void
1068 AcpiDmDumpMadt (
1069     ACPI_TABLE_HEADER       *Table)
1070 {
1071     ACPI_STATUS             Status;
1072     ACPI_SUBTABLE_HEADER    *SubTable;
1073     UINT32                  Length = Table->Length;
1074     UINT32                  Offset = sizeof (ACPI_TABLE_MADT);
1075     ACPI_DMTABLE_INFO       *InfoTable;
1076
1077
1078     /* Main table */
1079
1080     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
1081     if (ACPI_FAILURE (Status))
1082     {
1083         return;
1084     }
1085
1086     /* Sub-tables */
1087
1088     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1089     while (Offset < Table->Length)
1090     {
1091         /* Common sub-table header */
1092
1093         AcpiOsPrintf ("\n");
1094         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1095                     SubTable->Length, AcpiDmTableInfoMadtHdr);
1096         if (ACPI_FAILURE (Status))
1097         {
1098             return;
1099         }
1100
1101         switch (SubTable->Type)
1102         {
1103         case ACPI_MADT_TYPE_LOCAL_APIC:
1104             InfoTable = AcpiDmTableInfoMadt0;
1105             break;
1106         case ACPI_MADT_TYPE_IO_APIC:
1107             InfoTable = AcpiDmTableInfoMadt1;
1108             break;
1109         case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
1110             InfoTable = AcpiDmTableInfoMadt2;
1111             break;
1112         case ACPI_MADT_TYPE_NMI_SOURCE:
1113             InfoTable = AcpiDmTableInfoMadt3;
1114             break;
1115         case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
1116             InfoTable = AcpiDmTableInfoMadt4;
1117             break;
1118         case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
1119             InfoTable = AcpiDmTableInfoMadt5;
1120             break;
1121         case ACPI_MADT_TYPE_IO_SAPIC:
1122             InfoTable = AcpiDmTableInfoMadt6;
1123             break;
1124         case ACPI_MADT_TYPE_LOCAL_SAPIC:
1125             InfoTable = AcpiDmTableInfoMadt7;
1126             break;
1127         case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
1128             InfoTable = AcpiDmTableInfoMadt8;
1129             break;
1130         case ACPI_MADT_TYPE_LOCAL_X2APIC:
1131             InfoTable = AcpiDmTableInfoMadt9;
1132             break;
1133         case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
1134             InfoTable = AcpiDmTableInfoMadt10;
1135             break;
1136         default:
1137             AcpiOsPrintf ("\n**** Unknown MADT sub-table type 0x%X\n\n", SubTable->Type);
1138
1139             /* Attempt to continue */
1140
1141             if (!SubTable->Length)
1142             {
1143                 AcpiOsPrintf ("Invalid zero length subtable\n");
1144                 return;
1145             }
1146             goto NextSubTable;
1147         }
1148
1149         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1150                     SubTable->Length, InfoTable);
1151         if (ACPI_FAILURE (Status))
1152         {
1153             return;
1154         }
1155
1156 NextSubTable:
1157         /* Point to next sub-table */
1158
1159         Offset += SubTable->Length;
1160         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1161     }
1162 }
1163
1164
1165 /*******************************************************************************
1166  *
1167  * FUNCTION:    AcpiDmDumpMcfg
1168  *
1169  * PARAMETERS:  Table               - A MCFG Table
1170  *
1171  * RETURN:      None
1172  *
1173  * DESCRIPTION: Format the contents of a MCFG table
1174  *
1175  ******************************************************************************/
1176
1177 void
1178 AcpiDmDumpMcfg (
1179     ACPI_TABLE_HEADER       *Table)
1180 {
1181     ACPI_STATUS             Status;
1182     UINT32                  Offset = sizeof (ACPI_TABLE_MCFG);
1183     ACPI_MCFG_ALLOCATION    *SubTable;
1184
1185
1186     /* Main table */
1187
1188     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
1189     if (ACPI_FAILURE (Status))
1190     {
1191         return;
1192     }
1193
1194     /* Sub-tables */
1195
1196     SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
1197     while (Offset < Table->Length)
1198     {
1199         if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
1200         {
1201             AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
1202                 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
1203             return;
1204         }
1205
1206         AcpiOsPrintf ("\n");
1207         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1208                     sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
1209         if (ACPI_FAILURE (Status))
1210         {
1211             return;
1212         }
1213
1214         /* Point to next sub-table (each subtable is of fixed length) */
1215
1216         Offset += sizeof (ACPI_MCFG_ALLOCATION);
1217         SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
1218                         sizeof (ACPI_MCFG_ALLOCATION));
1219     }
1220 }
1221
1222
1223 /*******************************************************************************
1224  *
1225  * FUNCTION:    AcpiDmDumpMsct
1226  *
1227  * PARAMETERS:  Table               - A MSCT table
1228  *
1229  * RETURN:      None
1230  *
1231  * DESCRIPTION: Format the contents of a MSCT
1232  *
1233  ******************************************************************************/
1234
1235 void
1236 AcpiDmDumpMsct (
1237     ACPI_TABLE_HEADER       *Table)
1238 {
1239     ACPI_STATUS             Status;
1240     UINT32                  Offset = sizeof (ACPI_TABLE_MSCT);
1241     ACPI_MSCT_PROXIMITY     *SubTable;
1242
1243
1244     /* Main table */
1245
1246     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1247     if (ACPI_FAILURE (Status))
1248     {
1249         return;
1250     }
1251
1252     /* Sub-tables */
1253
1254     SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1255     while (Offset < Table->Length)
1256     {
1257         /* Common sub-table header */
1258
1259         AcpiOsPrintf ("\n");
1260         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1261                     sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1262         if (ACPI_FAILURE (Status))
1263         {
1264             return;
1265         }
1266
1267         /* Point to next sub-table */
1268
1269         Offset += sizeof (ACPI_MSCT_PROXIMITY);
1270         SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY));
1271     }
1272 }
1273
1274
1275 /*******************************************************************************
1276  *
1277  * FUNCTION:    AcpiDmDumpSlit
1278  *
1279  * PARAMETERS:  Table               - An SLIT
1280  *
1281  * RETURN:      None
1282  *
1283  * DESCRIPTION: Format the contents of a SLIT
1284  *
1285  ******************************************************************************/
1286
1287 void
1288 AcpiDmDumpSlit (
1289     ACPI_TABLE_HEADER       *Table)
1290 {
1291     ACPI_STATUS             Status;
1292     UINT32                  Offset;
1293     UINT8                   *Row;
1294     UINT32                  Localities;
1295     UINT32                  i;
1296     UINT32                  j;
1297
1298
1299     /* Main table */
1300
1301     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
1302     if (ACPI_FAILURE (Status))
1303     {
1304         return;
1305     }
1306
1307     /* Display the Locality NxN Matrix */
1308
1309     Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
1310     Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
1311     Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
1312
1313     for (i = 0; i < Localities; i++)
1314     {
1315         /* Display one row of the matrix */
1316
1317         AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
1318         for  (j = 0; j < Localities; j++)
1319         {
1320             /* Check for beyond EOT */
1321
1322             if (Offset >= Table->Length)
1323             {
1324                 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n");
1325                 return;
1326             }
1327
1328             AcpiOsPrintf ("%2.2X", Row[j]);
1329             Offset++;
1330
1331             /* Display up to 16 bytes per output row */
1332
1333             if ((j+1) < Localities)
1334             {
1335                 AcpiOsPrintf (",");
1336
1337                 if (j && (((j+1) % 16) == 0))
1338                 {
1339                     AcpiOsPrintf ("\n");
1340                     AcpiDmLineHeader (Offset, 0, "");
1341                 }
1342             }
1343         }
1344
1345         /* Point to next row */
1346
1347         AcpiOsPrintf ("\n");
1348         Row += Localities;
1349     }
1350 }
1351
1352
1353 /*******************************************************************************
1354  *
1355  * FUNCTION:    AcpiDmDumpSrat
1356  *
1357  * PARAMETERS:  Table               - A SRAT table
1358  *
1359  * RETURN:      None
1360  *
1361  * DESCRIPTION: Format the contents of a SRAT
1362  *
1363  ******************************************************************************/
1364
1365 void
1366 AcpiDmDumpSrat (
1367     ACPI_TABLE_HEADER       *Table)
1368 {
1369     ACPI_STATUS             Status;
1370     UINT32                  Offset = sizeof (ACPI_TABLE_SRAT);
1371     ACPI_SUBTABLE_HEADER    *SubTable;
1372     ACPI_DMTABLE_INFO       *InfoTable;
1373
1374
1375     /* Main table */
1376
1377     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
1378     if (ACPI_FAILURE (Status))
1379     {
1380         return;
1381     }
1382
1383     /* Sub-tables */
1384
1385     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1386     while (Offset < Table->Length)
1387     {
1388         /* Common sub-table header */
1389
1390         AcpiOsPrintf ("\n");
1391         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1392                     SubTable->Length, AcpiDmTableInfoSratHdr);
1393         if (ACPI_FAILURE (Status))
1394         {
1395             return;
1396         }
1397
1398         switch (SubTable->Type)
1399         {
1400         case ACPI_SRAT_TYPE_CPU_AFFINITY:
1401             InfoTable = AcpiDmTableInfoSrat0;
1402             break;
1403         case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
1404             InfoTable = AcpiDmTableInfoSrat1;
1405             break;
1406         case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
1407             InfoTable = AcpiDmTableInfoSrat2;
1408             break;
1409         default:
1410             AcpiOsPrintf ("\n**** Unknown SRAT sub-table type 0x%X\n", SubTable->Type);
1411
1412             /* Attempt to continue */
1413
1414             if (!SubTable->Length)
1415             {
1416                 AcpiOsPrintf ("Invalid zero length subtable\n");
1417                 return;
1418             }
1419             goto NextSubTable;
1420         }
1421
1422         AcpiOsPrintf ("\n");
1423         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1424                     SubTable->Length, InfoTable);
1425         if (ACPI_FAILURE (Status))
1426         {
1427             return;
1428         }
1429
1430 NextSubTable:
1431         /* Point to next sub-table */
1432
1433         Offset += SubTable->Length;
1434         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1435     }
1436 }
1437
1438
1439 /*******************************************************************************
1440  *
1441  * FUNCTION:    AcpiDmDumpWdat
1442  *
1443  * PARAMETERS:  Table               - A WDAT table
1444  *
1445  * RETURN:      None
1446  *
1447  * DESCRIPTION: Format the contents of a WDAT
1448  *
1449  ******************************************************************************/
1450
1451 void
1452 AcpiDmDumpWdat (
1453     ACPI_TABLE_HEADER       *Table)
1454 {
1455     ACPI_STATUS             Status;
1456     UINT32                  Offset = sizeof (ACPI_TABLE_WDAT);
1457     ACPI_WDAT_ENTRY         *SubTable;
1458
1459
1460     /* Main table */
1461
1462     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
1463     if (ACPI_FAILURE (Status))
1464     {
1465         return;
1466     }
1467
1468     /* Sub-tables */
1469
1470     SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
1471     while (Offset < Table->Length)
1472     {
1473         /* Common sub-table header */
1474
1475         AcpiOsPrintf ("\n");
1476         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1477                     sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
1478         if (ACPI_FAILURE (Status))
1479         {
1480             return;
1481         }
1482
1483         /* Point to next sub-table */
1484
1485         Offset += sizeof (ACPI_WDAT_ENTRY);
1486         SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY));
1487     }
1488 }