?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.20.7
[linux/fpc-iii.git] / drivers / acpi / executer / exresolv.c
blob6499de8780173f44e19a41ef7bf2ac9fb30d9531
1
2 /******************************************************************************
3 *
4 * Module Name: exresolv - AML Interpreter object resolution
5 *
6 *****************************************************************************/
7
8 /*
9 * Copyright (C) 2000 - 2006, R. Byron Moore
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45 #include <acpi/acpi.h>
46 #include <acpi/amlcode.h>
47 #include <acpi/acdispat.h>
48 #include <acpi/acinterp.h>
49 #include <acpi/acnamesp.h>
50 #include <acpi/acparser.h>
51
52 #define _COMPONENT ACPI_EXECUTER
53 ACPI_MODULE_NAME("exresolv")
54
55 /* Local prototypes */
56 static acpi_status
57 acpi_ex_resolve_object_to_value(union acpi_operand_object **stack_ptr,
58 struct acpi_walk_state *walk_state);
59
60 /*******************************************************************************
61 *
62 * FUNCTION: acpi_ex_resolve_to_value
63 *
64 * PARAMETERS: **stack_ptr - Points to entry on obj_stack, which can
65 * be either an (union acpi_operand_object *)
66 * or an acpi_handle.
67 * walk_state - Current method state
68 *
69 * RETURN: Status
70 *
71 * DESCRIPTION: Convert Reference objects to values
72 *
73 ******************************************************************************/
74
75 acpi_status
76 acpi_ex_resolve_to_value(union acpi_operand_object **stack_ptr,
77 struct acpi_walk_state *walk_state)
78 {
79 acpi_status status;
80
81 ACPI_FUNCTION_TRACE_PTR(ex_resolve_to_value, stack_ptr);
82
83 if (!stack_ptr || !*stack_ptr) {
84 ACPI_ERROR((AE_INFO, "Internal - null pointer"));
85 return_ACPI_STATUS(AE_AML_NO_OPERAND);
86 }
87
88 /*
89 * The entity pointed to by the stack_ptr can be either
90 * 1) A valid union acpi_operand_object, or
91 * 2) A struct acpi_namespace_node (named_obj)
92 */
93 if (ACPI_GET_DESCRIPTOR_TYPE(*stack_ptr) == ACPI_DESC_TYPE_OPERAND) {
94 status = acpi_ex_resolve_object_to_value(stack_ptr, walk_state);
95 if (ACPI_FAILURE(status)) {
96 return_ACPI_STATUS(status);
97 }
98
99 if (!*stack_ptr) {
100 ACPI_ERROR((AE_INFO, "Internal - null pointer"));
101 return_ACPI_STATUS(AE_AML_NO_OPERAND);
102 }
103 }
104
105 /*
106 * Object on the stack may have changed if acpi_ex_resolve_object_to_value()
107 * was called (i.e., we can't use an _else_ here.)
108 */
109 if (ACPI_GET_DESCRIPTOR_TYPE(*stack_ptr) == ACPI_DESC_TYPE_NAMED) {
110 status =
111 acpi_ex_resolve_node_to_value(ACPI_CAST_INDIRECT_PTR
112 (struct acpi_namespace_node,
113 stack_ptr), walk_state);
114 if (ACPI_FAILURE(status)) {
115 return_ACPI_STATUS(status);
116 }
117 }
118
119 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Resolved object %p\n", *stack_ptr));
120 return_ACPI_STATUS(AE_OK);
121 }
122
123 /*******************************************************************************
124 *
125 * FUNCTION: acpi_ex_resolve_object_to_value
126 *
127 * PARAMETERS: stack_ptr - Pointer to an internal object
128 * walk_state - Current method state
129 *
130 * RETURN: Status
131 *
132 * DESCRIPTION: Retrieve the value from an internal object. The Reference type
133 * uses the associated AML opcode to determine the value.
134 *
135 ******************************************************************************/
136
137 static acpi_status
138 acpi_ex_resolve_object_to_value(union acpi_operand_object **stack_ptr,
139 struct acpi_walk_state *walk_state)
140 {
141 acpi_status status = AE_OK;
142 union acpi_operand_object *stack_desc;
143 void *temp_node;
144 union acpi_operand_object *obj_desc;
145 u16 opcode;
146
147 ACPI_FUNCTION_TRACE(ex_resolve_object_to_value);
148
149 stack_desc = *stack_ptr;
150
151 /* This is an union acpi_operand_object */
152
153 switch (ACPI_GET_OBJECT_TYPE(stack_desc)) {
154 case ACPI_TYPE_LOCAL_REFERENCE:
155
156 opcode = stack_desc->reference.opcode;
157
158 switch (opcode) {
159 case AML_NAME_OP:
160
161 /*
162 * Convert name reference to a namespace node
163 * Then, acpi_ex_resolve_node_to_value can be used to get the value
164 */
165 temp_node = stack_desc->reference.object;
166
167 /* Delete the Reference Object */
168
169 acpi_ut_remove_reference(stack_desc);
170
171 /* Return the namespace node */
172
173 (*stack_ptr) = temp_node;
174 break;
175
176 case AML_LOCAL_OP:
177 case AML_ARG_OP:
178
179 /*
180 * Get the local from the method's state info
181 * Note: this increments the local's object reference count
182 */
183 status = acpi_ds_method_data_get_value(opcode,
184 stack_desc->
185 reference.offset,
186 walk_state,
187 &obj_desc);
188 if (ACPI_FAILURE(status)) {
189 return_ACPI_STATUS(status);
190 }
191
192 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
193 "[Arg/Local %X] ValueObj is %p\n",
194 stack_desc->reference.offset,
195 obj_desc));
196
197 /*
198 * Now we can delete the original Reference Object and
199 * replace it with the resolved value
200 */
201 acpi_ut_remove_reference(stack_desc);
202 *stack_ptr = obj_desc;
203 break;
204
205 case AML_INDEX_OP:
206
207 switch (stack_desc->reference.target_type) {
208 case ACPI_TYPE_BUFFER_FIELD:
209
210 /* Just return - leave the Reference on the stack */
211 break;
212
213 case ACPI_TYPE_PACKAGE:
214
215 obj_desc = *stack_desc->reference.where;
216 if (obj_desc) {
217 /*
218 * Valid obj descriptor, copy pointer to return value
219 * (i.e., dereference the package index)
220 * Delete the ref object, increment the returned object
221 */
222 acpi_ut_remove_reference(stack_desc);
223 acpi_ut_add_reference(obj_desc);
224 *stack_ptr = obj_desc;
225 } else {
226 /*
227 * A NULL object descriptor means an unitialized element of
228 * the package, can't dereference it
229 */
230 ACPI_ERROR((AE_INFO,
231 "Attempt to deref an Index to NULL pkg element Idx=%p",
232 stack_desc));
233 status = AE_AML_UNINITIALIZED_ELEMENT;
234 }
235 break;
236
237 default:
238
239 /* Invalid reference object */
240
241 ACPI_ERROR((AE_INFO,
242 "Unknown TargetType %X in Index/Reference obj %p",
243 stack_desc->reference.target_type,
244 stack_desc));
245 status = AE_AML_INTERNAL;
246 break;
247 }
248 break;
249
250 case AML_REF_OF_OP:
251 case AML_DEBUG_OP:
252 case AML_LOAD_OP:
253
254 /* Just leave the object as-is */
255
256 break;
257
258 case AML_INT_NAMEPATH_OP: /* Reference to a named object */
259
260 /* Dereference the name */
261
262 if ((stack_desc->reference.node->type ==
263 ACPI_TYPE_DEVICE)
264 || (stack_desc->reference.node->type ==
265 ACPI_TYPE_THERMAL)) {
266
267 /* These node types do not have 'real' subobjects */
268
269 *stack_ptr = (void *)stack_desc->reference.node;
270 } else {
271 /* Get the object pointed to by the namespace node */
272
273 *stack_ptr =
274 (stack_desc->reference.node)->object;
275 acpi_ut_add_reference(*stack_ptr);
276 }
277
278 acpi_ut_remove_reference(stack_desc);
279 break;
280
281 default:
282
283 ACPI_ERROR((AE_INFO,
284 "Unknown Reference opcode %X (%s) in %p",
285 opcode, acpi_ps_get_opcode_name(opcode),
286 stack_desc));
287 status = AE_AML_INTERNAL;
288 break;
289 }
290 break;
291
292 case ACPI_TYPE_BUFFER:
293
294 status = acpi_ds_get_buffer_arguments(stack_desc);
295 break;
296
297 case ACPI_TYPE_PACKAGE:
298
299 status = acpi_ds_get_package_arguments(stack_desc);
300 break;
301
302 /* These cases may never happen here, but just in case.. */
303
304 case ACPI_TYPE_BUFFER_FIELD:
305 case ACPI_TYPE_LOCAL_REGION_FIELD:
306 case ACPI_TYPE_LOCAL_BANK_FIELD:
307 case ACPI_TYPE_LOCAL_INDEX_FIELD:
308
309 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
310 "FieldRead SourceDesc=%p Type=%X\n",
311 stack_desc,
312 ACPI_GET_OBJECT_TYPE(stack_desc)));
313
314 status =
315 acpi_ex_read_data_from_field(walk_state, stack_desc,
316 &obj_desc);
317 *stack_ptr = (void *)obj_desc;
318 break;
319
320 default:
321 break;
322 }
323
324 return_ACPI_STATUS(status);
325 }
326
327 /*******************************************************************************
328 *
329 * FUNCTION: acpi_ex_resolve_multiple
330 *
331 * PARAMETERS: walk_state - Current state (contains AML opcode)
332 * Operand - Starting point for resolution
333 * return_type - Where the object type is returned
334 * return_desc - Where the resolved object is returned
335 *
336 * RETURN: Status
337 *
338 * DESCRIPTION: Return the base object and type. Traverse a reference list if
339 * necessary to get to the base object.
340 *
341 ******************************************************************************/
342
343 acpi_status
344 acpi_ex_resolve_multiple(struct acpi_walk_state *walk_state,
345 union acpi_operand_object *operand,
346 acpi_object_type * return_type,
347 union acpi_operand_object **return_desc)
348 {
349 union acpi_operand_object *obj_desc = (void *)operand;
350 struct acpi_namespace_node *node;
351 acpi_object_type type;
352 acpi_status status;
353
354 ACPI_FUNCTION_TRACE(acpi_ex_resolve_multiple);
355
356 /* Operand can be either a namespace node or an operand descriptor */
357
358 switch (ACPI_GET_DESCRIPTOR_TYPE(obj_desc)) {
359 case ACPI_DESC_TYPE_OPERAND:
360 type = obj_desc->common.type;
361 break;
362
363 case ACPI_DESC_TYPE_NAMED:
364 type = ((struct acpi_namespace_node *)obj_desc)->type;
365 obj_desc =
366 acpi_ns_get_attached_object((struct acpi_namespace_node *)
367 obj_desc);
368
369 /* If we had an Alias node, use the attached object for type info */
370
371 if (type == ACPI_TYPE_LOCAL_ALIAS) {
372 type = ((struct acpi_namespace_node *)obj_desc)->type;
373 obj_desc =
374 acpi_ns_get_attached_object((struct
375 acpi_namespace_node *)
376 obj_desc);
377 }
378 break;
379
380 default:
381 return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
382 }
383
384 /* If type is anything other than a reference, we are done */
385
386 if (type != ACPI_TYPE_LOCAL_REFERENCE) {
387 goto exit;
388 }
389
390 /*
391 * For reference objects created via the ref_of or Index operators,
392 * we need to get to the base object (as per the ACPI specification
393 * of the object_type and size_of operators). This means traversing
394 * the list of possibly many nested references.
395 */
396 while (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_LOCAL_REFERENCE) {
397 switch (obj_desc->reference.opcode) {
398 case AML_REF_OF_OP:
399 case AML_INT_NAMEPATH_OP:
400
401 /* Dereference the reference pointer */
402
403 if (obj_desc->reference.opcode == AML_REF_OF_OP) {
404 node = obj_desc->reference.object;
405 } else { /* AML_INT_NAMEPATH_OP */
406
407 node = obj_desc->reference.node;
408 }
409
410 /* All "References" point to a NS node */
411
412 if (ACPI_GET_DESCRIPTOR_TYPE(node) !=
413 ACPI_DESC_TYPE_NAMED) {
414 ACPI_ERROR((AE_INFO, "Not a NS node %p [%s]",
415 node,
416 acpi_ut_get_descriptor_name(node)));
417 return_ACPI_STATUS(AE_AML_INTERNAL);
418 }
419
420 /* Get the attached object */
421
422 obj_desc = acpi_ns_get_attached_object(node);
423 if (!obj_desc) {
424
425 /* No object, use the NS node type */
426
427 type = acpi_ns_get_type(node);
428 goto exit;
429 }
430
431 /* Check for circular references */
432
433 if (obj_desc == operand) {
434 return_ACPI_STATUS(AE_AML_CIRCULAR_REFERENCE);
435 }
436 break;
437
438 case AML_INDEX_OP:
439
440 /* Get the type of this reference (index into another object) */
441
442 type = obj_desc->reference.target_type;
443 if (type != ACPI_TYPE_PACKAGE) {
444 goto exit;
445 }
446
447 /*
448 * The main object is a package, we want to get the type
449 * of the individual package element that is referenced by
450 * the index.
451 *
452 * This could of course in turn be another reference object.
453 */
454 obj_desc = *(obj_desc->reference.where);
455 if (!obj_desc) {
456
457 /* NULL package elements are allowed */
458
459 type = 0; /* Uninitialized */
460 goto exit;
461 }
462 break;
463
464 case AML_LOCAL_OP:
465 case AML_ARG_OP:
466
467 if (return_desc) {
468 status =
469 acpi_ds_method_data_get_value(obj_desc->
470 reference.
471 opcode,
472 obj_desc->
473 reference.
474 offset,
475 walk_state,
476 &obj_desc);
477 if (ACPI_FAILURE(status)) {
478 return_ACPI_STATUS(status);
479 }
480 acpi_ut_remove_reference(obj_desc);
481 } else {
482 status =
483 acpi_ds_method_data_get_node(obj_desc->
484 reference.
485 opcode,
486 obj_desc->
487 reference.
488 offset,
489 walk_state,
490 &node);
491 if (ACPI_FAILURE(status)) {
492 return_ACPI_STATUS(status);
493 }
494
495 obj_desc = acpi_ns_get_attached_object(node);
496 if (!obj_desc) {
497 type = ACPI_TYPE_ANY;
498 goto exit;
499 }
500 }
501 break;
502
503 case AML_DEBUG_OP:
504
505 /* The Debug Object is of type "DebugObject" */
506
507 type = ACPI_TYPE_DEBUG_OBJECT;
508 goto exit;
509
510 default:
511
512 ACPI_ERROR((AE_INFO,
513 "Unknown Reference subtype %X",
514 obj_desc->reference.opcode));
515 return_ACPI_STATUS(AE_AML_INTERNAL);
516 }
517 }
518
519 /*
520 * Now we are guaranteed to have an object that has not been created
521 * via the ref_of or Index operators.
522 */
523 type = ACPI_GET_OBJECT_TYPE(obj_desc);
524
525 exit:
526 /* Convert internal types to external types */
527
528 switch (type) {
529 case ACPI_TYPE_LOCAL_REGION_FIELD:
530 case ACPI_TYPE_LOCAL_BANK_FIELD:
531 case ACPI_TYPE_LOCAL_INDEX_FIELD:
532
533 type = ACPI_TYPE_FIELD_UNIT;
534 break;
535
536 case ACPI_TYPE_LOCAL_SCOPE:
537
538 /* Per ACPI Specification, Scope is untyped */
539
540 type = ACPI_TYPE_ANY;
541 break;
542
543 default:
544 /* No change to Type required */
545 break;
546 }
547
548 *return_type = type;
549 if (return_desc) {
550 *return_desc = obj_desc;
551 }
552 return_ACPI_STATUS(AE_OK);
553 }
Linux with added FPC-III support