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