]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /****************************************************************************** |
2 | * | |
1fad8738 | 3 | * Module Name: exprep - ACPI AML field prep utilities |
1da177e4 LT |
4 | * |
5 | *****************************************************************************/ | |
6 | ||
7 | /* | |
c8100dc4 | 8 | * Copyright (C) 2000 - 2016, Intel Corp. |
1da177e4 LT |
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 | ||
1da177e4 | 44 | #include <acpi/acpi.h> |
e2f7a777 LB |
45 | #include "accommon.h" |
46 | #include "acinterp.h" | |
47 | #include "amlcode.h" | |
48 | #include "acnamesp.h" | |
9ce81784 | 49 | #include "acdispat.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 | |
73a3090a BM |
80 | * conditions (end-of-region). However, the region_length is a deferred |
81 | * operation. Therefore, to complete this implementation, the generation | |
1da177e4 LT |
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 | 105 | field_byte_offset = ACPI_DIV_8(ACPI_ROUND_DOWN(field_bit_offset, 8)); |
1fad8738 BM |
106 | |
107 | field_byte_end_offset = | |
108 | ACPI_DIV_8(ACPI_ROUND_UP(field_bit_length + field_bit_offset, 8)); | |
109 | ||
4be44fcd | 110 | field_byte_length = field_byte_end_offset - field_byte_offset; |
1da177e4 | 111 | |
4be44fcd | 112 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b27d6597 | 113 | "Bit length %u, Bit offset %u\n", |
4be44fcd | 114 | field_bit_length, field_bit_offset)); |
44f6c012 | 115 | |
4be44fcd | 116 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b27d6597 | 117 | "Byte Length %u, Byte Offset %u, End Offset %u\n", |
4be44fcd LB |
118 | field_byte_length, field_byte_offset, |
119 | field_byte_end_offset)); | |
1da177e4 LT |
120 | |
121 | /* | |
122 | * Iterative search for the maximum access width that is both aligned | |
123 | * and does not go beyond the end of the region | |
124 | * | |
125 | * Start at byte_acc and work upwards to qword_acc max. (1,2,4,8 bytes) | |
126 | */ | |
4be44fcd LB |
127 | for (access_byte_width = 1; access_byte_width <= 8; |
128 | access_byte_width <<= 1) { | |
1da177e4 | 129 | /* |
44f6c012 RM |
130 | * 1) Round end offset up to next access boundary and make sure that |
131 | * this does not go beyond the end of the parent region. | |
132 | * 2) When the Access width is greater than the field_byte_length, we | |
133 | * are done. (This does not optimize for the perfectly aligned | |
134 | * case yet). | |
1da177e4 | 135 | */ |
4be44fcd LB |
136 | if (ACPI_ROUND_UP(field_byte_end_offset, access_byte_width) <= |
137 | region_length) { | |
44f6c012 | 138 | field_start_offset = |
4be44fcd LB |
139 | ACPI_ROUND_DOWN(field_byte_offset, |
140 | access_byte_width) / | |
141 | access_byte_width; | |
44f6c012 RM |
142 | |
143 | field_end_offset = | |
4be44fcd LB |
144 | ACPI_ROUND_UP((field_byte_length + |
145 | field_byte_offset), | |
146 | access_byte_width) / | |
147 | access_byte_width; | |
44f6c012 RM |
148 | |
149 | accesses = field_end_offset - field_start_offset; | |
1da177e4 | 150 | |
4be44fcd | 151 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b27d6597 | 152 | "AccessWidth %u end is within region\n", |
4be44fcd | 153 | access_byte_width)); |
44f6c012 | 154 | |
4be44fcd | 155 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b27d6597 | 156 | "Field Start %u, Field End %u -- requires %u accesses\n", |
4be44fcd LB |
157 | field_start_offset, field_end_offset, |
158 | accesses)); | |
1da177e4 LT |
159 | |
160 | /* Single access is optimal */ | |
161 | ||
162 | if (accesses <= 1) { | |
4be44fcd | 163 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
1fad8738 BM |
164 | "Entire field can be accessed " |
165 | "with one operation of size %u\n", | |
4be44fcd LB |
166 | access_byte_width)); |
167 | return_VALUE(access_byte_width); | |
1da177e4 LT |
168 | } |
169 | ||
170 | /* | |
171 | * Fits in the region, but requires more than one read/write. | |
172 | * try the next wider access on next iteration | |
173 | */ | |
174 | if (accesses < minimum_accesses) { | |
4be44fcd | 175 | minimum_accesses = accesses; |
1da177e4 LT |
176 | minimum_access_width = access_byte_width; |
177 | } | |
4be44fcd LB |
178 | } else { |
179 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, | |
b27d6597 | 180 | "AccessWidth %u end is NOT within region\n", |
4be44fcd | 181 | access_byte_width)); |
1da177e4 | 182 | if (access_byte_width == 1) { |
4be44fcd LB |
183 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
184 | "Field goes beyond end-of-region!\n")); | |
1da177e4 | 185 | |
44f6c012 | 186 | /* Field does not fit in the region at all */ |
1da177e4 | 187 | |
4be44fcd | 188 | return_VALUE(0); |
44f6c012 RM |
189 | } |
190 | ||
191 | /* | |
192 | * This width goes beyond the end-of-region, back off to | |
193 | * previous access | |
194 | */ | |
4be44fcd | 195 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b27d6597 | 196 | "Backing off to previous optimal access width of %u\n", |
4be44fcd LB |
197 | minimum_access_width)); |
198 | return_VALUE(minimum_access_width); | |
1da177e4 LT |
199 | } |
200 | } | |
201 | ||
44f6c012 RM |
202 | /* |
203 | * Could not read/write field with one operation, | |
204 | * just use max access width | |
205 | */ | |
4be44fcd LB |
206 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
207 | "Cannot access field in one operation, using width 8\n")); | |
1fad8738 | 208 | |
4be44fcd | 209 | return_VALUE(8); |
1da177e4 | 210 | } |
4be44fcd | 211 | #endif /* ACPI_UNDER_DEVELOPMENT */ |
1da177e4 LT |
212 | |
213 | /******************************************************************************* | |
214 | * | |
215 | * FUNCTION: acpi_ex_decode_field_access | |
216 | * | |
44f6c012 RM |
217 | * PARAMETERS: obj_desc - Field object |
218 | * field_flags - Encoded fieldflags (contains access bits) | |
219 | * return_byte_alignment - Where the byte alignment is returned | |
1da177e4 LT |
220 | * |
221 | * RETURN: Field granularity (8, 16, 32 or 64) and | |
222 | * byte_alignment (1, 2, 3, or 4) | |
223 | * | |
224 | * DESCRIPTION: Decode the access_type bits of a field definition. | |
225 | * | |
226 | ******************************************************************************/ | |
227 | ||
228 | static u32 | |
4be44fcd LB |
229 | acpi_ex_decode_field_access(union acpi_operand_object *obj_desc, |
230 | u8 field_flags, u32 * return_byte_alignment) | |
1da177e4 | 231 | { |
4be44fcd LB |
232 | u32 access; |
233 | u32 byte_alignment; | |
234 | u32 bit_length; | |
1da177e4 | 235 | |
b229cf92 | 236 | ACPI_FUNCTION_TRACE(ex_decode_field_access); |
1da177e4 LT |
237 | |
238 | access = (field_flags & AML_FIELD_ACCESS_TYPE_MASK); | |
239 | ||
240 | switch (access) { | |
241 | case AML_FIELD_ACCESS_ANY: | |
242 | ||
243 | #ifdef ACPI_UNDER_DEVELOPMENT | |
44f6c012 | 244 | byte_alignment = |
4be44fcd LB |
245 | acpi_ex_generate_access(obj_desc->common_field. |
246 | start_field_bit_offset, | |
247 | obj_desc->common_field.bit_length, | |
248 | 0xFFFFFFFF | |
249 | /* Temp until we pass region_length as parameter */ | |
fd350943 | 250 | ); |
1da177e4 LT |
251 | bit_length = byte_alignment * 8; |
252 | #endif | |
253 | ||
254 | byte_alignment = 1; | |
255 | bit_length = 8; | |
256 | break; | |
257 | ||
258 | case AML_FIELD_ACCESS_BYTE: | |
4be44fcd | 259 | case AML_FIELD_ACCESS_BUFFER: /* ACPI 2.0 (SMBus Buffer) */ |
1d1ea1b7 | 260 | |
1da177e4 | 261 | byte_alignment = 1; |
4be44fcd | 262 | bit_length = 8; |
1da177e4 LT |
263 | break; |
264 | ||
265 | case AML_FIELD_ACCESS_WORD: | |
1d1ea1b7 | 266 | |
1da177e4 | 267 | byte_alignment = 2; |
4be44fcd | 268 | bit_length = 16; |
1da177e4 LT |
269 | break; |
270 | ||
271 | case AML_FIELD_ACCESS_DWORD: | |
1d1ea1b7 | 272 | |
1da177e4 | 273 | byte_alignment = 4; |
4be44fcd | 274 | bit_length = 32; |
1da177e4 LT |
275 | break; |
276 | ||
4be44fcd | 277 | case AML_FIELD_ACCESS_QWORD: /* ACPI 2.0 */ |
1d1ea1b7 | 278 | |
1da177e4 | 279 | byte_alignment = 8; |
4be44fcd | 280 | bit_length = 64; |
1da177e4 LT |
281 | break; |
282 | ||
283 | default: | |
1d1ea1b7 | 284 | |
1da177e4 LT |
285 | /* Invalid field access type */ |
286 | ||
f6a22b0b | 287 | ACPI_ERROR((AE_INFO, "Unknown field access type 0x%X", access)); |
1fad8738 | 288 | |
fd1af712 | 289 | return_UINT32(0); |
1da177e4 LT |
290 | } |
291 | ||
3371c19c | 292 | if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) { |
1da177e4 LT |
293 | /* |
294 | * buffer_field access can be on any byte boundary, so the | |
295 | * byte_alignment is always 1 byte -- regardless of any byte_alignment | |
296 | * implied by the field access type. | |
297 | */ | |
298 | byte_alignment = 1; | |
299 | } | |
300 | ||
301 | *return_byte_alignment = byte_alignment; | |
fd1af712 | 302 | return_UINT32(bit_length); |
1da177e4 LT |
303 | } |
304 | ||
1da177e4 LT |
305 | /******************************************************************************* |
306 | * | |
307 | * FUNCTION: acpi_ex_prep_common_field_object | |
308 | * | |
309 | * PARAMETERS: obj_desc - The field object | |
310 | * field_flags - Access, lock_rule, and update_rule. | |
311 | * The format of a field_flag is described | |
312 | * in the ACPI specification | |
44f6c012 | 313 | * field_attribute - Special attributes (not used) |
1da177e4 LT |
314 | * field_bit_position - Field start position |
315 | * field_bit_length - Field length in number of bits | |
316 | * | |
317 | * RETURN: Status | |
318 | * | |
319 | * DESCRIPTION: Initialize the areas of the field object that are common | |
73a3090a | 320 | * to the various types of fields. Note: This is very "sensitive" |
1da177e4 LT |
321 | * code because we are solving the general case for field |
322 | * alignment. | |
323 | * | |
324 | ******************************************************************************/ | |
325 | ||
326 | acpi_status | |
4be44fcd LB |
327 | acpi_ex_prep_common_field_object(union acpi_operand_object *obj_desc, |
328 | u8 field_flags, | |
329 | u8 field_attribute, | |
330 | u32 field_bit_position, u32 field_bit_length) | |
1da177e4 | 331 | { |
4be44fcd LB |
332 | u32 access_bit_width; |
333 | u32 byte_alignment; | |
334 | u32 nearest_byte_address; | |
1da177e4 | 335 | |
b229cf92 | 336 | ACPI_FUNCTION_TRACE(ex_prep_common_field_object); |
1da177e4 LT |
337 | |
338 | /* | |
339 | * Note: the structure being initialized is the | |
340 | * ACPI_COMMON_FIELD_INFO; No structure fields outside of the common | |
341 | * area are initialized by this procedure. | |
342 | */ | |
343 | obj_desc->common_field.field_flags = field_flags; | |
344 | obj_desc->common_field.attribute = field_attribute; | |
345 | obj_desc->common_field.bit_length = field_bit_length; | |
346 | ||
347 | /* | |
73a3090a | 348 | * Decode the access type so we can compute offsets. The access type gives |
1da177e4 LT |
349 | * two pieces of information - the width of each field access and the |
350 | * necessary byte_alignment (address granularity) of the access. | |
351 | * | |
352 | * For any_acc, the access_bit_width is the largest width that is both | |
353 | * necessary and possible in an attempt to access the whole field in one | |
73a3090a | 354 | * I/O operation. However, for any_acc, the byte_alignment is always one |
1da177e4 LT |
355 | * byte. |
356 | * | |
357 | * For all Buffer Fields, the byte_alignment is always one byte. | |
358 | * | |
359 | * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is | |
360 | * the same (equivalent) as the byte_alignment. | |
361 | */ | |
1fad8738 BM |
362 | access_bit_width = |
363 | acpi_ex_decode_field_access(obj_desc, field_flags, &byte_alignment); | |
1da177e4 | 364 | if (!access_bit_width) { |
4be44fcd | 365 | return_ACPI_STATUS(AE_AML_OPERAND_VALUE); |
1da177e4 LT |
366 | } |
367 | ||
09387b43 | 368 | /* Setup width (access granularity) fields (values are: 1, 2, 4, 8) */ |
1da177e4 LT |
369 | |
370 | obj_desc->common_field.access_byte_width = (u8) | |
09387b43 | 371 | ACPI_DIV_8(access_bit_width); |
1da177e4 LT |
372 | |
373 | /* | |
374 | * base_byte_offset is the address of the start of the field within the | |
73a3090a | 375 | * region. It is the byte address of the first *datum* (field-width data |
1da177e4 LT |
376 | * unit) of the field. (i.e., the first datum that contains at least the |
377 | * first *bit* of the field.) | |
378 | * | |
379 | * Note: byte_alignment is always either equal to the access_bit_width or 8 | |
380 | * (Byte access), and it defines the addressing granularity of the parent | |
381 | * region or buffer. | |
382 | */ | |
383 | nearest_byte_address = | |
4be44fcd | 384 | ACPI_ROUND_BITS_DOWN_TO_BYTES(field_bit_position); |
1da177e4 | 385 | obj_desc->common_field.base_byte_offset = (u32) |
4be44fcd | 386 | ACPI_ROUND_DOWN(nearest_byte_address, byte_alignment); |
1da177e4 LT |
387 | |
388 | /* | |
389 | * start_field_bit_offset is the offset of the first bit of the field within | |
390 | * a field datum. | |
391 | */ | |
392 | obj_desc->common_field.start_field_bit_offset = (u8) | |
4be44fcd LB |
393 | (field_bit_position - |
394 | ACPI_MUL_8(obj_desc->common_field.base_byte_offset)); | |
1da177e4 | 395 | |
4be44fcd | 396 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
397 | } |
398 | ||
1da177e4 LT |
399 | /******************************************************************************* |
400 | * | |
401 | * FUNCTION: acpi_ex_prep_field_value | |
402 | * | |
ba494bee | 403 | * PARAMETERS: info - Contains all field creation info |
1da177e4 LT |
404 | * |
405 | * RETURN: Status | |
406 | * | |
cf48958e BM |
407 | * DESCRIPTION: Construct an object of type union acpi_operand_object with a |
408 | * subtype of def_field and connect it to the parent Node. | |
1da177e4 LT |
409 | * |
410 | ******************************************************************************/ | |
411 | ||
4be44fcd | 412 | acpi_status acpi_ex_prep_field_value(struct acpi_create_field_info *info) |
1da177e4 | 413 | { |
4be44fcd | 414 | union acpi_operand_object *obj_desc; |
ef805d95 | 415 | union acpi_operand_object *second_desc = NULL; |
4be44fcd | 416 | acpi_status status; |
09387b43 BM |
417 | u32 access_byte_width; |
418 | u32 type; | |
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 | 432 | ACPI_ERROR((AE_INFO, |
09387b43 BM |
433 | "Needed Region, found type 0x%X (%s)", type, |
434 | 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; | |
09387b43 BM |
450 | status = acpi_ex_prep_common_field_object(obj_desc, |
451 | info->field_flags, | |
4be44fcd LB |
452 | info->attribute, |
453 | info->field_bit_position, | |
454 | info->field_bit_length); | |
455 | if (ACPI_FAILURE(status)) { | |
456 | acpi_ut_delete_object_desc(obj_desc); | |
457 | return_ACPI_STATUS(status); | |
1da177e4 LT |
458 | } |
459 | ||
460 | /* Initialize areas of the object that are specific to the field type */ | |
461 | ||
462 | switch (info->field_type) { | |
463 | case ACPI_TYPE_LOCAL_REGION_FIELD: | |
464 | ||
4be44fcd LB |
465 | obj_desc->field.region_obj = |
466 | acpi_ns_get_attached_object(info->region_node); | |
1da177e4 | 467 | |
9ce81784 BM |
468 | /* Fields specific to generic_serial_bus fields */ |
469 | ||
470 | obj_desc->field.access_length = info->access_length; | |
471 | ||
472 | if (info->connection_node) { | |
473 | second_desc = info->connection_node->object; | |
474 | if (!(second_desc->common.flags & AOPOBJ_DATA_VALID)) { | |
475 | status = | |
476 | acpi_ds_get_buffer_arguments(second_desc); | |
477 | if (ACPI_FAILURE(status)) { | |
478 | acpi_ut_delete_object_desc(obj_desc); | |
479 | return_ACPI_STATUS(status); | |
480 | } | |
481 | } | |
482 | ||
483 | obj_desc->field.resource_buffer = | |
484 | second_desc->buffer.pointer; | |
485 | obj_desc->field.resource_length = | |
486 | (u16)second_desc->buffer.length; | |
487 | } else if (info->resource_buffer) { | |
488 | obj_desc->field.resource_buffer = info->resource_buffer; | |
489 | obj_desc->field.resource_length = info->resource_length; | |
490 | } | |
491 | ||
75ec6e55 BM |
492 | obj_desc->field.pin_number_index = info->pin_number_index; |
493 | ||
09387b43 | 494 | /* Allow full data read from EC address space */ |
1da177e4 | 495 | |
09387b43 BM |
496 | if ((obj_desc->field.region_obj->region.space_id == |
497 | ACPI_ADR_SPACE_EC) | |
498 | && (obj_desc->common_field.bit_length > 8)) { | |
499 | access_byte_width = | |
500 | ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->common_field. | |
501 | bit_length); | |
502 | ||
503 | /* Maximum byte width supported is 255 */ | |
1da177e4 | 504 | |
09387b43 | 505 | if (access_byte_width < 256) { |
dadf28a1 | 506 | obj_desc->common_field.access_byte_width = |
09387b43 | 507 | (u8)access_byte_width; |
2060c445 | 508 | } |
dadf28a1 | 509 | } |
09387b43 BM |
510 | /* An additional reference for the container */ |
511 | ||
512 | acpi_ut_add_reference(obj_desc->field.region_obj); | |
dadf28a1 | 513 | |
4be44fcd | 514 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 515 | "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n", |
4be44fcd LB |
516 | obj_desc->field.start_field_bit_offset, |
517 | obj_desc->field.base_byte_offset, | |
518 | obj_desc->field.access_byte_width, | |
519 | obj_desc->field.region_obj)); | |
1da177e4 LT |
520 | break; |
521 | ||
1da177e4 LT |
522 | case ACPI_TYPE_LOCAL_BANK_FIELD: |
523 | ||
4be44fcd LB |
524 | obj_desc->bank_field.value = info->bank_value; |
525 | obj_desc->bank_field.region_obj = | |
526 | acpi_ns_get_attached_object(info->region_node); | |
527 | obj_desc->bank_field.bank_obj = | |
528 | acpi_ns_get_attached_object(info->register_node); | |
1da177e4 LT |
529 | |
530 | /* An additional reference for the attached objects */ | |
531 | ||
4be44fcd LB |
532 | acpi_ut_add_reference(obj_desc->bank_field.region_obj); |
533 | acpi_ut_add_reference(obj_desc->bank_field.bank_obj); | |
1da177e4 | 534 | |
4be44fcd | 535 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 536 | "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n", |
4be44fcd LB |
537 | obj_desc->bank_field.start_field_bit_offset, |
538 | obj_desc->bank_field.base_byte_offset, | |
539 | obj_desc->field.access_byte_width, | |
540 | obj_desc->bank_field.region_obj, | |
541 | obj_desc->bank_field.bank_obj)); | |
ef805d95 LM |
542 | |
543 | /* | |
544 | * Remember location in AML stream of the field unit | |
545 | * opcode and operands -- since the bank_value | |
546 | * operands must be evaluated. | |
547 | */ | |
548 | second_desc = obj_desc->common.next_object; | |
549 | second_desc->extra.aml_start = | |
b5243764 BM |
550 | ACPI_CAST_PTR(union acpi_parse_object, |
551 | info->data_register_node)->named.data; | |
ef805d95 | 552 | second_desc->extra.aml_length = |
b5243764 BM |
553 | ACPI_CAST_PTR(union acpi_parse_object, |
554 | info->data_register_node)->named.length; | |
ef805d95 | 555 | |
1da177e4 LT |
556 | break; |
557 | ||
1da177e4 LT |
558 | case ACPI_TYPE_LOCAL_INDEX_FIELD: |
559 | ||
b8e4d893 BM |
560 | /* Get the Index and Data registers */ |
561 | ||
4be44fcd LB |
562 | obj_desc->index_field.index_obj = |
563 | acpi_ns_get_attached_object(info->register_node); | |
564 | obj_desc->index_field.data_obj = | |
565 | acpi_ns_get_attached_object(info->data_register_node); | |
4be44fcd LB |
566 | |
567 | if (!obj_desc->index_field.data_obj | |
568 | || !obj_desc->index_field.index_obj) { | |
b8e4d893 BM |
569 | ACPI_ERROR((AE_INFO, |
570 | "Null Index Object during field prep")); | |
4be44fcd LB |
571 | acpi_ut_delete_object_desc(obj_desc); |
572 | return_ACPI_STATUS(AE_AML_INTERNAL); | |
1da177e4 LT |
573 | } |
574 | ||
575 | /* An additional reference for the attached objects */ | |
576 | ||
4be44fcd LB |
577 | acpi_ut_add_reference(obj_desc->index_field.data_obj); |
578 | acpi_ut_add_reference(obj_desc->index_field.index_obj); | |
579 | ||
b8e4d893 | 580 | /* |
b229cf92 | 581 | * April 2006: Changed to match MS behavior |
ea936b78 | 582 | * |
b8e4d893 | 583 | * The value written to the Index register is the byte offset of the |
b229cf92 | 584 | * target field in units of the granularity of the index_field |
ea936b78 BM |
585 | * |
586 | * Previously, the value was calculated as an index in terms of the | |
587 | * width of the Data register, as below: | |
588 | * | |
b229cf92 BM |
589 | * obj_desc->index_field.Value = (u32) |
590 | * (Info->field_bit_position / ACPI_MUL_8 ( | |
591 | * obj_desc->Field.access_byte_width)); | |
592 | * | |
593 | * February 2006: Tried value as a byte offset: | |
594 | * obj_desc->index_field.Value = (u32) | |
595 | * ACPI_DIV_8 (Info->field_bit_position); | |
b8e4d893 | 596 | */ |
ea936b78 | 597 | obj_desc->index_field.value = |
b229cf92 BM |
598 | (u32) ACPI_ROUND_DOWN(ACPI_DIV_8(info->field_bit_position), |
599 | obj_desc->index_field. | |
600 | access_byte_width); | |
b8e4d893 | 601 | |
4be44fcd | 602 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
1fad8738 BM |
603 | "IndexField: BitOff %X, Off %X, Value %X, " |
604 | "Gran %X, Index %p, Data %p\n", | |
4be44fcd LB |
605 | obj_desc->index_field.start_field_bit_offset, |
606 | obj_desc->index_field.base_byte_offset, | |
607 | obj_desc->index_field.value, | |
608 | obj_desc->field.access_byte_width, | |
609 | obj_desc->index_field.index_obj, | |
610 | obj_desc->index_field.data_obj)); | |
1da177e4 LT |
611 | break; |
612 | ||
613 | default: | |
1d1ea1b7 | 614 | |
1da177e4 | 615 | /* No other types should get here */ |
1d1ea1b7 | 616 | |
1da177e4 LT |
617 | break; |
618 | } | |
619 | ||
620 | /* | |
621 | * Store the constructed descriptor (obj_desc) into the parent Node, | |
622 | * preserving the current type of that named_obj. | |
623 | */ | |
1fad8738 BM |
624 | status = |
625 | acpi_ns_attach_object(info->field_node, obj_desc, | |
626 | acpi_ns_get_type(info->field_node)); | |
1da177e4 | 627 | |
4be44fcd | 628 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 629 | "Set NamedObj %p [%4.4s], ObjDesc %p\n", |
4be44fcd LB |
630 | info->field_node, |
631 | acpi_ut_get_node_name(info->field_node), obj_desc)); | |
1da177e4 LT |
632 | |
633 | /* Remove local reference to the object */ | |
634 | ||
4be44fcd LB |
635 | acpi_ut_remove_reference(obj_desc); |
636 | return_ACPI_STATUS(status); | |
1da177e4 | 637 | } |