1 /******************************************************************************* 2 * 3 * Module Name: dmresrcl.c - "Large" Resource Descriptor disassembly 4 * $Revision: 1.38 $ 5 * 6 ******************************************************************************/ 7 8 /****************************************************************************** 9 * 10 * 1. Copyright Notice 11 * 12 * Some or all of this work - Copyright (c) 1999 - 2008, Intel Corp. 13 * All rights reserved. 14 * 15 * 2. License 16 * 17 * 2.1. This is your license from Intel Corp. under its intellectual property 18 * rights. You may have additional license terms from the party that provided 19 * you this software, covering your right to use that party's intellectual 20 * property rights. 21 * 22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 23 * copy of the source code appearing in this file ("Covered Code") an 24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 25 * base code distributed originally by Intel ("Original Intel Code") to copy, 26 * make derivatives, distribute, use and display any portion of the Covered 27 * Code in any form, with the right to sublicense such rights; and 28 * 29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 30 * license (with the right to sublicense), under only those claims of Intel 31 * patents that are infringed by the Original Intel Code, to make, use, sell, 32 * offer to sell, and import the Covered Code and derivative works thereof 33 * solely to the minimum extent necessary to exercise the above copyright 34 * license, and in no event shall the patent license extend to any additions 35 * to or modifications of the Original Intel Code. No other license or right 36 * is granted directly or by implication, estoppel or otherwise; 37 * 38 * The above copyright and patent license is granted only if the following 39 * conditions are met: 40 * 41 * 3. Conditions 42 * 43 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 44 * Redistribution of source code of any substantial portion of the Covered 45 * Code or modification with rights to further distribute source must include 46 * the above Copyright Notice, the above License, this list of Conditions, 47 * and the following Disclaimer and Export Compliance provision. In addition, 48 * Licensee must cause all Covered Code to which Licensee contributes to 49 * contain a file documenting the changes Licensee made to create that Covered 50 * Code and the date of any change. Licensee must include in that file the 51 * documentation of any changes made by any predecessor Licensee. Licensee 52 * must include a prominent statement that the modification is derived, 53 * directly or indirectly, from Original Intel Code. 54 * 55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 56 * Redistribution of source code of any substantial portion of the Covered 57 * Code or modification without rights to further distribute source must 58 * include the following Disclaimer and Export Compliance provision in the 59 * documentation and/or other materials provided with distribution. In 60 * addition, Licensee may not authorize further sublicense of source of any 61 * portion of the Covered Code, and must include terms to the effect that the 62 * license from Licensee to its licensee is limited to the intellectual 63 * property embodied in the software Licensee provides to its licensee, and 64 * not to intellectual property embodied in modifications its licensee may 65 * make. 66 * 67 * 3.3. Redistribution of Executable. Redistribution in executable form of any 68 * substantial portion of the Covered Code or modification must reproduce the 69 * above Copyright Notice, and the following Disclaimer and Export Compliance 70 * provision in the documentation and/or other materials provided with the 71 * distribution. 72 * 73 * 3.4. Intel retains all right, title, and interest in and to the Original 74 * Intel Code. 75 * 76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 77 * Intel shall be used in advertising or otherwise to promote the sale, use or 78 * other dealings in products derived from or relating to the Covered Code 79 * without prior written authorization from Intel. 80 * 81 * 4. Disclaimer and Export Compliance 82 * 83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 89 * PARTICULAR PURPOSE. 90 * 91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 98 * LIMITED REMEDY. 99 * 100 * 4.3. Licensee shall not export, either directly or indirectly, any of this 101 * software or system incorporating such software without first obtaining any 102 * required license or other approval from the U. S. Department of Commerce or 103 * any other agency or department of the United States Government. In the 104 * event Licensee exports any such software from the United States or 105 * re-exports any such software from a foreign destination, Licensee shall 106 * ensure that the distribution and export/re-export of the software is in 107 * compliance with all laws, regulations, orders, or other restrictions of the 108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 109 * any of its subsidiaries will export/re-export any technical data, process, 110 * software, or service, directly or indirectly, to any country for which the 111 * United States government or any agency thereof requires an export license, 112 * other governmental approval, or letter of assurance, without first obtaining 113 * such license, approval or letter. 114 * 115 *****************************************************************************/ 116 117 118 #include "acpi.h" 119 #include "acdisasm.h" 120 121 122 #ifdef ACPI_DISASSEMBLER 123 124 #define _COMPONENT ACPI_CA_DEBUGGER 125 ACPI_MODULE_NAME ("dbresrcl") 126 127 128 /* Common names for address and memory descriptors */ 129 130 static char *AcpiDmAddressNames[] = 131 { 132 "Granularity", 133 "Range Minimum", 134 "Range Maximum", 135 "Translation Offset", 136 "Length" 137 }; 138 139 static char *AcpiDmMemoryNames[] = 140 { 141 "Range Minimum", 142 "Range Maximum", 143 "Alignment", 144 "Length" 145 }; 146 147 148 /* Local prototypes */ 149 150 static void 151 AcpiDmSpaceFlags ( 152 UINT8 Flags); 153 154 static void 155 AcpiDmIoFlags ( 156 UINT8 Flags); 157 158 static void 159 AcpiDmIoFlags2 ( 160 UINT8 SpecificFlags); 161 162 static void 163 AcpiDmMemoryFlags ( 164 UINT8 Flags, 165 UINT8 SpecificFlags); 166 167 static void 168 AcpiDmMemoryFlags2 ( 169 UINT8 SpecificFlags); 170 171 static void 172 AcpiDmResourceSource ( 173 AML_RESOURCE *Resource, 174 ACPI_SIZE MinimumLength, 175 UINT32 Length); 176 177 static void 178 AcpiDmAddressFields ( 179 void *Source, 180 UINT8 Type, 181 UINT32 Level); 182 183 static void 184 AcpiDmAddressPrefix ( 185 UINT8 Type); 186 187 static void 188 AcpiDmAddressCommon ( 189 AML_RESOURCE *Resource, 190 UINT8 Type, 191 UINT32 Level); 192 193 static void 194 AcpiDmAddressFlags ( 195 AML_RESOURCE *Resource); 196 197 198 /******************************************************************************* 199 * 200 * FUNCTION: AcpiDmMemoryFields 201 * 202 * PARAMETERS: Source - Pointer to the contiguous data fields 203 * Type - 16 or 32 (bit) 204 * Level - Current source code indentation level 205 * 206 * RETURN: None 207 * 208 * DESCRIPTION: Decode fields common to Memory24 and Memory32 descriptors 209 * 210 ******************************************************************************/ 211 212 static void 213 AcpiDmMemoryFields ( 214 void *Source, 215 UINT8 Type, 216 UINT32 Level) 217 { 218 UINT32 i; 219 220 221 for (i = 0; i < 4; i++) 222 { 223 AcpiDmIndent (Level + 1); 224 225 switch (Type) 226 { 227 case 16: 228 AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i], 229 AcpiDmMemoryNames[i]); 230 break; 231 232 case 32: 233 AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i], 234 AcpiDmMemoryNames[i]); 235 break; 236 237 default: 238 return; 239 } 240 } 241 } 242 243 244 /******************************************************************************* 245 * 246 * FUNCTION: AcpiDmAddressFields 247 * 248 * PARAMETERS: Source - Pointer to the contiguous data fields 249 * Type - 16, 32, or 64 (bit) 250 * Level - Current source code indentation level 251 * 252 * RETURN: None 253 * 254 * DESCRIPTION: Decode fields common to address descriptors 255 * 256 ******************************************************************************/ 257 258 static void 259 AcpiDmAddressFields ( 260 void *Source, 261 UINT8 Type, 262 UINT32 Level) 263 { 264 UINT32 i; 265 266 267 AcpiOsPrintf ("\n"); 268 269 for (i = 0; i < 5; i++) 270 { 271 AcpiDmIndent (Level + 1); 272 273 switch (Type) 274 { 275 case 16: 276 AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i], 277 AcpiDmAddressNames[i]); 278 break; 279 280 case 32: 281 AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i], 282 AcpiDmAddressNames[i]); 283 break; 284 285 case 64: 286 AcpiDmDumpInteger64 (ACPI_CAST_PTR (UINT64, Source)[i], 287 AcpiDmAddressNames[i]); 288 break; 289 290 default: 291 return; 292 } 293 } 294 } 295 296 297 /******************************************************************************* 298 * 299 * FUNCTION: AcpiDmAddressPrefix 300 * 301 * PARAMETERS: Type - Descriptor type 302 * 303 * RETURN: None 304 * 305 * DESCRIPTION: Emit name prefix representing the address descriptor type 306 * 307 ******************************************************************************/ 308 309 static void 310 AcpiDmAddressPrefix ( 311 UINT8 Type) 312 { 313 314 switch (Type) 315 { 316 case ACPI_RESOURCE_TYPE_ADDRESS16: 317 AcpiOsPrintf ("Word"); 318 break; 319 320 case ACPI_RESOURCE_TYPE_ADDRESS32: 321 AcpiOsPrintf ("DWord"); 322 break; 323 324 case ACPI_RESOURCE_TYPE_ADDRESS64: 325 AcpiOsPrintf ("QWord"); 326 break; 327 328 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64: 329 AcpiOsPrintf ("Extended"); 330 break; 331 332 default: 333 return; 334 } 335 } 336 337 338 /******************************************************************************* 339 * 340 * FUNCTION: AcpiDmAddressCommon 341 * 342 * PARAMETERS: Resource - Raw AML descriptor 343 * Type - Descriptor type 344 * Level - Current source code indentation level 345 * 346 * RETURN: None 347 * 348 * DESCRIPTION: Emit common name and flag fields common to address descriptors 349 * 350 ******************************************************************************/ 351 352 static void 353 AcpiDmAddressCommon ( 354 AML_RESOURCE *Resource, 355 UINT8 Type, 356 UINT32 Level) 357 { 358 UINT8 ResourceType; 359 UINT8 SpecificFlags; 360 UINT8 Flags; 361 362 363 ResourceType = Resource->Address.ResourceType; 364 SpecificFlags = Resource->Address.SpecificFlags; 365 Flags = Resource->Address.Flags; 366 367 AcpiDmIndent (Level); 368 369 /* Validate ResourceType */ 370 371 if ((ResourceType > 2) && (ResourceType < 0xC0)) 372 { 373 AcpiOsPrintf ("/**** Invalid Resource Type: 0x%X ****/", ResourceType); 374 return; 375 } 376 377 /* Prefix is either Word, DWord, QWord, or Extended */ 378 379 AcpiDmAddressPrefix (Type); 380 381 /* Resource Types above 0xC0 are vendor-defined */ 382 383 if (ResourceType > 2) 384 { 385 AcpiOsPrintf ("Space (0x%2.2X, ", ResourceType); 386 AcpiDmSpaceFlags (Flags); 387 AcpiOsPrintf (" 0x%2.2X,", SpecificFlags); 388 return; 389 } 390 391 /* This is either a Memory, IO, or BusNumber descriptor (0,1,2) */ 392 393 AcpiOsPrintf ("%s (", AcpiGbl_WordDecode [ResourceType & 0x3]); 394 395 /* Decode the general and type-specific flags */ 396 397 if (ResourceType == ACPI_MEMORY_RANGE) 398 { 399 AcpiDmMemoryFlags (Flags, SpecificFlags); 400 } 401 else /* IO range or BusNumberRange */ 402 { 403 AcpiDmIoFlags (Flags); 404 if (ResourceType == ACPI_IO_RANGE) 405 { 406 AcpiOsPrintf (" %s,", AcpiGbl_RngDecode [SpecificFlags & 0x3]); 407 } 408 } 409 } 410 411 412 /******************************************************************************* 413 * 414 * FUNCTION: AcpiDmAddressFlags 415 * 416 * PARAMETERS: Resource - Raw AML descriptor 417 * 418 * RETURN: None 419 * 420 * DESCRIPTION: Emit flags common to address descriptors 421 * 422 ******************************************************************************/ 423 424 static void 425 AcpiDmAddressFlags ( 426 AML_RESOURCE *Resource) 427 { 428 429 if (Resource->Address.ResourceType == ACPI_IO_RANGE) 430 { 431 AcpiDmIoFlags2 (Resource->Address.SpecificFlags); 432 } 433 else if (Resource->Address.ResourceType == ACPI_MEMORY_RANGE) 434 { 435 AcpiDmMemoryFlags2 (Resource->Address.SpecificFlags); 436 } 437 } 438 439 440 /******************************************************************************* 441 * 442 * FUNCTION: AcpiDmSpaceFlags 443 * 444 * PARAMETERS: Flags - Flag byte to be decoded 445 * 446 * RETURN: None 447 * 448 * DESCRIPTION: Decode the flags specific to Space Address space descriptors 449 * 450 ******************************************************************************/ 451 452 static void 453 AcpiDmSpaceFlags ( 454 UINT8 Flags) 455 { 456 457 AcpiOsPrintf ("%s, %s, %s, %s,", 458 AcpiGbl_ConsumeDecode [(Flags & 1)], 459 AcpiGbl_DecDecode [(Flags & 0x2) >> 1], 460 AcpiGbl_MinDecode [(Flags & 0x4) >> 2], 461 AcpiGbl_MaxDecode [(Flags & 0x8) >> 3]); 462 } 463 464 465 /******************************************************************************* 466 * 467 * FUNCTION: AcpiDmIoFlags 468 * 469 * PARAMETERS: Flags - Flag byte to be decoded 470 * 471 * RETURN: None 472 * 473 * DESCRIPTION: Decode the flags specific to IO Address space descriptors 474 * 475 ******************************************************************************/ 476 477 static void 478 AcpiDmIoFlags ( 479 UINT8 Flags) 480 { 481 AcpiOsPrintf ("%s, %s, %s, %s,", 482 AcpiGbl_ConsumeDecode [(Flags & 1)], 483 AcpiGbl_MinDecode [(Flags & 0x4) >> 2], 484 AcpiGbl_MaxDecode [(Flags & 0x8) >> 3], 485 AcpiGbl_DecDecode [(Flags & 0x2) >> 1]); 486 } 487 488 489 /******************************************************************************* 490 * 491 * FUNCTION: AcpiDmIoFlags2 492 * 493 * PARAMETERS: SpecificFlags - "Specific" flag byte to be decoded 494 * 495 * RETURN: None 496 * 497 * DESCRIPTION: Decode the flags specific to IO Address space descriptors 498 * 499 ******************************************************************************/ 500 501 static void 502 AcpiDmIoFlags2 ( 503 UINT8 SpecificFlags) 504 { 505 506 AcpiOsPrintf (", %s", 507 AcpiGbl_TtpDecode [(SpecificFlags & 0x10) >> 4]); 508 509 /* TRS is only used if TTP is TypeTranslation */ 510 511 if (SpecificFlags & 0x10) 512 { 513 AcpiOsPrintf (", %s", 514 AcpiGbl_TrsDecode [(SpecificFlags & 0x20) >> 5]); 515 } 516 } 517 518 519 /******************************************************************************* 520 * 521 * FUNCTION: AcpiDmMemoryFlags 522 * 523 * PARAMETERS: Flags - Flag byte to be decoded 524 * SpecificFlags - "Specific" flag byte to be decoded 525 * 526 * RETURN: None 527 * 528 * DESCRIPTION: Decode flags specific to Memory Address Space descriptors 529 * 530 ******************************************************************************/ 531 532 static void 533 AcpiDmMemoryFlags ( 534 UINT8 Flags, 535 UINT8 SpecificFlags) 536 { 537 538 AcpiOsPrintf ("%s, %s, %s, %s, %s, %s,", 539 AcpiGbl_ConsumeDecode [(Flags & 1)], 540 AcpiGbl_DecDecode [(Flags & 0x2) >> 1], 541 AcpiGbl_MinDecode [(Flags & 0x4) >> 2], 542 AcpiGbl_MaxDecode [(Flags & 0x8) >> 3], 543 AcpiGbl_MemDecode [(SpecificFlags & 0x6) >> 1], 544 AcpiGbl_RwDecode [(SpecificFlags & 0x1)]); 545 } 546 547 548 /******************************************************************************* 549 * 550 * FUNCTION: AcpiDmMemoryFlags2 551 * 552 * PARAMETERS: SpecificFlags - "Specific" flag byte to be decoded 553 * 554 * RETURN: None 555 * 556 * DESCRIPTION: Decode flags specific to Memory Address Space descriptors 557 * 558 ******************************************************************************/ 559 560 static void 561 AcpiDmMemoryFlags2 ( 562 UINT8 SpecificFlags) 563 { 564 565 AcpiOsPrintf (", %s, %s", 566 AcpiGbl_MtpDecode [(SpecificFlags & 0x18) >> 3], 567 AcpiGbl_TtpDecode [(SpecificFlags & 0x20) >> 5]); 568 } 569 570 571 /******************************************************************************* 572 * 573 * FUNCTION: AcpiDmResourceSource 574 * 575 * PARAMETERS: Resource - Raw AML descriptor 576 * MinimumLength - descriptor length without optional fields 577 * ResourceLength 578 * 579 * RETURN: None 580 * 581 * DESCRIPTION: Dump optional ResourceSource fields of an address descriptor 582 * 583 ******************************************************************************/ 584 585 static void 586 AcpiDmResourceSource ( 587 AML_RESOURCE *Resource, 588 ACPI_SIZE MinimumTotalLength, 589 UINT32 ResourceLength) 590 { 591 UINT8 *AmlResourceSource; 592 UINT32 TotalLength; 593 594 595 TotalLength = ResourceLength + sizeof (AML_RESOURCE_LARGE_HEADER); 596 597 /* Check if the optional ResourceSource fields are present */ 598 599 if (TotalLength <= MinimumTotalLength) 600 { 601 /* The two optional fields are not used */ 602 603 AcpiOsPrintf (",, "); 604 return; 605 } 606 607 /* Get a pointer to the ResourceSource */ 608 609 AmlResourceSource = ACPI_ADD_PTR (UINT8, Resource, MinimumTotalLength); 610 611 /* 612 * Always emit the ResourceSourceIndex (Byte) 613 * 614 * NOTE: Some ASL compilers always create a 0 byte (in the AML) for the 615 * Index even if the String does not exist. Although this is in violation 616 * of the ACPI specification, it is very important to emit ASL code that 617 * can be compiled back to the identical AML. There may be fields and/or 618 * indexes into the resource template buffer that are compiled to absolute 619 * offsets, and these will be broken if the AML length is changed. 620 */ 621 AcpiOsPrintf ("0x%2.2X,", (UINT32) AmlResourceSource[0]); 622 623 /* Make sure that the ResourceSource string exists before dumping it */ 624 625 if (TotalLength > (MinimumTotalLength + 1)) 626 { 627 AcpiOsPrintf (" "); 628 AcpiUtPrintString ((char *) &AmlResourceSource[1], ACPI_UINT8_MAX); 629 } 630 631 AcpiOsPrintf (", "); 632 } 633 634 635 /******************************************************************************* 636 * 637 * FUNCTION: AcpiDmWordDescriptor 638 * 639 * PARAMETERS: Resource - Pointer to the resource descriptor 640 * Length - Length of the descriptor in bytes 641 * Level - Current source code indentation level 642 * 643 * RETURN: None 644 * 645 * DESCRIPTION: Decode a Word Address Space descriptor 646 * 647 ******************************************************************************/ 648 649 void 650 AcpiDmWordDescriptor ( 651 AML_RESOURCE *Resource, 652 UINT32 Length, 653 UINT32 Level) 654 { 655 656 /* Dump resource name and flags */ 657 658 AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS16, Level); 659 660 /* Dump the 5 contiguous WORD values */ 661 662 AcpiDmAddressFields (&Resource->Address16.Granularity, 16, Level); 663 664 /* The ResourceSource fields are optional */ 665 666 AcpiDmIndent (Level + 1); 667 AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS16), Length); 668 669 /* Insert a descriptor name */ 670 671 AcpiDmDescriptorName (); 672 673 /* Type-specific flags */ 674 675 AcpiDmAddressFlags (Resource); 676 AcpiOsPrintf (")\n"); 677 } 678 679 680 /******************************************************************************* 681 * 682 * FUNCTION: AcpiDmDwordDescriptor 683 * 684 * PARAMETERS: Resource - Pointer to the resource descriptor 685 * Length - Length of the descriptor in bytes 686 * Level - Current source code indentation level 687 * 688 * RETURN: None 689 * 690 * DESCRIPTION: Decode a DWord Address Space descriptor 691 * 692 ******************************************************************************/ 693 694 void 695 AcpiDmDwordDescriptor ( 696 AML_RESOURCE *Resource, 697 UINT32 Length, 698 UINT32 Level) 699 { 700 701 /* Dump resource name and flags */ 702 703 AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS32, Level); 704 705 /* Dump the 5 contiguous DWORD values */ 706 707 AcpiDmAddressFields (&Resource->Address32.Granularity, 32, Level); 708 709 /* The ResourceSource fields are optional */ 710 711 AcpiDmIndent (Level + 1); 712 AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS32), Length); 713 714 /* Insert a descriptor name */ 715 716 AcpiDmDescriptorName (); 717 718 /* Type-specific flags */ 719 720 AcpiDmAddressFlags (Resource); 721 AcpiOsPrintf (")\n"); 722 } 723 724 725 /******************************************************************************* 726 * 727 * FUNCTION: AcpiDmQwordDescriptor 728 * 729 * PARAMETERS: Resource - Pointer to the resource descriptor 730 * Length - Length of the descriptor in bytes 731 * Level - Current source code indentation level 732 * 733 * RETURN: None 734 * 735 * DESCRIPTION: Decode a QWord Address Space descriptor 736 * 737 ******************************************************************************/ 738 739 void 740 AcpiDmQwordDescriptor ( 741 AML_RESOURCE *Resource, 742 UINT32 Length, 743 UINT32 Level) 744 { 745 746 /* Dump resource name and flags */ 747 748 AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS64, Level); 749 750 /* Dump the 5 contiguous QWORD values */ 751 752 AcpiDmAddressFields (&Resource->Address64.Granularity, 64, Level); 753 754 /* The ResourceSource fields are optional */ 755 756 AcpiDmIndent (Level + 1); 757 AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS64), Length); 758 759 /* Insert a descriptor name */ 760 761 AcpiDmDescriptorName (); 762 763 /* Type-specific flags */ 764 765 AcpiDmAddressFlags (Resource); 766 AcpiOsPrintf (")\n"); 767 } 768 769 770 /******************************************************************************* 771 * 772 * FUNCTION: AcpiDmExtendedDescriptor 773 * 774 * PARAMETERS: Resource - Pointer to the resource descriptor 775 * Length - Length of the descriptor in bytes 776 * Level - Current source code indentation level 777 * 778 * RETURN: None 779 * 780 * DESCRIPTION: Decode a Extended Address Space descriptor 781 * 782 ******************************************************************************/ 783 784 void 785 AcpiDmExtendedDescriptor ( 786 AML_RESOURCE *Resource, 787 UINT32 Length, 788 UINT32 Level) 789 { 790 791 /* Dump resource name and flags */ 792 793 AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64, Level); 794 795 /* Dump the 5 contiguous QWORD values */ 796 797 AcpiDmAddressFields (&Resource->ExtAddress64.Granularity, 64, Level); 798 799 /* Extra field for this descriptor only */ 800 801 AcpiDmIndent (Level + 1); 802 AcpiDmDumpInteger64 (Resource->ExtAddress64.TypeSpecific, 803 "Type-Specific Attributes"); 804 805 /* Insert a descriptor name */ 806 807 AcpiDmIndent (Level + 1); 808 AcpiDmDescriptorName (); 809 810 /* Type-specific flags */ 811 812 AcpiDmAddressFlags (Resource); 813 AcpiOsPrintf (")\n"); 814 } 815 816 817 /******************************************************************************* 818 * 819 * FUNCTION: AcpiDmMemory24Descriptor 820 * 821 * PARAMETERS: Resource - Pointer to the resource descriptor 822 * Length - Length of the descriptor in bytes 823 * Level - Current source code indentation level 824 * 825 * RETURN: None 826 * 827 * DESCRIPTION: Decode a Memory24 descriptor 828 * 829 ******************************************************************************/ 830 831 void 832 AcpiDmMemory24Descriptor ( 833 AML_RESOURCE *Resource, 834 UINT32 Length, 835 UINT32 Level) 836 { 837 838 /* Dump name and read/write flag */ 839 840 AcpiDmIndent (Level); 841 AcpiOsPrintf ("Memory24 (%s,\n", 842 AcpiGbl_RwDecode [Resource->Memory24.Flags & 1]); 843 844 /* Dump the 4 contiguous WORD values */ 845 846 AcpiDmMemoryFields (&Resource->Memory24.Minimum, 16, Level); 847 848 /* Insert a descriptor name */ 849 850 AcpiDmIndent (Level + 1); 851 AcpiDmDescriptorName (); 852 AcpiOsPrintf (")\n"); 853 } 854 855 856 /******************************************************************************* 857 * 858 * FUNCTION: AcpiDmMemory32Descriptor 859 * 860 * PARAMETERS: Resource - Pointer to the resource descriptor 861 * Length - Length of the descriptor in bytes 862 * Level - Current source code indentation level 863 * 864 * RETURN: None 865 * 866 * DESCRIPTION: Decode a Memory32 descriptor 867 * 868 ******************************************************************************/ 869 870 void 871 AcpiDmMemory32Descriptor ( 872 AML_RESOURCE *Resource, 873 UINT32 Length, 874 UINT32 Level) 875 { 876 877 /* Dump name and read/write flag */ 878 879 AcpiDmIndent (Level); 880 AcpiOsPrintf ("Memory32 (%s,\n", 881 AcpiGbl_RwDecode [Resource->Memory32.Flags & 1]); 882 883 /* Dump the 4 contiguous DWORD values */ 884 885 AcpiDmMemoryFields (&Resource->Memory32.Minimum, 32, Level); 886 887 /* Insert a descriptor name */ 888 889 AcpiDmIndent (Level + 1); 890 AcpiDmDescriptorName (); 891 AcpiOsPrintf (")\n"); 892 } 893 894 895 /******************************************************************************* 896 * 897 * FUNCTION: AcpiDmFixedMemory32Descriptor 898 * 899 * PARAMETERS: Resource - Pointer to the resource descriptor 900 * Length - Length of the descriptor in bytes 901 * Level - Current source code indentation level 902 * 903 * RETURN: None 904 * 905 * DESCRIPTION: Decode a Fixed Memory32 descriptor 906 * 907 ******************************************************************************/ 908 909 void 910 AcpiDmFixedMemory32Descriptor ( 911 AML_RESOURCE *Resource, 912 UINT32 Length, 913 UINT32 Level) 914 { 915 916 /* Dump name and read/write flag */ 917 918 AcpiDmIndent (Level); 919 AcpiOsPrintf ("Memory32Fixed (%s,\n", 920 AcpiGbl_RwDecode [Resource->FixedMemory32.Flags & 1]); 921 922 AcpiDmIndent (Level + 1); 923 AcpiDmDumpInteger32 (Resource->FixedMemory32.Address, "Address Base"); 924 925 AcpiDmIndent (Level + 1); 926 AcpiDmDumpInteger32 (Resource->FixedMemory32.AddressLength, "Address Length"); 927 928 /* Insert a descriptor name */ 929 930 AcpiDmIndent (Level + 1); 931 AcpiDmDescriptorName (); 932 AcpiOsPrintf (")\n"); 933 } 934 935 936 /******************************************************************************* 937 * 938 * FUNCTION: AcpiDmGenericRegisterDescriptor 939 * 940 * PARAMETERS: Resource - Pointer to the resource descriptor 941 * Length - Length of the descriptor in bytes 942 * Level - Current source code indentation level 943 * 944 * RETURN: None 945 * 946 * DESCRIPTION: Decode a Generic Register descriptor 947 * 948 ******************************************************************************/ 949 950 void 951 AcpiDmGenericRegisterDescriptor ( 952 AML_RESOURCE *Resource, 953 UINT32 Length, 954 UINT32 Level) 955 { 956 957 AcpiDmIndent (Level); 958 AcpiOsPrintf ("Register ("); 959 AcpiDmAddressSpace (Resource->GenericReg.AddressSpaceId); 960 AcpiOsPrintf ("\n"); 961 962 AcpiDmIndent (Level + 1); 963 AcpiDmDumpInteger8 (Resource->GenericReg.BitWidth, "Bit Width"); 964 965 AcpiDmIndent (Level + 1); 966 AcpiDmDumpInteger8 (Resource->GenericReg.BitOffset, "Bit Offset"); 967 968 AcpiDmIndent (Level + 1); 969 AcpiDmDumpInteger64 (Resource->GenericReg.Address, "Address"); 970 971 /* Optional field for ACPI 3.0 */ 972 973 AcpiDmIndent (Level + 1); 974 if (Resource->GenericReg.AccessSize) 975 { 976 AcpiOsPrintf ("0x%2.2X, // %s\n", 977 Resource->GenericReg.AccessSize, "Access Size"); 978 AcpiDmIndent (Level + 1); 979 } 980 else 981 { 982 AcpiOsPrintf (","); 983 } 984 985 /* DescriptorName was added for ACPI 3.0+ */ 986 987 AcpiDmDescriptorName (); 988 AcpiOsPrintf (")\n"); 989 } 990 991 992 /******************************************************************************* 993 * 994 * FUNCTION: AcpiDmInterruptDescriptor 995 * 996 * PARAMETERS: Resource - Pointer to the resource descriptor 997 * Length - Length of the descriptor in bytes 998 * Level - Current source code indentation level 999 * 1000 * RETURN: None 1001 * 1002 * DESCRIPTION: Decode a extended Interrupt descriptor 1003 * 1004 ******************************************************************************/ 1005 1006 void 1007 AcpiDmInterruptDescriptor ( 1008 AML_RESOURCE *Resource, 1009 UINT32 Length, 1010 UINT32 Level) 1011 { 1012 UINT32 i; 1013 1014 1015 AcpiDmIndent (Level); 1016 AcpiOsPrintf ("Interrupt (%s, %s, %s, %s, ", 1017 AcpiGbl_ConsumeDecode [(Resource->ExtendedIrq.Flags & 1)], 1018 AcpiGbl_HeDecode [(Resource->ExtendedIrq.Flags >> 1) & 1], 1019 AcpiGbl_LlDecode [(Resource->ExtendedIrq.Flags >> 2) & 1], 1020 AcpiGbl_ShrDecode [(Resource->ExtendedIrq.Flags >> 3) & 1]); 1021 1022 /* 1023 * The ResourceSource fields are optional and appear after the interrupt 1024 * list. Must compute length based on length of the list. First xrupt 1025 * is included in the struct (reason for -1 below) 1026 */ 1027 AcpiDmResourceSource (Resource, 1028 sizeof (AML_RESOURCE_EXTENDED_IRQ) + 1029 (Resource->ExtendedIrq.InterruptCount - 1) * sizeof (UINT32), 1030 Resource->ExtendedIrq.ResourceLength); 1031 1032 /* Insert a descriptor name */ 1033 1034 AcpiDmDescriptorName (); 1035 AcpiOsPrintf (")\n"); 1036 1037 /* Dump the interrupt list */ 1038 1039 AcpiDmIndent (Level); 1040 AcpiOsPrintf ("{\n"); 1041 for (i = 0; i < Resource->ExtendedIrq.InterruptCount; i++) 1042 { 1043 AcpiDmIndent (Level + 1); 1044 AcpiOsPrintf ("0x%8.8X,\n", 1045 (UINT32) Resource->ExtendedIrq.Interrupts[i]); 1046 } 1047 1048 AcpiDmIndent (Level); 1049 AcpiOsPrintf ("}\n"); 1050 } 1051 1052 1053 /******************************************************************************* 1054 * 1055 * FUNCTION: AcpiDmVendorCommon 1056 * 1057 * PARAMETERS: Name - Descriptor name suffix 1058 * ByteData - Pointer to the vendor byte data 1059 * Length - Length of the byte data 1060 * Level - Current source code indentation level 1061 * 1062 * RETURN: None 1063 * 1064 * DESCRIPTION: Decode a Vendor descriptor, both Large and Small 1065 * 1066 ******************************************************************************/ 1067 1068 void 1069 AcpiDmVendorCommon ( 1070 char *Name, 1071 UINT8 *ByteData, 1072 UINT32 Length, 1073 UINT32 Level) 1074 { 1075 1076 /* Dump macro name */ 1077 1078 AcpiDmIndent (Level); 1079 AcpiOsPrintf ("Vendor%s (", Name); 1080 1081 /* Insert a descriptor name */ 1082 1083 AcpiDmDescriptorName (); 1084 AcpiOsPrintf (") // Length = 0x%.2X\n", Length); 1085 1086 /* Dump the vendor bytes */ 1087 1088 AcpiDmIndent (Level); 1089 AcpiOsPrintf ("{\n"); 1090 1091 AcpiDmDisasmByteList (Level + 1, ByteData, Length); 1092 1093 AcpiDmIndent (Level); 1094 AcpiOsPrintf ("}\n"); 1095 } 1096 1097 1098 /******************************************************************************* 1099 * 1100 * FUNCTION: AcpiDmVendorLargeDescriptor 1101 * 1102 * PARAMETERS: Resource - Pointer to the resource descriptor 1103 * Length - Length of the descriptor in bytes 1104 * Level - Current source code indentation level 1105 * 1106 * RETURN: None 1107 * 1108 * DESCRIPTION: Decode a Vendor Large descriptor 1109 * 1110 ******************************************************************************/ 1111 1112 void 1113 AcpiDmVendorLargeDescriptor ( 1114 AML_RESOURCE *Resource, 1115 UINT32 Length, 1116 UINT32 Level) 1117 { 1118 1119 AcpiDmVendorCommon ("Long ", 1120 ACPI_ADD_PTR (UINT8, Resource, sizeof (AML_RESOURCE_LARGE_HEADER)), 1121 Length, Level); 1122 } 1123 1124 #endif 1125 1126