Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /****************************************************************************** |
2 | * | |
3 | * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities | |
4 | * | |
5 | *****************************************************************************/ | |
6 | ||
7 | /* | |
82a80941 | 8 | * Copyright (C) 2000 - 2015, 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 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 | 110 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b27d6597 | 111 | "Bit length %u, Bit offset %u\n", |
4be44fcd | 112 | field_bit_length, field_bit_offset)); |
44f6c012 | 113 | |
4be44fcd | 114 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b27d6597 | 115 | "Byte Length %u, Byte Offset %u, End Offset %u\n", |
4be44fcd LB |
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, |
b27d6597 | 150 | "AccessWidth %u end is within region\n", |
4be44fcd | 151 | access_byte_width)); |
44f6c012 | 152 | |
4be44fcd | 153 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b27d6597 | 154 | "Field Start %u, Field End %u -- requires %u accesses\n", |
4be44fcd LB |
155 | field_start_offset, field_end_offset, |
156 | accesses)); | |
1da177e4 LT |
157 | |
158 | /* Single access is optimal */ | |
159 | ||
160 | if (accesses <= 1) { | |
4be44fcd | 161 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b27d6597 | 162 | "Entire field can be accessed with one operation of size %u\n", |
4be44fcd LB |
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, | |
b27d6597 | 177 | "AccessWidth %u 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 | 192 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b27d6597 | 193 | "Backing off to previous optimal access width of %u\n", |
4be44fcd LB |
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) */ |
1d1ea1b7 | 256 | |
1da177e4 | 257 | byte_alignment = 1; |
4be44fcd | 258 | bit_length = 8; |
1da177e4 LT |
259 | break; |
260 | ||
261 | case AML_FIELD_ACCESS_WORD: | |
1d1ea1b7 | 262 | |
1da177e4 | 263 | byte_alignment = 2; |
4be44fcd | 264 | bit_length = 16; |
1da177e4 LT |
265 | break; |
266 | ||
267 | case AML_FIELD_ACCESS_DWORD: | |
1d1ea1b7 | 268 | |
1da177e4 | 269 | byte_alignment = 4; |
4be44fcd | 270 | bit_length = 32; |
1da177e4 LT |
271 | break; |
272 | ||
4be44fcd | 273 | case AML_FIELD_ACCESS_QWORD: /* ACPI 2.0 */ |
1d1ea1b7 | 274 | |
1da177e4 | 275 | byte_alignment = 8; |
4be44fcd | 276 | bit_length = 64; |
1da177e4 LT |
277 | break; |
278 | ||
279 | default: | |
1d1ea1b7 | 280 | |
1da177e4 LT |
281 | /* Invalid field access type */ |
282 | ||
f6a22b0b | 283 | ACPI_ERROR((AE_INFO, "Unknown field access type 0x%X", access)); |
fd1af712 | 284 | return_UINT32(0); |
1da177e4 LT |
285 | } |
286 | ||
3371c19c | 287 | if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) { |
1da177e4 LT |
288 | /* |
289 | * buffer_field access can be on any byte boundary, so the | |
290 | * byte_alignment is always 1 byte -- regardless of any byte_alignment | |
291 | * implied by the field access type. | |
292 | */ | |
293 | byte_alignment = 1; | |
294 | } | |
295 | ||
296 | *return_byte_alignment = byte_alignment; | |
fd1af712 | 297 | return_UINT32(bit_length); |
1da177e4 LT |
298 | } |
299 | ||
1da177e4 LT |
300 | /******************************************************************************* |
301 | * | |
302 | * FUNCTION: acpi_ex_prep_common_field_object | |
303 | * | |
304 | * PARAMETERS: obj_desc - The field object | |
305 | * field_flags - Access, lock_rule, and update_rule. | |
306 | * The format of a field_flag is described | |
307 | * in the ACPI specification | |
44f6c012 | 308 | * field_attribute - Special attributes (not used) |
1da177e4 LT |
309 | * field_bit_position - Field start position |
310 | * field_bit_length - Field length in number of bits | |
311 | * | |
312 | * RETURN: Status | |
313 | * | |
314 | * DESCRIPTION: Initialize the areas of the field object that are common | |
73a3090a | 315 | * to the various types of fields. Note: This is very "sensitive" |
1da177e4 LT |
316 | * code because we are solving the general case for field |
317 | * alignment. | |
318 | * | |
319 | ******************************************************************************/ | |
320 | ||
321 | acpi_status | |
4be44fcd LB |
322 | acpi_ex_prep_common_field_object(union acpi_operand_object *obj_desc, |
323 | u8 field_flags, | |
324 | u8 field_attribute, | |
325 | u32 field_bit_position, u32 field_bit_length) | |
1da177e4 | 326 | { |
4be44fcd LB |
327 | u32 access_bit_width; |
328 | u32 byte_alignment; | |
329 | u32 nearest_byte_address; | |
1da177e4 | 330 | |
b229cf92 | 331 | ACPI_FUNCTION_TRACE(ex_prep_common_field_object); |
1da177e4 LT |
332 | |
333 | /* | |
334 | * Note: the structure being initialized is the | |
335 | * ACPI_COMMON_FIELD_INFO; No structure fields outside of the common | |
336 | * area are initialized by this procedure. | |
337 | */ | |
338 | obj_desc->common_field.field_flags = field_flags; | |
339 | obj_desc->common_field.attribute = field_attribute; | |
340 | obj_desc->common_field.bit_length = field_bit_length; | |
341 | ||
342 | /* | |
73a3090a | 343 | * Decode the access type so we can compute offsets. The access type gives |
1da177e4 LT |
344 | * two pieces of information - the width of each field access and the |
345 | * necessary byte_alignment (address granularity) of the access. | |
346 | * | |
347 | * For any_acc, the access_bit_width is the largest width that is both | |
348 | * necessary and possible in an attempt to access the whole field in one | |
73a3090a | 349 | * I/O operation. However, for any_acc, the byte_alignment is always one |
1da177e4 LT |
350 | * byte. |
351 | * | |
352 | * For all Buffer Fields, the byte_alignment is always one byte. | |
353 | * | |
354 | * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is | |
355 | * the same (equivalent) as the byte_alignment. | |
356 | */ | |
4be44fcd LB |
357 | access_bit_width = acpi_ex_decode_field_access(obj_desc, field_flags, |
358 | &byte_alignment); | |
1da177e4 | 359 | if (!access_bit_width) { |
4be44fcd | 360 | return_ACPI_STATUS(AE_AML_OPERAND_VALUE); |
1da177e4 LT |
361 | } |
362 | ||
09387b43 | 363 | /* Setup width (access granularity) fields (values are: 1, 2, 4, 8) */ |
1da177e4 LT |
364 | |
365 | obj_desc->common_field.access_byte_width = (u8) | |
09387b43 | 366 | ACPI_DIV_8(access_bit_width); |
1da177e4 LT |
367 | |
368 | /* | |
369 | * base_byte_offset is the address of the start of the field within the | |
73a3090a | 370 | * region. It is the byte address of the first *datum* (field-width data |
1da177e4 LT |
371 | * unit) of the field. (i.e., the first datum that contains at least the |
372 | * first *bit* of the field.) | |
373 | * | |
374 | * Note: byte_alignment is always either equal to the access_bit_width or 8 | |
375 | * (Byte access), and it defines the addressing granularity of the parent | |
376 | * region or buffer. | |
377 | */ | |
378 | nearest_byte_address = | |
4be44fcd | 379 | ACPI_ROUND_BITS_DOWN_TO_BYTES(field_bit_position); |
1da177e4 | 380 | obj_desc->common_field.base_byte_offset = (u32) |
4be44fcd | 381 | ACPI_ROUND_DOWN(nearest_byte_address, byte_alignment); |
1da177e4 LT |
382 | |
383 | /* | |
384 | * start_field_bit_offset is the offset of the first bit of the field within | |
385 | * a field datum. | |
386 | */ | |
387 | obj_desc->common_field.start_field_bit_offset = (u8) | |
4be44fcd LB |
388 | (field_bit_position - |
389 | ACPI_MUL_8(obj_desc->common_field.base_byte_offset)); | |
1da177e4 | 390 | |
4be44fcd | 391 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
392 | } |
393 | ||
1da177e4 LT |
394 | /******************************************************************************* |
395 | * | |
396 | * FUNCTION: acpi_ex_prep_field_value | |
397 | * | |
ba494bee | 398 | * PARAMETERS: info - Contains all field creation info |
1da177e4 LT |
399 | * |
400 | * RETURN: Status | |
401 | * | |
cf48958e BM |
402 | * DESCRIPTION: Construct an object of type union acpi_operand_object with a |
403 | * subtype of def_field and connect it to the parent Node. | |
1da177e4 LT |
404 | * |
405 | ******************************************************************************/ | |
406 | ||
4be44fcd | 407 | acpi_status acpi_ex_prep_field_value(struct acpi_create_field_info *info) |
1da177e4 | 408 | { |
4be44fcd | 409 | union acpi_operand_object *obj_desc; |
ef805d95 | 410 | union acpi_operand_object *second_desc = NULL; |
4be44fcd | 411 | acpi_status status; |
09387b43 BM |
412 | u32 access_byte_width; |
413 | u32 type; | |
1da177e4 | 414 | |
b229cf92 | 415 | ACPI_FUNCTION_TRACE(ex_prep_field_value); |
1da177e4 LT |
416 | |
417 | /* Parameter validation */ | |
418 | ||
419 | if (info->field_type != ACPI_TYPE_LOCAL_INDEX_FIELD) { | |
420 | if (!info->region_node) { | |
b229cf92 | 421 | ACPI_ERROR((AE_INFO, "Null RegionNode")); |
4be44fcd | 422 | return_ACPI_STATUS(AE_AML_NO_OPERAND); |
1da177e4 LT |
423 | } |
424 | ||
4be44fcd | 425 | type = acpi_ns_get_type(info->region_node); |
1da177e4 | 426 | if (type != ACPI_TYPE_REGION) { |
b8e4d893 | 427 | ACPI_ERROR((AE_INFO, |
09387b43 BM |
428 | "Needed Region, found type 0x%X (%s)", type, |
429 | acpi_ut_get_type_name(type))); | |
1da177e4 | 430 | |
4be44fcd | 431 | return_ACPI_STATUS(AE_AML_OPERAND_TYPE); |
1da177e4 LT |
432 | } |
433 | } | |
434 | ||
435 | /* Allocate a new field object */ | |
436 | ||
4be44fcd | 437 | obj_desc = acpi_ut_create_internal_object(info->field_type); |
1da177e4 | 438 | if (!obj_desc) { |
4be44fcd | 439 | return_ACPI_STATUS(AE_NO_MEMORY); |
1da177e4 LT |
440 | } |
441 | ||
442 | /* Initialize areas of the object that are common to all fields */ | |
443 | ||
444 | obj_desc->common_field.node = info->field_node; | |
09387b43 BM |
445 | status = acpi_ex_prep_common_field_object(obj_desc, |
446 | info->field_flags, | |
4be44fcd LB |
447 | info->attribute, |
448 | info->field_bit_position, | |
449 | info->field_bit_length); | |
450 | if (ACPI_FAILURE(status)) { | |
451 | acpi_ut_delete_object_desc(obj_desc); | |
452 | return_ACPI_STATUS(status); | |
1da177e4 LT |
453 | } |
454 | ||
455 | /* Initialize areas of the object that are specific to the field type */ | |
456 | ||
457 | switch (info->field_type) { | |
458 | case ACPI_TYPE_LOCAL_REGION_FIELD: | |
459 | ||
4be44fcd LB |
460 | obj_desc->field.region_obj = |
461 | acpi_ns_get_attached_object(info->region_node); | |
1da177e4 | 462 | |
9ce81784 BM |
463 | /* Fields specific to generic_serial_bus fields */ |
464 | ||
465 | obj_desc->field.access_length = info->access_length; | |
466 | ||
467 | if (info->connection_node) { | |
468 | second_desc = info->connection_node->object; | |
469 | if (!(second_desc->common.flags & AOPOBJ_DATA_VALID)) { | |
470 | status = | |
471 | acpi_ds_get_buffer_arguments(second_desc); | |
472 | if (ACPI_FAILURE(status)) { | |
473 | acpi_ut_delete_object_desc(obj_desc); | |
474 | return_ACPI_STATUS(status); | |
475 | } | |
476 | } | |
477 | ||
478 | obj_desc->field.resource_buffer = | |
479 | second_desc->buffer.pointer; | |
480 | obj_desc->field.resource_length = | |
481 | (u16)second_desc->buffer.length; | |
482 | } else if (info->resource_buffer) { | |
483 | obj_desc->field.resource_buffer = info->resource_buffer; | |
484 | obj_desc->field.resource_length = info->resource_length; | |
485 | } | |
486 | ||
75ec6e55 BM |
487 | obj_desc->field.pin_number_index = info->pin_number_index; |
488 | ||
09387b43 | 489 | /* Allow full data read from EC address space */ |
1da177e4 | 490 | |
09387b43 BM |
491 | if ((obj_desc->field.region_obj->region.space_id == |
492 | ACPI_ADR_SPACE_EC) | |
493 | && (obj_desc->common_field.bit_length > 8)) { | |
494 | access_byte_width = | |
495 | ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->common_field. | |
496 | bit_length); | |
497 | ||
498 | /* Maximum byte width supported is 255 */ | |
1da177e4 | 499 | |
09387b43 | 500 | if (access_byte_width < 256) { |
dadf28a1 | 501 | obj_desc->common_field.access_byte_width = |
09387b43 | 502 | (u8)access_byte_width; |
2060c445 | 503 | } |
dadf28a1 | 504 | } |
09387b43 BM |
505 | /* An additional reference for the container */ |
506 | ||
507 | acpi_ut_add_reference(obj_desc->field.region_obj); | |
dadf28a1 | 508 | |
4be44fcd | 509 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 510 | "RegionField: BitOff %X, Off %X, Gran %X, Region %p\n", |
4be44fcd LB |
511 | obj_desc->field.start_field_bit_offset, |
512 | obj_desc->field.base_byte_offset, | |
513 | obj_desc->field.access_byte_width, | |
514 | obj_desc->field.region_obj)); | |
1da177e4 LT |
515 | break; |
516 | ||
1da177e4 LT |
517 | case ACPI_TYPE_LOCAL_BANK_FIELD: |
518 | ||
4be44fcd LB |
519 | obj_desc->bank_field.value = info->bank_value; |
520 | obj_desc->bank_field.region_obj = | |
521 | acpi_ns_get_attached_object(info->region_node); | |
522 | obj_desc->bank_field.bank_obj = | |
523 | acpi_ns_get_attached_object(info->register_node); | |
1da177e4 LT |
524 | |
525 | /* An additional reference for the attached objects */ | |
526 | ||
4be44fcd LB |
527 | acpi_ut_add_reference(obj_desc->bank_field.region_obj); |
528 | acpi_ut_add_reference(obj_desc->bank_field.bank_obj); | |
1da177e4 | 529 | |
4be44fcd | 530 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 531 | "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p\n", |
4be44fcd LB |
532 | obj_desc->bank_field.start_field_bit_offset, |
533 | obj_desc->bank_field.base_byte_offset, | |
534 | obj_desc->field.access_byte_width, | |
535 | obj_desc->bank_field.region_obj, | |
536 | obj_desc->bank_field.bank_obj)); | |
ef805d95 LM |
537 | |
538 | /* | |
539 | * Remember location in AML stream of the field unit | |
540 | * opcode and operands -- since the bank_value | |
541 | * operands must be evaluated. | |
542 | */ | |
543 | second_desc = obj_desc->common.next_object; | |
544 | second_desc->extra.aml_start = | |
b5243764 BM |
545 | ACPI_CAST_PTR(union acpi_parse_object, |
546 | info->data_register_node)->named.data; | |
ef805d95 | 547 | second_desc->extra.aml_length = |
b5243764 BM |
548 | ACPI_CAST_PTR(union acpi_parse_object, |
549 | info->data_register_node)->named.length; | |
ef805d95 | 550 | |
1da177e4 LT |
551 | break; |
552 | ||
1da177e4 LT |
553 | case ACPI_TYPE_LOCAL_INDEX_FIELD: |
554 | ||
b8e4d893 BM |
555 | /* Get the Index and Data registers */ |
556 | ||
4be44fcd LB |
557 | obj_desc->index_field.index_obj = |
558 | acpi_ns_get_attached_object(info->register_node); | |
559 | obj_desc->index_field.data_obj = | |
560 | acpi_ns_get_attached_object(info->data_register_node); | |
4be44fcd LB |
561 | |
562 | if (!obj_desc->index_field.data_obj | |
563 | || !obj_desc->index_field.index_obj) { | |
b8e4d893 BM |
564 | ACPI_ERROR((AE_INFO, |
565 | "Null Index Object during field prep")); | |
4be44fcd LB |
566 | acpi_ut_delete_object_desc(obj_desc); |
567 | return_ACPI_STATUS(AE_AML_INTERNAL); | |
1da177e4 LT |
568 | } |
569 | ||
570 | /* An additional reference for the attached objects */ | |
571 | ||
4be44fcd LB |
572 | acpi_ut_add_reference(obj_desc->index_field.data_obj); |
573 | acpi_ut_add_reference(obj_desc->index_field.index_obj); | |
574 | ||
b8e4d893 | 575 | /* |
b229cf92 | 576 | * April 2006: Changed to match MS behavior |
ea936b78 | 577 | * |
b8e4d893 | 578 | * The value written to the Index register is the byte offset of the |
b229cf92 | 579 | * target field in units of the granularity of the index_field |
ea936b78 BM |
580 | * |
581 | * Previously, the value was calculated as an index in terms of the | |
582 | * width of the Data register, as below: | |
583 | * | |
b229cf92 BM |
584 | * obj_desc->index_field.Value = (u32) |
585 | * (Info->field_bit_position / ACPI_MUL_8 ( | |
586 | * obj_desc->Field.access_byte_width)); | |
587 | * | |
588 | * February 2006: Tried value as a byte offset: | |
589 | * obj_desc->index_field.Value = (u32) | |
590 | * ACPI_DIV_8 (Info->field_bit_position); | |
b8e4d893 | 591 | */ |
ea936b78 | 592 | obj_desc->index_field.value = |
b229cf92 BM |
593 | (u32) ACPI_ROUND_DOWN(ACPI_DIV_8(info->field_bit_position), |
594 | obj_desc->index_field. | |
595 | access_byte_width); | |
b8e4d893 | 596 | |
4be44fcd | 597 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 598 | "IndexField: BitOff %X, Off %X, Value %X, Gran %X, Index %p, Data %p\n", |
4be44fcd LB |
599 | obj_desc->index_field.start_field_bit_offset, |
600 | obj_desc->index_field.base_byte_offset, | |
601 | obj_desc->index_field.value, | |
602 | obj_desc->field.access_byte_width, | |
603 | obj_desc->index_field.index_obj, | |
604 | obj_desc->index_field.data_obj)); | |
1da177e4 LT |
605 | break; |
606 | ||
607 | default: | |
1d1ea1b7 | 608 | |
1da177e4 | 609 | /* No other types should get here */ |
1d1ea1b7 | 610 | |
1da177e4 LT |
611 | break; |
612 | } | |
613 | ||
614 | /* | |
615 | * Store the constructed descriptor (obj_desc) into the parent Node, | |
616 | * preserving the current type of that named_obj. | |
617 | */ | |
4be44fcd LB |
618 | status = acpi_ns_attach_object(info->field_node, obj_desc, |
619 | acpi_ns_get_type(info->field_node)); | |
1da177e4 | 620 | |
4be44fcd | 621 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
b229cf92 | 622 | "Set NamedObj %p [%4.4s], ObjDesc %p\n", |
4be44fcd LB |
623 | info->field_node, |
624 | acpi_ut_get_node_name(info->field_node), obj_desc)); | |
1da177e4 LT |
625 | |
626 | /* Remove local reference to the object */ | |
627 | ||
4be44fcd LB |
628 | acpi_ut_remove_reference(obj_desc); |
629 | return_ACPI_STATUS(status); | |
1da177e4 | 630 | } |