dmtbdump1.c revision 1.1.1.12
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 - 2024, 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 default: 1484 1485 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n", 1486 Subtable->Type); 1487 return; 1488 } 1489 1490 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1491 Subtable->Length, InfoTable); 1492 if (ACPI_FAILURE (Status)) 1493 { 1494 return; 1495 } 1496 1497 /* 1498 * Dump the optional device scope entries 1499 */ 1500 if ((Subtable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || 1501 (Subtable->Type == ACPI_DMAR_TYPE_NAMESPACE)) 1502 { 1503 /* These types do not support device scopes */ 1504 1505 goto NextSubtable; 1506 } 1507 1508 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable, ScopeOffset); 1509 while (ScopeOffset < Subtable->Length) 1510 { 1511 AcpiOsPrintf ("\n"); 1512 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, 1513 ScopeTable->Length, AcpiDmTableInfoDmarScope); 1514 if (ACPI_FAILURE (Status)) 1515 { 1516 return; 1517 } 1518 AcpiOsPrintf ("\n"); 1519 1520 /* Dump the PCI Path entries for this device scope */ 1521 1522 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */ 1523 1524 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable, 1525 sizeof (ACPI_DMAR_DEVICE_SCOPE)); 1526 1527 while (PathOffset < ScopeTable->Length) 1528 { 1529 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, 1530 "PCI Path"); 1531 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]); 1532 1533 /* Point to next PCI Path entry */ 1534 1535 PathOffset += 2; 1536 PciPath += 2; 1537 AcpiOsPrintf ("\n"); 1538 } 1539 1540 /* Point to next device scope entry */ 1541 1542 ScopeOffset += ScopeTable->Length; 1543 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, 1544 ScopeTable, ScopeTable->Length); 1545 } 1546 1547 NextSubtable: 1548 /* Point to next subtable */ 1549 1550 Offset += Subtable->Length; 1551 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Subtable, 1552 Subtable->Length); 1553 } 1554 } 1555 1556 1557 /******************************************************************************* 1558 * 1559 * FUNCTION: AcpiDmDumpDrtm 1560 * 1561 * PARAMETERS: Table - A DRTM table 1562 * 1563 * RETURN: None 1564 * 1565 * DESCRIPTION: Format the contents of a DRTM. 1566 * 1567 ******************************************************************************/ 1568 1569 void 1570 AcpiDmDumpDrtm ( 1571 ACPI_TABLE_HEADER *Table) 1572 { 1573 ACPI_STATUS Status; 1574 UINT32 Offset; 1575 ACPI_DRTM_VTABLE_LIST *DrtmVtl; 1576 ACPI_DRTM_RESOURCE_LIST *DrtmRl; 1577 ACPI_DRTM_DPS_ID *DrtmDps; 1578 UINT32 Count; 1579 1580 1581 /* Main table */ 1582 1583 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 1584 AcpiDmTableInfoDrtm); 1585 if (ACPI_FAILURE (Status)) 1586 { 1587 return; 1588 } 1589 1590 Offset = sizeof (ACPI_TABLE_DRTM); 1591 1592 /* Sub-tables */ 1593 1594 /* Dump ValidatedTable length */ 1595 1596 DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset); 1597 AcpiOsPrintf ("\n"); 1598 Status = AcpiDmDumpTable (Table->Length, Offset, 1599 DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables), 1600 AcpiDmTableInfoDrtm0); 1601 if (ACPI_FAILURE (Status)) 1602 { 1603 return; 1604 } 1605 1606 Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables); 1607 1608 /* Dump Validated table addresses */ 1609 1610 Count = 0; 1611 while ((Offset < Table->Length) && 1612 (DrtmVtl->ValidatedTableCount > Count)) 1613 { 1614 Status = AcpiDmDumpTable (Table->Length, Offset, 1615 ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64), 1616 AcpiDmTableInfoDrtm0a); 1617 if (ACPI_FAILURE (Status)) 1618 { 1619 return; 1620 } 1621 1622 Offset += sizeof (UINT64); 1623 Count++; 1624 } 1625 1626 /* Dump ResourceList length */ 1627 1628 DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset); 1629 AcpiOsPrintf ("\n"); 1630 Status = AcpiDmDumpTable (Table->Length, Offset, 1631 DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources), 1632 AcpiDmTableInfoDrtm1); 1633 if (ACPI_FAILURE (Status)) 1634 { 1635 return; 1636 } 1637 1638 Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources); 1639 1640 /* Dump the Resource List */ 1641 1642 Count = 0; 1643 while ((Offset < Table->Length) && 1644 (DrtmRl->ResourceCount > Count)) 1645 { 1646 Status = AcpiDmDumpTable (Table->Length, Offset, 1647 ACPI_ADD_PTR (void, Table, Offset), 1648 sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a); 1649 if (ACPI_FAILURE (Status)) 1650 { 1651 return; 1652 } 1653 1654 Offset += sizeof (ACPI_DRTM_RESOURCE); 1655 Count++; 1656 } 1657 1658 /* Dump DPS */ 1659 1660 DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset); 1661 AcpiOsPrintf ("\n"); 1662 (void) AcpiDmDumpTable (Table->Length, Offset, 1663 DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2); 1664 } 1665 1666 1667 /******************************************************************************* 1668 * 1669 * FUNCTION: AcpiDmDumpEinj 1670 * 1671 * PARAMETERS: Table - A EINJ table 1672 * 1673 * RETURN: None 1674 * 1675 * DESCRIPTION: Format the contents of a EINJ. This table type consists 1676 * of an open-ended number of subtables. 1677 * 1678 ******************************************************************************/ 1679 1680 void 1681 AcpiDmDumpEinj ( 1682 ACPI_TABLE_HEADER *Table) 1683 { 1684 ACPI_STATUS Status; 1685 ACPI_WHEA_HEADER *Subtable; 1686 UINT32 Length = Table->Length; 1687 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 1688 1689 1690 /* Main table */ 1691 1692 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 1693 if (ACPI_FAILURE (Status)) 1694 { 1695 return; 1696 } 1697 1698 /* Subtables */ 1699 1700 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1701 while (Offset < Table->Length) 1702 { 1703 AcpiOsPrintf ("\n"); 1704 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1705 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 1706 if (ACPI_FAILURE (Status)) 1707 { 1708 return; 1709 } 1710 1711 /* Point to next subtable (each subtable is of fixed length) */ 1712 1713 Offset += sizeof (ACPI_WHEA_HEADER); 1714 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable, 1715 sizeof (ACPI_WHEA_HEADER)); 1716 } 1717 } 1718 1719 1720 /******************************************************************************* 1721 * 1722 * FUNCTION: AcpiDmDumpErst 1723 * 1724 * PARAMETERS: Table - A ERST table 1725 * 1726 * RETURN: None 1727 * 1728 * DESCRIPTION: Format the contents of a ERST. This table type consists 1729 * of an open-ended number of subtables. 1730 * 1731 ******************************************************************************/ 1732 1733 void 1734 AcpiDmDumpErst ( 1735 ACPI_TABLE_HEADER *Table) 1736 { 1737 ACPI_STATUS Status; 1738 ACPI_WHEA_HEADER *Subtable; 1739 UINT32 Length = Table->Length; 1740 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 1741 1742 1743 /* Main table */ 1744 1745 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 1746 if (ACPI_FAILURE (Status)) 1747 { 1748 return; 1749 } 1750 1751 /* Subtables */ 1752 1753 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1754 while (Offset < Table->Length) 1755 { 1756 AcpiOsPrintf ("\n"); 1757 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1758 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0); 1759 if (ACPI_FAILURE (Status)) 1760 { 1761 return; 1762 } 1763 1764 /* Point to next subtable (each subtable is of fixed length) */ 1765 1766 Offset += sizeof (ACPI_WHEA_HEADER); 1767 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable, 1768 sizeof (ACPI_WHEA_HEADER)); 1769 } 1770 } 1771 1772 1773 /******************************************************************************* 1774 * 1775 * FUNCTION: AcpiDmDumpFpdt 1776 * 1777 * PARAMETERS: Table - A FPDT table 1778 * 1779 * RETURN: None 1780 * 1781 * DESCRIPTION: Format the contents of a FPDT. This table type consists 1782 * of an open-ended number of subtables. 1783 * 1784 ******************************************************************************/ 1785 1786 void 1787 AcpiDmDumpFpdt ( 1788 ACPI_TABLE_HEADER *Table) 1789 { 1790 ACPI_STATUS Status; 1791 ACPI_FPDT_HEADER *Subtable; 1792 UINT32 Length = Table->Length; 1793 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 1794 ACPI_DMTABLE_INFO *InfoTable; 1795 1796 1797 /* There is no main table (other than the standard ACPI header) */ 1798 1799 /* Subtables */ 1800 1801 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); 1802 while (Offset < Table->Length) 1803 { 1804 /* Common subtable header */ 1805 1806 AcpiOsPrintf ("\n"); 1807 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1808 Subtable->Length, AcpiDmTableInfoFpdtHdr); 1809 if (ACPI_FAILURE (Status)) 1810 { 1811 return; 1812 } 1813 1814 switch (Subtable->Type) 1815 { 1816 case ACPI_FPDT_TYPE_BOOT: 1817 1818 InfoTable = AcpiDmTableInfoFpdt0; 1819 break; 1820 1821 case ACPI_FPDT_TYPE_S3PERF: 1822 1823 InfoTable = AcpiDmTableInfoFpdt1; 1824 break; 1825 1826 default: 1827 1828 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", 1829 Subtable->Type); 1830 1831 /* Attempt to continue */ 1832 1833 if (!Subtable->Length) 1834 { 1835 AcpiOsPrintf ("Invalid zero length subtable\n"); 1836 return; 1837 } 1838 goto NextSubtable; 1839 } 1840 1841 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1842 Subtable->Length, InfoTable); 1843 if (ACPI_FAILURE (Status)) 1844 { 1845 return; 1846 } 1847 1848 NextSubtable: 1849 /* Point to next subtable */ 1850 1851 Offset += Subtable->Length; 1852 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, 1853 Subtable->Length); 1854 } 1855 } 1856 1857 1858 /******************************************************************************* 1859 * 1860 * FUNCTION: AcpiDmDumpGtdt 1861 * 1862 * PARAMETERS: Table - A GTDT table 1863 * 1864 * RETURN: None 1865 * 1866 * DESCRIPTION: Format the contents of a GTDT. This table type consists 1867 * of an open-ended number of subtables. 1868 * 1869 ******************************************************************************/ 1870 1871 void 1872 AcpiDmDumpGtdt ( 1873 ACPI_TABLE_HEADER *Table) 1874 { 1875 ACPI_STATUS Status; 1876 ACPI_GTDT_HEADER *Subtable; 1877 UINT32 Length = Table->Length; 1878 UINT32 Offset = sizeof (ACPI_TABLE_GTDT); 1879 ACPI_DMTABLE_INFO *InfoTable; 1880 UINT32 SubtableLength; 1881 UINT32 GtCount; 1882 ACPI_GTDT_TIMER_ENTRY *GtxTable; 1883 1884 1885 /* Main table */ 1886 1887 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt); 1888 if (ACPI_FAILURE (Status)) 1889 { 1890 return; 1891 } 1892 1893 /* Rev 3 fields */ 1894 1895 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 1896 1897 if (Table->Revision > 2) 1898 { 1899 SubtableLength = sizeof (ACPI_GTDT_EL2); 1900 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1901 SubtableLength, AcpiDmTableInfoGtdtEl2); 1902 if (ACPI_FAILURE (Status)) 1903 { 1904 return; 1905 } 1906 Offset += SubtableLength; 1907 } 1908 1909 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 1910 1911 /* Subtables */ 1912 1913 while (Offset < Table->Length) 1914 { 1915 /* Common subtable header */ 1916 1917 AcpiOsPrintf ("\n"); 1918 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1919 Subtable->Length, AcpiDmTableInfoGtdtHdr); 1920 if (ACPI_FAILURE (Status)) 1921 { 1922 return; 1923 } 1924 1925 GtCount = 0; 1926 switch (Subtable->Type) 1927 { 1928 case ACPI_GTDT_TYPE_TIMER_BLOCK: 1929 1930 SubtableLength = sizeof (ACPI_GTDT_TIMER_BLOCK); 1931 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, 1932 Subtable))->TimerCount; 1933 1934 InfoTable = AcpiDmTableInfoGtdt0; 1935 break; 1936 1937 case ACPI_GTDT_TYPE_WATCHDOG: 1938 1939 SubtableLength = sizeof (ACPI_GTDT_WATCHDOG); 1940 1941 InfoTable = AcpiDmTableInfoGtdt1; 1942 break; 1943 1944 default: 1945 1946 /* Cannot continue on unknown type - no length */ 1947 1948 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n", 1949 Subtable->Type); 1950 return; 1951 } 1952 1953 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1954 Subtable->Length, InfoTable); 1955 if (ACPI_FAILURE (Status)) 1956 { 1957 return; 1958 } 1959 1960 /* Point to end of current subtable (each subtable above is of fixed length) */ 1961 1962 Offset += SubtableLength; 1963 1964 /* If there are any Gt Timer Blocks from above, dump them now */ 1965 1966 if (GtCount) 1967 { 1968 GtxTable = ACPI_ADD_PTR ( 1969 ACPI_GTDT_TIMER_ENTRY, Subtable, SubtableLength); 1970 SubtableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY); 1971 1972 while (GtCount) 1973 { 1974 AcpiOsPrintf ("\n"); 1975 Status = AcpiDmDumpTable (Length, Offset, GtxTable, 1976 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a); 1977 if (ACPI_FAILURE (Status)) 1978 { 1979 return; 1980 } 1981 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY); 1982 GtxTable++; 1983 GtCount--; 1984 } 1985 } 1986 1987 /* Point to next subtable */ 1988 1989 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Subtable, SubtableLength); 1990 } 1991 } 1992 1993 1994 /******************************************************************************* 1995 * 1996 * FUNCTION: AcpiDmDumpHest 1997 * 1998 * PARAMETERS: Table - A HEST table 1999 * 2000 * RETURN: None 2001 * 2002 * DESCRIPTION: Format the contents of a HEST. This table type consists 2003 * of an open-ended number of subtables. 2004 * 2005 ******************************************************************************/ 2006 2007 void 2008 AcpiDmDumpHest ( 2009 ACPI_TABLE_HEADER *Table) 2010 { 2011 ACPI_STATUS Status; 2012 ACPI_HEST_HEADER *Subtable; 2013 UINT32 Length = Table->Length; 2014 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 2015 ACPI_DMTABLE_INFO *InfoTable; 2016 UINT32 SubtableLength; 2017 UINT32 BankCount; 2018 ACPI_HEST_IA_ERROR_BANK *BankTable; 2019 2020 2021 /* Main table */ 2022 2023 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 2024 if (ACPI_FAILURE (Status)) 2025 { 2026 return; 2027 } 2028 2029 /* Subtables */ 2030 2031 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 2032 while (Offset < Table->Length) 2033 { 2034 BankCount = 0; 2035 switch (Subtable->Type) 2036 { 2037 case ACPI_HEST_TYPE_IA32_CHECK: 2038 2039 InfoTable = AcpiDmTableInfoHest0; 2040 SubtableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK); 2041 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 2042 Subtable))->NumHardwareBanks; 2043 break; 2044 2045 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 2046 2047 InfoTable = AcpiDmTableInfoHest1; 2048 SubtableLength = sizeof (ACPI_HEST_IA_CORRECTED); 2049 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 2050 Subtable))->NumHardwareBanks; 2051 break; 2052 2053 case ACPI_HEST_TYPE_IA32_NMI: 2054 2055 InfoTable = AcpiDmTableInfoHest2; 2056 SubtableLength = sizeof (ACPI_HEST_IA_NMI); 2057 break; 2058 2059 case ACPI_HEST_TYPE_AER_ROOT_PORT: 2060 2061 InfoTable = AcpiDmTableInfoHest6; 2062 SubtableLength = sizeof (ACPI_HEST_AER_ROOT); 2063 break; 2064 2065 case ACPI_HEST_TYPE_AER_ENDPOINT: 2066 2067 InfoTable = AcpiDmTableInfoHest7; 2068 SubtableLength = sizeof (ACPI_HEST_AER); 2069 break; 2070 2071 case ACPI_HEST_TYPE_AER_BRIDGE: 2072 2073 InfoTable = AcpiDmTableInfoHest8; 2074 SubtableLength = sizeof (ACPI_HEST_AER_BRIDGE); 2075 break; 2076 2077 case ACPI_HEST_TYPE_GENERIC_ERROR: 2078 2079 InfoTable = AcpiDmTableInfoHest9; 2080 SubtableLength = sizeof (ACPI_HEST_GENERIC); 2081 break; 2082 2083 case ACPI_HEST_TYPE_GENERIC_ERROR_V2: 2084 2085 InfoTable = AcpiDmTableInfoHest10; 2086 SubtableLength = sizeof (ACPI_HEST_GENERIC_V2); 2087 break; 2088 2089 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK: 2090 2091 InfoTable = AcpiDmTableInfoHest11; 2092 SubtableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK); 2093 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK, 2094 Subtable))->NumHardwareBanks; 2095 break; 2096 2097 default: 2098 2099 /* Cannot continue on unknown type - no length */ 2100 2101 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n", 2102 Subtable->Type); 2103 return; 2104 } 2105 2106 AcpiOsPrintf ("\n"); 2107 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2108 SubtableLength, InfoTable); 2109 if (ACPI_FAILURE (Status)) 2110 { 2111 return; 2112 } 2113 2114 /* Point to end of current subtable (each subtable above is of fixed length) */ 2115 2116 Offset += SubtableLength; 2117 2118 /* If there are any (fixed-length) Error Banks from above, dump them now */ 2119 2120 if (BankCount) 2121 { 2122 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, Subtable, 2123 SubtableLength); 2124 SubtableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 2125 2126 while (BankCount) 2127 { 2128 AcpiOsPrintf ("\n"); 2129 Status = AcpiDmDumpTable (Length, Offset, BankTable, 2130 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 2131 if (ACPI_FAILURE (Status)) 2132 { 2133 return; 2134 } 2135 2136 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 2137 BankTable++; 2138 BankCount--; 2139 } 2140 } 2141 2142 /* Point to next subtable */ 2143 2144 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Subtable, SubtableLength); 2145 } 2146 } 2147 2148 2149 /******************************************************************************* 2150 * 2151 * FUNCTION: AcpiDmDumpHmat 2152 * 2153 * PARAMETERS: Table - A HMAT table 2154 * 2155 * RETURN: None 2156 * 2157 * DESCRIPTION: Format the contents of a HMAT. 2158 * 2159 ******************************************************************************/ 2160 2161 void 2162 AcpiDmDumpHmat ( 2163 ACPI_TABLE_HEADER *Table) 2164 { 2165 ACPI_STATUS Status; 2166 ACPI_HMAT_STRUCTURE *HmatStruct; 2167 ACPI_HMAT_LOCALITY *HmatLocality; 2168 ACPI_HMAT_CACHE *HmatCache; 2169 UINT32 Offset; 2170 UINT32 SubtableOffset; 2171 UINT32 Length; 2172 ACPI_DMTABLE_INFO *InfoTable; 2173 UINT32 i, j; 2174 2175 2176 /* Main table */ 2177 2178 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat); 2179 if (ACPI_FAILURE (Status)) 2180 { 2181 return; 2182 } 2183 Offset = sizeof (ACPI_TABLE_HMAT); 2184 2185 while (Offset < Table->Length) 2186 { 2187 AcpiOsPrintf ("\n"); 2188 2189 /* Dump HMAT structure header */ 2190 2191 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset); 2192 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE)) 2193 { 2194 AcpiOsPrintf ("Invalid HMAT structure length\n"); 2195 return; 2196 } 2197 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 2198 HmatStruct->Length, AcpiDmTableInfoHmatHdr); 2199 if (ACPI_FAILURE (Status)) 2200 { 2201 return; 2202 } 2203 2204 switch (HmatStruct->Type) 2205 { 2206 case ACPI_HMAT_TYPE_ADDRESS_RANGE: 2207 2208 InfoTable = AcpiDmTableInfoHmat0; 2209 Length = sizeof (ACPI_HMAT_PROXIMITY_DOMAIN); 2210 break; 2211 2212 case ACPI_HMAT_TYPE_LOCALITY: 2213 2214 InfoTable = AcpiDmTableInfoHmat1; 2215 Length = sizeof (ACPI_HMAT_LOCALITY); 2216 break; 2217 2218 case ACPI_HMAT_TYPE_CACHE: 2219 2220 InfoTable = AcpiDmTableInfoHmat2; 2221 Length = sizeof (ACPI_HMAT_CACHE); 2222 break; 2223 2224 default: 2225 2226 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n", 2227 HmatStruct->Type); 2228 2229 /* Attempt to continue */ 2230 2231 goto NextSubtable; 2232 } 2233 2234 /* Dump HMAT structure body */ 2235 2236 if (HmatStruct->Length < Length) 2237 { 2238 AcpiOsPrintf ("Invalid HMAT structure length\n"); 2239 return; 2240 } 2241 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 2242 HmatStruct->Length, InfoTable); 2243 if (ACPI_FAILURE (Status)) 2244 { 2245 return; 2246 } 2247 2248 /* Dump HMAT structure additional */ 2249 2250 switch (HmatStruct->Type) 2251 { 2252 case ACPI_HMAT_TYPE_LOCALITY: 2253 2254 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct); 2255 SubtableOffset = sizeof (ACPI_HMAT_LOCALITY); 2256 2257 /* Dump initiator proximity domains */ 2258 2259 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2260 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4)) 2261 { 2262 AcpiOsPrintf ("Invalid initiator proximity domain number\n"); 2263 return; 2264 } 2265 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 2266 { 2267 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2268 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2269 4, AcpiDmTableInfoHmat1a); 2270 if (ACPI_FAILURE (Status)) 2271 { 2272 return; 2273 } 2274 2275 SubtableOffset += 4; 2276 } 2277 2278 /* Dump target proximity domains */ 2279 2280 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2281 (UINT32)(HmatLocality->NumberOfTargetPDs * 4)) 2282 { 2283 AcpiOsPrintf ("Invalid target proximity domain number\n"); 2284 return; 2285 } 2286 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++) 2287 { 2288 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2289 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2290 4, AcpiDmTableInfoHmat1b); 2291 if (ACPI_FAILURE (Status)) 2292 { 2293 return; 2294 } 2295 2296 SubtableOffset += 4; 2297 } 2298 2299 /* Dump latency/bandwidth entris */ 2300 2301 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2302 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 2303 HmatLocality->NumberOfTargetPDs * 2)) 2304 { 2305 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n"); 2306 return; 2307 } 2308 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 2309 { 2310 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++) 2311 { 2312 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2313 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2314 2, AcpiDmTableInfoHmat1c); 2315 if (ACPI_FAILURE(Status)) 2316 { 2317 return; 2318 } 2319 2320 SubtableOffset += 2; 2321 } 2322 } 2323 break; 2324 2325 case ACPI_HMAT_TYPE_CACHE: 2326 2327 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct); 2328 SubtableOffset = sizeof (ACPI_HMAT_CACHE); 2329 2330 /* Dump SMBIOS handles */ 2331 2332 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2333 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2)) 2334 { 2335 AcpiOsPrintf ("Invalid SMBIOS handle number\n"); 2336 return; 2337 } 2338 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++) 2339 { 2340 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2341 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2342 2, AcpiDmTableInfoHmat2a); 2343 if (ACPI_FAILURE (Status)) 2344 { 2345 return; 2346 } 2347 2348 SubtableOffset += 2; 2349 } 2350 break; 2351 2352 default: 2353 2354 break; 2355 } 2356 2357 NextSubtable: 2358 /* Point to next HMAT structure subtable */ 2359 2360 Offset += (HmatStruct->Length); 2361 } 2362 } 2363
Indexes created Tue Sep 30 07:10:03 GMT 2025