/******************************************************************************
*
* FUNCTION: acpi_get_handle
*
* PARAMETERS: Parent - Object to search under (search scope).
* Pathname - Pointer to an asciiz string containing the
* name
* ret_handle - Where the return handle is returned
*
* RETURN: Status
*
* DESCRIPTION: This routine will search for a caller specified name in the
* name space. The caller can restrict the search region by
* specifying a non NULL parent. The parent value is itself a
* namespace handle.
*
******************************************************************************/
acpi_status
acpi_get_handle(acpi_handle parent,
acpi_string pathname, acpi_handle * ret_handle)
{
acpi_status status;
struct acpi_namespace_node *node = NULL;
struct acpi_namespace_node *prefix_node = NULL;
ACPI_FUNCTION_ENTRY();
/* Parameter Validation */
if (!ret_handle || !pathname) {
return (AE_BAD_PARAMETER);
}
/* Convert a parent handle to a prefix node */
if (parent) {
prefix_node = acpi_ns_map_handle_to_node(parent);
if (!prefix_node) {
return (AE_BAD_PARAMETER);
}
}
/*
* Valid cases are:
* 1) Fully qualified pathname
* 2) Parent + Relative pathname
*
* Error for <null Parent + relative path>
*/
if (acpi_ns_valid_root_prefix(pathname[0])) {
/* Pathname is fully qualified (starts with '\') */
/* Special case for root-only, since we can't search for it */
if (!ACPI_STRCMP(pathname, ACPI_NS_ROOT_PATH)) {
*ret_handle =
acpi_ns_convert_entry_to_handle(acpi_gbl_root_node);
return (AE_OK);
}
} else if (!prefix_node) {
/* Relative path with null prefix is disallowed */
return (AE_BAD_PARAMETER);
}
/* Find the Node and convert to a handle */
status =
acpi_ns_get_node(prefix_node, pathname, ACPI_NS_NO_UPSEARCH, &node);
if (ACPI_SUCCESS(status)) {
*ret_handle = acpi_ns_convert_entry_to_handle(node);
}
return (status);
}
acpi_status
acpi_get_handle (
acpi_handle parent,
acpi_string pathname,
acpi_handle *ret_handle)
{
acpi_status status;
struct acpi_namespace_node *node = NULL;
struct acpi_namespace_node *prefix_node = NULL;
ACPI_FUNCTION_ENTRY ();
/* Parameter Validation */
if (!ret_handle || !pathname) {
return (AE_BAD_PARAMETER);
}
/* Convert a parent handle to a prefix node */
if (parent) {
status = acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (status)) {
return (status);
}
prefix_node = acpi_ns_map_handle_to_node (parent);
if (!prefix_node) {
(void) acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);
return (AE_BAD_PARAMETER);
}
status = acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (status)) {
return (status);
}
}
/* Special case for root, since we can't search for it */
if (ACPI_STRCMP (pathname, ACPI_NS_ROOT_PATH) == 0) {
*ret_handle = acpi_ns_convert_entry_to_handle (acpi_gbl_root_node);
return (AE_OK);
}
/*
* Find the Node and convert to a handle
*/
status = acpi_ns_get_node_by_path (pathname, prefix_node, ACPI_NS_NO_UPSEARCH,
&node);
*ret_handle = NULL;
if (ACPI_SUCCESS (status)) {
*ret_handle = acpi_ns_convert_entry_to_handle (node);
}
return (status);
}
acpi_status
acpi_get_next_object(acpi_object_type type,
acpi_handle parent,
acpi_handle child, acpi_handle * ret_handle)
{
acpi_status status;
struct acpi_namespace_node *node;
struct acpi_namespace_node *parent_node = NULL;
struct acpi_namespace_node *child_node = NULL;
if (type > ACPI_TYPE_EXTERNAL_MAX) {
return (AE_BAD_PARAMETER);
}
status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE(status)) {
return (status);
}
if (!child) {
parent_node = acpi_ns_map_handle_to_node(parent);
if (!parent_node) {
status = AE_BAD_PARAMETER;
goto unlock_and_exit;
}
} else {
child_node = acpi_ns_map_handle_to_node(child);
if (!child_node) {
status = AE_BAD_PARAMETER;
goto unlock_and_exit;
}
}
node = acpi_ns_get_next_node_typed(type, parent_node, child_node);
if (!node) {
status = AE_NOT_FOUND;
goto unlock_and_exit;
}
if (ret_handle) {
*ret_handle = acpi_ns_convert_entry_to_handle(node);
}
unlock_and_exit:
(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
return (status);
}
/*******************************************************************************
*
* FUNCTION: acpi_get_next_object
*
* PARAMETERS: Type - Type of object to be searched for
* Parent - Parent object whose children we are getting
* last_child - Previous child that was found.
* The NEXT child will be returned
* ret_handle - Where handle to the next object is placed
*
* RETURN: Status
*
* DESCRIPTION: Return the next peer object within the namespace. If Handle is
* valid, Scope is ignored. Otherwise, the first object within
* Scope is returned.
*
******************************************************************************/
acpi_status
acpi_get_next_object(acpi_object_type type,
acpi_handle parent,
acpi_handle child, acpi_handle * ret_handle)
{
acpi_status status;
struct acpi_namespace_node *node;
struct acpi_namespace_node *parent_node = NULL;
struct acpi_namespace_node *child_node = NULL;
/* Parameter validation */
if (type > ACPI_TYPE_EXTERNAL_MAX) {
return (AE_BAD_PARAMETER);
}
status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE(status)) {
return (status);
}
/* If null handle, use the parent */
if (!child) {
/* Start search at the beginning of the specified scope */
parent_node = acpi_ns_map_handle_to_node(parent);
if (!parent_node) {
status = AE_BAD_PARAMETER;
goto unlock_and_exit;
}
} else {
/* Non-null handle, ignore the parent */
/* Convert and validate the handle */
child_node = acpi_ns_map_handle_to_node(child);
if (!child_node) {
status = AE_BAD_PARAMETER;
goto unlock_and_exit;
}
}
/* Internal function does the real work */
node = acpi_ns_get_next_node(type, parent_node, child_node);
if (!node) {
status = AE_NOT_FOUND;
goto unlock_and_exit;
}
if (ret_handle) {
*ret_handle = acpi_ns_convert_entry_to_handle(node);
}
unlock_and_exit:
(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
return (status);
}
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_status
acpi_get_parent (
acpi_handle handle,
acpi_handle *ret_handle)
{
struct acpi_namespace_node *node;
acpi_status status;
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);
}
status = acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (status)) {
return (status);
}
/* Convert and validate the handle */
node = acpi_ns_map_handle_to_node (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_node (node));
/* Return exception if parent is null */
if (!acpi_ns_get_parent_node (node)) {
status = AE_NULL_ENTRY;
}
unlock_and_exit:
(void) acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);
return (status);
}
acpi_status acpi_get_parent(acpi_handle handle, acpi_handle * ret_handle)
{
struct acpi_namespace_node *node;
struct acpi_namespace_node *parent_node;
acpi_status status;
if (!ret_handle) {
return (AE_BAD_PARAMETER);
}
if (handle == ACPI_ROOT_OBJECT) {
return (AE_NULL_ENTRY);
}
status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE(status)) {
return (status);
}
node = acpi_ns_map_handle_to_node(handle);
if (!node) {
status = AE_BAD_PARAMETER;
goto unlock_and_exit;
}
parent_node = acpi_ns_get_parent_node(node);
*ret_handle = acpi_ns_convert_entry_to_handle(parent_node);
if (!parent_node) {
status = AE_NULL_ENTRY;
}
unlock_and_exit:
(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
return (status);
}
ACPI_STATUS
acpi_get_next_object (
ACPI_OBJECT_TYPE type,
ACPI_HANDLE parent,
ACPI_HANDLE child,
ACPI_HANDLE *ret_handle)
{
ACPI_STATUS status = AE_OK;
ACPI_NAMESPACE_NODE *node;
ACPI_NAMESPACE_NODE *parent_node = NULL;
ACPI_NAMESPACE_NODE *child_node = NULL;
/* Parameter validation */
if (type > ACPI_TYPE_MAX) {
return (AE_BAD_PARAMETER);
}
acpi_cm_acquire_mutex (ACPI_MTX_NAMESPACE);
/* If null handle, use the parent */
if (!child) {
/* Start search at the beginning of the specified scope */
parent_node = acpi_ns_convert_handle_to_entry (parent);
if (!parent_node) {
status = AE_BAD_PARAMETER;
goto unlock_and_exit;
}
}
/* Non-null handle, ignore the parent */
else {
/* Convert and validate the handle */
child_node = acpi_ns_convert_handle_to_entry (child);
if (!child_node) {
status = AE_BAD_PARAMETER;
goto unlock_and_exit;
}
}
/* Internal function does the real work */
node = acpi_ns_get_next_object ((OBJECT_TYPE_INTERNAL) type,
parent_node, child_node);
if (!node) {
status = AE_NOT_FOUND;
goto unlock_and_exit;
}
if (ret_handle) {
*ret_handle = acpi_ns_convert_entry_to_handle (node);
}
unlock_and_exit:
acpi_cm_release_mutex (ACPI_MTX_NAMESPACE);
return (status);
}
