1 | // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
2 | /****************************************************************************** |
3 | * |
4 | * Module Name: nsrepair - Repair for objects returned by predefined methods |
5 | * |
6 | * Copyright (C) 2000 - 2023, Intel Corp. |
7 | * |
8 | *****************************************************************************/ |
9 | |
10 | #include <acpi/acpi.h> |
11 | #include "accommon.h" |
12 | #include "acnamesp.h" |
13 | #include "acinterp.h" |
14 | #include "acpredef.h" |
15 | #include "amlresrc.h" |
16 | |
17 | #define _COMPONENT ACPI_NAMESPACE |
18 | ACPI_MODULE_NAME("nsrepair" ) |
19 | |
20 | /******************************************************************************* |
21 | * |
22 | * This module attempts to repair or convert objects returned by the |
23 | * predefined methods to an object type that is expected, as per the ACPI |
24 | * specification. The need for this code is dictated by the many machines that |
25 | * return incorrect types for the standard predefined methods. Performing these |
26 | * conversions here, in one place, eliminates the need for individual ACPI |
27 | * device drivers to do the same. Note: Most of these conversions are different |
28 | * than the internal object conversion routines used for implicit object |
29 | * conversion. |
30 | * |
31 | * The following conversions can be performed as necessary: |
32 | * |
33 | * Integer -> String |
34 | * Integer -> Buffer |
35 | * String -> Integer |
36 | * String -> Buffer |
37 | * Buffer -> Integer |
38 | * Buffer -> String |
39 | * Buffer -> Package of Integers |
40 | * Package -> Package of one Package |
41 | * |
42 | * Additional conversions that are available: |
43 | * Convert a null return or zero return value to an end_tag descriptor |
44 | * Convert an ASCII string to a Unicode buffer |
45 | * |
46 | * An incorrect standalone object is wrapped with required outer package |
47 | * |
48 | * Additional possible repairs: |
49 | * Required package elements that are NULL replaced by Integer/String/Buffer |
50 | * |
51 | ******************************************************************************/ |
52 | /* Local prototypes */ |
53 | static const struct acpi_simple_repair_info *acpi_ns_match_simple_repair(struct |
54 | acpi_namespace_node |
55 | *node, |
56 | u32 |
57 | return_btype, |
58 | u32 |
59 | package_index); |
60 | |
61 | /* |
62 | * Special but simple repairs for some names. |
63 | * |
64 | * 2nd argument: Unexpected types that can be repaired |
65 | */ |
66 | static const struct acpi_simple_repair_info acpi_object_repair_info[] = { |
67 | /* Resource descriptor conversions */ |
68 | |
69 | {.name: "_CRS" , |
70 | ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | |
71 | ACPI_RTYPE_NONE, |
72 | ACPI_NOT_PACKAGE_ELEMENT, |
73 | .object_converter: acpi_ns_convert_to_resource}, |
74 | {"_DMA" , |
75 | ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | |
76 | ACPI_RTYPE_NONE, |
77 | ACPI_NOT_PACKAGE_ELEMENT, |
78 | acpi_ns_convert_to_resource}, |
79 | {"_PRS" , |
80 | ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | |
81 | ACPI_RTYPE_NONE, |
82 | ACPI_NOT_PACKAGE_ELEMENT, |
83 | acpi_ns_convert_to_resource}, |
84 | |
85 | /* Object reference conversions */ |
86 | |
87 | {"_DEP" , ACPI_RTYPE_STRING, ACPI_ALL_PACKAGE_ELEMENTS, |
88 | acpi_ns_convert_to_reference}, |
89 | |
90 | /* Unicode conversions */ |
91 | |
92 | {"_MLS" , ACPI_RTYPE_STRING, 1, |
93 | acpi_ns_convert_to_unicode}, |
94 | {"_STR" , ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER, |
95 | ACPI_NOT_PACKAGE_ELEMENT, |
96 | acpi_ns_convert_to_unicode}, |
97 | {{0, 0, 0, 0}, 0, 0, NULL} /* Table terminator */ |
98 | }; |
99 | |
100 | /******************************************************************************* |
101 | * |
102 | * FUNCTION: acpi_ns_simple_repair |
103 | * |
104 | * PARAMETERS: info - Method execution information block |
105 | * expected_btypes - Object types expected |
106 | * package_index - Index of object within parent package (if |
107 | * applicable - ACPI_NOT_PACKAGE_ELEMENT |
108 | * otherwise) |
109 | * return_object_ptr - Pointer to the object returned from the |
110 | * evaluation of a method or object |
111 | * |
112 | * RETURN: Status. AE_OK if repair was successful. |
113 | * |
114 | * DESCRIPTION: Attempt to repair/convert a return object of a type that was |
115 | * not expected. |
116 | * |
117 | ******************************************************************************/ |
118 | |
119 | acpi_status |
120 | acpi_ns_simple_repair(struct acpi_evaluate_info *info, |
121 | u32 expected_btypes, |
122 | u32 package_index, |
123 | union acpi_operand_object **return_object_ptr) |
124 | { |
125 | union acpi_operand_object *return_object = *return_object_ptr; |
126 | union acpi_operand_object *new_object = NULL; |
127 | acpi_status status; |
128 | const struct acpi_simple_repair_info *predefined; |
129 | |
130 | ACPI_FUNCTION_NAME(ns_simple_repair); |
131 | |
132 | /* |
133 | * Special repairs for certain names that are in the repair table. |
134 | * Check if this name is in the list of repairable names. |
135 | */ |
136 | predefined = acpi_ns_match_simple_repair(node: info->node, |
137 | return_btype: info->return_btype, |
138 | package_index); |
139 | if (predefined) { |
140 | if (!return_object) { |
141 | ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname, |
142 | ACPI_WARN_ALWAYS, |
143 | "Missing expected return value" )); |
144 | } |
145 | |
146 | status = predefined->object_converter(info->node, return_object, |
147 | &new_object); |
148 | if (ACPI_FAILURE(status)) { |
149 | |
150 | /* A fatal error occurred during a conversion */ |
151 | |
152 | ACPI_EXCEPTION((AE_INFO, status, |
153 | "During return object analysis" )); |
154 | return (status); |
155 | } |
156 | if (new_object) { |
157 | goto object_repaired; |
158 | } |
159 | } |
160 | |
161 | /* |
162 | * Do not perform simple object repair unless the return type is not |
163 | * expected. |
164 | */ |
165 | if (info->return_btype & expected_btypes) { |
166 | return (AE_OK); |
167 | } |
168 | |
169 | /* |
170 | * At this point, we know that the type of the returned object was not |
171 | * one of the expected types for this predefined name. Attempt to |
172 | * repair the object by converting it to one of the expected object |
173 | * types for this predefined name. |
174 | */ |
175 | |
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 | * Try to fix if there was no return object. Warning if failed to fix. |
182 | */ |
183 | if (!return_object) { |
184 | if (expected_btypes) { |
185 | if (!(expected_btypes & ACPI_RTYPE_NONE) && |
186 | package_index != ACPI_NOT_PACKAGE_ELEMENT) { |
187 | ACPI_WARN_PREDEFINED((AE_INFO, |
188 | info->full_pathname, |
189 | ACPI_WARN_ALWAYS, |
190 | "Found unexpected NULL package element" )); |
191 | |
192 | status = |
193 | acpi_ns_repair_null_element(info, |
194 | expected_btypes, |
195 | package_index, |
196 | return_object_ptr); |
197 | if (ACPI_SUCCESS(status)) { |
198 | return (AE_OK); /* Repair was successful */ |
199 | } |
200 | } |
201 | |
202 | if (expected_btypes != ACPI_RTYPE_NONE) { |
203 | ACPI_WARN_PREDEFINED((AE_INFO, |
204 | info->full_pathname, |
205 | ACPI_WARN_ALWAYS, |
206 | "Missing expected return value" )); |
207 | return (AE_AML_NO_RETURN_VALUE); |
208 | } |
209 | } |
210 | } |
211 | |
212 | if (expected_btypes & ACPI_RTYPE_INTEGER) { |
213 | status = acpi_ns_convert_to_integer(original_object: return_object, return_object: &new_object); |
214 | if (ACPI_SUCCESS(status)) { |
215 | goto object_repaired; |
216 | } |
217 | } |
218 | if (expected_btypes & ACPI_RTYPE_STRING) { |
219 | status = acpi_ns_convert_to_string(original_object: return_object, return_object: &new_object); |
220 | if (ACPI_SUCCESS(status)) { |
221 | goto object_repaired; |
222 | } |
223 | } |
224 | if (expected_btypes & ACPI_RTYPE_BUFFER) { |
225 | status = acpi_ns_convert_to_buffer(original_object: return_object, return_object: &new_object); |
226 | if (ACPI_SUCCESS(status)) { |
227 | goto object_repaired; |
228 | } |
229 | } |
230 | if (expected_btypes & ACPI_RTYPE_PACKAGE) { |
231 | /* |
232 | * A package is expected. We will wrap the existing object with a |
233 | * new package object. It is often the case that if a variable-length |
234 | * package is required, but there is only a single object needed, the |
235 | * BIOS will return that object instead of wrapping it with a Package |
236 | * object. Note: after the wrapping, the package will be validated |
237 | * for correct contents (expected object type or types). |
238 | */ |
239 | status = |
240 | acpi_ns_wrap_with_package(info, original_object: return_object, obj_desc_ptr: &new_object); |
241 | if (ACPI_SUCCESS(status)) { |
242 | /* |
243 | * The original object just had its reference count |
244 | * incremented for being inserted into the new package. |
245 | */ |
246 | *return_object_ptr = new_object; /* New Package object */ |
247 | info->return_flags |= ACPI_OBJECT_REPAIRED; |
248 | return (AE_OK); |
249 | } |
250 | } |
251 | |
252 | /* We cannot repair this object */ |
253 | |
254 | return (AE_AML_OPERAND_TYPE); |
255 | |
256 | object_repaired: |
257 | |
258 | /* Object was successfully repaired */ |
259 | |
260 | if (package_index != ACPI_NOT_PACKAGE_ELEMENT) { |
261 | |
262 | /* Update reference count of new object */ |
263 | |
264 | if (!(info->return_flags & ACPI_OBJECT_WRAPPED)) { |
265 | new_object->common.reference_count = |
266 | return_object->common.reference_count; |
267 | } |
268 | |
269 | ACPI_DEBUG_PRINT((ACPI_DB_REPAIR, |
270 | "%s: Converted %s to expected %s at Package index %u\n" , |
271 | info->full_pathname, |
272 | acpi_ut_get_object_type_name(return_object), |
273 | acpi_ut_get_object_type_name(new_object), |
274 | package_index)); |
275 | } else { |
276 | ACPI_DEBUG_PRINT((ACPI_DB_REPAIR, |
277 | "%s: Converted %s to expected %s\n" , |
278 | info->full_pathname, |
279 | acpi_ut_get_object_type_name(return_object), |
280 | acpi_ut_get_object_type_name(new_object))); |
281 | } |
282 | |
283 | /* Delete old object, install the new return object */ |
284 | |
285 | acpi_ut_remove_reference(object: return_object); |
286 | *return_object_ptr = new_object; |
287 | info->return_flags |= ACPI_OBJECT_REPAIRED; |
288 | return (AE_OK); |
289 | } |
290 | |
291 | /****************************************************************************** |
292 | * |
293 | * FUNCTION: acpi_ns_match_simple_repair |
294 | * |
295 | * PARAMETERS: node - Namespace node for the method/object |
296 | * return_btype - Object type that was returned |
297 | * package_index - Index of object within parent package (if |
298 | * applicable - ACPI_NOT_PACKAGE_ELEMENT |
299 | * otherwise) |
300 | * |
301 | * RETURN: Pointer to entry in repair table. NULL indicates not found. |
302 | * |
303 | * DESCRIPTION: Check an object name against the repairable object list. |
304 | * |
305 | *****************************************************************************/ |
306 | |
307 | static const struct acpi_simple_repair_info *acpi_ns_match_simple_repair(struct |
308 | acpi_namespace_node |
309 | *node, |
310 | u32 |
311 | return_btype, |
312 | u32 |
313 | package_index) |
314 | { |
315 | const struct acpi_simple_repair_info *this_name; |
316 | |
317 | /* Search info table for a repairable predefined method/object name */ |
318 | |
319 | this_name = acpi_object_repair_info; |
320 | while (this_name->object_converter) { |
321 | if (ACPI_COMPARE_NAMESEG(node->name.ascii, this_name->name)) { |
322 | |
323 | /* Check if we can actually repair this name/type combination */ |
324 | |
325 | if ((return_btype & this_name->unexpected_btypes) && |
326 | (this_name->package_index == |
327 | ACPI_ALL_PACKAGE_ELEMENTS |
328 | || package_index == this_name->package_index)) { |
329 | return (this_name); |
330 | } |
331 | |
332 | return (NULL); |
333 | } |
334 | |
335 | this_name++; |
336 | } |
337 | |
338 | return (NULL); /* Name was not found in the repair table */ |
339 | } |
340 | |
341 | /******************************************************************************* |
342 | * |
343 | * FUNCTION: acpi_ns_repair_null_element |
344 | * |
345 | * PARAMETERS: info - Method execution information block |
346 | * expected_btypes - Object types expected |
347 | * package_index - Index of object within parent package (if |
348 | * applicable - ACPI_NOT_PACKAGE_ELEMENT |
349 | * otherwise) |
350 | * return_object_ptr - Pointer to the object returned from the |
351 | * evaluation of a method or object |
352 | * |
353 | * RETURN: Status. AE_OK if repair was successful. |
354 | * |
355 | * DESCRIPTION: Attempt to repair a NULL element of a returned Package object. |
356 | * |
357 | ******************************************************************************/ |
358 | |
359 | acpi_status |
360 | acpi_ns_repair_null_element(struct acpi_evaluate_info *info, |
361 | u32 expected_btypes, |
362 | u32 package_index, |
363 | union acpi_operand_object **return_object_ptr) |
364 | { |
365 | union acpi_operand_object *return_object = *return_object_ptr; |
366 | union acpi_operand_object *new_object; |
367 | |
368 | ACPI_FUNCTION_NAME(ns_repair_null_element); |
369 | |
370 | /* No repair needed if return object is non-NULL */ |
371 | |
372 | if (return_object) { |
373 | return (AE_OK); |
374 | } |
375 | |
376 | /* |
377 | * Attempt to repair a NULL element of a Package object. This applies to |
378 | * predefined names that return a fixed-length package and each element |
379 | * is required. It does not apply to variable-length packages where NULL |
380 | * elements are allowed, especially at the end of the package. |
381 | */ |
382 | if (expected_btypes & ACPI_RTYPE_INTEGER) { |
383 | |
384 | /* Need an integer - create a zero-value integer */ |
385 | |
386 | new_object = acpi_ut_create_integer_object(value: (u64)0); |
387 | } else if (expected_btypes & ACPI_RTYPE_STRING) { |
388 | |
389 | /* Need a string - create a NULL string */ |
390 | |
391 | new_object = acpi_ut_create_string_object(string_size: 0); |
392 | } else if (expected_btypes & ACPI_RTYPE_BUFFER) { |
393 | |
394 | /* Need a buffer - create a zero-length buffer */ |
395 | |
396 | new_object = acpi_ut_create_buffer_object(buffer_size: 0); |
397 | } else { |
398 | /* Error for all other expected types */ |
399 | |
400 | return (AE_AML_OPERAND_TYPE); |
401 | } |
402 | |
403 | if (!new_object) { |
404 | return (AE_NO_MEMORY); |
405 | } |
406 | |
407 | /* Set the reference count according to the parent Package object */ |
408 | |
409 | new_object->common.reference_count = |
410 | info->parent_package->common.reference_count; |
411 | |
412 | ACPI_DEBUG_PRINT((ACPI_DB_REPAIR, |
413 | "%s: Converted NULL package element to expected %s at index %u\n" , |
414 | info->full_pathname, |
415 | acpi_ut_get_object_type_name(new_object), |
416 | package_index)); |
417 | |
418 | *return_object_ptr = new_object; |
419 | info->return_flags |= ACPI_OBJECT_REPAIRED; |
420 | return (AE_OK); |
421 | } |
422 | |
423 | /****************************************************************************** |
424 | * |
425 | * FUNCTION: acpi_ns_remove_null_elements |
426 | * |
427 | * PARAMETERS: info - Method execution information block |
428 | * package_type - An acpi_return_package_types value |
429 | * obj_desc - A Package object |
430 | * |
431 | * RETURN: None. |
432 | * |
433 | * DESCRIPTION: Remove all NULL package elements from packages that contain |
434 | * a variable number of subpackages. For these types of |
435 | * packages, NULL elements can be safely removed. |
436 | * |
437 | *****************************************************************************/ |
438 | |
439 | void |
440 | acpi_ns_remove_null_elements(struct acpi_evaluate_info *info, |
441 | u8 package_type, |
442 | union acpi_operand_object *obj_desc) |
443 | { |
444 | union acpi_operand_object **source; |
445 | union acpi_operand_object **dest; |
446 | u32 count; |
447 | u32 new_count; |
448 | u32 i; |
449 | |
450 | ACPI_FUNCTION_NAME(ns_remove_null_elements); |
451 | |
452 | /* |
453 | * We can safely remove all NULL elements from these package types: |
454 | * PTYPE1_VAR packages contain a variable number of simple data types. |
455 | * PTYPE2 packages contain a variable number of subpackages. |
456 | */ |
457 | switch (package_type) { |
458 | case ACPI_PTYPE1_VAR: |
459 | case ACPI_PTYPE2: |
460 | case ACPI_PTYPE2_COUNT: |
461 | case ACPI_PTYPE2_PKG_COUNT: |
462 | case ACPI_PTYPE2_FIXED: |
463 | case ACPI_PTYPE2_MIN: |
464 | case ACPI_PTYPE2_REV_FIXED: |
465 | case ACPI_PTYPE2_FIX_VAR: |
466 | break; |
467 | |
468 | default: |
469 | case ACPI_PTYPE2_VAR_VAR: |
470 | case ACPI_PTYPE1_FIXED: |
471 | case ACPI_PTYPE1_OPTION: |
472 | return; |
473 | } |
474 | |
475 | count = obj_desc->package.count; |
476 | new_count = count; |
477 | |
478 | source = obj_desc->package.elements; |
479 | dest = source; |
480 | |
481 | /* Examine all elements of the package object, remove nulls */ |
482 | |
483 | for (i = 0; i < count; i++) { |
484 | if (!*source) { |
485 | new_count--; |
486 | } else { |
487 | *dest = *source; |
488 | dest++; |
489 | } |
490 | |
491 | source++; |
492 | } |
493 | |
494 | /* Update parent package if any null elements were removed */ |
495 | |
496 | if (new_count < count) { |
497 | ACPI_DEBUG_PRINT((ACPI_DB_REPAIR, |
498 | "%s: Found and removed %u NULL elements\n" , |
499 | info->full_pathname, (count - new_count))); |
500 | |
501 | /* NULL terminate list and update the package count */ |
502 | |
503 | *dest = NULL; |
504 | obj_desc->package.count = new_count; |
505 | } |
506 | } |
507 | |
508 | /******************************************************************************* |
509 | * |
510 | * FUNCTION: acpi_ns_wrap_with_package |
511 | * |
512 | * PARAMETERS: info - Method execution information block |
513 | * original_object - Pointer to the object to repair. |
514 | * obj_desc_ptr - The new package object is returned here |
515 | * |
516 | * RETURN: Status, new object in *obj_desc_ptr |
517 | * |
518 | * DESCRIPTION: Repair a common problem with objects that are defined to |
519 | * return a variable-length Package of sub-objects. If there is |
520 | * only one sub-object, some BIOS code mistakenly simply declares |
521 | * the single object instead of a Package with one sub-object. |
522 | * This function attempts to repair this error by wrapping a |
523 | * Package object around the original object, creating the |
524 | * correct and expected Package with one sub-object. |
525 | * |
526 | * Names that can be repaired in this manner include: |
527 | * _ALR, _CSD, _HPX, _MLS, _PLD, _PRT, _PSS, _TRT, _TSS, |
528 | * _BCL, _DOD, _FIX, _Sx |
529 | * |
530 | ******************************************************************************/ |
531 | |
532 | acpi_status |
533 | acpi_ns_wrap_with_package(struct acpi_evaluate_info *info, |
534 | union acpi_operand_object *original_object, |
535 | union acpi_operand_object **obj_desc_ptr) |
536 | { |
537 | union acpi_operand_object *pkg_obj_desc; |
538 | |
539 | ACPI_FUNCTION_NAME(ns_wrap_with_package); |
540 | |
541 | /* |
542 | * Create the new outer package and populate it. The new |
543 | * package will have a single element, the lone sub-object. |
544 | */ |
545 | pkg_obj_desc = acpi_ut_create_package_object(count: 1); |
546 | if (!pkg_obj_desc) { |
547 | return (AE_NO_MEMORY); |
548 | } |
549 | |
550 | pkg_obj_desc->package.elements[0] = original_object; |
551 | |
552 | ACPI_DEBUG_PRINT((ACPI_DB_REPAIR, |
553 | "%s: Wrapped %s with expected Package object\n" , |
554 | info->full_pathname, |
555 | acpi_ut_get_object_type_name(original_object))); |
556 | |
557 | /* Return the new object in the object pointer */ |
558 | |
559 | *obj_desc_ptr = pkg_obj_desc; |
560 | info->return_flags |= ACPI_OBJECT_REPAIRED | ACPI_OBJECT_WRAPPED; |
561 | return (AE_OK); |
562 | } |
563 | |