dmtbdump.c revision 1.1.1.12
1 /****************************************************************************** 2 * 3 * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2017, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include "acpi.h" 45 #include "accommon.h" 46 #include "acdisasm.h" 47 #include "actables.h" 48 49 /* This module used for application-level code only */ 50 51 #define _COMPONENT ACPI_CA_DISASSEMBLER 52 ACPI_MODULE_NAME ("dmtbdump") 53 54 55 /* Local prototypes */ 56 57 static void 58 AcpiDmValidateFadtLength ( 59 UINT32 Revision, 60 UINT32 Length); 61 62 63 /******************************************************************************* 64 * 65 * FUNCTION: AcpiDmDumpBuffer 66 * 67 * PARAMETERS: Table - ACPI Table or subtable 68 * BufferOffset - Offset of buffer from Table above 69 * Length - Length of the buffer 70 * AbsoluteOffset - Offset of buffer in the main ACPI table 71 * Header - Name of the buffer field (printed on the 72 * first line only.) 73 * 74 * RETURN: None 75 * 76 * DESCRIPTION: Format the contents of an arbitrary length data buffer (in the 77 * disassembler output format.) 78 * 79 ******************************************************************************/ 80 81 void 82 AcpiDmDumpBuffer ( 83 void *Table, 84 UINT32 BufferOffset, 85 UINT32 Length, 86 UINT32 AbsoluteOffset, 87 char *Header) 88 { 89 UINT8 *Buffer; 90 UINT32 i; 91 92 93 if (!Length) 94 { 95 return; 96 } 97 98 Buffer = ACPI_CAST_PTR (UINT8, Table) + BufferOffset; 99 i = 0; 100 101 while (i < Length) 102 { 103 if (!(i % 16)) 104 { 105 /* Insert a backslash - line continuation character */ 106 107 if (Length > 16) 108 { 109 AcpiOsPrintf ("\\\n "); 110 } 111 } 112 113 AcpiOsPrintf ("%.02X ", *Buffer); 114 i++; 115 Buffer++; 116 AbsoluteOffset++; 117 } 118 119 AcpiOsPrintf ("\n"); 120 } 121 122 123 /******************************************************************************* 124 * 125 * FUNCTION: AcpiDmDumpUnicode 126 * 127 * PARAMETERS: Table - ACPI Table or subtable 128 * BufferOffset - Offset of buffer from Table above 129 * ByteLength - Length of the buffer 130 * 131 * RETURN: None 132 * 133 * DESCRIPTION: Validate and dump the contents of a buffer that contains 134 * unicode data. The output is a standard ASCII string. If it 135 * appears that the data is not unicode, the buffer is dumped 136 * as hex characters. 137 * 138 ******************************************************************************/ 139 140 void 141 AcpiDmDumpUnicode ( 142 void *Table, 143 UINT32 BufferOffset, 144 UINT32 ByteLength) 145 { 146 UINT8 *Buffer; 147 UINT32 Length; 148 UINT32 i; 149 150 151 Buffer = ((UINT8 *) Table) + BufferOffset; 152 Length = ByteLength - 2; /* Last two bytes are the null terminator */ 153 154 /* Ensure all low bytes are entirely printable ASCII */ 155 156 for (i = 0; i < Length; i += 2) 157 { 158 if (!isprint (Buffer[i])) 159 { 160 goto DumpRawBuffer; 161 } 162 } 163 164 /* Ensure all high bytes are zero */ 165 166 for (i = 1; i < Length; i += 2) 167 { 168 if (Buffer[i]) 169 { 170 goto DumpRawBuffer; 171 } 172 } 173 174 /* Dump the buffer as a normal string */ 175 176 AcpiOsPrintf ("\""); 177 for (i = 0; i < Length; i += 2) 178 { 179 AcpiOsPrintf ("%c", Buffer[i]); 180 } 181 182 AcpiOsPrintf ("\"\n"); 183 return; 184 185 DumpRawBuffer: 186 AcpiDmDumpBuffer (Table, BufferOffset, ByteLength, 187 BufferOffset, NULL); 188 AcpiOsPrintf ("\n"); 189 } 190 191 192 /******************************************************************************* 193 * 194 * FUNCTION: AcpiDmDumpRsdp 195 * 196 * PARAMETERS: Table - A RSDP 197 * 198 * RETURN: Length of the table (there is not always a length field, 199 * use revision or length if available (ACPI 2.0+)) 200 * 201 * DESCRIPTION: Format the contents of a RSDP 202 * 203 ******************************************************************************/ 204 205 UINT32 206 AcpiDmDumpRsdp ( 207 ACPI_TABLE_HEADER *Table) 208 { 209 ACPI_TABLE_RSDP *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table); 210 UINT32 Length = sizeof (ACPI_RSDP_COMMON); 211 UINT8 Checksum; 212 ACPI_STATUS Status; 213 214 215 /* Dump the common ACPI 1.0 portion */ 216 217 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1); 218 if (ACPI_FAILURE (Status)) 219 { 220 return (Length); 221 } 222 223 /* Validate the first checksum */ 224 225 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON), 226 Rsdp->Checksum); 227 if (Checksum != Rsdp->Checksum) 228 { 229 AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n", 230 Checksum); 231 } 232 233 /* The RSDP for ACPI 2.0+ contains more data and has a Length field */ 234 235 if (Rsdp->Revision > 0) 236 { 237 Length = Rsdp->Length; 238 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2); 239 if (ACPI_FAILURE (Status)) 240 { 241 return (Length); 242 } 243 244 /* Validate the extended checksum over entire RSDP */ 245 246 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP), 247 Rsdp->ExtendedChecksum); 248 if (Checksum != Rsdp->ExtendedChecksum) 249 { 250 AcpiOsPrintf ( 251 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n", 252 Checksum); 253 } 254 } 255 256 return (Length); 257 } 258 259 260 /******************************************************************************* 261 * 262 * FUNCTION: AcpiDmDumpRsdt 263 * 264 * PARAMETERS: Table - A RSDT 265 * 266 * RETURN: None 267 * 268 * DESCRIPTION: Format the contents of a RSDT 269 * 270 ******************************************************************************/ 271 272 void 273 AcpiDmDumpRsdt ( 274 ACPI_TABLE_HEADER *Table) 275 { 276 UINT32 *Array; 277 UINT32 Entries; 278 UINT32 Offset; 279 UINT32 i; 280 281 282 /* Point to start of table pointer array */ 283 284 Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry; 285 Offset = sizeof (ACPI_TABLE_HEADER); 286 287 /* RSDT uses 32-bit pointers */ 288 289 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32); 290 291 for (i = 0; i < Entries; i++) 292 { 293 AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i); 294 AcpiOsPrintf ("%8.8X\n", Array[i]); 295 Offset += sizeof (UINT32); 296 } 297 } 298 299 300 /******************************************************************************* 301 * 302 * FUNCTION: AcpiDmDumpXsdt 303 * 304 * PARAMETERS: Table - A XSDT 305 * 306 * RETURN: None 307 * 308 * DESCRIPTION: Format the contents of a XSDT 309 * 310 ******************************************************************************/ 311 312 void 313 AcpiDmDumpXsdt ( 314 ACPI_TABLE_HEADER *Table) 315 { 316 UINT64 *Array; 317 UINT32 Entries; 318 UINT32 Offset; 319 UINT32 i; 320 321 322 /* Point to start of table pointer array */ 323 324 Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry; 325 Offset = sizeof (ACPI_TABLE_HEADER); 326 327 /* XSDT uses 64-bit pointers */ 328 329 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64); 330 331 for (i = 0; i < Entries; i++) 332 { 333 AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i); 334 AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i])); 335 Offset += sizeof (UINT64); 336 } 337 } 338 339 340 /******************************************************************************* 341 * 342 * FUNCTION: AcpiDmDumpFadt 343 * 344 * PARAMETERS: Table - A FADT 345 * 346 * RETURN: None 347 * 348 * DESCRIPTION: Format the contents of a FADT 349 * 350 * NOTE: We cannot depend on the FADT version to indicate the actual 351 * contents of the FADT because of BIOS bugs. The table length 352 * is the only reliable indicator. 353 * 354 ******************************************************************************/ 355 356 void 357 AcpiDmDumpFadt ( 358 ACPI_TABLE_HEADER *Table) 359 { 360 ACPI_STATUS Status; 361 362 363 /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */ 364 365 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 366 AcpiDmTableInfoFadt1); 367 if (ACPI_FAILURE (Status)) 368 { 369 return; 370 } 371 372 /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */ 373 374 if ((Table->Length > ACPI_FADT_V1_SIZE) && 375 (Table->Length <= ACPI_FADT_V2_SIZE)) 376 { 377 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 378 AcpiDmTableInfoFadt2); 379 if (ACPI_FAILURE (Status)) 380 { 381 return; 382 } 383 } 384 385 /* Check for FADT revision 3/4 fields and up (ACPI 2.0+ extended data) */ 386 387 else if (Table->Length > ACPI_FADT_V2_SIZE) 388 { 389 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 390 AcpiDmTableInfoFadt3); 391 if (ACPI_FAILURE (Status)) 392 { 393 return; 394 } 395 396 /* Check for FADT revision 5 fields and up (ACPI 5.0+) */ 397 398 if (Table->Length > ACPI_FADT_V3_SIZE) 399 { 400 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 401 AcpiDmTableInfoFadt5); 402 if (ACPI_FAILURE (Status)) 403 { 404 return; 405 } 406 } 407 408 /* Check for FADT revision 6 fields and up (ACPI 6.0+) */ 409 410 if (Table->Length > ACPI_FADT_V3_SIZE) 411 { 412 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 413 AcpiDmTableInfoFadt6); 414 if (ACPI_FAILURE (Status)) 415 { 416 return; 417 } 418 } 419 } 420 421 /* Validate various fields in the FADT, including length */ 422 423 AcpiTbCreateLocalFadt (Table, Table->Length); 424 425 /* Validate FADT length against the revision */ 426 427 AcpiDmValidateFadtLength (Table->Revision, Table->Length); 428 } 429 430 431 /******************************************************************************* 432 * 433 * FUNCTION: AcpiDmValidateFadtLength 434 * 435 * PARAMETERS: Revision - FADT revision (Header->Revision) 436 * Length - FADT length (Header->Length 437 * 438 * RETURN: None 439 * 440 * DESCRIPTION: Check the FADT revision against the expected table length for 441 * that revision. Issue a warning if the length is not what was 442 * expected. This seems to be such a common BIOS bug that the 443 * FADT revision has been rendered virtually meaningless. 444 * 445 ******************************************************************************/ 446 447 static void 448 AcpiDmValidateFadtLength ( 449 UINT32 Revision, 450 UINT32 Length) 451 { 452 UINT32 ExpectedLength; 453 454 455 switch (Revision) 456 { 457 case 0: 458 459 AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n"); 460 return; 461 462 case 1: 463 464 ExpectedLength = ACPI_FADT_V1_SIZE; 465 break; 466 467 case 2: 468 469 ExpectedLength = ACPI_FADT_V2_SIZE; 470 break; 471 472 case 3: 473 case 4: 474 475 ExpectedLength = ACPI_FADT_V3_SIZE; 476 break; 477 478 case 5: 479 480 ExpectedLength = ACPI_FADT_V5_SIZE; 481 break; 482 483 default: 484 485 return; 486 } 487 488 if (Length == ExpectedLength) 489 { 490 return; 491 } 492 493 AcpiOsPrintf ( 494 "\n// ACPI Warning: FADT revision %X does not match length: " 495 "found %X expected %X\n", 496 Revision, Length, ExpectedLength); 497 } 498 499 500 /******************************************************************************* 501 * 502 * FUNCTION: AcpiDmDumpAsf 503 * 504 * PARAMETERS: Table - A ASF table 505 * 506 * RETURN: None 507 * 508 * DESCRIPTION: Format the contents of a ASF table 509 * 510 ******************************************************************************/ 511 512 void 513 AcpiDmDumpAsf ( 514 ACPI_TABLE_HEADER *Table) 515 { 516 ACPI_STATUS Status; 517 UINT32 Offset = sizeof (ACPI_TABLE_HEADER); 518 ACPI_ASF_INFO *SubTable; 519 ACPI_DMTABLE_INFO *InfoTable; 520 ACPI_DMTABLE_INFO *DataInfoTable = NULL; 521 UINT8 *DataTable = NULL; 522 UINT32 DataCount = 0; 523 UINT32 DataLength = 0; 524 UINT32 DataOffset = 0; 525 UINT32 i; 526 UINT8 Type; 527 528 529 /* No main table, only subtables */ 530 531 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); 532 while (Offset < Table->Length) 533 { 534 /* Common subtable header */ 535 536 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 537 SubTable->Header.Length, AcpiDmTableInfoAsfHdr); 538 if (ACPI_FAILURE (Status)) 539 { 540 return; 541 } 542 543 /* The actual type is the lower 7 bits of Type */ 544 545 Type = (UINT8) (SubTable->Header.Type & 0x7F); 546 547 switch (Type) 548 { 549 case ACPI_ASF_TYPE_INFO: 550 551 InfoTable = AcpiDmTableInfoAsf0; 552 break; 553 554 case ACPI_ASF_TYPE_ALERT: 555 556 InfoTable = AcpiDmTableInfoAsf1; 557 DataInfoTable = AcpiDmTableInfoAsf1a; 558 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT)); 559 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts; 560 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength; 561 DataOffset = Offset + sizeof (ACPI_ASF_ALERT); 562 break; 563 564 case ACPI_ASF_TYPE_CONTROL: 565 566 InfoTable = AcpiDmTableInfoAsf2; 567 DataInfoTable = AcpiDmTableInfoAsf2a; 568 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE)); 569 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls; 570 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength; 571 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE); 572 break; 573 574 case ACPI_ASF_TYPE_BOOT: 575 576 InfoTable = AcpiDmTableInfoAsf3; 577 break; 578 579 case ACPI_ASF_TYPE_ADDRESS: 580 581 InfoTable = AcpiDmTableInfoAsf4; 582 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS)); 583 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices; 584 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS); 585 break; 586 587 default: 588 589 AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n", 590 SubTable->Header.Type); 591 return; 592 } 593 594 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 595 SubTable->Header.Length, InfoTable); 596 if (ACPI_FAILURE (Status)) 597 { 598 return; 599 } 600 601 /* Dump variable-length extra data */ 602 603 switch (Type) 604 { 605 case ACPI_ASF_TYPE_ALERT: 606 case ACPI_ASF_TYPE_CONTROL: 607 608 for (i = 0; i < DataCount; i++) 609 { 610 AcpiOsPrintf ("\n"); 611 Status = AcpiDmDumpTable (Table->Length, DataOffset, 612 DataTable, DataLength, DataInfoTable); 613 if (ACPI_FAILURE (Status)) 614 { 615 return; 616 } 617 618 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength); 619 DataOffset += DataLength; 620 } 621 break; 622 623 case ACPI_ASF_TYPE_ADDRESS: 624 625 for (i = 0; i < DataLength; i++) 626 { 627 if (!(i % 16)) 628 { 629 AcpiDmLineHeader (DataOffset, 1, "Addresses"); 630 } 631 632 AcpiOsPrintf ("%2.2X ", *DataTable); 633 DataTable++; 634 DataOffset++; 635 636 if (DataOffset > Table->Length) 637 { 638 AcpiOsPrintf ( 639 "**** ACPI table terminates in the middle of a " 640 "data structure! (ASF! table)\n"); 641 return; 642 } 643 } 644 645 AcpiOsPrintf ("\n"); 646 break; 647 648 default: 649 650 break; 651 } 652 653 AcpiOsPrintf ("\n"); 654 655 /* Point to next subtable */ 656 657 if (!SubTable->Header.Length) 658 { 659 AcpiOsPrintf ("Invalid zero subtable header length\n"); 660 return; 661 } 662 663 Offset += SubTable->Header.Length; 664 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, 665 SubTable->Header.Length); 666 } 667 } 668 669 670 /******************************************************************************* 671 * 672 * FUNCTION: AcpiDmDumpCpep 673 * 674 * PARAMETERS: Table - A CPEP table 675 * 676 * RETURN: None 677 * 678 * DESCRIPTION: Format the contents of a CPEP. This table type consists 679 * of an open-ended number of subtables. 680 * 681 ******************************************************************************/ 682 683 void 684 AcpiDmDumpCpep ( 685 ACPI_TABLE_HEADER *Table) 686 { 687 ACPI_STATUS Status; 688 ACPI_CPEP_POLLING *SubTable; 689 UINT32 Length = Table->Length; 690 UINT32 Offset = sizeof (ACPI_TABLE_CPEP); 691 692 693 /* Main table */ 694 695 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep); 696 if (ACPI_FAILURE (Status)) 697 { 698 return; 699 } 700 701 /* Subtables */ 702 703 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset); 704 while (Offset < Table->Length) 705 { 706 AcpiOsPrintf ("\n"); 707 Status = AcpiDmDumpTable (Length, Offset, SubTable, 708 SubTable->Header.Length, AcpiDmTableInfoCpep0); 709 if (ACPI_FAILURE (Status)) 710 { 711 return; 712 } 713 714 /* Point to next subtable */ 715 716 Offset += SubTable->Header.Length; 717 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable, 718 SubTable->Header.Length); 719 } 720 } 721 722 723 /******************************************************************************* 724 * 725 * FUNCTION: AcpiDmDumpCsrt 726 * 727 * PARAMETERS: Table - A CSRT table 728 * 729 * RETURN: None 730 * 731 * DESCRIPTION: Format the contents of a CSRT. This table type consists 732 * of an open-ended number of subtables. 733 * 734 ******************************************************************************/ 735 736 void 737 AcpiDmDumpCsrt ( 738 ACPI_TABLE_HEADER *Table) 739 { 740 ACPI_STATUS Status; 741 ACPI_CSRT_GROUP *SubTable; 742 ACPI_CSRT_SHARED_INFO *SharedInfoTable; 743 ACPI_CSRT_DESCRIPTOR *SubSubTable; 744 UINT32 Length = Table->Length; 745 UINT32 Offset = sizeof (ACPI_TABLE_CSRT); 746 UINT32 SubOffset; 747 UINT32 SubSubOffset; 748 UINT32 InfoLength; 749 750 751 /* The main table only contains the ACPI header, thus already handled */ 752 753 /* Subtables (Resource Groups) */ 754 755 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset); 756 while (Offset < Table->Length) 757 { 758 /* Resource group subtable */ 759 760 AcpiOsPrintf ("\n"); 761 Status = AcpiDmDumpTable (Length, Offset, SubTable, 762 SubTable->Length, AcpiDmTableInfoCsrt0); 763 if (ACPI_FAILURE (Status)) 764 { 765 return; 766 } 767 768 /* Shared info subtable (One per resource group) */ 769 770 SubOffset = sizeof (ACPI_CSRT_GROUP); 771 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table, 772 Offset + SubOffset); 773 774 AcpiOsPrintf ("\n"); 775 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable, 776 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1); 777 if (ACPI_FAILURE (Status)) 778 { 779 return; 780 } 781 782 SubOffset += SubTable->SharedInfoLength; 783 784 /* Sub-Subtables (Resource Descriptors) */ 785 786 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table, 787 Offset + SubOffset); 788 789 while ((SubOffset < SubTable->Length) && 790 ((Offset + SubOffset) < Table->Length)) 791 { 792 AcpiOsPrintf ("\n"); 793 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable, 794 SubSubTable->Length, AcpiDmTableInfoCsrt2); 795 if (ACPI_FAILURE (Status)) 796 { 797 return; 798 } 799 800 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR); 801 802 /* Resource-specific info buffer */ 803 804 InfoLength = SubSubTable->Length - SubSubOffset; 805 if (InfoLength) 806 { 807 Status = AcpiDmDumpTable (Length, 808 Offset + SubOffset + SubSubOffset, Table, 809 InfoLength, AcpiDmTableInfoCsrt2a); 810 if (ACPI_FAILURE (Status)) 811 { 812 return; 813 } 814 SubSubOffset += InfoLength; 815 } 816 817 /* Point to next sub-subtable */ 818 819 SubOffset += SubSubTable->Length; 820 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable, 821 SubSubTable->Length); 822 } 823 824 /* Point to next subtable */ 825 826 Offset += SubTable->Length; 827 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable, 828 SubTable->Length); 829 } 830 } 831 832 833 /******************************************************************************* 834 * 835 * FUNCTION: AcpiDmDumpDbg2 836 * 837 * PARAMETERS: Table - A DBG2 table 838 * 839 * RETURN: None 840 * 841 * DESCRIPTION: Format the contents of a DBG2. This table type consists 842 * of an open-ended number of subtables. 843 * 844 ******************************************************************************/ 845 846 void 847 AcpiDmDumpDbg2 ( 848 ACPI_TABLE_HEADER *Table) 849 { 850 ACPI_STATUS Status; 851 ACPI_DBG2_DEVICE *SubTable; 852 UINT32 Length = Table->Length; 853 UINT32 Offset = sizeof (ACPI_TABLE_DBG2); 854 UINT32 i; 855 UINT32 ArrayOffset; 856 UINT32 AbsoluteOffset; 857 UINT8 *Array; 858 859 860 /* Main table */ 861 862 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2); 863 if (ACPI_FAILURE (Status)) 864 { 865 return; 866 } 867 868 /* Subtables */ 869 870 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset); 871 while (Offset < Table->Length) 872 { 873 AcpiOsPrintf ("\n"); 874 Status = AcpiDmDumpTable (Length, Offset, SubTable, 875 SubTable->Length, AcpiDmTableInfoDbg2Device); 876 if (ACPI_FAILURE (Status)) 877 { 878 return; 879 } 880 881 /* Dump the BaseAddress array */ 882 883 for (i = 0; i < SubTable->RegisterCount; i++) 884 { 885 ArrayOffset = SubTable->BaseAddressOffset + 886 (sizeof (ACPI_GENERIC_ADDRESS) * i); 887 AbsoluteOffset = Offset + ArrayOffset; 888 Array = (UINT8 *) SubTable + ArrayOffset; 889 890 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 891 SubTable->Length, AcpiDmTableInfoDbg2Addr); 892 if (ACPI_FAILURE (Status)) 893 { 894 return; 895 } 896 } 897 898 /* Dump the AddressSize array */ 899 900 for (i = 0; i < SubTable->RegisterCount; i++) 901 { 902 ArrayOffset = SubTable->AddressSizeOffset + 903 (sizeof (UINT32) * i); 904 AbsoluteOffset = Offset + ArrayOffset; 905 Array = (UINT8 *) SubTable + ArrayOffset; 906 907 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 908 SubTable->Length, AcpiDmTableInfoDbg2Size); 909 if (ACPI_FAILURE (Status)) 910 { 911 return; 912 } 913 } 914 915 /* Dump the Namestring (required) */ 916 917 AcpiOsPrintf ("\n"); 918 ArrayOffset = SubTable->NamepathOffset; 919 AbsoluteOffset = Offset + ArrayOffset; 920 Array = (UINT8 *) SubTable + ArrayOffset; 921 922 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 923 SubTable->Length, AcpiDmTableInfoDbg2Name); 924 if (ACPI_FAILURE (Status)) 925 { 926 return; 927 } 928 929 /* Dump the OemData (optional) */ 930 931 if (SubTable->OemDataOffset) 932 { 933 Status = AcpiDmDumpTable (Length, Offset + SubTable->OemDataOffset, 934 Table, SubTable->OemDataLength, 935 AcpiDmTableInfoDbg2OemData); 936 if (ACPI_FAILURE (Status)) 937 { 938 return; 939 } 940 } 941 942 /* Point to next subtable */ 943 944 Offset += SubTable->Length; 945 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable, 946 SubTable->Length); 947 } 948 } 949 950 951 /******************************************************************************* 952 * 953 * FUNCTION: AcpiDmDumpDmar 954 * 955 * PARAMETERS: Table - A DMAR table 956 * 957 * RETURN: None 958 * 959 * DESCRIPTION: Format the contents of a DMAR. This table type consists 960 * of an open-ended number of subtables. 961 * 962 ******************************************************************************/ 963 964 void 965 AcpiDmDumpDmar ( 966 ACPI_TABLE_HEADER *Table) 967 { 968 ACPI_STATUS Status; 969 ACPI_DMAR_HEADER *SubTable; 970 UINT32 Length = Table->Length; 971 UINT32 Offset = sizeof (ACPI_TABLE_DMAR); 972 ACPI_DMTABLE_INFO *InfoTable; 973 ACPI_DMAR_DEVICE_SCOPE *ScopeTable; 974 UINT32 ScopeOffset; 975 UINT8 *PciPath; 976 UINT32 PathOffset; 977 978 979 /* Main table */ 980 981 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); 982 if (ACPI_FAILURE (Status)) 983 { 984 return; 985 } 986 987 /* Subtables */ 988 989 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); 990 while (Offset < Table->Length) 991 { 992 /* Common subtable header */ 993 994 AcpiOsPrintf ("\n"); 995 Status = AcpiDmDumpTable (Length, Offset, SubTable, 996 SubTable->Length, AcpiDmTableInfoDmarHdr); 997 if (ACPI_FAILURE (Status)) 998 { 999 return; 1000 } 1001 1002 AcpiOsPrintf ("\n"); 1003 1004 switch (SubTable->Type) 1005 { 1006 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 1007 1008 InfoTable = AcpiDmTableInfoDmar0; 1009 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT); 1010 break; 1011 1012 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 1013 1014 InfoTable = AcpiDmTableInfoDmar1; 1015 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY); 1016 break; 1017 1018 case ACPI_DMAR_TYPE_ROOT_ATS: 1019 1020 InfoTable = AcpiDmTableInfoDmar2; 1021 ScopeOffset = sizeof (ACPI_DMAR_ATSR); 1022 break; 1023 1024 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY: 1025 1026 InfoTable = AcpiDmTableInfoDmar3; 1027 ScopeOffset = sizeof (ACPI_DMAR_RHSA); 1028 break; 1029 1030 case ACPI_DMAR_TYPE_NAMESPACE: 1031 1032 InfoTable = AcpiDmTableInfoDmar4; 1033 ScopeOffset = sizeof (ACPI_DMAR_ANDD); 1034 break; 1035 1036 default: 1037 1038 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n", 1039 SubTable->Type); 1040 return; 1041 } 1042 1043 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1044 SubTable->Length, InfoTable); 1045 if (ACPI_FAILURE (Status)) 1046 { 1047 return; 1048 } 1049 1050 /* 1051 * Dump the optional device scope entries 1052 */ 1053 if ((SubTable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || 1054 (SubTable->Type == ACPI_DMAR_TYPE_NAMESPACE)) 1055 { 1056 /* These types do not support device scopes */ 1057 1058 goto NextSubtable; 1059 } 1060 1061 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset); 1062 while (ScopeOffset < SubTable->Length) 1063 { 1064 AcpiOsPrintf ("\n"); 1065 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, 1066 ScopeTable->Length, AcpiDmTableInfoDmarScope); 1067 if (ACPI_FAILURE (Status)) 1068 { 1069 return; 1070 } 1071 AcpiOsPrintf ("\n"); 1072 1073 /* Dump the PCI Path entries for this device scope */ 1074 1075 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */ 1076 1077 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable, 1078 sizeof (ACPI_DMAR_DEVICE_SCOPE)); 1079 1080 while (PathOffset < ScopeTable->Length) 1081 { 1082 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, 1083 "PCI Path"); 1084 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]); 1085 1086 /* Point to next PCI Path entry */ 1087 1088 PathOffset += 2; 1089 PciPath += 2; 1090 AcpiOsPrintf ("\n"); 1091 } 1092 1093 /* Point to next device scope entry */ 1094 1095 ScopeOffset += ScopeTable->Length; 1096 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, 1097 ScopeTable, ScopeTable->Length); 1098 } 1099 1100 NextSubtable: 1101 /* Point to next subtable */ 1102 1103 Offset += SubTable->Length; 1104 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, 1105 SubTable->Length); 1106 } 1107 } 1108 1109 1110 /******************************************************************************* 1111 * 1112 * FUNCTION: AcpiDmDumpDrtm 1113 * 1114 * PARAMETERS: Table - A DRTM table 1115 * 1116 * RETURN: None 1117 * 1118 * DESCRIPTION: Format the contents of a DRTM. 1119 * 1120 ******************************************************************************/ 1121 1122 void 1123 AcpiDmDumpDrtm ( 1124 ACPI_TABLE_HEADER *Table) 1125 { 1126 ACPI_STATUS Status; 1127 UINT32 Offset; 1128 ACPI_DRTM_VTABLE_LIST *DrtmVtl; 1129 ACPI_DRTM_RESOURCE_LIST *DrtmRl; 1130 ACPI_DRTM_DPS_ID *DrtmDps; 1131 UINT32 Count; 1132 1133 1134 /* Main table */ 1135 1136 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 1137 AcpiDmTableInfoDrtm); 1138 if (ACPI_FAILURE (Status)) 1139 { 1140 return; 1141 } 1142 1143 Offset = sizeof (ACPI_TABLE_DRTM); 1144 1145 /* Sub-tables */ 1146 1147 /* Dump ValidatedTable length */ 1148 1149 DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset); 1150 AcpiOsPrintf ("\n"); 1151 Status = AcpiDmDumpTable (Table->Length, Offset, 1152 DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables), 1153 AcpiDmTableInfoDrtm0); 1154 if (ACPI_FAILURE (Status)) 1155 { 1156 return; 1157 } 1158 1159 Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables); 1160 1161 /* Dump Validated table addresses */ 1162 1163 Count = 0; 1164 while ((Offset < Table->Length) && 1165 (DrtmVtl->ValidatedTableCount > Count)) 1166 { 1167 Status = AcpiDmDumpTable (Table->Length, Offset, 1168 ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64), 1169 AcpiDmTableInfoDrtm0a); 1170 if (ACPI_FAILURE (Status)) 1171 { 1172 return; 1173 } 1174 1175 Offset += sizeof (UINT64); 1176 Count++; 1177 } 1178 1179 /* Dump ResourceList length */ 1180 1181 DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset); 1182 AcpiOsPrintf ("\n"); 1183 Status = AcpiDmDumpTable (Table->Length, Offset, 1184 DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources), 1185 AcpiDmTableInfoDrtm1); 1186 if (ACPI_FAILURE (Status)) 1187 { 1188 return; 1189 } 1190 1191 Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources); 1192 1193 /* Dump the Resource List */ 1194 1195 Count = 0; 1196 while ((Offset < Table->Length) && 1197 (DrtmRl->ResourceCount > Count)) 1198 { 1199 Status = AcpiDmDumpTable (Table->Length, Offset, 1200 ACPI_ADD_PTR (void, Table, Offset), 1201 sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a); 1202 if (ACPI_FAILURE (Status)) 1203 { 1204 return; 1205 } 1206 1207 Offset += sizeof (ACPI_DRTM_RESOURCE); 1208 Count++; 1209 } 1210 1211 /* Dump DPS */ 1212 1213 DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset); 1214 AcpiOsPrintf ("\n"); 1215 (void) AcpiDmDumpTable (Table->Length, Offset, 1216 DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2); 1217 } 1218 1219 1220 /******************************************************************************* 1221 * 1222 * FUNCTION: AcpiDmDumpEinj 1223 * 1224 * PARAMETERS: Table - A EINJ table 1225 * 1226 * RETURN: None 1227 * 1228 * DESCRIPTION: Format the contents of a EINJ. This table type consists 1229 * of an open-ended number of subtables. 1230 * 1231 ******************************************************************************/ 1232 1233 void 1234 AcpiDmDumpEinj ( 1235 ACPI_TABLE_HEADER *Table) 1236 { 1237 ACPI_STATUS Status; 1238 ACPI_WHEA_HEADER *SubTable; 1239 UINT32 Length = Table->Length; 1240 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 1241 1242 1243 /* Main table */ 1244 1245 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 1246 if (ACPI_FAILURE (Status)) 1247 { 1248 return; 1249 } 1250 1251 /* Subtables */ 1252 1253 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1254 while (Offset < Table->Length) 1255 { 1256 AcpiOsPrintf ("\n"); 1257 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1258 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 1259 if (ACPI_FAILURE (Status)) 1260 { 1261 return; 1262 } 1263 1264 /* Point to next subtable (each subtable is of fixed length) */ 1265 1266 Offset += sizeof (ACPI_WHEA_HEADER); 1267 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 1268 sizeof (ACPI_WHEA_HEADER)); 1269 } 1270 } 1271 1272 1273 /******************************************************************************* 1274 * 1275 * FUNCTION: AcpiDmDumpErst 1276 * 1277 * PARAMETERS: Table - A ERST table 1278 * 1279 * RETURN: None 1280 * 1281 * DESCRIPTION: Format the contents of a ERST. This table type consists 1282 * of an open-ended number of subtables. 1283 * 1284 ******************************************************************************/ 1285 1286 void 1287 AcpiDmDumpErst ( 1288 ACPI_TABLE_HEADER *Table) 1289 { 1290 ACPI_STATUS Status; 1291 ACPI_WHEA_HEADER *SubTable; 1292 UINT32 Length = Table->Length; 1293 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 1294 1295 1296 /* Main table */ 1297 1298 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 1299 if (ACPI_FAILURE (Status)) 1300 { 1301 return; 1302 } 1303 1304 /* Subtables */ 1305 1306 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1307 while (Offset < Table->Length) 1308 { 1309 AcpiOsPrintf ("\n"); 1310 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1311 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0); 1312 if (ACPI_FAILURE (Status)) 1313 { 1314 return; 1315 } 1316 1317 /* Point to next subtable (each subtable is of fixed length) */ 1318 1319 Offset += sizeof (ACPI_WHEA_HEADER); 1320 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 1321 sizeof (ACPI_WHEA_HEADER)); 1322 } 1323 } 1324 1325 1326 /******************************************************************************* 1327 * 1328 * FUNCTION: AcpiDmDumpFpdt 1329 * 1330 * PARAMETERS: Table - A FPDT table 1331 * 1332 * RETURN: None 1333 * 1334 * DESCRIPTION: Format the contents of a FPDT. This table type consists 1335 * of an open-ended number of subtables. 1336 * 1337 ******************************************************************************/ 1338 1339 void 1340 AcpiDmDumpFpdt ( 1341 ACPI_TABLE_HEADER *Table) 1342 { 1343 ACPI_STATUS Status; 1344 ACPI_FPDT_HEADER *SubTable; 1345 UINT32 Length = Table->Length; 1346 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 1347 ACPI_DMTABLE_INFO *InfoTable; 1348 1349 1350 /* There is no main table (other than the standard ACPI header) */ 1351 1352 /* Subtables */ 1353 1354 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); 1355 while (Offset < Table->Length) 1356 { 1357 /* Common subtable header */ 1358 1359 AcpiOsPrintf ("\n"); 1360 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1361 SubTable->Length, AcpiDmTableInfoFpdtHdr); 1362 if (ACPI_FAILURE (Status)) 1363 { 1364 return; 1365 } 1366 1367 switch (SubTable->Type) 1368 { 1369 case ACPI_FPDT_TYPE_BOOT: 1370 1371 InfoTable = AcpiDmTableInfoFpdt0; 1372 break; 1373 1374 case ACPI_FPDT_TYPE_S3PERF: 1375 1376 InfoTable = AcpiDmTableInfoFpdt1; 1377 break; 1378 1379 default: 1380 1381 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", 1382 SubTable->Type); 1383 1384 /* Attempt to continue */ 1385 1386 if (!SubTable->Length) 1387 { 1388 AcpiOsPrintf ("Invalid zero length subtable\n"); 1389 return; 1390 } 1391 goto NextSubTable; 1392 } 1393 1394 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1395 SubTable->Length, InfoTable); 1396 if (ACPI_FAILURE (Status)) 1397 { 1398 return; 1399 } 1400 1401 NextSubTable: 1402 /* Point to next subtable */ 1403 1404 Offset += SubTable->Length; 1405 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, 1406 SubTable->Length); 1407 } 1408 } 1409 1410 1411 /******************************************************************************* 1412 * 1413 * FUNCTION: AcpiDmDumpGtdt 1414 * 1415 * PARAMETERS: Table - A GTDT table 1416 * 1417 * RETURN: None 1418 * 1419 * DESCRIPTION: Format the contents of a GTDT. This table type consists 1420 * of an open-ended number of subtables. 1421 * 1422 ******************************************************************************/ 1423 1424 void 1425 AcpiDmDumpGtdt ( 1426 ACPI_TABLE_HEADER *Table) 1427 { 1428 ACPI_STATUS Status; 1429 ACPI_GTDT_HEADER *SubTable; 1430 UINT32 Length = Table->Length; 1431 UINT32 Offset = sizeof (ACPI_TABLE_GTDT); 1432 ACPI_DMTABLE_INFO *InfoTable; 1433 UINT32 SubTableLength; 1434 UINT32 GtCount; 1435 ACPI_GTDT_TIMER_ENTRY *GtxTable; 1436 1437 1438 /* Main table */ 1439 1440 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt); 1441 if (ACPI_FAILURE (Status)) 1442 { 1443 return; 1444 } 1445 1446 /* Subtables */ 1447 1448 SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 1449 while (Offset < Table->Length) 1450 { 1451 /* Common subtable header */ 1452 1453 AcpiOsPrintf ("\n"); 1454 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1455 SubTable->Length, AcpiDmTableInfoGtdtHdr); 1456 if (ACPI_FAILURE (Status)) 1457 { 1458 return; 1459 } 1460 1461 GtCount = 0; 1462 switch (SubTable->Type) 1463 { 1464 case ACPI_GTDT_TYPE_TIMER_BLOCK: 1465 1466 SubTableLength = sizeof (ACPI_GTDT_TIMER_BLOCK); 1467 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, 1468 SubTable))->TimerCount; 1469 1470 InfoTable = AcpiDmTableInfoGtdt0; 1471 break; 1472 1473 case ACPI_GTDT_TYPE_WATCHDOG: 1474 1475 SubTableLength = sizeof (ACPI_GTDT_WATCHDOG); 1476 1477 InfoTable = AcpiDmTableInfoGtdt1; 1478 break; 1479 1480 default: 1481 1482 /* Cannot continue on unknown type - no length */ 1483 1484 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n", 1485 SubTable->Type); 1486 return; 1487 } 1488 1489 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1490 SubTable->Length, InfoTable); 1491 if (ACPI_FAILURE (Status)) 1492 { 1493 return; 1494 } 1495 1496 /* Point to end of current subtable (each subtable above is of fixed length) */ 1497 1498 Offset += SubTableLength; 1499 1500 /* If there are any Gt Timer Blocks from above, dump them now */ 1501 1502 if (GtCount) 1503 { 1504 GtxTable = ACPI_ADD_PTR ( 1505 ACPI_GTDT_TIMER_ENTRY, SubTable, SubTableLength); 1506 SubTableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY); 1507 1508 while (GtCount) 1509 { 1510 AcpiOsPrintf ("\n"); 1511 Status = AcpiDmDumpTable (Length, Offset, GtxTable, 1512 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a); 1513 if (ACPI_FAILURE (Status)) 1514 { 1515 return; 1516 } 1517 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY); 1518 GtxTable++; 1519 GtCount--; 1520 } 1521 } 1522 1523 /* Point to next subtable */ 1524 1525 SubTable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, SubTable, SubTableLength); 1526 } 1527 } 1528 1529 1530 /******************************************************************************* 1531 * 1532 * FUNCTION: AcpiDmDumpHest 1533 * 1534 * PARAMETERS: Table - A HEST table 1535 * 1536 * RETURN: None 1537 * 1538 * DESCRIPTION: Format the contents of a HEST. This table type consists 1539 * of an open-ended number of subtables. 1540 * 1541 ******************************************************************************/ 1542 1543 void 1544 AcpiDmDumpHest ( 1545 ACPI_TABLE_HEADER *Table) 1546 { 1547 ACPI_STATUS Status; 1548 ACPI_HEST_HEADER *SubTable; 1549 UINT32 Length = Table->Length; 1550 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 1551 ACPI_DMTABLE_INFO *InfoTable; 1552 UINT32 SubTableLength; 1553 UINT32 BankCount; 1554 ACPI_HEST_IA_ERROR_BANK *BankTable; 1555 1556 1557 /* Main table */ 1558 1559 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 1560 if (ACPI_FAILURE (Status)) 1561 { 1562 return; 1563 } 1564 1565 /* Subtables */ 1566 1567 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 1568 while (Offset < Table->Length) 1569 { 1570 BankCount = 0; 1571 switch (SubTable->Type) 1572 { 1573 case ACPI_HEST_TYPE_IA32_CHECK: 1574 1575 InfoTable = AcpiDmTableInfoHest0; 1576 SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK); 1577 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 1578 SubTable))->NumHardwareBanks; 1579 break; 1580 1581 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 1582 1583 InfoTable = AcpiDmTableInfoHest1; 1584 SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED); 1585 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 1586 SubTable))->NumHardwareBanks; 1587 break; 1588 1589 case ACPI_HEST_TYPE_IA32_NMI: 1590 1591 InfoTable = AcpiDmTableInfoHest2; 1592 SubTableLength = sizeof (ACPI_HEST_IA_NMI); 1593 break; 1594 1595 case ACPI_HEST_TYPE_AER_ROOT_PORT: 1596 1597 InfoTable = AcpiDmTableInfoHest6; 1598 SubTableLength = sizeof (ACPI_HEST_AER_ROOT); 1599 break; 1600 1601 case ACPI_HEST_TYPE_AER_ENDPOINT: 1602 1603 InfoTable = AcpiDmTableInfoHest7; 1604 SubTableLength = sizeof (ACPI_HEST_AER); 1605 break; 1606 1607 case ACPI_HEST_TYPE_AER_BRIDGE: 1608 1609 InfoTable = AcpiDmTableInfoHest8; 1610 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE); 1611 break; 1612 1613 case ACPI_HEST_TYPE_GENERIC_ERROR: 1614 1615 InfoTable = AcpiDmTableInfoHest9; 1616 SubTableLength = sizeof (ACPI_HEST_GENERIC); 1617 break; 1618 1619 case ACPI_HEST_TYPE_GENERIC_ERROR_V2: 1620 1621 InfoTable = AcpiDmTableInfoHest10; 1622 SubTableLength = sizeof (ACPI_HEST_GENERIC_V2); 1623 break; 1624 1625 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK: 1626 1627 InfoTable = AcpiDmTableInfoHest11; 1628 SubTableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK); 1629 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK, 1630 SubTable))->NumHardwareBanks; 1631 break; 1632 1633 default: 1634 1635 /* Cannot continue on unknown type - no length */ 1636 1637 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n", 1638 SubTable->Type); 1639 return; 1640 } 1641 1642 AcpiOsPrintf ("\n"); 1643 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1644 SubTableLength, InfoTable); 1645 if (ACPI_FAILURE (Status)) 1646 { 1647 return; 1648 } 1649 1650 /* Point to end of current subtable (each subtable above is of fixed length) */ 1651 1652 Offset += SubTableLength; 1653 1654 /* If there are any (fixed-length) Error Banks from above, dump them now */ 1655 1656 if (BankCount) 1657 { 1658 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, 1659 SubTableLength); 1660 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 1661 1662 while (BankCount) 1663 { 1664 AcpiOsPrintf ("\n"); 1665 Status = AcpiDmDumpTable (Length, Offset, BankTable, 1666 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 1667 if (ACPI_FAILURE (Status)) 1668 { 1669 return; 1670 } 1671 1672 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 1673 BankTable++; 1674 BankCount--; 1675 } 1676 } 1677 1678 /* Point to next subtable */ 1679 1680 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength); 1681 } 1682 } 1683 1684 1685 /******************************************************************************* 1686 * 1687 * FUNCTION: AcpiDmDumpHmat 1688 * 1689 * PARAMETERS: Table - A HMAT table 1690 * 1691 * RETURN: None 1692 * 1693 * DESCRIPTION: Format the contents of a HMAT. 1694 * 1695 ******************************************************************************/ 1696 1697 void 1698 AcpiDmDumpHmat ( 1699 ACPI_TABLE_HEADER *Table) 1700 { 1701 ACPI_STATUS Status; 1702 ACPI_HMAT_STRUCTURE *HmatStruct; 1703 ACPI_HMAT_LOCALITY *HmatLocality; 1704 ACPI_HMAT_CACHE *HmatCache; 1705 UINT32 Offset; 1706 UINT32 SubTableOffset; 1707 UINT32 Length; 1708 ACPI_DMTABLE_INFO *InfoTable; 1709 UINT32 i, j; 1710 1711 1712 /* Main table */ 1713 1714 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat); 1715 if (ACPI_FAILURE (Status)) 1716 { 1717 return; 1718 } 1719 Offset = sizeof (ACPI_TABLE_HMAT); 1720 1721 while (Offset < Table->Length) 1722 { 1723 AcpiOsPrintf ("\n"); 1724 SubTableOffset = 0; 1725 1726 /* Dump HMAT structure header */ 1727 1728 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset); 1729 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE)) 1730 { 1731 AcpiOsPrintf ("Invalid HMAT structure length\n"); 1732 return; 1733 } 1734 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 1735 HmatStruct->Length, AcpiDmTableInfoHmatHdr); 1736 if (ACPI_FAILURE (Status)) 1737 { 1738 return; 1739 } 1740 1741 switch (HmatStruct->Type) 1742 { 1743 case ACPI_HMAT_TYPE_ADDRESS_RANGE: 1744 1745 InfoTable = AcpiDmTableInfoHmat0; 1746 Length = sizeof (ACPI_HMAT_ADDRESS_RANGE); 1747 break; 1748 1749 case ACPI_HMAT_TYPE_LOCALITY: 1750 1751 InfoTable = AcpiDmTableInfoHmat1; 1752 Length = sizeof (ACPI_HMAT_LOCALITY); 1753 break; 1754 1755 case ACPI_HMAT_TYPE_CACHE: 1756 1757 InfoTable = AcpiDmTableInfoHmat2; 1758 Length = sizeof (ACPI_HMAT_CACHE); 1759 break; 1760 1761 default: 1762 1763 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n", 1764 HmatStruct->Type); 1765 1766 /* Attempt to continue */ 1767 1768 goto NextSubTable; 1769 } 1770 1771 /* Dump HMAT structure body */ 1772 1773 if (HmatStruct->Length < Length) 1774 { 1775 AcpiOsPrintf ("Invalid HMAT structure length\n"); 1776 return; 1777 } 1778 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 1779 HmatStruct->Length, InfoTable); 1780 if (ACPI_FAILURE (Status)) 1781 { 1782 return; 1783 } 1784 1785 /* Dump HMAT structure additionals */ 1786 1787 switch (HmatStruct->Type) 1788 { 1789 case ACPI_HMAT_TYPE_LOCALITY: 1790 1791 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct); 1792 SubTableOffset = sizeof (ACPI_HMAT_LOCALITY); 1793 1794 /* Dump initiator proximity domains */ 1795 1796 if ((UINT32)(HmatStruct->Length - SubTableOffset) < 1797 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4)) 1798 { 1799 AcpiOsPrintf ("Invalid initiator proximity domain number\n"); 1800 return; 1801 } 1802 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 1803 { 1804 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset, 1805 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset), 1806 4, AcpiDmTableInfoHmat1a); 1807 SubTableOffset += 4; 1808 } 1809 1810 /* Dump target proximity domains */ 1811 1812 if ((UINT32)(HmatStruct->Length - SubTableOffset) < 1813 (UINT32)(HmatLocality->NumberOfTargetPDs * 4)) 1814 { 1815 AcpiOsPrintf ("Invalid target proximity domain number\n"); 1816 return; 1817 } 1818 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++) 1819 { 1820 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset, 1821 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset), 1822 4, AcpiDmTableInfoHmat1b); 1823 SubTableOffset += 4; 1824 } 1825 1826 /* Dump latency/bandwidth entris */ 1827 1828 if ((UINT32)(HmatStruct->Length - SubTableOffset) < 1829 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 1830 HmatLocality->NumberOfTargetPDs * 2)) 1831 { 1832 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n"); 1833 return; 1834 } 1835 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 1836 { 1837 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++) 1838 { 1839 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset, 1840 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset), 1841 2, AcpiDmTableInfoHmat1c); 1842 SubTableOffset += 2; 1843 } 1844 } 1845 break; 1846 1847 case ACPI_HMAT_TYPE_CACHE: 1848 1849 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct); 1850 SubTableOffset = sizeof (ACPI_HMAT_CACHE); 1851 1852 /* Dump SMBIOS handles */ 1853 1854 if ((UINT32)(HmatStruct->Length - SubTableOffset) < 1855 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2)) 1856 { 1857 AcpiOsPrintf ("Invalid SMBIOS handle number\n"); 1858 return; 1859 } 1860 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++) 1861 { 1862 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset, 1863 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubTableOffset), 1864 2, AcpiDmTableInfoHmat2a); 1865 SubTableOffset += 2; 1866 } 1867 break; 1868 1869 default: 1870 1871 break; 1872 } 1873 1874 NextSubTable: 1875 /* Point to next HMAT structure subtable */ 1876 1877 Offset += (HmatStruct->Length); 1878 } 1879 } 1880 1881 1882 /******************************************************************************* 1883 * 1884 * FUNCTION: AcpiDmDumpIort 1885 * 1886 * PARAMETERS: Table - A IORT table 1887 * 1888 * RETURN: None 1889 * 1890 * DESCRIPTION: Format the contents of a IORT 1891 * 1892 ******************************************************************************/ 1893 1894 void 1895 AcpiDmDumpIort ( 1896 ACPI_TABLE_HEADER *Table) 1897 { 1898 ACPI_STATUS Status; 1899 ACPI_TABLE_IORT *Iort; 1900 ACPI_IORT_NODE *IortNode; 1901 ACPI_IORT_ITS_GROUP *IortItsGroup = NULL; 1902 ACPI_IORT_SMMU *IortSmmu = NULL; 1903 UINT32 Offset; 1904 UINT32 NodeOffset; 1905 UINT32 Length; 1906 ACPI_DMTABLE_INFO *InfoTable; 1907 char *String; 1908 UINT32 i; 1909 1910 1911 /* Main table */ 1912 1913 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIort); 1914 if (ACPI_FAILURE (Status)) 1915 { 1916 return; 1917 } 1918 1919 Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table); 1920 Offset = sizeof (ACPI_TABLE_IORT); 1921 1922 /* Dump the OptionalPadding (optional) */ 1923 1924 if (Iort->NodeOffset > Offset) 1925 { 1926 Status = AcpiDmDumpTable (Table->Length, Offset, Table, 1927 Iort->NodeOffset - Offset, AcpiDmTableInfoIortPad); 1928 if (ACPI_FAILURE (Status)) 1929 { 1930 return; 1931 } 1932 } 1933 1934 Offset = Iort->NodeOffset; 1935 while (Offset < Table->Length) 1936 { 1937 /* Common subtable header */ 1938 1939 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset); 1940 AcpiOsPrintf ("\n"); 1941 Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData); 1942 Status = AcpiDmDumpTable (Table->Length, Offset, 1943 IortNode, Length, AcpiDmTableInfoIortHdr); 1944 if (ACPI_FAILURE (Status)) 1945 { 1946 return; 1947 } 1948 1949 NodeOffset = Length; 1950 1951 switch (IortNode->Type) 1952 { 1953 case ACPI_IORT_NODE_ITS_GROUP: 1954 1955 InfoTable = AcpiDmTableInfoIort0; 1956 Length = ACPI_OFFSET (ACPI_IORT_ITS_GROUP, Identifiers); 1957 IortItsGroup = ACPI_ADD_PTR (ACPI_IORT_ITS_GROUP, IortNode, NodeOffset); 1958 break; 1959 1960 case ACPI_IORT_NODE_NAMED_COMPONENT: 1961 1962 InfoTable = AcpiDmTableInfoIort1; 1963 Length = ACPI_OFFSET (ACPI_IORT_NAMED_COMPONENT, DeviceName); 1964 String = ACPI_ADD_PTR (char, IortNode, NodeOffset + Length); 1965 Length += strlen (String) + 1; 1966 break; 1967 1968 case ACPI_IORT_NODE_PCI_ROOT_COMPLEX: 1969 1970 InfoTable = AcpiDmTableInfoIort2; 1971 Length = IortNode->Length - NodeOffset; 1972 break; 1973 1974 case ACPI_IORT_NODE_SMMU: 1975 1976 InfoTable = AcpiDmTableInfoIort3; 1977 Length = ACPI_OFFSET (ACPI_IORT_SMMU, Interrupts); 1978 IortSmmu = ACPI_ADD_PTR (ACPI_IORT_SMMU, IortNode, NodeOffset); 1979 break; 1980 1981 case ACPI_IORT_NODE_SMMU_V3: 1982 1983 InfoTable = AcpiDmTableInfoIort4; 1984 Length = IortNode->Length - NodeOffset; 1985 break; 1986 1987 default: 1988 1989 AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n", 1990 IortNode->Type); 1991 1992 /* Attempt to continue */ 1993 1994 if (!IortNode->Length) 1995 { 1996 AcpiOsPrintf ("Invalid zero length IORT node\n"); 1997 return; 1998 } 1999 goto NextSubTable; 2000 } 2001 2002 /* Dump the node subtable header */ 2003 2004 AcpiOsPrintf ("\n"); 2005 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2006 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2007 Length, InfoTable); 2008 if (ACPI_FAILURE (Status)) 2009 { 2010 return; 2011 } 2012 2013 NodeOffset += Length; 2014 2015 /* Dump the node specific data */ 2016 2017 switch (IortNode->Type) 2018 { 2019 case ACPI_IORT_NODE_ITS_GROUP: 2020 2021 /* Validate IortItsGroup to avoid compiler warnings */ 2022 2023 if (IortItsGroup) 2024 { 2025 for (i = 0; i < IortItsGroup->ItsCount; i++) 2026 { 2027 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2028 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2029 4, AcpiDmTableInfoIort0a); 2030 NodeOffset += 4; 2031 } 2032 } 2033 break; 2034 2035 case ACPI_IORT_NODE_NAMED_COMPONENT: 2036 2037 /* Dump the Padding (optional) */ 2038 2039 if (IortNode->Length > NodeOffset) 2040 { 2041 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2042 Table, IortNode->Length - NodeOffset, 2043 AcpiDmTableInfoIort1a); 2044 if (ACPI_FAILURE (Status)) 2045 { 2046 return; 2047 } 2048 } 2049 break; 2050 2051 case ACPI_IORT_NODE_SMMU: 2052 2053 AcpiOsPrintf ("\n"); 2054 2055 /* Validate IortSmmu to avoid compiler warnings */ 2056 2057 if (IortSmmu) 2058 { 2059 Length = 2 * sizeof (UINT64); 2060 NodeOffset = IortSmmu->GlobalInterruptOffset; 2061 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2062 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2063 Length, AcpiDmTableInfoIort3a); 2064 if (ACPI_FAILURE (Status)) 2065 { 2066 return; 2067 } 2068 2069 NodeOffset = IortSmmu->ContextInterruptOffset; 2070 for (i = 0; i < IortSmmu->ContextInterruptCount; i++) 2071 { 2072 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2073 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2074 8, AcpiDmTableInfoIort3b); 2075 if (ACPI_FAILURE (Status)) 2076 { 2077 return; 2078 } 2079 2080 NodeOffset += 8; 2081 } 2082 2083 NodeOffset = IortSmmu->PmuInterruptOffset; 2084 for (i = 0; i < IortSmmu->PmuInterruptCount; i++) 2085 { 2086 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2087 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2088 8, AcpiDmTableInfoIort3c); 2089 if (ACPI_FAILURE (Status)) 2090 { 2091 return; 2092 } 2093 2094 NodeOffset += 8; 2095 } 2096 } 2097 break; 2098 2099 default: 2100 2101 break; 2102 } 2103 2104 /* Dump the ID mappings */ 2105 2106 NodeOffset = IortNode->MappingOffset; 2107 for (i = 0; i < IortNode->MappingCount; i++) 2108 { 2109 AcpiOsPrintf ("\n"); 2110 Length = sizeof (ACPI_IORT_ID_MAPPING); 2111 Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset, 2112 ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset), 2113 Length, AcpiDmTableInfoIortMap); 2114 if (ACPI_FAILURE (Status)) 2115 { 2116 return; 2117 } 2118 2119 NodeOffset += Length; 2120 } 2121 2122 NextSubTable: 2123 /* Point to next node subtable */ 2124 2125 Offset += IortNode->Length; 2126 IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, IortNode->Length); 2127 } 2128 } 2129 2130 2131 /******************************************************************************* 2132 * 2133 * FUNCTION: AcpiDmDumpIvrs 2134 * 2135 * PARAMETERS: Table - A IVRS table 2136 * 2137 * RETURN: None 2138 * 2139 * DESCRIPTION: Format the contents of a IVRS 2140 * 2141 ******************************************************************************/ 2142 2143 static UINT8 EntrySizes[] = {4,8,16,32}; 2144 2145 void 2146 AcpiDmDumpIvrs ( 2147 ACPI_TABLE_HEADER *Table) 2148 { 2149 ACPI_STATUS Status; 2150 UINT32 Offset = sizeof (ACPI_TABLE_IVRS); 2151 UINT32 EntryOffset; 2152 UINT32 EntryLength; 2153 UINT32 EntryType; 2154 ACPI_IVRS_DE_HEADER *DeviceEntry; 2155 ACPI_IVRS_HEADER *SubTable; 2156 ACPI_DMTABLE_INFO *InfoTable; 2157 2158 2159 /* Main table */ 2160 2161 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); 2162 if (ACPI_FAILURE (Status)) 2163 { 2164 return; 2165 } 2166 2167 /* Subtables */ 2168 2169 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); 2170 while (Offset < Table->Length) 2171 { 2172 /* Common subtable header */ 2173 2174 AcpiOsPrintf ("\n"); 2175 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2176 SubTable->Length, AcpiDmTableInfoIvrsHdr); 2177 if (ACPI_FAILURE (Status)) 2178 { 2179 return; 2180 } 2181 2182 switch (SubTable->Type) 2183 { 2184 case ACPI_IVRS_TYPE_HARDWARE: 2185 2186 InfoTable = AcpiDmTableInfoIvrs0; 2187 break; 2188 2189 case ACPI_IVRS_TYPE_MEMORY1: 2190 case ACPI_IVRS_TYPE_MEMORY2: 2191 case ACPI_IVRS_TYPE_MEMORY3: 2192 2193 InfoTable = AcpiDmTableInfoIvrs1; 2194 break; 2195 2196 default: 2197 2198 AcpiOsPrintf ("\n**** Unknown IVRS subtable type 0x%X\n", 2199 SubTable->Type); 2200 2201 /* Attempt to continue */ 2202 2203 if (!SubTable->Length) 2204 { 2205 AcpiOsPrintf ("Invalid zero length subtable\n"); 2206 return; 2207 } 2208 goto NextSubTable; 2209 } 2210 2211 /* Dump the subtable */ 2212 2213 AcpiOsPrintf ("\n"); 2214 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2215 SubTable->Length, InfoTable); 2216 if (ACPI_FAILURE (Status)) 2217 { 2218 return; 2219 } 2220 2221 /* The hardware subtable can contain multiple device entries */ 2222 2223 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE) 2224 { 2225 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE); 2226 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable, 2227 sizeof (ACPI_IVRS_HARDWARE)); 2228 2229 while (EntryOffset < (Offset + SubTable->Length)) 2230 { 2231 AcpiOsPrintf ("\n"); 2232 /* 2233 * Upper 2 bits of Type encode the length of the device entry 2234 * 2235 * 00 = 4 byte 2236 * 01 = 8 byte 2237 * 10 = 16 byte - currently no entries defined 2238 * 11 = 32 byte - currently no entries defined 2239 */ 2240 EntryType = DeviceEntry->Type; 2241 EntryLength = EntrySizes [EntryType >> 6]; 2242 2243 switch (EntryType) 2244 { 2245 /* 4-byte device entries */ 2246 2247 case ACPI_IVRS_TYPE_PAD4: 2248 case ACPI_IVRS_TYPE_ALL: 2249 case ACPI_IVRS_TYPE_SELECT: 2250 case ACPI_IVRS_TYPE_START: 2251 case ACPI_IVRS_TYPE_END: 2252 2253 InfoTable = AcpiDmTableInfoIvrs4; 2254 break; 2255 2256 /* 8-byte entries, type A */ 2257 2258 case ACPI_IVRS_TYPE_ALIAS_SELECT: 2259 case ACPI_IVRS_TYPE_ALIAS_START: 2260 2261 InfoTable = AcpiDmTableInfoIvrs8a; 2262 break; 2263 2264 /* 8-byte entries, type B */ 2265 2266 case ACPI_IVRS_TYPE_PAD8: 2267 case ACPI_IVRS_TYPE_EXT_SELECT: 2268 case ACPI_IVRS_TYPE_EXT_START: 2269 2270 InfoTable = AcpiDmTableInfoIvrs8b; 2271 break; 2272 2273 /* 8-byte entries, type C */ 2274 2275 case ACPI_IVRS_TYPE_SPECIAL: 2276 2277 InfoTable = AcpiDmTableInfoIvrs8c; 2278 break; 2279 2280 default: 2281 InfoTable = AcpiDmTableInfoIvrs4; 2282 AcpiOsPrintf ( 2283 "\n**** Unknown IVRS device entry type/length: " 2284 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n", 2285 EntryType, EntryLength, EntryOffset); 2286 break; 2287 } 2288 2289 /* Dump the Device Entry */ 2290 2291 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 2292 DeviceEntry, EntryLength, InfoTable); 2293 if (ACPI_FAILURE (Status)) 2294 { 2295 return; 2296 } 2297 2298 EntryOffset += EntryLength; 2299 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry, 2300 EntryLength); 2301 } 2302 } 2303 2304 NextSubTable: 2305 /* Point to next subtable */ 2306 2307 Offset += SubTable->Length; 2308 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length); 2309 } 2310 } 2311 2312 2313 /******************************************************************************* 2314 * 2315 * FUNCTION: AcpiDmDumpLpit 2316 * 2317 * PARAMETERS: Table - A LPIT table 2318 * 2319 * RETURN: None 2320 * 2321 * DESCRIPTION: Format the contents of a LPIT. This table type consists 2322 * of an open-ended number of subtables. Note: There are no 2323 * entries in the main table. An LPIT consists of the table 2324 * header and then subtables only. 2325 * 2326 ******************************************************************************/ 2327 2328 void 2329 AcpiDmDumpLpit ( 2330 ACPI_TABLE_HEADER *Table) 2331 { 2332 ACPI_STATUS Status; 2333 ACPI_LPIT_HEADER *SubTable; 2334 UINT32 Length = Table->Length; 2335 UINT32 Offset = sizeof (ACPI_TABLE_LPIT); 2336 ACPI_DMTABLE_INFO *InfoTable; 2337 UINT32 SubTableLength; 2338 2339 2340 /* Subtables */ 2341 2342 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, Table, Offset); 2343 while (Offset < Table->Length) 2344 { 2345 /* Common subtable header */ 2346 2347 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2348 sizeof (ACPI_LPIT_HEADER), AcpiDmTableInfoLpitHdr); 2349 if (ACPI_FAILURE (Status)) 2350 { 2351 return; 2352 } 2353 2354 switch (SubTable->Type) 2355 { 2356 case ACPI_LPIT_TYPE_NATIVE_CSTATE: 2357 2358 InfoTable = AcpiDmTableInfoLpit0; 2359 SubTableLength = sizeof (ACPI_LPIT_NATIVE); 2360 break; 2361 2362 default: 2363 2364 /* Cannot continue on unknown type - no length */ 2365 2366 AcpiOsPrintf ("\n**** Unknown LPIT subtable type 0x%X\n", 2367 SubTable->Type); 2368 return; 2369 } 2370 2371 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2372 SubTableLength, InfoTable); 2373 if (ACPI_FAILURE (Status)) 2374 { 2375 return; 2376 } 2377 2378 AcpiOsPrintf ("\n"); 2379 2380 /* Point to next subtable */ 2381 2382 Offset += SubTableLength; 2383 SubTable = ACPI_ADD_PTR (ACPI_LPIT_HEADER, SubTable, SubTableLength); 2384 } 2385 } 2386 2387 2388 /******************************************************************************* 2389 * 2390 * FUNCTION: AcpiDmDumpMadt 2391 * 2392 * PARAMETERS: Table - A MADT table 2393 * 2394 * RETURN: None 2395 * 2396 * DESCRIPTION: Format the contents of a MADT. This table type consists 2397 * of an open-ended number of subtables. 2398 * 2399 ******************************************************************************/ 2400 2401 void 2402 AcpiDmDumpMadt ( 2403 ACPI_TABLE_HEADER *Table) 2404 { 2405 ACPI_STATUS Status; 2406 ACPI_SUBTABLE_HEADER *SubTable; 2407 UINT32 Length = Table->Length; 2408 UINT32 Offset = sizeof (ACPI_TABLE_MADT); 2409 ACPI_DMTABLE_INFO *InfoTable; 2410 2411 2412 /* Main table */ 2413 2414 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); 2415 if (ACPI_FAILURE (Status)) 2416 { 2417 return; 2418 } 2419 2420 /* Subtables */ 2421 2422 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 2423 while (Offset < Table->Length) 2424 { 2425 /* Common subtable header */ 2426 2427 AcpiOsPrintf ("\n"); 2428 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2429 SubTable->Length, AcpiDmTableInfoMadtHdr); 2430 if (ACPI_FAILURE (Status)) 2431 { 2432 return; 2433 } 2434 2435 switch (SubTable->Type) 2436 { 2437 case ACPI_MADT_TYPE_LOCAL_APIC: 2438 2439 InfoTable = AcpiDmTableInfoMadt0; 2440 break; 2441 2442 case ACPI_MADT_TYPE_IO_APIC: 2443 2444 InfoTable = AcpiDmTableInfoMadt1; 2445 break; 2446 2447 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 2448 2449 InfoTable = AcpiDmTableInfoMadt2; 2450 break; 2451 2452 case ACPI_MADT_TYPE_NMI_SOURCE: 2453 2454 InfoTable = AcpiDmTableInfoMadt3; 2455 break; 2456 2457 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 2458 2459 InfoTable = AcpiDmTableInfoMadt4; 2460 break; 2461 2462 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 2463 2464 InfoTable = AcpiDmTableInfoMadt5; 2465 break; 2466 2467 case ACPI_MADT_TYPE_IO_SAPIC: 2468 2469 InfoTable = AcpiDmTableInfoMadt6; 2470 break; 2471 2472 case ACPI_MADT_TYPE_LOCAL_SAPIC: 2473 2474 InfoTable = AcpiDmTableInfoMadt7; 2475 break; 2476 2477 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 2478 2479 InfoTable = AcpiDmTableInfoMadt8; 2480 break; 2481 2482 case ACPI_MADT_TYPE_LOCAL_X2APIC: 2483 2484 InfoTable = AcpiDmTableInfoMadt9; 2485 break; 2486 2487 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 2488 2489 InfoTable = AcpiDmTableInfoMadt10; 2490 break; 2491 2492 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 2493 2494 InfoTable = AcpiDmTableInfoMadt11; 2495 break; 2496 2497 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 2498 2499 InfoTable = AcpiDmTableInfoMadt12; 2500 break; 2501 2502 case ACPI_MADT_TYPE_GENERIC_MSI_FRAME: 2503 2504 InfoTable = AcpiDmTableInfoMadt13; 2505 break; 2506 2507 case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR: 2508 2509 InfoTable = AcpiDmTableInfoMadt14; 2510 break; 2511 2512 case ACPI_MADT_TYPE_GENERIC_TRANSLATOR: 2513 2514 InfoTable = AcpiDmTableInfoMadt15; 2515 break; 2516 2517 default: 2518 2519 AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n", 2520 SubTable->Type); 2521 2522 /* Attempt to continue */ 2523 2524 if (!SubTable->Length) 2525 { 2526 AcpiOsPrintf ("Invalid zero length subtable\n"); 2527 return; 2528 } 2529 2530 goto NextSubTable; 2531 } 2532 2533 Status = AcpiDmDumpTable (Length, Offset, SubTable, 2534 SubTable->Length, InfoTable); 2535 if (ACPI_FAILURE (Status)) 2536 { 2537 return; 2538 } 2539 2540 NextSubTable: 2541 /* Point to next subtable */ 2542 2543 Offset += SubTable->Length; 2544 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, 2545 SubTable->Length); 2546 } 2547 } 2548 2549 2550 /******************************************************************************* 2551 * 2552 * FUNCTION: AcpiDmDumpMcfg 2553 * 2554 * PARAMETERS: Table - A MCFG Table 2555 * 2556 * RETURN: None 2557 * 2558 * DESCRIPTION: Format the contents of a MCFG table 2559 * 2560 ******************************************************************************/ 2561 2562 void 2563 AcpiDmDumpMcfg ( 2564 ACPI_TABLE_HEADER *Table) 2565 { 2566 ACPI_STATUS Status; 2567 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 2568 ACPI_MCFG_ALLOCATION *SubTable; 2569 2570 2571 /* Main table */ 2572 2573 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 2574 if (ACPI_FAILURE (Status)) 2575 { 2576 return; 2577 } 2578 2579 /* Subtables */ 2580 2581 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 2582 while (Offset < Table->Length) 2583 { 2584 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 2585 { 2586 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", 2587 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 2588 return; 2589 } 2590 2591 AcpiOsPrintf ("\n"); 2592 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2593 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 2594 if (ACPI_FAILURE (Status)) 2595 { 2596 return; 2597 } 2598 2599 /* Point to next subtable (each subtable is of fixed length) */ 2600 2601 Offset += sizeof (ACPI_MCFG_ALLOCATION); 2602 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable, 2603 sizeof (ACPI_MCFG_ALLOCATION)); 2604 } 2605 } 2606 2607 2608 /******************************************************************************* 2609 * 2610 * FUNCTION: AcpiDmDumpMpst 2611 * 2612 * PARAMETERS: Table - A MPST Table 2613 * 2614 * RETURN: None 2615 * 2616 * DESCRIPTION: Format the contents of a MPST table 2617 * 2618 ******************************************************************************/ 2619 2620 void 2621 AcpiDmDumpMpst ( 2622 ACPI_TABLE_HEADER *Table) 2623 { 2624 ACPI_STATUS Status; 2625 UINT32 Offset = sizeof (ACPI_TABLE_MPST); 2626 ACPI_MPST_POWER_NODE *SubTable0; 2627 ACPI_MPST_POWER_STATE *SubTable0A; 2628 ACPI_MPST_COMPONENT *SubTable0B; 2629 ACPI_MPST_DATA_HDR *SubTable1; 2630 ACPI_MPST_POWER_DATA *SubTable2; 2631 UINT16 SubtableCount; 2632 UINT32 PowerStateCount; 2633 UINT32 ComponentCount; 2634 2635 2636 /* Main table */ 2637 2638 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); 2639 if (ACPI_FAILURE (Status)) 2640 { 2641 return; 2642 } 2643 2644 /* Subtable: Memory Power Node(s) */ 2645 2646 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; 2647 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); 2648 2649 while ((Offset < Table->Length) && SubtableCount) 2650 { 2651 AcpiOsPrintf ("\n"); 2652 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0, 2653 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); 2654 if (ACPI_FAILURE (Status)) 2655 { 2656 return; 2657 } 2658 2659 /* Extract the sub-subtable counts */ 2660 2661 PowerStateCount = SubTable0->NumPowerStates; 2662 ComponentCount = SubTable0->NumPhysicalComponents; 2663 Offset += sizeof (ACPI_MPST_POWER_NODE); 2664 2665 /* Sub-subtables - Memory Power State Structure(s) */ 2666 2667 SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0, 2668 sizeof (ACPI_MPST_POWER_NODE)); 2669 2670 while (PowerStateCount) 2671 { 2672 AcpiOsPrintf ("\n"); 2673 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A, 2674 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); 2675 if (ACPI_FAILURE (Status)) 2676 { 2677 return; 2678 } 2679 2680 SubTable0A++; 2681 PowerStateCount--; 2682 Offset += sizeof (ACPI_MPST_POWER_STATE); 2683 } 2684 2685 /* Sub-subtables - Physical Component ID Structure(s) */ 2686 2687 SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A); 2688 2689 if (ComponentCount) 2690 { 2691 AcpiOsPrintf ("\n"); 2692 } 2693 2694 while (ComponentCount) 2695 { 2696 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B, 2697 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); 2698 if (ACPI_FAILURE (Status)) 2699 { 2700 return; 2701 } 2702 2703 SubTable0B++; 2704 ComponentCount--; 2705 Offset += sizeof (ACPI_MPST_COMPONENT); 2706 } 2707 2708 /* Point to next Memory Power Node subtable */ 2709 2710 SubtableCount--; 2711 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0, 2712 sizeof (ACPI_MPST_POWER_NODE) + 2713 (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) + 2714 (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents)); 2715 } 2716 2717 /* Subtable: Count of Memory Power State Characteristic structures */ 2718 2719 AcpiOsPrintf ("\n"); 2720 SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0); 2721 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1, 2722 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); 2723 if (ACPI_FAILURE (Status)) 2724 { 2725 return; 2726 } 2727 2728 SubtableCount = SubTable1->CharacteristicsCount; 2729 Offset += sizeof (ACPI_MPST_DATA_HDR); 2730 2731 /* Subtable: Memory Power State Characteristics structure(s) */ 2732 2733 SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, 2734 sizeof (ACPI_MPST_DATA_HDR)); 2735 2736 while ((Offset < Table->Length) && SubtableCount) 2737 { 2738 AcpiOsPrintf ("\n"); 2739 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2, 2740 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); 2741 if (ACPI_FAILURE (Status)) 2742 { 2743 return; 2744 } 2745 2746 SubTable2++; 2747 SubtableCount--; 2748 Offset += sizeof (ACPI_MPST_POWER_DATA); 2749 } 2750 } 2751 2752 2753 /******************************************************************************* 2754 * 2755 * FUNCTION: AcpiDmDumpMsct 2756 * 2757 * PARAMETERS: Table - A MSCT table 2758 * 2759 * RETURN: None 2760 * 2761 * DESCRIPTION: Format the contents of a MSCT 2762 * 2763 ******************************************************************************/ 2764 2765 void 2766 AcpiDmDumpMsct ( 2767 ACPI_TABLE_HEADER *Table) 2768 { 2769 ACPI_STATUS Status; 2770 UINT32 Offset = sizeof (ACPI_TABLE_MSCT); 2771 ACPI_MSCT_PROXIMITY *SubTable; 2772 2773 2774 /* Main table */ 2775 2776 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); 2777 if (ACPI_FAILURE (Status)) 2778 { 2779 return; 2780 } 2781 2782 /* Subtables */ 2783 2784 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); 2785 while (Offset < Table->Length) 2786 { 2787 /* Common subtable header */ 2788 2789 AcpiOsPrintf ("\n"); 2790 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2791 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); 2792 if (ACPI_FAILURE (Status)) 2793 { 2794 return; 2795 } 2796 2797 /* Point to next subtable */ 2798 2799 Offset += sizeof (ACPI_MSCT_PROXIMITY); 2800 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, 2801 sizeof (ACPI_MSCT_PROXIMITY)); 2802 } 2803 } 2804 2805 2806 /******************************************************************************* 2807 * 2808 * FUNCTION: AcpiDmDumpMtmr 2809 * 2810 * PARAMETERS: Table - A MTMR table 2811 * 2812 * RETURN: None 2813 * 2814 * DESCRIPTION: Format the contents of a MTMR 2815 * 2816 ******************************************************************************/ 2817 2818 void 2819 AcpiDmDumpMtmr ( 2820 ACPI_TABLE_HEADER *Table) 2821 { 2822 ACPI_STATUS Status; 2823 UINT32 Offset = sizeof (ACPI_TABLE_MTMR); 2824 ACPI_MTMR_ENTRY *SubTable; 2825 2826 2827 /* Main table */ 2828 2829 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMtmr); 2830 if (ACPI_FAILURE (Status)) 2831 { 2832 return; 2833 } 2834 2835 /* Subtables */ 2836 2837 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, Table, Offset); 2838 while (Offset < Table->Length) 2839 { 2840 /* Common subtable header */ 2841 2842 AcpiOsPrintf ("\n"); 2843 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2844 sizeof (ACPI_MTMR_ENTRY), AcpiDmTableInfoMtmr0); 2845 if (ACPI_FAILURE (Status)) 2846 { 2847 return; 2848 } 2849 2850 /* Point to next subtable */ 2851 2852 Offset += sizeof (ACPI_MTMR_ENTRY); 2853 SubTable = ACPI_ADD_PTR (ACPI_MTMR_ENTRY, SubTable, 2854 sizeof (ACPI_MTMR_ENTRY)); 2855 } 2856 } 2857 2858 2859 /******************************************************************************* 2860 * 2861 * FUNCTION: AcpiDmDumpNfit 2862 * 2863 * PARAMETERS: Table - A NFIT table 2864 * 2865 * RETURN: None 2866 * 2867 * DESCRIPTION: Format the contents of an NFIT. 2868 * 2869 ******************************************************************************/ 2870 2871 void 2872 AcpiDmDumpNfit ( 2873 ACPI_TABLE_HEADER *Table) 2874 { 2875 ACPI_STATUS Status; 2876 UINT32 Offset = sizeof (ACPI_TABLE_NFIT); 2877 UINT32 FieldOffset = 0; 2878 UINT32 Length; 2879 ACPI_NFIT_HEADER *SubTable; 2880 ACPI_DMTABLE_INFO *InfoTable; 2881 ACPI_NFIT_INTERLEAVE *Interleave = NULL; 2882 ACPI_NFIT_SMBIOS *SmbiosInfo = NULL; 2883 ACPI_NFIT_FLUSH_ADDRESS *Hint = NULL; 2884 UINT32 i; 2885 2886 2887 /* Main table */ 2888 2889 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoNfit); 2890 if (ACPI_FAILURE (Status)) 2891 { 2892 return; 2893 } 2894 2895 /* Subtables */ 2896 2897 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, Table, Offset); 2898 while (Offset < Table->Length) 2899 { 2900 /* NFIT subtable header */ 2901 2902 AcpiOsPrintf ("\n"); 2903 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2904 SubTable->Length, AcpiDmTableInfoNfitHdr); 2905 if (ACPI_FAILURE (Status)) 2906 { 2907 return; 2908 } 2909 2910 switch (SubTable->Type) 2911 { 2912 case ACPI_NFIT_TYPE_SYSTEM_ADDRESS: 2913 2914 InfoTable = AcpiDmTableInfoNfit0; 2915 break; 2916 2917 case ACPI_NFIT_TYPE_MEMORY_MAP: 2918 2919 InfoTable = AcpiDmTableInfoNfit1; 2920 break; 2921 2922 case ACPI_NFIT_TYPE_INTERLEAVE: 2923 2924 /* Has a variable number of 32-bit values at the end */ 2925 2926 InfoTable = AcpiDmTableInfoNfit2; 2927 Interleave = ACPI_CAST_PTR (ACPI_NFIT_INTERLEAVE, SubTable); 2928 FieldOffset = sizeof (ACPI_NFIT_INTERLEAVE); 2929 break; 2930 2931 case ACPI_NFIT_TYPE_SMBIOS: 2932 2933 SmbiosInfo = ACPI_CAST_PTR (ACPI_NFIT_SMBIOS, SubTable); 2934 InfoTable = AcpiDmTableInfoNfit3; 2935 break; 2936 2937 case ACPI_NFIT_TYPE_CONTROL_REGION: 2938 2939 InfoTable = AcpiDmTableInfoNfit4; 2940 break; 2941 2942 case ACPI_NFIT_TYPE_DATA_REGION: 2943 2944 InfoTable = AcpiDmTableInfoNfit5; 2945 break; 2946 2947 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 2948 2949 /* Has a variable number of 64-bit addresses at the end */ 2950 2951 InfoTable = AcpiDmTableInfoNfit6; 2952 Hint = ACPI_CAST_PTR (ACPI_NFIT_FLUSH_ADDRESS, SubTable); 2953 FieldOffset = sizeof (ACPI_NFIT_FLUSH_ADDRESS) - sizeof (UINT64); 2954 break; 2955 2956 default: 2957 AcpiOsPrintf ("\n**** Unknown NFIT subtable type 0x%X\n", 2958 SubTable->Type); 2959 2960 /* Attempt to continue */ 2961 2962 if (!SubTable->Length) 2963 { 2964 AcpiOsPrintf ("Invalid zero length subtable\n"); 2965 return; 2966 } 2967 goto NextSubTable; 2968 } 2969 2970 AcpiOsPrintf ("\n"); 2971 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2972 SubTable->Length, InfoTable); 2973 if (ACPI_FAILURE (Status)) 2974 { 2975 return; 2976 } 2977 2978 /* Per-subtable variable-length fields */ 2979 2980 switch (SubTable->Type) 2981 { 2982 case ACPI_NFIT_TYPE_INTERLEAVE: 2983 2984 for (i = 0; i < Interleave->LineCount; i++) 2985 { 2986 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 2987 &Interleave->LineOffset[i], 2988 sizeof (UINT32), AcpiDmTableInfoNfit2a); 2989 if (ACPI_FAILURE (Status)) 2990 { 2991 return; 2992 } 2993 2994 FieldOffset += sizeof (UINT32); 2995 } 2996 break; 2997 2998 case ACPI_NFIT_TYPE_SMBIOS: 2999 3000 Length = SubTable->Length - 3001 sizeof (ACPI_NFIT_SMBIOS) + sizeof (UINT8); 3002 3003 if (Length) 3004 { 3005 Status = AcpiDmDumpTable (Table->Length, 3006 sizeof (ACPI_NFIT_SMBIOS) - sizeof (UINT8), 3007 SmbiosInfo, 3008 Length, AcpiDmTableInfoNfit3a); 3009 if (ACPI_FAILURE (Status)) 3010 { 3011 return; 3012 } 3013 } 3014 3015 break; 3016 3017 case ACPI_NFIT_TYPE_FLUSH_ADDRESS: 3018 3019 for (i = 0; i < Hint->HintCount; i++) 3020 { 3021 Status = AcpiDmDumpTable (Table->Length, Offset + FieldOffset, 3022 &Hint->HintAddress[i], 3023 sizeof (UINT64), AcpiDmTableInfoNfit6a); 3024 if (ACPI_FAILURE (Status)) 3025 { 3026 return; 3027 } 3028 3029 FieldOffset += sizeof (UINT64); 3030 } 3031 break; 3032 3033 default: 3034 break; 3035 } 3036 3037 NextSubTable: 3038 /* Point to next subtable */ 3039 3040 Offset += SubTable->Length; 3041 SubTable = ACPI_ADD_PTR (ACPI_NFIT_HEADER, SubTable, SubTable->Length); 3042 } 3043 } 3044 3045 3046 /******************************************************************************* 3047 * 3048 * FUNCTION: AcpiDmDumpPcct 3049 * 3050 * PARAMETERS: Table - A PCCT table 3051 * 3052 * RETURN: None 3053 * 3054 * DESCRIPTION: Format the contents of a PCCT. This table type consists 3055 * of an open-ended number of subtables. 3056 * 3057 ******************************************************************************/ 3058 3059 void 3060 AcpiDmDumpPcct ( 3061 ACPI_TABLE_HEADER *Table) 3062 { 3063 ACPI_STATUS Status; 3064 ACPI_PCCT_SUBSPACE *SubTable; 3065 ACPI_DMTABLE_INFO *InfoTable; 3066 UINT32 Length = Table->Length; 3067 UINT32 Offset = sizeof (ACPI_TABLE_PCCT); 3068 3069 3070 /* Main table */ 3071 3072 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); 3073 if (ACPI_FAILURE (Status)) 3074 { 3075 return; 3076 } 3077 3078 /* Subtables */ 3079 3080 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); 3081 while (Offset < Table->Length) 3082 { 3083 /* Common subtable header */ 3084 3085 AcpiOsPrintf ("\n"); 3086 Status = AcpiDmDumpTable (Length, Offset, SubTable, 3087 SubTable->Header.Length, AcpiDmTableInfoPcctHdr); 3088 if (ACPI_FAILURE (Status)) 3089 { 3090 return; 3091 } 3092 3093 switch (SubTable->Header.Type) 3094 { 3095 case ACPI_PCCT_TYPE_GENERIC_SUBSPACE: 3096 3097 InfoTable = AcpiDmTableInfoPcct0; 3098 break; 3099 3100 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE: 3101 3102 InfoTable = AcpiDmTableInfoPcct1; 3103 break; 3104 3105 case ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2: 3106 3107 InfoTable = AcpiDmTableInfoPcct2; 3108 break; 3109 3110 case ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE: 3111 3112 InfoTable = AcpiDmTableInfoPcct3; 3113 break; 3114 3115 case ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE: 3116 3117 InfoTable = AcpiDmTableInfoPcct4; 3118 break; 3119 3120 default: 3121 3122 AcpiOsPrintf ( 3123 "\n**** Unexpected or unknown PCCT subtable type 0x%X\n\n", 3124 SubTable->Header.Type); 3125 return; 3126 } 3127 3128 AcpiOsPrintf ("\n"); 3129 Status = AcpiDmDumpTable (Length, Offset, SubTable, 3130 SubTable->Header.Length, InfoTable); 3131 if (ACPI_FAILURE (Status)) 3132 { 3133 return; 3134 } 3135 3136 /* Point to next subtable */ 3137 3138 Offset += SubTable->Header.Length; 3139 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable, 3140 SubTable->Header.Length); 3141 } 3142 } 3143 3144 3145 /******************************************************************************* 3146 * 3147 * FUNCTION: AcpiDmDumpPmtt 3148 * 3149 * PARAMETERS: Table - A PMTT table 3150 * 3151 * RETURN: None 3152 * 3153 * DESCRIPTION: Format the contents of a PMTT. This table type consists 3154 * of an open-ended number of subtables. 3155 * 3156 ******************************************************************************/ 3157 3158 void 3159 AcpiDmDumpPmtt ( 3160 ACPI_TABLE_HEADER *Table) 3161 { 3162 ACPI_STATUS Status; 3163 ACPI_PMTT_HEADER *SubTable; 3164 ACPI_PMTT_HEADER *MemSubTable; 3165 ACPI_PMTT_HEADER *DimmSubTable; 3166 ACPI_PMTT_DOMAIN *DomainArray; 3167 UINT32 Length = Table->Length; 3168 UINT32 Offset = sizeof (ACPI_TABLE_PMTT); 3169 UINT32 MemOffset; 3170 UINT32 DimmOffset; 3171 UINT32 DomainOffset; 3172 UINT32 DomainCount; 3173 3174 3175 /* Main table */ 3176 3177 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); 3178 if (ACPI_FAILURE (Status)) 3179 { 3180 return; 3181 } 3182 3183 /* Subtables */ 3184 3185 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); 3186 while (Offset < Table->Length) 3187 { 3188 /* Common subtable header */ 3189 3190 AcpiOsPrintf ("\n"); 3191 Status = AcpiDmDumpTable (Length, Offset, SubTable, 3192 SubTable->Length, AcpiDmTableInfoPmttHdr); 3193 if (ACPI_FAILURE (Status)) 3194 { 3195 return; 3196 } 3197 3198 /* Only Socket subtables are expected at this level */ 3199 3200 if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET) 3201 { 3202 AcpiOsPrintf ( 3203 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 3204 SubTable->Type); 3205 return; 3206 } 3207 3208 /* Dump the fixed-length portion of the subtable */ 3209 3210 Status = AcpiDmDumpTable (Length, Offset, SubTable, 3211 SubTable->Length, AcpiDmTableInfoPmtt0); 3212 if (ACPI_FAILURE (Status)) 3213 { 3214 return; 3215 } 3216 3217 /* Walk the memory controller subtables */ 3218 3219 MemOffset = sizeof (ACPI_PMTT_SOCKET); 3220 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, 3221 sizeof (ACPI_PMTT_SOCKET)); 3222 3223 while (((Offset + MemOffset) < Table->Length) && 3224 (MemOffset < SubTable->Length)) 3225 { 3226 /* Common subtable header */ 3227 3228 AcpiOsPrintf ("\n"); 3229 Status = AcpiDmDumpTable (Length, 3230 Offset + MemOffset, MemSubTable, 3231 MemSubTable->Length, AcpiDmTableInfoPmttHdr); 3232 if (ACPI_FAILURE (Status)) 3233 { 3234 return; 3235 } 3236 3237 /* Only memory controller subtables are expected at this level */ 3238 3239 if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER) 3240 { 3241 AcpiOsPrintf ( 3242 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 3243 MemSubTable->Type); 3244 return; 3245 } 3246 3247 /* Dump the fixed-length portion of the controller subtable */ 3248 3249 Status = AcpiDmDumpTable (Length, 3250 Offset + MemOffset, MemSubTable, 3251 MemSubTable->Length, AcpiDmTableInfoPmtt1); 3252 if (ACPI_FAILURE (Status)) 3253 { 3254 return; 3255 } 3256 3257 /* Walk the variable count of proximity domains */ 3258 3259 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount; 3260 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER); 3261 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable, 3262 sizeof (ACPI_PMTT_CONTROLLER)); 3263 3264 while (((Offset + MemOffset + DomainOffset) < Table->Length) && 3265 ((MemOffset + DomainOffset) < SubTable->Length) && 3266 DomainCount) 3267 { 3268 Status = AcpiDmDumpTable (Length, 3269 Offset + MemOffset + DomainOffset, DomainArray, 3270 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a); 3271 if (ACPI_FAILURE (Status)) 3272 { 3273 return; 3274 } 3275 3276 DomainOffset += sizeof (ACPI_PMTT_DOMAIN); 3277 DomainArray++; 3278 DomainCount--; 3279 } 3280 3281 if (DomainCount) 3282 { 3283 AcpiOsPrintf ( 3284 "\n**** DomainCount exceeds subtable length\n\n"); 3285 } 3286 3287 /* Walk the physical component (DIMM) subtables */ 3288 3289 DimmOffset = DomainOffset; 3290 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable, 3291 DomainOffset); 3292 3293 while (((Offset + MemOffset + DimmOffset) < Table->Length) && 3294 (DimmOffset < MemSubTable->Length)) 3295 { 3296 /* Common subtable header */ 3297 3298 AcpiOsPrintf ("\n"); 3299 Status = AcpiDmDumpTable (Length, 3300 Offset + MemOffset + DimmOffset, DimmSubTable, 3301 DimmSubTable->Length, AcpiDmTableInfoPmttHdr); 3302 if (ACPI_FAILURE (Status)) 3303 { 3304 return; 3305 } 3306 3307 /* Only DIMM subtables are expected at this level */ 3308 3309 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM) 3310 { 3311 AcpiOsPrintf ( 3312 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 3313 DimmSubTable->Type); 3314 return; 3315 } 3316 3317 /* Dump the fixed-length DIMM subtable */ 3318 3319 Status = AcpiDmDumpTable (Length, 3320 Offset + MemOffset + DimmOffset, DimmSubTable, 3321 DimmSubTable->Length, AcpiDmTableInfoPmtt2); 3322 if (ACPI_FAILURE (Status)) 3323 { 3324 return; 3325 } 3326 3327 /* Point to next DIMM subtable */ 3328 3329 DimmOffset += DimmSubTable->Length; 3330 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 3331 DimmSubTable, DimmSubTable->Length); 3332 } 3333 3334 /* Point to next Controller subtable */ 3335 3336 MemOffset += MemSubTable->Length; 3337 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 3338 MemSubTable, MemSubTable->Length); 3339 } 3340 3341 /* Point to next Socket subtable */ 3342 3343 Offset += SubTable->Length; 3344 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 3345 SubTable, SubTable->Length); 3346 } 3347 } 3348 3349 3350 /******************************************************************************* 3351 * 3352 * FUNCTION: AcpiDmDumpPptt 3353 * 3354 * PARAMETERS: Table - A PMTT table 3355 * 3356 * RETURN: None 3357 * 3358 * DESCRIPTION: Format the contents of a PPTT. This table type consists 3359 * of an open-ended number of subtables. 3360 * 3361 ******************************************************************************/ 3362 3363 void 3364 AcpiDmDumpPptt ( 3365 ACPI_TABLE_HEADER *Table) 3366 { 3367 ACPI_STATUS Status; 3368 ACPI_SUBTABLE_HEADER *SubTable; 3369 ACPI_PPTT_PROCESSOR *PpttProcessor; 3370 UINT8 Length; 3371 UINT8 SubTableOffset; 3372 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 3373 ACPI_DMTABLE_INFO *InfoTable; 3374 UINT32 i; 3375 3376 3377 /* There is no main table (other than the standard ACPI header) */ 3378 3379 /* Subtables */ 3380 3381 Offset = sizeof (ACPI_TABLE_HEADER); 3382 while (Offset < Table->Length) 3383 { 3384 AcpiOsPrintf ("\n"); 3385 3386 /* Common subtable header */ 3387 3388 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 3389 if (SubTable->Length < sizeof (ACPI_SUBTABLE_HEADER)) 3390 { 3391 AcpiOsPrintf ("Invalid subtable length\n"); 3392 return; 3393 } 3394 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3395 SubTable->Length, AcpiDmTableInfoPpttHdr); 3396 if (ACPI_FAILURE (Status)) 3397 { 3398 return; 3399 } 3400 3401 switch (SubTable->Type) 3402 { 3403 case ACPI_PPTT_TYPE_PROCESSOR: 3404 3405 InfoTable = AcpiDmTableInfoPptt0; 3406 Length = sizeof (ACPI_PPTT_PROCESSOR); 3407 break; 3408 3409 case ACPI_PPTT_TYPE_CACHE: 3410 3411 InfoTable = AcpiDmTableInfoPptt1; 3412 Length = sizeof (ACPI_PPTT_CACHE); 3413 break; 3414 3415 case ACPI_PPTT_TYPE_ID: 3416 3417 InfoTable = AcpiDmTableInfoPptt2; 3418 Length = sizeof (ACPI_PPTT_ID); 3419 break; 3420 3421 default: 3422 3423 AcpiOsPrintf ("\n**** Unknown PPTT subtable type 0x%X\n\n", 3424 SubTable->Type); 3425 3426 /* Attempt to continue */ 3427 3428 goto NextSubTable; 3429 } 3430 3431 if (SubTable->Length < Length) 3432 { 3433 AcpiOsPrintf ("Invalid subtable length\n"); 3434 return; 3435 } 3436 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3437 SubTable->Length, InfoTable); 3438 if (ACPI_FAILURE (Status)) 3439 { 3440 return; 3441 } 3442 SubTableOffset = Length; 3443 3444 switch (SubTable->Type) 3445 { 3446 case ACPI_PPTT_TYPE_PROCESSOR: 3447 3448 PpttProcessor = ACPI_CAST_PTR (ACPI_PPTT_PROCESSOR, SubTable); 3449 3450 /* Dump SMBIOS handles */ 3451 3452 if ((UINT8)(SubTable->Length - SubTableOffset) < 3453 (UINT8)(PpttProcessor->NumberOfPrivResources * 4)) 3454 { 3455 AcpiOsPrintf ("Invalid private resource number\n"); 3456 return; 3457 } 3458 for (i = 0; i < PpttProcessor->NumberOfPrivResources; i++) 3459 { 3460 Status = AcpiDmDumpTable (Table->Length, Offset + SubTableOffset, 3461 ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTableOffset), 3462 4, AcpiDmTableInfoPptt0a); 3463 SubTableOffset += 4; 3464 } 3465 break; 3466 3467 default: 3468 3469 break; 3470 } 3471 3472 NextSubTable: 3473 /* Point to next subtable */ 3474 3475 Offset += SubTable->Length; 3476 } 3477 } 3478 3479 3480 /******************************************************************************* 3481 * 3482 * FUNCTION: AcpiDmDumpS3pt 3483 * 3484 * PARAMETERS: Table - A S3PT table 3485 * 3486 * RETURN: Length of the table 3487 * 3488 * DESCRIPTION: Format the contents of a S3PT 3489 * 3490 ******************************************************************************/ 3491 3492 UINT32 3493 AcpiDmDumpS3pt ( 3494 ACPI_TABLE_HEADER *Tables) 3495 { 3496 ACPI_STATUS Status; 3497 UINT32 Offset = sizeof (ACPI_TABLE_S3PT); 3498 ACPI_FPDT_HEADER *SubTable; 3499 ACPI_DMTABLE_INFO *InfoTable; 3500 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); 3501 3502 3503 /* Main table */ 3504 3505 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt); 3506 if (ACPI_FAILURE (Status)) 3507 { 3508 return 0; 3509 } 3510 3511 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, S3ptTable, Offset); 3512 while (Offset < S3ptTable->Length) 3513 { 3514 /* Common subtable header */ 3515 3516 AcpiOsPrintf ("\n"); 3517 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 3518 SubTable->Length, AcpiDmTableInfoS3ptHdr); 3519 if (ACPI_FAILURE (Status)) 3520 { 3521 return 0; 3522 } 3523 3524 switch (SubTable->Type) 3525 { 3526 case ACPI_S3PT_TYPE_RESUME: 3527 3528 InfoTable = AcpiDmTableInfoS3pt0; 3529 break; 3530 3531 case ACPI_S3PT_TYPE_SUSPEND: 3532 3533 InfoTable = AcpiDmTableInfoS3pt1; 3534 break; 3535 3536 default: 3537 3538 AcpiOsPrintf ("\n**** Unknown S3PT subtable type 0x%X\n", 3539 SubTable->Type); 3540 3541 /* Attempt to continue */ 3542 3543 if (!SubTable->Length) 3544 { 3545 AcpiOsPrintf ("Invalid zero length subtable\n"); 3546 return 0; 3547 } 3548 goto NextSubTable; 3549 } 3550 3551 AcpiOsPrintf ("\n"); 3552 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 3553 SubTable->Length, InfoTable); 3554 if (ACPI_FAILURE (Status)) 3555 { 3556 return 0; 3557 } 3558 3559 NextSubTable: 3560 /* Point to next subtable */ 3561 3562 Offset += SubTable->Length; 3563 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length); 3564 } 3565 3566 return (S3ptTable->Length); 3567 } 3568 3569 3570 /******************************************************************************* 3571 * 3572 * FUNCTION: AcpiDmDumpSlic 3573 * 3574 * PARAMETERS: Table - A SLIC table 3575 * 3576 * RETURN: None 3577 * 3578 * DESCRIPTION: Format the contents of a SLIC 3579 * 3580 ******************************************************************************/ 3581 3582 void 3583 AcpiDmDumpSlic ( 3584 ACPI_TABLE_HEADER *Table) 3585 { 3586 3587 (void) AcpiDmDumpTable (Table->Length, sizeof (ACPI_TABLE_HEADER), Table, 3588 Table->Length - sizeof (*Table), AcpiDmTableInfoSlic); 3589 } 3590 3591 3592 /******************************************************************************* 3593 * 3594 * FUNCTION: AcpiDmDumpSlit 3595 * 3596 * PARAMETERS: Table - An SLIT 3597 * 3598 * RETURN: None 3599 * 3600 * DESCRIPTION: Format the contents of a SLIT 3601 * 3602 ******************************************************************************/ 3603 3604 void 3605 AcpiDmDumpSlit ( 3606 ACPI_TABLE_HEADER *Table) 3607 { 3608 ACPI_STATUS Status; 3609 UINT32 Offset; 3610 UINT8 *Row; 3611 UINT32 Localities; 3612 UINT32 i; 3613 UINT32 j; 3614 3615 3616 /* Main table */ 3617 3618 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit); 3619 if (ACPI_FAILURE (Status)) 3620 { 3621 return; 3622 } 3623 3624 /* Display the Locality NxN Matrix */ 3625 3626 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; 3627 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]); 3628 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry; 3629 3630 for (i = 0; i < Localities; i++) 3631 { 3632 /* Display one row of the matrix */ 3633 3634 AcpiDmLineHeader2 (Offset, Localities, "Locality", i); 3635 for (j = 0; j < Localities; j++) 3636 { 3637 /* Check for beyond EOT */ 3638 3639 if (Offset >= Table->Length) 3640 { 3641 AcpiOsPrintf ( 3642 "\n**** Not enough room in table for all localities\n"); 3643 return; 3644 } 3645 3646 AcpiOsPrintf ("%2.2X", Row[j]); 3647 Offset++; 3648 3649 /* Display up to 16 bytes per output row */ 3650 3651 if ((j+1) < Localities) 3652 { 3653 AcpiOsPrintf (" "); 3654 3655 if (j && (((j+1) % 16) == 0)) 3656 { 3657 AcpiOsPrintf ("\\\n"); /* With line continuation char */ 3658 AcpiDmLineHeader (Offset, 0, NULL); 3659 } 3660 } 3661 } 3662 3663 /* Point to next row */ 3664 3665 AcpiOsPrintf ("\n"); 3666 Row += Localities; 3667 } 3668 } 3669 3670 3671 /******************************************************************************* 3672 * 3673 * FUNCTION: AcpiDmDumpSrat 3674 * 3675 * PARAMETERS: Table - A SRAT table 3676 * 3677 * RETURN: None 3678 * 3679 * DESCRIPTION: Format the contents of a SRAT 3680 * 3681 ******************************************************************************/ 3682 3683 void 3684 AcpiDmDumpSrat ( 3685 ACPI_TABLE_HEADER *Table) 3686 { 3687 ACPI_STATUS Status; 3688 UINT32 Offset = sizeof (ACPI_TABLE_SRAT); 3689 ACPI_SUBTABLE_HEADER *SubTable; 3690 ACPI_DMTABLE_INFO *InfoTable; 3691 3692 3693 /* Main table */ 3694 3695 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat); 3696 if (ACPI_FAILURE (Status)) 3697 { 3698 return; 3699 } 3700 3701 /* Subtables */ 3702 3703 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 3704 while (Offset < Table->Length) 3705 { 3706 /* Common subtable header */ 3707 3708 AcpiOsPrintf ("\n"); 3709 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3710 SubTable->Length, AcpiDmTableInfoSratHdr); 3711 if (ACPI_FAILURE (Status)) 3712 { 3713 return; 3714 } 3715 3716 switch (SubTable->Type) 3717 { 3718 case ACPI_SRAT_TYPE_CPU_AFFINITY: 3719 3720 InfoTable = AcpiDmTableInfoSrat0; 3721 break; 3722 3723 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 3724 3725 InfoTable = AcpiDmTableInfoSrat1; 3726 break; 3727 3728 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 3729 3730 InfoTable = AcpiDmTableInfoSrat2; 3731 break; 3732 3733 case ACPI_SRAT_TYPE_GICC_AFFINITY: 3734 3735 InfoTable = AcpiDmTableInfoSrat3; 3736 break; 3737 3738 case ACPI_SRAT_TYPE_GIC_ITS_AFFINITY: 3739 3740 InfoTable = AcpiDmTableInfoSrat4; 3741 break; 3742 3743 default: 3744 AcpiOsPrintf ("\n**** Unknown SRAT subtable type 0x%X\n", 3745 SubTable->Type); 3746 3747 /* Attempt to continue */ 3748 3749 if (!SubTable->Length) 3750 { 3751 AcpiOsPrintf ("Invalid zero length subtable\n"); 3752 return; 3753 } 3754 goto NextSubTable; 3755 } 3756 3757 AcpiOsPrintf ("\n"); 3758 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3759 SubTable->Length, InfoTable); 3760 if (ACPI_FAILURE (Status)) 3761 { 3762 return; 3763 } 3764 3765 NextSubTable: 3766 /* Point to next subtable */ 3767 3768 Offset += SubTable->Length; 3769 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, 3770 SubTable->Length); 3771 } 3772 } 3773 3774 3775 /******************************************************************************* 3776 * 3777 * FUNCTION: AcpiDmDumpStao 3778 * 3779 * PARAMETERS: Table - A STAO table 3780 * 3781 * RETURN: None 3782 * 3783 * DESCRIPTION: Format the contents of a STAO. This is a variable-length 3784 * table that contains an open-ended number of ASCII strings 3785 * at the end of the table. 3786 * 3787 ******************************************************************************/ 3788 3789 void 3790 AcpiDmDumpStao ( 3791 ACPI_TABLE_HEADER *Table) 3792 { 3793 ACPI_STATUS Status; 3794 char *Namepath; 3795 UINT32 Length = Table->Length; 3796 UINT32 StringLength; 3797 UINT32 Offset = sizeof (ACPI_TABLE_STAO); 3798 3799 3800 /* Main table */ 3801 3802 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoStao); 3803 if (ACPI_FAILURE (Status)) 3804 { 3805 return; 3806 } 3807 3808 /* The rest of the table consists of Namepath strings */ 3809 3810 while (Offset < Table->Length) 3811 { 3812 Namepath = ACPI_ADD_PTR (char, Table, Offset); 3813 StringLength = strlen (Namepath) + 1; 3814 3815 AcpiDmLineHeader (Offset, StringLength, "Namestring"); 3816 AcpiOsPrintf ("\"%s\"\n", Namepath); 3817 3818 /* Point to next namepath */ 3819 3820 Offset += StringLength; 3821 } 3822 } 3823 3824 3825 /******************************************************************************* 3826 * 3827 * FUNCTION: AcpiDmDumpTcpa 3828 * 3829 * PARAMETERS: Table - A TCPA table 3830 * 3831 * RETURN: None 3832 * 3833 * DESCRIPTION: Format the contents of a TCPA. 3834 * 3835 * NOTE: There are two versions of the table with the same signature: 3836 * the client version and the server version. The common 3837 * PlatformClass field is used to differentiate the two types of 3838 * tables. 3839 * 3840 ******************************************************************************/ 3841 3842 void 3843 AcpiDmDumpTcpa ( 3844 ACPI_TABLE_HEADER *Table) 3845 { 3846 UINT32 Offset = sizeof (ACPI_TABLE_TCPA_HDR); 3847 ACPI_TABLE_TCPA_HDR *CommonHeader = ACPI_CAST_PTR ( 3848 ACPI_TABLE_TCPA_HDR, Table); 3849 ACPI_TABLE_TCPA_HDR *SubTable = ACPI_ADD_PTR ( 3850 ACPI_TABLE_TCPA_HDR, Table, Offset); 3851 ACPI_STATUS Status; 3852 3853 3854 /* Main table */ 3855 3856 Status = AcpiDmDumpTable (Table->Length, 0, Table, 3857 0, AcpiDmTableInfoTcpaHdr); 3858 if (ACPI_FAILURE (Status)) 3859 { 3860 return; 3861 } 3862 3863 /* 3864 * Examine the PlatformClass field to determine the table type. 3865 * Either a client or server table. Only one. 3866 */ 3867 switch (CommonHeader->PlatformClass) 3868 { 3869 case ACPI_TCPA_CLIENT_TABLE: 3870 3871 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3872 Table->Length - Offset, AcpiDmTableInfoTcpaClient); 3873 break; 3874 3875 case ACPI_TCPA_SERVER_TABLE: 3876 3877 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3878 Table->Length - Offset, AcpiDmTableInfoTcpaServer); 3879 break; 3880 3881 default: 3882 3883 AcpiOsPrintf ("\n**** Unknown TCPA Platform Class 0x%X\n", 3884 CommonHeader->PlatformClass); 3885 Status = AE_ERROR; 3886 break; 3887 } 3888 3889 if (ACPI_FAILURE (Status)) 3890 { 3891 AcpiOsPrintf ("\n**** Cannot disassemble TCPA table\n"); 3892 } 3893 } 3894 3895 3896 /******************************************************************************* 3897 * 3898 * FUNCTION: AcpiDmDumpVrtc 3899 * 3900 * PARAMETERS: Table - A VRTC table 3901 * 3902 * RETURN: None 3903 * 3904 * DESCRIPTION: Format the contents of a VRTC 3905 * 3906 ******************************************************************************/ 3907 3908 void 3909 AcpiDmDumpVrtc ( 3910 ACPI_TABLE_HEADER *Table) 3911 { 3912 ACPI_STATUS Status; 3913 UINT32 Offset = sizeof (ACPI_TABLE_VRTC); 3914 ACPI_VRTC_ENTRY *SubTable; 3915 3916 3917 /* Main table */ 3918 3919 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoVrtc); 3920 if (ACPI_FAILURE (Status)) 3921 { 3922 return; 3923 } 3924 3925 /* Subtables */ 3926 3927 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, Table, Offset); 3928 while (Offset < Table->Length) 3929 { 3930 /* Common subtable header */ 3931 3932 AcpiOsPrintf ("\n"); 3933 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3934 sizeof (ACPI_VRTC_ENTRY), AcpiDmTableInfoVrtc0); 3935 if (ACPI_FAILURE (Status)) 3936 { 3937 return; 3938 } 3939 3940 /* Point to next subtable */ 3941 3942 Offset += sizeof (ACPI_VRTC_ENTRY); 3943 SubTable = ACPI_ADD_PTR (ACPI_VRTC_ENTRY, SubTable, 3944 sizeof (ACPI_VRTC_ENTRY)); 3945 } 3946 } 3947 3948 3949 /******************************************************************************* 3950 * 3951 * FUNCTION: AcpiDmDumpWdat 3952 * 3953 * PARAMETERS: Table - A WDAT table 3954 * 3955 * RETURN: None 3956 * 3957 * DESCRIPTION: Format the contents of a WDAT 3958 * 3959 ******************************************************************************/ 3960 3961 void 3962 AcpiDmDumpWdat ( 3963 ACPI_TABLE_HEADER *Table) 3964 { 3965 ACPI_STATUS Status; 3966 UINT32 Offset = sizeof (ACPI_TABLE_WDAT); 3967 ACPI_WDAT_ENTRY *SubTable; 3968 3969 3970 /* Main table */ 3971 3972 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat); 3973 if (ACPI_FAILURE (Status)) 3974 { 3975 return; 3976 } 3977 3978 /* Subtables */ 3979 3980 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset); 3981 while (Offset < Table->Length) 3982 { 3983 /* Common subtable header */ 3984 3985 AcpiOsPrintf ("\n"); 3986 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 3987 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0); 3988 if (ACPI_FAILURE (Status)) 3989 { 3990 return; 3991 } 3992 3993 /* Point to next subtable */ 3994 3995 Offset += sizeof (ACPI_WDAT_ENTRY); 3996 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, 3997 sizeof (ACPI_WDAT_ENTRY)); 3998 } 3999 } 4000 4001 4002 /******************************************************************************* 4003 * 4004 * FUNCTION: AcpiDmDumpWpbt 4005 * 4006 * PARAMETERS: Table - A WPBT table 4007 * 4008 * RETURN: None 4009 * 4010 * DESCRIPTION: Format the contents of a WPBT. This table type consists 4011 * of an open-ended arguments buffer at the end of the table. 4012 * 4013 ******************************************************************************/ 4014 4015 void 4016 AcpiDmDumpWpbt ( 4017 ACPI_TABLE_HEADER *Table) 4018 { 4019 ACPI_STATUS Status; 4020 ACPI_TABLE_WPBT *SubTable; 4021 UINT32 Length = Table->Length; 4022 UINT16 ArgumentsLength; 4023 4024 4025 /* Dump the main table */ 4026 4027 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoWpbt); 4028 if (ACPI_FAILURE (Status)) 4029 { 4030 return; 4031 } 4032 4033 /* Extract the arguments buffer length from the main table */ 4034 4035 SubTable = ACPI_CAST_PTR (ACPI_TABLE_WPBT, Table); 4036 ArgumentsLength = SubTable->ArgumentsLength; 4037 4038 /* Dump the arguments buffer */ 4039 4040 (void) AcpiDmDumpTable (Table->Length, 0, Table, ArgumentsLength, 4041 AcpiDmTableInfoWpbt0); 4042 } 4043
Indexes created Wed Oct 22 13:09:56 GMT 2025