1 /****************************************************************************** 2 * 3 * Module Name: uteval - Object evaluation 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2012, 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 "acnamesp.h" 47 48 #define _COMPONENT ACPI_UTILITIES 49 ACPI_MODULE_NAME("uteval") 50 51 /******************************************************************************* 52 * 53 * FUNCTION: acpi_ut_evaluate_object 54 * 55 * PARAMETERS: prefix_node - Starting node 56 * path - Path to object from starting node 57 * expected_return_types - Bitmap of allowed return types 58 * return_desc - Where a return value is stored 59 * 60 * RETURN: Status 61 * 62 * DESCRIPTION: Evaluates a namespace object and verifies the type of the 63 * return object. Common code that simplifies accessing objects 64 * that have required return objects of fixed types. 65 * 66 * NOTE: Internal function, no parameter validation 67 * 68 ******************************************************************************/ 69 70 acpi_status 71 acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node, 72 char *path, 73 u32 expected_return_btypes, 74 union acpi_operand_object **return_desc) 75 { 76 struct acpi_evaluate_info *info; 77 acpi_status status; 78 u32 return_btype; 79 80 ACPI_FUNCTION_TRACE(ut_evaluate_object); 81 82 /* Allocate the evaluation information block */ 83 84 info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info)); 85 if (!info) { 86 return_ACPI_STATUS(AE_NO_MEMORY); 87 } 88 89 info->prefix_node = prefix_node; 90 info->pathname = path; 91 92 /* Evaluate the object/method */ 93 94 status = acpi_ns_evaluate(info); 95 if (ACPI_FAILURE(status)) { 96 if (status == AE_NOT_FOUND) { 97 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 98 "[%4.4s.%s] was not found\n", 99 acpi_ut_get_node_name(prefix_node), 100 path)); 101 } else { 102 ACPI_ERROR_METHOD("Method execution failed", 103 prefix_node, path, status); 104 } 105 106 goto cleanup; 107 } 108 109 /* Did we get a return object? */ 110 111 if (!info->return_object) { 112 if (expected_return_btypes) { 113 ACPI_ERROR_METHOD("No object was returned from", 114 prefix_node, path, AE_NOT_EXIST); 115 116 status = AE_NOT_EXIST; 117 } 118 119 goto cleanup; 120 } 121 122 /* Map the return object type to the bitmapped type */ 123 124 switch ((info->return_object)->common.type) { 125 case ACPI_TYPE_INTEGER: 126 return_btype = ACPI_BTYPE_INTEGER; 127 break; 128 129 case ACPI_TYPE_BUFFER: 130 return_btype = ACPI_BTYPE_BUFFER; 131 break; 132 133 case ACPI_TYPE_STRING: 134 return_btype = ACPI_BTYPE_STRING; 135 break; 136 137 case ACPI_TYPE_PACKAGE: 138 return_btype = ACPI_BTYPE_PACKAGE; 139 break; 140 141 default: 142 return_btype = 0; 143 break; 144 } 145 146 if ((acpi_gbl_enable_interpreter_slack) && (!expected_return_btypes)) { 147 /* 148 * We received a return object, but one was not expected. This can 149 * happen frequently if the "implicit return" feature is enabled. 150 * Just delete the return object and return AE_OK. 151 */ 152 acpi_ut_remove_reference(info->return_object); 153 goto cleanup; 154 } 155 156 /* Is the return object one of the expected types? */ 157 158 if (!(expected_return_btypes & return_btype)) { 159 ACPI_ERROR_METHOD("Return object type is incorrect", 160 prefix_node, path, AE_TYPE); 161 162 ACPI_ERROR((AE_INFO, 163 "Type returned from %s was incorrect: %s, expected Btypes: 0x%X", 164 path, 165 acpi_ut_get_object_type_name(info->return_object), 166 expected_return_btypes)); 167 168 /* On error exit, we must delete the return object */ 169 170 acpi_ut_remove_reference(info->return_object); 171 status = AE_TYPE; 172 goto cleanup; 173 } 174 175 /* Object type is OK, return it */ 176 177 *return_desc = info->return_object; 178 179 cleanup: 180 ACPI_FREE(info); 181 return_ACPI_STATUS(status); 182 } 183 184 /******************************************************************************* 185 * 186 * FUNCTION: acpi_ut_evaluate_numeric_object 187 * 188 * PARAMETERS: object_name - Object name to be evaluated 189 * device_node - Node for the device 190 * value - Where the value is returned 191 * 192 * RETURN: Status 193 * 194 * DESCRIPTION: Evaluates a numeric namespace object for a selected device 195 * and stores result in *Value. 196 * 197 * NOTE: Internal function, no parameter validation 198 * 199 ******************************************************************************/ 200 201 acpi_status 202 acpi_ut_evaluate_numeric_object(char *object_name, 203 struct acpi_namespace_node *device_node, 204 u64 *value) 205 { 206 union acpi_operand_object *obj_desc; 207 acpi_status status; 208 209 ACPI_FUNCTION_TRACE(ut_evaluate_numeric_object); 210 211 status = acpi_ut_evaluate_object(device_node, object_name, 212 ACPI_BTYPE_INTEGER, &obj_desc); 213 if (ACPI_FAILURE(status)) { 214 return_ACPI_STATUS(status); 215 } 216 217 /* Get the returned Integer */ 218 219 *value = obj_desc->integer.value; 220 221 /* On exit, we must delete the return object */ 222 223 acpi_ut_remove_reference(obj_desc); 224 return_ACPI_STATUS(status); 225 } 226 227 /******************************************************************************* 228 * 229 * FUNCTION: acpi_ut_execute_STA 230 * 231 * PARAMETERS: device_node - Node for the device 232 * flags - Where the status flags are returned 233 * 234 * RETURN: Status 235 * 236 * DESCRIPTION: Executes _STA for selected device and stores results in 237 * *Flags. 238 * 239 * NOTE: Internal function, no parameter validation 240 * 241 ******************************************************************************/ 242 243 acpi_status 244 acpi_ut_execute_STA(struct acpi_namespace_node *device_node, u32 * flags) 245 { 246 union acpi_operand_object *obj_desc; 247 acpi_status status; 248 249 ACPI_FUNCTION_TRACE(ut_execute_STA); 250 251 status = acpi_ut_evaluate_object(device_node, METHOD_NAME__STA, 252 ACPI_BTYPE_INTEGER, &obj_desc); 253 if (ACPI_FAILURE(status)) { 254 if (AE_NOT_FOUND == status) { 255 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 256 "_STA on %4.4s was not found, assuming device is present\n", 257 acpi_ut_get_node_name(device_node))); 258 259 *flags = ACPI_UINT32_MAX; 260 status = AE_OK; 261 } 262 263 return_ACPI_STATUS(status); 264 } 265 266 /* Extract the status flags */ 267 268 *flags = (u32) obj_desc->integer.value; 269 270 /* On exit, we must delete the return object */ 271 272 acpi_ut_remove_reference(obj_desc); 273 return_ACPI_STATUS(status); 274 } 275 276 /******************************************************************************* 277 * 278 * FUNCTION: acpi_ut_execute_power_methods 279 * 280 * PARAMETERS: device_node - Node for the device 281 * method_names - Array of power method names 282 * method_count - Number of methods to execute 283 * out_values - Where the power method values are returned 284 * 285 * RETURN: Status, out_values 286 * 287 * DESCRIPTION: Executes the specified power methods for the device and returns 288 * the result(s). 289 * 290 * NOTE: Internal function, no parameter validation 291 * 292 ******************************************************************************/ 293 294 acpi_status 295 acpi_ut_execute_power_methods(struct acpi_namespace_node *device_node, 296 const char **method_names, 297 u8 method_count, u8 *out_values) 298 { 299 union acpi_operand_object *obj_desc; 300 acpi_status status; 301 acpi_status final_status = AE_NOT_FOUND; 302 u32 i; 303 304 ACPI_FUNCTION_TRACE(ut_execute_power_methods); 305 306 for (i = 0; i < method_count; i++) { 307 /* 308 * Execute the power method (_sx_d or _sx_w). The only allowable 309 * return type is an Integer. 310 */ 311 status = acpi_ut_evaluate_object(device_node, 312 ACPI_CAST_PTR(char, 313 method_names[i]), 314 ACPI_BTYPE_INTEGER, &obj_desc); 315 if (ACPI_SUCCESS(status)) { 316 out_values[i] = (u8)obj_desc->integer.value; 317 318 /* Delete the return object */ 319 320 acpi_ut_remove_reference(obj_desc); 321 final_status = AE_OK; /* At least one value is valid */ 322 continue; 323 } 324 325 out_values[i] = ACPI_UINT8_MAX; 326 if (status == AE_NOT_FOUND) { 327 continue; /* Ignore if not found */ 328 } 329 330 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 331 "Failed %s on Device %4.4s, %s\n", 332 ACPI_CAST_PTR(char, method_names[i]), 333 acpi_ut_get_node_name(device_node), 334 acpi_format_exception(status))); 335 } 336 337 return_ACPI_STATUS(final_status); 338 } 339