Pull altix-fpga-reset into release branch
[linux-2.6] / drivers / acpi / dispatcher / dsopcode.c
1 /******************************************************************************
2  *
3  * Module Name: dsopcode - Dispatcher Op Region support and handling of
4  *                         "control" opcodes
5  *
6  *****************************************************************************/
7
8 /*
9  * Copyright (C) 2000 - 2005, 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/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 #define _COMPONENT          ACPI_DISPATCHER
54 ACPI_MODULE_NAME("dsopcode")
55
56 /* Local prototypes */
57 static acpi_status
58 acpi_ds_execute_arguments(struct acpi_namespace_node *node,
59                           struct acpi_namespace_node *scope_node,
60                           u32 aml_length, u8 * aml_start);
61
62 static acpi_status
63 acpi_ds_init_buffer_field(u16 aml_opcode,
64                           union acpi_operand_object *obj_desc,
65                           union acpi_operand_object *buffer_desc,
66                           union acpi_operand_object *offset_desc,
67                           union acpi_operand_object *length_desc,
68                           union acpi_operand_object *result_desc);
69
70 /*******************************************************************************
71  *
72  * FUNCTION:    acpi_ds_execute_arguments
73  *
74  * PARAMETERS:  Node                - Object NS node
75  *              scope_node          - Parent NS node
76  *              aml_length          - Length of executable AML
77  *              aml_start           - Pointer to the AML
78  *
79  * RETURN:      Status.
80  *
81  * DESCRIPTION: Late (deferred) execution of region or field arguments
82  *
83  ******************************************************************************/
84
85 static acpi_status
86 acpi_ds_execute_arguments(struct acpi_namespace_node *node,
87                           struct acpi_namespace_node *scope_node,
88                           u32 aml_length, u8 * aml_start)
89 {
90         acpi_status status;
91         union acpi_parse_object *op;
92         struct acpi_walk_state *walk_state;
93
94         ACPI_FUNCTION_TRACE("ds_execute_arguments");
95
96         /*
97          * Allocate a new parser op to be the root of the parsed tree
98          */
99         op = acpi_ps_alloc_op(AML_INT_EVAL_SUBTREE_OP);
100         if (!op) {
101                 return_ACPI_STATUS(AE_NO_MEMORY);
102         }
103
104         /* Save the Node for use in acpi_ps_parse_aml */
105
106         op->common.node = scope_node;
107
108         /* Create and initialize a new parser state */
109
110         walk_state = acpi_ds_create_walk_state(0, NULL, NULL, NULL);
111         if (!walk_state) {
112                 status = AE_NO_MEMORY;
113                 goto cleanup;
114         }
115
116         status = acpi_ds_init_aml_walk(walk_state, op, NULL, aml_start,
117                                        aml_length, NULL, 1);
118         if (ACPI_FAILURE(status)) {
119                 acpi_ds_delete_walk_state(walk_state);
120                 goto cleanup;
121         }
122
123         /* Mark this parse as a deferred opcode */
124
125         walk_state->parse_flags = ACPI_PARSE_DEFERRED_OP;
126         walk_state->deferred_node = node;
127
128         /* Pass1: Parse the entire declaration */
129
130         status = acpi_ps_parse_aml(walk_state);
131         if (ACPI_FAILURE(status)) {
132                 goto cleanup;
133         }
134
135         /* Get and init the Op created above */
136
137         op->common.node = node;
138         acpi_ps_delete_parse_tree(op);
139
140         /* Evaluate the deferred arguments */
141
142         op = acpi_ps_alloc_op(AML_INT_EVAL_SUBTREE_OP);
143         if (!op) {
144                 return_ACPI_STATUS(AE_NO_MEMORY);
145         }
146
147         op->common.node = scope_node;
148
149         /* Create and initialize a new parser state */
150
151         walk_state = acpi_ds_create_walk_state(0, NULL, NULL, NULL);
152         if (!walk_state) {
153                 status = AE_NO_MEMORY;
154                 goto cleanup;
155         }
156
157         /* Execute the opcode and arguments */
158
159         status = acpi_ds_init_aml_walk(walk_state, op, NULL, aml_start,
160                                        aml_length, NULL, 3);
161         if (ACPI_FAILURE(status)) {
162                 acpi_ds_delete_walk_state(walk_state);
163                 goto cleanup;
164         }
165
166         /* Mark this execution as a deferred opcode */
167
168         walk_state->deferred_node = node;
169         status = acpi_ps_parse_aml(walk_state);
170
171       cleanup:
172         acpi_ps_delete_parse_tree(op);
173         return_ACPI_STATUS(status);
174 }
175
176 /*******************************************************************************
177  *
178  * FUNCTION:    acpi_ds_get_buffer_field_arguments
179  *
180  * PARAMETERS:  obj_desc        - A valid buffer_field object
181  *
182  * RETURN:      Status.
183  *
184  * DESCRIPTION: Get buffer_field Buffer and Index. This implements the late
185  *              evaluation of these field attributes.
186  *
187  ******************************************************************************/
188
189 acpi_status
190 acpi_ds_get_buffer_field_arguments(union acpi_operand_object *obj_desc)
191 {
192         union acpi_operand_object *extra_desc;
193         struct acpi_namespace_node *node;
194         acpi_status status;
195
196         ACPI_FUNCTION_TRACE_PTR("ds_get_buffer_field_arguments", obj_desc);
197
198         if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
199                 return_ACPI_STATUS(AE_OK);
200         }
201
202         /* Get the AML pointer (method object) and buffer_field node */
203
204         extra_desc = acpi_ns_get_secondary_object(obj_desc);
205         node = obj_desc->buffer_field.node;
206
207         ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
208                         (ACPI_TYPE_BUFFER_FIELD, node, NULL));
209         ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "[%4.4s] buffer_field Arg Init\n",
210                           acpi_ut_get_node_name(node)));
211
212         /* Execute the AML code for the term_arg arguments */
213
214         status = acpi_ds_execute_arguments(node, acpi_ns_get_parent_node(node),
215                                            extra_desc->extra.aml_length,
216                                            extra_desc->extra.aml_start);
217         return_ACPI_STATUS(status);
218 }
219
220 /*******************************************************************************
221  *
222  * FUNCTION:    acpi_ds_get_buffer_arguments
223  *
224  * PARAMETERS:  obj_desc        - A valid Buffer object
225  *
226  * RETURN:      Status.
227  *
228  * DESCRIPTION: Get Buffer length and initializer byte list.  This implements
229  *              the late evaluation of these attributes.
230  *
231  ******************************************************************************/
232
233 acpi_status acpi_ds_get_buffer_arguments(union acpi_operand_object *obj_desc)
234 {
235         struct acpi_namespace_node *node;
236         acpi_status status;
237
238         ACPI_FUNCTION_TRACE_PTR("ds_get_buffer_arguments", obj_desc);
239
240         if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
241                 return_ACPI_STATUS(AE_OK);
242         }
243
244         /* Get the Buffer node */
245
246         node = obj_desc->buffer.node;
247         if (!node) {
248                 ACPI_REPORT_ERROR(("No pointer back to NS node in buffer obj %p\n", obj_desc));
249                 return_ACPI_STATUS(AE_AML_INTERNAL);
250         }
251
252         ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Buffer Arg Init\n"));
253
254         /* Execute the AML code for the term_arg arguments */
255
256         status = acpi_ds_execute_arguments(node, node,
257                                            obj_desc->buffer.aml_length,
258                                            obj_desc->buffer.aml_start);
259         return_ACPI_STATUS(status);
260 }
261
262 /*******************************************************************************
263  *
264  * FUNCTION:    acpi_ds_get_package_arguments
265  *
266  * PARAMETERS:  obj_desc        - A valid Package object
267  *
268  * RETURN:      Status.
269  *
270  * DESCRIPTION: Get Package length and initializer byte list.  This implements
271  *              the late evaluation of these attributes.
272  *
273  ******************************************************************************/
274
275 acpi_status acpi_ds_get_package_arguments(union acpi_operand_object *obj_desc)
276 {
277         struct acpi_namespace_node *node;
278         acpi_status status;
279
280         ACPI_FUNCTION_TRACE_PTR("ds_get_package_arguments", obj_desc);
281
282         if (obj_desc->common.flags & AOPOBJ_DATA_VALID) {
283                 return_ACPI_STATUS(AE_OK);
284         }
285
286         /* Get the Package node */
287
288         node = obj_desc->package.node;
289         if (!node) {
290                 ACPI_REPORT_ERROR(("No pointer back to NS node in package %p\n",
291                                    obj_desc));
292                 return_ACPI_STATUS(AE_AML_INTERNAL);
293         }
294
295         ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Package Arg Init\n"));
296
297         /* Execute the AML code for the term_arg arguments */
298
299         status = acpi_ds_execute_arguments(node, node,
300                                            obj_desc->package.aml_length,
301                                            obj_desc->package.aml_start);
302         return_ACPI_STATUS(status);
303 }
304
305 /*****************************************************************************
306  *
307  * FUNCTION:    acpi_ds_get_region_arguments
308  *
309  * PARAMETERS:  obj_desc        - A valid region object
310  *
311  * RETURN:      Status.
312  *
313  * DESCRIPTION: Get region address and length.  This implements the late
314  *              evaluation of these region attributes.
315  *
316  ****************************************************************************/
317
318 acpi_status acpi_ds_get_region_arguments(union acpi_operand_object *obj_desc)
319 {
320         struct acpi_namespace_node *node;
321         acpi_status status;
322         union acpi_operand_object *extra_desc;
323
324         ACPI_FUNCTION_TRACE_PTR("ds_get_region_arguments", obj_desc);
325
326         if (obj_desc->region.flags & AOPOBJ_DATA_VALID) {
327                 return_ACPI_STATUS(AE_OK);
328         }
329
330         extra_desc = acpi_ns_get_secondary_object(obj_desc);
331         if (!extra_desc) {
332                 return_ACPI_STATUS(AE_NOT_EXIST);
333         }
334
335         /* Get the Region node */
336
337         node = obj_desc->region.node;
338
339         ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
340                         (ACPI_TYPE_REGION, node, NULL));
341
342         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
343                           "[%4.4s] op_region Arg Init at AML %p\n",
344                           acpi_ut_get_node_name(node),
345                           extra_desc->extra.aml_start));
346
347         /* Execute the argument AML */
348
349         status = acpi_ds_execute_arguments(node, acpi_ns_get_parent_node(node),
350                                            extra_desc->extra.aml_length,
351                                            extra_desc->extra.aml_start);
352         return_ACPI_STATUS(status);
353 }
354
355 /*******************************************************************************
356  *
357  * FUNCTION:    acpi_ds_initialize_region
358  *
359  * PARAMETERS:  obj_handle      - Region namespace node
360  *
361  * RETURN:      Status
362  *
363  * DESCRIPTION: Front end to ev_initialize_region
364  *
365  ******************************************************************************/
366
367 acpi_status acpi_ds_initialize_region(acpi_handle obj_handle)
368 {
369         union acpi_operand_object *obj_desc;
370         acpi_status status;
371
372         obj_desc = acpi_ns_get_attached_object(obj_handle);
373
374         /* Namespace is NOT locked */
375
376         status = acpi_ev_initialize_region(obj_desc, FALSE);
377         return (status);
378 }
379
380 /*******************************************************************************
381  *
382  * FUNCTION:    acpi_ds_init_buffer_field
383  *
384  * PARAMETERS:  aml_opcode      - create_xxx_field
385  *              obj_desc        - buffer_field object
386  *              buffer_desc     - Host Buffer
387  *              offset_desc     - Offset into buffer
388  *              length_desc     - Length of field (CREATE_FIELD_OP only)
389  *              result_desc     - Where to store the result
390  *
391  * RETURN:      Status
392  *
393  * DESCRIPTION: Perform actual initialization of a buffer field
394  *
395  ******************************************************************************/
396
397 static acpi_status
398 acpi_ds_init_buffer_field(u16 aml_opcode,
399                           union acpi_operand_object *obj_desc,
400                           union acpi_operand_object *buffer_desc,
401                           union acpi_operand_object *offset_desc,
402                           union acpi_operand_object *length_desc,
403                           union acpi_operand_object *result_desc)
404 {
405         u32 offset;
406         u32 bit_offset;
407         u32 bit_count;
408         u8 field_flags;
409         acpi_status status;
410
411         ACPI_FUNCTION_TRACE_PTR("ds_init_buffer_field", obj_desc);
412
413         /* Host object must be a Buffer */
414
415         if (ACPI_GET_OBJECT_TYPE(buffer_desc) != ACPI_TYPE_BUFFER) {
416                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
417                                   "Target of Create Field is not a Buffer object - %s\n",
418                                   acpi_ut_get_object_type_name(buffer_desc)));
419
420                 status = AE_AML_OPERAND_TYPE;
421                 goto cleanup;
422         }
423
424         /*
425          * The last parameter to all of these opcodes (result_desc) started
426          * out as a name_string, and should therefore now be a NS node
427          * after resolution in acpi_ex_resolve_operands().
428          */
429         if (ACPI_GET_DESCRIPTOR_TYPE(result_desc) != ACPI_DESC_TYPE_NAMED) {
430                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
431                                   "(%s) destination not a NS Node [%s]\n",
432                                   acpi_ps_get_opcode_name(aml_opcode),
433                                   acpi_ut_get_descriptor_name(result_desc)));
434
435                 status = AE_AML_OPERAND_TYPE;
436                 goto cleanup;
437         }
438
439         offset = (u32) offset_desc->integer.value;
440
441         /*
442          * Setup the Bit offsets and counts, according to the opcode
443          */
444         switch (aml_opcode) {
445         case AML_CREATE_FIELD_OP:
446
447                 /* Offset is in bits, count is in bits */
448
449                 field_flags = AML_FIELD_ACCESS_BYTE;
450                 bit_offset = offset;
451                 bit_count = (u32) length_desc->integer.value;
452
453                 /* Must have a valid (>0) bit count */
454
455                 if (bit_count == 0) {
456                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
457                                           "Attempt to create_field of length 0\n"));
458                         status = AE_AML_OPERAND_VALUE;
459                         goto cleanup;
460                 }
461                 break;
462
463         case AML_CREATE_BIT_FIELD_OP:
464
465                 /* Offset is in bits, Field is one bit */
466
467                 bit_offset = offset;
468                 bit_count = 1;
469                 field_flags = AML_FIELD_ACCESS_BYTE;
470                 break;
471
472         case AML_CREATE_BYTE_FIELD_OP:
473
474                 /* Offset is in bytes, field is one byte */
475
476                 bit_offset = 8 * offset;
477                 bit_count = 8;
478                 field_flags = AML_FIELD_ACCESS_BYTE;
479                 break;
480
481         case AML_CREATE_WORD_FIELD_OP:
482
483                 /* Offset is in bytes, field is one word */
484
485                 bit_offset = 8 * offset;
486                 bit_count = 16;
487                 field_flags = AML_FIELD_ACCESS_WORD;
488                 break;
489
490         case AML_CREATE_DWORD_FIELD_OP:
491
492                 /* Offset is in bytes, field is one dword */
493
494                 bit_offset = 8 * offset;
495                 bit_count = 32;
496                 field_flags = AML_FIELD_ACCESS_DWORD;
497                 break;
498
499         case AML_CREATE_QWORD_FIELD_OP:
500
501                 /* Offset is in bytes, field is one qword */
502
503                 bit_offset = 8 * offset;
504                 bit_count = 64;
505                 field_flags = AML_FIELD_ACCESS_QWORD;
506                 break;
507
508         default:
509
510                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
511                                   "Unknown field creation opcode %02x\n",
512                                   aml_opcode));
513                 status = AE_AML_BAD_OPCODE;
514                 goto cleanup;
515         }
516
517         /* Entire field must fit within the current length of the buffer */
518
519         if ((bit_offset + bit_count) > (8 * (u32) buffer_desc->buffer.length)) {
520                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
521                                   "Field [%4.4s] size %d exceeds Buffer [%4.4s] size %d (bits)\n",
522                                   acpi_ut_get_node_name(result_desc),
523                                   bit_offset + bit_count,
524                                   acpi_ut_get_node_name(buffer_desc->buffer.
525                                                         node),
526                                   8 * (u32) buffer_desc->buffer.length));
527                 status = AE_AML_BUFFER_LIMIT;
528                 goto cleanup;
529         }
530
531         /*
532          * Initialize areas of the field object that are common to all fields
533          * For field_flags, use LOCK_RULE = 0 (NO_LOCK),
534          * UPDATE_RULE = 0 (UPDATE_PRESERVE)
535          */
536         status = acpi_ex_prep_common_field_object(obj_desc, field_flags, 0,
537                                                   bit_offset, bit_count);
538         if (ACPI_FAILURE(status)) {
539                 goto cleanup;
540         }
541
542         obj_desc->buffer_field.buffer_obj = buffer_desc;
543
544         /* Reference count for buffer_desc inherits obj_desc count */
545
546         buffer_desc->common.reference_count = (u16)
547             (buffer_desc->common.reference_count +
548              obj_desc->common.reference_count);
549
550       cleanup:
551
552         /* Always delete the operands */
553
554         acpi_ut_remove_reference(offset_desc);
555         acpi_ut_remove_reference(buffer_desc);
556
557         if (aml_opcode == AML_CREATE_FIELD_OP) {
558                 acpi_ut_remove_reference(length_desc);
559         }
560
561         /* On failure, delete the result descriptor */
562
563         if (ACPI_FAILURE(status)) {
564                 acpi_ut_remove_reference(result_desc);  /* Result descriptor */
565         } else {
566                 /* Now the address and length are valid for this buffer_field */
567
568                 obj_desc->buffer_field.flags |= AOPOBJ_DATA_VALID;
569         }
570
571         return_ACPI_STATUS(status);
572 }
573
574 /*******************************************************************************
575  *
576  * FUNCTION:    acpi_ds_eval_buffer_field_operands
577  *
578  * PARAMETERS:  walk_state      - Current walk
579  *              Op              - A valid buffer_field Op object
580  *
581  * RETURN:      Status
582  *
583  * DESCRIPTION: Get buffer_field Buffer and Index
584  *              Called from acpi_ds_exec_end_op during buffer_field parse tree walk
585  *
586  ******************************************************************************/
587
588 acpi_status
589 acpi_ds_eval_buffer_field_operands(struct acpi_walk_state *walk_state,
590                                    union acpi_parse_object *op)
591 {
592         acpi_status status;
593         union acpi_operand_object *obj_desc;
594         struct acpi_namespace_node *node;
595         union acpi_parse_object *next_op;
596
597         ACPI_FUNCTION_TRACE_PTR("ds_eval_buffer_field_operands", op);
598
599         /*
600          * This is where we evaluate the address and length fields of the
601          * create_xxx_field declaration
602          */
603         node = op->common.node;
604
605         /* next_op points to the op that holds the Buffer */
606
607         next_op = op->common.value.arg;
608
609         /* Evaluate/create the address and length operands */
610
611         status = acpi_ds_create_operands(walk_state, next_op);
612         if (ACPI_FAILURE(status)) {
613                 return_ACPI_STATUS(status);
614         }
615
616         obj_desc = acpi_ns_get_attached_object(node);
617         if (!obj_desc) {
618                 return_ACPI_STATUS(AE_NOT_EXIST);
619         }
620
621         /* Resolve the operands */
622
623         status = acpi_ex_resolve_operands(op->common.aml_opcode,
624                                           ACPI_WALK_OPERANDS, walk_state);
625
626         ACPI_DUMP_OPERANDS(ACPI_WALK_OPERANDS, ACPI_IMODE_EXECUTE,
627                            acpi_ps_get_opcode_name(op->common.aml_opcode),
628                            walk_state->num_operands,
629                            "after acpi_ex_resolve_operands");
630
631         if (ACPI_FAILURE(status)) {
632                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "(%s) bad operand(s) (%X)\n",
633                                   acpi_ps_get_opcode_name(op->common.
634                                                           aml_opcode), status));
635
636                 return_ACPI_STATUS(status);
637         }
638
639         /* Initialize the Buffer Field */
640
641         if (op->common.aml_opcode == AML_CREATE_FIELD_OP) {
642                 /* NOTE: Slightly different operands for this opcode */
643
644                 status =
645                     acpi_ds_init_buffer_field(op->common.aml_opcode, obj_desc,
646                                               walk_state->operands[0],
647                                               walk_state->operands[1],
648                                               walk_state->operands[2],
649                                               walk_state->operands[3]);
650         } else {
651                 /* All other, create_xxx_field opcodes */
652
653                 status =
654                     acpi_ds_init_buffer_field(op->common.aml_opcode, obj_desc,
655                                               walk_state->operands[0],
656                                               walk_state->operands[1], NULL,
657                                               walk_state->operands[2]);
658         }
659
660         return_ACPI_STATUS(status);
661 }
662
663 /*******************************************************************************
664  *
665  * FUNCTION:    acpi_ds_eval_region_operands
666  *
667  * PARAMETERS:  walk_state      - Current walk
668  *              Op              - A valid region Op object
669  *
670  * RETURN:      Status
671  *
672  * DESCRIPTION: Get region address and length
673  *              Called from acpi_ds_exec_end_op during op_region parse tree walk
674  *
675  ******************************************************************************/
676
677 acpi_status
678 acpi_ds_eval_region_operands(struct acpi_walk_state *walk_state,
679                              union acpi_parse_object *op)
680 {
681         acpi_status status;
682         union acpi_operand_object *obj_desc;
683         union acpi_operand_object *operand_desc;
684         struct acpi_namespace_node *node;
685         union acpi_parse_object *next_op;
686
687         ACPI_FUNCTION_TRACE_PTR("ds_eval_region_operands", op);
688
689         /*
690          * This is where we evaluate the address and length fields of the
691          * op_region declaration
692          */
693         node = op->common.node;
694
695         /* next_op points to the op that holds the space_iD */
696
697         next_op = op->common.value.arg;
698
699         /* next_op points to address op */
700
701         next_op = next_op->common.next;
702
703         /* Evaluate/create the address and length operands */
704
705         status = acpi_ds_create_operands(walk_state, next_op);
706         if (ACPI_FAILURE(status)) {
707                 return_ACPI_STATUS(status);
708         }
709
710         /* Resolve the length and address operands to numbers */
711
712         status = acpi_ex_resolve_operands(op->common.aml_opcode,
713                                           ACPI_WALK_OPERANDS, walk_state);
714         if (ACPI_FAILURE(status)) {
715                 return_ACPI_STATUS(status);
716         }
717
718         ACPI_DUMP_OPERANDS(ACPI_WALK_OPERANDS, ACPI_IMODE_EXECUTE,
719                            acpi_ps_get_opcode_name(op->common.aml_opcode),
720                            1, "after acpi_ex_resolve_operands");
721
722         obj_desc = acpi_ns_get_attached_object(node);
723         if (!obj_desc) {
724                 return_ACPI_STATUS(AE_NOT_EXIST);
725         }
726
727         /*
728          * Get the length operand and save it
729          * (at Top of stack)
730          */
731         operand_desc = walk_state->operands[walk_state->num_operands - 1];
732
733         obj_desc->region.length = (u32) operand_desc->integer.value;
734         acpi_ut_remove_reference(operand_desc);
735
736         /*
737          * Get the address and save it
738          * (at top of stack - 1)
739          */
740         operand_desc = walk_state->operands[walk_state->num_operands - 2];
741
742         obj_desc->region.address = (acpi_physical_address)
743             operand_desc->integer.value;
744         acpi_ut_remove_reference(operand_desc);
745
746         ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "rgn_obj %p Addr %8.8X%8.8X Len %X\n",
747                           obj_desc,
748                           ACPI_FORMAT_UINT64(obj_desc->region.address),
749                           obj_desc->region.length));
750
751         /* Now the address and length are valid for this opregion */
752
753         obj_desc->region.flags |= AOPOBJ_DATA_VALID;
754
755         return_ACPI_STATUS(status);
756 }
757
758 /*******************************************************************************
759  *
760  * FUNCTION:    acpi_ds_eval_data_object_operands
761  *
762  * PARAMETERS:  walk_state      - Current walk
763  *              Op              - A valid data_object Op object
764  *              obj_desc        - data_object
765  *
766  * RETURN:      Status
767  *
768  * DESCRIPTION: Get the operands and complete the following data object types:
769  *              Buffer, Package.
770  *
771  ******************************************************************************/
772
773 acpi_status
774 acpi_ds_eval_data_object_operands(struct acpi_walk_state *walk_state,
775                                   union acpi_parse_object *op,
776                                   union acpi_operand_object *obj_desc)
777 {
778         acpi_status status;
779         union acpi_operand_object *arg_desc;
780         u32 length;
781
782         ACPI_FUNCTION_TRACE("ds_eval_data_object_operands");
783
784         /* The first operand (for all of these data objects) is the length */
785
786         status = acpi_ds_create_operand(walk_state, op->common.value.arg, 1);
787         if (ACPI_FAILURE(status)) {
788                 return_ACPI_STATUS(status);
789         }
790
791         status = acpi_ex_resolve_operands(walk_state->opcode,
792                                           &(walk_state->
793                                             operands[walk_state->num_operands -
794                                                      1]), walk_state);
795         if (ACPI_FAILURE(status)) {
796                 return_ACPI_STATUS(status);
797         }
798
799         /* Extract length operand */
800
801         arg_desc = walk_state->operands[walk_state->num_operands - 1];
802         length = (u32) arg_desc->integer.value;
803
804         /* Cleanup for length operand */
805
806         status = acpi_ds_obj_stack_pop(1, walk_state);
807         if (ACPI_FAILURE(status)) {
808                 return_ACPI_STATUS(status);
809         }
810
811         acpi_ut_remove_reference(arg_desc);
812
813         /*
814          * Create the actual data object
815          */
816         switch (op->common.aml_opcode) {
817         case AML_BUFFER_OP:
818
819                 status =
820                     acpi_ds_build_internal_buffer_obj(walk_state, op, length,
821                                                       &obj_desc);
822                 break;
823
824         case AML_PACKAGE_OP:
825         case AML_VAR_PACKAGE_OP:
826
827                 status =
828                     acpi_ds_build_internal_package_obj(walk_state, op, length,
829                                                        &obj_desc);
830                 break;
831
832         default:
833                 return_ACPI_STATUS(AE_AML_BAD_OPCODE);
834         }
835
836         if (ACPI_SUCCESS(status)) {
837                 /*
838                  * Return the object in the walk_state, unless the parent is a package -
839                  * in this case, the return object will be stored in the parse tree
840                  * for the package.
841                  */
842                 if ((!op->common.parent) ||
843                     ((op->common.parent->common.aml_opcode != AML_PACKAGE_OP) &&
844                      (op->common.parent->common.aml_opcode !=
845                       AML_VAR_PACKAGE_OP)
846                      && (op->common.parent->common.aml_opcode !=
847                          AML_NAME_OP))) {
848                         walk_state->result_obj = obj_desc;
849                 }
850         }
851
852         return_ACPI_STATUS(status);
853 }
854
855 /*******************************************************************************
856  *
857  * FUNCTION:    acpi_ds_exec_begin_control_op
858  *
859  * PARAMETERS:  walk_list       - The list that owns the walk stack
860  *              Op              - The control Op
861  *
862  * RETURN:      Status
863  *
864  * DESCRIPTION: Handles all control ops encountered during control method
865  *              execution.
866  *
867  ******************************************************************************/
868
869 acpi_status
870 acpi_ds_exec_begin_control_op(struct acpi_walk_state *walk_state,
871                               union acpi_parse_object *op)
872 {
873         acpi_status status = AE_OK;
874         union acpi_generic_state *control_state;
875
876         ACPI_FUNCTION_NAME("ds_exec_begin_control_op");
877
878         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p Opcode=%2.2X State=%p\n", op,
879                           op->common.aml_opcode, walk_state));
880
881         switch (op->common.aml_opcode) {
882         case AML_IF_OP:
883         case AML_WHILE_OP:
884
885                 /*
886                  * IF/WHILE: Create a new control state to manage these
887                  * constructs. We need to manage these as a stack, in order
888                  * to handle nesting.
889                  */
890                 control_state = acpi_ut_create_control_state();
891                 if (!control_state) {
892                         status = AE_NO_MEMORY;
893                         break;
894                 }
895                 /*
896                  * Save a pointer to the predicate for multiple executions
897                  * of a loop
898                  */
899                 control_state->control.aml_predicate_start =
900                     walk_state->parser_state.aml - 1;
901                 control_state->control.package_end =
902                     walk_state->parser_state.pkg_end;
903                 control_state->control.opcode = op->common.aml_opcode;
904
905                 /* Push the control state on this walk's control stack */
906
907                 acpi_ut_push_generic_state(&walk_state->control_state,
908                                            control_state);
909                 break;
910
911         case AML_ELSE_OP:
912
913                 /* Predicate is in the state object */
914                 /* If predicate is true, the IF was executed, ignore ELSE part */
915
916                 if (walk_state->last_predicate) {
917                         status = AE_CTRL_TRUE;
918                 }
919
920                 break;
921
922         case AML_RETURN_OP:
923
924                 break;
925
926         default:
927                 break;
928         }
929
930         return (status);
931 }
932
933 /*******************************************************************************
934  *
935  * FUNCTION:    acpi_ds_exec_end_control_op
936  *
937  * PARAMETERS:  walk_list       - The list that owns the walk stack
938  *              Op              - The control Op
939  *
940  * RETURN:      Status
941  *
942  * DESCRIPTION: Handles all control ops encountered during control method
943  *              execution.
944  *
945  ******************************************************************************/
946
947 acpi_status
948 acpi_ds_exec_end_control_op(struct acpi_walk_state * walk_state,
949                             union acpi_parse_object * op)
950 {
951         acpi_status status = AE_OK;
952         union acpi_generic_state *control_state;
953
954         ACPI_FUNCTION_NAME("ds_exec_end_control_op");
955
956         switch (op->common.aml_opcode) {
957         case AML_IF_OP:
958
959                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "[IF_OP] Op=%p\n", op));
960
961                 /*
962                  * Save the result of the predicate in case there is an
963                  * ELSE to come
964                  */
965                 walk_state->last_predicate =
966                     (u8) walk_state->control_state->common.value;
967
968                 /*
969                  * Pop the control state that was created at the start
970                  * of the IF and free it
971                  */
972                 control_state =
973                     acpi_ut_pop_generic_state(&walk_state->control_state);
974                 acpi_ut_delete_generic_state(control_state);
975                 break;
976
977         case AML_ELSE_OP:
978
979                 break;
980
981         case AML_WHILE_OP:
982
983                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "[WHILE_OP] Op=%p\n", op));
984
985                 if (walk_state->control_state->common.value) {
986                         /* Predicate was true, go back and evaluate it again! */
987
988                         status = AE_CTRL_PENDING;
989                 }
990
991                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
992                                   "[WHILE_OP] termination! Op=%p\n", op));
993
994                 /* Pop this control state and free it */
995
996                 control_state =
997                     acpi_ut_pop_generic_state(&walk_state->control_state);
998
999                 walk_state->aml_last_while =
1000                     control_state->control.aml_predicate_start;
1001                 acpi_ut_delete_generic_state(control_state);
1002                 break;
1003
1004         case AML_RETURN_OP:
1005
1006                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
1007                                   "[RETURN_OP] Op=%p Arg=%p\n", op,
1008                                   op->common.value.arg));
1009
1010                 /*
1011                  * One optional operand -- the return value
1012                  * It can be either an immediate operand or a result that
1013                  * has been bubbled up the tree
1014                  */
1015                 if (op->common.value.arg) {
1016                         /* Since we have a real Return(), delete any implicit return */
1017
1018                         acpi_ds_clear_implicit_return(walk_state);
1019
1020                         /* Return statement has an immediate operand */
1021
1022                         status =
1023                             acpi_ds_create_operands(walk_state,
1024                                                     op->common.value.arg);
1025                         if (ACPI_FAILURE(status)) {
1026                                 return (status);
1027                         }
1028
1029                         /*
1030                          * If value being returned is a Reference (such as
1031                          * an arg or local), resolve it now because it may
1032                          * cease to exist at the end of the method.
1033                          */
1034                         status =
1035                             acpi_ex_resolve_to_value(&walk_state->operands[0],
1036                                                      walk_state);
1037                         if (ACPI_FAILURE(status)) {
1038                                 return (status);
1039                         }
1040
1041                         /*
1042                          * Get the return value and save as the last result
1043                          * value.  This is the only place where walk_state->return_desc
1044                          * is set to anything other than zero!
1045                          */
1046                         walk_state->return_desc = walk_state->operands[0];
1047                 } else if ((walk_state->results) &&
1048                            (walk_state->results->results.num_results > 0)) {
1049                         /* Since we have a real Return(), delete any implicit return */
1050
1051                         acpi_ds_clear_implicit_return(walk_state);
1052
1053                         /*
1054                          * The return value has come from a previous calculation.
1055                          *
1056                          * If value being returned is a Reference (such as
1057                          * an arg or local), resolve it now because it may
1058                          * cease to exist at the end of the method.
1059                          *
1060                          * Allow references created by the Index operator to return unchanged.
1061                          */
1062                         if ((ACPI_GET_DESCRIPTOR_TYPE
1063                              (walk_state->results->results.obj_desc[0]) ==
1064                              ACPI_DESC_TYPE_OPERAND)
1065                             &&
1066                             (ACPI_GET_OBJECT_TYPE
1067                              (walk_state->results->results.obj_desc[0]) ==
1068                              ACPI_TYPE_LOCAL_REFERENCE)
1069                             && ((walk_state->results->results.obj_desc[0])->
1070                                 reference.opcode != AML_INDEX_OP)) {
1071                                 status =
1072                                     acpi_ex_resolve_to_value(&walk_state->
1073                                                              results->results.
1074                                                              obj_desc[0],
1075                                                              walk_state);
1076                                 if (ACPI_FAILURE(status)) {
1077                                         return (status);
1078                                 }
1079                         }
1080
1081                         walk_state->return_desc =
1082                             walk_state->results->results.obj_desc[0];
1083                 } else {
1084                         /* No return operand */
1085
1086                         if (walk_state->num_operands) {
1087                                 acpi_ut_remove_reference(walk_state->
1088                                                          operands[0]);
1089                         }
1090
1091                         walk_state->operands[0] = NULL;
1092                         walk_state->num_operands = 0;
1093                         walk_state->return_desc = NULL;
1094                 }
1095
1096                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
1097                                   "Completed RETURN_OP State=%p, ret_val=%p\n",
1098                                   walk_state, walk_state->return_desc));
1099
1100                 /* End the control method execution right now */
1101
1102                 status = AE_CTRL_TERMINATE;
1103                 break;
1104
1105         case AML_NOOP_OP:
1106
1107                 /* Just do nothing! */
1108                 break;
1109
1110         case AML_BREAK_POINT_OP:
1111
1112                 /* Call up to the OS service layer to handle this */
1113
1114                 status =
1115                     acpi_os_signal(ACPI_SIGNAL_BREAKPOINT,
1116                                    "Executed AML Breakpoint opcode");
1117
1118                 /* If and when it returns, all done. */
1119
1120                 break;
1121
1122         case AML_BREAK_OP:
1123         case AML_CONTINUE_OP:   /* ACPI 2.0 */
1124
1125                 /* Pop and delete control states until we find a while */
1126
1127                 while (walk_state->control_state &&
1128                        (walk_state->control_state->control.opcode !=
1129                         AML_WHILE_OP)) {
1130                         control_state =
1131                             acpi_ut_pop_generic_state(&walk_state->
1132                                                       control_state);
1133                         acpi_ut_delete_generic_state(control_state);
1134                 }
1135
1136                 /* No while found? */
1137
1138                 if (!walk_state->control_state) {
1139                         return (AE_AML_NO_WHILE);
1140                 }
1141
1142                 /* Was: walk_state->aml_last_while = walk_state->control_state->Control.aml_predicate_start; */
1143
1144                 walk_state->aml_last_while =
1145                     walk_state->control_state->control.package_end;
1146
1147                 /* Return status depending on opcode */
1148
1149                 if (op->common.aml_opcode == AML_BREAK_OP) {
1150                         status = AE_CTRL_BREAK;
1151                 } else {
1152                         status = AE_CTRL_CONTINUE;
1153                 }
1154                 break;
1155
1156         default:
1157
1158                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1159                                   "Unknown control opcode=%X Op=%p\n",
1160                                   op->common.aml_opcode, op));
1161
1162                 status = AE_AML_BAD_OPCODE;
1163                 break;
1164         }
1165
1166         return (status);
1167 }