renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-21 11:44:01 +08:00
Code

ACPICA: String conversions: Update to add new behaviors

Browse Source 
ACPICA commit e3574138af82a25d76324559848689946982dbd0

1) Allow whitespace in string before the constant
2) ut_strtoul64 now always creates a 64-bit integer; iASL will
truncate this to the lower 32-bits if the table being compiled
is a 32-bit table (DSDT revision less than 2).

Link: https://github.com/acpica/acpica/commit/e3574138af82
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
This commit is contained in:
Bob Moore 2017-09-20 10:00:49 +08:00 committed by Rafael J. Wysocki
parent 72a2935502
commit c2e56e54b2
3 changed files with 78 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/acpi/acpica/acutils.h
View File

@ -211,6 +211,8 @@ acpi_status acpi_ut_convert_decimal_string(char *string, u64 *return_value_ptr);
acpi_status acpi_ut_convert_hex_string(char *string, u64 *return_value_ptr);
char acpi_ut_remove_whitespace(char **string);
char acpi_ut_remove_leading_zeros(char **string);
u8 acpi_ut_detect_hex_prefix(char **string);

25
drivers/acpi/acpica/utstrsuppt.c
View File

@ -229,6 +229,31 @@ char acpi_ut_remove_leading_zeros(char **string)
return (**string);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_remove_whitespace
*
* PARAMETERS: string - Pointer to input ASCII string
*
* RETURN: Next character after any whitespace. This character may be
* used by the caller to detect end-of-string.
*
* DESCRIPTION: Remove any leading whitespace in the input string. Return the
* next character after the final ASCII zero to enable the caller
* to check for the end of the string (NULL terminator).
*
******************************************************************************/
char acpi_ut_remove_whitespace(char **string)
{
while (isspace((u8)**string)) {
*string += 1;
}
return (**string);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_detect_hex_prefix

72
drivers/acpi/acpica/utstrtoul64.c
View File

@ -66,22 +66,25 @@ ACPI_MODULE_NAME("utstrtoul64")
* iASL - Main parser, conversion of constants to integers
* iASL - Data Table Compiler parser (constants and math expressions)
* interpreter - Implicit and explicit conversions, GPE method names
* interpreter - Repair code for return values from predefined names
* debugger - Command line input string conversion
* acpi_dump - Input table addresses
* acpi_exec - Testing of the acpi_ut_strtoul64 function
* acpi_dump - ACPI table physical addresses
* acpi_exec - Support for namespace overrides
*
* Notes concerning users of these interfaces:
*
* acpi_gbl_integer_byte_width is used to set the 32/64 bit limit. This global
* must be set to the proper width. For the core ACPICA code, the width
* depends on the DSDT version. For iASL, the default width is 64 bits for
* all parsers, but error checking is performed later to flag cases where
* a 64-bit constant is wrongly defined in a 32-bit DSDT/SSDT.
* acpi_gbl_integer_byte_width is used to set the 32/64 bit limit for explicit
* and implicit conversions. This global must be set to the proper width.
* For the core ACPICA code, the width depends on the DSDT version. For the
* acpi_ut_strtoul64 interface, all conversions are 64 bits. This interface is
* used primarily for iASL, where the default width is 64 bits for all parsers,
* but error checking is performed later to flag cases where a 64-bit constant
* is wrongly defined in a 32-bit DSDT/SSDT.
*
* In ACPI, the only place where octal numbers are supported is within
* the ASL language itself. This is implemented via the main acpi_ut_strtoul64
* interface. According the ACPI specification, there is no ACPI runtime
* support for octal string conversions.
* In ACPI, the only place where octal numbers are supported is within
* the ASL language itself. This is implemented via the main acpi_ut_strtoul64
* interface. According the ACPI specification, there is no ACPI runtime
* support (explicit/implicit) for octal string conversions.
*
******************************************************************************/
/*******************************************************************************
@ -93,11 +96,11 @@ ACPI_MODULE_NAME("utstrtoul64")
* return_value - Where the converted integer is
* returned. Must be a valid pointer
*
* RETURN: Status and converted integer
* Returns an exception on numeric overflow
* RETURN: Status and converted integer. Returns an exception on a
* 64-bit numeric overflow
*
* DESCRIPTION: Convert a string into an unsigned integer. Performs either a
* 32-bit or 64-bit conversion, depending on the current global
* DESCRIPTION: Convert a string into an unsigned integer. Always performs a
* full 64-bit conversion, regardless of the current global
* integer width. Supports Decimal, Hex, and Octal strings.
*
* Current users of this function:
@ -105,11 +108,15 @@ ACPI_MODULE_NAME("utstrtoul64")
* iASL - Preprocessor (constants and math expressions)
* iASL - Main ASL parser, conversion of ASL constants to integers
* iASL - Data Table Compiler parser (constants and math expressions)
* interpreter - Repair code for return values from predefined names
* acpi_dump - ACPI table physical addresses
* acpi_exec - Support for namespace overrides
*
******************************************************************************/
acpi_status acpi_ut_strtoul64(char *string, u64 *return_value)
{
acpi_status status = AE_OK;
u8 original_bit_width;
u32 base = 10; /* Default is decimal */
ACPI_FUNCTION_TRACE_STR(ut_strtoul64, string);
@ -122,6 +129,10 @@ acpi_status acpi_ut_strtoul64(char *string, u64 *return_value)
return_ACPI_STATUS(AE_OK);
}
if (!acpi_ut_remove_whitespace(&string)) {
return_ACPI_STATUS(AE_OK);
}
/*
* 1) Check for a hex constant. A "0x" prefix indicates base 16.
*/
@ -142,8 +153,16 @@ acpi_status acpi_ut_strtoul64(char *string, u64 *return_value)
}
/*
* Perform the base 8, 10, or 16 conversion. A numeric overflow will
* return an exception (to allow iASL to flag the statement).
* Force a full 64-bit conversion. The caller (usually iASL) must
* check for a 32-bit overflow later as necessary (If current mode
* is 32-bit, meaning a 32-bit DSDT).
*/
original_bit_width = acpi_gbl_integer_bit_width;
acpi_gbl_integer_bit_width = 64;
/*
* Perform the base 8, 10, or 16 conversion. A 64-bit numeric overflow
* will return an exception (to allow iASL to flag the statement).
*/
switch (base) {
case 8:
@ -160,6 +179,9 @@ acpi_status acpi_ut_strtoul64(char *string, u64 *return_value)
break;
}
/* Only possible exception from above is a 64-bit overflow */
acpi_gbl_integer_bit_width = original_bit_width;
return_ACPI_STATUS(status);
}
@ -223,6 +245,10 @@ u64 acpi_ut_implicit_strtoul64(char *string)
ACPI_FUNCTION_TRACE_STR(ut_implicit_strtoul64, string);
if (!acpi_ut_remove_whitespace(&string)) {
return_VALUE(0);
}
/*
* Per the ACPI specification, only hexadecimal is supported for
* implicit conversions, and the "0x" prefix is "not allowed".
@ -236,8 +262,8 @@ u64 acpi_ut_implicit_strtoul64(char *string)
/*
* Ignore overflow as per the ACPI specification. This is implemented by
* ignoring the return status below. On overflow, the input string is
* simply truncated.
* ignoring the return status from the conversion function called below.
* On overflow, the input string is simply truncated.
*/
acpi_ut_convert_hex_string(string, &converted_integer);
return_VALUE(converted_integer);
@ -301,6 +327,10 @@ u64 acpi_ut_explicit_strtoul64(char *string)
ACPI_FUNCTION_TRACE_STR(ut_explicit_strtoul64, string);
if (!acpi_ut_remove_whitespace(&string)) {
return_VALUE(0);
}
/*
* Only Hex and Decimal are supported, as per the ACPI specification.
* A "0x" prefix indicates hex; otherwise decimal is assumed.
@ -315,8 +345,8 @@ u64 acpi_ut_explicit_strtoul64(char *string)
/*
* Ignore overflow as per the ACPI specification. This is implemented by
* ignoring the return status below. On overflow, the input string is
* simply truncated.
* ignoring the return status from the conversion functions called below.
* On overflow, the input string is simply truncated.
*/
switch (base) {
case 10: