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