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  * Copyright (C) 2000 - 2012, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include <contrib/dev/acpica/include/acpi.h>
  45 #include <contrib/dev/acpica/include/accommon.h>
  46 #include <contrib/dev/acpica/include/acdisasm.h>
  47 #include <contrib/dev/acpica/include/actables.h>
  48
  49 /* This module used for application-level code only */
  50
  51 #define _COMPONENT          ACPI_CA_DISASSEMBLER
  52         ACPI_MODULE_NAME    ("dmtbdump")
  53
  54
  55 /* Local prototypes */
  56
  57 static void
  58 AcpiDmValidateFadtLength (
  59     UINT32                  Revision,
  60     UINT32                  Length);
  61
  62 static void
  63 AcpiDmDumpBuffer (
  64     void                    *Table,
  65     UINT32                  BufferOffset,
  66     UINT32                  Length,
  67     UINT32                  AbsoluteOffset,
  68     char                    *Header);
  69
  70
  71 /*******************************************************************************
  72  *
  73  * FUNCTION:    AcpiDmDumpBuffer
  74  *
  75  * PARAMETERS:  Table               - ACPI Table or subtable
  76  *              BufferOffset        - Offset of buffer from Table above
  77  *              Length              - Length of the buffer
  78  *              AbsoluteOffset      - Offset of buffer in the main ACPI table
  79  *              Header              - Name of the buffer field (printed on the
  80  *                                    first line only.)
  81  *
  82  * RETURN:      None
  83  *
  84  * DESCRIPTION: Format the contents of an arbitrary length data buffer (in the
  85  *              disassembler output format.)
  86  *
  87  ******************************************************************************/
  88
  89 static void
  90 AcpiDmDumpBuffer (
  91     void                    *Table,
  92     UINT32                  BufferOffset,
  93     UINT32                  Length,
  94     UINT32                  AbsoluteOffset,
  95     char                    *Header)
  96 {
  97     UINT8                   *Buffer;
  98     UINT32                  i;
  99
 100
 101     if (!Length)
 102     {
 103         return;
 104     }
 105
 106     Buffer = ACPI_CAST_PTR (UINT8, Table) + BufferOffset;
 107     i = 0;
 108
 109     while (i < Length)
 110     {
 111         if (!(i % 16))
 112         {
 113             AcpiOsPrintf ("\n");
 114             AcpiDmLineHeader (AbsoluteOffset,
 115                 ((Length - i) > 16) ? 16 : (Length - i), Header);
 116             Header = NULL;
 117         }
 118
 119         AcpiOsPrintf ("%.02X ", *Buffer);
 120         i++;
 121         Buffer++;
 122         AbsoluteOffset++;
 123     }
 124
 125     AcpiOsPrintf ("\n");
 126 }
 127
 128
 129 /*******************************************************************************
 130  *
 131  * FUNCTION:    AcpiDmDumpRsdp
 132  *
 133  * PARAMETERS:  Table               - A RSDP
 134  *
 135  * RETURN:      Length of the table (there is not always a length field,
 136  *              use revision or length if available (ACPI 2.0+))
 137  *
 138  * DESCRIPTION: Format the contents of a RSDP
 139  *
 140  ******************************************************************************/
 141
 142 UINT32
 143 AcpiDmDumpRsdp (
 144     ACPI_TABLE_HEADER       *Table)
 145 {
 146     ACPI_TABLE_RSDP         *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
 147     UINT32                  Length = sizeof (ACPI_RSDP_COMMON);
 148     UINT8                   Checksum;
 149
 150
 151     /* Dump the common ACPI 1.0 portion */
 152
 153     AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
 154
 155     /* Validate the first checksum */
 156
 157     Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON),
 158                 Rsdp->Checksum);
 159     if (Checksum != Rsdp->Checksum)
 160     {
 161         AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n",
 162             Checksum);
 163     }
 164
 165     /* The RSDP for ACPI 2.0+ contains more data and has a Length field */
 166
 167     if (Rsdp->Revision > 0)
 168     {
 169         Length = Rsdp->Length;
 170         AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
 171
 172         /* Validate the extended checksum over entire RSDP */
 173
 174         Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP),
 175                     Rsdp->ExtendedChecksum);
 176         if (Checksum != Rsdp->ExtendedChecksum)
 177         {
 178             AcpiOsPrintf (
 179                 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n",
 180                 Checksum);
 181         }
 182     }
 183
 184     return (Length);
 185 }
 186
 187
 188 /*******************************************************************************
 189  *
 190  * FUNCTION:    AcpiDmDumpRsdt
 191  *
 192  * PARAMETERS:  Table               - A RSDT
 193  *
 194  * RETURN:      None
 195  *
 196  * DESCRIPTION: Format the contents of a RSDT
 197  *
 198  ******************************************************************************/
 199
 200 void
 201 AcpiDmDumpRsdt (
 202     ACPI_TABLE_HEADER       *Table)
 203 {
 204     UINT32                  *Array;
 205     UINT32                  Entries;
 206     UINT32                  Offset;
 207     UINT32                  i;
 208
 209
 210     /* Point to start of table pointer array */
 211
 212     Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry;
 213     Offset = sizeof (ACPI_TABLE_HEADER);
 214
 215     /* RSDT uses 32-bit pointers */
 216
 217     Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
 218
 219     for (i = 0; i < Entries; i++)
 220     {
 221         AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i);
 222         AcpiOsPrintf ("%8.8X\n", Array[i]);
 223         Offset += sizeof (UINT32);
 224     }
 225 }
 226
 227
 228 /*******************************************************************************
 229  *
 230  * FUNCTION:    AcpiDmDumpXsdt
 231  *
 232  * PARAMETERS:  Table               - A XSDT
 233  *
 234  * RETURN:      None
 235  *
 236  * DESCRIPTION: Format the contents of a XSDT
 237  *
 238  ******************************************************************************/
 239
 240 void
 241 AcpiDmDumpXsdt (
 242     ACPI_TABLE_HEADER       *Table)
 243 {
 244     UINT64                  *Array;
 245     UINT32                  Entries;
 246     UINT32                  Offset;
 247     UINT32                  i;
 248
 249
 250     /* Point to start of table pointer array */
 251
 252     Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry;
 253     Offset = sizeof (ACPI_TABLE_HEADER);
 254
 255     /* XSDT uses 64-bit pointers */
 256
 257     Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
 258
 259     for (i = 0; i < Entries; i++)
 260     {
 261         AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i);
 262         AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i]));
 263         Offset += sizeof (UINT64);
 264     }
 265 }
 266
 267
 268 /*******************************************************************************
 269  *
 270  * FUNCTION:    AcpiDmDumpFadt
 271  *
 272  * PARAMETERS:  Table               - A FADT
 273  *
 274  * RETURN:      None
 275  *
 276  * DESCRIPTION: Format the contents of a FADT
 277  *
 278  * NOTE:        We cannot depend on the FADT version to indicate the actual
 279  *              contents of the FADT because of BIOS bugs. The table length
 280  *              is the only reliable indicator.
 281  *
 282  ******************************************************************************/
 283
 284 void
 285 AcpiDmDumpFadt (
 286     ACPI_TABLE_HEADER       *Table)
 287 {
 288
 289     /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */
 290
 291     AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1);
 292
 293     /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */
 294
 295     if ((Table->Length > ACPI_FADT_V1_SIZE) &&
 296         (Table->Length <= ACPI_FADT_V2_SIZE))
 297     {
 298         AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2);
 299     }
 300
 301     /* Check for FADT revision 3/4 fields and up (ACPI 2.0+ extended data) */
 302
 303     else if (Table->Length > ACPI_FADT_V2_SIZE)
 304     {
 305         AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3);
 306
 307         /* Check for FADT revision 5 fields and up (ACPI 5.0+) */
 308
 309         if (Table->Length > ACPI_FADT_V3_SIZE)
 310         {
 311             AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt5);
 312         }
 313     }
 314
 315     /* Validate various fields in the FADT, including length */
 316
 317     AcpiTbCreateLocalFadt (Table, Table->Length);
 318
 319     /* Validate FADT length against the revision */
 320
 321     AcpiDmValidateFadtLength (Table->Revision, Table->Length);
 322 }
 323
 324
 325 /*******************************************************************************
 326  *
 327  * FUNCTION:    AcpiDmValidateFadtLength
 328  *
 329  * PARAMETERS:  Revision            - FADT revision (Header->Revision)
 330  *              Length              - FADT length (Header->Length
 331  *
 332  * RETURN:      None
 333  *
 334  * DESCRIPTION: Check the FADT revision against the expected table length for
 335  *              that revision. Issue a warning if the length is not what was
 336  *              expected. This seems to be such a common BIOS bug that the
 337  *              FADT revision has been rendered virtually meaningless.
 338  *
 339  ******************************************************************************/
 340
 341 static void
 342 AcpiDmValidateFadtLength (
 343     UINT32                  Revision,
 344     UINT32                  Length)
 345 {
 346     UINT32                  ExpectedLength;
 347
 348
 349     switch (Revision)
 350     {
 351     case 0:
 352         AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n");
 353         return;
 354
 355     case 1:
 356         ExpectedLength = ACPI_FADT_V1_SIZE;
 357         break;
 358
 359     case 2:
 360         ExpectedLength = ACPI_FADT_V2_SIZE;
 361         break;
 362
 363     case 3:
 364     case 4:
 365         ExpectedLength = ACPI_FADT_V3_SIZE;
 366         break;
 367
 368     case 5:
 369         ExpectedLength = ACPI_FADT_V5_SIZE;
 370         break;
 371
 372     default:
 373         return;
 374     }
 375
 376     if (Length == ExpectedLength)
 377     {
 378         return;
 379     }
 380
 381     AcpiOsPrintf (
 382         "\n// ACPI Warning: FADT revision %X does not match length: found %X expected %X\n",
 383         Revision, Length, ExpectedLength);
 384 }
 385
 386
 387 /*******************************************************************************
 388  *
 389  * FUNCTION:    AcpiDmDumpAsf
 390  *
 391  * PARAMETERS:  Table               - A ASF table
 392  *
 393  * RETURN:      None
 394  *
 395  * DESCRIPTION: Format the contents of a ASF table
 396  *
 397  ******************************************************************************/
 398
 399 void
 400 AcpiDmDumpAsf (
 401     ACPI_TABLE_HEADER       *Table)
 402 {
 403     ACPI_STATUS             Status;
 404     UINT32                  Offset = sizeof (ACPI_TABLE_HEADER);
 405     ACPI_ASF_INFO           *SubTable;
 406     ACPI_DMTABLE_INFO       *InfoTable;
 407     ACPI_DMTABLE_INFO       *DataInfoTable = NULL;
 408     UINT8                   *DataTable = NULL;
 409     UINT32                  DataCount = 0;
 410     UINT32                  DataLength = 0;
 411     UINT32                  DataOffset = 0;
 412     UINT32                  i;
 413     UINT8                   Type;
 414
 415
 416     /* No main table, only sub-tables */
 417
 418     SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
 419     while (Offset < Table->Length)
 420     {
 421         /* Common sub-table header */
 422
 423         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
 424                     SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
 425         if (ACPI_FAILURE (Status))
 426         {
 427             return;
 428         }
 429
 430         /* The actual type is the lower 7 bits of Type */
 431
 432         Type = (UINT8) (SubTable->Header.Type & 0x7F);
 433
 434         switch (Type)
 435         {
 436         case ACPI_ASF_TYPE_INFO:
 437             InfoTable = AcpiDmTableInfoAsf0;
 438             break;
 439
 440         case ACPI_ASF_TYPE_ALERT:
 441             InfoTable = AcpiDmTableInfoAsf1;
 442             DataInfoTable = AcpiDmTableInfoAsf1a;
 443             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT));
 444             DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts;
 445             DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength;
 446             DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
 447             break;
 448
 449         case ACPI_ASF_TYPE_CONTROL:
 450             InfoTable = AcpiDmTableInfoAsf2;
 451             DataInfoTable = AcpiDmTableInfoAsf2a;
 452             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE));
 453             DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls;
 454             DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength;
 455             DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
 456             break;
 457
 458         case ACPI_ASF_TYPE_BOOT:
 459             InfoTable = AcpiDmTableInfoAsf3;
 460             break;
 461
 462         case ACPI_ASF_TYPE_ADDRESS:
 463             InfoTable = AcpiDmTableInfoAsf4;
 464             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS));
 465             DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices;
 466             DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
 467             break;
 468
 469         default:
 470             AcpiOsPrintf ("\n**** Unknown ASF sub-table type 0x%X\n", SubTable->Header.Type);
 471             return;
 472         }
 473
 474         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
 475                     SubTable->Header.Length, InfoTable);
 476         if (ACPI_FAILURE (Status))
 477         {
 478             return;
 479         }
 480
 481         /* Dump variable-length extra data */
 482
 483         switch (Type)
 484         {
 485         case ACPI_ASF_TYPE_ALERT:
 486         case ACPI_ASF_TYPE_CONTROL:
 487
 488             for (i = 0; i < DataCount; i++)
 489             {
 490                 AcpiOsPrintf ("\n");
 491                 Status = AcpiDmDumpTable (Table->Length, DataOffset,
 492                             DataTable, DataLength, DataInfoTable);
 493                 if (ACPI_FAILURE (Status))
 494                 {
 495                     return;
 496                 }
 497
 498                 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
 499                 DataOffset += DataLength;
 500             }
 501             break;
 502
 503         case ACPI_ASF_TYPE_ADDRESS:
 504
 505             for (i = 0; i < DataLength; i++)
 506             {
 507                 if (!(i % 16))
 508                 {
 509                     AcpiDmLineHeader (DataOffset, 1, "Addresses");
 510                 }
 511
 512                 AcpiOsPrintf ("%2.2X ", *DataTable);
 513                 DataTable++;
 514                 DataOffset++;
 515                 if (DataOffset > Table->Length)
 516                 {
 517                     AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
 518                     return;
 519                 }
 520             }
 521
 522             AcpiOsPrintf ("\n");
 523             break;
 524
 525         default:
 526             break;
 527         }
 528
 529         AcpiOsPrintf ("\n");
 530
 531         /* Point to next sub-table */
 532
 533         if (!SubTable->Header.Length)
 534         {
 535             AcpiOsPrintf ("Invalid zero subtable header length\n");
 536             return;
 537         }
 538
 539         Offset += SubTable->Header.Length;
 540         SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length);
 541     }
 542 }
 543
 544
 545 /*******************************************************************************
 546  *
 547  * FUNCTION:    AcpiDmDumpCpep
 548  *
 549  * PARAMETERS:  Table               - A CPEP table
 550  *
 551  * RETURN:      None
 552  *
 553  * DESCRIPTION: Format the contents of a CPEP. This table type consists
 554  *              of an open-ended number of subtables.
 555  *
 556  ******************************************************************************/
 557
 558 void
 559 AcpiDmDumpCpep (
 560     ACPI_TABLE_HEADER       *Table)
 561 {
 562     ACPI_STATUS             Status;
 563     ACPI_CPEP_POLLING       *SubTable;
 564     UINT32                  Length = Table->Length;
 565     UINT32                  Offset = sizeof (ACPI_TABLE_CPEP);
 566
 567
 568     /* Main table */
 569
 570     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
 571     if (ACPI_FAILURE (Status))
 572     {
 573         return;
 574     }
 575
 576     /* Sub-tables */
 577
 578     SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
 579     while (Offset < Table->Length)
 580     {
 581         AcpiOsPrintf ("\n");
 582         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 583                     SubTable->Header.Length, AcpiDmTableInfoCpep0);
 584         if (ACPI_FAILURE (Status))
 585         {
 586             return;
 587         }
 588
 589         /* Point to next sub-table */
 590
 591         Offset += SubTable->Header.Length;
 592         SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable,
 593                     SubTable->Header.Length);
 594     }
 595 }
 596
 597
 598 /*******************************************************************************
 599  *
 600  * FUNCTION:    AcpiDmDumpCsrt
 601  *
 602  * PARAMETERS:  Table               - A CSRT table
 603  *
 604  * RETURN:      None
 605  *
 606  * DESCRIPTION: Format the contents of a CSRT. This table type consists
 607  *              of an open-ended number of subtables.
 608  *
 609  ******************************************************************************/
 610
 611 void
 612 AcpiDmDumpCsrt (
 613     ACPI_TABLE_HEADER       *Table)
 614 {
 615     ACPI_STATUS             Status;
 616     ACPI_CSRT_GROUP         *SubTable;
 617     ACPI_CSRT_DESCRIPTOR    *SubSubTable;
 618     UINT32                  Length = Table->Length;
 619     UINT32                  Offset = sizeof (ACPI_TABLE_CSRT);
 620     UINT32                  SubOffset;
 621     UINT32                  SubSubOffset;
 622     UINT32                  InfoLength;
 623
 624
 625     /* The main table only contains the ACPI header, thus already handled */
 626
 627     /* Sub-tables (Resource Groups) */
 628
 629     SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);
 630     while (Offset < Table->Length)
 631     {
 632         AcpiOsPrintf ("\n");
 633         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 634                     SubTable->Length, AcpiDmTableInfoCsrt0);
 635         if (ACPI_FAILURE (Status))
 636         {
 637             return;
 638         }
 639
 640         SubOffset = sizeof (ACPI_CSRT_GROUP);
 641
 642         /* Shared resource group info buffer */
 643
 644         AcpiDmDumpBuffer (SubTable, SubOffset, SubTable->InfoLength,
 645             Offset+SubOffset, "Shared Data");
 646         SubOffset += SubTable->InfoLength;
 647
 648         /* Sub-Sub-tables (Resource Descriptors) */
 649
 650         SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,
 651             Offset + SubOffset);
 652
 653         while ((SubOffset < SubTable->Length) &&
 654               ((Offset + SubOffset) < Table->Length))
 655         {
 656             AcpiOsPrintf ("\n");
 657             Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable,
 658                         SubSubTable->Length, AcpiDmTableInfoCsrt1);
 659             if (ACPI_FAILURE (Status))
 660             {
 661                 return;
 662             }
 663
 664             SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR);
 665
 666             /* Resource-specific info buffer */
 667
 668             InfoLength = SubSubTable->Length - SubSubOffset;
 669
 670             AcpiDmDumpBuffer (SubSubTable, SubSubOffset, InfoLength,
 671                 Offset + SubOffset + SubSubOffset, "ResourceInfo");
 672             SubSubOffset += InfoLength;
 673
 674             /* Point to next sub-sub-table */
 675
 676             SubOffset += SubSubTable->Length;
 677             SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable,
 678                         SubSubTable->Length);
 679         }
 680
 681         /* Point to next sub-table */
 682
 683         Offset += SubTable->Length;
 684         SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable,
 685                     SubTable->Length);
 686     }
 687 }
 688
 689
 690 /*******************************************************************************
 691  *
 692  * FUNCTION:    AcpiDmDumpDbg2
 693  *
 694  * PARAMETERS:  Table               - A DBG2 table
 695  *
 696  * RETURN:      None
 697  *
 698  * DESCRIPTION: Format the contents of a DBG2. This table type consists
 699  *              of an open-ended number of subtables.
 700  *
 701  ******************************************************************************/
 702
 703 void
 704 AcpiDmDumpDbg2 (
 705     ACPI_TABLE_HEADER       *Table)
 706 {
 707     ACPI_STATUS             Status;
 708     ACPI_DBG2_DEVICE        *SubTable;
 709     UINT32                  Length = Table->Length;
 710     UINT32                  Offset = sizeof (ACPI_TABLE_DBG2);
 711     UINT32                  i;
 712     UINT32                  ArrayOffset;
 713     UINT32                  AbsoluteOffset;
 714     UINT8                   *Array;
 715
 716
 717     /* Main table */
 718
 719     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);
 720     if (ACPI_FAILURE (Status))
 721     {
 722         return;
 723     }
 724
 725     /* Sub-tables */
 726
 727     SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);
 728     while (Offset < Table->Length)
 729     {
 730         AcpiOsPrintf ("\n");
 731         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 732                     SubTable->Length, AcpiDmTableInfoDbg2Device);
 733         if (ACPI_FAILURE (Status))
 734         {
 735             return;
 736         }
 737
 738         /* Dump the BaseAddress array */
 739
 740         for (i = 0; i < SubTable->RegisterCount; i++)
 741         {
 742             ArrayOffset = SubTable->BaseAddressOffset +
 743                 (sizeof (ACPI_GENERIC_ADDRESS) * i);
 744             AbsoluteOffset = Offset + ArrayOffset;
 745             Array = (UINT8 *) SubTable + ArrayOffset;
 746
 747             Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
 748                         SubTable->Length, AcpiDmTableInfoDbg2Addr);
 749             if (ACPI_FAILURE (Status))
 750             {
 751                 return;
 752             }
 753         }
 754
 755         /* Dump the AddressSize array */
 756
 757         for (i = 0; i < SubTable->RegisterCount; i++)
 758         {
 759             ArrayOffset = SubTable->AddressSizeOffset +
 760                 (sizeof (UINT32) * i);
 761             AbsoluteOffset = Offset + ArrayOffset;
 762             Array = (UINT8 *) SubTable + ArrayOffset;
 763
 764             Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
 765                         SubTable->Length, AcpiDmTableInfoDbg2Size);
 766             if (ACPI_FAILURE (Status))
 767             {
 768                 return;
 769             }
 770         }
 771
 772         /* Dump the Namestring (required) */
 773
 774         AcpiOsPrintf ("\n");
 775         ArrayOffset = SubTable->NamepathOffset;
 776         AbsoluteOffset = Offset + ArrayOffset;
 777         Array = (UINT8 *) SubTable + ArrayOffset;
 778
 779         Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
 780                     SubTable->Length, AcpiDmTableInfoDbg2Name);
 781         if (ACPI_FAILURE (Status))
 782         {
 783             return;
 784         }
 785
 786         /* Dump the OemData (optional) */
 787
 788         AcpiDmDumpBuffer (SubTable, SubTable->OemDataOffset, SubTable->OemDataLength,
 789             Offset + SubTable->OemDataOffset, "OEM Data");
 790
 791         /* Point to next sub-table */
 792
 793         Offset += SubTable->Length;
 794         SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable,
 795                     SubTable->Length);
 796     }
 797 }
 798
 799
 800 /*******************************************************************************
 801  *
 802  * FUNCTION:    AcpiDmDumpDmar
 803  *
 804  * PARAMETERS:  Table               - A DMAR table
 805  *
 806  * RETURN:      None
 807  *
 808  * DESCRIPTION: Format the contents of a DMAR. This table type consists
 809  *              of an open-ended number of subtables.
 810  *
 811  ******************************************************************************/
 812
 813
 814 void
 815 AcpiDmDumpDmar (
 816     ACPI_TABLE_HEADER       *Table)
 817 {
 818     ACPI_STATUS             Status;
 819     ACPI_DMAR_HEADER        *SubTable;
 820     UINT32                  Length = Table->Length;
 821     UINT32                  Offset = sizeof (ACPI_TABLE_DMAR);
 822     ACPI_DMTABLE_INFO       *InfoTable;
 823     ACPI_DMAR_DEVICE_SCOPE  *ScopeTable;
 824     UINT32                  ScopeOffset;
 825     UINT8                   *PciPath;
 826     UINT32                  PathOffset;
 827
 828
 829     /* Main table */
 830
 831     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
 832     if (ACPI_FAILURE (Status))
 833     {
 834         return;
 835     }
 836
 837     /* Sub-tables */
 838
 839     SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
 840     while (Offset < Table->Length)
 841     {
 842         /* Common sub-table header */
 843
 844         AcpiOsPrintf ("\n");
 845         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 846                     SubTable->Length, AcpiDmTableInfoDmarHdr);
 847         if (ACPI_FAILURE (Status))
 848         {
 849             return;
 850         }
 851
 852         switch (SubTable->Type)
 853         {
 854         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
 855             InfoTable = AcpiDmTableInfoDmar0;
 856             ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
 857             break;
 858         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
 859             InfoTable = AcpiDmTableInfoDmar1;
 860             ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
 861             break;
 862         case ACPI_DMAR_TYPE_ATSR:
 863             InfoTable = AcpiDmTableInfoDmar2;
 864             ScopeOffset = sizeof (ACPI_DMAR_ATSR);
 865             break;
 866         case ACPI_DMAR_HARDWARE_AFFINITY:
 867             InfoTable = AcpiDmTableInfoDmar3;
 868             ScopeOffset = sizeof (ACPI_DMAR_RHSA);
 869             break;
 870         default:
 871             AcpiOsPrintf ("\n**** Unknown DMAR sub-table type 0x%X\n\n", SubTable->Type);
 872             return;
 873         }
 874
 875         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 876                     SubTable->Length, InfoTable);
 877         if (ACPI_FAILURE (Status))
 878         {
 879             return;
 880         }
 881
 882         /* Dump the device scope entries (if any) */
 883
 884         ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
 885         while (ScopeOffset < SubTable->Length)
 886         {
 887             AcpiOsPrintf ("\n");
 888             Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
 889                         ScopeTable->Length, AcpiDmTableInfoDmarScope);
 890             if (ACPI_FAILURE (Status))
 891             {
 892                 return;
 893             }
 894
 895             /* Dump the PCI Path entries for this device scope */
 896
 897             PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
 898
 899             PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
 900                 sizeof (ACPI_DMAR_DEVICE_SCOPE));
 901
 902             while (PathOffset < ScopeTable->Length)
 903             {
 904                 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path");
 905                 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
 906
 907                 /* Point to next PCI Path entry */
 908
 909                 PathOffset += 2;
 910                 PciPath += 2;
 911             }
 912
 913             /* Point to next device scope entry */
 914
 915             ScopeOffset += ScopeTable->Length;
 916             ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
 917                 ScopeTable, ScopeTable->Length);
 918         }
 919
 920         /* Point to next sub-table */
 921
 922         Offset += SubTable->Length;
 923         SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length);
 924     }
 925 }
 926
 927
 928 /*******************************************************************************
 929  *
 930  * FUNCTION:    AcpiDmDumpEinj
 931  *
 932  * PARAMETERS:  Table               - A EINJ table
 933  *
 934  * RETURN:      None
 935  *
 936  * DESCRIPTION: Format the contents of a EINJ. This table type consists
 937  *              of an open-ended number of subtables.
 938  *
 939  ******************************************************************************/
 940
 941 void
 942 AcpiDmDumpEinj (
 943     ACPI_TABLE_HEADER       *Table)
 944 {
 945     ACPI_STATUS             Status;
 946     ACPI_WHEA_HEADER        *SubTable;
 947     UINT32                  Length = Table->Length;
 948     UINT32                  Offset = sizeof (ACPI_TABLE_EINJ);
 949
 950
 951     /* Main table */
 952
 953     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
 954     if (ACPI_FAILURE (Status))
 955     {
 956         return;
 957     }
 958
 959     /* Sub-tables */
 960
 961     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
 962     while (Offset < Table->Length)
 963     {
 964         AcpiOsPrintf ("\n");
 965         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 966                     sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
 967         if (ACPI_FAILURE (Status))
 968         {
 969             return;
 970         }
 971
 972         /* Point to next sub-table (each subtable is of fixed length) */
 973
 974         Offset += sizeof (ACPI_WHEA_HEADER);
 975         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
 976                         sizeof (ACPI_WHEA_HEADER));
 977     }
 978 }
 979
 980
 981 /*******************************************************************************
 982  *
 983  * FUNCTION:    AcpiDmDumpErst
 984  *
 985  * PARAMETERS:  Table               - A ERST table
 986  *
 987  * RETURN:      None
 988  *
 989  * DESCRIPTION: Format the contents of a ERST. This table type consists
 990  *              of an open-ended number of subtables.
 991  *
 992  ******************************************************************************/
 993
 994 void
 995 AcpiDmDumpErst (
 996     ACPI_TABLE_HEADER       *Table)
 997 {
 998     ACPI_STATUS             Status;
 999     ACPI_WHEA_HEADER        *SubTable;
1000     UINT32                  Length = Table->Length;
1001     UINT32                  Offset = sizeof (ACPI_TABLE_ERST);
1002
1003
1004     /* Main table */
1005
1006     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
1007     if (ACPI_FAILURE (Status))
1008     {
1009         return;
1010     }
1011
1012     /* Sub-tables */
1013
1014     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1015     while (Offset < Table->Length)
1016     {
1017         AcpiOsPrintf ("\n");
1018         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1019                     sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
1020         if (ACPI_FAILURE (Status))
1021         {
1022             return;
1023         }
1024
1025         /* Point to next sub-table (each subtable is of fixed length) */
1026
1027         Offset += sizeof (ACPI_WHEA_HEADER);
1028         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
1029                         sizeof (ACPI_WHEA_HEADER));
1030     }
1031 }
1032
1033
1034 /*******************************************************************************
1035  *
1036  * FUNCTION:    AcpiDmDumpFpdt
1037  *
1038  * PARAMETERS:  Table               - A FPDT table
1039  *
1040  * RETURN:      None
1041  *
1042  * DESCRIPTION: Format the contents of a FPDT. This table type consists
1043  *              of an open-ended number of subtables.
1044  *
1045  ******************************************************************************/
1046
1047 void
1048 AcpiDmDumpFpdt (
1049     ACPI_TABLE_HEADER       *Table)
1050 {
1051     ACPI_STATUS             Status;
1052     ACPI_FPDT_HEADER        *SubTable;
1053     UINT32                  Length = Table->Length;
1054     UINT32                  Offset = sizeof (ACPI_TABLE_FPDT);
1055     ACPI_DMTABLE_INFO       *InfoTable;
1056
1057
1058     /* There is no main table (other than the standard ACPI header) */
1059
1060     /* Sub-tables */
1061
1062     SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset);
1063     while (Offset < Table->Length)
1064     {
1065         /* Common sub-table header */
1066
1067         AcpiOsPrintf ("\n");
1068         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1069                     SubTable->Length, AcpiDmTableInfoFpdtHdr);
1070         if (ACPI_FAILURE (Status))
1071         {
1072             return;
1073         }
1074
1075         switch (SubTable->Type)
1076         {
1077         case ACPI_FPDT_TYPE_BOOT:
1078             InfoTable = AcpiDmTableInfoFpdt0;
1079             break;
1080         case ACPI_FPDT_TYPE_S3PERF:
1081             InfoTable = AcpiDmTableInfoFpdt1;
1082             break;
1083         default:
1084             AcpiOsPrintf ("\n**** Unknown FPDT sub-table type 0x%X\n\n", SubTable->Type);
1085
1086             /* Attempt to continue */
1087
1088             if (!SubTable->Length)
1089             {
1090                 AcpiOsPrintf ("Invalid zero length subtable\n");
1091                 return;
1092             }
1093             goto NextSubTable;
1094         }
1095
1096         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1097                     SubTable->Length, InfoTable);
1098         if (ACPI_FAILURE (Status))
1099         {
1100             return;
1101         }
1102
1103 NextSubTable:
1104         /* Point to next sub-table */
1105
1106         Offset += SubTable->Length;
1107         SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length);
1108     }
1109 }
1110
1111
1112 /*******************************************************************************
1113  *
1114  * FUNCTION:    AcpiDmDumpHest
1115  *
1116  * PARAMETERS:  Table               - A HEST table
1117  *
1118  * RETURN:      None
1119  *
1120  * DESCRIPTION: Format the contents of a HEST. This table type consists
1121  *              of an open-ended number of subtables.
1122  *
1123  ******************************************************************************/
1124
1125 void
1126 AcpiDmDumpHest (
1127     ACPI_TABLE_HEADER       *Table)
1128 {
1129     ACPI_STATUS             Status;
1130     ACPI_HEST_HEADER        *SubTable;
1131     UINT32                  Length = Table->Length;
1132     UINT32                  Offset = sizeof (ACPI_TABLE_HEST);
1133     ACPI_DMTABLE_INFO       *InfoTable;
1134     UINT32                  SubTableLength;
1135     UINT32                  BankCount;
1136     ACPI_HEST_IA_ERROR_BANK *BankTable;
1137
1138
1139     /* Main table */
1140
1141     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
1142     if (ACPI_FAILURE (Status))
1143     {
1144         return;
1145     }
1146
1147     /* Sub-tables */
1148
1149     SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
1150     while (Offset < Table->Length)
1151     {
1152         BankCount = 0;
1153         switch (SubTable->Type)
1154         {
1155         case ACPI_HEST_TYPE_IA32_CHECK:
1156             InfoTable = AcpiDmTableInfoHest0;
1157             SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
1158             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
1159                             SubTable))->NumHardwareBanks;
1160             break;
1161
1162         case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1163             InfoTable = AcpiDmTableInfoHest1;
1164             SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED);
1165             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
1166                             SubTable))->NumHardwareBanks;
1167             break;
1168
1169         case ACPI_HEST_TYPE_IA32_NMI:
1170             InfoTable = AcpiDmTableInfoHest2;
1171             SubTableLength = sizeof (ACPI_HEST_IA_NMI);
1172             break;
1173
1174         case ACPI_HEST_TYPE_AER_ROOT_PORT:
1175             InfoTable = AcpiDmTableInfoHest6;
1176             SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
1177             break;
1178
1179         case ACPI_HEST_TYPE_AER_ENDPOINT:
1180             InfoTable = AcpiDmTableInfoHest7;
1181             SubTableLength = sizeof (ACPI_HEST_AER);
1182             break;
1183
1184         case ACPI_HEST_TYPE_AER_BRIDGE:
1185             InfoTable = AcpiDmTableInfoHest8;
1186             SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
1187             break;
1188
1189         case ACPI_HEST_TYPE_GENERIC_ERROR:
1190             InfoTable = AcpiDmTableInfoHest9;
1191             SubTableLength = sizeof (ACPI_HEST_GENERIC);
1192             break;
1193
1194         default:
1195             /* Cannot continue on unknown type - no length */
1196
1197             AcpiOsPrintf ("\n**** Unknown HEST sub-table type 0x%X\n", SubTable->Type);
1198             return;
1199         }
1200
1201         AcpiOsPrintf ("\n");
1202         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1203                     SubTableLength, InfoTable);
1204         if (ACPI_FAILURE (Status))
1205         {
1206             return;
1207         }
1208
1209         /* Point to end of current subtable (each subtable above is of fixed length) */
1210
1211         Offset += SubTableLength;
1212
1213         /* If there are any (fixed-length) Error Banks from above, dump them now */
1214
1215         if (BankCount)
1216         {
1217             BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength);
1218             SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
1219
1220             while (BankCount)
1221             {
1222                 AcpiOsPrintf ("\n");
1223                 Status = AcpiDmDumpTable (Length, Offset, BankTable,
1224                             sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
1225                 if (ACPI_FAILURE (Status))
1226                 {
1227                     return;
1228                 }
1229                 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
1230                 BankTable++;
1231                 BankCount--;
1232             }
1233         }
1234
1235         /* Point to next sub-table */
1236
1237         SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
1238     }
1239 }
1240
1241
1242 /*******************************************************************************
1243  *
1244  * FUNCTION:    AcpiDmDumpIvrs
1245  *
1246  * PARAMETERS:  Table               - A IVRS table
1247  *
1248  * RETURN:      None
1249  *
1250  * DESCRIPTION: Format the contents of a IVRS
1251  *
1252  ******************************************************************************/
1253
1254 static UINT8 EntrySizes[] = {4,8,16,32};
1255
1256 void
1257 AcpiDmDumpIvrs (
1258     ACPI_TABLE_HEADER       *Table)
1259 {
1260     ACPI_STATUS             Status;
1261     UINT32                  Offset = sizeof (ACPI_TABLE_IVRS);
1262     UINT32                  EntryOffset;
1263     UINT32                  EntryLength;
1264     UINT32                  EntryType;
1265     ACPI_IVRS_DE_HEADER     *DeviceEntry;
1266     ACPI_IVRS_HEADER        *SubTable;
1267     ACPI_DMTABLE_INFO       *InfoTable;
1268
1269
1270     /* Main table */
1271
1272     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
1273     if (ACPI_FAILURE (Status))
1274     {
1275         return;
1276     }
1277
1278     /* Sub-tables */
1279
1280     SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
1281     while (Offset < Table->Length)
1282     {
1283         /* Common sub-table header */
1284
1285         AcpiOsPrintf ("\n");
1286         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1287                     SubTable->Length, AcpiDmTableInfoIvrsHdr);
1288         if (ACPI_FAILURE (Status))
1289         {
1290             return;
1291         }
1292
1293         switch (SubTable->Type)
1294         {
1295         case ACPI_IVRS_TYPE_HARDWARE:
1296             InfoTable = AcpiDmTableInfoIvrs0;
1297             break;
1298         case ACPI_IVRS_TYPE_MEMORY1:
1299         case ACPI_IVRS_TYPE_MEMORY2:
1300         case ACPI_IVRS_TYPE_MEMORY3:
1301             InfoTable = AcpiDmTableInfoIvrs1;
1302             break;
1303         default:
1304             AcpiOsPrintf ("\n**** Unknown IVRS sub-table type 0x%X\n",
1305                 SubTable->Type);
1306
1307             /* Attempt to continue */
1308
1309             if (!SubTable->Length)
1310             {
1311                 AcpiOsPrintf ("Invalid zero length subtable\n");
1312                 return;
1313             }
1314             goto NextSubTable;
1315         }
1316
1317         /* Dump the subtable */
1318
1319         AcpiOsPrintf ("\n");
1320         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1321                     SubTable->Length, InfoTable);
1322         if (ACPI_FAILURE (Status))
1323         {
1324             return;
1325         }
1326
1327         /* The hardware subtable can contain multiple device entries */
1328
1329         if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
1330         {
1331             EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
1332             DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
1333                             sizeof (ACPI_IVRS_HARDWARE));
1334
1335             while (EntryOffset < (Offset + SubTable->Length))
1336             {
1337                 AcpiOsPrintf ("\n");
1338                 /*
1339                  * Upper 2 bits of Type encode the length of the device entry
1340                  *
1341                  * 00 = 4 byte
1342                  * 01 = 8 byte
1343                  * 10 = 16 byte - currently no entries defined
1344                  * 11 = 32 byte - currently no entries defined
1345                  */
1346                 EntryType = DeviceEntry->Type;
1347                 EntryLength = EntrySizes [EntryType >> 6];
1348
1349                 switch (EntryType)
1350                 {
1351                 /* 4-byte device entries */
1352
1353                 case ACPI_IVRS_TYPE_PAD4:
1354                 case ACPI_IVRS_TYPE_ALL:
1355                 case ACPI_IVRS_TYPE_SELECT:
1356                 case ACPI_IVRS_TYPE_START:
1357                 case ACPI_IVRS_TYPE_END:
1358
1359                     InfoTable = AcpiDmTableInfoIvrs4;
1360                     break;
1361
1362                 /* 8-byte entries, type A */
1363
1364                 case ACPI_IVRS_TYPE_ALIAS_SELECT:
1365                 case ACPI_IVRS_TYPE_ALIAS_START:
1366
1367                     InfoTable = AcpiDmTableInfoIvrs8a;
1368                     break;
1369
1370                 /* 8-byte entries, type B */
1371
1372                 case ACPI_IVRS_TYPE_PAD8:
1373                 case ACPI_IVRS_TYPE_EXT_SELECT:
1374                 case ACPI_IVRS_TYPE_EXT_START:
1375
1376                     InfoTable = AcpiDmTableInfoIvrs8b;
1377                     break;
1378
1379                 /* 8-byte entries, type C */
1380
1381                 case ACPI_IVRS_TYPE_SPECIAL:
1382
1383                     InfoTable = AcpiDmTableInfoIvrs8c;
1384                     break;
1385
1386                 default:
1387                     InfoTable = AcpiDmTableInfoIvrs4;
1388                     AcpiOsPrintf (
1389                         "\n**** Unknown IVRS device entry type/length: "
1390                         "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
1391                         EntryType, EntryLength, EntryOffset);
1392                     break;
1393                 }
1394
1395                 /* Dump the Device Entry */
1396
1397                 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
1398                             DeviceEntry, EntryLength, InfoTable);
1399
1400                 EntryOffset += EntryLength;
1401                 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
1402                                 EntryLength);
1403             }
1404         }
1405
1406 NextSubTable:
1407         /* Point to next sub-table */
1408
1409         Offset += SubTable->Length;
1410         SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
1411     }
1412 }
1413
1414
1415 /*******************************************************************************
1416  *
1417  * FUNCTION:    AcpiDmDumpMadt
1418  *
1419  * PARAMETERS:  Table               - A MADT table
1420  *
1421  * RETURN:      None
1422  *
1423  * DESCRIPTION: Format the contents of a MADT. This table type consists
1424  *              of an open-ended number of subtables.
1425  *
1426  ******************************************************************************/
1427
1428 void
1429 AcpiDmDumpMadt (
1430     ACPI_TABLE_HEADER       *Table)
1431 {
1432     ACPI_STATUS             Status;
1433     ACPI_SUBTABLE_HEADER    *SubTable;
1434     UINT32                  Length = Table->Length;
1435     UINT32                  Offset = sizeof (ACPI_TABLE_MADT);
1436     ACPI_DMTABLE_INFO       *InfoTable;
1437
1438
1439     /* Main table */
1440
1441     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
1442     if (ACPI_FAILURE (Status))
1443     {
1444         return;
1445     }
1446
1447     /* Sub-tables */
1448
1449     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1450     while (Offset < Table->Length)
1451     {
1452         /* Common sub-table header */
1453
1454         AcpiOsPrintf ("\n");
1455         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1456                     SubTable->Length, AcpiDmTableInfoMadtHdr);
1457         if (ACPI_FAILURE (Status))
1458         {
1459             return;
1460         }
1461
1462         switch (SubTable->Type)
1463         {
1464         case ACPI_MADT_TYPE_LOCAL_APIC:
1465             InfoTable = AcpiDmTableInfoMadt0;
1466             break;
1467         case ACPI_MADT_TYPE_IO_APIC:
1468             InfoTable = AcpiDmTableInfoMadt1;
1469             break;
1470         case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
1471             InfoTable = AcpiDmTableInfoMadt2;
1472             break;
1473         case ACPI_MADT_TYPE_NMI_SOURCE:
1474             InfoTable = AcpiDmTableInfoMadt3;
1475             break;
1476         case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
1477             InfoTable = AcpiDmTableInfoMadt4;
1478             break;
1479         case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
1480             InfoTable = AcpiDmTableInfoMadt5;
1481             break;
1482         case ACPI_MADT_TYPE_IO_SAPIC:
1483             InfoTable = AcpiDmTableInfoMadt6;
1484             break;
1485         case ACPI_MADT_TYPE_LOCAL_SAPIC:
1486             InfoTable = AcpiDmTableInfoMadt7;
1487             break;
1488         case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
1489             InfoTable = AcpiDmTableInfoMadt8;
1490             break;
1491         case ACPI_MADT_TYPE_LOCAL_X2APIC:
1492             InfoTable = AcpiDmTableInfoMadt9;
1493             break;
1494         case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
1495             InfoTable = AcpiDmTableInfoMadt10;
1496             break;
1497         case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
1498             InfoTable = AcpiDmTableInfoMadt11;
1499             break;
1500         case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
1501             InfoTable = AcpiDmTableInfoMadt12;
1502             break;
1503         default:
1504             AcpiOsPrintf ("\n**** Unknown MADT sub-table type 0x%X\n\n", SubTable->Type);
1505
1506             /* Attempt to continue */
1507
1508             if (!SubTable->Length)
1509             {
1510                 AcpiOsPrintf ("Invalid zero length subtable\n");
1511                 return;
1512             }
1513             goto NextSubTable;
1514         }
1515
1516         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1517                     SubTable->Length, InfoTable);
1518         if (ACPI_FAILURE (Status))
1519         {
1520             return;
1521         }
1522
1523 NextSubTable:
1524         /* Point to next sub-table */
1525
1526         Offset += SubTable->Length;
1527         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1528     }
1529 }
1530
1531
1532 /*******************************************************************************
1533  *
1534  * FUNCTION:    AcpiDmDumpMcfg
1535  *
1536  * PARAMETERS:  Table               - A MCFG Table
1537  *
1538  * RETURN:      None
1539  *
1540  * DESCRIPTION: Format the contents of a MCFG table
1541  *
1542  ******************************************************************************/
1543
1544 void
1545 AcpiDmDumpMcfg (
1546     ACPI_TABLE_HEADER       *Table)
1547 {
1548     ACPI_STATUS             Status;
1549     UINT32                  Offset = sizeof (ACPI_TABLE_MCFG);
1550     ACPI_MCFG_ALLOCATION    *SubTable;
1551
1552
1553     /* Main table */
1554
1555     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
1556     if (ACPI_FAILURE (Status))
1557     {
1558         return;
1559     }
1560
1561     /* Sub-tables */
1562
1563     SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
1564     while (Offset < Table->Length)
1565     {
1566         if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
1567         {
1568             AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
1569                 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
1570             return;
1571         }
1572
1573         AcpiOsPrintf ("\n");
1574         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1575                     sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
1576         if (ACPI_FAILURE (Status))
1577         {
1578             return;
1579         }
1580
1581         /* Point to next sub-table (each subtable is of fixed length) */
1582
1583         Offset += sizeof (ACPI_MCFG_ALLOCATION);
1584         SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
1585                         sizeof (ACPI_MCFG_ALLOCATION));
1586     }
1587 }
1588
1589
1590 /*******************************************************************************
1591  *
1592  * FUNCTION:    AcpiDmDumpMpst
1593  *
1594  * PARAMETERS:  Table               - A MPST Table
1595  *
1596  * RETURN:      None
1597  *
1598  * DESCRIPTION: Format the contents of a MPST table
1599  *
1600  ******************************************************************************/
1601
1602 void
1603 AcpiDmDumpMpst (
1604     ACPI_TABLE_HEADER       *Table)
1605 {
1606     ACPI_STATUS             Status;
1607     UINT32                  Offset = sizeof (ACPI_TABLE_MPST);
1608     ACPI_MPST_POWER_NODE    *SubTable0;
1609     ACPI_MPST_POWER_STATE   *SubTable0A;
1610     ACPI_MPST_COMPONENT     *SubTable0B;
1611     ACPI_MPST_DATA_HDR      *SubTable1;
1612     ACPI_MPST_POWER_DATA    *SubTable2;
1613     UINT16                  SubtableCount;
1614     UINT8                   PowerStateCount;
1615     UINT8                   ComponentCount;
1616
1617
1618     /* Main table */
1619
1620     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
1621     if (ACPI_FAILURE (Status))
1622     {
1623         return;
1624     }
1625
1626     /* Subtable: Memory Power Node(s) */
1627
1628     SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
1629     SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
1630
1631     while ((Offset < Table->Length) && SubtableCount)
1632     {
1633         AcpiOsPrintf ("\n");
1634         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0,
1635                     sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
1636         if (ACPI_FAILURE (Status))
1637         {
1638             return;
1639         }
1640
1641         /* Extract the sub-subtable counts */
1642
1643         PowerStateCount = SubTable0->NumPowerStates;
1644         ComponentCount = SubTable0->NumPhysicalComponents;
1645         Offset += sizeof (ACPI_MPST_POWER_NODE);
1646
1647         /* Sub-subtables - Memory Power State Structure(s) */
1648
1649         SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0,
1650             sizeof (ACPI_MPST_POWER_NODE));
1651
1652         while (PowerStateCount)
1653         {
1654             AcpiOsPrintf ("\n");
1655             Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A,
1656                         sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
1657             if (ACPI_FAILURE (Status))
1658             {
1659                 return;
1660             }
1661
1662             SubTable0A++;
1663             PowerStateCount--;
1664             Offset += sizeof (ACPI_MPST_POWER_STATE);
1665        }
1666
1667         /* Sub-subtables - Physical Component ID Structure(s) */
1668
1669         SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A);
1670
1671         if (ComponentCount)
1672         {
1673             AcpiOsPrintf ("\n");
1674         }
1675
1676         while (ComponentCount)
1677         {
1678             Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B,
1679                         sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
1680             if (ACPI_FAILURE (Status))
1681             {
1682                 return;
1683             }
1684
1685             SubTable0B++;
1686             ComponentCount--;
1687             Offset += sizeof (ACPI_MPST_COMPONENT);
1688         }
1689
1690         /* Point to next Memory Power Node subtable */
1691
1692         SubtableCount--;
1693         SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0,
1694             sizeof (ACPI_MPST_POWER_NODE) +
1695             (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) +
1696             (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents));
1697     }
1698
1699     /* Subtable: Count of Memory Power State Characteristic structures */
1700
1701     AcpiOsPrintf ("\n");
1702     SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0);
1703     Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1,
1704                 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
1705     if (ACPI_FAILURE (Status))
1706     {
1707         return;
1708     }
1709
1710     SubtableCount = SubTable1->CharacteristicsCount;
1711     Offset += sizeof (ACPI_MPST_DATA_HDR);
1712
1713     /* Subtable: Memory Power State Characteristics structure(s) */
1714
1715     SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, sizeof (ACPI_MPST_DATA_HDR));
1716
1717     while ((Offset < Table->Length) && SubtableCount)
1718     {
1719         AcpiOsPrintf ("\n");
1720         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2,
1721                     sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
1722         if (ACPI_FAILURE (Status))
1723         {
1724             return;
1725         }
1726
1727         SubTable2++;
1728         SubtableCount--;
1729         Offset += sizeof (ACPI_MPST_POWER_DATA);
1730     }
1731 }
1732
1733
1734 /*******************************************************************************
1735  *
1736  * FUNCTION:    AcpiDmDumpMsct
1737  *
1738  * PARAMETERS:  Table               - A MSCT table
1739  *
1740  * RETURN:      None
1741  *
1742  * DESCRIPTION: Format the contents of a MSCT
1743  *
1744  ******************************************************************************/
1745
1746 void
1747 AcpiDmDumpMsct (
1748     ACPI_TABLE_HEADER       *Table)
1749 {
1750     ACPI_STATUS             Status;
1751     UINT32                  Offset = sizeof (ACPI_TABLE_MSCT);
1752     ACPI_MSCT_PROXIMITY     *SubTable;
1753
1754
1755     /* Main table */
1756
1757     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1758     if (ACPI_FAILURE (Status))
1759     {
1760         return;
1761     }
1762
1763     /* Sub-tables */
1764
1765     SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1766     while (Offset < Table->Length)
1767     {
1768         /* Common sub-table header */
1769
1770         AcpiOsPrintf ("\n");
1771         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1772                     sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1773         if (ACPI_FAILURE (Status))
1774         {
1775             return;
1776         }
1777
1778         /* Point to next sub-table */
1779
1780         Offset += sizeof (ACPI_MSCT_PROXIMITY);
1781         SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY));
1782     }
1783 }
1784
1785
1786 /*******************************************************************************
1787  *
1788  * FUNCTION:    AcpiDmDumpPcct
1789  *
1790  * PARAMETERS:  Table               - A PCCT table
1791  *
1792  * RETURN:      None
1793  *
1794  * DESCRIPTION: Format the contents of a PCCT. This table type consists
1795  *              of an open-ended number of subtables.
1796  *
1797  ******************************************************************************/
1798
1799 void
1800 AcpiDmDumpPcct (
1801     ACPI_TABLE_HEADER       *Table)
1802 {
1803     ACPI_STATUS             Status;
1804     ACPI_PCCT_SUBSPACE      *SubTable;
1805     UINT32                  Length = Table->Length;
1806     UINT32                  Offset = sizeof (ACPI_TABLE_PCCT);
1807
1808
1809     /* Main table */
1810
1811     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
1812     if (ACPI_FAILURE (Status))
1813     {
1814         return;
1815     }
1816
1817     /* Sub-tables */
1818
1819     SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
1820     while (Offset < Table->Length)
1821     {
1822         AcpiOsPrintf ("\n");
1823         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1824                     SubTable->Header.Length, AcpiDmTableInfoPcct0);
1825         if (ACPI_FAILURE (Status))
1826         {
1827             return;
1828         }
1829
1830         /* Point to next sub-table */
1831
1832         Offset += SubTable->Header.Length;
1833         SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable,
1834                     SubTable->Header.Length);
1835     }
1836 }
1837
1838
1839 /*******************************************************************************
1840  *
1841  * FUNCTION:    AcpiDmDumpPmtt
1842  *
1843  * PARAMETERS:  Table               - A PMTT table
1844  *
1845  * RETURN:      None
1846  *
1847  * DESCRIPTION: Format the contents of a PMTT. This table type consists
1848  *              of an open-ended number of subtables.
1849  *
1850  ******************************************************************************/
1851
1852 void
1853 AcpiDmDumpPmtt (
1854     ACPI_TABLE_HEADER       *Table)
1855 {
1856     ACPI_STATUS             Status;
1857     ACPI_PMTT_HEADER        *SubTable;
1858     ACPI_PMTT_HEADER        *MemSubTable;
1859     ACPI_PMTT_HEADER        *DimmSubTable;
1860     ACPI_PMTT_DOMAIN        *DomainArray;
1861     UINT32                  Length = Table->Length;
1862     UINT32                  Offset = sizeof (ACPI_TABLE_PMTT);
1863     UINT32                  MemOffset;
1864     UINT32                  DimmOffset;
1865     UINT32                  DomainOffset;
1866     UINT32                  DomainCount;
1867
1868
1869     /* Main table */
1870
1871     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
1872     if (ACPI_FAILURE (Status))
1873     {
1874         return;
1875     }
1876
1877     /* Subtables */
1878
1879     SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
1880     while (Offset < Table->Length)
1881     {
1882         /* Common subtable header */
1883
1884         AcpiOsPrintf ("\n");
1885         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1886                     SubTable->Length, AcpiDmTableInfoPmttHdr);
1887         if (ACPI_FAILURE (Status))
1888         {
1889             return;
1890         }
1891
1892         /* Only Socket subtables are expected at this level */
1893
1894         if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET)
1895         {
1896             AcpiOsPrintf (
1897                 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
1898                 SubTable->Type);
1899             return;
1900         }
1901
1902         /* Dump the fixed-length portion of the subtable */
1903
1904         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1905                     SubTable->Length, AcpiDmTableInfoPmtt0);
1906         if (ACPI_FAILURE (Status))
1907         {
1908             return;
1909         }
1910
1911         /* Walk the memory controller subtables */
1912
1913         MemOffset = sizeof (ACPI_PMTT_SOCKET);
1914         MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable,
1915             sizeof (ACPI_PMTT_SOCKET));
1916
1917         while (((Offset + MemOffset) < Table->Length) &&
1918             (MemOffset < SubTable->Length))
1919         {
1920             /* Common subtable header */
1921
1922             AcpiOsPrintf ("\n");
1923             Status = AcpiDmDumpTable (Length,
1924                         Offset + MemOffset, MemSubTable,
1925                         MemSubTable->Length, AcpiDmTableInfoPmttHdr);
1926             if (ACPI_FAILURE (Status))
1927             {
1928                 return;
1929             }
1930
1931             /* Only memory controller subtables are expected at this level */
1932
1933             if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER)
1934             {
1935                 AcpiOsPrintf (
1936                     "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
1937                     MemSubTable->Type);
1938                 return;
1939             }
1940
1941             /* Dump the fixed-length portion of the controller subtable */
1942
1943             Status = AcpiDmDumpTable (Length,
1944                         Offset + MemOffset, MemSubTable,
1945                         MemSubTable->Length, AcpiDmTableInfoPmtt1);
1946             if (ACPI_FAILURE (Status))
1947             {
1948                 return;
1949             }
1950
1951             /* Walk the variable count of proximity domains */
1952
1953             DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount;
1954             DomainOffset = sizeof (ACPI_PMTT_CONTROLLER);
1955             DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable,
1956                 sizeof (ACPI_PMTT_CONTROLLER));
1957
1958             while (((Offset + MemOffset + DomainOffset) < Table->Length) &&
1959                 ((MemOffset + DomainOffset) < SubTable->Length) &&
1960                 DomainCount)
1961             {
1962                 Status = AcpiDmDumpTable (Length,
1963                             Offset + MemOffset + DomainOffset, DomainArray,
1964                             sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
1965                 if (ACPI_FAILURE (Status))
1966                 {
1967                     return;
1968                 }
1969
1970                 DomainOffset += sizeof (ACPI_PMTT_DOMAIN);
1971                 DomainArray++;
1972                 DomainCount--;
1973             }
1974
1975             if (DomainCount)
1976             {
1977                 AcpiOsPrintf (
1978                     "\n**** DomainCount exceeds subtable length\n\n",
1979                     MemSubTable->Type);
1980             }
1981
1982             /* Walk the physical component (DIMM) subtables */
1983
1984             DimmOffset = DomainOffset;
1985             DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable,
1986                 DomainOffset);
1987
1988             while (((Offset + MemOffset + DimmOffset) < Table->Length) &&
1989                 (DimmOffset < MemSubTable->Length))
1990             {
1991                 /* Common subtable header */
1992
1993                 AcpiOsPrintf ("\n");
1994                 Status = AcpiDmDumpTable (Length,
1995                             Offset + MemOffset + DimmOffset, DimmSubTable,
1996                             DimmSubTable->Length, AcpiDmTableInfoPmttHdr);
1997                 if (ACPI_FAILURE (Status))
1998                 {
1999                     return;
2000                 }
2001
2002                 /* Only DIMM subtables are expected at this level */
2003
2004                 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM)
2005                 {
2006                     AcpiOsPrintf (
2007                         "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
2008                         DimmSubTable->Type);
2009                     return;
2010                 }
2011
2012                 /* Dump the fixed-length DIMM subtable */
2013
2014                 Status = AcpiDmDumpTable (Length,
2015                             Offset + MemOffset + DimmOffset, DimmSubTable,
2016                             DimmSubTable->Length, AcpiDmTableInfoPmtt2);
2017                 if (ACPI_FAILURE (Status))
2018                 {
2019                     return;
2020                 }
2021
2022                 /* Point to next DIMM subtable */
2023
2024                 DimmOffset += DimmSubTable->Length;
2025                 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2026                     DimmSubTable, DimmSubTable->Length);
2027             }
2028
2029             /* Point to next Controller subtable */
2030
2031             MemOffset += MemSubTable->Length;
2032             MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2033                 MemSubTable, MemSubTable->Length);
2034         }
2035
2036         /* Point to next Socket subtable */
2037
2038         Offset += SubTable->Length;
2039         SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2040             SubTable, SubTable->Length);
2041     }
2042 }
2043
2044
2045 /*******************************************************************************
2046  *
2047  * FUNCTION:    AcpiDmDumpS3pt
2048  *
2049  * PARAMETERS:  Table               - A S3PT table
2050  *
2051  * RETURN:      Length of the table
2052  *
2053  * DESCRIPTION: Format the contents of a S3PT
2054  *
2055  ******************************************************************************/
2056
2057 UINT32
2058 AcpiDmDumpS3pt (
2059     ACPI_TABLE_HEADER       *Tables)
2060 {
2061     ACPI_STATUS             Status;
2062     UINT32                  Offset = sizeof (ACPI_TABLE_S3PT);
2063     ACPI_S3PT_HEADER        *SubTable;
2064     ACPI_DMTABLE_INFO       *InfoTable;
2065     ACPI_TABLE_S3PT         *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
2066
2067
2068     /* Main table */
2069
2070     Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
2071     if (ACPI_FAILURE (Status))
2072     {
2073         return 0;
2074     }
2075
2076     SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, S3ptTable, Offset);
2077     while (Offset < S3ptTable->Length)
2078     {
2079         /* Common sub-table header */
2080
2081         AcpiOsPrintf ("\n");
2082         Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
2083                     SubTable->Length, AcpiDmTableInfoS3ptHdr);
2084         if (ACPI_FAILURE (Status))
2085         {
2086             return 0;
2087         }
2088
2089         switch (SubTable->Type)
2090         {
2091         case ACPI_S3PT_TYPE_RESUME:
2092             InfoTable = AcpiDmTableInfoS3pt0;
2093             break;
2094         case ACPI_S3PT_TYPE_SUSPEND:
2095             InfoTable = AcpiDmTableInfoS3pt1;
2096             break;
2097         default:
2098             AcpiOsPrintf ("\n**** Unknown S3PT sub-table type 0x%X\n", SubTable->Type);
2099
2100             /* Attempt to continue */
2101
2102             if (!SubTable->Length)
2103             {
2104                 AcpiOsPrintf ("Invalid zero length subtable\n");
2105                 return 0;
2106             }
2107             goto NextSubTable;
2108         }
2109
2110         AcpiOsPrintf ("\n");
2111         Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
2112                     SubTable->Length, InfoTable);
2113         if (ACPI_FAILURE (Status))
2114         {
2115             return 0;
2116         }
2117
2118 NextSubTable:
2119         /* Point to next sub-table */
2120
2121         Offset += SubTable->Length;
2122         SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, SubTable, SubTable->Length);
2123     }
2124
2125     return (S3ptTable->Length);
2126 }
2127
2128
2129 /*******************************************************************************
2130  *
2131  * FUNCTION:    AcpiDmDumpSlic
2132  *
2133  * PARAMETERS:  Table               - A SLIC table
2134  *
2135  * RETURN:      None
2136  *
2137  * DESCRIPTION: Format the contents of a SLIC
2138  *
2139  ******************************************************************************/
2140
2141 void
2142 AcpiDmDumpSlic (
2143     ACPI_TABLE_HEADER       *Table)
2144 {
2145     ACPI_STATUS             Status;
2146     UINT32                  Offset = sizeof (ACPI_TABLE_SLIC);
2147     ACPI_SLIC_HEADER        *SubTable;
2148     ACPI_DMTABLE_INFO       *InfoTable;
2149
2150
2151     /* There is no main SLIC table, only subtables */
2152
2153     SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, Table, Offset);
2154     while (Offset < Table->Length)
2155     {
2156         /* Common sub-table header */
2157
2158         AcpiOsPrintf ("\n");
2159         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2160                     SubTable->Length, AcpiDmTableInfoSlicHdr);
2161         if (ACPI_FAILURE (Status))
2162         {
2163             return;
2164         }
2165
2166         switch (SubTable->Type)
2167         {
2168         case ACPI_SLIC_TYPE_PUBLIC_KEY:
2169             InfoTable = AcpiDmTableInfoSlic0;
2170             break;
2171         case ACPI_SLIC_TYPE_WINDOWS_MARKER:
2172             InfoTable = AcpiDmTableInfoSlic1;
2173             break;
2174         default:
2175             AcpiOsPrintf ("\n**** Unknown SLIC sub-table type 0x%X\n", SubTable->Type);
2176
2177             /* Attempt to continue */
2178
2179             if (!SubTable->Length)
2180             {
2181                 AcpiOsPrintf ("Invalid zero length subtable\n");
2182                 return;
2183             }
2184             goto NextSubTable;
2185         }
2186
2187         AcpiOsPrintf ("\n");
2188         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2189                     SubTable->Length, InfoTable);
2190         if (ACPI_FAILURE (Status))
2191         {
2192             return;
2193         }
2194
2195 NextSubTable:
2196         /* Point to next sub-table */
2197
2198         Offset += SubTable->Length;
2199         SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, SubTable, SubTable->Length);
2200     }
2201 }
2202
2203
2204 /*******************************************************************************
2205  *
2206  * FUNCTION:    AcpiDmDumpSlit
2207  *
2208  * PARAMETERS:  Table               - An SLIT
2209  *
2210  * RETURN:      None
2211  *
2212  * DESCRIPTION: Format the contents of a SLIT
2213  *
2214  ******************************************************************************/
2215
2216 void
2217 AcpiDmDumpSlit (
2218     ACPI_TABLE_HEADER       *Table)
2219 {
2220     ACPI_STATUS             Status;
2221     UINT32                  Offset;
2222     UINT8                   *Row;
2223     UINT32                  Localities;
2224     UINT32                  i;
2225     UINT32                  j;
2226
2227
2228     /* Main table */
2229
2230     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
2231     if (ACPI_FAILURE (Status))
2232     {
2233         return;
2234     }
2235
2236     /* Display the Locality NxN Matrix */
2237
2238     Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
2239     Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
2240     Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
2241
2242     for (i = 0; i < Localities; i++)
2243     {
2244         /* Display one row of the matrix */
2245
2246         AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
2247         for  (j = 0; j < Localities; j++)
2248         {
2249             /* Check for beyond EOT */
2250
2251             if (Offset >= Table->Length)
2252             {
2253                 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n");
2254                 return;
2255             }
2256
2257             AcpiOsPrintf ("%2.2X", Row[j]);
2258             Offset++;
2259
2260             /* Display up to 16 bytes per output row */
2261
2262             if ((j+1) < Localities)
2263             {
2264                 AcpiOsPrintf (" ");
2265
2266                 if (j && (((j+1) % 16) == 0))
2267                 {
2268                     AcpiOsPrintf ("\\\n"); /* With line continuation char */
2269                     AcpiDmLineHeader (Offset, 0, NULL);
2270                 }
2271             }
2272         }
2273
2274         /* Point to next row */
2275
2276         AcpiOsPrintf ("\n");
2277         Row += Localities;
2278     }
2279 }
2280
2281
2282 /*******************************************************************************
2283  *
2284  * FUNCTION:    AcpiDmDumpSrat
2285  *
2286  * PARAMETERS:  Table               - A SRAT table
2287  *
2288  * RETURN:      None
2289  *
2290  * DESCRIPTION: Format the contents of a SRAT
2291  *
2292  ******************************************************************************/
2293
2294 void
2295 AcpiDmDumpSrat (
2296     ACPI_TABLE_HEADER       *Table)
2297 {
2298     ACPI_STATUS             Status;
2299     UINT32                  Offset = sizeof (ACPI_TABLE_SRAT);
2300     ACPI_SUBTABLE_HEADER    *SubTable;
2301     ACPI_DMTABLE_INFO       *InfoTable;
2302
2303
2304     /* Main table */
2305
2306     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
2307     if (ACPI_FAILURE (Status))
2308     {
2309         return;
2310     }
2311
2312     /* Sub-tables */
2313
2314     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
2315     while (Offset < Table->Length)
2316     {
2317         /* Common sub-table header */
2318
2319         AcpiOsPrintf ("\n");
2320         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2321                     SubTable->Length, AcpiDmTableInfoSratHdr);
2322         if (ACPI_FAILURE (Status))
2323         {
2324             return;
2325         }
2326
2327         switch (SubTable->Type)
2328         {
2329         case ACPI_SRAT_TYPE_CPU_AFFINITY:
2330             InfoTable = AcpiDmTableInfoSrat0;
2331             break;
2332         case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
2333             InfoTable = AcpiDmTableInfoSrat1;
2334             break;
2335         case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
2336             InfoTable = AcpiDmTableInfoSrat2;
2337             break;
2338         default:
2339             AcpiOsPrintf ("\n**** Unknown SRAT sub-table type 0x%X\n", SubTable->Type);
2340
2341             /* Attempt to continue */
2342
2343             if (!SubTable->Length)
2344             {
2345                 AcpiOsPrintf ("Invalid zero length subtable\n");
2346                 return;
2347             }
2348             goto NextSubTable;
2349         }
2350
2351         AcpiOsPrintf ("\n");
2352         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2353                     SubTable->Length, InfoTable);
2354         if (ACPI_FAILURE (Status))
2355         {
2356             return;
2357         }
2358
2359 NextSubTable:
2360         /* Point to next sub-table */
2361
2362         Offset += SubTable->Length;
2363         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
2364     }
2365 }
2366
2367
2368 /*******************************************************************************
2369  *
2370  * FUNCTION:    AcpiDmDumpWdat
2371  *
2372  * PARAMETERS:  Table               - A WDAT table
2373  *
2374  * RETURN:      None
2375  *
2376  * DESCRIPTION: Format the contents of a WDAT
2377  *
2378  ******************************************************************************/
2379
2380 void
2381 AcpiDmDumpWdat (
2382     ACPI_TABLE_HEADER       *Table)
2383 {
2384     ACPI_STATUS             Status;
2385     UINT32                  Offset = sizeof (ACPI_TABLE_WDAT);
2386     ACPI_WDAT_ENTRY         *SubTable;
2387
2388
2389     /* Main table */
2390
2391     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
2392     if (ACPI_FAILURE (Status))
2393     {
2394         return;
2395     }
2396
2397     /* Sub-tables */
2398
2399     SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
2400     while (Offset < Table->Length)
2401     {
2402         /* Common sub-table header */
2403
2404         AcpiOsPrintf ("\n");
2405         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2406                     sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
2407         if (ACPI_FAILURE (Status))
2408         {
2409             return;
2410         }
2411
2412         /* Point to next sub-table */
2413
2414         Offset += sizeof (ACPI_WDAT_ENTRY);
2415         SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY));
2416     }
2417 }