Branch data Line data Source code
1 : : // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 : : /******************************************************************************
3 : : *
4 : : * Module Name: uteval - Object evaluation
5 : : *
6 : : * Copyright (C) 2000 - 2020, 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
37 : 20592 : 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 : 20592 : struct acpi_evaluate_info *info;
43 : 20592 : acpi_status status;
44 : 20592 : u32 return_btype;
45 : :
46 : 20592 : ACPI_FUNCTION_TRACE(ut_evaluate_object);
47 : :
48 : : /* Allocate the evaluation information block */
49 : :
50 : 20592 : info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
51 [ + - ]: 20592 : if (!info) {
52 : : return_ACPI_STATUS(AE_NO_MEMORY);
53 : : }
54 : :
55 : 20592 : info->prefix_node = prefix_node;
56 : 20592 : info->relative_pathname = path;
57 : :
58 : : /* Evaluate the object/method */
59 : :
60 : 20592 : status = acpi_ns_evaluate(info);
61 [ + + ]: 20592 : if (ACPI_FAILURE(status)) {
62 [ - + ]: 17721 : 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 : 0 : ACPI_ERROR_METHOD("Method execution failed",
69 : 17721 : prefix_node, path, status);
70 : : }
71 : :
72 : 17721 : goto cleanup;
73 : : }
74 : :
75 : : /* Did we get a return object? */
76 : :
77 [ - + ]: 2871 : if (!info->return_object) {
78 [ # # ]: 0 : if (expected_return_btypes) {
79 : 0 : ACPI_ERROR_METHOD("No object was returned from",
80 : 0 : prefix_node, path, AE_NOT_EXIST);
81 : :
82 : 0 : status = AE_NOT_EXIST;
83 : : }
84 : :
85 : 0 : goto cleanup;
86 : : }
87 : :
88 : : /* Map the return object type to the bitmapped type */
89 : :
90 [ - + ]: 2871 : 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 [ + - - + ]: 2871 : 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 : 0 : acpi_ut_remove_reference(info->return_object);
124 : 0 : goto cleanup;
125 : : }
126 : :
127 : : /* Is the return object one of the expected types? */
128 : :
129 [ - + ]: 2871 : if (!(expected_return_btypes & return_btype)) {
130 : 0 : ACPI_ERROR_METHOD("Return object type is incorrect",
131 : 0 : prefix_node, path, AE_TYPE);
132 : :
133 : 0 : 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 : 0 : acpi_ut_remove_reference(info->return_object);
142 : 0 : status = AE_TYPE;
143 : 0 : goto cleanup;
144 : : }
145 : :
146 : : /* Object type is OK, return it */
147 : :
148 : 2871 : *return_desc = info->return_object;
149 : :
150 : 20592 : cleanup:
151 : 20592 : ACPI_FREE(info);
152 : 20592 : 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
173 : 1298 : acpi_ut_evaluate_numeric_object(const char *object_name,
174 : : struct acpi_namespace_node *device_node,
175 : : u64 *value)
176 : : {
177 : 1298 : union acpi_operand_object *obj_desc;
178 : 1298 : acpi_status status;
179 : :
180 : 1298 : ACPI_FUNCTION_TRACE(ut_evaluate_numeric_object);
181 : :
182 : 1298 : status = acpi_ut_evaluate_object(device_node, object_name,
183 : : ACPI_BTYPE_INTEGER, &obj_desc);
184 [ + + ]: 1298 : if (ACPI_FAILURE(status)) {
185 : : return_ACPI_STATUS(status);
186 : : }
187 : :
188 : : /* Get the returned Integer */
189 : :
190 : 814 : *value = obj_desc->integer.value;
191 : :
192 : : /* On exit, we must delete the return object */
193 : :
194 : 814 : acpi_ut_remove_reference(obj_desc);
195 : 814 : 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
216 : 638 : acpi_ut_execute_STA(struct acpi_namespace_node *device_node, u32 * flags)
217 : : {
218 : 638 : union acpi_operand_object *obj_desc;
219 : 638 : acpi_status status;
220 : :
221 : 638 : ACPI_FUNCTION_TRACE(ut_execute_STA);
222 : :
223 : 638 : status = acpi_ut_evaluate_object(device_node, METHOD_NAME__STA,
224 : : ACPI_BTYPE_INTEGER, &obj_desc);
225 [ + + ]: 638 : if (ACPI_FAILURE(status)) {
226 [ + - ]: 484 : 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 : 484 : acpi_ut_get_node_name(device_node)));
235 : :
236 : 484 : *flags = ACPI_UINT32_MAX;
237 : 484 : status = AE_OK;
238 : : }
239 : :
240 : 484 : return_ACPI_STATUS(status);
241 : : }
242 : :
243 : : /* Extract the status flags */
244 : :
245 : 154 : *flags = (u32) obj_desc->integer.value;
246 : :
247 : : /* On exit, we must delete the return object */
248 : :
249 : 154 : acpi_ut_remove_reference(obj_desc);
250 : 154 : 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
272 : 2420 : 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 : 2420 : union acpi_operand_object *obj_desc;
277 : 2420 : acpi_status status;
278 : 2420 : acpi_status final_status = AE_NOT_FOUND;
279 : 2420 : u32 i;
280 : :
281 : 2420 : ACPI_FUNCTION_TRACE(ut_execute_power_methods);
282 : :
283 [ + + ]: 13310 : 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 : 10890 : status = acpi_ut_evaluate_object(device_node,
289 : 10890 : ACPI_CAST_PTR(char,
290 : : method_names[i]),
291 : : ACPI_BTYPE_INTEGER, &obj_desc);
292 [ + + ]: 10890 : if (ACPI_SUCCESS(status)) {
293 : 66 : out_values[i] = (u8)obj_desc->integer.value;
294 : :
295 : : /* Delete the return object */
296 : :
297 : 66 : acpi_ut_remove_reference(obj_desc);
298 : 66 : final_status = AE_OK; /* At least one value is valid */
299 : 66 : continue;
300 : : }
301 : :
302 : 10824 : out_values[i] = ACPI_UINT8_MAX;
303 [ + - ]: 10824 : if (status == AE_NOT_FOUND) {
304 : 10824 : 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 : 10890 : acpi_format_exception(status)));
312 : : }
313 : :
314 : 2420 : return_ACPI_STATUS(final_status);
315 : : }
|
