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 | /* | |
9 | * Copyright (C) 2000 - 2008, Intel Corp. | |
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 | ||
45 | #include <acpi/acpi.h> | |
e2f7a777 LB |
46 | #include "accommon.h" |
47 | #include "acnamesp.h" | |
48 | #include "acpredef.h" | |
e8707b34 BM |
49 | |
50 | #define _COMPONENT ACPI_NAMESPACE | |
51 | ACPI_MODULE_NAME("nspredef") | |
52 | ||
53 | /******************************************************************************* | |
54 | * | |
55 | * This module validates predefined ACPI objects that appear in the namespace, | |
56 | * at the time they are evaluated (via acpi_evaluate_object). The purpose of this | |
57 | * validation is to detect problems with BIOS-exposed predefined ACPI objects | |
58 | * before the results are returned to the ACPI-related drivers. | |
59 | * | |
60 | * There are several areas that are validated: | |
61 | * | |
62 | * 1) The number of input arguments as defined by the method/object in the | |
63 | * ASL is validated against the ACPI specification. | |
64 | * 2) The type of the return object (if any) is validated against the ACPI | |
65 | * specification. | |
66 | * 3) For returned package objects, the count of package elements is | |
67 | * validated, as well as the type of each package element. Nested | |
68 | * packages are supported. | |
69 | * | |
70 | * For any problems found, a warning message is issued. | |
71 | * | |
72 | ******************************************************************************/ | |
73 | /* Local prototypes */ | |
74 | static acpi_status | |
0444e8f6 BM |
75 | acpi_ns_check_package(struct acpi_predefined_data *data, |
76 | union acpi_operand_object **return_object_ptr); | |
e8707b34 BM |
77 | |
78 | static acpi_status | |
0444e8f6 | 79 | acpi_ns_check_package_elements(struct acpi_predefined_data *data, |
e8707b34 | 80 | union acpi_operand_object **elements, |
03ef132b BM |
81 | u8 type1, |
82 | u32 count1, | |
83 | u8 type2, u32 count2, u32 start_index); | |
e8707b34 BM |
84 | |
85 | static acpi_status | |
0444e8f6 | 86 | acpi_ns_check_object_type(struct acpi_predefined_data *data, |
a647b5c3 | 87 | union acpi_operand_object **return_object_ptr, |
e8707b34 BM |
88 | u32 expected_btypes, u32 package_index); |
89 | ||
90 | static acpi_status | |
0444e8f6 | 91 | acpi_ns_check_reference(struct acpi_predefined_data *data, |
e8707b34 BM |
92 | union acpi_operand_object *return_object); |
93 | ||
0444e8f6 BM |
94 | static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes); |
95 | ||
e8707b34 BM |
96 | /* |
97 | * Names for the types that can be returned by the predefined objects. | |
98 | * Used for warning messages. Must be in the same order as the ACPI_RTYPEs | |
99 | */ | |
100 | static const char *acpi_rtype_names[] = { | |
101 | "/Integer", | |
102 | "/String", | |
103 | "/Buffer", | |
104 | "/Package", | |
105 | "/Reference", | |
106 | }; | |
107 | ||
e8707b34 BM |
108 | /******************************************************************************* |
109 | * | |
110 | * FUNCTION: acpi_ns_check_predefined_names | |
111 | * | |
112 | * PARAMETERS: Node - Namespace node for the method/object | |
0444e8f6 BM |
113 | * user_param_count - Number of parameters actually passed |
114 | * return_status - Status from the object evaluation | |
a647b5c3 BM |
115 | * return_object_ptr - Pointer to the object returned from the |
116 | * evaluation of a method or object | |
e8707b34 BM |
117 | * |
118 | * RETURN: Status | |
119 | * | |
120 | * DESCRIPTION: Check an ACPI name for a match in the predefined name list. | |
121 | * | |
122 | ******************************************************************************/ | |
123 | ||
124 | acpi_status | |
125 | acpi_ns_check_predefined_names(struct acpi_namespace_node *node, | |
eeb4437e BM |
126 | u32 user_param_count, |
127 | acpi_status return_status, | |
a647b5c3 | 128 | union acpi_operand_object **return_object_ptr) |
e8707b34 | 129 | { |
a647b5c3 | 130 | union acpi_operand_object *return_object = *return_object_ptr; |
e8707b34 BM |
131 | acpi_status status = AE_OK; |
132 | const union acpi_predefined_info *predefined; | |
133 | char *pathname; | |
0444e8f6 | 134 | struct acpi_predefined_data *data; |
e8707b34 BM |
135 | |
136 | /* Match the name for this method/object against the predefined list */ | |
137 | ||
138 | predefined = acpi_ns_check_for_predefined_name(node); | |
e8707b34 | 139 | |
0444e8f6 | 140 | /* Get the full pathname to the object, for use in warning messages */ |
e8707b34 BM |
141 | |
142 | pathname = acpi_ns_get_external_pathname(node); | |
143 | if (!pathname) { | |
65259094 | 144 | return AE_OK; /* Could not get pathname, ignore */ |
e8707b34 BM |
145 | } |
146 | ||
147 | /* | |
eeb4437e BM |
148 | * Check that the parameter count for this method matches the ASL |
149 | * definition. For predefined names, ensure that both the caller and | |
150 | * the method itself are in accordance with the ACPI specification. | |
151 | */ | |
152 | acpi_ns_check_parameter_count(pathname, node, user_param_count, | |
153 | predefined); | |
154 | ||
155 | /* If not a predefined name, we cannot validate the return object */ | |
156 | ||
157 | if (!predefined) { | |
0444e8f6 | 158 | goto cleanup; |
eeb4437e BM |
159 | } |
160 | ||
161 | /* | |
0444e8f6 BM |
162 | * If the method failed or did not actually return an object, we cannot |
163 | * validate the return object | |
e8707b34 | 164 | */ |
0444e8f6 BM |
165 | if ((return_status != AE_OK) && (return_status != AE_CTRL_RETURN_VALUE)) { |
166 | goto cleanup; | |
eeb4437e BM |
167 | } |
168 | ||
e8707b34 BM |
169 | /* |
170 | * If there is no return value, check if we require a return value for | |
171 | * this predefined name. Either one return value is expected, or none, | |
172 | * for both methods and other objects. | |
173 | * | |
174 | * Exit now if there is no return object. Warning if one was expected. | |
175 | */ | |
176 | if (!return_object) { | |
177 | if ((predefined->info.expected_btypes) && | |
178 | (!(predefined->info.expected_btypes & ACPI_RTYPE_NONE))) { | |
0444e8f6 BM |
179 | ACPI_WARN_PREDEFINED((AE_INFO, pathname, |
180 | ACPI_WARN_ALWAYS, | |
181 | "Missing expected return value")); | |
e8707b34 BM |
182 | |
183 | status = AE_AML_NO_RETURN_VALUE; | |
184 | } | |
0444e8f6 | 185 | goto cleanup; |
e8707b34 BM |
186 | } |
187 | ||
188 | /* | |
189 | * We have a return value, but if one wasn't expected, just exit, this is | |
0444e8f6 BM |
190 | * not a problem. For example, if the "Implicit Return" feature is |
191 | * enabled, methods will always return a value. | |
e8707b34 BM |
192 | */ |
193 | if (!predefined->info.expected_btypes) { | |
0444e8f6 BM |
194 | goto cleanup; |
195 | } | |
196 | ||
197 | /* Create the parameter data block for object validation */ | |
198 | ||
199 | data = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_predefined_data)); | |
200 | if (!data) { | |
201 | goto cleanup; | |
e8707b34 | 202 | } |
0444e8f6 BM |
203 | data->predefined = predefined; |
204 | data->node_flags = node->flags; | |
205 | data->pathname = pathname; | |
e8707b34 BM |
206 | |
207 | /* | |
208 | * Check that the type of the return object is what is expected for | |
209 | * this predefined name | |
210 | */ | |
0444e8f6 | 211 | status = acpi_ns_check_object_type(data, return_object_ptr, |
e8707b34 | 212 | predefined->info.expected_btypes, |
0444e8f6 | 213 | ACPI_NOT_PACKAGE_ELEMENT); |
e8707b34 | 214 | if (ACPI_FAILURE(status)) { |
0444e8f6 | 215 | goto check_validation_status; |
e8707b34 BM |
216 | } |
217 | ||
218 | /* For returned Package objects, check the type of all sub-objects */ | |
219 | ||
3371c19c | 220 | if (return_object->common.type == ACPI_TYPE_PACKAGE) { |
0444e8f6 | 221 | status = acpi_ns_check_package(data, return_object_ptr); |
e8707b34 BM |
222 | } |
223 | ||
0444e8f6 BM |
224 | check_validation_status: |
225 | /* | |
226 | * If the object validation failed or if we successfully repaired one | |
227 | * or more objects, mark the parent node to suppress further warning | |
228 | * messages during the next evaluation of the same method/object. | |
229 | */ | |
230 | if (ACPI_FAILURE(status) || (data->flags & ACPI_OBJECT_REPAIRED)) { | |
231 | node->flags |= ANOBJ_EVALUATED; | |
232 | } | |
233 | ACPI_FREE(data); | |
234 | ||
235 | cleanup: | |
65259094 | 236 | ACPI_FREE(pathname); |
e8707b34 BM |
237 | return (status); |
238 | } | |
239 | ||
240 | /******************************************************************************* | |
241 | * | |
242 | * FUNCTION: acpi_ns_check_parameter_count | |
243 | * | |
244 | * PARAMETERS: Pathname - Full pathname to the node (for error msgs) | |
245 | * Node - Namespace node for the method/object | |
eeb4437e | 246 | * user_param_count - Number of args passed in by the caller |
e8707b34 BM |
247 | * Predefined - Pointer to entry in predefined name table |
248 | * | |
249 | * RETURN: None | |
250 | * | |
251 | * DESCRIPTION: Check that the declared (in ASL/AML) parameter count for a | |
252 | * predefined name is what is expected (i.e., what is defined in | |
253 | * the ACPI specification for this predefined name.) | |
254 | * | |
255 | ******************************************************************************/ | |
256 | ||
257 | void | |
258 | acpi_ns_check_parameter_count(char *pathname, | |
259 | struct acpi_namespace_node *node, | |
eeb4437e | 260 | u32 user_param_count, |
e8707b34 BM |
261 | const union acpi_predefined_info *predefined) |
262 | { | |
263 | u32 param_count; | |
264 | u32 required_params_current; | |
265 | u32 required_params_old; | |
266 | ||
eeb4437e BM |
267 | /* Methods have 0-7 parameters. All other types have zero. */ |
268 | ||
e8707b34 BM |
269 | param_count = 0; |
270 | if (node->type == ACPI_TYPE_METHOD) { | |
271 | param_count = node->object->method.param_count; | |
272 | } | |
273 | ||
eeb4437e BM |
274 | if (!predefined) { |
275 | /* | |
0444e8f6 BM |
276 | * Check the parameter count for non-predefined methods/objects. |
277 | * | |
eeb4437e BM |
278 | * Warning if too few or too many arguments have been passed by the |
279 | * caller. An incorrect number of arguments may not cause the method | |
280 | * to fail. However, the method will fail if there are too few | |
281 | * arguments and the method attempts to use one of the missing ones. | |
282 | */ | |
283 | if (user_param_count < param_count) { | |
0444e8f6 BM |
284 | ACPI_WARN_PREDEFINED((AE_INFO, pathname, |
285 | ACPI_WARN_ALWAYS, | |
286 | "Insufficient arguments - needs %u, found %u", | |
287 | param_count, user_param_count)); | |
eeb4437e | 288 | } else if (user_param_count > param_count) { |
0444e8f6 BM |
289 | ACPI_WARN_PREDEFINED((AE_INFO, pathname, |
290 | ACPI_WARN_ALWAYS, | |
291 | "Excess arguments - needs %u, found %u", | |
292 | param_count, user_param_count)); | |
eeb4437e BM |
293 | } |
294 | return; | |
295 | } | |
296 | ||
0444e8f6 BM |
297 | /* |
298 | * Validate the user-supplied parameter count. | |
299 | * Allow two different legal argument counts (_SCP, etc.) | |
300 | */ | |
e8707b34 BM |
301 | required_params_current = predefined->info.param_count & 0x0F; |
302 | required_params_old = predefined->info.param_count >> 4; | |
303 | ||
eeb4437e | 304 | if (user_param_count != ACPI_UINT32_MAX) { |
eeb4437e BM |
305 | if ((user_param_count != required_params_current) && |
306 | (user_param_count != required_params_old)) { | |
0444e8f6 BM |
307 | ACPI_WARN_PREDEFINED((AE_INFO, pathname, |
308 | ACPI_WARN_ALWAYS, | |
309 | "Parameter count mismatch - " | |
310 | "caller passed %u, ACPI requires %u", | |
311 | user_param_count, | |
312 | required_params_current)); | |
eeb4437e BM |
313 | } |
314 | } | |
315 | ||
eeb4437e BM |
316 | /* |
317 | * Check that the ASL-defined parameter count is what is expected for | |
0444e8f6 BM |
318 | * this predefined name (parameter count as defined by the ACPI |
319 | * specification) | |
eeb4437e | 320 | */ |
e8707b34 BM |
321 | if ((param_count != required_params_current) && |
322 | (param_count != required_params_old)) { | |
0444e8f6 BM |
323 | ACPI_WARN_PREDEFINED((AE_INFO, pathname, node->flags, |
324 | "Parameter count mismatch - ASL declared %u, ACPI requires %u", | |
325 | param_count, required_params_current)); | |
e8707b34 BM |
326 | } |
327 | } | |
328 | ||
329 | /******************************************************************************* | |
330 | * | |
331 | * FUNCTION: acpi_ns_check_for_predefined_name | |
332 | * | |
333 | * PARAMETERS: Node - Namespace node for the method/object | |
334 | * | |
335 | * RETURN: Pointer to entry in predefined table. NULL indicates not found. | |
336 | * | |
337 | * DESCRIPTION: Check an object name against the predefined object list. | |
338 | * | |
339 | ******************************************************************************/ | |
340 | ||
341 | const union acpi_predefined_info *acpi_ns_check_for_predefined_name(struct | |
342 | acpi_namespace_node | |
343 | *node) | |
344 | { | |
345 | const union acpi_predefined_info *this_name; | |
346 | ||
347 | /* Quick check for a predefined name, first character must be underscore */ | |
348 | ||
349 | if (node->name.ascii[0] != '_') { | |
350 | return (NULL); | |
351 | } | |
352 | ||
353 | /* Search info table for a predefined method/object name */ | |
354 | ||
355 | this_name = predefined_names; | |
356 | while (this_name->info.name[0]) { | |
357 | if (ACPI_COMPARE_NAME(node->name.ascii, this_name->info.name)) { | |
e8707b34 BM |
358 | return (this_name); |
359 | } | |
360 | ||
361 | /* | |
362 | * Skip next entry in the table if this name returns a Package | |
363 | * (next entry contains the package info) | |
364 | */ | |
365 | if (this_name->info.expected_btypes & ACPI_RTYPE_PACKAGE) { | |
366 | this_name++; | |
367 | } | |
368 | ||
369 | this_name++; | |
370 | } | |
371 | ||
0444e8f6 | 372 | return (NULL); /* Not found */ |
e8707b34 BM |
373 | } |
374 | ||
375 | /******************************************************************************* | |
376 | * | |
377 | * FUNCTION: acpi_ns_check_package | |
378 | * | |
0444e8f6 | 379 | * PARAMETERS: Data - Pointer to validation data structure |
a647b5c3 BM |
380 | * return_object_ptr - Pointer to the object returned from the |
381 | * evaluation of a method or object | |
e8707b34 BM |
382 | * |
383 | * RETURN: Status | |
384 | * | |
385 | * DESCRIPTION: Check a returned package object for the correct count and | |
386 | * correct type of all sub-objects. | |
387 | * | |
388 | ******************************************************************************/ | |
389 | ||
390 | static acpi_status | |
0444e8f6 BM |
391 | acpi_ns_check_package(struct acpi_predefined_data *data, |
392 | union acpi_operand_object **return_object_ptr) | |
e8707b34 | 393 | { |
a647b5c3 | 394 | union acpi_operand_object *return_object = *return_object_ptr; |
e8707b34 BM |
395 | const union acpi_predefined_info *package; |
396 | union acpi_operand_object *sub_package; | |
397 | union acpi_operand_object **elements; | |
398 | union acpi_operand_object **sub_elements; | |
399 | acpi_status status; | |
400 | u32 expected_count; | |
401 | u32 count; | |
402 | u32 i; | |
403 | u32 j; | |
404 | ||
405 | ACPI_FUNCTION_NAME(ns_check_package); | |
406 | ||
407 | /* The package info for this name is in the next table entry */ | |
408 | ||
0444e8f6 | 409 | package = data->predefined + 1; |
e8707b34 BM |
410 | |
411 | ACPI_DEBUG_PRINT((ACPI_DB_NAMES, | |
412 | "%s Validating return Package of Type %X, Count %X\n", | |
0444e8f6 | 413 | data->pathname, package->ret_info.type, |
e8707b34 BM |
414 | return_object->package.count)); |
415 | ||
416 | /* Extract package count and elements array */ | |
417 | ||
418 | elements = return_object->package.elements; | |
419 | count = return_object->package.count; | |
420 | ||
421 | /* The package must have at least one element, else invalid */ | |
422 | ||
423 | if (!count) { | |
0444e8f6 BM |
424 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
425 | "Return Package has no elements (empty)")); | |
e8707b34 BM |
426 | |
427 | return (AE_AML_OPERAND_VALUE); | |
428 | } | |
429 | ||
430 | /* | |
431 | * Decode the type of the expected package contents | |
432 | * | |
433 | * PTYPE1 packages contain no subpackages | |
434 | * PTYPE2 packages contain sub-packages | |
435 | */ | |
436 | switch (package->ret_info.type) { | |
437 | case ACPI_PTYPE1_FIXED: | |
438 | ||
439 | /* | |
440 | * The package count is fixed and there are no sub-packages | |
441 | * | |
442 | * If package is too small, exit. | |
443 | * If package is larger than expected, issue warning but continue | |
444 | */ | |
445 | expected_count = | |
446 | package->ret_info.count1 + package->ret_info.count2; | |
447 | if (count < expected_count) { | |
448 | goto package_too_small; | |
449 | } else if (count > expected_count) { | |
0444e8f6 BM |
450 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, |
451 | data->node_flags, | |
452 | "Return Package is larger than needed - " | |
453 | "found %u, expected %u", count, | |
454 | expected_count)); | |
e8707b34 BM |
455 | } |
456 | ||
457 | /* Validate all elements of the returned package */ | |
458 | ||
0444e8f6 | 459 | status = acpi_ns_check_package_elements(data, elements, |
e8707b34 BM |
460 | package->ret_info. |
461 | object_type1, | |
462 | package->ret_info. | |
463 | count1, | |
464 | package->ret_info. | |
465 | object_type2, | |
466 | package->ret_info. | |
03ef132b | 467 | count2, 0); |
e8707b34 BM |
468 | if (ACPI_FAILURE(status)) { |
469 | return (status); | |
470 | } | |
471 | break; | |
472 | ||
473 | case ACPI_PTYPE1_VAR: | |
474 | ||
475 | /* | |
476 | * The package count is variable, there are no sub-packages, and all | |
477 | * elements must be of the same type | |
478 | */ | |
479 | for (i = 0; i < count; i++) { | |
0444e8f6 | 480 | status = acpi_ns_check_object_type(data, elements, |
e8707b34 BM |
481 | package->ret_info. |
482 | object_type1, i); | |
483 | if (ACPI_FAILURE(status)) { | |
484 | return (status); | |
485 | } | |
486 | elements++; | |
487 | } | |
488 | break; | |
489 | ||
490 | case ACPI_PTYPE1_OPTION: | |
491 | ||
492 | /* | |
493 | * The package count is variable, there are no sub-packages. There are | |
494 | * a fixed number of required elements, and a variable number of | |
495 | * optional elements. | |
496 | * | |
497 | * Check if package is at least as large as the minimum required | |
498 | */ | |
499 | expected_count = package->ret_info3.count; | |
500 | if (count < expected_count) { | |
501 | goto package_too_small; | |
502 | } | |
503 | ||
504 | /* Variable number of sub-objects */ | |
505 | ||
506 | for (i = 0; i < count; i++) { | |
507 | if (i < package->ret_info3.count) { | |
508 | ||
509 | /* These are the required package elements (0, 1, or 2) */ | |
510 | ||
511 | status = | |
0444e8f6 | 512 | acpi_ns_check_object_type(data, elements, |
e8707b34 BM |
513 | package-> |
514 | ret_info3. | |
515 | object_type[i], | |
516 | i); | |
517 | if (ACPI_FAILURE(status)) { | |
518 | return (status); | |
519 | } | |
520 | } else { | |
521 | /* These are the optional package elements */ | |
522 | ||
523 | status = | |
0444e8f6 | 524 | acpi_ns_check_object_type(data, elements, |
e8707b34 BM |
525 | package-> |
526 | ret_info3. | |
527 | tail_object_type, | |
528 | i); | |
529 | if (ACPI_FAILURE(status)) { | |
530 | return (status); | |
531 | } | |
532 | } | |
533 | elements++; | |
534 | } | |
535 | break; | |
536 | ||
537 | case ACPI_PTYPE2_PKG_COUNT: | |
538 | ||
539 | /* First element is the (Integer) count of sub-packages to follow */ | |
540 | ||
0444e8f6 | 541 | status = acpi_ns_check_object_type(data, elements, |
e8707b34 BM |
542 | ACPI_RTYPE_INTEGER, 0); |
543 | if (ACPI_FAILURE(status)) { | |
544 | return (status); | |
545 | } | |
546 | ||
547 | /* | |
548 | * Count cannot be larger than the parent package length, but allow it | |
549 | * to be smaller. The >= accounts for the Integer above. | |
550 | */ | |
551 | expected_count = (u32) (*elements)->integer.value; | |
552 | if (expected_count >= count) { | |
553 | goto package_too_small; | |
554 | } | |
555 | ||
556 | count = expected_count; | |
557 | elements++; | |
558 | ||
559 | /* Now we can walk the sub-packages */ | |
560 | ||
561 | /*lint -fallthrough */ | |
562 | ||
563 | case ACPI_PTYPE2: | |
564 | case ACPI_PTYPE2_FIXED: | |
565 | case ACPI_PTYPE2_MIN: | |
566 | case ACPI_PTYPE2_COUNT: | |
567 | ||
568 | /* | |
b2deadd5 BM |
569 | * These types all return a single package that consists of a |
570 | * variable number of sub-packages. | |
e8707b34 BM |
571 | */ |
572 | for (i = 0; i < count; i++) { | |
573 | sub_package = *elements; | |
574 | sub_elements = sub_package->package.elements; | |
575 | ||
576 | /* Each sub-object must be of type Package */ | |
577 | ||
0444e8f6 BM |
578 | status = acpi_ns_check_object_type(data, &sub_package, |
579 | ACPI_RTYPE_PACKAGE, | |
580 | i); | |
e8707b34 BM |
581 | if (ACPI_FAILURE(status)) { |
582 | return (status); | |
583 | } | |
584 | ||
585 | /* Examine the different types of sub-packages */ | |
586 | ||
587 | switch (package->ret_info.type) { | |
588 | case ACPI_PTYPE2: | |
589 | case ACPI_PTYPE2_PKG_COUNT: | |
590 | ||
591 | /* Each subpackage has a fixed number of elements */ | |
592 | ||
593 | expected_count = | |
594 | package->ret_info.count1 + | |
595 | package->ret_info.count2; | |
596 | if (sub_package->package.count != | |
597 | expected_count) { | |
598 | count = sub_package->package.count; | |
599 | goto package_too_small; | |
600 | } | |
601 | ||
602 | status = | |
0444e8f6 | 603 | acpi_ns_check_package_elements(data, |
e8707b34 BM |
604 | sub_elements, |
605 | package-> | |
606 | ret_info. | |
607 | object_type1, | |
608 | package-> | |
609 | ret_info. | |
610 | count1, | |
611 | package-> | |
612 | ret_info. | |
613 | object_type2, | |
614 | package-> | |
615 | ret_info. | |
03ef132b | 616 | count2, 0); |
e8707b34 BM |
617 | if (ACPI_FAILURE(status)) { |
618 | return (status); | |
619 | } | |
620 | break; | |
621 | ||
622 | case ACPI_PTYPE2_FIXED: | |
623 | ||
624 | /* Each sub-package has a fixed length */ | |
625 | ||
626 | expected_count = package->ret_info2.count; | |
627 | if (sub_package->package.count < expected_count) { | |
628 | count = sub_package->package.count; | |
629 | goto package_too_small; | |
630 | } | |
631 | ||
632 | /* Check the type of each sub-package element */ | |
633 | ||
634 | for (j = 0; j < expected_count; j++) { | |
635 | status = | |
0444e8f6 | 636 | acpi_ns_check_object_type(data, |
a647b5c3 BM |
637 | &sub_elements[j], |
638 | package->ret_info2.object_type[j], j); | |
e8707b34 BM |
639 | if (ACPI_FAILURE(status)) { |
640 | return (status); | |
641 | } | |
642 | } | |
643 | break; | |
644 | ||
645 | case ACPI_PTYPE2_MIN: | |
646 | ||
647 | /* Each sub-package has a variable but minimum length */ | |
648 | ||
649 | expected_count = package->ret_info.count1; | |
650 | if (sub_package->package.count < expected_count) { | |
651 | count = sub_package->package.count; | |
652 | goto package_too_small; | |
653 | } | |
654 | ||
655 | /* Check the type of each sub-package element */ | |
656 | ||
657 | status = | |
0444e8f6 | 658 | acpi_ns_check_package_elements(data, |
e8707b34 BM |
659 | sub_elements, |
660 | package-> | |
661 | ret_info. | |
662 | object_type1, | |
663 | sub_package-> | |
664 | package. | |
03ef132b BM |
665 | count, 0, 0, |
666 | 0); | |
e8707b34 BM |
667 | if (ACPI_FAILURE(status)) { |
668 | return (status); | |
669 | } | |
670 | break; | |
671 | ||
672 | case ACPI_PTYPE2_COUNT: | |
673 | ||
674 | /* First element is the (Integer) count of elements to follow */ | |
675 | ||
676 | status = | |
0444e8f6 | 677 | acpi_ns_check_object_type(data, |
a647b5c3 | 678 | sub_elements, |
e8707b34 BM |
679 | ACPI_RTYPE_INTEGER, |
680 | 0); | |
681 | if (ACPI_FAILURE(status)) { | |
682 | return (status); | |
683 | } | |
684 | ||
685 | /* Make sure package is large enough for the Count */ | |
686 | ||
687 | expected_count = | |
688 | (u32) (*sub_elements)->integer.value; | |
689 | if (sub_package->package.count < expected_count) { | |
690 | count = sub_package->package.count; | |
691 | goto package_too_small; | |
692 | } | |
693 | ||
694 | /* Check the type of each sub-package element */ | |
695 | ||
696 | status = | |
0444e8f6 | 697 | acpi_ns_check_package_elements(data, |
e8707b34 BM |
698 | (sub_elements |
699 | + 1), | |
700 | package-> | |
701 | ret_info. | |
702 | object_type1, | |
703 | (expected_count | |
03ef132b BM |
704 | - 1), 0, 0, |
705 | 1); | |
e8707b34 BM |
706 | if (ACPI_FAILURE(status)) { |
707 | return (status); | |
708 | } | |
709 | break; | |
710 | ||
711 | default: | |
712 | break; | |
713 | } | |
714 | ||
715 | elements++; | |
716 | } | |
717 | break; | |
718 | ||
719 | default: | |
720 | ||
721 | /* Should not get here if predefined info table is correct */ | |
722 | ||
0444e8f6 BM |
723 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
724 | "Invalid internal return type in table entry: %X", | |
725 | package->ret_info.type)); | |
e8707b34 BM |
726 | |
727 | return (AE_AML_INTERNAL); | |
728 | } | |
729 | ||
730 | return (AE_OK); | |
731 | ||
732 | package_too_small: | |
733 | ||
734 | /* Error exit for the case with an incorrect package count */ | |
735 | ||
0444e8f6 BM |
736 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
737 | "Return Package is too small - found %u, expected %u", | |
738 | count, expected_count)); | |
e8707b34 BM |
739 | |
740 | return (AE_AML_OPERAND_VALUE); | |
741 | } | |
742 | ||
743 | /******************************************************************************* | |
744 | * | |
745 | * FUNCTION: acpi_ns_check_package_elements | |
746 | * | |
0444e8f6 | 747 | * PARAMETERS: Data - Pointer to validation data structure |
e8707b34 BM |
748 | * Elements - Pointer to the package elements array |
749 | * Type1 - Object type for first group | |
750 | * Count1 - Count for first group | |
751 | * Type2 - Object type for second group | |
752 | * Count2 - Count for second group | |
03ef132b | 753 | * start_index - Start of the first group of elements |
e8707b34 BM |
754 | * |
755 | * RETURN: Status | |
756 | * | |
757 | * DESCRIPTION: Check that all elements of a package are of the correct object | |
758 | * type. Supports up to two groups of different object types. | |
759 | * | |
760 | ******************************************************************************/ | |
761 | ||
762 | static acpi_status | |
0444e8f6 | 763 | acpi_ns_check_package_elements(struct acpi_predefined_data *data, |
e8707b34 | 764 | union acpi_operand_object **elements, |
03ef132b BM |
765 | u8 type1, |
766 | u32 count1, | |
767 | u8 type2, u32 count2, u32 start_index) | |
e8707b34 BM |
768 | { |
769 | union acpi_operand_object **this_element = elements; | |
770 | acpi_status status; | |
771 | u32 i; | |
772 | ||
773 | /* | |
774 | * Up to two groups of package elements are supported by the data | |
775 | * structure. All elements in each group must be of the same type. | |
776 | * The second group can have a count of zero. | |
777 | */ | |
778 | for (i = 0; i < count1; i++) { | |
0444e8f6 | 779 | status = acpi_ns_check_object_type(data, this_element, |
03ef132b | 780 | type1, i + start_index); |
e8707b34 BM |
781 | if (ACPI_FAILURE(status)) { |
782 | return (status); | |
783 | } | |
784 | this_element++; | |
785 | } | |
786 | ||
787 | for (i = 0; i < count2; i++) { | |
0444e8f6 | 788 | status = acpi_ns_check_object_type(data, this_element, |
03ef132b BM |
789 | type2, |
790 | (i + count1 + start_index)); | |
e8707b34 BM |
791 | if (ACPI_FAILURE(status)) { |
792 | return (status); | |
793 | } | |
794 | this_element++; | |
795 | } | |
796 | ||
797 | return (AE_OK); | |
798 | } | |
799 | ||
800 | /******************************************************************************* | |
801 | * | |
802 | * FUNCTION: acpi_ns_check_object_type | |
803 | * | |
0444e8f6 | 804 | * PARAMETERS: Data - Pointer to validation data structure |
a647b5c3 BM |
805 | * return_object_ptr - Pointer to the object returned from the |
806 | * evaluation of a method or object | |
e8707b34 BM |
807 | * expected_btypes - Bitmap of expected return type(s) |
808 | * package_index - Index of object within parent package (if | |
0444e8f6 BM |
809 | * applicable - ACPI_NOT_PACKAGE_ELEMENT |
810 | * otherwise) | |
e8707b34 BM |
811 | * |
812 | * RETURN: Status | |
813 | * | |
814 | * DESCRIPTION: Check the type of the return object against the expected object | |
815 | * type(s). Use of Btype allows multiple expected object types. | |
816 | * | |
817 | ******************************************************************************/ | |
818 | ||
819 | static acpi_status | |
0444e8f6 | 820 | acpi_ns_check_object_type(struct acpi_predefined_data *data, |
a647b5c3 | 821 | union acpi_operand_object **return_object_ptr, |
e8707b34 BM |
822 | u32 expected_btypes, u32 package_index) |
823 | { | |
a647b5c3 | 824 | union acpi_operand_object *return_object = *return_object_ptr; |
e8707b34 BM |
825 | acpi_status status = AE_OK; |
826 | u32 return_btype; | |
827 | char type_buffer[48]; /* Room for 5 types */ | |
e8707b34 BM |
828 | |
829 | /* | |
830 | * If we get a NULL return_object here, it is a NULL package element, | |
831 | * and this is always an error. | |
832 | */ | |
833 | if (!return_object) { | |
834 | goto type_error_exit; | |
835 | } | |
836 | ||
837 | /* A Namespace node should not get here, but make sure */ | |
838 | ||
839 | if (ACPI_GET_DESCRIPTOR_TYPE(return_object) == ACPI_DESC_TYPE_NAMED) { | |
0444e8f6 BM |
840 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
841 | "Invalid return type - Found a Namespace node [%4.4s] type %s", | |
842 | return_object->node.name.ascii, | |
843 | acpi_ut_get_type_name(return_object->node. | |
844 | type))); | |
e8707b34 BM |
845 | return (AE_AML_OPERAND_TYPE); |
846 | } | |
847 | ||
848 | /* | |
849 | * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type. | |
850 | * The bitmapped type allows multiple possible return types. | |
851 | * | |
852 | * Note, the cases below must handle all of the possible types returned | |
853 | * from all of the predefined names (including elements of returned | |
854 | * packages) | |
855 | */ | |
3371c19c | 856 | switch (return_object->common.type) { |
e8707b34 BM |
857 | case ACPI_TYPE_INTEGER: |
858 | return_btype = ACPI_RTYPE_INTEGER; | |
859 | break; | |
860 | ||
861 | case ACPI_TYPE_BUFFER: | |
862 | return_btype = ACPI_RTYPE_BUFFER; | |
863 | break; | |
864 | ||
865 | case ACPI_TYPE_STRING: | |
866 | return_btype = ACPI_RTYPE_STRING; | |
867 | break; | |
868 | ||
869 | case ACPI_TYPE_PACKAGE: | |
870 | return_btype = ACPI_RTYPE_PACKAGE; | |
871 | break; | |
872 | ||
873 | case ACPI_TYPE_LOCAL_REFERENCE: | |
874 | return_btype = ACPI_RTYPE_REFERENCE; | |
875 | break; | |
876 | ||
877 | default: | |
878 | /* Not one of the supported objects, must be incorrect */ | |
879 | ||
880 | goto type_error_exit; | |
881 | } | |
882 | ||
883 | /* Is the object one of the expected types? */ | |
884 | ||
885 | if (!(return_btype & expected_btypes)) { | |
a647b5c3 BM |
886 | |
887 | /* Type mismatch -- attempt repair of the returned object */ | |
888 | ||
0444e8f6 BM |
889 | status = acpi_ns_repair_object(data, expected_btypes, |
890 | package_index, | |
a647b5c3 BM |
891 | return_object_ptr); |
892 | if (ACPI_SUCCESS(status)) { | |
0444e8f6 | 893 | return (AE_OK); /* Repair was successful */ |
a647b5c3 | 894 | } |
e8707b34 BM |
895 | goto type_error_exit; |
896 | } | |
897 | ||
898 | /* For reference objects, check that the reference type is correct */ | |
899 | ||
3371c19c | 900 | if (return_object->common.type == ACPI_TYPE_LOCAL_REFERENCE) { |
0444e8f6 | 901 | status = acpi_ns_check_reference(data, return_object); |
e8707b34 BM |
902 | } |
903 | ||
904 | return (status); | |
905 | ||
906 | type_error_exit: | |
907 | ||
908 | /* Create a string with all expected types for this predefined object */ | |
909 | ||
0444e8f6 | 910 | acpi_ns_get_expected_types(type_buffer, expected_btypes); |
e8707b34 | 911 | |
0444e8f6 BM |
912 | if (package_index == ACPI_NOT_PACKAGE_ELEMENT) { |
913 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, | |
914 | "Return type mismatch - found %s, expected %s", | |
915 | acpi_ut_get_object_type_name | |
916 | (return_object), type_buffer)); | |
e8707b34 | 917 | } else { |
0444e8f6 BM |
918 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
919 | "Return Package type mismatch at index %u - " | |
920 | "found %s, expected %s", package_index, | |
921 | acpi_ut_get_object_type_name | |
922 | (return_object), type_buffer)); | |
e8707b34 BM |
923 | } |
924 | ||
925 | return (AE_AML_OPERAND_TYPE); | |
926 | } | |
927 | ||
928 | /******************************************************************************* | |
929 | * | |
930 | * FUNCTION: acpi_ns_check_reference | |
931 | * | |
0444e8f6 | 932 | * PARAMETERS: Data - Pointer to validation data structure |
e8707b34 BM |
933 | * return_object - Object returned from the evaluation of a |
934 | * method or object | |
935 | * | |
936 | * RETURN: Status | |
937 | * | |
938 | * DESCRIPTION: Check a returned reference object for the correct reference | |
939 | * type. The only reference type that can be returned from a | |
940 | * predefined method is a named reference. All others are invalid. | |
941 | * | |
942 | ******************************************************************************/ | |
943 | ||
944 | static acpi_status | |
0444e8f6 | 945 | acpi_ns_check_reference(struct acpi_predefined_data *data, |
e8707b34 BM |
946 | union acpi_operand_object *return_object) |
947 | { | |
948 | ||
949 | /* | |
950 | * Check the reference object for the correct reference type (opcode). | |
951 | * The only type of reference that can be converted to an union acpi_object is | |
952 | * a reference to a named object (reference class: NAME) | |
953 | */ | |
954 | if (return_object->reference.class == ACPI_REFCLASS_NAME) { | |
955 | return (AE_OK); | |
956 | } | |
957 | ||
0444e8f6 BM |
958 | ACPI_WARN_PREDEFINED((AE_INFO, data->pathname, data->node_flags, |
959 | "Return type mismatch - unexpected reference object type [%s] %2.2X", | |
960 | acpi_ut_get_reference_name(return_object), | |
961 | return_object->reference.class)); | |
e8707b34 BM |
962 | |
963 | return (AE_AML_OPERAND_TYPE); | |
964 | } | |
a647b5c3 | 965 | |
0444e8f6 BM |
966 | /******************************************************************************* |
967 | * | |
968 | * FUNCTION: acpi_ns_get_expected_types | |
969 | * | |
970 | * PARAMETERS: Buffer - Pointer to where the string is returned | |
971 | * expected_btypes - Bitmap of expected return type(s) | |
972 | * | |
973 | * RETURN: Buffer is populated with type names. | |
974 | * | |
975 | * DESCRIPTION: Translate the expected types bitmap into a string of ascii | |
976 | * names of expected types, for use in warning messages. | |
977 | * | |
978 | ******************************************************************************/ | |
979 | ||
980 | static void acpi_ns_get_expected_types(char *buffer, u32 expected_btypes) | |
981 | { | |
982 | u32 this_rtype; | |
983 | u32 i; | |
984 | u32 j; | |
985 | ||
986 | j = 1; | |
987 | buffer[0] = 0; | |
988 | this_rtype = ACPI_RTYPE_INTEGER; | |
989 | ||
990 | for (i = 0; i < ACPI_NUM_RTYPES; i++) { | |
991 | ||
992 | /* If one of the expected types, concatenate the name of this type */ | |
993 | ||
994 | if (expected_btypes & this_rtype) { | |
995 | ACPI_STRCAT(buffer, &acpi_rtype_names[i][j]); | |
996 | j = 0; /* Use name separator from now on */ | |
997 | } | |
998 | this_rtype <<= 1; /* Next Rtype */ | |
999 | } | |
1000 | } |