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