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 default: 1734 1735 /* Cannot continue on unknown type - no length */ 1736 1737 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n", 1738 SubTable->Type); 1739 return; 1740 } 1741 1742 AcpiOsPrintf ("\n"); 1743 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1744 SubTableLength, InfoTable); 1745 if (ACPI_FAILURE (Status)) 1746 { 1747 return; 1748 } 1749 1750 /* Point to end of current subtable (each subtable above is of fixed length) */ 1751 1752 Offset += SubTableLength; 1753 1754 /* If there are any (fixed-length) Error Banks from above, dump them now */ 1755 1756 if (BankCount) 1757 { 1758 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, 1759 SubTableLength); 1760 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 1761 1762 while (BankCount) 1763 { 1764 AcpiOsPrintf ("\n"); 1765 Status = AcpiDmDumpTable (Length, Offset, BankTable, 1766 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 1767 if (ACPI_FAILURE (Status)) 1768 { 1769 return; 1770 } 1771 1772 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 1773 BankTable++; 1774 BankCount--; 1775 } 1776 } 1777 1778 /* Point to next subtable */ 1779 1780 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength); 1781 } 1782 } 1783 1784 1785 /******************************************************************************* 1786 * 1787 * FUNCTION: AcpiDmDumpIort 1788 * 1789 * PARAMETERS: Table - A IORT table 1790 * 1791 * RETURN: None 1792 * 1793 * DESCRIPTION: Format the contents of a IORT 1794 * 1795 ******************************************************************************/ 1796 1797 void 1798 AcpiDmDumpIort ( 1799 ACPI_TABLE_HEADER *Table) 1800 { 1801 ACPI_STATUS Status; 1802 ACPI_TABLE_IORT *Iort; 1803 ACPI_IORT_NODE *IortNode; 1804 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL; 1805 ACPI_IORT_SMMU *IortSmmu = NULL; 1806 UINT32 Offset; 1807 UINT32 NodeOffset; 1808 UINT32 Length; 1809 ACPI_DMTABLE_INFO *InfoTable; 1810 char *String; 1811 UINT32 i; 1812 1813 1814 /* Main table */ 1815 1816 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort); 1817 if (ACPI_FAILURE (Status)) 1818 { 1819 return; 1820 } 1821 1822 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table); 1823 Offset = sizeof (ACPI_TABLE_IORT); 1824 1825 /* Dump the OptionalPadding (optional) */ 1826 1827 if (Iort->NodeOffset > Offset) 1828 { 1829 Status = AcpiDmDumpTable (Table->Length, Offset, Table, 1830 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad); 1831 if (ACPI_FAILURE (Status)) 1832 { 1833 return; 1834 } 1835 } 1836 1837 Offset = Iort->NodeOffset; 1838 while (Offset < Table->Length) 1839 { 1840 /* Common subtable header */ 1841 1842 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset); 1843 AcpiOsPrintf ("\n"); 1844 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData); 1845 Status = AcpiDmDumpTable (Table->Length, Offset, 1846 IortNode, Length, AcpiDmTableInfoIortHdr); 1847 if (ACPI_FAILURE (Status)) 1848 { 1849 return; 1850 } 1851 1852 NodeOffset = Length; 1853 1854 switch (IortNode->Type) 1855 { 1856 case ACPI_IORT_NODE_ITS_GROUP: 1857 1858 InfoTable = AcpiDmTableInfoIort0; 1859 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers); 1860 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset); 1861 break; 1862 1863 case ACPI_IORT_NODE_NAMED_COMPONENT: 1864 1865 InfoTable = AcpiDmTableInfoIort1; 1866 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName); 1867 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length); 1868 Length += strlen (String) + 1; 1869 break; 1870 1871 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX: 1872 1873 InfoTable = AcpiDmTableInfoIort2; 1874 Length = IortNode->Length - NodeOffset; 1875 break; 1876 1877 case ACPI_IORT_NODE_SMMU: 1878 1879 InfoTable = AcpiDmTableInfoIort3; 1880 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts); 1881 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset); 1882 break; 1883 1884 case ACPI_IORT_NODE_SMMU_V3: 1885 1886 InfoTable = AcpiDmTableInfoIort4; 1887 Length = IortNode->Length - NodeOffset; 1888 break; 1889 1890 default: 1891 1892 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n", 1893 IortNode->Type); 1894 1895 /* Attempt to continue */ 1896 1897 if (!IortNode->Length) 1898 { 1899 AcpiOsPrintf ("Invalid zero length IORT node\n"); 1900 return; 1901 } 1902 goto NextSubTable; 1903 } 1904 1905 /* Dump the node subtable header */ 1906 1907 AcpiOsPrintf ("\n"); 1908 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 1909 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 1910 Length, InfoTable); 1911 if (ACPI_FAILURE (Status)) 1912 { 1913 return; 1914 } 1915 1916 NodeOffset += Length; 1917 1918 /* Dump the node specific data */ 1919 1920 switch (IortNode->Type) 1921 { 1922 case ACPI_IORT_NODE_ITS_GROUP: 1923 1924 /* Validate IortItsGroup to avoid compiler warnings */ 1925 1926 if (IortItsGroup) 1927 { 1928 for (i = 0; i < IortItsGroup->ItsCount; i++) 1929 { 1930 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 1931 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 1932 4, AcpiDmTableInfoIort0a); 1933 NodeOffset += 4; 1934 } 1935 } 1936 break; 1937 1938 case ACPI_IORT_NODE_NAMED_COMPONENT: 1939 1940 /* Dump the Padding (optional) */ 1941 1942 if (IortNode->Length > NodeOffset) 1943 { 1944 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 1945 Table, IortNode->Length - NodeOffset, 1946 AcpiDmTableInfoIort1a); 1947 if (ACPI_FAILURE (Status)) 1948 { 1949 return; 1950 } 1951 } 1952 break; 1953 1954 case ACPI_IORT_NODE_SMMU: 1955 1956 AcpiOsPrintf ("\n"); 1957 1958 /* Validate IortSmmu to avoid compiler warnings */ 1959 1960 if (IortSmmu) 1961 { 1962 Length = 2 * sizeof (UINT64); 1963 NodeOffset = IortSmmu->GlobalInterruptOffset; 1964 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 1965 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 1966 Length, AcpiDmTableInfoIort3a); 1967 if (ACPI_FAILURE (Status)) 1968 { 1969 return; 1970 } 1971 1972 NodeOffset = IortSmmu->ContextInterruptOffset; 1973 for (i = 0; i < IortSmmu->ContextInterruptCount; i++) 1974 { 1975 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 1976 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 1977 8, AcpiDmTableInfoIort3b); 1978 if (ACPI_FAILURE (Status)) 1979 { 1980 return; 1981 } 1982 1983 NodeOffset += 8; 1984 } 1985 1986 NodeOffset = IortSmmu->PmuInterruptOffset; 1987 for (i = 0; i < IortSmmu->PmuInterruptCount; i++) 1988 { 1989 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 1990 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 1991 8, AcpiDmTableInfoIort3c); 1992 if (ACPI_FAILURE (Status)) 1993 { 1994 return; 1995 } 1996 1997 NodeOffset += 8; 1998 } 1999 } 2000 break; 2001 2002 default: 2003 2004 break; 2005 } 2006 2007 /* Dump the ID mappings */ 2008 2009 NodeOffset = IortNode->MappingOffset; 2010 for (i = 0; i < IortNode->MappingCount; i++) 2011 { 2012 AcpiOsPrintf ("\n"); 2013 Length = sizeof (ACPI_IORT_ID_MAPPING); 2014 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2015 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2016 Length, AcpiDmTableInfoIortMap); 2017 if (ACPI_FAILURE (Status)) 2018 { 2019 return; 2020 } 2021 2022 NodeOffset += Length; 2023 } 2024 2025 NextSubTable: 2026 /* Point to next node subtable */ 2027 2028 Offset += IortNode->Length; 2029 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length); 2030 } 2031 } 2032 2033 2034 /******************************************************************************* 2035 * 2036 * FUNCTION: AcpiDmDumpIvrs 2037 * 2038 * PARAMETERS: Table - A IVRS table 2039 * 2040 * RETURN: None 2041 * 2042 * DESCRIPTION: Format the contents of a IVRS 2043 * 2044 ******************************************************************************/ 2045 2046 static UINT8 EntrySizes[] = {4,8,16,32}; 2047 2048 void 2049 AcpiDmDumpIvrs ( 2050 ACPI_TABLE_HEADER *Table) 2051 { 2052 ACPI_STATUS Status; 2053 UINT32 Offset = sizeof (ACPI_TABLE_IVRS); 2054 UINT32 EntryOffset; 2055 UINT32 EntryLength; 2056 UINT32 EntryType; 2057 ACPI_IVRS_DE_HEADER *DeviceEntry; 2058 ACPI_IVRS_HEADER *SubTable; 2059 ACPI_DMTABLE_INFO *InfoTable; 2060 2061 2062 /* Main table */ 2063 2064 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); 2065 if (ACPI_FAILURE (Status)) 2066 { 2067 return; 2068 } 2069 2070 /* Subtables */ 2071 2072 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); 2073 while (Offset < Table->Length) 2074 { 2075 /* Common subtable header */ 2076 2077 AcpiOsPrintf ("\n"); 2078 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2079 SubTable->Length, AcpiDmTableInfoIvrsHdr); 2080 if (ACPI_FAILURE (Status)) 2081 { 2082 return; 2083 } 2084 2085 switch (SubTable->Type) 2086 { 2087 case ACPI_IVRS_TYPE_HARDWARE: 2088 2089 InfoTable = AcpiDmTableInfoIvrs0; 2090 break; 2091 2092 case ACPI_IVRS_TYPE_MEMORY1: 2093 case ACPI_IVRS_TYPE_MEMORY2: 2094 case ACPI_IVRS_TYPE_MEMORY3: 2095 2096 InfoTable = AcpiDmTableInfoIvrs1; 2097 break; 2098 2099 default: 2100 2101 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n", 2102 SubTable->Type); 2103 2104 /* Attempt to continue */ 2105 2106 if (!SubTable->Length) 2107 { 2108 AcpiOsPrintf ("Invalid zero length subtable\n"); 2109 return; 2110 } 2111 goto NextSubTable; 2112 } 2113 2114 /* Dump the subtable */ 2115 2116 AcpiOsPrintf ("\n"); 2117 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2118 SubTable->Length, InfoTable); 2119 if (ACPI_FAILURE (Status)) 2120 { 2121 return; 2122 } 2123 2124 /* The hardware subtable can contain multiple device entries */ 2125 2126 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE) 2127 { 2128 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE); 2129 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable, 2130 sizeof (ACPI_IVRS_HARDWARE)); 2131 2132 while (EntryOffset < (Offset + SubTable->Length)) 2133 { 2134 AcpiOsPrintf ("\n"); 2135 /* 2136 * Upper 2 bits of Type encode the length of the device entry 2137 * 2138 * 00 = 4 byte 2139 * 01 = 8 byte 2140 * 10 = 16 byte - currently no entries defined 2141 * 11 = 32 byte - currently no entries defined 2142 */ 2143 EntryType = DeviceEntry->Type; 2144 EntryLength = EntrySizes [EntryType >> 6]; 2145 2146 switch (EntryType) 2147 { 2148 /* 4-byte device entries */ 2149 2150 case ACPI_IVRS_TYPE_PAD4: 2151 case ACPI_IVRS_TYPE_ALL: 2152 case ACPI_IVRS_TYPE_SELECT: 2153 case ACPI_IVRS_TYPE_START: 2154 case ACPI_IVRS_TYPE_END: 2155 2156 InfoTable = AcpiDmTableInfoIvrs4; 2157 break; 2158 2159 /* 8-byte entries, type A */ 2160 2161 case ACPI_IVRS_TYPE_ALIAS_SELECT: 2162 case ACPI_IVRS_TYPE_ALIAS_START: 2163 2164 InfoTable = AcpiDmTableInfoIvrs8a; 2165 break; 2166 2167 /* 8-byte entries, type B */ 2168 2169 case ACPI_IVRS_TYPE_PAD8: 2170 case ACPI_IVRS_TYPE_EXT_SELECT: 2171 case ACPI_IVRS_TYPE_EXT_START: 2172 2173 InfoTable = AcpiDmTableInfoIvrs8b; 2174 break; 2175 2176 /* 8-byte entries, type C */ 2177 2178 case ACPI_IVRS_TYPE_SPECIAL: 2179 2180 InfoTable = AcpiDmTableInfoIvrs8c; 2181 break; 2182 2183 default: 2184 InfoTable = AcpiDmTableInfoIvrs4; 2185 AcpiOsPrintf ( 2186 "\n**** Unknown IVRS device entry type/length: " 2187 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n", 2188 EntryType, EntryLength, EntryOffset); 2189 break; 2190 } 2191 2192 /* Dump the Device Entry */ 2193 2194 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 2195 DeviceEntry, EntryLength, InfoTable); 2196 if (ACPI_FAILURE (Status)) 2197 { 2198 return; 2199 } 2200 2201 EntryOffset += EntryLength; 2202 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry, 2203 EntryLength); 2204 } 2205 } 2206 2207 NextSubTable: 2208 /* Point to next subtable */ 2209 2210 Offset += SubTable->Length; 2211 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length); 2212 } 2213 } 2214 2215 2216 /******************************************************************************* 2217 * 2218 * FUNCTION: AcpiDmDumpLpit 2219 * 2220 * PARAMETERS: Table - A LPIT table 2221 * 2222 * RETURN: None 2223 * 2224 * DESCRIPTION: Format the contents of a LPIT. This table type consists 2225 * of an open-ended number of subtables. Note: There are no 2226 * entries in the main table. An LPIT consists of the table 2227 * header and then subtables only. 2228 * 2229 ******************************************************************************/ 2230 2231 void 2232 AcpiDmDumpLpit ( 2233 ACPI_TABLE_HEADER *Table) 2234 { 2235 ACPI_STATUS Status; 2236 ACPI_LPIT_HEADER *SubTable; 2237 UINT32 Length = Table->Length; 2238 UINT32 Offset = sizeof (ACPI_TABLE_LPIT); 2239 ACPI_DMTABLE_INFO *InfoTable; 2240 UINT32 SubTableLength; 2241 2242 2243 /* Subtables */ 2244 2245 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset); 2246 while (Offset < Table->Length) 2247 { 2248 /* Common subtable header */ 2249 2250 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2251 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr); 2252 if (ACPI_FAILURE (Status)) 2253 { 2254 return; 2255 } 2256 2257 switch (SubTable->Type) 2258 { 2259 case ACPI_LPIT_TYPE_NATIVE_CSTATE: 2260 2261 InfoTable = AcpiDmTableInfoLpit0; 2262 SubTableLength = sizeof (ACPI_LPIT_NATIVE); 2263 break; 2264 2265 default: 2266 2267 /* Cannot continue on unknown type - no length */ 2268 2269 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n", 2270 SubTable->Type); 2271 return; 2272 } 2273 2274 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2275 SubTableLength, InfoTable); 2276 if (ACPI_FAILURE (Status)) 2277 { 2278 return; 2279 } 2280 2281 AcpiOsPrintf ("\n"); 2282 2283 /* Point to next subtable */ 2284 2285 Offset += SubTableLength; 2286 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, SubTable, SubTableLength); 2287 } 2288 } 2289 2290 2291 /******************************************************************************* 2292 * 2293 * FUNCTION: AcpiDmDumpMadt 2294 * 2295 * PARAMETERS: Table - A MADT table 2296 * 2297 * RETURN: None 2298 * 2299 * DESCRIPTION: Format the contents of a MADT. This table type consists 2300 * of an open-ended number of subtables. 2301 * 2302 ******************************************************************************/ 2303 2304 void 2305 AcpiDmDumpMadt ( 2306 ACPI_TABLE_HEADER *Table) 2307 { 2308 ACPI_STATUS Status; 2309 ACPI_SUBTABLE_HEADER *SubTable; 2310 UINT32 Length = Table->Length; 2311 UINT32 Offset = sizeof (ACPI_TABLE_MADT); 2312 ACPI_DMTABLE_INFO *InfoTable; 2313 2314 2315 /* Main table */ 2316 2317 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); 2318 if (ACPI_FAILURE (Status)) 2319 { 2320 return; 2321 } 2322 2323 /* Subtables */ 2324 2325 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 2326 while (Offset < Table->Length) 2327 { 2328 /* Common subtable header */ 2329 2330 AcpiOsPrintf ("\n"); 2331 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2332 SubTable->Length, AcpiDmTableInfoMadtHdr); 2333 if (ACPI_FAILURE (Status)) 2334 { 2335 return; 2336 } 2337 2338 switch (SubTable->Type) 2339 { 2340 case ACPI_MADT_TYPE_LOCAL_APIC: 2341 2342 InfoTable = AcpiDmTableInfoMadt0; 2343 break; 2344 2345 case ACPI_MADT_TYPE_IO_APIC: 2346 2347 InfoTable = AcpiDmTableInfoMadt1; 2348 break; 2349 2350 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 2351 2352 InfoTable = AcpiDmTableInfoMadt2; 2353 break; 2354 2355 case ACPI_MADT_TYPE_NMI_SOURCE: 2356 2357 InfoTable = AcpiDmTableInfoMadt3; 2358 break; 2359 2360 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 2361 2362 InfoTable = AcpiDmTableInfoMadt4; 2363 break; 2364 2365 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 2366 2367 InfoTable = AcpiDmTableInfoMadt5; 2368 break; 2369 2370 case ACPI_MADT_TYPE_IO_SAPIC: 2371 2372 InfoTable = AcpiDmTableInfoMadt6; 2373 break; 2374 2375 case ACPI_MADT_TYPE_LOCAL_SAPIC: 2376 2377 InfoTable = AcpiDmTableInfoMadt7; 2378 break; 2379 2380 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 2381 2382 InfoTable = AcpiDmTableInfoMadt8; 2383 break; 2384 2385 case ACPI_MADT_TYPE_LOCAL_X2APIC: 2386 2387 InfoTable = AcpiDmTableInfoMadt9; 2388 break; 2389 2390 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 2391 2392 InfoTable = AcpiDmTableInfoMadt10; 2393 break; 2394 2395 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 2396 2397 InfoTable = AcpiDmTableInfoMadt11; 2398 break; 2399 2400 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 2401 2402 InfoTable = AcpiDmTableInfoMadt12; 2403 break; 2404 2405 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME: 2406 2407 InfoTable = AcpiDmTableInfoMadt13; 2408 break; 2409 2410 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR: 2411 2412 InfoTable = AcpiDmTableInfoMadt14; 2413 break; 2414 2415 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR: 2416 2417 InfoTable = AcpiDmTableInfoMadt15; 2418 break; 2419 2420 default: 2421 2422 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n", 2423 SubTable->Type); 2424 2425 /* Attempt to continue */ 2426 2427 if (!SubTable->Length) 2428 { 2429 AcpiOsPrintf ("Invalid zero length subtable\n"); 2430 return; 2431 } 2432 2433 goto NextSubTable; 2434 } 2435 2436 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2437 SubTable->Length, InfoTable); 2438 if (ACPI_FAILURE (Status)) 2439 { 2440 return; 2441 } 2442 2443 NextSubTable: 2444 /* Point to next subtable */ 2445 2446 Offset += SubTable->Length; 2447 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, 2448 SubTable->Length); 2449 } 2450 } 2451 2452 2453 /******************************************************************************* 2454 * 2455 * FUNCTION: AcpiDmDumpMcfg 2456 * 2457 * PARAMETERS: Table - A MCFG Table 2458 * 2459 * RETURN: None 2460 * 2461 * DESCRIPTION: Format the contents of a MCFG table 2462 * 2463 ******************************************************************************/ 2464 2465 void 2466 AcpiDmDumpMcfg ( 2467 ACPI_TABLE_HEADER *Table) 2468 { 2469 ACPI_STATUS Status; 2470 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 2471 ACPI_MCFG_ALLOCATION *SubTable; 2472 2473 2474 /* Main table */ 2475 2476 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 2477 if (ACPI_FAILURE (Status)) 2478 { 2479 return; 2480 } 2481 2482 /* Subtables */ 2483 2484 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 2485 while (Offset < Table->Length) 2486 { 2487 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 2488 { 2489 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", 2490 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 2491 return; 2492 } 2493 2494 AcpiOsPrintf ("\n"); 2495 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2496 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 2497 if (ACPI_FAILURE (Status)) 2498 { 2499 return; 2500 } 2501 2502 /* Point to next subtable (each subtable is of fixed length) */ 2503 2504 Offset += sizeof (ACPI_MCFG_ALLOCATION); 2505 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable, 2506 sizeof (ACPI_MCFG_ALLOCATION)); 2507 } 2508 } 2509 2510 2511 /******************************************************************************* 2512 * 2513 * FUNCTION: AcpiDmDumpMpst 2514 * 2515 * PARAMETERS: Table - A MPST Table 2516 * 2517 * RETURN: None 2518 * 2519 * DESCRIPTION: Format the contents of a MPST table 2520 * 2521 ******************************************************************************/ 2522 2523 void 2524 AcpiDmDumpMpst ( 2525 ACPI_TABLE_HEADER *Table) 2526 { 2527 ACPI_STATUS Status; 2528 UINT32 Offset = sizeof (ACPI_TABLE_MPST); 2529 ACPI_MPST_POWER_NODE *SubTable0; 2530 ACPI_MPST_POWER_STATE *SubTable0A; 2531 ACPI_MPST_COMPONENT *SubTable0B; 2532 ACPI_MPST_DATA_HDR *SubTable1; 2533 ACPI_MPST_POWER_DATA *SubTable2; 2534 UINT16 SubtableCount; 2535 UINT32 PowerStateCount; 2536 UINT32 ComponentCount; 2537 2538 2539 /* Main table */ 2540 2541 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); 2542 if (ACPI_FAILURE (Status)) 2543 { 2544 return; 2545 } 2546 2547 /* Subtable: Memory Power Node(s) */ 2548 2549 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; 2550 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); 2551 2552 while ((Offset < Table->Length) && SubtableCount) 2553 { 2554 AcpiOsPrintf ("\n"); 2555 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0, 2556 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); 2557 if (ACPI_FAILURE (Status)) 2558 { 2559 return; 2560 } 2561 2562 /* Extract the sub-subtable counts */ 2563 2564 PowerStateCount = SubTable0->NumPowerStates; 2565 ComponentCount = SubTable0->NumPhysicalComponents; 2566 Offset += sizeof (ACPI_MPST_POWER_NODE); 2567 2568 /* Sub-subtables - Memory Power State Structure(s) */ 2569 2570 SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0, 2571 sizeof (ACPI_MPST_POWER_NODE)); 2572 2573 while (PowerStateCount) 2574 { 2575 AcpiOsPrintf ("\n"); 2576 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A, 2577 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); 2578 if (ACPI_FAILURE (Status)) 2579 { 2580 return; 2581 } 2582 2583 SubTable0A++; 2584 PowerStateCount--; 2585 Offset += sizeof (ACPI_MPST_POWER_STATE); 2586 } 2587 2588 /* Sub-subtables - Physical Component ID Structure(s) */ 2589 2590 SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A); 2591 2592 if (ComponentCount) 2593 { 2594 AcpiOsPrintf ("\n"); 2595 } 2596 2597 while (ComponentCount) 2598 { 2599 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B, 2600 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); 2601 if (ACPI_FAILURE (Status)) 2602 { 2603 return; 2604 } 2605 2606 SubTable0B++; 2607 ComponentCount--; 2608 Offset += sizeof (ACPI_MPST_COMPONENT); 2609 } 2610 2611 /* Point to next Memory Power Node subtable */ 2612 2613 SubtableCount--; 2614 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0, 2615 sizeof (ACPI_MPST_POWER_NODE) + 2616 (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) + 2617 (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents)); 2618 } 2619 2620 /* Subtable: Count of Memory Power State Characteristic structures */ 2621 2622 AcpiOsPrintf ("\n"); 2623 SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0); 2624 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1, 2625 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); 2626 if (ACPI_FAILURE (Status)) 2627 { 2628 return; 2629 } 2630 2631 SubtableCount = SubTable1->CharacteristicsCount; 2632 Offset += sizeof (ACPI_MPST_DATA_HDR); 2633 2634 /* Subtable: Memory Power State Characteristics structure(s) */ 2635 2636 SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, 2637 sizeof (ACPI_MPST_DATA_HDR)); 2638 2639 while ((Offset < Table->Length) && SubtableCount) 2640 { 2641 AcpiOsPrintf ("\n"); 2642 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2, 2643 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); 2644 if (ACPI_FAILURE (Status)) 2645 { 2646 return; 2647 } 2648 2649 SubTable2++; 2650 SubtableCount--; 2651 Offset += sizeof (ACPI_MPST_POWER_DATA); 2652 } 2653 } 2654 2655 2656 /******************************************************************************* 2657 * 2658 * FUNCTION: AcpiDmDumpMsct 2659 * 2660 * PARAMETERS: Table - A MSCT table 2661 * 2662 * RETURN: None 2663 * 2664 * DESCRIPTION: Format the contents of a MSCT 2665 * 2666 ******************************************************************************/ 2667 2668 void 2669 AcpiDmDumpMsct ( 2670 ACPI_TABLE_HEADER *Table) 2671 { 2672 ACPI_STATUS Status; 2673 UINT32 Offset = sizeof (ACPI_TABLE_MSCT); 2674 ACPI_MSCT_PROXIMITY *SubTable; 2675 2676 2677 /* Main table */ 2678 2679 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); 2680 if (ACPI_FAILURE (Status)) 2681 { 2682 return; 2683 } 2684 2685 /* Subtables */ 2686 2687 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); 2688 while (Offset < Table->Length) 2689 { 2690 /* Common subtable header */ 2691 2692 AcpiOsPrintf ("\n"); 2693 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2694 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); 2695 if (ACPI_FAILURE (Status)) 2696 { 2697 return; 2698 } 2699 2700 /* Point to next subtable */ 2701 2702 Offset += sizeof (ACPI_MSCT_PROXIMITY); 2703 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, 2704 sizeof (ACPI_MSCT_PROXIMITY)); 2705 } 2706 } 2707 2708 2709 /******************************************************************************* 2710 * 2711 * FUNCTION: AcpiDmDumpMtmr 2712 * 2713 * PARAMETERS: Table - A MTMR table 2714 * 2715 * RETURN: None 2716 * 2717 * DESCRIPTION: Format the contents of a MTMR 2718 * 2719 ******************************************************************************/ 2720 2721 void 2722 AcpiDmDumpMtmr ( 2723 ACPI_TABLE_HEADER *Table) 2724 { 2725 ACPI_STATUS Status; 2726 UINT32 Offset = sizeof (ACPI_TABLE_MTMR); 2727 ACPI_MTMR_ENTRY *SubTable; 2728 2729 2730 /* Main table */ 2731 2732 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr); 2733 if (ACPI_FAILURE (Status)) 2734 { 2735 return; 2736 } 2737 2738 /* Subtables */ 2739 2740 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset); 2741 while (Offset < Table->Length) 2742 { 2743 /* Common subtable header */ 2744 2745 AcpiOsPrintf ("\n"); 2746 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2747 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0); 2748 if (ACPI_FAILURE (Status)) 2749 { 2750 return; 2751 } 2752 2753 /* Point to next subtable */ 2754 2755 Offset += sizeof (ACPI_MTMR_ENTRY); 2756 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable, 2757 sizeof (ACPI_MTMR_ENTRY)); 2758 } 2759 } 2760 2761 2762 /******************************************************************************* 2763 * 2764 * FUNCTION: AcpiDmDumpNfit 2765 * 2766 * PARAMETERS: Table - A NFIT table 2767 * 2768 * RETURN: None 2769 * 2770 * DESCRIPTION: Format the contents of an NFIT. 2771 * 2772 ******************************************************************************/ 2773 2774 void 2775 AcpiDmDumpNfit ( 2776 ACPI_TABLE_HEADER *Table) 2777 { 2778 ACPI_STATUS Status; 2779 UINT32 Offset = sizeof (ACPI_TABLE_NFIT); 2780 UINT32 FieldOffset = 0; 2781 UINT32 Length; 2782 ACPI_NFIT_HEADER *SubTable; 2783 ACPI_DMTABLE_INFO *InfoTable; 2784 ACPI_NFIT_INTERLEAVE *Interleave = NULL; 2785 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL; 2786 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; 2787 UINT32 i; 2788 2789 2790 /* Main table */ 2791 2792 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit); 2793 if (ACPI_FAILURE (Status)) 2794 { 2795 return; 2796 } 2797 2798 /* Subtables */ 2799 2800 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset); 2801 while (Offset < Table->Length) 2802 { 2803 /* NFIT subtable header */ 2804 2805 AcpiOsPrintf ("\n"); 2806 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2807 SubTable->Length, AcpiDmTableInfoNfitHdr); 2808 if (ACPI_FAILURE (Status)) 2809 { 2810 return; 2811 } 2812 2813 switch (SubTable->Type) 2814 { 2815 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: 2816 2817 InfoTable = AcpiDmTableInfoNfit0; 2818 break; 2819 2820 case ACPI_NFIT_TYPE_MEMORY_MAP: 2821 2822 InfoTable = AcpiDmTableInfoNfit1; 2823 break; 2824 2825 case ACPI_NFIT_TYPE_INTERLEAVE: 2826 2827 /* Has a variable number of 32-bit values at the end */ 2828 2829 InfoTable = AcpiDmTableInfoNfit2; 2830 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, SubTable); 2831 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE); 2832 break; 2833 2834 case ACPI_NFIT_TYPE_SMBIOS: 2835 2836 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, SubTable); 2837 InfoTable = AcpiDmTableInfoNfit3; 2838 break; 2839 2840 case ACPI_NFIT_TYPE_CONTROL_REGION: 2841 2842 InfoTable = AcpiDmTableInfoNfit4; 2843 break; 2844 2845 case ACPI_NFIT_TYPE_DATA_REGION: 2846 2847 InfoTable = AcpiDmTableInfoNfit5; 2848 break; 2849 2850 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 2851 2852 /* Has a variable number of 64-bit addresses at the end */ 2853 2854 InfoTable = AcpiDmTableInfoNfit6; 2855 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, SubTable); 2856 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64); 2857 break; 2858 2859 default: 2860 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n", 2861 SubTable->Type); 2862 2863 /* Attempt to continue */ 2864 2865 if (!SubTable->Length) 2866 { 2867 AcpiOsPrintf ("Invalid zero length subtable\n"); 2868 return; 2869 } 2870 goto NextSubTable; 2871 } 2872 2873 AcpiOsPrintf ("\n"); 2874 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2875 SubTable->Length, InfoTable); 2876 if (ACPI_FAILURE (Status)) 2877 { 2878 return; 2879 } 2880 2881 /* Per-subtable variable-length fields */ 2882 2883 switch (SubTable->Type) 2884 { 2885 case ACPI_NFIT_TYPE_INTERLEAVE: 2886 2887 for (i = 0; i < Interleave->LineCount; i++) 2888 { 2889 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 2890 &Interleave->LineOffset[i], 2891 sizeof (UINT32), AcpiDmTableInfoNfit2a); 2892 if (ACPI_FAILURE (Status)) 2893 { 2894 return; 2895 } 2896 2897 FieldOffset += sizeof (UINT32); 2898 } 2899 break; 2900 2901 case ACPI_NFIT_TYPE_SMBIOS: 2902 2903 Length = SubTable->Length - 2904 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8); 2905 2906 if (Length) 2907 { 2908 Status = AcpiDmDumpTable (Table->Length, 2909 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8), 2910 SmbiosInfo, 2911 Length, AcpiDmTableInfoNfit3a); 2912 if (ACPI_FAILURE (Status)) 2913 { 2914 return; 2915 } 2916 } 2917 2918 break; 2919 2920 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 2921 2922 for (i = 0; i < Hint->HintCount; i++) 2923 { 2924 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 2925 &Hint->HintAddress[i], 2926 sizeof (UINT64), AcpiDmTableInfoNfit6a); 2927 if (ACPI_FAILURE (Status)) 2928 { 2929 return; 2930 } 2931 2932 FieldOffset += sizeof (UINT64); 2933 } 2934 break; 2935 2936 default: 2937 break; 2938 } 2939 2940 NextSubTable: 2941 /* Point to next subtable */ 2942 2943 Offset += SubTable->Length; 2944 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubTable->Length); 2945 } 2946 } 2947 2948 2949 /******************************************************************************* 2950 * 2951 * FUNCTION: AcpiDmDumpPcct 2952 * 2953 * PARAMETERS: Table - A PCCT table 2954 * 2955 * RETURN: None 2956 * 2957 * DESCRIPTION: Format the contents of a PCCT. This table type consists 2958 * of an open-ended number of subtables. 2959 * 2960 ******************************************************************************/ 2961 2962 void 2963 AcpiDmDumpPcct ( 2964 ACPI_TABLE_HEADER *Table) 2965 { 2966 ACPI_STATUS Status; 2967 ACPI_PCCT_SUBSPACE *SubTable; 2968 ACPI_DMTABLE_INFO *InfoTable; 2969 UINT32 Length = Table->Length; 2970 UINT32 Offset = sizeof (ACPI_TABLE_PCCT); 2971 2972 2973 /* Main table */ 2974 2975 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); 2976 if (ACPI_FAILURE (Status)) 2977 { 2978 return; 2979 } 2980 2981 /* Subtables */ 2982 2983 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); 2984 while (Offset < Table->Length) 2985 { 2986 /* Common subtable header */ 2987 2988 AcpiOsPrintf ("\n"); 2989 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2990 SubTable->Header.Length, AcpiDmTableInfoPcctHdr); 2991 if (ACPI_FAILURE (Status)) 2992 { 2993 return; 2994 } 2995 2996 switch (SubTable->Header.Type) 2997 { 2998 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: 2999 3000 InfoTable = AcpiDmTableInfoPcct0; 3001 break; 3002 3003 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: 3004 3005 InfoTable = AcpiDmTableInfoPcct1; 3006 break; 3007 3008 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2: 3009 3010 InfoTable = AcpiDmTableInfoPcct2; 3011 break; 3012 3013 default: 3014 3015 AcpiOsPrintf ( 3016 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n", 3017 SubTable->Header.Type); 3018 return; 3019 } 3020 3021 AcpiOsPrintf ("\n"); 3022 Status = AcpiDmDumpTable (Length, Offset, SubTable, 3023 SubTable->Header.Length, InfoTable); 3024 if (ACPI_FAILURE (Status)) 3025 { 3026 return; 3027 } 3028 3029 /* Point to next subtable */ 3030 3031 Offset += SubTable->Header.Length; 3032 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable, 3033 SubTable->Header.Length); 3034 } 3035 } 3036 3037 3038 /******************************************************************************* 3039 * 3040 * FUNCTION: AcpiDmDumpPmtt 3041 * 3042 * PARAMETERS: Table - A PMTT table 3043 * 3044 * RETURN: None 3045 * 3046 * DESCRIPTION: Format the contents of a PMTT. This table type consists 3047 * of an open-ended number of subtables. 3048 * 3049 ******************************************************************************/ 3050 3051 void 3052 AcpiDmDumpPmtt ( 3053 ACPI_TABLE_HEADER *Table) 3054 { 3055 ACPI_STATUS Status; 3056 ACPI_PMTT_HEADER *SubTable; 3057 ACPI_PMTT_HEADER *MemSubTable; 3058 ACPI_PMTT_HEADER *DimmSubTable; 3059 ACPI_PMTT_DOMAIN *DomainArray; 3060 UINT32 Length = Table->Length; 3061 UINT32 Offset = sizeof (ACPI_TABLE_PMTT); 3062 UINT32 MemOffset; 3063 UINT32 DimmOffset; 3064 UINT32 DomainOffset; 3065 UINT32 DomainCount; 3066 3067 3068 /* Main table */ 3069 3070 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); 3071 if (ACPI_FAILURE (Status)) 3072 { 3073 return; 3074 } 3075 3076 /* Subtables */ 3077 3078 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); 3079 while (Offset < Table->Length) 3080 { 3081 /* Common subtable header */ 3082 3083 AcpiOsPrintf ("\n"); 3084 Status = AcpiDmDumpTable (Length, Offset, SubTable, 3085 SubTable->Length, AcpiDmTableInfoPmttHdr); 3086 if (ACPI_FAILURE (Status)) 3087 { 3088 return; 3089 } 3090 3091 /* Only Socket subtables are expected at this level */ 3092 3093 if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET) 3094 { 3095 AcpiOsPrintf ( 3096 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 3097 SubTable->Type); 3098 return; 3099 } 3100 3101 /* Dump the fixed-length portion of the subtable */ 3102 3103 Status = AcpiDmDumpTable (Length, Offset, SubTable, 3104 SubTable->Length, AcpiDmTableInfoPmtt0); 3105 if (ACPI_FAILURE (Status)) 3106 { 3107 return; 3108 } 3109 3110 /* Walk the memory controller subtables */ 3111 3112 MemOffset = sizeof (ACPI_PMTT_SOCKET); 3113 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, 3114 sizeof (ACPI_PMTT_SOCKET)); 3115 3116 while (((Offset + MemOffset) < Table->Length) && 3117 (MemOffset < SubTable->Length)) 3118 { 3119 /* Common subtable header */ 3120 3121 AcpiOsPrintf ("\n"); 3122 Status = AcpiDmDumpTable (Length, 3123 Offset + MemOffset, MemSubTable, 3124 MemSubTable->Length, AcpiDmTableInfoPmttHdr); 3125 if (ACPI_FAILURE (Status)) 3126 { 3127 return; 3128 } 3129 3130 /* Only memory controller subtables are expected at this level */ 3131 3132 if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER) 3133 { 3134 AcpiOsPrintf ( 3135 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 3136 MemSubTable->Type); 3137 return; 3138 } 3139 3140 /* Dump the fixed-length portion of the controller subtable */ 3141 3142 Status = AcpiDmDumpTable (Length, 3143 Offset + MemOffset, MemSubTable, 3144 MemSubTable->Length, AcpiDmTableInfoPmtt1); 3145 if (ACPI_FAILURE (Status)) 3146 { 3147 return; 3148 } 3149 3150 /* Walk the variable count of proximity domains */ 3151 3152 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount; 3153 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER); 3154 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable, 3155 sizeof (ACPI_PMTT_CONTROLLER)); 3156 3157 while (((Offset + MemOffset + DomainOffset) < Table->Length) && 3158 ((MemOffset + DomainOffset) < SubTable->Length) && 3159 DomainCount) 3160 { 3161 Status = AcpiDmDumpTable (Length, 3162 Offset + MemOffset + DomainOffset, DomainArray, 3163 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a); 3164 if (ACPI_FAILURE (Status)) 3165 { 3166 return; 3167 } 3168 3169 DomainOffset += sizeof (ACPI_PMTT_DOMAIN); 3170 DomainArray++; 3171 DomainCount--; 3172 } 3173 3174 if (DomainCount) 3175 { 3176 AcpiOsPrintf ( 3177 "\n**** DomainCount exceeds subtable length\n\n"); 3178 } 3179 3180 /* Walk the physical component (DIMM) subtables */ 3181 3182 DimmOffset = DomainOffset; 3183 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable, 3184 DomainOffset); 3185 3186 while (((Offset + MemOffset + DimmOffset) < Table->Length) && 3187 (DimmOffset < MemSubTable->Length)) 3188 { 3189 /* Common subtable header */ 3190 3191 AcpiOsPrintf ("\n"); 3192 Status = AcpiDmDumpTable (Length, 3193 Offset + MemOffset + DimmOffset, DimmSubTable, 3194 DimmSubTable->Length, AcpiDmTableInfoPmttHdr); 3195 if (ACPI_FAILURE (Status)) 3196 { 3197 return; 3198 } 3199 3200 /* Only DIMM subtables are expected at this level */ 3201 3202 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM) 3203 { 3204 AcpiOsPrintf ( 3205 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 3206 DimmSubTable->Type); 3207 return; 3208 } 3209 3210 /* Dump the fixed-length DIMM subtable */ 3211 3212 Status = AcpiDmDumpTable (Length, 3213 Offset + MemOffset + DimmOffset, DimmSubTable, 3214 DimmSubTable->Length, AcpiDmTableInfoPmtt2); 3215 if (ACPI_FAILURE (Status)) 3216 { 3217 return; 3218 } 3219 3220 /* Point to next DIMM subtable */ 3221 3222 DimmOffset += DimmSubTable->Length; 3223 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 3224 DimmSubTable, DimmSubTable->Length); 3225 } 3226 3227 /* Point to next Controller subtable */ 3228 3229 MemOffset += MemSubTable->Length; 3230 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 3231 MemSubTable, MemSubTable->Length); 3232 } 3233 3234 /* Point to next Socket subtable */ 3235 3236 Offset += SubTable->Length; 3237 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 3238 SubTable, SubTable->Length); 3239 } 3240 } 3241 3242 3243 /******************************************************************************* 3244 * 3245 * FUNCTION: AcpiDmDumpS3pt 3246 * 3247 * PARAMETERS: Table - A S3PT table 3248 * 3249 * RETURN: Length of the table 3250 * 3251 * DESCRIPTION: Format the contents of a S3PT 3252 * 3253 ******************************************************************************/ 3254 3255 UINT32 3256 AcpiDmDumpS3pt ( 3257 ACPI_TABLE_HEADER *Tables) 3258 { 3259 ACPI_STATUS Status; 3260 UINT32 Offset = sizeof (ACPI_TABLE_S3PT); 3261 ACPI_FPDT_HEADER *SubTable; 3262 ACPI_DMTABLE_INFO *InfoTable; 3263 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); 3264 3265 3266 /* Main table */ 3267 3268 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt); 3269 if (ACPI_FAILURE (Status)) 3270 { 3271 return 0; 3272 } 3273 3274 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset); 3275 while (Offset < S3ptTable->Length) 3276 { 3277 /* Common subtable header */ 3278 3279 AcpiOsPrintf ("\n"); 3280 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 3281 SubTable->Length, AcpiDmTableInfoS3ptHdr); 3282 if (ACPI_FAILURE (Status)) 3283 { 3284 return 0; 3285 } 3286 3287 switch (SubTable->Type) 3288 { 3289 case ACPI_S3PT_TYPE_RESUME: 3290 3291 InfoTable = AcpiDmTableInfoS3pt0; 3292 break; 3293 3294 case ACPI_S3PT_TYPE_SUSPEND: 3295 3296 InfoTable = AcpiDmTableInfoS3pt1; 3297 break; 3298 3299 default: 3300 3301 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", 3302 SubTable->Type); 3303 3304 /* Attempt to continue */ 3305 3306 if (!SubTable->Length) 3307 { 3308 AcpiOsPrintf ("Invalid zero length subtable\n"); 3309 return 0; 3310 } 3311 goto NextSubTable; 3312 } 3313 3314 AcpiOsPrintf ("\n"); 3315 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 3316 SubTable->Length, InfoTable); 3317 if (ACPI_FAILURE (Status)) 3318 { 3319 return 0; 3320 } 3321 3322 NextSubTable: 3323 /* Point to next subtable */ 3324 3325 Offset += SubTable->Length; 3326 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length); 3327 } 3328 3329 return (S3ptTable->Length); 3330 } 3331 3332 3333 /******************************************************************************* 3334 * 3335 * FUNCTION: AcpiDmDumpSlic 3336 * 3337 * PARAMETERS: Table - A SLIC table 3338 * 3339 * RETURN: None 3340 * 3341 * DESCRIPTION: Format the contents of a SLIC 3342 * 3343 ******************************************************************************/ 3344 3345 void 3346 AcpiDmDumpSlic ( 3347 ACPI_TABLE_HEADER *Table) 3348 { 3349 3350 (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table, 3351 Table->Length - sizeof (*Table), AcpiDmTableInfoSlic); 3352 } 3353 3354 3355 /******************************************************************************* 3356 * 3357 * FUNCTION: AcpiDmDumpSlit 3358 * 3359 * PARAMETERS: Table - An SLIT 3360 * 3361 * RETURN: None 3362 * 3363 * DESCRIPTION: Format the contents of a SLIT 3364 * 3365 ******************************************************************************/ 3366 3367 void 3368 AcpiDmDumpSlit ( 3369 ACPI_TABLE_HEADER *Table) 3370 { 3371 ACPI_STATUS Status; 3372 UINT32 Offset; 3373 UINT8 *Row; 3374 UINT32 Localities; 3375 UINT32 i; 3376 UINT32 j; 3377 3378 3379 /* Main table */ 3380 3381 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit); 3382 if (ACPI_FAILURE (Status)) 3383 { 3384 return; 3385 } 3386 3387 /* Display the Locality NxN Matrix */ 3388 3389 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; 3390 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]); 3391 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry; 3392 3393 for (i = 0; i < Localities; i++) 3394 { 3395 /* Display one row of the matrix */ 3396 3397 AcpiDmLineHeader2 (Offset, Localities, "Locality", i); 3398 for (j = 0; j < Localities; j++) 3399 { 3400 /* Check for beyond EOT */ 3401 3402 if (Offset >= Table->Length) 3403 { 3404 AcpiOsPrintf ( 3405 "\n**** Not enough room in table for all localities\n"); 3406 return; 3407 } 3408 3409 AcpiOsPrintf ("%2.2X", Row[j]); 3410 Offset++; 3411 3412 /* Display up to 16 bytes per output row */ 3413 3414 if ((j+1) < Localities) 3415 { 3416 AcpiOsPrintf (" "); 3417 3418 if (j && (((j+1) % 16) == 0)) 3419 { 3420 AcpiOsPrintf ("\\\n"); /* With line continuation char */ 3421 AcpiDmLineHeader (Offset, 0, NULL); 3422 } 3423 } 3424 } 3425 3426 /* Point to next row */ 3427 3428 AcpiOsPrintf ("\n"); 3429 Row += Localities; 3430 } 3431 } 3432 3433 3434 /******************************************************************************* 3435 * 3436 * FUNCTION: AcpiDmDumpSrat 3437 * 3438 * PARAMETERS: Table - A SRAT table 3439 * 3440 * RETURN: None 3441 * 3442 * DESCRIPTION: Format the contents of a SRAT 3443 * 3444 ******************************************************************************/ 3445 3446 void 3447 AcpiDmDumpSrat ( 3448 ACPI_TABLE_HEADER *Table) 3449 { 3450 ACPI_STATUS Status; 3451 UINT32 Offset = sizeof (ACPI_TABLE_SRAT); 3452 ACPI_SUBTABLE_HEADER *SubTable; 3453 ACPI_DMTABLE_INFO *InfoTable; 3454 3455 3456 /* Main table */ 3457 3458 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat); 3459 if (ACPI_FAILURE (Status)) 3460 { 3461 return; 3462 } 3463 3464 /* Subtables */ 3465 3466 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 3467 while (Offset < Table->Length) 3468 { 3469 /* Common subtable header */ 3470 3471 AcpiOsPrintf ("\n"); 3472 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3473 SubTable->Length, AcpiDmTableInfoSratHdr); 3474 if (ACPI_FAILURE (Status)) 3475 { 3476 return; 3477 } 3478 3479 switch (SubTable->Type) 3480 { 3481 case ACPI_SRAT_TYPE_CPU_AFFINITY: 3482 3483 InfoTable = AcpiDmTableInfoSrat0; 3484 break; 3485 3486 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 3487 3488 InfoTable = AcpiDmTableInfoSrat1; 3489 break; 3490 3491 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 3492 3493 InfoTable = AcpiDmTableInfoSrat2; 3494 break; 3495 3496 case ACPI_SRAT_TYPE_GICC_AFFINITY: 3497 3498 InfoTable = AcpiDmTableInfoSrat3; 3499 break; 3500 3501 default: 3502 AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n", 3503 SubTable->Type); 3504 3505 /* Attempt to continue */ 3506 3507 if (!SubTable->Length) 3508 { 3509 AcpiOsPrintf ("Invalid zero length subtable\n"); 3510 return; 3511 } 3512 goto NextSubTable; 3513 } 3514 3515 AcpiOsPrintf ("\n"); 3516 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3517 SubTable->Length, InfoTable); 3518 if (ACPI_FAILURE (Status)) 3519 { 3520 return; 3521 } 3522 3523 NextSubTable: 3524 /* Point to next subtable */ 3525 3526 Offset += SubTable->Length; 3527 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, 3528 SubTable->Length); 3529 } 3530 } 3531 3532 3533 /******************************************************************************* 3534 * 3535 * FUNCTION: AcpiDmDumpStao 3536 * 3537 * PARAMETERS: Table - A STAO table 3538 * 3539 * RETURN: None 3540 * 3541 * DESCRIPTION: Format the contents of a STAO. This is a variable-length 3542 * table that contains an open-ended number of ASCII strings 3543 * at the end of the table. 3544 * 3545 ******************************************************************************/ 3546 3547 void 3548 AcpiDmDumpStao ( 3549 ACPI_TABLE_HEADER *Table) 3550 { 3551 ACPI_STATUS Status; 3552 char *Namepath; 3553 UINT32 Length = Table->Length; 3554 UINT32 StringLength; 3555 UINT32 Offset = sizeof (ACPI_TABLE_STAO); 3556 3557 3558 /* Main table */ 3559 3560 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoStao); 3561 if (ACPI_FAILURE (Status)) 3562 { 3563 return; 3564 } 3565 3566 /* The rest of the table consists of Namepath strings */ 3567 3568 while (Offset < Table->Length) 3569 { 3570 Namepath = ACPI_ADD_PTR (char, Table, Offset); 3571 StringLength = strlen (Namepath) + 1; 3572 3573 AcpiDmLineHeader (Offset, StringLength, "Namestring"); 3574 AcpiOsPrintf ("\"%s\"\n", Namepath); 3575 3576 /* Point to next namepath */ 3577 3578 Offset += StringLength; 3579 } 3580 } 3581 3582 3583 /******************************************************************************* 3584 * 3585 * FUNCTION: AcpiDmDumpTcpa 3586 * 3587 * PARAMETERS: Table - A TCPA table 3588 * 3589 * RETURN: None 3590 * 3591 * DESCRIPTION: Format the contents of a TCPA. 3592 * 3593 * NOTE: There are two versions of the table with the same signature: 3594 * the client version and the server version. The common 3595 * PlatformClass field is used to differentiate the two types of 3596 * tables. 3597 * 3598 ******************************************************************************/ 3599 3600 void 3601 AcpiDmDumpTcpa ( 3602 ACPI_TABLE_HEADER *Table) 3603 { 3604 UINT32 Offset = sizeof (ACPI_TABLE_TCPA_HDR); 3605 ACPI_TABLE_TCPA_HDR *CommonHeader = ACPI_CAST_PTR ( 3606 ACPI_TABLE_TCPA_HDR, Table); 3607 ACPI_TABLE_TCPA_HDR *SubTable = ACPI_ADD_PTR ( 3608 ACPI_TABLE_TCPA_HDR, Table, Offset); 3609 ACPI_STATUS Status; 3610 3611 3612 /* Main table */ 3613 3614 Status = AcpiDmDumpTable (Table->Length, 0, Table, 3615 0, AcpiDmTableInfoTcpaHdr); 3616 if (ACPI_FAILURE (Status)) 3617 { 3618 return; 3619 } 3620 3621 /* 3622 * Examine the PlatformClass field to determine the table type. 3623 * Either a client or server table. Only one. 3624 */ 3625 switch (CommonHeader->PlatformClass) 3626 { 3627 case ACPI_TCPA_CLIENT_TABLE: 3628 3629 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3630 Table->Length - Offset, AcpiDmTableInfoTcpaClient); 3631 break; 3632 3633 case ACPI_TCPA_SERVER_TABLE: 3634 3635 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3636 Table->Length - Offset, AcpiDmTableInfoTcpaServer); 3637 break; 3638 3639 default: 3640 3641 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n", 3642 CommonHeader->PlatformClass); 3643 Status = AE_ERROR; 3644 break; 3645 } 3646 3647 if (ACPI_FAILURE (Status)) 3648 { 3649 AcpiOsPrintf ("\n**** Cannot disassemble TCPA table\n"); 3650 } 3651 } 3652 3653 3654 /******************************************************************************* 3655 * 3656 * FUNCTION: AcpiDmDumpVrtc 3657 * 3658 * PARAMETERS: Table - A VRTC table 3659 * 3660 * RETURN: None 3661 * 3662 * DESCRIPTION: Format the contents of a VRTC 3663 * 3664 ******************************************************************************/ 3665 3666 void 3667 AcpiDmDumpVrtc ( 3668 ACPI_TABLE_HEADER *Table) 3669 { 3670 ACPI_STATUS Status; 3671 UINT32 Offset = sizeof (ACPI_TABLE_VRTC); 3672 ACPI_VRTC_ENTRY *SubTable; 3673 3674 3675 /* Main table */ 3676 3677 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc); 3678 if (ACPI_FAILURE (Status)) 3679 { 3680 return; 3681 } 3682 3683 /* Subtables */ 3684 3685 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset); 3686 while (Offset < Table->Length) 3687 { 3688 /* Common subtable header */ 3689 3690 AcpiOsPrintf ("\n"); 3691 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3692 sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0); 3693 if (ACPI_FAILURE (Status)) 3694 { 3695 return; 3696 } 3697 3698 /* Point to next subtable */ 3699 3700 Offset += sizeof (ACPI_VRTC_ENTRY); 3701 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable, 3702 sizeof (ACPI_VRTC_ENTRY)); 3703 } 3704 } 3705 3706 3707 /******************************************************************************* 3708 * 3709 * FUNCTION: AcpiDmDumpWdat 3710 * 3711 * PARAMETERS: Table - A WDAT table 3712 * 3713 * RETURN: None 3714 * 3715 * DESCRIPTION: Format the contents of a WDAT 3716 * 3717 ******************************************************************************/ 3718 3719 void 3720 AcpiDmDumpWdat ( 3721 ACPI_TABLE_HEADER *Table) 3722 { 3723 ACPI_STATUS Status; 3724 UINT32 Offset = sizeof (ACPI_TABLE_WDAT); 3725 ACPI_WDAT_ENTRY *SubTable; 3726 3727 3728 /* Main table */ 3729 3730 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat); 3731 if (ACPI_FAILURE (Status)) 3732 { 3733 return; 3734 } 3735 3736 /* Subtables */ 3737 3738 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset); 3739 while (Offset < Table->Length) 3740 { 3741 /* Common subtable header */ 3742 3743 AcpiOsPrintf ("\n"); 3744 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3745 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0); 3746 if (ACPI_FAILURE (Status)) 3747 { 3748 return; 3749 } 3750 3751 /* Point to next subtable */ 3752 3753 Offset += sizeof (ACPI_WDAT_ENTRY); 3754 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, 3755 sizeof (ACPI_WDAT_ENTRY)); 3756 } 3757 } 3758 3759 3760 /******************************************************************************* 3761 * 3762 * FUNCTION: AcpiDmDumpWpbt 3763 * 3764 * PARAMETERS: Table - A WPBT table 3765 * 3766 * RETURN: None 3767 * 3768 * DESCRIPTION: Format the contents of a WPBT. This table type consists 3769 * of an open-ended arguments buffer at the end of the table. 3770 * 3771 ******************************************************************************/ 3772 3773 void 3774 AcpiDmDumpWpbt ( 3775 ACPI_TABLE_HEADER *Table) 3776 { 3777 ACPI_STATUS Status; 3778 ACPI_TABLE_WPBT *SubTable; 3779 UINT32 Length = Table->Length; 3780 UINT16 ArgumentsLength; 3781 3782 3783 /* Dump the main table */ 3784 3785 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt); 3786 if (ACPI_FAILURE (Status)) 3787 { 3788 return; 3789 } 3790 3791 /* Extract the arguments buffer length from the main table */ 3792 3793 SubTable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table); 3794 ArgumentsLength = SubTable->ArgumentsLength; 3795 3796 /* Dump the arguments buffer */ 3797 3798 (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength, 3799 AcpiDmTableInfoWpbt0); 3800 } 3801