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