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