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