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 if ((walk_state
->op_info
->class == AML_CLASS_EXECUTE
) ||
495 (walk_state
->op_info
->class == AML_CLASS_CONTROL
)) {
496 ACPI_REPORT_WARNING ((
497 "Encountered executable code at module level, [%s]\n",
498 acpi_ps_get_opcode_name (walk_state
->opcode
)));
500 return_ACPI_STATUS (AE_OK
);
503 /* Get the name we are going to enter or lookup in the namespace */
505 if (walk_state
->opcode
== AML_INT_NAMEPATH_OP
) {
506 /* For Namepath op, get the path string */
508 buffer_ptr
= op
->common
.value
.string
;
510 /* No name, just exit */
512 return_ACPI_STATUS (AE_OK
);
516 /* Get name from the op */
518 buffer_ptr
= (char *) &op
->named
.name
;
522 /* Get the namestring from the raw AML */
524 buffer_ptr
= acpi_ps_get_next_namestring (&walk_state
->parser_state
);
527 /* Map the opcode into an internal object type */
529 object_type
= walk_state
->op_info
->object_type
;
531 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
532 "State=%p Op=%p Type=%X\n", walk_state
, op
, object_type
));
535 switch (walk_state
->opcode
) {
537 case AML_BANK_FIELD_OP
:
538 case AML_INDEX_FIELD_OP
:
544 case AML_INT_NAMEPATH_OP
:
547 * The name_path is an object reference to an existing object.
548 * Don't enter the name into the namespace, but look it up
551 status
= acpi_ns_lookup (walk_state
->scope_info
, buffer_ptr
, object_type
,
552 ACPI_IMODE_EXECUTE
, ACPI_NS_SEARCH_PARENT
,
553 walk_state
, &(node
));
559 * The Path is an object reference to an existing object.
560 * Don't enter the name into the namespace, but look it up
563 status
= acpi_ns_lookup (walk_state
->scope_info
, buffer_ptr
, object_type
,
564 ACPI_IMODE_EXECUTE
, ACPI_NS_SEARCH_PARENT
,
565 walk_state
, &(node
));
566 if (ACPI_FAILURE (status
)) {
567 #ifdef _ACPI_ASL_COMPILER
568 if (status
== AE_NOT_FOUND
) {
572 ACPI_REPORT_NSERROR (buffer_ptr
, status
);
575 ACPI_REPORT_NSERROR (buffer_ptr
, status
);
577 return_ACPI_STATUS (status
);
580 * We must check to make sure that the target is
581 * one of the opcodes that actually opens a scope
583 switch (node
->type
) {
584 case ACPI_TYPE_LOCAL_SCOPE
: /* Scope */
585 case ACPI_TYPE_DEVICE
:
586 case ACPI_TYPE_POWER
:
587 case ACPI_TYPE_PROCESSOR
:
588 case ACPI_TYPE_THERMAL
:
590 /* These are acceptable types */
593 case ACPI_TYPE_INTEGER
:
594 case ACPI_TYPE_STRING
:
595 case ACPI_TYPE_BUFFER
:
598 * These types we will allow, but we will change the type. This
599 * enables some existing code of the form:
602 * Scope (DEB) { ... }
605 ACPI_REPORT_WARNING ((
606 "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
607 buffer_ptr
, acpi_ut_get_type_name (node
->type
)));
609 node
->type
= ACPI_TYPE_ANY
;
610 walk_state
->scope_info
->common
.value
= ACPI_TYPE_ANY
;
615 /* All other types are an error */
618 "Invalid type (%s) for target of Scope operator [%4.4s]\n",
619 acpi_ut_get_type_name (node
->type
), buffer_ptr
));
621 return (AE_AML_OPERAND_TYPE
);
627 /* All other opcodes */
629 if (op
&& op
->common
.node
) {
630 /* This op/node was previously entered into the namespace */
632 node
= op
->common
.node
;
634 if (acpi_ns_opens_scope (object_type
)) {
635 status
= acpi_ds_scope_stack_push (node
, object_type
, walk_state
);
636 if (ACPI_FAILURE (status
)) {
637 return_ACPI_STATUS (status
);
641 return_ACPI_STATUS (AE_OK
);
645 * Enter the named type into the internal namespace. We enter the name
646 * as we go downward in the parse tree. Any necessary subobjects that
647 * involve arguments to the opcode must be created as we go back up the
650 * Note: Name may already exist if we are executing a deferred opcode.
652 if (walk_state
->deferred_node
) {
653 /* This name is already in the namespace, get the node */
655 node
= walk_state
->deferred_node
;
660 status
= acpi_ns_lookup (walk_state
->scope_info
, buffer_ptr
, object_type
,
661 ACPI_IMODE_EXECUTE
, ACPI_NS_NO_UPSEARCH
,
662 walk_state
, &(node
));
666 if (ACPI_FAILURE (status
)) {
667 ACPI_REPORT_NSERROR (buffer_ptr
, status
);
668 return_ACPI_STATUS (status
);
673 /* Create a new op */
675 op
= acpi_ps_alloc_op (walk_state
->opcode
);
677 return_ACPI_STATUS (AE_NO_MEMORY
);
680 /* Initialize the new op */
683 op
->named
.name
= node
->name
.integer
;
691 * Put the Node in the "op" object that the parser uses, so we
692 * can get it again quickly when this scope is closed
694 op
->common
.node
= node
;
696 return_ACPI_STATUS (status
);
700 /*******************************************************************************
702 * FUNCTION: acpi_ds_load2_end_op
704 * PARAMETERS: walk_state - Current state of the parse tree walk
708 * DESCRIPTION: Ascending callback used during the loading of the namespace,
709 * both control methods and everything else.
711 ******************************************************************************/
714 acpi_ds_load2_end_op (
715 struct acpi_walk_state
*walk_state
)
717 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
;
723 #ifndef ACPI_NO_METHOD_EXECUTION
728 ACPI_FUNCTION_TRACE ("ds_load2_end_op");
731 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "Opcode [%s] Op %p State %p\n",
732 walk_state
->op_info
->name
, op
, walk_state
));
734 /* Only interested in opcodes that have namespace objects */
736 if (!(walk_state
->op_info
->flags
& AML_NSOBJECT
)) {
737 return_ACPI_STATUS (AE_OK
);
740 if (op
->common
.aml_opcode
== AML_SCOPE_OP
) {
741 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
742 "Ending scope Op=%p State=%p\n", op
, walk_state
));
746 object_type
= walk_state
->op_info
->object_type
;
749 * Get the Node/name from the earlier lookup
750 * (It was saved in the *op structure)
752 node
= op
->common
.node
;
755 * Put the Node on the object stack (Contains the ACPI Name of
758 walk_state
->operands
[0] = (void *) node
;
759 walk_state
->num_operands
= 1;
761 /* Pop the scope stack */
763 if (acpi_ns_opens_scope (object_type
) &&
764 (op
->common
.aml_opcode
!= AML_INT_METHODCALL_OP
)) {
765 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "(%s) Popping scope for Op %p\n",
766 acpi_ut_get_type_name (object_type
), op
));
768 status
= acpi_ds_scope_stack_pop (walk_state
);
769 if (ACPI_FAILURE (status
)) {
775 * Named operations are as follows:
780 * AML_CREATEBYTEFIELD
781 * AML_CREATEDWORDFIELD
783 * AML_CREATEQWORDFIELD
784 * AML_CREATEWORDFIELD
802 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
803 "Create-Load [%s] State=%p Op=%p named_obj=%p\n",
804 acpi_ps_get_opcode_name (op
->common
.aml_opcode
), walk_state
, op
, node
));
806 /* Decode the opcode */
808 arg
= op
->common
.value
.arg
;
810 switch (walk_state
->op_info
->type
) {
811 #ifndef ACPI_NO_METHOD_EXECUTION
813 case AML_TYPE_CREATE_FIELD
:
816 * Create the field object, but the field buffer and index must
817 * be evaluated later during the execution phase
819 status
= acpi_ds_create_buffer_field (op
, walk_state
);
823 case AML_TYPE_NAMED_FIELD
:
825 switch (op
->common
.aml_opcode
) {
826 case AML_INDEX_FIELD_OP
:
828 status
= acpi_ds_create_index_field (op
, (acpi_handle
) arg
->common
.node
,
832 case AML_BANK_FIELD_OP
:
834 status
= acpi_ds_create_bank_field (op
, arg
->common
.node
, walk_state
);
839 status
= acpi_ds_create_field (op
, arg
->common
.node
, walk_state
);
843 /* All NAMED_FIELD opcodes must be handled above */
849 case AML_TYPE_NAMED_SIMPLE
:
851 status
= acpi_ds_create_operands (walk_state
, arg
);
852 if (ACPI_FAILURE (status
)) {
856 switch (op
->common
.aml_opcode
) {
857 case AML_PROCESSOR_OP
:
859 status
= acpi_ex_create_processor (walk_state
);
862 case AML_POWER_RES_OP
:
864 status
= acpi_ex_create_power_resource (walk_state
);
869 status
= acpi_ex_create_mutex (walk_state
);
874 status
= acpi_ex_create_event (walk_state
);
877 case AML_DATA_REGION_OP
:
879 status
= acpi_ex_create_table_region (walk_state
);
884 status
= acpi_ex_create_alias (walk_state
);
894 /* Delete operands */
896 for (i
= 1; i
< walk_state
->num_operands
; i
++) {
897 acpi_ut_remove_reference (walk_state
->operands
[i
]);
898 walk_state
->operands
[i
] = NULL
;
902 #endif /* ACPI_NO_METHOD_EXECUTION */
904 case AML_TYPE_NAMED_COMPLEX
:
906 switch (op
->common
.aml_opcode
) {
907 #ifndef ACPI_NO_METHOD_EXECUTION
910 * The op_region is not fully parsed at this time. Only valid
911 * argument is the space_id. (We must save the address of the
912 * AML of the address and length operands)
915 * If we have a valid region, initialize it
916 * Namespace is NOT locked at this point.
918 status
= acpi_ev_initialize_region (acpi_ns_get_attached_object (node
),
920 if (ACPI_FAILURE (status
)) {
922 * If AE_NOT_EXIST is returned, it is not fatal
923 * because many regions get created before a handler
924 * is installed for said region.
926 if (AE_NOT_EXIST
== status
) {
935 status
= acpi_ds_create_node (walk_state
, node
, op
);
937 #endif /* ACPI_NO_METHOD_EXECUTION */
941 /* All NAMED_COMPLEX opcodes must be handled above */
942 /* Note: Method objects were already created in Pass 1 */
948 case AML_CLASS_INTERNAL
:
950 /* case AML_INT_NAMEPATH_OP: */
954 case AML_CLASS_METHOD_CALL
:
956 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
957 "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
958 walk_state
, op
, node
));
961 * Lookup the method name and save the Node
963 status
= acpi_ns_lookup (walk_state
->scope_info
, arg
->common
.value
.string
,
964 ACPI_TYPE_ANY
, ACPI_IMODE_LOAD_PASS2
,
965 ACPI_NS_SEARCH_PARENT
| ACPI_NS_DONT_OPEN_SCOPE
,
966 walk_state
, &(new_node
));
967 if (ACPI_SUCCESS (status
)) {
969 * Make sure that what we found is indeed a method
970 * We didn't search for a method on purpose, to see if the name
973 if (new_node
->type
!= ACPI_TYPE_METHOD
) {
974 status
= AE_AML_OPERAND_TYPE
;
977 /* We could put the returned object (Node) on the object stack for
978 * later, but for now, we will put it in the "op" object that the
979 * parser uses, so we can get it again at the end of this scope
981 op
->common
.node
= new_node
;
984 ACPI_REPORT_NSERROR (arg
->common
.value
.string
, status
);
995 /* Remove the Node pushed at the very beginning */
997 walk_state
->operands
[0] = NULL
;
998 walk_state
->num_operands
= 0;
999 return_ACPI_STATUS (status
);