[linux-2.6-block.git] / drivers / acpi / acpica / dswload.c

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/******************************************************************************
 *
 * Module Name: dswload - Dispatcher first pass namespace load callbacks
 *
 * Copyright (C) 2000 - 2023, Intel Corp.
 *
 *****************************************************************************/

#include <acpi/acpi.h>
#include "accommon.h"
#include "acparser.h"
#include "amlcode.h"
#include "acdispat.h"
#include "acinterp.h"
#include "acnamesp.h"
#ifdef ACPI_ASL_COMPILER
#include "acdisasm.h"
#endif

#define _COMPONENT          ACPI_DISPATCHER
ACPI_MODULE_NAME("dswload")

/*******************************************************************************
 *
 * FUNCTION:    acpi_ds_init_callbacks
 *
 * PARAMETERS:  walk_state      - Current state of the parse tree walk
 *              pass_number     - 1, 2, or 3
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Init walk state callbacks
 *
 ******************************************************************************/
acpi_status
acpi_ds_init_callbacks(struct acpi_walk_state *walk_state, u32 pass_number)
{

	switch (pass_number) {
	case 0:

		/* Parse only - caller will setup callbacks */

		walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 |
		    ACPI_PARSE_DELETE_TREE | ACPI_PARSE_DISASSEMBLE;
		walk_state->descending_callback = NULL;
		walk_state->ascending_callback = NULL;
		break;

	case 1:

		/* Load pass 1 */

		walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 |
		    ACPI_PARSE_DELETE_TREE;
		walk_state->descending_callback = acpi_ds_load1_begin_op;
		walk_state->ascending_callback = acpi_ds_load1_end_op;
		break;

	case 2:

		/* Load pass 2 */

		walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 |
		    ACPI_PARSE_DELETE_TREE;
		walk_state->descending_callback = acpi_ds_load2_begin_op;
		walk_state->ascending_callback = acpi_ds_load2_end_op;
		break;

	case 3:

		/* Execution pass */

		walk_state->parse_flags |= ACPI_PARSE_EXECUTE |
		    ACPI_PARSE_DELETE_TREE;
		walk_state->descending_callback = acpi_ds_exec_begin_op;
		walk_state->ascending_callback = acpi_ds_exec_end_op;
		break;

	default:

		return (AE_BAD_PARAMETER);
	}

	return (AE_OK);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ds_load1_begin_op
 *
 * PARAMETERS:  walk_state      - Current state of the parse tree walk
 *              out_op          - Where to return op if a new one is created
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Descending callback used during the loading of ACPI tables.
 *
 ******************************************************************************/

acpi_status
acpi_ds_load1_begin_op(struct acpi_walk_state *walk_state,
		       union acpi_parse_object **out_op)
{
	union acpi_parse_object *op;
	struct acpi_namespace_node *node;
	acpi_status status;
	acpi_object_type object_type;
	char *path;
	u32 flags;

	ACPI_FUNCTION_TRACE_PTR(ds_load1_begin_op, walk_state->op);

	op = walk_state->op;
	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
			  walk_state));

	/* We are only interested in opcodes that have an associated name */

	if (op) {
		if (!(walk_state->op_info->flags & AML_NAMED)) {
			*out_op = op;
			return_ACPI_STATUS(AE_OK);
		}

		/* Check if this object has already been installed in the namespace */

		if (op->common.node) {
			*out_op = op;
			return_ACPI_STATUS(AE_OK);
		}
	}

	path = acpi_ps_get_next_namestring(&walk_state->parser_state);

	/* Map the raw opcode into an internal object type */

	object_type = walk_state->op_info->object_type;

	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
			  "State=%p Op=%p [%s]\n", walk_state, op,
			  acpi_ut_get_type_name(object_type)));

	switch (walk_state->opcode) {
	case AML_SCOPE_OP:
		/*
		 * The target name of the Scope() operator must exist at this point so
		 * that we can actually open the scope to enter new names underneath it.
		 * Allow search-to-root for single namesegs.
		 */
		status =
		    acpi_ns_lookup(walk_state->scope_info, path, object_type,
				   ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
				   walk_state, &(node));
#ifdef ACPI_ASL_COMPILER
		if (status == AE_NOT_FOUND) {
			/*
			 * Table disassembly:
			 * Target of Scope() not found. Generate an External for it, and
			 * insert the name into the namespace.
			 */
			acpi_dm_add_op_to_external_list(op, path,
							ACPI_TYPE_DEVICE, 0, 0);
			status =
			    acpi_ns_lookup(walk_state->scope_info, path,
					   object_type, ACPI_IMODE_LOAD_PASS1,
					   ACPI_NS_SEARCH_PARENT, walk_state,
					   &node);
		}
#endif
		if (ACPI_FAILURE(status)) {
			ACPI_ERROR_NAMESPACE(walk_state->scope_info, path,
					     status);
			return_ACPI_STATUS(status);
		}

		/*
		 * Check to make sure that the target is
		 * one of the opcodes that actually opens a scope
		 */
		switch (node->type) {
		case ACPI_TYPE_ANY:
		case ACPI_TYPE_LOCAL_SCOPE:	/* Scope  */
		case ACPI_TYPE_DEVICE:
		case ACPI_TYPE_POWER:
		case ACPI_TYPE_PROCESSOR:
		case ACPI_TYPE_THERMAL:

			/* These are acceptable types */
			break;

		case ACPI_TYPE_INTEGER:
		case ACPI_TYPE_STRING:
		case ACPI_TYPE_BUFFER:
			/*
			 * These types we will allow, but we will change the type.
			 * This enables some existing code of the form:
			 *
			 *  Name (DEB, 0)
			 *  Scope (DEB) { ... }
			 *
			 * Note: silently change the type here. On the second pass,
			 * we will report a warning
			 */
			ACPI_DEBUG_PRINT((ACPI_DB_INFO,
					  "Type override - [%4.4s] had invalid type (%s) "
					  "for Scope operator, changed to type ANY\n",
					  acpi_ut_get_node_name(node),
					  acpi_ut_get_type_name(node->type)));

			node->type = ACPI_TYPE_ANY;
			walk_state->scope_info->common.value = ACPI_TYPE_ANY;
			break;

		case ACPI_TYPE_METHOD:
			/*
			 * Allow scope change to root during execution of module-level
			 * code. Root is typed METHOD during this time.
			 */
			if ((node == acpi_gbl_root_node) &&
			    (walk_state->
			     parse_flags & ACPI_PARSE_MODULE_LEVEL)) {
				break;
			}

			ACPI_FALLTHROUGH;

		default:

			/* All other types are an error */

			ACPI_ERROR((AE_INFO,
				    "Invalid type (%s) for target of "
				    "Scope operator [%4.4s] (Cannot override)",
				    acpi_ut_get_type_name(node->type),
				    acpi_ut_get_node_name(node)));

			return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
		}
		break;

	default:
		/*
		 * For all other named opcodes, we will enter the name into
		 * the namespace.
		 *
		 * Setup the search flags.
		 * Since we are entering a name into the namespace, we do not want to
		 * enable the search-to-root upsearch.
		 *
		 * There are only two conditions where it is acceptable that the name
		 * already exists:
		 *    1) the Scope() operator can reopen a scoping object that was
		 *       previously defined (Scope, Method, Device, etc.)
		 *    2) Whenever we are parsing a deferred opcode (op_region, Buffer,
		 *       buffer_field, or Package), the name of the object is already
		 *       in the namespace.
		 */
		if (walk_state->deferred_node) {

			/* This name is already in the namespace, get the node */

			node = walk_state->deferred_node;
			status = AE_OK;
			break;
		}

		/*
		 * If we are executing a method, do not create any namespace objects
		 * during the load phase, only during execution.
		 */
		if (walk_state->method_node) {
			node = NULL;
			status = AE_OK;
			break;
		}

		flags = ACPI_NS_NO_UPSEARCH;
		if ((walk_state->opcode != AML_SCOPE_OP) &&
		    (!(walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP))) {
			if (walk_state->namespace_override) {
				flags |= ACPI_NS_OVERRIDE_IF_FOUND;
				ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
						  "[%s] Override allowed\n",
						  acpi_ut_get_type_name
						  (object_type)));
			} else {
				flags |= ACPI_NS_ERROR_IF_FOUND;
				ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
						  "[%s] Cannot already exist\n",
						  acpi_ut_get_type_name
						  (object_type)));
			}
		} else {
			ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
					  "[%s] Both Find or Create allowed\n",
					  acpi_ut_get_type_name(object_type)));
		}

		/*
		 * Enter the named type into the internal namespace. We enter the name
		 * as we go downward in the parse tree. Any necessary subobjects that
		 * involve arguments to the opcode must be created as we go back up the
		 * parse tree later.
		 */
		status =
		    acpi_ns_lookup(walk_state->scope_info, path, object_type,
				   ACPI_IMODE_LOAD_PASS1, flags, walk_state,
				   &node);
		if (ACPI_FAILURE(status)) {
			if (status == AE_ALREADY_EXISTS) {

				/* The name already exists in this scope */

				if (node->flags & ANOBJ_IS_EXTERNAL) {
					/*
					 * Allow one create on an object or segment that was
					 * previously declared External
					 */
					node->flags &= ~ANOBJ_IS_EXTERNAL;
					node->type = (u8) object_type;

					/* Just retyped a node, probably will need to open a scope */

					if (acpi_ns_opens_scope(object_type)) {
						status =
						    acpi_ds_scope_stack_push
						    (node, object_type,
						     walk_state);
						if (ACPI_FAILURE(status)) {
							return_ACPI_STATUS
							    (status);
						}
					}

					status = AE_OK;
				}
			}

			if (ACPI_FAILURE(status)) {
				ACPI_ERROR_NAMESPACE(walk_state->scope_info,
						     path, status);
				return_ACPI_STATUS(status);
			}
		}
		break;
	}

	/* Common exit */

	if (!op) {

		/* Create a new op */

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

	/* Initialize the op */

#ifdef ACPI_CONSTANT_EVAL_ONLY
	op->named.path = path;
#endif

	if (node) {
		/*
		 * Put the Node in the "op" object that the parser uses, so we
		 * can get it again quickly when this scope is closed
		 */
		op->common.node = node;
		op->named.name = node->name.integer;
	}

	acpi_ps_append_arg(acpi_ps_get_parent_scope(&walk_state->parser_state),
			   op);
	*out_op = op;
	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ds_load1_end_op
 *
 * PARAMETERS:  walk_state      - Current state of the parse tree walk
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Ascending callback used during the loading of the namespace,
 *              both control methods and everything else.
 *
 ******************************************************************************/

acpi_status acpi_ds_load1_end_op(struct acpi_walk_state *walk_state)
{
	union acpi_parse_object *op;
	acpi_object_type object_type;
	acpi_status status = AE_OK;
#ifdef ACPI_ASL_COMPILER
	u8 param_count;
#endif

	ACPI_FUNCTION_TRACE(ds_load1_end_op);

	op = walk_state->op;
	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
			  walk_state));

	/*
	 * Disassembler: handle create field operators here.
	 *
	 * create_buffer_field is a deferred op that is typically processed in load
	 * pass 2. However, disassembly of control method contents walk the parse
	 * tree with ACPI_PARSE_LOAD_PASS1 and AML_CREATE operators are processed
	 * in a later walk. This is a problem when there is a control method that
	 * has the same name as the AML_CREATE object. In this case, any use of the
	 * name segment will be detected as a method call rather than a reference
	 * to a buffer field.
	 *
	 * This earlier creation during disassembly solves this issue by inserting
	 * the named object in the ACPI namespace so that references to this name
	 * would be a name string rather than a method call.
	 */
	if ((walk_state->parse_flags & ACPI_PARSE_DISASSEMBLE) &&
	    (walk_state->op_info->flags & AML_CREATE)) {
		status = acpi_ds_create_buffer_field(op, walk_state);
		return_ACPI_STATUS(status);
	}

	/* We are only interested in opcodes that have an associated name */

	if (!(walk_state->op_info->flags & (AML_NAMED | AML_FIELD))) {
		return_ACPI_STATUS(AE_OK);
	}

	/* Get the object type to determine if we should pop the scope */

	object_type = walk_state->op_info->object_type;

	if (walk_state->op_info->flags & AML_FIELD) {
		/*
		 * If we are executing a method, do not create any namespace objects
		 * during the load phase, only during execution.
		 */
		if (!walk_state->method_node) {
			if (walk_state->opcode == AML_FIELD_OP ||
			    walk_state->opcode == AML_BANK_FIELD_OP ||
			    walk_state->opcode == AML_INDEX_FIELD_OP) {
				status =
				    acpi_ds_init_field_objects(op, walk_state);
			}
		}
		return_ACPI_STATUS(status);
	}

	/*
	 * If we are executing a method, do not create any namespace objects
	 * during the load phase, only during execution.
	 */
	if (!walk_state->method_node) {
		if (op->common.aml_opcode == AML_REGION_OP) {
			status =
			    acpi_ex_create_region(op->named.data,
						  op->named.length,
						  (acpi_adr_space_type)
						  ((op->common.value.arg)->
						   common.value.integer),
						  walk_state);
			if (ACPI_FAILURE(status)) {
				return_ACPI_STATUS(status);
			}
		} else if (op->common.aml_opcode == AML_DATA_REGION_OP) {
			status =
			    acpi_ex_create_region(op->named.data,
						  op->named.length,
						  ACPI_ADR_SPACE_DATA_TABLE,
						  walk_state);
			if (ACPI_FAILURE(status)) {
				return_ACPI_STATUS(status);
			}
		}
	}

	if (op->common.aml_opcode == AML_NAME_OP) {

		/* For Name opcode, get the object type from the argument */

		if (op->common.value.arg) {
			object_type = (acpi_ps_get_opcode_info((op->common.
								value.arg)->
							       common.
							       aml_opcode))->
			    object_type;

			/* Set node type if we have a namespace node */

			if (op->common.node) {
				op->common.node->type = (u8) object_type;
			}
		}
	}
#ifdef ACPI_ASL_COMPILER
	/*
	 * For external opcode, get the object type from the argument and
	 * get the parameter count from the argument's next.
	 */
	if (acpi_gbl_disasm_flag &&
	    op->common.node && op->common.aml_opcode == AML_EXTERNAL_OP) {
		/*
		 * Note, if this external is not a method
		 * Op->Common.Value.Arg->Common.Next->Common.Value.Integer == 0
		 * Therefore, param_count will be 0.
		 */
		param_count =
		    (u8)op->common.value.arg->common.next->common.value.integer;
		object_type = (u8)op->common.value.arg->common.value.integer;
		op->common.node->flags |= ANOBJ_IS_EXTERNAL;
		op->common.node->type = (u8)object_type;

		acpi_dm_create_subobject_for_external((u8)object_type,
						      &op->common.node,
						      param_count);

		/*
		 * Add the external to the external list because we may be
		 * emitting code based off of the items within the external list.
		 */
		acpi_dm_add_op_to_external_list(op, op->named.path,
						(u8)object_type, param_count,
						ACPI_EXT_ORIGIN_FROM_OPCODE |
						ACPI_EXT_RESOLVED_REFERENCE);
	}
#endif

	/*
	 * If we are executing a method, do not create any namespace objects
	 * during the load phase, only during execution.
	 */
	if (!walk_state->method_node) {
		if (op->common.aml_opcode == AML_METHOD_OP) {
			/*
			 * method_op pkg_length name_string method_flags term_list
			 *
			 * Note: We must create the method node/object pair as soon as we
			 * see the method declaration. This allows later pass1 parsing
			 * of invocations of the method (need to know the number of
			 * arguments.)
			 */
			ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
					  "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
					  walk_state, op, op->named.node));

			if (!acpi_ns_get_attached_object(op->named.node)) {
				walk_state->operands[0] =
				    ACPI_CAST_PTR(void, op->named.node);
				walk_state->num_operands = 1;

				status =
				    acpi_ds_create_operands(walk_state,
							    op->common.value.
							    arg);
				if (ACPI_SUCCESS(status)) {
					status =
					    acpi_ex_create_method(op->named.
								  data,
								  op->named.
								  length,
								  walk_state);
				}

				walk_state->operands[0] = NULL;
				walk_state->num_operands = 0;

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

	/* Pop the scope stack (only if loading a table) */

	if (!walk_state->method_node &&
	    op->common.aml_opcode != AML_EXTERNAL_OP &&
	    acpi_ns_opens_scope(object_type)) {
		ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
				  "(%s): Popping scope for Op %p\n",
				  acpi_ut_get_type_name(object_type), op));

		status = acpi_ds_scope_stack_pop(walk_state);
	}

	return_ACPI_STATUS(status);
}
Commit	Line	Data
95857638	1	// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
1da177e4 LT	2	/******************************************************************************
1da177e4 LT	3	*
9ad19ac4	4	* Module Name: dswload - Dispatcher first pass namespace load callbacks
1da177e4	5	*
612c2932	6	* Copyright (C) 2000 - 2023, Intel Corp.
1da177e4	7	*
95857638	8	*****************************************************************************/
1da177e4	9
1da177e4	10	#include <acpi/acpi.h>
e2f7a777 LB	11	#include "accommon.h"
	12	#include "acparser.h"
	13	#include "amlcode.h"
	14	#include "acdispat.h"
	15	#include "acinterp.h"
	16	#include "acnamesp.h"
73459f73	17	#ifdef ACPI_ASL_COMPILER
56324c10	18	#include "acdisasm.h"
1da177e4 LT	19	#endif
	20
	21	#define _COMPONENT ACPI_DISPATCHER
4be44fcd	22	ACPI_MODULE_NAME("dswload")
1da177e4 LT	23
	24	/*******************************************************************************
	25	*
	26	* FUNCTION: acpi_ds_init_callbacks
	27	*
	28	* PARAMETERS: walk_state - Current state of the parse tree walk
	29	* pass_number - 1, 2, or 3
	30	*
	31	* RETURN: Status
	32	*
	33	* DESCRIPTION: Init walk state callbacks
	34	*
	35	******************************************************************************/
1da177e4	36	acpi_status
4be44fcd	37	acpi_ds_init_callbacks(struct acpi_walk_state *walk_state, u32 pass_number)
1da177e4 LT	38	{
	39
	40	switch (pass_number) {
22b5afce BM	41	case 0:
	42
	43	/* Parse only - caller will setup callbacks */
	44
	45	walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 \|
	46	ACPI_PARSE_DELETE_TREE \| ACPI_PARSE_DISASSEMBLE;
	47	walk_state->descending_callback = NULL;
	48	walk_state->ascending_callback = NULL;
	49	break;
	50
1da177e4	51	case 1:
1d1ea1b7	52
22b5afce BM	53	/* Load pass 1 */
22b5afce BM	54
4be44fcd LB	55	walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 \|
4be44fcd LB	56	ACPI_PARSE_DELETE_TREE;
1da177e4 LT	57	walk_state->descending_callback = acpi_ds_load1_begin_op;
	58	walk_state->ascending_callback = acpi_ds_load1_end_op;
	59	break;
	60
	61	case 2:
1d1ea1b7	62
22b5afce BM	63	/* Load pass 2 */
22b5afce BM	64
4be44fcd LB	65	walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 \|
4be44fcd LB	66	ACPI_PARSE_DELETE_TREE;
1da177e4 LT	67	walk_state->descending_callback = acpi_ds_load2_begin_op;
	68	walk_state->ascending_callback = acpi_ds_load2_end_op;
	69	break;
	70
	71	case 3:
1d1ea1b7	72
22b5afce BM	73	/* Execution pass */
22b5afce BM	74
4be44fcd LB	75	walk_state->parse_flags \|= ACPI_PARSE_EXECUTE \|
4be44fcd LB	76	ACPI_PARSE_DELETE_TREE;
1da177e4 LT	77	walk_state->descending_callback = acpi_ds_exec_begin_op;
1da177e4 LT	78	walk_state->ascending_callback = acpi_ds_exec_end_op;
1da177e4 LT	79	break;
	80
	81	default:
1d1ea1b7	82
1da177e4 LT	83	return (AE_BAD_PARAMETER);
	84	}
	85
	86	return (AE_OK);
	87	}
	88
1da177e4 LT	89	/*******************************************************************************
	90	*
	91	* FUNCTION: acpi_ds_load1_begin_op
	92	*
	93	* PARAMETERS: walk_state - Current state of the parse tree walk
44f6c012	94	* out_op - Where to return op if a new one is created
1da177e4 LT	95	*
	96	* RETURN: Status
	97	*
	98	* DESCRIPTION: Descending callback used during the loading of ACPI tables.
	99	*
	100	******************************************************************************/
	101
	102	acpi_status
f5c1e1c5 LZ	103	acpi_ds_load1_begin_op(struct acpi_walk_state *walk_state,
f5c1e1c5 LZ	104	union acpi_parse_object **out_op)
1da177e4	105	{
4be44fcd LB	106	union acpi_parse_object *op;
	107	struct acpi_namespace_node *node;
	108	acpi_status status;
	109	acpi_object_type object_type;
	110	char *path;
	111	u32 flags;
1da177e4	112
1ef63231	113	ACPI_FUNCTION_TRACE_PTR(ds_load1_begin_op, walk_state->op);
1da177e4 LT	114
1da177e4 LT	115	op = walk_state->op;
4be44fcd LB	116	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
4be44fcd LB	117	walk_state));
1da177e4 LT	118
	119	/* We are only interested in opcodes that have an associated name */
	120
	121	if (op) {
	122	if (!(walk_state->op_info->flags & AML_NAMED)) {
1da177e4	123	*out_op = op;
28f55ebc	124	return_ACPI_STATUS(AE_OK);
1da177e4 LT	125	}
	126
	127	/* Check if this object has already been installed in the namespace */
	128
	129	if (op->common.node) {
	130	*out_op = op;
28f55ebc	131	return_ACPI_STATUS(AE_OK);
1da177e4 LT	132	}
	133	}
	134
4be44fcd	135	path = acpi_ps_get_next_namestring(&walk_state->parser_state);
1da177e4 LT	136
	137	/* Map the raw opcode into an internal object type */
	138
	139	object_type = walk_state->op_info->object_type;
	140
4be44fcd LB	141	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
	142	"State=%p Op=%p [%s]\n", walk_state, op,
	143	acpi_ut_get_type_name(object_type)));
1da177e4 LT	144
	145	switch (walk_state->opcode) {
	146	case AML_SCOPE_OP:
1da177e4 LT	147	/*
	148	* The target name of the Scope() operator must exist at this point so
	149	* that we can actually open the scope to enter new names underneath it.
	150	* Allow search-to-root for single namesegs.
	151	*/
4be44fcd LB	152	status =
	153	acpi_ns_lookup(walk_state->scope_info, path, object_type,
	154	ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
	155	walk_state, &(node));
73459f73	156	#ifdef ACPI_ASL_COMPILER
1da177e4 LT	157	if (status == AE_NOT_FOUND) {
	158	/*
	159	* Table disassembly:
967440e3	160	* Target of Scope() not found. Generate an External for it, and
1da177e4 LT	161	* insert the name into the namespace.
1da177e4 LT	162	*/
5af2b635 BM	163	acpi_dm_add_op_to_external_list(op, path,
5af2b635 BM	164	ACPI_TYPE_DEVICE, 0, 0);
4be44fcd LB	165	status =
	166	acpi_ns_lookup(walk_state->scope_info, path,
	167	object_type, ACPI_IMODE_LOAD_PASS1,
	168	ACPI_NS_SEARCH_PARENT, walk_state,
958dd242	169	&node);
1da177e4 LT	170	}
1da177e4 LT	171	#endif
4be44fcd	172	if (ACPI_FAILURE(status)) {
16ccf829 BM	173	ACPI_ERROR_NAMESPACE(walk_state->scope_info, path,
16ccf829 BM	174	status);
28f55ebc	175	return_ACPI_STATUS(status);
1da177e4 LT	176	}
	177
	178	/*
	179	* Check to make sure that the target is
	180	* one of the opcodes that actually opens a scope
	181	*/
	182	switch (node->type) {
15f0c0d1	183	case ACPI_TYPE_ANY:
4be44fcd	184	case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
1da177e4 LT	185	case ACPI_TYPE_DEVICE:
	186	case ACPI_TYPE_POWER:
	187	case ACPI_TYPE_PROCESSOR:
	188	case ACPI_TYPE_THERMAL:
	189
	190	/* These are acceptable types */
	191	break;
	192
	193	case ACPI_TYPE_INTEGER:
	194	case ACPI_TYPE_STRING:
	195	case ACPI_TYPE_BUFFER:
1da177e4	196	/*
f2cb1251 BM	197	* These types we will allow, but we will change the type.
f2cb1251 BM	198	* This enables some existing code of the form:
1da177e4 LT	199	*
	200	* Name (DEB, 0)
	201	* Scope (DEB) { ... }
	202	*
f2cb1251 BM	203	* Note: silently change the type here. On the second pass,
f2cb1251 BM	204	* we will report a warning
1da177e4	205	*/
4be44fcd	206	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
f2cb1251 BM	207	"Type override - [%4.4s] had invalid type (%s) "
	208	"for Scope operator, changed to type ANY\n",
	209	acpi_ut_get_node_name(node),
4be44fcd	210	acpi_ut_get_type_name(node->type)));
1da177e4 LT	211
	212	node->type = ACPI_TYPE_ANY;
	213	walk_state->scope_info->common.value = ACPI_TYPE_ANY;
	214	break;
	215
28f538b5	216	case ACPI_TYPE_METHOD:
28f538b5 BM	217	/*
	218	* Allow scope change to root during execution of module-level
	219	* code. Root is typed METHOD during this time.
	220	*/
	221	if ((node == acpi_gbl_root_node) &&
	222	(walk_state->
	223	parse_flags & ACPI_PARSE_MODULE_LEVEL)) {
	224	break;
	225	}
	226
c1a7c2ce	227	ACPI_FALLTHROUGH;
28f538b5	228
1da177e4 LT	229	default:
	230
	231	/* All other types are an error */
	232
b8e4d893	233	ACPI_ERROR((AE_INFO,
f2cb1251 BM	234	"Invalid type (%s) for target of "
	235	"Scope operator [%4.4s] (Cannot override)",
	236	acpi_ut_get_type_name(node->type),
	237	acpi_ut_get_node_name(node)));
1da177e4	238
28f55ebc	239	return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
1da177e4 LT	240	}
	241	break;
	242
1da177e4	243	default:
1da177e4	244	/*
44f6c012 RM	245	* For all other named opcodes, we will enter the name into
44f6c012 RM	246	* the namespace.
1da177e4 LT	247	*
	248	* Setup the search flags.
	249	* Since we are entering a name into the namespace, we do not want to
	250	* enable the search-to-root upsearch.
	251	*
	252	* There are only two conditions where it is acceptable that the name
	253	* already exists:
	254	* 1) the Scope() operator can reopen a scoping object that was
	255	* previously defined (Scope, Method, Device, etc.)
	256	* 2) Whenever we are parsing a deferred opcode (op_region, Buffer,
	257	* buffer_field, or Package), the name of the object is already
	258	* in the namespace.
	259	*/
	260	if (walk_state->deferred_node) {
52fc0b02	261
1da177e4 LT	262	/* This name is already in the namespace, get the node */
	263
	264	node = walk_state->deferred_node;
	265	status = AE_OK;
	266	break;
	267	}
	268
28f55ebc BM	269	/*
	270	* If we are executing a method, do not create any namespace objects
	271	* during the load phase, only during execution.
	272	*/
	273	if (walk_state->method_node) {
	274	node = NULL;
	275	status = AE_OK;
	276	break;
	277	}
	278
1da177e4 LT	279	flags = ACPI_NS_NO_UPSEARCH;
1da177e4 LT	280	if ((walk_state->opcode != AML_SCOPE_OP) &&
4be44fcd	281	(!(walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP))) {
8f6f0361 LZ	282	if (walk_state->namespace_override) {
	283	flags \|= ACPI_NS_OVERRIDE_IF_FOUND;
	284	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
	285	"[%s] Override allowed\n",
	286	acpi_ut_get_type_name
	287	(object_type)));
	288	} else {
	289	flags \|= ACPI_NS_ERROR_IF_FOUND;
	290	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
	291	"[%s] Cannot already exist\n",
	292	acpi_ut_get_type_name
	293	(object_type)));
	294	}
4be44fcd LB	295	} else {
	296	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
	297	"[%s] Both Find or Create allowed\n",
	298	acpi_ut_get_type_name(object_type)));
1da177e4 LT	299	}
	300
	301	/*
967440e3 BM	302	* Enter the named type into the internal namespace. We enter the name
967440e3 BM	303	* as we go downward in the parse tree. Any necessary subobjects that
44f6c012 RM	304	* involve arguments to the opcode must be created as we go back up the
44f6c012 RM	305	* parse tree later.
1da177e4	306	*/
4be44fcd LB	307	status =
	308	acpi_ns_lookup(walk_state->scope_info, path, object_type,
	309	ACPI_IMODE_LOAD_PASS1, flags, walk_state,
958dd242	310	&node);
4be44fcd	311	if (ACPI_FAILURE(status)) {
958dd242 BM	312	if (status == AE_ALREADY_EXISTS) {
	313
	314	/* The name already exists in this scope */
	315
	316	if (node->flags & ANOBJ_IS_EXTERNAL) {
	317	/*
	318	* Allow one create on an object or segment that was
	319	* previously declared External
	320	*/
	321	node->flags &= ~ANOBJ_IS_EXTERNAL;
	322	node->type = (u8) object_type;
	323
	324	/* Just retyped a node, probably will need to open a scope */
	325
	326	if (acpi_ns_opens_scope(object_type)) {
	327	status =
	328	acpi_ds_scope_stack_push
	329	(node, object_type,
	330	walk_state);
	331	if (ACPI_FAILURE(status)) {
	332	return_ACPI_STATUS
	333	(status);
	334	}
	335	}
967440e3	336
958dd242 BM	337	status = AE_OK;
	338	}
	339	}
	340
	341	if (ACPI_FAILURE(status)) {
16ccf829 BM	342	ACPI_ERROR_NAMESPACE(walk_state->scope_info,
16ccf829 BM	343	path, status);
958dd242 BM	344	return_ACPI_STATUS(status);
958dd242 BM	345	}
1da177e4 LT	346	}
	347	break;
	348	}
	349
1da177e4 LT	350	/* Common exit */
	351
	352	if (!op) {
52fc0b02	353
1da177e4 LT	354	/* Create a new op */
1da177e4 LT	355
62eb935b	356	op = acpi_ps_alloc_op(walk_state->opcode, walk_state->aml);
1da177e4	357	if (!op) {
28f55ebc	358	return_ACPI_STATUS(AE_NO_MEMORY);
1da177e4 LT	359	}
	360	}
	361
28f55ebc	362	/* Initialize the op */
1da177e4	363
178a0f63	364	#ifdef ACPI_CONSTANT_EVAL_ONLY
05c3507c	365	op->named.path = path;
1da177e4 LT	366	#endif
1da177e4 LT	367
28f55ebc BM	368	if (node) {
	369	/*
	370	* Put the Node in the "op" object that the parser uses, so we
	371	* can get it again quickly when this scope is closed
	372	*/
	373	op->common.node = node;
	374	op->named.name = node->name.integer;
	375	}
	376
4be44fcd LB	377	acpi_ps_append_arg(acpi_ps_get_parent_scope(&walk_state->parser_state),
4be44fcd LB	378	op);
1da177e4	379	*out_op = op;
28f55ebc	380	return_ACPI_STATUS(status);
1da177e4 LT	381	}
1da177e4 LT	382
1da177e4 LT	383	/*******************************************************************************
	384	*
	385	* FUNCTION: acpi_ds_load1_end_op
	386	*
	387	* PARAMETERS: walk_state - Current state of the parse tree walk
1da177e4 LT	388	*
	389	* RETURN: Status
	390	*
	391	* DESCRIPTION: Ascending callback used during the loading of the namespace,
	392	* both control methods and everything else.
	393	*
	394	******************************************************************************/
	395
28f55ebc	396	acpi_status acpi_ds_load1_end_op(struct acpi_walk_state *walk_state)
1da177e4	397	{
4be44fcd LB	398	union acpi_parse_object *op;
	399	acpi_object_type object_type;
	400	acpi_status status = AE_OK;
bdcf4cdb ES	401	#ifdef ACPI_ASL_COMPILER
	402	u8 param_count;
	403	#endif
	404
b229cf92	405	ACPI_FUNCTION_TRACE(ds_load1_end_op);
1da177e4 LT	406
1da177e4 LT	407	op = walk_state->op;
4be44fcd LB	408	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
4be44fcd LB	409	walk_state));
1da177e4	410
5ddbd771 EK	411	/*
	412	* Disassembler: handle create field operators here.
	413	*
	414	* create_buffer_field is a deferred op that is typically processed in load
	415	* pass 2. However, disassembly of control method contents walk the parse
	416	* tree with ACPI_PARSE_LOAD_PASS1 and AML_CREATE operators are processed
	417	* in a later walk. This is a problem when there is a control method that
	418	* has the same name as the AML_CREATE object. In this case, any use of the
	419	* name segment will be detected as a method call rather than a reference
	420	* to a buffer field.
	421	*
	422	* This earlier creation during disassembly solves this issue by inserting
	423	* the named object in the ACPI namespace so that references to this name
	424	* would be a name string rather than a method call.
	425	*/
	426	if ((walk_state->parse_flags & ACPI_PARSE_DISASSEMBLE) &&
	427	(walk_state->op_info->flags & AML_CREATE)) {
	428	status = acpi_ds_create_buffer_field(op, walk_state);
	429	return_ACPI_STATUS(status);
	430	}
	431
1da177e4 LT	432	/* We are only interested in opcodes that have an associated name */
	433
	434	if (!(walk_state->op_info->flags & (AML_NAMED \| AML_FIELD))) {
28f55ebc	435	return_ACPI_STATUS(AE_OK);
1da177e4 LT	436	}
	437
	438	/* Get the object type to determine if we should pop the scope */
	439
	440	object_type = walk_state->op_info->object_type;
	441
1da177e4	442	if (walk_state->op_info->flags & AML_FIELD) {
28f55ebc BM	443	/*
	444	* If we are executing a method, do not create any namespace objects
	445	* during the load phase, only during execution.
	446	*/
	447	if (!walk_state->method_node) {
	448	if (walk_state->opcode == AML_FIELD_OP \|\|
	449	walk_state->opcode == AML_BANK_FIELD_OP \|\|
	450	walk_state->opcode == AML_INDEX_FIELD_OP) {
	451	status =
	452	acpi_ds_init_field_objects(op, walk_state);
	453	}
1da177e4	454	}
28f55ebc	455	return_ACPI_STATUS(status);
1da177e4 LT	456	}
1da177e4 LT	457
28f55ebc BM	458	/*
	459	* If we are executing a method, do not create any namespace objects
	460	* during the load phase, only during execution.
	461	*/
	462	if (!walk_state->method_node) {
	463	if (op->common.aml_opcode == AML_REGION_OP) {
	464	status =
	465	acpi_ex_create_region(op->named.data,
	466	op->named.length,
1fad8738 BM	467	(acpi_adr_space_type)
	468	((op->common.value.arg)->
	469	common.value.integer),
28f55ebc BM	470	walk_state);
	471	if (ACPI_FAILURE(status)) {
	472	return_ACPI_STATUS(status);
	473	}
941f48bb LM	474	} else if (op->common.aml_opcode == AML_DATA_REGION_OP) {
	475	status =
	476	acpi_ex_create_region(op->named.data,
	477	op->named.length,
82a1b7cb	478	ACPI_ADR_SPACE_DATA_TABLE,
941f48bb LM	479	walk_state);
	480	if (ACPI_FAILURE(status)) {
	481	return_ACPI_STATUS(status);
	482	}
1da177e4 LT	483	}
1da177e4 LT	484	}
1da177e4 LT	485
1da177e4 LT	486	if (op->common.aml_opcode == AML_NAME_OP) {
52fc0b02	487
1da177e4 LT	488	/* For Name opcode, get the object type from the argument */
	489
	490	if (op->common.value.arg) {
4be44fcd LB	491	object_type = (acpi_ps_get_opcode_info((op->common.
	492	value.arg)->
	493	common.
	494	aml_opcode))->
	495	object_type;
28f55ebc BM	496
	497	/* Set node type if we have a namespace node */
	498
	499	if (op->common.node) {
	500	op->common.node->type = (u8) object_type;
	501	}
1da177e4 LT	502	}
1da177e4 LT	503	}
bdcf4cdb ES	504	#ifdef ACPI_ASL_COMPILER
	505	/*
	506	* For external opcode, get the object type from the argument and
	507	* get the parameter count from the argument's next.
	508	*/
	509	if (acpi_gbl_disasm_flag &&
	510	op->common.node && op->common.aml_opcode == AML_EXTERNAL_OP) {
	511	/*
	512	* Note, if this external is not a method
	513	* Op->Common.Value.Arg->Common.Next->Common.Value.Integer == 0
	514	* Therefore, param_count will be 0.
	515	*/
	516	param_count =
	517	(u8)op->common.value.arg->common.next->common.value.integer;
	518	object_type = (u8)op->common.value.arg->common.value.integer;
	519	op->common.node->flags \|= ANOBJ_IS_EXTERNAL;
	520	op->common.node->type = (u8)object_type;
	521
	522	acpi_dm_create_subobject_for_external((u8)object_type,
	523	&op->common.node,
	524	param_count);
	525
	526	/*
	527	* Add the external to the external list because we may be
	528	* emitting code based off of the items within the external list.
	529	*/
	530	acpi_dm_add_op_to_external_list(op, op->named.path,
	531	(u8)object_type, param_count,
	532	ACPI_EXT_ORIGIN_FROM_OPCODE \|
	533	ACPI_EXT_RESOLVED_REFERENCE);
	534	}
	535	#endif
1da177e4	536
defba1d8 BM	537	/*
	538	* If we are executing a method, do not create any namespace objects
	539	* during the load phase, only during execution.
	540	*/
	541	if (!walk_state->method_node) {
	542	if (op->common.aml_opcode == AML_METHOD_OP) {
	543	/*
	544	* method_op pkg_length name_string method_flags term_list
	545	*
	546	* Note: We must create the method node/object pair as soon as we
967440e3	547	* see the method declaration. This allows later pass1 parsing
defba1d8 BM	548	* of invocations of the method (need to know the number of
	549	* arguments.)
	550	*/
	551	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
b229cf92	552	"LOADING-Method: State=%p Op=%p NamedObj=%p\n",
defba1d8	553	walk_state, op, op->named.node));
1da177e4	554
defba1d8 BM	555	if (!acpi_ns_get_attached_object(op->named.node)) {
	556	walk_state->operands[0] =
	557	ACPI_CAST_PTR(void, op->named.node);
	558	walk_state->num_operands = 1;
1da177e4	559
defba1d8 BM	560	status =
	561	acpi_ds_create_operands(walk_state,
	562	op->common.value.
	563	arg);
	564	if (ACPI_SUCCESS(status)) {
	565	status =
	566	acpi_ex_create_method(op->named.
	567	data,
	568	op->named.
	569	length,
	570	walk_state);
	571	}
967440e3	572
defba1d8 BM	573	walk_state->operands[0] = NULL;
defba1d8 BM	574	walk_state->num_operands = 0;
1da177e4	575
defba1d8 BM	576	if (ACPI_FAILURE(status)) {
	577	return_ACPI_STATUS(status);
	578	}
1da177e4 LT	579	}
	580	}
	581	}
	582
defba1d8	583	/* Pop the scope stack (only if loading a table) */
1da177e4	584
bdcf4cdb ES	585	if (!walk_state->method_node &&
	586	op->common.aml_opcode != AML_EXTERNAL_OP &&
	587	acpi_ns_opens_scope(object_type)) {
4be44fcd LB	588	ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
	589	"(%s): Popping scope for Op %p\n",
	590	acpi_ut_get_type_name(object_type), op));
1da177e4	591
4be44fcd	592	status = acpi_ds_scope_stack_pop(walk_state);
1da177e4 LT	593	}
1da177e4 LT	594
28f55ebc	595	return_ACPI_STATUS(status);
1da177e4	596	}