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
)) {
152 /* Check if this object has already been installed in the namespace */
154 if (op
->common
.node
) {
160 path
= acpi_ps_get_next_namestring (&walk_state
->parser_state
);
162 /* Map the raw opcode into an internal object type */
164 object_type
= walk_state
->op_info
->object_type
;
166 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
167 "State=%p Op=%p [%s]\n", walk_state
, op
, acpi_ut_get_type_name (object_type
)));
169 switch (walk_state
->opcode
) {
173 * The target name of the Scope() operator must exist at this point so
174 * that we can actually open the scope to enter new names underneath it.
175 * Allow search-to-root for single namesegs.
177 status
= acpi_ns_lookup (walk_state
->scope_info
, path
, object_type
,
178 ACPI_IMODE_EXECUTE
, ACPI_NS_SEARCH_PARENT
, walk_state
, &(node
));
179 #ifdef ACPI_ASL_COMPILER
180 if (status
== AE_NOT_FOUND
) {
183 * Target of Scope() not found. Generate an External for it, and
184 * insert the name into the namespace.
186 acpi_dm_add_to_external_list (path
);
187 status
= acpi_ns_lookup (walk_state
->scope_info
, path
, object_type
,
188 ACPI_IMODE_LOAD_PASS1
, ACPI_NS_SEARCH_PARENT
,
189 walk_state
, &(node
));
192 if (ACPI_FAILURE (status
)) {
193 ACPI_REPORT_NSERROR (path
, status
);
198 * Check to make sure that the target is
199 * one of the opcodes that actually opens a scope
201 switch (node
->type
) {
202 case ACPI_TYPE_LOCAL_SCOPE
: /* Scope */
203 case ACPI_TYPE_DEVICE
:
204 case ACPI_TYPE_POWER
:
205 case ACPI_TYPE_PROCESSOR
:
206 case ACPI_TYPE_THERMAL
:
208 /* These are acceptable types */
211 case ACPI_TYPE_INTEGER
:
212 case ACPI_TYPE_STRING
:
213 case ACPI_TYPE_BUFFER
:
216 * These types we will allow, but we will change the type. This
217 * enables some existing code of the form:
220 * Scope (DEB) { ... }
222 * Note: silently change the type here. On the second pass, we will report
226 ACPI_DEBUG_PRINT ((ACPI_DB_INFO
,
227 "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
228 path
, acpi_ut_get_type_name (node
->type
)));
230 node
->type
= ACPI_TYPE_ANY
;
231 walk_state
->scope_info
->common
.value
= ACPI_TYPE_ANY
;
236 /* All other types are an error */
239 "Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)\n",
240 acpi_ut_get_type_name (node
->type
), path
));
242 return (AE_AML_OPERAND_TYPE
);
250 * For all other named opcodes, we will enter the name into
253 * Setup the search flags.
254 * Since we are entering a name into the namespace, we do not want to
255 * enable the search-to-root upsearch.
257 * There are only two conditions where it is acceptable that the name
259 * 1) the Scope() operator can reopen a scoping object that was
260 * previously defined (Scope, Method, Device, etc.)
261 * 2) Whenever we are parsing a deferred opcode (op_region, Buffer,
262 * buffer_field, or Package), the name of the object is already
265 if (walk_state
->deferred_node
) {
266 /* This name is already in the namespace, get the node */
268 node
= walk_state
->deferred_node
;
273 flags
= ACPI_NS_NO_UPSEARCH
;
274 if ((walk_state
->opcode
!= AML_SCOPE_OP
) &&
275 (!(walk_state
->parse_flags
& ACPI_PARSE_DEFERRED_OP
))) {
276 flags
|= ACPI_NS_ERROR_IF_FOUND
;
277 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "[%s] Cannot already exist\n",
278 acpi_ut_get_type_name (object_type
)));
281 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
282 "[%s] Both Find or Create allowed\n",
283 acpi_ut_get_type_name (object_type
)));
287 * Enter the named type into the internal namespace. We enter the name
288 * as we go downward in the parse tree. Any necessary subobjects that
289 * involve arguments to the opcode must be created as we go back up the
292 status
= acpi_ns_lookup (walk_state
->scope_info
, path
, object_type
,
293 ACPI_IMODE_LOAD_PASS1
, flags
, walk_state
, &(node
));
294 if (ACPI_FAILURE (status
)) {
295 ACPI_REPORT_NSERROR (path
, status
);
305 /* Create a new op */
307 op
= acpi_ps_alloc_op (walk_state
->opcode
);
309 return (AE_NO_MEMORY
);
315 op
->named
.name
= node
->name
.integer
;
317 #if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
318 op
->named
.path
= (u8
*) path
;
323 * Put the Node in the "op" object that the parser uses, so we
324 * can get it again quickly when this scope is closed
326 op
->common
.node
= node
;
327 acpi_ps_append_arg (acpi_ps_get_parent_scope (&walk_state
->parser_state
), op
);
334 /*******************************************************************************
336 * FUNCTION: acpi_ds_load1_end_op
338 * PARAMETERS: walk_state - Current state of the parse tree walk
342 * DESCRIPTION: Ascending callback used during the loading of the namespace,
343 * both control methods and everything else.
345 ******************************************************************************/
348 acpi_ds_load1_end_op (
349 struct acpi_walk_state
*walk_state
)
351 union acpi_parse_object
*op
;
352 acpi_object_type object_type
;
353 acpi_status status
= AE_OK
;
356 ACPI_FUNCTION_NAME ("ds_load1_end_op");
360 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "Op=%p State=%p\n", op
, walk_state
));
362 /* We are only interested in opcodes that have an associated name */
364 if (!(walk_state
->op_info
->flags
& (AML_NAMED
| AML_FIELD
))) {
368 /* Get the object type to determine if we should pop the scope */
370 object_type
= walk_state
->op_info
->object_type
;
372 #ifndef ACPI_NO_METHOD_EXECUTION
373 if (walk_state
->op_info
->flags
& AML_FIELD
) {
374 if (walk_state
->opcode
== AML_FIELD_OP
||
375 walk_state
->opcode
== AML_BANK_FIELD_OP
||
376 walk_state
->opcode
== AML_INDEX_FIELD_OP
) {
377 status
= acpi_ds_init_field_objects (op
, walk_state
);
383 if (op
->common
.aml_opcode
== AML_REGION_OP
) {
384 status
= acpi_ex_create_region (op
->named
.data
, op
->named
.length
,
385 (acpi_adr_space_type
)
386 ((op
->common
.value
.arg
)->common
.value
.integer
),
388 if (ACPI_FAILURE (status
)) {
394 if (op
->common
.aml_opcode
== AML_NAME_OP
) {
395 /* For Name opcode, get the object type from the argument */
397 if (op
->common
.value
.arg
) {
398 object_type
= (acpi_ps_get_opcode_info (
399 (op
->common
.value
.arg
)->common
.aml_opcode
))->object_type
;
400 op
->common
.node
->type
= (u8
) object_type
;
404 if (op
->common
.aml_opcode
== AML_METHOD_OP
) {
406 * method_op pkg_length name_string method_flags term_list
408 * Note: We must create the method node/object pair as soon as we
409 * see the method declaration. This allows later pass1 parsing
410 * of invocations of the method (need to know the number of
413 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
414 "LOADING-Method: State=%p Op=%p named_obj=%p\n",
415 walk_state
, op
, op
->named
.node
));
417 if (!acpi_ns_get_attached_object (op
->named
.node
)) {
418 walk_state
->operands
[0] = (void *) op
->named
.node
;
419 walk_state
->num_operands
= 1;
421 status
= acpi_ds_create_operands (walk_state
, op
->common
.value
.arg
);
422 if (ACPI_SUCCESS (status
)) {
423 status
= acpi_ex_create_method (op
->named
.data
,
424 op
->named
.length
, walk_state
);
426 walk_state
->operands
[0] = NULL
;
427 walk_state
->num_operands
= 0;
429 if (ACPI_FAILURE (status
)) {
435 /* Pop the scope stack */
437 if (acpi_ns_opens_scope (object_type
)) {
438 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "(%s): Popping scope for Op %p\n",
439 acpi_ut_get_type_name (object_type
), op
));
441 status
= acpi_ds_scope_stack_pop (walk_state
);
448 /*******************************************************************************
450 * FUNCTION: acpi_ds_load2_begin_op
452 * PARAMETERS: walk_state - Current state of the parse tree walk
453 * out_op - Wher to return op if a new one is created
457 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
459 ******************************************************************************/
462 acpi_ds_load2_begin_op (
463 struct acpi_walk_state
*walk_state
,
464 union acpi_parse_object
**out_op
)
466 union acpi_parse_object
*op
;
467 struct acpi_namespace_node
*node
;
469 acpi_object_type object_type
;
473 ACPI_FUNCTION_TRACE ("ds_load2_begin_op");
477 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "Op=%p State=%p\n", op
, walk_state
));
480 if ((walk_state
->control_state
) &&
481 (walk_state
->control_state
->common
.state
==
482 ACPI_CONTROL_CONDITIONAL_EXECUTING
)) {
483 /* We are executing a while loop outside of a method */
485 status
= acpi_ds_exec_begin_op (walk_state
, out_op
);
486 return_ACPI_STATUS (status
);
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_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
497 "Begin/EXEC: %s (fl %8.8X)\n", walk_state
->op_info
->name
,
498 walk_state
->op_info
->flags
));
500 /* Executing a type1 or type2 opcode outside of a method */
502 status
= acpi_ds_exec_begin_op (walk_state
, out_op
);
503 return_ACPI_STATUS (status
);
505 return_ACPI_STATUS (AE_OK
);
508 /* Get the name we are going to enter or lookup in the namespace */
510 if (walk_state
->opcode
== AML_INT_NAMEPATH_OP
) {
511 /* For Namepath op, get the path string */
513 buffer_ptr
= op
->common
.value
.string
;
515 /* No name, just exit */
517 return_ACPI_STATUS (AE_OK
);
521 /* Get name from the op */
523 buffer_ptr
= (char *) &op
->named
.name
;
527 /* Get the namestring from the raw AML */
529 buffer_ptr
= acpi_ps_get_next_namestring (&walk_state
->parser_state
);
532 /* Map the opcode into an internal object type */
534 object_type
= walk_state
->op_info
->object_type
;
536 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
537 "State=%p Op=%p Type=%X\n", walk_state
, op
, object_type
));
540 switch (walk_state
->opcode
) {
542 case AML_BANK_FIELD_OP
:
543 case AML_INDEX_FIELD_OP
:
549 case AML_INT_NAMEPATH_OP
:
552 * The name_path is an object reference to an existing object.
553 * Don't enter the name into the namespace, but look it up
556 status
= acpi_ns_lookup (walk_state
->scope_info
, buffer_ptr
, object_type
,
557 ACPI_IMODE_EXECUTE
, ACPI_NS_SEARCH_PARENT
,
558 walk_state
, &(node
));
564 * The Path is an object reference to an existing object.
565 * Don't enter the name into the namespace, but look it up
568 status
= acpi_ns_lookup (walk_state
->scope_info
, buffer_ptr
, object_type
,
569 ACPI_IMODE_EXECUTE
, ACPI_NS_SEARCH_PARENT
,
570 walk_state
, &(node
));
571 if (ACPI_FAILURE (status
)) {
572 #ifdef ACPI_ASL_COMPILER
573 if (status
== AE_NOT_FOUND
) {
577 ACPI_REPORT_NSERROR (buffer_ptr
, status
);
580 ACPI_REPORT_NSERROR (buffer_ptr
, status
);
582 return_ACPI_STATUS (status
);
585 * We must check to make sure that the target is
586 * one of the opcodes that actually opens a scope
588 switch (node
->type
) {
589 case ACPI_TYPE_LOCAL_SCOPE
: /* Scope */
590 case ACPI_TYPE_DEVICE
:
591 case ACPI_TYPE_POWER
:
592 case ACPI_TYPE_PROCESSOR
:
593 case ACPI_TYPE_THERMAL
:
595 /* These are acceptable types */
598 case ACPI_TYPE_INTEGER
:
599 case ACPI_TYPE_STRING
:
600 case ACPI_TYPE_BUFFER
:
603 * These types we will allow, but we will change the type. This
604 * enables some existing code of the form:
607 * Scope (DEB) { ... }
610 ACPI_REPORT_WARNING ((
611 "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
612 buffer_ptr
, acpi_ut_get_type_name (node
->type
)));
614 node
->type
= ACPI_TYPE_ANY
;
615 walk_state
->scope_info
->common
.value
= ACPI_TYPE_ANY
;
620 /* All other types are an error */
623 "Invalid type (%s) for target of Scope operator [%4.4s]\n",
624 acpi_ut_get_type_name (node
->type
), buffer_ptr
));
626 return (AE_AML_OPERAND_TYPE
);
632 /* All other opcodes */
634 if (op
&& op
->common
.node
) {
635 /* This op/node was previously entered into the namespace */
637 node
= op
->common
.node
;
639 if (acpi_ns_opens_scope (object_type
)) {
640 status
= acpi_ds_scope_stack_push (node
, object_type
, walk_state
);
641 if (ACPI_FAILURE (status
)) {
642 return_ACPI_STATUS (status
);
646 return_ACPI_STATUS (AE_OK
);
650 * Enter the named type into the internal namespace. We enter the name
651 * as we go downward in the parse tree. Any necessary subobjects that
652 * involve arguments to the opcode must be created as we go back up the
655 * Note: Name may already exist if we are executing a deferred opcode.
657 if (walk_state
->deferred_node
) {
658 /* This name is already in the namespace, get the node */
660 node
= walk_state
->deferred_node
;
665 /* Add new entry into namespace */
667 status
= acpi_ns_lookup (walk_state
->scope_info
, buffer_ptr
, object_type
,
668 ACPI_IMODE_LOAD_PASS2
, ACPI_NS_NO_UPSEARCH
,
669 walk_state
, &(node
));
673 if (ACPI_FAILURE (status
)) {
674 ACPI_REPORT_NSERROR (buffer_ptr
, status
);
675 return_ACPI_STATUS (status
);
679 /* Create a new op */
681 op
= acpi_ps_alloc_op (walk_state
->opcode
);
683 return_ACPI_STATUS (AE_NO_MEMORY
);
686 /* Initialize the new op */
689 op
->named
.name
= node
->name
.integer
;
695 * Put the Node in the "op" object that the parser uses, so we
696 * can get it again quickly when this scope is closed
698 op
->common
.node
= node
;
700 return_ACPI_STATUS (status
);
704 /*******************************************************************************
706 * FUNCTION: acpi_ds_load2_end_op
708 * PARAMETERS: walk_state - Current state of the parse tree walk
712 * DESCRIPTION: Ascending callback used during the loading of the namespace,
713 * both control methods and everything else.
715 ******************************************************************************/
718 acpi_ds_load2_end_op (
719 struct acpi_walk_state
*walk_state
)
721 union acpi_parse_object
*op
;
722 acpi_status status
= AE_OK
;
723 acpi_object_type object_type
;
724 struct acpi_namespace_node
*node
;
725 union acpi_parse_object
*arg
;
726 struct acpi_namespace_node
*new_node
;
727 #ifndef ACPI_NO_METHOD_EXECUTION
732 ACPI_FUNCTION_TRACE ("ds_load2_end_op");
735 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "Opcode [%s] Op %p State %p\n",
736 walk_state
->op_info
->name
, op
, walk_state
));
738 /* Check if opcode had an associated namespace object */
740 if (!(walk_state
->op_info
->flags
& AML_NSOBJECT
)) {
741 #ifndef ACPI_NO_METHOD_EXECUTION
742 /* No namespace object. Executable opcode? */
744 if ((walk_state
->op_info
->class == AML_CLASS_EXECUTE
) ||
745 (walk_state
->op_info
->class == AML_CLASS_CONTROL
)) {
746 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
747 "End/EXEC: %s (fl %8.8X)\n", walk_state
->op_info
->name
,
748 walk_state
->op_info
->flags
));
750 /* Executing a type1 or type2 opcode outside of a method */
752 status
= acpi_ds_exec_end_op (walk_state
);
753 return_ACPI_STATUS (status
);
756 return_ACPI_STATUS (AE_OK
);
759 if (op
->common
.aml_opcode
== AML_SCOPE_OP
) {
760 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
761 "Ending scope Op=%p State=%p\n", op
, walk_state
));
764 object_type
= walk_state
->op_info
->object_type
;
767 * Get the Node/name from the earlier lookup
768 * (It was saved in the *op structure)
770 node
= op
->common
.node
;
773 * Put the Node on the object stack (Contains the ACPI Name of
776 walk_state
->operands
[0] = (void *) node
;
777 walk_state
->num_operands
= 1;
779 /* Pop the scope stack */
781 if (acpi_ns_opens_scope (object_type
) &&
782 (op
->common
.aml_opcode
!= AML_INT_METHODCALL_OP
)) {
783 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
, "(%s) Popping scope for Op %p\n",
784 acpi_ut_get_type_name (object_type
), op
));
786 status
= acpi_ds_scope_stack_pop (walk_state
);
787 if (ACPI_FAILURE (status
)) {
793 * Named operations are as follows:
798 * AML_CREATEBYTEFIELD
799 * AML_CREATEDWORDFIELD
801 * AML_CREATEQWORDFIELD
802 * AML_CREATEWORDFIELD
820 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
), walk_state
, op
, node
));
824 /* Decode the opcode */
826 arg
= op
->common
.value
.arg
;
828 switch (walk_state
->op_info
->type
) {
829 #ifndef ACPI_NO_METHOD_EXECUTION
831 case AML_TYPE_CREATE_FIELD
:
834 * Create the field object, but the field buffer and index must
835 * be evaluated later during the execution phase
837 status
= acpi_ds_create_buffer_field (op
, walk_state
);
841 case AML_TYPE_NAMED_FIELD
:
843 switch (op
->common
.aml_opcode
) {
844 case AML_INDEX_FIELD_OP
:
846 status
= acpi_ds_create_index_field (op
, (acpi_handle
) arg
->common
.node
,
850 case AML_BANK_FIELD_OP
:
852 status
= acpi_ds_create_bank_field (op
, arg
->common
.node
, walk_state
);
857 status
= acpi_ds_create_field (op
, arg
->common
.node
, walk_state
);
861 /* All NAMED_FIELD opcodes must be handled above */
867 case AML_TYPE_NAMED_SIMPLE
:
869 status
= acpi_ds_create_operands (walk_state
, arg
);
870 if (ACPI_FAILURE (status
)) {
874 switch (op
->common
.aml_opcode
) {
875 case AML_PROCESSOR_OP
:
877 status
= acpi_ex_create_processor (walk_state
);
880 case AML_POWER_RES_OP
:
882 status
= acpi_ex_create_power_resource (walk_state
);
887 status
= acpi_ex_create_mutex (walk_state
);
892 status
= acpi_ex_create_event (walk_state
);
895 case AML_DATA_REGION_OP
:
897 status
= acpi_ex_create_table_region (walk_state
);
902 status
= acpi_ex_create_alias (walk_state
);
912 /* Delete operands */
914 for (i
= 1; i
< walk_state
->num_operands
; i
++) {
915 acpi_ut_remove_reference (walk_state
->operands
[i
]);
916 walk_state
->operands
[i
] = NULL
;
920 #endif /* ACPI_NO_METHOD_EXECUTION */
922 case AML_TYPE_NAMED_COMPLEX
:
924 switch (op
->common
.aml_opcode
) {
925 #ifndef ACPI_NO_METHOD_EXECUTION
928 * The op_region is not fully parsed at this time. Only valid
929 * argument is the space_id. (We must save the address of the
930 * AML of the address and length operands)
933 * If we have a valid region, initialize it
934 * Namespace is NOT locked at this point.
936 status
= acpi_ev_initialize_region (acpi_ns_get_attached_object (node
),
938 if (ACPI_FAILURE (status
)) {
940 * If AE_NOT_EXIST is returned, it is not fatal
941 * because many regions get created before a handler
942 * is installed for said region.
944 if (AE_NOT_EXIST
== status
) {
953 status
= acpi_ds_create_node (walk_state
, node
, op
);
955 #endif /* ACPI_NO_METHOD_EXECUTION */
959 /* All NAMED_COMPLEX opcodes must be handled above */
960 /* Note: Method objects were already created in Pass 1 */
966 case AML_CLASS_INTERNAL
:
968 /* case AML_INT_NAMEPATH_OP: */
972 case AML_CLASS_METHOD_CALL
:
974 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH
,
975 "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
976 walk_state
, op
, node
));
979 * Lookup the method name and save the Node
981 status
= acpi_ns_lookup (walk_state
->scope_info
, arg
->common
.value
.string
,
982 ACPI_TYPE_ANY
, ACPI_IMODE_LOAD_PASS2
,
983 ACPI_NS_SEARCH_PARENT
| ACPI_NS_DONT_OPEN_SCOPE
,
984 walk_state
, &(new_node
));
985 if (ACPI_SUCCESS (status
)) {
988 * Make sure that what we found is indeed a method
989 * We didn't search for a method on purpose, to see if the name
992 if (new_node
->type
!= ACPI_TYPE_METHOD
) {
993 status
= AE_AML_OPERAND_TYPE
;
996 /* We could put the returned object (Node) on the object stack for
997 * later, but for now, we will put it in the "op" object that the
998 * parser uses, so we can get it again at the end of this scope
1000 op
->common
.node
= new_node
;
1003 ACPI_REPORT_NSERROR (arg
->common
.value
.string
, status
);
1014 /* Remove the Node pushed at the very beginning */
1016 walk_state
->operands
[0] = NULL
;
1017 walk_state
->num_operands
= 0;
1018 return_ACPI_STATUS (status
);