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