| // 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); |
| } |