[deliverable/linux.git] / drivers / acpi / acpica / exstore.c

/******************************************************************************
 *
 * Module Name: exstore - AML Interpreter object store support
 *
 *****************************************************************************/

/*
 * Copyright (C) 2000 - 2013, 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 "acdispat.h"
#include "acinterp.h"
#include "amlcode.h"
#include "acnamesp.h"

#define _COMPONENT          ACPI_EXECUTER
ACPI_MODULE_NAME("exstore")

/* Local prototypes */
static acpi_status
acpi_ex_store_object_to_index(union acpi_operand_object *val_desc,
			      union acpi_operand_object *dest_desc,
			      struct acpi_walk_state *walk_state);

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_store
 *
 * PARAMETERS:  *source_desc        - Value to be stored
 *              *dest_desc          - Where to store it. Must be an NS node
 *                                    or union acpi_operand_object of type
 *                                    Reference;
 *              walk_state          - Current walk state
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Store the value described by source_desc into the location
 *              described by dest_desc. Called by various interpreter
 *              functions to store the result of an operation into
 *              the destination operand -- not just simply the actual "Store"
 *              ASL operator.
 *
 ******************************************************************************/

acpi_status
acpi_ex_store(union acpi_operand_object *source_desc,
	      union acpi_operand_object *dest_desc,
	      struct acpi_walk_state *walk_state)
{
	acpi_status status = AE_OK;
	union acpi_operand_object *ref_desc = dest_desc;

	ACPI_FUNCTION_TRACE_PTR(ex_store, dest_desc);

	/* Validate parameters */

	if (!source_desc || !dest_desc) {
		ACPI_ERROR((AE_INFO, "Null parameter"));
		return_ACPI_STATUS(AE_AML_NO_OPERAND);
	}

	/* dest_desc can be either a namespace node or an ACPI object */

	if (ACPI_GET_DESCRIPTOR_TYPE(dest_desc) == ACPI_DESC_TYPE_NAMED) {
		/*
		 * Dest is a namespace node,
		 * Storing an object into a Named node.
		 */
		status = acpi_ex_store_object_to_node(source_desc,
						      (struct
						       acpi_namespace_node *)
						      dest_desc, walk_state,
						      ACPI_IMPLICIT_CONVERSION);

		return_ACPI_STATUS(status);
	}

	/* Destination object must be a Reference or a Constant object */

	switch (dest_desc->common.type) {
	case ACPI_TYPE_LOCAL_REFERENCE:

		break;

	case ACPI_TYPE_INTEGER:

		/* Allow stores to Constants -- a Noop as per ACPI spec */

		if (dest_desc->common.flags & AOPOBJ_AML_CONSTANT) {
			return_ACPI_STATUS(AE_OK);
		}

		/*lint -fallthrough */

	default:

		/* Destination is not a Reference object */

		ACPI_ERROR((AE_INFO,
			    "Target is not a Reference or Constant object - %s [%p]",
			    acpi_ut_get_object_type_name(dest_desc),
			    dest_desc));

		return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
	}

	/*
	 * Examine the Reference class. These cases are handled:
	 *
	 * 1) Store to Name (Change the object associated with a name)
	 * 2) Store to an indexed area of a Buffer or Package
	 * 3) Store to a Method Local or Arg
	 * 4) Store to the debug object
	 */
	switch (ref_desc->reference.class) {
	case ACPI_REFCLASS_REFOF:

		/* Storing an object into a Name "container" */

		status = acpi_ex_store_object_to_node(source_desc,
						      ref_desc->reference.
						      object, walk_state,
						      ACPI_IMPLICIT_CONVERSION);
		break;

	case ACPI_REFCLASS_INDEX:

		/* Storing to an Index (pointer into a packager or buffer) */

		status =
		    acpi_ex_store_object_to_index(source_desc, ref_desc,
						  walk_state);
		break;

	case ACPI_REFCLASS_LOCAL:
	case ACPI_REFCLASS_ARG:

		/* Store to a method local/arg  */

		status =
		    acpi_ds_store_object_to_local(ref_desc->reference.class,
						  ref_desc->reference.value,
						  source_desc, walk_state);
		break;

	case ACPI_REFCLASS_DEBUG:
		/*
		 * Storing to the Debug object causes the value stored to be
		 * displayed and otherwise has no effect -- see ACPI Specification
		 */
		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
				  "**** Write to Debug Object: Object %p %s ****:\n\n",
				  source_desc,
				  acpi_ut_get_object_type_name(source_desc)));

		ACPI_DEBUG_OBJECT(source_desc, 0, 0);
		break;

	default:

		ACPI_ERROR((AE_INFO, "Unknown Reference Class 0x%2.2X",
			    ref_desc->reference.class));
		ACPI_DUMP_ENTRY(ref_desc, ACPI_LV_INFO);

		status = AE_AML_INTERNAL;
		break;
	}

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_store_object_to_index
 *
 * PARAMETERS:  *source_desc            - Value to be stored
 *              *dest_desc              - Named object to receive the value
 *              walk_state              - Current walk state
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Store the object to indexed Buffer or Package element
 *
 ******************************************************************************/

static acpi_status
acpi_ex_store_object_to_index(union acpi_operand_object *source_desc,
			      union acpi_operand_object *index_desc,
			      struct acpi_walk_state *walk_state)
{
	acpi_status status = AE_OK;
	union acpi_operand_object *obj_desc;
	union acpi_operand_object *new_desc;
	u8 value = 0;
	u32 i;

	ACPI_FUNCTION_TRACE(ex_store_object_to_index);

	/*
	 * Destination must be a reference pointer, and
	 * must point to either a buffer or a package
	 */
	switch (index_desc->reference.target_type) {
	case ACPI_TYPE_PACKAGE:
		/*
		 * Storing to a package element. Copy the object and replace
		 * any existing object with the new object. No implicit
		 * conversion is performed.
		 *
		 * The object at *(index_desc->Reference.Where) is the
		 * element within the package that is to be modified.
		 * The parent package object is at index_desc->Reference.Object
		 */
		obj_desc = *(index_desc->reference.where);

		if (source_desc->common.type == ACPI_TYPE_LOCAL_REFERENCE &&
		    source_desc->reference.class == ACPI_REFCLASS_TABLE) {

			/* This is a DDBHandle, just add a reference to it */

			acpi_ut_add_reference(source_desc);
			new_desc = source_desc;
		} else {
			/* Normal object, copy it */

			status =
			    acpi_ut_copy_iobject_to_iobject(source_desc,
							    &new_desc,
							    walk_state);
			if (ACPI_FAILURE(status)) {
				return_ACPI_STATUS(status);
			}
		}

		if (obj_desc) {

			/* Decrement reference count by the ref count of the parent package */

			for (i = 0; i < ((union acpi_operand_object *)
					 index_desc->reference.object)->common.
			     reference_count; i++) {
				acpi_ut_remove_reference(obj_desc);
			}
		}

		*(index_desc->reference.where) = new_desc;

		/* Increment ref count by the ref count of the parent package-1 */

		for (i = 1; i < ((union acpi_operand_object *)
				 index_desc->reference.object)->common.
		     reference_count; i++) {
			acpi_ut_add_reference(new_desc);
		}

		break;

	case ACPI_TYPE_BUFFER_FIELD:
		/*
		 * Store into a Buffer or String (not actually a real buffer_field)
		 * at a location defined by an Index.
		 *
		 * The first 8-bit element of the source object is written to the
		 * 8-bit Buffer location defined by the Index destination object,
		 * according to the ACPI 2.0 specification.
		 */

		/*
		 * Make sure the target is a Buffer or String. An error should
		 * not happen here, since the reference_object was constructed
		 * by the INDEX_OP code.
		 */
		obj_desc = index_desc->reference.object;
		if ((obj_desc->common.type != ACPI_TYPE_BUFFER) &&
		    (obj_desc->common.type != ACPI_TYPE_STRING)) {
			return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
		}

		/*
		 * The assignment of the individual elements will be slightly
		 * different for each source type.
		 */
		switch (source_desc->common.type) {
		case ACPI_TYPE_INTEGER:

			/* Use the least-significant byte of the integer */

			value = (u8) (source_desc->integer.value);
			break;

		case ACPI_TYPE_BUFFER:
		case ACPI_TYPE_STRING:

			/* Note: Takes advantage of common string/buffer fields */

			value = source_desc->buffer.pointer[0];
			break;

		default:

			/* All other types are invalid */

			ACPI_ERROR((AE_INFO,
				    "Source must be Integer/Buffer/String type, not %s",
				    acpi_ut_get_object_type_name(source_desc)));
			return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
		}

		/* Store the source value into the target buffer byte */

		obj_desc->buffer.pointer[index_desc->reference.value] = value;
		break;

	default:
		ACPI_ERROR((AE_INFO, "Target is not a Package or BufferField"));
		status = AE_AML_OPERAND_TYPE;
		break;
	}

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_store_object_to_node
 *
 * PARAMETERS:  source_desc             - Value to be stored
 *              node                    - Named object to receive the value
 *              walk_state              - Current walk state
 *              implicit_conversion     - Perform implicit conversion (yes/no)
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Store the object to the named object.
 *
 *              The Assignment of an object to a named object is handled here
 *              The value passed in will replace the current value (if any)
 *              with the input value.
 *
 *              When storing into an object the data is converted to the
 *              target object type then stored in the object. This means
 *              that the target object type (for an initialized target) will
 *              not be changed by a store operation.
 *
 *              Assumes parameters are already validated.
 *
 ******************************************************************************/

acpi_status
acpi_ex_store_object_to_node(union acpi_operand_object *source_desc,
			     struct acpi_namespace_node *node,
			     struct acpi_walk_state *walk_state,
			     u8 implicit_conversion)
{
	acpi_status status = AE_OK;
	union acpi_operand_object *target_desc;
	union acpi_operand_object *new_desc;
	acpi_object_type target_type;

	ACPI_FUNCTION_TRACE_PTR(ex_store_object_to_node, source_desc);

	/* Get current type of the node, and object attached to Node */

	target_type = acpi_ns_get_type(node);
	target_desc = acpi_ns_get_attached_object(node);

	ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Storing %p(%s) into node %p(%s)\n",
			  source_desc,
			  acpi_ut_get_object_type_name(source_desc), node,
			  acpi_ut_get_type_name(target_type)));

	/*
	 * Resolve the source object to an actual value
	 * (If it is a reference object)
	 */
	status = acpi_ex_resolve_object(&source_desc, target_type, walk_state);
	if (ACPI_FAILURE(status)) {
		return_ACPI_STATUS(status);
	}

	/* If no implicit conversion, drop into the default case below */

	if ((!implicit_conversion) ||
	    ((walk_state->opcode == AML_COPY_OP) &&
	     (target_type != ACPI_TYPE_LOCAL_REGION_FIELD) &&
	     (target_type != ACPI_TYPE_LOCAL_BANK_FIELD) &&
	     (target_type != ACPI_TYPE_LOCAL_INDEX_FIELD))) {
		/*
		 * Force execution of default (no implicit conversion). Note:
		 * copy_object does not perform an implicit conversion, as per the ACPI
		 * spec -- except in case of region/bank/index fields -- because these
		 * objects must retain their original type permanently.
		 */
		target_type = ACPI_TYPE_ANY;
	}

	/* Do the actual store operation */

	switch (target_type) {
	case ACPI_TYPE_BUFFER_FIELD:
	case ACPI_TYPE_LOCAL_REGION_FIELD:
	case ACPI_TYPE_LOCAL_BANK_FIELD:
	case ACPI_TYPE_LOCAL_INDEX_FIELD:

		/* For fields, copy the source data to the target field. */

		status = acpi_ex_write_data_to_field(source_desc, target_desc,
						     &walk_state->result_obj);
		break;

	case ACPI_TYPE_INTEGER:
	case ACPI_TYPE_STRING:
	case ACPI_TYPE_BUFFER:
		/*
		 * These target types are all of type Integer/String/Buffer, and
		 * therefore support implicit conversion before the store.
		 *
		 * Copy and/or convert the source object to a new target object
		 */
		status =
		    acpi_ex_store_object_to_object(source_desc, target_desc,
						   &new_desc, walk_state);
		if (ACPI_FAILURE(status)) {
			return_ACPI_STATUS(status);
		}

		if (new_desc != target_desc) {
			/*
			 * Store the new new_desc as the new value of the Name, and set
			 * the Name's type to that of the value being stored in it.
			 * source_desc reference count is incremented by attach_object.
			 *
			 * Note: This may change the type of the node if an explicit store
			 * has been performed such that the node/object type has been
			 * changed.
			 */
			status =
			    acpi_ns_attach_object(node, new_desc,
						  new_desc->common.type);

			ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
					  "Store %s into %s via Convert/Attach\n",
					  acpi_ut_get_object_type_name
					  (source_desc),
					  acpi_ut_get_object_type_name
					  (new_desc)));
		}
		break;

	default:

		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
				  "Storing [%s] (%p) directly into node [%s] (%p)"
				  " with no implicit conversion\n",
				  acpi_ut_get_object_type_name(source_desc),
				  source_desc,
				  acpi_ut_get_object_type_name(target_desc),
				  node));

		/*
		 * No conversions for all other types. Directly store a copy of
		 * the source object. NOTE: This is a departure from the ACPI
		 * spec, which states "If conversion is impossible, abort the
		 * running control method".
		 *
		 * This code implements "If conversion is impossible, treat the
		 * Store operation as a CopyObject".
		 */
		status =
		    acpi_ut_copy_iobject_to_iobject(source_desc, &new_desc,
						    walk_state);
		if (ACPI_FAILURE(status)) {
			return_ACPI_STATUS(status);
		}

		status =
		    acpi_ns_attach_object(node, new_desc,
					  new_desc->common.type);
		acpi_ut_remove_reference(new_desc);
		break;
	}

	return_ACPI_STATUS(status);
}
Commit	Line	Data
1da177e4 LT	1	/******************************************************************************
	2	*
	3	* Module Name: exstore - AML Interpreter object store support
	4	*
	5	*****************************************************************************/
	6
	7	/*
25f044e6	8	* Copyright (C) 2000 - 2013, Intel Corp.
1da177e4 LT	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
1da177e4	44	#include <acpi/acpi.h>
e2f7a777 LB	45	#include "accommon.h"
	46	#include "acdispat.h"
	47	#include "acinterp.h"
	48	#include "amlcode.h"
	49	#include "acnamesp.h"
1da177e4	50
1da177e4	51	#define _COMPONENT ACPI_EXECUTER
4be44fcd	52	ACPI_MODULE_NAME("exstore")
1da177e4	53
44f6c012	54	/* Local prototypes */
44f6c012	55	static acpi_status
4be44fcd LB	56	acpi_ex_store_object_to_index(union acpi_operand_object *val_desc,
	57	union acpi_operand_object *dest_desc,
	58	struct acpi_walk_state *walk_state);
44f6c012	59
1da177e4 LT	60	/*******************************************************************************
	61	*
	62	* FUNCTION: acpi_ex_store
	63	*
	64	* PARAMETERS: *source_desc - Value to be stored
cf48958e BM	65	* *dest_desc - Where to store it. Must be an NS node
cf48958e BM	66	* or union acpi_operand_object of type
1da177e4 LT	67	* Reference;
	68	* walk_state - Current walk state
	69	*
	70	* RETURN: Status
	71	*
	72	* DESCRIPTION: Store the value described by source_desc into the location
	73	* described by dest_desc. Called by various interpreter
	74	* functions to store the result of an operation into
	75	* the destination operand -- not just simply the actual "Store"
	76	* ASL operator.
	77	*
	78	******************************************************************************/
	79
	80	acpi_status
4be44fcd LB	81	acpi_ex_store(union acpi_operand_object *source_desc,
	82	union acpi_operand_object *dest_desc,
	83	struct acpi_walk_state *walk_state)
1da177e4	84	{
4be44fcd LB	85	acpi_status status = AE_OK;
4be44fcd LB	86	union acpi_operand_object *ref_desc = dest_desc;
1da177e4	87
b229cf92	88	ACPI_FUNCTION_TRACE_PTR(ex_store, dest_desc);
1da177e4 LT	89
	90	/* Validate parameters */
	91
	92	if (!source_desc \|\| !dest_desc) {
b8e4d893	93	ACPI_ERROR((AE_INFO, "Null parameter"));
4be44fcd	94	return_ACPI_STATUS(AE_AML_NO_OPERAND);
1da177e4 LT	95	}
	96
	97	/* dest_desc can be either a namespace node or an ACPI object */
	98
4be44fcd	99	if (ACPI_GET_DESCRIPTOR_TYPE(dest_desc) == ACPI_DESC_TYPE_NAMED) {
1da177e4 LT	100	/*
	101	* Dest is a namespace node,
	102	* Storing an object into a Named node.
	103	*/
4be44fcd LB	104	status = acpi_ex_store_object_to_node(source_desc,
	105	(struct
	106	acpi_namespace_node *)
	107	dest_desc, walk_state,
	108	ACPI_IMPLICIT_CONVERSION);
1da177e4	109
4be44fcd	110	return_ACPI_STATUS(status);
1da177e4 LT	111	}
	112
	113	/* Destination object must be a Reference or a Constant object */
	114
3371c19c	115	switch (dest_desc->common.type) {
1da177e4	116	case ACPI_TYPE_LOCAL_REFERENCE:
1d1ea1b7	117
1da177e4 LT	118	break;
	119
	120	case ACPI_TYPE_INTEGER:
	121
	122	/* Allow stores to Constants -- a Noop as per ACPI spec */
	123
	124	if (dest_desc->common.flags & AOPOBJ_AML_CONSTANT) {
4be44fcd	125	return_ACPI_STATUS(AE_OK);
1da177e4 LT	126	}
	127
	128	/lint -fallthrough /
	129
	130	default:
	131
	132	/* Destination is not a Reference object */
	133
b8e4d893 BM	134	ACPI_ERROR((AE_INFO,
	135	"Target is not a Reference or Constant object - %s [%p]",
	136	acpi_ut_get_object_type_name(dest_desc),
	137	dest_desc));
1da177e4	138
4be44fcd	139	return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
1da177e4 LT	140	}
	141
	142	/*
1044f1f6	143	* Examine the Reference class. These cases are handled:
1da177e4 LT	144	*
	145	* 1) Store to Name (Change the object associated with a name)
	146	* 2) Store to an indexed area of a Buffer or Package
	147	* 3) Store to a Method Local or Arg
	148	* 4) Store to the debug object
	149	*/
1044f1f6 BM	150	switch (ref_desc->reference.class) {
1044f1f6 BM	151	case ACPI_REFCLASS_REFOF:
1da177e4 LT	152
	153	/* Storing an object into a Name "container" */
	154
4be44fcd LB	155	status = acpi_ex_store_object_to_node(source_desc,
	156	ref_desc->reference.
	157	object, walk_state,
	158	ACPI_IMPLICIT_CONVERSION);
1da177e4 LT	159	break;
1da177e4 LT	160
1044f1f6	161	case ACPI_REFCLASS_INDEX:
1da177e4 LT	162
	163	/* Storing to an Index (pointer into a packager or buffer) */
	164
4be44fcd LB	165	status =
	166	acpi_ex_store_object_to_index(source_desc, ref_desc,
	167	walk_state);
1da177e4 LT	168	break;
1da177e4 LT	169
1044f1f6 BM	170	case ACPI_REFCLASS_LOCAL:
1044f1f6 BM	171	case ACPI_REFCLASS_ARG:
1da177e4 LT	172
	173	/* Store to a method local/arg */
	174
4be44fcd	175	status =
1044f1f6 BM	176	acpi_ds_store_object_to_local(ref_desc->reference.class,
1044f1f6 BM	177	ref_desc->reference.value,
4be44fcd	178	source_desc, walk_state);
1da177e4 LT	179	break;
1da177e4 LT	180
1044f1f6	181	case ACPI_REFCLASS_DEBUG:
1da177e4 LT	182	/*
	183	* Storing to the Debug object causes the value stored to be
	184	* displayed and otherwise has no effect -- see ACPI Specification
	185	*/
4be44fcd LB	186	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
	187	"** Write to Debug Object: Object %p %s **:\n\n",
	188	source_desc,
	189	acpi_ut_get_object_type_name(source_desc)));
1da177e4	190
4cdf1a56	191	ACPI_DEBUG_OBJECT(source_desc, 0, 0);
1da177e4 LT	192	break;
1da177e4 LT	193
1da177e4 LT	194	default:
1da177e4 LT	195
f6a22b0b	196	ACPI_ERROR((AE_INFO, "Unknown Reference Class 0x%2.2X",
1044f1f6	197	ref_desc->reference.class));
23d3e055	198	ACPI_DUMP_ENTRY(ref_desc, ACPI_LV_INFO);
1da177e4 LT	199
	200	status = AE_AML_INTERNAL;
	201	break;
	202	}
	203
4be44fcd	204	return_ACPI_STATUS(status);
1da177e4 LT	205	}
1da177e4 LT	206
1da177e4 LT	207	/*******************************************************************************
	208	*
	209	* FUNCTION: acpi_ex_store_object_to_index
	210	*
	211	* PARAMETERS: *source_desc - Value to be stored
	212	* *dest_desc - Named object to receive the value
	213	* walk_state - Current walk state
	214	*
	215	* RETURN: Status
	216	*
	217	* DESCRIPTION: Store the object to indexed Buffer or Package element
	218	*
	219	******************************************************************************/
	220
44f6c012	221	static acpi_status
4be44fcd LB	222	acpi_ex_store_object_to_index(union acpi_operand_object *source_desc,
	223	union acpi_operand_object *index_desc,
	224	struct acpi_walk_state *walk_state)
1da177e4	225	{
4be44fcd LB	226	acpi_status status = AE_OK;
	227	union acpi_operand_object *obj_desc;
	228	union acpi_operand_object *new_desc;
	229	u8 value = 0;
	230	u32 i;
1da177e4	231
b229cf92	232	ACPI_FUNCTION_TRACE(ex_store_object_to_index);
1da177e4 LT	233
	234	/*
	235	* Destination must be a reference pointer, and
	236	* must point to either a buffer or a package
	237	*/
	238	switch (index_desc->reference.target_type) {
	239	case ACPI_TYPE_PACKAGE:
	240	/*
	241	* Storing to a package element. Copy the object and replace
	242	* any existing object with the new object. No implicit
	243	* conversion is performed.
	244	*
	245	* The object at *(index_desc->Reference.Where) is the
	246	* element within the package that is to be modified.
	247	* The parent package object is at index_desc->Reference.Object
	248	*/
	249	obj_desc = *(index_desc->reference.where);
	250
3371c19c BM	251	if (source_desc->common.type == ACPI_TYPE_LOCAL_REFERENCE &&
3371c19c BM	252	source_desc->reference.class == ACPI_REFCLASS_TABLE) {
bc7a36ab LM	253
	254	/* This is a DDBHandle, just add a reference to it */
	255
	256	acpi_ut_add_reference(source_desc);
	257	new_desc = source_desc;
	258	} else {
	259	/* Normal object, copy it */
	260
	261	status =
	262	acpi_ut_copy_iobject_to_iobject(source_desc,
	263	&new_desc,
	264	walk_state);
	265	if (ACPI_FAILURE(status)) {
	266	return_ACPI_STATUS(status);
	267	}
1da177e4 LT	268	}
	269
	270	if (obj_desc) {
52fc0b02	271
1da177e4 LT	272	/* Decrement reference count by the ref count of the parent package */
1da177e4 LT	273
4be44fcd LB	274	for (i = 0; i < ((union acpi_operand_object *)
	275	index_desc->reference.object)->common.
	276	reference_count; i++) {
	277	acpi_ut_remove_reference(obj_desc);
1da177e4 LT	278	}
	279	}
	280
	281	*(index_desc->reference.where) = new_desc;
	282
44f6c012	283	/* Increment ref count by the ref count of the parent package-1 */
1da177e4	284
4be44fcd LB	285	for (i = 1; i < ((union acpi_operand_object *)
	286	index_desc->reference.object)->common.
	287	reference_count; i++) {
	288	acpi_ut_add_reference(new_desc);
1da177e4 LT	289	}
	290
	291	break;
	292
1da177e4	293	case ACPI_TYPE_BUFFER_FIELD:
1da177e4 LT	294	/*
	295	* Store into a Buffer or String (not actually a real buffer_field)
	296	* at a location defined by an Index.
	297	*
	298	* The first 8-bit element of the source object is written to the
	299	* 8-bit Buffer location defined by the Index destination object,
	300	* according to the ACPI 2.0 specification.
	301	*/
	302
	303	/*
	304	* Make sure the target is a Buffer or String. An error should
	305	* not happen here, since the reference_object was constructed
	306	* by the INDEX_OP code.
	307	*/
	308	obj_desc = index_desc->reference.object;
3371c19c BM	309	if ((obj_desc->common.type != ACPI_TYPE_BUFFER) &&
3371c19c BM	310	(obj_desc->common.type != ACPI_TYPE_STRING)) {
4be44fcd	311	return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
1da177e4 LT	312	}
	313
	314	/*
	315	* The assignment of the individual elements will be slightly
	316	* different for each source type.
	317	*/
3371c19c	318	switch (source_desc->common.type) {
1da177e4 LT	319	case ACPI_TYPE_INTEGER:
	320
	321	/* Use the least-significant byte of the integer */
	322
	323	value = (u8) (source_desc->integer.value);
	324	break;
	325
	326	case ACPI_TYPE_BUFFER:
	327	case ACPI_TYPE_STRING:
	328
	329	/* Note: Takes advantage of common string/buffer fields */
	330
	331	value = source_desc->buffer.pointer[0];
	332	break;
	333
	334	default:
	335
	336	/* All other types are invalid */
	337
b8e4d893 BM	338	ACPI_ERROR((AE_INFO,
	339	"Source must be Integer/Buffer/String type, not %s",
	340	acpi_ut_get_object_type_name(source_desc)));
4be44fcd	341	return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
1da177e4 LT	342	}
	343
	344	/* Store the source value into the target buffer byte */
	345
1044f1f6	346	obj_desc->buffer.pointer[index_desc->reference.value] = value;
1da177e4 LT	347	break;
1da177e4 LT	348
1da177e4	349	default:
b229cf92	350	ACPI_ERROR((AE_INFO, "Target is not a Package or BufferField"));
1da177e4 LT	351	status = AE_AML_OPERAND_TYPE;
	352	break;
	353	}
	354
4be44fcd	355	return_ACPI_STATUS(status);
1da177e4 LT	356	}
1da177e4 LT	357
1da177e4 LT	358	/*******************************************************************************
	359	*
	360	* FUNCTION: acpi_ex_store_object_to_node
	361	*
	362	* PARAMETERS: source_desc - Value to be stored
ba494bee	363	* node - Named object to receive the value
1da177e4 LT	364	* walk_state - Current walk state
	365	* implicit_conversion - Perform implicit conversion (yes/no)
	366	*
	367	* RETURN: Status
	368	*
	369	* DESCRIPTION: Store the object to the named object.
	370	*
	371	* The Assignment of an object to a named object is handled here
	372	* The value passed in will replace the current value (if any)
	373	* with the input value.
	374	*
	375	* When storing into an object the data is converted to the
73a3090a	376	* target object type then stored in the object. This means
1da177e4 LT	377	* that the target object type (for an initialized target) will
	378	* not be changed by a store operation.
	379	*
	380	* Assumes parameters are already validated.
	381	*
	382	******************************************************************************/
	383
	384	acpi_status
4be44fcd LB	385	acpi_ex_store_object_to_node(union acpi_operand_object *source_desc,
	386	struct acpi_namespace_node *node,
	387	struct acpi_walk_state *walk_state,
	388	u8 implicit_conversion)
1da177e4	389	{
4be44fcd LB	390	acpi_status status = AE_OK;
	391	union acpi_operand_object *target_desc;
	392	union acpi_operand_object *new_desc;
	393	acpi_object_type target_type;
1da177e4	394
b229cf92	395	ACPI_FUNCTION_TRACE_PTR(ex_store_object_to_node, source_desc);
1da177e4	396
44f6c012 RM	397	/* Get current type of the node, and object attached to Node */
44f6c012 RM	398
4be44fcd LB	399	target_type = acpi_ns_get_type(node);
4be44fcd LB	400	target_desc = acpi_ns_get_attached_object(node);
1da177e4	401
4be44fcd LB	402	ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Storing %p(%s) into node %p(%s)\n",
	403	source_desc,
	404	acpi_ut_get_object_type_name(source_desc), node,
	405	acpi_ut_get_type_name(target_type)));
1da177e4 LT	406
	407	/*
	408	* Resolve the source object to an actual value
	409	* (If it is a reference object)
	410	*/
4be44fcd LB	411	status = acpi_ex_resolve_object(&source_desc, target_type, walk_state);
	412	if (ACPI_FAILURE(status)) {
	413	return_ACPI_STATUS(status);
1da177e4 LT	414	}
	415
	416	/* If no implicit conversion, drop into the default case below */
	417
a3df4dad LM	418	if ((!implicit_conversion) \|\|
	419	((walk_state->opcode == AML_COPY_OP) &&
	420	(target_type != ACPI_TYPE_LOCAL_REGION_FIELD) &&
	421	(target_type != ACPI_TYPE_LOCAL_BANK_FIELD) &&
	422	(target_type != ACPI_TYPE_LOCAL_INDEX_FIELD))) {
	423	/*
	424	* Force execution of default (no implicit conversion). Note:
	425	* copy_object does not perform an implicit conversion, as per the ACPI
	426	* spec -- except in case of region/bank/index fields -- because these
	427	* objects must retain their original type permanently.
	428	*/
1da177e4 LT	429	target_type = ACPI_TYPE_ANY;
	430	}
	431
44f6c012 RM	432	/* Do the actual store operation */
44f6c012 RM	433
1da177e4 LT	434	switch (target_type) {
	435	case ACPI_TYPE_BUFFER_FIELD:
	436	case ACPI_TYPE_LOCAL_REGION_FIELD:
	437	case ACPI_TYPE_LOCAL_BANK_FIELD:
	438	case ACPI_TYPE_LOCAL_INDEX_FIELD:
	439
44f6c012 RM	440	/* For fields, copy the source data to the target field. */
44f6c012 RM	441
4be44fcd LB	442	status = acpi_ex_write_data_to_field(source_desc, target_desc,
4be44fcd LB	443	&walk_state->result_obj);
1da177e4 LT	444	break;
1da177e4 LT	445
1da177e4 LT	446	case ACPI_TYPE_INTEGER:
	447	case ACPI_TYPE_STRING:
	448	case ACPI_TYPE_BUFFER:
1da177e4 LT	449	/*
	450	* These target types are all of type Integer/String/Buffer, and
	451	* therefore support implicit conversion before the store.
	452	*
	453	* Copy and/or convert the source object to a new target object
	454	*/
4be44fcd LB	455	status =
	456	acpi_ex_store_object_to_object(source_desc, target_desc,
	457	&new_desc, walk_state);
	458	if (ACPI_FAILURE(status)) {
	459	return_ACPI_STATUS(status);
1da177e4 LT	460	}
	461
	462	if (new_desc != target_desc) {
	463	/*
	464	* Store the new new_desc as the new value of the Name, and set
	465	* the Name's type to that of the value being stored in it.
	466	* source_desc reference count is incremented by attach_object.
	467	*
	468	* Note: This may change the type of the node if an explicit store
	469	* has been performed such that the node/object type has been
	470	* changed.
	471	*/
4be44fcd LB	472	status =
	473	acpi_ns_attach_object(node, new_desc,
	474	new_desc->common.type);
	475
	476	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
	477	"Store %s into %s via Convert/Attach\n",
	478	acpi_ut_get_object_type_name
	479	(source_desc),
	480	acpi_ut_get_object_type_name
	481	(new_desc)));
1da177e4 LT	482	}
	483	break;
	484
1da177e4 LT	485	default:
1da177e4 LT	486
4be44fcd	487	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
3f654bad BM	488	"Storing [%s] (%p) directly into node [%s] (%p)"
3f654bad BM	489	" with no implicit conversion\n",
4be44fcd	490	acpi_ut_get_object_type_name(source_desc),
3f654bad BM	491	source_desc,
	492	acpi_ut_get_object_type_name(target_desc),
	493	node));
1da177e4	494
3f654bad BM	495	/*
	496	* No conversions for all other types. Directly store a copy of
	497	* the source object. NOTE: This is a departure from the ACPI
	498	* spec, which states "If conversion is impossible, abort the
	499	* running control method".
	500	*
	501	* This code implements "If conversion is impossible, treat the
	502	* Store operation as a CopyObject".
	503	*/
	504	status =
	505	acpi_ut_copy_iobject_to_iobject(source_desc, &new_desc,
	506	walk_state);
	507	if (ACPI_FAILURE(status)) {
	508	return_ACPI_STATUS(status);
	509	}
1da177e4	510
3f654bad BM	511	status =
	512	acpi_ns_attach_object(node, new_desc,
	513	new_desc->common.type);
	514	acpi_ut_remove_reference(new_desc);
1da177e4 LT	515	break;
	516	}
	517
4be44fcd	518	return_ACPI_STATUS(status);
1da177e4	519	}