exprep.c File Reference

#include "acpi.h"
#include "accommon.h"
#include "acinterp.h"
#include "amlcode.h"
#include "acnamesp.h"
#include "acdispat.h"

Include dependency graph for exprep.c:

Go to the source code of this file.

Macros
#define	_COMPONENT   ACPI_EXECUTER

Functions
static UINT32	AcpiExDecodeFieldAccess (ACPI_OPERAND_OBJECT *ObjDesc, UINT8 FieldFlags, UINT32 *ReturnByteAlignment)
ACPI_STATUS	AcpiExPrepCommonFieldObject (ACPI_OPERAND_OBJECT *ObjDesc, UINT8 FieldFlags, UINT8 FieldAttribute, UINT32 FieldBitPosition, UINT32 FieldBitLength)
ACPI_STATUS	AcpiExPrepFieldValue (ACPI_CREATE_FIELD_INFO *Info)

Macro Definition Documentation

_COMPONENT

#define _COMPONENT   ACPI_EXECUTER

Definition at line 52 of file exprep.c.

Function Documentation

AcpiExDecodeFieldAccess()

static UINT32 AcpiExDecodeFieldAccess ( ACPI_OPERAND_OBJECT *  ObjDesc, UINT8  FieldFlags, UINT32 *  ReturnByteAlignment  )

static

Definition at line 243 of file exprep.c.

{
    UINT32                  Access;
    UINT32                  ByteAlignment;
    UINT32                  BitLength;
 
 
    ACPI_FUNCTION_TRACE (ExDecodeFieldAccess);
 
 
    Access = (FieldFlags & AML_FIELD_ACCESS_TYPE_MASK);
 
    switch (Access)
    {
    case AML_FIELD_ACCESS_ANY:
 
#ifdef ACPI_UNDER_DEVELOPMENT
        ByteAlignment =
            AcpiExGenerateAccess (ObjDesc->CommonField.StartFieldBitOffset,
                ObjDesc->CommonField.BitLength,
                0xFFFFFFFF /* Temp until we pass RegionLength as parameter */);
        BitLength = ByteAlignment * 8;
#endif
 
        ByteAlignment = 1;
        BitLength = 8;
        break;
 
    case AML_FIELD_ACCESS_BYTE:
    case AML_FIELD_ACCESS_BUFFER:   /* ACPI 2.0 (SMBus Buffer) */
 
        ByteAlignment = 1;
        BitLength     = 8;
        break;
 
    case AML_FIELD_ACCESS_WORD:
 
        ByteAlignment = 2;
        BitLength     = 16;
        break;
 
    case AML_FIELD_ACCESS_DWORD:
 
        ByteAlignment = 4;
        BitLength     = 32;
        break;
 
    case AML_FIELD_ACCESS_QWORD:    /* ACPI 2.0 */
 
        ByteAlignment = 8;
        BitLength     = 64;
        break;
 
    default:
 
        /* Invalid field access type */
 
        ACPI_ERROR ((AE_INFO,
            "Unknown field access type 0x%X",
            Access));
 
        return_UINT32 (0);
    }
 
    if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
    {
        /*
         * BufferField access can be on any byte boundary, so the
         * ByteAlignment is always 1 byte -- regardless of any ByteAlignment
         * implied by the field access type.
         */
        ByteAlignment = 1;
    }
 
    *ReturnByteAlignment = ByteAlignment;
    return_UINT32 (BitLength);
}

Referenced by AcpiExPrepCommonFieldObject().

AcpiExPrepCommonFieldObject()

ACPI_STATUS AcpiExPrepCommonFieldObject	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		UINT8	FieldFlags,
		UINT8	FieldAttribute,
		UINT32	FieldBitPosition,
		UINT32	FieldBitLength
	)

Definition at line 347 of file exprep.c.

{
    UINT32                  AccessBitWidth;
    UINT32                  ByteAlignment;
    UINT32                  NearestByteAddress;
 
 
    ACPI_FUNCTION_TRACE (ExPrepCommonFieldObject);
 
 
    /*
     * Note: the structure being initialized is the
     * ACPI_COMMON_FIELD_INFO;  No structure fields outside of the common
     * area are initialized by this procedure.
     */
    ObjDesc->CommonField.FieldFlags = FieldFlags;
    ObjDesc->CommonField.Attribute  = FieldAttribute;
    ObjDesc->CommonField.BitLength  = FieldBitLength;
 
    /*
     * Decode the access type so we can compute offsets. The access type gives
     * two pieces of information - the width of each field access and the
     * necessary ByteAlignment (address granularity) of the access.
     *
     * For AnyAcc, the AccessBitWidth is the largest width that is both
     * necessary and possible in an attempt to access the whole field in one
     * I/O operation. However, for AnyAcc, the ByteAlignment is always one
     * byte.
     *
     * For all Buffer Fields, the ByteAlignment is always one byte.
     *
     * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is
     * the same (equivalent) as the ByteAlignment.
     */
    AccessBitWidth = AcpiExDecodeFieldAccess (
        ObjDesc, FieldFlags, &ByteAlignment);
    if (!AccessBitWidth)
    {
        return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
    }
 
    /* Setup width (access granularity) fields (values are: 1, 2, 4, 8) */
 
    ObjDesc->CommonField.AccessByteWidth = (UINT8)
        ACPI_DIV_8 (AccessBitWidth);
 
    /*
     * BaseByteOffset is the address of the start of the field within the
     * region. It is the byte address of the first *datum* (field-width data
     * unit) of the field. (i.e., the first datum that contains at least the
     * first *bit* of the field.)
     *
     * Note: ByteAlignment is always either equal to the AccessBitWidth or 8
     * (Byte access), and it defines the addressing granularity of the parent
     * region or buffer.
     */
    NearestByteAddress =
        ACPI_ROUND_BITS_DOWN_TO_BYTES (FieldBitPosition);
    ObjDesc->CommonField.BaseByteOffset = (UINT32)
        ACPI_ROUND_DOWN (NearestByteAddress, ByteAlignment);
 
    /*
     * StartFieldBitOffset is the offset of the first bit of the field within
     * a field datum.
     */
    ObjDesc->CommonField.StartFieldBitOffset = (UINT8)
        (FieldBitPosition - ACPI_MUL_8 (ObjDesc->CommonField.BaseByteOffset));
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiDsInitBufferField(), and AcpiExPrepFieldValue().

AcpiExPrepFieldValue()

ACPI_STATUS AcpiExPrepFieldValue

(

ACPI_CREATE_FIELD_INFO *

Info

)

Definition at line 438 of file exprep.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_OPERAND_OBJECT     *SecondDesc = NULL;
    ACPI_STATUS             Status;
    UINT32                  AccessByteWidth;
    UINT32                  Type;
 
 
    ACPI_FUNCTION_TRACE (ExPrepFieldValue);
 
 
    /* Parameter validation */
 
    if (Info->FieldType != ACPI_TYPE_LOCAL_INDEX_FIELD)
    {
        if (!Info->RegionNode)
        {
            ACPI_ERROR ((AE_INFO, "Null RegionNode"));
            return_ACPI_STATUS (AE_AML_NO_OPERAND);
        }
 
        Type = AcpiNsGetType (Info->RegionNode);
        if (Type != ACPI_TYPE_REGION)
        {
            ACPI_ERROR ((AE_INFO, "Needed Region, found type 0x%X (%s)",
                Type, AcpiUtGetTypeName (Type)));
 
            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
    }
 
    /* Allocate a new field object */
 
    ObjDesc = AcpiUtCreateInternalObject (Info->FieldType);
    if (!ObjDesc)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /* Initialize areas of the object that are common to all fields */
 
    ObjDesc->CommonField.Node = Info->FieldNode;
    Status = AcpiExPrepCommonFieldObject (ObjDesc,
        Info->FieldFlags, Info->Attribute,
        Info->FieldBitPosition, Info->FieldBitLength);
    if (ACPI_FAILURE (Status))
    {
        AcpiUtDeleteObjectDesc (ObjDesc);
        return_ACPI_STATUS (Status);
    }
 
    /* Initialize areas of the object that are specific to the field type */
 
    switch (Info->FieldType)
    {
    case ACPI_TYPE_LOCAL_REGION_FIELD:
 
        ObjDesc->Field.RegionObj = AcpiNsGetAttachedObject (Info->RegionNode);
 
        /* Fields specific to GenericSerialBus fields */
 
        ObjDesc->Field.AccessLength = Info->AccessLength;
 
        if (Info->ConnectionNode)
        {
            SecondDesc = Info->ConnectionNode->Object;
            if (!(SecondDesc->Common.Flags & AOPOBJ_DATA_VALID))
            {
                Status = AcpiDsGetBufferArguments (SecondDesc);
                if (ACPI_FAILURE (Status))
                {
                    AcpiUtDeleteObjectDesc (ObjDesc);
                    return_ACPI_STATUS (Status);
                }
            }
 
            ObjDesc->Field.ResourceBuffer =
                SecondDesc->Buffer.Pointer;
            ObjDesc->Field.ResourceLength =
                (UINT16) SecondDesc->Buffer.Length;
        }
        else if (Info->ResourceBuffer)
        {
            ObjDesc->Field.ResourceBuffer = Info->ResourceBuffer;
            ObjDesc->Field.ResourceLength = Info->ResourceLength;
        }
 
        ObjDesc->Field.PinNumberIndex = Info->PinNumberIndex;
 
        /* Allow full data read from EC address space */
 
        if ((ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_EC) &&
            (ObjDesc->CommonField.BitLength > 8))
        {
            AccessByteWidth = ACPI_ROUND_BITS_UP_TO_BYTES (
                ObjDesc->CommonField.BitLength);
 
            /* Maximum byte width supported is 255 */
 
            if (AccessByteWidth < 256)
            {
                ObjDesc->CommonField.AccessByteWidth =
                    (UINT8) AccessByteWidth;
            }
        }
 
        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
            "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n",
            ObjDesc->Field.StartFieldBitOffset,
            ObjDesc->Field.BaseByteOffset,
            ObjDesc->Field.AccessByteWidth,
            ObjDesc->Field.RegionObj));
        break;
 
    case ACPI_TYPE_LOCAL_BANK_FIELD:
 
        ObjDesc->BankField.Value = Info->BankValue;
        ObjDesc->BankField.RegionObj =
            AcpiNsGetAttachedObject (Info->RegionNode);
        ObjDesc->BankField.BankObj =
            AcpiNsGetAttachedObject (Info->RegisterNode);
 
        /* An additional reference for the attached objects */
 
        AcpiUtAddReference (ObjDesc->BankField.RegionObj);
        AcpiUtAddReference (ObjDesc->BankField.BankObj);
 
        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
            "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n",
            ObjDesc->BankField.StartFieldBitOffset,
            ObjDesc->BankField.BaseByteOffset,
            ObjDesc->Field.AccessByteWidth,
            ObjDesc->BankField.RegionObj,
            ObjDesc->BankField.BankObj));
 
        /*
         * Remember location in AML stream of the field unit
         * opcode and operands -- since the BankValue
         * operands must be evaluated.
         */
        SecondDesc = ObjDesc->Common.NextObject;
        SecondDesc->Extra.AmlStart = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
            Info->DataRegisterNode)->Named.Data;
        SecondDesc->Extra.AmlLength = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,
            Info->DataRegisterNode)->Named.Length;
 
        break;
 
    case ACPI_TYPE_LOCAL_INDEX_FIELD:
 
        /* Get the Index and Data registers */
 
        ObjDesc->IndexField.IndexObj =
            AcpiNsGetAttachedObject (Info->RegisterNode);
        ObjDesc->IndexField.DataObj =
            AcpiNsGetAttachedObject (Info->DataRegisterNode);
 
        if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj)
        {
            ACPI_ERROR ((AE_INFO, "Null Index Object during field prep"));
            AcpiUtDeleteObjectDesc (ObjDesc);
            return_ACPI_STATUS (AE_AML_INTERNAL);
        }
 
        /* An additional reference for the attached objects */
 
        AcpiUtAddReference (ObjDesc->IndexField.DataObj);
        AcpiUtAddReference (ObjDesc->IndexField.IndexObj);
 
        /*
         * April 2006: Changed to match MS behavior
         *
         * The value written to the Index register is the byte offset of the
         * target field in units of the granularity of the IndexField
         *
         * Previously, the value was calculated as an index in terms of the
         * width of the Data register, as below:
         *
         *      ObjDesc->IndexField.Value = (UINT32)
         *          (Info->FieldBitPosition / ACPI_MUL_8 (
         *              ObjDesc->Field.AccessByteWidth));
         *
         * February 2006: Tried value as a byte offset:
         *      ObjDesc->IndexField.Value = (UINT32)
         *          ACPI_DIV_8 (Info->FieldBitPosition);
         */
        ObjDesc->IndexField.Value = (UINT32) ACPI_ROUND_DOWN (
            ACPI_DIV_8 (Info->FieldBitPosition),
            ObjDesc->IndexField.AccessByteWidth);
 
        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
            "IndexField: BitOff %X, Off %X, Value %X, "
            "Gran %X, Index %p, Data %p\n",
            ObjDesc->IndexField.StartFieldBitOffset,
            ObjDesc->IndexField.BaseByteOffset,
            ObjDesc->IndexField.Value,
            ObjDesc->Field.AccessByteWidth,
            ObjDesc->IndexField.IndexObj,
            ObjDesc->IndexField.DataObj));
        break;
 
    default:
 
        /* No other types should get here */
 
        break;
    }
 
    /*
     * Store the constructed descriptor (ObjDesc) into the parent Node,
     * preserving the current type of that NamedObj.
     */
    Status = AcpiNsAttachObject (
        Info->FieldNode, ObjDesc, AcpiNsGetType (Info->FieldNode));
 
    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
        "Set NamedObj %p [%4.4s], ObjDesc %p\n",
        Info->FieldNode, AcpiUtGetNodeName (Info->FieldNode), ObjDesc));
 
    /* Remove local reference to the object */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsGetFieldNames().