1 /****************************************************************************** 2 * 3 * Module Name: dmtbdump - Dump ACPI data 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 - 2009, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 *****************************************************************************/ 115 116 #include <contrib/dev/acpica/include/acpi.h> 117 #include <contrib/dev/acpica/include/accommon.h> 118 #include <contrib/dev/acpica/include/acdisasm.h> 119 #include <contrib/dev/acpica/include/actables.h> 120 121 /* This module used for application-level code only */ 122 123 #define _COMPONENT ACPI_CA_DISASSEMBLER 124 ACPI_MODULE_NAME ("dmtbdump") 125 126 127 /******************************************************************************* 128 * 129 * FUNCTION: AcpiDmDumpRsdp 130 * 131 * PARAMETERS: Table - A RSDP 132 * 133 * RETURN: Length of the table (there is no length field, use revision) 134 * 135 * DESCRIPTION: Format the contents of a RSDP 136 * 137 ******************************************************************************/ 138 139 UINT32 140 AcpiDmDumpRsdp ( 141 ACPI_TABLE_HEADER *Table) 142 { 143 UINT32 Length = ACPI_RSDP_REV0_SIZE; 144 145 146 /* Dump the common ACPI 1.0 portion */ 147 148 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1); 149 150 /* ACPI 2.0+ contains more data and has a Length field */ 151 152 if (ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table)->Revision > 0) 153 { 154 Length = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table)->Length; 155 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2); 156 } 157 158 return (Length); 159 } 160 161 162 /******************************************************************************* 163 * 164 * FUNCTION: AcpiDmDumpRsdt 165 * 166 * PARAMETERS: Table - A RSDT 167 * 168 * RETURN: None 169 * 170 * DESCRIPTION: Format the contents of a RSDT 171 * 172 ******************************************************************************/ 173 174 void 175 AcpiDmDumpRsdt ( 176 ACPI_TABLE_HEADER *Table) 177 { 178 UINT32 *Array; 179 UINT32 Entries; 180 UINT32 Offset; 181 UINT32 i; 182 183 184 /* Point to start of table pointer array */ 185 186 Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry; 187 Offset = sizeof (ACPI_TABLE_HEADER); 188 189 /* RSDT uses 32-bit pointers */ 190 191 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32); 192 193 for (i = 0; i < Entries; i++) 194 { 195 AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i); 196 AcpiOsPrintf ("%8.8X\n", Array[i]); 197 Offset += sizeof (UINT32); 198 } 199 } 200 201 202 /******************************************************************************* 203 * 204 * FUNCTION: AcpiDmDumpXsdt 205 * 206 * PARAMETERS: Table - A XSDT 207 * 208 * RETURN: None 209 * 210 * DESCRIPTION: Format the contents of a XSDT 211 * 212 ******************************************************************************/ 213 214 void 215 AcpiDmDumpXsdt ( 216 ACPI_TABLE_HEADER *Table) 217 { 218 UINT64 *Array; 219 UINT32 Entries; 220 UINT32 Offset; 221 UINT32 i; 222 223 224 /* Point to start of table pointer array */ 225 226 Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry; 227 Offset = sizeof (ACPI_TABLE_HEADER); 228 229 /* XSDT uses 64-bit pointers */ 230 231 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64); 232 233 for (i = 0; i < Entries; i++) 234 { 235 AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i); 236 AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i])); 237 Offset += sizeof (UINT64); 238 } 239 } 240 241 242 /******************************************************************************* 243 * 244 * FUNCTION: AcpiDmDumpFadt 245 * 246 * PARAMETERS: Table - A FADT 247 * 248 * RETURN: None 249 * 250 * DESCRIPTION: Format the contents of a FADT 251 * 252 ******************************************************************************/ 253 254 void 255 AcpiDmDumpFadt ( 256 ACPI_TABLE_HEADER *Table) 257 { 258 259 /* Common ACPI 1.0 portion of FADT */ 260 261 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1); 262 263 /* Check for ACPI 1.0B MS extensions (FADT revision 2) */ 264 265 if (Table->Revision == 2) 266 { 267 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2); 268 } 269 270 /* Check for ACPI 2.0+ extended data (FADT revision 3+) */ 271 272 else if (Table->Length >= sizeof (ACPI_TABLE_FADT)) 273 { 274 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3); 275 } 276 277 /* Validate various fields in the FADT, including length */ 278 279 AcpiTbCreateLocalFadt (Table, Table->Length); 280 } 281 282 283 /******************************************************************************* 284 * 285 * FUNCTION: AcpiDmDumpAsf 286 * 287 * PARAMETERS: Table - A ASF table 288 * 289 * RETURN: None 290 * 291 * DESCRIPTION: Format the contents of a ASF table 292 * 293 ******************************************************************************/ 294 295 void 296 AcpiDmDumpAsf ( 297 ACPI_TABLE_HEADER *Table) 298 { 299 ACPI_STATUS Status; 300 UINT32 Offset = sizeof (ACPI_TABLE_HEADER); 301 ACPI_ASF_INFO *SubTable; 302 ACPI_DMTABLE_INFO *InfoTable; 303 ACPI_DMTABLE_INFO *DataInfoTable = NULL; 304 UINT8 *DataTable = NULL; 305 UINT32 DataCount = 0; 306 UINT32 DataLength = 0; 307 UINT32 DataOffset = 0; 308 UINT32 i; 309 310 311 /* No main table, only sub-tables */ 312 313 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); 314 while (Offset < Table->Length) 315 { 316 /* Common sub-table header */ 317 318 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 319 SubTable->Header.Length, AcpiDmTableInfoAsfHdr); 320 if (ACPI_FAILURE (Status)) 321 { 322 return; 323 } 324 325 switch (SubTable->Header.Type & 0x7F) /* Mask off top bit */ 326 { 327 case ACPI_ASF_TYPE_INFO: 328 InfoTable = AcpiDmTableInfoAsf0; 329 break; 330 331 case ACPI_ASF_TYPE_ALERT: 332 InfoTable = AcpiDmTableInfoAsf1; 333 DataInfoTable = AcpiDmTableInfoAsf1a; 334 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT)); 335 DataCount = ((ACPI_ASF_ALERT *) SubTable)->Alerts; 336 DataLength = ((ACPI_ASF_ALERT *) SubTable)->DataLength; 337 DataOffset = Offset + sizeof (ACPI_ASF_ALERT); 338 break; 339 340 case ACPI_ASF_TYPE_CONTROL: 341 InfoTable = AcpiDmTableInfoAsf2; 342 DataInfoTable = AcpiDmTableInfoAsf2a; 343 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE)); 344 DataCount = ((ACPI_ASF_REMOTE *) SubTable)->Controls; 345 DataLength = ((ACPI_ASF_REMOTE *) SubTable)->DataLength; 346 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE); 347 break; 348 349 case ACPI_ASF_TYPE_BOOT: 350 InfoTable = AcpiDmTableInfoAsf3; 351 break; 352 353 case ACPI_ASF_TYPE_ADDRESS: 354 InfoTable = AcpiDmTableInfoAsf4; 355 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS)); 356 DataLength = ((ACPI_ASF_ADDRESS *) SubTable)->Devices; 357 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS); 358 break; 359 360 default: 361 AcpiOsPrintf ("\n**** Unknown ASF sub-table type %X\n", SubTable->Header.Type); 362 return; 363 } 364 365 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 366 SubTable->Header.Length, InfoTable); 367 if (ACPI_FAILURE (Status)) 368 { 369 return; 370 } 371 372 /* Dump variable-length extra data */ 373 374 switch (SubTable->Header.Type & 0x7F) /* Mask off top bit */ 375 { 376 case ACPI_ASF_TYPE_ALERT: 377 case ACPI_ASF_TYPE_CONTROL: 378 379 for (i = 0; i < DataCount; i++) 380 { 381 AcpiOsPrintf ("\n"); 382 Status = AcpiDmDumpTable (Table->Length, DataOffset, 383 DataTable, DataLength, DataInfoTable); 384 if (ACPI_FAILURE (Status)) 385 { 386 return; 387 } 388 389 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength); 390 DataOffset += DataLength; 391 } 392 break; 393 394 case ACPI_ASF_TYPE_ADDRESS: 395 396 for (i = 0; i < DataLength; i++) 397 { 398 if (!(i % 16)) 399 { 400 AcpiDmLineHeader (DataOffset, 1, "Addresses"); 401 } 402 403 AcpiOsPrintf ("%2.2X ", *DataTable); 404 DataTable++; 405 DataOffset++; 406 if (DataOffset > Table->Length) 407 { 408 AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n"); 409 return; 410 } 411 } 412 413 AcpiOsPrintf ("\n"); 414 break; 415 416 default: 417 break; 418 } 419 420 AcpiOsPrintf ("\n"); 421 422 /* Point to next sub-table */ 423 424 if (!SubTable->Header.Length) 425 { 426 AcpiOsPrintf ("Invalid zero subtable header length\n"); 427 return; 428 } 429 430 Offset += SubTable->Header.Length; 431 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length); 432 } 433 } 434 435 436 /******************************************************************************* 437 * 438 * FUNCTION: AcpiDmDumpCpep 439 * 440 * PARAMETERS: Table - A CPEP table 441 * 442 * RETURN: None 443 * 444 * DESCRIPTION: Format the contents of a CPEP. This table type consists 445 * of an open-ended number of subtables. 446 * 447 ******************************************************************************/ 448 449 void 450 AcpiDmDumpCpep ( 451 ACPI_TABLE_HEADER *Table) 452 { 453 ACPI_STATUS Status; 454 ACPI_CPEP_POLLING *SubTable; 455 UINT32 Length = Table->Length; 456 UINT32 Offset = sizeof (ACPI_TABLE_CPEP); 457 458 459 /* Main table */ 460 461 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep); 462 if (ACPI_FAILURE (Status)) 463 { 464 return; 465 } 466 467 /* Sub-tables */ 468 469 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset); 470 while (Offset < Table->Length) 471 { 472 AcpiOsPrintf ("\n"); 473 Status = AcpiDmDumpTable (Length, Offset, SubTable, 474 SubTable->Length, AcpiDmTableInfoCpep0); 475 if (ACPI_FAILURE (Status)) 476 { 477 return; 478 } 479 480 /* Point to next sub-table */ 481 482 Offset += SubTable->Length; 483 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable, SubTable->Length); 484 } 485 } 486 487 488 /******************************************************************************* 489 * 490 * FUNCTION: AcpiDmDumpDmar 491 * 492 * PARAMETERS: Table - A DMAR table 493 * 494 * RETURN: None 495 * 496 * DESCRIPTION: Format the contents of a DMAR. This table type consists 497 * of an open-ended number of subtables. 498 * 499 ******************************************************************************/ 500 501 void 502 AcpiDmDumpDmar ( 503 ACPI_TABLE_HEADER *Table) 504 { 505 ACPI_STATUS Status; 506 ACPI_DMAR_HEADER *SubTable; 507 UINT32 Length = Table->Length; 508 UINT32 Offset = sizeof (ACPI_TABLE_DMAR); 509 ACPI_DMTABLE_INFO *InfoTable; 510 ACPI_DMAR_DEVICE_SCOPE *ScopeTable; 511 UINT32 ScopeOffset; 512 UINT8 *PciPath; 513 UINT32 PathOffset; 514 515 516 /* Main table */ 517 518 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); 519 if (ACPI_FAILURE (Status)) 520 { 521 return; 522 } 523 524 /* Sub-tables */ 525 526 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); 527 while (Offset < Table->Length) 528 { 529 /* Common sub-table header */ 530 531 AcpiOsPrintf ("\n"); 532 Status = AcpiDmDumpTable (Length, Offset, SubTable, 533 SubTable->Length, AcpiDmTableInfoDmarHdr); 534 if (ACPI_FAILURE (Status)) 535 { 536 return; 537 } 538 539 switch (SubTable->Type) 540 { 541 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 542 InfoTable = AcpiDmTableInfoDmar0; 543 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT); 544 break; 545 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 546 InfoTable = AcpiDmTableInfoDmar1; 547 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY); 548 break; 549 case ACPI_DMAR_TYPE_ATSR: 550 InfoTable = AcpiDmTableInfoDmar2; 551 ScopeOffset = sizeof (ACPI_DMAR_ATSR); 552 break; 553 default: 554 AcpiOsPrintf ("\n**** Unknown DMAR sub-table type %X\n\n", SubTable->Type); 555 return; 556 } 557 558 Status = AcpiDmDumpTable (Length, Offset, SubTable, 559 SubTable->Length, InfoTable); 560 if (ACPI_FAILURE (Status)) 561 { 562 return; 563 } 564 565 /* Dump the device scope entries (if any) */ 566 567 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset); 568 while (ScopeOffset < SubTable->Length) 569 { 570 AcpiOsPrintf ("\n"); 571 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, 572 ScopeTable->Length, AcpiDmTableInfoDmarScope); 573 if (ACPI_FAILURE (Status)) 574 { 575 return; 576 } 577 578 /* Dump the PCI Path entries for this device scope */ 579 580 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */ 581 582 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable, 583 sizeof (ACPI_DMAR_DEVICE_SCOPE)); 584 585 while (PathOffset < ScopeTable->Length) 586 { 587 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path"); 588 AcpiOsPrintf ("[%2.2X, %2.2X]\n", PciPath[0], PciPath[1]); 589 590 /* Point to next PCI Path entry */ 591 592 PathOffset += 2; 593 PciPath += 2; 594 } 595 596 /* Point to next device scope entry */ 597 598 ScopeOffset += ScopeTable->Length; 599 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, 600 ScopeTable, ScopeTable->Length); 601 } 602 603 /* Point to next sub-table */ 604 605 Offset += SubTable->Length; 606 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length); 607 } 608 } 609 610 611 /******************************************************************************* 612 * 613 * FUNCTION: AcpiDmDumpEinj 614 * 615 * PARAMETERS: Table - A EINJ table 616 * 617 * RETURN: None 618 * 619 * DESCRIPTION: Format the contents of a EINJ. This table type consists 620 * of an open-ended number of subtables. 621 * 622 ******************************************************************************/ 623 624 void 625 AcpiDmDumpEinj ( 626 ACPI_TABLE_HEADER *Table) 627 { 628 ACPI_STATUS Status; 629 ACPI_WHEA_HEADER *SubTable; 630 UINT32 Length = Table->Length; 631 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 632 633 634 /* Main table */ 635 636 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 637 if (ACPI_FAILURE (Status)) 638 { 639 return; 640 } 641 642 /* Sub-tables */ 643 644 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 645 while (Offset < Table->Length) 646 { 647 AcpiOsPrintf ("\n"); 648 Status = AcpiDmDumpTable (Length, Offset, SubTable, 649 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 650 if (ACPI_FAILURE (Status)) 651 { 652 return; 653 } 654 655 /* Point to next sub-table (each subtable is of fixed length) */ 656 657 Offset += sizeof (ACPI_WHEA_HEADER); 658 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 659 sizeof (ACPI_WHEA_HEADER)); 660 } 661 } 662 663 664 /******************************************************************************* 665 * 666 * FUNCTION: AcpiDmDumpErst 667 * 668 * PARAMETERS: Table - A ERST table 669 * 670 * RETURN: None 671 * 672 * DESCRIPTION: Format the contents of a ERST. This table type consists 673 * of an open-ended number of subtables. 674 * 675 ******************************************************************************/ 676 677 void 678 AcpiDmDumpErst ( 679 ACPI_TABLE_HEADER *Table) 680 { 681 ACPI_STATUS Status; 682 ACPI_WHEA_HEADER *SubTable; 683 UINT32 Length = Table->Length; 684 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 685 686 687 /* Main table */ 688 689 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 690 if (ACPI_FAILURE (Status)) 691 { 692 return; 693 } 694 695 /* Sub-tables */ 696 697 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 698 while (Offset < Table->Length) 699 { 700 AcpiOsPrintf ("\n"); 701 Status = AcpiDmDumpTable (Length, Offset, SubTable, 702 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 703 if (ACPI_FAILURE (Status)) 704 { 705 return; 706 } 707 708 /* Point to next sub-table (each subtable is of fixed length) */ 709 710 Offset += sizeof (ACPI_WHEA_HEADER); 711 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 712 sizeof (ACPI_WHEA_HEADER)); 713 } 714 } 715 716 717 /******************************************************************************* 718 * 719 * FUNCTION: AcpiDmDumpHest 720 * 721 * PARAMETERS: Table - A HEST table 722 * 723 * RETURN: None 724 * 725 * DESCRIPTION: Format the contents of a HEST. This table type consists 726 * of an open-ended number of subtables. 727 * 728 ******************************************************************************/ 729 730 void 731 AcpiDmDumpHest ( 732 ACPI_TABLE_HEADER *Table) 733 { 734 ACPI_STATUS Status; 735 ACPI_HEST_HEADER *SubTable; 736 UINT32 Length = Table->Length; 737 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 738 ACPI_DMTABLE_INFO *InfoTable; 739 UINT32 SubTableLength; 740 741 742 /* Main table */ 743 744 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 745 if (ACPI_FAILURE (Status)) 746 { 747 return; 748 } 749 750 /* Sub-tables */ 751 752 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 753 while (Offset < Table->Length) 754 { 755 switch (SubTable->Type) 756 { 757 case ACPI_HEST_TYPE_XPF_MACHINE_CHECK: 758 InfoTable = AcpiDmTableInfoHest0; 759 SubTableLength = sizeof (ACPI_HEST_XPF_MACHINE_CHECK); 760 break; 761 762 case ACPI_HEST_TYPE_XPF_CORRECTED_MACHINE_CHECK: 763 InfoTable = AcpiDmTableInfoHest1; 764 SubTableLength = sizeof (ACPI_HEST_XPF_CORRECTED); 765 break; 766 767 case ACPI_HEST_TYPE_XPF_NON_MASKABLE_INTERRUPT: 768 InfoTable = AcpiDmTableInfoHest3; 769 SubTableLength = sizeof (ACPI_HEST_XPF_NMI); 770 break; 771 772 case ACPI_HEST_TYPE_IPF_CORRECTED_MACHINE_CHECK: 773 InfoTable = AcpiDmTableInfoHest4; 774 SubTableLength = sizeof (ACPI_HEST_IPF_CORRECTED); 775 break; 776 777 case ACPI_HEST_TYPE_IPF_CORRECTED_PLATFORM_ERROR: 778 InfoTable = AcpiDmTableInfoHest5; 779 SubTableLength = sizeof (ACPI_HEST_IPF_CORRECTED_PLATFORM); 780 break; 781 782 case ACPI_HEST_TYPE_AER_ROOT_PORT: 783 InfoTable = AcpiDmTableInfoHest6; 784 SubTableLength = sizeof (ACPI_HEST_AER_ROOT); 785 break; 786 787 case ACPI_HEST_TYPE_AER_ENDPOINT: 788 InfoTable = AcpiDmTableInfoHest7; 789 SubTableLength = sizeof (ACPI_HEST_AER); 790 break; 791 792 case ACPI_HEST_TYPE_AER_BRIDGE: 793 InfoTable = AcpiDmTableInfoHest8; 794 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE); 795 break; 796 797 case ACPI_HEST_TYPE_GENERIC_HARDWARE_ERROR_SOURCE: 798 InfoTable = AcpiDmTableInfoHest9; 799 SubTableLength = sizeof (ACPI_HEST_GENERIC); 800 break; 801 802 default: 803 /* Cannot continue on unknown type - no length */ 804 805 AcpiOsPrintf ("\n**** Unknown HEST sub-table type %X\n", SubTable->Type); 806 return; 807 } 808 809 AcpiOsPrintf ("\n"); 810 Status = AcpiDmDumpTable (Length, Offset, SubTable, 811 SubTableLength, InfoTable); 812 if (ACPI_FAILURE (Status)) 813 { 814 return; 815 } 816 817 /* Point to next sub-table (each subtable is of fixed length) */ 818 819 Offset += SubTableLength; 820 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength); 821 } 822 } 823 824 825 /******************************************************************************* 826 * 827 * FUNCTION: AcpiDmDumpMadt 828 * 829 * PARAMETERS: Table - A MADT table 830 * 831 * RETURN: None 832 * 833 * DESCRIPTION: Format the contents of a MADT. This table type consists 834 * of an open-ended number of subtables. 835 * 836 ******************************************************************************/ 837 838 void 839 AcpiDmDumpMadt ( 840 ACPI_TABLE_HEADER *Table) 841 { 842 ACPI_STATUS Status; 843 ACPI_SUBTABLE_HEADER *SubTable; 844 UINT32 Length = Table->Length; 845 UINT32 Offset = sizeof (ACPI_TABLE_MADT); 846 ACPI_DMTABLE_INFO *InfoTable; 847 848 849 /* Main table */ 850 851 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); 852 if (ACPI_FAILURE (Status)) 853 { 854 return; 855 } 856 857 /* Sub-tables */ 858 859 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 860 while (Offset < Table->Length) 861 { 862 /* Common sub-table header */ 863 864 AcpiOsPrintf ("\n"); 865 Status = AcpiDmDumpTable (Length, Offset, SubTable, 866 SubTable->Length, AcpiDmTableInfoMadtHdr); 867 if (ACPI_FAILURE (Status)) 868 { 869 return; 870 } 871 872 switch (SubTable->Type) 873 { 874 case ACPI_MADT_TYPE_LOCAL_APIC: 875 InfoTable = AcpiDmTableInfoMadt0; 876 break; 877 case ACPI_MADT_TYPE_IO_APIC: 878 InfoTable = AcpiDmTableInfoMadt1; 879 break; 880 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 881 InfoTable = AcpiDmTableInfoMadt2; 882 break; 883 case ACPI_MADT_TYPE_NMI_SOURCE: 884 InfoTable = AcpiDmTableInfoMadt3; 885 break; 886 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 887 InfoTable = AcpiDmTableInfoMadt4; 888 break; 889 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 890 InfoTable = AcpiDmTableInfoMadt5; 891 break; 892 case ACPI_MADT_TYPE_IO_SAPIC: 893 InfoTable = AcpiDmTableInfoMadt6; 894 break; 895 case ACPI_MADT_TYPE_LOCAL_SAPIC: 896 InfoTable = AcpiDmTableInfoMadt7; 897 break; 898 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 899 InfoTable = AcpiDmTableInfoMadt8; 900 break; 901 case ACPI_MADT_TYPE_LOCAL_X2APIC: 902 InfoTable = AcpiDmTableInfoMadt9; 903 break; 904 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 905 InfoTable = AcpiDmTableInfoMadt10; 906 break; 907 default: 908 AcpiOsPrintf ("\n**** Unknown MADT sub-table type %X\n\n", SubTable->Type); 909 910 /* Attempt to continue */ 911 912 if (!SubTable->Length) 913 { 914 AcpiOsPrintf ("Invalid zero length subtable\n"); 915 return; 916 } 917 goto NextSubTable; 918 } 919 920 Status = AcpiDmDumpTable (Length, Offset, SubTable, 921 SubTable->Length, InfoTable); 922 if (ACPI_FAILURE (Status)) 923 { 924 return; 925 } 926 927 NextSubTable: 928 /* Point to next sub-table */ 929 930 Offset += SubTable->Length; 931 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 932 } 933 } 934 935 936 /******************************************************************************* 937 * 938 * FUNCTION: AcpiDmDumpMcfg 939 * 940 * PARAMETERS: Table - A MCFG Table 941 * 942 * RETURN: None 943 * 944 * DESCRIPTION: Format the contents of a MCFG table 945 * 946 ******************************************************************************/ 947 948 void 949 AcpiDmDumpMcfg ( 950 ACPI_TABLE_HEADER *Table) 951 { 952 ACPI_STATUS Status; 953 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 954 ACPI_MCFG_ALLOCATION *SubTable; 955 956 957 /* Main table */ 958 959 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 960 if (ACPI_FAILURE (Status)) 961 { 962 return; 963 } 964 965 /* Sub-tables */ 966 967 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 968 while (Offset < Table->Length) 969 { 970 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 971 { 972 AcpiOsPrintf ("Warning: there are %d invalid trailing bytes\n", 973 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 974 return; 975 } 976 977 AcpiOsPrintf ("\n"); 978 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 979 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 980 if (ACPI_FAILURE (Status)) 981 { 982 return; 983 } 984 985 /* Point to next sub-table (each subtable is of fixed length) */ 986 987 Offset += sizeof (ACPI_MCFG_ALLOCATION); 988 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable, 989 sizeof (ACPI_MCFG_ALLOCATION)); 990 } 991 } 992 993 994 /******************************************************************************* 995 * 996 * FUNCTION: AcpiDmDumpSlit 997 * 998 * PARAMETERS: Table - An SLIT 999 * 1000 * RETURN: None 1001 * 1002 * DESCRIPTION: Format the contents of a SLIT 1003 * 1004 ******************************************************************************/ 1005 1006 void 1007 AcpiDmDumpSlit ( 1008 ACPI_TABLE_HEADER *Table) 1009 { 1010 ACPI_STATUS Status; 1011 UINT32 Offset; 1012 UINT8 *Row; 1013 UINT32 Localities; 1014 UINT32 i; 1015 UINT32 j; 1016 1017 1018 /* Main table */ 1019 1020 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit); 1021 if (ACPI_FAILURE (Status)) 1022 { 1023 return; 1024 } 1025 1026 /* Display the Locality NxN Matrix */ 1027 1028 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; 1029 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]); 1030 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry; 1031 1032 for (i = 0; i < Localities; i++) 1033 { 1034 /* Display one row of the matrix */ 1035 1036 AcpiDmLineHeader2 (Offset, Localities, "Locality", i); 1037 for (j = 0; j < Localities; j++) 1038 { 1039 /* Check for beyond EOT */ 1040 1041 if (Offset >= Table->Length) 1042 { 1043 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n"); 1044 return; 1045 } 1046 1047 AcpiOsPrintf ("%2.2X ", Row[j]); 1048 Offset++; 1049 1050 /* Display up to 16 bytes per output row */ 1051 1052 if (j && (((j+1) % 16) == 0) && ((j+1) < Localities)) 1053 { 1054 AcpiOsPrintf ("\n"); 1055 AcpiDmLineHeader (Offset, 0, ""); 1056 } 1057 } 1058 1059 /* Point to next row */ 1060 1061 AcpiOsPrintf ("\n"); 1062 Row += Localities; 1063 } 1064 } 1065 1066 1067 /******************************************************************************* 1068 * 1069 * FUNCTION: AcpiDmDumpSrat 1070 * 1071 * PARAMETERS: Table - A SRAT table 1072 * 1073 * RETURN: None 1074 * 1075 * DESCRIPTION: Format the contents of a SRAT 1076 * 1077 ******************************************************************************/ 1078 1079 void 1080 AcpiDmDumpSrat ( 1081 ACPI_TABLE_HEADER *Table) 1082 { 1083 ACPI_STATUS Status; 1084 UINT32 Offset = sizeof (ACPI_TABLE_SRAT); 1085 ACPI_SUBTABLE_HEADER *SubTable; 1086 ACPI_DMTABLE_INFO *InfoTable; 1087 1088 1089 /* Main table */ 1090 1091 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat); 1092 if (ACPI_FAILURE (Status)) 1093 { 1094 return; 1095 } 1096 1097 /* Sub-tables */ 1098 1099 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 1100 while (Offset < Table->Length) 1101 { 1102 /* Common sub-table header */ 1103 1104 AcpiOsPrintf ("\n"); 1105 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1106 SubTable->Length, AcpiDmTableInfoSratHdr); 1107 if (ACPI_FAILURE (Status)) 1108 { 1109 return; 1110 } 1111 1112 switch (SubTable->Type) 1113 { 1114 case ACPI_SRAT_TYPE_CPU_AFFINITY: 1115 InfoTable = AcpiDmTableInfoSrat0; 1116 break; 1117 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 1118 InfoTable = AcpiDmTableInfoSrat1; 1119 break; 1120 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 1121 InfoTable = AcpiDmTableInfoSrat2; 1122 break; 1123 default: 1124 AcpiOsPrintf ("\n**** Unknown SRAT sub-table type %X\n", SubTable->Type); 1125 1126 /* Attempt to continue */ 1127 1128 if (!SubTable->Length) 1129 { 1130 AcpiOsPrintf ("Invalid zero length subtable\n"); 1131 return; 1132 } 1133 goto NextSubTable; 1134 } 1135 1136 AcpiOsPrintf ("\n"); 1137 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1138 SubTable->Length, InfoTable); 1139 if (ACPI_FAILURE (Status)) 1140 { 1141 return; 1142 } 1143 1144 NextSubTable: 1145 /* Point to next sub-table */ 1146 1147 Offset += SubTable->Length; 1148 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 1149 } 1150 } 1151 1152