1 /******************************************************************************
3 * Module Name: dswload - Dispatcher namespace load callbacks
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2005, R. Byron Moore
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
45 #include <acpi/acpi.h>
46 #include <acpi/acparser.h>
47 #include <acpi/amlcode.h>
48 #include <acpi/acdispat.h>
49 #include <acpi/acinterp.h>
50 #include <acpi/acnamesp.h>
51 #include <acpi/acevents.h>
53 #ifdef _ACPI_ASL_COMPILER
54 #include <acpi/acdisasm.h>
57 #define _COMPONENT ACPI_DISPATCHER
58 ACPI_MODULE_NAME ("dswload")
61 /*******************************************************************************
63 * FUNCTION: acpi_ds_init_callbacks
65 * PARAMETERS: walk_state - Current state of the parse tree walk
66 * pass_number - 1, 2, or 3
70 * DESCRIPTION: Init walk state callbacks
72 ******************************************************************************/
75 acpi_ds_init_callbacks (
76 struct acpi_walk_state
*walk_state
,
80 switch (pass_number
) {
82 walk_state
->parse_flags
= ACPI_PARSE_LOAD_PASS1
|
83 ACPI_PARSE_DELETE_TREE
;
84 walk_state
->descending_callback
= acpi_ds_load1_begin_op
;
85 walk_state
->ascending_callback
= acpi_ds_load1_end_op
;
89 walk_state
->parse_flags
= ACPI_PARSE_LOAD_PASS1
|
90 ACPI_PARSE_DELETE_TREE
;
91 walk_state
->descending_callback
= acpi_ds_load2_begin_op
;
92 walk_state
->ascending_callback
= acpi_ds_load2_end_op
;
96 #ifndef ACPI_NO_METHOD_EXECUTION
97 walk_state
->parse_flags
|= ACPI_PARSE_EXECUTE
|
98 ACPI_PARSE_DELETE_TREE
;
99 walk_state
->descending_callback
= acpi_ds_exec_begin_op
;
100 walk_state
->ascending_callback
= acpi_ds_exec_end_op
;
105 return (AE_BAD_PARAMETER
);
112 /*******************************************************************************
114 * FUNCTION: acpi_ds_load1_begin_op
116 * PARAMETERS: walk_state - Current state of the parse tree walk
117 * out_op - Where to return op if a new one is created
121 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
123 ******************************************************************************/
126 acpi_ds_load1_begin_op (
127 struct acpi_walk_state
*walk_state
,
128 union acpi_parse_object
**out_op
)
130 union acpi_parse_object
*op
;
131 struct acpi_namespace_node
*node
;
133 acpi_object_type object_type
;
138 ACPI_FUNCTION_NAME ("ds_load1_begin_op");
142 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "Op=%p State=%p\n", op
, walk_state
));
144 /* We are only interested in opcodes that have an associated name */
147 if (!(walk_state
->op_info
->flags
& AML_NAMED
)) {
149 if ((walk_state
->op_info
->class == AML_CLASS_EXECUTE
) ||
150 (walk_state
->op_info
->class == AML_CLASS_CONTROL
)) {
151 acpi_os_printf ("\n\n***EXECUTABLE OPCODE %s***\n\n",
152 walk_state
->op_info
->name
);
154 return (AE_CTRL_SKIP
);
161 /* Check if this object has already been installed in the namespace */
163 if (op
->common
.node
) {
169 path
= acpi_ps_get_next_namestring (&walk_state
->parser_state
);
171 /* Map the raw opcode into an internal object type */
173 object_type
= walk_state
->op_info
->object_type
;
175 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
176 "State=%p Op=%p [%s]\n", walk_state
, op
, acpi_ut_get_type_name (object_type
)));
178 switch (walk_state
->opcode
) {
182 * The target name of the Scope() operator must exist at this point so
183 * that we can actually open the scope to enter new names underneath it.
184 * Allow search-to-root for single namesegs.
186 status
= acpi_ns_lookup (walk_state
->scope_info
, path
, object_type
,
187 ACPI_IMODE_EXECUTE
, ACPI_NS_SEARCH_PARENT
, walk_state
, &(node
));
188 #ifdef _ACPI_ASL_COMPILER
189 if (status
== AE_NOT_FOUND
) {
192 * Target of Scope() not found. Generate an External for it, and
193 * insert the name into the namespace.
195 acpi_dm_add_to_external_list (path
);
196 status
= acpi_ns_lookup (walk_state
->scope_info
, path
, object_type
,
197 ACPI_IMODE_LOAD_PASS1
, ACPI_NS_SEARCH_PARENT
,
198 walk_state
, &(node
));
201 if (ACPI_FAILURE (status
)) {
202 ACPI_REPORT_NSERROR (path
, status
);
207 * Check to make sure that the target is
208 * one of the opcodes that actually opens a scope
210 switch (node
->type
) {
211 case ACPI_TYPE_LOCAL_SCOPE
: /* Scope */
212 case ACPI_TYPE_DEVICE
:
213 case ACPI_TYPE_POWER
:
214 case ACPI_TYPE_PROCESSOR
:
215 case ACPI_TYPE_THERMAL
:
217 /* These are acceptable types */
220 case ACPI_TYPE_INTEGER
:
221 case ACPI_TYPE_STRING
:
222 case ACPI_TYPE_BUFFER
:
225 * These types we will allow, but we will change the type. This
226 * enables some existing code of the form:
229 * Scope (DEB) { ... }
231 * Note: silently change the type here. On the second pass, we will report
235 ACPI_DEBUG_PRINT ((ACPI_DB_INFO
,
236 "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
237 path
, acpi_ut_get_type_name (node
->type
)));
239 node
->type
= ACPI_TYPE_ANY
;
240 walk_state
->scope_info
->common
.value
= ACPI_TYPE_ANY
;
245 /* All other types are an error */
248 "Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)\n",
249 acpi_ut_get_type_name (node
->type
), path
));
251 return (AE_AML_OPERAND_TYPE
);
259 * For all other named opcodes, we will enter the name into
262 * Setup the search flags.
263 * Since we are entering a name into the namespace, we do not want to
264 * enable the search-to-root upsearch.
266 * There are only two conditions where it is acceptable that the name
268 * 1) the Scope() operator can reopen a scoping object that was
269 * previously defined (Scope, Method, Device, etc.)
270 * 2) Whenever we are parsing a deferred opcode (op_region, Buffer,
271 * buffer_field, or Package), the name of the object is already
274 if (walk_state
->deferred_node
) {
275 /* This name is already in the namespace, get the node */
277 node
= walk_state
->deferred_node
;
282 flags
= ACPI_NS_NO_UPSEARCH
;
283 if ((walk_state
->opcode
!= AML_SCOPE_OP
) &&
284 (!(walk_state
->parse_flags
& ACPI_PARSE_DEFERRED_OP
))) {
285 flags
|= ACPI_NS_ERROR_IF_FOUND
;
286 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "[%s] Cannot already exist\n",
287 acpi_ut_get_type_name (object_type
)));
290 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
291 "[%s] Both Find or Create allowed\n",
292 acpi_ut_get_type_name (object_type
)));
296 * Enter the named type into the internal namespace. We enter the name
297 * as we go downward in the parse tree. Any necessary subobjects that
298 * involve arguments to the opcode must be created as we go back up the
301 status
= acpi_ns_lookup (walk_state
->scope_info
, path
, object_type
,
302 ACPI_IMODE_LOAD_PASS1
, flags
, walk_state
, &(node
));
303 if (ACPI_FAILURE (status
)) {
304 ACPI_REPORT_NSERROR (path
, status
);
314 /* Create a new op */
316 op
= acpi_ps_alloc_op (walk_state
->opcode
);
318 return (AE_NO_MEMORY
);
324 op
->named
.name
= node
->name
.integer
;
326 #if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
327 op
->named
.path
= (u8
*) path
;
332 * Put the Node in the "op" object that the parser uses, so we
333 * can get it again quickly when this scope is closed
335 op
->common
.node
= node
;
336 acpi_ps_append_arg (acpi_ps_get_parent_scope (&walk_state
->parser_state
), op
);
343 /*******************************************************************************
345 * FUNCTION: acpi_ds_load1_end_op
347 * PARAMETERS: walk_state - Current state of the parse tree walk
351 * DESCRIPTION: Ascending callback used during the loading of the namespace,
352 * both control methods and everything else.
354 ******************************************************************************/
357 acpi_ds_load1_end_op (
358 struct acpi_walk_state
*walk_state
)
360 union acpi_parse_object
*op
;
361 acpi_object_type object_type
;
362 acpi_status status
= AE_OK
;
365 ACPI_FUNCTION_NAME ("ds_load1_end_op");
369 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "Op=%p State=%p\n", op
, walk_state
));
371 /* We are only interested in opcodes that have an associated name */
373 if (!(walk_state
->op_info
->flags
& (AML_NAMED
| AML_FIELD
))) {
377 /* Get the object type to determine if we should pop the scope */
379 object_type
= walk_state
->op_info
->object_type
;
381 #ifndef ACPI_NO_METHOD_EXECUTION
382 if (walk_state
->op_info
->flags
& AML_FIELD
) {
383 if (walk_state
->opcode
== AML_FIELD_OP
||
384 walk_state
->opcode
== AML_BANK_FIELD_OP
||
385 walk_state
->opcode
== AML_INDEX_FIELD_OP
) {
386 status
= acpi_ds_init_field_objects (op
, walk_state
);
392 if (op
->common
.aml_opcode
== AML_REGION_OP
) {
393 status
= acpi_ex_create_region (op
->named
.data
, op
->named
.length
,
394 (acpi_adr_space_type
)
395 ((op
->common
.value
.arg
)->common
.value
.integer
),
397 if (ACPI_FAILURE (status
)) {
403 if (op
->common
.aml_opcode
== AML_NAME_OP
) {
404 /* For Name opcode, get the object type from the argument */
406 if (op
->common
.value
.arg
) {
407 object_type
= (acpi_ps_get_opcode_info (
408 (op
->common
.value
.arg
)->common
.aml_opcode
))->object_type
;
409 op
->common
.node
->type
= (u8
) object_type
;
413 if (op
->common
.aml_opcode
== AML_METHOD_OP
) {
415 * method_op pkg_length name_string method_flags term_list
417 * Note: We must create the method node/object pair as soon as we
418 * see the method declaration. This allows later pass1 parsing
419 * of invocations of the method (need to know the number of
422 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
423 "LOADING-Method: State=%p Op=%p named_obj=%p\n",
424 walk_state
, op
, op
->named
.node
));
426 if (!acpi_ns_get_attached_object (op
->named
.node
)) {
427 walk_state
->operands
[0] = (void *) op
->named
.node
;
428 walk_state
->num_operands
= 1;
430 status
= acpi_ds_create_operands (walk_state
, op
->common
.value
.arg
);
431 if (ACPI_SUCCESS (status
)) {
432 status
= acpi_ex_create_method (op
->named
.data
,
433 op
->named
.length
, walk_state
);
435 walk_state
->operands
[0] = NULL
;
436 walk_state
->num_operands
= 0;
438 if (ACPI_FAILURE (status
)) {
444 /* Pop the scope stack */
446 if (acpi_ns_opens_scope (object_type
)) {
447 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "(%s): Popping scope for Op %p\n",
448 acpi_ut_get_type_name (object_type
), op
));
450 status
= acpi_ds_scope_stack_pop (walk_state
);
457 /*******************************************************************************
459 * FUNCTION: acpi_ds_load2_begin_op
461 * PARAMETERS: walk_state - Current state of the parse tree walk
462 * out_op - Wher to return op if a new one is created
466 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
468 ******************************************************************************/
471 acpi_ds_load2_begin_op (
472 struct acpi_walk_state
*walk_state
,
473 union acpi_parse_object
**out_op
)
475 union acpi_parse_object
*op
;
476 struct acpi_namespace_node
*node
;
478 acpi_object_type object_type
;
482 ACPI_FUNCTION_TRACE ("ds_load2_begin_op");
486 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "Op=%p State=%p\n", op
, walk_state
));
489 /* We only care about Namespace opcodes here */
491 if ((!(walk_state
->op_info
->flags
& AML_NSOPCODE
) &&
492 (walk_state
->opcode
!= AML_INT_NAMEPATH_OP
)) ||
493 (!(walk_state
->op_info
->flags
& AML_NAMED
))) {
494 return_ACPI_STATUS (AE_OK
);
497 /* Get the name we are going to enter or lookup in the namespace */
499 if (walk_state
->opcode
== AML_INT_NAMEPATH_OP
) {
500 /* For Namepath op, get the path string */
502 buffer_ptr
= op
->common
.value
.string
;
504 /* No name, just exit */
506 return_ACPI_STATUS (AE_OK
);
510 /* Get name from the op */
512 buffer_ptr
= (char *) &op
->named
.name
;
516 /* Get the namestring from the raw AML */
518 buffer_ptr
= acpi_ps_get_next_namestring (&walk_state
->parser_state
);
521 /* Map the opcode into an internal object type */
523 object_type
= walk_state
->op_info
->object_type
;
525 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
526 "State=%p Op=%p Type=%X\n", walk_state
, op
, object_type
));
529 switch (walk_state
->opcode
) {
531 case AML_BANK_FIELD_OP
:
532 case AML_INDEX_FIELD_OP
:
538 case AML_INT_NAMEPATH_OP
:
541 * The name_path is an object reference to an existing object.
542 * Don't enter the name into the namespace, but look it up
545 status
= acpi_ns_lookup (walk_state
->scope_info
, buffer_ptr
, object_type
,
546 ACPI_IMODE_EXECUTE
, ACPI_NS_SEARCH_PARENT
,
547 walk_state
, &(node
));
553 * The Path is an object reference to an existing object.
554 * Don't enter the name into the namespace, but look it up
557 status
= acpi_ns_lookup (walk_state
->scope_info
, buffer_ptr
, object_type
,
558 ACPI_IMODE_EXECUTE
, ACPI_NS_SEARCH_PARENT
,
559 walk_state
, &(node
));
560 if (ACPI_FAILURE (status
)) {
561 #ifdef _ACPI_ASL_COMPILER
562 if (status
== AE_NOT_FOUND
) {
566 ACPI_REPORT_NSERROR (buffer_ptr
, status
);
569 ACPI_REPORT_NSERROR (buffer_ptr
, status
);
571 return_ACPI_STATUS (status
);
574 * We must check to make sure that the target is
575 * one of the opcodes that actually opens a scope
577 switch (node
->type
) {
578 case ACPI_TYPE_LOCAL_SCOPE
: /* Scope */
579 case ACPI_TYPE_DEVICE
:
580 case ACPI_TYPE_POWER
:
581 case ACPI_TYPE_PROCESSOR
:
582 case ACPI_TYPE_THERMAL
:
584 /* These are acceptable types */
587 case ACPI_TYPE_INTEGER
:
588 case ACPI_TYPE_STRING
:
589 case ACPI_TYPE_BUFFER
:
592 * These types we will allow, but we will change the type. This
593 * enables some existing code of the form:
596 * Scope (DEB) { ... }
599 ACPI_REPORT_WARNING ((
600 "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
601 buffer_ptr
, acpi_ut_get_type_name (node
->type
)));
603 node
->type
= ACPI_TYPE_ANY
;
604 walk_state
->scope_info
->common
.value
= ACPI_TYPE_ANY
;
609 /* All other types are an error */
612 "Invalid type (%s) for target of Scope operator [%4.4s]\n",
613 acpi_ut_get_type_name (node
->type
), buffer_ptr
));
615 return (AE_AML_OPERAND_TYPE
);
621 /* All other opcodes */
623 if (op
&& op
->common
.node
) {
624 /* This op/node was previously entered into the namespace */
626 node
= op
->common
.node
;
628 if (acpi_ns_opens_scope (object_type
)) {
629 status
= acpi_ds_scope_stack_push (node
, object_type
, walk_state
);
630 if (ACPI_FAILURE (status
)) {
631 return_ACPI_STATUS (status
);
635 return_ACPI_STATUS (AE_OK
);
639 * Enter the named type into the internal namespace. We enter the name
640 * as we go downward in the parse tree. Any necessary subobjects that
641 * involve arguments to the opcode must be created as we go back up the
644 * Note: Name may already exist if we are executing a deferred opcode.
646 if (walk_state
->deferred_node
) {
647 /* This name is already in the namespace, get the node */
649 node
= walk_state
->deferred_node
;
654 status
= acpi_ns_lookup (walk_state
->scope_info
, buffer_ptr
, object_type
,
655 ACPI_IMODE_EXECUTE
, ACPI_NS_NO_UPSEARCH
,
656 walk_state
, &(node
));
660 if (ACPI_FAILURE (status
)) {
661 ACPI_REPORT_NSERROR (buffer_ptr
, status
);
662 return_ACPI_STATUS (status
);
667 /* Create a new op */
669 op
= acpi_ps_alloc_op (walk_state
->opcode
);
671 return_ACPI_STATUS (AE_NO_MEMORY
);
674 /* Initialize the new op */
677 op
->named
.name
= node
->name
.integer
;
685 * Put the Node in the "op" object that the parser uses, so we
686 * can get it again quickly when this scope is closed
688 op
->common
.node
= node
;
690 return_ACPI_STATUS (status
);
694 /*******************************************************************************
696 * FUNCTION: acpi_ds_load2_end_op
698 * PARAMETERS: walk_state - Current state of the parse tree walk
702 * DESCRIPTION: Ascending callback used during the loading of the namespace,
703 * both control methods and everything else.
705 ******************************************************************************/
708 acpi_ds_load2_end_op (
709 struct acpi_walk_state
*walk_state
)
711 union acpi_parse_object
*op
;
712 acpi_status status
= AE_OK
;
713 acpi_object_type object_type
;
714 struct acpi_namespace_node
*node
;
715 union acpi_parse_object
*arg
;
716 struct acpi_namespace_node
*new_node
;
717 #ifndef ACPI_NO_METHOD_EXECUTION
722 ACPI_FUNCTION_TRACE ("ds_load2_end_op");
725 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "Opcode [%s] Op %p State %p\n",
726 walk_state
->op_info
->name
, op
, walk_state
));
728 /* Only interested in opcodes that have namespace objects */
730 if (!(walk_state
->op_info
->flags
& AML_NSOBJECT
)) {
731 return_ACPI_STATUS (AE_OK
);
734 if (op
->common
.aml_opcode
== AML_SCOPE_OP
) {
735 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
736 "Ending scope Op=%p State=%p\n", op
, walk_state
));
740 object_type
= walk_state
->op_info
->object_type
;
743 * Get the Node/name from the earlier lookup
744 * (It was saved in the *op structure)
746 node
= op
->common
.node
;
749 * Put the Node on the object stack (Contains the ACPI Name of
752 walk_state
->operands
[0] = (void *) node
;
753 walk_state
->num_operands
= 1;
755 /* Pop the scope stack */
757 if (acpi_ns_opens_scope (object_type
) &&
758 (op
->common
.aml_opcode
!= AML_INT_METHODCALL_OP
)) {
759 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "(%s) Popping scope for Op %p\n",
760 acpi_ut_get_type_name (object_type
), op
));
762 status
= acpi_ds_scope_stack_pop (walk_state
);
763 if (ACPI_FAILURE (status
)) {
769 * Named operations are as follows:
774 * AML_CREATEBYTEFIELD
775 * AML_CREATEDWORDFIELD
777 * AML_CREATEQWORDFIELD
778 * AML_CREATEWORDFIELD
796 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
797 "Create-Load [%s] State=%p Op=%p named_obj=%p\n",
798 acpi_ps_get_opcode_name (op
->common
.aml_opcode
), walk_state
, op
, node
));
800 /* Decode the opcode */
802 arg
= op
->common
.value
.arg
;
804 switch (walk_state
->op_info
->type
) {
805 #ifndef ACPI_NO_METHOD_EXECUTION
807 case AML_TYPE_CREATE_FIELD
:
810 * Create the field object, but the field buffer and index must
811 * be evaluated later during the execution phase
813 status
= acpi_ds_create_buffer_field (op
, walk_state
);
817 case AML_TYPE_NAMED_FIELD
:
819 switch (op
->common
.aml_opcode
) {
820 case AML_INDEX_FIELD_OP
:
822 status
= acpi_ds_create_index_field (op
, (acpi_handle
) arg
->common
.node
,
826 case AML_BANK_FIELD_OP
:
828 status
= acpi_ds_create_bank_field (op
, arg
->common
.node
, walk_state
);
833 status
= acpi_ds_create_field (op
, arg
->common
.node
, walk_state
);
837 /* All NAMED_FIELD opcodes must be handled above */
843 case AML_TYPE_NAMED_SIMPLE
:
845 status
= acpi_ds_create_operands (walk_state
, arg
);
846 if (ACPI_FAILURE (status
)) {
850 switch (op
->common
.aml_opcode
) {
851 case AML_PROCESSOR_OP
:
853 status
= acpi_ex_create_processor (walk_state
);
856 case AML_POWER_RES_OP
:
858 status
= acpi_ex_create_power_resource (walk_state
);
863 status
= acpi_ex_create_mutex (walk_state
);
868 status
= acpi_ex_create_event (walk_state
);
871 case AML_DATA_REGION_OP
:
873 status
= acpi_ex_create_table_region (walk_state
);
878 status
= acpi_ex_create_alias (walk_state
);
888 /* Delete operands */
890 for (i
= 1; i
< walk_state
->num_operands
; i
++) {
891 acpi_ut_remove_reference (walk_state
->operands
[i
]);
892 walk_state
->operands
[i
] = NULL
;
896 #endif /* ACPI_NO_METHOD_EXECUTION */
898 case AML_TYPE_NAMED_COMPLEX
:
900 switch (op
->common
.aml_opcode
) {
901 #ifndef ACPI_NO_METHOD_EXECUTION
904 * The op_region is not fully parsed at this time. Only valid
905 * argument is the space_id. (We must save the address of the
906 * AML of the address and length operands)
909 * If we have a valid region, initialize it
910 * Namespace is NOT locked at this point.
912 status
= acpi_ev_initialize_region (acpi_ns_get_attached_object (node
),
914 if (ACPI_FAILURE (status
)) {
916 * If AE_NOT_EXIST is returned, it is not fatal
917 * because many regions get created before a handler
918 * is installed for said region.
920 if (AE_NOT_EXIST
== status
) {
929 status
= acpi_ds_create_node (walk_state
, node
, op
);
931 #endif /* ACPI_NO_METHOD_EXECUTION */
935 /* All NAMED_COMPLEX opcodes must be handled above */
936 /* Note: Method objects were already created in Pass 1 */
942 case AML_CLASS_INTERNAL
:
944 /* case AML_INT_NAMEPATH_OP: */
948 case AML_CLASS_METHOD_CALL
:
950 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
951 "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
952 walk_state
, op
, node
));
955 * Lookup the method name and save the Node
957 status
= acpi_ns_lookup (walk_state
->scope_info
, arg
->common
.value
.string
,
958 ACPI_TYPE_ANY
, ACPI_IMODE_LOAD_PASS2
,
959 ACPI_NS_SEARCH_PARENT
| ACPI_NS_DONT_OPEN_SCOPE
,
960 walk_state
, &(new_node
));
961 if (ACPI_SUCCESS (status
)) {
963 * Make sure that what we found is indeed a method
964 * We didn't search for a method on purpose, to see if the name
967 if (new_node
->type
!= ACPI_TYPE_METHOD
) {
968 status
= AE_AML_OPERAND_TYPE
;
971 /* We could put the returned object (Node) on the object stack for
972 * later, but for now, we will put it in the "op" object that the
973 * parser uses, so we can get it again at the end of this scope
975 op
->common
.node
= new_node
;
978 ACPI_REPORT_NSERROR (arg
->common
.value
.string
, status
);
989 /* Remove the Node pushed at the very beginning */
991 walk_state
->operands
[0] = NULL
;
992 walk_state
->num_operands
= 0;
993 return_ACPI_STATUS (status
);