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

   1 /*******************************************************************************
   2  *
   3  * Module Name: dmresrcl.c - "Large" Resource Descriptor disassembly
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2016, 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 const char           *AcpiDmAddressNames[] =
  58 {
  59     "Granularity",
  60     "Range Minimum",
  61     "Range Maximum",
  62     "Translation Offset",
  63     "Length"
  64 };
  65
  66 static const 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     /* _TTP */
 449
 450     AcpiOsPrintf (", %s",
 451         AcpiGbl_TtpDecode [ACPI_EXTRACT_1BIT_FLAG (SpecificFlags, 4)]);
 452
 453     /*
 454      * TRS is only used if TTP is TypeTranslation. However, the disassembler
 455      * always emits exactly what is in the AML.
 456      */
 457     AcpiOsPrintf (", %s",
 458         AcpiGbl_TrsDecode [ACPI_EXTRACT_1BIT_FLAG (SpecificFlags, 5)]);
 459 }
 460
 461
 462 /*******************************************************************************
 463  *
 464  * FUNCTION:    AcpiDmMemoryFlags
 465  *
 466  * PARAMETERS:  Flags               - Flag byte to be decoded
 467  *              SpecificFlags       - "Specific" flag byte to be decoded
 468  *
 469  * RETURN:      None
 470  *
 471  * DESCRIPTION: Decode flags specific to Memory Address Space descriptors
 472  *
 473  ******************************************************************************/
 474
 475 static void
 476 AcpiDmMemoryFlags (
 477     UINT8                   Flags,
 478     UINT8                   SpecificFlags)
 479 {
 480
 481     AcpiOsPrintf ("%s, %s, %s, %s, %s, %s,",
 482         AcpiGbl_ConsumeDecode [ACPI_GET_1BIT_FLAG (Flags)],
 483         AcpiGbl_DecDecode [ACPI_EXTRACT_1BIT_FLAG (Flags, 1)],
 484         AcpiGbl_MinDecode [ACPI_EXTRACT_1BIT_FLAG (Flags, 2)],
 485         AcpiGbl_MaxDecode [ACPI_EXTRACT_1BIT_FLAG (Flags, 3)],
 486         AcpiGbl_MemDecode [ACPI_EXTRACT_2BIT_FLAG (SpecificFlags, 1)],
 487         AcpiGbl_RwDecode [ACPI_GET_1BIT_FLAG (SpecificFlags)]);
 488 }
 489
 490
 491 /*******************************************************************************
 492  *
 493  * FUNCTION:    AcpiDmMemoryFlags2
 494  *
 495  * PARAMETERS:  SpecificFlags       - "Specific" flag byte to be decoded
 496  *
 497  * RETURN:      None
 498  *
 499  * DESCRIPTION: Decode flags specific to Memory Address Space descriptors
 500  *
 501  ******************************************************************************/
 502
 503 static void
 504 AcpiDmMemoryFlags2 (
 505     UINT8                   SpecificFlags)
 506 {
 507
 508     AcpiOsPrintf (", %s, %s",
 509         AcpiGbl_MtpDecode [ACPI_EXTRACT_2BIT_FLAG (SpecificFlags, 3)],
 510         AcpiGbl_TtpDecode [ACPI_EXTRACT_1BIT_FLAG (SpecificFlags, 5)]);
 511 }
 512
 513
 514 /*******************************************************************************
 515  *
 516  * FUNCTION:    AcpiDmResourceSource
 517  *
 518  * PARAMETERS:  Resource        - Raw AML descriptor
 519  *              MinimumLength   - descriptor length without optional fields
 520  *              ResourceLength
 521  *
 522  * RETURN:      None
 523  *
 524  * DESCRIPTION: Dump optional ResourceSource fields of an address descriptor
 525  *
 526  ******************************************************************************/
 527
 528 static void
 529 AcpiDmResourceSource (
 530     AML_RESOURCE            *Resource,
 531     ACPI_SIZE               MinimumTotalLength,
 532     UINT32                  ResourceLength)
 533 {
 534     UINT8                   *AmlResourceSource;
 535     UINT32                  TotalLength;
 536
 537
 538     TotalLength = ResourceLength + sizeof (AML_RESOURCE_LARGE_HEADER);
 539
 540     /* Check if the optional ResourceSource fields are present */
 541
 542     if (TotalLength <= MinimumTotalLength)
 543     {
 544         /* The two optional fields are not used */
 545
 546         AcpiOsPrintf (",, ");
 547         return;
 548     }
 549
 550     /* Get a pointer to the ResourceSource */
 551
 552     AmlResourceSource = ACPI_ADD_PTR (UINT8, Resource, MinimumTotalLength);
 553
 554     /*
 555      * Always emit the ResourceSourceIndex (Byte)
 556      *
 557      * NOTE: Some ASL compilers always create a 0 byte (in the AML) for the
 558      * Index even if the String does not exist. Although this is in violation
 559      * of the ACPI specification, it is very important to emit ASL code that
 560      * can be compiled back to the identical AML. There may be fields and/or
 561      * indexes into the resource template buffer that are compiled to absolute
 562      * offsets, and these will be broken if the AML length is changed.
 563      */
 564     AcpiOsPrintf ("0x%2.2X,", (UINT32) AmlResourceSource[0]);
 565
 566     /* Make sure that the ResourceSource string exists before dumping it */
 567
 568     if (TotalLength > (MinimumTotalLength + 1))
 569     {
 570         AcpiOsPrintf (" ");
 571         AcpiUtPrintString ((char *) &AmlResourceSource[1], ACPI_UINT16_MAX);
 572     }
 573
 574     AcpiOsPrintf (", ");
 575 }
 576
 577
 578 /*******************************************************************************
 579  *
 580  * FUNCTION:    AcpiDmWordDescriptor
 581  *
 582  * PARAMETERS:  Info                - Extra resource info
 583  *              Resource            - Pointer to the resource descriptor
 584  *              Length              - Length of the descriptor in bytes
 585  *              Level               - Current source code indentation level
 586  *
 587  * RETURN:      None
 588  *
 589  * DESCRIPTION: Decode a Word Address Space descriptor
 590  *
 591  ******************************************************************************/
 592
 593 void
 594 AcpiDmWordDescriptor (
 595     ACPI_OP_WALK_INFO       *Info,
 596     AML_RESOURCE            *Resource,
 597     UINT32                  Length,
 598     UINT32                  Level)
 599 {
 600
 601     /* Dump resource name and flags */
 602
 603     AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS16, Level);
 604
 605     /* Dump the 5 contiguous WORD values */
 606
 607     AcpiDmAddressFields (&Resource->Address16.Granularity, 16, Level);
 608
 609     /* The ResourceSource fields are optional */
 610
 611     AcpiDmIndent (Level + 1);
 612     AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS16), Length);
 613
 614     /* Insert a descriptor name */
 615
 616     AcpiDmDescriptorName ();
 617
 618     /* Type-specific flags */
 619
 620     AcpiDmAddressFlags (Resource);
 621     AcpiOsPrintf (")\n");
 622 }
 623
 624
 625 /*******************************************************************************
 626  *
 627  * FUNCTION:    AcpiDmDwordDescriptor
 628  *
 629  * PARAMETERS:  Info                - Extra resource info
 630  *              Resource            - Pointer to the resource descriptor
 631  *              Length              - Length of the descriptor in bytes
 632  *              Level               - Current source code indentation level
 633  *
 634  * RETURN:      None
 635  *
 636  * DESCRIPTION: Decode a DWord Address Space descriptor
 637  *
 638  ******************************************************************************/
 639
 640 void
 641 AcpiDmDwordDescriptor (
 642     ACPI_OP_WALK_INFO       *Info,
 643     AML_RESOURCE            *Resource,
 644     UINT32                  Length,
 645     UINT32                  Level)
 646 {
 647
 648     /* Dump resource name and flags */
 649
 650     AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS32, Level);
 651
 652     /* Dump the 5 contiguous DWORD values */
 653
 654     AcpiDmAddressFields (&Resource->Address32.Granularity, 32, Level);
 655
 656     /* The ResourceSource fields are optional */
 657
 658     AcpiDmIndent (Level + 1);
 659     AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS32), Length);
 660
 661     /* Insert a descriptor name */
 662
 663     AcpiDmDescriptorName ();
 664
 665     /* Type-specific flags */
 666
 667     AcpiDmAddressFlags (Resource);
 668     AcpiOsPrintf (")\n");
 669 }
 670
 671
 672 /*******************************************************************************
 673  *
 674  * FUNCTION:    AcpiDmQwordDescriptor
 675  *
 676  * PARAMETERS:  Info                - Extra resource info
 677  *              Resource            - Pointer to the resource descriptor
 678  *              Length              - Length of the descriptor in bytes
 679  *              Level               - Current source code indentation level
 680  *
 681  * RETURN:      None
 682  *
 683  * DESCRIPTION: Decode a QWord Address Space descriptor
 684  *
 685  ******************************************************************************/
 686
 687 void
 688 AcpiDmQwordDescriptor (
 689     ACPI_OP_WALK_INFO       *Info,
 690     AML_RESOURCE            *Resource,
 691     UINT32                  Length,
 692     UINT32                  Level)
 693 {
 694
 695     /* Dump resource name and flags */
 696
 697     AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS64, Level);
 698
 699     /* Dump the 5 contiguous QWORD values */
 700
 701     AcpiDmAddressFields (&Resource->Address64.Granularity, 64, Level);
 702
 703     /* The ResourceSource fields are optional */
 704
 705     AcpiDmIndent (Level + 1);
 706     AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS64), Length);
 707
 708     /* Insert a descriptor name */
 709
 710     AcpiDmDescriptorName ();
 711
 712     /* Type-specific flags */
 713
 714     AcpiDmAddressFlags (Resource);
 715     AcpiOsPrintf (")\n");
 716 }
 717
 718
 719 /*******************************************************************************
 720  *
 721  * FUNCTION:    AcpiDmExtendedDescriptor
 722  *
 723  * PARAMETERS:  Info                - Extra resource info
 724  *              Resource            - Pointer to the resource descriptor
 725  *              Length              - Length of the descriptor in bytes
 726  *              Level               - Current source code indentation level
 727  *
 728  * RETURN:      None
 729  *
 730  * DESCRIPTION: Decode a Extended Address Space descriptor
 731  *
 732  ******************************************************************************/
 733
 734 void
 735 AcpiDmExtendedDescriptor (
 736     ACPI_OP_WALK_INFO       *Info,
 737     AML_RESOURCE            *Resource,
 738     UINT32                  Length,
 739     UINT32                  Level)
 740 {
 741
 742     /* Dump resource name and flags */
 743
 744     AcpiDmAddressCommon (
 745         Resource, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64, Level);
 746
 747     /* Dump the 5 contiguous QWORD values */
 748
 749     AcpiDmAddressFields (&Resource->ExtAddress64.Granularity, 64, Level);
 750
 751     /* Extra field for this descriptor only */
 752
 753     AcpiDmIndent (Level + 1);
 754     AcpiDmDumpInteger64 (Resource->ExtAddress64.TypeSpecific,
 755         "Type-Specific Attributes");
 756
 757     /* Insert a descriptor name */
 758
 759     AcpiDmIndent (Level + 1);
 760     AcpiDmDescriptorName ();
 761
 762     /* Type-specific flags */
 763
 764     AcpiDmAddressFlags (Resource);
 765     AcpiOsPrintf (")\n");
 766 }
 767
 768
 769 /*******************************************************************************
 770  *
 771  * FUNCTION:    AcpiDmMemory24Descriptor
 772  *
 773  * PARAMETERS:  Info                - Extra resource info
 774  *              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 Memory24 descriptor
 781  *
 782  ******************************************************************************/
 783
 784 void
 785 AcpiDmMemory24Descriptor (
 786     ACPI_OP_WALK_INFO       *Info,
 787     AML_RESOURCE            *Resource,
 788     UINT32                  Length,
 789     UINT32                  Level)
 790 {
 791
 792     /* Dump name and read/write flag */
 793
 794     AcpiDmIndent (Level);
 795     AcpiOsPrintf ("Memory24 (%s,\n",
 796         AcpiGbl_RwDecode [ACPI_GET_1BIT_FLAG (Resource->Memory24.Flags)]);
 797
 798     /* Dump the 4 contiguous WORD values */
 799
 800     AcpiDmMemoryFields (&Resource->Memory24.Minimum, 16, Level);
 801
 802     /* Insert a descriptor name */
 803
 804     AcpiDmIndent (Level + 1);
 805     AcpiDmDescriptorName ();
 806     AcpiOsPrintf (")\n");
 807 }
 808
 809
 810 /*******************************************************************************
 811  *
 812  * FUNCTION:    AcpiDmMemory32Descriptor
 813  *
 814  * PARAMETERS:  Info                - Extra resource info
 815  *              Resource            - Pointer to the resource descriptor
 816  *              Length              - Length of the descriptor in bytes
 817  *              Level               - Current source code indentation level
 818  *
 819  * RETURN:      None
 820  *
 821  * DESCRIPTION: Decode a Memory32 descriptor
 822  *
 823  ******************************************************************************/
 824
 825 void
 826 AcpiDmMemory32Descriptor (
 827     ACPI_OP_WALK_INFO       *Info,
 828     AML_RESOURCE            *Resource,
 829     UINT32                  Length,
 830     UINT32                  Level)
 831 {
 832
 833     /* Dump name and read/write flag */
 834
 835     AcpiDmIndent (Level);
 836     AcpiOsPrintf ("Memory32 (%s,\n",
 837         AcpiGbl_RwDecode [ACPI_GET_1BIT_FLAG (Resource->Memory32.Flags)]);
 838
 839     /* Dump the 4 contiguous DWORD values */
 840
 841     AcpiDmMemoryFields (&Resource->Memory32.Minimum, 32, Level);
 842
 843     /* Insert a descriptor name */
 844
 845     AcpiDmIndent (Level + 1);
 846     AcpiDmDescriptorName ();
 847     AcpiOsPrintf (")\n");
 848 }
 849
 850
 851 /*******************************************************************************
 852  *
 853  * FUNCTION:    AcpiDmFixedMemory32Descriptor
 854  *
 855  * PARAMETERS:  Info                - Extra resource info
 856  *              Resource            - Pointer to the resource descriptor
 857  *              Length              - Length of the descriptor in bytes
 858  *              Level               - Current source code indentation level
 859  *
 860  * RETURN:      None
 861  *
 862  * DESCRIPTION: Decode a Fixed Memory32 descriptor
 863  *
 864  ******************************************************************************/
 865
 866 void
 867 AcpiDmFixedMemory32Descriptor (
 868     ACPI_OP_WALK_INFO       *Info,
 869     AML_RESOURCE            *Resource,
 870     UINT32                  Length,
 871     UINT32                  Level)
 872 {
 873
 874     /* Dump name and read/write flag */
 875
 876     AcpiDmIndent (Level);
 877     AcpiOsPrintf ("Memory32Fixed (%s,\n",
 878         AcpiGbl_RwDecode [ACPI_GET_1BIT_FLAG (Resource->FixedMemory32.Flags)]);
 879
 880     AcpiDmIndent (Level + 1);
 881     AcpiDmDumpInteger32 (Resource->FixedMemory32.Address,
 882         "Address Base");
 883
 884     AcpiDmIndent (Level + 1);
 885     AcpiDmDumpInteger32 (Resource->FixedMemory32.AddressLength,
 886         "Address Length");
 887
 888     /* Insert a descriptor name */
 889
 890     AcpiDmIndent (Level + 1);
 891     AcpiDmDescriptorName ();
 892     AcpiOsPrintf (")\n");
 893 }
 894
 895
 896 /*******************************************************************************
 897  *
 898  * FUNCTION:    AcpiDmGenericRegisterDescriptor
 899  *
 900  * PARAMETERS:  Info                - Extra resource info
 901  *              Resource            - Pointer to the resource descriptor
 902  *              Length              - Length of the descriptor in bytes
 903  *              Level               - Current source code indentation level
 904  *
 905  * RETURN:      None
 906  *
 907  * DESCRIPTION: Decode a Generic Register descriptor
 908  *
 909  ******************************************************************************/
 910
 911 void
 912 AcpiDmGenericRegisterDescriptor (
 913     ACPI_OP_WALK_INFO       *Info,
 914     AML_RESOURCE            *Resource,
 915     UINT32                  Length,
 916     UINT32                  Level)
 917 {
 918
 919     AcpiDmIndent (Level);
 920     AcpiOsPrintf ("Register (");
 921     AcpiDmAddressSpace (Resource->GenericReg.AddressSpaceId);
 922     AcpiOsPrintf ("\n");
 923
 924     AcpiDmIndent (Level + 1);
 925     AcpiDmDumpInteger8 (Resource->GenericReg.BitWidth, "Bit Width");
 926
 927     AcpiDmIndent (Level + 1);
 928     AcpiDmDumpInteger8 (Resource->GenericReg.BitOffset, "Bit Offset");
 929
 930     AcpiDmIndent (Level + 1);
 931     AcpiDmDumpInteger64 (Resource->GenericReg.Address, "Address");
 932
 933     /* Optional field for ACPI 3.0 */
 934
 935     AcpiDmIndent (Level + 1);
 936     if (Resource->GenericReg.AccessSize)
 937     {
 938         AcpiOsPrintf ("0x%2.2X,               // %s\n",
 939             Resource->GenericReg.AccessSize, "Access Size");
 940         AcpiDmIndent (Level + 1);
 941     }
 942     else
 943     {
 944         AcpiOsPrintf (",");
 945     }
 946
 947     /* DescriptorName was added for ACPI 3.0+ */
 948
 949     AcpiDmDescriptorName ();
 950     AcpiOsPrintf (")\n");
 951 }
 952
 953
 954 /*******************************************************************************
 955  *
 956  * FUNCTION:    AcpiDmInterruptDescriptor
 957  *
 958  * PARAMETERS:  Info                - Extra resource info
 959  *              Resource            - Pointer to the resource descriptor
 960  *              Length              - Length of the descriptor in bytes
 961  *              Level               - Current source code indentation level
 962  *
 963  * RETURN:      None
 964  *
 965  * DESCRIPTION: Decode a extended Interrupt descriptor
 966  *
 967  ******************************************************************************/
 968
 969 void
 970 AcpiDmInterruptDescriptor (
 971     ACPI_OP_WALK_INFO       *Info,
 972     AML_RESOURCE            *Resource,
 973     UINT32                  Length,
 974     UINT32                  Level)
 975 {
 976     UINT32                  i;
 977
 978
 979     AcpiDmIndent (Level);
 980     AcpiOsPrintf ("Interrupt (%s, %s, %s, %s, ",
 981         AcpiGbl_ConsumeDecode [ACPI_GET_1BIT_FLAG (Resource->ExtendedIrq.Flags)],
 982         AcpiGbl_HeDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->ExtendedIrq.Flags, 1)],
 983         AcpiGbl_LlDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->ExtendedIrq.Flags, 2)],
 984         AcpiGbl_ShrDecode [ACPI_EXTRACT_2BIT_FLAG (Resource->ExtendedIrq.Flags, 3)]);
 985
 986     /*
 987      * The ResourceSource fields are optional and appear after the interrupt
 988      * list. Must compute length based on length of the list. First xrupt
 989      * is included in the struct (reason for -1 below)
 990      */
 991     AcpiDmResourceSource (Resource,
 992         sizeof (AML_RESOURCE_EXTENDED_IRQ) +
 993             ((UINT32) Resource->ExtendedIrq.InterruptCount - 1) * sizeof (UINT32),
 994         Resource->ExtendedIrq.ResourceLength);
 995
 996     /* Insert a descriptor name */
 997
 998     AcpiDmDescriptorName ();
 999     AcpiOsPrintf (")\n");
1000
1001     /* Dump the interrupt list */
1002
1003     AcpiDmIndent (Level);
1004     AcpiOsPrintf ("{\n");
1005     for (i = 0; i < Resource->ExtendedIrq.InterruptCount; i++)
1006     {
1007         AcpiDmIndent (Level + 1);
1008         AcpiOsPrintf ("0x%8.8X,\n",
1009             (UINT32) Resource->ExtendedIrq.Interrupts[i]);
1010     }
1011
1012     AcpiDmIndent (Level);
1013     AcpiOsPrintf ("}\n");
1014 }
1015
1016
1017 /*******************************************************************************
1018  *
1019  * FUNCTION:    AcpiDmVendorCommon
1020  *
1021  * PARAMETERS:  Name                - Descriptor name suffix
1022  *              ByteData            - Pointer to the vendor byte data
1023  *              Length              - Length of the byte data
1024  *              Level               - Current source code indentation level
1025  *
1026  * RETURN:      None
1027  *
1028  * DESCRIPTION: Decode a Vendor descriptor, both Large and Small
1029  *
1030  ******************************************************************************/
1031
1032 void
1033 AcpiDmVendorCommon (
1034     const char              *Name,
1035     UINT8                   *ByteData,
1036     UINT32                  Length,
1037     UINT32                  Level)
1038 {
1039
1040     /* Dump macro name */
1041
1042     AcpiDmIndent (Level);
1043     AcpiOsPrintf ("Vendor%s (", Name);
1044
1045     /* Insert a descriptor name */
1046
1047     AcpiDmDescriptorName ();
1048     AcpiOsPrintf (")      // Length = 0x%.2X\n", Length);
1049
1050     /* Dump the vendor bytes */
1051
1052     AcpiDmIndent (Level);
1053     AcpiOsPrintf ("{\n");
1054
1055     AcpiDmDisasmByteList (Level + 1, ByteData, Length);
1056
1057     AcpiDmIndent (Level);
1058     AcpiOsPrintf ("}\n");
1059 }
1060
1061
1062 /*******************************************************************************
1063  *
1064  * FUNCTION:    AcpiDmVendorLargeDescriptor
1065  *
1066  * PARAMETERS:  Info                - Extra resource info
1067  *              Resource            - Pointer to the resource descriptor
1068  *              Length              - Length of the descriptor in bytes
1069  *              Level               - Current source code indentation level
1070  *
1071  * RETURN:      None
1072  *
1073  * DESCRIPTION: Decode a Vendor Large descriptor
1074  *
1075  ******************************************************************************/
1076
1077 void
1078 AcpiDmVendorLargeDescriptor (
1079     ACPI_OP_WALK_INFO       *Info,
1080     AML_RESOURCE            *Resource,
1081     UINT32                  Length,
1082     UINT32                  Level)
1083 {
1084
1085     AcpiDmVendorCommon ("Long ",
1086         ACPI_ADD_PTR (UINT8, Resource, sizeof (AML_RESOURCE_LARGE_HEADER)),
1087         Length, Level);
1088 }
1089
1090 #endif