1 /****************************************************************************** 2 * 3 * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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 MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include "acpi.h" 45 #include "accommon.h" 46 #include "acdisasm.h" 47 #include "actables.h" 48 49 /* This module used for application-level code only */ 50 51 #define _COMPONENT ACPI_CA_DISASSEMBLER 52 ACPI_MODULE_NAME ("dmtbdump") 53 54 55 /* Local prototypes */ 56 57 static void 58 AcpiDmValidateFadtLength ( 59 UINT32 Revision, 60 UINT32 Length); 61 62 static void 63 AcpiDmDumpBuffer ( 64 void *Table, 65 UINT32 BufferOffset, 66 UINT32 Length, 67 UINT32 AbsoluteOffset, 68 char *Header); 69 70 71 /******************************************************************************* 72 * 73 * FUNCTION: AcpiDmDumpBuffer 74 * 75 * PARAMETERS: Table - ACPI Table or subtable 76 * BufferOffset - Offset of buffer from Table above 77 * Length - Length of the buffer 78 * AbsoluteOffset - Offset of buffer in the main ACPI table 79 * Header - Name of the buffer field (printed on the 80 * first line only.) 81 * 82 * RETURN: None 83 * 84 * DESCRIPTION: Format the contents of an arbitrary length data buffer (in the 85 * disassembler output format.) 86 * 87 ******************************************************************************/ 88 89 static void 90 AcpiDmDumpBuffer ( 91 void *Table, 92 UINT32 BufferOffset, 93 UINT32 Length, 94 UINT32 AbsoluteOffset, 95 char *Header) 96 { 97 UINT8 *Buffer; 98 UINT32 i; 99 100 101 if (!Length) 102 { 103 return; 104 } 105 106 Buffer = ACPI_CAST_PTR (UINT8, Table) + BufferOffset; 107 i = 0; 108 109 while (i < Length) 110 { 111 if (!(i % 16)) 112 { 113 AcpiOsPrintf ("\n"); 114 AcpiDmLineHeader (AbsoluteOffset, 115 ((Length - i) > 16) ? 16 : (Length - i), Header); 116 Header = NULL; 117 } 118 119 AcpiOsPrintf ("%.02X ", *Buffer); 120 i++; 121 Buffer++; 122 AbsoluteOffset++; 123 } 124 125 AcpiOsPrintf ("\n"); 126 } 127 128 129 /******************************************************************************* 130 * 131 * FUNCTION: AcpiDmDumpRsdp 132 * 133 * PARAMETERS: Table - A RSDP 134 * 135 * RETURN: Length of the table (there is not always a length field, 136 * use revision or length if available (ACPI 2.0+)) 137 * 138 * DESCRIPTION: Format the contents of a RSDP 139 * 140 ******************************************************************************/ 141 142 UINT32 143 AcpiDmDumpRsdp ( 144 ACPI_TABLE_HEADER *Table) 145 { 146 ACPI_TABLE_RSDP *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table); 147 UINT32 Length = sizeof (ACPI_RSDP_COMMON); 148 UINT8 Checksum; 149 150 151 /* Dump the common ACPI 1.0 portion */ 152 153 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1); 154 155 /* Validate the first checksum */ 156 157 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON), 158 Rsdp->Checksum); 159 if (Checksum != Rsdp->Checksum) 160 { 161 AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n", 162 Checksum); 163 } 164 165 /* The RSDP for ACPI 2.0+ contains more data and has a Length field */ 166 167 if (Rsdp->Revision > 0) 168 { 169 Length = Rsdp->Length; 170 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2); 171 172 /* Validate the extended checksum over entire RSDP */ 173 174 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP), 175 Rsdp->ExtendedChecksum); 176 if (Checksum != Rsdp->ExtendedChecksum) 177 { 178 AcpiOsPrintf ( 179 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n", 180 Checksum); 181 } 182 } 183 184 return (Length); 185 } 186 187 188 /******************************************************************************* 189 * 190 * FUNCTION: AcpiDmDumpRsdt 191 * 192 * PARAMETERS: Table - A RSDT 193 * 194 * RETURN: None 195 * 196 * DESCRIPTION: Format the contents of a RSDT 197 * 198 ******************************************************************************/ 199 200 void 201 AcpiDmDumpRsdt ( 202 ACPI_TABLE_HEADER *Table) 203 { 204 UINT32 *Array; 205 UINT32 Entries; 206 UINT32 Offset; 207 UINT32 i; 208 209 210 /* Point to start of table pointer array */ 211 212 Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry; 213 Offset = sizeof (ACPI_TABLE_HEADER); 214 215 /* RSDT uses 32-bit pointers */ 216 217 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32); 218 219 for (i = 0; i < Entries; i++) 220 { 221 AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i); 222 AcpiOsPrintf ("%8.8X\n", Array[i]); 223 Offset += sizeof (UINT32); 224 } 225 } 226 227 228 /******************************************************************************* 229 * 230 * FUNCTION: AcpiDmDumpXsdt 231 * 232 * PARAMETERS: Table - A XSDT 233 * 234 * RETURN: None 235 * 236 * DESCRIPTION: Format the contents of a XSDT 237 * 238 ******************************************************************************/ 239 240 void 241 AcpiDmDumpXsdt ( 242 ACPI_TABLE_HEADER *Table) 243 { 244 UINT64 *Array; 245 UINT32 Entries; 246 UINT32 Offset; 247 UINT32 i; 248 249 250 /* Point to start of table pointer array */ 251 252 Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry; 253 Offset = sizeof (ACPI_TABLE_HEADER); 254 255 /* XSDT uses 64-bit pointers */ 256 257 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64); 258 259 for (i = 0; i < Entries; i++) 260 { 261 AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i); 262 AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i])); 263 Offset += sizeof (UINT64); 264 } 265 } 266 267 268 /******************************************************************************* 269 * 270 * FUNCTION: AcpiDmDumpFadt 271 * 272 * PARAMETERS: Table - A FADT 273 * 274 * RETURN: None 275 * 276 * DESCRIPTION: Format the contents of a FADT 277 * 278 * NOTE: We cannot depend on the FADT version to indicate the actual 279 * contents of the FADT because of BIOS bugs. The table length 280 * is the only reliable indicator. 281 * 282 ******************************************************************************/ 283 284 void 285 AcpiDmDumpFadt ( 286 ACPI_TABLE_HEADER *Table) 287 { 288 289 /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */ 290 291 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1); 292 293 /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */ 294 295 if ((Table->Length > ACPI_FADT_V1_SIZE) && 296 (Table->Length <= ACPI_FADT_V2_SIZE)) 297 { 298 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2); 299 } 300 301 /* Check for FADT revision 3/4 fields and up (ACPI 2.0+ extended data) */ 302 303 else if (Table->Length > ACPI_FADT_V2_SIZE) 304 { 305 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3); 306 307 /* Check for FADT revision 5 fields and up (ACPI 5.0+) */ 308 309 if (Table->Length > ACPI_FADT_V3_SIZE) 310 { 311 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt5); 312 } 313 } 314 315 /* Validate various fields in the FADT, including length */ 316 317 AcpiTbCreateLocalFadt (Table, Table->Length); 318 319 /* Validate FADT length against the revision */ 320 321 AcpiDmValidateFadtLength (Table->Revision, Table->Length); 322 } 323 324 325 /******************************************************************************* 326 * 327 * FUNCTION: AcpiDmValidateFadtLength 328 * 329 * PARAMETERS: Revision - FADT revision (Header->Revision) 330 * Length - FADT length (Header->Length 331 * 332 * RETURN: None 333 * 334 * DESCRIPTION: Check the FADT revision against the expected table length for 335 * that revision. Issue a warning if the length is not what was 336 * expected. This seems to be such a common BIOS bug that the 337 * FADT revision has been rendered virtually meaningless. 338 * 339 ******************************************************************************/ 340 341 static void 342 AcpiDmValidateFadtLength ( 343 UINT32 Revision, 344 UINT32 Length) 345 { 346 UINT32 ExpectedLength; 347 348 349 switch (Revision) 350 { 351 case 0: 352 353 AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n"); 354 return; 355 356 case 1: 357 358 ExpectedLength = ACPI_FADT_V1_SIZE; 359 break; 360 361 case 2: 362 363 ExpectedLength = ACPI_FADT_V2_SIZE; 364 break; 365 366 case 3: 367 case 4: 368 369 ExpectedLength = ACPI_FADT_V3_SIZE; 370 break; 371 372 case 5: 373 374 ExpectedLength = ACPI_FADT_V5_SIZE; 375 break; 376 377 default: 378 379 return; 380 } 381 382 if (Length == ExpectedLength) 383 { 384 return; 385 } 386 387 AcpiOsPrintf ( 388 "\n// ACPI Warning: FADT revision %X does not match length: found %X expected %X\n", 389 Revision, Length, ExpectedLength); 390 } 391 392 393 /******************************************************************************* 394 * 395 * FUNCTION: AcpiDmDumpAsf 396 * 397 * PARAMETERS: Table - A ASF table 398 * 399 * RETURN: None 400 * 401 * DESCRIPTION: Format the contents of a ASF table 402 * 403 ******************************************************************************/ 404 405 void 406 AcpiDmDumpAsf ( 407 ACPI_TABLE_HEADER *Table) 408 { 409 ACPI_STATUS Status; 410 UINT32 Offset = sizeof (ACPI_TABLE_HEADER); 411 ACPI_ASF_INFO *SubTable; 412 ACPI_DMTABLE_INFO *InfoTable; 413 ACPI_DMTABLE_INFO *DataInfoTable = NULL; 414 UINT8 *DataTable = NULL; 415 UINT32 DataCount = 0; 416 UINT32 DataLength = 0; 417 UINT32 DataOffset = 0; 418 UINT32 i; 419 UINT8 Type; 420 421 422 /* No main table, only sub-tables */ 423 424 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); 425 while (Offset < Table->Length) 426 { 427 /* Common sub-table header */ 428 429 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 430 SubTable->Header.Length, AcpiDmTableInfoAsfHdr); 431 if (ACPI_FAILURE (Status)) 432 { 433 return; 434 } 435 436 /* The actual type is the lower 7 bits of Type */ 437 438 Type = (UINT8) (SubTable->Header.Type & 0x7F); 439 440 switch (Type) 441 { 442 case ACPI_ASF_TYPE_INFO: 443 444 InfoTable = AcpiDmTableInfoAsf0; 445 break; 446 447 case ACPI_ASF_TYPE_ALERT: 448 449 InfoTable = AcpiDmTableInfoAsf1; 450 DataInfoTable = AcpiDmTableInfoAsf1a; 451 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT)); 452 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts; 453 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength; 454 DataOffset = Offset + sizeof (ACPI_ASF_ALERT); 455 break; 456 457 case ACPI_ASF_TYPE_CONTROL: 458 459 InfoTable = AcpiDmTableInfoAsf2; 460 DataInfoTable = AcpiDmTableInfoAsf2a; 461 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE)); 462 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls; 463 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength; 464 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE); 465 break; 466 467 case ACPI_ASF_TYPE_BOOT: 468 469 InfoTable = AcpiDmTableInfoAsf3; 470 break; 471 472 case ACPI_ASF_TYPE_ADDRESS: 473 474 InfoTable = AcpiDmTableInfoAsf4; 475 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS)); 476 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices; 477 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS); 478 break; 479 480 default: 481 482 AcpiOsPrintf ("\n**** Unknown ASF sub-table type 0x%X\n", SubTable->Header.Type); 483 return; 484 } 485 486 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 487 SubTable->Header.Length, InfoTable); 488 if (ACPI_FAILURE (Status)) 489 { 490 return; 491 } 492 493 /* Dump variable-length extra data */ 494 495 switch (Type) 496 { 497 case ACPI_ASF_TYPE_ALERT: 498 case ACPI_ASF_TYPE_CONTROL: 499 500 for (i = 0; i < DataCount; i++) 501 { 502 AcpiOsPrintf ("\n"); 503 Status = AcpiDmDumpTable (Table->Length, DataOffset, 504 DataTable, DataLength, DataInfoTable); 505 if (ACPI_FAILURE (Status)) 506 { 507 return; 508 } 509 510 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength); 511 DataOffset += DataLength; 512 } 513 break; 514 515 case ACPI_ASF_TYPE_ADDRESS: 516 517 for (i = 0; i < DataLength; i++) 518 { 519 if (!(i % 16)) 520 { 521 AcpiDmLineHeader (DataOffset, 1, "Addresses"); 522 } 523 524 AcpiOsPrintf ("%2.2X ", *DataTable); 525 DataTable++; 526 DataOffset++; 527 if (DataOffset > Table->Length) 528 { 529 AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n"); 530 return; 531 } 532 } 533 534 AcpiOsPrintf ("\n"); 535 break; 536 537 default: 538 539 break; 540 } 541 542 AcpiOsPrintf ("\n"); 543 544 /* Point to next sub-table */ 545 546 if (!SubTable->Header.Length) 547 { 548 AcpiOsPrintf ("Invalid zero subtable header length\n"); 549 return; 550 } 551 552 Offset += SubTable->Header.Length; 553 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length); 554 } 555 } 556 557 558 /******************************************************************************* 559 * 560 * FUNCTION: AcpiDmDumpCpep 561 * 562 * PARAMETERS: Table - A CPEP table 563 * 564 * RETURN: None 565 * 566 * DESCRIPTION: Format the contents of a CPEP. This table type consists 567 * of an open-ended number of subtables. 568 * 569 ******************************************************************************/ 570 571 void 572 AcpiDmDumpCpep ( 573 ACPI_TABLE_HEADER *Table) 574 { 575 ACPI_STATUS Status; 576 ACPI_CPEP_POLLING *SubTable; 577 UINT32 Length = Table->Length; 578 UINT32 Offset = sizeof (ACPI_TABLE_CPEP); 579 580 581 /* Main table */ 582 583 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep); 584 if (ACPI_FAILURE (Status)) 585 { 586 return; 587 } 588 589 /* Sub-tables */ 590 591 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset); 592 while (Offset < Table->Length) 593 { 594 AcpiOsPrintf ("\n"); 595 Status = AcpiDmDumpTable (Length, Offset, SubTable, 596 SubTable->Header.Length, AcpiDmTableInfoCpep0); 597 if (ACPI_FAILURE (Status)) 598 { 599 return; 600 } 601 602 /* Point to next sub-table */ 603 604 Offset += SubTable->Header.Length; 605 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable, 606 SubTable->Header.Length); 607 } 608 } 609 610 611 /******************************************************************************* 612 * 613 * FUNCTION: AcpiDmDumpCsrt 614 * 615 * PARAMETERS: Table - A CSRT table 616 * 617 * RETURN: None 618 * 619 * DESCRIPTION: Format the contents of a CSRT. This table type consists 620 * of an open-ended number of subtables. 621 * 622 ******************************************************************************/ 623 624 void 625 AcpiDmDumpCsrt ( 626 ACPI_TABLE_HEADER *Table) 627 { 628 ACPI_STATUS Status; 629 ACPI_CSRT_GROUP *SubTable; 630 ACPI_CSRT_SHARED_INFO *SharedInfoTable; 631 ACPI_CSRT_DESCRIPTOR *SubSubTable; 632 UINT32 Length = Table->Length; 633 UINT32 Offset = sizeof (ACPI_TABLE_CSRT); 634 UINT32 SubOffset; 635 UINT32 SubSubOffset; 636 UINT32 InfoLength; 637 638 639 /* The main table only contains the ACPI header, thus already handled */ 640 641 /* Sub-tables (Resource Groups) */ 642 643 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset); 644 while (Offset < Table->Length) 645 { 646 /* Resource group subtable */ 647 648 AcpiOsPrintf ("\n"); 649 Status = AcpiDmDumpTable (Length, Offset, SubTable, 650 SubTable->Length, AcpiDmTableInfoCsrt0); 651 if (ACPI_FAILURE (Status)) 652 { 653 return; 654 } 655 656 /* Shared info subtable (One per resource group) */ 657 658 SubOffset = sizeof (ACPI_CSRT_GROUP); 659 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table, 660 Offset + SubOffset); 661 662 AcpiOsPrintf ("\n"); 663 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable, 664 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1); 665 if (ACPI_FAILURE (Status)) 666 { 667 return; 668 } 669 670 SubOffset += SubTable->SharedInfoLength; 671 672 /* Sub-Subtables (Resource Descriptors) */ 673 674 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table, 675 Offset + SubOffset); 676 677 while ((SubOffset < SubTable->Length) && 678 ((Offset + SubOffset) < Table->Length)) 679 { 680 AcpiOsPrintf ("\n"); 681 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable, 682 SubSubTable->Length, AcpiDmTableInfoCsrt2); 683 if (ACPI_FAILURE (Status)) 684 { 685 return; 686 } 687 688 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR); 689 690 /* Resource-specific info buffer */ 691 692 InfoLength = SubSubTable->Length - SubSubOffset; 693 694 AcpiDmDumpBuffer (SubSubTable, SubSubOffset, InfoLength, 695 Offset + SubOffset + SubSubOffset, "ResourceInfo"); 696 SubSubOffset += InfoLength; 697 698 /* Point to next sub-subtable */ 699 700 SubOffset += SubSubTable->Length; 701 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable, 702 SubSubTable->Length); 703 } 704 705 /* Point to next sub-table */ 706 707 Offset += SubTable->Length; 708 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable, 709 SubTable->Length); 710 } 711 } 712 713 714 /******************************************************************************* 715 * 716 * FUNCTION: AcpiDmDumpDbg2 717 * 718 * PARAMETERS: Table - A DBG2 table 719 * 720 * RETURN: None 721 * 722 * DESCRIPTION: Format the contents of a DBG2. This table type consists 723 * of an open-ended number of subtables. 724 * 725 ******************************************************************************/ 726 727 void 728 AcpiDmDumpDbg2 ( 729 ACPI_TABLE_HEADER *Table) 730 { 731 ACPI_STATUS Status; 732 ACPI_DBG2_DEVICE *SubTable; 733 UINT32 Length = Table->Length; 734 UINT32 Offset = sizeof (ACPI_TABLE_DBG2); 735 UINT32 i; 736 UINT32 ArrayOffset; 737 UINT32 AbsoluteOffset; 738 UINT8 *Array; 739 740 741 /* Main table */ 742 743 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2); 744 if (ACPI_FAILURE (Status)) 745 { 746 return; 747 } 748 749 /* Sub-tables */ 750 751 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset); 752 while (Offset < Table->Length) 753 { 754 AcpiOsPrintf ("\n"); 755 Status = AcpiDmDumpTable (Length, Offset, SubTable, 756 SubTable->Length, AcpiDmTableInfoDbg2Device); 757 if (ACPI_FAILURE (Status)) 758 { 759 return; 760 } 761 762 /* Dump the BaseAddress array */ 763 764 for (i = 0; i < SubTable->RegisterCount; i++) 765 { 766 ArrayOffset = SubTable->BaseAddressOffset + 767 (sizeof (ACPI_GENERIC_ADDRESS) * i); 768 AbsoluteOffset = Offset + ArrayOffset; 769 Array = (UINT8 *) SubTable + ArrayOffset; 770 771 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 772 SubTable->Length, AcpiDmTableInfoDbg2Addr); 773 if (ACPI_FAILURE (Status)) 774 { 775 return; 776 } 777 } 778 779 /* Dump the AddressSize array */ 780 781 for (i = 0; i < SubTable->RegisterCount; i++) 782 { 783 ArrayOffset = SubTable->AddressSizeOffset + 784 (sizeof (UINT32) * i); 785 AbsoluteOffset = Offset + ArrayOffset; 786 Array = (UINT8 *) SubTable + ArrayOffset; 787 788 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 789 SubTable->Length, AcpiDmTableInfoDbg2Size); 790 if (ACPI_FAILURE (Status)) 791 { 792 return; 793 } 794 } 795 796 /* Dump the Namestring (required) */ 797 798 AcpiOsPrintf ("\n"); 799 ArrayOffset = SubTable->NamepathOffset; 800 AbsoluteOffset = Offset + ArrayOffset; 801 Array = (UINT8 *) SubTable + ArrayOffset; 802 803 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 804 SubTable->Length, AcpiDmTableInfoDbg2Name); 805 if (ACPI_FAILURE (Status)) 806 { 807 return; 808 } 809 810 /* Dump the OemData (optional) */ 811 812 if (SubTable->OemDataOffset) 813 { 814 AcpiDmDumpBuffer (SubTable, SubTable->OemDataOffset, SubTable->OemDataLength, 815 Offset + SubTable->OemDataOffset, "OEM Data"); 816 } 817 818 /* Point to next sub-table */ 819 820 Offset += SubTable->Length; 821 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable, 822 SubTable->Length); 823 } 824 } 825 826 827 /******************************************************************************* 828 * 829 * FUNCTION: AcpiDmDumpDmar 830 * 831 * PARAMETERS: Table - A DMAR table 832 * 833 * RETURN: None 834 * 835 * DESCRIPTION: Format the contents of a DMAR. This table type consists 836 * of an open-ended number of subtables. 837 * 838 ******************************************************************************/ 839 840 841 void 842 AcpiDmDumpDmar ( 843 ACPI_TABLE_HEADER *Table) 844 { 845 ACPI_STATUS Status; 846 ACPI_DMAR_HEADER *SubTable; 847 UINT32 Length = Table->Length; 848 UINT32 Offset = sizeof (ACPI_TABLE_DMAR); 849 ACPI_DMTABLE_INFO *InfoTable; 850 ACPI_DMAR_DEVICE_SCOPE *ScopeTable; 851 UINT32 ScopeOffset; 852 UINT8 *PciPath; 853 UINT32 PathOffset; 854 855 856 /* Main table */ 857 858 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); 859 if (ACPI_FAILURE (Status)) 860 { 861 return; 862 } 863 864 /* Sub-tables */ 865 866 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); 867 while (Offset < Table->Length) 868 { 869 /* Common sub-table header */ 870 871 AcpiOsPrintf ("\n"); 872 Status = AcpiDmDumpTable (Length, Offset, SubTable, 873 SubTable->Length, AcpiDmTableInfoDmarHdr); 874 if (ACPI_FAILURE (Status)) 875 { 876 return; 877 } 878 AcpiOsPrintf ("\n"); 879 880 switch (SubTable->Type) 881 { 882 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 883 884 InfoTable = AcpiDmTableInfoDmar0; 885 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT); 886 break; 887 888 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 889 890 InfoTable = AcpiDmTableInfoDmar1; 891 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY); 892 break; 893 894 case ACPI_DMAR_TYPE_ATSR: 895 896 InfoTable = AcpiDmTableInfoDmar2; 897 ScopeOffset = sizeof (ACPI_DMAR_ATSR); 898 break; 899 900 case ACPI_DMAR_HARDWARE_AFFINITY: 901 902 InfoTable = AcpiDmTableInfoDmar3; 903 ScopeOffset = sizeof (ACPI_DMAR_RHSA); 904 break; 905 906 default: 907 908 AcpiOsPrintf ("\n**** Unknown DMAR sub-table type 0x%X\n\n", SubTable->Type); 909 return; 910 } 911 912 Status = AcpiDmDumpTable (Length, Offset, SubTable, 913 SubTable->Length, InfoTable); 914 if (ACPI_FAILURE (Status)) 915 { 916 return; 917 } 918 919 /* Dump the device scope entries (if any) */ 920 921 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset); 922 while (ScopeOffset < SubTable->Length) 923 { 924 AcpiOsPrintf ("\n"); 925 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, 926 ScopeTable->Length, AcpiDmTableInfoDmarScope); 927 if (ACPI_FAILURE (Status)) 928 { 929 return; 930 } 931 AcpiOsPrintf ("\n"); 932 933 /* Dump the PCI Path entries for this device scope */ 934 935 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */ 936 937 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable, 938 sizeof (ACPI_DMAR_DEVICE_SCOPE)); 939 940 while (PathOffset < ScopeTable->Length) 941 { 942 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path"); 943 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]); 944 945 /* Point to next PCI Path entry */ 946 947 PathOffset += 2; 948 PciPath += 2; 949 AcpiOsPrintf ("\n"); 950 } 951 952 /* Point to next device scope entry */ 953 954 ScopeOffset += ScopeTable->Length; 955 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, 956 ScopeTable, ScopeTable->Length); 957 } 958 959 /* Point to next sub-table */ 960 961 Offset += SubTable->Length; 962 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length); 963 } 964 } 965 966 967 /******************************************************************************* 968 * 969 * FUNCTION: AcpiDmDumpEinj 970 * 971 * PARAMETERS: Table - A EINJ table 972 * 973 * RETURN: None 974 * 975 * DESCRIPTION: Format the contents of a EINJ. This table type consists 976 * of an open-ended number of subtables. 977 * 978 ******************************************************************************/ 979 980 void 981 AcpiDmDumpEinj ( 982 ACPI_TABLE_HEADER *Table) 983 { 984 ACPI_STATUS Status; 985 ACPI_WHEA_HEADER *SubTable; 986 UINT32 Length = Table->Length; 987 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 988 989 990 /* Main table */ 991 992 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 993 if (ACPI_FAILURE (Status)) 994 { 995 return; 996 } 997 998 /* Sub-tables */ 999 1000 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1001 while (Offset < Table->Length) 1002 { 1003 AcpiOsPrintf ("\n"); 1004 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1005 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 1006 if (ACPI_FAILURE (Status)) 1007 { 1008 return; 1009 } 1010 1011 /* Point to next sub-table (each subtable is of fixed length) */ 1012 1013 Offset += sizeof (ACPI_WHEA_HEADER); 1014 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 1015 sizeof (ACPI_WHEA_HEADER)); 1016 } 1017 } 1018 1019 1020 /******************************************************************************* 1021 * 1022 * FUNCTION: AcpiDmDumpErst 1023 * 1024 * PARAMETERS: Table - A ERST table 1025 * 1026 * RETURN: None 1027 * 1028 * DESCRIPTION: Format the contents of a ERST. This table type consists 1029 * of an open-ended number of subtables. 1030 * 1031 ******************************************************************************/ 1032 1033 void 1034 AcpiDmDumpErst ( 1035 ACPI_TABLE_HEADER *Table) 1036 { 1037 ACPI_STATUS Status; 1038 ACPI_WHEA_HEADER *SubTable; 1039 UINT32 Length = Table->Length; 1040 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 1041 1042 1043 /* Main table */ 1044 1045 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 1046 if (ACPI_FAILURE (Status)) 1047 { 1048 return; 1049 } 1050 1051 /* Sub-tables */ 1052 1053 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1054 while (Offset < Table->Length) 1055 { 1056 AcpiOsPrintf ("\n"); 1057 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1058 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0); 1059 if (ACPI_FAILURE (Status)) 1060 { 1061 return; 1062 } 1063 1064 /* Point to next sub-table (each subtable is of fixed length) */ 1065 1066 Offset += sizeof (ACPI_WHEA_HEADER); 1067 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 1068 sizeof (ACPI_WHEA_HEADER)); 1069 } 1070 } 1071 1072 1073 /******************************************************************************* 1074 * 1075 * FUNCTION: AcpiDmDumpFpdt 1076 * 1077 * PARAMETERS: Table - A FPDT table 1078 * 1079 * RETURN: None 1080 * 1081 * DESCRIPTION: Format the contents of a FPDT. This table type consists 1082 * of an open-ended number of subtables. 1083 * 1084 ******************************************************************************/ 1085 1086 void 1087 AcpiDmDumpFpdt ( 1088 ACPI_TABLE_HEADER *Table) 1089 { 1090 ACPI_STATUS Status; 1091 ACPI_FPDT_HEADER *SubTable; 1092 UINT32 Length = Table->Length; 1093 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 1094 ACPI_DMTABLE_INFO *InfoTable; 1095 1096 1097 /* There is no main table (other than the standard ACPI header) */ 1098 1099 /* Sub-tables */ 1100 1101 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); 1102 while (Offset < Table->Length) 1103 { 1104 /* Common sub-table header */ 1105 1106 AcpiOsPrintf ("\n"); 1107 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1108 SubTable->Length, AcpiDmTableInfoFpdtHdr); 1109 if (ACPI_FAILURE (Status)) 1110 { 1111 return; 1112 } 1113 1114 switch (SubTable->Type) 1115 { 1116 case ACPI_FPDT_TYPE_BOOT: 1117 1118 InfoTable = AcpiDmTableInfoFpdt0; 1119 break; 1120 1121 case ACPI_FPDT_TYPE_S3PERF: 1122 1123 InfoTable = AcpiDmTableInfoFpdt1; 1124 break; 1125 1126 default: 1127 1128 AcpiOsPrintf ("\n**** Unknown FPDT sub-table type 0x%X\n\n", SubTable->Type); 1129 1130 /* Attempt to continue */ 1131 1132 if (!SubTable->Length) 1133 { 1134 AcpiOsPrintf ("Invalid zero length subtable\n"); 1135 return; 1136 } 1137 goto NextSubTable; 1138 } 1139 1140 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1141 SubTable->Length, InfoTable); 1142 if (ACPI_FAILURE (Status)) 1143 { 1144 return; 1145 } 1146 1147 NextSubTable: 1148 /* Point to next sub-table */ 1149 1150 Offset += SubTable->Length; 1151 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length); 1152 } 1153 } 1154 1155 1156 /******************************************************************************* 1157 * 1158 * FUNCTION: AcpiDmDumpHest 1159 * 1160 * PARAMETERS: Table - A HEST table 1161 * 1162 * RETURN: None 1163 * 1164 * DESCRIPTION: Format the contents of a HEST. This table type consists 1165 * of an open-ended number of subtables. 1166 * 1167 ******************************************************************************/ 1168 1169 void 1170 AcpiDmDumpHest ( 1171 ACPI_TABLE_HEADER *Table) 1172 { 1173 ACPI_STATUS Status; 1174 ACPI_HEST_HEADER *SubTable; 1175 UINT32 Length = Table->Length; 1176 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 1177 ACPI_DMTABLE_INFO *InfoTable; 1178 UINT32 SubTableLength; 1179 UINT32 BankCount; 1180 ACPI_HEST_IA_ERROR_BANK *BankTable; 1181 1182 1183 /* Main table */ 1184 1185 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 1186 if (ACPI_FAILURE (Status)) 1187 { 1188 return; 1189 } 1190 1191 /* Sub-tables */ 1192 1193 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 1194 while (Offset < Table->Length) 1195 { 1196 BankCount = 0; 1197 switch (SubTable->Type) 1198 { 1199 case ACPI_HEST_TYPE_IA32_CHECK: 1200 1201 InfoTable = AcpiDmTableInfoHest0; 1202 SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK); 1203 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 1204 SubTable))->NumHardwareBanks; 1205 break; 1206 1207 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 1208 1209 InfoTable = AcpiDmTableInfoHest1; 1210 SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED); 1211 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 1212 SubTable))->NumHardwareBanks; 1213 break; 1214 1215 case ACPI_HEST_TYPE_IA32_NMI: 1216 1217 InfoTable = AcpiDmTableInfoHest2; 1218 SubTableLength = sizeof (ACPI_HEST_IA_NMI); 1219 break; 1220 1221 case ACPI_HEST_TYPE_AER_ROOT_PORT: 1222 1223 InfoTable = AcpiDmTableInfoHest6; 1224 SubTableLength = sizeof (ACPI_HEST_AER_ROOT); 1225 break; 1226 1227 case ACPI_HEST_TYPE_AER_ENDPOINT: 1228 1229 InfoTable = AcpiDmTableInfoHest7; 1230 SubTableLength = sizeof (ACPI_HEST_AER); 1231 break; 1232 1233 case ACPI_HEST_TYPE_AER_BRIDGE: 1234 1235 InfoTable = AcpiDmTableInfoHest8; 1236 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE); 1237 break; 1238 1239 case ACPI_HEST_TYPE_GENERIC_ERROR: 1240 1241 InfoTable = AcpiDmTableInfoHest9; 1242 SubTableLength = sizeof (ACPI_HEST_GENERIC); 1243 break; 1244 1245 default: 1246 1247 /* Cannot continue on unknown type - no length */ 1248 1249 AcpiOsPrintf ("\n**** Unknown HEST sub-table type 0x%X\n", SubTable->Type); 1250 return; 1251 } 1252 1253 AcpiOsPrintf ("\n"); 1254 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1255 SubTableLength, InfoTable); 1256 if (ACPI_FAILURE (Status)) 1257 { 1258 return; 1259 } 1260 1261 /* Point to end of current subtable (each subtable above is of fixed length) */ 1262 1263 Offset += SubTableLength; 1264 1265 /* If there are any (fixed-length) Error Banks from above, dump them now */ 1266 1267 if (BankCount) 1268 { 1269 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength); 1270 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 1271 1272 while (BankCount) 1273 { 1274 AcpiOsPrintf ("\n"); 1275 Status = AcpiDmDumpTable (Length, Offset, BankTable, 1276 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 1277 if (ACPI_FAILURE (Status)) 1278 { 1279 return; 1280 } 1281 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 1282 BankTable++; 1283 BankCount--; 1284 } 1285 } 1286 1287 /* Point to next sub-table */ 1288 1289 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength); 1290 } 1291 } 1292 1293 1294 /******************************************************************************* 1295 * 1296 * FUNCTION: AcpiDmDumpIvrs 1297 * 1298 * PARAMETERS: Table - A IVRS table 1299 * 1300 * RETURN: None 1301 * 1302 * DESCRIPTION: Format the contents of a IVRS 1303 * 1304 ******************************************************************************/ 1305 1306 static UINT8 EntrySizes[] = {4,8,16,32}; 1307 1308 void 1309 AcpiDmDumpIvrs ( 1310 ACPI_TABLE_HEADER *Table) 1311 { 1312 ACPI_STATUS Status; 1313 UINT32 Offset = sizeof (ACPI_TABLE_IVRS); 1314 UINT32 EntryOffset; 1315 UINT32 EntryLength; 1316 UINT32 EntryType; 1317 ACPI_IVRS_DE_HEADER *DeviceEntry; 1318 ACPI_IVRS_HEADER *SubTable; 1319 ACPI_DMTABLE_INFO *InfoTable; 1320 1321 1322 /* Main table */ 1323 1324 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); 1325 if (ACPI_FAILURE (Status)) 1326 { 1327 return; 1328 } 1329 1330 /* Sub-tables */ 1331 1332 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); 1333 while (Offset < Table->Length) 1334 { 1335 /* Common sub-table header */ 1336 1337 AcpiOsPrintf ("\n"); 1338 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1339 SubTable->Length, AcpiDmTableInfoIvrsHdr); 1340 if (ACPI_FAILURE (Status)) 1341 { 1342 return; 1343 } 1344 1345 switch (SubTable->Type) 1346 { 1347 case ACPI_IVRS_TYPE_HARDWARE: 1348 1349 InfoTable = AcpiDmTableInfoIvrs0; 1350 break; 1351 1352 case ACPI_IVRS_TYPE_MEMORY1: 1353 case ACPI_IVRS_TYPE_MEMORY2: 1354 case ACPI_IVRS_TYPE_MEMORY3: 1355 1356 InfoTable = AcpiDmTableInfoIvrs1; 1357 break; 1358 1359 default: 1360 1361 AcpiOsPrintf ("\n**** Unknown IVRS sub-table type 0x%X\n", 1362 SubTable->Type); 1363 1364 /* Attempt to continue */ 1365 1366 if (!SubTable->Length) 1367 { 1368 AcpiOsPrintf ("Invalid zero length subtable\n"); 1369 return; 1370 } 1371 goto NextSubTable; 1372 } 1373 1374 /* Dump the subtable */ 1375 1376 AcpiOsPrintf ("\n"); 1377 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1378 SubTable->Length, InfoTable); 1379 if (ACPI_FAILURE (Status)) 1380 { 1381 return; 1382 } 1383 1384 /* The hardware subtable can contain multiple device entries */ 1385 1386 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE) 1387 { 1388 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE); 1389 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable, 1390 sizeof (ACPI_IVRS_HARDWARE)); 1391 1392 while (EntryOffset < (Offset + SubTable->Length)) 1393 { 1394 AcpiOsPrintf ("\n"); 1395 /* 1396 * Upper 2 bits of Type encode the length of the device entry 1397 * 1398 * 00 = 4 byte 1399 * 01 = 8 byte 1400 * 10 = 16 byte - currently no entries defined 1401 * 11 = 32 byte - currently no entries defined 1402 */ 1403 EntryType = DeviceEntry->Type; 1404 EntryLength = EntrySizes [EntryType >> 6]; 1405 1406 switch (EntryType) 1407 { 1408 /* 4-byte device entries */ 1409 1410 case ACPI_IVRS_TYPE_PAD4: 1411 case ACPI_IVRS_TYPE_ALL: 1412 case ACPI_IVRS_TYPE_SELECT: 1413 case ACPI_IVRS_TYPE_START: 1414 case ACPI_IVRS_TYPE_END: 1415 1416 InfoTable = AcpiDmTableInfoIvrs4; 1417 break; 1418 1419 /* 8-byte entries, type A */ 1420 1421 case ACPI_IVRS_TYPE_ALIAS_SELECT: 1422 case ACPI_IVRS_TYPE_ALIAS_START: 1423 1424 InfoTable = AcpiDmTableInfoIvrs8a; 1425 break; 1426 1427 /* 8-byte entries, type B */ 1428 1429 case ACPI_IVRS_TYPE_PAD8: 1430 case ACPI_IVRS_TYPE_EXT_SELECT: 1431 case ACPI_IVRS_TYPE_EXT_START: 1432 1433 InfoTable = AcpiDmTableInfoIvrs8b; 1434 break; 1435 1436 /* 8-byte entries, type C */ 1437 1438 case ACPI_IVRS_TYPE_SPECIAL: 1439 1440 InfoTable = AcpiDmTableInfoIvrs8c; 1441 break; 1442 1443 default: 1444 InfoTable = AcpiDmTableInfoIvrs4; 1445 AcpiOsPrintf ( 1446 "\n**** Unknown IVRS device entry type/length: " 1447 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n", 1448 EntryType, EntryLength, EntryOffset); 1449 break; 1450 } 1451 1452 /* Dump the Device Entry */ 1453 1454 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 1455 DeviceEntry, EntryLength, InfoTable); 1456 1457 EntryOffset += EntryLength; 1458 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry, 1459 EntryLength); 1460 } 1461 } 1462 1463 NextSubTable: 1464 /* Point to next sub-table */ 1465 1466 Offset += SubTable->Length; 1467 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length); 1468 } 1469 } 1470 1471 1472 /******************************************************************************* 1473 * 1474 * FUNCTION: AcpiDmDumpMadt 1475 * 1476 * PARAMETERS: Table - A MADT table 1477 * 1478 * RETURN: None 1479 * 1480 * DESCRIPTION: Format the contents of a MADT. This table type consists 1481 * of an open-ended number of subtables. 1482 * 1483 ******************************************************************************/ 1484 1485 void 1486 AcpiDmDumpMadt ( 1487 ACPI_TABLE_HEADER *Table) 1488 { 1489 ACPI_STATUS Status; 1490 ACPI_SUBTABLE_HEADER *SubTable; 1491 UINT32 Length = Table->Length; 1492 UINT32 Offset = sizeof (ACPI_TABLE_MADT); 1493 ACPI_DMTABLE_INFO *InfoTable; 1494 1495 1496 /* Main table */ 1497 1498 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); 1499 if (ACPI_FAILURE (Status)) 1500 { 1501 return; 1502 } 1503 1504 /* Sub-tables */ 1505 1506 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 1507 while (Offset < Table->Length) 1508 { 1509 /* Common sub-table header */ 1510 1511 AcpiOsPrintf ("\n"); 1512 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1513 SubTable->Length, AcpiDmTableInfoMadtHdr); 1514 if (ACPI_FAILURE (Status)) 1515 { 1516 return; 1517 } 1518 1519 switch (SubTable->Type) 1520 { 1521 case ACPI_MADT_TYPE_LOCAL_APIC: 1522 1523 InfoTable = AcpiDmTableInfoMadt0; 1524 break; 1525 1526 case ACPI_MADT_TYPE_IO_APIC: 1527 1528 InfoTable = AcpiDmTableInfoMadt1; 1529 break; 1530 1531 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 1532 1533 InfoTable = AcpiDmTableInfoMadt2; 1534 break; 1535 1536 case ACPI_MADT_TYPE_NMI_SOURCE: 1537 1538 InfoTable = AcpiDmTableInfoMadt3; 1539 break; 1540 1541 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 1542 1543 InfoTable = AcpiDmTableInfoMadt4; 1544 break; 1545 1546 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 1547 1548 InfoTable = AcpiDmTableInfoMadt5; 1549 break; 1550 1551 case ACPI_MADT_TYPE_IO_SAPIC: 1552 1553 InfoTable = AcpiDmTableInfoMadt6; 1554 break; 1555 1556 case ACPI_MADT_TYPE_LOCAL_SAPIC: 1557 1558 InfoTable = AcpiDmTableInfoMadt7; 1559 break; 1560 1561 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 1562 1563 InfoTable = AcpiDmTableInfoMadt8; 1564 break; 1565 1566 case ACPI_MADT_TYPE_LOCAL_X2APIC: 1567 1568 InfoTable = AcpiDmTableInfoMadt9; 1569 break; 1570 1571 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 1572 1573 InfoTable = AcpiDmTableInfoMadt10; 1574 break; 1575 1576 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 1577 1578 InfoTable = AcpiDmTableInfoMadt11; 1579 break; 1580 1581 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 1582 1583 InfoTable = AcpiDmTableInfoMadt12; 1584 break; 1585 1586 default: 1587 1588 AcpiOsPrintf ("\n**** Unknown MADT sub-table type 0x%X\n\n", SubTable->Type); 1589 1590 /* Attempt to continue */ 1591 1592 if (!SubTable->Length) 1593 { 1594 AcpiOsPrintf ("Invalid zero length subtable\n"); 1595 return; 1596 } 1597 goto NextSubTable; 1598 } 1599 1600 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1601 SubTable->Length, InfoTable); 1602 if (ACPI_FAILURE (Status)) 1603 { 1604 return; 1605 } 1606 1607 NextSubTable: 1608 /* Point to next sub-table */ 1609 1610 Offset += SubTable->Length; 1611 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 1612 } 1613 } 1614 1615 1616 /******************************************************************************* 1617 * 1618 * FUNCTION: AcpiDmDumpMcfg 1619 * 1620 * PARAMETERS: Table - A MCFG Table 1621 * 1622 * RETURN: None 1623 * 1624 * DESCRIPTION: Format the contents of a MCFG table 1625 * 1626 ******************************************************************************/ 1627 1628 void 1629 AcpiDmDumpMcfg ( 1630 ACPI_TABLE_HEADER *Table) 1631 { 1632 ACPI_STATUS Status; 1633 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 1634 ACPI_MCFG_ALLOCATION *SubTable; 1635 1636 1637 /* Main table */ 1638 1639 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 1640 if (ACPI_FAILURE (Status)) 1641 { 1642 return; 1643 } 1644 1645 /* Sub-tables */ 1646 1647 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 1648 while (Offset < Table->Length) 1649 { 1650 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 1651 { 1652 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", 1653 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 1654 return; 1655 } 1656 1657 AcpiOsPrintf ("\n"); 1658 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1659 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 1660 if (ACPI_FAILURE (Status)) 1661 { 1662 return; 1663 } 1664 1665 /* Point to next sub-table (each subtable is of fixed length) */ 1666 1667 Offset += sizeof (ACPI_MCFG_ALLOCATION); 1668 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable, 1669 sizeof (ACPI_MCFG_ALLOCATION)); 1670 } 1671 } 1672 1673 1674 /******************************************************************************* 1675 * 1676 * FUNCTION: AcpiDmDumpMpst 1677 * 1678 * PARAMETERS: Table - A MPST Table 1679 * 1680 * RETURN: None 1681 * 1682 * DESCRIPTION: Format the contents of a MPST table 1683 * 1684 ******************************************************************************/ 1685 1686 void 1687 AcpiDmDumpMpst ( 1688 ACPI_TABLE_HEADER *Table) 1689 { 1690 ACPI_STATUS Status; 1691 UINT32 Offset = sizeof (ACPI_TABLE_MPST); 1692 ACPI_MPST_POWER_NODE *SubTable0; 1693 ACPI_MPST_POWER_STATE *SubTable0A; 1694 ACPI_MPST_COMPONENT *SubTable0B; 1695 ACPI_MPST_DATA_HDR *SubTable1; 1696 ACPI_MPST_POWER_DATA *SubTable2; 1697 UINT16 SubtableCount; 1698 UINT32 PowerStateCount; 1699 UINT32 ComponentCount; 1700 1701 1702 /* Main table */ 1703 1704 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); 1705 if (ACPI_FAILURE (Status)) 1706 { 1707 return; 1708 } 1709 1710 /* Subtable: Memory Power Node(s) */ 1711 1712 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; 1713 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); 1714 1715 while ((Offset < Table->Length) && SubtableCount) 1716 { 1717 AcpiOsPrintf ("\n"); 1718 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0, 1719 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); 1720 if (ACPI_FAILURE (Status)) 1721 { 1722 return; 1723 } 1724 1725 /* Extract the sub-subtable counts */ 1726 1727 PowerStateCount = SubTable0->NumPowerStates; 1728 ComponentCount = SubTable0->NumPhysicalComponents; 1729 Offset += sizeof (ACPI_MPST_POWER_NODE); 1730 1731 /* Sub-subtables - Memory Power State Structure(s) */ 1732 1733 SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0, 1734 sizeof (ACPI_MPST_POWER_NODE)); 1735 1736 while (PowerStateCount) 1737 { 1738 AcpiOsPrintf ("\n"); 1739 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A, 1740 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); 1741 if (ACPI_FAILURE (Status)) 1742 { 1743 return; 1744 } 1745 1746 SubTable0A++; 1747 PowerStateCount--; 1748 Offset += sizeof (ACPI_MPST_POWER_STATE); 1749 } 1750 1751 /* Sub-subtables - Physical Component ID Structure(s) */ 1752 1753 SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A); 1754 1755 if (ComponentCount) 1756 { 1757 AcpiOsPrintf ("\n"); 1758 } 1759 1760 while (ComponentCount) 1761 { 1762 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B, 1763 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); 1764 if (ACPI_FAILURE (Status)) 1765 { 1766 return; 1767 } 1768 1769 SubTable0B++; 1770 ComponentCount--; 1771 Offset += sizeof (ACPI_MPST_COMPONENT); 1772 } 1773 1774 /* Point to next Memory Power Node subtable */ 1775 1776 SubtableCount--; 1777 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0, 1778 sizeof (ACPI_MPST_POWER_NODE) + 1779 (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) + 1780 (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents)); 1781 } 1782 1783 /* Subtable: Count of Memory Power State Characteristic structures */ 1784 1785 AcpiOsPrintf ("\n"); 1786 SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0); 1787 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1, 1788 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); 1789 if (ACPI_FAILURE (Status)) 1790 { 1791 return; 1792 } 1793 1794 SubtableCount = SubTable1->CharacteristicsCount; 1795 Offset += sizeof (ACPI_MPST_DATA_HDR); 1796 1797 /* Subtable: Memory Power State Characteristics structure(s) */ 1798 1799 SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, sizeof (ACPI_MPST_DATA_HDR)); 1800 1801 while ((Offset < Table->Length) && SubtableCount) 1802 { 1803 AcpiOsPrintf ("\n"); 1804 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2, 1805 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); 1806 if (ACPI_FAILURE (Status)) 1807 { 1808 return; 1809 } 1810 1811 SubTable2++; 1812 SubtableCount--; 1813 Offset += sizeof (ACPI_MPST_POWER_DATA); 1814 } 1815 } 1816 1817 1818 /******************************************************************************* 1819 * 1820 * FUNCTION: AcpiDmDumpMsct 1821 * 1822 * PARAMETERS: Table - A MSCT table 1823 * 1824 * RETURN: None 1825 * 1826 * DESCRIPTION: Format the contents of a MSCT 1827 * 1828 ******************************************************************************/ 1829 1830 void 1831 AcpiDmDumpMsct ( 1832 ACPI_TABLE_HEADER *Table) 1833 { 1834 ACPI_STATUS Status; 1835 UINT32 Offset = sizeof (ACPI_TABLE_MSCT); 1836 ACPI_MSCT_PROXIMITY *SubTable; 1837 1838 1839 /* Main table */ 1840 1841 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); 1842 if (ACPI_FAILURE (Status)) 1843 { 1844 return; 1845 } 1846 1847 /* Sub-tables */ 1848 1849 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); 1850 while (Offset < Table->Length) 1851 { 1852 /* Common sub-table header */ 1853 1854 AcpiOsPrintf ("\n"); 1855 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1856 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); 1857 if (ACPI_FAILURE (Status)) 1858 { 1859 return; 1860 } 1861 1862 /* Point to next sub-table */ 1863 1864 Offset += sizeof (ACPI_MSCT_PROXIMITY); 1865 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY)); 1866 } 1867 } 1868 1869 1870 /******************************************************************************* 1871 * 1872 * FUNCTION: AcpiDmDumpMtmr 1873 * 1874 * PARAMETERS: Table - A MTMR table 1875 * 1876 * RETURN: None 1877 * 1878 * DESCRIPTION: Format the contents of a MTMR 1879 * 1880 ******************************************************************************/ 1881 1882 void 1883 AcpiDmDumpMtmr ( 1884 ACPI_TABLE_HEADER *Table) 1885 { 1886 ACPI_STATUS Status; 1887 UINT32 Offset = sizeof (ACPI_TABLE_MTMR); 1888 ACPI_MTMR_ENTRY *SubTable; 1889 1890 1891 /* Main table */ 1892 1893 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr); 1894 if (ACPI_FAILURE (Status)) 1895 { 1896 return; 1897 } 1898 1899 /* Sub-tables */ 1900 1901 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset); 1902 while (Offset < Table->Length) 1903 { 1904 /* Common sub-table header */ 1905 1906 AcpiOsPrintf ("\n"); 1907 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1908 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0); 1909 if (ACPI_FAILURE (Status)) 1910 { 1911 return; 1912 } 1913 1914 /* Point to next sub-table */ 1915 1916 Offset += sizeof (ACPI_MTMR_ENTRY); 1917 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable, sizeof (ACPI_MTMR_ENTRY)); 1918 } 1919 } 1920 1921 1922 /******************************************************************************* 1923 * 1924 * FUNCTION: AcpiDmDumpPcct 1925 * 1926 * PARAMETERS: Table - A PCCT table 1927 * 1928 * RETURN: None 1929 * 1930 * DESCRIPTION: Format the contents of a PCCT. This table type consists 1931 * of an open-ended number of subtables. 1932 * 1933 ******************************************************************************/ 1934 1935 void 1936 AcpiDmDumpPcct ( 1937 ACPI_TABLE_HEADER *Table) 1938 { 1939 ACPI_STATUS Status; 1940 ACPI_PCCT_SUBSPACE *SubTable; 1941 UINT32 Length = Table->Length; 1942 UINT32 Offset = sizeof (ACPI_TABLE_PCCT); 1943 1944 1945 /* Main table */ 1946 1947 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); 1948 if (ACPI_FAILURE (Status)) 1949 { 1950 return; 1951 } 1952 1953 /* Subtables */ 1954 1955 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); 1956 while (Offset < Table->Length) 1957 { 1958 /* Common subtable header */ 1959 1960 AcpiOsPrintf ("\n"); 1961 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1962 SubTable->Header.Length, AcpiDmTableInfoPcctHdr); 1963 if (ACPI_FAILURE (Status)) 1964 { 1965 return; 1966 } 1967 1968 /* ACPI 5.0: Only one type of PCCT subtable is supported */ 1969 1970 if (SubTable->Header.Type != ACPI_PCCT_TYPE_GENERIC_SUBSPACE) 1971 { 1972 AcpiOsPrintf ( 1973 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n", 1974 SubTable->Header.Type); 1975 return; 1976 } 1977 1978 AcpiOsPrintf ("\n"); 1979 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1980 SubTable->Header.Length, AcpiDmTableInfoPcct0); 1981 if (ACPI_FAILURE (Status)) 1982 { 1983 return; 1984 } 1985 1986 /* Point to next subtable */ 1987 1988 Offset += SubTable->Header.Length; 1989 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable, 1990 SubTable->Header.Length); 1991 } 1992 } 1993 1994 1995 /******************************************************************************* 1996 * 1997 * FUNCTION: AcpiDmDumpPmtt 1998 * 1999 * PARAMETERS: Table - A PMTT table 2000 * 2001 * RETURN: None 2002 * 2003 * DESCRIPTION: Format the contents of a PMTT. This table type consists 2004 * of an open-ended number of subtables. 2005 * 2006 ******************************************************************************/ 2007 2008 void 2009 AcpiDmDumpPmtt ( 2010 ACPI_TABLE_HEADER *Table) 2011 { 2012 ACPI_STATUS Status; 2013 ACPI_PMTT_HEADER *SubTable; 2014 ACPI_PMTT_HEADER *MemSubTable; 2015 ACPI_PMTT_HEADER *DimmSubTable; 2016 ACPI_PMTT_DOMAIN *DomainArray; 2017 UINT32 Length = Table->Length; 2018 UINT32 Offset = sizeof (ACPI_TABLE_PMTT); 2019 UINT32 MemOffset; 2020 UINT32 DimmOffset; 2021 UINT32 DomainOffset; 2022 UINT32 DomainCount; 2023 2024 2025 /* Main table */ 2026 2027 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); 2028 if (ACPI_FAILURE (Status)) 2029 { 2030 return; 2031 } 2032 2033 /* Subtables */ 2034 2035 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); 2036 while (Offset < Table->Length) 2037 { 2038 /* Common subtable header */ 2039 2040 AcpiOsPrintf ("\n"); 2041 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2042 SubTable->Length, AcpiDmTableInfoPmttHdr); 2043 if (ACPI_FAILURE (Status)) 2044 { 2045 return; 2046 } 2047 2048 /* Only Socket subtables are expected at this level */ 2049 2050 if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET) 2051 { 2052 AcpiOsPrintf ( 2053 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2054 SubTable->Type); 2055 return; 2056 } 2057 2058 /* Dump the fixed-length portion of the subtable */ 2059 2060 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2061 SubTable->Length, AcpiDmTableInfoPmtt0); 2062 if (ACPI_FAILURE (Status)) 2063 { 2064 return; 2065 } 2066 2067 /* Walk the memory controller subtables */ 2068 2069 MemOffset = sizeof (ACPI_PMTT_SOCKET); 2070 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, 2071 sizeof (ACPI_PMTT_SOCKET)); 2072 2073 while (((Offset + MemOffset) < Table->Length) && 2074 (MemOffset < SubTable->Length)) 2075 { 2076 /* Common subtable header */ 2077 2078 AcpiOsPrintf ("\n"); 2079 Status = AcpiDmDumpTable (Length, 2080 Offset + MemOffset, MemSubTable, 2081 MemSubTable->Length, AcpiDmTableInfoPmttHdr); 2082 if (ACPI_FAILURE (Status)) 2083 { 2084 return; 2085 } 2086 2087 /* Only memory controller subtables are expected at this level */ 2088 2089 if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER) 2090 { 2091 AcpiOsPrintf ( 2092 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2093 MemSubTable->Type); 2094 return; 2095 } 2096 2097 /* Dump the fixed-length portion of the controller subtable */ 2098 2099 Status = AcpiDmDumpTable (Length, 2100 Offset + MemOffset, MemSubTable, 2101 MemSubTable->Length, AcpiDmTableInfoPmtt1); 2102 if (ACPI_FAILURE (Status)) 2103 { 2104 return; 2105 } 2106 2107 /* Walk the variable count of proximity domains */ 2108 2109 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount; 2110 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER); 2111 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable, 2112 sizeof (ACPI_PMTT_CONTROLLER)); 2113 2114 while (((Offset + MemOffset + DomainOffset) < Table->Length) && 2115 ((MemOffset + DomainOffset) < SubTable->Length) && 2116 DomainCount) 2117 { 2118 Status = AcpiDmDumpTable (Length, 2119 Offset + MemOffset + DomainOffset, DomainArray, 2120 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a); 2121 if (ACPI_FAILURE (Status)) 2122 { 2123 return; 2124 } 2125 2126 DomainOffset += sizeof (ACPI_PMTT_DOMAIN); 2127 DomainArray++; 2128 DomainCount--; 2129 } 2130 2131 if (DomainCount) 2132 { 2133 AcpiOsPrintf ( 2134 "\n**** DomainCount exceeds subtable length\n\n", 2135 MemSubTable->Type); 2136 } 2137 2138 /* Walk the physical component (DIMM) subtables */ 2139 2140 DimmOffset = DomainOffset; 2141 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable, 2142 DomainOffset); 2143 2144 while (((Offset + MemOffset + DimmOffset) < Table->Length) && 2145 (DimmOffset < MemSubTable->Length)) 2146 { 2147 /* Common subtable header */ 2148 2149 AcpiOsPrintf ("\n"); 2150 Status = AcpiDmDumpTable (Length, 2151 Offset + MemOffset + DimmOffset, DimmSubTable, 2152 DimmSubTable->Length, AcpiDmTableInfoPmttHdr); 2153 if (ACPI_FAILURE (Status)) 2154 { 2155 return; 2156 } 2157 2158 /* Only DIMM subtables are expected at this level */ 2159 2160 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM) 2161 { 2162 AcpiOsPrintf ( 2163 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2164 DimmSubTable->Type); 2165 return; 2166 } 2167 2168 /* Dump the fixed-length DIMM subtable */ 2169 2170 Status = AcpiDmDumpTable (Length, 2171 Offset + MemOffset + DimmOffset, DimmSubTable, 2172 DimmSubTable->Length, AcpiDmTableInfoPmtt2); 2173 if (ACPI_FAILURE (Status)) 2174 { 2175 return; 2176 } 2177 2178 /* Point to next DIMM subtable */ 2179 2180 DimmOffset += DimmSubTable->Length; 2181 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2182 DimmSubTable, DimmSubTable->Length); 2183 } 2184 2185 /* Point to next Controller subtable */ 2186 2187 MemOffset += MemSubTable->Length; 2188 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2189 MemSubTable, MemSubTable->Length); 2190 } 2191 2192 /* Point to next Socket subtable */ 2193 2194 Offset += SubTable->Length; 2195 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2196 SubTable, SubTable->Length); 2197 } 2198 } 2199 2200 2201 /******************************************************************************* 2202 * 2203 * FUNCTION: AcpiDmDumpS3pt 2204 * 2205 * PARAMETERS: Table - A S3PT table 2206 * 2207 * RETURN: Length of the table 2208 * 2209 * DESCRIPTION: Format the contents of a S3PT 2210 * 2211 ******************************************************************************/ 2212 2213 UINT32 2214 AcpiDmDumpS3pt ( 2215 ACPI_TABLE_HEADER *Tables) 2216 { 2217 ACPI_STATUS Status; 2218 UINT32 Offset = sizeof (ACPI_TABLE_S3PT); 2219 ACPI_S3PT_HEADER *SubTable; 2220 ACPI_DMTABLE_INFO *InfoTable; 2221 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); 2222 2223 2224 /* Main table */ 2225 2226 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt); 2227 if (ACPI_FAILURE (Status)) 2228 { 2229 return 0; 2230 } 2231 2232 SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, S3ptTable, Offset); 2233 while (Offset < S3ptTable->Length) 2234 { 2235 /* Common sub-table header */ 2236 2237 AcpiOsPrintf ("\n"); 2238 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 2239 SubTable->Length, AcpiDmTableInfoS3ptHdr); 2240 if (ACPI_FAILURE (Status)) 2241 { 2242 return 0; 2243 } 2244 2245 switch (SubTable->Type) 2246 { 2247 case ACPI_S3PT_TYPE_RESUME: 2248 2249 InfoTable = AcpiDmTableInfoS3pt0; 2250 break; 2251 2252 case ACPI_S3PT_TYPE_SUSPEND: 2253 2254 InfoTable = AcpiDmTableInfoS3pt1; 2255 break; 2256 2257 default: 2258 2259 AcpiOsPrintf ("\n**** Unknown S3PT sub-table type 0x%X\n", SubTable->Type); 2260 2261 /* Attempt to continue */ 2262 2263 if (!SubTable->Length) 2264 { 2265 AcpiOsPrintf ("Invalid zero length subtable\n"); 2266 return 0; 2267 } 2268 goto NextSubTable; 2269 } 2270 2271 AcpiOsPrintf ("\n"); 2272 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 2273 SubTable->Length, InfoTable); 2274 if (ACPI_FAILURE (Status)) 2275 { 2276 return 0; 2277 } 2278 2279 NextSubTable: 2280 /* Point to next sub-table */ 2281 2282 Offset += SubTable->Length; 2283 SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, SubTable, SubTable->Length); 2284 } 2285 2286 return (S3ptTable->Length); 2287 } 2288 2289 2290 /******************************************************************************* 2291 * 2292 * FUNCTION: AcpiDmDumpSlic 2293 * 2294 * PARAMETERS: Table - A SLIC table 2295 * 2296 * RETURN: None 2297 * 2298 * DESCRIPTION: Format the contents of a SLIC 2299 * 2300 ******************************************************************************/ 2301 2302 void 2303 AcpiDmDumpSlic ( 2304 ACPI_TABLE_HEADER *Table) 2305 { 2306 ACPI_STATUS Status; 2307 UINT32 Offset = sizeof (ACPI_TABLE_SLIC); 2308 ACPI_SLIC_HEADER *SubTable; 2309 ACPI_DMTABLE_INFO *InfoTable; 2310 2311 2312 /* There is no main SLIC table, only subtables */ 2313 2314 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, Table, Offset); 2315 while (Offset < Table->Length) 2316 { 2317 /* Common sub-table header */ 2318 2319 AcpiOsPrintf ("\n"); 2320 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2321 SubTable->Length, AcpiDmTableInfoSlicHdr); 2322 if (ACPI_FAILURE (Status)) 2323 { 2324 return; 2325 } 2326 2327 switch (SubTable->Type) 2328 { 2329 case ACPI_SLIC_TYPE_PUBLIC_KEY: 2330 2331 InfoTable = AcpiDmTableInfoSlic0; 2332 break; 2333 2334 case ACPI_SLIC_TYPE_WINDOWS_MARKER: 2335 2336 InfoTable = AcpiDmTableInfoSlic1; 2337 break; 2338 2339 default: 2340 2341 AcpiOsPrintf ("\n**** Unknown SLIC sub-table type 0x%X\n", SubTable->Type); 2342 2343 /* Attempt to continue */ 2344 2345 if (!SubTable->Length) 2346 { 2347 AcpiOsPrintf ("Invalid zero length subtable\n"); 2348 return; 2349 } 2350 goto NextSubTable; 2351 } 2352 2353 AcpiOsPrintf ("\n"); 2354 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2355 SubTable->Length, InfoTable); 2356 if (ACPI_FAILURE (Status)) 2357 { 2358 return; 2359 } 2360 2361 NextSubTable: 2362 /* Point to next sub-table */ 2363 2364 Offset += SubTable->Length; 2365 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, SubTable, SubTable->Length); 2366 } 2367 } 2368 2369 2370 /******************************************************************************* 2371 * 2372 * FUNCTION: AcpiDmDumpSlit 2373 * 2374 * PARAMETERS: Table - An SLIT 2375 * 2376 * RETURN: None 2377 * 2378 * DESCRIPTION: Format the contents of a SLIT 2379 * 2380 ******************************************************************************/ 2381 2382 void 2383 AcpiDmDumpSlit ( 2384 ACPI_TABLE_HEADER *Table) 2385 { 2386 ACPI_STATUS Status; 2387 UINT32 Offset; 2388 UINT8 *Row; 2389 UINT32 Localities; 2390 UINT32 i; 2391 UINT32 j; 2392 2393 2394 /* Main table */ 2395 2396 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit); 2397 if (ACPI_FAILURE (Status)) 2398 { 2399 return; 2400 } 2401 2402 /* Display the Locality NxN Matrix */ 2403 2404 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; 2405 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]); 2406 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry; 2407 2408 for (i = 0; i < Localities; i++) 2409 { 2410 /* Display one row of the matrix */ 2411 2412 AcpiDmLineHeader2 (Offset, Localities, "Locality", i); 2413 for (j = 0; j < Localities; j++) 2414 { 2415 /* Check for beyond EOT */ 2416 2417 if (Offset >= Table->Length) 2418 { 2419 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n"); 2420 return; 2421 } 2422 2423 AcpiOsPrintf ("%2.2X", Row[j]); 2424 Offset++; 2425 2426 /* Display up to 16 bytes per output row */ 2427 2428 if ((j+1) < Localities) 2429 { 2430 AcpiOsPrintf (" "); 2431 2432 if (j && (((j+1) % 16) == 0)) 2433 { 2434 AcpiOsPrintf ("\\\n"); /* With line continuation char */ 2435 AcpiDmLineHeader (Offset, 0, NULL); 2436 } 2437 } 2438 } 2439 2440 /* Point to next row */ 2441 2442 AcpiOsPrintf ("\n"); 2443 Row += Localities; 2444 } 2445 } 2446 2447 2448 /******************************************************************************* 2449 * 2450 * FUNCTION: AcpiDmDumpSrat 2451 * 2452 * PARAMETERS: Table - A SRAT table 2453 * 2454 * RETURN: None 2455 * 2456 * DESCRIPTION: Format the contents of a SRAT 2457 * 2458 ******************************************************************************/ 2459 2460 void 2461 AcpiDmDumpSrat ( 2462 ACPI_TABLE_HEADER *Table) 2463 { 2464 ACPI_STATUS Status; 2465 UINT32 Offset = sizeof (ACPI_TABLE_SRAT); 2466 ACPI_SUBTABLE_HEADER *SubTable; 2467 ACPI_DMTABLE_INFO *InfoTable; 2468 2469 2470 /* Main table */ 2471 2472 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat); 2473 if (ACPI_FAILURE (Status)) 2474 { 2475 return; 2476 } 2477 2478 /* Sub-tables */ 2479 2480 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 2481 while (Offset < Table->Length) 2482 { 2483 /* Common sub-table header */ 2484 2485 AcpiOsPrintf ("\n"); 2486 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2487 SubTable->Length, AcpiDmTableInfoSratHdr); 2488 if (ACPI_FAILURE (Status)) 2489 { 2490 return; 2491 } 2492 2493 switch (SubTable->Type) 2494 { 2495 case ACPI_SRAT_TYPE_CPU_AFFINITY: 2496 2497 InfoTable = AcpiDmTableInfoSrat0; 2498 break; 2499 2500 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 2501 2502 InfoTable = AcpiDmTableInfoSrat1; 2503 break; 2504 2505 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 2506 2507 InfoTable = AcpiDmTableInfoSrat2; 2508 break; 2509 2510 default: 2511 AcpiOsPrintf ("\n**** Unknown SRAT sub-table type 0x%X\n", SubTable->Type); 2512 2513 /* Attempt to continue */ 2514 2515 if (!SubTable->Length) 2516 { 2517 AcpiOsPrintf ("Invalid zero length subtable\n"); 2518 return; 2519 } 2520 goto NextSubTable; 2521 } 2522 2523 AcpiOsPrintf ("\n"); 2524 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2525 SubTable->Length, InfoTable); 2526 if (ACPI_FAILURE (Status)) 2527 { 2528 return; 2529 } 2530 2531 NextSubTable: 2532 /* Point to next sub-table */ 2533 2534 Offset += SubTable->Length; 2535 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 2536 } 2537 } 2538 2539 2540 /******************************************************************************* 2541 * 2542 * FUNCTION: AcpiDmDumpVrtc 2543 * 2544 * PARAMETERS: Table - A VRTC table 2545 * 2546 * RETURN: None 2547 * 2548 * DESCRIPTION: Format the contents of a VRTC 2549 * 2550 ******************************************************************************/ 2551 2552 void 2553 AcpiDmDumpVrtc ( 2554 ACPI_TABLE_HEADER *Table) 2555 { 2556 ACPI_STATUS Status; 2557 UINT32 Offset = sizeof (ACPI_TABLE_VRTC); 2558 ACPI_VRTC_ENTRY *SubTable; 2559 2560 2561 /* Main table */ 2562 2563 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc); 2564 if (ACPI_FAILURE (Status)) 2565 { 2566 return; 2567 } 2568 2569 /* Sub-tables */ 2570 2571 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset); 2572 while (Offset < Table->Length) 2573 { 2574 /* Common sub-table header */ 2575 2576 AcpiOsPrintf ("\n"); 2577 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2578 sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0); 2579 if (ACPI_FAILURE (Status)) 2580 { 2581 return; 2582 } 2583 2584 /* Point to next sub-table */ 2585 2586 Offset += sizeof (ACPI_VRTC_ENTRY); 2587 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable, sizeof (ACPI_VRTC_ENTRY)); 2588 } 2589 } 2590 2591 2592 /******************************************************************************* 2593 * 2594 * FUNCTION: AcpiDmDumpWdat 2595 * 2596 * PARAMETERS: Table - A WDAT table 2597 * 2598 * RETURN: None 2599 * 2600 * DESCRIPTION: Format the contents of a WDAT 2601 * 2602 ******************************************************************************/ 2603 2604 void 2605 AcpiDmDumpWdat ( 2606 ACPI_TABLE_HEADER *Table) 2607 { 2608 ACPI_STATUS Status; 2609 UINT32 Offset = sizeof (ACPI_TABLE_WDAT); 2610 ACPI_WDAT_ENTRY *SubTable; 2611 2612 2613 /* Main table */ 2614 2615 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat); 2616 if (ACPI_FAILURE (Status)) 2617 { 2618 return; 2619 } 2620 2621 /* Sub-tables */ 2622 2623 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset); 2624 while (Offset < Table->Length) 2625 { 2626 /* Common sub-table header */ 2627 2628 AcpiOsPrintf ("\n"); 2629 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2630 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0); 2631 if (ACPI_FAILURE (Status)) 2632 { 2633 return; 2634 } 2635 2636 /* Point to next sub-table */ 2637 2638 Offset += sizeof (ACPI_WDAT_ENTRY); 2639 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY)); 2640 } 2641 } 2642