drivers/acpi/acpica/nsprepkg.c - linux - Git at Google

 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
 /******************************************************************************
  *
  * Module Name: nsprepkg - Validation of package objects for predefined names
  *
  * Copyright (C) 2000 - 2021, Intel Corp.
  *
  *****************************************************************************/

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

 #define _COMPONENT          ACPI_NAMESPACE
 ACPI_MODULE_NAME("nsprepkg")

 /* Local prototypes */
 static acpi_status
 acpi_ns_check_package_list(struct acpi_evaluate_info *info,
 			   const union acpi_predefined_info *package,
 			   union acpi_operand_object **elements, u32 count);

 static acpi_status
 acpi_ns_check_package_elements(struct acpi_evaluate_info *info,
 			       union acpi_operand_object **elements,
 			       u8 type1,
 			       u32 count1,
 			       u8 type2, u32 count2, u32 start_index);

 static acpi_status
 acpi_ns_custom_package(struct acpi_evaluate_info *info,
 		       union acpi_operand_object **elements, u32 count);

 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_package
  *
  * PARAMETERS:  info                - Method execution information block
  *              return_object_ptr   - Pointer to the object returned from the
  *                                    evaluation of a method or object
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Check a returned package object for the correct count and
  *              correct type of all sub-objects.
  *
  ******************************************************************************/

 acpi_status
 acpi_ns_check_package(struct acpi_evaluate_info *info,
 		      union acpi_operand_object **return_object_ptr)
 {
 	union acpi_operand_object *return_object = *return_object_ptr;
 	const union acpi_predefined_info *package;
 	union acpi_operand_object **elements;
 	acpi_status status = AE_OK;
 	u32 expected_count;
 	u32 count;
 	u32 i;

 	ACPI_FUNCTION_TRACE(ns_check_package);

 	/* The package info for this name is in the next table entry */

 	package = info->predefined + 1;

 	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
 			  "%s Validating return Package of Type %X, Count %X\n",
 			  info->full_pathname, package->ret_info.type,
 			  return_object->package.count));

 	/*
 	 * For variable-length Packages, we can safely remove all embedded
 	 * and trailing NULL package elements
 	 */
 	acpi_ns_remove_null_elements(info, package->ret_info.type,
 				     return_object);

 	/* Extract package count and elements array */

 	elements = return_object->package.elements;
 	count = return_object->package.count;

 	/*
 	 * Most packages must have at least one element. The only exception
 	 * is the variable-length package (ACPI_PTYPE1_VAR).
 	 */
 	if (!count) {
 		if (package->ret_info.type == ACPI_PTYPE1_VAR) {
 			return_ACPI_STATUS(AE_OK);
 		}

 		ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
 				      info->node_flags,
 				      "Return Package has no elements (empty)"));

 		return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
 	}

 	/*
 	 * Decode the type of the expected package contents
 	 *
 	 * PTYPE1 packages contain no subpackages
 	 * PTYPE2 packages contain subpackages
 	 */
 	switch (package->ret_info.type) {
 	case ACPI_PTYPE_CUSTOM:

 		status = acpi_ns_custom_package(info, elements, count);
 		break;

 	case ACPI_PTYPE1_FIXED:
 		/*
 		 * The package count is fixed and there are no subpackages
 		 *
 		 * If package is too small, exit.
 		 * If package is larger than expected, issue warning but continue
 		 */
 		expected_count =
 		    package->ret_info.count1 + package->ret_info.count2;
 		if (count < expected_count) {
 			goto package_too_small;
 		} else if (count > expected_count) {
 			ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 					  "%s: Return Package is larger than needed - "
 					  "found %u, expected %u\n",
 					  info->full_pathname, count,
 					  expected_count));
 		}

 		/* Validate all elements of the returned package */

 		status = acpi_ns_check_package_elements(info, elements,
 							package->ret_info.
 							object_type1,
 							package->ret_info.
 							count1,
 							package->ret_info.
 							object_type2,
 							package->ret_info.
 							count2, 0);
 		break;

 	case ACPI_PTYPE1_VAR:
 		/*
 		 * The package count is variable, there are no subpackages, and all
 		 * elements must be of the same type
 		 */
 		for (i = 0; i < count; i++) {
 			status = acpi_ns_check_object_type(info, elements,
 							   package->ret_info.
 							   object_type1, i);
 			if (ACPI_FAILURE(status)) {
 				return_ACPI_STATUS(status);
 			}

 			elements++;
 		}
 		break;

 	case ACPI_PTYPE1_OPTION:
 		/*
 		 * The package count is variable, there are no subpackages. There are
 		 * a fixed number of required elements, and a variable number of
 		 * optional elements.
 		 *
 		 * Check if package is at least as large as the minimum required
 		 */
 		expected_count = package->ret_info3.count;
 		if (count < expected_count) {
 			goto package_too_small;
 		}

 		/* Variable number of sub-objects */

 		for (i = 0; i < count; i++) {
 			if (i < package->ret_info3.count) {

 				/* These are the required package elements (0, 1, or 2) */

 				status =
 				    acpi_ns_check_object_type(info, elements,
 							      package->
 							      ret_info3.
 							      object_type[i],
 							      i);
 				if (ACPI_FAILURE(status)) {
 					return_ACPI_STATUS(status);
 				}
 			} else {
 				/* These are the optional package elements */

 				status =
 				    acpi_ns_check_object_type(info, elements,
 							      package->
 							      ret_info3.
 							      tail_object_type,
 							      i);
 				if (ACPI_FAILURE(status)) {
 					return_ACPI_STATUS(status);
 				}
 			}

 			elements++;
 		}
 		break;

 	case ACPI_PTYPE2_REV_FIXED:

 		/* First element is the (Integer) revision */

 		status =
 		    acpi_ns_check_object_type(info, elements,
 					      ACPI_RTYPE_INTEGER, 0);
 		if (ACPI_FAILURE(status)) {
 			return_ACPI_STATUS(status);
 		}

 		elements++;
 		count--;

 		/* Examine the subpackages */

 		status =
 		    acpi_ns_check_package_list(info, package, elements, count);
 		break;

 	case ACPI_PTYPE2_PKG_COUNT:

 		/* First element is the (Integer) count of subpackages to follow */

 		status =
 		    acpi_ns_check_object_type(info, elements,
 					      ACPI_RTYPE_INTEGER, 0);
 		if (ACPI_FAILURE(status)) {
 			return_ACPI_STATUS(status);
 		}

 		/*
 		 * Count cannot be larger than the parent package length, but allow it
 		 * to be smaller. The >= accounts for the Integer above.
 		 */
 		expected_count = (u32)(*elements)->integer.value;
 		if (expected_count >= count) {
 			goto package_too_small;
 		}

 		count = expected_count;
 		elements++;

 		/* Examine the subpackages */

 		status =
 		    acpi_ns_check_package_list(info, package, elements, count);
 		break;

 	case ACPI_PTYPE2:
 	case ACPI_PTYPE2_FIXED:
 	case ACPI_PTYPE2_MIN:
 	case ACPI_PTYPE2_COUNT:
 	case ACPI_PTYPE2_FIX_VAR:
 		/*
 		 * These types all return a single Package that consists of a
 		 * variable number of subpackages.
 		 *
 		 * First, ensure that the first element is a subpackage. If not,
 		 * the BIOS may have incorrectly returned the object as a single
 		 * package instead of a Package of Packages (a common error if
 		 * there is only one entry). We may be able to repair this by
 		 * wrapping the returned Package with a new outer Package.
 		 */
 		if (*elements
 		    && ((*elements)->common.type != ACPI_TYPE_PACKAGE)) {

 			/* Create the new outer package and populate it */

 			status =
 			    acpi_ns_wrap_with_package(info, return_object,
 						      return_object_ptr);
 			if (ACPI_FAILURE(status)) {
 				return_ACPI_STATUS(status);
 			}

 			/* Update locals to point to the new package (of 1 element) */

 			return_object = *return_object_ptr;
 			elements = return_object->package.elements;
 			count = 1;
 		}

 		/* Examine the subpackages */

 		status =
 		    acpi_ns_check_package_list(info, package, elements, count);
 		break;

 	case ACPI_PTYPE2_VAR_VAR:
 		/*
 		 * Returns a variable list of packages, each with a variable list
 		 * of objects.
 		 */
 		break;

 	case ACPI_PTYPE2_UUID_PAIR:

 		/* The package must contain pairs of (UUID + type) */

 		if (count & 1) {
 			expected_count = count + 1;
 			goto package_too_small;
 		}

 		while (count > 0) {
 			status = acpi_ns_check_object_type(info, elements,
 							   package->ret_info.
 							   object_type1, 0);
 			if (ACPI_FAILURE(status)) {
 				return_ACPI_STATUS(status);
 			}

 			/* Validate length of the UUID buffer */

 			if ((*elements)->buffer.length != 16) {
 				ACPI_WARN_PREDEFINED((AE_INFO,
 						      info->full_pathname,
 						      info->node_flags,
 						      "Invalid length for UUID Buffer"));
 				return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
 			}

 			status = acpi_ns_check_object_type(info, elements + 1,
 							   package->ret_info.
 							   object_type2, 0);
 			if (ACPI_FAILURE(status)) {
 				return_ACPI_STATUS(status);
 			}

 			elements += 2;
 			count -= 2;
 		}
 		break;

 	default:

 		/* Should not get here if predefined info table is correct */

 		ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
 				      info->node_flags,
 				      "Invalid internal return type in table entry: %X",
 				      package->ret_info.type));

 		return_ACPI_STATUS(AE_AML_INTERNAL);
 	}

 	return_ACPI_STATUS(status);

 package_too_small:

 	/* Error exit for the case with an incorrect package count */

 	ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname, info->node_flags,
 			      "Return Package is too small - found %u elements, expected %u",
 			      count, expected_count));

 	return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
 }

 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_package_list
  *
  * PARAMETERS:  info            - Method execution information block
  *              package         - Pointer to package-specific info for method
  *              elements        - Element list of parent package. All elements
  *                                of this list should be of type Package.
  *              count           - Count of subpackages
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Examine a list of subpackages
  *
  ******************************************************************************/

 static acpi_status
 acpi_ns_check_package_list(struct acpi_evaluate_info *info,
 			   const union acpi_predefined_info *package,
 			   union acpi_operand_object **elements, u32 count)
 {
 	union acpi_operand_object *sub_package;
 	union acpi_operand_object **sub_elements;
 	acpi_status status;
 	u32 expected_count;
 	u32 i;
 	u32 j;

 	/*
 	 * Validate each subpackage in the parent Package
 	 *
 	 * NOTE: assumes list of subpackages contains no NULL elements.
 	 * Any NULL elements should have been removed by earlier call
 	 * to acpi_ns_remove_null_elements.
 	 */
 	for (i = 0; i < count; i++) {
 		sub_package = *elements;
 		sub_elements = sub_package->package.elements;
 		info->parent_package = sub_package;

 		/* Each sub-object must be of type Package */

 		status = acpi_ns_check_object_type(info, &sub_package,
 						   ACPI_RTYPE_PACKAGE, i);
 		if (ACPI_FAILURE(status)) {
 			return (status);
 		}

 		/* Examine the different types of expected subpackages */

 		info->parent_package = sub_package;
 		switch (package->ret_info.type) {
 		case ACPI_PTYPE2:
 		case ACPI_PTYPE2_PKG_COUNT:
 		case ACPI_PTYPE2_REV_FIXED:

 			/* Each subpackage has a fixed number of elements */

 			expected_count =
 			    package->ret_info.count1 + package->ret_info.count2;
 			if (sub_package->package.count < expected_count) {
 				goto package_too_small;
 			}

 			status =
 			    acpi_ns_check_package_elements(info, sub_elements,
 							   package->ret_info.
 							   object_type1,
 							   package->ret_info.
 							   count1,
 							   package->ret_info.
 							   object_type2,
 							   package->ret_info.
 							   count2, 0);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 			break;

 		case ACPI_PTYPE2_FIX_VAR:
 			/*
 			 * Each subpackage has a fixed number of elements and an
 			 * optional element
 			 */
 			expected_count =
 			    package->ret_info.count1 + package->ret_info.count2;
 			if (sub_package->package.count < expected_count) {
 				goto package_too_small;
 			}

 			status =
 			    acpi_ns_check_package_elements(info, sub_elements,
 							   package->ret_info.
 							   object_type1,
 							   package->ret_info.
 							   count1,
 							   package->ret_info.
 							   object_type2,
 							   sub_package->package.
 							   count -
 							   package->ret_info.
 							   count1, 0);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 			break;

 		case ACPI_PTYPE2_VAR_VAR:
 			/*
 			 * Each subpackage has a fixed or variable number of elements
 			 */
 			break;

 		case ACPI_PTYPE2_FIXED:

 			/* Each subpackage has a fixed length */

 			expected_count = package->ret_info2.count;
 			if (sub_package->package.count < expected_count) {
 				goto package_too_small;
 			}

 			/* Check the type of each subpackage element */

 			for (j = 0; j < expected_count; j++) {
 				status =
 				    acpi_ns_check_object_type(info,
 							      &sub_elements[j],
 							      package->
 							      ret_info2.
 							      object_type[j],
 							      j);
 				if (ACPI_FAILURE(status)) {
 					return (status);
 				}
 			}
 			break;

 		case ACPI_PTYPE2_MIN:

 			/* Each subpackage has a variable but minimum length */

 			expected_count = package->ret_info.count1;
 			if (sub_package->package.count < expected_count) {
 				goto package_too_small;
 			}

 			/* Check the type of each subpackage element */

 			status =
 			    acpi_ns_check_package_elements(info, sub_elements,
 							   package->ret_info.
 							   object_type1,
 							   sub_package->package.
 							   count, 0, 0, 0);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 			break;

 		case ACPI_PTYPE2_COUNT:
 			/*
 			 * First element is the (Integer) count of elements, including
 			 * the count field (the ACPI name is num_elements)
 			 */
 			status = acpi_ns_check_object_type(info, sub_elements,
 							   ACPI_RTYPE_INTEGER,
 							   0);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}

 			/*
 			 * Make sure package is large enough for the Count and is
 			 * is as large as the minimum size
 			 */
 			expected_count = (u32)(*sub_elements)->integer.value;
 			if (sub_package->package.count < expected_count) {
 				goto package_too_small;
 			}

 			if (sub_package->package.count <
 			    package->ret_info.count1) {
 				expected_count = package->ret_info.count1;
 				goto package_too_small;
 			}

 			if (expected_count == 0) {
 				/*
 				 * Either the num_entries element was originally zero or it was
 				 * a NULL element and repaired to an Integer of value zero.
 				 * In either case, repair it by setting num_entries to be the
 				 * actual size of the subpackage.
 				 */
 				expected_count = sub_package->package.count;
 				(*sub_elements)->integer.value = expected_count;
 			}

 			/* Check the type of each subpackage element */

 			status =
 			    acpi_ns_check_package_elements(info,
 							   (sub_elements + 1),
 							   package->ret_info.
 							   object_type1,
 							   (expected_count - 1),
 							   0, 0, 1);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 			break;

 		default:	/* Should not get here, type was validated by caller */

 			ACPI_ERROR((AE_INFO, "Invalid Package type: %X",
 				    package->ret_info.type));
 			return (AE_AML_INTERNAL);
 		}

 		elements++;
 	}

 	return (AE_OK);

 package_too_small:

 	/* The subpackage count was smaller than required */

 	ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname, info->node_flags,
 			      "Return SubPackage[%u] is too small - found %u elements, expected %u",
 			      i, sub_package->package.count, expected_count));

 	return (AE_AML_OPERAND_VALUE);
 }

 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_custom_package
  *
  * PARAMETERS:  info                - Method execution information block
  *              elements            - Pointer to the package elements array
  *              count               - Element count for the package
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Check a returned package object for the correct count and
  *              correct type of all sub-objects.
  *
  * NOTE: Currently used for the _BIX method only. When needed for two or more
  * methods, probably a detect/dispatch mechanism will be required.
  *
  ******************************************************************************/

 static acpi_status
 acpi_ns_custom_package(struct acpi_evaluate_info *info,
 		       union acpi_operand_object **elements, u32 count)
 {
 	u32 expected_count;
 	u32 version;
 	acpi_status status = AE_OK;

 	ACPI_FUNCTION_NAME(ns_custom_package);

 	/* Get version number, must be Integer */

 	if ((*elements)->common.type != ACPI_TYPE_INTEGER) {
 		ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
 				      info->node_flags,
 				      "Return Package has invalid object type for version number"));
 		return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
 	}

 	version = (u32)(*elements)->integer.value;
 	expected_count = 21;	/* Version 1 */

 	if (version == 0) {
 		expected_count = 20;	/* Version 0 */
 	}

 	if (count < expected_count) {
 		ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
 				      info->node_flags,
 				      "Return Package is too small - found %u elements, expected %u",
 				      count, expected_count));
 		return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
 	} else if (count > expected_count) {
 		ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 				  "%s: Return Package is larger than needed - "
 				  "found %u, expected %u\n",
 				  info->full_pathname, count, expected_count));
 	}

 	/* Validate all elements of the returned package */

 	status = acpi_ns_check_package_elements(info, elements,
 						ACPI_RTYPE_INTEGER, 16,
 						ACPI_RTYPE_STRING, 4, 0);
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}

 	/* Version 1 has a single trailing integer */

 	if (version > 0) {
 		status = acpi_ns_check_package_elements(info, elements + 20,
 							ACPI_RTYPE_INTEGER, 1,
 							0, 0, 20);
 	}

 	return_ACPI_STATUS(status);
 }

 /*******************************************************************************
  *
  * FUNCTION:    acpi_ns_check_package_elements
  *
  * PARAMETERS:  info            - Method execution information block
  *              elements        - Pointer to the package elements array
  *              type1           - Object type for first group
  *              count1          - Count for first group
  *              type2           - Object type for second group
  *              count2          - Count for second group
  *              start_index     - Start of the first group of elements
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Check that all elements of a package are of the correct object
  *              type. Supports up to two groups of different object types.
  *
  ******************************************************************************/

 static acpi_status
 acpi_ns_check_package_elements(struct acpi_evaluate_info *info,
 			       union acpi_operand_object **elements,
 			       u8 type1,
 			       u32 count1,
 			       u8 type2, u32 count2, u32 start_index)
 {
 	union acpi_operand_object **this_element = elements;
 	acpi_status status;
 	u32 i;

 	ACPI_FUNCTION_TRACE(ns_check_package_elements);

 	/*
 	 * Up to two groups of package elements are supported by the data
 	 * structure. All elements in each group must be of the same type.
 	 * The second group can have a count of zero.
 	 */
 	for (i = 0; i < count1; i++) {
 		status = acpi_ns_check_object_type(info, this_element,
 						   type1, i + start_index);
 		if (ACPI_FAILURE(status)) {
 			return_ACPI_STATUS(status);
 		}

 		this_element++;
 	}

 	for (i = 0; i < count2; i++) {
 		status = acpi_ns_check_object_type(info, this_element,
 						   type2,
 						   (i + count1 + start_index));
 		if (ACPI_FAILURE(status)) {
 			return_ACPI_STATUS(status);
 		}

 		this_element++;
 	}

 	return_ACPI_STATUS(AE_OK);
 }
	// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
	/******************************************************************************
	*
	* Module Name: nsprepkg - Validation of package objects for predefined names
	*
	* Copyright (C) 2000 - 2021, Intel Corp.
	*
	*****************************************************************************/

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

	#define _COMPONENT ACPI_NAMESPACE
	ACPI_MODULE_NAME("nsprepkg")

	/* Local prototypes */
	static acpi_status
	acpi_ns_check_package_list(struct acpi_evaluate_info *info,
	const union acpi_predefined_info *package,
	union acpi_operand_object **elements, u32 count);

	static acpi_status
	acpi_ns_check_package_elements(struct acpi_evaluate_info *info,
	union acpi_operand_object **elements,
	u8 type1,
	u32 count1,
	u8 type2, u32 count2, u32 start_index);

	static acpi_status
	acpi_ns_custom_package(struct acpi_evaluate_info *info,
	union acpi_operand_object **elements, u32 count);

	/*******************************************************************************
	*
	* FUNCTION: acpi_ns_check_package
	*
	* PARAMETERS: info - Method execution information block
	* return_object_ptr - Pointer to the object returned from the
	* evaluation of a method or object
	*
	* RETURN: Status
	*
	* DESCRIPTION: Check a returned package object for the correct count and
	* correct type of all sub-objects.
	*
	******************************************************************************/

	acpi_status
	acpi_ns_check_package(struct acpi_evaluate_info *info,
	union acpi_operand_object **return_object_ptr)
	{
	union acpi_operand_object return_object = return_object_ptr;
	const union acpi_predefined_info *package;
	union acpi_operand_object **elements;
	acpi_status status = AE_OK;
	u32 expected_count;
	u32 count;
	u32 i;

	ACPI_FUNCTION_TRACE(ns_check_package);

	/* The package info for this name is in the next table entry */

	package = info->predefined + 1;

	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
	"%s Validating return Package of Type %X, Count %X\n",
	info->full_pathname, package->ret_info.type,
	return_object->package.count));

	/*
	* For variable-length Packages, we can safely remove all embedded
	* and trailing NULL package elements
	*/
	acpi_ns_remove_null_elements(info, package->ret_info.type,
	return_object);

	/* Extract package count and elements array */

	elements = return_object->package.elements;
	count = return_object->package.count;

	/*
	* Most packages must have at least one element. The only exception
	* is the variable-length package (ACPI_PTYPE1_VAR).
	*/
	if (!count) {
	if (package->ret_info.type == ACPI_PTYPE1_VAR) {
	return_ACPI_STATUS(AE_OK);
	}

	ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
	info->node_flags,
	"Return Package has no elements (empty)"));

	return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
	}

	/*
	* Decode the type of the expected package contents
	*
	* PTYPE1 packages contain no subpackages
	* PTYPE2 packages contain subpackages
	*/
	switch (package->ret_info.type) {
	case ACPI_PTYPE_CUSTOM:

	status = acpi_ns_custom_package(info, elements, count);
	break;

	case ACPI_PTYPE1_FIXED:
	/*
	* The package count is fixed and there are no subpackages
	*
	* If package is too small, exit.
	* If package is larger than expected, issue warning but continue
	*/
	expected_count =
	package->ret_info.count1 + package->ret_info.count2;
	if (count < expected_count) {
	goto package_too_small;
	} else if (count > expected_count) {
	ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
	"%s: Return Package is larger than needed - "
	"found %u, expected %u\n",
	info->full_pathname, count,
	expected_count));
	}

	/* Validate all elements of the returned package */

	status = acpi_ns_check_package_elements(info, elements,
	package->ret_info.
	object_type1,
	package->ret_info.
	count1,
	package->ret_info.
	object_type2,
	package->ret_info.
	count2, 0);
	break;

	case ACPI_PTYPE1_VAR:
	/*
	* The package count is variable, there are no subpackages, and all
	* elements must be of the same type
	*/
	for (i = 0; i < count; i++) {
	status = acpi_ns_check_object_type(info, elements,
	package->ret_info.
	object_type1, i);
	if (ACPI_FAILURE(status)) {
	return_ACPI_STATUS(status);
	}

	elements++;
	}
	break;

	case ACPI_PTYPE1_OPTION:
	/*
	* The package count is variable, there are no subpackages. There are
	* a fixed number of required elements, and a variable number of
	* optional elements.
	*
	* Check if package is at least as large as the minimum required
	*/
	expected_count = package->ret_info3.count;
	if (count < expected_count) {
	goto package_too_small;
	}

	/* Variable number of sub-objects */

	for (i = 0; i < count; i++) {
	if (i < package->ret_info3.count) {

	/* These are the required package elements (0, 1, or 2) */

	status =
	acpi_ns_check_object_type(info, elements,
	package->
	ret_info3.
	object_type[i],
	i);
	if (ACPI_FAILURE(status)) {
	return_ACPI_STATUS(status);
	}
	} else {
	/* These are the optional package elements */

	status =
	acpi_ns_check_object_type(info, elements,
	package->
	ret_info3.
	tail_object_type,
	i);
	if (ACPI_FAILURE(status)) {
	return_ACPI_STATUS(status);
	}
	}

	elements++;
	}
	break;

	case ACPI_PTYPE2_REV_FIXED:

	/* First element is the (Integer) revision */

	status =
	acpi_ns_check_object_type(info, elements,
	ACPI_RTYPE_INTEGER, 0);
	if (ACPI_FAILURE(status)) {
	return_ACPI_STATUS(status);
	}

	elements++;
	count--;

	/* Examine the subpackages */

	status =
	acpi_ns_check_package_list(info, package, elements, count);
	break;

	case ACPI_PTYPE2_PKG_COUNT:

	/* First element is the (Integer) count of subpackages to follow */

	status =
	acpi_ns_check_object_type(info, elements,
	ACPI_RTYPE_INTEGER, 0);
	if (ACPI_FAILURE(status)) {
	return_ACPI_STATUS(status);
	}

	/*
	* Count cannot be larger than the parent package length, but allow it
	* to be smaller. The >= accounts for the Integer above.
	*/
	expected_count = (u32)(*elements)->integer.value;
	if (expected_count >= count) {
	goto package_too_small;
	}

	count = expected_count;
	elements++;

	/* Examine the subpackages */

	status =
	acpi_ns_check_package_list(info, package, elements, count);
	break;

	case ACPI_PTYPE2:
	case ACPI_PTYPE2_FIXED:
	case ACPI_PTYPE2_MIN:
	case ACPI_PTYPE2_COUNT:
	case ACPI_PTYPE2_FIX_VAR:
	/*
	* These types all return a single Package that consists of a
	* variable number of subpackages.
	*
	* First, ensure that the first element is a subpackage. If not,
	* the BIOS may have incorrectly returned the object as a single
	* package instead of a Package of Packages (a common error if
	* there is only one entry). We may be able to repair this by
	* wrapping the returned Package with a new outer Package.
	*/
	if (*elements
	&& ((*elements)->common.type != ACPI_TYPE_PACKAGE)) {

	/* Create the new outer package and populate it */

	status =
	acpi_ns_wrap_with_package(info, return_object,
	return_object_ptr);
	if (ACPI_FAILURE(status)) {
	return_ACPI_STATUS(status);
	}

	/* Update locals to point to the new package (of 1 element) */

	return_object = *return_object_ptr;
	elements = return_object->package.elements;
	count = 1;
	}

	/* Examine the subpackages */

	status =
	acpi_ns_check_package_list(info, package, elements, count);
	break;

	case ACPI_PTYPE2_VAR_VAR:
	/*
	* Returns a variable list of packages, each with a variable list
	* of objects.
	*/
	break;

	case ACPI_PTYPE2_UUID_PAIR:

	/* The package must contain pairs of (UUID + type) */

	if (count & 1) {
	expected_count = count + 1;
	goto package_too_small;
	}

	while (count > 0) {
	status = acpi_ns_check_object_type(info, elements,
	package->ret_info.
	object_type1, 0);
	if (ACPI_FAILURE(status)) {
	return_ACPI_STATUS(status);
	}

	/* Validate length of the UUID buffer */

	if ((*elements)->buffer.length != 16) {
	ACPI_WARN_PREDEFINED((AE_INFO,
	info->full_pathname,
	info->node_flags,
	"Invalid length for UUID Buffer"));
	return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
	}

	status = acpi_ns_check_object_type(info, elements + 1,
	package->ret_info.
	object_type2, 0);
	if (ACPI_FAILURE(status)) {
	return_ACPI_STATUS(status);
	}

	elements += 2;
	count -= 2;
	}
	break;

	default:

	/* Should not get here if predefined info table is correct */

	ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
	info->node_flags,
	"Invalid internal return type in table entry: %X",
	package->ret_info.type));

	return_ACPI_STATUS(AE_AML_INTERNAL);
	}

	return_ACPI_STATUS(status);

	package_too_small:

	/* Error exit for the case with an incorrect package count */

	ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname, info->node_flags,
	"Return Package is too small - found %u elements, expected %u",
	count, expected_count));

	return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
	}

	/*******************************************************************************
	*
	* FUNCTION: acpi_ns_check_package_list
	*
	* PARAMETERS: info - Method execution information block
	* package - Pointer to package-specific info for method
	* elements - Element list of parent package. All elements
	* of this list should be of type Package.
	* count - Count of subpackages
	*
	* RETURN: Status
	*
	* DESCRIPTION: Examine a list of subpackages
	*
	******************************************************************************/

	static acpi_status
	acpi_ns_check_package_list(struct acpi_evaluate_info *info,
	const union acpi_predefined_info *package,
	union acpi_operand_object **elements, u32 count)
	{
	union acpi_operand_object *sub_package;
	union acpi_operand_object **sub_elements;
	acpi_status status;
	u32 expected_count;
	u32 i;
	u32 j;

	/*
	* Validate each subpackage in the parent Package
	*
	* NOTE: assumes list of subpackages contains no NULL elements.
	* Any NULL elements should have been removed by earlier call
	* to acpi_ns_remove_null_elements.
	*/
	for (i = 0; i < count; i++) {
	sub_package = *elements;
	sub_elements = sub_package->package.elements;
	info->parent_package = sub_package;

	/* Each sub-object must be of type Package */

	status = acpi_ns_check_object_type(info, &sub_package,
	ACPI_RTYPE_PACKAGE, i);
	if (ACPI_FAILURE(status)) {
	return (status);
	}

	/* Examine the different types of expected subpackages */

	info->parent_package = sub_package;
	switch (package->ret_info.type) {
	case ACPI_PTYPE2:
	case ACPI_PTYPE2_PKG_COUNT:
	case ACPI_PTYPE2_REV_FIXED:

	/* Each subpackage has a fixed number of elements */

	expected_count =
	package->ret_info.count1 + package->ret_info.count2;
	if (sub_package->package.count < expected_count) {
	goto package_too_small;
	}

	status =
	acpi_ns_check_package_elements(info, sub_elements,
	package->ret_info.
	object_type1,
	package->ret_info.
	count1,
	package->ret_info.
	object_type2,
	package->ret_info.
	count2, 0);
	if (ACPI_FAILURE(status)) {
	return (status);
	}
	break;

	case ACPI_PTYPE2_FIX_VAR:
	/*
	* Each subpackage has a fixed number of elements and an
	* optional element
	*/
	expected_count =
	package->ret_info.count1 + package->ret_info.count2;
	if (sub_package->package.count < expected_count) {
	goto package_too_small;
	}

	status =
	acpi_ns_check_package_elements(info, sub_elements,
	package->ret_info.
	object_type1,
	package->ret_info.
	count1,
	package->ret_info.
	object_type2,
	sub_package->package.
	count -
	package->ret_info.
	count1, 0);
	if (ACPI_FAILURE(status)) {
	return (status);
	}
	break;

	case ACPI_PTYPE2_VAR_VAR:
	/*
	* Each subpackage has a fixed or variable number of elements
	*/
	break;

	case ACPI_PTYPE2_FIXED:

	/* Each subpackage has a fixed length */

	expected_count = package->ret_info2.count;
	if (sub_package->package.count < expected_count) {
	goto package_too_small;
	}

	/* Check the type of each subpackage element */

	for (j = 0; j < expected_count; j++) {
	status =
	acpi_ns_check_object_type(info,
	&sub_elements[j],
	package->
	ret_info2.
	object_type[j],
	j);
	if (ACPI_FAILURE(status)) {
	return (status);
	}
	}
	break;

	case ACPI_PTYPE2_MIN:

	/* Each subpackage has a variable but minimum length */

	expected_count = package->ret_info.count1;
	if (sub_package->package.count < expected_count) {
	goto package_too_small;
	}

	/* Check the type of each subpackage element */

	status =
	acpi_ns_check_package_elements(info, sub_elements,
	package->ret_info.
	object_type1,
	sub_package->package.
	count, 0, 0, 0);
	if (ACPI_FAILURE(status)) {
	return (status);
	}
	break;

	case ACPI_PTYPE2_COUNT:
	/*
	* First element is the (Integer) count of elements, including
	* the count field (the ACPI name is num_elements)
	*/
	status = acpi_ns_check_object_type(info, sub_elements,
	ACPI_RTYPE_INTEGER,
	0);
	if (ACPI_FAILURE(status)) {
	return (status);
	}

	/*
	* Make sure package is large enough for the Count and is
	* is as large as the minimum size
	*/
	expected_count = (u32)(*sub_elements)->integer.value;
	if (sub_package->package.count < expected_count) {
	goto package_too_small;
	}

	if (sub_package->package.count <
	package->ret_info.count1) {
	expected_count = package->ret_info.count1;
	goto package_too_small;
	}

	if (expected_count == 0) {
	/*
	* Either the num_entries element was originally zero or it was
	* a NULL element and repaired to an Integer of value zero.
	* In either case, repair it by setting num_entries to be the
	* actual size of the subpackage.
	*/
	expected_count = sub_package->package.count;
	(*sub_elements)->integer.value = expected_count;
	}

	/* Check the type of each subpackage element */

	status =
	acpi_ns_check_package_elements(info,
	(sub_elements + 1),
	package->ret_info.
	object_type1,
	(expected_count - 1),
	0, 0, 1);
	if (ACPI_FAILURE(status)) {
	return (status);
	}
	break;

	default: /* Should not get here, type was validated by caller */

	ACPI_ERROR((AE_INFO, "Invalid Package type: %X",
	package->ret_info.type));
	return (AE_AML_INTERNAL);
	}

	elements++;
	}

	return (AE_OK);

	package_too_small:

	/* The subpackage count was smaller than required */

	ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname, info->node_flags,
	"Return SubPackage[%u] is too small - found %u elements, expected %u",
	i, sub_package->package.count, expected_count));

	return (AE_AML_OPERAND_VALUE);
	}

	/*******************************************************************************
	*
	* FUNCTION: acpi_ns_custom_package
	*
	* PARAMETERS: info - Method execution information block
	* elements - Pointer to the package elements array
	* count - Element count for the package
	*
	* RETURN: Status
	*
	* DESCRIPTION: Check a returned package object for the correct count and
	* correct type of all sub-objects.
	*
	* NOTE: Currently used for the _BIX method only. When needed for two or more
	* methods, probably a detect/dispatch mechanism will be required.
	*
	******************************************************************************/

	static acpi_status
	acpi_ns_custom_package(struct acpi_evaluate_info *info,
	union acpi_operand_object **elements, u32 count)
	{
	u32 expected_count;
	u32 version;
	acpi_status status = AE_OK;

	ACPI_FUNCTION_NAME(ns_custom_package);

	/* Get version number, must be Integer */

	if ((*elements)->common.type != ACPI_TYPE_INTEGER) {
	ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
	info->node_flags,
	"Return Package has invalid object type for version number"));
	return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
	}

	version = (u32)(*elements)->integer.value;
	expected_count = 21; /* Version 1 */

	if (version == 0) {
	expected_count = 20; /* Version 0 */
	}

	if (count < expected_count) {
	ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
	info->node_flags,
	"Return Package is too small - found %u elements, expected %u",
	count, expected_count));
	return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
	} else if (count > expected_count) {
	ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
	"%s: Return Package is larger than needed - "
	"found %u, expected %u\n",
	info->full_pathname, count, expected_count));
	}

	/* Validate all elements of the returned package */

	status = acpi_ns_check_package_elements(info, elements,
	ACPI_RTYPE_INTEGER, 16,
	ACPI_RTYPE_STRING, 4, 0);
	if (ACPI_FAILURE(status)) {
	return_ACPI_STATUS(status);
	}

	/* Version 1 has a single trailing integer */

	if (version > 0) {
	status = acpi_ns_check_package_elements(info, elements + 20,
	ACPI_RTYPE_INTEGER, 1,
	0, 0, 20);
	}

	return_ACPI_STATUS(status);
	}

	/*******************************************************************************
	*
	* FUNCTION: acpi_ns_check_package_elements
	*
	* PARAMETERS: info - Method execution information block
	* elements - Pointer to the package elements array
	* type1 - Object type for first group
	* count1 - Count for first group
	* type2 - Object type for second group
	* count2 - Count for second group
	* start_index - Start of the first group of elements
	*
	* RETURN: Status
	*
	* DESCRIPTION: Check that all elements of a package are of the correct object
	* type. Supports up to two groups of different object types.
	*
	******************************************************************************/

	static acpi_status
	acpi_ns_check_package_elements(struct acpi_evaluate_info *info,
	union acpi_operand_object **elements,
	u8 type1,
	u32 count1,
	u8 type2, u32 count2, u32 start_index)
	{
	union acpi_operand_object **this_element = elements;
	acpi_status status;
	u32 i;

	ACPI_FUNCTION_TRACE(ns_check_package_elements);

	/*
	* Up to two groups of package elements are supported by the data
	* structure. All elements in each group must be of the same type.
	* The second group can have a count of zero.
	*/
	for (i = 0; i < count1; i++) {
	status = acpi_ns_check_object_type(info, this_element,
	type1, i + start_index);
	if (ACPI_FAILURE(status)) {
	return_ACPI_STATUS(status);
	}

	this_element++;
	}

	for (i = 0; i < count2; i++) {
	status = acpi_ns_check_object_type(info, this_element,
	type2,
	(i + count1 + start_index));
	if (ACPI_FAILURE(status)) {
	return_ACPI_STATUS(status);
	}

	this_element++;
	}

	return_ACPI_STATUS(AE_OK);
	}