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