blob: 05230baf5de8ed5e738c93e07a3ecd327a53946a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*******************************************************************************
2 *
3 * Module Name: dsutils - Dispatcher utilities
4 *
5 ******************************************************************************/
6
7/*
Bob Moore4a90c7e2006-01-13 16:22:00 -05008 * Copyright (C) 2000 - 2006, R. Byron Moore
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#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
Len Brown4be44fc2005-08-05 00:44:28 -040053ACPI_MODULE_NAME("dsutils")
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
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 ******************************************************************************/
Len Brown4be44fc2005-08-05 00:44:28 -040069void acpi_ds_clear_implicit_return(struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
Bob Mooreb229cf92006-04-21 17:15:00 -040071 ACPI_FUNCTION_NAME(ds_clear_implicit_return);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
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 */
Len Brown4be44fc2005-08-05 00:44:28 -040086 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
87 "Removing reference on stale implicit return obj %p\n",
88 walk_state->implicit_return_obj));
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Len Brown4be44fc2005-08-05 00:44:28 -040090 acpi_ut_remove_reference(walk_state->implicit_return_obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 walk_state->implicit_return_obj = NULL;
92 }
93}
94
Linus Torvalds1da177e2005-04-16 15:20:36 -070095#ifndef ACPI_NO_METHOD_EXECUTION
Linus Torvalds1da177e2005-04-16 15:20:36 -070096/*******************************************************************************
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
114u8
Len Brown4be44fc2005-08-05 00:44:28 -0400115acpi_ds_do_implicit_return(union acpi_operand_object *return_desc,
116 struct acpi_walk_state *walk_state, u8 add_reference)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
Bob Mooreb229cf92006-04-21 17:15:00 -0400118 ACPI_FUNCTION_NAME(ds_do_implicit_return);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
120 /*
121 * Slack must be enabled for this feature, and we must
122 * have a valid return object
123 */
Len Brown4be44fc2005-08-05 00:44:28 -0400124 if ((!acpi_gbl_enable_interpreter_slack) || (!return_desc)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 return (FALSE);
126 }
127
Len Brown4be44fc2005-08-05 00:44:28 -0400128 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
129 "Result %p will be implicitly returned; Prev=%p\n",
130 return_desc, walk_state->implicit_return_obj));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
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 }
Len Brown4be44fc2005-08-05 00:44:28 -0400142 acpi_ds_clear_implicit_return(walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 }
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) {
Len Brown4be44fc2005-08-05 00:44:28 -0400149 acpi_ut_add_reference(return_desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 }
151
152 return (TRUE);
153}
154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155/*******************************************************************************
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
168u8
Len Brown4be44fc2005-08-05 00:44:28 -0400169acpi_ds_is_result_used(union acpi_parse_object * op,
170 struct acpi_walk_state * walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171{
Len Brown4be44fc2005-08-05 00:44:28 -0400172 const struct acpi_opcode_info *parent_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
Bob Mooreb229cf92006-04-21 17:15:00 -0400174 ACPI_FUNCTION_TRACE_PTR(ds_is_result_used, op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
176 /* Must have both an Op and a Result Object */
177
178 if (!op) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500179 ACPI_ERROR((AE_INFO, "Null Op"));
Bob Moore50eca3e2005-09-30 19:03:00 -0400180 return_UINT8(TRUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 }
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 */
Len Brown4be44fc2005-08-05 00:44:28 -0400192 (void)acpi_ds_do_implicit_return(walk_state->result_obj, walk_state,
193 TRUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
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) ||
Len Brown4be44fc2005-08-05 00:44:28 -0400204 (op->common.parent->common.aml_opcode == AML_SCOPE_OP)) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 /* No parent, the return value cannot possibly be used */
207
Len Brown4be44fc2005-08-05 00:44:28 -0400208 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)));
Bob Moore50eca3e2005-09-30 19:03:00 -0400212 return_UINT8(FALSE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 }
214
215 /* Get info on the parent. The root_op is AML_SCOPE */
216
Len Brown4be44fc2005-08-05 00:44:28 -0400217 parent_info =
218 acpi_ps_get_opcode_info(op->common.parent->common.aml_opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 if (parent_info->class == AML_CLASS_UNKNOWN) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500220 ACPI_ERROR((AE_INFO, "Unknown parent opcode Op=%p", op));
Bob Moore50eca3e2005-09-30 19:03:00 -0400221 return_UINT8(FALSE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 }
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 */
Len Brown4be44fc2005-08-05 00:44:28 -0400247 if ((walk_state->control_state->common.state ==
248 ACPI_CONTROL_PREDICATE_EXECUTING)
249 && (walk_state->control_state->control.
250 predicate_op == op)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 case AML_CLASS_NAMED_OBJECT:
273
Len Brown4be44fc2005-08-05 00:44:28 -0400274 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)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 /*
283 * These opcodes allow term_arg(s) as operands and therefore
284 * the operands can be method calls. The result is used.
285 */
286 goto result_used;
287 }
288
289 goto result_not_used;
290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 default:
292
293 /*
294 * In all other cases. the parent will actually use the return
295 * object, so keep it.
296 */
297 goto result_used;
298 }
299
Len Brown4be44fc2005-08-05 00:44:28 -0400300 result_used:
301 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
302 "Result of [%s] used by Parent [%s] Op=%p\n",
303 acpi_ps_get_opcode_name(op->common.aml_opcode),
304 acpi_ps_get_opcode_name(op->common.parent->common.
305 aml_opcode), op));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
Bob Moore50eca3e2005-09-30 19:03:00 -0400307 return_UINT8(TRUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308
Len Brown4be44fc2005-08-05 00:44:28 -0400309 result_not_used:
310 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
311 "Result of [%s] not used by Parent [%s] Op=%p\n",
312 acpi_ps_get_opcode_name(op->common.aml_opcode),
313 acpi_ps_get_opcode_name(op->common.parent->common.
314 aml_opcode), op));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315
Bob Moore50eca3e2005-09-30 19:03:00 -0400316 return_UINT8(FALSE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317}
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319/*******************************************************************************
320 *
321 * FUNCTION: acpi_ds_delete_result_if_not_used
322 *
323 * PARAMETERS: Op - Current parse Op
324 * result_obj - Result of the operation
325 * walk_state - Current state
326 *
327 * RETURN: Status
328 *
329 * DESCRIPTION: Used after interpretation of an opcode. If there is an internal
330 * result descriptor, check if the parent opcode will actually use
331 * this result. If not, delete the result now so that it will
332 * not become orphaned.
333 *
334 ******************************************************************************/
335
336void
Len Brown4be44fc2005-08-05 00:44:28 -0400337acpi_ds_delete_result_if_not_used(union acpi_parse_object *op,
338 union acpi_operand_object *result_obj,
339 struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
Len Brown4be44fc2005-08-05 00:44:28 -0400341 union acpi_operand_object *obj_desc;
342 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
Bob Mooreb229cf92006-04-21 17:15:00 -0400344 ACPI_FUNCTION_TRACE_PTR(ds_delete_result_if_not_used, result_obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
346 if (!op) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500347 ACPI_ERROR((AE_INFO, "Null Op"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 return_VOID;
349 }
350
351 if (!result_obj) {
352 return_VOID;
353 }
354
Len Brown4be44fc2005-08-05 00:44:28 -0400355 if (!acpi_ds_is_result_used(op, walk_state)) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400356
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 /* Must pop the result stack (obj_desc should be equal to result_obj) */
358
Len Brown4be44fc2005-08-05 00:44:28 -0400359 status = acpi_ds_result_pop(&obj_desc, walk_state);
360 if (ACPI_SUCCESS(status)) {
361 acpi_ut_remove_reference(result_obj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 }
363 }
364
365 return_VOID;
366}
367
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368/*******************************************************************************
369 *
370 * FUNCTION: acpi_ds_resolve_operands
371 *
372 * PARAMETERS: walk_state - Current walk state with operands on stack
373 *
374 * RETURN: Status
375 *
376 * DESCRIPTION: Resolve all operands to their values. Used to prepare
377 * arguments to a control method invocation (a call from one
378 * method to another.)
379 *
380 ******************************************************************************/
381
Len Brown4be44fc2005-08-05 00:44:28 -0400382acpi_status acpi_ds_resolve_operands(struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383{
Len Brown4be44fc2005-08-05 00:44:28 -0400384 u32 i;
385 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
Bob Mooreb229cf92006-04-21 17:15:00 -0400387 ACPI_FUNCTION_TRACE_PTR(ds_resolve_operands, walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
389 /*
390 * Attempt to resolve each of the valid operands
391 * Method arguments are passed by reference, not by value. This means
392 * that the actual objects are passed, not copies of the objects.
393 */
394 for (i = 0; i < walk_state->num_operands; i++) {
Len Brown4be44fc2005-08-05 00:44:28 -0400395 status =
396 acpi_ex_resolve_to_value(&walk_state->operands[i],
397 walk_state);
398 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 break;
400 }
401 }
402
Len Brown4be44fc2005-08-05 00:44:28 -0400403 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404}
405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406/*******************************************************************************
407 *
408 * FUNCTION: acpi_ds_clear_operands
409 *
410 * PARAMETERS: walk_state - Current walk state with operands on stack
411 *
412 * RETURN: None
413 *
414 * DESCRIPTION: Clear all operands on the current walk state operand stack.
415 *
416 ******************************************************************************/
417
Len Brown4be44fc2005-08-05 00:44:28 -0400418void acpi_ds_clear_operands(struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419{
Len Brown4be44fc2005-08-05 00:44:28 -0400420 u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
Bob Mooreb229cf92006-04-21 17:15:00 -0400422 ACPI_FUNCTION_TRACE_PTR(ds_clear_operands, walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 /* Remove a reference on each operand on the stack */
425
426 for (i = 0; i < walk_state->num_operands; i++) {
427 /*
428 * Remove a reference to all operands, including both
429 * "Arguments" and "Targets".
430 */
Len Brown4be44fc2005-08-05 00:44:28 -0400431 acpi_ut_remove_reference(walk_state->operands[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 walk_state->operands[i] = NULL;
433 }
434
435 walk_state->num_operands = 0;
436 return_VOID;
437}
438#endif
439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440/*******************************************************************************
441 *
442 * FUNCTION: acpi_ds_create_operand
443 *
444 * PARAMETERS: walk_state - Current walk state
445 * Arg - Parse object for the argument
446 * arg_index - Which argument (zero based)
447 *
448 * RETURN: Status
449 *
450 * DESCRIPTION: Translate a parse tree object that is an argument to an AML
451 * opcode to the equivalent interpreter object. This may include
452 * looking up a name or entering a new name into the internal
453 * namespace.
454 *
455 ******************************************************************************/
456
457acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400458acpi_ds_create_operand(struct acpi_walk_state *walk_state,
459 union acpi_parse_object *arg, u32 arg_index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460{
Len Brown4be44fc2005-08-05 00:44:28 -0400461 acpi_status status = AE_OK;
462 char *name_string;
463 u32 name_length;
464 union acpi_operand_object *obj_desc;
465 union acpi_parse_object *parent_op;
466 u16 opcode;
467 acpi_interpreter_mode interpreter_mode;
468 const struct acpi_opcode_info *op_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
Bob Mooreb229cf92006-04-21 17:15:00 -0400470 ACPI_FUNCTION_TRACE_PTR(ds_create_operand, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
472 /* A valid name must be looked up in the namespace */
473
474 if ((arg->common.aml_opcode == AML_INT_NAMEPATH_OP) &&
Len Brown4be44fc2005-08-05 00:44:28 -0400475 (arg->common.value.string)) {
476 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Getting a name: Arg=%p\n",
477 arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
479 /* Get the entire name string from the AML stream */
480
Len Brown4be44fc2005-08-05 00:44:28 -0400481 status =
482 acpi_ex_get_name_string(ACPI_TYPE_ANY,
483 arg->common.value.buffer,
484 &name_string, &name_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
Len Brown4be44fc2005-08-05 00:44:28 -0400486 if (ACPI_FAILURE(status)) {
487 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 }
489
490 /* All prefixes have been handled, and the name is in name_string */
491
492 /*
493 * Special handling for buffer_field declarations. This is a deferred
494 * opcode that unfortunately defines the field name as the last
495 * parameter instead of the first. We get here when we are performing
496 * the deferred execution, so the actual name of the field is already
497 * in the namespace. We don't want to attempt to look it up again
498 * because we may be executing in a different scope than where the
499 * actual opcode exists.
500 */
501 if ((walk_state->deferred_node) &&
Len Brown4be44fc2005-08-05 00:44:28 -0400502 (walk_state->deferred_node->type == ACPI_TYPE_BUFFER_FIELD)
Bob Moore52fc0b02006-10-02 00:00:00 -0400503 && (arg_index ==
504 (u32) ((walk_state->opcode ==
505 AML_CREATE_FIELD_OP) ? 3 : 2))) {
Len Brown4be44fc2005-08-05 00:44:28 -0400506 obj_desc =
507 ACPI_CAST_PTR(union acpi_operand_object,
508 walk_state->deferred_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 status = AE_OK;
Len Brown4be44fc2005-08-05 00:44:28 -0400510 } else { /* All other opcodes */
511
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 /*
513 * Differentiate between a namespace "create" operation
514 * versus a "lookup" operation (IMODE_LOAD_PASS2 vs.
515 * IMODE_EXECUTE) in order to support the creation of
516 * namespace objects during the execution of control methods.
517 */
518 parent_op = arg->common.parent;
Len Brown4be44fc2005-08-05 00:44:28 -0400519 op_info =
520 acpi_ps_get_opcode_info(parent_op->common.
521 aml_opcode);
522 if ((op_info->flags & AML_NSNODE)
523 && (parent_op->common.aml_opcode !=
524 AML_INT_METHODCALL_OP)
525 && (parent_op->common.aml_opcode != AML_REGION_OP)
526 && (parent_op->common.aml_opcode !=
527 AML_INT_NAMEPATH_OP)) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400528
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 /* Enter name into namespace if not found */
530
531 interpreter_mode = ACPI_IMODE_LOAD_PASS2;
Len Brown4be44fc2005-08-05 00:44:28 -0400532 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 /* Return a failure if name not found */
534
535 interpreter_mode = ACPI_IMODE_EXECUTE;
536 }
537
Len Brown4be44fc2005-08-05 00:44:28 -0400538 status =
539 acpi_ns_lookup(walk_state->scope_info, name_string,
540 ACPI_TYPE_ANY, interpreter_mode,
541 ACPI_NS_SEARCH_PARENT |
542 ACPI_NS_DONT_OPEN_SCOPE, walk_state,
543 ACPI_CAST_INDIRECT_PTR(struct
544 acpi_namespace_node,
545 &obj_desc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 /*
547 * The only case where we pass through (ignore) a NOT_FOUND
548 * error is for the cond_ref_of opcode.
549 */
550 if (status == AE_NOT_FOUND) {
Len Brown4be44fc2005-08-05 00:44:28 -0400551 if (parent_op->common.aml_opcode ==
552 AML_COND_REF_OF_OP) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 /*
554 * For the Conditional Reference op, it's OK if
555 * the name is not found; We just need a way to
556 * indicate this to the interpreter, set the
557 * object to the root
558 */
Len Brown4be44fc2005-08-05 00:44:28 -0400559 obj_desc =
560 ACPI_CAST_PTR(union
561 acpi_operand_object,
562 acpi_gbl_root_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 status = AE_OK;
Len Brown4be44fc2005-08-05 00:44:28 -0400564 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 /*
566 * We just plain didn't find it -- which is a
567 * very serious error at this point
568 */
569 status = AE_AML_NAME_NOT_FOUND;
570 }
571 }
572
Len Brown4be44fc2005-08-05 00:44:28 -0400573 if (ACPI_FAILURE(status)) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500574 ACPI_ERROR_NAMESPACE(name_string, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 }
576 }
577
578 /* Free the namestring created above */
579
Bob Moore83135242006-10-03 00:00:00 -0400580 ACPI_FREE(name_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 /* Check status from the lookup */
583
Len Brown4be44fc2005-08-05 00:44:28 -0400584 if (ACPI_FAILURE(status)) {
585 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 }
587
588 /* Put the resulting object onto the current object stack */
589
Len Brown4be44fc2005-08-05 00:44:28 -0400590 status = acpi_ds_obj_stack_push(obj_desc, walk_state);
591 if (ACPI_FAILURE(status)) {
592 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 }
Len Brown4be44fc2005-08-05 00:44:28 -0400594 ACPI_DEBUGGER_EXEC(acpi_db_display_argument_object
595 (obj_desc, walk_state));
596 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 /* Check for null name case */
598
599 if (arg->common.aml_opcode == AML_INT_NAMEPATH_OP) {
600 /*
601 * If the name is null, this means that this is an
602 * optional result parameter that was not specified
603 * in the original ASL. Create a Zero Constant for a
604 * placeholder. (Store to a constant is a Noop.)
605 */
Len Brown4be44fc2005-08-05 00:44:28 -0400606 opcode = AML_ZERO_OP; /* Has no arguments! */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Len Brown4be44fc2005-08-05 00:44:28 -0400608 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
609 "Null namepath: Arg=%p\n", arg));
610 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 opcode = arg->common.aml_opcode;
612 }
613
614 /* Get the object type of the argument */
615
Len Brown4be44fc2005-08-05 00:44:28 -0400616 op_info = acpi_ps_get_opcode_info(opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 if (op_info->object_type == ACPI_TYPE_INVALID) {
Len Brown4be44fc2005-08-05 00:44:28 -0400618 return_ACPI_STATUS(AE_NOT_IMPLEMENTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 }
620
621 if (op_info->flags & AML_HAS_RETVAL) {
Len Brown4be44fc2005-08-05 00:44:28 -0400622 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
Bob Moore50eca3e2005-09-30 19:03:00 -0400623 "Argument previously created, already stacked\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
Len Brown4be44fc2005-08-05 00:44:28 -0400625 ACPI_DEBUGGER_EXEC(acpi_db_display_argument_object
626 (walk_state->
627 operands[walk_state->num_operands -
628 1], walk_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
630 /*
631 * Use value that was already previously returned
632 * by the evaluation of this argument
633 */
Len Brown4be44fc2005-08-05 00:44:28 -0400634 status =
635 acpi_ds_result_pop_from_bottom(&obj_desc,
636 walk_state);
637 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 /*
639 * Only error is underflow, and this indicates
640 * a missing or null operand!
641 */
Bob Mooreb8e4d892006-01-27 16:43:00 -0500642 ACPI_EXCEPTION((AE_INFO, status,
643 "Missing or null operand"));
Len Brown4be44fc2005-08-05 00:44:28 -0400644 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 }
Len Brown4be44fc2005-08-05 00:44:28 -0400646 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 /* Create an ACPI_INTERNAL_OBJECT for the argument */
648
Len Brown4be44fc2005-08-05 00:44:28 -0400649 obj_desc =
650 acpi_ut_create_internal_object(op_info->
651 object_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 if (!obj_desc) {
Len Brown4be44fc2005-08-05 00:44:28 -0400653 return_ACPI_STATUS(AE_NO_MEMORY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 }
655
656 /* Initialize the new object */
657
Len Brown4be44fc2005-08-05 00:44:28 -0400658 status =
659 acpi_ds_init_object_from_op(walk_state, arg, opcode,
660 &obj_desc);
661 if (ACPI_FAILURE(status)) {
662 acpi_ut_delete_object_desc(obj_desc);
663 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 }
665 }
666
667 /* Put the operand object on the object stack */
668
Len Brown4be44fc2005-08-05 00:44:28 -0400669 status = acpi_ds_obj_stack_push(obj_desc, walk_state);
670 if (ACPI_FAILURE(status)) {
671 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 }
673
Len Brown4be44fc2005-08-05 00:44:28 -0400674 ACPI_DEBUGGER_EXEC(acpi_db_display_argument_object
675 (obj_desc, walk_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 }
677
Len Brown4be44fc2005-08-05 00:44:28 -0400678 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679}
680
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681/*******************************************************************************
682 *
683 * FUNCTION: acpi_ds_create_operands
684 *
685 * PARAMETERS: walk_state - Current state
686 * first_arg - First argument of a parser argument tree
687 *
688 * RETURN: Status
689 *
690 * DESCRIPTION: Convert an operator's arguments from a parse tree format to
691 * namespace objects and place those argument object on the object
692 * stack in preparation for evaluation by the interpreter.
693 *
694 ******************************************************************************/
695
696acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400697acpi_ds_create_operands(struct acpi_walk_state *walk_state,
698 union acpi_parse_object *first_arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699{
Len Brown4be44fc2005-08-05 00:44:28 -0400700 acpi_status status = AE_OK;
701 union acpi_parse_object *arg;
702 u32 arg_count = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703
Bob Mooreb229cf92006-04-21 17:15:00 -0400704 ACPI_FUNCTION_TRACE_PTR(ds_create_operands, first_arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
706 /* For all arguments in the list... */
707
708 arg = first_arg;
709 while (arg) {
Len Brown4be44fc2005-08-05 00:44:28 -0400710 status = acpi_ds_create_operand(walk_state, arg, arg_count);
711 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 goto cleanup;
713 }
714
Len Brown4be44fc2005-08-05 00:44:28 -0400715 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
716 "Arg #%d (%p) done, Arg1=%p\n", arg_count,
717 arg, first_arg));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
719 /* Move on to next argument, if any */
720
721 arg = arg->common.next;
722 arg_count++;
723 }
724
Len Brown4be44fc2005-08-05 00:44:28 -0400725 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
Len Brown4be44fc2005-08-05 00:44:28 -0400727 cleanup:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 /*
729 * We must undo everything done above; meaning that we must
730 * pop everything off of the operand stack and delete those
731 * objects
732 */
Len Brown4be44fc2005-08-05 00:44:28 -0400733 (void)acpi_ds_obj_stack_pop_and_delete(arg_count, walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
Bob Mooreb8e4d892006-01-27 16:43:00 -0500735 ACPI_EXCEPTION((AE_INFO, status, "While creating Arg %d",
736 (arg_count + 1)));
Len Brown4be44fc2005-08-05 00:44:28 -0400737 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738}