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