forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
560 lines
17 KiB
560 lines
17 KiB
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
|
/****************************************************************************** |
|
* |
|
* Module Name: nsrepair - Repair for objects returned by predefined methods |
|
* |
|
* Copyright (C) 2000 - 2021, 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); |
|
}
|
|
|