1 /****************************************************************************** 2 * 3 * Module Name: dmtable - Support for ACPI tables that contain no AML code 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include "acpi.h" 45 #include "accommon.h" 46 #include "acdisasm.h" 47 #include "actables.h" 48 #include "aslcompiler.h" 49 #include "dtcompiler.h" 50 51 /* This module used for application-level code only */ 52 53 #define _COMPONENT ACPI_CA_DISASSEMBLER 54 ACPI_MODULE_NAME ("dmtable") 55 56 const AH_TABLE * 57 AcpiAhGetTableInfo ( 58 char *Signature); 59 60 61 /* Local Prototypes */ 62 63 static void 64 AcpiDmCheckAscii ( 65 UINT8 *Target, 66 char *RepairedName, 67 UINT32 Count); 68 69 70 /* Common format strings for commented values */ 71 72 #define UINT8_FORMAT "%2.2X [%s]\n" 73 #define UINT16_FORMAT "%4.4X [%s]\n" 74 #define UINT32_FORMAT "%8.8X [%s]\n" 75 #define STRING_FORMAT "[%s]\n" 76 77 /* These tables map a subtable type to a description string */ 78 79 static const char *AcpiDmAsfSubnames[] = 80 { 81 "ASF Information", 82 "ASF Alerts", 83 "ASF Remote Control", 84 "ASF RMCP Boot Options", 85 "ASF Address", 86 "Unknown Subtable Type" /* Reserved */ 87 }; 88 89 static const char *AcpiDmDmarSubnames[] = 90 { 91 "Hardware Unit Definition", 92 "Reserved Memory Region", 93 "Root Port ATS Capability", 94 "Remapping Hardware Static Affinity", 95 "ACPI Namespace Device Declaration", 96 "Unknown Subtable Type" /* Reserved */ 97 }; 98 99 static const char *AcpiDmDmarScope[] = 100 { 101 "Reserved value", 102 "PCI Endpoint Device", 103 "PCI Bridge Device", 104 "IOAPIC Device", 105 "Message-capable HPET Device", 106 "Namespace Device", 107 "Unknown Scope Type" /* Reserved */ 108 }; 109 110 static const char *AcpiDmEinjActions[] = 111 { 112 "Begin Operation", 113 "Get Trigger Table", 114 "Set Error Type", 115 "Get Error Type", 116 "End Operation", 117 "Execute Operation", 118 "Check Busy Status", 119 "Get Command Status", 120 "Set Error Type With Address", 121 "Unknown Action" 122 }; 123 124 static const char *AcpiDmEinjInstructions[] = 125 { 126 "Read Register", 127 "Read Register Value", 128 "Write Register", 129 "Write Register Value", 130 "Noop", 131 "Flush Cacheline", 132 "Unknown Instruction" 133 }; 134 135 static const char *AcpiDmErstActions[] = 136 { 137 "Begin Write Operation", 138 "Begin Read Operation", 139 "Begin Clear Operation", 140 "End Operation", 141 "Set Record Offset", 142 "Execute Operation", 143 "Check Busy Status", 144 "Get Command Status", 145 "Get Record Identifier", 146 "Set Record Identifier", 147 "Get Record Count", 148 "Begin Dummy Write", 149 "Unused/Unknown Action", 150 "Get Error Address Range", 151 "Get Error Address Length", 152 "Get Error Attributes", 153 "Unknown Action" 154 }; 155 156 static const char *AcpiDmErstInstructions[] = 157 { 158 "Read Register", 159 "Read Register Value", 160 "Write Register", 161 "Write Register Value", 162 "Noop", 163 "Load Var1", 164 "Load Var2", 165 "Store Var1", 166 "Add", 167 "Subtract", 168 "Add Value", 169 "Subtract Value", 170 "Stall", 171 "Stall While True", 172 "Skip Next If True", 173 "GoTo", 174 "Set Source Address", 175 "Set Destination Address", 176 "Move Data", 177 "Unknown Instruction" 178 }; 179 180 static const char *AcpiDmGtdtSubnames[] = 181 { 182 "Generic Timer Block", 183 "Generic Watchdog Timer", 184 "Unknown Subtable Type" /* Reserved */ 185 }; 186 187 static const char *AcpiDmHestSubnames[] = 188 { 189 "IA-32 Machine Check Exception", 190 "IA-32 Corrected Machine Check", 191 "IA-32 Non-Maskable Interrupt", 192 "Unknown SubTable Type", /* 3 - Reserved */ 193 "Unknown SubTable Type", /* 4 - Reserved */ 194 "Unknown SubTable Type", /* 5 - Reserved */ 195 "PCI Express Root Port AER", 196 "PCI Express AER (AER Endpoint)", 197 "PCI Express/PCI-X Bridge AER", 198 "Generic Hardware Error Source", 199 "Generic Hardware Error Source V2", 200 "Unknown Subtable Type" /* Reserved */ 201 }; 202 203 static const char *AcpiDmHestNotifySubnames[] = 204 { 205 "Polled", 206 "External Interrupt", 207 "Local Interrupt", 208 "SCI", 209 "NMI", 210 "CMCI", /* ACPI 5.0 */ 211 "MCE", /* ACPI 5.0 */ 212 "Unknown Notify Type" /* Reserved */ 213 }; 214 215 static const char *AcpiDmMadtSubnames[] = 216 { 217 "Processor Local APIC", /* ACPI_MADT_TYPE_LOCAL_APIC */ 218 "I/O APIC", /* ACPI_MADT_TYPE_IO_APIC */ 219 "Interrupt Source Override", /* ACPI_MADT_TYPE_INTERRUPT_OVERRIDE */ 220 "NMI Source", /* ACPI_MADT_TYPE_NMI_SOURCE */ 221 "Local APIC NMI", /* ACPI_MADT_TYPE_LOCAL_APIC_NMI */ 222 "Local APIC Address Override", /* ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE */ 223 "I/O SAPIC", /* ACPI_MADT_TYPE_IO_SAPIC */ 224 "Local SAPIC", /* ACPI_MADT_TYPE_LOCAL_SAPIC */ 225 "Platform Interrupt Sources", /* ACPI_MADT_TYPE_INTERRUPT_SOURCE */ 226 "Processor Local x2APIC", /* ACPI_MADT_TYPE_LOCAL_X2APIC */ 227 "Local x2APIC NMI", /* ACPI_MADT_TYPE_LOCAL_X2APIC_NMI */ 228 "Generic Interrupt Controller", /* ACPI_MADT_GENERIC_INTERRUPT */ 229 "Generic Interrupt Distributor", /* ACPI_MADT_GENERIC_DISTRIBUTOR */ 230 "Generic MSI Frame", /* ACPI_MADT_GENERIC_MSI_FRAME */ 231 "Generic Interrupt Redistributor", /* ACPI_MADT_GENERIC_REDISTRIBUTOR */ 232 "Generic Interrupt Translator", /* ACPI_MADT_GENERIC_TRANSLATOR */ 233 "Unknown Subtable Type" /* Reserved */ 234 }; 235 236 static const char *AcpiDmNfitSubnames[] = 237 { 238 "System Physical Address Range", /* ACPI_NFIT_TYPE_SYSTEM_ADDRESS */ 239 "Memory Range Map", /* ACPI_NFIT_TYPE_MEMORY_MAP */ 240 "Interleave Info", /* ACPI_NFIT_TYPE_INTERLEAVE */ 241 "SMBIOS Information", /* ACPI_NFIT_TYPE_SMBIOS */ 242 "NVDIMM Control Region", /* ACPI_NFIT_TYPE_CONTROL_REGION */ 243 "NVDIMM Block Data Window Region", /* ACPI_NFIT_TYPE_DATA_REGION */ 244 "Flush Hint Address", /* ACPI_NFIT_TYPE_FLUSH_ADDRESS */ 245 "Unknown Subtable Type" /* Reserved */ 246 }; 247 248 static const char *AcpiDmPcctSubnames[] = 249 { 250 "Generic Communications Subspace", /* ACPI_PCCT_TYPE_GENERIC_SUBSPACE */ 251 "HW-Reduced Comm Subspace", /* ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE */ 252 "Unknown Subtable Type" /* Reserved */ 253 }; 254 255 static const char *AcpiDmPmttSubnames[] = 256 { 257 "Socket", /* ACPI_PMTT_TYPE_SOCKET */ 258 "Memory Controller", /* ACPI_PMTT_TYPE_CONTROLLER */ 259 "Physical Component (DIMM)", /* ACPI_PMTT_TYPE_DIMM */ 260 "Unknown Subtable Type" /* Reserved */ 261 }; 262 263 static const char *AcpiDmSratSubnames[] = 264 { 265 "Processor Local APIC/SAPIC Affinity", 266 "Memory Affinity", 267 "Processor Local x2APIC Affinity", 268 "GICC Affinity", 269 "Unknown Subtable Type" /* Reserved */ 270 }; 271 272 static const char *AcpiDmIvrsSubnames[] = 273 { 274 "Hardware Definition Block", 275 "Memory Definition Block", 276 "Unknown Subtable Type" /* Reserved */ 277 }; 278 279 static const char *AcpiDmLpitSubnames[] = 280 { 281 "Native C-state Idle Structure", 282 "Unknown Subtable Type" /* Reserved */ 283 }; 284 285 #define ACPI_FADT_PM_RESERVED 9 286 287 static const char *AcpiDmFadtProfiles[] = 288 { 289 "Unspecified", 290 "Desktop", 291 "Mobile", 292 "Workstation", 293 "Enterprise Server", 294 "SOHO Server", 295 "Appliance PC", 296 "Performance Server", 297 "Tablet", 298 "Unknown Profile Type" 299 }; 300 301 #define ACPI_GAS_WIDTH_RESERVED 5 302 303 static const char *AcpiDmGasAccessWidth[] = 304 { 305 "Undefined/Legacy", 306 "Byte Access:8", 307 "Word Access:16", 308 "DWord Access:32", 309 "QWord Access:64", 310 "Unknown Width Encoding" 311 }; 312 313 314 /******************************************************************************* 315 * 316 * ACPI Table Data, indexed by signature. 317 * 318 * Each entry contains: Signature, Table Info, Handler, DtHandler, 319 * Template, Description 320 * 321 * Simple tables have only a TableInfo structure, complex tables have a 322 * handler. This table must be NULL terminated. RSDP and FACS are 323 * special-cased elsewhere. 324 * 325 * Note: Any tables added here should be duplicated within AcpiSupportedTables 326 * in the file common/ahtable.c 327 * 328 ******************************************************************************/ 329 330 const ACPI_DMTABLE_DATA AcpiDmTableData[] = 331 { 332 {ACPI_SIG_ASF, NULL, AcpiDmDumpAsf, DtCompileAsf, TemplateAsf}, 333 {ACPI_SIG_BERT, AcpiDmTableInfoBert, NULL, NULL, TemplateBert}, 334 {ACPI_SIG_BGRT, AcpiDmTableInfoBgrt, NULL, NULL, TemplateBgrt}, 335 {ACPI_SIG_BOOT, AcpiDmTableInfoBoot, NULL, NULL, TemplateBoot}, 336 {ACPI_SIG_CPEP, NULL, AcpiDmDumpCpep, DtCompileCpep, TemplateCpep}, 337 {ACPI_SIG_CSRT, NULL, AcpiDmDumpCsrt, DtCompileCsrt, TemplateCsrt}, 338 {ACPI_SIG_DBG2, AcpiDmTableInfoDbg2, AcpiDmDumpDbg2, DtCompileDbg2, TemplateDbg2}, 339 {ACPI_SIG_DBGP, AcpiDmTableInfoDbgp, NULL, NULL, TemplateDbgp}, 340 {ACPI_SIG_DMAR, NULL, AcpiDmDumpDmar, DtCompileDmar, TemplateDmar}, 341 {ACPI_SIG_DRTM, NULL, AcpiDmDumpDrtm, DtCompileDrtm, TemplateDrtm}, 342 {ACPI_SIG_ECDT, AcpiDmTableInfoEcdt, NULL, NULL, TemplateEcdt}, 343 {ACPI_SIG_EINJ, NULL, AcpiDmDumpEinj, DtCompileEinj, TemplateEinj}, 344 {ACPI_SIG_ERST, NULL, AcpiDmDumpErst, DtCompileErst, TemplateErst}, 345 {ACPI_SIG_FADT, NULL, AcpiDmDumpFadt, DtCompileFadt, TemplateFadt}, 346 {ACPI_SIG_FPDT, NULL, AcpiDmDumpFpdt, DtCompileFpdt, TemplateFpdt}, 347 {ACPI_SIG_GTDT, NULL, AcpiDmDumpGtdt, DtCompileGtdt, TemplateGtdt}, 348 {ACPI_SIG_HEST, NULL, AcpiDmDumpHest, DtCompileHest, TemplateHest}, 349 {ACPI_SIG_HPET, AcpiDmTableInfoHpet, NULL, NULL, TemplateHpet}, 350 {ACPI_SIG_IORT, NULL, AcpiDmDumpIort, DtCompileIort, TemplateIort}, 351 {ACPI_SIG_IVRS, NULL, AcpiDmDumpIvrs, DtCompileIvrs, TemplateIvrs}, 352 {ACPI_SIG_LPIT, NULL, AcpiDmDumpLpit, DtCompileLpit, TemplateLpit}, 353 {ACPI_SIG_MADT, NULL, AcpiDmDumpMadt, DtCompileMadt, TemplateMadt}, 354 {ACPI_SIG_MCFG, NULL, AcpiDmDumpMcfg, DtCompileMcfg, TemplateMcfg}, 355 {ACPI_SIG_MCHI, AcpiDmTableInfoMchi, NULL, NULL, TemplateMchi}, 356 {ACPI_SIG_MPST, AcpiDmTableInfoMpst, AcpiDmDumpMpst, DtCompileMpst, TemplateMpst}, 357 {ACPI_SIG_MSCT, NULL, AcpiDmDumpMsct, DtCompileMsct, TemplateMsct}, 358 {ACPI_SIG_MSDM, NULL, AcpiDmDumpSlic, DtCompileSlic, TemplateMsdm}, 359 {ACPI_SIG_MTMR, NULL, AcpiDmDumpMtmr, DtCompileMtmr, TemplateMtmr}, 360 {ACPI_SIG_NFIT, AcpiDmTableInfoNfit, AcpiDmDumpNfit, DtCompileNfit, TemplateNfit}, 361 {ACPI_SIG_PCCT, AcpiDmTableInfoPcct, AcpiDmDumpPcct, DtCompilePcct, TemplatePcct}, 362 {ACPI_SIG_PMTT, NULL, AcpiDmDumpPmtt, DtCompilePmtt, TemplatePmtt}, 363 {ACPI_SIG_RSDT, NULL, AcpiDmDumpRsdt, DtCompileRsdt, TemplateRsdt}, 364 {ACPI_SIG_S3PT, NULL, NULL, NULL, TemplateS3pt}, 365 {ACPI_SIG_SBST, AcpiDmTableInfoSbst, NULL, NULL, TemplateSbst}, 366 {ACPI_SIG_SLIC, NULL, AcpiDmDumpSlic, DtCompileSlic, TemplateSlic}, 367 {ACPI_SIG_SLIT, NULL, AcpiDmDumpSlit, DtCompileSlit, TemplateSlit}, 368 {ACPI_SIG_SPCR, AcpiDmTableInfoSpcr, NULL, NULL, TemplateSpcr}, 369 {ACPI_SIG_SPMI, AcpiDmTableInfoSpmi, NULL, NULL, TemplateSpmi}, 370 {ACPI_SIG_SRAT, NULL, AcpiDmDumpSrat, DtCompileSrat, TemplateSrat}, 371 {ACPI_SIG_STAO, NULL, AcpiDmDumpStao, DtCompileStao, TemplateStao}, 372 {ACPI_SIG_TCPA, NULL, AcpiDmDumpTcpa, DtCompileTcpa, TemplateTcpa}, 373 {ACPI_SIG_TPM2, AcpiDmTableInfoTpm2, NULL, NULL, TemplateTpm2}, 374 {ACPI_SIG_UEFI, AcpiDmTableInfoUefi, NULL, DtCompileUefi, TemplateUefi}, 375 {ACPI_SIG_VRTC, AcpiDmTableInfoVrtc, AcpiDmDumpVrtc, DtCompileVrtc, TemplateVrtc}, 376 {ACPI_SIG_WAET, AcpiDmTableInfoWaet, NULL, NULL, TemplateWaet}, 377 {ACPI_SIG_WDAT, NULL, AcpiDmDumpWdat, DtCompileWdat, TemplateWdat}, 378 {ACPI_SIG_WDDT, AcpiDmTableInfoWddt, NULL, NULL, TemplateWddt}, 379 {ACPI_SIG_WDRT, AcpiDmTableInfoWdrt, NULL, NULL, TemplateWdrt}, 380 {ACPI_SIG_WPBT, NULL, AcpiDmDumpWpbt, DtCompileWpbt, TemplateWpbt}, 381 {ACPI_SIG_XENV, AcpiDmTableInfoXenv, NULL, NULL, TemplateXenv}, 382 {ACPI_SIG_XSDT, NULL, AcpiDmDumpXsdt, DtCompileXsdt, TemplateXsdt}, 383 {NULL, NULL, NULL, NULL, NULL} 384 }; 385 386 387 /******************************************************************************* 388 * 389 * FUNCTION: AcpiDmGenerateChecksum 390 * 391 * PARAMETERS: Table - Pointer to table to be checksummed 392 * Length - Length of the table 393 * OriginalChecksum - Value of the checksum field 394 * 395 * RETURN: 8 bit checksum of buffer 396 * 397 * DESCRIPTION: Computes an 8 bit checksum of the table. 398 * 399 ******************************************************************************/ 400 401 UINT8 402 AcpiDmGenerateChecksum ( 403 void *Table, 404 UINT32 Length, 405 UINT8 OriginalChecksum) 406 { 407 UINT8 Checksum; 408 409 410 /* Sum the entire table as-is */ 411 412 Checksum = AcpiTbChecksum ((UINT8 *) Table, Length); 413 414 /* Subtract off the existing checksum value in the table */ 415 416 Checksum = (UINT8) (Checksum - OriginalChecksum); 417 418 /* Compute the final checksum */ 419 420 Checksum = (UINT8) (0 - Checksum); 421 return (Checksum); 422 } 423 424 425 /******************************************************************************* 426 * 427 * FUNCTION: AcpiDmGetTableData 428 * 429 * PARAMETERS: Signature - ACPI signature (4 chars) to match 430 * 431 * RETURN: Pointer to a valid ACPI_DMTABLE_DATA. Null if no match found. 432 * 433 * DESCRIPTION: Find a match in the global table of supported ACPI tables 434 * 435 ******************************************************************************/ 436 437 const ACPI_DMTABLE_DATA * 438 AcpiDmGetTableData ( 439 char *Signature) 440 { 441 const ACPI_DMTABLE_DATA *Info; 442 443 444 for (Info = AcpiDmTableData; Info->Signature; Info++) 445 { 446 if (ACPI_COMPARE_NAME (Signature, Info->Signature)) 447 { 448 return (Info); 449 } 450 } 451 452 return (NULL); 453 } 454 455 456 /******************************************************************************* 457 * 458 * FUNCTION: AcpiDmDumpDataTable 459 * 460 * PARAMETERS: Table - An ACPI table 461 * 462 * RETURN: None. 463 * 464 * DESCRIPTION: Format the contents of an ACPI data table (any table other 465 * than an SSDT or DSDT that does not contain executable AML code) 466 * 467 ******************************************************************************/ 468 469 void 470 AcpiDmDumpDataTable ( 471 ACPI_TABLE_HEADER *Table) 472 { 473 ACPI_STATUS Status; 474 const ACPI_DMTABLE_DATA *TableData; 475 UINT32 Length; 476 477 478 /* Ignore tables that contain AML */ 479 480 if (AcpiUtIsAmlTable (Table)) 481 { 482 if (Gbl_VerboseTemplates) 483 { 484 /* Dump the raw table data */ 485 486 Length = Table->Length; 487 488 AcpiOsPrintf ("\n/*\n%s: Length %d (0x%X)\n\n", 489 ACPI_RAW_TABLE_DATA_HEADER, Length, Length); 490 AcpiUtDumpBuffer (ACPI_CAST_PTR (UINT8, Table), 491 Length, DB_BYTE_DISPLAY, 0); 492 AcpiOsPrintf (" */\n"); 493 } 494 return; 495 } 496 497 /* 498 * Handle tables that don't use the common ACPI table header structure. 499 * Currently, these are the FACS, RSDP, and S3PT. 500 */ 501 if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FACS)) 502 { 503 Length = Table->Length; 504 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoFacs); 505 if (ACPI_FAILURE (Status)) 506 { 507 return; 508 } 509 } 510 else if (ACPI_VALIDATE_RSDP_SIG (Table->Signature)) 511 { 512 Length = AcpiDmDumpRsdp (Table); 513 } 514 else if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_S3PT)) 515 { 516 Length = AcpiDmDumpS3pt (Table); 517 } 518 else 519 { 520 /* 521 * All other tables must use the common ACPI table header, dump it now 522 */ 523 Length = Table->Length; 524 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHeader); 525 if (ACPI_FAILURE (Status)) 526 { 527 return; 528 } 529 AcpiOsPrintf ("\n"); 530 531 /* Match signature and dispatch appropriately */ 532 533 TableData = AcpiDmGetTableData (Table->Signature); 534 if (!TableData) 535 { 536 if (!strncmp (Table->Signature, "OEM", 3)) 537 { 538 AcpiOsPrintf ("\n**** OEM-defined ACPI table [%4.4s], unknown contents\n\n", 539 Table->Signature); 540 } 541 else 542 { 543 AcpiOsPrintf ("\n**** Unknown ACPI table signature [%4.4s]\n\n", 544 Table->Signature); 545 546 fprintf (stderr, "Unknown ACPI table signature [%4.4s], ", 547 Table->Signature); 548 549 if (!AcpiGbl_ForceAmlDisassembly) 550 { 551 fprintf (stderr, "decoding ACPI table header only\n"); 552 } 553 else 554 { 555 fprintf (stderr, "assuming table contains valid AML code\n"); 556 } 557 } 558 } 559 else if (TableData->TableHandler) 560 { 561 /* Complex table, has a handler */ 562 563 TableData->TableHandler (Table); 564 } 565 else if (TableData->TableInfo) 566 { 567 /* Simple table, just walk the info table */ 568 569 Status = AcpiDmDumpTable (Length, 0, Table, 0, TableData->TableInfo); 570 if (ACPI_FAILURE (Status)) 571 { 572 return; 573 } 574 } 575 } 576 577 if (!Gbl_DoTemplates || Gbl_VerboseTemplates) 578 { 579 /* Dump the raw table data */ 580 581 AcpiOsPrintf ("\n%s: Length %d (0x%X)\n\n", 582 ACPI_RAW_TABLE_DATA_HEADER, Length, Length); 583 AcpiUtDumpBuffer (ACPI_CAST_PTR (UINT8, Table), 584 Length, DB_BYTE_DISPLAY, 0); 585 } 586 } 587 588 589 /******************************************************************************* 590 * 591 * FUNCTION: AcpiDmLineHeader 592 * 593 * PARAMETERS: Offset - Current byte offset, from table start 594 * ByteLength - Length of the field in bytes, 0 for flags 595 * Name - Name of this field 596 * 597 * RETURN: None 598 * 599 * DESCRIPTION: Utility routines for formatting output lines. Displays the 600 * current table offset in hex and decimal, the field length, 601 * and the field name. 602 * 603 ******************************************************************************/ 604 605 void 606 AcpiDmLineHeader ( 607 UINT32 Offset, 608 UINT32 ByteLength, 609 char *Name) 610 { 611 612 /* Allow a null name for fields that span multiple lines (large buffers) */ 613 614 if (!Name) 615 { 616 Name = ""; 617 } 618 619 if (Gbl_DoTemplates && !Gbl_VerboseTemplates) /* Terse template */ 620 { 621 if (ByteLength) 622 { 623 AcpiOsPrintf ("[%.4d] %34s : ", ByteLength, Name); 624 } 625 else 626 { 627 if (*Name) 628 { 629 AcpiOsPrintf ("%41s : ", Name); 630 } 631 else 632 { 633 AcpiOsPrintf ("%41s ", Name); 634 } 635 } 636 } 637 else /* Normal disassembler or verbose template */ 638 { 639 if (ByteLength) 640 { 641 AcpiOsPrintf ("[%3.3Xh %4.4d% 4d] %28s : ", 642 Offset, Offset, ByteLength, Name); 643 } 644 else 645 { 646 if (*Name) 647 { 648 AcpiOsPrintf ("%44s : ", Name); 649 } 650 else 651 { 652 AcpiOsPrintf ("%44s ", Name); 653 } 654 } 655 } 656 } 657 658 void 659 AcpiDmLineHeader2 ( 660 UINT32 Offset, 661 UINT32 ByteLength, 662 char *Name, 663 UINT32 Value) 664 { 665 666 if (Gbl_DoTemplates && !Gbl_VerboseTemplates) /* Terse template */ 667 { 668 if (ByteLength) 669 { 670 AcpiOsPrintf ("[%.4d] %30s %3d : ", 671 ByteLength, Name, Value); 672 } 673 else 674 { 675 AcpiOsPrintf ("%36s % 3d : ", 676 Name, Value); 677 } 678 } 679 else /* Normal disassembler or verbose template */ 680 { 681 if (ByteLength) 682 { 683 AcpiOsPrintf ("[%3.3Xh %4.4d %3d] %24s %3d : ", 684 Offset, Offset, ByteLength, Name, Value); 685 } 686 else 687 { 688 AcpiOsPrintf ("[%3.3Xh %4.4d ] %24s %3d : ", 689 Offset, Offset, Name, Value); 690 } 691 } 692 } 693 694 695 /******************************************************************************* 696 * 697 * FUNCTION: AcpiDmDumpTable 698 * 699 * PARAMETERS: TableLength - Length of the entire ACPI table 700 * TableOffset - Starting offset within the table for this 701 * sub-descriptor (0 if main table) 702 * Table - The ACPI table 703 * SubtableLength - Length of this sub-descriptor 704 * Info - Info table for this ACPI table 705 * 706 * RETURN: Status 707 * 708 * DESCRIPTION: Display ACPI table contents by walking the Info table. 709 * 710 * Note: This function must remain in sync with DtGetFieldLength. 711 * 712 ******************************************************************************/ 713 714 ACPI_STATUS 715 AcpiDmDumpTable ( 716 UINT32 TableLength, 717 UINT32 TableOffset, 718 void *Table, 719 UINT32 SubtableLength, 720 ACPI_DMTABLE_INFO *Info) 721 { 722 UINT8 *Target; 723 UINT32 CurrentOffset; 724 UINT32 ByteLength; 725 UINT8 Temp8; 726 UINT16 Temp16; 727 UINT32 Temp32; 728 UINT64 Value; 729 const AH_TABLE *TableData; 730 const char *Name; 731 BOOLEAN LastOutputBlankLine = FALSE; 732 ACPI_STATUS Status; 733 char RepairedName[8]; 734 735 736 if (!Info) 737 { 738 AcpiOsPrintf ("Display not implemented\n"); 739 return (AE_NOT_IMPLEMENTED); 740 } 741 742 /* Walk entire Info table; Null name terminates */ 743 744 for (; Info->Name; Info++) 745 { 746 /* 747 * Target points to the field within the ACPI Table. CurrentOffset is 748 * the offset of the field from the start of the main table. 749 */ 750 Target = ACPI_ADD_PTR (UINT8, Table, Info->Offset); 751 CurrentOffset = TableOffset + Info->Offset; 752 753 /* Check for beyond subtable end or (worse) beyond EOT */ 754 755 if (SubtableLength && (Info->Offset >= SubtableLength)) 756 { 757 AcpiOsPrintf ( 758 "/**** ACPI subtable terminates early - " 759 "may be older version (dump table) */\n"); 760 761 /* Move on to next subtable */ 762 763 return (AE_OK); 764 } 765 766 if (CurrentOffset >= TableLength) 767 { 768 AcpiOsPrintf ( 769 "/**** ACPI table terminates " 770 "in the middle of a data structure! (dump table) */\n"); 771 return (AE_BAD_DATA); 772 } 773 774 /* Generate the byte length for this field */ 775 776 switch (Info->Opcode) 777 { 778 case ACPI_DMT_UINT8: 779 case ACPI_DMT_CHKSUM: 780 case ACPI_DMT_SPACEID: 781 case ACPI_DMT_ACCWIDTH: 782 case ACPI_DMT_IVRS: 783 case ACPI_DMT_GTDT: 784 case ACPI_DMT_MADT: 785 case ACPI_DMT_PCCT: 786 case ACPI_DMT_PMTT: 787 case ACPI_DMT_SRAT: 788 case ACPI_DMT_ASF: 789 case ACPI_DMT_HESTNTYP: 790 case ACPI_DMT_FADTPM: 791 case ACPI_DMT_EINJACT: 792 case ACPI_DMT_EINJINST: 793 case ACPI_DMT_ERSTACT: 794 case ACPI_DMT_ERSTINST: 795 case ACPI_DMT_DMAR_SCOPE: 796 797 ByteLength = 1; 798 break; 799 800 case ACPI_DMT_UINT16: 801 case ACPI_DMT_DMAR: 802 case ACPI_DMT_HEST: 803 case ACPI_DMT_NFIT: 804 805 ByteLength = 2; 806 break; 807 808 case ACPI_DMT_UINT24: 809 810 ByteLength = 3; 811 break; 812 813 case ACPI_DMT_UINT32: 814 case ACPI_DMT_NAME4: 815 case ACPI_DMT_SIG: 816 case ACPI_DMT_LPIT: 817 818 ByteLength = 4; 819 break; 820 821 case ACPI_DMT_UINT40: 822 823 ByteLength = 5; 824 break; 825 826 case ACPI_DMT_UINT48: 827 case ACPI_DMT_NAME6: 828 829 ByteLength = 6; 830 break; 831 832 case ACPI_DMT_UINT56: 833 case ACPI_DMT_BUF7: 834 835 ByteLength = 7; 836 break; 837 838 case ACPI_DMT_UINT64: 839 case ACPI_DMT_NAME8: 840 841 ByteLength = 8; 842 break; 843 844 case ACPI_DMT_BUF10: 845 846 ByteLength = 10; 847 break; 848 849 case ACPI_DMT_BUF16: 850 case ACPI_DMT_UUID: 851 852 ByteLength = 16; 853 break; 854 855 case ACPI_DMT_BUF128: 856 857 ByteLength = 128; 858 break; 859 860 case ACPI_DMT_UNICODE: 861 case ACPI_DMT_BUFFER: 862 case ACPI_DMT_RAW_BUFFER: 863 864 ByteLength = SubtableLength; 865 break; 866 867 case ACPI_DMT_STRING: 868 869 ByteLength = strlen (ACPI_CAST_PTR (char, Target)) + 1; 870 break; 871 872 case ACPI_DMT_GAS: 873 874 if (!LastOutputBlankLine) 875 { 876 AcpiOsPrintf ("\n"); 877 LastOutputBlankLine = TRUE; 878 } 879 880 ByteLength = sizeof (ACPI_GENERIC_ADDRESS); 881 break; 882 883 case ACPI_DMT_HESTNTFY: 884 885 if (!LastOutputBlankLine) 886 { 887 AcpiOsPrintf ("\n"); 888 LastOutputBlankLine = TRUE; 889 } 890 891 ByteLength = sizeof (ACPI_HEST_NOTIFY); 892 break; 893 894 case ACPI_DMT_IORTMEM: 895 896 if (!LastOutputBlankLine) 897 { 898 LastOutputBlankLine = FALSE; 899 } 900 901 ByteLength = sizeof (ACPI_IORT_MEMORY_ACCESS); 902 break; 903 904 default: 905 906 ByteLength = 0; 907 break; 908 } 909 910 /* Check if we are beyond a subtable, or (worse) beyond EOT */ 911 912 if (CurrentOffset + ByteLength > TableLength) 913 { 914 if (SubtableLength) 915 { 916 AcpiOsPrintf ( 917 "/**** ACPI subtable terminates early - " 918 "may be older version (dump table) */\n"); 919 920 /* Move on to next subtable */ 921 922 return (AE_OK); 923 } 924 925 AcpiOsPrintf ( 926 "/**** ACPI table terminates " 927 "in the middle of a data structure! */\n"); 928 return (AE_BAD_DATA); 929 } 930 931 if (Info->Opcode == ACPI_DMT_EXTRA_TEXT) 932 { 933 AcpiOsPrintf ("%s", Info->Name); 934 continue; 935 } 936 937 /* Start a new line and decode the opcode */ 938 939 AcpiDmLineHeader (CurrentOffset, ByteLength, Info->Name); 940 941 switch (Info->Opcode) 942 { 943 /* Single-bit Flag fields. Note: Opcode is the bit position */ 944 945 case ACPI_DMT_FLAG0: 946 case ACPI_DMT_FLAG1: 947 case ACPI_DMT_FLAG2: 948 case ACPI_DMT_FLAG3: 949 case ACPI_DMT_FLAG4: 950 case ACPI_DMT_FLAG5: 951 case ACPI_DMT_FLAG6: 952 case ACPI_DMT_FLAG7: 953 954 AcpiOsPrintf ("%1.1X\n", (*Target >> Info->Opcode) & 0x01); 955 break; 956 957 /* 2-bit Flag fields */ 958 959 case ACPI_DMT_FLAGS0: 960 961 AcpiOsPrintf ("%1.1X\n", *Target & 0x03); 962 break; 963 964 case ACPI_DMT_FLAGS1: 965 966 AcpiOsPrintf ("%1.1X\n", (*Target >> 1) & 0x03); 967 break; 968 969 case ACPI_DMT_FLAGS2: 970 971 AcpiOsPrintf ("%1.1X\n", (*Target >> 2) & 0x03); 972 break; 973 974 case ACPI_DMT_FLAGS4: 975 976 AcpiOsPrintf ("%1.1X\n", (*Target >> 4) & 0x03); 977 break; 978 979 /* Integer Data Types */ 980 981 case ACPI_DMT_UINT8: 982 case ACPI_DMT_UINT16: 983 case ACPI_DMT_UINT24: 984 case ACPI_DMT_UINT32: 985 case ACPI_DMT_UINT40: 986 case ACPI_DMT_UINT48: 987 case ACPI_DMT_UINT56: 988 case ACPI_DMT_UINT64: 989 /* 990 * Dump bytes - high byte first, low byte last. 991 * Note: All ACPI tables are little-endian. 992 */ 993 Value = 0; 994 for (Temp8 = (UINT8) ByteLength; Temp8 > 0; Temp8--) 995 { 996 AcpiOsPrintf ("%2.2X", Target[Temp8 - 1]); 997 Value |= Target[Temp8 - 1]; 998 Value <<= 8; 999 } 1000 1001 if (!Value && (Info->Flags & DT_DESCRIBES_OPTIONAL)) 1002 { 1003 AcpiOsPrintf (" [Optional field not present]"); 1004 } 1005 1006 AcpiOsPrintf ("\n"); 1007 break; 1008 1009 case ACPI_DMT_BUF7: 1010 case ACPI_DMT_BUF10: 1011 case ACPI_DMT_BUF16: 1012 case ACPI_DMT_BUF128: 1013 /* 1014 * Buffer: Size depends on the opcode and was set above. 1015 * Each hex byte is separated with a space. 1016 * Multiple lines are separated by line continuation char. 1017 */ 1018 for (Temp16 = 0; Temp16 < ByteLength; Temp16++) 1019 { 1020 AcpiOsPrintf ("%2.2X", Target[Temp16]); 1021 if ((UINT32) (Temp16 + 1) < ByteLength) 1022 { 1023 if ((Temp16 > 0) && (!((Temp16+1) % 16))) 1024 { 1025 AcpiOsPrintf (" \\\n"); /* Line continuation */ 1026 AcpiDmLineHeader (0, 0, NULL); 1027 } 1028 else 1029 { 1030 AcpiOsPrintf (" "); 1031 } 1032 } 1033 } 1034 1035 AcpiOsPrintf ("\n"); 1036 break; 1037 1038 case ACPI_DMT_UUID: 1039 1040 /* Convert 16-byte UUID buffer to 36-byte formatted UUID string */ 1041 1042 (void) AuConvertUuidToString ((char *) Target, MsgBuffer); 1043 1044 AcpiOsPrintf ("%s\n", MsgBuffer); 1045 break; 1046 1047 case ACPI_DMT_STRING: 1048 1049 AcpiOsPrintf ("\"%s\"\n", ACPI_CAST_PTR (char, Target)); 1050 break; 1051 1052 /* Fixed length ASCII name fields */ 1053 1054 case ACPI_DMT_SIG: 1055 1056 AcpiDmCheckAscii (Target, RepairedName, 4); 1057 AcpiOsPrintf ("\"%.4s\" ", RepairedName); 1058 1059 TableData = AcpiAhGetTableInfo (ACPI_CAST_PTR (char, Target)); 1060 if (TableData) 1061 { 1062 AcpiOsPrintf (STRING_FORMAT, TableData->Description); 1063 } 1064 else 1065 { 1066 AcpiOsPrintf ("\n"); 1067 } 1068 break; 1069 1070 case ACPI_DMT_NAME4: 1071 1072 AcpiDmCheckAscii (Target, RepairedName, 4); 1073 AcpiOsPrintf ("\"%.4s\"\n", RepairedName); 1074 break; 1075 1076 case ACPI_DMT_NAME6: 1077 1078 AcpiDmCheckAscii (Target, RepairedName, 6); 1079 AcpiOsPrintf ("\"%.6s\"\n", RepairedName); 1080 break; 1081 1082 case ACPI_DMT_NAME8: 1083 1084 AcpiDmCheckAscii (Target, RepairedName, 8); 1085 AcpiOsPrintf ("\"%.8s\"\n", RepairedName); 1086 break; 1087 1088 /* Special Data Types */ 1089 1090 case ACPI_DMT_CHKSUM: 1091 1092 /* Checksum, display and validate */ 1093 1094 AcpiOsPrintf ("%2.2X", *Target); 1095 Temp8 = AcpiDmGenerateChecksum (Table, 1096 ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Length, 1097 ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum); 1098 1099 if (Temp8 != ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum) 1100 { 1101 AcpiOsPrintf ( 1102 " /* Incorrect checksum, should be %2.2X */", Temp8); 1103 } 1104 1105 AcpiOsPrintf ("\n"); 1106 break; 1107 1108 case ACPI_DMT_SPACEID: 1109 1110 /* Address Space ID */ 1111 1112 AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiUtGetRegionName (*Target)); 1113 break; 1114 1115 case ACPI_DMT_ACCWIDTH: 1116 1117 /* Encoded Access Width */ 1118 1119 Temp8 = *Target; 1120 if (Temp8 > ACPI_GAS_WIDTH_RESERVED) 1121 { 1122 Temp8 = ACPI_GAS_WIDTH_RESERVED; 1123 } 1124 1125 AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmGasAccessWidth[Temp8]); 1126 break; 1127 1128 case ACPI_DMT_GAS: 1129 1130 /* Generic Address Structure */ 1131 1132 AcpiOsPrintf (STRING_FORMAT, "Generic Address Structure"); 1133 Status = AcpiDmDumpTable (TableLength, CurrentOffset, Target, 1134 sizeof (ACPI_GENERIC_ADDRESS), AcpiDmTableInfoGas); 1135 if (ACPI_FAILURE (Status)) 1136 { 1137 return (Status); 1138 } 1139 1140 AcpiOsPrintf ("\n"); 1141 LastOutputBlankLine = TRUE; 1142 break; 1143 1144 case ACPI_DMT_ASF: 1145 1146 /* ASF subtable types */ 1147 1148 Temp16 = (UINT16) ((*Target) & 0x7F); /* Top bit can be zero or one */ 1149 if (Temp16 > ACPI_ASF_TYPE_RESERVED) 1150 { 1151 Temp16 = ACPI_ASF_TYPE_RESERVED; 1152 } 1153 1154 AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmAsfSubnames[Temp16]); 1155 break; 1156 1157 case ACPI_DMT_DMAR: 1158 1159 /* DMAR subtable types */ 1160 1161 Temp16 = ACPI_GET16 (Target); 1162 if (Temp16 > ACPI_DMAR_TYPE_RESERVED) 1163 { 1164 Temp16 = ACPI_DMAR_TYPE_RESERVED; 1165 } 1166 1167 AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target), 1168 AcpiDmDmarSubnames[Temp16]); 1169 break; 1170 1171 case ACPI_DMT_DMAR_SCOPE: 1172 1173 /* DMAR device scope types */ 1174 1175 Temp8 = *Target; 1176 if (Temp8 > ACPI_DMAR_SCOPE_TYPE_RESERVED) 1177 { 1178 Temp8 = ACPI_DMAR_SCOPE_TYPE_RESERVED; 1179 } 1180 1181 AcpiOsPrintf (UINT8_FORMAT, *Target, 1182 AcpiDmDmarScope[Temp8]); 1183 break; 1184 1185 case ACPI_DMT_EINJACT: 1186 1187 /* EINJ Action types */ 1188 1189 Temp8 = *Target; 1190 if (Temp8 > ACPI_EINJ_ACTION_RESERVED) 1191 { 1192 Temp8 = ACPI_EINJ_ACTION_RESERVED; 1193 } 1194 1195 AcpiOsPrintf (UINT8_FORMAT, *Target, 1196 AcpiDmEinjActions[Temp8]); 1197 break; 1198 1199 case ACPI_DMT_EINJINST: 1200 1201 /* EINJ Instruction types */ 1202 1203 Temp8 = *Target; 1204 if (Temp8 > ACPI_EINJ_INSTRUCTION_RESERVED) 1205 { 1206 Temp8 = ACPI_EINJ_INSTRUCTION_RESERVED; 1207 } 1208 1209 AcpiOsPrintf (UINT8_FORMAT, *Target, 1210 AcpiDmEinjInstructions[Temp8]); 1211 break; 1212 1213 case ACPI_DMT_ERSTACT: 1214 1215 /* ERST Action types */ 1216 1217 Temp8 = *Target; 1218 if (Temp8 > ACPI_ERST_ACTION_RESERVED) 1219 { 1220 Temp8 = ACPI_ERST_ACTION_RESERVED; 1221 } 1222 1223 AcpiOsPrintf (UINT8_FORMAT, *Target, 1224 AcpiDmErstActions[Temp8]); 1225 break; 1226 1227 case ACPI_DMT_ERSTINST: 1228 1229 /* ERST Instruction types */ 1230 1231 Temp8 = *Target; 1232 if (Temp8 > ACPI_ERST_INSTRUCTION_RESERVED) 1233 { 1234 Temp8 = ACPI_ERST_INSTRUCTION_RESERVED; 1235 } 1236 1237 AcpiOsPrintf (UINT8_FORMAT, *Target, 1238 AcpiDmErstInstructions[Temp8]); 1239 break; 1240 1241 case ACPI_DMT_GTDT: 1242 1243 /* GTDT subtable types */ 1244 1245 Temp8 = *Target; 1246 if (Temp8 > ACPI_GTDT_TYPE_RESERVED) 1247 { 1248 Temp8 = ACPI_GTDT_TYPE_RESERVED; 1249 } 1250 1251 AcpiOsPrintf (UINT8_FORMAT, *Target, 1252 AcpiDmGtdtSubnames[Temp8]); 1253 break; 1254 1255 case ACPI_DMT_HEST: 1256 1257 /* HEST subtable types */ 1258 1259 Temp16 = ACPI_GET16 (Target); 1260 if (Temp16 > ACPI_HEST_TYPE_RESERVED) 1261 { 1262 Temp16 = ACPI_HEST_TYPE_RESERVED; 1263 } 1264 1265 AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target), 1266 AcpiDmHestSubnames[Temp16]); 1267 break; 1268 1269 case ACPI_DMT_HESTNTFY: 1270 1271 AcpiOsPrintf (STRING_FORMAT, 1272 "Hardware Error Notification Structure"); 1273 1274 Status = AcpiDmDumpTable (TableLength, CurrentOffset, Target, 1275 sizeof (ACPI_HEST_NOTIFY), AcpiDmTableInfoHestNotify); 1276 if (ACPI_FAILURE (Status)) 1277 { 1278 return (Status); 1279 } 1280 1281 AcpiOsPrintf ("\n"); 1282 LastOutputBlankLine = TRUE; 1283 break; 1284 1285 case ACPI_DMT_HESTNTYP: 1286 1287 /* HEST Notify types */ 1288 1289 Temp8 = *Target; 1290 if (Temp8 > ACPI_HEST_NOTIFY_RESERVED) 1291 { 1292 Temp8 = ACPI_HEST_NOTIFY_RESERVED; 1293 } 1294 1295 AcpiOsPrintf (UINT8_FORMAT, *Target, 1296 AcpiDmHestNotifySubnames[Temp8]); 1297 break; 1298 1299 case ACPI_DMT_IORTMEM: 1300 1301 AcpiOsPrintf (STRING_FORMAT, 1302 "IORT Memory Access Properties"); 1303 1304 Status = AcpiDmDumpTable (TableLength, CurrentOffset, Target, 1305 sizeof (ACPI_IORT_MEMORY_ACCESS), AcpiDmTableInfoIortAcc); 1306 if (ACPI_FAILURE (Status)) 1307 { 1308 return (Status); 1309 } 1310 1311 LastOutputBlankLine = TRUE; 1312 break; 1313 1314 case ACPI_DMT_MADT: 1315 1316 /* MADT subtable types */ 1317 1318 Temp8 = *Target; 1319 if (Temp8 > ACPI_MADT_TYPE_RESERVED) 1320 { 1321 Temp8 = ACPI_MADT_TYPE_RESERVED; 1322 } 1323 1324 AcpiOsPrintf (UINT8_FORMAT, *Target, 1325 AcpiDmMadtSubnames[Temp8]); 1326 break; 1327 1328 case ACPI_DMT_NFIT: 1329 1330 /* NFIT subtable types */ 1331 1332 Temp16 = ACPI_GET16 (Target); 1333 if (Temp16 > ACPI_NFIT_TYPE_RESERVED) 1334 { 1335 Temp16 = ACPI_NFIT_TYPE_RESERVED; 1336 } 1337 1338 AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target), 1339 AcpiDmNfitSubnames[Temp16]); 1340 break; 1341 1342 case ACPI_DMT_PCCT: 1343 1344 /* PCCT subtable types */ 1345 1346 Temp8 = *Target; 1347 if (Temp8 > ACPI_PCCT_TYPE_RESERVED) 1348 { 1349 Temp8 = ACPI_PCCT_TYPE_RESERVED; 1350 } 1351 1352 AcpiOsPrintf (UINT8_FORMAT, *Target, 1353 AcpiDmPcctSubnames[Temp8]); 1354 break; 1355 1356 case ACPI_DMT_PMTT: 1357 1358 /* PMTT subtable types */ 1359 1360 Temp8 = *Target; 1361 if (Temp8 > ACPI_PMTT_TYPE_RESERVED) 1362 { 1363 Temp8 = ACPI_PMTT_TYPE_RESERVED; 1364 } 1365 1366 AcpiOsPrintf (UINT8_FORMAT, *Target, 1367 AcpiDmPmttSubnames[Temp8]); 1368 break; 1369 1370 case ACPI_DMT_UNICODE: 1371 1372 if (ByteLength == 0) 1373 { 1374 AcpiOsPrintf ("/* Zero-length Data */\n"); 1375 break; 1376 } 1377 1378 AcpiDmDumpUnicode (Table, CurrentOffset, ByteLength); 1379 break; 1380 1381 case ACPI_DMT_RAW_BUFFER: 1382 1383 if (ByteLength == 0) 1384 { 1385 AcpiOsPrintf ("/* Zero-length Data */\n"); 1386 break; 1387 } 1388 1389 AcpiDmDumpBuffer (Table, CurrentOffset, ByteLength, 1390 CurrentOffset, NULL); 1391 break; 1392 1393 case ACPI_DMT_SRAT: 1394 1395 /* SRAT subtable types */ 1396 1397 Temp8 = *Target; 1398 if (Temp8 > ACPI_SRAT_TYPE_RESERVED) 1399 { 1400 Temp8 = ACPI_SRAT_TYPE_RESERVED; 1401 } 1402 1403 AcpiOsPrintf (UINT8_FORMAT, *Target, 1404 AcpiDmSratSubnames[Temp8]); 1405 break; 1406 1407 case ACPI_DMT_FADTPM: 1408 1409 /* FADT Preferred PM Profile names */ 1410 1411 Temp8 = *Target; 1412 if (Temp8 > ACPI_FADT_PM_RESERVED) 1413 { 1414 Temp8 = ACPI_FADT_PM_RESERVED; 1415 } 1416 1417 AcpiOsPrintf (UINT8_FORMAT, *Target, 1418 AcpiDmFadtProfiles[Temp8]); 1419 break; 1420 1421 case ACPI_DMT_IVRS: 1422 1423 /* IVRS subtable types */ 1424 1425 Temp8 = *Target; 1426 switch (Temp8) 1427 { 1428 case ACPI_IVRS_TYPE_HARDWARE: 1429 1430 Name = AcpiDmIvrsSubnames[0]; 1431 break; 1432 1433 case ACPI_IVRS_TYPE_MEMORY1: 1434 case ACPI_IVRS_TYPE_MEMORY2: 1435 case ACPI_IVRS_TYPE_MEMORY3: 1436 1437 Name = AcpiDmIvrsSubnames[1]; 1438 break; 1439 1440 default: 1441 1442 Name = AcpiDmIvrsSubnames[2]; 1443 break; 1444 } 1445 1446 AcpiOsPrintf (UINT8_FORMAT, *Target, Name); 1447 break; 1448 1449 case ACPI_DMT_LPIT: 1450 1451 /* LPIT subtable types */ 1452 1453 Temp32 = ACPI_GET32 (Target); 1454 if (Temp32 > ACPI_LPIT_TYPE_RESERVED) 1455 { 1456 Temp32 = ACPI_LPIT_TYPE_RESERVED; 1457 } 1458 1459 AcpiOsPrintf (UINT32_FORMAT, ACPI_GET32 (Target), 1460 AcpiDmLpitSubnames[Temp32]); 1461 break; 1462 1463 case ACPI_DMT_EXIT: 1464 1465 return (AE_OK); 1466 1467 default: 1468 1469 ACPI_ERROR ((AE_INFO, 1470 "**** Invalid table opcode [0x%X] ****\n", Info->Opcode)); 1471 return (AE_SUPPORT); 1472 } 1473 } 1474 1475 if (TableOffset && !SubtableLength) 1476 { 1477 /* 1478 * If this table is not the main table, the subtable must have a 1479 * valid length 1480 */ 1481 AcpiOsPrintf ("Invalid zero length subtable\n"); 1482 return (AE_BAD_DATA); 1483 } 1484 1485 return (AE_OK); 1486 } 1487 1488 1489 /******************************************************************************* 1490 * 1491 * FUNCTION: AcpiDmCheckAscii 1492 * 1493 * PARAMETERS: Name - Ascii string 1494 * Count - Number of characters to check 1495 * 1496 * RETURN: None 1497 * 1498 * DESCRIPTION: Ensure that the requested number of characters are printable 1499 * Ascii characters. Sets non-printable and null chars to <space>. 1500 * 1501 ******************************************************************************/ 1502 1503 static void 1504 AcpiDmCheckAscii ( 1505 UINT8 *Name, 1506 char *RepairedName, 1507 UINT32 Count) 1508 { 1509 UINT32 i; 1510 1511 1512 for (i = 0; i < Count; i++) 1513 { 1514 RepairedName[i] = (char) Name[i]; 1515 1516 if (!Name[i]) 1517 { 1518 return; 1519 } 1520 if (!isprint (Name[i])) 1521 { 1522 RepairedName[i] = ' '; 1523 } 1524 } 1525 } 1526