[deliverable/linux.git] / drivers / acpi / parser / psutils.c

/******************************************************************************
 *
 * Module Name: psutils - Parser miscellaneous utilities (Parser only)
 *
 *****************************************************************************/

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

#define _COMPONENT          ACPI_PARSER
	 ACPI_MODULE_NAME    ("psutils")


/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_create_scope_op
 *
 * PARAMETERS:  None
 *
 * RETURN:      A new Scope object, null on failure
 *
 * DESCRIPTION: Create a Scope and associated namepath op with the root name
 *
 ******************************************************************************/

union acpi_parse_object *
acpi_ps_create_scope_op (
	void)
{
	union acpi_parse_object         *scope_op;


	scope_op = acpi_ps_alloc_op (AML_SCOPE_OP);
	if (!scope_op) {
		return (NULL);
	}

	scope_op->named.name = ACPI_ROOT_NAME;
	return (scope_op);
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_init_op
 *
 * PARAMETERS:  Op              - A newly allocated Op object
 *              Opcode          - Opcode to store in the Op
 *
 * RETURN:      None
 *
 * DESCRIPTION: Initialize a parse (Op) object
 *
 ******************************************************************************/

void
acpi_ps_init_op (
	union acpi_parse_object         *op,
	u16                             opcode)
{
	ACPI_FUNCTION_ENTRY ();


	op->common.data_type = ACPI_DESC_TYPE_PARSER;
	op->common.aml_opcode = opcode;

	ACPI_DISASM_ONLY_MEMBERS (ACPI_STRNCPY (op->common.aml_op_name,
			(acpi_ps_get_opcode_info (opcode))->name,
				sizeof (op->common.aml_op_name)));
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_alloc_op
 *
 * PARAMETERS:  Opcode          - Opcode that will be stored in the new Op
 *
 * RETURN:      Pointer to the new Op, null on failure
 *
 * DESCRIPTION: Allocate an acpi_op, choose op type (and thus size) based on
 *              opcode.  A cache of opcodes is available for the pure
 *              GENERIC_OP, since this is by far the most commonly used.
 *
 ******************************************************************************/

union acpi_parse_object*
acpi_ps_alloc_op (
	u16                             opcode)
{
	union acpi_parse_object         *op;
	const struct acpi_opcode_info   *op_info;
	u8                              flags = ACPI_PARSEOP_GENERIC;


	ACPI_FUNCTION_ENTRY ();


	op_info = acpi_ps_get_opcode_info (opcode);

	/* Determine type of parse_op required */

	if (op_info->flags & AML_DEFER) {
		flags = ACPI_PARSEOP_DEFERRED;
	}
	else if (op_info->flags & AML_NAMED) {
		flags = ACPI_PARSEOP_NAMED;
	}
	else if (opcode == AML_INT_BYTELIST_OP) {
		flags = ACPI_PARSEOP_BYTELIST;
	}

	/* Allocate the minimum required size object */

	if (flags == ACPI_PARSEOP_GENERIC) {
		/* The generic op (default) is by far the most common (16 to 1) */

		op = acpi_os_acquire_object (acpi_gbl_ps_node_cache);
		memset(op, 0, sizeof(struct acpi_parse_obj_common));
	}
	else {
		/* Extended parseop */

		op = acpi_os_acquire_object (acpi_gbl_ps_node_ext_cache);
		memset(op, 0, sizeof(struct acpi_parse_obj_named));
	}

	/* Initialize the Op */

	if (op) {
		acpi_ps_init_op (op, opcode);
		op->common.flags = flags;
	}

	return (op);
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_free_op
 *
 * PARAMETERS:  Op              - Op to be freed
 *
 * RETURN:      None.
 *
 * DESCRIPTION: Free an Op object.  Either put it on the GENERIC_OP cache list
 *              or actually free it.
 *
 ******************************************************************************/

void
acpi_ps_free_op (
	union acpi_parse_object         *op)
{
	ACPI_FUNCTION_NAME ("ps_free_op");


	if (op->common.aml_opcode == AML_INT_RETURN_VALUE_OP) {
		ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Free retval op: %p\n", op));
	}

	if (op->common.flags & ACPI_PARSEOP_GENERIC) {
		(void) acpi_os_release_object (acpi_gbl_ps_node_cache, op);
	}
	else {
		(void) acpi_os_release_object (acpi_gbl_ps_node_ext_cache, op);
	}
}


/*******************************************************************************
 *
 * FUNCTION:    Utility functions
 *
 * DESCRIPTION: Low level character and object functions
 *
 ******************************************************************************/


/*
 * Is "c" a namestring lead character?
 */
u8
acpi_ps_is_leading_char (
	u32                             c)
{
	return ((u8) (c == '_' || (c >= 'A' && c <= 'Z')));
}


/*
 * Is "c" a namestring prefix character?
 */
u8
acpi_ps_is_prefix_char (
	u32                             c)
{
	return ((u8) (c == '\\' || c == '^'));
}


/*
 * Get op's name (4-byte name segment) or 0 if unnamed
 */
#ifdef ACPI_FUTURE_USAGE
u32
acpi_ps_get_name (
	union acpi_parse_object         *op)
{

	/* The "generic" object has no name associated with it */

	if (op->common.flags & ACPI_PARSEOP_GENERIC) {
		return (0);
	}

	/* Only the "Extended" parse objects have a name */

	return (op->named.name);
}
#endif  /*  ACPI_FUTURE_USAGE  */


/*
 * Set op's name
 */
void
acpi_ps_set_name (
	union acpi_parse_object         *op,
	u32                             name)
{

	/* The "generic" object has no name associated with it */

	if (op->common.flags & ACPI_PARSEOP_GENERIC) {
		return;
	}

	op->named.name = name;
}
Commit	Line	Data
1da177e4 LT	1	/******************************************************************************
	2	*
	3	* Module Name: psutils - Parser miscellaneous utilities (Parser only)
	4	*
	5	*****************************************************************************/
	6
	7	/*
	8	* Copyright (C) 2000 - 2005, R. Byron Moore
	9	* All rights reserved.
	10	*
	11	* Redistribution and use in source and binary forms, with or without
	12	* modification, are permitted provided that the following conditions
	13	* are met:
	14	* 1. Redistributions of source code must retain the above copyright
	15	* notice, this list of conditions, and the following disclaimer,
	16	* without modification.
	17	* 2. Redistributions in binary form must reproduce at minimum a disclaimer
	18	* substantially similar to the "NO WARRANTY" disclaimer below
	19	* ("Disclaimer") and any redistribution must be conditioned upon
	20	* including a substantially similar Disclaimer requirement for further
	21	* binary redistribution.
	22	* 3. Neither the names of the above-listed copyright holders nor the names
	23	* of any contributors may be used to endorse or promote products derived
	24	* from this software without specific prior written permission.
	25	*
	26	* Alternatively, this software may be distributed under the terms of the
	27	* GNU General Public License ("GPL") version 2 as published by the Free
	28	* Software Foundation.
	29	*
	30	* NO WARRANTY
	31	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	32	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	33	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
	34	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	35	* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	36	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	37	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	38	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	39	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	40	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	41	* POSSIBILITY OF SUCH DAMAGES.
	42	*/
	43
	44
	45	#include <acpi/acpi.h>
	46	#include <acpi/acparser.h>
	47	#include <acpi/amlcode.h>
1da177e4 LT	48
	49	#define _COMPONENT ACPI_PARSER
	50	ACPI_MODULE_NAME ("psutils")
	51
	52
	53	/*******************************************************************************
	54	*
	55	* FUNCTION: acpi_ps_create_scope_op
	56	*
	57	* PARAMETERS: None
	58	*
44f6c012	59	* RETURN: A new Scope object, null on failure
1da177e4 LT	60	*
	61	* DESCRIPTION: Create a Scope and associated namepath op with the root name
	62	*
	63	******************************************************************************/
	64
	65	union acpi_parse_object *
	66	acpi_ps_create_scope_op (
	67	void)
	68	{
	69	union acpi_parse_object *scope_op;
	70
	71
	72	scope_op = acpi_ps_alloc_op (AML_SCOPE_OP);
	73	if (!scope_op) {
	74	return (NULL);
	75	}
	76
1da177e4 LT	77	scope_op->named.name = ACPI_ROOT_NAME;
	78	return (scope_op);
	79	}
	80
	81
	82	/*******************************************************************************
	83	*
	84	* FUNCTION: acpi_ps_init_op
	85	*
	86	* PARAMETERS: Op - A newly allocated Op object
	87	* Opcode - Opcode to store in the Op
	88	*
44f6c012	89	* RETURN: None
1da177e4	90	*
44f6c012	91	* DESCRIPTION: Initialize a parse (Op) object
1da177e4 LT	92	*
	93	******************************************************************************/
	94
	95	void
	96	acpi_ps_init_op (
	97	union acpi_parse_object *op,
	98	u16 opcode)
	99	{
	100	ACPI_FUNCTION_ENTRY ();
	101
	102
	103	op->common.data_type = ACPI_DESC_TYPE_PARSER;
	104	op->common.aml_opcode = opcode;
	105
	106	ACPI_DISASM_ONLY_MEMBERS (ACPI_STRNCPY (op->common.aml_op_name,
44f6c012 RM	107	(acpi_ps_get_opcode_info (opcode))->name,
44f6c012 RM	108	sizeof (op->common.aml_op_name)));
1da177e4 LT	109	}
	110
	111
	112	/*******************************************************************************
	113	*
	114	* FUNCTION: acpi_ps_alloc_op
	115	*
	116	* PARAMETERS: Opcode - Opcode that will be stored in the new Op
	117	*
44f6c012	118	* RETURN: Pointer to the new Op, null on failure
1da177e4 LT	119	*
	120	* DESCRIPTION: Allocate an acpi_op, choose op type (and thus size) based on
	121	* opcode. A cache of opcodes is available for the pure
	122	* GENERIC_OP, since this is by far the most commonly used.
	123	*
	124	******************************************************************************/
	125
	126	union acpi_parse_object*
	127	acpi_ps_alloc_op (
	128	u16 opcode)
	129	{
	130	union acpi_parse_object *op;
	131	const struct acpi_opcode_info *op_info;
	132	u8 flags = ACPI_PARSEOP_GENERIC;
	133
	134
	135	ACPI_FUNCTION_ENTRY ();
	136
	137
	138	op_info = acpi_ps_get_opcode_info (opcode);
	139
	140	/* Determine type of parse_op required */
	141
	142	if (op_info->flags & AML_DEFER) {
	143	flags = ACPI_PARSEOP_DEFERRED;
	144	}
	145	else if (op_info->flags & AML_NAMED) {
	146	flags = ACPI_PARSEOP_NAMED;
	147	}
	148	else if (opcode == AML_INT_BYTELIST_OP) {
	149	flags = ACPI_PARSEOP_BYTELIST;
	150	}
	151
	152	/* Allocate the minimum required size object */
	153
	154	if (flags == ACPI_PARSEOP_GENERIC) {
	155	/* The generic op (default) is by far the most common (16 to 1) */
	156
73459f73 RM	157	op = acpi_os_acquire_object (acpi_gbl_ps_node_cache);
73459f73 RM	158	memset(op, 0, sizeof(struct acpi_parse_obj_common));
1da177e4 LT	159	}
	160	else {
	161	/* Extended parseop */
	162
73459f73 RM	163	op = acpi_os_acquire_object (acpi_gbl_ps_node_ext_cache);
73459f73 RM	164	memset(op, 0, sizeof(struct acpi_parse_obj_named));
1da177e4 LT	165	}
	166
	167	/* Initialize the Op */
	168
	169	if (op) {
	170	acpi_ps_init_op (op, opcode);
	171	op->common.flags = flags;
	172	}
	173
	174	return (op);
	175	}
	176
	177
	178	/*******************************************************************************
	179	*
	180	* FUNCTION: acpi_ps_free_op
	181	*
	182	* PARAMETERS: Op - Op to be freed
	183	*
	184	* RETURN: None.
	185	*
	186	* DESCRIPTION: Free an Op object. Either put it on the GENERIC_OP cache list
	187	* or actually free it.
	188	*
	189	******************************************************************************/
	190
	191	void
	192	acpi_ps_free_op (
	193	union acpi_parse_object *op)
	194	{
	195	ACPI_FUNCTION_NAME ("ps_free_op");
	196
	197
	198	if (op->common.aml_opcode == AML_INT_RETURN_VALUE_OP) {
	199	ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Free retval op: %p\n", op));
	200	}
	201
	202	if (op->common.flags & ACPI_PARSEOP_GENERIC) {
0c9938cc	203	(void) acpi_os_release_object (acpi_gbl_ps_node_cache, op);
1da177e4 LT	204	}
1da177e4 LT	205	else {
0c9938cc	206	(void) acpi_os_release_object (acpi_gbl_ps_node_ext_cache, op);
1da177e4 LT	207	}
	208	}
	209
	210
1da177e4 LT	211	/*******************************************************************************
	212	*
	213	* FUNCTION: Utility functions
	214	*
	215	* DESCRIPTION: Low level character and object functions
	216	*
	217	******************************************************************************/
	218
	219
	220	/*
	221	* Is "c" a namestring lead character?
	222	*/
	223	u8
	224	acpi_ps_is_leading_char (
	225	u32 c)
	226	{
	227	return ((u8) (c == '_' \|\| (c >= 'A' && c <= 'Z')));
	228	}
	229
	230
	231	/*
	232	* Is "c" a namestring prefix character?
	233	*/
	234	u8
	235	acpi_ps_is_prefix_char (
	236	u32 c)
	237	{
	238	return ((u8) (c == '\\' \|\| c == '^'));
	239	}
	240
	241
	242	/*
	243	* Get op's name (4-byte name segment) or 0 if unnamed
	244	*/
	245	#ifdef ACPI_FUTURE_USAGE
	246	u32
	247	acpi_ps_get_name (
	248	union acpi_parse_object *op)
	249	{
	250
1da177e4 LT	251	/* The "generic" object has no name associated with it */
	252
	253	if (op->common.flags & ACPI_PARSEOP_GENERIC) {
	254	return (0);
	255	}
	256
	257	/* Only the "Extended" parse objects have a name */
	258
	259	return (op->named.name);
	260	}
	261	#endif /* ACPI_FUTURE_USAGE */
	262
	263
	264	/*
	265	* Set op's name
	266	*/
	267	void
	268	acpi_ps_set_name (
	269	union acpi_parse_object *op,
	270	u32 name)
	271	{
	272
	273	/* The "generic" object has no name associated with it */
	274
	275	if (op->common.flags & ACPI_PARSEOP_GENERIC) {
	276	return;
	277	}
	278
	279	op->named.name = name;
	280	}
	281