?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[POWERPC] Allow ptrace write to pt_regs trap and orig_r3
[linux-ginger.git] / drivers / acpi / dispatcher / dswload.c
blob8ab9d1b29a4ce4062f1163ed746a16a258c4cd4f
1 /******************************************************************************
2 *
3 * Module Name: dswload - Dispatcher namespace load callbacks
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2007, 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, 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 }
447 }
448 #endif
449
450 if (op->common.aml_opcode == AML_NAME_OP) {
451
452 /* For Name opcode, get the object type from the argument */
453
454 if (op->common.value.arg) {
455 object_type = (acpi_ps_get_opcode_info((op->common.
456 value.arg)->
457 common.
458 aml_opcode))->
459 object_type;
460
461 /* Set node type if we have a namespace node */
462
463 if (op->common.node) {
464 op->common.node->type = (u8) object_type;
465 }
466 }
467 }
468
469 /*
470 * If we are executing a method, do not create any namespace objects
471 * during the load phase, only during execution.
472 */
473 if (!walk_state->method_node) {
474 if (op->common.aml_opcode == AML_METHOD_OP) {
475 /*
476 * method_op pkg_length name_string method_flags term_list
477 *
478 * Note: We must create the method node/object pair as soon as we
479 * see the method declaration. This allows later pass1 parsing
480 * of invocations of the method (need to know the number of
481 * arguments.)
482 */
483 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
484 "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
485 walk_state, op, op->named.node));
486
487 if (!acpi_ns_get_attached_object(op->named.node)) {
488 walk_state->operands[0] =
489 ACPI_CAST_PTR(void, op->named.node);
490 walk_state->num_operands = 1;
491
492 status =
493 acpi_ds_create_operands(walk_state,
494 op->common.value.
495 arg);
496 if (ACPI_SUCCESS(status)) {
497 status =
498 acpi_ex_create_method(op->named.
499 data,
500 op->named.
501 length,
502 walk_state);
503 }
504
505 walk_state->operands[0] = NULL;
506 walk_state->num_operands = 0;
507
508 if (ACPI_FAILURE(status)) {
509 return_ACPI_STATUS(status);
510 }
511 }
512 }
513 }
514
515 /* Pop the scope stack (only if loading a table) */
516
517 if (!walk_state->method_node && acpi_ns_opens_scope(object_type)) {
518 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
519 "(%s): Popping scope for Op %p\n",
520 acpi_ut_get_type_name(object_type), op));
521
522 status = acpi_ds_scope_stack_pop(walk_state);
523 }
524
525 return_ACPI_STATUS(status);
526 }
527
528 /*******************************************************************************
529 *
530 * FUNCTION: acpi_ds_load2_begin_op
531 *
532 * PARAMETERS: walk_state - Current state of the parse tree walk
533 * out_op - Wher to return op if a new one is created
534 *
535 * RETURN: Status
536 *
537 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
538 *
539 ******************************************************************************/
540
541 acpi_status
542 acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
543 union acpi_parse_object **out_op)
544 {
545 union acpi_parse_object *op;
546 struct acpi_namespace_node *node;
547 acpi_status status;
548 acpi_object_type object_type;
549 char *buffer_ptr;
550 u32 flags;
551
552 ACPI_FUNCTION_TRACE(ds_load2_begin_op);
553
554 op = walk_state->op;
555 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
556 walk_state));
557
558 if (op) {
559 if ((walk_state->control_state) &&
560 (walk_state->control_state->common.state ==
561 ACPI_CONTROL_CONDITIONAL_EXECUTING)) {
562
563 /* We are executing a while loop outside of a method */
564
565 status = acpi_ds_exec_begin_op(walk_state, out_op);
566 return_ACPI_STATUS(status);
567 }
568
569 /* We only care about Namespace opcodes here */
570
571 if ((!(walk_state->op_info->flags & AML_NSOPCODE) &&
572 (walk_state->opcode != AML_INT_NAMEPATH_OP)) ||
573 (!(walk_state->op_info->flags & AML_NAMED))) {
574 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
575 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
576 (walk_state->op_info->class == AML_CLASS_CONTROL)) {
577 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
578 "Begin/EXEC: %s (fl %8.8X)\n",
579 walk_state->op_info->name,
580 walk_state->op_info->flags));
581
582 /* Executing a type1 or type2 opcode outside of a method */
583
584 status =
585 acpi_ds_exec_begin_op(walk_state, out_op);
586 return_ACPI_STATUS(status);
587 }
588 #endif
589 return_ACPI_STATUS(AE_OK);
590 }
591
592 /* Get the name we are going to enter or lookup in the namespace */
593
594 if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
595
596 /* For Namepath op, get the path string */
597
598 buffer_ptr = op->common.value.string;
599 if (!buffer_ptr) {
600
601 /* No name, just exit */
602
603 return_ACPI_STATUS(AE_OK);
604 }
605 } else {
606 /* Get name from the op */
607
608 buffer_ptr = ACPI_CAST_PTR(char, &op->named.name);
609 }
610 } else {
611 /* Get the namestring from the raw AML */
612
613 buffer_ptr =
614 acpi_ps_get_next_namestring(&walk_state->parser_state);
615 }
616
617 /* Map the opcode into an internal object type */
618
619 object_type = walk_state->op_info->object_type;
620
621 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
622 "State=%p Op=%p Type=%X\n", walk_state, op,
623 object_type));
624
625 switch (walk_state->opcode) {
626 case AML_FIELD_OP:
627 case AML_BANK_FIELD_OP:
628 case AML_INDEX_FIELD_OP:
629
630 node = NULL;
631 status = AE_OK;
632 break;
633
634 case AML_INT_NAMEPATH_OP:
635 /*
636 * The name_path is an object reference to an existing object.
637 * Don't enter the name into the namespace, but look it up
638 * for use later.
639 */
640 status =
641 acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
642 object_type, ACPI_IMODE_EXECUTE,
643 ACPI_NS_SEARCH_PARENT, walk_state, &(node));
644 break;
645
646 case AML_SCOPE_OP:
647 /*
648 * The Path is an object reference to an existing object.
649 * Don't enter the name into the namespace, but look it up
650 * for use later.
651 */
652 status =
653 acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
654 object_type, ACPI_IMODE_EXECUTE,
655 ACPI_NS_SEARCH_PARENT, walk_state, &(node));
656 if (ACPI_FAILURE(status)) {
657 #ifdef ACPI_ASL_COMPILER
658 if (status == AE_NOT_FOUND) {
659 status = AE_OK;
660 } else {
661 ACPI_ERROR_NAMESPACE(buffer_ptr, status);
662 }
663 #else
664 ACPI_ERROR_NAMESPACE(buffer_ptr, status);
665 #endif
666 return_ACPI_STATUS(status);
667 }
668
669 /*
670 * We must check to make sure that the target is
671 * one of the opcodes that actually opens a scope
672 */
673 switch (node->type) {
674 case ACPI_TYPE_ANY:
675 case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
676 case ACPI_TYPE_DEVICE:
677 case ACPI_TYPE_POWER:
678 case ACPI_TYPE_PROCESSOR:
679 case ACPI_TYPE_THERMAL:
680
681 /* These are acceptable types */
682 break;
683
684 case ACPI_TYPE_INTEGER:
685 case ACPI_TYPE_STRING:
686 case ACPI_TYPE_BUFFER:
687
688 /*
689 * These types we will allow, but we will change the type. This
690 * enables some existing code of the form:
691 *
692 * Name (DEB, 0)
693 * Scope (DEB) { ... }
694 */
695 ACPI_WARNING((AE_INFO,
696 "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)",
697 buffer_ptr,
698 acpi_ut_get_type_name(node->type)));
699
700 node->type = ACPI_TYPE_ANY;
701 walk_state->scope_info->common.value = ACPI_TYPE_ANY;
702 break;
703
704 default:
705
706 /* All other types are an error */
707
708 ACPI_ERROR((AE_INFO,
709 "Invalid type (%s) for target of Scope operator [%4.4s]",
710 acpi_ut_get_type_name(node->type),
711 buffer_ptr));
712
713 return (AE_AML_OPERAND_TYPE);
714 }
715 break;
716
717 default:
718
719 /* All other opcodes */
720
721 if (op && op->common.node) {
722
723 /* This op/node was previously entered into the namespace */
724
725 node = op->common.node;
726
727 if (acpi_ns_opens_scope(object_type)) {
728 status =
729 acpi_ds_scope_stack_push(node, object_type,
730 walk_state);
731 if (ACPI_FAILURE(status)) {
732 return_ACPI_STATUS(status);
733 }
734 }
735
736 return_ACPI_STATUS(AE_OK);
737 }
738
739 /*
740 * Enter the named type into the internal namespace. We enter the name
741 * as we go downward in the parse tree. Any necessary subobjects that
742 * involve arguments to the opcode must be created as we go back up the
743 * parse tree later.
744 *
745 * Note: Name may already exist if we are executing a deferred opcode.
746 */
747 if (walk_state->deferred_node) {
748
749 /* This name is already in the namespace, get the node */
750
751 node = walk_state->deferred_node;
752 status = AE_OK;
753 break;
754 }
755
756 flags = ACPI_NS_NO_UPSEARCH;
757 if (walk_state->pass_number == ACPI_IMODE_EXECUTE) {
758
759 /* Execution mode, node cannot already exist, node is temporary */
760
761 flags |= (ACPI_NS_ERROR_IF_FOUND | ACPI_NS_TEMPORARY);
762 }
763
764 /* Add new entry or lookup existing entry */
765
766 status =
767 acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
768 object_type, ACPI_IMODE_LOAD_PASS2, flags,
769 walk_state, &node);
770 break;
771 }
772
773 if (ACPI_FAILURE(status)) {
774 ACPI_ERROR_NAMESPACE(buffer_ptr, status);
775 return_ACPI_STATUS(status);
776 }
777
778 if (!op) {
779
780 /* Create a new op */
781
782 op = acpi_ps_alloc_op(walk_state->opcode);
783 if (!op) {
784 return_ACPI_STATUS(AE_NO_MEMORY);
785 }
786
787 /* Initialize the new op */
788
789 if (node) {
790 op->named.name = node->name.integer;
791 }
792 *out_op = op;
793 }
794
795 /*
796 * Put the Node in the "op" object that the parser uses, so we
797 * can get it again quickly when this scope is closed
798 */
799 op->common.node = node;
800 return_ACPI_STATUS(status);
801 }
802
803 /*******************************************************************************
804 *
805 * FUNCTION: acpi_ds_load2_end_op
806 *
807 * PARAMETERS: walk_state - Current state of the parse tree walk
808 *
809 * RETURN: Status
810 *
811 * DESCRIPTION: Ascending callback used during the loading of the namespace,
812 * both control methods and everything else.
813 *
814 ******************************************************************************/
815
816 acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
817 {
818 union acpi_parse_object *op;
819 acpi_status status = AE_OK;
820 acpi_object_type object_type;
821 struct acpi_namespace_node *node;
822 union acpi_parse_object *arg;
823 struct acpi_namespace_node *new_node;
824 #ifndef ACPI_NO_METHOD_EXECUTION
825 u32 i;
826 #endif
827
828 ACPI_FUNCTION_TRACE(ds_load2_end_op);
829
830 op = walk_state->op;
831 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
832 walk_state->op_info->name, op, walk_state));
833
834 /* Check if opcode had an associated namespace object */
835
836 if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
837 #ifndef ACPI_NO_METHOD_EXECUTION
838 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
839 /* No namespace object. Executable opcode? */
840
841 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
842 (walk_state->op_info->class == AML_CLASS_CONTROL)) {
843 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
844 "End/EXEC: %s (fl %8.8X)\n",
845 walk_state->op_info->name,
846 walk_state->op_info->flags));
847
848 /* Executing a type1 or type2 opcode outside of a method */
849
850 status = acpi_ds_exec_end_op(walk_state);
851 return_ACPI_STATUS(status);
852 }
853 #endif
854 #endif
855 return_ACPI_STATUS(AE_OK);
856 }
857
858 if (op->common.aml_opcode == AML_SCOPE_OP) {
859 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
860 "Ending scope Op=%p State=%p\n", op,
861 walk_state));
862 }
863
864 object_type = walk_state->op_info->object_type;
865
866 /*
867 * Get the Node/name from the earlier lookup
868 * (It was saved in the *op structure)
869 */
870 node = op->common.node;
871
872 /*
873 * Put the Node on the object stack (Contains the ACPI Name of
874 * this object)
875 */
876 walk_state->operands[0] = (void *)node;
877 walk_state->num_operands = 1;
878
879 /* Pop the scope stack */
880
881 if (acpi_ns_opens_scope(object_type) &&
882 (op->common.aml_opcode != AML_INT_METHODCALL_OP)) {
883 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
884 "(%s) Popping scope for Op %p\n",
885 acpi_ut_get_type_name(object_type), op));
886
887 status = acpi_ds_scope_stack_pop(walk_state);
888 if (ACPI_FAILURE(status)) {
889 goto cleanup;
890 }
891 }
892
893 /*
894 * Named operations are as follows:
895 *
896 * AML_ALIAS
897 * AML_BANKFIELD
898 * AML_CREATEBITFIELD
899 * AML_CREATEBYTEFIELD
900 * AML_CREATEDWORDFIELD
901 * AML_CREATEFIELD
902 * AML_CREATEQWORDFIELD
903 * AML_CREATEWORDFIELD
904 * AML_DATA_REGION
905 * AML_DEVICE
906 * AML_EVENT
907 * AML_FIELD
908 * AML_INDEXFIELD
909 * AML_METHOD
910 * AML_METHODCALL
911 * AML_MUTEX
912 * AML_NAME
913 * AML_NAMEDFIELD
914 * AML_OPREGION
915 * AML_POWERRES
916 * AML_PROCESSOR
917 * AML_SCOPE
918 * AML_THERMALZONE
919 */
920
921 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
922 "Create-Load [%s] State=%p Op=%p NamedObj=%p\n",
923 acpi_ps_get_opcode_name(op->common.aml_opcode),
924 walk_state, op, node));
925
926 /* Decode the opcode */
927
928 arg = op->common.value.arg;
929
930 switch (walk_state->op_info->type) {
931 #ifndef ACPI_NO_METHOD_EXECUTION
932
933 case AML_TYPE_CREATE_FIELD:
934 /*
935 * Create the field object, but the field buffer and index must
936 * be evaluated later during the execution phase
937 */
938 status = acpi_ds_create_buffer_field(op, walk_state);
939 break;
940
941 case AML_TYPE_NAMED_FIELD:
942 /*
943 * If we are executing a method, initialize the field
944 */
945 if (walk_state->method_node) {
946 status = acpi_ds_init_field_objects(op, walk_state);
947 }
948
949 switch (op->common.aml_opcode) {
950 case AML_INDEX_FIELD_OP:
951
952 status =
953 acpi_ds_create_index_field(op,
954 (acpi_handle) arg->
955 common.node, walk_state);
956 break;
957
958 case AML_BANK_FIELD_OP:
959
960 status =
961 acpi_ds_create_bank_field(op, arg->common.node,
962 walk_state);
963 break;
964
965 case AML_FIELD_OP:
966
967 status =
968 acpi_ds_create_field(op, arg->common.node,
969 walk_state);
970 break;
971
972 default:
973 /* All NAMED_FIELD opcodes must be handled above */
974 break;
975 }
976 break;
977
978 case AML_TYPE_NAMED_SIMPLE:
979
980 status = acpi_ds_create_operands(walk_state, arg);
981 if (ACPI_FAILURE(status)) {
982 goto cleanup;
983 }
984
985 switch (op->common.aml_opcode) {
986 case AML_PROCESSOR_OP:
987
988 status = acpi_ex_create_processor(walk_state);
989 break;
990
991 case AML_POWER_RES_OP:
992
993 status = acpi_ex_create_power_resource(walk_state);
994 break;
995
996 case AML_MUTEX_OP:
997
998 status = acpi_ex_create_mutex(walk_state);
999 break;
1000
1001 case AML_EVENT_OP:
1002
1003 status = acpi_ex_create_event(walk_state);
1004 break;
1005
1006 case AML_DATA_REGION_OP:
1007
1008 status = acpi_ex_create_table_region(walk_state);
1009 break;
1010
1011 case AML_ALIAS_OP:
1012
1013 status = acpi_ex_create_alias(walk_state);
1014 break;
1015
1016 default:
1017 /* Unknown opcode */
1018
1019 status = AE_OK;
1020 goto cleanup;
1021 }
1022
1023 /* Delete operands */
1024
1025 for (i = 1; i < walk_state->num_operands; i++) {
1026 acpi_ut_remove_reference(walk_state->operands[i]);
1027 walk_state->operands[i] = NULL;
1028 }
1029
1030 break;
1031 #endif /* ACPI_NO_METHOD_EXECUTION */
1032
1033 case AML_TYPE_NAMED_COMPLEX:
1034
1035 switch (op->common.aml_opcode) {
1036 #ifndef ACPI_NO_METHOD_EXECUTION
1037 case AML_REGION_OP:
1038
1039 /*
1040 * If we are executing a method, initialize the region
1041 */
1042 if (walk_state->method_node) {
1043 status =
1044 acpi_ex_create_region(op->named.data,
1045 op->named.length,
1046 (acpi_adr_space_type)
1047 ((op->common.value.
1048 arg)->common.value.
1049 integer),
1050 walk_state);
1051 if (ACPI_FAILURE(status)) {
1052 return (status);
1053 }
1054 }
1055
1056 /*
1057 * The op_region is not fully parsed at this time. Only valid
1058 * argument is the space_id. (We must save the address of the
1059 * AML of the address and length operands)
1060 */
1061
1062 /*
1063 * If we have a valid region, initialize it
1064 * Namespace is NOT locked at this point.
1065 */
1066 status =
1067 acpi_ev_initialize_region
1068 (acpi_ns_get_attached_object(node), FALSE);
1069 if (ACPI_FAILURE(status)) {
1070 /*
1071 * If AE_NOT_EXIST is returned, it is not fatal
1072 * because many regions get created before a handler
1073 * is installed for said region.
1074 */
1075 if (AE_NOT_EXIST == status) {
1076 status = AE_OK;
1077 }
1078 }
1079 break;
1080
1081 case AML_NAME_OP:
1082
1083 status = acpi_ds_create_node(walk_state, node, op);
1084 break;
1085
1086 case AML_METHOD_OP:
1087 /*
1088 * method_op pkg_length name_string method_flags term_list
1089 *
1090 * Note: We must create the method node/object pair as soon as we
1091 * see the method declaration. This allows later pass1 parsing
1092 * of invocations of the method (need to know the number of
1093 * arguments.)
1094 */
1095 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
1096 "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
1097 walk_state, op, op->named.node));
1098
1099 if (!acpi_ns_get_attached_object(op->named.node)) {
1100 walk_state->operands[0] =
1101 ACPI_CAST_PTR(void, op->named.node);
1102 walk_state->num_operands = 1;
1103
1104 status =
1105 acpi_ds_create_operands(walk_state,
1106 op->common.value.
1107 arg);
1108 if (ACPI_SUCCESS(status)) {
1109 status =
1110 acpi_ex_create_method(op->named.
1111 data,
1112 op->named.
1113 length,
1114 walk_state);
1115 }
1116 walk_state->operands[0] = NULL;
1117 walk_state->num_operands = 0;
1118
1119 if (ACPI_FAILURE(status)) {
1120 return_ACPI_STATUS(status);
1121 }
1122 }
1123 break;
1124
1125 #endif /* ACPI_NO_METHOD_EXECUTION */
1126
1127 default:
1128 /* All NAMED_COMPLEX opcodes must be handled above */
1129 break;
1130 }
1131 break;
1132
1133 case AML_CLASS_INTERNAL:
1134
1135 /* case AML_INT_NAMEPATH_OP: */
1136 break;
1137
1138 case AML_CLASS_METHOD_CALL:
1139
1140 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
1141 "RESOLVING-MethodCall: State=%p Op=%p NamedObj=%p\n",
1142 walk_state, op, node));
1143
1144 /*
1145 * Lookup the method name and save the Node
1146 */
1147 status =
1148 acpi_ns_lookup(walk_state->scope_info,
1149 arg->common.value.string, ACPI_TYPE_ANY,
1150 ACPI_IMODE_LOAD_PASS2,
1151 ACPI_NS_SEARCH_PARENT |
1152 ACPI_NS_DONT_OPEN_SCOPE, walk_state,
1153 &(new_node));
1154 if (ACPI_SUCCESS(status)) {
1155 /*
1156 * Make sure that what we found is indeed a method
1157 * We didn't search for a method on purpose, to see if the name
1158 * would resolve
1159 */
1160 if (new_node->type != ACPI_TYPE_METHOD) {
1161 status = AE_AML_OPERAND_TYPE;
1162 }
1163
1164 /* We could put the returned object (Node) on the object stack for
1165 * later, but for now, we will put it in the "op" object that the
1166 * parser uses, so we can get it again at the end of this scope
1167 */
1168 op->common.node = new_node;
1169 } else {
1170 ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
1171 }
1172 break;
1173
1174 default:
1175 break;
1176 }
1177
1178 cleanup:
1179
1180 /* Remove the Node pushed at the very beginning */
1181
1182 walk_state->operands[0] = NULL;
1183 walk_state->num_operands = 0;
1184 return_ACPI_STATUS(status);
1185 }
Linux for Ginger Game Console