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