d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
926328c406
freebsd-dev/sys/contrib/dev/acpica/dsmthdat.c

883 lines
26 KiB
C
Raw Normal View History

Initial import of the Intel-maintained ACPI Component Architecture. This is Intel's reference implementation of the core operating-system ACPI support. (This import is on the vendor branch.)
2000-10-28 05:01:06 +00:00
/*******************************************************************************
*
* Module Name: dsmthdat - control method arguments and local variables
* $Revision: 34 $
*
******************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999, 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 __DSMTHDAT_C__
#include "acpi.h"
#include "acparser.h"
#include "acdispat.h"
#include "acinterp.h"
#include "amlcode.h"
#include "acnamesp.h"
#define _COMPONENT DISPATCHER
MODULE_NAME ("dsmthdat")
/*******************************************************************************
*
* FUNCTION: AcpiDsMethodDataInit
*
* PARAMETERS: *ObjDesc
*
* RETURN: Status
*
* DESCRIPTION: Initialize the data structures that hold the method's arguments
* and locals. The data struct is an array of NTEs for each.
* This allows RefOf and DeRefOf to work properly for these
* special data types.
*
******************************************************************************/
ACPI_STATUS
AcpiDsMethodDataInit (
ACPI_WALK_STATE *WalkState)
{
UINT32 i;
FUNCTION_TRACE ("DsMethodDataInit");
/*
* WalkState fields are initialized to zero by the
* AcpiCmCallocate().
*
* An Node is assigned to each argument and local so
* that RefOf() can return a pointer to the Node.
*/
/* Init the method arguments */
for (i = 0; i < MTH_NUM_ARGS; i++)
{
MOVE_UNALIGNED32_TO_32 (&WalkState->Arguments[i].Name,
NAMEOF_ARG_NTE);
WalkState->Arguments[i].Name |= (i << 24);
WalkState->Arguments[i].DataType = ACPI_DESC_TYPE_NAMED;
WalkState->Arguments[i].Type = INTERNAL_TYPE_METHOD_ARGUMENT;
}
/* Init the method locals */
for (i = 0; i < MTH_NUM_LOCALS; i++)
{
MOVE_UNALIGNED32_TO_32 (&WalkState->LocalVariables[i].Name,
NAMEOF_LOCAL_NTE);
WalkState->LocalVariables[i].Name |= (i << 24);
WalkState->LocalVariables[i].DataType = ACPI_DESC_TYPE_NAMED;
WalkState->LocalVariables[i].Type = INTERNAL_TYPE_METHOD_LOCAL_VAR;
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsMethodDataDeleteAll
*
* PARAMETERS: None
*
* RETURN: Status
*
* DESCRIPTION: Delete method locals and arguments. Arguments are only
* deleted if this method was called from another method.
*
******************************************************************************/
ACPI_STATUS
AcpiDsMethodDataDeleteAll (
ACPI_WALK_STATE *WalkState)
{
UINT32 Index;
ACPI_OPERAND_OBJECT *Object;
FUNCTION_TRACE ("DsMethodDataDeleteAll");
/* Delete the locals */
DEBUG_PRINT (ACPI_INFO,
("MethodDeleteAll: Deleting local variables in %p\n", WalkState));
for (Index = 0; Index < MTH_NUM_LOCALS; Index++)
{
Object = WalkState->LocalVariables[Index].Object;
if (Object)
{
DEBUG_PRINT (TRACE_EXEC,
("MethodDeleteAll: Deleting Local%d=%p\n", Index, Object));
/* Remove first */
WalkState->LocalVariables[Index].Object = NULL;
/* Was given a ref when stored */
AcpiCmRemoveReference (Object);
}
}
/* Delete the arguments */
DEBUG_PRINT (ACPI_INFO,
("MethodDeleteAll: Deleting arguments in %p\n", WalkState));
for (Index = 0; Index < MTH_NUM_ARGS; Index++)
{
Object = WalkState->Arguments[Index].Object;
if (Object)
{
DEBUG_PRINT (TRACE_EXEC,
("MethodDeleteAll: Deleting Arg%d=%p\n", Index, Object));
/* Remove first */
WalkState->Arguments[Index].Object = NULL;
/* Was given a ref when stored */
AcpiCmRemoveReference (Object);
}
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsMethodDataInitArgs
*
* PARAMETERS: None
*
* RETURN: Status
*
* DESCRIPTION: Initialize arguments for a method
*
******************************************************************************/
ACPI_STATUS
AcpiDsMethodDataInitArgs (
ACPI_OPERAND_OBJECT **Params,
UINT32 MaxParamCount,
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status;
UINT32 Mindex;
UINT32 Pindex;
FUNCTION_TRACE_PTR ("DsMethodDataInitArgs", Params);
if (!Params)
{
DEBUG_PRINT (TRACE_EXEC,
("DsMethodDataInitArgs: No param list passed to method\n"));
return_ACPI_STATUS (AE_OK);
}
/* Copy passed parameters into the new method stack frame */
for (Pindex = Mindex = 0;
(Mindex < MTH_NUM_ARGS) && (Pindex < MaxParamCount);
Mindex++)
{
if (Params[Pindex])
{
/*
* A valid parameter.
* Set the current method argument to the
* Params[Pindex++] argument object descriptor
*/
Status = AcpiDsMethodDataSetValue (MTH_TYPE_ARG, Mindex,
Params[Pindex], WalkState);
if (ACPI_FAILURE (Status))
{
break;
}
Pindex++;
}
else
{
break;
}
}
DEBUG_PRINT (TRACE_EXEC,
("DsMethodDataInitArgs: %d args passed to method\n", Pindex));
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsMethodDataGetEntry
*
* PARAMETERS: Type - Either MTH_TYPE_LOCAL or MTH_TYPE_ARG
* Index - Which localVar or argument to get
* Entry - Pointer to where a pointer to the stack
* entry is returned.
*
* RETURN: Status
*
* DESCRIPTION: Get the address of the stack entry given by Type:Index
*
******************************************************************************/
ACPI_STATUS
AcpiDsMethodDataGetEntry (
UINT32 Type,
UINT32 Index,
ACPI_WALK_STATE *WalkState,
ACPI_OPERAND_OBJECT ***Entry)
{
FUNCTION_TRACE_U32 ("DsMethodDataGetEntry", Index);
/*
* Get the requested object.
* The stack "Type" is either a LocalVariable or an Argument
*/
switch (Type)
{
case MTH_TYPE_LOCAL:
if (Index > MTH_MAX_LOCAL)
{
DEBUG_PRINT (ACPI_ERROR,
("DsMethodDataGetEntry: LocalVar index %d is invalid (max %d)\n",
Index, MTH_MAX_LOCAL));
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
*Entry =
(ACPI_OPERAND_OBJECT **) &WalkState->LocalVariables[Index].Object;
break;
case MTH_TYPE_ARG:
if (Index > MTH_MAX_ARG)
{
DEBUG_PRINT (ACPI_ERROR,
("DsMethodDataGetEntry: Argument index %d is invalid (max %d)\n",
Index, MTH_MAX_ARG));
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
*Entry =
(ACPI_OPERAND_OBJECT **) &WalkState->Arguments[Index].Object;
break;
default:
DEBUG_PRINT (ACPI_ERROR,
("DsMethodDataGetEntry: Stack type %d is invalid\n",
Type));
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsMethodDataSetEntry
*
* PARAMETERS: Type - Either MTH_TYPE_LOCAL or MTH_TYPE_ARG
* Index - Which localVar or argument to get
* Object - Object to be inserted into the stack entry
*
* RETURN: Status
*
* DESCRIPTION: Insert an object onto the method stack at entry Type:Index.
*
******************************************************************************/
ACPI_STATUS
AcpiDsMethodDataSetEntry (
UINT32 Type,
UINT32 Index,
ACPI_OPERAND_OBJECT *Object,
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status;
ACPI_OPERAND_OBJECT **Entry;
FUNCTION_TRACE ("DsMethodDataSetEntry");
/* Get a pointer to the stack entry to set */
Status = AcpiDsMethodDataGetEntry (Type, Index, WalkState, &Entry);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Increment ref count so object can't be deleted while installed */
AcpiCmAddReference (Object);
/* Install the object into the stack entry */
*Entry = Object;
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsMethodDataGetType
*
* PARAMETERS: Type - Either MTH_TYPE_LOCAL or MTH_TYPE_ARG
* Index - Which localVar or argument whose type
* to get
*
* RETURN: Data type of selected Arg or Local
* Used only in ExecMonadic2()/TypeOp.
*
******************************************************************************/
OBJECT_TYPE_INTERNAL
AcpiDsMethodDataGetType (
UINT32 Type,
UINT32 Index,
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status;
ACPI_OPERAND_OBJECT **Entry;
ACPI_OPERAND_OBJECT *Object;
FUNCTION_TRACE ("DsMethodDataGetType");
/* Get a pointer to the requested stack entry */
Status = AcpiDsMethodDataGetEntry (Type, Index, WalkState, &Entry);
if (ACPI_FAILURE (Status))
{
return_VALUE ((ACPI_TYPE_NOT_FOUND));
}
/* Get the object from the method stack */
Object = *Entry;
/* Get the object type */
if (!Object)
{
/* Any == 0 => "uninitialized" -- see spec 15.2.3.5.2.28 */
return_VALUE (ACPI_TYPE_ANY);
}
return_VALUE (Object->Common.Type);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsMethodDataGetNte
*
* PARAMETERS: Type - Either MTH_TYPE_LOCAL or MTH_TYPE_ARG
* Index - Which localVar or argument whose type
* to get
*
* RETURN: Get the Node associated with a local or arg.
*
******************************************************************************/
ACPI_NAMESPACE_NODE *
AcpiDsMethodDataGetNte (
UINT32 Type,
UINT32 Index,
ACPI_WALK_STATE *WalkState)
{
ACPI_NAMESPACE_NODE *Node = NULL;
FUNCTION_TRACE ("DsMethodDataGetNte");
switch (Type)
{
case MTH_TYPE_LOCAL:
if (Index > MTH_MAX_LOCAL)
{
DEBUG_PRINT (ACPI_ERROR,
("DsMethodDataGetEntry: LocalVar index %d is invalid (max %d)\n",
Index, MTH_MAX_LOCAL));
return_PTR (Node);
}
Node = &WalkState->LocalVariables[Index];
break;
case MTH_TYPE_ARG:
if (Index > MTH_MAX_ARG)
{
DEBUG_PRINT (ACPI_ERROR,
("DsMethodDataGetEntry: Argument index %d is invalid (max %d)\n",
Index, MTH_MAX_ARG));
return_PTR (Node);
}
Node = &WalkState->Arguments[Index];
break;
default:
DEBUG_PRINT (ACPI_ERROR,
("DsMethodDataGetEntry: Stack type %d is invalid\n",
Type));
break;
}
return_PTR (Node);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsMethodDataGetValue
*
* PARAMETERS: Type - Either MTH_TYPE_LOCAL or MTH_TYPE_ARG
* Index - Which localVar or argument to get
* *DestDesc - Descriptor into which selected Arg
* or Local value should be copied
*
* RETURN: Status
*
* DESCRIPTION: Retrieve value of selected Arg or Local from the method frame
* at the current top of the method stack.
* Used only in AcpiAmlResolveToValue().
*
******************************************************************************/
ACPI_STATUS
AcpiDsMethodDataGetValue (
UINT32 Type,
UINT32 Index,
ACPI_WALK_STATE *WalkState,
ACPI_OPERAND_OBJECT **DestDesc)
{
ACPI_STATUS Status;
ACPI_OPERAND_OBJECT **Entry;
ACPI_OPERAND_OBJECT *Object;
FUNCTION_TRACE ("DsMethodDataGetValue");
/* Validate the object descriptor */
if (!DestDesc)
{
DEBUG_PRINT (ACPI_ERROR,
("DsMethodDataGetValue: NULL object descriptor pointer\n"));
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
/* Get a pointer to the requested method stack entry */
Status = AcpiDsMethodDataGetEntry (Type, Index, WalkState, &Entry);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Get the object from the method stack */
Object = *Entry;
/* Examine the returned object, it must be valid. */
if (!Object)
{
/*
* Index points to uninitialized object stack value.
* This means that either 1) The expected argument was
* not passed to the method, or 2) A local variable
* was referenced by the method (via the ASL)
* before it was initialized. Either case is an error.
*/
switch (Type)
{
case MTH_TYPE_ARG:
DEBUG_PRINT (ACPI_ERROR,
("DsMethodDataGetValue: Uninitialized Arg[%d] at entry %X\n",
Index, Entry));
return_ACPI_STATUS (AE_AML_UNINITIALIZED_ARG);
break;
case MTH_TYPE_LOCAL:
DEBUG_PRINT (ACPI_ERROR,
("DsMethodDataGetValue: Uninitialized Local[%d] at entry %X\n",
Index, Entry));
return_ACPI_STATUS (AE_AML_UNINITIALIZED_LOCAL);
break;
}
}
/*
* Index points to initialized and valid object stack value.
* Return an additional reference to the object
*/
*DestDesc = Object;
AcpiCmAddReference (Object);
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsMethodDataDeleteValue
*
* PARAMETERS: Type - Either MTH_TYPE_LOCAL or MTH_TYPE_ARG
* Index - Which localVar or argument to delete
*
* RETURN: Status
*
* DESCRIPTION: Delete the entry at Type:Index on the method stack. Inserts
* a null into the stack slot after the object is deleted.
*
******************************************************************************/
ACPI_STATUS
AcpiDsMethodDataDeleteValue (
UINT32 Type,
UINT32 Index,
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status;
ACPI_OPERAND_OBJECT **Entry;
ACPI_OPERAND_OBJECT *Object;
FUNCTION_TRACE ("DsMethodDataDeleteValue");
/* Get a pointer to the requested entry */
Status = AcpiDsMethodDataGetEntry (Type, Index, WalkState, &Entry);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Get the current entry in this slot k */
Object = *Entry;
/*
* Undefine the Arg or Local by setting its descriptor
* pointer to NULL. Locals/Args can contain both
* ACPI_OPERAND_OBJECTS and ACPI_NAMESPACE_NODEs
*/
*Entry = NULL;
if ((Object) &&
(VALID_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_INTERNAL)))
{
/*
* There is a valid object in this slot
* Decrement the reference count by one to balance the
* increment when the object was stored in the slot.
*/
AcpiCmRemoveReference (Object);
}
return_ACPI_STATUS (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: AcpiDsMethodDataSetValue
*
* PARAMETERS: Type - Either MTH_TYPE_LOCAL or MTH_TYPE_ARG
* Index - Which localVar or argument to set
* *SrcDesc - Value to be stored
* *DestDesc - Descriptor into which *SrcDesc
* can be copied, or NULL if one must
* be allocated for the purpose. If
* provided, this descriptor will be
* used for the new value.
*
* RETURN: Status
*
* DESCRIPTION: Store a value in an Arg or Local. The SrcDesc is installed
* as the new value for the Arg or Local and the reference count
* is incremented.
*
******************************************************************************/
ACPI_STATUS
AcpiDsMethodDataSetValue (
UINT32 Type,
UINT32 Index,
ACPI_OPERAND_OBJECT *SrcDesc,
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status;
ACPI_OPERAND_OBJECT **Entry;
FUNCTION_TRACE ("DsMethodDataSetValue");
DEBUG_PRINT (TRACE_EXEC,
("DsMethodDataSetValue: Type=%d Idx=%d Obj=%p\n",
Type, Index, SrcDesc));
/* Parameter validation */
if (!SrcDesc)
{
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
/* Get a pointer to the requested method stack entry */
Status = AcpiDsMethodDataGetEntry (Type, Index, WalkState, &Entry);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
if (*Entry == SrcDesc)
{
DEBUG_PRINT (TRACE_EXEC,
("DsMethodDataSetValue: Obj=%p already installed!\n",
SrcDesc));
goto Cleanup;
}
/*
* If there is an object already in this slot, we either
* have to delete it, or if this is an argument and there
* is an object reference stored there, we have to do
* an indirect store!
*/
if (*Entry)
{
/*
* Check for an indirect store if an argument
* contains an object reference (stored as an Node).
* We don't allow this automatic dereferencing for
* locals, since a store to a local should overwrite
* anything there, including an object reference.
*
* If both Arg0 and Local0 contain RefOf (Local4):
*
* Store (1, Arg0) - Causes indirect store to local4
* Store (1, Local0) - Stores 1 in local0, overwriting
* the reference to local4
* Store (1, DeRefof (Local0)) - Causes indirect store to local4
*
* Weird, but true.
*/
if ((Type == MTH_TYPE_ARG) &&
(VALID_DESCRIPTOR_TYPE (*Entry, ACPI_DESC_TYPE_NAMED)))
{
DEBUG_PRINT (TRACE_EXEC,
("DsMethodDataSetValue: Arg (%p) is an ObjRef(Node), storing in %p\n",
SrcDesc, *Entry));
/* Detach an existing object from the Node */
AcpiNsDetachObject ((ACPI_NAMESPACE_NODE *) *Entry);
/*
* Store this object into the Node
* (do the indirect store)
*/
Status = AcpiNsAttachObject ((ACPI_NAMESPACE_NODE *) *Entry, SrcDesc,
SrcDesc->Common.Type);
return_ACPI_STATUS (Status);
}
/*
* Otherwise, just delete the existing object
* before storing the new one
*/
AcpiDsMethodDataDeleteValue (Type, Index, WalkState);
}
/*
* Install the ObjStack descriptor (*SrcDesc) into
* the descriptor for the Arg or Local.
* Install the new object in the stack entry
* (increments the object reference count by one)
*/
Status = AcpiDsMethodDataSetEntry (Type, Index, SrcDesc, WalkState);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
/* Normal exit */
return_ACPI_STATUS (AE_OK);
/* Error exit */
Cleanup:
return_ACPI_STATUS (Status);
}
Reference in New Issue Copy Permalink