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