[mirror_ubuntu-focal-kernel.git] / drivers / acpi / acpica / nsrepair.c

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/******************************************************************************
 *
 * Module Name: nsrepair - Repair for objects returned by predefined methods
 *
 * Copyright (C) 2000 - 2019, Intel Corp.
 *
 *****************************************************************************/

#include <acpi/acpi.h>
#include "accommon.h"
#include "acnamesp.h"
#include "acinterp.h"
#include "acpredef.h"
#include "amlresrc.h"

#define _COMPONENT          ACPI_NAMESPACE
ACPI_MODULE_NAME("nsrepair")

/*******************************************************************************
 *
 * This module attempts to repair or convert objects returned by the
 * predefined methods to an object type that is expected, as per the ACPI
 * specification. The need for this code is dictated by the many machines that
 * return incorrect types for the standard predefined methods. Performing these
 * conversions here, in one place, eliminates the need for individual ACPI
 * device drivers to do the same. Note: Most of these conversions are different
 * than the internal object conversion routines used for implicit object
 * conversion.
 *
 * The following conversions can be performed as necessary:
 *
 * Integer -> String
 * Integer -> Buffer
 * String  -> Integer
 * String  -> Buffer
 * Buffer  -> Integer
 * Buffer  -> String
 * Buffer  -> Package of Integers
 * Package -> Package of one Package
 *
 * Additional conversions that are available:
 *  Convert a null return or zero return value to an end_tag descriptor
 *  Convert an ASCII string to a Unicode buffer
 *
 * An incorrect standalone object is wrapped with required outer package
 *
 * Additional possible repairs:
 * Required package elements that are NULL replaced by Integer/String/Buffer
 *
 ******************************************************************************/
/* Local prototypes */
static const struct acpi_simple_repair_info *acpi_ns_match_simple_repair(struct
									 acpi_namespace_node
									 *node,
									 u32
									 return_btype,
									 u32
									 package_index);

/*
 * Special but simple repairs for some names.
 *
 * 2nd argument: Unexpected types that can be repaired
 */
static const struct acpi_simple_repair_info acpi_object_repair_info[] = {
	/* Resource descriptor conversions */

	{"_CRS",
	 ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER |
	 ACPI_RTYPE_NONE,
	 ACPI_NOT_PACKAGE_ELEMENT,
	 acpi_ns_convert_to_resource},
	{"_DMA",
	 ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER |
	 ACPI_RTYPE_NONE,
	 ACPI_NOT_PACKAGE_ELEMENT,
	 acpi_ns_convert_to_resource},
	{"_PRS",
	 ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER |
	 ACPI_RTYPE_NONE,
	 ACPI_NOT_PACKAGE_ELEMENT,
	 acpi_ns_convert_to_resource},

	/* Object reference conversions */

	{"_DEP", ACPI_RTYPE_STRING, ACPI_ALL_PACKAGE_ELEMENTS,
	 acpi_ns_convert_to_reference},

	/* Unicode conversions */

	{"_MLS", ACPI_RTYPE_STRING, 1,
	 acpi_ns_convert_to_unicode},
	{"_STR", ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER,
	 ACPI_NOT_PACKAGE_ELEMENT,
	 acpi_ns_convert_to_unicode},
	{{0, 0, 0, 0}, 0, 0, NULL}	/* Table terminator */
};

/*******************************************************************************
 *
 * FUNCTION:    acpi_ns_simple_repair
 *
 * PARAMETERS:  info                - Method execution information block
 *              expected_btypes     - Object types expected
 *              package_index       - Index of object within parent package (if
 *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 *                                    otherwise)
 *              return_object_ptr   - Pointer to the object returned from the
 *                                    evaluation of a method or object
 *
 * RETURN:      Status. AE_OK if repair was successful.
 *
 * DESCRIPTION: Attempt to repair/convert a return object of a type that was
 *              not expected.
 *
 ******************************************************************************/

acpi_status
acpi_ns_simple_repair(struct acpi_evaluate_info *info,
		      u32 expected_btypes,
		      u32 package_index,
		      union acpi_operand_object **return_object_ptr)
{
	union acpi_operand_object *return_object = *return_object_ptr;
	union acpi_operand_object *new_object = NULL;
	acpi_status status;
	const struct acpi_simple_repair_info *predefined;

	ACPI_FUNCTION_NAME(ns_simple_repair);

	/*
	 * Special repairs for certain names that are in the repair table.
	 * Check if this name is in the list of repairable names.
	 */
	predefined = acpi_ns_match_simple_repair(info->node,
						 info->return_btype,
						 package_index);
	if (predefined) {
		if (!return_object) {
			ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
					      ACPI_WARN_ALWAYS,
					      "Missing expected return value"));
		}

		status = predefined->object_converter(info->node, return_object,
						      &new_object);
		if (ACPI_FAILURE(status)) {

			/* A fatal error occurred during a conversion */

			ACPI_EXCEPTION((AE_INFO, status,
					"During return object analysis"));
			return (status);
		}
		if (new_object) {
			goto object_repaired;
		}
	}

	/*
	 * Do not perform simple object repair unless the return type is not
	 * expected.
	 */
	if (info->return_btype & expected_btypes) {
		return (AE_OK);
	}

	/*
	 * At this point, we know that the type of the returned object was not
	 * one of the expected types for this predefined name. Attempt to
	 * repair the object by converting it to one of the expected object
	 * types for this predefined name.
	 */

	/*
	 * If there is no return value, check if we require a return value for
	 * this predefined name. Either one return value is expected, or none,
	 * for both methods and other objects.
	 *
	 * Try to fix if there was no return object. Warning if failed to fix.
	 */
	if (!return_object) {
		if (expected_btypes && (!(expected_btypes & ACPI_RTYPE_NONE))) {
			if (package_index != ACPI_NOT_PACKAGE_ELEMENT) {
				ACPI_WARN_PREDEFINED((AE_INFO,
						      info->full_pathname,
						      ACPI_WARN_ALWAYS,
						      "Found unexpected NULL package element"));

				status =
				    acpi_ns_repair_null_element(info,
								expected_btypes,
								package_index,
								return_object_ptr);
				if (ACPI_SUCCESS(status)) {
					return (AE_OK);	/* Repair was successful */
				}
			} else {
				ACPI_WARN_PREDEFINED((AE_INFO,
						      info->full_pathname,
						      ACPI_WARN_ALWAYS,
						      "Missing expected return value"));
			}

			return (AE_AML_NO_RETURN_VALUE);
		}
	}

	if (expected_btypes & ACPI_RTYPE_INTEGER) {
		status = acpi_ns_convert_to_integer(return_object, &new_object);
		if (ACPI_SUCCESS(status)) {
			goto object_repaired;
		}
	}
	if (expected_btypes & ACPI_RTYPE_STRING) {
		status = acpi_ns_convert_to_string(return_object, &new_object);
		if (ACPI_SUCCESS(status)) {
			goto object_repaired;
		}
	}
	if (expected_btypes & ACPI_RTYPE_BUFFER) {
		status = acpi_ns_convert_to_buffer(return_object, &new_object);
		if (ACPI_SUCCESS(status)) {
			goto object_repaired;
		}
	}
	if (expected_btypes & ACPI_RTYPE_PACKAGE) {
		/*
		 * A package is expected. We will wrap the existing object with a
		 * new package object. It is often the case that if a variable-length
		 * package is required, but there is only a single object needed, the
		 * BIOS will return that object instead of wrapping it with a Package
		 * object. Note: after the wrapping, the package will be validated
		 * for correct contents (expected object type or types).
		 */
		status =
		    acpi_ns_wrap_with_package(info, return_object, &new_object);
		if (ACPI_SUCCESS(status)) {
			/*
			 * The original object just had its reference count
			 * incremented for being inserted into the new package.
			 */
			*return_object_ptr = new_object;	/* New Package object */
			info->return_flags |= ACPI_OBJECT_REPAIRED;
			return (AE_OK);
		}
	}

	/* We cannot repair this object */

	return (AE_AML_OPERAND_TYPE);

object_repaired:

	/* Object was successfully repaired */

	if (package_index != ACPI_NOT_PACKAGE_ELEMENT) {

		/* Update reference count of new object */

		if (!(info->return_flags & ACPI_OBJECT_WRAPPED)) {
			new_object->common.reference_count =
			    return_object->common.reference_count;
		}

		ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
				  "%s: Converted %s to expected %s at Package index %u\n",
				  info->full_pathname,
				  acpi_ut_get_object_type_name(return_object),
				  acpi_ut_get_object_type_name(new_object),
				  package_index));
	} else {
		ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
				  "%s: Converted %s to expected %s\n",
				  info->full_pathname,
				  acpi_ut_get_object_type_name(return_object),
				  acpi_ut_get_object_type_name(new_object)));
	}

	/* Delete old object, install the new return object */

	acpi_ut_remove_reference(return_object);
	*return_object_ptr = new_object;
	info->return_flags |= ACPI_OBJECT_REPAIRED;
	return (AE_OK);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_ns_match_simple_repair
 *
 * PARAMETERS:  node                - Namespace node for the method/object
 *              return_btype        - Object type that was returned
 *              package_index       - Index of object within parent package (if
 *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 *                                    otherwise)
 *
 * RETURN:      Pointer to entry in repair table. NULL indicates not found.
 *
 * DESCRIPTION: Check an object name against the repairable object list.
 *
 *****************************************************************************/

static const struct acpi_simple_repair_info *acpi_ns_match_simple_repair(struct
									 acpi_namespace_node
									 *node,
									 u32
									 return_btype,
									 u32
									 package_index)
{
	const struct acpi_simple_repair_info *this_name;

	/* Search info table for a repairable predefined method/object name */

	this_name = acpi_object_repair_info;
	while (this_name->object_converter) {
		if (ACPI_COMPARE_NAMESEG(node->name.ascii, this_name->name)) {

			/* Check if we can actually repair this name/type combination */

			if ((return_btype & this_name->unexpected_btypes) &&
			    (this_name->package_index ==
			     ACPI_ALL_PACKAGE_ELEMENTS
			     || package_index == this_name->package_index)) {
				return (this_name);
			}

			return (NULL);
		}

		this_name++;
	}

	return (NULL);		/* Name was not found in the repair table */
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ns_repair_null_element
 *
 * PARAMETERS:  info                - Method execution information block
 *              expected_btypes     - Object types expected
 *              package_index       - Index of object within parent package (if
 *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 *                                    otherwise)
 *              return_object_ptr   - Pointer to the object returned from the
 *                                    evaluation of a method or object
 *
 * RETURN:      Status. AE_OK if repair was successful.
 *
 * DESCRIPTION: Attempt to repair a NULL element of a returned Package object.
 *
 ******************************************************************************/

acpi_status
acpi_ns_repair_null_element(struct acpi_evaluate_info *info,
			    u32 expected_btypes,
			    u32 package_index,
			    union acpi_operand_object **return_object_ptr)
{
	union acpi_operand_object *return_object = *return_object_ptr;
	union acpi_operand_object *new_object;

	ACPI_FUNCTION_NAME(ns_repair_null_element);

	/* No repair needed if return object is non-NULL */

	if (return_object) {
		return (AE_OK);
	}

	/*
	 * Attempt to repair a NULL element of a Package object. This applies to
	 * predefined names that return a fixed-length package and each element
	 * is required. It does not apply to variable-length packages where NULL
	 * elements are allowed, especially at the end of the package.
	 */
	if (expected_btypes & ACPI_RTYPE_INTEGER) {

		/* Need an integer - create a zero-value integer */

		new_object = acpi_ut_create_integer_object((u64)0);
	} else if (expected_btypes & ACPI_RTYPE_STRING) {

		/* Need a string - create a NULL string */

		new_object = acpi_ut_create_string_object(0);
	} else if (expected_btypes & ACPI_RTYPE_BUFFER) {

		/* Need a buffer - create a zero-length buffer */

		new_object = acpi_ut_create_buffer_object(0);
	} else {
		/* Error for all other expected types */

		return (AE_AML_OPERAND_TYPE);
	}

	if (!new_object) {
		return (AE_NO_MEMORY);
	}

	/* Set the reference count according to the parent Package object */

	new_object->common.reference_count =
	    info->parent_package->common.reference_count;

	ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
			  "%s: Converted NULL package element to expected %s at index %u\n",
			  info->full_pathname,
			  acpi_ut_get_object_type_name(new_object),
			  package_index));

	*return_object_ptr = new_object;
	info->return_flags |= ACPI_OBJECT_REPAIRED;
	return (AE_OK);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_ns_remove_null_elements
 *
 * PARAMETERS:  info                - Method execution information block
 *              package_type        - An acpi_return_package_types value
 *              obj_desc            - A Package object
 *
 * RETURN:      None.
 *
 * DESCRIPTION: Remove all NULL package elements from packages that contain
 *              a variable number of subpackages. For these types of
 *              packages, NULL elements can be safely removed.
 *
 *****************************************************************************/

void
acpi_ns_remove_null_elements(struct acpi_evaluate_info *info,
			     u8 package_type,
			     union acpi_operand_object *obj_desc)
{
	union acpi_operand_object **source;
	union acpi_operand_object **dest;
	u32 count;
	u32 new_count;
	u32 i;

	ACPI_FUNCTION_NAME(ns_remove_null_elements);

	/*
	 * We can safely remove all NULL elements from these package types:
	 * PTYPE1_VAR packages contain a variable number of simple data types.
	 * PTYPE2 packages contain a variable number of subpackages.
	 */
	switch (package_type) {
	case ACPI_PTYPE1_VAR:
	case ACPI_PTYPE2:
	case ACPI_PTYPE2_COUNT:
	case ACPI_PTYPE2_PKG_COUNT:
	case ACPI_PTYPE2_FIXED:
	case ACPI_PTYPE2_MIN:
	case ACPI_PTYPE2_REV_FIXED:
	case ACPI_PTYPE2_FIX_VAR:
		break;

	default:
	case ACPI_PTYPE2_VAR_VAR:
	case ACPI_PTYPE1_FIXED:
	case ACPI_PTYPE1_OPTION:
		return;
	}

	count = obj_desc->package.count;
	new_count = count;

	source = obj_desc->package.elements;
	dest = source;

	/* Examine all elements of the package object, remove nulls */

	for (i = 0; i < count; i++) {
		if (!*source) {
			new_count--;
		} else {
			*dest = *source;
			dest++;
		}

		source++;
	}

	/* Update parent package if any null elements were removed */

	if (new_count < count) {
		ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
				  "%s: Found and removed %u NULL elements\n",
				  info->full_pathname, (count - new_count)));

		/* NULL terminate list and update the package count */

		*dest = NULL;
		obj_desc->package.count = new_count;
	}
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ns_wrap_with_package
 *
 * PARAMETERS:  info                - Method execution information block
 *              original_object     - Pointer to the object to repair.
 *              obj_desc_ptr        - The new package object is returned here
 *
 * RETURN:      Status, new object in *obj_desc_ptr
 *
 * DESCRIPTION: Repair a common problem with objects that are defined to
 *              return a variable-length Package of sub-objects. If there is
 *              only one sub-object, some BIOS code mistakenly simply declares
 *              the single object instead of a Package with one sub-object.
 *              This function attempts to repair this error by wrapping a
 *              Package object around the original object, creating the
 *              correct and expected Package with one sub-object.
 *
 *              Names that can be repaired in this manner include:
 *              _ALR, _CSD, _HPX, _MLS, _PLD, _PRT, _PSS, _TRT, _TSS,
 *              _BCL, _DOD, _FIX, _Sx
 *
 ******************************************************************************/

acpi_status
acpi_ns_wrap_with_package(struct acpi_evaluate_info *info,
			  union acpi_operand_object *original_object,
			  union acpi_operand_object **obj_desc_ptr)
{
	union acpi_operand_object *pkg_obj_desc;

	ACPI_FUNCTION_NAME(ns_wrap_with_package);

	/*
	 * Create the new outer package and populate it. The new
	 * package will have a single element, the lone sub-object.
	 */
	pkg_obj_desc = acpi_ut_create_package_object(1);
	if (!pkg_obj_desc) {
		return (AE_NO_MEMORY);
	}

	pkg_obj_desc->package.elements[0] = original_object;

	ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
			  "%s: Wrapped %s with expected Package object\n",
			  info->full_pathname,
			  acpi_ut_get_object_type_name(original_object)));

	/* Return the new object in the object pointer */

	*obj_desc_ptr = pkg_obj_desc;
	info->return_flags |= ACPI_OBJECT_REPAIRED | ACPI_OBJECT_WRAPPED;
	return (AE_OK);
}
Commit	Line	Data
95857638	1	// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
b2deadd5 BM	2	/******************************************************************************
	3	*
	4	* Module Name: nsrepair - Repair for objects returned by predefined methods
	5	*
840c02ca	6	* Copyright (C) 2000 - 2019, Intel Corp.
b2deadd5	7	*
95857638	8	*****************************************************************************/
b2deadd5 BM	9
	10	#include <acpi/acpi.h>
	11	#include "accommon.h"
	12	#include "acnamesp.h"
0240d7b4	13	#include "acinterp.h"
091f4d71	14	#include "acpredef.h"
d5a36100	15	#include "amlresrc.h"
b2deadd5 BM	16
	17	#define _COMPONENT ACPI_NAMESPACE
	18	ACPI_MODULE_NAME("nsrepair")
	19
47e11d54 BM	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
d5a36100 BM	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	*
6a99b1c9	46	* An incorrect standalone object is wrapped with required outer package
47e11d54	47	*
091f4d71	48	* Additional possible repairs:
091f4d71	49	* Required package elements that are NULL replaced by Integer/String/Buffer
091f4d71	50	*
47e11d54 BM	51	******************************************************************************/
47e11d54 BM	52	/* Local prototypes */
d5a36100 BM	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[] = {
88fd0ac8 LZ	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
ee387409 LZ	85	/* Object reference conversions */
	86
	87	{"_DEP", ACPI_RTYPE_STRING, ACPI_ALL_PACKAGE_ELEMENTS,
	88	acpi_ns_convert_to_reference},
	89
96b44cc6 LZ	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},
d5a36100 BM	97	{{0, 0, 0, 0}, 0, 0, NULL} /* Table terminator */
	98	};
	99
b2deadd5 BM	100	/*******************************************************************************
b2deadd5 BM	101	*
d5a36100	102	* FUNCTION: acpi_ns_simple_repair
b2deadd5	103	*
29a241cc	104	* PARAMETERS: info - Method execution information block
b2deadd5 BM	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	******************************************************************************/
47e11d54	118
b2deadd5	119	acpi_status
29a241cc	120	acpi_ns_simple_repair(struct acpi_evaluate_info *info,
b2deadd5 BM	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;
d5a36100	126	union acpi_operand_object *new_object = NULL;
0240d7b4	127	acpi_status status;
d5a36100	128	const struct acpi_simple_repair_info *predefined;
b2deadd5	129
d5a36100 BM	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	*/
29a241cc BM	136	predefined = acpi_ns_match_simple_repair(info->node,
29a241cc BM	137	info->return_btype,
d5a36100 BM	138	package_index);
	139	if (predefined) {
	140	if (!return_object) {
29a241cc	141	ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
d5a36100 BM	142	ACPI_WARN_ALWAYS,
	143	"Missing expected return value"));
	144	}
	145
4debda53 LZ	146	status = predefined->object_converter(info->node, return_object,
4debda53 LZ	147	&new_object);
d5a36100 BM	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	*/
29a241cc	165	if (info->return_btype & expected_btypes) {
d5a36100 BM	166	return (AE_OK);
d5a36100 BM	167	}
3a58176e	168
27526993 BM	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
47e11d54 BM	172	* repair the object by converting it to one of the expected object
	173	* types for this predefined name.
	174	*/
d5a36100 BM	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	*
61db45ca	181	* Try to fix if there was no return object. Warning if failed to fix.
d5a36100 BM	182	*/
	183	if (!return_object) {
	184	if (expected_btypes && (!(expected_btypes & ACPI_RTYPE_NONE))) {
61db45ca LZ	185	if (package_index != ACPI_NOT_PACKAGE_ELEMENT) {
	186	ACPI_WARN_PREDEFINED((AE_INFO,
	187	info->full_pathname,
	188	ACPI_WARN_ALWAYS,
	189	"Found unexpected NULL package element"));
	190
	191	status =
	192	acpi_ns_repair_null_element(info,
	193	expected_btypes,
	194	package_index,
	195	return_object_ptr);
	196	if (ACPI_SUCCESS(status)) {
	197	return (AE_OK); /* Repair was successful */
	198	}
	199	} else {
	200	ACPI_WARN_PREDEFINED((AE_INFO,
	201	info->full_pathname,
	202	ACPI_WARN_ALWAYS,
	203	"Missing expected return value"));
	204	}
d5a36100 BM	205
	206	return (AE_AML_NO_RETURN_VALUE);
	207	}
	208	}
	209
47e11d54 BM	210	if (expected_btypes & ACPI_RTYPE_INTEGER) {
	211	status = acpi_ns_convert_to_integer(return_object, &new_object);
	212	if (ACPI_SUCCESS(status)) {
	213	goto object_repaired;
	214	}
	215	}
	216	if (expected_btypes & ACPI_RTYPE_STRING) {
	217	status = acpi_ns_convert_to_string(return_object, &new_object);
	218	if (ACPI_SUCCESS(status)) {
	219	goto object_repaired;
	220	}
	221	}
	222	if (expected_btypes & ACPI_RTYPE_BUFFER) {
	223	status = acpi_ns_convert_to_buffer(return_object, &new_object);
	224	if (ACPI_SUCCESS(status)) {
	225	goto object_repaired;
	226	}
	227	}
	228	if (expected_btypes & ACPI_RTYPE_PACKAGE) {
6a99b1c9 BM	229	/*
	230	* A package is expected. We will wrap the existing object with a
	231	* new package object. It is often the case that if a variable-length
	232	* package is required, but there is only a single object needed, the
	233	* BIOS will return that object instead of wrapping it with a Package
	234	* object. Note: after the wrapping, the package will be validated
	235	* for correct contents (expected object type or types).
	236	*/
	237	status =
29a241cc	238	acpi_ns_wrap_with_package(info, return_object, &new_object);
47e11d54	239	if (ACPI_SUCCESS(status)) {
6a99b1c9 BM	240	/*
	241	* The original object just had its reference count
	242	* incremented for being inserted into the new package.
	243	*/
	244	return_object_ptr = new_object; / New Package object */
29a241cc	245	info->return_flags \|= ACPI_OBJECT_REPAIRED;
6a99b1c9	246	return (AE_OK);
47e11d54 BM	247	}
	248	}
	249
	250	/* We cannot repair this object */
	251
	252	return (AE_AML_OPERAND_TYPE);
	253
10622bf8	254	object_repaired:
47e11d54 BM	255
	256	/* Object was successfully repaired */
	257
47e11d54	258	if (package_index != ACPI_NOT_PACKAGE_ELEMENT) {
ed7f8bc9 BM	259
	260	/* Update reference count of new object */
	261
29a241cc	262	if (!(info->return_flags & ACPI_OBJECT_WRAPPED)) {
6a99b1c9 BM	263	new_object->common.reference_count =
6a99b1c9 BM	264	return_object->common.reference_count;
47e11d54 BM	265	}
47e11d54 BM	266
3a58176e	267	ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
6a99b1c9	268	"%s: Converted %s to expected %s at Package index %u\n",
29a241cc	269	info->full_pathname,
3a58176e BM	270	acpi_ut_get_object_type_name(return_object),
	271	acpi_ut_get_object_type_name(new_object),
	272	package_index));
47e11d54	273	} else {
3a58176e BM	274	ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
3a58176e BM	275	"%s: Converted %s to expected %s\n",
29a241cc	276	info->full_pathname,
3a58176e BM	277	acpi_ut_get_object_type_name(return_object),
3a58176e BM	278	acpi_ut_get_object_type_name(new_object)));
47e11d54 BM	279	}
	280
	281	/* Delete old object, install the new return object */
	282
	283	acpi_ut_remove_reference(return_object);
	284	*return_object_ptr = new_object;
29a241cc	285	info->return_flags \|= ACPI_OBJECT_REPAIRED;
47e11d54 BM	286	return (AE_OK);
	287	}
	288
d5a36100 BM	289	/******************************************************************************
	290	*
	291	* FUNCTION: acpi_ns_match_simple_repair
	292	*
	293	* PARAMETERS: node - Namespace node for the method/object
	294	* return_btype - Object type that was returned
	295	* package_index - Index of object within parent package (if
	296	* applicable - ACPI_NOT_PACKAGE_ELEMENT
	297	* otherwise)
	298	*
	299	* RETURN: Pointer to entry in repair table. NULL indicates not found.
	300	*
	301	* DESCRIPTION: Check an object name against the repairable object list.
	302	*
	303	*****************************************************************************/
	304
	305	static const struct acpi_simple_repair_info *acpi_ns_match_simple_repair(struct
	306	acpi_namespace_node
	307	*node,
	308	u32
	309	return_btype,
	310	u32
	311	package_index)
	312	{
	313	const struct acpi_simple_repair_info *this_name;
	314
	315	/* Search info table for a repairable predefined method/object name */
	316
	317	this_name = acpi_object_repair_info;
	318	while (this_name->object_converter) {
5599fb69	319	if (ACPI_COMPARE_NAMESEG(node->name.ascii, this_name->name)) {
d5a36100 BM	320
	321	/* Check if we can actually repair this name/type combination */
	322
	323	if ((return_btype & this_name->unexpected_btypes) &&
ee387409 LZ	324	(this_name->package_index ==
	325	ACPI_ALL_PACKAGE_ELEMENTS
	326	\|\| package_index == this_name->package_index)) {
d5a36100 BM	327	return (this_name);
	328	}
	329
	330	return (NULL);
	331	}
1fad8738	332
d5a36100 BM	333	this_name++;
	334	}
	335
	336	return (NULL); /* Name was not found in the repair table */
	337	}
	338
091f4d71 BM	339	/*******************************************************************************
	340	*
	341	* FUNCTION: acpi_ns_repair_null_element
	342	*
29a241cc	343	* PARAMETERS: info - Method execution information block
091f4d71 BM	344	* expected_btypes - Object types expected
	345	* package_index - Index of object within parent package (if
	346	* applicable - ACPI_NOT_PACKAGE_ELEMENT
	347	* otherwise)
	348	* return_object_ptr - Pointer to the object returned from the
	349	* evaluation of a method or object
	350	*
	351	* RETURN: Status. AE_OK if repair was successful.
	352	*
	353	* DESCRIPTION: Attempt to repair a NULL element of a returned Package object.
	354	*
	355	******************************************************************************/
	356
	357	acpi_status
f5c1e1c5	358	acpi_ns_repair_null_element(struct acpi_evaluate_info *info,
091f4d71 BM	359	u32 expected_btypes,
	360	u32 package_index,
	361	union acpi_operand_object **return_object_ptr)
	362	{
	363	union acpi_operand_object return_object = return_object_ptr;
	364	union acpi_operand_object *new_object;
	365
	366	ACPI_FUNCTION_NAME(ns_repair_null_element);
	367
	368	/* No repair needed if return object is non-NULL */
	369
	370	if (return_object) {
	371	return (AE_OK);
	372	}
	373
	374	/*
	375	* Attempt to repair a NULL element of a Package object. This applies to
	376	* predefined names that return a fixed-length package and each element
	377	* is required. It does not apply to variable-length packages where NULL
	378	* elements are allowed, especially at the end of the package.
	379	*/
	380	if (expected_btypes & ACPI_RTYPE_INTEGER) {
	381
ba494bee	382	/* Need an integer - create a zero-value integer */
091f4d71	383
150dba38	384	new_object = acpi_ut_create_integer_object((u64)0);
091f4d71 BM	385	} else if (expected_btypes & ACPI_RTYPE_STRING) {
091f4d71 BM	386
ba494bee	387	/* Need a string - create a NULL string */
091f4d71 BM	388
	389	new_object = acpi_ut_create_string_object(0);
	390	} else if (expected_btypes & ACPI_RTYPE_BUFFER) {
	391
ba494bee	392	/* Need a buffer - create a zero-length buffer */
091f4d71 BM	393
	394	new_object = acpi_ut_create_buffer_object(0);
	395	} else {
	396	/* Error for all other expected types */
	397
	398	return (AE_AML_OPERAND_TYPE);
	399	}
	400
	401	if (!new_object) {
	402	return (AE_NO_MEMORY);
	403	}
	404
	405	/* Set the reference count according to the parent Package object */
	406
	407	new_object->common.reference_count =
29a241cc	408	info->parent_package->common.reference_count;
091f4d71 BM	409
	410	ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
	411	"%s: Converted NULL package element to expected %s at index %u\n",
29a241cc	412	info->full_pathname,
091f4d71 BM	413	acpi_ut_get_object_type_name(new_object),
	414	package_index));
	415
	416	*return_object_ptr = new_object;
29a241cc	417	info->return_flags \|= ACPI_OBJECT_REPAIRED;
091f4d71 BM	418	return (AE_OK);
	419	}
	420
	421	/******************************************************************************
	422	*
	423	* FUNCTION: acpi_ns_remove_null_elements
	424	*
29a241cc	425	* PARAMETERS: info - Method execution information block
091f4d71 BM	426	* package_type - An acpi_return_package_types value
	427	* obj_desc - A Package object
	428	*
	429	* RETURN: None.
	430	*
	431	* DESCRIPTION: Remove all NULL package elements from packages that contain
0a16d12a	432	* a variable number of subpackages. For these types of
091f4d71 BM	433	* packages, NULL elements can be safely removed.
	434	*
	435	*****************************************************************************/
	436
	437	void
29a241cc	438	acpi_ns_remove_null_elements(struct acpi_evaluate_info *info,
091f4d71 BM	439	u8 package_type,
	440	union acpi_operand_object *obj_desc)
	441	{
	442	union acpi_operand_object **source;
	443	union acpi_operand_object **dest;
	444	u32 count;
	445	u32 new_count;
	446	u32 i;
	447
	448	ACPI_FUNCTION_NAME(ns_remove_null_elements);
	449
	450	/*
945488b9 BM	451	* We can safely remove all NULL elements from these package types:
945488b9 BM	452	* PTYPE1_VAR packages contain a variable number of simple data types.
0a16d12a	453	* PTYPE2 packages contain a variable number of subpackages.
091f4d71 BM	454	*/
091f4d71 BM	455	switch (package_type) {
091f4d71	456	case ACPI_PTYPE1_VAR:
091f4d71 BM	457	case ACPI_PTYPE2:
	458	case ACPI_PTYPE2_COUNT:
	459	case ACPI_PTYPE2_PKG_COUNT:
	460	case ACPI_PTYPE2_FIXED:
	461	case ACPI_PTYPE2_MIN:
	462	case ACPI_PTYPE2_REV_FIXED:
7fce7a4b	463	case ACPI_PTYPE2_FIX_VAR:
091f4d71 BM	464	break;
	465
	466	default:
e34a7813	467	case ACPI_PTYPE2_VAR_VAR:
945488b9 BM	468	case ACPI_PTYPE1_FIXED:
945488b9 BM	469	case ACPI_PTYPE1_OPTION:
091f4d71 BM	470	return;
	471	}
	472
	473	count = obj_desc->package.count;
	474	new_count = count;
	475
	476	source = obj_desc->package.elements;
	477	dest = source;
	478
	479	/* Examine all elements of the package object, remove nulls */
	480
	481	for (i = 0; i < count; i++) {
	482	if (!*source) {
	483	new_count--;
	484	} else {
	485	dest = source;
	486	dest++;
	487	}
1fad8738	488
091f4d71 BM	489	source++;
	490	}
	491
	492	/* Update parent package if any null elements were removed */
	493
	494	if (new_count < count) {
	495	ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
	496	"%s: Found and removed %u NULL elements\n",
29a241cc	497	info->full_pathname, (count - new_count)));
091f4d71 BM	498
	499	/* NULL terminate list and update the package count */
	500
	501	*dest = NULL;
	502	obj_desc->package.count = new_count;
	503	}
	504	}
	505
e5f69d6e BM	506	/*******************************************************************************
e5f69d6e BM	507	*
6a99b1c9	508	* FUNCTION: acpi_ns_wrap_with_package
e5f69d6e	509	*
29a241cc	510	* PARAMETERS: info - Method execution information block
6a99b1c9 BM	511	* original_object - Pointer to the object to repair.
6a99b1c9 BM	512	* obj_desc_ptr - The new package object is returned here
e5f69d6e BM	513	*
	514	* RETURN: Status, new object in *obj_desc_ptr
	515	*
6a99b1c9 BM	516	* DESCRIPTION: Repair a common problem with objects that are defined to
	517	* return a variable-length Package of sub-objects. If there is
	518	* only one sub-object, some BIOS code mistakenly simply declares
	519	* the single object instead of a Package with one sub-object.
	520	* This function attempts to repair this error by wrapping a
	521	* Package object around the original object, creating the
	522	* correct and expected Package with one sub-object.
e5f69d6e BM	523	*
e5f69d6e BM	524	* Names that can be repaired in this manner include:
6a99b1c9 BM	525	* _ALR, _CSD, _HPX, _MLS, _PLD, _PRT, _PSS, _TRT, _TSS,
6a99b1c9 BM	526	* _BCL, _DOD, _FIX, _Sx
e5f69d6e BM	527	*
	528	******************************************************************************/
	529
	530	acpi_status
29a241cc	531	acpi_ns_wrap_with_package(struct acpi_evaluate_info *info,
6a99b1c9 BM	532	union acpi_operand_object *original_object,
6a99b1c9 BM	533	union acpi_operand_object **obj_desc_ptr)
e5f69d6e BM	534	{
	535	union acpi_operand_object *pkg_obj_desc;
	536
6a99b1c9	537	ACPI_FUNCTION_NAME(ns_wrap_with_package);
3a58176e	538
e5f69d6e	539	/*
1fad8738 BM	540	* Create the new outer package and populate it. The new
1fad8738 BM	541	* package will have a single element, the lone sub-object.
e5f69d6e BM	542	*/
	543	pkg_obj_desc = acpi_ut_create_package_object(1);
	544	if (!pkg_obj_desc) {
	545	return (AE_NO_MEMORY);
	546	}
	547
6a99b1c9 BM	548	pkg_obj_desc->package.elements[0] = original_object;
	549
	550	ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
	551	"%s: Wrapped %s with expected Package object\n",
29a241cc	552	info->full_pathname,
6a99b1c9	553	acpi_ut_get_object_type_name(original_object)));
e5f69d6e BM	554
	555	/* Return the new object in the object pointer */
	556
	557	*obj_desc_ptr = pkg_obj_desc;
29a241cc	558	info->return_flags \|= ACPI_OBJECT_REPAIRED \| ACPI_OBJECT_WRAPPED;
e5f69d6e BM	559	return (AE_OK);
e5f69d6e BM	560	}