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