?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Kai Germaschewski: ISDN update (including Makefiles)
[davej-history.git] / drivers / acpi / dispatcher / dsutils.c
blob2efa43e5164bc7a0f7f00e728f645f6ab1c5f92f
1 /*******************************************************************************
2 *
3 * Module Name: dsutils - Dispatcher utilities
4 * $Revision: 50 $
5 *
6 ******************************************************************************/
7
8 /*
9 * Copyright (C) 2000 R. Byron Moore
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */
25
26
27 #include "acpi.h"
28 #include "acparser.h"
29 #include "amlcode.h"
30 #include "acdispat.h"
31 #include "acinterp.h"
32 #include "acnamesp.h"
33 #include "acdebug.h"
34
35 #define _COMPONENT PARSER
36 MODULE_NAME ("dsutils")
37
38
39 /*******************************************************************************
40 *
41 * FUNCTION: Acpi_ds_is_result_used
42 *
43 * PARAMETERS: Op
44 * Result_obj
45 * Walk_state
46 *
47 * RETURN: Status
48 *
49 * DESCRIPTION: Check if a result object will be used by the parent
50 *
51 ******************************************************************************/
52
53 u8
54 acpi_ds_is_result_used (
55 ACPI_PARSE_OBJECT *op,
56 ACPI_WALK_STATE *walk_state)
57 {
58 ACPI_OPCODE_INFO *parent_info;
59
60
61 /* Must have both an Op and a Result Object */
62
63 if (!op) {
64 return (TRUE);
65 }
66
67
68 /*
69 * If there is no parent, the result can't possibly be used!
70 * (An executing method typically has no parent, since each
71 * method is parsed separately) However, a method that is
72 * invoked from another method has a parent.
73 */
74 if (!op->parent) {
75 return (FALSE);
76 }
77
78
79 /*
80 * Get info on the parent. The root Op is AML_SCOPE
81 */
82
83 parent_info = acpi_ps_get_opcode_info (op->parent->opcode);
84 if (ACPI_GET_OP_TYPE (parent_info) != ACPI_OP_TYPE_OPCODE) {
85 return (FALSE);
86 }
87
88
89 /*
90 * Decide what to do with the result based on the parent. If
91 * the parent opcode will not use the result, delete the object.
92 * Otherwise leave it as is, it will be deleted when it is used
93 * as an operand later.
94 */
95
96 switch (ACPI_GET_OP_CLASS (parent_info))
97 {
98 /*
99 * In these cases, the parent will never use the return object
100 */
101 case OPTYPE_CONTROL: /* IF, ELSE, WHILE only */
102
103 switch (op->parent->opcode)
104 {
105 case AML_RETURN_OP:
106
107 /* Never delete the return value associated with a return opcode */
108
109 return (TRUE);
110 break;
111
112 case AML_IF_OP:
113 case AML_WHILE_OP:
114
115 /*
116 * If we are executing the predicate AND this is the predicate op,
117 * we will use the return value!
118 */
119
120 if ((walk_state->control_state->common.state == CONTROL_PREDICATE_EXECUTING) &&
121 (walk_state->control_state->control.predicate_op == op))
122 {
123 return (TRUE);
124 }
125
126 break;
127 }
128
129
130 /* Fall through to not used case below */
131
132
133 case OPTYPE_NAMED_OBJECT: /* Scope, method, etc. */
134
135 /*
136 * These opcodes allow Term_arg(s) as operands and therefore
137 * method calls. The result is used.
138 */
139 if ((op->parent->opcode == AML_REGION_OP) ||
140 (op->parent->opcode == AML_CREATE_FIELD_OP) ||
141 (op->parent->opcode == AML_BIT_FIELD_OP) ||
142 (op->parent->opcode == AML_BYTE_FIELD_OP) ||
143 (op->parent->opcode == AML_WORD_FIELD_OP) ||
144 (op->parent->opcode == AML_DWORD_FIELD_OP) ||
145 (op->parent->opcode == AML_QWORD_FIELD_OP))
146 {
147 return (TRUE);
148 }
149
150 return (FALSE);
151 break;
152
153 /*
154 * In all other cases. the parent will actually use the return
155 * object, so keep it.
156 */
157 default:
158 break;
159 }
160
161 return (TRUE);
162 }
163
164
165 /*******************************************************************************
166 *
167 * FUNCTION: Acpi_ds_delete_result_if_not_used
168 *
169 * PARAMETERS: Op
170 * Result_obj
171 * Walk_state
172 *
173 * RETURN: Status
174 *
175 * DESCRIPTION: Used after interpretation of an opcode. If there is an internal
176 * result descriptor, check if the parent opcode will actually use
177 * this result. If not, delete the result now so that it will
178 * not become orphaned.
179 *
180 ******************************************************************************/
181
182 void
183 acpi_ds_delete_result_if_not_used (
184 ACPI_PARSE_OBJECT *op,
185 ACPI_OPERAND_OBJECT *result_obj,
186 ACPI_WALK_STATE *walk_state)
187 {
188 ACPI_OPERAND_OBJECT *obj_desc;
189 ACPI_STATUS status;
190
191
192 if (!op) {
193 return;
194 }
195
196 if (!result_obj) {
197 return;
198 }
199
200
201 if (!acpi_ds_is_result_used (op, walk_state)) {
202 /*
203 * Must pop the result stack (Obj_desc should be equal
204 * to Result_obj)
205 */
206
207 status = acpi_ds_result_pop (&obj_desc, walk_state);
208 if (ACPI_SUCCESS (status)) {
209 acpi_cm_remove_reference (result_obj);
210 }
211 }
212
213 return;
214 }
215
216
217 /*******************************************************************************
218 *
219 * FUNCTION: Acpi_ds_create_operand
220 *
221 * PARAMETERS: Walk_state
222 * Arg
223 *
224 * RETURN: Status
225 *
226 * DESCRIPTION: Translate a parse tree object that is an argument to an AML
227 * opcode to the equivalent interpreter object. This may include
228 * looking up a name or entering a new name into the internal
229 * namespace.
230 *
231 ******************************************************************************/
232
233 ACPI_STATUS
234 acpi_ds_create_operand (
235 ACPI_WALK_STATE *walk_state,
236 ACPI_PARSE_OBJECT *arg,
237 u32 arg_index)
238 {
239 ACPI_STATUS status = AE_OK;
240 NATIVE_CHAR *name_string;
241 u32 name_length;
242 OBJECT_TYPE_INTERNAL data_type;
243 ACPI_OPERAND_OBJECT *obj_desc;
244 ACPI_PARSE_OBJECT *parent_op;
245 u16 opcode;
246 u32 flags;
247 OPERATING_MODE interpreter_mode;
248
249
250 /* A valid name must be looked up in the namespace */
251
252 if ((arg->opcode == AML_NAMEPATH_OP) &&
253 (arg->value.string))
254 {
255 /* Get the entire name string from the AML stream */
256
257 status = acpi_aml_get_name_string (ACPI_TYPE_ANY,
258 arg->value.buffer,
259 &name_string,
260 &name_length);
261
262 if (ACPI_FAILURE (status)) {
263 return (status);
264 }
265
266 /*
267 * All prefixes have been handled, and the name is
268 * in Name_string
269 */
270
271 /*
272 * Differentiate between a namespace "create" operation
273 * versus a "lookup" operation (IMODE_LOAD_PASS2 vs.
274 * IMODE_EXECUTE) in order to support the creation of
275 * namespace objects during the execution of control methods.
276 */
277
278 parent_op = arg->parent;
279 if ((acpi_ps_is_node_op (parent_op->opcode)) &&
280 (parent_op->opcode != AML_METHODCALL_OP) &&
281 (parent_op->opcode != AML_REGION_OP) &&
282 (parent_op->opcode != AML_NAMEPATH_OP))
283 {
284 /* Enter name into namespace if not found */
285
286 interpreter_mode = IMODE_LOAD_PASS2;
287 }
288
289 else {
290 /* Return a failure if name not found */
291
292 interpreter_mode = IMODE_EXECUTE;
293 }
294
295 status = acpi_ns_lookup (walk_state->scope_info, name_string,
296 ACPI_TYPE_ANY, interpreter_mode,
297 NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE,
298 walk_state,
299 (ACPI_NAMESPACE_NODE **) &obj_desc);
300
301 /* Free the namestring created above */
302
303 acpi_cm_free (name_string);
304
305 /*
306 * The only case where we pass through (ignore) a NOT_FOUND
307 * error is for the Cond_ref_of opcode.
308 */
309
310 if (status == AE_NOT_FOUND) {
311 if (parent_op->opcode == AML_COND_REF_OF_OP) {
312 /*
313 * For the Conditional Reference op, it's OK if
314 * the name is not found; We just need a way to
315 * indicate this to the interpreter, set the
316 * object to the root
317 */
318 obj_desc = (ACPI_OPERAND_OBJECT *) acpi_gbl_root_node;
319 status = AE_OK;
320 }
321
322 else {
323 /*
324 * We just plain didn't find it -- which is a
325 * very serious error at this point
326 */
327 status = AE_AML_NAME_NOT_FOUND;
328 }
329 }
330
331 /* Check status from the lookup */
332
333 if (ACPI_FAILURE (status)) {
334 return (status);
335 }
336
337 /* Put the resulting object onto the current object stack */
338
339 status = acpi_ds_obj_stack_push (obj_desc, walk_state);
340 if (ACPI_FAILURE (status)) {
341 return (status);
342 }
343 DEBUGGER_EXEC (acpi_db_display_argument_object (obj_desc, walk_state));
344 }
345
346
347 else {
348 /* Check for null name case */
349
350 if (arg->opcode == AML_NAMEPATH_OP) {
351 /*
352 * If the name is null, this means that this is an
353 * optional result parameter that was not specified
354 * in the original ASL. Create an Reference for a
355 * placeholder
356 */
357 opcode = AML_ZERO_OP; /* Has no arguments! */
358
359 /*
360 * TBD: [Investigate] anything else needed for the
361 * zero op lvalue?
362 */
363 }
364
365 else {
366 opcode = arg->opcode;
367 }
368
369
370 /* Get the data type of the argument */
371
372 data_type = acpi_ds_map_opcode_to_data_type (opcode, &flags);
373 if (data_type == INTERNAL_TYPE_INVALID) {
374 return (AE_NOT_IMPLEMENTED);
375 }
376
377 if (flags & OP_HAS_RETURN_VALUE) {
378 DEBUGGER_EXEC (acpi_db_display_argument_object (walk_state->operands [walk_state->num_operands - 1], walk_state));
379
380 /*
381 * Use value that was already previously returned
382 * by the evaluation of this argument
383 */
384
385 status = acpi_ds_result_pop_from_bottom (&obj_desc, walk_state);
386 if (ACPI_FAILURE (status)) {
387 /*
388 * Only error is underflow, and this indicates
389 * a missing or null operand!
390 */
391 return (status);
392 }
393
394 }
395
396 else {
397 /* Create an ACPI_INTERNAL_OBJECT for the argument */
398
399 obj_desc = acpi_cm_create_internal_object (data_type);
400 if (!obj_desc) {
401 return (AE_NO_MEMORY);
402 }
403
404 /* Initialize the new object */
405
406 status = acpi_ds_init_object_from_op (walk_state, arg,
407 opcode, &obj_desc);
408 if (ACPI_FAILURE (status)) {
409 acpi_cm_delete_object_desc (obj_desc);
410 return (status);
411 }
412 }
413
414 /* Put the operand object on the object stack */
415
416 status = acpi_ds_obj_stack_push (obj_desc, walk_state);
417 if (ACPI_FAILURE (status)) {
418 return (status);
419 }
420
421 DEBUGGER_EXEC (acpi_db_display_argument_object (obj_desc, walk_state));
422 }
423
424 return (AE_OK);
425 }
426
427
428 /*******************************************************************************
429 *
430 * FUNCTION: Acpi_ds_create_operands
431 *
432 * PARAMETERS: First_arg - First argument of a parser argument tree
433 *
434 * RETURN: Status
435 *
436 * DESCRIPTION: Convert an operator's arguments from a parse tree format to
437 * namespace objects and place those argument object on the object
438 * stack in preparation for evaluation by the interpreter.
439 *
440 ******************************************************************************/
441
442 ACPI_STATUS
443 acpi_ds_create_operands (
444 ACPI_WALK_STATE *walk_state,
445 ACPI_PARSE_OBJECT *first_arg)
446 {
447 ACPI_STATUS status = AE_OK;
448 ACPI_PARSE_OBJECT *arg;
449 u32 arg_count = 0;
450
451
452 /* For all arguments in the list... */
453
454 arg = first_arg;
455 while (arg) {
456 status = acpi_ds_create_operand (walk_state, arg, arg_count);
457 if (ACPI_FAILURE (status)) {
458 goto cleanup;
459 }
460
461 /* Move on to next argument, if any */
462
463 arg = arg->next;
464 arg_count++;
465 }
466
467 return (status);
468
469
470 cleanup:
471 /*
472 * We must undo everything done above; meaning that we must
473 * pop everything off of the operand stack and delete those
474 * objects
475 */
476
477 acpi_ds_obj_stack_pop_and_delete (arg_count, walk_state);
478
479 return (status);
480 }
481
482
483 /*******************************************************************************
484 *
485 * FUNCTION: Acpi_ds_resolve_operands
486 *
487 * PARAMETERS: Walk_state - Current walk state with operands on stack
488 *
489 * RETURN: Status
490 *
491 * DESCRIPTION: Resolve all operands to their values. Used to prepare
492 * arguments to a control method invocation (a call from one
493 * method to another.)
494 *
495 ******************************************************************************/
496
497 ACPI_STATUS
498 acpi_ds_resolve_operands (
499 ACPI_WALK_STATE *walk_state)
500 {
501 u32 i;
502 ACPI_STATUS status = AE_OK;
503
504
505 /*
506 * Attempt to resolve each of the valid operands
507 * Method arguments are passed by value, not by reference
508 */
509
510 /*
511 * TBD: [Investigate] Note from previous parser:
512 * Ref_of problem with Acpi_aml_resolve_to_value() conversion.
513 */
514
515 for (i = 0; i < walk_state->num_operands; i++) {
516 status = acpi_aml_resolve_to_value (&walk_state->operands[i], walk_state);
517 if (ACPI_FAILURE (status)) {
518 break;
519 }
520 }
521
522 return (status);
523 }
524
525
526 /*******************************************************************************
527 *
528 * FUNCTION: Acpi_ds_map_opcode_to_data_type
529 *
530 * PARAMETERS: Opcode - AML opcode to map
531 * Out_flags - Additional info about the opcode
532 *
533 * RETURN: The ACPI type associated with the opcode
534 *
535 * DESCRIPTION: Convert a raw AML opcode to the associated ACPI data type,
536 * if any. If the opcode returns a value as part of the
537 * intepreter execution, a flag is returned in Out_flags.
538 *
539 ******************************************************************************/
540
541 OBJECT_TYPE_INTERNAL
542 acpi_ds_map_opcode_to_data_type (
543 u16 opcode,
544 u32 *out_flags)
545 {
546 OBJECT_TYPE_INTERNAL data_type = INTERNAL_TYPE_INVALID;
547 ACPI_OPCODE_INFO *op_info;
548 u32 flags = 0;
549
550
551 op_info = acpi_ps_get_opcode_info (opcode);
552 if (ACPI_GET_OP_TYPE (op_info) != ACPI_OP_TYPE_OPCODE) {
553 /* Unknown opcode */
554
555 return (data_type);
556 }
557
558 switch (ACPI_GET_OP_CLASS (op_info))
559 {
560
561 case OPTYPE_LITERAL:
562
563 switch (opcode)
564 {
565 case AML_BYTE_OP:
566 case AML_WORD_OP:
567 case AML_DWORD_OP:
568
569 data_type = ACPI_TYPE_NUMBER;
570 break;
571
572
573 case AML_STRING_OP:
574
575 data_type = ACPI_TYPE_STRING;
576 break;
577
578 case AML_NAMEPATH_OP:
579 data_type = INTERNAL_TYPE_REFERENCE;
580 break;
581
582 default:
583 break;
584 }
585 break;
586
587
588 case OPTYPE_DATA_TERM:
589
590 switch (opcode)
591 {
592 case AML_BUFFER_OP:
593
594 data_type = ACPI_TYPE_BUFFER;
595 break;
596
597 case AML_PACKAGE_OP:
598
599 data_type = ACPI_TYPE_PACKAGE;
600 break;
601
602 default:
603 break;
604 }
605 break;
606
607
608 case OPTYPE_CONSTANT:
609 case OPTYPE_METHOD_ARGUMENT:
610 case OPTYPE_LOCAL_VARIABLE:
611
612 data_type = INTERNAL_TYPE_REFERENCE;
613 break;
614
615
616 case OPTYPE_MONADIC2:
617 case OPTYPE_MONADIC2_r:
618 case OPTYPE_DYADIC2:
619 case OPTYPE_DYADIC2_r:
620 case OPTYPE_DYADIC2_s:
621 case OPTYPE_INDEX:
622 case OPTYPE_MATCH:
623 case OPTYPE_RETURN:
624
625 flags = OP_HAS_RETURN_VALUE;
626 data_type = ACPI_TYPE_ANY;
627 break;
628
629 case OPTYPE_METHOD_CALL:
630
631 flags = OP_HAS_RETURN_VALUE;
632 data_type = ACPI_TYPE_METHOD;
633 break;
634
635
636 case OPTYPE_NAMED_OBJECT:
637
638 data_type = acpi_ds_map_named_opcode_to_data_type (opcode);
639 break;
640
641
642 case OPTYPE_DYADIC1:
643 case OPTYPE_CONTROL:
644
645 /* No mapping needed at this time */
646
647 break;
648
649
650 default:
651
652 break;
653 }
654
655 /* Return flags to caller if requested */
656
657 if (out_flags) {
658 *out_flags = flags;
659 }
660
661 return (data_type);
662 }
663
664
665 /*******************************************************************************
666 *
667 * FUNCTION: Acpi_ds_map_named_opcode_to_data_type
668 *
669 * PARAMETERS: Opcode - The Named AML opcode to map
670 *
671 * RETURN: The ACPI type associated with the named opcode
672 *
673 * DESCRIPTION: Convert a raw Named AML opcode to the associated data type.
674 * Named opcodes are a subsystem of the AML opcodes.
675 *
676 ******************************************************************************/
677
678 OBJECT_TYPE_INTERNAL
679 acpi_ds_map_named_opcode_to_data_type (
680 u16 opcode)
681 {
682 OBJECT_TYPE_INTERNAL data_type;
683
684
685 /* Decode Opcode */
686
687 switch (opcode)
688 {
689 case AML_SCOPE_OP:
690 data_type = INTERNAL_TYPE_SCOPE;
691 break;
692
693 case AML_DEVICE_OP:
694 data_type = ACPI_TYPE_DEVICE;
695 break;
696
697 case AML_THERMAL_ZONE_OP:
698 data_type = ACPI_TYPE_THERMAL;
699 break;
700
701 case AML_METHOD_OP:
702 data_type = ACPI_TYPE_METHOD;
703 break;
704
705 case AML_POWER_RES_OP:
706 data_type = ACPI_TYPE_POWER;
707 break;
708
709 case AML_PROCESSOR_OP:
710 data_type = ACPI_TYPE_PROCESSOR;
711 break;
712
713 case AML_DEF_FIELD_OP: /* Def_field_op */
714 data_type = INTERNAL_TYPE_DEF_FIELD_DEFN;
715 break;
716
717 case AML_INDEX_FIELD_OP: /* Index_field_op */
718 data_type = INTERNAL_TYPE_INDEX_FIELD_DEFN;
719 break;
720
721 case AML_BANK_FIELD_OP: /* Bank_field_op */
722 data_type = INTERNAL_TYPE_BANK_FIELD_DEFN;
723 break;
724
725 case AML_NAMEDFIELD_OP: /* NO CASE IN ORIGINAL */
726 data_type = ACPI_TYPE_ANY;
727 break;
728
729 case AML_NAME_OP: /* Name_op - special code in original */
730 case AML_NAMEPATH_OP:
731 data_type = ACPI_TYPE_ANY;
732 break;
733
734 case AML_ALIAS_OP:
735 data_type = INTERNAL_TYPE_ALIAS;
736 break;
737
738 case AML_MUTEX_OP:
739 data_type = ACPI_TYPE_MUTEX;
740 break;
741
742 case AML_EVENT_OP:
743 data_type = ACPI_TYPE_EVENT;
744 break;
745
746 case AML_REGION_OP:
747 data_type = ACPI_TYPE_REGION;
748 break;
749
750
751 default:
752 data_type = ACPI_TYPE_ANY;
753 break;
754
755 }
756
757 return (data_type);
758 }
759
760
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux