934 lines
27 KiB
C
934 lines
27 KiB
C
/*******************************************************************************
|
|
*
|
|
* Module Name: dsutils - Dispatcher utilities
|
|
* $Revision: 72 $
|
|
*
|
|
******************************************************************************/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* 1. Copyright Notice
|
|
*
|
|
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp.
|
|
* All rights reserved.
|
|
*
|
|
* 2. License
|
|
*
|
|
* 2.1. This is your license from Intel Corp. under its intellectual property
|
|
* rights. You may have additional license terms from the party that provided
|
|
* you this software, covering your right to use that party's intellectual
|
|
* property rights.
|
|
*
|
|
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
|
|
* copy of the source code appearing in this file ("Covered Code") an
|
|
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
|
|
* base code distributed originally by Intel ("Original Intel Code") to copy,
|
|
* make derivatives, distribute, use and display any portion of the Covered
|
|
* Code in any form, with the right to sublicense such rights; and
|
|
*
|
|
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
|
|
* license (with the right to sublicense), under only those claims of Intel
|
|
* patents that are infringed by the Original Intel Code, to make, use, sell,
|
|
* offer to sell, and import the Covered Code and derivative works thereof
|
|
* solely to the minimum extent necessary to exercise the above copyright
|
|
* license, and in no event shall the patent license extend to any additions
|
|
* to or modifications of the Original Intel Code. No other license or right
|
|
* is granted directly or by implication, estoppel or otherwise;
|
|
*
|
|
* The above copyright and patent license is granted only if the following
|
|
* conditions are met:
|
|
*
|
|
* 3. Conditions
|
|
*
|
|
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
|
|
* Redistribution of source code of any substantial portion of the Covered
|
|
* Code or modification with rights to further distribute source must include
|
|
* the above Copyright Notice, the above License, this list of Conditions,
|
|
* and the following Disclaimer and Export Compliance provision. In addition,
|
|
* Licensee must cause all Covered Code to which Licensee contributes to
|
|
* contain a file documenting the changes Licensee made to create that Covered
|
|
* Code and the date of any change. Licensee must include in that file the
|
|
* documentation of any changes made by any predecessor Licensee. Licensee
|
|
* must include a prominent statement that the modification is derived,
|
|
* directly or indirectly, from Original Intel Code.
|
|
*
|
|
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
|
|
* Redistribution of source code of any substantial portion of the Covered
|
|
* Code or modification without rights to further distribute source must
|
|
* include the following Disclaimer and Export Compliance provision in the
|
|
* documentation and/or other materials provided with distribution. In
|
|
* addition, Licensee may not authorize further sublicense of source of any
|
|
* portion of the Covered Code, and must include terms to the effect that the
|
|
* license from Licensee to its licensee is limited to the intellectual
|
|
* property embodied in the software Licensee provides to its licensee, and
|
|
* not to intellectual property embodied in modifications its licensee may
|
|
* make.
|
|
*
|
|
* 3.3. Redistribution of Executable. Redistribution in executable form of any
|
|
* substantial portion of the Covered Code or modification must reproduce the
|
|
* above Copyright Notice, and the following Disclaimer and Export Compliance
|
|
* provision in the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* 3.4. Intel retains all right, title, and interest in and to the Original
|
|
* Intel Code.
|
|
*
|
|
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
|
|
* Intel shall be used in advertising or otherwise to promote the sale, use or
|
|
* other dealings in products derived from or relating to the Covered Code
|
|
* without prior written authorization from Intel.
|
|
*
|
|
* 4. Disclaimer and Export Compliance
|
|
*
|
|
* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
|
|
* HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
|
|
* IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
|
|
* INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
|
|
* UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
|
|
* PARTICULAR PURPOSE.
|
|
*
|
|
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
|
|
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
|
|
* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
|
|
* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
|
|
* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
|
|
* HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
|
|
* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
|
|
* LIMITED REMEDY.
|
|
*
|
|
* 4.3. Licensee shall not export, either directly or indirectly, any of this
|
|
* software or system incorporating such software without first obtaining any
|
|
* required license or other approval from the U. S. Department of Commerce or
|
|
* any other agency or department of the United States Government. In the
|
|
* event Licensee exports any such software from the United States or
|
|
* re-exports any such software from a foreign destination, Licensee shall
|
|
* ensure that the distribution and export/re-export of the software is in
|
|
* compliance with all laws, regulations, orders, or other restrictions of the
|
|
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
|
|
* any of its subsidiaries will export/re-export any technical data, process,
|
|
* software, or service, directly or indirectly, to any country for which the
|
|
* United States government or any agency thereof requires an export license,
|
|
* other governmental approval, or letter of assurance, without first obtaining
|
|
* such license, approval or letter.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define __DSUTILS_C__
|
|
|
|
#include "acpi.h"
|
|
#include "acparser.h"
|
|
#include "amlcode.h"
|
|
#include "acdispat.h"
|
|
#include "acinterp.h"
|
|
#include "acnamesp.h"
|
|
#include "acdebug.h"
|
|
|
|
#define _COMPONENT ACPI_DISPATCHER
|
|
MODULE_NAME ("dsutils")
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiDsIsResultUsed
|
|
*
|
|
* PARAMETERS: Op
|
|
* ResultObj
|
|
* WalkState
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Check if a result object will be used by the parent
|
|
*
|
|
******************************************************************************/
|
|
|
|
BOOLEAN
|
|
AcpiDsIsResultUsed (
|
|
ACPI_PARSE_OBJECT *Op,
|
|
ACPI_WALK_STATE *WalkState)
|
|
{
|
|
const ACPI_OPCODE_INFO *ParentInfo;
|
|
|
|
|
|
FUNCTION_TRACE_PTR ("DsIsResultUsed", Op);
|
|
|
|
|
|
/* Must have both an Op and a Result Object */
|
|
|
|
if (!Op)
|
|
{
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null Op\n"));
|
|
return_VALUE (TRUE);
|
|
}
|
|
|
|
|
|
/*
|
|
* If there is no parent, the result can't possibly be used!
|
|
* (An executing method typically has no parent, since each
|
|
* method is parsed separately) However, a method that is
|
|
* invoked from another method has a parent.
|
|
*/
|
|
if (!Op->Parent)
|
|
{
|
|
return_VALUE (FALSE);
|
|
}
|
|
|
|
|
|
/*
|
|
* Get info on the parent. The root Op is AML_SCOPE
|
|
*/
|
|
|
|
ParentInfo = AcpiPsGetOpcodeInfo (Op->Parent->Opcode);
|
|
if (ACPI_GET_OP_TYPE (ParentInfo) != ACPI_OP_TYPE_OPCODE)
|
|
{
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown parent opcode. Op=%X\n", Op));
|
|
return_VALUE (FALSE);
|
|
}
|
|
|
|
|
|
/*
|
|
* Decide what to do with the result based on the parent. If
|
|
* the parent opcode will not use the result, delete the object.
|
|
* Otherwise leave it as is, it will be deleted when it is used
|
|
* as an operand later.
|
|
*/
|
|
switch (ACPI_GET_OP_CLASS (ParentInfo))
|
|
{
|
|
/*
|
|
* In these cases, the parent will never use the return object
|
|
*/
|
|
case OPTYPE_CONTROL: /* IF, ELSE, WHILE only */
|
|
|
|
switch (Op->Parent->Opcode)
|
|
{
|
|
case AML_RETURN_OP:
|
|
|
|
/* Never delete the return value associated with a return opcode */
|
|
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
|
|
"Result used, [RETURN] opcode=%X Op=%X\n", Op->Opcode, Op));
|
|
return_VALUE (TRUE);
|
|
break;
|
|
|
|
case AML_IF_OP:
|
|
case AML_WHILE_OP:
|
|
|
|
/*
|
|
* If we are executing the predicate AND this is the predicate op,
|
|
* we will use the return value!
|
|
*/
|
|
if ((WalkState->ControlState->Common.State == CONTROL_PREDICATE_EXECUTING) &&
|
|
(WalkState->ControlState->Control.PredicateOp == Op))
|
|
{
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
|
|
"Result used as a predicate, [IF/WHILE] opcode=%X Op=%X\n",
|
|
Op->Opcode, Op));
|
|
return_VALUE (TRUE);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
/* Fall through to not used case below */
|
|
|
|
|
|
case OPTYPE_NAMED_OBJECT: /* Scope, method, etc. */
|
|
|
|
/*
|
|
* These opcodes allow TermArg(s) as operands and therefore
|
|
* method calls. The result is used.
|
|
*/
|
|
if ((Op->Parent->Opcode == AML_REGION_OP) ||
|
|
(Op->Parent->Opcode == AML_CREATE_FIELD_OP) ||
|
|
(Op->Parent->Opcode == AML_CREATE_BIT_FIELD_OP) ||
|
|
(Op->Parent->Opcode == AML_CREATE_BYTE_FIELD_OP) ||
|
|
(Op->Parent->Opcode == AML_CREATE_WORD_FIELD_OP) ||
|
|
(Op->Parent->Opcode == AML_CREATE_DWORD_FIELD_OP) ||
|
|
(Op->Parent->Opcode == AML_CREATE_QWORD_FIELD_OP))
|
|
{
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
|
|
"Result used, [Region or CreateField] opcode=%X Op=%X\n",
|
|
Op->Opcode, Op));
|
|
return_VALUE (TRUE);
|
|
}
|
|
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
|
|
"Result not used, Parent opcode=%X Op=%X\n", Op->Opcode, Op));
|
|
|
|
return_VALUE (FALSE);
|
|
break;
|
|
|
|
/*
|
|
* In all other cases. the parent will actually use the return
|
|
* object, so keep it.
|
|
*/
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return_VALUE (TRUE);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiDsDeleteResultIfNotUsed
|
|
*
|
|
* PARAMETERS: Op
|
|
* ResultObj
|
|
* WalkState
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Used after interpretation of an opcode. If there is an internal
|
|
* result descriptor, check if the parent opcode will actually use
|
|
* this result. If not, delete the result now so that it will
|
|
* not become orphaned.
|
|
*
|
|
******************************************************************************/
|
|
|
|
void
|
|
AcpiDsDeleteResultIfNotUsed (
|
|
ACPI_PARSE_OBJECT *Op,
|
|
ACPI_OPERAND_OBJECT *ResultObj,
|
|
ACPI_WALK_STATE *WalkState)
|
|
{
|
|
ACPI_OPERAND_OBJECT *ObjDesc;
|
|
ACPI_STATUS Status;
|
|
|
|
|
|
FUNCTION_TRACE_PTR ("DsDeleteResultIfNotUsed", ResultObj);
|
|
|
|
|
|
if (!Op)
|
|
{
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null Op\n"));
|
|
return_VOID;
|
|
}
|
|
|
|
if (!ResultObj)
|
|
{
|
|
return_VOID;
|
|
}
|
|
|
|
|
|
if (!AcpiDsIsResultUsed (Op, WalkState))
|
|
{
|
|
/*
|
|
* Must pop the result stack (ObjDesc should be equal to ResultObj)
|
|
*/
|
|
Status = AcpiDsResultPop (&ObjDesc, WalkState);
|
|
if (ACPI_SUCCESS (Status))
|
|
{
|
|
AcpiUtRemoveReference (ResultObj);
|
|
}
|
|
}
|
|
|
|
return_VOID;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiDsCreateOperand
|
|
*
|
|
* PARAMETERS: WalkState
|
|
* Arg
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Translate a parse tree object that is an argument to an AML
|
|
* opcode to the equivalent interpreter object. This may include
|
|
* looking up a name or entering a new name into the internal
|
|
* namespace.
|
|
*
|
|
******************************************************************************/
|
|
|
|
ACPI_STATUS
|
|
AcpiDsCreateOperand (
|
|
ACPI_WALK_STATE *WalkState,
|
|
ACPI_PARSE_OBJECT *Arg,
|
|
UINT32 ArgIndex)
|
|
{
|
|
ACPI_STATUS Status = AE_OK;
|
|
NATIVE_CHAR *NameString;
|
|
UINT32 NameLength;
|
|
ACPI_OBJECT_TYPE8 DataType;
|
|
ACPI_OPERAND_OBJECT *ObjDesc;
|
|
ACPI_PARSE_OBJECT *ParentOp;
|
|
UINT16 Opcode;
|
|
UINT32 Flags;
|
|
OPERATING_MODE InterpreterMode;
|
|
const ACPI_OPCODE_INFO *OpInfo;
|
|
|
|
|
|
FUNCTION_TRACE_PTR ("DsCreateOperand", Arg);
|
|
|
|
|
|
/* A valid name must be looked up in the namespace */
|
|
|
|
if ((Arg->Opcode == AML_INT_NAMEPATH_OP) &&
|
|
(Arg->Value.String))
|
|
{
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Getting a name: Arg=%p\n", Arg));
|
|
|
|
/* Get the entire name string from the AML stream */
|
|
|
|
Status = AcpiExGetNameString (ACPI_TYPE_ANY, Arg->Value.Buffer,
|
|
&NameString, &NameLength);
|
|
|
|
if (ACPI_FAILURE (Status))
|
|
{
|
|
return_ACPI_STATUS (Status);
|
|
}
|
|
|
|
/*
|
|
* All prefixes have been handled, and the name is
|
|
* in NameString
|
|
*/
|
|
|
|
/*
|
|
* Differentiate between a namespace "create" operation
|
|
* versus a "lookup" operation (IMODE_LOAD_PASS2 vs.
|
|
* IMODE_EXECUTE) in order to support the creation of
|
|
* namespace objects during the execution of control methods.
|
|
*/
|
|
ParentOp = Arg->Parent;
|
|
OpInfo = AcpiPsGetOpcodeInfo (ParentOp->Opcode);
|
|
if ((OpInfo->Flags & AML_NSNODE) &&
|
|
(ParentOp->Opcode != AML_INT_METHODCALL_OP) &&
|
|
(ParentOp->Opcode != AML_REGION_OP) &&
|
|
(ParentOp->Opcode != AML_INT_NAMEPATH_OP))
|
|
{
|
|
/* Enter name into namespace if not found */
|
|
|
|
InterpreterMode = IMODE_LOAD_PASS2;
|
|
}
|
|
|
|
else
|
|
{
|
|
/* Return a failure if name not found */
|
|
|
|
InterpreterMode = IMODE_EXECUTE;
|
|
}
|
|
|
|
Status = AcpiNsLookup (WalkState->ScopeInfo, NameString,
|
|
ACPI_TYPE_ANY, InterpreterMode,
|
|
NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE,
|
|
WalkState,
|
|
(ACPI_NAMESPACE_NODE **) &ObjDesc);
|
|
|
|
/* Free the namestring created above */
|
|
|
|
ACPI_MEM_FREE (NameString);
|
|
|
|
/*
|
|
* The only case where we pass through (ignore) a NOT_FOUND
|
|
* error is for the CondRefOf opcode.
|
|
*/
|
|
if (Status == AE_NOT_FOUND)
|
|
{
|
|
if (ParentOp->Opcode == AML_COND_REF_OF_OP)
|
|
{
|
|
/*
|
|
* For the Conditional Reference op, it's OK if
|
|
* the name is not found; We just need a way to
|
|
* indicate this to the interpreter, set the
|
|
* object to the root
|
|
*/
|
|
ObjDesc = (ACPI_OPERAND_OBJECT *) AcpiGbl_RootNode;
|
|
Status = AE_OK;
|
|
}
|
|
|
|
else
|
|
{
|
|
/*
|
|
* We just plain didn't find it -- which is a
|
|
* very serious error at this point
|
|
*/
|
|
Status = AE_AML_NAME_NOT_FOUND;
|
|
}
|
|
}
|
|
|
|
/* Check status from the lookup */
|
|
|
|
if (ACPI_FAILURE (Status))
|
|
{
|
|
return_ACPI_STATUS (Status);
|
|
}
|
|
|
|
/* Put the resulting object onto the current object stack */
|
|
|
|
Status = AcpiDsObjStackPush (ObjDesc, WalkState);
|
|
if (ACPI_FAILURE (Status))
|
|
{
|
|
return_ACPI_STATUS (Status);
|
|
}
|
|
DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (ObjDesc, WalkState));
|
|
}
|
|
|
|
|
|
else
|
|
{
|
|
/* Check for null name case */
|
|
|
|
if (Arg->Opcode == AML_INT_NAMEPATH_OP)
|
|
{
|
|
/*
|
|
* If the name is null, this means that this is an
|
|
* optional result parameter that was not specified
|
|
* in the original ASL. Create an Reference for a
|
|
* placeholder
|
|
*/
|
|
Opcode = AML_ZERO_OP; /* Has no arguments! */
|
|
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Null namepath: Arg=%p\n", Arg));
|
|
|
|
/*
|
|
* TBD: [Investigate] anything else needed for the
|
|
* zero op lvalue?
|
|
*/
|
|
}
|
|
|
|
else
|
|
{
|
|
Opcode = Arg->Opcode;
|
|
}
|
|
|
|
|
|
/* Get the data type of the argument */
|
|
|
|
DataType = AcpiDsMapOpcodeToDataType (Opcode, &Flags);
|
|
if (DataType == INTERNAL_TYPE_INVALID)
|
|
{
|
|
return_ACPI_STATUS (AE_NOT_IMPLEMENTED);
|
|
}
|
|
|
|
if (Flags & OP_HAS_RETURN_VALUE)
|
|
{
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
|
|
"Argument previously created, already stacked \n"));
|
|
|
|
DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (WalkState->Operands [WalkState->NumOperands - 1], WalkState));
|
|
|
|
/*
|
|
* Use value that was already previously returned
|
|
* by the evaluation of this argument
|
|
*/
|
|
Status = AcpiDsResultPopFromBottom (&ObjDesc, WalkState);
|
|
if (ACPI_FAILURE (Status))
|
|
{
|
|
/*
|
|
* Only error is underflow, and this indicates
|
|
* a missing or null operand!
|
|
*/
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Missing or null operand, %s\n",
|
|
AcpiFormatException (Status)));
|
|
return_ACPI_STATUS (Status);
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
{
|
|
/* Create an ACPI_INTERNAL_OBJECT for the argument */
|
|
|
|
ObjDesc = AcpiUtCreateInternalObject (DataType);
|
|
if (!ObjDesc)
|
|
{
|
|
return_ACPI_STATUS (AE_NO_MEMORY);
|
|
}
|
|
|
|
/* Initialize the new object */
|
|
|
|
Status = AcpiDsInitObjectFromOp (WalkState, Arg,
|
|
Opcode, &ObjDesc);
|
|
if (ACPI_FAILURE (Status))
|
|
{
|
|
AcpiUtDeleteObjectDesc (ObjDesc);
|
|
return_ACPI_STATUS (Status);
|
|
}
|
|
}
|
|
|
|
/* Put the operand object on the object stack */
|
|
|
|
Status = AcpiDsObjStackPush (ObjDesc, WalkState);
|
|
if (ACPI_FAILURE (Status))
|
|
{
|
|
return_ACPI_STATUS (Status);
|
|
}
|
|
|
|
DEBUGGER_EXEC (AcpiDbDisplayArgumentObject (ObjDesc, WalkState));
|
|
}
|
|
|
|
return_ACPI_STATUS (AE_OK);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiDsCreateOperands
|
|
*
|
|
* PARAMETERS: FirstArg - First argument of a parser argument tree
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Convert an operator's arguments from a parse tree format to
|
|
* namespace objects and place those argument object on the object
|
|
* stack in preparation for evaluation by the interpreter.
|
|
*
|
|
******************************************************************************/
|
|
|
|
ACPI_STATUS
|
|
AcpiDsCreateOperands (
|
|
ACPI_WALK_STATE *WalkState,
|
|
ACPI_PARSE_OBJECT *FirstArg)
|
|
{
|
|
ACPI_STATUS Status = AE_OK;
|
|
ACPI_PARSE_OBJECT *Arg;
|
|
UINT32 ArgCount = 0;
|
|
|
|
|
|
FUNCTION_TRACE_PTR ("DsCreateOperands", FirstArg);
|
|
|
|
|
|
/* For all arguments in the list... */
|
|
|
|
Arg = FirstArg;
|
|
while (Arg)
|
|
{
|
|
Status = AcpiDsCreateOperand (WalkState, Arg, ArgCount);
|
|
if (ACPI_FAILURE (Status))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Arg #%d (%p) done, Arg1=%p\n",
|
|
ArgCount, Arg, FirstArg));
|
|
|
|
/* Move on to next argument, if any */
|
|
|
|
Arg = Arg->Next;
|
|
ArgCount++;
|
|
}
|
|
|
|
return_ACPI_STATUS (Status);
|
|
|
|
|
|
Cleanup:
|
|
/*
|
|
* We must undo everything done above; meaning that we must
|
|
* pop everything off of the operand stack and delete those
|
|
* objects
|
|
*/
|
|
AcpiDsObjStackPopAndDelete (ArgCount, WalkState);
|
|
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "While creating Arg %d - %s\n",
|
|
(ArgCount + 1), AcpiFormatException (Status)));
|
|
return_ACPI_STATUS (Status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiDsResolveOperands
|
|
*
|
|
* PARAMETERS: WalkState - Current walk state with operands on stack
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Resolve all operands to their values. Used to prepare
|
|
* arguments to a control method invocation (a call from one
|
|
* method to another.)
|
|
*
|
|
******************************************************************************/
|
|
|
|
ACPI_STATUS
|
|
AcpiDsResolveOperands (
|
|
ACPI_WALK_STATE *WalkState)
|
|
{
|
|
UINT32 i;
|
|
ACPI_STATUS Status = AE_OK;
|
|
|
|
|
|
FUNCTION_TRACE_PTR ("DsResolveOperands", WalkState);
|
|
|
|
|
|
/*
|
|
* Attempt to resolve each of the valid operands
|
|
* Method arguments are passed by value, not by reference
|
|
*/
|
|
|
|
/*
|
|
* TBD: [Investigate] Note from previous parser:
|
|
* RefOf problem with AcpiExResolveToValue() conversion.
|
|
*/
|
|
for (i = 0; i < WalkState->NumOperands; i++)
|
|
{
|
|
Status = AcpiExResolveToValue (&WalkState->Operands[i], WalkState);
|
|
if (ACPI_FAILURE (Status))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return_ACPI_STATUS (Status);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiDsMapOpcodeToDataType
|
|
*
|
|
* PARAMETERS: Opcode - AML opcode to map
|
|
* OutFlags - Additional info about the opcode
|
|
*
|
|
* RETURN: The ACPI type associated with the opcode
|
|
*
|
|
* DESCRIPTION: Convert a raw AML opcode to the associated ACPI data type,
|
|
* if any. If the opcode returns a value as part of the
|
|
* intepreter execution, a flag is returned in OutFlags.
|
|
*
|
|
******************************************************************************/
|
|
|
|
ACPI_OBJECT_TYPE8
|
|
AcpiDsMapOpcodeToDataType (
|
|
UINT16 Opcode,
|
|
UINT32 *OutFlags)
|
|
{
|
|
ACPI_OBJECT_TYPE8 DataType = INTERNAL_TYPE_INVALID;
|
|
const ACPI_OPCODE_INFO *OpInfo;
|
|
UINT32 Flags = 0;
|
|
|
|
|
|
PROC_NAME ("DsMapOpcodeToDataType");
|
|
|
|
|
|
OpInfo = AcpiPsGetOpcodeInfo (Opcode);
|
|
if (ACPI_GET_OP_TYPE (OpInfo) != ACPI_OP_TYPE_OPCODE)
|
|
{
|
|
/* Unknown opcode */
|
|
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown AML opcode: %x\n", Opcode));
|
|
return (DataType);
|
|
}
|
|
|
|
switch (ACPI_GET_OP_CLASS (OpInfo))
|
|
{
|
|
|
|
case OPTYPE_LITERAL:
|
|
|
|
switch (Opcode)
|
|
{
|
|
case AML_BYTE_OP:
|
|
case AML_WORD_OP:
|
|
case AML_DWORD_OP:
|
|
case AML_QWORD_OP:
|
|
|
|
DataType = ACPI_TYPE_INTEGER;
|
|
break;
|
|
|
|
|
|
case AML_STRING_OP:
|
|
|
|
DataType = ACPI_TYPE_STRING;
|
|
break;
|
|
|
|
case AML_INT_NAMEPATH_OP:
|
|
DataType = INTERNAL_TYPE_REFERENCE;
|
|
break;
|
|
|
|
default:
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
|
|
"Unknown (type LITERAL) AML opcode: %x\n", Opcode));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
|
|
case OPTYPE_DATA_TERM:
|
|
|
|
switch (Opcode)
|
|
{
|
|
case AML_BUFFER_OP:
|
|
|
|
DataType = ACPI_TYPE_BUFFER;
|
|
break;
|
|
|
|
case AML_PACKAGE_OP:
|
|
case AML_VAR_PACKAGE_OP:
|
|
|
|
DataType = ACPI_TYPE_PACKAGE;
|
|
break;
|
|
|
|
default:
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
|
|
"Unknown (type DATA_TERM) AML opcode: %x\n", Opcode));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
|
|
case OPTYPE_CONSTANT:
|
|
case OPTYPE_METHOD_ARGUMENT:
|
|
case OPTYPE_LOCAL_VARIABLE:
|
|
|
|
DataType = INTERNAL_TYPE_REFERENCE;
|
|
break;
|
|
|
|
|
|
case OPTYPE_MONADIC2:
|
|
case OPTYPE_MONADIC2R:
|
|
case OPTYPE_DYADIC2:
|
|
case OPTYPE_DYADIC2R:
|
|
case OPTYPE_DYADIC2S:
|
|
case OPTYPE_TRIADIC:
|
|
case OPTYPE_QUADRADIC:
|
|
case OPTYPE_HEXADIC:
|
|
case OPTYPE_RETURN:
|
|
|
|
Flags = OP_HAS_RETURN_VALUE;
|
|
DataType = ACPI_TYPE_ANY;
|
|
break;
|
|
|
|
|
|
case OPTYPE_METHOD_CALL:
|
|
|
|
Flags = OP_HAS_RETURN_VALUE;
|
|
DataType = ACPI_TYPE_METHOD;
|
|
break;
|
|
|
|
|
|
case OPTYPE_NAMED_OBJECT:
|
|
|
|
DataType = AcpiDsMapNamedOpcodeToDataType (Opcode);
|
|
break;
|
|
|
|
|
|
case OPTYPE_DYADIC1:
|
|
case OPTYPE_CONTROL:
|
|
|
|
/* No mapping needed at this time */
|
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
|
|
"Unimplemented data type opcode: %x\n", Opcode));
|
|
break;
|
|
}
|
|
|
|
/* Return flags to caller if requested */
|
|
|
|
if (OutFlags)
|
|
{
|
|
*OutFlags = Flags;
|
|
}
|
|
|
|
return (DataType);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiDsMapNamedOpcodeToDataType
|
|
*
|
|
* PARAMETERS: Opcode - The Named AML opcode to map
|
|
*
|
|
* RETURN: The ACPI type associated with the named opcode
|
|
*
|
|
* DESCRIPTION: Convert a raw Named AML opcode to the associated data type.
|
|
* Named opcodes are a subsystem of the AML opcodes.
|
|
*
|
|
******************************************************************************/
|
|
|
|
ACPI_OBJECT_TYPE8
|
|
AcpiDsMapNamedOpcodeToDataType (
|
|
UINT16 Opcode)
|
|
{
|
|
ACPI_OBJECT_TYPE8 DataType;
|
|
|
|
|
|
FUNCTION_ENTRY ();
|
|
|
|
|
|
/* Decode Opcode */
|
|
|
|
switch (Opcode)
|
|
{
|
|
case AML_SCOPE_OP:
|
|
DataType = INTERNAL_TYPE_SCOPE;
|
|
break;
|
|
|
|
case AML_DEVICE_OP:
|
|
DataType = ACPI_TYPE_DEVICE;
|
|
break;
|
|
|
|
case AML_THERMAL_ZONE_OP:
|
|
DataType = ACPI_TYPE_THERMAL;
|
|
break;
|
|
|
|
case AML_METHOD_OP:
|
|
DataType = ACPI_TYPE_METHOD;
|
|
break;
|
|
|
|
case AML_POWER_RES_OP:
|
|
DataType = ACPI_TYPE_POWER;
|
|
break;
|
|
|
|
case AML_PROCESSOR_OP:
|
|
DataType = ACPI_TYPE_PROCESSOR;
|
|
break;
|
|
|
|
case AML_FIELD_OP: /* FieldOp */
|
|
DataType = INTERNAL_TYPE_FIELD_DEFN;
|
|
break;
|
|
|
|
case AML_INDEX_FIELD_OP: /* IndexFieldOp */
|
|
DataType = INTERNAL_TYPE_INDEX_FIELD_DEFN;
|
|
break;
|
|
|
|
case AML_BANK_FIELD_OP: /* BankFieldOp */
|
|
DataType = INTERNAL_TYPE_BANK_FIELD_DEFN;
|
|
break;
|
|
|
|
case AML_INT_NAMEDFIELD_OP: /* NO CASE IN ORIGINAL */
|
|
DataType = ACPI_TYPE_ANY;
|
|
break;
|
|
|
|
case AML_NAME_OP: /* NameOp - special code in original */
|
|
case AML_INT_NAMEPATH_OP:
|
|
DataType = ACPI_TYPE_ANY;
|
|
break;
|
|
|
|
case AML_ALIAS_OP:
|
|
DataType = INTERNAL_TYPE_ALIAS;
|
|
break;
|
|
|
|
case AML_MUTEX_OP:
|
|
DataType = ACPI_TYPE_MUTEX;
|
|
break;
|
|
|
|
case AML_EVENT_OP:
|
|
DataType = ACPI_TYPE_EVENT;
|
|
break;
|
|
|
|
case AML_REGION_OP:
|
|
DataType = ACPI_TYPE_REGION;
|
|
break;
|
|
|
|
|
|
default:
|
|
DataType = ACPI_TYPE_ANY;
|
|
break;
|
|
|
|
}
|
|
|
|
return (DataType);
|
|
}
|
|
|
|
|