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