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 - 2017, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 ***************************************************************************** 115 * 116 * Alternatively, you may choose to be licensed under the terms of the 117 * following license: 118 * 119 * Redistribution and use in source and binary forms, with or without 120 * modification, are permitted provided that the following conditions 121 * are met: 122 * 1. Redistributions of source code must retain the above copyright 123 * notice, this list of conditions, and the following disclaimer, 124 * without modification. 125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 126 * substantially similar to the "NO WARRANTY" disclaimer below 127 * ("Disclaimer") and any redistribution must be conditioned upon 128 * including a substantially similar Disclaimer requirement for further 129 * binary redistribution. 130 * 3. Neither the names of the above-listed copyright holders nor the names 131 * of any contributors may be used to endorse or promote products derived 132 * from this software without specific prior written permission. 133 * 134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 145 * 146 * Alternatively, you may choose to be licensed under the terms of the 147 * GNU General Public License ("GPL") version 2 as published by the Free 148 * Software Foundation. 149 * 150 *****************************************************************************/ 151 152 #include "acpi.h" 153 #include "accommon.h" 154 #include "acdisasm.h" 155 #include "actables.h" 156 157 /* This module used for application-level code only */ 158 159 #define _COMPONENT ACPI_CA_DISASSEMBLER 160 ACPI_MODULE_NAME ("dmtbdump") 161 162 163 /* Local prototypes */ 164 165 static void 166 AcpiDmValidateFadtLength ( 167 UINT32 Revision, 168 UINT32 Length); 169 170 171 /******************************************************************************* 172 * 173 * FUNCTION: AcpiDmDumpBuffer 174 * 175 * PARAMETERS: Table - ACPI Table or subtable 176 * BufferOffset - Offset of buffer from Table above 177 * Length - Length of the buffer 178 * AbsoluteOffset - Offset of buffer in the main ACPI table 179 * Header - Name of the buffer field (printed on the 180 * first line only.) 181 * 182 * RETURN: None 183 * 184 * DESCRIPTION: Format the contents of an arbitrary length data buffer (in the 185 * disassembler output format.) 186 * 187 ******************************************************************************/ 188 189 void 190 AcpiDmDumpBuffer ( 191 void *Table, 192 UINT32 BufferOffset, 193 UINT32 Length, 194 UINT32 AbsoluteOffset, 195 char *Header) 196 { 197 UINT8 *Buffer; 198 UINT32 i; 199 200 201 if (!Length) 202 { 203 return; 204 } 205 206 Buffer = ACPI_CAST_PTR (UINT8, Table) + BufferOffset; 207 i = 0; 208 209 while (i < Length) 210 { 211 if (!(i % 16)) 212 { 213 /* Insert a backslash - line continuation character */ 214 215 if (Length > 16) 216 { 217 AcpiOsPrintf ("\\\n "); 218 } 219 } 220 221 AcpiOsPrintf ("%.02X ", *Buffer); 222 i++; 223 Buffer++; 224 AbsoluteOffset++; 225 } 226 227 AcpiOsPrintf ("\n"); 228 } 229 230 231 /******************************************************************************* 232 * 233 * FUNCTION: AcpiDmDumpUnicode 234 * 235 * PARAMETERS: Table - ACPI Table or subtable 236 * BufferOffset - Offset of buffer from Table above 237 * ByteLength - Length of the buffer 238 * 239 * RETURN: None 240 * 241 * DESCRIPTION: Validate and dump the contents of a buffer that contains 242 * unicode data. The output is a standard ASCII string. If it 243 * appears that the data is not unicode, the buffer is dumped 244 * as hex characters. 245 * 246 ******************************************************************************/ 247 248 void 249 AcpiDmDumpUnicode ( 250 void *Table, 251 UINT32 BufferOffset, 252 UINT32 ByteLength) 253 { 254 UINT8 *Buffer; 255 UINT32 Length; 256 UINT32 i; 257 258 259 Buffer = ((UINT8 *) Table) + BufferOffset; 260 Length = ByteLength - 2; /* Last two bytes are the null terminator */ 261 262 /* Ensure all low bytes are entirely printable ASCII */ 263 264 for (i = 0; i < Length; i += 2) 265 { 266 if (!isprint (Buffer[i])) 267 { 268 goto DumpRawBuffer; 269 } 270 } 271 272 /* Ensure all high bytes are zero */ 273 274 for (i = 1; i < Length; i += 2) 275 { 276 if (Buffer[i]) 277 { 278 goto DumpRawBuffer; 279 } 280 } 281 282 /* Dump the buffer as a normal string */ 283 284 AcpiOsPrintf ("\""); 285 for (i = 0; i < Length; i += 2) 286 { 287 AcpiOsPrintf ("%c", Buffer[i]); 288 } 289 290 AcpiOsPrintf ("\"\n"); 291 return; 292 293 DumpRawBuffer: 294 AcpiDmDumpBuffer (Table, BufferOffset, ByteLength, 295 BufferOffset, NULL); 296 AcpiOsPrintf ("\n"); 297 } 298 299 300 /******************************************************************************* 301 * 302 * FUNCTION: AcpiDmDumpRsdp 303 * 304 * PARAMETERS: Table - A RSDP 305 * 306 * RETURN: Length of the table (there is not always a length field, 307 * use revision or length if available (ACPI 2.0+)) 308 * 309 * DESCRIPTION: Format the contents of a RSDP 310 * 311 ******************************************************************************/ 312 313 UINT32 314 AcpiDmDumpRsdp ( 315 ACPI_TABLE_HEADER *Table) 316 { 317 ACPI_TABLE_RSDP *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table); 318 UINT32 Length = sizeof (ACPI_RSDP_COMMON); 319 UINT8 Checksum; 320 ACPI_STATUS Status; 321 322 323 /* Dump the common ACPI 1.0 portion */ 324 325 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1); 326 if (ACPI_FAILURE (Status)) 327 { 328 return (Length); 329 } 330 331 /* Validate the first checksum */ 332 333 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON), 334 Rsdp->Checksum); 335 if (Checksum != Rsdp->Checksum) 336 { 337 AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n", 338 Checksum); 339 } 340 341 /* The RSDP for ACPI 2.0+ contains more data and has a Length field */ 342 343 if (Rsdp->Revision > 0) 344 { 345 Length = Rsdp->Length; 346 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2); 347 if (ACPI_FAILURE (Status)) 348 { 349 return (Length); 350 } 351 352 /* Validate the extended checksum over entire RSDP */ 353 354 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP), 355 Rsdp->ExtendedChecksum); 356 if (Checksum != Rsdp->ExtendedChecksum) 357 { 358 AcpiOsPrintf ( 359 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n", 360 Checksum); 361 } 362 } 363 364 return (Length); 365 } 366 367 368 /******************************************************************************* 369 * 370 * FUNCTION: AcpiDmDumpRsdt 371 * 372 * PARAMETERS: Table - A RSDT 373 * 374 * RETURN: None 375 * 376 * DESCRIPTION: Format the contents of a RSDT 377 * 378 ******************************************************************************/ 379 380 void 381 AcpiDmDumpRsdt ( 382 ACPI_TABLE_HEADER *Table) 383 { 384 UINT32 *Array; 385 UINT32 Entries; 386 UINT32 Offset; 387 UINT32 i; 388 389 390 /* Point to start of table pointer array */ 391 392 Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry; 393 Offset = sizeof (ACPI_TABLE_HEADER); 394 395 /* RSDT uses 32-bit pointers */ 396 397 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32); 398 399 for (i = 0; i < Entries; i++) 400 { 401 AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i); 402 AcpiOsPrintf ("%8.8X\n", Array[i]); 403 Offset += sizeof (UINT32); 404 } 405 } 406 407 408 /******************************************************************************* 409 * 410 * FUNCTION: AcpiDmDumpXsdt 411 * 412 * PARAMETERS: Table - A XSDT 413 * 414 * RETURN: None 415 * 416 * DESCRIPTION: Format the contents of a XSDT 417 * 418 ******************************************************************************/ 419 420 void 421 AcpiDmDumpXsdt ( 422 ACPI_TABLE_HEADER *Table) 423 { 424 UINT64 *Array; 425 UINT32 Entries; 426 UINT32 Offset; 427 UINT32 i; 428 429 430 /* Point to start of table pointer array */ 431 432 Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry; 433 Offset = sizeof (ACPI_TABLE_HEADER); 434 435 /* XSDT uses 64-bit pointers */ 436 437 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64); 438 439 for (i = 0; i < Entries; i++) 440 { 441 AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i); 442 AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i])); 443 Offset += sizeof (UINT64); 444 } 445 } 446 447 448 /******************************************************************************* 449 * 450 * FUNCTION: AcpiDmDumpFadt 451 * 452 * PARAMETERS: Table - A FADT 453 * 454 * RETURN: None 455 * 456 * DESCRIPTION: Format the contents of a FADT 457 * 458 * NOTE: We cannot depend on the FADT version to indicate the actual 459 * contents of the FADT because of BIOS bugs. The table length 460 * is the only reliable indicator. 461 * 462 ******************************************************************************/ 463 464 void 465 AcpiDmDumpFadt ( 466 ACPI_TABLE_HEADER *Table) 467 { 468 ACPI_STATUS Status; 469 470 471 /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */ 472 473 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 474 AcpiDmTableInfoFadt1); 475 if (ACPI_FAILURE (Status)) 476 { 477 return; 478 } 479 480 /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */ 481 482 if ((Table->Length > ACPI_FADT_V1_SIZE) && 483 (Table->Length <= ACPI_FADT_V2_SIZE)) 484 { 485 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 486 AcpiDmTableInfoFadt2); 487 if (ACPI_FAILURE (Status)) 488 { 489 return; 490 } 491 } 492 493 /* Check for FADT revision 3/4 fields and up (ACPI 2.0+ extended data) */ 494 495 else if (Table->Length > ACPI_FADT_V2_SIZE) 496 { 497 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 498 AcpiDmTableInfoFadt3); 499 if (ACPI_FAILURE (Status)) 500 { 501 return; 502 } 503 504 /* Check for FADT revision 5 fields and up (ACPI 5.0+) */ 505 506 if (Table->Length > ACPI_FADT_V3_SIZE) 507 { 508 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 509 AcpiDmTableInfoFadt5); 510 if (ACPI_FAILURE (Status)) 511 { 512 return; 513 } 514 } 515 516 /* Check for FADT revision 6 fields and up (ACPI 6.0+) */ 517 518 if (Table->Length > ACPI_FADT_V3_SIZE) 519 { 520 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 521 AcpiDmTableInfoFadt6); 522 if (ACPI_FAILURE (Status)) 523 { 524 return; 525 } 526 } 527 } 528 529 /* Validate various fields in the FADT, including length */ 530 531 AcpiTbCreateLocalFadt (Table, Table->Length); 532 533 /* Validate FADT length against the revision */ 534 535 AcpiDmValidateFadtLength (Table->Revision, Table->Length); 536 } 537 538 539 /******************************************************************************* 540 * 541 * FUNCTION: AcpiDmValidateFadtLength 542 * 543 * PARAMETERS: Revision - FADT revision (Header->Revision) 544 * Length - FADT length (Header->Length 545 * 546 * RETURN: None 547 * 548 * DESCRIPTION: Check the FADT revision against the expected table length for 549 * that revision. Issue a warning if the length is not what was 550 * expected. This seems to be such a common BIOS bug that the 551 * FADT revision has been rendered virtually meaningless. 552 * 553 ******************************************************************************/ 554 555 static void 556 AcpiDmValidateFadtLength ( 557 UINT32 Revision, 558 UINT32 Length) 559 { 560 UINT32 ExpectedLength; 561 562 563 switch (Revision) 564 { 565 case 0: 566 567 AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n"); 568 return; 569 570 case 1: 571 572 ExpectedLength = ACPI_FADT_V1_SIZE; 573 break; 574 575 case 2: 576 577 ExpectedLength = ACPI_FADT_V2_SIZE; 578 break; 579 580 case 3: 581 case 4: 582 583 ExpectedLength = ACPI_FADT_V3_SIZE; 584 break; 585 586 case 5: 587 588 ExpectedLength = ACPI_FADT_V5_SIZE; 589 break; 590 591 default: 592 593 return; 594 } 595 596 if (Length == ExpectedLength) 597 { 598 return; 599 } 600 601 AcpiOsPrintf ( 602 "\n// ACPI Warning: FADT revision %X does not match length: " 603 "found %X expected %X\n", 604 Revision, Length, ExpectedLength); 605 } 606 607 608 /******************************************************************************* 609 * 610 * FUNCTION: AcpiDmDumpAsf 611 * 612 * PARAMETERS: Table - A ASF table 613 * 614 * RETURN: None 615 * 616 * DESCRIPTION: Format the contents of a ASF table 617 * 618 ******************************************************************************/ 619 620 void 621 AcpiDmDumpAsf ( 622 ACPI_TABLE_HEADER *Table) 623 { 624 ACPI_STATUS Status; 625 UINT32 Offset = sizeof (ACPI_TABLE_HEADER); 626 ACPI_ASF_INFO *SubTable; 627 ACPI_DMTABLE_INFO *InfoTable; 628 ACPI_DMTABLE_INFO *DataInfoTable = NULL; 629 UINT8 *DataTable = NULL; 630 UINT32 DataCount = 0; 631 UINT32 DataLength = 0; 632 UINT32 DataOffset = 0; 633 UINT32 i; 634 UINT8 Type; 635 636 637 /* No main table, only subtables */ 638 639 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); 640 while (Offset < Table->Length) 641 { 642 /* Common subtable header */ 643 644 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 645 SubTable->Header.Length, AcpiDmTableInfoAsfHdr); 646 if (ACPI_FAILURE (Status)) 647 { 648 return; 649 } 650 651 /* The actual type is the lower 7 bits of Type */ 652 653 Type = (UINT8) (SubTable->Header.Type & 0x7F); 654 655 switch (Type) 656 { 657 case ACPI_ASF_TYPE_INFO: 658 659 InfoTable = AcpiDmTableInfoAsf0; 660 break; 661 662 case ACPI_ASF_TYPE_ALERT: 663 664 InfoTable = AcpiDmTableInfoAsf1; 665 DataInfoTable = AcpiDmTableInfoAsf1a; 666 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT)); 667 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts; 668 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength; 669 DataOffset = Offset + sizeof (ACPI_ASF_ALERT); 670 break; 671 672 case ACPI_ASF_TYPE_CONTROL: 673 674 InfoTable = AcpiDmTableInfoAsf2; 675 DataInfoTable = AcpiDmTableInfoAsf2a; 676 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE)); 677 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls; 678 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength; 679 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE); 680 break; 681 682 case ACPI_ASF_TYPE_BOOT: 683 684 InfoTable = AcpiDmTableInfoAsf3; 685 break; 686 687 case ACPI_ASF_TYPE_ADDRESS: 688 689 InfoTable = AcpiDmTableInfoAsf4; 690 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS)); 691 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices; 692 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS); 693 break; 694 695 default: 696 697 AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n", 698 SubTable->Header.Type); 699 return; 700 } 701 702 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 703 SubTable->Header.Length, InfoTable); 704 if (ACPI_FAILURE (Status)) 705 { 706 return; 707 } 708 709 /* Dump variable-length extra data */ 710 711 switch (Type) 712 { 713 case ACPI_ASF_TYPE_ALERT: 714 case ACPI_ASF_TYPE_CONTROL: 715 716 for (i = 0; i < DataCount; i++) 717 { 718 AcpiOsPrintf ("\n"); 719 Status = AcpiDmDumpTable (Table->Length, DataOffset, 720 DataTable, DataLength, DataInfoTable); 721 if (ACPI_FAILURE (Status)) 722 { 723 return; 724 } 725 726 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength); 727 DataOffset += DataLength; 728 } 729 break; 730 731 case ACPI_ASF_TYPE_ADDRESS: 732 733 for (i = 0; i < DataLength; i++) 734 { 735 if (!(i % 16)) 736 { 737 AcpiDmLineHeader (DataOffset, 1, "Addresses"); 738 } 739 740 AcpiOsPrintf ("%2.2X ", *DataTable); 741 DataTable++; 742 DataOffset++; 743 744 if (DataOffset > Table->Length) 745 { 746 AcpiOsPrintf ( 747 "**** ACPI table terminates in the middle of a " 748 "data structure! (ASF! table)\n"); 749 return; 750 } 751 } 752 753 AcpiOsPrintf ("\n"); 754 break; 755 756 default: 757 758 break; 759 } 760 761 AcpiOsPrintf ("\n"); 762 763 /* Point to next subtable */ 764 765 if (!SubTable->Header.Length) 766 { 767 AcpiOsPrintf ("Invalid zero subtable header length\n"); 768 return; 769 } 770 771 Offset += SubTable->Header.Length; 772 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, 773 SubTable->Header.Length); 774 } 775 } 776 777 778 /******************************************************************************* 779 * 780 * FUNCTION: AcpiDmDumpCpep 781 * 782 * PARAMETERS: Table - A CPEP table 783 * 784 * RETURN: None 785 * 786 * DESCRIPTION: Format the contents of a CPEP. This table type consists 787 * of an open-ended number of subtables. 788 * 789 ******************************************************************************/ 790 791 void 792 AcpiDmDumpCpep ( 793 ACPI_TABLE_HEADER *Table) 794 { 795 ACPI_STATUS Status; 796 ACPI_CPEP_POLLING *SubTable; 797 UINT32 Length = Table->Length; 798 UINT32 Offset = sizeof (ACPI_TABLE_CPEP); 799 800 801 /* Main table */ 802 803 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep); 804 if (ACPI_FAILURE (Status)) 805 { 806 return; 807 } 808 809 /* Subtables */ 810 811 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset); 812 while (Offset < Table->Length) 813 { 814 AcpiOsPrintf ("\n"); 815 Status = AcpiDmDumpTable (Length, Offset, SubTable, 816 SubTable->Header.Length, AcpiDmTableInfoCpep0); 817 if (ACPI_FAILURE (Status)) 818 { 819 return; 820 } 821 822 /* Point to next subtable */ 823 824 Offset += SubTable->Header.Length; 825 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable, 826 SubTable->Header.Length); 827 } 828 } 829 830 831 /******************************************************************************* 832 * 833 * FUNCTION: AcpiDmDumpCsrt 834 * 835 * PARAMETERS: Table - A CSRT table 836 * 837 * RETURN: None 838 * 839 * DESCRIPTION: Format the contents of a CSRT. This table type consists 840 * of an open-ended number of subtables. 841 * 842 ******************************************************************************/ 843 844 void 845 AcpiDmDumpCsrt ( 846 ACPI_TABLE_HEADER *Table) 847 { 848 ACPI_STATUS Status; 849 ACPI_CSRT_GROUP *SubTable; 850 ACPI_CSRT_SHARED_INFO *SharedInfoTable; 851 ACPI_CSRT_DESCRIPTOR *SubSubTable; 852 UINT32 Length = Table->Length; 853 UINT32 Offset = sizeof (ACPI_TABLE_CSRT); 854 UINT32 SubOffset; 855 UINT32 SubSubOffset; 856 UINT32 InfoLength; 857 858 859 /* The main table only contains the ACPI header, thus already handled */ 860 861 /* Subtables (Resource Groups) */ 862 863 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset); 864 while (Offset < Table->Length) 865 { 866 /* Resource group subtable */ 867 868 AcpiOsPrintf ("\n"); 869 Status = AcpiDmDumpTable (Length, Offset, SubTable, 870 SubTable->Length, AcpiDmTableInfoCsrt0); 871 if (ACPI_FAILURE (Status)) 872 { 873 return; 874 } 875 876 /* Shared info subtable (One per resource group) */ 877 878 SubOffset = sizeof (ACPI_CSRT_GROUP); 879 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table, 880 Offset + SubOffset); 881 882 AcpiOsPrintf ("\n"); 883 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable, 884 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1); 885 if (ACPI_FAILURE (Status)) 886 { 887 return; 888 } 889 890 SubOffset += SubTable->SharedInfoLength; 891 892 /* Sub-Subtables (Resource Descriptors) */ 893 894 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table, 895 Offset + SubOffset); 896 897 while ((SubOffset < SubTable->Length) && 898 ((Offset + SubOffset) < Table->Length)) 899 { 900 AcpiOsPrintf ("\n"); 901 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable, 902 SubSubTable->Length, AcpiDmTableInfoCsrt2); 903 if (ACPI_FAILURE (Status)) 904 { 905 return; 906 } 907 908 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR); 909 910 /* Resource-specific info buffer */ 911 912 InfoLength = SubSubTable->Length - SubSubOffset; 913 if (InfoLength) 914 { 915 Status = AcpiDmDumpTable (Length, 916 Offset + SubOffset + SubSubOffset, Table, 917 InfoLength, AcpiDmTableInfoCsrt2a); 918 if (ACPI_FAILURE (Status)) 919 { 920 return; 921 } 922 SubSubOffset += InfoLength; 923 } 924 925 /* Point to next sub-subtable */ 926 927 SubOffset += SubSubTable->Length; 928 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable, 929 SubSubTable->Length); 930 } 931 932 /* Point to next subtable */ 933 934 Offset += SubTable->Length; 935 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable, 936 SubTable->Length); 937 } 938 } 939 940 941 /******************************************************************************* 942 * 943 * FUNCTION: AcpiDmDumpDbg2 944 * 945 * PARAMETERS: Table - A DBG2 table 946 * 947 * RETURN: None 948 * 949 * DESCRIPTION: Format the contents of a DBG2. This table type consists 950 * of an open-ended number of subtables. 951 * 952 ******************************************************************************/ 953 954 void 955 AcpiDmDumpDbg2 ( 956 ACPI_TABLE_HEADER *Table) 957 { 958 ACPI_STATUS Status; 959 ACPI_DBG2_DEVICE *SubTable; 960 UINT32 Length = Table->Length; 961 UINT32 Offset = sizeof (ACPI_TABLE_DBG2); 962 UINT32 i; 963 UINT32 ArrayOffset; 964 UINT32 AbsoluteOffset; 965 UINT8 *Array; 966 967 968 /* Main table */ 969 970 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2); 971 if (ACPI_FAILURE (Status)) 972 { 973 return; 974 } 975 976 /* Subtables */ 977 978 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset); 979 while (Offset < Table->Length) 980 { 981 AcpiOsPrintf ("\n"); 982 Status = AcpiDmDumpTable (Length, Offset, SubTable, 983 SubTable->Length, AcpiDmTableInfoDbg2Device); 984 if (ACPI_FAILURE (Status)) 985 { 986 return; 987 } 988 989 /* Dump the BaseAddress array */ 990 991 for (i = 0; i < SubTable->RegisterCount; i++) 992 { 993 ArrayOffset = SubTable->BaseAddressOffset + 994 (sizeof (ACPI_GENERIC_ADDRESS) * i); 995 AbsoluteOffset = Offset + ArrayOffset; 996 Array = (UINT8 *) SubTable + ArrayOffset; 997 998 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 999 SubTable->Length, AcpiDmTableInfoDbg2Addr); 1000 if (ACPI_FAILURE (Status)) 1001 { 1002 return; 1003 } 1004 } 1005 1006 /* Dump the AddressSize array */ 1007 1008 for (i = 0; i < SubTable->RegisterCount; i++) 1009 { 1010 ArrayOffset = SubTable->AddressSizeOffset + 1011 (sizeof (UINT32) * i); 1012 AbsoluteOffset = Offset + ArrayOffset; 1013 Array = (UINT8 *) SubTable + ArrayOffset; 1014 1015 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 1016 SubTable->Length, AcpiDmTableInfoDbg2Size); 1017 if (ACPI_FAILURE (Status)) 1018 { 1019 return; 1020 } 1021 } 1022 1023 /* Dump the Namestring (required) */ 1024 1025 AcpiOsPrintf ("\n"); 1026 ArrayOffset = SubTable->NamepathOffset; 1027 AbsoluteOffset = Offset + ArrayOffset; 1028 Array = (UINT8 *) SubTable + ArrayOffset; 1029 1030 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 1031 SubTable->Length, AcpiDmTableInfoDbg2Name); 1032 if (ACPI_FAILURE (Status)) 1033 { 1034 return; 1035 } 1036 1037 /* Dump the OemData (optional) */ 1038 1039 if (SubTable->OemDataOffset) 1040 { 1041 Status = AcpiDmDumpTable (Length, Offset + SubTable->OemDataOffset, 1042 Table, SubTable->OemDataLength, 1043 AcpiDmTableInfoDbg2OemData); 1044 if (ACPI_FAILURE (Status)) 1045 { 1046 return; 1047 } 1048 } 1049 1050 /* Point to next subtable */ 1051 1052 Offset += SubTable->Length; 1053 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable, 1054 SubTable->Length); 1055 } 1056 } 1057 1058 1059 /******************************************************************************* 1060 * 1061 * FUNCTION: AcpiDmDumpDmar 1062 * 1063 * PARAMETERS: Table - A DMAR table 1064 * 1065 * RETURN: None 1066 * 1067 * DESCRIPTION: Format the contents of a DMAR. This table type consists 1068 * of an open-ended number of subtables. 1069 * 1070 ******************************************************************************/ 1071 1072 void 1073 AcpiDmDumpDmar ( 1074 ACPI_TABLE_HEADER *Table) 1075 { 1076 ACPI_STATUS Status; 1077 ACPI_DMAR_HEADER *SubTable; 1078 UINT32 Length = Table->Length; 1079 UINT32 Offset = sizeof (ACPI_TABLE_DMAR); 1080 ACPI_DMTABLE_INFO *InfoTable; 1081 ACPI_DMAR_DEVICE_SCOPE *ScopeTable; 1082 UINT32 ScopeOffset; 1083 UINT8 *PciPath; 1084 UINT32 PathOffset; 1085 1086 1087 /* Main table */ 1088 1089 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); 1090 if (ACPI_FAILURE (Status)) 1091 { 1092 return; 1093 } 1094 1095 /* Subtables */ 1096 1097 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); 1098 while (Offset < Table->Length) 1099 { 1100 /* Common subtable header */ 1101 1102 AcpiOsPrintf ("\n"); 1103 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1104 SubTable->Length, AcpiDmTableInfoDmarHdr); 1105 if (ACPI_FAILURE (Status)) 1106 { 1107 return; 1108 } 1109 1110 AcpiOsPrintf ("\n"); 1111 1112 switch (SubTable->Type) 1113 { 1114 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 1115 1116 InfoTable = AcpiDmTableInfoDmar0; 1117 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT); 1118 break; 1119 1120 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 1121 1122 InfoTable = AcpiDmTableInfoDmar1; 1123 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY); 1124 break; 1125 1126 case ACPI_DMAR_TYPE_ROOT_ATS: 1127 1128 InfoTable = AcpiDmTableInfoDmar2; 1129 ScopeOffset = sizeof (ACPI_DMAR_ATSR); 1130 break; 1131 1132 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY: 1133 1134 InfoTable = AcpiDmTableInfoDmar3; 1135 ScopeOffset = sizeof (ACPI_DMAR_RHSA); 1136 break; 1137 1138 case ACPI_DMAR_TYPE_NAMESPACE: 1139 1140 InfoTable = AcpiDmTableInfoDmar4; 1141 ScopeOffset = sizeof (ACPI_DMAR_ANDD); 1142 break; 1143 1144 default: 1145 1146 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n", 1147 SubTable->Type); 1148 return; 1149 } 1150 1151 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1152 SubTable->Length, InfoTable); 1153 if (ACPI_FAILURE (Status)) 1154 { 1155 return; 1156 } 1157 1158 /* 1159 * Dump the optional device scope entries 1160 */ 1161 if ((SubTable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || 1162 (SubTable->Type == ACPI_DMAR_TYPE_NAMESPACE)) 1163 { 1164 /* These types do not support device scopes */ 1165 1166 goto NextSubtable; 1167 } 1168 1169 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset); 1170 while (ScopeOffset < SubTable->Length) 1171 { 1172 AcpiOsPrintf ("\n"); 1173 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, 1174 ScopeTable->Length, AcpiDmTableInfoDmarScope); 1175 if (ACPI_FAILURE (Status)) 1176 { 1177 return; 1178 } 1179 AcpiOsPrintf ("\n"); 1180 1181 /* Dump the PCI Path entries for this device scope */ 1182 1183 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */ 1184 1185 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable, 1186 sizeof (ACPI_DMAR_DEVICE_SCOPE)); 1187 1188 while (PathOffset < ScopeTable->Length) 1189 { 1190 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, 1191 "PCI Path"); 1192 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]); 1193 1194 /* Point to next PCI Path entry */ 1195 1196 PathOffset += 2; 1197 PciPath += 2; 1198 AcpiOsPrintf ("\n"); 1199 } 1200 1201 /* Point to next device scope entry */ 1202 1203 ScopeOffset += ScopeTable->Length; 1204 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, 1205 ScopeTable, ScopeTable->Length); 1206 } 1207 1208 NextSubtable: 1209 /* Point to next subtable */ 1210 1211 Offset += SubTable->Length; 1212 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, 1213 SubTable->Length); 1214 } 1215 } 1216 1217 1218 /******************************************************************************* 1219 * 1220 * FUNCTION: AcpiDmDumpDrtm 1221 * 1222 * PARAMETERS: Table - A DRTM table 1223 * 1224 * RETURN: None 1225 * 1226 * DESCRIPTION: Format the contents of a DRTM. 1227 * 1228 ******************************************************************************/ 1229 1230 void 1231 AcpiDmDumpDrtm ( 1232 ACPI_TABLE_HEADER *Table) 1233 { 1234 ACPI_STATUS Status; 1235 UINT32 Offset; 1236 ACPI_DRTM_VTABLE_LIST *DrtmVtl; 1237 ACPI_DRTM_RESOURCE_LIST *DrtmRl; 1238 ACPI_DRTM_DPS_ID *DrtmDps; 1239 UINT32 Count; 1240 1241 1242 /* Main table */ 1243 1244 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 1245 AcpiDmTableInfoDrtm); 1246 if (ACPI_FAILURE (Status)) 1247 { 1248 return; 1249 } 1250 1251 Offset = sizeof (ACPI_TABLE_DRTM); 1252 1253 /* Sub-tables */ 1254 1255 /* Dump ValidatedTable length */ 1256 1257 DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset); 1258 AcpiOsPrintf ("\n"); 1259 Status = AcpiDmDumpTable (Table->Length, Offset, 1260 DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables), 1261 AcpiDmTableInfoDrtm0); 1262 if (ACPI_FAILURE (Status)) 1263 { 1264 return; 1265 } 1266 1267 Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables); 1268 1269 /* Dump Validated table addresses */ 1270 1271 Count = 0; 1272 while ((Offset < Table->Length) && 1273 (DrtmVtl->ValidatedTableCount > Count)) 1274 { 1275 Status = AcpiDmDumpTable (Table->Length, Offset, 1276 ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64), 1277 AcpiDmTableInfoDrtm0a); 1278 if (ACPI_FAILURE (Status)) 1279 { 1280 return; 1281 } 1282 1283 Offset += sizeof (UINT64); 1284 Count++; 1285 } 1286 1287 /* Dump ResourceList length */ 1288 1289 DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset); 1290 AcpiOsPrintf ("\n"); 1291 Status = AcpiDmDumpTable (Table->Length, Offset, 1292 DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources), 1293 AcpiDmTableInfoDrtm1); 1294 if (ACPI_FAILURE (Status)) 1295 { 1296 return; 1297 } 1298 1299 Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources); 1300 1301 /* Dump the Resource List */ 1302 1303 Count = 0; 1304 while ((Offset < Table->Length) && 1305 (DrtmRl->ResourceCount > Count)) 1306 { 1307 Status = AcpiDmDumpTable (Table->Length, Offset, 1308 ACPI_ADD_PTR (void, Table, Offset), 1309 sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a); 1310 if (ACPI_FAILURE (Status)) 1311 { 1312 return; 1313 } 1314 1315 Offset += sizeof (ACPI_DRTM_RESOURCE); 1316 Count++; 1317 } 1318 1319 /* Dump DPS */ 1320 1321 DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset); 1322 AcpiOsPrintf ("\n"); 1323 (void) AcpiDmDumpTable (Table->Length, Offset, 1324 DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2); 1325 } 1326 1327 1328 /******************************************************************************* 1329 * 1330 * FUNCTION: AcpiDmDumpEinj 1331 * 1332 * PARAMETERS: Table - A EINJ table 1333 * 1334 * RETURN: None 1335 * 1336 * DESCRIPTION: Format the contents of a EINJ. This table type consists 1337 * of an open-ended number of subtables. 1338 * 1339 ******************************************************************************/ 1340 1341 void 1342 AcpiDmDumpEinj ( 1343 ACPI_TABLE_HEADER *Table) 1344 { 1345 ACPI_STATUS Status; 1346 ACPI_WHEA_HEADER *SubTable; 1347 UINT32 Length = Table->Length; 1348 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 1349 1350 1351 /* Main table */ 1352 1353 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 1354 if (ACPI_FAILURE (Status)) 1355 { 1356 return; 1357 } 1358 1359 /* Subtables */ 1360 1361 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1362 while (Offset < Table->Length) 1363 { 1364 AcpiOsPrintf ("\n"); 1365 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1366 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 1367 if (ACPI_FAILURE (Status)) 1368 { 1369 return; 1370 } 1371 1372 /* Point to next subtable (each subtable is of fixed length) */ 1373 1374 Offset += sizeof (ACPI_WHEA_HEADER); 1375 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 1376 sizeof (ACPI_WHEA_HEADER)); 1377 } 1378 } 1379 1380 1381 /******************************************************************************* 1382 * 1383 * FUNCTION: AcpiDmDumpErst 1384 * 1385 * PARAMETERS: Table - A ERST table 1386 * 1387 * RETURN: None 1388 * 1389 * DESCRIPTION: Format the contents of a ERST. This table type consists 1390 * of an open-ended number of subtables. 1391 * 1392 ******************************************************************************/ 1393 1394 void 1395 AcpiDmDumpErst ( 1396 ACPI_TABLE_HEADER *Table) 1397 { 1398 ACPI_STATUS Status; 1399 ACPI_WHEA_HEADER *SubTable; 1400 UINT32 Length = Table->Length; 1401 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 1402 1403 1404 /* Main table */ 1405 1406 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 1407 if (ACPI_FAILURE (Status)) 1408 { 1409 return; 1410 } 1411 1412 /* Subtables */ 1413 1414 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1415 while (Offset < Table->Length) 1416 { 1417 AcpiOsPrintf ("\n"); 1418 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1419 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0); 1420 if (ACPI_FAILURE (Status)) 1421 { 1422 return; 1423 } 1424 1425 /* Point to next subtable (each subtable is of fixed length) */ 1426 1427 Offset += sizeof (ACPI_WHEA_HEADER); 1428 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 1429 sizeof (ACPI_WHEA_HEADER)); 1430 } 1431 } 1432 1433 1434 /******************************************************************************* 1435 * 1436 * FUNCTION: AcpiDmDumpFpdt 1437 * 1438 * PARAMETERS: Table - A FPDT table 1439 * 1440 * RETURN: None 1441 * 1442 * DESCRIPTION: Format the contents of a FPDT. This table type consists 1443 * of an open-ended number of subtables. 1444 * 1445 ******************************************************************************/ 1446 1447 void 1448 AcpiDmDumpFpdt ( 1449 ACPI_TABLE_HEADER *Table) 1450 { 1451 ACPI_STATUS Status; 1452 ACPI_FPDT_HEADER *SubTable; 1453 UINT32 Length = Table->Length; 1454 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 1455 ACPI_DMTABLE_INFO *InfoTable; 1456 1457 1458 /* There is no main table (other than the standard ACPI header) */ 1459 1460 /* Subtables */ 1461 1462 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); 1463 while (Offset < Table->Length) 1464 { 1465 /* Common subtable header */ 1466 1467 AcpiOsPrintf ("\n"); 1468 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1469 SubTable->Length, AcpiDmTableInfoFpdtHdr); 1470 if (ACPI_FAILURE (Status)) 1471 { 1472 return; 1473 } 1474 1475 switch (SubTable->Type) 1476 { 1477 case ACPI_FPDT_TYPE_BOOT: 1478 1479 InfoTable = AcpiDmTableInfoFpdt0; 1480 break; 1481 1482 case ACPI_FPDT_TYPE_S3PERF: 1483 1484 InfoTable = AcpiDmTableInfoFpdt1; 1485 break; 1486 1487 default: 1488 1489 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", 1490 SubTable->Type); 1491 1492 /* Attempt to continue */ 1493 1494 if (!SubTable->Length) 1495 { 1496 AcpiOsPrintf ("Invalid zero length subtable\n"); 1497 return; 1498 } 1499 goto NextSubTable; 1500 } 1501 1502 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1503 SubTable->Length, InfoTable); 1504 if (ACPI_FAILURE (Status)) 1505 { 1506 return; 1507 } 1508 1509 NextSubTable: 1510 /* Point to next subtable */ 1511 1512 Offset += SubTable->Length; 1513 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, 1514 SubTable->Length); 1515 } 1516 } 1517 1518 1519 /******************************************************************************* 1520 * 1521 * FUNCTION: AcpiDmDumpGtdt 1522 * 1523 * PARAMETERS: Table - A GTDT table 1524 * 1525 * RETURN: None 1526 * 1527 * DESCRIPTION: Format the contents of a GTDT. This table type consists 1528 * of an open-ended number of subtables. 1529 * 1530 ******************************************************************************/ 1531 1532 void 1533 AcpiDmDumpGtdt ( 1534 ACPI_TABLE_HEADER *Table) 1535 { 1536 ACPI_STATUS Status; 1537 ACPI_GTDT_HEADER *SubTable; 1538 UINT32 Length = Table->Length; 1539 UINT32 Offset = sizeof (ACPI_TABLE_GTDT); 1540 ACPI_DMTABLE_INFO *InfoTable; 1541 UINT32 SubTableLength; 1542 UINT32 GtCount; 1543 ACPI_GTDT_TIMER_ENTRY *GtxTable; 1544 1545 1546 /* Main table */ 1547 1548 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt); 1549 if (ACPI_FAILURE (Status)) 1550 { 1551 return; 1552 } 1553 1554 /* Subtables */ 1555 1556 SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 1557 while (Offset < Table->Length) 1558 { 1559 /* Common subtable header */ 1560 1561 AcpiOsPrintf ("\n"); 1562 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1563 SubTable->Length, AcpiDmTableInfoGtdtHdr); 1564 if (ACPI_FAILURE (Status)) 1565 { 1566 return; 1567 } 1568 1569 GtCount = 0; 1570 switch (SubTable->Type) 1571 { 1572 case ACPI_GTDT_TYPE_TIMER_BLOCK: 1573 1574 SubTableLength = sizeof (ACPI_GTDT_TIMER_BLOCK); 1575 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, 1576 SubTable))->TimerCount; 1577 1578 InfoTable = AcpiDmTableInfoGtdt0; 1579 break; 1580 1581 case ACPI_GTDT_TYPE_WATCHDOG: 1582 1583 SubTableLength = sizeof (ACPI_GTDT_WATCHDOG); 1584 1585 InfoTable = AcpiDmTableInfoGtdt1; 1586 break; 1587 1588 default: 1589 1590 /* Cannot continue on unknown type - no length */ 1591 1592 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n", 1593 SubTable->Type); 1594 return; 1595 } 1596 1597 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1598 SubTable->Length, InfoTable); 1599 if (ACPI_FAILURE (Status)) 1600 { 1601 return; 1602 } 1603 1604 /* Point to end of current subtable (each subtable above is of fixed length) */ 1605 1606 Offset += SubTableLength; 1607 1608 /* If there are any Gt Timer Blocks from above, dump them now */ 1609 1610 if (GtCount) 1611 { 1612 GtxTable = ACPI_ADD_PTR ( 1613 ACPI_GTDT_TIMER_ENTRY, SubTable, SubTableLength); 1614 SubTableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY); 1615 1616 while (GtCount) 1617 { 1618 AcpiOsPrintf ("\n"); 1619 Status = AcpiDmDumpTable (Length, Offset, GtxTable, 1620 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a); 1621 if (ACPI_FAILURE (Status)) 1622 { 1623 return; 1624 } 1625 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY); 1626 GtxTable++; 1627 GtCount--; 1628 } 1629 } 1630 1631 /* Point to next subtable */ 1632 1633 SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, SubTable, SubTableLength); 1634 } 1635 } 1636 1637 1638 /******************************************************************************* 1639 * 1640 * FUNCTION: AcpiDmDumpHest 1641 * 1642 * PARAMETERS: Table - A HEST table 1643 * 1644 * RETURN: None 1645 * 1646 * DESCRIPTION: Format the contents of a HEST. This table type consists 1647 * of an open-ended number of subtables. 1648 * 1649 ******************************************************************************/ 1650 1651 void 1652 AcpiDmDumpHest ( 1653 ACPI_TABLE_HEADER *Table) 1654 { 1655 ACPI_STATUS Status; 1656 ACPI_HEST_HEADER *SubTable; 1657 UINT32 Length = Table->Length; 1658 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 1659 ACPI_DMTABLE_INFO *InfoTable; 1660 UINT32 SubTableLength; 1661 UINT32 BankCount; 1662 ACPI_HEST_IA_ERROR_BANK *BankTable; 1663 1664 1665 /* Main table */ 1666 1667 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 1668 if (ACPI_FAILURE (Status)) 1669 { 1670 return; 1671 } 1672 1673 /* Subtables */ 1674 1675 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 1676 while (Offset < Table->Length) 1677 { 1678 BankCount = 0; 1679 switch (SubTable->Type) 1680 { 1681 case ACPI_HEST_TYPE_IA32_CHECK: 1682 1683 InfoTable = AcpiDmTableInfoHest0; 1684 SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK); 1685 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 1686 SubTable))->NumHardwareBanks; 1687 break; 1688 1689 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 1690 1691 InfoTable = AcpiDmTableInfoHest1; 1692 SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED); 1693 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 1694 SubTable))->NumHardwareBanks; 1695 break; 1696 1697 case ACPI_HEST_TYPE_IA32_NMI: 1698 1699 InfoTable = AcpiDmTableInfoHest2; 1700 SubTableLength = sizeof (ACPI_HEST_IA_NMI); 1701 break; 1702 1703 case ACPI_HEST_TYPE_AER_ROOT_PORT: 1704 1705 InfoTable = AcpiDmTableInfoHest6; 1706 SubTableLength = sizeof (ACPI_HEST_AER_ROOT); 1707 break; 1708 1709 case ACPI_HEST_TYPE_AER_ENDPOINT: 1710 1711 InfoTable = AcpiDmTableInfoHest7; 1712 SubTableLength = sizeof (ACPI_HEST_AER); 1713 break; 1714 1715 case ACPI_HEST_TYPE_AER_BRIDGE: 1716 1717 InfoTable = AcpiDmTableInfoHest8; 1718 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE); 1719 break; 1720 1721 case ACPI_HEST_TYPE_GENERIC_ERROR: 1722 1723 InfoTable = AcpiDmTableInfoHest9; 1724 SubTableLength = sizeof (ACPI_HEST_GENERIC); 1725 break; 1726 1727 case ACPI_HEST_TYPE_GENERIC_ERROR_V2: 1728 1729 InfoTable = AcpiDmTableInfoHest10; 1730 SubTableLength = sizeof (ACPI_HEST_GENERIC_V2); 1731 break; 1732 1733 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK: 1734 1735 InfoTable = AcpiDmTableInfoHest11; 1736 SubTableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK); 1737 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK, 1738 SubTable))->NumHardwareBanks; 1739 break; 1740 1741 default: 1742 1743 /* Cannot continue on unknown type - no length */ 1744 1745 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n", 1746 SubTable->Type); 1747 return; 1748 } 1749 1750 AcpiOsPrintf ("\n"); 1751 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1752 SubTableLength, InfoTable); 1753 if (ACPI_FAILURE (Status)) 1754 { 1755 return; 1756 } 1757 1758 /* Point to end of current subtable (each subtable above is of fixed length) */ 1759 1760 Offset += SubTableLength; 1761 1762 /* If there are any (fixed-length) Error Banks from above, dump them now */ 1763 1764 if (BankCount) 1765 { 1766 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, 1767 SubTableLength); 1768 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 1769 1770 while (BankCount) 1771 { 1772 AcpiOsPrintf ("\n"); 1773 Status = AcpiDmDumpTable (Length, Offset, BankTable, 1774 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 1775 if (ACPI_FAILURE (Status)) 1776 { 1777 return; 1778 } 1779 1780 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 1781 BankTable++; 1782 BankCount--; 1783 } 1784 } 1785 1786 /* Point to next subtable */ 1787 1788 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength); 1789 } 1790 } 1791 1792 1793 /******************************************************************************* 1794 * 1795 * FUNCTION: AcpiDmDumpHmat 1796 * 1797 * PARAMETERS: Table - A HMAT table 1798 * 1799 * RETURN: None 1800 * 1801 * DESCRIPTION: Format the contents of a HMAT. 1802 * 1803 ******************************************************************************/ 1804 1805 void 1806 AcpiDmDumpHmat ( 1807 ACPI_TABLE_HEADER *Table) 1808 { 1809 ACPI_STATUS Status; 1810 ACPI_HMAT_STRUCTURE *HmatStruct; 1811 ACPI_HMAT_LOCALITY *HmatLocality; 1812 ACPI_HMAT_CACHE *HmatCache; 1813 UINT32 Offset; 1814 UINT32 SubTableOffset; 1815 UINT32 Length; 1816 ACPI_DMTABLE_INFO *InfoTable; 1817 UINT32 i, j; 1818 1819 1820 /* Main table */ 1821 1822 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat); 1823 if (ACPI_FAILURE (Status)) 1824 { 1825 return; 1826 } 1827 Offset = sizeof (ACPI_TABLE_HMAT); 1828 1829 while (Offset < Table->Length) 1830 { 1831 AcpiOsPrintf ("\n"); 1832 SubTableOffset = 0; 1833 1834 /* Dump HMAT structure header */ 1835 1836 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset); 1837 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE)) 1838 { 1839 AcpiOsPrintf ("Invalid HMAT structure length\n"); 1840 return; 1841 } 1842 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 1843 HmatStruct->Length, AcpiDmTableInfoHmatHdr); 1844 if (ACPI_FAILURE (Status)) 1845 { 1846 return; 1847 } 1848 1849 switch (HmatStruct->Type) 1850 { 1851 case ACPI_HMAT_TYPE_ADDRESS_RANGE: 1852 1853 InfoTable = AcpiDmTableInfoHmat0; 1854 Length = sizeof (ACPI_HMAT_ADDRESS_RANGE); 1855 break; 1856 1857 case ACPI_HMAT_TYPE_LOCALITY: 1858 1859 InfoTable = AcpiDmTableInfoHmat1; 1860 Length = sizeof (ACPI_HMAT_LOCALITY); 1861 break; 1862 1863 case ACPI_HMAT_TYPE_CACHE: 1864 1865 InfoTable = AcpiDmTableInfoHmat2; 1866 Length = sizeof (ACPI_HMAT_CACHE); 1867 break; 1868 1869 default: 1870 1871 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n", 1872 HmatStruct->Type); 1873 1874 /* Attempt to continue */ 1875 1876 goto NextSubTable; 1877 } 1878 1879 /* Dump HMAT structure body */ 1880 1881 if (HmatStruct->Length < Length) 1882 { 1883 AcpiOsPrintf ("Invalid HMAT structure length\n"); 1884 return; 1885 } 1886 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 1887 HmatStruct->Length, InfoTable); 1888 if (ACPI_FAILURE (Status)) 1889 { 1890 return; 1891 } 1892 1893 /* Dump HMAT structure additionals */ 1894 1895 switch (HmatStruct->Type) 1896 { 1897 case ACPI_HMAT_TYPE_LOCALITY: 1898 1899 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct); 1900 SubTableOffset = sizeof (ACPI_HMAT_LOCALITY); 1901 1902 /* Dump initiator proximity domains */ 1903 1904 if ((UINT32)(HmatStruct->Length - SubTableOffset) < 1905 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4)) 1906 { 1907 AcpiOsPrintf ("Invalid initiator proximity domain number\n"); 1908 return; 1909 } 1910 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 1911 { 1912 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset, 1913 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset), 1914 4, AcpiDmTableInfoHmat1a); 1915 SubTableOffset += 4; 1916 } 1917 1918 /* Dump target proximity domains */ 1919 1920 if ((UINT32)(HmatStruct->Length - SubTableOffset) < 1921 (UINT32)(HmatLocality->NumberOfTargetPDs * 4)) 1922 { 1923 AcpiOsPrintf ("Invalid target proximity domain number\n"); 1924 return; 1925 } 1926 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++) 1927 { 1928 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset, 1929 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset), 1930 4, AcpiDmTableInfoHmat1b); 1931 SubTableOffset += 4; 1932 } 1933 1934 /* Dump latency/bandwidth entris */ 1935 1936 if ((UINT32)(HmatStruct->Length - SubTableOffset) < 1937 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 1938 HmatLocality->NumberOfTargetPDs * 2)) 1939 { 1940 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n"); 1941 return; 1942 } 1943 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 1944 { 1945 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++) 1946 { 1947 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset, 1948 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset), 1949 2, AcpiDmTableInfoHmat1c); 1950 SubTableOffset += 2; 1951 } 1952 } 1953 break; 1954 1955 case ACPI_HMAT_TYPE_CACHE: 1956 1957 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct); 1958 SubTableOffset = sizeof (ACPI_HMAT_CACHE); 1959 1960 /* Dump SMBIOS handles */ 1961 1962 if ((UINT32)(HmatStruct->Length - SubTableOffset) < 1963 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2)) 1964 { 1965 AcpiOsPrintf ("Invalid SMBIOS handle number\n"); 1966 return; 1967 } 1968 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++) 1969 { 1970 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset, 1971 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset), 1972 2, AcpiDmTableInfoHmat2a); 1973 SubTableOffset += 2; 1974 } 1975 break; 1976 1977 default: 1978 1979 break; 1980 } 1981 1982 NextSubTable: 1983 /* Point to next HMAT structure subtable */ 1984 1985 Offset += (HmatStruct->Length); 1986 } 1987 } 1988 1989 1990 /******************************************************************************* 1991 * 1992 * FUNCTION: AcpiDmDumpIort 1993 * 1994 * PARAMETERS: Table - A IORT table 1995 * 1996 * RETURN: None 1997 * 1998 * DESCRIPTION: Format the contents of a IORT 1999 * 2000 ******************************************************************************/ 2001 2002 void 2003 AcpiDmDumpIort ( 2004 ACPI_TABLE_HEADER *Table) 2005 { 2006 ACPI_STATUS Status; 2007 ACPI_TABLE_IORT *Iort; 2008 ACPI_IORT_NODE *IortNode; 2009 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL; 2010 ACPI_IORT_SMMU *IortSmmu = NULL; 2011 UINT32 Offset; 2012 UINT32 NodeOffset; 2013 UINT32 Length; 2014 ACPI_DMTABLE_INFO *InfoTable; 2015 char *String; 2016 UINT32 i; 2017 2018 2019 /* Main table */ 2020 2021 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort); 2022 if (ACPI_FAILURE (Status)) 2023 { 2024 return; 2025 } 2026 2027 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table); 2028 Offset = sizeof (ACPI_TABLE_IORT); 2029 2030 /* Dump the OptionalPadding (optional) */ 2031 2032 if (Iort->NodeOffset > Offset) 2033 { 2034 Status = AcpiDmDumpTable (Table->Length, Offset, Table, 2035 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad); 2036 if (ACPI_FAILURE (Status)) 2037 { 2038 return; 2039 } 2040 } 2041 2042 Offset = Iort->NodeOffset; 2043 while (Offset < Table->Length) 2044 { 2045 /* Common subtable header */ 2046 2047 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset); 2048 AcpiOsPrintf ("\n"); 2049 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData); 2050 Status = AcpiDmDumpTable (Table->Length, Offset, 2051 IortNode, Length, AcpiDmTableInfoIortHdr); 2052 if (ACPI_FAILURE (Status)) 2053 { 2054 return; 2055 } 2056 2057 NodeOffset = Length; 2058 2059 switch (IortNode->Type) 2060 { 2061 case ACPI_IORT_NODE_ITS_GROUP: 2062 2063 InfoTable = AcpiDmTableInfoIort0; 2064 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers); 2065 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset); 2066 break; 2067 2068 case ACPI_IORT_NODE_NAMED_COMPONENT: 2069 2070 InfoTable = AcpiDmTableInfoIort1; 2071 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName); 2072 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length); 2073 Length += strlen (String) + 1; 2074 break; 2075 2076 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX: 2077 2078 InfoTable = AcpiDmTableInfoIort2; 2079 Length = IortNode->Length - NodeOffset; 2080 break; 2081 2082 case ACPI_IORT_NODE_SMMU: 2083 2084 InfoTable = AcpiDmTableInfoIort3; 2085 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts); 2086 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset); 2087 break; 2088 2089 case ACPI_IORT_NODE_SMMU_V3: 2090 2091 InfoTable = AcpiDmTableInfoIort4; 2092 Length = IortNode->Length - NodeOffset; 2093 break; 2094 2095 default: 2096 2097 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n", 2098 IortNode->Type); 2099 2100 /* Attempt to continue */ 2101 2102 if (!IortNode->Length) 2103 { 2104 AcpiOsPrintf ("Invalid zero length IORT node\n"); 2105 return; 2106 } 2107 goto NextSubTable; 2108 } 2109 2110 /* Dump the node subtable header */ 2111 2112 AcpiOsPrintf ("\n"); 2113 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2114 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2115 Length, InfoTable); 2116 if (ACPI_FAILURE (Status)) 2117 { 2118 return; 2119 } 2120 2121 NodeOffset += Length; 2122 2123 /* Dump the node specific data */ 2124 2125 switch (IortNode->Type) 2126 { 2127 case ACPI_IORT_NODE_ITS_GROUP: 2128 2129 /* Validate IortItsGroup to avoid compiler warnings */ 2130 2131 if (IortItsGroup) 2132 { 2133 for (i = 0; i < IortItsGroup->ItsCount; i++) 2134 { 2135 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2136 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2137 4, AcpiDmTableInfoIort0a); 2138 NodeOffset += 4; 2139 } 2140 } 2141 break; 2142 2143 case ACPI_IORT_NODE_NAMED_COMPONENT: 2144 2145 /* Dump the Padding (optional) */ 2146 2147 if (IortNode->Length > NodeOffset) 2148 { 2149 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2150 Table, IortNode->Length - NodeOffset, 2151 AcpiDmTableInfoIort1a); 2152 if (ACPI_FAILURE (Status)) 2153 { 2154 return; 2155 } 2156 } 2157 break; 2158 2159 case ACPI_IORT_NODE_SMMU: 2160 2161 AcpiOsPrintf ("\n"); 2162 2163 /* Validate IortSmmu to avoid compiler warnings */ 2164 2165 if (IortSmmu) 2166 { 2167 Length = 2 * sizeof (UINT64); 2168 NodeOffset = IortSmmu->GlobalInterruptOffset; 2169 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2170 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2171 Length, AcpiDmTableInfoIort3a); 2172 if (ACPI_FAILURE (Status)) 2173 { 2174 return; 2175 } 2176 2177 NodeOffset = IortSmmu->ContextInterruptOffset; 2178 for (i = 0; i < IortSmmu->ContextInterruptCount; i++) 2179 { 2180 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2181 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2182 8, AcpiDmTableInfoIort3b); 2183 if (ACPI_FAILURE (Status)) 2184 { 2185 return; 2186 } 2187 2188 NodeOffset += 8; 2189 } 2190 2191 NodeOffset = IortSmmu->PmuInterruptOffset; 2192 for (i = 0; i < IortSmmu->PmuInterruptCount; i++) 2193 { 2194 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2195 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2196 8, AcpiDmTableInfoIort3c); 2197 if (ACPI_FAILURE (Status)) 2198 { 2199 return; 2200 } 2201 2202 NodeOffset += 8; 2203 } 2204 } 2205 break; 2206 2207 default: 2208 2209 break; 2210 } 2211 2212 /* Dump the ID mappings */ 2213 2214 NodeOffset = IortNode->MappingOffset; 2215 for (i = 0; i < IortNode->MappingCount; i++) 2216 { 2217 AcpiOsPrintf ("\n"); 2218 Length = sizeof (ACPI_IORT_ID_MAPPING); 2219 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2220 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2221 Length, AcpiDmTableInfoIortMap); 2222 if (ACPI_FAILURE (Status)) 2223 { 2224 return; 2225 } 2226 2227 NodeOffset += Length; 2228 } 2229 2230 NextSubTable: 2231 /* Point to next node subtable */ 2232 2233 Offset += IortNode->Length; 2234 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length); 2235 } 2236 } 2237 2238 2239 /******************************************************************************* 2240 * 2241 * FUNCTION: AcpiDmDumpIvrs 2242 * 2243 * PARAMETERS: Table - A IVRS table 2244 * 2245 * RETURN: None 2246 * 2247 * DESCRIPTION: Format the contents of a IVRS 2248 * 2249 ******************************************************************************/ 2250 2251 static UINT8 EntrySizes[] = {4,8,16,32}; 2252 2253 void 2254 AcpiDmDumpIvrs ( 2255 ACPI_TABLE_HEADER *Table) 2256 { 2257 ACPI_STATUS Status; 2258 UINT32 Offset = sizeof (ACPI_TABLE_IVRS); 2259 UINT32 EntryOffset; 2260 UINT32 EntryLength; 2261 UINT32 EntryType; 2262 ACPI_IVRS_DE_HEADER *DeviceEntry; 2263 ACPI_IVRS_HEADER *SubTable; 2264 ACPI_DMTABLE_INFO *InfoTable; 2265 2266 2267 /* Main table */ 2268 2269 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); 2270 if (ACPI_FAILURE (Status)) 2271 { 2272 return; 2273 } 2274 2275 /* Subtables */ 2276 2277 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); 2278 while (Offset < Table->Length) 2279 { 2280 /* Common subtable header */ 2281 2282 AcpiOsPrintf ("\n"); 2283 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2284 SubTable->Length, AcpiDmTableInfoIvrsHdr); 2285 if (ACPI_FAILURE (Status)) 2286 { 2287 return; 2288 } 2289 2290 switch (SubTable->Type) 2291 { 2292 case ACPI_IVRS_TYPE_HARDWARE: 2293 2294 InfoTable = AcpiDmTableInfoIvrs0; 2295 break; 2296 2297 case ACPI_IVRS_TYPE_MEMORY1: 2298 case ACPI_IVRS_TYPE_MEMORY2: 2299 case ACPI_IVRS_TYPE_MEMORY3: 2300 2301 InfoTable = AcpiDmTableInfoIvrs1; 2302 break; 2303 2304 default: 2305 2306 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n", 2307 SubTable->Type); 2308 2309 /* Attempt to continue */ 2310 2311 if (!SubTable->Length) 2312 { 2313 AcpiOsPrintf ("Invalid zero length subtable\n"); 2314 return; 2315 } 2316 goto NextSubTable; 2317 } 2318 2319 /* Dump the subtable */ 2320 2321 AcpiOsPrintf ("\n"); 2322 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2323 SubTable->Length, InfoTable); 2324 if (ACPI_FAILURE (Status)) 2325 { 2326 return; 2327 } 2328 2329 /* The hardware subtable can contain multiple device entries */ 2330 2331 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE) 2332 { 2333 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE); 2334 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable, 2335 sizeof (ACPI_IVRS_HARDWARE)); 2336 2337 while (EntryOffset < (Offset + SubTable->Length)) 2338 { 2339 AcpiOsPrintf ("\n"); 2340 /* 2341 * Upper 2 bits of Type encode the length of the device entry 2342 * 2343 * 00 = 4 byte 2344 * 01 = 8 byte 2345 * 10 = 16 byte - currently no entries defined 2346 * 11 = 32 byte - currently no entries defined 2347 */ 2348 EntryType = DeviceEntry->Type; 2349 EntryLength = EntrySizes [EntryType >> 6]; 2350 2351 switch (EntryType) 2352 { 2353 /* 4-byte device entries */ 2354 2355 case ACPI_IVRS_TYPE_PAD4: 2356 case ACPI_IVRS_TYPE_ALL: 2357 case ACPI_IVRS_TYPE_SELECT: 2358 case ACPI_IVRS_TYPE_START: 2359 case ACPI_IVRS_TYPE_END: 2360 2361 InfoTable = AcpiDmTableInfoIvrs4; 2362 break; 2363 2364 /* 8-byte entries, type A */ 2365 2366 case ACPI_IVRS_TYPE_ALIAS_SELECT: 2367 case ACPI_IVRS_TYPE_ALIAS_START: 2368 2369 InfoTable = AcpiDmTableInfoIvrs8a; 2370 break; 2371 2372 /* 8-byte entries, type B */ 2373 2374 case ACPI_IVRS_TYPE_PAD8: 2375 case ACPI_IVRS_TYPE_EXT_SELECT: 2376 case ACPI_IVRS_TYPE_EXT_START: 2377 2378 InfoTable = AcpiDmTableInfoIvrs8b; 2379 break; 2380 2381 /* 8-byte entries, type C */ 2382 2383 case ACPI_IVRS_TYPE_SPECIAL: 2384 2385 InfoTable = AcpiDmTableInfoIvrs8c; 2386 break; 2387 2388 default: 2389 InfoTable = AcpiDmTableInfoIvrs4; 2390 AcpiOsPrintf ( 2391 "\n**** Unknown IVRS device entry type/length: " 2392 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n", 2393 EntryType, EntryLength, EntryOffset); 2394 break; 2395 } 2396 2397 /* Dump the Device Entry */ 2398 2399 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 2400 DeviceEntry, EntryLength, InfoTable); 2401 if (ACPI_FAILURE (Status)) 2402 { 2403 return; 2404 } 2405 2406 EntryOffset += EntryLength; 2407 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry, 2408 EntryLength); 2409 } 2410 } 2411 2412 NextSubTable: 2413 /* Point to next subtable */ 2414 2415 Offset += SubTable->Length; 2416 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length); 2417 } 2418 } 2419 2420 2421 /******************************************************************************* 2422 * 2423 * FUNCTION: AcpiDmDumpLpit 2424 * 2425 * PARAMETERS: Table - A LPIT table 2426 * 2427 * RETURN: None 2428 * 2429 * DESCRIPTION: Format the contents of a LPIT. This table type consists 2430 * of an open-ended number of subtables. Note: There are no 2431 * entries in the main table. An LPIT consists of the table 2432 * header and then subtables only. 2433 * 2434 ******************************************************************************/ 2435 2436 void 2437 AcpiDmDumpLpit ( 2438 ACPI_TABLE_HEADER *Table) 2439 { 2440 ACPI_STATUS Status; 2441 ACPI_LPIT_HEADER *SubTable; 2442 UINT32 Length = Table->Length; 2443 UINT32 Offset = sizeof (ACPI_TABLE_LPIT); 2444 ACPI_DMTABLE_INFO *InfoTable; 2445 UINT32 SubTableLength; 2446 2447 2448 /* Subtables */ 2449 2450 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset); 2451 while (Offset < Table->Length) 2452 { 2453 /* Common subtable header */ 2454 2455 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2456 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr); 2457 if (ACPI_FAILURE (Status)) 2458 { 2459 return; 2460 } 2461 2462 switch (SubTable->Type) 2463 { 2464 case ACPI_LPIT_TYPE_NATIVE_CSTATE: 2465 2466 InfoTable = AcpiDmTableInfoLpit0; 2467 SubTableLength = sizeof (ACPI_LPIT_NATIVE); 2468 break; 2469 2470 default: 2471 2472 /* Cannot continue on unknown type - no length */ 2473 2474 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n", 2475 SubTable->Type); 2476 return; 2477 } 2478 2479 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2480 SubTableLength, InfoTable); 2481 if (ACPI_FAILURE (Status)) 2482 { 2483 return; 2484 } 2485 2486 AcpiOsPrintf ("\n"); 2487 2488 /* Point to next subtable */ 2489 2490 Offset += SubTableLength; 2491 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, SubTable, SubTableLength); 2492 } 2493 } 2494 2495 2496 /******************************************************************************* 2497 * 2498 * FUNCTION: AcpiDmDumpMadt 2499 * 2500 * PARAMETERS: Table - A MADT table 2501 * 2502 * RETURN: None 2503 * 2504 * DESCRIPTION: Format the contents of a MADT. This table type consists 2505 * of an open-ended number of subtables. 2506 * 2507 ******************************************************************************/ 2508 2509 void 2510 AcpiDmDumpMadt ( 2511 ACPI_TABLE_HEADER *Table) 2512 { 2513 ACPI_STATUS Status; 2514 ACPI_SUBTABLE_HEADER *SubTable; 2515 UINT32 Length = Table->Length; 2516 UINT32 Offset = sizeof (ACPI_TABLE_MADT); 2517 ACPI_DMTABLE_INFO *InfoTable; 2518 2519 2520 /* Main table */ 2521 2522 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); 2523 if (ACPI_FAILURE (Status)) 2524 { 2525 return; 2526 } 2527 2528 /* Subtables */ 2529 2530 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 2531 while (Offset < Table->Length) 2532 { 2533 /* Common subtable header */ 2534 2535 AcpiOsPrintf ("\n"); 2536 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2537 SubTable->Length, AcpiDmTableInfoMadtHdr); 2538 if (ACPI_FAILURE (Status)) 2539 { 2540 return; 2541 } 2542 2543 switch (SubTable->Type) 2544 { 2545 case ACPI_MADT_TYPE_LOCAL_APIC: 2546 2547 InfoTable = AcpiDmTableInfoMadt0; 2548 break; 2549 2550 case ACPI_MADT_TYPE_IO_APIC: 2551 2552 InfoTable = AcpiDmTableInfoMadt1; 2553 break; 2554 2555 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 2556 2557 InfoTable = AcpiDmTableInfoMadt2; 2558 break; 2559 2560 case ACPI_MADT_TYPE_NMI_SOURCE: 2561 2562 InfoTable = AcpiDmTableInfoMadt3; 2563 break; 2564 2565 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 2566 2567 InfoTable = AcpiDmTableInfoMadt4; 2568 break; 2569 2570 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 2571 2572 InfoTable = AcpiDmTableInfoMadt5; 2573 break; 2574 2575 case ACPI_MADT_TYPE_IO_SAPIC: 2576 2577 InfoTable = AcpiDmTableInfoMadt6; 2578 break; 2579 2580 case ACPI_MADT_TYPE_LOCAL_SAPIC: 2581 2582 InfoTable = AcpiDmTableInfoMadt7; 2583 break; 2584 2585 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 2586 2587 InfoTable = AcpiDmTableInfoMadt8; 2588 break; 2589 2590 case ACPI_MADT_TYPE_LOCAL_X2APIC: 2591 2592 InfoTable = AcpiDmTableInfoMadt9; 2593 break; 2594 2595 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 2596 2597 InfoTable = AcpiDmTableInfoMadt10; 2598 break; 2599 2600 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 2601 2602 InfoTable = AcpiDmTableInfoMadt11; 2603 break; 2604 2605 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 2606 2607 InfoTable = AcpiDmTableInfoMadt12; 2608 break; 2609 2610 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME: 2611 2612 InfoTable = AcpiDmTableInfoMadt13; 2613 break; 2614 2615 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR: 2616 2617 InfoTable = AcpiDmTableInfoMadt14; 2618 break; 2619 2620 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR: 2621 2622 InfoTable = AcpiDmTableInfoMadt15; 2623 break; 2624 2625 default: 2626 2627 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n", 2628 SubTable->Type); 2629 2630 /* Attempt to continue */ 2631 2632 if (!SubTable->Length) 2633 { 2634 AcpiOsPrintf ("Invalid zero length subtable\n"); 2635 return; 2636 } 2637 2638 goto NextSubTable; 2639 } 2640 2641 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2642 SubTable->Length, InfoTable); 2643 if (ACPI_FAILURE (Status)) 2644 { 2645 return; 2646 } 2647 2648 NextSubTable: 2649 /* Point to next subtable */ 2650 2651 Offset += SubTable->Length; 2652 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, 2653 SubTable->Length); 2654 } 2655 } 2656 2657 2658 /******************************************************************************* 2659 * 2660 * FUNCTION: AcpiDmDumpMcfg 2661 * 2662 * PARAMETERS: Table - A MCFG Table 2663 * 2664 * RETURN: None 2665 * 2666 * DESCRIPTION: Format the contents of a MCFG table 2667 * 2668 ******************************************************************************/ 2669 2670 void 2671 AcpiDmDumpMcfg ( 2672 ACPI_TABLE_HEADER *Table) 2673 { 2674 ACPI_STATUS Status; 2675 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 2676 ACPI_MCFG_ALLOCATION *SubTable; 2677 2678 2679 /* Main table */ 2680 2681 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 2682 if (ACPI_FAILURE (Status)) 2683 { 2684 return; 2685 } 2686 2687 /* Subtables */ 2688 2689 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 2690 while (Offset < Table->Length) 2691 { 2692 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 2693 { 2694 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", 2695 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 2696 return; 2697 } 2698 2699 AcpiOsPrintf ("\n"); 2700 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2701 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 2702 if (ACPI_FAILURE (Status)) 2703 { 2704 return; 2705 } 2706 2707 /* Point to next subtable (each subtable is of fixed length) */ 2708 2709 Offset += sizeof (ACPI_MCFG_ALLOCATION); 2710 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable, 2711 sizeof (ACPI_MCFG_ALLOCATION)); 2712 } 2713 } 2714 2715 2716 /******************************************************************************* 2717 * 2718 * FUNCTION: AcpiDmDumpMpst 2719 * 2720 * PARAMETERS: Table - A MPST Table 2721 * 2722 * RETURN: None 2723 * 2724 * DESCRIPTION: Format the contents of a MPST table 2725 * 2726 ******************************************************************************/ 2727 2728 void 2729 AcpiDmDumpMpst ( 2730 ACPI_TABLE_HEADER *Table) 2731 { 2732 ACPI_STATUS Status; 2733 UINT32 Offset = sizeof (ACPI_TABLE_MPST); 2734 ACPI_MPST_POWER_NODE *SubTable0; 2735 ACPI_MPST_POWER_STATE *SubTable0A; 2736 ACPI_MPST_COMPONENT *SubTable0B; 2737 ACPI_MPST_DATA_HDR *SubTable1; 2738 ACPI_MPST_POWER_DATA *SubTable2; 2739 UINT16 SubtableCount; 2740 UINT32 PowerStateCount; 2741 UINT32 ComponentCount; 2742 2743 2744 /* Main table */ 2745 2746 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); 2747 if (ACPI_FAILURE (Status)) 2748 { 2749 return; 2750 } 2751 2752 /* Subtable: Memory Power Node(s) */ 2753 2754 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; 2755 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); 2756 2757 while ((Offset < Table->Length) && SubtableCount) 2758 { 2759 AcpiOsPrintf ("\n"); 2760 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0, 2761 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); 2762 if (ACPI_FAILURE (Status)) 2763 { 2764 return; 2765 } 2766 2767 /* Extract the sub-subtable counts */ 2768 2769 PowerStateCount = SubTable0->NumPowerStates; 2770 ComponentCount = SubTable0->NumPhysicalComponents; 2771 Offset += sizeof (ACPI_MPST_POWER_NODE); 2772 2773 /* Sub-subtables - Memory Power State Structure(s) */ 2774 2775 SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0, 2776 sizeof (ACPI_MPST_POWER_NODE)); 2777 2778 while (PowerStateCount) 2779 { 2780 AcpiOsPrintf ("\n"); 2781 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A, 2782 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); 2783 if (ACPI_FAILURE (Status)) 2784 { 2785 return; 2786 } 2787 2788 SubTable0A++; 2789 PowerStateCount--; 2790 Offset += sizeof (ACPI_MPST_POWER_STATE); 2791 } 2792 2793 /* Sub-subtables - Physical Component ID Structure(s) */ 2794 2795 SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A); 2796 2797 if (ComponentCount) 2798 { 2799 AcpiOsPrintf ("\n"); 2800 } 2801 2802 while (ComponentCount) 2803 { 2804 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B, 2805 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); 2806 if (ACPI_FAILURE (Status)) 2807 { 2808 return; 2809 } 2810 2811 SubTable0B++; 2812 ComponentCount--; 2813 Offset += sizeof (ACPI_MPST_COMPONENT); 2814 } 2815 2816 /* Point to next Memory Power Node subtable */ 2817 2818 SubtableCount--; 2819 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0, 2820 sizeof (ACPI_MPST_POWER_NODE) + 2821 (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) + 2822 (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents)); 2823 } 2824 2825 /* Subtable: Count of Memory Power State Characteristic structures */ 2826 2827 AcpiOsPrintf ("\n"); 2828 SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0); 2829 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1, 2830 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); 2831 if (ACPI_FAILURE (Status)) 2832 { 2833 return; 2834 } 2835 2836 SubtableCount = SubTable1->CharacteristicsCount; 2837 Offset += sizeof (ACPI_MPST_DATA_HDR); 2838 2839 /* Subtable: Memory Power State Characteristics structure(s) */ 2840 2841 SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, 2842 sizeof (ACPI_MPST_DATA_HDR)); 2843 2844 while ((Offset < Table->Length) && SubtableCount) 2845 { 2846 AcpiOsPrintf ("\n"); 2847 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2, 2848 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); 2849 if (ACPI_FAILURE (Status)) 2850 { 2851 return; 2852 } 2853 2854 SubTable2++; 2855 SubtableCount--; 2856 Offset += sizeof (ACPI_MPST_POWER_DATA); 2857 } 2858 } 2859 2860 2861 /******************************************************************************* 2862 * 2863 * FUNCTION: AcpiDmDumpMsct 2864 * 2865 * PARAMETERS: Table - A MSCT table 2866 * 2867 * RETURN: None 2868 * 2869 * DESCRIPTION: Format the contents of a MSCT 2870 * 2871 ******************************************************************************/ 2872 2873 void 2874 AcpiDmDumpMsct ( 2875 ACPI_TABLE_HEADER *Table) 2876 { 2877 ACPI_STATUS Status; 2878 UINT32 Offset = sizeof (ACPI_TABLE_MSCT); 2879 ACPI_MSCT_PROXIMITY *SubTable; 2880 2881 2882 /* Main table */ 2883 2884 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); 2885 if (ACPI_FAILURE (Status)) 2886 { 2887 return; 2888 } 2889 2890 /* Subtables */ 2891 2892 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); 2893 while (Offset < Table->Length) 2894 { 2895 /* Common subtable header */ 2896 2897 AcpiOsPrintf ("\n"); 2898 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2899 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); 2900 if (ACPI_FAILURE (Status)) 2901 { 2902 return; 2903 } 2904 2905 /* Point to next subtable */ 2906 2907 Offset += sizeof (ACPI_MSCT_PROXIMITY); 2908 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, 2909 sizeof (ACPI_MSCT_PROXIMITY)); 2910 } 2911 } 2912 2913 2914 /******************************************************************************* 2915 * 2916 * FUNCTION: AcpiDmDumpMtmr 2917 * 2918 * PARAMETERS: Table - A MTMR table 2919 * 2920 * RETURN: None 2921 * 2922 * DESCRIPTION: Format the contents of a MTMR 2923 * 2924 ******************************************************************************/ 2925 2926 void 2927 AcpiDmDumpMtmr ( 2928 ACPI_TABLE_HEADER *Table) 2929 { 2930 ACPI_STATUS Status; 2931 UINT32 Offset = sizeof (ACPI_TABLE_MTMR); 2932 ACPI_MTMR_ENTRY *SubTable; 2933 2934 2935 /* Main table */ 2936 2937 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr); 2938 if (ACPI_FAILURE (Status)) 2939 { 2940 return; 2941 } 2942 2943 /* Subtables */ 2944 2945 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset); 2946 while (Offset < Table->Length) 2947 { 2948 /* Common subtable header */ 2949 2950 AcpiOsPrintf ("\n"); 2951 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2952 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0); 2953 if (ACPI_FAILURE (Status)) 2954 { 2955 return; 2956 } 2957 2958 /* Point to next subtable */ 2959 2960 Offset += sizeof (ACPI_MTMR_ENTRY); 2961 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable, 2962 sizeof (ACPI_MTMR_ENTRY)); 2963 } 2964 } 2965 2966 2967 /******************************************************************************* 2968 * 2969 * FUNCTION: AcpiDmDumpNfit 2970 * 2971 * PARAMETERS: Table - A NFIT table 2972 * 2973 * RETURN: None 2974 * 2975 * DESCRIPTION: Format the contents of an NFIT. 2976 * 2977 ******************************************************************************/ 2978 2979 void 2980 AcpiDmDumpNfit ( 2981 ACPI_TABLE_HEADER *Table) 2982 { 2983 ACPI_STATUS Status; 2984 UINT32 Offset = sizeof (ACPI_TABLE_NFIT); 2985 UINT32 FieldOffset = 0; 2986 UINT32 Length; 2987 ACPI_NFIT_HEADER *SubTable; 2988 ACPI_DMTABLE_INFO *InfoTable; 2989 ACPI_NFIT_INTERLEAVE *Interleave = NULL; 2990 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL; 2991 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; 2992 UINT32 i; 2993 2994 2995 /* Main table */ 2996 2997 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit); 2998 if (ACPI_FAILURE (Status)) 2999 { 3000 return; 3001 } 3002 3003 /* Subtables */ 3004 3005 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset); 3006 while (Offset < Table->Length) 3007 { 3008 /* NFIT subtable header */ 3009 3010 AcpiOsPrintf ("\n"); 3011 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3012 SubTable->Length, AcpiDmTableInfoNfitHdr); 3013 if (ACPI_FAILURE (Status)) 3014 { 3015 return; 3016 } 3017 3018 switch (SubTable->Type) 3019 { 3020 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: 3021 3022 InfoTable = AcpiDmTableInfoNfit0; 3023 break; 3024 3025 case ACPI_NFIT_TYPE_MEMORY_MAP: 3026 3027 InfoTable = AcpiDmTableInfoNfit1; 3028 break; 3029 3030 case ACPI_NFIT_TYPE_INTERLEAVE: 3031 3032 /* Has a variable number of 32-bit values at the end */ 3033 3034 InfoTable = AcpiDmTableInfoNfit2; 3035 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, SubTable); 3036 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE); 3037 break; 3038 3039 case ACPI_NFIT_TYPE_SMBIOS: 3040 3041 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, SubTable); 3042 InfoTable = AcpiDmTableInfoNfit3; 3043 break; 3044 3045 case ACPI_NFIT_TYPE_CONTROL_REGION: 3046 3047 InfoTable = AcpiDmTableInfoNfit4; 3048 break; 3049 3050 case ACPI_NFIT_TYPE_DATA_REGION: 3051 3052 InfoTable = AcpiDmTableInfoNfit5; 3053 break; 3054 3055 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 3056 3057 /* Has a variable number of 64-bit addresses at the end */ 3058 3059 InfoTable = AcpiDmTableInfoNfit6; 3060 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, SubTable); 3061 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64); 3062 break; 3063 3064 default: 3065 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n", 3066 SubTable->Type); 3067 3068 /* Attempt to continue */ 3069 3070 if (!SubTable->Length) 3071 { 3072 AcpiOsPrintf ("Invalid zero length subtable\n"); 3073 return; 3074 } 3075 goto NextSubTable; 3076 } 3077 3078 AcpiOsPrintf ("\n"); 3079 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3080 SubTable->Length, InfoTable); 3081 if (ACPI_FAILURE (Status)) 3082 { 3083 return; 3084 } 3085 3086 /* Per-subtable variable-length fields */ 3087 3088 switch (SubTable->Type) 3089 { 3090 case ACPI_NFIT_TYPE_INTERLEAVE: 3091 3092 for (i = 0; i < Interleave->LineCount; i++) 3093 { 3094 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 3095 &Interleave->LineOffset[i], 3096 sizeof (UINT32), AcpiDmTableInfoNfit2a); 3097 if (ACPI_FAILURE (Status)) 3098 { 3099 return; 3100 } 3101 3102 FieldOffset += sizeof (UINT32); 3103 } 3104 break; 3105 3106 case ACPI_NFIT_TYPE_SMBIOS: 3107 3108 Length = SubTable->Length - 3109 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8); 3110 3111 if (Length) 3112 { 3113 Status = AcpiDmDumpTable (Table->Length, 3114 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8), 3115 SmbiosInfo, 3116 Length, AcpiDmTableInfoNfit3a); 3117 if (ACPI_FAILURE (Status)) 3118 { 3119 return; 3120 } 3121 } 3122 3123 break; 3124 3125 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 3126 3127 for (i = 0; i < Hint->HintCount; i++) 3128 { 3129 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 3130 &Hint->HintAddress[i], 3131 sizeof (UINT64), AcpiDmTableInfoNfit6a); 3132 if (ACPI_FAILURE (Status)) 3133 { 3134 return; 3135 } 3136 3137 FieldOffset += sizeof (UINT64); 3138 } 3139 break; 3140 3141 default: 3142 break; 3143 } 3144 3145 NextSubTable: 3146 /* Point to next subtable */ 3147 3148 Offset += SubTable->Length; 3149 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubTable->Length); 3150 } 3151 } 3152 3153 3154 /******************************************************************************* 3155 * 3156 * FUNCTION: AcpiDmDumpPcct 3157 * 3158 * PARAMETERS: Table - A PCCT table 3159 * 3160 * RETURN: None 3161 * 3162 * DESCRIPTION: Format the contents of a PCCT. This table type consists 3163 * of an open-ended number of subtables. 3164 * 3165 ******************************************************************************/ 3166 3167 void 3168 AcpiDmDumpPcct ( 3169 ACPI_TABLE_HEADER *Table) 3170 { 3171 ACPI_STATUS Status; 3172 ACPI_PCCT_SUBSPACE *SubTable; 3173 ACPI_DMTABLE_INFO *InfoTable; 3174 UINT32 Length = Table->Length; 3175 UINT32 Offset = sizeof (ACPI_TABLE_PCCT); 3176 3177 3178 /* Main table */ 3179 3180 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); 3181 if (ACPI_FAILURE (Status)) 3182 { 3183 return; 3184 } 3185 3186 /* Subtables */ 3187 3188 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); 3189 while (Offset < Table->Length) 3190 { 3191 /* Common subtable header */ 3192 3193 AcpiOsPrintf ("\n"); 3194 Status = AcpiDmDumpTable (Length, Offset, SubTable, 3195 SubTable->Header.Length, AcpiDmTableInfoPcctHdr); 3196 if (ACPI_FAILURE (Status)) 3197 { 3198 return; 3199 } 3200 3201 switch (SubTable->Header.Type) 3202 { 3203 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: 3204 3205 InfoTable = AcpiDmTableInfoPcct0; 3206 break; 3207 3208 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: 3209 3210 InfoTable = AcpiDmTableInfoPcct1; 3211 break; 3212 3213 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2: 3214 3215 InfoTable = AcpiDmTableInfoPcct2; 3216 break; 3217 3218 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE: 3219 3220 InfoTable = AcpiDmTableInfoPcct3; 3221 break; 3222 3223 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE: 3224 3225 InfoTable = AcpiDmTableInfoPcct4; 3226 break; 3227 3228 default: 3229 3230 AcpiOsPrintf ( 3231 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n", 3232 SubTable->Header.Type); 3233 return; 3234 } 3235 3236 AcpiOsPrintf ("\n"); 3237 Status = AcpiDmDumpTable (Length, Offset, SubTable, 3238 SubTable->Header.Length, InfoTable); 3239 if (ACPI_FAILURE (Status)) 3240 { 3241 return; 3242 } 3243 3244 /* Point to next subtable */ 3245 3246 Offset += SubTable->Header.Length; 3247 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable, 3248 SubTable->Header.Length); 3249 } 3250 } 3251 3252 3253 /******************************************************************************* 3254 * 3255 * FUNCTION: AcpiDmDumpPmtt 3256 * 3257 * PARAMETERS: Table - A PMTT table 3258 * 3259 * RETURN: None 3260 * 3261 * DESCRIPTION: Format the contents of a PMTT. This table type consists 3262 * of an open-ended number of subtables. 3263 * 3264 ******************************************************************************/ 3265 3266 void 3267 AcpiDmDumpPmtt ( 3268 ACPI_TABLE_HEADER *Table) 3269 { 3270 ACPI_STATUS Status; 3271 ACPI_PMTT_HEADER *SubTable; 3272 ACPI_PMTT_HEADER *MemSubTable; 3273 ACPI_PMTT_HEADER *DimmSubTable; 3274 ACPI_PMTT_DOMAIN *DomainArray; 3275 UINT32 Length = Table->Length; 3276 UINT32 Offset = sizeof (ACPI_TABLE_PMTT); 3277 UINT32 MemOffset; 3278 UINT32 DimmOffset; 3279 UINT32 DomainOffset; 3280 UINT32 DomainCount; 3281 3282 3283 /* Main table */ 3284 3285 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); 3286 if (ACPI_FAILURE (Status)) 3287 { 3288 return; 3289 } 3290 3291 /* Subtables */ 3292 3293 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); 3294 while (Offset < Table->Length) 3295 { 3296 /* Common subtable header */ 3297 3298 AcpiOsPrintf ("\n"); 3299 Status = AcpiDmDumpTable (Length, Offset, SubTable, 3300 SubTable->Length, AcpiDmTableInfoPmttHdr); 3301 if (ACPI_FAILURE (Status)) 3302 { 3303 return; 3304 } 3305 3306 /* Only Socket subtables are expected at this level */ 3307 3308 if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET) 3309 { 3310 AcpiOsPrintf ( 3311 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 3312 SubTable->Type); 3313 return; 3314 } 3315 3316 /* Dump the fixed-length portion of the subtable */ 3317 3318 Status = AcpiDmDumpTable (Length, Offset, SubTable, 3319 SubTable->Length, AcpiDmTableInfoPmtt0); 3320 if (ACPI_FAILURE (Status)) 3321 { 3322 return; 3323 } 3324 3325 /* Walk the memory controller subtables */ 3326 3327 MemOffset = sizeof (ACPI_PMTT_SOCKET); 3328 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, 3329 sizeof (ACPI_PMTT_SOCKET)); 3330 3331 while (((Offset + MemOffset) < Table->Length) && 3332 (MemOffset < SubTable->Length)) 3333 { 3334 /* Common subtable header */ 3335 3336 AcpiOsPrintf ("\n"); 3337 Status = AcpiDmDumpTable (Length, 3338 Offset + MemOffset, MemSubTable, 3339 MemSubTable->Length, AcpiDmTableInfoPmttHdr); 3340 if (ACPI_FAILURE (Status)) 3341 { 3342 return; 3343 } 3344 3345 /* Only memory controller subtables are expected at this level */ 3346 3347 if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER) 3348 { 3349 AcpiOsPrintf ( 3350 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 3351 MemSubTable->Type); 3352 return; 3353 } 3354 3355 /* Dump the fixed-length portion of the controller subtable */ 3356 3357 Status = AcpiDmDumpTable (Length, 3358 Offset + MemOffset, MemSubTable, 3359 MemSubTable->Length, AcpiDmTableInfoPmtt1); 3360 if (ACPI_FAILURE (Status)) 3361 { 3362 return; 3363 } 3364 3365 /* Walk the variable count of proximity domains */ 3366 3367 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount; 3368 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER); 3369 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable, 3370 sizeof (ACPI_PMTT_CONTROLLER)); 3371 3372 while (((Offset + MemOffset + DomainOffset) < Table->Length) && 3373 ((MemOffset + DomainOffset) < SubTable->Length) && 3374 DomainCount) 3375 { 3376 Status = AcpiDmDumpTable (Length, 3377 Offset + MemOffset + DomainOffset, DomainArray, 3378 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a); 3379 if (ACPI_FAILURE (Status)) 3380 { 3381 return; 3382 } 3383 3384 DomainOffset += sizeof (ACPI_PMTT_DOMAIN); 3385 DomainArray++; 3386 DomainCount--; 3387 } 3388 3389 if (DomainCount) 3390 { 3391 AcpiOsPrintf ( 3392 "\n**** DomainCount exceeds subtable length\n\n"); 3393 } 3394 3395 /* Walk the physical component (DIMM) subtables */ 3396 3397 DimmOffset = DomainOffset; 3398 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable, 3399 DomainOffset); 3400 3401 while (((Offset + MemOffset + DimmOffset) < Table->Length) && 3402 (DimmOffset < MemSubTable->Length)) 3403 { 3404 /* Common subtable header */ 3405 3406 AcpiOsPrintf ("\n"); 3407 Status = AcpiDmDumpTable (Length, 3408 Offset + MemOffset + DimmOffset, DimmSubTable, 3409 DimmSubTable->Length, AcpiDmTableInfoPmttHdr); 3410 if (ACPI_FAILURE (Status)) 3411 { 3412 return; 3413 } 3414 3415 /* Only DIMM subtables are expected at this level */ 3416 3417 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM) 3418 { 3419 AcpiOsPrintf ( 3420 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 3421 DimmSubTable->Type); 3422 return; 3423 } 3424 3425 /* Dump the fixed-length DIMM subtable */ 3426 3427 Status = AcpiDmDumpTable (Length, 3428 Offset + MemOffset + DimmOffset, DimmSubTable, 3429 DimmSubTable->Length, AcpiDmTableInfoPmtt2); 3430 if (ACPI_FAILURE (Status)) 3431 { 3432 return; 3433 } 3434 3435 /* Point to next DIMM subtable */ 3436 3437 DimmOffset += DimmSubTable->Length; 3438 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 3439 DimmSubTable, DimmSubTable->Length); 3440 } 3441 3442 /* Point to next Controller subtable */ 3443 3444 MemOffset += MemSubTable->Length; 3445 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 3446 MemSubTable, MemSubTable->Length); 3447 } 3448 3449 /* Point to next Socket subtable */ 3450 3451 Offset += SubTable->Length; 3452 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 3453 SubTable, SubTable->Length); 3454 } 3455 } 3456 3457 3458 /******************************************************************************* 3459 * 3460 * FUNCTION: AcpiDmDumpPptt 3461 * 3462 * PARAMETERS: Table - A PMTT table 3463 * 3464 * RETURN: None 3465 * 3466 * DESCRIPTION: Format the contents of a PPTT. This table type consists 3467 * of an open-ended number of subtables. 3468 * 3469 ******************************************************************************/ 3470 3471 void 3472 AcpiDmDumpPptt ( 3473 ACPI_TABLE_HEADER *Table) 3474 { 3475 ACPI_STATUS Status; 3476 ACPI_SUBTABLE_HEADER *SubTable; 3477 ACPI_PPTT_PROCESSOR *PpttProcessor; 3478 UINT8 Length; 3479 UINT8 SubTableOffset; 3480 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 3481 ACPI_DMTABLE_INFO *InfoTable; 3482 UINT32 i; 3483 3484 3485 /* There is no main table (other than the standard ACPI header) */ 3486 3487 /* Subtables */ 3488 3489 Offset = sizeof (ACPI_TABLE_HEADER); 3490 while (Offset < Table->Length) 3491 { 3492 AcpiOsPrintf ("\n"); 3493 3494 /* Common subtable header */ 3495 3496 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 3497 if (SubTable->Length < sizeof (ACPI_SUBTABLE_HEADER)) 3498 { 3499 AcpiOsPrintf ("Invalid subtable length\n"); 3500 return; 3501 } 3502 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3503 SubTable->Length, AcpiDmTableInfoPpttHdr); 3504 if (ACPI_FAILURE (Status)) 3505 { 3506 return; 3507 } 3508 3509 switch (SubTable->Type) 3510 { 3511 case ACPI_PPTT_TYPE_PROCESSOR: 3512 3513 InfoTable = AcpiDmTableInfoPptt0; 3514 Length = sizeof (ACPI_PPTT_PROCESSOR); 3515 break; 3516 3517 case ACPI_PPTT_TYPE_CACHE: 3518 3519 InfoTable = AcpiDmTableInfoPptt1; 3520 Length = sizeof (ACPI_PPTT_CACHE); 3521 break; 3522 3523 case ACPI_PPTT_TYPE_ID: 3524 3525 InfoTable = AcpiDmTableInfoPptt2; 3526 Length = sizeof (ACPI_PPTT_ID); 3527 break; 3528 3529 default: 3530 3531 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n", 3532 SubTable->Type); 3533 3534 /* Attempt to continue */ 3535 3536 goto NextSubTable; 3537 } 3538 3539 if (SubTable->Length < Length) 3540 { 3541 AcpiOsPrintf ("Invalid subtable length\n"); 3542 return; 3543 } 3544 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3545 SubTable->Length, InfoTable); 3546 if (ACPI_FAILURE (Status)) 3547 { 3548 return; 3549 } 3550 SubTableOffset = Length; 3551 3552 switch (SubTable->Type) 3553 { 3554 case ACPI_PPTT_TYPE_PROCESSOR: 3555 3556 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, SubTable); 3557 3558 /* Dump SMBIOS handles */ 3559 3560 if ((UINT8)(SubTable->Length - SubTableOffset) < 3561 (UINT8)(PpttProcessor->NumberOfPrivResources * 4)) 3562 { 3563 AcpiOsPrintf ("Invalid private resource number\n"); 3564 return; 3565 } 3566 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++) 3567 { 3568 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset, 3569 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTableOffset), 3570 4, AcpiDmTableInfoPptt0a); 3571 SubTableOffset += 4; 3572 } 3573 break; 3574 3575 default: 3576 3577 break; 3578 } 3579 3580 NextSubTable: 3581 /* Point to next subtable */ 3582 3583 Offset += SubTable->Length; 3584 } 3585 } 3586 3587 3588 /******************************************************************************* 3589 * 3590 * FUNCTION: AcpiDmDumpS3pt 3591 * 3592 * PARAMETERS: Table - A S3PT table 3593 * 3594 * RETURN: Length of the table 3595 * 3596 * DESCRIPTION: Format the contents of a S3PT 3597 * 3598 ******************************************************************************/ 3599 3600 UINT32 3601 AcpiDmDumpS3pt ( 3602 ACPI_TABLE_HEADER *Tables) 3603 { 3604 ACPI_STATUS Status; 3605 UINT32 Offset = sizeof (ACPI_TABLE_S3PT); 3606 ACPI_FPDT_HEADER *SubTable; 3607 ACPI_DMTABLE_INFO *InfoTable; 3608 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); 3609 3610 3611 /* Main table */ 3612 3613 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt); 3614 if (ACPI_FAILURE (Status)) 3615 { 3616 return 0; 3617 } 3618 3619 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset); 3620 while (Offset < S3ptTable->Length) 3621 { 3622 /* Common subtable header */ 3623 3624 AcpiOsPrintf ("\n"); 3625 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 3626 SubTable->Length, AcpiDmTableInfoS3ptHdr); 3627 if (ACPI_FAILURE (Status)) 3628 { 3629 return 0; 3630 } 3631 3632 switch (SubTable->Type) 3633 { 3634 case ACPI_S3PT_TYPE_RESUME: 3635 3636 InfoTable = AcpiDmTableInfoS3pt0; 3637 break; 3638 3639 case ACPI_S3PT_TYPE_SUSPEND: 3640 3641 InfoTable = AcpiDmTableInfoS3pt1; 3642 break; 3643 3644 default: 3645 3646 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", 3647 SubTable->Type); 3648 3649 /* Attempt to continue */ 3650 3651 if (!SubTable->Length) 3652 { 3653 AcpiOsPrintf ("Invalid zero length subtable\n"); 3654 return 0; 3655 } 3656 goto NextSubTable; 3657 } 3658 3659 AcpiOsPrintf ("\n"); 3660 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 3661 SubTable->Length, InfoTable); 3662 if (ACPI_FAILURE (Status)) 3663 { 3664 return 0; 3665 } 3666 3667 NextSubTable: 3668 /* Point to next subtable */ 3669 3670 Offset += SubTable->Length; 3671 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length); 3672 } 3673 3674 return (S3ptTable->Length); 3675 } 3676 3677 3678 /******************************************************************************* 3679 * 3680 * FUNCTION: AcpiDmDumpSlic 3681 * 3682 * PARAMETERS: Table - A SLIC table 3683 * 3684 * RETURN: None 3685 * 3686 * DESCRIPTION: Format the contents of a SLIC 3687 * 3688 ******************************************************************************/ 3689 3690 void 3691 AcpiDmDumpSlic ( 3692 ACPI_TABLE_HEADER *Table) 3693 { 3694 3695 (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table, 3696 Table->Length - sizeof (*Table), AcpiDmTableInfoSlic); 3697 } 3698 3699 3700 /******************************************************************************* 3701 * 3702 * FUNCTION: AcpiDmDumpSlit 3703 * 3704 * PARAMETERS: Table - An SLIT 3705 * 3706 * RETURN: None 3707 * 3708 * DESCRIPTION: Format the contents of a SLIT 3709 * 3710 ******************************************************************************/ 3711 3712 void 3713 AcpiDmDumpSlit ( 3714 ACPI_TABLE_HEADER *Table) 3715 { 3716 ACPI_STATUS Status; 3717 UINT32 Offset; 3718 UINT8 *Row; 3719 UINT32 Localities; 3720 UINT32 i; 3721 UINT32 j; 3722 3723 3724 /* Main table */ 3725 3726 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit); 3727 if (ACPI_FAILURE (Status)) 3728 { 3729 return; 3730 } 3731 3732 /* Display the Locality NxN Matrix */ 3733 3734 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; 3735 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]); 3736 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry; 3737 3738 for (i = 0; i < Localities; i++) 3739 { 3740 /* Display one row of the matrix */ 3741 3742 AcpiDmLineHeader2 (Offset, Localities, "Locality", i); 3743 for (j = 0; j < Localities; j++) 3744 { 3745 /* Check for beyond EOT */ 3746 3747 if (Offset >= Table->Length) 3748 { 3749 AcpiOsPrintf ( 3750 "\n**** Not enough room in table for all localities\n"); 3751 return; 3752 } 3753 3754 AcpiOsPrintf ("%2.2X", Row[j]); 3755 Offset++; 3756 3757 /* Display up to 16 bytes per output row */ 3758 3759 if ((j+1) < Localities) 3760 { 3761 AcpiOsPrintf (" "); 3762 3763 if (j && (((j+1) % 16) == 0)) 3764 { 3765 AcpiOsPrintf ("\\\n"); /* With line continuation char */ 3766 AcpiDmLineHeader (Offset, 0, NULL); 3767 } 3768 } 3769 } 3770 3771 /* Point to next row */ 3772 3773 AcpiOsPrintf ("\n"); 3774 Row += Localities; 3775 } 3776 } 3777 3778 3779 /******************************************************************************* 3780 * 3781 * FUNCTION: AcpiDmDumpSrat 3782 * 3783 * PARAMETERS: Table - A SRAT table 3784 * 3785 * RETURN: None 3786 * 3787 * DESCRIPTION: Format the contents of a SRAT 3788 * 3789 ******************************************************************************/ 3790 3791 void 3792 AcpiDmDumpSrat ( 3793 ACPI_TABLE_HEADER *Table) 3794 { 3795 ACPI_STATUS Status; 3796 UINT32 Offset = sizeof (ACPI_TABLE_SRAT); 3797 ACPI_SUBTABLE_HEADER *SubTable; 3798 ACPI_DMTABLE_INFO *InfoTable; 3799 3800 3801 /* Main table */ 3802 3803 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat); 3804 if (ACPI_FAILURE (Status)) 3805 { 3806 return; 3807 } 3808 3809 /* Subtables */ 3810 3811 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 3812 while (Offset < Table->Length) 3813 { 3814 /* Common subtable header */ 3815 3816 AcpiOsPrintf ("\n"); 3817 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3818 SubTable->Length, AcpiDmTableInfoSratHdr); 3819 if (ACPI_FAILURE (Status)) 3820 { 3821 return; 3822 } 3823 3824 switch (SubTable->Type) 3825 { 3826 case ACPI_SRAT_TYPE_CPU_AFFINITY: 3827 3828 InfoTable = AcpiDmTableInfoSrat0; 3829 break; 3830 3831 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 3832 3833 InfoTable = AcpiDmTableInfoSrat1; 3834 break; 3835 3836 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 3837 3838 InfoTable = AcpiDmTableInfoSrat2; 3839 break; 3840 3841 case ACPI_SRAT_TYPE_GICC_AFFINITY: 3842 3843 InfoTable = AcpiDmTableInfoSrat3; 3844 break; 3845 3846 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY: 3847 3848 InfoTable = AcpiDmTableInfoSrat4; 3849 break; 3850 3851 default: 3852 AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n", 3853 SubTable->Type); 3854 3855 /* Attempt to continue */ 3856 3857 if (!SubTable->Length) 3858 { 3859 AcpiOsPrintf ("Invalid zero length subtable\n"); 3860 return; 3861 } 3862 goto NextSubTable; 3863 } 3864 3865 AcpiOsPrintf ("\n"); 3866 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3867 SubTable->Length, InfoTable); 3868 if (ACPI_FAILURE (Status)) 3869 { 3870 return; 3871 } 3872 3873 NextSubTable: 3874 /* Point to next subtable */ 3875 3876 Offset += SubTable->Length; 3877 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, 3878 SubTable->Length); 3879 } 3880 } 3881 3882 3883 /******************************************************************************* 3884 * 3885 * FUNCTION: AcpiDmDumpStao 3886 * 3887 * PARAMETERS: Table - A STAO table 3888 * 3889 * RETURN: None 3890 * 3891 * DESCRIPTION: Format the contents of a STAO. This is a variable-length 3892 * table that contains an open-ended number of ASCII strings 3893 * at the end of the table. 3894 * 3895 ******************************************************************************/ 3896 3897 void 3898 AcpiDmDumpStao ( 3899 ACPI_TABLE_HEADER *Table) 3900 { 3901 ACPI_STATUS Status; 3902 char *Namepath; 3903 UINT32 Length = Table->Length; 3904 UINT32 StringLength; 3905 UINT32 Offset = sizeof (ACPI_TABLE_STAO); 3906 3907 3908 /* Main table */ 3909 3910 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoStao); 3911 if (ACPI_FAILURE (Status)) 3912 { 3913 return; 3914 } 3915 3916 /* The rest of the table consists of Namepath strings */ 3917 3918 while (Offset < Table->Length) 3919 { 3920 Namepath = ACPI_ADD_PTR (char, Table, Offset); 3921 StringLength = strlen (Namepath) + 1; 3922 3923 AcpiDmLineHeader (Offset, StringLength, "Namestring"); 3924 AcpiOsPrintf ("\"%s\"\n", Namepath); 3925 3926 /* Point to next namepath */ 3927 3928 Offset += StringLength; 3929 } 3930 } 3931 3932 3933 /******************************************************************************* 3934 * 3935 * FUNCTION: AcpiDmDumpTcpa 3936 * 3937 * PARAMETERS: Table - A TCPA table 3938 * 3939 * RETURN: None 3940 * 3941 * DESCRIPTION: Format the contents of a TCPA. 3942 * 3943 * NOTE: There are two versions of the table with the same signature: 3944 * the client version and the server version. The common 3945 * PlatformClass field is used to differentiate the two types of 3946 * tables. 3947 * 3948 ******************************************************************************/ 3949 3950 void 3951 AcpiDmDumpTcpa ( 3952 ACPI_TABLE_HEADER *Table) 3953 { 3954 UINT32 Offset = sizeof (ACPI_TABLE_TCPA_HDR); 3955 ACPI_TABLE_TCPA_HDR *CommonHeader = ACPI_CAST_PTR ( 3956 ACPI_TABLE_TCPA_HDR, Table); 3957 ACPI_TABLE_TCPA_HDR *SubTable = ACPI_ADD_PTR ( 3958 ACPI_TABLE_TCPA_HDR, Table, Offset); 3959 ACPI_STATUS Status; 3960 3961 3962 /* Main table */ 3963 3964 Status = AcpiDmDumpTable (Table->Length, 0, Table, 3965 0, AcpiDmTableInfoTcpaHdr); 3966 if (ACPI_FAILURE (Status)) 3967 { 3968 return; 3969 } 3970 3971 /* 3972 * Examine the PlatformClass field to determine the table type. 3973 * Either a client or server table. Only one. 3974 */ 3975 switch (CommonHeader->PlatformClass) 3976 { 3977 case ACPI_TCPA_CLIENT_TABLE: 3978 3979 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3980 Table->Length - Offset, AcpiDmTableInfoTcpaClient); 3981 break; 3982 3983 case ACPI_TCPA_SERVER_TABLE: 3984 3985 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3986 Table->Length - Offset, AcpiDmTableInfoTcpaServer); 3987 break; 3988 3989 default: 3990 3991 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n", 3992 CommonHeader->PlatformClass); 3993 Status = AE_ERROR; 3994 break; 3995 } 3996 3997 if (ACPI_FAILURE (Status)) 3998 { 3999 AcpiOsPrintf ("\n**** Cannot disassemble TCPA table\n"); 4000 } 4001 } 4002 4003 4004 /******************************************************************************* 4005 * 4006 * FUNCTION: AcpiDmDumpVrtc 4007 * 4008 * PARAMETERS: Table - A VRTC table 4009 * 4010 * RETURN: None 4011 * 4012 * DESCRIPTION: Format the contents of a VRTC 4013 * 4014 ******************************************************************************/ 4015 4016 void 4017 AcpiDmDumpVrtc ( 4018 ACPI_TABLE_HEADER *Table) 4019 { 4020 ACPI_STATUS Status; 4021 UINT32 Offset = sizeof (ACPI_TABLE_VRTC); 4022 ACPI_VRTC_ENTRY *SubTable; 4023 4024 4025 /* Main table */ 4026 4027 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc); 4028 if (ACPI_FAILURE (Status)) 4029 { 4030 return; 4031 } 4032 4033 /* Subtables */ 4034 4035 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset); 4036 while (Offset < Table->Length) 4037 { 4038 /* Common subtable header */ 4039 4040 AcpiOsPrintf ("\n"); 4041 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 4042 sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0); 4043 if (ACPI_FAILURE (Status)) 4044 { 4045 return; 4046 } 4047 4048 /* Point to next subtable */ 4049 4050 Offset += sizeof (ACPI_VRTC_ENTRY); 4051 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable, 4052 sizeof (ACPI_VRTC_ENTRY)); 4053 } 4054 } 4055 4056 4057 /******************************************************************************* 4058 * 4059 * FUNCTION: AcpiDmDumpWdat 4060 * 4061 * PARAMETERS: Table - A WDAT table 4062 * 4063 * RETURN: None 4064 * 4065 * DESCRIPTION: Format the contents of a WDAT 4066 * 4067 ******************************************************************************/ 4068 4069 void 4070 AcpiDmDumpWdat ( 4071 ACPI_TABLE_HEADER *Table) 4072 { 4073 ACPI_STATUS Status; 4074 UINT32 Offset = sizeof (ACPI_TABLE_WDAT); 4075 ACPI_WDAT_ENTRY *SubTable; 4076 4077 4078 /* Main table */ 4079 4080 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat); 4081 if (ACPI_FAILURE (Status)) 4082 { 4083 return; 4084 } 4085 4086 /* Subtables */ 4087 4088 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset); 4089 while (Offset < Table->Length) 4090 { 4091 /* Common subtable header */ 4092 4093 AcpiOsPrintf ("\n"); 4094 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 4095 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0); 4096 if (ACPI_FAILURE (Status)) 4097 { 4098 return; 4099 } 4100 4101 /* Point to next subtable */ 4102 4103 Offset += sizeof (ACPI_WDAT_ENTRY); 4104 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, 4105 sizeof (ACPI_WDAT_ENTRY)); 4106 } 4107 } 4108 4109 4110 /******************************************************************************* 4111 * 4112 * FUNCTION: AcpiDmDumpWpbt 4113 * 4114 * PARAMETERS: Table - A WPBT table 4115 * 4116 * RETURN: None 4117 * 4118 * DESCRIPTION: Format the contents of a WPBT. This table type consists 4119 * of an open-ended arguments buffer at the end of the table. 4120 * 4121 ******************************************************************************/ 4122 4123 void 4124 AcpiDmDumpWpbt ( 4125 ACPI_TABLE_HEADER *Table) 4126 { 4127 ACPI_STATUS Status; 4128 ACPI_TABLE_WPBT *SubTable; 4129 UINT32 Length = Table->Length; 4130 UINT16 ArgumentsLength; 4131 4132 4133 /* Dump the main table */ 4134 4135 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt); 4136 if (ACPI_FAILURE (Status)) 4137 { 4138 return; 4139 } 4140 4141 /* Extract the arguments buffer length from the main table */ 4142 4143 SubTable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table); 4144 ArgumentsLength = SubTable->ArgumentsLength; 4145 4146 /* Dump the arguments buffer */ 4147 4148 (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength, 4149 AcpiDmTableInfoWpbt0); 4150 } 4151