acinterp.h File Reference

Go to the source code of this file.

Classes
struct	acpi_exdump_info

Macros
#define	ACPI_WALK_OPERANDS   (&(WalkState->Operands [WalkState->NumOperands -1]))
#define	ACPI_EXD_OFFSET(f)   (UINT8) ACPI_OFFSET (ACPI_OPERAND_OBJECT,f)
#define	ACPI_EXD_NSOFFSET(f)   (UINT8) ACPI_OFFSET (ACPI_NAMESPACE_NODE,f)
#define	ACPI_EXD_TABLE_SIZE(name)   (sizeof(name) / sizeof (ACPI_EXDUMP_INFO))
#define	ACPI_EXD_INIT   0
#define	ACPI_EXD_TYPE   1
#define	ACPI_EXD_UINT8   2
#define	ACPI_EXD_UINT16   3
#define	ACPI_EXD_UINT32   4
#define	ACPI_EXD_UINT64   5
#define	ACPI_EXD_LITERAL   6
#define	ACPI_EXD_POINTER   7
#define	ACPI_EXD_ADDRESS   8
#define	ACPI_EXD_STRING   9
#define	ACPI_EXD_BUFFER   10
#define	ACPI_EXD_PACKAGE   11
#define	ACPI_EXD_FIELD   12
#define	ACPI_EXD_REFERENCE   13
#define	ACPI_EXD_LIST   14 /* Operand object list */
#define	ACPI_EXD_HDLR_LIST   15 /* Address Handler list */
#define	ACPI_EXD_RGN_LIST   16 /* Region list */
#define	ACPI_EXD_NODE   17 /* Namespace Node */
#define	ACPI_EXPLICIT_BYTE_COPY   0x00000000
#define	ACPI_EXPLICIT_CONVERT_HEX   0x00000001
#define	ACPI_IMPLICIT_CONVERT_HEX   0x00000002
#define	ACPI_EXPLICIT_CONVERT_DECIMAL   0x00000003

Typedefs
typedef const struct acpi_exdump_info	ACPI_EXDUMP_INFO

Functions
ACPI_STATUS	AcpiExConvertToInteger (ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc, UINT32 ImplicitConversion)
ACPI_STATUS	AcpiExConvertToBuffer (ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc)
ACPI_STATUS	AcpiExConvertToString (ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc, UINT32 Type)
ACPI_STATUS	AcpiExConvertToTargetType (ACPI_OBJECT_TYPE DestinationType, ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT **ResultDesc, ACPI_WALK_STATE *WalkState)
void	AcpiExDoDebugObject (ACPI_OPERAND_OBJECT *SourceDesc, UINT32 Level, UINT32 Index)
void	AcpiExStartTraceMethod (ACPI_NAMESPACE_NODE *MethodNode, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState)
void	AcpiExStopTraceMethod (ACPI_NAMESPACE_NODE *MethodNode, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState)
void	AcpiExStartTraceOpcode (ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState)
void	AcpiExStopTraceOpcode (ACPI_PARSE_OBJECT *Op, ACPI_WALK_STATE *WalkState)
void	AcpiExTracePoint (ACPI_TRACE_EVENT_TYPE Type, BOOLEAN Begin, UINT8 *Aml, char *Pathname)
ACPI_STATUS	AcpiExGetProtocolBufferLength (UINT32 ProtocolId, UINT32 *ReturnLength)
ACPI_STATUS	AcpiExCommonBufferSetup (ACPI_OPERAND_OBJECT *ObjDesc, UINT32 BufferLength, UINT32 *DatumCount)
ACPI_STATUS	AcpiExWriteWithUpdateRule (ACPI_OPERAND_OBJECT *ObjDesc, UINT64 Mask, UINT64 FieldValue, UINT32 FieldDatumByteOffset)
void	AcpiExGetBufferDatum (UINT64 *Datum, void *Buffer, UINT32 BufferLength, UINT32 ByteGranularity, UINT32 BufferOffset)
void	AcpiExSetBufferDatum (UINT64 MergedDatum, void *Buffer, UINT32 BufferLength, UINT32 ByteGranularity, UINT32 BufferOffset)
ACPI_STATUS	AcpiExReadDataFromField (ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **RetBufferDesc)
ACPI_STATUS	AcpiExWriteDataToField (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ResultDesc)
ACPI_STATUS	AcpiExExtractFromField (ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength)
ACPI_STATUS	AcpiExInsertIntoField (ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer, UINT32 BufferLength)
ACPI_STATUS	AcpiExAccessRegion (ACPI_OPERAND_OBJECT *ObjDesc, UINT32 FieldDatumByteOffset, UINT64 *Value, UINT32 ReadWrite)
ACPI_STATUS	AcpiExGetObjectReference (ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ReturnDesc, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExConcatTemplate (ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT *ObjDesc2, ACPI_OPERAND_OBJECT **ActualReturnDesc, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExDoConcatenate (ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT *ObjDesc2, ACPI_OPERAND_OBJECT **ActualReturnDesc, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExDoLogicalNumericOp (UINT16 Opcode, UINT64 Integer0, UINT64 Integer1, BOOLEAN *LogicalResult)
ACPI_STATUS	AcpiExDoLogicalOp (UINT16 Opcode, ACPI_OPERAND_OBJECT *Operand0, ACPI_OPERAND_OBJECT *Operand1, BOOLEAN *LogicalResult)
UINT64	AcpiExDoMathOp (UINT16 Opcode, UINT64 Operand0, UINT64 Operand1)
ACPI_STATUS	AcpiExCreateMutex (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExCreateProcessor (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExCreatePowerResource (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExCreateRegion (UINT8 *AmlStart, UINT32 AmlLength, UINT8 RegionSpace, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExCreateEvent (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExCreateAlias (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExCreateMethod (UINT8 *AmlStart, UINT32 AmlLength, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExLoadOp (ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT *Target, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExLoadTableOp (ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT **ReturnDesc)
ACPI_STATUS	AcpiExUnloadTable (ACPI_OPERAND_OBJECT *DdbHandle)
ACPI_STATUS	AcpiExAcquireMutex (ACPI_OPERAND_OBJECT *TimeDesc, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExAcquireMutexObject (UINT16 Timeout, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_THREAD_ID ThreadId)
ACPI_STATUS	AcpiExReleaseMutex (ACPI_OPERAND_OBJECT *ObjDesc, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExReleaseMutexObject (ACPI_OPERAND_OBJECT *ObjDesc)
void	AcpiExReleaseAllMutexes (ACPI_THREAD_STATE *Thread)
void	AcpiExUnlinkMutex (ACPI_OPERAND_OBJECT *ObjDesc)
ACPI_STATUS	AcpiExPrepCommonFieldObject (ACPI_OPERAND_OBJECT *ObjDesc, UINT8 FieldFlags, UINT8 FieldAttribute, UINT32 FieldBitPosition, UINT32 FieldBitLength)
ACPI_STATUS	AcpiExPrepFieldValue (ACPI_CREATE_FIELD_INFO *Info)
ACPI_STATUS	AcpiExReadSerialBus (ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ReturnBuffer)
ACPI_STATUS	AcpiExWriteSerialBus (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ReturnBuffer)
ACPI_STATUS	AcpiExReadGpio (ACPI_OPERAND_OBJECT *ObjDesc, void *Buffer)
ACPI_STATUS	AcpiExWriteGpio (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *ObjDesc, ACPI_OPERAND_OBJECT **ReturnBuffer)
ACPI_STATUS	AcpiExSystemDoNotifyOp (ACPI_OPERAND_OBJECT *Value, ACPI_OPERAND_OBJECT *ObjDesc)
ACPI_STATUS	AcpiExSystemDoSleep (UINT64 Time)
ACPI_STATUS	AcpiExSystemDoStall (UINT32 Time)
ACPI_STATUS	AcpiExSystemSignalEvent (ACPI_OPERAND_OBJECT *ObjDesc)
ACPI_STATUS	AcpiExSystemWaitEvent (ACPI_OPERAND_OBJECT *Time, ACPI_OPERAND_OBJECT *ObjDesc)
ACPI_STATUS	AcpiExSystemResetEvent (ACPI_OPERAND_OBJECT *ObjDesc)
ACPI_STATUS	AcpiExSystemWaitSemaphore (ACPI_SEMAPHORE Semaphore, UINT16 Timeout)
ACPI_STATUS	AcpiExSystemWaitMutex (ACPI_MUTEX Mutex, UINT16 Timeout)
ACPI_STATUS	AcpiExOpcode_0A_0T_1R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExOpcode_1A_0T_0R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExOpcode_1A_0T_1R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExOpcode_1A_1T_1R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExOpcode_1A_1T_0R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExOpcode_2A_0T_0R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExOpcode_2A_0T_1R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExOpcode_2A_1T_1R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExOpcode_2A_2T_1R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExOpcode_3A_0T_0R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExOpcode_3A_1T_1R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExOpcode_6A_0T_1R (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExResolveToValue (ACPI_OPERAND_OBJECT **StackPtr, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExResolveMultiple (ACPI_WALK_STATE *WalkState, ACPI_OPERAND_OBJECT *Operand, ACPI_OBJECT_TYPE *ReturnType, ACPI_OPERAND_OBJECT **ReturnDesc)
ACPI_STATUS	AcpiExResolveNodeToValue (ACPI_NAMESPACE_NODE **StackPtr, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExResolveOperands (UINT16 Opcode, ACPI_OPERAND_OBJECT **StackPtr, ACPI_WALK_STATE *WalkState)
void	AcpiExDumpOperand (ACPI_OPERAND_OBJECT *ObjDesc, UINT32 Depth)
void	AcpiExDumpOperands (ACPI_OPERAND_OBJECT **Operands, const char *OpcodeName, UINT32 NumOpcodes)
void	AcpiExDumpObjectDescriptor (ACPI_OPERAND_OBJECT *Object, UINT32 Flags)
void	AcpiExDumpNamespaceNode (ACPI_NAMESPACE_NODE *Node, UINT32 Flags)
ACPI_STATUS	AcpiExGetNameString (ACPI_OBJECT_TYPE DataType, UINT8 *InAmlAddress, char **OutNameString, UINT32 *OutNameLength)
ACPI_STATUS	AcpiExStore (ACPI_OPERAND_OBJECT *ValDesc, ACPI_OPERAND_OBJECT *DestDesc, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExStoreObjectToNode (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_NAMESPACE_NODE *Node, ACPI_WALK_STATE *WalkState, UINT8 ImplicitConversion)
ACPI_STATUS	AcpiExResolveObject (ACPI_OPERAND_OBJECT **SourceDescPtr, ACPI_OBJECT_TYPE TargetType, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExStoreObjectToObject (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *DestDesc, ACPI_OPERAND_OBJECT **NewDesc, ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiExStoreBufferToBuffer (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc)
ACPI_STATUS	AcpiExStoreStringToString (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc)
ACPI_STATUS	AcpiExCopyIntegerToIndexField (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc)
ACPI_STATUS	AcpiExCopyIntegerToBankField (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc)
ACPI_STATUS	AcpiExCopyDataToNamedField (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_NAMESPACE_NODE *Node)
ACPI_STATUS	AcpiExCopyIntegerToBufferField (ACPI_OPERAND_OBJECT *SourceDesc, ACPI_OPERAND_OBJECT *TargetDesc)
void	AcpiExEnterInterpreter (void)
void	AcpiExExitInterpreter (void)
BOOLEAN	AcpiExTruncateFor32bitTable (ACPI_OPERAND_OBJECT *ObjDesc)
void	AcpiExAcquireGlobalLock (UINT32 Rule)
void	AcpiExReleaseGlobalLock (UINT32 Rule)
void	AcpiExEisaIdToString (char *Dest, UINT64 CompressedId)
void	AcpiExIntegerToString (char *Dest, UINT64 Value)
void	AcpiExPciClsToString (char *Dest, UINT8 ClassCode[3])
BOOLEAN	AcpiIsValidSpaceId (UINT8 SpaceId)
ACPI_STATUS	AcpiExSystemMemorySpaceHandler (UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
ACPI_STATUS	AcpiExSystemIoSpaceHandler (UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
ACPI_STATUS	AcpiExPciConfigSpaceHandler (UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
ACPI_STATUS	AcpiExCmosSpaceHandler (UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
ACPI_STATUS	AcpiExPciBarSpaceHandler (UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
ACPI_STATUS	AcpiExEmbeddedControllerSpaceHandler (UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
ACPI_STATUS	AcpiExSmBusSpaceHandler (UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)
ACPI_STATUS	AcpiExDataTableSpaceHandler (UINT32 Function, ACPI_PHYSICAL_ADDRESS Address, UINT32 BitWidth, UINT64 *Value, void *HandlerContext, void *RegionContext)

Macro Definition Documentation

ACPI_EXD_ADDRESS

#define ACPI_EXD_ADDRESS   8

Definition at line 86 of file acinterp.h.

ACPI_EXD_BUFFER

#define ACPI_EXD_BUFFER   10

Definition at line 88 of file acinterp.h.

ACPI_EXD_FIELD

#define ACPI_EXD_FIELD   12

Definition at line 90 of file acinterp.h.

ACPI_EXD_HDLR_LIST

#define ACPI_EXD_HDLR_LIST   15 /* Address Handler list */

Definition at line 93 of file acinterp.h.

ACPI_EXD_INIT

#define ACPI_EXD_INIT   0

Definition at line 78 of file acinterp.h.

ACPI_EXD_LIST

#define ACPI_EXD_LIST   14 /* Operand object list */

Definition at line 92 of file acinterp.h.

ACPI_EXD_LITERAL

#define ACPI_EXD_LITERAL   6

Definition at line 84 of file acinterp.h.

ACPI_EXD_NODE

#define ACPI_EXD_NODE   17 /* Namespace Node */

Definition at line 95 of file acinterp.h.

ACPI_EXD_NSOFFSET

#define ACPI_EXD_NSOFFSET

(

f

)

(UINT8) ACPI_OFFSET (ACPI_NAMESPACE_NODE,f)

Definition at line 53 of file acinterp.h.

ACPI_EXD_OFFSET

#define ACPI_EXD_OFFSET

(

f

)

(UINT8) ACPI_OFFSET (ACPI_OPERAND_OBJECT,f)

Definition at line 52 of file acinterp.h.

ACPI_EXD_PACKAGE

#define ACPI_EXD_PACKAGE   11

Definition at line 89 of file acinterp.h.

ACPI_EXD_POINTER

#define ACPI_EXD_POINTER   7

Definition at line 85 of file acinterp.h.

ACPI_EXD_REFERENCE

#define ACPI_EXD_REFERENCE   13

Definition at line 91 of file acinterp.h.

ACPI_EXD_RGN_LIST

#define ACPI_EXD_RGN_LIST   16 /* Region list */

Definition at line 94 of file acinterp.h.

ACPI_EXD_STRING

#define ACPI_EXD_STRING   9

Definition at line 87 of file acinterp.h.

ACPI_EXD_TABLE_SIZE

#define ACPI_EXD_TABLE_SIZE

(

name

)

(sizeof(name) / sizeof (ACPI_EXDUMP_INFO))

Definition at line 54 of file acinterp.h.

ACPI_EXD_TYPE

#define ACPI_EXD_TYPE   1

Definition at line 79 of file acinterp.h.

ACPI_EXD_UINT16

#define ACPI_EXD_UINT16   3

Definition at line 81 of file acinterp.h.

ACPI_EXD_UINT32

#define ACPI_EXD_UINT32   4

Definition at line 82 of file acinterp.h.

ACPI_EXD_UINT64

#define ACPI_EXD_UINT64   5

Definition at line 83 of file acinterp.h.

ACPI_EXD_UINT8

#define ACPI_EXD_UINT8   2

Definition at line 80 of file acinterp.h.

ACPI_EXPLICIT_BYTE_COPY

#define ACPI_EXPLICIT_BYTE_COPY   0x00000000

Definition at line 124 of file acinterp.h.

ACPI_EXPLICIT_CONVERT_DECIMAL

#define ACPI_EXPLICIT_CONVERT_DECIMAL   0x00000003

Definition at line 127 of file acinterp.h.

ACPI_EXPLICIT_CONVERT_HEX

#define ACPI_EXPLICIT_CONVERT_HEX   0x00000001

Definition at line 125 of file acinterp.h.

ACPI_IMPLICIT_CONVERT_HEX

#define ACPI_IMPLICIT_CONVERT_HEX   0x00000002

Definition at line 126 of file acinterp.h.

ACPI_WALK_OPERANDS

#define ACPI_WALK_OPERANDS   (&(WalkState->Operands [WalkState->NumOperands -1]))

Definition at line 48 of file acinterp.h.

Typedef Documentation

ACPI_EXDUMP_INFO

typedef const struct acpi_exdump_info ACPI_EXDUMP_INFO

Function Documentation

AcpiExAccessRegion()

ACPI_STATUS AcpiExAccessRegion	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		UINT32	FieldDatumByteOffset,
		UINT64 *	Value,
		UINT32	ReadWrite
	)

Definition at line 249 of file exfldio.c.

{
    ACPI_STATUS             Status;
    ACPI_OPERAND_OBJECT     *RgnDesc;
    UINT32                  RegionOffset;
 
 
    ACPI_FUNCTION_TRACE (ExAccessRegion);
 
 
    /*
     * Ensure that the region operands are fully evaluated and verify
     * the validity of the request
     */
    Status = AcpiExSetupRegion (ObjDesc, FieldDatumByteOffset);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * The physical address of this field datum is:
     *
     * 1) The base of the region, plus
     * 2) The base offset of the field, plus
     * 3) The current offset into the field
     */
    RgnDesc = ObjDesc->CommonField.RegionObj;
    RegionOffset =
        ObjDesc->CommonField.BaseByteOffset +
        FieldDatumByteOffset;
 
    if ((Function & ACPI_IO_MASK) == ACPI_READ)
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "[READ]"));
    }
    else
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "[WRITE]"));
    }
 
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_BFIELD,
        " Region [%s:%X], Width %X, ByteBase %X, Offset %X at %8.8X%8.8X\n",
        AcpiUtGetRegionName (RgnDesc->Region.SpaceId),
        RgnDesc->Region.SpaceId,
        ObjDesc->CommonField.AccessByteWidth,
        ObjDesc->CommonField.BaseByteOffset,
        FieldDatumByteOffset,
        ACPI_FORMAT_UINT64 (RgnDesc->Region.Address + RegionOffset)));
 
    /* Invoke the appropriate AddressSpace/OpRegion handler */
 
    Status = AcpiEvAddressSpaceDispatch (RgnDesc, ObjDesc,
        Function, RegionOffset,
        ACPI_MUL_8 (ObjDesc->CommonField.AccessByteWidth), Value);
 
    if (ACPI_FAILURE (Status))
    {
        if (Status == AE_NOT_IMPLEMENTED)
        {
            ACPI_ERROR ((AE_INFO,
                "Region %s (ID=%u) not implemented",
                AcpiUtGetRegionName (RgnDesc->Region.SpaceId),
                RgnDesc->Region.SpaceId));
        }
        else if (Status == AE_NOT_EXIST)
        {
            ACPI_ERROR ((AE_INFO,
                "Region %s (ID=%u) has no handler",
                AcpiUtGetRegionName (RgnDesc->Region.SpaceId),
                RgnDesc->Region.SpaceId));
        }
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExFieldDatumIo(), AcpiExReadGpio(), AcpiExReadSerialBus(), AcpiExWriteDataToField(), AcpiExWriteGpio(), and AcpiExWriteSerialBus().

AcpiExAcquireGlobalLock()

void AcpiExAcquireGlobalLock

(

UINT32

Rule

)

Definition at line 225 of file exutils.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (ExAcquireGlobalLock);
 
 
    /* Only use the lock if the AlwaysLock bit is set */
 
    if (!(FieldFlags & AML_FIELD_LOCK_RULE_MASK))
    {
        return_VOID;
    }
 
    /* Attempt to get the global lock, wait forever */
 
    Status = AcpiExAcquireMutexObject (ACPI_WAIT_FOREVER,
        AcpiGbl_GlobalLockMutex, AcpiOsGetThreadId ());
 
    if (ACPI_FAILURE (Status))
    {
        ACPI_EXCEPTION ((AE_INFO, Status,
            "Could not acquire Global Lock"));
    }
 
    return_VOID;
}

Referenced by AcpiExReadDataFromField(), AcpiExReadGpio(), AcpiExReadSerialBus(), AcpiExWriteDataToField(), AcpiExWriteGpio(), and AcpiExWriteSerialBus().

AcpiExAcquireMutex()

ACPI_STATUS AcpiExAcquireMutex	(	ACPI_OPERAND_OBJECT *	TimeDesc,
		ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 248 of file exmutex.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExAcquireMutex, ObjDesc);
 
 
    if (!ObjDesc)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /* Must have a valid thread state struct */
 
    if (!WalkState->Thread)
    {
        ACPI_ERROR ((AE_INFO,
            "Cannot acquire Mutex [%4.4s], null thread info",
            AcpiUtGetNodeName (ObjDesc->Mutex.Node)));
        return_ACPI_STATUS (AE_AML_INTERNAL);
    }
 
    /*
     * Current sync level must be less than or equal to the sync level
     * of the mutex. This mechanism provides some deadlock prevention.
     */
    if (WalkState->Thread->CurrentSyncLevel > ObjDesc->Mutex.SyncLevel)
    {
        ACPI_ERROR ((AE_INFO,
            "Cannot acquire Mutex [%4.4s], "
            "current SyncLevel is too large (%u)",
            AcpiUtGetNodeName (ObjDesc->Mutex.Node),
            WalkState->Thread->CurrentSyncLevel));
        return_ACPI_STATUS (AE_AML_MUTEX_ORDER);
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
        "Acquiring: Mutex SyncLevel %u, Thread SyncLevel %u, "
        "Depth %u TID %p\n",
        ObjDesc->Mutex.SyncLevel, WalkState->Thread->CurrentSyncLevel,
        ObjDesc->Mutex.AcquisitionDepth, WalkState->Thread));
 
    Status = AcpiExAcquireMutexObject ((UINT16) TimeDesc->Integer.Value,
        ObjDesc, WalkState->Thread->ThreadId);
 
    if (ACPI_SUCCESS (Status) && ObjDesc->Mutex.AcquisitionDepth == 1)
    {
        /* Save Thread object, original/current sync levels */
 
        ObjDesc->Mutex.OwnerThread = WalkState->Thread;
        ObjDesc->Mutex.OriginalSyncLevel =
            WalkState->Thread->CurrentSyncLevel;
        WalkState->Thread->CurrentSyncLevel =
            ObjDesc->Mutex.SyncLevel;
 
        /* Link the mutex to the current thread for force-unlock at method exit */
 
        AcpiExLinkMutex (ObjDesc, WalkState->Thread);
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
        "Acquired: Mutex SyncLevel %u, Thread SyncLevel %u, Depth %u\n",
        ObjDesc->Mutex.SyncLevel, WalkState->Thread->CurrentSyncLevel,
        ObjDesc->Mutex.AcquisitionDepth));
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExOpcode_2A_0T_1R().

AcpiExAcquireMutexObject()

ACPI_STATUS AcpiExAcquireMutexObject	(	UINT16	Timeout,
		ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_THREAD_ID	ThreadId
	)

Definition at line 176 of file exmutex.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExAcquireMutexObject, ObjDesc);
 
 
    if (!ObjDesc)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /* Support for multiple acquires by the owning thread */
 
    if (ObjDesc->Mutex.ThreadId == ThreadId)
    {
        /*
         * The mutex is already owned by this thread, just increment the
         * acquisition depth
         */
        ObjDesc->Mutex.AcquisitionDepth++;
        return_ACPI_STATUS (AE_OK);
    }
 
    /* Acquire the mutex, wait if necessary. Special case for Global Lock */
 
    if (ObjDesc == AcpiGbl_GlobalLockMutex)
    {
        Status = AcpiEvAcquireGlobalLock (Timeout);
    }
    else
    {
        Status = AcpiExSystemWaitMutex (ObjDesc->Mutex.OsMutex, Timeout);
    }
 
    if (ACPI_FAILURE (Status))
    {
        /* Includes failure from a timeout on TimeDesc */
 
        return_ACPI_STATUS (Status);
    }
 
    /* Acquired the mutex: update mutex object */
 
    ObjDesc->Mutex.ThreadId = ThreadId;
    ObjDesc->Mutex.AcquisitionDepth = 1;
    ObjDesc->Mutex.OriginalSyncLevel = 0;
    ObjDesc->Mutex.OwnerThread = NULL;      /* Used only for AML Acquire() */
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiAcquireGlobalLock(), AcpiExAcquireGlobalLock(), and AcpiExAcquireMutex().

AcpiExCmosSpaceHandler()

ACPI_STATUS AcpiExCmosSpaceHandler	(	UINT32	Function,
		ACPI_PHYSICAL_ADDRESS	Address,
		UINT32	BitWidth,
		UINT64 *	Value,
		void *	HandlerContext,
		void *	RegionContext
	)

Definition at line 505 of file exregion.c.

{
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE (ExCmosSpaceHandler);
 
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvInstallSpaceHandler().

AcpiExCommonBufferSetup()

ACPI_STATUS AcpiExCommonBufferSetup	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		UINT32	BufferLength,
		UINT32 *	DatumCount
	)

AcpiExConcatTemplate()

ACPI_STATUS AcpiExConcatTemplate	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT *	ObjDesc2,
		ACPI_OPERAND_OBJECT **	ActualReturnDesc,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 388 of file exconcat.c.

{
    ACPI_STATUS             Status;
    ACPI_OPERAND_OBJECT     *ReturnDesc;
    UINT8                   *NewBuf;
    UINT8                   *EndTag;
    ACPI_SIZE               Length0;
    ACPI_SIZE               Length1;
    ACPI_SIZE               NewLength;
 
 
    ACPI_FUNCTION_TRACE (ExConcatTemplate);
 
 
    /*
     * Find the EndTag descriptor in each resource template.
     * Note1: returned pointers point TO the EndTag, not past it.
     * Note2: zero-length buffers are allowed; treated like one EndTag
     */
 
    /* Get the length of the first resource template */
 
    Status = AcpiUtGetResourceEndTag (Operand0, &EndTag);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Length0 = ACPI_PTR_DIFF (EndTag, Operand0->Buffer.Pointer);
 
    /* Get the length of the second resource template */
 
    Status = AcpiUtGetResourceEndTag (Operand1, &EndTag);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Length1 = ACPI_PTR_DIFF (EndTag, Operand1->Buffer.Pointer);
 
    /* Combine both lengths, minimum size will be 2 for EndTag */
 
    NewLength = Length0 + Length1 + sizeof (AML_RESOURCE_END_TAG);
 
    /* Create a new buffer object for the result (with one EndTag) */
 
    ReturnDesc = AcpiUtCreateBufferObject (NewLength);
    if (!ReturnDesc)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /*
     * Copy the templates to the new buffer, 0 first, then 1 follows. One
     * EndTag descriptor is copied from Operand1.
     */
    NewBuf = ReturnDesc->Buffer.Pointer;
    memcpy (NewBuf, Operand0->Buffer.Pointer, Length0);
    memcpy (NewBuf + Length0, Operand1->Buffer.Pointer, Length1);
 
    /* Insert EndTag and set the checksum to zero, means "ignore checksum" */
 
    NewBuf[NewLength - 1] = 0;
    NewBuf[NewLength - 2] = ACPI_RESOURCE_NAME_END_TAG | 1;
 
    /* Return the completed resource template */
 
    *ActualReturnDesc = ReturnDesc;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExOpcode_2A_1T_1R().

AcpiExConvertToBuffer()

ACPI_STATUS AcpiExConvertToBuffer	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT **	ResultDesc
	)

Definition at line 224 of file exconvrt.c.

{
    ACPI_OPERAND_OBJECT     *ReturnDesc;
    UINT8                   *NewBuf;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExConvertToBuffer, ObjDesc);
 
 
    switch (ObjDesc->Common.Type)
    {
    case ACPI_TYPE_BUFFER:
 
        /* No conversion necessary */
 
        *ResultDesc = ObjDesc;
        return_ACPI_STATUS (AE_OK);
 
 
    case ACPI_TYPE_INTEGER:
        /*
         * Create a new Buffer object.
         * Need enough space for one integer
         */
        ReturnDesc = AcpiUtCreateBufferObject (AcpiGbl_IntegerByteWidth);
        if (!ReturnDesc)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        /* Copy the integer to the buffer, LSB first */
 
        NewBuf = ReturnDesc->Buffer.Pointer;
        memcpy (NewBuf, &ObjDesc->Integer.Value, AcpiGbl_IntegerByteWidth);
        break;
 
    case ACPI_TYPE_STRING:
        /*
         * Create a new Buffer object
         * Size will be the string length
         *
         * NOTE: Add one to the string length to include the null terminator.
         * The ACPI spec is unclear on this subject, but there is existing
         * ASL/AML code that depends on the null being transferred to the new
         * buffer.
         */
        ReturnDesc = AcpiUtCreateBufferObject ((ACPI_SIZE)
            ObjDesc->String.Length + 1);
        if (!ReturnDesc)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        /* Copy the string to the buffer */
 
        NewBuf = ReturnDesc->Buffer.Pointer;
        strncpy ((char *) NewBuf, (char *) ObjDesc->String.Pointer,
            ObjDesc->String.Length);
        break;
 
    default:
 
        return_ACPI_STATUS (AE_TYPE);
    }
 
    /* Mark buffer initialized */
 
    ReturnDesc->Common.Flags |= AOPOBJ_DATA_VALID;
    *ResultDesc = ReturnDesc;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExConvertToTargetType(), AcpiExDoConcatenate(), AcpiExDoLogicalOp(), AcpiExOpcode_1A_1T_1R(), AcpiExResolveOperands(), and AcpiNsConvertToBuffer().

AcpiExConvertToInteger()

ACPI_STATUS AcpiExConvertToInteger	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT **	ResultDesc,
		UINT32	ImplicitConversion
	)

Definition at line 79 of file exconvrt.c.

{
    ACPI_OPERAND_OBJECT     *ReturnDesc;
    UINT8                   *Pointer;
    UINT64                  Result;
    UINT32                  i;
    UINT32                  Count;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExConvertToInteger, ObjDesc);
 
 
    switch (ObjDesc->Common.Type)
    {
    case ACPI_TYPE_INTEGER:
 
        /* No conversion necessary */
 
        *ResultDesc = ObjDesc;
        return_ACPI_STATUS (AE_OK);
 
    case ACPI_TYPE_BUFFER:
    case ACPI_TYPE_STRING:
 
        /* Note: Takes advantage of common buffer/string fields */
 
        Pointer = ObjDesc->Buffer.Pointer;
        Count   = ObjDesc->Buffer.Length;
        break;
 
    default:
 
        return_ACPI_STATUS (AE_TYPE);
    }
 
    /*
     * Convert the buffer/string to an integer. Note that both buffers and
     * strings are treated as raw data - we don't convert ascii to hex for
     * strings.
     *
     * There are two terminating conditions for the loop:
     * 1) The size of an integer has been reached, or
     * 2) The end of the buffer or string has been reached
     */
    Result = 0;
 
    /* String conversion is different than Buffer conversion */
 
    switch (ObjDesc->Common.Type)
    {
    case ACPI_TYPE_STRING:
        /*
         * Convert string to an integer - for most cases, the string must be
         * hexadecimal as per the ACPI specification. The only exception (as
         * of ACPI 3.0) is that the ToInteger() operator allows both decimal
         * and hexadecimal strings (hex prefixed with "0x").
         *
         * Explicit conversion is used only by ToInteger.
         * All other string-to-integer conversions are implicit conversions.
         */
        if (ImplicitConversion)
        {
            Result = AcpiUtImplicitStrtoul64 (ACPI_CAST_PTR (char, Pointer));
        }
        else
        {
            Result = AcpiUtExplicitStrtoul64 (ACPI_CAST_PTR (char, Pointer));
        }
        break;
 
    case ACPI_TYPE_BUFFER:
 
        /* Check for zero-length buffer */
 
        if (!Count)
        {
            return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);
        }
 
        /* Transfer no more than an integer's worth of data */
 
        if (Count > AcpiGbl_IntegerByteWidth)
        {
            Count = AcpiGbl_IntegerByteWidth;
        }
 
        /*
         * Convert buffer to an integer - we simply grab enough raw data
         * from the buffer to fill an integer
         */
        for (i = 0; i < Count; i++)
        {
            /*
             * Get next byte and shift it into the Result.
             * Little endian is used, meaning that the first byte of the buffer
             * is the LSB of the integer
             */
            Result |= (((UINT64) Pointer[i]) << (i * 8));
        }
        break;
 
    default:
 
        /* No other types can get here */
 
        break;
    }
 
    /* Create a new integer */
 
    ReturnDesc = AcpiUtCreateIntegerObject (Result);
    if (!ReturnDesc)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
        ACPI_FORMAT_UINT64 (Result)));
 
    /* Save the Result */
 
    (void) AcpiExTruncateFor32bitTable (ReturnDesc);
    *ResultDesc = ReturnDesc;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiDsGetPredicateValue(), AcpiExConvertToTargetType(), AcpiExDoConcatenate(), AcpiExDoLogicalOp(), AcpiExOpcode_1A_1T_1R(), and AcpiExResolveOperands().

AcpiExConvertToString()

ACPI_STATUS AcpiExConvertToString	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT **	ResultDesc,
		UINT32	Type
	)

Definition at line 440 of file exconvrt.c.

{
    ACPI_OPERAND_OBJECT     *ReturnDesc;
    UINT8                   *NewBuf;
    UINT32                  i;
    UINT32                  StringLength = 0;
    UINT16                  Base = 16;
    UINT8                   Separator = ',';
 
 
    ACPI_FUNCTION_TRACE_PTR (ExConvertToString, ObjDesc);
 
 
    switch (ObjDesc->Common.Type)
    {
    case ACPI_TYPE_STRING:
 
        /* No conversion necessary */
 
        *ResultDesc = ObjDesc;
        return_ACPI_STATUS (AE_OK);
 
    case ACPI_TYPE_INTEGER:
 
        switch (Type)
        {
        case ACPI_EXPLICIT_CONVERT_DECIMAL:
            /*
             * From ToDecimalString, integer source.
             *
             * Make room for the maximum decimal number size
             */
            StringLength = ACPI_MAX_DECIMAL_DIGITS;
            Base = 10;
            break;
 
        default:
 
            /* Two hex string characters for each integer byte */
 
            StringLength = ACPI_MUL_2 (AcpiGbl_IntegerByteWidth);
            break;
        }
 
        /*
         * Create a new String
         * Need enough space for one ASCII integer (plus null terminator)
         */
        ReturnDesc = AcpiUtCreateStringObject ((ACPI_SIZE) StringLength);
        if (!ReturnDesc)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        NewBuf = ReturnDesc->Buffer.Pointer;
 
        /* Convert integer to string */
 
        StringLength = AcpiExConvertToAscii (
            ObjDesc->Integer.Value, Base, NewBuf, AcpiGbl_IntegerByteWidth);
 
        /* Null terminate at the correct place */
 
        ReturnDesc->String.Length = StringLength;
        NewBuf [StringLength] = 0;
        break;
 
    case ACPI_TYPE_BUFFER:
 
        /* Setup string length, base, and separator */
 
        switch (Type)
        {
        case ACPI_EXPLICIT_CONVERT_DECIMAL: /* Used by ToDecimalString */
            /*
             * Explicit conversion from the ToDecimalString ASL operator.
             *
             * From ACPI: "If the input is a buffer, it is converted to a
             * a string of decimal values separated by commas."
             */
            Base = 10;
 
            /*
             * Calculate the final string length. Individual string values
             * are variable length (include separator for each)
             */
            for (i = 0; i < ObjDesc->Buffer.Length; i++)
            {
                if (ObjDesc->Buffer.Pointer[i] >= 100)
                {
                    StringLength += 4;
                }
                else if (ObjDesc->Buffer.Pointer[i] >= 10)
                {
                    StringLength += 3;
                }
                else
                {
                    StringLength += 2;
                }
            }
            break;
 
        case ACPI_IMPLICIT_CONVERT_HEX:
            /*
             * Implicit buffer-to-string conversion
             *
             * From the ACPI spec:
             * "The entire contents of the buffer are converted to a string of
             * two-character hexadecimal numbers, each separated by a space."
             *
             * Each hex number is prefixed with 0x (11/2018)
             */
            Separator = ' ';
            StringLength = (ObjDesc->Buffer.Length * 5);
            break;
 
        case ACPI_EXPLICIT_CONVERT_HEX:
            /*
             * Explicit conversion from the ToHexString ASL operator.
             *
             * From ACPI: "If Data is a buffer, it is converted to a string of
             * hexadecimal values separated by commas."
             *
             * Each hex number is prefixed with 0x (11/2018)
             */
            Separator = ',';
            StringLength = (ObjDesc->Buffer.Length * 5);
            break;
 
        default:
            return_ACPI_STATUS (AE_BAD_PARAMETER);
        }
 
        /*
         * Create a new string object and string buffer
         * (-1 because of extra separator included in StringLength from above)
         * Allow creation of zero-length strings from zero-length buffers.
         */
        if (StringLength)
        {
            StringLength--;
        }
 
        ReturnDesc = AcpiUtCreateStringObject ((ACPI_SIZE) StringLength);
        if (!ReturnDesc)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        NewBuf = ReturnDesc->Buffer.Pointer;
 
        /*
         * Convert buffer bytes to hex or decimal values
         * (separated by commas or spaces)
         */
        for (i = 0; i < ObjDesc->Buffer.Length; i++)
        {
            if (Base == 16)
            {
                /* Emit 0x prefix for explicit/implicit hex conversion */
 
                *NewBuf++ = '0';
                *NewBuf++ = 'x';
            }
 
            NewBuf += AcpiExConvertToAscii (
                (UINT64) ObjDesc->Buffer.Pointer[i], Base, NewBuf, 1);
 
            /* Each digit is separated by either a comma or space */
 
            *NewBuf++ = Separator;
        }
 
        /*
         * Null terminate the string
         * (overwrites final comma/space from above)
         */
        if (ObjDesc->Buffer.Length)
        {
            NewBuf--;
        }
        *NewBuf = 0;
        break;
 
    default:
 
        return_ACPI_STATUS (AE_TYPE);
    }
 
    *ResultDesc = ReturnDesc;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExConvertToTargetType(), AcpiExDoConcatenate(), AcpiExDoLogicalOp(), AcpiExOpcode_1A_1T_1R(), AcpiExResolveOperands(), and AcpiNsConvertToString().

AcpiExConvertToTargetType()

ACPI_STATUS AcpiExConvertToTargetType	(	ACPI_OBJECT_TYPE	DestinationType,
		ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_OPERAND_OBJECT **	ResultDesc,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 654 of file exconvrt.c.

{
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE (ExConvertToTargetType);
 
 
    /* Default behavior */
 
    *ResultDesc = SourceDesc;
 
    /*
     * If required by the target,
     * perform implicit conversion on the source before we store it.
     */
    switch (GET_CURRENT_ARG_TYPE (WalkState->OpInfo->RuntimeArgs))
    {
    case ARGI_SIMPLE_TARGET:
    case ARGI_FIXED_TARGET:
    case ARGI_INTEGER_REF:      /* Handles Increment, Decrement cases */
 
        switch (DestinationType)
        {
        case ACPI_TYPE_LOCAL_REGION_FIELD:
            /*
             * Named field can always handle conversions
             */
            break;
 
        default:
 
            /* No conversion allowed for these types */
 
            if (DestinationType != SourceDesc->Common.Type)
            {
                ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
                    "Explicit operator, will store (%s) over existing type (%s)\n",
                    AcpiUtGetObjectTypeName (SourceDesc),
                    AcpiUtGetTypeName (DestinationType)));
                Status = AE_TYPE;
            }
        }
        break;
 
    case ARGI_TARGETREF:
    case ARGI_STORE_TARGET:
 
        switch (DestinationType)
        {
        case ACPI_TYPE_INTEGER:
        case ACPI_TYPE_BUFFER_FIELD:
        case ACPI_TYPE_LOCAL_BANK_FIELD:
        case ACPI_TYPE_LOCAL_INDEX_FIELD:
            /*
             * These types require an Integer operand. We can convert
             * a Buffer or a String to an Integer if necessary.
             */
            Status = AcpiExConvertToInteger (SourceDesc, ResultDesc,
                ACPI_IMPLICIT_CONVERSION);
            break;
 
        case ACPI_TYPE_STRING:
            /*
             * The operand must be a String. We can convert an
             * Integer or Buffer if necessary
             */
            Status = AcpiExConvertToString (SourceDesc, ResultDesc,
                ACPI_IMPLICIT_CONVERT_HEX);
            break;
 
        case ACPI_TYPE_BUFFER:
            /*
             * The operand must be a Buffer. We can convert an
             * Integer or String if necessary
             */
            Status = AcpiExConvertToBuffer (SourceDesc, ResultDesc);
            break;
 
        default:
 
            ACPI_ERROR ((AE_INFO,
                "Bad destination type during conversion: 0x%X",
                DestinationType));
            Status = AE_AML_INTERNAL;
            break;
        }
        break;
 
    case ARGI_REFERENCE:
        /*
         * CreateXxxxField cases - we are storing the field object into the name
         */
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO,
            "Unknown Target type ID 0x%X AmlOpcode 0x%X DestType %s",
            GET_CURRENT_ARG_TYPE (WalkState->OpInfo->RuntimeArgs),
            WalkState->Opcode, AcpiUtGetTypeName (DestinationType)));
        Status = AE_AML_INTERNAL;
    }
 
    /*
     * Source-to-Target conversion semantics:
     *
     * If conversion to the target type cannot be performed, then simply
     * overwrite the target with the new object and type.
     */
    if (Status == AE_TYPE)
    {
        Status = AE_OK;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExStoreObjectToObject().

AcpiExCopyDataToNamedField()

ACPI_STATUS AcpiExCopyDataToNamedField	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_NAMESPACE_NODE *	Node
	)

AcpiExCopyIntegerToBankField()

ACPI_STATUS AcpiExCopyIntegerToBankField	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_OPERAND_OBJECT *	TargetDesc
	)

AcpiExCopyIntegerToBufferField()

ACPI_STATUS AcpiExCopyIntegerToBufferField	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_OPERAND_OBJECT *	TargetDesc
	)

AcpiExCopyIntegerToIndexField()

ACPI_STATUS AcpiExCopyIntegerToIndexField	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_OPERAND_OBJECT *	TargetDesc
	)

AcpiExCreateAlias()

ACPI_STATUS AcpiExCreateAlias

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 68 of file excreate.c.

{
    ACPI_NAMESPACE_NODE     *TargetNode;
    ACPI_NAMESPACE_NODE     *AliasNode;
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE (ExCreateAlias);
 
 
    /* Get the source/alias operands (both namespace nodes) */
 
    AliasNode =  (ACPI_NAMESPACE_NODE *) WalkState->Operands[0];
    TargetNode = (ACPI_NAMESPACE_NODE *) WalkState->Operands[1];
 
    if ((TargetNode->Type == ACPI_TYPE_LOCAL_ALIAS)  ||
        (TargetNode->Type == ACPI_TYPE_LOCAL_METHOD_ALIAS))
    {
        /*
         * Dereference an existing alias so that we don't create a chain
         * of aliases. With this code, we guarantee that an alias is
         * always exactly one level of indirection away from the
         * actual aliased name.
         */
        TargetNode = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, TargetNode->Object);
    }
 
    /* Ensure that the target node is valid */
 
    if (!TargetNode)
    {
        return_ACPI_STATUS (AE_NULL_OBJECT);
    }
 
    /* Construct the alias object (a namespace node) */
 
    switch (TargetNode->Type)
    {
    case ACPI_TYPE_METHOD:
        /*
         * Control method aliases need to be differentiated with
         * a special type
         */
        AliasNode->Type = ACPI_TYPE_LOCAL_METHOD_ALIAS;
        break;
 
    default:
        /*
         * All other object types.
         *
         * The new alias has the type ALIAS and points to the original
         * NS node, not the object itself.
         */
        AliasNode->Type = ACPI_TYPE_LOCAL_ALIAS;
        AliasNode->Object = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, TargetNode);
        break;
    }
 
    /* Since both operands are Nodes, we don't need to delete them */
 
    AliasNode->Object = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, TargetNode);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsLoad2EndOp().

AcpiExCreateEvent()

ACPI_STATUS AcpiExCreateEvent

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 147 of file excreate.c.

{
    ACPI_STATUS             Status;
    ACPI_OPERAND_OBJECT     *ObjDesc;
 
 
    ACPI_FUNCTION_TRACE (ExCreateEvent);
 
 
    ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_EVENT);
    if (!ObjDesc)
    {
        Status = AE_NO_MEMORY;
        goto Cleanup;
    }
 
    /*
     * Create the actual OS semaphore, with zero initial units -- meaning
     * that the event is created in an unsignalled state
     */
    Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 0,
        &ObjDesc->Event.OsSemaphore);
    if (ACPI_FAILURE (Status))
    {
        goto Cleanup;
    }
 
    /* Attach object to the Node */
 
    Status = AcpiNsAttachObject (
        (ACPI_NAMESPACE_NODE *) WalkState->Operands[0],
        ObjDesc, ACPI_TYPE_EVENT);
 
Cleanup:
    /*
     * Remove local reference to the object (on error, will cause deletion
     * of both object and semaphore if present.)
     */
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsLoad2EndOp().

AcpiExCreateMethod()

ACPI_STATUS AcpiExCreateMethod	(	UINT8 *	AmlStart,
		UINT32	AmlLength,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 484 of file excreate.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status;
    UINT8                   MethodFlags;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExCreateMethod, WalkState);
 
 
    /* Create a new method object */
 
    ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD);
    if (!ObjDesc)
    {
       Status = AE_NO_MEMORY;
       goto Exit;
    }
 
    /* Save the method's AML pointer and length  */
 
    ObjDesc->Method.AmlStart = AmlStart;
    ObjDesc->Method.AmlLength = AmlLength;
    ObjDesc->Method.Node = Operand[0];
 
    /*
     * Disassemble the method flags. Split off the ArgCount, Serialized
     * flag, and SyncLevel for efficiency.
     */
    MethodFlags = (UINT8) Operand[1]->Integer.Value;
    ObjDesc->Method.ParamCount = (UINT8)
        (MethodFlags & AML_METHOD_ARG_COUNT);
 
    /*
     * Get the SyncLevel. If method is serialized, a mutex will be
     * created for this method when it is parsed.
     */
    if (MethodFlags & AML_METHOD_SERIALIZED)
    {
        ObjDesc->Method.InfoFlags = ACPI_METHOD_SERIALIZED;
 
        /*
         * ACPI 1.0: SyncLevel = 0
         * ACPI 2.0: SyncLevel = SyncLevel in method declaration
         */
        ObjDesc->Method.SyncLevel = (UINT8)
            ((MethodFlags & AML_METHOD_SYNC_LEVEL) >> 4);
    }
 
    /* Attach the new object to the method Node */
 
    Status = AcpiNsAttachObject ((ACPI_NAMESPACE_NODE *) Operand[0],
        ObjDesc, ACPI_TYPE_METHOD);
 
    /* Remove local reference to the object */
 
    AcpiUtRemoveReference (ObjDesc);
 
Exit:
    /* Remove a reference to the operand */
 
    AcpiUtRemoveReference (Operand[1]);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsLoad1EndOp(), and AcpiDsLoad2EndOp().

AcpiExCreateMutex()

ACPI_STATUS AcpiExCreateMutex

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 206 of file excreate.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_OPERAND_OBJECT     *ObjDesc;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExCreateMutex, ACPI_WALK_OPERANDS);
 
 
    /* Create the new mutex object */
 
    ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_MUTEX);
    if (!ObjDesc)
    {
        Status = AE_NO_MEMORY;
        goto Cleanup;
    }
 
    /* Create the actual OS Mutex */
 
    Status = AcpiOsCreateMutex (&ObjDesc->Mutex.OsMutex);
    if (ACPI_FAILURE (Status))
    {
        goto Cleanup;
    }
 
    /* Init object and attach to NS node */
 
    ObjDesc->Mutex.SyncLevel = (UINT8) WalkState->Operands[1]->Integer.Value;
    ObjDesc->Mutex.Node = (ACPI_NAMESPACE_NODE *) WalkState->Operands[0];
 
    Status = AcpiNsAttachObject (
        ObjDesc->Mutex.Node, ObjDesc, ACPI_TYPE_MUTEX);
 
 
Cleanup:
    /*
     * Remove local reference to the object (on error, will cause deletion
     * of both object and semaphore if present.)
     */
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsLoad2EndOp().

AcpiExCreatePowerResource()

ACPI_STATUS AcpiExCreatePowerResource

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 433 of file excreate.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_STATUS             Status;
    ACPI_OPERAND_OBJECT     *ObjDesc;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExCreatePowerResource, WalkState);
 
 
    /* Create the power resource object */
 
    ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_POWER);
    if (!ObjDesc)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /* Initialize the power object from the operands */
 
    ObjDesc->PowerResource.SystemLevel = (UINT8) Operand[1]->Integer.Value;
    ObjDesc->PowerResource.ResourceOrder = (UINT16) Operand[2]->Integer.Value;
 
    /* Install the  power resource object in the parent Node */
 
    Status = AcpiNsAttachObject ((ACPI_NAMESPACE_NODE *) Operand[0],
        ObjDesc, ACPI_TYPE_POWER);
 
    /* Remove local reference to the object */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsLoad2EndOp().

AcpiExCreateProcessor()

ACPI_STATUS AcpiExCreateProcessor

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 381 of file excreate.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExCreateProcessor, WalkState);
 
 
    /* Create the processor object */
 
    ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_PROCESSOR);
    if (!ObjDesc)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /* Initialize the processor object from the operands */
 
    ObjDesc->Processor.ProcId = (UINT8) Operand[1]->Integer.Value;
    ObjDesc->Processor.Length = (UINT8) Operand[3]->Integer.Value;
    ObjDesc->Processor.Address = (ACPI_IO_ADDRESS) Operand[2]->Integer.Value;
 
    /* Install the processor object in the parent Node */
 
    Status = AcpiNsAttachObject ((ACPI_NAMESPACE_NODE *) Operand[0],
        ObjDesc, ACPI_TYPE_PROCESSOR);
 
    /* Remove local reference to the object */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsLoad2EndOp().

AcpiExCreateRegion()

ACPI_STATUS AcpiExCreateRegion	(	UINT8 *	AmlStart,
		UINT32	AmlLength,
		UINT8	RegionSpace,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 268 of file excreate.c.

{
    ACPI_STATUS             Status;
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_NAMESPACE_NODE     *Node;
    ACPI_OPERAND_OBJECT     *RegionObj2;
 
 
    ACPI_FUNCTION_TRACE (ExCreateRegion);
 
 
    /* Get the Namespace Node */
 
    Node = WalkState->Op->Common.Node;
 
    /*
     * If the region object is already attached to this node,
     * just return
     */
    if (AcpiNsGetAttachedObject (Node))
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    /*
     * Space ID must be one of the predefined IDs, or in the user-defined
     * range
     */
    if (!AcpiIsValidSpaceId (SpaceId))
    {
        /*
         * Print an error message, but continue. We don't want to abort
         * a table load for this exception. Instead, if the region is
         * actually used at runtime, abort the executing method.
         */
        ACPI_ERROR ((AE_INFO,
            "Invalid/unknown Address Space ID: 0x%2.2X", SpaceId));
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "Region Type - %s (0x%X)\n",
        AcpiUtGetRegionName (SpaceId), SpaceId));
 
    /* Create the region descriptor */
 
    ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_REGION);
    if (!ObjDesc)
    {
        Status = AE_NO_MEMORY;
        goto Cleanup;
    }
 
    /*
     * Remember location in AML stream of address & length
     * operands since they need to be evaluated at run time.
     */
    RegionObj2 = AcpiNsGetSecondaryObject (ObjDesc);
    RegionObj2->Extra.AmlStart = AmlStart;
    RegionObj2->Extra.AmlLength = AmlLength;
    RegionObj2->Extra.Method_REG = NULL;
    if (WalkState->ScopeInfo)
    {
        RegionObj2->Extra.ScopeNode = WalkState->ScopeInfo->Scope.Node;
    }
    else
    {
        RegionObj2->Extra.ScopeNode = Node;
    }
 
    /* Init the region from the operands */
 
    ObjDesc->Region.SpaceId = SpaceId;
    ObjDesc->Region.Address = 0;
    ObjDesc->Region.Length = 0;
    ObjDesc->Region.Pointer = NULL;
    ObjDesc->Region.Node = Node;
    ObjDesc->Region.Handler = NULL;
    ObjDesc->Common.Flags &=
        ~(AOPOBJ_SETUP_COMPLETE | AOPOBJ_REG_CONNECTED |
          AOPOBJ_OBJECT_INITIALIZED);
 
    /* Install the new region object in the parent Node */
 
    Status = AcpiNsAttachObject (Node, ObjDesc, ACPI_TYPE_REGION);
 
 
Cleanup:
 
    /* Remove local reference to the object */
 
    AcpiUtRemoveReference (ObjDesc);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsLoad1EndOp(), and AcpiDsLoad2EndOp().

AcpiExDataTableSpaceHandler()

ACPI_STATUS AcpiExDataTableSpaceHandler	(	UINT32	Function,
		ACPI_PHYSICAL_ADDRESS	Address,
		UINT32	BitWidth,
		UINT64 *	Value,
		void *	HandlerContext,
		void *	RegionContext
	)

Definition at line 579 of file exregion.c.

{
    ACPI_DATA_TABLE_MAPPING *Mapping;
    char                    *Pointer;
 
 
    ACPI_FUNCTION_TRACE (ExDataTableSpaceHandler);
 
 
    Mapping = (ACPI_DATA_TABLE_MAPPING *) RegionContext;
    Pointer = ACPI_CAST_PTR (char, Mapping->Pointer) +
        (Address - ACPI_PTR_TO_PHYSADDR (Mapping->Pointer));
 
    /*
     * Perform the memory read or write. The BitWidth was already
     * validated.
     */
    switch (Function)
    {
    case ACPI_READ:
 
        memcpy (ACPI_CAST_PTR (char, Value), Pointer, ACPI_DIV_8 (BitWidth));
        break;
 
    case ACPI_WRITE:
 
        memcpy (Pointer, ACPI_CAST_PTR (char, Value), ACPI_DIV_8 (BitWidth));
        break;
 
    default:
 
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiEvInstallSpaceHandler().

AcpiExDoConcatenate()

ACPI_STATUS AcpiExDoConcatenate	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT *	ObjDesc2,
		ACPI_OPERAND_OBJECT **	ActualReturnDesc,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 85 of file exconcat.c.

{
    ACPI_OPERAND_OBJECT     *LocalOperand0 = Operand0;
    ACPI_OPERAND_OBJECT     *LocalOperand1 = Operand1;
    ACPI_OPERAND_OBJECT     *TempOperand1 = NULL;
    ACPI_OPERAND_OBJECT     *ReturnDesc;
    char                    *Buffer;
    ACPI_OBJECT_TYPE        Operand0Type;
    ACPI_OBJECT_TYPE        Operand1Type;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (ExDoConcatenate);
 
 
    /* Operand 0 preprocessing */
 
    switch (Operand0->Common.Type)
    {
    case ACPI_TYPE_INTEGER:
    case ACPI_TYPE_STRING:
    case ACPI_TYPE_BUFFER:
 
        Operand0Type = Operand0->Common.Type;
        break;
 
    default:
 
        /* For all other types, get the "object type" string */
 
        Status = AcpiExConvertToObjectTypeString (
            Operand0, &LocalOperand0);
        if (ACPI_FAILURE (Status))
        {
            goto Cleanup;
        }
 
        Operand0Type = ACPI_TYPE_STRING;
        break;
    }
 
    /* Operand 1 preprocessing */
 
    switch (Operand1->Common.Type)
    {
    case ACPI_TYPE_INTEGER:
    case ACPI_TYPE_STRING:
    case ACPI_TYPE_BUFFER:
 
        Operand1Type = Operand1->Common.Type;
        break;
 
    default:
 
        /* For all other types, get the "object type" string */
 
        Status = AcpiExConvertToObjectTypeString (
            Operand1, &LocalOperand1);
        if (ACPI_FAILURE (Status))
        {
            goto Cleanup;
        }
 
        Operand1Type = ACPI_TYPE_STRING;
        break;
    }
 
    /*
     * Convert the second operand if necessary. The first operand (0)
     * determines the type of the second operand (1) (See the Data Types
     * section of the ACPI specification). Both object types are
     * guaranteed to be either Integer/String/Buffer by the operand
     * resolution mechanism.
     */
    switch (Operand0Type)
    {
    case ACPI_TYPE_INTEGER:
 
        Status = AcpiExConvertToInteger (LocalOperand1, &TempOperand1,
            ACPI_IMPLICIT_CONVERSION);
        break;
 
    case ACPI_TYPE_BUFFER:
 
        Status = AcpiExConvertToBuffer (LocalOperand1, &TempOperand1);
        break;
 
    case ACPI_TYPE_STRING:
 
        switch (Operand1Type)
        {
        case ACPI_TYPE_INTEGER:
        case ACPI_TYPE_STRING:
        case ACPI_TYPE_BUFFER:
 
            /* Other types have already been converted to string */
 
            Status = AcpiExConvertToString (
                LocalOperand1, &TempOperand1, ACPI_IMPLICIT_CONVERT_HEX);
            break;
 
        default:
 
            Status = AE_OK;
            break;
        }
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Invalid object type: 0x%X",
            Operand0->Common.Type));
        Status = AE_AML_INTERNAL;
    }
 
    if (ACPI_FAILURE (Status))
    {
        goto Cleanup;
    }
 
    /* Take care with any newly created operand objects */
 
    if ((LocalOperand1 != Operand1) &&
        (LocalOperand1 != TempOperand1))
    {
        AcpiUtRemoveReference (LocalOperand1);
    }
 
    LocalOperand1 = TempOperand1;
 
    /*
     * Both operands are now known to be the same object type
     * (Both are Integer, String, or Buffer), and we can now perform
     * the concatenation.
     *
     * There are three cases to handle, as per the ACPI spec:
     *
     * 1) Two Integers concatenated to produce a new Buffer
     * 2) Two Strings concatenated to produce a new String
     * 3) Two Buffers concatenated to produce a new Buffer
     */
    switch (Operand0Type)
    {
    case ACPI_TYPE_INTEGER:
 
        /* Result of two Integers is a Buffer */
        /* Need enough buffer space for two integers */
 
        ReturnDesc = AcpiUtCreateBufferObject (
            (ACPI_SIZE) ACPI_MUL_2 (AcpiGbl_IntegerByteWidth));
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        Buffer = (char *) ReturnDesc->Buffer.Pointer;
 
        /* Copy the first integer, LSB first */
 
        memcpy (Buffer, &Operand0->Integer.Value,
            AcpiGbl_IntegerByteWidth);
 
        /* Copy the second integer (LSB first) after the first */
 
        memcpy (Buffer + AcpiGbl_IntegerByteWidth,
            &LocalOperand1->Integer.Value, AcpiGbl_IntegerByteWidth);
        break;
 
    case ACPI_TYPE_STRING:
 
        /* Result of two Strings is a String */
 
        ReturnDesc = AcpiUtCreateStringObject (
            ((ACPI_SIZE) LocalOperand0->String.Length +
            LocalOperand1->String.Length));
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        Buffer = ReturnDesc->String.Pointer;
 
        /* Concatenate the strings */
 
        strcpy (Buffer, LocalOperand0->String.Pointer);
        strcat (Buffer, LocalOperand1->String.Pointer);
        break;
 
    case ACPI_TYPE_BUFFER:
 
        /* Result of two Buffers is a Buffer */
 
        ReturnDesc = AcpiUtCreateBufferObject (
            ((ACPI_SIZE) Operand0->Buffer.Length +
            LocalOperand1->Buffer.Length));
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        Buffer = (char *) ReturnDesc->Buffer.Pointer;
 
        /* Concatenate the buffers */
 
        memcpy (Buffer, Operand0->Buffer.Pointer,
            Operand0->Buffer.Length);
        memcpy (Buffer + Operand0->Buffer.Length,
            LocalOperand1->Buffer.Pointer,
            LocalOperand1->Buffer.Length);
        break;
 
    default:
 
        /* Invalid object type, should not happen here */
 
        ACPI_ERROR ((AE_INFO, "Invalid object type: 0x%X",
            Operand0->Common.Type));
        Status = AE_AML_INTERNAL;
        goto Cleanup;
    }
 
    *ActualReturnDesc = ReturnDesc;
 
Cleanup:
    if (LocalOperand0 != Operand0)
    {
        AcpiUtRemoveReference (LocalOperand0);
    }
 
    if (LocalOperand1 != Operand1)
    {
        AcpiUtRemoveReference (LocalOperand1);
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExOpcode_2A_1T_1R().

AcpiExDoDebugObject()

void AcpiExDoDebugObject	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		UINT32	Level,
		UINT32	Index
	)

Definition at line 77 of file exdebug.c.

{
    UINT32                  i;
    UINT32                  Timer;
    ACPI_OPERAND_OBJECT     *ObjectDesc;
    UINT32                  Value;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExDoDebugObject, SourceDesc);
 
 
    /* Output must be enabled via the DebugObject global or the DbgLevel */
 
    if (!AcpiGbl_EnableAmlDebugObject &&
        !(AcpiDbgLevel & ACPI_LV_DEBUG_OBJECT))
    {
        return_VOID;
    }
 
    /* Newline -- don't emit the line header */
 
    if (SourceDesc &&
        (ACPI_GET_DESCRIPTOR_TYPE (SourceDesc) == ACPI_DESC_TYPE_OPERAND) &&
        (SourceDesc->Common.Type == ACPI_TYPE_STRING))
    {
        if ((SourceDesc->String.Length == 1) &&
            (*SourceDesc->String.Pointer == '\n'))
        {
            AcpiOsPrintf ("\n");
            return_VOID;
        }
    }
 
    /*
     * Print line header as long as we are not in the middle of an
     * object display
     */
    if (!((Level > 0) && Index == 0))
    {
        if (AcpiGbl_DisplayDebugTimer)
        {
            /*
             * We will emit the current timer value (in microseconds) with each
             * debug output. Only need the lower 26 bits. This allows for 67
             * million microseconds or 67 seconds before rollover.
             *
             * Convert 100 nanosecond units to microseconds
             */
            Timer = ((UINT32) AcpiOsGetTimer () / 10);
            Timer &= 0x03FFFFFF;
 
            AcpiOsPrintf ("ACPI Debug: T=0x%8.8X %*s", Timer, Level, " ");
        }
        else
        {
            AcpiOsPrintf ("ACPI Debug: %*s", Level, " ");
        }
    }
 
    /* Display the index for package output only */
 
    if (Index > 0)
    {
       AcpiOsPrintf ("(%.2u) ", Index - 1);
    }
 
    if (!SourceDesc)
    {
        AcpiOsPrintf ("[Null Object]\n");
        return_VOID;
    }
 
    if (ACPI_GET_DESCRIPTOR_TYPE (SourceDesc) == ACPI_DESC_TYPE_OPERAND)
    {
        /* No object type prefix needed for integers and strings */
 
        if ((SourceDesc->Common.Type != ACPI_TYPE_INTEGER) &&
            (SourceDesc->Common.Type != ACPI_TYPE_STRING))
        {
            AcpiOsPrintf ("%s  ", AcpiUtGetObjectTypeName (SourceDesc));
        }
 
        if (!AcpiUtValidInternalObject (SourceDesc))
        {
           AcpiOsPrintf ("%p, Invalid Internal Object!\n", SourceDesc);
           return_VOID;
        }
    }
    else if (ACPI_GET_DESCRIPTOR_TYPE (SourceDesc) == ACPI_DESC_TYPE_NAMED)
    {
        AcpiOsPrintf ("%s  (Node %p)\n",
            AcpiUtGetTypeName (((ACPI_NAMESPACE_NODE *) SourceDesc)->Type),
                SourceDesc);
        return_VOID;
    }
    else
    {
        return_VOID;
    }
 
    /* SourceDesc is of type ACPI_DESC_TYPE_OPERAND */
 
    switch (SourceDesc->Common.Type)
    {
    case ACPI_TYPE_INTEGER:
 
        /* Output correct integer width */
 
        if (AcpiGbl_IntegerByteWidth == 4)
        {
            AcpiOsPrintf ("0x%8.8X\n",
                (UINT32) SourceDesc->Integer.Value);
        }
        else
        {
            AcpiOsPrintf ("0x%8.8X%8.8X\n",
                ACPI_FORMAT_UINT64 (SourceDesc->Integer.Value));
        }
        break;
 
    case ACPI_TYPE_BUFFER:
 
        AcpiOsPrintf ("[0x%.2X]\n", (UINT32) SourceDesc->Buffer.Length);
        AcpiUtDumpBuffer (SourceDesc->Buffer.Pointer,
            (SourceDesc->Buffer.Length < 256) ?
                SourceDesc->Buffer.Length : 256, DB_BYTE_DISPLAY, 0);
        break;
 
    case ACPI_TYPE_STRING:
 
        AcpiOsPrintf ("\"%s\"\n", SourceDesc->String.Pointer);
        break;
 
    case ACPI_TYPE_PACKAGE:
 
        AcpiOsPrintf ("(Contains 0x%.2X Elements):\n",
            SourceDesc->Package.Count);
 
        /* Output the entire contents of the package */
 
        for (i = 0; i < SourceDesc->Package.Count; i++)
        {
            AcpiExDoDebugObject (SourceDesc->Package.Elements[i],
                Level + 4, i + 1);
        }
        break;
 
    case ACPI_TYPE_LOCAL_REFERENCE:
 
        AcpiOsPrintf ("[%s] ", AcpiUtGetReferenceName (SourceDesc));
 
        /* Decode the reference */
 
        switch (SourceDesc->Reference.Class)
        {
        case ACPI_REFCLASS_INDEX:
 
            AcpiOsPrintf ("0x%X\n", SourceDesc->Reference.Value);
            break;
 
        case ACPI_REFCLASS_TABLE:
 
            /* Case for DdbHandle */
 
            AcpiOsPrintf ("Table Index 0x%X\n", SourceDesc->Reference.Value);
            return_VOID;
 
        default:
 
            break;
        }
 
        AcpiOsPrintf ("  ");
 
        /* Check for valid node first, then valid object */
 
        if (SourceDesc->Reference.Node)
        {
            if (ACPI_GET_DESCRIPTOR_TYPE (SourceDesc->Reference.Node) !=
                ACPI_DESC_TYPE_NAMED)
            {
                AcpiOsPrintf (" %p - Not a valid namespace node\n",
                    SourceDesc->Reference.Node);
            }
            else
            {
                AcpiOsPrintf ("Node %p [%4.4s] ", SourceDesc->Reference.Node,
                    (SourceDesc->Reference.Node)->Name.Ascii);
 
                switch ((SourceDesc->Reference.Node)->Type)
                {
                /* These types have no attached object */
 
                case ACPI_TYPE_DEVICE:
                    AcpiOsPrintf ("Device\n");
                    break;
 
                case ACPI_TYPE_THERMAL:
                    AcpiOsPrintf ("Thermal Zone\n");
                    break;
 
                default:
 
                    AcpiExDoDebugObject ((SourceDesc->Reference.Node)->Object,
                        Level + 4, 0);
                    break;
                }
            }
        }
        else if (SourceDesc->Reference.Object)
        {
            if (ACPI_GET_DESCRIPTOR_TYPE (SourceDesc->Reference.Object) ==
                ACPI_DESC_TYPE_NAMED)
            {
                /* Reference object is a namespace node */
 
                AcpiExDoDebugObject (ACPI_CAST_PTR (ACPI_OPERAND_OBJECT,
                    SourceDesc->Reference.Object),
                    Level + 4, 0);
            }
            else
            {
                ObjectDesc = SourceDesc->Reference.Object;
                Value = SourceDesc->Reference.Value;
 
                switch (ObjectDesc->Common.Type)
                {
                case ACPI_TYPE_BUFFER:
 
                    AcpiOsPrintf ("Buffer[%u] = 0x%2.2X\n",
                        Value, *SourceDesc->Reference.IndexPointer);
                    break;
 
                case ACPI_TYPE_STRING:
 
                    AcpiOsPrintf ("String[%u] = \"%c\" (0x%2.2X)\n",
                        Value, *SourceDesc->Reference.IndexPointer,
                        *SourceDesc->Reference.IndexPointer);
                    break;
 
                case ACPI_TYPE_PACKAGE:
 
                    AcpiOsPrintf ("Package[%u] = ", Value);
                    if (!(*SourceDesc->Reference.Where))
                    {
                        AcpiOsPrintf ("[Uninitialized Package Element]\n");
                    }
                    else
                    {
                        AcpiExDoDebugObject (*SourceDesc->Reference.Where,
                            Level+4, 0);
                    }
                    break;
 
                default:
 
                    AcpiOsPrintf ("Unknown Reference object type %X\n",
                        ObjectDesc->Common.Type);
                    break;
                }
            }
        }
        break;
 
    default:
 
        AcpiOsPrintf ("(Descriptor %p)\n", SourceDesc);
        break;
    }
 
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EXEC, "\n"));
    return_VOID;
}

Referenced by AcpiExDoDebugObject().

AcpiExDoLogicalNumericOp()

ACPI_STATUS AcpiExDoLogicalNumericOp	(	UINT16	Opcode,
		UINT64	Integer0,
		UINT64	Integer1,
		BOOLEAN *	LogicalResult
	)

Definition at line 262 of file exmisc.c.

{
    ACPI_STATUS             Status = AE_OK;
    BOOLEAN                 LocalResult = FALSE;
 
 
    ACPI_FUNCTION_TRACE (ExDoLogicalNumericOp);
 
 
    switch (Opcode)
    {
    case AML_LOGICAL_AND_OP:        /* LAnd (Integer0, Integer1) */
 
        if (Integer0 && Integer1)
        {
            LocalResult = TRUE;
        }
        break;
 
    case AML_LOGICAL_OR_OP:         /* LOr (Integer0, Integer1) */
 
        if (Integer0 || Integer1)
        {
            LocalResult = TRUE;
        }
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO,
            "Invalid numeric logical opcode: %X", Opcode));
        Status = AE_AML_INTERNAL;
        break;
    }
 
    /* Return the logical result and status */
 
    *LogicalResult = LocalResult;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExOpcode_2A_0T_1R().

AcpiExDoLogicalOp()

ACPI_STATUS AcpiExDoLogicalOp	(	UINT16	Opcode,
		ACPI_OPERAND_OBJECT *	Operand0,
		ACPI_OPERAND_OBJECT *	Operand1,
		BOOLEAN *	LogicalResult
	)

Definition at line 335 of file exmisc.c.

{
    ACPI_OPERAND_OBJECT     *LocalOperand1 = Operand1;
    UINT64                  Integer0;
    UINT64                  Integer1;
    UINT32                  Length0;
    UINT32                  Length1;
    ACPI_STATUS             Status = AE_OK;
    BOOLEAN                 LocalResult = FALSE;
    int                     Compare;
 
 
    ACPI_FUNCTION_TRACE (ExDoLogicalOp);
 
 
    /*
     * Convert the second operand if necessary. The first operand
     * determines the type of the second operand, (See the Data Types
     * section of the ACPI 3.0+ specification.)  Both object types are
     * guaranteed to be either Integer/String/Buffer by the operand
     * resolution mechanism.
     */
    switch (Operand0->Common.Type)
    {
    case ACPI_TYPE_INTEGER:
 
        Status = AcpiExConvertToInteger (Operand1, &LocalOperand1,
            ACPI_IMPLICIT_CONVERSION);
        break;
 
    case ACPI_TYPE_STRING:
 
        Status = AcpiExConvertToString (
            Operand1, &LocalOperand1, ACPI_IMPLICIT_CONVERT_HEX);
        break;
 
    case ACPI_TYPE_BUFFER:
 
        Status = AcpiExConvertToBuffer (Operand1, &LocalOperand1);
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO,
            "Invalid object type for logical operator: %X",
            Operand0->Common.Type));
        Status = AE_AML_INTERNAL;
        break;
    }
 
    if (ACPI_FAILURE (Status))
    {
        goto Cleanup;
    }
 
    /*
     * Two cases: 1) Both Integers, 2) Both Strings or Buffers
     */
    if (Operand0->Common.Type == ACPI_TYPE_INTEGER)
    {
        /*
         * 1) Both operands are of type integer
         *    Note: LocalOperand1 may have changed above
         */
        Integer0 = Operand0->Integer.Value;
        Integer1 = LocalOperand1->Integer.Value;
 
        switch (Opcode)
        {
        case AML_LOGICAL_EQUAL_OP:          /* LEqual (Operand0, Operand1) */
 
            if (Integer0 == Integer1)
            {
                LocalResult = TRUE;
            }
            break;
 
        case AML_LOGICAL_GREATER_OP:        /* LGreater (Operand0, Operand1) */
 
            if (Integer0 > Integer1)
            {
                LocalResult = TRUE;
            }
            break;
 
        case AML_LOGICAL_LESS_OP:           /* LLess (Operand0, Operand1) */
 
            if (Integer0 < Integer1)
            {
                LocalResult = TRUE;
            }
            break;
 
        default:
 
            ACPI_ERROR ((AE_INFO,
                "Invalid comparison opcode: %X", Opcode));
            Status = AE_AML_INTERNAL;
            break;
        }
    }
    else
    {
        /*
         * 2) Both operands are Strings or both are Buffers
         *    Note: Code below takes advantage of common Buffer/String
         *          object fields. LocalOperand1 may have changed above. Use
         *          memcmp to handle nulls in buffers.
         */
        Length0 = Operand0->Buffer.Length;
        Length1 = LocalOperand1->Buffer.Length;
 
        /* Lexicographic compare: compare the data bytes */
 
        Compare = memcmp (Operand0->Buffer.Pointer,
            LocalOperand1->Buffer.Pointer,
            (Length0 > Length1) ? Length1 : Length0);
 
        switch (Opcode)
        {
        case AML_LOGICAL_EQUAL_OP:      /* LEqual (Operand0, Operand1) */
 
            /* Length and all bytes must be equal */
 
            if ((Length0 == Length1) &&
                (Compare == 0))
            {
                /* Length and all bytes match ==> TRUE */
 
                LocalResult = TRUE;
            }
            break;
 
        case AML_LOGICAL_GREATER_OP:    /* LGreater (Operand0, Operand1) */
 
            if (Compare > 0)
            {
                LocalResult = TRUE;
                goto Cleanup;   /* TRUE */
            }
            if (Compare < 0)
            {
                goto Cleanup;   /* FALSE */
            }
 
            /* Bytes match (to shortest length), compare lengths */
 
            if (Length0 > Length1)
            {
                LocalResult = TRUE;
            }
            break;
 
        case AML_LOGICAL_LESS_OP:       /* LLess (Operand0, Operand1) */
 
            if (Compare > 0)
            {
                goto Cleanup;   /* FALSE */
            }
            if (Compare < 0)
            {
                LocalResult = TRUE;
                goto Cleanup;   /* TRUE */
            }
 
            /* Bytes match (to shortest length), compare lengths */
 
            if (Length0 < Length1)
            {
                LocalResult = TRUE;
            }
            break;
 
        default:
 
            ACPI_ERROR ((AE_INFO,
                "Invalid comparison opcode: %X", Opcode));
            Status = AE_AML_INTERNAL;
            break;
        }
    }
 
Cleanup:
 
    /* New object was created if implicit conversion performed - delete */
 
    if (LocalOperand1 != Operand1)
    {
        AcpiUtRemoveReference (LocalOperand1);
    }
 
    /* Return the logical result and status */
 
    *LogicalResult = LocalResult;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExDoMatch(), and AcpiExOpcode_2A_0T_1R().

AcpiExDoMathOp()

UINT64 AcpiExDoMathOp	(	UINT16	Opcode,
		UINT64	Operand0,
		UINT64	Operand1
	)

Definition at line 167 of file exmisc.c.

{
 
    ACPI_FUNCTION_ENTRY ();
 
 
    switch (Opcode)
    {
    case AML_ADD_OP:                /* Add (Integer0, Integer1, Result) */
 
        return (Integer0 + Integer1);
 
    case AML_BIT_AND_OP:            /* And (Integer0, Integer1, Result) */
 
        return (Integer0 & Integer1);
 
    case AML_BIT_NAND_OP:           /* NAnd (Integer0, Integer1, Result) */
 
        return (~(Integer0 & Integer1));
 
    case AML_BIT_OR_OP:             /* Or (Integer0, Integer1, Result) */
 
        return (Integer0 | Integer1);
 
    case AML_BIT_NOR_OP:            /* NOr (Integer0, Integer1, Result) */
 
        return (~(Integer0 | Integer1));
 
    case AML_BIT_XOR_OP:            /* XOr (Integer0, Integer1, Result) */
 
        return (Integer0 ^ Integer1);
 
    case AML_MULTIPLY_OP:           /* Multiply (Integer0, Integer1, Result) */
 
        return (Integer0 * Integer1);
 
    case AML_SHIFT_LEFT_OP:         /* ShiftLeft (Operand, ShiftCount, Result)*/
 
        /*
         * We need to check if the shiftcount is larger than the integer bit
         * width since the behavior of this is not well-defined in the C language.
         */
        if (Integer1 >= AcpiGbl_IntegerBitWidth)
        {
            return (0);
        }
        return (Integer0 << Integer1);
 
    case AML_SHIFT_RIGHT_OP:        /* ShiftRight (Operand, ShiftCount, Result) */
 
        /*
         * We need to check if the shiftcount is larger than the integer bit
         * width since the behavior of this is not well-defined in the C language.
         */
        if (Integer1 >= AcpiGbl_IntegerBitWidth)
        {
            return (0);
        }
        return (Integer0 >> Integer1);
 
    case AML_SUBTRACT_OP:           /* Subtract (Integer0, Integer1, Result) */
 
        return (Integer0 - Integer1);
 
    default:
 
        return (0);
    }
}

Referenced by AcpiExOpcode_2A_1T_1R().

AcpiExDumpNamespaceNode()

void AcpiExDumpNamespaceNode	(	ACPI_NAMESPACE_NODE *	Node,
		UINT32	Flags
	)

AcpiExDumpObjectDescriptor()

void AcpiExDumpObjectDescriptor	(	ACPI_OPERAND_OBJECT *	Object,
		UINT32	Flags
	)

AcpiExDumpOperand()

void AcpiExDumpOperand	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		UINT32	Depth
	)

AcpiExDumpOperands()

void AcpiExDumpOperands	(	ACPI_OPERAND_OBJECT **	Operands,
		const char *	OpcodeName,
		UINT32	NumOpcodes
	)

AcpiExEisaIdToString()

void AcpiExEisaIdToString	(	char *	Dest,
		UINT64	CompressedId
	)

Definition at line 366 of file exutils.c.

{
    UINT32                  SwappedId;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* The EISAID should be a 32-bit integer */
 
    if (CompressedId > ACPI_UINT32_MAX)
    {
        ACPI_WARNING ((AE_INFO,
            "Expected EISAID is larger than 32 bits: "
            "0x%8.8X%8.8X, truncating",
            ACPI_FORMAT_UINT64 (CompressedId)));
    }
 
    /* Swap ID to big-endian to get contiguous bits */
 
    SwappedId = AcpiUtDwordByteSwap ((UINT32) CompressedId);
 
    /* First 3 bytes are uppercase letters. Next 4 bytes are hexadecimal */
 
    OutString[0] = (char) (0x40 + (((unsigned long) SwappedId >> 26) & 0x1F));
    OutString[1] = (char) (0x40 + ((SwappedId >> 21) & 0x1F));
    OutString[2] = (char) (0x40 + ((SwappedId >> 16) & 0x1F));
    OutString[3] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 12);
    OutString[4] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 8);
    OutString[5] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 4);
    OutString[6] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 0);
    OutString[7] = 0;
}

Referenced by AcpiUtExecute_CID(), and AcpiUtExecute_HID().

AcpiExEmbeddedControllerSpaceHandler()

ACPI_STATUS AcpiExEmbeddedControllerSpaceHandler	(	UINT32	Function,
		ACPI_PHYSICAL_ADDRESS	Address,
		UINT32	BitWidth,
		UINT64 *	Value,
		void *	HandlerContext,
		void *	RegionContext
	)

AcpiExEnterInterpreter()

void AcpiExEnterInterpreter

(

void

)

Definition at line 91 of file exutils.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (ExEnterInterpreter);
 
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER);
    if (ACPI_FAILURE (Status))
    {
        ACPI_ERROR ((AE_INFO, "Could not acquire AML Interpreter mutex"));
    }
    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
    if (ACPI_FAILURE (Status))
    {
        ACPI_ERROR ((AE_INFO, "Could not acquire AML Namespace mutex"));
    }
 
    return_VOID;
}

Referenced by AcpiAcquireGlobalLock(), AcpiDsMethodError(), AcpiDsTerminateControlMethod(), AcpiEvAddressSpaceDispatch(), AcpiEvaluateObject(), AcpiEvInitializeRegion(), AcpiExLoadOp(), AcpiExLoadTableOp(), AcpiExSystemDoSleep(), AcpiExSystemWaitMutex(), AcpiExSystemWaitSemaphore(), AcpiExUnloadTable(), AcpiNsEvaluate(), AcpiNsInitOneObject(), AcpiNsLoadTable(), AcpiNsOneCompleteParse(), AcpiPsExecuteTable(), and AcpiPsParseAml().

AcpiExExitInterpreter()

void AcpiExExitInterpreter

(

void

)

Definition at line 139 of file exutils.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (ExExitInterpreter);
 
 
    Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
    if (ACPI_FAILURE (Status))
    {
        ACPI_ERROR ((AE_INFO, "Could not release AML Namespace mutex"));
    }
    Status = AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
    if (ACPI_FAILURE (Status))
    {
        ACPI_ERROR ((AE_INFO, "Could not release AML Interpreter mutex"));
    }
 
    return_VOID;
}

Referenced by AcpiAcquireGlobalLock(), AcpiDsMethodError(), AcpiDsTerminateControlMethod(), AcpiEvAddressSpaceDispatch(), AcpiEvaluateObject(), AcpiEvInitializeRegion(), AcpiExLoadOp(), AcpiExLoadTableOp(), AcpiExSystemDoSleep(), AcpiExSystemWaitMutex(), AcpiExSystemWaitSemaphore(), AcpiExUnloadTable(), AcpiNsEvaluate(), AcpiNsInitOneObject(), AcpiNsLoadTable(), AcpiNsOneCompleteParse(), AcpiPsExecuteTable(), and AcpiPsParseAml().

AcpiExExtractFromField()

ACPI_STATUS AcpiExExtractFromField	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		void *	Buffer,
		UINT32	BufferLength
	)

Definition at line 723 of file exfldio.c.

{
    ACPI_STATUS             Status;
    UINT64                  RawDatum;
    UINT64                  MergedDatum;
    UINT32                  FieldOffset = 0;
    UINT32                  BufferOffset = 0;
    UINT32                  BufferTailBits;
    UINT32                  DatumCount;
    UINT32                  FieldDatumCount;
    UINT32                  AccessBitWidth;
    UINT32                  i;
 
 
    ACPI_FUNCTION_TRACE (ExExtractFromField);
 
 
    /* Validate target buffer and clear it */
 
    if (BufferLength <
        ACPI_ROUND_BITS_UP_TO_BYTES (ObjDesc->CommonField.BitLength))
    {
        ACPI_ERROR ((AE_INFO,
            "Field size %u (bits) is too large for buffer (%u)",
            ObjDesc->CommonField.BitLength, BufferLength));
 
        return_ACPI_STATUS (AE_BUFFER_OVERFLOW);
    }
 
    memset (Buffer, 0, BufferLength);
    AccessBitWidth = ACPI_MUL_8 (ObjDesc->CommonField.AccessByteWidth);
 
    /* Handle the simple case here */
 
    if ((ObjDesc->CommonField.StartFieldBitOffset == 0) &&
        (ObjDesc->CommonField.BitLength == AccessBitWidth))
    {
        if (BufferLength >= sizeof (UINT64))
        {
            Status = AcpiExFieldDatumIo (ObjDesc, 0, Buffer, ACPI_READ);
        }
        else
        {
            /* Use RawDatum (UINT64) to handle buffers < 64 bits */
 
            Status = AcpiExFieldDatumIo (ObjDesc, 0, &RawDatum, ACPI_READ);
            memcpy (Buffer, &RawDatum, BufferLength);
        }
 
        return_ACPI_STATUS (Status);
    }
 
/* TBD: Move to common setup code */
 
    /* Field algorithm is limited to sizeof(UINT64), truncate if needed */
 
    if (ObjDesc->CommonField.AccessByteWidth > sizeof (UINT64))
    {
        ObjDesc->CommonField.AccessByteWidth = sizeof (UINT64);
        AccessBitWidth = sizeof (UINT64) * 8;
    }
 
    /* Compute the number of datums (access width data items) */
 
    DatumCount = ACPI_ROUND_UP_TO (
        ObjDesc->CommonField.BitLength, AccessBitWidth);
 
    FieldDatumCount = ACPI_ROUND_UP_TO (
        ObjDesc->CommonField.BitLength +
        ObjDesc->CommonField.StartFieldBitOffset, AccessBitWidth);
 
    /* Priming read from the field */
 
    Status = AcpiExFieldDatumIo (ObjDesc, FieldOffset, &RawDatum, ACPI_READ);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
    MergedDatum = RawDatum >> ObjDesc->CommonField.StartFieldBitOffset;
 
    /* Read the rest of the field */
 
    for (i = 1; i < FieldDatumCount; i++)
    {
        /* Get next input datum from the field */
 
        FieldOffset += ObjDesc->CommonField.AccessByteWidth;
        Status = AcpiExFieldDatumIo (
            ObjDesc, FieldOffset, &RawDatum, ACPI_READ);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        /*
         * Merge with previous datum if necessary.
         *
         * Note: Before the shift, check if the shift value will be larger than
         * the integer size. If so, there is no need to perform the operation.
         * This avoids the differences in behavior between different compilers
         * concerning shift values larger than the target data width.
         */
        if (AccessBitWidth - ObjDesc->CommonField.StartFieldBitOffset <
            ACPI_INTEGER_BIT_SIZE)
        {
            MergedDatum |= RawDatum <<
                (AccessBitWidth - ObjDesc->CommonField.StartFieldBitOffset);
        }
 
        if (i == DatumCount)
        {
            break;
        }
 
        /* Write merged datum to target buffer */
 
        memcpy (((char *) Buffer) + BufferOffset, &MergedDatum,
            ACPI_MIN(ObjDesc->CommonField.AccessByteWidth,
                BufferLength - BufferOffset));
 
        BufferOffset += ObjDesc->CommonField.AccessByteWidth;
        MergedDatum = RawDatum >> ObjDesc->CommonField.StartFieldBitOffset;
    }
 
    /* Mask off any extra bits in the last datum */
 
    BufferTailBits = ObjDesc->CommonField.BitLength % AccessBitWidth;
    if (BufferTailBits)
    {
        MergedDatum &= ACPI_MASK_BITS_ABOVE (BufferTailBits);
    }
 
    /* Write the last datum to the buffer */
 
    memcpy (((char *) Buffer) + BufferOffset, &MergedDatum,
        ACPI_MIN(ObjDesc->CommonField.AccessByteWidth,
            BufferLength - BufferOffset));
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExFieldDatumIo(), and AcpiExReadDataFromField().

AcpiExGetBufferDatum()

void AcpiExGetBufferDatum	(	UINT64 *	Datum,
		void *	Buffer,
		UINT32	BufferLength,
		UINT32	ByteGranularity,
		UINT32	BufferOffset
	)

AcpiExGetNameString()

ACPI_STATUS AcpiExGetNameString	(	ACPI_OBJECT_TYPE	DataType,
		UINT8 *	InAmlAddress,
		char **	OutNameString,
		UINT32 *	OutNameLength
	)

Definition at line 278 of file exnames.c.

{
    ACPI_STATUS             Status = AE_OK;
    UINT8                   *AmlAddress = InAmlAddress;
    char                    *NameString = NULL;
    UINT32                  NumSegments;
    UINT32                  PrefixCount = 0;
    BOOLEAN                 HasPrefix = FALSE;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExGetNameString, AmlAddress);
 
 
    if (ACPI_TYPE_LOCAL_REGION_FIELD == DataType   ||
        ACPI_TYPE_LOCAL_BANK_FIELD == DataType     ||
        ACPI_TYPE_LOCAL_INDEX_FIELD == DataType)
    {
        /* Disallow prefixes for types associated with FieldUnit names */
 
        NameString = AcpiExAllocateNameString (0, 1);
        if (!NameString)
        {
            Status = AE_NO_MEMORY;
        }
        else
        {
            Status = AcpiExNameSegment (&AmlAddress, NameString);
        }
    }
    else
    {
        /*
         * DataType is not a field name.
         * Examine first character of name for root or parent prefix operators
         */
        switch (*AmlAddress)
        {
        case AML_ROOT_PREFIX:
 
            ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "RootPrefix(\\) at %p\n",
                AmlAddress));
 
            /*
             * Remember that we have a RootPrefix --
             * see comment in AcpiExAllocateNameString()
             */
            AmlAddress++;
            PrefixCount = ACPI_UINT32_MAX;
            HasPrefix = TRUE;
            break;
 
        case AML_PARENT_PREFIX:
 
            /* Increment past possibly multiple parent prefixes */
 
            do
            {
                ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "ParentPrefix (^) at %p\n",
                    AmlAddress));
 
                AmlAddress++;
                PrefixCount++;
 
            } while (*AmlAddress == AML_PARENT_PREFIX);
 
            HasPrefix = TRUE;
            break;
 
        default:
 
            /* Not a prefix character */
 
            break;
        }
 
        /* Examine first character of name for name segment prefix operator */
 
        switch (*AmlAddress)
        {
        case AML_DUAL_NAME_PREFIX:
 
            ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "DualNamePrefix at %p\n",
                AmlAddress));
 
            AmlAddress++;
            NameString = AcpiExAllocateNameString (PrefixCount, 2);
            if (!NameString)
            {
                Status = AE_NO_MEMORY;
                break;
            }
 
            /* Indicate that we processed a prefix */
 
            HasPrefix = TRUE;
 
            Status = AcpiExNameSegment (&AmlAddress, NameString);
            if (ACPI_SUCCESS (Status))
            {
                Status = AcpiExNameSegment (&AmlAddress, NameString);
            }
            break;
 
        case AML_MULTI_NAME_PREFIX:
 
            ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "MultiNamePrefix at %p\n",
                AmlAddress));
 
            /* Fetch count of segments remaining in name path */
 
            AmlAddress++;
            NumSegments = *AmlAddress;
 
            NameString = AcpiExAllocateNameString (
                PrefixCount, NumSegments);
            if (!NameString)
            {
                Status = AE_NO_MEMORY;
                break;
            }
 
            /* Indicate that we processed a prefix */
 
            AmlAddress++;
            HasPrefix = TRUE;
 
            while (NumSegments &&
                    (Status = AcpiExNameSegment (&AmlAddress, NameString)) ==
                        AE_OK)
            {
                NumSegments--;
            }
 
            break;
 
        case 0:
 
            /* NullName valid as of 8-12-98 ASL/AML Grammar Update */
 
            if (PrefixCount == ACPI_UINT32_MAX)
            {
                ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
                    "NameSeg is \"\\\" followed by NULL\n"));
            }
 
            /* Consume the NULL byte */
 
            AmlAddress++;
            NameString = AcpiExAllocateNameString (PrefixCount, 0);
            if (!NameString)
            {
                Status = AE_NO_MEMORY;
                break;
            }
 
            break;
 
        default:
 
            /* Name segment string */
 
            NameString = AcpiExAllocateNameString (PrefixCount, 1);
            if (!NameString)
            {
                Status = AE_NO_MEMORY;
                break;
            }
 
            Status = AcpiExNameSegment (&AmlAddress, NameString);
            break;
        }
    }
 
    if (AE_CTRL_PENDING == Status && HasPrefix)
    {
        /* Ran out of segments after processing a prefix */
 
        ACPI_ERROR ((AE_INFO,
            "Malformed Name at %p", NameString));
        Status = AE_AML_BAD_NAME;
    }
 
    if (ACPI_FAILURE (Status))
    {
        if (NameString)
        {
            ACPI_FREE (NameString);
        }
        return_ACPI_STATUS (Status);
    }
 
    *OutNameString = NameString;
    *OutNameLength = (UINT32) (AmlAddress - InAmlAddress);
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsCreateOperand().

AcpiExGetObjectReference()

ACPI_STATUS AcpiExGetObjectReference	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT **	ReturnDesc,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 70 of file exmisc.c.

{
    ACPI_OPERAND_OBJECT     *ReferenceObj;
    ACPI_OPERAND_OBJECT     *ReferencedObj;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExGetObjectReference, ObjDesc);
 
 
    *ReturnDesc = NULL;
 
    switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc))
    {
    case ACPI_DESC_TYPE_OPERAND:
 
        if (ObjDesc->Common.Type != ACPI_TYPE_LOCAL_REFERENCE)
        {
            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
 
        /*
         * Must be a reference to a Local or Arg
         */
        switch (ObjDesc->Reference.Class)
        {
        case ACPI_REFCLASS_LOCAL:
        case ACPI_REFCLASS_ARG:
        case ACPI_REFCLASS_DEBUG:
 
            /* The referenced object is the pseudo-node for the local/arg */
 
            ReferencedObj = ObjDesc->Reference.Object;
            break;
 
        default:
 
            ACPI_ERROR ((AE_INFO, "Invalid Reference Class 0x%2.2X",
                ObjDesc->Reference.Class));
            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
        break;
 
    case ACPI_DESC_TYPE_NAMED:
        /*
         * A named reference that has already been resolved to a Node
         */
        ReferencedObj = ObjDesc;
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Invalid descriptor type 0x%X",
            ACPI_GET_DESCRIPTOR_TYPE (ObjDesc)));
        return_ACPI_STATUS (AE_TYPE);
    }
 
 
    /* Create a new reference object */
 
    ReferenceObj = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_REFERENCE);
    if (!ReferenceObj)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    ReferenceObj->Reference.Class = ACPI_REFCLASS_REFOF;
    ReferenceObj->Reference.Object = ReferencedObj;
    *ReturnDesc = ReferenceObj;
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
        "Object %p Type [%s], returning Reference %p\n",
        ObjDesc, AcpiUtGetObjectTypeName (ObjDesc), *ReturnDesc));
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExOpcode_1A_0T_1R(), and AcpiExOpcode_1A_1T_1R().

AcpiExGetProtocolBufferLength()

ACPI_STATUS AcpiExGetProtocolBufferLength	(	UINT32	ProtocolId,
		UINT32 *	ReturnLength
	)

Definition at line 111 of file exfield.c.

{
 
    if ((ProtocolId > ACPI_MAX_PROTOCOL_ID) ||
        (AcpiProtocolLengths[ProtocolId] == ACPI_INVALID_PROTOCOL_ID))
    {
        ACPI_ERROR ((AE_INFO,
            "Invalid Field/AccessAs protocol ID: 0x%4.4X", ProtocolId));
 
        return (AE_AML_PROTOCOL);
    }
 
    *ReturnLength = AcpiProtocolLengths[ProtocolId];
    return (AE_OK);
}

Referenced by AcpiExReadSerialBus(), and AcpiExWriteSerialBus().

AcpiExInsertIntoField()

ACPI_STATUS AcpiExInsertIntoField	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		void *	Buffer,
		UINT32	BufferLength
	)

Definition at line 883 of file exfldio.c.

{
    void                    *NewBuffer;
    ACPI_STATUS             Status;
    UINT64                  Mask;
    UINT64                  WidthMask;
    UINT64                  MergedDatum;
    UINT64                  RawDatum = 0;
    UINT32                  FieldOffset = 0;
    UINT32                  BufferOffset = 0;
    UINT32                  BufferTailBits;
    UINT32                  DatumCount;
    UINT32                  FieldDatumCount;
    UINT32                  AccessBitWidth;
    UINT32                  RequiredLength;
    UINT32                  i;
 
 
    ACPI_FUNCTION_TRACE (ExInsertIntoField);
 
 
    /* Validate input buffer */
 
    NewBuffer = NULL;
    RequiredLength = ACPI_ROUND_BITS_UP_TO_BYTES (
        ObjDesc->CommonField.BitLength);
 
    /*
     * We must have a buffer that is at least as long as the field
     * we are writing to. This is because individual fields are
     * indivisible and partial writes are not supported -- as per
     * the ACPI specification.
     */
    if (BufferLength < RequiredLength)
    {
        /* We need to create a new buffer */
 
        NewBuffer = ACPI_ALLOCATE_ZEROED (RequiredLength);
        if (!NewBuffer)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        /*
         * Copy the original data to the new buffer, starting
         * at Byte zero. All unused (upper) bytes of the
         * buffer will be 0.
         */
        memcpy ((char *) NewBuffer, (char *) Buffer, BufferLength);
        Buffer = NewBuffer;
        BufferLength = RequiredLength;
    }
 
/* TBD: Move to common setup code */
 
    /* Algo is limited to sizeof(UINT64), so cut the AccessByteWidth */
    if (ObjDesc->CommonField.AccessByteWidth > sizeof (UINT64))
    {
        ObjDesc->CommonField.AccessByteWidth = sizeof (UINT64);
    }
 
    AccessBitWidth = ACPI_MUL_8 (ObjDesc->CommonField.AccessByteWidth);
 
    /* Create the bitmasks used for bit insertion */
 
    WidthMask = ACPI_MASK_BITS_ABOVE_64 (AccessBitWidth);
    Mask = WidthMask &
        ACPI_MASK_BITS_BELOW (ObjDesc->CommonField.StartFieldBitOffset);
 
    /* Compute the number of datums (access width data items) */
 
    DatumCount = ACPI_ROUND_UP_TO (ObjDesc->CommonField.BitLength,
        AccessBitWidth);
 
    FieldDatumCount = ACPI_ROUND_UP_TO (ObjDesc->CommonField.BitLength +
        ObjDesc->CommonField.StartFieldBitOffset,
        AccessBitWidth);
 
    /* Get initial Datum from the input buffer */
 
    memcpy (&RawDatum, Buffer,
        ACPI_MIN(ObjDesc->CommonField.AccessByteWidth,
            BufferLength - BufferOffset));
 
    MergedDatum = RawDatum << ObjDesc->CommonField.StartFieldBitOffset;
 
    /* Write the entire field */
 
    for (i = 1; i < FieldDatumCount; i++)
    {
        /* Write merged datum to the target field */
 
        MergedDatum &= Mask;
        Status = AcpiExWriteWithUpdateRule (
            ObjDesc, Mask, MergedDatum, FieldOffset);
        if (ACPI_FAILURE (Status))
        {
            goto Exit;
        }
 
        FieldOffset += ObjDesc->CommonField.AccessByteWidth;
 
        /*
         * Start new output datum by merging with previous input datum
         * if necessary.
         *
         * Note: Before the shift, check if the shift value will be larger than
         * the integer size. If so, there is no need to perform the operation.
         * This avoids the differences in behavior between different compilers
         * concerning shift values larger than the target data width.
         */
        if ((AccessBitWidth - ObjDesc->CommonField.StartFieldBitOffset) <
            ACPI_INTEGER_BIT_SIZE)
        {
            MergedDatum = RawDatum >>
                (AccessBitWidth - ObjDesc->CommonField.StartFieldBitOffset);
        }
        else
        {
            MergedDatum = 0;
        }
 
        Mask = WidthMask;
 
        if (i == DatumCount)
        {
            break;
        }
 
        /* Get the next input datum from the buffer */
 
        BufferOffset += ObjDesc->CommonField.AccessByteWidth;
        memcpy (&RawDatum, ((char *) Buffer) + BufferOffset,
            ACPI_MIN(ObjDesc->CommonField.AccessByteWidth,
                 BufferLength - BufferOffset));
 
        MergedDatum |= RawDatum << ObjDesc->CommonField.StartFieldBitOffset;
    }
 
    /* Mask off any extra bits in the last datum */
 
    BufferTailBits = (ObjDesc->CommonField.BitLength +
        ObjDesc->CommonField.StartFieldBitOffset) % AccessBitWidth;
    if (BufferTailBits)
    {
        Mask &= ACPI_MASK_BITS_ABOVE (BufferTailBits);
    }
 
    /* Write the last datum to the field */
 
    MergedDatum &= Mask;
    Status = AcpiExWriteWithUpdateRule (
        ObjDesc, Mask, MergedDatum, FieldOffset);
 
Exit:
    /* Free temporary buffer if we used one */
 
    if (NewBuffer)
    {
        ACPI_FREE (NewBuffer);
    }
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExFieldDatumIo(), and AcpiExWriteDataToField().

AcpiExIntegerToString()

void AcpiExIntegerToString	(	char *	Dest,
		UINT64	Value
	)

Definition at line 421 of file exutils.c.

{
    UINT32                  Count;
    UINT32                  DigitsNeeded;
    UINT32                  Remainder;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    DigitsNeeded = AcpiExDigitsNeeded (Value, 10);
    OutString[DigitsNeeded] = 0;
 
    for (Count = DigitsNeeded; Count > 0; Count--)
    {
        (void) AcpiUtShortDivide (Value, 10, &Value, &Remainder);
        OutString[Count-1] = (char) ('0' + Remainder);\
    }
}

Referenced by AcpiUtExecute_UID().

AcpiExLoadOp()

ACPI_STATUS AcpiExLoadOp	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT *	Target,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 343 of file exconfig.c.

{
    ACPI_OPERAND_OBJECT     *DdbHandle;
    ACPI_TABLE_HEADER       *TableHeader;
    ACPI_TABLE_HEADER       *Table;
    UINT32                  TableIndex;
    ACPI_STATUS             Status;
    UINT32                  Length;
 
 
    ACPI_FUNCTION_TRACE (ExLoadOp);
 
 
    if (Target->Common.DescriptorType == ACPI_DESC_TYPE_NAMED)
    {
        Target = AcpiNsGetAttachedObject (ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Target));
    }
    if (Target->Common.Type != ACPI_TYPE_INTEGER)
    {
        ACPI_ERROR ((AE_INFO, "Type not integer: %X", Target->Common.Type));
        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
    }
 
    Target->Integer.Value = 0;
 
    /* Source Object can be either an OpRegion or a Buffer/Field */
 
    switch (ObjDesc->Common.Type)
    {
    case ACPI_TYPE_REGION:
 
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "Load table from Region %p\n", ObjDesc));
 
        /* Region must be SystemMemory (from ACPI spec) */
 
        if (ObjDesc->Region.SpaceId != ACPI_ADR_SPACE_SYSTEM_MEMORY)
        {
            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
 
        /*
         * If the Region Address and Length have not been previously
         * evaluated, evaluate them now and save the results.
         */
        if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
        {
            Status = AcpiDsGetRegionArguments (ObjDesc);
            if (ACPI_FAILURE (Status))
            {
                return_ACPI_STATUS (Status);
            }
        }
 
        /* Get the table header first so we can get the table length */
 
        TableHeader = ACPI_ALLOCATE (sizeof (ACPI_TABLE_HEADER));
        if (!TableHeader)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        Status = AcpiExRegionRead (ObjDesc, sizeof (ACPI_TABLE_HEADER),
            ACPI_CAST_PTR (UINT8, TableHeader));
        Length = TableHeader->Length;
        ACPI_FREE (TableHeader);
 
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        /* Must have at least an ACPI table header */
 
        if (Length < sizeof (ACPI_TABLE_HEADER))
        {
            return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH);
        }
 
        /*
         * The original implementation simply mapped the table, with no copy.
         * However, the memory region is not guaranteed to remain stable and
         * we must copy the table to a local buffer. For example, the memory
         * region is corrupted after suspend on some machines. Dynamically
         * loaded tables are usually small, so this overhead is minimal.
         *
         * The latest implementation (5/2009) does not use a mapping at all.
         * We use the low-level operation region interface to read the table
         * instead of the obvious optimization of using a direct mapping.
         * This maintains a consistent use of operation regions across the
         * entire subsystem. This is important if additional processing must
         * be performed in the (possibly user-installed) operation region
         * handler. For example, AcpiExec and ASLTS depend on this.
         */
 
        /* Allocate a buffer for the table */
 
        Table = ACPI_ALLOCATE (Length);
        if (!Table)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        /* Read the entire table */
 
        Status = AcpiExRegionRead (ObjDesc, Length,
            ACPI_CAST_PTR (UINT8, Table));
        if (ACPI_FAILURE (Status))
        {
            ACPI_FREE (Table);
            return_ACPI_STATUS (Status);
        }
        break;
 
    case ACPI_TYPE_BUFFER: /* Buffer or resolved RegionField */
 
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "Load table from Buffer or Field %p\n", ObjDesc));
 
        /* Must have at least an ACPI table header */
 
        if (ObjDesc->Buffer.Length < sizeof (ACPI_TABLE_HEADER))
        {
            return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH);
        }
 
        /* Get the actual table length from the table header */
 
        TableHeader = ACPI_CAST_PTR (
            ACPI_TABLE_HEADER, ObjDesc->Buffer.Pointer);
        Length = TableHeader->Length;
 
        /* Table cannot extend beyond the buffer */
 
        if (Length > ObjDesc->Buffer.Length)
        {
            return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);
        }
        if (Length < sizeof (ACPI_TABLE_HEADER))
        {
            return_ACPI_STATUS (AE_INVALID_TABLE_LENGTH);
        }
 
        /*
         * Copy the table from the buffer because the buffer could be
         * modified or even deleted in the future
         */
        Table = ACPI_ALLOCATE (Length);
        if (!Table)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        memcpy (Table, TableHeader, Length);
        break;
 
    default:
 
        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
    }
 
    /* Install the new table into the local data structures */
 
    ACPI_INFO (("Dynamic OEM Table Load:"));
    AcpiExExitInterpreter ();
    Status = AcpiTbInstallAndLoadTable (ACPI_PTR_TO_PHYSADDR (Table),
        ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, Table, TRUE, &TableIndex);
    AcpiExEnterInterpreter ();
    if (ACPI_FAILURE (Status))
    {
        /* Delete allocated table buffer */
 
        ACPI_FREE (Table);
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Add the table to the namespace.
     *
     * Note: Load the table objects relative to the root of the namespace.
     * This appears to go against the ACPI specification, but we do it for
     * compatibility with other ACPI implementations.
     */
    Status = AcpiExAddTable (TableIndex, &DdbHandle);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Complete the initialization/resolution of new objects */
 
    AcpiExExitInterpreter ();
    AcpiNsInitializeObjects ();
    AcpiExEnterInterpreter ();
 
    /* Remove the reference to DdbHandle created by AcpiExAddTable above */
 
    AcpiUtRemoveReference (DdbHandle);
 
    /* Return -1 (non-zero) indicates success */
 
    Target->Integer.Value = 0xFFFFFFFFFFFFFFFF;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExOpcode_1A_1T_1R().

AcpiExLoadTableOp()

ACPI_STATUS AcpiExLoadTableOp	(	ACPI_WALK_STATE *	WalkState,
		ACPI_OPERAND_OBJECT **	ReturnDesc
	)

Definition at line 129 of file exconfig.c.

{
    ACPI_STATUS             Status;
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_NAMESPACE_NODE     *ParentNode;
    ACPI_NAMESPACE_NODE     *StartNode;
    ACPI_NAMESPACE_NODE     *ParameterNode = NULL;
    ACPI_OPERAND_OBJECT     *ReturnObj;
    ACPI_OPERAND_OBJECT     *DdbHandle;
    UINT32                  TableIndex;
 
 
    ACPI_FUNCTION_TRACE (ExLoadTableOp);
 
 
    /* Create the return object */
 
    ReturnObj = AcpiUtCreateIntegerObject ((UINT64) 0);
    if (!ReturnObj)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    *ReturnDesc = ReturnObj;
 
    /* Find the ACPI table in the RSDT/XSDT */
 
    AcpiExExitInterpreter ();
    Status = AcpiTbFindTable (
        Operand[0]->String.Pointer,
        Operand[1]->String.Pointer,
        Operand[2]->String.Pointer, &TableIndex);
    AcpiExEnterInterpreter ();
    if (ACPI_FAILURE (Status))
    {
        if (Status != AE_NOT_FOUND)
        {
            return_ACPI_STATUS (Status);
        }
 
        /* Table not found, return an Integer=0 and AE_OK */
 
        return_ACPI_STATUS (AE_OK);
    }
 
    /* Default nodes */
 
    StartNode = WalkState->ScopeInfo->Scope.Node;
    ParentNode = AcpiGbl_RootNode;
 
    /* RootPath (optional parameter) */
 
    if (Operand[3]->String.Length > 0)
    {
        /*
         * Find the node referenced by the RootPathString. This is the
         * location within the namespace where the table will be loaded.
         */
        Status = AcpiNsGetNodeUnlocked (StartNode,
            Operand[3]->String.Pointer, ACPI_NS_SEARCH_PARENT,
            &ParentNode);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
    }
 
    /* ParameterPath (optional parameter) */
 
    if (Operand[4]->String.Length > 0)
    {
        if ((Operand[4]->String.Pointer[0] != AML_ROOT_PREFIX) &&
            (Operand[4]->String.Pointer[0] != AML_PARENT_PREFIX))
        {
            /*
             * Path is not absolute, so it will be relative to the node
             * referenced by the RootPathString (or the NS root if omitted)
             */
            StartNode = ParentNode;
        }
 
        /* Find the node referenced by the ParameterPathString */
 
        Status = AcpiNsGetNodeUnlocked (StartNode,
            Operand[4]->String.Pointer, ACPI_NS_SEARCH_PARENT,
            &ParameterNode);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
    }
 
    /* Load the table into the namespace */
 
    ACPI_INFO (("Dynamic OEM Table Load:"));
    AcpiExExitInterpreter ();
    Status = AcpiTbLoadTable (TableIndex, ParentNode);
    AcpiExEnterInterpreter ();
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Status = AcpiExAddTable (TableIndex, &DdbHandle);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Complete the initialization/resolution of new objects */
 
    AcpiExExitInterpreter();
    AcpiNsInitializeObjects();
    AcpiExEnterInterpreter();
 
    /* Parameter Data (optional) */
 
    if (ParameterNode)
    {
        /* Store the parameter data into the optional parameter object */
 
        Status = AcpiExStore (Operand[5],
            ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, ParameterNode), WalkState);
        if (ACPI_FAILURE (Status))
        {
            (void) AcpiExUnloadTable (DdbHandle);
 
            AcpiUtRemoveReference (DdbHandle);
            return_ACPI_STATUS (Status);
        }
    }
 
    /* Remove the reference to DdbHandle created by AcpiExAddTable above */
 
    AcpiUtRemoveReference (DdbHandle);
 
    /* Return -1 (non-zero) indicates success */
 
    ReturnObj->Integer.Value = 0xFFFFFFFFFFFFFFFF;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExOpcode_6A_0T_1R().

AcpiExOpcode_0A_0T_1R()

ACPI_STATUS AcpiExOpcode_0A_0T_1R

(

ACPI_WALK_STATE *

WalkState

)

Naming convention for AML interpreter execution routines.

The routines that begin execution of AML opcodes are named with a common convention based upon the number of arguments, the number of target operands, and whether or not a value is returned:

 AcpiExOpcode_xA_yT_zR

Where:

xA - ARGUMENTS: The number of arguments (input operands) that are required for this opcode type (0 through 6 args). yT - TARGETS: The number of targets (output operands) that are required for this opcode type (0, 1, or 2 targets). zR - RETURN VALUE: Indicates whether this opcode type returns a value as the function return (0 or 1).

The AcpiExOpcode* functions are called via the Dispatcher component with fully resolved operands. !

Definition at line 92 of file exoparg1.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
 
 
    ACPI_FUNCTION_TRACE_STR (ExOpcode_0A_0T_1R,
        AcpiPsGetOpcodeName (WalkState->Opcode));
 
 
    /* Examine the AML opcode */
 
    switch (WalkState->Opcode)
    {
    case AML_TIMER_OP:      /*  Timer () */
 
        /* Create a return object of type Integer */
 
        ReturnDesc = AcpiUtCreateIntegerObject (AcpiOsGetTimer ());
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
        break;
 
    default:                /*  Unknown opcode  */
 
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            WalkState->Opcode));
        Status = AE_AML_BAD_OPCODE;
        break;
    }
 
Cleanup:
 
    /* Delete return object on error */
 
    if ((ACPI_FAILURE (Status)) || WalkState->ResultObj)
    {
        AcpiUtRemoveReference (ReturnDesc);
        WalkState->ResultObj = NULL;
    }
    else
    {
        /* Save the return value */
 
        WalkState->ResultObj = ReturnDesc;
    }
 
    return_ACPI_STATUS (Status);
}

AcpiExOpcode_1A_0T_0R()

ACPI_STATUS AcpiExOpcode_1A_0T_0R

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 161 of file exoparg1.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_0T_0R,
        AcpiPsGetOpcodeName (WalkState->Opcode));
 
 
    /* Examine the AML opcode */
 
    switch (WalkState->Opcode)
    {
    case AML_RELEASE_OP:    /*  Release (MutexObject) */
 
        Status = AcpiExReleaseMutex (Operand[0], WalkState);
        break;
 
    case AML_RESET_OP:      /*  Reset (EventObject) */
 
        Status = AcpiExSystemResetEvent (Operand[0]);
        break;
 
    case AML_SIGNAL_OP:     /*  Signal (EventObject) */
 
        Status = AcpiExSystemSignalEvent (Operand[0]);
        break;
 
    case AML_SLEEP_OP:      /*  Sleep (MsecTime) */
 
        Status = AcpiExSystemDoSleep (Operand[0]->Integer.Value);
        break;
 
    case AML_STALL_OP:      /*  Stall (UsecTime) */
 
        Status = AcpiExSystemDoStall ((UINT32) Operand[0]->Integer.Value);
        break;
 
    case AML_UNLOAD_OP:     /*  Unload (Handle) */
 
        Status = AcpiExUnloadTable (Operand[0]);
        break;
 
    default:                /*  Unknown opcode  */
 
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            WalkState->Opcode));
        Status = AE_AML_BAD_OPCODE;
        break;
    }
 
    return_ACPI_STATUS (Status);
}

AcpiExOpcode_1A_0T_1R()

ACPI_STATUS AcpiExOpcode_1A_0T_1R

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 642 of file exoparg1.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_OPERAND_OBJECT     *TempDesc;
    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
    ACPI_STATUS             Status = AE_OK;
    UINT32                  Type;
    UINT64                  Value;
 
 
    ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_0T_1R,
        AcpiPsGetOpcodeName (WalkState->Opcode));
 
 
    /* Examine the AML opcode */
 
    switch (WalkState->Opcode)
    {
    case AML_LOGICAL_NOT_OP:        /* LNot (Operand) */
 
        ReturnDesc = AcpiUtCreateIntegerObject ((UINT64) 0);
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        /*
         * Set result to ONES (TRUE) if Value == 0. Note:
         * ReturnDesc->Integer.Value is initially == 0 (FALSE) from above.
         */
        if (!Operand[0]->Integer.Value)
        {
            ReturnDesc->Integer.Value = ACPI_UINT64_MAX;
        }
        break;
 
    case AML_DECREMENT_OP:          /* Decrement (Operand)  */
    case AML_INCREMENT_OP:          /* Increment (Operand)  */
        /*
         * Create a new integer. Can't just get the base integer and
         * increment it because it may be an Arg or Field.
         */
        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        /*
         * Since we are expecting a Reference operand, it can be either a
         * NS Node or an internal object.
         */
        TempDesc = Operand[0];
        if (ACPI_GET_DESCRIPTOR_TYPE (TempDesc) == ACPI_DESC_TYPE_OPERAND)
        {
            /* Internal reference object - prevent deletion */
 
            AcpiUtAddReference (TempDesc);
        }
 
        /*
         * Convert the Reference operand to an Integer (This removes a
         * reference on the Operand[0] object)
         *
         * NOTE:  We use LNOT_OP here in order to force resolution of the
         * reference operand to an actual integer.
         */
        Status = AcpiExResolveOperands (AML_LOGICAL_NOT_OP,
            &TempDesc, WalkState);
        if (ACPI_FAILURE (Status))
        {
            ACPI_EXCEPTION ((AE_INFO, Status,
                "While resolving operands for [%s]",
                AcpiPsGetOpcodeName (WalkState->Opcode)));
 
            goto Cleanup;
        }
 
        /*
         * TempDesc is now guaranteed to be an Integer object --
         * Perform the actual increment or decrement
         */
        if (WalkState->Opcode == AML_INCREMENT_OP)
        {
            ReturnDesc->Integer.Value = TempDesc->Integer.Value + 1;
        }
        else
        {
            ReturnDesc->Integer.Value = TempDesc->Integer.Value - 1;
        }
 
        /* Finished with this Integer object */
 
        AcpiUtRemoveReference (TempDesc);
 
        /*
         * Store the result back (indirectly) through the original
         * Reference object
         */
        Status = AcpiExStore (ReturnDesc, Operand[0], WalkState);
        break;
 
    case AML_OBJECT_TYPE_OP:            /* ObjectType (SourceObject) */
        /*
         * Note: The operand is not resolved at this point because we want to
         * get the associated object, not its value. For example, we don't
         * want to resolve a FieldUnit to its value, we want the actual
         * FieldUnit object.
         */
 
        /* Get the type of the base object */
 
        Status = AcpiExResolveMultiple (WalkState, Operand[0], &Type, NULL);
        if (ACPI_FAILURE (Status))
        {
            goto Cleanup;
        }
 
        /* Allocate a descriptor to hold the type. */
 
        ReturnDesc = AcpiUtCreateIntegerObject ((UINT64) Type);
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
        break;
 
    case AML_SIZE_OF_OP:            /* SizeOf (SourceObject)  */
        /*
         * Note: The operand is not resolved at this point because we want to
         * get the associated object, not its value.
         */
 
        /* Get the base object */
 
        Status = AcpiExResolveMultiple (
            WalkState, Operand[0], &Type, &TempDesc);
        if (ACPI_FAILURE (Status))
        {
            goto Cleanup;
        }
 
        /*
         * The type of the base object must be integer, buffer, string, or
         * package. All others are not supported.
         *
         * NOTE: Integer is not specifically supported by the ACPI spec,
         * but is supported implicitly via implicit operand conversion.
         * rather than bother with conversion, we just use the byte width
         * global (4 or 8 bytes).
         */
        switch (Type)
        {
        case ACPI_TYPE_INTEGER:
 
            Value = AcpiGbl_IntegerByteWidth;
            break;
 
        case ACPI_TYPE_STRING:
 
            Value = TempDesc->String.Length;
            break;
 
        case ACPI_TYPE_BUFFER:
 
            /* Buffer arguments may not be evaluated at this point */
 
            Status = AcpiDsGetBufferArguments (TempDesc);
            Value = TempDesc->Buffer.Length;
            break;
 
        case ACPI_TYPE_PACKAGE:
 
            /* Package arguments may not be evaluated at this point */
 
            Status = AcpiDsGetPackageArguments (TempDesc);
            Value = TempDesc->Package.Count;
            break;
 
        default:
 
            ACPI_ERROR ((AE_INFO,
                "Operand must be Buffer/Integer/String/Package"
                " - found type %s",
                AcpiUtGetTypeName (Type)));
 
            Status = AE_AML_OPERAND_TYPE;
            goto Cleanup;
        }
 
        if (ACPI_FAILURE (Status))
        {
            goto Cleanup;
        }
 
        /*
         * Now that we have the size of the object, create a result
         * object to hold the value
         */
        ReturnDesc = AcpiUtCreateIntegerObject (Value);
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
        break;
 
 
    case AML_REF_OF_OP:             /* RefOf (SourceObject) */
 
        Status = AcpiExGetObjectReference (
            Operand[0], &ReturnDesc, WalkState);
        if (ACPI_FAILURE (Status))
        {
            goto Cleanup;
        }
        break;
 
 
    case AML_DEREF_OF_OP:           /* DerefOf (ObjReference | String) */
 
        /* Check for a method local or argument, or standalone String */
 
        if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) == ACPI_DESC_TYPE_NAMED)
        {
            TempDesc = AcpiNsGetAttachedObject (
                (ACPI_NAMESPACE_NODE *) Operand[0]);
            if (TempDesc &&
                 ((TempDesc->Common.Type == ACPI_TYPE_STRING) ||
                  (TempDesc->Common.Type == ACPI_TYPE_LOCAL_REFERENCE)))
            {
                Operand[0] = TempDesc;
                AcpiUtAddReference (TempDesc);
            }
            else
            {
                Status = AE_AML_OPERAND_TYPE;
                goto Cleanup;
            }
        }
        else
        {
            switch ((Operand[0])->Common.Type)
            {
            case ACPI_TYPE_LOCAL_REFERENCE:
                /*
                 * This is a DerefOf (LocalX | ArgX)
                 *
                 * Must resolve/dereference the local/arg reference first
                 */
                switch (Operand[0]->Reference.Class)
                {
                case ACPI_REFCLASS_LOCAL:
                case ACPI_REFCLASS_ARG:
 
                    /* Set Operand[0] to the value of the local/arg */
 
                    Status = AcpiDsMethodDataGetValue (
                        Operand[0]->Reference.Class,
                        Operand[0]->Reference.Value,
                        WalkState, &TempDesc);
                    if (ACPI_FAILURE (Status))
                    {
                        goto Cleanup;
                    }
 
                    /*
                     * Delete our reference to the input object and
                     * point to the object just retrieved
                     */
                    AcpiUtRemoveReference (Operand[0]);
                    Operand[0] = TempDesc;
                    break;
 
                case ACPI_REFCLASS_REFOF:
 
                    /* Get the object to which the reference refers */
 
                    TempDesc = Operand[0]->Reference.Object;
                    AcpiUtRemoveReference (Operand[0]);
                    Operand[0] = TempDesc;
                    break;
 
                default:
 
                    /* Must be an Index op - handled below */
                    break;
                }
                break;
 
            case ACPI_TYPE_STRING:
 
                break;
 
            default:
 
                Status = AE_AML_OPERAND_TYPE;
                goto Cleanup;
            }
        }
 
        if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) != ACPI_DESC_TYPE_NAMED)
        {
            if ((Operand[0])->Common.Type == ACPI_TYPE_STRING)
            {
                /*
                 * This is a DerefOf (String). The string is a reference
                 * to a named ACPI object.
                 *
                 * 1) Find the owning Node
                 * 2) Dereference the node to an actual object. Could be a
                 *    Field, so we need to resolve the node to a value.
                 */
                Status = AcpiNsGetNodeUnlocked (WalkState->ScopeInfo->Scope.Node,
                    Operand[0]->String.Pointer,
                    ACPI_NS_SEARCH_PARENT,
                    ACPI_CAST_INDIRECT_PTR (
                        ACPI_NAMESPACE_NODE, &ReturnDesc));
                if (ACPI_FAILURE (Status))
                {
                    goto Cleanup;
                }
 
                Status = AcpiExResolveNodeToValue (
                    ACPI_CAST_INDIRECT_PTR (
                        ACPI_NAMESPACE_NODE, &ReturnDesc),
                    WalkState);
                goto Cleanup;
            }
        }
 
        /* Operand[0] may have changed from the code above */
 
        if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) == ACPI_DESC_TYPE_NAMED)
        {
            /*
             * This is a DerefOf (ObjectReference)
             * Get the actual object from the Node (This is the dereference).
             * This case may only happen when a LocalX or ArgX is
             * dereferenced above, or for references to device and
             * thermal objects.
             */
            switch (((ACPI_NAMESPACE_NODE *) Operand[0])->Type)
            {
            case ACPI_TYPE_DEVICE:
            case ACPI_TYPE_THERMAL:
 
                /* These types have no node subobject, return the NS node */
 
                ReturnDesc = Operand[0];
                break;
 
            default:
                /* For most types, get the object attached to the node */
 
                ReturnDesc = AcpiNsGetAttachedObject (
                    (ACPI_NAMESPACE_NODE *) Operand[0]);
                AcpiUtAddReference (ReturnDesc);
                break;
            }
        }
        else
        {
            /*
             * This must be a reference object produced by either the
             * Index() or RefOf() operator
             */
            switch (Operand[0]->Reference.Class)
            {
            case ACPI_REFCLASS_INDEX:
                /*
                 * The target type for the Index operator must be
                 * either a Buffer or a Package
                 */
                switch (Operand[0]->Reference.TargetType)
                {
                case ACPI_TYPE_BUFFER_FIELD:
 
                    TempDesc = Operand[0]->Reference.Object;
 
                    /*
                     * Create a new object that contains one element of the
                     * buffer -- the element pointed to by the index.
                     *
                     * NOTE: index into a buffer is NOT a pointer to a
                     * sub-buffer of the main buffer, it is only a pointer to a
                     * single element (byte) of the buffer!
                     *
                     * Since we are returning the value of the buffer at the
                     * indexed location, we don't need to add an additional
                     * reference to the buffer itself.
                     */
                    ReturnDesc = AcpiUtCreateIntegerObject ((UINT64)
                        TempDesc->Buffer.Pointer[Operand[0]->Reference.Value]);
                    if (!ReturnDesc)
                    {
                        Status = AE_NO_MEMORY;
                        goto Cleanup;
                    }
                    break;
 
                case ACPI_TYPE_PACKAGE:
                    /*
                     * Return the referenced element of the package. We must
                     * add another reference to the referenced object, however.
                     */
                    ReturnDesc = *(Operand[0]->Reference.Where);
                    if (!ReturnDesc)
                    {
                        /*
                         * Element is NULL, do not allow the dereference.
                         * This provides compatibility with other ACPI
                         * implementations.
                         */
                        return_ACPI_STATUS (AE_AML_UNINITIALIZED_ELEMENT);
                    }
 
                    AcpiUtAddReference (ReturnDesc);
                    break;
 
                default:
 
                    ACPI_ERROR ((AE_INFO,
                        "Unknown Index TargetType 0x%X in reference object %p",
                        Operand[0]->Reference.TargetType, Operand[0]));
 
                    Status = AE_AML_OPERAND_TYPE;
                    goto Cleanup;
                }
                break;
 
            case ACPI_REFCLASS_REFOF:
 
                ReturnDesc = Operand[0]->Reference.Object;
 
                if (ACPI_GET_DESCRIPTOR_TYPE (ReturnDesc) ==
                    ACPI_DESC_TYPE_NAMED)
                {
                    ReturnDesc = AcpiNsGetAttachedObject (
                        (ACPI_NAMESPACE_NODE *) ReturnDesc);
                    if (!ReturnDesc)
                    {
                        break;
                    }
 
                   /*
                    * June 2013:
                    * BufferFields/FieldUnits require additional resolution
                    */
                    switch (ReturnDesc->Common.Type)
                    {
                    case ACPI_TYPE_BUFFER_FIELD:
                    case ACPI_TYPE_LOCAL_REGION_FIELD:
                    case ACPI_TYPE_LOCAL_BANK_FIELD:
                    case ACPI_TYPE_LOCAL_INDEX_FIELD:
 
                        Status = AcpiExReadDataFromField (
                            WalkState, ReturnDesc, &TempDesc);
                        if (ACPI_FAILURE (Status))
                        {
                            return_ACPI_STATUS (Status);
                        }
 
                        ReturnDesc = TempDesc;
                        break;
 
                    default:
 
                        /* Add another reference to the object */
 
                        AcpiUtAddReference (ReturnDesc);
                        break;
                    }
                }
                break;
 
            default:
 
                ACPI_ERROR ((AE_INFO,
                    "Unknown class in reference(%p) - 0x%2.2X",
                    Operand[0], Operand[0]->Reference.Class));
 
                Status = AE_TYPE;
                goto Cleanup;
            }
        }
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            WalkState->Opcode));
 
        Status = AE_AML_BAD_OPCODE;
        goto Cleanup;
    }
 
 
Cleanup:
 
    /* Delete return object on error */
 
    if (ACPI_FAILURE (Status))
    {
        AcpiUtRemoveReference (ReturnDesc);
    }
 
    /* Save return object on success */
 
    else
    {
        WalkState->ResultObj = ReturnDesc;
    }
 
    return_ACPI_STATUS (Status);
}

AcpiExOpcode_1A_1T_0R()

ACPI_STATUS AcpiExOpcode_1A_1T_0R

(

ACPI_WALK_STATE *

WalkState

)

AcpiExOpcode_1A_1T_1R()

ACPI_STATUS AcpiExOpcode_1A_1T_1R

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 286 of file exoparg1.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
    ACPI_OPERAND_OBJECT     *ReturnDesc2 = NULL;
    UINT32                  Temp32;
    UINT32                  i;
    UINT64                  PowerOfTen;
    UINT64                  Digit;
 
 
    ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_1T_1R,
        AcpiPsGetOpcodeName (WalkState->Opcode));
 
 
    /* Examine the AML opcode */
 
    switch (WalkState->Opcode)
    {
    case AML_BIT_NOT_OP:
    case AML_FIND_SET_LEFT_BIT_OP:
    case AML_FIND_SET_RIGHT_BIT_OP:
    case AML_FROM_BCD_OP:
    case AML_LOAD_OP:
    case AML_TO_BCD_OP:
    case AML_CONDITIONAL_REF_OF_OP:
 
        /* Create a return object of type Integer for these opcodes */
 
        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        switch (WalkState->Opcode)
        {
        case AML_BIT_NOT_OP:            /* Not (Operand, Result)  */
 
            ReturnDesc->Integer.Value = ~Operand[0]->Integer.Value;
            break;
 
        case AML_FIND_SET_LEFT_BIT_OP:  /* FindSetLeftBit (Operand, Result) */
 
            ReturnDesc->Integer.Value = Operand[0]->Integer.Value;
 
            /*
             * Acpi specification describes Integer type as a little
             * endian unsigned value, so this boundary condition is valid.
             */
            for (Temp32 = 0; ReturnDesc->Integer.Value &&
                    Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32)
            {
                ReturnDesc->Integer.Value >>= 1;
            }
 
            ReturnDesc->Integer.Value = Temp32;
            break;
 
        case AML_FIND_SET_RIGHT_BIT_OP: /* FindSetRightBit (Operand, Result) */
 
            ReturnDesc->Integer.Value = Operand[0]->Integer.Value;
 
            /*
             * The Acpi specification describes Integer type as a little
             * endian unsigned value, so this boundary condition is valid.
             */
            for (Temp32 = 0; ReturnDesc->Integer.Value &&
                     Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32)
            {
                ReturnDesc->Integer.Value <<= 1;
            }
 
            /* Since the bit position is one-based, subtract from 33 (65) */
 
            ReturnDesc->Integer.Value =
                Temp32 == 0 ? 0 : (ACPI_INTEGER_BIT_SIZE + 1) - Temp32;
            break;
 
        case AML_FROM_BCD_OP:           /* FromBcd (BCDValue, Result)  */
            /*
             * The 64-bit ACPI integer can hold 16 4-bit BCD characters
             * (if table is 32-bit, integer can hold 8 BCD characters)
             * Convert each 4-bit BCD value
             */
            PowerOfTen = 1;
            ReturnDesc->Integer.Value = 0;
            Digit = Operand[0]->Integer.Value;
 
            /* Convert each BCD digit (each is one nybble wide) */
 
            for (i = 0; (i < AcpiGbl_IntegerNybbleWidth) && (Digit > 0); i++)
            {
                /* Get the least significant 4-bit BCD digit */
 
                Temp32 = ((UINT32) Digit) & 0xF;
 
                /* Check the range of the digit */
 
                if (Temp32 > 9)
                {
                    ACPI_ERROR ((AE_INFO,
                        "BCD digit too large (not decimal): 0x%X",
                        Temp32));
 
                    Status = AE_AML_NUMERIC_OVERFLOW;
                    goto Cleanup;
                }
 
                /* Sum the digit into the result with the current power of 10 */
 
                ReturnDesc->Integer.Value +=
                    (((UINT64) Temp32) * PowerOfTen);
 
                /* Shift to next BCD digit */
 
                Digit >>= 4;
 
                /* Next power of 10 */
 
                PowerOfTen *= 10;
            }
            break;
 
        case AML_LOAD_OP:               /* Result1 = Load (Operand[0], Result1) */
 
            ReturnDesc->Integer.Value = 0;
            Status = AcpiExLoadOp (Operand[0], ReturnDesc, WalkState);
            if (ACPI_SUCCESS (Status))
            {
                /* Return -1 (non-zero) indicates success */
 
                ReturnDesc->Integer.Value = 0xFFFFFFFFFFFFFFFF;
            }
            break;
 
        case AML_TO_BCD_OP:             /* ToBcd (Operand, Result)  */
 
            ReturnDesc->Integer.Value = 0;
            Digit = Operand[0]->Integer.Value;
 
            /* Each BCD digit is one nybble wide */
 
            for (i = 0; (i < AcpiGbl_IntegerNybbleWidth) && (Digit > 0); i++)
            {
                (void) AcpiUtShortDivide (Digit, 10, &Digit, &Temp32);
 
                /*
                 * Insert the BCD digit that resides in the
                 * remainder from above
                 */
                ReturnDesc->Integer.Value |=
                    (((UINT64) Temp32) << ACPI_MUL_4 (i));
            }
 
            /* Overflow if there is any data left in Digit */
 
            if (Digit > 0)
            {
                ACPI_ERROR ((AE_INFO,
                    "Integer too large to convert to BCD: 0x%8.8X%8.8X",
                    ACPI_FORMAT_UINT64 (Operand[0]->Integer.Value)));
                Status = AE_AML_NUMERIC_OVERFLOW;
                goto Cleanup;
            }
            break;
 
        case AML_CONDITIONAL_REF_OF_OP:     /* CondRefOf (SourceObject, Result)  */
            /*
             * This op is a little strange because the internal return value is
             * different than the return value stored in the result descriptor
             * (There are really two return values)
             */
            if ((ACPI_NAMESPACE_NODE *) Operand[0] == AcpiGbl_RootNode)
            {
                /*
                 * This means that the object does not exist in the namespace,
                 * return FALSE
                 */
                ReturnDesc->Integer.Value = 0;
                goto Cleanup;
            }
 
            /* Get the object reference, store it, and remove our reference */
 
            Status = AcpiExGetObjectReference (Operand[0],
                &ReturnDesc2, WalkState);
            if (ACPI_FAILURE (Status))
            {
                goto Cleanup;
            }
 
            Status = AcpiExStore (ReturnDesc2, Operand[1], WalkState);
            AcpiUtRemoveReference (ReturnDesc2);
 
            /* The object exists in the namespace, return TRUE */
 
            ReturnDesc->Integer.Value = ACPI_UINT64_MAX;
            goto Cleanup;
 
 
        default:
 
            /* No other opcodes get here */
 
            break;
        }
        break;
 
    case AML_STORE_OP:              /* Store (Source, Target) */
        /*
         * A store operand is typically a number, string, buffer or lvalue
         * Be careful about deleting the source object,
         * since the object itself may have been stored.
         */
        Status = AcpiExStore (Operand[0], Operand[1], WalkState);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        /* It is possible that the Store already produced a return object */
 
        if (!WalkState->ResultObj)
        {
            /*
             * Normally, we would remove a reference on the Operand[0]
             * parameter; But since it is being used as the internal return
             * object (meaning we would normally increment it), the two
             * cancel out, and we simply don't do anything.
             */
            WalkState->ResultObj = Operand[0];
            WalkState->Operands[0] = NULL;  /* Prevent deletion */
        }
        return_ACPI_STATUS (Status);
 
    /*
     * ACPI 2.0 Opcodes
     */
    case AML_COPY_OBJECT_OP:        /* CopyObject (Source, Target) */
 
        Status = AcpiUtCopyIobjectToIobject (
            Operand[0], &ReturnDesc, WalkState);
        break;
 
    case AML_TO_DECIMAL_STRING_OP:  /* ToDecimalString (Data, Result) */
 
        Status = AcpiExConvertToString (
            Operand[0], &ReturnDesc, ACPI_EXPLICIT_CONVERT_DECIMAL);
        if (ReturnDesc == Operand[0])
        {
            /* No conversion performed, add ref to handle return value */
 
            AcpiUtAddReference (ReturnDesc);
        }
        break;
 
    case AML_TO_HEX_STRING_OP:      /* ToHexString (Data, Result) */
 
        Status = AcpiExConvertToString (
            Operand[0], &ReturnDesc, ACPI_EXPLICIT_CONVERT_HEX);
        if (ReturnDesc == Operand[0])
        {
            /* No conversion performed, add ref to handle return value */
 
            AcpiUtAddReference (ReturnDesc);
        }
        break;
 
    case AML_TO_BUFFER_OP:          /* ToBuffer (Data, Result) */
 
        Status = AcpiExConvertToBuffer (Operand[0], &ReturnDesc);
        if (ReturnDesc == Operand[0])
        {
            /* No conversion performed, add ref to handle return value */
 
            AcpiUtAddReference (ReturnDesc);
        }
        break;
 
    case AML_TO_INTEGER_OP:         /* ToInteger (Data, Result) */
 
        /* Perform "explicit" conversion */
 
        Status = AcpiExConvertToInteger (Operand[0], &ReturnDesc, 0);
        if (ReturnDesc == Operand[0])
        {
            /* No conversion performed, add ref to handle return value */
 
            AcpiUtAddReference (ReturnDesc);
        }
        break;
 
    case AML_SHIFT_LEFT_BIT_OP:     /* ShiftLeftBit (Source, BitNum)  */
    case AML_SHIFT_RIGHT_BIT_OP:    /* ShiftRightBit (Source, BitNum) */
 
        /* These are two obsolete opcodes */
 
        ACPI_ERROR ((AE_INFO,
            "%s is obsolete and not implemented",
            AcpiPsGetOpcodeName (WalkState->Opcode)));
        Status = AE_SUPPORT;
        goto Cleanup;
 
    default:                        /* Unknown opcode */
 
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            WalkState->Opcode));
        Status = AE_AML_BAD_OPCODE;
        goto Cleanup;
    }
 
    if (ACPI_SUCCESS (Status))
    {
        /* Store the return value computed above into the target object */
 
        Status = AcpiExStore (ReturnDesc, Operand[1], WalkState);
    }
 
 
Cleanup:
 
    /* Delete return object on error */
 
    if (ACPI_FAILURE (Status))
    {
        AcpiUtRemoveReference (ReturnDesc);
    }
 
    /* Save return object on success */
 
    else if (!WalkState->ResultObj)
    {
        WalkState->ResultObj = ReturnDesc;
    }
 
    return_ACPI_STATUS (Status);
}

AcpiExOpcode_2A_0T_0R()

ACPI_STATUS AcpiExOpcode_2A_0T_0R

(

ACPI_WALK_STATE *

WalkState

)

Naming convention for AML interpreter execution routines.

The routines that begin execution of AML opcodes are named with a common convention based upon the number of arguments, the number of target operands, and whether or not a value is returned:

 AcpiExOpcode_xA_yT_zR

Where:

xA - ARGUMENTS: The number of arguments (input operands) that are required for this opcode type (1 through 6 args). yT - TARGETS: The number of targets (output operands) that are required for this opcode type (0, 1, or 2 targets). zR - RETURN VALUE: Indicates whether this opcode type returns a value as the function return (0 or 1).

The AcpiExOpcode* functions are called via the Dispatcher component with fully resolved operands. !

Definition at line 95 of file exoparg2.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_NAMESPACE_NODE     *Node;
    UINT32                  Value;
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_0R,
            AcpiPsGetOpcodeName (WalkState->Opcode));
 
 
    /* Examine the opcode */
 
    switch (WalkState->Opcode)
    {
    case AML_NOTIFY_OP:         /* Notify (NotifyObject, NotifyValue) */
 
        /* The first operand is a namespace node */
 
        Node = (ACPI_NAMESPACE_NODE *) Operand[0];
 
        /* Second value is the notify value */
 
        Value = (UINT32) Operand[1]->Integer.Value;
 
        /* Are notifies allowed on this object? */
 
        if (!AcpiEvIsNotifyObject (Node))
        {
            ACPI_ERROR ((AE_INFO,
                "Unexpected notify object type [%s]",
                AcpiUtGetTypeName (Node->Type)));
 
            Status = AE_AML_OPERAND_TYPE;
            break;
        }
 
        /*
         * Dispatch the notify to the appropriate handler
         * NOTE: the request is queued for execution after this method
         * completes. The notify handlers are NOT invoked synchronously
         * from this thread -- because handlers may in turn run other
         * control methods.
         */
        Status = AcpiEvQueueNotifyRequest (Node, Value);
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            WalkState->Opcode));
        Status = AE_AML_BAD_OPCODE;
    }
 
    return_ACPI_STATUS (Status);
}

AcpiExOpcode_2A_0T_1R()

ACPI_STATUS AcpiExOpcode_2A_0T_1R

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 540 of file exoparg2.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
    ACPI_STATUS             Status = AE_OK;
    BOOLEAN                 LogicalResult = FALSE;
 
 
    ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_0T_1R,
        AcpiPsGetOpcodeName (WalkState->Opcode));
 
 
    /* Create the internal return object */
 
    ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
    if (!ReturnDesc)
    {
        Status = AE_NO_MEMORY;
        goto Cleanup;
    }
 
    /* Execute the Opcode */
 
    if (WalkState->OpInfo->Flags & AML_LOGICAL_NUMERIC)
    {
        /* LogicalOp  (Operand0, Operand1) */
 
        Status = AcpiExDoLogicalNumericOp (WalkState->Opcode,
            Operand[0]->Integer.Value, Operand[1]->Integer.Value,
            &LogicalResult);
        goto StoreLogicalResult;
    }
    else if (WalkState->OpInfo->Flags & AML_LOGICAL)
    {
        /* LogicalOp  (Operand0, Operand1) */
 
        Status = AcpiExDoLogicalOp (WalkState->Opcode, Operand[0],
            Operand[1], &LogicalResult);
        goto StoreLogicalResult;
    }
 
    switch (WalkState->Opcode)
    {
    case AML_ACQUIRE_OP:            /* Acquire (MutexObject, Timeout) */
 
        Status = AcpiExAcquireMutex (Operand[1], Operand[0], WalkState);
        if (Status == AE_TIME)
        {
            LogicalResult = TRUE;       /* TRUE = Acquire timed out */
            Status = AE_OK;
        }
        break;
 
 
    case AML_WAIT_OP:               /* Wait (EventObject, Timeout) */
 
        Status = AcpiExSystemWaitEvent (Operand[1], Operand[0]);
        if (Status == AE_TIME)
        {
            LogicalResult = TRUE;       /* TRUE, Wait timed out */
            Status = AE_OK;
        }
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            WalkState->Opcode));
 
        Status = AE_AML_BAD_OPCODE;
        goto Cleanup;
    }
 
 
StoreLogicalResult:
    /*
     * Set return value to according to LogicalResult. logical TRUE (all ones)
     * Default is FALSE (zero)
     */
    if (LogicalResult)
    {
        ReturnDesc->Integer.Value = ACPI_UINT64_MAX;
    }
 
Cleanup:
 
    /* Delete return object on error */
 
    if (ACPI_FAILURE (Status))
    {
        AcpiUtRemoveReference (ReturnDesc);
    }
 
    /* Save return object on success */
 
    else
    {
        WalkState->ResultObj = ReturnDesc;
    }
 
    return_ACPI_STATUS (Status);
}

AcpiExOpcode_2A_1T_1R()

ACPI_STATUS AcpiExOpcode_2A_1T_1R

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 279 of file exoparg2.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
    UINT64                  Index;
    ACPI_STATUS             Status = AE_OK;
    ACPI_SIZE               Length = 0;
 
 
    ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_1T_1R,
        AcpiPsGetOpcodeName (WalkState->Opcode));
 
 
    /* Execute the opcode */
 
    if (WalkState->OpInfo->Flags & AML_MATH)
    {
        /* All simple math opcodes (add, etc.) */
 
        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        ReturnDesc->Integer.Value = AcpiExDoMathOp (
            WalkState->Opcode,
            Operand[0]->Integer.Value,
            Operand[1]->Integer.Value);
        goto StoreResultToTarget;
    }
 
    switch (WalkState->Opcode)
    {
    case AML_MOD_OP: /* Mod (Dividend, Divisor, RemainderResult (ACPI 2.0) */
 
        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        /* ReturnDesc will contain the remainder */
 
        Status = AcpiUtDivide (
            Operand[0]->Integer.Value,
            Operand[1]->Integer.Value,
            NULL,
            &ReturnDesc->Integer.Value);
        break;
 
    case AML_CONCATENATE_OP: /* Concatenate (Data1, Data2, Result) */
 
        Status = AcpiExDoConcatenate (
            Operand[0], Operand[1], &ReturnDesc, WalkState);
        break;
 
    case AML_TO_STRING_OP: /* ToString (Buffer, Length, Result) (ACPI 2.0) */
        /*
         * Input object is guaranteed to be a buffer at this point (it may have
         * been converted.)  Copy the raw buffer data to a new object of
         * type String.
         */
 
        /*
         * Get the length of the new string. It is the smallest of:
         * 1) Length of the input buffer
         * 2) Max length as specified in the ToString operator
         * 3) Length of input buffer up to a zero byte (null terminator)
         *
         * NOTE: A length of zero is ok, and will create a zero-length, null
         *       terminated string.
         */
        while ((Length < Operand[0]->Buffer.Length) &&  /* Length of input buffer */
               (Length < Operand[1]->Integer.Value) &&  /* Length operand */
               (Operand[0]->Buffer.Pointer[Length]))    /* Null terminator */
        {
            Length++;
        }
 
        /* Allocate a new string object */
 
        ReturnDesc = AcpiUtCreateStringObject (Length);
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        /*
         * Copy the raw buffer data with no transform.
         * (NULL terminated already)
         */
        memcpy (ReturnDesc->String.Pointer,
            Operand[0]->Buffer.Pointer, Length);
        break;
 
    case AML_CONCATENATE_TEMPLATE_OP:
 
        /* ConcatenateResTemplate (Buffer, Buffer, Result) (ACPI 2.0) */
 
        Status = AcpiExConcatTemplate (
            Operand[0], Operand[1], &ReturnDesc, WalkState);
        break;
 
    case AML_INDEX_OP:              /* Index (Source Index Result) */
 
        /* Create the internal return object */
 
        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_REFERENCE);
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        /* Initialize the Index reference object */
 
        Index = Operand[1]->Integer.Value;
        ReturnDesc->Reference.Value = (UINT32) Index;
        ReturnDesc->Reference.Class = ACPI_REFCLASS_INDEX;
 
        /*
         * At this point, the Source operand is a String, Buffer, or Package.
         * Verify that the index is within range.
         */
        switch ((Operand[0])->Common.Type)
        {
        case ACPI_TYPE_STRING:
 
            if (Index >= Operand[0]->String.Length)
            {
                Length = Operand[0]->String.Length;
                Status = AE_AML_STRING_LIMIT;
            }
 
            ReturnDesc->Reference.TargetType = ACPI_TYPE_BUFFER_FIELD;
            ReturnDesc->Reference.IndexPointer =
                &(Operand[0]->Buffer.Pointer [Index]);
            break;
 
        case ACPI_TYPE_BUFFER:
 
            if (Index >= Operand[0]->Buffer.Length)
            {
                Length = Operand[0]->Buffer.Length;
                Status = AE_AML_BUFFER_LIMIT;
            }
 
            ReturnDesc->Reference.TargetType = ACPI_TYPE_BUFFER_FIELD;
            ReturnDesc->Reference.IndexPointer =
                &(Operand[0]->Buffer.Pointer [Index]);
            break;
 
        case ACPI_TYPE_PACKAGE:
 
            if (Index >= Operand[0]->Package.Count)
            {
                Length = Operand[0]->Package.Count;
                Status = AE_AML_PACKAGE_LIMIT;
            }
 
            ReturnDesc->Reference.TargetType = ACPI_TYPE_PACKAGE;
            ReturnDesc->Reference.Where =
                &Operand[0]->Package.Elements [Index];
            break;
 
        default:
 
            ACPI_ERROR ((AE_INFO,
                "Invalid object type: %X", (Operand[0])->Common.Type));
            Status = AE_AML_INTERNAL;
            goto Cleanup;
        }
 
        /* Failure means that the Index was beyond the end of the object */
 
        if (ACPI_FAILURE (Status))
        {
            ACPI_BIOS_EXCEPTION ((AE_INFO, Status,
                "Index (0x%X%8.8X) is beyond end of object (length 0x%X)",
                ACPI_FORMAT_UINT64 (Index), (UINT32) Length));
            goto Cleanup;
        }
 
        /*
         * Save the target object and add a reference to it for the life
         * of the index
         */
        ReturnDesc->Reference.Object = Operand[0];
        AcpiUtAddReference (Operand[0]);
 
        /* Store the reference to the Target */
 
        Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
 
        /* Return the reference */
 
        WalkState->ResultObj = ReturnDesc;
        goto Cleanup;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            WalkState->Opcode));
        Status = AE_AML_BAD_OPCODE;
        break;
    }
 
 
StoreResultToTarget:
 
    if (ACPI_SUCCESS (Status))
    {
        /*
         * Store the result of the operation (which is now in ReturnDesc) into
         * the Target descriptor.
         */
        Status = AcpiExStore (ReturnDesc, Operand[2], WalkState);
        if (ACPI_FAILURE (Status))
        {
            goto Cleanup;
        }
 
        if (!WalkState->ResultObj)
        {
            WalkState->ResultObj = ReturnDesc;
        }
    }
 
 
Cleanup:
 
    /* Delete return object on error */
 
    if (ACPI_FAILURE (Status))
    {
        AcpiUtRemoveReference (ReturnDesc);
        WalkState->ResultObj = NULL;
    }
 
    return_ACPI_STATUS (Status);
}

AcpiExOpcode_2A_2T_1R()

ACPI_STATUS AcpiExOpcode_2A_2T_1R

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 169 of file exoparg2.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_OPERAND_OBJECT     *ReturnDesc1 = NULL;
    ACPI_OPERAND_OBJECT     *ReturnDesc2 = NULL;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE_STR (ExOpcode_2A_2T_1R,
        AcpiPsGetOpcodeName (WalkState->Opcode));
 
 
    /* Execute the opcode */
 
    switch (WalkState->Opcode)
    {
    case AML_DIVIDE_OP:
 
        /* Divide (Dividend, Divisor, RemainderResult QuotientResult) */
 
        ReturnDesc1 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
        if (!ReturnDesc1)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        ReturnDesc2 = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
        if (!ReturnDesc2)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        /* Quotient to ReturnDesc1, remainder to ReturnDesc2 */
 
        Status = AcpiUtDivide (
            Operand[0]->Integer.Value,
            Operand[1]->Integer.Value,
            &ReturnDesc1->Integer.Value,
            &ReturnDesc2->Integer.Value);
        if (ACPI_FAILURE (Status))
        {
            goto Cleanup;
        }
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            WalkState->Opcode));
 
        Status = AE_AML_BAD_OPCODE;
        goto Cleanup;
    }
 
    /* Store the results to the target reference operands */
 
    Status = AcpiExStore (ReturnDesc2, Operand[2], WalkState);
    if (ACPI_FAILURE (Status))
    {
        goto Cleanup;
    }
 
    Status = AcpiExStore (ReturnDesc1, Operand[3], WalkState);
    if (ACPI_FAILURE (Status))
    {
        goto Cleanup;
    }
 
Cleanup:
    /*
     * Since the remainder is not returned indirectly, remove a reference to
     * it. Only the quotient is returned indirectly.
     */
    AcpiUtRemoveReference (ReturnDesc2);
 
    if (ACPI_FAILURE (Status))
    {
        /* Delete the return object */
 
        AcpiUtRemoveReference (ReturnDesc1);
    }
 
    /* Save return object (the remainder) on success */
 
    else
    {
        WalkState->ResultObj = ReturnDesc1;
    }
 
    return_ACPI_STATUS (Status);
}

AcpiExOpcode_3A_0T_0R()

ACPI_STATUS AcpiExOpcode_3A_0T_0R

(

ACPI_WALK_STATE *

WalkState

)

Naming convention for AML interpreter execution routines.

The routines that begin execution of AML opcodes are named with a common convention based upon the number of arguments, the number of target operands, and whether or not a value is returned:

 AcpiExOpcode_xA_yT_zR

Where:

xA - ARGUMENTS: The number of arguments (input operands) that are required for this opcode type (1 through 6 args). yT - TARGETS: The number of targets (output operands) that are required for this opcode type (0, 1, or 2 targets). zR - RETURN VALUE: Indicates whether this opcode type returns a value as the function return (0 or 1).

The AcpiExOpcode* functions are called via the Dispatcher component with fully resolved operands. !

Definition at line 91 of file exoparg3.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_SIGNAL_FATAL_INFO  *Fatal;
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE_STR (ExOpcode_3A_0T_0R,
        AcpiPsGetOpcodeName (WalkState->Opcode));
 
 
    switch (WalkState->Opcode)
    {
    case AML_FATAL_OP:          /* Fatal (FatalType  FatalCode  FatalArg) */
 
        ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
            "FatalOp: Type %X Code %X Arg %X "
            "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n",
            (UINT32) Operand[0]->Integer.Value,
            (UINT32) Operand[1]->Integer.Value,
            (UINT32) Operand[2]->Integer.Value));
 
        Fatal = ACPI_ALLOCATE (sizeof (ACPI_SIGNAL_FATAL_INFO));
        if (Fatal)
        {
            Fatal->Type = (UINT32) Operand[0]->Integer.Value;
            Fatal->Code = (UINT32) Operand[1]->Integer.Value;
            Fatal->Argument = (UINT32) Operand[2]->Integer.Value;
        }
 
        /* Always signal the OS! */
 
        Status = AcpiOsSignal (ACPI_SIGNAL_FATAL, Fatal);
 
        /* Might return while OS is shutting down, just continue */
 
        ACPI_FREE (Fatal);
        goto Cleanup;
 
    case AML_EXTERNAL_OP:
        /*
         * If the interpreter sees this opcode, just ignore it. The External
         * op is intended for use by disassemblers in order to properly
         * disassemble control method invocations. The opcode or group of
         * opcodes should be surrounded by an "if (0)" clause to ensure that
         * AML interpreters never see the opcode. Thus, something is
         * wrong if an external opcode ever gets here.
         */
        ACPI_ERROR ((AE_INFO, "Executed External Op"));
        Status = AE_OK;
        goto Cleanup;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            WalkState->Opcode));
 
        Status = AE_AML_BAD_OPCODE;
        goto Cleanup;
    }
 
 
Cleanup:
 
    return_ACPI_STATUS (Status);
}

AcpiExOpcode_3A_1T_1R()

ACPI_STATUS AcpiExOpcode_3A_1T_1R

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 173 of file exoparg3.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
    char                    *Buffer = NULL;
    ACPI_STATUS             Status = AE_OK;
    UINT64                  Index;
    ACPI_SIZE               Length;
 
 
    ACPI_FUNCTION_TRACE_STR (ExOpcode_3A_1T_1R,
        AcpiPsGetOpcodeName (WalkState->Opcode));
 
 
    switch (WalkState->Opcode)
    {
    case AML_MID_OP:    /* Mid (Source[0], Index[1], Length[2], Result[3]) */
        /*
         * Create the return object. The Source operand is guaranteed to be
         * either a String or a Buffer, so just use its type.
         */
        ReturnDesc = AcpiUtCreateInternalObject (
            (Operand[0])->Common.Type);
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
        }
 
        /* Get the Integer values from the objects */
 
        Index = Operand[1]->Integer.Value;
        Length = (ACPI_SIZE) Operand[2]->Integer.Value;
 
        /*
         * If the index is beyond the length of the String/Buffer, or if the
         * requested length is zero, return a zero-length String/Buffer
         */
        if (Index >= Operand[0]->String.Length)
        {
            Length = 0;
        }
 
        /* Truncate request if larger than the actual String/Buffer */
 
        else if ((Index + Length) > Operand[0]->String.Length)
        {
            Length =
                (ACPI_SIZE) Operand[0]->String.Length - (ACPI_SIZE) Index;
        }
 
        /* Strings always have a sub-pointer, not so for buffers */
 
        switch ((Operand[0])->Common.Type)
        {
        case ACPI_TYPE_STRING:
 
            /* Always allocate a new buffer for the String */
 
            Buffer = ACPI_ALLOCATE_ZEROED ((ACPI_SIZE) Length + 1);
            if (!Buffer)
            {
                Status = AE_NO_MEMORY;
                goto Cleanup;
            }
            break;
 
        case ACPI_TYPE_BUFFER:
 
            /* If the requested length is zero, don't allocate a buffer */
 
            if (Length > 0)
            {
                /* Allocate a new buffer for the Buffer */
 
                Buffer = ACPI_ALLOCATE_ZEROED (Length);
                if (!Buffer)
                {
                    Status = AE_NO_MEMORY;
                    goto Cleanup;
                }
            }
            break;
 
        default:                        /* Should not happen */
 
            Status = AE_AML_OPERAND_TYPE;
            goto Cleanup;
        }
 
        if (Buffer)
        {
            /* We have a buffer, copy the portion requested */
 
            memcpy (Buffer,
                Operand[0]->String.Pointer + Index, Length);
        }
 
        /* Set the length of the new String/Buffer */
 
        ReturnDesc->String.Pointer = Buffer;
        ReturnDesc->String.Length = (UINT32) Length;
 
        /* Mark buffer initialized */
 
        ReturnDesc->Buffer.Flags |= AOPOBJ_DATA_VALID;
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            WalkState->Opcode));
 
        Status = AE_AML_BAD_OPCODE;
        goto Cleanup;
    }
 
    /* Store the result in the target */
 
    Status = AcpiExStore (ReturnDesc, Operand[3], WalkState);
 
Cleanup:
 
    /* Delete return object on error */
 
    if (ACPI_FAILURE (Status) || WalkState->ResultObj)
    {
        AcpiUtRemoveReference (ReturnDesc);
        WalkState->ResultObj = NULL;
    }
    else
    {
        /* Set the return object and exit */
 
        WalkState->ResultObj = ReturnDesc;
    }
 
    return_ACPI_STATUS (Status);
}

AcpiExOpcode_6A_0T_1R()

ACPI_STATUS AcpiExOpcode_6A_0T_1R

(

ACPI_WALK_STATE *

WalkState

)

Definition at line 221 of file exoparg6.c.

{
    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];
    ACPI_OPERAND_OBJECT     *ReturnDesc = NULL;
    ACPI_STATUS             Status = AE_OK;
    UINT64                  Index;
    ACPI_OPERAND_OBJECT     *ThisElement;
 
 
    ACPI_FUNCTION_TRACE_STR (ExOpcode_6A_0T_1R,
        AcpiPsGetOpcodeName (WalkState->Opcode));
 
 
    switch (WalkState->Opcode)
    {
    case AML_MATCH_OP:
        /*
         * Match (SearchPkg[0], MatchOp1[1], MatchObj1[2],
         *                      MatchOp2[3], MatchObj2[4], StartIndex[5])
         */
 
        /* Validate both Match Term Operators (MTR, MEQ, etc.) */
 
        if ((Operand[1]->Integer.Value > MAX_MATCH_OPERATOR) ||
            (Operand[3]->Integer.Value > MAX_MATCH_OPERATOR))
        {
            ACPI_ERROR ((AE_INFO, "Match operator out of range"));
            Status = AE_AML_OPERAND_VALUE;
            goto Cleanup;
        }
 
        /* Get the package StartIndex, validate against the package length */
 
        Index = Operand[5]->Integer.Value;
        if (Index >= Operand[0]->Package.Count)
        {
            ACPI_ERROR ((AE_INFO,
                "Index (0x%8.8X%8.8X) beyond package end (0x%X)",
                ACPI_FORMAT_UINT64 (Index), Operand[0]->Package.Count));
            Status = AE_AML_PACKAGE_LIMIT;
            goto Cleanup;
        }
 
        /* Create an integer for the return value */
        /* Default return value is ACPI_UINT64_MAX if no match found */
 
        ReturnDesc = AcpiUtCreateIntegerObject (ACPI_UINT64_MAX);
        if (!ReturnDesc)
        {
            Status = AE_NO_MEMORY;
            goto Cleanup;
 
        }
 
        /*
         * Examine each element until a match is found. Both match conditions
         * must be satisfied for a match to occur. Within the loop,
         * "continue" signifies that the current element does not match
         * and the next should be examined.
         *
         * Upon finding a match, the loop will terminate via "break" at
         * the bottom. If it terminates "normally", MatchValue will be
         * ACPI_UINT64_MAX (Ones) (its initial value) indicating that no
         * match was found.
         */
        for ( ; Index < Operand[0]->Package.Count; Index++)
        {
            /* Get the current package element */
 
            ThisElement = Operand[0]->Package.Elements[Index];
 
            /* Treat any uninitialized (NULL) elements as non-matching */
 
            if (!ThisElement)
            {
                continue;
            }
 
            /*
             * Both match conditions must be satisfied. Execution of a continue
             * (proceed to next iteration of enclosing for loop) signifies a
             * non-match.
             */
            if (!AcpiExDoMatch ((UINT32) Operand[1]->Integer.Value,
                    ThisElement, Operand[2]))
            {
                continue;
            }
 
            if (!AcpiExDoMatch ((UINT32) Operand[3]->Integer.Value,
                    ThisElement, Operand[4]))
            {
                continue;
            }
 
            /* Match found: Index is the return value */
 
            ReturnDesc->Integer.Value = Index;
            break;
        }
        break;
 
    case AML_LOAD_TABLE_OP:
 
        Status = AcpiExLoadTableOp (WalkState, &ReturnDesc);
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            WalkState->Opcode));
 
        Status = AE_AML_BAD_OPCODE;
        goto Cleanup;
    }
 
 
Cleanup:
 
    /* Delete return object on error */
 
    if (ACPI_FAILURE (Status))
    {
        AcpiUtRemoveReference (ReturnDesc);
    }
 
    /* Save return object on success */
 
    else
    {
        WalkState->ResultObj = ReturnDesc;
    }
 
    return_ACPI_STATUS (Status);
}

AcpiExPciBarSpaceHandler()

ACPI_STATUS AcpiExPciBarSpaceHandler	(	UINT32	Function,
		ACPI_PHYSICAL_ADDRESS	Address,
		UINT32	BitWidth,
		UINT64 *	Value,
		void *	HandlerContext,
		void *	RegionContext
	)

Definition at line 542 of file exregion.c.

{
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE (ExPciBarSpaceHandler);
 
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvInstallSpaceHandler().

AcpiExPciClsToString()

void AcpiExPciClsToString	(	char *	Dest,
		UINT8	ClassCode[3]
	)

Definition at line 461 of file exutils.c.

{
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* All 3 bytes are hexadecimal */
 
    OutString[0] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[0], 4);
    OutString[1] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[0], 0);
    OutString[2] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[1], 4);
    OutString[3] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[1], 0);
    OutString[4] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[2], 4);
    OutString[5] = AcpiUtHexToAsciiChar ((UINT64) ClassCode[2], 0);
    OutString[6] = 0;
}

Referenced by AcpiUtExecute_CLS().

AcpiExPciConfigSpaceHandler()

ACPI_STATUS AcpiExPciConfigSpaceHandler	(	UINT32	Function,
		ACPI_PHYSICAL_ADDRESS	Address,
		UINT32	BitWidth,
		UINT64 *	Value,
		void *	HandlerContext,
		void *	RegionContext
	)

Definition at line 424 of file exregion.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_PCI_ID             *PciId;
    UINT16                  PciRegister;
 
 
    ACPI_FUNCTION_TRACE (ExPciConfigSpaceHandler);
 
 
    /*
     *  The arguments to AcpiOs(Read|Write)PciConfiguration are:
     *
     *  PciSegment  is the PCI bus segment range 0-31
     *  PciBus      is the PCI bus number range 0-255
     *  PciDevice   is the PCI device number range 0-31
     *  PciFunction is the PCI device function number
     *  PciRegister is the Config space register range 0-255 bytes
     *
     *  Value - input value for write, output address for read
     *
     */
    PciId       = (ACPI_PCI_ID *) RegionContext;
    PciRegister = (UINT16) (UINT32) Address;
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
        "Pci-Config %u (%u) Seg(%04x) Bus(%04x) "
        "Dev(%04x) Func(%04x) Reg(%04x)\n",
        Function, BitWidth, PciId->Segment, PciId->Bus, PciId->Device,
        PciId->Function, PciRegister));
 
    switch (Function)
    {
    case ACPI_READ:
 
        *Value = 0;
        Status = AcpiOsReadPciConfiguration (
            PciId, PciRegister, Value, BitWidth);
        break;
 
    case ACPI_WRITE:
 
        Status = AcpiOsWritePciConfiguration (
            PciId, PciRegister, *Value, BitWidth);
        break;
 
    default:
 
        Status = AE_BAD_PARAMETER;
        break;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvInstallSpaceHandler().

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().

AcpiExReadDataFromField()

ACPI_STATUS AcpiExReadDataFromField	(	ACPI_WALK_STATE *	WalkState,
		ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT **	RetBufferDesc
	)

Definition at line 147 of file exfield.c.

{
    ACPI_STATUS             Status;
    ACPI_OPERAND_OBJECT     *BufferDesc;
    void                    *Buffer;
    UINT32                  BufferLength;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExReadDataFromField, ObjDesc);
 
 
    /* Parameter validation */
 
    if (!ObjDesc)
    {
        return_ACPI_STATUS (AE_AML_NO_OPERAND);
    }
    if (!RetBufferDesc)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
    {
        /*
         * If the BufferField arguments have not been previously evaluated,
         * evaluate them now and save the results.
         */
        if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
        {
            Status = AcpiDsGetBufferFieldArguments (ObjDesc);
            if (ACPI_FAILURE (Status))
            {
                return_ACPI_STATUS (Status);
            }
        }
    }
    else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
        (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||
         ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS ||
         ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI  ||
         ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_PLATFORM_RT ||
         ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_FIXED_HARDWARE))
    {
        /* SMBus, GSBus, IPMI serial */
 
        Status = AcpiExReadSerialBus (ObjDesc, RetBufferDesc);
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Allocate a buffer for the contents of the field.
     *
     * If the field is larger than the current integer width, create
     * a BUFFER to hold it. Otherwise, use an INTEGER. This allows
     * the use of arithmetic operators on the returned value if the
     * field size is equal or smaller than an Integer.
     *
     * However, all buffer fields created by CreateField operator needs to
     * remain as a buffer to match other AML interpreter implementations.
     *
     * Note: Field.length is in bits.
     */
    BufferLength = (ACPI_SIZE) ACPI_ROUND_BITS_UP_TO_BYTES (
        ObjDesc->Field.BitLength);
 
    if (BufferLength > AcpiGbl_IntegerByteWidth ||
        (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD &&
        ObjDesc->BufferField.IsCreateField))
    {
        /* Field is too large for an Integer, create a Buffer instead */
 
        BufferDesc = AcpiUtCreateBufferObject (BufferLength);
        if (!BufferDesc)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
        Buffer = BufferDesc->Buffer.Pointer;
    }
    else
    {
        /* Field will fit within an Integer (normal case) */
 
        BufferDesc = AcpiUtCreateIntegerObject ((UINT64) 0);
        if (!BufferDesc)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        BufferLength = AcpiGbl_IntegerByteWidth;
        Buffer = &BufferDesc->Integer.Value;
    }
 
    if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
        (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GPIO))
    {
        /* General Purpose I/O */
 
        Status = AcpiExReadGpio (ObjDesc, Buffer);
        goto Exit;
    }
    else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
        (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_PLATFORM_COMM))
    {
        /*
         * Reading from a PCC field unit does not require the handler because
         * it only requires reading from the InternalPccBuffer.
         */
        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
            "PCC FieldRead bits %u\n", ObjDesc->Field.BitLength));
 
        memcpy (Buffer, ObjDesc->Field.RegionObj->Field.InternalPccBuffer +
        ObjDesc->Field.BaseByteOffset, (ACPI_SIZE) ACPI_ROUND_BITS_UP_TO_BYTES (
            ObjDesc->Field.BitLength));
 
        *RetBufferDesc = BufferDesc;
        return AE_OK;
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
        "FieldRead [TO]:   Obj %p, Type %X, Buf %p, ByteLen %X\n",
        ObjDesc, ObjDesc->Common.Type, Buffer, BufferLength));
    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
        "FieldRead [FROM]: BitLen %X, BitOff %X, ByteOff %X\n",
        ObjDesc->CommonField.BitLength,
        ObjDesc->CommonField.StartFieldBitOffset,
        ObjDesc->CommonField.BaseByteOffset));
 
    /* Lock entire transaction if requested */
 
    AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 
    /* Read from the field */
 
    Status = AcpiExExtractFromField (ObjDesc, Buffer, BufferLength);
    AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 
 
Exit:
    if (ACPI_FAILURE (Status))
    {
        AcpiUtRemoveReference (BufferDesc);
    }
    else
    {
        *RetBufferDesc = BufferDesc;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExOpcode_1A_0T_1R(), AcpiExResolveNodeToValue(), and AcpiExResolveObjectToValue().

AcpiExReadGpio()

ACPI_STATUS AcpiExReadGpio	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		void *	Buffer
	)

Definition at line 70 of file exserial.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExReadGpio, ObjDesc);
 
 
    /*
     * For GPIO (GeneralPurposeIo), the Address will be the bit offset
     * from the previous Connection() operator, making it effectively a
     * pin number index. The BitLength is the length of the field, which
     * is thus the number of pins.
     */
    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
        "GPIO FieldRead [FROM]:  Pin %u Bits %u\n",
        ObjDesc->Field.PinNumberIndex, ObjDesc->Field.BitLength));
 
    /* Lock entire transaction if requested */
 
    AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 
    /* Perform the read */
 
    Status = AcpiExAccessRegion (
        ObjDesc, 0, (UINT64 *) Buffer, ACPI_READ);
 
    AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExReadDataFromField().

AcpiExReadSerialBus()

ACPI_STATUS AcpiExReadSerialBus	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT **	ReturnBuffer
	)

Definition at line 182 of file exserial.c.

{
    ACPI_STATUS             Status;
    UINT32                  BufferLength;
    ACPI_OPERAND_OBJECT     *BufferDesc;
    UINT32                  Function;
    UINT16                  AccessorType;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExReadSerialBus, ObjDesc);
 
 
    /*
     * This is an SMBus, GSBus or IPMI read. We must create a buffer to
     * hold the data and then directly access the region handler.
     *
     * Note: SMBus and GSBus protocol value is passed in upper 16-bits
     * of Function
     *
     * Common buffer format:
     *     Status;    (Byte 0 of the data buffer)
     *     Length;    (Byte 1 of the data buffer)
     *     Data[x-1]: (Bytes 2-x of the arbitrary length data buffer)
     */
    switch (ObjDesc->Field.RegionObj->Region.SpaceId)
    {
    case ACPI_ADR_SPACE_SMBUS:
 
        BufferLength = ACPI_SMBUS_BUFFER_SIZE;
        Function = ACPI_READ | (ObjDesc->Field.Attribute << 16);
        break;
 
    case ACPI_ADR_SPACE_IPMI:
 
        BufferLength = ACPI_IPMI_BUFFER_SIZE;
        Function = ACPI_READ;
        break;
 
    case ACPI_ADR_SPACE_GSBUS:
 
        AccessorType = ObjDesc->Field.Attribute;
        if (AccessorType == AML_FIELD_ATTRIB_RAW_PROCESS_BYTES)
        {
            ACPI_ERROR ((AE_INFO,
                "Invalid direct read using bidirectional write-then-read protocol"));
 
            return_ACPI_STATUS (AE_AML_PROTOCOL);
        }
 
        Status = AcpiExGetProtocolBufferLength (AccessorType, &BufferLength);
        if (ACPI_FAILURE (Status))
        {
            ACPI_ERROR ((AE_INFO,
                "Invalid protocol ID for GSBus: 0x%4.4X", AccessorType));
 
            return_ACPI_STATUS (Status);
        }
 
        /* Add header length to get the full size of the buffer */
 
        BufferLength += ACPI_SERIAL_HEADER_SIZE;
        Function = ACPI_READ | (AccessorType << 16);
        break;
 
    case ACPI_ADR_SPACE_PLATFORM_RT:
 
        BufferLength = ACPI_PRM_INPUT_BUFFER_SIZE;
        Function = ACPI_READ;
        break;
 
    default:
        return_ACPI_STATUS (AE_AML_INVALID_SPACE_ID);
    }
 
    /* Create the local transfer buffer that is returned to the caller */
 
    BufferDesc = AcpiUtCreateBufferObject (BufferLength);
    if (!BufferDesc)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /* Lock entire transaction if requested */
 
    AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 
    /* Call the region handler for the write-then-read */
 
    Status = AcpiExAccessRegion (ObjDesc, 0,
        ACPI_CAST_PTR (UINT64, BufferDesc->Buffer.Pointer), Function);
    AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 
    *ReturnBuffer = BufferDesc;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExReadDataFromField().

AcpiExReleaseAllMutexes()

void AcpiExReleaseAllMutexes

(

ACPI_THREAD_STATE *

Thread

)

Definition at line 536 of file exmutex.c.

{
    ACPI_OPERAND_OBJECT     *Next = Thread->AcquiredMutexList;
    ACPI_OPERAND_OBJECT     *ObjDesc;
 
 
    ACPI_FUNCTION_TRACE (ExReleaseAllMutexes);
 
 
    /* Traverse the list of owned mutexes, releasing each one */
 
    while (Next)
    {
        ObjDesc = Next;
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "Mutex [%4.4s] force-release, SyncLevel %u Depth %u\n",
            ObjDesc->Mutex.Node->Name.Ascii, ObjDesc->Mutex.SyncLevel,
            ObjDesc->Mutex.AcquisitionDepth));
 
        /* Release the mutex, special case for Global Lock */
 
        if (ObjDesc == AcpiGbl_GlobalLockMutex)
        {
            /* Ignore errors */
 
            (void) AcpiEvReleaseGlobalLock ();
        }
        else
        {
            AcpiOsReleaseMutex (ObjDesc->Mutex.OsMutex);
        }
 
        /* Update Thread SyncLevel (Last mutex is the important one) */
 
        Thread->CurrentSyncLevel = ObjDesc->Mutex.OriginalSyncLevel;
 
        /* Mark mutex unowned */
 
        Next = ObjDesc->Mutex.Next;
 
        ObjDesc->Mutex.Prev = NULL;
        ObjDesc->Mutex.Next = NULL;
        ObjDesc->Mutex.AcquisitionDepth = 0;
        ObjDesc->Mutex.OwnerThread = NULL;
        ObjDesc->Mutex.ThreadId = 0;
    }
 
    return_VOID;
}

Referenced by AcpiPsParseAml().

AcpiExReleaseGlobalLock()

void AcpiExReleaseGlobalLock

(

UINT32

Rule

)

Definition at line 270 of file exutils.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (ExReleaseGlobalLock);
 
 
    /* Only use the lock if the AlwaysLock bit is set */
 
    if (!(FieldFlags & AML_FIELD_LOCK_RULE_MASK))
    {
        return_VOID;
    }
 
    /* Release the global lock */
 
    Status = AcpiExReleaseMutexObject (AcpiGbl_GlobalLockMutex);
    if (ACPI_FAILURE (Status))
    {
        /* Report the error, but there isn't much else we can do */
 
        ACPI_EXCEPTION ((AE_INFO, Status,
            "Could not release Global Lock"));
    }
 
    return_VOID;
}

Referenced by AcpiExReadDataFromField(), AcpiExReadGpio(), AcpiExReadSerialBus(), AcpiExWriteDataToField(), AcpiExWriteGpio(), and AcpiExWriteSerialBus().

AcpiExReleaseMutex()

ACPI_STATUS AcpiExReleaseMutex	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 408 of file exmutex.c.

{
    UINT8                   PreviousSyncLevel;
    ACPI_THREAD_STATE       *OwnerThread;
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE (ExReleaseMutex);
 
 
    if (!ObjDesc)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    OwnerThread = ObjDesc->Mutex.OwnerThread;
 
    /* The mutex must have been previously acquired in order to release it */
 
    if (!OwnerThread)
    {
        ACPI_ERROR ((AE_INFO,
            "Cannot release Mutex [%4.4s], not acquired",
            AcpiUtGetNodeName (ObjDesc->Mutex.Node)));
        return_ACPI_STATUS (AE_AML_MUTEX_NOT_ACQUIRED);
    }
 
    /* Must have a valid thread ID */
 
    if (!WalkState->Thread)
    {
        ACPI_ERROR ((AE_INFO,
            "Cannot release Mutex [%4.4s], null thread info",
            AcpiUtGetNodeName (ObjDesc->Mutex.Node)));
        return_ACPI_STATUS (AE_AML_INTERNAL);
    }
 
    /*
     * The Mutex is owned, but this thread must be the owner.
     * Special case for Global Lock, any thread can release
     */
    if ((OwnerThread->ThreadId != WalkState->Thread->ThreadId) &&
        (ObjDesc != AcpiGbl_GlobalLockMutex))
    {
        ACPI_ERROR ((AE_INFO,
            "Thread %u cannot release Mutex [%4.4s] acquired by thread %u",
            (UINT32) WalkState->Thread->ThreadId,
            AcpiUtGetNodeName (ObjDesc->Mutex.Node),
            (UINT32) OwnerThread->ThreadId));
        return_ACPI_STATUS (AE_AML_NOT_OWNER);
    }
 
    /*
     * The sync level of the mutex must be equal to the current sync level. In
     * other words, the current level means that at least one mutex at that
     * level is currently being held. Attempting to release a mutex of a
     * different level can only mean that the mutex ordering rule is being
     * violated. This behavior is clarified in ACPI 4.0 specification.
     */
    if (ObjDesc->Mutex.SyncLevel != OwnerThread->CurrentSyncLevel)
    {
        ACPI_ERROR ((AE_INFO,
            "Cannot release Mutex [%4.4s], SyncLevel mismatch: "
            "mutex %u current %u",
            AcpiUtGetNodeName (ObjDesc->Mutex.Node),
            ObjDesc->Mutex.SyncLevel, WalkState->Thread->CurrentSyncLevel));
        return_ACPI_STATUS (AE_AML_MUTEX_ORDER);
    }
 
    /*
     * Get the previous SyncLevel from the head of the acquired mutex list.
     * This handles the case where several mutexes at the same level have been
     * acquired, but are not released in reverse order.
     */
    PreviousSyncLevel =
        OwnerThread->AcquiredMutexList->Mutex.OriginalSyncLevel;
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
        "Releasing: Object SyncLevel %u, Thread SyncLevel %u, "
        "Prev SyncLevel %u, Depth %u TID %p\n",
        ObjDesc->Mutex.SyncLevel, WalkState->Thread->CurrentSyncLevel,
        PreviousSyncLevel, ObjDesc->Mutex.AcquisitionDepth,
        WalkState->Thread));
 
    Status = AcpiExReleaseMutexObject (ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    if (ObjDesc->Mutex.AcquisitionDepth == 0)
    {
        /* Restore the previous SyncLevel */
 
        OwnerThread->CurrentSyncLevel = PreviousSyncLevel;
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
        "Released: Object SyncLevel %u, Thread SyncLevel, %u, "
        "Prev SyncLevel %u, Depth %u\n",
        ObjDesc->Mutex.SyncLevel, WalkState->Thread->CurrentSyncLevel,
        PreviousSyncLevel, ObjDesc->Mutex.AcquisitionDepth));
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExOpcode_1A_0T_0R().

AcpiExReleaseMutexObject()

ACPI_STATUS AcpiExReleaseMutexObject

(

ACPI_OPERAND_OBJECT *

ObjDesc

)

Definition at line 344 of file exmutex.c.

{
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE (ExReleaseMutexObject);
 
 
    if (ObjDesc->Mutex.AcquisitionDepth == 0)
    {
        return_ACPI_STATUS (AE_NOT_ACQUIRED);
    }
 
    /* Match multiple Acquires with multiple Releases */
 
    ObjDesc->Mutex.AcquisitionDepth--;
    if (ObjDesc->Mutex.AcquisitionDepth != 0)
    {
        /* Just decrement the depth and return */
 
        return_ACPI_STATUS (AE_OK);
    }
 
    if (ObjDesc->Mutex.OwnerThread)
    {
        /* Unlink the mutex from the owner's list */
 
        AcpiExUnlinkMutex (ObjDesc);
        ObjDesc->Mutex.OwnerThread = NULL;
    }
 
    /* Release the mutex, special case for Global Lock */
 
    if (ObjDesc == AcpiGbl_GlobalLockMutex)
    {
        Status = AcpiEvReleaseGlobalLock ();
    }
    else
    {
        AcpiOsReleaseMutex (ObjDesc->Mutex.OsMutex);
    }
 
    /* Clear mutex info */
 
    ObjDesc->Mutex.ThreadId = 0;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExReleaseGlobalLock(), AcpiExReleaseMutex(), and AcpiReleaseGlobalLock().

AcpiExResolveMultiple()

ACPI_STATUS AcpiExResolveMultiple	(	ACPI_WALK_STATE *	WalkState,
		ACPI_OPERAND_OBJECT *	Operand,
		ACPI_OBJECT_TYPE *	ReturnType,
		ACPI_OPERAND_OBJECT **	ReturnDesc
	)

Definition at line 350 of file exresolv.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc = ACPI_CAST_PTR (void, Operand);
    ACPI_NAMESPACE_NODE     *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Operand);
    ACPI_OBJECT_TYPE        Type;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (AcpiExResolveMultiple);
 
 
    /* Operand can be either a namespace node or an operand descriptor */
 
    switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc))
    {
    case ACPI_DESC_TYPE_OPERAND:
 
        Type = ObjDesc->Common.Type;
        break;
 
    case ACPI_DESC_TYPE_NAMED:
 
        Type = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type;
        ObjDesc = AcpiNsGetAttachedObject (Node);
 
        /* If we had an Alias node, use the attached object for type info */
 
        if (Type == ACPI_TYPE_LOCAL_ALIAS)
        {
            Type = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type;
            ObjDesc = AcpiNsGetAttachedObject (
                (ACPI_NAMESPACE_NODE *) ObjDesc);
        }
 
        switch (Type)
        {
        case ACPI_TYPE_DEVICE:
        case ACPI_TYPE_THERMAL:
 
            /* These types have no attached subobject */
            break;
 
        default:
 
            /* All other types require a subobject */
 
            if (!ObjDesc)
            {
                ACPI_ERROR ((AE_INFO,
                    "[%4.4s] Node is unresolved or uninitialized",
                    AcpiUtGetNodeName (Node)));
                return_ACPI_STATUS (AE_AML_UNINITIALIZED_NODE);
            }
            break;
        }
        break;
 
    default:
        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
    }
 
    /* If type is anything other than a reference, we are done */
 
    if (Type != ACPI_TYPE_LOCAL_REFERENCE)
    {
        goto Exit;
    }
 
    /*
     * For reference objects created via the RefOf, Index, or Load/LoadTable
     * operators, we need to get to the base object (as per the ACPI
     * specification of the ObjectType and SizeOf operators). This means
     * traversing the list of possibly many nested references.
     */
    while (ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REFERENCE)
    {
        switch (ObjDesc->Reference.Class)
        {
        case ACPI_REFCLASS_REFOF:
        case ACPI_REFCLASS_NAME:
 
            /* Dereference the reference pointer */
 
            if (ObjDesc->Reference.Class == ACPI_REFCLASS_REFOF)
            {
                Node = ObjDesc->Reference.Object;
            }
            else /* AML_INT_NAMEPATH_OP */
            {
                Node = ObjDesc->Reference.Node;
            }
 
            /* All "References" point to a NS node */
 
            if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
            {
                ACPI_ERROR ((AE_INFO,
                    "Not a namespace node %p [%s]",
                    Node, AcpiUtGetDescriptorName (Node)));
                return_ACPI_STATUS (AE_AML_INTERNAL);
            }
 
            /* Get the attached object */
 
            ObjDesc = AcpiNsGetAttachedObject (Node);
            if (!ObjDesc)
            {
                /* No object, use the NS node type */
 
                Type = AcpiNsGetType (Node);
                goto Exit;
            }
 
            /* Check for circular references */
 
            if (ObjDesc == Operand)
            {
                return_ACPI_STATUS (AE_AML_CIRCULAR_REFERENCE);
            }
            break;
 
        case ACPI_REFCLASS_INDEX:
 
            /* Get the type of this reference (index into another object) */
 
            Type = ObjDesc->Reference.TargetType;
            if (Type != ACPI_TYPE_PACKAGE)
            {
                goto Exit;
            }
 
            /*
             * The main object is a package, we want to get the type
             * of the individual package element that is referenced by
             * the index.
             *
             * This could of course in turn be another reference object.
             */
            ObjDesc = *(ObjDesc->Reference.Where);
            if (!ObjDesc)
            {
                /* NULL package elements are allowed */
 
                Type = 0; /* Uninitialized */
                goto Exit;
            }
            break;
 
        case ACPI_REFCLASS_TABLE:
 
            Type = ACPI_TYPE_DDB_HANDLE;
            goto Exit;
 
        case ACPI_REFCLASS_LOCAL:
        case ACPI_REFCLASS_ARG:
 
            if (ReturnDesc)
            {
                Status = AcpiDsMethodDataGetValue (ObjDesc->Reference.Class,
                    ObjDesc->Reference.Value, WalkState, &ObjDesc);
                if (ACPI_FAILURE (Status))
                {
                    return_ACPI_STATUS (Status);
                }
                AcpiUtRemoveReference (ObjDesc);
            }
            else
            {
                Status = AcpiDsMethodDataGetNode (ObjDesc->Reference.Class,
                    ObjDesc->Reference.Value, WalkState, &Node);
                if (ACPI_FAILURE (Status))
                {
                    return_ACPI_STATUS (Status);
                }
 
                ObjDesc = AcpiNsGetAttachedObject (Node);
                if (!ObjDesc)
                {
                    Type = ACPI_TYPE_ANY;
                    goto Exit;
                }
            }
            break;
 
        case ACPI_REFCLASS_DEBUG:
 
            /* The Debug Object is of type "DebugObject" */
 
            Type = ACPI_TYPE_DEBUG_OBJECT;
            goto Exit;
 
        default:
 
            ACPI_ERROR ((AE_INFO,
                "Unknown Reference Class 0x%2.2X",
                ObjDesc->Reference.Class));
            return_ACPI_STATUS (AE_AML_INTERNAL);
        }
    }
 
    /*
     * Now we are guaranteed to have an object that has not been created
     * via the RefOf or Index operators.
     */
    Type = ObjDesc->Common.Type;
 
 
Exit:
    /* Convert internal types to external types */
 
    switch (Type)
    {
    case ACPI_TYPE_LOCAL_REGION_FIELD:
    case ACPI_TYPE_LOCAL_BANK_FIELD:
    case ACPI_TYPE_LOCAL_INDEX_FIELD:
 
        Type = ACPI_TYPE_FIELD_UNIT;
        break;
 
    case ACPI_TYPE_LOCAL_SCOPE:
 
        /* Per ACPI Specification, Scope is untyped */
 
        Type = ACPI_TYPE_ANY;
        break;
 
    default:
 
        /* No change to Type required */
 
        break;
    }
 
    *ReturnType = Type;
    if (ReturnDesc)
    {
        *ReturnDesc = ObjDesc;
    }
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExOpcode_1A_0T_1R(), and AcpiExResolveMultiple().

AcpiExResolveNodeToValue()

ACPI_STATUS AcpiExResolveNodeToValue	(	ACPI_NAMESPACE_NODE **	StackPtr,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 82 of file exresnte.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_OPERAND_OBJECT     *SourceDesc;
    ACPI_OPERAND_OBJECT     *ObjDesc = NULL;
    ACPI_NAMESPACE_NODE     *Node;
    ACPI_OBJECT_TYPE        EntryType;
 
 
    ACPI_FUNCTION_TRACE (ExResolveNodeToValue);
 
 
    /*
     * The stack pointer points to a ACPI_NAMESPACE_NODE (Node). Get the
     * object that is attached to the Node.
     */
    Node = *ObjectPtr;
    SourceDesc = AcpiNsGetAttachedObject (Node);
    EntryType = AcpiNsGetType ((ACPI_HANDLE) Node);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Entry=%p SourceDesc=%p [%s]\n",
         Node, SourceDesc, AcpiUtGetTypeName (EntryType)));
 
    if ((EntryType == ACPI_TYPE_LOCAL_ALIAS) ||
        (EntryType == ACPI_TYPE_LOCAL_METHOD_ALIAS))
    {
        /* There is always exactly one level of indirection */
 
        Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Node->Object);
        SourceDesc = AcpiNsGetAttachedObject (Node);
        EntryType = AcpiNsGetType ((ACPI_HANDLE) Node);
        *ObjectPtr = Node;
    }
 
    /*
     * Several object types require no further processing:
     * 1) Device/Thermal objects don't have a "real" subobject, return Node
     * 2) Method locals and arguments have a pseudo-Node
     * 3) 10/2007: Added method type to assist with Package construction.
     */
    if ((EntryType == ACPI_TYPE_DEVICE)  ||
        (EntryType == ACPI_TYPE_THERMAL) ||
        (EntryType == ACPI_TYPE_METHOD)  ||
        (Node->Flags & (ANOBJ_METHOD_ARG | ANOBJ_METHOD_LOCAL)))
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    if (!SourceDesc)
    {
        ACPI_ERROR ((AE_INFO, "No object attached to node [%4.4s] %p",
            Node->Name.Ascii, Node));
        return_ACPI_STATUS (AE_AML_UNINITIALIZED_NODE);
    }
 
    /*
     * Action is based on the type of the Node, which indicates the type
     * of the attached object or pointer
     */
    switch (EntryType)
    {
    case ACPI_TYPE_PACKAGE:
 
        if (SourceDesc->Common.Type != ACPI_TYPE_PACKAGE)
        {
            ACPI_ERROR ((AE_INFO, "Object not a Package, type %s",
                AcpiUtGetObjectTypeName (SourceDesc)));
            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
 
        Status = AcpiDsGetPackageArguments (SourceDesc);
        if (ACPI_SUCCESS (Status))
        {
            /* Return an additional reference to the object */
 
            ObjDesc = SourceDesc;
            AcpiUtAddReference (ObjDesc);
        }
        break;
 
    case ACPI_TYPE_BUFFER:
 
        if (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)
        {
            ACPI_ERROR ((AE_INFO, "Object not a Buffer, type %s",
                AcpiUtGetObjectTypeName (SourceDesc)));
            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
 
        Status = AcpiDsGetBufferArguments (SourceDesc);
        if (ACPI_SUCCESS (Status))
        {
            /* Return an additional reference to the object */
 
            ObjDesc = SourceDesc;
            AcpiUtAddReference (ObjDesc);
        }
        break;
 
    case ACPI_TYPE_STRING:
 
        if (SourceDesc->Common.Type != ACPI_TYPE_STRING)
        {
            ACPI_ERROR ((AE_INFO, "Object not a String, type %s",
                AcpiUtGetObjectTypeName (SourceDesc)));
            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
 
        /* Return an additional reference to the object */
 
        ObjDesc = SourceDesc;
        AcpiUtAddReference (ObjDesc);
        break;
 
    case ACPI_TYPE_INTEGER:
 
        if (SourceDesc->Common.Type != ACPI_TYPE_INTEGER)
        {
            ACPI_ERROR ((AE_INFO, "Object not a Integer, type %s",
                AcpiUtGetObjectTypeName (SourceDesc)));
            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
 
        /* Return an additional reference to the object */
 
        ObjDesc = SourceDesc;
        AcpiUtAddReference (ObjDesc);
        break;
 
    case ACPI_TYPE_BUFFER_FIELD:
    case ACPI_TYPE_LOCAL_REGION_FIELD:
    case ACPI_TYPE_LOCAL_BANK_FIELD:
    case ACPI_TYPE_LOCAL_INDEX_FIELD:
 
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "FieldRead Node=%p SourceDesc=%p Type=%X\n",
            Node, SourceDesc, EntryType));
 
        Status = AcpiExReadDataFromField (WalkState, SourceDesc, &ObjDesc);
        break;
 
    /* For these objects, just return the object attached to the Node */
 
    case ACPI_TYPE_MUTEX:
    case ACPI_TYPE_POWER:
    case ACPI_TYPE_PROCESSOR:
    case ACPI_TYPE_EVENT:
    case ACPI_TYPE_REGION:
 
        /* Return an additional reference to the object */
 
        ObjDesc = SourceDesc;
        AcpiUtAddReference (ObjDesc);
        break;
 
    /* TYPE_ANY is untyped, and thus there is no object associated with it */
 
    case ACPI_TYPE_ANY:
 
        ACPI_ERROR ((AE_INFO,
            "Untyped entry %p, no attached object!", Node));
 
        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);  /* Cannot be AE_TYPE */
 
    case ACPI_TYPE_LOCAL_REFERENCE:
 
        switch (SourceDesc->Reference.Class)
        {
        case ACPI_REFCLASS_TABLE:   /* This is a DdbHandle */
        case ACPI_REFCLASS_REFOF:
        case ACPI_REFCLASS_INDEX:
 
            /* Return an additional reference to the object */
 
            ObjDesc = SourceDesc;
            AcpiUtAddReference (ObjDesc);
            break;
 
        default:
 
            /* No named references are allowed here */
 
            ACPI_ERROR ((AE_INFO,
                "Unsupported Reference type 0x%X",
                SourceDesc->Reference.Class));
 
            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
        break;
 
    default:
 
        /* Default case is for unknown types */
 
        ACPI_ERROR ((AE_INFO,
            "Node %p - Unknown object type 0x%X",
            Node, EntryType));
 
        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 
    } /* switch (EntryType) */
 
 
    /* Return the object descriptor */
 
    *ObjectPtr = (void *) ObjDesc;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsResolvePackageElement(), AcpiExOpcode_1A_0T_1R(), AcpiExResolveToValue(), and AcpiNsEvaluate().

AcpiExResolveObject()

ACPI_STATUS AcpiExResolveObject	(	ACPI_OPERAND_OBJECT **	SourceDescPtr,
		ACPI_OBJECT_TYPE	TargetType,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 71 of file exstoren.c.

{
    ACPI_OPERAND_OBJECT     *SourceDesc = *SourceDescPtr;
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE (ExResolveObject);
 
 
    /* Ensure we have a Target that can be stored to */
 
    switch (TargetType)
    {
    case ACPI_TYPE_BUFFER_FIELD:
    case ACPI_TYPE_LOCAL_REGION_FIELD:
    case ACPI_TYPE_LOCAL_BANK_FIELD:
    case ACPI_TYPE_LOCAL_INDEX_FIELD:
        /*
         * These cases all require only Integers or values that
         * can be converted to Integers (Strings or Buffers)
         */
    case ACPI_TYPE_INTEGER:
    case ACPI_TYPE_STRING:
    case ACPI_TYPE_BUFFER:
        /*
         * Stores into a Field/Region or into a Integer/Buffer/String
         * are all essentially the same. This case handles the
         * "interchangeable" types Integer, String, and Buffer.
         */
        if (SourceDesc->Common.Type == ACPI_TYPE_LOCAL_REFERENCE)
        {
            /* Resolve a reference object first */
 
            Status = AcpiExResolveToValue (SourceDescPtr, WalkState);
            if (ACPI_FAILURE (Status))
            {
                break;
            }
        }
 
        /* For CopyObject, no further validation necessary */
 
        if (WalkState->Opcode == AML_COPY_OBJECT_OP)
        {
            break;
        }
 
        /* Must have a Integer, Buffer, or String */
 
        if ((SourceDesc->Common.Type != ACPI_TYPE_INTEGER)    &&
            (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)     &&
            (SourceDesc->Common.Type != ACPI_TYPE_STRING)     &&
            !((SourceDesc->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) &&
                (SourceDesc->Reference.Class== ACPI_REFCLASS_TABLE)))
        {
            /* Conversion successful but still not a valid type */
 
            ACPI_ERROR ((AE_INFO,
                "Cannot assign type [%s] to [%s] (must be type Int/Str/Buf)",
                AcpiUtGetObjectTypeName (SourceDesc),
                AcpiUtGetTypeName (TargetType)));
 
            Status = AE_AML_OPERAND_TYPE;
        }
        break;
 
    case ACPI_TYPE_LOCAL_ALIAS:
    case ACPI_TYPE_LOCAL_METHOD_ALIAS:
        /*
         * All aliases should have been resolved earlier, during the
         * operand resolution phase.
         */
        ACPI_ERROR ((AE_INFO, "Store into an unresolved Alias object"));
        Status = AE_AML_INTERNAL;
        break;
 
    case ACPI_TYPE_PACKAGE:
    default:
        /*
         * All other types than Alias and the various Fields come here,
         * including the untyped case - ACPI_TYPE_ANY.
         */
        break;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExStoreObjectToNode().

AcpiExResolveOperands()

ACPI_STATUS AcpiExResolveOperands	(	UINT16	Opcode,
		ACPI_OPERAND_OBJECT **	StackPtr,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 145 of file exresop.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_STATUS             Status = AE_OK;
    UINT8                   ObjectType;
    UINT32                  ArgTypes;
    const ACPI_OPCODE_INFO  *OpInfo;
    UINT32                  ThisArgType;
    ACPI_OBJECT_TYPE        TypeNeeded;
    UINT16                  TargetOp = 0;
 
 
    ACPI_FUNCTION_TRACE_U32 (ExResolveOperands, Opcode);
 
 
    OpInfo = AcpiPsGetOpcodeInfo (Opcode);
    if (OpInfo->Class == AML_CLASS_UNKNOWN)
    {
        return_ACPI_STATUS (AE_AML_BAD_OPCODE);
    }
 
    ArgTypes = OpInfo->RuntimeArgs;
    if (ArgTypes == ARGI_INVALID_OPCODE)
    {
        ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
            Opcode));
 
        return_ACPI_STATUS (AE_AML_INTERNAL);
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
        "Opcode %X [%s] RequiredOperandTypes=%8.8X\n",
        Opcode, OpInfo->Name, ArgTypes));
 
    /*
     * Normal exit is with (ArgTypes == 0) at end of argument list.
     * Function will return an exception from within the loop upon
     * finding an entry which is not (or cannot be converted
     * to) the required type; if stack underflows; or upon
     * finding a NULL stack entry (which should not happen).
     */
    while (GET_CURRENT_ARG_TYPE (ArgTypes))
    {
        if (!StackPtr || !*StackPtr)
        {
            ACPI_ERROR ((AE_INFO, "Null stack entry at %p",
                StackPtr));
 
            return_ACPI_STATUS (AE_AML_INTERNAL);
        }
 
        /* Extract useful items */
 
        ObjDesc = *StackPtr;
 
        /* Decode the descriptor type */
 
        switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc))
        {
        case ACPI_DESC_TYPE_NAMED:
 
            /* Namespace Node */
 
            ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type;
 
            /*
             * Resolve an alias object. The construction of these objects
             * guarantees that there is only one level of alias indirection;
             * thus, the attached object is always the aliased namespace node
             */
            if (ObjectType == ACPI_TYPE_LOCAL_ALIAS)
            {
                ObjDesc = AcpiNsGetAttachedObject (
                    (ACPI_NAMESPACE_NODE *) ObjDesc);
                *StackPtr = ObjDesc;
                ObjectType = ((ACPI_NAMESPACE_NODE *) ObjDesc)->Type;
            }
            break;
 
        case ACPI_DESC_TYPE_OPERAND:
 
            /* ACPI internal object */
 
            ObjectType = ObjDesc->Common.Type;
 
            /* Check for bad ACPI_OBJECT_TYPE */
 
            if (!AcpiUtValidObjectType (ObjectType))
            {
                ACPI_ERROR ((AE_INFO,
                    "Bad operand object type [0x%X]", ObjectType));
 
                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
            }
 
            if (ObjectType == (UINT8) ACPI_TYPE_LOCAL_REFERENCE)
            {
                /* Validate the Reference */
 
                switch (ObjDesc->Reference.Class)
                {
                case ACPI_REFCLASS_DEBUG:
 
                    TargetOp = AML_DEBUG_OP;
 
                    ACPI_FALLTHROUGH;
 
                case ACPI_REFCLASS_ARG:
                case ACPI_REFCLASS_LOCAL:
                case ACPI_REFCLASS_INDEX:
                case ACPI_REFCLASS_REFOF:
                case ACPI_REFCLASS_TABLE:    /* DdbHandle from LOAD_OP or LOAD_TABLE_OP */
                case ACPI_REFCLASS_NAME:     /* Reference to a named object */
 
                    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
                        "Operand is a Reference, Class [%s] %2.2X\n",
                        AcpiUtGetReferenceName (ObjDesc),
                        ObjDesc->Reference.Class));
                    break;
 
                default:
 
                    ACPI_ERROR ((AE_INFO,
                        "Unknown Reference Class 0x%2.2X in %p",
                        ObjDesc->Reference.Class, ObjDesc));
 
                    return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
                }
            }
            break;
 
        default:
 
            /* Invalid descriptor */
 
            ACPI_ERROR ((AE_INFO, "Invalid descriptor %p [%s]",
                ObjDesc, AcpiUtGetDescriptorName (ObjDesc)));
 
            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
        }
 
        /* Get one argument type, point to the next */
 
        ThisArgType = GET_CURRENT_ARG_TYPE (ArgTypes);
        INCREMENT_ARG_LIST (ArgTypes);
 
        /*
         * Handle cases where the object does not need to be
         * resolved to a value
         */
        switch (ThisArgType)
        {
        case ARGI_REF_OR_STRING:        /* Can be a String or Reference */
 
            if ((ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) ==
                ACPI_DESC_TYPE_OPERAND) &&
                (ObjDesc->Common.Type == ACPI_TYPE_STRING))
            {
                /*
                 * String found - the string references a named object and
                 * must be resolved to a node
                 */
                goto NextOperand;
            }
 
            /*
             * Else not a string - fall through to the normal Reference
             * case below
             */
            ACPI_FALLTHROUGH;
 
        case ARGI_REFERENCE:            /* References: */
        case ARGI_INTEGER_REF:
        case ARGI_OBJECT_REF:
        case ARGI_DEVICE_REF:
        case ARGI_TARGETREF:     /* Allows implicit conversion rules before store */
        case ARGI_FIXED_TARGET:  /* No implicit conversion before store to target */
        case ARGI_SIMPLE_TARGET: /* Name, Local, or Arg - no implicit conversion  */
        case ARGI_STORE_TARGET:
 
            /*
             * Need an operand of type ACPI_TYPE_LOCAL_REFERENCE
             * A Namespace Node is OK as-is
             */
            if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_NAMED)
            {
                goto NextOperand;
            }
 
            Status = AcpiExCheckObjectType (
                ACPI_TYPE_LOCAL_REFERENCE, ObjectType, ObjDesc);
            if (ACPI_FAILURE (Status))
            {
                return_ACPI_STATUS (Status);
            }
            goto NextOperand;
 
        case ARGI_DATAREFOBJ:  /* Store operator only */
            /*
             * We don't want to resolve IndexOp reference objects during
             * a store because this would be an implicit DeRefOf operation.
             * Instead, we just want to store the reference object.
             * -- All others must be resolved below.
             */
            if ((Opcode == AML_STORE_OP) &&
                ((*StackPtr)->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) &&
                ((*StackPtr)->Reference.Class == ACPI_REFCLASS_INDEX))
            {
                goto NextOperand;
            }
            break;
 
        default:
 
            /* All cases covered above */
 
            break;
        }
 
        /*
         * Resolve this object to a value
         */
        Status = AcpiExResolveToValue (StackPtr, WalkState);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        /* Get the resolved object */
 
        ObjDesc = *StackPtr;
 
        /*
         * Check the resulting object (value) type
         */
        switch (ThisArgType)
        {
        /*
         * For the simple cases, only one type of resolved object
         * is allowed
         */
        case ARGI_MUTEX:
 
            /* Need an operand of type ACPI_TYPE_MUTEX */
 
            TypeNeeded = ACPI_TYPE_MUTEX;
            break;
 
        case ARGI_EVENT:
 
            /* Need an operand of type ACPI_TYPE_EVENT */
 
            TypeNeeded = ACPI_TYPE_EVENT;
            break;
 
        case ARGI_PACKAGE:   /* Package */
 
            /* Need an operand of type ACPI_TYPE_PACKAGE */
 
            TypeNeeded = ACPI_TYPE_PACKAGE;
            break;
 
        case ARGI_ANYTYPE:
 
            /* Any operand type will do */
 
            TypeNeeded = ACPI_TYPE_ANY;
            break;
 
        case ARGI_DDBHANDLE:
 
            /* Need an operand of type ACPI_TYPE_DDB_HANDLE */
 
            TypeNeeded = ACPI_TYPE_LOCAL_REFERENCE;
            break;
 
 
        /*
         * The more complex cases allow multiple resolved object types
         */
        case ARGI_INTEGER:
 
            /*
             * Need an operand of type ACPI_TYPE_INTEGER, but we can
             * implicitly convert from a STRING or BUFFER.
             *
             * Known as "Implicit Source Operand Conversion"
             */
            Status = AcpiExConvertToInteger (ObjDesc, StackPtr,
                ACPI_IMPLICIT_CONVERSION);
            if (ACPI_FAILURE (Status))
            {
                if (Status == AE_TYPE)
                {
                    ACPI_ERROR ((AE_INFO,
                        "Needed [Integer/String/Buffer], found [%s] %p",
                        AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 
                    return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
                }
 
                return_ACPI_STATUS (Status);
            }
 
            if (ObjDesc != *StackPtr)
            {
                AcpiUtRemoveReference (ObjDesc);
            }
            goto NextOperand;
 
        case ARGI_BUFFER:
            /*
             * Need an operand of type ACPI_TYPE_BUFFER,
             * But we can implicitly convert from a STRING or INTEGER
             * Aka - "Implicit Source Operand Conversion"
             */
            Status = AcpiExConvertToBuffer (ObjDesc, StackPtr);
            if (ACPI_FAILURE (Status))
            {
                if (Status == AE_TYPE)
                {
                    ACPI_ERROR ((AE_INFO,
                        "Needed [Integer/String/Buffer], found [%s] %p",
                        AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 
                    return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
                }
 
                return_ACPI_STATUS (Status);
            }
 
            if (ObjDesc != *StackPtr)
            {
                AcpiUtRemoveReference (ObjDesc);
            }
            goto NextOperand;
 
        case ARGI_STRING:
            /*
             * Need an operand of type ACPI_TYPE_STRING,
             * But we can implicitly convert from a BUFFER or INTEGER
             * Aka - "Implicit Source Operand Conversion"
             */
            Status = AcpiExConvertToString (
                ObjDesc, StackPtr, ACPI_IMPLICIT_CONVERT_HEX);
            if (ACPI_FAILURE (Status))
            {
                if (Status == AE_TYPE)
                {
                    ACPI_ERROR ((AE_INFO,
                        "Needed [Integer/String/Buffer], found [%s] %p",
                        AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 
                    return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
                }
 
                return_ACPI_STATUS (Status);
            }
 
            if (ObjDesc != *StackPtr)
            {
                AcpiUtRemoveReference (ObjDesc);
            }
            goto NextOperand;
 
        case ARGI_COMPUTEDATA:
 
            /* Need an operand of type INTEGER, STRING or BUFFER */
 
            switch (ObjDesc->Common.Type)
            {
            case ACPI_TYPE_INTEGER:
            case ACPI_TYPE_STRING:
            case ACPI_TYPE_BUFFER:
 
                /* Valid operand */
               break;
 
            default:
                ACPI_ERROR ((AE_INFO,
                    "Needed [Integer/String/Buffer], found [%s] %p",
                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 
                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
            }
            goto NextOperand;
 
        case ARGI_BUFFER_OR_STRING:
 
            /* Need an operand of type STRING or BUFFER */
 
            switch (ObjDesc->Common.Type)
            {
            case ACPI_TYPE_STRING:
            case ACPI_TYPE_BUFFER:
 
                /* Valid operand */
               break;
 
            case ACPI_TYPE_INTEGER:
 
                /* Highest priority conversion is to type Buffer */
 
                Status = AcpiExConvertToBuffer (ObjDesc, StackPtr);
                if (ACPI_FAILURE (Status))
                {
                    return_ACPI_STATUS (Status);
                }
 
                if (ObjDesc != *StackPtr)
                {
                    AcpiUtRemoveReference (ObjDesc);
                }
                break;
 
            default:
                ACPI_ERROR ((AE_INFO,
                    "Needed [Integer/String/Buffer], found [%s] %p",
                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 
                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
            }
            goto NextOperand;
 
        case ARGI_DATAOBJECT:
            /*
             * ARGI_DATAOBJECT is only used by the SizeOf operator.
             * Need a buffer, string, package, or RefOf reference.
             *
             * The only reference allowed here is a direct reference to
             * a namespace node.
             */
            switch (ObjDesc->Common.Type)
            {
            case ACPI_TYPE_PACKAGE:
            case ACPI_TYPE_STRING:
            case ACPI_TYPE_BUFFER:
            case ACPI_TYPE_LOCAL_REFERENCE:
 
                /* Valid operand */
                break;
 
            default:
 
                ACPI_ERROR ((AE_INFO,
                    "Needed [Buffer/String/Package/Reference], found [%s] %p",
                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 
                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
            }
            goto NextOperand;
 
        case ARGI_COMPLEXOBJ:
 
            /* Need a buffer or package or (ACPI 2.0) String */
 
            switch (ObjDesc->Common.Type)
            {
            case ACPI_TYPE_PACKAGE:
            case ACPI_TYPE_STRING:
            case ACPI_TYPE_BUFFER:
 
                /* Valid operand */
                break;
 
            default:
 
                ACPI_ERROR ((AE_INFO,
                    "Needed [Buffer/String/Package], found [%s] %p",
                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 
                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
            }
            goto NextOperand;
 
        case ARGI_REGION_OR_BUFFER: /* Used by Load() only */
 
            /*
             * Need an operand of type REGION or a BUFFER
             * (which could be a resolved region field)
             */
            switch (ObjDesc->Common.Type)
            {
            case ACPI_TYPE_BUFFER:
            case ACPI_TYPE_REGION:
 
                /* Valid operand */
                break;
 
            default:
 
                ACPI_ERROR ((AE_INFO,
                    "Needed [Region/Buffer], found [%s] %p",
                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 
                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
            }
            goto NextOperand;
 
        case ARGI_DATAREFOBJ:
 
            /* Used by the Store() operator only */
 
            switch (ObjDesc->Common.Type)
            {
            case ACPI_TYPE_INTEGER:
            case ACPI_TYPE_PACKAGE:
            case ACPI_TYPE_STRING:
            case ACPI_TYPE_BUFFER:
            case ACPI_TYPE_BUFFER_FIELD:
            case ACPI_TYPE_LOCAL_REFERENCE:
            case ACPI_TYPE_LOCAL_REGION_FIELD:
            case ACPI_TYPE_LOCAL_BANK_FIELD:
            case ACPI_TYPE_LOCAL_INDEX_FIELD:
            case ACPI_TYPE_DDB_HANDLE:
 
                /* Valid operand */
                break;
 
            default:
 
                if (AcpiGbl_EnableInterpreterSlack)
                {
                    /*
                     * Enable original behavior of Store(), allowing any
                     * and all objects as the source operand. The ACPI
                     * spec does not allow this, however.
                     */
                    break;
                }
 
                if (TargetOp == AML_DEBUG_OP)
                {
                    /* Allow store of any object to the Debug object */
 
                    break;
                }
 
                ACPI_ERROR ((AE_INFO,
                    "Needed Integer/Buffer/String/Package/Ref/Ddb]"
                    ", found [%s] %p",
                    AcpiUtGetObjectTypeName (ObjDesc), ObjDesc));
 
                return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
            }
            goto NextOperand;
 
        default:
 
            /* Unknown type */
 
            ACPI_ERROR ((AE_INFO,
                "Internal - Unknown ARGI (required operand) type 0x%X",
                ThisArgType));
 
            return_ACPI_STATUS (AE_BAD_PARAMETER);
        }
 
        /*
         * Make sure that the original object was resolved to the
         * required object type (Simple cases only).
         */
        Status = AcpiExCheckObjectType (
            TypeNeeded, (*StackPtr)->Common.Type, *StackPtr);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
NextOperand:
        /*
         * If more operands needed, decrement StackPtr to point
         * to next operand on stack
         */
        if (GET_CURRENT_ARG_TYPE (ArgTypes))
        {
            StackPtr--;
        }
    }
 
    ACPI_DUMP_OPERANDS (WalkState->Operands,
        AcpiPsGetOpcodeName (Opcode), WalkState->NumOperands);
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsEvalBufferFieldOperands(), AcpiDsEvalDataObjectOperands(), AcpiDsEvalRegionOperands(), AcpiDsEvalTableRegionOperands(), AcpiDsExecEndOp(), and AcpiExOpcode_1A_0T_1R().

AcpiExResolveToValue()

ACPI_STATUS AcpiExResolveToValue	(	ACPI_OPERAND_OBJECT **	StackPtr,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 79 of file exresolv.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExResolveToValue, StackPtr);
 
 
    if (!StackPtr || !*StackPtr)
    {
        ACPI_ERROR ((AE_INFO, "Internal - null pointer"));
        return_ACPI_STATUS (AE_AML_NO_OPERAND);
    }
 
    /*
     * The entity pointed to by the StackPtr can be either
     * 1) A valid ACPI_OPERAND_OBJECT, or
     * 2) A ACPI_NAMESPACE_NODE (NamedObj)
     */
    if (ACPI_GET_DESCRIPTOR_TYPE (*StackPtr) == ACPI_DESC_TYPE_OPERAND)
    {
        Status = AcpiExResolveObjectToValue (StackPtr, WalkState);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        if (!*StackPtr)
        {
            ACPI_ERROR ((AE_INFO, "Internal - null pointer"));
            return_ACPI_STATUS (AE_AML_NO_OPERAND);
        }
    }
 
    /*
     * Object on the stack may have changed if AcpiExResolveObjectToValue()
     * was called (i.e., we can't use an _else_ here.)
     */
    if (ACPI_GET_DESCRIPTOR_TYPE (*StackPtr) == ACPI_DESC_TYPE_NAMED)
    {
        Status = AcpiExResolveNodeToValue (
            ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE, StackPtr),
            WalkState);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Resolved object %p\n", *StackPtr));
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiDsEvalBankFieldOperands(), AcpiDsEvaluateNamePath(), AcpiDsExecEndControlOp(), AcpiDsGetPredicateValue(), AcpiDsResolveOperands(), AcpiExResolveObject(), and AcpiExResolveOperands().

AcpiExSetBufferDatum()

void AcpiExSetBufferDatum	(	UINT64	MergedDatum,
		void *	Buffer,
		UINT32	BufferLength,
		UINT32	ByteGranularity,
		UINT32	BufferOffset
	)

AcpiExSmBusSpaceHandler()

ACPI_STATUS AcpiExSmBusSpaceHandler	(	UINT32	Function,
		ACPI_PHYSICAL_ADDRESS	Address,
		UINT32	BitWidth,
		UINT64 *	Value,
		void *	HandlerContext,
		void *	RegionContext
	)

AcpiExStartTraceMethod()

void AcpiExStartTraceMethod	(	ACPI_NAMESPACE_NODE *	MethodNode,
		ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 224 of file extrace.c.

{
    char                    *Pathname = NULL;
    BOOLEAN                 Enabled = FALSE;
 
 
    ACPI_FUNCTION_NAME (ExStartTraceMethod);
 
 
    if (MethodNode)
    {
        Pathname = AcpiNsGetNormalizedPathname (MethodNode, TRUE);
    }
 
    Enabled = AcpiExInterpreterTraceEnabled (Pathname);
    if (Enabled && !AcpiGbl_TraceMethodObject)
    {
        AcpiGbl_TraceMethodObject = ObjDesc;
        AcpiGbl_OriginalDbgLevel = AcpiDbgLevel;
        AcpiGbl_OriginalDbgLayer = AcpiDbgLayer;
        AcpiDbgLevel = ACPI_TRACE_LEVEL_ALL;
        AcpiDbgLayer = ACPI_TRACE_LAYER_ALL;
 
        if (AcpiGbl_TraceDbgLevel)
        {
            AcpiDbgLevel = AcpiGbl_TraceDbgLevel;
        }
 
        if (AcpiGbl_TraceDbgLayer)
        {
            AcpiDbgLayer = AcpiGbl_TraceDbgLayer;
        }
    }
 
    if (Enabled)
    {
        ACPI_TRACE_POINT (ACPI_TRACE_AML_METHOD, TRUE,
            ObjDesc ? ObjDesc->Method.AmlStart : NULL, Pathname);
    }
 
    if (Pathname)
    {
        ACPI_FREE (Pathname);
    }
}

Referenced by AcpiDsBeginMethodExecution().

AcpiExStartTraceOpcode()

void AcpiExStartTraceOpcode	(	ACPI_PARSE_OBJECT *	Op,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 353 of file extrace.c.

{
 
    ACPI_FUNCTION_NAME (ExStartTraceOpcode);
 
 
    if (AcpiExInterpreterTraceEnabled (NULL) &&
        (AcpiGbl_TraceFlags & ACPI_TRACE_OPCODE))
    {
        ACPI_TRACE_POINT (ACPI_TRACE_AML_OPCODE, TRUE,
            Op->Common.Aml, Op->Common.AmlOpName);
    }
}

Referenced by AcpiPsParseLoop().

AcpiExStopTraceMethod()

void AcpiExStopTraceMethod	(	ACPI_NAMESPACE_NODE *	MethodNode,
		ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 290 of file extrace.c.

{
    char                    *Pathname = NULL;
    BOOLEAN                 Enabled;
 
 
    ACPI_FUNCTION_NAME (ExStopTraceMethod);
 
 
    if (MethodNode)
    {
        Pathname = AcpiNsGetNormalizedPathname (MethodNode, TRUE);
    }
 
    Enabled = AcpiExInterpreterTraceEnabled (NULL);
 
    if (Enabled)
    {
        ACPI_TRACE_POINT (ACPI_TRACE_AML_METHOD, FALSE,
            ObjDesc ? ObjDesc->Method.AmlStart : NULL, Pathname);
    }
 
    /* Check whether the tracer should be stopped */
 
    if (AcpiGbl_TraceMethodObject == ObjDesc)
    {
        /* Disable further tracing if type is one-shot */
 
        if (AcpiGbl_TraceFlags & ACPI_TRACE_ONESHOT)
        {
            AcpiGbl_TraceMethodName = NULL;
        }
 
        AcpiDbgLevel = AcpiGbl_OriginalDbgLevel;
        AcpiDbgLayer = AcpiGbl_OriginalDbgLayer;
        AcpiGbl_TraceMethodObject = NULL;
    }
 
    if (Pathname)
    {
        ACPI_FREE (Pathname);
    }
}

Referenced by AcpiDsTerminateControlMethod().

AcpiExStopTraceOpcode()

void AcpiExStopTraceOpcode	(	ACPI_PARSE_OBJECT *	Op,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 385 of file extrace.c.

{
 
    ACPI_FUNCTION_NAME (ExStopTraceOpcode);
 
 
    if (AcpiExInterpreterTraceEnabled (NULL) &&
        (AcpiGbl_TraceFlags & ACPI_TRACE_OPCODE))
    {
        ACPI_TRACE_POINT (ACPI_TRACE_AML_OPCODE, FALSE,
            Op->Common.Aml, Op->Common.AmlOpName);
    }
}

Referenced by AcpiPsCompleteThisOp().

AcpiExStore()

ACPI_STATUS AcpiExStore	(	ACPI_OPERAND_OBJECT *	ValDesc,
		ACPI_OPERAND_OBJECT *	DestDesc,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 91 of file exstore.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_OPERAND_OBJECT     *RefDesc = DestDesc;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExStore, DestDesc);
 
 
    /* Validate parameters */
 
    if (!SourceDesc || !DestDesc)
    {
        ACPI_ERROR ((AE_INFO, "Null parameter"));
        return_ACPI_STATUS (AE_AML_NO_OPERAND);
    }
 
    /* DestDesc can be either a namespace node or an ACPI object */
 
    if (ACPI_GET_DESCRIPTOR_TYPE (DestDesc) == ACPI_DESC_TYPE_NAMED)
    {
        /*
         * Dest is a namespace node,
         * Storing an object into a Named node.
         */
        Status = AcpiExStoreObjectToNode (SourceDesc,
            (ACPI_NAMESPACE_NODE *) DestDesc, WalkState,
            ACPI_IMPLICIT_CONVERSION);
 
        return_ACPI_STATUS (Status);
    }
 
    /* Destination object must be a Reference or a Constant object */
 
    switch (DestDesc->Common.Type)
    {
    case ACPI_TYPE_LOCAL_REFERENCE:
 
        break;
 
    case ACPI_TYPE_INTEGER:
 
        /* Allow stores to Constants -- a Noop as per ACPI spec */
 
        if (DestDesc->Common.Flags & AOPOBJ_AML_CONSTANT)
        {
            return_ACPI_STATUS (AE_OK);
        }
 
        ACPI_FALLTHROUGH;
 
    default:
 
        /* Destination is not a Reference object */
 
        ACPI_ERROR ((AE_INFO,
            "Target is not a Reference or Constant object - [%s] %p",
            AcpiUtGetObjectTypeName (DestDesc), DestDesc));
 
        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
    }
 
    /*
     * Examine the Reference class. These cases are handled:
     *
     * 1) Store to Name (Change the object associated with a name)
     * 2) Store to an indexed area of a Buffer or Package
     * 3) Store to a Method Local or Arg
     * 4) Store to the debug object
     */
    switch (RefDesc->Reference.Class)
    {
    case ACPI_REFCLASS_REFOF:
 
        /* Storing an object into a Name "container" */
 
        Status = AcpiExStoreObjectToNode (SourceDesc,
            RefDesc->Reference.Object,
            WalkState, ACPI_IMPLICIT_CONVERSION);
        break;
 
    case ACPI_REFCLASS_INDEX:
 
        /* Storing to an Index (pointer into a packager or buffer) */
 
        Status = AcpiExStoreObjectToIndex (SourceDesc, RefDesc, WalkState);
        break;
 
    case ACPI_REFCLASS_LOCAL:
    case ACPI_REFCLASS_ARG:
 
        /* Store to a method local/arg  */
 
        Status = AcpiDsStoreObjectToLocal (RefDesc->Reference.Class,
            RefDesc->Reference.Value, SourceDesc, WalkState);
        break;
 
    case ACPI_REFCLASS_DEBUG:
        /*
         * Storing to the Debug object causes the value stored to be
         * displayed and otherwise has no effect -- see ACPI Specification
         */
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "**** Write to Debug Object: Object %p [%s] ****:\n\n",
            SourceDesc, AcpiUtGetObjectTypeName (SourceDesc)));
 
        ACPI_DEBUG_OBJECT (SourceDesc, 0, 0);
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Unknown Reference Class 0x%2.2X",
            RefDesc->Reference.Class));
        ACPI_DUMP_ENTRY (RefDesc, ACPI_LV_INFO);
 
        Status = AE_AML_INTERNAL;
        break;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExLoadTableOp(), AcpiExOpcode_1A_0T_1R(), AcpiExOpcode_1A_1T_1R(), AcpiExOpcode_2A_1T_1R(), AcpiExOpcode_2A_2T_1R(), and AcpiExOpcode_3A_1T_1R().

AcpiExStoreBufferToBuffer()

ACPI_STATUS AcpiExStoreBufferToBuffer	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_OPERAND_OBJECT *	TargetDesc
	)

Definition at line 67 of file exstorob.c.

{
    UINT32                  Length;
    UINT8                   *Buffer;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExStoreBufferToBuffer, SourceDesc);
 
 
    /* If Source and Target are the same, just return */
 
    if (SourceDesc == TargetDesc)
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    /* We know that SourceDesc is a buffer by now */
 
    Buffer = ACPI_CAST_PTR (UINT8, SourceDesc->Buffer.Pointer);
    Length = SourceDesc->Buffer.Length;
 
    /*
     * If target is a buffer of length zero or is a static buffer,
     * allocate a new buffer of the proper length
     */
    if ((TargetDesc->Buffer.Length == 0) ||
        (TargetDesc->Common.Flags & AOPOBJ_STATIC_POINTER))
    {
        TargetDesc->Buffer.Pointer = ACPI_ALLOCATE (Length);
        if (!TargetDesc->Buffer.Pointer)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        TargetDesc->Buffer.Length = Length;
    }
 
    /* Copy source buffer to target buffer */
 
    if (Length <= TargetDesc->Buffer.Length)
    {
        /* Clear existing buffer and copy in the new one */
 
        memset (TargetDesc->Buffer.Pointer, 0, TargetDesc->Buffer.Length);
        memcpy (TargetDesc->Buffer.Pointer, Buffer, Length);
 
#ifdef ACPI_OBSOLETE_BEHAVIOR
        /*
         * NOTE: ACPI versions up to 3.0 specified that the buffer must be
         * truncated if the string is smaller than the buffer. However, "other"
         * implementations of ACPI never did this and thus became the defacto
         * standard. ACPI 3.0A changes this behavior such that the buffer
         * is no longer truncated.
         */
 
        /*
         * OBSOLETE BEHAVIOR:
         * If the original source was a string, we must truncate the buffer,
         * according to the ACPI spec. Integer-to-Buffer and Buffer-to-Buffer
         * copy must not truncate the original buffer.
         */
        if (OriginalSrcType == ACPI_TYPE_STRING)
        {
            /* Set the new length of the target */
 
            TargetDesc->Buffer.Length = Length;
        }
#endif
    }
    else
    {
        /* Truncate the source, copy only what will fit */
 
        memcpy (TargetDesc->Buffer.Pointer, Buffer,
            TargetDesc->Buffer.Length);
 
        ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
            "Truncating source buffer from %X to %X\n",
            Length, TargetDesc->Buffer.Length));
    }
 
    /* Copy flags */
 
    TargetDesc->Buffer.Flags = SourceDesc->Buffer.Flags;
    TargetDesc->Common.Flags &= ~AOPOBJ_STATIC_POINTER;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExStoreObjectToObject().

AcpiExStoreObjectToNode()

ACPI_STATUS AcpiExStoreObjectToNode	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_NAMESPACE_NODE *	Node,
		ACPI_WALK_STATE *	WalkState,
		UINT8	ImplicitConversion
	)

Definition at line 412 of file exstore.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_OPERAND_OBJECT     *TargetDesc;
    ACPI_OPERAND_OBJECT     *NewDesc;
    ACPI_OBJECT_TYPE        TargetType;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExStoreObjectToNode, SourceDesc);
 
 
    /* Get current type of the node, and object attached to Node */
 
    TargetType = AcpiNsGetType (Node);
    TargetDesc = AcpiNsGetAttachedObject (Node);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Storing %p [%s] to node %p [%s]\n",
        SourceDesc, AcpiUtGetObjectTypeName (SourceDesc),
        Node, AcpiUtGetTypeName (TargetType)));
 
    /* Only limited target types possible for everything except CopyObject */
 
    if (WalkState->Opcode != AML_COPY_OBJECT_OP)
    {
        /*
         * Only CopyObject allows all object types to be overwritten. For
         * TargetRef(s), there are restrictions on the object types that
         * are allowed.
         *
         * Allowable operations/typing for Store:
         *
         * 1) Simple Store
         *      Integer     --> Integer (Named/Local/Arg)
         *      String      --> String  (Named/Local/Arg)
         *      Buffer      --> Buffer  (Named/Local/Arg)
         *      Package     --> Package (Named/Local/Arg)
         *
         * 2) Store with implicit conversion
         *      Integer     --> String or Buffer  (Named)
         *      String      --> Integer or Buffer (Named)
         *      Buffer      --> Integer or String (Named)
         */
        switch (TargetType)
        {
        case ACPI_TYPE_PACKAGE:
            /*
             * Here, can only store a package to an existing package.
             * Storing a package to a Local/Arg is OK, and handled
             * elsewhere.
             */
            if (WalkState->Opcode == AML_STORE_OP)
            {
                if (SourceDesc->Common.Type != ACPI_TYPE_PACKAGE)
                {
                    ACPI_ERROR ((AE_INFO,
                        "Cannot assign type [%s] to [Package] "
                        "(source must be type Pkg)",
                        AcpiUtGetObjectTypeName (SourceDesc)));
 
                    return_ACPI_STATUS (AE_AML_TARGET_TYPE);
                }
                break;
            }
 
            ACPI_FALLTHROUGH;
 
        case ACPI_TYPE_DEVICE:
        case ACPI_TYPE_EVENT:
        case ACPI_TYPE_MUTEX:
        case ACPI_TYPE_REGION:
        case ACPI_TYPE_POWER:
        case ACPI_TYPE_PROCESSOR:
        case ACPI_TYPE_THERMAL:
 
            ACPI_ERROR ((AE_INFO,
                "Target must be [Buffer/Integer/String/Reference]"
                ", found [%s] (%4.4s)",
                AcpiUtGetTypeName (Node->Type), Node->Name.Ascii));
 
            return_ACPI_STATUS (AE_AML_TARGET_TYPE);
 
        default:
            break;
        }
    }
 
    /*
     * Resolve the source object to an actual value
     * (If it is a reference object)
     */
    Status = AcpiExResolveObject (&SourceDesc, TargetType, WalkState);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Do the actual store operation */
 
    switch (TargetType)
    {
        /*
         * The simple data types all support implicit source operand
         * conversion before the store.
         */
    case ACPI_TYPE_INTEGER:
    case ACPI_TYPE_STRING:
    case ACPI_TYPE_BUFFER:
 
        if ((WalkState->Opcode == AML_COPY_OBJECT_OP) ||
            !ImplicitConversion)
        {
            /*
             * However, CopyObject and Stores to ArgX do not perform
             * an implicit conversion, as per the ACPI specification.
             * A direct store is performed instead.
             */
            Status = AcpiExStoreDirectToNode (SourceDesc, Node, WalkState);
            break;
        }
 
        /* Store with implicit source operand conversion support */
 
        Status = AcpiExStoreObjectToObject (SourceDesc, TargetDesc,
            &NewDesc, WalkState);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        if (NewDesc != TargetDesc)
        {
            /*
             * Store the new NewDesc as the new value of the Name, and set
             * the Name's type to that of the value being stored in it.
             * SourceDesc reference count is incremented by AttachObject.
             *
             * Note: This may change the type of the node if an explicit
             * store has been performed such that the node/object type
             * has been changed.
             */
            Status = AcpiNsAttachObject (
                Node, NewDesc, NewDesc->Common.Type);
 
            ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
                "Store type [%s] into [%s] via Convert/Attach\n",
                AcpiUtGetObjectTypeName (SourceDesc),
                AcpiUtGetObjectTypeName (NewDesc)));
        }
        break;
 
    case ACPI_TYPE_BUFFER_FIELD:
    case ACPI_TYPE_LOCAL_REGION_FIELD:
    case ACPI_TYPE_LOCAL_BANK_FIELD:
    case ACPI_TYPE_LOCAL_INDEX_FIELD:
        /*
         * For all fields, always write the source data to the target
         * field. Any required implicit source operand conversion is
         * performed in the function below as necessary. Note, field
         * objects must retain their original type permanently.
         */
        Status = AcpiExWriteDataToField (SourceDesc, TargetDesc,
            &WalkState->ResultObj);
        break;
 
    default:
        /*
         * CopyObject operator: No conversions for all other types.
         * Instead, directly store a copy of the source object.
         *
         * This is the ACPI spec-defined behavior for the CopyObject
         * operator. (Note, for this default case, all normal
         * Store/Target operations exited above with an error).
         */
        Status = AcpiExStoreDirectToNode (SourceDesc, Node, WalkState);
        break;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsStoreObjectToLocal(), and AcpiExStore().

AcpiExStoreObjectToObject()

ACPI_STATUS AcpiExStoreObjectToObject	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_OPERAND_OBJECT *	DestDesc,
		ACPI_OPERAND_OBJECT **	NewDesc,
		ACPI_WALK_STATE *	WalkState
	)

Definition at line 199 of file exstoren.c.

{
    ACPI_OPERAND_OBJECT     *ActualSrcDesc;
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExStoreObjectToObject, SourceDesc);
 
 
    ActualSrcDesc = SourceDesc;
    if (!DestDesc)
    {
        /*
         * There is no destination object (An uninitialized node or
         * package element), so we can simply copy the source object
         * creating a new destination object
         */
        Status = AcpiUtCopyIobjectToIobject (ActualSrcDesc, NewDesc, WalkState);
        return_ACPI_STATUS (Status);
    }
 
    if (SourceDesc->Common.Type != DestDesc->Common.Type)
    {
        /*
         * The source type does not match the type of the destination.
         * Perform the "implicit conversion" of the source to the current type
         * of the target as per the ACPI specification.
         *
         * If no conversion performed, ActualSrcDesc = SourceDesc.
         * Otherwise, ActualSrcDesc is a temporary object to hold the
         * converted object.
         */
        Status = AcpiExConvertToTargetType (DestDesc->Common.Type,
            SourceDesc, &ActualSrcDesc, WalkState);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        if (SourceDesc == ActualSrcDesc)
        {
            /*
             * No conversion was performed. Return the SourceDesc as the
             * new object.
             */
            *NewDesc = SourceDesc;
            return_ACPI_STATUS (AE_OK);
        }
    }
 
    /*
     * We now have two objects of identical types, and we can perform a
     * copy of the *value* of the source object.
     */
    switch (DestDesc->Common.Type)
    {
    case ACPI_TYPE_INTEGER:
 
        DestDesc->Integer.Value = ActualSrcDesc->Integer.Value;
 
        /* Truncate value if we are executing from a 32-bit ACPI table */
 
        (void) AcpiExTruncateFor32bitTable (DestDesc);
        break;
 
    case ACPI_TYPE_STRING:
 
        Status = AcpiExStoreStringToString (ActualSrcDesc, DestDesc);
        break;
 
    case ACPI_TYPE_BUFFER:
 
        Status = AcpiExStoreBufferToBuffer (ActualSrcDesc, DestDesc);
        break;
 
    case ACPI_TYPE_PACKAGE:
 
        Status = AcpiUtCopyIobjectToIobject (ActualSrcDesc, &DestDesc,
                    WalkState);
        break;
 
    default:
        /*
         * All other types come here.
         */
        ACPI_WARNING ((AE_INFO, "Store into type [%s] not implemented",
            AcpiUtGetObjectTypeName (DestDesc)));
 
        Status = AE_NOT_IMPLEMENTED;
        break;
    }
 
    if (ActualSrcDesc != SourceDesc)
    {
        /* Delete the intermediate (temporary) source object */
 
        AcpiUtRemoveReference (ActualSrcDesc);
    }
 
    *NewDesc = DestDesc;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExStoreObjectToNode().

AcpiExStoreStringToString()

ACPI_STATUS AcpiExStoreStringToString	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_OPERAND_OBJECT *	TargetDesc
	)

Definition at line 172 of file exstorob.c.

{
    UINT32                  Length;
    UINT8                   *Buffer;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExStoreStringToString, SourceDesc);
 
 
    /* If Source and Target are the same, just return */
 
    if (SourceDesc == TargetDesc)
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    /* We know that SourceDesc is a string by now */
 
    Buffer = ACPI_CAST_PTR (UINT8, SourceDesc->String.Pointer);
    Length = SourceDesc->String.Length;
 
    /*
     * Replace existing string value if it will fit and the string
     * pointer is not a static pointer (part of an ACPI table)
     */
    if ((Length < TargetDesc->String.Length) &&
       (!(TargetDesc->Common.Flags & AOPOBJ_STATIC_POINTER)))
    {
        /*
         * String will fit in existing non-static buffer.
         * Clear old string and copy in the new one
         */
        memset (TargetDesc->String.Pointer, 0,
            (ACPI_SIZE) TargetDesc->String.Length + 1);
        memcpy (TargetDesc->String.Pointer, Buffer, Length);
    }
    else
    {
        /*
         * Free the current buffer, then allocate a new buffer
         * large enough to hold the value
         */
        if (TargetDesc->String.Pointer &&
           (!(TargetDesc->Common.Flags & AOPOBJ_STATIC_POINTER)))
        {
            /* Only free if not a pointer into the DSDT */
 
            ACPI_FREE (TargetDesc->String.Pointer);
        }
 
        TargetDesc->String.Pointer =
            ACPI_ALLOCATE_ZEROED ((ACPI_SIZE) Length + 1);
 
        if (!TargetDesc->String.Pointer)
        {
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        TargetDesc->Common.Flags &= ~AOPOBJ_STATIC_POINTER;
        memcpy (TargetDesc->String.Pointer, Buffer, Length);
    }
 
    /* Set the new target length */
 
    TargetDesc->String.Length = Length;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExStoreObjectToObject().

AcpiExSystemDoNotifyOp()

ACPI_STATUS AcpiExSystemDoNotifyOp	(	ACPI_OPERAND_OBJECT *	Value,
		ACPI_OPERAND_OBJECT *	ObjDesc
	)

AcpiExSystemDoSleep()

ACPI_STATUS AcpiExSystemDoSleep

(

UINT64

Time

)

Definition at line 223 of file exsystem.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Since this thread will sleep, we must release the interpreter */
 
    AcpiExExitInterpreter ();
 
    /*
     * For compatibility with other ACPI implementations and to prevent
     * accidental deep sleeps, limit the sleep time to something reasonable.
     */
    if (HowLongMs > ACPI_MAX_SLEEP)
    {
        HowLongMs = ACPI_MAX_SLEEP;
    }
 
    AcpiOsSleep (HowLongMs);
 
    /* And now we must get the interpreter again */
 
    AcpiExEnterInterpreter ();
    return (AE_OK);
}

Referenced by AcpiExOpcode_1A_0T_0R().

AcpiExSystemDoStall()

ACPI_STATUS AcpiExSystemDoStall

(

UINT32

Time

)

Definition at line 174 of file exsystem.c.

{
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    if (HowLongUs > 255)
    {
        /*
         * Longer than 255 microseconds, this is an error
         *
         * (ACPI specifies 100 usec as max, but this gives some slack in
         * order to support existing BIOSs)
         */
        ACPI_ERROR ((AE_INFO,
            "Time parameter is too large (%u)", HowLongUs));
        Status = AE_AML_OPERAND_VALUE;
    }
    else
    {
        if (HowLongUs > 100)
    {
            ACPI_WARNING ((AE_INFO,
                "Time parameter %u us > 100 us violating ACPI spec, please fix the firmware.", HowLongUs));
    }
        AcpiOsStall (HowLongUs);
    }
 
    return (Status);
}

Referenced by AcpiExOpcode_1A_0T_0R().

AcpiExSystemIoSpaceHandler()

ACPI_STATUS AcpiExSystemIoSpaceHandler	(	UINT32	Function,
		ACPI_PHYSICAL_ADDRESS	Address,
		UINT32	BitWidth,
		UINT64 *	Value,
		void *	HandlerContext,
		void *	RegionContext
	)

Definition at line 359 of file exregion.c.

{
    ACPI_STATUS             Status = AE_OK;
    UINT32                  Value32;
 
 
    ACPI_FUNCTION_TRACE (ExSystemIoSpaceHandler);
 
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
        "System-IO (width %u) R/W %u Address=%8.8X%8.8X\n",
        BitWidth, Function, ACPI_FORMAT_UINT64 (Address)));
 
    /* Decode the function parameter */
 
    switch (Function)
    {
    case ACPI_READ:
 
        Status = AcpiHwReadPort ((ACPI_IO_ADDRESS) Address,
                    &Value32, BitWidth);
        *Value = Value32;
        break;
 
    case ACPI_WRITE:
 
        Status = AcpiHwWritePort ((ACPI_IO_ADDRESS) Address,
                    (UINT32) *Value, BitWidth);
        break;
 
    default:
 
        Status = AE_BAD_PARAMETER;
        break;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvInstallSpaceHandler().

AcpiExSystemMemorySpaceHandler()

ACPI_STATUS AcpiExSystemMemorySpaceHandler	(	UINT32	Function,
		ACPI_PHYSICAL_ADDRESS	Address,
		UINT32	BitWidth,
		UINT64 *	Value,
		void *	HandlerContext,
		void *	RegionContext
	)

Definition at line 72 of file exregion.c.

{
    ACPI_STATUS             Status = AE_OK;
    void                    *LogicalAddrPtr = NULL;
    ACPI_MEM_SPACE_CONTEXT  *MemInfo = RegionContext;
    ACPI_MEM_MAPPING        *Mm = MemInfo->CurMm;
    UINT32                  Length;
    ACPI_SIZE               MapLength;
    ACPI_SIZE               PageBoundaryMapLength;
#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
    UINT32                  Remainder;
#endif
 
 
    ACPI_FUNCTION_TRACE (ExSystemMemorySpaceHandler);
 
 
    /* Validate and translate the bit width */
 
    switch (BitWidth)
    {
    case 8:
 
        Length = 1;
        break;
 
    case 16:
 
        Length = 2;
        break;
 
    case 32:
 
        Length = 4;
        break;
 
    case 64:
 
        Length = 8;
        break;
 
    default:
 
        ACPI_ERROR ((AE_INFO, "Invalid SystemMemory width %u",
            BitWidth));
        return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
    }
 
#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
    /*
     * Hardware does not support non-aligned data transfers, we must verify
     * the request.
     */
    (void) AcpiUtShortDivide ((UINT64) Address, Length, NULL, &Remainder);
    if (Remainder != 0)
    {
        return_ACPI_STATUS (AE_AML_ALIGNMENT);
    }
#endif
 
    /*
     * Does the request fit into the cached memory mapping?
     * Is 1) Address below the current mapping? OR
     *    2) Address beyond the current mapping?
     */
    if (!Mm || (Address < Mm->PhysicalAddress) ||
        ((UINT64) Address + Length > (UINT64) Mm->PhysicalAddress + Mm->Length))
    {
        /*
         * The request cannot be resolved by the current memory mapping.
         *
         * Look for an existing saved mapping covering the address range
         * at hand. If found, save it as the current one and carry out
         * the access.
         */
        for (Mm = MemInfo->FirstMm; Mm; Mm = Mm->NextMm)
        {
            if (Mm == MemInfo->CurMm)
            {
                continue;
            }
 
            if (Address < Mm->PhysicalAddress)
            {
                continue;
            }
 
            if ((UINT64) Address + Length > (UINT64) Mm->PhysicalAddress + Mm->Length)
            {
                continue;
            }
 
            MemInfo->CurMm = Mm;
            goto access;
        }
 
        /* Create a new mappings list entry */
 
        Mm = ACPI_ALLOCATE_ZEROED(sizeof(*Mm));
        if (!Mm)
        {
            ACPI_ERROR((AE_INFO,
                "Unable to save memory mapping at 0x%8.8X%8.8X, size %u",
                ACPI_FORMAT_UINT64(Address), Length));
            return_ACPI_STATUS(AE_NO_MEMORY);
        }
 
        /*
         * October 2009: Attempt to map from the requested address to the
         * end of the region. However, we will never map more than one
         * page, nor will we cross a page boundary.
         */
        MapLength = (ACPI_SIZE)
            ((MemInfo->Address + MemInfo->Length) - Address);
 
        /*
         * If mapping the entire remaining portion of the region will cross
         * a page boundary, just map up to the page boundary, do not cross.
         * On some systems, crossing a page boundary while mapping regions
         * can cause warnings if the pages have different attributes
         * due to resource management.
         *
         * This has the added benefit of constraining a single mapping to
         * one page, which is similar to the original code that used a 4k
         * maximum window.
         */
        PageBoundaryMapLength = (ACPI_SIZE)
            (ACPI_ROUND_UP (Address, ACPI_DEFAULT_PAGE_SIZE) - Address);
        if (PageBoundaryMapLength == 0)
        {
            PageBoundaryMapLength = ACPI_DEFAULT_PAGE_SIZE;
        }
 
        if (MapLength > PageBoundaryMapLength)
        {
            MapLength = PageBoundaryMapLength;
        }
 
        /* Create a new mapping starting at the address given */
 
        LogicalAddrPtr = AcpiOsMapMemory(Address, MapLength);
        if (!LogicalAddrPtr)
        {
            ACPI_ERROR ((AE_INFO,
                "Could not map memory at 0x%8.8X%8.8X, size %u",
                ACPI_FORMAT_UINT64 (Address), (UINT32) MapLength));
            ACPI_FREE(Mm);
            return_ACPI_STATUS (AE_NO_MEMORY);
        }
 
        /* Save the physical address and mapping size */
 
        Mm->LogicalAddress = LogicalAddrPtr;
        Mm->PhysicalAddress = Address;
        Mm->Length = MapLength;
 
        /*
         * Add the new entry to the mappigs list and save it as the
         * current mapping.
         */
        Mm->NextMm = MemInfo->FirstMm;
        MemInfo->FirstMm = Mm;
        MemInfo->CurMm = Mm;
    }
 
access:
    /*
     * Generate a logical pointer corresponding to the address we want to
     * access
     */
    LogicalAddrPtr = Mm->LogicalAddress +
        ((UINT64) Address - (UINT64) Mm->PhysicalAddress);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
        "System-Memory (width %u) R/W %u Address=%8.8X%8.8X\n",
        BitWidth, Function, ACPI_FORMAT_UINT64 (Address)));
 
    /*
     * Perform the memory read or write
     *
     * Note: For machines that do not support non-aligned transfers, the target
     * address was checked for alignment above. We do not attempt to break the
     * transfer up into smaller (byte-size) chunks because the AML specifically
     * asked for a transfer width that the hardware may require.
     */
    switch (Function)
    {
    case ACPI_READ:
 
        *Value = 0;
        switch (BitWidth)
        {
        case 8:
 
            *Value = (UINT64) ACPI_GET8 (LogicalAddrPtr);
            break;
 
        case 16:
 
            *Value = (UINT64) ACPI_GET16 (LogicalAddrPtr);
            break;
 
        case 32:
 
            *Value = (UINT64) ACPI_GET32 (LogicalAddrPtr);
            break;
 
        case 64:
 
            *Value = (UINT64) ACPI_GET64 (LogicalAddrPtr);
            break;
 
        default:
 
            /* BitWidth was already validated */
 
            break;
        }
        break;
 
    case ACPI_WRITE:
 
        switch (BitWidth)
        {
        case 8:
 
            ACPI_SET8 (LogicalAddrPtr, *Value);
            break;
 
        case 16:
 
            ACPI_SET16 (LogicalAddrPtr, *Value);
            break;
 
        case 32:
 
            ACPI_SET32 (LogicalAddrPtr, *Value);
            break;
 
        case 64:
 
            ACPI_SET64 (LogicalAddrPtr, *Value);
            break;
 
        default:
 
            /* BitWidth was already validated */
 
            break;
        }
        break;
 
    default:
 
        Status = AE_BAD_PARAMETER;
        break;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvInstallSpaceHandler().

AcpiExSystemResetEvent()

ACPI_STATUS AcpiExSystemResetEvent

(

ACPI_OPERAND_OBJECT *

ObjDesc

)

Definition at line 332 of file exsystem.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_SEMAPHORE          TempSemaphore;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /*
     * We are going to simply delete the existing semaphore and
     * create a new one!
     */
    Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 0, &TempSemaphore);
    if (ACPI_SUCCESS (Status))
    {
        (void) AcpiOsDeleteSemaphore (ObjDesc->Event.OsSemaphore);
        ObjDesc->Event.OsSemaphore = TempSemaphore;
    }
 
    return (Status);
}

Referenced by AcpiExOpcode_1A_0T_0R().

AcpiExSystemSignalEvent()

ACPI_STATUS AcpiExSystemSignalEvent

(

ACPI_OPERAND_OBJECT *

ObjDesc

)

Definition at line 265 of file exsystem.c.

{
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE (ExSystemSignalEvent);
 
 
    if (ObjDesc)
    {
        Status = AcpiOsSignalSemaphore (ObjDesc->Event.OsSemaphore, 1);
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExOpcode_1A_0T_0R().

AcpiExSystemWaitEvent()

ACPI_STATUS AcpiExSystemWaitEvent	(	ACPI_OPERAND_OBJECT *	Time,
		ACPI_OPERAND_OBJECT *	ObjDesc
	)

Definition at line 299 of file exsystem.c.

{
    ACPI_STATUS             Status = AE_OK;
 
 
    ACPI_FUNCTION_TRACE (ExSystemWaitEvent);
 
 
    if (ObjDesc)
    {
        Status = AcpiExSystemWaitSemaphore (ObjDesc->Event.OsSemaphore,
            (UINT16) TimeDesc->Integer.Value);
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExOpcode_2A_0T_1R().

AcpiExSystemWaitMutex()

ACPI_STATUS AcpiExSystemWaitMutex	(	ACPI_MUTEX	Mutex,
		UINT16	Timeout
	)

Definition at line 120 of file exsystem.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (ExSystemWaitMutex);
 
 
    Status = AcpiOsAcquireMutex (Mutex, ACPI_DO_NOT_WAIT);
    if (ACPI_SUCCESS (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    if (Status == AE_TIME)
    {
        /* We must wait, so unlock the interpreter */
 
        AcpiExExitInterpreter ();
        Status = AcpiOsAcquireMutex (Mutex, Timeout);
 
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "*** Thread awake after blocking, %s\n",
            AcpiFormatException (Status)));
 
        /* Reacquire the interpreter */
 
        AcpiExEnterInterpreter ();
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsBeginMethodExecution(), AcpiEvAcquireGlobalLock(), and AcpiExAcquireMutexObject().

AcpiExSystemWaitSemaphore()

ACPI_STATUS AcpiExSystemWaitSemaphore	(	ACPI_SEMAPHORE	Semaphore,
		UINT16	Timeout
	)

Definition at line 68 of file exsystem.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (ExSystemWaitSemaphore);
 
 
    Status = AcpiOsWaitSemaphore (Semaphore, 1, ACPI_DO_NOT_WAIT);
    if (ACPI_SUCCESS (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    if (Status == AE_TIME)
    {
        /* We must wait, so unlock the interpreter */
 
        AcpiExExitInterpreter ();
        Status = AcpiOsWaitSemaphore (Semaphore, 1, Timeout);
 
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "*** Thread awake after blocking, %s\n",
            AcpiFormatException (Status)));
 
        /* Reacquire the interpreter */
 
        AcpiExEnterInterpreter ();
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvAcquireGlobalLock(), and AcpiExSystemWaitEvent().

AcpiExTracePoint()

void AcpiExTracePoint	(	ACPI_TRACE_EVENT_TYPE	Type,
		BOOLEAN	Begin,
		UINT8 *	Aml,
		char *	Pathname
	)

Definition at line 181 of file extrace.c.

{
 
    ACPI_FUNCTION_NAME (ExTracePoint);
 
 
    if (Pathname)
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_TRACE_POINT,
            "%s %s [0x%p:%s] execution.\n",
            AcpiExGetTraceEventName (Type), Begin ? "Begin" : "End",
            Aml, Pathname));
    }
    else
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_TRACE_POINT,
            "%s %s [0x%p] execution.\n",
            AcpiExGetTraceEventName (Type), Begin ? "Begin" : "End",
            Aml));
    }
}

AcpiExTruncateFor32bitTable()

BOOLEAN AcpiExTruncateFor32bitTable

(

ACPI_OPERAND_OBJECT *

ObjDesc

)

Definition at line 177 of file exutils.c.

{
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /*
     * Object must be a valid number and we must be executing
     * a control method. Object could be NS node for AML_INT_NAMEPATH_OP.
     */
    if ((!ObjDesc) ||
        (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND) ||
        (ObjDesc->Common.Type != ACPI_TYPE_INTEGER))
    {
        return (FALSE);
    }
 
    if ((AcpiGbl_IntegerByteWidth == 4) &&
        (ObjDesc->Integer.Value > (UINT64) ACPI_UINT32_MAX))
    {
        /*
         * We are executing in a 32-bit ACPI table. Truncate
         * the value to 32 bits by zeroing out the upper 32-bit field
         */
        ObjDesc->Integer.Value &= (UINT64) ACPI_UINT32_MAX;
        return (TRUE);
    }
 
    return (FALSE);
}

Referenced by AcpiDsExecEndOp(), AcpiDsGetPredicateValue(), AcpiDsInitObjectFromOp(), AcpiExConvertToInteger(), and AcpiExStoreObjectToObject().

AcpiExUnlinkMutex()

void AcpiExUnlinkMutex

(

ACPI_OPERAND_OBJECT *

ObjDesc

)

Definition at line 73 of file exmutex.c.

{
    ACPI_THREAD_STATE       *Thread = ObjDesc->Mutex.OwnerThread;
 
 
    if (!Thread)
    {
        return;
    }
 
    /* Doubly linked list */
 
    if (ObjDesc->Mutex.Next)
    {
        (ObjDesc->Mutex.Next)->Mutex.Prev = ObjDesc->Mutex.Prev;
    }
 
    if (ObjDesc->Mutex.Prev)
    {
        (ObjDesc->Mutex.Prev)->Mutex.Next = ObjDesc->Mutex.Next;
 
        /*
         * Migrate the previous sync level associated with this mutex to
         * the previous mutex on the list so that it may be preserved.
         * This handles the case where several mutexes have been acquired
         * at the same level, but are not released in opposite order.
         */
        (ObjDesc->Mutex.Prev)->Mutex.OriginalSyncLevel =
            ObjDesc->Mutex.OriginalSyncLevel;
    }
    else
    {
        Thread->AcquiredMutexList = ObjDesc->Mutex.Next;
    }
}

Referenced by AcpiExReleaseMutexObject(), and AcpiUtDeleteInternalObj().

AcpiExUnloadTable()

ACPI_STATUS AcpiExUnloadTable

(

ACPI_OPERAND_OBJECT *

DdbHandle

)

Definition at line 565 of file exconfig.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_OPERAND_OBJECT     *TableDesc = DdbHandle;
    UINT32                  TableIndex;
 
 
    ACPI_FUNCTION_TRACE (ExUnloadTable);
 
 
    /*
     * Temporarily emit a warning so that the ASL for the machine can be
     * hopefully obtained. This is to say that the Unload() operator is
     * extremely rare if not completely unused.
     */
    ACPI_WARNING ((AE_INFO,
        "Received request to unload an ACPI table"));
 
    /*
     * May 2018: Unload is no longer supported for the following reasons:
     * 1) A correct implementation on some hosts may not be possible.
     * 2) Other ACPI implementations do not correctly/fully support it.
     * 3) It requires host device driver support which does not exist.
     *    (To properly support namespace unload out from underneath.)
     * 4) This AML operator has never been seen in the field.
     */
    ACPI_EXCEPTION ((AE_INFO, AE_NOT_IMPLEMENTED,
        "AML Unload operator is not supported"));
 
    /*
     * Validate the handle
     * Although the handle is partially validated in AcpiExReconfiguration()
     * when it calls AcpiExResolveOperands(), the handle is more completely
     * validated here.
     *
     * Handle must be a valid operand object of type reference. Also, the
     * DdbHandle must still be marked valid (table has not been previously
     * unloaded)
     */
    if ((!DdbHandle) ||
        (ACPI_GET_DESCRIPTOR_TYPE (DdbHandle) != ACPI_DESC_TYPE_OPERAND) ||
        (DdbHandle->Common.Type != ACPI_TYPE_LOCAL_REFERENCE) ||
        (!(DdbHandle->Common.Flags & AOPOBJ_DATA_VALID)))
    {
        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
    }
 
    /* Get the table index from the DdbHandle */
 
    TableIndex = TableDesc->Reference.Value;
 
    /*
     * Release the interpreter lock so that the table lock won't have
     * strict order requirement against it.
     */
    AcpiExExitInterpreter ();
    Status = AcpiTbUnloadTable (TableIndex);
    AcpiExEnterInterpreter ();
 
    /*
     * Invalidate the handle. We do this because the handle may be stored
     * in a named object and may not be actually deleted until much later.
     */
    if (ACPI_SUCCESS (Status))
    {
        DdbHandle->Common.Flags &= ~AOPOBJ_DATA_VALID;
    }
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExLoadTableOp(), and AcpiExOpcode_1A_0T_0R().

AcpiExWriteDataToField()

ACPI_STATUS AcpiExWriteDataToField	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT **	ResultDesc
	)

Definition at line 317 of file exfield.c.

{
    ACPI_STATUS             Status;
    UINT32                  BufferLength;
    UINT32                  DataLength;
    void                    *Buffer;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExWriteDataToField, ObjDesc);
 
 
    /* Parameter validation */
 
    if (!SourceDesc || !ObjDesc)
    {
        return_ACPI_STATUS (AE_AML_NO_OPERAND);
    }
 
    if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
    {
        /*
         * If the BufferField arguments have not been previously evaluated,
         * evaluate them now and save the results.
         */
        if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
        {
            Status = AcpiDsGetBufferFieldArguments (ObjDesc);
            if (ACPI_FAILURE (Status))
            {
                return_ACPI_STATUS (Status);
            }
        }
    }
    else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
        (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GPIO))
    {
        /* General Purpose I/O */
 
        Status = AcpiExWriteGpio (SourceDesc, ObjDesc, ResultDesc);
        return_ACPI_STATUS (Status);
    }
    else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
        (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||
         ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS ||
         ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI  ||
         ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_PLATFORM_RT ||
         ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_FIXED_HARDWARE))
    {
        /* SMBus, GSBus, IPMI serial */
 
        Status = AcpiExWriteSerialBus (SourceDesc, ObjDesc, ResultDesc);
        return_ACPI_STATUS (Status);
    }
    else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
             (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_PLATFORM_COMM))
    {
        /*
         * According to the spec a write to the COMD field will invoke the
         * region handler. Otherwise, write to the PccInternal buffer. This
         * implementation will use the offsets specified rather than the name
         * of the field. This is considered safer because some firmware tools
         * are known to obfiscate named objects.
         */
        DataLength = (ACPI_SIZE) ACPI_ROUND_BITS_UP_TO_BYTES (
            ObjDesc->Field.BitLength);
        memcpy (ObjDesc->Field.RegionObj->Field.InternalPccBuffer +
            ObjDesc->Field.BaseByteOffset,
            SourceDesc->Buffer.Pointer, DataLength);
 
        if (MASTER_SUBSPACE_COMMAND (ObjDesc->Field.BaseByteOffset))
        {
            /* Perform the write */
 
            ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
                "PCC COMD field has been written. Invoking PCC handler now.\n"));
 
            Status = AcpiExAccessRegion (
                ObjDesc, 0, (UINT64 *) ObjDesc->Field.RegionObj->Field.InternalPccBuffer,
                ACPI_WRITE);
            return_ACPI_STATUS (Status);
        }
        return (AE_OK);
    }
 
 
    /* Get a pointer to the data to be written */
 
    switch (SourceDesc->Common.Type)
    {
    case ACPI_TYPE_INTEGER:
 
        Buffer = &SourceDesc->Integer.Value;
        BufferLength = sizeof (SourceDesc->Integer.Value);
        break;
 
    case ACPI_TYPE_BUFFER:
 
        Buffer = SourceDesc->Buffer.Pointer;
        BufferLength = SourceDesc->Buffer.Length;
        break;
 
    case ACPI_TYPE_STRING:
 
        Buffer = SourceDesc->String.Pointer;
        BufferLength = SourceDesc->String.Length;
        break;
 
    default:
        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
        "FieldWrite [FROM]: Obj %p (%s:%X), Buf %p, ByteLen %X\n",
        SourceDesc, AcpiUtGetTypeName (SourceDesc->Common.Type),
        SourceDesc->Common.Type, Buffer, BufferLength));
 
    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
        "FieldWrite [TO]:   Obj %p (%s:%X), BitLen %X, BitOff %X, ByteOff %X\n",
        ObjDesc, AcpiUtGetTypeName (ObjDesc->Common.Type),
        ObjDesc->Common.Type,
        ObjDesc->CommonField.BitLength,
        ObjDesc->CommonField.StartFieldBitOffset,
        ObjDesc->CommonField.BaseByteOffset));
 
    /* Lock entire transaction if requested */
 
    AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 
    /* Write to the field */
 
    Status = AcpiExInsertIntoField (ObjDesc, Buffer, BufferLength);
    AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiDsExecEndOp(), AcpiDsGetFieldNames(), and AcpiExStoreObjectToNode().

AcpiExWriteGpio()

ACPI_STATUS AcpiExWriteGpio	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT **	ReturnBuffer
	)

Definition at line 121 of file exserial.c.

{
    ACPI_STATUS             Status;
    void                    *Buffer;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExWriteGpio, ObjDesc);
 
 
    /*
     * For GPIO (GeneralPurposeIo), we will bypass the entire field
     * mechanism and handoff the bit address and bit width directly to
     * the handler. The Address will be the bit offset
     * from the previous Connection() operator, making it effectively a
     * pin number index. The BitLength is the length of the field, which
     * is thus the number of pins.
     */
    if (SourceDesc->Common.Type != ACPI_TYPE_INTEGER)
    {
        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
        "GPIO FieldWrite [FROM]: (%s:%X), Value %.8X  [TO]: Pin %u Bits %u\n",
        AcpiUtGetTypeName (SourceDesc->Common.Type),
        SourceDesc->Common.Type, (UINT32) SourceDesc->Integer.Value,
        ObjDesc->Field.PinNumberIndex, ObjDesc->Field.BitLength));
 
    Buffer = &SourceDesc->Integer.Value;
 
    /* Lock entire transaction if requested */
 
    AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 
    /* Perform the write */
 
    Status = AcpiExAccessRegion (
        ObjDesc, 0, (UINT64 *) Buffer, ACPI_WRITE);
    AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExWriteDataToField().

AcpiExWriteSerialBus()

ACPI_STATUS AcpiExWriteSerialBus	(	ACPI_OPERAND_OBJECT *	SourceDesc,
		ACPI_OPERAND_OBJECT *	ObjDesc,
		ACPI_OPERAND_OBJECT **	ReturnBuffer
	)

Definition at line 297 of file exserial.c.

{
    ACPI_STATUS             Status;
    UINT32                  BufferLength;
    UINT32                  DataLength;
    void                    *Buffer;
    ACPI_OPERAND_OBJECT     *BufferDesc;
    UINT32                  Function;
    UINT16                  AccessorType;
 
 
    ACPI_FUNCTION_TRACE_PTR (ExWriteSerialBus, ObjDesc);
 
 
    /*
     * This is an SMBus, GSBus or IPMI write. We will bypass the entire
     * field mechanism and handoff the buffer directly to the handler.
     * For these address spaces, the buffer is bidirectional; on a
     * write, return data is returned in the same buffer.
     *
     * Source must be a buffer of sufficient size, these are fixed size:
     * ACPI_SMBUS_BUFFER_SIZE, or ACPI_IPMI_BUFFER_SIZE.
     *
     * Note: SMBus and GSBus protocol type is passed in upper 16-bits
     * of Function
     *
     * Common buffer format:
     *     Status;    (Byte 0 of the data buffer)
     *     Length;    (Byte 1 of the data buffer)
     *     Data[x-1]: (Bytes 2-x of the arbitrary length data buffer)
     */
    if (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)
    {
        ACPI_ERROR ((AE_INFO,
            "SMBus/IPMI/GenericSerialBus write requires "
            "Buffer, found type %s",
            AcpiUtGetObjectTypeName (SourceDesc)));
 
        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
    }
 
    switch (ObjDesc->Field.RegionObj->Region.SpaceId)
    {
    case ACPI_ADR_SPACE_SMBUS:
 
        BufferLength = ACPI_SMBUS_BUFFER_SIZE;
        Function = ACPI_WRITE | (ObjDesc->Field.Attribute << 16);
        break;
 
    case ACPI_ADR_SPACE_IPMI:
 
        BufferLength = ACPI_IPMI_BUFFER_SIZE;
        Function = ACPI_WRITE;
        break;
 
    case ACPI_ADR_SPACE_GSBUS:
 
        AccessorType = ObjDesc->Field.Attribute;
        Status = AcpiExGetProtocolBufferLength (AccessorType, &BufferLength);
        if (ACPI_FAILURE (Status))
        {
            ACPI_ERROR ((AE_INFO,
                "Invalid protocol ID for GSBus: 0x%4.4X", AccessorType));
 
            return_ACPI_STATUS (Status);
        }
 
        /* Add header length to get the full size of the buffer */
 
        BufferLength += ACPI_SERIAL_HEADER_SIZE;
        Function = ACPI_WRITE | (AccessorType << 16);
        break;
 
    case ACPI_ADR_SPACE_PLATFORM_RT:
 
        BufferLength = ACPI_PRM_INPUT_BUFFER_SIZE;
        Function = ACPI_WRITE;
        break;
 
    case ACPI_ADR_SPACE_FIXED_HARDWARE:
 
        BufferLength = ACPI_FFH_INPUT_BUFFER_SIZE;
        Function = ACPI_WRITE;
        break;
 
    default:
        return_ACPI_STATUS (AE_AML_INVALID_SPACE_ID);
    }
 
    /* Create the transfer/bidirectional/return buffer */
 
    BufferDesc = AcpiUtCreateBufferObject (BufferLength);
    if (!BufferDesc)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /* Copy the input buffer data to the transfer buffer */
 
    Buffer = BufferDesc->Buffer.Pointer;
    DataLength = (BufferLength < SourceDesc->Buffer.Length ?
        BufferLength : SourceDesc->Buffer.Length);
    memcpy (Buffer, SourceDesc->Buffer.Pointer, DataLength);
 
    /* Lock entire transaction if requested */
 
    AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 
    /*
     * Perform the write (returns status and perhaps data in the
     * same buffer)
     */
    Status = AcpiExAccessRegion (
        ObjDesc, 0, (UINT64 *) Buffer, Function);
    AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 
    *ReturnBuffer = BufferDesc;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExWriteDataToField().

AcpiExWriteWithUpdateRule()

ACPI_STATUS AcpiExWriteWithUpdateRule	(	ACPI_OPERAND_OBJECT *	ObjDesc,
		UINT64	Mask,
		UINT64	FieldValue,
		UINT32	FieldDatumByteOffset
	)

Definition at line 617 of file exfldio.c.

{
    ACPI_STATUS             Status = AE_OK;
    UINT64                  MergedValue;
    UINT64                  CurrentValue;
 
 
    ACPI_FUNCTION_TRACE_U32 (ExWriteWithUpdateRule, Mask);
 
 
    /* Start with the new bits  */
 
    MergedValue = FieldValue;
 
    /* If the mask is all ones, we don't need to worry about the update rule */
 
    if (Mask != ACPI_UINT64_MAX)
    {
        /* Decode the update rule */
 
        switch (ObjDesc->CommonField.FieldFlags & AML_FIELD_UPDATE_RULE_MASK)
        {
        case AML_FIELD_UPDATE_PRESERVE:
            /*
             * Check if update rule needs to be applied (not if mask is all
             * ones)  The left shift drops the bits we want to ignore.
             */
            if ((~Mask << (ACPI_MUL_8 (sizeof (Mask)) -
                   ACPI_MUL_8 (ObjDesc->CommonField.AccessByteWidth))) != 0)
            {
                /*
                 * Read the current contents of the byte/word/dword containing
                 * the field, and merge with the new field value.
                 */
                Status = AcpiExFieldDatumIo (
                    ObjDesc, FieldDatumByteOffset, &CurrentValue, ACPI_READ);
                if (ACPI_FAILURE (Status))
                {
                    return_ACPI_STATUS (Status);
                }
 
                MergedValue |= (CurrentValue & ~Mask);
            }
            break;
 
        case AML_FIELD_UPDATE_WRITE_AS_ONES:
 
            /* Set positions outside the field to all ones */
 
            MergedValue |= ~Mask;
            break;
 
        case AML_FIELD_UPDATE_WRITE_AS_ZEROS:
 
            /* Set positions outside the field to all zeros */
 
            MergedValue &= Mask;
            break;
 
        default:
 
            ACPI_ERROR ((AE_INFO,
                "Unknown UpdateRule value: 0x%X",
                (ObjDesc->CommonField.FieldFlags &
                    AML_FIELD_UPDATE_RULE_MASK)));
            return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
        }
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
        "Mask %8.8X%8.8X, DatumOffset %X, Width %X, "
        "Value %8.8X%8.8X, MergedValue %8.8X%8.8X\n",
        ACPI_FORMAT_UINT64 (Mask),
        FieldDatumByteOffset,
        ObjDesc->CommonField.AccessByteWidth,
        ACPI_FORMAT_UINT64 (FieldValue),
        ACPI_FORMAT_UINT64 (MergedValue)));
 
    /* Write the merged value */
 
    Status = AcpiExFieldDatumIo (
        ObjDesc, FieldDatumByteOffset, &MergedValue, ACPI_WRITE);
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExInsertIntoField().

AcpiIsValidSpaceId()

BOOLEAN AcpiIsValidSpaceId

(

UINT8

SpaceId

)

Definition at line 494 of file exutils.c.

{
 
    if ((SpaceId >= ACPI_NUM_PREDEFINED_REGIONS) &&
        (SpaceId < ACPI_USER_REGION_BEGIN) &&
        (SpaceId != ACPI_ADR_SPACE_DATA_TABLE) &&
        (SpaceId != ACPI_ADR_SPACE_FIXED_HARDWARE))
    {
        return (FALSE);
    }
 
    return (TRUE);
}

Referenced by AcpiExCreateRegion(), and AcpiExSetupRegion().