dmtbdump2.c revision 1.1.1.10
1 /****************************************************************************** 2 * 3 * Module Name: dmtbdump2 - Dump ACPI data tables that contain no AML code 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2021, 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 MERCHANTABILITY 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 #include "aslcompiler.h" 49 50 /* This module used for application-level code only */ 51 52 #define _COMPONENT ACPI_CA_DISASSEMBLER 53 ACPI_MODULE_NAME ("dmtbdump2") 54 55 56 /******************************************************************************* 57 * 58 * FUNCTION: AcpiDmDumpIort 59 * 60 * PARAMETERS: Table - A IORT table 61 * 62 * RETURN: None 63 * 64 * DESCRIPTION: Format the contents of a IORT 65 * 66 ******************************************************************************/ 67 68 void 69 AcpiDmDumpIort ( 70 ACPI_TABLE_HEADER *Table) 71 { 72 ACPI_STATUS Status; 73 ACPI_TABLE_IORT *Iort; 74 ACPI_IORT_NODE *IortNode; 75 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL; 76 ACPI_IORT_SMMU *IortSmmu = NULL; 77 ACPI_IORT_RMR *IortRmr = NULL; 78 UINT32 Offset; 79 UINT32 NodeOffset; 80 UINT32 Length; 81 ACPI_DMTABLE_INFO *InfoTable; 82 char *String; 83 UINT32 i; 84 UINT32 MappingByteLength; 85 UINT8 Revision; 86 87 88 /* Main table */ 89 90 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort); 91 if (ACPI_FAILURE (Status)) 92 { 93 return; 94 } 95 96 Revision = Table->Revision; 97 98 /* Both IORT Rev E and E.a have known issues and are not supported */ 99 100 if (Revision == 1 || Revision == 2) 101 { 102 AcpiOsPrintf ("\n**** Unsupported IORT revision 0x%X\n", 103 Revision); 104 return; 105 } 106 107 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table); 108 Offset = sizeof (ACPI_TABLE_IORT); 109 110 /* Dump the OptionalPadding (optional) */ 111 112 if (Iort->NodeOffset > Offset) 113 { 114 Status = AcpiDmDumpTable (Table->Length, Offset, Table, 115 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad); 116 if (ACPI_FAILURE (Status)) 117 { 118 return; 119 } 120 } 121 122 Offset = Iort->NodeOffset; 123 while (Offset < Table->Length) 124 { 125 /* Common subtable header */ 126 127 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset); 128 AcpiOsPrintf ("\n"); 129 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData); 130 131 if (Revision == 0) 132 { 133 Status = AcpiDmDumpTable (Table->Length, Offset, 134 IortNode, Length, AcpiDmTableInfoIortHdr); 135 } 136 else if (Revision >= 3) 137 { 138 Status = AcpiDmDumpTable (Table->Length, Offset, 139 IortNode, Length, AcpiDmTableInfoIortHdr3); 140 } 141 142 if (ACPI_FAILURE (Status)) 143 { 144 return; 145 } 146 147 NodeOffset = Length; 148 149 switch (IortNode->Type) 150 { 151 case ACPI_IORT_NODE_ITS_GROUP: 152 153 InfoTable = AcpiDmTableInfoIort0; 154 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers); 155 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset); 156 break; 157 158 case ACPI_IORT_NODE_NAMED_COMPONENT: 159 160 InfoTable = AcpiDmTableInfoIort1; 161 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName); 162 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length); 163 Length += strlen (String) + 1; 164 break; 165 166 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX: 167 168 InfoTable = AcpiDmTableInfoIort2; 169 Length = IortNode->Length - NodeOffset; 170 break; 171 172 case ACPI_IORT_NODE_SMMU: 173 174 InfoTable = AcpiDmTableInfoIort3; 175 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts); 176 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset); 177 break; 178 179 case ACPI_IORT_NODE_SMMU_V3: 180 181 InfoTable = AcpiDmTableInfoIort4; 182 Length = IortNode->Length - NodeOffset; 183 break; 184 185 case ACPI_IORT_NODE_PMCG: 186 187 InfoTable = AcpiDmTableInfoIort5; 188 Length = IortNode->Length - NodeOffset; 189 break; 190 191 case ACPI_IORT_NODE_RMR: 192 193 InfoTable = AcpiDmTableInfoIort6; 194 Length = IortNode->Length - NodeOffset; 195 IortRmr = ACPI_ADD_PTR (ACPI_IORT_RMR, IortNode, NodeOffset); 196 break; 197 198 default: 199 200 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n", 201 IortNode->Type); 202 203 /* Attempt to continue */ 204 205 if (!IortNode->Length) 206 { 207 AcpiOsPrintf ("Invalid zero length IORT node\n"); 208 return; 209 } 210 goto NextSubtable; 211 } 212 213 /* Dump the node subtable header */ 214 215 AcpiOsPrintf ("\n"); 216 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 217 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 218 Length, InfoTable); 219 if (ACPI_FAILURE (Status)) 220 { 221 return; 222 } 223 224 NodeOffset += Length; 225 226 /* Dump the node specific data */ 227 228 switch (IortNode->Type) 229 { 230 case ACPI_IORT_NODE_ITS_GROUP: 231 232 /* Validate IortItsGroup to avoid compiler warnings */ 233 234 if (IortItsGroup) 235 { 236 for (i = 0; i < IortItsGroup->ItsCount; i++) 237 { 238 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 239 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 240 4, AcpiDmTableInfoIort0a); 241 if (ACPI_FAILURE (Status)) 242 { 243 return; 244 } 245 246 NodeOffset += 4; 247 } 248 } 249 break; 250 251 case ACPI_IORT_NODE_NAMED_COMPONENT: 252 253 /* Dump the Padding (optional) */ 254 255 if (IortNode->Length > NodeOffset) 256 { 257 MappingByteLength = 258 IortNode->MappingCount * sizeof (ACPI_IORT_ID_MAPPING); 259 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 260 Table, IortNode->Length - NodeOffset - MappingByteLength, 261 AcpiDmTableInfoIort1a); 262 if (ACPI_FAILURE (Status)) 263 { 264 return; 265 } 266 } 267 break; 268 269 case ACPI_IORT_NODE_SMMU: 270 271 AcpiOsPrintf ("\n"); 272 273 /* Validate IortSmmu to avoid compiler warnings */ 274 275 if (IortSmmu) 276 { 277 Length = 2 * sizeof (UINT64); 278 NodeOffset = IortSmmu->GlobalInterruptOffset; 279 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 280 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 281 Length, AcpiDmTableInfoIort3a); 282 if (ACPI_FAILURE (Status)) 283 { 284 return; 285 } 286 287 NodeOffset = IortSmmu->ContextInterruptOffset; 288 for (i = 0; i < IortSmmu->ContextInterruptCount; i++) 289 { 290 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 291 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 292 8, AcpiDmTableInfoIort3b); 293 if (ACPI_FAILURE (Status)) 294 { 295 return; 296 } 297 298 NodeOffset += 8; 299 } 300 301 NodeOffset = IortSmmu->PmuInterruptOffset; 302 for (i = 0; i < IortSmmu->PmuInterruptCount; i++) 303 { 304 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 305 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 306 8, AcpiDmTableInfoIort3c); 307 if (ACPI_FAILURE (Status)) 308 { 309 return; 310 } 311 312 NodeOffset += 8; 313 } 314 } 315 break; 316 317 case ACPI_IORT_NODE_RMR: 318 319 /* Validate IortRmr to avoid compiler warnings */ 320 if (IortRmr) 321 { 322 NodeOffset = IortRmr->RmrOffset; 323 Length = sizeof (ACPI_IORT_RMR_DESC); 324 for (i = 0; i < IortRmr->RmrCount; i++) 325 { 326 AcpiOsPrintf ("\n"); 327 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 328 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 329 Length, AcpiDmTableInfoIort6a); 330 if (ACPI_FAILURE (Status)) 331 { 332 return; 333 } 334 335 NodeOffset += Length; 336 } 337 } 338 break; 339 340 default: 341 342 break; 343 } 344 345 /* Dump the ID mappings */ 346 347 NodeOffset = IortNode->MappingOffset; 348 for (i = 0; i < IortNode->MappingCount; i++) 349 { 350 AcpiOsPrintf ("\n"); 351 Length = sizeof (ACPI_IORT_ID_MAPPING); 352 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 353 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 354 Length, AcpiDmTableInfoIortMap); 355 if (ACPI_FAILURE (Status)) 356 { 357 return; 358 } 359 360 NodeOffset += Length; 361 } 362 363 NextSubtable: 364 /* Point to next node subtable */ 365 366 Offset += IortNode->Length; 367 } 368 } 369 370 371 /******************************************************************************* 372 * 373 * FUNCTION: AcpiDmDumpIvrs 374 * 375 * PARAMETERS: Table - A IVRS table 376 * 377 * RETURN: None 378 * 379 * DESCRIPTION: Format the contents of a IVRS. Notes: 380 * The IVRS is essentially a flat table, with the following 381 * structure: 382 * <Main ACPI Table Header> 383 * <Main subtable - virtualization info> 384 * <IVHD> 385 * <Device Entries> 386 * ... 387 * <IVHD> 388 * <Device Entries> 389 * <IVMD> 390 * ... 391 * 392 ******************************************************************************/ 393 394 void 395 AcpiDmDumpIvrs ( 396 ACPI_TABLE_HEADER *Table) 397 { 398 ACPI_STATUS Status; 399 UINT32 Offset = sizeof (ACPI_TABLE_IVRS); 400 UINT32 EntryOffset; 401 UINT32 EntryLength; 402 UINT32 EntryType; 403 ACPI_IVRS_DEVICE_HID *HidSubtable; 404 ACPI_IVRS_DE_HEADER *DeviceEntry; 405 ACPI_IVRS_HEADER *Subtable; 406 ACPI_DMTABLE_INFO *InfoTable; 407 408 409 /* Main table */ 410 411 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); 412 if (ACPI_FAILURE (Status)) 413 { 414 return; 415 } 416 417 /* Subtables */ 418 419 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); 420 421 while (Offset < Table->Length) 422 { 423 switch (Subtable->Type) 424 { 425 /* Type 10h, IVHD (I/O Virtualization Hardware Definition) */ 426 427 case ACPI_IVRS_TYPE_HARDWARE1: 428 429 AcpiOsPrintf ("\n"); 430 InfoTable = AcpiDmTableInfoIvrsHware1; 431 break; 432 433 /* Types 11h, 40h, IVHD (I/O Virtualization Hardware Definition) */ 434 435 case ACPI_IVRS_TYPE_HARDWARE2: 436 case ACPI_IVRS_TYPE_HARDWARE3: 437 438 AcpiOsPrintf ("\n"); 439 InfoTable = AcpiDmTableInfoIvrsHware23; 440 break; 441 442 /* Types 20h-22h, IVMD (I/O Virtualization Memory Definition Block) */ 443 444 case ACPI_IVRS_TYPE_MEMORY1: 445 case ACPI_IVRS_TYPE_MEMORY2: 446 case ACPI_IVRS_TYPE_MEMORY3: 447 448 AcpiOsPrintf ("\n"); 449 InfoTable = AcpiDmTableInfoIvrsMemory; 450 break; 451 452 default: 453 454 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n", 455 Subtable->Type); 456 457 /* Attempt to continue */ 458 459 if (!Subtable->Length) 460 { 461 AcpiOsPrintf ("Invalid zero length subtable\n"); 462 return; 463 } 464 goto NextSubtable; 465 } 466 467 /* Dump the subtable */ 468 469 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 470 Subtable->Length, InfoTable); 471 if (ACPI_FAILURE (Status)) 472 { 473 return; 474 } 475 476 /* The hardware subtables (IVHD) can contain multiple device entries */ 477 478 if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE1 || 479 Subtable->Type == ACPI_IVRS_TYPE_HARDWARE2 || 480 Subtable->Type == ACPI_IVRS_TYPE_HARDWARE3) 481 { 482 if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE1) 483 { 484 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE1); 485 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable, 486 sizeof (ACPI_IVRS_HARDWARE1)); 487 } 488 else 489 { 490 /* ACPI_IVRS_TYPE_HARDWARE2, HARDWARE3 subtable types */ 491 492 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE2); 493 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, Subtable, 494 sizeof (ACPI_IVRS_HARDWARE2)); 495 } 496 497 /* Process all of the Device Entries */ 498 499 while (EntryOffset < (Offset + Subtable->Length)) 500 { 501 AcpiOsPrintf ("\n"); 502 503 /* 504 * Upper 2 bits of Type encode the length of the device entry 505 * 506 * 00 = 4 byte 507 * 01 = 8 byte 508 * 1x = variable length 509 */ 510 EntryType = DeviceEntry->Type; 511 EntryLength = EntryType >> 6 == 1 ? 8 : 4; 512 513 switch (EntryType) 514 { 515 /* 4-byte device entries */ 516 517 case ACPI_IVRS_TYPE_PAD4: 518 case ACPI_IVRS_TYPE_ALL: 519 case ACPI_IVRS_TYPE_SELECT: 520 case ACPI_IVRS_TYPE_START: 521 case ACPI_IVRS_TYPE_END: 522 523 InfoTable = AcpiDmTableInfoIvrs4; 524 break; 525 526 /* 8-byte entries, type A */ 527 528 case ACPI_IVRS_TYPE_ALIAS_SELECT: 529 case ACPI_IVRS_TYPE_ALIAS_START: 530 531 InfoTable = AcpiDmTableInfoIvrs8a; 532 break; 533 534 /* 8-byte entries, type B */ 535 536 case ACPI_IVRS_TYPE_PAD8: 537 case ACPI_IVRS_TYPE_EXT_SELECT: 538 case ACPI_IVRS_TYPE_EXT_START: 539 540 InfoTable = AcpiDmTableInfoIvrs8b; 541 break; 542 543 /* 8-byte entries, type C */ 544 545 case ACPI_IVRS_TYPE_SPECIAL: 546 547 InfoTable = AcpiDmTableInfoIvrs8c; 548 break; 549 550 /* Variable-length entries */ 551 552 case ACPI_IVRS_TYPE_HID: 553 554 EntryLength = 4; 555 InfoTable = AcpiDmTableInfoIvrsHid; 556 break; 557 558 default: 559 InfoTable = AcpiDmTableInfoIvrs4; 560 AcpiOsPrintf ( 561 "\n**** Unknown IVRS device entry type/length: " 562 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n", 563 EntryType, EntryLength, EntryOffset); 564 break; 565 } 566 567 /* Dump the Device Entry */ 568 569 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 570 DeviceEntry, EntryLength, InfoTable); 571 if (ACPI_FAILURE (Status)) 572 { 573 return; 574 } 575 576 HidSubtable = ACPI_CAST_PTR (ACPI_IVRS_DEVICE_HID, DeviceEntry); 577 EntryOffset += EntryLength; 578 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, HidSubtable, 579 EntryLength); 580 581 if (EntryType == ACPI_IVRS_TYPE_HID) 582 { 583 /* 584 * Determine if the HID is an integer or a string. 585 * An integer is defined to be 32 bits, with the upper 32 bits 586 * set to zero. (from the ACPI Spec): "The HID can be a 32-bit 587 * integer or a character string. If an integer, the lower 588 * 4 bytes of the field contain the integer and the upper 589 * 4 bytes are padded with 0". 590 */ 591 if (UtIsIdInteger ((UINT8 *) &HidSubtable->AcpiHid)) 592 { 593 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 594 &HidSubtable->AcpiHid, 8, AcpiDmTableInfoIvrsHidInteger); 595 } 596 else 597 { 598 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 599 &HidSubtable->AcpiHid, 8, AcpiDmTableInfoIvrsHidString); 600 } 601 if (ACPI_FAILURE (Status)) 602 { 603 return; 604 } 605 606 EntryOffset += 8; 607 608 /* 609 * Determine if the CID is an integer or a string. The format 610 * of the CID is the same as the HID above. From ACPI Spec: 611 * "If present, CID must be a single Compatible Device ID 612 * following the same format as the HID field." 613 */ 614 if (UtIsIdInteger ((UINT8 *) &HidSubtable->AcpiCid)) 615 { 616 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 617 &HidSubtable->AcpiCid, 8, AcpiDmTableInfoIvrsCidInteger); 618 } 619 else 620 { 621 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 622 &HidSubtable->AcpiCid, 8, AcpiDmTableInfoIvrsCidString); 623 } 624 if (ACPI_FAILURE (Status)) 625 { 626 return; 627 } 628 629 EntryOffset += 8; 630 EntryLength = HidSubtable->UidLength; 631 632 if (EntryLength > ACPI_IVRS_UID_NOT_PRESENT) 633 { 634 /* Dump the UID based upon the UidType field (String or Integer) */ 635 636 if (HidSubtable->UidType == ACPI_IVRS_UID_IS_STRING) 637 { 638 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 639 &HidSubtable->UidType, EntryLength, AcpiDmTableInfoIvrsUidString); 640 if (ACPI_FAILURE (Status)) 641 { 642 return; 643 } 644 } 645 else /* ACPI_IVRS_UID_IS_INTEGER */ 646 { 647 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 648 &HidSubtable->UidType, EntryLength, AcpiDmTableInfoIvrsUidInteger); 649 if (ACPI_FAILURE (Status)) 650 { 651 return; 652 } 653 } 654 } 655 656 EntryOffset += EntryLength+2; 657 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, 658 Table, EntryOffset); 659 } 660 } 661 } 662 663 NextSubtable: 664 /* Point to next subtable */ 665 666 Offset += Subtable->Length; 667 Subtable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Subtable, Subtable->Length); 668 } 669 } 670 671 672 /******************************************************************************* 673 * 674 * FUNCTION: AcpiDmDumpLpit 675 * 676 * PARAMETERS: Table - A LPIT table 677 * 678 * RETURN: None 679 * 680 * DESCRIPTION: Format the contents of a LPIT. This table type consists 681 * of an open-ended number of subtables. Note: There are no 682 * entries in the main table. An LPIT consists of the table 683 * header and then subtables only. 684 * 685 ******************************************************************************/ 686 687 void 688 AcpiDmDumpLpit ( 689 ACPI_TABLE_HEADER *Table) 690 { 691 ACPI_STATUS Status; 692 ACPI_LPIT_HEADER *Subtable; 693 UINT32 Length = Table->Length; 694 UINT32 Offset = sizeof (ACPI_TABLE_LPIT); 695 ACPI_DMTABLE_INFO *InfoTable; 696 UINT32 SubtableLength; 697 698 699 /* Subtables */ 700 701 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset); 702 while (Offset < Table->Length) 703 { 704 /* Common subtable header */ 705 706 Status = AcpiDmDumpTable (Length, Offset, Subtable, 707 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr); 708 if (ACPI_FAILURE (Status)) 709 { 710 return; 711 } 712 713 switch (Subtable->Type) 714 { 715 case ACPI_LPIT_TYPE_NATIVE_CSTATE: 716 717 InfoTable = AcpiDmTableInfoLpit0; 718 SubtableLength = sizeof (ACPI_LPIT_NATIVE); 719 break; 720 721 default: 722 723 /* Cannot continue on unknown type - no length */ 724 725 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n", 726 Subtable->Type); 727 return; 728 } 729 730 Status = AcpiDmDumpTable (Length, Offset, Subtable, 731 SubtableLength, InfoTable); 732 if (ACPI_FAILURE (Status)) 733 { 734 return; 735 } 736 737 AcpiOsPrintf ("\n"); 738 739 /* Point to next subtable */ 740 741 Offset += SubtableLength; 742 Subtable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Subtable, SubtableLength); 743 } 744 } 745 746 747 /******************************************************************************* 748 * 749 * FUNCTION: AcpiDmDumpMadt 750 * 751 * PARAMETERS: Table - A MADT table 752 * 753 * RETURN: None 754 * 755 * DESCRIPTION: Format the contents of a MADT. This table type consists 756 * of an open-ended number of subtables. 757 * 758 ******************************************************************************/ 759 760 void 761 AcpiDmDumpMadt ( 762 ACPI_TABLE_HEADER *Table) 763 { 764 ACPI_STATUS Status; 765 ACPI_SUBTABLE_HEADER *Subtable; 766 UINT32 Length = Table->Length; 767 UINT32 Offset = sizeof (ACPI_TABLE_MADT); 768 ACPI_DMTABLE_INFO *InfoTable; 769 770 771 /* Main table */ 772 773 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); 774 if (ACPI_FAILURE (Status)) 775 { 776 return; 777 } 778 779 /* Subtables */ 780 781 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 782 while (Offset < Table->Length) 783 { 784 /* Common subtable header */ 785 786 AcpiOsPrintf ("\n"); 787 Status = AcpiDmDumpTable (Length, Offset, Subtable, 788 Subtable->Length, AcpiDmTableInfoMadtHdr); 789 if (ACPI_FAILURE (Status)) 790 { 791 return; 792 } 793 794 switch (Subtable->Type) 795 { 796 case ACPI_MADT_TYPE_LOCAL_APIC: 797 798 InfoTable = AcpiDmTableInfoMadt0; 799 break; 800 801 case ACPI_MADT_TYPE_IO_APIC: 802 803 InfoTable = AcpiDmTableInfoMadt1; 804 break; 805 806 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 807 808 InfoTable = AcpiDmTableInfoMadt2; 809 break; 810 811 case ACPI_MADT_TYPE_NMI_SOURCE: 812 813 InfoTable = AcpiDmTableInfoMadt3; 814 break; 815 816 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 817 818 InfoTable = AcpiDmTableInfoMadt4; 819 break; 820 821 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 822 823 InfoTable = AcpiDmTableInfoMadt5; 824 break; 825 826 case ACPI_MADT_TYPE_IO_SAPIC: 827 828 InfoTable = AcpiDmTableInfoMadt6; 829 break; 830 831 case ACPI_MADT_TYPE_LOCAL_SAPIC: 832 833 InfoTable = AcpiDmTableInfoMadt7; 834 break; 835 836 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 837 838 InfoTable = AcpiDmTableInfoMadt8; 839 break; 840 841 case ACPI_MADT_TYPE_LOCAL_X2APIC: 842 843 InfoTable = AcpiDmTableInfoMadt9; 844 break; 845 846 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 847 848 InfoTable = AcpiDmTableInfoMadt10; 849 break; 850 851 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 852 853 InfoTable = AcpiDmTableInfoMadt11; 854 break; 855 856 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 857 858 InfoTable = AcpiDmTableInfoMadt12; 859 break; 860 861 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME: 862 863 InfoTable = AcpiDmTableInfoMadt13; 864 break; 865 866 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR: 867 868 InfoTable = AcpiDmTableInfoMadt14; 869 break; 870 871 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR: 872 873 InfoTable = AcpiDmTableInfoMadt15; 874 break; 875 876 case ACPI_MADT_TYPE_MULTIPROC_WAKEUP: 877 878 InfoTable = AcpiDmTableInfoMadt16; 879 break; 880 881 default: 882 883 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n", 884 Subtable->Type); 885 886 /* Attempt to continue */ 887 888 if (!Subtable->Length) 889 { 890 AcpiOsPrintf ("Invalid zero length subtable\n"); 891 return; 892 } 893 894 goto NextSubtable; 895 } 896 897 Status = AcpiDmDumpTable (Length, Offset, Subtable, 898 Subtable->Length, InfoTable); 899 if (ACPI_FAILURE (Status)) 900 { 901 return; 902 } 903 904 NextSubtable: 905 /* Point to next subtable */ 906 907 Offset += Subtable->Length; 908 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, 909 Subtable->Length); 910 } 911 } 912 913 914 /******************************************************************************* 915 * 916 * FUNCTION: AcpiDmDumpMcfg 917 * 918 * PARAMETERS: Table - A MCFG Table 919 * 920 * RETURN: None 921 * 922 * DESCRIPTION: Format the contents of a MCFG table 923 * 924 ******************************************************************************/ 925 926 void 927 AcpiDmDumpMcfg ( 928 ACPI_TABLE_HEADER *Table) 929 { 930 ACPI_STATUS Status; 931 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 932 ACPI_MCFG_ALLOCATION *Subtable; 933 934 935 /* Main table */ 936 937 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 938 if (ACPI_FAILURE (Status)) 939 { 940 return; 941 } 942 943 /* Subtables */ 944 945 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 946 while (Offset < Table->Length) 947 { 948 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 949 { 950 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", 951 (UINT32) sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 952 return; 953 } 954 955 AcpiOsPrintf ("\n"); 956 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 957 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 958 if (ACPI_FAILURE (Status)) 959 { 960 return; 961 } 962 963 /* Point to next subtable (each subtable is of fixed length) */ 964 965 Offset += sizeof (ACPI_MCFG_ALLOCATION); 966 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Subtable, 967 sizeof (ACPI_MCFG_ALLOCATION)); 968 } 969 } 970 971 972 /******************************************************************************* 973 * 974 * FUNCTION: AcpiDmDumpMpst 975 * 976 * PARAMETERS: Table - A MPST Table 977 * 978 * RETURN: None 979 * 980 * DESCRIPTION: Format the contents of a MPST table 981 * 982 ******************************************************************************/ 983 984 void 985 AcpiDmDumpMpst ( 986 ACPI_TABLE_HEADER *Table) 987 { 988 ACPI_STATUS Status; 989 UINT32 Offset = sizeof (ACPI_TABLE_MPST); 990 ACPI_MPST_POWER_NODE *Subtable0; 991 ACPI_MPST_POWER_STATE *Subtable0A; 992 ACPI_MPST_COMPONENT *Subtable0B; 993 ACPI_MPST_DATA_HDR *Subtable1; 994 ACPI_MPST_POWER_DATA *Subtable2; 995 UINT16 SubtableCount; 996 UINT32 PowerStateCount; 997 UINT32 ComponentCount; 998 999 1000 /* Main table */ 1001 1002 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); 1003 if (ACPI_FAILURE (Status)) 1004 { 1005 return; 1006 } 1007 1008 /* Subtable: Memory Power Node(s) */ 1009 1010 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; 1011 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); 1012 1013 while ((Offset < Table->Length) && SubtableCount) 1014 { 1015 AcpiOsPrintf ("\n"); 1016 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0, 1017 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); 1018 if (ACPI_FAILURE (Status)) 1019 { 1020 return; 1021 } 1022 1023 /* Extract the sub-subtable counts */ 1024 1025 PowerStateCount = Subtable0->NumPowerStates; 1026 ComponentCount = Subtable0->NumPhysicalComponents; 1027 Offset += sizeof (ACPI_MPST_POWER_NODE); 1028 1029 /* Sub-subtables - Memory Power State Structure(s) */ 1030 1031 Subtable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, Subtable0, 1032 sizeof (ACPI_MPST_POWER_NODE)); 1033 1034 while (PowerStateCount) 1035 { 1036 AcpiOsPrintf ("\n"); 1037 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0A, 1038 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); 1039 if (ACPI_FAILURE (Status)) 1040 { 1041 return; 1042 } 1043 1044 Subtable0A++; 1045 PowerStateCount--; 1046 Offset += sizeof (ACPI_MPST_POWER_STATE); 1047 } 1048 1049 /* Sub-subtables - Physical Component ID Structure(s) */ 1050 1051 Subtable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, Subtable0A); 1052 1053 if (ComponentCount) 1054 { 1055 AcpiOsPrintf ("\n"); 1056 } 1057 1058 while (ComponentCount) 1059 { 1060 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0B, 1061 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); 1062 if (ACPI_FAILURE (Status)) 1063 { 1064 return; 1065 } 1066 1067 Subtable0B++; 1068 ComponentCount--; 1069 Offset += sizeof (ACPI_MPST_COMPONENT); 1070 } 1071 1072 /* Point to next Memory Power Node subtable */ 1073 1074 SubtableCount--; 1075 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Subtable0, 1076 sizeof (ACPI_MPST_POWER_NODE) + 1077 (sizeof (ACPI_MPST_POWER_STATE) * Subtable0->NumPowerStates) + 1078 (sizeof (ACPI_MPST_COMPONENT) * Subtable0->NumPhysicalComponents)); 1079 } 1080 1081 /* Subtable: Count of Memory Power State Characteristic structures */ 1082 1083 AcpiOsPrintf ("\n"); 1084 Subtable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable0); 1085 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable1, 1086 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); 1087 if (ACPI_FAILURE (Status)) 1088 { 1089 return; 1090 } 1091 1092 SubtableCount = Subtable1->CharacteristicsCount; 1093 Offset += sizeof (ACPI_MPST_DATA_HDR); 1094 1095 /* Subtable: Memory Power State Characteristics structure(s) */ 1096 1097 Subtable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, Subtable1, 1098 sizeof (ACPI_MPST_DATA_HDR)); 1099 1100 while ((Offset < Table->Length) && SubtableCount) 1101 { 1102 AcpiOsPrintf ("\n"); 1103 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable2, 1104 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); 1105 if (ACPI_FAILURE (Status)) 1106 { 1107 return; 1108 } 1109 1110 Subtable2++; 1111 SubtableCount--; 1112 Offset += sizeof (ACPI_MPST_POWER_DATA); 1113 } 1114 } 1115 1116 1117 /******************************************************************************* 1118 * 1119 * FUNCTION: AcpiDmDumpMsct 1120 * 1121 * PARAMETERS: Table - A MSCT table 1122 * 1123 * RETURN: None 1124 * 1125 * DESCRIPTION: Format the contents of a MSCT 1126 * 1127 ******************************************************************************/ 1128 1129 void 1130 AcpiDmDumpMsct ( 1131 ACPI_TABLE_HEADER *Table) 1132 { 1133 ACPI_STATUS Status; 1134 UINT32 Offset = sizeof (ACPI_TABLE_MSCT); 1135 ACPI_MSCT_PROXIMITY *Subtable; 1136 1137 1138 /* Main table */ 1139 1140 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); 1141 if (ACPI_FAILURE (Status)) 1142 { 1143 return; 1144 } 1145 1146 /* Subtables */ 1147 1148 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); 1149 while (Offset < Table->Length) 1150 { 1151 /* Common subtable header */ 1152 1153 AcpiOsPrintf ("\n"); 1154 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1155 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); 1156 if (ACPI_FAILURE (Status)) 1157 { 1158 return; 1159 } 1160 1161 /* Point to next subtable */ 1162 1163 Offset += sizeof (ACPI_MSCT_PROXIMITY); 1164 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Subtable, 1165 sizeof (ACPI_MSCT_PROXIMITY)); 1166 } 1167 } 1168 1169 1170 /******************************************************************************* 1171 * 1172 * FUNCTION: AcpiDmDumpNfit 1173 * 1174 * PARAMETERS: Table - A NFIT table 1175 * 1176 * RETURN: None 1177 * 1178 * DESCRIPTION: Format the contents of an NFIT. 1179 * 1180 ******************************************************************************/ 1181 1182 void 1183 AcpiDmDumpNfit ( 1184 ACPI_TABLE_HEADER *Table) 1185 { 1186 ACPI_STATUS Status; 1187 UINT32 Offset = sizeof (ACPI_TABLE_NFIT); 1188 UINT32 FieldOffset = 0; 1189 UINT32 Length; 1190 ACPI_NFIT_HEADER *Subtable; 1191 ACPI_DMTABLE_INFO *InfoTable; 1192 ACPI_NFIT_INTERLEAVE *Interleave = NULL; 1193 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL; 1194 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; 1195 UINT32 i; 1196 1197 1198 /* Main table */ 1199 1200 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit); 1201 if (ACPI_FAILURE (Status)) 1202 { 1203 return; 1204 } 1205 1206 /* Subtables */ 1207 1208 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset); 1209 while (Offset < Table->Length) 1210 { 1211 /* NFIT subtable header */ 1212 1213 AcpiOsPrintf ("\n"); 1214 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1215 Subtable->Length, AcpiDmTableInfoNfitHdr); 1216 if (ACPI_FAILURE (Status)) 1217 { 1218 return; 1219 } 1220 1221 switch (Subtable->Type) 1222 { 1223 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: 1224 1225 InfoTable = AcpiDmTableInfoNfit0; 1226 break; 1227 1228 case ACPI_NFIT_TYPE_MEMORY_MAP: 1229 1230 InfoTable = AcpiDmTableInfoNfit1; 1231 break; 1232 1233 case ACPI_NFIT_TYPE_INTERLEAVE: 1234 1235 /* Has a variable number of 32-bit values at the end */ 1236 1237 InfoTable = AcpiDmTableInfoNfit2; 1238 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE); 1239 break; 1240 1241 case ACPI_NFIT_TYPE_SMBIOS: 1242 1243 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, Subtable); 1244 InfoTable = AcpiDmTableInfoNfit3; 1245 break; 1246 1247 case ACPI_NFIT_TYPE_CONTROL_REGION: 1248 1249 InfoTable = AcpiDmTableInfoNfit4; 1250 break; 1251 1252 case ACPI_NFIT_TYPE_DATA_REGION: 1253 1254 InfoTable = AcpiDmTableInfoNfit5; 1255 break; 1256 1257 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 1258 1259 /* Has a variable number of 64-bit addresses at the end */ 1260 1261 InfoTable = AcpiDmTableInfoNfit6; 1262 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64); 1263 break; 1264 1265 case ACPI_NFIT_TYPE_CAPABILITIES: /* ACPI 6.0A */ 1266 1267 InfoTable = AcpiDmTableInfoNfit7; 1268 break; 1269 1270 default: 1271 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n", 1272 Subtable->Type); 1273 1274 /* Attempt to continue */ 1275 1276 if (!Subtable->Length) 1277 { 1278 AcpiOsPrintf ("Invalid zero length subtable\n"); 1279 return; 1280 } 1281 goto NextSubtable; 1282 } 1283 1284 AcpiOsPrintf ("\n"); 1285 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1286 Subtable->Length, InfoTable); 1287 if (ACPI_FAILURE (Status)) 1288 { 1289 return; 1290 } 1291 1292 /* Per-subtable variable-length fields */ 1293 1294 switch (Subtable->Type) 1295 { 1296 case ACPI_NFIT_TYPE_INTERLEAVE: 1297 1298 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable); 1299 for (i = 0; i < Interleave->LineCount; i++) 1300 { 1301 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 1302 &Interleave->LineOffset[i], 1303 sizeof (UINT32), AcpiDmTableInfoNfit2a); 1304 if (ACPI_FAILURE (Status)) 1305 { 1306 return; 1307 } 1308 1309 FieldOffset += sizeof (UINT32); 1310 } 1311 break; 1312 1313 case ACPI_NFIT_TYPE_SMBIOS: 1314 1315 Length = Subtable->Length - 1316 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8); 1317 1318 if (Length) 1319 { 1320 Status = AcpiDmDumpTable (Table->Length, 1321 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8), 1322 SmbiosInfo, 1323 Length, AcpiDmTableInfoNfit3a); 1324 if (ACPI_FAILURE (Status)) 1325 { 1326 return; 1327 } 1328 } 1329 1330 break; 1331 1332 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 1333 1334 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable); 1335 for (i = 0; i < Hint->HintCount; i++) 1336 { 1337 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 1338 &Hint->HintAddress[i], 1339 sizeof (UINT64), AcpiDmTableInfoNfit6a); 1340 if (ACPI_FAILURE (Status)) 1341 { 1342 return; 1343 } 1344 1345 FieldOffset += sizeof (UINT64); 1346 } 1347 break; 1348 1349 default: 1350 break; 1351 } 1352 1353 NextSubtable: 1354 /* Point to next subtable */ 1355 1356 Offset += Subtable->Length; 1357 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Subtable, Subtable->Length); 1358 } 1359 } 1360 1361 1362 /******************************************************************************* 1363 * 1364 * FUNCTION: AcpiDmDumpNhlt 1365 * 1366 * PARAMETERS: Table - A NHLT table 1367 * 1368 * RETURN: None 1369 * 1370 * DESCRIPTION: Format the contents of an NHLT. 1371 * 1372 ******************************************************************************/ 1373 1374 void 1375 AcpiDmDumpNhlt ( 1376 ACPI_TABLE_HEADER *Table) 1377 { 1378 ACPI_STATUS Status; 1379 UINT32 Offset; 1380 UINT32 TableLength = Table->Length; 1381 UINT32 EndpointCount; 1382 UINT8 FormatsCount; 1383 ACPI_NHLT_ENDPOINT *Subtable; 1384 ACPI_NHLT_FORMAT_CONFIG *FormatSubtable; 1385 ACPI_TABLE_NHLT *InfoTable; 1386 UINT32 CapabilitiesSize; 1387 UINT32 i; 1388 UINT32 j; 1389 UINT32 k; 1390 UINT32 EndpointEndOffset; 1391 UINT8 ConfigType = 0; 1392 UINT8 ArrayType; 1393 ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A *DevSpecific; 1394 ACPI_NHLT_FORMATS_CONFIG *FormatsConfig; 1395 ACPI_NHLT_LINUX_SPECIFIC_COUNT *Count; 1396 ACPI_NHLT_LINUX_SPECIFIC_DATA *LinuxData; 1397 1398 1399 /* Main table */ 1400 1401 AcpiOsPrintf ("/* Main table */\n"); 1402 1403 Status = AcpiDmDumpTable (TableLength, 0, Table, 0, AcpiDmTableInfoNhlt); 1404 if (ACPI_FAILURE (Status)) 1405 { 1406 return; 1407 } 1408 1409 /* Get the Endpoint Descriptor Count */ 1410 1411 InfoTable = ACPI_ADD_PTR (ACPI_TABLE_NHLT, Table, 0); 1412 EndpointCount = InfoTable->EndpointCount; 1413 1414 /* Subtables */ 1415 1416 Offset = sizeof (ACPI_TABLE_NHLT); 1417 1418 while (Offset < TableLength) 1419 { 1420 /* A variable number of Endpoint Descriptors - process each */ 1421 1422 for (i = 0; i < EndpointCount; i++) 1423 { 1424 /* Do the Endpoint Descriptor table */ 1425 1426 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset); 1427 if (Subtable->DescriptorLength > TableLength) 1428 { 1429 Offset += 1; 1430 AcpiOsPrintf ("\n/* Endpoint Descriptor Length larger than" 1431 " table size: %X, table %X, adjusting table offset (+1) */\n", 1432 Subtable->DescriptorLength, TableLength); 1433 1434 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset); 1435 } 1436 1437 AcpiOsPrintf ("\n/* Endpoint Descriptor #%u */\n", i+1); 1438 Status = AcpiDmDumpTable (TableLength, Offset, Subtable, 1439 Subtable->DescriptorLength, AcpiDmTableInfoNhlt0); 1440 if (ACPI_FAILURE (Status)) 1441 { 1442 return; 1443 } 1444 EndpointEndOffset = Subtable->DescriptorLength + Offset; 1445 1446 /* Check for endpoint descriptor beyond end-of-table */ 1447 1448 if (Subtable->DescriptorLength > TableLength) 1449 { 1450 AcpiOsPrintf ("\n/* Endpoint Descriptor Length larger than table size: %X, table %X */\n", 1451 Subtable->DescriptorLength, TableLength); 1452 } 1453 Offset += sizeof (ACPI_NHLT_ENDPOINT); 1454 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset); 1455 1456 /* Do the Device Specific table */ 1457 1458 AcpiOsPrintf ("\n/* Endpoint Device_Specific_Config table */\n"); 1459 DevSpecific = ACPI_CAST_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Subtable); 1460 CapabilitiesSize = DevSpecific->CapabilitiesSize; 1461 1462 /* Different subtables based upon capabilities_size */ 1463 1464 switch (CapabilitiesSize) 1465 { 1466 case 0: 1467 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1468 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B), AcpiDmTableInfoNhlt5b); 1469 if (ACPI_FAILURE (Status)) 1470 { 1471 return; 1472 } 1473 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B); 1474 break; 1475 1476 case 1: 1477 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1478 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_C), AcpiDmTableInfoNhlt5c); 1479 if (ACPI_FAILURE (Status)) 1480 { 1481 return; 1482 } 1483 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_C); 1484 break; 1485 1486 case 2: 1487 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1488 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG), AcpiDmTableInfoNhlt5); 1489 if (ACPI_FAILURE (Status)) 1490 { 1491 return; 1492 } 1493 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG); 1494 break; 1495 1496 case 3: 1497 ConfigType = DevSpecific->ConfigType; 1498 ArrayType = DevSpecific->ArrayType; 1499 1500 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1501 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A), AcpiDmTableInfoNhlt5a); 1502 if (ACPI_FAILURE (Status)) 1503 { 1504 return; 1505 } 1506 1507 /* Capabilities Size == 3 */ 1508 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A); 1509 1510 /* Check for a vendor-defined mic array */ 1511 1512 if ((ConfigType == ACPI_NHLT_TYPE_MIC_ARRAY) && ((ArrayType & ARRAY_TYPE_MASK) == VENDOR_DEFINED)) 1513 { 1514 /* Vendor-defined microphone array */ 1515 1516 AcpiOsPrintf ("\n/* Vendor-defined microphone array */\n"); 1517 1518 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1519 sizeof (ACPI_NHLT_VENDOR_MIC_CONFIG), AcpiDmTableInfoNhlt6); 1520 if (ACPI_FAILURE (Status)) 1521 { 1522 return; 1523 } 1524 Offset += sizeof (ACPI_NHLT_VENDOR_MIC_CONFIG); 1525 } 1526 break; 1527 1528 default: 1529 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1530 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B), AcpiDmTableInfoNhlt5b); 1531 if (ACPI_FAILURE (Status)) 1532 { 1533 return; 1534 } 1535 1536 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B); 1537 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1538 CapabilitiesSize, AcpiDmTableInfoNhlt3a); 1539 if (ACPI_FAILURE (Status)) 1540 { 1541 return; 1542 } 1543 Offset += CapabilitiesSize; 1544 break; 1545 } 1546 1547 /* Do the Formats_Config table */ 1548 1549 FormatsConfig = ACPI_ADD_PTR (ACPI_NHLT_FORMATS_CONFIG, Table, Offset); 1550 FormatsCount = FormatsConfig->FormatsCount; 1551 1552 AcpiOsPrintf ("\n/* Formats_Config table */\n"); 1553 1554 Status = AcpiDmDumpTable (TableLength, Offset, FormatsConfig, 1555 sizeof (ACPI_NHLT_FORMATS_CONFIG), AcpiDmTableInfoNhlt4); 1556 if (ACPI_FAILURE (Status)) 1557 { 1558 return; 1559 } 1560 Offset += sizeof (ACPI_NHLT_FORMATS_CONFIG); 1561 1562 /* A variable number of Format_Config Descriptors - process each */ 1563 1564 for (j = 0; j < FormatsCount; j++) 1565 { 1566 FormatSubtable = ACPI_ADD_PTR (ACPI_NHLT_FORMAT_CONFIG, Table, Offset); 1567 CapabilitiesSize = FormatSubtable->CapabilitySize; 1568 1569 /* Do the Wave_extensible struct */ 1570 1571 AcpiOsPrintf ("\n/* Wave_Format_Extensible table #%u */\n", j+1); 1572 Status = AcpiDmDumpTable (TableLength, Offset, FormatSubtable, 1573 sizeof (ACPI_NHLT_FORMAT_CONFIG), AcpiDmTableInfoNhlt3); 1574 if (ACPI_FAILURE (Status)) 1575 { 1576 return; 1577 } 1578 Offset += sizeof (ACPI_NHLT_WAVE_EXTENSIBLE); 1579 1580 /* Do the Capabilities array */ 1581 1582 Offset += sizeof (UINT32); 1583 AcpiOsPrintf ("\n/* Specific_Config table #%u */\n", j+1); 1584 FormatSubtable = ACPI_ADD_PTR (ACPI_NHLT_FORMAT_CONFIG, Table, Offset); 1585 Status = AcpiDmDumpTable (TableLength, Offset, FormatSubtable, 1586 CapabilitiesSize, AcpiDmTableInfoNhlt3a); 1587 if (ACPI_FAILURE (Status)) 1588 { 1589 return; 1590 } 1591 Offset += CapabilitiesSize; 1592 } 1593 1594 /* 1595 * If we are not done with the Endpoint(s) yet, then there must be 1596 * some Linux-specific structure(s) yet to be processed. 1597 */ 1598 if (Offset < EndpointEndOffset) 1599 { 1600 AcpiOsPrintf ("\n"); 1601 Count = ACPI_ADD_PTR (ACPI_NHLT_LINUX_SPECIFIC_COUNT, Table, Offset); 1602 Status = AcpiDmDumpTable (TableLength, Offset, Count, 1603 sizeof (ACPI_NHLT_LINUX_SPECIFIC_COUNT), AcpiDmTableInfoNhlt7); 1604 if (ACPI_FAILURE (Status)) 1605 { 1606 return; 1607 } 1608 Offset += sizeof (ACPI_NHLT_LINUX_SPECIFIC_COUNT); 1609 1610 /* Variable number of linux-specific structures */ 1611 1612 for (k = 0; k < Count->StructureCount; k++) 1613 { 1614 LinuxData = ACPI_ADD_PTR (ACPI_NHLT_LINUX_SPECIFIC_DATA, Table, Offset); 1615 1616 AcpiOsPrintf ("\n/* Linux-specific structure #%u */\n", k+1); 1617 1618 Status = AcpiDmDumpTable (TableLength, Offset, LinuxData, 1619 sizeof (ACPI_NHLT_LINUX_SPECIFIC_DATA), AcpiDmTableInfoNhlt7a); 1620 if (ACPI_FAILURE (Status)) 1621 { 1622 return; 1623 } 1624 1625 Offset += sizeof (ACPI_NHLT_LINUX_SPECIFIC_DATA); 1626 } 1627 1628 /* Should be at the end of the Endpoint structure. Skip any extra bytes */ 1629 1630 if (Offset < EndpointEndOffset) 1631 { 1632 AcpiOsPrintf ("\n/* Endpoint descriptor ended before endpoint size was reached. " 1633 "skipped %X input bytes, current offset: %X, Endpoint End Offset: %X */\n", 1634 EndpointEndOffset - Offset, Offset, EndpointEndOffset); 1635 AcpiUtDumpBuffer (((UINT8 *)Table)+Offset, 1636 EndpointEndOffset - Offset, DB_BYTE_DISPLAY, Offset); 1637 Offset = EndpointEndOffset; 1638 } 1639 } 1640 } 1641 1642 /* Emit the table terminator (if present) */ 1643 1644 if (Offset == TableLength - sizeof (ACPI_NHLT_TABLE_TERMINATOR)) 1645 { 1646 LinuxData = ACPI_ADD_PTR (ACPI_NHLT_LINUX_SPECIFIC_DATA, Table, Offset); 1647 AcpiOsPrintf ("\n/* Table terminator structure */\n"); 1648 1649 Status = AcpiDmDumpTable (TableLength, Offset, LinuxData, 1650 sizeof (ACPI_NHLT_TABLE_TERMINATOR), AcpiDmTableInfoNhlt8); 1651 if (ACPI_FAILURE (Status)) 1652 { 1653 return; 1654 } 1655 } 1656 1657 return; 1658 } 1659 } 1660 1661 1662 /******************************************************************************* 1663 * 1664 * FUNCTION: AcpiDmDumpPcct 1665 * 1666 * PARAMETERS: Table - A PCCT table 1667 * 1668 * RETURN: None 1669 * 1670 * DESCRIPTION: Format the contents of a PCCT. This table type consists 1671 * of an open-ended number of subtables. 1672 * 1673 ******************************************************************************/ 1674 1675 void 1676 AcpiDmDumpPcct ( 1677 ACPI_TABLE_HEADER *Table) 1678 { 1679 ACPI_STATUS Status; 1680 ACPI_PCCT_SUBSPACE *Subtable; 1681 ACPI_DMTABLE_INFO *InfoTable; 1682 UINT32 Length = Table->Length; 1683 UINT32 Offset = sizeof (ACPI_TABLE_PCCT); 1684 1685 1686 /* Main table */ 1687 1688 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); 1689 if (ACPI_FAILURE (Status)) 1690 { 1691 return; 1692 } 1693 1694 /* Subtables */ 1695 1696 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); 1697 while (Offset < Table->Length) 1698 { 1699 /* Common subtable header */ 1700 1701 AcpiOsPrintf ("\n"); 1702 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1703 Subtable->Header.Length, AcpiDmTableInfoPcctHdr); 1704 if (ACPI_FAILURE (Status)) 1705 { 1706 return; 1707 } 1708 1709 switch (Subtable->Header.Type) 1710 { 1711 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: 1712 1713 InfoTable = AcpiDmTableInfoPcct0; 1714 break; 1715 1716 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: 1717 1718 InfoTable = AcpiDmTableInfoPcct1; 1719 break; 1720 1721 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2: 1722 1723 InfoTable = AcpiDmTableInfoPcct2; 1724 break; 1725 1726 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE: 1727 1728 InfoTable = AcpiDmTableInfoPcct3; 1729 break; 1730 1731 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE: 1732 1733 InfoTable = AcpiDmTableInfoPcct4; 1734 break; 1735 1736 case ACPI_PCCT_TYPE_HW_REG_COMM_SUBSPACE: 1737 1738 InfoTable = AcpiDmTableInfoPcct5; 1739 break; 1740 1741 default: 1742 1743 AcpiOsPrintf ( 1744 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n", 1745 Subtable->Header.Type); 1746 return; 1747 } 1748 1749 AcpiOsPrintf ("\n"); 1750 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1751 Subtable->Header.Length, InfoTable); 1752 if (ACPI_FAILURE (Status)) 1753 { 1754 return; 1755 } 1756 1757 /* Point to next subtable */ 1758 1759 Offset += Subtable->Header.Length; 1760 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Subtable, 1761 Subtable->Header.Length); 1762 } 1763 } 1764 1765 1766 /******************************************************************************* 1767 * 1768 * FUNCTION: AcpiDmDumpPdtt 1769 * 1770 * PARAMETERS: Table - A PDTT table 1771 * 1772 * RETURN: None 1773 * 1774 * DESCRIPTION: Format the contents of a Pdtt. This is a variable-length 1775 * table that contains an open-ended number of IDs 1776 * at the end of the table. 1777 * 1778 ******************************************************************************/ 1779 1780 void 1781 AcpiDmDumpPdtt ( 1782 ACPI_TABLE_HEADER *Table) 1783 { 1784 ACPI_STATUS Status; 1785 ACPI_PDTT_CHANNEL *Subtable; 1786 UINT32 Length = Table->Length; 1787 UINT32 Offset = sizeof (ACPI_TABLE_PDTT); 1788 1789 1790 /* Main table */ 1791 1792 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPdtt); 1793 if (ACPI_FAILURE (Status)) 1794 { 1795 return; 1796 } 1797 1798 /* Subtables. Currently there is only one type, but can be multiples */ 1799 1800 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Table, Offset); 1801 while (Offset < Table->Length) 1802 { 1803 AcpiOsPrintf ("\n"); 1804 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1805 sizeof (ACPI_PDTT_CHANNEL), AcpiDmTableInfoPdtt0); 1806 if (ACPI_FAILURE (Status)) 1807 { 1808 return; 1809 } 1810 1811 /* Point to next subtable */ 1812 1813 Offset += sizeof (ACPI_PDTT_CHANNEL); 1814 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Subtable, 1815 sizeof (ACPI_PDTT_CHANNEL)); 1816 } 1817 } 1818 1819 1820 /******************************************************************************* 1821 * 1822 * FUNCTION: AcpiDmDumpPhat 1823 * 1824 * PARAMETERS: Table - A PHAT table 1825 * 1826 * RETURN: None 1827 * 1828 * DESCRIPTION: Format the contents of a PHAT. 1829 * 1830 ******************************************************************************/ 1831 1832 void 1833 AcpiDmDumpPhat ( 1834 ACPI_TABLE_HEADER *Table) 1835 { 1836 ACPI_STATUS Status; 1837 ACPI_DMTABLE_INFO *InfoTable; 1838 ACPI_PHAT_HEADER *Subtable; 1839 ACPI_PHAT_VERSION_DATA *VersionData; 1840 UINT32 RecordCount; 1841 UINT32 Length = Table->Length; 1842 UINT32 Offset = sizeof (ACPI_TABLE_PHAT); 1843 UINT32 SubtableLength; 1844 UINT32 PathLength; 1845 UINT32 VendorLength; 1846 1847 1848 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, sizeof (ACPI_TABLE_PHAT)); 1849 1850 while (Offset < Table->Length) 1851 { 1852 /* Common subtable header */ 1853 1854 AcpiOsPrintf ("\n"); 1855 Status = AcpiDmDumpTable (Length, 0, Subtable, 1856 sizeof (ACPI_PHAT_HEADER), AcpiDmTableInfoPhatHdr); 1857 if (ACPI_FAILURE (Status)) 1858 { 1859 return; 1860 } 1861 1862 switch (Subtable->Type) 1863 { 1864 case ACPI_PHAT_TYPE_FW_VERSION_DATA: 1865 1866 InfoTable = AcpiDmTableInfoPhat0; 1867 SubtableLength = sizeof (ACPI_PHAT_VERSION_DATA); 1868 break; 1869 1870 case ACPI_PHAT_TYPE_FW_HEALTH_DATA: 1871 1872 InfoTable = AcpiDmTableInfoPhat1; 1873 SubtableLength = sizeof (ACPI_PHAT_HEALTH_DATA); 1874 break; 1875 1876 default: 1877 1878 AcpiOsPrintf ("\n**** Unknown PHAT subtable type 0x%X\n\n", 1879 Subtable->Type); 1880 1881 return; 1882 } 1883 1884 Status = AcpiDmDumpTable (Length, 0, Subtable, 1885 SubtableLength, InfoTable); 1886 if (ACPI_FAILURE (Status)) 1887 { 1888 return; 1889 } 1890 1891 switch (Subtable->Type) 1892 { 1893 case ACPI_PHAT_TYPE_FW_VERSION_DATA: 1894 1895 VersionData = ACPI_CAST_PTR (ACPI_PHAT_VERSION_DATA, Subtable); 1896 RecordCount = VersionData->ElementCount; 1897 while (RecordCount) 1898 { 1899 Status = AcpiDmDumpTable (Length, Offset, 1900 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_VERSION_DATA)), 1901 sizeof (ACPI_PHAT_VERSION_ELEMENT), AcpiDmTableInfoPhat0a); 1902 if (ACPI_FAILURE (Status)) 1903 { 1904 return; 1905 } 1906 1907 RecordCount--; 1908 } 1909 1910 break; 1911 1912 case ACPI_PHAT_TYPE_FW_HEALTH_DATA: 1913 1914 /* account for the null terminator */ 1915 1916 PathLength = strlen (ACPI_ADD_PTR (char, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA))) + 1; 1917 Status = AcpiDmDumpTable (Length, Offset, 1918 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA)), 1919 PathLength, AcpiDmTableInfoPhat1a); 1920 if (ACPI_FAILURE (Status)) 1921 { 1922 return; 1923 } 1924 1925 /* Get vendor data - data length is the remaining subtable length */ 1926 1927 VendorLength = 1928 Subtable->Length - sizeof (ACPI_PHAT_HEALTH_DATA) - PathLength; 1929 Status = AcpiDmDumpTable (Length, 0, 1930 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA) + PathLength), 1931 VendorLength, AcpiDmTableInfoPhat1b); 1932 if (ACPI_FAILURE (Status)) 1933 { 1934 return; 1935 } 1936 break; 1937 1938 default: 1939 1940 AcpiOsPrintf ("\n**** Unknown PHAT subtable type 0x%X\n\n", 1941 Subtable->Type); 1942 return; 1943 } 1944 1945 /* Next subtable */ 1946 1947 Offset += Subtable->Length; 1948 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, 1949 Subtable->Length); 1950 } 1951 } 1952 1953 1954 /******************************************************************************* 1955 * 1956 * FUNCTION: AcpiDmDumpPmtt 1957 * 1958 * PARAMETERS: Table - A PMTT table 1959 * 1960 * RETURN: None 1961 * 1962 * DESCRIPTION: Format the contents of a PMTT. This table type consists 1963 * of an open-ended number of subtables. 1964 * 1965 ******************************************************************************/ 1966 1967 void 1968 AcpiDmDumpPmtt ( 1969 ACPI_TABLE_HEADER *Table) 1970 { 1971 ACPI_STATUS Status; 1972 ACPI_PMTT_HEADER *Subtable; 1973 UINT32 Length = Table->Length; 1974 UINT32 Offset = sizeof (ACPI_TABLE_PMTT); 1975 1976 1977 /* Main table */ 1978 1979 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); 1980 if (ACPI_FAILURE (Status)) 1981 { 1982 return; 1983 } 1984 1985 /* Subtables */ 1986 1987 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); 1988 while (Offset < Table->Length) 1989 { 1990 /* Each of the types below contain the common subtable header */ 1991 1992 AcpiOsPrintf ("\n"); 1993 switch (Subtable->Type) 1994 { 1995 case ACPI_PMTT_TYPE_SOCKET: 1996 1997 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1998 Subtable->Length, AcpiDmTableInfoPmtt0); 1999 if (ACPI_FAILURE (Status)) 2000 { 2001 return; 2002 } 2003 break; 2004 2005 case ACPI_PMTT_TYPE_CONTROLLER: 2006 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2007 Subtable->Length, AcpiDmTableInfoPmtt1); 2008 if (ACPI_FAILURE (Status)) 2009 { 2010 return; 2011 } 2012 break; 2013 2014 case ACPI_PMTT_TYPE_DIMM: 2015 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2016 Subtable->Length, AcpiDmTableInfoPmtt2); 2017 if (ACPI_FAILURE (Status)) 2018 { 2019 return; 2020 } 2021 break; 2022 2023 case ACPI_PMTT_TYPE_VENDOR: 2024 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2025 Subtable->Length, AcpiDmTableInfoPmttVendor); 2026 if (ACPI_FAILURE (Status)) 2027 { 2028 return; 2029 } 2030 break; 2031 2032 default: 2033 AcpiOsPrintf ( 2034 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2035 Subtable->Type); 2036 return; 2037 } 2038 2039 /* Point to next subtable */ 2040 2041 Offset += Subtable->Length; 2042 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2043 Subtable, Subtable->Length); 2044 } 2045 } 2046 2047 2048 /******************************************************************************* 2049 * 2050 * FUNCTION: AcpiDmDumpPptt 2051 * 2052 * PARAMETERS: Table - A PMTT table 2053 * 2054 * RETURN: None 2055 * 2056 * DESCRIPTION: Format the contents of a PPTT. This table type consists 2057 * of an open-ended number of subtables. 2058 * 2059 ******************************************************************************/ 2060 2061 void 2062 AcpiDmDumpPptt ( 2063 ACPI_TABLE_HEADER *Table) 2064 { 2065 ACPI_STATUS Status; 2066 ACPI_SUBTABLE_HEADER *Subtable; 2067 ACPI_PPTT_PROCESSOR *PpttProcessor; 2068 UINT8 Length; 2069 UINT8 SubtableOffset; 2070 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 2071 ACPI_DMTABLE_INFO *InfoTable; 2072 UINT32 i; 2073 2074 2075 /* There is no main table (other than the standard ACPI header) */ 2076 2077 /* Subtables */ 2078 2079 Offset = sizeof (ACPI_TABLE_HEADER); 2080 while (Offset < Table->Length) 2081 { 2082 AcpiOsPrintf ("\n"); 2083 2084 /* Common subtable header */ 2085 2086 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 2087 if (Subtable->Length < sizeof (ACPI_SUBTABLE_HEADER)) 2088 { 2089 AcpiOsPrintf ("Invalid subtable length\n"); 2090 return; 2091 } 2092 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 2093 Subtable->Length, AcpiDmTableInfoPpttHdr); 2094 if (ACPI_FAILURE (Status)) 2095 { 2096 return; 2097 } 2098 2099 switch (Subtable->Type) 2100 { 2101 case ACPI_PPTT_TYPE_PROCESSOR: 2102 2103 InfoTable = AcpiDmTableInfoPptt0; 2104 Length = sizeof (ACPI_PPTT_PROCESSOR); 2105 break; 2106 2107 case ACPI_PPTT_TYPE_CACHE: 2108 2109 InfoTable = AcpiDmTableInfoPptt1; 2110 Length = sizeof (ACPI_PPTT_CACHE); 2111 break; 2112 2113 case ACPI_PPTT_TYPE_ID: 2114 2115 InfoTable = AcpiDmTableInfoPptt2; 2116 Length = sizeof (ACPI_PPTT_ID); 2117 break; 2118 2119 default: 2120 2121 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n", 2122 Subtable->Type); 2123 2124 /* Attempt to continue */ 2125 2126 goto NextSubtable; 2127 } 2128 2129 if (Subtable->Length < Length) 2130 { 2131 AcpiOsPrintf ("Invalid subtable length\n"); 2132 return; 2133 } 2134 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 2135 Subtable->Length, InfoTable); 2136 if (ACPI_FAILURE (Status)) 2137 { 2138 return; 2139 } 2140 SubtableOffset = Length; 2141 2142 switch (Subtable->Type) 2143 { 2144 case ACPI_PPTT_TYPE_PROCESSOR: 2145 2146 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, Subtable); 2147 2148 /* Dump SMBIOS handles */ 2149 2150 if ((UINT8)(Subtable->Length - SubtableOffset) < 2151 (UINT8)(PpttProcessor->NumberOfPrivResources * 4)) 2152 { 2153 AcpiOsPrintf ("Invalid private resource number\n"); 2154 return; 2155 } 2156 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++) 2157 { 2158 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2159 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset), 2160 4, AcpiDmTableInfoPptt0a); 2161 if (ACPI_FAILURE (Status)) 2162 { 2163 return; 2164 } 2165 2166 SubtableOffset += 4; 2167 } 2168 break; 2169 2170 case ACPI_PPTT_TYPE_CACHE: 2171 2172 if (Table->Revision < 3) 2173 { 2174 break; 2175 } 2176 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2177 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset), 2178 sizeof (ACPI_PPTT_CACHE_V1), AcpiDmTableInfoPptt1a); 2179 if (ACPI_FAILURE (Status)) 2180 { 2181 return; 2182 } 2183 break; 2184 2185 default: 2186 2187 break; 2188 } 2189 2190 NextSubtable: 2191 /* Point to next subtable */ 2192 2193 Offset += Subtable->Length; 2194 } 2195 } 2196 2197 2198 /******************************************************************************* 2199 * 2200 * FUNCTION: AcpiDmDumpPrmt 2201 * 2202 * PARAMETERS: Table - A PRMT table 2203 * 2204 * RETURN: None 2205 * 2206 * DESCRIPTION: Format the contents of a PRMT. This table type consists 2207 * of an open-ended number of subtables. 2208 * 2209 ******************************************************************************/ 2210 2211 void 2212 AcpiDmDumpPrmt ( 2213 ACPI_TABLE_HEADER *Table) 2214 { 2215 UINT32 CurrentOffset = sizeof (ACPI_TABLE_HEADER); 2216 ACPI_TABLE_PRMT_HEADER *PrmtHeader; 2217 ACPI_PRMT_MODULE_INFO *PrmtModuleInfo; 2218 ACPI_PRMT_HANDLER_INFO *PrmtHandlerInfo; 2219 ACPI_STATUS Status; 2220 UINT32 i, j; 2221 2222 2223 /* Main table header */ 2224 2225 PrmtHeader = ACPI_ADD_PTR (ACPI_TABLE_PRMT_HEADER, Table, CurrentOffset); 2226 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHeader, 2227 sizeof (ACPI_TABLE_PRMT_HEADER), AcpiDmTableInfoPrmtHdr); 2228 if (ACPI_FAILURE (Status)) 2229 { 2230 AcpiOsPrintf ("Invalid PRMT header\n"); 2231 return; 2232 } 2233 2234 CurrentOffset += sizeof (ACPI_TABLE_PRMT_HEADER); 2235 2236 /* PRM Module Information Structure array */ 2237 2238 for (i = 0; i < PrmtHeader->ModuleInfoCount; ++i) 2239 { 2240 PrmtModuleInfo = ACPI_ADD_PTR (ACPI_PRMT_MODULE_INFO, Table, CurrentOffset); 2241 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtModuleInfo, 2242 sizeof (ACPI_PRMT_MODULE_INFO), AcpiDmTableInfoPrmtModule); 2243 2244 CurrentOffset += sizeof (ACPI_PRMT_MODULE_INFO); 2245 2246 /* PRM handler information structure array */ 2247 2248 for (j = 0; j < PrmtModuleInfo->HandlerInfoCount; ++j) 2249 { 2250 PrmtHandlerInfo = ACPI_ADD_PTR (ACPI_PRMT_HANDLER_INFO, Table, CurrentOffset); 2251 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHandlerInfo, 2252 sizeof (ACPI_PRMT_HANDLER_INFO), AcpiDmTableInfoPrmtHandler); 2253 2254 CurrentOffset += sizeof (ACPI_PRMT_HANDLER_INFO); 2255 } 2256 } 2257 } 2258 2259 2260 /******************************************************************************* 2261 * 2262 * FUNCTION: AcpiDmDumpRgrt 2263 * 2264 * PARAMETERS: Table - A RGRT table 2265 * 2266 * RETURN: None 2267 * 2268 * DESCRIPTION: Format the contents of a RGRT 2269 * 2270 ******************************************************************************/ 2271 2272 void 2273 AcpiDmDumpRgrt ( 2274 ACPI_TABLE_HEADER *Table) 2275 { 2276 ACPI_STATUS Status; 2277 ACPI_TABLE_RGRT *Subtable = ACPI_CAST_PTR (ACPI_TABLE_RGRT, Table); 2278 UINT32 Offset = sizeof (ACPI_TABLE_RGRT); 2279 2280 2281 /* Main table */ 2282 2283 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoRgrt); 2284 if (ACPI_FAILURE (Status)) 2285 { 2286 return; 2287 } 2288 2289 /* Dump the binary image as a subtable */ 2290 2291 Status = AcpiDmDumpTable (Table->Length, Offset, &Subtable->Image, 2292 Table->Length - Offset, AcpiDmTableInfoRgrt0); 2293 if (ACPI_FAILURE (Status)) 2294 { 2295 return; 2296 } 2297 } 2298 2299 2300 /******************************************************************************* 2301 * 2302 * FUNCTION: AcpiDmDumpS3pt 2303 * 2304 * PARAMETERS: Table - A S3PT table 2305 * 2306 * RETURN: Length of the table 2307 * 2308 * DESCRIPTION: Format the contents of a S3PT 2309 * 2310 ******************************************************************************/ 2311 2312 UINT32 2313 AcpiDmDumpS3pt ( 2314 ACPI_TABLE_HEADER *Tables) 2315 { 2316 ACPI_STATUS Status; 2317 UINT32 Offset = sizeof (ACPI_TABLE_S3PT); 2318 ACPI_FPDT_HEADER *Subtable; 2319 ACPI_DMTABLE_INFO *InfoTable; 2320 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); 2321 2322 2323 /* Main table */ 2324 2325 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt); 2326 if (ACPI_FAILURE (Status)) 2327 { 2328 return 0; 2329 } 2330 2331 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset); 2332 while (Offset < S3ptTable->Length) 2333 { 2334 /* Common subtable header */ 2335 2336 AcpiOsPrintf ("\n"); 2337 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable, 2338 Subtable->Length, AcpiDmTableInfoS3ptHdr); 2339 if (ACPI_FAILURE (Status)) 2340 { 2341 return 0; 2342 } 2343 2344 switch (Subtable->Type) 2345 { 2346 case ACPI_S3PT_TYPE_RESUME: 2347 2348 InfoTable = AcpiDmTableInfoS3pt0; 2349 break; 2350 2351 case ACPI_S3PT_TYPE_SUSPEND: 2352 2353 InfoTable = AcpiDmTableInfoS3pt1; 2354 break; 2355 2356 default: 2357 2358 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", 2359 Subtable->Type); 2360 2361 /* Attempt to continue */ 2362 2363 if (!Subtable->Length) 2364 { 2365 AcpiOsPrintf ("Invalid zero length subtable\n"); 2366 return 0; 2367 } 2368 goto NextSubtable; 2369 } 2370 2371 AcpiOsPrintf ("\n"); 2372 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable, 2373 Subtable->Length, InfoTable); 2374 if (ACPI_FAILURE (Status)) 2375 { 2376 return 0; 2377 } 2378 2379 NextSubtable: 2380 /* Point to next subtable */ 2381 2382 Offset += Subtable->Length; 2383 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, Subtable->Length); 2384 } 2385 2386 return (S3ptTable->Length); 2387 } 2388 2389 2390 /******************************************************************************* 2391 * 2392 * FUNCTION: AcpiDmDumpSdev 2393 * 2394 * PARAMETERS: Table - A SDEV table 2395 * 2396 * RETURN: None 2397 * 2398 * DESCRIPTION: Format the contents of a SDEV. This is a variable-length 2399 * table that contains variable strings and vendor data. 2400 * 2401 ******************************************************************************/ 2402 2403 void 2404 AcpiDmDumpSdev ( 2405 ACPI_TABLE_HEADER *Table) 2406 { 2407 ACPI_STATUS Status; 2408 ACPI_SDEV_HEADER *Subtable; 2409 ACPI_SDEV_PCIE *Pcie; 2410 ACPI_SDEV_NAMESPACE *Namesp; 2411 ACPI_DMTABLE_INFO *InfoTable; 2412 ACPI_DMTABLE_INFO *SecureComponentInfoTable; 2413 UINT32 Length = Table->Length; 2414 UINT32 Offset = sizeof (ACPI_TABLE_SDEV); 2415 UINT16 PathOffset; 2416 UINT16 PathLength; 2417 UINT16 VendorDataOffset; 2418 UINT16 VendorDataLength; 2419 ACPI_SDEV_SECURE_COMPONENT *SecureComponent = NULL; 2420 UINT32 CurrentOffset = 0; 2421 2422 2423 /* Main table */ 2424 2425 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSdev); 2426 if (ACPI_FAILURE (Status)) 2427 { 2428 return; 2429 } 2430 2431 /* Subtables */ 2432 2433 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Table, Offset); 2434 while (Offset < Table->Length) 2435 { 2436 /* Common subtable header */ 2437 2438 AcpiOsPrintf ("\n"); 2439 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 2440 Subtable->Length, AcpiDmTableInfoSdevHdr); 2441 if (ACPI_FAILURE (Status)) 2442 { 2443 return; 2444 } 2445 2446 switch (Subtable->Type) 2447 { 2448 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 2449 2450 InfoTable = AcpiDmTableInfoSdev0; 2451 break; 2452 2453 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 2454 2455 InfoTable = AcpiDmTableInfoSdev1; 2456 break; 2457 2458 default: 2459 goto NextSubtable; 2460 } 2461 2462 AcpiOsPrintf ("\n"); 2463 Status = AcpiDmDumpTable (Table->Length, 0, Subtable, 2464 Subtable->Length, InfoTable); 2465 if (ACPI_FAILURE (Status)) 2466 { 2467 return; 2468 } 2469 2470 switch (Subtable->Type) 2471 { 2472 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 2473 2474 CurrentOffset = sizeof (ACPI_SDEV_NAMESPACE); 2475 if (Subtable->Flags & ACPI_SDEV_SECURE_COMPONENTS_PRESENT) 2476 { 2477 SecureComponent = ACPI_CAST_PTR (ACPI_SDEV_SECURE_COMPONENT, 2478 ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE))); 2479 2480 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, 2481 ACPI_ADD_PTR(UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)), 2482 sizeof (ACPI_SDEV_SECURE_COMPONENT), AcpiDmTableInfoSdev0b); 2483 if (ACPI_FAILURE (Status)) 2484 { 2485 return; 2486 } 2487 CurrentOffset += sizeof (ACPI_SDEV_SECURE_COMPONENT); 2488 2489 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, 2490 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset), 2491 sizeof (ACPI_SDEV_HEADER), AcpiDmTableInfoSdevSecCompHdr); 2492 if (ACPI_FAILURE (Status)) 2493 { 2494 return; 2495 } 2496 CurrentOffset += sizeof (ACPI_SDEV_HEADER); 2497 2498 switch (Subtable->Type) 2499 { 2500 case ACPI_SDEV_TYPE_ID_COMPONENT: 2501 2502 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompId; 2503 break; 2504 2505 case ACPI_SDEV_TYPE_MEM_COMPONENT: 2506 2507 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompMem; 2508 break; 2509 2510 default: 2511 goto NextSubtable; 2512 } 2513 2514 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, 2515 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset), 2516 SecureComponent->SecureComponentLength, SecureComponentInfoTable); 2517 CurrentOffset += SecureComponent->SecureComponentLength; 2518 } 2519 2520 /* Dump the PCIe device ID(s) */ 2521 2522 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable); 2523 PathOffset = Namesp->DeviceIdOffset; 2524 PathLength = Namesp->DeviceIdLength; 2525 2526 if (PathLength) 2527 { 2528 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, 2529 ACPI_ADD_PTR (UINT8, Namesp, PathOffset), 2530 PathLength, AcpiDmTableInfoSdev0a); 2531 if (ACPI_FAILURE (Status)) 2532 { 2533 return; 2534 } 2535 CurrentOffset += PathLength; 2536 } 2537 2538 /* Dump the vendor-specific data */ 2539 2540 VendorDataLength = 2541 Namesp->VendorDataLength; 2542 VendorDataOffset = 2543 Namesp->DeviceIdOffset + Namesp->DeviceIdLength; 2544 2545 if (VendorDataLength) 2546 { 2547 Status = AcpiDmDumpTable (Table->Length, 0, 2548 ACPI_ADD_PTR (UINT8, Namesp, VendorDataOffset), 2549 VendorDataLength, AcpiDmTableInfoSdev1b); 2550 if (ACPI_FAILURE (Status)) 2551 { 2552 return; 2553 } 2554 } 2555 break; 2556 2557 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 2558 2559 /* PCI path substructures */ 2560 2561 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable); 2562 PathOffset = Pcie->PathOffset; 2563 PathLength = Pcie->PathLength; 2564 2565 while (PathLength) 2566 { 2567 Status = AcpiDmDumpTable (Table->Length, 2568 PathOffset + Offset, 2569 ACPI_ADD_PTR (UINT8, Pcie, PathOffset), 2570 sizeof (ACPI_SDEV_PCIE_PATH), AcpiDmTableInfoSdev1a); 2571 if (ACPI_FAILURE (Status)) 2572 { 2573 return; 2574 } 2575 2576 PathOffset += sizeof (ACPI_SDEV_PCIE_PATH); 2577 PathLength -= sizeof (ACPI_SDEV_PCIE_PATH); 2578 } 2579 2580 /* VendorData */ 2581 2582 VendorDataLength = Pcie->VendorDataLength; 2583 VendorDataOffset = Pcie->PathOffset + Pcie->PathLength; 2584 2585 if (VendorDataLength) 2586 { 2587 Status = AcpiDmDumpTable (Table->Length, 0, 2588 ACPI_ADD_PTR (UINT8, Pcie, VendorDataOffset), 2589 VendorDataLength, AcpiDmTableInfoSdev1b); 2590 if (ACPI_FAILURE (Status)) 2591 { 2592 return; 2593 } 2594 } 2595 break; 2596 2597 default: 2598 goto NextSubtable; 2599 } 2600 2601 NextSubtable: 2602 /* Point to next subtable */ 2603 2604 Offset += Subtable->Length; 2605 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Subtable, 2606 Subtable->Length); 2607 } 2608 } 2609
Indexes created Tue Sep 30 17:09:57 GMT 2025