sys/contrib/dev/acpica-unix/common/dmtbdump.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights.  You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code.  No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision.  In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change.  Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee.  Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution.  In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government.  In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116 #include "acpi.h"
 117 #include "accommon.h"
 118 #include "acdisasm.h"
 119 #include "actables.h"
 120
 121 /* This module used for application-level code only */
 122
 123 #define _COMPONENT          ACPI_CA_DISASSEMBLER
 124         ACPI_MODULE_NAME    ("dmtbdump")
 125
 126
 127 /*******************************************************************************
 128  *
 129  * FUNCTION:    AcpiDmDumpRsdp
 130  *
 131  * PARAMETERS:  Table               - A RSDP
 132  *
 133  * RETURN:      Length of the table (there is no length field, use revision)
 134  *
 135  * DESCRIPTION: Format the contents of a RSDP
 136  *
 137  ******************************************************************************/
 138
 139 UINT32
 140 AcpiDmDumpRsdp (
 141     ACPI_TABLE_HEADER       *Table)
 142 {
 143     UINT32                  Length = ACPI_RSDP_REV0_SIZE;
 144
 145
 146     /* Dump the common ACPI 1.0 portion */
 147
 148     AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1);
 149
 150     /* ACPI 2.0+ contains more data and has a Length field */
 151
 152     if (ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table)->Revision > 0)
 153     {
 154         Length = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table)->Length;
 155         AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2);
 156     }
 157
 158     return (Length);
 159 }
 160
 161
 162 /*******************************************************************************
 163  *
 164  * FUNCTION:    AcpiDmDumpRsdt
 165  *
 166  * PARAMETERS:  Table               - A RSDT
 167  *
 168  * RETURN:      None
 169  *
 170  * DESCRIPTION: Format the contents of a RSDT
 171  *
 172  ******************************************************************************/
 173
 174 void
 175 AcpiDmDumpRsdt (
 176     ACPI_TABLE_HEADER       *Table)
 177 {
 178     UINT32                  *Array;
 179     UINT32                  Entries;
 180     UINT32                  Offset;
 181     UINT32                  i;
 182
 183
 184     /* Point to start of table pointer array */
 185
 186     Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry;
 187     Offset = sizeof (ACPI_TABLE_HEADER);
 188
 189     /* RSDT uses 32-bit pointers */
 190
 191     Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32);
 192
 193     for (i = 0; i < Entries; i++)
 194     {
 195         AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i);
 196         AcpiOsPrintf ("%8.8X\n", Array[i]);
 197         Offset += sizeof (UINT32);
 198     }
 199 }
 200
 201
 202 /*******************************************************************************
 203  *
 204  * FUNCTION:    AcpiDmDumpXsdt
 205  *
 206  * PARAMETERS:  Table               - A XSDT
 207  *
 208  * RETURN:      None
 209  *
 210  * DESCRIPTION: Format the contents of a XSDT
 211  *
 212  ******************************************************************************/
 213
 214 void
 215 AcpiDmDumpXsdt (
 216     ACPI_TABLE_HEADER       *Table)
 217 {
 218     UINT64                  *Array;
 219     UINT32                  Entries;
 220     UINT32                  Offset;
 221     UINT32                  i;
 222
 223
 224     /* Point to start of table pointer array */
 225
 226     Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry;
 227     Offset = sizeof (ACPI_TABLE_HEADER);
 228
 229     /* XSDT uses 64-bit pointers */
 230
 231     Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64);
 232
 233     for (i = 0; i < Entries; i++)
 234     {
 235         AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i);
 236         AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i]));
 237         Offset += sizeof (UINT64);
 238     }
 239 }
 240
 241
 242 /*******************************************************************************
 243  *
 244  * FUNCTION:    AcpiDmDumpFadt
 245  *
 246  * PARAMETERS:  Table               - A FADT
 247  *
 248  * RETURN:      None
 249  *
 250  * DESCRIPTION: Format the contents of a FADT
 251  *
 252  ******************************************************************************/
 253
 254 void
 255 AcpiDmDumpFadt (
 256     ACPI_TABLE_HEADER       *Table)
 257 {
 258
 259     /* Common ACPI 1.0 portion of FADT */
 260
 261     AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1);
 262
 263     /* Check for ACPI 1.0B MS extensions (FADT revision 2) */
 264
 265     if (Table->Revision == 2)
 266     {
 267         AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2);
 268     }
 269
 270     /* Check for ACPI 2.0+ extended data (FADT revision 3+) */
 271
 272     else if (Table->Length >= sizeof (ACPI_TABLE_FADT))
 273     {
 274         AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3);
 275     }
 276
 277     /* Validate various fields in the FADT, including length */
 278
 279     AcpiTbCreateLocalFadt (Table, Table->Length);
 280 }
 281
 282
 283 /*******************************************************************************
 284  *
 285  * FUNCTION:    AcpiDmDumpAsf
 286  *
 287  * PARAMETERS:  Table               - A ASF table
 288  *
 289  * RETURN:      None
 290  *
 291  * DESCRIPTION: Format the contents of a ASF table
 292  *
 293  ******************************************************************************/
 294
 295 void
 296 AcpiDmDumpAsf (
 297     ACPI_TABLE_HEADER       *Table)
 298 {
 299     ACPI_STATUS             Status;
 300     UINT32                  Offset = sizeof (ACPI_TABLE_HEADER);
 301     ACPI_ASF_INFO           *SubTable;
 302     ACPI_DMTABLE_INFO       *InfoTable;
 303     ACPI_DMTABLE_INFO       *DataInfoTable = NULL;
 304     UINT8                   *DataTable = NULL;
 305     UINT32                  DataCount = 0;
 306     UINT32                  DataLength = 0;
 307     UINT32                  DataOffset = 0;
 308     UINT32                  i;
 309
 310
 311     /* No main table, only sub-tables */
 312
 313     SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset);
 314     while (Offset < Table->Length)
 315     {
 316         /* Common sub-table header */
 317
 318         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
 319                     SubTable->Header.Length, AcpiDmTableInfoAsfHdr);
 320         if (ACPI_FAILURE (Status))
 321         {
 322             return;
 323         }
 324
 325         switch (SubTable->Header.Type & 0x7F) /* Mask off top bit */
 326         {
 327         case ACPI_ASF_TYPE_INFO:
 328             InfoTable = AcpiDmTableInfoAsf0;
 329             break;
 330
 331         case ACPI_ASF_TYPE_ALERT:
 332             InfoTable = AcpiDmTableInfoAsf1;
 333             DataInfoTable = AcpiDmTableInfoAsf1a;
 334             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT));
 335             DataCount = ((ACPI_ASF_ALERT *) SubTable)->Alerts;
 336             DataLength = ((ACPI_ASF_ALERT *) SubTable)->DataLength;
 337             DataOffset = Offset + sizeof (ACPI_ASF_ALERT);
 338             break;
 339
 340         case ACPI_ASF_TYPE_CONTROL:
 341             InfoTable = AcpiDmTableInfoAsf2;
 342             DataInfoTable = AcpiDmTableInfoAsf2a;
 343             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE));
 344             DataCount = ((ACPI_ASF_REMOTE *) SubTable)->Controls;
 345             DataLength = ((ACPI_ASF_REMOTE *) SubTable)->DataLength;
 346             DataOffset = Offset + sizeof (ACPI_ASF_REMOTE);
 347             break;
 348
 349         case ACPI_ASF_TYPE_BOOT:
 350             InfoTable = AcpiDmTableInfoAsf3;
 351             break;
 352
 353         case ACPI_ASF_TYPE_ADDRESS:
 354             InfoTable = AcpiDmTableInfoAsf4;
 355             DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS));
 356             DataLength = ((ACPI_ASF_ADDRESS *) SubTable)->Devices;
 357             DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS);
 358             break;
 359
 360         default:
 361             AcpiOsPrintf ("\n**** Unknown ASF sub-table type %X\n", SubTable->Header.Type);
 362             return;
 363         }
 364
 365         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
 366                     SubTable->Header.Length, InfoTable);
 367         if (ACPI_FAILURE (Status))
 368         {
 369             return;
 370         }
 371
 372         /* Dump variable-length extra data */
 373
 374         switch (SubTable->Header.Type & 0x7F) /* Mask off top bit */
 375         {
 376         case ACPI_ASF_TYPE_ALERT:
 377         case ACPI_ASF_TYPE_CONTROL:
 378
 379             for (i = 0; i < DataCount; i++)
 380             {
 381                 AcpiOsPrintf ("\n");
 382                 Status = AcpiDmDumpTable (Table->Length, DataOffset,
 383                             DataTable, DataLength, DataInfoTable);
 384                 if (ACPI_FAILURE (Status))
 385                 {
 386                     return;
 387                 }
 388
 389                 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength);
 390                 DataOffset += DataLength;
 391             }
 392             break;
 393
 394         case ACPI_ASF_TYPE_ADDRESS:
 395
 396             for (i = 0; i < DataLength; i++)
 397             {
 398                 if (!(i % 16))
 399                 {
 400                     AcpiDmLineHeader (DataOffset, 1, "Addresses");
 401                 }
 402
 403                 AcpiOsPrintf ("%2.2X ", *DataTable);
 404                 DataTable++;
 405                 DataOffset++;
 406                 if (DataOffset > Table->Length)
 407                 {
 408                     AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
 409                     return;
 410                 }
 411             }
 412
 413             AcpiOsPrintf ("\n");
 414             break;
 415
 416         default:
 417             break;
 418         }
 419
 420         AcpiOsPrintf ("\n");
 421
 422         /* Point to next sub-table */
 423
 424         if (!SubTable->Header.Length)
 425         {
 426             AcpiOsPrintf ("Invalid zero subtable header length\n");
 427             return;
 428         }
 429
 430         Offset += SubTable->Header.Length;
 431         SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length);
 432     }
 433 }
 434
 435
 436 /*******************************************************************************
 437  *
 438  * FUNCTION:    AcpiDmDumpCpep
 439  *
 440  * PARAMETERS:  Table               - A CPEP table
 441  *
 442  * RETURN:      None
 443  *
 444  * DESCRIPTION: Format the contents of a CPEP. This table type consists
 445  *              of an open-ended number of subtables.
 446  *
 447  ******************************************************************************/
 448
 449 void
 450 AcpiDmDumpCpep (
 451     ACPI_TABLE_HEADER       *Table)
 452 {
 453     ACPI_STATUS             Status;
 454     ACPI_CPEP_POLLING       *SubTable;
 455     UINT32                  Length = Table->Length;
 456     UINT32                  Offset = sizeof (ACPI_TABLE_CPEP);
 457
 458
 459     /* Main table */
 460
 461     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep);
 462     if (ACPI_FAILURE (Status))
 463     {
 464         return;
 465     }
 466
 467     /* Sub-tables */
 468
 469     SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset);
 470     while (Offset < Table->Length)
 471     {
 472         AcpiOsPrintf ("\n");
 473         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 474                     SubTable->Length, AcpiDmTableInfoCpep0);
 475         if (ACPI_FAILURE (Status))
 476         {
 477             return;
 478         }
 479
 480         /* Point to next sub-table */
 481
 482         Offset += SubTable->Length;
 483         SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable, SubTable->Length);
 484     }
 485 }
 486
 487
 488 /*******************************************************************************
 489  *
 490  * FUNCTION:    AcpiDmDumpDmar
 491  *
 492  * PARAMETERS:  Table               - A DMAR table
 493  *
 494  * RETURN:      None
 495  *
 496  * DESCRIPTION: Format the contents of a DMAR. This table type consists
 497  *              of an open-ended number of subtables.
 498  *
 499  ******************************************************************************/
 500
 501 void
 502 AcpiDmDumpDmar (
 503     ACPI_TABLE_HEADER       *Table)
 504 {
 505     ACPI_STATUS             Status;
 506     ACPI_DMAR_HEADER        *SubTable;
 507     UINT32                  Length = Table->Length;
 508     UINT32                  Offset = sizeof (ACPI_TABLE_DMAR);
 509     ACPI_DMTABLE_INFO       *InfoTable;
 510     ACPI_DMAR_DEVICE_SCOPE  *ScopeTable;
 511     UINT32                  ScopeOffset;
 512     UINT8                   *PciPath;
 513     UINT32                  PathOffset;
 514
 515
 516     /* Main table */
 517
 518     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar);
 519     if (ACPI_FAILURE (Status))
 520     {
 521         return;
 522     }
 523
 524     /* Sub-tables */
 525
 526     SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset);
 527     while (Offset < Table->Length)
 528     {
 529         /* Common sub-table header */
 530
 531         AcpiOsPrintf ("\n");
 532         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 533                     SubTable->Length, AcpiDmTableInfoDmarHdr);
 534         if (ACPI_FAILURE (Status))
 535         {
 536             return;
 537         }
 538
 539         switch (SubTable->Type)
 540         {
 541         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
 542             InfoTable = AcpiDmTableInfoDmar0;
 543             ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT);
 544             break;
 545         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
 546             InfoTable = AcpiDmTableInfoDmar1;
 547             ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY);
 548             break;
 549         case ACPI_DMAR_TYPE_ATSR:
 550             InfoTable = AcpiDmTableInfoDmar2;
 551             ScopeOffset = sizeof (ACPI_DMAR_ATSR);
 552             break;
 553         default:
 554             AcpiOsPrintf ("\n**** Unknown DMAR sub-table type %X\n\n", SubTable->Type);
 555             return;
 556         }
 557
 558         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 559                     SubTable->Length, InfoTable);
 560         if (ACPI_FAILURE (Status))
 561         {
 562             return;
 563         }
 564
 565         /* Dump the device scope entries (if any) */
 566
 567         ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset);
 568         while (ScopeOffset < SubTable->Length)
 569         {
 570             AcpiOsPrintf ("\n");
 571             Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable,
 572                         ScopeTable->Length, AcpiDmTableInfoDmarScope);
 573             if (ACPI_FAILURE (Status))
 574             {
 575                 return;
 576             }
 577
 578             /* Dump the PCI Path entries for this device scope */
 579
 580             PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */
 581
 582             PciPath = ACPI_ADD_PTR (UINT8, ScopeTable,
 583                 sizeof (ACPI_DMAR_DEVICE_SCOPE));
 584
 585             while (PathOffset < ScopeTable->Length)
 586             {
 587                 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path");
 588                 AcpiOsPrintf ("[%2.2X, %2.2X]\n", PciPath[0], PciPath[1]);
 589
 590                 /* Point to next PCI Path entry */
 591
 592                 PathOffset += 2;
 593                 PciPath += 2;
 594             }
 595
 596             /* Point to next device scope entry */
 597
 598             ScopeOffset += ScopeTable->Length;
 599             ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE,
 600                 ScopeTable, ScopeTable->Length);
 601         }
 602
 603         /* Point to next sub-table */
 604
 605         Offset += SubTable->Length;
 606         SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length);
 607     }
 608 }
 609
 610
 611 /*******************************************************************************
 612  *
 613  * FUNCTION:    AcpiDmDumpEinj
 614  *
 615  * PARAMETERS:  Table               - A EINJ table
 616  *
 617  * RETURN:      None
 618  *
 619  * DESCRIPTION: Format the contents of a EINJ. This table type consists
 620  *              of an open-ended number of subtables.
 621  *
 622  ******************************************************************************/
 623
 624 void
 625 AcpiDmDumpEinj (
 626     ACPI_TABLE_HEADER       *Table)
 627 {
 628     ACPI_STATUS             Status;
 629     ACPI_WHEA_HEADER        *SubTable;
 630     UINT32                  Length = Table->Length;
 631     UINT32                  Offset = sizeof (ACPI_TABLE_EINJ);
 632
 633
 634     /* Main table */
 635
 636     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj);
 637     if (ACPI_FAILURE (Status))
 638     {
 639         return;
 640     }
 641
 642     /* Sub-tables */
 643
 644     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
 645     while (Offset < Table->Length)
 646     {
 647         AcpiOsPrintf ("\n");
 648         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 649                     sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
 650         if (ACPI_FAILURE (Status))
 651         {
 652             return;
 653         }
 654
 655         /* Point to next sub-table (each subtable is of fixed length) */
 656
 657         Offset += sizeof (ACPI_WHEA_HEADER);
 658         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
 659                         sizeof (ACPI_WHEA_HEADER));
 660     }
 661 }
 662
 663
 664 /*******************************************************************************
 665  *
 666  * FUNCTION:    AcpiDmDumpErst
 667  *
 668  * PARAMETERS:  Table               - A ERST table
 669  *
 670  * RETURN:      None
 671  *
 672  * DESCRIPTION: Format the contents of a ERST. This table type consists
 673  *              of an open-ended number of subtables.
 674  *
 675  ******************************************************************************/
 676
 677 void
 678 AcpiDmDumpErst (
 679     ACPI_TABLE_HEADER       *Table)
 680 {
 681     ACPI_STATUS             Status;
 682     ACPI_WHEA_HEADER        *SubTable;
 683     UINT32                  Length = Table->Length;
 684     UINT32                  Offset = sizeof (ACPI_TABLE_ERST);
 685
 686
 687     /* Main table */
 688
 689     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst);
 690     if (ACPI_FAILURE (Status))
 691     {
 692         return;
 693     }
 694
 695     /* Sub-tables */
 696
 697     SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset);
 698     while (Offset < Table->Length)
 699     {
 700         AcpiOsPrintf ("\n");
 701         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 702                     sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0);
 703         if (ACPI_FAILURE (Status))
 704         {
 705             return;
 706         }
 707
 708         /* Point to next sub-table (each subtable is of fixed length) */
 709
 710         Offset += sizeof (ACPI_WHEA_HEADER);
 711         SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable,
 712                         sizeof (ACPI_WHEA_HEADER));
 713     }
 714 }
 715
 716
 717 /*******************************************************************************
 718  *
 719  * FUNCTION:    AcpiDmDumpHest
 720  *
 721  * PARAMETERS:  Table               - A HEST table
 722  *
 723  * RETURN:      None
 724  *
 725  * DESCRIPTION: Format the contents of a HEST. This table type consists
 726  *              of an open-ended number of subtables.
 727  *
 728  ******************************************************************************/
 729
 730 void
 731 AcpiDmDumpHest (
 732     ACPI_TABLE_HEADER       *Table)
 733 {
 734     ACPI_STATUS             Status;
 735     ACPI_HEST_HEADER        *SubTable;
 736     UINT32                  Length = Table->Length;
 737     UINT32                  Offset = sizeof (ACPI_TABLE_HEST);
 738     ACPI_DMTABLE_INFO       *InfoTable;
 739     UINT32                  SubTableLength;
 740
 741
 742     /* Main table */
 743
 744     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest);
 745     if (ACPI_FAILURE (Status))
 746     {
 747         return;
 748     }
 749
 750     /* Sub-tables */
 751
 752     SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset);
 753     while (Offset < Table->Length)
 754     {
 755         switch (SubTable->Type)
 756         {
 757         case ACPI_HEST_TYPE_XPF_MACHINE_CHECK:
 758             InfoTable = AcpiDmTableInfoHest0;
 759             SubTableLength = sizeof (ACPI_HEST_XPF_MACHINE_CHECK);
 760             break;
 761
 762         case ACPI_HEST_TYPE_XPF_CORRECTED_MACHINE_CHECK:
 763             InfoTable = AcpiDmTableInfoHest1;
 764             SubTableLength = sizeof (ACPI_HEST_XPF_CORRECTED);
 765             break;
 766
 767         case ACPI_HEST_TYPE_XPF_NON_MASKABLE_INTERRUPT:
 768             InfoTable = AcpiDmTableInfoHest3;
 769             SubTableLength = sizeof (ACPI_HEST_XPF_NMI);
 770             break;
 771
 772         case ACPI_HEST_TYPE_IPF_CORRECTED_MACHINE_CHECK:
 773             InfoTable = AcpiDmTableInfoHest4;
 774             SubTableLength = sizeof (ACPI_HEST_IPF_CORRECTED);
 775             break;
 776
 777         case ACPI_HEST_TYPE_IPF_CORRECTED_PLATFORM_ERROR:
 778             InfoTable = AcpiDmTableInfoHest5;
 779             SubTableLength = sizeof (ACPI_HEST_IPF_CORRECTED_PLATFORM);
 780             break;
 781
 782         case ACPI_HEST_TYPE_AER_ROOT_PORT:
 783             InfoTable = AcpiDmTableInfoHest6;
 784             SubTableLength = sizeof (ACPI_HEST_AER_ROOT);
 785             break;
 786
 787         case ACPI_HEST_TYPE_AER_ENDPOINT:
 788             InfoTable = AcpiDmTableInfoHest7;
 789             SubTableLength = sizeof (ACPI_HEST_AER);
 790             break;
 791
 792         case ACPI_HEST_TYPE_AER_BRIDGE:
 793             InfoTable = AcpiDmTableInfoHest8;
 794             SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE);
 795             break;
 796
 797         case ACPI_HEST_TYPE_GENERIC_HARDWARE_ERROR_SOURCE:
 798             InfoTable = AcpiDmTableInfoHest9;
 799             SubTableLength = sizeof (ACPI_HEST_GENERIC);
 800             break;
 801
 802         default:
 803             /* Cannot continue on unknown type - no length */
 804
 805             AcpiOsPrintf ("\n**** Unknown HEST sub-table type %X\n", SubTable->Type);
 806             return;
 807         }
 808
 809         AcpiOsPrintf ("\n");
 810         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 811                     SubTableLength, InfoTable);
 812         if (ACPI_FAILURE (Status))
 813         {
 814             return;
 815         }
 816
 817         /* Point to next sub-table (each subtable is of fixed length) */
 818
 819         Offset += SubTableLength;
 820         SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength);
 821     }
 822 }
 823
 824
 825 /*******************************************************************************
 826  *
 827  * FUNCTION:    AcpiDmDumpMadt
 828  *
 829  * PARAMETERS:  Table               - A MADT table
 830  *
 831  * RETURN:      None
 832  *
 833  * DESCRIPTION: Format the contents of a MADT. This table type consists
 834  *              of an open-ended number of subtables.
 835  *
 836  ******************************************************************************/
 837
 838 void
 839 AcpiDmDumpMadt (
 840     ACPI_TABLE_HEADER       *Table)
 841 {
 842     ACPI_STATUS             Status;
 843     ACPI_SUBTABLE_HEADER    *SubTable;
 844     UINT32                  Length = Table->Length;
 845     UINT32                  Offset = sizeof (ACPI_TABLE_MADT);
 846     ACPI_DMTABLE_INFO       *InfoTable;
 847
 848
 849     /* Main table */
 850
 851     Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt);
 852     if (ACPI_FAILURE (Status))
 853     {
 854         return;
 855     }
 856
 857     /* Sub-tables */
 858
 859     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
 860     while (Offset < Table->Length)
 861     {
 862         /* Common sub-table header */
 863
 864         AcpiOsPrintf ("\n");
 865         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 866                     SubTable->Length, AcpiDmTableInfoMadtHdr);
 867         if (ACPI_FAILURE (Status))
 868         {
 869             return;
 870         }
 871
 872         switch (SubTable->Type)
 873         {
 874         case ACPI_MADT_TYPE_LOCAL_APIC:
 875             InfoTable = AcpiDmTableInfoMadt0;
 876             break;
 877         case ACPI_MADT_TYPE_IO_APIC:
 878             InfoTable = AcpiDmTableInfoMadt1;
 879             break;
 880         case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
 881             InfoTable = AcpiDmTableInfoMadt2;
 882             break;
 883         case ACPI_MADT_TYPE_NMI_SOURCE:
 884             InfoTable = AcpiDmTableInfoMadt3;
 885             break;
 886         case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
 887             InfoTable = AcpiDmTableInfoMadt4;
 888             break;
 889         case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
 890             InfoTable = AcpiDmTableInfoMadt5;
 891             break;
 892         case ACPI_MADT_TYPE_IO_SAPIC:
 893             InfoTable = AcpiDmTableInfoMadt6;
 894             break;
 895         case ACPI_MADT_TYPE_LOCAL_SAPIC:
 896             InfoTable = AcpiDmTableInfoMadt7;
 897             break;
 898         case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
 899             InfoTable = AcpiDmTableInfoMadt8;
 900             break;
 901         case ACPI_MADT_TYPE_LOCAL_X2APIC:
 902             InfoTable = AcpiDmTableInfoMadt9;
 903             break;
 904         case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
 905             InfoTable = AcpiDmTableInfoMadt10;
 906             break;
 907         default:
 908             AcpiOsPrintf ("\n**** Unknown MADT sub-table type %X\n\n", SubTable->Type);
 909
 910             /* Attempt to continue */
 911
 912             if (!SubTable->Length)
 913             {
 914                 AcpiOsPrintf ("Invalid zero length subtable\n");
 915                 return;
 916             }
 917             goto NextSubTable;
 918         }
 919
 920         Status = AcpiDmDumpTable (Length, Offset, SubTable,
 921                     SubTable->Length, InfoTable);
 922         if (ACPI_FAILURE (Status))
 923         {
 924             return;
 925         }
 926
 927 NextSubTable:
 928         /* Point to next sub-table */
 929
 930         Offset += SubTable->Length;
 931         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
 932     }
 933 }
 934
 935
 936 /*******************************************************************************
 937  *
 938  * FUNCTION:    AcpiDmDumpMcfg
 939  *
 940  * PARAMETERS:  Table               - A MCFG Table
 941  *
 942  * RETURN:      None
 943  *
 944  * DESCRIPTION: Format the contents of a MCFG table
 945  *
 946  ******************************************************************************/
 947
 948 void
 949 AcpiDmDumpMcfg (
 950     ACPI_TABLE_HEADER       *Table)
 951 {
 952     ACPI_STATUS             Status;
 953     UINT32                  Offset = sizeof (ACPI_TABLE_MCFG);
 954     ACPI_MCFG_ALLOCATION    *SubTable;
 955
 956
 957     /* Main table */
 958
 959     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg);
 960     if (ACPI_FAILURE (Status))
 961     {
 962         return;
 963     }
 964
 965     /* Sub-tables */
 966
 967     SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset);
 968     while (Offset < Table->Length)
 969     {
 970         if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length)
 971         {
 972             AcpiOsPrintf ("Warning: there are %d invalid trailing bytes\n",
 973                 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length));
 974             return;
 975         }
 976
 977         AcpiOsPrintf ("\n");
 978         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
 979                     sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0);
 980         if (ACPI_FAILURE (Status))
 981         {
 982             return;
 983         }
 984
 985         /* Point to next sub-table (each subtable is of fixed length) */
 986
 987         Offset += sizeof (ACPI_MCFG_ALLOCATION);
 988         SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable,
 989                         sizeof (ACPI_MCFG_ALLOCATION));
 990     }
 991 }
 992
 993
 994 /*******************************************************************************
 995  *
 996  * FUNCTION:    AcpiDmDumpSlit
 997  *
 998  * PARAMETERS:  Table               - An SLIT
 999  *
1000  * RETURN:      None
1001  *
1002  * DESCRIPTION: Format the contents of a SLIT
1003  *
1004  ******************************************************************************/
1005
1006 void
1007 AcpiDmDumpSlit (
1008     ACPI_TABLE_HEADER       *Table)
1009 {
1010     ACPI_STATUS             Status;
1011     UINT32                  Offset;
1012     UINT8                   *Row;
1013     UINT32                  Localities;
1014     UINT32                  i;
1015     UINT32                  j;
1016
1017
1018     /* Main table */
1019
1020     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit);
1021     if (ACPI_FAILURE (Status))
1022     {
1023         return;
1024     }
1025
1026     /* Display the Locality NxN Matrix */
1027
1028     Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount;
1029     Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]);
1030     Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry;
1031
1032     for (i = 0; i < Localities; i++)
1033     {
1034         /* Display one row of the matrix */
1035
1036         AcpiDmLineHeader2 (Offset, Localities, "Locality", i);
1037         for  (j = 0; j < Localities; j++)
1038         {
1039             /* Check for beyond EOT */
1040
1041             if (Offset >= Table->Length)
1042             {
1043                 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n");
1044                 return;
1045             }
1046
1047             AcpiOsPrintf ("%2.2X ", Row[j]);
1048             Offset++;
1049
1050             /* Display up to 16 bytes per output row */
1051
1052             if (j && (((j+1) % 16) == 0) && ((j+1) < Localities))
1053             {
1054                 AcpiOsPrintf ("\n");
1055                 AcpiDmLineHeader (Offset, 0, "");
1056             }
1057         }
1058
1059         /* Point to next row */
1060
1061         AcpiOsPrintf ("\n");
1062         Row += Localities;
1063     }
1064 }
1065
1066
1067 /*******************************************************************************
1068  *
1069  * FUNCTION:    AcpiDmDumpSrat
1070  *
1071  * PARAMETERS:  Table               - A SRAT table
1072  *
1073  * RETURN:      None
1074  *
1075  * DESCRIPTION: Format the contents of a SRAT
1076  *
1077  ******************************************************************************/
1078
1079 void
1080 AcpiDmDumpSrat (
1081     ACPI_TABLE_HEADER       *Table)
1082 {
1083     ACPI_STATUS             Status;
1084     UINT32                  Offset = sizeof (ACPI_TABLE_SRAT);
1085     ACPI_SUBTABLE_HEADER    *SubTable;
1086     ACPI_DMTABLE_INFO       *InfoTable;
1087
1088
1089     /* Main table */
1090
1091     Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat);
1092     if (ACPI_FAILURE (Status))
1093     {
1094         return;
1095     }
1096
1097     /* Sub-tables */
1098
1099     SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset);
1100     while (Offset < Table->Length)
1101     {
1102         /* Common sub-table header */
1103
1104         AcpiOsPrintf ("\n");
1105         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1106                     SubTable->Length, AcpiDmTableInfoSratHdr);
1107         if (ACPI_FAILURE (Status))
1108         {
1109             return;
1110         }
1111
1112         switch (SubTable->Type)
1113         {
1114         case ACPI_SRAT_TYPE_CPU_AFFINITY:
1115             InfoTable = AcpiDmTableInfoSrat0;
1116             break;
1117         case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
1118             InfoTable = AcpiDmTableInfoSrat1;
1119             break;
1120         case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
1121             InfoTable = AcpiDmTableInfoSrat2;
1122             break;
1123         default:
1124             AcpiOsPrintf ("\n**** Unknown SRAT sub-table type %X\n", SubTable->Type);
1125
1126             /* Attempt to continue */
1127
1128             if (!SubTable->Length)
1129             {
1130                 AcpiOsPrintf ("Invalid zero length subtable\n");
1131                 return;
1132             }
1133             goto NextSubTable;
1134         }
1135
1136         AcpiOsPrintf ("\n");
1137         Status = AcpiDmDumpTable (Table->Length, Offset, SubTable,
1138                     SubTable->Length, InfoTable);
1139         if (ACPI_FAILURE (Status))
1140         {
1141             return;
1142         }
1143
1144 NextSubTable:
1145         /* Point to next sub-table */
1146
1147         Offset += SubTable->Length;
1148         SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length);
1149     }
1150 }
1151