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