?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] W1: w1_netlink: New init/fini netlink callbacks.
[linux-2.6/verdex.git] / drivers / acpi / dispatcher / dswload.c
blob411731261c2986b2c19e01104bd0e48e89be6131
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 #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_NAME("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 (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 (AE_OK);
149 }
150 }
151
152 path = acpi_ps_get_next_namestring(&walk_state->parser_state);
153
154 /* Map the raw opcode into an internal object type */
155
156 object_type = walk_state->op_info->object_type;
157
158 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
159 "State=%p Op=%p [%s]\n", walk_state, op,
160 acpi_ut_get_type_name(object_type)));
161
162 switch (walk_state->opcode) {
163 case AML_SCOPE_OP:
164
165 /*
166 * The target name of the Scope() operator must exist at this point so
167 * that we can actually open the scope to enter new names underneath it.
168 * Allow search-to-root for single namesegs.
169 */
170 status =
171 acpi_ns_lookup(walk_state->scope_info, path, object_type,
172 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
173 walk_state, &(node));
174 #ifdef ACPI_ASL_COMPILER
175 if (status == AE_NOT_FOUND) {
176 /*
177 * Table disassembly:
178 * Target of Scope() not found. Generate an External for it, and
179 * insert the name into the namespace.
180 */
181 acpi_dm_add_to_external_list(path);
182 status =
183 acpi_ns_lookup(walk_state->scope_info, path,
184 object_type, ACPI_IMODE_LOAD_PASS1,
185 ACPI_NS_SEARCH_PARENT, walk_state,
186 &(node));
187 }
188 #endif
189 if (ACPI_FAILURE(status)) {
190 ACPI_REPORT_NSERROR(path, status);
191 return (status);
192 }
193
194 /*
195 * Check to make sure that the target is
196 * one of the opcodes that actually opens a scope
197 */
198 switch (node->type) {
199 case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
200 case ACPI_TYPE_DEVICE:
201 case ACPI_TYPE_POWER:
202 case ACPI_TYPE_PROCESSOR:
203 case ACPI_TYPE_THERMAL:
204
205 /* These are acceptable types */
206 break;
207
208 case ACPI_TYPE_INTEGER:
209 case ACPI_TYPE_STRING:
210 case ACPI_TYPE_BUFFER:
211
212 /*
213 * These types we will allow, but we will change the type. This
214 * enables some existing code of the form:
215 *
216 * Name (DEB, 0)
217 * Scope (DEB) { ... }
218 *
219 * Note: silently change the type here. On the second pass, we will report
220 * a warning
221 */
222
223 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
224 "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
225 path,
226 acpi_ut_get_type_name(node->type)));
227
228 node->type = ACPI_TYPE_ANY;
229 walk_state->scope_info->common.value = ACPI_TYPE_ANY;
230 break;
231
232 default:
233
234 /* All other types are an error */
235
236 ACPI_REPORT_ERROR(("Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)\n", acpi_ut_get_type_name(node->type), path));
237
238 return (AE_AML_OPERAND_TYPE);
239 }
240 break;
241
242 default:
243
244 /*
245 * For all other named opcodes, we will enter the name into
246 * the namespace.
247 *
248 * Setup the search flags.
249 * Since we are entering a name into the namespace, we do not want to
250 * enable the search-to-root upsearch.
251 *
252 * There are only two conditions where it is acceptable that the name
253 * already exists:
254 * 1) the Scope() operator can reopen a scoping object that was
255 * previously defined (Scope, Method, Device, etc.)
256 * 2) Whenever we are parsing a deferred opcode (op_region, Buffer,
257 * buffer_field, or Package), the name of the object is already
258 * in the namespace.
259 */
260 if (walk_state->deferred_node) {
261 /* This name is already in the namespace, get the node */
262
263 node = walk_state->deferred_node;
264 status = AE_OK;
265 break;
266 }
267
268 flags = ACPI_NS_NO_UPSEARCH;
269 if ((walk_state->opcode != AML_SCOPE_OP) &&
270 (!(walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP))) {
271 flags |= ACPI_NS_ERROR_IF_FOUND;
272 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
273 "[%s] Cannot already exist\n",
274 acpi_ut_get_type_name(object_type)));
275 } else {
276 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
277 "[%s] Both Find or Create allowed\n",
278 acpi_ut_get_type_name(object_type)));
279 }
280
281 /*
282 * Enter the named type into the internal namespace. We enter the name
283 * as we go downward in the parse tree. Any necessary subobjects that
284 * involve arguments to the opcode must be created as we go back up the
285 * parse tree later.
286 */
287 status =
288 acpi_ns_lookup(walk_state->scope_info, path, object_type,
289 ACPI_IMODE_LOAD_PASS1, flags, walk_state,
290 &(node));
291 if (ACPI_FAILURE(status)) {
292 ACPI_REPORT_NSERROR(path, status);
293 return (status);
294 }
295 break;
296 }
297
298 /* Common exit */
299
300 if (!op) {
301 /* Create a new op */
302
303 op = acpi_ps_alloc_op(walk_state->opcode);
304 if (!op) {
305 return (AE_NO_MEMORY);
306 }
307 }
308
309 /* Initialize */
310
311 op->named.name = node->name.integer;
312
313 #if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
314 op->named.path = (u8 *) path;
315 #endif
316
317 /*
318 * Put the Node in the "op" object that the parser uses, so we
319 * can get it again quickly when this scope is closed
320 */
321 op->common.node = node;
322 acpi_ps_append_arg(acpi_ps_get_parent_scope(&walk_state->parser_state),
323 op);
324
325 *out_op = op;
326 return (status);
327 }
328
329 /*******************************************************************************
330 *
331 * FUNCTION: acpi_ds_load1_end_op
332 *
333 * PARAMETERS: walk_state - Current state of the parse tree walk
334 *
335 * RETURN: Status
336 *
337 * DESCRIPTION: Ascending callback used during the loading of the namespace,
338 * both control methods and everything else.
339 *
340 ******************************************************************************/
341
342 acpi_status acpi_ds_load1_end_op(struct acpi_walk_state * walk_state)
343 {
344 union acpi_parse_object *op;
345 acpi_object_type object_type;
346 acpi_status status = AE_OK;
347
348 ACPI_FUNCTION_NAME("ds_load1_end_op");
349
350 op = walk_state->op;
351 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
352 walk_state));
353
354 /* We are only interested in opcodes that have an associated name */
355
356 if (!(walk_state->op_info->flags & (AML_NAMED | AML_FIELD))) {
357 return (AE_OK);
358 }
359
360 /* Get the object type to determine if we should pop the scope */
361
362 object_type = walk_state->op_info->object_type;
363
364 #ifndef ACPI_NO_METHOD_EXECUTION
365 if (walk_state->op_info->flags & AML_FIELD) {
366 if (walk_state->opcode == AML_FIELD_OP ||
367 walk_state->opcode == AML_BANK_FIELD_OP ||
368 walk_state->opcode == AML_INDEX_FIELD_OP) {
369 status = acpi_ds_init_field_objects(op, walk_state);
370 }
371 return (status);
372 }
373
374 if (op->common.aml_opcode == AML_REGION_OP) {
375 status = acpi_ex_create_region(op->named.data, op->named.length,
376 (acpi_adr_space_type)
377 ((op->common.value.arg)->common.
378 value.integer), walk_state);
379 if (ACPI_FAILURE(status)) {
380 return (status);
381 }
382 }
383 #endif
384
385 if (op->common.aml_opcode == AML_NAME_OP) {
386 /* For Name opcode, get the object type from the argument */
387
388 if (op->common.value.arg) {
389 object_type = (acpi_ps_get_opcode_info((op->common.
390 value.arg)->
391 common.
392 aml_opcode))->
393 object_type;
394 op->common.node->type = (u8) object_type;
395 }
396 }
397
398 if (op->common.aml_opcode == AML_METHOD_OP) {
399 /*
400 * method_op pkg_length name_string method_flags term_list
401 *
402 * Note: We must create the method node/object pair as soon as we
403 * see the method declaration. This allows later pass1 parsing
404 * of invocations of the method (need to know the number of
405 * arguments.)
406 */
407 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
408 "LOADING-Method: State=%p Op=%p named_obj=%p\n",
409 walk_state, op, op->named.node));
410
411 if (!acpi_ns_get_attached_object(op->named.node)) {
412 walk_state->operands[0] = (void *)op->named.node;
413 walk_state->num_operands = 1;
414
415 status =
416 acpi_ds_create_operands(walk_state,
417 op->common.value.arg);
418 if (ACPI_SUCCESS(status)) {
419 status = acpi_ex_create_method(op->named.data,
420 op->named.length,
421 walk_state);
422 }
423 walk_state->operands[0] = NULL;
424 walk_state->num_operands = 0;
425
426 if (ACPI_FAILURE(status)) {
427 return (status);
428 }
429 }
430 }
431
432 /* Pop the scope stack */
433
434 if (acpi_ns_opens_scope(object_type)) {
435 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
436 "(%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 * FUNCTION: acpi_ds_load2_begin_op
448 *
449 * PARAMETERS: walk_state - Current state of the parse tree walk
450 * out_op - Wher to return op if a new one is created
451 *
452 * RETURN: Status
453 *
454 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
455 *
456 ******************************************************************************/
457
458 acpi_status
459 acpi_ds_load2_begin_op(struct acpi_walk_state * walk_state,
460 union acpi_parse_object ** out_op)
461 {
462 union acpi_parse_object *op;
463 struct acpi_namespace_node *node;
464 acpi_status status;
465 acpi_object_type object_type;
466 char *buffer_ptr;
467
468 ACPI_FUNCTION_TRACE("ds_load2_begin_op");
469
470 op = walk_state->op;
471 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
472 walk_state));
473
474 if (op) {
475 if ((walk_state->control_state) &&
476 (walk_state->control_state->common.state ==
477 ACPI_CONTROL_CONDITIONAL_EXECUTING)) {
478 /* We are executing a while loop outside of a method */
479
480 status = acpi_ds_exec_begin_op(walk_state, out_op);
481 return_ACPI_STATUS(status);
482 }
483
484 /* We only care about Namespace opcodes here */
485
486 if ((!(walk_state->op_info->flags & AML_NSOPCODE) &&
487 (walk_state->opcode != AML_INT_NAMEPATH_OP)) ||
488 (!(walk_state->op_info->flags & AML_NAMED))) {
489 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
490 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
491 (walk_state->op_info->class == AML_CLASS_CONTROL)) {
492
493 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
494 "Begin/EXEC: %s (fl %8.8X)\n",
495 walk_state->op_info->name,
496 walk_state->op_info->flags));
497
498 /* Executing a type1 or type2 opcode outside of a method */
499
500 status =
501 acpi_ds_exec_begin_op(walk_state, out_op);
502 return_ACPI_STATUS(status);
503 }
504 #endif
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 } else {
520 /* Get name from the op */
521
522 buffer_ptr = (char *)&op->named.name;
523 }
524 } else {
525 /* Get the namestring from the raw AML */
526
527 buffer_ptr =
528 acpi_ps_get_next_namestring(&walk_state->parser_state);
529 }
530
531 /* Map the opcode into an internal object type */
532
533 object_type = walk_state->op_info->object_type;
534
535 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
536 "State=%p Op=%p Type=%X\n", walk_state, op,
537 object_type));
538
539 switch (walk_state->opcode) {
540 case AML_FIELD_OP:
541 case AML_BANK_FIELD_OP:
542 case AML_INDEX_FIELD_OP:
543
544 node = NULL;
545 status = AE_OK;
546 break;
547
548 case AML_INT_NAMEPATH_OP:
549
550 /*
551 * The name_path is an object reference to an existing object.
552 * Don't enter the name into the namespace, but look it up
553 * for use later.
554 */
555 status =
556 acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
557 object_type, ACPI_IMODE_EXECUTE,
558 ACPI_NS_SEARCH_PARENT, 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 =
569 acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
570 object_type, ACPI_IMODE_EXECUTE,
571 ACPI_NS_SEARCH_PARENT, walk_state, &(node));
572 if (ACPI_FAILURE(status)) {
573 #ifdef ACPI_ASL_COMPILER
574 if (status == AE_NOT_FOUND) {
575 status = AE_OK;
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(("Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n", buffer_ptr, acpi_ut_get_type_name(node->type)));
611
612 node->type = ACPI_TYPE_ANY;
613 walk_state->scope_info->common.value = ACPI_TYPE_ANY;
614 break;
615
616 default:
617
618 /* All other types are an error */
619
620 ACPI_REPORT_ERROR(("Invalid type (%s) for target of Scope operator [%4.4s]\n", acpi_ut_get_type_name(node->type), buffer_ptr));
621
622 return (AE_AML_OPERAND_TYPE);
623 }
624 break;
625
626 default:
627
628 /* All other opcodes */
629
630 if (op && op->common.node) {
631 /* This op/node was previously entered into the namespace */
632
633 node = op->common.node;
634
635 if (acpi_ns_opens_scope(object_type)) {
636 status =
637 acpi_ds_scope_stack_push(node, object_type,
638 walk_state);
639 if (ACPI_FAILURE(status)) {
640 return_ACPI_STATUS(status);
641 }
642
643 }
644 return_ACPI_STATUS(AE_OK);
645 }
646
647 /*
648 * Enter the named type into the internal namespace. We enter the name
649 * as we go downward in the parse tree. Any necessary subobjects that
650 * involve arguments to the opcode must be created as we go back up the
651 * parse tree later.
652 *
653 * Note: Name may already exist if we are executing a deferred opcode.
654 */
655 if (walk_state->deferred_node) {
656 /* This name is already in the namespace, get the node */
657
658 node = walk_state->deferred_node;
659 status = AE_OK;
660 break;
661 }
662
663 /* Add new entry into namespace */
664
665 status =
666 acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
667 object_type, ACPI_IMODE_LOAD_PASS2,
668 ACPI_NS_NO_UPSEARCH, walk_state, &(node));
669 break;
670 }
671
672 if (ACPI_FAILURE(status)) {
673 ACPI_REPORT_NSERROR(buffer_ptr, status);
674 return_ACPI_STATUS(status);
675 }
676
677 if (!op) {
678 /* Create a new op */
679
680 op = acpi_ps_alloc_op(walk_state->opcode);
681 if (!op) {
682 return_ACPI_STATUS(AE_NO_MEMORY);
683 }
684
685 /* Initialize the new op */
686
687 if (node) {
688 op->named.name = node->name.integer;
689 }
690 *out_op = op;
691 }
692
693 /*
694 * Put the Node in the "op" object that the parser uses, so we
695 * can get it again quickly when this scope is closed
696 */
697 op->common.node = node;
698
699 return_ACPI_STATUS(status);
700 }
701
702 /*******************************************************************************
703 *
704 * FUNCTION: acpi_ds_load2_end_op
705 *
706 * PARAMETERS: walk_state - Current state of the parse tree walk
707 *
708 * RETURN: Status
709 *
710 * DESCRIPTION: Ascending callback used during the loading of the namespace,
711 * both control methods and everything else.
712 *
713 ******************************************************************************/
714
715 acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
716 {
717 union acpi_parse_object *op;
718 acpi_status status = AE_OK;
719 acpi_object_type object_type;
720 struct acpi_namespace_node *node;
721 union acpi_parse_object *arg;
722 struct acpi_namespace_node *new_node;
723 #ifndef ACPI_NO_METHOD_EXECUTION
724 u32 i;
725 #endif
726
727 ACPI_FUNCTION_TRACE("ds_load2_end_op");
728
729 op = walk_state->op;
730 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
731 walk_state->op_info->name, op, walk_state));
732
733 /* Check if opcode had an associated namespace object */
734
735 if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
736 #ifndef ACPI_NO_METHOD_EXECUTION
737 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
738 /* No namespace object. Executable opcode? */
739
740 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
741 (walk_state->op_info->class == AML_CLASS_CONTROL)) {
742 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
743 "End/EXEC: %s (fl %8.8X)\n",
744 walk_state->op_info->name,
745 walk_state->op_info->flags));
746
747 /* Executing a type1 or type2 opcode outside of a method */
748
749 status = acpi_ds_exec_end_op(walk_state);
750 return_ACPI_STATUS(status);
751 }
752 #endif
753 #endif
754 return_ACPI_STATUS(AE_OK);
755 }
756
757 if (op->common.aml_opcode == AML_SCOPE_OP) {
758 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
759 "Ending scope Op=%p State=%p\n", op,
760 walk_state));
761 }
762
763 object_type = walk_state->op_info->object_type;
764
765 /*
766 * Get the Node/name from the earlier lookup
767 * (It was saved in the *op structure)
768 */
769 node = op->common.node;
770
771 /*
772 * Put the Node on the object stack (Contains the ACPI Name of
773 * this object)
774 */
775 walk_state->operands[0] = (void *)node;
776 walk_state->num_operands = 1;
777
778 /* Pop the scope stack */
779
780 if (acpi_ns_opens_scope(object_type) &&
781 (op->common.aml_opcode != AML_INT_METHODCALL_OP)) {
782 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
783 "(%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),
823 walk_state, op, node));
824
825 /* Decode the opcode */
826
827 arg = op->common.value.arg;
828
829 switch (walk_state->op_info->type) {
830 #ifndef ACPI_NO_METHOD_EXECUTION
831
832 case AML_TYPE_CREATE_FIELD:
833
834 /*
835 * Create the field object, but the field buffer and index must
836 * be evaluated later during the execution phase
837 */
838 status = acpi_ds_create_buffer_field(op, walk_state);
839 break;
840
841 case AML_TYPE_NAMED_FIELD:
842
843 switch (op->common.aml_opcode) {
844 case AML_INDEX_FIELD_OP:
845
846 status =
847 acpi_ds_create_index_field(op,
848 (acpi_handle) arg->
849 common.node, walk_state);
850 break;
851
852 case AML_BANK_FIELD_OP:
853
854 status =
855 acpi_ds_create_bank_field(op, arg->common.node,
856 walk_state);
857 break;
858
859 case AML_FIELD_OP:
860
861 status =
862 acpi_ds_create_field(op, arg->common.node,
863 walk_state);
864 break;
865
866 default:
867 /* All NAMED_FIELD opcodes must be handled above */
868 break;
869 }
870 break;
871
872 case AML_TYPE_NAMED_SIMPLE:
873
874 status = acpi_ds_create_operands(walk_state, arg);
875 if (ACPI_FAILURE(status)) {
876 goto cleanup;
877 }
878
879 switch (op->common.aml_opcode) {
880 case AML_PROCESSOR_OP:
881
882 status = acpi_ex_create_processor(walk_state);
883 break;
884
885 case AML_POWER_RES_OP:
886
887 status = acpi_ex_create_power_resource(walk_state);
888 break;
889
890 case AML_MUTEX_OP:
891
892 status = acpi_ex_create_mutex(walk_state);
893 break;
894
895 case AML_EVENT_OP:
896
897 status = acpi_ex_create_event(walk_state);
898 break;
899
900 case AML_DATA_REGION_OP:
901
902 status = acpi_ex_create_table_region(walk_state);
903 break;
904
905 case AML_ALIAS_OP:
906
907 status = acpi_ex_create_alias(walk_state);
908 break;
909
910 default:
911 /* Unknown opcode */
912
913 status = AE_OK;
914 goto cleanup;
915 }
916
917 /* Delete operands */
918
919 for (i = 1; i < walk_state->num_operands; i++) {
920 acpi_ut_remove_reference(walk_state->operands[i]);
921 walk_state->operands[i] = NULL;
922 }
923
924 break;
925 #endif /* ACPI_NO_METHOD_EXECUTION */
926
927 case AML_TYPE_NAMED_COMPLEX:
928
929 switch (op->common.aml_opcode) {
930 #ifndef ACPI_NO_METHOD_EXECUTION
931 case AML_REGION_OP:
932 /*
933 * The op_region is not fully parsed at this time. Only valid
934 * argument is the space_id. (We must save the address of the
935 * AML of the address and length operands)
936 */
937 /*
938 * If we have a valid region, initialize it
939 * Namespace is NOT locked at this point.
940 */
941 status =
942 acpi_ev_initialize_region
943 (acpi_ns_get_attached_object(node), FALSE);
944 if (ACPI_FAILURE(status)) {
945 /*
946 * If AE_NOT_EXIST is returned, it is not fatal
947 * because many regions get created before a handler
948 * is installed for said region.
949 */
950 if (AE_NOT_EXIST == status) {
951 status = AE_OK;
952 }
953 }
954 break;
955
956 case AML_NAME_OP:
957
958 status = acpi_ds_create_node(walk_state, node, op);
959 break;
960 #endif /* ACPI_NO_METHOD_EXECUTION */
961
962 default:
963 /* All NAMED_COMPLEX opcodes must be handled above */
964 /* Note: Method objects were already created in Pass 1 */
965 break;
966 }
967 break;
968
969 case AML_CLASS_INTERNAL:
970
971 /* case AML_INT_NAMEPATH_OP: */
972 break;
973
974 case AML_CLASS_METHOD_CALL:
975
976 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
977 "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
978 walk_state, op, node));
979
980 /*
981 * Lookup the method name and save the Node
982 */
983 status =
984 acpi_ns_lookup(walk_state->scope_info,
985 arg->common.value.string, ACPI_TYPE_ANY,
986 ACPI_IMODE_LOAD_PASS2,
987 ACPI_NS_SEARCH_PARENT |
988 ACPI_NS_DONT_OPEN_SCOPE, walk_state,
989 &(new_node));
990 if (ACPI_SUCCESS(status)) {
991
992 /*
993 * Make sure that what we found is indeed a method
994 * We didn't search for a method on purpose, to see if the name
995 * would resolve
996 */
997 if (new_node->type != ACPI_TYPE_METHOD) {
998 status = AE_AML_OPERAND_TYPE;
999 }
1000
1001 /* We could put the returned object (Node) on the object stack for
1002 * later, but for now, we will put it in the "op" object that the
1003 * parser uses, so we can get it again at the end of this scope
1004 */
1005 op->common.node = new_node;
1006 } else {
1007 ACPI_REPORT_NSERROR(arg->common.value.string, status);
1008 }
1009 break;
1010
1011 default:
1012 break;
1013 }
1014
1015 cleanup:
1016
1017 /* Remove the Node pushed at the very beginning */
1018
1019 walk_state->operands[0] = NULL;
1020 walk_state->num_operands = 0;
1021 return_ACPI_STATUS(status);
1022 }
Verdex Pro support