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 }
338
|
This page was automatically generated by the
LXR engine.
|