[ACPI] ACPICA 20060210
[linux-2.6] / drivers / acpi / dispatcher / dswload.c
1 /******************************************************************************
2  *
3  * Module Name: dswload - Dispatcher namespace load callbacks
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2006, R. Byron Moore
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43
44 #include <acpi/acpi.h>
45 #include <acpi/acparser.h>
46 #include <acpi/amlcode.h>
47 #include <acpi/acdispat.h>
48 #include <acpi/acinterp.h>
49 #include <acpi/acnamesp.h>
50 #include <acpi/acevents.h>
51
52 #ifdef ACPI_ASL_COMPILER
53 #include <acpi/acdisasm.h>
54 #endif
55
56 #define _COMPONENT          ACPI_DISPATCHER
57 ACPI_MODULE_NAME("dswload")
58
59 /*******************************************************************************
60  *
61  * FUNCTION:    acpi_ds_init_callbacks
62  *
63  * PARAMETERS:  walk_state      - Current state of the parse tree walk
64  *              pass_number     - 1, 2, or 3
65  *
66  * RETURN:      Status
67  *
68  * DESCRIPTION: Init walk state callbacks
69  *
70  ******************************************************************************/
71 acpi_status
72 acpi_ds_init_callbacks(struct acpi_walk_state *walk_state, u32 pass_number)
73 {
74
75         switch (pass_number) {
76         case 1:
77                 walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 |
78                     ACPI_PARSE_DELETE_TREE;
79                 walk_state->descending_callback = acpi_ds_load1_begin_op;
80                 walk_state->ascending_callback = acpi_ds_load1_end_op;
81                 break;
82
83         case 2:
84                 walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 |
85                     ACPI_PARSE_DELETE_TREE;
86                 walk_state->descending_callback = acpi_ds_load2_begin_op;
87                 walk_state->ascending_callback = acpi_ds_load2_end_op;
88                 break;
89
90         case 3:
91 #ifndef ACPI_NO_METHOD_EXECUTION
92                 walk_state->parse_flags |= ACPI_PARSE_EXECUTE |
93                     ACPI_PARSE_DELETE_TREE;
94                 walk_state->descending_callback = acpi_ds_exec_begin_op;
95                 walk_state->ascending_callback = acpi_ds_exec_end_op;
96 #endif
97                 break;
98
99         default:
100                 return (AE_BAD_PARAMETER);
101         }
102
103         return (AE_OK);
104 }
105
106 /*******************************************************************************
107  *
108  * FUNCTION:    acpi_ds_load1_begin_op
109  *
110  * PARAMETERS:  walk_state      - Current state of the parse tree walk
111  *              out_op          - Where to return op if a new one is created
112  *
113  * RETURN:      Status
114  *
115  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
116  *
117  ******************************************************************************/
118
119 acpi_status
120 acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
121                        union acpi_parse_object ** out_op)
122 {
123         union acpi_parse_object *op;
124         struct acpi_namespace_node *node;
125         acpi_status status;
126         acpi_object_type object_type;
127         char *path;
128         u32 flags;
129
130         ACPI_FUNCTION_TRACE("ds_load1_begin_op");
131
132         op = walk_state->op;
133         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
134                           walk_state));
135
136         /* We are only interested in opcodes that have an associated name */
137
138         if (op) {
139                 if (!(walk_state->op_info->flags & AML_NAMED)) {
140                         *out_op = op;
141                         return_ACPI_STATUS(AE_OK);
142                 }
143
144                 /* Check if this object has already been installed in the namespace */
145
146                 if (op->common.node) {
147                         *out_op = op;
148                         return_ACPI_STATUS(AE_OK);
149                 }
150         }
151
152         path = acpi_ps_get_next_namestring(&walk_state->parser_state);
153
154         /* Map the raw opcode into an internal object type */
155
156         object_type = walk_state->op_info->object_type;
157
158         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
159                           "State=%p Op=%p [%s]\n", walk_state, op,
160                           acpi_ut_get_type_name(object_type)));
161
162         switch (walk_state->opcode) {
163         case AML_SCOPE_OP:
164
165                 /*
166                  * The target name of the Scope() operator must exist at this point so
167                  * that we can actually open the scope to enter new names underneath it.
168                  * Allow search-to-root for single namesegs.
169                  */
170                 status =
171                     acpi_ns_lookup(walk_state->scope_info, path, object_type,
172                                    ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
173                                    walk_state, &(node));
174 #ifdef ACPI_ASL_COMPILER
175                 if (status == AE_NOT_FOUND) {
176                         /*
177                          * Table disassembly:
178                          * Target of Scope() not found.  Generate an External for it, and
179                          * insert the name into the namespace.
180                          */
181                         acpi_dm_add_to_external_list(path);
182                         status =
183                             acpi_ns_lookup(walk_state->scope_info, path,
184                                            object_type, ACPI_IMODE_LOAD_PASS1,
185                                            ACPI_NS_SEARCH_PARENT, walk_state,
186                                            &(node));
187                 }
188 #endif
189                 if (ACPI_FAILURE(status)) {
190                         ACPI_ERROR_NAMESPACE(path, status);
191                         return_ACPI_STATUS(status);
192                 }
193
194                 /*
195                  * Check to make sure that the target is
196                  * one of the opcodes that actually opens a scope
197                  */
198                 switch (node->type) {
199                 case ACPI_TYPE_LOCAL_SCOPE:     /* Scope  */
200                 case ACPI_TYPE_DEVICE:
201                 case ACPI_TYPE_POWER:
202                 case ACPI_TYPE_PROCESSOR:
203                 case ACPI_TYPE_THERMAL:
204
205                         /* These are acceptable types */
206                         break;
207
208                 case ACPI_TYPE_INTEGER:
209                 case ACPI_TYPE_STRING:
210                 case ACPI_TYPE_BUFFER:
211
212                         /*
213                          * These types we will allow, but we will change the type.  This
214                          * enables some existing code of the form:
215                          *
216                          *  Name (DEB, 0)
217                          *  Scope (DEB) { ... }
218                          *
219                          * Note: silently change the type here.  On the second pass, we will report
220                          * a warning
221                          */
222
223                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
224                                           "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
225                                           path,
226                                           acpi_ut_get_type_name(node->type)));
227
228                         node->type = ACPI_TYPE_ANY;
229                         walk_state->scope_info->common.value = ACPI_TYPE_ANY;
230                         break;
231
232                 default:
233
234                         /* All other types are an error */
235
236                         ACPI_ERROR((AE_INFO,
237                                     "Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)",
238                                     acpi_ut_get_type_name(node->type), path));
239
240                         return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
241                 }
242                 break;
243
244         default:
245
246                 /*
247                  * For all other named opcodes, we will enter the name into
248                  * the namespace.
249                  *
250                  * Setup the search flags.
251                  * Since we are entering a name into the namespace, we do not want to
252                  * enable the search-to-root upsearch.
253                  *
254                  * There are only two conditions where it is acceptable that the name
255                  * already exists:
256                  *    1) the Scope() operator can reopen a scoping object that was
257                  *       previously defined (Scope, Method, Device, etc.)
258                  *    2) Whenever we are parsing a deferred opcode (op_region, Buffer,
259                  *       buffer_field, or Package), the name of the object is already
260                  *       in the namespace.
261                  */
262
263                 if (walk_state->deferred_node) {
264
265                         /* This name is already in the namespace, get the node */
266
267                         node = walk_state->deferred_node;
268                         status = AE_OK;
269                         break;
270                 }
271
272                 /*
273                  * If we are executing a method, do not create any namespace objects
274                  * during the load phase, only during execution.
275                  */
276                 if (walk_state->method_node) {
277                         node = NULL;
278                         status = AE_OK;
279                         break;
280                 }
281
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,
287                                           "[%s] Cannot already exist\n",
288                                           acpi_ut_get_type_name(object_type)));
289                 } else {
290                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
291                                           "[%s] Both Find or Create allowed\n",
292                                           acpi_ut_get_type_name(object_type)));
293                 }
294
295                 /*
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
299                  * parse tree later.
300                  */
301                 status =
302                     acpi_ns_lookup(walk_state->scope_info, path, object_type,
303                                    ACPI_IMODE_LOAD_PASS1, flags, walk_state,
304                                    &(node));
305                 if (ACPI_FAILURE(status)) {
306                         ACPI_ERROR_NAMESPACE(path, status);
307                         return_ACPI_STATUS(status);
308                 }
309                 break;
310         }
311
312         /* Common exit */
313
314         if (!op) {
315
316                 /* Create a new op */
317
318                 op = acpi_ps_alloc_op(walk_state->opcode);
319                 if (!op) {
320                         return_ACPI_STATUS(AE_NO_MEMORY);
321                 }
322         }
323
324         /* Initialize the op */
325
326 #if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
327         op->named.path = ACPI_CAST_PTR(u8, path);
328 #endif
329
330         if (node) {
331                 /*
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
334                  */
335                 op->common.node = node;
336                 op->named.name = node->name.integer;
337         }
338
339         acpi_ps_append_arg(acpi_ps_get_parent_scope(&walk_state->parser_state),
340                            op);
341         *out_op = op;
342         return_ACPI_STATUS(status);
343 }
344
345 /*******************************************************************************
346  *
347  * FUNCTION:    acpi_ds_load1_end_op
348  *
349  * PARAMETERS:  walk_state      - Current state of the parse tree walk
350  *
351  * RETURN:      Status
352  *
353  * DESCRIPTION: Ascending callback used during the loading of the namespace,
354  *              both control methods and everything else.
355  *
356  ******************************************************************************/
357
358 acpi_status acpi_ds_load1_end_op(struct acpi_walk_state *walk_state)
359 {
360         union acpi_parse_object *op;
361         acpi_object_type object_type;
362         acpi_status status = AE_OK;
363
364         ACPI_FUNCTION_TRACE("ds_load1_end_op");
365
366         op = walk_state->op;
367         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
368                           walk_state));
369
370         /* We are only interested in opcodes that have an associated name */
371
372         if (!(walk_state->op_info->flags & (AML_NAMED | AML_FIELD))) {
373                 return_ACPI_STATUS(AE_OK);
374         }
375
376         /* Get the object type to determine if we should pop the scope */
377
378         object_type = walk_state->op_info->object_type;
379
380 #ifndef ACPI_NO_METHOD_EXECUTION
381         if (walk_state->op_info->flags & AML_FIELD) {
382                 /*
383                  * If we are executing a method, do not create any namespace objects
384                  * during the load phase, only during execution.
385                  */
386                 if (!walk_state->method_node) {
387                         if (walk_state->opcode == AML_FIELD_OP ||
388                             walk_state->opcode == AML_BANK_FIELD_OP ||
389                             walk_state->opcode == AML_INDEX_FIELD_OP) {
390                                 status =
391                                     acpi_ds_init_field_objects(op, walk_state);
392                         }
393                 }
394                 return_ACPI_STATUS(status);
395         }
396
397         /*
398          * If we are executing a method, do not create any namespace objects
399          * during the load phase, only during execution.
400          */
401         if (!walk_state->method_node) {
402                 if (op->common.aml_opcode == AML_REGION_OP) {
403                         status =
404                             acpi_ex_create_region(op->named.data,
405                                                   op->named.length,
406                                                   (acpi_adr_space_type)
407                                                   ((op->common.value.arg)->
408                                                    common.value.integer),
409                                                   walk_state);
410                         if (ACPI_FAILURE(status)) {
411                                 return_ACPI_STATUS(status);
412                         }
413                 }
414         }
415 #endif
416
417         if (op->common.aml_opcode == AML_NAME_OP) {
418
419                 /* For Name opcode, get the object type from the argument */
420
421                 if (op->common.value.arg) {
422                         object_type = (acpi_ps_get_opcode_info((op->common.
423                                                                 value.arg)->
424                                                                common.
425                                                                aml_opcode))->
426                             object_type;
427
428                         /* Set node type if we have a namespace node */
429
430                         if (op->common.node) {
431                                 op->common.node->type = (u8) object_type;
432                         }
433                 }
434         }
435
436         /*
437          * If we are executing a method, do not create any namespace objects
438          * during the load phase, only during execution.
439          */
440         if (!walk_state->method_node) {
441                 if (op->common.aml_opcode == AML_METHOD_OP) {
442                         /*
443                          * method_op pkg_length name_string method_flags term_list
444                          *
445                          * Note: We must create the method node/object pair as soon as we
446                          * see the method declaration.  This allows later pass1 parsing
447                          * of invocations of the method (need to know the number of
448                          * arguments.)
449                          */
450                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
451                                           "LOADING-Method: State=%p Op=%p named_obj=%p\n",
452                                           walk_state, op, op->named.node));
453
454                         if (!acpi_ns_get_attached_object(op->named.node)) {
455                                 walk_state->operands[0] =
456                                     ACPI_CAST_PTR(void, op->named.node);
457                                 walk_state->num_operands = 1;
458
459                                 status =
460                                     acpi_ds_create_operands(walk_state,
461                                                             op->common.value.
462                                                             arg);
463                                 if (ACPI_SUCCESS(status)) {
464                                         status =
465                                             acpi_ex_create_method(op->named.
466                                                                   data,
467                                                                   op->named.
468                                                                   length,
469                                                                   walk_state);
470                                 }
471                                 walk_state->operands[0] = NULL;
472                                 walk_state->num_operands = 0;
473
474                                 if (ACPI_FAILURE(status)) {
475                                         return_ACPI_STATUS(status);
476                                 }
477                         }
478                 }
479         }
480
481         /* Pop the scope stack (only if loading a table) */
482
483         if (!walk_state->method_node && acpi_ns_opens_scope(object_type)) {
484                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
485                                   "(%s): Popping scope for Op %p\n",
486                                   acpi_ut_get_type_name(object_type), op));
487
488                 status = acpi_ds_scope_stack_pop(walk_state);
489         }
490
491         return_ACPI_STATUS(status);
492 }
493
494 /*******************************************************************************
495  *
496  * FUNCTION:    acpi_ds_load2_begin_op
497  *
498  * PARAMETERS:  walk_state      - Current state of the parse tree walk
499  *              out_op          - Wher to return op if a new one is created
500  *
501  * RETURN:      Status
502  *
503  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
504  *
505  ******************************************************************************/
506
507 acpi_status
508 acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
509                        union acpi_parse_object **out_op)
510 {
511         union acpi_parse_object *op;
512         struct acpi_namespace_node *node;
513         acpi_status status;
514         acpi_object_type object_type;
515         char *buffer_ptr;
516
517         ACPI_FUNCTION_TRACE("ds_load2_begin_op");
518
519         op = walk_state->op;
520         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
521                           walk_state));
522
523         if (op) {
524                 if ((walk_state->control_state) &&
525                     (walk_state->control_state->common.state ==
526                      ACPI_CONTROL_CONDITIONAL_EXECUTING)) {
527
528                         /* We are executing a while loop outside of a method */
529
530                         status = acpi_ds_exec_begin_op(walk_state, out_op);
531                         return_ACPI_STATUS(status);
532                 }
533
534                 /* We only care about Namespace opcodes here */
535
536                 if ((!(walk_state->op_info->flags & AML_NSOPCODE) &&
537                      (walk_state->opcode != AML_INT_NAMEPATH_OP)) ||
538                     (!(walk_state->op_info->flags & AML_NAMED))) {
539 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
540                         if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
541                             (walk_state->op_info->class == AML_CLASS_CONTROL)) {
542
543                                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
544                                                   "Begin/EXEC: %s (fl %8.8X)\n",
545                                                   walk_state->op_info->name,
546                                                   walk_state->op_info->flags));
547
548                                 /* Executing a type1 or type2 opcode outside of a method */
549
550                                 status =
551                                     acpi_ds_exec_begin_op(walk_state, out_op);
552                                 return_ACPI_STATUS(status);
553                         }
554 #endif
555                         return_ACPI_STATUS(AE_OK);
556                 }
557
558                 /* Get the name we are going to enter or lookup in the namespace */
559
560                 if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
561
562                         /* For Namepath op, get the path string */
563
564                         buffer_ptr = op->common.value.string;
565                         if (!buffer_ptr) {
566
567                                 /* No name, just exit */
568
569                                 return_ACPI_STATUS(AE_OK);
570                         }
571                 } else {
572                         /* Get name from the op */
573
574                         buffer_ptr = (char *)&op->named.name;
575                 }
576         } else {
577                 /* Get the namestring from the raw AML */
578
579                 buffer_ptr =
580                     acpi_ps_get_next_namestring(&walk_state->parser_state);
581         }
582
583         /* Map the opcode into an internal object type */
584
585         object_type = walk_state->op_info->object_type;
586
587         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
588                           "State=%p Op=%p Type=%X\n", walk_state, op,
589                           object_type));
590
591         switch (walk_state->opcode) {
592         case AML_FIELD_OP:
593         case AML_BANK_FIELD_OP:
594         case AML_INDEX_FIELD_OP:
595
596                 node = NULL;
597                 status = AE_OK;
598                 break;
599
600         case AML_INT_NAMEPATH_OP:
601
602                 /*
603                  * The name_path is an object reference to an existing object.
604                  * Don't enter the name into the namespace, but look it up
605                  * for use later.
606                  */
607                 status =
608                     acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
609                                    object_type, ACPI_IMODE_EXECUTE,
610                                    ACPI_NS_SEARCH_PARENT, walk_state, &(node));
611                 break;
612
613         case AML_SCOPE_OP:
614
615                 /*
616                  * The Path is an object reference to an existing object.
617                  * Don't enter the name into the namespace, but look it up
618                  * for use later.
619                  */
620                 status =
621                     acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
622                                    object_type, ACPI_IMODE_EXECUTE,
623                                    ACPI_NS_SEARCH_PARENT, walk_state, &(node));
624                 if (ACPI_FAILURE(status)) {
625 #ifdef ACPI_ASL_COMPILER
626                         if (status == AE_NOT_FOUND) {
627                                 status = AE_OK;
628                         } else {
629                                 ACPI_ERROR_NAMESPACE(buffer_ptr, status);
630                         }
631 #else
632                         ACPI_ERROR_NAMESPACE(buffer_ptr, status);
633 #endif
634                         return_ACPI_STATUS(status);
635                 }
636                 /*
637                  * We must check to make sure that the target is
638                  * one of the opcodes that actually opens a scope
639                  */
640                 switch (node->type) {
641                 case ACPI_TYPE_LOCAL_SCOPE:     /* Scope */
642                 case ACPI_TYPE_DEVICE:
643                 case ACPI_TYPE_POWER:
644                 case ACPI_TYPE_PROCESSOR:
645                 case ACPI_TYPE_THERMAL:
646
647                         /* These are acceptable types */
648                         break;
649
650                 case ACPI_TYPE_INTEGER:
651                 case ACPI_TYPE_STRING:
652                 case ACPI_TYPE_BUFFER:
653
654                         /*
655                          * These types we will allow, but we will change the type.  This
656                          * enables some existing code of the form:
657                          *
658                          *  Name (DEB, 0)
659                          *  Scope (DEB) { ... }
660                          */
661
662                         ACPI_WARNING((AE_INFO,
663                                       "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)",
664                                       buffer_ptr,
665                                       acpi_ut_get_type_name(node->type)));
666
667                         node->type = ACPI_TYPE_ANY;
668                         walk_state->scope_info->common.value = ACPI_TYPE_ANY;
669                         break;
670
671                 default:
672
673                         /* All other types are an error */
674
675                         ACPI_ERROR((AE_INFO,
676                                     "Invalid type (%s) for target of Scope operator [%4.4s]",
677                                     acpi_ut_get_type_name(node->type),
678                                     buffer_ptr));
679
680                         return (AE_AML_OPERAND_TYPE);
681                 }
682                 break;
683
684         default:
685
686                 /* All other opcodes */
687
688                 if (op && op->common.node) {
689
690                         /* This op/node was previously entered into the namespace */
691
692                         node = op->common.node;
693
694                         if (acpi_ns_opens_scope(object_type)) {
695                                 status =
696                                     acpi_ds_scope_stack_push(node, object_type,
697                                                              walk_state);
698                                 if (ACPI_FAILURE(status)) {
699                                         return_ACPI_STATUS(status);
700                                 }
701
702                         }
703                         return_ACPI_STATUS(AE_OK);
704                 }
705
706                 /*
707                  * Enter the named type into the internal namespace.  We enter the name
708                  * as we go downward in the parse tree.  Any necessary subobjects that
709                  * involve arguments to the opcode must be created as we go back up the
710                  * parse tree later.
711                  *
712                  * Note: Name may already exist if we are executing a deferred opcode.
713                  */
714                 if (walk_state->deferred_node) {
715
716                         /* This name is already in the namespace, get the node */
717
718                         node = walk_state->deferred_node;
719                         status = AE_OK;
720                         break;
721                 }
722
723                 /* Add new entry into namespace */
724
725                 status =
726                     acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
727                                    object_type, ACPI_IMODE_LOAD_PASS2,
728                                    ACPI_NS_NO_UPSEARCH, walk_state, &(node));
729                 break;
730         }
731
732         if (ACPI_FAILURE(status)) {
733                 ACPI_ERROR_NAMESPACE(buffer_ptr, status);
734                 return_ACPI_STATUS(status);
735         }
736
737         if (!op) {
738
739                 /* Create a new op */
740
741                 op = acpi_ps_alloc_op(walk_state->opcode);
742                 if (!op) {
743                         return_ACPI_STATUS(AE_NO_MEMORY);
744                 }
745
746                 /* Initialize the new op */
747
748                 if (node) {
749                         op->named.name = node->name.integer;
750                 }
751                 *out_op = op;
752         }
753
754         /*
755          * Put the Node in the "op" object that the parser uses, so we
756          * can get it again quickly when this scope is closed
757          */
758         op->common.node = node;
759
760         return_ACPI_STATUS(status);
761 }
762
763 /*******************************************************************************
764  *
765  * FUNCTION:    acpi_ds_load2_end_op
766  *
767  * PARAMETERS:  walk_state      - Current state of the parse tree walk
768  *
769  * RETURN:      Status
770  *
771  * DESCRIPTION: Ascending callback used during the loading of the namespace,
772  *              both control methods and everything else.
773  *
774  ******************************************************************************/
775
776 acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
777 {
778         union acpi_parse_object *op;
779         acpi_status status = AE_OK;
780         acpi_object_type object_type;
781         struct acpi_namespace_node *node;
782         union acpi_parse_object *arg;
783         struct acpi_namespace_node *new_node;
784 #ifndef ACPI_NO_METHOD_EXECUTION
785         u32 i;
786 #endif
787
788         ACPI_FUNCTION_TRACE("ds_load2_end_op");
789
790         op = walk_state->op;
791         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
792                           walk_state->op_info->name, op, walk_state));
793
794         /* Check if opcode had an associated namespace object */
795
796         if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
797 #ifndef ACPI_NO_METHOD_EXECUTION
798 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
799                 /* No namespace object. Executable opcode? */
800
801                 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
802                     (walk_state->op_info->class == AML_CLASS_CONTROL)) {
803                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
804                                           "End/EXEC:   %s (fl %8.8X)\n",
805                                           walk_state->op_info->name,
806                                           walk_state->op_info->flags));
807
808                         /* Executing a type1 or type2 opcode outside of a method */
809
810                         status = acpi_ds_exec_end_op(walk_state);
811                         return_ACPI_STATUS(status);
812                 }
813 #endif
814 #endif
815                 return_ACPI_STATUS(AE_OK);
816         }
817
818         if (op->common.aml_opcode == AML_SCOPE_OP) {
819                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
820                                   "Ending scope Op=%p State=%p\n", op,
821                                   walk_state));
822         }
823
824         object_type = walk_state->op_info->object_type;
825
826         /*
827          * Get the Node/name from the earlier lookup
828          * (It was saved in the *op structure)
829          */
830         node = op->common.node;
831
832         /*
833          * Put the Node on the object stack (Contains the ACPI Name of
834          * this object)
835          */
836         walk_state->operands[0] = (void *)node;
837         walk_state->num_operands = 1;
838
839         /* Pop the scope stack */
840
841         if (acpi_ns_opens_scope(object_type) &&
842             (op->common.aml_opcode != AML_INT_METHODCALL_OP)) {
843                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
844                                   "(%s) Popping scope for Op %p\n",
845                                   acpi_ut_get_type_name(object_type), op));
846
847                 status = acpi_ds_scope_stack_pop(walk_state);
848                 if (ACPI_FAILURE(status)) {
849                         goto cleanup;
850                 }
851         }
852
853         /*
854          * Named operations are as follows:
855          *
856          * AML_ALIAS
857          * AML_BANKFIELD
858          * AML_CREATEBITFIELD
859          * AML_CREATEBYTEFIELD
860          * AML_CREATEDWORDFIELD
861          * AML_CREATEFIELD
862          * AML_CREATEQWORDFIELD
863          * AML_CREATEWORDFIELD
864          * AML_DATA_REGION
865          * AML_DEVICE
866          * AML_EVENT
867          * AML_FIELD
868          * AML_INDEXFIELD
869          * AML_METHOD
870          * AML_METHODCALL
871          * AML_MUTEX
872          * AML_NAME
873          * AML_NAMEDFIELD
874          * AML_OPREGION
875          * AML_POWERRES
876          * AML_PROCESSOR
877          * AML_SCOPE
878          * AML_THERMALZONE
879          */
880
881         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
882                           "Create-Load [%s] State=%p Op=%p named_obj=%p\n",
883                           acpi_ps_get_opcode_name(op->common.aml_opcode),
884                           walk_state, op, node));
885
886         /* Decode the opcode */
887
888         arg = op->common.value.arg;
889
890         switch (walk_state->op_info->type) {
891 #ifndef ACPI_NO_METHOD_EXECUTION
892
893         case AML_TYPE_CREATE_FIELD:
894
895                 /*
896                  * Create the field object, but the field buffer and index must
897                  * be evaluated later during the execution phase
898                  */
899                 status = acpi_ds_create_buffer_field(op, walk_state);
900                 break;
901
902         case AML_TYPE_NAMED_FIELD:
903
904                 /*
905                  * If we are executing a method, initialize the field
906                  */
907                 if (walk_state->method_node) {
908                         status = acpi_ds_init_field_objects(op, walk_state);
909                 }
910
911                 switch (op->common.aml_opcode) {
912                 case AML_INDEX_FIELD_OP:
913
914                         status =
915                             acpi_ds_create_index_field(op,
916                                                        (acpi_handle) arg->
917                                                        common.node, walk_state);
918                         break;
919
920                 case AML_BANK_FIELD_OP:
921
922                         status =
923                             acpi_ds_create_bank_field(op, arg->common.node,
924                                                       walk_state);
925                         break;
926
927                 case AML_FIELD_OP:
928
929                         status =
930                             acpi_ds_create_field(op, arg->common.node,
931                                                  walk_state);
932                         break;
933
934                 default:
935                         /* All NAMED_FIELD opcodes must be handled above */
936                         break;
937                 }
938                 break;
939
940         case AML_TYPE_NAMED_SIMPLE:
941
942                 status = acpi_ds_create_operands(walk_state, arg);
943                 if (ACPI_FAILURE(status)) {
944                         goto cleanup;
945                 }
946
947                 switch (op->common.aml_opcode) {
948                 case AML_PROCESSOR_OP:
949
950                         status = acpi_ex_create_processor(walk_state);
951                         break;
952
953                 case AML_POWER_RES_OP:
954
955                         status = acpi_ex_create_power_resource(walk_state);
956                         break;
957
958                 case AML_MUTEX_OP:
959
960                         status = acpi_ex_create_mutex(walk_state);
961                         break;
962
963                 case AML_EVENT_OP:
964
965                         status = acpi_ex_create_event(walk_state);
966                         break;
967
968                 case AML_DATA_REGION_OP:
969
970                         status = acpi_ex_create_table_region(walk_state);
971                         break;
972
973                 case AML_ALIAS_OP:
974
975                         status = acpi_ex_create_alias(walk_state);
976                         break;
977
978                 default:
979                         /* Unknown opcode */
980
981                         status = AE_OK;
982                         goto cleanup;
983                 }
984
985                 /* Delete operands */
986
987                 for (i = 1; i < walk_state->num_operands; i++) {
988                         acpi_ut_remove_reference(walk_state->operands[i]);
989                         walk_state->operands[i] = NULL;
990                 }
991
992                 break;
993 #endif                          /* ACPI_NO_METHOD_EXECUTION */
994
995         case AML_TYPE_NAMED_COMPLEX:
996
997                 switch (op->common.aml_opcode) {
998 #ifndef ACPI_NO_METHOD_EXECUTION
999                 case AML_REGION_OP:
1000
1001                         /*
1002                          * If we are executing a method, initialize the region
1003                          */
1004                         if (walk_state->method_node) {
1005                                 status =
1006                                     acpi_ex_create_region(op->named.data,
1007                                                           op->named.length,
1008                                                           (acpi_adr_space_type)
1009                                                           ((op->common.value.
1010                                                             arg)->common.value.
1011                                                            integer),
1012                                                           walk_state);
1013                                 if (ACPI_FAILURE(status)) {
1014                                         return (status);
1015                                 }
1016                         }
1017
1018                         /*
1019                          * The op_region is not fully parsed at this time. Only valid
1020                          * argument is the space_id. (We must save the address of the
1021                          * AML of the address and length operands)
1022                          */
1023                         /*
1024                          * If we have a valid region, initialize it
1025                          * Namespace is NOT locked at this point.
1026                          */
1027                         status =
1028                             acpi_ev_initialize_region
1029                             (acpi_ns_get_attached_object(node), FALSE);
1030                         if (ACPI_FAILURE(status)) {
1031                                 /*
1032                                  *  If AE_NOT_EXIST is returned, it is not fatal
1033                                  *  because many regions get created before a handler
1034                                  *  is installed for said region.
1035                                  */
1036                                 if (AE_NOT_EXIST == status) {
1037                                         status = AE_OK;
1038                                 }
1039                         }
1040                         break;
1041
1042                 case AML_NAME_OP:
1043
1044                         status = acpi_ds_create_node(walk_state, node, op);
1045                         break;
1046
1047                 case AML_METHOD_OP:
1048                         /*
1049                          * method_op pkg_length name_string method_flags term_list
1050                          *
1051                          * Note: We must create the method node/object pair as soon as we
1052                          * see the method declaration.  This allows later pass1 parsing
1053                          * of invocations of the method (need to know the number of
1054                          * arguments.)
1055                          */
1056                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
1057                                           "LOADING-Method: State=%p Op=%p named_obj=%p\n",
1058                                           walk_state, op, op->named.node));
1059
1060                         if (!acpi_ns_get_attached_object(op->named.node)) {
1061                                 walk_state->operands[0] =
1062                                     ACPI_CAST_PTR(void, op->named.node);
1063                                 walk_state->num_operands = 1;
1064
1065                                 status =
1066                                     acpi_ds_create_operands(walk_state,
1067                                                             op->common.value.
1068                                                             arg);
1069                                 if (ACPI_SUCCESS(status)) {
1070                                         status =
1071                                             acpi_ex_create_method(op->named.
1072                                                                   data,
1073                                                                   op->named.
1074                                                                   length,
1075                                                                   walk_state);
1076                                 }
1077                                 walk_state->operands[0] = NULL;
1078                                 walk_state->num_operands = 0;
1079
1080                                 if (ACPI_FAILURE(status)) {
1081                                         return_ACPI_STATUS(status);
1082                                 }
1083                         }
1084                         break;
1085
1086 #endif                          /* ACPI_NO_METHOD_EXECUTION */
1087
1088                 default:
1089                         /* All NAMED_COMPLEX opcodes must be handled above */
1090                         break;
1091                 }
1092                 break;
1093
1094         case AML_CLASS_INTERNAL:
1095
1096                 /* case AML_INT_NAMEPATH_OP: */
1097                 break;
1098
1099         case AML_CLASS_METHOD_CALL:
1100
1101                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
1102                                   "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
1103                                   walk_state, op, node));
1104
1105                 /*
1106                  * Lookup the method name and save the Node
1107                  */
1108                 status =
1109                     acpi_ns_lookup(walk_state->scope_info,
1110                                    arg->common.value.string, ACPI_TYPE_ANY,
1111                                    ACPI_IMODE_LOAD_PASS2,
1112                                    ACPI_NS_SEARCH_PARENT |
1113                                    ACPI_NS_DONT_OPEN_SCOPE, walk_state,
1114                                    &(new_node));
1115                 if (ACPI_SUCCESS(status)) {
1116
1117                         /*
1118                          * Make sure that what we found is indeed a method
1119                          * We didn't search for a method on purpose, to see if the name
1120                          * would resolve
1121                          */
1122                         if (new_node->type != ACPI_TYPE_METHOD) {
1123                                 status = AE_AML_OPERAND_TYPE;
1124                         }
1125
1126                         /* We could put the returned object (Node) on the object stack for
1127                          * later, but for now, we will put it in the "op" object that the
1128                          * parser uses, so we can get it again at the end of this scope
1129                          */
1130                         op->common.node = new_node;
1131                 } else {
1132                         ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
1133                 }
1134                 break;
1135
1136         default:
1137                 break;
1138         }
1139
1140       cleanup:
1141
1142         /* Remove the Node pushed at the very beginning */
1143
1144         walk_state->operands[0] = NULL;
1145         walk_state->num_operands = 0;
1146         return_ACPI_STATUS(status);
1147 }