Merge branch 'for-2.6.26' of git://neil.brown.name/md
[linux-2.6] / drivers / acpi / dispatcher / dsutils.c
1 /*******************************************************************************
2  *
3  * Module Name: dsutils - Dispatcher utilities
4  *
5  ******************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2008, 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/acpi.h>
45 #include <acpi/acparser.h>
46 #include <acpi/amlcode.h>
47 #include <acpi/acdispat.h>
48 #include <acpi/acinterp.h>
49 #include <acpi/acnamesp.h>
50 #include <acpi/acdebug.h>
51
52 #define _COMPONENT          ACPI_DISPATCHER
53 ACPI_MODULE_NAME("dsutils")
54
55 /*******************************************************************************
56  *
57  * FUNCTION:    acpi_ds_clear_implicit_return
58  *
59  * PARAMETERS:  walk_state          - Current State
60  *
61  * RETURN:      None.
62  *
63  * DESCRIPTION: Clear and remove a reference on an implicit return value.  Used
64  *              to delete "stale" return values (if enabled, the return value
65  *              from every operator is saved at least momentarily, in case the
66  *              parent method exits.)
67  *
68  ******************************************************************************/
69 void acpi_ds_clear_implicit_return(struct acpi_walk_state *walk_state)
70 {
71         ACPI_FUNCTION_NAME(ds_clear_implicit_return);
72
73         /*
74          * Slack must be enabled for this feature
75          */
76         if (!acpi_gbl_enable_interpreter_slack) {
77                 return;
78         }
79
80         if (walk_state->implicit_return_obj) {
81                 /*
82                  * Delete any "stale" implicit return. However, in
83                  * complex statements, the implicit return value can be
84                  * bubbled up several levels.
85                  */
86                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
87                                   "Removing reference on stale implicit return obj %p\n",
88                                   walk_state->implicit_return_obj));
89
90                 acpi_ut_remove_reference(walk_state->implicit_return_obj);
91                 walk_state->implicit_return_obj = NULL;
92         }
93 }
94
95 #ifndef ACPI_NO_METHOD_EXECUTION
96 /*******************************************************************************
97  *
98  * FUNCTION:    acpi_ds_do_implicit_return
99  *
100  * PARAMETERS:  return_desc         - The return value
101  *              walk_state          - Current State
102  *              add_reference       - True if a reference should be added to the
103  *                                    return object
104  *
105  * RETURN:      TRUE if implicit return enabled, FALSE otherwise
106  *
107  * DESCRIPTION: Implements the optional "implicit return".  We save the result
108  *              of every ASL operator and control method invocation in case the
109  *              parent method exit.  Before storing a new return value, we
110  *              delete the previous return value.
111  *
112  ******************************************************************************/
113
114 u8
115 acpi_ds_do_implicit_return(union acpi_operand_object *return_desc,
116                            struct acpi_walk_state *walk_state, u8 add_reference)
117 {
118         ACPI_FUNCTION_NAME(ds_do_implicit_return);
119
120         /*
121          * Slack must be enabled for this feature, and we must
122          * have a valid return object
123          */
124         if ((!acpi_gbl_enable_interpreter_slack) || (!return_desc)) {
125                 return (FALSE);
126         }
127
128         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
129                           "Result %p will be implicitly returned; Prev=%p\n",
130                           return_desc, walk_state->implicit_return_obj));
131
132         /*
133          * Delete any "stale" implicit return value first. However, in
134          * complex statements, the implicit return value can be
135          * bubbled up several levels, so we don't clear the value if it
136          * is the same as the return_desc.
137          */
138         if (walk_state->implicit_return_obj) {
139                 if (walk_state->implicit_return_obj == return_desc) {
140                         return (TRUE);
141                 }
142                 acpi_ds_clear_implicit_return(walk_state);
143         }
144
145         /* Save the implicit return value, add a reference if requested */
146
147         walk_state->implicit_return_obj = return_desc;
148         if (add_reference) {
149                 acpi_ut_add_reference(return_desc);
150         }
151
152         return (TRUE);
153 }
154
155 /*******************************************************************************
156  *
157  * FUNCTION:    acpi_ds_is_result_used
158  *
159  * PARAMETERS:  Op                  - Current Op
160  *              walk_state          - Current State
161  *
162  * RETURN:      TRUE if result is used, FALSE otherwise
163  *
164  * DESCRIPTION: Check if a result object will be used by the parent
165  *
166  ******************************************************************************/
167
168 u8
169 acpi_ds_is_result_used(union acpi_parse_object * op,
170                        struct acpi_walk_state * walk_state)
171 {
172         const struct acpi_opcode_info *parent_info;
173
174         ACPI_FUNCTION_TRACE_PTR(ds_is_result_used, op);
175
176         /* Must have both an Op and a Result Object */
177
178         if (!op) {
179                 ACPI_ERROR((AE_INFO, "Null Op"));
180                 return_UINT8(TRUE);
181         }
182
183         /*
184          * We know that this operator is not a
185          * Return() operator (would not come here.) The following code is the
186          * optional support for a so-called "implicit return". Some AML code
187          * assumes that the last value of the method is "implicitly" returned
188          * to the caller. Just save the last result as the return value.
189          * NOTE: this is optional because the ASL language does not actually
190          * support this behavior.
191          */
192         (void)acpi_ds_do_implicit_return(walk_state->result_obj, walk_state,
193                                          TRUE);
194
195         /*
196          * Now determine if the parent will use the result
197          *
198          * If there is no parent, or the parent is a scope_op, we are executing
199          * at the method level. An executing method typically has no parent,
200          * since each method is parsed separately.  A method invoked externally
201          * via execute_control_method has a scope_op as the parent.
202          */
203         if ((!op->common.parent) ||
204             (op->common.parent->common.aml_opcode == AML_SCOPE_OP)) {
205
206                 /* No parent, the return value cannot possibly be used */
207
208                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
209                                   "At Method level, result of [%s] not used\n",
210                                   acpi_ps_get_opcode_name(op->common.
211                                                           aml_opcode)));
212                 return_UINT8(FALSE);
213         }
214
215         /* Get info on the parent. The root_op is AML_SCOPE */
216
217         parent_info =
218             acpi_ps_get_opcode_info(op->common.parent->common.aml_opcode);
219         if (parent_info->class == AML_CLASS_UNKNOWN) {
220                 ACPI_ERROR((AE_INFO, "Unknown parent opcode Op=%p", op));
221                 return_UINT8(FALSE);
222         }
223
224         /*
225          * Decide what to do with the result based on the parent.  If
226          * the parent opcode will not use the result, delete the object.
227          * Otherwise leave it as is, it will be deleted when it is used
228          * as an operand later.
229          */
230         switch (parent_info->class) {
231         case AML_CLASS_CONTROL:
232
233                 switch (op->common.parent->common.aml_opcode) {
234                 case AML_RETURN_OP:
235
236                         /* Never delete the return value associated with a return opcode */
237
238                         goto result_used;
239
240                 case AML_IF_OP:
241                 case AML_WHILE_OP:
242
243                         /*
244                          * If we are executing the predicate AND this is the predicate op,
245                          * we will use the return value
246                          */
247                         if ((walk_state->control_state->common.state ==
248                              ACPI_CONTROL_PREDICATE_EXECUTING)
249                             && (walk_state->control_state->control.
250                                 predicate_op == op)) {
251                                 goto result_used;
252                         }
253                         break;
254
255                 default:
256                         /* Ignore other control opcodes */
257                         break;
258                 }
259
260                 /* The general control opcode returns no result */
261
262                 goto result_not_used;
263
264         case AML_CLASS_CREATE:
265
266                 /*
267                  * These opcodes allow term_arg(s) as operands and therefore
268                  * the operands can be method calls.  The result is used.
269                  */
270                 goto result_used;
271
272         case AML_CLASS_NAMED_OBJECT:
273
274                 if ((op->common.parent->common.aml_opcode == AML_REGION_OP) ||
275                     (op->common.parent->common.aml_opcode == AML_DATA_REGION_OP)
276                     || (op->common.parent->common.aml_opcode == AML_PACKAGE_OP)
277                     || (op->common.parent->common.aml_opcode ==
278                         AML_VAR_PACKAGE_OP)
279                     || (op->common.parent->common.aml_opcode == AML_BUFFER_OP)
280                     || (op->common.parent->common.aml_opcode ==
281                         AML_INT_EVAL_SUBTREE_OP)
282                     || (op->common.parent->common.aml_opcode ==
283                         AML_BANK_FIELD_OP)) {
284                         /*
285                          * These opcodes allow term_arg(s) as operands and therefore
286                          * the operands can be method calls.  The result is used.
287                          */
288                         goto result_used;
289                 }
290
291                 goto result_not_used;
292
293         default:
294
295                 /*
296                  * In all other cases. the parent will actually use the return
297                  * object, so keep it.
298                  */
299                 goto result_used;
300         }
301
302       result_used:
303         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
304                           "Result of [%s] used by Parent [%s] Op=%p\n",
305                           acpi_ps_get_opcode_name(op->common.aml_opcode),
306                           acpi_ps_get_opcode_name(op->common.parent->common.
307                                                   aml_opcode), op));
308
309         return_UINT8(TRUE);
310
311       result_not_used:
312         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
313                           "Result of [%s] not used by Parent [%s] Op=%p\n",
314                           acpi_ps_get_opcode_name(op->common.aml_opcode),
315                           acpi_ps_get_opcode_name(op->common.parent->common.
316                                                   aml_opcode), op));
317
318         return_UINT8(FALSE);
319 }
320
321 /*******************************************************************************
322  *
323  * FUNCTION:    acpi_ds_delete_result_if_not_used
324  *
325  * PARAMETERS:  Op              - Current parse Op
326  *              result_obj      - Result of the operation
327  *              walk_state      - Current state
328  *
329  * RETURN:      Status
330  *
331  * DESCRIPTION: Used after interpretation of an opcode.  If there is an internal
332  *              result descriptor, check if the parent opcode will actually use
333  *              this result.  If not, delete the result now so that it will
334  *              not become orphaned.
335  *
336  ******************************************************************************/
337
338 void
339 acpi_ds_delete_result_if_not_used(union acpi_parse_object *op,
340                                   union acpi_operand_object *result_obj,
341                                   struct acpi_walk_state *walk_state)
342 {
343         union acpi_operand_object *obj_desc;
344         acpi_status status;
345
346         ACPI_FUNCTION_TRACE_PTR(ds_delete_result_if_not_used, result_obj);
347
348         if (!op) {
349                 ACPI_ERROR((AE_INFO, "Null Op"));
350                 return_VOID;
351         }
352
353         if (!result_obj) {
354                 return_VOID;
355         }
356
357         if (!acpi_ds_is_result_used(op, walk_state)) {
358
359                 /* Must pop the result stack (obj_desc should be equal to result_obj) */
360
361                 status = acpi_ds_result_pop(&obj_desc, walk_state);
362                 if (ACPI_SUCCESS(status)) {
363                         acpi_ut_remove_reference(result_obj);
364                 }
365         }
366
367         return_VOID;
368 }
369
370 /*******************************************************************************
371  *
372  * FUNCTION:    acpi_ds_resolve_operands
373  *
374  * PARAMETERS:  walk_state          - Current walk state with operands on stack
375  *
376  * RETURN:      Status
377  *
378  * DESCRIPTION: Resolve all operands to their values.  Used to prepare
379  *              arguments to a control method invocation (a call from one
380  *              method to another.)
381  *
382  ******************************************************************************/
383
384 acpi_status acpi_ds_resolve_operands(struct acpi_walk_state *walk_state)
385 {
386         u32 i;
387         acpi_status status = AE_OK;
388
389         ACPI_FUNCTION_TRACE_PTR(ds_resolve_operands, walk_state);
390
391         /*
392          * Attempt to resolve each of the valid operands
393          * Method arguments are passed by reference, not by value.  This means
394          * that the actual objects are passed, not copies of the objects.
395          */
396         for (i = 0; i < walk_state->num_operands; i++) {
397                 status =
398                     acpi_ex_resolve_to_value(&walk_state->operands[i],
399                                              walk_state);
400                 if (ACPI_FAILURE(status)) {
401                         break;
402                 }
403         }
404
405         return_ACPI_STATUS(status);
406 }
407
408 /*******************************************************************************
409  *
410  * FUNCTION:    acpi_ds_clear_operands
411  *
412  * PARAMETERS:  walk_state          - Current walk state with operands on stack
413  *
414  * RETURN:      None
415  *
416  * DESCRIPTION: Clear all operands on the current walk state operand stack.
417  *
418  ******************************************************************************/
419
420 void acpi_ds_clear_operands(struct acpi_walk_state *walk_state)
421 {
422         u32 i;
423
424         ACPI_FUNCTION_TRACE_PTR(ds_clear_operands, walk_state);
425
426         /* Remove a reference on each operand on the stack */
427
428         for (i = 0; i < walk_state->num_operands; i++) {
429                 /*
430                  * Remove a reference to all operands, including both
431                  * "Arguments" and "Targets".
432                  */
433                 acpi_ut_remove_reference(walk_state->operands[i]);
434                 walk_state->operands[i] = NULL;
435         }
436
437         walk_state->num_operands = 0;
438         return_VOID;
439 }
440 #endif
441
442 /*******************************************************************************
443  *
444  * FUNCTION:    acpi_ds_create_operand
445  *
446  * PARAMETERS:  walk_state      - Current walk state
447  *              Arg             - Parse object for the argument
448  *              arg_index       - Which argument (zero based)
449  *
450  * RETURN:      Status
451  *
452  * DESCRIPTION: Translate a parse tree object that is an argument to an AML
453  *              opcode to the equivalent interpreter object.  This may include
454  *              looking up a name or entering a new name into the internal
455  *              namespace.
456  *
457  ******************************************************************************/
458
459 acpi_status
460 acpi_ds_create_operand(struct acpi_walk_state *walk_state,
461                        union acpi_parse_object *arg, u32 arg_index)
462 {
463         acpi_status status = AE_OK;
464         char *name_string;
465         u32 name_length;
466         union acpi_operand_object *obj_desc;
467         union acpi_parse_object *parent_op;
468         u16 opcode;
469         acpi_interpreter_mode interpreter_mode;
470         const struct acpi_opcode_info *op_info;
471
472         ACPI_FUNCTION_TRACE_PTR(ds_create_operand, arg);
473
474         /* A valid name must be looked up in the namespace */
475
476         if ((arg->common.aml_opcode == AML_INT_NAMEPATH_OP) &&
477             (arg->common.value.string) &&
478             !(arg->common.flags & ACPI_PARSEOP_IN_STACK)) {
479                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Getting a name: Arg=%p\n",
480                                   arg));
481
482                 /* Get the entire name string from the AML stream */
483
484                 status =
485                     acpi_ex_get_name_string(ACPI_TYPE_ANY,
486                                             arg->common.value.buffer,
487                                             &name_string, &name_length);
488
489                 if (ACPI_FAILURE(status)) {
490                         return_ACPI_STATUS(status);
491                 }
492
493                 /* All prefixes have been handled, and the name is in name_string */
494
495                 /*
496                  * Special handling for buffer_field declarations. This is a deferred
497                  * opcode that unfortunately defines the field name as the last
498                  * parameter instead of the first.  We get here when we are performing
499                  * the deferred execution, so the actual name of the field is already
500                  * in the namespace.  We don't want to attempt to look it up again
501                  * because we may be executing in a different scope than where the
502                  * actual opcode exists.
503                  */
504                 if ((walk_state->deferred_node) &&
505                     (walk_state->deferred_node->type == ACPI_TYPE_BUFFER_FIELD)
506                     && (arg_index ==
507                         (u32) ((walk_state->opcode ==
508                                 AML_CREATE_FIELD_OP) ? 3 : 2))) {
509                         obj_desc =
510                             ACPI_CAST_PTR(union acpi_operand_object,
511                                           walk_state->deferred_node);
512                         status = AE_OK;
513                 } else {        /* All other opcodes */
514
515                         /*
516                          * Differentiate between a namespace "create" operation
517                          * versus a "lookup" operation (IMODE_LOAD_PASS2 vs.
518                          * IMODE_EXECUTE) in order to support the creation of
519                          * namespace objects during the execution of control methods.
520                          */
521                         parent_op = arg->common.parent;
522                         op_info =
523                             acpi_ps_get_opcode_info(parent_op->common.
524                                                     aml_opcode);
525                         if ((op_info->flags & AML_NSNODE)
526                             && (parent_op->common.aml_opcode !=
527                                 AML_INT_METHODCALL_OP)
528                             && (parent_op->common.aml_opcode != AML_REGION_OP)
529                             && (parent_op->common.aml_opcode !=
530                                 AML_INT_NAMEPATH_OP)) {
531
532                                 /* Enter name into namespace if not found */
533
534                                 interpreter_mode = ACPI_IMODE_LOAD_PASS2;
535                         } else {
536                                 /* Return a failure if name not found */
537
538                                 interpreter_mode = ACPI_IMODE_EXECUTE;
539                         }
540
541                         status =
542                             acpi_ns_lookup(walk_state->scope_info, name_string,
543                                            ACPI_TYPE_ANY, interpreter_mode,
544                                            ACPI_NS_SEARCH_PARENT |
545                                            ACPI_NS_DONT_OPEN_SCOPE, walk_state,
546                                            ACPI_CAST_INDIRECT_PTR(struct
547                                                                   acpi_namespace_node,
548                                                                   &obj_desc));
549                         /*
550                          * The only case where we pass through (ignore) a NOT_FOUND
551                          * error is for the cond_ref_of opcode.
552                          */
553                         if (status == AE_NOT_FOUND) {
554                                 if (parent_op->common.aml_opcode ==
555                                     AML_COND_REF_OF_OP) {
556                                         /*
557                                          * For the Conditional Reference op, it's OK if
558                                          * the name is not found;  We just need a way to
559                                          * indicate this to the interpreter, set the
560                                          * object to the root
561                                          */
562                                         obj_desc = ACPI_CAST_PTR(union
563                                                                  acpi_operand_object,
564                                                                  acpi_gbl_root_node);
565                                         status = AE_OK;
566                                 } else {
567                                         /*
568                                          * We just plain didn't find it -- which is a
569                                          * very serious error at this point
570                                          */
571                                         status = AE_AML_NAME_NOT_FOUND;
572                                 }
573                         }
574
575                         if (ACPI_FAILURE(status)) {
576                                 ACPI_ERROR_NAMESPACE(name_string, status);
577                         }
578                 }
579
580                 /* Free the namestring created above */
581
582                 ACPI_FREE(name_string);
583
584                 /* Check status from the lookup */
585
586                 if (ACPI_FAILURE(status)) {
587                         return_ACPI_STATUS(status);
588                 }
589
590                 /* Put the resulting object onto the current object stack */
591
592                 status = acpi_ds_obj_stack_push(obj_desc, walk_state);
593                 if (ACPI_FAILURE(status)) {
594                         return_ACPI_STATUS(status);
595                 }
596                 ACPI_DEBUGGER_EXEC(acpi_db_display_argument_object
597                                    (obj_desc, walk_state));
598         } else {
599                 /* Check for null name case */
600
601                 if ((arg->common.aml_opcode == AML_INT_NAMEPATH_OP) &&
602                     !(arg->common.flags & ACPI_PARSEOP_IN_STACK)) {
603                         /*
604                          * If the name is null, this means that this is an
605                          * optional result parameter that was not specified
606                          * in the original ASL.  Create a Zero Constant for a
607                          * placeholder.  (Store to a constant is a Noop.)
608                          */
609                         opcode = AML_ZERO_OP;   /* Has no arguments! */
610
611                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
612                                           "Null namepath: Arg=%p\n", arg));
613                 } else {
614                         opcode = arg->common.aml_opcode;
615                 }
616
617                 /* Get the object type of the argument */
618
619                 op_info = acpi_ps_get_opcode_info(opcode);
620                 if (op_info->object_type == ACPI_TYPE_INVALID) {
621                         return_ACPI_STATUS(AE_NOT_IMPLEMENTED);
622                 }
623
624                 if ((op_info->flags & AML_HAS_RETVAL)
625                     || (arg->common.flags & ACPI_PARSEOP_IN_STACK)) {
626                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
627                                           "Argument previously created, already stacked\n"));
628
629                         ACPI_DEBUGGER_EXEC(acpi_db_display_argument_object
630                                            (walk_state->
631                                             operands[walk_state->num_operands -
632                                                      1], walk_state));
633
634                         /*
635                          * Use value that was already previously returned
636                          * by the evaluation of this argument
637                          */
638                         status = acpi_ds_result_pop(&obj_desc, walk_state);
639                         if (ACPI_FAILURE(status)) {
640                                 /*
641                                  * Only error is underflow, and this indicates
642                                  * a missing or null operand!
643                                  */
644                                 ACPI_EXCEPTION((AE_INFO, status,
645                                                 "Missing or null operand"));
646                                 return_ACPI_STATUS(status);
647                         }
648                 } else {
649                         /* Create an ACPI_INTERNAL_OBJECT for the argument */
650
651                         obj_desc =
652                             acpi_ut_create_internal_object(op_info->
653                                                            object_type);
654                         if (!obj_desc) {
655                                 return_ACPI_STATUS(AE_NO_MEMORY);
656                         }
657
658                         /* Initialize the new object */
659
660                         status =
661                             acpi_ds_init_object_from_op(walk_state, arg, opcode,
662                                                         &obj_desc);
663                         if (ACPI_FAILURE(status)) {
664                                 acpi_ut_delete_object_desc(obj_desc);
665                                 return_ACPI_STATUS(status);
666                         }
667                 }
668
669                 /* Put the operand object on the object stack */
670
671                 status = acpi_ds_obj_stack_push(obj_desc, walk_state);
672                 if (ACPI_FAILURE(status)) {
673                         return_ACPI_STATUS(status);
674                 }
675
676                 ACPI_DEBUGGER_EXEC(acpi_db_display_argument_object
677                                    (obj_desc, walk_state));
678         }
679
680         return_ACPI_STATUS(AE_OK);
681 }
682
683 /*******************************************************************************
684  *
685  * FUNCTION:    acpi_ds_create_operands
686  *
687  * PARAMETERS:  walk_state          - Current state
688  *              first_arg           - First argument of a parser argument tree
689  *
690  * RETURN:      Status
691  *
692  * DESCRIPTION: Convert an operator's arguments from a parse tree format to
693  *              namespace objects and place those argument object on the object
694  *              stack in preparation for evaluation by the interpreter.
695  *
696  ******************************************************************************/
697
698 acpi_status
699 acpi_ds_create_operands(struct acpi_walk_state *walk_state,
700                         union acpi_parse_object *first_arg)
701 {
702         acpi_status status = AE_OK;
703         union acpi_parse_object *arg;
704         union acpi_parse_object *arguments[ACPI_OBJ_NUM_OPERANDS];
705         u32 arg_count = 0;
706         u32 index = walk_state->num_operands;
707         u32 i;
708
709         ACPI_FUNCTION_TRACE_PTR(ds_create_operands, first_arg);
710
711         /* Get all arguments in the list */
712
713         arg = first_arg;
714         while (arg) {
715                 if (index >= ACPI_OBJ_NUM_OPERANDS) {
716                         return_ACPI_STATUS(AE_BAD_DATA);
717                 }
718
719                 arguments[index] = arg;
720                 walk_state->operands[index] = NULL;
721
722                 /* Move on to next argument, if any */
723
724                 arg = arg->common.next;
725                 arg_count++;
726                 index++;
727         }
728
729         index--;
730
731         /* It is the appropriate order to get objects from the Result stack */
732
733         for (i = 0; i < arg_count; i++) {
734                 arg = arguments[index];
735
736                 /* Force the filling of the operand stack in inverse order */
737
738                 walk_state->operand_index = (u8) index;
739
740                 status = acpi_ds_create_operand(walk_state, arg, index);
741                 if (ACPI_FAILURE(status)) {
742                         goto cleanup;
743                 }
744
745                 index--;
746
747                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
748                                   "Arg #%d (%p) done, Arg1=%p\n", index, arg,
749                                   first_arg));
750         }
751
752         return_ACPI_STATUS(status);
753
754       cleanup:
755         /*
756          * We must undo everything done above; meaning that we must
757          * pop everything off of the operand stack and delete those
758          * objects
759          */
760         acpi_ds_obj_stack_pop_and_delete(arg_count, walk_state);
761
762         ACPI_EXCEPTION((AE_INFO, status, "While creating Arg %d", index));
763         return_ACPI_STATUS(status);
764 }
765
766 /*****************************************************************************
767  *
768  * FUNCTION:    acpi_ds_evaluate_name_path
769  *
770  * PARAMETERS:  walk_state      - Current state of the parse tree walk,
771  *                                the opcode of current operation should be
772  *                                AML_INT_NAMEPATH_OP
773  *
774  * RETURN:      Status
775  *
776  * DESCRIPTION: Translate the -name_path- parse tree object to the equivalent
777  *              interpreter object, convert it to value, if needed, duplicate
778  *              it, if needed, and push it onto the current result stack.
779  *
780  ****************************************************************************/
781
782 acpi_status acpi_ds_evaluate_name_path(struct acpi_walk_state *walk_state)
783 {
784         acpi_status status = AE_OK;
785         union acpi_parse_object *op = walk_state->op;
786         union acpi_operand_object **operand = &walk_state->operands[0];
787         union acpi_operand_object *new_obj_desc;
788         u8 type;
789
790         ACPI_FUNCTION_TRACE_PTR(ds_evaluate_name_path, walk_state);
791
792         if (!op->common.parent) {
793
794                 /* This happens after certain exception processing */
795
796                 goto exit;
797         }
798
799         if ((op->common.parent->common.aml_opcode == AML_PACKAGE_OP) ||
800             (op->common.parent->common.aml_opcode == AML_VAR_PACKAGE_OP) ||
801             (op->common.parent->common.aml_opcode == AML_REF_OF_OP)) {
802
803                 /* TBD: Should we specify this feature as a bit of op_info->Flags of these opcodes? */
804
805                 goto exit;
806         }
807
808         status = acpi_ds_create_operand(walk_state, op, 0);
809         if (ACPI_FAILURE(status)) {
810                 goto exit;
811         }
812
813         if (op->common.flags & ACPI_PARSEOP_TARGET) {
814                 new_obj_desc = *operand;
815                 goto push_result;
816         }
817
818         type = ACPI_GET_OBJECT_TYPE(*operand);
819
820         status = acpi_ex_resolve_to_value(operand, walk_state);
821         if (ACPI_FAILURE(status)) {
822                 goto exit;
823         }
824
825         if (type == ACPI_TYPE_INTEGER) {
826
827                 /* It was incremented by acpi_ex_resolve_to_value */
828
829                 acpi_ut_remove_reference(*operand);
830
831                 status =
832                     acpi_ut_copy_iobject_to_iobject(*operand, &new_obj_desc,
833                                                     walk_state);
834                 if (ACPI_FAILURE(status)) {
835                         goto exit;
836                 }
837         } else {
838                 /*
839                  * The object either was anew created or is
840                  * a Namespace node - don't decrement it.
841                  */
842                 new_obj_desc = *operand;
843         }
844
845         /* Cleanup for name-path operand */
846
847         status = acpi_ds_obj_stack_pop(1, walk_state);
848         if (ACPI_FAILURE(status)) {
849                 walk_state->result_obj = new_obj_desc;
850                 goto exit;
851         }
852
853       push_result:
854
855         walk_state->result_obj = new_obj_desc;
856
857         status = acpi_ds_result_push(walk_state->result_obj, walk_state);
858         if (ACPI_SUCCESS(status)) {
859
860                 /* Force to take it from stack */
861
862                 op->common.flags |= ACPI_PARSEOP_IN_STACK;
863         }
864
865       exit:
866
867         return_ACPI_STATUS(status);
868 }