sys/contrib/dev/acpica-unix-20031203/interpreter/dispatcher/dsmthdat.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: dsmthdat - control method arguments and local variables
   4  *              $Revision: 74 $
   5  *
   6  ******************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2003, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117 #define __DSMTHDAT_C__
 118
 119 #include "acpi.h"
 120 #include "acdispat.h"
 121 #include "amlcode.h"
 122 #include "acnamesp.h"
 123 #include "acinterp.h"
 124
 125
 126 #define _COMPONENT          ACPI_DISPATCHER
 127         ACPI_MODULE_NAME    ("dsmthdat")
 128
 129
 130 /*******************************************************************************
 131  *
 132  * FUNCTION:    AcpiDsMethodDataInit
 133  *
 134  * PARAMETERS:  WalkState           - Current walk state object
 135  *
 136  * RETURN:      Status
 137  *
 138  * DESCRIPTION: Initialize the data structures that hold the method's arguments
 139  *              and locals.  The data struct is an array of NTEs for each.
 140  *              This allows RefOf and DeRefOf to work properly for these
 141  *              special data types.
 142  *
 143  * NOTES:       WalkState fields are initialized to zero by the
 144  *              ACPI_MEM_CALLOCATE().
 145  *
 146  *              A pseudo-Namespace Node is assigned to each argument and local
 147  *              so that RefOf() can return a pointer to the Node.
 148  *
 149  ******************************************************************************/
 150
 151 void
 152 AcpiDsMethodDataInit (
 153     ACPI_WALK_STATE         *WalkState)
 154 {
 155     UINT32                  i;
 156
 157
 158     ACPI_FUNCTION_TRACE ("DsMethodDataInit");
 159
 160
 161     /* Init the method arguments */
 162
 163     for (i = 0; i < ACPI_METHOD_NUM_ARGS; i++)
 164     {
 165         ACPI_MOVE_32_TO_32 (&WalkState->Arguments[i].Name,
 166                             NAMEOF_ARG_NTE);
 167         WalkState->Arguments[i].Name.Integer |= (i << 24);
 168         WalkState->Arguments[i].Descriptor    = ACPI_DESC_TYPE_NAMED;
 169         WalkState->Arguments[i].Type          = ACPI_TYPE_ANY;
 170         WalkState->Arguments[i].Flags         = ANOBJ_END_OF_PEER_LIST | ANOBJ_METHOD_ARG;
 171     }
 172
 173     /* Init the method locals */
 174
 175     for (i = 0; i < ACPI_METHOD_NUM_LOCALS; i++)
 176     {
 177         ACPI_MOVE_32_TO_32 (&WalkState->LocalVariables[i].Name,
 178                             NAMEOF_LOCAL_NTE);
 179
 180         WalkState->LocalVariables[i].Name.Integer |= (i << 24);
 181         WalkState->LocalVariables[i].Descriptor    = ACPI_DESC_TYPE_NAMED;
 182         WalkState->LocalVariables[i].Type          = ACPI_TYPE_ANY;
 183         WalkState->LocalVariables[i].Flags         = ANOBJ_END_OF_PEER_LIST | ANOBJ_METHOD_LOCAL;
 184     }
 185
 186     return_VOID;
 187 }
 188
 189
 190 /*******************************************************************************
 191  *
 192  * FUNCTION:    AcpiDsMethodDataDeleteAll
 193  *
 194  * PARAMETERS:  WalkState           - Current walk state object
 195  *
 196  * RETURN:      None
 197  *
 198  * DESCRIPTION: Delete method locals and arguments.  Arguments are only
 199  *              deleted if this method was called from another method.
 200  *
 201  ******************************************************************************/
 202
 203 void
 204 AcpiDsMethodDataDeleteAll (
 205     ACPI_WALK_STATE         *WalkState)
 206 {
 207     UINT32                  Index;
 208
 209
 210     ACPI_FUNCTION_TRACE ("DsMethodDataDeleteAll");
 211
 212
 213     /* Detach the locals */
 214
 215     for (Index = 0; Index < ACPI_METHOD_NUM_LOCALS; Index++)
 216     {
 217         if (WalkState->LocalVariables[Index].Object)
 218         {
 219             ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Deleting Local%d=%p\n",
 220                     Index, WalkState->LocalVariables[Index].Object));
 221
 222             /* Detach object (if present) and remove a reference */
 223
 224             AcpiNsDetachObject (&WalkState->LocalVariables[Index]);
 225         }
 226     }
 227
 228     /* Detach the arguments */
 229
 230     for (Index = 0; Index < ACPI_METHOD_NUM_ARGS; Index++)
 231     {
 232         if (WalkState->Arguments[Index].Object)
 233         {
 234             ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Deleting Arg%d=%p\n",
 235                     Index, WalkState->Arguments[Index].Object));
 236
 237             /* Detach object (if present) and remove a reference */
 238
 239             AcpiNsDetachObject (&WalkState->Arguments[Index]);
 240         }
 241     }
 242
 243     return_VOID;
 244 }
 245
 246
 247 /*******************************************************************************
 248  *
 249  * FUNCTION:    AcpiDsMethodDataInitArgs
 250  *
 251  * PARAMETERS:  *Params         - Pointer to a parameter list for the method
 252  *              MaxParamCount   - The arg count for this method
 253  *              WalkState       - Current walk state object
 254  *
 255  * RETURN:      Status
 256  *
 257  * DESCRIPTION: Initialize arguments for a method.  The parameter list is a list
 258  *              of ACPI operand objects, either null terminated or whose length
 259  *              is defined by MaxParamCount.
 260  *
 261  ******************************************************************************/
 262
 263 ACPI_STATUS
 264 AcpiDsMethodDataInitArgs (
 265     ACPI_OPERAND_OBJECT     **Params,
 266     UINT32                  MaxParamCount,
 267     ACPI_WALK_STATE         *WalkState)
 268 {
 269     ACPI_STATUS             Status;
 270     UINT32                  Index = 0;
 271
 272
 273     ACPI_FUNCTION_TRACE_PTR ("DsMethodDataInitArgs", Params);
 274
 275
 276     if (!Params)
 277     {
 278         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "No param list passed to method\n"));
 279         return_ACPI_STATUS (AE_OK);
 280     }
 281
 282     /* Copy passed parameters into the new method stack frame  */
 283
 284     while ((Index < ACPI_METHOD_NUM_ARGS) && (Index < MaxParamCount) && Params[Index])
 285     {
 286         /*
 287          * A valid parameter.
 288          * Store the argument in the method/walk descriptor
 289          */
 290         Status = AcpiDsStoreObjectToLocal (AML_ARG_OP, Index, Params[Index],
 291                                             WalkState);
 292         if (ACPI_FAILURE (Status))
 293         {
 294             return_ACPI_STATUS (Status);
 295         }
 296
 297         Index++;
 298     }
 299
 300     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%d args passed to method\n", Index));
 301     return_ACPI_STATUS (AE_OK);
 302 }
 303
 304
 305 /*******************************************************************************
 306  *
 307  * FUNCTION:    AcpiDsMethodDataGetNode
 308  *
 309  * PARAMETERS:  Opcode              - Either AML_LOCAL_OP or AML_ARG_OP
 310  *              Index               - Which localVar or argument whose type
 311  *                                      to get
 312  *              WalkState           - Current walk state object
 313  *
 314  * RETURN:      Get the Node associated with a local or arg.
 315  *
 316  ******************************************************************************/
 317
 318 ACPI_STATUS
 319 AcpiDsMethodDataGetNode (
 320     UINT16                  Opcode,
 321     UINT32                  Index,
 322     ACPI_WALK_STATE         *WalkState,
 323     ACPI_NAMESPACE_NODE     **Node)
 324 {
 325     ACPI_FUNCTION_TRACE ("DsMethodDataGetNode");
 326
 327
 328     /*
 329      * Method Locals and Arguments are supported
 330      */
 331     switch (Opcode)
 332     {
 333     case AML_LOCAL_OP:
 334
 335         if (Index > ACPI_METHOD_MAX_LOCAL)
 336         {
 337             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Local index %d is invalid (max %d)\n",
 338                 Index, ACPI_METHOD_MAX_LOCAL));
 339             return_ACPI_STATUS (AE_AML_INVALID_INDEX);
 340         }
 341
 342         /* Return a pointer to the pseudo-node */
 343
 344         *Node = &WalkState->LocalVariables[Index];
 345         break;
 346
 347     case AML_ARG_OP:
 348
 349         if (Index > ACPI_METHOD_MAX_ARG)
 350         {
 351             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Arg index %d is invalid (max %d)\n",
 352                 Index, ACPI_METHOD_MAX_ARG));
 353             return_ACPI_STATUS (AE_AML_INVALID_INDEX);
 354         }
 355
 356         /* Return a pointer to the pseudo-node */
 357
 358         *Node = &WalkState->Arguments[Index];
 359         break;
 360
 361     default:
 362         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Opcode %d is invalid\n", Opcode));
 363         return_ACPI_STATUS (AE_AML_BAD_OPCODE);
 364     }
 365
 366     return_ACPI_STATUS (AE_OK);
 367 }
 368
 369
 370 /*******************************************************************************
 371  *
 372  * FUNCTION:    AcpiDsMethodDataSetValue
 373  *
 374  * PARAMETERS:  Opcode              - Either AML_LOCAL_OP or AML_ARG_OP
 375  *              Index               - Which localVar or argument to get
 376  *              Object              - Object to be inserted into the stack entry
 377  *              WalkState           - Current walk state object
 378  *
 379  * RETURN:      Status
 380  *
 381  * DESCRIPTION: Insert an object onto the method stack at entry Opcode:Index.
 382  *              Note: There is no "implicit conversion" for locals.
 383  *
 384  ******************************************************************************/
 385
 386 ACPI_STATUS
 387 AcpiDsMethodDataSetValue (
 388     UINT16                  Opcode,
 389     UINT32                  Index,
 390     ACPI_OPERAND_OBJECT     *Object,
 391     ACPI_WALK_STATE         *WalkState)
 392 {
 393     ACPI_STATUS             Status;
 394     ACPI_NAMESPACE_NODE     *Node;
 395
 396
 397     ACPI_FUNCTION_TRACE ("DsMethodDataSetValue");
 398
 399
 400     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 401         "obj %p op %X, ref count = %d [%s]\n", Object,
 402         Opcode, Object->Common.ReferenceCount,
 403         AcpiUtGetTypeName (Object->Common.Type)));
 404
 405     /* Get the namespace node for the arg/local */
 406
 407     Status = AcpiDsMethodDataGetNode (Opcode, Index, WalkState, &Node);
 408     if (ACPI_FAILURE (Status))
 409     {
 410         return_ACPI_STATUS (Status);
 411     }
 412
 413     /*
 414      * Increment ref count so object can't be deleted while installed.
 415      * NOTE: We do not copy the object in order to preserve the call by
 416      * reference semantics of ACPI Control Method invocation.
 417      * (See ACPI Specification 2.0C)
 418      */
 419     AcpiUtAddReference (Object);
 420
 421     /* Install the object */
 422
 423     Node->Object = Object;
 424     return_ACPI_STATUS (Status);
 425 }
 426
 427
 428 /*******************************************************************************
 429  *
 430  * FUNCTION:    AcpiDsMethodDataGetType
 431  *
 432  * PARAMETERS:  Opcode              - Either AML_LOCAL_OP or AML_ARG_OP
 433  *              Index               - Which localVar or argument whose type
 434  *                                      to get
 435  *              WalkState           - Current walk state object
 436  *
 437  * RETURN:      Data type of current value of the selected Arg or Local
 438  *
 439  ******************************************************************************/
 440
 441 ACPI_OBJECT_TYPE
 442 AcpiDsMethodDataGetType (
 443     UINT16                  Opcode,
 444     UINT32                  Index,
 445     ACPI_WALK_STATE         *WalkState)
 446 {
 447     ACPI_STATUS             Status;
 448     ACPI_NAMESPACE_NODE     *Node;
 449     ACPI_OPERAND_OBJECT     *Object;
 450
 451
 452     ACPI_FUNCTION_TRACE ("DsMethodDataGetType");
 453
 454
 455     /* Get the namespace node for the arg/local */
 456
 457     Status = AcpiDsMethodDataGetNode (Opcode, Index, WalkState, &Node);
 458     if (ACPI_FAILURE (Status))
 459     {
 460         return_VALUE ((ACPI_TYPE_NOT_FOUND));
 461     }
 462
 463     /* Get the object */
 464
 465     Object = AcpiNsGetAttachedObject (Node);
 466     if (!Object)
 467     {
 468         /* Uninitialized local/arg, return TYPE_ANY */
 469
 470         return_VALUE (ACPI_TYPE_ANY);
 471     }
 472
 473     /* Get the object type */
 474
 475     return_VALUE (ACPI_GET_OBJECT_TYPE (Object));
 476 }
 477
 478
 479 /*******************************************************************************
 480  *
 481  * FUNCTION:    AcpiDsMethodDataGetValue
 482  *
 483  * PARAMETERS:  Opcode              - Either AML_LOCAL_OP or AML_ARG_OP
 484  *              Index               - Which localVar or argument to get
 485  *              WalkState           - Current walk state object
 486  *              *DestDesc           - Ptr to Descriptor into which selected Arg
 487  *                                    or Local value should be copied
 488  *
 489  * RETURN:      Status
 490  *
 491  * DESCRIPTION: Retrieve value of selected Arg or Local from the method frame
 492  *              at the current top of the method stack.
 493  *              Used only in AcpiExResolveToValue().
 494  *
 495  ******************************************************************************/
 496
 497 ACPI_STATUS
 498 AcpiDsMethodDataGetValue (
 499     UINT16                  Opcode,
 500     UINT32                  Index,
 501     ACPI_WALK_STATE         *WalkState,
 502     ACPI_OPERAND_OBJECT     **DestDesc)
 503 {
 504     ACPI_STATUS             Status;
 505     ACPI_NAMESPACE_NODE     *Node;
 506     ACPI_OPERAND_OBJECT     *Object;
 507
 508
 509     ACPI_FUNCTION_TRACE ("DsMethodDataGetValue");
 510
 511
 512     /* Validate the object descriptor */
 513
 514     if (!DestDesc)
 515     {
 516         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null object descriptor pointer\n"));
 517         return_ACPI_STATUS (AE_BAD_PARAMETER);
 518     }
 519
 520     /* Get the namespace node for the arg/local */
 521
 522     Status = AcpiDsMethodDataGetNode (Opcode, Index, WalkState, &Node);
 523     if (ACPI_FAILURE (Status))
 524     {
 525         return_ACPI_STATUS (Status);
 526     }
 527
 528     /* Get the object from the node */
 529
 530     Object = Node->Object;
 531
 532     /* Examine the returned object, it must be valid. */
 533
 534     if (!Object)
 535     {
 536         /*
 537          * Index points to uninitialized object.
 538          * This means that either 1) The expected argument was
 539          * not passed to the method, or 2) A local variable
 540          * was referenced by the method (via the ASL)
 541          * before it was initialized.  Either case is an error.
 542          */
 543         switch (Opcode)
 544         {
 545         case AML_ARG_OP:
 546
 547             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Uninitialized Arg[%d] at node %p\n",
 548                 Index, Node));
 549
 550             return_ACPI_STATUS (AE_AML_UNINITIALIZED_ARG);
 551
 552         case AML_LOCAL_OP:
 553
 554             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Uninitialized Local[%d] at node %p\n",
 555                 Index, Node));
 556
 557             return_ACPI_STATUS (AE_AML_UNINITIALIZED_LOCAL);
 558
 559         default:
 560             return_ACPI_STATUS (AE_AML_INTERNAL);
 561         }
 562     }
 563
 564     /*
 565      * The Index points to an initialized and valid object.
 566      * Return an additional reference to the object
 567      */
 568     *DestDesc = Object;
 569     AcpiUtAddReference (Object);
 570
 571     return_ACPI_STATUS (AE_OK);
 572 }
 573
 574
 575 /*******************************************************************************
 576  *
 577  * FUNCTION:    AcpiDsMethodDataDeleteValue
 578  *
 579  * PARAMETERS:  Opcode              - Either AML_LOCAL_OP or AML_ARG_OP
 580  *              Index               - Which localVar or argument to delete
 581  *              WalkState           - Current walk state object
 582  *
 583  * RETURN:      None
 584  *
 585  * DESCRIPTION: Delete the entry at Opcode:Index on the method stack.  Inserts
 586  *              a null into the stack slot after the object is deleted.
 587  *
 588  ******************************************************************************/
 589
 590 void
 591 AcpiDsMethodDataDeleteValue (
 592     UINT16                  Opcode,
 593     UINT32                  Index,
 594     ACPI_WALK_STATE         *WalkState)
 595 {
 596     ACPI_STATUS             Status;
 597     ACPI_NAMESPACE_NODE     *Node;
 598     ACPI_OPERAND_OBJECT     *Object;
 599
 600
 601     ACPI_FUNCTION_TRACE ("DsMethodDataDeleteValue");
 602
 603
 604     /* Get the namespace node for the arg/local */
 605
 606     Status = AcpiDsMethodDataGetNode (Opcode, Index, WalkState, &Node);
 607     if (ACPI_FAILURE (Status))
 608     {
 609         return_VOID;
 610     }
 611
 612     /* Get the associated object */
 613
 614     Object = AcpiNsGetAttachedObject (Node);
 615
 616     /*
 617      * Undefine the Arg or Local by setting its descriptor
 618      * pointer to NULL. Locals/Args can contain both
 619      * ACPI_OPERAND_OBJECTS and ACPI_NAMESPACE_NODEs
 620      */
 621     Node->Object = NULL;
 622
 623     if ((Object) &&
 624         (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_OPERAND))
 625     {
 626         /*
 627          * There is a valid object.
 628          * Decrement the reference count by one to balance the
 629          * increment when the object was stored.
 630          */
 631         AcpiUtRemoveReference (Object);
 632     }
 633
 634     return_VOID;
 635 }
 636
 637
 638 /*******************************************************************************
 639  *
 640  * FUNCTION:    AcpiDsStoreObjectToLocal
 641  *
 642  * PARAMETERS:  Opcode              - Either AML_LOCAL_OP or AML_ARG_OP
 643  *              Index               - Which localVar or argument to set
 644  *              ObjDesc             - Value to be stored
 645  *              WalkState           - Current walk state
 646  *
 647  * RETURN:      Status
 648  *
 649  * DESCRIPTION: Store a value in an Arg or Local.  The ObjDesc is installed
 650  *              as the new value for the Arg or Local and the reference count
 651  *              for ObjDesc is incremented.
 652  *
 653  ******************************************************************************/
 654
 655 ACPI_STATUS
 656 AcpiDsStoreObjectToLocal (
 657     UINT16                  Opcode,
 658     UINT32                  Index,
 659     ACPI_OPERAND_OBJECT     *ObjDesc,
 660     ACPI_WALK_STATE         *WalkState)
 661 {
 662     ACPI_STATUS             Status;
 663     ACPI_NAMESPACE_NODE     *Node;
 664     ACPI_OPERAND_OBJECT     *CurrentObjDesc;
 665     ACPI_OPERAND_OBJECT     *NewObjDesc;
 666
 667
 668     ACPI_FUNCTION_TRACE ("DsStoreObjectToLocal");
 669     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Opcode=%d Idx=%d Obj=%p\n",
 670         Opcode, Index, ObjDesc));
 671
 672     /* Parameter validation */
 673
 674     if (!ObjDesc)
 675     {
 676         return_ACPI_STATUS (AE_BAD_PARAMETER);
 677     }
 678
 679     /* Get the namespace node for the arg/local */
 680
 681     Status = AcpiDsMethodDataGetNode (Opcode, Index, WalkState, &Node);
 682     if (ACPI_FAILURE (Status))
 683     {
 684         return_ACPI_STATUS (Status);
 685     }
 686
 687     CurrentObjDesc = AcpiNsGetAttachedObject (Node);
 688     if (CurrentObjDesc == ObjDesc)
 689     {
 690         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p already installed!\n",
 691             ObjDesc));
 692         return_ACPI_STATUS (Status);
 693     }
 694
 695     /*
 696      * If the reference count on the object is more than one, we must
 697      * take a copy of the object before we store.
 698      */
 699     NewObjDesc = ObjDesc;
 700     if (ObjDesc->Common.ReferenceCount > 1)
 701     {
 702         Status = AcpiUtCopyIobjectToIobject (ObjDesc, &NewObjDesc, WalkState);
 703         NewObjDesc;
 704         if (ACPI_FAILURE (Status))
 705         {
 706             return_ACPI_STATUS (Status);
 707         }
 708     }
 709
 710     /*
 711      * If there is an object already in this slot, we either
 712      * have to delete it, or if this is an argument and there
 713      * is an object reference stored there, we have to do
 714      * an indirect store!
 715      */
 716     if (CurrentObjDesc)
 717     {
 718         /*
 719          * Check for an indirect store if an argument
 720          * contains an object reference (stored as an Node).
 721          * We don't allow this automatic dereferencing for
 722          * locals, since a store to a local should overwrite
 723          * anything there, including an object reference.
 724          *
 725          * If both Arg0 and Local0 contain RefOf (Local4):
 726          *
 727          * Store (1, Arg0)             - Causes indirect store to local4
 728          * Store (1, Local0)           - Stores 1 in local0, overwriting
 729          *                                  the reference to local4
 730          * Store (1, DeRefof (Local0)) - Causes indirect store to local4
 731          *
 732          * Weird, but true.
 733          */
 734         if (Opcode == AML_ARG_OP)
 735         {
 736             /*
 737              * Make sure that the object is the correct type.  This may be overkill, but
 738              * it is here because references were NS nodes in the past.  Now they are
 739              * operand objects of type Reference.
 740              */
 741             if (ACPI_GET_DESCRIPTOR_TYPE (CurrentObjDesc) != ACPI_DESC_TYPE_OPERAND)
 742             {
 743                 ACPI_REPORT_ERROR (("Invalid descriptor type while storing to method arg: [%s]\n",
 744                         AcpiUtGetDescriptorName (CurrentObjDesc)));
 745                 return_ACPI_STATUS (AE_AML_INTERNAL);
 746             }
 747
 748             /*
 749              * If we have a valid reference object that came from RefOf(), do the
 750              * indirect store
 751              */
 752             if ((CurrentObjDesc->Common.Type == ACPI_TYPE_LOCAL_REFERENCE) &&
 753                 (CurrentObjDesc->Reference.Opcode == AML_REF_OF_OP))
 754             {
 755                 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 756                         "Arg (%p) is an ObjRef(Node), storing in node %p\n",
 757                         NewObjDesc, CurrentObjDesc));
 758
 759                 /*
 760                  * Store this object to the Node
 761                  * (perform the indirect store)
 762                  */
 763                 Status = AcpiExStoreObjectToNode (NewObjDesc,
 764                             CurrentObjDesc->Reference.Object, WalkState);
 765
 766                 /* Remove local reference if we copied the object above */
 767
 768                 if (NewObjDesc != ObjDesc)
 769                 {
 770                     AcpiUtRemoveReference (NewObjDesc);
 771                 }
 772                 return_ACPI_STATUS (Status);
 773             }
 774         }
 775
 776         /*
 777          * Delete the existing object
 778          * before storing the new one
 779          */
 780         AcpiDsMethodDataDeleteValue (Opcode, Index, WalkState);
 781     }
 782
 783     /*
 784      * Install the Obj descriptor (*NewObjDesc) into
 785      * the descriptor for the Arg or Local.
 786      * (increments the object reference count by one)
 787      */
 788     Status = AcpiDsMethodDataSetValue (Opcode, Index, NewObjDesc, WalkState);
 789
 790     /* Remove local reference if we copied the object above */
 791
 792     if (NewObjDesc != ObjDesc)
 793     {
 794         AcpiUtRemoveReference (NewObjDesc);
 795     }
 796
 797     return_ACPI_STATUS (Status);
 798 }
 799
 800