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

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

/*
 * Copyright (C) 2000 - 2016, 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)
{
	u32 aml_offset;

	ACPI_FUNCTION_TRACE_PTR(ps_get_aml_opcode, walk_state);

	walk_state->aml = walk_state->parser_state.aml;
	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) {
			aml_offset = (u32)ACPI_PTR_DIFF(walk_state->aml,
							walk_state->
							parser_state.aml_start);

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