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 - 2021, 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 157 /* This module used for application-level code only */ 158 159 #define _COMPONENT ACPI_CA_DISASSEMBLER 160 ACPI_MODULE_NAME ("dmtbdump1") 161 162 163 /******************************************************************************* 164 * 165 * FUNCTION: AcpiDmDumpAest 166 * 167 * PARAMETERS: Table - A AEST table 168 * 169 * RETURN: None 170 * 171 * DESCRIPTION: Format the contents of a AEST table 172 * 173 * NOTE: Assumes the following table structure: 174 * For all AEST Error Nodes: 175 * 1) An AEST Error Node, followed immediately by: 176 * 2) Any node-specific data 177 * 3) An Interface Structure (one) 178 * 4) A list (array) of Interrupt Structures 179 * 180 * AEST - ARM Error Source table. Conforms to: 181 * ACPI for the Armv8 RAS Extensions 1.1 Platform Design Document Sep 2020 182 * 183 ******************************************************************************/ 184 185 void 186 AcpiDmDumpAest ( 187 ACPI_TABLE_HEADER *Table) 188 { 189 ACPI_STATUS Status; 190 UINT32 Offset = sizeof (ACPI_TABLE_HEADER); 191 ACPI_AEST_HEADER *Subtable; 192 ACPI_AEST_HEADER *NodeHeader; 193 ACPI_AEST_PROCESSOR *ProcessorSubtable; 194 ACPI_DMTABLE_INFO *InfoTable; 195 ACPI_SIZE Length; 196 UINT8 Type; 197 198 199 /* Very small, generic main table. AEST consists of mostly subtables */ 200 201 while (Offset < Table->Length) 202 { 203 NodeHeader = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 204 205 /* Dump the common error node (subtable) header */ 206 207 Status = AcpiDmDumpTable (Table->Length, Offset, NodeHeader, 208 NodeHeader->Length, AcpiDmTableInfoAestHdr); 209 if (ACPI_FAILURE (Status)) 210 { 211 return; 212 } 213 214 Type = NodeHeader->Type; 215 216 /* Setup the node-specific subtable based on the header Type field */ 217 218 switch (Type) 219 { 220 case ACPI_AEST_PROCESSOR_ERROR_NODE: 221 InfoTable = AcpiDmTableInfoAestProcError; 222 Length = sizeof (ACPI_AEST_PROCESSOR); 223 break; 224 225 case ACPI_AEST_MEMORY_ERROR_NODE: 226 InfoTable = AcpiDmTableInfoAestMemError; 227 Length = sizeof (ACPI_AEST_MEMORY); 228 break; 229 230 case ACPI_AEST_SMMU_ERROR_NODE: 231 InfoTable = AcpiDmTableInfoAestSmmuError; 232 Length = sizeof (ACPI_AEST_SMMU); 233 break; 234 235 case ACPI_AEST_VENDOR_ERROR_NODE: 236 InfoTable = AcpiDmTableInfoAestVendorError; 237 Length = sizeof (ACPI_AEST_VENDOR); 238 break; 239 240 case ACPI_AEST_GIC_ERROR_NODE: 241 InfoTable = AcpiDmTableInfoAestGicError; 242 Length = sizeof (ACPI_AEST_GIC); 243 break; 244 245 /* Error case below */ 246 default: 247 248 AcpiOsPrintf ("\n**** Unknown AEST Error Subtable type 0x%X\n", 249 Type); 250 return; 251 } 252 253 /* Point past the common header (to the node-specific data) */ 254 255 Offset += sizeof (ACPI_AEST_HEADER); 256 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 257 AcpiOsPrintf ("\n"); 258 259 /* Dump the node-specific subtable */ 260 261 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, Length, 262 InfoTable); 263 if (ACPI_FAILURE (Status)) 264 { 265 return; 266 } 267 AcpiOsPrintf ("\n"); 268 269 if (Type == ACPI_AEST_PROCESSOR_ERROR_NODE) 270 { 271 /* 272 * Special handling for PROCESSOR_ERROR_NODE subtables 273 * (to handle the Resource Substructure via the ResourceType 274 * field). 275 */ 276 277 /* Point past the node-specific data */ 278 279 Offset += Length; 280 ProcessorSubtable = ACPI_CAST_PTR (ACPI_AEST_PROCESSOR, Subtable); 281 282 switch (ProcessorSubtable->ResourceType) 283 { 284 /* Setup the Resource Substructure subtable */ 285 286 case ACPI_AEST_CACHE_RESOURCE: 287 InfoTable = AcpiDmTableInfoAestCacheRsrc; 288 Length = sizeof (ACPI_AEST_PROCESSOR_CACHE); 289 break; 290 291 case ACPI_AEST_TLB_RESOURCE: 292 InfoTable = AcpiDmTableInfoAestTlbRsrc; 293 Length = sizeof (ACPI_AEST_PROCESSOR_TLB); 294 break; 295 296 case ACPI_AEST_GENERIC_RESOURCE: 297 InfoTable = AcpiDmTableInfoAestGenRsrc; 298 Length = sizeof (ACPI_AEST_PROCESSOR_GENERIC); 299 break; 300 301 /* Error case below */ 302 default: 303 AcpiOsPrintf ("\n**** Unknown AEST Processor Resource type 0x%X\n", 304 ProcessorSubtable->ResourceType); 305 return; 306 } 307 308 ProcessorSubtable = ACPI_ADD_PTR (ACPI_AEST_PROCESSOR, Table, 309 Offset); 310 311 /* Dump the resource substructure subtable */ 312 313 Status = AcpiDmDumpTable (Table->Length, Offset, ProcessorSubtable, 314 Length, InfoTable); 315 if (ACPI_FAILURE (Status)) 316 { 317 return; 318 } 319 320 AcpiOsPrintf ("\n"); 321 } 322 323 /* Point past the resource substructure or the node-specific data */ 324 325 Offset += Length; 326 327 /* Dump the interface structure, required to be present */ 328 329 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 330 if (Subtable->Type >= ACPI_AEST_XFACE_RESERVED) 331 { 332 AcpiOsPrintf ("\n**** Unknown AEST Node Interface type 0x%X\n", 333 Subtable->Type); 334 return; 335 } 336 337 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 338 sizeof (ACPI_AEST_NODE_INTERFACE), AcpiDmTableInfoAestXface); 339 if (ACPI_FAILURE (Status)) 340 { 341 return; 342 } 343 344 /* Point past the interface structure */ 345 346 AcpiOsPrintf ("\n"); 347 Offset += sizeof (ACPI_AEST_NODE_INTERFACE); 348 349 /* Dump the entire interrupt structure array, if present */ 350 351 if (NodeHeader->NodeInterruptOffset) 352 { 353 Length = NodeHeader->NodeInterruptCount; 354 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 355 356 while (Length) 357 { 358 /* Dump the interrupt structure */ 359 360 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 361 sizeof (ACPI_AEST_NODE_INTERRUPT), 362 AcpiDmTableInfoAestXrupt); 363 if (ACPI_FAILURE (Status)) 364 { 365 return; 366 } 367 368 /* Point to the next interrupt structure */ 369 370 Offset += sizeof (ACPI_AEST_NODE_INTERRUPT); 371 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 372 Length--; 373 AcpiOsPrintf ("\n"); 374 } 375 } 376 } 377 } 378 379 380 /******************************************************************************* 381 * 382 * FUNCTION: AcpiDmDumpAsf 383 * 384 * PARAMETERS: Table - A ASF table 385 * 386 * RETURN: None 387 * 388 * DESCRIPTION: Format the contents of a ASF table 389 * 390 ******************************************************************************/ 391 392 void 393 AcpiDmDumpAsf ( 394 ACPI_TABLE_HEADER *Table) 395 { 396 ACPI_STATUS Status; 397 UINT32 Offset = sizeof (ACPI_TABLE_HEADER); 398 ACPI_ASF_INFO *Subtable; 399 ACPI_DMTABLE_INFO *InfoTable; 400 ACPI_DMTABLE_INFO *DataInfoTable = NULL; 401 UINT8 *DataTable = NULL; 402 UINT32 DataCount = 0; 403 UINT32 DataLength = 0; 404 UINT32 DataOffset = 0; 405 UINT32 i; 406 UINT8 Type; 407 408 409 /* No main table, only subtables */ 410 411 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); 412 while (Offset < Table->Length) 413 { 414 /* Common subtable header */ 415 416 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 417 Subtable->Header.Length, AcpiDmTableInfoAsfHdr); 418 if (ACPI_FAILURE (Status)) 419 { 420 return; 421 } 422 423 /* The actual type is the lower 7 bits of Type */ 424 425 Type = (UINT8) (Subtable->Header.Type & 0x7F); 426 427 switch (Type) 428 { 429 case ACPI_ASF_TYPE_INFO: 430 431 InfoTable = AcpiDmTableInfoAsf0; 432 break; 433 434 case ACPI_ASF_TYPE_ALERT: 435 436 InfoTable = AcpiDmTableInfoAsf1; 437 DataInfoTable = AcpiDmTableInfoAsf1a; 438 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ALERT)); 439 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->Alerts; 440 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->DataLength; 441 DataOffset = Offset + sizeof (ACPI_ASF_ALERT); 442 break; 443 444 case ACPI_ASF_TYPE_CONTROL: 445 446 InfoTable = AcpiDmTableInfoAsf2; 447 DataInfoTable = AcpiDmTableInfoAsf2a; 448 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_REMOTE)); 449 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->Controls; 450 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->DataLength; 451 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE); 452 break; 453 454 case ACPI_ASF_TYPE_BOOT: 455 456 InfoTable = AcpiDmTableInfoAsf3; 457 break; 458 459 case ACPI_ASF_TYPE_ADDRESS: 460 461 InfoTable = AcpiDmTableInfoAsf4; 462 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ADDRESS)); 463 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, Subtable)->Devices; 464 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS); 465 break; 466 467 default: 468 469 AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n", 470 Subtable->Header.Type); 471 return; 472 } 473 474 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 475 Subtable->Header.Length, InfoTable); 476 if (ACPI_FAILURE (Status)) 477 { 478 return; 479 } 480 481 /* Dump variable-length extra data */ 482 483 switch (Type) 484 { 485 case ACPI_ASF_TYPE_ALERT: 486 case ACPI_ASF_TYPE_CONTROL: 487 488 for (i = 0; i < DataCount; i++) 489 { 490 AcpiOsPrintf ("\n"); 491 Status = AcpiDmDumpTable (Table->Length, DataOffset, 492 DataTable, DataLength, DataInfoTable); 493 if (ACPI_FAILURE (Status)) 494 { 495 return; 496 } 497 498 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength); 499 DataOffset += DataLength; 500 } 501 break; 502 503 case ACPI_ASF_TYPE_ADDRESS: 504 505 for (i = 0; i < DataLength; i++) 506 { 507 if (!(i % 16)) 508 { 509 AcpiDmLineHeader (DataOffset, 1, "Addresses"); 510 } 511 512 AcpiOsPrintf ("%2.2X ", *DataTable); 513 DataTable++; 514 DataOffset++; 515 516 if (DataOffset > Table->Length) 517 { 518 AcpiOsPrintf ( 519 "**** ACPI table terminates in the middle of a " 520 "data structure! (ASF! table)\n"); 521 return; 522 } 523 } 524 525 AcpiOsPrintf ("\n"); 526 break; 527 528 default: 529 530 break; 531 } 532 533 AcpiOsPrintf ("\n"); 534 535 /* Point to next subtable */ 536 537 if (!Subtable->Header.Length) 538 { 539 AcpiOsPrintf ("Invalid zero subtable header length\n"); 540 return; 541 } 542 543 Offset += Subtable->Header.Length; 544 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Subtable, 545 Subtable->Header.Length); 546 } 547 } 548 549 /******************************************************************************* 550 * 551 * FUNCTION: AcpiDmDumpCedt 552 * 553 * PARAMETERS: Table - A CEDT table 554 * 555 * RETURN: None 556 * 557 * DESCRIPTION: Format the contents of a CEDT. This table type consists 558 * of an open-ended number of subtables. 559 * 560 ******************************************************************************/ 561 562 void 563 AcpiDmDumpCedt ( 564 ACPI_TABLE_HEADER *Table) 565 { 566 ACPI_STATUS Status; 567 ACPI_CEDT_HEADER *Subtable; 568 UINT32 Length = Table->Length; 569 UINT32 Offset = sizeof (ACPI_TABLE_CEDT); 570 ACPI_DMTABLE_INFO *InfoTable; 571 572 573 /* There is no main table (other than the standard ACPI header) */ 574 575 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Table, Offset); 576 while (Offset < Table->Length) 577 { 578 /* Common subtable header */ 579 580 AcpiOsPrintf ("\n"); 581 Status = AcpiDmDumpTable (Length, Offset, Subtable, 582 Subtable->Length, AcpiDmTableInfoCedtHdr); 583 if (ACPI_FAILURE (Status)) 584 { 585 return; 586 } 587 588 switch (Subtable->Type) 589 { 590 case ACPI_CEDT_TYPE_CHBS: 591 592 InfoTable = AcpiDmTableInfoCedt0; 593 break; 594 595 default: 596 597 AcpiOsPrintf ("\n**** Unknown CEDT subtable type 0x%X\n\n", 598 Subtable->Type); 599 600 /* Attempt to continue */ 601 602 if (!Subtable->Length) 603 { 604 AcpiOsPrintf ("Invalid zero length subtable\n"); 605 return; 606 } 607 goto NextSubtable; 608 } 609 610 Status = AcpiDmDumpTable (Length, Offset, Subtable, 611 Subtable->Length, InfoTable); 612 if (ACPI_FAILURE (Status)) 613 { 614 return; 615 } 616 617 NextSubtable: 618 /* Point to next subtable */ 619 620 Offset += Subtable->Length; 621 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Subtable, 622 Subtable->Length); 623 } 624 } 625 626 /******************************************************************************* 627 * 628 * FUNCTION: AcpiDmDumpCpep 629 * 630 * PARAMETERS: Table - A CPEP table 631 * 632 * RETURN: None 633 * 634 * DESCRIPTION: Format the contents of a CPEP. This table type consists 635 * of an open-ended number of subtables. 636 * 637 ******************************************************************************/ 638 639 void 640 AcpiDmDumpCpep ( 641 ACPI_TABLE_HEADER *Table) 642 { 643 ACPI_STATUS Status; 644 ACPI_CPEP_POLLING *Subtable; 645 UINT32 Length = Table->Length; 646 UINT32 Offset = sizeof (ACPI_TABLE_CPEP); 647 648 649 /* Main table */ 650 651 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep); 652 if (ACPI_FAILURE (Status)) 653 { 654 return; 655 } 656 657 /* Subtables */ 658 659 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset); 660 while (Offset < Table->Length) 661 { 662 AcpiOsPrintf ("\n"); 663 Status = AcpiDmDumpTable (Length, Offset, Subtable, 664 Subtable->Header.Length, AcpiDmTableInfoCpep0); 665 if (ACPI_FAILURE (Status)) 666 { 667 return; 668 } 669 670 /* Point to next subtable */ 671 672 Offset += Subtable->Header.Length; 673 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Subtable, 674 Subtable->Header.Length); 675 } 676 } 677 678 679 /******************************************************************************* 680 * 681 * FUNCTION: AcpiDmDumpCsrt 682 * 683 * PARAMETERS: Table - A CSRT table 684 * 685 * RETURN: None 686 * 687 * DESCRIPTION: Format the contents of a CSRT. This table type consists 688 * of an open-ended number of subtables. 689 * 690 ******************************************************************************/ 691 692 void 693 AcpiDmDumpCsrt ( 694 ACPI_TABLE_HEADER *Table) 695 { 696 ACPI_STATUS Status; 697 ACPI_CSRT_GROUP *Subtable; 698 ACPI_CSRT_SHARED_INFO *SharedInfoTable; 699 ACPI_CSRT_DESCRIPTOR *SubSubtable; 700 UINT32 Length = Table->Length; 701 UINT32 Offset = sizeof (ACPI_TABLE_CSRT); 702 UINT32 SubOffset; 703 UINT32 SubSubOffset; 704 UINT32 InfoLength; 705 706 707 /* The main table only contains the ACPI header, thus already handled */ 708 709 /* Subtables (Resource Groups) */ 710 711 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset); 712 while (Offset < Table->Length) 713 { 714 /* Resource group subtable */ 715 716 AcpiOsPrintf ("\n"); 717 Status = AcpiDmDumpTable (Length, Offset, Subtable, 718 Subtable->Length, AcpiDmTableInfoCsrt0); 719 if (ACPI_FAILURE (Status)) 720 { 721 return; 722 } 723 724 /* Shared info subtable (One per resource group) */ 725 726 SubOffset = sizeof (ACPI_CSRT_GROUP); 727 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table, 728 Offset + SubOffset); 729 730 AcpiOsPrintf ("\n"); 731 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable, 732 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1); 733 if (ACPI_FAILURE (Status)) 734 { 735 return; 736 } 737 738 SubOffset += Subtable->SharedInfoLength; 739 740 /* Sub-Subtables (Resource Descriptors) */ 741 742 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table, 743 Offset + SubOffset); 744 745 while ((SubOffset < Subtable->Length) && 746 ((Offset + SubOffset) < Table->Length)) 747 { 748 AcpiOsPrintf ("\n"); 749 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubtable, 750 SubSubtable->Length, AcpiDmTableInfoCsrt2); 751 if (ACPI_FAILURE (Status)) 752 { 753 return; 754 } 755 756 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR); 757 758 /* Resource-specific info buffer */ 759 760 InfoLength = SubSubtable->Length - SubSubOffset; 761 if (InfoLength) 762 { 763 Status = AcpiDmDumpTable (Length, 764 Offset + SubOffset + SubSubOffset, Table, 765 InfoLength, AcpiDmTableInfoCsrt2a); 766 if (ACPI_FAILURE (Status)) 767 { 768 return; 769 } 770 } 771 772 /* Point to next sub-subtable */ 773 774 SubOffset += SubSubtable->Length; 775 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubtable, 776 SubSubtable->Length); 777 } 778 779 /* Point to next subtable */ 780 781 Offset += Subtable->Length; 782 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Subtable, 783 Subtable->Length); 784 } 785 } 786 787 788 /******************************************************************************* 789 * 790 * FUNCTION: AcpiDmDumpDbg2 791 * 792 * PARAMETERS: Table - A DBG2 table 793 * 794 * RETURN: None 795 * 796 * DESCRIPTION: Format the contents of a DBG2. This table type consists 797 * of an open-ended number of subtables. 798 * 799 ******************************************************************************/ 800 801 void 802 AcpiDmDumpDbg2 ( 803 ACPI_TABLE_HEADER *Table) 804 { 805 ACPI_STATUS Status; 806 ACPI_DBG2_DEVICE *Subtable; 807 UINT32 Length = Table->Length; 808 UINT32 Offset = sizeof (ACPI_TABLE_DBG2); 809 UINT32 i; 810 UINT32 ArrayOffset; 811 UINT32 AbsoluteOffset; 812 UINT8 *Array; 813 814 815 /* Main table */ 816 817 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2); 818 if (ACPI_FAILURE (Status)) 819 { 820 return; 821 } 822 823 /* Subtables */ 824 825 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset); 826 while (Offset < Table->Length) 827 { 828 AcpiOsPrintf ("\n"); 829 Status = AcpiDmDumpTable (Length, Offset, Subtable, 830 Subtable->Length, AcpiDmTableInfoDbg2Device); 831 if (ACPI_FAILURE (Status)) 832 { 833 return; 834 } 835 836 /* Dump the BaseAddress array */ 837 838 for (i = 0; i < Subtable->RegisterCount; i++) 839 { 840 ArrayOffset = Subtable->BaseAddressOffset + 841 (sizeof (ACPI_GENERIC_ADDRESS) * i); 842 AbsoluteOffset = Offset + ArrayOffset; 843 Array = (UINT8 *) Subtable + ArrayOffset; 844 845 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 846 Subtable->Length, AcpiDmTableInfoDbg2Addr); 847 if (ACPI_FAILURE (Status)) 848 { 849 return; 850 } 851 } 852 853 /* Dump the AddressSize array */ 854 855 for (i = 0; i < Subtable->RegisterCount; i++) 856 { 857 ArrayOffset = Subtable->AddressSizeOffset + 858 (sizeof (UINT32) * i); 859 AbsoluteOffset = Offset + ArrayOffset; 860 Array = (UINT8 *) Subtable + ArrayOffset; 861 862 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 863 Subtable->Length, AcpiDmTableInfoDbg2Size); 864 if (ACPI_FAILURE (Status)) 865 { 866 return; 867 } 868 } 869 870 /* Dump the Namestring (required) */ 871 872 AcpiOsPrintf ("\n"); 873 ArrayOffset = Subtable->NamepathOffset; 874 AbsoluteOffset = Offset + ArrayOffset; 875 Array = (UINT8 *) Subtable + ArrayOffset; 876 877 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 878 Subtable->Length, AcpiDmTableInfoDbg2Name); 879 if (ACPI_FAILURE (Status)) 880 { 881 return; 882 } 883 884 /* Dump the OemData (optional) */ 885 886 if (Subtable->OemDataOffset) 887 { 888 Status = AcpiDmDumpTable (Length, Offset + Subtable->OemDataOffset, 889 Table, Subtable->OemDataLength, 890 AcpiDmTableInfoDbg2OemData); 891 if (ACPI_FAILURE (Status)) 892 { 893 return; 894 } 895 } 896 897 /* Point to next subtable */ 898 899 Offset += Subtable->Length; 900 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Subtable, 901 Subtable->Length); 902 } 903 } 904 905 906 /******************************************************************************* 907 * 908 * FUNCTION: AcpiDmDumpDmar 909 * 910 * PARAMETERS: Table - A DMAR table 911 * 912 * RETURN: None 913 * 914 * DESCRIPTION: Format the contents of a DMAR. This table type consists 915 * of an open-ended number of subtables. 916 * 917 ******************************************************************************/ 918 919 void 920 AcpiDmDumpDmar ( 921 ACPI_TABLE_HEADER *Table) 922 { 923 ACPI_STATUS Status; 924 ACPI_DMAR_HEADER *Subtable; 925 UINT32 Length = Table->Length; 926 UINT32 Offset = sizeof (ACPI_TABLE_DMAR); 927 ACPI_DMTABLE_INFO *InfoTable; 928 ACPI_DMAR_DEVICE_SCOPE *ScopeTable; 929 UINT32 ScopeOffset; 930 UINT8 *PciPath; 931 UINT32 PathOffset; 932 933 934 /* Main table */ 935 936 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); 937 if (ACPI_FAILURE (Status)) 938 { 939 return; 940 } 941 942 /* Subtables */ 943 944 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); 945 while (Offset < Table->Length) 946 { 947 /* Common subtable header */ 948 949 AcpiOsPrintf ("\n"); 950 Status = AcpiDmDumpTable (Length, Offset, Subtable, 951 Subtable->Length, AcpiDmTableInfoDmarHdr); 952 if (ACPI_FAILURE (Status)) 953 { 954 return; 955 } 956 957 AcpiOsPrintf ("\n"); 958 959 switch (Subtable->Type) 960 { 961 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 962 963 InfoTable = AcpiDmTableInfoDmar0; 964 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT); 965 break; 966 967 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 968 969 InfoTable = AcpiDmTableInfoDmar1; 970 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY); 971 break; 972 973 case ACPI_DMAR_TYPE_ROOT_ATS: 974 975 InfoTable = AcpiDmTableInfoDmar2; 976 ScopeOffset = sizeof (ACPI_DMAR_ATSR); 977 break; 978 979 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY: 980 981 InfoTable = AcpiDmTableInfoDmar3; 982 ScopeOffset = sizeof (ACPI_DMAR_RHSA); 983 break; 984 985 case ACPI_DMAR_TYPE_NAMESPACE: 986 987 InfoTable = AcpiDmTableInfoDmar4; 988 ScopeOffset = sizeof (ACPI_DMAR_ANDD); 989 break; 990 991 default: 992 993 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n", 994 Subtable->Type); 995 return; 996 } 997 998 Status = AcpiDmDumpTable (Length, Offset, Subtable, 999 Subtable->Length, InfoTable); 1000 if (ACPI_FAILURE (Status)) 1001 { 1002 return; 1003 } 1004 1005 /* 1006 * Dump the optional device scope entries 1007 */ 1008 if ((Subtable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || 1009 (Subtable->Type == ACPI_DMAR_TYPE_NAMESPACE)) 1010 { 1011 /* These types do not support device scopes */ 1012 1013 goto NextSubtable; 1014 } 1015 1016 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable, ScopeOffset); 1017 while (ScopeOffset < Subtable->Length) 1018 { 1019 AcpiOsPrintf ("\n"); 1020 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, 1021 ScopeTable->Length, AcpiDmTableInfoDmarScope); 1022 if (ACPI_FAILURE (Status)) 1023 { 1024 return; 1025 } 1026 AcpiOsPrintf ("\n"); 1027 1028 /* Dump the PCI Path entries for this device scope */ 1029 1030 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */ 1031 1032 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable, 1033 sizeof (ACPI_DMAR_DEVICE_SCOPE)); 1034 1035 while (PathOffset < ScopeTable->Length) 1036 { 1037 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, 1038 "PCI Path"); 1039 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]); 1040 1041 /* Point to next PCI Path entry */ 1042 1043 PathOffset += 2; 1044 PciPath += 2; 1045 AcpiOsPrintf ("\n"); 1046 } 1047 1048 /* Point to next device scope entry */ 1049 1050 ScopeOffset += ScopeTable->Length; 1051 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, 1052 ScopeTable, ScopeTable->Length); 1053 } 1054 1055 NextSubtable: 1056 /* Point to next subtable */ 1057 1058 Offset += Subtable->Length; 1059 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Subtable, 1060 Subtable->Length); 1061 } 1062 } 1063 1064 1065 /******************************************************************************* 1066 * 1067 * FUNCTION: AcpiDmDumpDrtm 1068 * 1069 * PARAMETERS: Table - A DRTM table 1070 * 1071 * RETURN: None 1072 * 1073 * DESCRIPTION: Format the contents of a DRTM. 1074 * 1075 ******************************************************************************/ 1076 1077 void 1078 AcpiDmDumpDrtm ( 1079 ACPI_TABLE_HEADER *Table) 1080 { 1081 ACPI_STATUS Status; 1082 UINT32 Offset; 1083 ACPI_DRTM_VTABLE_LIST *DrtmVtl; 1084 ACPI_DRTM_RESOURCE_LIST *DrtmRl; 1085 ACPI_DRTM_DPS_ID *DrtmDps; 1086 UINT32 Count; 1087 1088 1089 /* Main table */ 1090 1091 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 1092 AcpiDmTableInfoDrtm); 1093 if (ACPI_FAILURE (Status)) 1094 { 1095 return; 1096 } 1097 1098 Offset = sizeof (ACPI_TABLE_DRTM); 1099 1100 /* Sub-tables */ 1101 1102 /* Dump ValidatedTable length */ 1103 1104 DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset); 1105 AcpiOsPrintf ("\n"); 1106 Status = AcpiDmDumpTable (Table->Length, Offset, 1107 DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables), 1108 AcpiDmTableInfoDrtm0); 1109 if (ACPI_FAILURE (Status)) 1110 { 1111 return; 1112 } 1113 1114 Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables); 1115 1116 /* Dump Validated table addresses */ 1117 1118 Count = 0; 1119 while ((Offset < Table->Length) && 1120 (DrtmVtl->ValidatedTableCount > Count)) 1121 { 1122 Status = AcpiDmDumpTable (Table->Length, Offset, 1123 ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64), 1124 AcpiDmTableInfoDrtm0a); 1125 if (ACPI_FAILURE (Status)) 1126 { 1127 return; 1128 } 1129 1130 Offset += sizeof (UINT64); 1131 Count++; 1132 } 1133 1134 /* Dump ResourceList length */ 1135 1136 DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset); 1137 AcpiOsPrintf ("\n"); 1138 Status = AcpiDmDumpTable (Table->Length, Offset, 1139 DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources), 1140 AcpiDmTableInfoDrtm1); 1141 if (ACPI_FAILURE (Status)) 1142 { 1143 return; 1144 } 1145 1146 Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources); 1147 1148 /* Dump the Resource List */ 1149 1150 Count = 0; 1151 while ((Offset < Table->Length) && 1152 (DrtmRl->ResourceCount > Count)) 1153 { 1154 Status = AcpiDmDumpTable (Table->Length, Offset, 1155 ACPI_ADD_PTR (void, Table, Offset), 1156 sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a); 1157 if (ACPI_FAILURE (Status)) 1158 { 1159 return; 1160 } 1161 1162 Offset += sizeof (ACPI_DRTM_RESOURCE); 1163 Count++; 1164 } 1165 1166 /* Dump DPS */ 1167 1168 DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset); 1169 AcpiOsPrintf ("\n"); 1170 (void) AcpiDmDumpTable (Table->Length, Offset, 1171 DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2); 1172 } 1173 1174 1175 /******************************************************************************* 1176 * 1177 * FUNCTION: AcpiDmDumpEinj 1178 * 1179 * PARAMETERS: Table - A EINJ table 1180 * 1181 * RETURN: None 1182 * 1183 * DESCRIPTION: Format the contents of a EINJ. This table type consists 1184 * of an open-ended number of subtables. 1185 * 1186 ******************************************************************************/ 1187 1188 void 1189 AcpiDmDumpEinj ( 1190 ACPI_TABLE_HEADER *Table) 1191 { 1192 ACPI_STATUS Status; 1193 ACPI_WHEA_HEADER *Subtable; 1194 UINT32 Length = Table->Length; 1195 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 1196 1197 1198 /* Main table */ 1199 1200 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 1201 if (ACPI_FAILURE (Status)) 1202 { 1203 return; 1204 } 1205 1206 /* Subtables */ 1207 1208 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1209 while (Offset < Table->Length) 1210 { 1211 AcpiOsPrintf ("\n"); 1212 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1213 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 1214 if (ACPI_FAILURE (Status)) 1215 { 1216 return; 1217 } 1218 1219 /* Point to next subtable (each subtable is of fixed length) */ 1220 1221 Offset += sizeof (ACPI_WHEA_HEADER); 1222 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable, 1223 sizeof (ACPI_WHEA_HEADER)); 1224 } 1225 } 1226 1227 1228 /******************************************************************************* 1229 * 1230 * FUNCTION: AcpiDmDumpErst 1231 * 1232 * PARAMETERS: Table - A ERST table 1233 * 1234 * RETURN: None 1235 * 1236 * DESCRIPTION: Format the contents of a ERST. This table type consists 1237 * of an open-ended number of subtables. 1238 * 1239 ******************************************************************************/ 1240 1241 void 1242 AcpiDmDumpErst ( 1243 ACPI_TABLE_HEADER *Table) 1244 { 1245 ACPI_STATUS Status; 1246 ACPI_WHEA_HEADER *Subtable; 1247 UINT32 Length = Table->Length; 1248 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 1249 1250 1251 /* Main table */ 1252 1253 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 1254 if (ACPI_FAILURE (Status)) 1255 { 1256 return; 1257 } 1258 1259 /* Subtables */ 1260 1261 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1262 while (Offset < Table->Length) 1263 { 1264 AcpiOsPrintf ("\n"); 1265 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1266 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0); 1267 if (ACPI_FAILURE (Status)) 1268 { 1269 return; 1270 } 1271 1272 /* Point to next subtable (each subtable is of fixed length) */ 1273 1274 Offset += sizeof (ACPI_WHEA_HEADER); 1275 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable, 1276 sizeof (ACPI_WHEA_HEADER)); 1277 } 1278 } 1279 1280 1281 /******************************************************************************* 1282 * 1283 * FUNCTION: AcpiDmDumpFpdt 1284 * 1285 * PARAMETERS: Table - A FPDT table 1286 * 1287 * RETURN: None 1288 * 1289 * DESCRIPTION: Format the contents of a FPDT. This table type consists 1290 * of an open-ended number of subtables. 1291 * 1292 ******************************************************************************/ 1293 1294 void 1295 AcpiDmDumpFpdt ( 1296 ACPI_TABLE_HEADER *Table) 1297 { 1298 ACPI_STATUS Status; 1299 ACPI_FPDT_HEADER *Subtable; 1300 UINT32 Length = Table->Length; 1301 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 1302 ACPI_DMTABLE_INFO *InfoTable; 1303 1304 1305 /* There is no main table (other than the standard ACPI header) */ 1306 1307 /* Subtables */ 1308 1309 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); 1310 while (Offset < Table->Length) 1311 { 1312 /* Common subtable header */ 1313 1314 AcpiOsPrintf ("\n"); 1315 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1316 Subtable->Length, AcpiDmTableInfoFpdtHdr); 1317 if (ACPI_FAILURE (Status)) 1318 { 1319 return; 1320 } 1321 1322 switch (Subtable->Type) 1323 { 1324 case ACPI_FPDT_TYPE_BOOT: 1325 1326 InfoTable = AcpiDmTableInfoFpdt0; 1327 break; 1328 1329 case ACPI_FPDT_TYPE_S3PERF: 1330 1331 InfoTable = AcpiDmTableInfoFpdt1; 1332 break; 1333 1334 default: 1335 1336 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", 1337 Subtable->Type); 1338 1339 /* Attempt to continue */ 1340 1341 if (!Subtable->Length) 1342 { 1343 AcpiOsPrintf ("Invalid zero length subtable\n"); 1344 return; 1345 } 1346 goto NextSubtable; 1347 } 1348 1349 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1350 Subtable->Length, InfoTable); 1351 if (ACPI_FAILURE (Status)) 1352 { 1353 return; 1354 } 1355 1356 NextSubtable: 1357 /* Point to next subtable */ 1358 1359 Offset += Subtable->Length; 1360 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, 1361 Subtable->Length); 1362 } 1363 } 1364 1365 1366 /******************************************************************************* 1367 * 1368 * FUNCTION: AcpiDmDumpGtdt 1369 * 1370 * PARAMETERS: Table - A GTDT table 1371 * 1372 * RETURN: None 1373 * 1374 * DESCRIPTION: Format the contents of a GTDT. This table type consists 1375 * of an open-ended number of subtables. 1376 * 1377 ******************************************************************************/ 1378 1379 void 1380 AcpiDmDumpGtdt ( 1381 ACPI_TABLE_HEADER *Table) 1382 { 1383 ACPI_STATUS Status; 1384 ACPI_GTDT_HEADER *Subtable; 1385 UINT32 Length = Table->Length; 1386 UINT32 Offset = sizeof (ACPI_TABLE_GTDT); 1387 ACPI_DMTABLE_INFO *InfoTable; 1388 UINT32 SubtableLength; 1389 UINT32 GtCount; 1390 ACPI_GTDT_TIMER_ENTRY *GtxTable; 1391 1392 1393 /* Main table */ 1394 1395 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt); 1396 if (ACPI_FAILURE (Status)) 1397 { 1398 return; 1399 } 1400 1401 /* Rev 3 fields */ 1402 1403 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 1404 1405 if (Table->Revision > 2) 1406 { 1407 SubtableLength = sizeof (ACPI_GTDT_EL2); 1408 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1409 SubtableLength, AcpiDmTableInfoGtdtEl2); 1410 if (ACPI_FAILURE (Status)) 1411 { 1412 return; 1413 } 1414 Offset += SubtableLength; 1415 } 1416 1417 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 1418 1419 /* Subtables */ 1420 1421 while (Offset < Table->Length) 1422 { 1423 /* Common subtable header */ 1424 1425 AcpiOsPrintf ("\n"); 1426 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1427 Subtable->Length, AcpiDmTableInfoGtdtHdr); 1428 if (ACPI_FAILURE (Status)) 1429 { 1430 return; 1431 } 1432 1433 GtCount = 0; 1434 switch (Subtable->Type) 1435 { 1436 case ACPI_GTDT_TYPE_TIMER_BLOCK: 1437 1438 SubtableLength = sizeof (ACPI_GTDT_TIMER_BLOCK); 1439 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, 1440 Subtable))->TimerCount; 1441 1442 InfoTable = AcpiDmTableInfoGtdt0; 1443 break; 1444 1445 case ACPI_GTDT_TYPE_WATCHDOG: 1446 1447 SubtableLength = sizeof (ACPI_GTDT_WATCHDOG); 1448 1449 InfoTable = AcpiDmTableInfoGtdt1; 1450 break; 1451 1452 default: 1453 1454 /* Cannot continue on unknown type - no length */ 1455 1456 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n", 1457 Subtable->Type); 1458 return; 1459 } 1460 1461 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1462 Subtable->Length, InfoTable); 1463 if (ACPI_FAILURE (Status)) 1464 { 1465 return; 1466 } 1467 1468 /* Point to end of current subtable (each subtable above is of fixed length) */ 1469 1470 Offset += SubtableLength; 1471 1472 /* If there are any Gt Timer Blocks from above, dump them now */ 1473 1474 if (GtCount) 1475 { 1476 GtxTable = ACPI_ADD_PTR ( 1477 ACPI_GTDT_TIMER_ENTRY, Subtable, SubtableLength); 1478 SubtableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY); 1479 1480 while (GtCount) 1481 { 1482 AcpiOsPrintf ("\n"); 1483 Status = AcpiDmDumpTable (Length, Offset, GtxTable, 1484 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a); 1485 if (ACPI_FAILURE (Status)) 1486 { 1487 return; 1488 } 1489 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY); 1490 GtxTable++; 1491 GtCount--; 1492 } 1493 } 1494 1495 /* Point to next subtable */ 1496 1497 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Subtable, SubtableLength); 1498 } 1499 } 1500 1501 1502 /******************************************************************************* 1503 * 1504 * FUNCTION: AcpiDmDumpHest 1505 * 1506 * PARAMETERS: Table - A HEST table 1507 * 1508 * RETURN: None 1509 * 1510 * DESCRIPTION: Format the contents of a HEST. This table type consists 1511 * of an open-ended number of subtables. 1512 * 1513 ******************************************************************************/ 1514 1515 void 1516 AcpiDmDumpHest ( 1517 ACPI_TABLE_HEADER *Table) 1518 { 1519 ACPI_STATUS Status; 1520 ACPI_HEST_HEADER *Subtable; 1521 UINT32 Length = Table->Length; 1522 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 1523 ACPI_DMTABLE_INFO *InfoTable; 1524 UINT32 SubtableLength; 1525 UINT32 BankCount; 1526 ACPI_HEST_IA_ERROR_BANK *BankTable; 1527 1528 1529 /* Main table */ 1530 1531 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 1532 if (ACPI_FAILURE (Status)) 1533 { 1534 return; 1535 } 1536 1537 /* Subtables */ 1538 1539 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 1540 while (Offset < Table->Length) 1541 { 1542 BankCount = 0; 1543 switch (Subtable->Type) 1544 { 1545 case ACPI_HEST_TYPE_IA32_CHECK: 1546 1547 InfoTable = AcpiDmTableInfoHest0; 1548 SubtableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK); 1549 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 1550 Subtable))->NumHardwareBanks; 1551 break; 1552 1553 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 1554 1555 InfoTable = AcpiDmTableInfoHest1; 1556 SubtableLength = sizeof (ACPI_HEST_IA_CORRECTED); 1557 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 1558 Subtable))->NumHardwareBanks; 1559 break; 1560 1561 case ACPI_HEST_TYPE_IA32_NMI: 1562 1563 InfoTable = AcpiDmTableInfoHest2; 1564 SubtableLength = sizeof (ACPI_HEST_IA_NMI); 1565 break; 1566 1567 case ACPI_HEST_TYPE_AER_ROOT_PORT: 1568 1569 InfoTable = AcpiDmTableInfoHest6; 1570 SubtableLength = sizeof (ACPI_HEST_AER_ROOT); 1571 break; 1572 1573 case ACPI_HEST_TYPE_AER_ENDPOINT: 1574 1575 InfoTable = AcpiDmTableInfoHest7; 1576 SubtableLength = sizeof (ACPI_HEST_AER); 1577 break; 1578 1579 case ACPI_HEST_TYPE_AER_BRIDGE: 1580 1581 InfoTable = AcpiDmTableInfoHest8; 1582 SubtableLength = sizeof (ACPI_HEST_AER_BRIDGE); 1583 break; 1584 1585 case ACPI_HEST_TYPE_GENERIC_ERROR: 1586 1587 InfoTable = AcpiDmTableInfoHest9; 1588 SubtableLength = sizeof (ACPI_HEST_GENERIC); 1589 break; 1590 1591 case ACPI_HEST_TYPE_GENERIC_ERROR_V2: 1592 1593 InfoTable = AcpiDmTableInfoHest10; 1594 SubtableLength = sizeof (ACPI_HEST_GENERIC_V2); 1595 break; 1596 1597 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK: 1598 1599 InfoTable = AcpiDmTableInfoHest11; 1600 SubtableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK); 1601 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK, 1602 Subtable))->NumHardwareBanks; 1603 break; 1604 1605 default: 1606 1607 /* Cannot continue on unknown type - no length */ 1608 1609 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n", 1610 Subtable->Type); 1611 return; 1612 } 1613 1614 AcpiOsPrintf ("\n"); 1615 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1616 SubtableLength, InfoTable); 1617 if (ACPI_FAILURE (Status)) 1618 { 1619 return; 1620 } 1621 1622 /* Point to end of current subtable (each subtable above is of fixed length) */ 1623 1624 Offset += SubtableLength; 1625 1626 /* If there are any (fixed-length) Error Banks from above, dump them now */ 1627 1628 if (BankCount) 1629 { 1630 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, Subtable, 1631 SubtableLength); 1632 SubtableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 1633 1634 while (BankCount) 1635 { 1636 AcpiOsPrintf ("\n"); 1637 Status = AcpiDmDumpTable (Length, Offset, BankTable, 1638 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 1639 if (ACPI_FAILURE (Status)) 1640 { 1641 return; 1642 } 1643 1644 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 1645 BankTable++; 1646 BankCount--; 1647 } 1648 } 1649 1650 /* Point to next subtable */ 1651 1652 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Subtable, SubtableLength); 1653 } 1654 } 1655 1656 1657 /******************************************************************************* 1658 * 1659 * FUNCTION: AcpiDmDumpHmat 1660 * 1661 * PARAMETERS: Table - A HMAT table 1662 * 1663 * RETURN: None 1664 * 1665 * DESCRIPTION: Format the contents of a HMAT. 1666 * 1667 ******************************************************************************/ 1668 1669 void 1670 AcpiDmDumpHmat ( 1671 ACPI_TABLE_HEADER *Table) 1672 { 1673 ACPI_STATUS Status; 1674 ACPI_HMAT_STRUCTURE *HmatStruct; 1675 ACPI_HMAT_LOCALITY *HmatLocality; 1676 ACPI_HMAT_CACHE *HmatCache; 1677 UINT32 Offset; 1678 UINT32 SubtableOffset; 1679 UINT32 Length; 1680 ACPI_DMTABLE_INFO *InfoTable; 1681 UINT32 i, j; 1682 1683 1684 /* Main table */ 1685 1686 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat); 1687 if (ACPI_FAILURE (Status)) 1688 { 1689 return; 1690 } 1691 Offset = sizeof (ACPI_TABLE_HMAT); 1692 1693 while (Offset < Table->Length) 1694 { 1695 AcpiOsPrintf ("\n"); 1696 1697 /* Dump HMAT structure header */ 1698 1699 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset); 1700 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE)) 1701 { 1702 AcpiOsPrintf ("Invalid HMAT structure length\n"); 1703 return; 1704 } 1705 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 1706 HmatStruct->Length, AcpiDmTableInfoHmatHdr); 1707 if (ACPI_FAILURE (Status)) 1708 { 1709 return; 1710 } 1711 1712 switch (HmatStruct->Type) 1713 { 1714 case ACPI_HMAT_TYPE_ADDRESS_RANGE: 1715 1716 InfoTable = AcpiDmTableInfoHmat0; 1717 Length = sizeof (ACPI_HMAT_PROXIMITY_DOMAIN); 1718 break; 1719 1720 case ACPI_HMAT_TYPE_LOCALITY: 1721 1722 InfoTable = AcpiDmTableInfoHmat1; 1723 Length = sizeof (ACPI_HMAT_LOCALITY); 1724 break; 1725 1726 case ACPI_HMAT_TYPE_CACHE: 1727 1728 InfoTable = AcpiDmTableInfoHmat2; 1729 Length = sizeof (ACPI_HMAT_CACHE); 1730 break; 1731 1732 default: 1733 1734 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n", 1735 HmatStruct->Type); 1736 1737 /* Attempt to continue */ 1738 1739 goto NextSubtable; 1740 } 1741 1742 /* Dump HMAT structure body */ 1743 1744 if (HmatStruct->Length < Length) 1745 { 1746 AcpiOsPrintf ("Invalid HMAT structure length\n"); 1747 return; 1748 } 1749 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 1750 HmatStruct->Length, InfoTable); 1751 if (ACPI_FAILURE (Status)) 1752 { 1753 return; 1754 } 1755 1756 /* Dump HMAT structure additionals */ 1757 1758 switch (HmatStruct->Type) 1759 { 1760 case ACPI_HMAT_TYPE_LOCALITY: 1761 1762 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct); 1763 SubtableOffset = sizeof (ACPI_HMAT_LOCALITY); 1764 1765 /* Dump initiator proximity domains */ 1766 1767 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 1768 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4)) 1769 { 1770 AcpiOsPrintf ("Invalid initiator proximity domain number\n"); 1771 return; 1772 } 1773 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 1774 { 1775 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 1776 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 1777 4, AcpiDmTableInfoHmat1a); 1778 if (ACPI_FAILURE (Status)) 1779 { 1780 return; 1781 } 1782 1783 SubtableOffset += 4; 1784 } 1785 1786 /* Dump target proximity domains */ 1787 1788 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 1789 (UINT32)(HmatLocality->NumberOfTargetPDs * 4)) 1790 { 1791 AcpiOsPrintf ("Invalid target proximity domain number\n"); 1792 return; 1793 } 1794 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++) 1795 { 1796 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 1797 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 1798 4, AcpiDmTableInfoHmat1b); 1799 if (ACPI_FAILURE (Status)) 1800 { 1801 return; 1802 } 1803 1804 SubtableOffset += 4; 1805 } 1806 1807 /* Dump latency/bandwidth entris */ 1808 1809 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 1810 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 1811 HmatLocality->NumberOfTargetPDs * 2)) 1812 { 1813 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n"); 1814 return; 1815 } 1816 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 1817 { 1818 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++) 1819 { 1820 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 1821 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 1822 2, AcpiDmTableInfoHmat1c); 1823 if (ACPI_FAILURE(Status)) 1824 { 1825 return; 1826 } 1827 1828 SubtableOffset += 2; 1829 } 1830 } 1831 break; 1832 1833 case ACPI_HMAT_TYPE_CACHE: 1834 1835 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct); 1836 SubtableOffset = sizeof (ACPI_HMAT_CACHE); 1837 1838 /* Dump SMBIOS handles */ 1839 1840 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 1841 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2)) 1842 { 1843 AcpiOsPrintf ("Invalid SMBIOS handle number\n"); 1844 return; 1845 } 1846 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++) 1847 { 1848 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 1849 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 1850 2, AcpiDmTableInfoHmat2a); 1851 if (ACPI_FAILURE (Status)) 1852 { 1853 return; 1854 } 1855 1856 SubtableOffset += 2; 1857 } 1858 break; 1859 1860 default: 1861 1862 break; 1863 } 1864 1865 NextSubtable: 1866 /* Point to next HMAT structure subtable */ 1867 1868 Offset += (HmatStruct->Length); 1869 } 1870 } 1871