Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | |
| 2 | /****************************************************************************** |
| 3 | * |
| 4 | * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities |
| 5 | * |
| 6 | *****************************************************************************/ |
| 7 | |
| 8 | /* |
Bob Moore | 4a90c7e | 2006-01-13 16:22:00 -0500 | [diff] [blame] | 9 | * Copyright (C) 2000 - 2006, R. Byron Moore |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | #include <acpi/acpi.h> |
| 46 | #include <acpi/acinterp.h> |
| 47 | #include <acpi/amlcode.h> |
| 48 | #include <acpi/acnamesp.h> |
| 49 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | #define _COMPONENT ACPI_EXECUTER |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 51 | ACPI_MODULE_NAME("exprep") |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 53 | /* Local prototypes */ |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 54 | static u32 |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 55 | acpi_ex_decode_field_access(union acpi_operand_object *obj_desc, |
| 56 | u8 field_flags, u32 * return_byte_alignment); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | |
| 58 | #ifdef ACPI_UNDER_DEVELOPMENT |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 59 | |
| 60 | static u32 |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 61 | acpi_ex_generate_access(u32 field_bit_offset, |
| 62 | u32 field_bit_length, u32 region_length); |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 63 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 87 | acpi_ex_generate_access(u32 field_bit_offset, |
| 88 | u32 field_bit_length, u32 region_length) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 99 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 100 | ACPI_FUNCTION_TRACE("ex_generate_access"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | |
| 102 | /* Round Field start offset and length to "minimal" byte boundaries */ |
| 103 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 108 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 109 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
| 110 | "Bit length %d, Bit offset %d\n", |
| 111 | field_bit_length, field_bit_offset)); |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 112 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 124 | for (access_byte_width = 1; access_byte_width <= 8; |
| 125 | access_byte_width <<= 1) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | /* |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 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). |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | */ |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 133 | if (ACPI_ROUND_UP(field_byte_end_offset, access_byte_width) <= |
| 134 | region_length) { |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 135 | field_start_offset = |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 136 | ACPI_ROUND_DOWN(field_byte_offset, |
| 137 | access_byte_width) / |
| 138 | access_byte_width; |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 139 | |
| 140 | field_end_offset = |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 141 | ACPI_ROUND_UP((field_byte_length + |
| 142 | field_byte_offset), |
| 143 | access_byte_width) / |
| 144 | access_byte_width; |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 145 | |
| 146 | accesses = field_end_offset - field_start_offset; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 148 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
| 149 | "access_width %d end is within region\n", |
| 150 | access_byte_width)); |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 151 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 156 | |
| 157 | /* Single access is optimal */ |
| 158 | |
| 159 | if (accesses <= 1) { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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) { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 171 | minimum_accesses = accesses; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | minimum_access_width = access_byte_width; |
| 173 | } |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 174 | } else { |
| 175 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
| 176 | "access_width %d end is NOT within region\n", |
| 177 | access_byte_width)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 178 | if (access_byte_width == 1) { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 179 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
| 180 | "Field goes beyond end-of-region!\n")); |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 181 | |
| 182 | /* Field does not fit in the region at all */ |
| 183 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 184 | return_VALUE(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 185 | } |
| 186 | |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 187 | /* |
| 188 | * This width goes beyond the end-of-region, back off to |
| 189 | * previous access |
| 190 | */ |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | } |
| 196 | } |
| 197 | |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 198 | /* |
| 199 | * Could not read/write field with one operation, |
| 200 | * just use max access width |
| 201 | */ |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 202 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
| 203 | "Cannot access field in one operation, using width 8\n")); |
| 204 | return_VALUE(8); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | } |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 206 | #endif /* ACPI_UNDER_DEVELOPMENT */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | |
| 208 | /******************************************************************************* |
| 209 | * |
| 210 | * FUNCTION: acpi_ex_decode_field_access |
| 211 | * |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 212 | * PARAMETERS: obj_desc - Field object |
| 213 | * field_flags - Encoded fieldflags (contains access bits) |
| 214 | * return_byte_alignment - Where the byte alignment is returned |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 224 | acpi_ex_decode_field_access(union acpi_operand_object *obj_desc, |
| 225 | u8 field_flags, u32 * return_byte_alignment) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 226 | { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 227 | u32 access; |
| 228 | u32 byte_alignment; |
| 229 | u32 bit_length; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 231 | ACPI_FUNCTION_TRACE("ex_decode_field_access"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 239 | byte_alignment = |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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 | ); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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: |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 254 | case AML_FIELD_ACCESS_BUFFER: /* ACPI 2.0 (SMBus Buffer) */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | byte_alignment = 1; |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 256 | bit_length = 8; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | break; |
| 258 | |
| 259 | case AML_FIELD_ACCESS_WORD: |
| 260 | byte_alignment = 2; |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 261 | bit_length = 16; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 262 | break; |
| 263 | |
| 264 | case AML_FIELD_ACCESS_DWORD: |
| 265 | byte_alignment = 4; |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 266 | bit_length = 32; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 267 | break; |
| 268 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 269 | case AML_FIELD_ACCESS_QWORD: /* ACPI 2.0 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 270 | byte_alignment = 8; |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 271 | bit_length = 64; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | break; |
| 273 | |
| 274 | default: |
| 275 | /* Invalid field access type */ |
| 276 | |
Bob Moore | b8e4d89 | 2006-01-27 16:43:00 -0500 | [diff] [blame] | 277 | ACPI_ERROR((AE_INFO, "Unknown field access type %X", access)); |
Bob Moore | 50eca3e | 2005-09-30 19:03:00 -0400 | [diff] [blame] | 278 | return_UINT32(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | } |
| 280 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 281 | if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_BUFFER_FIELD) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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; |
Bob Moore | 50eca3e | 2005-09-30 19:03:00 -0400 | [diff] [blame] | 291 | return_UINT32(bit_length); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 292 | } |
| 293 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 302 | * field_attribute - Special attributes (not used) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 321 | u32 access_bit_width; |
| 322 | u32 byte_alignment; |
| 323 | u32 nearest_byte_address; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 324 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 325 | ACPI_FUNCTION_TRACE("ex_prep_common_field_object"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 351 | access_bit_width = acpi_ex_decode_field_access(obj_desc, field_flags, |
| 352 | &byte_alignment); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | if (!access_bit_width) { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 354 | return_ACPI_STATUS(AE_AML_OPERAND_VALUE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | } |
| 356 | |
| 357 | /* Setup width (access granularity) fields */ |
| 358 | |
| 359 | obj_desc->common_field.access_byte_width = (u8) |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 360 | ACPI_DIV_8(access_bit_width); /* 1, 2, 4, 8 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 = |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 375 | ACPI_ROUND_BITS_DOWN_TO_BYTES(field_bit_position); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 376 | obj_desc->common_field.base_byte_offset = (u32) |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 377 | ACPI_ROUND_DOWN(nearest_byte_address, byte_alignment); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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) |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 384 | (field_bit_position - |
| 385 | ACPI_MUL_8(obj_desc->common_field.base_byte_offset)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 386 | |
| 387 | /* |
| 388 | * Does the entire field fit within a single field access element? (datum) |
| 389 | * (i.e., without crossing a datum boundary) |
| 390 | */ |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 391 | if ((obj_desc->common_field.start_field_bit_offset + |
| 392 | field_bit_length) <= (u16) access_bit_width) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 393 | obj_desc->common.flags |= AOPOBJ_SINGLE_DATUM; |
| 394 | } |
| 395 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 396 | return_ACPI_STATUS(AE_OK); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | } |
| 398 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 399 | /******************************************************************************* |
| 400 | * |
| 401 | * FUNCTION: acpi_ex_prep_field_value |
| 402 | * |
Robert Moore | 44f6c01 | 2005-04-18 22:49:35 -0400 | [diff] [blame] | 403 | * PARAMETERS: Info - Contains all field creation info |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 412 | acpi_status acpi_ex_prep_field_value(struct acpi_create_field_info *info) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 413 | { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 414 | union acpi_operand_object *obj_desc; |
| 415 | u32 type; |
| 416 | acpi_status status; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 417 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 418 | ACPI_FUNCTION_TRACE("ex_prep_field_value"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 419 | |
| 420 | /* Parameter validation */ |
| 421 | |
| 422 | if (info->field_type != ACPI_TYPE_LOCAL_INDEX_FIELD) { |
| 423 | if (!info->region_node) { |
Bob Moore | b8e4d89 | 2006-01-27 16:43:00 -0500 | [diff] [blame] | 424 | ACPI_ERROR((AE_INFO, "Null region_node")); |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 425 | return_ACPI_STATUS(AE_AML_NO_OPERAND); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 426 | } |
| 427 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 428 | type = acpi_ns_get_type(info->region_node); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 429 | if (type != ACPI_TYPE_REGION) { |
Bob Moore | b8e4d89 | 2006-01-27 16:43:00 -0500 | [diff] [blame] | 430 | ACPI_ERROR((AE_INFO, |
| 431 | "Needed Region, found type %X (%s)", |
| 432 | type, acpi_ut_get_type_name(type))); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 434 | return_ACPI_STATUS(AE_AML_OPERAND_TYPE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 435 | } |
| 436 | } |
| 437 | |
| 438 | /* Allocate a new field object */ |
| 439 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 440 | obj_desc = acpi_ut_create_internal_object(info->field_type); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 441 | if (!obj_desc) { |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 442 | return_ACPI_STATUS(AE_NO_MEMORY); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 443 | } |
| 444 | |
| 445 | /* Initialize areas of the object that are common to all fields */ |
| 446 | |
| 447 | obj_desc->common_field.node = info->field_node; |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 462 | obj_desc->field.region_obj = |
| 463 | acpi_ns_get_attached_object(info->region_node); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 464 | |
| 465 | /* An additional reference for the container */ |
| 466 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 467 | acpi_ut_add_reference(obj_desc->field.region_obj); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 475 | break; |
| 476 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 477 | case ACPI_TYPE_LOCAL_BANK_FIELD: |
| 478 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 484 | |
| 485 | /* An additional reference for the attached objects */ |
| 486 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 487 | acpi_ut_add_reference(obj_desc->bank_field.region_obj); |
| 488 | acpi_ut_add_reference(obj_desc->bank_field.bank_obj); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 489 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 497 | break; |
| 498 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 499 | case ACPI_TYPE_LOCAL_INDEX_FIELD: |
| 500 | |
Bob Moore | b8e4d89 | 2006-01-27 16:43:00 -0500 | [diff] [blame] | 501 | /* Get the Index and Data registers */ |
| 502 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 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); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 507 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 508 | if (!obj_desc->index_field.data_obj |
| 509 | || !obj_desc->index_field.index_obj) { |
Bob Moore | b8e4d89 | 2006-01-27 16:43:00 -0500 | [diff] [blame] | 510 | ACPI_ERROR((AE_INFO, |
| 511 | "Null Index Object during field prep")); |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 512 | acpi_ut_delete_object_desc(obj_desc); |
| 513 | return_ACPI_STATUS(AE_AML_INTERNAL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 514 | } |
| 515 | |
| 516 | /* An additional reference for the attached objects */ |
| 517 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 518 | acpi_ut_add_reference(obj_desc->index_field.data_obj); |
| 519 | acpi_ut_add_reference(obj_desc->index_field.index_obj); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 520 | |
Bob Moore | b8e4d89 | 2006-01-27 16:43:00 -0500 | [diff] [blame] | 521 | /* |
| 522 | * The value written to the Index register is the byte offset of the |
| 523 | * target field |
| 524 | * Note: may change code to: ACPI_DIV_8 (Info->field_bit_position) |
| 525 | */ |
| 526 | obj_desc->index_field.value = (u32) |
| 527 | (info->field_bit_position / |
| 528 | ACPI_MUL_8(obj_desc->field.access_byte_width)); |
| 529 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 530 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
| 531 | "index_field: bit_off %X, Off %X, Value %X, Gran %X, Index %p, Data %p\n", |
| 532 | obj_desc->index_field.start_field_bit_offset, |
| 533 | obj_desc->index_field.base_byte_offset, |
| 534 | obj_desc->index_field.value, |
| 535 | obj_desc->field.access_byte_width, |
| 536 | obj_desc->index_field.index_obj, |
| 537 | obj_desc->index_field.data_obj)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 538 | break; |
| 539 | |
| 540 | default: |
| 541 | /* No other types should get here */ |
| 542 | break; |
| 543 | } |
| 544 | |
| 545 | /* |
| 546 | * Store the constructed descriptor (obj_desc) into the parent Node, |
| 547 | * preserving the current type of that named_obj. |
| 548 | */ |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 549 | status = acpi_ns_attach_object(info->field_node, obj_desc, |
| 550 | acpi_ns_get_type(info->field_node)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 551 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 552 | ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, |
| 553 | "Set named_obj %p [%4.4s], obj_desc %p\n", |
| 554 | info->field_node, |
| 555 | acpi_ut_get_node_name(info->field_node), obj_desc)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 556 | |
| 557 | /* Remove local reference to the object */ |
| 558 | |
Len Brown | 4be44fc | 2005-08-05 00:44:28 -0400 | [diff] [blame] | 559 | acpi_ut_remove_reference(obj_desc); |
| 560 | return_ACPI_STATUS(status); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 561 | } |