]>
Commit | Line | Data |
---|---|---|
e8707b34 BM |
1 | /****************************************************************************** |
2 | * | |
3 | * Module Name: nspredef - Validation of ACPI predefined methods and objects | |
4 | * $Revision: 1.1 $ | |
5 | * | |
6 | *****************************************************************************/ | |
7 | ||
8 | /* | |
77848130 | 9 | * Copyright (C) 2000 - 2012, Intel Corp. |
e8707b34 BM |
10 | * All rights reserved. |
11 | * | |
12 | * Redistribution and use in source and binary forms, with or without | |
13 | * modification, are permitted provided that the following conditions | |
14 | * are met: | |
15 | * 1. Redistributions of source code must retain the above copyright | |
16 | * notice, this list of conditions, and the following disclaimer, | |
17 | * without modification. | |
18 | * 2. Redistributions in binary form must reproduce at minimum a disclaimer | |
19 | * substantially similar to the "NO WARRANTY" disclaimer below | |
20 | * ("Disclaimer") and any redistribution must be conditioned upon | |
21 | * including a substantially similar Disclaimer requirement for further | |
22 | * binary redistribution. | |
23 | * 3. Neither the names of the above-listed copyright holders nor the names | |
24 | * of any contributors may be used to endorse or promote products derived | |
25 | * from this software without specific prior written permission. | |
26 | * | |
27 | * Alternatively, this software may be distributed under the terms of the | |
28 | * GNU General Public License ("GPL") version 2 as published by the Free | |
29 | * Software Foundation. | |
30 | * | |
31 | * NO WARRANTY | |
32 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
33 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
34 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR | |
35 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
36 | * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
37 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
38 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
39 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, | |
40 | * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING | |
41 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
42 | * POSSIBILITY OF SUCH DAMAGES. | |
43 | */ | |
44 | ||
999e08f9 BM |
45 | #define ACPI_CREATE_PREDEFINED_TABLE |
46 | ||
e8707b34 | 47 | #include <acpi/acpi.h> |
e2f7a777 LB |
48 | #include "accommon.h" |
49 | #include "acnamesp.h" | |
50 | #include "acpredef.h" | |
e8707b34 BM |
51 | |
52 | #define _COMPONENT ACPI_NAMESPACE | |
53 | ACPI_MODULE_NAME("nspredef") | |
54 | ||
55 | /******************************************************************************* | |
56 | * | |
57 | * This module validates predefined ACPI objects that appear in the namespace, | |
58 | * at the time they are evaluated (via acpi_evaluate_object). The purpose of this | |
59 | * validation is to detect problems with BIOS-exposed predefined ACPI objects | |
60 | * before the results are returned to the ACPI-related drivers. | |
61 | * | |
62 | * There are several areas that are validated: | |
63 | * | |
64 | * 1) The number of input arguments as defined by the method/object in the | |
65 | * ASL is validated against the ACPI specification. | |
66 | * 2) The type of the return object (if any) is validated against the ACPI | |
67 | * specification. | |
68 | * 3) For returned package objects, the count of package elements is | |
69 | * validated, as well as the type of each package element. Nested | |
70 | * packages are supported. | |
71 | * | |
72 | * For any problems found, a warning message is issued. | |
73 | * | |
74 | ******************************************************************************/ | |
75 | /* Local prototypes */ | |
76 | static acpi_status | |
0444e8f6 BM |
77 | acpi_ns_check_package(struct acpi_predefined_data *data, |
78 | union acpi_operand_object **return_object_ptr); | |
e8707b34 | 79 | |
53e9387b BM |
80 | static acpi_status |
81 | acpi_ns_check_package_list(struct acpi_predefined_data *data, | |
82 | const union acpi_predefined_info *package, | |
83 | union acpi_operand_object **elements, u32 count); | |
84 | ||
e8707b34 | 85 | static acpi_status |
0444e8f6 | 86 | acpi_ns_check_package_elements(struct acpi_predefined_data *data, |
e8707b34 | 87 | union acpi_operand_object **elements, |
03ef132b BM |
88 | u8 type1, |
89 | u32 count1, | |
90 | u8 type2, u32 count2, u32 start_index); | |
e8707b34 BM |
91 | |
92 | static acpi_status | |
0444e8f6 | 93 | acpi_ns_check_object_type(struct acpi_predefined_data *data, |
a647b5c3 | 94 | union acpi_operand_object **return_object_ptr, |
e8707b34 BM |
95 | u32 expected_btypes, u32 package_index); |
96 | ||
97 | static acpi_status | |
0444e8f6 | 98 | acpi_ns_check_reference(struct acpi_predefined_data *data, |
e8707b34 BM |
99 | union acpi_operand_object *return_object); |
100 | ||
0444e8f6 BM |
101 | static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes); |
102 | ||
e8707b34 BM |
103 | /* |
104 | * Names for the types that can be returned by the predefined objects. | |
105 | * Used for warning messages. Must be in the same order as the ACPI_RTYPEs | |
106 | */ | |
107 | static const char *acpi_rtype_names[] = { | |
108 | "/Integer", | |
109 | "/String", | |
110 | "/Buffer", | |
111 | "/Package", | |
112 | "/Reference", | |
113 | }; | |
114 | ||
e8707b34 BM |
115 | /******************************************************************************* |
116 | * | |
117 | * FUNCTION: acpi_ns_check_predefined_names | |
118 | * | |
ba494bee | 119 | * PARAMETERS: node - Namespace node for the method/object |
0444e8f6 BM |
120 | * user_param_count - Number of parameters actually passed |
121 | * return_status - Status from the object evaluation | |
a647b5c3 BM |
122 | * return_object_ptr - Pointer to the object returned from the |
123 | * evaluation of a method or object | |
e8707b34 BM |
124 | * |
125 | * RETURN: Status | |
126 | * | |
127 | * DESCRIPTION: Check an ACPI name for a match in the predefined name list. | |
128 | * | |
129 | ******************************************************************************/ | |
130 | ||
131 | acpi_status | |
132 | acpi_ns_check_predefined_names(struct acpi_namespace_node *node, | |
eeb4437e BM |
133 | u32 user_param_count, |
134 | acpi_status return_status, | |
a647b5c3 | 135 | union acpi_operand_object **return_object_ptr) |
e8707b34 | 136 | { |
a647b5c3 | 137 | union acpi_operand_object *return_object = *return_object_ptr; |
e8707b34 BM |
138 | acpi_status status = AE_OK; |
139 | const union acpi_predefined_info *predefined; | |
140 | char *pathname; | |
0444e8f6 | 141 | struct acpi_predefined_data *data; |
e8707b34 BM |
142 | |
143 | /* Match the name for this method/object against the predefined list */ | |
144 | ||
145 | predefined = acpi_ns_check_for_predefined_name(node); | |
e8707b34 | 146 | |
0444e8f6 | 147 | /* Get the full pathname to the object, for use in warning messages */ |
e8707b34 BM |
148 | |
149 | pathname = acpi_ns_get_external_pathname(node); | |
150 | if (!pathname) { | |
65259094 | 151 | return AE_OK; /* Could not get pathname, ignore */ |
e8707b34 BM |
152 | } |
153 | ||
154 | /* | |
eeb4437e BM |
155 | * Check that the parameter count for this method matches the ASL |
156 | * definition. For predefined names, ensure that both the caller and | |
157 | * the method itself are in accordance with the ACPI specification. | |
158 | */ | |
159 | acpi_ns_check_parameter_count(pathname, node, user_param_count, | |
160 | predefined); | |
161 | ||
162 | /* If not a predefined name, we cannot validate the return object */ | |
163 | ||
164 | if (!predefined) { | |
0444e8f6 | 165 | goto cleanup; |
eeb4437e BM |
166 | } |
167 | ||
168 | /* | |
0444e8f6 BM |
169 | * If the method failed or did not actually return an object, we cannot |
170 | * validate the return object | |
e8707b34 | 171 | */ |
0444e8f6 BM |
172 | if ((return_status != AE_OK) && (return_status != AE_CTRL_RETURN_VALUE)) { |
173 | goto cleanup; | |
eeb4437e BM |
174 | } |
175 | ||
e8707b34 BM |
176 | /* |
177 | * If there is no return value, check if we require a return value for | |
178 | * this predefined name. Either one return value is expected, or none, | |
179 | * for both methods and other objects. | |
180 | * | |
181 | * Exit now if there is no return object. Warning if one was expected. | |
182 | */ | |
183 | if (!return_object) { | |
184 | if ((predefined->info.expected_btypes) && | |
185 | (!(predefined->info.expected_btypes & ACPI_RTYPE_NONE))) { | |
0444e8f6 BM |
186 | ACPI_WARN_PREDEFINED((AE_INFO, pathname, |
187 | ACPI_WARN_ALWAYS, | |
188 | "Missing expected return value")); | |
e8707b34 BM |
189 | |
190 | status = AE_AML_NO_RETURN_VALUE; | |
191 | } | |
0444e8f6 | 192 | goto cleanup; |
e8707b34 BM |
193 | } |
194 | ||
195 | /* | |
d57b23ad | 196 | * Return value validation and possible repair. |
307a0424 | 197 | * |
d57b23ad BM |
198 | * 1) Don't perform return value validation/repair if this feature |
199 | * has been disabled via a global option. | |
200 | * | |
201 | * 2) We have a return value, but if one wasn't expected, just exit, | |
202 | * this is not a problem. For example, if the "Implicit Return" | |
203 | * feature is enabled, methods will always return a value. | |
204 | * | |
205 | * 3) If the return value can be of any type, then we cannot perform | |
206 | * any validation, just exit. | |
e8707b34 | 207 | */ |
d57b23ad BM |
208 | if (acpi_gbl_disable_auto_repair || |
209 | (!predefined->info.expected_btypes) || | |
307a0424 | 210 | (predefined->info.expected_btypes == ACPI_RTYPE_ALL)) { |
0444e8f6 BM |
211 | goto cleanup; |
212 | } | |
213 | ||
214 | /* Create the parameter data block for object validation */ | |
215 | ||
216 | data = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_predefined_data)); | |
217 | if (!data) { | |
218 | goto cleanup; | |
e8707b34 | 219 | } |
0444e8f6 | 220 | data->predefined = predefined; |
8f9c9127 | 221 | data->node = node; |
0444e8f6 BM |
222 | data->node_flags = node->flags; |
223 | data->pathname = pathname; | |
e8707b34 BM |
224 | |
225 | /* | |
465da9eb BM |
226 | * Check that the type of the main return object is what is expected |
227 | * for this predefined name | |
e8707b34 | 228 | */ |
0444e8f6 | 229 | status = acpi_ns_check_object_type(data, return_object_ptr, |
e8707b34 | 230 | predefined->info.expected_btypes, |
0444e8f6 | 231 | ACPI_NOT_PACKAGE_ELEMENT); |
465da9eb BM |
232 | if (ACPI_FAILURE(status)) { |
233 | goto exit; | |
234 | } | |
235 | ||
236 | /* | |
237 | * For returned Package objects, check the type of all sub-objects. | |
238 | * Note: Package may have been newly created by call above. | |
239 | */ | |
240 | if ((*return_object_ptr)->common.type == ACPI_TYPE_PACKAGE) { | |
091f4d71 | 241 | data->parent_package = *return_object_ptr; |
465da9eb BM |
242 | status = acpi_ns_check_package(data, return_object_ptr); |
243 | if (ACPI_FAILURE(status)) { | |
244 | goto exit; | |
34c39c75 | 245 | } |
e8707b34 BM |
246 | } |
247 | ||
ad5babee | 248 | /* |
465da9eb BM |
249 | * The return object was OK, or it was successfully repaired above. |
250 | * Now make some additional checks such as verifying that package | |
251 | * objects are sorted correctly (if required) or buffer objects have | |
252 | * the correct data width (bytes vs. dwords). These repairs are | |
253 | * performed on a per-name basis, i.e., the code is specific to | |
254 | * particular predefined names. | |
ad5babee BM |
255 | */ |
256 | status = acpi_ns_complex_repairs(data, node, status, return_object_ptr); | |
257 | ||
465da9eb | 258 | exit: |
0444e8f6 BM |
259 | /* |
260 | * If the object validation failed or if we successfully repaired one | |
261 | * or more objects, mark the parent node to suppress further warning | |
262 | * messages during the next evaluation of the same method/object. | |
263 | */ | |
264 | if (ACPI_FAILURE(status) || (data->flags & ACPI_OBJECT_REPAIRED)) { | |
265 | node->flags |= ANOBJ_EVALUATED; | |
266 | } | |
267 | ACPI_FREE(data); | |
268 | ||
269 | cleanup: | |
65259094 | 270 | ACPI_FREE(pathname); |
e8707b34 BM |
271 | return (status); |
272 | } | |
273 | ||
274 | /******************************************************************************* | |
275 | * | |
276 | * FUNCTION: acpi_ns_check_parameter_count | |
277 | * | |
ba494bee BM |
278 | * PARAMETERS: pathname - Full pathname to the node (for error msgs) |
279 | * node - Namespace node for the method/object | |
eeb4437e | 280 | * user_param_count - Number of args passed in by the caller |
ba494bee | 281 | * predefined - Pointer to entry in predefined name table |
e8707b34 BM |
282 | * |
283 | * RETURN: None | |
284 | * | |
285 | * DESCRIPTION: Check that the declared (in ASL/AML) parameter count for a | |
286 | * predefined name is what is expected (i.e., what is defined in | |
287 | * the ACPI specification for this predefined name.) | |
288 | * | |
289 | ******************************************************************************/ | |
290 | ||
291 | void | |
292 | acpi_ns_check_parameter_count(char *pathname, | |
293 | struct acpi_namespace_node *node, | |
eeb4437e | 294 | u32 user_param_count, |
e8707b34 BM |
295 | const union acpi_predefined_info *predefined) |
296 | { | |
297 | u32 param_count; | |
298 | u32 required_params_current; | |
299 | u32 required_params_old; | |
300 | ||
eeb4437e BM |
301 | /* Methods have 0-7 parameters. All other types have zero. */ |
302 | ||
e8707b34 BM |
303 | param_count = 0; |
304 | if (node->type == ACPI_TYPE_METHOD) { | |
305 | param_count = node->object->method.param_count; | |
306 | } | |
307 | ||
eeb4437e BM |
308 | if (!predefined) { |
309 | /* | |
0444e8f6 BM |
310 | * Check the parameter count for non-predefined methods/objects. |
311 | * | |
eeb4437e BM |
312 | * Warning if too few or too many arguments have been passed by the |
313 | * caller. An incorrect number of arguments may not cause the method | |
314 | * to fail. However, the method will fail if there are too few | |
315 | * arguments and the method attempts to use one of the missing ones. | |
316 | */ | |
317 | if (user_param_count < param_count) { | |
0444e8f6 BM |
318 | ACPI_WARN_PREDEFINED((AE_INFO, pathname, |
319 | ACPI_WARN_ALWAYS, | |
320 | "Insufficient arguments - needs %u, found %u", | |
321 | param_count, user_param_count)); | |
eeb4437e | 322 | } else if (user_param_count > param_count) { |
0444e8f6 BM |
323 | ACPI_WARN_PREDEFINED((AE_INFO, pathname, |
324 | ACPI_WARN_ALWAYS, | |
325 | "Excess arguments - needs %u, found %u", | |
326 | param_count, user_param_count)); | |
eeb4437e BM |
327 | } |
328 | return; | |
329 | } | |
330 | ||
0444e8f6 BM |
331 | /* |
332 | * Validate the user-supplied parameter count. | |
333 | * Allow two different legal argument counts (_SCP, etc.) | |
334 | */ | |
e8707b34 BM |
335 | required_params_current = predefined->info.param_count & 0x0F; |
336 | required_params_old = predefined->info.param_count >> 4; | |
337 | ||
eeb4437e | 338 | if (user_param_count != ACPI_UINT32_MAX) { |
eeb4437e BM |
339 | if ((user_param_count != required_params_current) && |
340 | (user_param_count != required_params_old)) { | |
0444e8f6 BM |
341 | ACPI_WARN_PREDEFINED((AE_INFO, pathname, |
342 | ACPI_WARN_ALWAYS, | |
343 | "Parameter count mismatch - " | |
344 | "caller passed %u, ACPI requires %u", | |
345 | user_param_count, | |
346 | required_params_current)); | |
eeb4437e BM |
347 | } |
348 | } | |
349 | ||
eeb4437e BM |
350 | /* |
351 | * Check that the ASL-defined parameter count is what is expected for | |
0444e8f6 BM |
352 | * this predefined name (parameter count as defined by the ACPI |
353 | * specification) | |
eeb4437e | 354 | */ |
e8707b34 BM |
355 | if ((param_count != required_params_current) && |
356 | (param_count != required_params_old)) { | |
0444e8f6 BM |
357 | ACPI_WARN_PREDEFINED((AE_INFO, pathname, node->flags, |
358 | "Parameter count mismatch - ASL declared %u, ACPI requires %u", | |
359 | param_count, required_params_current)); | |
e8707b34 BM |
360 | } |
361 | } | |
362 | ||
363 | /******************************************************************************* | |
364 | * | |
365 | * FUNCTION: acpi_ns_check_for_predefined_name | |
366 | * | |
ba494bee | 367 | * PARAMETERS: node - Namespace node for the method/object |
e8707b34 BM |
368 | * |
369 | * RETURN: Pointer to entry in predefined table. NULL indicates not found. | |
370 | * | |
371 | * DESCRIPTION: Check an object name against the predefined object list. | |
372 | * | |
373 | ******************************************************************************/ | |
374 | ||
375 | const union acpi_predefined_info *acpi_ns_check_for_predefined_name(struct | |
376 | acpi_namespace_node | |
377 | *node) | |
378 | { | |
379 | const union acpi_predefined_info *this_name; | |
380 | ||
381 | /* Quick check for a predefined name, first character must be underscore */ | |
382 | ||
383 | if (node->name.ascii[0] != '_') { | |
384 | return (NULL); | |
385 | } | |
386 | ||
387 | /* Search info table for a predefined method/object name */ | |
388 | ||
389 | this_name = predefined_names; | |
390 | while (this_name->info.name[0]) { | |
391 | if (ACPI_COMPARE_NAME(node->name.ascii, this_name->info.name)) { | |
e8707b34 BM |
392 | return (this_name); |
393 | } | |
394 | ||
395 | /* | |
396 | * Skip next entry in the table if this name returns a Package | |
397 | * (next entry contains the package info) | |
398 | */ | |
399 | if (this_name->info.expected_btypes & ACPI_RTYPE_PACKAGE) { | |
400 | this_name++; | |
401 | } | |
402 | ||
403 | this_name++; | |
404 | } | |
405 | ||
0444e8f6 | 406 | return (NULL); /* Not found */ |
e8707b34 BM |
407 | } |
408 | ||
409 | /******************************************************************************* | |
410 | * | |
411 | * FUNCTION: acpi_ns_check_package | |
412 | * | |
ba494bee | 413 | * PARAMETERS: data - Pointer to validation data structure |
a647b5c3 BM |
414 | * return_object_ptr - Pointer to the object returned from the |
415 | * evaluation of a method or object | |
e8707b34 BM |
416 | * |
417 | * RETURN: Status | |
418 | * | |
419 | * DESCRIPTION: Check a returned package object for the correct count and | |
420 | * correct type of all sub-objects. | |
421 | * | |
422 | ******************************************************************************/ | |
423 | ||
424 | static acpi_status | |
0444e8f6 BM |
425 | acpi_ns_check_package(struct acpi_predefined_data *data, |
426 | union acpi_operand_object **return_object_ptr) | |
e8707b34 | 427 | { |
a647b5c3 | 428 | union acpi_operand_object *return_object = *return_object_ptr; |
e8707b34 | 429 | const union acpi_predefined_info *package; |
e8707b34 | 430 | union acpi_operand_object **elements; |
53e9387b | 431 | acpi_status status = AE_OK; |
e8707b34 BM |
432 | u32 expected_count; |
433 | u32 count; | |
434 | u32 i; | |
e8707b34 BM |
435 | |
436 | ACPI_FUNCTION_NAME(ns_check_package); | |
437 | ||
438 | /* The package info for this name is in the next table entry */ | |
439 | ||
0444e8f6 | 440 | package = data->predefined + 1; |
e8707b34 BM |
441 | |
442 | ACPI_DEBUG_PRINT((ACPI_DB_NAMES, | |
443 | "%s Validating return Package of Type %X, Count %X\n", | |
0444e8f6 | 444 | data->pathname, package->ret_info.type, |
e8707b34 BM |
445 | return_object->package.count)); |
446 | ||
d4085a3f BM |
447 | /* |
448 | * For variable-length Packages, we can safely remove all embedded | |
449 | * and trailing NULL package elements | |
450 | */ | |
451 | acpi_ns_remove_null_elements(data, package->ret_info.type, | |
452 | return_object); | |
453 | ||
e8707b34 BM |
454 | /* Extract package count and elements array */ |
455 | ||
456 | elements = return_object->package.elements; | |
457 | count = return_object->package.count; | |
458 | ||
459 | /* The package must have at least one element, else invalid */ | |
460 | ||
461 | if (!count) { | |
0444e8f6 BM |
462 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
463 | "Return Package has no elements (empty)")); | |
e8707b34 BM |
464 | |
465 | return (AE_AML_OPERAND_VALUE); | |
466 | } | |
467 | ||
468 | /* | |
469 | * Decode the type of the expected package contents | |
470 | * | |
471 | * PTYPE1 packages contain no subpackages | |
472 | * PTYPE2 packages contain sub-packages | |
473 | */ | |
474 | switch (package->ret_info.type) { | |
475 | case ACPI_PTYPE1_FIXED: | |
476 | ||
477 | /* | |
478 | * The package count is fixed and there are no sub-packages | |
479 | * | |
480 | * If package is too small, exit. | |
481 | * If package is larger than expected, issue warning but continue | |
482 | */ | |
483 | expected_count = | |
484 | package->ret_info.count1 + package->ret_info.count2; | |
485 | if (count < expected_count) { | |
486 | goto package_too_small; | |
487 | } else if (count > expected_count) { | |
3a58176e BM |
488 | ACPI_DEBUG_PRINT((ACPI_DB_REPAIR, |
489 | "%s: Return Package is larger than needed - " | |
490 | "found %u, expected %u\n", | |
491 | data->pathname, count, | |
492 | expected_count)); | |
e8707b34 BM |
493 | } |
494 | ||
495 | /* Validate all elements of the returned package */ | |
496 | ||
0444e8f6 | 497 | status = acpi_ns_check_package_elements(data, elements, |
e8707b34 BM |
498 | package->ret_info. |
499 | object_type1, | |
500 | package->ret_info. | |
501 | count1, | |
502 | package->ret_info. | |
503 | object_type2, | |
504 | package->ret_info. | |
03ef132b | 505 | count2, 0); |
e8707b34 BM |
506 | break; |
507 | ||
508 | case ACPI_PTYPE1_VAR: | |
509 | ||
510 | /* | |
511 | * The package count is variable, there are no sub-packages, and all | |
512 | * elements must be of the same type | |
513 | */ | |
514 | for (i = 0; i < count; i++) { | |
0444e8f6 | 515 | status = acpi_ns_check_object_type(data, elements, |
e8707b34 BM |
516 | package->ret_info. |
517 | object_type1, i); | |
518 | if (ACPI_FAILURE(status)) { | |
519 | return (status); | |
520 | } | |
521 | elements++; | |
522 | } | |
523 | break; | |
524 | ||
525 | case ACPI_PTYPE1_OPTION: | |
526 | ||
527 | /* | |
528 | * The package count is variable, there are no sub-packages. There are | |
529 | * a fixed number of required elements, and a variable number of | |
530 | * optional elements. | |
531 | * | |
532 | * Check if package is at least as large as the minimum required | |
533 | */ | |
534 | expected_count = package->ret_info3.count; | |
535 | if (count < expected_count) { | |
536 | goto package_too_small; | |
537 | } | |
538 | ||
539 | /* Variable number of sub-objects */ | |
540 | ||
541 | for (i = 0; i < count; i++) { | |
542 | if (i < package->ret_info3.count) { | |
543 | ||
544 | /* These are the required package elements (0, 1, or 2) */ | |
545 | ||
546 | status = | |
0444e8f6 | 547 | acpi_ns_check_object_type(data, elements, |
e8707b34 BM |
548 | package-> |
549 | ret_info3. | |
550 | object_type[i], | |
551 | i); | |
552 | if (ACPI_FAILURE(status)) { | |
553 | return (status); | |
554 | } | |
555 | } else { | |
556 | /* These are the optional package elements */ | |
557 | ||
558 | status = | |
0444e8f6 | 559 | acpi_ns_check_object_type(data, elements, |
e8707b34 BM |
560 | package-> |
561 | ret_info3. | |
562 | tail_object_type, | |
563 | i); | |
564 | if (ACPI_FAILURE(status)) { | |
565 | return (status); | |
566 | } | |
567 | } | |
568 | elements++; | |
569 | } | |
570 | break; | |
571 | ||
53e9387b BM |
572 | case ACPI_PTYPE2_REV_FIXED: |
573 | ||
574 | /* First element is the (Integer) revision */ | |
575 | ||
576 | status = acpi_ns_check_object_type(data, elements, | |
577 | ACPI_RTYPE_INTEGER, 0); | |
578 | if (ACPI_FAILURE(status)) { | |
579 | return (status); | |
580 | } | |
581 | ||
582 | elements++; | |
583 | count--; | |
584 | ||
585 | /* Examine the sub-packages */ | |
586 | ||
587 | status = | |
588 | acpi_ns_check_package_list(data, package, elements, count); | |
589 | break; | |
590 | ||
e8707b34 BM |
591 | case ACPI_PTYPE2_PKG_COUNT: |
592 | ||
593 | /* First element is the (Integer) count of sub-packages to follow */ | |
594 | ||
0444e8f6 | 595 | status = acpi_ns_check_object_type(data, elements, |
e8707b34 BM |
596 | ACPI_RTYPE_INTEGER, 0); |
597 | if (ACPI_FAILURE(status)) { | |
598 | return (status); | |
599 | } | |
600 | ||
601 | /* | |
602 | * Count cannot be larger than the parent package length, but allow it | |
603 | * to be smaller. The >= accounts for the Integer above. | |
604 | */ | |
605 | expected_count = (u32) (*elements)->integer.value; | |
606 | if (expected_count >= count) { | |
607 | goto package_too_small; | |
608 | } | |
609 | ||
610 | count = expected_count; | |
611 | elements++; | |
612 | ||
53e9387b | 613 | /* Examine the sub-packages */ |
e8707b34 | 614 | |
53e9387b BM |
615 | status = |
616 | acpi_ns_check_package_list(data, package, elements, count); | |
617 | break; | |
e8707b34 BM |
618 | |
619 | case ACPI_PTYPE2: | |
620 | case ACPI_PTYPE2_FIXED: | |
621 | case ACPI_PTYPE2_MIN: | |
622 | case ACPI_PTYPE2_COUNT: | |
7fce7a4b | 623 | case ACPI_PTYPE2_FIX_VAR: |
e8707b34 BM |
624 | |
625 | /* | |
e5f69d6e BM |
626 | * These types all return a single Package that consists of a |
627 | * variable number of sub-Packages. | |
628 | * | |
629 | * First, ensure that the first element is a sub-Package. If not, | |
630 | * the BIOS may have incorrectly returned the object as a single | |
631 | * package instead of a Package of Packages (a common error if | |
632 | * there is only one entry). We may be able to repair this by | |
633 | * wrapping the returned Package with a new outer Package. | |
e8707b34 | 634 | */ |
419a909d BM |
635 | if (*elements |
636 | && ((*elements)->common.type != ACPI_TYPE_PACKAGE)) { | |
e5f69d6e BM |
637 | |
638 | /* Create the new outer package and populate it */ | |
639 | ||
640 | status = | |
46befd6b | 641 | acpi_ns_wrap_with_package(data, return_object, |
6a99b1c9 | 642 | return_object_ptr); |
e5f69d6e BM |
643 | if (ACPI_FAILURE(status)) { |
644 | return (status); | |
645 | } | |
646 | ||
647 | /* Update locals to point to the new package (of 1 element) */ | |
648 | ||
649 | return_object = *return_object_ptr; | |
650 | elements = return_object->package.elements; | |
651 | count = 1; | |
652 | } | |
653 | ||
53e9387b | 654 | /* Examine the sub-packages */ |
e5f69d6e | 655 | |
53e9387b BM |
656 | status = |
657 | acpi_ns_check_package_list(data, package, elements, count); | |
658 | break; | |
e8707b34 | 659 | |
53e9387b | 660 | default: |
e8707b34 | 661 | |
53e9387b | 662 | /* Should not get here if predefined info table is correct */ |
e8707b34 | 663 | |
53e9387b BM |
664 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
665 | "Invalid internal return type in table entry: %X", | |
666 | package->ret_info.type)); | |
e8707b34 | 667 | |
53e9387b BM |
668 | return (AE_AML_INTERNAL); |
669 | } | |
e8707b34 | 670 | |
53e9387b | 671 | return (status); |
e8707b34 | 672 | |
53e9387b | 673 | package_too_small: |
e8707b34 | 674 | |
53e9387b | 675 | /* Error exit for the case with an incorrect package count */ |
e8707b34 | 676 | |
53e9387b BM |
677 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
678 | "Return Package is too small - found %u elements, expected %u", | |
679 | count, expected_count)); | |
e8707b34 | 680 | |
53e9387b BM |
681 | return (AE_AML_OPERAND_VALUE); |
682 | } | |
e8707b34 | 683 | |
53e9387b BM |
684 | /******************************************************************************* |
685 | * | |
686 | * FUNCTION: acpi_ns_check_package_list | |
687 | * | |
ba494bee BM |
688 | * PARAMETERS: data - Pointer to validation data structure |
689 | * package - Pointer to package-specific info for method | |
690 | * elements - Element list of parent package. All elements | |
53e9387b | 691 | * of this list should be of type Package. |
ba494bee | 692 | * count - Count of subpackages |
53e9387b BM |
693 | * |
694 | * RETURN: Status | |
695 | * | |
696 | * DESCRIPTION: Examine a list of subpackages | |
697 | * | |
698 | ******************************************************************************/ | |
e8707b34 | 699 | |
53e9387b BM |
700 | static acpi_status |
701 | acpi_ns_check_package_list(struct acpi_predefined_data *data, | |
702 | const union acpi_predefined_info *package, | |
703 | union acpi_operand_object **elements, u32 count) | |
704 | { | |
705 | union acpi_operand_object *sub_package; | |
706 | union acpi_operand_object **sub_elements; | |
707 | acpi_status status; | |
708 | u32 expected_count; | |
709 | u32 i; | |
710 | u32 j; | |
e8707b34 | 711 | |
d4085a3f BM |
712 | /* |
713 | * Validate each sub-Package in the parent Package | |
714 | * | |
715 | * NOTE: assumes list of sub-packages contains no NULL elements. | |
716 | * Any NULL elements should have been removed by earlier call | |
717 | * to acpi_ns_remove_null_elements. | |
718 | */ | |
53e9387b BM |
719 | for (i = 0; i < count; i++) { |
720 | sub_package = *elements; | |
721 | sub_elements = sub_package->package.elements; | |
091f4d71 | 722 | data->parent_package = sub_package; |
e8707b34 | 723 | |
53e9387b | 724 | /* Each sub-object must be of type Package */ |
e8707b34 | 725 | |
53e9387b BM |
726 | status = acpi_ns_check_object_type(data, &sub_package, |
727 | ACPI_RTYPE_PACKAGE, i); | |
728 | if (ACPI_FAILURE(status)) { | |
729 | return (status); | |
730 | } | |
e8707b34 | 731 | |
53e9387b | 732 | /* Examine the different types of expected sub-packages */ |
e8707b34 | 733 | |
091f4d71 | 734 | data->parent_package = sub_package; |
53e9387b BM |
735 | switch (package->ret_info.type) { |
736 | case ACPI_PTYPE2: | |
737 | case ACPI_PTYPE2_PKG_COUNT: | |
738 | case ACPI_PTYPE2_REV_FIXED: | |
739 | ||
740 | /* Each subpackage has a fixed number of elements */ | |
741 | ||
742 | expected_count = | |
743 | package->ret_info.count1 + package->ret_info.count2; | |
744 | if (sub_package->package.count < expected_count) { | |
745 | goto package_too_small; | |
746 | } | |
747 | ||
748 | status = | |
749 | acpi_ns_check_package_elements(data, sub_elements, | |
750 | package->ret_info. | |
751 | object_type1, | |
752 | package->ret_info. | |
753 | count1, | |
754 | package->ret_info. | |
755 | object_type2, | |
756 | package->ret_info. | |
757 | count2, 0); | |
758 | if (ACPI_FAILURE(status)) { | |
759 | return (status); | |
760 | } | |
761 | break; | |
762 | ||
7fce7a4b BM |
763 | case ACPI_PTYPE2_FIX_VAR: |
764 | /* | |
765 | * Each subpackage has a fixed number of elements and an | |
766 | * optional element | |
767 | */ | |
768 | expected_count = | |
769 | package->ret_info.count1 + package->ret_info.count2; | |
770 | if (sub_package->package.count < expected_count) { | |
771 | goto package_too_small; | |
772 | } | |
773 | ||
774 | status = | |
775 | acpi_ns_check_package_elements(data, sub_elements, | |
776 | package->ret_info. | |
777 | object_type1, | |
778 | package->ret_info. | |
779 | count1, | |
780 | package->ret_info. | |
781 | object_type2, | |
782 | sub_package->package. | |
783 | count - | |
784 | package->ret_info. | |
785 | count1, 0); | |
786 | if (ACPI_FAILURE(status)) { | |
787 | return (status); | |
788 | } | |
789 | break; | |
790 | ||
53e9387b BM |
791 | case ACPI_PTYPE2_FIXED: |
792 | ||
793 | /* Each sub-package has a fixed length */ | |
e8707b34 | 794 | |
53e9387b BM |
795 | expected_count = package->ret_info2.count; |
796 | if (sub_package->package.count < expected_count) { | |
797 | goto package_too_small; | |
798 | } | |
e8707b34 | 799 | |
53e9387b | 800 | /* Check the type of each sub-package element */ |
e8707b34 | 801 | |
53e9387b | 802 | for (j = 0; j < expected_count; j++) { |
e8707b34 | 803 | status = |
0444e8f6 | 804 | acpi_ns_check_object_type(data, |
53e9387b BM |
805 | &sub_elements[j], |
806 | package-> | |
807 | ret_info2. | |
808 | object_type[j], | |
809 | j); | |
e8707b34 BM |
810 | if (ACPI_FAILURE(status)) { |
811 | return (status); | |
812 | } | |
53e9387b BM |
813 | } |
814 | break; | |
e8707b34 | 815 | |
53e9387b | 816 | case ACPI_PTYPE2_MIN: |
e8707b34 | 817 | |
53e9387b | 818 | /* Each sub-package has a variable but minimum length */ |
e8707b34 | 819 | |
53e9387b BM |
820 | expected_count = package->ret_info.count1; |
821 | if (sub_package->package.count < expected_count) { | |
822 | goto package_too_small; | |
823 | } | |
e8707b34 | 824 | |
53e9387b | 825 | /* Check the type of each sub-package element */ |
e8707b34 | 826 | |
53e9387b BM |
827 | status = |
828 | acpi_ns_check_package_elements(data, sub_elements, | |
829 | package->ret_info. | |
830 | object_type1, | |
831 | sub_package->package. | |
832 | count, 0, 0, 0); | |
833 | if (ACPI_FAILURE(status)) { | |
834 | return (status); | |
e8707b34 | 835 | } |
53e9387b | 836 | break; |
e8707b34 | 837 | |
53e9387b | 838 | case ACPI_PTYPE2_COUNT: |
e8707b34 | 839 | |
53e9387b BM |
840 | /* |
841 | * First element is the (Integer) count of elements, including | |
091f4d71 | 842 | * the count field (the ACPI name is num_elements) |
53e9387b BM |
843 | */ |
844 | status = acpi_ns_check_object_type(data, sub_elements, | |
845 | ACPI_RTYPE_INTEGER, | |
846 | 0); | |
847 | if (ACPI_FAILURE(status)) { | |
848 | return (status); | |
849 | } | |
e8707b34 | 850 | |
53e9387b BM |
851 | /* |
852 | * Make sure package is large enough for the Count and is | |
853 | * is as large as the minimum size | |
854 | */ | |
855 | expected_count = (u32)(*sub_elements)->integer.value; | |
856 | if (sub_package->package.count < expected_count) { | |
857 | goto package_too_small; | |
858 | } | |
859 | if (sub_package->package.count < | |
860 | package->ret_info.count1) { | |
861 | expected_count = package->ret_info.count1; | |
862 | goto package_too_small; | |
863 | } | |
091f4d71 BM |
864 | if (expected_count == 0) { |
865 | /* | |
866 | * Either the num_entries element was originally zero or it was | |
867 | * a NULL element and repaired to an Integer of value zero. | |
868 | * In either case, repair it by setting num_entries to be the | |
869 | * actual size of the subpackage. | |
870 | */ | |
871 | expected_count = sub_package->package.count; | |
872 | (*sub_elements)->integer.value = expected_count; | |
873 | } | |
e8707b34 | 874 | |
53e9387b | 875 | /* Check the type of each sub-package element */ |
e8707b34 | 876 | |
53e9387b BM |
877 | status = |
878 | acpi_ns_check_package_elements(data, | |
879 | (sub_elements + 1), | |
880 | package->ret_info. | |
881 | object_type1, | |
882 | (expected_count - 1), | |
883 | 0, 0, 1); | |
884 | if (ACPI_FAILURE(status)) { | |
885 | return (status); | |
886 | } | |
887 | break; | |
888 | ||
889 | default: /* Should not get here, type was validated by caller */ | |
890 | ||
891 | return (AE_AML_INTERNAL); | |
892 | } | |
893 | ||
894 | elements++; | |
e8707b34 BM |
895 | } |
896 | ||
897 | return (AE_OK); | |
898 | ||
53e9387b | 899 | package_too_small: |
e8707b34 | 900 | |
53e9387b | 901 | /* The sub-package count was smaller than required */ |
e8707b34 | 902 | |
0444e8f6 | 903 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
53e9387b BM |
904 | "Return Sub-Package[%u] is too small - found %u elements, expected %u", |
905 | i, sub_package->package.count, expected_count)); | |
e8707b34 BM |
906 | |
907 | return (AE_AML_OPERAND_VALUE); | |
908 | } | |
909 | ||
910 | /******************************************************************************* | |
911 | * | |
912 | * FUNCTION: acpi_ns_check_package_elements | |
913 | * | |
ba494bee BM |
914 | * PARAMETERS: data - Pointer to validation data structure |
915 | * elements - Pointer to the package elements array | |
916 | * type1 - Object type for first group | |
917 | * count1 - Count for first group | |
918 | * type2 - Object type for second group | |
919 | * count2 - Count for second group | |
03ef132b | 920 | * start_index - Start of the first group of elements |
e8707b34 BM |
921 | * |
922 | * RETURN: Status | |
923 | * | |
924 | * DESCRIPTION: Check that all elements of a package are of the correct object | |
925 | * type. Supports up to two groups of different object types. | |
926 | * | |
927 | ******************************************************************************/ | |
928 | ||
929 | static acpi_status | |
0444e8f6 | 930 | acpi_ns_check_package_elements(struct acpi_predefined_data *data, |
e8707b34 | 931 | union acpi_operand_object **elements, |
03ef132b BM |
932 | u8 type1, |
933 | u32 count1, | |
934 | u8 type2, u32 count2, u32 start_index) | |
e8707b34 BM |
935 | { |
936 | union acpi_operand_object **this_element = elements; | |
937 | acpi_status status; | |
938 | u32 i; | |
939 | ||
940 | /* | |
941 | * Up to two groups of package elements are supported by the data | |
942 | * structure. All elements in each group must be of the same type. | |
943 | * The second group can have a count of zero. | |
944 | */ | |
945 | for (i = 0; i < count1; i++) { | |
0444e8f6 | 946 | status = acpi_ns_check_object_type(data, this_element, |
03ef132b | 947 | type1, i + start_index); |
e8707b34 BM |
948 | if (ACPI_FAILURE(status)) { |
949 | return (status); | |
950 | } | |
951 | this_element++; | |
952 | } | |
953 | ||
954 | for (i = 0; i < count2; i++) { | |
0444e8f6 | 955 | status = acpi_ns_check_object_type(data, this_element, |
03ef132b BM |
956 | type2, |
957 | (i + count1 + start_index)); | |
e8707b34 BM |
958 | if (ACPI_FAILURE(status)) { |
959 | return (status); | |
960 | } | |
961 | this_element++; | |
962 | } | |
963 | ||
964 | return (AE_OK); | |
965 | } | |
966 | ||
967 | /******************************************************************************* | |
968 | * | |
969 | * FUNCTION: acpi_ns_check_object_type | |
970 | * | |
ba494bee | 971 | * PARAMETERS: data - Pointer to validation data structure |
a647b5c3 BM |
972 | * return_object_ptr - Pointer to the object returned from the |
973 | * evaluation of a method or object | |
e8707b34 BM |
974 | * expected_btypes - Bitmap of expected return type(s) |
975 | * package_index - Index of object within parent package (if | |
0444e8f6 BM |
976 | * applicable - ACPI_NOT_PACKAGE_ELEMENT |
977 | * otherwise) | |
e8707b34 BM |
978 | * |
979 | * RETURN: Status | |
980 | * | |
981 | * DESCRIPTION: Check the type of the return object against the expected object | |
982 | * type(s). Use of Btype allows multiple expected object types. | |
983 | * | |
984 | ******************************************************************************/ | |
985 | ||
986 | static acpi_status | |
0444e8f6 | 987 | acpi_ns_check_object_type(struct acpi_predefined_data *data, |
a647b5c3 | 988 | union acpi_operand_object **return_object_ptr, |
e8707b34 BM |
989 | u32 expected_btypes, u32 package_index) |
990 | { | |
a647b5c3 | 991 | union acpi_operand_object *return_object = *return_object_ptr; |
e8707b34 BM |
992 | acpi_status status = AE_OK; |
993 | u32 return_btype; | |
994 | char type_buffer[48]; /* Room for 5 types */ | |
e8707b34 BM |
995 | |
996 | /* | |
091f4d71 BM |
997 | * If we get a NULL return_object here, it is a NULL package element. |
998 | * Since all extraneous NULL package elements were removed earlier by a | |
999 | * call to acpi_ns_remove_null_elements, this is an unexpected NULL element. | |
1000 | * We will attempt to repair it. | |
e8707b34 BM |
1001 | */ |
1002 | if (!return_object) { | |
091f4d71 BM |
1003 | status = acpi_ns_repair_null_element(data, expected_btypes, |
1004 | package_index, | |
1005 | return_object_ptr); | |
1006 | if (ACPI_SUCCESS(status)) { | |
1007 | return (AE_OK); /* Repair was successful */ | |
1008 | } | |
e8707b34 BM |
1009 | goto type_error_exit; |
1010 | } | |
1011 | ||
1012 | /* A Namespace node should not get here, but make sure */ | |
1013 | ||
1014 | if (ACPI_GET_DESCRIPTOR_TYPE(return_object) == ACPI_DESC_TYPE_NAMED) { | |
0444e8f6 BM |
1015 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
1016 | "Invalid return type - Found a Namespace node [%4.4s] type %s", | |
1017 | return_object->node.name.ascii, | |
1018 | acpi_ut_get_type_name(return_object->node. | |
1019 | type))); | |
e8707b34 BM |
1020 | return (AE_AML_OPERAND_TYPE); |
1021 | } | |
1022 | ||
1023 | /* | |
1024 | * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type. | |
1025 | * The bitmapped type allows multiple possible return types. | |
1026 | * | |
1027 | * Note, the cases below must handle all of the possible types returned | |
1028 | * from all of the predefined names (including elements of returned | |
1029 | * packages) | |
1030 | */ | |
3371c19c | 1031 | switch (return_object->common.type) { |
e8707b34 BM |
1032 | case ACPI_TYPE_INTEGER: |
1033 | return_btype = ACPI_RTYPE_INTEGER; | |
1034 | break; | |
1035 | ||
1036 | case ACPI_TYPE_BUFFER: | |
1037 | return_btype = ACPI_RTYPE_BUFFER; | |
1038 | break; | |
1039 | ||
1040 | case ACPI_TYPE_STRING: | |
1041 | return_btype = ACPI_RTYPE_STRING; | |
1042 | break; | |
1043 | ||
1044 | case ACPI_TYPE_PACKAGE: | |
1045 | return_btype = ACPI_RTYPE_PACKAGE; | |
1046 | break; | |
1047 | ||
1048 | case ACPI_TYPE_LOCAL_REFERENCE: | |
1049 | return_btype = ACPI_RTYPE_REFERENCE; | |
1050 | break; | |
1051 | ||
1052 | default: | |
1053 | /* Not one of the supported objects, must be incorrect */ | |
1054 | ||
1055 | goto type_error_exit; | |
1056 | } | |
1057 | ||
1058 | /* Is the object one of the expected types? */ | |
1059 | ||
2147d3f0 | 1060 | if (return_btype & expected_btypes) { |
a647b5c3 | 1061 | |
2147d3f0 | 1062 | /* For reference objects, check that the reference type is correct */ |
a647b5c3 | 1063 | |
2147d3f0 BM |
1064 | if (return_object->common.type == ACPI_TYPE_LOCAL_REFERENCE) { |
1065 | status = acpi_ns_check_reference(data, return_object); | |
a647b5c3 | 1066 | } |
2147d3f0 BM |
1067 | |
1068 | return (status); | |
e8707b34 BM |
1069 | } |
1070 | ||
2147d3f0 | 1071 | /* Type mismatch -- attempt repair of the returned object */ |
e8707b34 | 1072 | |
2147d3f0 BM |
1073 | status = acpi_ns_repair_object(data, expected_btypes, |
1074 | package_index, return_object_ptr); | |
1075 | if (ACPI_SUCCESS(status)) { | |
1076 | return (AE_OK); /* Repair was successful */ | |
e8707b34 BM |
1077 | } |
1078 | ||
e8707b34 BM |
1079 | type_error_exit: |
1080 | ||
1081 | /* Create a string with all expected types for this predefined object */ | |
1082 | ||
0444e8f6 | 1083 | acpi_ns_get_expected_types(type_buffer, expected_btypes); |
e8707b34 | 1084 | |
0444e8f6 BM |
1085 | if (package_index == ACPI_NOT_PACKAGE_ELEMENT) { |
1086 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, | |
1087 | "Return type mismatch - found %s, expected %s", | |
1088 | acpi_ut_get_object_type_name | |
1089 | (return_object), type_buffer)); | |
e8707b34 | 1090 | } else { |
0444e8f6 BM |
1091 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
1092 | "Return Package type mismatch at index %u - " | |
1093 | "found %s, expected %s", package_index, | |
1094 | acpi_ut_get_object_type_name | |
1095 | (return_object), type_buffer)); | |
e8707b34 BM |
1096 | } |
1097 | ||
1098 | return (AE_AML_OPERAND_TYPE); | |
1099 | } | |
1100 | ||
1101 | /******************************************************************************* | |
1102 | * | |
1103 | * FUNCTION: acpi_ns_check_reference | |
1104 | * | |
ba494bee | 1105 | * PARAMETERS: data - Pointer to validation data structure |
e8707b34 BM |
1106 | * return_object - Object returned from the evaluation of a |
1107 | * method or object | |
1108 | * | |
1109 | * RETURN: Status | |
1110 | * | |
1111 | * DESCRIPTION: Check a returned reference object for the correct reference | |
1112 | * type. The only reference type that can be returned from a | |
1113 | * predefined method is a named reference. All others are invalid. | |
1114 | * | |
1115 | ******************************************************************************/ | |
1116 | ||
1117 | static acpi_status | |
0444e8f6 | 1118 | acpi_ns_check_reference(struct acpi_predefined_data *data, |
e8707b34 BM |
1119 | union acpi_operand_object *return_object) |
1120 | { | |
1121 | ||
1122 | /* | |
1123 | * Check the reference object for the correct reference type (opcode). | |
1124 | * The only type of reference that can be converted to an union acpi_object is | |
1125 | * a reference to a named object (reference class: NAME) | |
1126 | */ | |
1127 | if (return_object->reference.class == ACPI_REFCLASS_NAME) { | |
1128 | return (AE_OK); | |
1129 | } | |
1130 | ||
0444e8f6 BM |
1131 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
1132 | "Return type mismatch - unexpected reference object type [%s] %2.2X", | |
1133 | acpi_ut_get_reference_name(return_object), | |
1134 | return_object->reference.class)); | |
e8707b34 BM |
1135 | |
1136 | return (AE_AML_OPERAND_TYPE); | |
1137 | } | |
a647b5c3 | 1138 | |
0444e8f6 BM |
1139 | /******************************************************************************* |
1140 | * | |
1141 | * FUNCTION: acpi_ns_get_expected_types | |
1142 | * | |
ba494bee | 1143 | * PARAMETERS: buffer - Pointer to where the string is returned |
0444e8f6 BM |
1144 | * expected_btypes - Bitmap of expected return type(s) |
1145 | * | |
1146 | * RETURN: Buffer is populated with type names. | |
1147 | * | |
1148 | * DESCRIPTION: Translate the expected types bitmap into a string of ascii | |
1149 | * names of expected types, for use in warning messages. | |
1150 | * | |
1151 | ******************************************************************************/ | |
1152 | ||
1153 | static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes) | |
1154 | { | |
1155 | u32 this_rtype; | |
1156 | u32 i; | |
1157 | u32 j; | |
1158 | ||
1159 | j = 1; | |
1160 | buffer[0] = 0; | |
1161 | this_rtype = ACPI_RTYPE_INTEGER; | |
1162 | ||
1163 | for (i = 0; i < ACPI_NUM_RTYPES; i++) { | |
1164 | ||
1165 | /* If one of the expected types, concatenate the name of this type */ | |
1166 | ||
1167 | if (expected_btypes & this_rtype) { | |
1168 | ACPI_STRCAT(buffer, &acpi_rtype_names[i][j]); | |
1169 | j = 0; /* Use name separator from now on */ | |
1170 | } | |
1171 | this_rtype <<= 1; /* Next Rtype */ | |
1172 | } | |
1173 | } |