Merge branch 'fb' into devel
[linux-2.6] / drivers / acpi / dispatcher / dsfield.c
1 /******************************************************************************
2  *
3  * Module Name: dsfield - Dispatcher field routines
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2008, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43
44 #include <acpi/acpi.h>
45 #include <acpi/amlcode.h>
46 #include <acpi/acdispat.h>
47 #include <acpi/acinterp.h>
48 #include <acpi/acnamesp.h>
49 #include <acpi/acparser.h>
50
51 #define _COMPONENT          ACPI_DISPATCHER
52 ACPI_MODULE_NAME("dsfield")
53
54 /* Local prototypes */
55 static acpi_status
56 acpi_ds_get_field_names(struct acpi_create_field_info *info,
57                         struct acpi_walk_state *walk_state,
58                         union acpi_parse_object *arg);
59
60 /*******************************************************************************
61  *
62  * FUNCTION:    acpi_ds_create_buffer_field
63  *
64  * PARAMETERS:  Op                  - Current parse op (create_xXField)
65  *              walk_state          - Current state
66  *
67  * RETURN:      Status
68  *
69  * DESCRIPTION: Execute the create_field operators:
70  *              create_bit_field_op,
71  *              create_byte_field_op,
72  *              create_word_field_op,
73  *              create_dword_field_op,
74  *              create_qword_field_op,
75  *              create_field_op     (all of which define a field in a buffer)
76  *
77  ******************************************************************************/
78
79 acpi_status
80 acpi_ds_create_buffer_field(union acpi_parse_object *op,
81                             struct acpi_walk_state *walk_state)
82 {
83         union acpi_parse_object *arg;
84         struct acpi_namespace_node *node;
85         acpi_status status;
86         union acpi_operand_object *obj_desc;
87         union acpi_operand_object *second_desc = NULL;
88         u32 flags;
89
90         ACPI_FUNCTION_TRACE(ds_create_buffer_field);
91
92         /*
93          * Get the name_string argument (name of the new buffer_field)
94          */
95         if (op->common.aml_opcode == AML_CREATE_FIELD_OP) {
96
97                 /* For create_field, name is the 4th argument */
98
99                 arg = acpi_ps_get_arg(op, 3);
100         } else {
101                 /* For all other create_xXXField operators, name is the 3rd argument */
102
103                 arg = acpi_ps_get_arg(op, 2);
104         }
105
106         if (!arg) {
107                 return_ACPI_STATUS(AE_AML_NO_OPERAND);
108         }
109
110         if (walk_state->deferred_node) {
111                 node = walk_state->deferred_node;
112                 status = AE_OK;
113         } else {
114                 /* Execute flag should always be set when this function is entered */
115
116                 if (!(walk_state->parse_flags & ACPI_PARSE_EXECUTE)) {
117                         return_ACPI_STATUS(AE_AML_INTERNAL);
118                 }
119
120                 /* Creating new namespace node, should not already exist */
121
122                 flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
123                     ACPI_NS_ERROR_IF_FOUND;
124
125                 /* Mark node temporary if we are executing a method */
126
127                 if (walk_state->method_node) {
128                         flags |= ACPI_NS_TEMPORARY;
129                 }
130
131                 /* Enter the name_string into the namespace */
132
133                 status =
134                     acpi_ns_lookup(walk_state->scope_info,
135                                    arg->common.value.string, ACPI_TYPE_ANY,
136                                    ACPI_IMODE_LOAD_PASS1, flags, walk_state,
137                                    &node);
138                 if (ACPI_FAILURE(status)) {
139                         ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
140                         return_ACPI_STATUS(status);
141                 }
142         }
143
144         /*
145          * We could put the returned object (Node) on the object stack for later,
146          * but for now, we will put it in the "op" object that the parser uses,
147          * so we can get it again at the end of this scope.
148          */
149         op->common.node = node;
150
151         /*
152          * If there is no object attached to the node, this node was just created
153          * and we need to create the field object. Otherwise, this was a lookup
154          * of an existing node and we don't want to create the field object again.
155          */
156         obj_desc = acpi_ns_get_attached_object(node);
157         if (obj_desc) {
158                 return_ACPI_STATUS(AE_OK);
159         }
160
161         /*
162          * The Field definition is not fully parsed at this time.
163          * (We must save the address of the AML for the buffer and index operands)
164          */
165
166         /* Create the buffer field object */
167
168         obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER_FIELD);
169         if (!obj_desc) {
170                 status = AE_NO_MEMORY;
171                 goto cleanup;
172         }
173
174         /*
175          * Remember location in AML stream of the field unit opcode and operands --
176          * since the buffer and index operands must be evaluated.
177          */
178         second_desc = obj_desc->common.next_object;
179         second_desc->extra.aml_start = op->named.data;
180         second_desc->extra.aml_length = op->named.length;
181         obj_desc->buffer_field.node = node;
182
183         /* Attach constructed field descriptors to parent node */
184
185         status = acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_BUFFER_FIELD);
186         if (ACPI_FAILURE(status)) {
187                 goto cleanup;
188         }
189
190       cleanup:
191
192         /* Remove local reference to the object */
193
194         acpi_ut_remove_reference(obj_desc);
195         return_ACPI_STATUS(status);
196 }
197
198 /*******************************************************************************
199  *
200  * FUNCTION:    acpi_ds_get_field_names
201  *
202  * PARAMETERS:  Info            - create_field info structure
203  *  `           walk_state      - Current method state
204  *              Arg             - First parser arg for the field name list
205  *
206  * RETURN:      Status
207  *
208  * DESCRIPTION: Process all named fields in a field declaration.  Names are
209  *              entered into the namespace.
210  *
211  ******************************************************************************/
212
213 static acpi_status
214 acpi_ds_get_field_names(struct acpi_create_field_info *info,
215                         struct acpi_walk_state *walk_state,
216                         union acpi_parse_object *arg)
217 {
218         acpi_status status;
219         acpi_integer position;
220
221         ACPI_FUNCTION_TRACE_PTR(ds_get_field_names, info);
222
223         /* First field starts at bit zero */
224
225         info->field_bit_position = 0;
226
227         /* Process all elements in the field list (of parse nodes) */
228
229         while (arg) {
230                 /*
231                  * Three types of field elements are handled:
232                  * 1) Offset - specifies a bit offset
233                  * 2) access_as - changes the access mode
234                  * 3) Name - Enters a new named field into the namespace
235                  */
236                 switch (arg->common.aml_opcode) {
237                 case AML_INT_RESERVEDFIELD_OP:
238
239                         position = (acpi_integer) info->field_bit_position
240                             + (acpi_integer) arg->common.value.size;
241
242                         if (position > ACPI_UINT32_MAX) {
243                                 ACPI_ERROR((AE_INFO,
244                                             "Bit offset within field too large (> 0xFFFFFFFF)"));
245                                 return_ACPI_STATUS(AE_SUPPORT);
246                         }
247
248                         info->field_bit_position = (u32) position;
249                         break;
250
251                 case AML_INT_ACCESSFIELD_OP:
252
253                         /*
254                          * Get a new access_type and access_attribute -- to be used for all
255                          * field units that follow, until field end or another access_as
256                          * keyword.
257                          *
258                          * In field_flags, preserve the flag bits other than the
259                          * ACCESS_TYPE bits
260                          */
261                         info->field_flags = (u8)
262                             ((info->
263                               field_flags & ~(AML_FIELD_ACCESS_TYPE_MASK)) |
264                              ((u8) ((u32) arg->common.value.integer >> 8)));
265
266                         info->attribute = (u8) (arg->common.value.integer);
267                         break;
268
269                 case AML_INT_NAMEDFIELD_OP:
270
271                         /* Lookup the name, it should already exist */
272
273                         status = acpi_ns_lookup(walk_state->scope_info,
274                                                 (char *)&arg->named.name,
275                                                 info->field_type,
276                                                 ACPI_IMODE_EXECUTE,
277                                                 ACPI_NS_DONT_OPEN_SCOPE,
278                                                 walk_state, &info->field_node);
279                         if (ACPI_FAILURE(status)) {
280                                 ACPI_ERROR_NAMESPACE((char *)&arg->named.name,
281                                                      status);
282                                 return_ACPI_STATUS(status);
283                         } else {
284                                 arg->common.node = info->field_node;
285                                 info->field_bit_length = arg->common.value.size;
286
287                                 /*
288                                  * If there is no object attached to the node, this node was
289                                  * just created and we need to create the field object.
290                                  * Otherwise, this was a lookup of an existing node and we
291                                  * don't want to create the field object again.
292                                  */
293                                 if (!acpi_ns_get_attached_object
294                                     (info->field_node)) {
295                                         status = acpi_ex_prep_field_value(info);
296                                         if (ACPI_FAILURE(status)) {
297                                                 return_ACPI_STATUS(status);
298                                         }
299                                 }
300                         }
301
302                         /* Keep track of bit position for the next field */
303
304                         position = (acpi_integer) info->field_bit_position
305                             + (acpi_integer) arg->common.value.size;
306
307                         if (position > ACPI_UINT32_MAX) {
308                                 ACPI_ERROR((AE_INFO,
309                                             "Field [%4.4s] bit offset too large (> 0xFFFFFFFF)",
310                                             ACPI_CAST_PTR(char,
311                                                           &info->field_node->
312                                                           name)));
313                                 return_ACPI_STATUS(AE_SUPPORT);
314                         }
315
316                         info->field_bit_position += info->field_bit_length;
317                         break;
318
319                 default:
320
321                         ACPI_ERROR((AE_INFO,
322                                     "Invalid opcode in field list: %X",
323                                     arg->common.aml_opcode));
324                         return_ACPI_STATUS(AE_AML_BAD_OPCODE);
325                 }
326
327                 arg = arg->common.next;
328         }
329
330         return_ACPI_STATUS(AE_OK);
331 }
332
333 /*******************************************************************************
334  *
335  * FUNCTION:    acpi_ds_create_field
336  *
337  * PARAMETERS:  Op              - Op containing the Field definition and args
338  *              region_node     - Object for the containing Operation Region
339  *  `           walk_state      - Current method state
340  *
341  * RETURN:      Status
342  *
343  * DESCRIPTION: Create a new field in the specified operation region
344  *
345  ******************************************************************************/
346
347 acpi_status
348 acpi_ds_create_field(union acpi_parse_object *op,
349                      struct acpi_namespace_node *region_node,
350                      struct acpi_walk_state *walk_state)
351 {
352         acpi_status status;
353         union acpi_parse_object *arg;
354         struct acpi_create_field_info info;
355
356         ACPI_FUNCTION_TRACE_PTR(ds_create_field, op);
357
358         /* First arg is the name of the parent op_region (must already exist) */
359
360         arg = op->common.value.arg;
361         if (!region_node) {
362                 status =
363                     acpi_ns_lookup(walk_state->scope_info,
364                                    arg->common.value.name, ACPI_TYPE_REGION,
365                                    ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
366                                    walk_state, &region_node);
367                 if (ACPI_FAILURE(status)) {
368                         ACPI_ERROR_NAMESPACE(arg->common.value.name, status);
369                         return_ACPI_STATUS(status);
370                 }
371         }
372
373         /* Second arg is the field flags */
374
375         arg = arg->common.next;
376         info.field_flags = (u8) arg->common.value.integer;
377         info.attribute = 0;
378
379         /* Each remaining arg is a Named Field */
380
381         info.field_type = ACPI_TYPE_LOCAL_REGION_FIELD;
382         info.region_node = region_node;
383
384         status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
385
386         return_ACPI_STATUS(status);
387 }
388
389 /*******************************************************************************
390  *
391  * FUNCTION:    acpi_ds_init_field_objects
392  *
393  * PARAMETERS:  Op              - Op containing the Field definition and args
394  *  `           walk_state      - Current method state
395  *
396  * RETURN:      Status
397  *
398  * DESCRIPTION: For each "Field Unit" name in the argument list that is
399  *              part of the field declaration, enter the name into the
400  *              namespace.
401  *
402  ******************************************************************************/
403
404 acpi_status
405 acpi_ds_init_field_objects(union acpi_parse_object *op,
406                            struct acpi_walk_state *walk_state)
407 {
408         acpi_status status;
409         union acpi_parse_object *arg = NULL;
410         struct acpi_namespace_node *node;
411         u8 type = 0;
412         u32 flags;
413
414         ACPI_FUNCTION_TRACE_PTR(ds_init_field_objects, op);
415
416         /* Execute flag should always be set when this function is entered */
417
418         if (!(walk_state->parse_flags & ACPI_PARSE_EXECUTE)) {
419                 if (walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP) {
420
421                         /* bank_field Op is deferred, just return OK */
422
423                         return_ACPI_STATUS(AE_OK);
424                 }
425
426                 return_ACPI_STATUS(AE_AML_INTERNAL);
427         }
428
429         /*
430          * Get the field_list argument for this opcode. This is the start of the
431          * list of field elements.
432          */
433         switch (walk_state->opcode) {
434         case AML_FIELD_OP:
435                 arg = acpi_ps_get_arg(op, 2);
436                 type = ACPI_TYPE_LOCAL_REGION_FIELD;
437                 break;
438
439         case AML_BANK_FIELD_OP:
440                 arg = acpi_ps_get_arg(op, 4);
441                 type = ACPI_TYPE_LOCAL_BANK_FIELD;
442                 break;
443
444         case AML_INDEX_FIELD_OP:
445                 arg = acpi_ps_get_arg(op, 3);
446                 type = ACPI_TYPE_LOCAL_INDEX_FIELD;
447                 break;
448
449         default:
450                 return_ACPI_STATUS(AE_BAD_PARAMETER);
451         }
452
453         /* Creating new namespace node(s), should not already exist */
454
455         flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
456             ACPI_NS_ERROR_IF_FOUND;
457
458         /* Mark node(s) temporary if we are executing a method */
459
460         if (walk_state->method_node) {
461                 flags |= ACPI_NS_TEMPORARY;
462         }
463
464         /*
465          * Walk the list of entries in the field_list
466          * Note: field_list can be of zero length. In this case, Arg will be NULL.
467          */
468         while (arg) {
469                 /*
470                  * Ignore OFFSET and ACCESSAS terms here; we are only interested in the
471                  * field names in order to enter them into the namespace.
472                  */
473                 if (arg->common.aml_opcode == AML_INT_NAMEDFIELD_OP) {
474                         status = acpi_ns_lookup(walk_state->scope_info,
475                                                 (char *)&arg->named.name, type,
476                                                 ACPI_IMODE_LOAD_PASS1, flags,
477                                                 walk_state, &node);
478                         if (ACPI_FAILURE(status)) {
479                                 ACPI_ERROR_NAMESPACE((char *)&arg->named.name,
480                                                      status);
481                                 if (status != AE_ALREADY_EXISTS) {
482                                         return_ACPI_STATUS(status);
483                                 }
484
485                                 /* Name already exists, just ignore this error */
486
487                                 status = AE_OK;
488                         }
489
490                         arg->common.node = node;
491                 }
492
493                 /* Get the next field element in the list */
494
495                 arg = arg->common.next;
496         }
497
498         return_ACPI_STATUS(AE_OK);
499 }
500
501 /*******************************************************************************
502  *
503  * FUNCTION:    acpi_ds_create_bank_field
504  *
505  * PARAMETERS:  Op              - Op containing the Field definition and args
506  *              region_node     - Object for the containing Operation Region
507  *              walk_state      - Current method state
508  *
509  * RETURN:      Status
510  *
511  * DESCRIPTION: Create a new bank field in the specified operation region
512  *
513  ******************************************************************************/
514
515 acpi_status
516 acpi_ds_create_bank_field(union acpi_parse_object *op,
517                           struct acpi_namespace_node *region_node,
518                           struct acpi_walk_state *walk_state)
519 {
520         acpi_status status;
521         union acpi_parse_object *arg;
522         struct acpi_create_field_info info;
523
524         ACPI_FUNCTION_TRACE_PTR(ds_create_bank_field, op);
525
526         /* First arg is the name of the parent op_region (must already exist) */
527
528         arg = op->common.value.arg;
529         if (!region_node) {
530                 status =
531                     acpi_ns_lookup(walk_state->scope_info,
532                                    arg->common.value.name, ACPI_TYPE_REGION,
533                                    ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
534                                    walk_state, &region_node);
535                 if (ACPI_FAILURE(status)) {
536                         ACPI_ERROR_NAMESPACE(arg->common.value.name, status);
537                         return_ACPI_STATUS(status);
538                 }
539         }
540
541         /* Second arg is the Bank Register (Field) (must already exist) */
542
543         arg = arg->common.next;
544         status =
545             acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
546                            ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
547                            ACPI_NS_SEARCH_PARENT, walk_state,
548                            &info.register_node);
549         if (ACPI_FAILURE(status)) {
550                 ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
551                 return_ACPI_STATUS(status);
552         }
553
554         /*
555          * Third arg is the bank_value
556          * This arg is a term_arg, not a constant
557          * It will be evaluated later, by acpi_ds_eval_bank_field_operands
558          */
559         arg = arg->common.next;
560
561         /* Fourth arg is the field flags */
562
563         arg = arg->common.next;
564         info.field_flags = (u8) arg->common.value.integer;
565
566         /* Each remaining arg is a Named Field */
567
568         info.field_type = ACPI_TYPE_LOCAL_BANK_FIELD;
569         info.region_node = region_node;
570
571         /*
572          * Use Info.data_register_node to store bank_field Op
573          * It's safe because data_register_node will never be used when create bank field
574          * We store aml_start and aml_length in the bank_field Op for late evaluation
575          * Used in acpi_ex_prep_field_value(Info)
576          *
577          * TBD: Or, should we add a field in struct acpi_create_field_info, like "void *ParentOp"?
578          */
579         info.data_register_node = (struct acpi_namespace_node *)op;
580
581         status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
582         return_ACPI_STATUS(status);
583 }
584
585 /*******************************************************************************
586  *
587  * FUNCTION:    acpi_ds_create_index_field
588  *
589  * PARAMETERS:  Op              - Op containing the Field definition and args
590  *              region_node     - Object for the containing Operation Region
591  *  `           walk_state      - Current method state
592  *
593  * RETURN:      Status
594  *
595  * DESCRIPTION: Create a new index field in the specified operation region
596  *
597  ******************************************************************************/
598
599 acpi_status
600 acpi_ds_create_index_field(union acpi_parse_object *op,
601                            struct acpi_namespace_node *region_node,
602                            struct acpi_walk_state *walk_state)
603 {
604         acpi_status status;
605         union acpi_parse_object *arg;
606         struct acpi_create_field_info info;
607
608         ACPI_FUNCTION_TRACE_PTR(ds_create_index_field, op);
609
610         /* First arg is the name of the Index register (must already exist) */
611
612         arg = op->common.value.arg;
613         status =
614             acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
615                            ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
616                            ACPI_NS_SEARCH_PARENT, walk_state,
617                            &info.register_node);
618         if (ACPI_FAILURE(status)) {
619                 ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
620                 return_ACPI_STATUS(status);
621         }
622
623         /* Second arg is the data register (must already exist) */
624
625         arg = arg->common.next;
626         status =
627             acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
628                            ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
629                            ACPI_NS_SEARCH_PARENT, walk_state,
630                            &info.data_register_node);
631         if (ACPI_FAILURE(status)) {
632                 ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
633                 return_ACPI_STATUS(status);
634         }
635
636         /* Next arg is the field flags */
637
638         arg = arg->common.next;
639         info.field_flags = (u8) arg->common.value.integer;
640
641         /* Each remaining arg is a Named Field */
642
643         info.field_type = ACPI_TYPE_LOCAL_INDEX_FIELD;
644         info.region_node = region_node;
645
646         status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
647
648         return_ACPI_STATUS(status);
649 }