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