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: