Merge master.kernel.org:/pub/scm/linux/kernel/git/lenb/to-linus
[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                         return_ACPI_STATUS (AE_OK);
495                 }
496
497                 /* Get the name we are going to enter or lookup in the namespace */
498
499                 if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
500                         /* For Namepath op, get the path string */
501
502                         buffer_ptr = op->common.value.string;
503                         if (!buffer_ptr) {
504                                 /* No name, just exit */
505
506                                 return_ACPI_STATUS (AE_OK);
507                         }
508                 }
509                 else {
510                         /* Get name from the op */
511
512                         buffer_ptr = (char *) &op->named.name;
513                 }
514         }
515         else {
516                 /* Get the namestring from the raw AML */
517
518                 buffer_ptr = acpi_ps_get_next_namestring (&walk_state->parser_state);
519         }
520
521         /* Map the opcode into an internal object type */
522
523         object_type = walk_state->op_info->object_type;
524
525         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
526                 "State=%p Op=%p Type=%X\n", walk_state, op, object_type));
527
528
529         switch (walk_state->opcode) {
530         case AML_FIELD_OP:
531         case AML_BANK_FIELD_OP:
532         case AML_INDEX_FIELD_OP:
533
534                 node = NULL;
535                 status = AE_OK;
536                 break;
537
538         case AML_INT_NAMEPATH_OP:
539
540                 /*
541                  * The name_path is an object reference to an existing object.
542                  * Don't enter the name into the namespace, but look it up
543                  * for use later.
544                  */
545                 status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, object_type,
546                                   ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
547                                   walk_state, &(node));
548                 break;
549
550         case AML_SCOPE_OP:
551
552                 /*
553                  * The Path is an object reference to an existing object.
554                  * Don't enter the name into the namespace, but look it up
555                  * for use later.
556                  */
557                 status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, object_type,
558                                   ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
559                                   walk_state, &(node));
560                 if (ACPI_FAILURE (status)) {
561 #ifdef _ACPI_ASL_COMPILER
562                         if (status == AE_NOT_FOUND) {
563                                 status = AE_OK;
564                         }
565                         else {
566                                 ACPI_REPORT_NSERROR (buffer_ptr, status);
567                         }
568 #else
569                         ACPI_REPORT_NSERROR (buffer_ptr, status);
570 #endif
571                         return_ACPI_STATUS (status);
572                 }
573                 /*
574                  * We must check to make sure that the target is
575                  * one of the opcodes that actually opens a scope
576                  */
577                 switch (node->type) {
578                 case ACPI_TYPE_LOCAL_SCOPE:         /* Scope */
579                 case ACPI_TYPE_DEVICE:
580                 case ACPI_TYPE_POWER:
581                 case ACPI_TYPE_PROCESSOR:
582                 case ACPI_TYPE_THERMAL:
583
584                         /* These are acceptable types */
585                         break;
586
587                 case ACPI_TYPE_INTEGER:
588                 case ACPI_TYPE_STRING:
589                 case ACPI_TYPE_BUFFER:
590
591                         /*
592                          * These types we will allow, but we will change the type.  This
593                          * enables some existing code of the form:
594                          *
595                          *  Name (DEB, 0)
596                          *  Scope (DEB) { ... }
597                          */
598
599                         ACPI_REPORT_WARNING ((
600                                 "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
601                                 buffer_ptr, acpi_ut_get_type_name (node->type)));
602
603                         node->type = ACPI_TYPE_ANY;
604                         walk_state->scope_info->common.value = ACPI_TYPE_ANY;
605                         break;
606
607                 default:
608
609                         /* All other types are an error */
610
611                         ACPI_REPORT_ERROR ((
612                                 "Invalid type (%s) for target of Scope operator [%4.4s]\n",
613                                 acpi_ut_get_type_name (node->type), buffer_ptr));
614
615                         return (AE_AML_OPERAND_TYPE);
616                 }
617                 break;
618
619         default:
620
621                 /* All other opcodes */
622
623                 if (op && op->common.node) {
624                         /* This op/node was previously entered into the namespace */
625
626                         node = op->common.node;
627
628                         if (acpi_ns_opens_scope (object_type)) {
629                                 status = acpi_ds_scope_stack_push (node, object_type, walk_state);
630                                 if (ACPI_FAILURE (status)) {
631                                         return_ACPI_STATUS (status);
632                                 }
633
634                         }
635                         return_ACPI_STATUS (AE_OK);
636                 }
637
638                 /*
639                  * Enter the named type into the internal namespace.  We enter the name
640                  * as we go downward in the parse tree.  Any necessary subobjects that
641                  * involve arguments to the opcode must be created as we go back up the
642                  * parse tree later.
643                  *
644                  * Note: Name may already exist if we are executing a deferred opcode.
645                  */
646                 if (walk_state->deferred_node) {
647                         /* This name is already in the namespace, get the node */
648
649                         node = walk_state->deferred_node;
650                         status = AE_OK;
651                         break;
652                 }
653
654                 status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, object_type,
655                                   ACPI_IMODE_EXECUTE, ACPI_NS_NO_UPSEARCH,
656                                   walk_state, &(node));
657                 break;
658         }
659
660         if (ACPI_FAILURE (status)) {
661                 ACPI_REPORT_NSERROR (buffer_ptr, status);
662                 return_ACPI_STATUS (status);
663         }
664
665
666         if (!op) {
667                 /* Create a new op */
668
669                 op = acpi_ps_alloc_op (walk_state->opcode);
670                 if (!op) {
671                         return_ACPI_STATUS (AE_NO_MEMORY);
672                 }
673
674                 /* Initialize the new op */
675
676                 if (node) {
677                         op->named.name = node->name.integer;
678                 }
679                 if (out_op) {
680                         *out_op = op;
681                 }
682         }
683
684         /*
685          * Put the Node in the "op" object that the parser uses, so we
686          * can get it again quickly when this scope is closed
687          */
688         op->common.node = node;
689
690         return_ACPI_STATUS (status);
691 }
692
693
694 /*******************************************************************************
695  *
696  * FUNCTION:    acpi_ds_load2_end_op
697  *
698  * PARAMETERS:  walk_state      - Current state of the parse tree walk
699  *
700  * RETURN:      Status
701  *
702  * DESCRIPTION: Ascending callback used during the loading of the namespace,
703  *              both control methods and everything else.
704  *
705  ******************************************************************************/
706
707 acpi_status
708 acpi_ds_load2_end_op (
709         struct acpi_walk_state          *walk_state)
710 {
711         union acpi_parse_object         *op;
712         acpi_status                     status = AE_OK;
713         acpi_object_type                object_type;
714         struct acpi_namespace_node      *node;
715         union acpi_parse_object         *arg;
716         struct acpi_namespace_node      *new_node;
717 #ifndef ACPI_NO_METHOD_EXECUTION
718         u32                             i;
719 #endif
720
721
722         ACPI_FUNCTION_TRACE ("ds_load2_end_op");
723
724         op = walk_state->op;
725         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
726                         walk_state->op_info->name, op, walk_state));
727
728         /* Only interested in opcodes that have namespace objects */
729
730         if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
731                 return_ACPI_STATUS (AE_OK);
732         }
733
734         if (op->common.aml_opcode == AML_SCOPE_OP) {
735                 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
736                         "Ending scope Op=%p State=%p\n", op, walk_state));
737         }
738
739
740         object_type = walk_state->op_info->object_type;
741
742         /*
743          * Get the Node/name from the earlier lookup
744          * (It was saved in the *op structure)
745          */
746         node = op->common.node;
747
748         /*
749          * Put the Node on the object stack (Contains the ACPI Name of
750          * this object)
751          */
752         walk_state->operands[0] = (void *) node;
753         walk_state->num_operands = 1;
754
755         /* Pop the scope stack */
756
757         if (acpi_ns_opens_scope (object_type) &&
758            (op->common.aml_opcode != AML_INT_METHODCALL_OP)) {
759                 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s) Popping scope for Op %p\n",
760                         acpi_ut_get_type_name (object_type), op));
761
762                 status = acpi_ds_scope_stack_pop (walk_state);
763                 if (ACPI_FAILURE (status)) {
764                         goto cleanup;
765                 }
766         }
767
768         /*
769          * Named operations are as follows:
770          *
771          * AML_ALIAS
772          * AML_BANKFIELD
773          * AML_CREATEBITFIELD
774          * AML_CREATEBYTEFIELD
775          * AML_CREATEDWORDFIELD
776          * AML_CREATEFIELD
777          * AML_CREATEQWORDFIELD
778          * AML_CREATEWORDFIELD
779          * AML_DATA_REGION
780          * AML_DEVICE
781          * AML_EVENT
782          * AML_FIELD
783          * AML_INDEXFIELD
784          * AML_METHOD
785          * AML_METHODCALL
786          * AML_MUTEX
787          * AML_NAME
788          * AML_NAMEDFIELD
789          * AML_OPREGION
790          * AML_POWERRES
791          * AML_PROCESSOR
792          * AML_SCOPE
793          * AML_THERMALZONE
794          */
795
796         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
797                 "Create-Load [%s] State=%p Op=%p named_obj=%p\n",
798                 acpi_ps_get_opcode_name (op->common.aml_opcode), walk_state, op, node));
799
800         /* Decode the opcode */
801
802         arg = op->common.value.arg;
803
804         switch (walk_state->op_info->type) {
805 #ifndef ACPI_NO_METHOD_EXECUTION
806
807         case AML_TYPE_CREATE_FIELD:
808
809                 /*
810                  * Create the field object, but the field buffer and index must
811                  * be evaluated later during the execution phase
812                  */
813                 status = acpi_ds_create_buffer_field (op, walk_state);
814                 break;
815
816
817          case AML_TYPE_NAMED_FIELD:
818
819                 switch (op->common.aml_opcode) {
820                 case AML_INDEX_FIELD_OP:
821
822                         status = acpi_ds_create_index_field (op, (acpi_handle) arg->common.node,
823                                          walk_state);
824                         break;
825
826                 case AML_BANK_FIELD_OP:
827
828                         status = acpi_ds_create_bank_field (op, arg->common.node, walk_state);
829                         break;
830
831                 case AML_FIELD_OP:
832
833                         status = acpi_ds_create_field (op, arg->common.node, walk_state);
834                         break;
835
836                 default:
837                         /* All NAMED_FIELD opcodes must be handled above */
838                         break;
839                 }
840                 break;
841
842
843          case AML_TYPE_NAMED_SIMPLE:
844
845                 status = acpi_ds_create_operands (walk_state, arg);
846                 if (ACPI_FAILURE (status)) {
847                         goto cleanup;
848                 }
849
850                 switch (op->common.aml_opcode) {
851                 case AML_PROCESSOR_OP:
852
853                         status = acpi_ex_create_processor (walk_state);
854                         break;
855
856                 case AML_POWER_RES_OP:
857
858                         status = acpi_ex_create_power_resource (walk_state);
859                         break;
860
861                 case AML_MUTEX_OP:
862
863                         status = acpi_ex_create_mutex (walk_state);
864                         break;
865
866                 case AML_EVENT_OP:
867
868                         status = acpi_ex_create_event (walk_state);
869                         break;
870
871                 case AML_DATA_REGION_OP:
872
873                         status = acpi_ex_create_table_region (walk_state);
874                         break;
875
876                 case AML_ALIAS_OP:
877
878                         status = acpi_ex_create_alias (walk_state);
879                         break;
880
881                 default:
882                         /* Unknown opcode */
883
884                         status = AE_OK;
885                         goto cleanup;
886                 }
887
888                 /* Delete operands */
889
890                 for (i = 1; i < walk_state->num_operands; i++) {
891                         acpi_ut_remove_reference (walk_state->operands[i]);
892                         walk_state->operands[i] = NULL;
893                 }
894
895                 break;
896 #endif /* ACPI_NO_METHOD_EXECUTION */
897
898         case AML_TYPE_NAMED_COMPLEX:
899
900                 switch (op->common.aml_opcode) {
901 #ifndef ACPI_NO_METHOD_EXECUTION
902                 case AML_REGION_OP:
903                         /*
904                          * The op_region is not fully parsed at this time. Only valid
905                          * argument is the space_id. (We must save the address of the
906                          * AML of the address and length operands)
907                          */
908                         /*
909                          * If we have a valid region, initialize it
910                          * Namespace is NOT locked at this point.
911                          */
912                         status = acpi_ev_initialize_region (acpi_ns_get_attached_object (node),
913                                          FALSE);
914                         if (ACPI_FAILURE (status)) {
915                                 /*
916                                  *  If AE_NOT_EXIST is returned, it is not fatal
917                                  *  because many regions get created before a handler
918                                  *  is installed for said region.
919                                  */
920                                 if (AE_NOT_EXIST == status) {
921                                         status = AE_OK;
922                                 }
923                         }
924                         break;
925
926
927                 case AML_NAME_OP:
928
929                         status = acpi_ds_create_node (walk_state, node, op);
930                         break;
931 #endif /* ACPI_NO_METHOD_EXECUTION */
932
933
934                 default:
935                         /* All NAMED_COMPLEX opcodes must be handled above */
936                         /* Note: Method objects were already created in Pass 1 */
937                         break;
938                 }
939                 break;
940
941
942         case AML_CLASS_INTERNAL:
943
944                 /* case AML_INT_NAMEPATH_OP: */
945                 break;
946
947
948         case AML_CLASS_METHOD_CALL:
949
950                 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
951                         "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
952                         walk_state, op, node));
953
954                 /*
955                  * Lookup the method name and save the Node
956                  */
957                 status = acpi_ns_lookup (walk_state->scope_info, arg->common.value.string,
958                                   ACPI_TYPE_ANY, ACPI_IMODE_LOAD_PASS2,
959                                   ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
960                                   walk_state, &(new_node));
961                 if (ACPI_SUCCESS (status)) {
962                         /*
963                          * Make sure that what we found is indeed a method
964                          * We didn't search for a method on purpose, to see if the name
965                          * would resolve
966                          */
967                         if (new_node->type != ACPI_TYPE_METHOD) {
968                                 status = AE_AML_OPERAND_TYPE;
969                         }
970
971                         /* We could put the returned object (Node) on the object stack for
972                          * later, but for now, we will put it in the "op" object that the
973                          * parser uses, so we can get it again at the end of this scope
974                          */
975                         op->common.node = new_node;
976                 }
977                 else {
978                         ACPI_REPORT_NSERROR (arg->common.value.string, status);
979                 }
980                 break;
981
982
983         default:
984                 break;
985         }
986
987 cleanup:
988
989         /* Remove the Node pushed at the very beginning */
990
991         walk_state->operands[0] = NULL;
992         walk_state->num_operands = 0;
993         return_ACPI_STATUS (status);
994 }
995
996