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