dmtbdump.c revision 245582
1/****************************************************************************** 2 * 3 * Module Name: dmtbdump - Dump ACPI data tables that contain no AML code 4 * 5 *****************************************************************************/ 6 7/* 8 * Copyright (C) 2000 - 2013, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44#include <contrib/dev/acpica/include/acpi.h> 45#include <contrib/dev/acpica/include/accommon.h> 46#include <contrib/dev/acpica/include/acdisasm.h> 47#include <contrib/dev/acpica/include/actables.h> 48 49/* This module used for application-level code only */ 50 51#define _COMPONENT ACPI_CA_DISASSEMBLER 52 ACPI_MODULE_NAME ("dmtbdump") 53 54 55/* Local prototypes */ 56 57static void 58AcpiDmValidateFadtLength ( 59 UINT32 Revision, 60 UINT32 Length); 61 62static void 63AcpiDmDumpBuffer ( 64 void *Table, 65 UINT32 BufferOffset, 66 UINT32 Length, 67 UINT32 AbsoluteOffset, 68 char *Header); 69 70 71/******************************************************************************* 72 * 73 * FUNCTION: AcpiDmDumpBuffer 74 * 75 * PARAMETERS: Table - ACPI Table or subtable 76 * BufferOffset - Offset of buffer from Table above 77 * Length - Length of the buffer 78 * AbsoluteOffset - Offset of buffer in the main ACPI table 79 * Header - Name of the buffer field (printed on the 80 * first line only.) 81 * 82 * RETURN: None 83 * 84 * DESCRIPTION: Format the contents of an arbitrary length data buffer (in the 85 * disassembler output format.) 86 * 87 ******************************************************************************/ 88 89static void 90AcpiDmDumpBuffer ( 91 void *Table, 92 UINT32 BufferOffset, 93 UINT32 Length, 94 UINT32 AbsoluteOffset, 95 char *Header) 96{ 97 UINT8 *Buffer; 98 UINT32 i; 99 100 101 if (!Length) 102 { 103 return; 104 } 105 106 Buffer = ACPI_CAST_PTR (UINT8, Table) + BufferOffset; 107 i = 0; 108 109 while (i < Length) 110 { 111 if (!(i % 16)) 112 { 113 AcpiOsPrintf ("\n"); 114 AcpiDmLineHeader (AbsoluteOffset, 115 ((Length - i) > 16) ? 16 : (Length - i), Header); 116 Header = NULL; 117 } 118 119 AcpiOsPrintf ("%.02X ", *Buffer); 120 i++; 121 Buffer++; 122 AbsoluteOffset++; 123 } 124 125 AcpiOsPrintf ("\n"); 126} 127 128 129/******************************************************************************* 130 * 131 * FUNCTION: AcpiDmDumpRsdp 132 * 133 * PARAMETERS: Table - A RSDP 134 * 135 * RETURN: Length of the table (there is not always a length field, 136 * use revision or length if available (ACPI 2.0+)) 137 * 138 * DESCRIPTION: Format the contents of a RSDP 139 * 140 ******************************************************************************/ 141 142UINT32 143AcpiDmDumpRsdp ( 144 ACPI_TABLE_HEADER *Table) 145{ 146 ACPI_TABLE_RSDP *Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table); 147 UINT32 Length = sizeof (ACPI_RSDP_COMMON); 148 UINT8 Checksum; 149 150 151 /* Dump the common ACPI 1.0 portion */ 152 153 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp1); 154 155 /* Validate the first checksum */ 156 157 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_RSDP_COMMON), 158 Rsdp->Checksum); 159 if (Checksum != Rsdp->Checksum) 160 { 161 AcpiOsPrintf ("/* Incorrect Checksum above, should be 0x%2.2X */\n", 162 Checksum); 163 } 164 165 /* The RSDP for ACPI 2.0+ contains more data and has a Length field */ 166 167 if (Rsdp->Revision > 0) 168 { 169 Length = Rsdp->Length; 170 AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoRsdp2); 171 172 /* Validate the extended checksum over entire RSDP */ 173 174 Checksum = AcpiDmGenerateChecksum (Rsdp, sizeof (ACPI_TABLE_RSDP), 175 Rsdp->ExtendedChecksum); 176 if (Checksum != Rsdp->ExtendedChecksum) 177 { 178 AcpiOsPrintf ( 179 "/* Incorrect Extended Checksum above, should be 0x%2.2X */\n", 180 Checksum); 181 } 182 } 183 184 return (Length); 185} 186 187 188/******************************************************************************* 189 * 190 * FUNCTION: AcpiDmDumpRsdt 191 * 192 * PARAMETERS: Table - A RSDT 193 * 194 * RETURN: None 195 * 196 * DESCRIPTION: Format the contents of a RSDT 197 * 198 ******************************************************************************/ 199 200void 201AcpiDmDumpRsdt ( 202 ACPI_TABLE_HEADER *Table) 203{ 204 UINT32 *Array; 205 UINT32 Entries; 206 UINT32 Offset; 207 UINT32 i; 208 209 210 /* Point to start of table pointer array */ 211 212 Array = ACPI_CAST_PTR (ACPI_TABLE_RSDT, Table)->TableOffsetEntry; 213 Offset = sizeof (ACPI_TABLE_HEADER); 214 215 /* RSDT uses 32-bit pointers */ 216 217 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT32); 218 219 for (i = 0; i < Entries; i++) 220 { 221 AcpiDmLineHeader2 (Offset, sizeof (UINT32), "ACPI Table Address", i); 222 AcpiOsPrintf ("%8.8X\n", Array[i]); 223 Offset += sizeof (UINT32); 224 } 225} 226 227 228/******************************************************************************* 229 * 230 * FUNCTION: AcpiDmDumpXsdt 231 * 232 * PARAMETERS: Table - A XSDT 233 * 234 * RETURN: None 235 * 236 * DESCRIPTION: Format the contents of a XSDT 237 * 238 ******************************************************************************/ 239 240void 241AcpiDmDumpXsdt ( 242 ACPI_TABLE_HEADER *Table) 243{ 244 UINT64 *Array; 245 UINT32 Entries; 246 UINT32 Offset; 247 UINT32 i; 248 249 250 /* Point to start of table pointer array */ 251 252 Array = ACPI_CAST_PTR (ACPI_TABLE_XSDT, Table)->TableOffsetEntry; 253 Offset = sizeof (ACPI_TABLE_HEADER); 254 255 /* XSDT uses 64-bit pointers */ 256 257 Entries = (Table->Length - sizeof (ACPI_TABLE_HEADER)) / sizeof (UINT64); 258 259 for (i = 0; i < Entries; i++) 260 { 261 AcpiDmLineHeader2 (Offset, sizeof (UINT64), "ACPI Table Address", i); 262 AcpiOsPrintf ("%8.8X%8.8X\n", ACPI_FORMAT_UINT64 (Array[i])); 263 Offset += sizeof (UINT64); 264 } 265} 266 267 268/******************************************************************************* 269 * 270 * FUNCTION: AcpiDmDumpFadt 271 * 272 * PARAMETERS: Table - A FADT 273 * 274 * RETURN: None 275 * 276 * DESCRIPTION: Format the contents of a FADT 277 * 278 * NOTE: We cannot depend on the FADT version to indicate the actual 279 * contents of the FADT because of BIOS bugs. The table length 280 * is the only reliable indicator. 281 * 282 ******************************************************************************/ 283 284void 285AcpiDmDumpFadt ( 286 ACPI_TABLE_HEADER *Table) 287{ 288 289 /* Always dump the minimum FADT revision 1 fields (ACPI 1.0) */ 290 291 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt1); 292 293 /* Check for FADT revision 2 fields (ACPI 1.0B MS extensions) */ 294 295 if ((Table->Length > ACPI_FADT_V1_SIZE) && 296 (Table->Length <= ACPI_FADT_V2_SIZE)) 297 { 298 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt2); 299 } 300 301 /* Check for FADT revision 3/4 fields and up (ACPI 2.0+ extended data) */ 302 303 else if (Table->Length > ACPI_FADT_V2_SIZE) 304 { 305 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt3); 306 307 /* Check for FADT revision 5 fields and up (ACPI 5.0+) */ 308 309 if (Table->Length > ACPI_FADT_V3_SIZE) 310 { 311 AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoFadt5); 312 } 313 } 314 315 /* Validate various fields in the FADT, including length */ 316 317 AcpiTbCreateLocalFadt (Table, Table->Length); 318 319 /* Validate FADT length against the revision */ 320 321 AcpiDmValidateFadtLength (Table->Revision, Table->Length); 322} 323 324 325/******************************************************************************* 326 * 327 * FUNCTION: AcpiDmValidateFadtLength 328 * 329 * PARAMETERS: Revision - FADT revision (Header->Revision) 330 * Length - FADT length (Header->Length 331 * 332 * RETURN: None 333 * 334 * DESCRIPTION: Check the FADT revision against the expected table length for 335 * that revision. Issue a warning if the length is not what was 336 * expected. This seems to be such a common BIOS bug that the 337 * FADT revision has been rendered virtually meaningless. 338 * 339 ******************************************************************************/ 340 341static void 342AcpiDmValidateFadtLength ( 343 UINT32 Revision, 344 UINT32 Length) 345{ 346 UINT32 ExpectedLength; 347 348 349 switch (Revision) 350 { 351 case 0: 352 AcpiOsPrintf ("// ACPI Warning: Invalid FADT revision: 0\n"); 353 return; 354 355 case 1: 356 ExpectedLength = ACPI_FADT_V1_SIZE; 357 break; 358 359 case 2: 360 ExpectedLength = ACPI_FADT_V2_SIZE; 361 break; 362 363 case 3: 364 case 4: 365 ExpectedLength = ACPI_FADT_V3_SIZE; 366 break; 367 368 case 5: 369 ExpectedLength = ACPI_FADT_V5_SIZE; 370 break; 371 372 default: 373 return; 374 } 375 376 if (Length == ExpectedLength) 377 { 378 return; 379 } 380 381 AcpiOsPrintf ( 382 "\n// ACPI Warning: FADT revision %X does not match length: found %X expected %X\n", 383 Revision, Length, ExpectedLength); 384} 385 386 387/******************************************************************************* 388 * 389 * FUNCTION: AcpiDmDumpAsf 390 * 391 * PARAMETERS: Table - A ASF table 392 * 393 * RETURN: None 394 * 395 * DESCRIPTION: Format the contents of a ASF table 396 * 397 ******************************************************************************/ 398 399void 400AcpiDmDumpAsf ( 401 ACPI_TABLE_HEADER *Table) 402{ 403 ACPI_STATUS Status; 404 UINT32 Offset = sizeof (ACPI_TABLE_HEADER); 405 ACPI_ASF_INFO *SubTable; 406 ACPI_DMTABLE_INFO *InfoTable; 407 ACPI_DMTABLE_INFO *DataInfoTable = NULL; 408 UINT8 *DataTable = NULL; 409 UINT32 DataCount = 0; 410 UINT32 DataLength = 0; 411 UINT32 DataOffset = 0; 412 UINT32 i; 413 UINT8 Type; 414 415 416 /* No main table, only sub-tables */ 417 418 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); 419 while (Offset < Table->Length) 420 { 421 /* Common sub-table header */ 422 423 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 424 SubTable->Header.Length, AcpiDmTableInfoAsfHdr); 425 if (ACPI_FAILURE (Status)) 426 { 427 return; 428 } 429 430 /* The actual type is the lower 7 bits of Type */ 431 432 Type = (UINT8) (SubTable->Header.Type & 0x7F); 433 434 switch (Type) 435 { 436 case ACPI_ASF_TYPE_INFO: 437 InfoTable = AcpiDmTableInfoAsf0; 438 break; 439 440 case ACPI_ASF_TYPE_ALERT: 441 InfoTable = AcpiDmTableInfoAsf1; 442 DataInfoTable = AcpiDmTableInfoAsf1a; 443 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ALERT)); 444 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->Alerts; 445 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, SubTable)->DataLength; 446 DataOffset = Offset + sizeof (ACPI_ASF_ALERT); 447 break; 448 449 case ACPI_ASF_TYPE_CONTROL: 450 InfoTable = AcpiDmTableInfoAsf2; 451 DataInfoTable = AcpiDmTableInfoAsf2a; 452 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_REMOTE)); 453 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->Controls; 454 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, SubTable)->DataLength; 455 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE); 456 break; 457 458 case ACPI_ASF_TYPE_BOOT: 459 InfoTable = AcpiDmTableInfoAsf3; 460 break; 461 462 case ACPI_ASF_TYPE_ADDRESS: 463 InfoTable = AcpiDmTableInfoAsf4; 464 DataTable = ACPI_ADD_PTR (UINT8, SubTable, sizeof (ACPI_ASF_ADDRESS)); 465 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, SubTable)->Devices; 466 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS); 467 break; 468 469 default: 470 AcpiOsPrintf ("\n**** Unknown ASF sub-table type 0x%X\n", SubTable->Header.Type); 471 return; 472 } 473 474 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 475 SubTable->Header.Length, InfoTable); 476 if (ACPI_FAILURE (Status)) 477 { 478 return; 479 } 480 481 /* Dump variable-length extra data */ 482 483 switch (Type) 484 { 485 case ACPI_ASF_TYPE_ALERT: 486 case ACPI_ASF_TYPE_CONTROL: 487 488 for (i = 0; i < DataCount; i++) 489 { 490 AcpiOsPrintf ("\n"); 491 Status = AcpiDmDumpTable (Table->Length, DataOffset, 492 DataTable, DataLength, DataInfoTable); 493 if (ACPI_FAILURE (Status)) 494 { 495 return; 496 } 497 498 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength); 499 DataOffset += DataLength; 500 } 501 break; 502 503 case ACPI_ASF_TYPE_ADDRESS: 504 505 for (i = 0; i < DataLength; i++) 506 { 507 if (!(i % 16)) 508 { 509 AcpiDmLineHeader (DataOffset, 1, "Addresses"); 510 } 511 512 AcpiOsPrintf ("%2.2X ", *DataTable); 513 DataTable++; 514 DataOffset++; 515 if (DataOffset > Table->Length) 516 { 517 AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n"); 518 return; 519 } 520 } 521 522 AcpiOsPrintf ("\n"); 523 break; 524 525 default: 526 break; 527 } 528 529 AcpiOsPrintf ("\n"); 530 531 /* Point to next sub-table */ 532 533 if (!SubTable->Header.Length) 534 { 535 AcpiOsPrintf ("Invalid zero subtable header length\n"); 536 return; 537 } 538 539 Offset += SubTable->Header.Length; 540 SubTable = ACPI_ADD_PTR (ACPI_ASF_INFO, SubTable, SubTable->Header.Length); 541 } 542} 543 544 545/******************************************************************************* 546 * 547 * FUNCTION: AcpiDmDumpCpep 548 * 549 * PARAMETERS: Table - A CPEP table 550 * 551 * RETURN: None 552 * 553 * DESCRIPTION: Format the contents of a CPEP. This table type consists 554 * of an open-ended number of subtables. 555 * 556 ******************************************************************************/ 557 558void 559AcpiDmDumpCpep ( 560 ACPI_TABLE_HEADER *Table) 561{ 562 ACPI_STATUS Status; 563 ACPI_CPEP_POLLING *SubTable; 564 UINT32 Length = Table->Length; 565 UINT32 Offset = sizeof (ACPI_TABLE_CPEP); 566 567 568 /* Main table */ 569 570 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep); 571 if (ACPI_FAILURE (Status)) 572 { 573 return; 574 } 575 576 /* Sub-tables */ 577 578 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset); 579 while (Offset < Table->Length) 580 { 581 AcpiOsPrintf ("\n"); 582 Status = AcpiDmDumpTable (Length, Offset, SubTable, 583 SubTable->Header.Length, AcpiDmTableInfoCpep0); 584 if (ACPI_FAILURE (Status)) 585 { 586 return; 587 } 588 589 /* Point to next sub-table */ 590 591 Offset += SubTable->Header.Length; 592 SubTable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, SubTable, 593 SubTable->Header.Length); 594 } 595} 596 597 598/******************************************************************************* 599 * 600 * FUNCTION: AcpiDmDumpCsrt 601 * 602 * PARAMETERS: Table - A CSRT table 603 * 604 * RETURN: None 605 * 606 * DESCRIPTION: Format the contents of a CSRT. This table type consists 607 * of an open-ended number of subtables. 608 * 609 ******************************************************************************/ 610 611void 612AcpiDmDumpCsrt ( 613 ACPI_TABLE_HEADER *Table) 614{ 615 ACPI_STATUS Status; 616 ACPI_CSRT_GROUP *SubTable; 617 ACPI_CSRT_SHARED_INFO *SharedInfoTable; 618 ACPI_CSRT_DESCRIPTOR *SubSubTable; 619 UINT32 Length = Table->Length; 620 UINT32 Offset = sizeof (ACPI_TABLE_CSRT); 621 UINT32 SubOffset; 622 UINT32 SubSubOffset; 623 UINT32 InfoLength; 624 625 626 /* The main table only contains the ACPI header, thus already handled */ 627 628 /* Sub-tables (Resource Groups) */ 629 630 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset); 631 while (Offset < Table->Length) 632 { 633 /* Resource group subtable */ 634 635 AcpiOsPrintf ("\n"); 636 Status = AcpiDmDumpTable (Length, Offset, SubTable, 637 SubTable->Length, AcpiDmTableInfoCsrt0); 638 if (ACPI_FAILURE (Status)) 639 { 640 return; 641 } 642 643 /* Shared info subtable (One per resource group) */ 644 645 SubOffset = sizeof (ACPI_CSRT_GROUP); 646 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table, 647 Offset + SubOffset); 648 649 AcpiOsPrintf ("\n"); 650 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable, 651 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1); 652 if (ACPI_FAILURE (Status)) 653 { 654 return; 655 } 656 657 SubOffset += SubTable->SharedInfoLength; 658 659 /* Sub-Subtables (Resource Descriptors) */ 660 661 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table, 662 Offset + SubOffset); 663 664 while ((SubOffset < SubTable->Length) && 665 ((Offset + SubOffset) < Table->Length)) 666 { 667 AcpiOsPrintf ("\n"); 668 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubTable, 669 SubSubTable->Length, AcpiDmTableInfoCsrt2); 670 if (ACPI_FAILURE (Status)) 671 { 672 return; 673 } 674 675 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR); 676 677 /* Resource-specific info buffer */ 678 679 InfoLength = SubSubTable->Length - SubSubOffset; 680 681 AcpiDmDumpBuffer (SubSubTable, SubSubOffset, InfoLength, 682 Offset + SubOffset + SubSubOffset, "ResourceInfo"); 683 SubSubOffset += InfoLength; 684 685 /* Point to next sub-subtable */ 686 687 SubOffset += SubSubTable->Length; 688 SubSubTable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubTable, 689 SubSubTable->Length); 690 } 691 692 /* Point to next sub-table */ 693 694 Offset += SubTable->Length; 695 SubTable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, SubTable, 696 SubTable->Length); 697 } 698} 699 700 701/******************************************************************************* 702 * 703 * FUNCTION: AcpiDmDumpDbg2 704 * 705 * PARAMETERS: Table - A DBG2 table 706 * 707 * RETURN: None 708 * 709 * DESCRIPTION: Format the contents of a DBG2. This table type consists 710 * of an open-ended number of subtables. 711 * 712 ******************************************************************************/ 713 714void 715AcpiDmDumpDbg2 ( 716 ACPI_TABLE_HEADER *Table) 717{ 718 ACPI_STATUS Status; 719 ACPI_DBG2_DEVICE *SubTable; 720 UINT32 Length = Table->Length; 721 UINT32 Offset = sizeof (ACPI_TABLE_DBG2); 722 UINT32 i; 723 UINT32 ArrayOffset; 724 UINT32 AbsoluteOffset; 725 UINT8 *Array; 726 727 728 /* Main table */ 729 730 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2); 731 if (ACPI_FAILURE (Status)) 732 { 733 return; 734 } 735 736 /* Sub-tables */ 737 738 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset); 739 while (Offset < Table->Length) 740 { 741 AcpiOsPrintf ("\n"); 742 Status = AcpiDmDumpTable (Length, Offset, SubTable, 743 SubTable->Length, AcpiDmTableInfoDbg2Device); 744 if (ACPI_FAILURE (Status)) 745 { 746 return; 747 } 748 749 /* Dump the BaseAddress array */ 750 751 for (i = 0; i < SubTable->RegisterCount; i++) 752 { 753 ArrayOffset = SubTable->BaseAddressOffset + 754 (sizeof (ACPI_GENERIC_ADDRESS) * i); 755 AbsoluteOffset = Offset + ArrayOffset; 756 Array = (UINT8 *) SubTable + ArrayOffset; 757 758 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 759 SubTable->Length, AcpiDmTableInfoDbg2Addr); 760 if (ACPI_FAILURE (Status)) 761 { 762 return; 763 } 764 } 765 766 /* Dump the AddressSize array */ 767 768 for (i = 0; i < SubTable->RegisterCount; i++) 769 { 770 ArrayOffset = SubTable->AddressSizeOffset + 771 (sizeof (UINT32) * i); 772 AbsoluteOffset = Offset + ArrayOffset; 773 Array = (UINT8 *) SubTable + ArrayOffset; 774 775 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 776 SubTable->Length, AcpiDmTableInfoDbg2Size); 777 if (ACPI_FAILURE (Status)) 778 { 779 return; 780 } 781 } 782 783 /* Dump the Namestring (required) */ 784 785 AcpiOsPrintf ("\n"); 786 ArrayOffset = SubTable->NamepathOffset; 787 AbsoluteOffset = Offset + ArrayOffset; 788 Array = (UINT8 *) SubTable + ArrayOffset; 789 790 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 791 SubTable->Length, AcpiDmTableInfoDbg2Name); 792 if (ACPI_FAILURE (Status)) 793 { 794 return; 795 } 796 797 /* Dump the OemData (optional) */ 798 799 AcpiDmDumpBuffer (SubTable, SubTable->OemDataOffset, SubTable->OemDataLength, 800 Offset + SubTable->OemDataOffset, "OEM Data"); 801 802 /* Point to next sub-table */ 803 804 Offset += SubTable->Length; 805 SubTable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, SubTable, 806 SubTable->Length); 807 } 808} 809 810 811/******************************************************************************* 812 * 813 * FUNCTION: AcpiDmDumpDmar 814 * 815 * PARAMETERS: Table - A DMAR table 816 * 817 * RETURN: None 818 * 819 * DESCRIPTION: Format the contents of a DMAR. This table type consists 820 * of an open-ended number of subtables. 821 * 822 ******************************************************************************/ 823 824 825void 826AcpiDmDumpDmar ( 827 ACPI_TABLE_HEADER *Table) 828{ 829 ACPI_STATUS Status; 830 ACPI_DMAR_HEADER *SubTable; 831 UINT32 Length = Table->Length; 832 UINT32 Offset = sizeof (ACPI_TABLE_DMAR); 833 ACPI_DMTABLE_INFO *InfoTable; 834 ACPI_DMAR_DEVICE_SCOPE *ScopeTable; 835 UINT32 ScopeOffset; 836 UINT8 *PciPath; 837 UINT32 PathOffset; 838 839 840 /* Main table */ 841 842 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); 843 if (ACPI_FAILURE (Status)) 844 { 845 return; 846 } 847 848 /* Sub-tables */ 849 850 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); 851 while (Offset < Table->Length) 852 { 853 /* Common sub-table header */ 854 855 AcpiOsPrintf ("\n"); 856 Status = AcpiDmDumpTable (Length, Offset, SubTable, 857 SubTable->Length, AcpiDmTableInfoDmarHdr); 858 if (ACPI_FAILURE (Status)) 859 { 860 return; 861 } 862 863 switch (SubTable->Type) 864 { 865 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 866 InfoTable = AcpiDmTableInfoDmar0; 867 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT); 868 break; 869 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 870 InfoTable = AcpiDmTableInfoDmar1; 871 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY); 872 break; 873 case ACPI_DMAR_TYPE_ATSR: 874 InfoTable = AcpiDmTableInfoDmar2; 875 ScopeOffset = sizeof (ACPI_DMAR_ATSR); 876 break; 877 case ACPI_DMAR_HARDWARE_AFFINITY: 878 InfoTable = AcpiDmTableInfoDmar3; 879 ScopeOffset = sizeof (ACPI_DMAR_RHSA); 880 break; 881 default: 882 AcpiOsPrintf ("\n**** Unknown DMAR sub-table type 0x%X\n\n", SubTable->Type); 883 return; 884 } 885 886 Status = AcpiDmDumpTable (Length, Offset, SubTable, 887 SubTable->Length, InfoTable); 888 if (ACPI_FAILURE (Status)) 889 { 890 return; 891 } 892 893 /* Dump the device scope entries (if any) */ 894 895 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, SubTable, ScopeOffset); 896 while (ScopeOffset < SubTable->Length) 897 { 898 AcpiOsPrintf ("\n"); 899 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, 900 ScopeTable->Length, AcpiDmTableInfoDmarScope); 901 if (ACPI_FAILURE (Status)) 902 { 903 return; 904 } 905 906 /* Dump the PCI Path entries for this device scope */ 907 908 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */ 909 910 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable, 911 sizeof (ACPI_DMAR_DEVICE_SCOPE)); 912 913 while (PathOffset < ScopeTable->Length) 914 { 915 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, "PCI Path"); 916 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]); 917 918 /* Point to next PCI Path entry */ 919 920 PathOffset += 2; 921 PciPath += 2; 922 } 923 924 /* Point to next device scope entry */ 925 926 ScopeOffset += ScopeTable->Length; 927 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, 928 ScopeTable, ScopeTable->Length); 929 } 930 931 /* Point to next sub-table */ 932 933 Offset += SubTable->Length; 934 SubTable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, SubTable, SubTable->Length); 935 } 936} 937 938 939/******************************************************************************* 940 * 941 * FUNCTION: AcpiDmDumpEinj 942 * 943 * PARAMETERS: Table - A EINJ table 944 * 945 * RETURN: None 946 * 947 * DESCRIPTION: Format the contents of a EINJ. This table type consists 948 * of an open-ended number of subtables. 949 * 950 ******************************************************************************/ 951 952void 953AcpiDmDumpEinj ( 954 ACPI_TABLE_HEADER *Table) 955{ 956 ACPI_STATUS Status; 957 ACPI_WHEA_HEADER *SubTable; 958 UINT32 Length = Table->Length; 959 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 960 961 962 /* Main table */ 963 964 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 965 if (ACPI_FAILURE (Status)) 966 { 967 return; 968 } 969 970 /* Sub-tables */ 971 972 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 973 while (Offset < Table->Length) 974 { 975 AcpiOsPrintf ("\n"); 976 Status = AcpiDmDumpTable (Length, Offset, SubTable, 977 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 978 if (ACPI_FAILURE (Status)) 979 { 980 return; 981 } 982 983 /* Point to next sub-table (each subtable is of fixed length) */ 984 985 Offset += sizeof (ACPI_WHEA_HEADER); 986 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 987 sizeof (ACPI_WHEA_HEADER)); 988 } 989} 990 991 992/******************************************************************************* 993 * 994 * FUNCTION: AcpiDmDumpErst 995 * 996 * PARAMETERS: Table - A ERST table 997 * 998 * RETURN: None 999 * 1000 * DESCRIPTION: Format the contents of a ERST. This table type consists 1001 * of an open-ended number of subtables. 1002 * 1003 ******************************************************************************/ 1004 1005void 1006AcpiDmDumpErst ( 1007 ACPI_TABLE_HEADER *Table) 1008{ 1009 ACPI_STATUS Status; 1010 ACPI_WHEA_HEADER *SubTable; 1011 UINT32 Length = Table->Length; 1012 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 1013 1014 1015 /* Main table */ 1016 1017 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 1018 if (ACPI_FAILURE (Status)) 1019 { 1020 return; 1021 } 1022 1023 /* Sub-tables */ 1024 1025 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1026 while (Offset < Table->Length) 1027 { 1028 AcpiOsPrintf ("\n"); 1029 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1030 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0); 1031 if (ACPI_FAILURE (Status)) 1032 { 1033 return; 1034 } 1035 1036 /* Point to next sub-table (each subtable is of fixed length) */ 1037 1038 Offset += sizeof (ACPI_WHEA_HEADER); 1039 SubTable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, SubTable, 1040 sizeof (ACPI_WHEA_HEADER)); 1041 } 1042} 1043 1044 1045/******************************************************************************* 1046 * 1047 * FUNCTION: AcpiDmDumpFpdt 1048 * 1049 * PARAMETERS: Table - A FPDT table 1050 * 1051 * RETURN: None 1052 * 1053 * DESCRIPTION: Format the contents of a FPDT. This table type consists 1054 * of an open-ended number of subtables. 1055 * 1056 ******************************************************************************/ 1057 1058void 1059AcpiDmDumpFpdt ( 1060 ACPI_TABLE_HEADER *Table) 1061{ 1062 ACPI_STATUS Status; 1063 ACPI_FPDT_HEADER *SubTable; 1064 UINT32 Length = Table->Length; 1065 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 1066 ACPI_DMTABLE_INFO *InfoTable; 1067 1068 1069 /* There is no main table (other than the standard ACPI header) */ 1070 1071 /* Sub-tables */ 1072 1073 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); 1074 while (Offset < Table->Length) 1075 { 1076 /* Common sub-table header */ 1077 1078 AcpiOsPrintf ("\n"); 1079 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1080 SubTable->Length, AcpiDmTableInfoFpdtHdr); 1081 if (ACPI_FAILURE (Status)) 1082 { 1083 return; 1084 } 1085 1086 switch (SubTable->Type) 1087 { 1088 case ACPI_FPDT_TYPE_BOOT: 1089 InfoTable = AcpiDmTableInfoFpdt0; 1090 break; 1091 case ACPI_FPDT_TYPE_S3PERF: 1092 InfoTable = AcpiDmTableInfoFpdt1; 1093 break; 1094 default: 1095 AcpiOsPrintf ("\n**** Unknown FPDT sub-table type 0x%X\n\n", SubTable->Type); 1096 1097 /* Attempt to continue */ 1098 1099 if (!SubTable->Length) 1100 { 1101 AcpiOsPrintf ("Invalid zero length subtable\n"); 1102 return; 1103 } 1104 goto NextSubTable; 1105 } 1106 1107 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1108 SubTable->Length, InfoTable); 1109 if (ACPI_FAILURE (Status)) 1110 { 1111 return; 1112 } 1113 1114NextSubTable: 1115 /* Point to next sub-table */ 1116 1117 Offset += SubTable->Length; 1118 SubTable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, SubTable, SubTable->Length); 1119 } 1120} 1121 1122 1123/******************************************************************************* 1124 * 1125 * FUNCTION: AcpiDmDumpHest 1126 * 1127 * PARAMETERS: Table - A HEST table 1128 * 1129 * RETURN: None 1130 * 1131 * DESCRIPTION: Format the contents of a HEST. This table type consists 1132 * of an open-ended number of subtables. 1133 * 1134 ******************************************************************************/ 1135 1136void 1137AcpiDmDumpHest ( 1138 ACPI_TABLE_HEADER *Table) 1139{ 1140 ACPI_STATUS Status; 1141 ACPI_HEST_HEADER *SubTable; 1142 UINT32 Length = Table->Length; 1143 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 1144 ACPI_DMTABLE_INFO *InfoTable; 1145 UINT32 SubTableLength; 1146 UINT32 BankCount; 1147 ACPI_HEST_IA_ERROR_BANK *BankTable; 1148 1149 1150 /* Main table */ 1151 1152 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 1153 if (ACPI_FAILURE (Status)) 1154 { 1155 return; 1156 } 1157 1158 /* Sub-tables */ 1159 1160 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 1161 while (Offset < Table->Length) 1162 { 1163 BankCount = 0; 1164 switch (SubTable->Type) 1165 { 1166 case ACPI_HEST_TYPE_IA32_CHECK: 1167 InfoTable = AcpiDmTableInfoHest0; 1168 SubTableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK); 1169 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 1170 SubTable))->NumHardwareBanks; 1171 break; 1172 1173 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 1174 InfoTable = AcpiDmTableInfoHest1; 1175 SubTableLength = sizeof (ACPI_HEST_IA_CORRECTED); 1176 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 1177 SubTable))->NumHardwareBanks; 1178 break; 1179 1180 case ACPI_HEST_TYPE_IA32_NMI: 1181 InfoTable = AcpiDmTableInfoHest2; 1182 SubTableLength = sizeof (ACPI_HEST_IA_NMI); 1183 break; 1184 1185 case ACPI_HEST_TYPE_AER_ROOT_PORT: 1186 InfoTable = AcpiDmTableInfoHest6; 1187 SubTableLength = sizeof (ACPI_HEST_AER_ROOT); 1188 break; 1189 1190 case ACPI_HEST_TYPE_AER_ENDPOINT: 1191 InfoTable = AcpiDmTableInfoHest7; 1192 SubTableLength = sizeof (ACPI_HEST_AER); 1193 break; 1194 1195 case ACPI_HEST_TYPE_AER_BRIDGE: 1196 InfoTable = AcpiDmTableInfoHest8; 1197 SubTableLength = sizeof (ACPI_HEST_AER_BRIDGE); 1198 break; 1199 1200 case ACPI_HEST_TYPE_GENERIC_ERROR: 1201 InfoTable = AcpiDmTableInfoHest9; 1202 SubTableLength = sizeof (ACPI_HEST_GENERIC); 1203 break; 1204 1205 default: 1206 /* Cannot continue on unknown type - no length */ 1207 1208 AcpiOsPrintf ("\n**** Unknown HEST sub-table type 0x%X\n", SubTable->Type); 1209 return; 1210 } 1211 1212 AcpiOsPrintf ("\n"); 1213 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1214 SubTableLength, InfoTable); 1215 if (ACPI_FAILURE (Status)) 1216 { 1217 return; 1218 } 1219 1220 /* Point to end of current subtable (each subtable above is of fixed length) */ 1221 1222 Offset += SubTableLength; 1223 1224 /* If there are any (fixed-length) Error Banks from above, dump them now */ 1225 1226 if (BankCount) 1227 { 1228 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, SubTable, SubTableLength); 1229 SubTableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 1230 1231 while (BankCount) 1232 { 1233 AcpiOsPrintf ("\n"); 1234 Status = AcpiDmDumpTable (Length, Offset, BankTable, 1235 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 1236 if (ACPI_FAILURE (Status)) 1237 { 1238 return; 1239 } 1240 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 1241 BankTable++; 1242 BankCount--; 1243 } 1244 } 1245 1246 /* Point to next sub-table */ 1247 1248 SubTable = ACPI_ADD_PTR (ACPI_HEST_HEADER, SubTable, SubTableLength); 1249 } 1250} 1251 1252 1253/******************************************************************************* 1254 * 1255 * FUNCTION: AcpiDmDumpIvrs 1256 * 1257 * PARAMETERS: Table - A IVRS table 1258 * 1259 * RETURN: None 1260 * 1261 * DESCRIPTION: Format the contents of a IVRS 1262 * 1263 ******************************************************************************/ 1264 1265static UINT8 EntrySizes[] = {4,8,16,32}; 1266 1267void 1268AcpiDmDumpIvrs ( 1269 ACPI_TABLE_HEADER *Table) 1270{ 1271 ACPI_STATUS Status; 1272 UINT32 Offset = sizeof (ACPI_TABLE_IVRS); 1273 UINT32 EntryOffset; 1274 UINT32 EntryLength; 1275 UINT32 EntryType; 1276 ACPI_IVRS_DE_HEADER *DeviceEntry; 1277 ACPI_IVRS_HEADER *SubTable; 1278 ACPI_DMTABLE_INFO *InfoTable; 1279 1280 1281 /* Main table */ 1282 1283 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoIvrs); 1284 if (ACPI_FAILURE (Status)) 1285 { 1286 return; 1287 } 1288 1289 /* Sub-tables */ 1290 1291 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, Table, Offset); 1292 while (Offset < Table->Length) 1293 { 1294 /* Common sub-table header */ 1295 1296 AcpiOsPrintf ("\n"); 1297 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1298 SubTable->Length, AcpiDmTableInfoIvrsHdr); 1299 if (ACPI_FAILURE (Status)) 1300 { 1301 return; 1302 } 1303 1304 switch (SubTable->Type) 1305 { 1306 case ACPI_IVRS_TYPE_HARDWARE: 1307 InfoTable = AcpiDmTableInfoIvrs0; 1308 break; 1309 case ACPI_IVRS_TYPE_MEMORY1: 1310 case ACPI_IVRS_TYPE_MEMORY2: 1311 case ACPI_IVRS_TYPE_MEMORY3: 1312 InfoTable = AcpiDmTableInfoIvrs1; 1313 break; 1314 default: 1315 AcpiOsPrintf ("\n**** Unknown IVRS sub-table type 0x%X\n", 1316 SubTable->Type); 1317 1318 /* Attempt to continue */ 1319 1320 if (!SubTable->Length) 1321 { 1322 AcpiOsPrintf ("Invalid zero length subtable\n"); 1323 return; 1324 } 1325 goto NextSubTable; 1326 } 1327 1328 /* Dump the subtable */ 1329 1330 AcpiOsPrintf ("\n"); 1331 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1332 SubTable->Length, InfoTable); 1333 if (ACPI_FAILURE (Status)) 1334 { 1335 return; 1336 } 1337 1338 /* The hardware subtable can contain multiple device entries */ 1339 1340 if (SubTable->Type == ACPI_IVRS_TYPE_HARDWARE) 1341 { 1342 EntryOffset = Offset + sizeof (ACPI_IVRS_HARDWARE); 1343 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, SubTable, 1344 sizeof (ACPI_IVRS_HARDWARE)); 1345 1346 while (EntryOffset < (Offset + SubTable->Length)) 1347 { 1348 AcpiOsPrintf ("\n"); 1349 /* 1350 * Upper 2 bits of Type encode the length of the device entry 1351 * 1352 * 00 = 4 byte 1353 * 01 = 8 byte 1354 * 10 = 16 byte - currently no entries defined 1355 * 11 = 32 byte - currently no entries defined 1356 */ 1357 EntryType = DeviceEntry->Type; 1358 EntryLength = EntrySizes [EntryType >> 6]; 1359 1360 switch (EntryType) 1361 { 1362 /* 4-byte device entries */ 1363 1364 case ACPI_IVRS_TYPE_PAD4: 1365 case ACPI_IVRS_TYPE_ALL: 1366 case ACPI_IVRS_TYPE_SELECT: 1367 case ACPI_IVRS_TYPE_START: 1368 case ACPI_IVRS_TYPE_END: 1369 1370 InfoTable = AcpiDmTableInfoIvrs4; 1371 break; 1372 1373 /* 8-byte entries, type A */ 1374 1375 case ACPI_IVRS_TYPE_ALIAS_SELECT: 1376 case ACPI_IVRS_TYPE_ALIAS_START: 1377 1378 InfoTable = AcpiDmTableInfoIvrs8a; 1379 break; 1380 1381 /* 8-byte entries, type B */ 1382 1383 case ACPI_IVRS_TYPE_PAD8: 1384 case ACPI_IVRS_TYPE_EXT_SELECT: 1385 case ACPI_IVRS_TYPE_EXT_START: 1386 1387 InfoTable = AcpiDmTableInfoIvrs8b; 1388 break; 1389 1390 /* 8-byte entries, type C */ 1391 1392 case ACPI_IVRS_TYPE_SPECIAL: 1393 1394 InfoTable = AcpiDmTableInfoIvrs8c; 1395 break; 1396 1397 default: 1398 InfoTable = AcpiDmTableInfoIvrs4; 1399 AcpiOsPrintf ( 1400 "\n**** Unknown IVRS device entry type/length: " 1401 "0x%.2X/0x%X at offset 0x%.4X: (header below)\n", 1402 EntryType, EntryLength, EntryOffset); 1403 break; 1404 } 1405 1406 /* Dump the Device Entry */ 1407 1408 Status = AcpiDmDumpTable (Table->Length, EntryOffset, 1409 DeviceEntry, EntryLength, InfoTable); 1410 1411 EntryOffset += EntryLength; 1412 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry, 1413 EntryLength); 1414 } 1415 } 1416 1417NextSubTable: 1418 /* Point to next sub-table */ 1419 1420 Offset += SubTable->Length; 1421 SubTable = ACPI_ADD_PTR (ACPI_IVRS_HEADER, SubTable, SubTable->Length); 1422 } 1423} 1424 1425 1426/******************************************************************************* 1427 * 1428 * FUNCTION: AcpiDmDumpMadt 1429 * 1430 * PARAMETERS: Table - A MADT table 1431 * 1432 * RETURN: None 1433 * 1434 * DESCRIPTION: Format the contents of a MADT. This table type consists 1435 * of an open-ended number of subtables. 1436 * 1437 ******************************************************************************/ 1438 1439void 1440AcpiDmDumpMadt ( 1441 ACPI_TABLE_HEADER *Table) 1442{ 1443 ACPI_STATUS Status; 1444 ACPI_SUBTABLE_HEADER *SubTable; 1445 UINT32 Length = Table->Length; 1446 UINT32 Offset = sizeof (ACPI_TABLE_MADT); 1447 ACPI_DMTABLE_INFO *InfoTable; 1448 1449 1450 /* Main table */ 1451 1452 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoMadt); 1453 if (ACPI_FAILURE (Status)) 1454 { 1455 return; 1456 } 1457 1458 /* Sub-tables */ 1459 1460 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 1461 while (Offset < Table->Length) 1462 { 1463 /* Common sub-table header */ 1464 1465 AcpiOsPrintf ("\n"); 1466 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1467 SubTable->Length, AcpiDmTableInfoMadtHdr); 1468 if (ACPI_FAILURE (Status)) 1469 { 1470 return; 1471 } 1472 1473 switch (SubTable->Type) 1474 { 1475 case ACPI_MADT_TYPE_LOCAL_APIC: 1476 InfoTable = AcpiDmTableInfoMadt0; 1477 break; 1478 case ACPI_MADT_TYPE_IO_APIC: 1479 InfoTable = AcpiDmTableInfoMadt1; 1480 break; 1481 case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE: 1482 InfoTable = AcpiDmTableInfoMadt2; 1483 break; 1484 case ACPI_MADT_TYPE_NMI_SOURCE: 1485 InfoTable = AcpiDmTableInfoMadt3; 1486 break; 1487 case ACPI_MADT_TYPE_LOCAL_APIC_NMI: 1488 InfoTable = AcpiDmTableInfoMadt4; 1489 break; 1490 case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE: 1491 InfoTable = AcpiDmTableInfoMadt5; 1492 break; 1493 case ACPI_MADT_TYPE_IO_SAPIC: 1494 InfoTable = AcpiDmTableInfoMadt6; 1495 break; 1496 case ACPI_MADT_TYPE_LOCAL_SAPIC: 1497 InfoTable = AcpiDmTableInfoMadt7; 1498 break; 1499 case ACPI_MADT_TYPE_INTERRUPT_SOURCE: 1500 InfoTable = AcpiDmTableInfoMadt8; 1501 break; 1502 case ACPI_MADT_TYPE_LOCAL_X2APIC: 1503 InfoTable = AcpiDmTableInfoMadt9; 1504 break; 1505 case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI: 1506 InfoTable = AcpiDmTableInfoMadt10; 1507 break; 1508 case ACPI_MADT_TYPE_GENERIC_INTERRUPT: 1509 InfoTable = AcpiDmTableInfoMadt11; 1510 break; 1511 case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR: 1512 InfoTable = AcpiDmTableInfoMadt12; 1513 break; 1514 default: 1515 AcpiOsPrintf ("\n**** Unknown MADT sub-table type 0x%X\n\n", SubTable->Type); 1516 1517 /* Attempt to continue */ 1518 1519 if (!SubTable->Length) 1520 { 1521 AcpiOsPrintf ("Invalid zero length subtable\n"); 1522 return; 1523 } 1524 goto NextSubTable; 1525 } 1526 1527 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1528 SubTable->Length, InfoTable); 1529 if (ACPI_FAILURE (Status)) 1530 { 1531 return; 1532 } 1533 1534NextSubTable: 1535 /* Point to next sub-table */ 1536 1537 Offset += SubTable->Length; 1538 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 1539 } 1540} 1541 1542 1543/******************************************************************************* 1544 * 1545 * FUNCTION: AcpiDmDumpMcfg 1546 * 1547 * PARAMETERS: Table - A MCFG Table 1548 * 1549 * RETURN: None 1550 * 1551 * DESCRIPTION: Format the contents of a MCFG table 1552 * 1553 ******************************************************************************/ 1554 1555void 1556AcpiDmDumpMcfg ( 1557 ACPI_TABLE_HEADER *Table) 1558{ 1559 ACPI_STATUS Status; 1560 UINT32 Offset = sizeof (ACPI_TABLE_MCFG); 1561 ACPI_MCFG_ALLOCATION *SubTable; 1562 1563 1564 /* Main table */ 1565 1566 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMcfg); 1567 if (ACPI_FAILURE (Status)) 1568 { 1569 return; 1570 } 1571 1572 /* Sub-tables */ 1573 1574 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, Table, Offset); 1575 while (Offset < Table->Length) 1576 { 1577 if (Offset + sizeof (ACPI_MCFG_ALLOCATION) > Table->Length) 1578 { 1579 AcpiOsPrintf ("Warning: there are %u invalid trailing bytes\n", 1580 sizeof (ACPI_MCFG_ALLOCATION) - (Offset - Table->Length)); 1581 return; 1582 } 1583 1584 AcpiOsPrintf ("\n"); 1585 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1586 sizeof (ACPI_MCFG_ALLOCATION), AcpiDmTableInfoMcfg0); 1587 if (ACPI_FAILURE (Status)) 1588 { 1589 return; 1590 } 1591 1592 /* Point to next sub-table (each subtable is of fixed length) */ 1593 1594 Offset += sizeof (ACPI_MCFG_ALLOCATION); 1595 SubTable = ACPI_ADD_PTR (ACPI_MCFG_ALLOCATION, SubTable, 1596 sizeof (ACPI_MCFG_ALLOCATION)); 1597 } 1598} 1599 1600 1601/******************************************************************************* 1602 * 1603 * FUNCTION: AcpiDmDumpMpst 1604 * 1605 * PARAMETERS: Table - A MPST Table 1606 * 1607 * RETURN: None 1608 * 1609 * DESCRIPTION: Format the contents of a MPST table 1610 * 1611 ******************************************************************************/ 1612 1613void 1614AcpiDmDumpMpst ( 1615 ACPI_TABLE_HEADER *Table) 1616{ 1617 ACPI_STATUS Status; 1618 UINT32 Offset = sizeof (ACPI_TABLE_MPST); 1619 ACPI_MPST_POWER_NODE *SubTable0; 1620 ACPI_MPST_POWER_STATE *SubTable0A; 1621 ACPI_MPST_COMPONENT *SubTable0B; 1622 ACPI_MPST_DATA_HDR *SubTable1; 1623 ACPI_MPST_POWER_DATA *SubTable2; 1624 UINT16 SubtableCount; 1625 UINT32 PowerStateCount; 1626 UINT32 ComponentCount; 1627 1628 1629 /* Main table */ 1630 1631 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMpst); 1632 if (ACPI_FAILURE (Status)) 1633 { 1634 return; 1635 } 1636 1637 /* Subtable: Memory Power Node(s) */ 1638 1639 SubtableCount = (ACPI_CAST_PTR (ACPI_TABLE_MPST, Table))->PowerNodeCount; 1640 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, Table, Offset); 1641 1642 while ((Offset < Table->Length) && SubtableCount) 1643 { 1644 AcpiOsPrintf ("\n"); 1645 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0, 1646 sizeof (ACPI_MPST_POWER_NODE), AcpiDmTableInfoMpst0); 1647 if (ACPI_FAILURE (Status)) 1648 { 1649 return; 1650 } 1651 1652 /* Extract the sub-subtable counts */ 1653 1654 PowerStateCount = SubTable0->NumPowerStates; 1655 ComponentCount = SubTable0->NumPhysicalComponents; 1656 Offset += sizeof (ACPI_MPST_POWER_NODE); 1657 1658 /* Sub-subtables - Memory Power State Structure(s) */ 1659 1660 SubTable0A = ACPI_ADD_PTR (ACPI_MPST_POWER_STATE, SubTable0, 1661 sizeof (ACPI_MPST_POWER_NODE)); 1662 1663 while (PowerStateCount) 1664 { 1665 AcpiOsPrintf ("\n"); 1666 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0A, 1667 sizeof (ACPI_MPST_POWER_STATE), AcpiDmTableInfoMpst0A); 1668 if (ACPI_FAILURE (Status)) 1669 { 1670 return; 1671 } 1672 1673 SubTable0A++; 1674 PowerStateCount--; 1675 Offset += sizeof (ACPI_MPST_POWER_STATE); 1676 } 1677 1678 /* Sub-subtables - Physical Component ID Structure(s) */ 1679 1680 SubTable0B = ACPI_CAST_PTR (ACPI_MPST_COMPONENT, SubTable0A); 1681 1682 if (ComponentCount) 1683 { 1684 AcpiOsPrintf ("\n"); 1685 } 1686 1687 while (ComponentCount) 1688 { 1689 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable0B, 1690 sizeof (ACPI_MPST_COMPONENT), AcpiDmTableInfoMpst0B); 1691 if (ACPI_FAILURE (Status)) 1692 { 1693 return; 1694 } 1695 1696 SubTable0B++; 1697 ComponentCount--; 1698 Offset += sizeof (ACPI_MPST_COMPONENT); 1699 } 1700 1701 /* Point to next Memory Power Node subtable */ 1702 1703 SubtableCount--; 1704 SubTable0 = ACPI_ADD_PTR (ACPI_MPST_POWER_NODE, SubTable0, 1705 sizeof (ACPI_MPST_POWER_NODE) + 1706 (sizeof (ACPI_MPST_POWER_STATE) * SubTable0->NumPowerStates) + 1707 (sizeof (ACPI_MPST_COMPONENT) * SubTable0->NumPhysicalComponents)); 1708 } 1709 1710 /* Subtable: Count of Memory Power State Characteristic structures */ 1711 1712 AcpiOsPrintf ("\n"); 1713 SubTable1 = ACPI_CAST_PTR (ACPI_MPST_DATA_HDR, SubTable0); 1714 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable1, 1715 sizeof (ACPI_MPST_DATA_HDR), AcpiDmTableInfoMpst1); 1716 if (ACPI_FAILURE (Status)) 1717 { 1718 return; 1719 } 1720 1721 SubtableCount = SubTable1->CharacteristicsCount; 1722 Offset += sizeof (ACPI_MPST_DATA_HDR); 1723 1724 /* Subtable: Memory Power State Characteristics structure(s) */ 1725 1726 SubTable2 = ACPI_ADD_PTR (ACPI_MPST_POWER_DATA, SubTable1, sizeof (ACPI_MPST_DATA_HDR)); 1727 1728 while ((Offset < Table->Length) && SubtableCount) 1729 { 1730 AcpiOsPrintf ("\n"); 1731 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable2, 1732 sizeof (ACPI_MPST_POWER_DATA), AcpiDmTableInfoMpst2); 1733 if (ACPI_FAILURE (Status)) 1734 { 1735 return; 1736 } 1737 1738 SubTable2++; 1739 SubtableCount--; 1740 Offset += sizeof (ACPI_MPST_POWER_DATA); 1741 } 1742} 1743 1744 1745/******************************************************************************* 1746 * 1747 * FUNCTION: AcpiDmDumpMsct 1748 * 1749 * PARAMETERS: Table - A MSCT table 1750 * 1751 * RETURN: None 1752 * 1753 * DESCRIPTION: Format the contents of a MSCT 1754 * 1755 ******************************************************************************/ 1756 1757void 1758AcpiDmDumpMsct ( 1759 ACPI_TABLE_HEADER *Table) 1760{ 1761 ACPI_STATUS Status; 1762 UINT32 Offset = sizeof (ACPI_TABLE_MSCT); 1763 ACPI_MSCT_PROXIMITY *SubTable; 1764 1765 1766 /* Main table */ 1767 1768 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoMsct); 1769 if (ACPI_FAILURE (Status)) 1770 { 1771 return; 1772 } 1773 1774 /* Sub-tables */ 1775 1776 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, Table, Offset); 1777 while (Offset < Table->Length) 1778 { 1779 /* Common sub-table header */ 1780 1781 AcpiOsPrintf ("\n"); 1782 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 1783 sizeof (ACPI_MSCT_PROXIMITY), AcpiDmTableInfoMsct0); 1784 if (ACPI_FAILURE (Status)) 1785 { 1786 return; 1787 } 1788 1789 /* Point to next sub-table */ 1790 1791 Offset += sizeof (ACPI_MSCT_PROXIMITY); 1792 SubTable = ACPI_ADD_PTR (ACPI_MSCT_PROXIMITY, SubTable, sizeof (ACPI_MSCT_PROXIMITY)); 1793 } 1794} 1795 1796 1797/******************************************************************************* 1798 * 1799 * FUNCTION: AcpiDmDumpPcct 1800 * 1801 * PARAMETERS: Table - A PCCT table 1802 * 1803 * RETURN: None 1804 * 1805 * DESCRIPTION: Format the contents of a PCCT. This table type consists 1806 * of an open-ended number of subtables. 1807 * 1808 ******************************************************************************/ 1809 1810void 1811AcpiDmDumpPcct ( 1812 ACPI_TABLE_HEADER *Table) 1813{ 1814 ACPI_STATUS Status; 1815 ACPI_PCCT_SUBSPACE *SubTable; 1816 UINT32 Length = Table->Length; 1817 UINT32 Offset = sizeof (ACPI_TABLE_PCCT); 1818 1819 1820 /* Main table */ 1821 1822 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPcct); 1823 if (ACPI_FAILURE (Status)) 1824 { 1825 return; 1826 } 1827 1828 /* Sub-tables */ 1829 1830 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, Table, Offset); 1831 while (Offset < Table->Length) 1832 { 1833 AcpiOsPrintf ("\n"); 1834 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1835 SubTable->Header.Length, AcpiDmTableInfoPcct0); 1836 if (ACPI_FAILURE (Status)) 1837 { 1838 return; 1839 } 1840 1841 /* Point to next sub-table */ 1842 1843 Offset += SubTable->Header.Length; 1844 SubTable = ACPI_ADD_PTR (ACPI_PCCT_SUBSPACE, SubTable, 1845 SubTable->Header.Length); 1846 } 1847} 1848 1849 1850/******************************************************************************* 1851 * 1852 * FUNCTION: AcpiDmDumpPmtt 1853 * 1854 * PARAMETERS: Table - A PMTT table 1855 * 1856 * RETURN: None 1857 * 1858 * DESCRIPTION: Format the contents of a PMTT. This table type consists 1859 * of an open-ended number of subtables. 1860 * 1861 ******************************************************************************/ 1862 1863void 1864AcpiDmDumpPmtt ( 1865 ACPI_TABLE_HEADER *Table) 1866{ 1867 ACPI_STATUS Status; 1868 ACPI_PMTT_HEADER *SubTable; 1869 ACPI_PMTT_HEADER *MemSubTable; 1870 ACPI_PMTT_HEADER *DimmSubTable; 1871 ACPI_PMTT_DOMAIN *DomainArray; 1872 UINT32 Length = Table->Length; 1873 UINT32 Offset = sizeof (ACPI_TABLE_PMTT); 1874 UINT32 MemOffset; 1875 UINT32 DimmOffset; 1876 UINT32 DomainOffset; 1877 UINT32 DomainCount; 1878 1879 1880 /* Main table */ 1881 1882 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt); 1883 if (ACPI_FAILURE (Status)) 1884 { 1885 return; 1886 } 1887 1888 /* Subtables */ 1889 1890 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset); 1891 while (Offset < Table->Length) 1892 { 1893 /* Common subtable header */ 1894 1895 AcpiOsPrintf ("\n"); 1896 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1897 SubTable->Length, AcpiDmTableInfoPmttHdr); 1898 if (ACPI_FAILURE (Status)) 1899 { 1900 return; 1901 } 1902 1903 /* Only Socket subtables are expected at this level */ 1904 1905 if (SubTable->Type != ACPI_PMTT_TYPE_SOCKET) 1906 { 1907 AcpiOsPrintf ( 1908 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 1909 SubTable->Type); 1910 return; 1911 } 1912 1913 /* Dump the fixed-length portion of the subtable */ 1914 1915 Status = AcpiDmDumpTable (Length, Offset, SubTable, 1916 SubTable->Length, AcpiDmTableInfoPmtt0); 1917 if (ACPI_FAILURE (Status)) 1918 { 1919 return; 1920 } 1921 1922 /* Walk the memory controller subtables */ 1923 1924 MemOffset = sizeof (ACPI_PMTT_SOCKET); 1925 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, SubTable, 1926 sizeof (ACPI_PMTT_SOCKET)); 1927 1928 while (((Offset + MemOffset) < Table->Length) && 1929 (MemOffset < SubTable->Length)) 1930 { 1931 /* Common subtable header */ 1932 1933 AcpiOsPrintf ("\n"); 1934 Status = AcpiDmDumpTable (Length, 1935 Offset + MemOffset, MemSubTable, 1936 MemSubTable->Length, AcpiDmTableInfoPmttHdr); 1937 if (ACPI_FAILURE (Status)) 1938 { 1939 return; 1940 } 1941 1942 /* Only memory controller subtables are expected at this level */ 1943 1944 if (MemSubTable->Type != ACPI_PMTT_TYPE_CONTROLLER) 1945 { 1946 AcpiOsPrintf ( 1947 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 1948 MemSubTable->Type); 1949 return; 1950 } 1951 1952 /* Dump the fixed-length portion of the controller subtable */ 1953 1954 Status = AcpiDmDumpTable (Length, 1955 Offset + MemOffset, MemSubTable, 1956 MemSubTable->Length, AcpiDmTableInfoPmtt1); 1957 if (ACPI_FAILURE (Status)) 1958 { 1959 return; 1960 } 1961 1962 /* Walk the variable count of proximity domains */ 1963 1964 DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubTable)->DomainCount; 1965 DomainOffset = sizeof (ACPI_PMTT_CONTROLLER); 1966 DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubTable, 1967 sizeof (ACPI_PMTT_CONTROLLER)); 1968 1969 while (((Offset + MemOffset + DomainOffset) < Table->Length) && 1970 ((MemOffset + DomainOffset) < SubTable->Length) && 1971 DomainCount) 1972 { 1973 Status = AcpiDmDumpTable (Length, 1974 Offset + MemOffset + DomainOffset, DomainArray, 1975 sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a); 1976 if (ACPI_FAILURE (Status)) 1977 { 1978 return; 1979 } 1980 1981 DomainOffset += sizeof (ACPI_PMTT_DOMAIN); 1982 DomainArray++; 1983 DomainCount--; 1984 } 1985 1986 if (DomainCount) 1987 { 1988 AcpiOsPrintf ( 1989 "\n**** DomainCount exceeds subtable length\n\n", 1990 MemSubTable->Type); 1991 } 1992 1993 /* Walk the physical component (DIMM) subtables */ 1994 1995 DimmOffset = DomainOffset; 1996 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubTable, 1997 DomainOffset); 1998 1999 while (((Offset + MemOffset + DimmOffset) < Table->Length) && 2000 (DimmOffset < MemSubTable->Length)) 2001 { 2002 /* Common subtable header */ 2003 2004 AcpiOsPrintf ("\n"); 2005 Status = AcpiDmDumpTable (Length, 2006 Offset + MemOffset + DimmOffset, DimmSubTable, 2007 DimmSubTable->Length, AcpiDmTableInfoPmttHdr); 2008 if (ACPI_FAILURE (Status)) 2009 { 2010 return; 2011 } 2012 2013 /* Only DIMM subtables are expected at this level */ 2014 2015 if (DimmSubTable->Type != ACPI_PMTT_TYPE_DIMM) 2016 { 2017 AcpiOsPrintf ( 2018 "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n", 2019 DimmSubTable->Type); 2020 return; 2021 } 2022 2023 /* Dump the fixed-length DIMM subtable */ 2024 2025 Status = AcpiDmDumpTable (Length, 2026 Offset + MemOffset + DimmOffset, DimmSubTable, 2027 DimmSubTable->Length, AcpiDmTableInfoPmtt2); 2028 if (ACPI_FAILURE (Status)) 2029 { 2030 return; 2031 } 2032 2033 /* Point to next DIMM subtable */ 2034 2035 DimmOffset += DimmSubTable->Length; 2036 DimmSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2037 DimmSubTable, DimmSubTable->Length); 2038 } 2039 2040 /* Point to next Controller subtable */ 2041 2042 MemOffset += MemSubTable->Length; 2043 MemSubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2044 MemSubTable, MemSubTable->Length); 2045 } 2046 2047 /* Point to next Socket subtable */ 2048 2049 Offset += SubTable->Length; 2050 SubTable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, 2051 SubTable, SubTable->Length); 2052 } 2053} 2054 2055 2056/******************************************************************************* 2057 * 2058 * FUNCTION: AcpiDmDumpS3pt 2059 * 2060 * PARAMETERS: Table - A S3PT table 2061 * 2062 * RETURN: Length of the table 2063 * 2064 * DESCRIPTION: Format the contents of a S3PT 2065 * 2066 ******************************************************************************/ 2067 2068UINT32 2069AcpiDmDumpS3pt ( 2070 ACPI_TABLE_HEADER *Tables) 2071{ 2072 ACPI_STATUS Status; 2073 UINT32 Offset = sizeof (ACPI_TABLE_S3PT); 2074 ACPI_S3PT_HEADER *SubTable; 2075 ACPI_DMTABLE_INFO *InfoTable; 2076 ACPI_TABLE_S3PT *S3ptTable = ACPI_CAST_PTR (ACPI_TABLE_S3PT, Tables); 2077 2078 2079 /* Main table */ 2080 2081 Status = AcpiDmDumpTable (Offset, 0, S3ptTable, 0, AcpiDmTableInfoS3pt); 2082 if (ACPI_FAILURE (Status)) 2083 { 2084 return 0; 2085 } 2086 2087 SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, S3ptTable, Offset); 2088 while (Offset < S3ptTable->Length) 2089 { 2090 /* Common sub-table header */ 2091 2092 AcpiOsPrintf ("\n"); 2093 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 2094 SubTable->Length, AcpiDmTableInfoS3ptHdr); 2095 if (ACPI_FAILURE (Status)) 2096 { 2097 return 0; 2098 } 2099 2100 switch (SubTable->Type) 2101 { 2102 case ACPI_S3PT_TYPE_RESUME: 2103 InfoTable = AcpiDmTableInfoS3pt0; 2104 break; 2105 case ACPI_S3PT_TYPE_SUSPEND: 2106 InfoTable = AcpiDmTableInfoS3pt1; 2107 break; 2108 default: 2109 AcpiOsPrintf ("\n**** Unknown S3PT sub-table type 0x%X\n", SubTable->Type); 2110 2111 /* Attempt to continue */ 2112 2113 if (!SubTable->Length) 2114 { 2115 AcpiOsPrintf ("Invalid zero length subtable\n"); 2116 return 0; 2117 } 2118 goto NextSubTable; 2119 } 2120 2121 AcpiOsPrintf ("\n"); 2122 Status = AcpiDmDumpTable (S3ptTable->Length, Offset, SubTable, 2123 SubTable->Length, InfoTable); 2124 if (ACPI_FAILURE (Status)) 2125 { 2126 return 0; 2127 } 2128 2129NextSubTable: 2130 /* Point to next sub-table */ 2131 2132 Offset += SubTable->Length; 2133 SubTable = ACPI_ADD_PTR (ACPI_S3PT_HEADER, SubTable, SubTable->Length); 2134 } 2135 2136 return (S3ptTable->Length); 2137} 2138 2139 2140/******************************************************************************* 2141 * 2142 * FUNCTION: AcpiDmDumpSlic 2143 * 2144 * PARAMETERS: Table - A SLIC table 2145 * 2146 * RETURN: None 2147 * 2148 * DESCRIPTION: Format the contents of a SLIC 2149 * 2150 ******************************************************************************/ 2151 2152void 2153AcpiDmDumpSlic ( 2154 ACPI_TABLE_HEADER *Table) 2155{ 2156 ACPI_STATUS Status; 2157 UINT32 Offset = sizeof (ACPI_TABLE_SLIC); 2158 ACPI_SLIC_HEADER *SubTable; 2159 ACPI_DMTABLE_INFO *InfoTable; 2160 2161 2162 /* There is no main SLIC table, only subtables */ 2163 2164 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, Table, Offset); 2165 while (Offset < Table->Length) 2166 { 2167 /* Common sub-table header */ 2168 2169 AcpiOsPrintf ("\n"); 2170 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2171 SubTable->Length, AcpiDmTableInfoSlicHdr); 2172 if (ACPI_FAILURE (Status)) 2173 { 2174 return; 2175 } 2176 2177 switch (SubTable->Type) 2178 { 2179 case ACPI_SLIC_TYPE_PUBLIC_KEY: 2180 InfoTable = AcpiDmTableInfoSlic0; 2181 break; 2182 case ACPI_SLIC_TYPE_WINDOWS_MARKER: 2183 InfoTable = AcpiDmTableInfoSlic1; 2184 break; 2185 default: 2186 AcpiOsPrintf ("\n**** Unknown SLIC sub-table type 0x%X\n", SubTable->Type); 2187 2188 /* Attempt to continue */ 2189 2190 if (!SubTable->Length) 2191 { 2192 AcpiOsPrintf ("Invalid zero length subtable\n"); 2193 return; 2194 } 2195 goto NextSubTable; 2196 } 2197 2198 AcpiOsPrintf ("\n"); 2199 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2200 SubTable->Length, InfoTable); 2201 if (ACPI_FAILURE (Status)) 2202 { 2203 return; 2204 } 2205 2206NextSubTable: 2207 /* Point to next sub-table */ 2208 2209 Offset += SubTable->Length; 2210 SubTable = ACPI_ADD_PTR (ACPI_SLIC_HEADER, SubTable, SubTable->Length); 2211 } 2212} 2213 2214 2215/******************************************************************************* 2216 * 2217 * FUNCTION: AcpiDmDumpSlit 2218 * 2219 * PARAMETERS: Table - An SLIT 2220 * 2221 * RETURN: None 2222 * 2223 * DESCRIPTION: Format the contents of a SLIT 2224 * 2225 ******************************************************************************/ 2226 2227void 2228AcpiDmDumpSlit ( 2229 ACPI_TABLE_HEADER *Table) 2230{ 2231 ACPI_STATUS Status; 2232 UINT32 Offset; 2233 UINT8 *Row; 2234 UINT32 Localities; 2235 UINT32 i; 2236 UINT32 j; 2237 2238 2239 /* Main table */ 2240 2241 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSlit); 2242 if (ACPI_FAILURE (Status)) 2243 { 2244 return; 2245 } 2246 2247 /* Display the Locality NxN Matrix */ 2248 2249 Localities = (UINT32) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->LocalityCount; 2250 Offset = ACPI_OFFSET (ACPI_TABLE_SLIT, Entry[0]); 2251 Row = (UINT8 *) ACPI_CAST_PTR (ACPI_TABLE_SLIT, Table)->Entry; 2252 2253 for (i = 0; i < Localities; i++) 2254 { 2255 /* Display one row of the matrix */ 2256 2257 AcpiDmLineHeader2 (Offset, Localities, "Locality", i); 2258 for (j = 0; j < Localities; j++) 2259 { 2260 /* Check for beyond EOT */ 2261 2262 if (Offset >= Table->Length) 2263 { 2264 AcpiOsPrintf ("\n**** Not enough room in table for all localities\n"); 2265 return; 2266 } 2267 2268 AcpiOsPrintf ("%2.2X", Row[j]); 2269 Offset++; 2270 2271 /* Display up to 16 bytes per output row */ 2272 2273 if ((j+1) < Localities) 2274 { 2275 AcpiOsPrintf (" "); 2276 2277 if (j && (((j+1) % 16) == 0)) 2278 { 2279 AcpiOsPrintf ("\\\n"); /* With line continuation char */ 2280 AcpiDmLineHeader (Offset, 0, NULL); 2281 } 2282 } 2283 } 2284 2285 /* Point to next row */ 2286 2287 AcpiOsPrintf ("\n"); 2288 Row += Localities; 2289 } 2290} 2291 2292 2293/******************************************************************************* 2294 * 2295 * FUNCTION: AcpiDmDumpSrat 2296 * 2297 * PARAMETERS: Table - A SRAT table 2298 * 2299 * RETURN: None 2300 * 2301 * DESCRIPTION: Format the contents of a SRAT 2302 * 2303 ******************************************************************************/ 2304 2305void 2306AcpiDmDumpSrat ( 2307 ACPI_TABLE_HEADER *Table) 2308{ 2309 ACPI_STATUS Status; 2310 UINT32 Offset = sizeof (ACPI_TABLE_SRAT); 2311 ACPI_SUBTABLE_HEADER *SubTable; 2312 ACPI_DMTABLE_INFO *InfoTable; 2313 2314 2315 /* Main table */ 2316 2317 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoSrat); 2318 if (ACPI_FAILURE (Status)) 2319 { 2320 return; 2321 } 2322 2323 /* Sub-tables */ 2324 2325 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Table, Offset); 2326 while (Offset < Table->Length) 2327 { 2328 /* Common sub-table header */ 2329 2330 AcpiOsPrintf ("\n"); 2331 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2332 SubTable->Length, AcpiDmTableInfoSratHdr); 2333 if (ACPI_FAILURE (Status)) 2334 { 2335 return; 2336 } 2337 2338 switch (SubTable->Type) 2339 { 2340 case ACPI_SRAT_TYPE_CPU_AFFINITY: 2341 InfoTable = AcpiDmTableInfoSrat0; 2342 break; 2343 case ACPI_SRAT_TYPE_MEMORY_AFFINITY: 2344 InfoTable = AcpiDmTableInfoSrat1; 2345 break; 2346 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY: 2347 InfoTable = AcpiDmTableInfoSrat2; 2348 break; 2349 default: 2350 AcpiOsPrintf ("\n**** Unknown SRAT sub-table type 0x%X\n", SubTable->Type); 2351 2352 /* Attempt to continue */ 2353 2354 if (!SubTable->Length) 2355 { 2356 AcpiOsPrintf ("Invalid zero length subtable\n"); 2357 return; 2358 } 2359 goto NextSubTable; 2360 } 2361 2362 AcpiOsPrintf ("\n"); 2363 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2364 SubTable->Length, InfoTable); 2365 if (ACPI_FAILURE (Status)) 2366 { 2367 return; 2368 } 2369 2370NextSubTable: 2371 /* Point to next sub-table */ 2372 2373 Offset += SubTable->Length; 2374 SubTable = ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, SubTable, SubTable->Length); 2375 } 2376} 2377 2378 2379/******************************************************************************* 2380 * 2381 * FUNCTION: AcpiDmDumpWdat 2382 * 2383 * PARAMETERS: Table - A WDAT table 2384 * 2385 * RETURN: None 2386 * 2387 * DESCRIPTION: Format the contents of a WDAT 2388 * 2389 ******************************************************************************/ 2390 2391void 2392AcpiDmDumpWdat ( 2393 ACPI_TABLE_HEADER *Table) 2394{ 2395 ACPI_STATUS Status; 2396 UINT32 Offset = sizeof (ACPI_TABLE_WDAT); 2397 ACPI_WDAT_ENTRY *SubTable; 2398 2399 2400 /* Main table */ 2401 2402 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoWdat); 2403 if (ACPI_FAILURE (Status)) 2404 { 2405 return; 2406 } 2407 2408 /* Sub-tables */ 2409 2410 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, Table, Offset); 2411 while (Offset < Table->Length) 2412 { 2413 /* Common sub-table header */ 2414 2415 AcpiOsPrintf ("\n"); 2416 Status = AcpiDmDumpTable (Table->Length, Offset, SubTable, 2417 sizeof (ACPI_WDAT_ENTRY), AcpiDmTableInfoWdat0); 2418 if (ACPI_FAILURE (Status)) 2419 { 2420 return; 2421 } 2422 2423 /* Point to next sub-table */ 2424 2425 Offset += sizeof (ACPI_WDAT_ENTRY); 2426 SubTable = ACPI_ADD_PTR (ACPI_WDAT_ENTRY, SubTable, sizeof (ACPI_WDAT_ENTRY)); 2427 } 2428} 2429