dmtbdump1.c revision 1.1.1.10
1 /****************************************************************************** 2 * 3 * Module Name: dmtbdump1 - Dump ACPI data tables that contain no AML code 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2023, 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 MERCHANTABILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include "acpi.h" 45 #include "accommon.h" 46 #include "acdisasm.h" 47 #include "actables.h" 48 #include "aslcompiler.h" 49 50 /* This module used for application-level code only */ 51 52 #define _COMPONENT ACPI_CA_DISASSEMBLER 53 ACPI_MODULE_NAME ("dmtbdump1") 54 55 56 /******************************************************************************* 57 * 58 * FUNCTION: AcpiDmDumpAest 59 * 60 * PARAMETERS: Table - A AEST table 61 * 62 * RETURN: None 63 * 64 * DESCRIPTION: Format the contents of a AEST table 65 * 66 * NOTE: Assumes the following table structure: 67 * For all AEST Error Nodes: 68 * 1) An AEST Error Node, followed immediately by: 69 * 2) Any node-specific data 70 * 3) An Interface Structure (one) 71 * 4) A list (array) of Interrupt Structures 72 * 73 * AEST - ARM Error Source table. Conforms to: 74 * ACPI for the Armv8 RAS Extensions 1.1 Platform Design Document Sep 2020 75 * 76 ******************************************************************************/ 77 78 void 79 AcpiDmDumpAest ( 80 ACPI_TABLE_HEADER *Table) 81 { 82 ACPI_STATUS Status; 83 UINT32 Offset = sizeof (ACPI_TABLE_HEADER); 84 ACPI_AEST_HEADER *Subtable; 85 ACPI_AEST_HEADER *NodeHeader; 86 ACPI_AEST_PROCESSOR *ProcessorSubtable; 87 ACPI_DMTABLE_INFO *InfoTable; 88 ACPI_SIZE Length; 89 UINT8 Type; 90 91 92 /* Very small, generic main table. AEST consists of mostly subtables */ 93 94 while (Offset < Table->Length) 95 { 96 NodeHeader = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 97 98 /* Dump the common error node (subtable) header */ 99 100 Status = AcpiDmDumpTable (Table->Length, Offset, NodeHeader, 101 NodeHeader->Length, AcpiDmTableInfoAestHdr); 102 if (ACPI_FAILURE (Status)) 103 { 104 return; 105 } 106 107 Type = NodeHeader->Type; 108 109 /* Setup the node-specific subtable based on the header Type field */ 110 111 switch (Type) 112 { 113 case ACPI_AEST_PROCESSOR_ERROR_NODE: 114 InfoTable = AcpiDmTableInfoAestProcError; 115 Length = sizeof (ACPI_AEST_PROCESSOR); 116 break; 117 118 case ACPI_AEST_MEMORY_ERROR_NODE: 119 InfoTable = AcpiDmTableInfoAestMemError; 120 Length = sizeof (ACPI_AEST_MEMORY); 121 break; 122 123 case ACPI_AEST_SMMU_ERROR_NODE: 124 InfoTable = AcpiDmTableInfoAestSmmuError; 125 Length = sizeof (ACPI_AEST_SMMU); 126 break; 127 128 case ACPI_AEST_VENDOR_ERROR_NODE: 129 InfoTable = AcpiDmTableInfoAestVendorError; 130 Length = sizeof (ACPI_AEST_VENDOR); 131 break; 132 133 case ACPI_AEST_GIC_ERROR_NODE: 134 InfoTable = AcpiDmTableInfoAestGicError; 135 Length = sizeof (ACPI_AEST_GIC); 136 break; 137 138 /* Error case below */ 139 default: 140 141 AcpiOsPrintf ("\n**** Unknown AEST Error Subtable type 0x%X\n", 142 Type); 143 return; 144 } 145 146 /* Point past the common header (to the node-specific data) */ 147 148 Offset += sizeof (ACPI_AEST_HEADER); 149 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 150 AcpiOsPrintf ("\n"); 151 152 /* Dump the node-specific subtable */ 153 154 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, Length, 155 InfoTable); 156 if (ACPI_FAILURE (Status)) 157 { 158 return; 159 } 160 AcpiOsPrintf ("\n"); 161 162 if (Type == ACPI_AEST_PROCESSOR_ERROR_NODE) 163 { 164 /* 165 * Special handling for PROCESSOR_ERROR_NODE subtables 166 * (to handle the Resource Substructure via the ResourceType 167 * field). 168 */ 169 170 /* Point past the node-specific data */ 171 172 Offset += Length; 173 ProcessorSubtable = ACPI_CAST_PTR (ACPI_AEST_PROCESSOR, Subtable); 174 175 switch (ProcessorSubtable->ResourceType) 176 { 177 /* Setup the Resource Substructure subtable */ 178 179 case ACPI_AEST_CACHE_RESOURCE: 180 InfoTable = AcpiDmTableInfoAestCacheRsrc; 181 Length = sizeof (ACPI_AEST_PROCESSOR_CACHE); 182 break; 183 184 case ACPI_AEST_TLB_RESOURCE: 185 InfoTable = AcpiDmTableInfoAestTlbRsrc; 186 Length = sizeof (ACPI_AEST_PROCESSOR_TLB); 187 break; 188 189 case ACPI_AEST_GENERIC_RESOURCE: 190 InfoTable = AcpiDmTableInfoAestGenRsrc; 191 Length = sizeof (ACPI_AEST_PROCESSOR_GENERIC); 192 break; 193 194 /* Error case below */ 195 default: 196 AcpiOsPrintf ("\n**** Unknown AEST Processor Resource type 0x%X\n", 197 ProcessorSubtable->ResourceType); 198 return; 199 } 200 201 ProcessorSubtable = ACPI_ADD_PTR (ACPI_AEST_PROCESSOR, Table, 202 Offset); 203 204 /* Dump the resource substructure subtable */ 205 206 Status = AcpiDmDumpTable (Table->Length, Offset, ProcessorSubtable, 207 Length, InfoTable); 208 if (ACPI_FAILURE (Status)) 209 { 210 return; 211 } 212 213 AcpiOsPrintf ("\n"); 214 } 215 216 /* Point past the resource substructure or the node-specific data */ 217 218 Offset += Length; 219 220 /* Dump the interface structure, required to be present */ 221 222 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 223 if (Subtable->Type >= ACPI_AEST_XFACE_RESERVED) 224 { 225 AcpiOsPrintf ("\n**** Unknown AEST Node Interface type 0x%X\n", 226 Subtable->Type); 227 return; 228 } 229 230 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 231 sizeof (ACPI_AEST_NODE_INTERFACE), AcpiDmTableInfoAestXface); 232 if (ACPI_FAILURE (Status)) 233 { 234 return; 235 } 236 237 /* Point past the interface structure */ 238 239 AcpiOsPrintf ("\n"); 240 Offset += sizeof (ACPI_AEST_NODE_INTERFACE); 241 242 /* Dump the entire interrupt structure array, if present */ 243 244 if (NodeHeader->NodeInterruptOffset) 245 { 246 Length = NodeHeader->NodeInterruptCount; 247 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 248 249 while (Length) 250 { 251 /* Dump the interrupt structure */ 252 253 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 254 sizeof (ACPI_AEST_NODE_INTERRUPT), 255 AcpiDmTableInfoAestXrupt); 256 if (ACPI_FAILURE (Status)) 257 { 258 return; 259 } 260 261 /* Point to the next interrupt structure */ 262 263 Offset += sizeof (ACPI_AEST_NODE_INTERRUPT); 264 Subtable = ACPI_ADD_PTR (ACPI_AEST_HEADER, Table, Offset); 265 Length--; 266 AcpiOsPrintf ("\n"); 267 } 268 } 269 } 270 } 271 272 /******************************************************************************* 273 * 274 * FUNCTION: AcpiDmDumpApmt 275 * 276 * PARAMETERS: Table - A APMT table 277 * 278 * RETURN: None 279 * 280 * DESCRIPTION: Format the contents of a APMT. This table type consists 281 * of an open-ended number of subtables. 282 * 283 * 284 * APMT - ARM Performance Monitoring Unit table. Conforms to: 285 * ARM Performance Monitoring Unit Architecture 1.0 Platform Design Document 286 * ARM DEN0117 v1.0 November 25, 2021 287 * 288 ******************************************************************************/ 289 290 void 291 AcpiDmDumpApmt ( 292 ACPI_TABLE_HEADER *Table) 293 { 294 ACPI_STATUS Status; 295 ACPI_APMT_NODE *Subtable; 296 UINT32 Length = Table->Length; 297 UINT32 Offset = sizeof (ACPI_TABLE_APMT); 298 UINT32 NodeNum = 0; 299 300 /* There is no main table (other than the standard ACPI header) */ 301 302 /* Subtables */ 303 304 Subtable = ACPI_ADD_PTR (ACPI_APMT_NODE, Table, Offset); 305 while (Offset < Table->Length) 306 { 307 AcpiOsPrintf ("\n"); 308 309 if (Subtable->Type >= ACPI_APMT_NODE_TYPE_COUNT) 310 { 311 AcpiOsPrintf ("\n**** Unknown APMT subtable type 0x%X\n", 312 Subtable->Type); 313 return; 314 } 315 316 AcpiOsPrintf ("/* APMT Node-%u */\n", NodeNum++); 317 318 Status = AcpiDmDumpTable (Length, Offset, Subtable, 319 Subtable->Length, AcpiDmTableInfoApmtNode); 320 if (ACPI_FAILURE (Status)) 321 { 322 return; 323 } 324 325 /* Point to next subtable */ 326 327 Offset += Subtable->Length; 328 Subtable = ACPI_ADD_PTR (ACPI_APMT_NODE, Subtable, 329 Subtable->Length); 330 AcpiOsPrintf ("\n"); 331 } 332 } 333 334 335 /******************************************************************************* 336 * 337 * FUNCTION: AcpiDmDumpAsf 338 * 339 * PARAMETERS: Table - A ASF table 340 * 341 * RETURN: None 342 * 343 * DESCRIPTION: Format the contents of a ASF table 344 * 345 ******************************************************************************/ 346 347 void 348 AcpiDmDumpAsf ( 349 ACPI_TABLE_HEADER *Table) 350 { 351 ACPI_STATUS Status; 352 UINT32 Offset = sizeof (ACPI_TABLE_HEADER); 353 ACPI_ASF_INFO *Subtable; 354 ACPI_DMTABLE_INFO *InfoTable; 355 ACPI_DMTABLE_INFO *DataInfoTable = NULL; 356 UINT8 *DataTable = NULL; 357 UINT32 DataCount = 0; 358 UINT32 DataLength = 0; 359 UINT32 DataOffset = 0; 360 UINT32 i; 361 UINT8 Type; 362 363 364 /* No main table, only subtables */ 365 366 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Table, Offset); 367 while (Offset < Table->Length) 368 { 369 /* Common subtable header */ 370 371 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 372 Subtable->Header.Length, AcpiDmTableInfoAsfHdr); 373 if (ACPI_FAILURE (Status)) 374 { 375 return; 376 } 377 378 /* The actual type is the lower 7 bits of Type */ 379 380 Type = (UINT8) (Subtable->Header.Type & 0x7F); 381 382 switch (Type) 383 { 384 case ACPI_ASF_TYPE_INFO: 385 386 InfoTable = AcpiDmTableInfoAsf0; 387 break; 388 389 case ACPI_ASF_TYPE_ALERT: 390 391 InfoTable = AcpiDmTableInfoAsf1; 392 DataInfoTable = AcpiDmTableInfoAsf1a; 393 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ALERT)); 394 DataCount = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->Alerts; 395 DataLength = ACPI_CAST_PTR (ACPI_ASF_ALERT, Subtable)->DataLength; 396 DataOffset = Offset + sizeof (ACPI_ASF_ALERT); 397 break; 398 399 case ACPI_ASF_TYPE_CONTROL: 400 401 InfoTable = AcpiDmTableInfoAsf2; 402 DataInfoTable = AcpiDmTableInfoAsf2a; 403 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_REMOTE)); 404 DataCount = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->Controls; 405 DataLength = ACPI_CAST_PTR (ACPI_ASF_REMOTE, Subtable)->DataLength; 406 DataOffset = Offset + sizeof (ACPI_ASF_REMOTE); 407 break; 408 409 case ACPI_ASF_TYPE_BOOT: 410 411 InfoTable = AcpiDmTableInfoAsf3; 412 break; 413 414 case ACPI_ASF_TYPE_ADDRESS: 415 416 InfoTable = AcpiDmTableInfoAsf4; 417 DataTable = ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_ASF_ADDRESS)); 418 DataLength = ACPI_CAST_PTR (ACPI_ASF_ADDRESS, Subtable)->Devices; 419 DataOffset = Offset + sizeof (ACPI_ASF_ADDRESS); 420 break; 421 422 default: 423 424 AcpiOsPrintf ("\n**** Unknown ASF subtable type 0x%X\n", 425 Subtable->Header.Type); 426 return; 427 } 428 429 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 430 Subtable->Header.Length, InfoTable); 431 if (ACPI_FAILURE (Status)) 432 { 433 return; 434 } 435 436 /* Dump variable-length extra data */ 437 438 switch (Type) 439 { 440 case ACPI_ASF_TYPE_ALERT: 441 case ACPI_ASF_TYPE_CONTROL: 442 443 for (i = 0; i < DataCount; i++) 444 { 445 AcpiOsPrintf ("\n"); 446 Status = AcpiDmDumpTable (Table->Length, DataOffset, 447 DataTable, DataLength, DataInfoTable); 448 if (ACPI_FAILURE (Status)) 449 { 450 return; 451 } 452 453 DataTable = ACPI_ADD_PTR (UINT8, DataTable, DataLength); 454 DataOffset += DataLength; 455 } 456 break; 457 458 case ACPI_ASF_TYPE_ADDRESS: 459 460 for (i = 0; i < DataLength; i++) 461 { 462 if (!(i % 16)) 463 { 464 AcpiDmLineHeader (DataOffset, 1, "Addresses"); 465 } 466 467 AcpiOsPrintf ("%2.2X ", *DataTable); 468 DataTable++; 469 DataOffset++; 470 471 if (DataOffset > Table->Length) 472 { 473 AcpiOsPrintf ( 474 "**** ACPI table terminates in the middle of a " 475 "data structure! (ASF! table)\n"); 476 return; 477 } 478 } 479 480 AcpiOsPrintf ("\n"); 481 break; 482 483 default: 484 485 break; 486 } 487 488 AcpiOsPrintf ("\n"); 489 490 /* Point to next subtable */ 491 492 if (!Subtable->Header.Length) 493 { 494 AcpiOsPrintf ("Invalid zero subtable header length\n"); 495 return; 496 } 497 498 Offset += Subtable->Header.Length; 499 Subtable = ACPI_ADD_PTR (ACPI_ASF_INFO, Subtable, 500 Subtable->Header.Length); 501 } 502 } 503 504 /******************************************************************************* 505 * 506 * FUNCTION: AcpiDmDumpAspt 507 * 508 * PARAMETERS: Table - A ASPT table 509 * 510 * RETURN: None 511 * 512 * DESCRIPTION: Format the contents of a ASPT table 513 * 514 ******************************************************************************/ 515 516 void 517 AcpiDmDumpAspt ( 518 ACPI_TABLE_HEADER *Table) 519 { 520 ACPI_STATUS Status; 521 UINT32 Offset = sizeof (ACPI_TABLE_ASPT); 522 UINT32 Length = Table->Length; 523 ACPI_ASPT_HEADER *Subtable; 524 ACPI_DMTABLE_INFO *InfoTable; 525 UINT16 Type; 526 527 /* Main table */ 528 Status = AcpiDmDumpTable(Length, 0, Table, 0, AcpiDmTableInfoAspt); 529 530 /* Subtables */ 531 532 Subtable = ACPI_ADD_PTR (ACPI_ASPT_HEADER, Table, Offset); 533 while (Offset < Table->Length) 534 { 535 AcpiOsPrintf ("\n"); 536 537 /* Common subtable header */ 538 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 539 Subtable->Length, AcpiDmTableInfoAsptHdr); 540 if (ACPI_FAILURE (Status)) 541 { 542 return; 543 } 544 545 Type = Subtable->Type; 546 547 switch (Type) 548 { 549 case ACPI_ASPT_TYPE_GLOBAL_REGS: 550 551 InfoTable = AcpiDmTableInfoAspt0; 552 break; 553 554 case ACPI_ASPT_TYPE_SEV_MBOX_REGS: 555 556 InfoTable = AcpiDmTableInfoAspt1; 557 break; 558 559 case ACPI_ASPT_TYPE_ACPI_MBOX_REGS: 560 561 InfoTable = AcpiDmTableInfoAspt2; 562 break; 563 564 default: 565 566 AcpiOsPrintf ("\n**** Unknown ASPT subtable type 0x%X\n", 567 Subtable->Type); 568 return; 569 } 570 571 Status = AcpiDmDumpTable (Table->Length, Offset, Subtable, 572 Subtable->Length, InfoTable); 573 if (ACPI_FAILURE (Status)) 574 { 575 return; 576 } 577 578 AcpiOsPrintf ("\n"); 579 580 /* Point to next subtable */ 581 if (!Subtable->Length) 582 { 583 AcpiOsPrintf ("Invalid zero subtable header length\n"); 584 return; 585 } 586 587 Offset += Subtable->Length; 588 Subtable = ACPI_ADD_PTR (ACPI_ASPT_HEADER, Subtable, 589 Subtable->Length); 590 } 591 } 592 593 594 /******************************************************************************* 595 * 596 * FUNCTION: AcpiDmDumpCdat 597 * 598 * PARAMETERS: InTable - A CDAT table 599 * 600 * RETURN: None 601 * 602 * DESCRIPTION: Format the contents of a CDAT. This table type consists 603 * of an open-ended number of subtables. 604 * 605 ******************************************************************************/ 606 607 void 608 AcpiDmDumpCdat ( 609 ACPI_TABLE_HEADER *InTable) 610 { 611 ACPI_TABLE_CDAT *Table = ACPI_CAST_PTR (ACPI_TABLE_CDAT, InTable); 612 ACPI_STATUS Status; 613 ACPI_CDAT_HEADER *Subtable; 614 ACPI_TABLE_CDAT *CdatTable = ACPI_CAST_PTR (ACPI_TABLE_CDAT, Table); 615 ACPI_DMTABLE_INFO *InfoTable; 616 UINT32 Length = CdatTable->Length; 617 UINT32 Offset = sizeof (ACPI_TABLE_CDAT); 618 UINT32 SubtableLength; 619 UINT32 SubtableType; 620 INT32 EntriesLength; 621 622 623 /* Main table */ 624 625 Status = AcpiDmDumpTable (Offset, 0, CdatTable, 0, 626 AcpiDmTableInfoCdatTableHdr); 627 if (ACPI_FAILURE (Status)) 628 { 629 return; 630 } 631 632 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, sizeof (ACPI_TABLE_CDAT)); 633 while (Offset < Table->Length) 634 { 635 /* Dump the common subtable header */ 636 637 DbgPrint (ASL_DEBUG_OUTPUT, "0) HeaderOffset: %X\n", Offset); 638 AcpiOsPrintf ("\n"); 639 Status = AcpiDmDumpTable (Length, Offset, Subtable, 640 sizeof (ACPI_CDAT_HEADER), AcpiDmTableInfoCdatHeader); 641 if (ACPI_FAILURE (Status)) 642 { 643 return; 644 } 645 646 /* Point past the common subtable header, decode the subtable type */ 647 648 Offset += sizeof (ACPI_CDAT_HEADER); 649 SubtableType = Subtable->Type; 650 651 switch (Subtable->Type) 652 { 653 case ACPI_CDAT_TYPE_DSMAS: 654 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 655 SubtableLength = sizeof (ACPI_CDAT_DSMAS); 656 657 InfoTable = AcpiDmTableInfoCdat0; 658 break; 659 660 case ACPI_CDAT_TYPE_DSLBIS: 661 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 662 SubtableLength = sizeof (ACPI_CDAT_DSLBIS); 663 DbgPrint (ASL_DEBUG_OUTPUT, "1) Offset: %X\n", Offset); 664 665 InfoTable = AcpiDmTableInfoCdat1; 666 break; 667 668 case ACPI_CDAT_TYPE_DSMSCIS: 669 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 670 SubtableLength = sizeof (ACPI_CDAT_DSMSCIS); 671 672 InfoTable = AcpiDmTableInfoCdat2; 673 break; 674 675 case ACPI_CDAT_TYPE_DSIS: 676 DbgPrint (ASL_DEBUG_OUTPUT, "2) Offset: %X ", Offset); 677 SubtableLength = sizeof (ACPI_CDAT_DSIS); 678 DbgPrint (ASL_DEBUG_OUTPUT, "1) input pointer: %p\n", Table); 679 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 680 DbgPrint (ASL_DEBUG_OUTPUT, "1) output pointers: %p, %p, Offset: %X\n", 681 Table, Subtable, Offset); 682 DbgPrint (ASL_DEBUG_OUTPUT, "3) Offset: %X\n", Offset); 683 684 InfoTable = AcpiDmTableInfoCdat3; 685 break; 686 687 case ACPI_CDAT_TYPE_DSEMTS: 688 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 689 SubtableLength = sizeof (ACPI_CDAT_DSEMTS); 690 691 InfoTable = AcpiDmTableInfoCdat4; 692 break; 693 694 case ACPI_CDAT_TYPE_SSLBIS: 695 SubtableLength = Subtable->Length; 696 697 InfoTable = AcpiDmTableInfoCdat5; 698 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 699 break; 700 701 default: 702 fprintf (stderr, "ERROR: Unknown SubtableType: %X\n", Subtable->Type); 703 return; 704 } 705 706 DbgPrint (ASL_DEBUG_OUTPUT, "SubtableType: %X, Length: %X Actual " 707 "Length: %X Offset: %X tableptr: %p\n", SubtableType, 708 Subtable->Length, SubtableLength, Offset, Table); 709 710 /* 711 * Do the subtable-specific fields 712 */ 713 Status = AcpiDmDumpTable (Length, Offset, Subtable, Offset, InfoTable); 714 if (ACPI_FAILURE (Status)) 715 { 716 return; 717 } 718 719 DbgPrint (ASL_DEBUG_OUTPUT, "Subtable Type: %X, Offset: %X, SubtableLength: %X\n", 720 SubtableType, Offset, SubtableLength); 721 722 /* Additional sub-subtables, dependent on the main subtable type */ 723 724 switch (SubtableType) 725 { 726 case ACPI_CDAT_TYPE_SSLBIS: 727 Offset += sizeof (ACPI_CDAT_SSLBIS); 728 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, 729 Offset); 730 731 DbgPrint (ASL_DEBUG_OUTPUT, "Case SSLBIS, Offset: %X, SubtableLength: %X " 732 "Subtable->Length %X\n", Offset, SubtableLength, Subtable->Length); 733 734 /* Generate the total length of all the SSLBE entries */ 735 736 EntriesLength = SubtableLength - sizeof (ACPI_CDAT_HEADER) - 737 sizeof (ACPI_CDAT_SSLBIS); 738 DbgPrint (ASL_DEBUG_OUTPUT, "EntriesLength: %X, Offset: %X, Table->Length: %X\n", 739 EntriesLength, Offset, Table->Length); 740 741 /* Do each of the SSLBE Entries */ 742 743 while ((EntriesLength > 0) && (Offset < Table->Length)) 744 { 745 AcpiOsPrintf ("\n"); 746 747 Status = AcpiDmDumpTable (Length, Offset, Subtable, Offset, 748 AcpiDmTableInfoCdatEntries); 749 if (ACPI_FAILURE (Status)) 750 { 751 return; 752 } 753 754 EntriesLength -= sizeof (ACPI_CDAT_SSLBE); 755 Offset += sizeof (ACPI_CDAT_SSLBE); 756 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 757 } 758 759 SubtableLength = 0; 760 break; 761 762 default: 763 break; 764 } 765 766 DbgPrint (ASL_DEBUG_OUTPUT, "Offset: %X, Subtable Length: %X\n", 767 Offset, SubtableLength); 768 769 /* Point to next subtable */ 770 771 Offset += SubtableLength; 772 Subtable = ACPI_ADD_PTR (ACPI_CDAT_HEADER, Table, Offset); 773 } 774 775 return; 776 } 777 778 779 /******************************************************************************* 780 * 781 * FUNCTION: AcpiDmDumpCedt 782 * 783 * PARAMETERS: Table - A CEDT table 784 * 785 * RETURN: None 786 * 787 * DESCRIPTION: Format the contents of a CEDT. This table type consists 788 * of an open-ended number of subtables. 789 * 790 ******************************************************************************/ 791 792 void 793 AcpiDmDumpCedt ( 794 ACPI_TABLE_HEADER *Table) 795 { 796 ACPI_STATUS Status; 797 ACPI_CEDT_HEADER *Subtable; 798 UINT32 Length = Table->Length; 799 UINT32 Offset = sizeof (ACPI_TABLE_CEDT); 800 801 802 /* There is no main table (other than the standard ACPI header) */ 803 804 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Table, Offset); 805 while (Offset < Table->Length) 806 { 807 /* Common subtable header */ 808 809 AcpiOsPrintf ("\n"); 810 Status = AcpiDmDumpTable (Length, Offset, Subtable, 811 Subtable->Length, AcpiDmTableInfoCedtHdr); 812 if (ACPI_FAILURE (Status)) 813 { 814 return; 815 } 816 817 switch (Subtable->Type) 818 { 819 case ACPI_CEDT_TYPE_CHBS: 820 Status = AcpiDmDumpTable (Length, Offset, Subtable, 821 Subtable->Length, AcpiDmTableInfoCedt0); 822 if (ACPI_FAILURE (Status)) 823 { 824 return; 825 } 826 break; 827 828 case ACPI_CEDT_TYPE_CFMWS: 829 { 830 ACPI_CEDT_CFMWS *ptr = (ACPI_CEDT_CFMWS *) Subtable; 831 unsigned int i, max = 0x01 << (ptr->InterleaveWays); 832 833 /* print out table with first "Interleave target" */ 834 835 Status = AcpiDmDumpTable (Length, Offset, Subtable, 836 Subtable->Length, AcpiDmTableInfoCedt1); 837 if (ACPI_FAILURE (Status)) 838 { 839 return; 840 } 841 842 /* Now, print out any interleave targets beyond the first. */ 843 844 for (i = 1; i < max; i++) 845 { 846 unsigned int loc_offset = Offset + (i * 4) + ACPI_OFFSET (ACPI_CEDT_CFMWS, InterleaveTargets); 847 unsigned int *trg = &(ptr->InterleaveTargets[i]); 848 849 Status = AcpiDmDumpTable (Length, loc_offset, trg, 850 Subtable->Length, AcpiDmTableInfoCedt1_te); 851 if (ACPI_FAILURE (Status)) 852 { 853 return; 854 } 855 } 856 break; 857 } 858 859 default: 860 AcpiOsPrintf ("\n**** Unknown CEDT subtable type 0x%X\n\n", 861 Subtable->Type); 862 863 /* Attempt to continue */ 864 if (!Subtable->Length) 865 { 866 AcpiOsPrintf ("Invalid zero length subtable\n"); 867 return; 868 } 869 } 870 871 /* Point to next subtable */ 872 Offset += Subtable->Length; 873 Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Subtable, 874 Subtable->Length); 875 } 876 } 877 878 /******************************************************************************* 879 * 880 * FUNCTION: AcpiDmDumpCpep 881 * 882 * PARAMETERS: Table - A CPEP table 883 * 884 * RETURN: None 885 * 886 * DESCRIPTION: Format the contents of a CPEP. This table type consists 887 * of an open-ended number of subtables. 888 * 889 ******************************************************************************/ 890 891 void 892 AcpiDmDumpCpep ( 893 ACPI_TABLE_HEADER *Table) 894 { 895 ACPI_STATUS Status; 896 ACPI_CPEP_POLLING *Subtable; 897 UINT32 Length = Table->Length; 898 UINT32 Offset = sizeof (ACPI_TABLE_CPEP); 899 900 901 /* Main table */ 902 903 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoCpep); 904 if (ACPI_FAILURE (Status)) 905 { 906 return; 907 } 908 909 /* Subtables */ 910 911 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Table, Offset); 912 while (Offset < Table->Length) 913 { 914 AcpiOsPrintf ("\n"); 915 Status = AcpiDmDumpTable (Length, Offset, Subtable, 916 Subtable->Header.Length, AcpiDmTableInfoCpep0); 917 if (ACPI_FAILURE (Status)) 918 { 919 return; 920 } 921 922 /* Point to next subtable */ 923 924 Offset += Subtable->Header.Length; 925 Subtable = ACPI_ADD_PTR (ACPI_CPEP_POLLING, Subtable, 926 Subtable->Header.Length); 927 } 928 } 929 930 931 /******************************************************************************* 932 * 933 * FUNCTION: AcpiDmDumpCsrt 934 * 935 * PARAMETERS: Table - A CSRT table 936 * 937 * RETURN: None 938 * 939 * DESCRIPTION: Format the contents of a CSRT. This table type consists 940 * of an open-ended number of subtables. 941 * 942 ******************************************************************************/ 943 944 void 945 AcpiDmDumpCsrt ( 946 ACPI_TABLE_HEADER *Table) 947 { 948 ACPI_STATUS Status; 949 ACPI_CSRT_GROUP *Subtable; 950 ACPI_CSRT_SHARED_INFO *SharedInfoTable; 951 ACPI_CSRT_DESCRIPTOR *SubSubtable; 952 UINT32 Length = Table->Length; 953 UINT32 Offset = sizeof (ACPI_TABLE_CSRT); 954 UINT32 SubOffset; 955 UINT32 SubSubOffset; 956 UINT32 InfoLength; 957 958 959 /* The main table only contains the ACPI header, thus already handled */ 960 961 /* Subtables (Resource Groups) */ 962 963 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Table, Offset); 964 while (Offset < Table->Length) 965 { 966 /* Resource group subtable */ 967 968 AcpiOsPrintf ("\n"); 969 Status = AcpiDmDumpTable (Length, Offset, Subtable, 970 Subtable->Length, AcpiDmTableInfoCsrt0); 971 if (ACPI_FAILURE (Status)) 972 { 973 return; 974 } 975 976 /* Shared info subtable (One per resource group) */ 977 978 SubOffset = sizeof (ACPI_CSRT_GROUP); 979 SharedInfoTable = ACPI_ADD_PTR (ACPI_CSRT_SHARED_INFO, Table, 980 Offset + SubOffset); 981 982 AcpiOsPrintf ("\n"); 983 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SharedInfoTable, 984 sizeof (ACPI_CSRT_SHARED_INFO), AcpiDmTableInfoCsrt1); 985 if (ACPI_FAILURE (Status)) 986 { 987 return; 988 } 989 990 SubOffset += Subtable->SharedInfoLength; 991 992 /* Sub-Subtables (Resource Descriptors) */ 993 994 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, Table, 995 Offset + SubOffset); 996 997 while ((SubOffset < Subtable->Length) && 998 ((Offset + SubOffset) < Table->Length)) 999 { 1000 AcpiOsPrintf ("\n"); 1001 Status = AcpiDmDumpTable (Length, Offset + SubOffset, SubSubtable, 1002 SubSubtable->Length, AcpiDmTableInfoCsrt2); 1003 if (ACPI_FAILURE (Status)) 1004 { 1005 return; 1006 } 1007 1008 SubSubOffset = sizeof (ACPI_CSRT_DESCRIPTOR); 1009 1010 /* Resource-specific info buffer */ 1011 1012 InfoLength = SubSubtable->Length - SubSubOffset; 1013 if (InfoLength) 1014 { 1015 Status = AcpiDmDumpTable (Length, 1016 Offset + SubOffset + SubSubOffset, Table, 1017 InfoLength, AcpiDmTableInfoCsrt2a); 1018 if (ACPI_FAILURE (Status)) 1019 { 1020 return; 1021 } 1022 } 1023 1024 /* Point to next sub-subtable */ 1025 1026 SubOffset += SubSubtable->Length; 1027 SubSubtable = ACPI_ADD_PTR (ACPI_CSRT_DESCRIPTOR, SubSubtable, 1028 SubSubtable->Length); 1029 } 1030 1031 /* Point to next subtable */ 1032 1033 Offset += Subtable->Length; 1034 Subtable = ACPI_ADD_PTR (ACPI_CSRT_GROUP, Subtable, 1035 Subtable->Length); 1036 } 1037 } 1038 1039 1040 /******************************************************************************* 1041 * 1042 * FUNCTION: AcpiDmDumpDbg2 1043 * 1044 * PARAMETERS: Table - A DBG2 table 1045 * 1046 * RETURN: None 1047 * 1048 * DESCRIPTION: Format the contents of a DBG2. This table type consists 1049 * of an open-ended number of subtables. 1050 * 1051 ******************************************************************************/ 1052 1053 void 1054 AcpiDmDumpDbg2 ( 1055 ACPI_TABLE_HEADER *Table) 1056 { 1057 ACPI_STATUS Status; 1058 ACPI_DBG2_DEVICE *Subtable; 1059 UINT32 Length = Table->Length; 1060 UINT32 Offset = sizeof (ACPI_TABLE_DBG2); 1061 UINT32 i; 1062 UINT32 ArrayOffset; 1063 UINT32 AbsoluteOffset; 1064 UINT8 *Array; 1065 1066 1067 /* Main table */ 1068 1069 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDbg2); 1070 if (ACPI_FAILURE (Status)) 1071 { 1072 return; 1073 } 1074 1075 /* Subtables */ 1076 1077 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Table, Offset); 1078 while (Offset < Table->Length) 1079 { 1080 AcpiOsPrintf ("\n"); 1081 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1082 Subtable->Length, AcpiDmTableInfoDbg2Device); 1083 if (ACPI_FAILURE (Status)) 1084 { 1085 return; 1086 } 1087 1088 /* Dump the BaseAddress array */ 1089 1090 for (i = 0; i < Subtable->RegisterCount; i++) 1091 { 1092 ArrayOffset = Subtable->BaseAddressOffset + 1093 (sizeof (ACPI_GENERIC_ADDRESS) * i); 1094 AbsoluteOffset = Offset + ArrayOffset; 1095 Array = (UINT8 *) Subtable + ArrayOffset; 1096 1097 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 1098 Subtable->Length, AcpiDmTableInfoDbg2Addr); 1099 if (ACPI_FAILURE (Status)) 1100 { 1101 return; 1102 } 1103 } 1104 1105 /* Dump the AddressSize array */ 1106 1107 for (i = 0; i < Subtable->RegisterCount; i++) 1108 { 1109 ArrayOffset = Subtable->AddressSizeOffset + 1110 (sizeof (UINT32) * i); 1111 AbsoluteOffset = Offset + ArrayOffset; 1112 Array = (UINT8 *) Subtable + ArrayOffset; 1113 1114 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 1115 Subtable->Length, AcpiDmTableInfoDbg2Size); 1116 if (ACPI_FAILURE (Status)) 1117 { 1118 return; 1119 } 1120 } 1121 1122 /* Dump the Namestring (required) */ 1123 1124 AcpiOsPrintf ("\n"); 1125 ArrayOffset = Subtable->NamepathOffset; 1126 AbsoluteOffset = Offset + ArrayOffset; 1127 Array = (UINT8 *) Subtable + ArrayOffset; 1128 1129 Status = AcpiDmDumpTable (Length, AbsoluteOffset, Array, 1130 Subtable->Length, AcpiDmTableInfoDbg2Name); 1131 if (ACPI_FAILURE (Status)) 1132 { 1133 return; 1134 } 1135 1136 /* Dump the OemData (optional) */ 1137 1138 if (Subtable->OemDataOffset) 1139 { 1140 Status = AcpiDmDumpTable (Length, Offset + Subtable->OemDataOffset, 1141 Table, Subtable->OemDataLength, 1142 AcpiDmTableInfoDbg2OemData); 1143 if (ACPI_FAILURE (Status)) 1144 { 1145 return; 1146 } 1147 } 1148 1149 /* Point to next subtable */ 1150 1151 Offset += Subtable->Length; 1152 Subtable = ACPI_ADD_PTR (ACPI_DBG2_DEVICE, Subtable, 1153 Subtable->Length); 1154 } 1155 } 1156 1157 1158 /******************************************************************************* 1159 * 1160 * FUNCTION: AcpiDmDumpDmar 1161 * 1162 * PARAMETERS: Table - A DMAR table 1163 * 1164 * RETURN: None 1165 * 1166 * DESCRIPTION: Format the contents of a DMAR. This table type consists 1167 * of an open-ended number of subtables. 1168 * 1169 ******************************************************************************/ 1170 1171 void 1172 AcpiDmDumpDmar ( 1173 ACPI_TABLE_HEADER *Table) 1174 { 1175 ACPI_STATUS Status; 1176 ACPI_DMAR_HEADER *Subtable; 1177 UINT32 Length = Table->Length; 1178 UINT32 Offset = sizeof (ACPI_TABLE_DMAR); 1179 ACPI_DMTABLE_INFO *InfoTable; 1180 ACPI_DMAR_DEVICE_SCOPE *ScopeTable; 1181 UINT32 ScopeOffset; 1182 UINT8 *PciPath; 1183 UINT32 PathOffset; 1184 1185 1186 /* Main table */ 1187 1188 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoDmar); 1189 if (ACPI_FAILURE (Status)) 1190 { 1191 return; 1192 } 1193 1194 /* Subtables */ 1195 1196 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Table, Offset); 1197 while (Offset < Table->Length) 1198 { 1199 /* Common subtable header */ 1200 1201 AcpiOsPrintf ("\n"); 1202 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1203 Subtable->Length, AcpiDmTableInfoDmarHdr); 1204 if (ACPI_FAILURE (Status)) 1205 { 1206 return; 1207 } 1208 1209 AcpiOsPrintf ("\n"); 1210 1211 switch (Subtable->Type) 1212 { 1213 case ACPI_DMAR_TYPE_HARDWARE_UNIT: 1214 1215 InfoTable = AcpiDmTableInfoDmar0; 1216 ScopeOffset = sizeof (ACPI_DMAR_HARDWARE_UNIT); 1217 break; 1218 1219 case ACPI_DMAR_TYPE_RESERVED_MEMORY: 1220 1221 InfoTable = AcpiDmTableInfoDmar1; 1222 ScopeOffset = sizeof (ACPI_DMAR_RESERVED_MEMORY); 1223 break; 1224 1225 case ACPI_DMAR_TYPE_ROOT_ATS: 1226 1227 InfoTable = AcpiDmTableInfoDmar2; 1228 ScopeOffset = sizeof (ACPI_DMAR_ATSR); 1229 break; 1230 1231 case ACPI_DMAR_TYPE_HARDWARE_AFFINITY: 1232 1233 InfoTable = AcpiDmTableInfoDmar3; 1234 ScopeOffset = sizeof (ACPI_DMAR_RHSA); 1235 break; 1236 1237 case ACPI_DMAR_TYPE_NAMESPACE: 1238 1239 InfoTable = AcpiDmTableInfoDmar4; 1240 ScopeOffset = sizeof (ACPI_DMAR_ANDD); 1241 break; 1242 1243 case ACPI_DMAR_TYPE_SATC: 1244 1245 InfoTable = AcpiDmTableInfoDmar5; 1246 ScopeOffset = sizeof (ACPI_DMAR_SATC); 1247 break; 1248 1249 default: 1250 1251 AcpiOsPrintf ("\n**** Unknown DMAR subtable type 0x%X\n\n", 1252 Subtable->Type); 1253 return; 1254 } 1255 1256 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1257 Subtable->Length, InfoTable); 1258 if (ACPI_FAILURE (Status)) 1259 { 1260 return; 1261 } 1262 1263 /* 1264 * Dump the optional device scope entries 1265 */ 1266 if ((Subtable->Type == ACPI_DMAR_TYPE_HARDWARE_AFFINITY) || 1267 (Subtable->Type == ACPI_DMAR_TYPE_NAMESPACE)) 1268 { 1269 /* These types do not support device scopes */ 1270 1271 goto NextSubtable; 1272 } 1273 1274 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, Subtable, ScopeOffset); 1275 while (ScopeOffset < Subtable->Length) 1276 { 1277 AcpiOsPrintf ("\n"); 1278 Status = AcpiDmDumpTable (Length, Offset + ScopeOffset, ScopeTable, 1279 ScopeTable->Length, AcpiDmTableInfoDmarScope); 1280 if (ACPI_FAILURE (Status)) 1281 { 1282 return; 1283 } 1284 AcpiOsPrintf ("\n"); 1285 1286 /* Dump the PCI Path entries for this device scope */ 1287 1288 PathOffset = sizeof (ACPI_DMAR_DEVICE_SCOPE); /* Path entries start at this offset */ 1289 1290 PciPath = ACPI_ADD_PTR (UINT8, ScopeTable, 1291 sizeof (ACPI_DMAR_DEVICE_SCOPE)); 1292 1293 while (PathOffset < ScopeTable->Length) 1294 { 1295 AcpiDmLineHeader ((PathOffset + ScopeOffset + Offset), 2, 1296 "PCI Path"); 1297 AcpiOsPrintf ("%2.2X,%2.2X\n", PciPath[0], PciPath[1]); 1298 1299 /* Point to next PCI Path entry */ 1300 1301 PathOffset += 2; 1302 PciPath += 2; 1303 AcpiOsPrintf ("\n"); 1304 } 1305 1306 /* Point to next device scope entry */ 1307 1308 ScopeOffset += ScopeTable->Length; 1309 ScopeTable = ACPI_ADD_PTR (ACPI_DMAR_DEVICE_SCOPE, 1310 ScopeTable, ScopeTable->Length); 1311 } 1312 1313 NextSubtable: 1314 /* Point to next subtable */ 1315 1316 Offset += Subtable->Length; 1317 Subtable = ACPI_ADD_PTR (ACPI_DMAR_HEADER, Subtable, 1318 Subtable->Length); 1319 } 1320 } 1321 1322 1323 /******************************************************************************* 1324 * 1325 * FUNCTION: AcpiDmDumpDrtm 1326 * 1327 * PARAMETERS: Table - A DRTM table 1328 * 1329 * RETURN: None 1330 * 1331 * DESCRIPTION: Format the contents of a DRTM. 1332 * 1333 ******************************************************************************/ 1334 1335 void 1336 AcpiDmDumpDrtm ( 1337 ACPI_TABLE_HEADER *Table) 1338 { 1339 ACPI_STATUS Status; 1340 UINT32 Offset; 1341 ACPI_DRTM_VTABLE_LIST *DrtmVtl; 1342 ACPI_DRTM_RESOURCE_LIST *DrtmRl; 1343 ACPI_DRTM_DPS_ID *DrtmDps; 1344 UINT32 Count; 1345 1346 1347 /* Main table */ 1348 1349 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, 1350 AcpiDmTableInfoDrtm); 1351 if (ACPI_FAILURE (Status)) 1352 { 1353 return; 1354 } 1355 1356 Offset = sizeof (ACPI_TABLE_DRTM); 1357 1358 /* Sub-tables */ 1359 1360 /* Dump ValidatedTable length */ 1361 1362 DrtmVtl = ACPI_ADD_PTR (ACPI_DRTM_VTABLE_LIST, Table, Offset); 1363 AcpiOsPrintf ("\n"); 1364 Status = AcpiDmDumpTable (Table->Length, Offset, 1365 DrtmVtl, ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables), 1366 AcpiDmTableInfoDrtm0); 1367 if (ACPI_FAILURE (Status)) 1368 { 1369 return; 1370 } 1371 1372 Offset += ACPI_OFFSET (ACPI_DRTM_VTABLE_LIST, ValidatedTables); 1373 1374 /* Dump Validated table addresses */ 1375 1376 Count = 0; 1377 while ((Offset < Table->Length) && 1378 (DrtmVtl->ValidatedTableCount > Count)) 1379 { 1380 Status = AcpiDmDumpTable (Table->Length, Offset, 1381 ACPI_ADD_PTR (void, Table, Offset), sizeof (UINT64), 1382 AcpiDmTableInfoDrtm0a); 1383 if (ACPI_FAILURE (Status)) 1384 { 1385 return; 1386 } 1387 1388 Offset += sizeof (UINT64); 1389 Count++; 1390 } 1391 1392 /* Dump ResourceList length */ 1393 1394 DrtmRl = ACPI_ADD_PTR (ACPI_DRTM_RESOURCE_LIST, Table, Offset); 1395 AcpiOsPrintf ("\n"); 1396 Status = AcpiDmDumpTable (Table->Length, Offset, 1397 DrtmRl, ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources), 1398 AcpiDmTableInfoDrtm1); 1399 if (ACPI_FAILURE (Status)) 1400 { 1401 return; 1402 } 1403 1404 Offset += ACPI_OFFSET (ACPI_DRTM_RESOURCE_LIST, Resources); 1405 1406 /* Dump the Resource List */ 1407 1408 Count = 0; 1409 while ((Offset < Table->Length) && 1410 (DrtmRl->ResourceCount > Count)) 1411 { 1412 Status = AcpiDmDumpTable (Table->Length, Offset, 1413 ACPI_ADD_PTR (void, Table, Offset), 1414 sizeof (ACPI_DRTM_RESOURCE), AcpiDmTableInfoDrtm1a); 1415 if (ACPI_FAILURE (Status)) 1416 { 1417 return; 1418 } 1419 1420 Offset += sizeof (ACPI_DRTM_RESOURCE); 1421 Count++; 1422 } 1423 1424 /* Dump DPS */ 1425 1426 DrtmDps = ACPI_ADD_PTR (ACPI_DRTM_DPS_ID, Table, Offset); 1427 AcpiOsPrintf ("\n"); 1428 (void) AcpiDmDumpTable (Table->Length, Offset, 1429 DrtmDps, sizeof (ACPI_DRTM_DPS_ID), AcpiDmTableInfoDrtm2); 1430 } 1431 1432 1433 /******************************************************************************* 1434 * 1435 * FUNCTION: AcpiDmDumpEinj 1436 * 1437 * PARAMETERS: Table - A EINJ table 1438 * 1439 * RETURN: None 1440 * 1441 * DESCRIPTION: Format the contents of a EINJ. This table type consists 1442 * of an open-ended number of subtables. 1443 * 1444 ******************************************************************************/ 1445 1446 void 1447 AcpiDmDumpEinj ( 1448 ACPI_TABLE_HEADER *Table) 1449 { 1450 ACPI_STATUS Status; 1451 ACPI_WHEA_HEADER *Subtable; 1452 UINT32 Length = Table->Length; 1453 UINT32 Offset = sizeof (ACPI_TABLE_EINJ); 1454 1455 1456 /* Main table */ 1457 1458 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoEinj); 1459 if (ACPI_FAILURE (Status)) 1460 { 1461 return; 1462 } 1463 1464 /* Subtables */ 1465 1466 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1467 while (Offset < Table->Length) 1468 { 1469 AcpiOsPrintf ("\n"); 1470 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1471 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoEinj0); 1472 if (ACPI_FAILURE (Status)) 1473 { 1474 return; 1475 } 1476 1477 /* Point to next subtable (each subtable is of fixed length) */ 1478 1479 Offset += sizeof (ACPI_WHEA_HEADER); 1480 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable, 1481 sizeof (ACPI_WHEA_HEADER)); 1482 } 1483 } 1484 1485 1486 /******************************************************************************* 1487 * 1488 * FUNCTION: AcpiDmDumpErst 1489 * 1490 * PARAMETERS: Table - A ERST table 1491 * 1492 * RETURN: None 1493 * 1494 * DESCRIPTION: Format the contents of a ERST. This table type consists 1495 * of an open-ended number of subtables. 1496 * 1497 ******************************************************************************/ 1498 1499 void 1500 AcpiDmDumpErst ( 1501 ACPI_TABLE_HEADER *Table) 1502 { 1503 ACPI_STATUS Status; 1504 ACPI_WHEA_HEADER *Subtable; 1505 UINT32 Length = Table->Length; 1506 UINT32 Offset = sizeof (ACPI_TABLE_ERST); 1507 1508 1509 /* Main table */ 1510 1511 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoErst); 1512 if (ACPI_FAILURE (Status)) 1513 { 1514 return; 1515 } 1516 1517 /* Subtables */ 1518 1519 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Table, Offset); 1520 while (Offset < Table->Length) 1521 { 1522 AcpiOsPrintf ("\n"); 1523 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1524 sizeof (ACPI_WHEA_HEADER), AcpiDmTableInfoErst0); 1525 if (ACPI_FAILURE (Status)) 1526 { 1527 return; 1528 } 1529 1530 /* Point to next subtable (each subtable is of fixed length) */ 1531 1532 Offset += sizeof (ACPI_WHEA_HEADER); 1533 Subtable = ACPI_ADD_PTR (ACPI_WHEA_HEADER, Subtable, 1534 sizeof (ACPI_WHEA_HEADER)); 1535 } 1536 } 1537 1538 1539 /******************************************************************************* 1540 * 1541 * FUNCTION: AcpiDmDumpFpdt 1542 * 1543 * PARAMETERS: Table - A FPDT table 1544 * 1545 * RETURN: None 1546 * 1547 * DESCRIPTION: Format the contents of a FPDT. This table type consists 1548 * of an open-ended number of subtables. 1549 * 1550 ******************************************************************************/ 1551 1552 void 1553 AcpiDmDumpFpdt ( 1554 ACPI_TABLE_HEADER *Table) 1555 { 1556 ACPI_STATUS Status; 1557 ACPI_FPDT_HEADER *Subtable; 1558 UINT32 Length = Table->Length; 1559 UINT32 Offset = sizeof (ACPI_TABLE_FPDT); 1560 ACPI_DMTABLE_INFO *InfoTable; 1561 1562 1563 /* There is no main table (other than the standard ACPI header) */ 1564 1565 /* Subtables */ 1566 1567 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Table, Offset); 1568 while (Offset < Table->Length) 1569 { 1570 /* Common subtable header */ 1571 1572 AcpiOsPrintf ("\n"); 1573 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1574 Subtable->Length, AcpiDmTableInfoFpdtHdr); 1575 if (ACPI_FAILURE (Status)) 1576 { 1577 return; 1578 } 1579 1580 switch (Subtable->Type) 1581 { 1582 case ACPI_FPDT_TYPE_BOOT: 1583 1584 InfoTable = AcpiDmTableInfoFpdt0; 1585 break; 1586 1587 case ACPI_FPDT_TYPE_S3PERF: 1588 1589 InfoTable = AcpiDmTableInfoFpdt1; 1590 break; 1591 1592 default: 1593 1594 AcpiOsPrintf ("\n**** Unknown FPDT subtable type 0x%X\n\n", 1595 Subtable->Type); 1596 1597 /* Attempt to continue */ 1598 1599 if (!Subtable->Length) 1600 { 1601 AcpiOsPrintf ("Invalid zero length subtable\n"); 1602 return; 1603 } 1604 goto NextSubtable; 1605 } 1606 1607 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1608 Subtable->Length, InfoTable); 1609 if (ACPI_FAILURE (Status)) 1610 { 1611 return; 1612 } 1613 1614 NextSubtable: 1615 /* Point to next subtable */ 1616 1617 Offset += Subtable->Length; 1618 Subtable = ACPI_ADD_PTR (ACPI_FPDT_HEADER, Subtable, 1619 Subtable->Length); 1620 } 1621 } 1622 1623 1624 /******************************************************************************* 1625 * 1626 * FUNCTION: AcpiDmDumpGtdt 1627 * 1628 * PARAMETERS: Table - A GTDT table 1629 * 1630 * RETURN: None 1631 * 1632 * DESCRIPTION: Format the contents of a GTDT. This table type consists 1633 * of an open-ended number of subtables. 1634 * 1635 ******************************************************************************/ 1636 1637 void 1638 AcpiDmDumpGtdt ( 1639 ACPI_TABLE_HEADER *Table) 1640 { 1641 ACPI_STATUS Status; 1642 ACPI_GTDT_HEADER *Subtable; 1643 UINT32 Length = Table->Length; 1644 UINT32 Offset = sizeof (ACPI_TABLE_GTDT); 1645 ACPI_DMTABLE_INFO *InfoTable; 1646 UINT32 SubtableLength; 1647 UINT32 GtCount; 1648 ACPI_GTDT_TIMER_ENTRY *GtxTable; 1649 1650 1651 /* Main table */ 1652 1653 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoGtdt); 1654 if (ACPI_FAILURE (Status)) 1655 { 1656 return; 1657 } 1658 1659 /* Rev 3 fields */ 1660 1661 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 1662 1663 if (Table->Revision > 2) 1664 { 1665 SubtableLength = sizeof (ACPI_GTDT_EL2); 1666 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1667 SubtableLength, AcpiDmTableInfoGtdtEl2); 1668 if (ACPI_FAILURE (Status)) 1669 { 1670 return; 1671 } 1672 Offset += SubtableLength; 1673 } 1674 1675 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Table, Offset); 1676 1677 /* Subtables */ 1678 1679 while (Offset < Table->Length) 1680 { 1681 /* Common subtable header */ 1682 1683 AcpiOsPrintf ("\n"); 1684 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1685 Subtable->Length, AcpiDmTableInfoGtdtHdr); 1686 if (ACPI_FAILURE (Status)) 1687 { 1688 return; 1689 } 1690 1691 GtCount = 0; 1692 switch (Subtable->Type) 1693 { 1694 case ACPI_GTDT_TYPE_TIMER_BLOCK: 1695 1696 SubtableLength = sizeof (ACPI_GTDT_TIMER_BLOCK); 1697 GtCount = (ACPI_CAST_PTR (ACPI_GTDT_TIMER_BLOCK, 1698 Subtable))->TimerCount; 1699 1700 InfoTable = AcpiDmTableInfoGtdt0; 1701 break; 1702 1703 case ACPI_GTDT_TYPE_WATCHDOG: 1704 1705 SubtableLength = sizeof (ACPI_GTDT_WATCHDOG); 1706 1707 InfoTable = AcpiDmTableInfoGtdt1; 1708 break; 1709 1710 default: 1711 1712 /* Cannot continue on unknown type - no length */ 1713 1714 AcpiOsPrintf ("\n**** Unknown GTDT subtable type 0x%X\n", 1715 Subtable->Type); 1716 return; 1717 } 1718 1719 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1720 Subtable->Length, InfoTable); 1721 if (ACPI_FAILURE (Status)) 1722 { 1723 return; 1724 } 1725 1726 /* Point to end of current subtable (each subtable above is of fixed length) */ 1727 1728 Offset += SubtableLength; 1729 1730 /* If there are any Gt Timer Blocks from above, dump them now */ 1731 1732 if (GtCount) 1733 { 1734 GtxTable = ACPI_ADD_PTR ( 1735 ACPI_GTDT_TIMER_ENTRY, Subtable, SubtableLength); 1736 SubtableLength += GtCount * sizeof (ACPI_GTDT_TIMER_ENTRY); 1737 1738 while (GtCount) 1739 { 1740 AcpiOsPrintf ("\n"); 1741 Status = AcpiDmDumpTable (Length, Offset, GtxTable, 1742 sizeof (ACPI_GTDT_TIMER_ENTRY), AcpiDmTableInfoGtdt0a); 1743 if (ACPI_FAILURE (Status)) 1744 { 1745 return; 1746 } 1747 Offset += sizeof (ACPI_GTDT_TIMER_ENTRY); 1748 GtxTable++; 1749 GtCount--; 1750 } 1751 } 1752 1753 /* Point to next subtable */ 1754 1755 Subtable = ACPI_ADD_PTR (ACPI_GTDT_HEADER, Subtable, SubtableLength); 1756 } 1757 } 1758 1759 1760 /******************************************************************************* 1761 * 1762 * FUNCTION: AcpiDmDumpHest 1763 * 1764 * PARAMETERS: Table - A HEST table 1765 * 1766 * RETURN: None 1767 * 1768 * DESCRIPTION: Format the contents of a HEST. This table type consists 1769 * of an open-ended number of subtables. 1770 * 1771 ******************************************************************************/ 1772 1773 void 1774 AcpiDmDumpHest ( 1775 ACPI_TABLE_HEADER *Table) 1776 { 1777 ACPI_STATUS Status; 1778 ACPI_HEST_HEADER *Subtable; 1779 UINT32 Length = Table->Length; 1780 UINT32 Offset = sizeof (ACPI_TABLE_HEST); 1781 ACPI_DMTABLE_INFO *InfoTable; 1782 UINT32 SubtableLength; 1783 UINT32 BankCount; 1784 ACPI_HEST_IA_ERROR_BANK *BankTable; 1785 1786 1787 /* Main table */ 1788 1789 Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHest); 1790 if (ACPI_FAILURE (Status)) 1791 { 1792 return; 1793 } 1794 1795 /* Subtables */ 1796 1797 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Table, Offset); 1798 while (Offset < Table->Length) 1799 { 1800 BankCount = 0; 1801 switch (Subtable->Type) 1802 { 1803 case ACPI_HEST_TYPE_IA32_CHECK: 1804 1805 InfoTable = AcpiDmTableInfoHest0; 1806 SubtableLength = sizeof (ACPI_HEST_IA_MACHINE_CHECK); 1807 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_MACHINE_CHECK, 1808 Subtable))->NumHardwareBanks; 1809 break; 1810 1811 case ACPI_HEST_TYPE_IA32_CORRECTED_CHECK: 1812 1813 InfoTable = AcpiDmTableInfoHest1; 1814 SubtableLength = sizeof (ACPI_HEST_IA_CORRECTED); 1815 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_CORRECTED, 1816 Subtable))->NumHardwareBanks; 1817 break; 1818 1819 case ACPI_HEST_TYPE_IA32_NMI: 1820 1821 InfoTable = AcpiDmTableInfoHest2; 1822 SubtableLength = sizeof (ACPI_HEST_IA_NMI); 1823 break; 1824 1825 case ACPI_HEST_TYPE_AER_ROOT_PORT: 1826 1827 InfoTable = AcpiDmTableInfoHest6; 1828 SubtableLength = sizeof (ACPI_HEST_AER_ROOT); 1829 break; 1830 1831 case ACPI_HEST_TYPE_AER_ENDPOINT: 1832 1833 InfoTable = AcpiDmTableInfoHest7; 1834 SubtableLength = sizeof (ACPI_HEST_AER); 1835 break; 1836 1837 case ACPI_HEST_TYPE_AER_BRIDGE: 1838 1839 InfoTable = AcpiDmTableInfoHest8; 1840 SubtableLength = sizeof (ACPI_HEST_AER_BRIDGE); 1841 break; 1842 1843 case ACPI_HEST_TYPE_GENERIC_ERROR: 1844 1845 InfoTable = AcpiDmTableInfoHest9; 1846 SubtableLength = sizeof (ACPI_HEST_GENERIC); 1847 break; 1848 1849 case ACPI_HEST_TYPE_GENERIC_ERROR_V2: 1850 1851 InfoTable = AcpiDmTableInfoHest10; 1852 SubtableLength = sizeof (ACPI_HEST_GENERIC_V2); 1853 break; 1854 1855 case ACPI_HEST_TYPE_IA32_DEFERRED_CHECK: 1856 1857 InfoTable = AcpiDmTableInfoHest11; 1858 SubtableLength = sizeof (ACPI_HEST_IA_DEFERRED_CHECK); 1859 BankCount = (ACPI_CAST_PTR (ACPI_HEST_IA_DEFERRED_CHECK, 1860 Subtable))->NumHardwareBanks; 1861 break; 1862 1863 default: 1864 1865 /* Cannot continue on unknown type - no length */ 1866 1867 AcpiOsPrintf ("\n**** Unknown HEST subtable type 0x%X\n", 1868 Subtable->Type); 1869 return; 1870 } 1871 1872 AcpiOsPrintf ("\n"); 1873 Status = AcpiDmDumpTable (Length, Offset, Subtable, 1874 SubtableLength, InfoTable); 1875 if (ACPI_FAILURE (Status)) 1876 { 1877 return; 1878 } 1879 1880 /* Point to end of current subtable (each subtable above is of fixed length) */ 1881 1882 Offset += SubtableLength; 1883 1884 /* If there are any (fixed-length) Error Banks from above, dump them now */ 1885 1886 if (BankCount) 1887 { 1888 BankTable = ACPI_ADD_PTR (ACPI_HEST_IA_ERROR_BANK, Subtable, 1889 SubtableLength); 1890 SubtableLength += BankCount * sizeof (ACPI_HEST_IA_ERROR_BANK); 1891 1892 while (BankCount) 1893 { 1894 AcpiOsPrintf ("\n"); 1895 Status = AcpiDmDumpTable (Length, Offset, BankTable, 1896 sizeof (ACPI_HEST_IA_ERROR_BANK), AcpiDmTableInfoHestBank); 1897 if (ACPI_FAILURE (Status)) 1898 { 1899 return; 1900 } 1901 1902 Offset += sizeof (ACPI_HEST_IA_ERROR_BANK); 1903 BankTable++; 1904 BankCount--; 1905 } 1906 } 1907 1908 /* Point to next subtable */ 1909 1910 Subtable = ACPI_ADD_PTR (ACPI_HEST_HEADER, Subtable, SubtableLength); 1911 } 1912 } 1913 1914 1915 /******************************************************************************* 1916 * 1917 * FUNCTION: AcpiDmDumpHmat 1918 * 1919 * PARAMETERS: Table - A HMAT table 1920 * 1921 * RETURN: None 1922 * 1923 * DESCRIPTION: Format the contents of a HMAT. 1924 * 1925 ******************************************************************************/ 1926 1927 void 1928 AcpiDmDumpHmat ( 1929 ACPI_TABLE_HEADER *Table) 1930 { 1931 ACPI_STATUS Status; 1932 ACPI_HMAT_STRUCTURE *HmatStruct; 1933 ACPI_HMAT_LOCALITY *HmatLocality; 1934 ACPI_HMAT_CACHE *HmatCache; 1935 UINT32 Offset; 1936 UINT32 SubtableOffset; 1937 UINT32 Length; 1938 ACPI_DMTABLE_INFO *InfoTable; 1939 UINT32 i, j; 1940 1941 1942 /* Main table */ 1943 1944 Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoHmat); 1945 if (ACPI_FAILURE (Status)) 1946 { 1947 return; 1948 } 1949 Offset = sizeof (ACPI_TABLE_HMAT); 1950 1951 while (Offset < Table->Length) 1952 { 1953 AcpiOsPrintf ("\n"); 1954 1955 /* Dump HMAT structure header */ 1956 1957 HmatStruct = ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, Table, Offset); 1958 if (HmatStruct->Length < sizeof (ACPI_HMAT_STRUCTURE)) 1959 { 1960 AcpiOsPrintf ("Invalid HMAT structure length\n"); 1961 return; 1962 } 1963 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 1964 HmatStruct->Length, AcpiDmTableInfoHmatHdr); 1965 if (ACPI_FAILURE (Status)) 1966 { 1967 return; 1968 } 1969 1970 switch (HmatStruct->Type) 1971 { 1972 case ACPI_HMAT_TYPE_ADDRESS_RANGE: 1973 1974 InfoTable = AcpiDmTableInfoHmat0; 1975 Length = sizeof (ACPI_HMAT_PROXIMITY_DOMAIN); 1976 break; 1977 1978 case ACPI_HMAT_TYPE_LOCALITY: 1979 1980 InfoTable = AcpiDmTableInfoHmat1; 1981 Length = sizeof (ACPI_HMAT_LOCALITY); 1982 break; 1983 1984 case ACPI_HMAT_TYPE_CACHE: 1985 1986 InfoTable = AcpiDmTableInfoHmat2; 1987 Length = sizeof (ACPI_HMAT_CACHE); 1988 break; 1989 1990 default: 1991 1992 AcpiOsPrintf ("\n**** Unknown HMAT structure type 0x%X\n", 1993 HmatStruct->Type); 1994 1995 /* Attempt to continue */ 1996 1997 goto NextSubtable; 1998 } 1999 2000 /* Dump HMAT structure body */ 2001 2002 if (HmatStruct->Length < Length) 2003 { 2004 AcpiOsPrintf ("Invalid HMAT structure length\n"); 2005 return; 2006 } 2007 Status = AcpiDmDumpTable (Table->Length, Offset, HmatStruct, 2008 HmatStruct->Length, InfoTable); 2009 if (ACPI_FAILURE (Status)) 2010 { 2011 return; 2012 } 2013 2014 /* Dump HMAT structure additional */ 2015 2016 switch (HmatStruct->Type) 2017 { 2018 case ACPI_HMAT_TYPE_LOCALITY: 2019 2020 HmatLocality = ACPI_CAST_PTR (ACPI_HMAT_LOCALITY, HmatStruct); 2021 SubtableOffset = sizeof (ACPI_HMAT_LOCALITY); 2022 2023 /* Dump initiator proximity domains */ 2024 2025 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2026 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 4)) 2027 { 2028 AcpiOsPrintf ("Invalid initiator proximity domain number\n"); 2029 return; 2030 } 2031 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 2032 { 2033 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2034 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2035 4, AcpiDmTableInfoHmat1a); 2036 if (ACPI_FAILURE (Status)) 2037 { 2038 return; 2039 } 2040 2041 SubtableOffset += 4; 2042 } 2043 2044 /* Dump target proximity domains */ 2045 2046 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2047 (UINT32)(HmatLocality->NumberOfTargetPDs * 4)) 2048 { 2049 AcpiOsPrintf ("Invalid target proximity domain number\n"); 2050 return; 2051 } 2052 for (i = 0; i < HmatLocality->NumberOfTargetPDs; i++) 2053 { 2054 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2055 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2056 4, AcpiDmTableInfoHmat1b); 2057 if (ACPI_FAILURE (Status)) 2058 { 2059 return; 2060 } 2061 2062 SubtableOffset += 4; 2063 } 2064 2065 /* Dump latency/bandwidth entris */ 2066 2067 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2068 (UINT32)(HmatLocality->NumberOfInitiatorPDs * 2069 HmatLocality->NumberOfTargetPDs * 2)) 2070 { 2071 AcpiOsPrintf ("Invalid latency/bandwidth entry number\n"); 2072 return; 2073 } 2074 for (i = 0; i < HmatLocality->NumberOfInitiatorPDs; i++) 2075 { 2076 for (j = 0; j < HmatLocality->NumberOfTargetPDs; j++) 2077 { 2078 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2079 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2080 2, AcpiDmTableInfoHmat1c); 2081 if (ACPI_FAILURE(Status)) 2082 { 2083 return; 2084 } 2085 2086 SubtableOffset += 2; 2087 } 2088 } 2089 break; 2090 2091 case ACPI_HMAT_TYPE_CACHE: 2092 2093 HmatCache = ACPI_CAST_PTR (ACPI_HMAT_CACHE, HmatStruct); 2094 SubtableOffset = sizeof (ACPI_HMAT_CACHE); 2095 2096 /* Dump SMBIOS handles */ 2097 2098 if ((UINT32)(HmatStruct->Length - SubtableOffset) < 2099 (UINT32)(HmatCache->NumberOfSMBIOSHandles * 2)) 2100 { 2101 AcpiOsPrintf ("Invalid SMBIOS handle number\n"); 2102 return; 2103 } 2104 for (i = 0; i < HmatCache->NumberOfSMBIOSHandles; i++) 2105 { 2106 Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset, 2107 ACPI_ADD_PTR (ACPI_HMAT_STRUCTURE, HmatStruct, SubtableOffset), 2108 2, AcpiDmTableInfoHmat2a); 2109 if (ACPI_FAILURE (Status)) 2110 { 2111 return; 2112 } 2113 2114 SubtableOffset += 2; 2115 } 2116 break; 2117 2118 default: 2119 2120 break; 2121 } 2122 2123 NextSubtable: 2124 /* Point to next HMAT structure subtable */ 2125 2126 Offset += (HmatStruct->Length); 2127 } 2128 } 2129
Indexes created Mon Sep 29 21:09:56 GMT 2025