1 /****************************************************************************** 2 * 3 * Module Name: dmtbdump1 - 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 "acpi.h" 153 #include "accommon.h" 154 #include "acdisasm.h" 155 #include "actables.h" 156 #include "aslcompiler.h" 157 158 /* This module used for application-level code only */ 159 160 #define _COMPONENT ACPI_CA_DISASSEMBLER 161 ACPI_MODULE_NAME ("dmtbdump1") 162 163 164 /******************************************************************************* 165 * 166 * FUNCTION: AcpiDmDumpAest 167 * 168 * PARAMETERS: Table - A AEST table 169 * 170 * RETURN: None 171 * 172 * DESCRIPTION: Format the contents of a AEST table 173 * 174 * NOTE: Assumes the following table structure: 175 * For all AEST Error Nodes: 176 * 1) An AEST Error Node, followed immediately by: 177 * 2) Any node-specific data 178 * 3) An Interface Structure (one) 179 * 4) A list (array) of Interrupt Structures 180 * 181 * AEST - ARM Error Source table. Conforms to: 182 * ACPI for the Armv8 RAS Extensions 1.1 Platform Design Document Sep 2020 183 * 184 ******************************************************************************/ 185 186 void 187 AcpiDmDumpAest ( 188 ACPI_TABLE_HEADER *Table) 189 { 190 ACPI_STATUS Status; 191 UINT32 Offset = sizeof (ACPI_TABLE_HEADER); 192 ACPI_AEST_HEADER *Subtable; 193 ACPI_AEST_HEADER *NodeHeader; 194 ACPI_AEST_PROCESSOR *ProcessorSubtable; 195 ACPI_DMTABLE_INFO *InfoTable; 196 ACPI_SIZE Length; 197 UINT8 Type; 198 UINT8 Revision = Table->Revision; 199 UINT32 Count; 200 ACPI_AEST_NODE_INTERFACE_HEADER *InterfaceHeader; 201 202 203 /* Very small, generic main table. AEST consists of mostly subtables */ 204 205 while (Offset < Table->Length) 206 { 207 NodeHeader = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 208 209 /* Dump the common error node (subtable) header */ 210 211 Status = AcpiDmDumpTable (Table->Length, Offset, NodeHeader, 212 NodeHeader->Length, AcpiDmTableInfoAestHdr); 213 if (ACPI_FAILURE (Status)) 214 { 215 return; 216 } 217 218 Type = NodeHeader->Type; 219 220 /* Setup the node-specific subtable based on the header Type field */ 221 222 switch (Type) 223 { 224 case ACPI_AEST_PROCESSOR_ERROR_NODE: 225 InfoTable = AcpiDmTableInfoAestProcError; 226 Length = sizeof (ACPI_AEST_PROCESSOR); 227 break; 228 229 case ACPI_AEST_MEMORY_ERROR_NODE: 230 InfoTable = AcpiDmTableInfoAestMemError; 231 Length = sizeof (ACPI_AEST_MEMORY); 232 break; 233 234 case ACPI_AEST_SMMU_ERROR_NODE: 235 InfoTable = AcpiDmTableInfoAestSmmuError; 236 Length = sizeof (ACPI_AEST_SMMU); 237 break; 238 239 case ACPI_AEST_VENDOR_ERROR_NODE: 240 switch (Revision) 241 { 242 case 1: 243 InfoTable = AcpiDmTableInfoAestVendorError; 244 Length = sizeof (ACPI_AEST_VENDOR); 245 break; 246 247 case 2: 248 InfoTable = AcpiDmTableInfoAestVendorV2Error; 249 Length = sizeof (ACPI_AEST_VENDOR_V2); 250 break; 251 252 default: 253 AcpiOsPrintf ("\n**** Unknown AEST revision 0x%X\n", Revision); 254 return; 255 } 256 break; 257 258 case ACPI_AEST_GIC_ERROR_NODE: 259 InfoTable = AcpiDmTableInfoAestGicError; 260 Length = sizeof (ACPI_AEST_GIC); 261 break; 262 263 case ACPI_AEST_PCIE_ERROR_NODE: 264 InfoTable = AcpiDmTableInfoAestPCIeError; 265 Length = sizeof (ACPI_AEST_PCIE); 266 break; 267 268 case ACPI_AEST_PROXY_ERROR_NODE: 269 InfoTable = AcpiDmTableInfoAestProxyError; 270 Length = sizeof (ACPI_AEST_PROXY); 271 break; 272 273 /* Error case below */ 274 default: 275 276 AcpiOsPrintf ("\n**** Unknown AEST Error Subtable type 0x%X\n", 277 Type); 278 return; 279 } 280 281 /* Point past the common header (to the node-specific data) */ 282 283 Offset += sizeof (ACPI_AEST_HEADER); 284 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 285 AcpiOsPrintf ("\n"); 286 287 /* Dump the node-specific subtable */ 288 289 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, Length, 290 InfoTable); 291 if (ACPI_FAILURE (Status)) 292 { 293 return; 294 } 295 AcpiOsPrintf ("\n"); 296 297 if (Type == ACPI_AEST_PROCESSOR_ERROR_NODE) 298 { 299 /* 300 * Special handling for PROCESSOR_ERROR_NODE subtables 301 * (to handle the Resource Substructure via the ResourceType 302 * field). 303 */ 304 305 /* Point past the node-specific data */ 306 307 Offset += Length; 308 ProcessorSubtable = ACPI_CAST_PTR (ACPI_AEST_PROCESSOR, Subtable); 309 310 switch (ProcessorSubtable->ResourceType) 311 { 312 /* Setup the Resource Substructure subtable */ 313 314 case ACPI_AEST_CACHE_RESOURCE: 315 InfoTable = AcpiDmTableInfoAestCacheRsrc; 316 Length = sizeof (ACPI_AEST_PROCESSOR_CACHE); 317 break; 318 319 case ACPI_AEST_TLB_RESOURCE: 320 InfoTable = AcpiDmTableInfoAestTlbRsrc; 321 Length = sizeof (ACPI_AEST_PROCESSOR_TLB); 322 break; 323 324 case ACPI_AEST_GENERIC_RESOURCE: 325 InfoTable = AcpiDmTableInfoAestGenRsrc; 326 Length = sizeof (ACPI_AEST_PROCESSOR_GENERIC); 327 break; 328 329 /* Error case below */ 330 default: 331 AcpiOsPrintf ("\n**** Unknown AEST Processor Resource type 0x%X\n", 332 ProcessorSubtable->ResourceType); 333 return; 334 } 335 336 ProcessorSubtable = ACPI_ADD_PTR (ACPI_AEST_PROCESSOR, Table, 337 Offset); 338 339 /* Dump the resource substructure subtable */ 340 341 Status = AcpiDmDumpTable (Table->Length, Offset, ProcessorSubtable, 342 Length, InfoTable); 343 if (ACPI_FAILURE (Status)) 344 { 345 return; 346 } 347 348 AcpiOsPrintf ("\n"); 349 } 350 351 /* Point past the resource substructure or the node-specific data */ 352 353 Offset += Length; 354 355 /* Dump the interface structure, required to be present */ 356 357 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 358 if (Subtable->Type >= ACPI_AEST_XFACE_RESERVED) 359 { 360 AcpiOsPrintf ("\n**** Unknown AEST Node Interface type 0x%X\n", 361 Subtable->Type); 362 return; 363 } 364 365 if (Revision == 1) 366 { 367 InfoTable = AcpiDmTableInfoAestXface; 368 Length = sizeof (ACPI_AEST_NODE_INTERFACE); 369 } 370 else if (Revision == 2) 371 { 372 InfoTable = AcpiDmTableInfoAestXfaceHeader; 373 Length = sizeof (ACPI_AEST_NODE_INTERFACE_HEADER); 374 375 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, Length, InfoTable); 376 if (ACPI_FAILURE (Status)) 377 { 378 return; 379 } 380 381 Offset += Length; 382 383 InterfaceHeader = ACPI_CAST_PTR (ACPI_AEST_NODE_INTERFACE_HEADER, Subtable); 384 switch (InterfaceHeader->GroupFormat) 385 { 386 case ACPI_AEST_NODE_GROUP_FORMAT_4K: 387 InfoTable = AcpiDmTableInfoAestXface4k; 388 Length = sizeof (ACPI_AEST_NODE_INTERFACE_4K); 389 break; 390 391 case ACPI_AEST_NODE_GROUP_FORMAT_16K: 392 InfoTable = AcpiDmTableInfoAestXface16k; 393 Length = sizeof (ACPI_AEST_NODE_INTERFACE_16K); 394 break; 395 396 case ACPI_AEST_NODE_GROUP_FORMAT_64K: 397 InfoTable = AcpiDmTableInfoAestXface64k; 398 Length = sizeof (ACPI_AEST_NODE_INTERFACE_64K); 399 break; 400 401 default: 402 AcpiOsPrintf ("\n**** Unknown AEST Interface Group Format 0x%X\n", 403 InterfaceHeader->GroupFormat); 404 return; 405 } 406 407 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 408 } 409 else 410 { 411 AcpiOsPrintf ("\n**** Unknown AEST revision 0x%X\n", Revision); 412 return; 413 } 414 415 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, Length, InfoTable); 416 if (ACPI_FAILURE (Status)) 417 { 418 return; 419 } 420 421 /* Point past the interface structure */ 422 423 AcpiOsPrintf ("\n"); 424 Offset += Length; 425 426 /* Dump the entire interrupt structure array, if present */ 427 428 if (NodeHeader->NodeInterruptOffset) 429 { 430 Count = NodeHeader->NodeInterruptCount; 431 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 432 433 while (Count) 434 { 435 /* Dump the interrupt structure */ 436 437 switch (Revision) { 438 case 1: 439 InfoTable = AcpiDmTableInfoAestXrupt; 440 Length = sizeof (ACPI_AEST_NODE_INTERRUPT); 441 break; 442 443 case 2: 444 InfoTable = AcpiDmTableInfoAestXruptV2; 445 Length = sizeof (ACPI_AEST_NODE_INTERRUPT_V2); 446 break; 447 default: 448 AcpiOsPrintf ("\n**** Unknown AEST revision 0x%X\n", 449 Revision); 450 return; 451 } 452 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 453 Length, InfoTable); 454 if (ACPI_FAILURE (Status)) 455 { 456 return; 457 } 458 459 /* Point to the next interrupt structure */ 460 461 Offset += Length; 462 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 463 Count--; 464 AcpiOsPrintf ("\n"); 465 } 466 } 467 } 468 } 469 470 /******************************************************************************* 471 * 472 * FUNCTION: AcpiDmDumpApmt 473 * 474 * PARAMETERS: Table - A APMT table 475 * 476 * RETURN: None 477 * 478 * DESCRIPTION: Format the contents of a APMT. This table type consists 479 * of an open-ended number of subtables. 480 * 481 * 482 * APMT - ARM Performance Monitoring Unit table. Conforms to: 483 * ARM Performance Monitoring Unit Architecture 1.0 Platform Design Document 484 * ARM DEN0117 v1.0 November 25, 2021 485 * 486 ******************************************************************************/ 487 488 void 489 AcpiDmDumpApmt ( 490 ACPI_TABLE_HEADER *Table) 491 { 492 ACPI_STATUS Status; 493 ACPI_APMT_NODE *Subtable; 494 UINT32 Length = Table->Length; 495 UINT32 Offset = sizeof (ACPI_TABLE_APMT); 496 UINT32 NodeNum = 0; 497 498 /* There is no main table (other than the standard ACPI header) */ 499 500 /* Subtables */ 501 502 Subtable = ACPI_ADD_PTR (ACPI_APMT_NODE, Table, Offset); 503 while (Offset < Table->Length) 504 { 505 AcpiOsPrintf ("\n"); 506 507 if (Subtable->Type >= ACPI_APMT_NODE_TYPE_COUNT) 508 { 509 AcpiOsPrintf ("\n**** Unknown APMT subtable type 0x%X\n", 510 Subtable->Type); 511 return; 512 } 513 514 AcpiOsPrintf ("/* APMT Node-%u */\n", NodeNum++); 515 516 Status = AcpiDmDumpTable (Length, Offset, Subtable, 517 Subtable->Length, AcpiDmTableInfoApmtNode); 518 if (ACPI_FAILURE (Status)) 519 { 520 return; 521 } 522 523 /* Point to next subtable */ 524 525 Offset += Subtable->Length; 526 Subtable = ACPI_ADD_PTR (ACPI_APMT_NODE, Subtable, 527 Subtable->Length); 528 AcpiOsPrintf ("\n"); 529 } 530 } 531 532 533 /******************************************************************************* 534 * 535 * FUNCTION: AcpiDmDumpAsf 536 * 537 * PARAMETERS: Table - A ASF table 538 * 539 * RETURN: None 540 * 541 * DESCRIPTION: Format the contents of a ASF table 542 * 543 ******************************************************************************/ 544 545 void 546 AcpiDmDumpAsf ( 547 ACPI_TABLE_HEADER *Table) 548 { 549 ACPI_STATUS Status; 550 UINT32 Offset = sizeof (ACPI_TABLE_HEADER); 551 ACPI_ASF_INFO *Subtable; 552 ACPI_DMTABLE_INFO *InfoTable; 553 ACPI_DMTABLE_INFO *DataInfoTable = NULL; 554 UINT8 *DataTable = NULL; 555 UINT32 DataCount = 0; 556 UINT32 DataLength = 0; 557 UINT32 DataOffset = 0; 558 UINT32 i; 559 UINT8 Type; 560 561 562 /* No main table, only subtables */ 563 564 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); 565 while (Offset < Table->Length) 566 { 567 /* Common subtable header */ 568 569 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 570 Subtable->Header.Length, AcpiDmTableInfoAsfHdr); 571 if (ACPI_FAILURE (Status)) 572 { 573 return; 574 } 575 576 /* The actual type is the lower 7 bits of Type */ 577 578 Type = (UINT8) (Subtable->Header.Type & 0x7F); 579 580 switch (Type) 581 { 582 case ACPI_ASF_TYPE_INFO: 583 584 InfoTable = AcpiDmTableInfoAsf0; 585 break; 586 587 case ACPI_ASF_TYPE_ALERT: 588 589 InfoTable = AcpiDmTableInfoAsf1; 590 DataInfoTable = AcpiDmTableInfoAsf1a; 591 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ALERT)); 592 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->Alerts; 593 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->DataLength; 594 DataOffset = Offset + sizeof (ACPI_ASF_ALERT); 595 break; 596 597 case ACPI_ASF_TYPE_CONTROL: 598 599 InfoTable = AcpiDmTableInfoAsf2; 600 DataInfoTable = AcpiDmTableInfoAsf2a; 601 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_REMOTE)); 602 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->Controls; 603 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->DataLength; 604 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE); 605 break; 606 607 case ACPI_ASF_TYPE_BOOT: 608 609 InfoTable = AcpiDmTableInfoAsf3; 610 break; 611 612 case ACPI_ASF_TYPE_ADDRESS: 613 614 InfoTable = AcpiDmTableInfoAsf4; 615 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ADDRESS)); 616 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, Subtable)->Devices; 617 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS); 618 break; 619 620 default: 621 622 AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n", 623 Subtable->Header.Type); 624 return; 625 } 626 627 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 628 Subtable->Header.Length, InfoTable); 629 if (ACPI_FAILURE (Status)) 630 { 631 return; 632 } 633 634 /* Dump variable-length extra data */ 635 636 switch (Type) 637 { 638 case ACPI_ASF_TYPE_ALERT: 639 case ACPI_ASF_TYPE_CONTROL: 640 641 for (i = 0; i < DataCount; i++) 642 { 643 AcpiOsPrintf ("\n"); 644 Status = AcpiDmDumpTable (Table->Length, DataOffset, 645 DataTable, DataLength, DataInfoTable); 646 if (ACPI_FAILURE (Status)) 647 { 648 return; 649 } 650 651 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength); 652 DataOffset += DataLength; 653 } 654 break; 655 656 case ACPI_ASF_TYPE_ADDRESS: 657 658 for (i = 0; i < DataLength; i++) 659 { 660 if (!(i % 16)) 661 { 662 AcpiDmLineHeader (DataOffset, 1, "Addresses"); 663 } 664 665 AcpiOsPrintf ("%2.2X ", *DataTable); 666 DataTable++; 667 DataOffset++; 668 669 if (DataOffset > Table->Length) 670 { 671 AcpiOsPrintf ( 672 "**** ACPI table terminates in the middle of a " 673 "data structure! (ASF! table)\n"); 674 return; 675 } 676 } 677 678 AcpiOsPrintf ("\n"); 679 break; 680 681 default: 682 683 break; 684 } 685 686 AcpiOsPrintf ("\n"); 687 688 /* Point to next subtable */ 689 690 if (!Subtable->Header.Length) 691 { 692 AcpiOsPrintf ("Invalid zero subtable header length\n"); 693 return; 694 } 695 696 Offset += Subtable->Header.Length; 697 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Subtable, 698 Subtable->Header.Length); 699 } 700 } 701 702 /******************************************************************************* 703 * 704 * FUNCTION: AcpiDmDumpAspt 705 * 706 * PARAMETERS: Table - A ASPT table 707 * 708 * RETURN: None 709 * 710 * DESCRIPTION: Format the contents of a ASPT table 711 * 712 ******************************************************************************/ 713 714 void 715 AcpiDmDumpAspt ( 716 ACPI_TABLE_HEADER *Table) 717 { 718 ACPI_STATUS Status; 719 UINT32 Offset = sizeof (ACPI_TABLE_ASPT); 720 UINT32 Length = Table->Length; 721 ACPI_ASPT_HEADER *Subtable; 722 ACPI_DMTABLE_INFO *InfoTable; 723 UINT16 Type; 724 725 /* Main table */ 726 Status = AcpiDmDumpTable(Length, 0, Table, 0, AcpiDmTableInfoAspt); 727 728 /* Subtables */ 729 730 Subtable = ACPI_ADD_PTR (ACPI_ASPT_HEADER, Table, Offset); 731 while (Offset < Table->Length) 732 { 733 AcpiOsPrintf ("\n"); 734 735 /* Common subtable header */ 736 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 737 Subtable->Length, AcpiDmTableInfoAsptHdr); 738 if (ACPI_FAILURE (Status)) 739 { 740 return; 741 } 742 743 Type = Subtable->Type; 744 745 switch (Type) 746 { 747 case ACPI_ASPT_TYPE_GLOBAL_REGS: 748 749 InfoTable = AcpiDmTableInfoAspt0; 750 break; 751 752 case ACPI_ASPT_TYPE_SEV_MBOX_REGS: 753 754 InfoTable = AcpiDmTableInfoAspt1; 755 break; 756 757 case ACPI_ASPT_TYPE_ACPI_MBOX_REGS: 758 759 InfoTable = AcpiDmTableInfoAspt2; 760 break; 761 762 default: 763 764 AcpiOsPrintf ("\n**** Unknown ASPT subtable type 0x%X\n", 765 Subtable->Type); 766 return; 767 } 768 769 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 770 Subtable->Length, InfoTable); 771 if (ACPI_FAILURE (Status)) 772 { 773 return; 774 } 775 776 AcpiOsPrintf ("\n"); 777 778 /* Point to next subtable */ 779 if (!Subtable->Length) 780 { 781 AcpiOsPrintf ("Invalid zero subtable header length\n"); 782 return; 783 } 784 785 Offset += Subtable->Length; 786 Subtable = ACPI_ADD_PTR (ACPI_ASPT_HEADER, Subtable, 787 Subtable->Length); 788 } 789 } 790 791 792 /******************************************************************************* 793 * 794 * FUNCTION: AcpiDmDumpCdat 795 * 796 * PARAMETERS: InTable - A CDAT table 797 * 798 * RETURN: None 799 * 800 * DESCRIPTION: Format the contents of a CDAT. This table type consists 801 * of an open-ended number of subtables. 802 * 803 ******************************************************************************/ 804 805 void 806 AcpiDmDumpCdat ( 807 ACPI_TABLE_HEADER *InTable) 808 { 809 ACPI_TABLE_CDAT *Table = ACPI_CAST_PTR (ACPI_TABLE_CDAT, InTable); 810 ACPI_STATUS Status; 811 ACPI_CDAT_HEADER *Subtable; 812 ACPI_TABLE_CDAT *CdatTable = ACPI_CAST_PTR (ACPI_TABLE_CDAT, Table); 813 ACPI_DMTABLE_INFO *InfoTable; 814 UINT32 Length = CdatTable->Length; 815 UINT32 Offset = sizeof (ACPI_TABLE_CDAT); 816 UINT32 SubtableLength; 817 UINT32 SubtableType; 818 INT32 EntriesLength; 819 820 821 /* Main table */ 822 823 Status = AcpiDmDumpTable (Offset, 0, CdatTable, 0, 824 AcpiDmTableInfoCdatTableHdr); 825 if (ACPI_FAILURE (Status)) 826 { 827 return; 828 } 829 830 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, sizeof (ACPI_TABLE_CDAT)); 831 while (Offset < Table->Length) 832 { 833 /* Dump the common subtable header */ 834 835 DbgPrint (ASL_DEBUG_OUTPUT, "0) HeaderOffset: %X\n", Offset); 836 AcpiOsPrintf ("\n"); 837 Status = AcpiDmDumpTable (Length, Offset, Subtable, 838 sizeof (ACPI_CDAT_HEADER), AcpiDmTableInfoCdatHeader); 839 if (ACPI_FAILURE (Status)) 840 { 841 return; 842 } 843 844 /* Point past the common subtable header, decode the subtable type */ 845 846 Offset += sizeof (ACPI_CDAT_HEADER); 847 SubtableType = Subtable->Type; 848 849 switch (Subtable->Type) 850 { 851 case ACPI_CDAT_TYPE_DSMAS: 852 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 853 SubtableLength = sizeof (ACPI_CDAT_DSMAS); 854 855 InfoTable = AcpiDmTableInfoCdat0; 856 break; 857 858 case ACPI_CDAT_TYPE_DSLBIS: 859 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 860 SubtableLength = sizeof (ACPI_CDAT_DSLBIS); 861 DbgPrint (ASL_DEBUG_OUTPUT, "1) Offset: %X\n", Offset); 862 863 InfoTable = AcpiDmTableInfoCdat1; 864 break; 865 866 case ACPI_CDAT_TYPE_DSMSCIS: 867 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 868 SubtableLength = sizeof (ACPI_CDAT_DSMSCIS); 869 870 InfoTable = AcpiDmTableInfoCdat2; 871 break; 872 873 case ACPI_CDAT_TYPE_DSIS: 874 DbgPrint (ASL_DEBUG_OUTPUT, "2) Offset: %X ", Offset); 875 SubtableLength = sizeof (ACPI_CDAT_DSIS); 876 DbgPrint (ASL_DEBUG_OUTPUT, "1) input pointer: %p\n", Table); 877 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 878 DbgPrint (ASL_DEBUG_OUTPUT, "1) output pointers: %p, %p, Offset: %X\n", 879 Table, Subtable, Offset); 880 DbgPrint (ASL_DEBUG_OUTPUT, "3) Offset: %X\n", Offset); 881 882 InfoTable = AcpiDmTableInfoCdat3; 883 break; 884 885 case ACPI_CDAT_TYPE_DSEMTS: 886 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 887 SubtableLength = sizeof (ACPI_CDAT_DSEMTS); 888 889 InfoTable = AcpiDmTableInfoCdat4; 890 break; 891 892 case ACPI_CDAT_TYPE_SSLBIS: 893 SubtableLength = Subtable->Length; 894 895 InfoTable = AcpiDmTableInfoCdat5; 896 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 897 break; 898 899 default: 900 fprintf (stderr, "ERROR: Unknown SubtableType: %X\n", Subtable->Type); 901 return; 902 } 903 904 DbgPrint (ASL_DEBUG_OUTPUT, "SubtableType: %X, Length: %X Actual " 905 "Length: %X Offset: %X tableptr: %p\n", SubtableType, 906 Subtable->Length, SubtableLength, Offset, Table); 907 908 /* 909 * Do the subtable-specific fields 910 */ 911 Status = AcpiDmDumpTable (Length, Offset, Subtable, Offset, InfoTable); 912 if (ACPI_FAILURE (Status)) 913 { 914 return; 915 } 916 917 DbgPrint (ASL_DEBUG_OUTPUT, "Subtable Type: %X, Offset: %X, SubtableLength: %X\n", 918 SubtableType, Offset, SubtableLength); 919 920 /* Additional sub-subtables, dependent on the main subtable type */ 921 922 switch (SubtableType) 923 { 924 case ACPI_CDAT_TYPE_SSLBIS: 925 Offset += sizeof (ACPI_CDAT_SSLBIS); 926 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, 927 Offset); 928 929 DbgPrint (ASL_DEBUG_OUTPUT, "Case SSLBIS, Offset: %X, SubtableLength: %X " 930 "Subtable->Length %X\n", Offset, SubtableLength, Subtable->Length); 931 932 /* Generate the total length of all the SSLBE entries */ 933 934 EntriesLength = SubtableLength - sizeof (ACPI_CDAT_HEADER) - 935 sizeof (ACPI_CDAT_SSLBIS); 936 DbgPrint (ASL_DEBUG_OUTPUT, "EntriesLength: %X, Offset: %X, Table->Length: %X\n", 937 EntriesLength, Offset, Table->Length); 938 939 /* Do each of the SSLBE Entries */ 940 941 while ((EntriesLength > 0) && (Offset < Table->Length)) 942 { 943 AcpiOsPrintf ("\n"); 944 945 Status = AcpiDmDumpTable (Length, Offset, Subtable, Offset, 946 AcpiDmTableInfoCdatEntries); 947 if (ACPI_FAILURE (Status)) 948 { 949 return; 950 } 951 952 EntriesLength -= sizeof (ACPI_CDAT_SSLBE); 953 Offset += sizeof (ACPI_CDAT_SSLBE); 954 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 955 } 956 957 SubtableLength = 0; 958 break; 959 960 default: 961 break; 962 } 963 964 DbgPrint (ASL_DEBUG_OUTPUT, "Offset: %X, Subtable Length: %X\n", 965 Offset, SubtableLength); 966 967 /* Point to next subtable */ 968 969 Offset += SubtableLength; 970 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 971 } 972 973 return; 974 } 975 976 977 /******************************************************************************* 978 * 979 * FUNCTION: AcpiDmDumpCedt 980 * 981 * PARAMETERS: Table - A CEDT table 982 * 983 * RETURN: None 984 * 985 * DESCRIPTION: Format the contents of a CEDT. This table type consists 986 * of an open-ended number of subtables. 987 * 988 ******************************************************************************/ 989 990 void 991 AcpiDmDumpCedt ( 992 ACPI_TABLE_HEADER *Table) 993 { 994 ACPI_STATUS Status; 995 ACPI_CEDT_HEADER *Subtable; 996 UINT32 Length = Table->Length; 997 UINT32 Offset = sizeof (ACPI_TABLE_CEDT); 998 999 1000 /* There is no main table (other than the standard ACPI header) */ 1001 1002 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Table, Offset); 1003 while (Offset < Table->Length) 1004 { 1005 /* Common subtable header */ 1006 1007 AcpiOsPrintf ("\n"); 1008 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1009 Subtable->Length, AcpiDmTableInfoCedtHdr); 1010 if (ACPI_FAILURE (Status)) 1011 { 1012 return; 1013 } 1014 1015 switch (Subtable->Type) 1016 { 1017 case ACPI_CEDT_TYPE_CHBS: 1018 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1019 Subtable->Length, AcpiDmTableInfoCedt0); 1020 if (ACPI_FAILURE (Status)) 1021 { 1022 return; 1023 } 1024 break; 1025 1026 case ACPI_CEDT_TYPE_CFMWS: 1027 { 1028 ACPI_CEDT_CFMWS *ptr = (ACPI_CEDT_CFMWS *) Subtable; 1029 unsigned int i, max; 1030 1031 if (ptr->InterleaveWays < 8) 1032 max = 1 << (ptr->InterleaveWays); 1033 else 1034 max = 3 << (ptr->InterleaveWays - 8); 1035 1036 /* print out table with first "Interleave target" */ 1037 1038 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1039 Subtable->Length, AcpiDmTableInfoCedt1); 1040 if (ACPI_FAILURE (Status)) 1041 { 1042 return; 1043 } 1044 1045 /* Now, print out any interleave targets beyond the first. */ 1046 1047 for (i = 1; i < max; i++) 1048 { 1049 unsigned int loc_offset = Offset + (i * 4) + ACPI_OFFSET (ACPI_CEDT_CFMWS, InterleaveTargets); 1050 unsigned int *trg = &(ptr->InterleaveTargets[i]); 1051 1052 Status = AcpiDmDumpTable (Length, loc_offset, trg, 1053 Subtable->Length, AcpiDmTableInfoCedt1_te); 1054 if (ACPI_FAILURE (Status)) 1055 { 1056 return; 1057 } 1058 } 1059 break; 1060 } 1061 1062 case ACPI_CEDT_TYPE_CXIMS: 1063 { 1064 ACPI_CEDT_CXIMS *ptr = (ACPI_CEDT_CXIMS *) Subtable; 1065 unsigned int i, max = ptr->NrXormaps; 1066 1067 /* print out table with first "XOR Map" */ 1068 1069 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1070 Subtable->Length, AcpiDmTableInfoCedt2); 1071 if (ACPI_FAILURE (Status)) 1072 { 1073 return; 1074 } 1075 1076 /* Now, print out any XOR Map beyond the first. */ 1077 1078 for (i = 1; i < max; i++) 1079 { 1080 unsigned int loc_offset = Offset + (i * 1) + ACPI_OFFSET (ACPI_CEDT_CXIMS, XormapList); 1081 UINT64 *trg = &(ptr->XormapList[i]); 1082 1083 Status = AcpiDmDumpTable (Length, loc_offset, trg, 1084 Subtable->Length, AcpiDmTableInfoCedt2_te); 1085 if (ACPI_FAILURE (Status)) 1086 { 1087 return; 1088 } 1089 } 1090 break; 1091 } 1092 1093 default: 1094 AcpiOsPrintf ("\n**** Unknown CEDT subtable type 0x%X\n\n", 1095 Subtable->Type); 1096 1097 /* Attempt to continue */ 1098 if (!Subtable->Length) 1099 { 1100 AcpiOsPrintf ("Invalid zero length subtable\n"); 1101 return; 1102 } 1103 } 1104 1105 /* Point to next subtable */ 1106 Offset += Subtable->Length; 1107 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Subtable, 1108 Subtable->Length); 1109 } 1110 } 1111 1112 /******************************************************************************* 1113 * 1114 * FUNCTION: AcpiDmDumpCpep 1115 * 1116 * PARAMETERS: Table - A CPEP table 1117 * 1118 * RETURN: None 1119 * 1120 * DESCRIPTION: Format the contents of a CPEP. This table type consists 1121 * of an open-ended number of subtables. 1122 * 1123 ******************************************************************************/ 1124 1125 void 1126 AcpiDmDumpCpep ( 1127 ACPI_TABLE_HEADER *Table) 1128 { 1129 ACPI_STATUS Status; 1130 ACPI_CPEP_POLLING *Subtable; 1131 UINT32 Length = Table->Length; 1132 UINT32 Offset = sizeof (ACPI_TABLE_CPEP); 1133 1134 1135 /* Main table */ 1136 1137 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep); 1138 if (ACPI_FAILURE (Status)) 1139 { 1140 return; 1141 } 1142 1143 /* Subtables */ 1144 1145 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset); 1146 while (Offset < Table->Length) 1147 { 1148 AcpiOsPrintf ("\n"); 1149 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1150 Subtable->Header.Length, AcpiDmTableInfoCpep0); 1151 if (ACPI_FAILURE (Status)) 1152 { 1153 return; 1154 } 1155 1156 /* Point to next subtable */ 1157 1158 Offset += Subtable->Header.Length; 1159 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Subtable, 1160 Subtable->Header.Length); 1161 } 1162 } 1163 1164 1165 /******************************************************************************* 1166 * 1167 * FUNCTION: AcpiDmDumpCsrt 1168 * 1169 * PARAMETERS: Table - A CSRT table 1170 * 1171 * RETURN: None 1172 * 1173 * DESCRIPTION: Format the contents of a CSRT. This table type consists 1174 * of an open-ended number of subtables. 1175 * 1176 ******************************************************************************/ 1177 1178 void 1179 AcpiDmDumpCsrt ( 1180 ACPI_TABLE_HEADER *Table) 1181 { 1182 ACPI_STATUS Status; 1183 ACPI_CSRT_GROUP *Subtable; 1184 ACPI_CSRT_SHARED_INFO *SharedInfoTable; 1185 ACPI_CSRT_DESCRIPTOR *SubSubtable; 1186 UINT32 Length = Table->Length; 1187 UINT32 Offset = sizeof (ACPI_TABLE_CSRT); 1188 UINT32 SubOffset; 1189 UINT32 SubSubOffset; 1190 UINT32 InfoLength; 1191 1192 1193 /* The main table only contains the ACPI header, thus already handled */ 1194 1195 /* Subtables (Resource Groups) */ 1196 1197 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset); 1198 while (Offset < Table->Length) 1199 { 1200 /* Resource group subtable */ 1201 1202 AcpiOsPrintf ("\n"); 1203 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1204 Subtable->Length, AcpiDmTableInfoCsrt0); 1205 if (ACPI_FAILURE (Status)) 1206 { 1207 return; 1208 } 1209 1210 /* Shared info subtable (One per resource group) */ 1211 1212 SubOffset = sizeof (ACPI_CSRT_GROUP); 1213 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table, 1214 Offset + SubOffset); 1215 1216 AcpiOsPrintf ("\n"); 1217 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable, 1218 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1); 1219 if (ACPI_FAILURE (Status)) 1220 { 1221 return; 1222 } 1223 1224 SubOffset += Subtable->SharedInfoLength; 1225 1226 /* Sub-Subtables (Resource Descriptors) */ 1227 1228 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table, 1229 Offset + SubOffset); 1230 1231 while ((SubOffset < Subtable->Length) && 1232 ((Offset + SubOffset) < Table->Length)) 1233 { 1234 AcpiOsPrintf ("\n"); 1235 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubtable, 1236 SubSubtable->Length, AcpiDmTableInfoCsrt2); 1237 if (ACPI_FAILURE (Status)) 1238 { 1239 return; 1240 } 1241 1242 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR); 1243 1244 /* Resource-specific info buffer */ 1245 1246 InfoLength = SubSubtable->Length - SubSubOffset; 1247 if (InfoLength) 1248 { 1249 Status = AcpiDmDumpTable (Length, 1250 Offset + SubOffset + SubSubOffset, Table, 1251 InfoLength, AcpiDmTableInfoCsrt2a); 1252 if (ACPI_FAILURE (Status)) 1253 { 1254 return; 1255 } 1256 } 1257 1258 /* Point to next sub-subtable */ 1259 1260 SubOffset += SubSubtable->Length; 1261 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubtable, 1262 SubSubtable->Length); 1263 } 1264 1265 /* Point to next subtable */ 1266 1267 Offset += Subtable->Length; 1268 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Subtable, 1269 Subtable->Length); 1270 } 1271 } 1272 1273 1274 /******************************************************************************* 1275 * 1276 * FUNCTION: AcpiDmDumpDbg2 1277 * 1278 * PARAMETERS: Table - A DBG2 table 1279 * 1280 * RETURN: None 1281 * 1282 * DESCRIPTION: Format the contents of a DBG2. This table type consists 1283 * of an open-ended number of subtables. 1284 * 1285 ******************************************************************************/ 1286 1287 void 1288 AcpiDmDumpDbg2 ( 1289 ACPI_TABLE_HEADER *Table) 1290 { 1291 ACPI_STATUS Status; 1292 ACPI_DBG2_DEVICE *Subtable; 1293 UINT32 Length = Table->Length; 1294 UINT32 Offset = sizeof (ACPI_TABLE_DBG2); 1295 UINT32 i; 1296 UINT32 ArrayOffset; 1297 UINT32 AbsoluteOffset; 1298 UINT8 *Array; 1299 1300 1301 /* Main table */ 1302 1303 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2); 1304 if (ACPI_FAILURE (Status)) 1305 { 1306 return; 1307 } 1308 1309 /* Subtables */ 1310 1311 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset); 1312 while (Offset < Table->Length) 1313 { 1314 AcpiOsPrintf ("\n"); 1315 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1316 Subtable->Length, AcpiDmTableInfoDbg2Device); 1317 if (ACPI_FAILURE (Status)) 1318 { 1319 return; 1320 } 1321 1322 /* Dump the BaseAddress array */ 1323 1324 for (i = 0; i < Subtable->RegisterCount; i++) 1325 { 1326 ArrayOffset = Subtable->BaseAddressOffset + 1327 (sizeof (ACPI_GENERIC_ADDRESS) * i); 1328 AbsoluteOffset = Offset + ArrayOffset; 1329 Array = (UINT8 *) Subtable + ArrayOffset; 1330 1331 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 1332 Subtable->Length, AcpiDmTableInfoDbg2Addr); 1333 if (ACPI_FAILURE (Status)) 1334 { 1335 return; 1336 } 1337 } 1338 1339 /* Dump the AddressSize array */ 1340 1341 for (i = 0; i < Subtable->RegisterCount; i++) 1342 { 1343 ArrayOffset = Subtable->AddressSizeOffset + 1344 (sizeof (UINT32) * i); 1345 AbsoluteOffset = Offset + ArrayOffset; 1346 Array = (UINT8 *) Subtable + ArrayOffset; 1347 1348 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 1349 Subtable->Length, AcpiDmTableInfoDbg2Size); 1350 if (ACPI_FAILURE (Status)) 1351 { 1352 return; 1353 } 1354 } 1355 1356 /* Dump the Namestring (required) */ 1357 1358 AcpiOsPrintf ("\n"); 1359 ArrayOffset = Subtable->NamepathOffset; 1360 AbsoluteOffset = Offset + ArrayOffset; 1361 Array = (UINT8 *) Subtable + ArrayOffset; 1362 1363 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 1364 Subtable->Length, AcpiDmTableInfoDbg2Name); 1365 if (ACPI_FAILURE (Status)) 1366 { 1367 return; 1368 } 1369 1370 /* Dump the OemData (optional) */ 1371 1372 if (Subtable->OemDataOffset) 1373 { 1374 Status = AcpiDmDumpTable (Length, Subtable->OemDataOffset, 1375 Subtable, Subtable->OemDataLength, 1376 AcpiDmTableInfoDbg2OemData); 1377 if (ACPI_FAILURE (Status)) 1378 { 1379 return; 1380 } 1381 } 1382 1383 /* Point to next subtable */ 1384 1385 Offset += Subtable->Length; 1386 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Subtable, 1387 Subtable->Length); 1388 } 1389 } 1390 1391 1392 /******************************************************************************* 1393 * 1394 * FUNCTION: AcpiDmDumpDmar 1395 * 1396 * PARAMETERS: Table - A DMAR table 1397 * 1398 * RETURN: None 1399 * 1400 * DESCRIPTION: Format the contents of a DMAR. This table type consists 1401 * of an open-ended number of subtables. 1402 * 1403 ******************************************************************************/ 1404 1405 void 1406 AcpiDmDumpDmar ( 1407 ACPI_TABLE_HEADER *Table) 1408 { 1409 ACPI_STATUS Status; 1410 ACPI_DMAR_HEADER *Subtable; 1411 UINT32 Length = Table->Length; 1412 UINT32 Offset = sizeof (ACPI_TABLE_DMAR); 1413 ACPI_DMTABLE_INFO *InfoTable; 1414 ACPI_DMAR_DEVICE_SCOPE *ScopeTable; 1415 UINT32 ScopeOffset; 1416 UINT8 *PciPath; 1417 UINT32 PathOffset; 1418 1419 1420 /* Main table */ 1421 1422 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); 1423 if (ACPI_FAILURE (Status)) 1424 { 1425 return; 1426 } 1427 1428 /* Subtables */ 1429 1430 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); 1431 while (Offset < Table->Length) 1432 { 1433 /* Common subtable header */ 1434 1435 AcpiOsPrintf ("\n"); 1436 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1437 Subtable->Length, AcpiDmTableInfoDmarHdr); 1438 if (ACPI_FAILURE (Status)) 1439 { 1440 return; 1441 } 1442 1443 AcpiOsPrintf ("\n"); 1444 1445 switch (Subtable->Type) 1446 { 1447 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 1448 1449 InfoTable = AcpiDmTableInfoDmar0; 1450 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT); 1451 break; 1452 1453 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 1454 1455 InfoTable = AcpiDmTableInfoDmar1; 1456 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY); 1457 break; 1458 1459 case ACPI_DMAR_TYPE_ROOT_ATS: 1460 1461 InfoTable = AcpiDmTableInfoDmar2; 1462 ScopeOffset = sizeof (ACPI_DMAR_ATSR); 1463 break; 1464 1465 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY: 1466 1467 InfoTable = AcpiDmTableInfoDmar3; 1468 ScopeOffset = sizeof (ACPI_DMAR_RHSA); 1469 break; 1470 1471 case ACPI_DMAR_TYPE_NAMESPACE: 1472 1473 InfoTable = AcpiDmTableInfoDmar4; 1474 ScopeOffset = sizeof (ACPI_DMAR_ANDD); 1475 break; 1476 1477 case ACPI_DMAR_TYPE_SATC: 1478 1479 InfoTable = AcpiDmTableInfoDmar5; 1480 ScopeOffset = sizeof (ACPI_DMAR_SATC); 1481 break; 1482 1483 case ACPI_DMAR_TYPE_SIDP: 1484 1485 InfoTable = AcpiDmTableInfoDmar6; 1486 ScopeOffset = sizeof (ACPI_DMAR_SIDP); 1487 break; 1488 1489 default: 1490 1491 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n", 1492 Subtable->Type); 1493 return; 1494 } 1495 1496 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1497 Subtable->Length, InfoTable); 1498 if (ACPI_FAILURE (Status)) 1499 { 1500 return; 1501 } 1502 1503 /* 1504 * Dump the optional device scope entries 1505 */ 1506 if ((Subtable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || 1507 (Subtable->Type == ACPI_DMAR_TYPE_NAMESPACE)) 1508 { 1509 /* These types do not support device scopes */ 1510 1511 goto NextSubtable; 1512 } 1513 1514 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable, ScopeOffset); 1515 while (ScopeOffset < Subtable->Length) 1516 { 1517 AcpiOsPrintf ("\n"); 1518 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, 1519 ScopeTable->Length, AcpiDmTableInfoDmarScope); 1520 if (ACPI_FAILURE (Status)) 1521 { 1522 return; 1523 } 1524 AcpiOsPrintf ("\n"); 1525 1526 /* Dump the PCI Path entries for this device scope */ 1527 1528 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */ 1529 1530 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable, 1531 sizeof (ACPI_DMAR_DEVICE_SCOPE)); 1532 1533 while (PathOffset < ScopeTable->Length) 1534 { 1535 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, 1536 "PCI Path"); 1537 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]); 1538 1539 /* Point to next PCI Path entry */ 1540 1541 PathOffset += 2; 1542 PciPath += 2; 1543 AcpiOsPrintf ("\n"); 1544 } 1545 1546 /* Point to next device scope entry */ 1547 1548 ScopeOffset += ScopeTable->Length; 1549 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, 1550 ScopeTable, ScopeTable->Length); 1551 } 1552 1553 NextSubtable: 1554 /* Point to next subtable */ 1555 1556 Offset += Subtable->Length; 1557 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Subtable, 1558 Subtable->Length); 1559 } 1560 } 1561 1562 1563 /******************************************************************************* 1564 * 1565 * FUNCTION: AcpiDmDumpDrtm 1566 * 1567 * PARAMETERS: Table - A DRTM table 1568 * 1569 * RETURN: None 1570 * 1571 * DESCRIPTION: Format the contents of a DRTM. 1572 * 1573 ******************************************************************************/ 1574 1575 void 1576 AcpiDmDumpDrtm ( 1577 ACPI_TABLE_HEADER *Table) 1578 { 1579 ACPI_STATUS Status; 1580 UINT32 Offset; 1581 ACPI_DRTM_VTABLE_LIST *DrtmVtl; 1582 ACPI_DRTM_RESOURCE_LIST *DrtmRl; 1583 ACPI_DRTM_DPS_ID *DrtmDps; 1584 UINT32 Count; 1585 1586 1587 /* Main table */ 1588 1589 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 1590 AcpiDmTableInfoDrtm); 1591 if (ACPI_FAILURE (Status)) 1592 { 1593 return; 1594 } 1595 1596 Offset = sizeof (ACPI_TABLE_DRTM); 1597 1598 /* Sub-tables */ 1599 1600 /* Dump ValidatedTable length */ 1601 1602 DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset); 1603 AcpiOsPrintf ("\n"); 1604 Status = AcpiDmDumpTable (Table->Length, Offset, 1605 DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables), 1606 AcpiDmTableInfoDrtm0); 1607 if (ACPI_FAILURE (Status)) 1608 { 1609 return; 1610 } 1611 1612 Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables); 1613 1614 /* Dump Validated table addresses */ 1615 1616 Count = 0; 1617 while ((Offset < Table->Length) && 1618 (DrtmVtl->ValidatedTableCount > Count)) 1619 { 1620 Status = AcpiDmDumpTable (Table->Length, Offset, 1621 ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64), 1622 AcpiDmTableInfoDrtm0a); 1623 if (ACPI_FAILURE (Status)) 1624 { 1625 return; 1626 } 1627 1628 Offset += sizeof (UINT64); 1629 Count++; 1630 } 1631 1632 /* Dump ResourceList length */ 1633 1634 DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset); 1635 AcpiOsPrintf ("\n"); 1636 Status = AcpiDmDumpTable (Table->Length, Offset, 1637 DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources), 1638 AcpiDmTableInfoDrtm1); 1639 if (ACPI_FAILURE (Status)) 1640 { 1641 return; 1642 } 1643 1644 Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources); 1645 1646 /* Dump the Resource List */ 1647 1648 Count = 0; 1649 while ((Offset < Table->Length) && 1650 (DrtmRl->ResourceCount > Count)) 1651 { 1652 Status = AcpiDmDumpTable (Table->Length, Offset, 1653 ACPI_ADD_PTR (void, Table, Offset), 1654 sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a); 1655 if (ACPI_FAILURE (Status)) 1656 { 1657 return; 1658 } 1659 1660 Offset += sizeof (ACPI_DRTM_RESOURCE); 1661 Count++; 1662 } 1663 1664 /* Dump DPS */ 1665 1666 DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset); 1667 AcpiOsPrintf ("\n"); 1668 (void) AcpiDmDumpTable (Table->Length, Offset, 1669 DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2); 1670 } 1671 1672 1673 /******************************************************************************* 1674 * 1675 * FUNCTION: AcpiDmDumpEinj 1676 * 1677 * PARAMETERS: Table - A EINJ table 1678 * 1679 * RETURN: None 1680 * 1681 * DESCRIPTION: Format the contents of a EINJ. This table type consists 1682 * of an open-ended number of subtables. 1683 * 1684 ******************************************************************************/ 1685 1686 void 1687 AcpiDmDumpEinj ( 1688 ACPI_TABLE_HEADER *Table) 1689 { 1690 ACPI_STATUS Status; 1691 ACPI_WHEA_HEADER *Subtable; 1692 UINT32 Length = Table->Length; 1693 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 1694 1695 1696 /* Main table */ 1697 1698 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 1699 if (ACPI_FAILURE (Status)) 1700 { 1701 return; 1702 } 1703 1704 /* Subtables */ 1705 1706 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1707 while (Offset < Table->Length) 1708 { 1709 AcpiOsPrintf ("\n"); 1710 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1711 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 1712 if (ACPI_FAILURE (Status)) 1713 { 1714 return; 1715 } 1716 1717 /* Point to next subtable (each subtable is of fixed length) */ 1718 1719 Offset += sizeof (ACPI_WHEA_HEADER); 1720 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable, 1721 sizeof (ACPI_WHEA_HEADER)); 1722 } 1723 } 1724 1725 1726 /******************************************************************************* 1727 * 1728 * FUNCTION: AcpiDmDumpErdt 1729 * 1730 * PARAMETERS: Table - A ERDT table 1731 * 1732 * RETURN: None 1733 * 1734 * DESCRIPTION: Format the contents of a ERDT. This table type consists 1735 * of an open-ended number of subtables. 1736 * 1737 ******************************************************************************/ 1738 1739 void 1740 AcpiDmDumpErdt ( 1741 ACPI_TABLE_HEADER *Table) 1742 { 1743 ACPI_STATUS Status; 1744 ACPI_SUBTBL_HDR_16 *Subtable, *Subsubtable; 1745 ACPI_ERDT_DACD_PATHS *ScopeTable; 1746 UINT32 Offset = sizeof (ACPI_TABLE_ERDT); 1747 UINT32 Suboffset; 1748 UINT32 ScopeOffset; 1749 UINT32 SubsubtableLength = 0; 1750 ACPI_DMTABLE_INFO *InfoTable, *TrailEntries, *DacdEntries; 1751 UINT32 NumTrailers = 0; 1752 1753 /* Main table */ 1754 1755 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoErdt); 1756 if (ACPI_FAILURE (Status)) 1757 { 1758 return; 1759 } 1760 1761 /* Subtables */ 1762 Subtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Table, Offset); 1763 while (Offset < Table->Length) 1764 { 1765 1766 /* Dump common header */ 1767 1768 AcpiOsPrintf ("\n"); 1769 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1770 Subtable->Length, AcpiDmTableInfoErdtHdr); 1771 if (ACPI_FAILURE (Status)) 1772 { 1773 return; 1774 } 1775 1776 AcpiOsPrintf ("\n"); 1777 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1778 Subtable->Length, AcpiDmTableInfoErdtRmdd); 1779 if (ACPI_FAILURE (Status)) 1780 { 1781 return; 1782 } 1783 1784 /* Subtables of this RMDD table */ 1785 1786 Suboffset = Offset + sizeof(ACPI_ERDT_RMDD); 1787 Subsubtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Table, Suboffset); 1788 while (Suboffset < Offset + Subtable->Length) 1789 { 1790 AcpiOsPrintf ("\n"); 1791 1792 TrailEntries = NULL; 1793 DacdEntries = NULL; 1794 switch (Subsubtable->Type) 1795 { 1796 case ACPI_ERDT_TYPE_CACD: 1797 InfoTable = AcpiDmTableInfoErdtCacd; 1798 TrailEntries = AcpiDmTableInfoErdtCacdX2apic; 1799 SubsubtableLength = sizeof(ACPI_ERDT_CACD); 1800 break; 1801 1802 case ACPI_ERDT_TYPE_DACD: 1803 InfoTable = AcpiDmTableInfoErdtDacd; 1804 DacdEntries = AcpiDmTableInfoErdtDacdScope; 1805 SubsubtableLength = sizeof(ACPI_ERDT_DACD); 1806 break; 1807 1808 case ACPI_ERDT_TYPE_CMRC: 1809 InfoTable = AcpiDmTableInfoErdtCmrc; 1810 break; 1811 1812 case ACPI_ERDT_TYPE_MMRC: 1813 InfoTable = AcpiDmTableInfoErdtMmrc; 1814 TrailEntries = AcpiDmTableInfoErdtMmrcCorrFactor; 1815 SubsubtableLength = sizeof(ACPI_ERDT_MMRC); 1816 break; 1817 1818 case ACPI_ERDT_TYPE_MARC: 1819 InfoTable = AcpiDmTableInfoErdtMarc; 1820 break; 1821 1822 case ACPI_ERDT_TYPE_CARC: 1823 InfoTable = AcpiDmTableInfoErdtCarc; 1824 break; 1825 1826 case ACPI_ERDT_TYPE_CMRD: 1827 InfoTable = AcpiDmTableInfoErdtCmrd; 1828 break; 1829 1830 case ACPI_ERDT_TYPE_IBRD: 1831 InfoTable = AcpiDmTableInfoErdtIbrd; 1832 TrailEntries = AcpiDmTableInfoErdtIbrdCorrFactor; 1833 SubsubtableLength = sizeof(ACPI_ERDT_IBRD); 1834 break; 1835 1836 case ACPI_ERDT_TYPE_IBAD: 1837 InfoTable = AcpiDmTableInfoErdtIbad; 1838 break; 1839 1840 case ACPI_ERDT_TYPE_CARD: 1841 InfoTable = AcpiDmTableInfoErdtCard; 1842 break; 1843 1844 default: 1845 AcpiOsPrintf ("\n**** Unknown RMDD subtable type 0x%X\n", 1846 Subsubtable->Type); 1847 1848 /* Attempt to continue */ 1849 1850 if (!Subsubtable->Length) 1851 { 1852 AcpiOsPrintf ("Invalid zero length subtable\n"); 1853 return; 1854 } 1855 goto NextSubsubtable; 1856 } 1857 1858 /* Dump subtable header */ 1859 1860 Status = AcpiDmDumpTable (Table->Length, Suboffset, Subsubtable, 1861 Subsubtable->Length, AcpiDmTableInfoErdtHdr); 1862 if (ACPI_FAILURE (Status)) 1863 { 1864 return; 1865 } 1866 1867 /* Dump subtable body */ 1868 1869 Status = AcpiDmDumpTable (Table->Length, Suboffset, Subsubtable, 1870 Subsubtable->Length, InfoTable); 1871 if (ACPI_FAILURE (Status)) 1872 { 1873 return; 1874 } 1875 1876 /* CACD, MMRC, and IBRD subtables have simple flex array at end */ 1877 1878 if (TrailEntries) 1879 { 1880 NumTrailers = 0; 1881 while (NumTrailers < Subsubtable->Length - SubsubtableLength) 1882 { 1883 1884 /* Dump one flex array element */ 1885 1886 Status = AcpiDmDumpTable (Table->Length, Suboffset + 1887 SubsubtableLength + NumTrailers, 1888 ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Subsubtable, 1889 SubsubtableLength + NumTrailers), 1890 sizeof(UINT32), TrailEntries); 1891 if (ACPI_FAILURE (Status)) 1892 { 1893 return; 1894 } 1895 NumTrailers += sizeof(UINT32); 1896 } 1897 } 1898 1899 /* DACD subtable has flex array of device agent structures */ 1900 1901 if (DacdEntries) { 1902 ScopeOffset = Suboffset + SubsubtableLength; 1903 ScopeTable = ACPI_ADD_PTR (ACPI_ERDT_DACD_PATHS, 1904 Subsubtable, SubsubtableLength); 1905 while (ScopeOffset < Suboffset + Subsubtable->Length) 1906 { 1907 /* Dump one device agent structure */ 1908 1909 AcpiOsPrintf ("\n"); 1910 Status = AcpiDmDumpTable (Table->Length, ScopeOffset, 1911 ScopeTable, ScopeTable->Header.Length, DacdEntries); 1912 if (ACPI_FAILURE (Status)) 1913 { 1914 return; 1915 } 1916 1917 /* Flex array of UINT8 for device path */ 1918 1919 NumTrailers = 0; 1920 while (NumTrailers < ScopeTable->Header.Length - sizeof(ACPI_ERDT_DACD_PATHS)) 1921 { 1922 /* Dump one UINT8 of the device path */ 1923 1924 Status = AcpiDmDumpTable (Table->Length, ScopeOffset + 1925 sizeof(ACPI_ERDT_DACD_PATHS) + NumTrailers, 1926 ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, ScopeTable, 1927 sizeof(*ScopeTable) + NumTrailers), 1928 sizeof(UINT32), AcpiDmTableInfoErdtDacdPath); 1929 if (ACPI_FAILURE (Status)) 1930 { 1931 return; 1932 } 1933 NumTrailers++; 1934 } 1935 1936 ScopeOffset += ScopeTable->Header.Length; 1937 ScopeTable = ACPI_ADD_PTR (ACPI_ERDT_DACD_PATHS, 1938 ScopeTable, ScopeTable->Header.Length); 1939 } 1940 } 1941 NextSubsubtable: 1942 Suboffset += Subsubtable->Length; 1943 Subsubtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Table, Suboffset); 1944 } 1945 1946 Offset += Subtable->Length; 1947 Subtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Subtable, 1948 Subtable->Length); 1949 } 1950 } 1951 1952 1953 /******************************************************************************* 1954 * 1955 * FUNCTION: AcpiDmDumpErst 1956 * 1957 * PARAMETERS: Table - A ERST table 1958 * 1959 * RETURN: None 1960 * 1961 * DESCRIPTION: Format the contents of a ERST. This table type consists 1962 * of an open-ended number of subtables. 1963 * 1964 ******************************************************************************/ 1965 1966 void 1967 AcpiDmDumpErst ( 1968 ACPI_TABLE_HEADER *Table) 1969 { 1970 ACPI_STATUS Status; 1971 ACPI_WHEA_HEADER *Subtable; 1972 UINT32 Length = Table->Length; 1973 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 1974 1975 1976 /* Main table */ 1977 1978 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 1979 if (ACPI_FAILURE (Status)) 1980 { 1981 return; 1982 } 1983 1984 /* Subtables */ 1985 1986 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1987 while (Offset < Table->Length) 1988 { 1989 AcpiOsPrintf ("\n"); 1990 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1991 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0); 1992 if (ACPI_FAILURE (Status)) 1993 { 1994 return; 1995 } 1996 1997 /* Point to next subtable (each subtable is of fixed length) */ 1998 1999 Offset += sizeof (ACPI_WHEA_HEADER); 2000 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable, 2001 sizeof (ACPI_WHEA_HEADER)); 2002 } 2003 } 2004 2005 2006 /******************************************************************************* 2007 * 2008 * FUNCTION: AcpiDmDumpFpdt 2009 * 2010 * PARAMETERS: Table - A FPDT table 2011 * 2012 * RETURN: None 2013 * 2014 * DESCRIPTION: Format the contents of a FPDT. This table type consists 2015 * of an open-ended number of subtables. 2016 * 2017 ******************************************************************************/ 2018 2019 void 2020 AcpiDmDumpFpdt ( 2021 ACPI_TABLE_HEADER *Table) 2022 { 2023 ACPI_STATUS Status; 2024 ACPI_FPDT_HEADER *Subtable; 2025 UINT32 Length = Table->Length; 2026 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 2027 ACPI_DMTABLE_INFO *InfoTable; 2028 2029 2030 /* There is no main table (other than the standard ACPI header) */ 2031 2032 /* Subtables */ 2033 2034 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); 2035 while (Offset < Table->Length) 2036 { 2037 /* Common subtable header */ 2038 2039 AcpiOsPrintf ("\n"); 2040 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2041 Subtable->Length, AcpiDmTableInfoFpdtHdr); 2042 if (ACPI_FAILURE (Status)) 2043 { 2044 return; 2045 } 2046 2047 switch (Subtable->Type) 2048 { 2049 case ACPI_FPDT_TYPE_BOOT: 2050 2051 InfoTable = AcpiDmTableInfoFpdt0; 2052 break; 2053 2054 case ACPI_FPDT_TYPE_S3PERF: 2055 2056 InfoTable = AcpiDmTableInfoFpdt1; 2057 break; 2058 2059 default: 2060 2061 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", 2062 Subtable->Type); 2063 2064 /* Attempt to continue */ 2065 2066 if (!Subtable->Length) 2067 { 2068 AcpiOsPrintf ("Invalid zero length subtable\n"); 2069 return; 2070 } 2071 goto NextSubtable; 2072 } 2073 2074 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2075 Subtable->Length, InfoTable); 2076 if (ACPI_FAILURE (Status)) 2077 { 2078 return; 2079 } 2080 2081 NextSubtable: 2082 /* Point to next subtable */ 2083 2084 Offset += Subtable->Length; 2085 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, 2086 Subtable->Length); 2087 } 2088 } 2089 2090 2091 /******************************************************************************* 2092 * 2093 * FUNCTION: AcpiDmDumpGtdt 2094 * 2095 * PARAMETERS: Table - A GTDT table 2096 * 2097 * RETURN: None 2098 * 2099 * DESCRIPTION: Format the contents of a GTDT. This table type consists 2100 * of an open-ended number of subtables. 2101 * 2102 ******************************************************************************/ 2103 2104 void 2105 AcpiDmDumpGtdt ( 2106 ACPI_TABLE_HEADER *Table) 2107 { 2108 ACPI_STATUS Status; 2109 ACPI_GTDT_HEADER *Subtable; 2110 UINT32 Length = Table->Length; 2111 UINT32 Offset = sizeof (ACPI_TABLE_GTDT); 2112 ACPI_DMTABLE_INFO *InfoTable; 2113 UINT32 SubtableLength; 2114 UINT32 GtCount; 2115 ACPI_GTDT_TIMER_ENTRY *GtxTable; 2116 2117 2118 /* Main table */ 2119 2120 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt); 2121 if (ACPI_FAILURE (Status)) 2122 { 2123 return; 2124 } 2125 2126 /* Rev 3 fields */ 2127 2128 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 2129 2130 if (Table->Revision > 2) 2131 { 2132 SubtableLength = sizeof (ACPI_GTDT_EL2); 2133 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2134 SubtableLength, AcpiDmTableInfoGtdtEl2); 2135 if (ACPI_FAILURE (Status)) 2136 { 2137 return; 2138 } 2139 Offset += SubtableLength; 2140 } 2141 2142 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 2143 2144 /* Subtables */ 2145 2146 while (Offset < Table->Length) 2147 { 2148 /* Common subtable header */ 2149 2150 AcpiOsPrintf ("\n"); 2151 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2152 Subtable->Length, AcpiDmTableInfoGtdtHdr); 2153 if (ACPI_FAILURE (Status)) 2154 { 2155 return; 2156 } 2157 2158 GtCount = 0; 2159 switch (Subtable->Type) 2160 { 2161 case ACPI_GTDT_TYPE_TIMER_BLOCK: 2162 2163 SubtableLength = sizeof (ACPI_GTDT_TIMER_BLOCK); 2164 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, 2165 Subtable))->TimerCount; 2166 2167 InfoTable = AcpiDmTableInfoGtdt0; 2168 break; 2169 2170 case ACPI_GTDT_TYPE_WATCHDOG: 2171 2172 SubtableLength = sizeof (ACPI_GTDT_WATCHDOG); 2173 2174 InfoTable = AcpiDmTableInfoGtdt1; 2175 break; 2176 2177 default: 2178 2179 /* Cannot continue on unknown type - no length */ 2180 2181 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n", 2182 Subtable->Type); 2183 return; 2184 } 2185 2186 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2187 Subtable->Length, InfoTable); 2188 if (ACPI_FAILURE (Status)) 2189 { 2190 return; 2191 } 2192 2193 /* Point to end of current subtable (each subtable above is of fixed length) */ 2194 2195 Offset += SubtableLength; 2196 2197 /* If there are any Gt Timer Blocks from above, dump them now */ 2198 2199 if (GtCount) 2200 { 2201 GtxTable = ACPI_ADD_PTR ( 2202 ACPI_GTDT_TIMER_ENTRY, Subtable, SubtableLength); 2203 SubtableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY); 2204 2205 while (GtCount) 2206 { 2207 AcpiOsPrintf ("\n"); 2208 Status = AcpiDmDumpTable (Length, Offset, GtxTable, 2209 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a); 2210 if (ACPI_FAILURE (Status)) 2211 { 2212 return; 2213 } 2214 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY); 2215 GtxTable++; 2216 GtCount--; 2217 } 2218 } 2219 2220 /* Point to next subtable */ 2221 2222 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Subtable, SubtableLength); 2223 } 2224 } 2225 2226 2227 /******************************************************************************* 2228 * 2229 * FUNCTION: AcpiDmDumpHest 2230 * 2231 * PARAMETERS: Table - A HEST table 2232 * 2233 * RETURN: None 2234 * 2235 * DESCRIPTION: Format the contents of a HEST. This table type consists 2236 * of an open-ended number of subtables. 2237 * 2238 ******************************************************************************/ 2239 2240 void 2241 AcpiDmDumpHest ( 2242 ACPI_TABLE_HEADER *Table) 2243 { 2244 ACPI_STATUS Status; 2245 ACPI_HEST_HEADER *Subtable; 2246 UINT32 Length = Table->Length; 2247 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 2248 ACPI_DMTABLE_INFO *InfoTable; 2249 UINT32 SubtableLength; 2250 UINT32 BankCount; 2251 ACPI_HEST_IA_ERROR_BANK *BankTable; 2252 2253 2254 /* Main table */ 2255 2256 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 2257 if (ACPI_FAILURE (Status)) 2258 { 2259 return; 2260 } 2261 2262 /* Subtables */ 2263 2264 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 2265 while (Offset < Table->Length) 2266 { 2267 BankCount = 0; 2268 switch (Subtable->Type) 2269 { 2270 case ACPI_HEST_TYPE_IA32_CHECK: 2271 2272 InfoTable = AcpiDmTableInfoHest0; 2273 SubtableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK); 2274 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 2275 Subtable))->NumHardwareBanks; 2276 break; 2277 2278 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 2279 2280 InfoTable = AcpiDmTableInfoHest1; 2281 SubtableLength = sizeof (ACPI_HEST_IA_CORRECTED); 2282 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 2283 Subtable))->NumHardwareBanks; 2284 break; 2285 2286 case ACPI_HEST_TYPE_IA32_NMI: 2287 2288 InfoTable = AcpiDmTableInfoHest2; 2289 SubtableLength = sizeof (ACPI_HEST_IA_NMI); 2290 break; 2291 2292 case ACPI_HEST_TYPE_AER_ROOT_PORT: 2293 2294 InfoTable = AcpiDmTableInfoHest6; 2295 SubtableLength = sizeof (ACPI_HEST_AER_ROOT); 2296 break; 2297 2298 case ACPI_HEST_TYPE_AER_ENDPOINT: 2299 2300 InfoTable = AcpiDmTableInfoHest7; 2301 SubtableLength = sizeof (ACPI_HEST_AER); 2302 break; 2303 2304 case ACPI_HEST_TYPE_AER_BRIDGE: 2305 2306 InfoTable = AcpiDmTableInfoHest8; 2307 SubtableLength = sizeof (ACPI_HEST_AER_BRIDGE); 2308 break; 2309 2310 case ACPI_HEST_TYPE_GENERIC_ERROR: 2311 2312 InfoTable = AcpiDmTableInfoHest9; 2313 SubtableLength = sizeof (ACPI_HEST_GENERIC); 2314 break; 2315 2316 case ACPI_HEST_TYPE_GENERIC_ERROR_V2: 2317 2318 InfoTable = AcpiDmTableInfoHest10; 2319 SubtableLength = sizeof (ACPI_HEST_GENERIC_V2); 2320 break; 2321 2322 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK: 2323 2324 InfoTable = AcpiDmTableInfoHest11; 2325 SubtableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK); 2326 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK, 2327 Subtable))->NumHardwareBanks; 2328 break; 2329 2330 default: 2331 2332 /* Cannot continue on unknown type - no length */ 2333 2334 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n", 2335 Subtable->Type); 2336 return; 2337 } 2338 2339 AcpiOsPrintf ("\n"); 2340 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2341 SubtableLength, InfoTable); 2342 if (ACPI_FAILURE (Status)) 2343 { 2344 return; 2345 } 2346 2347 /* Point to end of current subtable (each subtable above is of fixed length) */ 2348 2349 Offset += SubtableLength; 2350 2351 /* If there are any (fixed-length) Error Banks from above, dump them now */ 2352 2353 if (BankCount) 2354 { 2355 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, Subtable, 2356 SubtableLength); 2357 SubtableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 2358 2359 while (BankCount) 2360 { 2361 AcpiOsPrintf ("\n"); 2362 Status = AcpiDmDumpTable (Length, Offset, BankTable, 2363 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 2364 if (ACPI_FAILURE (Status)) 2365 { 2366 return; 2367 } 2368 2369 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 2370 BankTable++; 2371 BankCount--; 2372 } 2373 } 2374 2375 /* Point to next subtable */ 2376 2377 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Subtable, SubtableLength); 2378 } 2379 } 2380 2381 2382 /******************************************************************************* 2383 * 2384 * FUNCTION: AcpiDmDumpHmat 2385 * 2386 * PARAMETERS: Table - A HMAT table 2387 * 2388 * RETURN: None 2389 * 2390 * DESCRIPTION: Format the contents of a HMAT. 2391 * 2392 ******************************************************************************/ 2393 2394 void 2395 AcpiDmDumpHmat ( 2396 ACPI_TABLE_HEADER *Table) 2397 { 2398 ACPI_STATUS Status; 2399 ACPI_HMAT_STRUCTURE *HmatStruct; 2400 ACPI_HMAT_LOCALITY *HmatLocality; 2401 ACPI_HMAT_CACHE *HmatCache; 2402 UINT32 Offset; 2403 UINT32 SubtableOffset; 2404 UINT32 Length; 2405 ACPI_DMTABLE_INFO *InfoTable; 2406 UINT32 i, j; 2407 2408 2409 /* Main table */ 2410 2411 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat); 2412 if (ACPI_FAILURE (Status)) 2413 { 2414 return; 2415 } 2416 Offset = sizeof (ACPI_TABLE_HMAT); 2417 2418 while (Offset < Table->Length) 2419 { 2420 AcpiOsPrintf ("\n"); 2421 2422 /* Dump HMAT structure header */ 2423 2424 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset); 2425 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE)) 2426 { 2427 AcpiOsPrintf ("Invalid HMAT structure length\n"); 2428 return; 2429 } 2430 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 2431 HmatStruct->Length, AcpiDmTableInfoHmatHdr); 2432 if (ACPI_FAILURE (Status)) 2433 { 2434 return; 2435 } 2436 2437 switch (HmatStruct->Type) 2438 { 2439 case ACPI_HMAT_TYPE_ADDRESS_RANGE: 2440 2441 InfoTable = AcpiDmTableInfoHmat0; 2442 Length = sizeof (ACPI_HMAT_PROXIMITY_DOMAIN); 2443 break; 2444 2445 case ACPI_HMAT_TYPE_LOCALITY: 2446 2447 InfoTable = AcpiDmTableInfoHmat1; 2448 Length = sizeof (ACPI_HMAT_LOCALITY); 2449 break; 2450 2451 case ACPI_HMAT_TYPE_CACHE: 2452 2453 InfoTable = AcpiDmTableInfoHmat2; 2454 Length = sizeof (ACPI_HMAT_CACHE); 2455 break; 2456 2457 default: 2458 2459 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n", 2460 HmatStruct->Type); 2461 2462 /* Attempt to continue */ 2463 2464 goto NextSubtable; 2465 } 2466 2467 /* Dump HMAT structure body */ 2468 2469 if (HmatStruct->Length < Length) 2470 { 2471 AcpiOsPrintf ("Invalid HMAT structure length\n"); 2472 return; 2473 } 2474 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 2475 HmatStruct->Length, InfoTable); 2476 if (ACPI_FAILURE (Status)) 2477 { 2478 return; 2479 } 2480 2481 /* Dump HMAT structure additional */ 2482 2483 switch (HmatStruct->Type) 2484 { 2485 case ACPI_HMAT_TYPE_LOCALITY: 2486 2487 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct); 2488 SubtableOffset = sizeof (ACPI_HMAT_LOCALITY); 2489 2490 /* Dump initiator proximity domains */ 2491 2492 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2493 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4)) 2494 { 2495 AcpiOsPrintf ("Invalid initiator proximity domain number\n"); 2496 return; 2497 } 2498 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 2499 { 2500 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2501 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2502 4, AcpiDmTableInfoHmat1a); 2503 if (ACPI_FAILURE (Status)) 2504 { 2505 return; 2506 } 2507 2508 SubtableOffset += 4; 2509 } 2510 2511 /* Dump target proximity domains */ 2512 2513 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2514 (UINT32)(HmatLocality->NumberOfTargetPDs * 4)) 2515 { 2516 AcpiOsPrintf ("Invalid target proximity domain number\n"); 2517 return; 2518 } 2519 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++) 2520 { 2521 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2522 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2523 4, AcpiDmTableInfoHmat1b); 2524 if (ACPI_FAILURE (Status)) 2525 { 2526 return; 2527 } 2528 2529 SubtableOffset += 4; 2530 } 2531 2532 /* Dump latency/bandwidth entris */ 2533 2534 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2535 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 2536 HmatLocality->NumberOfTargetPDs * 2)) 2537 { 2538 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n"); 2539 return; 2540 } 2541 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 2542 { 2543 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++) 2544 { 2545 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2546 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2547 2, AcpiDmTableInfoHmat1c); 2548 if (ACPI_FAILURE(Status)) 2549 { 2550 return; 2551 } 2552 2553 SubtableOffset += 2; 2554 } 2555 } 2556 break; 2557 2558 case ACPI_HMAT_TYPE_CACHE: 2559 2560 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct); 2561 SubtableOffset = sizeof (ACPI_HMAT_CACHE); 2562 2563 /* Dump SMBIOS handles */ 2564 2565 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2566 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2)) 2567 { 2568 AcpiOsPrintf ("Invalid SMBIOS handle number\n"); 2569 return; 2570 } 2571 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++) 2572 { 2573 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2574 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2575 2, AcpiDmTableInfoHmat2a); 2576 if (ACPI_FAILURE (Status)) 2577 { 2578 return; 2579 } 2580 2581 SubtableOffset += 2; 2582 } 2583 break; 2584 2585 default: 2586 2587 break; 2588 } 2589 2590 NextSubtable: 2591 /* Point to next HMAT structure subtable */ 2592 2593 Offset += (HmatStruct->Length); 2594 } 2595 } 2596
Indexes created Sat Sep 20 22:09:52 GMT 2025