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
18ACPI_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 */
53static 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 */
66static const struct acpi_simple_repair_info acpi_object_repair_info[] = {
67	/* Resource descriptor conversions */
68
69	{"_CRS",
70	 ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER |
71	 ACPI_RTYPE_NONE,
72	 ACPI_NOT_PACKAGE_ELEMENT,
73	 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
119acpi_status
120acpi_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(info->node,
137						 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(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(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(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, return_object, &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
256object_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(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
307static 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
359acpi_status
360acpi_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((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(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(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
439void
440acpi_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
532acpi_status
533acpi_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(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