source/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 "acpi.h"
  45 #include "accommon.h"
  46 #include "acdisasm.h"
  47 #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_SHARED_INFO   *SharedInfoTable;
 618     ACPI_CSRT_DESCRIPTOR    *SubSubTable;
 619     UINT32                  Length = Table->Length;
 620     UINT32                  Offset = sizeof (ACPI_TABLE_CSRT);
 621     UINT32                  SubOffset;
 622     UINT32                  SubSubOffset;
 623     UINT32                  InfoLength;
 624
 625
 626     /* The main table only contains the ACPI header, thus already handled */
 627
 628     /* Sub-tables (Resource Groups) */
 629
 630     SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset);
 631     while (Offset < Table->Length)
 632     {
 633         /* Resource group subtable */
 634
 635         AcpiOsPrintf ("\n");
 636         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 637                     SubTable->Length, AcpiDmTableInfoCsrt0);
 638         if (ACPI_FAILURE (Status))
 639         {
 640             return;
 641         }
 642
 643         /* Shared info subtable (One per resource group) */
 644
 645         SubOffset = sizeof (ACPI_CSRT_GROUP);
 646         SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table,
 647             Offset + SubOffset);
 648
 649         AcpiOsPrintf ("\n");
 650         Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable,
 651                     sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1);
 652         if (ACPI_FAILURE (Status))
 653         {
 654             return;
 655         }
 656
 657         SubOffset += SubTable->SharedInfoLength;
 658
 659         /* Sub-Subtables (Resource Descriptors) */
 660
 661         SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table,
 662             Offset + SubOffset);
 663
 664         while ((SubOffset < SubTable->Length) &&
 665               ((Offset + SubOffset) < Table->Length))
 666         {
 667             AcpiOsPrintf ("\n");
 668             Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable,
 669                         SubSubTable->Length, AcpiDmTableInfoCsrt2);
 670             if (ACPI_FAILURE (Status))
 671             {
 672                 return;
 673             }
 674
 675             SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR);
 676
 677             /* Resource-specific info buffer */
 678
 679             InfoLength = SubSubTable->Length - SubSubOffset;
 680
 681             AcpiDmDumpBuffer (SubSubTable, SubSubOffset, InfoLength,
 682                 Offset + SubOffset + SubSubOffset, "ResourceInfo");
 683             SubSubOffset += InfoLength;
 684
 685             /* Point to next sub-subtable */
 686
 687             SubOffset += SubSubTable->Length;
 688             SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable,
 689                         SubSubTable->Length);
 690         }
 691
 692         /* Point to next sub-table */
 693
 694         Offset += SubTable->Length;
 695         SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable,
 696                     SubTable->Length);
 697     }
 698 }
 699
 700
 701 /*******************************************************************************
 702  *
 703  * FUNCTION:    AcpiDmDumpDbg2
 704  *
 705  * PARAMETERS:  Table               - A DBG2 table
 706  *
 707  * RETURN:      None
 708  *
 709  * DESCRIPTION: Format the contents of a DBG2. This table type consists
 710  *              of an open-ended number of subtables.
 711  *
 712  ******************************************************************************/
 713
 714 void
 715 AcpiDmDumpDbg2 (
 716     ACPI_TABLE_HEADER       *Table)
 717 {
 718     ACPI_STATUS             Status;
 719     ACPI_DBG2_DEVICE        *SubTable;
 720     UINT32                  Length = Table->Length;
 721     UINT32                  Offset = sizeof (ACPI_TABLE_DBG2);
 722     UINT32                  i;
 723     UINT32                  ArrayOffset;
 724     UINT32                  AbsoluteOffset;
 725     UINT8                   *Array;
 726
 727
 728     /* Main table */
 729
 730     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2);
 731     if (ACPI_FAILURE (Status))
 732     {
 733         return;
 734     }
 735
 736     /* Sub-tables */
 737
 738     SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset);
 739     while (Offset < Table->Length)
 740     {
 741         AcpiOsPrintf ("\n");
 742         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 743                     SubTable->Length, AcpiDmTableInfoDbg2Device);
 744         if (ACPI_FAILURE (Status))
 745         {
 746             return;
 747         }
 748
 749         /* Dump the BaseAddress array */
 750
 751         for (i = 0; i < SubTable->RegisterCount; i++)
 752         {
 753             ArrayOffset = SubTable->BaseAddressOffset +
 754                 (sizeof (ACPI_GENERIC_ADDRESS) * i);
 755             AbsoluteOffset = Offset + ArrayOffset;
 756             Array = (UINT8 *) SubTable + ArrayOffset;
 757
 758             Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
 759                         SubTable->Length, AcpiDmTableInfoDbg2Addr);
 760             if (ACPI_FAILURE (Status))
 761             {
 762                 return;
 763             }
 764         }
 765
 766         /* Dump the AddressSize array */
 767
 768         for (i = 0; i < SubTable->RegisterCount; i++)
 769         {
 770             ArrayOffset = SubTable->AddressSizeOffset +
 771                 (sizeof (UINT32) * i);
 772             AbsoluteOffset = Offset + ArrayOffset;
 773             Array = (UINT8 *) SubTable + ArrayOffset;
 774
 775             Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
 776                         SubTable->Length, AcpiDmTableInfoDbg2Size);
 777             if (ACPI_FAILURE (Status))
 778             {
 779                 return;
 780             }
 781         }
 782
 783         /* Dump the Namestring (required) */
 784
 785         AcpiOsPrintf ("\n");
 786         ArrayOffset = SubTable->NamepathOffset;
 787         AbsoluteOffset = Offset + ArrayOffset;
 788         Array = (UINT8 *) SubTable + ArrayOffset;
 789
 790         Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array,
 791                     SubTable->Length, AcpiDmTableInfoDbg2Name);
 792         if (ACPI_FAILURE (Status))
 793         {
 794             return;
 795         }
 796
 797         /* Dump the OemData (optional) */
 798
 799         AcpiDmDumpBuffer (SubTable, SubTable->OemDataOffset, SubTable->OemDataLength,
 800             Offset + SubTable->OemDataOffset, "OEM Data");
 801
 802         /* Point to next sub-table */
 803
 804         Offset += SubTable->Length;
 805         SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable,
 806                     SubTable->Length);
 807     }
 808 }
 809
 810
 811 /*******************************************************************************
 812  *
 813  * FUNCTION:    AcpiDmDumpDmar
 814  *
 815  * PARAMETERS:  Table               - A DMAR table
 816  *
 817  * RETURN:      None
 818  *
 819  * DESCRIPTION: Format the contents of a DMAR. This table type consists
 820  *              of an open-ended number of subtables.
 821  *
 822  ******************************************************************************/
 823
 824
 825 void
 826 AcpiDmDumpDmar (
 827     ACPI_TABLE_HEADER       *Table)
 828 {
 829     ACPI_STATUS             Status;
 830     ACPI_DMAR_HEADER        *SubTable;
 831     UINT32                  Length = Table->Length;
 832     UINT32                  Offset = sizeof (ACPI_TABLE_DMAR);
 833     ACPI_DMTABLE_INFO       *InfoTable;
 834     ACPI_DMAR_DEVICE_SCOPE  *ScopeTable;
 835     UINT32                  ScopeOffset;
 836     UINT8                   *PciPath;
 837     UINT32                  PathOffset;
 838
 839
 840     /* Main table */
 841
 842     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
 843     if (ACPI_FAILURE (Status))
 844     {
 845         return;
 846     }
 847
 848     /* Sub-tables */
 849
 850     SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
 851     while (Offset < Table->Length)
 852     {
 853         /* Common sub-table header */
 854
 855         AcpiOsPrintf ("\n");
 856         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 857                     SubTable->Length, AcpiDmTableInfoDmarHdr);
 858         if (ACPI_FAILURE (Status))
 859         {
 860             return;
 861         }
 862
 863         switch (SubTable->Type)
 864         {
 865         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
 866             InfoTable = AcpiDmTableInfoDmar0;
 867             ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
 868             break;
 869         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
 870             InfoTable = AcpiDmTableInfoDmar1;
 871             ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
 872             break;
 873         case ACPI_DMAR_TYPE_ATSR:
 874             InfoTable = AcpiDmTableInfoDmar2;
 875             ScopeOffset = sizeof (ACPI_DMAR_ATSR);
 876             break;
 877         case ACPI_DMAR_HARDWARE_AFFINITY:
 878             InfoTable = AcpiDmTableInfoDmar3;
 879             ScopeOffset = sizeof (ACPI_DMAR_RHSA);
 880             break;
 881         default:
 882             AcpiOsPrintf ("\n**** Unknown DMAR sub-table type 0x%X\n\n", SubTable->Type);
 883             return;
 884         }
 885
 886         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 887                     SubTable->Length, InfoTable);
 888         if (ACPI_FAILURE (Status))
 889         {
 890             return;
 891         }
 892
 893         /* Dump the device scope entries (if any) */
 894
 895         ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
 896         while (ScopeOffset < SubTable->Length)
 897         {
 898             AcpiOsPrintf ("\n");
 899             Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
 900                         ScopeTable->Length, AcpiDmTableInfoDmarScope);
 901             if (ACPI_FAILURE (Status))
 902             {
 903                 return;
 904             }
 905
 906             /* Dump the PCI Path entries for this device scope */
 907
 908             PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
 909
 910             PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
 911                 sizeof (ACPI_DMAR_DEVICE_SCOPE));
 912
 913             while (PathOffset < ScopeTable->Length)
 914             {
 915                 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path");
 916                 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]);
 917
 918                 /* Point to next PCI Path entry */
 919
 920                 PathOffset += 2;
 921                 PciPath += 2;
 922             }
 923
 924             /* Point to next device scope entry */
 925
 926             ScopeOffset += ScopeTable->Length;
 927             ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
 928                 ScopeTable, ScopeTable->Length);
 929         }
 930
 931         /* Point to next sub-table */
 932
 933         Offset += SubTable->Length;
 934         SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length);
 935     }
 936 }
 937
 938
 939 /*******************************************************************************
 940  *
 941  * FUNCTION:    AcpiDmDumpEinj
 942  *
 943  * PARAMETERS:  Table               - A EINJ table
 944  *
 945  * RETURN:      None
 946  *
 947  * DESCRIPTION: Format the contents of a EINJ. This table type consists
 948  *              of an open-ended number of subtables.
 949  *
 950  ******************************************************************************/
 951
 952 void
 953 AcpiDmDumpEinj (
 954     ACPI_TABLE_HEADER       *Table)
 955 {
 956     ACPI_STATUS             Status;
 957     ACPI_WHEA_HEADER        *SubTable;
 958     UINT32                  Length = Table->Length;
 959     UINT32                  Offset = sizeof (ACPI_TABLE_EINJ);
 960
 961
 962     /* Main table */
 963
 964     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
 965     if (ACPI_FAILURE (Status))
 966     {
 967         return;
 968     }
 969
 970     /* Sub-tables */
 971
 972     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
 973     while (Offset < Table->Length)
 974     {
 975         AcpiOsPrintf ("\n");
 976         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 977                     sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
 978         if (ACPI_FAILURE (Status))
 979         {
 980             return;
 981         }
 982
 983         /* Point to next sub-table (each subtable is of fixed length) */
 984
 985         Offset += sizeof (ACPI_WHEA_HEADER);
 986         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
 987                         sizeof (ACPI_WHEA_HEADER));
 988     }
 989 }
 990
 991
 992 /*******************************************************************************
 993  *
 994  * FUNCTION:    AcpiDmDumpErst
 995  *
 996  * PARAMETERS:  Table               - A ERST table
 997  *
 998  * RETURN:      None
 999  *
1000  * DESCRIPTION: Format the contents of a ERST. This table type consists
1001  *              of an open-ended number of subtables.
1002  *
1003  ******************************************************************************/
1004
1005 void
1006 AcpiDmDumpErst (
1007     ACPI_TABLE_HEADER       *Table)
1008 {
1009     ACPI_STATUS             Status;
1010     ACPI_WHEA_HEADER        *SubTable;
1011     UINT32                  Length = Table->Length;
1012     UINT32                  Offset = sizeof (ACPI_TABLE_ERST);
1013
1014
1015     /* Main table */
1016
1017     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
1018     if (ACPI_FAILURE (Status))
1019     {
1020         return;
1021     }
1022
1023     /* Sub-tables */
1024
1025     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
1026     while (Offset < Table->Length)
1027     {
1028         AcpiOsPrintf ("\n");
1029         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1030                     sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0);
1031         if (ACPI_FAILURE (Status))
1032         {
1033             return;
1034         }
1035
1036         /* Point to next sub-table (each subtable is of fixed length) */
1037
1038         Offset += sizeof (ACPI_WHEA_HEADER);
1039         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
1040                         sizeof (ACPI_WHEA_HEADER));
1041     }
1042 }
1043
1044
1045 /*******************************************************************************
1046  *
1047  * FUNCTION:    AcpiDmDumpFpdt
1048  *
1049  * PARAMETERS:  Table               - A FPDT table
1050  *
1051  * RETURN:      None
1052  *
1053  * DESCRIPTION: Format the contents of a FPDT. This table type consists
1054  *              of an open-ended number of subtables.
1055  *
1056  ******************************************************************************/
1057
1058 void
1059 AcpiDmDumpFpdt (
1060     ACPI_TABLE_HEADER       *Table)
1061 {
1062     ACPI_STATUS             Status;
1063     ACPI_FPDT_HEADER        *SubTable;
1064     UINT32                  Length = Table->Length;
1065     UINT32                  Offset = sizeof (ACPI_TABLE_FPDT);
1066     ACPI_DMTABLE_INFO       *InfoTable;
1067
1068
1069     /* There is no main table (other than the standard ACPI header) */
1070
1071     /* Sub-tables */
1072
1073     SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset);
1074     while (Offset < Table->Length)
1075     {
1076         /* Common sub-table header */
1077
1078         AcpiOsPrintf ("\n");
1079         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1080                     SubTable->Length, AcpiDmTableInfoFpdtHdr);
1081         if (ACPI_FAILURE (Status))
1082         {
1083             return;
1084         }
1085
1086         switch (SubTable->Type)
1087         {
1088         case ACPI_FPDT_TYPE_BOOT:
1089             InfoTable = AcpiDmTableInfoFpdt0;
1090             break;
1091         case ACPI_FPDT_TYPE_S3PERF:
1092             InfoTable = AcpiDmTableInfoFpdt1;
1093             break;
1094         default:
1095             AcpiOsPrintf ("\n**** Unknown FPDT sub-table type 0x%X\n\n", SubTable->Type);
1096
1097             /* Attempt to continue */
1098
1099             if (!SubTable->Length)
1100             {
1101                 AcpiOsPrintf ("Invalid zero length subtable\n");
1102                 return;
1103             }
1104             goto NextSubTable;
1105         }
1106
1107         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1108                     SubTable->Length, InfoTable);
1109         if (ACPI_FAILURE (Status))
1110         {
1111             return;
1112         }
1113
1114 NextSubTable:
1115         /* Point to next sub-table */
1116
1117         Offset += SubTable->Length;
1118         SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length);
1119     }
1120 }
1121
1122
1123 /*******************************************************************************
1124  *
1125  * FUNCTION:    AcpiDmDumpHest
1126  *
1127  * PARAMETERS:  Table               - A HEST table
1128  *
1129  * RETURN:      None
1130  *
1131  * DESCRIPTION: Format the contents of a HEST. This table type consists
1132  *              of an open-ended number of subtables.
1133  *
1134  ******************************************************************************/
1135
1136 void
1137 AcpiDmDumpHest (
1138     ACPI_TABLE_HEADER       *Table)
1139 {
1140     ACPI_STATUS             Status;
1141     ACPI_HEST_HEADER        *SubTable;
1142     UINT32                  Length = Table->Length;
1143     UINT32                  Offset = sizeof (ACPI_TABLE_HEST);
1144     ACPI_DMTABLE_INFO       *InfoTable;
1145     UINT32                  SubTableLength;
1146     UINT32                  BankCount;
1147     ACPI_HEST_IA_ERROR_BANK *BankTable;
1148
1149
1150     /* Main table */
1151
1152     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
1153     if (ACPI_FAILURE (Status))
1154     {
1155         return;
1156     }
1157
1158     /* Sub-tables */
1159
1160     SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
1161     while (Offset < Table->Length)
1162     {
1163         BankCount = 0;
1164         switch (SubTable->Type)
1165         {
1166         case ACPI_HEST_TYPE_IA32_CHECK:
1167             InfoTable = AcpiDmTableInfoHest0;
1168             SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK);
1169             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK,
1170                             SubTable))->NumHardwareBanks;
1171             break;
1172
1173         case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK:
1174             InfoTable = AcpiDmTableInfoHest1;
1175             SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED);
1176             BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED,
1177                             SubTable))->NumHardwareBanks;
1178             break;
1179
1180         case ACPI_HEST_TYPE_IA32_NMI:
1181             InfoTable = AcpiDmTableInfoHest2;
1182             SubTableLength = sizeof (ACPI_HEST_IA_NMI);
1183             break;
1184
1185         case ACPI_HEST_TYPE_AER_ROOT_PORT:
1186             InfoTable = AcpiDmTableInfoHest6;
1187             SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
1188             break;
1189
1190         case ACPI_HEST_TYPE_AER_ENDPOINT:
1191             InfoTable = AcpiDmTableInfoHest7;
1192             SubTableLength = sizeof (ACPI_HEST_AER);
1193             break;
1194
1195         case ACPI_HEST_TYPE_AER_BRIDGE:
1196             InfoTable = AcpiDmTableInfoHest8;
1197             SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
1198             break;
1199
1200         case ACPI_HEST_TYPE_GENERIC_ERROR:
1201             InfoTable = AcpiDmTableInfoHest9;
1202             SubTableLength = sizeof (ACPI_HEST_GENERIC);
1203             break;
1204
1205         default:
1206             /* Cannot continue on unknown type - no length */
1207
1208             AcpiOsPrintf ("\n**** Unknown HEST sub-table type 0x%X\n", SubTable->Type);
1209             return;
1210         }
1211
1212         AcpiOsPrintf ("\n");
1213         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1214                     SubTableLength, InfoTable);
1215         if (ACPI_FAILURE (Status))
1216         {
1217             return;
1218         }
1219
1220         /* Point to end of current subtable (each subtable above is of fixed length) */
1221
1222         Offset += SubTableLength;
1223
1224         /* If there are any (fixed-length) Error Banks from above, dump them now */
1225
1226         if (BankCount)
1227         {
1228             BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength);
1229             SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK);
1230
1231             while (BankCount)
1232             {
1233                 AcpiOsPrintf ("\n");
1234                 Status = AcpiDmDumpTable (Length, Offset, BankTable,
1235                             sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank);
1236                 if (ACPI_FAILURE (Status))
1237                 {
1238                     return;
1239                 }
1240                 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK);
1241                 BankTable++;
1242                 BankCount--;
1243             }
1244         }
1245
1246         /* Point to next sub-table */
1247
1248         SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
1249     }
1250 }
1251
1252
1253 /*******************************************************************************
1254  *
1255  * FUNCTION:    AcpiDmDumpIvrs
1256  *
1257  * PARAMETERS:  Table               - A IVRS table
1258  *
1259  * RETURN:      None
1260  *
1261  * DESCRIPTION: Format the contents of a IVRS
1262  *
1263  ******************************************************************************/
1264
1265 static UINT8 EntrySizes[] = {4,8,16,32};
1266
1267 void
1268 AcpiDmDumpIvrs (
1269     ACPI_TABLE_HEADER       *Table)
1270 {
1271     ACPI_STATUS             Status;
1272     UINT32                  Offset = sizeof (ACPI_TABLE_IVRS);
1273     UINT32                  EntryOffset;
1274     UINT32                  EntryLength;
1275     UINT32                  EntryType;
1276     ACPI_IVRS_DE_HEADER     *DeviceEntry;
1277     ACPI_IVRS_HEADER        *SubTable;
1278     ACPI_DMTABLE_INFO       *InfoTable;
1279
1280
1281     /* Main table */
1282
1283     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs);
1284     if (ACPI_FAILURE (Status))
1285     {
1286         return;
1287     }
1288
1289     /* Sub-tables */
1290
1291     SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset);
1292     while (Offset < Table->Length)
1293     {
1294         /* Common sub-table header */
1295
1296         AcpiOsPrintf ("\n");
1297         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1298                     SubTable->Length, AcpiDmTableInfoIvrsHdr);
1299         if (ACPI_FAILURE (Status))
1300         {
1301             return;
1302         }
1303
1304         switch (SubTable->Type)
1305         {
1306         case ACPI_IVRS_TYPE_HARDWARE:
1307             InfoTable = AcpiDmTableInfoIvrs0;
1308             break;
1309         case ACPI_IVRS_TYPE_MEMORY1:
1310         case ACPI_IVRS_TYPE_MEMORY2:
1311         case ACPI_IVRS_TYPE_MEMORY3:
1312             InfoTable = AcpiDmTableInfoIvrs1;
1313             break;
1314         default:
1315             AcpiOsPrintf ("\n**** Unknown IVRS sub-table type 0x%X\n",
1316                 SubTable->Type);
1317
1318             /* Attempt to continue */
1319
1320             if (!SubTable->Length)
1321             {
1322                 AcpiOsPrintf ("Invalid zero length subtable\n");
1323                 return;
1324             }
1325             goto NextSubTable;
1326         }
1327
1328         /* Dump the subtable */
1329
1330         AcpiOsPrintf ("\n");
1331         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1332                     SubTable->Length, InfoTable);
1333         if (ACPI_FAILURE (Status))
1334         {
1335             return;
1336         }
1337
1338         /* The hardware subtable can contain multiple device entries */
1339
1340         if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE)
1341         {
1342             EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE);
1343             DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable,
1344                             sizeof (ACPI_IVRS_HARDWARE));
1345
1346             while (EntryOffset < (Offset + SubTable->Length))
1347             {
1348                 AcpiOsPrintf ("\n");
1349                 /*
1350                  * Upper 2 bits of Type encode the length of the device entry
1351                  *
1352                  * 00 = 4 byte
1353                  * 01 = 8 byte
1354                  * 10 = 16 byte - currently no entries defined
1355                  * 11 = 32 byte - currently no entries defined
1356                  */
1357                 EntryType = DeviceEntry->Type;
1358                 EntryLength = EntrySizes [EntryType >> 6];
1359
1360                 switch (EntryType)
1361                 {
1362                 /* 4-byte device entries */
1363
1364                 case ACPI_IVRS_TYPE_PAD4:
1365                 case ACPI_IVRS_TYPE_ALL:
1366                 case ACPI_IVRS_TYPE_SELECT:
1367                 case ACPI_IVRS_TYPE_START:
1368                 case ACPI_IVRS_TYPE_END:
1369
1370                     InfoTable = AcpiDmTableInfoIvrs4;
1371                     break;
1372
1373                 /* 8-byte entries, type A */
1374
1375                 case ACPI_IVRS_TYPE_ALIAS_SELECT:
1376                 case ACPI_IVRS_TYPE_ALIAS_START:
1377
1378                     InfoTable = AcpiDmTableInfoIvrs8a;
1379                     break;
1380
1381                 /* 8-byte entries, type B */
1382
1383                 case ACPI_IVRS_TYPE_PAD8:
1384                 case ACPI_IVRS_TYPE_EXT_SELECT:
1385                 case ACPI_IVRS_TYPE_EXT_START:
1386
1387                     InfoTable = AcpiDmTableInfoIvrs8b;
1388                     break;
1389
1390                 /* 8-byte entries, type C */
1391
1392                 case ACPI_IVRS_TYPE_SPECIAL:
1393
1394                     InfoTable = AcpiDmTableInfoIvrs8c;
1395                     break;
1396
1397                 default:
1398                     InfoTable = AcpiDmTableInfoIvrs4;
1399                     AcpiOsPrintf (
1400                         "\n**** Unknown IVRS device entry type/length: "
1401                         "0x%.2X/0x%X at offset 0x%.4X: (header below)\n",
1402                         EntryType, EntryLength, EntryOffset);
1403                     break;
1404                 }
1405
1406                 /* Dump the Device Entry */
1407
1408                 Status = AcpiDmDumpTable (Table->Length, EntryOffset,
1409                             DeviceEntry, EntryLength, InfoTable);
1410
1411                 EntryOffset += EntryLength;
1412                 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
1413                                 EntryLength);
1414             }
1415         }
1416
1417 NextSubTable:
1418         /* Point to next sub-table */
1419
1420         Offset += SubTable->Length;
1421         SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length);
1422     }
1423 }
1424
1425
1426 /*******************************************************************************
1427  *
1428  * FUNCTION:    AcpiDmDumpMadt
1429  *
1430  * PARAMETERS:  Table               - A MADT table
1431  *
1432  * RETURN:      None
1433  *
1434  * DESCRIPTION: Format the contents of a MADT. This table type consists
1435  *              of an open-ended number of subtables.
1436  *
1437  ******************************************************************************/
1438
1439 void
1440 AcpiDmDumpMadt (
1441     ACPI_TABLE_HEADER       *Table)
1442 {
1443     ACPI_STATUS             Status;
1444     ACPI_SUBTABLE_HEADER    *SubTable;
1445     UINT32                  Length = Table->Length;
1446     UINT32                  Offset = sizeof (ACPI_TABLE_MADT);
1447     ACPI_DMTABLE_INFO       *InfoTable;
1448
1449
1450     /* Main table */
1451
1452     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
1453     if (ACPI_FAILURE (Status))
1454     {
1455         return;
1456     }
1457
1458     /* Sub-tables */
1459
1460     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1461     while (Offset < Table->Length)
1462     {
1463         /* Common sub-table header */
1464
1465         AcpiOsPrintf ("\n");
1466         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1467                     SubTable->Length, AcpiDmTableInfoMadtHdr);
1468         if (ACPI_FAILURE (Status))
1469         {
1470             return;
1471         }
1472
1473         switch (SubTable->Type)
1474         {
1475         case ACPI_MADT_TYPE_LOCAL_APIC:
1476             InfoTable = AcpiDmTableInfoMadt0;
1477             break;
1478         case ACPI_MADT_TYPE_IO_APIC:
1479             InfoTable = AcpiDmTableInfoMadt1;
1480             break;
1481         case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
1482             InfoTable = AcpiDmTableInfoMadt2;
1483             break;
1484         case ACPI_MADT_TYPE_NMI_SOURCE:
1485             InfoTable = AcpiDmTableInfoMadt3;
1486             break;
1487         case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
1488             InfoTable = AcpiDmTableInfoMadt4;
1489             break;
1490         case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
1491             InfoTable = AcpiDmTableInfoMadt5;
1492             break;
1493         case ACPI_MADT_TYPE_IO_SAPIC:
1494             InfoTable = AcpiDmTableInfoMadt6;
1495             break;
1496         case ACPI_MADT_TYPE_LOCAL_SAPIC:
1497             InfoTable = AcpiDmTableInfoMadt7;
1498             break;
1499         case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
1500             InfoTable = AcpiDmTableInfoMadt8;
1501             break;
1502         case ACPI_MADT_TYPE_LOCAL_X2APIC:
1503             InfoTable = AcpiDmTableInfoMadt9;
1504             break;
1505         case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
1506             InfoTable = AcpiDmTableInfoMadt10;
1507             break;
1508         case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
1509             InfoTable = AcpiDmTableInfoMadt11;
1510             break;
1511         case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
1512             InfoTable = AcpiDmTableInfoMadt12;
1513             break;
1514         default:
1515             AcpiOsPrintf ("\n**** Unknown MADT sub-table type 0x%X\n\n", SubTable->Type);
1516
1517             /* Attempt to continue */
1518
1519             if (!SubTable->Length)
1520             {
1521                 AcpiOsPrintf ("Invalid zero length subtable\n");
1522                 return;
1523             }
1524             goto NextSubTable;
1525         }
1526
1527         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1528                     SubTable->Length, InfoTable);
1529         if (ACPI_FAILURE (Status))
1530         {
1531             return;
1532         }
1533
1534 NextSubTable:
1535         /* Point to next sub-table */
1536
1537         Offset += SubTable->Length;
1538         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1539     }
1540 }
1541
1542
1543 /*******************************************************************************
1544  *
1545  * FUNCTION:    AcpiDmDumpMcfg
1546  *
1547  * PARAMETERS:  Table               - A MCFG Table
1548  *
1549  * RETURN:      None
1550  *
1551  * DESCRIPTION: Format the contents of a MCFG table
1552  *
1553  ******************************************************************************/
1554
1555 void
1556 AcpiDmDumpMcfg (
1557     ACPI_TABLE_HEADER       *Table)
1558 {
1559     ACPI_STATUS             Status;
1560     UINT32                  Offset = sizeof (ACPI_TABLE_MCFG);
1561     ACPI_MCFG_ALLOCATION    *SubTable;
1562
1563
1564     /* Main table */
1565
1566     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
1567     if (ACPI_FAILURE (Status))
1568     {
1569         return;
1570     }
1571
1572     /* Sub-tables */
1573
1574     SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
1575     while (Offset < Table->Length)
1576     {
1577         if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
1578         {
1579             AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n",
1580                 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
1581             return;
1582         }
1583
1584         AcpiOsPrintf ("\n");
1585         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1586                     sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
1587         if (ACPI_FAILURE (Status))
1588         {
1589             return;
1590         }
1591
1592         /* Point to next sub-table (each subtable is of fixed length) */
1593
1594         Offset += sizeof (ACPI_MCFG_ALLOCATION);
1595         SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
1596                         sizeof (ACPI_MCFG_ALLOCATION));
1597     }
1598 }
1599
1600
1601 /*******************************************************************************
1602  *
1603  * FUNCTION:    AcpiDmDumpMpst
1604  *
1605  * PARAMETERS:  Table               - A MPST Table
1606  *
1607  * RETURN:      None
1608  *
1609  * DESCRIPTION: Format the contents of a MPST table
1610  *
1611  ******************************************************************************/
1612
1613 void
1614 AcpiDmDumpMpst (
1615     ACPI_TABLE_HEADER       *Table)
1616 {
1617     ACPI_STATUS             Status;
1618     UINT32                  Offset = sizeof (ACPI_TABLE_MPST);
1619     ACPI_MPST_POWER_NODE    *SubTable0;
1620     ACPI_MPST_POWER_STATE   *SubTable0A;
1621     ACPI_MPST_COMPONENT     *SubTable0B;
1622     ACPI_MPST_DATA_HDR      *SubTable1;
1623     ACPI_MPST_POWER_DATA    *SubTable2;
1624     UINT16                  SubtableCount;
1625     UINT32                  PowerStateCount;
1626     UINT32                  ComponentCount;
1627
1628
1629     /* Main table */
1630
1631     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst);
1632     if (ACPI_FAILURE (Status))
1633     {
1634         return;
1635     }
1636
1637     /* Subtable: Memory Power Node(s) */
1638
1639     SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount;
1640     SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset);
1641
1642     while ((Offset < Table->Length) && SubtableCount)
1643     {
1644         AcpiOsPrintf ("\n");
1645         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0,
1646                     sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0);
1647         if (ACPI_FAILURE (Status))
1648         {
1649             return;
1650         }
1651
1652         /* Extract the sub-subtable counts */
1653
1654         PowerStateCount = SubTable0->NumPowerStates;
1655         ComponentCount = SubTable0->NumPhysicalComponents;
1656         Offset += sizeof (ACPI_MPST_POWER_NODE);
1657
1658         /* Sub-subtables - Memory Power State Structure(s) */
1659
1660         SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0,
1661             sizeof (ACPI_MPST_POWER_NODE));
1662
1663         while (PowerStateCount)
1664         {
1665             AcpiOsPrintf ("\n");
1666             Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A,
1667                         sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A);
1668             if (ACPI_FAILURE (Status))
1669             {
1670                 return;
1671             }
1672
1673             SubTable0A++;
1674             PowerStateCount--;
1675             Offset += sizeof (ACPI_MPST_POWER_STATE);
1676        }
1677
1678         /* Sub-subtables - Physical Component ID Structure(s) */
1679
1680         SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A);
1681
1682         if (ComponentCount)
1683         {
1684             AcpiOsPrintf ("\n");
1685         }
1686
1687         while (ComponentCount)
1688         {
1689             Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B,
1690                         sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B);
1691             if (ACPI_FAILURE (Status))
1692             {
1693                 return;
1694             }
1695
1696             SubTable0B++;
1697             ComponentCount--;
1698             Offset += sizeof (ACPI_MPST_COMPONENT);
1699         }
1700
1701         /* Point to next Memory Power Node subtable */
1702
1703         SubtableCount--;
1704         SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0,
1705             sizeof (ACPI_MPST_POWER_NODE) +
1706             (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) +
1707             (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents));
1708     }
1709
1710     /* Subtable: Count of Memory Power State Characteristic structures */
1711
1712     AcpiOsPrintf ("\n");
1713     SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0);
1714     Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1,
1715                 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1);
1716     if (ACPI_FAILURE (Status))
1717     {
1718         return;
1719     }
1720
1721     SubtableCount = SubTable1->CharacteristicsCount;
1722     Offset += sizeof (ACPI_MPST_DATA_HDR);
1723
1724     /* Subtable: Memory Power State Characteristics structure(s) */
1725
1726     SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, sizeof (ACPI_MPST_DATA_HDR));
1727
1728     while ((Offset < Table->Length) && SubtableCount)
1729     {
1730         AcpiOsPrintf ("\n");
1731         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2,
1732                     sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2);
1733         if (ACPI_FAILURE (Status))
1734         {
1735             return;
1736         }
1737
1738         SubTable2++;
1739         SubtableCount--;
1740         Offset += sizeof (ACPI_MPST_POWER_DATA);
1741     }
1742 }
1743
1744
1745 /*******************************************************************************
1746  *
1747  * FUNCTION:    AcpiDmDumpMsct
1748  *
1749  * PARAMETERS:  Table               - A MSCT table
1750  *
1751  * RETURN:      None
1752  *
1753  * DESCRIPTION: Format the contents of a MSCT
1754  *
1755  ******************************************************************************/
1756
1757 void
1758 AcpiDmDumpMsct (
1759     ACPI_TABLE_HEADER       *Table)
1760 {
1761     ACPI_STATUS             Status;
1762     UINT32                  Offset = sizeof (ACPI_TABLE_MSCT);
1763     ACPI_MSCT_PROXIMITY     *SubTable;
1764
1765
1766     /* Main table */
1767
1768     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct);
1769     if (ACPI_FAILURE (Status))
1770     {
1771         return;
1772     }
1773
1774     /* Sub-tables */
1775
1776     SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset);
1777     while (Offset < Table->Length)
1778     {
1779         /* Common sub-table header */
1780
1781         AcpiOsPrintf ("\n");
1782         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1783                     sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0);
1784         if (ACPI_FAILURE (Status))
1785         {
1786             return;
1787         }
1788
1789         /* Point to next sub-table */
1790
1791         Offset += sizeof (ACPI_MSCT_PROXIMITY);
1792         SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY));
1793     }
1794 }
1795
1796
1797 /*******************************************************************************
1798  *
1799  * FUNCTION:    AcpiDmDumpPcct
1800  *
1801  * PARAMETERS:  Table               - A PCCT table
1802  *
1803  * RETURN:      None
1804  *
1805  * DESCRIPTION: Format the contents of a PCCT. This table type consists
1806  *              of an open-ended number of subtables.
1807  *
1808  ******************************************************************************/
1809
1810 void
1811 AcpiDmDumpPcct (
1812     ACPI_TABLE_HEADER       *Table)
1813 {
1814     ACPI_STATUS             Status;
1815     ACPI_PCCT_SUBSPACE      *SubTable;
1816     UINT32                  Length = Table->Length;
1817     UINT32                  Offset = sizeof (ACPI_TABLE_PCCT);
1818
1819
1820     /* Main table */
1821
1822     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct);
1823     if (ACPI_FAILURE (Status))
1824     {
1825         return;
1826     }
1827
1828     /* Sub-tables */
1829
1830     SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset);
1831     while (Offset < Table->Length)
1832     {
1833         AcpiOsPrintf ("\n");
1834         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1835                     SubTable->Header.Length, AcpiDmTableInfoPcct0);
1836         if (ACPI_FAILURE (Status))
1837         {
1838             return;
1839         }
1840
1841         /* Point to next sub-table */
1842
1843         Offset += SubTable->Header.Length;
1844         SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable,
1845                     SubTable->Header.Length);
1846     }
1847 }
1848
1849
1850 /*******************************************************************************
1851  *
1852  * FUNCTION:    AcpiDmDumpPmtt
1853  *
1854  * PARAMETERS:  Table               - A PMTT table
1855  *
1856  * RETURN:      None
1857  *
1858  * DESCRIPTION: Format the contents of a PMTT. This table type consists
1859  *              of an open-ended number of subtables.
1860  *
1861  ******************************************************************************/
1862
1863 void
1864 AcpiDmDumpPmtt (
1865     ACPI_TABLE_HEADER       *Table)
1866 {
1867     ACPI_STATUS             Status;
1868     ACPI_PMTT_HEADER        *SubTable;
1869     ACPI_PMTT_HEADER        *MemSubTable;
1870     ACPI_PMTT_HEADER        *DimmSubTable;
1871     ACPI_PMTT_DOMAIN        *DomainArray;
1872     UINT32                  Length = Table->Length;
1873     UINT32                  Offset = sizeof (ACPI_TABLE_PMTT);
1874     UINT32                  MemOffset;
1875     UINT32                  DimmOffset;
1876     UINT32                  DomainOffset;
1877     UINT32                  DomainCount;
1878
1879
1880     /* Main table */
1881
1882     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
1883     if (ACPI_FAILURE (Status))
1884     {
1885         return;
1886     }
1887
1888     /* Subtables */
1889
1890     SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
1891     while (Offset < Table->Length)
1892     {
1893         /* Common subtable header */
1894
1895         AcpiOsPrintf ("\n");
1896         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1897                     SubTable->Length, AcpiDmTableInfoPmttHdr);
1898         if (ACPI_FAILURE (Status))
1899         {
1900             return;
1901         }
1902
1903         /* Only Socket subtables are expected at this level */
1904
1905         if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET)
1906         {
1907             AcpiOsPrintf (
1908                 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
1909                 SubTable->Type);
1910             return;
1911         }
1912
1913         /* Dump the fixed-length portion of the subtable */
1914
1915         Status = AcpiDmDumpTable (Length, Offset, SubTable,
1916                     SubTable->Length, AcpiDmTableInfoPmtt0);
1917         if (ACPI_FAILURE (Status))
1918         {
1919             return;
1920         }
1921
1922         /* Walk the memory controller subtables */
1923
1924         MemOffset = sizeof (ACPI_PMTT_SOCKET);
1925         MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable,
1926             sizeof (ACPI_PMTT_SOCKET));
1927
1928         while (((Offset + MemOffset) < Table->Length) &&
1929             (MemOffset < SubTable->Length))
1930         {
1931             /* Common subtable header */
1932
1933             AcpiOsPrintf ("\n");
1934             Status = AcpiDmDumpTable (Length,
1935                         Offset + MemOffset, MemSubTable,
1936                         MemSubTable->Length, AcpiDmTableInfoPmttHdr);
1937             if (ACPI_FAILURE (Status))
1938             {
1939                 return;
1940             }
1941
1942             /* Only memory controller subtables are expected at this level */
1943
1944             if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER)
1945             {
1946                 AcpiOsPrintf (
1947                     "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
1948                     MemSubTable->Type);
1949                 return;
1950             }
1951
1952             /* Dump the fixed-length portion of the controller subtable */
1953
1954             Status = AcpiDmDumpTable (Length,
1955                         Offset + MemOffset, MemSubTable,
1956                         MemSubTable->Length, AcpiDmTableInfoPmtt1);
1957             if (ACPI_FAILURE (Status))
1958             {
1959                 return;
1960             }
1961
1962             /* Walk the variable count of proximity domains */
1963
1964             DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount;
1965             DomainOffset = sizeof (ACPI_PMTT_CONTROLLER);
1966             DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable,
1967                 sizeof (ACPI_PMTT_CONTROLLER));
1968
1969             while (((Offset + MemOffset + DomainOffset) < Table->Length) &&
1970                 ((MemOffset + DomainOffset) < SubTable->Length) &&
1971                 DomainCount)
1972             {
1973                 Status = AcpiDmDumpTable (Length,
1974                             Offset + MemOffset + DomainOffset, DomainArray,
1975                             sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
1976                 if (ACPI_FAILURE (Status))
1977                 {
1978                     return;
1979                 }
1980
1981                 DomainOffset += sizeof (ACPI_PMTT_DOMAIN);
1982                 DomainArray++;
1983                 DomainCount--;
1984             }
1985
1986             if (DomainCount)
1987             {
1988                 AcpiOsPrintf (
1989                     "\n**** DomainCount exceeds subtable length\n\n",
1990                     MemSubTable->Type);
1991             }
1992
1993             /* Walk the physical component (DIMM) subtables */
1994
1995             DimmOffset = DomainOffset;
1996             DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable,
1997                 DomainOffset);
1998
1999             while (((Offset + MemOffset + DimmOffset) < Table->Length) &&
2000                 (DimmOffset < MemSubTable->Length))
2001             {
2002                 /* Common subtable header */
2003
2004                 AcpiOsPrintf ("\n");
2005                 Status = AcpiDmDumpTable (Length,
2006                             Offset + MemOffset + DimmOffset, DimmSubTable,
2007                             DimmSubTable->Length, AcpiDmTableInfoPmttHdr);
2008                 if (ACPI_FAILURE (Status))
2009                 {
2010                     return;
2011                 }
2012
2013                 /* Only DIMM subtables are expected at this level */
2014
2015                 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM)
2016                 {
2017                     AcpiOsPrintf (
2018                         "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
2019                         DimmSubTable->Type);
2020                     return;
2021                 }
2022
2023                 /* Dump the fixed-length DIMM subtable */
2024
2025                 Status = AcpiDmDumpTable (Length,
2026                             Offset + MemOffset + DimmOffset, DimmSubTable,
2027                             DimmSubTable->Length, AcpiDmTableInfoPmtt2);
2028                 if (ACPI_FAILURE (Status))
2029                 {
2030                     return;
2031                 }
2032
2033                 /* Point to next DIMM subtable */
2034
2035                 DimmOffset += DimmSubTable->Length;
2036                 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2037                     DimmSubTable, DimmSubTable->Length);
2038             }
2039
2040             /* Point to next Controller subtable */
2041
2042             MemOffset += MemSubTable->Length;
2043             MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2044                 MemSubTable, MemSubTable->Length);
2045         }
2046
2047         /* Point to next Socket subtable */
2048
2049         Offset += SubTable->Length;
2050         SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
2051             SubTable, SubTable->Length);
2052     }
2053 }
2054
2055
2056 /*******************************************************************************
2057  *
2058  * FUNCTION:    AcpiDmDumpS3pt
2059  *
2060  * PARAMETERS:  Table               - A S3PT table
2061  *
2062  * RETURN:      Length of the table
2063  *
2064  * DESCRIPTION: Format the contents of a S3PT
2065  *
2066  ******************************************************************************/
2067
2068 UINT32
2069 AcpiDmDumpS3pt (
2070     ACPI_TABLE_HEADER       *Tables)
2071 {
2072     ACPI_STATUS             Status;
2073     UINT32                  Offset = sizeof (ACPI_TABLE_S3PT);
2074     ACPI_S3PT_HEADER        *SubTable;
2075     ACPI_DMTABLE_INFO       *InfoTable;
2076     ACPI_TABLE_S3PT         *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables);
2077
2078
2079     /* Main table */
2080
2081     Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt);
2082     if (ACPI_FAILURE (Status))
2083     {
2084         return 0;
2085     }
2086
2087     SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, S3ptTable, Offset);
2088     while (Offset < S3ptTable->Length)
2089     {
2090         /* Common sub-table header */
2091
2092         AcpiOsPrintf ("\n");
2093         Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
2094                     SubTable->Length, AcpiDmTableInfoS3ptHdr);
2095         if (ACPI_FAILURE (Status))
2096         {
2097             return 0;
2098         }
2099
2100         switch (SubTable->Type)
2101         {
2102         case ACPI_S3PT_TYPE_RESUME:
2103             InfoTable = AcpiDmTableInfoS3pt0;
2104             break;
2105         case ACPI_S3PT_TYPE_SUSPEND:
2106             InfoTable = AcpiDmTableInfoS3pt1;
2107             break;
2108         default:
2109             AcpiOsPrintf ("\n**** Unknown S3PT sub-table type 0x%X\n", SubTable->Type);
2110
2111             /* Attempt to continue */
2112
2113             if (!SubTable->Length)
2114             {
2115                 AcpiOsPrintf ("Invalid zero length subtable\n");
2116                 return 0;
2117             }
2118             goto NextSubTable;
2119         }
2120
2121         AcpiOsPrintf ("\n");
2122         Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable,
2123                     SubTable->Length, InfoTable);
2124         if (ACPI_FAILURE (Status))
2125         {
2126             return 0;
2127         }
2128
2129 NextSubTable:
2130         /* Point to next sub-table */
2131
2132         Offset += SubTable->Length;
2133         SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, SubTable, SubTable->Length);
2134     }
2135
2136     return (S3ptTable->Length);
2137 }
2138
2139
2140 /*******************************************************************************
2141  *
2142  * FUNCTION:    AcpiDmDumpSlic
2143  *
2144  * PARAMETERS:  Table               - A SLIC table
2145  *
2146  * RETURN:      None
2147  *
2148  * DESCRIPTION: Format the contents of a SLIC
2149  *
2150  ******************************************************************************/
2151
2152 void
2153 AcpiDmDumpSlic (
2154     ACPI_TABLE_HEADER       *Table)
2155 {
2156     ACPI_STATUS             Status;
2157     UINT32                  Offset = sizeof (ACPI_TABLE_SLIC);
2158     ACPI_SLIC_HEADER        *SubTable;
2159     ACPI_DMTABLE_INFO       *InfoTable;
2160
2161
2162     /* There is no main SLIC table, only subtables */
2163
2164     SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, Table, Offset);
2165     while (Offset < Table->Length)
2166     {
2167         /* Common sub-table header */
2168
2169         AcpiOsPrintf ("\n");
2170         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2171                     SubTable->Length, AcpiDmTableInfoSlicHdr);
2172         if (ACPI_FAILURE (Status))
2173         {
2174             return;
2175         }
2176
2177         switch (SubTable->Type)
2178         {
2179         case ACPI_SLIC_TYPE_PUBLIC_KEY:
2180             InfoTable = AcpiDmTableInfoSlic0;
2181             break;
2182         case ACPI_SLIC_TYPE_WINDOWS_MARKER:
2183             InfoTable = AcpiDmTableInfoSlic1;
2184             break;
2185         default:
2186             AcpiOsPrintf ("\n**** Unknown SLIC sub-table type 0x%X\n", SubTable->Type);
2187
2188             /* Attempt to continue */
2189
2190             if (!SubTable->Length)
2191             {
2192                 AcpiOsPrintf ("Invalid zero length subtable\n");
2193                 return;
2194             }
2195             goto NextSubTable;
2196         }
2197
2198         AcpiOsPrintf ("\n");
2199         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2200                     SubTable->Length, InfoTable);
2201         if (ACPI_FAILURE (Status))
2202         {
2203             return;
2204         }
2205
2206 NextSubTable:
2207         /* Point to next sub-table */
2208
2209         Offset += SubTable->Length;
2210         SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, SubTable, SubTable->Length);
2211     }
2212 }
2213
2214
2215 /*******************************************************************************
2216  *
2217  * FUNCTION:    AcpiDmDumpSlit
2218  *
2219  * PARAMETERS:  Table               - An SLIT
2220  *
2221  * RETURN:      None
2222  *
2223  * DESCRIPTION: Format the contents of a SLIT
2224  *
2225  ******************************************************************************/
2226
2227 void
2228 AcpiDmDumpSlit (
2229     ACPI_TABLE_HEADER       *Table)
2230 {
2231     ACPI_STATUS             Status;
2232     UINT32                  Offset;
2233     UINT8                   *Row;
2234     UINT32                  Localities;
2235     UINT32                  i;
2236     UINT32                  j;
2237
2238
2239     /* Main table */
2240
2241     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
2242     if (ACPI_FAILURE (Status))
2243     {
2244         return;
2245     }
2246
2247     /* Display the Locality NxN Matrix */
2248
2249     Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
2250     Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
2251     Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
2252
2253     for (i = 0; i < Localities; i++)
2254     {
2255         /* Display one row of the matrix */
2256
2257         AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
2258         for  (j = 0; j < Localities; j++)
2259         {
2260             /* Check for beyond EOT */
2261
2262             if (Offset >= Table->Length)
2263             {
2264                 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n");
2265                 return;
2266             }
2267
2268             AcpiOsPrintf ("%2.2X", Row[j]);
2269             Offset++;
2270
2271             /* Display up to 16 bytes per output row */
2272
2273             if ((j+1) < Localities)
2274             {
2275                 AcpiOsPrintf (" ");
2276
2277                 if (j && (((j+1) % 16) == 0))
2278                 {
2279                     AcpiOsPrintf ("\\\n"); /* With line continuation char */
2280                     AcpiDmLineHeader (Offset, 0, NULL);
2281                 }
2282             }
2283         }
2284
2285         /* Point to next row */
2286
2287         AcpiOsPrintf ("\n");
2288         Row += Localities;
2289     }
2290 }
2291
2292
2293 /*******************************************************************************
2294  *
2295  * FUNCTION:    AcpiDmDumpSrat
2296  *
2297  * PARAMETERS:  Table               - A SRAT table
2298  *
2299  * RETURN:      None
2300  *
2301  * DESCRIPTION: Format the contents of a SRAT
2302  *
2303  ******************************************************************************/
2304
2305 void
2306 AcpiDmDumpSrat (
2307     ACPI_TABLE_HEADER       *Table)
2308 {
2309     ACPI_STATUS             Status;
2310     UINT32                  Offset = sizeof (ACPI_TABLE_SRAT);
2311     ACPI_SUBTABLE_HEADER    *SubTable;
2312     ACPI_DMTABLE_INFO       *InfoTable;
2313
2314
2315     /* Main table */
2316
2317     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
2318     if (ACPI_FAILURE (Status))
2319     {
2320         return;
2321     }
2322
2323     /* Sub-tables */
2324
2325     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
2326     while (Offset < Table->Length)
2327     {
2328         /* Common sub-table header */
2329
2330         AcpiOsPrintf ("\n");
2331         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2332                     SubTable->Length, AcpiDmTableInfoSratHdr);
2333         if (ACPI_FAILURE (Status))
2334         {
2335             return;
2336         }
2337
2338         switch (SubTable->Type)
2339         {
2340         case ACPI_SRAT_TYPE_CPU_AFFINITY:
2341             InfoTable = AcpiDmTableInfoSrat0;
2342             break;
2343         case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
2344             InfoTable = AcpiDmTableInfoSrat1;
2345             break;
2346         case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
2347             InfoTable = AcpiDmTableInfoSrat2;
2348             break;
2349         default:
2350             AcpiOsPrintf ("\n**** Unknown SRAT sub-table type 0x%X\n", SubTable->Type);
2351
2352             /* Attempt to continue */
2353
2354             if (!SubTable->Length)
2355             {
2356                 AcpiOsPrintf ("Invalid zero length subtable\n");
2357                 return;
2358             }
2359             goto NextSubTable;
2360         }
2361
2362         AcpiOsPrintf ("\n");
2363         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2364                     SubTable->Length, InfoTable);
2365         if (ACPI_FAILURE (Status))
2366         {
2367             return;
2368         }
2369
2370 NextSubTable:
2371         /* Point to next sub-table */
2372
2373         Offset += SubTable->Length;
2374         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
2375     }
2376 }
2377
2378
2379 /*******************************************************************************
2380  *
2381  * FUNCTION:    AcpiDmDumpWdat
2382  *
2383  * PARAMETERS:  Table               - A WDAT table
2384  *
2385  * RETURN:      None
2386  *
2387  * DESCRIPTION: Format the contents of a WDAT
2388  *
2389  ******************************************************************************/
2390
2391 void
2392 AcpiDmDumpWdat (
2393     ACPI_TABLE_HEADER       *Table)
2394 {
2395     ACPI_STATUS             Status;
2396     UINT32                  Offset = sizeof (ACPI_TABLE_WDAT);
2397     ACPI_WDAT_ENTRY         *SubTable;
2398
2399
2400     /* Main table */
2401
2402     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat);
2403     if (ACPI_FAILURE (Status))
2404     {
2405         return;
2406     }
2407
2408     /* Sub-tables */
2409
2410     SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset);
2411     while (Offset < Table->Length)
2412     {
2413         /* Common sub-table header */
2414
2415         AcpiOsPrintf ("\n");
2416         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
2417                     sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0);
2418         if (ACPI_FAILURE (Status))
2419         {
2420             return;
2421         }
2422
2423         /* Point to next sub-table */
2424
2425         Offset += sizeof (ACPI_WDAT_ENTRY);
2426         SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY));
2427     }
2428 }