dmtbdump.c revision 250838
1/****************************************************************************** 2 * 3 * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code 4 * 5 *****************************************************************************/ 6 7/* 8 * Copyright (C) 2000 - 2013, 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 <contrib/dev/acpica/include/acpi.h> 45#include <contrib/dev/acpica/include/accommon.h> 46#include <contrib/dev/acpica/include/acdisasm.h> 47#include <contrib/dev/acpica/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 57static void 58AcpiDmValidateFadtLength ( 59 UINT32 Revision, 60 UINT32 Length); 61 62static void 63AcpiDmDumpBuffer ( 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 89static void 90AcpiDmDumpBuffer ( 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 142UINT32 143AcpiDmDumpRsdp ( 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 200void 201AcpiDmDumpRsdt ( 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 240void 241AcpiDmDumpXsdt ( 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 284void 285AcpiDmDumpFadt ( 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 341static void 342AcpiDmValidateFadtLength ( 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 405void 406AcpiDmDumpAsf ( 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 571void 572AcpiDmDumpCpep ( 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 624void 625AcpiDmDumpCsrt ( 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 727void 728AcpiDmDumpDbg2 ( 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 AcpiDmDumpBuffer (SubTable, SubTable->OemDataOffset, SubTable->OemDataLength, 813 Offset + SubTable->OemDataOffset, "OEM Data"); 814 815 /* Point to next sub-table */ 816 817 Offset += SubTable->Length; 818 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable, 819 SubTable->Length); 820 } 821} 822 823 824/******************************************************************************* 825 * 826 * FUNCTION: AcpiDmDumpDmar 827 * 828 * PARAMETERS: Table - A DMAR table 829 * 830 * RETURN: None 831 * 832 * DESCRIPTION: Format the contents of a DMAR. This table type consists 833 * of an open-ended number of subtables. 834 * 835 ******************************************************************************/ 836 837 838void 839AcpiDmDumpDmar ( 840 ACPI_TABLE_HEADER *Table) 841{ 842 ACPI_STATUS Status; 843 ACPI_DMAR_HEADER *SubTable; 844 UINT32 Length = Table->Length; 845 UINT32 Offset = sizeof (ACPI_TABLE_DMAR); 846 ACPI_DMTABLE_INFO *InfoTable; 847 ACPI_DMAR_DEVICE_SCOPE *ScopeTable; 848 UINT32 ScopeOffset; 849 UINT8 *PciPath; 850 UINT32 PathOffset; 851 852 853 /* Main table */ 854 855 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); 856 if (ACPI_FAILURE (Status)) 857 { 858 return; 859 } 860 861 /* Sub-tables */ 862 863 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); 864 while (Offset < Table->Length) 865 { 866 /* Common sub-table header */ 867 868 AcpiOsPrintf ("\n"); 869 Status = AcpiDmDumpTable (Length, Offset, SubTable, 870 SubTable->Length, AcpiDmTableInfoDmarHdr); 871 if (ACPI_FAILURE (Status)) 872 { 873 return; 874 } 875 876 switch (SubTable->Type) 877 { 878 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 879 880 InfoTable = AcpiDmTableInfoDmar0; 881 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT); 882 break; 883 884 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 885 886 InfoTable = AcpiDmTableInfoDmar1; 887 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY); 888 break; 889 890 case ACPI_DMAR_TYPE_ATSR: 891 892 InfoTable = AcpiDmTableInfoDmar2; 893 ScopeOffset = sizeof (ACPI_DMAR_ATSR); 894 break; 895 896 case ACPI_DMAR_HARDWARE_AFFINITY: 897 898 InfoTable = AcpiDmTableInfoDmar3; 899 ScopeOffset = sizeof (ACPI_DMAR_RHSA); 900 break; 901 902 default: 903 904 AcpiOsPrintf ("\n**** Unknown DMAR sub-table type 0x%X\n\n", SubTable->Type); 905 return; 906 } 907 908 Status = AcpiDmDumpTable (Length, Offset, SubTable, 909 SubTable->Length, InfoTable); 910 if (ACPI_FAILURE (Status)) 911 { 912 return; 913 } 914 915 /* Dump the device scope entries (if any) */ 916 917 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset); 918 while (ScopeOffset < SubTable->Length) 919 { 920 AcpiOsPrintf ("\n"); 921 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, 922 ScopeTable->Length, AcpiDmTableInfoDmarScope); 923 if (ACPI_FAILURE (Status)) 924 { 925 return; 926 } 927 928 /* Dump the PCI Path entries for this device scope */ 929 930 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */ 931 932 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable, 933 sizeof (ACPI_DMAR_DEVICE_SCOPE)); 934 935 while (PathOffset < ScopeTable->Length) 936 { 937 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path"); 938 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]); 939 940 /* Point to next PCI Path entry */ 941 942 PathOffset += 2; 943 PciPath += 2; 944 } 945 946 /* Point to next device scope entry */ 947 948 ScopeOffset += ScopeTable->Length; 949 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, 950 ScopeTable, ScopeTable->Length); 951 } 952 953 /* Point to next sub-table */ 954 955 Offset += SubTable->Length; 956 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length); 957 } 958} 959 960 961/******************************************************************************* 962 * 963 * FUNCTION: AcpiDmDumpEinj 964 * 965 * PARAMETERS: Table - A EINJ table 966 * 967 * RETURN: None 968 * 969 * DESCRIPTION: Format the contents of a EINJ. This table type consists 970 * of an open-ended number of subtables. 971 * 972 ******************************************************************************/ 973 974void 975AcpiDmDumpEinj ( 976 ACPI_TABLE_HEADER *Table) 977{ 978 ACPI_STATUS Status; 979 ACPI_WHEA_HEADER *SubTable; 980 UINT32 Length = Table->Length; 981 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 982 983 984 /* Main table */ 985 986 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 987 if (ACPI_FAILURE (Status)) 988 { 989 return; 990 } 991 992 /* Sub-tables */ 993 994 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 995 while (Offset < Table->Length) 996 { 997 AcpiOsPrintf ("\n"); 998 Status = AcpiDmDumpTable (Length, Offset, SubTable, 999 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 1000 if (ACPI_FAILURE (Status)) 1001 { 1002 return; 1003 } 1004 1005 /* Point to next sub-table (each subtable is of fixed length) */ 1006 1007 Offset += sizeof (ACPI_WHEA_HEADER); 1008 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 1009 sizeof (ACPI_WHEA_HEADER)); 1010 } 1011} 1012 1013 1014/******************************************************************************* 1015 * 1016 * FUNCTION: AcpiDmDumpErst 1017 * 1018 * PARAMETERS: Table - A ERST table 1019 * 1020 * RETURN: None 1021 * 1022 * DESCRIPTION: Format the contents of a ERST. This table type consists 1023 * of an open-ended number of subtables. 1024 * 1025 ******************************************************************************/ 1026 1027void 1028AcpiDmDumpErst ( 1029 ACPI_TABLE_HEADER *Table) 1030{ 1031 ACPI_STATUS Status; 1032 ACPI_WHEA_HEADER *SubTable; 1033 UINT32 Length = Table->Length; 1034 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 1035 1036 1037 /* Main table */ 1038 1039 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 1040 if (ACPI_FAILURE (Status)) 1041 { 1042 return; 1043 } 1044 1045 /* Sub-tables */ 1046 1047 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1048 while (Offset < Table->Length) 1049 { 1050 AcpiOsPrintf ("\n"); 1051 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1052 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0); 1053 if (ACPI_FAILURE (Status)) 1054 { 1055 return; 1056 } 1057 1058 /* Point to next sub-table (each subtable is of fixed length) */ 1059 1060 Offset += sizeof (ACPI_WHEA_HEADER); 1061 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 1062 sizeof (ACPI_WHEA_HEADER)); 1063 } 1064} 1065 1066 1067/******************************************************************************* 1068 * 1069 * FUNCTION: AcpiDmDumpFpdt 1070 * 1071 * PARAMETERS: Table - A FPDT table 1072 * 1073 * RETURN: None 1074 * 1075 * DESCRIPTION: Format the contents of a FPDT. This table type consists 1076 * of an open-ended number of subtables. 1077 * 1078 ******************************************************************************/ 1079 1080void 1081AcpiDmDumpFpdt ( 1082 ACPI_TABLE_HEADER *Table) 1083{ 1084 ACPI_STATUS Status; 1085 ACPI_FPDT_HEADER *SubTable; 1086 UINT32 Length = Table->Length; 1087 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 1088 ACPI_DMTABLE_INFO *InfoTable; 1089 1090 1091 /* There is no main table (other than the standard ACPI header) */ 1092 1093 /* Sub-tables */ 1094 1095 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); 1096 while (Offset < Table->Length) 1097 { 1098 /* Common sub-table header */ 1099 1100 AcpiOsPrintf ("\n"); 1101 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1102 SubTable->Length, AcpiDmTableInfoFpdtHdr); 1103 if (ACPI_FAILURE (Status)) 1104 { 1105 return; 1106 } 1107 1108 switch (SubTable->Type) 1109 { 1110 case ACPI_FPDT_TYPE_BOOT: 1111 1112 InfoTable = AcpiDmTableInfoFpdt0; 1113 break; 1114 1115 case ACPI_FPDT_TYPE_S3PERF: 1116 1117 InfoTable = AcpiDmTableInfoFpdt1; 1118 break; 1119 1120 default: 1121 1122 AcpiOsPrintf ("\n**** Unknown FPDT sub-table type 0x%X\n\n", SubTable->Type); 1123 1124 /* Attempt to continue */ 1125 1126 if (!SubTable->Length) 1127 { 1128 AcpiOsPrintf ("Invalid zero length subtable\n"); 1129 return; 1130 } 1131 goto NextSubTable; 1132 } 1133 1134 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1135 SubTable->Length, InfoTable); 1136 if (ACPI_FAILURE (Status)) 1137 { 1138 return; 1139 } 1140 1141NextSubTable: 1142 /* Point to next sub-table */ 1143 1144 Offset += SubTable->Length; 1145 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length); 1146 } 1147} 1148 1149 1150/******************************************************************************* 1151 * 1152 * FUNCTION: AcpiDmDumpHest 1153 * 1154 * PARAMETERS: Table - A HEST table 1155 * 1156 * RETURN: None 1157 * 1158 * DESCRIPTION: Format the contents of a HEST. This table type consists 1159 * of an open-ended number of subtables. 1160 * 1161 ******************************************************************************/ 1162 1163void 1164AcpiDmDumpHest ( 1165 ACPI_TABLE_HEADER *Table) 1166{ 1167 ACPI_STATUS Status; 1168 ACPI_HEST_HEADER *SubTable; 1169 UINT32 Length = Table->Length; 1170 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 1171 ACPI_DMTABLE_INFO *InfoTable; 1172 UINT32 SubTableLength; 1173 UINT32 BankCount; 1174 ACPI_HEST_IA_ERROR_BANK *BankTable; 1175 1176 1177 /* Main table */ 1178 1179 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 1180 if (ACPI_FAILURE (Status)) 1181 { 1182 return; 1183 } 1184 1185 /* Sub-tables */ 1186 1187 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 1188 while (Offset < Table->Length) 1189 { 1190 BankCount = 0; 1191 switch (SubTable->Type) 1192 { 1193 case ACPI_HEST_TYPE_IA32_CHECK: 1194 1195 InfoTable = AcpiDmTableInfoHest0; 1196 SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK); 1197 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 1198 SubTable))->NumHardwareBanks; 1199 break; 1200 1201 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 1202 1203 InfoTable = AcpiDmTableInfoHest1; 1204 SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED); 1205 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 1206 SubTable))->NumHardwareBanks; 1207 break; 1208 1209 case ACPI_HEST_TYPE_IA32_NMI: 1210 1211 InfoTable = AcpiDmTableInfoHest2; 1212 SubTableLength = sizeof (ACPI_HEST_IA_NMI); 1213 break; 1214 1215 case ACPI_HEST_TYPE_AER_ROOT_PORT: 1216 1217 InfoTable = AcpiDmTableInfoHest6; 1218 SubTableLength = sizeof (ACPI_HEST_AER_ROOT); 1219 break; 1220 1221 case ACPI_HEST_TYPE_AER_ENDPOINT: 1222 1223 InfoTable = AcpiDmTableInfoHest7; 1224 SubTableLength = sizeof (ACPI_HEST_AER); 1225 break; 1226 1227 case ACPI_HEST_TYPE_AER_BRIDGE: 1228 1229 InfoTable = AcpiDmTableInfoHest8; 1230 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE); 1231 break; 1232 1233 case ACPI_HEST_TYPE_GENERIC_ERROR: 1234 1235 InfoTable = AcpiDmTableInfoHest9; 1236 SubTableLength = sizeof (ACPI_HEST_GENERIC); 1237 break; 1238 1239 default: 1240 1241 /* Cannot continue on unknown type - no length */ 1242 1243 AcpiOsPrintf ("\n**** Unknown HEST sub-table type 0x%X\n", SubTable->Type); 1244 return; 1245 } 1246 1247 AcpiOsPrintf ("\n"); 1248 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1249 SubTableLength, InfoTable); 1250 if (ACPI_FAILURE (Status)) 1251 { 1252 return; 1253 } 1254 1255 /* Point to end of current subtable (each subtable above is of fixed length) */ 1256 1257 Offset += SubTableLength; 1258 1259 /* If there are any (fixed-length) Error Banks from above, dump them now */ 1260 1261 if (BankCount) 1262 { 1263 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength); 1264 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 1265 1266 while (BankCount) 1267 { 1268 AcpiOsPrintf ("\n"); 1269 Status = AcpiDmDumpTable (Length, Offset, BankTable, 1270 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 1271 if (ACPI_FAILURE (Status)) 1272 { 1273 return; 1274 } 1275 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 1276 BankTable++; 1277 BankCount--; 1278 } 1279 } 1280 1281 /* Point to next sub-table */ 1282 1283 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength); 1284 } 1285} 1286 1287 1288/******************************************************************************* 1289 * 1290 * FUNCTION: AcpiDmDumpIvrs 1291 * 1292 * PARAMETERS: Table - A IVRS table 1293 * 1294 * RETURN: None 1295 * 1296 * DESCRIPTION: Format the contents of a IVRS 1297 * 1298 ******************************************************************************/ 1299 1300static UINT8 EntrySizes[] = {4,8,16,32}; 1301 1302void 1303AcpiDmDumpIvrs ( 1304 ACPI_TABLE_HEADER *Table) 1305{ 1306 ACPI_STATUS Status; 1307 UINT32 Offset = sizeof (ACPI_TABLE_IVRS); 1308 UINT32 EntryOffset; 1309 UINT32 EntryLength; 1310 UINT32 EntryType; 1311 ACPI_IVRS_DE_HEADER *DeviceEntry; 1312 ACPI_IVRS_HEADER *SubTable; 1313 ACPI_DMTABLE_INFO *InfoTable; 1314 1315 1316 /* Main table */ 1317 1318 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); 1319 if (ACPI_FAILURE (Status)) 1320 { 1321 return; 1322 } 1323 1324 /* Sub-tables */ 1325 1326 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); 1327 while (Offset < Table->Length) 1328 { 1329 /* Common sub-table header */ 1330 1331 AcpiOsPrintf ("\n"); 1332 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1333 SubTable->Length, AcpiDmTableInfoIvrsHdr); 1334 if (ACPI_FAILURE (Status)) 1335 { 1336 return; 1337 } 1338 1339 switch (SubTable->Type) 1340 { 1341 case ACPI_IVRS_TYPE_HARDWARE: 1342 1343 InfoTable = AcpiDmTableInfoIvrs0; 1344 break; 1345 1346 case ACPI_IVRS_TYPE_MEMORY1: 1347 case ACPI_IVRS_TYPE_MEMORY2: 1348 case ACPI_IVRS_TYPE_MEMORY3: 1349 1350 InfoTable = AcpiDmTableInfoIvrs1; 1351 break; 1352 1353 default: 1354 1355 AcpiOsPrintf ("\n**** Unknown IVRS sub-table type 0x%X\n", 1356 SubTable->Type); 1357 1358 /* Attempt to continue */ 1359 1360 if (!SubTable->Length) 1361 { 1362 AcpiOsPrintf ("Invalid zero length subtable\n"); 1363 return; 1364 } 1365 goto NextSubTable; 1366 } 1367 1368 /* Dump the subtable */ 1369 1370 AcpiOsPrintf ("\n"); 1371 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1372 SubTable->Length, InfoTable); 1373 if (ACPI_FAILURE (Status)) 1374 { 1375 return; 1376 } 1377 1378 /* The hardware subtable can contain multiple device entries */ 1379 1380 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE) 1381 { 1382 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE); 1383 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable, 1384 sizeof (ACPI_IVRS_HARDWARE)); 1385 1386 while (EntryOffset < (Offset + SubTable->Length)) 1387 { 1388 AcpiOsPrintf ("\n"); 1389 /* 1390 * Upper 2 bits of Type encode the length of the device entry 1391 * 1392 * 00 = 4 byte 1393 * 01 = 8 byte 1394 * 10 = 16 byte - currently no entries defined 1395 * 11 = 32 byte - currently no entries defined 1396 */ 1397 EntryType = DeviceEntry->Type; 1398 EntryLength = EntrySizes [EntryType >> 6]; 1399 1400 switch (EntryType) 1401 { 1402 /* 4-byte device entries */ 1403 1404 case ACPI_IVRS_TYPE_PAD4: 1405 case ACPI_IVRS_TYPE_ALL: 1406 case ACPI_IVRS_TYPE_SELECT: 1407 case ACPI_IVRS_TYPE_START: 1408 case ACPI_IVRS_TYPE_END: 1409 1410 InfoTable = AcpiDmTableInfoIvrs4; 1411 break; 1412 1413 /* 8-byte entries, type A */ 1414 1415 case ACPI_IVRS_TYPE_ALIAS_SELECT: 1416 case ACPI_IVRS_TYPE_ALIAS_START: 1417 1418 InfoTable = AcpiDmTableInfoIvrs8a; 1419 break; 1420 1421 /* 8-byte entries, type B */ 1422 1423 case ACPI_IVRS_TYPE_PAD8: 1424 case ACPI_IVRS_TYPE_EXT_SELECT: 1425 case ACPI_IVRS_TYPE_EXT_START: 1426 1427 InfoTable = AcpiDmTableInfoIvrs8b; 1428 break; 1429 1430 /* 8-byte entries, type C */ 1431 1432 case ACPI_IVRS_TYPE_SPECIAL: 1433 1434 InfoTable = AcpiDmTableInfoIvrs8c; 1435 break; 1436 1437 default: 1438 InfoTable = AcpiDmTableInfoIvrs4; 1439 AcpiOsPrintf ( 1440 "\n**** Unknown IVRS device entry type/length: " 1441 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n", 1442 EntryType, EntryLength, EntryOffset); 1443 break; 1444 } 1445 1446 /* Dump the Device Entry */ 1447 1448 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 1449 DeviceEntry, EntryLength, InfoTable); 1450 1451 EntryOffset += EntryLength; 1452 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry, 1453 EntryLength); 1454 } 1455 } 1456 1457NextSubTable: 1458 /* Point to next sub-table */ 1459 1460 Offset += SubTable->Length; 1461 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length); 1462 } 1463} 1464 1465 1466/******************************************************************************* 1467 * 1468 * FUNCTION: AcpiDmDumpMadt 1469 * 1470 * PARAMETERS: Table - A MADT table 1471 * 1472 * RETURN: None 1473 * 1474 * DESCRIPTION: Format the contents of a MADT. This table type consists 1475 * of an open-ended number of subtables. 1476 * 1477 ******************************************************************************/ 1478 1479void 1480AcpiDmDumpMadt ( 1481 ACPI_TABLE_HEADER *Table) 1482{ 1483 ACPI_STATUS Status; 1484 ACPI_SUBTABLE_HEADER *SubTable; 1485 UINT32 Length = Table->Length; 1486 UINT32 Offset = sizeof (ACPI_TABLE_MADT); 1487 ACPI_DMTABLE_INFO *InfoTable; 1488 1489 1490 /* Main table */ 1491 1492 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); 1493 if (ACPI_FAILURE (Status)) 1494 { 1495 return; 1496 } 1497 1498 /* Sub-tables */ 1499 1500 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 1501 while (Offset < Table->Length) 1502 { 1503 /* Common sub-table header */ 1504 1505 AcpiOsPrintf ("\n"); 1506 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1507 SubTable->Length, AcpiDmTableInfoMadtHdr); 1508 if (ACPI_FAILURE (Status)) 1509 { 1510 return; 1511 } 1512 1513 switch (SubTable->Type) 1514 { 1515 case ACPI_MADT_TYPE_LOCAL_APIC: 1516 1517 InfoTable = AcpiDmTableInfoMadt0; 1518 break; 1519 1520 case ACPI_MADT_TYPE_IO_APIC: 1521 1522 InfoTable = AcpiDmTableInfoMadt1; 1523 break; 1524 1525 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 1526 1527 InfoTable = AcpiDmTableInfoMadt2; 1528 break; 1529 1530 case ACPI_MADT_TYPE_NMI_SOURCE: 1531 1532 InfoTable = AcpiDmTableInfoMadt3; 1533 break; 1534 1535 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 1536 1537 InfoTable = AcpiDmTableInfoMadt4; 1538 break; 1539 1540 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 1541 1542 InfoTable = AcpiDmTableInfoMadt5; 1543 break; 1544 1545 case ACPI_MADT_TYPE_IO_SAPIC: 1546 1547 InfoTable = AcpiDmTableInfoMadt6; 1548 break; 1549 1550 case ACPI_MADT_TYPE_LOCAL_SAPIC: 1551 1552 InfoTable = AcpiDmTableInfoMadt7; 1553 break; 1554 1555 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 1556 1557 InfoTable = AcpiDmTableInfoMadt8; 1558 break; 1559 1560 case ACPI_MADT_TYPE_LOCAL_X2APIC: 1561 1562 InfoTable = AcpiDmTableInfoMadt9; 1563 break; 1564 1565 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 1566 1567 InfoTable = AcpiDmTableInfoMadt10; 1568 break; 1569 1570 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 1571 1572 InfoTable = AcpiDmTableInfoMadt11; 1573 break; 1574 1575 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 1576 1577 InfoTable = AcpiDmTableInfoMadt12; 1578 break; 1579 1580 default: 1581 1582 AcpiOsPrintf ("\n**** Unknown MADT sub-table type 0x%X\n\n", SubTable->Type); 1583 1584 /* Attempt to continue */ 1585 1586 if (!SubTable->Length) 1587 { 1588 AcpiOsPrintf ("Invalid zero length subtable\n"); 1589 return; 1590 } 1591 goto NextSubTable; 1592 } 1593 1594 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1595 SubTable->Length, InfoTable); 1596 if (ACPI_FAILURE (Status)) 1597 { 1598 return; 1599 } 1600 1601NextSubTable: 1602 /* Point to next sub-table */ 1603 1604 Offset += SubTable->Length; 1605 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 1606 } 1607} 1608 1609 1610/******************************************************************************* 1611 * 1612 * FUNCTION: AcpiDmDumpMcfg 1613 * 1614 * PARAMETERS: Table - A MCFG Table 1615 * 1616 * RETURN: None 1617 * 1618 * DESCRIPTION: Format the contents of a MCFG table 1619 * 1620 ******************************************************************************/ 1621 1622void 1623AcpiDmDumpMcfg ( 1624 ACPI_TABLE_HEADER *Table) 1625{ 1626 ACPI_STATUS Status; 1627 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 1628 ACPI_MCFG_ALLOCATION *SubTable; 1629 1630 1631 /* Main table */ 1632 1633 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 1634 if (ACPI_FAILURE (Status)) 1635 { 1636 return; 1637 } 1638 1639 /* Sub-tables */ 1640 1641 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 1642 while (Offset < Table->Length) 1643 { 1644 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 1645 { 1646 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", 1647 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 1648 return; 1649 } 1650 1651 AcpiOsPrintf ("\n"); 1652 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1653 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 1654 if (ACPI_FAILURE (Status)) 1655 { 1656 return; 1657 } 1658 1659 /* Point to next sub-table (each subtable is of fixed length) */ 1660 1661 Offset += sizeof (ACPI_MCFG_ALLOCATION); 1662 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable, 1663 sizeof (ACPI_MCFG_ALLOCATION)); 1664 } 1665} 1666 1667 1668/******************************************************************************* 1669 * 1670 * FUNCTION: AcpiDmDumpMpst 1671 * 1672 * PARAMETERS: Table - A MPST Table 1673 * 1674 * RETURN: None 1675 * 1676 * DESCRIPTION: Format the contents of a MPST table 1677 * 1678 ******************************************************************************/ 1679 1680void 1681AcpiDmDumpMpst ( 1682 ACPI_TABLE_HEADER *Table) 1683{ 1684 ACPI_STATUS Status; 1685 UINT32 Offset = sizeof (ACPI_TABLE_MPST); 1686 ACPI_MPST_POWER_NODE *SubTable0; 1687 ACPI_MPST_POWER_STATE *SubTable0A; 1688 ACPI_MPST_COMPONENT *SubTable0B; 1689 ACPI_MPST_DATA_HDR *SubTable1; 1690 ACPI_MPST_POWER_DATA *SubTable2; 1691 UINT16 SubtableCount; 1692 UINT32 PowerStateCount; 1693 UINT32 ComponentCount; 1694 1695 1696 /* Main table */ 1697 1698 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); 1699 if (ACPI_FAILURE (Status)) 1700 { 1701 return; 1702 } 1703 1704 /* Subtable: Memory Power Node(s) */ 1705 1706 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; 1707 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); 1708 1709 while ((Offset < Table->Length) && SubtableCount) 1710 { 1711 AcpiOsPrintf ("\n"); 1712 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0, 1713 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); 1714 if (ACPI_FAILURE (Status)) 1715 { 1716 return; 1717 } 1718 1719 /* Extract the sub-subtable counts */ 1720 1721 PowerStateCount = SubTable0->NumPowerStates; 1722 ComponentCount = SubTable0->NumPhysicalComponents; 1723 Offset += sizeof (ACPI_MPST_POWER_NODE); 1724 1725 /* Sub-subtables - Memory Power State Structure(s) */ 1726 1727 SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0, 1728 sizeof (ACPI_MPST_POWER_NODE)); 1729 1730 while (PowerStateCount) 1731 { 1732 AcpiOsPrintf ("\n"); 1733 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A, 1734 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); 1735 if (ACPI_FAILURE (Status)) 1736 { 1737 return; 1738 } 1739 1740 SubTable0A++; 1741 PowerStateCount--; 1742 Offset += sizeof (ACPI_MPST_POWER_STATE); 1743 } 1744 1745 /* Sub-subtables - Physical Component ID Structure(s) */ 1746 1747 SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A); 1748 1749 if (ComponentCount) 1750 { 1751 AcpiOsPrintf ("\n"); 1752 } 1753 1754 while (ComponentCount) 1755 { 1756 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B, 1757 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); 1758 if (ACPI_FAILURE (Status)) 1759 { 1760 return; 1761 } 1762 1763 SubTable0B++; 1764 ComponentCount--; 1765 Offset += sizeof (ACPI_MPST_COMPONENT); 1766 } 1767 1768 /* Point to next Memory Power Node subtable */ 1769 1770 SubtableCount--; 1771 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0, 1772 sizeof (ACPI_MPST_POWER_NODE) + 1773 (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) + 1774 (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents)); 1775 } 1776 1777 /* Subtable: Count of Memory Power State Characteristic structures */ 1778 1779 AcpiOsPrintf ("\n"); 1780 SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0); 1781 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1, 1782 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); 1783 if (ACPI_FAILURE (Status)) 1784 { 1785 return; 1786 } 1787 1788 SubtableCount = SubTable1->CharacteristicsCount; 1789 Offset += sizeof (ACPI_MPST_DATA_HDR); 1790 1791 /* Subtable: Memory Power State Characteristics structure(s) */ 1792 1793 SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, sizeof (ACPI_MPST_DATA_HDR)); 1794 1795 while ((Offset < Table->Length) && SubtableCount) 1796 { 1797 AcpiOsPrintf ("\n"); 1798 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2, 1799 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); 1800 if (ACPI_FAILURE (Status)) 1801 { 1802 return; 1803 } 1804 1805 SubTable2++; 1806 SubtableCount--; 1807 Offset += sizeof (ACPI_MPST_POWER_DATA); 1808 } 1809} 1810 1811 1812/******************************************************************************* 1813 * 1814 * FUNCTION: AcpiDmDumpMsct 1815 * 1816 * PARAMETERS: Table - A MSCT table 1817 * 1818 * RETURN: None 1819 * 1820 * DESCRIPTION: Format the contents of a MSCT 1821 * 1822 ******************************************************************************/ 1823 1824void 1825AcpiDmDumpMsct ( 1826 ACPI_TABLE_HEADER *Table) 1827{ 1828 ACPI_STATUS Status; 1829 UINT32 Offset = sizeof (ACPI_TABLE_MSCT); 1830 ACPI_MSCT_PROXIMITY *SubTable; 1831 1832 1833 /* Main table */ 1834 1835 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); 1836 if (ACPI_FAILURE (Status)) 1837 { 1838 return; 1839 } 1840 1841 /* Sub-tables */ 1842 1843 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); 1844 while (Offset < Table->Length) 1845 { 1846 /* Common sub-table header */ 1847 1848 AcpiOsPrintf ("\n"); 1849 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1850 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); 1851 if (ACPI_FAILURE (Status)) 1852 { 1853 return; 1854 } 1855 1856 /* Point to next sub-table */ 1857 1858 Offset += sizeof (ACPI_MSCT_PROXIMITY); 1859 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY)); 1860 } 1861} 1862 1863 1864/******************************************************************************* 1865 * 1866 * FUNCTION: AcpiDmDumpMtmr 1867 * 1868 * PARAMETERS: Table - A MTMR table 1869 * 1870 * RETURN: None 1871 * 1872 * DESCRIPTION: Format the contents of a MTMR 1873 * 1874 ******************************************************************************/ 1875 1876void 1877AcpiDmDumpMtmr ( 1878 ACPI_TABLE_HEADER *Table) 1879{ 1880 ACPI_STATUS Status; 1881 UINT32 Offset = sizeof (ACPI_TABLE_MTMR); 1882 ACPI_MTMR_ENTRY *SubTable; 1883 1884 1885 /* Main table */ 1886 1887 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr); 1888 if (ACPI_FAILURE (Status)) 1889 { 1890 return; 1891 } 1892 1893 /* Sub-tables */ 1894 1895 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset); 1896 while (Offset < Table->Length) 1897 { 1898 /* Common sub-table header */ 1899 1900 AcpiOsPrintf ("\n"); 1901 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1902 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0); 1903 if (ACPI_FAILURE (Status)) 1904 { 1905 return; 1906 } 1907 1908 /* Point to next sub-table */ 1909 1910 Offset += sizeof (ACPI_MTMR_ENTRY); 1911 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable, sizeof (ACPI_MTMR_ENTRY)); 1912 } 1913} 1914 1915 1916/******************************************************************************* 1917 * 1918 * FUNCTION: AcpiDmDumpPcct 1919 * 1920 * PARAMETERS: Table - A PCCT table 1921 * 1922 * RETURN: None 1923 * 1924 * DESCRIPTION: Format the contents of a PCCT. This table type consists 1925 * of an open-ended number of subtables. 1926 * 1927 ******************************************************************************/ 1928 1929void 1930AcpiDmDumpPcct ( 1931 ACPI_TABLE_HEADER *Table) 1932{ 1933 ACPI_STATUS Status; 1934 ACPI_PCCT_SUBSPACE *SubTable; 1935 UINT32 Length = Table->Length; 1936 UINT32 Offset = sizeof (ACPI_TABLE_PCCT); 1937 1938 1939 /* Main table */ 1940 1941 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); 1942 if (ACPI_FAILURE (Status)) 1943 { 1944 return; 1945 } 1946 1947 /* Sub-tables */ 1948 1949 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); 1950 while (Offset < Table->Length) 1951 { 1952 AcpiOsPrintf ("\n"); 1953 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1954 SubTable->Header.Length, AcpiDmTableInfoPcct0); 1955 if (ACPI_FAILURE (Status)) 1956 { 1957 return; 1958 } 1959 1960 /* Point to next sub-table */ 1961 1962 Offset += SubTable->Header.Length; 1963 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable, 1964 SubTable->Header.Length); 1965 } 1966} 1967 1968 1969/******************************************************************************* 1970 * 1971 * FUNCTION: AcpiDmDumpPmtt 1972 * 1973 * PARAMETERS: Table - A PMTT table 1974 * 1975 * RETURN: None 1976 * 1977 * DESCRIPTION: Format the contents of a PMTT. This table type consists 1978 * of an open-ended number of subtables. 1979 * 1980 ******************************************************************************/ 1981 1982void 1983AcpiDmDumpPmtt ( 1984 ACPI_TABLE_HEADER *Table) 1985{ 1986 ACPI_STATUS Status; 1987 ACPI_PMTT_HEADER *SubTable; 1988 ACPI_PMTT_HEADER *MemSubTable; 1989 ACPI_PMTT_HEADER *DimmSubTable; 1990 ACPI_PMTT_DOMAIN *DomainArray; 1991 UINT32 Length = Table->Length; 1992 UINT32 Offset = sizeof (ACPI_TABLE_PMTT); 1993 UINT32 MemOffset; 1994 UINT32 DimmOffset; 1995 UINT32 DomainOffset; 1996 UINT32 DomainCount; 1997 1998 1999 /* Main table */ 2000 2001 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); 2002 if (ACPI_FAILURE (Status)) 2003 { 2004 return; 2005 } 2006 2007 /* Subtables */ 2008 2009 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); 2010 while (Offset < Table->Length) 2011 { 2012 /* Common subtable header */ 2013 2014 AcpiOsPrintf ("\n"); 2015 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2016 SubTable->Length, AcpiDmTableInfoPmttHdr); 2017 if (ACPI_FAILURE (Status)) 2018 { 2019 return; 2020 } 2021 2022 /* Only Socket subtables are expected at this level */ 2023 2024 if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET) 2025 { 2026 AcpiOsPrintf ( 2027 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2028 SubTable->Type); 2029 return; 2030 } 2031 2032 /* Dump the fixed-length portion of the subtable */ 2033 2034 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2035 SubTable->Length, AcpiDmTableInfoPmtt0); 2036 if (ACPI_FAILURE (Status)) 2037 { 2038 return; 2039 } 2040 2041 /* Walk the memory controller subtables */ 2042 2043 MemOffset = sizeof (ACPI_PMTT_SOCKET); 2044 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, 2045 sizeof (ACPI_PMTT_SOCKET)); 2046 2047 while (((Offset + MemOffset) < Table->Length) && 2048 (MemOffset < SubTable->Length)) 2049 { 2050 /* Common subtable header */ 2051 2052 AcpiOsPrintf ("\n"); 2053 Status = AcpiDmDumpTable (Length, 2054 Offset + MemOffset, MemSubTable, 2055 MemSubTable->Length, AcpiDmTableInfoPmttHdr); 2056 if (ACPI_FAILURE (Status)) 2057 { 2058 return; 2059 } 2060 2061 /* Only memory controller subtables are expected at this level */ 2062 2063 if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER) 2064 { 2065 AcpiOsPrintf ( 2066 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2067 MemSubTable->Type); 2068 return; 2069 } 2070 2071 /* Dump the fixed-length portion of the controller subtable */ 2072 2073 Status = AcpiDmDumpTable (Length, 2074 Offset + MemOffset, MemSubTable, 2075 MemSubTable->Length, AcpiDmTableInfoPmtt1); 2076 if (ACPI_FAILURE (Status)) 2077 { 2078 return; 2079 } 2080 2081 /* Walk the variable count of proximity domains */ 2082 2083 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount; 2084 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER); 2085 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable, 2086 sizeof (ACPI_PMTT_CONTROLLER)); 2087 2088 while (((Offset + MemOffset + DomainOffset) < Table->Length) && 2089 ((MemOffset + DomainOffset) < SubTable->Length) && 2090 DomainCount) 2091 { 2092 Status = AcpiDmDumpTable (Length, 2093 Offset + MemOffset + DomainOffset, DomainArray, 2094 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a); 2095 if (ACPI_FAILURE (Status)) 2096 { 2097 return; 2098 } 2099 2100 DomainOffset += sizeof (ACPI_PMTT_DOMAIN); 2101 DomainArray++; 2102 DomainCount--; 2103 } 2104 2105 if (DomainCount) 2106 { 2107 AcpiOsPrintf ( 2108 "\n**** DomainCount exceeds subtable length\n\n", 2109 MemSubTable->Type); 2110 } 2111 2112 /* Walk the physical component (DIMM) subtables */ 2113 2114 DimmOffset = DomainOffset; 2115 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable, 2116 DomainOffset); 2117 2118 while (((Offset + MemOffset + DimmOffset) < Table->Length) && 2119 (DimmOffset < MemSubTable->Length)) 2120 { 2121 /* Common subtable header */ 2122 2123 AcpiOsPrintf ("\n"); 2124 Status = AcpiDmDumpTable (Length, 2125 Offset + MemOffset + DimmOffset, DimmSubTable, 2126 DimmSubTable->Length, AcpiDmTableInfoPmttHdr); 2127 if (ACPI_FAILURE (Status)) 2128 { 2129 return; 2130 } 2131 2132 /* Only DIMM subtables are expected at this level */ 2133 2134 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM) 2135 { 2136 AcpiOsPrintf ( 2137 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2138 DimmSubTable->Type); 2139 return; 2140 } 2141 2142 /* Dump the fixed-length DIMM subtable */ 2143 2144 Status = AcpiDmDumpTable (Length, 2145 Offset + MemOffset + DimmOffset, DimmSubTable, 2146 DimmSubTable->Length, AcpiDmTableInfoPmtt2); 2147 if (ACPI_FAILURE (Status)) 2148 { 2149 return; 2150 } 2151 2152 /* Point to next DIMM subtable */ 2153 2154 DimmOffset += DimmSubTable->Length; 2155 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2156 DimmSubTable, DimmSubTable->Length); 2157 } 2158 2159 /* Point to next Controller subtable */ 2160 2161 MemOffset += MemSubTable->Length; 2162 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2163 MemSubTable, MemSubTable->Length); 2164 } 2165 2166 /* Point to next Socket subtable */ 2167 2168 Offset += SubTable->Length; 2169 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2170 SubTable, SubTable->Length); 2171 } 2172} 2173 2174 2175/******************************************************************************* 2176 * 2177 * FUNCTION: AcpiDmDumpS3pt 2178 * 2179 * PARAMETERS: Table - A S3PT table 2180 * 2181 * RETURN: Length of the table 2182 * 2183 * DESCRIPTION: Format the contents of a S3PT 2184 * 2185 ******************************************************************************/ 2186 2187UINT32 2188AcpiDmDumpS3pt ( 2189 ACPI_TABLE_HEADER *Tables) 2190{ 2191 ACPI_STATUS Status; 2192 UINT32 Offset = sizeof (ACPI_TABLE_S3PT); 2193 ACPI_S3PT_HEADER *SubTable; 2194 ACPI_DMTABLE_INFO *InfoTable; 2195 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); 2196 2197 2198 /* Main table */ 2199 2200 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt); 2201 if (ACPI_FAILURE (Status)) 2202 { 2203 return 0; 2204 } 2205 2206 SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, S3ptTable, Offset); 2207 while (Offset < S3ptTable->Length) 2208 { 2209 /* Common sub-table header */ 2210 2211 AcpiOsPrintf ("\n"); 2212 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 2213 SubTable->Length, AcpiDmTableInfoS3ptHdr); 2214 if (ACPI_FAILURE (Status)) 2215 { 2216 return 0; 2217 } 2218 2219 switch (SubTable->Type) 2220 { 2221 case ACPI_S3PT_TYPE_RESUME: 2222 2223 InfoTable = AcpiDmTableInfoS3pt0; 2224 break; 2225 2226 case ACPI_S3PT_TYPE_SUSPEND: 2227 2228 InfoTable = AcpiDmTableInfoS3pt1; 2229 break; 2230 2231 default: 2232 2233 AcpiOsPrintf ("\n**** Unknown S3PT sub-table type 0x%X\n", SubTable->Type); 2234 2235 /* Attempt to continue */ 2236 2237 if (!SubTable->Length) 2238 { 2239 AcpiOsPrintf ("Invalid zero length subtable\n"); 2240 return 0; 2241 } 2242 goto NextSubTable; 2243 } 2244 2245 AcpiOsPrintf ("\n"); 2246 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 2247 SubTable->Length, InfoTable); 2248 if (ACPI_FAILURE (Status)) 2249 { 2250 return 0; 2251 } 2252 2253NextSubTable: 2254 /* Point to next sub-table */ 2255 2256 Offset += SubTable->Length; 2257 SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, SubTable, SubTable->Length); 2258 } 2259 2260 return (S3ptTable->Length); 2261} 2262 2263 2264/******************************************************************************* 2265 * 2266 * FUNCTION: AcpiDmDumpSlic 2267 * 2268 * PARAMETERS: Table - A SLIC table 2269 * 2270 * RETURN: None 2271 * 2272 * DESCRIPTION: Format the contents of a SLIC 2273 * 2274 ******************************************************************************/ 2275 2276void 2277AcpiDmDumpSlic ( 2278 ACPI_TABLE_HEADER *Table) 2279{ 2280 ACPI_STATUS Status; 2281 UINT32 Offset = sizeof (ACPI_TABLE_SLIC); 2282 ACPI_SLIC_HEADER *SubTable; 2283 ACPI_DMTABLE_INFO *InfoTable; 2284 2285 2286 /* There is no main SLIC table, only subtables */ 2287 2288 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, Table, Offset); 2289 while (Offset < Table->Length) 2290 { 2291 /* Common sub-table header */ 2292 2293 AcpiOsPrintf ("\n"); 2294 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2295 SubTable->Length, AcpiDmTableInfoSlicHdr); 2296 if (ACPI_FAILURE (Status)) 2297 { 2298 return; 2299 } 2300 2301 switch (SubTable->Type) 2302 { 2303 case ACPI_SLIC_TYPE_PUBLIC_KEY: 2304 2305 InfoTable = AcpiDmTableInfoSlic0; 2306 break; 2307 2308 case ACPI_SLIC_TYPE_WINDOWS_MARKER: 2309 2310 InfoTable = AcpiDmTableInfoSlic1; 2311 break; 2312 2313 default: 2314 2315 AcpiOsPrintf ("\n**** Unknown SLIC sub-table type 0x%X\n", SubTable->Type); 2316 2317 /* Attempt to continue */ 2318 2319 if (!SubTable->Length) 2320 { 2321 AcpiOsPrintf ("Invalid zero length subtable\n"); 2322 return; 2323 } 2324 goto NextSubTable; 2325 } 2326 2327 AcpiOsPrintf ("\n"); 2328 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2329 SubTable->Length, InfoTable); 2330 if (ACPI_FAILURE (Status)) 2331 { 2332 return; 2333 } 2334 2335NextSubTable: 2336 /* Point to next sub-table */ 2337 2338 Offset += SubTable->Length; 2339 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, SubTable, SubTable->Length); 2340 } 2341} 2342 2343 2344/******************************************************************************* 2345 * 2346 * FUNCTION: AcpiDmDumpSlit 2347 * 2348 * PARAMETERS: Table - An SLIT 2349 * 2350 * RETURN: None 2351 * 2352 * DESCRIPTION: Format the contents of a SLIT 2353 * 2354 ******************************************************************************/ 2355 2356void 2357AcpiDmDumpSlit ( 2358 ACPI_TABLE_HEADER *Table) 2359{ 2360 ACPI_STATUS Status; 2361 UINT32 Offset; 2362 UINT8 *Row; 2363 UINT32 Localities; 2364 UINT32 i; 2365 UINT32 j; 2366 2367 2368 /* Main table */ 2369 2370 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit); 2371 if (ACPI_FAILURE (Status)) 2372 { 2373 return; 2374 } 2375 2376 /* Display the Locality NxN Matrix */ 2377 2378 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; 2379 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]); 2380 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry; 2381 2382 for (i = 0; i < Localities; i++) 2383 { 2384 /* Display one row of the matrix */ 2385 2386 AcpiDmLineHeader2 (Offset, Localities, "Locality", i); 2387 for (j = 0; j < Localities; j++) 2388 { 2389 /* Check for beyond EOT */ 2390 2391 if (Offset >= Table->Length) 2392 { 2393 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n"); 2394 return; 2395 } 2396 2397 AcpiOsPrintf ("%2.2X", Row[j]); 2398 Offset++; 2399 2400 /* Display up to 16 bytes per output row */ 2401 2402 if ((j+1) < Localities) 2403 { 2404 AcpiOsPrintf (" "); 2405 2406 if (j && (((j+1) % 16) == 0)) 2407 { 2408 AcpiOsPrintf ("\\\n"); /* With line continuation char */ 2409 AcpiDmLineHeader (Offset, 0, NULL); 2410 } 2411 } 2412 } 2413 2414 /* Point to next row */ 2415 2416 AcpiOsPrintf ("\n"); 2417 Row += Localities; 2418 } 2419} 2420 2421 2422/******************************************************************************* 2423 * 2424 * FUNCTION: AcpiDmDumpSrat 2425 * 2426 * PARAMETERS: Table - A SRAT table 2427 * 2428 * RETURN: None 2429 * 2430 * DESCRIPTION: Format the contents of a SRAT 2431 * 2432 ******************************************************************************/ 2433 2434void 2435AcpiDmDumpSrat ( 2436 ACPI_TABLE_HEADER *Table) 2437{ 2438 ACPI_STATUS Status; 2439 UINT32 Offset = sizeof (ACPI_TABLE_SRAT); 2440 ACPI_SUBTABLE_HEADER *SubTable; 2441 ACPI_DMTABLE_INFO *InfoTable; 2442 2443 2444 /* Main table */ 2445 2446 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat); 2447 if (ACPI_FAILURE (Status)) 2448 { 2449 return; 2450 } 2451 2452 /* Sub-tables */ 2453 2454 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 2455 while (Offset < Table->Length) 2456 { 2457 /* Common sub-table header */ 2458 2459 AcpiOsPrintf ("\n"); 2460 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2461 SubTable->Length, AcpiDmTableInfoSratHdr); 2462 if (ACPI_FAILURE (Status)) 2463 { 2464 return; 2465 } 2466 2467 switch (SubTable->Type) 2468 { 2469 case ACPI_SRAT_TYPE_CPU_AFFINITY: 2470 2471 InfoTable = AcpiDmTableInfoSrat0; 2472 break; 2473 2474 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 2475 2476 InfoTable = AcpiDmTableInfoSrat1; 2477 break; 2478 2479 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 2480 2481 InfoTable = AcpiDmTableInfoSrat2; 2482 break; 2483 2484 default: 2485 AcpiOsPrintf ("\n**** Unknown SRAT sub-table type 0x%X\n", SubTable->Type); 2486 2487 /* Attempt to continue */ 2488 2489 if (!SubTable->Length) 2490 { 2491 AcpiOsPrintf ("Invalid zero length subtable\n"); 2492 return; 2493 } 2494 goto NextSubTable; 2495 } 2496 2497 AcpiOsPrintf ("\n"); 2498 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2499 SubTable->Length, InfoTable); 2500 if (ACPI_FAILURE (Status)) 2501 { 2502 return; 2503 } 2504 2505NextSubTable: 2506 /* Point to next sub-table */ 2507 2508 Offset += SubTable->Length; 2509 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 2510 } 2511} 2512 2513 2514/******************************************************************************* 2515 * 2516 * FUNCTION: AcpiDmDumpVrtc 2517 * 2518 * PARAMETERS: Table - A VRTC table 2519 * 2520 * RETURN: None 2521 * 2522 * DESCRIPTION: Format the contents of a VRTC 2523 * 2524 ******************************************************************************/ 2525 2526void 2527AcpiDmDumpVrtc ( 2528 ACPI_TABLE_HEADER *Table) 2529{ 2530 ACPI_STATUS Status; 2531 UINT32 Offset = sizeof (ACPI_TABLE_VRTC); 2532 ACPI_VRTC_ENTRY *SubTable; 2533 2534 2535 /* Main table */ 2536 2537 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc); 2538 if (ACPI_FAILURE (Status)) 2539 { 2540 return; 2541 } 2542 2543 /* Sub-tables */ 2544 2545 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset); 2546 while (Offset < Table->Length) 2547 { 2548 /* Common sub-table header */ 2549 2550 AcpiOsPrintf ("\n"); 2551 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2552 sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0); 2553 if (ACPI_FAILURE (Status)) 2554 { 2555 return; 2556 } 2557 2558 /* Point to next sub-table */ 2559 2560 Offset += sizeof (ACPI_VRTC_ENTRY); 2561 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable, sizeof (ACPI_VRTC_ENTRY)); 2562 } 2563} 2564 2565 2566/******************************************************************************* 2567 * 2568 * FUNCTION: AcpiDmDumpWdat 2569 * 2570 * PARAMETERS: Table - A WDAT table 2571 * 2572 * RETURN: None 2573 * 2574 * DESCRIPTION: Format the contents of a WDAT 2575 * 2576 ******************************************************************************/ 2577 2578void 2579AcpiDmDumpWdat ( 2580 ACPI_TABLE_HEADER *Table) 2581{ 2582 ACPI_STATUS Status; 2583 UINT32 Offset = sizeof (ACPI_TABLE_WDAT); 2584 ACPI_WDAT_ENTRY *SubTable; 2585 2586 2587 /* Main table */ 2588 2589 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat); 2590 if (ACPI_FAILURE (Status)) 2591 { 2592 return; 2593 } 2594 2595 /* Sub-tables */ 2596 2597 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset); 2598 while (Offset < Table->Length) 2599 { 2600 /* Common sub-table header */ 2601 2602 AcpiOsPrintf ("\n"); 2603 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2604 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0); 2605 if (ACPI_FAILURE (Status)) 2606 { 2607 return; 2608 } 2609 2610 /* Point to next sub-table */ 2611 2612 Offset += sizeof (ACPI_WDAT_ENTRY); 2613 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY)); 2614 } 2615} 2616