Merge branch 'battery' into release
[linux-2.6] / drivers / acpi / acpica / exfield.c
1 /******************************************************************************
2  *
3  * Module Name: exfield - ACPI AML (p-code) execution - field manipulation
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 "accommon.h"
46 #include "acdispat.h"
47 #include "acinterp.h"
48
49 #define _COMPONENT          ACPI_EXECUTER
50 ACPI_MODULE_NAME("exfield")
51
52 /*******************************************************************************
53  *
54  * FUNCTION:    acpi_ex_read_data_from_field
55  *
56  * PARAMETERS:  walk_state          - Current execution state
57  *              obj_desc            - The named field
58  *              ret_buffer_desc     - Where the return data object is stored
59  *
60  * RETURN:      Status
61  *
62  * DESCRIPTION: Read from a named field.  Returns either an Integer or a
63  *              Buffer, depending on the size of the field.
64  *
65  ******************************************************************************/
66 acpi_status
67 acpi_ex_read_data_from_field(struct acpi_walk_state *walk_state,
68                              union acpi_operand_object *obj_desc,
69                              union acpi_operand_object **ret_buffer_desc)
70 {
71         acpi_status status;
72         union acpi_operand_object *buffer_desc;
73         acpi_size length;
74         void *buffer;
75
76         ACPI_FUNCTION_TRACE_PTR(ex_read_data_from_field, obj_desc);
77
78         /* Parameter validation */
79
80         if (!obj_desc) {
81                 return_ACPI_STATUS(AE_AML_NO_OPERAND);
82         }
83         if (!ret_buffer_desc) {
84                 return_ACPI_STATUS(AE_BAD_PARAMETER);
85         }
86
87         if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) {
88                 /*
89                  * If the buffer_field arguments have not been previously evaluated,
90                  * evaluate them now and save the results.
91                  */
92                 if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
93                         status = acpi_ds_get_buffer_field_arguments(obj_desc);
94                         if (ACPI_FAILURE(status)) {
95                                 return_ACPI_STATUS(status);
96                         }
97                 }
98         } else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
99                    (obj_desc->field.region_obj->region.space_id ==
100                     ACPI_ADR_SPACE_SMBUS)) {
101                 /*
102                  * This is an SMBus read.  We must create a buffer to hold the data
103                  * and directly access the region handler.
104                  */
105                 buffer_desc =
106                     acpi_ut_create_buffer_object(ACPI_SMBUS_BUFFER_SIZE);
107                 if (!buffer_desc) {
108                         return_ACPI_STATUS(AE_NO_MEMORY);
109                 }
110
111                 /* Lock entire transaction if requested */
112
113                 acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);
114
115                 /*
116                  * Perform the read.
117                  * Note: Smbus protocol value is passed in upper 16-bits of Function
118                  */
119                 status = acpi_ex_access_region(obj_desc, 0,
120                                                ACPI_CAST_PTR(acpi_integer,
121                                                              buffer_desc->
122                                                              buffer.pointer),
123                                                ACPI_READ | (obj_desc->field.
124                                                             attribute << 16));
125                 acpi_ex_release_global_lock(obj_desc->common_field.field_flags);
126                 goto exit;
127         }
128
129         /*
130          * Allocate a buffer for the contents of the field.
131          *
132          * If the field is larger than the size of an acpi_integer, create
133          * a BUFFER to hold it.  Otherwise, use an INTEGER.  This allows
134          * the use of arithmetic operators on the returned value if the
135          * field size is equal or smaller than an Integer.
136          *
137          * Note: Field.length is in bits.
138          */
139         length =
140             (acpi_size) ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->field.bit_length);
141         if (length > acpi_gbl_integer_byte_width) {
142
143                 /* Field is too large for an Integer, create a Buffer instead */
144
145                 buffer_desc = acpi_ut_create_buffer_object(length);
146                 if (!buffer_desc) {
147                         return_ACPI_STATUS(AE_NO_MEMORY);
148                 }
149                 buffer = buffer_desc->buffer.pointer;
150         } else {
151                 /* Field will fit within an Integer (normal case) */
152
153                 buffer_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
154                 if (!buffer_desc) {
155                         return_ACPI_STATUS(AE_NO_MEMORY);
156                 }
157
158                 length = acpi_gbl_integer_byte_width;
159                 buffer_desc->integer.value = 0;
160                 buffer = &buffer_desc->integer.value;
161         }
162
163         ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
164                           "FieldRead [TO]:   Obj %p, Type %X, Buf %p, ByteLen %X\n",
165                           obj_desc, obj_desc->common.type, buffer,
166                           (u32) length));
167         ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
168                           "FieldRead [FROM]: BitLen %X, BitOff %X, ByteOff %X\n",
169                           obj_desc->common_field.bit_length,
170                           obj_desc->common_field.start_field_bit_offset,
171                           obj_desc->common_field.base_byte_offset));
172
173         /* Lock entire transaction if requested */
174
175         acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);
176
177         /* Read from the field */
178
179         status = acpi_ex_extract_from_field(obj_desc, buffer, (u32) length);
180         acpi_ex_release_global_lock(obj_desc->common_field.field_flags);
181
182       exit:
183         if (ACPI_FAILURE(status)) {
184                 acpi_ut_remove_reference(buffer_desc);
185         } else {
186                 *ret_buffer_desc = buffer_desc;
187         }
188
189         return_ACPI_STATUS(status);
190 }
191
192 /*******************************************************************************
193  *
194  * FUNCTION:    acpi_ex_write_data_to_field
195  *
196  * PARAMETERS:  source_desc         - Contains data to write
197  *              obj_desc            - The named field
198  *              result_desc         - Where the return value is returned, if any
199  *
200  * RETURN:      Status
201  *
202  * DESCRIPTION: Write to a named field
203  *
204  ******************************************************************************/
205
206 acpi_status
207 acpi_ex_write_data_to_field(union acpi_operand_object *source_desc,
208                             union acpi_operand_object *obj_desc,
209                             union acpi_operand_object **result_desc)
210 {
211         acpi_status status;
212         u32 length;
213         void *buffer;
214         union acpi_operand_object *buffer_desc;
215
216         ACPI_FUNCTION_TRACE_PTR(ex_write_data_to_field, obj_desc);
217
218         /* Parameter validation */
219
220         if (!source_desc || !obj_desc) {
221                 return_ACPI_STATUS(AE_AML_NO_OPERAND);
222         }
223
224         if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) {
225                 /*
226                  * If the buffer_field arguments have not been previously evaluated,
227                  * evaluate them now and save the results.
228                  */
229                 if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
230                         status = acpi_ds_get_buffer_field_arguments(obj_desc);
231                         if (ACPI_FAILURE(status)) {
232                                 return_ACPI_STATUS(status);
233                         }
234                 }
235         } else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
236                    (obj_desc->field.region_obj->region.space_id ==
237                     ACPI_ADR_SPACE_SMBUS)) {
238                 /*
239                  * This is an SMBus write.  We will bypass the entire field mechanism
240                  * and handoff the buffer directly to the handler.
241                  *
242                  * Source must be a buffer of sufficient size (ACPI_SMBUS_BUFFER_SIZE).
243                  */
244                 if (source_desc->common.type != ACPI_TYPE_BUFFER) {
245                         ACPI_ERROR((AE_INFO,
246                                     "SMBus write requires Buffer, found type %s",
247                                     acpi_ut_get_object_type_name(source_desc)));
248
249                         return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
250                 }
251
252                 if (source_desc->buffer.length < ACPI_SMBUS_BUFFER_SIZE) {
253                         ACPI_ERROR((AE_INFO,
254                                     "SMBus write requires Buffer of length %X, found length %X",
255                                     ACPI_SMBUS_BUFFER_SIZE,
256                                     source_desc->buffer.length));
257
258                         return_ACPI_STATUS(AE_AML_BUFFER_LIMIT);
259                 }
260
261                 buffer_desc =
262                     acpi_ut_create_buffer_object(ACPI_SMBUS_BUFFER_SIZE);
263                 if (!buffer_desc) {
264                         return_ACPI_STATUS(AE_NO_MEMORY);
265                 }
266
267                 buffer = buffer_desc->buffer.pointer;
268                 ACPI_MEMCPY(buffer, source_desc->buffer.pointer,
269                             ACPI_SMBUS_BUFFER_SIZE);
270
271                 /* Lock entire transaction if requested */
272
273                 acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);
274
275                 /*
276                  * Perform the write (returns status and perhaps data in the
277                  * same buffer)
278                  * Note: SMBus protocol type is passed in upper 16-bits of Function.
279                  */
280                 status = acpi_ex_access_region(obj_desc, 0,
281                                                (acpi_integer *) buffer,
282                                                ACPI_WRITE | (obj_desc->field.
283                                                              attribute << 16));
284                 acpi_ex_release_global_lock(obj_desc->common_field.field_flags);
285
286                 *result_desc = buffer_desc;
287                 return_ACPI_STATUS(status);
288         }
289
290         /* Get a pointer to the data to be written */
291
292         switch (source_desc->common.type) {
293         case ACPI_TYPE_INTEGER:
294                 buffer = &source_desc->integer.value;
295                 length = sizeof(source_desc->integer.value);
296                 break;
297
298         case ACPI_TYPE_BUFFER:
299                 buffer = source_desc->buffer.pointer;
300                 length = source_desc->buffer.length;
301                 break;
302
303         case ACPI_TYPE_STRING:
304                 buffer = source_desc->string.pointer;
305                 length = source_desc->string.length;
306                 break;
307
308         default:
309                 return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
310         }
311
312         ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
313                           "FieldWrite [FROM]: Obj %p (%s:%X), Buf %p, ByteLen %X\n",
314                           source_desc,
315                           acpi_ut_get_type_name(source_desc->common.type),
316                           source_desc->common.type, buffer, length));
317
318         ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
319                           "FieldWrite [TO]:   Obj %p (%s:%X), BitLen %X, BitOff %X, ByteOff %X\n",
320                           obj_desc,
321                           acpi_ut_get_type_name(obj_desc->common.type),
322                           obj_desc->common.type,
323                           obj_desc->common_field.bit_length,
324                           obj_desc->common_field.start_field_bit_offset,
325                           obj_desc->common_field.base_byte_offset));
326
327         /* Lock entire transaction if requested */
328
329         acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);
330
331         /* Write to the field */
332
333         status = acpi_ex_insert_into_field(obj_desc, buffer, length);
334         acpi_ex_release_global_lock(obj_desc->common_field.field_flags);
335
336         return_ACPI_STATUS(status);
337 }