sys/contrib/dev/acpica/source/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 - 2021, 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  * Alternatively, you may choose to be licensed under the terms of the
 117  * following license:
 118  *
 119  * Redistribution and use in source and binary forms, with or without
 120  * modification, are permitted provided that the following conditions
 121  * are met:
 122  * 1. Redistributions of source code must retain the above copyright
 123  *    notice, this list of conditions, and the following disclaimer,
 124  *    without modification.
 125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 126  *    substantially similar to the "NO WARRANTY" disclaimer below
 127  *    ("Disclaimer") and any redistribution must be conditioned upon
 128  *    including a substantially similar Disclaimer requirement for further
 129  *    binary redistribution.
 130  * 3. Neither the names of the above-listed copyright holders nor the names
 131  *    of any contributors may be used to endorse or promote products derived
 132  *    from this software without specific prior written permission.
 133  *
 134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 145  *
 146  * Alternatively, you may choose to be licensed under the terms of the
 147  * GNU General Public License ("GPL") version 2 as published by the Free
 148  * Software Foundation.
 149  *
 150  *****************************************************************************/
 151
 152 #include "acpi.h"
 153 #include "accommon.h"
 154 #include "acdisasm.h"
 155 #include "actables.h"
 156 #include "aslcompiler.h"
 157
 158 /* This module used for application-level code only */
 159
 160 #define _COMPONENT          ACPI_CA_DISASSEMBLER
 161         ACPI_MODULE_NAME    ("dmtable")
 162
 163 const AH_TABLE *
 164 AcpiAhGetTableInfo (
 165     char                    *Signature);
 166
 167
 168 /* Common format strings for commented values */
 169
 170 #define UINT8_FORMAT            "%2.2X [%s]\n"
 171 #define UINT8_FORMAT_NO_NEWLINE "%2.2X [%s]"
 172 #define UINT16_FORMAT           "%4.4X [%s]\n"
 173 #define UINT32_FORMAT           "%8.8X [%s]\n"
 174 #define STRING_FORMAT           "[%s]\n"
 175
 176 /* These tables map a subtable type to a description string */
 177
 178 static const char           *AcpiDmAestResourceNames[] =
 179 {
 180     "Cache Resource",
 181     "TLB Resource",
 182     "Generic Resource",
 183     "Unknown Resource Type"         /* Reserved */
 184 };
 185
 186 static const char           *AcpiDmAestSubnames[] =
 187 {
 188     "Processor Error Node",
 189     "Memory Error Node",
 190     "SMMU Error Node",
 191     "Vendor-defined Error Node",
 192     "GIC Error Node",
 193     "Unknown Subtable Type"         /* Reserved */
 194 };
 195
 196 static const char           *AcpiDmAestCacheNames[] =
 197 {
 198     "Data Cache",
 199     "Instruction Cache",
 200     "Unified Cache",
 201     "Unknown Cache Type"            /* Reserved */
 202 };
 203
 204 static const char           *AcpiDmAestGicNames[] =
 205 {
 206     "GIC CPU",
 207     "GIC Distributor",
 208     "GIC Redistributor",
 209     "GIC ITS",
 210     "Unknown GIC Interface Type"    /* Reserved */
 211 };
 212
 213 static const char           *AcpiDmAestXfaceNames[] =
 214 {
 215     "System Register Interface",
 216     "Memory Mapped Interface",
 217     "Unknown Interface Type"        /* Reserved */
 218 };
 219
 220 static const char           *AcpiDmAestXruptNames[] =
 221 {
 222     "Fault Handling Interrupt",
 223     "Error Recovery Interrupt",
 224     "Unknown Interrupt Type"        /* Reserved */
 225 };
 226
 227 static const char           *AcpiDmAsfSubnames[] =
 228 {
 229     "ASF Information",
 230     "ASF Alerts",
 231     "ASF Remote Control",
 232     "ASF RMCP Boot Options",
 233     "ASF Address",
 234     "Unknown Subtable Type"         /* Reserved */
 235 };
 236
 237 static const char           *AcpiDmCedtSubnames[] =
 238 {
 239     "CXL Host Bridge Structure",
 240     "CXL Fixed Memory Window Structure",
 241     "Unknown Subtable Type"         /* Reserved */
 242 };
 243
 244 static const char           *AcpiDmDmarSubnames[] =
 245 {
 246     "Hardware Unit Definition",
 247     "Reserved Memory Region",
 248     "Root Port ATS Capability",
 249     "Remapping Hardware Static Affinity",
 250     "ACPI Namespace Device Declaration",
 251     "Unknown Subtable Type"         /* Reserved */
 252 };
 253
 254 static const char           *AcpiDmDmarScope[] =
 255 {
 256     "Reserved value",
 257     "PCI Endpoint Device",
 258     "PCI Bridge Device",
 259     "IOAPIC Device",
 260     "Message-capable HPET Device",
 261     "Namespace Device",
 262     "Unknown Scope Type"            /* Reserved */
 263 };
 264
 265 static const char           *AcpiDmEinjActions[] =
 266 {
 267     "Begin Operation",
 268     "Get Trigger Table",
 269     "Set Error Type",
 270     "Get Error Type",
 271     "End Operation",
 272     "Execute Operation",
 273     "Check Busy Status",
 274     "Get Command Status",
 275     "Set Error Type With Address",
 276     "Get Execute Timings",
 277     "Unknown Action"
 278 };
 279
 280 static const char           *AcpiDmEinjInstructions[] =
 281 {
 282     "Read Register",
 283     "Read Register Value",
 284     "Write Register",
 285     "Write Register Value",
 286     "Noop",
 287     "Flush Cacheline",
 288     "Unknown Instruction"
 289 };
 290
 291 static const char           *AcpiDmErstActions[] =
 292 {
 293     "Begin Write Operation",
 294     "Begin Read Operation",
 295     "Begin Clear Operation",
 296     "End Operation",
 297     "Set Record Offset",
 298     "Execute Operation",
 299     "Check Busy Status",
 300     "Get Command Status",
 301     "Get Record Identifier",
 302     "Set Record Identifier",
 303     "Get Record Count",
 304     "Begin Dummy Write",
 305     "Unused/Unknown Action",
 306     "Get Error Address Range",
 307     "Get Error Address Length",
 308     "Get Error Attributes",
 309     "Execute Timings",
 310     "Unknown Action"
 311 };
 312
 313 static const char           *AcpiDmErstInstructions[] =
 314 {
 315     "Read Register",
 316     "Read Register Value",
 317     "Write Register",
 318     "Write Register Value",
 319     "Noop",
 320     "Load Var1",
 321     "Load Var2",
 322     "Store Var1",
 323     "Add",
 324     "Subtract",
 325     "Add Value",
 326     "Subtract Value",
 327     "Stall",
 328     "Stall While True",
 329     "Skip Next If True",
 330     "GoTo",
 331     "Set Source Address",
 332     "Set Destination Address",
 333     "Move Data",
 334     "Unknown Instruction"
 335 };
 336
 337 static const char           *AcpiDmGtdtSubnames[] =
 338 {
 339     "Generic Timer Block",
 340     "Generic Watchdog Timer",
 341     "Unknown Subtable Type"         /* Reserved */
 342 };
 343
 344 static const char           *AcpiDmHestSubnames[] =
 345 {
 346     "IA-32 Machine Check Exception",
 347     "IA-32 Corrected Machine Check",
 348     "IA-32 Non-Maskable Interrupt",
 349     "Unknown Subtable Type",        /* 3 - Reserved */
 350     "Unknown Subtable Type",        /* 4 - Reserved */
 351     "Unknown Subtable Type",        /* 5 - Reserved */
 352     "PCI Express Root Port AER",
 353     "PCI Express AER (AER Endpoint)",
 354     "PCI Express/PCI-X Bridge AER",
 355     "Generic Hardware Error Source",
 356     "Generic Hardware Error Source V2",
 357     "IA-32 Deferred Machine Check",
 358     "Unknown Subtable Type"         /* Reserved */
 359 };
 360
 361 static const char           *AcpiDmHestNotifySubnames[] =
 362 {
 363     "Polled",
 364     "External Interrupt",
 365     "Local Interrupt",
 366     "SCI",
 367     "NMI",
 368     "CMCI",                         /* ACPI 5.0 */
 369     "MCE",                          /* ACPI 5.0 */
 370     "GPIO",                         /* ACPI 6.0 */
 371     "SEA",                          /* ACPI 6.1 */
 372     "SEI",                          /* ACPI 6.1 */
 373     "GSIV",                         /* ACPI 6.1 */
 374     "Software Delegated Exception", /* ACPI 6.2 */
 375     "Unknown Notify Type"           /* Reserved */
 376 };
 377
 378 static const char           *AcpiDmHmatSubnames[] =
 379 {
 380     "Memory Proximity Domain Attributes",
 381     "System Locality Latency and Bandwidth Information",
 382     "Memory Side Cache Information",
 383     "Unknown Structure Type"         /* Reserved */
 384 };
 385
 386 static const char           *AcpiDmMadtSubnames[] =
 387 {
 388     "Processor Local APIC",             /* ACPI_MADT_TYPE_LOCAL_APIC */
 389     "I/O APIC",                         /* ACPI_MADT_TYPE_IO_APIC */
 390     "Interrupt Source Override",        /* ACPI_MADT_TYPE_INTERRUPT_OVERRIDE */
 391     "NMI Source",                       /* ACPI_MADT_TYPE_NMI_SOURCE */
 392     "Local APIC NMI",                   /* ACPI_MADT_TYPE_LOCAL_APIC_NMI */
 393     "Local APIC Address Override",      /* ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE */
 394     "I/O SAPIC",                        /* ACPI_MADT_TYPE_IO_SAPIC */
 395     "Local SAPIC",                      /* ACPI_MADT_TYPE_LOCAL_SAPIC */
 396     "Platform Interrupt Sources",       /* ACPI_MADT_TYPE_INTERRUPT_SOURCE */
 397     "Processor Local x2APIC",           /* ACPI_MADT_TYPE_LOCAL_X2APIC */
 398     "Local x2APIC NMI",                 /* ACPI_MADT_TYPE_LOCAL_X2APIC_NMI */
 399     "Generic Interrupt Controller",     /* ACPI_MADT_GENERIC_INTERRUPT */
 400     "Generic Interrupt Distributor",    /* ACPI_MADT_GENERIC_DISTRIBUTOR */
 401     "Generic MSI Frame",                /* ACPI_MADT_GENERIC_MSI_FRAME */
 402     "Generic Interrupt Redistributor",  /* ACPI_MADT_GENERIC_REDISTRIBUTOR */
 403     "Generic Interrupt Translator",     /* ACPI_MADT_GENERIC_TRANSLATOR */
 404     "Mutiprocessor Wakeup",             /* ACPI_MADT_TYPE_MULTIPROC_WAKEUP */
 405     "Unknown Subtable Type"             /* Reserved */
 406 };
 407
 408 static const char           *AcpiDmNfitSubnames[] =
 409 {
 410     "System Physical Address Range",    /* ACPI_NFIT_TYPE_SYSTEM_ADDRESS */
 411     "Memory Range Map",                 /* ACPI_NFIT_TYPE_MEMORY_MAP */
 412     "Interleave Info",                  /* ACPI_NFIT_TYPE_INTERLEAVE */
 413     "SMBIOS Information",               /* ACPI_NFIT_TYPE_SMBIOS */
 414     "NVDIMM Control Region",            /* ACPI_NFIT_TYPE_CONTROL_REGION */
 415     "NVDIMM Block Data Window Region",  /* ACPI_NFIT_TYPE_DATA_REGION */
 416     "Flush Hint Address",               /* ACPI_NFIT_TYPE_FLUSH_ADDRESS */
 417     "Platform Capabilities",            /* ACPI_NFIT_TYPE_CAPABILITIES */
 418     "Unknown Subtable Type"             /* Reserved */
 419 };
 420
 421 static const char           *AcpiDmNhltLinkTypeNames[] =
 422 {
 423     "Reserved for HD-Audio",            /* ACPI_NHLT_RESERVED_HD_AUDIO */
 424     "Reserved for DSP",                 /* ACPI_NHLT_RESERVED_DSP */
 425     "Type PDM",                         /* ACPI_NHLT_PDM */
 426     "Type SSP",                         /* ACPI_NHLT_SSP */
 427     "Reserved for SlimBus",             /* ACPI_NHLT_RESERVED_SLIMBUS */
 428     "Reserved for SoundWire",           /* ACPI_NHLT_RESERVED_SOUNDWIRE */
 429     "Unknown Link Type"                 /* Reserved */
 430 };
 431
 432 static const char           *AcpiDmNhltDirectionNames[] =
 433 {
 434     "Render",                           /* ACPI_NHLT_DIR_RENDER */
 435     "Capture",                          /* ACPI_NHLT_DIR_CAPTURE */
 436     "Render with Loopback",             /* ACPI_NHLT_DIR_RENDER_LOOPBACK */
 437     "Feedback for Render",              /* ACPI_NHLT_DIR_RENDER_FEEDBACK */
 438     "Unknown Direction"                 /* Reserved */
 439 };
 440
 441 static const char           *AcpiDmNhltMicTypeNames[] =
 442 {
 443     "Omnidirectional",                  /* ACPI_NHLT_MIC_OMNIDIRECTIONAL */
 444     "Subcardioid",                      /* ACPI_NHLT_MIC_SUBCARDIOID */
 445     "Cardioid",                         /* ACPI_NHLT_MIC_CARDIOID */
 446     "SuperCardioid",                    /* ACPI_NHLT_MIC_SUPER_CARDIOID */
 447     "HyperCardioid",                    /* ACPI_NHLT_MIC_HYPER_CARDIOID */
 448     "8 Shaped",                         /* ACPI_NHLT_MIC_8_SHAPED */
 449     "Reserved Mic Type",                /* Reserved */
 450     "Vendor Defined",                   /* ACPI_NHLT_MIC_VENDOR_DEFINED */
 451     "Unknown Mic Type"                  /* ACPI_NHLT_MIC_RESERVED */
 452 };
 453
 454 static const char           *AcpiDmNhltMicPositionNames[] =
 455 {
 456     "Top",                              /* ACPI_NHLT_MIC_POSITION_TOP */
 457     "Bottom",                           /* ACPI_NHLT_MIC_POSITION_BOTTOM */
 458     "Left",                             /* ACPI_NHLT_MIC_POSITION_LEFT */
 459     "Right",                            /* ACPI_NHLT_MIC_POSITION_RIGHT */
 460     "Front",                            /* ACPI_NHLT_MIC_POSITION_FRONT */
 461     "Back",                             /* ACPI_NHLT_MIC_POSITION_BACK */
 462     "Unknown Mic Position"              /* 6 and above are reserved */
 463 };
 464
 465 static const char           *AcpiDmNhltMicArrayTypeNames[] =
 466 {
 467     "Unknown Array Type",               /* ACPI_NHLT_ARRAY_TYPE_RESERVED */
 468     "Small Linear 2-element",           /* ACPI_NHLT_SMALL_LINEAR_2ELEMENT */
 469     "Big Linear 2-element",             /* ACPI_NHLT_BIG_LINEAR_2ELEMENT */
 470     "Linear 4-element 1st Geometry",    /* ACPI_NHLT_FIRST_GEOMETRY_LINEAR_4ELEMENT */
 471     "Planar L-shaped 4-element",        /* ACPI_NHLT_PLANAR_LSHAPED_4ELEMENT */
 472     "Linear 4-element 2nd Geometry",    /* ACPI_NHLT_SECOND_GEOMETRY_LINEAR_4ELEMENT */
 473     "Vendor Defined"                    /* ACPI_NHLT_VENDOR_DEFINED */
 474 };
 475
 476 static const char           *AcpiDmNhltConfigTypeNames[] =
 477 {
 478     "Generic Type",                     /* ACPI_NHLT_CONFIG_TYPE_GENERIC */
 479     "Microphone Array",                 /* ACPI_NHLT_CONFIG_TYPE_MIC_ARRAY */
 480     "Reserved",                         /* ACPI_NHLT_CONFIG_TYPE_RESERVED */
 481     "Render Feedback",                  /* ACPI_NHLT_CONFIG_TYPE_RENDER_FEEDBACK */
 482     "Unknown Config Type"               /* ACPI_NHLT_CONFIG_TYPE_RESERVED */
 483 };
 484
 485 static const char           *AcpiDmPcctSubnames[] =
 486 {
 487     "Generic Communications Subspace",  /* ACPI_PCCT_TYPE_GENERIC_SUBSPACE */
 488     "HW-Reduced Comm Subspace",         /* ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE */
 489     "HW-Reduced Comm Subspace Type2",   /* ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2 */
 490     "Extended PCC Master Subspace",     /* ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE */
 491     "Extended PCC Slave Subspace",      /* ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE */
 492     "HW Registers based Comm Subspace", /* ACPI_PCCT_TYPE_HW_REG_COMM_SUBSPACE */
 493     "Unknown Subtable Type"             /* Reserved */
 494 };
 495
 496 static const char           *AcpiDmPhatSubnames[] =
 497 {
 498     "Firmware Version Data",        /* ACPI_PHAT_TYPE_FW_VERSION_DATA */
 499     "Firmware Health Data",         /* ACPI_PHAT_TYPE_FW_HEALTH_DATA */
 500     "Unknown Subtable Type"         /* Reserved */
 501 };
 502
 503 static const char           *AcpiDmPmttSubnames[] =
 504 {
 505     "Socket",                       /* ACPI_PMTT_TYPE_SOCKET */
 506     "Memory Controller",            /* ACPI_PMTT_TYPE_CONTROLLER */
 507     "Physical Component (DIMM)",    /* ACPI_PMTT_TYPE_DIMM */
 508     "Unknown Subtable Type",        /* Reserved */
 509     "Vendor Specific"               /* ACPI_PMTT_TYPE_VENDOR */
 510 };
 511
 512 static const char           *AcpiDmPpttSubnames[] =
 513 {
 514     "Processor Hierarchy Node",     /* ACPI_PPTT_TYPE_PROCESSOR */
 515     "Cache Type",                   /* ACPI_PPTT_TYPE_CACHE */
 516     "ID",                           /* ACPI_PPTT_TYPE_ID */
 517     "Unknown Subtable Type"         /* Reserved */
 518 };
 519
 520 static const char           *AcpiDmRgrtSubnames[] =
 521 {
 522     "Unknown/Reserved Image Type",  /* ACPI_RGRT_TYPE_RESERVED0 */
 523     "Type PNG"                      /* ACPI_RGRT_IMAGE_TYPE_PNG */
 524 };
 525
 526 static const char           *AcpiDmSdevSubnames[] =
 527 {
 528     "Namespace Device",             /* ACPI_SDEV_TYPE_NAMESPACE_DEVICE */
 529     "PCIe Endpoint Device",         /* ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE */
 530     "Unknown Subtable Type"         /* Reserved */
 531 };
 532
 533 static const char           *AcpiDmSratSubnames[] =
 534 {
 535     "Processor Local APIC/SAPIC Affinity",
 536     "Memory Affinity",
 537     "Processor Local x2APIC Affinity",
 538     "GICC Affinity",
 539     "GIC ITS Affinity",             /* Acpi 6.2 */
 540     "Generic Initiator Affinity",   /* Acpi 6.3 */
 541     "Generic Port Affinity",        /* Acpi 6.4 */
 542     "Unknown Subtable Type"         /* Reserved */
 543 };
 544
 545 static const char           *AcpiDmTpm2Subnames[] =
 546 {
 547     "Illegal Start Method value",
 548     "Reserved",
 549     "ACPI Start Method",
 550     "Reserved",
 551     "Reserved",
 552     "Reserved",
 553     "Memory Mapped I/O",
 554     "Command Response Buffer",
 555     "Command Response Buffer with ACPI Start Method",
 556     "Reserved",
 557     "Reserved",
 558     "Command Response Buffer with ARM SMC",
 559     "Unknown Subtable Type"         /* Reserved */
 560 };
 561
 562 static const char           *AcpiDmIvrsSubnames[] =
 563 {
 564     "Hardware Definition Block (IVHD)",
 565     "Hardware Definition Block - Mixed Format (IVHD)",
 566     "Memory Definition Block (IVMD)",
 567     "Unknown/Reserved Subtable Type"            /* Reserved */
 568 };
 569
 570 static const char           *AcpiDmIvrsDevEntryNames[] =
 571 {
 572     "Unknown/Reserved Device Entry Type",       /* 0- Reserved */
 573     "Device Entry: Select All Devices",         /* 1 */
 574     "Device Entry: Select One Device",          /* 2 */
 575     "Device Entry: Start of Range",             /* 3 */
 576     "Device Entry: End of Range",               /* 4 */
 577     "Device Entry: Alias Select",               /* 66 */
 578     "Device Entry: Alias Start of Range",       /* 67 */
 579     "Unknown/Reserved Device Entry Type",       /* 68- Reserved */
 580     "Unknown/Reserved Device Entry Type",       /* 69- Reserved */
 581     "Device Entry: Extended Select",            /* 70 */
 582     "Device Entry: Extended Start of Range",    /* 71 */
 583     "Device Entry: Special Device",             /* 72 */
 584     "Device Entry: ACPI HID Named Device",      /* 240 */
 585     "Unknown/Reserved Device Entry Type"        /* Reserved */
 586 };
 587
 588 static const char           *AcpiDmLpitSubnames[] =
 589 {
 590     "Native C-state Idle Structure",
 591     "Unknown Subtable Type"         /* Reserved */
 592 };
 593
 594 static const char           *AcpiDmViotSubnames[] =
 595 {
 596     "Unknown Subtable Type",        /* 0 -Reserved */
 597     "PCI Range",
 598     "MMIO Endpoint",
 599     "VirtIO-PCI IOMMU",
 600     "VirtIO-MMIO IOMMU",
 601     "Unknown Subtable Type"         /* Reserved */
 602 };
 603
 604 #define ACPI_FADT_PM_RESERVED       9
 605
 606 static const char           *AcpiDmFadtProfiles[] =
 607 {
 608     "Unspecified",
 609     "Desktop",
 610     "Mobile",
 611     "Workstation",
 612     "Enterprise Server",
 613     "SOHO Server",
 614     "Appliance PC",
 615     "Performance Server",
 616     "Tablet",
 617     "Unknown Profile Type"
 618 };
 619
 620 #define ACPI_GAS_WIDTH_RESERVED     5
 621
 622 static const char           *AcpiDmGasAccessWidth[] =
 623 {
 624     "Undefined/Legacy",
 625     "Byte Access:8",
 626     "Word Access:16",
 627     "DWord Access:32",
 628     "QWord Access:64",
 629     "Unknown Width Encoding"
 630 };
 631
 632
 633 /*******************************************************************************
 634  *
 635  * ACPI Table Data, indexed by signature.
 636  *
 637  * Each entry contains: Signature, Table Info, Handler, DtHandler,
 638  *  Template, Description
 639  *
 640  * Simple tables have only a TableInfo structure, complex tables have a
 641  * handler. This table must be NULL terminated. RSDP and FACS are
 642  * special-cased elsewhere.
 643  *
 644  * Note: Any tables added here should be duplicated within
 645  * AcpiGbl_SupportedTables in the file common/ahtable.c
 646  *
 647  ******************************************************************************/
 648
 649 const ACPI_DMTABLE_DATA     AcpiDmTableData[] =
 650 {
 651     {ACPI_SIG_AEST, NULL,                   AcpiDmDumpAest, DtCompileAest,  TemplateAest},
 652     {ACPI_SIG_AGDI, AcpiDmTableInfoAgdi,    NULL,           NULL,           TemplateAgdi},
 653     {ACPI_SIG_ASF,  NULL,                   AcpiDmDumpAsf,  DtCompileAsf,   TemplateAsf},
 654     {ACPI_SIG_BDAT, AcpiDmTableInfoBdat,    NULL,           NULL,           TemplateBdat},
 655     {ACPI_SIG_BERT, AcpiDmTableInfoBert,    NULL,           NULL,           TemplateBert},
 656     {ACPI_SIG_BGRT, AcpiDmTableInfoBgrt,    NULL,           NULL,           TemplateBgrt},
 657     {ACPI_SIG_BOOT, AcpiDmTableInfoBoot,    NULL,           NULL,           TemplateBoot},
 658     {ACPI_SIG_CEDT, NULL,                   AcpiDmDumpCedt, DtCompileCedt,  TemplateCedt},
 659     {ACPI_SIG_CPEP, NULL,                   AcpiDmDumpCpep, DtCompileCpep,  TemplateCpep},
 660     {ACPI_SIG_CSRT, NULL,                   AcpiDmDumpCsrt, DtCompileCsrt,  TemplateCsrt},
 661     {ACPI_SIG_DBG2, AcpiDmTableInfoDbg2,    AcpiDmDumpDbg2, DtCompileDbg2,  TemplateDbg2},
 662     {ACPI_SIG_DBGP, AcpiDmTableInfoDbgp,    NULL,           NULL,           TemplateDbgp},
 663     {ACPI_SIG_DMAR, NULL,                   AcpiDmDumpDmar, DtCompileDmar,  TemplateDmar},
 664     {ACPI_SIG_DRTM, NULL,                   AcpiDmDumpDrtm, DtCompileDrtm,  TemplateDrtm},
 665     {ACPI_SIG_ECDT, AcpiDmTableInfoEcdt,    NULL,           NULL,           TemplateEcdt},
 666     {ACPI_SIG_EINJ, NULL,                   AcpiDmDumpEinj, DtCompileEinj,  TemplateEinj},
 667     {ACPI_SIG_ERST, NULL,                   AcpiDmDumpErst, DtCompileErst,  TemplateErst},
 668     {ACPI_SIG_FADT, NULL,                   AcpiDmDumpFadt, DtCompileFadt,  TemplateFadt},
 669     {ACPI_SIG_FPDT, NULL,                   AcpiDmDumpFpdt, DtCompileFpdt,  TemplateFpdt},
 670     {ACPI_SIG_GTDT, NULL,                   AcpiDmDumpGtdt, DtCompileGtdt,  TemplateGtdt},
 671     {ACPI_SIG_HEST, NULL,                   AcpiDmDumpHest, DtCompileHest,  TemplateHest},
 672     {ACPI_SIG_HMAT, NULL,                   AcpiDmDumpHmat, DtCompileHmat,  TemplateHmat},
 673     {ACPI_SIG_HPET, AcpiDmTableInfoHpet,    NULL,           NULL,           TemplateHpet},
 674     {ACPI_SIG_IORT, NULL,                   AcpiDmDumpIort, DtCompileIort,  TemplateIort},
 675     {ACPI_SIG_IVRS, NULL,                   AcpiDmDumpIvrs, DtCompileIvrs,  TemplateIvrs},
 676     {ACPI_SIG_LPIT, NULL,                   AcpiDmDumpLpit, DtCompileLpit,  TemplateLpit},
 677     {ACPI_SIG_MADT, NULL,                   AcpiDmDumpMadt, DtCompileMadt,  TemplateMadt},
 678     {ACPI_SIG_MCFG, NULL,                   AcpiDmDumpMcfg, DtCompileMcfg,  TemplateMcfg},
 679     {ACPI_SIG_MCHI, AcpiDmTableInfoMchi,    NULL,           NULL,           TemplateMchi},
 680     {ACPI_SIG_MPST, AcpiDmTableInfoMpst,    AcpiDmDumpMpst, DtCompileMpst,  TemplateMpst},
 681     {ACPI_SIG_MSCT, NULL,                   AcpiDmDumpMsct, DtCompileMsct,  TemplateMsct},
 682     {ACPI_SIG_MSDM, NULL,                   AcpiDmDumpSlic, DtCompileSlic,  TemplateMsdm},
 683     {ACPI_SIG_NFIT, AcpiDmTableInfoNfit,    AcpiDmDumpNfit, DtCompileNfit,  TemplateNfit},
 684     {ACPI_SIG_NHLT, AcpiDmTableInfoNhlt,    AcpiDmDumpNhlt, DtCompileNhlt,  TemplateNhlt},
 685     {ACPI_SIG_PCCT, AcpiDmTableInfoPcct,    AcpiDmDumpPcct, DtCompilePcct,  TemplatePcct},
 686     {ACPI_SIG_PDTT, AcpiDmTableInfoPdtt,    AcpiDmDumpPdtt, DtCompilePdtt,  TemplatePdtt},
 687     {ACPI_SIG_PHAT, NULL,                   AcpiDmDumpPhat, DtCompilePhat,  TemplatePhat},
 688     {ACPI_SIG_PMTT, NULL,                   AcpiDmDumpPmtt, DtCompilePmtt,  TemplatePmtt},
 689     {ACPI_SIG_PPTT, NULL,                   AcpiDmDumpPptt, DtCompilePptt,  TemplatePptt},
 690     {ACPI_SIG_PRMT, NULL,                   AcpiDmDumpPrmt, DtCompilePrmt,  TemplatePrmt},
 691     {ACPI_SIG_RASF, AcpiDmTableInfoRasf,    NULL,           NULL,           TemplateRasf},
 692     {ACPI_SIG_RGRT, NULL,                   AcpiDmDumpRgrt, DtCompileRgrt,  TemplateRgrt},
 693     {ACPI_SIG_RSDT, NULL,                   AcpiDmDumpRsdt, DtCompileRsdt,  TemplateRsdt},
 694     {ACPI_SIG_S3PT, NULL,                   NULL,           NULL,           TemplateS3pt},
 695     {ACPI_SIG_SBST, AcpiDmTableInfoSbst,    NULL,           NULL,           TemplateSbst},
 696     {ACPI_SIG_SDEI, AcpiDmTableInfoSdei,    NULL,           NULL,           TemplateSdei},
 697     {ACPI_SIG_SDEV, AcpiDmTableInfoSdev,    AcpiDmDumpSdev, DtCompileSdev,  TemplateSdev},
 698     {ACPI_SIG_SLIC, NULL,                   AcpiDmDumpSlic, DtCompileSlic,  TemplateSlic},
 699     {ACPI_SIG_SLIT, NULL,                   AcpiDmDumpSlit, DtCompileSlit,  TemplateSlit},
 700     {ACPI_SIG_SPCR, AcpiDmTableInfoSpcr,    NULL,           NULL,           TemplateSpcr},
 701     {ACPI_SIG_SPMI, AcpiDmTableInfoSpmi,    NULL,           NULL,           TemplateSpmi},
 702     {ACPI_SIG_SRAT, NULL,                   AcpiDmDumpSrat, DtCompileSrat,  TemplateSrat},
 703     {ACPI_SIG_STAO, NULL,                   AcpiDmDumpStao, DtCompileStao,  TemplateStao},
 704     {ACPI_SIG_SVKL, AcpiDmTableInfoSvkl,    AcpiDmDumpSvkl, DtCompileSvkl,  TemplateSvkl},
 705     {ACPI_SIG_TCPA, NULL,                   AcpiDmDumpTcpa, DtCompileTcpa,  TemplateTcpa},
 706     {ACPI_SIG_TDEL, AcpiDmTableInfoTdel,    NULL,           NULL,           TemplateTdel},
 707     {ACPI_SIG_TPM2, AcpiDmTableInfoTpm2,    AcpiDmDumpTpm2, DtCompileTpm2,  TemplateTpm2},
 708     {ACPI_SIG_UEFI, AcpiDmTableInfoUefi,    NULL,           DtCompileUefi,  TemplateUefi},
 709     {ACPI_SIG_VIOT, AcpiDmTableInfoViot,    AcpiDmDumpViot, DtCompileViot,  TemplateViot},
 710     {ACPI_SIG_WAET, AcpiDmTableInfoWaet,    NULL,           NULL,           TemplateWaet},
 711     {ACPI_SIG_WDAT, NULL,                   AcpiDmDumpWdat, DtCompileWdat,  TemplateWdat},
 712     {ACPI_SIG_WDDT, AcpiDmTableInfoWddt,    NULL,           NULL,           TemplateWddt},
 713     {ACPI_SIG_WDRT, AcpiDmTableInfoWdrt,    NULL,           NULL,           TemplateWdrt},
 714     {ACPI_SIG_WPBT, NULL,                   AcpiDmDumpWpbt, DtCompileWpbt,  TemplateWpbt},
 715     {ACPI_SIG_WSMT, AcpiDmTableInfoWsmt,    NULL,           NULL,           TemplateWsmt},
 716     {ACPI_SIG_XENV, AcpiDmTableInfoXenv,    NULL,           NULL,           TemplateXenv},
 717     {ACPI_SIG_XSDT, NULL,                   AcpiDmDumpXsdt, DtCompileXsdt,  TemplateXsdt},
 718     {NULL,          NULL,                   NULL,           NULL,           NULL}
 719 };
 720
 721
 722 /*******************************************************************************
 723  *
 724  * FUNCTION:    AcpiDmGenerateChecksum
 725  *
 726  * PARAMETERS:  Table               - Pointer to table to be checksummed
 727  *              Length              - Length of the table
 728  *              OriginalChecksum    - Value of the checksum field
 729  *
 730  * RETURN:      8 bit checksum of buffer
 731  *
 732  * DESCRIPTION: Computes an 8 bit checksum of the table.
 733  *
 734  ******************************************************************************/
 735
 736 UINT8
 737 AcpiDmGenerateChecksum (
 738     void                    *Table,
 739     UINT32                  Length,
 740     UINT8                   OriginalChecksum)
 741 {
 742     UINT8                   Checksum;
 743
 744
 745     /* Sum the entire table as-is */
 746
 747     Checksum = AcpiTbChecksum ((UINT8 *) Table, Length);
 748
 749     /* Subtract off the existing checksum value in the table */
 750
 751     Checksum = (UINT8) (Checksum - OriginalChecksum);
 752
 753     /* Compute the final checksum */
 754
 755     Checksum = (UINT8) (0 - Checksum);
 756     return (Checksum);
 757 }
 758
 759
 760 /*******************************************************************************
 761  *
 762  * FUNCTION:    AcpiDmGetTableData
 763  *
 764  * PARAMETERS:  Signature           - ACPI signature (4 chars) to match
 765  *
 766  * RETURN:      Pointer to a valid ACPI_DMTABLE_DATA. Null if no match found.
 767  *
 768  * DESCRIPTION: Find a match in the global table of supported ACPI tables
 769  *
 770  ******************************************************************************/
 771
 772 const ACPI_DMTABLE_DATA *
 773 AcpiDmGetTableData (
 774     char                    *Signature)
 775 {
 776     const ACPI_DMTABLE_DATA *Info;
 777
 778
 779     for (Info = AcpiDmTableData; Info->Signature; Info++)
 780     {
 781         if (ACPI_COMPARE_NAMESEG (Signature, Info->Signature))
 782         {
 783             return (Info);
 784         }
 785     }
 786
 787     return (NULL);
 788 }
 789
 790
 791 /*******************************************************************************
 792  *
 793  * FUNCTION:    AcpiDmDumpDataTable
 794  *
 795  * PARAMETERS:  Table               - An ACPI table
 796  *
 797  * RETURN:      None.
 798  *
 799  * DESCRIPTION: Format the contents of an ACPI data table (any table other
 800  *              than an SSDT or DSDT that does not contain executable AML code)
 801  *
 802  ******************************************************************************/
 803
 804 void
 805 AcpiDmDumpDataTable (
 806     ACPI_TABLE_HEADER       *Table)
 807 {
 808     ACPI_STATUS             Status;
 809     const ACPI_DMTABLE_DATA *TableData;
 810     UINT32                  Length;
 811
 812
 813     /* Ignore tables that contain AML */
 814
 815     if (AcpiUtIsAmlTable (Table))
 816     {
 817         if (AslGbl_VerboseTemplates)
 818         {
 819             /* Dump the raw table data */
 820
 821             Length = Table->Length;
 822
 823             AcpiOsPrintf ("\n/*\n%s: Length %d (0x%X)\n\n",
 824                 ACPI_RAW_TABLE_DATA_HEADER, Length, Length);
 825             AcpiUtDumpBuffer (ACPI_CAST_PTR (UINT8, Table),
 826                 Length, DB_BYTE_DISPLAY, 0);
 827             AcpiOsPrintf (" */\n");
 828         }
 829         return;
 830     }
 831
 832     /*
 833      * Handle tables that don't use the common ACPI table header structure.
 834      * Currently, these are the FACS, RSDP, and S3PT.
 835      */
 836     if (ACPI_COMPARE_NAMESEG (Table->Signature, ACPI_SIG_FACS))
 837     {
 838         Length = Table->Length;
 839         Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoFacs);
 840         if (ACPI_FAILURE (Status))
 841         {
 842             return;
 843         }
 844     }
 845     else if (ACPI_VALIDATE_RSDP_SIG (ACPI_CAST_PTR (ACPI_TABLE_RSDP,
 846         Table)->Signature))
 847     {
 848         Length = AcpiDmDumpRsdp (Table);
 849     }
 850     else if (ACPI_COMPARE_NAMESEG (Table->Signature, ACPI_SIG_S3PT))
 851     {
 852         Length = AcpiDmDumpS3pt (Table);
 853     }
 854     else
 855     {
 856         /*
 857          * All other tables must use the common ACPI table header, dump it now
 858          */
 859         Length = Table->Length;
 860         Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHeader);
 861         if (ACPI_FAILURE (Status))
 862         {
 863             return;
 864         }
 865         AcpiOsPrintf ("\n");
 866
 867         /* Match signature and dispatch appropriately */
 868
 869         TableData = AcpiDmGetTableData (Table->Signature);
 870         if (!TableData)
 871         {
 872             if (!strncmp (Table->Signature, "OEM", 3))
 873             {
 874                 AcpiOsPrintf ("\n**** OEM-defined ACPI table [%4.4s], unknown contents\n\n",
 875                     Table->Signature);
 876             }
 877             else
 878             {
 879                 AcpiOsPrintf ("\n**** Unknown ACPI table signature [%4.4s]\n\n",
 880                     Table->Signature);
 881
 882                 fprintf (stderr, "Unknown ACPI table signature [%4.4s], ",
 883                     Table->Signature);
 884
 885                 if (!AcpiGbl_ForceAmlDisassembly)
 886                 {
 887                     fprintf (stderr, "decoding ACPI table header only\n");
 888                 }
 889                 else
 890                 {
 891                     fprintf (stderr, "assuming table contains valid AML code\n");
 892                 }
 893             }
 894         }
 895         else if (TableData->TableHandler)
 896         {
 897             /* Complex table, has a handler */
 898
 899             TableData->TableHandler (Table);
 900         }
 901         else if (TableData->TableInfo)
 902         {
 903             /* Simple table, just walk the info table */
 904
 905             Status = AcpiDmDumpTable (Length, 0, Table, 0, TableData->TableInfo);
 906             if (ACPI_FAILURE (Status))
 907             {
 908                 return;
 909             }
 910         }
 911     }
 912
 913     if (!AslGbl_DoTemplates || AslGbl_VerboseTemplates)
 914     {
 915         /* Dump the raw table data */
 916
 917         AcpiOsPrintf ("\n%s: Length %d (0x%X)\n\n",
 918             ACPI_RAW_TABLE_DATA_HEADER, Length, Length);
 919         AcpiUtDumpBuffer (ACPI_CAST_PTR (UINT8, Table),
 920             Length, DB_BYTE_DISPLAY, 0);
 921     }
 922 }
 923
 924
 925 /*******************************************************************************
 926  *
 927  * FUNCTION:    AcpiDmLineHeader
 928  *
 929  * PARAMETERS:  Offset              - Current byte offset, from table start
 930  *              ByteLength          - Length of the field in bytes, 0 for flags
 931  *              Name                - Name of this field
 932  *
 933  * RETURN:      None
 934  *
 935  * DESCRIPTION: Utility routines for formatting output lines. Displays the
 936  *              current table offset in hex and decimal, the field length,
 937  *              and the field name.
 938  *
 939  ******************************************************************************/
 940
 941 void
 942 AcpiDmLineHeader (
 943     UINT32                  Offset,
 944     UINT32                  ByteLength,
 945     char                    *Name)
 946 {
 947
 948     /* Allow a null name for fields that span multiple lines (large buffers) */
 949
 950     if (!Name)
 951     {
 952         Name = "";
 953     }
 954
 955     if (AslGbl_DoTemplates && !AslGbl_VerboseTemplates) /* Terse template */
 956     {
 957         if (ByteLength)
 958         {
 959             AcpiOsPrintf ("[%.4d] %34s : ", ByteLength, Name);
 960         }
 961         else
 962         {
 963             if (*Name)
 964             {
 965                 AcpiOsPrintf ("%41s : ", Name);
 966             }
 967             else
 968             {
 969                 AcpiOsPrintf ("%41s   ", Name);
 970             }
 971         }
 972     }
 973     else /* Normal disassembler or verbose template */
 974     {
 975         if (ByteLength)
 976         {
 977             AcpiOsPrintf ("[%3.3Xh %4.4d% 4d] %28s : ",
 978                 Offset, Offset, ByteLength, Name);
 979         }
 980         else
 981         {
 982             if (*Name)
 983             {
 984                 AcpiOsPrintf ("%44s : ", Name);
 985             }
 986             else
 987             {
 988                 AcpiOsPrintf ("%44s   ", Name);
 989             }
 990         }
 991     }
 992 }
 993
 994 void
 995 AcpiDmLineHeader2 (
 996     UINT32                  Offset,
 997     UINT32                  ByteLength,
 998     char                    *Name,
 999     UINT32                  Value)
1000 {
1001
1002     if (AslGbl_DoTemplates && !AslGbl_VerboseTemplates) /* Terse template */
1003     {
1004         if (ByteLength)
1005         {
1006             AcpiOsPrintf ("[%.4d] %30s %3d : ",
1007                 ByteLength, Name, Value);
1008         }
1009         else
1010         {
1011             AcpiOsPrintf ("%36s % 3d : ",
1012                 Name, Value);
1013         }
1014     }
1015     else /* Normal disassembler or verbose template */
1016     {
1017         if (ByteLength)
1018         {
1019             AcpiOsPrintf ("[%3.3Xh %4.4d %3d] %24s %3d : ",
1020                 Offset, Offset, ByteLength, Name, Value);
1021         }
1022         else
1023         {
1024             AcpiOsPrintf ("[%3.3Xh %4.4d   ] %24s %3d : ",
1025                 Offset, Offset, Name, Value);
1026         }
1027     }
1028 }
1029
1030
1031 /*******************************************************************************
1032  *
1033  * FUNCTION:    AcpiDmDumpTable
1034  *
1035  * PARAMETERS:  TableLength         - Length of the entire ACPI table
1036  *              TableOffset         - Starting offset within the table for this
1037  *                                    sub-descriptor (0 if main table)
1038  *              Table               - The ACPI table
1039  *              SubtableLength      - Length of this sub-descriptor
1040  *              Info                - Info table for this ACPI table
1041  *
1042  * RETURN:      Status
1043  *
1044  * DESCRIPTION: Display ACPI table contents by walking the Info table.
1045  *
1046  * Note: This function must remain in sync with DtGetFieldLength.
1047  *
1048  ******************************************************************************/
1049
1050 ACPI_STATUS
1051 AcpiDmDumpTable (
1052     UINT32                  TableLength,
1053     UINT32                  TableOffset,
1054     void                    *Table,
1055     UINT32                  SubtableLength,
1056     ACPI_DMTABLE_INFO       *Info)
1057 {
1058     UINT8                   *Target;
1059     UINT32                  CurrentOffset;
1060     UINT32                  ByteLength;
1061     UINT8                   Temp8;
1062     UINT16                  Temp16;
1063     UINT32                  Temp32;
1064     UINT64                  Value;
1065     const AH_TABLE          *TableData;
1066     const char              *Name;
1067     BOOLEAN                 LastOutputBlankLine = FALSE;
1068     ACPI_STATUS             Status;
1069     char                    RepairedName[8];
1070
1071
1072     if (!Info)
1073     {
1074         AcpiOsPrintf ("Display not implemented\n");
1075         return (AE_NOT_IMPLEMENTED);
1076     }
1077
1078     /* Walk entire Info table; Null name terminates */
1079
1080     for (; Info->Name; Info++)
1081     {
1082         /*
1083          * Target points to the field within the ACPI Table. CurrentOffset is
1084          * the offset of the field from the start of the main table.
1085          */
1086         Target = ACPI_ADD_PTR (UINT8, Table, Info->Offset);
1087         CurrentOffset = TableOffset + Info->Offset;
1088
1089         /* Check for beyond subtable end or (worse) beyond EOT */
1090
1091         if (SubtableLength && (Info->Offset > SubtableLength))
1092         {
1093             AcpiOsPrintf (
1094                 "/**** ACPI subtable terminates early (Len %u) - "
1095                 "may be older version (dump table) */\n", SubtableLength);
1096
1097             /* Move on to next subtable */
1098
1099             return (AE_OK);
1100         }
1101
1102         if (CurrentOffset >= TableLength)
1103         {
1104             AcpiOsPrintf (
1105                 "/**** ACPI table terminates "
1106                 "in the middle of a data structure! (dump table) */\n");
1107             return (AE_BAD_DATA);
1108         }
1109
1110         /* Generate the byte length for this field */
1111
1112         switch (Info->Opcode)
1113         {
1114         case ACPI_DMT_UINT8:
1115         case ACPI_DMT_CHKSUM:
1116         case ACPI_DMT_SPACEID:
1117         case ACPI_DMT_ACCWIDTH:
1118         case ACPI_DMT_CEDT:
1119         case ACPI_DMT_IVRS:
1120         case ACPI_DMT_IVRS_DE:
1121         case ACPI_DMT_GTDT:
1122         case ACPI_DMT_MADT:
1123         case ACPI_DMT_NHLT1:
1124         case ACPI_DMT_NHLT1a:
1125         case ACPI_DMT_NHLT1b:
1126         case ACPI_DMT_NHLT1c:
1127         case ACPI_DMT_NHLT1d:
1128         case ACPI_DMT_NHLT1f:
1129         case ACPI_DMT_PCCT:
1130         case ACPI_DMT_PMTT:
1131         case ACPI_DMT_PPTT:
1132         case ACPI_DMT_RGRT:
1133         case ACPI_DMT_SDEV:
1134         case ACPI_DMT_SRAT:
1135         case ACPI_DMT_AEST:
1136         case ACPI_DMT_AEST_RES:
1137         case ACPI_DMT_AEST_XFACE:
1138         case ACPI_DMT_AEST_XRUPT:
1139         case ACPI_DMT_ASF:
1140         case ACPI_DMT_HESTNTYP:
1141         case ACPI_DMT_FADTPM:
1142         case ACPI_DMT_EINJACT:
1143         case ACPI_DMT_EINJINST:
1144         case ACPI_DMT_ERSTACT:
1145         case ACPI_DMT_ERSTINST:
1146         case ACPI_DMT_DMAR_SCOPE:
1147         case ACPI_DMT_VIOT:
1148
1149             ByteLength = 1;
1150             break;
1151
1152         case ACPI_DMT_UINT16:
1153         case ACPI_DMT_DMAR:
1154         case ACPI_DMT_HEST:
1155         case ACPI_DMT_HMAT:
1156         case ACPI_DMT_NFIT:
1157         case ACPI_DMT_NHLT1e:
1158         case ACPI_DMT_PHAT:
1159
1160             ByteLength = 2;
1161             break;
1162
1163         case ACPI_DMT_UINT24:
1164
1165             ByteLength = 3;
1166             break;
1167
1168         case ACPI_DMT_UINT32:
1169         case ACPI_DMT_AEST_CACHE:
1170         case ACPI_DMT_AEST_GIC:
1171         case ACPI_DMT_NAME4:
1172         case ACPI_DMT_SIG:
1173         case ACPI_DMT_LPIT:
1174         case ACPI_DMT_TPM2:
1175
1176             ByteLength = 4;
1177             break;
1178
1179         case ACPI_DMT_UINT40:
1180
1181             ByteLength = 5;
1182             break;
1183
1184         case ACPI_DMT_UINT48:
1185         case ACPI_DMT_NAME6:
1186
1187             ByteLength = 6;
1188             break;
1189
1190         case ACPI_DMT_UINT56:
1191         case ACPI_DMT_BUF7:
1192
1193             ByteLength = 7;
1194             break;
1195
1196         case ACPI_DMT_UINT64:
1197         case ACPI_DMT_NAME8:
1198
1199             ByteLength = 8;
1200             break;
1201
1202         case ACPI_DMT_BUF10:
1203
1204             ByteLength = 10;
1205             break;
1206
1207         case ACPI_DMT_BUF12:
1208
1209             ByteLength = 12;
1210             break;
1211
1212         case ACPI_DMT_BUF16:
1213         case ACPI_DMT_UUID:
1214
1215             ByteLength = 16;
1216             break;
1217
1218         case ACPI_DMT_BUF18:
1219
1220             ByteLength = 18;
1221             break;
1222
1223         case ACPI_DMT_BUF128:
1224
1225             ByteLength = 128;
1226             break;
1227
1228         case ACPI_DMT_WPBT_UNICODE:
1229
1230             ByteLength = SubtableLength;
1231             CurrentOffset = sizeof (ACPI_TABLE_WPBT);
1232             break;
1233
1234         case ACPI_DMT_UNICODE:
1235         case ACPI_DMT_BUFFER:
1236         case ACPI_DMT_RAW_BUFFER:
1237
1238             ByteLength = SubtableLength;
1239             break;
1240
1241         case ACPI_DMT_PMTT_VENDOR:
1242             /*
1243              * Calculate the length of the vendor data for the PMTT table:
1244              * Length = (Current Subtable ptr + Subtable length) -
1245              *          Start of the vendor data (Target)
1246              */
1247             ByteLength = ((ACPI_CAST_PTR (char, Table) +
1248                             (ACPI_CAST_PTR (ACPI_PMTT_HEADER, Table)->Length)) -
1249                             ACPI_CAST_PTR (char, Target));
1250             break;
1251
1252         case ACPI_DMT_STRING:
1253
1254             ByteLength = strlen (ACPI_CAST_PTR (char, Target)) + 1;
1255             break;
1256
1257         case ACPI_DMT_IVRS_UNTERMINATED_STRING:
1258
1259             ByteLength = ((ACPI_CAST_PTR (ACPI_IVRS_DEVICE_HID, Target) -1)->UidLength);
1260             break;
1261
1262         case ACPI_DMT_GAS:
1263
1264             if (!LastOutputBlankLine)
1265             {
1266                 AcpiOsPrintf ("\n");
1267                 LastOutputBlankLine = TRUE;
1268             }
1269
1270             ByteLength = sizeof (ACPI_GENERIC_ADDRESS);
1271             break;
1272
1273         case ACPI_DMT_HESTNTFY:
1274
1275             if (!LastOutputBlankLine)
1276             {
1277                 AcpiOsPrintf ("\n");
1278                 LastOutputBlankLine = TRUE;
1279             }
1280
1281             ByteLength = sizeof (ACPI_HEST_NOTIFY);
1282             break;
1283
1284         case ACPI_DMT_IORTMEM:
1285
1286             if (!LastOutputBlankLine)
1287             {
1288                 LastOutputBlankLine = FALSE;
1289             }
1290
1291             ByteLength = sizeof (ACPI_IORT_MEMORY_ACCESS);
1292             break;
1293
1294         default:
1295
1296             ByteLength = 0;
1297             break;
1298         }
1299
1300         /* Check if we are beyond a subtable, or (worse) beyond EOT */
1301
1302         if (CurrentOffset + ByteLength > TableLength)
1303         {
1304             if (SubtableLength)
1305             {
1306                 AcpiOsPrintf (
1307                     "/**** ACPI subtable terminates early - "
1308                     "may be older version (dump table) */\n");
1309
1310                 /* Move on to next subtable */
1311
1312                 return (AE_OK);
1313             }
1314
1315             AcpiOsPrintf (
1316                 "/**** ACPI table terminates "
1317                 "in the middle of a data structure! */\n");
1318             return (AE_BAD_DATA);
1319         }
1320
1321         if (Info->Opcode == ACPI_DMT_EXTRA_TEXT)
1322         {
1323             AcpiOsPrintf ("%s", Info->Name);
1324             continue;
1325         }
1326
1327         /* Start a new line and decode the opcode */
1328
1329         AcpiDmLineHeader (CurrentOffset, ByteLength, Info->Name);
1330
1331         switch (Info->Opcode)
1332         {
1333         /* Single-bit Flag fields. Note: Opcode is the bit position */
1334
1335         case ACPI_DMT_FLAG0:
1336         case ACPI_DMT_FLAG1:
1337         case ACPI_DMT_FLAG2:
1338         case ACPI_DMT_FLAG3:
1339         case ACPI_DMT_FLAG4:
1340         case ACPI_DMT_FLAG5:
1341         case ACPI_DMT_FLAG6:
1342         case ACPI_DMT_FLAG7:
1343
1344             AcpiOsPrintf ("%1.1X\n", (*Target >> Info->Opcode) & 0x01);
1345             break;
1346
1347         /* 2-bit Flag fields */
1348
1349         case ACPI_DMT_FLAGS0:
1350
1351             AcpiOsPrintf ("%1.1X\n", *Target & 0x03);
1352             break;
1353
1354         case ACPI_DMT_FLAGS1:
1355
1356             AcpiOsPrintf ("%1.1X\n", (*Target >> 1) & 0x03);
1357             break;
1358
1359         case ACPI_DMT_FLAGS2:
1360
1361             AcpiOsPrintf ("%1.1X\n", (*Target >> 2) & 0x03);
1362             break;
1363
1364         case ACPI_DMT_FLAGS4:
1365
1366             AcpiOsPrintf ("%1.1X\n", (*Target >> 4) & 0x03);
1367             break;
1368
1369         case ACPI_DMT_FLAGS4_0:
1370
1371             AcpiOsPrintf ("%1.1X\n", (*(UINT32 *)Target) & 0x0F);
1372             break;
1373
1374         case ACPI_DMT_FLAGS4_4:
1375
1376             AcpiOsPrintf ("%1.1X\n", (*(UINT32 *)Target >> 4) & 0x0F);
1377             break;
1378
1379         case ACPI_DMT_FLAGS4_8:
1380
1381             AcpiOsPrintf ("%1.1X\n", (*(UINT32 *)Target >> 8) & 0x0F);
1382             break;
1383
1384         case ACPI_DMT_FLAGS4_12:
1385
1386             AcpiOsPrintf ("%1.1X\n", (*(UINT32 *)Target >> 12) & 0x0F);
1387             break;
1388
1389         case ACPI_DMT_FLAGS16_16:
1390
1391             AcpiOsPrintf ("%4.4X\n", (*(UINT32 *)Target >> 16) & 0xFFFF);
1392             break;
1393
1394         /* Integer Data Types */
1395
1396         case ACPI_DMT_UINT8:
1397         case ACPI_DMT_UINT16:
1398         case ACPI_DMT_UINT24:
1399         case ACPI_DMT_UINT32:
1400         case ACPI_DMT_UINT40:
1401         case ACPI_DMT_UINT48:
1402         case ACPI_DMT_UINT56:
1403         case ACPI_DMT_UINT64:
1404             /*
1405              * Dump bytes - high byte first, low byte last.
1406              * Note: All ACPI tables are little-endian.
1407              */
1408             Value = 0;
1409             for (Temp8 = (UINT8) ByteLength; Temp8 > 0; Temp8--)
1410             {
1411                 AcpiOsPrintf ("%2.2X", Target[Temp8 - 1]);
1412                 Value |= Target[Temp8 - 1];
1413                 Value <<= 8;
1414             }
1415
1416             if (!Value && (Info->Flags & DT_DESCRIBES_OPTIONAL))
1417             {
1418                 AcpiOsPrintf (" [Optional field not present]");
1419             }
1420
1421             AcpiOsPrintf ("\n");
1422             break;
1423
1424         case ACPI_DMT_BUF7:
1425         case ACPI_DMT_BUF10:
1426         case ACPI_DMT_BUF12:
1427         case ACPI_DMT_BUF16:
1428         case ACPI_DMT_BUF18:
1429         case ACPI_DMT_BUF128:
1430             /*
1431              * Buffer: Size depends on the opcode and was set above.
1432              * Each hex byte is separated with a space.
1433              * Multiple lines are separated by line continuation char.
1434              */
1435             for (Temp16 = 0; Temp16 < ByteLength; Temp16++)
1436             {
1437                 AcpiOsPrintf ("%2.2X", Target[Temp16]);
1438                 if ((UINT32) (Temp16 + 1) < ByteLength)
1439                 {
1440                     if ((Temp16 > 0) && (!((Temp16+1) % 16)))
1441                     {
1442                         AcpiOsPrintf (" \\\n"); /* Line continuation */
1443                         AcpiDmLineHeader (0, 0, NULL);
1444                     }
1445                     else
1446                     {
1447                         AcpiOsPrintf (" ");
1448                     }
1449                 }
1450             }
1451
1452             AcpiOsPrintf ("\n");
1453             break;
1454
1455         case ACPI_DMT_UUID:
1456
1457             /* Convert 16-byte UUID buffer to 36-byte formatted UUID string */
1458
1459             (void) AcpiUtConvertUuidToString ((char *) Target, AslGbl_MsgBuffer);
1460
1461             AcpiOsPrintf ("%s\n", AslGbl_MsgBuffer);
1462             break;
1463
1464         case ACPI_DMT_STRING:
1465
1466             AcpiOsPrintf ("\"%s\"\n", ACPI_CAST_PTR (char, Target));
1467             break;
1468
1469         case ACPI_DMT_IVRS_UNTERMINATED_STRING:
1470
1471             AcpiOsPrintf ("\"%.*s\"\n", ByteLength, ACPI_CAST_PTR (char, Target));
1472             break;
1473
1474         /* Fixed length ASCII name fields */
1475
1476         case ACPI_DMT_SIG:
1477
1478             AcpiUtCheckAndRepairAscii (Target, RepairedName, 4);
1479             AcpiOsPrintf ("\"%.4s\"    ", RepairedName);
1480
1481             TableData = AcpiAhGetTableInfo (ACPI_CAST_PTR (char, Target));
1482             if (TableData)
1483             {
1484                 AcpiOsPrintf (STRING_FORMAT, TableData->Description);
1485             }
1486             else
1487             {
1488                 AcpiOsPrintf ("\n");
1489             }
1490             break;
1491
1492         case ACPI_DMT_NAME4:
1493
1494             AcpiUtCheckAndRepairAscii (Target, RepairedName, 4);
1495             AcpiOsPrintf ("\"%.4s\"\n", RepairedName);
1496             break;
1497
1498         case ACPI_DMT_NAME6:
1499
1500             AcpiUtCheckAndRepairAscii (Target, RepairedName, 6);
1501             AcpiOsPrintf ("\"%.6s\"\n", RepairedName);
1502             break;
1503
1504         case ACPI_DMT_NAME8:
1505
1506             AcpiUtCheckAndRepairAscii (Target, RepairedName, 8);
1507             AcpiOsPrintf ("\"%.8s\"\n", RepairedName);
1508             break;
1509
1510         /* Special Data Types */
1511
1512         case ACPI_DMT_CHKSUM:
1513
1514             /* Checksum, display and validate */
1515
1516             AcpiOsPrintf ("%2.2X", *Target);
1517             Temp8 = AcpiDmGenerateChecksum (Table,
1518                 ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Length,
1519                 ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum);
1520
1521             if (Temp8 != ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum)
1522             {
1523                 AcpiOsPrintf (
1524                     "     /* Incorrect checksum, should be %2.2X */", Temp8);
1525             }
1526
1527             AcpiOsPrintf ("\n");
1528             break;
1529
1530         case ACPI_DMT_SPACEID:
1531
1532             /* Address Space ID */
1533
1534             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiUtGetRegionName (*Target));
1535             break;
1536
1537         case ACPI_DMT_ACCWIDTH:
1538
1539             /* Encoded Access Width */
1540
1541             Temp8 = *Target;
1542             if (Temp8 > ACPI_GAS_WIDTH_RESERVED)
1543             {
1544                 Temp8 = ACPI_GAS_WIDTH_RESERVED;
1545             }
1546
1547             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmGasAccessWidth[Temp8]);
1548             break;
1549
1550         case ACPI_DMT_GAS:
1551
1552             /* Generic Address Structure */
1553
1554             AcpiOsPrintf (STRING_FORMAT, "Generic Address Structure");
1555             Status = AcpiDmDumpTable (TableLength, CurrentOffset, Target,
1556                 sizeof (ACPI_GENERIC_ADDRESS), AcpiDmTableInfoGas);
1557             if (ACPI_FAILURE (Status))
1558             {
1559                 return (Status);
1560             }
1561
1562             AcpiOsPrintf ("\n");
1563             LastOutputBlankLine = TRUE;
1564             break;
1565
1566         case ACPI_DMT_AEST:
1567
1568             /* AEST subtable types */
1569
1570             Temp8 = *Target;
1571             if (Temp8 > ACPI_AEST_NODE_TYPE_RESERVED)
1572             {
1573                 Temp8 = ACPI_AEST_NODE_TYPE_RESERVED;
1574             }
1575
1576             AcpiOsPrintf (UINT8_FORMAT, *Target,
1577                 AcpiDmAestSubnames[Temp8]);
1578             break;
1579
1580         case ACPI_DMT_AEST_CACHE:
1581
1582             /* AEST cache resource subtable */
1583
1584             Temp32 = *Target;
1585             if (Temp32 > ACPI_AEST_CACHE_RESERVED)
1586             {
1587                 Temp32 = ACPI_AEST_CACHE_RESERVED;
1588             }
1589
1590             AcpiOsPrintf (UINT32_FORMAT, *Target,
1591                 AcpiDmAestCacheNames[Temp32]);
1592             break;
1593
1594         case ACPI_DMT_AEST_GIC:
1595
1596             /* AEST GIC error subtable */
1597
1598             Temp32 = *Target;
1599             if (Temp32 > ACPI_AEST_GIC_RESERVED)
1600             {
1601                 Temp32 = ACPI_AEST_GIC_RESERVED;
1602             }
1603
1604             AcpiOsPrintf (UINT32_FORMAT, *Target,
1605                 AcpiDmAestGicNames[Temp32]);
1606             break;
1607
1608         case ACPI_DMT_AEST_RES:
1609
1610             /* AEST resource type subtable */
1611
1612             Temp8 = *Target;
1613             if (Temp8 > ACPI_AEST_RESOURCE_RESERVED)
1614             {
1615                 Temp8 = ACPI_AEST_RESOURCE_RESERVED;
1616             }
1617
1618             AcpiOsPrintf (UINT8_FORMAT, *Target,
1619                 AcpiDmAestResourceNames[Temp8]);
1620             break;
1621
1622         case ACPI_DMT_AEST_XFACE:
1623
1624             /* AEST interface structure types */
1625
1626             Temp8 = *Target;
1627             if (Temp8 > ACPI_AEST_XFACE_RESERVED)
1628             {
1629                 Temp8 = ACPI_AEST_XFACE_RESERVED;
1630             }
1631
1632             AcpiOsPrintf (UINT8_FORMAT, *Target,
1633                 AcpiDmAestXfaceNames[Temp8]);
1634             break;
1635
1636         case ACPI_DMT_AEST_XRUPT:
1637
1638             /* AEST interrupt structure types */
1639
1640             Temp8 = *Target;
1641             if (Temp8 > ACPI_AEST_XRUPT_RESERVED)
1642             {
1643                 Temp8 = ACPI_AEST_XRUPT_RESERVED;
1644             }
1645
1646             AcpiOsPrintf (UINT8_FORMAT, *Target,
1647                 AcpiDmAestXruptNames[Temp8]);
1648             break;
1649
1650         case ACPI_DMT_ASF:
1651
1652             /* ASF subtable types */
1653
1654             Temp16 = (UINT16) ((*Target) & 0x7F);  /* Top bit can be zero or one */
1655             if (Temp16 > ACPI_ASF_TYPE_RESERVED)
1656             {
1657                 Temp16 = ACPI_ASF_TYPE_RESERVED;
1658             }
1659
1660             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmAsfSubnames[Temp16]);
1661             break;
1662
1663         case ACPI_DMT_CEDT:
1664
1665             /* CEDT subtable types */
1666
1667             Temp8 = *Target;
1668             if (Temp8 > ACPI_CEDT_TYPE_RESERVED)
1669             {
1670                 Temp8 = ACPI_CEDT_TYPE_RESERVED;
1671             }
1672
1673             AcpiOsPrintf (UINT8_FORMAT, *Target,
1674                 AcpiDmCedtSubnames[Temp8]);
1675             break;
1676
1677         case ACPI_DMT_DMAR:
1678
1679             /* DMAR subtable types */
1680
1681             Temp16 = ACPI_GET16 (Target);
1682             if (Temp16 > ACPI_DMAR_TYPE_RESERVED)
1683             {
1684                 Temp16 = ACPI_DMAR_TYPE_RESERVED;
1685             }
1686
1687             AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target),
1688                 AcpiDmDmarSubnames[Temp16]);
1689             break;
1690
1691         case ACPI_DMT_DMAR_SCOPE:
1692
1693             /* DMAR device scope types */
1694
1695             Temp8 = *Target;
1696             if (Temp8 > ACPI_DMAR_SCOPE_TYPE_RESERVED)
1697             {
1698                 Temp8 = ACPI_DMAR_SCOPE_TYPE_RESERVED;
1699             }
1700
1701             AcpiOsPrintf (UINT8_FORMAT, *Target,
1702                 AcpiDmDmarScope[Temp8]);
1703             break;
1704
1705         case ACPI_DMT_EINJACT:
1706
1707             /* EINJ Action types */
1708
1709             Temp8 = *Target;
1710             if (Temp8 > ACPI_EINJ_ACTION_RESERVED)
1711             {
1712                 Temp8 = ACPI_EINJ_ACTION_RESERVED;
1713             }
1714
1715             AcpiOsPrintf (UINT8_FORMAT, *Target,
1716                 AcpiDmEinjActions[Temp8]);
1717             break;
1718
1719         case ACPI_DMT_EINJINST:
1720
1721             /* EINJ Instruction types */
1722
1723             Temp8 = *Target;
1724             if (Temp8 > ACPI_EINJ_INSTRUCTION_RESERVED)
1725             {
1726                 Temp8 = ACPI_EINJ_INSTRUCTION_RESERVED;
1727             }
1728
1729             AcpiOsPrintf (UINT8_FORMAT, *Target,
1730                 AcpiDmEinjInstructions[Temp8]);
1731             break;
1732
1733         case ACPI_DMT_ERSTACT:
1734
1735             /* ERST Action types */
1736
1737             Temp8 = *Target;
1738             if (Temp8 > ACPI_ERST_ACTION_RESERVED)
1739             {
1740                 Temp8 = ACPI_ERST_ACTION_RESERVED;
1741             }
1742
1743             AcpiOsPrintf (UINT8_FORMAT, *Target,
1744                 AcpiDmErstActions[Temp8]);
1745             break;
1746
1747         case ACPI_DMT_ERSTINST:
1748
1749             /* ERST Instruction types */
1750
1751             Temp8 = *Target;
1752             if (Temp8 > ACPI_ERST_INSTRUCTION_RESERVED)
1753             {
1754                 Temp8 = ACPI_ERST_INSTRUCTION_RESERVED;
1755             }
1756
1757             AcpiOsPrintf (UINT8_FORMAT, *Target,
1758                 AcpiDmErstInstructions[Temp8]);
1759             break;
1760
1761         case ACPI_DMT_GTDT:
1762
1763             /* GTDT subtable types */
1764
1765             Temp8 = *Target;
1766             if (Temp8 > ACPI_GTDT_TYPE_RESERVED)
1767             {
1768                 Temp8 = ACPI_GTDT_TYPE_RESERVED;
1769             }
1770
1771             AcpiOsPrintf (UINT8_FORMAT, *Target,
1772                 AcpiDmGtdtSubnames[Temp8]);
1773             break;
1774
1775         case ACPI_DMT_HEST:
1776
1777             /* HEST subtable types */
1778
1779             Temp16 = ACPI_GET16 (Target);
1780             if (Temp16 > ACPI_HEST_TYPE_RESERVED)
1781             {
1782                 Temp16 = ACPI_HEST_TYPE_RESERVED;
1783             }
1784
1785             AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target),
1786                 AcpiDmHestSubnames[Temp16]);
1787             break;
1788
1789         case ACPI_DMT_HESTNTFY:
1790
1791             AcpiOsPrintf (STRING_FORMAT,
1792                 "Hardware Error Notification Structure");
1793
1794             Status = AcpiDmDumpTable (TableLength, CurrentOffset, Target,
1795                 sizeof (ACPI_HEST_NOTIFY), AcpiDmTableInfoHestNotify);
1796             if (ACPI_FAILURE (Status))
1797             {
1798                 return (Status);
1799             }
1800
1801             AcpiOsPrintf ("\n");
1802             LastOutputBlankLine = TRUE;
1803             break;
1804
1805         case ACPI_DMT_HESTNTYP:
1806
1807             /* HEST Notify types */
1808
1809             Temp8 = *Target;
1810             if (Temp8 > ACPI_HEST_NOTIFY_RESERVED)
1811             {
1812                 Temp8 = ACPI_HEST_NOTIFY_RESERVED;
1813             }
1814
1815             AcpiOsPrintf (UINT8_FORMAT, *Target,
1816                 AcpiDmHestNotifySubnames[Temp8]);
1817             break;
1818
1819         case ACPI_DMT_HMAT:
1820
1821             /* HMAT subtable types */
1822
1823             Temp16 = *Target;
1824             if (Temp16 > ACPI_HMAT_TYPE_RESERVED)
1825             {
1826                 Temp16 = ACPI_HMAT_TYPE_RESERVED;
1827             }
1828
1829             AcpiOsPrintf (UINT16_FORMAT, *Target,
1830                 AcpiDmHmatSubnames[Temp16]);
1831             break;
1832
1833         case ACPI_DMT_IORTMEM:
1834
1835             AcpiOsPrintf (STRING_FORMAT,
1836                 "IORT Memory Access Properties");
1837
1838             Status = AcpiDmDumpTable (TableLength, CurrentOffset, Target,
1839                 sizeof (ACPI_IORT_MEMORY_ACCESS), AcpiDmTableInfoIortAcc);
1840             if (ACPI_FAILURE (Status))
1841             {
1842                 return (Status);
1843             }
1844
1845             LastOutputBlankLine = TRUE;
1846             break;
1847
1848         case ACPI_DMT_MADT:
1849
1850             /* MADT subtable types */
1851
1852             Temp8 = *Target;
1853             if (Temp8 > ACPI_MADT_TYPE_RESERVED)
1854             {
1855                 Temp8 = ACPI_MADT_TYPE_RESERVED;
1856             }
1857
1858             AcpiOsPrintf (UINT8_FORMAT, *Target,
1859                 AcpiDmMadtSubnames[Temp8]);
1860             break;
1861
1862         case ACPI_DMT_NFIT:
1863
1864             /* NFIT subtable types */
1865
1866             Temp16 = ACPI_GET16 (Target);
1867             if (Temp16 > ACPI_NFIT_TYPE_RESERVED)
1868             {
1869                 Temp16 = ACPI_NFIT_TYPE_RESERVED;
1870             }
1871
1872             AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target),
1873                 AcpiDmNfitSubnames[Temp16]);
1874             break;
1875
1876         case ACPI_DMT_NHLT1:
1877
1878             /* NHLT link types */
1879
1880             Temp8 = *Target;
1881             if (Temp8 > ACPI_NHLT_TYPE_RESERVED)
1882             {
1883                 Temp8 = ACPI_NHLT_TYPE_RESERVED;
1884             }
1885
1886             AcpiOsPrintf (UINT8_FORMAT, *Target,
1887                 AcpiDmNhltLinkTypeNames[Temp8]);
1888             break;
1889
1890         case ACPI_DMT_NHLT1a:
1891
1892             /* NHLT direction */
1893
1894             Temp8 = *Target;
1895             if (Temp8 > ACPI_NHLT_DIR_RESERVED)
1896             {
1897                 Temp8 = ACPI_NHLT_DIR_RESERVED;
1898             }
1899
1900             AcpiOsPrintf (UINT8_FORMAT, *Target,
1901                 AcpiDmNhltDirectionNames[Temp8]);
1902             break;
1903
1904         case ACPI_DMT_NHLT1b:
1905
1906             /* NHLT microphone type */
1907
1908             Temp8 = *Target;
1909             if (Temp8 > ACPI_NHLT_MIC_RESERVED)
1910             {
1911                 Temp8 = ACPI_NHLT_MIC_RESERVED;
1912             }
1913
1914             AcpiOsPrintf (UINT8_FORMAT, *Target,
1915                 AcpiDmNhltMicTypeNames[Temp8]);
1916             break;
1917
1918         case ACPI_DMT_NHLT1c:
1919
1920             /* NHLT microphone position */
1921
1922             Temp8 = *Target;
1923             if (Temp8 > ACPI_NHLT_MIC_POSITION_RESERVED)
1924             {
1925                 Temp8 = ACPI_NHLT_MIC_POSITION_RESERVED;
1926             }
1927
1928             AcpiOsPrintf (UINT8_FORMAT, *Target,
1929                 AcpiDmNhltMicPositionNames[Temp8]);
1930             break;
1931
1932         case ACPI_DMT_NHLT1d:
1933
1934             /* NHLT microphone array type */
1935
1936             Temp8 = *Target & ACPI_NHLT_ARRAY_TYPE_MASK;
1937             if (Temp8 < ACPI_NHLT_ARRAY_TYPE_RESERVED)
1938             {
1939                 Temp8 = ACPI_NHLT_ARRAY_TYPE_RESERVED;
1940             }
1941
1942             AcpiOsPrintf (UINT8_FORMAT_NO_NEWLINE, *Target,
1943                 AcpiDmNhltMicArrayTypeNames[Temp8 - ACPI_NHLT_ARRAY_TYPE_RESERVED]);
1944
1945             Temp8 = *Target;
1946             if (Temp8 & ACPI_NHLT_MIC_SNR_SENSITIVITY_EXT)
1947             {
1948                 AcpiOsPrintf (" [%s]", "SNR and Sensitivity");
1949             }
1950
1951             AcpiOsPrintf ("\n");
1952             break;
1953
1954         case ACPI_DMT_NHLT1e:
1955
1956             /* NHLT Endpoint Device ID */
1957
1958             Temp16 = ACPI_GET16 (Target);
1959             if (Temp16 == 0xAE20)
1960             {
1961                 Name = "PDM DMIC";
1962             }
1963             else if (Temp16 == 0xAE30)
1964             {
1965                 Name = "BT Sideband";
1966             }
1967             else if (Temp16 == 0xAE34)
1968             {
1969                 Name = "I2S/TDM Codecs";
1970             }
1971             else
1972             {
1973                 Name = "Unknown Device ID";
1974             }
1975
1976             AcpiOsPrintf (UINT16_FORMAT, Temp16, Name);
1977             break;
1978
1979         case ACPI_DMT_NHLT1f:
1980
1981             /* NHLT ConfigType field */
1982
1983             Temp8 = *Target;
1984             if (Temp8 > ACPI_NHLT_CONFIG_TYPE_RESERVED)
1985             {
1986                 Temp8 = ACPI_NHLT_CONFIG_TYPE_RESERVED;
1987             }
1988
1989             AcpiOsPrintf (UINT8_FORMAT, *Target,
1990                 AcpiDmNhltConfigTypeNames[Temp8]);
1991             break;
1992
1993         case ACPI_DMT_PCCT:
1994
1995             /* PCCT subtable types */
1996
1997             Temp8 = *Target;
1998             if (Temp8 > ACPI_PCCT_TYPE_RESERVED)
1999             {
2000                 Temp8 = ACPI_PCCT_TYPE_RESERVED;
2001             }
2002
2003             AcpiOsPrintf (UINT8_FORMAT, *Target,
2004                 AcpiDmPcctSubnames[Temp8]);
2005             break;
2006
2007         case ACPI_DMT_PHAT:
2008
2009             /* PMTT subtable types */
2010
2011             Temp16 = *Target;
2012             if (Temp16 > ACPI_PHAT_TYPE_RESERVED)
2013             {
2014                 Temp16 = ACPI_PHAT_TYPE_RESERVED;
2015             }
2016
2017             AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16(Target),
2018                 AcpiDmPhatSubnames[Temp16]);
2019             break;
2020
2021         case ACPI_DMT_PMTT:
2022
2023             /* PMTT subtable types */
2024
2025             Temp8 = *Target;
2026             if (Temp8 == ACPI_PMTT_TYPE_VENDOR)
2027             {
2028                 Temp8 = ACPI_PMTT_TYPE_RESERVED + 1;
2029             }
2030             else if (Temp8 > ACPI_PMTT_TYPE_RESERVED)
2031             {
2032                 Temp8 = ACPI_PMTT_TYPE_RESERVED;
2033             }
2034             AcpiOsPrintf (UINT8_FORMAT, *Target,
2035                 AcpiDmPmttSubnames[Temp8]);
2036             break;
2037
2038         case ACPI_DMT_PPTT:
2039
2040             /* PPTT subtable types */
2041
2042             Temp8 = *Target;
2043             if (Temp8 > ACPI_PPTT_TYPE_RESERVED)
2044             {
2045                 Temp8 = ACPI_PPTT_TYPE_RESERVED;
2046             }
2047
2048             AcpiOsPrintf (UINT8_FORMAT, *Target,
2049                 AcpiDmPpttSubnames[Temp8]);
2050             break;
2051
2052         case ACPI_DMT_UNICODE:
2053         case ACPI_DMT_WPBT_UNICODE:
2054
2055             if (ByteLength == 0)
2056             {
2057                 AcpiOsPrintf ("/* Zero-length Data */\n");
2058                 break;
2059             }
2060
2061             AcpiDmDumpUnicode (Table, CurrentOffset, ByteLength);
2062             break;
2063
2064         case ACPI_DMT_RAW_BUFFER:
2065         case ACPI_DMT_BUFFER:
2066         case ACPI_DMT_PMTT_VENDOR:
2067
2068             if (ByteLength == 0)
2069             {
2070                 AcpiOsPrintf ("/* Zero-length Data */\n");
2071                 break;
2072             }
2073
2074             AcpiDmDumpBuffer (Target, 0, ByteLength, CurrentOffset, NULL);
2075             break;
2076
2077         case ACPI_DMT_RGRT:
2078
2079             /* RGRT subtable types */
2080
2081             Temp8 = *Target;
2082             if (Temp8 >= ACPI_RGRT_TYPE_RESERVED)
2083             {
2084                 Temp8 = ACPI_RGRT_TYPE_RESERVED0;
2085             }
2086
2087             AcpiOsPrintf (UINT8_FORMAT, *Target,
2088                 AcpiDmRgrtSubnames[Temp8]);
2089             break;
2090
2091         case ACPI_DMT_SDEV:
2092
2093             /* SDEV subtable types */
2094
2095             Temp8 = *Target;
2096             if (Temp8 > ACPI_SDEV_TYPE_RESERVED)
2097             {
2098                 Temp8 = ACPI_SDEV_TYPE_RESERVED;
2099             }
2100
2101             AcpiOsPrintf (UINT8_FORMAT, *Target,
2102                 AcpiDmSdevSubnames[Temp8]);
2103             break;
2104
2105         case ACPI_DMT_SRAT:
2106
2107             /* SRAT subtable types */
2108
2109             Temp8 = *Target;
2110             if (Temp8 > ACPI_SRAT_TYPE_RESERVED)
2111             {
2112                 Temp8 = ACPI_SRAT_TYPE_RESERVED;
2113             }
2114
2115             AcpiOsPrintf (UINT8_FORMAT, *Target,
2116                 AcpiDmSratSubnames[Temp8]);
2117             break;
2118
2119         case ACPI_DMT_TPM2:
2120
2121             /* TPM2 Start Method types */
2122
2123             Temp8 = *Target;
2124             if (Temp8 > ACPI_TPM2_RESERVED)
2125             {
2126                 Temp8 = ACPI_TPM2_RESERVED;
2127             }
2128
2129             AcpiOsPrintf (UINT8_FORMAT, *Target,
2130                 AcpiDmTpm2Subnames[Temp8]);
2131             break;
2132
2133
2134         case ACPI_DMT_FADTPM:
2135
2136             /* FADT Preferred PM Profile names */
2137
2138             Temp8 = *Target;
2139             if (Temp8 > ACPI_FADT_PM_RESERVED)
2140             {
2141                 Temp8 = ACPI_FADT_PM_RESERVED;
2142             }
2143
2144             AcpiOsPrintf (UINT8_FORMAT, *Target,
2145                 AcpiDmFadtProfiles[Temp8]);
2146             break;
2147
2148         case ACPI_DMT_IVRS:
2149
2150             /* IVRS subtable types */
2151
2152             Temp8 = *Target;
2153             switch (Temp8)
2154             {
2155             case ACPI_IVRS_TYPE_HARDWARE1:
2156             case ACPI_IVRS_TYPE_HARDWARE2:
2157
2158                 Name = AcpiDmIvrsSubnames[0];
2159                 break;
2160
2161             case ACPI_IVRS_TYPE_HARDWARE3:
2162
2163                 Name = AcpiDmIvrsSubnames[1];
2164                 break;
2165
2166             case ACPI_IVRS_TYPE_MEMORY1:
2167             case ACPI_IVRS_TYPE_MEMORY2:
2168             case ACPI_IVRS_TYPE_MEMORY3:
2169
2170                 Name = AcpiDmIvrsSubnames[2];
2171                 break;
2172
2173             default:
2174
2175                 Name = AcpiDmIvrsSubnames[3];
2176                 break;
2177             }
2178
2179             AcpiOsPrintf (UINT8_FORMAT, *Target, Name);
2180             break;
2181
2182         case ACPI_DMT_IVRS_DE:
2183
2184             /* IVRS device entry types */
2185
2186             Temp8 = *Target;
2187             switch (Temp8)
2188             {
2189             case ACPI_IVRS_TYPE_ALL:
2190             case ACPI_IVRS_TYPE_SELECT:
2191             case ACPI_IVRS_TYPE_START:
2192             case ACPI_IVRS_TYPE_END:
2193
2194                 Name = AcpiDmIvrsDevEntryNames[Temp8];
2195                 break;
2196
2197             case ACPI_IVRS_TYPE_ALIAS_SELECT:
2198             case ACPI_IVRS_TYPE_ALIAS_START:
2199             case ACPI_IVRS_TYPE_EXT_SELECT:
2200             case ACPI_IVRS_TYPE_EXT_START:
2201             case ACPI_IVRS_TYPE_SPECIAL:
2202
2203                 Name = AcpiDmIvrsDevEntryNames[Temp8 - 61];
2204                 break;
2205
2206             case ACPI_IVRS_TYPE_HID:
2207
2208                 Name = AcpiDmIvrsDevEntryNames[Temp8 - 228];
2209                 break;
2210
2211             default:
2212                 Name = AcpiDmIvrsDevEntryNames[0];  /* Unknown/Reserved */
2213                 break;
2214             }
2215
2216             AcpiOsPrintf (UINT8_FORMAT, *Target, Name);
2217             break;
2218
2219         case ACPI_DMT_LPIT:
2220
2221             /* LPIT subtable types */
2222
2223             Temp32 = ACPI_GET32 (Target);
2224             if (Temp32 > ACPI_LPIT_TYPE_RESERVED)
2225             {
2226                 Temp32 = ACPI_LPIT_TYPE_RESERVED;
2227             }
2228
2229             AcpiOsPrintf (UINT32_FORMAT, ACPI_GET32 (Target),
2230                 AcpiDmLpitSubnames[Temp32]);
2231             break;
2232
2233         case ACPI_DMT_VIOT:
2234
2235             /* VIOT subtable types */
2236
2237             Temp8 = *Target;
2238             if (Temp8 > ACPI_VIOT_RESERVED)
2239             {
2240                 Temp8 = ACPI_VIOT_RESERVED;
2241             }
2242
2243             AcpiOsPrintf (UINT8_FORMAT, *Target,
2244                 AcpiDmViotSubnames[Temp8]);
2245             break;
2246
2247         case ACPI_DMT_EXIT:
2248
2249             return (AE_OK);
2250
2251         default:
2252
2253             ACPI_ERROR ((AE_INFO,
2254                 "**** Invalid table opcode [0x%X] ****\n", Info->Opcode));
2255             return (AE_SUPPORT);
2256         }
2257     }
2258
2259     if (TableOffset && !SubtableLength)
2260     {
2261         /*
2262          * If this table is not the main table, the subtable must have a
2263          * valid length
2264          */
2265         AcpiOsPrintf ("Invalid zero length subtable\n");
2266         return (AE_BAD_DATA);
2267     }
2268
2269     return (AE_OK);
2270 }