dmtbdump2.c revision 1.1.1.12
1 /****************************************************************************** 2 * 3 * Module Name: dmtbdump2 - Dump ACPI data tables that contain no AML code 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2022, 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 /* IORT Revisions E, E.a and E.c have known issues and are not supported */ 99 100 if (Revision == 1 || Revision == 2 || Revision == 4) 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 DbgPrint (ASL_PARSE_OUTPUT, "//0B) Offset %X, from table start: 0x%8.8X%8.8X\n", 783 Offset, ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table))); 784 while (Offset < Table->Length) 785 { 786 /* Common subtable header */ 787 788 AcpiOsPrintf ("\n"); 789 Status = AcpiDmDumpTable (Length, Offset, Subtable, 790 Subtable->Length, AcpiDmTableInfoMadtHdr); 791 if (ACPI_FAILURE (Status)) 792 { 793 return; 794 } 795 796 DbgPrint (ASL_PARSE_OUTPUT, "subtableType: %X\n", Subtable->Type); 797 switch (Subtable->Type) 798 { 799 case ACPI_MADT_TYPE_LOCAL_APIC: 800 801 InfoTable = AcpiDmTableInfoMadt0; 802 break; 803 804 case ACPI_MADT_TYPE_IO_APIC: 805 806 InfoTable = AcpiDmTableInfoMadt1; 807 break; 808 809 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 810 811 InfoTable = AcpiDmTableInfoMadt2; 812 break; 813 814 case ACPI_MADT_TYPE_NMI_SOURCE: 815 816 InfoTable = AcpiDmTableInfoMadt3; 817 break; 818 819 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 820 821 InfoTable = AcpiDmTableInfoMadt4; 822 break; 823 824 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 825 826 InfoTable = AcpiDmTableInfoMadt5; 827 break; 828 829 case ACPI_MADT_TYPE_IO_SAPIC: 830 831 InfoTable = AcpiDmTableInfoMadt6; 832 break; 833 834 case ACPI_MADT_TYPE_LOCAL_SAPIC: 835 836 InfoTable = AcpiDmTableInfoMadt7; 837 break; 838 839 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 840 841 InfoTable = AcpiDmTableInfoMadt8; 842 break; 843 844 case ACPI_MADT_TYPE_LOCAL_X2APIC: 845 846 InfoTable = AcpiDmTableInfoMadt9; 847 break; 848 849 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 850 851 InfoTable = AcpiDmTableInfoMadt10; 852 break; 853 854 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 855 856 InfoTable = AcpiDmTableInfoMadt11; 857 break; 858 859 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 860 861 InfoTable = AcpiDmTableInfoMadt12; 862 break; 863 864 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME: 865 866 InfoTable = AcpiDmTableInfoMadt13; 867 break; 868 869 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR: 870 871 InfoTable = AcpiDmTableInfoMadt14; 872 break; 873 874 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR: 875 876 InfoTable = AcpiDmTableInfoMadt15; 877 break; 878 879 case ACPI_MADT_TYPE_MULTIPROC_WAKEUP: 880 881 InfoTable = AcpiDmTableInfoMadt16; 882 break; 883 884 default: 885 886 if ((Subtable->Type >= ACPI_MADT_TYPE_RESERVED) && 887 (Subtable->Type < ACPI_MADT_TYPE_OEM_RESERVED)) 888 { 889 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n", 890 Subtable->Type); 891 goto NextSubtable; 892 } 893 else if (Subtable->Type >= ACPI_MADT_TYPE_OEM_RESERVED) 894 { 895 DbgPrint (ASL_PARSE_OUTPUT, "//[Found an OEM structure, type = %0x]\n", 896 Subtable->Type); 897 Offset += sizeof (ACPI_SUBTABLE_HEADER); 898 DbgPrint (ASL_PARSE_OUTPUT, "//[0) Subtable->Length = %X, Subtable = %p, Offset = %X]\n", 899 Subtable->Length, Subtable, Offset); 900 DbgPrint (ASL_PARSE_OUTPUT, "//[0A) Offset from table start: 0x%8.8X%8.8X]\n", 901 ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table))); 902 } 903 904 /* Attempt to continue */ 905 906 if (!Subtable->Length) 907 { 908 AcpiOsPrintf ("Invalid zero length subtable\n"); 909 return; 910 } 911 912 /* Dump the OEM data */ 913 914 Status = AcpiDmDumpTable (Length, Offset, ACPI_CAST_PTR (UINT8, Table) + Offset, 915 Subtable->Length - sizeof (ACPI_SUBTABLE_HEADER), AcpiDmTableInfoMadt17); 916 if (ACPI_FAILURE (Status)) 917 { 918 return; 919 } 920 921 DbgPrint (ASL_PARSE_OUTPUT, "//[1) Subtable->Length = %X, Offset = %X]\n", 922 Subtable->Length, Offset); 923 Offset -= sizeof (ACPI_SUBTABLE_HEADER); 924 925 goto NextSubtable; 926 } 927 928 DbgPrint (ASL_PARSE_OUTPUT, "//[2) Subtable->Length = %X, Offset = %X]\n", 929 Subtable->Length, Offset); 930 Status = AcpiDmDumpTable (Length, Offset, Subtable, 931 Subtable->Length, InfoTable); 932 if (ACPI_FAILURE (Status)) 933 { 934 return; 935 } 936 937 NextSubtable: 938 /* Point to next subtable */ 939 940 DbgPrint (ASL_PARSE_OUTPUT, "//[3) Subtable->Length = %X, Offset = %X]\n", 941 Subtable->Length, Offset); 942 DbgPrint (ASL_PARSE_OUTPUT, "//[4) Offset from table start: 0x%8.8X%8.8X (%p) %p]\n", 943 ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (UINT8, Subtable) - ACPI_CAST_PTR (UINT8, Table)), Subtable, Table); 944 if (Offset > Table->Length) 945 { 946 return; 947 } 948 949 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, 950 Subtable->Length); 951 952 DbgPrint (ASL_PARSE_OUTPUT, "//[5) Next Subtable %p, length %X]\n", 953 Subtable, Subtable->Length); 954 DbgPrint (ASL_PARSE_OUTPUT, "//[5B) Offset from table start: 0x%8.8X%8.8X (%p)]\n", 955 ACPI_FORMAT_UINT64 (ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table)), Subtable); 956 957 Offset = ACPI_CAST_PTR (char, Subtable) - ACPI_CAST_PTR (char, Table); 958 if (Offset >= Table->Length) 959 { 960 return; 961 } 962 } 963 } 964 965 966 /******************************************************************************* 967 * 968 * FUNCTION: AcpiDmDumpMcfg 969 * 970 * PARAMETERS: Table - A MCFG Table 971 * 972 * RETURN: None 973 * 974 * DESCRIPTION: Format the contents of a MCFG table 975 * 976 ******************************************************************************/ 977 978 void 979 AcpiDmDumpMcfg ( 980 ACPI_TABLE_HEADER *Table) 981 { 982 ACPI_STATUS Status; 983 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 984 ACPI_MCFG_ALLOCATION *Subtable; 985 986 987 /* Main table */ 988 989 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 990 if (ACPI_FAILURE (Status)) 991 { 992 return; 993 } 994 995 /* Subtables */ 996 997 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 998 while (Offset < Table->Length) 999 { 1000 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 1001 { 1002 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", 1003 (UINT32) sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 1004 return; 1005 } 1006 1007 AcpiOsPrintf ("\n"); 1008 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1009 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 1010 if (ACPI_FAILURE (Status)) 1011 { 1012 return; 1013 } 1014 1015 /* Point to next subtable (each subtable is of fixed length) */ 1016 1017 Offset += sizeof (ACPI_MCFG_ALLOCATION); 1018 Subtable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Subtable, 1019 sizeof (ACPI_MCFG_ALLOCATION)); 1020 } 1021 } 1022 1023 1024 /******************************************************************************* 1025 * 1026 * FUNCTION: AcpiDmDumpMpst 1027 * 1028 * PARAMETERS: Table - A MPST Table 1029 * 1030 * RETURN: None 1031 * 1032 * DESCRIPTION: Format the contents of a MPST table 1033 * 1034 ******************************************************************************/ 1035 1036 void 1037 AcpiDmDumpMpst ( 1038 ACPI_TABLE_HEADER *Table) 1039 { 1040 ACPI_STATUS Status; 1041 UINT32 Offset = sizeof (ACPI_TABLE_MPST); 1042 ACPI_MPST_POWER_NODE *Subtable0; 1043 ACPI_MPST_POWER_STATE *Subtable0A; 1044 ACPI_MPST_COMPONENT *Subtable0B; 1045 ACPI_MPST_DATA_HDR *Subtable1; 1046 ACPI_MPST_POWER_DATA *Subtable2; 1047 UINT16 SubtableCount; 1048 UINT32 PowerStateCount; 1049 UINT32 ComponentCount; 1050 1051 1052 /* Main table */ 1053 1054 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); 1055 if (ACPI_FAILURE (Status)) 1056 { 1057 return; 1058 } 1059 1060 /* Subtable: Memory Power Node(s) */ 1061 1062 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; 1063 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); 1064 1065 while ((Offset < Table->Length) && SubtableCount) 1066 { 1067 AcpiOsPrintf ("\n"); 1068 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0, 1069 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); 1070 if (ACPI_FAILURE (Status)) 1071 { 1072 return; 1073 } 1074 1075 /* Extract the sub-subtable counts */ 1076 1077 PowerStateCount = Subtable0->NumPowerStates; 1078 ComponentCount = Subtable0->NumPhysicalComponents; 1079 Offset += sizeof (ACPI_MPST_POWER_NODE); 1080 1081 /* Sub-subtables - Memory Power State Structure(s) */ 1082 1083 Subtable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, Subtable0, 1084 sizeof (ACPI_MPST_POWER_NODE)); 1085 1086 while (PowerStateCount) 1087 { 1088 AcpiOsPrintf ("\n"); 1089 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0A, 1090 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); 1091 if (ACPI_FAILURE (Status)) 1092 { 1093 return; 1094 } 1095 1096 Subtable0A++; 1097 PowerStateCount--; 1098 Offset += sizeof (ACPI_MPST_POWER_STATE); 1099 } 1100 1101 /* Sub-subtables - Physical Component ID Structure(s) */ 1102 1103 Subtable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, Subtable0A); 1104 1105 if (ComponentCount) 1106 { 1107 AcpiOsPrintf ("\n"); 1108 } 1109 1110 while (ComponentCount) 1111 { 1112 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable0B, 1113 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); 1114 if (ACPI_FAILURE (Status)) 1115 { 1116 return; 1117 } 1118 1119 Subtable0B++; 1120 ComponentCount--; 1121 Offset += sizeof (ACPI_MPST_COMPONENT); 1122 } 1123 1124 /* Point to next Memory Power Node subtable */ 1125 1126 SubtableCount--; 1127 Subtable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Subtable0, 1128 sizeof (ACPI_MPST_POWER_NODE) + 1129 (sizeof (ACPI_MPST_POWER_STATE) * Subtable0->NumPowerStates) + 1130 (sizeof (ACPI_MPST_COMPONENT) * Subtable0->NumPhysicalComponents)); 1131 } 1132 1133 /* Subtable: Count of Memory Power State Characteristic structures */ 1134 1135 AcpiOsPrintf ("\n"); 1136 Subtable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, Subtable0); 1137 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable1, 1138 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); 1139 if (ACPI_FAILURE (Status)) 1140 { 1141 return; 1142 } 1143 1144 SubtableCount = Subtable1->CharacteristicsCount; 1145 Offset += sizeof (ACPI_MPST_DATA_HDR); 1146 1147 /* Subtable: Memory Power State Characteristics structure(s) */ 1148 1149 Subtable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, Subtable1, 1150 sizeof (ACPI_MPST_DATA_HDR)); 1151 1152 while ((Offset < Table->Length) && SubtableCount) 1153 { 1154 AcpiOsPrintf ("\n"); 1155 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable2, 1156 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); 1157 if (ACPI_FAILURE (Status)) 1158 { 1159 return; 1160 } 1161 1162 Subtable2++; 1163 SubtableCount--; 1164 Offset += sizeof (ACPI_MPST_POWER_DATA); 1165 } 1166 } 1167 1168 1169 /******************************************************************************* 1170 * 1171 * FUNCTION: AcpiDmDumpMsct 1172 * 1173 * PARAMETERS: Table - A MSCT table 1174 * 1175 * RETURN: None 1176 * 1177 * DESCRIPTION: Format the contents of a MSCT 1178 * 1179 ******************************************************************************/ 1180 1181 void 1182 AcpiDmDumpMsct ( 1183 ACPI_TABLE_HEADER *Table) 1184 { 1185 ACPI_STATUS Status; 1186 UINT32 Offset = sizeof (ACPI_TABLE_MSCT); 1187 ACPI_MSCT_PROXIMITY *Subtable; 1188 1189 1190 /* Main table */ 1191 1192 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); 1193 if (ACPI_FAILURE (Status)) 1194 { 1195 return; 1196 } 1197 1198 /* Subtables */ 1199 1200 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); 1201 while (Offset < Table->Length) 1202 { 1203 /* Common subtable header */ 1204 1205 AcpiOsPrintf ("\n"); 1206 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1207 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); 1208 if (ACPI_FAILURE (Status)) 1209 { 1210 return; 1211 } 1212 1213 /* Point to next subtable */ 1214 1215 Offset += sizeof (ACPI_MSCT_PROXIMITY); 1216 Subtable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Subtable, 1217 sizeof (ACPI_MSCT_PROXIMITY)); 1218 } 1219 } 1220 1221 1222 /******************************************************************************* 1223 * 1224 * FUNCTION: AcpiDmDumpNfit 1225 * 1226 * PARAMETERS: Table - A NFIT table 1227 * 1228 * RETURN: None 1229 * 1230 * DESCRIPTION: Format the contents of an NFIT. 1231 * 1232 ******************************************************************************/ 1233 1234 void 1235 AcpiDmDumpNfit ( 1236 ACPI_TABLE_HEADER *Table) 1237 { 1238 ACPI_STATUS Status; 1239 UINT32 Offset = sizeof (ACPI_TABLE_NFIT); 1240 UINT32 FieldOffset = 0; 1241 UINT32 Length; 1242 ACPI_NFIT_HEADER *Subtable; 1243 ACPI_DMTABLE_INFO *InfoTable; 1244 ACPI_NFIT_INTERLEAVE *Interleave = NULL; 1245 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL; 1246 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; 1247 UINT32 i; 1248 1249 1250 /* Main table */ 1251 1252 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit); 1253 if (ACPI_FAILURE (Status)) 1254 { 1255 return; 1256 } 1257 1258 /* Subtables */ 1259 1260 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset); 1261 while (Offset < Table->Length) 1262 { 1263 /* NFIT subtable header */ 1264 1265 AcpiOsPrintf ("\n"); 1266 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1267 Subtable->Length, AcpiDmTableInfoNfitHdr); 1268 if (ACPI_FAILURE (Status)) 1269 { 1270 return; 1271 } 1272 1273 switch (Subtable->Type) 1274 { 1275 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: 1276 1277 InfoTable = AcpiDmTableInfoNfit0; 1278 break; 1279 1280 case ACPI_NFIT_TYPE_MEMORY_MAP: 1281 1282 InfoTable = AcpiDmTableInfoNfit1; 1283 break; 1284 1285 case ACPI_NFIT_TYPE_INTERLEAVE: 1286 1287 /* Has a variable number of 32-bit values at the end */ 1288 1289 InfoTable = AcpiDmTableInfoNfit2; 1290 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE); 1291 break; 1292 1293 case ACPI_NFIT_TYPE_SMBIOS: 1294 1295 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, Subtable); 1296 InfoTable = AcpiDmTableInfoNfit3; 1297 break; 1298 1299 case ACPI_NFIT_TYPE_CONTROL_REGION: 1300 1301 InfoTable = AcpiDmTableInfoNfit4; 1302 break; 1303 1304 case ACPI_NFIT_TYPE_DATA_REGION: 1305 1306 InfoTable = AcpiDmTableInfoNfit5; 1307 break; 1308 1309 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 1310 1311 /* Has a variable number of 64-bit addresses at the end */ 1312 1313 InfoTable = AcpiDmTableInfoNfit6; 1314 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64); 1315 break; 1316 1317 case ACPI_NFIT_TYPE_CAPABILITIES: /* ACPI 6.0A */ 1318 1319 InfoTable = AcpiDmTableInfoNfit7; 1320 break; 1321 1322 default: 1323 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n", 1324 Subtable->Type); 1325 1326 /* Attempt to continue */ 1327 1328 if (!Subtable->Length) 1329 { 1330 AcpiOsPrintf ("Invalid zero length subtable\n"); 1331 return; 1332 } 1333 goto NextSubtable; 1334 } 1335 1336 AcpiOsPrintf ("\n"); 1337 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1338 Subtable->Length, InfoTable); 1339 if (ACPI_FAILURE (Status)) 1340 { 1341 return; 1342 } 1343 1344 /* Per-subtable variable-length fields */ 1345 1346 switch (Subtable->Type) 1347 { 1348 case ACPI_NFIT_TYPE_INTERLEAVE: 1349 1350 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, Subtable); 1351 for (i = 0; i < Interleave->LineCount; i++) 1352 { 1353 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 1354 &Interleave->LineOffset[i], 1355 sizeof (UINT32), AcpiDmTableInfoNfit2a); 1356 if (ACPI_FAILURE (Status)) 1357 { 1358 return; 1359 } 1360 1361 FieldOffset += sizeof (UINT32); 1362 } 1363 break; 1364 1365 case ACPI_NFIT_TYPE_SMBIOS: 1366 1367 Length = Subtable->Length - 1368 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8); 1369 1370 if (Length) 1371 { 1372 Status = AcpiDmDumpTable (Table->Length, 1373 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8), 1374 SmbiosInfo, 1375 Length, AcpiDmTableInfoNfit3a); 1376 if (ACPI_FAILURE (Status)) 1377 { 1378 return; 1379 } 1380 } 1381 1382 break; 1383 1384 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 1385 1386 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, Subtable); 1387 for (i = 0; i < Hint->HintCount; i++) 1388 { 1389 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 1390 &Hint->HintAddress[i], 1391 sizeof (UINT64), AcpiDmTableInfoNfit6a); 1392 if (ACPI_FAILURE (Status)) 1393 { 1394 return; 1395 } 1396 1397 FieldOffset += sizeof (UINT64); 1398 } 1399 break; 1400 1401 default: 1402 break; 1403 } 1404 1405 NextSubtable: 1406 /* Point to next subtable */ 1407 1408 Offset += Subtable->Length; 1409 Subtable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Subtable, Subtable->Length); 1410 } 1411 } 1412 1413 1414 /******************************************************************************* 1415 * 1416 * FUNCTION: AcpiDmDumpNhlt 1417 * 1418 * PARAMETERS: Table - A NHLT table 1419 * 1420 * RETURN: None 1421 * 1422 * DESCRIPTION: Format the contents of an NHLT. 1423 * 1424 ******************************************************************************/ 1425 1426 void 1427 AcpiDmDumpNhlt ( 1428 ACPI_TABLE_HEADER *Table) 1429 { 1430 ACPI_STATUS Status; 1431 UINT32 Offset; 1432 UINT32 TableLength = Table->Length; 1433 UINT32 EndpointCount; 1434 UINT8 FormatsCount; 1435 ACPI_NHLT_ENDPOINT *Subtable; 1436 ACPI_NHLT_FORMAT_CONFIG *FormatSubtable; 1437 ACPI_TABLE_NHLT *InfoTable; 1438 UINT32 CapabilitiesSize; 1439 UINT32 i; 1440 UINT32 j; 1441 UINT32 EndpointEndOffset; 1442 UINT8 ConfigType = 0; 1443 UINT8 ArrayType; 1444 UINT8 MicrophoneCount; 1445 ACPI_NHLT_VENDOR_MIC_COUNT *MicCount; 1446 ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A *DevSpecific; 1447 ACPI_NHLT_FORMATS_CONFIG *FormatsConfig; 1448 ACPI_NHLT_DEVICE_INFO_COUNT *Count; 1449 ACPI_NHLT_DEVICE_INFO *DeviceInfo; 1450 ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B *Capabilities; 1451 1452 1453 /* Main table */ 1454 1455 AcpiOsPrintf (" /* Main table */\n"); 1456 1457 Status = AcpiDmDumpTable (TableLength, 0, Table, 0, AcpiDmTableInfoNhlt); 1458 if (ACPI_FAILURE (Status)) 1459 { 1460 return; 1461 } 1462 1463 /* Get the Endpoint Descriptor Count */ 1464 1465 InfoTable = ACPI_ADD_PTR (ACPI_TABLE_NHLT, Table, 0); 1466 EndpointCount = InfoTable->EndpointCount; 1467 1468 /* Subtables */ 1469 1470 Offset = sizeof (ACPI_TABLE_NHLT); 1471 1472 while (Offset < TableLength) 1473 { 1474 /* A variable number of Endpoint Descriptors - process each */ 1475 1476 for (i = 0; i < EndpointCount; i++) 1477 { 1478 /* Do the Endpoint Descriptor table */ 1479 1480 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset); 1481 1482 /* Check for endpoint descriptor length beyond end-of-table */ 1483 1484 if (Subtable->DescriptorLength > TableLength) 1485 { 1486 Offset += 1; 1487 AcpiOsPrintf ("\n /* Endpoint Descriptor Length larger than" 1488 " table size: %X, table %X, adjusting table offset (+1) */\n", 1489 Subtable->DescriptorLength, TableLength); 1490 1491 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset); 1492 } 1493 1494 AcpiOsPrintf ("\n /* Endpoint Descriptor #%u */\n", i+1); 1495 Status = AcpiDmDumpTable (TableLength, Offset, Subtable, 1496 Subtable->DescriptorLength, AcpiDmTableInfoNhlt0); 1497 if (ACPI_FAILURE (Status)) 1498 { 1499 return; 1500 } 1501 1502 EndpointEndOffset = Subtable->DescriptorLength + Offset; 1503 1504 /* Check for endpoint descriptor beyond end-of-table */ 1505 1506 if (Subtable->DescriptorLength > TableLength) 1507 { 1508 AcpiOsPrintf ("\n /* Endpoint Descriptor Length larger than table size: %X, table %X */\n", 1509 Subtable->DescriptorLength, TableLength); 1510 } 1511 1512 Offset += sizeof (ACPI_NHLT_ENDPOINT); 1513 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset); 1514 1515 /* Do the Device Specific table */ 1516 1517 AcpiOsPrintf ("\n /* Endpoint Device_Specific_Config table */\n"); 1518 DevSpecific = ACPI_CAST_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Subtable); 1519 CapabilitiesSize = DevSpecific->CapabilitiesSize; 1520 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1521 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B), AcpiDmTableInfoNhlt5b); 1522 if (ACPI_FAILURE (Status)) 1523 { 1524 return; 1525 } 1526 1527 ArrayType = 0; 1528 1529 /* Different subtables based upon capabilities_size */ 1530 1531 switch (CapabilitiesSize) 1532 { 1533 case 0: 1534 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B); 1535 break; 1536 1537 case 1: 1538 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1539 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_C), AcpiDmTableInfoNhlt5c); 1540 if (ACPI_FAILURE (Status)) 1541 { 1542 return; 1543 } 1544 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_C); 1545 break; 1546 1547 case 2: 1548 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1549 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG), AcpiDmTableInfoNhlt5); 1550 if (ACPI_FAILURE (Status)) 1551 { 1552 return; 1553 } 1554 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG); 1555 break; 1556 1557 case 3: 1558 default: 1559 /* Extract the ConfigType and ArrayType */ 1560 1561 ConfigType = DevSpecific->ConfigType; 1562 ArrayType = DevSpecific->ArrayType; 1563 1564 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1565 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A), AcpiDmTableInfoNhlt5a); 1566 if (ACPI_FAILURE (Status)) 1567 { 1568 return; 1569 } 1570 1571 /* Capabilities Size == 3 */ 1572 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A); 1573 break; 1574 1575 case 7: 1576 ConfigType = DevSpecific->ConfigType; 1577 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset); 1578 DevSpecific = ACPI_CAST_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Subtable); 1579 1580 AcpiOsPrintf ("\n /* Render Feedback Device-Specific table */\n"); 1581 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1582 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG), AcpiDmTableInfoNhlt5); 1583 if (ACPI_FAILURE (Status)) 1584 { 1585 return; 1586 } 1587 1588 /* Capabilities Size = 7 */ 1589 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG); 1590 1591 if (ConfigType == ACPI_NHLT_CONFIG_TYPE_RENDER_FEEDBACK) 1592 { 1593 Subtable = ACPI_ADD_PTR (ACPI_NHLT_ENDPOINT, Table, Offset); 1594 DevSpecific = ACPI_CAST_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Subtable); 1595 1596 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1597 sizeof (ACPI_NHLT_RENDER_FEEDBACK_DEVICE_SPECIFIC_CONFIG), AcpiDmTableInfoNhlt6b); 1598 if (ACPI_FAILURE (Status)) 1599 { 1600 return; 1601 } 1602 Offset += sizeof (ACPI_NHLT_RENDER_FEEDBACK_DEVICE_SPECIFIC_CONFIG); 1603 } 1604 break; 1605 } 1606 1607 /* Check for a vendor-defined mic array */ 1608 1609 if (ConfigType == ACPI_NHLT_CONFIG_TYPE_MIC_ARRAY) 1610 { 1611 if ((ArrayType & ACPI_NHLT_ARRAY_TYPE_MASK) == ACPI_NHLT_VENDOR_DEFINED) 1612 { 1613 /* Vendor-defined microphone array; get the microphone count first */ 1614 1615 AcpiOsPrintf ("\n /* Vendor-defined microphone count */\n"); 1616 MicCount = ACPI_ADD_PTR (ACPI_NHLT_VENDOR_MIC_COUNT, Table, Offset); 1617 MicrophoneCount = MicCount->MicrophoneCount; 1618 1619 Status = AcpiDmDumpTable (TableLength, Offset, MicCount, 1620 sizeof (ACPI_NHLT_VENDOR_MIC_COUNT), AcpiDmTableInfoNhlt6a); 1621 Offset += sizeof (ACPI_NHLT_VENDOR_MIC_COUNT); 1622 if (ACPI_FAILURE (Status)) 1623 { 1624 return; 1625 } 1626 1627 /* Get the vendor microphone config structure(s) */ 1628 1629 for (j = 0; j < MicrophoneCount; j++) 1630 { 1631 AcpiOsPrintf ("\n /* Vendor-defined microphone array #%u*/\n", j+1); 1632 DevSpecific = ACPI_ADD_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Table, Offset); 1633 1634 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1635 sizeof (ACPI_NHLT_VENDOR_MIC_CONFIG), AcpiDmTableInfoNhlt6); 1636 if (ACPI_FAILURE (Status)) 1637 { 1638 return; 1639 } 1640 1641 Offset += sizeof (ACPI_NHLT_VENDOR_MIC_CONFIG); 1642 } 1643 1644 /* Check for Microphone SNR and sensitivity extension */ 1645 1646 if ((ArrayType & ACPI_NHLT_ARRAY_TYPE_EXT_MASK) == ACPI_NHLT_MIC_SNR_SENSITIVITY_EXT) 1647 { 1648 AcpiOsPrintf ("\n /* Microphone SNR and sensitivity array */\n"); 1649 DevSpecific = ACPI_ADD_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_A, Table, Offset); 1650 1651 Status = AcpiDmDumpTable (TableLength, Offset, DevSpecific, 1652 sizeof (ACPI_NHLT_MIC_SNR_SENSITIVITY_EXTENSION), AcpiDmTableInfoNhlt9); 1653 if (ACPI_FAILURE (Status)) 1654 { 1655 return; 1656 } 1657 1658 Offset += sizeof (ACPI_NHLT_MIC_SNR_SENSITIVITY_EXTENSION); 1659 } 1660 } 1661 } 1662 1663 /* Do the Formats_Config table - starts with the FormatsCount field */ 1664 1665 FormatsConfig = ACPI_ADD_PTR (ACPI_NHLT_FORMATS_CONFIG, Table, Offset); 1666 FormatsCount = FormatsConfig->FormatsCount; 1667 1668 AcpiOsPrintf ("\n /* Formats_Config table */\n"); 1669 1670 /* Dump the FormatsCount value */ 1671 1672 if (FormatsCount > 0) 1673 { 1674 Status = AcpiDmDumpTable (TableLength, Offset, FormatsConfig, 1675 sizeof (ACPI_NHLT_FORMATS_CONFIG), AcpiDmTableInfoNhlt4); 1676 if (ACPI_FAILURE (Status)) 1677 { 1678 return; 1679 } 1680 } 1681 Offset += sizeof (ACPI_NHLT_FORMATS_CONFIG); 1682 1683 /* A variable number of Format_Config Descriptors - process each */ 1684 1685 for (j = 0; j < FormatsCount; j++) 1686 { 1687 FormatSubtable = ACPI_ADD_PTR (ACPI_NHLT_FORMAT_CONFIG, Table, Offset); 1688 CapabilitiesSize = FormatSubtable->CapabilitySize; 1689 1690 /* Do the Wave_extensible struct */ 1691 1692 AcpiOsPrintf ("\n /* Wave_Format_Extensible table #%u */\n", j+1); 1693 Status = AcpiDmDumpTable (TableLength, Offset, FormatSubtable, 1694 sizeof (ACPI_NHLT_FORMAT_CONFIG), AcpiDmTableInfoNhlt3); 1695 if (ACPI_FAILURE (Status)) 1696 { 1697 return; 1698 } 1699 1700 Offset += sizeof (ACPI_NHLT_FORMAT_CONFIG); 1701 1702 if (CapabilitiesSize > 0) 1703 { 1704 UINT8* CapabilitiesBuf = ACPI_ADD_PTR (UINT8, Table, Offset); 1705 /* Do the Capabilities array (of bytes) */ 1706 1707 AcpiOsPrintf ("\n /* Specific_Config table #%u */\n", j+1); 1708 1709 Status = AcpiDmDumpTable (TableLength, Offset, CapabilitiesBuf, 1710 CapabilitiesSize, AcpiDmTableInfoNhlt3a); 1711 if (ACPI_FAILURE (Status)) 1712 { 1713 return; 1714 } 1715 1716 Offset += CapabilitiesSize; /* + sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B); */ 1717 } 1718 1719 } /* for (j = 0; j < FormatsCount; j++) */ 1720 1721 /* 1722 * If we are not done with the current Endpoint yet, then there must be 1723 * some non documented structure(s) yet to be processed. First, get 1724 * the count of such structure(s). 1725 */ 1726 if (Offset < EndpointEndOffset) 1727 { 1728 AcpiOsPrintf ("\n /* Structures that are not part of NHLT spec */\n"); 1729 Count = ACPI_ADD_PTR (ACPI_NHLT_DEVICE_INFO_COUNT, Table, Offset); 1730 Status = AcpiDmDumpTable (TableLength, Offset, Count, 1731 sizeof (ACPI_NHLT_DEVICE_INFO_COUNT), AcpiDmTableInfoNhlt7); 1732 if (ACPI_FAILURE (Status)) 1733 { 1734 return; 1735 } 1736 Offset += sizeof (ACPI_NHLT_DEVICE_INFO_COUNT); 1737 1738 /* Variable number of device structures */ 1739 1740 for (j = 0; j < Count->StructureCount; j++) 1741 { 1742 DeviceInfo = ACPI_ADD_PTR (ACPI_NHLT_DEVICE_INFO, Table, Offset); 1743 AcpiOsPrintf ("\n /* Device Info structure #%u (not part of NHLT spec) */\n", j+1); 1744 1745 /* 1746 * Dump the following Device Info fields: 1747 * 1) Device ID 1748 * 2) Device Instance ID 1749 * 3) Device Port ID 1750 */ 1751 Status = AcpiDmDumpTable (TableLength, Offset, DeviceInfo, 1752 sizeof (ACPI_NHLT_DEVICE_INFO), AcpiDmTableInfoNhlt7a); 1753 if (ACPI_FAILURE (Status)) 1754 { 1755 return; 1756 } 1757 1758 Offset += sizeof (ACPI_NHLT_DEVICE_INFO); 1759 } 1760 1761 /* 1762 * Check that the current offset is not beyond the end of 1763 * this endpoint descriptor. If it is not, print those 1764 * undocumented bytes. 1765 */ 1766 if (Offset < EndpointEndOffset) 1767 { 1768 /* Unknown data at the end of the Endpoint */ 1769 UINT32 size = EndpointEndOffset - Offset; 1770 UINT8* buffer = ACPI_ADD_PTR (UINT8, Table, Offset); 1771 AcpiOsPrintf ("\n /* Unknown data at the end of the Endpoint, size: %X */\n", size); 1772 Status = AcpiDmDumpTable (TableLength, Offset, buffer, 1773 size, AcpiDmTableInfoNhlt7b); 1774 Offset = EndpointEndOffset; 1775 } 1776 1777 /* Should be at the end of the Endpoint structure. */ 1778 } 1779 1780 } /* for (i = 0; i < EndpointCount; i++) */ 1781 1782 1783 /* 1784 * Done with all of the Endpoint Descriptors, Emit the table terminator 1785 * (if such a legacy structure is present -- not in NHLT specification) 1786 */ 1787 if (Offset < TableLength) 1788 { 1789 Capabilities = ACPI_ADD_PTR (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B, Table, Offset); 1790 AcpiOsPrintf ("\n/* Terminating specific config (not part of NHLT spec) */\n"); 1791 1792 Status = AcpiDmDumpTable (TableLength, Offset, Capabilities, 1793 sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B), AcpiDmTableInfoNhlt5b); 1794 if (ACPI_FAILURE (Status)) 1795 { 1796 return; 1797 } 1798 Offset += sizeof (ACPI_NHLT_DEVICE_SPECIFIC_CONFIG_B); 1799 1800 if (Capabilities->CapabilitiesSize > 0) 1801 { 1802 UINT32 remainingBytes = TableLength - Offset; 1803 UINT8* buffer = ACPI_ADD_PTR (UINT8, Table, Offset); 1804 1805 if (remainingBytes != Capabilities->CapabilitiesSize) 1806 AcpiOsPrintf ("\n/* Incorrect config size, should be %X, is %X */\n", 1807 Capabilities->CapabilitiesSize, remainingBytes); 1808 Status = AcpiDmDumpTable (TableLength, Offset, buffer, 1809 remainingBytes, AcpiDmTableInfoNhlt3a); 1810 } 1811 } 1812 1813 return; 1814 } 1815 } 1816 1817 1818 /******************************************************************************* 1819 * 1820 * FUNCTION: AcpiDmDumpPcct 1821 * 1822 * PARAMETERS: Table - A PCCT table 1823 * 1824 * RETURN: None 1825 * 1826 * DESCRIPTION: Format the contents of a PCCT. This table type consists 1827 * of an open-ended number of subtables. 1828 * 1829 ******************************************************************************/ 1830 1831 void 1832 AcpiDmDumpPcct ( 1833 ACPI_TABLE_HEADER *Table) 1834 { 1835 ACPI_STATUS Status; 1836 ACPI_PCCT_SUBSPACE *Subtable; 1837 ACPI_DMTABLE_INFO *InfoTable; 1838 UINT32 Length = Table->Length; 1839 UINT32 Offset = sizeof (ACPI_TABLE_PCCT); 1840 1841 1842 /* Main table */ 1843 1844 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); 1845 if (ACPI_FAILURE (Status)) 1846 { 1847 return; 1848 } 1849 1850 /* Subtables */ 1851 1852 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); 1853 while (Offset < Table->Length) 1854 { 1855 /* Common subtable header */ 1856 1857 AcpiOsPrintf ("\n"); 1858 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1859 Subtable->Header.Length, AcpiDmTableInfoPcctHdr); 1860 if (ACPI_FAILURE (Status)) 1861 { 1862 return; 1863 } 1864 1865 switch (Subtable->Header.Type) 1866 { 1867 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: 1868 1869 InfoTable = AcpiDmTableInfoPcct0; 1870 break; 1871 1872 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: 1873 1874 InfoTable = AcpiDmTableInfoPcct1; 1875 break; 1876 1877 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2: 1878 1879 InfoTable = AcpiDmTableInfoPcct2; 1880 break; 1881 1882 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE: 1883 1884 InfoTable = AcpiDmTableInfoPcct3; 1885 break; 1886 1887 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE: 1888 1889 InfoTable = AcpiDmTableInfoPcct4; 1890 break; 1891 1892 case ACPI_PCCT_TYPE_HW_REG_COMM_SUBSPACE: 1893 1894 InfoTable = AcpiDmTableInfoPcct5; 1895 break; 1896 1897 default: 1898 1899 AcpiOsPrintf ( 1900 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n", 1901 Subtable->Header.Type); 1902 return; 1903 } 1904 1905 AcpiOsPrintf ("\n"); 1906 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1907 Subtable->Header.Length, InfoTable); 1908 if (ACPI_FAILURE (Status)) 1909 { 1910 return; 1911 } 1912 1913 /* Point to next subtable */ 1914 1915 Offset += Subtable->Header.Length; 1916 Subtable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Subtable, 1917 Subtable->Header.Length); 1918 } 1919 } 1920 1921 1922 /******************************************************************************* 1923 * 1924 * FUNCTION: AcpiDmDumpPdtt 1925 * 1926 * PARAMETERS: Table - A PDTT table 1927 * 1928 * RETURN: None 1929 * 1930 * DESCRIPTION: Format the contents of a Pdtt. This is a variable-length 1931 * table that contains an open-ended number of IDs 1932 * at the end of the table. 1933 * 1934 ******************************************************************************/ 1935 1936 void 1937 AcpiDmDumpPdtt ( 1938 ACPI_TABLE_HEADER *Table) 1939 { 1940 ACPI_STATUS Status; 1941 ACPI_PDTT_CHANNEL *Subtable; 1942 UINT32 Length = Table->Length; 1943 UINT32 Offset = sizeof (ACPI_TABLE_PDTT); 1944 1945 1946 /* Main table */ 1947 1948 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPdtt); 1949 if (ACPI_FAILURE (Status)) 1950 { 1951 return; 1952 } 1953 1954 /* Subtables. Currently there is only one type, but can be multiples */ 1955 1956 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Table, Offset); 1957 while (Offset < Table->Length) 1958 { 1959 AcpiOsPrintf ("\n"); 1960 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1961 sizeof (ACPI_PDTT_CHANNEL), AcpiDmTableInfoPdtt0); 1962 if (ACPI_FAILURE (Status)) 1963 { 1964 return; 1965 } 1966 1967 /* Point to next subtable */ 1968 1969 Offset += sizeof (ACPI_PDTT_CHANNEL); 1970 Subtable = ACPI_ADD_PTR (ACPI_PDTT_CHANNEL, Subtable, 1971 sizeof (ACPI_PDTT_CHANNEL)); 1972 } 1973 } 1974 1975 1976 /******************************************************************************* 1977 * 1978 * FUNCTION: AcpiDmDumpPhat 1979 * 1980 * PARAMETERS: Table - A PHAT table 1981 * 1982 * RETURN: None 1983 * 1984 * DESCRIPTION: Format the contents of a PHAT. 1985 * 1986 ******************************************************************************/ 1987 1988 void 1989 AcpiDmDumpPhat ( 1990 ACPI_TABLE_HEADER *Table) 1991 { 1992 ACPI_STATUS Status; 1993 ACPI_DMTABLE_INFO *InfoTable; 1994 ACPI_PHAT_HEADER *Subtable; 1995 ACPI_PHAT_VERSION_DATA *VersionData; 1996 UINT32 RecordCount; 1997 UINT32 Length = Table->Length; 1998 UINT32 Offset = sizeof (ACPI_TABLE_PHAT); 1999 UINT32 SubtableLength; 2000 UINT32 PathLength; 2001 UINT32 VendorLength; 2002 2003 2004 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, sizeof (ACPI_TABLE_PHAT)); 2005 2006 while (Offset < Table->Length) 2007 { 2008 /* Common subtable header */ 2009 2010 AcpiOsPrintf ("\n"); 2011 Status = AcpiDmDumpTable (Length, 0, Subtable, 2012 sizeof (ACPI_PHAT_HEADER), AcpiDmTableInfoPhatHdr); 2013 if (ACPI_FAILURE (Status)) 2014 { 2015 return; 2016 } 2017 2018 switch (Subtable->Type) 2019 { 2020 case ACPI_PHAT_TYPE_FW_VERSION_DATA: 2021 2022 InfoTable = AcpiDmTableInfoPhat0; 2023 SubtableLength = sizeof (ACPI_PHAT_VERSION_DATA); 2024 break; 2025 2026 case ACPI_PHAT_TYPE_FW_HEALTH_DATA: 2027 2028 InfoTable = AcpiDmTableInfoPhat1; 2029 SubtableLength = sizeof (ACPI_PHAT_HEALTH_DATA); 2030 break; 2031 2032 default: 2033 2034 AcpiOsPrintf ("\n**** Unknown PHAT subtable type 0x%X\n\n", 2035 Subtable->Type); 2036 2037 return; 2038 } 2039 2040 Status = AcpiDmDumpTable (Length, 0, Subtable, 2041 SubtableLength, InfoTable); 2042 if (ACPI_FAILURE (Status)) 2043 { 2044 return; 2045 } 2046 2047 switch (Subtable->Type) 2048 { 2049 case ACPI_PHAT_TYPE_FW_VERSION_DATA: 2050 2051 VersionData = ACPI_CAST_PTR (ACPI_PHAT_VERSION_DATA, Subtable); 2052 RecordCount = VersionData->ElementCount; 2053 while (RecordCount) 2054 { 2055 Status = AcpiDmDumpTable (Length, Offset, 2056 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_VERSION_DATA)), 2057 sizeof (ACPI_PHAT_VERSION_ELEMENT), AcpiDmTableInfoPhat0a); 2058 if (ACPI_FAILURE (Status)) 2059 { 2060 return; 2061 } 2062 2063 RecordCount--; 2064 } 2065 2066 break; 2067 2068 case ACPI_PHAT_TYPE_FW_HEALTH_DATA: 2069 2070 /* account for the null terminator */ 2071 2072 PathLength = strlen (ACPI_ADD_PTR (char, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA))) + 1; 2073 Status = AcpiDmDumpTable (Length, Offset, 2074 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA)), 2075 PathLength, AcpiDmTableInfoPhat1a); 2076 if (ACPI_FAILURE (Status)) 2077 { 2078 return; 2079 } 2080 2081 /* Get vendor data - data length is the remaining subtable length */ 2082 2083 VendorLength = 2084 Subtable->Length - sizeof (ACPI_PHAT_HEALTH_DATA) - PathLength; 2085 Status = AcpiDmDumpTable (Length, 0, 2086 ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA) + PathLength), 2087 VendorLength, AcpiDmTableInfoPhat1b); 2088 if (ACPI_FAILURE (Status)) 2089 { 2090 return; 2091 } 2092 break; 2093 2094 default: 2095 2096 AcpiOsPrintf ("\n**** Unknown PHAT subtable type 0x%X\n\n", 2097 Subtable->Type); 2098 return; 2099 } 2100 2101 /* Next subtable */ 2102 2103 Offset += Subtable->Length; 2104 Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, 2105 Subtable->Length); 2106 } 2107 } 2108 2109 2110 /******************************************************************************* 2111 * 2112 * FUNCTION: AcpiDmDumpPmtt 2113 * 2114 * PARAMETERS: Table - A PMTT table 2115 * 2116 * RETURN: None 2117 * 2118 * DESCRIPTION: Format the contents of a PMTT. This table type consists 2119 * of an open-ended number of subtables. 2120 * 2121 ******************************************************************************/ 2122 2123 void 2124 AcpiDmDumpPmtt ( 2125 ACPI_TABLE_HEADER *Table) 2126 { 2127 ACPI_STATUS Status; 2128 ACPI_PMTT_HEADER *Subtable; 2129 UINT32 Length = Table->Length; 2130 UINT32 Offset = sizeof (ACPI_TABLE_PMTT); 2131 2132 2133 /* Main table */ 2134 2135 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); 2136 if (ACPI_FAILURE (Status)) 2137 { 2138 return; 2139 } 2140 2141 /* Subtables */ 2142 2143 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); 2144 while (Offset < Table->Length) 2145 { 2146 /* Each of the types below contain the common subtable header */ 2147 2148 AcpiOsPrintf ("\n"); 2149 switch (Subtable->Type) 2150 { 2151 case ACPI_PMTT_TYPE_SOCKET: 2152 2153 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2154 Subtable->Length, AcpiDmTableInfoPmtt0); 2155 if (ACPI_FAILURE (Status)) 2156 { 2157 return; 2158 } 2159 break; 2160 2161 case ACPI_PMTT_TYPE_CONTROLLER: 2162 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2163 Subtable->Length, AcpiDmTableInfoPmtt1); 2164 if (ACPI_FAILURE (Status)) 2165 { 2166 return; 2167 } 2168 break; 2169 2170 case ACPI_PMTT_TYPE_DIMM: 2171 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2172 Subtable->Length, AcpiDmTableInfoPmtt2); 2173 if (ACPI_FAILURE (Status)) 2174 { 2175 return; 2176 } 2177 break; 2178 2179 case ACPI_PMTT_TYPE_VENDOR: 2180 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2181 Subtable->Length, AcpiDmTableInfoPmttVendor); 2182 if (ACPI_FAILURE (Status)) 2183 { 2184 return; 2185 } 2186 break; 2187 2188 default: 2189 AcpiOsPrintf ( 2190 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2191 Subtable->Type); 2192 return; 2193 } 2194 2195 /* Point to next subtable */ 2196 2197 Offset += Subtable->Length; 2198 Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2199 Subtable, Subtable->Length); 2200 } 2201 } 2202 2203 2204 /******************************************************************************* 2205 * 2206 * FUNCTION: AcpiDmDumpPptt 2207 * 2208 * PARAMETERS: Table - A PMTT table 2209 * 2210 * RETURN: None 2211 * 2212 * DESCRIPTION: Format the contents of a PPTT. This table type consists 2213 * of an open-ended number of subtables. 2214 * 2215 ******************************************************************************/ 2216 2217 void 2218 AcpiDmDumpPptt ( 2219 ACPI_TABLE_HEADER *Table) 2220 { 2221 ACPI_STATUS Status; 2222 ACPI_SUBTABLE_HEADER *Subtable; 2223 ACPI_PPTT_PROCESSOR *PpttProcessor; 2224 UINT8 Length; 2225 UINT8 SubtableOffset; 2226 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 2227 ACPI_DMTABLE_INFO *InfoTable; 2228 UINT32 i; 2229 2230 2231 /* There is no main table (other than the standard ACPI header) */ 2232 2233 /* Subtables */ 2234 2235 Offset = sizeof (ACPI_TABLE_HEADER); 2236 while (Offset < Table->Length) 2237 { 2238 AcpiOsPrintf ("\n"); 2239 2240 /* Common subtable header */ 2241 2242 Subtable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 2243 if (Subtable->Length < sizeof (ACPI_SUBTABLE_HEADER)) 2244 { 2245 AcpiOsPrintf ("Invalid subtable length\n"); 2246 return; 2247 } 2248 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 2249 Subtable->Length, AcpiDmTableInfoPpttHdr); 2250 if (ACPI_FAILURE (Status)) 2251 { 2252 return; 2253 } 2254 2255 switch (Subtable->Type) 2256 { 2257 case ACPI_PPTT_TYPE_PROCESSOR: 2258 2259 InfoTable = AcpiDmTableInfoPptt0; 2260 Length = sizeof (ACPI_PPTT_PROCESSOR); 2261 break; 2262 2263 case ACPI_PPTT_TYPE_CACHE: 2264 2265 InfoTable = AcpiDmTableInfoPptt1; 2266 Length = sizeof (ACPI_PPTT_CACHE); 2267 break; 2268 2269 case ACPI_PPTT_TYPE_ID: 2270 2271 InfoTable = AcpiDmTableInfoPptt2; 2272 Length = sizeof (ACPI_PPTT_ID); 2273 break; 2274 2275 default: 2276 2277 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n", 2278 Subtable->Type); 2279 2280 /* Attempt to continue */ 2281 2282 goto NextSubtable; 2283 } 2284 2285 if (Subtable->Length < Length) 2286 { 2287 AcpiOsPrintf ("Invalid subtable length\n"); 2288 return; 2289 } 2290 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 2291 Subtable->Length, InfoTable); 2292 if (ACPI_FAILURE (Status)) 2293 { 2294 return; 2295 } 2296 SubtableOffset = Length; 2297 2298 switch (Subtable->Type) 2299 { 2300 case ACPI_PPTT_TYPE_PROCESSOR: 2301 2302 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, Subtable); 2303 2304 /* Dump SMBIOS handles */ 2305 2306 if ((UINT8)(Subtable->Length - SubtableOffset) < 2307 (UINT8)(PpttProcessor->NumberOfPrivResources * 4)) 2308 { 2309 AcpiOsPrintf ("Invalid private resource number\n"); 2310 return; 2311 } 2312 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++) 2313 { 2314 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2315 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset), 2316 4, AcpiDmTableInfoPptt0a); 2317 if (ACPI_FAILURE (Status)) 2318 { 2319 return; 2320 } 2321 2322 SubtableOffset += 4; 2323 } 2324 break; 2325 2326 case ACPI_PPTT_TYPE_CACHE: 2327 2328 if (Table->Revision < 3) 2329 { 2330 break; 2331 } 2332 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2333 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset), 2334 sizeof (ACPI_PPTT_CACHE_V1), AcpiDmTableInfoPptt1a); 2335 if (ACPI_FAILURE (Status)) 2336 { 2337 return; 2338 } 2339 break; 2340 2341 default: 2342 2343 break; 2344 } 2345 2346 NextSubtable: 2347 /* Point to next subtable */ 2348 2349 Offset += Subtable->Length; 2350 } 2351 } 2352 2353 2354 /******************************************************************************* 2355 * 2356 * FUNCTION: AcpiDmDumpPrmt 2357 * 2358 * PARAMETERS: Table - A PRMT table 2359 * 2360 * RETURN: None 2361 * 2362 * DESCRIPTION: Format the contents of a PRMT. This table type consists 2363 * of an open-ended number of subtables. 2364 * 2365 ******************************************************************************/ 2366 2367 void 2368 AcpiDmDumpPrmt ( 2369 ACPI_TABLE_HEADER *Table) 2370 { 2371 UINT32 CurrentOffset = sizeof (ACPI_TABLE_HEADER); 2372 ACPI_TABLE_PRMT_HEADER *PrmtHeader; 2373 ACPI_PRMT_MODULE_INFO *PrmtModuleInfo; 2374 ACPI_PRMT_HANDLER_INFO *PrmtHandlerInfo; 2375 ACPI_STATUS Status; 2376 UINT32 i, j; 2377 2378 2379 /* Main table header */ 2380 2381 PrmtHeader = ACPI_ADD_PTR (ACPI_TABLE_PRMT_HEADER, Table, CurrentOffset); 2382 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHeader, 2383 sizeof (ACPI_TABLE_PRMT_HEADER), AcpiDmTableInfoPrmtHdr); 2384 if (ACPI_FAILURE (Status)) 2385 { 2386 AcpiOsPrintf ("Invalid PRMT header\n"); 2387 return; 2388 } 2389 2390 CurrentOffset += sizeof (ACPI_TABLE_PRMT_HEADER); 2391 2392 /* PRM Module Information Structure array */ 2393 2394 for (i = 0; i < PrmtHeader->ModuleInfoCount; ++i) 2395 { 2396 PrmtModuleInfo = ACPI_ADD_PTR (ACPI_PRMT_MODULE_INFO, Table, CurrentOffset); 2397 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtModuleInfo, 2398 sizeof (ACPI_PRMT_MODULE_INFO), AcpiDmTableInfoPrmtModule); 2399 2400 CurrentOffset += sizeof (ACPI_PRMT_MODULE_INFO); 2401 2402 /* PRM handler information structure array */ 2403 2404 for (j = 0; j < PrmtModuleInfo->HandlerInfoCount; ++j) 2405 { 2406 PrmtHandlerInfo = ACPI_ADD_PTR (ACPI_PRMT_HANDLER_INFO, Table, CurrentOffset); 2407 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, PrmtHandlerInfo, 2408 sizeof (ACPI_PRMT_HANDLER_INFO), AcpiDmTableInfoPrmtHandler); 2409 2410 CurrentOffset += sizeof (ACPI_PRMT_HANDLER_INFO); 2411 } 2412 } 2413 } 2414 2415 2416 /******************************************************************************* 2417 * 2418 * FUNCTION: AcpiDmDumpRgrt 2419 * 2420 * PARAMETERS: Table - A RGRT table 2421 * 2422 * RETURN: None 2423 * 2424 * DESCRIPTION: Format the contents of a RGRT 2425 * 2426 ******************************************************************************/ 2427 2428 void 2429 AcpiDmDumpRgrt ( 2430 ACPI_TABLE_HEADER *Table) 2431 { 2432 ACPI_STATUS Status; 2433 ACPI_TABLE_RGRT *Subtable = ACPI_CAST_PTR (ACPI_TABLE_RGRT, Table); 2434 UINT32 Offset = sizeof (ACPI_TABLE_RGRT); 2435 2436 2437 /* Main table */ 2438 2439 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoRgrt); 2440 if (ACPI_FAILURE (Status)) 2441 { 2442 return; 2443 } 2444 2445 /* Dump the binary image as a subtable */ 2446 2447 Status = AcpiDmDumpTable (Table->Length, Offset, &Subtable->Image, 2448 Table->Length - Offset, AcpiDmTableInfoRgrt0); 2449 if (ACPI_FAILURE (Status)) 2450 { 2451 return; 2452 } 2453 } 2454 2455 2456 /******************************************************************************* 2457 * 2458 * FUNCTION: AcpiDmDumpS3pt 2459 * 2460 * PARAMETERS: Table - A S3PT table 2461 * 2462 * RETURN: Length of the table 2463 * 2464 * DESCRIPTION: Format the contents of a S3PT 2465 * 2466 ******************************************************************************/ 2467 2468 UINT32 2469 AcpiDmDumpS3pt ( 2470 ACPI_TABLE_HEADER *Tables) 2471 { 2472 ACPI_STATUS Status; 2473 UINT32 Offset = sizeof (ACPI_TABLE_S3PT); 2474 ACPI_FPDT_HEADER *Subtable; 2475 ACPI_DMTABLE_INFO *InfoTable; 2476 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); 2477 2478 2479 /* Main table */ 2480 2481 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt); 2482 if (ACPI_FAILURE (Status)) 2483 { 2484 return 0; 2485 } 2486 2487 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset); 2488 while (Offset < S3ptTable->Length) 2489 { 2490 /* Common subtable header */ 2491 2492 AcpiOsPrintf ("\n"); 2493 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable, 2494 Subtable->Length, AcpiDmTableInfoS3ptHdr); 2495 if (ACPI_FAILURE (Status)) 2496 { 2497 return 0; 2498 } 2499 2500 switch (Subtable->Type) 2501 { 2502 case ACPI_S3PT_TYPE_RESUME: 2503 2504 InfoTable = AcpiDmTableInfoS3pt0; 2505 break; 2506 2507 case ACPI_S3PT_TYPE_SUSPEND: 2508 2509 InfoTable = AcpiDmTableInfoS3pt1; 2510 break; 2511 2512 default: 2513 2514 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", 2515 Subtable->Type); 2516 2517 /* Attempt to continue */ 2518 2519 if (!Subtable->Length) 2520 { 2521 AcpiOsPrintf ("Invalid zero length subtable\n"); 2522 return 0; 2523 } 2524 goto NextSubtable; 2525 } 2526 2527 AcpiOsPrintf ("\n"); 2528 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, Subtable, 2529 Subtable->Length, InfoTable); 2530 if (ACPI_FAILURE (Status)) 2531 { 2532 return 0; 2533 } 2534 2535 NextSubtable: 2536 /* Point to next subtable */ 2537 2538 Offset += Subtable->Length; 2539 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, Subtable->Length); 2540 } 2541 2542 return (S3ptTable->Length); 2543 } 2544 2545 2546 /******************************************************************************* 2547 * 2548 * FUNCTION: AcpiDmDumpSdev 2549 * 2550 * PARAMETERS: Table - A SDEV table 2551 * 2552 * RETURN: None 2553 * 2554 * DESCRIPTION: Format the contents of a SDEV. This is a variable-length 2555 * table that contains variable strings and vendor data. 2556 * 2557 ******************************************************************************/ 2558 2559 void 2560 AcpiDmDumpSdev ( 2561 ACPI_TABLE_HEADER *Table) 2562 { 2563 ACPI_STATUS Status; 2564 ACPI_SDEV_HEADER *Subtable; 2565 ACPI_SDEV_PCIE *Pcie; 2566 ACPI_SDEV_NAMESPACE *Namesp; 2567 ACPI_DMTABLE_INFO *InfoTable; 2568 ACPI_DMTABLE_INFO *SecureComponentInfoTable; 2569 UINT32 Length = Table->Length; 2570 UINT32 Offset = sizeof (ACPI_TABLE_SDEV); 2571 UINT16 PathOffset; 2572 UINT16 PathLength; 2573 UINT16 VendorDataOffset; 2574 UINT16 VendorDataLength; 2575 ACPI_SDEV_SECURE_COMPONENT *SecureComponent = NULL; 2576 UINT32 CurrentOffset = 0; 2577 2578 2579 /* Main table */ 2580 2581 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoSdev); 2582 if (ACPI_FAILURE (Status)) 2583 { 2584 return; 2585 } 2586 2587 /* Subtables */ 2588 2589 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Table, Offset); 2590 while (Offset < Table->Length) 2591 { 2592 /* Common subtable header */ 2593 2594 AcpiOsPrintf ("\n"); 2595 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 2596 Subtable->Length, AcpiDmTableInfoSdevHdr); 2597 if (ACPI_FAILURE (Status)) 2598 { 2599 return; 2600 } 2601 2602 switch (Subtable->Type) 2603 { 2604 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 2605 2606 InfoTable = AcpiDmTableInfoSdev0; 2607 break; 2608 2609 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 2610 2611 InfoTable = AcpiDmTableInfoSdev1; 2612 break; 2613 2614 default: 2615 goto NextSubtable; 2616 } 2617 2618 AcpiOsPrintf ("\n"); 2619 Status = AcpiDmDumpTable (Table->Length, 0, Subtable, 2620 Subtable->Length, InfoTable); 2621 if (ACPI_FAILURE (Status)) 2622 { 2623 return; 2624 } 2625 2626 switch (Subtable->Type) 2627 { 2628 case ACPI_SDEV_TYPE_NAMESPACE_DEVICE: 2629 2630 CurrentOffset = sizeof (ACPI_SDEV_NAMESPACE); 2631 if (Subtable->Flags & ACPI_SDEV_SECURE_COMPONENTS_PRESENT) 2632 { 2633 SecureComponent = ACPI_CAST_PTR (ACPI_SDEV_SECURE_COMPONENT, 2634 ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE))); 2635 2636 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, 2637 ACPI_ADD_PTR(UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)), 2638 sizeof (ACPI_SDEV_SECURE_COMPONENT), AcpiDmTableInfoSdev0b); 2639 if (ACPI_FAILURE (Status)) 2640 { 2641 return; 2642 } 2643 CurrentOffset += sizeof (ACPI_SDEV_SECURE_COMPONENT); 2644 2645 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, 2646 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset), 2647 sizeof (ACPI_SDEV_HEADER), AcpiDmTableInfoSdevSecCompHdr); 2648 if (ACPI_FAILURE (Status)) 2649 { 2650 return; 2651 } 2652 CurrentOffset += sizeof (ACPI_SDEV_HEADER); 2653 2654 switch (Subtable->Type) 2655 { 2656 case ACPI_SDEV_TYPE_ID_COMPONENT: 2657 2658 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompId; 2659 break; 2660 2661 case ACPI_SDEV_TYPE_MEM_COMPONENT: 2662 2663 SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompMem; 2664 break; 2665 2666 default: 2667 goto NextSubtable; 2668 } 2669 2670 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, 2671 ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset), 2672 SecureComponent->SecureComponentLength, SecureComponentInfoTable); 2673 CurrentOffset += SecureComponent->SecureComponentLength; 2674 } 2675 2676 /* Dump the PCIe device ID(s) */ 2677 2678 Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable); 2679 PathOffset = Namesp->DeviceIdOffset; 2680 PathLength = Namesp->DeviceIdLength; 2681 2682 if (PathLength) 2683 { 2684 Status = AcpiDmDumpTable (Table->Length, CurrentOffset, 2685 ACPI_ADD_PTR (UINT8, Namesp, PathOffset), 2686 PathLength, AcpiDmTableInfoSdev0a); 2687 if (ACPI_FAILURE (Status)) 2688 { 2689 return; 2690 } 2691 CurrentOffset += PathLength; 2692 } 2693 2694 /* Dump the vendor-specific data */ 2695 2696 VendorDataLength = 2697 Namesp->VendorDataLength; 2698 VendorDataOffset = 2699 Namesp->DeviceIdOffset + Namesp->DeviceIdLength; 2700 2701 if (VendorDataLength) 2702 { 2703 Status = AcpiDmDumpTable (Table->Length, 0, 2704 ACPI_ADD_PTR (UINT8, Namesp, VendorDataOffset), 2705 VendorDataLength, AcpiDmTableInfoSdev1b); 2706 if (ACPI_FAILURE (Status)) 2707 { 2708 return; 2709 } 2710 } 2711 break; 2712 2713 case ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE: 2714 2715 /* PCI path substructures */ 2716 2717 Pcie = ACPI_CAST_PTR (ACPI_SDEV_PCIE, Subtable); 2718 PathOffset = Pcie->PathOffset; 2719 PathLength = Pcie->PathLength; 2720 2721 while (PathLength) 2722 { 2723 Status = AcpiDmDumpTable (Table->Length, 2724 PathOffset + Offset, 2725 ACPI_ADD_PTR (UINT8, Pcie, PathOffset), 2726 sizeof (ACPI_SDEV_PCIE_PATH), AcpiDmTableInfoSdev1a); 2727 if (ACPI_FAILURE (Status)) 2728 { 2729 return; 2730 } 2731 2732 PathOffset += sizeof (ACPI_SDEV_PCIE_PATH); 2733 PathLength -= sizeof (ACPI_SDEV_PCIE_PATH); 2734 } 2735 2736 /* VendorData */ 2737 2738 VendorDataLength = Pcie->VendorDataLength; 2739 VendorDataOffset = Pcie->PathOffset + Pcie->PathLength; 2740 2741 if (VendorDataLength) 2742 { 2743 Status = AcpiDmDumpTable (Table->Length, 0, 2744 ACPI_ADD_PTR (UINT8, Pcie, VendorDataOffset), 2745 VendorDataLength, AcpiDmTableInfoSdev1b); 2746 if (ACPI_FAILURE (Status)) 2747 { 2748 return; 2749 } 2750 } 2751 break; 2752 2753 default: 2754 goto NextSubtable; 2755 } 2756 2757 NextSubtable: 2758 /* Point to next subtable */ 2759 2760 Offset += Subtable->Length; 2761 Subtable = ACPI_ADD_PTR (ACPI_SDEV_HEADER, Subtable, 2762 Subtable->Length); 2763 } 2764 } 2765
Indexes created Tue Sep 30 06:09:59 GMT 2025