blob: ae402949c357db76a40a3a7077c1fbd222b7d223 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/******************************************************************************
2 *
3 * Module Name: exfldio - Aml Field I/O
4 *
5 *****************************************************************************/
6
7/*
Bob Moore6c9deb72007-02-02 19:48:24 +03008 * Copyright (C) 2000 - 2007, R. Byron Moore
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <acpi/acpi.h>
45#include <acpi/acinterp.h>
46#include <acpi/amlcode.h>
47#include <acpi/acevents.h>
48#include <acpi/acdispat.h>
49
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#define _COMPONENT ACPI_EXECUTER
Len Brown4be44fc2005-08-05 00:44:28 -040051ACPI_MODULE_NAME("exfldio")
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
Robert Moore44f6c012005-04-18 22:49:35 -040053/* Local prototypes */
Robert Moore44f6c012005-04-18 22:49:35 -040054static acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -040055acpi_ex_field_datum_io(union acpi_operand_object *obj_desc,
56 u32 field_datum_byte_offset,
57 acpi_integer * value, u32 read_write);
Robert Moore44f6c012005-04-18 22:49:35 -040058
59static u8
Len Brown4be44fc2005-08-05 00:44:28 -040060acpi_ex_register_overflow(union acpi_operand_object *obj_desc,
61 acpi_integer value);
Robert Moore44f6c012005-04-18 22:49:35 -040062
63static acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -040064acpi_ex_setup_region(union acpi_operand_object *obj_desc,
65 u32 field_datum_byte_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
67/*******************************************************************************
68 *
69 * FUNCTION: acpi_ex_setup_region
70 *
Robert Moore44f6c012005-04-18 22:49:35 -040071 * PARAMETERS: obj_desc - Field to be read or written
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 * field_datum_byte_offset - Byte offset of this datum within the
73 * parent field
74 *
75 * RETURN: Status
76 *
77 * DESCRIPTION: Common processing for acpi_ex_extract_from_field and
78 * acpi_ex_insert_into_field. Initialize the Region if necessary and
79 * validate the request.
80 *
81 ******************************************************************************/
82
Robert Moore44f6c012005-04-18 22:49:35 -040083static acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -040084acpi_ex_setup_region(union acpi_operand_object *obj_desc,
85 u32 field_datum_byte_offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -070086{
Len Brown4be44fc2005-08-05 00:44:28 -040087 acpi_status status = AE_OK;
88 union acpi_operand_object *rgn_desc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Bob Mooreb229cf92006-04-21 17:15:00 -040090 ACPI_FUNCTION_TRACE_U32(ex_setup_region, field_datum_byte_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92 rgn_desc = obj_desc->common_field.region_obj;
93
94 /* We must have a valid region */
95
Len Brown4be44fc2005-08-05 00:44:28 -040096 if (ACPI_GET_OBJECT_TYPE(rgn_desc) != ACPI_TYPE_REGION) {
Bob Mooreb8e4d892006-01-27 16:43:00 -050097 ACPI_ERROR((AE_INFO, "Needed Region, found type %X (%s)",
98 ACPI_GET_OBJECT_TYPE(rgn_desc),
99 acpi_ut_get_object_type_name(rgn_desc)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Len Brown4be44fc2005-08-05 00:44:28 -0400101 return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 }
103
104 /*
105 * If the Region Address and Length have not been previously evaluated,
106 * evaluate them now and save the results.
107 */
108 if (!(rgn_desc->common.flags & AOPOBJ_DATA_VALID)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400109 status = acpi_ds_get_region_arguments(rgn_desc);
110 if (ACPI_FAILURE(status)) {
111 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 }
113 }
114
Bob Mooreb229cf92006-04-21 17:15:00 -0400115 /* Exit if Address/Length have been disallowed by the host OS */
116
117 if (rgn_desc->common.flags & AOPOBJ_INVALID) {
118 return_ACPI_STATUS(AE_AML_ILLEGAL_ADDRESS);
119 }
120
121 /*
122 * Exit now for SMBus address space, it has a non-linear address space
123 * and the request cannot be directly validated
124 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 if (rgn_desc->region.space_id == ACPI_ADR_SPACE_SMBUS) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 /* SMBus has a non-linear address space */
128
Len Brown4be44fc2005-08-05 00:44:28 -0400129 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131#ifdef ACPI_UNDER_DEVELOPMENT
132 /*
133 * If the Field access is any_acc, we can now compute the optimal
134 * access (because we know know the length of the parent region)
135 */
136 if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400137 if (ACPI_FAILURE(status)) {
138 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 }
140 }
141#endif
142
143 /*
144 * Validate the request. The entire request from the byte offset for a
145 * length of one field datum (access width) must fit within the region.
146 * (Region length is specified in bytes)
147 */
Bob Moore41195322006-05-26 16:36:00 -0400148 if (rgn_desc->region.length <
149 (obj_desc->common_field.base_byte_offset +
150 field_datum_byte_offset +
151 obj_desc->common_field.access_byte_width)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 if (acpi_gbl_enable_interpreter_slack) {
153 /*
154 * Slack mode only: We will go ahead and allow access to this
155 * field if it is within the region length rounded up to the next
156 * access width boundary.
157 */
Len Brown4be44fc2005-08-05 00:44:28 -0400158 if (ACPI_ROUND_UP(rgn_desc->region.length,
159 obj_desc->common_field.
160 access_byte_width) >=
161 (obj_desc->common_field.base_byte_offset +
162 (acpi_native_uint) obj_desc->common_field.
163 access_byte_width + field_datum_byte_offset)) {
164 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 }
166 }
167
Len Brown4be44fc2005-08-05 00:44:28 -0400168 if (rgn_desc->region.length <
169 obj_desc->common_field.access_byte_width) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 /*
171 * This is the case where the access_type (acc_word, etc.) is wider
172 * than the region itself. For example, a region of length one
173 * byte, and a field with Dword access specified.
174 */
Bob Mooreb8e4d892006-01-27 16:43:00 -0500175 ACPI_ERROR((AE_INFO,
176 "Field [%4.4s] access width (%d bytes) too large for region [%4.4s] (length %X)",
177 acpi_ut_get_node_name(obj_desc->
178 common_field.node),
179 obj_desc->common_field.access_byte_width,
180 acpi_ut_get_node_name(rgn_desc->region.
181 node),
182 rgn_desc->region.length));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 }
184
185 /*
186 * Offset rounded up to next multiple of field width
187 * exceeds region length, indicate an error
188 */
Bob Mooreb8e4d892006-01-27 16:43:00 -0500189 ACPI_ERROR((AE_INFO,
190 "Field [%4.4s] Base+Offset+Width %X+%X+%X is beyond end of region [%4.4s] (length %X)",
191 acpi_ut_get_node_name(obj_desc->common_field.node),
192 obj_desc->common_field.base_byte_offset,
193 field_datum_byte_offset,
194 obj_desc->common_field.access_byte_width,
195 acpi_ut_get_node_name(rgn_desc->region.node),
196 rgn_desc->region.length));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
Len Brown4be44fc2005-08-05 00:44:28 -0400198 return_ACPI_STATUS(AE_AML_REGION_LIMIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 }
200
Len Brown4be44fc2005-08-05 00:44:28 -0400201 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202}
203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204/*******************************************************************************
205 *
206 * FUNCTION: acpi_ex_access_region
207 *
Robert Moore44f6c012005-04-18 22:49:35 -0400208 * PARAMETERS: obj_desc - Field to be read
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 * field_datum_byte_offset - Byte offset of this datum within the
210 * parent field
Robert Moore44f6c012005-04-18 22:49:35 -0400211 * Value - Where to store value (must at least
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 * the size of acpi_integer)
213 * Function - Read or Write flag plus other region-
214 * dependent flags
215 *
216 * RETURN: Status
217 *
218 * DESCRIPTION: Read or Write a single field datum to an Operation Region.
219 *
220 ******************************************************************************/
221
222acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400223acpi_ex_access_region(union acpi_operand_object *obj_desc,
224 u32 field_datum_byte_offset,
225 acpi_integer * value, u32 function)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226{
Len Brown4be44fc2005-08-05 00:44:28 -0400227 acpi_status status;
228 union acpi_operand_object *rgn_desc;
229 acpi_physical_address address;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Bob Mooreb229cf92006-04-21 17:15:00 -0400231 ACPI_FUNCTION_TRACE(ex_access_region);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
233 /*
234 * Ensure that the region operands are fully evaluated and verify
235 * the validity of the request
236 */
Len Brown4be44fc2005-08-05 00:44:28 -0400237 status = acpi_ex_setup_region(obj_desc, field_datum_byte_offset);
238 if (ACPI_FAILURE(status)) {
239 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 }
241
242 /*
243 * The physical address of this field datum is:
244 *
245 * 1) The base of the region, plus
246 * 2) The base offset of the field, plus
247 * 3) The current offset into the field
248 */
249 rgn_desc = obj_desc->common_field.region_obj;
Robert Moore44f6c012005-04-18 22:49:35 -0400250 address = rgn_desc->region.address +
Len Brown4be44fc2005-08-05 00:44:28 -0400251 obj_desc->common_field.base_byte_offset + field_datum_byte_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 if ((function & ACPI_IO_MASK) == ACPI_READ) {
Len Brown4be44fc2005-08-05 00:44:28 -0400254 ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, "[READ]"));
255 } else {
256 ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, "[WRITE]"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
258
Len Brown4be44fc2005-08-05 00:44:28 -0400259 ACPI_DEBUG_PRINT_RAW((ACPI_DB_BFIELD,
Bob Mooref3d2e782007-02-02 19:48:18 +0300260 " Region [%s:%X], Width %X, ByteBase %X, Offset %X at %p\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400261 acpi_ut_get_region_name(rgn_desc->region.
262 space_id),
263 rgn_desc->region.space_id,
264 obj_desc->common_field.access_byte_width,
265 obj_desc->common_field.base_byte_offset,
Bob Mooreb7f9f042008-04-10 19:06:40 +0400266 field_datum_byte_offset, ACPI_CAST_PTR(void,
267 address)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268
269 /* Invoke the appropriate address_space/op_region handler */
270
Len Brown4be44fc2005-08-05 00:44:28 -0400271 status = acpi_ev_address_space_dispatch(rgn_desc, function,
272 address,
273 ACPI_MUL_8(obj_desc->
274 common_field.
275 access_byte_width),
276 value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
Len Brown4be44fc2005-08-05 00:44:28 -0400278 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 if (status == AE_NOT_IMPLEMENTED) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500280 ACPI_ERROR((AE_INFO,
281 "Region %s(%X) not implemented",
282 acpi_ut_get_region_name(rgn_desc->region.
283 space_id),
284 rgn_desc->region.space_id));
Len Brown4be44fc2005-08-05 00:44:28 -0400285 } else if (status == AE_NOT_EXIST) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500286 ACPI_ERROR((AE_INFO,
287 "Region %s(%X) has no handler",
288 acpi_ut_get_region_name(rgn_desc->region.
289 space_id),
290 rgn_desc->region.space_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 }
292 }
293
Len Brown4be44fc2005-08-05 00:44:28 -0400294 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295}
296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297/*******************************************************************************
298 *
299 * FUNCTION: acpi_ex_register_overflow
300 *
Robert Moore44f6c012005-04-18 22:49:35 -0400301 * PARAMETERS: obj_desc - Register(Field) to be written
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 * Value - Value to be stored
303 *
304 * RETURN: TRUE if value overflows the field, FALSE otherwise
305 *
306 * DESCRIPTION: Check if a value is out of range of the field being written.
307 * Used to check if the values written to Index and Bank registers
308 * are out of range. Normally, the value is simply truncated
309 * to fit the field, but this case is most likely a serious
310 * coding error in the ASL.
311 *
312 ******************************************************************************/
313
Robert Moore44f6c012005-04-18 22:49:35 -0400314static u8
Len Brown4be44fc2005-08-05 00:44:28 -0400315acpi_ex_register_overflow(union acpi_operand_object *obj_desc,
316 acpi_integer value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317{
318
319 if (obj_desc->common_field.bit_length >= ACPI_INTEGER_BIT_SIZE) {
320 /*
321 * The field is large enough to hold the maximum integer, so we can
322 * never overflow it.
323 */
324 return (FALSE);
325 }
326
327 if (value >= ((acpi_integer) 1 << obj_desc->common_field.bit_length)) {
328 /*
329 * The Value is larger than the maximum value that can fit into
330 * the register.
331 */
332 return (TRUE);
333 }
334
335 /* The Value will fit into the field with no truncation */
336
337 return (FALSE);
338}
339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340/*******************************************************************************
341 *
342 * FUNCTION: acpi_ex_field_datum_io
343 *
Robert Moore44f6c012005-04-18 22:49:35 -0400344 * PARAMETERS: obj_desc - Field to be read
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 * field_datum_byte_offset - Byte offset of this datum within the
346 * parent field
Robert Moore44f6c012005-04-18 22:49:35 -0400347 * Value - Where to store value (must be 64 bits)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 * read_write - Read or Write flag
349 *
350 * RETURN: Status
351 *
352 * DESCRIPTION: Read or Write a single datum of a field. The field_type is
353 * demultiplexed here to handle the different types of fields
354 * (buffer_field, region_field, index_field, bank_field)
355 *
356 ******************************************************************************/
357
Robert Moore44f6c012005-04-18 22:49:35 -0400358static acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400359acpi_ex_field_datum_io(union acpi_operand_object *obj_desc,
360 u32 field_datum_byte_offset,
361 acpi_integer * value, u32 read_write)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362{
Len Brown4be44fc2005-08-05 00:44:28 -0400363 acpi_status status;
364 acpi_integer local_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Bob Mooreb229cf92006-04-21 17:15:00 -0400366 ACPI_FUNCTION_TRACE_U32(ex_field_datum_io, field_datum_byte_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
368 if (read_write == ACPI_READ) {
369 if (!value) {
370 local_value = 0;
Robert Moore44f6c012005-04-18 22:49:35 -0400371
372 /* To support reads without saving return value */
373 value = &local_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 }
375
376 /* Clear the entire return buffer first, [Very Important!] */
377
378 *value = 0;
379 }
380
381 /*
382 * The four types of fields are:
383 *
384 * buffer_field - Read/write from/to a Buffer
385 * region_field - Read/write from/to a Operation Region.
Robert Moore44f6c012005-04-18 22:49:35 -0400386 * bank_field - Write to a Bank Register, then read/write from/to an
387 * operation_region
388 * index_field - Write to an Index Register, then read/write from/to a
389 * Data Register
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 */
Len Brown4be44fc2005-08-05 00:44:28 -0400391 switch (ACPI_GET_OBJECT_TYPE(obj_desc)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 case ACPI_TYPE_BUFFER_FIELD:
393 /*
394 * If the buffer_field arguments have not been previously evaluated,
395 * evaluate them now and save the results.
396 */
397 if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400398 status = acpi_ds_get_buffer_field_arguments(obj_desc);
399 if (ACPI_FAILURE(status)) {
400 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 }
402 }
403
404 if (read_write == ACPI_READ) {
405 /*
406 * Copy the data from the source buffer.
407 * Length is the field width in bytes.
408 */
Len Brown4be44fc2005-08-05 00:44:28 -0400409 ACPI_MEMCPY(value,
410 (obj_desc->buffer_field.buffer_obj)->buffer.
411 pointer +
412 obj_desc->buffer_field.base_byte_offset +
413 field_datum_byte_offset,
414 obj_desc->common_field.access_byte_width);
415 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 /*
417 * Copy the data to the target buffer.
418 * Length is the field width in bytes.
419 */
Len Brown4be44fc2005-08-05 00:44:28 -0400420 ACPI_MEMCPY((obj_desc->buffer_field.buffer_obj)->buffer.
421 pointer +
422 obj_desc->buffer_field.base_byte_offset +
423 field_datum_byte_offset, value,
424 obj_desc->common_field.access_byte_width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 }
426
427 status = AE_OK;
428 break;
429
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 case ACPI_TYPE_LOCAL_BANK_FIELD:
431
Robert Moore44f6c012005-04-18 22:49:35 -0400432 /*
433 * Ensure that the bank_value is not beyond the capacity of
434 * the register
435 */
Len Brown4be44fc2005-08-05 00:44:28 -0400436 if (acpi_ex_register_overflow(obj_desc->bank_field.bank_obj,
437 (acpi_integer) obj_desc->
438 bank_field.value)) {
439 return_ACPI_STATUS(AE_AML_REGISTER_LIMIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 }
441
442 /*
443 * For bank_fields, we must write the bank_value to the bank_register
444 * (itself a region_field) before we can access the data.
445 */
Len Brown4be44fc2005-08-05 00:44:28 -0400446 status =
447 acpi_ex_insert_into_field(obj_desc->bank_field.bank_obj,
448 &obj_desc->bank_field.value,
449 sizeof(obj_desc->bank_field.
450 value));
451 if (ACPI_FAILURE(status)) {
452 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 }
454
455 /*
456 * Now that the Bank has been selected, fall through to the
457 * region_field case and write the datum to the Operation Region
458 */
459
460 /*lint -fallthrough */
461
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 case ACPI_TYPE_LOCAL_REGION_FIELD:
463 /*
464 * For simple region_fields, we just directly access the owning
465 * Operation Region.
466 */
Len Brown4be44fc2005-08-05 00:44:28 -0400467 status =
468 acpi_ex_access_region(obj_desc, field_datum_byte_offset,
469 value, read_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 break;
471
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 case ACPI_TYPE_LOCAL_INDEX_FIELD:
473
Robert Moore44f6c012005-04-18 22:49:35 -0400474 /*
475 * Ensure that the index_value is not beyond the capacity of
476 * the register
477 */
Len Brown4be44fc2005-08-05 00:44:28 -0400478 if (acpi_ex_register_overflow(obj_desc->index_field.index_obj,
479 (acpi_integer) obj_desc->
480 index_field.value)) {
481 return_ACPI_STATUS(AE_AML_REGISTER_LIMIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 }
483
484 /* Write the index value to the index_register (itself a region_field) */
485
486 field_datum_byte_offset += obj_desc->index_field.value;
487
Len Brown4be44fc2005-08-05 00:44:28 -0400488 ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
489 "Write to Index Register: Value %8.8X\n",
490 field_datum_byte_offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Len Brown4be44fc2005-08-05 00:44:28 -0400492 status =
493 acpi_ex_insert_into_field(obj_desc->index_field.index_obj,
494 &field_datum_byte_offset,
495 sizeof(field_datum_byte_offset));
496 if (ACPI_FAILURE(status)) {
497 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 }
499
Len Brown4be44fc2005-08-05 00:44:28 -0400500 ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
Bob Mooreb229cf92006-04-21 17:15:00 -0400501 "I/O to Data Register: ValuePtr %p\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400502 value));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504 if (read_write == ACPI_READ) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 /* Read the datum from the data_register */
507
Len Brown4be44fc2005-08-05 00:44:28 -0400508 status =
509 acpi_ex_extract_from_field(obj_desc->index_field.
510 data_obj, value,
511 sizeof(acpi_integer));
512 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 /* Write the datum to the data_register */
514
Len Brown4be44fc2005-08-05 00:44:28 -0400515 status =
516 acpi_ex_insert_into_field(obj_desc->index_field.
517 data_obj, value,
518 sizeof(acpi_integer));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 }
520 break;
521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 default:
523
Bob Mooreb8e4d892006-01-27 16:43:00 -0500524 ACPI_ERROR((AE_INFO, "Wrong object type in field I/O %X",
525 ACPI_GET_OBJECT_TYPE(obj_desc)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 status = AE_AML_INTERNAL;
527 break;
528 }
529
Len Brown4be44fc2005-08-05 00:44:28 -0400530 if (ACPI_SUCCESS(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 if (read_write == ACPI_READ) {
Len Brown4be44fc2005-08-05 00:44:28 -0400532 ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
533 "Value Read %8.8X%8.8X, Width %d\n",
534 ACPI_FORMAT_UINT64(*value),
535 obj_desc->common_field.
536 access_byte_width));
537 } else {
538 ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
539 "Value Written %8.8X%8.8X, Width %d\n",
540 ACPI_FORMAT_UINT64(*value),
541 obj_desc->common_field.
542 access_byte_width));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 }
544 }
545
Len Brown4be44fc2005-08-05 00:44:28 -0400546 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547}
548
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549/*******************************************************************************
550 *
551 * FUNCTION: acpi_ex_write_with_update_rule
552 *
Robert Moore44f6c012005-04-18 22:49:35 -0400553 * PARAMETERS: obj_desc - Field to be written
554 * Mask - bitmask within field datum
555 * field_value - Value to write
556 * field_datum_byte_offset - Offset of datum within field
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 *
558 * RETURN: Status
559 *
560 * DESCRIPTION: Apply the field update rule to a field write
561 *
562 ******************************************************************************/
563
564acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400565acpi_ex_write_with_update_rule(union acpi_operand_object *obj_desc,
566 acpi_integer mask,
567 acpi_integer field_value,
568 u32 field_datum_byte_offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
Len Brown4be44fc2005-08-05 00:44:28 -0400570 acpi_status status = AE_OK;
571 acpi_integer merged_value;
572 acpi_integer current_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Bob Mooreb229cf92006-04-21 17:15:00 -0400574 ACPI_FUNCTION_TRACE_U32(ex_write_with_update_rule, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
576 /* Start with the new bits */
577
578 merged_value = field_value;
579
580 /* If the mask is all ones, we don't need to worry about the update rule */
581
582 if (mask != ACPI_INTEGER_MAX) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400583
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 /* Decode the update rule */
585
Len Brown4be44fc2005-08-05 00:44:28 -0400586 switch (obj_desc->common_field.
587 field_flags & AML_FIELD_UPDATE_RULE_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 case AML_FIELD_UPDATE_PRESERVE:
589 /*
590 * Check if update rule needs to be applied (not if mask is all
591 * ones) The left shift drops the bits we want to ignore.
592 */
Len Brown4be44fc2005-08-05 00:44:28 -0400593 if ((~mask << (ACPI_MUL_8(sizeof(mask)) -
594 ACPI_MUL_8(obj_desc->common_field.
595 access_byte_width))) != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 /*
597 * Read the current contents of the byte/word/dword containing
598 * the field, and merge with the new field value.
599 */
Len Brown4be44fc2005-08-05 00:44:28 -0400600 status =
601 acpi_ex_field_datum_io(obj_desc,
602 field_datum_byte_offset,
603 &current_value,
604 ACPI_READ);
605 if (ACPI_FAILURE(status)) {
606 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 }
608
609 merged_value |= (current_value & ~mask);
610 }
611 break;
612
613 case AML_FIELD_UPDATE_WRITE_AS_ONES:
614
615 /* Set positions outside the field to all ones */
616
617 merged_value |= ~mask;
618 break;
619
620 case AML_FIELD_UPDATE_WRITE_AS_ZEROS:
621
622 /* Set positions outside the field to all zeros */
623
624 merged_value &= mask;
625 break;
626
627 default:
628
Bob Mooreb8e4d892006-01-27 16:43:00 -0500629 ACPI_ERROR((AE_INFO,
Bob Mooreb229cf92006-04-21 17:15:00 -0400630 "Unknown UpdateRule value: %X",
Bob Mooreb8e4d892006-01-27 16:43:00 -0500631 (obj_desc->common_field.
632 field_flags &
633 AML_FIELD_UPDATE_RULE_MASK)));
Len Brown4be44fc2005-08-05 00:44:28 -0400634 return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 }
636 }
637
Len Brown4be44fc2005-08-05 00:44:28 -0400638 ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
Bob Mooreb229cf92006-04-21 17:15:00 -0400639 "Mask %8.8X%8.8X, DatumOffset %X, Width %X, Value %8.8X%8.8X, MergedValue %8.8X%8.8X\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400640 ACPI_FORMAT_UINT64(mask),
641 field_datum_byte_offset,
642 obj_desc->common_field.access_byte_width,
643 ACPI_FORMAT_UINT64(field_value),
644 ACPI_FORMAT_UINT64(merged_value)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646 /* Write the merged value */
647
Len Brown4be44fc2005-08-05 00:44:28 -0400648 status = acpi_ex_field_datum_io(obj_desc, field_datum_byte_offset,
649 &merged_value, ACPI_WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Len Brown4be44fc2005-08-05 00:44:28 -0400651 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652}
653
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654/*******************************************************************************
655 *
656 * FUNCTION: acpi_ex_extract_from_field
657 *
658 * PARAMETERS: obj_desc - Field to be read
659 * Buffer - Where to store the field data
660 * buffer_length - Length of Buffer
661 *
662 * RETURN: Status
663 *
664 * DESCRIPTION: Retrieve the current value of the given field
665 *
666 ******************************************************************************/
667
668acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400669acpi_ex_extract_from_field(union acpi_operand_object *obj_desc,
670 void *buffer, u32 buffer_length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671{
Len Brown4be44fc2005-08-05 00:44:28 -0400672 acpi_status status;
673 acpi_integer raw_datum;
674 acpi_integer merged_datum;
675 u32 field_offset = 0;
676 u32 buffer_offset = 0;
677 u32 buffer_tail_bits;
678 u32 datum_count;
679 u32 field_datum_count;
680 u32 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
Bob Mooreb229cf92006-04-21 17:15:00 -0400682 ACPI_FUNCTION_TRACE(ex_extract_from_field);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
684 /* Validate target buffer and clear it */
685
Len Brown4be44fc2005-08-05 00:44:28 -0400686 if (buffer_length <
687 ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->common_field.bit_length)) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500688 ACPI_ERROR((AE_INFO,
689 "Field size %X (bits) is too large for buffer (%X)",
690 obj_desc->common_field.bit_length, buffer_length));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Len Brown4be44fc2005-08-05 00:44:28 -0400692 return_ACPI_STATUS(AE_BUFFER_OVERFLOW);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 }
Len Brown4be44fc2005-08-05 00:44:28 -0400694 ACPI_MEMSET(buffer, 0, buffer_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
696 /* Compute the number of datums (access width data items) */
697
Len Brown4be44fc2005-08-05 00:44:28 -0400698 datum_count = ACPI_ROUND_UP_TO(obj_desc->common_field.bit_length,
699 obj_desc->common_field.access_bit_width);
700 field_datum_count = ACPI_ROUND_UP_TO(obj_desc->common_field.bit_length +
701 obj_desc->common_field.
702 start_field_bit_offset,
703 obj_desc->common_field.
704 access_bit_width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705
706 /* Priming read from the field */
707
Len Brown4be44fc2005-08-05 00:44:28 -0400708 status =
709 acpi_ex_field_datum_io(obj_desc, field_offset, &raw_datum,
710 ACPI_READ);
711 if (ACPI_FAILURE(status)) {
712 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 }
Len Brown4be44fc2005-08-05 00:44:28 -0400714 merged_datum =
715 raw_datum >> obj_desc->common_field.start_field_bit_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
717 /* Read the rest of the field */
718
719 for (i = 1; i < field_datum_count; i++) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400720
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 /* Get next input datum from the field */
722
723 field_offset += obj_desc->common_field.access_byte_width;
Len Brown4be44fc2005-08-05 00:44:28 -0400724 status = acpi_ex_field_datum_io(obj_desc, field_offset,
725 &raw_datum, ACPI_READ);
726 if (ACPI_FAILURE(status)) {
727 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 }
729
Bob Moore967440e32006-06-23 17:04:00 -0400730 /*
731 * Merge with previous datum if necessary.
732 *
733 * Note: Before the shift, check if the shift value will be larger than
734 * the integer size. If so, there is no need to perform the operation.
735 * This avoids the differences in behavior between different compilers
736 * concerning shift values larger than the target data width.
737 */
738 if ((obj_desc->common_field.access_bit_width -
739 obj_desc->common_field.start_field_bit_offset) <
740 ACPI_INTEGER_BIT_SIZE) {
741 merged_datum |=
742 raw_datum << (obj_desc->common_field.
743 access_bit_width -
744 obj_desc->common_field.
745 start_field_bit_offset);
746 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
748 if (i == datum_count) {
749 break;
750 }
751
752 /* Write merged datum to target buffer */
753
Len Brown4be44fc2005-08-05 00:44:28 -0400754 ACPI_MEMCPY(((char *)buffer) + buffer_offset, &merged_datum,
755 ACPI_MIN(obj_desc->common_field.access_byte_width,
756 buffer_length - buffer_offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
758 buffer_offset += obj_desc->common_field.access_byte_width;
Len Brown4be44fc2005-08-05 00:44:28 -0400759 merged_datum =
760 raw_datum >> obj_desc->common_field.start_field_bit_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 }
762
763 /* Mask off any extra bits in the last datum */
764
Robert Moore44f6c012005-04-18 22:49:35 -0400765 buffer_tail_bits = obj_desc->common_field.bit_length %
Len Brown4be44fc2005-08-05 00:44:28 -0400766 obj_desc->common_field.access_bit_width;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 if (buffer_tail_bits) {
Len Brown4be44fc2005-08-05 00:44:28 -0400768 merged_datum &= ACPI_MASK_BITS_ABOVE(buffer_tail_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 }
770
771 /* Write the last datum to the buffer */
772
Len Brown4be44fc2005-08-05 00:44:28 -0400773 ACPI_MEMCPY(((char *)buffer) + buffer_offset, &merged_datum,
774 ACPI_MIN(obj_desc->common_field.access_byte_width,
775 buffer_length - buffer_offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Len Brown4be44fc2005-08-05 00:44:28 -0400777 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778}
779
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780/*******************************************************************************
781 *
782 * FUNCTION: acpi_ex_insert_into_field
783 *
784 * PARAMETERS: obj_desc - Field to be written
785 * Buffer - Data to be written
786 * buffer_length - Length of Buffer
787 *
788 * RETURN: Status
789 *
790 * DESCRIPTION: Store the Buffer contents into the given field
791 *
792 ******************************************************************************/
793
794acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400795acpi_ex_insert_into_field(union acpi_operand_object *obj_desc,
796 void *buffer, u32 buffer_length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797{
Len Brown4be44fc2005-08-05 00:44:28 -0400798 acpi_status status;
799 acpi_integer mask;
Bob Moore4c90ece2006-06-08 16:29:00 -0400800 acpi_integer width_mask;
Len Brown4be44fc2005-08-05 00:44:28 -0400801 acpi_integer merged_datum;
802 acpi_integer raw_datum = 0;
803 u32 field_offset = 0;
804 u32 buffer_offset = 0;
805 u32 buffer_tail_bits;
806 u32 datum_count;
807 u32 field_datum_count;
808 u32 i;
Bob Moore9aa61692008-04-10 19:06:41 +0400809 u32 required_length;
810 void *new_buffer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811
Bob Mooreb229cf92006-04-21 17:15:00 -0400812 ACPI_FUNCTION_TRACE(ex_insert_into_field);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
814 /* Validate input buffer */
815
Bob Moore9aa61692008-04-10 19:06:41 +0400816 new_buffer = NULL;
817 required_length =
818 ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->common_field.bit_length);
819 /*
820 * We must have a buffer that is at least as long as the field
821 * we are writing to. This is because individual fields are
822 * indivisible and partial writes are not supported -- as per
823 * the ACPI specification.
824 */
825 if (buffer_length < required_length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
Bob Moore9aa61692008-04-10 19:06:41 +0400827 /* We need to create a new buffer */
828
829 new_buffer = ACPI_ALLOCATE_ZEROED(required_length);
830 if (!new_buffer) {
831 return_ACPI_STATUS(AE_NO_MEMORY);
832 }
833
834 /*
835 * Copy the original data to the new buffer, starting
836 * at Byte zero. All unused (upper) bytes of the
837 * buffer will be 0.
838 */
839 ACPI_MEMCPY((char *)new_buffer, (char *)buffer, buffer_length);
840 buffer = new_buffer;
841 buffer_length = required_length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 }
843
Bob Moore967440e32006-06-23 17:04:00 -0400844 /*
845 * Create the bitmasks used for bit insertion.
846 * Note: This if/else is used to bypass compiler differences with the
847 * shift operator
848 */
849 if (obj_desc->common_field.access_bit_width == ACPI_INTEGER_BIT_SIZE) {
850 width_mask = ACPI_INTEGER_MAX;
851 } else {
852 width_mask =
853 ACPI_MASK_BITS_ABOVE(obj_desc->common_field.
854 access_bit_width);
855 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
Bob Moore967440e32006-06-23 17:04:00 -0400857 mask = width_mask &
858 ACPI_MASK_BITS_BELOW(obj_desc->common_field.start_field_bit_offset);
859
860 /* Compute the number of datums (access width data items) */
Bob Moore41195322006-05-26 16:36:00 -0400861
862 datum_count = ACPI_ROUND_UP_TO(obj_desc->common_field.bit_length,
863 obj_desc->common_field.access_bit_width);
864
865 field_datum_count = ACPI_ROUND_UP_TO(obj_desc->common_field.bit_length +
866 obj_desc->common_field.
867 start_field_bit_offset,
868 obj_desc->common_field.
869 access_bit_width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870
871 /* Get initial Datum from the input buffer */
872
Len Brown4be44fc2005-08-05 00:44:28 -0400873 ACPI_MEMCPY(&raw_datum, buffer,
874 ACPI_MIN(obj_desc->common_field.access_byte_width,
875 buffer_length - buffer_offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876
Len Brown4be44fc2005-08-05 00:44:28 -0400877 merged_datum =
878 raw_datum << obj_desc->common_field.start_field_bit_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
880 /* Write the entire field */
881
882 for (i = 1; i < field_datum_count; i++) {
Bob Moore52fc0b02006-10-02 00:00:00 -0400883
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 /* Write merged datum to the target field */
885
886 merged_datum &= mask;
Len Brown4be44fc2005-08-05 00:44:28 -0400887 status = acpi_ex_write_with_update_rule(obj_desc, mask,
888 merged_datum,
889 field_offset);
890 if (ACPI_FAILURE(status)) {
Bob Moore9aa61692008-04-10 19:06:41 +0400891 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 }
893
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 field_offset += obj_desc->common_field.access_byte_width;
Bob Moore967440e32006-06-23 17:04:00 -0400895
896 /*
897 * Start new output datum by merging with previous input datum
898 * if necessary.
899 *
900 * Note: Before the shift, check if the shift value will be larger than
901 * the integer size. If so, there is no need to perform the operation.
902 * This avoids the differences in behavior between different compilers
903 * concerning shift values larger than the target data width.
904 */
905 if ((obj_desc->common_field.access_bit_width -
906 obj_desc->common_field.start_field_bit_offset) <
907 ACPI_INTEGER_BIT_SIZE) {
908 merged_datum =
909 raw_datum >> (obj_desc->common_field.
910 access_bit_width -
911 obj_desc->common_field.
912 start_field_bit_offset);
913 } else {
914 merged_datum = 0;
915 }
916
Bob Moore4c90ece2006-06-08 16:29:00 -0400917 mask = width_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
919 if (i == datum_count) {
920 break;
921 }
922
923 /* Get the next input datum from the buffer */
924
925 buffer_offset += obj_desc->common_field.access_byte_width;
Len Brown4be44fc2005-08-05 00:44:28 -0400926 ACPI_MEMCPY(&raw_datum, ((char *)buffer) + buffer_offset,
927 ACPI_MIN(obj_desc->common_field.access_byte_width,
928 buffer_length - buffer_offset));
929 merged_datum |=
930 raw_datum << obj_desc->common_field.start_field_bit_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 }
932
933 /* Mask off any extra bits in the last datum */
934
935 buffer_tail_bits = (obj_desc->common_field.bit_length +
Len Brown4be44fc2005-08-05 00:44:28 -0400936 obj_desc->common_field.start_field_bit_offset) %
937 obj_desc->common_field.access_bit_width;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 if (buffer_tail_bits) {
Len Brown4be44fc2005-08-05 00:44:28 -0400939 mask &= ACPI_MASK_BITS_ABOVE(buffer_tail_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 }
941
942 /* Write the last datum to the field */
943
944 merged_datum &= mask;
Len Brown4be44fc2005-08-05 00:44:28 -0400945 status = acpi_ex_write_with_update_rule(obj_desc,
946 mask, merged_datum,
947 field_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948
Bob Moore9aa61692008-04-10 19:06:41 +0400949 exit:
950 /* Free temporary buffer if we used one */
951
952 if (new_buffer) {
953 ACPI_FREE(new_buffer);
954 }
Len Brown4be44fc2005-08-05 00:44:28 -0400955 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956}