sys/contrib/dev/acpica/dispatcher/dsmthdat.c

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