path: root/sys/contrib/dev/acpica/Subsystem/Dispatcher/dsmthdat.c

/*******************************************************************************
 *
 * Module Name: dsmthdat - control method arguments and local variables
 *              $Revision: 39 $
 *
 ******************************************************************************/

/******************************************************************************
 *
 * 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 __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:  WalkState           - Current walk state object
 *
 * 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        = ACPI_TYPE_ANY;
        WalkState->Arguments[i].Flags       = ANOBJ_END_OF_PEER_LIST | ANOBJ_METHOD_ARG;
    }

    /* 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     = ACPI_TYPE_ANY;
        WalkState->LocalVariables[i].Flags    = ANOBJ_END_OF_PEER_LIST | ANOBJ_METHOD_LOCAL;
    }

    return_ACPI_STATUS (AE_OK);
}


/*******************************************************************************
 *
 * FUNCTION:    AcpiDsMethodDataDeleteAll
 *
 * PARAMETERS:  WalkState           - Current walk state object
 *
 * 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:  *Params         - Pointer to a parameter list for the method
 *              MaxParamCount   - The arg count for this method
 *              WalkState       - Current walk state object
 *
 * 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.
 *              WalkState           - Current walk state object
 *
 * 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
 *              WalkState           - Current walk state object
 *
 * 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
 *              WalkState           - Current walk state object
 *
 * 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
 *              WalkState           - Current walk state object
 *
 * 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
 *              WalkState           - Current walk state object
 *              *DestDesc           - Ptr to 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 %p\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 %p\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
 *              WalkState           - Current walk state object
 *
 * 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
 *              WalkState           - Current walk state
 *
 * 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
 *              for SrcDesc 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);
        }


        /*
         * Perform "Implicit conversion" of the new object to the type of the
         * existing object
         */
        Status = AcpiAmlConvertToTargetType ((*Entry)->Common.Type, &SrcDesc, WalkState);
        if (ACPI_FAILURE (Status))
        {
            goto Cleanup;
        }

        /*
         * 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);
}