blob: 411731261c2986b2c19e01104bd0e48e89be6131 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/******************************************************************************
2 *
3 * Module Name: dswload - Dispatcher namespace load callbacks
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2005, R. Byron Moore
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
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/acevents.h>
51
Robert Moore73459f72005-06-24 00:00:00 -040052#ifdef ACPI_ASL_COMPILER
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <acpi/acdisasm.h>
54#endif
55
56#define _COMPONENT ACPI_DISPATCHER
Len Brown4be44fc2005-08-05 00:44:28 -040057ACPI_MODULE_NAME("dswload")
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
59/*******************************************************************************
60 *
61 * FUNCTION: acpi_ds_init_callbacks
62 *
63 * PARAMETERS: walk_state - Current state of the parse tree walk
64 * pass_number - 1, 2, or 3
65 *
66 * RETURN: Status
67 *
68 * DESCRIPTION: Init walk state callbacks
69 *
70 ******************************************************************************/
Linus Torvalds1da177e2005-04-16 15:20:36 -070071acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -040072acpi_ds_init_callbacks(struct acpi_walk_state *walk_state, u32 pass_number)
Linus Torvalds1da177e2005-04-16 15:20:36 -070073{
74
75 switch (pass_number) {
76 case 1:
Len Brown4be44fc2005-08-05 00:44:28 -040077 walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 |
78 ACPI_PARSE_DELETE_TREE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 walk_state->descending_callback = acpi_ds_load1_begin_op;
80 walk_state->ascending_callback = acpi_ds_load1_end_op;
81 break;
82
83 case 2:
Len Brown4be44fc2005-08-05 00:44:28 -040084 walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 |
85 ACPI_PARSE_DELETE_TREE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 walk_state->descending_callback = acpi_ds_load2_begin_op;
87 walk_state->ascending_callback = acpi_ds_load2_end_op;
88 break;
89
90 case 3:
91#ifndef ACPI_NO_METHOD_EXECUTION
Len Brown4be44fc2005-08-05 00:44:28 -040092 walk_state->parse_flags |= ACPI_PARSE_EXECUTE |
93 ACPI_PARSE_DELETE_TREE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 walk_state->descending_callback = acpi_ds_exec_begin_op;
95 walk_state->ascending_callback = acpi_ds_exec_end_op;
96#endif
97 break;
98
99 default:
100 return (AE_BAD_PARAMETER);
101 }
102
103 return (AE_OK);
104}
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106/*******************************************************************************
107 *
108 * FUNCTION: acpi_ds_load1_begin_op
109 *
110 * PARAMETERS: walk_state - Current state of the parse tree walk
Robert Moore44f6c012005-04-18 22:49:35 -0400111 * out_op - Where to return op if a new one is created
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 *
113 * RETURN: Status
114 *
115 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
116 *
117 ******************************************************************************/
118
119acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400120acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
121 union acpi_parse_object ** out_op)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122{
Len Brown4be44fc2005-08-05 00:44:28 -0400123 union acpi_parse_object *op;
124 struct acpi_namespace_node *node;
125 acpi_status status;
126 acpi_object_type object_type;
127 char *path;
128 u32 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129
Len Brown4be44fc2005-08-05 00:44:28 -0400130 ACPI_FUNCTION_NAME("ds_load1_begin_op");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
132 op = walk_state->op;
Len Brown4be44fc2005-08-05 00:44:28 -0400133 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
134 walk_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
136 /* We are only interested in opcodes that have an associated name */
137
138 if (op) {
139 if (!(walk_state->op_info->flags & AML_NAMED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 *out_op = op;
141 return (AE_OK);
142 }
143
144 /* Check if this object has already been installed in the namespace */
145
146 if (op->common.node) {
147 *out_op = op;
148 return (AE_OK);
149 }
150 }
151
Len Brown4be44fc2005-08-05 00:44:28 -0400152 path = acpi_ps_get_next_namestring(&walk_state->parser_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 /* Map the raw opcode into an internal object type */
155
156 object_type = walk_state->op_info->object_type;
157
Len Brown4be44fc2005-08-05 00:44:28 -0400158 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
159 "State=%p Op=%p [%s]\n", walk_state, op,
160 acpi_ut_get_type_name(object_type)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
162 switch (walk_state->opcode) {
163 case AML_SCOPE_OP:
164
165 /*
166 * The target name of the Scope() operator must exist at this point so
167 * that we can actually open the scope to enter new names underneath it.
168 * Allow search-to-root for single namesegs.
169 */
Len Brown4be44fc2005-08-05 00:44:28 -0400170 status =
171 acpi_ns_lookup(walk_state->scope_info, path, object_type,
172 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
173 walk_state, &(node));
Robert Moore73459f72005-06-24 00:00:00 -0400174#ifdef ACPI_ASL_COMPILER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 if (status == AE_NOT_FOUND) {
176 /*
177 * Table disassembly:
178 * Target of Scope() not found. Generate an External for it, and
179 * insert the name into the namespace.
180 */
Len Brown4be44fc2005-08-05 00:44:28 -0400181 acpi_dm_add_to_external_list(path);
182 status =
183 acpi_ns_lookup(walk_state->scope_info, path,
184 object_type, ACPI_IMODE_LOAD_PASS1,
185 ACPI_NS_SEARCH_PARENT, walk_state,
186 &(node));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 }
188#endif
Len Brown4be44fc2005-08-05 00:44:28 -0400189 if (ACPI_FAILURE(status)) {
190 ACPI_REPORT_NSERROR(path, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 return (status);
192 }
193
194 /*
195 * Check to make sure that the target is
196 * one of the opcodes that actually opens a scope
197 */
198 switch (node->type) {
Len Brown4be44fc2005-08-05 00:44:28 -0400199 case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 case ACPI_TYPE_DEVICE:
201 case ACPI_TYPE_POWER:
202 case ACPI_TYPE_PROCESSOR:
203 case ACPI_TYPE_THERMAL:
204
205 /* These are acceptable types */
206 break;
207
208 case ACPI_TYPE_INTEGER:
209 case ACPI_TYPE_STRING:
210 case ACPI_TYPE_BUFFER:
211
212 /*
213 * These types we will allow, but we will change the type. This
214 * enables some existing code of the form:
215 *
216 * Name (DEB, 0)
217 * Scope (DEB) { ... }
218 *
Robert Moore44f6c012005-04-18 22:49:35 -0400219 * Note: silently change the type here. On the second pass, we will report
220 * a warning
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 */
222
Len Brown4be44fc2005-08-05 00:44:28 -0400223 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
224 "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
225 path,
226 acpi_ut_get_type_name(node->type)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
228 node->type = ACPI_TYPE_ANY;
229 walk_state->scope_info->common.value = ACPI_TYPE_ANY;
230 break;
231
232 default:
233
234 /* All other types are an error */
235
Len Brown4be44fc2005-08-05 00:44:28 -0400236 ACPI_REPORT_ERROR(("Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)\n", acpi_ut_get_type_name(node->type), path));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
238 return (AE_AML_OPERAND_TYPE);
239 }
240 break;
241
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 default:
243
244 /*
Robert Moore44f6c012005-04-18 22:49:35 -0400245 * For all other named opcodes, we will enter the name into
246 * the namespace.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 *
248 * Setup the search flags.
249 * Since we are entering a name into the namespace, we do not want to
250 * enable the search-to-root upsearch.
251 *
252 * There are only two conditions where it is acceptable that the name
253 * already exists:
254 * 1) the Scope() operator can reopen a scoping object that was
255 * previously defined (Scope, Method, Device, etc.)
256 * 2) Whenever we are parsing a deferred opcode (op_region, Buffer,
257 * buffer_field, or Package), the name of the object is already
258 * in the namespace.
259 */
260 if (walk_state->deferred_node) {
261 /* This name is already in the namespace, get the node */
262
263 node = walk_state->deferred_node;
264 status = AE_OK;
265 break;
266 }
267
268 flags = ACPI_NS_NO_UPSEARCH;
269 if ((walk_state->opcode != AML_SCOPE_OP) &&
Len Brown4be44fc2005-08-05 00:44:28 -0400270 (!(walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 flags |= ACPI_NS_ERROR_IF_FOUND;
Len Brown4be44fc2005-08-05 00:44:28 -0400272 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
273 "[%s] Cannot already exist\n",
274 acpi_ut_get_type_name(object_type)));
275 } else {
276 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
277 "[%s] Both Find or Create allowed\n",
278 acpi_ut_get_type_name(object_type)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 }
280
281 /*
282 * Enter the named type into the internal namespace. We enter the name
Robert Moore44f6c012005-04-18 22:49:35 -0400283 * as we go downward in the parse tree. Any necessary subobjects that
284 * involve arguments to the opcode must be created as we go back up the
285 * parse tree later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 */
Len Brown4be44fc2005-08-05 00:44:28 -0400287 status =
288 acpi_ns_lookup(walk_state->scope_info, path, object_type,
289 ACPI_IMODE_LOAD_PASS1, flags, walk_state,
290 &(node));
291 if (ACPI_FAILURE(status)) {
292 ACPI_REPORT_NSERROR(path, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 return (status);
294 }
295 break;
296 }
297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 /* Common exit */
299
300 if (!op) {
301 /* Create a new op */
302
Len Brown4be44fc2005-08-05 00:44:28 -0400303 op = acpi_ps_alloc_op(walk_state->opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 if (!op) {
305 return (AE_NO_MEMORY);
306 }
307 }
308
309 /* Initialize */
310
311 op->named.name = node->name.integer;
312
313#if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
314 op->named.path = (u8 *) path;
315#endif
316
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 /*
318 * Put the Node in the "op" object that the parser uses, so we
319 * can get it again quickly when this scope is closed
320 */
321 op->common.node = node;
Len Brown4be44fc2005-08-05 00:44:28 -0400322 acpi_ps_append_arg(acpi_ps_get_parent_scope(&walk_state->parser_state),
323 op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
325 *out_op = op;
326 return (status);
327}
328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329/*******************************************************************************
330 *
331 * FUNCTION: acpi_ds_load1_end_op
332 *
333 * PARAMETERS: walk_state - Current state of the parse tree walk
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 *
335 * RETURN: Status
336 *
337 * DESCRIPTION: Ascending callback used during the loading of the namespace,
338 * both control methods and everything else.
339 *
340 ******************************************************************************/
341
Len Brown4be44fc2005-08-05 00:44:28 -0400342acpi_status acpi_ds_load1_end_op(struct acpi_walk_state * walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
Len Brown4be44fc2005-08-05 00:44:28 -0400344 union acpi_parse_object *op;
345 acpi_object_type object_type;
346 acpi_status status = AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
Len Brown4be44fc2005-08-05 00:44:28 -0400348 ACPI_FUNCTION_NAME("ds_load1_end_op");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349
350 op = walk_state->op;
Len Brown4be44fc2005-08-05 00:44:28 -0400351 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
352 walk_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
354 /* We are only interested in opcodes that have an associated name */
355
356 if (!(walk_state->op_info->flags & (AML_NAMED | AML_FIELD))) {
357 return (AE_OK);
358 }
359
360 /* Get the object type to determine if we should pop the scope */
361
362 object_type = walk_state->op_info->object_type;
363
364#ifndef ACPI_NO_METHOD_EXECUTION
365 if (walk_state->op_info->flags & AML_FIELD) {
Len Brown4be44fc2005-08-05 00:44:28 -0400366 if (walk_state->opcode == AML_FIELD_OP ||
367 walk_state->opcode == AML_BANK_FIELD_OP ||
368 walk_state->opcode == AML_INDEX_FIELD_OP) {
369 status = acpi_ds_init_field_objects(op, walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 }
371 return (status);
372 }
373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 if (op->common.aml_opcode == AML_REGION_OP) {
Len Brown4be44fc2005-08-05 00:44:28 -0400375 status = acpi_ex_create_region(op->named.data, op->named.length,
376 (acpi_adr_space_type)
377 ((op->common.value.arg)->common.
378 value.integer), walk_state);
379 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 return (status);
381 }
382 }
383#endif
384
385 if (op->common.aml_opcode == AML_NAME_OP) {
386 /* For Name opcode, get the object type from the argument */
387
388 if (op->common.value.arg) {
Len Brown4be44fc2005-08-05 00:44:28 -0400389 object_type = (acpi_ps_get_opcode_info((op->common.
390 value.arg)->
391 common.
392 aml_opcode))->
393 object_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 op->common.node->type = (u8) object_type;
395 }
396 }
397
398 if (op->common.aml_opcode == AML_METHOD_OP) {
399 /*
400 * method_op pkg_length name_string method_flags term_list
401 *
402 * Note: We must create the method node/object pair as soon as we
403 * see the method declaration. This allows later pass1 parsing
404 * of invocations of the method (need to know the number of
405 * arguments.)
406 */
Len Brown4be44fc2005-08-05 00:44:28 -0400407 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
408 "LOADING-Method: State=%p Op=%p named_obj=%p\n",
409 walk_state, op, op->named.node));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Len Brown4be44fc2005-08-05 00:44:28 -0400411 if (!acpi_ns_get_attached_object(op->named.node)) {
412 walk_state->operands[0] = (void *)op->named.node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 walk_state->num_operands = 1;
414
Len Brown4be44fc2005-08-05 00:44:28 -0400415 status =
416 acpi_ds_create_operands(walk_state,
417 op->common.value.arg);
418 if (ACPI_SUCCESS(status)) {
419 status = acpi_ex_create_method(op->named.data,
420 op->named.length,
421 walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 }
423 walk_state->operands[0] = NULL;
424 walk_state->num_operands = 0;
425
Len Brown4be44fc2005-08-05 00:44:28 -0400426 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 return (status);
428 }
429 }
430 }
431
432 /* Pop the scope stack */
433
Len Brown4be44fc2005-08-05 00:44:28 -0400434 if (acpi_ns_opens_scope(object_type)) {
435 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
436 "(%s): Popping scope for Op %p\n",
437 acpi_ut_get_type_name(object_type), op));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
Len Brown4be44fc2005-08-05 00:44:28 -0400439 status = acpi_ds_scope_stack_pop(walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 }
441
442 return (status);
443}
444
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445/*******************************************************************************
446 *
447 * FUNCTION: acpi_ds_load2_begin_op
448 *
449 * PARAMETERS: walk_state - Current state of the parse tree walk
Robert Moore44f6c012005-04-18 22:49:35 -0400450 * out_op - Wher to return op if a new one is created
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 *
452 * RETURN: Status
453 *
454 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
455 *
456 ******************************************************************************/
457
458acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400459acpi_ds_load2_begin_op(struct acpi_walk_state * walk_state,
460 union acpi_parse_object ** out_op)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461{
Len Brown4be44fc2005-08-05 00:44:28 -0400462 union acpi_parse_object *op;
463 struct acpi_namespace_node *node;
464 acpi_status status;
465 acpi_object_type object_type;
466 char *buffer_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Len Brown4be44fc2005-08-05 00:44:28 -0400468 ACPI_FUNCTION_TRACE("ds_load2_begin_op");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
470 op = walk_state->op;
Len Brown4be44fc2005-08-05 00:44:28 -0400471 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
472 walk_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
474 if (op) {
Robert Moore88ac00f2005-05-26 00:00:00 -0400475 if ((walk_state->control_state) &&
Len Brown4be44fc2005-08-05 00:44:28 -0400476 (walk_state->control_state->common.state ==
477 ACPI_CONTROL_CONDITIONAL_EXECUTING)) {
Robert Moore88ac00f2005-05-26 00:00:00 -0400478 /* We are executing a while loop outside of a method */
479
Len Brown4be44fc2005-08-05 00:44:28 -0400480 status = acpi_ds_exec_begin_op(walk_state, out_op);
481 return_ACPI_STATUS(status);
Robert Moore88ac00f2005-05-26 00:00:00 -0400482 }
483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 /* We only care about Namespace opcodes here */
485
Robert Moore44f6c012005-04-18 22:49:35 -0400486 if ((!(walk_state->op_info->flags & AML_NSOPCODE) &&
Len Brown4be44fc2005-08-05 00:44:28 -0400487 (walk_state->opcode != AML_INT_NAMEPATH_OP)) ||
488 (!(walk_state->op_info->flags & AML_NAMED))) {
Robert Mooreaff8c272005-09-02 17:24:17 -0400489#ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
Robert Moore44f6c012005-04-18 22:49:35 -0400490 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
Len Brown4be44fc2005-08-05 00:44:28 -0400491 (walk_state->op_info->class == AML_CLASS_CONTROL)) {
Robert Mooreaff8c272005-09-02 17:24:17 -0400492
Len Brown4be44fc2005-08-05 00:44:28 -0400493 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
494 "Begin/EXEC: %s (fl %8.8X)\n",
495 walk_state->op_info->name,
496 walk_state->op_info->flags));
Robert Moore88ac00f2005-05-26 00:00:00 -0400497
498 /* Executing a type1 or type2 opcode outside of a method */
499
Len Brown4be44fc2005-08-05 00:44:28 -0400500 status =
501 acpi_ds_exec_begin_op(walk_state, out_op);
502 return_ACPI_STATUS(status);
Robert Moore44f6c012005-04-18 22:49:35 -0400503 }
Robert Mooreaff8c272005-09-02 17:24:17 -0400504#endif
Len Brown4be44fc2005-08-05 00:44:28 -0400505 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 }
507
Robert Moore44f6c012005-04-18 22:49:35 -0400508 /* Get the name we are going to enter or lookup in the namespace */
509
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
511 /* For Namepath op, get the path string */
512
513 buffer_ptr = op->common.value.string;
514 if (!buffer_ptr) {
515 /* No name, just exit */
516
Len Brown4be44fc2005-08-05 00:44:28 -0400517 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 }
Len Brown4be44fc2005-08-05 00:44:28 -0400519 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 /* Get name from the op */
521
Len Brown4be44fc2005-08-05 00:44:28 -0400522 buffer_ptr = (char *)&op->named.name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 }
Len Brown4be44fc2005-08-05 00:44:28 -0400524 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 /* Get the namestring from the raw AML */
526
Len Brown4be44fc2005-08-05 00:44:28 -0400527 buffer_ptr =
528 acpi_ps_get_next_namestring(&walk_state->parser_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 }
530
531 /* Map the opcode into an internal object type */
532
533 object_type = walk_state->op_info->object_type;
534
Len Brown4be44fc2005-08-05 00:44:28 -0400535 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
536 "State=%p Op=%p Type=%X\n", walk_state, op,
537 object_type));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
539 switch (walk_state->opcode) {
540 case AML_FIELD_OP:
541 case AML_BANK_FIELD_OP:
542 case AML_INDEX_FIELD_OP:
543
544 node = NULL;
545 status = AE_OK;
546 break;
547
548 case AML_INT_NAMEPATH_OP:
549
550 /*
Robert Moore44f6c012005-04-18 22:49:35 -0400551 * The name_path is an object reference to an existing object.
552 * Don't enter the name into the namespace, but look it up
553 * for use later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 */
Len Brown4be44fc2005-08-05 00:44:28 -0400555 status =
556 acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
557 object_type, ACPI_IMODE_EXECUTE,
558 ACPI_NS_SEARCH_PARENT, walk_state, &(node));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 break;
560
561 case AML_SCOPE_OP:
562
563 /*
Robert Moore44f6c012005-04-18 22:49:35 -0400564 * The Path is an object reference to an existing object.
565 * Don't enter the name into the namespace, but look it up
566 * for use later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 */
Len Brown4be44fc2005-08-05 00:44:28 -0400568 status =
569 acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
570 object_type, ACPI_IMODE_EXECUTE,
571 ACPI_NS_SEARCH_PARENT, walk_state, &(node));
572 if (ACPI_FAILURE(status)) {
Robert Moore73459f72005-06-24 00:00:00 -0400573#ifdef ACPI_ASL_COMPILER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 if (status == AE_NOT_FOUND) {
575 status = AE_OK;
Len Brown4be44fc2005-08-05 00:44:28 -0400576 } else {
577 ACPI_REPORT_NSERROR(buffer_ptr, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 }
579#else
Len Brown4be44fc2005-08-05 00:44:28 -0400580 ACPI_REPORT_NSERROR(buffer_ptr, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581#endif
Len Brown4be44fc2005-08-05 00:44:28 -0400582 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 }
584 /*
585 * We must check to make sure that the target is
586 * one of the opcodes that actually opens a scope
587 */
588 switch (node->type) {
Len Brown4be44fc2005-08-05 00:44:28 -0400589 case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 case ACPI_TYPE_DEVICE:
591 case ACPI_TYPE_POWER:
592 case ACPI_TYPE_PROCESSOR:
593 case ACPI_TYPE_THERMAL:
594
595 /* These are acceptable types */
596 break;
597
598 case ACPI_TYPE_INTEGER:
599 case ACPI_TYPE_STRING:
600 case ACPI_TYPE_BUFFER:
601
602 /*
603 * These types we will allow, but we will change the type. This
604 * enables some existing code of the form:
605 *
606 * Name (DEB, 0)
607 * Scope (DEB) { ... }
608 */
609
Len Brown4be44fc2005-08-05 00:44:28 -0400610 ACPI_REPORT_WARNING(("Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n", buffer_ptr, acpi_ut_get_type_name(node->type)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
612 node->type = ACPI_TYPE_ANY;
613 walk_state->scope_info->common.value = ACPI_TYPE_ANY;
614 break;
615
616 default:
617
618 /* All other types are an error */
619
Len Brown4be44fc2005-08-05 00:44:28 -0400620 ACPI_REPORT_ERROR(("Invalid type (%s) for target of Scope operator [%4.4s]\n", acpi_ut_get_type_name(node->type), buffer_ptr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
622 return (AE_AML_OPERAND_TYPE);
623 }
624 break;
625
626 default:
627
628 /* All other opcodes */
629
630 if (op && op->common.node) {
631 /* This op/node was previously entered into the namespace */
632
633 node = op->common.node;
634
Len Brown4be44fc2005-08-05 00:44:28 -0400635 if (acpi_ns_opens_scope(object_type)) {
636 status =
637 acpi_ds_scope_stack_push(node, object_type,
638 walk_state);
639 if (ACPI_FAILURE(status)) {
640 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 }
642
643 }
Len Brown4be44fc2005-08-05 00:44:28 -0400644 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 }
646
647 /*
648 * Enter the named type into the internal namespace. We enter the name
Robert Moore44f6c012005-04-18 22:49:35 -0400649 * as we go downward in the parse tree. Any necessary subobjects that
650 * involve arguments to the opcode must be created as we go back up the
651 * parse tree later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 *
653 * Note: Name may already exist if we are executing a deferred opcode.
654 */
655 if (walk_state->deferred_node) {
656 /* This name is already in the namespace, get the node */
657
658 node = walk_state->deferred_node;
659 status = AE_OK;
660 break;
661 }
662
Robert Moore88ac00f2005-05-26 00:00:00 -0400663 /* Add new entry into namespace */
664
Len Brown4be44fc2005-08-05 00:44:28 -0400665 status =
666 acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
667 object_type, ACPI_IMODE_LOAD_PASS2,
668 ACPI_NS_NO_UPSEARCH, walk_state, &(node));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 break;
670 }
671
Len Brown4be44fc2005-08-05 00:44:28 -0400672 if (ACPI_FAILURE(status)) {
673 ACPI_REPORT_NSERROR(buffer_ptr, status);
674 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 }
676
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 if (!op) {
678 /* Create a new op */
679
Len Brown4be44fc2005-08-05 00:44:28 -0400680 op = acpi_ps_alloc_op(walk_state->opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 if (!op) {
Len Brown4be44fc2005-08-05 00:44:28 -0400682 return_ACPI_STATUS(AE_NO_MEMORY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 }
684
685 /* Initialize the new op */
686
687 if (node) {
688 op->named.name = node->name.integer;
689 }
Robert Moore88ac00f2005-05-26 00:00:00 -0400690 *out_op = op;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 }
692
693 /*
694 * Put the Node in the "op" object that the parser uses, so we
695 * can get it again quickly when this scope is closed
696 */
697 op->common.node = node;
698
Len Brown4be44fc2005-08-05 00:44:28 -0400699 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700}
701
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702/*******************************************************************************
703 *
704 * FUNCTION: acpi_ds_load2_end_op
705 *
706 * PARAMETERS: walk_state - Current state of the parse tree walk
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 *
708 * RETURN: Status
709 *
710 * DESCRIPTION: Ascending callback used during the loading of the namespace,
711 * both control methods and everything else.
712 *
713 ******************************************************************************/
714
Len Brown4be44fc2005-08-05 00:44:28 -0400715acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716{
Len Brown4be44fc2005-08-05 00:44:28 -0400717 union acpi_parse_object *op;
718 acpi_status status = AE_OK;
719 acpi_object_type object_type;
720 struct acpi_namespace_node *node;
721 union acpi_parse_object *arg;
722 struct acpi_namespace_node *new_node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723#ifndef ACPI_NO_METHOD_EXECUTION
Len Brown4be44fc2005-08-05 00:44:28 -0400724 u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725#endif
726
Len Brown4be44fc2005-08-05 00:44:28 -0400727 ACPI_FUNCTION_TRACE("ds_load2_end_op");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729 op = walk_state->op;
Len Brown4be44fc2005-08-05 00:44:28 -0400730 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
731 walk_state->op_info->name, op, walk_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
Robert Moore88ac00f2005-05-26 00:00:00 -0400733 /* Check if opcode had an associated namespace object */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
735 if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
Robert Moore88ac00f2005-05-26 00:00:00 -0400736#ifndef ACPI_NO_METHOD_EXECUTION
Robert Mooreaff8c272005-09-02 17:24:17 -0400737#ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
Robert Moore88ac00f2005-05-26 00:00:00 -0400738 /* No namespace object. Executable opcode? */
739
740 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
Len Brown4be44fc2005-08-05 00:44:28 -0400741 (walk_state->op_info->class == AML_CLASS_CONTROL)) {
742 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
743 "End/EXEC: %s (fl %8.8X)\n",
744 walk_state->op_info->name,
745 walk_state->op_info->flags));
Robert Moore88ac00f2005-05-26 00:00:00 -0400746
747 /* Executing a type1 or type2 opcode outside of a method */
748
Len Brown4be44fc2005-08-05 00:44:28 -0400749 status = acpi_ds_exec_end_op(walk_state);
750 return_ACPI_STATUS(status);
Robert Moore88ac00f2005-05-26 00:00:00 -0400751 }
752#endif
Robert Mooreaff8c272005-09-02 17:24:17 -0400753#endif
Len Brown4be44fc2005-08-05 00:44:28 -0400754 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 }
756
757 if (op->common.aml_opcode == AML_SCOPE_OP) {
Len Brown4be44fc2005-08-05 00:44:28 -0400758 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
759 "Ending scope Op=%p State=%p\n", op,
760 walk_state));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 }
762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 object_type = walk_state->op_info->object_type;
764
765 /*
766 * Get the Node/name from the earlier lookup
767 * (It was saved in the *op structure)
768 */
769 node = op->common.node;
770
771 /*
772 * Put the Node on the object stack (Contains the ACPI Name of
773 * this object)
774 */
Len Brown4be44fc2005-08-05 00:44:28 -0400775 walk_state->operands[0] = (void *)node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 walk_state->num_operands = 1;
777
778 /* Pop the scope stack */
779
Len Brown4be44fc2005-08-05 00:44:28 -0400780 if (acpi_ns_opens_scope(object_type) &&
781 (op->common.aml_opcode != AML_INT_METHODCALL_OP)) {
782 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
783 "(%s) Popping scope for Op %p\n",
784 acpi_ut_get_type_name(object_type), op));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Len Brown4be44fc2005-08-05 00:44:28 -0400786 status = acpi_ds_scope_stack_pop(walk_state);
787 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 goto cleanup;
789 }
790 }
791
792 /*
793 * Named operations are as follows:
794 *
795 * AML_ALIAS
796 * AML_BANKFIELD
797 * AML_CREATEBITFIELD
798 * AML_CREATEBYTEFIELD
799 * AML_CREATEDWORDFIELD
800 * AML_CREATEFIELD
801 * AML_CREATEQWORDFIELD
802 * AML_CREATEWORDFIELD
803 * AML_DATA_REGION
804 * AML_DEVICE
805 * AML_EVENT
806 * AML_FIELD
807 * AML_INDEXFIELD
808 * AML_METHOD
809 * AML_METHODCALL
810 * AML_MUTEX
811 * AML_NAME
812 * AML_NAMEDFIELD
813 * AML_OPREGION
814 * AML_POWERRES
815 * AML_PROCESSOR
816 * AML_SCOPE
817 * AML_THERMALZONE
818 */
819
Len Brown4be44fc2005-08-05 00:44:28 -0400820 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
821 "Create-Load [%s] State=%p Op=%p named_obj=%p\n",
822 acpi_ps_get_opcode_name(op->common.aml_opcode),
823 walk_state, op, node));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 /* Decode the opcode */
826
827 arg = op->common.value.arg;
828
829 switch (walk_state->op_info->type) {
830#ifndef ACPI_NO_METHOD_EXECUTION
831
832 case AML_TYPE_CREATE_FIELD:
833
834 /*
835 * Create the field object, but the field buffer and index must
836 * be evaluated later during the execution phase
837 */
Len Brown4be44fc2005-08-05 00:44:28 -0400838 status = acpi_ds_create_buffer_field(op, walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 break;
840
Len Brown4be44fc2005-08-05 00:44:28 -0400841 case AML_TYPE_NAMED_FIELD:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
843 switch (op->common.aml_opcode) {
844 case AML_INDEX_FIELD_OP:
845
Len Brown4be44fc2005-08-05 00:44:28 -0400846 status =
847 acpi_ds_create_index_field(op,
848 (acpi_handle) arg->
849 common.node, walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 break;
851
852 case AML_BANK_FIELD_OP:
853
Len Brown4be44fc2005-08-05 00:44:28 -0400854 status =
855 acpi_ds_create_bank_field(op, arg->common.node,
856 walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 break;
858
859 case AML_FIELD_OP:
860
Len Brown4be44fc2005-08-05 00:44:28 -0400861 status =
862 acpi_ds_create_field(op, arg->common.node,
863 walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 break;
865
866 default:
867 /* All NAMED_FIELD opcodes must be handled above */
868 break;
869 }
870 break;
871
Len Brown4be44fc2005-08-05 00:44:28 -0400872 case AML_TYPE_NAMED_SIMPLE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
Len Brown4be44fc2005-08-05 00:44:28 -0400874 status = acpi_ds_create_operands(walk_state, arg);
875 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 goto cleanup;
877 }
878
879 switch (op->common.aml_opcode) {
880 case AML_PROCESSOR_OP:
881
Len Brown4be44fc2005-08-05 00:44:28 -0400882 status = acpi_ex_create_processor(walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 break;
884
885 case AML_POWER_RES_OP:
886
Len Brown4be44fc2005-08-05 00:44:28 -0400887 status = acpi_ex_create_power_resource(walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 break;
889
890 case AML_MUTEX_OP:
891
Len Brown4be44fc2005-08-05 00:44:28 -0400892 status = acpi_ex_create_mutex(walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 break;
894
895 case AML_EVENT_OP:
896
Len Brown4be44fc2005-08-05 00:44:28 -0400897 status = acpi_ex_create_event(walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 break;
899
900 case AML_DATA_REGION_OP:
901
Len Brown4be44fc2005-08-05 00:44:28 -0400902 status = acpi_ex_create_table_region(walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 break;
904
905 case AML_ALIAS_OP:
906
Len Brown4be44fc2005-08-05 00:44:28 -0400907 status = acpi_ex_create_alias(walk_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 break;
909
910 default:
911 /* Unknown opcode */
912
913 status = AE_OK;
914 goto cleanup;
915 }
916
917 /* Delete operands */
918
919 for (i = 1; i < walk_state->num_operands; i++) {
Len Brown4be44fc2005-08-05 00:44:28 -0400920 acpi_ut_remove_reference(walk_state->operands[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 walk_state->operands[i] = NULL;
922 }
923
924 break;
Len Brown4be44fc2005-08-05 00:44:28 -0400925#endif /* ACPI_NO_METHOD_EXECUTION */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
927 case AML_TYPE_NAMED_COMPLEX:
928
929 switch (op->common.aml_opcode) {
930#ifndef ACPI_NO_METHOD_EXECUTION
931 case AML_REGION_OP:
932 /*
Robert Moore44f6c012005-04-18 22:49:35 -0400933 * The op_region is not fully parsed at this time. Only valid
934 * argument is the space_id. (We must save the address of the
935 * AML of the address and length operands)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 */
937 /*
938 * If we have a valid region, initialize it
939 * Namespace is NOT locked at this point.
940 */
Len Brown4be44fc2005-08-05 00:44:28 -0400941 status =
942 acpi_ev_initialize_region
943 (acpi_ns_get_attached_object(node), FALSE);
944 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 /*
946 * If AE_NOT_EXIST is returned, it is not fatal
947 * because many regions get created before a handler
948 * is installed for said region.
949 */
950 if (AE_NOT_EXIST == status) {
951 status = AE_OK;
952 }
953 }
954 break;
955
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 case AML_NAME_OP:
957
Len Brown4be44fc2005-08-05 00:44:28 -0400958 status = acpi_ds_create_node(walk_state, node, op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 break;
Len Brown4be44fc2005-08-05 00:44:28 -0400960#endif /* ACPI_NO_METHOD_EXECUTION */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
962 default:
963 /* All NAMED_COMPLEX opcodes must be handled above */
964 /* Note: Method objects were already created in Pass 1 */
965 break;
966 }
967 break;
968
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 case AML_CLASS_INTERNAL:
970
971 /* case AML_INT_NAMEPATH_OP: */
972 break;
973
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 case AML_CLASS_METHOD_CALL:
975
Len Brown4be44fc2005-08-05 00:44:28 -0400976 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
977 "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
978 walk_state, op, node));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
980 /*
981 * Lookup the method name and save the Node
982 */
Len Brown4be44fc2005-08-05 00:44:28 -0400983 status =
984 acpi_ns_lookup(walk_state->scope_info,
985 arg->common.value.string, ACPI_TYPE_ANY,
986 ACPI_IMODE_LOAD_PASS2,
987 ACPI_NS_SEARCH_PARENT |
988 ACPI_NS_DONT_OPEN_SCOPE, walk_state,
989 &(new_node));
990 if (ACPI_SUCCESS(status)) {
Len Brownbd6dbdf2005-08-04 00:17:42 -0400991
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 /*
993 * Make sure that what we found is indeed a method
Robert Moore44f6c012005-04-18 22:49:35 -0400994 * We didn't search for a method on purpose, to see if the name
995 * would resolve
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 */
997 if (new_node->type != ACPI_TYPE_METHOD) {
998 status = AE_AML_OPERAND_TYPE;
999 }
1000
Robert Moore44f6c012005-04-18 22:49:35 -04001001 /* We could put the returned object (Node) on the object stack for
1002 * later, but for now, we will put it in the "op" object that the
1003 * parser uses, so we can get it again at the end of this scope
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 */
1005 op->common.node = new_node;
Len Brown4be44fc2005-08-05 00:44:28 -04001006 } else {
1007 ACPI_REPORT_NSERROR(arg->common.value.string, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 }
1009 break;
1010
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 default:
1012 break;
1013 }
1014
Len Brown4be44fc2005-08-05 00:44:28 -04001015 cleanup:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016
1017 /* Remove the Node pushed at the very beginning */
1018
1019 walk_state->operands[0] = NULL;
1020 walk_state->num_operands = 0;
Len Brown4be44fc2005-08-05 00:44:28 -04001021 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022}