[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 */

		mem_info->mapped_logical_address =
		    acpi_os_map_memory((acpi_native_uint) address, window_size);
		if (!mem_info->mapped_logical_address) {
			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(AE_NO_MEMORY);
		}

		/* 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_FUNCTION_TRACE(ex_data_table_space_handler);

	/* Perform the memory read or write */

	switch (function) {
	case ACPI_READ:

		ACPI_MEMCPY(ACPI_CAST_PTR(char, value),
			    ACPI_PHYSADDR_TO_PTR(address),
			    ACPI_DIV_8(bit_width));
		break;

	case ACPI_WRITE:
	default:

		return_ACPI_STATUS(AE_SUPPORT);
	}

	return_ACPI_STATUS(AE_OK);
}
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
f3d2e786 BM	158	mem_info->mapped_logical_address =
	159	acpi_os_map_memory((acpi_native_uint) address, window_size);
	160	if (!mem_info->mapped_logical_address) {
b8e4d893 BM	161	ACPI_ERROR((AE_INFO,
	162	"Could not map memory at %8.8X%8.8X, size %X",
	163	ACPI_FORMAT_UINT64(address),
	164	(u32) window_size));
1da177e4	165	mem_info->mapped_length = 0;
f3d2e786	166	return_ACPI_STATUS(AE_NO_MEMORY);
1da177e4 LT	167	}
	168
	169	/* Save the physical address and mapping size */
	170
	171	mem_info->mapped_physical_address = address;
	172	mem_info->mapped_length = window_size;
	173	}
	174
	175	/*
	176	* Generate a logical pointer corresponding to the address we want to
	177	* access
	178	*/
	179	logical_addr_ptr = mem_info->mapped_logical_address +
4be44fcd LB	180	((acpi_integer) address -
	181	(acpi_integer) mem_info->mapped_physical_address);
	182
	183	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
8313524a BM	184	"System-Memory (width %d) R/W %d Address=%8.8X%8.8X\n",
8313524a BM	185	bit_width, function, ACPI_FORMAT_UINT64(address)));
4be44fcd LB	186
	187	/*
	188	* Perform the memory read or write
	189	*
	190	* Note: For machines that do not support non-aligned transfers, the target
	191	* address was checked for alignment above. We do not attempt to break the
	192	* transfer up into smaller (byte-size) chunks because the AML specifically
	193	* asked for a transfer width that the hardware may require.
	194	*/
1da177e4 LT	195	switch (function) {
	196	case ACPI_READ:
	197
	198	*value = 0;
	199	switch (bit_width) {
	200	case 8:
c51a4de8	201	*value = (acpi_integer) ACPI_GET8(logical_addr_ptr);
1da177e4 LT	202	break;
	203
	204	case 16:
c51a4de8	205	*value = (acpi_integer) ACPI_GET16(logical_addr_ptr);
1da177e4 LT	206	break;
	207
	208	case 32:
c51a4de8	209	*value = (acpi_integer) ACPI_GET32(logical_addr_ptr);
1da177e4 LT	210	break;
	211
	212	#if ACPI_MACHINE_WIDTH != 16
	213	case 64:
c51a4de8	214	*value = (acpi_integer) ACPI_GET64(logical_addr_ptr);
1da177e4 LT	215	break;
	216	#endif
	217	default:
	218	/* bit_width was already validated */
	219	break;
	220	}
	221	break;
	222
	223	case ACPI_WRITE:
	224
	225	switch (bit_width) {
	226	case 8:
c51a4de8	227	ACPI_SET8(logical_addr_ptr) = (u8) * value;
1da177e4 LT	228	break;
	229
	230	case 16:
c51a4de8	231	ACPI_SET16(logical_addr_ptr) = (u16) * value;
1da177e4 LT	232	break;
	233
	234	case 32:
c51a4de8	235	ACPI_SET32(logical_addr_ptr) = (u32) * value;
1da177e4 LT	236	break;
	237
	238	#if ACPI_MACHINE_WIDTH != 16
	239	case 64:
c51a4de8	240	ACPI_SET64(logical_addr_ptr) = (u64) * value;
1da177e4 LT	241	break;
	242	#endif
	243
	244	default:
	245	/* bit_width was already validated */
	246	break;
	247	}
	248	break;
	249
	250	default:
	251	status = AE_BAD_PARAMETER;
	252	break;
	253	}
	254
4be44fcd	255	return_ACPI_STATUS(status);
1da177e4 LT	256	}
1da177e4 LT	257
1da177e4 LT	258	/*******************************************************************************
	259	*
	260	* FUNCTION: acpi_ex_system_io_space_handler
	261	*
	262	* PARAMETERS: Function - Read or Write operation
	263	* Address - Where in the space to read or write
	264	* bit_width - Field width in bits (8, 16, or 32)
	265	* Value - Pointer to in or out value
	266	* handler_context - Pointer to Handler's context
	267	* region_context - Pointer to context specific to the
	268	* accessed region
	269	*
	270	* RETURN: Status
	271	*
	272	* DESCRIPTION: Handler for the System IO address space (Op Region)
	273	*
	274	******************************************************************************/
	275
	276	acpi_status
4be44fcd LB	277	acpi_ex_system_io_space_handler(u32 function,
	278	acpi_physical_address address,
	279	u32 bit_width,
	280	acpi_integer * value,
	281	void handler_context, void region_context)
1da177e4	282	{
4be44fcd LB	283	acpi_status status = AE_OK;
4be44fcd LB	284	u32 value32;
1da177e4	285
b229cf92	286	ACPI_FUNCTION_TRACE(ex_system_io_space_handler);
1da177e4	287
4be44fcd	288	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
8313524a BM	289	"System-IO (width %d) R/W %d Address=%8.8X%8.8X\n",
8313524a BM	290	bit_width, function, ACPI_FORMAT_UINT64(address)));
1da177e4 LT	291
	292	/* Decode the function parameter */
	293
	294	switch (function) {
	295	case ACPI_READ:
	296
4be44fcd LB	297	status = acpi_os_read_port((acpi_io_address) address,
4be44fcd LB	298	&value32, bit_width);
1da177e4 LT	299	*value = value32;
	300	break;
	301
	302	case ACPI_WRITE:
	303
4be44fcd LB	304	status = acpi_os_write_port((acpi_io_address) address,
4be44fcd LB	305	(u32) * value, bit_width);
1da177e4 LT	306	break;
	307
	308	default:
	309	status = AE_BAD_PARAMETER;
	310	break;
	311	}
	312
4be44fcd	313	return_ACPI_STATUS(status);
1da177e4 LT	314	}
1da177e4 LT	315
1da177e4 LT	316	/*******************************************************************************
	317	*
	318	* FUNCTION: acpi_ex_pci_config_space_handler
	319	*
	320	* PARAMETERS: Function - Read or Write operation
	321	* Address - Where in the space to read or write
	322	* bit_width - Field width in bits (8, 16, or 32)
	323	* Value - Pointer to in or out value
	324	* handler_context - Pointer to Handler's context
	325	* region_context - Pointer to context specific to the
	326	* accessed region
	327	*
	328	* RETURN: Status
	329	*
	330	* DESCRIPTION: Handler for the PCI Config address space (Op Region)
	331	*
	332	******************************************************************************/
	333
	334	acpi_status
4be44fcd LB	335	acpi_ex_pci_config_space_handler(u32 function,
	336	acpi_physical_address address,
	337	u32 bit_width,
	338	acpi_integer * value,
	339	void handler_context, void region_context)
1da177e4	340	{
4be44fcd LB	341	acpi_status status = AE_OK;
	342	struct acpi_pci_id *pci_id;
	343	u16 pci_register;
1da177e4	344
b229cf92	345	ACPI_FUNCTION_TRACE(ex_pci_config_space_handler);
1da177e4 LT	346
	347	/*
	348	* The arguments to acpi_os(Read\|Write)pci_configuration are:
	349	*
	350	* pci_segment is the PCI bus segment range 0-31
	351	* pci_bus is the PCI bus number range 0-255
	352	* pci_device is the PCI device number range 0-31
	353	* pci_function is the PCI device function number
	354	* pci_register is the Config space register range 0-255 bytes
	355	*
	356	* Value - input value for write, output address for read
	357	*
	358	*/
4be44fcd	359	pci_id = (struct acpi_pci_id *)region_context;
1da177e4 LT	360	pci_register = (u16) (u32) address;
1da177e4 LT	361
4be44fcd	362	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
8313524a	363	"Pci-Config %d (%d) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n",
4be44fcd LB	364	function, bit_width, pci_id->segment, pci_id->bus,
4be44fcd LB	365	pci_id->device, pci_id->function, pci_register));
1da177e4 LT	366
	367	switch (function) {
	368	case ACPI_READ:
	369
	370	*value = 0;
4be44fcd LB	371	status = acpi_os_read_pci_configuration(pci_id, pci_register,
4be44fcd LB	372	value, bit_width);
1da177e4 LT	373	break;
	374
	375	case ACPI_WRITE:
	376
4be44fcd LB	377	status = acpi_os_write_pci_configuration(pci_id, pci_register,
4be44fcd LB	378	*value, bit_width);
1da177e4 LT	379	break;
	380
	381	default:
	382
	383	status = AE_BAD_PARAMETER;
	384	break;
	385	}
	386
4be44fcd	387	return_ACPI_STATUS(status);
1da177e4 LT	388	}
1da177e4 LT	389
1da177e4 LT	390	/*******************************************************************************
	391	*
	392	* FUNCTION: acpi_ex_cmos_space_handler
	393	*
	394	* PARAMETERS: Function - Read or Write operation
	395	* Address - Where in the space to read or write
	396	* bit_width - Field width in bits (8, 16, or 32)
	397	* Value - Pointer to in or out value
	398	* handler_context - Pointer to Handler's context
	399	* region_context - Pointer to context specific to the
	400	* accessed region
	401	*
	402	* RETURN: Status
	403	*
	404	* DESCRIPTION: Handler for the CMOS address space (Op Region)
	405	*
	406	******************************************************************************/
	407
	408	acpi_status
4be44fcd LB	409	acpi_ex_cmos_space_handler(u32 function,
	410	acpi_physical_address address,
	411	u32 bit_width,
	412	acpi_integer * value,
	413	void handler_context, void region_context)
1da177e4	414	{
4be44fcd	415	acpi_status status = AE_OK;
1da177e4	416
b229cf92	417	ACPI_FUNCTION_TRACE(ex_cmos_space_handler);
1da177e4	418
4be44fcd	419	return_ACPI_STATUS(status);
1da177e4 LT	420	}
1da177e4 LT	421
1da177e4 LT	422	/*******************************************************************************
	423	*
	424	* FUNCTION: acpi_ex_pci_bar_space_handler
	425	*
	426	* PARAMETERS: Function - Read or Write operation
	427	* Address - Where in the space to read or write
	428	* bit_width - Field width in bits (8, 16, or 32)
	429	* Value - Pointer to in or out value
	430	* handler_context - Pointer to Handler's context
	431	* region_context - Pointer to context specific to the
	432	* accessed region
	433	*
	434	* RETURN: Status
	435	*
	436	* DESCRIPTION: Handler for the PCI bar_target address space (Op Region)
	437	*
	438	******************************************************************************/
	439
	440	acpi_status
4be44fcd LB	441	acpi_ex_pci_bar_space_handler(u32 function,
	442	acpi_physical_address address,
	443	u32 bit_width,
	444	acpi_integer * value,
	445	void handler_context, void region_context)
1da177e4	446	{
4be44fcd	447	acpi_status status = AE_OK;
1da177e4	448
b229cf92	449	ACPI_FUNCTION_TRACE(ex_pci_bar_space_handler);
1da177e4	450
4be44fcd	451	return_ACPI_STATUS(status);
1da177e4 LT	452	}
1da177e4 LT	453
1da177e4 LT	454	/*******************************************************************************
	455	*
	456	* FUNCTION: acpi_ex_data_table_space_handler
	457	*
	458	* PARAMETERS: Function - Read or Write operation
	459	* Address - Where in the space to read or write
	460	* bit_width - Field width in bits (8, 16, or 32)
	461	* Value - Pointer to in or out value
	462	* handler_context - Pointer to Handler's context
	463	* region_context - Pointer to context specific to the
	464	* accessed region
	465	*
	466	* RETURN: Status
	467	*
	468	* DESCRIPTION: Handler for the Data Table address space (Op Region)
	469	*
	470	******************************************************************************/
	471
	472	acpi_status
4be44fcd LB	473	acpi_ex_data_table_space_handler(u32 function,
	474	acpi_physical_address address,
	475	u32 bit_width,
	476	acpi_integer * value,
	477	void handler_context, void region_context)
1da177e4	478	{
b229cf92	479	ACPI_FUNCTION_TRACE(ex_data_table_space_handler);
1da177e4	480
44f6c012	481	/* Perform the memory read or write */
1da177e4 LT	482
	483	switch (function) {
	484	case ACPI_READ:
	485
4119532c BM	486	ACPI_MEMCPY(ACPI_CAST_PTR(char, value),
	487	ACPI_PHYSADDR_TO_PTR(address),
	488	ACPI_DIV_8(bit_width));
1da177e4 LT	489	break;
	490
	491	case ACPI_WRITE:
	492	default:
	493
4be44fcd	494	return_ACPI_STATUS(AE_SUPPORT);
1da177e4 LT	495	}
1da177e4 LT	496
4119532c	497	return_ACPI_STATUS(AE_OK);
1da177e4	498	}