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