1 /****************************************************************************** 2 * 3 * Module Name: exfield - ACPI AML (p-code) execution - field manipulation 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2008, Intel Corp. 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 44 #include <acpi/acpi.h> 45 #include "accommon.h" 46 #include "acdispat.h" 47 #include "acinterp.h" 48 49 #define _COMPONENT ACPI_EXECUTER 50 ACPI_MODULE_NAME("exfield") 51 52 /******************************************************************************* 53 * 54 * FUNCTION: acpi_ex_read_data_from_field 55 * 56 * PARAMETERS: walk_state - Current execution state 57 * obj_desc - The named field 58 * ret_buffer_desc - Where the return data object is stored 59 * 60 * RETURN: Status 61 * 62 * DESCRIPTION: Read from a named field. Returns either an Integer or a 63 * Buffer, depending on the size of the field. 64 * 65 ******************************************************************************/ 66 acpi_status 67 acpi_ex_read_data_from_field(struct acpi_walk_state *walk_state, 68 union acpi_operand_object *obj_desc, 69 union acpi_operand_object **ret_buffer_desc) 70 { 71 acpi_status status; 72 union acpi_operand_object *buffer_desc; 73 acpi_size length; 74 void *buffer; 75 76 ACPI_FUNCTION_TRACE_PTR(ex_read_data_from_field, obj_desc); 77 78 /* Parameter validation */ 79 80 if (!obj_desc) { 81 return_ACPI_STATUS(AE_AML_NO_OPERAND); 82 } 83 if (!ret_buffer_desc) { 84 return_ACPI_STATUS(AE_BAD_PARAMETER); 85 } 86 87 if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) { 88 /* 89 * If the buffer_field arguments have not been previously evaluated, 90 * evaluate them now and save the results. 91 */ 92 if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) { 93 status = acpi_ds_get_buffer_field_arguments(obj_desc); 94 if (ACPI_FAILURE(status)) { 95 return_ACPI_STATUS(status); 96 } 97 } 98 } else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) && 99 (obj_desc->field.region_obj->region.space_id == 100 ACPI_ADR_SPACE_SMBUS)) { 101 /* 102 * This is an SMBus read. We must create a buffer to hold the data 103 * and directly access the region handler. 104 */ 105 buffer_desc = 106 acpi_ut_create_buffer_object(ACPI_SMBUS_BUFFER_SIZE); 107 if (!buffer_desc) { 108 return_ACPI_STATUS(AE_NO_MEMORY); 109 } 110 111 /* Lock entire transaction if requested */ 112 113 acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags); 114 115 /* 116 * Perform the read. 117 * Note: Smbus protocol value is passed in upper 16-bits of Function 118 */ 119 status = acpi_ex_access_region(obj_desc, 0, 120 ACPI_CAST_PTR(acpi_integer, 121 buffer_desc-> 122 buffer.pointer), 123 ACPI_READ | (obj_desc->field. 124 attribute << 16)); 125 acpi_ex_release_global_lock(obj_desc->common_field.field_flags); 126 goto exit; 127 } 128 129 /* 130 * Allocate a buffer for the contents of the field. 131 * 132 * If the field is larger than the size of an acpi_integer, create 133 * a BUFFER to hold it. Otherwise, use an INTEGER. This allows 134 * the use of arithmetic operators on the returned value if the 135 * field size is equal or smaller than an Integer. 136 * 137 * Note: Field.length is in bits. 138 */ 139 length = 140 (acpi_size) ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->field.bit_length); 141 if (length > acpi_gbl_integer_byte_width) { 142 143 /* Field is too large for an Integer, create a Buffer instead */ 144 145 buffer_desc = acpi_ut_create_buffer_object(length); 146 if (!buffer_desc) { 147 return_ACPI_STATUS(AE_NO_MEMORY); 148 } 149 buffer = buffer_desc->buffer.pointer; 150 } else { 151 /* Field will fit within an Integer (normal case) */ 152 153 buffer_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER); 154 if (!buffer_desc) { 155 return_ACPI_STATUS(AE_NO_MEMORY); 156 } 157 158 length = acpi_gbl_integer_byte_width; 159 buffer_desc->integer.value = 0; 160 buffer = &buffer_desc->integer.value; 161 } 162 163 ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, 164 "FieldRead [TO]: Obj %p, Type %X, Buf %p, ByteLen %X\n", 165 obj_desc, obj_desc->common.type, buffer, 166 (u32) length)); 167 ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, 168 "FieldRead [FROM]: BitLen %X, BitOff %X, ByteOff %X\n", 169 obj_desc->common_field.bit_length, 170 obj_desc->common_field.start_field_bit_offset, 171 obj_desc->common_field.base_byte_offset)); 172 173 /* Lock entire transaction if requested */ 174 175 acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags); 176 177 /* Read from the field */ 178 179 status = acpi_ex_extract_from_field(obj_desc, buffer, (u32) length); 180 acpi_ex_release_global_lock(obj_desc->common_field.field_flags); 181 182 exit: 183 if (ACPI_FAILURE(status)) { 184 acpi_ut_remove_reference(buffer_desc); 185 } else { 186 *ret_buffer_desc = buffer_desc; 187 } 188 189 return_ACPI_STATUS(status); 190 } 191 192 /******************************************************************************* 193 * 194 * FUNCTION: acpi_ex_write_data_to_field 195 * 196 * PARAMETERS: source_desc - Contains data to write 197 * obj_desc - The named field 198 * result_desc - Where the return value is returned, if any 199 * 200 * RETURN: Status 201 * 202 * DESCRIPTION: Write to a named field 203 * 204 ******************************************************************************/ 205 206 acpi_status 207 acpi_ex_write_data_to_field(union acpi_operand_object *source_desc, 208 union acpi_operand_object *obj_desc, 209 union acpi_operand_object **result_desc) 210 { 211 acpi_status status; 212 u32 length; 213 void *buffer; 214 union acpi_operand_object *buffer_desc; 215 216 ACPI_FUNCTION_TRACE_PTR(ex_write_data_to_field, obj_desc); 217 218 /* Parameter validation */ 219 220 if (!source_desc || !obj_desc) { 221 return_ACPI_STATUS(AE_AML_NO_OPERAND); 222 } 223 224 if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) { 225 /* 226 * If the buffer_field arguments have not been previously evaluated, 227 * evaluate them now and save the results. 228 */ 229 if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) { 230 status = acpi_ds_get_buffer_field_arguments(obj_desc); 231 if (ACPI_FAILURE(status)) { 232 return_ACPI_STATUS(status); 233 } 234 } 235 } else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) && 236 (obj_desc->field.region_obj->region.space_id == 237 ACPI_ADR_SPACE_SMBUS)) { 238 /* 239 * This is an SMBus write. We will bypass the entire field mechanism 240 * and handoff the buffer directly to the handler. 241 * 242 * Source must be a buffer of sufficient size (ACPI_SMBUS_BUFFER_SIZE). 243 */ 244 if (source_desc->common.type != ACPI_TYPE_BUFFER) { 245 ACPI_ERROR((AE_INFO, 246 "SMBus write requires Buffer, found type %s", 247 acpi_ut_get_object_type_name(source_desc))); 248 249 return_ACPI_STATUS(AE_AML_OPERAND_TYPE); 250 } 251 252 if (source_desc->buffer.length < ACPI_SMBUS_BUFFER_SIZE) { 253 ACPI_ERROR((AE_INFO, 254 "SMBus write requires Buffer of length %X, found length %X", 255 ACPI_SMBUS_BUFFER_SIZE, 256 source_desc->buffer.length)); 257 258 return_ACPI_STATUS(AE_AML_BUFFER_LIMIT); 259 } 260 261 buffer_desc = 262 acpi_ut_create_buffer_object(ACPI_SMBUS_BUFFER_SIZE); 263 if (!buffer_desc) { 264 return_ACPI_STATUS(AE_NO_MEMORY); 265 } 266 267 buffer = buffer_desc->buffer.pointer; 268 ACPI_MEMCPY(buffer, source_desc->buffer.pointer, 269 ACPI_SMBUS_BUFFER_SIZE); 270 271 /* Lock entire transaction if requested */ 272 273 acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags); 274 275 /* 276 * Perform the write (returns status and perhaps data in the 277 * same buffer) 278 * Note: SMBus protocol type is passed in upper 16-bits of Function. 279 */ 280 status = acpi_ex_access_region(obj_desc, 0, 281 (acpi_integer *) buffer, 282 ACPI_WRITE | (obj_desc->field. 283 attribute << 16)); 284 acpi_ex_release_global_lock(obj_desc->common_field.field_flags); 285 286 *result_desc = buffer_desc; 287 return_ACPI_STATUS(status); 288 } 289 290 /* Get a pointer to the data to be written */ 291 292 switch (source_desc->common.type) { 293 case ACPI_TYPE_INTEGER: 294 buffer = &source_desc->integer.value; 295 length = sizeof(source_desc->integer.value); 296 break; 297 298 case ACPI_TYPE_BUFFER: 299 buffer = source_desc->buffer.pointer; 300 length = source_desc->buffer.length; 301 break; 302 303 case ACPI_TYPE_STRING: 304 buffer = source_desc->string.pointer; 305 length = source_desc->string.length; 306 break; 307 308 default: 309 return_ACPI_STATUS(AE_AML_OPERAND_TYPE); 310 } 311 312 ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, 313 "FieldWrite [FROM]: Obj %p (%s:%X), Buf %p, ByteLen %X\n", 314 source_desc, 315 acpi_ut_get_type_name(source_desc->common.type), 316 source_desc->common.type, buffer, length)); 317 318 ACPI_DEBUG_PRINT((ACPI_DB_BFIELD, 319 "FieldWrite [TO]: Obj %p (%s:%X), BitLen %X, BitOff %X, ByteOff %X\n", 320 obj_desc, 321 acpi_ut_get_type_name(obj_desc->common.type), 322 obj_desc->common.type, 323 obj_desc->common_field.bit_length, 324 obj_desc->common_field.start_field_bit_offset, 325 obj_desc->common_field.base_byte_offset)); 326 327 /* Lock entire transaction if requested */ 328 329 acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags); 330 331 /* Write to the field */ 332 333 status = acpi_ex_insert_into_field(obj_desc, buffer, length); 334 acpi_ex_release_global_lock(obj_desc->common_field.field_flags); 335 336 return_ACPI_STATUS(status); 337 } 338