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