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 - 2010, 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 UINT8 Type; 310 311 312 /* No main table, only sub-tables */ 313 314 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); 315 while (Offset < Table->Length) 316 { 317 /* Common sub-table header */ 318 319 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 320 SubTable->Header.Length, AcpiDmTableInfoAsfHdr); 321 if (ACPI_FAILURE (Status)) 322 { 323 return; 324 } 325 326 /* The actual type is the lower 7 bits of Type */ 327 328 Type = (UINT8) (SubTable->Header.Type & 0x7F); 329 330 switch (Type) 331 { 332 case ACPI_ASF_TYPE_INFO: 333 InfoTable = AcpiDmTableInfoAsf0; 334 break; 335 336 case ACPI_ASF_TYPE_ALERT: 337 InfoTable = AcpiDmTableInfoAsf1; 338 DataInfoTable = AcpiDmTableInfoAsf1a; 339 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT)); 340 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts; 341 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength; 342 DataOffset = Offset + sizeof (ACPI_ASF_ALERT); 343 break; 344 345 case ACPI_ASF_TYPE_CONTROL: 346 InfoTable = AcpiDmTableInfoAsf2; 347 DataInfoTable = AcpiDmTableInfoAsf2a; 348 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE)); 349 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls; 350 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength; 351 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE); 352 break; 353 354 case ACPI_ASF_TYPE_BOOT: 355 InfoTable = AcpiDmTableInfoAsf3; 356 break; 357 358 case ACPI_ASF_TYPE_ADDRESS: 359 InfoTable = AcpiDmTableInfoAsf4; 360 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS)); 361 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices; 362 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS); 363 break; 364 365 default: 366 AcpiOsPrintf ("\n**** Unknown ASF sub-table type 0x%X\n", SubTable->Header.Type); 367 return; 368 } 369 370 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 371 SubTable->Header.Length, InfoTable); 372 if (ACPI_FAILURE (Status)) 373 { 374 return; 375 } 376 377 /* Dump variable-length extra data */ 378 379 switch (Type) 380 { 381 case ACPI_ASF_TYPE_ALERT: 382 case ACPI_ASF_TYPE_CONTROL: 383 384 for (i = 0; i < DataCount; i++) 385 { 386 AcpiOsPrintf ("\n"); 387 Status = AcpiDmDumpTable (Table->Length, DataOffset, 388 DataTable, DataLength, DataInfoTable); 389 if (ACPI_FAILURE (Status)) 390 { 391 return; 392 } 393 394 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength); 395 DataOffset += DataLength; 396 } 397 break; 398 399 case ACPI_ASF_TYPE_ADDRESS: 400 401 for (i = 0; i < DataLength; i++) 402 { 403 if (!(i % 16)) 404 { 405 AcpiDmLineHeader (DataOffset, 1, "Addresses"); 406 } 407 408 AcpiOsPrintf ("%2.2X ", *DataTable); 409 DataTable++; 410 DataOffset++; 411 if (DataOffset > Table->Length) 412 { 413 AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n"); 414 return; 415 } 416 } 417 418 AcpiOsPrintf ("\n"); 419 break; 420 421 default: 422 break; 423 } 424 425 AcpiOsPrintf ("\n"); 426 427 /* Point to next sub-table */ 428 429 if (!SubTable->Header.Length) 430 { 431 AcpiOsPrintf ("Invalid zero subtable header length\n"); 432 return; 433 } 434 435 Offset += SubTable->Header.Length; 436 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length); 437 } 438 } 439 440 441 /******************************************************************************* 442 * 443 * FUNCTION: AcpiDmDumpCpep 444 * 445 * PARAMETERS: Table - A CPEP table 446 * 447 * RETURN: None 448 * 449 * DESCRIPTION: Format the contents of a CPEP. This table type consists 450 * of an open-ended number of subtables. 451 * 452 ******************************************************************************/ 453 454 void 455 AcpiDmDumpCpep ( 456 ACPI_TABLE_HEADER *Table) 457 { 458 ACPI_STATUS Status; 459 ACPI_CPEP_POLLING *SubTable; 460 UINT32 Length = Table->Length; 461 UINT32 Offset = sizeof (ACPI_TABLE_CPEP); 462 463 464 /* Main table */ 465 466 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep); 467 if (ACPI_FAILURE (Status)) 468 { 469 return; 470 } 471 472 /* Sub-tables */ 473 474 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset); 475 while (Offset < Table->Length) 476 { 477 AcpiOsPrintf ("\n"); 478 Status = AcpiDmDumpTable (Length, Offset, SubTable, 479 SubTable->Header.Length, AcpiDmTableInfoCpep0); 480 if (ACPI_FAILURE (Status)) 481 { 482 return; 483 } 484 485 /* Point to next sub-table */ 486 487 Offset += SubTable->Header.Length; 488 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable, 489 SubTable->Header.Length); 490 } 491 } 492 493 494 /******************************************************************************* 495 * 496 * FUNCTION: AcpiDmDumpDmar 497 * 498 * PARAMETERS: Table - A DMAR table 499 * 500 * RETURN: None 501 * 502 * DESCRIPTION: Format the contents of a DMAR. This table type consists 503 * of an open-ended number of subtables. 504 * 505 ******************************************************************************/ 506 507 void 508 AcpiDmDumpDmar ( 509 ACPI_TABLE_HEADER *Table) 510 { 511 ACPI_STATUS Status; 512 ACPI_DMAR_HEADER *SubTable; 513 UINT32 Length = Table->Length; 514 UINT32 Offset = sizeof (ACPI_TABLE_DMAR); 515 ACPI_DMTABLE_INFO *InfoTable; 516 ACPI_DMAR_DEVICE_SCOPE *ScopeTable; 517 UINT32 ScopeOffset; 518 UINT8 *PciPath; 519 UINT32 PathOffset; 520 521 522 /* Main table */ 523 524 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); 525 if (ACPI_FAILURE (Status)) 526 { 527 return; 528 } 529 530 /* Sub-tables */ 531 532 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); 533 while (Offset < Table->Length) 534 { 535 /* Common sub-table header */ 536 537 AcpiOsPrintf ("\n"); 538 Status = AcpiDmDumpTable (Length, Offset, SubTable, 539 SubTable->Length, AcpiDmTableInfoDmarHdr); 540 if (ACPI_FAILURE (Status)) 541 { 542 return; 543 } 544 545 switch (SubTable->Type) 546 { 547 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 548 InfoTable = AcpiDmTableInfoDmar0; 549 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT); 550 break; 551 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 552 InfoTable = AcpiDmTableInfoDmar1; 553 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY); 554 break; 555 case ACPI_DMAR_TYPE_ATSR: 556 InfoTable = AcpiDmTableInfoDmar2; 557 ScopeOffset = sizeof (ACPI_DMAR_ATSR); 558 break; 559 case ACPI_DMAR_HARDWARE_AFFINITY: 560 InfoTable = AcpiDmTableInfoDmar3; 561 ScopeOffset = sizeof (ACPI_DMAR_RHSA); 562 break; 563 default: 564 AcpiOsPrintf ("\n**** Unknown DMAR sub-table type 0x%X\n\n", SubTable->Type); 565 return; 566 } 567 568 Status = AcpiDmDumpTable (Length, Offset, SubTable, 569 SubTable->Length, InfoTable); 570 if (ACPI_FAILURE (Status)) 571 { 572 return; 573 } 574 575 /* Dump the device scope entries (if any) */ 576 577 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset); 578 while (ScopeOffset < SubTable->Length) 579 { 580 AcpiOsPrintf ("\n"); 581 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, 582 ScopeTable->Length, AcpiDmTableInfoDmarScope); 583 if (ACPI_FAILURE (Status)) 584 { 585 return; 586 } 587 588 /* Dump the PCI Path entries for this device scope */ 589 590 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */ 591 592 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable, 593 sizeof (ACPI_DMAR_DEVICE_SCOPE)); 594 595 while (PathOffset < ScopeTable->Length) 596 { 597 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path"); 598 AcpiOsPrintf ("[%2.2X, %2.2X]\n", PciPath[0], PciPath[1]); 599 600 /* Point to next PCI Path entry */ 601 602 PathOffset += 2; 603 PciPath += 2; 604 } 605 606 /* Point to next device scope entry */ 607 608 ScopeOffset += ScopeTable->Length; 609 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, 610 ScopeTable, ScopeTable->Length); 611 } 612 613 /* Point to next sub-table */ 614 615 Offset += SubTable->Length; 616 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length); 617 } 618 } 619 620 621 /******************************************************************************* 622 * 623 * FUNCTION: AcpiDmDumpEinj 624 * 625 * PARAMETERS: Table - A EINJ table 626 * 627 * RETURN: None 628 * 629 * DESCRIPTION: Format the contents of a EINJ. This table type consists 630 * of an open-ended number of subtables. 631 * 632 ******************************************************************************/ 633 634 void 635 AcpiDmDumpEinj ( 636 ACPI_TABLE_HEADER *Table) 637 { 638 ACPI_STATUS Status; 639 ACPI_WHEA_HEADER *SubTable; 640 UINT32 Length = Table->Length; 641 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 642 643 644 /* Main table */ 645 646 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 647 if (ACPI_FAILURE (Status)) 648 { 649 return; 650 } 651 652 /* Sub-tables */ 653 654 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 655 while (Offset < Table->Length) 656 { 657 AcpiOsPrintf ("\n"); 658 Status = AcpiDmDumpTable (Length, Offset, SubTable, 659 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 660 if (ACPI_FAILURE (Status)) 661 { 662 return; 663 } 664 665 /* Point to next sub-table (each subtable is of fixed length) */ 666 667 Offset += sizeof (ACPI_WHEA_HEADER); 668 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 669 sizeof (ACPI_WHEA_HEADER)); 670 } 671 } 672 673 674 /******************************************************************************* 675 * 676 * FUNCTION: AcpiDmDumpErst 677 * 678 * PARAMETERS: Table - A ERST table 679 * 680 * RETURN: None 681 * 682 * DESCRIPTION: Format the contents of a ERST. This table type consists 683 * of an open-ended number of subtables. 684 * 685 ******************************************************************************/ 686 687 void 688 AcpiDmDumpErst ( 689 ACPI_TABLE_HEADER *Table) 690 { 691 ACPI_STATUS Status; 692 ACPI_WHEA_HEADER *SubTable; 693 UINT32 Length = Table->Length; 694 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 695 696 697 /* Main table */ 698 699 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 700 if (ACPI_FAILURE (Status)) 701 { 702 return; 703 } 704 705 /* Sub-tables */ 706 707 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 708 while (Offset < Table->Length) 709 { 710 AcpiOsPrintf ("\n"); 711 Status = AcpiDmDumpTable (Length, Offset, SubTable, 712 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 713 if (ACPI_FAILURE (Status)) 714 { 715 return; 716 } 717 718 /* Point to next sub-table (each subtable is of fixed length) */ 719 720 Offset += sizeof (ACPI_WHEA_HEADER); 721 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 722 sizeof (ACPI_WHEA_HEADER)); 723 } 724 } 725 726 727 /******************************************************************************* 728 * 729 * FUNCTION: AcpiDmDumpHest 730 * 731 * PARAMETERS: Table - A HEST table 732 * 733 * RETURN: None 734 * 735 * DESCRIPTION: Format the contents of a HEST. This table type consists 736 * of an open-ended number of subtables. 737 * 738 ******************************************************************************/ 739 740 void 741 AcpiDmDumpHest ( 742 ACPI_TABLE_HEADER *Table) 743 { 744 ACPI_STATUS Status; 745 ACPI_HEST_HEADER *SubTable; 746 UINT32 Length = Table->Length; 747 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 748 ACPI_DMTABLE_INFO *InfoTable; 749 UINT32 SubTableLength; 750 UINT32 BankCount; 751 ACPI_HEST_IA_ERROR_BANK *BankTable; 752 753 754 /* Main table */ 755 756 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 757 if (ACPI_FAILURE (Status)) 758 { 759 return; 760 } 761 762 /* Sub-tables */ 763 764 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 765 while (Offset < Table->Length) 766 { 767 BankCount = 0; 768 switch (SubTable->Type) 769 { 770 case ACPI_HEST_TYPE_IA32_CHECK: 771 InfoTable = AcpiDmTableInfoHest0; 772 SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK); 773 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 774 SubTable))->NumHardwareBanks; 775 break; 776 777 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 778 InfoTable = AcpiDmTableInfoHest1; 779 SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED); 780 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 781 SubTable))->NumHardwareBanks; 782 break; 783 784 case ACPI_HEST_TYPE_IA32_NMI: 785 InfoTable = AcpiDmTableInfoHest2; 786 SubTableLength = sizeof (ACPI_HEST_IA_NMI); 787 break; 788 789 case ACPI_HEST_TYPE_AER_ROOT_PORT: 790 InfoTable = AcpiDmTableInfoHest6; 791 SubTableLength = sizeof (ACPI_HEST_AER_ROOT); 792 break; 793 794 case ACPI_HEST_TYPE_AER_ENDPOINT: 795 InfoTable = AcpiDmTableInfoHest7; 796 SubTableLength = sizeof (ACPI_HEST_AER); 797 break; 798 799 case ACPI_HEST_TYPE_AER_BRIDGE: 800 InfoTable = AcpiDmTableInfoHest8; 801 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE); 802 break; 803 804 case ACPI_HEST_TYPE_GENERIC_ERROR: 805 InfoTable = AcpiDmTableInfoHest9; 806 SubTableLength = sizeof (ACPI_HEST_GENERIC); 807 break; 808 809 default: 810 /* Cannot continue on unknown type - no length */ 811 812 AcpiOsPrintf ("\n**** Unknown HEST sub-table type 0x%X\n", SubTable->Type); 813 return; 814 } 815 816 AcpiOsPrintf ("\n"); 817 Status = AcpiDmDumpTable (Length, Offset, SubTable, 818 SubTableLength, InfoTable); 819 if (ACPI_FAILURE (Status)) 820 { 821 return; 822 } 823 824 /* Point to end of current subtable (each subtable above is of fixed length) */ 825 826 Offset += SubTableLength; 827 828 /* If there are any (fixed-length) Error Banks from above, dump them now */ 829 830 if (BankCount) 831 { 832 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength); 833 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 834 835 while (BankCount) 836 { 837 AcpiOsPrintf ("\n"); 838 Status = AcpiDmDumpTable (Length, Offset, BankTable, 839 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 840 if (ACPI_FAILURE (Status)) 841 { 842 return; 843 } 844 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 845 BankTable++; 846 BankCount--; 847 } 848 } 849 850 /* Point to next sub-table */ 851 852 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength); 853 } 854 } 855 856 857 /******************************************************************************* 858 * 859 * FUNCTION: AcpiDmDumpIvrs 860 * 861 * PARAMETERS: Table - A IVRS table 862 * 863 * RETURN: None 864 * 865 * DESCRIPTION: Format the contents of a IVRS 866 * 867 ******************************************************************************/ 868 869 static UINT8 EntrySizes[] = {4,8,16,32}; 870 871 void 872 AcpiDmDumpIvrs ( 873 ACPI_TABLE_HEADER *Table) 874 { 875 ACPI_STATUS Status; 876 UINT32 Offset = sizeof (ACPI_TABLE_IVRS); 877 UINT32 EntryOffset; 878 UINT32 EntryLength; 879 UINT32 EntryType; 880 ACPI_IVRS_DE_HEADER *DeviceEntry; 881 ACPI_IVRS_HEADER *SubTable; 882 ACPI_DMTABLE_INFO *InfoTable; 883 884 885 /* Main table */ 886 887 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); 888 if (ACPI_FAILURE (Status)) 889 { 890 return; 891 } 892 893 /* Sub-tables */ 894 895 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); 896 while (Offset < Table->Length) 897 { 898 /* Common sub-table header */ 899 900 AcpiOsPrintf ("\n"); 901 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 902 SubTable->Length, AcpiDmTableInfoIvrsHdr); 903 if (ACPI_FAILURE (Status)) 904 { 905 return; 906 } 907 908 switch (SubTable->Type) 909 { 910 case ACPI_IVRS_TYPE_HARDWARE: 911 InfoTable = AcpiDmTableInfoIvrs0; 912 break; 913 case ACPI_IVRS_TYPE_MEMORY1: 914 case ACPI_IVRS_TYPE_MEMORY2: 915 case ACPI_IVRS_TYPE_MEMORY3: 916 InfoTable = AcpiDmTableInfoIvrs1; 917 break; 918 default: 919 AcpiOsPrintf ("\n**** Unknown IVRS sub-table type 0x%X\n", 920 SubTable->Type); 921 922 /* Attempt to continue */ 923 924 if (!SubTable->Length) 925 { 926 AcpiOsPrintf ("Invalid zero length subtable\n"); 927 return; 928 } 929 goto NextSubTable; 930 } 931 932 /* Dump the subtable */ 933 934 AcpiOsPrintf ("\n"); 935 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 936 SubTable->Length, InfoTable); 937 if (ACPI_FAILURE (Status)) 938 { 939 return; 940 } 941 942 /* The hardware subtable can contain multiple device entries */ 943 944 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE) 945 { 946 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE); 947 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable, 948 sizeof (ACPI_IVRS_HARDWARE)); 949 950 while (EntryOffset < (Offset + SubTable->Length)) 951 { 952 AcpiOsPrintf ("\n"); 953 /* 954 * Upper 2 bits of Type encode the length of the device entry 955 * 956 * 00 = 4 byte 957 * 01 = 8 byte 958 * 10 = 16 byte - currently no entries defined 959 * 11 = 32 byte - currently no entries defined 960 */ 961 EntryType = DeviceEntry->Type; 962 EntryLength = EntrySizes [EntryType >> 6]; 963 964 switch (EntryType) 965 { 966 /* 4-byte device entries */ 967 968 case ACPI_IVRS_TYPE_PAD4: 969 case ACPI_IVRS_TYPE_ALL: 970 case ACPI_IVRS_TYPE_SELECT: 971 case ACPI_IVRS_TYPE_START: 972 case ACPI_IVRS_TYPE_END: 973 974 InfoTable = AcpiDmTableInfoIvrs4; 975 break; 976 977 /* 8-byte entries, type A */ 978 979 case ACPI_IVRS_TYPE_ALIAS_SELECT: 980 case ACPI_IVRS_TYPE_ALIAS_START: 981 982 InfoTable = AcpiDmTableInfoIvrs8a; 983 break; 984 985 /* 8-byte entries, type B */ 986 987 case ACPI_IVRS_TYPE_PAD8: 988 case ACPI_IVRS_TYPE_EXT_SELECT: 989 case ACPI_IVRS_TYPE_EXT_START: 990 991 InfoTable = AcpiDmTableInfoIvrs8b; 992 break; 993 994 /* 8-byte entries, type C */ 995 996 case ACPI_IVRS_TYPE_SPECIAL: 997 998 InfoTable = AcpiDmTableInfoIvrs8c; 999 break; 1000 1001 default: 1002 InfoTable = AcpiDmTableInfoIvrs4; 1003 AcpiOsPrintf ( 1004 "\n**** Unknown IVRS device entry type/length: " 1005 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n", 1006 EntryType, EntryLength, EntryOffset); 1007 break; 1008 } 1009 1010 /* Dump the Device Entry */ 1011 1012 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 1013 DeviceEntry, EntryLength, InfoTable); 1014 1015 EntryOffset += EntryLength; 1016 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry, 1017 EntryLength); 1018 } 1019 } 1020 1021 NextSubTable: 1022 /* Point to next sub-table */ 1023 1024 Offset += SubTable->Length; 1025 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length); 1026 } 1027 } 1028 1029 1030 /******************************************************************************* 1031 * 1032 * FUNCTION: AcpiDmDumpMadt 1033 * 1034 * PARAMETERS: Table - A MADT table 1035 * 1036 * RETURN: None 1037 * 1038 * DESCRIPTION: Format the contents of a MADT. This table type consists 1039 * of an open-ended number of subtables. 1040 * 1041 ******************************************************************************/ 1042 1043 void 1044 AcpiDmDumpMadt ( 1045 ACPI_TABLE_HEADER *Table) 1046 { 1047 ACPI_STATUS Status; 1048 ACPI_SUBTABLE_HEADER *SubTable; 1049 UINT32 Length = Table->Length; 1050 UINT32 Offset = sizeof (ACPI_TABLE_MADT); 1051 ACPI_DMTABLE_INFO *InfoTable; 1052 1053 1054 /* Main table */ 1055 1056 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); 1057 if (ACPI_FAILURE (Status)) 1058 { 1059 return; 1060 } 1061 1062 /* Sub-tables */ 1063 1064 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 1065 while (Offset < Table->Length) 1066 { 1067 /* Common sub-table header */ 1068 1069 AcpiOsPrintf ("\n"); 1070 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1071 SubTable->Length, AcpiDmTableInfoMadtHdr); 1072 if (ACPI_FAILURE (Status)) 1073 { 1074 return; 1075 } 1076 1077 switch (SubTable->Type) 1078 { 1079 case ACPI_MADT_TYPE_LOCAL_APIC: 1080 InfoTable = AcpiDmTableInfoMadt0; 1081 break; 1082 case ACPI_MADT_TYPE_IO_APIC: 1083 InfoTable = AcpiDmTableInfoMadt1; 1084 break; 1085 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 1086 InfoTable = AcpiDmTableInfoMadt2; 1087 break; 1088 case ACPI_MADT_TYPE_NMI_SOURCE: 1089 InfoTable = AcpiDmTableInfoMadt3; 1090 break; 1091 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 1092 InfoTable = AcpiDmTableInfoMadt4; 1093 break; 1094 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 1095 InfoTable = AcpiDmTableInfoMadt5; 1096 break; 1097 case ACPI_MADT_TYPE_IO_SAPIC: 1098 InfoTable = AcpiDmTableInfoMadt6; 1099 break; 1100 case ACPI_MADT_TYPE_LOCAL_SAPIC: 1101 InfoTable = AcpiDmTableInfoMadt7; 1102 break; 1103 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 1104 InfoTable = AcpiDmTableInfoMadt8; 1105 break; 1106 case ACPI_MADT_TYPE_LOCAL_X2APIC: 1107 InfoTable = AcpiDmTableInfoMadt9; 1108 break; 1109 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 1110 InfoTable = AcpiDmTableInfoMadt10; 1111 break; 1112 default: 1113 AcpiOsPrintf ("\n**** Unknown MADT sub-table type 0x%X\n\n", SubTable->Type); 1114 1115 /* Attempt to continue */ 1116 1117 if (!SubTable->Length) 1118 { 1119 AcpiOsPrintf ("Invalid zero length subtable\n"); 1120 return; 1121 } 1122 goto NextSubTable; 1123 } 1124 1125 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1126 SubTable->Length, InfoTable); 1127 if (ACPI_FAILURE (Status)) 1128 { 1129 return; 1130 } 1131 1132 NextSubTable: 1133 /* Point to next sub-table */ 1134 1135 Offset += SubTable->Length; 1136 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 1137 } 1138 } 1139 1140 1141 /******************************************************************************* 1142 * 1143 * FUNCTION: AcpiDmDumpMcfg 1144 * 1145 * PARAMETERS: Table - A MCFG Table 1146 * 1147 * RETURN: None 1148 * 1149 * DESCRIPTION: Format the contents of a MCFG table 1150 * 1151 ******************************************************************************/ 1152 1153 void 1154 AcpiDmDumpMcfg ( 1155 ACPI_TABLE_HEADER *Table) 1156 { 1157 ACPI_STATUS Status; 1158 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 1159 ACPI_MCFG_ALLOCATION *SubTable; 1160 1161 1162 /* Main table */ 1163 1164 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 1165 if (ACPI_FAILURE (Status)) 1166 { 1167 return; 1168 } 1169 1170 /* Sub-tables */ 1171 1172 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 1173 while (Offset < Table->Length) 1174 { 1175 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 1176 { 1177 AcpiOsPrintf ("Warning: there are %d invalid trailing bytes\n", 1178 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 1179 return; 1180 } 1181 1182 AcpiOsPrintf ("\n"); 1183 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1184 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 1185 if (ACPI_FAILURE (Status)) 1186 { 1187 return; 1188 } 1189 1190 /* Point to next sub-table (each subtable is of fixed length) */ 1191 1192 Offset += sizeof (ACPI_MCFG_ALLOCATION); 1193 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable, 1194 sizeof (ACPI_MCFG_ALLOCATION)); 1195 } 1196 } 1197 1198 1199 /******************************************************************************* 1200 * 1201 * FUNCTION: AcpiDmDumpMsct 1202 * 1203 * PARAMETERS: Table - A MSCT table 1204 * 1205 * RETURN: None 1206 * 1207 * DESCRIPTION: Format the contents of a MSCT 1208 * 1209 ******************************************************************************/ 1210 1211 void 1212 AcpiDmDumpMsct ( 1213 ACPI_TABLE_HEADER *Table) 1214 { 1215 ACPI_STATUS Status; 1216 UINT32 Offset = sizeof (ACPI_TABLE_MSCT); 1217 ACPI_MSCT_PROXIMITY *SubTable; 1218 1219 1220 /* Main table */ 1221 1222 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); 1223 if (ACPI_FAILURE (Status)) 1224 { 1225 return; 1226 } 1227 1228 /* Sub-tables */ 1229 1230 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); 1231 while (Offset < Table->Length) 1232 { 1233 /* Common sub-table header */ 1234 1235 AcpiOsPrintf ("\n"); 1236 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1237 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); 1238 if (ACPI_FAILURE (Status)) 1239 { 1240 return; 1241 } 1242 1243 /* Point to next sub-table */ 1244 1245 Offset += sizeof (ACPI_MSCT_PROXIMITY); 1246 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY)); 1247 } 1248 } 1249 1250 1251 /******************************************************************************* 1252 * 1253 * FUNCTION: AcpiDmDumpSlit 1254 * 1255 * PARAMETERS: Table - An SLIT 1256 * 1257 * RETURN: None 1258 * 1259 * DESCRIPTION: Format the contents of a SLIT 1260 * 1261 ******************************************************************************/ 1262 1263 void 1264 AcpiDmDumpSlit ( 1265 ACPI_TABLE_HEADER *Table) 1266 { 1267 ACPI_STATUS Status; 1268 UINT32 Offset; 1269 UINT8 *Row; 1270 UINT32 Localities; 1271 UINT32 i; 1272 UINT32 j; 1273 1274 1275 /* Main table */ 1276 1277 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit); 1278 if (ACPI_FAILURE (Status)) 1279 { 1280 return; 1281 } 1282 1283 /* Display the Locality NxN Matrix */ 1284 1285 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; 1286 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]); 1287 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry; 1288 1289 for (i = 0; i < Localities; i++) 1290 { 1291 /* Display one row of the matrix */ 1292 1293 AcpiDmLineHeader2 (Offset, Localities, "Locality", i); 1294 for (j = 0; j < Localities; j++) 1295 { 1296 /* Check for beyond EOT */ 1297 1298 if (Offset >= Table->Length) 1299 { 1300 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n"); 1301 return; 1302 } 1303 1304 AcpiOsPrintf ("%2.2X ", Row[j]); 1305 Offset++; 1306 1307 /* Display up to 16 bytes per output row */ 1308 1309 if (j && (((j+1) % 16) == 0) && ((j+1) < Localities)) 1310 { 1311 AcpiOsPrintf ("\n"); 1312 AcpiDmLineHeader (Offset, 0, ""); 1313 } 1314 } 1315 1316 /* Point to next row */ 1317 1318 AcpiOsPrintf ("\n"); 1319 Row += Localities; 1320 } 1321 } 1322 1323 1324 /******************************************************************************* 1325 * 1326 * FUNCTION: AcpiDmDumpSrat 1327 * 1328 * PARAMETERS: Table - A SRAT table 1329 * 1330 * RETURN: None 1331 * 1332 * DESCRIPTION: Format the contents of a SRAT 1333 * 1334 ******************************************************************************/ 1335 1336 void 1337 AcpiDmDumpSrat ( 1338 ACPI_TABLE_HEADER *Table) 1339 { 1340 ACPI_STATUS Status; 1341 UINT32 Offset = sizeof (ACPI_TABLE_SRAT); 1342 ACPI_SUBTABLE_HEADER *SubTable; 1343 ACPI_DMTABLE_INFO *InfoTable; 1344 1345 1346 /* Main table */ 1347 1348 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat); 1349 if (ACPI_FAILURE (Status)) 1350 { 1351 return; 1352 } 1353 1354 /* Sub-tables */ 1355 1356 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 1357 while (Offset < Table->Length) 1358 { 1359 /* Common sub-table header */ 1360 1361 AcpiOsPrintf ("\n"); 1362 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1363 SubTable->Length, AcpiDmTableInfoSratHdr); 1364 if (ACPI_FAILURE (Status)) 1365 { 1366 return; 1367 } 1368 1369 switch (SubTable->Type) 1370 { 1371 case ACPI_SRAT_TYPE_CPU_AFFINITY: 1372 InfoTable = AcpiDmTableInfoSrat0; 1373 break; 1374 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 1375 InfoTable = AcpiDmTableInfoSrat1; 1376 break; 1377 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 1378 InfoTable = AcpiDmTableInfoSrat2; 1379 break; 1380 default: 1381 AcpiOsPrintf ("\n**** Unknown SRAT sub-table type 0x%X\n", SubTable->Type); 1382 1383 /* Attempt to continue */ 1384 1385 if (!SubTable->Length) 1386 { 1387 AcpiOsPrintf ("Invalid zero length subtable\n"); 1388 return; 1389 } 1390 goto NextSubTable; 1391 } 1392 1393 AcpiOsPrintf ("\n"); 1394 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1395 SubTable->Length, InfoTable); 1396 if (ACPI_FAILURE (Status)) 1397 { 1398 return; 1399 } 1400 1401 NextSubTable: 1402 /* Point to next sub-table */ 1403 1404 Offset += SubTable->Length; 1405 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 1406 } 1407 } 1408 1409 1410 /******************************************************************************* 1411 * 1412 * FUNCTION: AcpiDmDumpWdat 1413 * 1414 * PARAMETERS: Table - A WDAT table 1415 * 1416 * RETURN: None 1417 * 1418 * DESCRIPTION: Format the contents of a WDAT 1419 * 1420 ******************************************************************************/ 1421 1422 void 1423 AcpiDmDumpWdat ( 1424 ACPI_TABLE_HEADER *Table) 1425 { 1426 ACPI_STATUS Status; 1427 UINT32 Offset = sizeof (ACPI_TABLE_WDAT); 1428 ACPI_WDAT_ENTRY *SubTable; 1429 1430 1431 /* Main table */ 1432 1433 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat); 1434 if (ACPI_FAILURE (Status)) 1435 { 1436 return; 1437 } 1438 1439 /* Sub-tables */ 1440 1441 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset); 1442 while (Offset < Table->Length) 1443 { 1444 /* Common sub-table header */ 1445 1446 AcpiOsPrintf ("\n"); 1447 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1448 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0); 1449 if (ACPI_FAILURE (Status)) 1450 { 1451 return; 1452 } 1453 1454 /* Point to next sub-table */ 1455 1456 Offset += sizeof (ACPI_WDAT_ENTRY); 1457 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY)); 1458 } 1459 } 1460