WebSVN – Kolibri OS – Diff – /drivers/devman/acpica/disassembler/dmresrcl.c


/*******************************************************************************
 *
 * Module Name: dmresrcl.c - "Large" Resource Descriptor disassembly
 *
 ******************************************************************************/
 
/******************************************************************************
 *
 * 1. Copyright Notice
 *
 * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
 * All rights reserved.
 *
 * 2. License
 *
 * 2.1. This is your license from Intel Corp. under its intellectual property
 * rights.  You may have additional license terms from the party that provided
 * you this software, covering your right to use that party's intellectual
 * property rights.
 *
 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
 * copy of the source code appearing in this file ("Covered Code") an
 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
 * base code distributed originally by Intel ("Original Intel Code") to copy,
 * make derivatives, distribute, use and display any portion of the Covered
 * Code in any form, with the right to sublicense such rights; and
 *
 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
 * license (with the right to sublicense), under only those claims of Intel
 * patents that are infringed by the Original Intel Code, to make, use, sell,
 * offer to sell, and import the Covered Code and derivative works thereof
 * solely to the minimum extent necessary to exercise the above copyright
 * license, and in no event shall the patent license extend to any additions
 * to or modifications of the Original Intel Code.  No other license or right
 * is granted directly or by implication, estoppel or otherwise;
 *
 * The above copyright and patent license is granted only if the following
 * conditions are met:
 *
 * 3. Conditions
 *
 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
 * Redistribution of source code of any substantial portion of the Covered
 * Code or modification with rights to further distribute source must include
 * the above Copyright Notice, the above License, this list of Conditions,
 * and the following Disclaimer and Export Compliance provision.  In addition,
 * Licensee must cause all Covered Code to which Licensee contributes to
 * contain a file documenting the changes Licensee made to create that Covered
 * Code and the date of any change.  Licensee must include in that file the
 * documentation of any changes made by any predecessor Licensee.  Licensee
 * must include a prominent statement that the modification is derived,
 * directly or indirectly, from Original Intel Code.
 *
 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
 * Redistribution of source code of any substantial portion of the Covered
 * Code or modification without rights to further distribute source must
 * include the following Disclaimer and Export Compliance provision in the
 * documentation and/or other materials provided with distribution.  In
 * addition, Licensee may not authorize further sublicense of source of any
 * portion of the Covered Code, and must include terms to the effect that the
 * license from Licensee to its licensee is limited to the intellectual
 * property embodied in the software Licensee provides to its licensee, and
 * not to intellectual property embodied in modifications its licensee may
 * make.
 *
 * 3.3. Redistribution of Executable. Redistribution in executable form of any
 * substantial portion of the Covered Code or modification must reproduce the
 * above Copyright Notice, and the following Disclaimer and Export Compliance
 * provision in the documentation and/or other materials provided with the
 * distribution.
 *
 * 3.4. Intel retains all right, title, and interest in and to the Original
 * Intel Code.
 *
 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
 * Intel shall be used in advertising or otherwise to promote the sale, use or
 * other dealings in products derived from or relating to the Covered Code
 * without prior written authorization from Intel.
 *
 * 4. Disclaimer and Export Compliance
 *
 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
 * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
 * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
 * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
 * PARTICULAR PURPOSE.
 *
 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
 * LIMITED REMEDY.
 *
 * 4.3. Licensee shall not export, either directly or indirectly, any of this
 * software or system incorporating such software without first obtaining any
 * required license or other approval from the U. S. Department of Commerce or
 * any other agency or department of the United States Government.  In the
 * event Licensee exports any such software from the United States or
 * re-exports any such software from a foreign destination, Licensee shall
 * ensure that the distribution and export/re-export of the software is in
 * compliance with all laws, regulations, orders, or other restrictions of the
 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 * any of its subsidiaries will export/re-export any technical data, process,
 * software, or service, directly or indirectly, to any country for which the
 * United States government or any agency thereof requires an export license,
 * other governmental approval, or letter of assurance, without first obtaining
 * such license, approval or letter.
 *
 *****************************************************************************/
 
 
#include "acpi.h"
#include "accommon.h"
#include "acdisasm.h"
 
 
#ifdef ACPI_DISASSEMBLER
 
#define _COMPONENT          ACPI_CA_DEBUGGER
        ACPI_MODULE_NAME    ("dbresrcl")
 
 
/* Common names for address and memory descriptors */
 
static char                 *AcpiDmAddressNames[] =
{
    "Granularity",
    "Range Minimum",
    "Range Maximum",
    "Translation Offset",
    "Length"
};
 
static char                 *AcpiDmMemoryNames[] =
{
    "Range Minimum",
    "Range Maximum",
    "Alignment",
    "Length"
};
 
 
/* Local prototypes */
 
static void
AcpiDmSpaceFlags (
        UINT8               Flags);
 
static void
AcpiDmIoFlags (
        UINT8               Flags);
 
static void
AcpiDmIoFlags2 (
        UINT8               SpecificFlags);
 
static void
AcpiDmMemoryFlags (
    UINT8                   Flags,
    UINT8                   SpecificFlags);
 
static void
AcpiDmMemoryFlags2 (
    UINT8                   SpecificFlags);
 
static void
AcpiDmResourceSource (
    AML_RESOURCE            *Resource,
    ACPI_SIZE               MinimumLength,
    UINT32                  Length);
 
static void
AcpiDmAddressFields (
    void                    *Source,
    UINT8                   Type,
    UINT32                  Level);
 
static void
AcpiDmAddressPrefix (
    UINT8                   Type);
 
static void
AcpiDmAddressCommon (
    AML_RESOURCE            *Resource,
    UINT8                   Type,
    UINT32                  Level);
 
static void
AcpiDmAddressFlags (
    AML_RESOURCE            *Resource);
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmMemoryFields
 *
 * PARAMETERS:  Source              - Pointer to the contiguous data fields
 *              Type                - 16 or 32 (bit)
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode fields common to Memory24 and Memory32 descriptors
 *
 ******************************************************************************/
 
static void
AcpiDmMemoryFields (
    void                    *Source,
    UINT8                   Type,
    UINT32                  Level)
{
    UINT32                  i;
 
 
    for (i = 0; i < 4; i++)
    {
        AcpiDmIndent (Level + 1);
 
        switch (Type)
        {
        case 16:
            AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i],
                AcpiDmMemoryNames[i]);
            break;
 
        case 32:
            AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i],
                AcpiDmMemoryNames[i]);
            break;
 
        default:
            return;
        }
    }
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmAddressFields
 *
 * PARAMETERS:  Source              - Pointer to the contiguous data fields
 *              Type                - 16, 32, or 64 (bit)
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode fields common to address descriptors
 *
 ******************************************************************************/
 
static void
AcpiDmAddressFields (
    void                    *Source,
    UINT8                   Type,
    UINT32                  Level)
{
    UINT32                  i;
 
 
    AcpiOsPrintf ("\n");
 
    for (i = 0; i < 5; i++)
    {
        AcpiDmIndent (Level + 1);
 
        switch (Type)
        {
        case 16:
            AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i],
                AcpiDmAddressNames[i]);
            break;
 
        case 32:
            AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i],
                AcpiDmAddressNames[i]);
            break;
 
        case 64:
            AcpiDmDumpInteger64 (ACPI_CAST_PTR (UINT64, Source)[i],
                AcpiDmAddressNames[i]);
            break;
 
        default:
            return;
        }
    }
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmAddressPrefix
 *
 * PARAMETERS:  Type                - Descriptor type
 *
 * RETURN:      None
 *
 * DESCRIPTION: Emit name prefix representing the address descriptor type
 *
 ******************************************************************************/
 
static void
AcpiDmAddressPrefix (
    UINT8                   Type)
{
 
    switch (Type)
    {
    case ACPI_RESOURCE_TYPE_ADDRESS16:
        AcpiOsPrintf ("Word");
        break;
 
    case ACPI_RESOURCE_TYPE_ADDRESS32:
        AcpiOsPrintf ("DWord");
        break;
 
    case ACPI_RESOURCE_TYPE_ADDRESS64:
        AcpiOsPrintf ("QWord");
        break;
 
    case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
        AcpiOsPrintf ("Extended");
        break;
 
    default:
        return;
    }
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmAddressCommon
 *
 * PARAMETERS:  Resource            - Raw AML descriptor
 *              Type                - Descriptor type
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Emit common name and flag fields common to address descriptors
 *
 ******************************************************************************/
 
static void
AcpiDmAddressCommon (
    AML_RESOURCE            *Resource,
    UINT8                   Type,
    UINT32                  Level)
{
    UINT8                   ResourceType;
    UINT8                   SpecificFlags;
    UINT8                   Flags;
 
 
    ResourceType = Resource->Address.ResourceType;
    SpecificFlags = Resource->Address.SpecificFlags;
    Flags = Resource->Address.Flags;
 
    AcpiDmIndent (Level);
 
    /* Validate ResourceType */
 
    if ((ResourceType > 2) && (ResourceType < 0xC0))
    {
        AcpiOsPrintf ("/**** Invalid Resource Type: 0x%X ****/", ResourceType);
        return;
    }
 
    /* Prefix is either Word, DWord, QWord, or Extended */
 
    AcpiDmAddressPrefix (Type);
 
    /* Resource Types above 0xC0 are vendor-defined */
 
    if (ResourceType > 2)
    {
        AcpiOsPrintf ("Space (0x%2.2X, ", ResourceType);
        AcpiDmSpaceFlags (Flags);
        AcpiOsPrintf (" 0x%2.2X,", SpecificFlags);
        return;
    }
 
    /* This is either a Memory, IO, or BusNumber descriptor (0,1,2) */
 
    AcpiOsPrintf ("%s (", AcpiGbl_WordDecode [ResourceType & 0x3]);
 
    /* Decode the general and type-specific flags */
 
    if (ResourceType == ACPI_MEMORY_RANGE)
    {
        AcpiDmMemoryFlags (Flags, SpecificFlags);
    }
    else /* IO range or BusNumberRange */
    {
        AcpiDmIoFlags (Flags);
        if (ResourceType == ACPI_IO_RANGE)
        {
            AcpiOsPrintf (" %s,", AcpiGbl_RngDecode [SpecificFlags & 0x3]);
        }
    }
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmAddressFlags
 *
 * PARAMETERS:  Resource        - Raw AML descriptor
 *
 * RETURN:      None
 *
 * DESCRIPTION: Emit flags common to address descriptors
 *
 ******************************************************************************/
 
static void
AcpiDmAddressFlags (
    AML_RESOURCE            *Resource)
{
 
    if (Resource->Address.ResourceType == ACPI_IO_RANGE)
    {
        AcpiDmIoFlags2 (Resource->Address.SpecificFlags);
    }
    else if (Resource->Address.ResourceType == ACPI_MEMORY_RANGE)
    {
        AcpiDmMemoryFlags2 (Resource->Address.SpecificFlags);
    }
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmSpaceFlags
 *
 * PARAMETERS:  Flags               - Flag byte to be decoded
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode the flags specific to Space Address space descriptors
 *
 ******************************************************************************/
 
static void
AcpiDmSpaceFlags (
    UINT8                   Flags)
{
 
    AcpiOsPrintf ("%s, %s, %s, %s,",
        AcpiGbl_ConsumeDecode [(Flags & 1)],
        AcpiGbl_DecDecode [(Flags & 0x2) >> 1],
        AcpiGbl_MinDecode [(Flags & 0x4) >> 2],
        AcpiGbl_MaxDecode [(Flags & 0x8) >> 3]);
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmIoFlags
 *
 * PARAMETERS:  Flags               - Flag byte to be decoded
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode the flags specific to IO Address space descriptors
 *
 ******************************************************************************/
 
static void
AcpiDmIoFlags (
        UINT8               Flags)
{
    AcpiOsPrintf ("%s, %s, %s, %s,",
        AcpiGbl_ConsumeDecode [(Flags & 1)],
        AcpiGbl_MinDecode [(Flags & 0x4) >> 2],
        AcpiGbl_MaxDecode [(Flags & 0x8) >> 3],
        AcpiGbl_DecDecode [(Flags & 0x2) >> 1]);
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmIoFlags2
 *
 * PARAMETERS:  SpecificFlags       - "Specific" flag byte to be decoded
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode the flags specific to IO Address space descriptors
 *
 ******************************************************************************/
 
static void
AcpiDmIoFlags2 (
        UINT8               SpecificFlags)
{
 
    AcpiOsPrintf (", %s",
        AcpiGbl_TtpDecode [(SpecificFlags & 0x10) >> 4]);
 
    /* TRS is only used if TTP is TypeTranslation */
 
    if (SpecificFlags & 0x10)
    {
        AcpiOsPrintf (", %s",
            AcpiGbl_TrsDecode [(SpecificFlags & 0x20) >> 5]);
    }
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmMemoryFlags
 *
 * PARAMETERS:  Flags               - Flag byte to be decoded
 *              SpecificFlags       - "Specific" flag byte to be decoded
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode flags specific to Memory Address Space descriptors
 *
 ******************************************************************************/
 
static void
AcpiDmMemoryFlags (
    UINT8                   Flags,
    UINT8                   SpecificFlags)
{
 
    AcpiOsPrintf ("%s, %s, %s, %s, %s, %s,",
        AcpiGbl_ConsumeDecode [(Flags & 1)],
        AcpiGbl_DecDecode [(Flags & 0x2) >> 1],
        AcpiGbl_MinDecode [(Flags & 0x4) >> 2],
        AcpiGbl_MaxDecode [(Flags & 0x8) >> 3],
        AcpiGbl_MemDecode [(SpecificFlags & 0x6) >> 1],
        AcpiGbl_RwDecode [(SpecificFlags & 0x1)]);
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmMemoryFlags2
 *
 * PARAMETERS:  SpecificFlags       - "Specific" flag byte to be decoded
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode flags specific to Memory Address Space descriptors
 *
 ******************************************************************************/
 
static void
AcpiDmMemoryFlags2 (
    UINT8                   SpecificFlags)
{
 
    AcpiOsPrintf (", %s, %s",
        AcpiGbl_MtpDecode [(SpecificFlags & 0x18) >> 3],
        AcpiGbl_TtpDecode [(SpecificFlags & 0x20) >> 5]);
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmResourceSource
 *
 * PARAMETERS:  Resource        - Raw AML descriptor
 *              MinimumLength   - descriptor length without optional fields
 *              ResourceLength
 *
 * RETURN:      None
 *
 * DESCRIPTION: Dump optional ResourceSource fields of an address descriptor
 *
 ******************************************************************************/
 
static void
AcpiDmResourceSource (
    AML_RESOURCE            *Resource,
    ACPI_SIZE               MinimumTotalLength,
    UINT32                  ResourceLength)
{
    UINT8                   *AmlResourceSource;
    UINT32                  TotalLength;
 
 
    TotalLength = ResourceLength + sizeof (AML_RESOURCE_LARGE_HEADER);
 
    /* Check if the optional ResourceSource fields are present */
 
    if (TotalLength <= MinimumTotalLength)
    {
        /* The two optional fields are not used */
 
        AcpiOsPrintf (",, ");
        return;
    }
 
    /* Get a pointer to the ResourceSource */
 
    AmlResourceSource = ACPI_ADD_PTR (UINT8, Resource, MinimumTotalLength);
 
    /*
     * Always emit the ResourceSourceIndex (Byte)
     *
     * NOTE: Some ASL compilers always create a 0 byte (in the AML) for the
     * Index even if the String does not exist. Although this is in violation
     * of the ACPI specification, it is very important to emit ASL code that
     * can be compiled back to the identical AML. There may be fields and/or
     * indexes into the resource template buffer that are compiled to absolute
     * offsets, and these will be broken if the AML length is changed.
     */
    AcpiOsPrintf ("0x%2.2X,", (UINT32) AmlResourceSource[0]);
 
    /* Make sure that the ResourceSource string exists before dumping it */
 
    if (TotalLength > (MinimumTotalLength + 1))
    {
        AcpiOsPrintf (" ");
        AcpiUtPrintString ((char *) &AmlResourceSource[1], ACPI_UINT8_MAX);
    }
 
    AcpiOsPrintf (", ");
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmWordDescriptor
 *
 * PARAMETERS:  Resource            - Pointer to the resource descriptor
 *              Length              - Length of the descriptor in bytes
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode a Word Address Space descriptor
 *
 ******************************************************************************/
 
void
AcpiDmWordDescriptor (
    AML_RESOURCE            *Resource,
    UINT32                  Length,
    UINT32                  Level)
{
 
    /* Dump resource name and flags */
 
    AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS16, Level);
 
    /* Dump the 5 contiguous WORD values */
 
    AcpiDmAddressFields (&Resource->Address16.Granularity, 16, Level);
 
    /* The ResourceSource fields are optional */
 
    AcpiDmIndent (Level + 1);
    AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS16), Length);
 
    /* Insert a descriptor name */
 
    AcpiDmDescriptorName ();
 
    /* Type-specific flags */
 
    AcpiDmAddressFlags (Resource);
    AcpiOsPrintf (")\n");
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmDwordDescriptor
 *
 * PARAMETERS:  Resource            - Pointer to the resource descriptor
 *              Length              - Length of the descriptor in bytes
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode a DWord Address Space descriptor
 *
 ******************************************************************************/
 
void
AcpiDmDwordDescriptor (
    AML_RESOURCE            *Resource,
    UINT32                  Length,
    UINT32                  Level)
{
 
    /* Dump resource name and flags */
 
    AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS32, Level);
 
    /* Dump the 5 contiguous DWORD values */
 
    AcpiDmAddressFields (&Resource->Address32.Granularity, 32, Level);
 
    /* The ResourceSource fields are optional */
 
    AcpiDmIndent (Level + 1);
    AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS32), Length);
 
    /* Insert a descriptor name */
 
    AcpiDmDescriptorName ();
 
    /* Type-specific flags */
 
    AcpiDmAddressFlags (Resource);
    AcpiOsPrintf (")\n");
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmQwordDescriptor
 *
 * PARAMETERS:  Resource            - Pointer to the resource descriptor
 *              Length              - Length of the descriptor in bytes
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode a QWord Address Space descriptor
 *
 ******************************************************************************/
 
void
AcpiDmQwordDescriptor (
    AML_RESOURCE            *Resource,
    UINT32                  Length,
    UINT32                  Level)
{
 
    /* Dump resource name and flags */
 
    AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_ADDRESS64, Level);
 
    /* Dump the 5 contiguous QWORD values */
 
    AcpiDmAddressFields (&Resource->Address64.Granularity, 64, Level);
 
    /* The ResourceSource fields are optional */
 
    AcpiDmIndent (Level + 1);
    AcpiDmResourceSource (Resource, sizeof (AML_RESOURCE_ADDRESS64), Length);
 
    /* Insert a descriptor name */
 
    AcpiDmDescriptorName ();
 
    /* Type-specific flags */
 
    AcpiDmAddressFlags (Resource);
    AcpiOsPrintf (")\n");
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmExtendedDescriptor
 *
 * PARAMETERS:  Resource            - Pointer to the resource descriptor
 *              Length              - Length of the descriptor in bytes
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode a Extended Address Space descriptor
 *
 ******************************************************************************/
 
void
AcpiDmExtendedDescriptor (
    AML_RESOURCE            *Resource,
    UINT32                  Length,
    UINT32                  Level)
{
 
    /* Dump resource name and flags */
 
    AcpiDmAddressCommon (Resource, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64, Level);
 
    /* Dump the 5 contiguous QWORD values */
 
    AcpiDmAddressFields (&Resource->ExtAddress64.Granularity, 64, Level);
 
    /* Extra field for this descriptor only */
 
    AcpiDmIndent (Level + 1);
    AcpiDmDumpInteger64 (Resource->ExtAddress64.TypeSpecific,
        "Type-Specific Attributes");
 
    /* Insert a descriptor name */
 
    AcpiDmIndent (Level + 1);
    AcpiDmDescriptorName ();
 
    /* Type-specific flags */
 
    AcpiDmAddressFlags (Resource);
    AcpiOsPrintf (")\n");
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmMemory24Descriptor
 *
 * PARAMETERS:  Resource            - Pointer to the resource descriptor
 *              Length              - Length of the descriptor in bytes
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode a Memory24 descriptor
 *
 ******************************************************************************/
 
void
AcpiDmMemory24Descriptor (
    AML_RESOURCE            *Resource,
    UINT32                  Length,
    UINT32                  Level)
{
 
    /* Dump name and read/write flag */
 
    AcpiDmIndent (Level);
    AcpiOsPrintf ("Memory24 (%s,\n",
        AcpiGbl_RwDecode [Resource->Memory24.Flags & 1]);
 
    /* Dump the 4 contiguous WORD values */
 
    AcpiDmMemoryFields (&Resource->Memory24.Minimum, 16, Level);
 
    /* Insert a descriptor name */
 
    AcpiDmIndent (Level + 1);
    AcpiDmDescriptorName ();
    AcpiOsPrintf (")\n");
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmMemory32Descriptor
 *
 * PARAMETERS:  Resource            - Pointer to the resource descriptor
 *              Length              - Length of the descriptor in bytes
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode a Memory32 descriptor
 *
 ******************************************************************************/
 
void
AcpiDmMemory32Descriptor (
    AML_RESOURCE            *Resource,
    UINT32                  Length,
    UINT32                  Level)
{
 
    /* Dump name and read/write flag */
 
    AcpiDmIndent (Level);
    AcpiOsPrintf ("Memory32 (%s,\n",
        AcpiGbl_RwDecode [Resource->Memory32.Flags & 1]);
 
    /* Dump the 4 contiguous DWORD values */
 
    AcpiDmMemoryFields (&Resource->Memory32.Minimum, 32, Level);
 
    /* Insert a descriptor name */
 
    AcpiDmIndent (Level + 1);
    AcpiDmDescriptorName ();
    AcpiOsPrintf (")\n");
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmFixedMemory32Descriptor
 *
 * PARAMETERS:  Resource            - Pointer to the resource descriptor
 *              Length              - Length of the descriptor in bytes
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode a Fixed Memory32 descriptor
 *
 ******************************************************************************/
 
void
AcpiDmFixedMemory32Descriptor (
    AML_RESOURCE            *Resource,
    UINT32                  Length,
    UINT32                  Level)
{
 
    /* Dump name and read/write flag */
 
    AcpiDmIndent (Level);
    AcpiOsPrintf ("Memory32Fixed (%s,\n",
        AcpiGbl_RwDecode [Resource->FixedMemory32.Flags & 1]);
 
    AcpiDmIndent (Level + 1);
    AcpiDmDumpInteger32 (Resource->FixedMemory32.Address, "Address Base");
 
    AcpiDmIndent (Level + 1);
    AcpiDmDumpInteger32 (Resource->FixedMemory32.AddressLength, "Address Length");
 
    /* Insert a descriptor name */
 
    AcpiDmIndent (Level + 1);
    AcpiDmDescriptorName ();
    AcpiOsPrintf (")\n");
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmGenericRegisterDescriptor
 *
 * PARAMETERS:  Resource            - Pointer to the resource descriptor
 *              Length              - Length of the descriptor in bytes
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode a Generic Register descriptor
 *
 ******************************************************************************/
 
void
AcpiDmGenericRegisterDescriptor (
    AML_RESOURCE            *Resource,
    UINT32                  Length,
    UINT32                  Level)
{
 
    AcpiDmIndent (Level);
    AcpiOsPrintf ("Register (");
    AcpiDmAddressSpace (Resource->GenericReg.AddressSpaceId);
    AcpiOsPrintf ("\n");
 
    AcpiDmIndent (Level + 1);
    AcpiDmDumpInteger8 (Resource->GenericReg.BitWidth, "Bit Width");
 
    AcpiDmIndent (Level + 1);
    AcpiDmDumpInteger8 (Resource->GenericReg.BitOffset, "Bit Offset");
 
    AcpiDmIndent (Level + 1);
    AcpiDmDumpInteger64 (Resource->GenericReg.Address, "Address");
 
    /* Optional field for ACPI 3.0 */
 
    AcpiDmIndent (Level + 1);
    if (Resource->GenericReg.AccessSize)
    {
        AcpiOsPrintf ("0x%2.2X,               // %s\n",
            Resource->GenericReg.AccessSize, "Access Size");
        AcpiDmIndent (Level + 1);
    }
    else
    {
        AcpiOsPrintf (",");
    }
 
    /* DescriptorName was added for ACPI 3.0+ */
 
    AcpiDmDescriptorName ();
    AcpiOsPrintf (")\n");
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmInterruptDescriptor
 *
 * PARAMETERS:  Resource            - Pointer to the resource descriptor
 *              Length              - Length of the descriptor in bytes
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode a extended Interrupt descriptor
 *
 ******************************************************************************/
 
void
AcpiDmInterruptDescriptor (
    AML_RESOURCE            *Resource,
    UINT32                  Length,
    UINT32                  Level)
{
    UINT32                  i;
 
 
    AcpiDmIndent (Level);
    AcpiOsPrintf ("Interrupt (%s, %s, %s, %s, ",
        AcpiGbl_ConsumeDecode [(Resource->ExtendedIrq.Flags & 1)],
        AcpiGbl_HeDecode [(Resource->ExtendedIrq.Flags >> 1) & 1],
        AcpiGbl_LlDecode [(Resource->ExtendedIrq.Flags >> 2) & 1],
        AcpiGbl_ShrDecode [(Resource->ExtendedIrq.Flags >> 3) & 1]);
 
    /*
     * The ResourceSource fields are optional and appear after the interrupt
     * list. Must compute length based on length of the list. First xrupt
     * is included in the struct (reason for -1 below)
     */
    AcpiDmResourceSource (Resource,
        sizeof (AML_RESOURCE_EXTENDED_IRQ) +
            ((UINT32) Resource->ExtendedIrq.InterruptCount - 1) * sizeof (UINT32),
        Resource->ExtendedIrq.ResourceLength);
 
    /* Insert a descriptor name */
 
    AcpiDmDescriptorName ();
    AcpiOsPrintf (")\n");
 
    /* Dump the interrupt list */
 
    AcpiDmIndent (Level);
    AcpiOsPrintf ("{\n");
    for (i = 0; i < Resource->ExtendedIrq.InterruptCount; i++)
    {
        AcpiDmIndent (Level + 1);
        AcpiOsPrintf ("0x%8.8X,\n",
            (UINT32) Resource->ExtendedIrq.Interrupts[i]);
    }
 
    AcpiDmIndent (Level);
    AcpiOsPrintf ("}\n");
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmVendorCommon
 *
 * PARAMETERS:  Name                - Descriptor name suffix
 *              ByteData            - Pointer to the vendor byte data
 *              Length              - Length of the byte data
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode a Vendor descriptor, both Large and Small
 *
 ******************************************************************************/
 
void
AcpiDmVendorCommon (
    char                    *Name,
    UINT8                   *ByteData,
    UINT32                  Length,
    UINT32                  Level)
{
 
    /* Dump macro name */
 
    AcpiDmIndent (Level);
    AcpiOsPrintf ("Vendor%s (", Name);
 
    /* Insert a descriptor name */
 
    AcpiDmDescriptorName ();
    AcpiOsPrintf (")      // Length = 0x%.2X\n", Length);
 
    /* Dump the vendor bytes */
 
    AcpiDmIndent (Level);
    AcpiOsPrintf ("{\n");
 
    AcpiDmDisasmByteList (Level + 1, ByteData, Length);
 
    AcpiDmIndent (Level);
    AcpiOsPrintf ("}\n");
}
 
 
/*******************************************************************************
 *
 * FUNCTION:    AcpiDmVendorLargeDescriptor
 *
 * PARAMETERS:  Resource            - Pointer to the resource descriptor
 *              Length              - Length of the descriptor in bytes
 *              Level               - Current source code indentation level
 *
 * RETURN:      None
 *
 * DESCRIPTION: Decode a Vendor Large descriptor
 *
 ******************************************************************************/
 
void
AcpiDmVendorLargeDescriptor (
    AML_RESOURCE            *Resource,
    UINT32                  Length,
    UINT32                  Level)
{
 
    AcpiDmVendorCommon ("Long ",
        ACPI_ADD_PTR (UINT8, Resource, sizeof (AML_RESOURCE_LARGE_HEADER)),
        Length, Level);
}
 
#endif

Rev 1498	Rev 2216
1	/*******************************************************************************	1	/*******************************************************************************
2	*	2	*
3	* Module Name: dmresrcl.c - "Large" Resource Descriptor disassembly	3	* Module Name: dmresrcl.c - "Large" Resource Descriptor disassembly
4	*	4	*
5	******************************************************************************/	5	******************************************************************************/
6		6
7	/******************************************************************************	7	/******************************************************************************
8	*	8	*
9	* 1. Copyright Notice	9	* 1. Copyright Notice
10	*	10	*
11	* Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.	11	* Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
12	* All rights reserved.	12	* All rights reserved.
13	*	13	*
14	* 2. License	14	* 2. License
15	*	15	*
16	* 2.1. This is your license from Intel Corp. under its intellectual property	16	* 2.1. This is your license from Intel Corp. under its intellectual property
17	* rights. You may have additional license terms from the party that provided	17	* rights. You may have additional license terms from the party that provided
18	* you this software, covering your right to use that party's intellectual	18	* you this software, covering your right to use that party's intellectual
19	* property rights.	19	* property rights.
20	*	20	*
21	* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a	21	* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22	* copy of the source code appearing in this file ("Covered Code") an	22	* copy of the source code appearing in this file ("Covered Code") an
23	* irrevocable, perpetual, worldwide license under Intel's copyrights in the	23	* irrevocable, perpetual, worldwide license under Intel's copyrights in the
24	* base code distributed originally by Intel ("Original Intel Code") to copy,	24	* base code distributed originally by Intel ("Original Intel Code") to copy,
25	* make derivatives, distribute, use and display any portion of the Covered	25	* make derivatives, distribute, use and display any portion of the Covered
26	* Code in any form, with the right to sublicense such rights; and	26	* Code in any form, with the right to sublicense such rights; and
27	*	27	*
28	* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent	28	* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29	* license (with the right to sublicense), under only those claims of Intel	29	* license (with the right to sublicense), under only those claims of Intel
30	* patents that are infringed by the Original Intel Code, to make, use, sell,	30	* patents that are infringed by the Original Intel Code, to make, use, sell,
31	* offer to sell, and import the Covered Code and derivative works thereof	31	* offer to sell, and import the Covered Code and derivative works thereof
32	* solely to the minimum extent necessary to exercise the above copyright	32	* solely to the minimum extent necessary to exercise the above copyright
33	* license, and in no event shall the patent license extend to any additions	33	* license, and in no event shall the patent license extend to any additions
34	* to or modifications of the Original Intel Code. No other license or right	34	* to or modifications of the Original Intel Code. No other license or right
35	* is granted directly or by implication, estoppel or otherwise;	35	* is granted directly or by implication, estoppel or otherwise;
36	*	36	*
37	* The above copyright and patent license is granted only if the following	37	* The above copyright and patent license is granted only if the following
38	* conditions are met:	38	* conditions are met:
39	*	39	*
40	* 3. Conditions	40	* 3. Conditions
41	*	41	*
42	* 3.1. Redistribution of Source with Rights to Further Distribute Source.	42	* 3.1. Redistribution of Source with Rights to Further Distribute Source.
43	* Redistribution of source code of any substantial portion of the Covered	43	* Redistribution of source code of any substantial portion of the Covered
44	* Code or modification with rights to further distribute source must include	44	* Code or modification with rights to further distribute source must include
45	* the above Copyright Notice, the above License, this list of Conditions,	45	* the above Copyright Notice, the above License, this list of Conditions,
46	* and the following Disclaimer and Export Compliance provision. In addition,	46	* and the following Disclaimer and Export Compliance provision. In addition,
47	* Licensee must cause all Covered Code to which Licensee contributes to	47	* Licensee must cause all Covered Code to which Licensee contributes to
48	* contain a file documenting the changes Licensee made to create that Covered	48	* contain a file documenting the changes Licensee made to create that Covered
49	* Code and the date of any change. Licensee must include in that file the	49	* Code and the date of any change. Licensee must include in that file the
50	* documentation of any changes made by any predecessor Licensee. Licensee	50	* documentation of any changes made by any predecessor Licensee. Licensee
51	* must include a prominent statement that the modification is derived,	51	* must include a prominent statement that the modification is derived,
52	* directly or indirectly, from Original Intel Code.	52	* directly or indirectly, from Original Intel Code.
53	*	53	*
54	* 3.2. Redistribution of Source with no Rights to Further Distribute Source.	54	* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55	* Redistribution of source code of any substantial portion of the Covered	55	* Redistribution of source code of any substantial portion of the Covered
56	* Code or modification without rights to further distribute source must	56	* Code or modification without rights to further distribute source must
57	* include the following Disclaimer and Export Compliance provision in the	57	* include the following Disclaimer and Export Compliance provision in the
58	* documentation and/or other materials provided with distribution. In	58	* documentation and/or other materials provided with distribution. In
59	* addition, Licensee may not authorize further sublicense of source of any	59	* addition, Licensee may not authorize further sublicense of source of any
60	* portion of the Covered Code, and must include terms to the effect that the	60	* portion of the Covered Code, and must include terms to the effect that the
61	* license from Licensee to its licensee is limited to the intellectual	61	* license from Licensee to its licensee is limited to the intellectual
62	* property embodied in the software Licensee provides to its licensee, and	62	* property embodied in the software Licensee provides to its licensee, and
63	* not to intellectual property embodied in modifications its licensee may	63	* not to intellectual property embodied in modifications its licensee may
64	* make.	64	* make.
65	*	65	*
66	* 3.3. Redistribution of Executable. Redistribution in executable form of any	66	* 3.3. Redistribution of Executable. Redistribution in executable form of any
67	* substantial portion of the Covered Code or modification must reproduce the	67	* substantial portion of the Covered Code or modification must reproduce the
68	* above Copyright Notice, and the following Disclaimer and Export Compliance	68	* above Copyright Notice, and the following Disclaimer and Export Compliance
69	* provision in the documentation and/or other materials provided with the	69	* provision in the documentation and/or other materials provided with the
70	* distribution.	70	* distribution.
71	*	71	*
72	* 3.4. Intel retains all right, title, and interest in and to the Original	72	* 3.4. Intel retains all right, title, and interest in and to the Original
73	* Intel Code.	73	* Intel Code.
74	*	74	*
75	* 3.5. Neither the name Intel nor any other trademark owned or controlled by	75	* 3.5. Neither the name Intel nor any other trademark owned or controlled by
76	* Intel shall be used in advertising or otherwise to promote the sale, use or	76	* Intel shall be used in advertising or otherwise to promote the sale, use or
77	* other dealings in products derived from or relating to the Covered Code	77	* other dealings in products derived from or relating to the Covered Code
78	* without prior written authorization from Intel.	78	* without prior written authorization from Intel.
79	*	79	*
80	* 4. Disclaimer and Export Compliance	80	* 4. Disclaimer and Export Compliance
81	*	81	*
82	* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED	82	* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83	* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE	83	* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84	* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,	84	* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85	* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY	85	* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86	* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY	86	* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87	* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A	87	* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88	* PARTICULAR PURPOSE.	88	* PARTICULAR PURPOSE.
89	*	89	*
90	* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES	90	* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91	* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR	91	* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92	* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,	92	* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93	* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY	93	* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94	* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL	94	* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95	* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS	95	* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96	* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY	96	* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97	* LIMITED REMEDY.	97	* LIMITED REMEDY.
98	*	98	*
99	* 4.3. Licensee shall not export, either directly or indirectly, any of this	99	* 4.3. Licensee shall not export, either directly or indirectly, any of this
100	* software or system incorporating such software without first obtaining any	100	* software or system incorporating such software without first obtaining any
101	* required license or other approval from the U. S. Department of Commerce or	101	* required license or other approval from the U. S. Department of Commerce or
102	* any other agency or department of the United States Government. In the	102	* any other agency or department of the United States Government. In the
103	* event Licensee exports any such software from the United States or	103	* event Licensee exports any such software from the United States or
104	* re-exports any such software from a foreign destination, Licensee shall	104	* re-exports any such software from a foreign destination, Licensee shall
105	* ensure that the distribution and export/re-export of the software is in	105	* ensure that the distribution and export/re-export of the software is in
106	* compliance with all laws, regulations, orders, or other restrictions of the	106	* compliance with all laws, regulations, orders, or other restrictions of the
107	* U.S. Export Administration Regulations. Licensee agrees that neither it nor	107	* U.S. Export Administration Regulations. Licensee agrees that neither it nor
108	* any of its subsidiaries will export/re-export any technical data, process,	108	* any of its subsidiaries will export/re-export any technical data, process,
109	* software, or service, directly or indirectly, to any country for which the	109	* software, or service, directly or indirectly, to any country for which the
110	* United States government or any agency thereof requires an export license,	110	* United States government or any agency thereof requires an export license,
111	* other governmental approval, or letter of assurance, without first obtaining	111	* other governmental approval, or letter of assurance, without first obtaining
112	* such license, approval or letter.	112	* such license, approval or letter.
113	*	113	*
114	*****************************************************************************/	114	*****************************************************************************/
115		115
116		116
117	#include "acpi.h"	117	#include "acpi.h"
118	#include "accommon.h"	118	#include "accommon.h"
119	#include "acdisasm.h"	119	#include "acdisasm.h"
120		120
121		121
122	#ifdef ACPI_DISASSEMBLER	122	#ifdef ACPI_DISASSEMBLER
123		123
124	#define _COMPONENT ACPI_CA_DEBUGGER	124	#define _COMPONENT ACPI_CA_DEBUGGER
125	ACPI_MODULE_NAME ("dbresrcl")	125	ACPI_MODULE_NAME ("dbresrcl")
126		126
127		127
128	/* Common names for address and memory descriptors */	128	/* Common names for address and memory descriptors */
129		129
130	static char *AcpiDmAddressNames[] =	130	static char *AcpiDmAddressNames[] =
131	{	131	{
132	"Granularity",	132	"Granularity",
133	"Range Minimum",	133	"Range Minimum",
134	"Range Maximum",	134	"Range Maximum",
135	"Translation Offset",	135	"Translation Offset",
136	"Length"	136	"Length"
137	};	137	};
138		138
139	static char *AcpiDmMemoryNames[] =	139	static char *AcpiDmMemoryNames[] =
140	{	140	{
141	"Range Minimum",	141	"Range Minimum",
142	"Range Maximum",	142	"Range Maximum",
143	"Alignment",	143	"Alignment",
144	"Length"	144	"Length"
145	};	145	};
146		146
147		147
148	/* Local prototypes */	148	/* Local prototypes */
149		149
150	static void	150	static void
151	AcpiDmSpaceFlags (	151	AcpiDmSpaceFlags (
152	UINT8 Flags);	152	UINT8 Flags);
153		153
154	static void	154	static void
155	AcpiDmIoFlags (	155	AcpiDmIoFlags (
156	UINT8 Flags);	156	UINT8 Flags);
157		157
158	static void	158	static void
159	AcpiDmIoFlags2 (	159	AcpiDmIoFlags2 (
160	UINT8 SpecificFlags);	160	UINT8 SpecificFlags);
161		161
162	static void	162	static void
163	AcpiDmMemoryFlags (	163	AcpiDmMemoryFlags (
164	UINT8 Flags,	164	UINT8 Flags,
165	UINT8 SpecificFlags);	165	UINT8 SpecificFlags);
166		166
167	static void	167	static void
168	AcpiDmMemoryFlags2 (	168	AcpiDmMemoryFlags2 (
169	UINT8 SpecificFlags);	169	UINT8 SpecificFlags);
170		170
171	static void	171	static void
172	AcpiDmResourceSource (	172	AcpiDmResourceSource (
173	AML_RESOURCE *Resource,	173	AML_RESOURCE *Resource,
174	ACPI_SIZE MinimumLength,	174	ACPI_SIZE MinimumLength,
175	UINT32 Length);	175	UINT32 Length);
176		176
177	static void	177	static void
178	AcpiDmAddressFields (	178	AcpiDmAddressFields (
179	void *Source,	179	void *Source,
180	UINT8 Type,	180	UINT8 Type,
181	UINT32 Level);	181	UINT32 Level);
182		182
183	static void	183	static void
184	AcpiDmAddressPrefix (	184	AcpiDmAddressPrefix (
185	UINT8 Type);	185	UINT8 Type);
186		186
187	static void	187	static void
188	AcpiDmAddressCommon (	188	AcpiDmAddressCommon (
189	AML_RESOURCE *Resource,	189	AML_RESOURCE *Resource,
190	UINT8 Type,	190	UINT8 Type,
191	UINT32 Level);	191	UINT32 Level);
192		192
193	static void	193	static void
194	AcpiDmAddressFlags (	194	AcpiDmAddressFlags (
195	AML_RESOURCE *Resource);	195	AML_RESOURCE *Resource);
196		196
197		197
198	/*******************************************************************************	198	/*******************************************************************************
199	*	199	*
200	* FUNCTION: AcpiDmMemoryFields	200	* FUNCTION: AcpiDmMemoryFields
201	*	201	*
202	* PARAMETERS: Source - Pointer to the contiguous data fields	202	* PARAMETERS: Source - Pointer to the contiguous data fields
203	* Type - 16 or 32 (bit)	203	* Type - 16 or 32 (bit)
204	* Level - Current source code indentation level	204	* Level - Current source code indentation level
205	*	205	*
206	* RETURN: None	206	* RETURN: None
207	*	207	*
208	* DESCRIPTION: Decode fields common to Memory24 and Memory32 descriptors	208	* DESCRIPTION: Decode fields common to Memory24 and Memory32 descriptors
209	*	209	*
210	******************************************************************************/	210	******************************************************************************/
211		211
212	static void	212	static void
213	AcpiDmMemoryFields (	213	AcpiDmMemoryFields (
214	void *Source,	214	void *Source,
215	UINT8 Type,	215	UINT8 Type,
216	UINT32 Level)	216	UINT32 Level)
217	{	217	{
218	UINT32 i;	218	UINT32 i;
219		219
220		220
221	for (i = 0; i < 4; i++)	221	for (i = 0; i < 4; i++)
222	{	222	{
223	AcpiDmIndent (Level + 1);	223	AcpiDmIndent (Level + 1);
224		224
225	switch (Type)	225	switch (Type)
226	{	226	{
227	case 16:	227	case 16:
228	AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i],	228	AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i],
229	AcpiDmMemoryNames[i]);	229	AcpiDmMemoryNames[i]);
230	break;	230	break;
231		231
232	case 32:	232	case 32:
233	AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i],	233	AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i],
234	AcpiDmMemoryNames[i]);	234	AcpiDmMemoryNames[i]);
235	break;	235	break;
236		236
237	default:	237	default:
238	return;	238	return;
239	}	239	}
240	}	240	}
241	}	241	}
242		242
243		243
244	/*******************************************************************************	244	/*******************************************************************************
245	*	245	*
246	* FUNCTION: AcpiDmAddressFields	246	* FUNCTION: AcpiDmAddressFields
247	*	247	*
248	* PARAMETERS: Source - Pointer to the contiguous data fields	248	* PARAMETERS: Source - Pointer to the contiguous data fields
249	* Type - 16, 32, or 64 (bit)	249	* Type - 16, 32, or 64 (bit)
250	* Level - Current source code indentation level	250	* Level - Current source code indentation level
251	*	251	*
252	* RETURN: None	252	* RETURN: None
253	*	253	*
254	* DESCRIPTION: Decode fields common to address descriptors	254	* DESCRIPTION: Decode fields common to address descriptors
255	*	255	*
256	******************************************************************************/	256	******************************************************************************/
257		257
258	static void	258	static void
259	AcpiDmAddressFields (	259	AcpiDmAddressFields (
260	void *Source,	260	void *Source,
261	UINT8 Type,	261	UINT8 Type,
262	UINT32 Level)	262	UINT32 Level)
263	{	263	{
264	UINT32 i;	264	UINT32 i;
265		265
266		266
267	AcpiOsPrintf ("\n");	267	AcpiOsPrintf ("\n");
268		268
269	for (i = 0; i < 5; i++)	269	for (i = 0; i < 5; i++)
270	{	270	{
271	AcpiDmIndent (Level + 1);	271	AcpiDmIndent (Level + 1);
272		272
273	switch (Type)	273	switch (Type)
274	{	274	{
275	case 16:	275	case 16:
276	AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i],	276	AcpiDmDumpInteger16 (ACPI_CAST_PTR (UINT16, Source)[i],
277	AcpiDmAddressNames[i]);	277	AcpiDmAddressNames[i]);
278	break;	278	break;
279		279
280	case 32:	280	case 32:
281	AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i],	281	AcpiDmDumpInteger32 (ACPI_CAST_PTR (UINT32, Source)[i],
282	AcpiDmAddressNames[i]);	282	AcpiDmAddressNames[i]);
283	break;	283	break;
284		284
285	case 64:	285	case 64:
286	AcpiDmDumpInteger64 (ACPI_CAST_PTR (UINT64, Source)[i],	286	AcpiDmDumpInteger64 (ACPI_CAST_PTR (UINT64, Source)[i],
287	AcpiDmAddressNames[i]);	287	AcpiDmAddressNames[i]);
288	break;	288	break;
289		289
290	default:	290	default:
291	return;	291	return;
292	}	292	}
293	}	293	}
294	}	294	}
295		295
296		296
297	/*******************************************************************************	297	/*******************************************************************************
298	*	298	*
299	* FUNCTION: AcpiDmAddressPrefix	299	* FUNCTION: AcpiDmAddressPrefix
300	*	300	*
301	* PARAMETERS: Type - Descriptor type	301	* PARAMETERS: Type - Descriptor type
302	*	302	*
303	* RETURN: None	303	* RETURN: None
304	*	304	*
305	* DESCRIPTION: Emit name prefix representing the address descriptor type	305	* DESCRIPTION: Emit name prefix representing the address descriptor type
306	*	306	*
307	******************************************************************************/	307	******************************************************************************/
308		308
309	static void	309	static void
310	AcpiDmAddressPrefix (	310	AcpiDmAddressPrefix (
311	UINT8 Type)	311	UINT8 Type)
312	{	312	{
313		313
314	switch (Type)	314	switch (Type)
315	{	315	{
316	case ACPI_RESOURCE_TYPE_ADDRESS16:	316	case ACPI_RESOURCE_TYPE_ADDRESS16:
317	AcpiOsPrintf ("Word");	317	AcpiOsPrintf ("Word");
318	break;	318	break;
319		319
320	case ACPI_RESOURCE_TYPE_ADDRESS32:	320	case ACPI_RESOURCE_TYPE_ADDRESS32:
321	AcpiOsPrintf ("DWord");	321	AcpiOsPrintf ("DWord");
322	break;	322	break;
323		323
324	case ACPI_RESOURCE_TYPE_ADDRESS64:	324	case ACPI_RESOURCE_TYPE_ADDRESS64:
325	AcpiOsPrintf ("QWord");	325	AcpiOsPrintf ("QWord");
326	break;	326	break;
327		327
328	case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:	328	case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
329	AcpiOsPrintf ("Extended");	329	AcpiOsPrintf ("Extended");
330	break;	330	break;
331		331
332	default:	332	default:
333	return;	333	return;
334	}	334	}
335	}	335	}
336		336
337		337
338	/*******************************************************************************	338	/*******************************************************************************
339	*	339	*
340	* FUNCTION: AcpiDmAddressCommon	340	* FUNCTION: AcpiDmAddressCommon
341	*	341	*
342	* PARAMETERS: Resource - Raw AML descriptor	342	* PARAMETERS: Resource - Raw AML descriptor
343	* Type - Descriptor type	343	* Type - Descriptor type
344	* Level - Current source code indentation level	344	* Level - Current source code indentation level
345	*	345	*
346	* RETURN: None	346	* RETURN: None
347	*	347	*
348	* DESCRIPTION: Emit common name and flag fields common to address descriptors	348	* DESCRIPTION: Emit common name and flag fields common to address descriptors
349	*	349	*
350	******************************************************************************/	350	******************************************************************************/
351		351
352	static void	352	static void
353	AcpiDmAddressCommon (	353	AcpiDmAddressCommon (
354	AML_RESOURCE *Resource,	354	AML_RESOURCE *Resource,
355	UINT8 Type,	355	UINT8 Type,
356	UINT32 Level)	356	UINT32 Level)
357	{	357	{
358	UINT8 ResourceType;	358	UINT8 ResourceType;
359	UINT8 SpecificFlags;	359	UINT8 SpecificFlags;
360	UINT8 Flags;	360	UINT8 Flags;
361		361
362		362
363	ResourceType = Resource->Address.ResourceType;	363	ResourceType = Resource->Address.ResourceType;
364	SpecificFlags = Resource->Address.SpecificFlags;	364	SpecificFlags = Resource->Address.SpecificFlags;
365	Flags = Resource->Address.Flags;	365	Flags = Resource->Address.Flags;
366		366
367	AcpiDmIndent (Level);	367	AcpiDmIndent (Level);
368		368
369	/* Validate ResourceType */	369	/* Validate ResourceType */
370		370
371	if ((ResourceType > 2) && (ResourceType < 0xC0))	371	if ((ResourceType > 2) && (ResourceType < 0xC0))
372	{	372	{
373	AcpiOsPrintf ("/** Invalid Resource Type: 0x%X **/", ResourceType);	373	AcpiOsPrintf ("/** Invalid Resource Type: 0x%X **/", ResourceType);
374	return;	374	return;
375	}	375	}
376		376
377	/* Prefix is either Word, DWord, QWord, or Extended */	377	/* Prefix is either Word, DWord, QWord, or Extended */
378		378
379	AcpiDmAddressPrefix (Type);	379	AcpiDmAddressPrefix (Type);
380		380
381	/* Resource Types above 0xC0 are vendor-defined */	381	/* Resource Types above 0xC0 are vendor-defined */
382		382
383	if (ResourceType > 2)	383	if (ResourceType > 2)
384	{	384	{
385	AcpiOsPrintf ("Space (0x%2.2X, ", ResourceType);	385	AcpiOsPrintf ("Space (0x%2.2X, ", ResourceType);
386	AcpiDmSpaceFlags (Flags);	386	AcpiDmSpaceFlags (Flags);
387	AcpiOsPrintf (" 0x%2.2X,", SpecificFlags);	387	AcpiOsPrintf (" 0x%2.2X,", SpecificFlags);
388	return;	388	return;
389	}	389	}
390		390
391	/* This is either a Memory, IO, or BusNumber descriptor (0,1,2) */	391	/* This is either a Memory, IO, or BusNumber descriptor (0,1,2) */
392		392
393	AcpiOsPrintf ("%s (", AcpiGbl_WordDecode [ResourceType & 0x3]);	393	AcpiOsPrintf ("%s (", AcpiGbl_WordDecode [ResourceType & 0x3]);
394		394
395	/* Decode the general and type-specific flags */	395	/* Decode the general and type-specific flags */
396		396
397	if (ResourceType == ACPI_MEMORY_RANGE)	397	if (ResourceType == ACPI_MEMORY_RANGE)
398	{	398	{
399	AcpiDmMemoryFlags (Flags, SpecificFlags);	399	AcpiDmMemoryFlags (Flags, SpecificFlags);
400	}	400	}
401	else /* IO range or BusNumberRange */	401	else /* IO range or BusNumberRange */
402	{	402	{
403	AcpiDmIoFlags (Flags);	403	AcpiDmIoFlags (Flags);
404	if (ResourceType == ACPI_IO_RANGE)	404	if (ResourceType == ACPI_IO_RANGE)
405	{	405	{
406	AcpiOsPrintf (" %s,", AcpiGbl_RngDecode [SpecificFlags & 0x3]);	406	AcpiOsPrintf (" %s,", AcpiGbl_RngDecode [SpecificFlags & 0x3]);
407	}	407	}
408	}	408	}
409	}	409	}
410		410
411		411
412	/*******************************************************************************	412	/*******************************************************************************
413	*	413	*
414	* FUNCTION: AcpiDmAddressFlags	414	* FUNCTION: AcpiDmAddressFlags
415	*	415	*
416	* PARAMETERS: Resource - Raw AML descriptor	416	* PARAMETERS: Resource - Raw AML descriptor
417	*	417	*
418	* RETURN: None	418	* RETURN: None
419	*	419	*
420	* DESCRIPTION: Emit flags common to address descriptors	420	* DESCRIPTION: Emit flags common to address descriptors
421	*	421	*
422	******************************************************************************/	422	******************************************************************************/
423		423
424	static void	424	static void
425	AcpiDmAddressFlags (	425	AcpiDmAddressFlags (
426	AML_RESOURCE *Resource)	426	AML_RESOURCE *Resource)
427	{	427	{
428		428
429	if (Resource->Address.ResourceType == ACPI_IO_RANGE)	429	if (Resource->Address.ResourceType == ACPI_IO_RANGE)
430	{	430	{
431	AcpiDmIoFlags2 (Resource->Address.SpecificFlags);	431	AcpiDmIoFlags2 (Resource->Address.SpecificFlags);
432	}	432	}
433	else if (Resource->Address.ResourceType == ACPI_MEMORY_RANGE)	433	else if (Resource->Address.ResourceType == ACPI_MEMORY_RANGE)
434	{	434	{
435	AcpiDmMemoryFlags2 (Resource->Address.SpecificFlags);	435	AcpiDmMemoryFlags2 (Resource->Address.SpecificFlags);
436	}	436	}
437	}	437	}
438		438
439		439
440	/*******************************************************************************	440	/*******************************************************************************
441	*	441	*
442	* FUNCTION: AcpiDmSpaceFlags	442	* FUNCTION: AcpiDmSpaceFlags
443	*	443	*
444	* PARAMETERS: Flags - Flag byte to be decoded	444	* PARAMETERS: Flags - Flag byte to be decoded
445	*	445	*
446	* RETURN: None	446	* RETURN: None
447	*	447	*
448	* DESCRIPTION: Decode the flags specific to Space Address space descriptors	448	* DESCRIPTION: Decode the flags specific to Space Address space descriptors
449	*	449	*
450	******************************************************************************/	450	******************************************************************************/
451		451
452	static void	452	static void
453	AcpiDmSpaceFlags (	453	AcpiDmSpaceFlags (
454	UINT8 Flags)	454	UINT8 Flags)
455	{	455	{
456		456
457	AcpiOsPrintf ("%s, %s, %s, %s,",	457	AcpiOsPrintf ("%s, %s, %s, %s,",
458	AcpiGbl_ConsumeDecode [(Flags & 1)],	458	AcpiGbl_ConsumeDecode [(Flags & 1)],
459	AcpiGbl_DecDecode [(Flags & 0x2) >> 1],	459	AcpiGbl_DecDecode [(Flags & 0x2) >> 1],
460	AcpiGbl_MinDecode [(Flags & 0x4) >> 2],	460	AcpiGbl_MinDecode [(Flags & 0x4) >> 2],
461	AcpiGbl_MaxDecode [(Flags & 0x8) >> 3]);	461	AcpiGbl_MaxDecode [(Flags & 0x8) >> 3]);
462	}	462	}
463		463
464		464
465	/*******************************************************************************	465	/*******************************************************************************
466	*	466	*
467	* FUNCTION: AcpiDmIoFlags	467	* FUNCTION: AcpiDmIoFlags
468	*	468	*
469	* PARAMETERS: Flags - Flag byte to be decoded	469	* PARAMETERS: Flags - Flag byte to be decoded
470	*	470	*
471	* RETURN: None	471	* RETURN: None
472	*	472	*
473	* DESCRIPTION: Decode the flags specific to IO Address space descriptors	473	* DESCRIPTION: Decode the flags specific to IO Address space descriptors
474	*	474	*
475	******************************************************************************/	475	******************************************************************************/
476		476
477	static void	477	static void
478	AcpiDmIoFlags (	478	AcpiDmIoFlags (
479	UINT8 Flags)	479	UINT8 Flags)
480	{	480	{
481	AcpiOsPrintf ("%s, %s, %s, %s,",	481	AcpiOsPrintf ("%s, %s, %s, %s,",
482	AcpiGbl_ConsumeDecode [(Flags & 1)],	482	AcpiGbl_ConsumeDecode [(Flags & 1)],
483	AcpiGbl_MinDecode [(Flags & 0x4) >> 2],	483	AcpiGbl_MinDecode [(Flags & 0x4) >> 2],
484	AcpiGbl_MaxDecode [(Flags & 0x8) >> 3],	484	AcpiGbl_MaxDecode [(Flags & 0x8) >> 3],
485	AcpiGbl_DecDecode [(Flags & 0x2) >> 1]);	485	AcpiGbl_DecDecode [(Flags & 0x2) >> 1]);
486	}	486	}
487		487
488		488
489	/*******************************************************************************	489	/*******************************************************************************
490	*	490	*
491	* FUNCTION: AcpiDmIoFlags2	491	* FUNCTION: AcpiDmIoFlags2
492	*	492	*
493	* PARAMETERS: SpecificFlags - "Specific" flag byte to be decoded	493	* PARAMETERS: SpecificFlags - "Specific" flag byte to be decoded
494	*	494	*
495	* RETURN: None	495	* RETURN: None
496	*	496	*
497	* DESCRIPTION: Decode the flags specific to IO Address space descriptors	497	* DESCRIPTION: Decode the flags specific to IO Address space descriptors
498	*	498	*
499	******************************************************************************/	499	******************************************************************************/
500		500

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpica/disassembler/dmresrcl.c – Rev 1498 → 2216