aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/acpi/dispatcher/dswload.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/acpi/dispatcher/dswload.c')
-rw-r--r--drivers/acpi/dispatcher/dswload.c976
1 files changed, 976 insertions, 0 deletions
diff --git a/drivers/acpi/dispatcher/dswload.c b/drivers/acpi/dispatcher/dswload.c
new file mode 100644
index 000000000000..06d758679588
--- /dev/null
+++ b/drivers/acpi/dispatcher/dswload.c
@@ -0,0 +1,976 @@
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
74acpi_status
75acpi_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 | ACPI_PARSE_DELETE_TREE;
83 walk_state->descending_callback = acpi_ds_load1_begin_op;
84 walk_state->ascending_callback = acpi_ds_load1_end_op;
85 break;
86
87 case 2:
88 walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 | ACPI_PARSE_DELETE_TREE;
89 walk_state->descending_callback = acpi_ds_load2_begin_op;
90 walk_state->ascending_callback = acpi_ds_load2_end_op;
91 break;
92
93 case 3:
94#ifndef ACPI_NO_METHOD_EXECUTION
95 walk_state->parse_flags |= ACPI_PARSE_EXECUTE | ACPI_PARSE_DELETE_TREE;
96 walk_state->descending_callback = acpi_ds_exec_begin_op;
97 walk_state->ascending_callback = acpi_ds_exec_end_op;
98#endif
99 break;
100
101 default:
102 return (AE_BAD_PARAMETER);
103 }
104
105 return (AE_OK);
106}
107
108
109/*******************************************************************************
110 *
111 * FUNCTION: acpi_ds_load1_begin_op
112 *
113 * PARAMETERS: walk_state - Current state of the parse tree walk
114 * Op - Op that has been just been reached in the
115 * walk; Arguments have not been evaluated yet.
116 *
117 * RETURN: Status
118 *
119 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
120 *
121 ******************************************************************************/
122
123acpi_status
124acpi_ds_load1_begin_op (
125 struct acpi_walk_state *walk_state,
126 union acpi_parse_object **out_op)
127{
128 union acpi_parse_object *op;
129 struct acpi_namespace_node *node;
130 acpi_status status;
131 acpi_object_type object_type;
132 char *path;
133 u32 flags;
134
135
136 ACPI_FUNCTION_NAME ("ds_load1_begin_op");
137
138
139 op = walk_state->op;
140 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));
141
142 /* We are only interested in opcodes that have an associated name */
143
144 if (op) {
145 if (!(walk_state->op_info->flags & AML_NAMED)) {
146#if 0
147 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
148 (walk_state->op_info->class == AML_CLASS_CONTROL)) {
149 acpi_os_printf ("\n\n***EXECUTABLE OPCODE %s***\n\n", walk_state->op_info->name);
150 *out_op = op;
151 return (AE_CTRL_SKIP);
152 }
153#endif
154 *out_op = op;
155 return (AE_OK);
156 }
157
158 /* Check if this object has already been installed in the namespace */
159
160 if (op->common.node) {
161 *out_op = op;
162 return (AE_OK);
163 }
164 }
165
166 path = acpi_ps_get_next_namestring (&walk_state->parser_state);
167
168 /* Map the raw opcode into an internal object type */
169
170 object_type = walk_state->op_info->object_type;
171
172 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
173 "State=%p Op=%p [%s]\n", walk_state, op, acpi_ut_get_type_name (object_type)));
174
175 switch (walk_state->opcode) {
176 case AML_SCOPE_OP:
177
178 /*
179 * The target name of the Scope() operator must exist at this point so
180 * that we can actually open the scope to enter new names underneath it.
181 * Allow search-to-root for single namesegs.
182 */
183 status = acpi_ns_lookup (walk_state->scope_info, path, object_type,
184 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, walk_state, &(node));
185#ifdef _ACPI_ASL_COMPILER
186 if (status == AE_NOT_FOUND) {
187 /*
188 * Table disassembly:
189 * Target of Scope() not found. Generate an External for it, and
190 * insert the name into the namespace.
191 */
192 acpi_dm_add_to_external_list (path);
193 status = acpi_ns_lookup (walk_state->scope_info, path, object_type,
194 ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT, walk_state, &(node));
195 }
196#endif
197 if (ACPI_FAILURE (status)) {
198 ACPI_REPORT_NSERROR (path, status);
199 return (status);
200 }
201
202 /*
203 * Check to make sure that the target is
204 * one of the opcodes that actually opens a scope
205 */
206 switch (node->type) {
207 case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
208 case ACPI_TYPE_DEVICE:
209 case ACPI_TYPE_POWER:
210 case ACPI_TYPE_PROCESSOR:
211 case ACPI_TYPE_THERMAL:
212
213 /* These are acceptable types */
214 break;
215
216 case ACPI_TYPE_INTEGER:
217 case ACPI_TYPE_STRING:
218 case ACPI_TYPE_BUFFER:
219
220 /*
221 * These types we will allow, but we will change the type. This
222 * enables some existing code of the form:
223 *
224 * Name (DEB, 0)
225 * Scope (DEB) { ... }
226 *
227 * Note: silently change the type here. On the second pass, we will report a warning
228 */
229
230 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
231 path, acpi_ut_get_type_name (node->type)));
232
233 node->type = ACPI_TYPE_ANY;
234 walk_state->scope_info->common.value = ACPI_TYPE_ANY;
235 break;
236
237 default:
238
239 /* All other types are an error */
240
241 ACPI_REPORT_ERROR (("Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)\n",
242 acpi_ut_get_type_name (node->type), path));
243
244 return (AE_AML_OPERAND_TYPE);
245 }
246 break;
247
248
249 default:
250
251 /*
252 * For all other named opcodes, we will enter the name into the namespace.
253 *
254 * Setup the search flags.
255 * Since we are entering a name into the namespace, we do not want to
256 * enable the search-to-root upsearch.
257 *
258 * There are only two conditions where it is acceptable that the name
259 * already exists:
260 * 1) the Scope() operator can reopen a scoping object that was
261 * previously defined (Scope, Method, Device, etc.)
262 * 2) Whenever we are parsing a deferred opcode (op_region, Buffer,
263 * buffer_field, or Package), the name of the object is already
264 * in the namespace.
265 */
266 if (walk_state->deferred_node) {
267 /* This name is already in the namespace, get the node */
268
269 node = walk_state->deferred_node;
270 status = AE_OK;
271 break;
272 }
273
274 flags = ACPI_NS_NO_UPSEARCH;
275 if ((walk_state->opcode != AML_SCOPE_OP) &&
276 (!(walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP))) {
277 flags |= ACPI_NS_ERROR_IF_FOUND;
278 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%s] Cannot already exist\n",
279 acpi_ut_get_type_name (object_type)));
280 }
281 else {
282 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%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 involve
289 * arguments to the opcode must be created as we go back up the parse tree later.
290 */
291 status = acpi_ns_lookup (walk_state->scope_info, path, object_type,
292 ACPI_IMODE_LOAD_PASS1, flags, walk_state, &(node));
293 if (ACPI_FAILURE (status)) {
294 ACPI_REPORT_NSERROR (path, status);
295 return (status);
296 }
297 break;
298 }
299
300
301 /* Common exit */
302
303 if (!op) {
304 /* Create a new op */
305
306 op = acpi_ps_alloc_op (walk_state->opcode);
307 if (!op) {
308 return (AE_NO_MEMORY);
309 }
310 }
311
312 /* Initialize */
313
314 op->named.name = node->name.integer;
315
316#if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
317 op->named.path = (u8 *) path;
318#endif
319
320
321 /*
322 * Put the Node in the "op" object that the parser uses, so we
323 * can get it again quickly when this scope is closed
324 */
325 op->common.node = node;
326 acpi_ps_append_arg (acpi_ps_get_parent_scope (&walk_state->parser_state), op);
327
328 *out_op = op;
329 return (status);
330}
331
332
333/*******************************************************************************
334 *
335 * FUNCTION: acpi_ds_load1_end_op
336 *
337 * PARAMETERS: walk_state - Current state of the parse tree walk
338 * Op - Op that has been just been completed in the
339 * walk; Arguments have now been evaluated.
340 *
341 * RETURN: Status
342 *
343 * DESCRIPTION: Ascending callback used during the loading of the namespace,
344 * both control methods and everything else.
345 *
346 ******************************************************************************/
347
348acpi_status
349acpi_ds_load1_end_op (
350 struct acpi_walk_state *walk_state)
351{
352 union acpi_parse_object *op;
353 acpi_object_type object_type;
354 acpi_status status = AE_OK;
355
356
357 ACPI_FUNCTION_NAME ("ds_load1_end_op");
358
359
360 op = walk_state->op;
361 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));
362
363 /* We are only interested in opcodes that have an associated name */
364
365 if (!(walk_state->op_info->flags & (AML_NAMED | AML_FIELD))) {
366 return (AE_OK);
367 }
368
369 /* Get the object type to determine if we should pop the scope */
370
371 object_type = walk_state->op_info->object_type;
372
373#ifndef ACPI_NO_METHOD_EXECUTION
374 if (walk_state->op_info->flags & AML_FIELD) {
375 if (walk_state->opcode == AML_FIELD_OP ||
376 walk_state->opcode == AML_BANK_FIELD_OP ||
377 walk_state->opcode == AML_INDEX_FIELD_OP) {
378 status = acpi_ds_init_field_objects (op, walk_state);
379 }
380 return (status);
381 }
382
383
384 if (op->common.aml_opcode == AML_REGION_OP) {
385 status = acpi_ex_create_region (op->named.data, op->named.length,
386 (acpi_adr_space_type) ((op->common.value.arg)->common.value.integer), walk_state);
387 if (ACPI_FAILURE (status)) {
388 return (status);
389 }
390 }
391#endif
392
393 if (op->common.aml_opcode == AML_NAME_OP) {
394 /* For Name opcode, get the object type from the argument */
395
396 if (op->common.value.arg) {
397 object_type = (acpi_ps_get_opcode_info ((op->common.value.arg)->common.aml_opcode))->object_type;
398 op->common.node->type = (u8) object_type;
399 }
400 }
401
402 if (op->common.aml_opcode == AML_METHOD_OP) {
403 /*
404 * method_op pkg_length name_string method_flags term_list
405 *
406 * Note: We must create the method node/object pair as soon as we
407 * see the method declaration. This allows later pass1 parsing
408 * of invocations of the method (need to know the number of
409 * arguments.)
410 */
411 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
412 "LOADING-Method: State=%p Op=%p named_obj=%p\n",
413 walk_state, op, op->named.node));
414
415 if (!acpi_ns_get_attached_object (op->named.node)) {
416 walk_state->operands[0] = (void *) op->named.node;
417 walk_state->num_operands = 1;
418
419 status = acpi_ds_create_operands (walk_state, op->common.value.arg);
420 if (ACPI_SUCCESS (status)) {
421 status = acpi_ex_create_method (op->named.data,
422 op->named.length, walk_state);
423 }
424 walk_state->operands[0] = NULL;
425 walk_state->num_operands = 0;
426
427 if (ACPI_FAILURE (status)) {
428 return (status);
429 }
430 }
431 }
432
433 /* Pop the scope stack */
434
435 if (acpi_ns_opens_scope (object_type)) {
436 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s): Popping scope for Op %p\n",
437 acpi_ut_get_type_name (object_type), op));
438
439 status = acpi_ds_scope_stack_pop (walk_state);
440 }
441
442 return (status);
443}
444
445
446/*******************************************************************************
447 *
448 * FUNCTION: acpi_ds_load2_begin_op
449 *
450 * PARAMETERS: walk_state - Current state of the parse tree walk
451 * Op - Op that has been just been reached in the
452 * walk; Arguments have not been evaluated yet.
453 *
454 * RETURN: Status
455 *
456 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
457 *
458 ******************************************************************************/
459
460acpi_status
461acpi_ds_load2_begin_op (
462 struct acpi_walk_state *walk_state,
463 union acpi_parse_object **out_op)
464{
465 union acpi_parse_object *op;
466 struct acpi_namespace_node *node;
467 acpi_status status;
468 acpi_object_type object_type;
469 char *buffer_ptr;
470
471
472 ACPI_FUNCTION_TRACE ("ds_load2_begin_op");
473
474
475 op = walk_state->op;
476 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));
477
478 if (op) {
479 /* We only care about Namespace opcodes here */
480
481 if ((!(walk_state->op_info->flags & AML_NSOPCODE) && (walk_state->opcode != AML_INT_NAMEPATH_OP)) ||
482 (!(walk_state->op_info->flags & AML_NAMED))) {
483 return_ACPI_STATUS (AE_OK);
484 }
485
486 /*
487 * Get the name we are going to enter or lookup in the namespace
488 */
489 if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
490 /* For Namepath op, get the path string */
491
492 buffer_ptr = op->common.value.string;
493 if (!buffer_ptr) {
494 /* No name, just exit */
495
496 return_ACPI_STATUS (AE_OK);
497 }
498 }
499 else {
500 /* Get name from the op */
501
502 buffer_ptr = (char *) &op->named.name;
503 }
504 }
505 else {
506 /* Get the namestring from the raw AML */
507
508 buffer_ptr = acpi_ps_get_next_namestring (&walk_state->parser_state);
509 }
510
511 /* Map the opcode into an internal object type */
512
513 object_type = walk_state->op_info->object_type;
514
515 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
516 "State=%p Op=%p Type=%X\n", walk_state, op, object_type));
517
518
519 switch (walk_state->opcode) {
520 case AML_FIELD_OP:
521 case AML_BANK_FIELD_OP:
522 case AML_INDEX_FIELD_OP:
523
524 node = NULL;
525 status = AE_OK;
526 break;
527
528 case AML_INT_NAMEPATH_OP:
529
530 /*
531 * The name_path is an object reference to an existing object. Don't enter the
532 * name into the namespace, but look it up for use later
533 */
534 status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, object_type,
535 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, walk_state, &(node));
536 break;
537
538 case AML_SCOPE_OP:
539
540 /*
541 * The Path is an object reference to an existing object. Don't enter the
542 * name into the namespace, but look it up for use later
543 */
544 status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, object_type,
545 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, walk_state, &(node));
546 if (ACPI_FAILURE (status)) {
547#ifdef _ACPI_ASL_COMPILER
548 if (status == AE_NOT_FOUND) {
549 status = AE_OK;
550 }
551 else {
552 ACPI_REPORT_NSERROR (buffer_ptr, status);
553 }
554#else
555 ACPI_REPORT_NSERROR (buffer_ptr, status);
556#endif
557 return_ACPI_STATUS (status);
558 }
559 /*
560 * We must check to make sure that the target is
561 * one of the opcodes that actually opens a scope
562 */
563 switch (node->type) {
564 case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
565 case ACPI_TYPE_DEVICE:
566 case ACPI_TYPE_POWER:
567 case ACPI_TYPE_PROCESSOR:
568 case ACPI_TYPE_THERMAL:
569
570 /* These are acceptable types */
571 break;
572
573 case ACPI_TYPE_INTEGER:
574 case ACPI_TYPE_STRING:
575 case ACPI_TYPE_BUFFER:
576
577 /*
578 * These types we will allow, but we will change the type. This
579 * enables some existing code of the form:
580 *
581 * Name (DEB, 0)
582 * Scope (DEB) { ... }
583 */
584
585 ACPI_REPORT_WARNING (("Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
586 buffer_ptr, acpi_ut_get_type_name (node->type)));
587
588 node->type = ACPI_TYPE_ANY;
589 walk_state->scope_info->common.value = ACPI_TYPE_ANY;
590 break;
591
592 default:
593
594 /* All other types are an error */
595
596 ACPI_REPORT_ERROR (("Invalid type (%s) for target of Scope operator [%4.4s]\n",
597 acpi_ut_get_type_name (node->type), buffer_ptr));
598
599 return (AE_AML_OPERAND_TYPE);
600 }
601 break;
602
603 default:
604
605 /* All other opcodes */
606
607 if (op && op->common.node) {
608 /* This op/node was previously entered into the namespace */
609
610 node = op->common.node;
611
612 if (acpi_ns_opens_scope (object_type)) {
613 status = acpi_ds_scope_stack_push (node, object_type, walk_state);
614 if (ACPI_FAILURE (status)) {
615 return_ACPI_STATUS (status);
616 }
617
618 }
619 return_ACPI_STATUS (AE_OK);
620 }
621
622 /*
623 * Enter the named type into the internal namespace. We enter the name
624 * as we go downward in the parse tree. Any necessary subobjects that involve
625 * arguments to the opcode must be created as we go back up the parse tree later.
626 *
627 * Note: Name may already exist if we are executing a deferred opcode.
628 */
629 if (walk_state->deferred_node) {
630 /* This name is already in the namespace, get the node */
631
632 node = walk_state->deferred_node;
633 status = AE_OK;
634 break;
635 }
636
637 status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, object_type,
638 ACPI_IMODE_EXECUTE, ACPI_NS_NO_UPSEARCH, walk_state, &(node));
639 break;
640 }
641
642 if (ACPI_FAILURE (status)) {
643 ACPI_REPORT_NSERROR (buffer_ptr, status);
644 return_ACPI_STATUS (status);
645 }
646
647
648 if (!op) {
649 /* Create a new op */
650
651 op = acpi_ps_alloc_op (walk_state->opcode);
652 if (!op) {
653 return_ACPI_STATUS (AE_NO_MEMORY);
654 }
655
656 /* Initialize the new op */
657
658 if (node) {
659 op->named.name = node->name.integer;
660 }
661 if (out_op) {
662 *out_op = op;
663 }
664 }
665
666 /*
667 * Put the Node in the "op" object that the parser uses, so we
668 * can get it again quickly when this scope is closed
669 */
670 op->common.node = node;
671
672 return_ACPI_STATUS (status);
673}
674
675
676/*******************************************************************************
677 *
678 * FUNCTION: acpi_ds_load2_end_op
679 *
680 * PARAMETERS: walk_state - Current state of the parse tree walk
681 * Op - Op that has been just been completed in the
682 * walk; Arguments have now been evaluated.
683 *
684 * RETURN: Status
685 *
686 * DESCRIPTION: Ascending callback used during the loading of the namespace,
687 * both control methods and everything else.
688 *
689 ******************************************************************************/
690
691acpi_status
692acpi_ds_load2_end_op (
693 struct acpi_walk_state *walk_state)
694{
695 union acpi_parse_object *op;
696 acpi_status status = AE_OK;
697 acpi_object_type object_type;
698 struct acpi_namespace_node *node;
699 union acpi_parse_object *arg;
700 struct acpi_namespace_node *new_node;
701#ifndef ACPI_NO_METHOD_EXECUTION
702 u32 i;
703#endif
704
705
706 ACPI_FUNCTION_TRACE ("ds_load2_end_op");
707
708 op = walk_state->op;
709 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
710 walk_state->op_info->name, op, walk_state));
711
712 /* Only interested in opcodes that have namespace objects */
713
714 if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
715 return_ACPI_STATUS (AE_OK);
716 }
717
718 if (op->common.aml_opcode == AML_SCOPE_OP) {
719 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
720 "Ending scope Op=%p State=%p\n", op, walk_state));
721 }
722
723
724 object_type = walk_state->op_info->object_type;
725
726 /*
727 * Get the Node/name from the earlier lookup
728 * (It was saved in the *op structure)
729 */
730 node = op->common.node;
731
732 /*
733 * Put the Node on the object stack (Contains the ACPI Name of
734 * this object)
735 */
736 walk_state->operands[0] = (void *) node;
737 walk_state->num_operands = 1;
738
739 /* Pop the scope stack */
740
741 if (acpi_ns_opens_scope (object_type) && (op->common.aml_opcode != AML_INT_METHODCALL_OP)) {
742 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s) Popping scope for Op %p\n",
743 acpi_ut_get_type_name (object_type), op));
744
745 status = acpi_ds_scope_stack_pop (walk_state);
746 if (ACPI_FAILURE (status)) {
747 goto cleanup;
748 }
749 }
750
751 /*
752 * Named operations are as follows:
753 *
754 * AML_ALIAS
755 * AML_BANKFIELD
756 * AML_CREATEBITFIELD
757 * AML_CREATEBYTEFIELD
758 * AML_CREATEDWORDFIELD
759 * AML_CREATEFIELD
760 * AML_CREATEQWORDFIELD
761 * AML_CREATEWORDFIELD
762 * AML_DATA_REGION
763 * AML_DEVICE
764 * AML_EVENT
765 * AML_FIELD
766 * AML_INDEXFIELD
767 * AML_METHOD
768 * AML_METHODCALL
769 * AML_MUTEX
770 * AML_NAME
771 * AML_NAMEDFIELD
772 * AML_OPREGION
773 * AML_POWERRES
774 * AML_PROCESSOR
775 * AML_SCOPE
776 * AML_THERMALZONE
777 */
778
779 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
780 "Create-Load [%s] State=%p Op=%p named_obj=%p\n",
781 acpi_ps_get_opcode_name (op->common.aml_opcode), walk_state, op, node));
782
783 /* Decode the opcode */
784
785 arg = op->common.value.arg;
786
787 switch (walk_state->op_info->type) {
788#ifndef ACPI_NO_METHOD_EXECUTION
789
790 case AML_TYPE_CREATE_FIELD:
791
792 /*
793 * Create the field object, but the field buffer and index must
794 * be evaluated later during the execution phase
795 */
796 status = acpi_ds_create_buffer_field (op, walk_state);
797 break;
798
799
800 case AML_TYPE_NAMED_FIELD:
801
802 switch (op->common.aml_opcode) {
803 case AML_INDEX_FIELD_OP:
804
805 status = acpi_ds_create_index_field (op, (acpi_handle) arg->common.node,
806 walk_state);
807 break;
808
809 case AML_BANK_FIELD_OP:
810
811 status = acpi_ds_create_bank_field (op, arg->common.node, walk_state);
812 break;
813
814 case AML_FIELD_OP:
815
816 status = acpi_ds_create_field (op, arg->common.node, walk_state);
817 break;
818
819 default:
820 /* All NAMED_FIELD opcodes must be handled above */
821 break;
822 }
823 break;
824
825
826 case AML_TYPE_NAMED_SIMPLE:
827
828 status = acpi_ds_create_operands (walk_state, arg);
829 if (ACPI_FAILURE (status)) {
830 goto cleanup;
831 }
832
833 switch (op->common.aml_opcode) {
834 case AML_PROCESSOR_OP:
835
836 status = acpi_ex_create_processor (walk_state);
837 break;
838
839 case AML_POWER_RES_OP:
840
841 status = acpi_ex_create_power_resource (walk_state);
842 break;
843
844 case AML_MUTEX_OP:
845
846 status = acpi_ex_create_mutex (walk_state);
847 break;
848
849 case AML_EVENT_OP:
850
851 status = acpi_ex_create_event (walk_state);
852 break;
853
854 case AML_DATA_REGION_OP:
855
856 status = acpi_ex_create_table_region (walk_state);
857 break;
858
859 case AML_ALIAS_OP:
860
861 status = acpi_ex_create_alias (walk_state);
862 break;
863
864 default:
865 /* Unknown opcode */
866
867 status = AE_OK;
868 goto cleanup;
869 }
870
871 /* Delete operands */
872
873 for (i = 1; i < walk_state->num_operands; i++) {
874 acpi_ut_remove_reference (walk_state->operands[i]);
875 walk_state->operands[i] = NULL;
876 }
877
878 break;
879#endif /* ACPI_NO_METHOD_EXECUTION */
880
881 case AML_TYPE_NAMED_COMPLEX:
882
883 switch (op->common.aml_opcode) {
884#ifndef ACPI_NO_METHOD_EXECUTION
885 case AML_REGION_OP:
886 /*
887 * The op_region is not fully parsed at this time. Only valid argument is the space_id.
888 * (We must save the address of the AML of the address and length operands)
889 */
890 /*
891 * If we have a valid region, initialize it
892 * Namespace is NOT locked at this point.
893 */
894 status = acpi_ev_initialize_region (acpi_ns_get_attached_object (node), FALSE);
895 if (ACPI_FAILURE (status)) {
896 /*
897 * If AE_NOT_EXIST is returned, it is not fatal
898 * because many regions get created before a handler
899 * is installed for said region.
900 */
901 if (AE_NOT_EXIST == status) {
902 status = AE_OK;
903 }
904 }
905 break;
906
907
908 case AML_NAME_OP:
909
910 status = acpi_ds_create_node (walk_state, node, op);
911 break;
912#endif /* ACPI_NO_METHOD_EXECUTION */
913
914
915 default:
916 /* All NAMED_COMPLEX opcodes must be handled above */
917 /* Note: Method objects were already created in Pass 1 */
918 break;
919 }
920 break;
921
922
923 case AML_CLASS_INTERNAL:
924
925 /* case AML_INT_NAMEPATH_OP: */
926 break;
927
928
929 case AML_CLASS_METHOD_CALL:
930
931 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
932 "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
933 walk_state, op, node));
934
935 /*
936 * Lookup the method name and save the Node
937 */
938 status = acpi_ns_lookup (walk_state->scope_info, arg->common.value.string,
939 ACPI_TYPE_ANY, ACPI_IMODE_LOAD_PASS2,
940 ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
941 walk_state, &(new_node));
942 if (ACPI_SUCCESS (status)) {
943 /*
944 * Make sure that what we found is indeed a method
945 * We didn't search for a method on purpose, to see if the name would resolve
946 */
947 if (new_node->type != ACPI_TYPE_METHOD) {
948 status = AE_AML_OPERAND_TYPE;
949 }
950
951 /* We could put the returned object (Node) on the object stack for later, but
952 * for now, we will put it in the "op" object that the parser uses, so we
953 * can get it again at the end of this scope
954 */
955 op->common.node = new_node;
956 }
957 else {
958 ACPI_REPORT_NSERROR (arg->common.value.string, status);
959 }
960 break;
961
962
963 default:
964 break;
965 }
966
967cleanup:
968
969 /* Remove the Node pushed at the very beginning */
970
971 walk_state->operands[0] = NULL;
972 walk_state->num_operands = 0;
973 return_ACPI_STATUS (status);
974}
975
976
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-26 12:45:36 -0500