acpi_status
acpi_ds_load1_end_op (
acpi_walk_state *walk_state)
{
acpi_parse_object *op;
acpi_object_type8 data_type;
PROC_NAME ("Ds_load1_end_op");
op = walk_state->op;
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));
/* We are only interested in opcodes that have an associated name */
if (!(walk_state->op_info->flags & AML_NAMED)) {
return (AE_OK);
}
/* Get the type to determine if we should pop the scope */
data_type = acpi_ds_map_named_opcode_to_data_type (op->opcode);
if (op->opcode == AML_NAME_OP) {
/* For Name opcode, check the argument */
if (op->value.arg) {
data_type = acpi_ds_map_opcode_to_data_type (
(op->value.arg)->opcode, NULL);
((acpi_namespace_node *)op->node)->type =
(u8) data_type;
}
}
/* Pop the scope stack */
if (acpi_ns_opens_scope (data_type)) {
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s): Popping scope for Op %p\n",
acpi_ut_get_type_name (data_type), op));
acpi_ds_scope_stack_pop (walk_state);
}
return (AE_OK);
}
acpi_status
acpi_ns_lookup(union acpi_generic_state *scope_info,
char *pathname,
acpi_object_type type,
acpi_interpreter_mode interpreter_mode,
u32 flags,
struct acpi_walk_state *walk_state,
struct acpi_namespace_node **return_node)
{
acpi_status status;
char *path = pathname;
struct acpi_namespace_node *prefix_node;
struct acpi_namespace_node *current_node = NULL;
struct acpi_namespace_node *this_node = NULL;
u32 num_segments;
u32 num_carats;
acpi_name simple_name;
acpi_object_type type_to_check_for;
acpi_object_type this_search_type;
u32 search_parent_flag = ACPI_NS_SEARCH_PARENT;
u32 local_flags;
ACPI_FUNCTION_TRACE(ns_lookup);
if (!return_node) {
return_ACPI_STATUS(AE_BAD_PARAMETER);
}
local_flags = flags & ~(ACPI_NS_ERROR_IF_FOUND | ACPI_NS_SEARCH_PARENT);
*return_node = ACPI_ENTRY_NOT_FOUND;
acpi_gbl_ns_lookup_count++;
if (!acpi_gbl_root_node) {
return_ACPI_STATUS(AE_NO_NAMESPACE);
}
/*
* Get the prefix scope.
* A null scope means use the root scope
*/
if ((!scope_info) || (!scope_info->scope.node)) {
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Null scope prefix, using root node (%p)\n",
acpi_gbl_root_node));
prefix_node = acpi_gbl_root_node;
} else {
prefix_node = scope_info->scope.node;
if (ACPI_GET_DESCRIPTOR_TYPE(prefix_node) !=
ACPI_DESC_TYPE_NAMED) {
ACPI_ERROR((AE_INFO, "%p is not a namespace node [%s]",
prefix_node,
acpi_ut_get_descriptor_name(prefix_node)));
return_ACPI_STATUS(AE_AML_INTERNAL);
}
if (!(flags & ACPI_NS_PREFIX_IS_SCOPE)) {
/*
* This node might not be a actual "scope" node (such as a
* Device/Method, etc.) It could be a Package or other object node.
* Backup up the tree to find the containing scope node.
*/
while (!acpi_ns_opens_scope(prefix_node->type) &&
prefix_node->type != ACPI_TYPE_ANY) {
prefix_node =
acpi_ns_get_parent_node(prefix_node);
}
}
}
/* Save type TBD: may be no longer necessary */
type_to_check_for = type;
/*
* Begin examination of the actual pathname
*/
if (!pathname) {
/* A Null name_path is allowed and refers to the root */
num_segments = 0;
this_node = acpi_gbl_root_node;
path = "";
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Null Pathname (Zero segments), Flags=%X\n",
flags));
} else {
/*
* Name pointer is valid (and must be in internal name format)
*
* Check for scope prefixes:
*
* As represented in the AML stream, a namepath consists of an
* optional scope prefix followed by a name segment part.
*
* If present, the scope prefix is either a Root Prefix (in
* which case the name is fully qualified), or one or more
* Parent Prefixes (in which case the name's scope is relative
* to the current scope).
*/
if (*path == (u8) AML_ROOT_PREFIX) {
/* Pathname is fully qualified, start from the root */
this_node = acpi_gbl_root_node;
search_parent_flag = ACPI_NS_NO_UPSEARCH;
/* Point to name segment part */
path++;
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Path is absolute from root [%p]\n",
this_node));
} else {
/* Pathname is relative to current scope, start there */
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Searching relative to prefix scope [%4.4s] (%p)\n",
acpi_ut_get_node_name(prefix_node),
prefix_node));
/*
* Handle multiple Parent Prefixes (carat) by just getting
* the parent node for each prefix instance.
*/
this_node = prefix_node;
num_carats = 0;
while (*path == (u8) AML_PARENT_PREFIX) {
/* Name is fully qualified, no search rules apply */
search_parent_flag = ACPI_NS_NO_UPSEARCH;
/*
* Point past this prefix to the name segment
* part or the next Parent Prefix
*/
path++;
/* Backup to the parent node */
num_carats++;
this_node = acpi_ns_get_parent_node(this_node);
if (!this_node) {
/* Current scope has no parent scope */
ACPI_ERROR((AE_INFO,
"ACPI path has too many parent prefixes (^) - reached beyond root node"));
return_ACPI_STATUS(AE_NOT_FOUND);
}
}
if (search_parent_flag == ACPI_NS_NO_UPSEARCH) {
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Search scope is [%4.4s], path has %d carat(s)\n",
acpi_ut_get_node_name
(this_node), num_carats));
}
}
/*
* Determine the number of ACPI name segments in this pathname.
*
* The segment part consists of either:
* - A Null name segment (0)
* - A dual_name_prefix followed by two 4-byte name segments
* - A multi_name_prefix followed by a byte indicating the
* number of segments and the segments themselves.
* - A single 4-byte name segment
*
* Examine the name prefix opcode, if any, to determine the number of
* segments.
*/
switch (*path) {
case 0:
/*
* Null name after a root or parent prefixes. We already
* have the correct target node and there are no name segments.
*/
num_segments = 0;
type = this_node->type;
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Prefix-only Pathname (Zero name segments), Flags=%X\n",
flags));
break;
case AML_DUAL_NAME_PREFIX:
/* More than one name_seg, search rules do not apply */
search_parent_flag = ACPI_NS_NO_UPSEARCH;
/* Two segments, point to first name segment */
num_segments = 2;
path++;
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Dual Pathname (2 segments, Flags=%X)\n",
flags));
break;
case AML_MULTI_NAME_PREFIX_OP:
/* More than one name_seg, search rules do not apply */
search_parent_flag = ACPI_NS_NO_UPSEARCH;
/* Extract segment count, point to first name segment */
path++;
num_segments = (u32) (u8) * path;
path++;
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Multi Pathname (%d Segments, Flags=%X)\n",
num_segments, flags));
break;
default:
/*
* Not a Null name, no Dual or Multi prefix, hence there is
* only one name segment and Pathname is already pointing to it.
*/
num_segments = 1;
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Simple Pathname (1 segment, Flags=%X)\n",
flags));
break;
}
ACPI_DEBUG_EXEC(acpi_ns_print_pathname(num_segments, path));
}
/*
* Search namespace for each segment of the name. Loop through and
* verify (or add to the namespace) each name segment.
*
* The object type is significant only at the last name
* segment. (We don't care about the types along the path, only
* the type of the final target object.)
*/
this_search_type = ACPI_TYPE_ANY;
current_node = this_node;
while (num_segments && current_node) {
num_segments--;
if (!num_segments) {
/*
* This is the last segment, enable typechecking
*/
this_search_type = type;
/*
* Only allow automatic parent search (search rules) if the caller
* requested it AND we have a single, non-fully-qualified name_seg
*/
if ((search_parent_flag != ACPI_NS_NO_UPSEARCH) &&
(flags & ACPI_NS_SEARCH_PARENT)) {
local_flags |= ACPI_NS_SEARCH_PARENT;
}
/* Set error flag according to caller */
if (flags & ACPI_NS_ERROR_IF_FOUND) {
local_flags |= ACPI_NS_ERROR_IF_FOUND;
}
}
/* Extract one ACPI name from the front of the pathname */
ACPI_MOVE_32_TO_32(&simple_name, path);
/* Try to find the single (4 character) ACPI name */
status =
acpi_ns_search_and_enter(simple_name, walk_state,
current_node, interpreter_mode,
this_search_type, local_flags,
&this_node);
if (ACPI_FAILURE(status)) {
if (status == AE_NOT_FOUND) {
/* Name not found in ACPI namespace */
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Name [%4.4s] not found in scope [%4.4s] %p\n",
(char *)&simple_name,
(char *)¤t_node->name,
current_node));
}
*return_node = this_node;
return_ACPI_STATUS(status);
}
/* More segments to follow? */
if (num_segments > 0) {
/*
* If we have an alias to an object that opens a scope (such as a
* device or processor), we need to dereference the alias here so that
* we can access any children of the original node (via the remaining
* segments).
*/
if (this_node->type == ACPI_TYPE_LOCAL_ALIAS) {
if (!this_node->object) {
return_ACPI_STATUS(AE_NOT_EXIST);
}
if (acpi_ns_opens_scope
(((struct acpi_namespace_node *)this_node->
object)->type)) {
this_node =
(struct acpi_namespace_node *)
this_node->object;
}
}
}
/* Special handling for the last segment (num_segments == 0) */
else {
/*
* Sanity typecheck of the target object:
*
* If 1) This is the last segment (num_segments == 0)
* 2) And we are looking for a specific type
* (Not checking for TYPE_ANY)
* 3) Which is not an alias
* 4) Which is not a local type (TYPE_SCOPE)
* 5) And the type of target object is known (not TYPE_ANY)
* 6) And target object does not match what we are looking for
*
* Then we have a type mismatch. Just warn and ignore it.
*/
if ((type_to_check_for != ACPI_TYPE_ANY) &&
(type_to_check_for != ACPI_TYPE_LOCAL_ALIAS) &&
(type_to_check_for != ACPI_TYPE_LOCAL_METHOD_ALIAS)
&& (type_to_check_for != ACPI_TYPE_LOCAL_SCOPE)
&& (this_node->type != ACPI_TYPE_ANY)
&& (this_node->type != type_to_check_for)) {
/* Complain about a type mismatch */
ACPI_WARNING((AE_INFO,
"NsLookup: Type mismatch on %4.4s (%s), searching for (%s)",
ACPI_CAST_PTR(char, &simple_name),
acpi_ut_get_type_name(this_node->
type),
acpi_ut_get_type_name
(type_to_check_for)));
}
/*
* If this is the last name segment and we are not looking for a
* specific type, but the type of found object is known, use that type
* to (later) see if it opens a scope.
*/
if (type == ACPI_TYPE_ANY) {
type = this_node->type;
}
}
/* Point to next name segment and make this node current */
path += ACPI_NAME_SIZE;
current_node = this_node;
}
acpi_status
acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
union acpi_parse_object ** out_op)
{
union acpi_parse_object *op;
struct acpi_namespace_node *node;
acpi_status status;
acpi_object_type object_type;
char *path;
u32 flags;
ACPI_FUNCTION_TRACE(ds_load1_begin_op);
op = walk_state->op;
ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
walk_state));
/* We are only interested in opcodes that have an associated name */
if (op) {
if (!(walk_state->op_info->flags & AML_NAMED)) {
*out_op = op;
return_ACPI_STATUS(AE_OK);
}
/* Check if this object has already been installed in the namespace */
if (op->common.node) {
*out_op = op;
return_ACPI_STATUS(AE_OK);
}
}
path = acpi_ps_get_next_namestring(&walk_state->parser_state);
/* Map the raw opcode into an internal object type */
object_type = walk_state->op_info->object_type;
ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
"State=%p Op=%p [%s]\n", walk_state, op,
acpi_ut_get_type_name(object_type)));
switch (walk_state->opcode) {
case AML_SCOPE_OP:
/*
* The target name of the Scope() operator must exist at this point so
* that we can actually open the scope to enter new names underneath it.
* Allow search-to-root for single namesegs.
*/
status =
acpi_ns_lookup(walk_state->scope_info, path, object_type,
ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
walk_state, &(node));
#ifdef ACPI_ASL_COMPILER
if (status == AE_NOT_FOUND) {
/*
* Table disassembly:
* Target of Scope() not found. Generate an External for it, and
* insert the name into the namespace.
*/
acpi_dm_add_to_external_list(path, ACPI_TYPE_DEVICE, 0);
status =
acpi_ns_lookup(walk_state->scope_info, path,
object_type, ACPI_IMODE_LOAD_PASS1,
ACPI_NS_SEARCH_PARENT, walk_state,
&node);
}
#endif
if (ACPI_FAILURE(status)) {
ACPI_ERROR_NAMESPACE(path, status);
return_ACPI_STATUS(status);
}
/*
* Check to make sure that the target is
* one of the opcodes that actually opens a scope
*/
switch (node->type) {
case ACPI_TYPE_ANY:
case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_POWER:
case ACPI_TYPE_PROCESSOR:
case ACPI_TYPE_THERMAL:
/* These are acceptable types */
break;
case ACPI_TYPE_INTEGER:
case ACPI_TYPE_STRING:
case ACPI_TYPE_BUFFER:
/*
* These types we will allow, but we will change the type. This
* enables some existing code of the form:
*
* Name (DEB, 0)
* Scope (DEB) { ... }
*
* Note: silently change the type here. On the second pass, we will report
* a warning
*/
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
"Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
path,
acpi_ut_get_type_name(node->type)));
node->type = ACPI_TYPE_ANY;
walk_state->scope_info->common.value = ACPI_TYPE_ANY;
break;
default:
/* All other types are an error */
ACPI_ERROR((AE_INFO,
"Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)",
acpi_ut_get_type_name(node->type), path));
return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
}
break;
default:
/*
* For all other named opcodes, we will enter the name into
* the namespace.
*
* Setup the search flags.
* Since we are entering a name into the namespace, we do not want to
* enable the search-to-root upsearch.
*
* There are only two conditions where it is acceptable that the name
* already exists:
* 1) the Scope() operator can reopen a scoping object that was
* previously defined (Scope, Method, Device, etc.)
* 2) Whenever we are parsing a deferred opcode (op_region, Buffer,
* buffer_field, or Package), the name of the object is already
* in the namespace.
*/
if (walk_state->deferred_node) {
/* This name is already in the namespace, get the node */
node = walk_state->deferred_node;
status = AE_OK;
break;
}
/*
* If we are executing a method, do not create any namespace objects
* during the load phase, only during execution.
*/
if (walk_state->method_node) {
node = NULL;
status = AE_OK;
break;
}
flags = ACPI_NS_NO_UPSEARCH;
if ((walk_state->opcode != AML_SCOPE_OP) &&
(!(walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP))) {
flags |= ACPI_NS_ERROR_IF_FOUND;
ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
"[%s] Cannot already exist\n",
acpi_ut_get_type_name(object_type)));
} else {
ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
"[%s] Both Find or Create allowed\n",
acpi_ut_get_type_name(object_type)));
}
/*
* Enter the named type into the internal namespace. We enter the name
* as we go downward in the parse tree. Any necessary subobjects that
* involve arguments to the opcode must be created as we go back up the
* parse tree later.
*/
status =
acpi_ns_lookup(walk_state->scope_info, path, object_type,
ACPI_IMODE_LOAD_PASS1, flags, walk_state,
&node);
if (ACPI_FAILURE(status)) {
if (status == AE_ALREADY_EXISTS) {
/* The name already exists in this scope */
if (node->flags & ANOBJ_IS_EXTERNAL) {
/*
* Allow one create on an object or segment that was
* previously declared External
*/
node->flags &= ~ANOBJ_IS_EXTERNAL;
node->type = (u8) object_type;
/* Just retyped a node, probably will need to open a scope */
if (acpi_ns_opens_scope(object_type)) {
status =
acpi_ds_scope_stack_push
(node, object_type,
walk_state);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS
(status);
}
}
status = AE_OK;
}
}
if (ACPI_FAILURE(status)) {
ACPI_ERROR_NAMESPACE(path, status);
return_ACPI_STATUS(status);
}
}
break;
}
/* Common exit */
if (!op) {
/* Create a new op */
op = acpi_ps_alloc_op(walk_state->opcode);
if (!op) {
return_ACPI_STATUS(AE_NO_MEMORY);
}
}
/* Initialize the op */
#if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
op->named.path = ACPI_CAST_PTR(u8, path);
#endif
if (node) {
/*
* Put the Node in the "op" object that the parser uses, so we
* can get it again quickly when this scope is closed
*/
op->common.node = node;
op->named.name = node->name.integer;
}
acpi_ps_append_arg(acpi_ps_get_parent_scope(&walk_state->parser_state),
op);
*out_op = op;
return_ACPI_STATUS(status);
}
ACPI_STATUS
acpi_ns_lookup (
ACPI_GENERIC_STATE *scope_info,
NATIVE_CHAR *pathname,
OBJECT_TYPE_INTERNAL type,
OPERATING_MODE interpreter_mode,
u32 flags,
ACPI_WALK_STATE *walk_state,
ACPI_NAMESPACE_NODE **return_node)
{
ACPI_STATUS status;
ACPI_NAMESPACE_NODE *prefix_node;
ACPI_NAMESPACE_NODE *current_node = NULL;
ACPI_NAMESPACE_NODE *scope_to_push = NULL;
ACPI_NAMESPACE_NODE *this_node = NULL;
u32 num_segments;
ACPI_NAME simple_name;
u8 null_name_path = FALSE;
OBJECT_TYPE_INTERNAL type_to_check_for;
OBJECT_TYPE_INTERNAL this_search_type;
DEBUG_ONLY_MEMBERS (u32 i)
if (!return_node) {
return (AE_BAD_PARAMETER);
}
acpi_gbl_ns_lookup_count++;
*return_node = ENTRY_NOT_FOUND;
if (!acpi_gbl_root_node) {
return (AE_NO_NAMESPACE);
}
/*
* Get the prefix scope.
* A null scope means use the root scope
*/
if ((!scope_info) ||
(!scope_info->scope.node))
{
prefix_node = acpi_gbl_root_node;
}
else {
prefix_node = scope_info->scope.node;
}
/*
* This check is explicitly split provide relax the Type_to_check_for
* conditions for Bank_field_defn. Originally, both Bank_field_defn and
* Def_field_defn caused Type_to_check_for to be set to ACPI_TYPE_REGION,
* but the Bank_field_defn may also check for a Field definition as well
* as an Operation_region.
*/
if (INTERNAL_TYPE_DEF_FIELD_DEFN == type) {
/* Def_field_defn defines fields in a Region */
type_to_check_for = ACPI_TYPE_REGION;
}
else if (INTERNAL_TYPE_BANK_FIELD_DEFN == type) {
/* Bank_field_defn defines data fields in a Field Object */
type_to_check_for = ACPI_TYPE_ANY;
}
else {
type_to_check_for = type;
}
/* TBD: [Restructure] - Move the pathname stuff into a new procedure */
/* Examine the name pointer */
if (!pathname) {
/* 8-12-98 ASL Grammar Update supports null Name_path */
null_name_path = TRUE;
num_segments = 0;
this_node = acpi_gbl_root_node;
}
else {
/*
* Valid name pointer (Internal name format)
*
* Check for prefixes. As represented in the AML stream, a
* Pathname consists of an optional scope prefix followed by
* a segment part.
*
* If present, the scope prefix is either a Root_prefix (in
* which case the name is fully qualified), or zero or more
* Parent_prefixes (in which case the name's scope is relative
* to the current scope).
*
* The segment part consists of either:
* - A single 4-byte name segment, or
* - A Dual_name_prefix followed by two 4-byte name segments, or
* - A Multi_name_prefix_op, followed by a byte indicating the
* number of segments and the segments themselves.
*/
if (*pathname == AML_ROOT_PREFIX) {
/* Pathname is fully qualified, look in root name table */
current_node = acpi_gbl_root_node;
/* point to segment part */
pathname++;
/* Direct reference to root, "\" */
if (!(*pathname)) {
this_node = acpi_gbl_root_node;
goto check_for_new_scope_and_exit;
}
}
else {
/* Pathname is relative to current scope, start there */
current_node = prefix_node;
/*
* Handle up-prefix (carat). More than one prefix
* is supported
*/
while (*pathname == AML_PARENT_PREFIX) {
/* Point to segment part or next Parent_prefix */
pathname++;
/* Backup to the parent's scope */
this_node = acpi_ns_get_parent_object (current_node);
if (!this_node) {
/* Current scope has no parent scope */
REPORT_ERROR (("Too many parent prefixes (^) - reached root\n"));
return (AE_NOT_FOUND);
}
current_node = this_node;
}
}
/*
* Examine the name prefix opcode, if any,
* to determine the number of segments
*/
if (*pathname == AML_DUAL_NAME_PREFIX) {
num_segments = 2;
/* point to first segment */
pathname++;
}
else if (*pathname == AML_MULTI_NAME_PREFIX_OP) {
num_segments = (u32)* (u8 *) ++pathname;
/* point to first segment */
pathname++;
}
else {
/*
* No Dual or Multi prefix, hence there is only one
* segment and Pathname is already pointing to it.
*/
num_segments = 1;
}
}
/*
* Search namespace for each segment of the name.
* Loop through and verify/add each name segment.
*/
while (num_segments-- && current_node) {
/*
* Search for the current name segment under the current
* named object. The Type is significant only at the last (topmost)
* level. (We don't care about the types along the path, only
* the type of the final target object.)
*/
this_search_type = ACPI_TYPE_ANY;
if (!num_segments) {
this_search_type = type;
}
/* Pluck one ACPI name from the front of the pathname */
MOVE_UNALIGNED32_TO_32 (&simple_name, pathname);
/* Try to find the ACPI name */
status = acpi_ns_search_and_enter (simple_name, walk_state,
current_node, interpreter_mode,
this_search_type, flags,
&this_node);
if (ACPI_FAILURE (status)) {
if (status == AE_NOT_FOUND) {
/* Name not found in ACPI namespace */
}
return (status);
}
/*
* If 1) This is the last segment (Num_segments == 0)
* 2) and looking for a specific type
* (Not checking for TYPE_ANY)
* 3) Which is not an alias
* 4) which is not a local type (TYPE_DEF_ANY)
* 5) which is not a local type (TYPE_SCOPE)
* 6) which is not a local type (TYPE_INDEX_FIELD_DEFN)
* 7) and type of object is known (not TYPE_ANY)
* 8) and object does not match request
*
* Then we have a type mismatch. Just warn and ignore it.
*/
if ((num_segments == 0) &&
(type_to_check_for != ACPI_TYPE_ANY) &&
(type_to_check_for != INTERNAL_TYPE_ALIAS) &&
(type_to_check_for != INTERNAL_TYPE_DEF_ANY) &&
(type_to_check_for != INTERNAL_TYPE_SCOPE) &&
(type_to_check_for != INTERNAL_TYPE_INDEX_FIELD_DEFN) &&
(this_node->type != ACPI_TYPE_ANY) &&
(this_node->type != type_to_check_for))
{
/* Complain about a type mismatch */
REPORT_WARNING (
("Ns_lookup: %4.4s, type %X, checking for type %X\n",
&simple_name, this_node->type, type_to_check_for));
}
/*
* If this is the last name segment and we are not looking for a
* specific type, but the type of found object is known, use that type
* to see if it opens a scope.
*/
if ((0 == num_segments) && (ACPI_TYPE_ANY == type)) {
type = this_node->type;
}
if ((num_segments || acpi_ns_opens_scope (type)) &&
(this_node->child == NULL))
{
/*
* More segments or the type implies enclosed scope,
* and the next scope has not been allocated.
*/
}
current_node = this_node;
/* point to next name segment */
pathname += ACPI_NAME_SIZE;
}
/*
* Always check if we need to open a new scope
*/
check_for_new_scope_and_exit:
if (!(flags & NS_DONT_OPEN_SCOPE) && (walk_state)) {
/*
* If entry is a type which opens a scope,
* push the new scope on the scope stack.
*/
if (acpi_ns_opens_scope (type_to_check_for)) {
/* 8-12-98 ASL Grammar Update supports null Name_path */
if (null_name_path) {
/* TBD: [Investigate] - is this the correct thing to do? */
scope_to_push = NULL;
}
else {
scope_to_push = this_node;
}
status = acpi_ds_scope_stack_push (scope_to_push, type,
walk_state);
if (ACPI_FAILURE (status)) {
return (status);
}
}
}
*return_node = this_node;
return (AE_OK);
}
acpi_status
acpi_ns_lookup(union acpi_generic_state *scope_info,
char *pathname,
acpi_object_type type,
acpi_interpreter_mode interpreter_mode,
u32 flags,
struct acpi_walk_state *walk_state,
struct acpi_namespace_node **return_node)
{
acpi_status status;
char *path = pathname;
struct acpi_namespace_node *prefix_node;
struct acpi_namespace_node *current_node = NULL;
struct acpi_namespace_node *this_node = NULL;
u32 num_segments;
u32 num_carats;
acpi_name simple_name;
acpi_object_type type_to_check_for;
acpi_object_type this_search_type;
u32 search_parent_flag = ACPI_NS_SEARCH_PARENT;
u32 local_flags;
ACPI_FUNCTION_TRACE(ns_lookup);
if (!return_node) {
return_ACPI_STATUS(AE_BAD_PARAMETER);
}
local_flags = flags & ~(ACPI_NS_ERROR_IF_FOUND | ACPI_NS_SEARCH_PARENT);
*return_node = ACPI_ENTRY_NOT_FOUND;
acpi_gbl_ns_lookup_count++;
if (!acpi_gbl_root_node) {
return_ACPI_STATUS(AE_NO_NAMESPACE);
}
if ((!scope_info) || (!scope_info->scope.node)) {
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Null scope prefix, using root node (%p)\n",
acpi_gbl_root_node));
prefix_node = acpi_gbl_root_node;
} else {
prefix_node = scope_info->scope.node;
if (ACPI_GET_DESCRIPTOR_TYPE(prefix_node) !=
ACPI_DESC_TYPE_NAMED) {
ACPI_ERROR((AE_INFO, "%p is not a namespace node [%s]",
prefix_node,
acpi_ut_get_descriptor_name(prefix_node)));
return_ACPI_STATUS(AE_AML_INTERNAL);
}
if (!(flags & ACPI_NS_PREFIX_IS_SCOPE)) {
while (!acpi_ns_opens_scope(prefix_node->type) &&
prefix_node->type != ACPI_TYPE_ANY) {
prefix_node = prefix_node->parent;
}
}
}
type_to_check_for = type;
if (!pathname) {
num_segments = 0;
this_node = acpi_gbl_root_node;
path = "";
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Null Pathname (Zero segments), Flags=%X\n",
flags));
} else {
if (*path == (u8) AML_ROOT_PREFIX) {
this_node = acpi_gbl_root_node;
search_parent_flag = ACPI_NS_NO_UPSEARCH;
path++;
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Path is absolute from root [%p]\n",
this_node));
} else {
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Searching relative to prefix scope [%4.4s] (%p)\n",
acpi_ut_get_node_name(prefix_node),
prefix_node));
this_node = prefix_node;
num_carats = 0;
while (*path == (u8) AML_PARENT_PREFIX) {
search_parent_flag = ACPI_NS_NO_UPSEARCH;
path++;
num_carats++;
this_node = this_node->parent;
if (!this_node) {
ACPI_ERROR((AE_INFO,
"ACPI path has too many parent prefixes (^) "
"- reached beyond root node"));
return_ACPI_STATUS(AE_NOT_FOUND);
}
}
if (search_parent_flag == ACPI_NS_NO_UPSEARCH) {
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Search scope is [%4.4s], path has %u carat(s)\n",
acpi_ut_get_node_name
(this_node), num_carats));
}
}
switch (*path) {
case 0:
num_segments = 0;
type = this_node->type;
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Prefix-only Pathname (Zero name segments), Flags=%X\n",
flags));
break;
case AML_DUAL_NAME_PREFIX:
search_parent_flag = ACPI_NS_NO_UPSEARCH;
num_segments = 2;
path++;
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Dual Pathname (2 segments, Flags=%X)\n",
flags));
break;
case AML_MULTI_NAME_PREFIX_OP:
search_parent_flag = ACPI_NS_NO_UPSEARCH;
path++;
num_segments = (u32) (u8) * path;
path++;
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Multi Pathname (%u Segments, Flags=%X)\n",
num_segments, flags));
break;
default:
num_segments = 1;
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Simple Pathname (1 segment, Flags=%X)\n",
flags));
break;
}
ACPI_DEBUG_EXEC(acpi_ns_print_pathname(num_segments, path));
}
this_search_type = ACPI_TYPE_ANY;
current_node = this_node;
while (num_segments && current_node) {
num_segments--;
if (!num_segments) {
this_search_type = type;
if ((search_parent_flag != ACPI_NS_NO_UPSEARCH) &&
(flags & ACPI_NS_SEARCH_PARENT)) {
local_flags |= ACPI_NS_SEARCH_PARENT;
}
if (flags & ACPI_NS_ERROR_IF_FOUND) {
local_flags |= ACPI_NS_ERROR_IF_FOUND;
}
}
ACPI_MOVE_32_TO_32(&simple_name, path);
status =
acpi_ns_search_and_enter(simple_name, walk_state,
current_node, interpreter_mode,
this_search_type, local_flags,
&this_node);
if (ACPI_FAILURE(status)) {
if (status == AE_NOT_FOUND) {
ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
"Name [%4.4s] not found in scope [%4.4s] %p\n",
(char *)&simple_name,
(char *)¤t_node->name,
current_node));
}
*return_node = this_node;
return_ACPI_STATUS(status);
}
if (num_segments > 0) {
if (this_node->type == ACPI_TYPE_LOCAL_ALIAS) {
if (!this_node->object) {
return_ACPI_STATUS(AE_NOT_EXIST);
}
if (acpi_ns_opens_scope
(((struct acpi_namespace_node *)
this_node->object)->type)) {
this_node =
(struct acpi_namespace_node *)
this_node->object;
}
}
}
else {
if ((type_to_check_for != ACPI_TYPE_ANY) &&
(type_to_check_for != ACPI_TYPE_LOCAL_ALIAS) &&
(type_to_check_for != ACPI_TYPE_LOCAL_METHOD_ALIAS)
&& (type_to_check_for != ACPI_TYPE_LOCAL_SCOPE)
&& (this_node->type != ACPI_TYPE_ANY)
&& (this_node->type != type_to_check_for)) {
ACPI_WARNING((AE_INFO,
"NsLookup: Type mismatch on %4.4s (%s), searching for (%s)",
ACPI_CAST_PTR(char, &simple_name),
acpi_ut_get_type_name(this_node->
type),
acpi_ut_get_type_name
(type_to_check_for)));
}
if (type == ACPI_TYPE_ANY) {
type = this_node->type;
}
}
path += ACPI_NAME_SIZE;
current_node = this_node;
}
acpi_status
acpi_ds_load2_end_op (
acpi_walk_state *walk_state)
{
acpi_parse_object *op;
acpi_status status = AE_OK;
acpi_object_type8 data_type;
acpi_namespace_node *node;
acpi_parse_object *arg;
acpi_namespace_node *new_node;
u32 i;
PROC_NAME ("Ds_load2_end_op");
op = walk_state->op;
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));
/* Only interested in opcodes that have namespace objects */
if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
return (AE_OK);
}
if (op->opcode == AML_SCOPE_OP) {
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"Ending scope Op=%p State=%p\n", op, walk_state));
if (((acpi_parse2_object *)op)->name == -1) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unnamed scope! Op=%p State=%p\n",
op, walk_state));
return (AE_OK);
}
}
data_type = acpi_ds_map_named_opcode_to_data_type (op->opcode);
/*
* Get the Node/name from the earlier lookup
* (It was saved in the *op structure)
*/
node = op->node;
/*
* Put the Node on the object stack (Contains the ACPI Name of
* this object)
*/
walk_state->operands[0] = (void *) node;
walk_state->num_operands = 1;
/* Pop the scope stack */
if (acpi_ns_opens_scope (data_type)) {
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s) Popping scope for Op %p\n",
acpi_ut_get_type_name (data_type), op));
acpi_ds_scope_stack_pop (walk_state);
}
/*
* Named operations are as follows:
*
* AML_ALIAS
* AML_BANKFIELD
* AML_CREATEBITFIELD
* AML_CREATEBYTEFIELD
* AML_CREATEDWORDFIELD
* AML_CREATEFIELD
* AML_CREATEQWORDFIELD
* AML_CREATEWORDFIELD
* AML_DATA_REGION
* AML_DEVICE
* AML_EVENT
* AML_FIELD
* AML_INDEXFIELD
* AML_METHOD
* AML_METHODCALL
* AML_MUTEX
* AML_NAME
* AML_NAMEDFIELD
* AML_OPREGION
* AML_POWERRES
* AML_PROCESSOR
* AML_SCOPE
* AML_THERMALZONE
*/
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"Create-Load [%s] State=%p Op=%p Named_obj=%p\n",
acpi_ps_get_opcode_name (op->opcode), walk_state, op, node));
/* Decode the opcode */
arg = op->value.arg;
switch (walk_state->op_info->type) {
case AML_TYPE_CREATE_FIELD:
/*
* Create the field object, but the field buffer and index must
* be evaluated later during the execution phase
*/
status = acpi_ds_create_buffer_field (op, walk_state);
break;
case AML_TYPE_NAMED_FIELD:
arg = op->value.arg;
switch (op->opcode) {
case AML_INDEX_FIELD_OP:
status = acpi_ds_create_index_field (op, (acpi_handle) arg->node,
walk_state);
break;
case AML_BANK_FIELD_OP:
status = acpi_ds_create_bank_field (op, arg->node, walk_state);
break;
case AML_FIELD_OP:
status = acpi_ds_create_field (op, arg->node, walk_state);
break;
}
break;
case AML_TYPE_NAMED_SIMPLE:
status = acpi_ds_create_operands (walk_state, arg);
if (ACPI_FAILURE (status)) {
goto cleanup;
}
switch (op->opcode) {
case AML_PROCESSOR_OP:
status = acpi_ex_create_processor (walk_state);
break;
case AML_POWER_RES_OP:
status = acpi_ex_create_power_resource (walk_state);
break;
case AML_MUTEX_OP:
status = acpi_ex_create_mutex (walk_state);
break;
case AML_EVENT_OP:
status = acpi_ex_create_event (walk_state);
break;
case AML_DATA_REGION_OP:
status = acpi_ex_create_table_region (walk_state);
break;
case AML_ALIAS_OP:
status = acpi_ex_create_alias (walk_state);
break;
default:
/* Unknown opcode */
status = AE_OK;
goto cleanup;
break;
}
/* Delete operands */
for (i = 1; i < walk_state->num_operands; i++) {
acpi_ut_remove_reference (walk_state->operands[i]);
walk_state->operands[i] = NULL;
}
break;
case AML_TYPE_NAMED_COMPLEX:
switch (op->opcode) {
case AML_METHOD_OP:
/*
* Method_op Pkg_length Names_string Method_flags Term_list
*/
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"LOADING-Method: State=%p Op=%p Named_obj=%p\n",
walk_state, op, node));
if (!node->object) {
status = acpi_ds_create_operands (walk_state, arg);
if (ACPI_FAILURE (status)) {
goto cleanup;
}
status = acpi_ex_create_method (((acpi_parse2_object *) op)->data,
((acpi_parse2_object *) op)->length,
walk_state);
}
break;
case AML_REGION_OP:
/*
* The Op_region is not fully parsed at this time. Only valid argument is the Space_id.
* (We must save the address of the AML of the address and length operands)
*/
status = acpi_ex_create_region (((acpi_parse2_object *) op)->data,
((acpi_parse2_object *) op)->length,
(ACPI_ADR_SPACE_TYPE) arg->value.integer, walk_state);
break;
case AML_NAME_OP:
status = acpi_ds_create_node (walk_state, node, op);
break;
}
break;
case AML_CLASS_INTERNAL:
/* case AML_INT_NAMEPATH_OP: */
break;
case AML_CLASS_METHOD_CALL:
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"RESOLVING-Method_call: State=%p Op=%p Named_obj=%p\n",
walk_state, op, node));
/*
* Lookup the method name and save the Node
*/
status = acpi_ns_lookup (walk_state->scope_info, arg->value.string,
ACPI_TYPE_ANY, IMODE_LOAD_PASS2,
NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE,
walk_state, &(new_node));
if (ACPI_SUCCESS (status)) {
/* TBD: has name already been resolved by here ??*/
/* TBD: [Restructure] Make sure that what we found is indeed a method! */
/* We didn't search for a method on purpose, to see if the name would resolve! */
/* We could put the returned object (Node) on the object stack for later, but
* for now, we will put it in the "op" object that the parser uses, so we
* can get it again at the end of this scope
*/
op->node = new_node;
}
break;
default:
break;
}
cleanup:
/* Remove the Node pushed at the very beginning */
walk_state->operands[0] = NULL;
walk_state->num_operands = 0;
return (status);
}
acpi_status
acpi_ds_load2_begin_op (
acpi_walk_state *walk_state,
acpi_parse_object **out_op)
{
acpi_parse_object *op;
acpi_namespace_node *node;
acpi_status status;
acpi_object_type8 data_type;
NATIVE_CHAR *buffer_ptr;
void *original = NULL;
PROC_NAME ("Ds_load2_begin_op");
op = walk_state->op;
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op, walk_state));
if (op) {
/* We only care about Namespace opcodes here */
if (!(walk_state->op_info->flags & AML_NSOPCODE) &&
walk_state->opcode != AML_INT_NAMEPATH_OP) {
return (AE_OK);
}
/* TBD: [Restructure] Temp! same code as in psparse */
if (!(walk_state->op_info->flags & AML_NAMED)) {
return (AE_OK);
}
/*
* Get the name we are going to enter or lookup in the namespace
*/
if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
/* For Namepath op, get the path string */
buffer_ptr = op->value.string;
if (!buffer_ptr) {
/* No name, just exit */
return (AE_OK);
}
}
else {
/* Get name from the op */
buffer_ptr = (NATIVE_CHAR *) &((acpi_parse2_object *)op)->name;
}
}
else {
buffer_ptr = acpi_ps_get_next_namestring (&walk_state->parser_state);
}
/* Map the raw opcode into an internal object type */
data_type = acpi_ds_map_named_opcode_to_data_type (walk_state->opcode);
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"State=%p Op=%p Type=%x\n", walk_state, op, data_type));
if (walk_state->opcode == AML_FIELD_OP ||
walk_state->opcode == AML_BANK_FIELD_OP ||
walk_state->opcode == AML_INDEX_FIELD_OP) {
node = NULL;
status = AE_OK;
}
else if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
/*
* The Name_path is an object reference to an existing object. Don't enter the
* name into the namespace, but look it up for use later
*/
status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, data_type,
IMODE_EXECUTE, NS_SEARCH_PARENT, walk_state, &(node));
}
else {
if (op && op->node) {
original = op->node;
node = op->node;
if (acpi_ns_opens_scope (data_type)) {
status = acpi_ds_scope_stack_push (node, data_type, walk_state);
if (ACPI_FAILURE (status)) {
return (status);
}
}
return (AE_OK);
}
/*
* Enter the named type into the internal namespace. We enter the name
* as we go downward in the parse tree. Any necessary subobjects that involve
* arguments to the opcode must be created as we go back up the parse tree later.
*/
status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr, data_type,
IMODE_EXECUTE, NS_NO_UPSEARCH, walk_state, &(node));
}
if (ACPI_SUCCESS (status)) {
if (!op) {
/* Create a new op */
op = acpi_ps_alloc_op (walk_state->opcode);
if (!op) {
return (AE_NO_MEMORY);
}
/* Initialize */
((acpi_parse2_object *)op)->name = node->name;
*out_op = op;
}
/*
* Put the Node in the "op" object that the parser uses, so we
* can get it again quickly when this scope is closed
*/
op->node = node;
if (original) {
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "old %p new %p\n", original, node));
if (original != node) {
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Lookup match error: old %p new %p\n", original, node));
}
}
}
return (status);
}
