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