X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=drivers%2Facpi%2Futilities%2Futmisc.c;h=7364f5f8c9cd63556e80c5da13022620d46b11ac;hb=9464c7cf61b9433057924c36e6e02f303a00e768;hp=6d8a8211be90a4f84abf2ad8efb62c8a3c9cabfa;hpb=41689045f6a3cbe0550e1d34e9cc20d2e8c432ba;p=linux-2.6.git diff --git a/drivers/acpi/utilities/utmisc.c b/drivers/acpi/utilities/utmisc.c index 6d8a8211b..7364f5f8c 100644 --- a/drivers/acpi/utilities/utmisc.c +++ b/drivers/acpi/utilities/utmisc.c @@ -41,41 +41,12 @@ * POSSIBILITY OF SUCH DAMAGES. */ -#include - #include #include #define _COMPONENT ACPI_UTILITIES ACPI_MODULE_NAME("utmisc") -/******************************************************************************* - * - * FUNCTION: acpi_ut_is_aml_table - * - * PARAMETERS: Table - An ACPI table - * - * RETURN: TRUE if table contains executable AML; FALSE otherwise - * - * DESCRIPTION: Check ACPI Signature for a table that contains AML code. - * Currently, these are DSDT,SSDT,PSDT. All other table types are - * data tables that do not contain AML code. - * - ******************************************************************************/ -u8 acpi_ut_is_aml_table(struct acpi_table_header *table) -{ - - /* These are the only tables that contain executable AML */ - - if (ACPI_COMPARE_NAME(table->signature, DSDT_SIG) || - ACPI_COMPARE_NAME(table->signature, PSDT_SIG) || - ACPI_COMPARE_NAME(table->signature, SSDT_SIG)) { - return (TRUE); - } - - return (FALSE); -} - /******************************************************************************* * * FUNCTION: acpi_ut_allocate_owner_id @@ -89,7 +60,6 @@ u8 acpi_ut_is_aml_table(struct acpi_table_header *table) * when the method exits or the table is unloaded. * ******************************************************************************/ - acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id) { acpi_native_uint i; @@ -97,7 +67,7 @@ acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id) acpi_native_uint k; acpi_status status; - ACPI_FUNCTION_TRACE(ut_allocate_owner_id); + ACPI_FUNCTION_TRACE("ut_allocate_owner_id"); /* Guard against multiple allocations of ID to the same location */ @@ -127,7 +97,6 @@ acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id) for (k = acpi_gbl_next_owner_id_offset; k < 32; k++) { if (acpi_gbl_owner_id_mask[j] == ACPI_UINT32_MAX) { - /* There are no free IDs in this mask */ break; @@ -154,7 +123,7 @@ acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id) (acpi_owner_id) ((k + 1) + ACPI_MUL_32(j)); ACPI_DEBUG_PRINT((ACPI_DB_VALUES, - "Allocated OwnerId: %2.2X\n", + "Allocated owner_id: %2.2X\n", (unsigned int)*owner_id)); goto exit; } @@ -175,7 +144,7 @@ acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id) */ status = AE_OWNER_ID_LIMIT; ACPI_ERROR((AE_INFO, - "Could not allocate new OwnerId (255 max), AE_OWNER_ID_LIMIT")); + "Could not allocate new owner_id (255 max), AE_OWNER_ID_LIMIT")); exit: (void)acpi_ut_release_mutex(ACPI_MTX_CACHES); @@ -203,7 +172,7 @@ void acpi_ut_release_owner_id(acpi_owner_id * owner_id_ptr) acpi_native_uint index; u32 bit; - ACPI_FUNCTION_TRACE_U32(ut_release_owner_id, owner_id); + ACPI_FUNCTION_TRACE_U32("ut_release_owner_id", owner_id); /* Always clear the input owner_id (zero is an invalid ID) */ @@ -212,7 +181,7 @@ void acpi_ut_release_owner_id(acpi_owner_id * owner_id_ptr) /* Zero is not a valid owner_iD */ if (owner_id == 0) { - ACPI_ERROR((AE_INFO, "Invalid OwnerId: %2.2X", owner_id)); + ACPI_ERROR((AE_INFO, "Invalid owner_id: %2.2X", owner_id)); return_VOID; } @@ -238,7 +207,7 @@ void acpi_ut_release_owner_id(acpi_owner_id * owner_id_ptr) acpi_gbl_owner_id_mask[index] ^= bit; } else { ACPI_ERROR((AE_INFO, - "Release of non-allocated OwnerId: %2.2X", + "Release of non-allocated owner_id: %2.2X", owner_id + 1)); } @@ -304,7 +273,6 @@ void acpi_ut_print_string(char *string, u8 max_length) acpi_os_printf("\""); for (i = 0; string[i] && (i < max_length); i++) { - /* Escape sequences */ switch (string[i]) { @@ -419,15 +387,10 @@ void acpi_ut_set_integer_width(u8 revision) { if (revision <= 1) { - - /* 32-bit case */ - acpi_gbl_integer_bit_width = 32; acpi_gbl_integer_nybble_width = 8; acpi_gbl_integer_byte_width = 4; } else { - /* 64-bit case (ACPI 2.0+) */ - acpi_gbl_integer_bit_width = 64; acpi_gbl_integer_nybble_width = 16; acpi_gbl_integer_byte_width = 8; @@ -498,46 +461,10 @@ acpi_ut_display_init_pathname(u8 type, } acpi_os_printf("\n"); - ACPI_FREE(buffer.pointer); + ACPI_MEM_FREE(buffer.pointer); } #endif -/******************************************************************************* - * - * FUNCTION: acpi_ut_valid_acpi_char - * - * PARAMETERS: Char - The character to be examined - * Position - Byte position (0-3) - * - * RETURN: TRUE if the character is valid, FALSE otherwise - * - * DESCRIPTION: Check for a valid ACPI character. Must be one of: - * 1) Upper case alpha - * 2) numeric - * 3) underscore - * - * We allow a '!' as the last character because of the ASF! table - * - ******************************************************************************/ - -u8 acpi_ut_valid_acpi_char(char character, acpi_native_uint position) -{ - - if (!((character >= 'A' && character <= 'Z') || - (character >= '0' && character <= '9') || (character == '_'))) { - - /* Allow a '!' in the last position */ - - if (character == '!' && position == 3) { - return (TRUE); - } - - return (FALSE); - } - - return (TRUE); -} - /******************************************************************************* * * FUNCTION: acpi_ut_valid_acpi_name @@ -555,13 +482,19 @@ u8 acpi_ut_valid_acpi_char(char character, acpi_native_uint position) u8 acpi_ut_valid_acpi_name(u32 name) { + char *name_ptr = (char *)&name; + char character; acpi_native_uint i; ACPI_FUNCTION_ENTRY(); for (i = 0; i < ACPI_NAME_SIZE; i++) { - if (!acpi_ut_valid_acpi_char - ((ACPI_CAST_PTR(char, &name))[i], i)) { + character = *name_ptr; + name_ptr++; + + if (!((character == '_') || + (character >= 'A' && character <= 'Z') || + (character >= '0' && character <= '9'))) { return (FALSE); } } @@ -571,37 +504,24 @@ u8 acpi_ut_valid_acpi_name(u32 name) /******************************************************************************* * - * FUNCTION: acpi_ut_repair_name + * FUNCTION: acpi_ut_valid_acpi_character * - * PARAMETERS: Name - The ACPI name to be repaired + * PARAMETERS: Character - The character to be examined * - * RETURN: Repaired version of the name + * RETURN: 1 if Character may appear in a name, else 0 * - * DESCRIPTION: Repair an ACPI name: Change invalid characters to '*' and - * return the new name. + * DESCRIPTION: Check for a printable character * ******************************************************************************/ -acpi_name acpi_ut_repair_name(acpi_name name) +u8 acpi_ut_valid_acpi_character(char character) { - char *name_ptr = ACPI_CAST_PTR(char, &name); - char new_name[ACPI_NAME_SIZE]; - acpi_native_uint i; - for (i = 0; i < ACPI_NAME_SIZE; i++) { - new_name[i] = name_ptr[i]; - - /* - * Replace a bad character with something printable, yet technically - * still invalid. This prevents any collisions with existing "good" - * names in the namespace. - */ - if (!acpi_ut_valid_acpi_char(name_ptr[i], i)) { - new_name[i] = '*'; - } - } + ACPI_FUNCTION_ENTRY(); - return (*ACPI_CAST_PTR(u32, new_name)); + return ((u8) ((character == '_') || + (character >= 'A' && character <= 'Z') || + (character >= '0' && character <= '9'))); } /******************************************************************************* @@ -609,15 +529,12 @@ acpi_name acpi_ut_repair_name(acpi_name name) * FUNCTION: acpi_ut_strtoul64 * * PARAMETERS: String - Null terminated string - * Base - Radix of the string: 16 or ACPI_ANY_BASE; - * ACPI_ANY_BASE means 'in behalf of to_integer' + * Base - Radix of the string: 10, 16, or ACPI_ANY_BASE * ret_integer - Where the converted integer is returned * * RETURN: Status and Converted value * - * DESCRIPTION: Convert a string into an unsigned value. Performs either a - * 32-bit or 64-bit conversion, depending on the current mode - * of the interpreter. + * DESCRIPTION: Convert a string into an unsigned value. * NOTE: Does not support Octal strings, not needed. * ******************************************************************************/ @@ -628,17 +545,16 @@ acpi_ut_strtoul64(char *string, u32 base, acpi_integer * ret_integer) u32 this_digit = 0; acpi_integer return_value = 0; acpi_integer quotient; - acpi_integer dividend; - u32 to_integer_op = (base == ACPI_ANY_BASE); - u32 mode32 = (acpi_gbl_integer_byte_width == 4); - u8 valid_digits = 0; - u8 sign_of0x = 0; - u8 term = 0; - ACPI_FUNCTION_TRACE_STR(ut_stroul64, string); + ACPI_FUNCTION_TRACE("ut_stroul64"); + + if ((!string) || !(*string)) { + goto error_exit; + } switch (base) { case ACPI_ANY_BASE: + case 10: case 16: break; @@ -647,112 +563,76 @@ acpi_ut_strtoul64(char *string, u32 base, acpi_integer * ret_integer) return_ACPI_STATUS(AE_BAD_PARAMETER); } - if (!string) { - goto error_exit; - } - /* Skip over any white space in the buffer */ - while ((*string) && (ACPI_IS_SPACE(*string) || *string == '\t')) { + while (ACPI_IS_SPACE(*string) || *string == '\t') { string++; } - if (to_integer_op) { - /* - * Base equal to ACPI_ANY_BASE means 'to_integer operation case'. - * We need to determine if it is decimal or hexadecimal. - */ + /* + * If the input parameter Base is zero, then we need to + * determine if it is decimal or hexadecimal: + */ + if (base == 0) { if ((*string == '0') && (ACPI_TOLOWER(*(string + 1)) == 'x')) { - sign_of0x = 1; base = 16; - - /* Skip over the leading '0x' */ string += 2; } else { base = 10; } } - /* Any string left? Check that '0x' is not followed by white space. */ - - if (!(*string) || ACPI_IS_SPACE(*string) || *string == '\t') { - if (to_integer_op) { - goto error_exit; - } else { - goto all_done; - } - } - /* - * Perform a 32-bit or 64-bit conversion, depending upon the current - * execution mode of the interpreter + * For hexadecimal base, skip over the leading + * 0 or 0x, if they are present. */ - dividend = (mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX; + if ((base == 16) && + (*string == '0') && (ACPI_TOLOWER(*(string + 1)) == 'x')) { + string += 2; + } - /* Main loop: convert the string to a 32- or 64-bit integer */ + /* Any string left? */ + + if (!(*string)) { + goto error_exit; + } + + /* Main loop: convert the string to a 64-bit integer */ while (*string) { if (ACPI_IS_DIGIT(*string)) { - /* Convert ASCII 0-9 to Decimal value */ this_digit = ((u8) * string) - '0'; - } else if (base == 10) { + } else { + if (base == 10) { + /* Digit is out of range */ - /* Digit is out of range; possible in to_integer case only */ + goto error_exit; + } - term = 1; - } else { this_digit = (u8) ACPI_TOUPPER(*string); if (ACPI_IS_XDIGIT((char)this_digit)) { - /* Convert ASCII Hex char to value */ this_digit = this_digit - 'A' + 10; } else { - term = 1; - } - } - - if (term) { - if (to_integer_op) { - goto error_exit; - } else { + /* + * We allow non-hex chars, just stop now, same as end-of-string. + * See ACPI spec, string-to-integer conversion. + */ break; } - } else if ((valid_digits == 0) && (this_digit == 0) - && !sign_of0x) { - - /* Skip zeros */ - string++; - continue; - } - - valid_digits++; - - if (sign_of0x - && ((valid_digits > 16) - || ((valid_digits > 8) && mode32))) { - /* - * This is to_integer operation case. - * No any restrictions for string-to-integer conversion, - * see ACPI spec. - */ - goto error_exit; } /* Divide the digit into the correct position */ (void) - acpi_ut_short_divide((dividend - (acpi_integer) this_digit), - base, "ient, NULL); - + acpi_ut_short_divide((ACPI_INTEGER_MAX - + (acpi_integer) this_digit), base, + "ient, NULL); if (return_value > quotient) { - if (to_integer_op) { - goto error_exit; - } else { - break; - } + goto error_exit; } return_value *= base; @@ -762,11 +642,6 @@ acpi_ut_strtoul64(char *string, u32 base, acpi_integer * ret_integer) /* All done, normal exit */ - all_done: - - ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n", - ACPI_FORMAT_UINT64(return_value))); - *ret_integer = return_value; return_ACPI_STATUS(AE_OK); @@ -844,7 +719,7 @@ acpi_ut_walk_package_tree(union acpi_operand_object * source_object, u32 this_index; union acpi_operand_object *this_source_obj; - ACPI_FUNCTION_TRACE(ut_walk_package_tree); + ACPI_FUNCTION_TRACE("ut_walk_package_tree"); state = acpi_ut_create_pkg_state(source_object, target_object, 0); if (!state) { @@ -852,7 +727,6 @@ acpi_ut_walk_package_tree(union acpi_operand_object * source_object, } while (state) { - /* Get one element of the package */ this_index = state->pkg.index; @@ -938,6 +812,31 @@ acpi_ut_walk_package_tree(union acpi_operand_object * source_object, return_ACPI_STATUS(AE_AML_INTERNAL); } +/******************************************************************************* + * + * FUNCTION: acpi_ut_generate_checksum + * + * PARAMETERS: Buffer - Buffer to be scanned + * Length - number of bytes to examine + * + * RETURN: The generated checksum + * + * DESCRIPTION: Generate a checksum on a raw buffer + * + ******************************************************************************/ + +u8 acpi_ut_generate_checksum(u8 * buffer, u32 length) +{ + u32 i; + signed char sum = 0; + + for (i = 0; i < length; i++) { + sum = (signed char)(sum + buffer[i]); + } + + return ((u8) (0 - sum)); +} + /******************************************************************************* * * FUNCTION: acpi_ut_error, acpi_ut_warning, acpi_ut_info @@ -977,7 +876,6 @@ acpi_ut_exception(char *module_name, acpi_os_vprintf(format, args); acpi_os_printf(" [%X]\n", ACPI_CA_VERSION); } -EXPORT_SYMBOL(acpi_ut_exception); void ACPI_INTERNAL_VAR_XFACE acpi_ut_warning(char *module_name, u32 line_number, char *format, ...) @@ -1002,3 +900,36 @@ acpi_ut_info(char *module_name, u32 line_number, char *format, ...) acpi_os_vprintf(format, args); acpi_os_printf(" [%X]\n", ACPI_CA_VERSION); } + +/******************************************************************************* + * + * FUNCTION: acpi_ut_report_error, Warning, Info + * + * PARAMETERS: module_name - Caller's module name (for error output) + * line_number - Caller's line number (for error output) + * + * RETURN: None + * + * DESCRIPTION: Print error message + * + * Note: Legacy only, should be removed when no longer used by drivers. + * + ******************************************************************************/ + +void acpi_ut_report_error(char *module_name, u32 line_number) +{ + + acpi_os_printf("ACPI Error (%s-%04d): ", module_name, line_number); +} + +void acpi_ut_report_warning(char *module_name, u32 line_number) +{ + + acpi_os_printf("ACPI Warning (%s-%04d): ", module_name, line_number); +} + +void acpi_ut_report_info(char *module_name, u32 line_number) +{ + + acpi_os_printf("ACPI (%s-%04d): ", module_name, line_number); +}