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