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