[deliverable/linux.git] / drivers / acpi / acpica / nsxfobj.c

/*******************************************************************************
 *
 * Module Name: nsxfobj - Public interfaces to the ACPI subsystem
 *                         ACPI Object oriented interfaces
 *
 ******************************************************************************/

/*
 * Copyright (C) 2000 - 2012, 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 <linux/export.h>
#include <acpi/acpi.h>
#include "accommon.h"
#include "acnamesp.h"

#define _COMPONENT          ACPI_NAMESPACE
ACPI_MODULE_NAME("nsxfobj")

/*******************************************************************************
 *
 * FUNCTION:    acpi_get_id
 *
 * PARAMETERS:  Handle          - Handle of object whose id is desired
 *              ret_id          - Where the id will be placed
 *
 * RETURN:      Status
 *
 * DESCRIPTION: This routine returns the owner id associated with a handle
 *
 ******************************************************************************/
acpi_status acpi_get_id(acpi_handle handle, acpi_owner_id * ret_id)
{
	struct acpi_namespace_node *node;
	acpi_status status;

	/* Parameter Validation */

	if (!ret_id) {
		return (AE_BAD_PARAMETER);
	}

	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
	if (ACPI_FAILURE(status)) {
		return (status);
	}

	/* Convert and validate the handle */

	node = acpi_ns_validate_handle(handle);
	if (!node) {
		(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
		return (AE_BAD_PARAMETER);
	}

	*ret_id = node->owner_id;

	status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
	return (status);
}

ACPI_EXPORT_SYMBOL(acpi_get_id)

/*******************************************************************************
 *
 * FUNCTION:    acpi_get_type
 *
 * PARAMETERS:  Handle          - Handle of object whose type is desired
 *              ret_type        - Where the type will be placed
 *
 * RETURN:      Status
 *
 * DESCRIPTION: This routine returns the type associatd with a particular handle
 *
 ******************************************************************************/
acpi_status acpi_get_type(acpi_handle handle, acpi_object_type * ret_type)
{
	struct acpi_namespace_node *node;
	acpi_status status;

	/* Parameter Validation */

	if (!ret_type) {
		return (AE_BAD_PARAMETER);
	}

	/*
	 * Special case for the predefined Root Node
	 * (return type ANY)
	 */
	if (handle == ACPI_ROOT_OBJECT) {
		*ret_type = ACPI_TYPE_ANY;
		return (AE_OK);
	}

	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
	if (ACPI_FAILURE(status)) {
		return (status);
	}

	/* Convert and validate the handle */

	node = acpi_ns_validate_handle(handle);
	if (!node) {
		(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
		return (AE_BAD_PARAMETER);
	}

	*ret_type = node->type;

	status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
	return (status);
}

ACPI_EXPORT_SYMBOL(acpi_get_type)

/*******************************************************************************
 *
 * FUNCTION:    acpi_get_parent
 *
 * PARAMETERS:  Handle          - Handle of object whose parent is desired
 *              ret_handle      - Where the parent handle will be placed
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Returns a handle to the parent of the object represented by
 *              Handle.
 *
 ******************************************************************************/
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);
	}

	/* 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_validate_handle(handle);
	if (!node) {
		status = AE_BAD_PARAMETER;
		goto unlock_and_exit;
	}

	/* Get the parent entry */

	parent_node = node->parent;
	*ret_handle = ACPI_CAST_PTR(acpi_handle, parent_node);

	/* Return exception if parent is null */

	if (!parent_node) {
		status = AE_NULL_ENTRY;
	}

      unlock_and_exit:

	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
	return (status);
}

ACPI_EXPORT_SYMBOL(acpi_get_parent)

/*******************************************************************************
 *
 * 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_validate_handle(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_validate_handle(child);
		if (!child_node) {
			status = AE_BAD_PARAMETER;
			goto unlock_and_exit;
		}
	}

	/* Internal function does the real work */

	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_CAST_PTR(acpi_handle, node);
	}

      unlock_and_exit:

	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
	return (status);
}

ACPI_EXPORT_SYMBOL(acpi_get_next_object)
Commit	Line	Data
1da177e4 LT	1	/*******************************************************************************
	2	*
	3	* Module Name: nsxfobj - Public interfaces to the ACPI subsystem
	4	* ACPI Object oriented interfaces
	5	*
	6	******************************************************************************/
	7
	8	/*
77848130	9	* Copyright (C) 2000 - 2012, Intel Corp.
1da177e4 LT	10	* All rights reserved.
	11	*
	12	* Redistribution and use in source and binary forms, with or without
	13	* modification, are permitted provided that the following conditions
	14	* are met:
	15	* 1. Redistributions of source code must retain the above copyright
	16	* notice, this list of conditions, and the following disclaimer,
	17	* without modification.
	18	* 2. Redistributions in binary form must reproduce at minimum a disclaimer
	19	* substantially similar to the "NO WARRANTY" disclaimer below
	20	* ("Disclaimer") and any redistribution must be conditioned upon
	21	* including a substantially similar Disclaimer requirement for further
	22	* binary redistribution.
	23	* 3. Neither the names of the above-listed copyright holders nor the names
	24	* of any contributors may be used to endorse or promote products derived
	25	* from this software without specific prior written permission.
	26	*
	27	* Alternatively, this software may be distributed under the terms of the
	28	* GNU General Public License ("GPL") version 2 as published by the Free
	29	* Software Foundation.
	30	*
	31	* NO WARRANTY
	32	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	33	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	34	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
	35	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	36	* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	37	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	38	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	39	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	40	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	41	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	42	* POSSIBILITY OF SUCH DAMAGES.
	43	*/
	44
214f2c90	45	#include <linux/export.h>
1da177e4	46	#include <acpi/acpi.h>
e2f7a777 LB	47	#include "accommon.h"
e2f7a777 LB	48	#include "acnamesp.h"
1da177e4	49
1da177e4	50	#define _COMPONENT ACPI_NAMESPACE
4be44fcd	51	ACPI_MODULE_NAME("nsxfobj")
1da177e4	52
0f0fe1a0 JK	53	/*******************************************************************************
	54	*
	55	* FUNCTION: acpi_get_id
	56	*
	57	* PARAMETERS: Handle - Handle of object whose id is desired
	58	* ret_id - Where the id will be placed
	59	*
	60	* RETURN: Status
	61	*
	62	* DESCRIPTION: This routine returns the owner id associated with a handle
	63	*
	64	******************************************************************************/
	65	acpi_status acpi_get_id(acpi_handle handle, acpi_owner_id * ret_id)
	66	{
	67	struct acpi_namespace_node *node;
	68	acpi_status status;
	69
	70	/* Parameter Validation */
	71
	72	if (!ret_id) {
	73	return (AE_BAD_PARAMETER);
	74	}
	75
	76	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
	77	if (ACPI_FAILURE(status)) {
	78	return (status);
	79	}
	80
	81	/* Convert and validate the handle */
	82
f24b664d	83	node = acpi_ns_validate_handle(handle);
0f0fe1a0 JK	84	if (!node) {
	85	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
	86	return (AE_BAD_PARAMETER);
	87	}
	88
	89	*ret_id = node->owner_id;
	90
	91	status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
	92	return (status);
	93	}
	94
	95	ACPI_EXPORT_SYMBOL(acpi_get_id)
	96
1da177e4 LT	97	/*******************************************************************************
	98	*
	99	* FUNCTION: acpi_get_type
	100	*
	101	* PARAMETERS: Handle - Handle of object whose type is desired
44f6c012	102	* ret_type - Where the type will be placed
1da177e4 LT	103	*
	104	* RETURN: Status
	105	*
	106	* DESCRIPTION: This routine returns the type associatd with a particular handle
	107	*
	108	******************************************************************************/
4be44fcd	109	acpi_status acpi_get_type(acpi_handle handle, acpi_object_type * ret_type)
1da177e4	110	{
4be44fcd LB	111	struct acpi_namespace_node *node;
4be44fcd LB	112	acpi_status status;
1da177e4 LT	113
	114	/* Parameter Validation */
	115
	116	if (!ret_type) {
	117	return (AE_BAD_PARAMETER);
	118	}
	119
	120	/*
	121	* Special case for the predefined Root Node
	122	* (return type ANY)
	123	*/
	124	if (handle == ACPI_ROOT_OBJECT) {
	125	*ret_type = ACPI_TYPE_ANY;
	126	return (AE_OK);
	127	}
	128
4be44fcd LB	129	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
4be44fcd LB	130	if (ACPI_FAILURE(status)) {
1da177e4 LT	131	return (status);
	132	}
	133
	134	/* Convert and validate the handle */
	135
f24b664d	136	node = acpi_ns_validate_handle(handle);
1da177e4	137	if (!node) {
4be44fcd	138	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
1da177e4 LT	139	return (AE_BAD_PARAMETER);
	140	}
	141
	142	*ret_type = node->type;
	143
4be44fcd	144	status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
1da177e4 LT	145	return (status);
1da177e4 LT	146	}
1da177e4	147
8313524a	148	ACPI_EXPORT_SYMBOL(acpi_get_type)
1da177e4 LT	149
	150	/*******************************************************************************
	151	*
	152	* FUNCTION: acpi_get_parent
	153	*
	154	* PARAMETERS: Handle - Handle of object whose parent is desired
	155	* ret_handle - Where the parent handle will be placed
	156	*
	157	* RETURN: Status
	158	*
	159	* DESCRIPTION: Returns a handle to the parent of the object represented by
	160	* Handle.
	161	*
	162	******************************************************************************/
4be44fcd	163	acpi_status acpi_get_parent(acpi_handle handle, acpi_handle * ret_handle)
1da177e4	164	{
4be44fcd	165	struct acpi_namespace_node *node;
c446eed6	166	struct acpi_namespace_node *parent_node;
4be44fcd	167	acpi_status status;
1da177e4 LT	168
	169	if (!ret_handle) {
	170	return (AE_BAD_PARAMETER);
	171	}
	172
	173	/* Special case for the predefined Root Node (no parent) */
	174
	175	if (handle == ACPI_ROOT_OBJECT) {
	176	return (AE_NULL_ENTRY);
	177	}
	178
4be44fcd LB	179	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
4be44fcd LB	180	if (ACPI_FAILURE(status)) {
1da177e4 LT	181	return (status);
	182	}
	183
	184	/* Convert and validate the handle */
	185
f24b664d	186	node = acpi_ns_validate_handle(handle);
1da177e4 LT	187	if (!node) {
	188	status = AE_BAD_PARAMETER;
	189	goto unlock_and_exit;
	190	}
	191
	192	/* Get the parent entry */
	193
c45b5c09	194	parent_node = node->parent;
f24b664d	195	*ret_handle = ACPI_CAST_PTR(acpi_handle, parent_node);
1da177e4 LT	196
	197	/* Return exception if parent is null */
	198
c446eed6	199	if (!parent_node) {
1da177e4 LT	200	status = AE_NULL_ENTRY;
	201	}
	202
4be44fcd	203	unlock_and_exit:
1da177e4	204
4be44fcd	205	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
1da177e4 LT	206	return (status);
1da177e4 LT	207	}
1da177e4	208
8313524a	209	ACPI_EXPORT_SYMBOL(acpi_get_parent)
1da177e4 LT	210
	211	/*******************************************************************************
	212	*
	213	* FUNCTION: acpi_get_next_object
	214	*
	215	* PARAMETERS: Type - Type of object to be searched for
	216	* Parent - Parent object whose children we are getting
	217	* last_child - Previous child that was found.
	218	* The NEXT child will be returned
	219	* ret_handle - Where handle to the next object is placed
	220	*
	221	* RETURN: Status
	222	*
	223	* DESCRIPTION: Return the next peer object within the namespace. If Handle is
	224	* valid, Scope is ignored. Otherwise, the first object within
	225	* Scope is returned.
	226	*
	227	******************************************************************************/
1da177e4	228	acpi_status
4be44fcd LB	229	acpi_get_next_object(acpi_object_type type,
	230	acpi_handle parent,
	231	acpi_handle child, acpi_handle * ret_handle)
1da177e4	232	{
4be44fcd LB	233	acpi_status status;
	234	struct acpi_namespace_node *node;
	235	struct acpi_namespace_node *parent_node = NULL;
	236	struct acpi_namespace_node *child_node = NULL;
1da177e4 LT	237
	238	/* Parameter validation */
	239
	240	if (type > ACPI_TYPE_EXTERNAL_MAX) {
	241	return (AE_BAD_PARAMETER);
	242	}
	243
4be44fcd LB	244	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
4be44fcd LB	245	if (ACPI_FAILURE(status)) {
1da177e4 LT	246	return (status);
	247	}
	248
	249	/* If null handle, use the parent */
	250
	251	if (!child) {
52fc0b02	252
1da177e4 LT	253	/* Start search at the beginning of the specified scope */
1da177e4 LT	254
f24b664d	255	parent_node = acpi_ns_validate_handle(parent);
1da177e4 LT	256	if (!parent_node) {
	257	status = AE_BAD_PARAMETER;
	258	goto unlock_and_exit;
	259	}
4be44fcd	260	} else {
1da177e4 LT	261	/* Non-null handle, ignore the parent */
	262	/* Convert and validate the handle */
	263
f24b664d	264	child_node = acpi_ns_validate_handle(child);
1da177e4 LT	265	if (!child_node) {
	266	status = AE_BAD_PARAMETER;
	267	goto unlock_and_exit;
	268	}
	269	}
	270
	271	/* Internal function does the real work */
	272
8c725bf9	273	node = acpi_ns_get_next_node_typed(type, parent_node, child_node);
1da177e4 LT	274	if (!node) {
	275	status = AE_NOT_FOUND;
	276	goto unlock_and_exit;
	277	}
	278
	279	if (ret_handle) {
f24b664d	280	*ret_handle = ACPI_CAST_PTR(acpi_handle, node);
1da177e4 LT	281	}
1da177e4 LT	282
4be44fcd	283	unlock_and_exit:
1da177e4	284
4be44fcd	285	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
1da177e4 LT	286	return (status);
1da177e4 LT	287	}
1da177e4	288
8313524a	289	ACPI_EXPORT_SYMBOL(acpi_get_next_object)