u32
acpi_ns_get_pathname_length (
acpi_namespace_node *node)
{
u32 size;
acpi_namespace_node *next_node;
FUNCTION_ENTRY ();
/*
* Compute length of pathname as 5 * number of name segments.
* Go back up the parent tree to the root
*/
for (size = 0, next_node = node;
acpi_ns_get_parent_object (next_node);
next_node = acpi_ns_get_parent_object (next_node)) {
size += PATH_SEGMENT_LENGTH;
}
/* Special case for size still 0 - no parent for "special" nodes */
if (!size) {
size = PATH_SEGMENT_LENGTH;
}
return (size + 1);
}
static ACPI_STATUS
acpi_ns_search_parent_tree (
u32 target_name,
ACPI_NAMESPACE_NODE *node,
OBJECT_TYPE_INTERNAL type,
ACPI_NAMESPACE_NODE **return_node)
{
ACPI_STATUS status;
ACPI_NAMESPACE_NODE *parent_node;
parent_node = acpi_ns_get_parent_object (node);
/*
* If there is no parent (at the root) or type is "local", we won't be
* searching the parent tree.
*/
if ((acpi_ns_local (type)) ||
(!parent_node))
{
return (AE_NOT_FOUND);
}
/* Search the parent tree */
/*
* Search parents until found the target or we have backed up to
* the root
*/
while (parent_node) {
/* Search parent scope */
/* TBD: [Investigate] Why ACPI_TYPE_ANY? */
status = acpi_ns_search_node (target_name, parent_node,
ACPI_TYPE_ANY, return_node);
if (ACPI_SUCCESS (status)) {
return (status);
}
/*
* Not found here, go up another level
* (until we reach the root)
*/
parent_node = acpi_ns_get_parent_object (parent_node);
}
/* Not found in parent tree */
return (AE_NOT_FOUND);
}
ACPI_STATUS
acpi_get_parent (
ACPI_HANDLE handle,
ACPI_HANDLE *ret_handle)
{
ACPI_NAMESPACE_NODE *node;
ACPI_STATUS status = AE_OK;
/* No trace macro, too verbose */
if (!ret_handle) {
return (AE_BAD_PARAMETER);
}
/* Special case for the predefined Root Node (no parent) */
if (handle == ACPI_ROOT_OBJECT) {
return (AE_NULL_ENTRY);
}
acpi_cm_acquire_mutex (ACPI_MTX_NAMESPACE);
/* Convert and validate the handle */
node = acpi_ns_convert_handle_to_entry (handle);
if (!node) {
status = AE_BAD_PARAMETER;
goto unlock_and_exit;
}
/* Get the parent entry */
*ret_handle =
acpi_ns_convert_entry_to_handle (acpi_ns_get_parent_object (node));
/* Return exeption if parent is null */
if (!acpi_ns_get_parent_object (node)) {
status = AE_NULL_ENTRY;
}
unlock_and_exit:
acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
return (status);
}
acpi_name
acpi_ns_find_parent_name (
acpi_namespace_node *child_node)
{
acpi_namespace_node *parent_node;
FUNCTION_TRACE ("Ns_find_parent_name");
if (child_node) {
/* Valid entry. Get the parent Node */
parent_node = acpi_ns_get_parent_object (child_node);
if (parent_node) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Parent of %p [%4.4s] is %p [%4.4s]\n",
child_node, (char*)&child_node->name, parent_node, (char*)&parent_node->name));
if (parent_node->name) {
return_VALUE (parent_node->name);
}
}
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "unable to find parent of %p (%4.4s)\n",
child_node, (char*)&child_node->name));
}
return_VALUE (ACPI_UNKNOWN_NAME);
}
NATIVE_CHAR *
acpi_ns_get_table_pathname (
acpi_namespace_node *node)
{
NATIVE_CHAR *name_buffer;
u32 size;
acpi_name name;
acpi_namespace_node *child_node;
acpi_namespace_node *parent_node;
FUNCTION_TRACE_PTR ("Ns_get_table_pathname", node);
if (!acpi_gbl_root_node || !node) {
/*
* If the name space has not been initialized,
* this function should not have been called.
*/
return_PTR (NULL);
}
child_node = node->child;
/* Calculate required buffer size based on depth below root */
size = 1;
parent_node = child_node;
while (parent_node) {
parent_node = acpi_ns_get_parent_object (parent_node);
if (parent_node) {
size += ACPI_NAME_SIZE;
}
}
/* Allocate a buffer to be returned to caller */
name_buffer = ACPI_MEM_CALLOCATE (size + 1);
if (!name_buffer) {
REPORT_ERROR (("Ns_get_table_pathname: allocation failure\n"));
return_PTR (NULL);
}
/* Store terminator byte, then build name backwards */
name_buffer[size] = '\0';
while ((size > ACPI_NAME_SIZE) &&
acpi_ns_get_parent_object (child_node)) {
size -= ACPI_NAME_SIZE;
name = acpi_ns_find_parent_name (child_node);
/* Put the name into the buffer */
MOVE_UNALIGNED32_TO_32 ((name_buffer + size), &name);
child_node = acpi_ns_get_parent_object (child_node);
}
name_buffer[--size] = AML_ROOT_PREFIX;
if (size != 0) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Bad pointer returned; size=%X\n", size));
}
return_PTR (name_buffer);
}
acpi_status
acpi_ns_handle_to_pathname (
acpi_handle target_handle,
u32 *buf_size,
NATIVE_CHAR *user_buffer)
{
acpi_status status = AE_OK;
acpi_namespace_node *node;
u32 path_length;
u32 user_buf_size;
acpi_name name;
u32 size;
FUNCTION_TRACE_PTR ("Ns_handle_to_pathname", target_handle);
if (!acpi_gbl_root_node) {
/*
* If the name space has not been initialized,
* this function should not have been called.
*/
return_ACPI_STATUS (AE_NO_NAMESPACE);
}
node = acpi_ns_map_handle_to_node (target_handle);
if (!node) {
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
/* Set return length to the required path length */
path_length = acpi_ns_get_pathname_length (node);
size = path_length - 1;
user_buf_size = *buf_size;
*buf_size = path_length;
/* Check if the user buffer is sufficiently large */
if (path_length > user_buf_size) {
status = AE_BUFFER_OVERFLOW;
goto exit;
}
/* Store null terminator */
user_buffer[size] = 0;
size -= ACPI_NAME_SIZE;
/* Put the original ACPI name at the end of the path */
MOVE_UNALIGNED32_TO_32 ((user_buffer + size),
&node->name);
user_buffer[--size] = PATH_SEPARATOR;
/* Build name backwards, putting "." between segments */
while ((size > ACPI_NAME_SIZE) && node) {
size -= ACPI_NAME_SIZE;
name = acpi_ns_find_parent_name (node);
MOVE_UNALIGNED32_TO_32 ((user_buffer + size), &name);
user_buffer[--size] = PATH_SEPARATOR;
node = acpi_ns_get_parent_object (node);
}
/*
* Overlay the "." preceding the first segment with
* the root name "\"
*/
user_buffer[size] = '\\';
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Len=%X, %s \n", path_length, user_buffer));
exit:
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_ev_initialize_region (
ACPI_OPERAND_OBJECT *region_obj,
u8 acpi_ns_locked)
{
ACPI_OPERAND_OBJECT *handler_obj;
ACPI_OPERAND_OBJECT *obj_desc;
ACPI_ADDRESS_SPACE_TYPE space_id;
ACPI_NAMESPACE_NODE *node;
ACPI_STATUS status;
ACPI_NAMESPACE_NODE *method_node;
ACPI_NAME *reg_name_ptr = (ACPI_NAME *) METHOD_NAME__REG;
if (!region_obj) {
return (AE_BAD_PARAMETER);
}
ACPI_ASSERT(region_obj->region.node);
node = acpi_ns_get_parent_object (region_obj->region.node);
space_id = region_obj->region.space_id;
region_obj->region.addr_handler = NULL;
region_obj->region.extra->extra.method_REG = NULL;
region_obj->region.flags &= ~(AOPOBJ_INITIALIZED);
/*
* Find any "_REG" associated with this region definition
*/
status = acpi_ns_search_node (*reg_name_ptr, node,
ACPI_TYPE_METHOD, &method_node);
if (ACPI_SUCCESS (status)) {
/*
* The _REG method is optional and there can be only one per region
* definition. This will be executed when the handler is attached
* or removed
*/
region_obj->region.extra->extra.method_REG = method_node;
}
/*
* The following loop depends upon the root Node having no parent
* ie: Acpi_gbl_Root_node->Parent_entry being set to NULL
*/
while (node) {
/*
* Check to see if a handler exists
*/
handler_obj = NULL;
obj_desc = acpi_ns_get_attached_object ((ACPI_HANDLE) node);
if (obj_desc) {
/*
* can only be a handler if the object exists
*/
switch (node->type)
{
case ACPI_TYPE_DEVICE:
handler_obj = obj_desc->device.addr_handler;
break;
case ACPI_TYPE_PROCESSOR:
handler_obj = obj_desc->processor.addr_handler;
break;
case ACPI_TYPE_THERMAL:
handler_obj = obj_desc->thermal_zone.addr_handler;
break;
}
while (handler_obj) {
/*
* This guy has at least one address handler
* see if it has the type we want
*/
if (handler_obj->addr_handler.space_id == space_id) {
/*
* Found it! Now update the region and the handler
*/
acpi_ev_associate_region_and_handler (handler_obj, region_obj, acpi_ns_locked);
return (AE_OK);
}
handler_obj = handler_obj->addr_handler.next;
} /* while handlerobj */
}
/*
* This one does not have the handler we need
* Pop up one level
*/
node = acpi_ns_get_parent_object (node);
} /* while Node != ROOT */
/*
* If we get here, there is no handler for this region
*/
return (AE_NOT_EXIST);
}
ACPI_STATUS
acpi_ev_pci_config_region_setup (
ACPI_HANDLE handle,
u32 function,
void *handler_context,
void **region_context)
{
ACPI_STATUS status = AE_OK;
ACPI_INTEGER temp;
PCI_HANDLER_CONTEXT *pci_context = *region_context;
ACPI_OPERAND_OBJECT *handler_obj;
ACPI_NAMESPACE_NODE *node;
ACPI_OPERAND_OBJECT *region_obj = (ACPI_OPERAND_OBJECT *) handle;
DEVICE_ID object_hID;
handler_obj = region_obj->region.addr_handler;
if (!handler_obj) {
/*
* No installed handler. This shouldn't happen because the dispatch
* routine checks before we get here, but we check again just in case.
*/
return(AE_NOT_EXIST);
}
if (function == ACPI_REGION_DEACTIVATE) {
if (pci_context) {
acpi_cm_free (pci_context);
*region_context = NULL;
}
return (status);
}
/* Create a new context */
pci_context = acpi_cm_callocate (sizeof(PCI_HANDLER_CONTEXT));
if (!pci_context) {
return (AE_NO_MEMORY);
}
/*
* For PCI Config space access, we have to pass the segment, bus,
* device and function numbers. This routine must acquire those.
*/
/*
* First get device and function numbers from the _ADR object
* in the parent's scope.
*/
ACPI_ASSERT(region_obj->region.node);
node = acpi_ns_get_parent_object (region_obj->region.node);
/* Acpi_evaluate the _ADR object */
status = acpi_cm_evaluate_numeric_object (METHOD_NAME__ADR, node, &temp);
/*
* The default is zero, since the allocation above zeroed the data, just
* do nothing on failures.
*/
if (ACPI_SUCCESS (status)) {
/*
* Got it..
*/
pci_context->dev_func = (u32) temp;
}
/*
* Get the _SEG and _BBN values from the device upon which the handler
* is installed.
*
* We need to get the _SEG and _BBN objects relative to the PCI BUS device.
* This is the device the handler has been registered to handle.
*/
/*
* If the Addr_handler.Node is still pointing to the root, we need
* to scan upward for a PCI Root bridge and re-associate the Op_region
* handlers with that device.
*/
if (handler_obj->addr_handler.node == acpi_gbl_root_node) {
/*
* Node is currently the parent object
*/
while (node != acpi_gbl_root_node) {
status = acpi_cm_execute_HID(node, &object_hID);
if (ACPI_SUCCESS (status)) {
if (!(STRNCMP(object_hID.buffer, PCI_ROOT_HID_STRING,
sizeof (PCI_ROOT_HID_STRING))))
{
acpi_install_address_space_handler(node,
ADDRESS_SPACE_PCI_CONFIG,
ACPI_DEFAULT_HANDLER, NULL, NULL);
break;
}
}
node = acpi_ns_get_parent_object(node);
}
}
else {
node = handler_obj->addr_handler.node;
}
status = acpi_cm_evaluate_numeric_object (METHOD_NAME__SEG, node, &temp);
if (ACPI_SUCCESS (status)) {
/*
* Got it..
*/
pci_context->seg = (u32) temp;
}
status = acpi_cm_evaluate_numeric_object (METHOD_NAME__BBN, node, &temp);
if (ACPI_SUCCESS (status)) {
/*
* Got it..
*/
pci_context->bus = (u32) temp;
}
*region_context = pci_context;
return (AE_OK);
}
