Merge master.kernel.org:/home/rmk/linux-2.6-arm
[linux-2.6.git] / drivers / acpi / dispatcher / dswload.c
1 /******************************************************************************
2  *
3  * Module Name: dswload - Dispatcher namespace load callbacks
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2005, 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
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>
52
53 #ifdef _ACPI_ASL_COMPILER
54 #include <acpi/acdisasm.h>
55 #endif
56
57 #define _COMPONENT          ACPI_DISPATCHER
58          ACPI_MODULE_NAME    ("dswload")
59
60
61 /*******************************************************************************
62  *
63  * FUNCTION:    acpi_ds_init_callbacks
64  *
65  * PARAMETERS:  walk_state      - Current state of the parse tree walk
66  *              pass_number     - 1, 2, or 3
67  *
68  * RETURN:      Status
69  *
70  * DESCRIPTION: Init walk state callbacks
71  *
72  ******************************************************************************/
73
74 acpi_status
75 acpi_ds_init_callbacks (
76         struct acpi_walk_state          *walk_state,
77         u32                             pass_number)
78 {
79
80         switch (pass_number) {
81         case 1:
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;
86                 break;
87
88         case 2:
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;
93                 break;
94
95         case 3:
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;
101 #endif
102                 break;
103
104         default:
105                 return (AE_BAD_PARAMETER);
106         }
107
108         return (AE_OK);
109 }
110
111
112 /*******************************************************************************
113  *
114  * FUNCTION:    acpi_ds_load1_begin_op
115  *
116  * PARAMETERS:  walk_state      - Current state of the parse tree walk
117  *              out_op          - Where to return op if a new one is created
118  *
119  * RETURN:      Status
120  *
121  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
122  *
123  ******************************************************************************/
124
125 acpi_status
126 acpi_ds_load1_begin_op (
127         struct acpi_walk_state          *walk_state,
128         union acpi_parse_object         **out_op)
129 {
130         union acpi_parse_object         *op;
131         struct acpi_namespace_node      *node;
132         acpi_status                     status;
133         acpi_object_type                object_type;
134         char                            *path;
135         u32                             flags;
136
137
138         ACPI_FUNCTION_NAME ("ds_load1_begin_op");
139
140
141         op = walk_state->op;
142         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));
143
144         /* We are only interested in opcodes that have an associated name */
145
146         if (op) {
147                 if (!(walk_state->op_info->flags & AML_NAMED)) {
148 #if 0
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);
153                                 *out_op = op;
154                                 return (AE_CTRL_SKIP);
155                         }
156 #endif
157                         *out_op = op;
158                         return (AE_OK);
159                 }
160
161                 /* Check if this object has already been installed in the namespace */
162
163                 if (op->common.node) {
164                         *out_op = op;
165                         return (AE_OK);
166                 }
167         }
168
169         path = acpi_ps_get_next_namestring (&walk_state->parser_state);
170
171         /* Map the raw opcode into an internal object type */
172
173         object_type = walk_state->op_info->object_type;
174
175         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
176                 "State=%p Op=%p [%s]\n", walk_state, op, acpi_ut_get_type_name (object_type)));
177
178         switch (walk_state->opcode) {
179         case AML_SCOPE_OP:
180
181                 /*
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.
185                  */
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) {
190                         /*
191                          * Table disassembly:
192                          * Target of Scope() not found.  Generate an External for it, and
193                          * insert the name into the namespace.
194                          */
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));
199                 }
200 #endif
201                 if (ACPI_FAILURE (status)) {
202                         ACPI_REPORT_NSERROR (path, status);
203                         return (status);
204                 }
205
206                 /*
207                  * Check to make sure that the target is
208                  * one of the opcodes that actually opens a scope
209                  */
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:
216
217                         /* These are acceptable types */
218                         break;
219
220                 case ACPI_TYPE_INTEGER:
221                 case ACPI_TYPE_STRING:
222                 case ACPI_TYPE_BUFFER:
223
224                         /*
225                          * These types we will allow, but we will change the type.  This
226                          * enables some existing code of the form:
227                          *
228                          *  Name (DEB, 0)
229                          *  Scope (DEB) { ... }
230                          *
231                          * Note: silently change the type here.  On the second pass, we will report
232                          * a warning
233                          */
234
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)));
238
239                         node->type = ACPI_TYPE_ANY;
240                         walk_state->scope_info->common.value = ACPI_TYPE_ANY;
241                         break;
242
243                 default:
244
245                         /* All other types are an error */
246
247                         ACPI_REPORT_ERROR ((
248                                 "Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)\n",
249                                 acpi_ut_get_type_name (node->type), path));
250
251                         return (AE_AML_OPERAND_TYPE);
252                 }
253                 break;
254
255
256         default:
257
258                 /*
259                  * For all other named opcodes, we will enter the name into
260                  * the namespace.
261                  *
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.
265                  *
266                  * There are only two conditions where it is acceptable that the name
267                  * already exists:
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
272                  *       in the namespace.
273                  */
274                 if (walk_state->deferred_node) {
275                         /* This name is already in the namespace, get the node */
276
277                         node = walk_state->deferred_node;
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, "[%s] Cannot already exist\n",
287                                         acpi_ut_get_type_name (object_type)));
288                 }
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 = 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);
305                         return (status);
306                 }
307                 break;
308         }
309
310
311         /* Common exit */
312
313         if (!op) {
314                 /* Create a new op */
315
316                 op = acpi_ps_alloc_op (walk_state->opcode);
317                 if (!op) {
318                         return (AE_NO_MEMORY);
319                 }
320         }
321
322         /* Initialize */
323
324         op->named.name = node->name.integer;
325
326 #if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
327         op->named.path = (u8 *) path;
328 #endif
329
330
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         acpi_ps_append_arg (acpi_ps_get_parent_scope (&walk_state->parser_state), op);
337
338         *out_op = op;
339         return (status);
340 }
341
342
343 /*******************************************************************************
344  *
345  * FUNCTION:    acpi_ds_load1_end_op
346  *
347  * PARAMETERS:  walk_state      - Current state of the parse tree walk
348  *
349  * RETURN:      Status
350  *
351  * DESCRIPTION: Ascending callback used during the loading of the namespace,
352  *              both control methods and everything else.
353  *
354  ******************************************************************************/
355
356 acpi_status
357 acpi_ds_load1_end_op (
358         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
365         ACPI_FUNCTION_NAME ("ds_load1_end_op");
366
367
368         op = walk_state->op;
369         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));
370
371         /* We are only interested in opcodes that have an associated name */
372
373         if (!(walk_state->op_info->flags & (AML_NAMED | AML_FIELD))) {
374                 return (AE_OK);
375         }
376
377         /* Get the object type to determine if we should pop the scope */
378
379         object_type = walk_state->op_info->object_type;
380
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);
387                 }
388                 return (status);
389         }
390
391
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),
396                                                  walk_state);
397                 if (ACPI_FAILURE (status)) {
398                         return (status);
399                 }
400         }
401 #endif
402
403         if (op->common.aml_opcode == AML_NAME_OP) {
404                 /* For Name opcode, get the object type from the argument */
405
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;
410                 }
411         }
412
413         if (op->common.aml_opcode == AML_METHOD_OP) {
414                 /*
415                  * method_op pkg_length name_string method_flags term_list
416                  *
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
420                  * arguments.)
421                  */
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));
425
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;
429
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);
434                         }
435                         walk_state->operands[0] = NULL;
436                         walk_state->num_operands = 0;
437
438                         if (ACPI_FAILURE (status)) {
439                                 return (status);
440                         }
441                 }
442         }
443
444         /* Pop the scope stack */
445
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));
449
450                 status = acpi_ds_scope_stack_pop (walk_state);
451         }
452
453         return (status);
454 }
455
456
457 /*******************************************************************************
458  *
459  * FUNCTION:    acpi_ds_load2_begin_op
460  *
461  * PARAMETERS:  walk_state      - Current state of the parse tree walk
462  *              out_op          - Wher to return op if a new one is created
463  *
464  * RETURN:      Status
465  *
466  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
467  *
468  ******************************************************************************/
469
470 acpi_status
471 acpi_ds_load2_begin_op (
472         struct acpi_walk_state          *walk_state,
473         union acpi_parse_object         **out_op)
474 {
475         union acpi_parse_object         *op;
476         struct acpi_namespace_node      *node;
477         acpi_status                     status;
478         acpi_object_type                object_type;
479         char                            *buffer_ptr;
480
481
482         ACPI_FUNCTION_TRACE ("ds_load2_begin_op");
483
484
485         op = walk_state->op;
486         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));
487
488         if (op) {
489                 /* We only care about Namespace opcodes here */
490
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)));
499                         }
500                         return_ACPI_STATUS (AE_OK);
501                 }
502
503                 /* Get the name we are going to enter or lookup in the namespace */
504
505                 if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
506                         /* For Namepath op, get the path string */
507
508                         buffer_ptr = op->common.value.string;
509                         if (!buffer_ptr) {
510                                 /* No name, just exit */
511
512                                 return_ACPI_STATUS (AE_OK);
513                         }
514                 }
515                 else {
516                         /* Get name from the op */
517
518                         buffer_ptr = (char *) &op->named.name;
519                 }
520         }
521         else {
522                 /* Get the namestring from the raw AML */
523
524                 buffer_ptr = acpi_ps_get_next_namestring (&walk_state->parser_state);
525         }
526
527         /* Map the opcode into an internal object type */
528
529         object_type = walk_state->op_info->object_type;
530
531         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
532                 "State=%p Op=%p Type=%X\n", walk_state, op, object_type));
533
534
535         switch (walk_state->opcode) {
536         case AML_FIELD_OP:
537         case AML_BANK_FIELD_OP:
538         case AML_INDEX_FIELD_OP:
539
540                 node = NULL;
541                 status = AE_OK;
542                 break;
543
544         case AML_INT_NAMEPATH_OP:
545
546                 /*
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
549                  * for use later.
550                  */
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));
554                 break;
555
556         case AML_SCOPE_OP:
557
558                 /*
559                  * The Path is an object reference to an existing object.
560                  * Don't enter the name into the namespace, but look it up
561                  * for use later.
562                  */
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) {
569                                 status = AE_OK;
570                         }
571                         else {
572                                 ACPI_REPORT_NSERROR (buffer_ptr, status);
573                         }
574 #else
575                         ACPI_REPORT_NSERROR (buffer_ptr, status);
576 #endif
577                         return_ACPI_STATUS (status);
578                 }
579                 /*
580                  * We must check to make sure that the target is
581                  * one of the opcodes that actually opens a scope
582                  */
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:
589
590                         /* These are acceptable types */
591                         break;
592
593                 case ACPI_TYPE_INTEGER:
594                 case ACPI_TYPE_STRING:
595                 case ACPI_TYPE_BUFFER:
596
597                         /*
598                          * These types we will allow, but we will change the type.  This
599                          * enables some existing code of the form:
600                          *
601                          *  Name (DEB, 0)
602                          *  Scope (DEB) { ... }
603                          */
604
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)));
608
609                         node->type = ACPI_TYPE_ANY;
610                         walk_state->scope_info->common.value = ACPI_TYPE_ANY;
611                         break;
612
613                 default:
614
615                         /* All other types are an error */
616
617                         ACPI_REPORT_ERROR ((
618                                 "Invalid type (%s) for target of Scope operator [%4.4s]\n",
619                                 acpi_ut_get_type_name (node->type), buffer_ptr));
620
621                         return (AE_AML_OPERAND_TYPE);
622                 }
623                 break;
624
625         default:
626
627                 /* All other opcodes */
628
629                 if (op && op->common.node) {
630                         /* This op/node was previously entered into the namespace */
631
632                         node = op->common.node;
633
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);
638                                 }
639
640                         }
641                         return_ACPI_STATUS (AE_OK);
642                 }
643
644                 /*
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
648                  * parse tree later.
649                  *
650                  * Note: Name may already exist if we are executing a deferred opcode.
651                  */
652                 if (walk_state->deferred_node) {
653                         /* This name is already in the namespace, get the node */
654
655                         node = walk_state->deferred_node;
656                         status = AE_OK;
657                         break;
658                 }
659
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));
663                 break;
664         }
665
666         if (ACPI_FAILURE (status)) {
667                 ACPI_REPORT_NSERROR (buffer_ptr, status);
668                 return_ACPI_STATUS (status);
669         }
670
671
672         if (!op) {
673                 /* Create a new op */
674
675                 op = acpi_ps_alloc_op (walk_state->opcode);
676                 if (!op) {
677                         return_ACPI_STATUS (AE_NO_MEMORY);
678                 }
679
680                 /* Initialize the new op */
681
682                 if (node) {
683                         op->named.name = node->name.integer;
684                 }
685                 if (out_op) {
686                         *out_op = op;
687                 }
688         }
689
690         /*
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
693          */
694         op->common.node = node;
695
696         return_ACPI_STATUS (status);
697 }
698
699
700 /*******************************************************************************
701  *
702  * FUNCTION:    acpi_ds_load2_end_op
703  *
704  * PARAMETERS:  walk_state      - Current state of the parse tree walk
705  *
706  * RETURN:      Status
707  *
708  * DESCRIPTION: Ascending callback used during the loading of the namespace,
709  *              both control methods and everything else.
710  *
711  ******************************************************************************/
712
713 acpi_status
714 acpi_ds_load2_end_op (
715         struct acpi_walk_state          *walk_state)
716 {
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
724         u32                             i;
725 #endif
726
727
728         ACPI_FUNCTION_TRACE ("ds_load2_end_op");
729
730         op = walk_state->op;
731         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
732                         walk_state->op_info->name, op, walk_state));
733
734         /* Only interested in opcodes that have namespace objects */
735
736         if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
737                 return_ACPI_STATUS (AE_OK);
738         }
739
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));
743         }
744
745
746         object_type = walk_state->op_info->object_type;
747
748         /*
749          * Get the Node/name from the earlier lookup
750          * (It was saved in the *op structure)
751          */
752         node = op->common.node;
753
754         /*
755          * Put the Node on the object stack (Contains the ACPI Name of
756          * this object)
757          */
758         walk_state->operands[0] = (void *) node;
759         walk_state->num_operands = 1;
760
761         /* Pop the scope stack */
762
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));
767
768                 status = acpi_ds_scope_stack_pop (walk_state);
769                 if (ACPI_FAILURE (status)) {
770                         goto cleanup;
771                 }
772         }
773
774         /*
775          * Named operations are as follows:
776          *
777          * AML_ALIAS
778          * AML_BANKFIELD
779          * AML_CREATEBITFIELD
780          * AML_CREATEBYTEFIELD
781          * AML_CREATEDWORDFIELD
782          * AML_CREATEFIELD
783          * AML_CREATEQWORDFIELD
784          * AML_CREATEWORDFIELD
785          * AML_DATA_REGION
786          * AML_DEVICE
787          * AML_EVENT
788          * AML_FIELD
789          * AML_INDEXFIELD
790          * AML_METHOD
791          * AML_METHODCALL
792          * AML_MUTEX
793          * AML_NAME
794          * AML_NAMEDFIELD
795          * AML_OPREGION
796          * AML_POWERRES
797          * AML_PROCESSOR
798          * AML_SCOPE
799          * AML_THERMALZONE
800          */
801
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));
805
806         /* Decode the opcode */
807
808         arg = op->common.value.arg;
809
810         switch (walk_state->op_info->type) {
811 #ifndef ACPI_NO_METHOD_EXECUTION
812
813         case AML_TYPE_CREATE_FIELD:
814
815                 /*
816                  * Create the field object, but the field buffer and index must
817                  * be evaluated later during the execution phase
818                  */
819                 status = acpi_ds_create_buffer_field (op, walk_state);
820                 break;
821
822
823          case AML_TYPE_NAMED_FIELD:
824
825                 switch (op->common.aml_opcode) {
826                 case AML_INDEX_FIELD_OP:
827
828                         status = acpi_ds_create_index_field (op, (acpi_handle) arg->common.node,
829                                          walk_state);
830                         break;
831
832                 case AML_BANK_FIELD_OP:
833
834                         status = acpi_ds_create_bank_field (op, arg->common.node, walk_state);
835                         break;
836
837                 case AML_FIELD_OP:
838
839                         status = acpi_ds_create_field (op, arg->common.node, walk_state);
840                         break;
841
842                 default:
843                         /* All NAMED_FIELD opcodes must be handled above */
844                         break;
845                 }
846                 break;
847
848
849          case AML_TYPE_NAMED_SIMPLE:
850
851                 status = acpi_ds_create_operands (walk_state, arg);
852                 if (ACPI_FAILURE (status)) {
853                         goto cleanup;
854                 }
855
856                 switch (op->common.aml_opcode) {
857                 case AML_PROCESSOR_OP:
858
859                         status = acpi_ex_create_processor (walk_state);
860                         break;
861
862                 case AML_POWER_RES_OP:
863
864                         status = acpi_ex_create_power_resource (walk_state);
865                         break;
866
867                 case AML_MUTEX_OP:
868
869                         status = acpi_ex_create_mutex (walk_state);
870                         break;
871
872                 case AML_EVENT_OP:
873
874                         status = acpi_ex_create_event (walk_state);
875                         break;
876
877                 case AML_DATA_REGION_OP:
878
879                         status = acpi_ex_create_table_region (walk_state);
880                         break;
881
882                 case AML_ALIAS_OP:
883
884                         status = acpi_ex_create_alias (walk_state);
885                         break;
886
887                 default:
888                         /* Unknown opcode */
889
890                         status = AE_OK;
891                         goto cleanup;
892                 }
893
894                 /* Delete operands */
895
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;
899                 }
900
901                 break;
902 #endif /* ACPI_NO_METHOD_EXECUTION */
903
904         case AML_TYPE_NAMED_COMPLEX:
905
906                 switch (op->common.aml_opcode) {
907 #ifndef ACPI_NO_METHOD_EXECUTION
908                 case AML_REGION_OP:
909                         /*
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)
913                          */
914                         /*
915                          * If we have a valid region, initialize it
916                          * Namespace is NOT locked at this point.
917                          */
918                         status = acpi_ev_initialize_region (acpi_ns_get_attached_object (node),
919                                          FALSE);
920                         if (ACPI_FAILURE (status)) {
921                                 /*
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.
925                                  */
926                                 if (AE_NOT_EXIST == status) {
927                                         status = AE_OK;
928                                 }
929                         }
930                         break;
931
932
933                 case AML_NAME_OP:
934
935                         status = acpi_ds_create_node (walk_state, node, op);
936                         break;
937 #endif /* ACPI_NO_METHOD_EXECUTION */
938
939
940                 default:
941                         /* All NAMED_COMPLEX opcodes must be handled above */
942                         /* Note: Method objects were already created in Pass 1 */
943                         break;
944                 }
945                 break;
946
947
948         case AML_CLASS_INTERNAL:
949
950                 /* case AML_INT_NAMEPATH_OP: */
951                 break;
952
953
954         case AML_CLASS_METHOD_CALL:
955
956                 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
957                         "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
958                         walk_state, op, node));
959
960                 /*
961                  * Lookup the method name and save the Node
962                  */
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)) {
968                         /*
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
971                          * would resolve
972                          */
973                         if (new_node->type != ACPI_TYPE_METHOD) {
974                                 status = AE_AML_OPERAND_TYPE;
975                         }
976
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
980                          */
981                         op->common.node = new_node;
982                 }
983                 else {
984                         ACPI_REPORT_NSERROR (arg->common.value.string, status);
985                 }
986                 break;
987
988
989         default:
990                 break;
991         }
992
993 cleanup:
994
995         /* Remove the Node pushed at the very beginning */
996
997         walk_state->operands[0] = NULL;
998         walk_state->num_operands = 0;
999         return_ACPI_STATUS (status);
1000 }
1001
1002