projects / deliverable / linux.git / blob
? search:


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