mirror of https://github.com/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.
306 lines
9.1 KiB
306 lines
9.1 KiB
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
|
/******************************************************************************* |
|
* |
|
* Module Name: nseval - Object evaluation, includes control method execution |
|
* |
|
******************************************************************************/ |
|
|
|
#include <acpi/acpi.h> |
|
#include "accommon.h" |
|
#include "acparser.h" |
|
#include "acinterp.h" |
|
#include "acnamesp.h" |
|
|
|
#define _COMPONENT ACPI_NAMESPACE |
|
ACPI_MODULE_NAME("nseval") |
|
|
|
/******************************************************************************* |
|
* |
|
* FUNCTION: acpi_ns_evaluate |
|
* |
|
* PARAMETERS: info - Evaluation info block, contains these fields |
|
* and more: |
|
* prefix_node - Prefix or Method/Object Node to execute |
|
* relative_path - Name of method to execute, If NULL, the |
|
* Node is the object to execute |
|
* parameters - List of parameters to pass to the method, |
|
* terminated by NULL. Params itself may be |
|
* NULL if no parameters are being passed. |
|
* parameter_type - Type of Parameter list |
|
* return_object - Where to put method's return value (if |
|
* any). If NULL, no value is returned. |
|
* flags - ACPI_IGNORE_RETURN_VALUE to delete return |
|
* |
|
* RETURN: Status |
|
* |
|
* DESCRIPTION: Execute a control method or return the current value of an |
|
* ACPI namespace object. |
|
* |
|
* MUTEX: Locks interpreter |
|
* |
|
******************************************************************************/ |
|
acpi_status acpi_ns_evaluate(struct acpi_evaluate_info *info) |
|
{ |
|
acpi_status status; |
|
|
|
ACPI_FUNCTION_TRACE(ns_evaluate); |
|
|
|
if (!info) { |
|
return_ACPI_STATUS(AE_BAD_PARAMETER); |
|
} |
|
|
|
if (!info->node) { |
|
/* |
|
* Get the actual namespace node for the target object if we |
|
* need to. Handles these cases: |
|
* |
|
* 1) Null node, valid pathname from root (absolute path) |
|
* 2) Node and valid pathname (path relative to Node) |
|
* 3) Node, Null pathname |
|
*/ |
|
status = |
|
acpi_ns_get_node(info->prefix_node, info->relative_pathname, |
|
ACPI_NS_NO_UPSEARCH, &info->node); |
|
if (ACPI_FAILURE(status)) { |
|
return_ACPI_STATUS(status); |
|
} |
|
} |
|
|
|
/* |
|
* For a method alias, we must grab the actual method node so that |
|
* proper scoping context will be established before execution. |
|
*/ |
|
if (acpi_ns_get_type(info->node) == ACPI_TYPE_LOCAL_METHOD_ALIAS) { |
|
info->node = |
|
ACPI_CAST_PTR(struct acpi_namespace_node, |
|
info->node->object); |
|
} |
|
|
|
/* Complete the info block initialization */ |
|
|
|
info->return_object = NULL; |
|
info->node_flags = info->node->flags; |
|
info->obj_desc = acpi_ns_get_attached_object(info->node); |
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_NAMES, "%s [%p] Value %p\n", |
|
info->relative_pathname, info->node, |
|
acpi_ns_get_attached_object(info->node))); |
|
|
|
/* Get info if we have a predefined name (_HID, etc.) */ |
|
|
|
info->predefined = |
|
acpi_ut_match_predefined_method(info->node->name.ascii); |
|
|
|
/* Get the full pathname to the object, for use in warning messages */ |
|
|
|
info->full_pathname = acpi_ns_get_normalized_pathname(info->node, TRUE); |
|
if (!info->full_pathname) { |
|
return_ACPI_STATUS(AE_NO_MEMORY); |
|
} |
|
|
|
/* Optional object evaluation log */ |
|
|
|
ACPI_DEBUG_PRINT_RAW((ACPI_DB_EVALUATION, |
|
"%-26s: %s (%s)\n", " Enter evaluation", |
|
&info->full_pathname[1], |
|
acpi_ut_get_type_name(info->node->type))); |
|
|
|
/* Count the number of arguments being passed in */ |
|
|
|
info->param_count = 0; |
|
if (info->parameters) { |
|
while (info->parameters[info->param_count]) { |
|
info->param_count++; |
|
} |
|
|
|
/* Warn on impossible argument count */ |
|
|
|
if (info->param_count > ACPI_METHOD_NUM_ARGS) { |
|
ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname, |
|
ACPI_WARN_ALWAYS, |
|
"Excess arguments (%u) - using only %u", |
|
info->param_count, |
|
ACPI_METHOD_NUM_ARGS)); |
|
|
|
info->param_count = ACPI_METHOD_NUM_ARGS; |
|
} |
|
} |
|
|
|
/* |
|
* For predefined names: Check that the declared argument count |
|
* matches the ACPI spec -- otherwise this is a BIOS error. |
|
*/ |
|
acpi_ns_check_acpi_compliance(info->full_pathname, info->node, |
|
info->predefined); |
|
|
|
/* |
|
* For all names: Check that the incoming argument count for |
|
* this method/object matches the actual ASL/AML definition. |
|
*/ |
|
acpi_ns_check_argument_count(info->full_pathname, info->node, |
|
info->param_count, info->predefined); |
|
|
|
/* For predefined names: Typecheck all incoming arguments */ |
|
|
|
acpi_ns_check_argument_types(info); |
|
|
|
/* |
|
* Three major evaluation cases: |
|
* |
|
* 1) Object types that cannot be evaluated by definition |
|
* 2) The object is a control method -- execute it |
|
* 3) The object is not a method -- just return it's current value |
|
*/ |
|
switch (acpi_ns_get_type(info->node)) { |
|
case ACPI_TYPE_ANY: |
|
case ACPI_TYPE_DEVICE: |
|
case ACPI_TYPE_EVENT: |
|
case ACPI_TYPE_MUTEX: |
|
case ACPI_TYPE_REGION: |
|
case ACPI_TYPE_THERMAL: |
|
case ACPI_TYPE_LOCAL_SCOPE: |
|
/* |
|
* 1) Disallow evaluation of these object types. For these, |
|
* object evaluation is undefined. |
|
*/ |
|
ACPI_ERROR((AE_INFO, |
|
"%s: This object type [%s] " |
|
"never contains data and cannot be evaluated", |
|
info->full_pathname, |
|
acpi_ut_get_type_name(info->node->type))); |
|
|
|
status = AE_TYPE; |
|
goto cleanup; |
|
|
|
case ACPI_TYPE_METHOD: |
|
/* |
|
* 2) Object is a control method - execute it |
|
*/ |
|
|
|
/* Verify that there is a method object associated with this node */ |
|
|
|
if (!info->obj_desc) { |
|
ACPI_ERROR((AE_INFO, |
|
"%s: Method has no attached sub-object", |
|
info->full_pathname)); |
|
status = AE_NULL_OBJECT; |
|
goto cleanup; |
|
} |
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_EXEC, |
|
"**** Execute method [%s] at AML address %p length %X\n", |
|
info->full_pathname, |
|
info->obj_desc->method.aml_start + 1, |
|
info->obj_desc->method.aml_length - 1)); |
|
|
|
/* |
|
* Any namespace deletion must acquire both the namespace and |
|
* interpreter locks to ensure that no thread is using the portion of |
|
* the namespace that is being deleted. |
|
* |
|
* Execute the method via the interpreter. The interpreter is locked |
|
* here before calling into the AML parser |
|
*/ |
|
acpi_ex_enter_interpreter(); |
|
status = acpi_ps_execute_method(info); |
|
acpi_ex_exit_interpreter(); |
|
break; |
|
|
|
default: |
|
/* |
|
* 3) All other non-method objects -- get the current object value |
|
*/ |
|
|
|
/* |
|
* Some objects require additional resolution steps (e.g., the Node |
|
* may be a field that must be read, etc.) -- we can't just grab |
|
* the object out of the node. |
|
* |
|
* Use resolve_node_to_value() to get the associated value. |
|
* |
|
* NOTE: we can get away with passing in NULL for a walk state because |
|
* the Node is guaranteed to not be a reference to either a method |
|
* local or a method argument (because this interface is never called |
|
* from a running method.) |
|
* |
|
* Even though we do not directly invoke the interpreter for object |
|
* resolution, we must lock it because we could access an op_region. |
|
* The op_region access code assumes that the interpreter is locked. |
|
*/ |
|
acpi_ex_enter_interpreter(); |
|
|
|
/* TBD: resolve_node_to_value has a strange interface, fix */ |
|
|
|
info->return_object = |
|
ACPI_CAST_PTR(union acpi_operand_object, info->node); |
|
|
|
status = |
|
acpi_ex_resolve_node_to_value(ACPI_CAST_INDIRECT_PTR |
|
(struct acpi_namespace_node, |
|
&info->return_object), NULL); |
|
acpi_ex_exit_interpreter(); |
|
|
|
if (ACPI_FAILURE(status)) { |
|
info->return_object = NULL; |
|
goto cleanup; |
|
} |
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_NAMES, "Returned object %p [%s]\n", |
|
info->return_object, |
|
acpi_ut_get_object_type_name(info-> |
|
return_object))); |
|
|
|
status = AE_CTRL_RETURN_VALUE; /* Always has a "return value" */ |
|
break; |
|
} |
|
|
|
/* |
|
* For predefined names, check the return value against the ACPI |
|
* specification. Some incorrect return value types are repaired. |
|
*/ |
|
(void)acpi_ns_check_return_value(info->node, info, info->param_count, |
|
status, &info->return_object); |
|
|
|
/* Check if there is a return value that must be dealt with */ |
|
|
|
if (status == AE_CTRL_RETURN_VALUE) { |
|
|
|
/* If caller does not want the return value, delete it */ |
|
|
|
if (info->flags & ACPI_IGNORE_RETURN_VALUE) { |
|
acpi_ut_remove_reference(info->return_object); |
|
info->return_object = NULL; |
|
} |
|
|
|
/* Map AE_CTRL_RETURN_VALUE to AE_OK, we are done with it */ |
|
|
|
status = AE_OK; |
|
} else if (ACPI_FAILURE(status)) { |
|
|
|
/* If return_object exists, delete it */ |
|
|
|
if (info->return_object) { |
|
acpi_ut_remove_reference(info->return_object); |
|
info->return_object = NULL; |
|
} |
|
} |
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_NAMES, |
|
"*** Completed evaluation of object %s ***\n", |
|
info->relative_pathname)); |
|
|
|
cleanup: |
|
/* Optional object evaluation log */ |
|
|
|
ACPI_DEBUG_PRINT_RAW((ACPI_DB_EVALUATION, |
|
"%-26s: %s\n", " Exit evaluation", |
|
&info->full_pathname[1])); |
|
|
|
/* |
|
* Namespace was unlocked by the handling acpi_ns* function, so we |
|
* just free the pathname and return |
|
*/ |
|
ACPI_FREE(info->full_pathname); |
|
info->full_pathname = NULL; |
|
return_ACPI_STATUS(status); |
|
}
|
|
|