Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | |
2 | /****************************************************************************** | |
3 | * | |
4 | * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities | |
5 | * | |
6 | *****************************************************************************/ | |
7 | ||
8 | /* | |
75a44ce0 | 9 | * Copyright (C) 2000 - 2008, Intel Corp. |
1da177e4 LT |
10 | * All rights reserved. |
11 | * | |
12 | * Redistribution and use in source and binary forms, with or without | |
13 | * modification, are permitted provided that the following conditions | |
14 | * are met: | |
15 | * 1. Redistributions of source code must retain the above copyright | |
16 | * notice, this list of conditions, and the following disclaimer, | |
17 | * without modification. | |
18 | * 2. Redistributions in binary form must reproduce at minimum a disclaimer | |
19 | * substantially similar to the "NO WARRANTY" disclaimer below | |
20 | * ("Disclaimer") and any redistribution must be conditioned upon | |
21 | * including a substantially similar Disclaimer requirement for further | |
22 | * binary redistribution. | |
23 | * 3. Neither the names of the above-listed copyright holders nor the names | |
24 | * of any contributors may be used to endorse or promote products derived | |
25 | * from this software without specific prior written permission. | |
26 | * | |
27 | * Alternatively, this software may be distributed under the terms of the | |
28 | * GNU General Public License ("GPL") version 2 as published by the Free | |
29 | * Software Foundation. | |
30 | * | |
31 | * NO WARRANTY | |
32 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
33 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
34 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR | |
35 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
36 | * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
37 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
38 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
39 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
40 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING | |
41 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
42 | * POSSIBILITY OF SUCH DAMAGES. | |
43 | */ | |
44 | ||
1da177e4 | 45 | #include <acpi/acpi.h> |
e2f7a777 LB |
46 | #include "accommon.h" |
47 | #include "acinterp.h" | |
48 | #include "amlcode.h" | |
49 | #include "acnamesp.h" | |
1da177e4 | 50 | |
1da177e4 | 51 | #define _COMPONENT ACPI_EXECUTER |
4be44fcd | 52 | ACPI_MODULE_NAME("exprep") |
1da177e4 | 53 | |
44f6c012 | 54 | /* Local prototypes */ |
44f6c012 | 55 | static u32 |
4be44fcd LB |
56 | acpi_ex_decode_field_access(union acpi_operand_object *obj_desc, |
57 | u8 field_flags, u32 * return_byte_alignment); | |
1da177e4 LT |
58 | |
59 | #ifdef ACPI_UNDER_DEVELOPMENT | |
44f6c012 RM |
60 | |
61 | static u32 | |
4be44fcd LB |
62 | acpi_ex_generate_access(u32 field_bit_offset, |
63 | u32 field_bit_length, u32 region_length); | |
44f6c012 | 64 | |
1da177e4 LT |
65 | /******************************************************************************* |
66 | * | |
67 | * FUNCTION: acpi_ex_generate_access | |
68 | * | |
69 | * PARAMETERS: field_bit_offset - Start of field within parent region/buffer | |
70 | * field_bit_length - Length of field in bits | |
71 | * region_length - Length of parent in bytes | |
72 | * | |
73 | * RETURN: Field granularity (8, 16, 32 or 64) and | |
74 | * byte_alignment (1, 2, 3, or 4) | |
75 | * | |
76 | * DESCRIPTION: Generate an optimal access width for fields defined with the | |
77 | * any_acc keyword. | |
78 | * | |
79 | * NOTE: Need to have the region_length in order to check for boundary | |
80 | * conditions (end-of-region). However, the region_length is a deferred | |
81 | * operation. Therefore, to complete this implementation, the generation | |
82 | * of this access width must be deferred until the region length has | |
83 | * been evaluated. | |
84 | * | |
85 | ******************************************************************************/ | |
86 | ||
87 | static u32 | |
4be44fcd LB |
88 | acpi_ex_generate_access(u32 field_bit_offset, |
89 | u32 field_bit_length, u32 region_length) | |
1da177e4 | 90 | { |
4be44fcd LB |
91 | u32 field_byte_length; |
92 | u32 field_byte_offset; | |
93 | u32 field_byte_end_offset; | |
94 | u32 access_byte_width; | |
95 | u32 field_start_offset; | |
96 | u32 field_end_offset; | |
97 | u32 minimum_access_width = 0xFFFFFFFF; | |
98 | u32 minimum_accesses = 0xFFFFFFFF; | |
99 | u32 accesses; | |
100 | ||
b229cf92 | 101 | ACPI_FUNCTION_TRACE(ex_generate_access); |
1da177e4 LT |
102 | |
103 | /* Round Field start offset and length to "minimal" byte boundaries */ | |
104 | ||
4be44fcd LB |
105 | field_byte_offset = ACPI_DIV_8(ACPI_ROUND_DOWN(field_bit_offset, 8)); |
106 | field_byte_end_offset = ACPI_DIV_8(ACPI_ROUND_UP(field_bit_length + | |
107 | field_bit_offset, 8)); | |
108 | field_byte_length = field_byte_end_offset - field_byte_offset; | |
1da177e4 | 109 | |
4be44fcd LB |
110 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
111 | "Bit length %d, Bit offset %d\n", | |
112 | field_bit_length, field_bit_offset)); | |
44f6c012 | 113 | |
4be44fcd LB |
114 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
115 | "Byte Length %d, Byte Offset %d, End Offset %d\n", | |
116 | field_byte_length, field_byte_offset, | |
117 | field_byte_end_offset)); | |
1da177e4 LT |
118 | |
119 | /* | |
120 | * Iterative search for the maximum access width that is both aligned | |
121 | * and does not go beyond the end of the region | |
122 | * | |
123 | * Start at byte_acc and work upwards to qword_acc max. (1,2,4,8 bytes) | |
124 | */ | |
4be44fcd LB |
125 | for (access_byte_width = 1; access_byte_width <= 8; |
126 | access_byte_width <<= 1) { | |
1da177e4 | 127 | /* |
44f6c012 RM |
128 | * 1) Round end offset up to next access boundary and make sure that |
129 | * this does not go beyond the end of the parent region. | |
130 | * 2) When the Access width is greater than the field_byte_length, we | |
131 | * are done. (This does not optimize for the perfectly aligned | |
132 | * case yet). | |
1da177e4 | 133 | */ |
4be44fcd LB |
134 | if (ACPI_ROUND_UP(field_byte_end_offset, access_byte_width) <= |
135 | region_length) { | |
44f6c012 | 136 | field_start_offset = |
4be44fcd LB |
137 | ACPI_ROUND_DOWN(field_byte_offset, |
138 | access_byte_width) / | |
139 | access_byte_width; | |
44f6c012 RM |
140 | |
141 | field_end_offset = | |
4be44fcd LB |
142 | ACPI_ROUND_UP((field_byte_length + |
143 | field_byte_offset), | |
144 | access_byte_width) / | |
145 | access_byte_width; | |
44f6c012 RM |
146 | |
147 | accesses = field_end_offset - field_start_offset; | |
1da177e4 | 148 | |
4be44fcd | 149 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 150 | "AccessWidth %d end is within region\n", |
4be44fcd | 151 | access_byte_width)); |
44f6c012 | 152 | |
4be44fcd LB |
153 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
154 | "Field Start %d, Field End %d -- requires %d accesses\n", | |
155 | field_start_offset, field_end_offset, | |
156 | accesses)); | |
1da177e4 LT |
157 | |
158 | /* Single access is optimal */ | |
159 | ||
160 | if (accesses <= 1) { | |
4be44fcd LB |
161 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
162 | "Entire field can be accessed with one operation of size %d\n", | |
163 | access_byte_width)); | |
164 | return_VALUE(access_byte_width); | |
1da177e4 LT |
165 | } |
166 | ||
167 | /* | |
168 | * Fits in the region, but requires more than one read/write. | |
169 | * try the next wider access on next iteration | |
170 | */ | |
171 | if (accesses < minimum_accesses) { | |
4be44fcd | 172 | minimum_accesses = accesses; |
1da177e4 LT |
173 | minimum_access_width = access_byte_width; |
174 | } | |
4be44fcd LB |
175 | } else { |
176 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, | |
b229cf92 | 177 | "AccessWidth %d end is NOT within region\n", |
4be44fcd | 178 | access_byte_width)); |
1da177e4 | 179 | if (access_byte_width == 1) { |
4be44fcd LB |
180 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
181 | "Field goes beyond end-of-region!\n")); | |
1da177e4 | 182 | |
44f6c012 | 183 | /* Field does not fit in the region at all */ |
1da177e4 | 184 | |
4be44fcd | 185 | return_VALUE(0); |
44f6c012 RM |
186 | } |
187 | ||
188 | /* | |
189 | * This width goes beyond the end-of-region, back off to | |
190 | * previous access | |
191 | */ | |
4be44fcd LB |
192 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
193 | "Backing off to previous optimal access width of %d\n", | |
194 | minimum_access_width)); | |
195 | return_VALUE(minimum_access_width); | |
1da177e4 LT |
196 | } |
197 | } | |
198 | ||
44f6c012 RM |
199 | /* |
200 | * Could not read/write field with one operation, | |
201 | * just use max access width | |
202 | */ | |
4be44fcd LB |
203 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
204 | "Cannot access field in one operation, using width 8\n")); | |
205 | return_VALUE(8); | |
1da177e4 | 206 | } |
4be44fcd | 207 | #endif /* ACPI_UNDER_DEVELOPMENT */ |
1da177e4 LT |
208 | |
209 | /******************************************************************************* | |
210 | * | |
211 | * FUNCTION: acpi_ex_decode_field_access | |
212 | * | |
44f6c012 RM |
213 | * PARAMETERS: obj_desc - Field object |
214 | * field_flags - Encoded fieldflags (contains access bits) | |
215 | * return_byte_alignment - Where the byte alignment is returned | |
1da177e4 LT |
216 | * |
217 | * RETURN: Field granularity (8, 16, 32 or 64) and | |
218 | * byte_alignment (1, 2, 3, or 4) | |
219 | * | |
220 | * DESCRIPTION: Decode the access_type bits of a field definition. | |
221 | * | |
222 | ******************************************************************************/ | |
223 | ||
224 | static u32 | |
4be44fcd LB |
225 | acpi_ex_decode_field_access(union acpi_operand_object *obj_desc, |
226 | u8 field_flags, u32 * return_byte_alignment) | |
1da177e4 | 227 | { |
4be44fcd LB |
228 | u32 access; |
229 | u32 byte_alignment; | |
230 | u32 bit_length; | |
1da177e4 | 231 | |
b229cf92 | 232 | ACPI_FUNCTION_TRACE(ex_decode_field_access); |
1da177e4 LT |
233 | |
234 | access = (field_flags & AML_FIELD_ACCESS_TYPE_MASK); | |
235 | ||
236 | switch (access) { | |
237 | case AML_FIELD_ACCESS_ANY: | |
238 | ||
239 | #ifdef ACPI_UNDER_DEVELOPMENT | |
44f6c012 | 240 | byte_alignment = |
4be44fcd LB |
241 | acpi_ex_generate_access(obj_desc->common_field. |
242 | start_field_bit_offset, | |
243 | obj_desc->common_field.bit_length, | |
244 | 0xFFFFFFFF | |
245 | /* Temp until we pass region_length as parameter */ | |
fd350943 | 246 | ); |
1da177e4 LT |
247 | bit_length = byte_alignment * 8; |
248 | #endif | |
249 | ||
250 | byte_alignment = 1; | |
251 | bit_length = 8; | |
252 | break; | |
253 | ||
254 | case AML_FIELD_ACCESS_BYTE: | |
4be44fcd | 255 | case AML_FIELD_ACCESS_BUFFER: /* ACPI 2.0 (SMBus Buffer) */ |
1da177e4 | 256 | byte_alignment = 1; |
4be44fcd | 257 | bit_length = 8; |
1da177e4 LT |
258 | break; |
259 | ||
260 | case AML_FIELD_ACCESS_WORD: | |
261 | byte_alignment = 2; | |
4be44fcd | 262 | bit_length = 16; |
1da177e4 LT |
263 | break; |
264 | ||
265 | case AML_FIELD_ACCESS_DWORD: | |
266 | byte_alignment = 4; | |
4be44fcd | 267 | bit_length = 32; |
1da177e4 LT |
268 | break; |
269 | ||
4be44fcd | 270 | case AML_FIELD_ACCESS_QWORD: /* ACPI 2.0 */ |
1da177e4 | 271 | byte_alignment = 8; |
4be44fcd | 272 | bit_length = 64; |
1da177e4 LT |
273 | break; |
274 | ||
275 | default: | |
276 | /* Invalid field access type */ | |
277 | ||
b8e4d893 | 278 | ACPI_ERROR((AE_INFO, "Unknown field access type %X", access)); |
50eca3eb | 279 | return_UINT32(0); |
1da177e4 LT |
280 | } |
281 | ||
4be44fcd | 282 | if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_BUFFER_FIELD) { |
1da177e4 LT |
283 | /* |
284 | * buffer_field access can be on any byte boundary, so the | |
285 | * byte_alignment is always 1 byte -- regardless of any byte_alignment | |
286 | * implied by the field access type. | |
287 | */ | |
288 | byte_alignment = 1; | |
289 | } | |
290 | ||
291 | *return_byte_alignment = byte_alignment; | |
50eca3eb | 292 | return_UINT32(bit_length); |
1da177e4 LT |
293 | } |
294 | ||
1da177e4 LT |
295 | /******************************************************************************* |
296 | * | |
297 | * FUNCTION: acpi_ex_prep_common_field_object | |
298 | * | |
299 | * PARAMETERS: obj_desc - The field object | |
300 | * field_flags - Access, lock_rule, and update_rule. | |
301 | * The format of a field_flag is described | |
302 | * in the ACPI specification | |
44f6c012 | 303 | * field_attribute - Special attributes (not used) |
1da177e4 LT |
304 | * field_bit_position - Field start position |
305 | * field_bit_length - Field length in number of bits | |
306 | * | |
307 | * RETURN: Status | |
308 | * | |
309 | * DESCRIPTION: Initialize the areas of the field object that are common | |
310 | * to the various types of fields. Note: This is very "sensitive" | |
311 | * code because we are solving the general case for field | |
312 | * alignment. | |
313 | * | |
314 | ******************************************************************************/ | |
315 | ||
316 | acpi_status | |
4be44fcd LB |
317 | acpi_ex_prep_common_field_object(union acpi_operand_object *obj_desc, |
318 | u8 field_flags, | |
319 | u8 field_attribute, | |
320 | u32 field_bit_position, u32 field_bit_length) | |
1da177e4 | 321 | { |
4be44fcd LB |
322 | u32 access_bit_width; |
323 | u32 byte_alignment; | |
324 | u32 nearest_byte_address; | |
1da177e4 | 325 | |
b229cf92 | 326 | ACPI_FUNCTION_TRACE(ex_prep_common_field_object); |
1da177e4 LT |
327 | |
328 | /* | |
329 | * Note: the structure being initialized is the | |
330 | * ACPI_COMMON_FIELD_INFO; No structure fields outside of the common | |
331 | * area are initialized by this procedure. | |
332 | */ | |
333 | obj_desc->common_field.field_flags = field_flags; | |
334 | obj_desc->common_field.attribute = field_attribute; | |
335 | obj_desc->common_field.bit_length = field_bit_length; | |
336 | ||
337 | /* | |
338 | * Decode the access type so we can compute offsets. The access type gives | |
339 | * two pieces of information - the width of each field access and the | |
340 | * necessary byte_alignment (address granularity) of the access. | |
341 | * | |
342 | * For any_acc, the access_bit_width is the largest width that is both | |
343 | * necessary and possible in an attempt to access the whole field in one | |
344 | * I/O operation. However, for any_acc, the byte_alignment is always one | |
345 | * byte. | |
346 | * | |
347 | * For all Buffer Fields, the byte_alignment is always one byte. | |
348 | * | |
349 | * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is | |
350 | * the same (equivalent) as the byte_alignment. | |
351 | */ | |
4be44fcd LB |
352 | access_bit_width = acpi_ex_decode_field_access(obj_desc, field_flags, |
353 | &byte_alignment); | |
1da177e4 | 354 | if (!access_bit_width) { |
4be44fcd | 355 | return_ACPI_STATUS(AE_AML_OPERAND_VALUE); |
1da177e4 LT |
356 | } |
357 | ||
358 | /* Setup width (access granularity) fields */ | |
359 | ||
360 | obj_desc->common_field.access_byte_width = (u8) | |
4be44fcd | 361 | ACPI_DIV_8(access_bit_width); /* 1, 2, 4, 8 */ |
1da177e4 LT |
362 | |
363 | obj_desc->common_field.access_bit_width = (u8) access_bit_width; | |
364 | ||
365 | /* | |
366 | * base_byte_offset is the address of the start of the field within the | |
367 | * region. It is the byte address of the first *datum* (field-width data | |
368 | * unit) of the field. (i.e., the first datum that contains at least the | |
369 | * first *bit* of the field.) | |
370 | * | |
371 | * Note: byte_alignment is always either equal to the access_bit_width or 8 | |
372 | * (Byte access), and it defines the addressing granularity of the parent | |
373 | * region or buffer. | |
374 | */ | |
375 | nearest_byte_address = | |
4be44fcd | 376 | ACPI_ROUND_BITS_DOWN_TO_BYTES(field_bit_position); |
1da177e4 | 377 | obj_desc->common_field.base_byte_offset = (u32) |
4be44fcd | 378 | ACPI_ROUND_DOWN(nearest_byte_address, byte_alignment); |
1da177e4 LT |
379 | |
380 | /* | |
381 | * start_field_bit_offset is the offset of the first bit of the field within | |
382 | * a field datum. | |
383 | */ | |
384 | obj_desc->common_field.start_field_bit_offset = (u8) | |
4be44fcd LB |
385 | (field_bit_position - |
386 | ACPI_MUL_8(obj_desc->common_field.base_byte_offset)); | |
1da177e4 LT |
387 | |
388 | /* | |
389 | * Does the entire field fit within a single field access element? (datum) | |
390 | * (i.e., without crossing a datum boundary) | |
391 | */ | |
4be44fcd LB |
392 | if ((obj_desc->common_field.start_field_bit_offset + |
393 | field_bit_length) <= (u16) access_bit_width) { | |
1da177e4 LT |
394 | obj_desc->common.flags |= AOPOBJ_SINGLE_DATUM; |
395 | } | |
396 | ||
4be44fcd | 397 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
398 | } |
399 | ||
1da177e4 LT |
400 | /******************************************************************************* |
401 | * | |
402 | * FUNCTION: acpi_ex_prep_field_value | |
403 | * | |
44f6c012 | 404 | * PARAMETERS: Info - Contains all field creation info |
1da177e4 LT |
405 | * |
406 | * RETURN: Status | |
407 | * | |
408 | * DESCRIPTION: Construct an union acpi_operand_object of type def_field and | |
409 | * connect it to the parent Node. | |
410 | * | |
411 | ******************************************************************************/ | |
412 | ||
4be44fcd | 413 | acpi_status acpi_ex_prep_field_value(struct acpi_create_field_info *info) |
1da177e4 | 414 | { |
4be44fcd | 415 | union acpi_operand_object *obj_desc; |
ef805d95 | 416 | union acpi_operand_object *second_desc = NULL; |
4be44fcd LB |
417 | u32 type; |
418 | acpi_status status; | |
1da177e4 | 419 | |
b229cf92 | 420 | ACPI_FUNCTION_TRACE(ex_prep_field_value); |
1da177e4 LT |
421 | |
422 | /* Parameter validation */ | |
423 | ||
424 | if (info->field_type != ACPI_TYPE_LOCAL_INDEX_FIELD) { | |
425 | if (!info->region_node) { | |
b229cf92 | 426 | ACPI_ERROR((AE_INFO, "Null RegionNode")); |
4be44fcd | 427 | return_ACPI_STATUS(AE_AML_NO_OPERAND); |
1da177e4 LT |
428 | } |
429 | ||
4be44fcd | 430 | type = acpi_ns_get_type(info->region_node); |
1da177e4 | 431 | if (type != ACPI_TYPE_REGION) { |
b8e4d893 BM |
432 | ACPI_ERROR((AE_INFO, |
433 | "Needed Region, found type %X (%s)", | |
434 | type, acpi_ut_get_type_name(type))); | |
1da177e4 | 435 | |
4be44fcd | 436 | return_ACPI_STATUS(AE_AML_OPERAND_TYPE); |
1da177e4 LT |
437 | } |
438 | } | |
439 | ||
440 | /* Allocate a new field object */ | |
441 | ||
4be44fcd | 442 | obj_desc = acpi_ut_create_internal_object(info->field_type); |
1da177e4 | 443 | if (!obj_desc) { |
4be44fcd | 444 | return_ACPI_STATUS(AE_NO_MEMORY); |
1da177e4 LT |
445 | } |
446 | ||
447 | /* Initialize areas of the object that are common to all fields */ | |
448 | ||
449 | obj_desc->common_field.node = info->field_node; | |
4be44fcd LB |
450 | status = acpi_ex_prep_common_field_object(obj_desc, info->field_flags, |
451 | info->attribute, | |
452 | info->field_bit_position, | |
453 | info->field_bit_length); | |
454 | if (ACPI_FAILURE(status)) { | |
455 | acpi_ut_delete_object_desc(obj_desc); | |
456 | return_ACPI_STATUS(status); | |
1da177e4 LT |
457 | } |
458 | ||
459 | /* Initialize areas of the object that are specific to the field type */ | |
460 | ||
461 | switch (info->field_type) { | |
462 | case ACPI_TYPE_LOCAL_REGION_FIELD: | |
463 | ||
4be44fcd LB |
464 | obj_desc->field.region_obj = |
465 | acpi_ns_get_attached_object(info->region_node); | |
1da177e4 LT |
466 | |
467 | /* An additional reference for the container */ | |
468 | ||
4be44fcd | 469 | acpi_ut_add_reference(obj_desc->field.region_obj); |
1da177e4 | 470 | |
4be44fcd | 471 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 472 | "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n", |
4be44fcd LB |
473 | obj_desc->field.start_field_bit_offset, |
474 | obj_desc->field.base_byte_offset, | |
475 | obj_desc->field.access_byte_width, | |
476 | obj_desc->field.region_obj)); | |
1da177e4 LT |
477 | break; |
478 | ||
1da177e4 LT |
479 | case ACPI_TYPE_LOCAL_BANK_FIELD: |
480 | ||
4be44fcd LB |
481 | obj_desc->bank_field.value = info->bank_value; |
482 | obj_desc->bank_field.region_obj = | |
483 | acpi_ns_get_attached_object(info->region_node); | |
484 | obj_desc->bank_field.bank_obj = | |
485 | acpi_ns_get_attached_object(info->register_node); | |
1da177e4 LT |
486 | |
487 | /* An additional reference for the attached objects */ | |
488 | ||
4be44fcd LB |
489 | acpi_ut_add_reference(obj_desc->bank_field.region_obj); |
490 | acpi_ut_add_reference(obj_desc->bank_field.bank_obj); | |
1da177e4 | 491 | |
4be44fcd | 492 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 493 | "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n", |
4be44fcd LB |
494 | obj_desc->bank_field.start_field_bit_offset, |
495 | obj_desc->bank_field.base_byte_offset, | |
496 | obj_desc->field.access_byte_width, | |
497 | obj_desc->bank_field.region_obj, | |
498 | obj_desc->bank_field.bank_obj)); | |
ef805d95 LM |
499 | |
500 | /* | |
501 | * Remember location in AML stream of the field unit | |
502 | * opcode and operands -- since the bank_value | |
503 | * operands must be evaluated. | |
504 | */ | |
505 | second_desc = obj_desc->common.next_object; | |
506 | second_desc->extra.aml_start = | |
b5243764 BM |
507 | ACPI_CAST_PTR(union acpi_parse_object, |
508 | info->data_register_node)->named.data; | |
ef805d95 | 509 | second_desc->extra.aml_length = |
b5243764 BM |
510 | ACPI_CAST_PTR(union acpi_parse_object, |
511 | info->data_register_node)->named.length; | |
ef805d95 | 512 | |
1da177e4 LT |
513 | break; |
514 | ||
1da177e4 LT |
515 | case ACPI_TYPE_LOCAL_INDEX_FIELD: |
516 | ||
b8e4d893 BM |
517 | /* Get the Index and Data registers */ |
518 | ||
4be44fcd LB |
519 | obj_desc->index_field.index_obj = |
520 | acpi_ns_get_attached_object(info->register_node); | |
521 | obj_desc->index_field.data_obj = | |
522 | acpi_ns_get_attached_object(info->data_register_node); | |
4be44fcd LB |
523 | |
524 | if (!obj_desc->index_field.data_obj | |
525 | || !obj_desc->index_field.index_obj) { | |
b8e4d893 BM |
526 | ACPI_ERROR((AE_INFO, |
527 | "Null Index Object during field prep")); | |
4be44fcd LB |
528 | acpi_ut_delete_object_desc(obj_desc); |
529 | return_ACPI_STATUS(AE_AML_INTERNAL); | |
1da177e4 LT |
530 | } |
531 | ||
532 | /* An additional reference for the attached objects */ | |
533 | ||
4be44fcd LB |
534 | acpi_ut_add_reference(obj_desc->index_field.data_obj); |
535 | acpi_ut_add_reference(obj_desc->index_field.index_obj); | |
536 | ||
b8e4d893 | 537 | /* |
b229cf92 | 538 | * April 2006: Changed to match MS behavior |
ea936b78 | 539 | * |
b8e4d893 | 540 | * The value written to the Index register is the byte offset of the |
b229cf92 | 541 | * target field in units of the granularity of the index_field |
ea936b78 BM |
542 | * |
543 | * Previously, the value was calculated as an index in terms of the | |
544 | * width of the Data register, as below: | |
545 | * | |
b229cf92 BM |
546 | * obj_desc->index_field.Value = (u32) |
547 | * (Info->field_bit_position / ACPI_MUL_8 ( | |
548 | * obj_desc->Field.access_byte_width)); | |
549 | * | |
550 | * February 2006: Tried value as a byte offset: | |
551 | * obj_desc->index_field.Value = (u32) | |
552 | * ACPI_DIV_8 (Info->field_bit_position); | |
b8e4d893 | 553 | */ |
ea936b78 | 554 | obj_desc->index_field.value = |
b229cf92 BM |
555 | (u32) ACPI_ROUND_DOWN(ACPI_DIV_8(info->field_bit_position), |
556 | obj_desc->index_field. | |
557 | access_byte_width); | |
b8e4d893 | 558 | |
4be44fcd | 559 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 560 | "IndexField: BitOff %X, Off %X, Value %X, Gran %X, Index %p, Data %p\n", |
4be44fcd LB |
561 | obj_desc->index_field.start_field_bit_offset, |
562 | obj_desc->index_field.base_byte_offset, | |
563 | obj_desc->index_field.value, | |
564 | obj_desc->field.access_byte_width, | |
565 | obj_desc->index_field.index_obj, | |
566 | obj_desc->index_field.data_obj)); | |
1da177e4 LT |
567 | break; |
568 | ||
569 | default: | |
570 | /* No other types should get here */ | |
571 | break; | |
572 | } | |
573 | ||
574 | /* | |
575 | * Store the constructed descriptor (obj_desc) into the parent Node, | |
576 | * preserving the current type of that named_obj. | |
577 | */ | |
4be44fcd LB |
578 | status = acpi_ns_attach_object(info->field_node, obj_desc, |
579 | acpi_ns_get_type(info->field_node)); | |
1da177e4 | 580 | |
4be44fcd | 581 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 582 | "Set NamedObj %p [%4.4s], ObjDesc %p\n", |
4be44fcd LB |
583 | info->field_node, |
584 | acpi_ut_get_node_name(info->field_node), obj_desc)); | |
1da177e4 LT |
585 | |
586 | /* Remove local reference to the object */ | |
587 | ||
4be44fcd LB |
588 | acpi_ut_remove_reference(obj_desc); |
589 | return_ACPI_STATUS(status); | |
1da177e4 | 590 | } |