[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / acpi / acpica / nsxfname.c

/******************************************************************************
 *
 * Module Name: nsxfname - Public interfaces to the ACPI subsystem
 *                         ACPI Namespace oriented interfaces
 *
 *****************************************************************************/

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

#define _COMPONENT          ACPI_NAMESPACE
ACPI_MODULE_NAME("nsxfname")

/******************************************************************************
 *
 * 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_EXPORT_SYMBOL(acpi_get_handle)

/******************************************************************************
 *
 * FUNCTION:    acpi_get_name
 *
 * PARAMETERS:  Handle          - Handle to be converted to a pathname
 *              name_type       - Full pathname or single segment
 *              Buffer          - Buffer for returned path
 *
 * RETURN:      Pointer to a string containing the fully qualified Name.
 *
 * DESCRIPTION: This routine returns the fully qualified name associated with
 *              the Handle parameter.  This and the acpi_pathname_to_handle are
 *              complementary functions.
 *
 ******************************************************************************/
acpi_status
acpi_get_name(acpi_handle handle, u32 name_type, struct acpi_buffer * buffer)
{
	acpi_status status;
	struct acpi_namespace_node *node;

	/* Parameter validation */

	if (name_type > ACPI_NAME_TYPE_MAX) {
		return (AE_BAD_PARAMETER);
	}

	status = acpi_ut_validate_buffer(buffer);
	if (ACPI_FAILURE(status)) {
		return (status);
	}

	if (name_type == ACPI_FULL_PATHNAME) {

		/* Get the full pathname (From the namespace root) */

		status = acpi_ns_handle_to_pathname(handle, buffer);
		return (status);
	}

	/*
	 * Wants the single segment ACPI name.
	 * Validate handle and convert to a namespace Node
	 */
	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;
	}

	/* Validate/Allocate/Clear caller buffer */

	status = acpi_ut_initialize_buffer(buffer, ACPI_PATH_SEGMENT_LENGTH);
	if (ACPI_FAILURE(status)) {
		goto unlock_and_exit;
	}

	/* Just copy the ACPI name from the Node and zero terminate it */

	ACPI_STRNCPY(buffer->pointer, acpi_ut_get_node_name(node),
		     ACPI_NAME_SIZE);
	((char *)buffer->pointer)[ACPI_NAME_SIZE] = 0;
	status = AE_OK;

      unlock_and_exit:

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

ACPI_EXPORT_SYMBOL(acpi_get_name)

/******************************************************************************
 *
 * FUNCTION:    acpi_get_object_info
 *
 * PARAMETERS:  Handle          - Object Handle
 *              Buffer          - Where the info is returned
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Returns information about an object as gleaned from the
 *              namespace node and possibly by running several standard
 *              control methods (Such as in the case of a device.)
 *
 ******************************************************************************/
acpi_status
acpi_get_object_info(acpi_handle handle, struct acpi_buffer * buffer)
{
	acpi_status status;
	struct acpi_namespace_node *node;
	struct acpi_device_info *info;
	struct acpi_device_info *return_info;
	struct acpi_compatible_id_list *cid_list = NULL;
	acpi_size size;

	/* Parameter validation */

	if (!handle || !buffer) {
		return (AE_BAD_PARAMETER);
	}

	status = acpi_ut_validate_buffer(buffer);
	if (ACPI_FAILURE(status)) {
		return (status);
	}

	info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_device_info));
	if (!info) {
		return (AE_NO_MEMORY);
	}

	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
	if (ACPI_FAILURE(status)) {
		goto cleanup;
	}

	node = acpi_ns_map_handle_to_node(handle);
	if (!node) {
		(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
		status = AE_BAD_PARAMETER;
		goto cleanup;
	}

	/* Init return structure */

	size = sizeof(struct acpi_device_info);

	info->type = node->type;
	info->name = node->name.integer;
	info->valid = 0;

	if (node->type == ACPI_TYPE_METHOD) {
		info->param_count = node->object->method.param_count;
	}

	status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
	if (ACPI_FAILURE(status)) {
		goto cleanup;
	}

	/* If not a device, we are all done */

	if (info->type == ACPI_TYPE_DEVICE) {
		/*
		 * Get extra info for ACPI Devices objects only:
		 * Run the Device _HID, _UID, _CID, _STA, _ADR and _sx_d methods.
		 *
		 * Note: none of these methods are required, so they may or may
		 * not be present for this device.  The Info->Valid bitfield is used
		 * to indicate which methods were found and ran successfully.
		 */

		/* Execute the Device._HID method */

		status = acpi_ut_execute_HID(node, &info->hardware_id);
		if (ACPI_SUCCESS(status)) {
			info->valid |= ACPI_VALID_HID;
		}

		/* Execute the Device._UID method */

		status = acpi_ut_execute_UID(node, &info->unique_id);
		if (ACPI_SUCCESS(status)) {
			info->valid |= ACPI_VALID_UID;
		}

		/* Execute the Device._CID method */

		status = acpi_ut_execute_CID(node, &cid_list);
		if (ACPI_SUCCESS(status)) {
			size += cid_list->size;
			info->valid |= ACPI_VALID_CID;
		}

		/* Execute the Device._STA method */

		status = acpi_ut_execute_STA(node, &info->current_status);
		if (ACPI_SUCCESS(status)) {
			info->valid |= ACPI_VALID_STA;
		}

		/* Execute the Device._ADR method */

		status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, node,
							 &info->address);
		if (ACPI_SUCCESS(status)) {
			info->valid |= ACPI_VALID_ADR;
		}

		/* Execute the Device._sx_d methods */

		status = acpi_ut_execute_sxds(node, info->highest_dstates);
		if (ACPI_SUCCESS(status)) {
			info->valid |= ACPI_VALID_SXDS;
		}
	}

	/* Validate/Allocate/Clear caller buffer */

	status = acpi_ut_initialize_buffer(buffer, size);
	if (ACPI_FAILURE(status)) {
		goto cleanup;
	}

	/* Populate the return buffer */

	return_info = buffer->pointer;
	ACPI_MEMCPY(return_info, info, sizeof(struct acpi_device_info));

	if (cid_list) {
		ACPI_MEMCPY(&return_info->compatibility_id, cid_list,
			    cid_list->size);
	}

      cleanup:
	ACPI_FREE(info);
	if (cid_list) {
		ACPI_FREE(cid_list);
	}
	return (status);
}

ACPI_EXPORT_SYMBOL(acpi_get_object_info)

/******************************************************************************
 *
 * FUNCTION:    acpi_install_method
 *
 * PARAMETERS:  Buffer         - An ACPI table containing one control method
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Install a control method into the namespace. If the method
 *              name already exists in the namespace, it is overwritten. The
 *              input buffer must contain a valid DSDT or SSDT containing a
 *              single control method.
 *
 ******************************************************************************/
acpi_status acpi_install_method(u8 *buffer)
{
	struct acpi_table_header *table =
	    ACPI_CAST_PTR(struct acpi_table_header, buffer);
	u8 *aml_buffer;
	u8 *aml_start;
	char *path;
	struct acpi_namespace_node *node;
	union acpi_operand_object *method_obj;
	struct acpi_parse_state parser_state;
	u32 aml_length;
	u16 opcode;
	u8 method_flags;
	acpi_status status;

	/* Parameter validation */

	if (!buffer) {
		return AE_BAD_PARAMETER;
	}

	/* Table must be a DSDT or SSDT */

	if (!ACPI_COMPARE_NAME(table->signature, ACPI_SIG_DSDT) &&
	    !ACPI_COMPARE_NAME(table->signature, ACPI_SIG_SSDT)) {
		return AE_BAD_HEADER;
	}

	/* First AML opcode in the table must be a control method */

	parser_state.aml = buffer + sizeof(struct acpi_table_header);
	opcode = acpi_ps_peek_opcode(&parser_state);
	if (opcode != AML_METHOD_OP) {
		return AE_BAD_PARAMETER;
	}

	/* Extract method information from the raw AML */

	parser_state.aml += acpi_ps_get_opcode_size(opcode);
	parser_state.pkg_end = acpi_ps_get_next_package_end(&parser_state);
	path = acpi_ps_get_next_namestring(&parser_state);
	method_flags = *parser_state.aml++;
	aml_start = parser_state.aml;
	aml_length = ACPI_PTR_DIFF(parser_state.pkg_end, aml_start);

	/*
	 * Allocate resources up-front. We don't want to have to delete a new
	 * node from the namespace if we cannot allocate memory.
	 */
	aml_buffer = ACPI_ALLOCATE(aml_length);
	if (!aml_buffer) {
		return AE_NO_MEMORY;
	}

	method_obj = acpi_ut_create_internal_object(ACPI_TYPE_METHOD);
	if (!method_obj) {
		ACPI_FREE(aml_buffer);
		return AE_NO_MEMORY;
	}

	/* Lock namespace for acpi_ns_lookup, we may be creating a new node */

	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
	if (ACPI_FAILURE(status)) {
		goto error_exit;
	}

	/* The lookup either returns an existing node or creates a new one */

	status =
	    acpi_ns_lookup(NULL, path, ACPI_TYPE_METHOD, ACPI_IMODE_LOAD_PASS1,
			   ACPI_NS_DONT_OPEN_SCOPE | ACPI_NS_ERROR_IF_FOUND,
			   NULL, &node);

	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);

	if (ACPI_FAILURE(status)) {	/* ns_lookup */
		if (status != AE_ALREADY_EXISTS) {
			goto error_exit;
		}

		/* Node existed previously, make sure it is a method node */

		if (node->type != ACPI_TYPE_METHOD) {
			status = AE_TYPE;
			goto error_exit;
		}
	}

	/* Copy the method AML to the local buffer */

	ACPI_MEMCPY(aml_buffer, aml_start, aml_length);

	/* Initialize the method object with the new method's information */

	method_obj->method.aml_start = aml_buffer;
	method_obj->method.aml_length = aml_length;

	method_obj->method.param_count = (u8)
	    (method_flags & AML_METHOD_ARG_COUNT);

	method_obj->method.method_flags = (u8)
	    (method_flags & ~AML_METHOD_ARG_COUNT);

	if (method_flags & AML_METHOD_SERIALIZED) {
		method_obj->method.sync_level = (u8)
		    ((method_flags & AML_METHOD_SYNC_LEVEL) >> 4);
	}

	/*
	 * Now that it is complete, we can attach the new method object to
	 * the method Node (detaches/deletes any existing object)
	 */
	status = acpi_ns_attach_object(node, method_obj, ACPI_TYPE_METHOD);

	/*
	 * Flag indicates AML buffer is dynamic, must be deleted later.
	 * Must be set only after attach above.
	 */
	node->flags |= ANOBJ_ALLOCATED_BUFFER;

	/* Remove local reference to the method object */

	acpi_ut_remove_reference(method_obj);
	return status;

error_exit:

	ACPI_FREE(aml_buffer);
	ACPI_FREE(method_obj);
	return status;
}
ACPI_EXPORT_SYMBOL(acpi_install_method)
Commit	Line	Data
1da177e4 LT	1	/******************************************************************************
	2	*
	3	* Module Name: nsxfname - Public interfaces to the ACPI subsystem
	4	* ACPI Namespace oriented interfaces
	5	*
	6	*****************************************************************************/
	7
	8	/*
75a44ce0	9	* Copyright (C) 2000 - 2008, 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
1da177e4	45	#include <acpi/acpi.h>
e2f7a777 LB	46	#include "accommon.h"
e2f7a777 LB	47	#include "acnamesp.h"
b2f7ddcf LM	48	#include "acparser.h"
b2f7ddcf LM	49	#include "amlcode.h"
1da177e4	50
1da177e4	51	#define _COMPONENT ACPI_NAMESPACE
4be44fcd	52	ACPI_MODULE_NAME("nsxfname")
1da177e4 LT	53
	54	/******************************************************************************
	55	*
	56	* FUNCTION: acpi_get_handle
	57	*
	58	* PARAMETERS: Parent - Object to search under (search scope).
44f6c012 RM	59	* Pathname - Pointer to an asciiz string containing the
	60	* name
	61	* ret_handle - Where the return handle is returned
1da177e4 LT	62	*
	63	* RETURN: Status
	64	*
	65	* DESCRIPTION: This routine will search for a caller specified name in the
	66	* name space. The caller can restrict the search region by
	67	* specifying a non NULL parent. The parent value is itself a
	68	* namespace handle.
	69	*
	70	******************************************************************************/
1da177e4	71	acpi_status
4be44fcd LB	72	acpi_get_handle(acpi_handle parent,
4be44fcd LB	73	acpi_string pathname, acpi_handle * ret_handle)
1da177e4	74	{
4be44fcd LB	75	acpi_status status;
	76	struct acpi_namespace_node *node = NULL;
	77	struct acpi_namespace_node *prefix_node = NULL;
1da177e4	78
4be44fcd	79	ACPI_FUNCTION_ENTRY();
1da177e4 LT	80
	81	/* Parameter Validation */
	82
	83	if (!ret_handle \|\| !pathname) {
	84	return (AE_BAD_PARAMETER);
	85	}
	86
	87	/* Convert a parent handle to a prefix node */
	88
	89	if (parent) {
4be44fcd	90	prefix_node = acpi_ns_map_handle_to_node(parent);
1da177e4	91	if (!prefix_node) {
1da177e4 LT	92	return (AE_BAD_PARAMETER);
1da177e4 LT	93	}
f1c2b1da BM	94	}
	95
	96	/*
	97	* Valid cases are:
	98	* 1) Fully qualified pathname
	99	* 2) Parent + Relative pathname
	100	*
	101	* Error for <null Parent + relative path>
	102	*/
	103	if (acpi_ns_valid_root_prefix(pathname[0])) {
1da177e4	104
f1c2b1da BM	105	/* Pathname is fully qualified (starts with '\') */
	106
	107	/* Special case for root-only, since we can't search for it */
	108
	109	if (!ACPI_STRCMP(pathname, ACPI_NS_ROOT_PATH)) {
	110	*ret_handle =
	111	acpi_ns_convert_entry_to_handle(acpi_gbl_root_node);
	112	return (AE_OK);
1da177e4	113	}
f1c2b1da	114	} else if (!prefix_node) {
1da177e4	115
f1c2b1da	116	/* Relative path with null prefix is disallowed */
1da177e4	117
f1c2b1da	118	return (AE_BAD_PARAMETER);
1da177e4 LT	119	}
1da177e4 LT	120
f1c2b1da	121	/* Find the Node and convert to a handle */
1da177e4	122
f1c2b1da BM	123	status =
f1c2b1da BM	124	acpi_ns_get_node(prefix_node, pathname, ACPI_NS_NO_UPSEARCH, &node);
4be44fcd LB	125	if (ACPI_SUCCESS(status)) {
4be44fcd LB	126	*ret_handle = acpi_ns_convert_entry_to_handle(node);
1da177e4 LT	127	}
	128
	129	return (status);
	130	}
1da177e4	131
8313524a	132	ACPI_EXPORT_SYMBOL(acpi_get_handle)
1da177e4 LT	133
	134	/******************************************************************************
	135	*
	136	* FUNCTION: acpi_get_name
	137	*
	138	* PARAMETERS: Handle - Handle to be converted to a pathname
	139	* name_type - Full pathname or single segment
	140	* Buffer - Buffer for returned path
	141	*
	142	* RETURN: Pointer to a string containing the fully qualified Name.
	143	*
	144	* DESCRIPTION: This routine returns the fully qualified name associated with
	145	* the Handle parameter. This and the acpi_pathname_to_handle are
	146	* complementary functions.
	147	*
	148	******************************************************************************/
1da177e4	149	acpi_status
4be44fcd	150	acpi_get_name(acpi_handle handle, u32 name_type, struct acpi_buffer * buffer)
1da177e4	151	{
4be44fcd LB	152	acpi_status status;
4be44fcd LB	153	struct acpi_namespace_node *node;
1da177e4 LT	154
	155	/* Parameter validation */
	156
	157	if (name_type > ACPI_NAME_TYPE_MAX) {
	158	return (AE_BAD_PARAMETER);
	159	}
	160
4be44fcd LB	161	status = acpi_ut_validate_buffer(buffer);
4be44fcd LB	162	if (ACPI_FAILURE(status)) {
1da177e4 LT	163	return (status);
	164	}
	165
	166	if (name_type == ACPI_FULL_PATHNAME) {
52fc0b02	167
1da177e4 LT	168	/* Get the full pathname (From the namespace root) */
1da177e4 LT	169
4be44fcd	170	status = acpi_ns_handle_to_pathname(handle, buffer);
1da177e4 LT	171	return (status);
	172	}
	173
	174	/*
	175	* Wants the single segment ACPI name.
	176	* Validate handle and convert to a namespace Node
	177	*/
4be44fcd LB	178	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
4be44fcd LB	179	if (ACPI_FAILURE(status)) {
1da177e4 LT	180	return (status);
	181	}
	182
4be44fcd	183	node = acpi_ns_map_handle_to_node(handle);
1da177e4 LT	184	if (!node) {
	185	status = AE_BAD_PARAMETER;
	186	goto unlock_and_exit;
	187	}
	188
	189	/* Validate/Allocate/Clear caller buffer */
	190
4be44fcd LB	191	status = acpi_ut_initialize_buffer(buffer, ACPI_PATH_SEGMENT_LENGTH);
4be44fcd LB	192	if (ACPI_FAILURE(status)) {
1da177e4 LT	193	goto unlock_and_exit;
	194	}
	195
	196	/* Just copy the ACPI name from the Node and zero terminate it */
	197
4be44fcd LB	198	ACPI_STRNCPY(buffer->pointer, acpi_ut_get_node_name(node),
	199	ACPI_NAME_SIZE);
	200	((char *)buffer->pointer)[ACPI_NAME_SIZE] = 0;
1da177e4 LT	201	status = AE_OK;
1da177e4 LT	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_name)
1da177e4 LT	210
	211	/******************************************************************************
	212	*
	213	* FUNCTION: acpi_get_object_info
	214	*
	215	* PARAMETERS: Handle - Object Handle
44f6c012	216	* Buffer - Where the info is returned
1da177e4 LT	217	*
	218	* RETURN: Status
	219	*
	220	* DESCRIPTION: Returns information about an object as gleaned from the
	221	* namespace node and possibly by running several standard
	222	* control methods (Such as in the case of a device.)
	223	*
	224	******************************************************************************/
1da177e4	225	acpi_status
4be44fcd	226	acpi_get_object_info(acpi_handle handle, struct acpi_buffer * buffer)
1da177e4	227	{
4be44fcd LB	228	acpi_status status;
	229	struct acpi_namespace_node *node;
	230	struct acpi_device_info *info;
	231	struct acpi_device_info *return_info;
1da177e4	232	struct acpi_compatible_id_list *cid_list = NULL;
4be44fcd	233	acpi_size size;
1da177e4 LT	234
	235	/* Parameter validation */
	236
	237	if (!handle \|\| !buffer) {
	238	return (AE_BAD_PARAMETER);
	239	}
	240
4be44fcd LB	241	status = acpi_ut_validate_buffer(buffer);
4be44fcd LB	242	if (ACPI_FAILURE(status)) {
1da177e4 LT	243	return (status);
	244	}
	245
8313524a	246	info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_device_info));
1da177e4 LT	247	if (!info) {
	248	return (AE_NO_MEMORY);
	249	}
	250
4be44fcd LB	251	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
4be44fcd LB	252	if (ACPI_FAILURE(status)) {
1da177e4 LT	253	goto cleanup;
	254	}
	255
4be44fcd	256	node = acpi_ns_map_handle_to_node(handle);
1da177e4	257	if (!node) {
4be44fcd	258	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
237a9276	259	status = AE_BAD_PARAMETER;
1da177e4 LT	260	goto cleanup;
	261	}
	262
	263	/* Init return structure */
	264
4be44fcd	265	size = sizeof(struct acpi_device_info);
1da177e4	266
4be44fcd LB	267	info->type = node->type;
4be44fcd LB	268	info->name = node->name.integer;
1da177e4 LT	269	info->valid = 0;
1da177e4 LT	270
0a1fbf2d BM	271	if (node->type == ACPI_TYPE_METHOD) {
	272	info->param_count = node->object->method.param_count;
	273	}
	274
4be44fcd LB	275	status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
4be44fcd LB	276	if (ACPI_FAILURE(status)) {
1da177e4 LT	277	goto cleanup;
	278	}
	279
	280	/* If not a device, we are all done */
	281
	282	if (info->type == ACPI_TYPE_DEVICE) {
	283	/*
	284	* Get extra info for ACPI Devices objects only:
	285	* Run the Device _HID, _UID, _CID, _STA, _ADR and _sx_d methods.
	286	*
	287	* Note: none of these methods are required, so they may or may
	288	* not be present for this device. The Info->Valid bitfield is used
	289	* to indicate which methods were found and ran successfully.
	290	*/
	291
	292	/* Execute the Device._HID method */
	293
4be44fcd LB	294	status = acpi_ut_execute_HID(node, &info->hardware_id);
4be44fcd LB	295	if (ACPI_SUCCESS(status)) {
1da177e4 LT	296	info->valid \|= ACPI_VALID_HID;
	297	}
	298
	299	/* Execute the Device._UID method */
	300
4be44fcd LB	301	status = acpi_ut_execute_UID(node, &info->unique_id);
4be44fcd LB	302	if (ACPI_SUCCESS(status)) {
1da177e4 LT	303	info->valid \|= ACPI_VALID_UID;
	304	}
	305
	306	/* Execute the Device._CID method */
	307
4be44fcd LB	308	status = acpi_ut_execute_CID(node, &cid_list);
4be44fcd LB	309	if (ACPI_SUCCESS(status)) {
b8e4d893	310	size += cid_list->size;
1da177e4 LT	311	info->valid \|= ACPI_VALID_CID;
	312	}
	313
	314	/* Execute the Device._STA method */
	315
4be44fcd LB	316	status = acpi_ut_execute_STA(node, &info->current_status);
4be44fcd LB	317	if (ACPI_SUCCESS(status)) {
1da177e4 LT	318	info->valid \|= ACPI_VALID_STA;
	319	}
	320
	321	/* Execute the Device._ADR method */
	322
4be44fcd LB	323	status = acpi_ut_evaluate_numeric_object(METHOD_NAME__ADR, node,
	324	&info->address);
	325	if (ACPI_SUCCESS(status)) {
1da177e4 LT	326	info->valid \|= ACPI_VALID_ADR;
	327	}
	328
	329	/* Execute the Device._sx_d methods */
	330
4be44fcd LB	331	status = acpi_ut_execute_sxds(node, info->highest_dstates);
4be44fcd LB	332	if (ACPI_SUCCESS(status)) {
1da177e4 LT	333	info->valid \|= ACPI_VALID_SXDS;
	334	}
	335	}
	336
	337	/* Validate/Allocate/Clear caller buffer */
	338
4be44fcd LB	339	status = acpi_ut_initialize_buffer(buffer, size);
4be44fcd LB	340	if (ACPI_FAILURE(status)) {
1da177e4 LT	341	goto cleanup;
	342	}
	343
	344	/* Populate the return buffer */
	345
	346	return_info = buffer->pointer;
4be44fcd	347	ACPI_MEMCPY(return_info, info, sizeof(struct acpi_device_info));
1da177e4 LT	348
1da177e4 LT	349	if (cid_list) {
4be44fcd LB	350	ACPI_MEMCPY(&return_info->compatibility_id, cid_list,
4be44fcd LB	351	cid_list->size);
1da177e4 LT	352	}
1da177e4 LT	353
4be44fcd	354	cleanup:
8313524a	355	ACPI_FREE(info);
1da177e4	356	if (cid_list) {
8313524a	357	ACPI_FREE(cid_list);
1da177e4 LT	358	}
	359	return (status);
	360	}
1da177e4	361
8313524a	362	ACPI_EXPORT_SYMBOL(acpi_get_object_info)
b2f7ddcf LM	363
	364	/******************************************************************************
	365	*
	366	* FUNCTION: acpi_install_method
	367	*
	368	* PARAMETERS: Buffer - An ACPI table containing one control method
	369	*
	370	* RETURN: Status
	371	*
	372	* DESCRIPTION: Install a control method into the namespace. If the method
	373	* name already exists in the namespace, it is overwritten. The
	374	* input buffer must contain a valid DSDT or SSDT containing a
	375	* single control method.
	376	*
	377	******************************************************************************/
	378	acpi_status acpi_install_method(u8 *buffer)
	379	{
	380	struct acpi_table_header *table =
	381	ACPI_CAST_PTR(struct acpi_table_header, buffer);
	382	u8 *aml_buffer;
	383	u8 *aml_start;
	384	char *path;
	385	struct acpi_namespace_node *node;
	386	union acpi_operand_object *method_obj;
	387	struct acpi_parse_state parser_state;
	388	u32 aml_length;
	389	u16 opcode;
	390	u8 method_flags;
	391	acpi_status status;
	392
	393	/* Parameter validation */
	394
	395	if (!buffer) {
	396	return AE_BAD_PARAMETER;
	397	}
	398
	399	/* Table must be a DSDT or SSDT */
	400
	401	if (!ACPI_COMPARE_NAME(table->signature, ACPI_SIG_DSDT) &&
	402	!ACPI_COMPARE_NAME(table->signature, ACPI_SIG_SSDT)) {
	403	return AE_BAD_HEADER;
	404	}
	405
	406	/* First AML opcode in the table must be a control method */
	407
	408	parser_state.aml = buffer + sizeof(struct acpi_table_header);
	409	opcode = acpi_ps_peek_opcode(&parser_state);
	410	if (opcode != AML_METHOD_OP) {
	411	return AE_BAD_PARAMETER;
	412	}
	413
	414	/* Extract method information from the raw AML */
	415
	416	parser_state.aml += acpi_ps_get_opcode_size(opcode);
	417	parser_state.pkg_end = acpi_ps_get_next_package_end(&parser_state);
	418	path = acpi_ps_get_next_namestring(&parser_state);
	419	method_flags = *parser_state.aml++;
	420	aml_start = parser_state.aml;
	421	aml_length = ACPI_PTR_DIFF(parser_state.pkg_end, aml_start);
	422
	423	/*
	424	* Allocate resources up-front. We don't want to have to delete a new
	425	* node from the namespace if we cannot allocate memory.
	426	*/
427	aml_buffer = ACPI_ALLOCATE(aml_length);
428	if (!aml_buffer) {
429	return AE_NO_MEMORY;
430	}
431
432	method_obj = acpi_ut_create_internal_object(ACPI_TYPE_METHOD);
433	if (!method_obj) {
434	ACPI_FREE(aml_buffer);
435	return AE_NO_MEMORY;
436	}
437
438	/* Lock namespace for acpi_ns_lookup, we may be creating a new node */
439
440	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
441	if (ACPI_FAILURE(status)) {
442	goto error_exit;
443	}
444
445	/* The lookup either returns an existing node or creates a new one */
446
447	status =
448	acpi_ns_lookup(NULL, path, ACPI_TYPE_METHOD, ACPI_IMODE_LOAD_PASS1,
449	ACPI_NS_DONT_OPEN_SCOPE \| ACPI_NS_ERROR_IF_FOUND,
450	NULL, &node);
451
452	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
453
454	if (ACPI_FAILURE(status)) { /* ns_lookup */
455	if (status != AE_ALREADY_EXISTS) {
456	goto error_exit;
457	}
458
459	/* Node existed previously, make sure it is a method node */
460
461	if (node->type != ACPI_TYPE_METHOD) {
462	status = AE_TYPE;
463	goto error_exit;
464	}
465	}
466
467	/* Copy the method AML to the local buffer */
468
469	ACPI_MEMCPY(aml_buffer, aml_start, aml_length);
470
471	/* Initialize the method object with the new method's information */
472
473	method_obj->method.aml_start = aml_buffer;
474	method_obj->method.aml_length = aml_length;
475
476	method_obj->method.param_count = (u8)
477	(method_flags & AML_METHOD_ARG_COUNT);
478
479	method_obj->method.method_flags = (u8)
480	(method_flags & ~AML_METHOD_ARG_COUNT);
481
482	if (method_flags & AML_METHOD_SERIALIZED) {
483	method_obj->method.sync_level = (u8)
484	((method_flags & AML_METHOD_SYNC_LEVEL) >> 4);
485	}
486
487	/*
488	* Now that it is complete, we can attach the new method object to
489	* the method Node (detaches/deletes any existing object)
490	*/
491	status = acpi_ns_attach_object(node, method_obj, ACPI_TYPE_METHOD);
492
493	/*
494	* Flag indicates AML buffer is dynamic, must be deleted later.
495	* Must be set only after attach above.
496	*/
497	node->flags \|= ANOBJ_ALLOCATED_BUFFER;
498
499	/* Remove local reference to the method object */
500
501	acpi_ut_remove_reference(method_obj);
502	return status;
503
504	error_exit:
505
506	ACPI_FREE(aml_buffer);
507	ACPI_FREE(method_obj);
508	return status;
509	}
510	ACPI_EXPORT_SYMBOL(acpi_install_method)