Branch data Line data Source code
1 : : // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 : : /******************************************************************************
3 : : *
4 : : * Module Name: dswload2 - Dispatcher second pass namespace load callbacks
5 : : *
6 : : * Copyright (C) 2000 - 2020, Intel Corp.
7 : : *
8 : : *****************************************************************************/
9 : :
10 : : #include <acpi/acpi.h>
11 : : #include "accommon.h"
12 : : #include "acparser.h"
13 : : #include "amlcode.h"
14 : : #include "acdispat.h"
15 : : #include "acinterp.h"
16 : : #include "acnamesp.h"
17 : : #include "acevents.h"
18 : :
19 : : #define _COMPONENT ACPI_DISPATCHER
20 : : ACPI_MODULE_NAME("dswload2")
21 : :
22 : : /*******************************************************************************
23 : : *
24 : : * FUNCTION: acpi_ds_load2_begin_op
25 : : *
26 : : * PARAMETERS: walk_state - Current state of the parse tree walk
27 : : * out_op - Where to return op if a new one is created
28 : : *
29 : : * RETURN: Status
30 : : *
31 : : * DESCRIPTION: Descending callback used during the loading of ACPI tables.
32 : : *
33 : : ******************************************************************************/
34 : : acpi_status
35 : 10230 : acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
36 : : union acpi_parse_object **out_op)
37 : : {
38 : 10230 : union acpi_parse_object *op;
39 : 10230 : struct acpi_namespace_node *node;
40 : 10230 : acpi_status status;
41 : 10230 : acpi_object_type object_type;
42 : 10230 : char *buffer_ptr;
43 : 10230 : u32 flags;
44 : :
45 : 10230 : ACPI_FUNCTION_TRACE(ds_load2_begin_op);
46 : :
47 : 10230 : op = walk_state->op;
48 : : ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
49 : 10230 : walk_state));
50 : :
51 [ + + ]: 10230 : if (op) {
52 [ + + ]: 7040 : if ((walk_state->control_state) &&
53 [ - + ]: 2838 : (walk_state->control_state->common.state ==
54 : : ACPI_CONTROL_CONDITIONAL_EXECUTING)) {
55 : :
56 : : /* We are executing a while loop outside of a method */
57 : :
58 : 0 : status = acpi_ds_exec_begin_op(walk_state, out_op);
59 : 0 : return_ACPI_STATUS(status);
60 : : }
61 : :
62 : : /* We only care about Namespace opcodes here */
63 : :
64 [ + + ]: 7040 : if ((!(walk_state->op_info->flags & AML_NSOPCODE) &&
65 [ + - + + ]: 7040 : (walk_state->opcode != AML_INT_NAMEPATH_OP)) ||
66 : : (!(walk_state->op_info->flags & AML_NAMED))) {
67 : : return_ACPI_STATUS(AE_OK);
68 : : }
69 : :
70 : : /* Get the name we are going to enter or lookup in the namespace */
71 : :
72 [ - + ]: 3014 : if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
73 : :
74 : : /* For Namepath op, get the path string */
75 : :
76 : 0 : buffer_ptr = op->common.value.string;
77 [ # # ]: 0 : if (!buffer_ptr) {
78 : :
79 : : /* No name, just exit */
80 : :
81 : : return_ACPI_STATUS(AE_OK);
82 : : }
83 : : } else {
84 : : /* Get name from the op */
85 : :
86 : 3014 : buffer_ptr = ACPI_CAST_PTR(char, &op->named.name);
87 : : }
88 : : } else {
89 : : /* Get the namestring from the raw AML */
90 : :
91 : 3190 : buffer_ptr =
92 : 3190 : acpi_ps_get_next_namestring(&walk_state->parser_state);
93 : : }
94 : :
95 : : /* Map the opcode into an internal object type */
96 : :
97 : 6204 : object_type = walk_state->op_info->object_type;
98 : :
99 : : ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
100 : : "State=%p Op=%p Type=%X\n", walk_state, op,
101 : 6204 : object_type));
102 : :
103 [ - - + + ]: 6204 : switch (walk_state->opcode) {
104 : 0 : case AML_FIELD_OP:
105 : : case AML_BANK_FIELD_OP:
106 : : case AML_INDEX_FIELD_OP:
107 : :
108 : 0 : node = NULL;
109 : 0 : status = AE_OK;
110 : 0 : break;
111 : :
112 : 0 : case AML_INT_NAMEPATH_OP:
113 : : /*
114 : : * The name_path is an object reference to an existing object.
115 : : * Don't enter the name into the namespace, but look it up
116 : : * for use later.
117 : : */
118 : 0 : status =
119 : 0 : acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
120 : : object_type, ACPI_IMODE_EXECUTE,
121 : : ACPI_NS_SEARCH_PARENT, walk_state, &(node));
122 : 0 : break;
123 : :
124 : 176 : case AML_SCOPE_OP:
125 : :
126 : : /* Special case for Scope(\) -> refers to the Root node */
127 : :
128 [ - + - - ]: 176 : if (op && (op->named.node == acpi_gbl_root_node)) {
129 : 0 : node = op->named.node;
130 : :
131 : 0 : status =
132 : 0 : acpi_ds_scope_stack_push(node, object_type,
133 : : walk_state);
134 [ # # ]: 0 : if (ACPI_FAILURE(status)) {
135 : : return_ACPI_STATUS(status);
136 : : }
137 : : } else {
138 : : /*
139 : : * The Path is an object reference to an existing object.
140 : : * Don't enter the name into the namespace, but look it up
141 : : * for use later.
142 : : */
143 : 176 : status =
144 : 176 : acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
145 : : object_type, ACPI_IMODE_EXECUTE,
146 : : ACPI_NS_SEARCH_PARENT, walk_state,
147 : : &(node));
148 [ - + ]: 176 : if (ACPI_FAILURE(status)) {
149 : : #ifdef ACPI_ASL_COMPILER
150 : : if (status == AE_NOT_FOUND) {
151 : : status = AE_OK;
152 : : } else {
153 : : ACPI_ERROR_NAMESPACE(walk_state->
154 : : scope_info,
155 : : buffer_ptr,
156 : : status);
157 : : }
158 : : #else
159 : 0 : ACPI_ERROR_NAMESPACE(walk_state->scope_info,
160 : 0 : buffer_ptr, status);
161 : : #endif
162 : 0 : return_ACPI_STATUS(status);
163 : : }
164 : : }
165 : :
166 : : /*
167 : : * We must check to make sure that the target is
168 : : * one of the opcodes that actually opens a scope
169 : : */
170 [ - - - + ]: 176 : switch (node->type) {
171 : : case ACPI_TYPE_ANY:
172 : : case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
173 : : case ACPI_TYPE_DEVICE:
174 : : case ACPI_TYPE_POWER:
175 : : case ACPI_TYPE_PROCESSOR:
176 : : case ACPI_TYPE_THERMAL:
177 : :
178 : : /* These are acceptable types */
179 : : break;
180 : :
181 : 0 : case ACPI_TYPE_INTEGER:
182 : : case ACPI_TYPE_STRING:
183 : : case ACPI_TYPE_BUFFER:
184 : :
185 : : /*
186 : : * These types we will allow, but we will change the type.
187 : : * This enables some existing code of the form:
188 : : *
189 : : * Name (DEB, 0)
190 : : * Scope (DEB) { ... }
191 : : */
192 : 0 : ACPI_WARNING((AE_INFO,
193 : : "Type override - [%4.4s] had invalid type (%s) "
194 : : "for Scope operator, changed to type ANY",
195 : : acpi_ut_get_node_name(node),
196 : : acpi_ut_get_type_name(node->type)));
197 : :
198 : 0 : node->type = ACPI_TYPE_ANY;
199 : 0 : walk_state->scope_info->common.value = ACPI_TYPE_ANY;
200 : 0 : break;
201 : :
202 : 0 : case ACPI_TYPE_METHOD:
203 : :
204 : : /*
205 : : * Allow scope change to root during execution of module-level
206 : : * code. Root is typed METHOD during this time.
207 : : */
208 [ # # ]: 0 : if ((node == acpi_gbl_root_node) &&
209 : 0 : (walk_state->
210 [ # # ]: 0 : parse_flags & ACPI_PARSE_MODULE_LEVEL)) {
211 : : break;
212 : : }
213 : :
214 : : /*lint -fallthrough */
215 : :
216 : : default:
217 : :
218 : : /* All other types are an error */
219 : :
220 : 0 : ACPI_ERROR((AE_INFO,
221 : : "Invalid type (%s) for target of "
222 : : "Scope operator [%4.4s] (Cannot override)",
223 : : acpi_ut_get_type_name(node->type),
224 : : acpi_ut_get_node_name(node)));
225 : :
226 : 0 : return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
227 : : }
228 : 0 : break;
229 : :
230 : 6028 : default:
231 : :
232 : : /* All other opcodes */
233 : :
234 [ + + + - ]: 6028 : if (op && op->common.node) {
235 : :
236 : : /* This op/node was previously entered into the namespace */
237 : :
238 : 3014 : node = op->common.node;
239 : :
240 [ + + ]: 3014 : if (acpi_ns_opens_scope(object_type)) {
241 : 1430 : status =
242 : 1430 : acpi_ds_scope_stack_push(node, object_type,
243 : : walk_state);
244 [ + - ]: 1430 : if (ACPI_FAILURE(status)) {
245 : : return_ACPI_STATUS(status);
246 : : }
247 : : }
248 : :
249 : 3014 : return_ACPI_STATUS(AE_OK);
250 : : }
251 : :
252 : : /*
253 : : * Enter the named type into the internal namespace. We enter the name
254 : : * as we go downward in the parse tree. Any necessary subobjects that
255 : : * involve arguments to the opcode must be created as we go back up the
256 : : * parse tree later.
257 : : *
258 : : * Note: Name may already exist if we are executing a deferred opcode.
259 : : */
260 [ - + ]: 3014 : if (walk_state->deferred_node) {
261 : :
262 : : /* This name is already in the namespace, get the node */
263 : :
264 : 0 : node = walk_state->deferred_node;
265 : 0 : status = AE_OK;
266 : 0 : break;
267 : : }
268 : :
269 : 3014 : flags = ACPI_NS_NO_UPSEARCH;
270 [ + - ]: 3014 : if (walk_state->pass_number == ACPI_IMODE_EXECUTE) {
271 : :
272 : : /* Execution mode, node cannot already exist, node is temporary */
273 : :
274 : 3014 : flags |= ACPI_NS_ERROR_IF_FOUND;
275 : :
276 : 3014 : if (!
277 : 3014 : (walk_state->
278 [ + + ]: 3014 : parse_flags & ACPI_PARSE_MODULE_LEVEL)) {
279 : 99 : flags |= ACPI_NS_TEMPORARY;
280 : : }
281 : : }
282 : : #ifdef ACPI_ASL_COMPILER
283 : :
284 : : /*
285 : : * Do not open a scope for AML_EXTERNAL_OP
286 : : * acpi_ns_lookup can open a new scope based on the object type
287 : : * of this op. AML_EXTERNAL_OP is a declaration rather than a
288 : : * definition. In the case that this external is a method object,
289 : : * acpi_ns_lookup will open a new scope. However, an AML_EXTERNAL_OP
290 : : * associated with the ACPI_TYPE_METHOD is a declaration, rather than
291 : : * a definition. Flags is set to avoid opening a scope for any
292 : : * AML_EXTERNAL_OP.
293 : : */
294 : : if (walk_state->opcode == AML_EXTERNAL_OP) {
295 : : flags |= ACPI_NS_DONT_OPEN_SCOPE;
296 : : }
297 : : #endif
298 : :
299 : : /*
300 : : * For name creation opcodes, the full namepath prefix must
301 : : * exist, except for the final (new) nameseg.
302 : : */
303 [ + - ]: 3014 : if (walk_state->op_info->flags & AML_NAMED) {
304 : 3014 : flags |= ACPI_NS_PREFIX_MUST_EXIST;
305 : : }
306 : :
307 : : /* Add new entry or lookup existing entry */
308 : :
309 : 3014 : status =
310 : 3014 : acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
311 : : object_type, ACPI_IMODE_LOAD_PASS2, flags,
312 : : walk_state, &node);
313 : :
314 : 3014 : if (ACPI_SUCCESS(status) && (flags & ACPI_NS_TEMPORARY)) {
315 : : ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
316 : : "***New Node [%4.4s] %p is temporary\n",
317 : : acpi_ut_get_node_name(node), node));
318 : : }
319 : : break;
320 : : }
321 : :
322 [ - + ]: 3190 : if (ACPI_FAILURE(status)) {
323 : 0 : ACPI_ERROR_NAMESPACE(walk_state->scope_info,
324 : 0 : buffer_ptr, status);
325 : 0 : return_ACPI_STATUS(status);
326 : : }
327 : :
328 [ + - ]: 3190 : if (!op) {
329 : :
330 : : /* Create a new op */
331 : :
332 : 3190 : op = acpi_ps_alloc_op(walk_state->opcode, walk_state->aml);
333 [ + - ]: 3190 : if (!op) {
334 : : return_ACPI_STATUS(AE_NO_MEMORY);
335 : : }
336 : :
337 : : /* Initialize the new op */
338 : :
339 [ + - ]: 3190 : if (node) {
340 : 3190 : op->named.name = node->name.integer;
341 : : }
342 : 3190 : *out_op = op;
343 : : }
344 : :
345 : : /*
346 : : * Put the Node in the "op" object that the parser uses, so we
347 : : * can get it again quickly when this scope is closed
348 : : */
349 : 3190 : op->common.node = node;
350 : 3190 : return_ACPI_STATUS(status);
351 : : }
352 : :
353 : : /*******************************************************************************
354 : : *
355 : : * FUNCTION: acpi_ds_load2_end_op
356 : : *
357 : : * PARAMETERS: walk_state - Current state of the parse tree walk
358 : : *
359 : : * RETURN: Status
360 : : *
361 : : * DESCRIPTION: Ascending callback used during the loading of the namespace,
362 : : * both control methods and everything else.
363 : : *
364 : : ******************************************************************************/
365 : :
366 : 3399 : acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
367 : : {
368 : 3399 : union acpi_parse_object *op;
369 : 3399 : acpi_status status = AE_OK;
370 : 3399 : acpi_object_type object_type;
371 : 3399 : struct acpi_namespace_node *node;
372 : 3399 : union acpi_parse_object *arg;
373 : 3399 : struct acpi_namespace_node *new_node;
374 : 3399 : u32 i;
375 : 3399 : u8 region_space;
376 : :
377 : 3399 : ACPI_FUNCTION_TRACE(ds_load2_end_op);
378 : :
379 : 3399 : op = walk_state->op;
380 : : ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
381 : 3399 : walk_state->op_info->name, op, walk_state));
382 : :
383 : : /* Check if opcode had an associated namespace object */
384 : :
385 [ + - ]: 3399 : if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
386 : : return_ACPI_STATUS(AE_OK);
387 : : }
388 : :
389 : 3399 : if (op->common.aml_opcode == AML_SCOPE_OP) {
390 : : ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
391 : : "Ending scope Op=%p State=%p\n", op,
392 : 3399 : walk_state));
393 : : }
394 : :
395 : 3399 : object_type = walk_state->op_info->object_type;
396 : :
397 : : /*
398 : : * Get the Node/name from the earlier lookup
399 : : * (It was saved in the *op structure)
400 : : */
401 : 3399 : node = op->common.node;
402 : :
403 : : /*
404 : : * Put the Node on the object stack (Contains the ACPI Name of
405 : : * this object)
406 : : */
407 : 3399 : walk_state->operands[0] = (void *)node;
408 : 3399 : walk_state->num_operands = 1;
409 : :
410 : : /* Pop the scope stack */
411 : :
412 [ + + ]: 3399 : if (acpi_ns_opens_scope(object_type) &&
413 [ + - ]: 1606 : (op->common.aml_opcode != AML_INT_METHODCALL_OP)) {
414 : : ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
415 : : "(%s) Popping scope for Op %p\n",
416 : 1606 : acpi_ut_get_type_name(object_type), op));
417 : :
418 : 1606 : status = acpi_ds_scope_stack_pop(walk_state);
419 [ - + ]: 1606 : if (ACPI_FAILURE(status)) {
420 : 0 : goto cleanup;
421 : : }
422 : : }
423 : :
424 : : /*
425 : : * Named operations are as follows:
426 : : *
427 : : * AML_ALIAS
428 : : * AML_BANKFIELD
429 : : * AML_CREATEBITFIELD
430 : : * AML_CREATEBYTEFIELD
431 : : * AML_CREATEDWORDFIELD
432 : : * AML_CREATEFIELD
433 : : * AML_CREATEQWORDFIELD
434 : : * AML_CREATEWORDFIELD
435 : : * AML_DATA_REGION
436 : : * AML_DEVICE
437 : : * AML_EVENT
438 : : * AML_FIELD
439 : : * AML_INDEXFIELD
440 : : * AML_METHOD
441 : : * AML_METHODCALL
442 : : * AML_MUTEX
443 : : * AML_NAME
444 : : * AML_NAMEDFIELD
445 : : * AML_OPREGION
446 : : * AML_POWERRES
447 : : * AML_PROCESSOR
448 : : * AML_SCOPE
449 : : * AML_THERMALZONE
450 : : */
451 : :
452 : : ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
453 : : "Create-Load [%s] State=%p Op=%p NamedObj=%p\n",
454 : : acpi_ps_get_opcode_name(op->common.aml_opcode),
455 : 3399 : walk_state, op, node));
456 : :
457 : : /* Decode the opcode */
458 : :
459 : 3399 : arg = op->common.value.arg;
460 : :
461 [ + + + + : 3399 : switch (walk_state->op_info->type) {
- + ]
462 : :
463 : 110 : case AML_TYPE_CREATE_FIELD:
464 : : /*
465 : : * Create the field object, but the field buffer and index must
466 : : * be evaluated later during the execution phase
467 : : */
468 : 110 : status = acpi_ds_create_buffer_field(op, walk_state);
469 : 110 : break;
470 : :
471 : 99 : case AML_TYPE_NAMED_FIELD:
472 : : /*
473 : : * If we are executing a method, initialize the field
474 : : */
475 [ + - ]: 99 : if (walk_state->method_node) {
476 : 99 : status = acpi_ds_init_field_objects(op, walk_state);
477 : : }
478 : :
479 [ - - + - ]: 99 : switch (op->common.aml_opcode) {
480 : 0 : case AML_INDEX_FIELD_OP:
481 : :
482 : 0 : status =
483 : 0 : acpi_ds_create_index_field(op,
484 : : (acpi_handle)arg->common.
485 : : node, walk_state);
486 : 0 : break;
487 : :
488 : 0 : case AML_BANK_FIELD_OP:
489 : :
490 : 0 : status =
491 : 0 : acpi_ds_create_bank_field(op, arg->common.node,
492 : : walk_state);
493 : 0 : break;
494 : :
495 : 99 : case AML_FIELD_OP:
496 : :
497 : 99 : status =
498 : 99 : acpi_ds_create_field(op, arg->common.node,
499 : : walk_state);
500 : 99 : break;
501 : :
502 : : default:
503 : :
504 : : /* All NAMED_FIELD opcodes must be handled above */
505 : : break;
506 : : }
507 : : break;
508 : :
509 : 33 : case AML_TYPE_NAMED_SIMPLE:
510 : :
511 : 33 : status = acpi_ds_create_operands(walk_state, arg);
512 [ - + ]: 33 : if (ACPI_FAILURE(status)) {
513 : 0 : goto cleanup;
514 : : }
515 : :
516 [ + - + - : 33 : switch (op->common.aml_opcode) {
- - ]
517 : 11 : case AML_PROCESSOR_OP:
518 : :
519 : 11 : status = acpi_ex_create_processor(walk_state);
520 : 11 : break;
521 : :
522 : 0 : case AML_POWER_RESOURCE_OP:
523 : :
524 : 0 : status = acpi_ex_create_power_resource(walk_state);
525 : 0 : break;
526 : :
527 : 22 : case AML_MUTEX_OP:
528 : :
529 : 22 : status = acpi_ex_create_mutex(walk_state);
530 : 22 : break;
531 : :
532 : 0 : case AML_EVENT_OP:
533 : :
534 : 0 : status = acpi_ex_create_event(walk_state);
535 : 0 : break;
536 : :
537 : 0 : case AML_ALIAS_OP:
538 : :
539 : 0 : status = acpi_ex_create_alias(walk_state);
540 : 0 : break;
541 : :
542 : 0 : default:
543 : :
544 : : /* Unknown opcode */
545 : :
546 : 0 : status = AE_OK;
547 : 0 : goto cleanup;
548 : : }
549 : :
550 : : /* Delete operands */
551 : :
552 [ + + ]: 88 : for (i = 1; i < walk_state->num_operands; i++) {
553 : 55 : acpi_ut_remove_reference(walk_state->operands[i]);
554 : 55 : walk_state->operands[i] = NULL;
555 : : }
556 : :
557 : : break;
558 : :
559 : 2398 : case AML_TYPE_NAMED_COMPLEX:
560 : :
561 [ + + + - ]: 2398 : switch (op->common.aml_opcode) {
562 : 88 : case AML_REGION_OP:
563 : : case AML_DATA_REGION_OP:
564 : :
565 [ + - ]: 88 : if (op->common.aml_opcode == AML_REGION_OP) {
566 : 88 : region_space = (acpi_adr_space_type)
567 : 88 : ((op->common.value.arg)->common.value.
568 : : integer);
569 : : } else {
570 : : region_space = ACPI_ADR_SPACE_DATA_TABLE;
571 : : }
572 : :
573 : : /*
574 : : * The op_region is not fully parsed at this time. The only valid
575 : : * argument is the space_id. (We must save the address of the
576 : : * AML of the address and length operands)
577 : : *
578 : : * If we have a valid region, initialize it. The namespace is
579 : : * unlocked at this point.
580 : : *
581 : : * Need to unlock interpreter if it is locked (if we are running
582 : : * a control method), in order to allow _REG methods to be run
583 : : * during acpi_ev_initialize_region.
584 : : */
585 [ + - ]: 88 : if (walk_state->method_node) {
586 : : /*
587 : : * Executing a method: initialize the region and unlock
588 : : * the interpreter
589 : : */
590 : 88 : status = acpi_ex_create_region(op->named.data,
591 : : op->named.length,
592 : : region_space,
593 : : walk_state);
594 [ + - ]: 88 : if (ACPI_FAILURE(status)) {
595 : : return_ACPI_STATUS(status);
596 : : }
597 : : }
598 : :
599 : 88 : status =
600 : 88 : acpi_ev_initialize_region
601 : : (acpi_ns_get_attached_object(node));
602 : 88 : break;
603 : :
604 : 1474 : case AML_NAME_OP:
605 : :
606 : 1474 : status = acpi_ds_create_node(walk_state, node, op);
607 : 1474 : break;
608 : :
609 : 836 : case AML_METHOD_OP:
610 : : /*
611 : : * method_op pkg_length name_string method_flags term_list
612 : : *
613 : : * Note: We must create the method node/object pair as soon as we
614 : : * see the method declaration. This allows later pass1 parsing
615 : : * of invocations of the method (need to know the number of
616 : : * arguments.)
617 : : */
618 : : ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
619 : : "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
620 : 836 : walk_state, op, op->named.node));
621 : :
622 [ + - ]: 836 : if (!acpi_ns_get_attached_object(op->named.node)) {
623 : 836 : walk_state->operands[0] =
624 : 836 : ACPI_CAST_PTR(void, op->named.node);
625 : 836 : walk_state->num_operands = 1;
626 : :
627 : 836 : status =
628 : 836 : acpi_ds_create_operands(walk_state,
629 : : op->common.value.
630 : : arg);
631 [ + - ]: 836 : if (ACPI_SUCCESS(status)) {
632 : 836 : status =
633 : 836 : acpi_ex_create_method(op->named.
634 : : data,
635 : : op->named.
636 : : length,
637 : : walk_state);
638 : : }
639 : :
640 : 836 : walk_state->operands[0] = NULL;
641 : 836 : walk_state->num_operands = 0;
642 : :
643 [ + - ]: 836 : if (ACPI_FAILURE(status)) {
644 : : return_ACPI_STATUS(status);
645 : : }
646 : : }
647 : : break;
648 : :
649 : : default:
650 : :
651 : : /* All NAMED_COMPLEX opcodes must be handled above */
652 : : break;
653 : : }
654 : : break;
655 : :
656 : : case AML_CLASS_INTERNAL:
657 : :
658 : : /* case AML_INT_NAMEPATH_OP: */
659 : : break;
660 : :
661 : 0 : case AML_CLASS_METHOD_CALL:
662 : :
663 : : ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
664 : : "RESOLVING-MethodCall: State=%p Op=%p NamedObj=%p\n",
665 : 0 : walk_state, op, node));
666 : :
667 : : /*
668 : : * Lookup the method name and save the Node
669 : : */
670 : 0 : status =
671 : 0 : acpi_ns_lookup(walk_state->scope_info,
672 : : arg->common.value.string, ACPI_TYPE_ANY,
673 : : ACPI_IMODE_LOAD_PASS2,
674 : : ACPI_NS_SEARCH_PARENT |
675 : : ACPI_NS_DONT_OPEN_SCOPE, walk_state,
676 : : &(new_node));
677 [ # # ]: 0 : if (ACPI_SUCCESS(status)) {
678 : : /*
679 : : * Make sure that what we found is indeed a method
680 : : * We didn't search for a method on purpose, to see if the name
681 : : * would resolve
682 : : */
683 [ # # ]: 0 : if (new_node->type != ACPI_TYPE_METHOD) {
684 : 0 : status = AE_AML_OPERAND_TYPE;
685 : : }
686 : :
687 : : /* We could put the returned object (Node) on the object stack for
688 : : * later, but for now, we will put it in the "op" object that the
689 : : * parser uses, so we can get it again at the end of this scope
690 : : */
691 : 0 : op->common.node = new_node;
692 : : } else {
693 : 0 : ACPI_ERROR_NAMESPACE(walk_state->scope_info,
694 : : arg->common.value.string, status);
695 : : }
696 : : break;
697 : :
698 : : default:
699 : :
700 : : break;
701 : : }
702 : :
703 : 3399 : cleanup:
704 : :
705 : : /* Remove the Node pushed at the very beginning */
706 : :
707 : 3399 : walk_state->operands[0] = NULL;
708 : 3399 : walk_state->num_operands = 0;
709 : 3399 : return_ACPI_STATUS(status);
710 : : }
|
