sys/contrib/dev/acpica/common/dmtable.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dmtable - Support for ACPI tables that contain no AML code
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights.  You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code.  No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision.  In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change.  Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee.  Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution.  In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government.  In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116 #include <contrib/dev/acpica/include/acpi.h>
 117 #include <contrib/dev/acpica/include/accommon.h>
 118 #include <contrib/dev/acpica/include/acdisasm.h>
 119 #include <contrib/dev/acpica/include/actables.h>
 120 #include <contrib/dev/acpica/compiler/aslcompiler.h>
 121 #include <contrib/dev/acpica/compiler/dtcompiler.h>
 122
 123 /* This module used for application-level code only */
 124
 125 #define _COMPONENT          ACPI_CA_DISASSEMBLER
 126         ACPI_MODULE_NAME    ("dmtable")
 127
 128 /* Local Prototypes */
 129
 130 static void
 131 AcpiDmCheckAscii (
 132     UINT8                   *Target,
 133     char                    *RepairedName,
 134     UINT32                  Count);
 135
 136
 137 /* These tables map a subtable type to a description string */
 138
 139 static const char           *AcpiDmAsfSubnames[] =
 140 {
 141     "ASF Information",
 142     "ASF Alerts",
 143     "ASF Remote Control",
 144     "ASF RMCP Boot Options",
 145     "ASF Address",
 146     "Unknown SubTable Type"         /* Reserved */
 147 };
 148
 149 static const char           *AcpiDmDmarSubnames[] =
 150 {
 151     "Hardware Unit Definition",
 152     "Reserved Memory Region",
 153     "Root Port ATS Capability",
 154     "Remapping Hardware Static Affinity",
 155     "Unknown SubTable Type"         /* Reserved */
 156 };
 157
 158 static const char           *AcpiDmEinjActions[] =
 159 {
 160     "Begin Operation",
 161     "Get Trigger Table",
 162     "Set Error Type",
 163     "Get Error Type",
 164     "End Operation",
 165     "Execute Operation",
 166     "Check Busy Status",
 167     "Get Command Status",
 168     "Unknown Action"
 169 };
 170
 171 static const char           *AcpiDmEinjInstructions[] =
 172 {
 173     "Read Register",
 174     "Read Register Value",
 175     "Write Register",
 176     "Write Register Value",
 177     "Noop",
 178     "Unknown Instruction"
 179 };
 180
 181 static const char           *AcpiDmErstActions[] =
 182 {
 183     "Begin Write Operation",
 184     "Begin Read Operation",
 185     "Begin Clear Operation",
 186     "End Operation",
 187     "Set Record Offset",
 188     "Execute Operation",
 189     "Check Busy Status",
 190     "Get Command Status",
 191     "Get Record Identifier",
 192     "Set Record Identifier",
 193     "Get Record Count",
 194     "Begin Dummy Write",
 195     "Unused/Unknown Action",
 196     "Get Error Address Range",
 197     "Get Error Address Length",
 198     "Get Error Attributes",
 199     "Unknown Action"
 200 };
 201
 202 static const char           *AcpiDmErstInstructions[] =
 203 {
 204     "Read Register",
 205     "Read Register Value",
 206     "Write Register",
 207     "Write Register Value",
 208     "Noop",
 209     "Load Var1",
 210     "Load Var2",
 211     "Store Var1",
 212     "Add",
 213     "Subtract",
 214     "Add Value",
 215     "Subtract Value",
 216     "Stall",
 217     "Stall While True",
 218     "Skip Next If True",
 219     "GoTo",
 220     "Set Source Address",
 221     "Set Destination Address",
 222     "Move Data",
 223     "Unknown Instruction"
 224 };
 225
 226 static const char           *AcpiDmHestSubnames[] =
 227 {
 228     "IA-32 Machine Check Exception",
 229     "IA-32 Corrected Machine Check",
 230     "IA-32 Non-Maskable Interrupt",
 231     "Unknown SubTable Type",        /* 3 - Reserved */
 232     "Unknown SubTable Type",        /* 4 - Reserved */
 233     "Unknown SubTable Type",        /* 5 - Reserved */
 234     "PCI Express Root Port AER",
 235     "PCI Express AER (AER Endpoint)",
 236     "PCI Express/PCI-X Bridge AER",
 237     "Generic Hardware Error Source",
 238     "Unknown SubTable Type"         /* Reserved */
 239 };
 240
 241 static const char           *AcpiDmHestNotifySubnames[] =
 242 {
 243     "Polled",
 244     "External Interrupt",
 245     "Local Interrupt",
 246     "SCI",
 247     "NMI",
 248     "Unknown Notify Type"           /* Reserved */
 249 };
 250
 251 static const char           *AcpiDmMadtSubnames[] =
 252 {
 253     "Processor Local APIC",         /* ACPI_MADT_TYPE_LOCAL_APIC */
 254     "I/O APIC",                     /* ACPI_MADT_TYPE_IO_APIC */
 255     "Interrupt Source Override",    /* ACPI_MADT_TYPE_INTERRUPT_OVERRIDE */
 256     "NMI Source",                   /* ACPI_MADT_TYPE_NMI_SOURCE */
 257     "Local APIC NMI",               /* ACPI_MADT_TYPE_LOCAL_APIC_NMI */
 258     "Local APIC Address Override",  /* ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE */
 259     "I/O SAPIC",                    /* ACPI_MADT_TYPE_IO_SAPIC */
 260     "Local SAPIC",                  /* ACPI_MADT_TYPE_LOCAL_SAPIC */
 261     "Platform Interrupt Sources",   /* ACPI_MADT_TYPE_INTERRUPT_SOURCE */
 262     "Processor Local x2APIC",       /* ACPI_MADT_TYPE_LOCAL_X2APIC */
 263     "Local x2APIC NMI",             /* ACPI_MADT_TYPE_LOCAL_X2APIC_NMI */
 264     "Unknown SubTable Type"         /* Reserved */
 265 };
 266
 267 static const char           *AcpiDmSratSubnames[] =
 268 {
 269     "Processor Local APIC/SAPIC Affinity",
 270     "Memory Affinity",
 271     "Processor Local x2APIC Affinity",
 272     "Unknown SubTable Type"         /* Reserved */
 273 };
 274
 275 static const char           *AcpiDmIvrsSubnames[] =
 276 {
 277     "Hardware Definition Block",
 278     "Memory Definition Block",
 279     "Unknown SubTable Type"         /* Reserved */
 280 };
 281
 282
 283 #define ACPI_FADT_PM_RESERVED       8
 284
 285 static const char           *AcpiDmFadtProfiles[] =
 286 {
 287     "Unspecified",
 288     "Desktop",
 289     "Mobile",
 290     "Workstation",
 291     "Enterprise Server",
 292     "SOHO Server",
 293     "Appliance PC",
 294     "Performance Server",
 295     "Unknown Profile Type"
 296 };
 297
 298 /*******************************************************************************
 299  *
 300  * ACPI Table Data, indexed by signature.
 301  *
 302  * Each entry contains: Signature, Table Info, Handler, DtHandler,
 303  *  Template, Description
 304  *
 305  * Simple tables have only a TableInfo structure, complex tables have a
 306  * handler. This table must be NULL terminated. RSDP and FACS are
 307  * special-cased elsewhere.
 308  *
 309  ******************************************************************************/
 310
 311 ACPI_DMTABLE_DATA    AcpiDmTableData[] =
 312 {
 313     {ACPI_SIG_ASF,  NULL,                   AcpiDmDumpAsf,  DtCompileAsf,   TemplateAsf,    "Alert Standard Format table"},
 314     {ACPI_SIG_BOOT, AcpiDmTableInfoBoot,    NULL,           NULL,           TemplateBoot,   "Simple Boot Flag Table"},
 315     {ACPI_SIG_BERT, AcpiDmTableInfoBert,    NULL,           NULL,           TemplateBert,   "Boot Error Record Table"},
 316     {ACPI_SIG_CPEP, NULL,                   AcpiDmDumpCpep, DtCompileCpep,  TemplateCpep,   "Corrected Platform Error Polling table"},
 317     {ACPI_SIG_DBGP, AcpiDmTableInfoDbgp,    NULL,           NULL,           TemplateDbgp,   "Debug Port table"},
 318     {ACPI_SIG_DMAR, NULL,                   AcpiDmDumpDmar, DtCompileDmar,  TemplateDmar,   "DMA Remapping table"},
 319     {ACPI_SIG_ECDT, AcpiDmTableInfoEcdt,    NULL,           NULL,           TemplateEcdt,   "Embedded Controller Boot Resources Table"},
 320     {ACPI_SIG_EINJ, NULL,                   AcpiDmDumpEinj, DtCompileEinj,  TemplateEinj,   "Error Injection table"},
 321     {ACPI_SIG_ERST, NULL,                   AcpiDmDumpErst, DtCompileErst,  TemplateErst,   "Error Record Serialization Table"},
 322     {ACPI_SIG_FADT, NULL,                   AcpiDmDumpFadt, DtCompileFadt,  TemplateFadt,   "Fixed ACPI Description Table"},
 323     {ACPI_SIG_HEST, NULL,                   AcpiDmDumpHest, DtCompileHest,  TemplateHest,   "Hardware Error Source Table"},
 324     {ACPI_SIG_HPET, AcpiDmTableInfoHpet,    NULL,           NULL,           TemplateHpet,   "High Precision Event Timer table"},
 325     {ACPI_SIG_IVRS, NULL,                   AcpiDmDumpIvrs, DtCompileIvrs,  TemplateIvrs,   "I/O Virtualization Reporting Structure"},
 326     {ACPI_SIG_MADT, NULL,                   AcpiDmDumpMadt, DtCompileMadt,  TemplateMadt,   "Multiple APIC Description Table"},
 327     {ACPI_SIG_MCFG, NULL,                   AcpiDmDumpMcfg, DtCompileMcfg,  TemplateMcfg,   "Memory Mapped Configuration table"},
 328     {ACPI_SIG_MCHI, AcpiDmTableInfoMchi,    NULL,           NULL,           TemplateMchi,   "Management Controller Host Interface table"},
 329     {ACPI_SIG_MSCT, NULL,                   AcpiDmDumpMsct, DtCompileMsct,  TemplateMsct,   "Maximum System Characteristics Table"},
 330     {ACPI_SIG_RSDT, NULL,                   AcpiDmDumpRsdt, DtCompileRsdt,  TemplateRsdt,   "Root System Description Table"},
 331     {ACPI_SIG_SBST, AcpiDmTableInfoSbst,    NULL,           NULL,           TemplateSbst,   "Smart Battery Specification Table"},
 332     {ACPI_SIG_SLIC, AcpiDmTableInfoSlic,    NULL,           NULL,           NULL,           "Software Licensing Description Table"},
 333     {ACPI_SIG_SLIT, NULL,                   AcpiDmDumpSlit, DtCompileSlit,  TemplateSlit,   "System Locality Information Table"},
 334     {ACPI_SIG_SPCR, AcpiDmTableInfoSpcr,    NULL,           NULL,           TemplateSpcr,   "Serial Port Console Redirection table"},
 335     {ACPI_SIG_SPMI, AcpiDmTableInfoSpmi,    NULL,           NULL,           TemplateSpmi,   "Server Platform Management Interface table"},
 336     {ACPI_SIG_SRAT, NULL,                   AcpiDmDumpSrat, DtCompileSrat,  TemplateSrat,   "System Resource Affinity Table"},
 337     {ACPI_SIG_TCPA, AcpiDmTableInfoTcpa,    NULL,           NULL,           TemplateTcpa,   "Trusted Computing Platform Alliance table"},
 338     {ACPI_SIG_UEFI, AcpiDmTableInfoUefi,    NULL,           NULL,           TemplateUefi,   "UEFI Boot Optimization Table"},
 339     {ACPI_SIG_WAET, AcpiDmTableInfoWaet,    NULL,           NULL,           TemplateWaet,   "Windows ACPI Emulated Devices Table"},
 340     {ACPI_SIG_WDAT, NULL,                   AcpiDmDumpWdat, DtCompileWdat,  TemplateWdat,   "Watchdog Action Table"},
 341     {ACPI_SIG_WDDT, AcpiDmTableInfoWddt,    NULL,           NULL,           TemplateWddt,   "Watchdog Description Table"},
 342     {ACPI_SIG_WDRT, AcpiDmTableInfoWdrt,    NULL,           NULL,           TemplateWdrt,   "Watchdog Resource Table"},
 343     {ACPI_SIG_XSDT, NULL,                   AcpiDmDumpXsdt, DtCompileXsdt,  TemplateXsdt,   "Extended System Description Table"},
 344     {NULL,          NULL,                   NULL,           NULL,           NULL,           NULL}
 345 };
 346
 347
 348 /*******************************************************************************
 349  *
 350  * FUNCTION:    AcpiDmGenerateChecksum
 351  *
 352  * PARAMETERS:  Table               - Pointer to table to be checksummed
 353  *              Length              - Length of the table
 354  *              OriginalChecksum    - Value of the checksum field
 355  *
 356  * RETURN:      8 bit checksum of buffer
 357  *
 358  * DESCRIPTION: Computes an 8 bit checksum of the table.
 359  *
 360  ******************************************************************************/
 361
 362 UINT8
 363 AcpiDmGenerateChecksum (
 364     void                    *Table,
 365     UINT32                  Length,
 366     UINT8                   OriginalChecksum)
 367 {
 368     UINT8                   Checksum;
 369
 370
 371     /* Sum the entire table as-is */
 372
 373     Checksum = AcpiTbChecksum ((UINT8 *) Table, Length);
 374
 375     /* Subtract off the existing checksum value in the table */
 376
 377     Checksum = (UINT8) (Checksum - OriginalChecksum);
 378
 379     /* Compute the final checksum */
 380
 381     Checksum = (UINT8) (0 - Checksum);
 382     return (Checksum);
 383 }
 384
 385
 386 /*******************************************************************************
 387  *
 388  * FUNCTION:    AcpiDmGetTableData
 389  *
 390  * PARAMETERS:  Signature           - ACPI signature (4 chars) to match
 391  *
 392  * RETURN:      Pointer to a valid ACPI_DMTABLE_DATA. Null if no match found.
 393  *
 394  * DESCRIPTION: Find a match in the global table of supported ACPI tables
 395  *
 396  ******************************************************************************/
 397
 398 ACPI_DMTABLE_DATA *
 399 AcpiDmGetTableData (
 400     char                    *Signature)
 401 {
 402     ACPI_DMTABLE_DATA       *TableData;
 403
 404
 405     for (TableData = AcpiDmTableData; TableData->Signature; TableData++)
 406     {
 407         if (ACPI_COMPARE_NAME (Signature, TableData->Signature))
 408         {
 409             return (TableData);
 410         }
 411     }
 412
 413     return (NULL);
 414 }
 415
 416
 417 /*******************************************************************************
 418  *
 419  * FUNCTION:    AcpiDmDumpDataTable
 420  *
 421  * PARAMETERS:  Table               - An ACPI table
 422  *
 423  * RETURN:      None.
 424  *
 425  * DESCRIPTION: Format the contents of an ACPI data table (any table other
 426  *              than an SSDT or DSDT that does not contain executable AML code)
 427  *
 428  ******************************************************************************/
 429
 430 void
 431 AcpiDmDumpDataTable (
 432     ACPI_TABLE_HEADER       *Table)
 433 {
 434     ACPI_STATUS             Status;
 435     ACPI_DMTABLE_DATA       *TableData;
 436     UINT32                  Length;
 437
 438
 439     /* Ignore tables that contain AML */
 440
 441     if (AcpiUtIsAmlTable (Table))
 442     {
 443         return;
 444     }
 445
 446     /*
 447      * Handle tables that don't use the common ACPI table header structure.
 448      * Currently, these are the FACS and RSDP.
 449      */
 450     if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FACS))
 451     {
 452         Length = Table->Length;
 453         AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoFacs);
 454     }
 455     else if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_RSDP))
 456     {
 457         Length = AcpiDmDumpRsdp (Table);
 458     }
 459     else
 460     {
 461         /*
 462          * All other tables must use the common ACPI table header, dump it now
 463          */
 464         Length = Table->Length;
 465         Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHeader);
 466         if (ACPI_FAILURE (Status))
 467         {
 468             return;
 469         }
 470         AcpiOsPrintf ("\n");
 471
 472         /* Match signature and dispatch appropriately */
 473
 474         TableData = AcpiDmGetTableData (Table->Signature);
 475         if (!TableData)
 476         {
 477             if (!ACPI_STRNCMP (Table->Signature, "OEM", 3))
 478             {
 479                 AcpiOsPrintf ("\n**** OEM-defined ACPI table [%4.4s], unknown contents\n\n",
 480                     Table->Signature);
 481             }
 482             else
 483             {
 484                 AcpiOsPrintf ("\n**** Unknown ACPI table type [%4.4s]\n\n",
 485                     Table->Signature);
 486             }
 487         }
 488         else if (TableData->TableHandler)
 489         {
 490             /* Complex table, has a handler */
 491
 492             TableData->TableHandler (Table);
 493         }
 494         else if (TableData->TableInfo)
 495         {
 496             /* Simple table, just walk the info table */
 497
 498             AcpiDmDumpTable (Length, 0, Table, 0, TableData->TableInfo);
 499         }
 500     }
 501
 502     if (!Gbl_DoTemplates || Gbl_VerboseTemplates)
 503     {
 504         /* Dump the raw table data */
 505
 506         AcpiOsPrintf ("\nRaw Table Data\n\n");
 507         AcpiUtDumpBuffer2 (ACPI_CAST_PTR (UINT8, Table), Length, DB_BYTE_DISPLAY);
 508     }
 509 }
 510
 511
 512 /*******************************************************************************
 513  *
 514  * FUNCTION:    AcpiDmLineHeader
 515  *
 516  * PARAMETERS:  Offset              - Current byte offset, from table start
 517  *              ByteLength          - Length of the field in bytes, 0 for flags
 518  *              Name                - Name of this field
 519  *              Value               - Optional value, displayed on left of ':'
 520  *
 521  * RETURN:      None
 522  *
 523  * DESCRIPTION: Utility routines for formatting output lines. Displays the
 524  *              current table offset in hex and decimal, the field length,
 525  *              and the field name.
 526  *
 527  ******************************************************************************/
 528
 529 void
 530 AcpiDmLineHeader (
 531     UINT32                  Offset,
 532     UINT32                  ByteLength,
 533     char                    *Name)
 534 {
 535
 536     if (Gbl_DoTemplates && !Gbl_VerboseTemplates) /* Terse template */
 537     {
 538         if (ByteLength)
 539         {
 540             AcpiOsPrintf ("[%.3d] %34s : ",
 541                 ByteLength, Name);
 542         }
 543         else
 544         {
 545             AcpiOsPrintf ("%40s : ",
 546                 Name);
 547         }
 548     }
 549     else /* Normal disassembler or verbose template */
 550     {
 551         if (ByteLength)
 552         {
 553             AcpiOsPrintf ("[%3.3Xh %4.4d% 3d] %28s : ",
 554                 Offset, Offset, ByteLength, Name);
 555         }
 556         else
 557         {
 558             AcpiOsPrintf ("%43s : ",
 559                 Name);
 560         }
 561     }
 562 }
 563
 564 void
 565 AcpiDmLineHeader2 (
 566     UINT32                  Offset,
 567     UINT32                  ByteLength,
 568     char                    *Name,
 569     UINT32                  Value)
 570 {
 571
 572     if (Gbl_DoTemplates && !Gbl_VerboseTemplates) /* Terse template */
 573     {
 574         if (ByteLength)
 575         {
 576             AcpiOsPrintf ("[%.3d] %30s % 3d : ",
 577                 ByteLength, Name, Value);
 578         }
 579         else
 580         {
 581             AcpiOsPrintf ("%36s % 3d : ",
 582                 Name, Value);
 583         }
 584     }
 585     else /* Normal disassembler or verbose template */
 586     {
 587         if (ByteLength)
 588         {
 589             AcpiOsPrintf ("[%3.3Xh %4.4d% 3d] %24s % 3d : ",
 590                 Offset, Offset, ByteLength, Name, Value);
 591         }
 592         else
 593         {
 594             AcpiOsPrintf ("[%3.3Xh %4.4d   ] %24s % 3d : ",
 595                 Offset, Offset, Name, Value);
 596         }
 597     }
 598 }
 599
 600
 601 /*******************************************************************************
 602  *
 603  * FUNCTION:    AcpiDmDumpTable
 604  *
 605  * PARAMETERS:  TableLength         - Length of the entire ACPI table
 606  *              TableOffset         - Starting offset within the table for this
 607  *                                    sub-descriptor (0 if main table)
 608  *              Table               - The ACPI table
 609  *              SubtableLength      - Length of this sub-descriptor
 610  *              Info                - Info table for this ACPI table
 611  *
 612  * RETURN:      None
 613  *
 614  * DESCRIPTION: Display ACPI table contents by walking the Info table.
 615  *
 616  * Note: This function must remain in sync with DtGetFieldLength.
 617  *
 618  ******************************************************************************/
 619
 620 ACPI_STATUS
 621 AcpiDmDumpTable (
 622     UINT32                  TableLength,
 623     UINT32                  TableOffset,
 624     void                    *Table,
 625     UINT32                  SubtableLength,
 626     ACPI_DMTABLE_INFO       *Info)
 627 {
 628     UINT8                   *Target;
 629     UINT32                  CurrentOffset;
 630     UINT32                  ByteLength;
 631     UINT8                   Temp8;
 632     UINT16                  Temp16;
 633     ACPI_DMTABLE_DATA       *TableData;
 634     const char              *Name;
 635     BOOLEAN                 LastOutputBlankLine = FALSE;
 636     char                    RepairedName[8];
 637
 638
 639     if (!Info)
 640     {
 641         AcpiOsPrintf ("Display not implemented\n");
 642         return (AE_NOT_IMPLEMENTED);
 643     }
 644
 645     /* Walk entire Info table; Null name terminates */
 646
 647     for (; Info->Name; Info++)
 648     {
 649         /*
 650          * Target points to the field within the ACPI Table. CurrentOffset is
 651          * the offset of the field from the start of the main table.
 652          */
 653         Target = ACPI_ADD_PTR (UINT8, Table, Info->Offset);
 654         CurrentOffset = TableOffset + Info->Offset;
 655
 656         /* Check for beyond EOT or beyond subtable end */
 657
 658         if ((CurrentOffset >= TableLength) ||
 659             (SubtableLength && (Info->Offset >= SubtableLength)))
 660         {
 661             AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
 662             return (AE_BAD_DATA);
 663         }
 664
 665         /* Generate the byte length for this field */
 666
 667         switch (Info->Opcode)
 668         {
 669         case ACPI_DMT_UINT8:
 670         case ACPI_DMT_CHKSUM:
 671         case ACPI_DMT_SPACEID:
 672         case ACPI_DMT_IVRS:
 673         case ACPI_DMT_MADT:
 674         case ACPI_DMT_SRAT:
 675         case ACPI_DMT_ASF:
 676         case ACPI_DMT_HESTNTYP:
 677         case ACPI_DMT_FADTPM:
 678         case ACPI_DMT_EINJACT:
 679         case ACPI_DMT_EINJINST:
 680         case ACPI_DMT_ERSTACT:
 681         case ACPI_DMT_ERSTINST:
 682             ByteLength = 1;
 683             break;
 684         case ACPI_DMT_UINT16:
 685         case ACPI_DMT_DMAR:
 686         case ACPI_DMT_HEST:
 687             ByteLength = 2;
 688             break;
 689         case ACPI_DMT_UINT24:
 690             ByteLength = 3;
 691             break;
 692         case ACPI_DMT_UINT32:
 693         case ACPI_DMT_NAME4:
 694         case ACPI_DMT_SIG:
 695             ByteLength = 4;
 696             break;
 697         case ACPI_DMT_NAME6:
 698             ByteLength = 6;
 699             break;
 700         case ACPI_DMT_UINT56:
 701             ByteLength = 7;
 702             break;
 703         case ACPI_DMT_UINT64:
 704         case ACPI_DMT_NAME8:
 705             ByteLength = 8;
 706             break;
 707         case ACPI_DMT_BUF16:
 708             ByteLength = 16;
 709             break;
 710         case ACPI_DMT_STRING:
 711             ByteLength = ACPI_STRLEN (ACPI_CAST_PTR (char, Target)) + 1;
 712             break;
 713         case ACPI_DMT_GAS:
 714             if (!LastOutputBlankLine)
 715             {
 716                 AcpiOsPrintf ("\n");
 717                 LastOutputBlankLine = TRUE;
 718             }
 719             ByteLength = sizeof (ACPI_GENERIC_ADDRESS);
 720             break;
 721         case ACPI_DMT_HESTNTFY:
 722             if (!LastOutputBlankLine)
 723             {
 724                 AcpiOsPrintf ("\n");
 725                 LastOutputBlankLine = TRUE;
 726             }
 727             ByteLength = sizeof (ACPI_HEST_NOTIFY);
 728             break;
 729         default:
 730             ByteLength = 0;
 731             break;
 732         }
 733
 734         if (CurrentOffset + ByteLength > TableLength)
 735         {
 736             AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
 737             return (AE_BAD_DATA);
 738         }
 739
 740         /* Start a new line and decode the opcode */
 741
 742         AcpiDmLineHeader (CurrentOffset, ByteLength, Info->Name);
 743
 744         switch (Info->Opcode)
 745         {
 746         /* Single-bit Flag fields. Note: Opcode is the bit position */
 747
 748         case ACPI_DMT_FLAG0:
 749         case ACPI_DMT_FLAG1:
 750         case ACPI_DMT_FLAG2:
 751         case ACPI_DMT_FLAG3:
 752         case ACPI_DMT_FLAG4:
 753         case ACPI_DMT_FLAG5:
 754         case ACPI_DMT_FLAG6:
 755         case ACPI_DMT_FLAG7:
 756
 757             AcpiOsPrintf ("%1.1X\n", (*Target >> Info->Opcode) & 0x01);
 758             break;
 759
 760         /* 2-bit Flag fields */
 761
 762         case ACPI_DMT_FLAGS0:
 763
 764             AcpiOsPrintf ("%1.1X\n", *Target & 0x03);
 765             break;
 766
 767         case ACPI_DMT_FLAGS2:
 768
 769             AcpiOsPrintf ("%1.1X\n", (*Target >> 2) & 0x03);
 770             break;
 771
 772         /* Standard Data Types */
 773
 774         case ACPI_DMT_UINT8:
 775
 776             AcpiOsPrintf ("%2.2X\n", *Target);
 777             break;
 778
 779         case ACPI_DMT_UINT16:
 780
 781             AcpiOsPrintf ("%4.4X\n", ACPI_GET16 (Target));
 782             break;
 783
 784         case ACPI_DMT_UINT24:
 785
 786             AcpiOsPrintf ("%2.2X%2.2X%2.2X\n",
 787                 *Target, *(Target + 1), *(Target + 2));
 788             break;
 789
 790         case ACPI_DMT_UINT32:
 791
 792             AcpiOsPrintf ("%8.8X\n", ACPI_GET32 (Target));
 793             break;
 794
 795         case ACPI_DMT_UINT56:
 796
 797             for (Temp8 = 0; Temp8 < 7; Temp8++)
 798             {
 799                 AcpiOsPrintf ("%2.2X", Target[Temp8]);
 800             }
 801             AcpiOsPrintf ("\n");
 802             break;
 803
 804         case ACPI_DMT_UINT64:
 805
 806             AcpiOsPrintf ("%8.8X%8.8X\n",
 807                 ACPI_FORMAT_UINT64 (ACPI_GET64 (Target)));
 808             break;
 809
 810         case ACPI_DMT_BUF16:
 811
 812             /* Buffer of length 16 */
 813
 814             for (Temp8 = 0; Temp8 < 16; Temp8++)
 815             {
 816                 AcpiOsPrintf ("%2.2X", Target[Temp8]);
 817                 if ((Temp8 + 1) < 16)
 818                 {
 819                     AcpiOsPrintf (",");
 820                 }
 821             }
 822             AcpiOsPrintf ("\n");
 823             break;
 824
 825         case ACPI_DMT_STRING:
 826
 827             AcpiOsPrintf ("\"%s\"\n", ACPI_CAST_PTR (char, Target));
 828             break;
 829
 830         /* Fixed length ASCII name fields */
 831
 832         case ACPI_DMT_SIG:
 833
 834             AcpiDmCheckAscii (Target, RepairedName, 4);
 835             AcpiOsPrintf ("\"%.4s\"    ", RepairedName);
 836             TableData = AcpiDmGetTableData (ACPI_CAST_PTR (char, Target));
 837             if (TableData)
 838             {
 839                 AcpiOsPrintf ("/* %s */", TableData->Name);
 840             }
 841             AcpiOsPrintf ("\n");
 842             break;
 843
 844         case ACPI_DMT_NAME4:
 845
 846             AcpiDmCheckAscii (Target, RepairedName, 4);
 847             AcpiOsPrintf ("\"%.4s\"\n", RepairedName);
 848             break;
 849
 850         case ACPI_DMT_NAME6:
 851
 852             AcpiDmCheckAscii (Target, RepairedName, 6);
 853             AcpiOsPrintf ("\"%.6s\"\n", RepairedName);
 854             break;
 855
 856         case ACPI_DMT_NAME8:
 857
 858             AcpiDmCheckAscii (Target, RepairedName, 8);
 859             AcpiOsPrintf ("\"%.8s\"\n", RepairedName);
 860             break;
 861
 862         /* Special Data Types */
 863
 864         case ACPI_DMT_CHKSUM:
 865
 866             /* Checksum, display and validate */
 867
 868             AcpiOsPrintf ("%2.2X", *Target);
 869             Temp8 = AcpiDmGenerateChecksum (Table,
 870                         ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Length,
 871                         ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum);
 872             if (Temp8 != ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum)
 873             {
 874                 AcpiOsPrintf (
 875                     "     /* Incorrect checksum, should be %2.2X */", Temp8);
 876             }
 877             AcpiOsPrintf ("\n");
 878             break;
 879
 880         case ACPI_DMT_SPACEID:
 881
 882             /* Address Space ID */
 883
 884             AcpiOsPrintf ("%2.2X (%s)\n", *Target, AcpiUtGetRegionName (*Target));
 885             break;
 886
 887         case ACPI_DMT_GAS:
 888
 889             /* Generic Address Structure */
 890
 891             AcpiOsPrintf ("<Generic Address Structure>\n");
 892             AcpiDmDumpTable (TableLength, CurrentOffset, Target,
 893                 sizeof (ACPI_GENERIC_ADDRESS), AcpiDmTableInfoGas);
 894             AcpiOsPrintf ("\n");
 895             LastOutputBlankLine = TRUE;
 896             break;
 897
 898         case ACPI_DMT_ASF:
 899
 900             /* ASF subtable types */
 901
 902             Temp16 = (UINT16) ((*Target) & 0x7F);  /* Top bit can be zero or one */
 903             if (Temp16 > ACPI_ASF_TYPE_RESERVED)
 904             {
 905                 Temp16 = ACPI_ASF_TYPE_RESERVED;
 906             }
 907
 908             AcpiOsPrintf ("%2.2X <%s>\n", *Target, AcpiDmAsfSubnames[Temp16]);
 909             break;
 910
 911         case ACPI_DMT_DMAR:
 912
 913             /* DMAR subtable types */
 914
 915             Temp16 = ACPI_GET16 (Target);
 916             if (Temp16 > ACPI_DMAR_TYPE_RESERVED)
 917             {
 918                 Temp16 = ACPI_DMAR_TYPE_RESERVED;
 919             }
 920
 921             AcpiOsPrintf ("%4.4X <%s>\n", ACPI_GET16 (Target), AcpiDmDmarSubnames[Temp16]);
 922             break;
 923
 924         case ACPI_DMT_EINJACT:
 925
 926             /* EINJ Action types */
 927
 928             Temp8 = *Target;
 929             if (Temp8 > ACPI_EINJ_ACTION_RESERVED)
 930             {
 931                 Temp8 = ACPI_EINJ_ACTION_RESERVED;
 932             }
 933
 934             AcpiOsPrintf ("%2.2X (%s)\n", *Target, AcpiDmEinjActions[Temp8]);
 935             break;
 936
 937         case ACPI_DMT_EINJINST:
 938
 939             /* EINJ Instruction types */
 940
 941             Temp8 = *Target;
 942             if (Temp8 > ACPI_EINJ_INSTRUCTION_RESERVED)
 943             {
 944                 Temp8 = ACPI_EINJ_INSTRUCTION_RESERVED;
 945             }
 946
 947             AcpiOsPrintf ("%2.2X (%s)\n", *Target, AcpiDmEinjInstructions[Temp8]);
 948             break;
 949
 950         case ACPI_DMT_ERSTACT:
 951
 952             /* ERST Action types */
 953
 954             Temp8 = *Target;
 955             if (Temp8 > ACPI_ERST_ACTION_RESERVED)
 956             {
 957                 Temp8 = ACPI_ERST_ACTION_RESERVED;
 958             }
 959
 960             AcpiOsPrintf ("%2.2X (%s)\n", *Target, AcpiDmErstActions[Temp8]);
 961             break;
 962
 963         case ACPI_DMT_ERSTINST:
 964
 965             /* ERST Instruction types */
 966
 967             Temp8 = *Target;
 968             if (Temp8 > ACPI_ERST_INSTRUCTION_RESERVED)
 969             {
 970                 Temp8 = ACPI_ERST_INSTRUCTION_RESERVED;
 971             }
 972
 973             AcpiOsPrintf ("%2.2X (%s)\n", *Target, AcpiDmErstInstructions[Temp8]);
 974             break;
 975
 976         case ACPI_DMT_HEST:
 977
 978             /* HEST subtable types */
 979
 980             Temp16 = ACPI_GET16 (Target);
 981             if (Temp16 > ACPI_HEST_TYPE_RESERVED)
 982             {
 983                 Temp16 = ACPI_HEST_TYPE_RESERVED;
 984             }
 985
 986             AcpiOsPrintf ("%4.4X (%s)\n", ACPI_GET16 (Target), AcpiDmHestSubnames[Temp16]);
 987             break;
 988
 989         case ACPI_DMT_HESTNTFY:
 990
 991             AcpiOsPrintf ("<Hardware Error Notification Structure>\n");
 992             AcpiDmDumpTable (TableLength, CurrentOffset, Target,
 993                 sizeof (ACPI_HEST_NOTIFY), AcpiDmTableInfoHestNotify);
 994             AcpiOsPrintf ("\n");
 995             LastOutputBlankLine = TRUE;
 996             break;
 997
 998         case ACPI_DMT_HESTNTYP:
 999
1000             /* HEST Notify types */
1001
1002             Temp8 = *Target;
1003             if (Temp8 > ACPI_HEST_NOTIFY_RESERVED)
1004             {
1005                 Temp8 = ACPI_HEST_NOTIFY_RESERVED;
1006             }
1007
1008             AcpiOsPrintf ("%2.2X (%s)\n", *Target, AcpiDmHestNotifySubnames[Temp8]);
1009             break;
1010
1011         case ACPI_DMT_MADT:
1012
1013             /* MADT subtable types */
1014
1015             Temp8 = *Target;
1016             if (Temp8 > ACPI_MADT_TYPE_RESERVED)
1017             {
1018                 Temp8 = ACPI_MADT_TYPE_RESERVED;
1019             }
1020
1021             AcpiOsPrintf ("%2.2X <%s>\n", *Target, AcpiDmMadtSubnames[Temp8]);
1022             break;
1023
1024         case ACPI_DMT_SRAT:
1025
1026             /* SRAT subtable types */
1027
1028             Temp8 = *Target;
1029             if (Temp8 > ACPI_SRAT_TYPE_RESERVED)
1030             {
1031                 Temp8 = ACPI_SRAT_TYPE_RESERVED;
1032             }
1033
1034             AcpiOsPrintf ("%2.2X <%s>\n", *Target, AcpiDmSratSubnames[Temp8]);
1035             break;
1036
1037         case ACPI_DMT_FADTPM:
1038
1039             /* FADT Preferred PM Profile names */
1040
1041             Temp8 = *Target;
1042             if (Temp8 > ACPI_FADT_PM_RESERVED)
1043             {
1044                 Temp8 = ACPI_FADT_PM_RESERVED;
1045             }
1046
1047             AcpiOsPrintf ("%2.2X (%s)\n", *Target, AcpiDmFadtProfiles[Temp8]);
1048             break;
1049
1050         case ACPI_DMT_IVRS:
1051
1052             /* IVRS subtable types */
1053
1054             Temp8 = *Target;
1055             switch (Temp8)
1056             {
1057             case ACPI_IVRS_TYPE_HARDWARE:
1058                 Name = AcpiDmIvrsSubnames[0];
1059                 break;
1060
1061             case ACPI_IVRS_TYPE_MEMORY1:
1062             case ACPI_IVRS_TYPE_MEMORY2:
1063             case ACPI_IVRS_TYPE_MEMORY3:
1064                 Name = AcpiDmIvrsSubnames[1];
1065                 break;
1066
1067             default:
1068                 Name = AcpiDmIvrsSubnames[2];
1069                 break;
1070             }
1071
1072             AcpiOsPrintf ("%2.2X <%s>\n", *Target, Name);
1073             break;
1074
1075         case ACPI_DMT_EXIT:
1076             return (AE_OK);
1077
1078         default:
1079             ACPI_ERROR ((AE_INFO,
1080                 "**** Invalid table opcode [0x%X] ****\n", Info->Opcode));
1081             return (AE_SUPPORT);
1082         }
1083     }
1084
1085     if (TableOffset && !SubtableLength)
1086     {
1087         /* If this table is not the main table, subtable must have valid length */
1088
1089         AcpiOsPrintf ("Invalid zero length subtable\n");
1090         return (AE_BAD_DATA);
1091     }
1092
1093     return (AE_OK);
1094 }
1095
1096
1097 /*******************************************************************************
1098  *
1099  * FUNCTION:    AcpiDmCheckAscii
1100  *
1101  * PARAMETERS:  Name                - Ascii string
1102  *              Count               - Number of characters to check
1103  *
1104  * RETURN:      None
1105  *
1106  * DESCRIPTION: Ensure that the requested number of characters are printable
1107  *              Ascii characters. Sets non-printable and null chars to <space>.
1108  *
1109  ******************************************************************************/
1110
1111 static void
1112 AcpiDmCheckAscii (
1113     UINT8                   *Name,
1114     char                    *RepairedName,
1115     UINT32                  Count)
1116 {
1117     UINT32                  i;
1118
1119
1120     for (i = 0; i < Count; i++)
1121     {
1122         RepairedName[i] = (char) Name[i];
1123
1124         if (!Name[i])
1125         {
1126             return;
1127         }
1128         if (!isprint (Name[i]))
1129         {
1130             RepairedName[i] = ' ';
1131         }
1132     }
1133 }