dmtbdump2.c revision 1.1.1.3
1 /****************************************************************************** 2 * 3 * Module Name: dmtbdump2 - Dump ACPI data tables that contain no AML code 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2019, 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 ("dmtbdump2") 53 54 55 /******************************************************************************* 56 * 57 * FUNCTION: AcpiDmDumpIort 58 * 59 * PARAMETERS: Table - A IORT table 60 * 61 * RETURN: None 62 * 63 * DESCRIPTION: Format the contents of a IORT 64 * 65 ******************************************************************************/ 66 67 void 68 AcpiDmDumpIort ( 69 ACPI_TABLE_HEADER *Table) 70 { 71 ACPI_STATUS Status; 72 ACPI_TABLE_IORT *Iort; 73 ACPI_IORT_NODE *IortNode; 74 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL; 75 ACPI_IORT_SMMU *IortSmmu = NULL; 76 UINT32 Offset; 77 UINT32 NodeOffset; 78 UINT32 Length; 79 ACPI_DMTABLE_INFO *InfoTable; 80 char *String; 81 UINT32 i; 82 83 84 /* Main table */ 85 86 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort); 87 if (ACPI_FAILURE (Status)) 88 { 89 return; 90 } 91 92 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table); 93 Offset = sizeof (ACPI_TABLE_IORT); 94 95 /* Dump the OptionalPadding (optional) */ 96 97 if (Iort->NodeOffset > Offset) 98 { 99 Status = AcpiDmDumpTable (Table->Length, Offset, Table, 100 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad); 101 if (ACPI_FAILURE (Status)) 102 { 103 return; 104 } 105 } 106 107 Offset = Iort->NodeOffset; 108 while (Offset < Table->Length) 109 { 110 /* Common subtable header */ 111 112 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset); 113 AcpiOsPrintf ("\n"); 114 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData); 115 Status = AcpiDmDumpTable (Table->Length, Offset, 116 IortNode, Length, AcpiDmTableInfoIortHdr); 117 if (ACPI_FAILURE (Status)) 118 { 119 return; 120 } 121 122 NodeOffset = Length; 123 124 switch (IortNode->Type) 125 { 126 case ACPI_IORT_NODE_ITS_GROUP: 127 128 InfoTable = AcpiDmTableInfoIort0; 129 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers); 130 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset); 131 break; 132 133 case ACPI_IORT_NODE_NAMED_COMPONENT: 134 135 InfoTable = AcpiDmTableInfoIort1; 136 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName); 137 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length); 138 Length += strlen (String) + 1; 139 break; 140 141 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX: 142 143 InfoTable = AcpiDmTableInfoIort2; 144 Length = IortNode->Length - NodeOffset; 145 break; 146 147 case ACPI_IORT_NODE_SMMU: 148 149 InfoTable = AcpiDmTableInfoIort3; 150 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts); 151 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset); 152 break; 153 154 case ACPI_IORT_NODE_SMMU_V3: 155 156 InfoTable = AcpiDmTableInfoIort4; 157 Length = IortNode->Length - NodeOffset; 158 break; 159 160 case ACPI_IORT_NODE_PMCG: 161 162 InfoTable = AcpiDmTableInfoIort5; 163 Length = IortNode->Length - NodeOffset; 164 break; 165 166 default: 167 168 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n", 169 IortNode->Type); 170 171 /* Attempt to continue */ 172 173 if (!IortNode->Length) 174 { 175 AcpiOsPrintf ("Invalid zero length IORT node\n"); 176 return; 177 } 178 goto NextSubtable; 179 } 180 181 /* Dump the node subtable header */ 182 183 AcpiOsPrintf ("\n"); 184 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 185 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 186 Length, InfoTable); 187 if (ACPI_FAILURE (Status)) 188 { 189 return; 190 } 191 192 NodeOffset += Length; 193 194 /* Dump the node specific data */ 195 196 switch (IortNode->Type) 197 { 198 case ACPI_IORT_NODE_ITS_GROUP: 199 200 /* Validate IortItsGroup to avoid compiler warnings */ 201 202 if (IortItsGroup) 203 { 204 for (i = 0; i < IortItsGroup->ItsCount; i++) 205 { 206 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 207 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 208 4, AcpiDmTableInfoIort0a); 209 NodeOffset += 4; 210 } 211 } 212 break; 213 214 case ACPI_IORT_NODE_NAMED_COMPONENT: 215 216 /* Dump the Padding (optional) */ 217 218 if (IortNode->Length > NodeOffset) 219 { 220 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 221 Table, IortNode->Length - NodeOffset, 222 AcpiDmTableInfoIort1a); 223 if (ACPI_FAILURE (Status)) 224 { 225 return; 226 } 227 } 228 break; 229 230 case ACPI_IORT_NODE_SMMU: 231 232 AcpiOsPrintf ("\n"); 233 234 /* Validate IortSmmu to avoid compiler warnings */ 235 236 if (IortSmmu) 237 { 238 Length = 2 * sizeof (UINT64); 239 NodeOffset = IortSmmu->GlobalInterruptOffset; 240 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 241 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 242 Length, AcpiDmTableInfoIort3a); 243 if (ACPI_FAILURE (Status)) 244 { 245 return; 246 } 247 248 NodeOffset = IortSmmu->ContextInterruptOffset; 249 for (i = 0; i < IortSmmu->ContextInterruptCount; i++) 250 { 251 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 252 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 253 8, AcpiDmTableInfoIort3b); 254 if (ACPI_FAILURE (Status)) 255 { 256 return; 257 } 258 259 NodeOffset += 8; 260 } 261 262 NodeOffset = IortSmmu->PmuInterruptOffset; 263 for (i = 0; i < IortSmmu->PmuInterruptCount; i++) 264 { 265 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 266 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 267 8, AcpiDmTableInfoIort3c); 268 if (ACPI_FAILURE (Status)) 269 { 270 return; 271 } 272 273 NodeOffset += 8; 274 } 275 } 276 break; 277 278 default: 279 280 break; 281 } 282 283 /* Dump the ID mappings */ 284 285 NodeOffset = IortNode->MappingOffset; 286 for (i = 0; i < IortNode->MappingCount; i++) 287 { 288 AcpiOsPrintf ("\n"); 289 Length = sizeof (ACPI_IORT_ID_MAPPING); 290 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 291 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 292 Length, AcpiDmTableInfoIortMap); 293 if (ACPI_FAILURE (Status)) 294 { 295 return; 296 } 297 298 NodeOffset += Length; 299 } 300 301 NextSubtable: 302 /* Point to next node subtable */ 303 304 Offset += IortNode->Length; 305 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length); 306 } 307 } 308 309 310 /******************************************************************************* 311 * 312 * FUNCTION: AcpiDmDumpIvrs 313 * 314 * PARAMETERS: Table - A IVRS table 315 * 316 * RETURN: None 317 * 318 * DESCRIPTION: Format the contents of a IVRS 319 * 320 ******************************************************************************/ 321 322 static UINT8 EntrySizes[] = {4,8,16,32}; 323 324 void 325 AcpiDmDumpIvrs ( 326 ACPI_TABLE_HEADER *Table) 327 { 328 ACPI_STATUS Status; 329 UINT32 Offset = sizeof (ACPI_TABLE_IVRS); 330 UINT32 EntryOffset; 331 UINT32 EntryLength; 332 UINT32 EntryType; 333 ACPI_IVRS_DE_HEADER *DeviceEntry; 334 ACPI_IVRS_HEADER *Subtable; 335 ACPI_DMTABLE_INFO *InfoTable; 336 337 338 /* Main table */ 339 340 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); 341 if (ACPI_FAILURE (Status)) 342 { 343 return; 344 } 345 346 /* Subtables */ 347 348 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); 349 while (Offset < Table->Length) 350 { 351 /* Common subtable header */ 352 353 AcpiOsPrintf ("\n"); 354 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 355 Subtable->Length, AcpiDmTableInfoIvrsHdr); 356 if (ACPI_FAILURE (Status)) 357 { 358 return; 359 } 360 361 switch (Subtable->Type) 362 { 363 case ACPI_IVRS_TYPE_HARDWARE: 364 365 InfoTable = AcpiDmTableInfoIvrs0; 366 break; 367 368 case ACPI_IVRS_TYPE_MEMORY1: 369 case ACPI_IVRS_TYPE_MEMORY2: 370 case ACPI_IVRS_TYPE_MEMORY3: 371 372 InfoTable = AcpiDmTableInfoIvrs1; 373 break; 374 375 default: 376 377 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n", 378 Subtable->Type); 379 380 /* Attempt to continue */ 381 382 if (!Subtable->Length) 383 { 384 AcpiOsPrintf ("Invalid zero length subtable\n"); 385 return; 386 } 387 goto NextSubtable; 388 } 389 390 /* Dump the subtable */ 391 392 AcpiOsPrintf ("\n"); 393 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 394 Subtable->Length, InfoTable); 395 if (ACPI_FAILURE (Status)) 396 { 397 return; 398 } 399 400 /* The hardware subtable can contain multiple device entries */ 401 402 if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE) 403 { 404 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE); 405 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable, 406 sizeof (ACPI_IVRS_HARDWARE)); 407 408 while (EntryOffset < (Offset + Subtable->Length)) 409 { 410 AcpiOsPrintf ("\n"); 411 /* 412 * Upper 2 bits of Type encode the length of the device entry 413 * 414 * 00 = 4 byte 415 * 01 = 8 byte 416 * 10 = 16 byte - currently no entries defined 417 * 11 = 32 byte - currently no entries defined 418 */ 419 EntryType = DeviceEntry->Type; 420 EntryLength = EntrySizes [EntryType >> 6]; 421 422 switch (EntryType) 423 { 424 /* 4-byte device entries */ 425 426 case ACPI_IVRS_TYPE_PAD4: 427 case ACPI_IVRS_TYPE_ALL: 428 case ACPI_IVRS_TYPE_SELECT: 429 case ACPI_IVRS_TYPE_START: 430 case ACPI_IVRS_TYPE_END: 431 432 InfoTable = AcpiDmTableInfoIvrs4; 433 break; 434 435 /* 8-byte entries, type A */ 436 437 case ACPI_IVRS_TYPE_ALIAS_SELECT: 438 case ACPI_IVRS_TYPE_ALIAS_START: 439 440 InfoTable = AcpiDmTableInfoIvrs8a; 441 break; 442 443 /* 8-byte entries, type B */ 444 445 case ACPI_IVRS_TYPE_PAD8: 446 case ACPI_IVRS_TYPE_EXT_SELECT: 447 case ACPI_IVRS_TYPE_EXT_START: 448 449 InfoTable = AcpiDmTableInfoIvrs8b; 450 break; 451 452 /* 8-byte entries, type C */ 453 454 case ACPI_IVRS_TYPE_SPECIAL: 455 456 InfoTable = AcpiDmTableInfoIvrs8c; 457 break; 458 459 default: 460 InfoTable = AcpiDmTableInfoIvrs4; 461 AcpiOsPrintf ( 462 "\n**** Unknown IVRS device entry type/length: " 463 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n", 464 EntryType, EntryLength, EntryOffset); 465 break; 466 } 467 468 /* Dump the Device Entry */ 469 470 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 471 DeviceEntry, EntryLength, InfoTable); 472 if (ACPI_FAILURE (Status)) 473 { 474 return; 475 } 476 477 EntryOffset += EntryLength; 478 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry, 479 EntryLength); 480 } 481 } 482 483 NextSubtable: 484 /* Point to next subtable */ 485 486 Offset += Subtable->Length; 487 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Subtable, Subtable->Length); 488 } 489 } 490 491 492 /******************************************************************************* 493 * 494 * FUNCTION: AcpiDmDumpLpit 495 * 496 * PARAMETERS: Table - A LPIT table 497 * 498 * RETURN: None 499 * 500 * DESCRIPTION: Format the contents of a LPIT. This table type consists 501 * of an open-ended number of subtables. Note: There are no 502 * entries in the main table. An LPIT consists of the table 503 * header and then subtables only. 504 * 505 ******************************************************************************/ 506 507 void 508 AcpiDmDumpLpit ( 509 ACPI_TABLE_HEADER *Table) 510 { 511 ACPI_STATUS Status; 512 ACPI_LPIT_HEADER *Subtable; 513 UINT32 Length = Table->Length; 514 UINT32 Offset = sizeof (ACPI_TABLE_LPIT); 515 ACPI_DMTABLE_INFO *InfoTable; 516 UINT32 SubtableLength; 517 518 519 /* Subtables */ 520 521 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset); 522 while (Offset < Table->Length) 523 { 524 /* Common subtable header */ 525 526 Status = AcpiDmDumpTable (Length, Offset, Subtable, 527 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr); 528 if (ACPI_FAILURE (Status)) 529 { 530 return; 531 } 532 533 switch (Subtable->Type) 534 { 535 case ACPI_LPIT_TYPE_NATIVE_CSTATE: 536 537 InfoTable = AcpiDmTableInfoLpit0; 538 SubtableLength = sizeof (ACPI_LPIT_NATIVE); 539 break; 540 541 default: 542 543 /* Cannot continue on unknown type - no length */ 544 545 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n", 546 Subtable->Type); 547 return; 548 } 549 550 Status = AcpiDmDumpTable (Length, Offset, Subtable, 551 SubtableLength, InfoTable); 552 if (ACPI_FAILURE (Status)) 553 { 554 return; 555 } 556 557 AcpiOsPrintf ("\n"); 558 559 /* Point to next subtable */ 560 561 Offset += SubtableLength; 562 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Subtable, SubtableLength); 563 } 564 } 565 566 567 /******************************************************************************* 568 * 569 * FUNCTION: AcpiDmDumpMadt 570 * 571 * PARAMETERS: Table - A MADT table 572 * 573 * RETURN: None 574 * 575 * DESCRIPTION: Format the contents of a MADT. This table type consists 576 * of an open-ended number of subtables. 577 * 578 ******************************************************************************/ 579 580 void 581 AcpiDmDumpMadt ( 582 ACPI_TABLE_HEADER *Table) 583 { 584 ACPI_STATUS Status; 585 ACPI_SUBTABLE_HEADER *Subtable; 586 UINT32 Length = Table->Length; 587 UINT32 Offset = sizeof (ACPI_TABLE_MADT); 588 ACPI_DMTABLE_INFO *InfoTable; 589 590 591 /* Main table */ 592 593 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); 594 if (ACPI_FAILURE (Status)) 595 { 596 return; 597 } 598 599 /* Subtables */ 600 601 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 602 while (Offset < Table->Length) 603 { 604 /* Common subtable header */ 605 606 AcpiOsPrintf ("\n"); 607 Status = AcpiDmDumpTable (Length, Offset, Subtable, 608 Subtable->Length, AcpiDmTableInfoMadtHdr); 609 if (ACPI_FAILURE (Status)) 610 { 611 return; 612 } 613 614 switch (Subtable->Type) 615 { 616 case ACPI_MADT_TYPE_LOCAL_APIC: 617 618 InfoTable = AcpiDmTableInfoMadt0; 619 break; 620 621 case ACPI_MADT_TYPE_IO_APIC: 622 623 InfoTable = AcpiDmTableInfoMadt1; 624 break; 625 626 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 627 628 InfoTable = AcpiDmTableInfoMadt2; 629 break; 630 631 case ACPI_MADT_TYPE_NMI_SOURCE: 632 633 InfoTable = AcpiDmTableInfoMadt3; 634 break; 635 636 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 637 638 InfoTable = AcpiDmTableInfoMadt4; 639 break; 640 641 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 642 643 InfoTable = AcpiDmTableInfoMadt5; 644 break; 645 646 case ACPI_MADT_TYPE_IO_SAPIC: 647 648 InfoTable = AcpiDmTableInfoMadt6; 649 break; 650 651 case ACPI_MADT_TYPE_LOCAL_SAPIC: 652 653 InfoTable = AcpiDmTableInfoMadt7; 654 break; 655 656 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 657 658 InfoTable = AcpiDmTableInfoMadt8; 659 break; 660 661 case ACPI_MADT_TYPE_LOCAL_X2APIC: 662 663 InfoTable = AcpiDmTableInfoMadt9; 664 break; 665 666 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 667 668 InfoTable = AcpiDmTableInfoMadt10; 669 break; 670 671 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 672 673 InfoTable = AcpiDmTableInfoMadt11; 674 break; 675 676 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 677 678 InfoTable = AcpiDmTableInfoMadt12; 679 break; 680 681 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME: 682 683 InfoTable = AcpiDmTableInfoMadt13; 684 break; 685 686 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR: 687 688 InfoTable = AcpiDmTableInfoMadt14; 689 break; 690 691 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR: 692 693 InfoTable = AcpiDmTableInfoMadt15; 694 break; 695 696 default: 697 698 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n", 699 Subtable->Type); 700 701 /* Attempt to continue */ 702 703 if (!Subtable->Length) 704 { 705 AcpiOsPrintf ("Invalid zero length subtable\n"); 706 return; 707 } 708 709 goto NextSubtable; 710 } 711 712 Status = AcpiDmDumpTable (Length, Offset, Subtable, 713 Subtable->Length, InfoTable); 714 if (ACPI_FAILURE (Status)) 715 { 716 return; 717 } 718 719 NextSubtable: 720 /* Point to next subtable */ 721 722 Offset += Subtable->Length; 723 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, 724 Subtable->Length); 725 } 726 } 727 728 729 /******************************************************************************* 730 * 731 * FUNCTION: AcpiDmDumpMcfg 732 * 733 * PARAMETERS: Table - A MCFG Table 734 * 735 * RETURN: None 736 * 737 * DESCRIPTION: Format the contents of a MCFG table 738 * 739 ******************************************************************************/ 740 741 void 742 AcpiDmDumpMcfg ( 743 ACPI_TABLE_HEADER *Table) 744 { 745 ACPI_STATUS Status; 746 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 747 ACPI_MCFG_ALLOCATION *Subtable; 748 749 750 /* Main table */ 751 752 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 753 if (ACPI_FAILURE (Status)) 754 { 755 return; 756 } 757 758 /* Subtables */ 759 760 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 761 while (Offset < Table->Length) 762 { 763 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 764 { 765 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", 766 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 767 return; 768 } 769 770 AcpiOsPrintf ("\n"); 771 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 772 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 773 if (ACPI_FAILURE (Status)) 774 { 775 return; 776 } 777 778 /* Point to next subtable (each subtable is of fixed length) */ 779 780 Offset += sizeof (ACPI_MCFG_ALLOCATION); 781 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Subtable, 782 sizeof (ACPI_MCFG_ALLOCATION)); 783 } 784 } 785 786 787 /******************************************************************************* 788 * 789 * FUNCTION: AcpiDmDumpMpst 790 * 791 * PARAMETERS: Table - A MPST Table 792 * 793 * RETURN: None 794 * 795 * DESCRIPTION: Format the contents of a MPST table 796 * 797 ******************************************************************************/ 798 799 void 800 AcpiDmDumpMpst ( 801 ACPI_TABLE_HEADER *Table) 802 { 803 ACPI_STATUS Status; 804 UINT32 Offset = sizeof (ACPI_TABLE_MPST); 805 ACPI_MPST_POWER_NODE *Subtable0; 806 ACPI_MPST_POWER_STATE *Subtable0A; 807 ACPI_MPST_COMPONENT *Subtable0B; 808 ACPI_MPST_DATA_HDR *Subtable1; 809 ACPI_MPST_POWER_DATA *Subtable2; 810 UINT16 SubtableCount; 811 UINT32 PowerStateCount; 812 UINT32 ComponentCount; 813 814 815 /* Main table */ 816 817 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); 818 if (ACPI_FAILURE (Status)) 819 { 820 return; 821 } 822 823 /* Subtable: Memory Power Node(s) */ 824 825 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; 826 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); 827 828 while ((Offset < Table->Length) && SubtableCount) 829 { 830 AcpiOsPrintf ("\n"); 831 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0, 832 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); 833 if (ACPI_FAILURE (Status)) 834 { 835 return; 836 } 837 838 /* Extract the sub-subtable counts */ 839 840 PowerStateCount = Subtable0->NumPowerStates; 841 ComponentCount = Subtable0->NumPhysicalComponents; 842 Offset += sizeof (ACPI_MPST_POWER_NODE); 843 844 /* Sub-subtables - Memory Power State Structure(s) */ 845 846 Subtable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, Subtable0, 847 sizeof (ACPI_MPST_POWER_NODE)); 848 849 while (PowerStateCount) 850 { 851 AcpiOsPrintf ("\n"); 852 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0A, 853 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); 854 if (ACPI_FAILURE (Status)) 855 { 856 return; 857 } 858 859 Subtable0A++; 860 PowerStateCount--; 861 Offset += sizeof (ACPI_MPST_POWER_STATE); 862 } 863 864 /* Sub-subtables - Physical Component ID Structure(s) */ 865 866 Subtable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, Subtable0A); 867 868 if (ComponentCount) 869 { 870 AcpiOsPrintf ("\n"); 871 } 872 873 while (ComponentCount) 874 { 875 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0B, 876 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); 877 if (ACPI_FAILURE (Status)) 878 { 879 return; 880 } 881 882 Subtable0B++; 883 ComponentCount--; 884 Offset += sizeof (ACPI_MPST_COMPONENT); 885 } 886 887 /* Point to next Memory Power Node subtable */ 888 889 SubtableCount--; 890 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Subtable0, 891 sizeof (ACPI_MPST_POWER_NODE) + 892 (sizeof (ACPI_MPST_POWER_STATE) * Subtable0->NumPowerStates) + 893 (sizeof (ACPI_MPST_COMPONENT) * Subtable0->NumPhysicalComponents)); 894 } 895 896 /* Subtable: Count of Memory Power State Characteristic structures */ 897 898 AcpiOsPrintf ("\n"); 899 Subtable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable0); 900 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable1, 901 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); 902 if (ACPI_FAILURE (Status)) 903 { 904 return; 905 } 906 907 SubtableCount = Subtable1->CharacteristicsCount; 908 Offset += sizeof (ACPI_MPST_DATA_HDR); 909 910 /* Subtable: Memory Power State Characteristics structure(s) */ 911 912 Subtable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, Subtable1, 913 sizeof (ACPI_MPST_DATA_HDR)); 914 915 while ((Offset < Table->Length) && SubtableCount) 916 { 917 AcpiOsPrintf ("\n"); 918 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable2, 919 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); 920 if (ACPI_FAILURE (Status)) 921 { 922 return; 923 } 924 925 Subtable2++; 926 SubtableCount--; 927 Offset += sizeof (ACPI_MPST_POWER_DATA); 928 } 929 } 930 931 932 /******************************************************************************* 933 * 934 * FUNCTION: AcpiDmDumpMsct 935 * 936 * PARAMETERS: Table - A MSCT table 937 * 938 * RETURN: None 939 * 940 * DESCRIPTION: Format the contents of a MSCT 941 * 942 ******************************************************************************/ 943 944 void 945 AcpiDmDumpMsct ( 946 ACPI_TABLE_HEADER *Table) 947 { 948 ACPI_STATUS Status; 949 UINT32 Offset = sizeof (ACPI_TABLE_MSCT); 950 ACPI_MSCT_PROXIMITY *Subtable; 951 952 953 /* Main table */ 954 955 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); 956 if (ACPI_FAILURE (Status)) 957 { 958 return; 959 } 960 961 /* Subtables */ 962 963 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); 964 while (Offset < Table->Length) 965 { 966 /* Common subtable header */ 967 968 AcpiOsPrintf ("\n"); 969 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 970 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); 971 if (ACPI_FAILURE (Status)) 972 { 973 return; 974 } 975 976 /* Point to next subtable */ 977 978 Offset += sizeof (ACPI_MSCT_PROXIMITY); 979 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Subtable, 980 sizeof (ACPI_MSCT_PROXIMITY)); 981 } 982 } 983 984 985 /******************************************************************************* 986 * 987 * FUNCTION: AcpiDmDumpMtmr 988 * 989 * PARAMETERS: Table - A MTMR table 990 * 991 * RETURN: None 992 * 993 * DESCRIPTION: Format the contents of a MTMR 994 * 995 ******************************************************************************/ 996 997 void 998 AcpiDmDumpMtmr ( 999 ACPI_TABLE_HEADER *Table) 1000 { 1001 ACPI_STATUS Status; 1002 UINT32 Offset = sizeof (ACPI_TABLE_MTMR); 1003 ACPI_MTMR_ENTRY *Subtable; 1004 1005 1006 /* Main table */ 1007 1008 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr); 1009 if (ACPI_FAILURE (Status)) 1010 { 1011 return; 1012 } 1013 1014 /* Subtables */ 1015 1016 Subtable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset); 1017 while (Offset < Table->Length) 1018 { 1019 /* Common subtable header */ 1020 1021 AcpiOsPrintf ("\n"); 1022 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1023 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0); 1024 if (ACPI_FAILURE (Status)) 1025 { 1026 return; 1027 } 1028 1029 /* Point to next subtable */ 1030 1031 Offset += sizeof (ACPI_MTMR_ENTRY); 1032 Subtable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Subtable, 1033 sizeof (ACPI_MTMR_ENTRY)); 1034 } 1035 } 1036 1037 1038 /******************************************************************************* 1039 * 1040 * FUNCTION: AcpiDmDumpNfit 1041 * 1042 * PARAMETERS: Table - A NFIT table 1043 * 1044 * RETURN: None 1045 * 1046 * DESCRIPTION: Format the contents of an NFIT. 1047 * 1048 ******************************************************************************/ 1049 1050 void 1051 AcpiDmDumpNfit ( 1052 ACPI_TABLE_HEADER *Table) 1053 { 1054 ACPI_STATUS Status; 1055 UINT32 Offset = sizeof (ACPI_TABLE_NFIT); 1056 UINT32 FieldOffset = 0; 1057 UINT32 Length; 1058 ACPI_NFIT_HEADER *Subtable; 1059 ACPI_DMTABLE_INFO *InfoTable; 1060 ACPI_NFIT_INTERLEAVE *Interleave = NULL; 1061 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL; 1062 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; 1063 UINT32 i; 1064 1065 1066 /* Main table */ 1067 1068 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit); 1069 if (ACPI_FAILURE (Status)) 1070 { 1071 return; 1072 } 1073 1074 /* Subtables */ 1075 1076 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset); 1077 while (Offset < Table->Length) 1078 { 1079 /* NFIT subtable header */ 1080 1081 AcpiOsPrintf ("\n"); 1082 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1083 Subtable->Length, AcpiDmTableInfoNfitHdr); 1084 if (ACPI_FAILURE (Status)) 1085 { 1086 return; 1087 } 1088 1089 switch (Subtable->Type) 1090 { 1091 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: 1092 1093 InfoTable = AcpiDmTableInfoNfit0; 1094 break; 1095 1096 case ACPI_NFIT_TYPE_MEMORY_MAP: 1097 1098 InfoTable = AcpiDmTableInfoNfit1; 1099 break; 1100 1101 case ACPI_NFIT_TYPE_INTERLEAVE: 1102 1103 /* Has a variable number of 32-bit values at the end */ 1104 1105 InfoTable = AcpiDmTableInfoNfit2; 1106 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable); 1107 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE); 1108 break; 1109 1110 case ACPI_NFIT_TYPE_SMBIOS: 1111 1112 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, Subtable); 1113 InfoTable = AcpiDmTableInfoNfit3; 1114 break; 1115 1116 case ACPI_NFIT_TYPE_CONTROL_REGION: 1117 1118 InfoTable = AcpiDmTableInfoNfit4; 1119 break; 1120 1121 case ACPI_NFIT_TYPE_DATA_REGION: 1122 1123 InfoTable = AcpiDmTableInfoNfit5; 1124 break; 1125 1126 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 1127 1128 /* Has a variable number of 64-bit addresses at the end */ 1129 1130 InfoTable = AcpiDmTableInfoNfit6; 1131 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable); 1132 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64); 1133 break; 1134 1135 case ACPI_NFIT_TYPE_CAPABILITIES: /* ACPI 6.0A */ 1136 1137 InfoTable = AcpiDmTableInfoNfit7; 1138 break; 1139 1140 default: 1141 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n", 1142 Subtable->Type); 1143 1144 /* Attempt to continue */ 1145 1146 if (!Subtable->Length) 1147 { 1148 AcpiOsPrintf ("Invalid zero length subtable\n"); 1149 return; 1150 } 1151 goto NextSubtable; 1152 } 1153 1154 AcpiOsPrintf ("\n"); 1155 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1156 Subtable->Length, InfoTable); 1157 if (ACPI_FAILURE (Status)) 1158 { 1159 return; 1160 } 1161 1162 /* Per-subtable variable-length fields */ 1163 1164 switch (Subtable->Type) 1165 { 1166 case ACPI_NFIT_TYPE_INTERLEAVE: 1167 1168 for (i = 0; i < Interleave->LineCount; i++) 1169 { 1170 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 1171 &Interleave->LineOffset[i], 1172 sizeof (UINT32), AcpiDmTableInfoNfit2a); 1173 if (ACPI_FAILURE (Status)) 1174 { 1175 return; 1176 } 1177 1178 FieldOffset += sizeof (UINT32); 1179 } 1180 break; 1181 1182 case ACPI_NFIT_TYPE_SMBIOS: 1183 1184 Length = Subtable->Length - 1185 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8); 1186 1187 if (Length) 1188 { 1189 Status = AcpiDmDumpTable (Table->Length, 1190 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8), 1191 SmbiosInfo, 1192 Length, AcpiDmTableInfoNfit3a); 1193 if (ACPI_FAILURE (Status)) 1194 { 1195 return; 1196 } 1197 } 1198 1199 break; 1200 1201 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 1202 1203 for (i = 0; i < Hint->HintCount; i++) 1204 { 1205 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 1206 &Hint->HintAddress[i], 1207 sizeof (UINT64), AcpiDmTableInfoNfit6a); 1208 if (ACPI_FAILURE (Status)) 1209 { 1210 return; 1211 } 1212 1213 FieldOffset += sizeof (UINT64); 1214 } 1215 break; 1216 1217 default: 1218 break; 1219 } 1220 1221 NextSubtable: 1222 /* Point to next subtable */ 1223 1224 Offset += Subtable->Length; 1225 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Subtable, Subtable->Length); 1226 } 1227 } 1228 1229 1230 /******************************************************************************* 1231 * 1232 * FUNCTION: AcpiDmDumpPcct 1233 * 1234 * PARAMETERS: Table - A PCCT table 1235 * 1236 * RETURN: None 1237 * 1238 * DESCRIPTION: Format the contents of a PCCT. This table type consists 1239 * of an open-ended number of subtables. 1240 * 1241 ******************************************************************************/ 1242 1243 void 1244 AcpiDmDumpPcct ( 1245 ACPI_TABLE_HEADER *Table) 1246 { 1247 ACPI_STATUS Status; 1248 ACPI_PCCT_SUBSPACE *Subtable; 1249 ACPI_DMTABLE_INFO *InfoTable; 1250 UINT32 Length = Table->Length; 1251 UINT32 Offset = sizeof (ACPI_TABLE_PCCT); 1252 1253 1254 /* Main table */ 1255 1256 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); 1257 if (ACPI_FAILURE (Status)) 1258 { 1259 return; 1260 } 1261 1262 /* Subtables */ 1263 1264 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); 1265 while (Offset < Table->Length) 1266 { 1267 /* Common subtable header */ 1268 1269 AcpiOsPrintf ("\n"); 1270 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1271 Subtable->Header.Length, AcpiDmTableInfoPcctHdr); 1272 if (ACPI_FAILURE (Status)) 1273 { 1274 return; 1275 } 1276 1277 switch (Subtable->Header.Type) 1278 { 1279 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: 1280 1281 InfoTable = AcpiDmTableInfoPcct0; 1282 break; 1283 1284 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: 1285 1286 InfoTable = AcpiDmTableInfoPcct1; 1287 break; 1288 1289 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2: 1290 1291 InfoTable = AcpiDmTableInfoPcct2; 1292 break; 1293 1294 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE: 1295 1296 InfoTable = AcpiDmTableInfoPcct3; 1297 break; 1298 1299 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE: 1300 1301 InfoTable = AcpiDmTableInfoPcct4; 1302 break; 1303 1304 default: 1305 1306 AcpiOsPrintf ( 1307 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n", 1308 Subtable->Header.Type); 1309 return; 1310 } 1311 1312 AcpiOsPrintf ("\n"); 1313 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1314 Subtable->Header.Length, InfoTable); 1315 if (ACPI_FAILURE (Status)) 1316 { 1317 return; 1318 } 1319 1320 /* Point to next subtable */ 1321 1322 Offset += Subtable->Header.Length; 1323 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Subtable, 1324 Subtable->Header.Length); 1325 } 1326 } 1327 1328 1329 /******************************************************************************* 1330 * 1331 * FUNCTION: AcpiDmDumpPdtt 1332 * 1333 * PARAMETERS: Table - A PDTT table 1334 * 1335 * RETURN: None 1336 * 1337 * DESCRIPTION: Format the contents of a Pdtt. This is a variable-length 1338 * table that contains an open-ended number of IDs 1339 * at the end of the table. 1340 * 1341 ******************************************************************************/ 1342 1343 void 1344 AcpiDmDumpPdtt ( 1345 ACPI_TABLE_HEADER *Table) 1346 { 1347 ACPI_STATUS Status; 1348 ACPI_PDTT_CHANNEL *Subtable; 1349 UINT32 Length = Table->Length; 1350 UINT32 Offset = sizeof (ACPI_TABLE_PDTT); 1351 1352 1353 /* Main table */ 1354 1355 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPdtt); 1356 if (ACPI_FAILURE (Status)) 1357 { 1358 return; 1359 } 1360 1361 /* Subtables. Currently there is only one type, but can be multiples */ 1362 1363 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Table, Offset); 1364 while (Offset < Table->Length) 1365 { 1366 AcpiOsPrintf ("\n"); 1367 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1368 sizeof (ACPI_PDTT_CHANNEL), AcpiDmTableInfoPdtt0); 1369 if (ACPI_FAILURE (Status)) 1370 { 1371 return; 1372 } 1373 1374 /* Point to next subtable */ 1375 1376 Offset += sizeof (ACPI_PDTT_CHANNEL); 1377 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Subtable, 1378 sizeof (ACPI_PDTT_CHANNEL)); 1379 } 1380 } 1381 1382 1383 /******************************************************************************* 1384 * 1385 * FUNCTION: AcpiDmDumpPmtt 1386 * 1387 * PARAMETERS: Table - A PMTT table 1388 * 1389 * RETURN: None 1390 * 1391 * DESCRIPTION: Format the contents of a PMTT. This table type consists 1392 * of an open-ended number of subtables. 1393 * 1394 ******************************************************************************/ 1395 1396 void 1397 AcpiDmDumpPmtt ( 1398 ACPI_TABLE_HEADER *Table) 1399 { 1400 ACPI_STATUS Status; 1401 ACPI_PMTT_HEADER *Subtable; 1402 ACPI_PMTT_HEADER *MemSubtable; 1403 ACPI_PMTT_HEADER *DimmSubtable; 1404 ACPI_PMTT_DOMAIN *DomainArray; 1405 UINT32 Length = Table->Length; 1406 UINT32 Offset = sizeof (ACPI_TABLE_PMTT); 1407 UINT32 MemOffset; 1408 UINT32 DimmOffset; 1409 UINT32 DomainOffset; 1410 UINT32 DomainCount; 1411 1412 1413 /* Main table */ 1414 1415 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); 1416 if (ACPI_FAILURE (Status)) 1417 { 1418 return; 1419 } 1420 1421 /* Subtables */ 1422 1423 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); 1424 while (Offset < Table->Length) 1425 { 1426 /* Common subtable header */ 1427 1428 AcpiOsPrintf ("\n"); 1429 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1430 Subtable->Length, AcpiDmTableInfoPmttHdr); 1431 if (ACPI_FAILURE (Status)) 1432 { 1433 return; 1434 } 1435 1436 /* Only Socket subtables are expected at this level */ 1437 1438 if (Subtable->Type != ACPI_PMTT_TYPE_SOCKET) 1439 { 1440 AcpiOsPrintf ( 1441 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 1442 Subtable->Type); 1443 return; 1444 } 1445 1446 /* Dump the fixed-length portion of the subtable */ 1447 1448 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1449 Subtable->Length, AcpiDmTableInfoPmtt0); 1450 if (ACPI_FAILURE (Status)) 1451 { 1452 return; 1453 } 1454 1455 /* Walk the memory controller subtables */ 1456 1457 MemOffset = sizeof (ACPI_PMTT_SOCKET); 1458 MemSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Subtable, 1459 sizeof (ACPI_PMTT_SOCKET)); 1460 1461 while (((Offset + MemOffset) < Table->Length) && 1462 (MemOffset < Subtable->Length)) 1463 { 1464 /* Common subtable header */ 1465 1466 AcpiOsPrintf ("\n"); 1467 Status = AcpiDmDumpTable (Length, 1468 Offset + MemOffset, MemSubtable, 1469 MemSubtable->Length, AcpiDmTableInfoPmttHdr); 1470 if (ACPI_FAILURE (Status)) 1471 { 1472 return; 1473 } 1474 1475 /* Only memory controller subtables are expected at this level */ 1476 1477 if (MemSubtable->Type != ACPI_PMTT_TYPE_CONTROLLER) 1478 { 1479 AcpiOsPrintf ( 1480 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 1481 MemSubtable->Type); 1482 return; 1483 } 1484 1485 /* Dump the fixed-length portion of the controller subtable */ 1486 1487 Status = AcpiDmDumpTable (Length, 1488 Offset + MemOffset, MemSubtable, 1489 MemSubtable->Length, AcpiDmTableInfoPmtt1); 1490 if (ACPI_FAILURE (Status)) 1491 { 1492 return; 1493 } 1494 1495 /* Walk the variable count of proximity domains */ 1496 1497 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubtable)->DomainCount; 1498 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER); 1499 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubtable, 1500 sizeof (ACPI_PMTT_CONTROLLER)); 1501 1502 while (((Offset + MemOffset + DomainOffset) < Table->Length) && 1503 ((MemOffset + DomainOffset) < Subtable->Length) && 1504 DomainCount) 1505 { 1506 Status = AcpiDmDumpTable (Length, 1507 Offset + MemOffset + DomainOffset, DomainArray, 1508 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a); 1509 if (ACPI_FAILURE (Status)) 1510 { 1511 return; 1512 } 1513 1514 DomainOffset += sizeof (ACPI_PMTT_DOMAIN); 1515 DomainArray++; 1516 DomainCount--; 1517 } 1518 1519 if (DomainCount) 1520 { 1521 AcpiOsPrintf ( 1522 "\n**** DomainCount exceeds subtable length\n\n"); 1523 } 1524 1525 /* Walk the physical component (DIMM) subtables */ 1526 1527 DimmOffset = DomainOffset; 1528 DimmSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubtable, 1529 DomainOffset); 1530 1531 while (((Offset + MemOffset + DimmOffset) < Table->Length) && 1532 (DimmOffset < MemSubtable->Length)) 1533 { 1534 /* Common subtable header */ 1535 1536 AcpiOsPrintf ("\n"); 1537 Status = AcpiDmDumpTable (Length, 1538 Offset + MemOffset + DimmOffset, DimmSubtable, 1539 DimmSubtable->Length, AcpiDmTableInfoPmttHdr); 1540 if (ACPI_FAILURE (Status)) 1541 { 1542 return; 1543 } 1544 1545 /* Only DIMM subtables are expected at this level */ 1546 1547 if (DimmSubtable->Type != ACPI_PMTT_TYPE_DIMM) 1548 { 1549 AcpiOsPrintf ( 1550 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 1551 DimmSubtable->Type); 1552 return; 1553 } 1554 1555 /* Dump the fixed-length DIMM subtable */ 1556 1557 Status = AcpiDmDumpTable (Length, 1558 Offset + MemOffset + DimmOffset, DimmSubtable, 1559 DimmSubtable->Length, AcpiDmTableInfoPmtt2); 1560 if (ACPI_FAILURE (Status)) 1561 { 1562 return; 1563 } 1564 1565 /* Point to next DIMM subtable */ 1566 1567 DimmOffset += DimmSubtable->Length; 1568 DimmSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 1569 DimmSubtable, DimmSubtable->Length); 1570 } 1571 1572 /* Point to next Controller subtable */ 1573 1574 MemOffset += MemSubtable->Length; 1575 MemSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 1576 MemSubtable, MemSubtable->Length); 1577 } 1578 1579 /* Point to next Socket subtable */ 1580 1581 Offset += Subtable->Length; 1582 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 1583 Subtable, Subtable->Length); 1584 } 1585 } 1586 1587 1588 /******************************************************************************* 1589 * 1590 * FUNCTION: AcpiDmDumpPptt 1591 * 1592 * PARAMETERS: Table - A PMTT table 1593 * 1594 * RETURN: None 1595 * 1596 * DESCRIPTION: Format the contents of a PPTT. This table type consists 1597 * of an open-ended number of subtables. 1598 * 1599 ******************************************************************************/ 1600 1601 void 1602 AcpiDmDumpPptt ( 1603 ACPI_TABLE_HEADER *Table) 1604 { 1605 ACPI_STATUS Status; 1606 ACPI_SUBTABLE_HEADER *Subtable; 1607 ACPI_PPTT_PROCESSOR *PpttProcessor; 1608 UINT8 Length; 1609 UINT8 SubtableOffset; 1610 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 1611 ACPI_DMTABLE_INFO *InfoTable; 1612 UINT32 i; 1613 1614 1615 /* There is no main table (other than the standard ACPI header) */ 1616 1617 /* Subtables */ 1618 1619 Offset = sizeof (ACPI_TABLE_HEADER); 1620 while (Offset < Table->Length) 1621 { 1622 AcpiOsPrintf ("\n"); 1623 1624 /* Common subtable header */ 1625 1626 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 1627 if (Subtable->Length < sizeof (ACPI_SUBTABLE_HEADER)) 1628 { 1629 AcpiOsPrintf ("Invalid subtable length\n"); 1630 return; 1631 } 1632 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1633 Subtable->Length, AcpiDmTableInfoPpttHdr); 1634 if (ACPI_FAILURE (Status)) 1635 { 1636 return; 1637 } 1638 1639 switch (Subtable->Type) 1640 { 1641 case ACPI_PPTT_TYPE_PROCESSOR: 1642 1643 InfoTable = AcpiDmTableInfoPptt0; 1644 Length = sizeof (ACPI_PPTT_PROCESSOR); 1645 break; 1646 1647 case ACPI_PPTT_TYPE_CACHE: 1648 1649 InfoTable = AcpiDmTableInfoPptt1; 1650 Length = sizeof (ACPI_PPTT_CACHE); 1651 break; 1652 1653 case ACPI_PPTT_TYPE_ID: 1654 1655 InfoTable = AcpiDmTableInfoPptt2; 1656 Length = sizeof (ACPI_PPTT_ID); 1657 break; 1658 1659 default: 1660 1661 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n", 1662 Subtable->Type); 1663 1664 /* Attempt to continue */ 1665 1666 goto NextSubtable; 1667 } 1668 1669 if (Subtable->Length < Length) 1670 { 1671 AcpiOsPrintf ("Invalid subtable length\n"); 1672 return; 1673 } 1674 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1675 Subtable->Length, InfoTable); 1676 if (ACPI_FAILURE (Status)) 1677 { 1678 return; 1679 } 1680 SubtableOffset = Length; 1681 1682 switch (Subtable->Type) 1683 { 1684 case ACPI_PPTT_TYPE_PROCESSOR: 1685 1686 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, Subtable); 1687 1688 /* Dump SMBIOS handles */ 1689 1690 if ((UINT8)(Subtable->Length - SubtableOffset) < 1691 (UINT8)(PpttProcessor->NumberOfPrivResources * 4)) 1692 { 1693 AcpiOsPrintf ("Invalid private resource number\n"); 1694 return; 1695 } 1696 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++) 1697 { 1698 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 1699 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset), 1700 4, AcpiDmTableInfoPptt0a); 1701 SubtableOffset += 4; 1702 } 1703 break; 1704 1705 default: 1706 1707 break; 1708 } 1709 1710 NextSubtable: 1711 /* Point to next subtable */ 1712 1713 Offset += Subtable->Length; 1714 } 1715 } 1716 1717 1718 /******************************************************************************* 1719 * 1720 * FUNCTION: AcpiDmDumpS3pt 1721 * 1722 * PARAMETERS: Table - A S3PT table 1723 * 1724 * RETURN: Length of the table 1725 * 1726 * DESCRIPTION: Format the contents of a S3PT 1727 * 1728 ******************************************************************************/ 1729 1730 UINT32 1731 AcpiDmDumpS3pt ( 1732 ACPI_TABLE_HEADER *Tables) 1733 { 1734 ACPI_STATUS Status; 1735 UINT32 Offset = sizeof (ACPI_TABLE_S3PT); 1736 ACPI_FPDT_HEADER *Subtable; 1737 ACPI_DMTABLE_INFO *InfoTable; 1738 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); 1739 1740 1741 /* Main table */ 1742 1743 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt); 1744 if (ACPI_FAILURE (Status)) 1745 { 1746 return 0; 1747 } 1748 1749 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset); 1750 while (Offset < S3ptTable->Length) 1751 { 1752 /* Common subtable header */ 1753 1754 AcpiOsPrintf ("\n"); 1755 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable, 1756 Subtable->Length, AcpiDmTableInfoS3ptHdr); 1757 if (ACPI_FAILURE (Status)) 1758 { 1759 return 0; 1760 } 1761 1762 switch (Subtable->Type) 1763 { 1764 case ACPI_S3PT_TYPE_RESUME: 1765 1766 InfoTable = AcpiDmTableInfoS3pt0; 1767 break; 1768 1769 case ACPI_S3PT_TYPE_SUSPEND: 1770 1771 InfoTable = AcpiDmTableInfoS3pt1; 1772 break; 1773 1774 default: 1775 1776 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", 1777 Subtable->Type); 1778 1779 /* Attempt to continue */ 1780 1781 if (!Subtable->Length) 1782 { 1783 AcpiOsPrintf ("Invalid zero length subtable\n"); 1784 return 0; 1785 } 1786 goto NextSubtable; 1787 } 1788 1789 AcpiOsPrintf ("\n"); 1790 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable, 1791 Subtable->Length, InfoTable); 1792 if (ACPI_FAILURE (Status)) 1793 { 1794 return 0; 1795 } 1796 1797 NextSubtable: 1798 /* Point to next subtable */ 1799 1800 Offset += Subtable->Length; 1801 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, Subtable->Length); 1802 } 1803 1804 return (S3ptTable->Length); 1805 } 1806 1807 1808 /******************************************************************************* 1809 * 1810 * FUNCTION: AcpiDmDumpSdev 1811 * 1812 * PARAMETERS: Table - A SDEV table 1813 * 1814 * RETURN: None 1815 * 1816 * DESCRIPTION: Format the contents of a SDEV. This is a variable-length 1817 * table that contains variable strings and vendor data. 1818 * 1819 ******************************************************************************/ 1820 1821 void 1822 AcpiDmDumpSdev ( 1823 ACPI_TABLE_HEADER *Table) 1824 { 1825 ACPI_STATUS Status; 1826 ACPI_SDEV_HEADER *Subtable; 1827 ACPI_SDEV_PCIE *Pcie; 1828 ACPI_SDEV_NAMESPACE *Namesp; 1829 ACPI_DMTABLE_INFO *InfoTable; 1830 UINT32 Length = Table->Length; 1831 UINT32 Offset = sizeof (ACPI_TABLE_SDEV); 1832 UINT16 PathOffset; 1833 UINT16 PathLength; 1834 UINT16 VendorDataOffset; 1835 UINT16 VendorDataLength; 1836 1837 1838 /* Main table */ 1839 1840 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSdev); 1841 if (ACPI_FAILURE (Status)) 1842 { 1843 return; 1844 } 1845 1846 /* Subtables */ 1847 1848 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Table, Offset); 1849 while (Offset < Table->Length) 1850 { 1851 /* Common subtable header */ 1852 1853 AcpiOsPrintf ("\n"); 1854 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1855 Subtable->Length, AcpiDmTableInfoSdevHdr); 1856 if (ACPI_FAILURE (Status)) 1857 { 1858 return; 1859 } 1860 1861 switch (Subtable->Type) 1862 { 1863 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 1864 1865 InfoTable = AcpiDmTableInfoSdev0; 1866 break; 1867 1868 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 1869 1870 InfoTable = AcpiDmTableInfoSdev1; 1871 break; 1872 1873 default: 1874 goto NextSubtable; 1875 } 1876 1877 AcpiOsPrintf ("\n"); 1878 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1879 Subtable->Length, InfoTable); 1880 if (ACPI_FAILURE (Status)) 1881 { 1882 return; 1883 } 1884 1885 switch (Subtable->Type) 1886 { 1887 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 1888 1889 /* Dump the PCIe device ID(s) */ 1890 1891 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable); 1892 PathOffset = Namesp->DeviceIdOffset; 1893 PathLength = Namesp->DeviceIdLength; 1894 1895 if (PathLength) 1896 { 1897 Status = AcpiDmDumpTable (Table->Length, 0, 1898 ACPI_ADD_PTR (UINT8, Namesp, PathOffset), 1899 PathLength, AcpiDmTableInfoSdev0a); 1900 if (ACPI_FAILURE (Status)) 1901 { 1902 return; 1903 } 1904 } 1905 1906 /* Dump the vendor-specific data */ 1907 1908 VendorDataLength = 1909 Namesp->VendorDataLength; 1910 VendorDataOffset = 1911 Namesp->DeviceIdOffset + Namesp->DeviceIdLength; 1912 1913 if (VendorDataLength) 1914 { 1915 Status = AcpiDmDumpTable (Table->Length, 0, 1916 ACPI_ADD_PTR (UINT8, Namesp, VendorDataOffset), 1917 VendorDataLength, AcpiDmTableInfoSdev1b); 1918 if (ACPI_FAILURE (Status)) 1919 { 1920 return; 1921 } 1922 } 1923 break; 1924 1925 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 1926 1927 /* PCI path substructures */ 1928 1929 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable); 1930 PathOffset = Pcie->PathOffset; 1931 PathLength = Pcie->PathLength; 1932 1933 while (PathLength) 1934 { 1935 Status = AcpiDmDumpTable (Table->Length, 1936 PathOffset + Offset, 1937 ACPI_ADD_PTR (UINT8, Pcie, PathOffset), 1938 sizeof (ACPI_SDEV_PCIE_PATH), AcpiDmTableInfoSdev1a); 1939 if (ACPI_FAILURE (Status)) 1940 { 1941 return; 1942 } 1943 1944 PathOffset += sizeof (ACPI_SDEV_PCIE_PATH); 1945 PathLength -= sizeof (ACPI_SDEV_PCIE_PATH); 1946 } 1947 1948 /* VendorData */ 1949 1950 VendorDataLength = Pcie->VendorDataLength; 1951 VendorDataOffset = Pcie->PathOffset + Pcie->PathLength; 1952 1953 if (VendorDataLength) 1954 { 1955 Status = AcpiDmDumpTable (Table->Length, 0, 1956 ACPI_ADD_PTR (UINT8, Pcie, VendorDataOffset), 1957 VendorDataLength, AcpiDmTableInfoSdev1b); 1958 } 1959 break; 1960 1961 default: 1962 goto NextSubtable; 1963 } 1964 1965 NextSubtable: 1966 /* Point to next subtable */ 1967 1968 Offset += Subtable->Length; 1969 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Subtable, 1970 Subtable->Length); 1971 } 1972 } 1973
Indexes created Mon Sep 29 21:09:56 GMT 2025