[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / acpi / executer / exnames.c


/******************************************************************************
 *
 * Module Name: exnames - interpreter/scanner name load/execute
 *
 *****************************************************************************/

/*
 * Copyright (C) 2000 - 2006, R. Byron Moore
 * 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 <acpi/acinterp.h>
#include <acpi/amlcode.h>

#define _COMPONENT          ACPI_EXECUTER
ACPI_MODULE_NAME("exnames")

/* Local prototypes */
static char *acpi_ex_allocate_name_string(u32 prefix_count, u32 num_name_segs);

static acpi_status
acpi_ex_name_segment(u8 ** in_aml_address, char *name_string);

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_allocate_name_string
 *
 * PARAMETERS:  prefix_count        - Count of parent levels. Special cases:
 *                                    (-1)==root,  0==none
 *              num_name_segs       - count of 4-character name segments
 *
 * RETURN:      A pointer to the allocated string segment.  This segment must
 *              be deleted by the caller.
 *
 * DESCRIPTION: Allocate a buffer for a name string. Ensure allocated name
 *              string is long enough, and set up prefix if any.
 *
 ******************************************************************************/

static char *acpi_ex_allocate_name_string(u32 prefix_count, u32 num_name_segs)
{
	char *temp_ptr;
	char *name_string;
	u32 size_needed;

	ACPI_FUNCTION_TRACE("ex_allocate_name_string");

	/*
	 * Allow room for all \ and ^ prefixes, all segments and a multi_name_prefix.
	 * Also, one byte for the null terminator.
	 * This may actually be somewhat longer than needed.
	 */
	if (prefix_count == ACPI_UINT32_MAX) {
		/* Special case for root */

		size_needed = 1 + (ACPI_NAME_SIZE * num_name_segs) + 2 + 1;
	} else {
		size_needed =
		    prefix_count + (ACPI_NAME_SIZE * num_name_segs) + 2 + 1;
	}

	/*
	 * Allocate a buffer for the name.
	 * This buffer must be deleted by the caller!
	 */
	name_string = ACPI_MEM_ALLOCATE(size_needed);
	if (!name_string) {
		ACPI_ERROR((AE_INFO,
			    "Could not allocate size %d", size_needed));
		return_PTR(NULL);
	}

	temp_ptr = name_string;

	/* Set up Root or Parent prefixes if needed */

	if (prefix_count == ACPI_UINT32_MAX) {
		*temp_ptr++ = AML_ROOT_PREFIX;
	} else {
		while (prefix_count--) {
			*temp_ptr++ = AML_PARENT_PREFIX;
		}
	}

	/* Set up Dual or Multi prefixes if needed */

	if (num_name_segs > 2) {
		/* Set up multi prefixes   */

		*temp_ptr++ = AML_MULTI_NAME_PREFIX_OP;
		*temp_ptr++ = (char)num_name_segs;
	} else if (2 == num_name_segs) {
		/* Set up dual prefixes */

		*temp_ptr++ = AML_DUAL_NAME_PREFIX;
	}

	/*
	 * Terminate string following prefixes. acpi_ex_name_segment() will
	 * append the segment(s)
	 */
	*temp_ptr = 0;

	return_PTR(name_string);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_name_segment
 *
 * PARAMETERS:  in_aml_address  - Pointer to the name in the AML code
 *              name_string     - Where to return the name. The name is appended
 *                                to any existing string to form a namepath
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Extract an ACPI name (4 bytes) from the AML byte stream
 *
 ******************************************************************************/

static acpi_status acpi_ex_name_segment(u8 ** in_aml_address, char *name_string)
{
	char *aml_address = (void *)*in_aml_address;
	acpi_status status = AE_OK;
	u32 index;
	char char_buf[5];

	ACPI_FUNCTION_TRACE("ex_name_segment");

	/*
	 * If first character is a digit, then we know that we aren't looking at a
	 * valid name segment
	 */
	char_buf[0] = *aml_address;

	if ('0' <= char_buf[0] && char_buf[0] <= '9') {
		ACPI_ERROR((AE_INFO, "Invalid leading digit: %c", char_buf[0]));
		return_ACPI_STATUS(AE_CTRL_PENDING);
	}

	ACPI_DEBUG_PRINT((ACPI_DB_LOAD, "Bytes from stream:\n"));

	for (index = 0;
	     (index < ACPI_NAME_SIZE)
	     && (acpi_ut_valid_acpi_character(*aml_address)); index++) {
		char_buf[index] = *aml_address++;
		ACPI_DEBUG_PRINT((ACPI_DB_LOAD, "%c\n", char_buf[index]));
	}

	/* Valid name segment  */

	if (index == 4) {
		/* Found 4 valid characters */

		char_buf[4] = '\0';

		if (name_string) {
			ACPI_STRCAT(name_string, char_buf);
			ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
					  "Appended to - %s\n", name_string));
		} else {
			ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
					  "No Name string - %s\n", char_buf));
		}
	} else if (index == 0) {
		/*
		 * First character was not a valid name character,
		 * so we are looking at something other than a name.
		 */
		ACPI_DEBUG_PRINT((ACPI_DB_INFO,
				  "Leading character is not alpha: %02Xh (not a name)\n",
				  char_buf[0]));
		status = AE_CTRL_PENDING;
	} else {
		/*
		 * Segment started with one or more valid characters, but fewer than
		 * the required 4
		 */
		status = AE_AML_BAD_NAME;
		ACPI_ERROR((AE_INFO,
			    "Bad character %02x in name, at %p",
			    *aml_address, aml_address));
	}

	*in_aml_address = ACPI_CAST_PTR(u8, aml_address);
	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_get_name_string
 *
 * PARAMETERS:  data_type           - Object type to be associated with this
 *                                    name
 *              in_aml_address      - Pointer to the namestring in the AML code
 *              out_name_string     - Where the namestring is returned
 *              out_name_length     - Length of the returned string
 *
 * RETURN:      Status, namestring and length
 *
 * DESCRIPTION: Extract a full namepath from the AML byte stream,
 *              including any prefixes.
 *
 ******************************************************************************/

acpi_status
acpi_ex_get_name_string(acpi_object_type data_type,
			u8 * in_aml_address,
			char **out_name_string, u32 * out_name_length)
{
	acpi_status status = AE_OK;
	u8 *aml_address = in_aml_address;
	char *name_string = NULL;
	u32 num_segments;
	u32 prefix_count = 0;
	u8 has_prefix = FALSE;

	ACPI_FUNCTION_TRACE_PTR("ex_get_name_string", aml_address);

	if (ACPI_TYPE_LOCAL_REGION_FIELD == data_type ||
	    ACPI_TYPE_LOCAL_BANK_FIELD == data_type ||
	    ACPI_TYPE_LOCAL_INDEX_FIELD == data_type) {
		/* Disallow prefixes for types associated with field_unit names */

		name_string = acpi_ex_allocate_name_string(0, 1);
		if (!name_string) {
			status = AE_NO_MEMORY;
		} else {
			status =
			    acpi_ex_name_segment(&aml_address, name_string);
		}
	} else {
		/*
		 * data_type is not a field name.
		 * Examine first character of name for root or parent prefix operators
		 */
		switch (*aml_address) {
		case AML_ROOT_PREFIX:

			ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
					  "root_prefix(\\) at %p\n",
					  aml_address));

			/*
			 * Remember that we have a root_prefix --
			 * see comment in acpi_ex_allocate_name_string()
			 */
			aml_address++;
			prefix_count = ACPI_UINT32_MAX;
			has_prefix = TRUE;
			break;

		case AML_PARENT_PREFIX:

			/* Increment past possibly multiple parent prefixes */

			do {
				ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
						  "parent_prefix (^) at %p\n",
						  aml_address));

				aml_address++;
				prefix_count++;

			} while (*aml_address == AML_PARENT_PREFIX);

			has_prefix = TRUE;
			break;

		default:

			/* Not a prefix character */

			break;
		}

		/* Examine first character of name for name segment prefix operator */

		switch (*aml_address) {
		case AML_DUAL_NAME_PREFIX:

			ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
					  "dual_name_prefix at %p\n",
					  aml_address));

			aml_address++;
			name_string =
			    acpi_ex_allocate_name_string(prefix_count, 2);
			if (!name_string) {
				status = AE_NO_MEMORY;
				break;
			}

			/* Indicate that we processed a prefix */

			has_prefix = TRUE;

			status =
			    acpi_ex_name_segment(&aml_address, name_string);
			if (ACPI_SUCCESS(status)) {
				status =
				    acpi_ex_name_segment(&aml_address,
							 name_string);
			}
			break;

		case AML_MULTI_NAME_PREFIX_OP:

			ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
					  "multi_name_prefix at %p\n",
					  aml_address));

			/* Fetch count of segments remaining in name path */

			aml_address++;
			num_segments = *aml_address;

			name_string =
			    acpi_ex_allocate_name_string(prefix_count,
							 num_segments);
			if (!name_string) {
				status = AE_NO_MEMORY;
				break;
			}

			/* Indicate that we processed a prefix */

			aml_address++;
			has_prefix = TRUE;

			while (num_segments &&
			       (status =
				acpi_ex_name_segment(&aml_address,
						     name_string)) == AE_OK) {
				num_segments--;
			}

			break;

		case 0:

			/* null_name valid as of 8-12-98 ASL/AML Grammar Update */

			if (prefix_count == ACPI_UINT32_MAX) {
				ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
						  "name_seg is \"\\\" followed by NULL\n"));
			}

			/* Consume the NULL byte */

			aml_address++;
			name_string =
			    acpi_ex_allocate_name_string(prefix_count, 0);
			if (!name_string) {
				status = AE_NO_MEMORY;
				break;
			}

			break;

		default:

			/* Name segment string */

			name_string =
			    acpi_ex_allocate_name_string(prefix_count, 1);
			if (!name_string) {
				status = AE_NO_MEMORY;
				break;
			}

			status =
			    acpi_ex_name_segment(&aml_address, name_string);
			break;
		}
	}

	if (AE_CTRL_PENDING == status && has_prefix) {
		/* Ran out of segments after processing a prefix */

		ACPI_ERROR((AE_INFO, "Malformed Name at %p", name_string));
		status = AE_AML_BAD_NAME;
	}

	if (ACPI_FAILURE(status)) {
		if (name_string) {
			ACPI_MEM_FREE(name_string);
		}
		return_ACPI_STATUS(status);
	}

	*out_name_string = name_string;
	*out_name_length = (u32) (aml_address - in_aml_address);

	return_ACPI_STATUS(status);
}
Commit	Line	Data
1da177e4 LT	1
	2	/******************************************************************************
	3	*
	4	* Module Name: exnames - interpreter/scanner name load/execute
	5	*
	6	*****************************************************************************/
	7
	8	/*
4a90c7e8	9	* Copyright (C) 2000 - 2006, R. Byron Moore
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 LT	45	#include <acpi/acpi.h>
	46	#include <acpi/acinterp.h>
	47	#include <acpi/amlcode.h>
	48
	49	#define _COMPONENT ACPI_EXECUTER
4be44fcd	50	ACPI_MODULE_NAME("exnames")
1da177e4	51
44f6c012	52	/* Local prototypes */
4be44fcd	53	static char *acpi_ex_allocate_name_string(u32 prefix_count, u32 num_name_segs);
1da177e4	54
44f6c012	55	static acpi_status
4be44fcd	56	acpi_ex_name_segment(u8 ** in_aml_address, char *name_string);
1da177e4 LT	57
	58	/*******************************************************************************
	59	*
	60	* FUNCTION: acpi_ex_allocate_name_string
	61	*
	62	* PARAMETERS: prefix_count - Count of parent levels. Special cases:
44f6c012	63	* (-1)==root, 0==none
1da177e4 LT	64	* num_name_segs - count of 4-character name segments
	65	*
	66	* RETURN: A pointer to the allocated string segment. This segment must
	67	* be deleted by the caller.
	68	*
	69	* DESCRIPTION: Allocate a buffer for a name string. Ensure allocated name
	70	* string is long enough, and set up prefix if any.
	71	*
	72	******************************************************************************/
	73
4be44fcd	74	static char *acpi_ex_allocate_name_string(u32 prefix_count, u32 num_name_segs)
1da177e4	75	{
4be44fcd LB	76	char *temp_ptr;
	77	char *name_string;
	78	u32 size_needed;
1da177e4	79
4be44fcd	80	ACPI_FUNCTION_TRACE("ex_allocate_name_string");
1da177e4 LT	81
1da177e4 LT	82	/*
44f6c012	83	* Allow room for all \ and ^ prefixes, all segments and a multi_name_prefix.
1da177e4 LT	84	* Also, one byte for the null terminator.
	85	* This may actually be somewhat longer than needed.
	86	*/
	87	if (prefix_count == ACPI_UINT32_MAX) {
	88	/* Special case for root */
	89
	90	size_needed = 1 + (ACPI_NAME_SIZE * num_name_segs) + 2 + 1;
4be44fcd LB	91	} else {
	92	size_needed =
	93	prefix_count + (ACPI_NAME_SIZE * num_name_segs) + 2 + 1;
1da177e4 LT	94	}
	95
	96	/*
	97	* Allocate a buffer for the name.
	98	* This buffer must be deleted by the caller!
	99	*/
4be44fcd	100	name_string = ACPI_MEM_ALLOCATE(size_needed);
1da177e4	101	if (!name_string) {
b8e4d893 BM	102	ACPI_ERROR((AE_INFO,
b8e4d893 BM	103	"Could not allocate size %d", size_needed));
4be44fcd	104	return_PTR(NULL);
1da177e4 LT	105	}
	106
	107	temp_ptr = name_string;
	108
	109	/* Set up Root or Parent prefixes if needed */
	110
	111	if (prefix_count == ACPI_UINT32_MAX) {
	112	*temp_ptr++ = AML_ROOT_PREFIX;
4be44fcd	113	} else {
1da177e4 LT	114	while (prefix_count--) {
	115	*temp_ptr++ = AML_PARENT_PREFIX;
	116	}
	117	}
	118
1da177e4 LT	119	/* Set up Dual or Multi prefixes if needed */
	120
	121	if (num_name_segs > 2) {
	122	/* Set up multi prefixes */
	123
	124	*temp_ptr++ = AML_MULTI_NAME_PREFIX_OP;
4be44fcd LB	125	*temp_ptr++ = (char)num_name_segs;
4be44fcd LB	126	} else if (2 == num_name_segs) {
1da177e4 LT	127	/* Set up dual prefixes */
	128
	129	*temp_ptr++ = AML_DUAL_NAME_PREFIX;
	130	}
	131
	132	/*
	133	* Terminate string following prefixes. acpi_ex_name_segment() will
	134	* append the segment(s)
	135	*/
	136	*temp_ptr = 0;
	137
4be44fcd	138	return_PTR(name_string);
1da177e4 LT	139	}
	140
	141	/*******************************************************************************
	142	*
	143	* FUNCTION: acpi_ex_name_segment
	144	*
44f6c012 RM	145	* PARAMETERS: in_aml_address - Pointer to the name in the AML code
	146	* name_string - Where to return the name. The name is appended
	147	* to any existing string to form a namepath
1da177e4 LT	148	*
	149	* RETURN: Status
	150	*
44f6c012	151	* DESCRIPTION: Extract an ACPI name (4 bytes) from the AML byte stream
1da177e4 LT	152	*
	153	******************************************************************************/
	154
4be44fcd	155	static acpi_status acpi_ex_name_segment(u8 ** in_aml_address, char *name_string)
1da177e4	156	{
4be44fcd LB	157	char aml_address = (void )*in_aml_address;
	158	acpi_status status = AE_OK;
	159	u32 index;
	160	char char_buf[5];
1da177e4	161
4be44fcd	162	ACPI_FUNCTION_TRACE("ex_name_segment");
1da177e4 LT	163
	164	/*
	165	* If first character is a digit, then we know that we aren't looking at a
	166	* valid name segment
	167	*/
	168	char_buf[0] = *aml_address;
	169
	170	if ('0' <= char_buf[0] && char_buf[0] <= '9') {
b8e4d893	171	ACPI_ERROR((AE_INFO, "Invalid leading digit: %c", char_buf[0]));
4be44fcd	172	return_ACPI_STATUS(AE_CTRL_PENDING);
1da177e4 LT	173	}
1da177e4 LT	174
4be44fcd	175	ACPI_DEBUG_PRINT((ACPI_DB_LOAD, "Bytes from stream:\n"));
1da177e4 LT	176
1da177e4 LT	177	for (index = 0;
4be44fcd LB	178	(index < ACPI_NAME_SIZE)
4be44fcd LB	179	&& (acpi_ut_valid_acpi_character(*aml_address)); index++) {
1da177e4	180	char_buf[index] = *aml_address++;
4be44fcd	181	ACPI_DEBUG_PRINT((ACPI_DB_LOAD, "%c\n", char_buf[index]));
1da177e4 LT	182	}
1da177e4 LT	183
1da177e4 LT	184	/* Valid name segment */
	185
	186	if (index == 4) {
	187	/* Found 4 valid characters */
	188
	189	char_buf[4] = '\0';
	190
	191	if (name_string) {
4be44fcd LB	192	ACPI_STRCAT(name_string, char_buf);
4be44fcd LB	193	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
50eca3eb	194	"Appended to - %s\n", name_string));
4be44fcd LB	195	} else {
4be44fcd LB	196	ACPI_DEBUG_PRINT((ACPI_DB_NAMES,
50eca3eb	197	"No Name string - %s\n", char_buf));
1da177e4	198	}
4be44fcd	199	} else if (index == 0) {
1da177e4 LT	200	/*
	201	* First character was not a valid name character,
	202	* so we are looking at something other than a name.
	203	*/
4be44fcd LB	204	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
	205	"Leading character is not alpha: %02Xh (not a name)\n",
	206	char_buf[0]));
1da177e4	207	status = AE_CTRL_PENDING;
4be44fcd	208	} else {
44f6c012 RM	209	/*
	210	* Segment started with one or more valid characters, but fewer than
	211	* the required 4
	212	*/
1da177e4	213	status = AE_AML_BAD_NAME;
b8e4d893 BM	214	ACPI_ERROR((AE_INFO,
	215	"Bad character %02x in name, at %p",
	216	*aml_address, aml_address));
1da177e4 LT	217	}
1da177e4 LT	218
c51a4de8	219	*in_aml_address = ACPI_CAST_PTR(u8, aml_address);
4be44fcd	220	return_ACPI_STATUS(status);
1da177e4 LT	221	}
1da177e4 LT	222
1da177e4 LT	223	/*******************************************************************************
	224	*
	225	* FUNCTION: acpi_ex_get_name_string
	226	*
44f6c012 RM	227	* PARAMETERS: data_type - Object type to be associated with this
	228	* name
	229	* in_aml_address - Pointer to the namestring in the AML code
	230	* out_name_string - Where the namestring is returned
	231	* out_name_length - Length of the returned string
1da177e4	232	*
44f6c012	233	* RETURN: Status, namestring and length
1da177e4	234	*
44f6c012 RM	235	* DESCRIPTION: Extract a full namepath from the AML byte stream,
44f6c012 RM	236	* including any prefixes.
1da177e4 LT	237	*
	238	******************************************************************************/
	239
	240	acpi_status
4be44fcd LB	241	acpi_ex_get_name_string(acpi_object_type data_type,
	242	u8 * in_aml_address,
	243	char *out_name_string, u32 out_name_length)
1da177e4	244	{
4be44fcd LB	245	acpi_status status = AE_OK;
	246	u8 *aml_address = in_aml_address;
	247	char *name_string = NULL;
	248	u32 num_segments;
	249	u32 prefix_count = 0;
	250	u8 has_prefix = FALSE;
	251
	252	ACPI_FUNCTION_TRACE_PTR("ex_get_name_string", aml_address);
	253
	254	if (ACPI_TYPE_LOCAL_REGION_FIELD == data_type \|\|
	255	ACPI_TYPE_LOCAL_BANK_FIELD == data_type \|\|
	256	ACPI_TYPE_LOCAL_INDEX_FIELD == data_type) {
1da177e4 LT	257	/* Disallow prefixes for types associated with field_unit names */
1da177e4 LT	258
4be44fcd	259	name_string = acpi_ex_allocate_name_string(0, 1);
1da177e4 LT	260	if (!name_string) {
1da177e4 LT	261	status = AE_NO_MEMORY;
4be44fcd LB	262	} else {
	263	status =
	264	acpi_ex_name_segment(&aml_address, name_string);
1da177e4	265	}
4be44fcd	266	} else {
1da177e4 LT	267	/*
	268	* data_type is not a field name.
	269	* Examine first character of name for root or parent prefix operators
	270	*/
	271	switch (*aml_address) {
	272	case AML_ROOT_PREFIX:
	273
4be44fcd LB	274	ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
	275	"root_prefix(\\) at %p\n",
	276	aml_address));
1da177e4 LT	277
	278	/*
	279	* Remember that we have a root_prefix --
	280	* see comment in acpi_ex_allocate_name_string()
	281	*/
	282	aml_address++;
	283	prefix_count = ACPI_UINT32_MAX;
	284	has_prefix = TRUE;
	285	break;
	286
1da177e4 LT	287	case AML_PARENT_PREFIX:
	288
	289	/* Increment past possibly multiple parent prefixes */
	290
	291	do {
4be44fcd LB	292	ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
	293	"parent_prefix (^) at %p\n",
	294	aml_address));
1da177e4 LT	295
	296	aml_address++;
	297	prefix_count++;
	298
	299	} while (*aml_address == AML_PARENT_PREFIX);
	300
	301	has_prefix = TRUE;
	302	break;
	303
1da177e4 LT	304	default:
	305
	306	/* Not a prefix character */
	307
	308	break;
	309	}
	310
1da177e4 LT	311	/* Examine first character of name for name segment prefix operator */
	312
	313	switch (*aml_address) {
	314	case AML_DUAL_NAME_PREFIX:
	315
4be44fcd LB	316	ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
	317	"dual_name_prefix at %p\n",
	318	aml_address));
1da177e4 LT	319
1da177e4 LT	320	aml_address++;
4be44fcd LB	321	name_string =
4be44fcd LB	322	acpi_ex_allocate_name_string(prefix_count, 2);
1da177e4 LT	323	if (!name_string) {
	324	status = AE_NO_MEMORY;
	325	break;
	326	}
	327
	328	/* Indicate that we processed a prefix */
	329
	330	has_prefix = TRUE;
	331
4be44fcd LB	332	status =
	333	acpi_ex_name_segment(&aml_address, name_string);
	334	if (ACPI_SUCCESS(status)) {
	335	status =
	336	acpi_ex_name_segment(&aml_address,
	337	name_string);
1da177e4 LT	338	}
	339	break;
	340
1da177e4 LT	341	case AML_MULTI_NAME_PREFIX_OP:
1da177e4 LT	342
4be44fcd LB	343	ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
	344	"multi_name_prefix at %p\n",
	345	aml_address));
1da177e4 LT	346
	347	/* Fetch count of segments remaining in name path */
	348
	349	aml_address++;
	350	num_segments = *aml_address;
	351
4be44fcd LB	352	name_string =
	353	acpi_ex_allocate_name_string(prefix_count,
	354	num_segments);
1da177e4 LT	355	if (!name_string) {
	356	status = AE_NO_MEMORY;
	357	break;
	358	}
	359
	360	/* Indicate that we processed a prefix */
	361
	362	aml_address++;
	363	has_prefix = TRUE;
	364
	365	while (num_segments &&
4be44fcd LB	366	(status =
	367	acpi_ex_name_segment(&aml_address,
	368	name_string)) == AE_OK) {
1da177e4 LT	369	num_segments--;
	370	}
	371
	372	break;
	373
1da177e4 LT	374	case 0:
	375
	376	/* null_name valid as of 8-12-98 ASL/AML Grammar Update */
	377
	378	if (prefix_count == ACPI_UINT32_MAX) {
4be44fcd LB	379	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
4be44fcd LB	380	"name_seg is \"\\\" followed by NULL\n"));
1da177e4 LT	381	}
	382
	383	/* Consume the NULL byte */
	384
	385	aml_address++;
4be44fcd LB	386	name_string =
4be44fcd LB	387	acpi_ex_allocate_name_string(prefix_count, 0);
1da177e4 LT	388	if (!name_string) {
	389	status = AE_NO_MEMORY;
	390	break;
	391	}
	392
	393	break;
	394
1da177e4 LT	395	default:
	396
	397	/* Name segment string */
	398
4be44fcd LB	399	name_string =
4be44fcd LB	400	acpi_ex_allocate_name_string(prefix_count, 1);
1da177e4 LT	401	if (!name_string) {
	402	status = AE_NO_MEMORY;
	403	break;
	404	}
	405
4be44fcd LB	406	status =
4be44fcd LB	407	acpi_ex_name_segment(&aml_address, name_string);
1da177e4 LT	408	break;
	409	}
	410	}
	411
	412	if (AE_CTRL_PENDING == status && has_prefix) {
	413	/* Ran out of segments after processing a prefix */
	414
b8e4d893	415	ACPI_ERROR((AE_INFO, "Malformed Name at %p", name_string));
1da177e4 LT	416	status = AE_AML_BAD_NAME;
	417	}
	418
4be44fcd	419	if (ACPI_FAILURE(status)) {
88ac00f5	420	if (name_string) {
4be44fcd	421	ACPI_MEM_FREE(name_string);
88ac00f5	422	}
4be44fcd	423	return_ACPI_STATUS(status);
88ac00f5 RM	424	}
88ac00f5 RM	425
1da177e4 LT	426	*out_name_string = name_string;
	427	*out_name_length = (u32) (aml_address - in_aml_address);
	428
4be44fcd	429	return_ACPI_STATUS(status);
1da177e4	430	}