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