1 /******************************************************************************* 2 * 3 * Module Name: dsmthdat - control method arguments and local variables 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include "acpi.h" 45 #include "accommon.h" 46 #include "acdispat.h" 47 #include "acnamesp.h" 48 #include "acinterp.h" 49 50 51 #define _COMPONENT ACPI_DISPATCHER 52 ACPI_MODULE_NAME ("dsmthdat") 53 54 /* Local prototypes */ 55 56 static void 57 AcpiDsMethodDataDeleteValue ( 58 UINT8 Type, 59 UINT32 Index, 60 ACPI_WALK_STATE *WalkState); 61 62 static ACPI_STATUS 63 AcpiDsMethodDataSetValue ( 64 UINT8 Type, 65 UINT32 Index, 66 ACPI_OPERAND_OBJECT *Object, 67 ACPI_WALK_STATE *WalkState); 68 69 #ifdef ACPI_OBSOLETE_FUNCTIONS 70 ACPI_OBJECT_TYPE 71 AcpiDsMethodDataGetType ( 72 UINT16 Opcode, 73 UINT32 Index, 74 ACPI_WALK_STATE *WalkState); 75 #endif 76 77 78 /******************************************************************************* 79 * 80 * FUNCTION: AcpiDsMethodDataInit 81 * 82 * PARAMETERS: WalkState - Current walk state object 83 * 84 * RETURN: Status 85 * 86 * DESCRIPTION: Initialize the data structures that hold the method's arguments 87 * and locals. The data struct is an array of namespace nodes for 88 * each - this allows RefOf and DeRefOf to work properly for these 89 * special data types. 90 * 91 * NOTES: WalkState fields are initialized to zero by the 92 * ACPI_ALLOCATE_ZEROED(). 93 * 94 * A pseudo-Namespace Node is assigned to each argument and local 95 * so that RefOf() can return a pointer to the Node. 96 * 97 ******************************************************************************/ 98 99 void 100 AcpiDsMethodDataInit ( 101 ACPI_WALK_STATE *WalkState) 102 { 103 UINT32 i; 104 105 106 ACPI_FUNCTION_TRACE (DsMethodDataInit); 107 108 109 /* Init the method arguments */ 110 111 for (i = 0; i < ACPI_METHOD_NUM_ARGS; i++) 112 { 113 ACPI_MOVE_32_TO_32 (&WalkState->Arguments[i].Name, 114 NAMEOF_ARG_NTE); 115 116 WalkState->Arguments[i].Name.Integer |= (i << 24); 117 WalkState->Arguments[i].DescriptorType = ACPI_DESC_TYPE_NAMED; 118 WalkState->Arguments[i].Type = ACPI_TYPE_ANY; 119 WalkState->Arguments[i].Flags = ANOBJ_METHOD_ARG; 120 } 121 122 /* Init the method locals */ 123 124 for (i = 0; i < ACPI_METHOD_NUM_LOCALS; i++) 125 { 126 ACPI_MOVE_32_TO_32 (&WalkState->LocalVariables[i].Name, 127 NAMEOF_LOCAL_NTE); 128 129 WalkState->LocalVariables[i].Name.Integer |= (i << 24); 130 WalkState->LocalVariables[i].DescriptorType = ACPI_DESC_TYPE_NAMED; 131 WalkState->LocalVariables[i].Type = ACPI_TYPE_ANY; 132 WalkState->LocalVariables[i].Flags = ANOBJ_METHOD_LOCAL; 133 } 134 135 return_VOID; 136 } 137 138 139 /******************************************************************************* 140 * 141 * FUNCTION: AcpiDsMethodDataDeleteAll 142 * 143 * PARAMETERS: WalkState - Current walk state object 144 * 145 * RETURN: None 146 * 147 * DESCRIPTION: Delete method locals and arguments. Arguments are only 148 * deleted if this method was called from another method. 149 * 150 ******************************************************************************/ 151 152 void 153 AcpiDsMethodDataDeleteAll ( 154 ACPI_WALK_STATE *WalkState) 155 { 156 UINT32 Index; 157 158 159 ACPI_FUNCTION_TRACE (DsMethodDataDeleteAll); 160 161 162 /* Detach the locals */ 163 164 for (Index = 0; Index < ACPI_METHOD_NUM_LOCALS; Index++) 165 { 166 if (WalkState->LocalVariables[Index].Object) 167 { 168 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Deleting Local%u=%p\n", 169 Index, WalkState->LocalVariables[Index].Object)); 170 171 /* Detach object (if present) and remove a reference */ 172 173 AcpiNsDetachObject (&WalkState->LocalVariables[Index]); 174 } 175 } 176 177 /* Detach the arguments */ 178 179 for (Index = 0; Index < ACPI_METHOD_NUM_ARGS; Index++) 180 { 181 if (WalkState->Arguments[Index].Object) 182 { 183 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Deleting Arg%u=%p\n", 184 Index, WalkState->Arguments[Index].Object)); 185 186 /* Detach object (if present) and remove a reference */ 187 188 AcpiNsDetachObject (&WalkState->Arguments[Index]); 189 } 190 } 191 192 return_VOID; 193 } 194 195 196 /******************************************************************************* 197 * 198 * FUNCTION: AcpiDsMethodDataInitArgs 199 * 200 * PARAMETERS: *Params - Pointer to a parameter list for the method 201 * MaxParamCount - The arg count for this method 202 * WalkState - Current walk state object 203 * 204 * RETURN: Status 205 * 206 * DESCRIPTION: Initialize arguments for a method. The parameter list is a list 207 * of ACPI operand objects, either null terminated or whose length 208 * is defined by MaxParamCount. 209 * 210 ******************************************************************************/ 211 212 ACPI_STATUS 213 AcpiDsMethodDataInitArgs ( 214 ACPI_OPERAND_OBJECT **Params, 215 UINT32 MaxParamCount, 216 ACPI_WALK_STATE *WalkState) 217 { 218 ACPI_STATUS Status; 219 UINT32 Index = 0; 220 221 222 ACPI_FUNCTION_TRACE_PTR (DsMethodDataInitArgs, Params); 223 224 225 if (!Params) 226 { 227 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 228 "No parameter list passed to method\n")); 229 return_ACPI_STATUS (AE_OK); 230 } 231 232 /* Copy passed parameters into the new method stack frame */ 233 234 while ((Index < ACPI_METHOD_NUM_ARGS) && 235 (Index < MaxParamCount) && 236 Params[Index]) 237 { 238 /* 239 * A valid parameter. 240 * Store the argument in the method/walk descriptor. 241 * Do not copy the arg in order to implement call by reference 242 */ 243 Status = AcpiDsMethodDataSetValue ( 244 ACPI_REFCLASS_ARG, Index, Params[Index], WalkState); 245 if (ACPI_FAILURE (Status)) 246 { 247 return_ACPI_STATUS (Status); 248 } 249 250 Index++; 251 } 252 253 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%u args passed to method\n", Index)); 254 return_ACPI_STATUS (AE_OK); 255 } 256 257 258 /******************************************************************************* 259 * 260 * FUNCTION: AcpiDsMethodDataGetNode 261 * 262 * PARAMETERS: Type - Either ACPI_REFCLASS_LOCAL or 263 * ACPI_REFCLASS_ARG 264 * Index - Which Local or Arg whose type to get 265 * WalkState - Current walk state object 266 * Node - Where the node is returned. 267 * 268 * RETURN: Status and node 269 * 270 * DESCRIPTION: Get the Node associated with a local or arg. 271 * 272 ******************************************************************************/ 273 274 ACPI_STATUS 275 AcpiDsMethodDataGetNode ( 276 UINT8 Type, 277 UINT32 Index, 278 ACPI_WALK_STATE *WalkState, 279 ACPI_NAMESPACE_NODE **Node) 280 { 281 ACPI_FUNCTION_TRACE (DsMethodDataGetNode); 282 283 284 /* 285 * Method Locals and Arguments are supported 286 */ 287 switch (Type) 288 { 289 case ACPI_REFCLASS_LOCAL: 290 291 if (Index > ACPI_METHOD_MAX_LOCAL) 292 { 293 ACPI_ERROR ((AE_INFO, 294 "Local index %u is invalid (max %u)", 295 Index, ACPI_METHOD_MAX_LOCAL)); 296 return_ACPI_STATUS (AE_AML_INVALID_INDEX); 297 } 298 299 /* Return a pointer to the pseudo-node */ 300 301 *Node = &WalkState->LocalVariables[Index]; 302 break; 303 304 case ACPI_REFCLASS_ARG: 305 306 if (Index > ACPI_METHOD_MAX_ARG) 307 { 308 ACPI_ERROR ((AE_INFO, 309 "Arg index %u is invalid (max %u)", 310 Index, ACPI_METHOD_MAX_ARG)); 311 return_ACPI_STATUS (AE_AML_INVALID_INDEX); 312 } 313 314 /* Return a pointer to the pseudo-node */ 315 316 *Node = &WalkState->Arguments[Index]; 317 break; 318 319 default: 320 321 ACPI_ERROR ((AE_INFO, "Type %u is invalid", Type)); 322 return_ACPI_STATUS (AE_TYPE); 323 } 324 325 return_ACPI_STATUS (AE_OK); 326 } 327 328 329 /******************************************************************************* 330 * 331 * FUNCTION: AcpiDsMethodDataSetValue 332 * 333 * PARAMETERS: Type - Either ACPI_REFCLASS_LOCAL or 334 * ACPI_REFCLASS_ARG 335 * Index - Which Local or Arg to get 336 * Object - Object to be inserted into the stack entry 337 * WalkState - Current walk state object 338 * 339 * RETURN: Status 340 * 341 * DESCRIPTION: Insert an object onto the method stack at entry Opcode:Index. 342 * Note: There is no "implicit conversion" for locals. 343 * 344 ******************************************************************************/ 345 346 static ACPI_STATUS 347 AcpiDsMethodDataSetValue ( 348 UINT8 Type, 349 UINT32 Index, 350 ACPI_OPERAND_OBJECT *Object, 351 ACPI_WALK_STATE *WalkState) 352 { 353 ACPI_STATUS Status; 354 ACPI_NAMESPACE_NODE *Node; 355 356 357 ACPI_FUNCTION_TRACE (DsMethodDataSetValue); 358 359 360 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 361 "NewObj %p Type %2.2X, Refs=%u [%s]\n", Object, 362 Type, Object->Common.ReferenceCount, 363 AcpiUtGetTypeName (Object->Common.Type))); 364 365 /* Get the namespace node for the arg/local */ 366 367 Status = AcpiDsMethodDataGetNode (Type, Index, WalkState, &Node); 368 if (ACPI_FAILURE (Status)) 369 { 370 return_ACPI_STATUS (Status); 371 } 372 373 /* 374 * Increment ref count so object can't be deleted while installed. 375 * NOTE: We do not copy the object in order to preserve the call by 376 * reference semantics of ACPI Control Method invocation. 377 * (See ACPI Specification 2.0C) 378 */ 379 AcpiUtAddReference (Object); 380 381 /* Install the object */ 382 383 Node->Object = Object; 384 return_ACPI_STATUS (Status); 385 } 386 387 388 /******************************************************************************* 389 * 390 * FUNCTION: AcpiDsMethodDataGetValue 391 * 392 * PARAMETERS: Type - Either ACPI_REFCLASS_LOCAL or 393 * ACPI_REFCLASS_ARG 394 * Index - Which localVar or argument to get 395 * WalkState - Current walk state object 396 * DestDesc - Where Arg or Local value is returned 397 * 398 * RETURN: Status 399 * 400 * DESCRIPTION: Retrieve value of selected Arg or Local for this method 401 * Used only in AcpiExResolveToValue(). 402 * 403 ******************************************************************************/ 404 405 ACPI_STATUS 406 AcpiDsMethodDataGetValue ( 407 UINT8 Type, 408 UINT32 Index, 409 ACPI_WALK_STATE *WalkState, 410 ACPI_OPERAND_OBJECT **DestDesc) 411 { 412 ACPI_STATUS Status; 413 ACPI_NAMESPACE_NODE *Node; 414 ACPI_OPERAND_OBJECT *Object; 415 416 417 ACPI_FUNCTION_TRACE (DsMethodDataGetValue); 418 419 420 /* Validate the object descriptor */ 421 422 if (!DestDesc) 423 { 424 ACPI_ERROR ((AE_INFO, "Null object descriptor pointer")); 425 return_ACPI_STATUS (AE_BAD_PARAMETER); 426 } 427 428 /* Get the namespace node for the arg/local */ 429 430 Status = AcpiDsMethodDataGetNode (Type, Index, WalkState, &Node); 431 if (ACPI_FAILURE (Status)) 432 { 433 return_ACPI_STATUS (Status); 434 } 435 436 /* Get the object from the node */ 437 438 Object = Node->Object; 439 440 /* Examine the returned object, it must be valid. */ 441 442 if (!Object) 443 { 444 /* 445 * Index points to uninitialized object. 446 * This means that either 1) The expected argument was 447 * not passed to the method, or 2) A local variable 448 * was referenced by the method (via the ASL) 449 * before it was initialized. Either case is an error. 450 */ 451 452 /* If slack enabled, init the LocalX/ArgX to an Integer of value zero */ 453 454 if (AcpiGbl_EnableInterpreterSlack) 455 { 456 Object = AcpiUtCreateIntegerObject ((UINT64) 0); 457 if (!Object) 458 { 459 return_ACPI_STATUS (AE_NO_MEMORY); 460 } 461 462 Node->Object = Object; 463 } 464 465 /* Otherwise, return the error */ 466 467 else switch (Type) 468 { 469 case ACPI_REFCLASS_ARG: 470 471 ACPI_ERROR ((AE_INFO, 472 "Uninitialized Arg[%u] at node %p", 473 Index, Node)); 474 475 return_ACPI_STATUS (AE_AML_UNINITIALIZED_ARG); 476 477 case ACPI_REFCLASS_LOCAL: 478 /* 479 * No error message for this case, will be trapped again later to 480 * detect and ignore cases of Store(LocalX,LocalX) 481 */ 482 return_ACPI_STATUS (AE_AML_UNINITIALIZED_LOCAL); 483 484 default: 485 486 ACPI_ERROR ((AE_INFO, "Not a Arg/Local opcode: 0x%X", Type)); 487 return_ACPI_STATUS (AE_AML_INTERNAL); 488 } 489 } 490 491 /* 492 * The Index points to an initialized and valid object. 493 * Return an additional reference to the object 494 */ 495 *DestDesc = Object; 496 AcpiUtAddReference (Object); 497 498 return_ACPI_STATUS (AE_OK); 499 } 500 501 502 /******************************************************************************* 503 * 504 * FUNCTION: AcpiDsMethodDataDeleteValue 505 * 506 * PARAMETERS: Type - Either ACPI_REFCLASS_LOCAL or 507 * ACPI_REFCLASS_ARG 508 * Index - Which localVar or argument to delete 509 * WalkState - Current walk state object 510 * 511 * RETURN: None 512 * 513 * DESCRIPTION: Delete the entry at Opcode:Index. Inserts 514 * a null into the stack slot after the object is deleted. 515 * 516 ******************************************************************************/ 517 518 static void 519 AcpiDsMethodDataDeleteValue ( 520 UINT8 Type, 521 UINT32 Index, 522 ACPI_WALK_STATE *WalkState) 523 { 524 ACPI_STATUS Status; 525 ACPI_NAMESPACE_NODE *Node; 526 ACPI_OPERAND_OBJECT *Object; 527 528 529 ACPI_FUNCTION_TRACE (DsMethodDataDeleteValue); 530 531 532 /* Get the namespace node for the arg/local */ 533 534 Status = AcpiDsMethodDataGetNode (Type, Index, WalkState, &Node); 535 if (ACPI_FAILURE (Status)) 536 { 537 return_VOID; 538 } 539 540 /* Get the associated object */ 541 542 Object = AcpiNsGetAttachedObject (Node); 543 544 /* 545 * Undefine the Arg or Local by setting its descriptor 546 * pointer to NULL. Locals/Args can contain both 547 * ACPI_OPERAND_OBJECTS and ACPI_NAMESPACE_NODEs 548 */ 549 Node->Object = NULL; 550 551 if ((Object) && 552 (ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_OPERAND)) 553 { 554 /* 555 * There is a valid object. 556 * Decrement the reference count by one to balance the 557 * increment when the object was stored. 558 */ 559 AcpiUtRemoveReference (Object); 560 } 561 562 return_VOID; 563 } 564 565 566 /******************************************************************************* 567 * 568 * FUNCTION: AcpiDsStoreObjectToLocal 569 * 570 * PARAMETERS: Type - Either ACPI_REFCLASS_LOCAL or 571 * ACPI_REFCLASS_ARG 572 * Index - Which Local or Arg to set 573 * ObjDesc - Value to be stored 574 * WalkState - Current walk state 575 * 576 * RETURN: Status 577 * 578 * DESCRIPTION: Store a value in an Arg or Local. The ObjDesc is installed 579 * as the new value for the Arg or Local and the reference count 580 * for ObjDesc is incremented. 581 * 582 ******************************************************************************/ 583 584 ACPI_STATUS 585 AcpiDsStoreObjectToLocal ( 586 UINT8 Type, 587 UINT32 Index, 588 ACPI_OPERAND_OBJECT *ObjDesc, 589 ACPI_WALK_STATE *WalkState) 590 { 591 ACPI_STATUS Status; 592 ACPI_NAMESPACE_NODE *Node; 593 ACPI_OPERAND_OBJECT *CurrentObjDesc; 594 ACPI_OPERAND_OBJECT *NewObjDesc; 595 596 597 ACPI_FUNCTION_TRACE (DsStoreObjectToLocal); 598 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Type=%2.2X Index=%u Obj=%p\n", 599 Type, Index, ObjDesc)); 600 601 /* Parameter validation */ 602 603 if (!ObjDesc) 604 { 605 return_ACPI_STATUS (AE_BAD_PARAMETER); 606 } 607 608 /* Get the namespace node for the arg/local */ 609 610 Status = AcpiDsMethodDataGetNode (Type, Index, WalkState, &Node); 611 if (ACPI_FAILURE (Status)) 612 { 613 return_ACPI_STATUS (Status); 614 } 615 616 CurrentObjDesc = AcpiNsGetAttachedObject (Node); 617 if (CurrentObjDesc == ObjDesc) 618 { 619 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Obj=%p already installed!\n", 620 ObjDesc)); 621 return_ACPI_STATUS (Status); 622 } 623 624 /* 625 * If the reference count on the object is more than one, we must 626 * take a copy of the object before we store. A reference count 627 * of exactly 1 means that the object was just created during the 628 * evaluation of an expression, and we can safely use it since it 629 * is not used anywhere else. 630 */ 631 NewObjDesc = ObjDesc; 632 if (ObjDesc->Common.ReferenceCount > 1) 633 { 634 Status = AcpiUtCopyIobjectToIobject ( 635 ObjDesc, &NewObjDesc, WalkState); 636 if (ACPI_FAILURE (Status)) 637 { 638 return_ACPI_STATUS (Status); 639 } 640 } 641 642 /* 643 * If there is an object already in this slot, we either 644 * have to delete it, or if this is an argument and there 645 * is an object reference stored there, we have to do 646 * an indirect store! 647 */ 648 if (CurrentObjDesc) 649 { 650 /* 651 * Check for an indirect store if an argument 652 * contains an object reference (stored as an Node). 653 * We don't allow this automatic dereferencing for 654 * locals, since a store to a local should overwrite 655 * anything there, including an object reference. 656 * 657 * If both Arg0 and Local0 contain RefOf (Local4): 658 * 659 * Store (1, Arg0) - Causes indirect store to local4 660 * Store (1, Local0) - Stores 1 in local0, overwriting 661 * the reference to local4 662 * Store (1, DeRefof (Local0)) - Causes indirect store to local4 663 * 664 * Weird, but true. 665 */ 666 if (Type == ACPI_REFCLASS_ARG) 667 { 668 /* 669 * If we have a valid reference object that came from RefOf(), 670 * do the indirect store 671 */ 672 if ((ACPI_GET_DESCRIPTOR_TYPE (CurrentObjDesc) == 673 ACPI_DESC_TYPE_OPERAND) && 674 (CurrentObjDesc->Common.Type == 675 ACPI_TYPE_LOCAL_REFERENCE) && 676 (CurrentObjDesc->Reference.Class == 677 ACPI_REFCLASS_REFOF)) 678 { 679 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 680 "Arg (%p) is an ObjRef(Node), storing in node %p\n", 681 NewObjDesc, CurrentObjDesc)); 682 683 /* 684 * Store this object to the Node (perform the indirect store) 685 * NOTE: No implicit conversion is performed, as per the ACPI 686 * specification rules on storing to Locals/Args. 687 */ 688 Status = AcpiExStoreObjectToNode (NewObjDesc, 689 CurrentObjDesc->Reference.Object, WalkState, 690 ACPI_NO_IMPLICIT_CONVERSION); 691 692 /* Remove local reference if we copied the object above */ 693 694 if (NewObjDesc != ObjDesc) 695 { 696 AcpiUtRemoveReference (NewObjDesc); 697 } 698 699 return_ACPI_STATUS (Status); 700 } 701 } 702 703 /* Delete the existing object before storing the new one */ 704 705 AcpiDsMethodDataDeleteValue (Type, Index, WalkState); 706 } 707 708 /* 709 * Install the Obj descriptor (*NewObjDesc) into 710 * the descriptor for the Arg or Local. 711 * (increments the object reference count by one) 712 */ 713 Status = AcpiDsMethodDataSetValue (Type, Index, NewObjDesc, WalkState); 714 715 /* Remove local reference if we copied the object above */ 716 717 if (NewObjDesc != ObjDesc) 718 { 719 AcpiUtRemoveReference (NewObjDesc); 720 } 721 722 return_ACPI_STATUS (Status); 723 } 724 725 726 #ifdef ACPI_OBSOLETE_FUNCTIONS 727 /******************************************************************************* 728 * 729 * FUNCTION: AcpiDsMethodDataGetType 730 * 731 * PARAMETERS: Opcode - Either AML_LOCAL_OP or AML_ARG_OP 732 * Index - Which Local or Arg whose type to get 733 * WalkState - Current walk state object 734 * 735 * RETURN: Data type of current value of the selected Arg or Local 736 * 737 * DESCRIPTION: Get the type of the object stored in the Local or Arg 738 * 739 ******************************************************************************/ 740 741 ACPI_OBJECT_TYPE 742 AcpiDsMethodDataGetType ( 743 UINT16 Opcode, 744 UINT32 Index, 745 ACPI_WALK_STATE *WalkState) 746 { 747 ACPI_STATUS Status; 748 ACPI_NAMESPACE_NODE *Node; 749 ACPI_OPERAND_OBJECT *Object; 750 751 752 ACPI_FUNCTION_TRACE (DsMethodDataGetType); 753 754 755 /* Get the namespace node for the arg/local */ 756 757 Status = AcpiDsMethodDataGetNode (Opcode, Index, WalkState, &Node); 758 if (ACPI_FAILURE (Status)) 759 { 760 return_VALUE ((ACPI_TYPE_NOT_FOUND)); 761 } 762 763 /* Get the object */ 764 765 Object = AcpiNsGetAttachedObject (Node); 766 if (!Object) 767 { 768 /* Uninitialized local/arg, return TYPE_ANY */ 769 770 return_VALUE (ACPI_TYPE_ANY); 771 } 772 773 /* Get the object type */ 774 775 return_VALUE (Object->Type); 776 } 777 #endif 778