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