/******************************************************************************* * * Module Name: dbtest - Various debug-related tests * ******************************************************************************/ /* * Copyright (C) 2000 - 2017, Intel Corp. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions, and the following disclaimer, * without modification. * 2. Redistributions in binary form must reproduce at minimum a disclaimer * substantially similar to the "NO WARRANTY" disclaimer below * ("Disclaimer") and any redistribution must be conditioned upon * including a substantially similar Disclaimer requirement for further * binary redistribution. * 3. Neither the names of the above-listed copyright holders nor the names * of any contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * Alternatively, this software may be distributed under the terms of the * GNU General Public License ("GPL") version 2 as published by the Free * Software Foundation. * * NO WARRANTY * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGES. */ #include #include "accommon.h" #include "acdebug.h" #include "acnamesp.h" #include "acpredef.h" #define _COMPONENT ACPI_CA_DEBUGGER ACPI_MODULE_NAME("dbtest") /* Local prototypes */ static void acpi_db_test_all_objects(void); static acpi_status acpi_db_test_one_object(acpi_handle obj_handle, u32 nesting_level, void *context, void **return_value); static acpi_status acpi_db_test_integer_type(struct acpi_namespace_node *node, u32 bit_length); static acpi_status acpi_db_test_buffer_type(struct acpi_namespace_node *node, u32 bit_length); static acpi_status acpi_db_test_string_type(struct acpi_namespace_node *node, u32 byte_length); static acpi_status acpi_db_read_from_object(struct acpi_namespace_node *node, acpi_object_type expected_type, union acpi_object **value); static acpi_status acpi_db_write_to_object(struct acpi_namespace_node *node, union acpi_object *value); static void acpi_db_evaluate_all_predefined_names(char *count_arg); static acpi_status acpi_db_evaluate_one_predefined_name(acpi_handle obj_handle, u32 nesting_level, void *context, void **return_value); /* * Test subcommands */ static struct acpi_db_argument_info acpi_db_test_types[] = { {"OBJECTS"}, {"PREDEFINED"}, {NULL} /* Must be null terminated */ }; #define CMD_TEST_OBJECTS 0 #define CMD_TEST_PREDEFINED 1 #define BUFFER_FILL_VALUE 0xFF /* * Support for the special debugger read/write control methods. * These methods are installed into the current namespace and are * used to read and write the various namespace objects. The point * is to force the AML interpreter do all of the work. */ #define ACPI_DB_READ_METHOD "\\_T98" #define ACPI_DB_WRITE_METHOD "\\_T99" static acpi_handle read_handle = NULL; static acpi_handle write_handle = NULL; /* ASL Definitions of the debugger read/write control methods */ #if 0 definition_block("ssdt.aml", "SSDT", 2, "Intel", "DEBUG", 0x00000001) { method(_T98, 1, not_serialized) { /* Read */ return (de_ref_of(arg0)) } } definition_block("ssdt2.aml", "SSDT", 2, "Intel", "DEBUG", 0x00000001) { method(_T99, 2, not_serialized) { /* Write */ store(arg1, arg0) } } #endif static unsigned char read_method_code[] = { 0x53, 0x53, 0x44, 0x54, 0x2E, 0x00, 0x00, 0x00, /* 00000000 "SSDT...." */ 0x02, 0xC9, 0x49, 0x6E, 0x74, 0x65, 0x6C, 0x00, /* 00000008 "..Intel." */ 0x44, 0x45, 0x42, 0x55, 0x47, 0x00, 0x00, 0x00, /* 00000010 "DEBUG..." */ 0x01, 0x00, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* 00000018 "....INTL" */ 0x18, 0x12, 0x13, 0x20, 0x14, 0x09, 0x5F, 0x54, /* 00000020 "... .._T" */ 0x39, 0x38, 0x01, 0xA4, 0x83, 0x68 /* 00000028 "98...h" */ }; static unsigned char write_method_code[] = { 0x53, 0x53, 0x44, 0x54, 0x2E, 0x00, 0x00, 0x00, /* 00000000 "SSDT...." */ 0x02, 0x15, 0x49, 0x6E, 0x74, 0x65, 0x6C, 0x00, /* 00000008 "..Intel." */ 0x44, 0x45, 0x42, 0x55, 0x47, 0x00, 0x00, 0x00, /* 00000010 "DEBUG..." */ 0x01, 0x00, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* 00000018 "....INTL" */ 0x18, 0x12, 0x13, 0x20, 0x14, 0x09, 0x5F, 0x54, /* 00000020 "... .._T" */ 0x39, 0x39, 0x02, 0x70, 0x69, 0x68 /* 00000028 "99.pih" */ }; /******************************************************************************* * * FUNCTION: acpi_db_execute_test * * PARAMETERS: type_arg - Subcommand * * RETURN: None * * DESCRIPTION: Execute various debug tests. * * Note: Code is prepared for future expansion of the TEST command. * ******************************************************************************/ void acpi_db_execute_test(char *type_arg) { u32 temp; acpi_ut_strupr(type_arg); temp = acpi_db_match_argument(type_arg, acpi_db_test_types); if (temp == ACPI_TYPE_NOT_FOUND) { acpi_os_printf("Invalid or unsupported argument\n"); return; } switch (temp) { case CMD_TEST_OBJECTS: acpi_db_test_all_objects(); break; case CMD_TEST_PREDEFINED: acpi_db_evaluate_all_predefined_names(NULL); break; default: break; } } /******************************************************************************* * * FUNCTION: acpi_db_test_all_objects * * PARAMETERS: None * * RETURN: None * * DESCRIPTION: This test implements the OBJECTS subcommand. It exercises the * namespace by reading/writing/comparing all data objects such * as integers, strings, buffers, fields, buffer fields, etc. * ******************************************************************************/ static void acpi_db_test_all_objects(void) { acpi_status status; /* Install the debugger read-object control method if necessary */ if (!read_handle) { status = acpi_install_method(read_method_code); if (ACPI_FAILURE(status)) { acpi_os_printf ("%s, Could not install debugger read method\n", acpi_format_exception(status)); return; } status = acpi_get_handle(NULL, ACPI_DB_READ_METHOD, &read_handle); if (ACPI_FAILURE(status)) { acpi_os_printf ("Could not obtain handle for debug method %s\n", ACPI_DB_READ_METHOD); return; } } /* Install the debugger write-object control method if necessary */ if (!write_handle) { status = acpi_install_method(write_method_code); if (ACPI_FAILURE(status)) { acpi_os_printf ("%s, Could not install debugger write method\n", acpi_format_exception(status)); return; } status = acpi_get_handle(NULL, ACPI_DB_WRITE_METHOD, &write_handle); if (ACPI_FAILURE(status)) { acpi_os_printf ("Could not obtain handle for debug method %s\n", ACPI_DB_WRITE_METHOD); return; } } /* Walk the entire namespace, testing each supported named data object */ (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, acpi_db_test_one_object, NULL, NULL, NULL); } /******************************************************************************* * * FUNCTION: acpi_db_test_one_object * * PARAMETERS: acpi_walk_callback * * RETURN: Status * * DESCRIPTION: Test one namespace object. Supported types are Integer, * String, Buffer, buffer_field, and field_unit. All other object * types are simply ignored. * * Note: Support for Packages is not implemented. * ******************************************************************************/ static acpi_status acpi_db_test_one_object(acpi_handle obj_handle, u32 nesting_level, void *context, void **return_value) { struct acpi_namespace_node *node; union acpi_operand_object *obj_desc; union acpi_operand_object *region_obj; acpi_object_type local_type; u32 bit_length = 0; u32 byte_length = 0; acpi_status status = AE_OK; node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle); obj_desc = node->object; /* * For the supported types, get the actual bit length or * byte length. Map the type to one of Integer/String/Buffer. */ switch (node->type) { case ACPI_TYPE_INTEGER: /* Integer width is either 32 or 64 */ local_type = ACPI_TYPE_INTEGER; bit_length = acpi_gbl_integer_bit_width; break; case ACPI_TYPE_STRING: local_type = ACPI_TYPE_STRING; byte_length = obj_desc->string.length; break; case ACPI_TYPE_BUFFER: local_type = ACPI_TYPE_BUFFER; byte_length = obj_desc->buffer.length; bit_length = byte_length * 8; break; case ACPI_TYPE_FIELD_UNIT: case ACPI_TYPE_BUFFER_FIELD: case ACPI_TYPE_LOCAL_REGION_FIELD: case ACPI_TYPE_LOCAL_INDEX_FIELD: case ACPI_TYPE_LOCAL_BANK_FIELD: local_type = ACPI_TYPE_INTEGER; if (obj_desc) { /* * Returned object will be a Buffer if the field length * is larger than the size of an Integer (32 or 64 bits * depending on the DSDT version). */ bit_length = obj_desc->common_field.bit_length; byte_length = ACPI_ROUND_BITS_UP_TO_BYTES(bit_length); if (bit_length > acpi_gbl_integer_bit_width) { local_type = ACPI_TYPE_BUFFER; } } break; default: /* Ignore all other types */ return (AE_OK); } /* Emit the common prefix: Type:Name */ acpi_os_printf("%14s: %4.4s", acpi_ut_get_type_name(node->type), node->name.ascii); if (!obj_desc) { acpi_os_printf(" Ignoring, no attached object\n"); return (AE_OK); } /* * Check for unsupported region types. Note: acpi_exec simulates * access to system_memory, system_IO, PCI_Config, and EC. */ switch (node->type) { case ACPI_TYPE_LOCAL_REGION_FIELD: region_obj = obj_desc->field.region_obj; switch (region_obj->region.space_id) { case ACPI_ADR_SPACE_SYSTEM_MEMORY: case ACPI_ADR_SPACE_SYSTEM_IO: case ACPI_ADR_SPACE_PCI_CONFIG: case ACPI_ADR_SPACE_EC: break; default: acpi_os_printf (" %s space is not supported [%4.4s]\n", acpi_ut_get_region_name(region_obj->region. space_id), region_obj->region.node->name.ascii); return (AE_OK); } break; default: break; } /* At this point, we have resolved the object to one of the major types */ switch (local_type) { case ACPI_TYPE_INTEGER: status = acpi_db_test_integer_type(node, bit_length); break; case ACPI_TYPE_STRING: status = acpi_db_test_string_type(node, byte_length); break; case ACPI_TYPE_BUFFER: status = acpi_db_test_buffer_type(node, bit_length); break; default: acpi_os_printf(" Ignoring, type not implemented (%2.2X)", local_type); break; } switch (node->type) { case ACPI_TYPE_LOCAL_REGION_FIELD: region_obj = obj_desc->field.region_obj; acpi_os_printf(" (%s)", acpi_ut_get_region_name(region_obj->region. space_id)); break; default: break; } acpi_os_printf("\n"); return (status); } /******************************************************************************* * * FUNCTION: acpi_db_test_integer_type * * PARAMETERS: node - Parent NS node for the object * bit_length - Actual length of the object. Used for * support of arbitrary length field_unit * and buffer_field objects. * * RETURN: Status * * DESCRIPTION: Test read/write for an Integer-valued object. Performs a * write/read/compare of an arbitrary new value, then performs * a write/read/compare of the original value. * ******************************************************************************/ static acpi_status acpi_db_test_integer_type(struct acpi_namespace_node *node, u32 bit_length) { union acpi_object *temp1 = NULL; union acpi_object *temp2 = NULL; union acpi_object *temp3 = NULL; union acpi_object write_value; u64 value_to_write; acpi_status status; if (bit_length > 64) { acpi_os_printf(" Invalid length for an Integer: %u", bit_length); return (AE_OK); } /* Read the original value */ status = acpi_db_read_from_object(node, ACPI_TYPE_INTEGER, &temp1); if (ACPI_FAILURE(status)) { return (status); } acpi_os_printf(" (%4.4X/%3.3X) %8.8X%8.8X", bit_length, ACPI_ROUND_BITS_UP_TO_BYTES(bit_length), ACPI_FORMAT_UINT64(temp1->integer.value)); value_to_write = ACPI_UINT64_MAX >> (64 - bit_length); if (temp1->integer.value == value_to_write) { value_to_write = 0; } /* Write a new value */ write_value.type = ACPI_TYPE_INTEGER; write_value.integer.value = value_to_write; status = acpi_db_write_to_object(node, &write_value); if (ACPI_FAILURE(status)) { goto exit; } /* Ensure that we can read back the new value */ status = acpi_db_read_from_object(node, ACPI_TYPE_INTEGER, &temp2); if (ACPI_FAILURE(status)) { goto exit; } if (temp2->integer.value != value_to_write) { acpi_os_printf(" MISMATCH 2: %8.8X%8.8X, expecting %8.8X%8.8X", ACPI_FORMAT_UINT64(temp2->integer.value), ACPI_FORMAT_UINT64(value_to_write)); } /* Write back the original value */ write_value.integer.value = temp1->integer.value; status = acpi_db_write_to_object(node, &write_value); if (ACPI_FAILURE(status)) { goto exit; } /* Ensure that we can read back the original value */ status = acpi_db_read_from_object(node, ACPI_TYPE_INTEGER, &temp3); if (ACPI_FAILURE(status)) { goto exit; } if (temp3->integer.value != temp1->integer.value) { acpi_os_printf(" MISMATCH 3: %8.8X%8.8X, expecting %8.8X%8.8X", ACPI_FORMAT_UINT64(temp3->integer.value), ACPI_FORMAT_UINT64(temp1->integer.value)); } exit: if (temp1) { acpi_os_free(temp1); } if (temp2) { acpi_os_free(temp2); } if (temp3) { acpi_os_free(temp3); } return (AE_OK); } /******************************************************************************* * * FUNCTION: acpi_db_test_buffer_type * * PARAMETERS: node - Parent NS node for the object * bit_length - Actual length of the object. * * RETURN: Status * * DESCRIPTION: Test read/write for an Buffer-valued object. Performs a * write/read/compare of an arbitrary new value, then performs * a write/read/compare of the original value. * ******************************************************************************/ static acpi_status acpi_db_test_buffer_type(struct acpi_namespace_node *node, u32 bit_length) { union acpi_object *temp1 = NULL; union acpi_object *temp2 = NULL; union acpi_object *temp3 = NULL; u8 *buffer; union acpi_object write_value; acpi_status status; u32 byte_length; u32 i; u8 extra_bits; byte_length = ACPI_ROUND_BITS_UP_TO_BYTES(bit_length); if (byte_length == 0) { acpi_os_printf(" Ignoring zero length buffer"); return (AE_OK); } /* Allocate a local buffer */ buffer = ACPI_ALLOCATE_ZEROED(byte_length); if (!buffer) { return (AE_NO_MEMORY); } /* Read the original value */ status = acpi_db_read_from_object(node, ACPI_TYPE_BUFFER, &temp1); if (ACPI_FAILURE(status)) { goto exit; } /* Emit a few bytes of the buffer */ acpi_os_printf(" (%4.4X/%3.3X)", bit_length, temp1->buffer.length); for (i = 0; ((i < 4) && (i < byte_length)); i++) { acpi_os_printf(" %2.2X", temp1->buffer.pointer[i]); } acpi_os_printf("... "); /* * Write a new value. * * Handle possible extra bits at the end of the buffer. Can * happen for field_units larger than an integer, but the bit * count is not an integral number of bytes. Zero out the * unused bits. */ memset(buffer, BUFFER_FILL_VALUE, byte_length); extra_bits = bit_length % 8; if (extra_bits) { buffer[byte_length - 1] = ACPI_MASK_BITS_ABOVE(extra_bits); } write_value.type = ACPI_TYPE_BUFFER; write_value.buffer.length = byte_length; write_value.buffer.pointer = buffer; status = acpi_db_write_to_object(node, &write_value); if (ACPI_FAILURE(status)) { goto exit; } /* Ensure that we can read back the new value */ status = acpi_db_read_from_object(node, ACPI_TYPE_BUFFER, &temp2); if (ACPI_FAILURE(status)) { goto exit; } if (memcmp(temp2->buffer.pointer, buffer, byte_length)) { acpi_os_printf(" MISMATCH 2: New buffer value"); } /* Write back the original value */ write_value.buffer.length = byte_length; write_value.buffer.pointer = temp1->buffer.pointer; status = acpi_db_write_to_object(node, &write_value); if (ACPI_FAILURE(status)) { goto exit; } /* Ensure that we can read back the original value */ status = acpi_db_read_from_object(node, ACPI_TYPE_BUFFER, &temp3); if (ACPI_FAILURE(status)) { goto exit; } if (memcmp(temp1->buffer.pointer, temp3->buffer.pointer, byte_length)) { acpi_os_printf(" MISMATCH 3: While restoring original buffer"); } exit: ACPI_FREE(buffer); if (temp1) { acpi_os_free(temp1); } if (temp2) { acpi_os_free(temp2); } if (temp3) { acpi_os_free(temp3); } return (status); } /******************************************************************************* * * FUNCTION: acpi_db_test_string_type * * PARAMETERS: node - Parent NS node for the object * byte_length - Actual length of the object. * * RETURN: Status * * DESCRIPTION: Test read/write for an String-valued object. Performs a * write/read/compare of an arbitrary new value, then performs * a write/read/compare of the original value. * ******************************************************************************/ static acpi_status acpi_db_test_string_type(struct acpi_namespace_node *node, u32 byte_length) { union acpi_object *temp1 = NULL; union acpi_object *temp2 = NULL; union acpi_object *temp3 = NULL; char *value_to_write = "Test String from AML Debugger"; union acpi_object write_value; acpi_status status; /* Read the original value */ status = acpi_db_read_from_object(node, ACPI_TYPE_STRING, &temp1); if (ACPI_FAILURE(status)) { return (status); } acpi_os_printf(" (%4.4X/%3.3X) \"%s\"", (temp1->string.length * 8), temp1->string.length, temp1->string.pointer); /* Write a new value */ write_value.type = ACPI_TYPE_STRING; write_value.string.length = strlen(value_to_write); write_value.string.pointer = value_to_write; status = acpi_db_write_to_object(node, &write_value); if (ACPI_FAILURE(status)) { goto exit; } /* Ensure that we can read back the new value */ status = acpi_db_read_from_object(node, ACPI_TYPE_STRING, &temp2); if (ACPI_FAILURE(status)) { goto exit; } if (strcmp(temp2->string.pointer, value_to_write)) { acpi_os_printf(" MISMATCH 2: %s, expecting %s", temp2->string.pointer, value_to_write); } /* Write back the original value */ write_value.string.length = strlen(temp1->string.pointer); write_value.string.pointer = temp1->string.pointer; status = acpi_db_write_to_object(node, &write_value); if (ACPI_FAILURE(status)) { goto exit; } /* Ensure that we can read back the original value */ status = acpi_db_read_from_object(node, ACPI_TYPE_STRING, &temp3); if (ACPI_FAILURE(status)) { goto exit; } if (strcmp(temp1->string.pointer, temp3->string.pointer)) { acpi_os_printf(" MISMATCH 3: %s, expecting %s", temp3->string.pointer, temp1->string.pointer); } exit: if (temp1) { acpi_os_free(temp1); } if (temp2) { acpi_os_free(temp2); } if (temp3) { acpi_os_free(temp3); } return (status); } /******************************************************************************* * * FUNCTION: acpi_db_read_from_object * * PARAMETERS: node - Parent NS node for the object * expected_type - Object type expected from the read * value - Where the value read is returned * * RETURN: Status * * DESCRIPTION: Performs a read from the specified object by invoking the * special debugger control method that reads the object. Thus, * the AML interpreter is doing all of the work, increasing the * validity of the test. * ******************************************************************************/ static acpi_status acpi_db_read_from_object(struct acpi_namespace_node *node, acpi_object_type expected_type, union acpi_object **value) { union acpi_object *ret_value; struct acpi_object_list param_objects; union acpi_object params[2]; struct acpi_buffer return_obj; acpi_status status; params[0].type = ACPI_TYPE_LOCAL_REFERENCE; params[0].reference.actual_type = node->type; params[0].reference.handle = ACPI_CAST_PTR(acpi_handle, node); param_objects.count = 1; param_objects.pointer = params; return_obj.length = ACPI_ALLOCATE_BUFFER; acpi_gbl_method_executing = TRUE; status = acpi_evaluate_object(read_handle, NULL, ¶m_objects, &return_obj); acpi_gbl_method_executing = FALSE; if (ACPI_FAILURE(status)) { acpi_os_printf("Could not read from object, %s", acpi_format_exception(status)); return (status); } ret_value = (union acpi_object *)return_obj.pointer; switch (ret_value->type) { case ACPI_TYPE_INTEGER: case ACPI_TYPE_BUFFER: case ACPI_TYPE_STRING: /* * Did we receive the type we wanted? Most important for the * Integer/Buffer case (when a field is larger than an Integer, * it should return a Buffer). */ if (ret_value->type != expected_type) { acpi_os_printf (" Type mismatch: Expected %s, Received %s", acpi_ut_get_type_name(expected_type), acpi_ut_get_type_name(ret_value->type)); return (AE_TYPE); } *value = ret_value; break; default: acpi_os_printf(" Unsupported return object type, %s", acpi_ut_get_type_name(ret_value->type)); acpi_os_free(return_obj.pointer); return (AE_TYPE); } return (status); } /******************************************************************************* * * FUNCTION: acpi_db_write_to_object * * PARAMETERS: node - Parent NS node for the object * value - Value to be written * * RETURN: Status * * DESCRIPTION: Performs a write to the specified object by invoking the * special debugger control method that writes the object. Thus, * the AML interpreter is doing all of the work, increasing the * validity of the test. * ******************************************************************************/ static acpi_status acpi_db_write_to_object(struct acpi_namespace_node *node, union acpi_object *value) { struct acpi_object_list param_objects; union acpi_object params[2]; acpi_status status; params[0].type = ACPI_TYPE_LOCAL_REFERENCE; params[0].reference.actual_type = node->type; params[0].reference.handle = ACPI_CAST_PTR(acpi_handle, node); /* Copy the incoming user parameter */ memcpy(¶ms[1], value, sizeof(union acpi_object)); param_objects.count = 2; param_objects.pointer = params; acpi_gbl_method_executing = TRUE; status = acpi_evaluate_object(write_handle, NULL, ¶m_objects, NULL); acpi_gbl_method_executing = FALSE; if (ACPI_FAILURE(status)) { acpi_os_printf("Could not write to object, %s", acpi_format_exception(status)); } return (status); } /******************************************************************************* * * FUNCTION: acpi_db_evaluate_all_predefined_names * * PARAMETERS: count_arg - Max number of methods to execute * * RETURN: None * * DESCRIPTION: Namespace batch execution. Execute predefined names in the * namespace, up to the max count, if specified. * ******************************************************************************/ static void acpi_db_evaluate_all_predefined_names(char *count_arg) { struct acpi_db_execute_walk info; info.count = 0; info.max_count = ACPI_UINT32_MAX; if (count_arg) { info.max_count = strtoul(count_arg, NULL, 0); } /* Search all nodes in namespace */ (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX, acpi_db_evaluate_one_predefined_name, NULL, (void *)&info, NULL); acpi_os_printf("Evaluated %u predefined names in the namespace\n", info.count); } /******************************************************************************* * * FUNCTION: acpi_db_evaluate_one_predefined_name * * PARAMETERS: Callback from walk_namespace * * RETURN: Status * * DESCRIPTION: Batch execution module. Currently only executes predefined * ACPI names. * ******************************************************************************/ static acpi_status acpi_db_evaluate_one_predefined_name(acpi_handle obj_handle, u32 nesting_level, void *context, void **return_value) { struct acpi_namespace_node *node = (struct acpi_namespace_node *)obj_handle; struct acpi_db_execute_walk *info = (struct acpi_db_execute_walk *)context; char *pathname; const union acpi_predefined_info *predefined; struct acpi_device_info *obj_info; struct acpi_object_list param_objects; union acpi_object params[ACPI_METHOD_NUM_ARGS]; union acpi_object *this_param; struct acpi_buffer return_obj; acpi_status status; u16 arg_type_list; u8 arg_count; u8 arg_type; u32 i; /* The name must be a predefined ACPI name */ predefined = acpi_ut_match_predefined_method(node->name.ascii); if (!predefined) { return (AE_OK); } if (node->type == ACPI_TYPE_LOCAL_SCOPE) { return (AE_OK); } pathname = acpi_ns_get_normalized_pathname(node, TRUE); if (!pathname) { return (AE_OK); } /* Get the object info for number of method parameters */ status = acpi_get_object_info(obj_handle, &obj_info); if (ACPI_FAILURE(status)) { ACPI_FREE(pathname); return (status); } param_objects.count = 0; param_objects.pointer = NULL; if (obj_info->type == ACPI_TYPE_METHOD) { /* Setup default parameters (with proper types) */ arg_type_list = predefined->info.argument_list; arg_count = METHOD_GET_ARG_COUNT(arg_type_list); /* * Setup the ACPI-required number of arguments, regardless of what * the actual method defines. If there is a difference, then the * method is wrong and a warning will be issued during execution. */ this_param = params; for (i = 0; i < arg_count; i++) { arg_type = METHOD_GET_NEXT_TYPE(arg_type_list); this_param->type = arg_type; switch (arg_type) { case ACPI_TYPE_INTEGER: this_param->integer.value = 1; break; case ACPI_TYPE_STRING: this_param->string.pointer = "This is the default argument string"; this_param->string.length = strlen(this_param->string.pointer); break; case ACPI_TYPE_BUFFER: this_param->buffer.pointer = (u8 *)params; /* just a garbage buffer */ this_param->buffer.length = 48; break; case ACPI_TYPE_PACKAGE: this_param->package.elements = NULL; this_param->package.count = 0; break; default: acpi_os_printf ("%s: Unsupported argument type: %u\n", pathname, arg_type); break; } this_param++; } param_objects.count = arg_count; param_objects.pointer = params; } ACPI_FREE(obj_info); return_obj.pointer = NULL; return_obj.length = ACPI_ALLOCATE_BUFFER; /* Do the actual method execution */ acpi_gbl_method_executing = TRUE; status = acpi_evaluate_object(node, NULL, ¶m_objects, &return_obj); acpi_os_printf("%-32s returned %s\n", pathname, acpi_format_exception(status)); acpi_gbl_method_executing = FALSE; ACPI_FREE(pathname); /* Ignore status from method execution */ status = AE_OK; /* Update count, check if we have executed enough methods */ info->count++; if (info->count >= info->max_count) { status = AE_CTRL_TERMINATE; } return (status); }