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