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