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