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