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
acpi_ut_evaluate_object(struct acpi_namespace_node * prefix_node,char * path,u32 expected_return_btypes,union acpi_operand_object ** return_desc)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
acpi_ut_evaluate_numeric_object(char * object_name,struct acpi_namespace_node * device_node,u64 * value)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
acpi_ut_execute_STA(struct acpi_namespace_node * device_node,u32 * flags)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
acpi_ut_execute_power_methods(struct acpi_namespace_node * device_node,const char ** method_names,u8 method_count,u8 * out_values)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