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