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 subtables */ 423 424 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); 425 while (Offset < Table->Length) 426 { 427 /* Common subtable 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 subtable 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 subtable */ 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 /* Subtables */ 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 subtable */ 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 /* Subtables (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 subtable */ 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 /* Subtables */ 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 subtable */ 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 /* Subtables */ 865 866 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); 867 while (Offset < Table->Length) 868 { 869 /* Common subtable 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 subtable 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 subtable */ 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 /* Subtables */ 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 subtable (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 /* Subtables */ 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 subtable (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 /* Subtables */ 1100 1101 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); 1102 while (Offset < Table->Length) 1103 { 1104 /* Common subtable 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 subtable 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 subtable */ 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 /* Subtables */ 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 subtable 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 subtable */ 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 /* Subtables */ 1331 1332 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); 1333 while (Offset < Table->Length) 1334 { 1335 /* Common subtable 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 subtable 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 subtable */ 1465 1466 Offset += SubTable->Length; 1467 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length); 1468 } 1469 } 1470 1471 1472 /******************************************************************************* 1473 * 1474 * FUNCTION: AcpiDmDumpLpit 1475 * 1476 * PARAMETERS: Table - A LPIT table 1477 * 1478 * RETURN: None 1479 * 1480 * DESCRIPTION: Format the contents of a LPIT. This table type consists 1481 * of an open-ended number of subtables. Note: There are no 1482 * entries in the main table. An LPIT consists of the table 1483 * header and then subtables only. 1484 * 1485 ******************************************************************************/ 1486 1487 void 1488 AcpiDmDumpLpit ( 1489 ACPI_TABLE_HEADER *Table) 1490 { 1491 ACPI_STATUS Status; 1492 ACPI_LPIT_HEADER *SubTable; 1493 UINT32 Length = Table->Length; 1494 UINT32 Offset = sizeof (ACPI_TABLE_LPIT); 1495 ACPI_DMTABLE_INFO *InfoTable; 1496 UINT32 SubTableLength; 1497 1498 1499 /* Subtables */ 1500 1501 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset); 1502 while (Offset < Table->Length) 1503 { 1504 /* Common subtable header */ 1505 1506 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1507 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr); 1508 if (ACPI_FAILURE (Status)) 1509 { 1510 return; 1511 } 1512 1513 switch (SubTable->Type) 1514 { 1515 case ACPI_LPIT_TYPE_NATIVE_CSTATE: 1516 1517 InfoTable = AcpiDmTableInfoLpit0; 1518 SubTableLength = sizeof (ACPI_LPIT_NATIVE); 1519 break; 1520 1521 case ACPI_LPIT_TYPE_SIMPLE_IO: 1522 1523 InfoTable = AcpiDmTableInfoLpit1; 1524 SubTableLength = sizeof (ACPI_LPIT_IO); 1525 break; 1526 1527 default: 1528 1529 /* Cannot continue on unknown type - no length */ 1530 1531 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n", SubTable->Type); 1532 return; 1533 } 1534 1535 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1536 SubTableLength, InfoTable); 1537 if (ACPI_FAILURE (Status)) 1538 { 1539 return; 1540 } 1541 AcpiOsPrintf ("\n"); 1542 1543 /* Point to next subtable */ 1544 1545 Offset += SubTableLength; 1546 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, SubTable, SubTableLength); 1547 } 1548 } 1549 1550 1551 /******************************************************************************* 1552 * 1553 * FUNCTION: AcpiDmDumpMadt 1554 * 1555 * PARAMETERS: Table - A MADT table 1556 * 1557 * RETURN: None 1558 * 1559 * DESCRIPTION: Format the contents of a MADT. This table type consists 1560 * of an open-ended number of subtables. 1561 * 1562 ******************************************************************************/ 1563 1564 void 1565 AcpiDmDumpMadt ( 1566 ACPI_TABLE_HEADER *Table) 1567 { 1568 ACPI_STATUS Status; 1569 ACPI_SUBTABLE_HEADER *SubTable; 1570 UINT32 Length = Table->Length; 1571 UINT32 Offset = sizeof (ACPI_TABLE_MADT); 1572 ACPI_DMTABLE_INFO *InfoTable; 1573 1574 1575 /* Main table */ 1576 1577 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); 1578 if (ACPI_FAILURE (Status)) 1579 { 1580 return; 1581 } 1582 1583 /* Subtables */ 1584 1585 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 1586 while (Offset < Table->Length) 1587 { 1588 /* Common subtable header */ 1589 1590 AcpiOsPrintf ("\n"); 1591 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1592 SubTable->Length, AcpiDmTableInfoMadtHdr); 1593 if (ACPI_FAILURE (Status)) 1594 { 1595 return; 1596 } 1597 1598 switch (SubTable->Type) 1599 { 1600 case ACPI_MADT_TYPE_LOCAL_APIC: 1601 1602 InfoTable = AcpiDmTableInfoMadt0; 1603 break; 1604 1605 case ACPI_MADT_TYPE_IO_APIC: 1606 1607 InfoTable = AcpiDmTableInfoMadt1; 1608 break; 1609 1610 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 1611 1612 InfoTable = AcpiDmTableInfoMadt2; 1613 break; 1614 1615 case ACPI_MADT_TYPE_NMI_SOURCE: 1616 1617 InfoTable = AcpiDmTableInfoMadt3; 1618 break; 1619 1620 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 1621 1622 InfoTable = AcpiDmTableInfoMadt4; 1623 break; 1624 1625 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 1626 1627 InfoTable = AcpiDmTableInfoMadt5; 1628 break; 1629 1630 case ACPI_MADT_TYPE_IO_SAPIC: 1631 1632 InfoTable = AcpiDmTableInfoMadt6; 1633 break; 1634 1635 case ACPI_MADT_TYPE_LOCAL_SAPIC: 1636 1637 InfoTable = AcpiDmTableInfoMadt7; 1638 break; 1639 1640 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 1641 1642 InfoTable = AcpiDmTableInfoMadt8; 1643 break; 1644 1645 case ACPI_MADT_TYPE_LOCAL_X2APIC: 1646 1647 InfoTable = AcpiDmTableInfoMadt9; 1648 break; 1649 1650 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 1651 1652 InfoTable = AcpiDmTableInfoMadt10; 1653 break; 1654 1655 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 1656 1657 InfoTable = AcpiDmTableInfoMadt11; 1658 break; 1659 1660 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 1661 1662 InfoTable = AcpiDmTableInfoMadt12; 1663 break; 1664 1665 default: 1666 1667 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n", SubTable->Type); 1668 1669 /* Attempt to continue */ 1670 1671 if (!SubTable->Length) 1672 { 1673 AcpiOsPrintf ("Invalid zero length subtable\n"); 1674 return; 1675 } 1676 goto NextSubTable; 1677 } 1678 1679 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1680 SubTable->Length, InfoTable); 1681 if (ACPI_FAILURE (Status)) 1682 { 1683 return; 1684 } 1685 1686 NextSubTable: 1687 /* Point to next subtable */ 1688 1689 Offset += SubTable->Length; 1690 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 1691 } 1692 } 1693 1694 1695 /******************************************************************************* 1696 * 1697 * FUNCTION: AcpiDmDumpMcfg 1698 * 1699 * PARAMETERS: Table - A MCFG Table 1700 * 1701 * RETURN: None 1702 * 1703 * DESCRIPTION: Format the contents of a MCFG table 1704 * 1705 ******************************************************************************/ 1706 1707 void 1708 AcpiDmDumpMcfg ( 1709 ACPI_TABLE_HEADER *Table) 1710 { 1711 ACPI_STATUS Status; 1712 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 1713 ACPI_MCFG_ALLOCATION *SubTable; 1714 1715 1716 /* Main table */ 1717 1718 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 1719 if (ACPI_FAILURE (Status)) 1720 { 1721 return; 1722 } 1723 1724 /* Subtables */ 1725 1726 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 1727 while (Offset < Table->Length) 1728 { 1729 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 1730 { 1731 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", 1732 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 1733 return; 1734 } 1735 1736 AcpiOsPrintf ("\n"); 1737 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1738 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 1739 if (ACPI_FAILURE (Status)) 1740 { 1741 return; 1742 } 1743 1744 /* Point to next subtable (each subtable is of fixed length) */ 1745 1746 Offset += sizeof (ACPI_MCFG_ALLOCATION); 1747 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable, 1748 sizeof (ACPI_MCFG_ALLOCATION)); 1749 } 1750 } 1751 1752 1753 /******************************************************************************* 1754 * 1755 * FUNCTION: AcpiDmDumpMpst 1756 * 1757 * PARAMETERS: Table - A MPST Table 1758 * 1759 * RETURN: None 1760 * 1761 * DESCRIPTION: Format the contents of a MPST table 1762 * 1763 ******************************************************************************/ 1764 1765 void 1766 AcpiDmDumpMpst ( 1767 ACPI_TABLE_HEADER *Table) 1768 { 1769 ACPI_STATUS Status; 1770 UINT32 Offset = sizeof (ACPI_TABLE_MPST); 1771 ACPI_MPST_POWER_NODE *SubTable0; 1772 ACPI_MPST_POWER_STATE *SubTable0A; 1773 ACPI_MPST_COMPONENT *SubTable0B; 1774 ACPI_MPST_DATA_HDR *SubTable1; 1775 ACPI_MPST_POWER_DATA *SubTable2; 1776 UINT16 SubtableCount; 1777 UINT32 PowerStateCount; 1778 UINT32 ComponentCount; 1779 1780 1781 /* Main table */ 1782 1783 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); 1784 if (ACPI_FAILURE (Status)) 1785 { 1786 return; 1787 } 1788 1789 /* Subtable: Memory Power Node(s) */ 1790 1791 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; 1792 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); 1793 1794 while ((Offset < Table->Length) && SubtableCount) 1795 { 1796 AcpiOsPrintf ("\n"); 1797 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0, 1798 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); 1799 if (ACPI_FAILURE (Status)) 1800 { 1801 return; 1802 } 1803 1804 /* Extract the sub-subtable counts */ 1805 1806 PowerStateCount = SubTable0->NumPowerStates; 1807 ComponentCount = SubTable0->NumPhysicalComponents; 1808 Offset += sizeof (ACPI_MPST_POWER_NODE); 1809 1810 /* Sub-subtables - Memory Power State Structure(s) */ 1811 1812 SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0, 1813 sizeof (ACPI_MPST_POWER_NODE)); 1814 1815 while (PowerStateCount) 1816 { 1817 AcpiOsPrintf ("\n"); 1818 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A, 1819 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); 1820 if (ACPI_FAILURE (Status)) 1821 { 1822 return; 1823 } 1824 1825 SubTable0A++; 1826 PowerStateCount--; 1827 Offset += sizeof (ACPI_MPST_POWER_STATE); 1828 } 1829 1830 /* Sub-subtables - Physical Component ID Structure(s) */ 1831 1832 SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A); 1833 1834 if (ComponentCount) 1835 { 1836 AcpiOsPrintf ("\n"); 1837 } 1838 1839 while (ComponentCount) 1840 { 1841 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B, 1842 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); 1843 if (ACPI_FAILURE (Status)) 1844 { 1845 return; 1846 } 1847 1848 SubTable0B++; 1849 ComponentCount--; 1850 Offset += sizeof (ACPI_MPST_COMPONENT); 1851 } 1852 1853 /* Point to next Memory Power Node subtable */ 1854 1855 SubtableCount--; 1856 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0, 1857 sizeof (ACPI_MPST_POWER_NODE) + 1858 (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) + 1859 (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents)); 1860 } 1861 1862 /* Subtable: Count of Memory Power State Characteristic structures */ 1863 1864 AcpiOsPrintf ("\n"); 1865 SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0); 1866 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1, 1867 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); 1868 if (ACPI_FAILURE (Status)) 1869 { 1870 return; 1871 } 1872 1873 SubtableCount = SubTable1->CharacteristicsCount; 1874 Offset += sizeof (ACPI_MPST_DATA_HDR); 1875 1876 /* Subtable: Memory Power State Characteristics structure(s) */ 1877 1878 SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, sizeof (ACPI_MPST_DATA_HDR)); 1879 1880 while ((Offset < Table->Length) && SubtableCount) 1881 { 1882 AcpiOsPrintf ("\n"); 1883 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2, 1884 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); 1885 if (ACPI_FAILURE (Status)) 1886 { 1887 return; 1888 } 1889 1890 SubTable2++; 1891 SubtableCount--; 1892 Offset += sizeof (ACPI_MPST_POWER_DATA); 1893 } 1894 } 1895 1896 1897 /******************************************************************************* 1898 * 1899 * FUNCTION: AcpiDmDumpMsct 1900 * 1901 * PARAMETERS: Table - A MSCT table 1902 * 1903 * RETURN: None 1904 * 1905 * DESCRIPTION: Format the contents of a MSCT 1906 * 1907 ******************************************************************************/ 1908 1909 void 1910 AcpiDmDumpMsct ( 1911 ACPI_TABLE_HEADER *Table) 1912 { 1913 ACPI_STATUS Status; 1914 UINT32 Offset = sizeof (ACPI_TABLE_MSCT); 1915 ACPI_MSCT_PROXIMITY *SubTable; 1916 1917 1918 /* Main table */ 1919 1920 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); 1921 if (ACPI_FAILURE (Status)) 1922 { 1923 return; 1924 } 1925 1926 /* Subtables */ 1927 1928 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); 1929 while (Offset < Table->Length) 1930 { 1931 /* Common subtable header */ 1932 1933 AcpiOsPrintf ("\n"); 1934 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1935 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); 1936 if (ACPI_FAILURE (Status)) 1937 { 1938 return; 1939 } 1940 1941 /* Point to next subtable */ 1942 1943 Offset += sizeof (ACPI_MSCT_PROXIMITY); 1944 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY)); 1945 } 1946 } 1947 1948 1949 /******************************************************************************* 1950 * 1951 * FUNCTION: AcpiDmDumpMtmr 1952 * 1953 * PARAMETERS: Table - A MTMR table 1954 * 1955 * RETURN: None 1956 * 1957 * DESCRIPTION: Format the contents of a MTMR 1958 * 1959 ******************************************************************************/ 1960 1961 void 1962 AcpiDmDumpMtmr ( 1963 ACPI_TABLE_HEADER *Table) 1964 { 1965 ACPI_STATUS Status; 1966 UINT32 Offset = sizeof (ACPI_TABLE_MTMR); 1967 ACPI_MTMR_ENTRY *SubTable; 1968 1969 1970 /* Main table */ 1971 1972 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr); 1973 if (ACPI_FAILURE (Status)) 1974 { 1975 return; 1976 } 1977 1978 /* Subtables */ 1979 1980 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset); 1981 while (Offset < Table->Length) 1982 { 1983 /* Common subtable header */ 1984 1985 AcpiOsPrintf ("\n"); 1986 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1987 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0); 1988 if (ACPI_FAILURE (Status)) 1989 { 1990 return; 1991 } 1992 1993 /* Point to next subtable */ 1994 1995 Offset += sizeof (ACPI_MTMR_ENTRY); 1996 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable, sizeof (ACPI_MTMR_ENTRY)); 1997 } 1998 } 1999 2000 2001 /******************************************************************************* 2002 * 2003 * FUNCTION: AcpiDmDumpPcct 2004 * 2005 * PARAMETERS: Table - A PCCT table 2006 * 2007 * RETURN: None 2008 * 2009 * DESCRIPTION: Format the contents of a PCCT. This table type consists 2010 * of an open-ended number of subtables. 2011 * 2012 ******************************************************************************/ 2013 2014 void 2015 AcpiDmDumpPcct ( 2016 ACPI_TABLE_HEADER *Table) 2017 { 2018 ACPI_STATUS Status; 2019 ACPI_PCCT_SUBSPACE *SubTable; 2020 UINT32 Length = Table->Length; 2021 UINT32 Offset = sizeof (ACPI_TABLE_PCCT); 2022 2023 2024 /* Main table */ 2025 2026 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); 2027 if (ACPI_FAILURE (Status)) 2028 { 2029 return; 2030 } 2031 2032 /* Subtables */ 2033 2034 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); 2035 while (Offset < Table->Length) 2036 { 2037 /* Common subtable header */ 2038 2039 AcpiOsPrintf ("\n"); 2040 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2041 SubTable->Header.Length, AcpiDmTableInfoPcctHdr); 2042 if (ACPI_FAILURE (Status)) 2043 { 2044 return; 2045 } 2046 2047 /* ACPI 5.0: Only one type of PCCT subtable is supported */ 2048 2049 if (SubTable->Header.Type != ACPI_PCCT_TYPE_GENERIC_SUBSPACE) 2050 { 2051 AcpiOsPrintf ( 2052 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n", 2053 SubTable->Header.Type); 2054 return; 2055 } 2056 2057 AcpiOsPrintf ("\n"); 2058 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2059 SubTable->Header.Length, AcpiDmTableInfoPcct0); 2060 if (ACPI_FAILURE (Status)) 2061 { 2062 return; 2063 } 2064 2065 /* Point to next subtable */ 2066 2067 Offset += SubTable->Header.Length; 2068 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable, 2069 SubTable->Header.Length); 2070 } 2071 } 2072 2073 2074 /******************************************************************************* 2075 * 2076 * FUNCTION: AcpiDmDumpPmtt 2077 * 2078 * PARAMETERS: Table - A PMTT table 2079 * 2080 * RETURN: None 2081 * 2082 * DESCRIPTION: Format the contents of a PMTT. This table type consists 2083 * of an open-ended number of subtables. 2084 * 2085 ******************************************************************************/ 2086 2087 void 2088 AcpiDmDumpPmtt ( 2089 ACPI_TABLE_HEADER *Table) 2090 { 2091 ACPI_STATUS Status; 2092 ACPI_PMTT_HEADER *SubTable; 2093 ACPI_PMTT_HEADER *MemSubTable; 2094 ACPI_PMTT_HEADER *DimmSubTable; 2095 ACPI_PMTT_DOMAIN *DomainArray; 2096 UINT32 Length = Table->Length; 2097 UINT32 Offset = sizeof (ACPI_TABLE_PMTT); 2098 UINT32 MemOffset; 2099 UINT32 DimmOffset; 2100 UINT32 DomainOffset; 2101 UINT32 DomainCount; 2102 2103 2104 /* Main table */ 2105 2106 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); 2107 if (ACPI_FAILURE (Status)) 2108 { 2109 return; 2110 } 2111 2112 /* Subtables */ 2113 2114 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); 2115 while (Offset < Table->Length) 2116 { 2117 /* Common subtable header */ 2118 2119 AcpiOsPrintf ("\n"); 2120 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2121 SubTable->Length, AcpiDmTableInfoPmttHdr); 2122 if (ACPI_FAILURE (Status)) 2123 { 2124 return; 2125 } 2126 2127 /* Only Socket subtables are expected at this level */ 2128 2129 if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET) 2130 { 2131 AcpiOsPrintf ( 2132 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2133 SubTable->Type); 2134 return; 2135 } 2136 2137 /* Dump the fixed-length portion of the subtable */ 2138 2139 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2140 SubTable->Length, AcpiDmTableInfoPmtt0); 2141 if (ACPI_FAILURE (Status)) 2142 { 2143 return; 2144 } 2145 2146 /* Walk the memory controller subtables */ 2147 2148 MemOffset = sizeof (ACPI_PMTT_SOCKET); 2149 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, 2150 sizeof (ACPI_PMTT_SOCKET)); 2151 2152 while (((Offset + MemOffset) < Table->Length) && 2153 (MemOffset < SubTable->Length)) 2154 { 2155 /* Common subtable header */ 2156 2157 AcpiOsPrintf ("\n"); 2158 Status = AcpiDmDumpTable (Length, 2159 Offset + MemOffset, MemSubTable, 2160 MemSubTable->Length, AcpiDmTableInfoPmttHdr); 2161 if (ACPI_FAILURE (Status)) 2162 { 2163 return; 2164 } 2165 2166 /* Only memory controller subtables are expected at this level */ 2167 2168 if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER) 2169 { 2170 AcpiOsPrintf ( 2171 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2172 MemSubTable->Type); 2173 return; 2174 } 2175 2176 /* Dump the fixed-length portion of the controller subtable */ 2177 2178 Status = AcpiDmDumpTable (Length, 2179 Offset + MemOffset, MemSubTable, 2180 MemSubTable->Length, AcpiDmTableInfoPmtt1); 2181 if (ACPI_FAILURE (Status)) 2182 { 2183 return; 2184 } 2185 2186 /* Walk the variable count of proximity domains */ 2187 2188 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount; 2189 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER); 2190 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable, 2191 sizeof (ACPI_PMTT_CONTROLLER)); 2192 2193 while (((Offset + MemOffset + DomainOffset) < Table->Length) && 2194 ((MemOffset + DomainOffset) < SubTable->Length) && 2195 DomainCount) 2196 { 2197 Status = AcpiDmDumpTable (Length, 2198 Offset + MemOffset + DomainOffset, DomainArray, 2199 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a); 2200 if (ACPI_FAILURE (Status)) 2201 { 2202 return; 2203 } 2204 2205 DomainOffset += sizeof (ACPI_PMTT_DOMAIN); 2206 DomainArray++; 2207 DomainCount--; 2208 } 2209 2210 if (DomainCount) 2211 { 2212 AcpiOsPrintf ( 2213 "\n**** DomainCount exceeds subtable length\n\n", 2214 MemSubTable->Type); 2215 } 2216 2217 /* Walk the physical component (DIMM) subtables */ 2218 2219 DimmOffset = DomainOffset; 2220 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable, 2221 DomainOffset); 2222 2223 while (((Offset + MemOffset + DimmOffset) < Table->Length) && 2224 (DimmOffset < MemSubTable->Length)) 2225 { 2226 /* Common subtable header */ 2227 2228 AcpiOsPrintf ("\n"); 2229 Status = AcpiDmDumpTable (Length, 2230 Offset + MemOffset + DimmOffset, DimmSubTable, 2231 DimmSubTable->Length, AcpiDmTableInfoPmttHdr); 2232 if (ACPI_FAILURE (Status)) 2233 { 2234 return; 2235 } 2236 2237 /* Only DIMM subtables are expected at this level */ 2238 2239 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM) 2240 { 2241 AcpiOsPrintf ( 2242 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2243 DimmSubTable->Type); 2244 return; 2245 } 2246 2247 /* Dump the fixed-length DIMM subtable */ 2248 2249 Status = AcpiDmDumpTable (Length, 2250 Offset + MemOffset + DimmOffset, DimmSubTable, 2251 DimmSubTable->Length, AcpiDmTableInfoPmtt2); 2252 if (ACPI_FAILURE (Status)) 2253 { 2254 return; 2255 } 2256 2257 /* Point to next DIMM subtable */ 2258 2259 DimmOffset += DimmSubTable->Length; 2260 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2261 DimmSubTable, DimmSubTable->Length); 2262 } 2263 2264 /* Point to next Controller subtable */ 2265 2266 MemOffset += MemSubTable->Length; 2267 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2268 MemSubTable, MemSubTable->Length); 2269 } 2270 2271 /* Point to next Socket subtable */ 2272 2273 Offset += SubTable->Length; 2274 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2275 SubTable, SubTable->Length); 2276 } 2277 } 2278 2279 2280 /******************************************************************************* 2281 * 2282 * FUNCTION: AcpiDmDumpS3pt 2283 * 2284 * PARAMETERS: Table - A S3PT table 2285 * 2286 * RETURN: Length of the table 2287 * 2288 * DESCRIPTION: Format the contents of a S3PT 2289 * 2290 ******************************************************************************/ 2291 2292 UINT32 2293 AcpiDmDumpS3pt ( 2294 ACPI_TABLE_HEADER *Tables) 2295 { 2296 ACPI_STATUS Status; 2297 UINT32 Offset = sizeof (ACPI_TABLE_S3PT); 2298 ACPI_S3PT_HEADER *SubTable; 2299 ACPI_DMTABLE_INFO *InfoTable; 2300 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); 2301 2302 2303 /* Main table */ 2304 2305 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt); 2306 if (ACPI_FAILURE (Status)) 2307 { 2308 return 0; 2309 } 2310 2311 SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, S3ptTable, Offset); 2312 while (Offset < S3ptTable->Length) 2313 { 2314 /* Common subtable header */ 2315 2316 AcpiOsPrintf ("\n"); 2317 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 2318 SubTable->Length, AcpiDmTableInfoS3ptHdr); 2319 if (ACPI_FAILURE (Status)) 2320 { 2321 return 0; 2322 } 2323 2324 switch (SubTable->Type) 2325 { 2326 case ACPI_S3PT_TYPE_RESUME: 2327 2328 InfoTable = AcpiDmTableInfoS3pt0; 2329 break; 2330 2331 case ACPI_S3PT_TYPE_SUSPEND: 2332 2333 InfoTable = AcpiDmTableInfoS3pt1; 2334 break; 2335 2336 default: 2337 2338 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", SubTable->Type); 2339 2340 /* Attempt to continue */ 2341 2342 if (!SubTable->Length) 2343 { 2344 AcpiOsPrintf ("Invalid zero length subtable\n"); 2345 return 0; 2346 } 2347 goto NextSubTable; 2348 } 2349 2350 AcpiOsPrintf ("\n"); 2351 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 2352 SubTable->Length, InfoTable); 2353 if (ACPI_FAILURE (Status)) 2354 { 2355 return 0; 2356 } 2357 2358 NextSubTable: 2359 /* Point to next subtable */ 2360 2361 Offset += SubTable->Length; 2362 SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, SubTable, SubTable->Length); 2363 } 2364 2365 return (S3ptTable->Length); 2366 } 2367 2368 2369 /******************************************************************************* 2370 * 2371 * FUNCTION: AcpiDmDumpSlic 2372 * 2373 * PARAMETERS: Table - A SLIC table 2374 * 2375 * RETURN: None 2376 * 2377 * DESCRIPTION: Format the contents of a SLIC 2378 * 2379 ******************************************************************************/ 2380 2381 void 2382 AcpiDmDumpSlic ( 2383 ACPI_TABLE_HEADER *Table) 2384 { 2385 ACPI_STATUS Status; 2386 UINT32 Offset = sizeof (ACPI_TABLE_SLIC); 2387 ACPI_SLIC_HEADER *SubTable; 2388 ACPI_DMTABLE_INFO *InfoTable; 2389 2390 2391 /* There is no main SLIC table, only subtables */ 2392 2393 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, Table, Offset); 2394 while (Offset < Table->Length) 2395 { 2396 /* Common subtable header */ 2397 2398 AcpiOsPrintf ("\n"); 2399 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2400 SubTable->Length, AcpiDmTableInfoSlicHdr); 2401 if (ACPI_FAILURE (Status)) 2402 { 2403 return; 2404 } 2405 2406 switch (SubTable->Type) 2407 { 2408 case ACPI_SLIC_TYPE_PUBLIC_KEY: 2409 2410 InfoTable = AcpiDmTableInfoSlic0; 2411 break; 2412 2413 case ACPI_SLIC_TYPE_WINDOWS_MARKER: 2414 2415 InfoTable = AcpiDmTableInfoSlic1; 2416 break; 2417 2418 default: 2419 2420 AcpiOsPrintf ("\n**** Unknown SLIC subtable type 0x%X\n", SubTable->Type); 2421 2422 /* Attempt to continue */ 2423 2424 if (!SubTable->Length) 2425 { 2426 AcpiOsPrintf ("Invalid zero length subtable\n"); 2427 return; 2428 } 2429 goto NextSubTable; 2430 } 2431 2432 AcpiOsPrintf ("\n"); 2433 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2434 SubTable->Length, InfoTable); 2435 if (ACPI_FAILURE (Status)) 2436 { 2437 return; 2438 } 2439 2440 NextSubTable: 2441 /* Point to next subtable */ 2442 2443 Offset += SubTable->Length; 2444 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, SubTable, SubTable->Length); 2445 } 2446 } 2447 2448 2449 /******************************************************************************* 2450 * 2451 * FUNCTION: AcpiDmDumpSlit 2452 * 2453 * PARAMETERS: Table - An SLIT 2454 * 2455 * RETURN: None 2456 * 2457 * DESCRIPTION: Format the contents of a SLIT 2458 * 2459 ******************************************************************************/ 2460 2461 void 2462 AcpiDmDumpSlit ( 2463 ACPI_TABLE_HEADER *Table) 2464 { 2465 ACPI_STATUS Status; 2466 UINT32 Offset; 2467 UINT8 *Row; 2468 UINT32 Localities; 2469 UINT32 i; 2470 UINT32 j; 2471 2472 2473 /* Main table */ 2474 2475 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit); 2476 if (ACPI_FAILURE (Status)) 2477 { 2478 return; 2479 } 2480 2481 /* Display the Locality NxN Matrix */ 2482 2483 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; 2484 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]); 2485 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry; 2486 2487 for (i = 0; i < Localities; i++) 2488 { 2489 /* Display one row of the matrix */ 2490 2491 AcpiDmLineHeader2 (Offset, Localities, "Locality", i); 2492 for (j = 0; j < Localities; j++) 2493 { 2494 /* Check for beyond EOT */ 2495 2496 if (Offset >= Table->Length) 2497 { 2498 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n"); 2499 return; 2500 } 2501 2502 AcpiOsPrintf ("%2.2X", Row[j]); 2503 Offset++; 2504 2505 /* Display up to 16 bytes per output row */ 2506 2507 if ((j+1) < Localities) 2508 { 2509 AcpiOsPrintf (" "); 2510 2511 if (j && (((j+1) % 16) == 0)) 2512 { 2513 AcpiOsPrintf ("\\\n"); /* With line continuation char */ 2514 AcpiDmLineHeader (Offset, 0, NULL); 2515 } 2516 } 2517 } 2518 2519 /* Point to next row */ 2520 2521 AcpiOsPrintf ("\n"); 2522 Row += Localities; 2523 } 2524 } 2525 2526 2527 /******************************************************************************* 2528 * 2529 * FUNCTION: AcpiDmDumpSrat 2530 * 2531 * PARAMETERS: Table - A SRAT table 2532 * 2533 * RETURN: None 2534 * 2535 * DESCRIPTION: Format the contents of a SRAT 2536 * 2537 ******************************************************************************/ 2538 2539 void 2540 AcpiDmDumpSrat ( 2541 ACPI_TABLE_HEADER *Table) 2542 { 2543 ACPI_STATUS Status; 2544 UINT32 Offset = sizeof (ACPI_TABLE_SRAT); 2545 ACPI_SUBTABLE_HEADER *SubTable; 2546 ACPI_DMTABLE_INFO *InfoTable; 2547 2548 2549 /* Main table */ 2550 2551 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat); 2552 if (ACPI_FAILURE (Status)) 2553 { 2554 return; 2555 } 2556 2557 /* Subtables */ 2558 2559 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 2560 while (Offset < Table->Length) 2561 { 2562 /* Common subtable header */ 2563 2564 AcpiOsPrintf ("\n"); 2565 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2566 SubTable->Length, AcpiDmTableInfoSratHdr); 2567 if (ACPI_FAILURE (Status)) 2568 { 2569 return; 2570 } 2571 2572 switch (SubTable->Type) 2573 { 2574 case ACPI_SRAT_TYPE_CPU_AFFINITY: 2575 2576 InfoTable = AcpiDmTableInfoSrat0; 2577 break; 2578 2579 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 2580 2581 InfoTable = AcpiDmTableInfoSrat1; 2582 break; 2583 2584 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 2585 2586 InfoTable = AcpiDmTableInfoSrat2; 2587 break; 2588 2589 default: 2590 AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n", SubTable->Type); 2591 2592 /* Attempt to continue */ 2593 2594 if (!SubTable->Length) 2595 { 2596 AcpiOsPrintf ("Invalid zero length subtable\n"); 2597 return; 2598 } 2599 goto NextSubTable; 2600 } 2601 2602 AcpiOsPrintf ("\n"); 2603 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2604 SubTable->Length, InfoTable); 2605 if (ACPI_FAILURE (Status)) 2606 { 2607 return; 2608 } 2609 2610 NextSubTable: 2611 /* Point to next subtable */ 2612 2613 Offset += SubTable->Length; 2614 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 2615 } 2616 } 2617 2618 2619 /******************************************************************************* 2620 * 2621 * FUNCTION: AcpiDmDumpVrtc 2622 * 2623 * PARAMETERS: Table - A VRTC table 2624 * 2625 * RETURN: None 2626 * 2627 * DESCRIPTION: Format the contents of a VRTC 2628 * 2629 ******************************************************************************/ 2630 2631 void 2632 AcpiDmDumpVrtc ( 2633 ACPI_TABLE_HEADER *Table) 2634 { 2635 ACPI_STATUS Status; 2636 UINT32 Offset = sizeof (ACPI_TABLE_VRTC); 2637 ACPI_VRTC_ENTRY *SubTable; 2638 2639 2640 /* Main table */ 2641 2642 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc); 2643 if (ACPI_FAILURE (Status)) 2644 { 2645 return; 2646 } 2647 2648 /* Subtables */ 2649 2650 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset); 2651 while (Offset < Table->Length) 2652 { 2653 /* Common subtable header */ 2654 2655 AcpiOsPrintf ("\n"); 2656 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2657 sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0); 2658 if (ACPI_FAILURE (Status)) 2659 { 2660 return; 2661 } 2662 2663 /* Point to next subtable */ 2664 2665 Offset += sizeof (ACPI_VRTC_ENTRY); 2666 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable, sizeof (ACPI_VRTC_ENTRY)); 2667 } 2668 } 2669 2670 2671 /******************************************************************************* 2672 * 2673 * FUNCTION: AcpiDmDumpWdat 2674 * 2675 * PARAMETERS: Table - A WDAT table 2676 * 2677 * RETURN: None 2678 * 2679 * DESCRIPTION: Format the contents of a WDAT 2680 * 2681 ******************************************************************************/ 2682 2683 void 2684 AcpiDmDumpWdat ( 2685 ACPI_TABLE_HEADER *Table) 2686 { 2687 ACPI_STATUS Status; 2688 UINT32 Offset = sizeof (ACPI_TABLE_WDAT); 2689 ACPI_WDAT_ENTRY *SubTable; 2690 2691 2692 /* Main table */ 2693 2694 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat); 2695 if (ACPI_FAILURE (Status)) 2696 { 2697 return; 2698 } 2699 2700 /* Subtables */ 2701 2702 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset); 2703 while (Offset < Table->Length) 2704 { 2705 /* Common subtable header */ 2706 2707 AcpiOsPrintf ("\n"); 2708 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2709 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0); 2710 if (ACPI_FAILURE (Status)) 2711 { 2712 return; 2713 } 2714 2715 /* Point to next subtable */ 2716 2717 Offset += sizeof (ACPI_WDAT_ENTRY); 2718 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY)); 2719 } 2720 } 2721