sys/contrib/dev/acpica/disassembler/dmresrcl.c

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