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