[linux.git] / drivers / acpi / acpica / psobject.c

/******************************************************************************
 *
 * Module Name: psobject - Support for parse objects
 *
 *****************************************************************************/

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

#define _COMPONENT          ACPI_PARSER
ACPI_MODULE_NAME("psobject")

/* Local prototypes */
static acpi_status acpi_ps_get_aml_opcode(struct acpi_walk_state *walk_state);

/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_get_aml_opcode
 *
 * PARAMETERS:  walk_state          - Current state
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Extract the next AML opcode from the input stream.
 *
 ******************************************************************************/

static acpi_status acpi_ps_get_aml_opcode(struct acpi_walk_state *walk_state)
{

	ACPI_FUNCTION_TRACE_PTR(ps_get_aml_opcode, walk_state);

	walk_state->aml_offset =
	    (u32)ACPI_PTR_DIFF(walk_state->parser_state.aml,
			       walk_state->parser_state.aml_start);
	walk_state->opcode = acpi_ps_peek_opcode(&(walk_state->parser_state));

	/*
	 * First cut to determine what we have found:
	 * 1) A valid AML opcode
	 * 2) A name string
	 * 3) An unknown/invalid opcode
	 */
	walk_state->op_info = acpi_ps_get_opcode_info(walk_state->opcode);

	switch (walk_state->op_info->class) {
	case AML_CLASS_ASCII:
	case AML_CLASS_PREFIX:
		/*
		 * Starts with a valid prefix or ASCII char, this is a name
		 * string. Convert the bare name string to a namepath.
		 */
		walk_state->opcode = AML_INT_NAMEPATH_OP;
		walk_state->arg_types = ARGP_NAMESTRING;
		break;

	case AML_CLASS_UNKNOWN:

		/* The opcode is unrecognized. Complain and skip unknown opcodes */

		if (walk_state->pass_number == 2) {
			ACPI_ERROR((AE_INFO,
				    "Unknown opcode 0x%.2X at table offset 0x%.4X, ignoring",
				    walk_state->opcode,
				    (u32)(walk_state->aml_offset +
					  sizeof(struct acpi_table_header))));

			ACPI_DUMP_BUFFER((walk_state->parser_state.aml - 16),
					 48);

#ifdef ACPI_ASL_COMPILER
			/*
			 * This is executed for the disassembler only. Output goes
			 * to the disassembled ASL output file.
			 */
			acpi_os_printf
			    ("/*\nError: Unknown opcode 0x%.2X at table offset 0x%.4X, context:\n",
			     walk_state->opcode,
			     (u32)(walk_state->aml_offset +
				   sizeof(struct acpi_table_header)));

			/* Dump the context surrounding the invalid opcode */

			acpi_ut_dump_buffer(((u8 *)walk_state->parser_state.
					     aml - 16), 48, DB_BYTE_DISPLAY,
					    (walk_state->aml_offset +
					     sizeof(struct acpi_table_header) -
					     16));
			acpi_os_printf(" */\n");
#endif
		}

		/* Increment past one-byte or two-byte opcode */

		walk_state->parser_state.aml++;
		if (walk_state->opcode > 0xFF) {	/* Can only happen if first byte is 0x5B */
			walk_state->parser_state.aml++;
		}

		return_ACPI_STATUS(AE_CTRL_PARSE_CONTINUE);

	default:

		/* Found opcode info, this is a normal opcode */

		walk_state->parser_state.aml +=
		    acpi_ps_get_opcode_size(walk_state->opcode);
		walk_state->arg_types = walk_state->op_info->parse_args;
		break;
	}

	return_ACPI_STATUS(AE_OK);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_build_named_op
 *
 * PARAMETERS:  walk_state          - Current state
 *              aml_op_start        - Begin of named Op in AML
 *              unnamed_op          - Early Op (not a named Op)
 *              op                  - Returned Op
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Parse a named Op
 *
 ******************************************************************************/

acpi_status
acpi_ps_build_named_op(struct acpi_walk_state *walk_state,
		       u8 *aml_op_start,
		       union acpi_parse_object *unnamed_op,
		       union acpi_parse_object **op)
{
	acpi_status status = AE_OK;
	union acpi_parse_object *arg = NULL;

	ACPI_FUNCTION_TRACE_PTR(ps_build_named_op, walk_state);

	unnamed_op->common.value.arg = NULL;
	unnamed_op->common.arg_list_length = 0;
	unnamed_op->common.aml_opcode = walk_state->opcode;

	/*
	 * Get and append arguments until we find the node that contains
	 * the name (the type ARGP_NAME).
	 */
	while (GET_CURRENT_ARG_TYPE(walk_state->arg_types) &&
	       (GET_CURRENT_ARG_TYPE(walk_state->arg_types) != ARGP_NAME)) {
		status =
		    acpi_ps_get_next_arg(walk_state,
					 &(walk_state->parser_state),
					 GET_CURRENT_ARG_TYPE(walk_state->
							      arg_types), &arg);
		if (ACPI_FAILURE(status)) {
			return_ACPI_STATUS(status);
		}

		acpi_ps_append_arg(unnamed_op, arg);
		INCREMENT_ARG_LIST(walk_state->arg_types);
	}

	/*
	 * Make sure that we found a NAME and didn't run out of arguments
	 */
	if (!GET_CURRENT_ARG_TYPE(walk_state->arg_types)) {
		return_ACPI_STATUS(AE_AML_NO_OPERAND);
	}

	/* We know that this arg is a name, move to next arg */

	INCREMENT_ARG_LIST(walk_state->arg_types);

	/*
	 * Find the object. This will either insert the object into
	 * the namespace or simply look it up
	 */
	walk_state->op = NULL;

	status = walk_state->descending_callback(walk_state, op);
	if (ACPI_FAILURE(status)) {
		ACPI_EXCEPTION((AE_INFO, status, "During name lookup/catalog"));
		return_ACPI_STATUS(status);
	}

	if (!*op) {
		return_ACPI_STATUS(AE_CTRL_PARSE_CONTINUE);
	}

	status = acpi_ps_next_parse_state(walk_state, *op, status);
	if (ACPI_FAILURE(status)) {
		if (status == AE_CTRL_PENDING) {
			return_ACPI_STATUS(AE_CTRL_PARSE_PENDING);
		}
		return_ACPI_STATUS(status);
	}

	acpi_ps_append_arg(*op, unnamed_op->common.value.arg);

	if ((*op)->common.aml_opcode == AML_REGION_OP ||
	    (*op)->common.aml_opcode == AML_DATA_REGION_OP) {
		/*
		 * Defer final parsing of an operation_region body, because we don't
		 * have enough info in the first pass to parse it correctly (i.e.,
		 * there may be method calls within the term_arg elements of the body.)
		 *
		 * However, we must continue parsing because the opregion is not a
		 * standalone package -- we don't know where the end is at this point.
		 *
		 * (Length is unknown until parse of the body complete)
		 */
		(*op)->named.data = aml_op_start;
		(*op)->named.length = 0;
	}

	return_ACPI_STATUS(AE_OK);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_create_op
 *
 * PARAMETERS:  walk_state          - Current state
 *              aml_op_start        - Op start in AML
 *              new_op              - Returned Op
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Get Op from AML
 *
 ******************************************************************************/

acpi_status
acpi_ps_create_op(struct acpi_walk_state *walk_state,
		  u8 *aml_op_start, union acpi_parse_object **new_op)
{
	acpi_status status = AE_OK;
	union acpi_parse_object *op;
	union acpi_parse_object *named_op = NULL;
	union acpi_parse_object *parent_scope;
	u8 argument_count;
	const struct acpi_opcode_info *op_info;

	ACPI_FUNCTION_TRACE_PTR(ps_create_op, walk_state);

	status = acpi_ps_get_aml_opcode(walk_state);
	if (status == AE_CTRL_PARSE_CONTINUE) {
		return_ACPI_STATUS(AE_CTRL_PARSE_CONTINUE);
	}

	/* Create Op structure and append to parent's argument list */

	walk_state->op_info = acpi_ps_get_opcode_info(walk_state->opcode);
	op = acpi_ps_alloc_op(walk_state->opcode);
	if (!op) {
		return_ACPI_STATUS(AE_NO_MEMORY);
	}

	if (walk_state->op_info->flags & AML_NAMED) {
		status =
		    acpi_ps_build_named_op(walk_state, aml_op_start, op,
					   &named_op);
		acpi_ps_free_op(op);
		if (ACPI_FAILURE(status)) {
			return_ACPI_STATUS(status);
		}

		*new_op = named_op;
		return_ACPI_STATUS(AE_OK);
	}

	/* Not a named opcode, just allocate Op and append to parent */

	if (walk_state->op_info->flags & AML_CREATE) {
		/*
		 * Backup to beginning of create_XXXfield declaration
		 * body_length is unknown until we parse the body
		 */
		op->named.data = aml_op_start;
		op->named.length = 0;
	}

	if (walk_state->opcode == AML_BANK_FIELD_OP) {
		/*
		 * Backup to beginning of bank_field declaration
		 * body_length is unknown until we parse the body
		 */
		op->named.data = aml_op_start;
		op->named.length = 0;
	}

	parent_scope = acpi_ps_get_parent_scope(&(walk_state->parser_state));
	acpi_ps_append_arg(parent_scope, op);

	if (parent_scope) {
		op_info =
		    acpi_ps_get_opcode_info(parent_scope->common.aml_opcode);
		if (op_info->flags & AML_HAS_TARGET) {
			argument_count =
			    acpi_ps_get_argument_count(op_info->type);
			if (parent_scope->common.arg_list_length >
			    argument_count) {
				op->common.flags |= ACPI_PARSEOP_TARGET;
			}
		} else if (parent_scope->common.aml_opcode == AML_INCREMENT_OP) {
			op->common.flags |= ACPI_PARSEOP_TARGET;
		}
	}

	if (walk_state->descending_callback != NULL) {
		/*
		 * Find the object. This will either insert the object into
		 * the namespace or simply look it up
		 */
		walk_state->op = *new_op = op;

		status = walk_state->descending_callback(walk_state, &op);
		status = acpi_ps_next_parse_state(walk_state, op, status);
		if (status == AE_CTRL_PENDING) {
			status = AE_CTRL_PARSE_PENDING;
		}
	}

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_complete_op
 *
 * PARAMETERS:  walk_state          - Current state
 *              op                  - Returned Op
 *              status              - Parse status before complete Op
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Complete Op
 *
 ******************************************************************************/

acpi_status
acpi_ps_complete_op(struct acpi_walk_state *walk_state,
		    union acpi_parse_object **op, acpi_status status)
{
	acpi_status status2;

	ACPI_FUNCTION_TRACE_PTR(ps_complete_op, walk_state);

	/*
	 * Finished one argument of the containing scope
	 */
	walk_state->parser_state.scope->parse_scope.arg_count--;

	/* Close this Op (will result in parse subtree deletion) */

	status2 = acpi_ps_complete_this_op(walk_state, *op);
	if (ACPI_FAILURE(status2)) {
		return_ACPI_STATUS(status2);
	}

	*op = NULL;

	switch (status) {
	case AE_OK:

		break;

	case AE_CTRL_TRANSFER:

		/* We are about to transfer to a called method */

		walk_state->prev_op = NULL;
		walk_state->prev_arg_types = walk_state->arg_types;
		return_ACPI_STATUS(status);

	case AE_CTRL_END:

		acpi_ps_pop_scope(&(walk_state->parser_state), op,
				  &walk_state->arg_types,
				  &walk_state->arg_count);

		if (*op) {
			walk_state->op = *op;
			walk_state->op_info =
			    acpi_ps_get_opcode_info((*op)->common.aml_opcode);
			walk_state->opcode = (*op)->common.aml_opcode;

			status = walk_state->ascending_callback(walk_state);
			status =
			    acpi_ps_next_parse_state(walk_state, *op, status);

			status2 = acpi_ps_complete_this_op(walk_state, *op);
			if (ACPI_FAILURE(status2)) {
				return_ACPI_STATUS(status2);
			}
		}

		status = AE_OK;
		break;

	case AE_CTRL_BREAK:
	case AE_CTRL_CONTINUE:

		/* Pop off scopes until we find the While */

		while (!(*op) || ((*op)->common.aml_opcode != AML_WHILE_OP)) {
			acpi_ps_pop_scope(&(walk_state->parser_state), op,
					  &walk_state->arg_types,
					  &walk_state->arg_count);
		}

		/* Close this iteration of the While loop */

		walk_state->op = *op;
		walk_state->op_info =
		    acpi_ps_get_opcode_info((*op)->common.aml_opcode);
		walk_state->opcode = (*op)->common.aml_opcode;

		status = walk_state->ascending_callback(walk_state);
		status = acpi_ps_next_parse_state(walk_state, *op, status);

		status2 = acpi_ps_complete_this_op(walk_state, *op);
		if (ACPI_FAILURE(status2)) {
			return_ACPI_STATUS(status2);
		}

		status = AE_OK;
		break;

	case AE_CTRL_TERMINATE:

		/* Clean up */
		do {
			if (*op) {
				status2 =
				    acpi_ps_complete_this_op(walk_state, *op);
				if (ACPI_FAILURE(status2)) {
					return_ACPI_STATUS(status2);
				}

				acpi_ut_delete_generic_state
				    (acpi_ut_pop_generic_state
				     (&walk_state->control_state));
			}

			acpi_ps_pop_scope(&(walk_state->parser_state), op,
					  &walk_state->arg_types,
					  &walk_state->arg_count);

		} while (*op);

		return_ACPI_STATUS(AE_OK);

	default:		/* All other non-AE_OK status */

		do {
			if (*op) {
				status2 =
				    acpi_ps_complete_this_op(walk_state, *op);
				if (ACPI_FAILURE(status2)) {
					return_ACPI_STATUS(status2);
				}
			}

			acpi_ps_pop_scope(&(walk_state->parser_state), op,
					  &walk_state->arg_types,
					  &walk_state->arg_count);

		} while (*op);

#if 0
		/*
		 * TBD: Cleanup parse ops on error
		 */
		if (*op == NULL) {
			acpi_ps_pop_scope(parser_state, op,
					  &walk_state->arg_types,
					  &walk_state->arg_count);
		}
#endif
		walk_state->prev_op = NULL;
		walk_state->prev_arg_types = walk_state->arg_types;
		return_ACPI_STATUS(status);
	}

	/* This scope complete? */

	if (acpi_ps_has_completed_scope(&(walk_state->parser_state))) {
		acpi_ps_pop_scope(&(walk_state->parser_state), op,
				  &walk_state->arg_types,
				  &walk_state->arg_count);
		ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "Popped scope, Op=%p\n", *op));
	} else {
		*op = NULL;
	}

	return_ACPI_STATUS(AE_OK);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ps_complete_final_op
 *
 * PARAMETERS:  walk_state          - Current state
 *              op                  - Current Op
 *              status              - Current parse status before complete last
 *                                    Op
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Complete last Op.
 *
 ******************************************************************************/

acpi_status
acpi_ps_complete_final_op(struct acpi_walk_state *walk_state,
			  union acpi_parse_object *op, acpi_status status)
{
	acpi_status status2;

	ACPI_FUNCTION_TRACE_PTR(ps_complete_final_op, walk_state);

	/*
	 * Complete the last Op (if not completed), and clear the scope stack.
	 * It is easily possible to end an AML "package" with an unbounded number
	 * of open scopes (such as when several ASL blocks are closed with
	 * sequential closing braces). We want to terminate each one cleanly.
	 */
	ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "AML package complete at Op %p\n",
			  op));
	do {
		if (op) {
			if (walk_state->ascending_callback != NULL) {
				walk_state->op = op;
				walk_state->op_info =
				    acpi_ps_get_opcode_info(op->common.
							    aml_opcode);
				walk_state->opcode = op->common.aml_opcode;

				status =
				    walk_state->ascending_callback(walk_state);
				status =
				    acpi_ps_next_parse_state(walk_state, op,
							     status);
				if (status == AE_CTRL_PENDING) {
					status =
					    acpi_ps_complete_op(walk_state, &op,
								AE_OK);
					if (ACPI_FAILURE(status)) {
						return_ACPI_STATUS(status);
					}
				}

				if (status == AE_CTRL_TERMINATE) {
					status = AE_OK;

					/* Clean up */
					do {
						if (op) {
							status2 =
							    acpi_ps_complete_this_op
							    (walk_state, op);
							if (ACPI_FAILURE
							    (status2)) {
								return_ACPI_STATUS
								    (status2);
							}
						}

						acpi_ps_pop_scope(&
								  (walk_state->
								   parser_state),
								  &op,
								  &walk_state->
								  arg_types,
								  &walk_state->
								  arg_count);

					} while (op);

					return_ACPI_STATUS(status);
				}

				else if (ACPI_FAILURE(status)) {

					/* First error is most important */

					(void)
					    acpi_ps_complete_this_op(walk_state,
								     op);
					return_ACPI_STATUS(status);
				}
			}

			status2 = acpi_ps_complete_this_op(walk_state, op);
			if (ACPI_FAILURE(status2)) {
				return_ACPI_STATUS(status2);
			}
		}

		acpi_ps_pop_scope(&(walk_state->parser_state), &op,
				  &walk_state->arg_types,
				  &walk_state->arg_count);

	} while (op);

	return_ACPI_STATUS(status);
}
Commit	Line	Data
42f8fb75 BM	1	/******************************************************************************
	2	*
	3	* Module Name: psobject - Support for parse objects
	4	*
	5	*****************************************************************************/
	6
	7	/*
fbb7a2dc	8	* Copyright (C) 2000 - 2014, Intel Corp.
42f8fb75 BM	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	#include <acpi/acpi.h>
	45	#include "accommon.h"
	46	#include "acparser.h"
	47	#include "amlcode.h"
	48
	49	#define _COMPONENT ACPI_PARSER
	50	ACPI_MODULE_NAME("psobject")
	51
	52	/* Local prototypes */
	53	static acpi_status acpi_ps_get_aml_opcode(struct acpi_walk_state *walk_state);
	54
	55	/*******************************************************************************
	56	*
	57	* FUNCTION: acpi_ps_get_aml_opcode
	58	*
	59	* PARAMETERS: walk_state - Current state
	60	*
	61	* RETURN: Status
	62	*
	63	* DESCRIPTION: Extract the next AML opcode from the input stream.
	64	*
	65	******************************************************************************/
	66
	67	static acpi_status acpi_ps_get_aml_opcode(struct acpi_walk_state *walk_state)
	68	{
	69
	70	ACPI_FUNCTION_TRACE_PTR(ps_get_aml_opcode, walk_state);
	71
	72	walk_state->aml_offset =
73	(u32)ACPI_PTR_DIFF(walk_state->parser_state.aml,
74	walk_state->parser_state.aml_start);
75	walk_state->opcode = acpi_ps_peek_opcode(&(walk_state->parser_state));
76
77	/*
78	* First cut to determine what we have found:
79	* 1) A valid AML opcode
80	* 2) A name string
81	* 3) An unknown/invalid opcode
82	*/
83	walk_state->op_info = acpi_ps_get_opcode_info(walk_state->opcode);
84
85	switch (walk_state->op_info->class) {
86	case AML_CLASS_ASCII:
87	case AML_CLASS_PREFIX:
88	/*
89	* Starts with a valid prefix or ASCII char, this is a name
90	* string. Convert the bare name string to a namepath.
91	*/
92	walk_state->opcode = AML_INT_NAMEPATH_OP;
93	walk_state->arg_types = ARGP_NAMESTRING;
94	break;
95
96	case AML_CLASS_UNKNOWN:
97
98	/* The opcode is unrecognized. Complain and skip unknown opcodes */
99
100	if (walk_state->pass_number == 2) {
101	ACPI_ERROR((AE_INFO,
102	"Unknown opcode 0x%.2X at table offset 0x%.4X, ignoring",
103	walk_state->opcode,
104	(u32)(walk_state->aml_offset +
105	sizeof(struct acpi_table_header))));
106
107	ACPI_DUMP_BUFFER((walk_state->parser_state.aml - 16),
108	48);
109
110	#ifdef ACPI_ASL_COMPILER
111	/*
112	* This is executed for the disassembler only. Output goes
113	* to the disassembled ASL output file.
114	*/
115	acpi_os_printf
116	("/*\nError: Unknown opcode 0x%.2X at table offset 0x%.4X, context:\n",
117	walk_state->opcode,
118	(u32)(walk_state->aml_offset +
119	sizeof(struct acpi_table_header)));
120
121	/* Dump the context surrounding the invalid opcode */
122
123	acpi_ut_dump_buffer(((u8 *)walk_state->parser_state.
124	aml - 16), 48, DB_BYTE_DISPLAY,
125	(walk_state->aml_offset +
126	sizeof(struct acpi_table_header) -
127	16));
128	acpi_os_printf(" */\n");
129	#endif
130	}
131
132	/* Increment past one-byte or two-byte opcode */
133
134	walk_state->parser_state.aml++;
135	if (walk_state->opcode > 0xFF) { /* Can only happen if first byte is 0x5B */
136	walk_state->parser_state.aml++;
137	}
138
139	return_ACPI_STATUS(AE_CTRL_PARSE_CONTINUE);
140
141	default:
142
143	/* Found opcode info, this is a normal opcode */
144
145	walk_state->parser_state.aml +=
146	acpi_ps_get_opcode_size(walk_state->opcode);
147	walk_state->arg_types = walk_state->op_info->parse_args;
148	break;
149	}
150
151	return_ACPI_STATUS(AE_OK);
152	}
153
154	/*******************************************************************************
155	*
156	* FUNCTION: acpi_ps_build_named_op
157	*
158	* PARAMETERS: walk_state - Current state
159	* aml_op_start - Begin of named Op in AML
160	* unnamed_op - Early Op (not a named Op)
161	* op - Returned Op
162	*
163	* RETURN: Status
164	*
165	* DESCRIPTION: Parse a named Op
166	*
167	******************************************************************************/
168
169	acpi_status
170	acpi_ps_build_named_op(struct acpi_walk_state *walk_state,
171	u8 *aml_op_start,
172	union acpi_parse_object *unnamed_op,
173	union acpi_parse_object **op)
174	{
175	acpi_status status = AE_OK;
176	union acpi_parse_object *arg = NULL;
177
178	ACPI_FUNCTION_TRACE_PTR(ps_build_named_op, walk_state);
179
180	unnamed_op->common.value.arg = NULL;
181	unnamed_op->common.arg_list_length = 0;
182	unnamed_op->common.aml_opcode = walk_state->opcode;
183
184	/*
185	* Get and append arguments until we find the node that contains
186	* the name (the type ARGP_NAME).
187	*/
188	while (GET_CURRENT_ARG_TYPE(walk_state->arg_types) &&
189	(GET_CURRENT_ARG_TYPE(walk_state->arg_types) != ARGP_NAME)) {
190	status =
191	acpi_ps_get_next_arg(walk_state,
192	&(walk_state->parser_state),
193	GET_CURRENT_ARG_TYPE(walk_state->
194	arg_types), &arg);
195	if (ACPI_FAILURE(status)) {
196	return_ACPI_STATUS(status);
197	}
198
199	acpi_ps_append_arg(unnamed_op, arg);
200	INCREMENT_ARG_LIST(walk_state->arg_types);
201	}
202
203	/*
204	* Make sure that we found a NAME and didn't run out of arguments
205	*/
206	if (!GET_CURRENT_ARG_TYPE(walk_state->arg_types)) {
207	return_ACPI_STATUS(AE_AML_NO_OPERAND);
208	}
209
210	/* We know that this arg is a name, move to next arg */
211
212	INCREMENT_ARG_LIST(walk_state->arg_types);
213
214	/*
215	* Find the object. This will either insert the object into
216	* the namespace or simply look it up
217	*/
218	walk_state->op = NULL;
219
220	status = walk_state->descending_callback(walk_state, op);
221	if (ACPI_FAILURE(status)) {
222	ACPI_EXCEPTION((AE_INFO, status, "During name lookup/catalog"));
223	return_ACPI_STATUS(status);
224	}
225
226	if (!*op) {
227	return_ACPI_STATUS(AE_CTRL_PARSE_CONTINUE);
228	}
229
230	status = acpi_ps_next_parse_state(walk_state, *op, status);
231	if (ACPI_FAILURE(status)) {
232	if (status == AE_CTRL_PENDING) {
233	return_ACPI_STATUS(AE_CTRL_PARSE_PENDING);
234	}
235	return_ACPI_STATUS(status);
236	}
237
238	acpi_ps_append_arg(*op, unnamed_op->common.value.arg);
239
240	if ((*op)->common.aml_opcode == AML_REGION_OP \|\|
241	(*op)->common.aml_opcode == AML_DATA_REGION_OP) {
242	/*
243	* Defer final parsing of an operation_region body, because we don't
244	* have enough info in the first pass to parse it correctly (i.e.,
245	* there may be method calls within the term_arg elements of the body.)
246	*
247	* However, we must continue parsing because the opregion is not a
248	* standalone package -- we don't know where the end is at this point.
249	*
250	* (Length is unknown until parse of the body complete)
251	*/
252	(*op)->named.data = aml_op_start;
253	(*op)->named.length = 0;
254	}
255
256	return_ACPI_STATUS(AE_OK);
257	}
258
259	/*******************************************************************************
260	*
261	* FUNCTION: acpi_ps_create_op
262	*
263	* PARAMETERS: walk_state - Current state
264	* aml_op_start - Op start in AML
265	* new_op - Returned Op
266	*
267	* RETURN: Status
268	*
269	* DESCRIPTION: Get Op from AML
270	*
271	******************************************************************************/
272
273	acpi_status
274	acpi_ps_create_op(struct acpi_walk_state *walk_state,
275	u8 aml_op_start, union acpi_parse_object *new_op)
276	{
277	acpi_status status = AE_OK;
278	union acpi_parse_object *op;
279	union acpi_parse_object *named_op = NULL;
280	union acpi_parse_object *parent_scope;
281	u8 argument_count;
282	const struct acpi_opcode_info *op_info;
283
284	ACPI_FUNCTION_TRACE_PTR(ps_create_op, walk_state);
285
286	status = acpi_ps_get_aml_opcode(walk_state);
287	if (status == AE_CTRL_PARSE_CONTINUE) {
288	return_ACPI_STATUS(AE_CTRL_PARSE_CONTINUE);
289	}
290
291	/* Create Op structure and append to parent's argument list */
292
293	walk_state->op_info = acpi_ps_get_opcode_info(walk_state->opcode);
294	op = acpi_ps_alloc_op(walk_state->opcode);
295	if (!op) {
296	return_ACPI_STATUS(AE_NO_MEMORY);
297	}
298
299	if (walk_state->op_info->flags & AML_NAMED) {
300	status =
301	acpi_ps_build_named_op(walk_state, aml_op_start, op,
302	&named_op);
303	acpi_ps_free_op(op);
304	if (ACPI_FAILURE(status)) {
305	return_ACPI_STATUS(status);
306	}
307
308	*new_op = named_op;
309	return_ACPI_STATUS(AE_OK);
310	}
311
312	/* Not a named opcode, just allocate Op and append to parent */
313
314	if (walk_state->op_info->flags & AML_CREATE) {
315	/*
316	* Backup to beginning of create_XXXfield declaration
317	* body_length is unknown until we parse the body
318	*/
319	op->named.data = aml_op_start;
320	op->named.length = 0;
321	}
322
323	if (walk_state->opcode == AML_BANK_FIELD_OP) {
324	/*
325	* Backup to beginning of bank_field declaration
326	* body_length is unknown until we parse the body
327	*/
328	op->named.data = aml_op_start;
329	op->named.length = 0;
330	}
331
332	parent_scope = acpi_ps_get_parent_scope(&(walk_state->parser_state));
333	acpi_ps_append_arg(parent_scope, op);
334
335	if (parent_scope) {
336	op_info =
337	acpi_ps_get_opcode_info(parent_scope->common.aml_opcode);
338	if (op_info->flags & AML_HAS_TARGET) {
339	argument_count =
340	acpi_ps_get_argument_count(op_info->type);
341	if (parent_scope->common.arg_list_length >
342	argument_count) {
343	op->common.flags \|= ACPI_PARSEOP_TARGET;
344	}
345	} else if (parent_scope->common.aml_opcode == AML_INCREMENT_OP) {
346	op->common.flags \|= ACPI_PARSEOP_TARGET;
347	}
348	}
349
350	if (walk_state->descending_callback != NULL) {
351	/*
352	* Find the object. This will either insert the object into
353	* the namespace or simply look it up
354	*/
355	walk_state->op = *new_op = op;
356
357	status = walk_state->descending_callback(walk_state, &op);
358	status = acpi_ps_next_parse_state(walk_state, op, status);
359	if (status == AE_CTRL_PENDING) {
360	status = AE_CTRL_PARSE_PENDING;
361	}
362	}
363
364	return_ACPI_STATUS(status);
365	}
366
367	/*******************************************************************************
368	*
369	* FUNCTION: acpi_ps_complete_op
370	*
371	* PARAMETERS: walk_state - Current state
372	* op - Returned Op
373	* status - Parse status before complete Op
374	*
375	* RETURN: Status
376	*
377	* DESCRIPTION: Complete Op
378	*
379	******************************************************************************/
380
381	acpi_status
382	acpi_ps_complete_op(struct acpi_walk_state *walk_state,
383	union acpi_parse_object **op, acpi_status status)
384	{
385	acpi_status status2;
386
387	ACPI_FUNCTION_TRACE_PTR(ps_complete_op, walk_state);
388
389	/*
390	* Finished one argument of the containing scope
391	*/
392	walk_state->parser_state.scope->parse_scope.arg_count--;
393
394	/* Close this Op (will result in parse subtree deletion) */
395
396	status2 = acpi_ps_complete_this_op(walk_state, *op);
397	if (ACPI_FAILURE(status2)) {
398	return_ACPI_STATUS(status2);
399	}
400
401	*op = NULL;
402
403	switch (status) {
404	case AE_OK:
1d1ea1b7	405
42f8fb75 BM	406	break;
	407
	408	case AE_CTRL_TRANSFER:
	409
	410	/* We are about to transfer to a called method */
	411
	412	walk_state->prev_op = NULL;
	413	walk_state->prev_arg_types = walk_state->arg_types;
	414	return_ACPI_STATUS(status);
	415
	416	case AE_CTRL_END:
	417
	418	acpi_ps_pop_scope(&(walk_state->parser_state), op,
	419	&walk_state->arg_types,
	420	&walk_state->arg_count);
	421
	422	if (*op) {
	423	walk_state->op = *op;
	424	walk_state->op_info =
	425	acpi_ps_get_opcode_info((*op)->common.aml_opcode);
	426	walk_state->opcode = (*op)->common.aml_opcode;
	427
	428	status = walk_state->ascending_callback(walk_state);
	429	status =
	430	acpi_ps_next_parse_state(walk_state, *op, status);
	431
	432	status2 = acpi_ps_complete_this_op(walk_state, *op);
	433	if (ACPI_FAILURE(status2)) {
	434	return_ACPI_STATUS(status2);
	435	}
	436	}
	437
	438	status = AE_OK;
	439	break;
	440
	441	case AE_CTRL_BREAK:
	442	case AE_CTRL_CONTINUE:
	443
	444	/* Pop off scopes until we find the While */
	445
	446	while (!(op) \|\| ((op)->common.aml_opcode != AML_WHILE_OP)) {
	447	acpi_ps_pop_scope(&(walk_state->parser_state), op,
	448	&walk_state->arg_types,
	449	&walk_state->arg_count);
	450	}
	451
	452	/* Close this iteration of the While loop */
	453
	454	walk_state->op = *op;
	455	walk_state->op_info =
	456	acpi_ps_get_opcode_info((*op)->common.aml_opcode);
	457	walk_state->opcode = (*op)->common.aml_opcode;
	458
	459	status = walk_state->ascending_callback(walk_state);
	460	status = acpi_ps_next_parse_state(walk_state, *op, status);
	461
	462	status2 = acpi_ps_complete_this_op(walk_state, *op);
	463	if (ACPI_FAILURE(status2)) {
	464	return_ACPI_STATUS(status2);
	465	}
	466
	467	status = AE_OK;
	468	break;
	469
470	case AE_CTRL_TERMINATE:
471
472	/* Clean up */
473	do {
474	if (*op) {
475	status2 =
476	acpi_ps_complete_this_op(walk_state, *op);
477	if (ACPI_FAILURE(status2)) {
478	return_ACPI_STATUS(status2);
479	}
480
481	acpi_ut_delete_generic_state
482	(acpi_ut_pop_generic_state
483	(&walk_state->control_state));
484	}
485
486	acpi_ps_pop_scope(&(walk_state->parser_state), op,
487	&walk_state->arg_types,
488	&walk_state->arg_count);
489
490	} while (*op);
491
492	return_ACPI_STATUS(AE_OK);
493
494	default: /* All other non-AE_OK status */
495
496	do {
497	if (*op) {
498	status2 =
499	acpi_ps_complete_this_op(walk_state, *op);
500	if (ACPI_FAILURE(status2)) {
501	return_ACPI_STATUS(status2);
502	}
503	}
504
505	acpi_ps_pop_scope(&(walk_state->parser_state), op,
506	&walk_state->arg_types,
507	&walk_state->arg_count);
508
509	} while (*op);
510
511	#if 0
512	/*
513	* TBD: Cleanup parse ops on error
514	*/
515	if (*op == NULL) {
516	acpi_ps_pop_scope(parser_state, op,
517	&walk_state->arg_types,
518	&walk_state->arg_count);
519	}
520	#endif
521	walk_state->prev_op = NULL;
522	walk_state->prev_arg_types = walk_state->arg_types;
523	return_ACPI_STATUS(status);
524	}
525
526	/* This scope complete? */
527
528	if (acpi_ps_has_completed_scope(&(walk_state->parser_state))) {
529	acpi_ps_pop_scope(&(walk_state->parser_state), op,
530	&walk_state->arg_types,
531	&walk_state->arg_count);
532	ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "Popped scope, Op=%p\n", *op));
533	} else {
534	*op = NULL;
535	}
536
537	return_ACPI_STATUS(AE_OK);
538	}
539
540	/*******************************************************************************
541	*
542	* FUNCTION: acpi_ps_complete_final_op
543	*
544	* PARAMETERS: walk_state - Current state
545	* op - Current Op
546	* status - Current parse status before complete last
547	* Op
548	*
549	* RETURN: Status
550	*
551	* DESCRIPTION: Complete last Op.
552	*
553	******************************************************************************/
554
555	acpi_status
556	acpi_ps_complete_final_op(struct acpi_walk_state *walk_state,
557	union acpi_parse_object *op, acpi_status status)
558	{
559	acpi_status status2;
560
561	ACPI_FUNCTION_TRACE_PTR(ps_complete_final_op, walk_state);
562
563	/*
564	* Complete the last Op (if not completed), and clear the scope stack.
565	* It is easily possible to end an AML "package" with an unbounded number
566	* of open scopes (such as when several ASL blocks are closed with
567	* sequential closing braces). We want to terminate each one cleanly.
568	*/
569	ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "AML package complete at Op %p\n",
570	op));
571	do {
572	if (op) {
573	if (walk_state->ascending_callback != NULL) {
574	walk_state->op = op;
575	walk_state->op_info =
576	acpi_ps_get_opcode_info(op->common.
577	aml_opcode);
578	walk_state->opcode = op->common.aml_opcode;
579
580	status =
581	walk_state->ascending_callback(walk_state);
582	status =
583	acpi_ps_next_parse_state(walk_state, op,
584	status);
585	if (status == AE_CTRL_PENDING) {
586	status =
587	acpi_ps_complete_op(walk_state, &op,
588	AE_OK);
589	if (ACPI_FAILURE(status)) {
590	return_ACPI_STATUS(status);
591	}
592	}
593
594	if (status == AE_CTRL_TERMINATE) {
595	status = AE_OK;
596
597	/* Clean up */
598	do {
599	if (op) {
600	status2 =
601	acpi_ps_complete_this_op
602	(walk_state, op);
603	if (ACPI_FAILURE
604	(status2)) {
605	return_ACPI_STATUS
606	(status2);
607	}
608	}
609
610	acpi_ps_pop_scope(&
611	(walk_state->
612	parser_state),
613	&op,
614	&walk_state->
615	arg_types,
616	&walk_state->
617	arg_count);
618
619	} while (op);
620
621	return_ACPI_STATUS(status);
622	}
623
624	else if (ACPI_FAILURE(status)) {
625
626	/* First error is most important */
627
628	(void)
629	acpi_ps_complete_this_op(walk_state,
630	op);
631	return_ACPI_STATUS(status);
632	}
633	}
634
635	status2 = acpi_ps_complete_this_op(walk_state, op);
636	if (ACPI_FAILURE(status2)) {
637	return_ACPI_STATUS(status2);
638	}
639	}
640
641	acpi_ps_pop_scope(&(walk_state->parser_state), &op,
642	&walk_state->arg_types,
643	&walk_state->arg_count);
644
645	} while (op);
646
647	return_ACPI_STATUS(status);
648	}