1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2/******************************************************************************* 3 * 4 * Module Name: dsmthdat - control method arguments and local variables 5 * 6 ******************************************************************************/ 7 8#include <acpi/acpi.h> 9#include "accommon.h" 10#include "acdispat.h" 11#include "acnamesp.h" 12#include "acinterp.h" 13 14#define _COMPONENT ACPI_DISPATCHER 15ACPI_MODULE_NAME("dsmthdat") 16 17/* Local prototypes */ 18static void 19acpi_ds_method_data_delete_value(u8 type, 20 u32 index, struct acpi_walk_state *walk_state); 21 22static acpi_status 23acpi_ds_method_data_set_value(u8 type, 24 u32 index, 25 union acpi_operand_object *object, 26 struct acpi_walk_state *walk_state); 27 28#ifdef ACPI_OBSOLETE_FUNCTIONS 29acpi_object_type 30acpi_ds_method_data_get_type(u16 opcode, 31 u32 index, struct acpi_walk_state *walk_state); 32#endif 33 34/******************************************************************************* 35 * 36 * FUNCTION: acpi_ds_method_data_init 37 * 38 * PARAMETERS: walk_state - Current walk state object 39 * 40 * RETURN: Status 41 * 42 * DESCRIPTION: Initialize the data structures that hold the method's arguments 43 * and locals. The data struct is an array of namespace nodes for 44 * each - this allows ref_of and de_ref_of to work properly for these 45 * special data types. 46 * 47 * NOTES: walk_state fields are initialized to zero by the 48 * ACPI_ALLOCATE_ZEROED(). 49 * 50 * A pseudo-Namespace Node is assigned to each argument and local 51 * so that ref_of() can return a pointer to the Node. 52 * 53 ******************************************************************************/ 54 55void acpi_ds_method_data_init(struct acpi_walk_state *walk_state) 56{ 57 u32 i; 58 59 ACPI_FUNCTION_TRACE(ds_method_data_init); 60 61 /* Init the method arguments */ 62 63 for (i = 0; i < ACPI_METHOD_NUM_ARGS; i++) { 64 ACPI_MOVE_32_TO_32(&walk_state->arguments[i].name, 65 NAMEOF_ARG_NTE); 66 67 walk_state->arguments[i].name.integer |= (i << 24); 68 walk_state->arguments[i].descriptor_type = ACPI_DESC_TYPE_NAMED; 69 walk_state->arguments[i].type = ACPI_TYPE_ANY; 70 walk_state->arguments[i].flags = ANOBJ_METHOD_ARG; 71 } 72 73 /* Init the method locals */ 74 75 for (i = 0; i < ACPI_METHOD_NUM_LOCALS; i++) { 76 ACPI_MOVE_32_TO_32(&walk_state->local_variables[i].name, 77 NAMEOF_LOCAL_NTE); 78 79 walk_state->local_variables[i].name.integer |= (i << 24); 80 walk_state->local_variables[i].descriptor_type = 81 ACPI_DESC_TYPE_NAMED; 82 walk_state->local_variables[i].type = ACPI_TYPE_ANY; 83 walk_state->local_variables[i].flags = ANOBJ_METHOD_LOCAL; 84 } 85 86 return_VOID; 87} 88 89/******************************************************************************* 90 * 91 * FUNCTION: acpi_ds_method_data_delete_all 92 * 93 * PARAMETERS: walk_state - Current walk state object 94 * 95 * RETURN: None 96 * 97 * DESCRIPTION: Delete method locals and arguments. Arguments are only 98 * deleted if this method was called from another method. 99 * 100 ******************************************************************************/ 101 102void acpi_ds_method_data_delete_all(struct acpi_walk_state *walk_state) 103{ 104 u32 index; 105 106 ACPI_FUNCTION_TRACE(ds_method_data_delete_all); 107 108 /* Detach the locals */ 109 110 for (index = 0; index < ACPI_METHOD_NUM_LOCALS; index++) { 111 if (walk_state->local_variables[index].object) { 112 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Deleting Local%u=%p\n", 113 index, 114 walk_state->local_variables[index]. 115 object)); 116 117 /* Detach object (if present) and remove a reference */ 118 119 acpi_ns_detach_object(&walk_state-> 120 local_variables[index]); 121 } 122 } 123 124 /* Detach the arguments */ 125 126 for (index = 0; index < ACPI_METHOD_NUM_ARGS; index++) { 127 if (walk_state->arguments[index].object) { 128 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Deleting Arg%u=%p\n", 129 index, 130 walk_state->arguments[index].object)); 131 132 /* Detach object (if present) and remove a reference */ 133 134 acpi_ns_detach_object(&walk_state->arguments[index]); 135 } 136 } 137 138 return_VOID; 139} 140 141/******************************************************************************* 142 * 143 * FUNCTION: acpi_ds_method_data_init_args 144 * 145 * PARAMETERS: *params - Pointer to a parameter list for the method 146 * max_param_count - The arg count for this method 147 * walk_state - Current walk state object 148 * 149 * RETURN: Status 150 * 151 * DESCRIPTION: Initialize arguments for a method. The parameter list is a list 152 * of ACPI operand objects, either null terminated or whose length 153 * is defined by max_param_count. 154 * 155 ******************************************************************************/ 156 157acpi_status 158acpi_ds_method_data_init_args(union acpi_operand_object **params, 159 u32 max_param_count, 160 struct acpi_walk_state *walk_state) 161{ 162 acpi_status status; 163 u32 index = 0; 164 165 ACPI_FUNCTION_TRACE_PTR(ds_method_data_init_args, params); 166 167 if (!params) { 168 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 169 "No parameter list passed to method\n")); 170 return_ACPI_STATUS(AE_OK); 171 } 172 173 /* Copy passed parameters into the new method stack frame */ 174 175 while ((index < ACPI_METHOD_NUM_ARGS) && 176 (index < max_param_count) && params[index]) { 177 /* 178 * A valid parameter. 179 * Store the argument in the method/walk descriptor. 180 * Do not copy the arg in order to implement call by reference 181 */ 182 status = 183 acpi_ds_method_data_set_value(ACPI_REFCLASS_ARG, index, 184 params[index], walk_state); 185 if (ACPI_FAILURE(status)) { 186 return_ACPI_STATUS(status); 187 } 188 189 index++; 190 } 191 192 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "%u args passed to method\n", index)); 193 return_ACPI_STATUS(AE_OK); 194} 195 196/******************************************************************************* 197 * 198 * FUNCTION: acpi_ds_method_data_get_node 199 * 200 * PARAMETERS: type - Either ACPI_REFCLASS_LOCAL or 201 * ACPI_REFCLASS_ARG 202 * index - Which Local or Arg whose type to get 203 * walk_state - Current walk state object 204 * node - Where the node is returned. 205 * 206 * RETURN: Status and node 207 * 208 * DESCRIPTION: Get the Node associated with a local or arg. 209 * 210 ******************************************************************************/ 211 212acpi_status 213acpi_ds_method_data_get_node(u8 type, 214 u32 index, 215 struct acpi_walk_state *walk_state, 216 struct acpi_namespace_node **node) 217{ 218 ACPI_FUNCTION_TRACE(ds_method_data_get_node); 219 220 /* 221 * Method Locals and Arguments are supported 222 */ 223 switch (type) { 224 case ACPI_REFCLASS_LOCAL: 225 226 if (index > ACPI_METHOD_MAX_LOCAL) { 227 ACPI_ERROR((AE_INFO, 228 "Local index %u is invalid (max %u)", 229 index, ACPI_METHOD_MAX_LOCAL)); 230 return_ACPI_STATUS(AE_AML_INVALID_INDEX); 231 } 232 233 /* Return a pointer to the pseudo-node */ 234 235 *node = &walk_state->local_variables[index]; 236 break; 237 238 case ACPI_REFCLASS_ARG: 239 240 if (index > ACPI_METHOD_MAX_ARG) { 241 ACPI_ERROR((AE_INFO, 242 "Arg index %u is invalid (max %u)", 243 index, ACPI_METHOD_MAX_ARG)); 244 return_ACPI_STATUS(AE_AML_INVALID_INDEX); 245 } 246 247 /* Return a pointer to the pseudo-node */ 248 249 *node = &walk_state->arguments[index]; 250 break; 251 252 default: 253 254 ACPI_ERROR((AE_INFO, "Type %u is invalid", type)); 255 return_ACPI_STATUS(AE_TYPE); 256 } 257 258 return_ACPI_STATUS(AE_OK); 259} 260 261/******************************************************************************* 262 * 263 * FUNCTION: acpi_ds_method_data_set_value 264 * 265 * PARAMETERS: type - Either ACPI_REFCLASS_LOCAL or 266 * ACPI_REFCLASS_ARG 267 * index - Which Local or Arg to get 268 * object - Object to be inserted into the stack entry 269 * walk_state - Current walk state object 270 * 271 * RETURN: Status 272 * 273 * DESCRIPTION: Insert an object onto the method stack at entry Opcode:Index. 274 * Note: There is no "implicit conversion" for locals. 275 * 276 ******************************************************************************/ 277 278static acpi_status 279acpi_ds_method_data_set_value(u8 type, 280 u32 index, 281 union acpi_operand_object *object, 282 struct acpi_walk_state *walk_state) 283{ 284 acpi_status status; 285 struct acpi_namespace_node *node; 286 287 ACPI_FUNCTION_TRACE(ds_method_data_set_value); 288 289 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 290 "NewObj %p Type %2.2X, Refs=%u [%s]\n", object, 291 type, object->common.reference_count, 292 acpi_ut_get_type_name(object->common.type))); 293 294 /* Get the namespace node for the arg/local */ 295 296 status = acpi_ds_method_data_get_node(type, index, walk_state, &node); 297 if (ACPI_FAILURE(status)) { 298 return_ACPI_STATUS(status); 299 } 300 301 /* 302 * Increment ref count so object can't be deleted while installed. 303 * NOTE: We do not copy the object in order to preserve the call by 304 * reference semantics of ACPI Control Method invocation. 305 * (See ACPI Specification 2.0C) 306 */ 307 acpi_ut_add_reference(object); 308 309 /* Install the object */ 310 311 node->object = object; 312 return_ACPI_STATUS(status); 313} 314 315/******************************************************************************* 316 * 317 * FUNCTION: acpi_ds_method_data_get_value 318 * 319 * PARAMETERS: type - Either ACPI_REFCLASS_LOCAL or 320 * ACPI_REFCLASS_ARG 321 * index - Which localVar or argument to get 322 * walk_state - Current walk state object 323 * dest_desc - Where Arg or Local value is returned 324 * 325 * RETURN: Status 326 * 327 * DESCRIPTION: Retrieve value of selected Arg or Local for this method 328 * Used only in acpi_ex_resolve_to_value(). 329 * 330 ******************************************************************************/ 331 332acpi_status 333acpi_ds_method_data_get_value(u8 type, 334 u32 index, 335 struct acpi_walk_state *walk_state, 336 union acpi_operand_object **dest_desc) 337{ 338 acpi_status status; 339 struct acpi_namespace_node *node; 340 union acpi_operand_object *object; 341 342 ACPI_FUNCTION_TRACE(ds_method_data_get_value); 343 344 /* Validate the object descriptor */ 345 346 if (!dest_desc) { 347 ACPI_ERROR((AE_INFO, "Null object descriptor pointer")); 348 return_ACPI_STATUS(AE_BAD_PARAMETER); 349 } 350 351 /* Get the namespace node for the arg/local */ 352 353 status = acpi_ds_method_data_get_node(type, index, walk_state, &node); 354 if (ACPI_FAILURE(status)) { 355 return_ACPI_STATUS(status); 356 } 357 358 /* Get the object from the node */ 359 360 object = node->object; 361 362 /* Examine the returned object, it must be valid. */ 363 364 if (!object) { 365 /* 366 * Index points to uninitialized object. 367 * This means that either 1) The expected argument was 368 * not passed to the method, or 2) A local variable 369 * was referenced by the method (via the ASL) 370 * before it was initialized. Either case is an error. 371 */ 372 373 /* If slack enabled, init the local_x/arg_x to an Integer of value zero */ 374 375 if (acpi_gbl_enable_interpreter_slack) { 376 object = acpi_ut_create_integer_object((u64) 0); 377 if (!object) { 378 return_ACPI_STATUS(AE_NO_MEMORY); 379 } 380 381 node->object = object; 382 } 383 384 /* Otherwise, return the error */ 385 386 else 387 switch (type) { 388 case ACPI_REFCLASS_ARG: 389 390 ACPI_ERROR((AE_INFO, 391 "Uninitialized Arg[%u] at node %p", 392 index, node)); 393 394 return_ACPI_STATUS(AE_AML_UNINITIALIZED_ARG); 395 396 case ACPI_REFCLASS_LOCAL: 397 /* 398 * No error message for this case, will be trapped again later to 399 * detect and ignore cases of Store(local_x,local_x) 400 */ 401 return_ACPI_STATUS(AE_AML_UNINITIALIZED_LOCAL); 402 403 default: 404 405 ACPI_ERROR((AE_INFO, 406 "Not a Arg/Local opcode: 0x%X", 407 type)); 408 return_ACPI_STATUS(AE_AML_INTERNAL); 409 } 410 } 411 412 /* 413 * The Index points to an initialized and valid object. 414 * Return an additional reference to the object 415 */ 416 *dest_desc = object; 417 acpi_ut_add_reference(object); 418 419 return_ACPI_STATUS(AE_OK); 420} 421 422/******************************************************************************* 423 * 424 * FUNCTION: acpi_ds_method_data_delete_value 425 * 426 * PARAMETERS: type - Either ACPI_REFCLASS_LOCAL or 427 * ACPI_REFCLASS_ARG 428 * index - Which localVar or argument to delete 429 * walk_state - Current walk state object 430 * 431 * RETURN: None 432 * 433 * DESCRIPTION: Delete the entry at Opcode:Index. Inserts 434 * a null into the stack slot after the object is deleted. 435 * 436 ******************************************************************************/ 437 438static void 439acpi_ds_method_data_delete_value(u8 type, 440 u32 index, struct acpi_walk_state *walk_state) 441{ 442 acpi_status status; 443 struct acpi_namespace_node *node; 444 union acpi_operand_object *object; 445 446 ACPI_FUNCTION_TRACE(ds_method_data_delete_value); 447 448 /* Get the namespace node for the arg/local */ 449 450 status = acpi_ds_method_data_get_node(type, index, walk_state, &node); 451 if (ACPI_FAILURE(status)) { 452 return_VOID; 453 } 454 455 /* Get the associated object */ 456 457 object = acpi_ns_get_attached_object(node); 458 459 /* 460 * Undefine the Arg or Local by setting its descriptor 461 * pointer to NULL. Locals/Args can contain both 462 * ACPI_OPERAND_OBJECTS and ACPI_NAMESPACE_NODEs 463 */ 464 node->object = NULL; 465 466 if ((object) && 467 (ACPI_GET_DESCRIPTOR_TYPE(object) == ACPI_DESC_TYPE_OPERAND)) { 468 /* 469 * There is a valid object. 470 * Decrement the reference count by one to balance the 471 * increment when the object was stored. 472 */ 473 acpi_ut_remove_reference(object); 474 } 475 476 return_VOID; 477} 478 479/******************************************************************************* 480 * 481 * FUNCTION: acpi_ds_store_object_to_local 482 * 483 * PARAMETERS: type - Either ACPI_REFCLASS_LOCAL or 484 * ACPI_REFCLASS_ARG 485 * index - Which Local or Arg to set 486 * obj_desc - Value to be stored 487 * walk_state - Current walk state 488 * 489 * RETURN: Status 490 * 491 * DESCRIPTION: Store a value in an Arg or Local. The obj_desc is installed 492 * as the new value for the Arg or Local and the reference count 493 * for obj_desc is incremented. 494 * 495 ******************************************************************************/ 496 497acpi_status 498acpi_ds_store_object_to_local(u8 type, 499 u32 index, 500 union acpi_operand_object *obj_desc, 501 struct acpi_walk_state *walk_state) 502{ 503 acpi_status status; 504 struct acpi_namespace_node *node; 505 union acpi_operand_object *current_obj_desc; 506 union acpi_operand_object *new_obj_desc; 507 508 ACPI_FUNCTION_TRACE(ds_store_object_to_local); 509 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Type=%2.2X Index=%u Obj=%p\n", 510 type, index, obj_desc)); 511 512 /* Parameter validation */ 513 514 if (!obj_desc) { 515 return_ACPI_STATUS(AE_BAD_PARAMETER); 516 } 517 518 /* Get the namespace node for the arg/local */ 519 520 status = acpi_ds_method_data_get_node(type, index, walk_state, &node); 521 if (ACPI_FAILURE(status)) { 522 return_ACPI_STATUS(status); 523 } 524 525 current_obj_desc = acpi_ns_get_attached_object(node); 526 if (current_obj_desc == obj_desc) { 527 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Obj=%p already installed!\n", 528 obj_desc)); 529 return_ACPI_STATUS(status); 530 } 531 532 /* 533 * If the reference count on the object is more than one, we must 534 * take a copy of the object before we store. A reference count 535 * of exactly 1 means that the object was just created during the 536 * evaluation of an expression, and we can safely use it since it 537 * is not used anywhere else. 538 */ 539 new_obj_desc = obj_desc; 540 if (obj_desc->common.reference_count > 1) { 541 status = 542 acpi_ut_copy_iobject_to_iobject(obj_desc, &new_obj_desc, 543 walk_state); 544 if (ACPI_FAILURE(status)) { 545 return_ACPI_STATUS(status); 546 } 547 } 548 549 /* 550 * If there is an object already in this slot, we either 551 * have to delete it, or if this is an argument and there 552 * is an object reference stored there, we have to do 553 * an indirect store! 554 */ 555 if (current_obj_desc) { 556 /* 557 * Check for an indirect store if an argument 558 * contains an object reference (stored as an Node). 559 * We don't allow this automatic dereferencing for 560 * locals, since a store to a local should overwrite 561 * anything there, including an object reference. 562 * 563 * If both Arg0 and Local0 contain ref_of (Local4): 564 * 565 * Store (1, Arg0) - Causes indirect store to local4 566 * Store (1, Local0) - Stores 1 in local0, overwriting 567 * the reference to local4 568 * Store (1, de_refof (Local0)) - Causes indirect store to local4 569 * 570 * Weird, but true. 571 */ 572 if (type == ACPI_REFCLASS_ARG) { 573 /* 574 * If we have a valid reference object that came from ref_of(), 575 * do the indirect store 576 */ 577 if ((ACPI_GET_DESCRIPTOR_TYPE(current_obj_desc) == 578 ACPI_DESC_TYPE_OPERAND) && 579 (current_obj_desc->common.type == 580 ACPI_TYPE_LOCAL_REFERENCE) && 581 (current_obj_desc->reference.class == 582 ACPI_REFCLASS_REFOF)) { 583 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 584 "Arg (%p) is an ObjRef(Node), storing in node %p\n", 585 new_obj_desc, 586 current_obj_desc)); 587 588 /* 589 * Store this object to the Node (perform the indirect store) 590 * NOTE: No implicit conversion is performed, as per the ACPI 591 * specification rules on storing to Locals/Args. 592 */ 593 status = 594 acpi_ex_store_object_to_node(new_obj_desc, 595 current_obj_desc-> 596 reference. 597 object, 598 walk_state, 599 ACPI_NO_IMPLICIT_CONVERSION); 600 601 /* Remove local reference if we copied the object above */ 602 603 if (new_obj_desc != obj_desc) { 604 acpi_ut_remove_reference(new_obj_desc); 605 } 606 607 return_ACPI_STATUS(status); 608 } 609 } 610 611 /* Delete the existing object before storing the new one */ 612 613 acpi_ds_method_data_delete_value(type, index, walk_state); 614 } 615 616 /* 617 * Install the Obj descriptor (*new_obj_desc) into 618 * the descriptor for the Arg or Local. 619 * (increments the object reference count by one) 620 */ 621 status = 622 acpi_ds_method_data_set_value(type, index, new_obj_desc, 623 walk_state); 624 625 /* Remove local reference if we copied the object above */ 626 627 if (new_obj_desc != obj_desc) { 628 acpi_ut_remove_reference(new_obj_desc); 629 } 630 631 return_ACPI_STATUS(status); 632} 633 634#ifdef ACPI_OBSOLETE_FUNCTIONS 635/******************************************************************************* 636 * 637 * FUNCTION: acpi_ds_method_data_get_type 638 * 639 * PARAMETERS: opcode - Either AML_FIRST LOCAL_OP or 640 * AML_FIRST_ARG_OP 641 * index - Which Local or Arg whose type to get 642 * walk_state - Current walk state object 643 * 644 * RETURN: Data type of current value of the selected Arg or Local 645 * 646 * DESCRIPTION: Get the type of the object stored in the Local or Arg 647 * 648 ******************************************************************************/ 649 650acpi_object_type 651acpi_ds_method_data_get_type(u16 opcode, 652 u32 index, struct acpi_walk_state *walk_state) 653{ 654 acpi_status status; 655 struct acpi_namespace_node *node; 656 union acpi_operand_object *object; 657 658 ACPI_FUNCTION_TRACE(ds_method_data_get_type); 659 660 /* Get the namespace node for the arg/local */ 661 662 status = acpi_ds_method_data_get_node(opcode, index, walk_state, &node); 663 if (ACPI_FAILURE(status)) { 664 return_VALUE((ACPI_TYPE_NOT_FOUND)); 665 } 666 667 /* Get the object */ 668 669 object = acpi_ns_get_attached_object(node); 670 if (!object) { 671 672 /* Uninitialized local/arg, return TYPE_ANY */ 673 674 return_VALUE(ACPI_TYPE_ANY); 675 } 676 677 /* Get the object type */ 678 679 return_VALUE(object->type); 680} 681#endif 682