[deliverable/linux.git] / drivers / acpi / executer / exregion.c


/******************************************************************************
 *
 * Module Name: exregion - ACPI default op_region (address space) handlers
 *
 *****************************************************************************/

/*
 * Copyright (C) 2000 - 2006, R. Byron Moore
 * 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 <acpi/acinterp.h>

#define _COMPONENT          ACPI_EXECUTER
ACPI_MODULE_NAME("exregion")

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_system_memory_space_handler
 *
 * PARAMETERS:  Function            - Read or Write operation
 *              Address             - Where in the space to read or write
 *              bit_width           - Field width in bits (8, 16, or 32)
 *              Value               - Pointer to in or out value
 *              handler_context     - Pointer to Handler's context
 *              region_context      - Pointer to context specific to the
 *                                    accessed region
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Handler for the System Memory address space (Op Region)
 *
 ******************************************************************************/
acpi_status
acpi_ex_system_memory_space_handler(u32 function,
				    acpi_physical_address address,
				    u32 bit_width,
				    acpi_integer * value,
				    void *handler_context, void *region_context)
{
	acpi_status status = AE_OK;
	void *logical_addr_ptr = NULL;
	struct acpi_mem_space_context *mem_info = region_context;
	u32 length;
	acpi_size window_size;
#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
	u32 remainder;
#endif

	ACPI_FUNCTION_TRACE(ex_system_memory_space_handler);

	/* Validate and translate the bit width */

	switch (bit_width) {
	case 8:
		length = 1;
		break;

	case 16:
		length = 2;
		break;

	case 32:
		length = 4;
		break;

	case 64:
		length = 8;
		break;

	default:
		ACPI_ERROR((AE_INFO, "Invalid SystemMemory width %d",
			    bit_width));
		return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
	}

#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
	/*
	 * Hardware does not support non-aligned data transfers, we must verify
	 * the request.
	 */
	(void)acpi_ut_short_divide((acpi_integer) address, length, NULL,
				   &remainder);
	if (remainder != 0) {
		return_ACPI_STATUS(AE_AML_ALIGNMENT);
	}
#endif

	/*
	 * Does the request fit into the cached memory mapping?
	 * Is 1) Address below the current mapping? OR
	 *    2) Address beyond the current mapping?
	 */
	if ((address < mem_info->mapped_physical_address) ||
	    (((acpi_integer) address + length) > ((acpi_integer)
						  mem_info->
						  mapped_physical_address +
						  mem_info->mapped_length))) {
		/*
		 * The request cannot be resolved by the current memory mapping;
		 * Delete the existing mapping and create a new one.
		 */
		if (mem_info->mapped_length) {

			/* Valid mapping, delete it */

			acpi_os_unmap_memory(mem_info->mapped_logical_address,
					     mem_info->mapped_length);
		}

		/*
		 * Don't attempt to map memory beyond the end of the region, and
		 * constrain the maximum mapping size to something reasonable.
		 */
		window_size = (acpi_size)
		    ((mem_info->address + mem_info->length) - address);

		if (window_size > ACPI_SYSMEM_REGION_WINDOW_SIZE) {
			window_size = ACPI_SYSMEM_REGION_WINDOW_SIZE;
		}

		/* Create a new mapping starting at the address given */

		status = acpi_os_map_memory(address, window_size,
					    (void **)&mem_info->
					    mapped_logical_address);
		if (ACPI_FAILURE(status)) {
			ACPI_ERROR((AE_INFO,
				    "Could not map memory at %8.8X%8.8X, size %X",
				    ACPI_FORMAT_UINT64(address),
				    (u32) window_size));
			mem_info->mapped_length = 0;
			return_ACPI_STATUS(status);
		}

		/* Save the physical address and mapping size */

		mem_info->mapped_physical_address = address;
		mem_info->mapped_length = window_size;
	}

	/*
	 * Generate a logical pointer corresponding to the address we want to
	 * access
	 */
	logical_addr_ptr = mem_info->mapped_logical_address +
	    ((acpi_integer) address -
	     (acpi_integer) mem_info->mapped_physical_address);

	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "System-Memory (width %d) R/W %d Address=%8.8X%8.8X\n",
			  bit_width, function, ACPI_FORMAT_UINT64(address)));

	/*
	 * Perform the memory read or write
	 *
	 * Note: For machines that do not support non-aligned transfers, the target
	 * address was checked for alignment above.  We do not attempt to break the
	 * transfer up into smaller (byte-size) chunks because the AML specifically
	 * asked for a transfer width that the hardware may require.
	 */
	switch (function) {
	case ACPI_READ:

		*value = 0;
		switch (bit_width) {
		case 8:
			*value = (acpi_integer) ACPI_GET8(logical_addr_ptr);
			break;

		case 16:
			*value = (acpi_integer) ACPI_GET16(logical_addr_ptr);
			break;

		case 32:
			*value = (acpi_integer) ACPI_GET32(logical_addr_ptr);
			break;

#if ACPI_MACHINE_WIDTH != 16
		case 64:
			*value = (acpi_integer) ACPI_GET64(logical_addr_ptr);
			break;
#endif
		default:
			/* bit_width was already validated */
			break;
		}
		break;

	case ACPI_WRITE:

		switch (bit_width) {
		case 8:
			ACPI_SET8(logical_addr_ptr) = (u8) * value;
			break;

		case 16:
			ACPI_SET16(logical_addr_ptr) = (u16) * value;
			break;

		case 32:
			ACPI_SET32(logical_addr_ptr) = (u32) * value;
			break;

#if ACPI_MACHINE_WIDTH != 16
		case 64:
			ACPI_SET64(logical_addr_ptr) = (u64) * value;
			break;
#endif

		default:
			/* bit_width was already validated */
			break;
		}
		break;

	default:
		status = AE_BAD_PARAMETER;
		break;
	}

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_system_io_space_handler
 *
 * PARAMETERS:  Function            - Read or Write operation
 *              Address             - Where in the space to read or write
 *              bit_width           - Field width in bits (8, 16, or 32)
 *              Value               - Pointer to in or out value
 *              handler_context     - Pointer to Handler's context
 *              region_context      - Pointer to context specific to the
 *                                    accessed region
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Handler for the System IO address space (Op Region)
 *
 ******************************************************************************/

acpi_status
acpi_ex_system_io_space_handler(u32 function,
				acpi_physical_address address,
				u32 bit_width,
				acpi_integer * value,
				void *handler_context, void *region_context)
{
	acpi_status status = AE_OK;
	u32 value32;

	ACPI_FUNCTION_TRACE(ex_system_io_space_handler);

	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "System-IO (width %d) R/W %d Address=%8.8X%8.8X\n",
			  bit_width, function, ACPI_FORMAT_UINT64(address)));

	/* Decode the function parameter */

	switch (function) {
	case ACPI_READ:

		status = acpi_os_read_port((acpi_io_address) address,
					   &value32, bit_width);
		*value = value32;
		break;

	case ACPI_WRITE:

		status = acpi_os_write_port((acpi_io_address) address,
					    (u32) * value, bit_width);
		break;

	default:
		status = AE_BAD_PARAMETER;
		break;
	}

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_pci_config_space_handler
 *
 * PARAMETERS:  Function            - Read or Write operation
 *              Address             - Where in the space to read or write
 *              bit_width           - Field width in bits (8, 16, or 32)
 *              Value               - Pointer to in or out value
 *              handler_context     - Pointer to Handler's context
 *              region_context      - Pointer to context specific to the
 *                                    accessed region
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Handler for the PCI Config address space (Op Region)
 *
 ******************************************************************************/

acpi_status
acpi_ex_pci_config_space_handler(u32 function,
				 acpi_physical_address address,
				 u32 bit_width,
				 acpi_integer * value,
				 void *handler_context, void *region_context)
{
	acpi_status status = AE_OK;
	struct acpi_pci_id *pci_id;
	u16 pci_register;

	ACPI_FUNCTION_TRACE(ex_pci_config_space_handler);

	/*
	 *  The arguments to acpi_os(Read|Write)pci_configuration are:
	 *
	 *  pci_segment is the PCI bus segment range 0-31
	 *  pci_bus     is the PCI bus number range 0-255
	 *  pci_device  is the PCI device number range 0-31
	 *  pci_function is the PCI device function number
	 *  pci_register is the Config space register range 0-255 bytes
	 *
	 *  Value - input value for write, output address for read
	 *
	 */
	pci_id = (struct acpi_pci_id *)region_context;
	pci_register = (u16) (u32) address;

	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
			  "Pci-Config %d (%d) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n",
			  function, bit_width, pci_id->segment, pci_id->bus,
			  pci_id->device, pci_id->function, pci_register));

	switch (function) {
	case ACPI_READ:

		*value = 0;
		status = acpi_os_read_pci_configuration(pci_id, pci_register,
							value, bit_width);
		break;

	case ACPI_WRITE:

		status = acpi_os_write_pci_configuration(pci_id, pci_register,
							 *value, bit_width);
		break;

	default:

		status = AE_BAD_PARAMETER;
		break;
	}

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_cmos_space_handler
 *
 * PARAMETERS:  Function            - Read or Write operation
 *              Address             - Where in the space to read or write
 *              bit_width           - Field width in bits (8, 16, or 32)
 *              Value               - Pointer to in or out value
 *              handler_context     - Pointer to Handler's context
 *              region_context      - Pointer to context specific to the
 *                                    accessed region
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Handler for the CMOS address space (Op Region)
 *
 ******************************************************************************/

acpi_status
acpi_ex_cmos_space_handler(u32 function,
			   acpi_physical_address address,
			   u32 bit_width,
			   acpi_integer * value,
			   void *handler_context, void *region_context)
{
	acpi_status status = AE_OK;

	ACPI_FUNCTION_TRACE(ex_cmos_space_handler);

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_pci_bar_space_handler
 *
 * PARAMETERS:  Function            - Read or Write operation
 *              Address             - Where in the space to read or write
 *              bit_width           - Field width in bits (8, 16, or 32)
 *              Value               - Pointer to in or out value
 *              handler_context     - Pointer to Handler's context
 *              region_context      - Pointer to context specific to the
 *                                    accessed region
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Handler for the PCI bar_target address space (Op Region)
 *
 ******************************************************************************/

acpi_status
acpi_ex_pci_bar_space_handler(u32 function,
			      acpi_physical_address address,
			      u32 bit_width,
			      acpi_integer * value,
			      void *handler_context, void *region_context)
{
	acpi_status status = AE_OK;

	ACPI_FUNCTION_TRACE(ex_pci_bar_space_handler);

	return_ACPI_STATUS(status);
}

/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_data_table_space_handler
 *
 * PARAMETERS:  Function            - Read or Write operation
 *              Address             - Where in the space to read or write
 *              bit_width           - Field width in bits (8, 16, or 32)
 *              Value               - Pointer to in or out value
 *              handler_context     - Pointer to Handler's context
 *              region_context      - Pointer to context specific to the
 *                                    accessed region
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Handler for the Data Table address space (Op Region)
 *
 ******************************************************************************/

acpi_status
acpi_ex_data_table_space_handler(u32 function,
				 acpi_physical_address address,
				 u32 bit_width,
				 acpi_integer * value,
				 void *handler_context, void *region_context)
{
	acpi_status status = AE_OK;
	u32 byte_width = ACPI_DIV_8(bit_width);
	u32 i;
	char *logical_addr_ptr;

	ACPI_FUNCTION_TRACE(ex_data_table_space_handler);

	logical_addr_ptr = ACPI_PHYSADDR_TO_PTR(address);

	/* Perform the memory read or write */

	switch (function) {
	case ACPI_READ:

		for (i = 0; i < byte_width; i++) {
			((char *)value)[i] = logical_addr_ptr[i];
		}
		break;

	case ACPI_WRITE:
	default:

		return_ACPI_STATUS(AE_SUPPORT);
	}

	return_ACPI_STATUS(status);
}
Commit	Line	Data
1da177e4 LT	1
	2	/******************************************************************************
	3	*
	4	* Module Name: exregion - ACPI default op_region (address space) handlers
	5	*
	6	*****************************************************************************/
	7
	8	/*
4a90c7e8	9	* Copyright (C) 2000 - 2006, R. Byron Moore
1da177e4 LT	10	* All rights reserved.
	11	*
	12	* Redistribution and use in source and binary forms, with or without
	13	* modification, are permitted provided that the following conditions
	14	* are met:
	15	* 1. Redistributions of source code must retain the above copyright
	16	* notice, this list of conditions, and the following disclaimer,
	17	* without modification.
	18	* 2. Redistributions in binary form must reproduce at minimum a disclaimer
	19	* substantially similar to the "NO WARRANTY" disclaimer below
	20	* ("Disclaimer") and any redistribution must be conditioned upon
	21	* including a substantially similar Disclaimer requirement for further
	22	* binary redistribution.
	23	* 3. Neither the names of the above-listed copyright holders nor the names
	24	* of any contributors may be used to endorse or promote products derived
	25	* from this software without specific prior written permission.
	26	*
	27	* Alternatively, this software may be distributed under the terms of the
	28	* GNU General Public License ("GPL") version 2 as published by the Free
	29	* Software Foundation.
	30	*
	31	* NO WARRANTY
	32	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	33	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	34	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
	35	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	36	* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	37	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	38	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	39	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	40	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
	41	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	42	* POSSIBILITY OF SUCH DAMAGES.
	43	*/
	44
1da177e4 LT	45	#include <acpi/acpi.h>
	46	#include <acpi/acinterp.h>
	47
1da177e4	48	#define _COMPONENT ACPI_EXECUTER
4be44fcd	49	ACPI_MODULE_NAME("exregion")
1da177e4 LT	50
	51	/*******************************************************************************
	52	*
	53	* FUNCTION: acpi_ex_system_memory_space_handler
	54	*
	55	* PARAMETERS: Function - Read or Write operation
	56	* Address - Where in the space to read or write
	57	* bit_width - Field width in bits (8, 16, or 32)
	58	* Value - Pointer to in or out value
	59	* handler_context - Pointer to Handler's context
	60	* region_context - Pointer to context specific to the
	61	* accessed region
	62	*
	63	* RETURN: Status
	64	*
	65	* DESCRIPTION: Handler for the System Memory address space (Op Region)
	66	*
	67	******************************************************************************/
1da177e4	68	acpi_status
4be44fcd LB	69	acpi_ex_system_memory_space_handler(u32 function,
	70	acpi_physical_address address,
	71	u32 bit_width,
	72	acpi_integer * value,
	73	void handler_context, void region_context)
1da177e4	74	{
4be44fcd LB	75	acpi_status status = AE_OK;
	76	void *logical_addr_ptr = NULL;
	77	struct acpi_mem_space_context *mem_info = region_context;
	78	u32 length;
	79	acpi_size window_size;
0897831b	80	#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
4be44fcd	81	u32 remainder;
1da177e4 LT	82	#endif
1da177e4 LT	83
b229cf92	84	ACPI_FUNCTION_TRACE(ex_system_memory_space_handler);
1da177e4 LT	85
	86	/* Validate and translate the bit width */
	87
	88	switch (bit_width) {
	89	case 8:
	90	length = 1;
	91	break;
	92
	93	case 16:
	94	length = 2;
	95	break;
	96
	97	case 32:
	98	length = 4;
	99	break;
	100
	101	case 64:
	102	length = 8;
	103	break;
	104
	105	default:
b229cf92	106	ACPI_ERROR((AE_INFO, "Invalid SystemMemory width %d",
b8e4d893	107	bit_width));
4be44fcd	108	return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
1da177e4 LT	109	}
1da177e4 LT	110
0897831b	111	#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
1da177e4 LT	112	/*
	113	* Hardware does not support non-aligned data transfers, we must verify
	114	* the request.
	115	*/
4be44fcd LB	116	(void)acpi_ut_short_divide((acpi_integer) address, length, NULL,
4be44fcd LB	117	&remainder);
1da177e4	118	if (remainder != 0) {
4be44fcd	119	return_ACPI_STATUS(AE_AML_ALIGNMENT);
1da177e4 LT	120	}
	121	#endif
	122
	123	/*
	124	* Does the request fit into the cached memory mapping?
	125	* Is 1) Address below the current mapping? OR
	126	* 2) Address beyond the current mapping?
	127	*/
	128	if ((address < mem_info->mapped_physical_address) \|\|
4be44fcd LB	129	(((acpi_integer) address + length) > ((acpi_integer)
	130	mem_info->
	131	mapped_physical_address +
	132	mem_info->mapped_length))) {
1da177e4 LT	133	/*
	134	* The request cannot be resolved by the current memory mapping;
	135	* Delete the existing mapping and create a new one.
	136	*/
	137	if (mem_info->mapped_length) {
52fc0b02	138
1da177e4 LT	139	/* Valid mapping, delete it */
1da177e4 LT	140
4be44fcd LB	141	acpi_os_unmap_memory(mem_info->mapped_logical_address,
4be44fcd LB	142	mem_info->mapped_length);
1da177e4 LT	143	}
	144
	145	/*
	146	* Don't attempt to map memory beyond the end of the region, and
	147	* constrain the maximum mapping size to something reasonable.
	148	*/
44f6c012	149	window_size = (acpi_size)
4be44fcd	150	((mem_info->address + mem_info->length) - address);
44f6c012	151
1da177e4 LT	152	if (window_size > ACPI_SYSMEM_REGION_WINDOW_SIZE) {
	153	window_size = ACPI_SYSMEM_REGION_WINDOW_SIZE;
	154	}
	155
	156	/* Create a new mapping starting at the address given */
	157
4be44fcd LB	158	status = acpi_os_map_memory(address, window_size,
	159	(void **)&mem_info->
	160	mapped_logical_address);
	161	if (ACPI_FAILURE(status)) {
b8e4d893 BM	162	ACPI_ERROR((AE_INFO,
	163	"Could not map memory at %8.8X%8.8X, size %X",
	164	ACPI_FORMAT_UINT64(address),
	165	(u32) window_size));
1da177e4	166	mem_info->mapped_length = 0;
4be44fcd	167	return_ACPI_STATUS(status);
1da177e4 LT	168	}
	169
	170	/* Save the physical address and mapping size */
	171
	172	mem_info->mapped_physical_address = address;
	173	mem_info->mapped_length = window_size;
	174	}
	175
	176	/*
	177	* Generate a logical pointer corresponding to the address we want to
	178	* access
	179	*/
	180	logical_addr_ptr = mem_info->mapped_logical_address +
4be44fcd LB	181	((acpi_integer) address -
	182	(acpi_integer) mem_info->mapped_physical_address);
	183
	184	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
8313524a BM	185	"System-Memory (width %d) R/W %d Address=%8.8X%8.8X\n",
8313524a BM	186	bit_width, function, ACPI_FORMAT_UINT64(address)));
4be44fcd LB	187
	188	/*
	189	* Perform the memory read or write
	190	*
	191	* Note: For machines that do not support non-aligned transfers, the target
	192	* address was checked for alignment above. We do not attempt to break the
	193	* transfer up into smaller (byte-size) chunks because the AML specifically
	194	* asked for a transfer width that the hardware may require.
	195	*/
1da177e4 LT	196	switch (function) {
	197	case ACPI_READ:
	198
	199	*value = 0;
	200	switch (bit_width) {
	201	case 8:
c51a4de8	202	*value = (acpi_integer) ACPI_GET8(logical_addr_ptr);
1da177e4 LT	203	break;
	204
	205	case 16:
c51a4de8	206	*value = (acpi_integer) ACPI_GET16(logical_addr_ptr);
1da177e4 LT	207	break;
	208
	209	case 32:
c51a4de8	210	*value = (acpi_integer) ACPI_GET32(logical_addr_ptr);
1da177e4 LT	211	break;
	212
	213	#if ACPI_MACHINE_WIDTH != 16
	214	case 64:
c51a4de8	215	*value = (acpi_integer) ACPI_GET64(logical_addr_ptr);
1da177e4 LT	216	break;
	217	#endif
	218	default:
	219	/* bit_width was already validated */
	220	break;
	221	}
	222	break;
	223
	224	case ACPI_WRITE:
	225
	226	switch (bit_width) {
	227	case 8:
c51a4de8	228	ACPI_SET8(logical_addr_ptr) = (u8) * value;
1da177e4 LT	229	break;
	230
	231	case 16:
c51a4de8	232	ACPI_SET16(logical_addr_ptr) = (u16) * value;
1da177e4 LT	233	break;
	234
	235	case 32:
c51a4de8	236	ACPI_SET32(logical_addr_ptr) = (u32) * value;
1da177e4 LT	237	break;
	238
	239	#if ACPI_MACHINE_WIDTH != 16
	240	case 64:
c51a4de8	241	ACPI_SET64(logical_addr_ptr) = (u64) * value;
1da177e4 LT	242	break;
	243	#endif
	244
	245	default:
	246	/* bit_width was already validated */
	247	break;
	248	}
	249	break;
	250
	251	default:
	252	status = AE_BAD_PARAMETER;
	253	break;
	254	}
	255
4be44fcd	256	return_ACPI_STATUS(status);
1da177e4 LT	257	}
1da177e4 LT	258
1da177e4 LT	259	/*******************************************************************************
	260	*
	261	* FUNCTION: acpi_ex_system_io_space_handler
	262	*
	263	* PARAMETERS: Function - Read or Write operation
	264	* Address - Where in the space to read or write
	265	* bit_width - Field width in bits (8, 16, or 32)
	266	* Value - Pointer to in or out value
	267	* handler_context - Pointer to Handler's context
	268	* region_context - Pointer to context specific to the
	269	* accessed region
	270	*
	271	* RETURN: Status
	272	*
	273	* DESCRIPTION: Handler for the System IO address space (Op Region)
	274	*
	275	******************************************************************************/
	276
	277	acpi_status
4be44fcd LB	278	acpi_ex_system_io_space_handler(u32 function,
	279	acpi_physical_address address,
	280	u32 bit_width,
	281	acpi_integer * value,
	282	void handler_context, void region_context)
1da177e4	283	{
4be44fcd LB	284	acpi_status status = AE_OK;
4be44fcd LB	285	u32 value32;
1da177e4	286
b229cf92	287	ACPI_FUNCTION_TRACE(ex_system_io_space_handler);
1da177e4	288
4be44fcd	289	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
8313524a BM	290	"System-IO (width %d) R/W %d Address=%8.8X%8.8X\n",
8313524a BM	291	bit_width, function, ACPI_FORMAT_UINT64(address)));
1da177e4 LT	292
	293	/* Decode the function parameter */
	294
	295	switch (function) {
	296	case ACPI_READ:
	297
4be44fcd LB	298	status = acpi_os_read_port((acpi_io_address) address,
4be44fcd LB	299	&value32, bit_width);
1da177e4 LT	300	*value = value32;
	301	break;
	302
	303	case ACPI_WRITE:
	304
4be44fcd LB	305	status = acpi_os_write_port((acpi_io_address) address,
4be44fcd LB	306	(u32) * value, bit_width);
1da177e4 LT	307	break;
	308
	309	default:
	310	status = AE_BAD_PARAMETER;
	311	break;
	312	}
	313
4be44fcd	314	return_ACPI_STATUS(status);
1da177e4 LT	315	}
1da177e4 LT	316
1da177e4 LT	317	/*******************************************************************************
	318	*
	319	* FUNCTION: acpi_ex_pci_config_space_handler
	320	*
	321	* PARAMETERS: Function - Read or Write operation
	322	* Address - Where in the space to read or write
	323	* bit_width - Field width in bits (8, 16, or 32)
	324	* Value - Pointer to in or out value
	325	* handler_context - Pointer to Handler's context
	326	* region_context - Pointer to context specific to the
	327	* accessed region
	328	*
	329	* RETURN: Status
	330	*
	331	* DESCRIPTION: Handler for the PCI Config address space (Op Region)
	332	*
	333	******************************************************************************/
	334
	335	acpi_status
4be44fcd LB	336	acpi_ex_pci_config_space_handler(u32 function,
	337	acpi_physical_address address,
	338	u32 bit_width,
	339	acpi_integer * value,
	340	void handler_context, void region_context)
1da177e4	341	{
4be44fcd LB	342	acpi_status status = AE_OK;
	343	struct acpi_pci_id *pci_id;
	344	u16 pci_register;
1da177e4	345
b229cf92	346	ACPI_FUNCTION_TRACE(ex_pci_config_space_handler);
1da177e4 LT	347
	348	/*
	349	* The arguments to acpi_os(Read\|Write)pci_configuration are:
	350	*
	351	* pci_segment is the PCI bus segment range 0-31
	352	* pci_bus is the PCI bus number range 0-255
	353	* pci_device is the PCI device number range 0-31
	354	* pci_function is the PCI device function number
	355	* pci_register is the Config space register range 0-255 bytes
	356	*
	357	* Value - input value for write, output address for read
	358	*
	359	*/
4be44fcd	360	pci_id = (struct acpi_pci_id *)region_context;
1da177e4 LT	361	pci_register = (u16) (u32) address;
1da177e4 LT	362
4be44fcd	363	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
8313524a	364	"Pci-Config %d (%d) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n",
4be44fcd LB	365	function, bit_width, pci_id->segment, pci_id->bus,
4be44fcd LB	366	pci_id->device, pci_id->function, pci_register));
1da177e4 LT	367
	368	switch (function) {
	369	case ACPI_READ:
	370
	371	*value = 0;
4be44fcd LB	372	status = acpi_os_read_pci_configuration(pci_id, pci_register,
4be44fcd LB	373	value, bit_width);
1da177e4 LT	374	break;
	375
	376	case ACPI_WRITE:
	377
4be44fcd LB	378	status = acpi_os_write_pci_configuration(pci_id, pci_register,
4be44fcd LB	379	*value, bit_width);
1da177e4 LT	380	break;
	381
	382	default:
	383
	384	status = AE_BAD_PARAMETER;
	385	break;
	386	}
	387
4be44fcd	388	return_ACPI_STATUS(status);
1da177e4 LT	389	}
1da177e4 LT	390
1da177e4 LT	391	/*******************************************************************************
	392	*
	393	* FUNCTION: acpi_ex_cmos_space_handler
	394	*
	395	* PARAMETERS: Function - Read or Write operation
	396	* Address - Where in the space to read or write
	397	* bit_width - Field width in bits (8, 16, or 32)
	398	* Value - Pointer to in or out value
	399	* handler_context - Pointer to Handler's context
	400	* region_context - Pointer to context specific to the
	401	* accessed region
	402	*
	403	* RETURN: Status
	404	*
	405	* DESCRIPTION: Handler for the CMOS address space (Op Region)
	406	*
	407	******************************************************************************/
	408
	409	acpi_status
4be44fcd LB	410	acpi_ex_cmos_space_handler(u32 function,
	411	acpi_physical_address address,
	412	u32 bit_width,
	413	acpi_integer * value,
	414	void handler_context, void region_context)
1da177e4	415	{
4be44fcd	416	acpi_status status = AE_OK;
1da177e4	417
b229cf92	418	ACPI_FUNCTION_TRACE(ex_cmos_space_handler);
1da177e4	419
4be44fcd	420	return_ACPI_STATUS(status);
1da177e4 LT	421	}
1da177e4 LT	422
1da177e4 LT	423	/*******************************************************************************
	424	*
	425	* FUNCTION: acpi_ex_pci_bar_space_handler
	426	*
	427	* PARAMETERS: Function - Read or Write operation
	428	* Address - Where in the space to read or write
	429	* bit_width - Field width in bits (8, 16, or 32)
	430	* Value - Pointer to in or out value
	431	* handler_context - Pointer to Handler's context
	432	* region_context - Pointer to context specific to the
	433	* accessed region
	434	*
	435	* RETURN: Status
	436	*
	437	* DESCRIPTION: Handler for the PCI bar_target address space (Op Region)
	438	*
	439	******************************************************************************/
	440
	441	acpi_status
4be44fcd LB	442	acpi_ex_pci_bar_space_handler(u32 function,
	443	acpi_physical_address address,
	444	u32 bit_width,
	445	acpi_integer * value,
	446	void handler_context, void region_context)
1da177e4	447	{
4be44fcd	448	acpi_status status = AE_OK;
1da177e4	449
b229cf92	450	ACPI_FUNCTION_TRACE(ex_pci_bar_space_handler);
1da177e4	451
4be44fcd	452	return_ACPI_STATUS(status);
1da177e4 LT	453	}
1da177e4 LT	454
1da177e4 LT	455	/*******************************************************************************
	456	*
	457	* FUNCTION: acpi_ex_data_table_space_handler
	458	*
	459	* PARAMETERS: Function - Read or Write operation
	460	* Address - Where in the space to read or write
	461	* bit_width - Field width in bits (8, 16, or 32)
	462	* Value - Pointer to in or out value
	463	* handler_context - Pointer to Handler's context
	464	* region_context - Pointer to context specific to the
	465	* accessed region
	466	*
	467	* RETURN: Status
	468	*
	469	* DESCRIPTION: Handler for the Data Table address space (Op Region)
	470	*
	471	******************************************************************************/
	472
	473	acpi_status
4be44fcd LB	474	acpi_ex_data_table_space_handler(u32 function,
	475	acpi_physical_address address,
	476	u32 bit_width,
	477	acpi_integer * value,
	478	void handler_context, void region_context)
1da177e4	479	{
4be44fcd LB	480	acpi_status status = AE_OK;
	481	u32 byte_width = ACPI_DIV_8(bit_width);
	482	u32 i;
	483	char *logical_addr_ptr;
1da177e4	484
b229cf92	485	ACPI_FUNCTION_TRACE(ex_data_table_space_handler);
1da177e4	486
4be44fcd	487	logical_addr_ptr = ACPI_PHYSADDR_TO_PTR(address);
1da177e4	488
44f6c012	489	/* Perform the memory read or write */
1da177e4 LT	490
	491	switch (function) {
	492	case ACPI_READ:
	493
	494	for (i = 0; i < byte_width; i++) {
4be44fcd	495	((char *)value)[i] = logical_addr_ptr[i];
1da177e4 LT	496	}
	497	break;
	498
	499	case ACPI_WRITE:
	500	default:
	501
4be44fcd	502	return_ACPI_STATUS(AE_SUPPORT);
1da177e4 LT	503	}
1da177e4 LT	504
4be44fcd	505	return_ACPI_STATUS(status);
1da177e4	506	}