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