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