Branch data Line data Source code
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
15 : : ACPI_MODULE_NAME("dsmthdat")
16 : :
17 : : /* Local prototypes */
18 : : static void
19 : : acpi_ds_method_data_delete_value(u8 type,
20 : : u32 index, struct acpi_walk_state *walk_state);
21 : :
22 : : static acpi_status
23 : : acpi_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
29 : : acpi_object_type
30 : : acpi_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 : :
55 : 4959 : void acpi_ds_method_data_init(struct acpi_walk_state *walk_state)
56 : : {
57 : 4959 : u32 i;
58 : :
59 : 4959 : ACPI_FUNCTION_TRACE(ds_method_data_init);
60 : :
61 : : /* Init the method arguments */
62 : :
63 [ + + ]: 39672 : for (i = 0; i < ACPI_METHOD_NUM_ARGS; i++) {
64 : 34713 : ACPI_MOVE_32_TO_32(&walk_state->arguments[i].name,
65 : : NAMEOF_ARG_NTE);
66 : :
67 : 34713 : walk_state->arguments[i].name.integer |= (i << 24);
68 : 34713 : walk_state->arguments[i].descriptor_type = ACPI_DESC_TYPE_NAMED;
69 : 34713 : walk_state->arguments[i].type = ACPI_TYPE_ANY;
70 : 34713 : walk_state->arguments[i].flags = ANOBJ_METHOD_ARG;
71 : : }
72 : :
73 : : /* Init the method locals */
74 : :
75 [ + + ]: 44631 : for (i = 0; i < ACPI_METHOD_NUM_LOCALS; i++) {
76 : 39672 : ACPI_MOVE_32_TO_32(&walk_state->local_variables[i].name,
77 : : NAMEOF_LOCAL_NTE);
78 : :
79 : 39672 : walk_state->local_variables[i].name.integer |= (i << 24);
80 : 39672 : walk_state->local_variables[i].descriptor_type =
81 : : ACPI_DESC_TYPE_NAMED;
82 : 39672 : walk_state->local_variables[i].type = ACPI_TYPE_ANY;
83 : 39672 : walk_state->local_variables[i].flags = ANOBJ_METHOD_LOCAL;
84 : : }
85 : :
86 : 4959 : 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 : :
102 : 2803 : void acpi_ds_method_data_delete_all(struct acpi_walk_state *walk_state)
103 : : {
104 : 2803 : u32 index;
105 : :
106 : 2803 : ACPI_FUNCTION_TRACE(ds_method_data_delete_all);
107 : :
108 : : /* Detach the locals */
109 : :
110 [ + + ]: 25227 : for (index = 0; index < ACPI_METHOD_NUM_LOCALS; index++) {
111 [ + + ]: 22424 : 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 : 771 : object));
116 : :
117 : : /* Detach object (if present) and remove a reference */
118 : :
119 : 771 : acpi_ns_detach_object(&walk_state->
120 : : local_variables[index]);
121 : : }
122 : : }
123 : :
124 : : /* Detach the arguments */
125 : :
126 [ + + ]: 22424 : for (index = 0; index < ACPI_METHOD_NUM_ARGS; index++) {
127 [ + + ]: 19621 : if (walk_state->arguments[index].object) {
128 : : ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Deleting Arg%u=%p\n",
129 : : index,
130 : 812 : walk_state->arguments[index].object));
131 : :
132 : : /* Detach object (if present) and remove a reference */
133 : :
134 : 812 : acpi_ns_detach_object(&walk_state->arguments[index]);
135 : : }
136 : : }
137 : :
138 : 2803 : 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 : :
157 : : acpi_status
158 : 4735 : acpi_ds_method_data_init_args(union acpi_operand_object **params,
159 : : u32 max_param_count,
160 : : struct acpi_walk_state *walk_state)
161 : : {
162 : 4735 : acpi_status status;
163 : 4735 : u32 index = 0;
164 : :
165 : 4735 : ACPI_FUNCTION_TRACE_PTR(ds_method_data_init_args, params);
166 : :
167 [ + + ]: 4735 : 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 : 1624 : while ((index < ACPI_METHOD_NUM_ARGS) &&
176 [ + - + + ]: 1624 : (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 : 812 : status =
183 : 812 : acpi_ds_method_data_set_value(ACPI_REFCLASS_ARG, index,
184 : : params[index], walk_state);
185 [ - + ]: 812 : if (ACPI_FAILURE(status)) {
186 : 0 : return_ACPI_STATUS(status);
187 : : }
188 : :
189 : 812 : 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 : :
212 : : acpi_status
213 : 196061 : acpi_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 : 196061 : ACPI_FUNCTION_TRACE(ds_method_data_get_node);
219 : :
220 : : /*
221 : : * Method Locals and Arguments are supported
222 : : */
223 [ + + - ]: 196061 : switch (type) {
224 : 193121 : case ACPI_REFCLASS_LOCAL:
225 : :
226 [ - + ]: 193121 : if (index > ACPI_METHOD_MAX_LOCAL) {
227 : 0 : ACPI_ERROR((AE_INFO,
228 : : "Local index %u is invalid (max %u)",
229 : : index, ACPI_METHOD_MAX_LOCAL));
230 : 0 : return_ACPI_STATUS(AE_AML_INVALID_INDEX);
231 : : }
232 : :
233 : : /* Return a pointer to the pseudo-node */
234 : :
235 : 193121 : *node = &walk_state->local_variables[index];
236 : 193121 : break;
237 : :
238 : 2940 : case ACPI_REFCLASS_ARG:
239 : :
240 [ - + ]: 2940 : if (index > ACPI_METHOD_MAX_ARG) {
241 : 0 : ACPI_ERROR((AE_INFO,
242 : : "Arg index %u is invalid (max %u)",
243 : : index, ACPI_METHOD_MAX_ARG));
244 : 0 : return_ACPI_STATUS(AE_AML_INVALID_INDEX);
245 : : }
246 : :
247 : : /* Return a pointer to the pseudo-node */
248 : :
249 : 2940 : *node = &walk_state->arguments[index];
250 : 2940 : break;
251 : :
252 : 0 : default:
253 : :
254 : 0 : ACPI_ERROR((AE_INFO, "Type %u is invalid", type));
255 : 0 : 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 : :
278 : : static acpi_status
279 : 17530 : acpi_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 : 17530 : acpi_status status;
285 : 17530 : struct acpi_namespace_node *node;
286 : :
287 : 17530 : 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 : 17530 : acpi_ut_get_type_name(object->common.type)));
293 : :
294 : : /* Get the namespace node for the arg/local */
295 : :
296 : 17530 : status = acpi_ds_method_data_get_node(type, index, walk_state, &node);
297 [ + - ]: 17530 : 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 : 17530 : acpi_ut_add_reference(object);
308 : :
309 : : /* Install the object */
310 : :
311 : 17530 : node->object = object;
312 : 17530 : 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 : :
332 : : acpi_status
333 : 66558 : acpi_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 : 66558 : acpi_status status;
339 : 66558 : struct acpi_namespace_node *node;
340 : 66558 : union acpi_operand_object *object;
341 : :
342 : 66558 : ACPI_FUNCTION_TRACE(ds_method_data_get_value);
343 : :
344 : : /* Validate the object descriptor */
345 : :
346 [ - + ]: 66558 : if (!dest_desc) {
347 : 0 : ACPI_ERROR((AE_INFO, "Null object descriptor pointer"));
348 : 0 : return_ACPI_STATUS(AE_BAD_PARAMETER);
349 : : }
350 : :
351 : : /* Get the namespace node for the arg/local */
352 : :
353 : 66558 : status = acpi_ds_method_data_get_node(type, index, walk_state, &node);
354 [ + - ]: 66558 : if (ACPI_FAILURE(status)) {
355 : : return_ACPI_STATUS(status);
356 : : }
357 : :
358 : : /* Get the object from the node */
359 : :
360 : 66558 : object = node->object;
361 : :
362 : : /* Examine the returned object, it must be valid. */
363 : :
364 [ - + ]: 66558 : 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 [ # # ]: 0 : if (acpi_gbl_enable_interpreter_slack) {
376 : 0 : object = acpi_ut_create_integer_object((u64) 0);
377 [ # # ]: 0 : if (!object) {
378 : : return_ACPI_STATUS(AE_NO_MEMORY);
379 : : }
380 : :
381 : 0 : node->object = object;
382 : : }
383 : :
384 : : /* Otherwise, return the error */
385 : :
386 : : else
387 [ # # # ]: 0 : switch (type) {
388 : 0 : case ACPI_REFCLASS_ARG:
389 : :
390 : 0 : ACPI_ERROR((AE_INFO,
391 : : "Uninitialized Arg[%u] at node %p",
392 : : index, node));
393 : :
394 : 0 : 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 : 0 : default:
404 : :
405 : 0 : ACPI_ERROR((AE_INFO,
406 : : "Not a Arg/Local opcode: 0x%X",
407 : : type));
408 : 0 : 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 : 66558 : *dest_desc = object;
417 : 66558 : acpi_ut_add_reference(object);
418 : :
419 : 66558 : 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 : :
438 : : static void
439 : 15947 : acpi_ds_method_data_delete_value(u8 type,
440 : : u32 index, struct acpi_walk_state *walk_state)
441 : : {
442 : 15947 : acpi_status status;
443 : 15947 : struct acpi_namespace_node *node;
444 : 15947 : union acpi_operand_object *object;
445 : :
446 : 15947 : ACPI_FUNCTION_TRACE(ds_method_data_delete_value);
447 : :
448 : : /* Get the namespace node for the arg/local */
449 : :
450 : 15947 : status = acpi_ds_method_data_get_node(type, index, walk_state, &node);
451 [ + - ]: 15947 : if (ACPI_FAILURE(status)) {
452 : : return_VOID;
453 : : }
454 : :
455 : : /* Get the associated object */
456 : :
457 : 15947 : 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 : 15947 : node->object = NULL;
465 : :
466 [ + - ]: 15947 : if ((object) &&
467 [ + - ]: 15947 : (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 : 15947 : 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 : :
497 : : acpi_status
498 : 16718 : acpi_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 : 16718 : acpi_status status;
504 : 16718 : struct acpi_namespace_node *node;
505 : 16718 : union acpi_operand_object *current_obj_desc;
506 : 16718 : union acpi_operand_object *new_obj_desc;
507 : :
508 : 16718 : ACPI_FUNCTION_TRACE(ds_store_object_to_local);
509 : : ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Type=%2.2X Index=%u Obj=%p\n",
510 : 16718 : type, index, obj_desc));
511 : :
512 : : /* Parameter validation */
513 : :
514 [ + - ]: 16718 : if (!obj_desc) {
515 : : return_ACPI_STATUS(AE_BAD_PARAMETER);
516 : : }
517 : :
518 : : /* Get the namespace node for the arg/local */
519 : :
520 : 16718 : status = acpi_ds_method_data_get_node(type, index, walk_state, &node);
521 [ + - ]: 16718 : if (ACPI_FAILURE(status)) {
522 : : return_ACPI_STATUS(status);
523 : : }
524 : :
525 : 16718 : current_obj_desc = acpi_ns_get_attached_object(node);
526 [ + - ]: 16718 : 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 : 16718 : new_obj_desc = obj_desc;
540 [ + + ]: 16718 : if (obj_desc->common.reference_count > 1) {
541 : 12495 : status =
542 : 12495 : acpi_ut_copy_iobject_to_iobject(obj_desc, &new_obj_desc,
543 : : walk_state);
544 [ + - ]: 12495 : 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 [ + + ]: 16718 : 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 [ - + ]: 15947 : 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 [ # # ]: 0 : if ((ACPI_GET_DESCRIPTOR_TYPE(current_obj_desc) ==
578 : : ACPI_DESC_TYPE_OPERAND) &&
579 : : (current_obj_desc->common.type ==
580 [ # # ]: 0 : 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 : 0 : 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 : 0 : status =
594 : 0 : acpi_ex_store_object_to_node(new_obj_desc,
595 : : current_obj_desc->
596 : 0 : reference.
597 : : object,
598 : : walk_state,
599 : : ACPI_NO_IMPLICIT_CONVERSION);
600 : :
601 : : /* Remove local reference if we copied the object above */
602 : :
603 [ # # ]: 0 : if (new_obj_desc != obj_desc) {
604 : 0 : acpi_ut_remove_reference(new_obj_desc);
605 : : }
606 : :
607 : 0 : return_ACPI_STATUS(status);
608 : : }
609 : : }
610 : :
611 : : /* Delete the existing object before storing the new one */
612 : :
613 : 15947 : 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 : 16718 : status =
622 : 16718 : 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 [ + + ]: 16718 : if (new_obj_desc != obj_desc) {
628 : 12495 : 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 : :
650 : : acpi_object_type
651 : : acpi_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
|
