1 /****************************************************************************** 2 * 3 * Module Name: dmtbdump1 - Dump ACPI data tables that contain no AML code 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2026, 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: AcpiDmDumpDtpr 1568 * 1569 * PARAMETERS: Table - A DTPR table 1570 * 1571 * RETURN: None 1572 * 1573 * DESCRIPTION: Format the contents of a DTPR. 1574 * 1575 ******************************************************************************/ 1576 1577 void 1578 AcpiDmDumpDtpr ( 1579 ACPI_TABLE_HEADER *Table) 1580 { 1581 ACPI_STATUS Status; 1582 ACPI_TPR_ARRAY *TprArr; 1583 ACPI_TPR_INSTANCE *TprInstance; 1584 ACPI_TPR_AUX_SR *TprAuxSr; 1585 ACPI_TPR_SERIALIZE_REQUEST *TprSerializeRequest; 1586 UINT32 i = 0, j, InsCnt, TprRefCnt; 1587 UINT32 Offset = sizeof(ACPI_TABLE_DTPR); 1588 1589 /* Main table */ 1590 1591 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoDtpr); 1592 if (ACPI_FAILURE (Status)) 1593 { 1594 return; 1595 } 1596 1597 /* Subtables */ 1598 1599 while (Offset < Table->Length) 1600 { 1601 InsCnt = ((ACPI_TABLE_DTPR*) Table)->InsCnt; 1602 1603 for (i = 0; i < InsCnt; i++) 1604 { 1605 TprInstance = ACPI_ADD_PTR(ACPI_TPR_INSTANCE, Table, Offset); 1606 Status = AcpiDmDumpTable(Table->Length, Offset, TprInstance, 1607 sizeof(ACPI_TPR_INSTANCE), AcpiDmTableInfoDtprInstance); 1608 if (ACPI_FAILURE (Status)) 1609 { 1610 return; 1611 } 1612 1613 /* Each of the TPR instances must have the same number of TPRs*/ 1614 TprRefCnt = TprInstance->TprCnt; 1615 1616 Offset += sizeof(ACPI_TPR_INSTANCE); 1617 1618 if (TprInstance->TprCnt < 2) 1619 { 1620 AcpiOsPrintf("TPR Instance No.%d has invalid number of TPRs.\n" 1621 "There should be at least 2 of them, but there is %d.", 1622 i, TprInstance->TprCnt); 1623 return; 1624 } 1625 else 1626 { 1627 if (TprInstance->TprCnt != TprRefCnt) 1628 { 1629 AcpiOsPrintf("Each of TPR instances should have equal\n" 1630 "number of TPRs. TprInstance No.%d has %d TPRs" 1631 ", while the reference TPR instance has %d.\n", 1632 i, TprInstance->TprCnt, TprRefCnt); 1633 return; 1634 } 1635 } 1636 1637 for (j = 0; j < TprInstance->TprCnt; j++) 1638 { 1639 TprArr = ACPI_ADD_PTR(ACPI_TPR_ARRAY, Table, Offset); 1640 Status = AcpiDmDumpTable(Table->Length, Offset, TprArr, 1641 sizeof(ACPI_TPR_ARRAY), AcpiDmTableInfoDtprArr); 1642 if (ACPI_FAILURE (Status)) 1643 { 1644 return; 1645 } 1646 1647 Offset += sizeof(ACPI_TPR_ARRAY); 1648 } 1649 } 1650 1651 TprAuxSr = ACPI_ADD_PTR(ACPI_TPR_AUX_SR, Table, Offset); 1652 Status = AcpiDmDumpTable(Table->Length, Offset, TprAuxSr, 1653 sizeof(ACPI_TPR_AUX_SR), AcpiDmTableInfoDtprSerializeReq0); 1654 1655 Offset += sizeof(ACPI_TPR_AUX_SR); 1656 1657 for (i = 0; i < TprAuxSr->SrlCnt; i++) 1658 { 1659 TprSerializeRequest = ACPI_ADD_PTR(ACPI_TPR_SERIALIZE_REQUEST, 1660 Table, Offset); 1661 Status = AcpiDmDumpTable(Table->Length, Offset, TprSerializeRequest, 1662 sizeof(ACPI_TPR_SERIALIZE_REQUEST), AcpiDmTableInfoDtprSerializeReq1); 1663 if (ACPI_FAILURE (Status)) 1664 { 1665 return; 1666 } 1667 1668 Offset += sizeof(ACPI_TPR_SERIALIZE_REQUEST); 1669 } 1670 } 1671 } 1672 1673 1674 /******************************************************************************* 1675 * 1676 * FUNCTION: AcpiDmDumpEinj 1677 * 1678 * PARAMETERS: Table - A EINJ table 1679 * 1680 * RETURN: None 1681 * 1682 * DESCRIPTION: Format the contents of a EINJ. This table type consists 1683 * of an open-ended number of subtables. 1684 * 1685 ******************************************************************************/ 1686 1687 void 1688 AcpiDmDumpEinj ( 1689 ACPI_TABLE_HEADER *Table) 1690 { 1691 ACPI_STATUS Status; 1692 ACPI_WHEA_HEADER *Subtable; 1693 UINT32 Length = Table->Length; 1694 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 1695 1696 1697 /* Main table */ 1698 1699 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 1700 if (ACPI_FAILURE (Status)) 1701 { 1702 return; 1703 } 1704 1705 /* Subtables */ 1706 1707 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1708 while (Offset < Table->Length) 1709 { 1710 AcpiOsPrintf ("\n"); 1711 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1712 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 1713 if (ACPI_FAILURE (Status)) 1714 { 1715 return; 1716 } 1717 1718 /* Point to next subtable (each subtable is of fixed length) */ 1719 1720 Offset += sizeof (ACPI_WHEA_HEADER); 1721 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable, 1722 sizeof (ACPI_WHEA_HEADER)); 1723 } 1724 } 1725 1726 1727 /******************************************************************************* 1728 * 1729 * FUNCTION: AcpiDmDumpErdt 1730 * 1731 * PARAMETERS: Table - A ERDT table 1732 * 1733 * RETURN: None 1734 * 1735 * DESCRIPTION: Format the contents of a ERDT. This table type consists 1736 * of an open-ended number of subtables. 1737 * 1738 ******************************************************************************/ 1739 1740 void 1741 AcpiDmDumpErdt ( 1742 ACPI_TABLE_HEADER *Table) 1743 { 1744 ACPI_STATUS Status; 1745 ACPI_SUBTBL_HDR_16 *Subtable, *Subsubtable; 1746 ACPI_ERDT_DACD_PATHS *ScopeTable; 1747 UINT32 Offset = sizeof (ACPI_TABLE_ERDT); 1748 UINT32 Suboffset; 1749 UINT32 ScopeOffset; 1750 UINT32 SubsubtableLength = 0; 1751 ACPI_DMTABLE_INFO *InfoTable, *TrailEntries, *DacdEntries; 1752 UINT32 NumTrailers = 0; 1753 1754 /* Main table */ 1755 1756 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoErdt); 1757 if (ACPI_FAILURE (Status)) 1758 { 1759 return; 1760 } 1761 1762 /* Subtables */ 1763 Subtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Table, Offset); 1764 while (Offset < Table->Length) 1765 { 1766 1767 /* Dump common header */ 1768 1769 AcpiOsPrintf ("\n"); 1770 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1771 Subtable->Length, AcpiDmTableInfoErdtHdr); 1772 if (ACPI_FAILURE (Status)) 1773 { 1774 return; 1775 } 1776 1777 AcpiOsPrintf ("\n"); 1778 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 1779 Subtable->Length, AcpiDmTableInfoErdtRmdd); 1780 if (ACPI_FAILURE (Status)) 1781 { 1782 return; 1783 } 1784 1785 /* Subtables of this RMDD table */ 1786 1787 Suboffset = Offset + sizeof(ACPI_ERDT_RMDD); 1788 Subsubtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Table, Suboffset); 1789 while (Suboffset < Offset + Subtable->Length) 1790 { 1791 AcpiOsPrintf ("\n"); 1792 1793 TrailEntries = NULL; 1794 DacdEntries = NULL; 1795 switch (Subsubtable->Type) 1796 { 1797 case ACPI_ERDT_TYPE_CACD: 1798 InfoTable = AcpiDmTableInfoErdtCacd; 1799 TrailEntries = AcpiDmTableInfoErdtCacdX2apic; 1800 SubsubtableLength = sizeof(ACPI_ERDT_CACD); 1801 break; 1802 1803 case ACPI_ERDT_TYPE_DACD: 1804 InfoTable = AcpiDmTableInfoErdtDacd; 1805 DacdEntries = AcpiDmTableInfoErdtDacdScope; 1806 SubsubtableLength = sizeof(ACPI_ERDT_DACD); 1807 break; 1808 1809 case ACPI_ERDT_TYPE_CMRC: 1810 InfoTable = AcpiDmTableInfoErdtCmrc; 1811 break; 1812 1813 case ACPI_ERDT_TYPE_MMRC: 1814 InfoTable = AcpiDmTableInfoErdtMmrc; 1815 TrailEntries = AcpiDmTableInfoErdtMmrcCorrFactor; 1816 SubsubtableLength = sizeof(ACPI_ERDT_MMRC); 1817 break; 1818 1819 case ACPI_ERDT_TYPE_MARC: 1820 InfoTable = AcpiDmTableInfoErdtMarc; 1821 break; 1822 1823 case ACPI_ERDT_TYPE_CARC: 1824 InfoTable = AcpiDmTableInfoErdtCarc; 1825 break; 1826 1827 case ACPI_ERDT_TYPE_CMRD: 1828 InfoTable = AcpiDmTableInfoErdtCmrd; 1829 break; 1830 1831 case ACPI_ERDT_TYPE_IBRD: 1832 InfoTable = AcpiDmTableInfoErdtIbrd; 1833 TrailEntries = AcpiDmTableInfoErdtIbrdCorrFactor; 1834 SubsubtableLength = sizeof(ACPI_ERDT_IBRD); 1835 break; 1836 1837 case ACPI_ERDT_TYPE_IBAD: 1838 InfoTable = AcpiDmTableInfoErdtIbad; 1839 break; 1840 1841 case ACPI_ERDT_TYPE_CARD: 1842 InfoTable = AcpiDmTableInfoErdtCard; 1843 break; 1844 1845 default: 1846 AcpiOsPrintf ("\n**** Unknown RMDD subtable type 0x%X\n", 1847 Subsubtable->Type); 1848 1849 /* Attempt to continue */ 1850 1851 if (!Subsubtable->Length) 1852 { 1853 AcpiOsPrintf ("Invalid zero length subtable\n"); 1854 return; 1855 } 1856 goto NextSubsubtable; 1857 } 1858 1859 /* Dump subtable header */ 1860 1861 Status = AcpiDmDumpTable (Table->Length, Suboffset, Subsubtable, 1862 Subsubtable->Length, AcpiDmTableInfoErdtHdr); 1863 if (ACPI_FAILURE (Status)) 1864 { 1865 return; 1866 } 1867 1868 /* Dump subtable body */ 1869 1870 Status = AcpiDmDumpTable (Table->Length, Suboffset, Subsubtable, 1871 Subsubtable->Length, InfoTable); 1872 if (ACPI_FAILURE (Status)) 1873 { 1874 return; 1875 } 1876 1877 /* CACD, MMRC, and IBRD subtables have simple flex array at end */ 1878 1879 if (TrailEntries) 1880 { 1881 NumTrailers = 0; 1882 while (NumTrailers < Subsubtable->Length - SubsubtableLength) 1883 { 1884 1885 /* Dump one flex array element */ 1886 1887 Status = AcpiDmDumpTable (Table->Length, Suboffset + 1888 SubsubtableLength + NumTrailers, 1889 ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Subsubtable, 1890 SubsubtableLength + NumTrailers), 1891 sizeof(UINT32), TrailEntries); 1892 if (ACPI_FAILURE (Status)) 1893 { 1894 return; 1895 } 1896 NumTrailers += sizeof(UINT32); 1897 } 1898 } 1899 1900 /* DACD subtable has flex array of device agent structures */ 1901 1902 if (DacdEntries) { 1903 ScopeOffset = Suboffset + SubsubtableLength; 1904 ScopeTable = ACPI_ADD_PTR (ACPI_ERDT_DACD_PATHS, 1905 Subsubtable, SubsubtableLength); 1906 while (ScopeOffset < Suboffset + Subsubtable->Length) 1907 { 1908 /* Dump one device agent structure */ 1909 1910 AcpiOsPrintf ("\n"); 1911 Status = AcpiDmDumpTable (Table->Length, ScopeOffset, 1912 ScopeTable, ScopeTable->Header.Length, DacdEntries); 1913 if (ACPI_FAILURE (Status)) 1914 { 1915 return; 1916 } 1917 1918 /* Flex array of UINT8 for device path */ 1919 1920 NumTrailers = 0; 1921 while (NumTrailers < ScopeTable->Header.Length - sizeof(ACPI_ERDT_DACD_PATHS)) 1922 { 1923 /* Dump one UINT8 of the device path */ 1924 1925 Status = AcpiDmDumpTable (Table->Length, ScopeOffset + 1926 sizeof(ACPI_ERDT_DACD_PATHS) + NumTrailers, 1927 ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, ScopeTable, 1928 sizeof(*ScopeTable) + NumTrailers), 1929 sizeof(UINT32), AcpiDmTableInfoErdtDacdPath); 1930 if (ACPI_FAILURE (Status)) 1931 { 1932 return; 1933 } 1934 NumTrailers++; 1935 } 1936 1937 ScopeOffset += ScopeTable->Header.Length; 1938 ScopeTable = ACPI_ADD_PTR (ACPI_ERDT_DACD_PATHS, 1939 ScopeTable, ScopeTable->Header.Length); 1940 } 1941 } 1942 NextSubsubtable: 1943 Suboffset += Subsubtable->Length; 1944 Subsubtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Table, Suboffset); 1945 } 1946 1947 Offset += Subtable->Length; 1948 Subtable = ACPI_ADD_PTR (ACPI_SUBTBL_HDR_16, Subtable, 1949 Subtable->Length); 1950 } 1951 } 1952 1953 1954 /******************************************************************************* 1955 * 1956 * FUNCTION: AcpiDmDumpErst 1957 * 1958 * PARAMETERS: Table - A ERST table 1959 * 1960 * RETURN: None 1961 * 1962 * DESCRIPTION: Format the contents of a ERST. This table type consists 1963 * of an open-ended number of subtables. 1964 * 1965 ******************************************************************************/ 1966 1967 void 1968 AcpiDmDumpErst ( 1969 ACPI_TABLE_HEADER *Table) 1970 { 1971 ACPI_STATUS Status; 1972 ACPI_WHEA_HEADER *Subtable; 1973 UINT32 Length = Table->Length; 1974 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 1975 1976 1977 /* Main table */ 1978 1979 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 1980 if (ACPI_FAILURE (Status)) 1981 { 1982 return; 1983 } 1984 1985 /* Subtables */ 1986 1987 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1988 while (Offset < Table->Length) 1989 { 1990 AcpiOsPrintf ("\n"); 1991 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1992 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0); 1993 if (ACPI_FAILURE (Status)) 1994 { 1995 return; 1996 } 1997 1998 /* Point to next subtable (each subtable is of fixed length) */ 1999 2000 Offset += sizeof (ACPI_WHEA_HEADER); 2001 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable, 2002 sizeof (ACPI_WHEA_HEADER)); 2003 } 2004 } 2005 2006 2007 /******************************************************************************* 2008 * 2009 * FUNCTION: AcpiDmDumpFpdt 2010 * 2011 * PARAMETERS: Table - A FPDT table 2012 * 2013 * RETURN: None 2014 * 2015 * DESCRIPTION: Format the contents of a FPDT. This table type consists 2016 * of an open-ended number of subtables. 2017 * 2018 ******************************************************************************/ 2019 2020 void 2021 AcpiDmDumpFpdt ( 2022 ACPI_TABLE_HEADER *Table) 2023 { 2024 ACPI_STATUS Status; 2025 ACPI_FPDT_HEADER *Subtable; 2026 UINT32 Length = Table->Length; 2027 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 2028 ACPI_DMTABLE_INFO *InfoTable; 2029 2030 2031 /* There is no main table (other than the standard ACPI header) */ 2032 2033 /* Subtables */ 2034 2035 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); 2036 while (Offset < Table->Length) 2037 { 2038 /* Common subtable header */ 2039 2040 AcpiOsPrintf ("\n"); 2041 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2042 Subtable->Length, AcpiDmTableInfoFpdtHdr); 2043 if (ACPI_FAILURE (Status)) 2044 { 2045 return; 2046 } 2047 2048 switch (Subtable->Type) 2049 { 2050 case ACPI_FPDT_TYPE_BOOT: 2051 2052 InfoTable = AcpiDmTableInfoFpdt0; 2053 break; 2054 2055 case ACPI_FPDT_TYPE_S3PERF: 2056 2057 InfoTable = AcpiDmTableInfoFpdt1; 2058 break; 2059 2060 default: 2061 2062 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", 2063 Subtable->Type); 2064 2065 /* Attempt to continue */ 2066 2067 if (!Subtable->Length) 2068 { 2069 AcpiOsPrintf ("Invalid zero length subtable\n"); 2070 return; 2071 } 2072 goto NextSubtable; 2073 } 2074 2075 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2076 Subtable->Length, InfoTable); 2077 if (ACPI_FAILURE (Status)) 2078 { 2079 return; 2080 } 2081 2082 NextSubtable: 2083 /* Point to next subtable */ 2084 2085 Offset += Subtable->Length; 2086 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, 2087 Subtable->Length); 2088 } 2089 } 2090 2091 2092 /******************************************************************************* 2093 * 2094 * FUNCTION: AcpiDmDumpGtdt 2095 * 2096 * PARAMETERS: Table - A GTDT table 2097 * 2098 * RETURN: None 2099 * 2100 * DESCRIPTION: Format the contents of a GTDT. This table type consists 2101 * of an open-ended number of subtables. 2102 * 2103 ******************************************************************************/ 2104 2105 void 2106 AcpiDmDumpGtdt ( 2107 ACPI_TABLE_HEADER *Table) 2108 { 2109 ACPI_STATUS Status; 2110 ACPI_GTDT_HEADER *Subtable; 2111 UINT32 Length = Table->Length; 2112 UINT32 Offset = sizeof (ACPI_TABLE_GTDT); 2113 ACPI_DMTABLE_INFO *InfoTable; 2114 UINT32 SubtableLength; 2115 UINT32 GtCount; 2116 ACPI_GTDT_TIMER_ENTRY *GtxTable; 2117 2118 2119 /* Main table */ 2120 2121 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt); 2122 if (ACPI_FAILURE (Status)) 2123 { 2124 return; 2125 } 2126 2127 /* Rev 3 fields */ 2128 2129 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 2130 2131 if (Table->Revision > 2) 2132 { 2133 SubtableLength = sizeof (ACPI_GTDT_EL2); 2134 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2135 SubtableLength, AcpiDmTableInfoGtdtEl2); 2136 if (ACPI_FAILURE (Status)) 2137 { 2138 return; 2139 } 2140 Offset += SubtableLength; 2141 } 2142 2143 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 2144 2145 /* Subtables */ 2146 2147 while (Offset < Table->Length) 2148 { 2149 /* Common subtable header */ 2150 2151 AcpiOsPrintf ("\n"); 2152 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2153 Subtable->Length, AcpiDmTableInfoGtdtHdr); 2154 if (ACPI_FAILURE (Status)) 2155 { 2156 return; 2157 } 2158 2159 GtCount = 0; 2160 switch (Subtable->Type) 2161 { 2162 case ACPI_GTDT_TYPE_TIMER_BLOCK: 2163 2164 SubtableLength = sizeof (ACPI_GTDT_TIMER_BLOCK); 2165 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, 2166 Subtable))->TimerCount; 2167 2168 InfoTable = AcpiDmTableInfoGtdt0; 2169 break; 2170 2171 case ACPI_GTDT_TYPE_WATCHDOG: 2172 2173 SubtableLength = sizeof (ACPI_GTDT_WATCHDOG); 2174 2175 InfoTable = AcpiDmTableInfoGtdt1; 2176 break; 2177 2178 default: 2179 2180 /* Cannot continue on unknown type - no length */ 2181 2182 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n", 2183 Subtable->Type); 2184 return; 2185 } 2186 2187 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2188 Subtable->Length, InfoTable); 2189 if (ACPI_FAILURE (Status)) 2190 { 2191 return; 2192 } 2193 2194 /* Point to end of current subtable (each subtable above is of fixed length) */ 2195 2196 Offset += SubtableLength; 2197 2198 /* If there are any Gt Timer Blocks from above, dump them now */ 2199 2200 if (GtCount) 2201 { 2202 GtxTable = ACPI_ADD_PTR ( 2203 ACPI_GTDT_TIMER_ENTRY, Subtable, SubtableLength); 2204 SubtableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY); 2205 2206 while (GtCount) 2207 { 2208 AcpiOsPrintf ("\n"); 2209 Status = AcpiDmDumpTable (Length, Offset, GtxTable, 2210 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a); 2211 if (ACPI_FAILURE (Status)) 2212 { 2213 return; 2214 } 2215 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY); 2216 GtxTable++; 2217 GtCount--; 2218 } 2219 } 2220 2221 /* Point to next subtable */ 2222 2223 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Subtable, SubtableLength); 2224 } 2225 } 2226 2227 2228 /******************************************************************************* 2229 * 2230 * FUNCTION: AcpiDmDumpHest 2231 * 2232 * PARAMETERS: Table - A HEST table 2233 * 2234 * RETURN: None 2235 * 2236 * DESCRIPTION: Format the contents of a HEST. This table type consists 2237 * of an open-ended number of subtables. 2238 * 2239 ******************************************************************************/ 2240 2241 void 2242 AcpiDmDumpHest ( 2243 ACPI_TABLE_HEADER *Table) 2244 { 2245 ACPI_STATUS Status; 2246 ACPI_HEST_HEADER *Subtable; 2247 UINT32 Length = Table->Length; 2248 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 2249 ACPI_DMTABLE_INFO *InfoTable; 2250 UINT32 SubtableLength; 2251 UINT32 BankCount; 2252 ACPI_HEST_IA_ERROR_BANK *BankTable; 2253 2254 2255 /* Main table */ 2256 2257 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 2258 if (ACPI_FAILURE (Status)) 2259 { 2260 return; 2261 } 2262 2263 /* Subtables */ 2264 2265 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 2266 while (Offset < Table->Length) 2267 { 2268 BankCount = 0; 2269 switch (Subtable->Type) 2270 { 2271 case ACPI_HEST_TYPE_IA32_CHECK: 2272 2273 InfoTable = AcpiDmTableInfoHest0; 2274 SubtableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK); 2275 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 2276 Subtable))->NumHardwareBanks; 2277 break; 2278 2279 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 2280 2281 InfoTable = AcpiDmTableInfoHest1; 2282 SubtableLength = sizeof (ACPI_HEST_IA_CORRECTED); 2283 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 2284 Subtable))->NumHardwareBanks; 2285 break; 2286 2287 case ACPI_HEST_TYPE_IA32_NMI: 2288 2289 InfoTable = AcpiDmTableInfoHest2; 2290 SubtableLength = sizeof (ACPI_HEST_IA_NMI); 2291 break; 2292 2293 case ACPI_HEST_TYPE_AER_ROOT_PORT: 2294 2295 InfoTable = AcpiDmTableInfoHest6; 2296 SubtableLength = sizeof (ACPI_HEST_AER_ROOT); 2297 break; 2298 2299 case ACPI_HEST_TYPE_AER_ENDPOINT: 2300 2301 InfoTable = AcpiDmTableInfoHest7; 2302 SubtableLength = sizeof (ACPI_HEST_AER); 2303 break; 2304 2305 case ACPI_HEST_TYPE_AER_BRIDGE: 2306 2307 InfoTable = AcpiDmTableInfoHest8; 2308 SubtableLength = sizeof (ACPI_HEST_AER_BRIDGE); 2309 break; 2310 2311 case ACPI_HEST_TYPE_GENERIC_ERROR: 2312 2313 InfoTable = AcpiDmTableInfoHest9; 2314 SubtableLength = sizeof (ACPI_HEST_GENERIC); 2315 break; 2316 2317 case ACPI_HEST_TYPE_GENERIC_ERROR_V2: 2318 2319 InfoTable = AcpiDmTableInfoHest10; 2320 SubtableLength = sizeof (ACPI_HEST_GENERIC_V2); 2321 break; 2322 2323 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK: 2324 2325 InfoTable = AcpiDmTableInfoHest11; 2326 SubtableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK); 2327 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK, 2328 Subtable))->NumHardwareBanks; 2329 break; 2330 2331 default: 2332 2333 /* Cannot continue on unknown type - no length */ 2334 2335 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n", 2336 Subtable->Type); 2337 return; 2338 } 2339 2340 AcpiOsPrintf ("\n"); 2341 Status = AcpiDmDumpTable (Length, Offset, Subtable, 2342 SubtableLength, InfoTable); 2343 if (ACPI_FAILURE (Status)) 2344 { 2345 return; 2346 } 2347 2348 /* Point to end of current subtable (each subtable above is of fixed length) */ 2349 2350 Offset += SubtableLength; 2351 2352 /* If there are any (fixed-length) Error Banks from above, dump them now */ 2353 2354 if (BankCount) 2355 { 2356 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, Subtable, 2357 SubtableLength); 2358 SubtableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 2359 2360 while (BankCount) 2361 { 2362 AcpiOsPrintf ("\n"); 2363 Status = AcpiDmDumpTable (Length, Offset, BankTable, 2364 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 2365 if (ACPI_FAILURE (Status)) 2366 { 2367 return; 2368 } 2369 2370 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 2371 BankTable++; 2372 BankCount--; 2373 } 2374 } 2375 2376 /* Point to next subtable */ 2377 2378 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Subtable, SubtableLength); 2379 } 2380 } 2381 2382 2383 /******************************************************************************* 2384 * 2385 * FUNCTION: AcpiDmDumpHmat 2386 * 2387 * PARAMETERS: Table - A HMAT table 2388 * 2389 * RETURN: None 2390 * 2391 * DESCRIPTION: Format the contents of a HMAT. 2392 * 2393 ******************************************************************************/ 2394 2395 void 2396 AcpiDmDumpHmat ( 2397 ACPI_TABLE_HEADER *Table) 2398 { 2399 ACPI_STATUS Status; 2400 ACPI_HMAT_STRUCTURE *HmatStruct; 2401 ACPI_HMAT_LOCALITY *HmatLocality; 2402 ACPI_HMAT_CACHE *HmatCache; 2403 UINT32 Offset; 2404 UINT32 SubtableOffset; 2405 UINT32 Length; 2406 ACPI_DMTABLE_INFO *InfoTable; 2407 UINT32 i, j; 2408 2409 2410 /* Main table */ 2411 2412 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat); 2413 if (ACPI_FAILURE (Status)) 2414 { 2415 return; 2416 } 2417 Offset = sizeof (ACPI_TABLE_HMAT); 2418 2419 while (Offset < Table->Length) 2420 { 2421 AcpiOsPrintf ("\n"); 2422 2423 /* Dump HMAT structure header */ 2424 2425 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset); 2426 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE)) 2427 { 2428 AcpiOsPrintf ("Invalid HMAT structure length\n"); 2429 return; 2430 } 2431 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 2432 HmatStruct->Length, AcpiDmTableInfoHmatHdr); 2433 if (ACPI_FAILURE (Status)) 2434 { 2435 return; 2436 } 2437 2438 switch (HmatStruct->Type) 2439 { 2440 case ACPI_HMAT_TYPE_ADDRESS_RANGE: 2441 2442 InfoTable = AcpiDmTableInfoHmat0; 2443 Length = sizeof (ACPI_HMAT_PROXIMITY_DOMAIN); 2444 break; 2445 2446 case ACPI_HMAT_TYPE_LOCALITY: 2447 2448 InfoTable = AcpiDmTableInfoHmat1; 2449 Length = sizeof (ACPI_HMAT_LOCALITY); 2450 break; 2451 2452 case ACPI_HMAT_TYPE_CACHE: 2453 2454 InfoTable = AcpiDmTableInfoHmat2; 2455 Length = sizeof (ACPI_HMAT_CACHE); 2456 break; 2457 2458 default: 2459 2460 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n", 2461 HmatStruct->Type); 2462 2463 /* Attempt to continue */ 2464 2465 goto NextSubtable; 2466 } 2467 2468 /* Dump HMAT structure body */ 2469 2470 if (HmatStruct->Length < Length) 2471 { 2472 AcpiOsPrintf ("Invalid HMAT structure length\n"); 2473 return; 2474 } 2475 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 2476 HmatStruct->Length, InfoTable); 2477 if (ACPI_FAILURE (Status)) 2478 { 2479 return; 2480 } 2481 2482 /* Dump HMAT structure additional */ 2483 2484 switch (HmatStruct->Type) 2485 { 2486 case ACPI_HMAT_TYPE_LOCALITY: 2487 2488 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct); 2489 SubtableOffset = sizeof (ACPI_HMAT_LOCALITY); 2490 2491 /* Dump initiator proximity domains */ 2492 2493 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2494 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4)) 2495 { 2496 AcpiOsPrintf ("Invalid initiator proximity domain number\n"); 2497 return; 2498 } 2499 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 2500 { 2501 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2502 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2503 4, AcpiDmTableInfoHmat1a); 2504 if (ACPI_FAILURE (Status)) 2505 { 2506 return; 2507 } 2508 2509 SubtableOffset += 4; 2510 } 2511 2512 /* Dump target proximity domains */ 2513 2514 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2515 (UINT32)(HmatLocality->NumberOfTargetPDs * 4)) 2516 { 2517 AcpiOsPrintf ("Invalid target proximity domain number\n"); 2518 return; 2519 } 2520 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++) 2521 { 2522 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2523 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2524 4, AcpiDmTableInfoHmat1b); 2525 if (ACPI_FAILURE (Status)) 2526 { 2527 return; 2528 } 2529 2530 SubtableOffset += 4; 2531 } 2532 2533 /* Dump latency/bandwidth entris */ 2534 2535 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2536 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 2537 HmatLocality->NumberOfTargetPDs * 2)) 2538 { 2539 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n"); 2540 return; 2541 } 2542 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 2543 { 2544 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++) 2545 { 2546 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2547 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2548 2, AcpiDmTableInfoHmat1c); 2549 if (ACPI_FAILURE(Status)) 2550 { 2551 return; 2552 } 2553 2554 SubtableOffset += 2; 2555 } 2556 } 2557 break; 2558 2559 case ACPI_HMAT_TYPE_CACHE: 2560 2561 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct); 2562 SubtableOffset = sizeof (ACPI_HMAT_CACHE); 2563 2564 /* Dump SMBIOS handles */ 2565 2566 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2567 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2)) 2568 { 2569 AcpiOsPrintf ("Invalid SMBIOS handle number\n"); 2570 return; 2571 } 2572 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++) 2573 { 2574 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2575 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2576 2, AcpiDmTableInfoHmat2a); 2577 if (ACPI_FAILURE (Status)) 2578 { 2579 return; 2580 } 2581 2582 SubtableOffset += 2; 2583 } 2584 break; 2585 2586 default: 2587 2588 break; 2589 } 2590 2591 NextSubtable: 2592 /* Point to next HMAT structure subtable */ 2593 2594 Offset += (HmatStruct->Length); 2595 } 2596 } 2597
Indexes created Tue Jun 23 00:25:03 UTC 2026