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