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