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