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

/******************************************************************************
 *
 * Module Name: exfield - ACPI AML (p-code) execution - field manipulation
 *
 *****************************************************************************/

/*
 * Copyright (C) 2000 - 2014, Intel Corp.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 * 3. Neither the names of the above-listed copyright holders nor the names
 *    of any contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 */

#include <acpi/acpi.h>
#include "accommon.h"
#include "acdispat.h"
#include "acinterp.h"
#include "amlcode.h"

#define _COMPONENT          ACPI_EXECUTER
ACPI_MODULE_NAME("exfield")

/* Local prototypes */
static u32
acpi_ex_get_serial_access_length(u32 accessor_type, u32 access_length);

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_get_serial_access_length
 *
 * PARAMETERS:  accessor_type   - The type of the protocol indicated by region
 *                                field access attributes
 *              access_length   - The access length of the region field
 *
 * RETURN:      Decoded access length
 *
 * DESCRIPTION: This routine returns the length of the generic_serial_bus
 *              protocol bytes
 *
 ******************************************************************************/

static u32
acpi_ex_get_serial_access_length(u32 accessor_type, u32 access_length)
{
	u32 length;

	switch (accessor_type) {
	case AML_FIELD_ATTRIB_QUICK:

		length = 0;
		break;

	case AML_FIELD_ATTRIB_SEND_RCV:
	case AML_FIELD_ATTRIB_BYTE:

		length = 1;
		break;

	case AML_FIELD_ATTRIB_WORD:
	case AML_FIELD_ATTRIB_WORD_CALL:

		length = 2;
		break;

	case AML_FIELD_ATTRIB_MULTIBYTE:
	case AML_FIELD_ATTRIB_RAW_BYTES:
	case AML_FIELD_ATTRIB_RAW_PROCESS:

		length = access_length;
		break;

	case AML_FIELD_ATTRIB_BLOCK:
	case AML_FIELD_ATTRIB_BLOCK_CALL:
	default:

		length = ACPI_GSBUS_BUFFER_SIZE - 2;
		break;
	}

	return (length);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_read_data_from_field
 *
 * PARAMETERS:  walk_state          - Current execution state
 *              obj_desc            - The named field
 *              ret_buffer_desc     - Where the return data object is stored
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Read from a named field. Returns either an Integer or a
 *              Buffer, depending on the size of the field.
 *
 ******************************************************************************/

acpi_status
acpi_ex_read_data_from_field(struct acpi_walk_state * walk_state,
			     union acpi_operand_object *obj_desc,
			     union acpi_operand_object **ret_buffer_desc)
{
	acpi_status status;
	union acpi_operand_object *buffer_desc;
	acpi_size length;
	void *buffer;
	u32 function;
	u16 accessor_type;

	ACPI_FUNCTION_TRACE_PTR(ex_read_data_from_field, obj_desc);

	/* Parameter validation */

	if (!obj_desc) {
		return_ACPI_STATUS(AE_AML_NO_OPERAND);
	}
	if (!ret_buffer_desc) {
		return_ACPI_STATUS(AE_BAD_PARAMETER);
	}

	if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) {
		/*
		 * If the buffer_field arguments have not been previously evaluated,
		 * evaluate them now and save the results.
		 */
		if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
			status = acpi_ds_get_buffer_field_arguments(obj_desc);
			if (ACPI_FAILURE(status)) {
				return_ACPI_STATUS(status);
			}
		}
	} else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
		   (obj_desc->field.region_obj->region.space_id ==
		    ACPI_ADR_SPACE_SMBUS
		    || obj_desc->field.region_obj->region.space_id ==
		    ACPI_ADR_SPACE_GSBUS
		    || obj_desc->field.region_obj->region.space_id ==
		    ACPI_ADR_SPACE_IPMI)) {
		/*
		 * This is an SMBus, GSBus or IPMI read. We must create a buffer to hold
		 * the data and then directly access the region handler.
		 *
		 * Note: SMBus and GSBus protocol value is passed in upper 16-bits of Function
		 */
		if (obj_desc->field.region_obj->region.space_id ==
		    ACPI_ADR_SPACE_SMBUS) {
			length = ACPI_SMBUS_BUFFER_SIZE;
			function =
			    ACPI_READ | (obj_desc->field.attribute << 16);
		} else if (obj_desc->field.region_obj->region.space_id ==
			   ACPI_ADR_SPACE_GSBUS) {
			accessor_type = obj_desc->field.attribute;
			length = acpi_ex_get_serial_access_length(accessor_type,
								  obj_desc->
								  field.
								  access_length);

			/*
			 * Add additional 2 bytes for the generic_serial_bus data buffer:
			 *
			 *     Status;      (Byte 0 of the data buffer)
			 *     Length;      (Byte 1 of the data buffer)
			 *     Data[x-1];   (Bytes 2-x of the arbitrary length data buffer)
			 */
			length += 2;
			function = ACPI_READ | (accessor_type << 16);
		} else {	/* IPMI */

			length = ACPI_IPMI_BUFFER_SIZE;
			function = ACPI_READ;
		}

		buffer_desc = acpi_ut_create_buffer_object(length);
		if (!buffer_desc) {
			return_ACPI_STATUS(AE_NO_MEMORY);
		}

		/* Lock entire transaction if requested */

		acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);

		/* Call the region handler for the read */

		status = acpi_ex_access_region(obj_desc, 0,
					       ACPI_CAST_PTR(u64,
							     buffer_desc->
							     buffer.pointer),
					       function);
		acpi_ex_release_global_lock(obj_desc->common_field.field_flags);
		goto exit;
	}

	/*
	 * Allocate a buffer for the contents of the field.
	 *
	 * If the field is larger than the current integer width, create
	 * a BUFFER to hold it. Otherwise, use an INTEGER. This allows
	 * the use of arithmetic operators on the returned value if the
	 * field size is equal or smaller than an Integer.
	 *
	 * Note: Field.length is in bits.
	 */
	length =
	    (acpi_size) ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->field.bit_length);
	if (length > acpi_gbl_integer_byte_width) {

		/* Field is too large for an Integer, create a Buffer instead */

		buffer_desc = acpi_ut_create_buffer_object(length);
		if (!buffer_desc) {
			return_ACPI_STATUS(AE_NO_MEMORY);
		}
		buffer = buffer_desc->buffer.pointer;
	} else {
		/* Field will fit within an Integer (normal case) */

		buffer_desc = acpi_ut_create_integer_object((u64) 0);
		if (!buffer_desc) {
			return_ACPI_STATUS(AE_NO_MEMORY);
		}

		length = acpi_gbl_integer_byte_width;
		buffer = &buffer_desc->integer.value;
	}

	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
			  "FieldRead [TO]:   Obj %p, Type %X, Buf %p, ByteLen %X\n",
			  obj_desc, obj_desc->common.type, buffer,
			  (u32) length));
	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
			  "FieldRead [FROM]: BitLen %X, BitOff %X, ByteOff %X\n",
			  obj_desc->common_field.bit_length,
			  obj_desc->common_field.start_field_bit_offset,
			  obj_desc->common_field.base_byte_offset));

	/* Lock entire transaction if requested */

	acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);

	/* Read from the field */

	status = acpi_ex_extract_from_field(obj_desc, buffer, (u32) length);
	acpi_ex_release_global_lock(obj_desc->common_field.field_flags);

exit:
	if (ACPI_FAILURE(status)) {
		acpi_ut_remove_reference(buffer_desc);
	} else {
		*ret_buffer_desc = buffer_desc;
	}

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_write_data_to_field
 *
 * PARAMETERS:  source_desc         - Contains data to write
 *              obj_desc            - The named field
 *              result_desc         - Where the return value is returned, if any
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Write to a named field
 *
 ******************************************************************************/

acpi_status
acpi_ex_write_data_to_field(union acpi_operand_object *source_desc,
			    union acpi_operand_object *obj_desc,
			    union acpi_operand_object **result_desc)
{
	acpi_status status;
	u32 length;
	void *buffer;
	union acpi_operand_object *buffer_desc;
	u32 function;
	u16 accessor_type;

	ACPI_FUNCTION_TRACE_PTR(ex_write_data_to_field, obj_desc);

	/* Parameter validation */

	if (!source_desc || !obj_desc) {
		return_ACPI_STATUS(AE_AML_NO_OPERAND);
	}

	if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) {
		/*
		 * If the buffer_field arguments have not been previously evaluated,
		 * evaluate them now and save the results.
		 */
		if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
			status = acpi_ds_get_buffer_field_arguments(obj_desc);
			if (ACPI_FAILURE(status)) {
				return_ACPI_STATUS(status);
			}
		}
	} else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
		   (obj_desc->field.region_obj->region.space_id ==
		    ACPI_ADR_SPACE_SMBUS
		    || obj_desc->field.region_obj->region.space_id ==
		    ACPI_ADR_SPACE_GSBUS
		    || obj_desc->field.region_obj->region.space_id ==
		    ACPI_ADR_SPACE_IPMI)) {
		/*
		 * This is an SMBus, GSBus or IPMI write. We will bypass the entire field
		 * mechanism and handoff the buffer directly to the handler. For
		 * these address spaces, the buffer is bi-directional; on a write,
		 * return data is returned in the same buffer.
		 *
		 * Source must be a buffer of sufficient size:
		 * ACPI_SMBUS_BUFFER_SIZE, ACPI_GSBUS_BUFFER_SIZE, or ACPI_IPMI_BUFFER_SIZE.
		 *
		 * Note: SMBus and GSBus protocol type is passed in upper 16-bits of Function
		 */
		if (source_desc->common.type != ACPI_TYPE_BUFFER) {
			ACPI_ERROR((AE_INFO,
				    "SMBus/IPMI/GenericSerialBus write requires Buffer, found type %s",
				    acpi_ut_get_object_type_name(source_desc)));

			return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
		}

		if (obj_desc->field.region_obj->region.space_id ==
		    ACPI_ADR_SPACE_SMBUS) {
			length = ACPI_SMBUS_BUFFER_SIZE;
			function =
			    ACPI_WRITE | (obj_desc->field.attribute << 16);
		} else if (obj_desc->field.region_obj->region.space_id ==
			   ACPI_ADR_SPACE_GSBUS) {
			accessor_type = obj_desc->field.attribute;
			length = acpi_ex_get_serial_access_length(accessor_type,
								  obj_desc->
								  field.
								  access_length);

			/*
			 * Add additional 2 bytes for the generic_serial_bus data buffer:
			 *
			 *     Status;      (Byte 0 of the data buffer)
			 *     Length;      (Byte 1 of the data buffer)
			 *     Data[x-1];   (Bytes 2-x of the arbitrary length data buffer)
			 */
			length += 2;
			function = ACPI_WRITE | (accessor_type << 16);
		} else {	/* IPMI */

			length = ACPI_IPMI_BUFFER_SIZE;
			function = ACPI_WRITE;
		}

		if (source_desc->buffer.length < length) {
			ACPI_ERROR((AE_INFO,
				    "SMBus/IPMI/GenericSerialBus write requires Buffer of length %u, found length %u",
				    length, source_desc->buffer.length));

			return_ACPI_STATUS(AE_AML_BUFFER_LIMIT);
		}

		/* Create the bi-directional buffer */

		buffer_desc = acpi_ut_create_buffer_object(length);
		if (!buffer_desc) {
			return_ACPI_STATUS(AE_NO_MEMORY);
		}

		buffer = buffer_desc->buffer.pointer;
		ACPI_MEMCPY(buffer, source_desc->buffer.pointer, length);

		/* Lock entire transaction if requested */

		acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);

		/*
		 * Perform the write (returns status and perhaps data in the
		 * same buffer)
		 */
		status = acpi_ex_access_region(obj_desc, 0,
					       (u64 *) buffer, function);
		acpi_ex_release_global_lock(obj_desc->common_field.field_flags);

		*result_desc = buffer_desc;
		return_ACPI_STATUS(status);
	}

	/* Get a pointer to the data to be written */

	switch (source_desc->common.type) {
	case ACPI_TYPE_INTEGER:

		buffer = &source_desc->integer.value;
		length = sizeof(source_desc->integer.value);
		break;

	case ACPI_TYPE_BUFFER:

		buffer = source_desc->buffer.pointer;
		length = source_desc->buffer.length;
		break;

	case ACPI_TYPE_STRING:

		buffer = source_desc->string.pointer;
		length = source_desc->string.length;
		break;

	default:

		return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
	}

	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
			  "FieldWrite [FROM]: Obj %p (%s:%X), Buf %p, ByteLen %X\n",
			  source_desc,
			  acpi_ut_get_type_name(source_desc->common.type),
			  source_desc->common.type, buffer, length));

	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
			  "FieldWrite [TO]:   Obj %p (%s:%X), BitLen %X, BitOff %X, ByteOff %X\n",
			  obj_desc,
			  acpi_ut_get_type_name(obj_desc->common.type),
			  obj_desc->common.type,
			  obj_desc->common_field.bit_length,
			  obj_desc->common_field.start_field_bit_offset,
			  obj_desc->common_field.base_byte_offset));

	/* Lock entire transaction if requested */

	acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);

	/* Write to the field */

	status = acpi_ex_insert_into_field(obj_desc, buffer, length);
	acpi_ex_release_global_lock(obj_desc->common_field.field_flags);

	return_ACPI_STATUS(status);
}
Commit	Line	Data
1da177e4 LT	1	/******************************************************************************
	2	*
	3	* Module Name: exfield - ACPI AML (p-code) execution - field manipulation
	4	*
	5	*****************************************************************************/
	6
	7	/*
fbb7a2dc	8	* Copyright (C) 2000 - 2014, 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"
6273f00e	48	#include "amlcode.h"
1da177e4	49
1da177e4	50	#define _COMPONENT ACPI_EXECUTER
4be44fcd	51	ACPI_MODULE_NAME("exfield")
1da177e4	52
6273f00e LZ	53	/* Local prototypes */
	54	static u32
	55	acpi_ex_get_serial_access_length(u32 accessor_type, u32 access_length);
	56
	57	/*******************************************************************************
	58	*
c0469129	59	* FUNCTION: acpi_ex_get_serial_access_length
6273f00e LZ	60	*
	61	* PARAMETERS: accessor_type - The type of the protocol indicated by region
	62	* field access attributes
	63	* access_length - The access length of the region field
	64	*
	65	* RETURN: Decoded access length
	66	*
	67	* DESCRIPTION: This routine returns the length of the generic_serial_bus
	68	* protocol bytes
	69	*
	70	******************************************************************************/
	71
	72	static u32
	73	acpi_ex_get_serial_access_length(u32 accessor_type, u32 access_length)
	74	{
	75	u32 length;
	76
	77	switch (accessor_type) {
	78	case AML_FIELD_ATTRIB_QUICK:
	79
	80	length = 0;
	81	break;
	82
	83	case AML_FIELD_ATTRIB_SEND_RCV:
	84	case AML_FIELD_ATTRIB_BYTE:
	85
	86	length = 1;
	87	break;
	88
	89	case AML_FIELD_ATTRIB_WORD:
	90	case AML_FIELD_ATTRIB_WORD_CALL:
	91
	92	length = 2;
	93	break;
	94
	95	case AML_FIELD_ATTRIB_MULTIBYTE:
	96	case AML_FIELD_ATTRIB_RAW_BYTES:
	97	case AML_FIELD_ATTRIB_RAW_PROCESS:
	98
	99	length = access_length;
	100	break;
	101
	102	case AML_FIELD_ATTRIB_BLOCK:
	103	case AML_FIELD_ATTRIB_BLOCK_CALL:
	104	default:
	105
c0469129	106	length = ACPI_GSBUS_BUFFER_SIZE - 2;
6273f00e LZ	107	break;
	108	}
	109
	110	return (length);
	111	}
	112
1da177e4 LT	113	/*******************************************************************************
	114	*
	115	* FUNCTION: acpi_ex_read_data_from_field
	116	*
	117	* PARAMETERS: walk_state - Current execution state
	118	* obj_desc - The named field
	119	* ret_buffer_desc - Where the return data object is stored
	120	*
	121	* RETURN: Status
	122	*
73a3090a	123	* DESCRIPTION: Read from a named field. Returns either an Integer or a
1da177e4 LT	124	* Buffer, depending on the size of the field.
	125	*
	126	******************************************************************************/
6273f00e	127
1da177e4	128	acpi_status
6273f00e	129	acpi_ex_read_data_from_field(struct acpi_walk_state * walk_state,
4be44fcd LB	130	union acpi_operand_object *obj_desc,
4be44fcd LB	131	union acpi_operand_object **ret_buffer_desc)
1da177e4	132	{
4be44fcd LB	133	acpi_status status;
	134	union acpi_operand_object *buffer_desc;
	135	acpi_size length;
	136	void *buffer;
6557a49a	137	u32 function;
6273f00e	138	u16 accessor_type;
1da177e4	139
b229cf92	140	ACPI_FUNCTION_TRACE_PTR(ex_read_data_from_field, obj_desc);
1da177e4 LT	141
	142	/* Parameter validation */
	143
	144	if (!obj_desc) {
4be44fcd	145	return_ACPI_STATUS(AE_AML_NO_OPERAND);
1da177e4	146	}
88ac00f5	147	if (!ret_buffer_desc) {
4be44fcd	148	return_ACPI_STATUS(AE_BAD_PARAMETER);
88ac00f5	149	}
1da177e4	150
3371c19c	151	if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) {
1da177e4 LT	152	/*
	153	* If the buffer_field arguments have not been previously evaluated,
	154	* evaluate them now and save the results.
	155	*/
	156	if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
4be44fcd LB	157	status = acpi_ds_get_buffer_field_arguments(obj_desc);
	158	if (ACPI_FAILURE(status)) {
	159	return_ACPI_STATUS(status);
1da177e4 LT	160	}
1da177e4 LT	161	}
3371c19c BM	162	} else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
3371c19c BM	163	(obj_desc->field.region_obj->region.space_id ==
6557a49a LM	164	ACPI_ADR_SPACE_SMBUS
6557a49a LM	165	\|\| obj_desc->field.region_obj->region.space_id ==
2da120b6 BM	166	ACPI_ADR_SPACE_GSBUS
2da120b6 BM	167	\|\| obj_desc->field.region_obj->region.space_id ==
6557a49a	168	ACPI_ADR_SPACE_IPMI)) {
1da177e4	169	/*
2da120b6	170	* This is an SMBus, GSBus or IPMI read. We must create a buffer to hold
6557a49a LM	171	* the data and then directly access the region handler.
6557a49a LM	172	*
2da120b6	173	* Note: SMBus and GSBus protocol value is passed in upper 16-bits of Function
1da177e4	174	*/
6557a49a LM	175	if (obj_desc->field.region_obj->region.space_id ==
	176	ACPI_ADR_SPACE_SMBUS) {
	177	length = ACPI_SMBUS_BUFFER_SIZE;
	178	function =
	179	ACPI_READ \| (obj_desc->field.attribute << 16);
2da120b6 BM	180	} else if (obj_desc->field.region_obj->region.space_id ==
2da120b6 BM	181	ACPI_ADR_SPACE_GSBUS) {
6273f00e LZ	182	accessor_type = obj_desc->field.attribute;
	183	length = acpi_ex_get_serial_access_length(accessor_type,
	184	obj_desc->
	185	field.
	186	access_length);
	187
	188	/*
d38bb002 BM	189	* Add additional 2 bytes for the generic_serial_bus data buffer:
	190	*
	191	* Status; (Byte 0 of the data buffer)
	192	* Length; (Byte 1 of the data buffer)
	193	* Data[x-1]; (Bytes 2-x of the arbitrary length data buffer)
6273f00e LZ	194	*/
	195	length += 2;
	196	function = ACPI_READ \| (accessor_type << 16);
6557a49a LM	197	} else { /* IPMI */
	198
	199	length = ACPI_IPMI_BUFFER_SIZE;
	200	function = ACPI_READ;
	201	}
	202
	203	buffer_desc = acpi_ut_create_buffer_object(length);
1da177e4	204	if (!buffer_desc) {
4be44fcd	205	return_ACPI_STATUS(AE_NO_MEMORY);
1da177e4 LT	206	}
	207
	208	/* Lock entire transaction if requested */
	209
ba886cd4	210	acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);
1da177e4	211
6557a49a LM	212	/* Call the region handler for the read */
6557a49a LM	213
4be44fcd	214	status = acpi_ex_access_region(obj_desc, 0,
5df7e6cb	215	ACPI_CAST_PTR(u64,
4be44fcd LB	216	buffer_desc->
4be44fcd LB	217	buffer.pointer),
6557a49a	218	function);
f02e9fa1	219	acpi_ex_release_global_lock(obj_desc->common_field.field_flags);
1da177e4 LT	220	goto exit;
	221	}
	222
	223	/*
	224	* Allocate a buffer for the contents of the field.
	225	*
5df7e6cb	226	* If the field is larger than the current integer width, create
73a3090a	227	* a BUFFER to hold it. Otherwise, use an INTEGER. This allows
1da177e4 LT	228	* the use of arithmetic operators on the returned value if the
	229	* field size is equal or smaller than an Integer.
	230	*
	231	* Note: Field.length is in bits.
	232	*/
4be44fcd LB	233	length =
4be44fcd LB	234	(acpi_size) ACPI_ROUND_BITS_UP_TO_BYTES(obj_desc->field.bit_length);
1da177e4	235	if (length > acpi_gbl_integer_byte_width) {
52fc0b02	236
1da177e4 LT	237	/* Field is too large for an Integer, create a Buffer instead */
1da177e4 LT	238
4be44fcd	239	buffer_desc = acpi_ut_create_buffer_object(length);
1da177e4	240	if (!buffer_desc) {
4be44fcd	241	return_ACPI_STATUS(AE_NO_MEMORY);
1da177e4 LT	242	}
1da177e4 LT	243	buffer = buffer_desc->buffer.pointer;
4be44fcd	244	} else {
1da177e4 LT	245	/* Field will fit within an Integer (normal case) */
1da177e4 LT	246
dc95a270	247	buffer_desc = acpi_ut_create_integer_object((u64) 0);
1da177e4	248	if (!buffer_desc) {
4be44fcd	249	return_ACPI_STATUS(AE_NO_MEMORY);
1da177e4 LT	250	}
	251
	252	length = acpi_gbl_integer_byte_width;
1da177e4 LT	253	buffer = &buffer_desc->integer.value;
	254	}
	255
4be44fcd	256	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
b229cf92	257	"FieldRead [TO]: Obj %p, Type %X, Buf %p, ByteLen %X\n",
3371c19c	258	obj_desc, obj_desc->common.type, buffer,
4be44fcd LB	259	(u32) length));
4be44fcd LB	260	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
b229cf92	261	"FieldRead [FROM]: BitLen %X, BitOff %X, ByteOff %X\n",
4be44fcd LB	262	obj_desc->common_field.bit_length,
	263	obj_desc->common_field.start_field_bit_offset,
	264	obj_desc->common_field.base_byte_offset));
1da177e4 LT	265
	266	/* Lock entire transaction if requested */
	267
ba886cd4	268	acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);
1da177e4 LT	269
	270	/* Read from the field */
	271
4be44fcd	272	status = acpi_ex_extract_from_field(obj_desc, buffer, (u32) length);
f02e9fa1	273	acpi_ex_release_global_lock(obj_desc->common_field.field_flags);
1da177e4	274
10622bf8	275	exit:
4be44fcd LB	276	if (ACPI_FAILURE(status)) {
	277	acpi_ut_remove_reference(buffer_desc);
	278	} else {
1da177e4 LT	279	*ret_buffer_desc = buffer_desc;
	280	}
	281
4be44fcd	282	return_ACPI_STATUS(status);
1da177e4 LT	283	}
1da177e4 LT	284
1da177e4 LT	285	/*******************************************************************************
	286	*
	287	* FUNCTION: acpi_ex_write_data_to_field
	288	*
	289	* PARAMETERS: source_desc - Contains data to write
	290	* obj_desc - The named field
44f6c012	291	* result_desc - Where the return value is returned, if any
1da177e4 LT	292	*
	293	* RETURN: Status
	294	*
	295	* DESCRIPTION: Write to a named field
	296	*
	297	******************************************************************************/
	298
	299	acpi_status
4be44fcd LB	300	acpi_ex_write_data_to_field(union acpi_operand_object *source_desc,
	301	union acpi_operand_object *obj_desc,
	302	union acpi_operand_object **result_desc)
1da177e4	303	{
4be44fcd LB	304	acpi_status status;
4be44fcd LB	305	u32 length;
4be44fcd	306	void *buffer;
4be44fcd	307	union acpi_operand_object *buffer_desc;
6557a49a	308	u32 function;
6273f00e	309	u16 accessor_type;
1da177e4	310
b229cf92	311	ACPI_FUNCTION_TRACE_PTR(ex_write_data_to_field, obj_desc);
1da177e4 LT	312
	313	/* Parameter validation */
	314
	315	if (!source_desc \|\| !obj_desc) {
4be44fcd	316	return_ACPI_STATUS(AE_AML_NO_OPERAND);
1da177e4 LT	317	}
1da177e4 LT	318
3371c19c	319	if (obj_desc->common.type == ACPI_TYPE_BUFFER_FIELD) {
1da177e4 LT	320	/*
	321	* If the buffer_field arguments have not been previously evaluated,
	322	* evaluate them now and save the results.
	323	*/
	324	if (!(obj_desc->common.flags & AOPOBJ_DATA_VALID)) {
4be44fcd LB	325	status = acpi_ds_get_buffer_field_arguments(obj_desc);
	326	if (ACPI_FAILURE(status)) {
	327	return_ACPI_STATUS(status);
1da177e4 LT	328	}
1da177e4 LT	329	}
3371c19c BM	330	} else if ((obj_desc->common.type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
3371c19c BM	331	(obj_desc->field.region_obj->region.space_id ==
6557a49a LM	332	ACPI_ADR_SPACE_SMBUS
6557a49a LM	333	\|\| obj_desc->field.region_obj->region.space_id ==
2da120b6 BM	334	ACPI_ADR_SPACE_GSBUS
2da120b6 BM	335	\|\| obj_desc->field.region_obj->region.space_id ==
6557a49a	336	ACPI_ADR_SPACE_IPMI)) {
1da177e4	337	/*
2da120b6	338	* This is an SMBus, GSBus or IPMI write. We will bypass the entire field
6557a49a LM	339	* mechanism and handoff the buffer directly to the handler. For
	340	* these address spaces, the buffer is bi-directional; on a write,
	341	* return data is returned in the same buffer.
	342	*
	343	* Source must be a buffer of sufficient size:
2da120b6	344	* ACPI_SMBUS_BUFFER_SIZE, ACPI_GSBUS_BUFFER_SIZE, or ACPI_IPMI_BUFFER_SIZE.
1da177e4	345	*
2da120b6	346	* Note: SMBus and GSBus protocol type is passed in upper 16-bits of Function
1da177e4	347	*/
3371c19c	348	if (source_desc->common.type != ACPI_TYPE_BUFFER) {
b8e4d893	349	ACPI_ERROR((AE_INFO,
2da120b6	350	"SMBus/IPMI/GenericSerialBus write requires Buffer, found type %s",
b8e4d893	351	acpi_ut_get_object_type_name(source_desc)));
44f6c012	352
4be44fcd	353	return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
1da177e4 LT	354	}
1da177e4 LT	355
6557a49a LM	356	if (obj_desc->field.region_obj->region.space_id ==
	357	ACPI_ADR_SPACE_SMBUS) {
	358	length = ACPI_SMBUS_BUFFER_SIZE;
	359	function =
	360	ACPI_WRITE \| (obj_desc->field.attribute << 16);
2da120b6 BM	361	} else if (obj_desc->field.region_obj->region.space_id ==
2da120b6 BM	362	ACPI_ADR_SPACE_GSBUS) {
6273f00e LZ	363	accessor_type = obj_desc->field.attribute;
	364	length = acpi_ex_get_serial_access_length(accessor_type,
	365	obj_desc->
	366	field.
	367	access_length);
	368
	369	/*
d38bb002 BM	370	* Add additional 2 bytes for the generic_serial_bus data buffer:
	371	*
	372	* Status; (Byte 0 of the data buffer)
	373	* Length; (Byte 1 of the data buffer)
	374	* Data[x-1]; (Bytes 2-x of the arbitrary length data buffer)
6273f00e LZ	375	*/
	376	length += 2;
	377	function = ACPI_WRITE \| (accessor_type << 16);
6557a49a LM	378	} else { /* IPMI */
	379
	380	length = ACPI_IPMI_BUFFER_SIZE;
	381	function = ACPI_WRITE;
	382	}
	383
	384	if (source_desc->buffer.length < length) {
b8e4d893	385	ACPI_ERROR((AE_INFO,
2da120b6	386	"SMBus/IPMI/GenericSerialBus write requires Buffer of length %u, found length %u",
6557a49a	387	length, source_desc->buffer.length));
44f6c012	388
4be44fcd	389	return_ACPI_STATUS(AE_AML_BUFFER_LIMIT);
1da177e4 LT	390	}
1da177e4 LT	391
6557a49a LM	392	/* Create the bi-directional buffer */
	393
	394	buffer_desc = acpi_ut_create_buffer_object(length);
1da177e4	395	if (!buffer_desc) {
4be44fcd	396	return_ACPI_STATUS(AE_NO_MEMORY);
1da177e4 LT	397	}
	398
	399	buffer = buffer_desc->buffer.pointer;
6557a49a	400	ACPI_MEMCPY(buffer, source_desc->buffer.pointer, length);
1da177e4 LT	401
	402	/* Lock entire transaction if requested */
	403
ba886cd4	404	acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);
1da177e4 LT	405
1da177e4 LT	406	/*
44f6c012 RM	407	* Perform the write (returns status and perhaps data in the
44f6c012 RM	408	* same buffer)
1da177e4	409	*/
4be44fcd	410	status = acpi_ex_access_region(obj_desc, 0,
5df7e6cb	411	(u64 *) buffer, function);
f02e9fa1	412	acpi_ex_release_global_lock(obj_desc->common_field.field_flags);
1da177e4 LT	413
1da177e4 LT	414	*result_desc = buffer_desc;
4be44fcd	415	return_ACPI_STATUS(status);
1da177e4 LT	416	}
1da177e4 LT	417
44f6c012 RM	418	/* Get a pointer to the data to be written */
44f6c012 RM	419
3371c19c	420	switch (source_desc->common.type) {
1da177e4	421	case ACPI_TYPE_INTEGER:
1d1ea1b7	422
1da177e4	423	buffer = &source_desc->integer.value;
4be44fcd	424	length = sizeof(source_desc->integer.value);
1da177e4 LT	425	break;
	426
	427	case ACPI_TYPE_BUFFER:
1d1ea1b7	428
1da177e4 LT	429	buffer = source_desc->buffer.pointer;
	430	length = source_desc->buffer.length;
	431	break;
	432
	433	case ACPI_TYPE_STRING:
1d1ea1b7	434
1da177e4 LT	435	buffer = source_desc->string.pointer;
	436	length = source_desc->string.length;
	437	break;
	438
	439	default:
1d1ea1b7	440
4be44fcd	441	return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
1da177e4 LT	442	}
1da177e4 LT	443
4be44fcd	444	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
b229cf92	445	"FieldWrite [FROM]: Obj %p (%s:%X), Buf %p, ByteLen %X\n",
4be44fcd	446	source_desc,
3371c19c BM	447	acpi_ut_get_type_name(source_desc->common.type),
3371c19c BM	448	source_desc->common.type, buffer, length));
4be44fcd LB	449
4be44fcd LB	450	ACPI_DEBUG_PRINT((ACPI_DB_BFIELD,
b229cf92	451	"FieldWrite [TO]: Obj %p (%s:%X), BitLen %X, BitOff %X, ByteOff %X\n",
4be44fcd	452	obj_desc,
3371c19c BM	453	acpi_ut_get_type_name(obj_desc->common.type),
3371c19c BM	454	obj_desc->common.type,
4be44fcd LB	455	obj_desc->common_field.bit_length,
	456	obj_desc->common_field.start_field_bit_offset,
	457	obj_desc->common_field.base_byte_offset));
1da177e4 LT	458
	459	/* Lock entire transaction if requested */
	460
ba886cd4	461	acpi_ex_acquire_global_lock(obj_desc->common_field.field_flags);
1da177e4 LT	462
	463	/* Write to the field */
	464
4be44fcd	465	status = acpi_ex_insert_into_field(obj_desc, buffer, length);
f02e9fa1	466	acpi_ex_release_global_lock(obj_desc->common_field.field_flags);
1da177e4	467
4be44fcd	468	return_ACPI_STATUS(status);
1da177e4	469	}