[mirror_ubuntu-artful-kernel.git] / drivers / acpi / acpica / exregion.c


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

/*
 * Copyright (C) 2000 - 2010, 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 "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 map_length;
	acpi_size page_boundary_map_length;
#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);
		}

		/*
		 * Attempt to map from the requested address to the end of the region.
		 * However, we will never map more than one page, nor will we cross
		 * a page boundary.
		 */
		map_length = (acpi_size)
		    ((mem_info->address + mem_info->length) - address);

		/*
		 * If mapping the entire remaining portion of the region will cross
		 * a page boundary, just map up to the page boundary, do not cross.
		 * On some systems, crossing a page boundary while mapping regions
		 * can cause warnings if the pages have different attributes
		 * due to resource management
		 */
		page_boundary_map_length =
		    ACPI_ROUND_UP(address, ACPI_DEFAULT_PAGE_SIZE) - address;

		if (!page_boundary_map_length) {
			page_boundary_map_length = ACPI_DEFAULT_PAGE_SIZE;
		}

		if (map_length > page_boundary_map_length) {
			map_length = page_boundary_map_length;
		}

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

		mem_info->mapped_logical_address = acpi_os_map_memory((acpi_physical_address) address, map_length);
		if (!mem_info->mapped_logical_address) {
			ACPI_ERROR((AE_INFO,
				    "Could not map memory at %8.8X%8.8X, size %X",
				    ACPI_FORMAT_NATIVE_UINT(address),
				    (u32) map_length));
			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 = map_length;
	}

	/*
	 * 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_NATIVE_UINT(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;

		case 64:
			*value = (acpi_integer) ACPI_GET64(logical_addr_ptr);
			break;

		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;

		case 64:
			ACPI_SET64(logical_addr_ptr) = (u64) * value;
			break;

		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_NATIVE_UINT(address)));

	/* Decode the function parameter */

	switch (function) {
	case ACPI_READ:

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

	case ACPI_WRITE:

		status = acpi_hw_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;
	u32 value32;

	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:

		status = acpi_os_read_pci_configuration(pci_id, pci_register,
							&value32, bit_width);
		*value = value32;
		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	/*
a8357b0c	9	* Copyright (C) 2000 - 2010, Intel Corp.
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	45	#include <acpi/acpi.h>
e2f7a777 LB	46	#include "accommon.h"
e2f7a777 LB	47	#include "acinterp.h"
1da177e4	48
1da177e4	49	#define _COMPONENT ACPI_EXECUTER
4be44fcd	50	ACPI_MODULE_NAME("exregion")
1da177e4 LT	51
	52	/*******************************************************************************
	53	*
	54	* FUNCTION: acpi_ex_system_memory_space_handler
	55	*
	56	* PARAMETERS: Function - Read or Write operation
	57	* Address - Where in the space to read or write
	58	* bit_width - Field width in bits (8, 16, or 32)
	59	* Value - Pointer to in or out value
	60	* handler_context - Pointer to Handler's context
	61	* region_context - Pointer to context specific to the
	62	* accessed region
	63	*
	64	* RETURN: Status
	65	*
	66	* DESCRIPTION: Handler for the System Memory address space (Op Region)
	67	*
	68	******************************************************************************/
1da177e4	69	acpi_status
4be44fcd LB	70	acpi_ex_system_memory_space_handler(u32 function,
	71	acpi_physical_address address,
	72	u32 bit_width,
	73	acpi_integer * value,
	74	void handler_context, void region_context)
1da177e4	75	{
4be44fcd LB	76	acpi_status status = AE_OK;
	77	void *logical_addr_ptr = NULL;
	78	struct acpi_mem_space_context *mem_info = region_context;
	79	u32 length;
d410ee51 BM	80	acpi_size map_length;
d410ee51 BM	81	acpi_size page_boundary_map_length;
0897831b	82	#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
4be44fcd	83	u32 remainder;
1da177e4 LT	84	#endif
1da177e4 LT	85
b229cf92	86	ACPI_FUNCTION_TRACE(ex_system_memory_space_handler);
1da177e4 LT	87
	88	/* Validate and translate the bit width */
	89
	90	switch (bit_width) {
	91	case 8:
	92	length = 1;
	93	break;
	94
	95	case 16:
	96	length = 2;
	97	break;
	98
	99	case 32:
	100	length = 4;
	101	break;
	102
	103	case 64:
	104	length = 8;
	105	break;
	106
	107	default:
b229cf92	108	ACPI_ERROR((AE_INFO, "Invalid SystemMemory width %d",
b8e4d893	109	bit_width));
4be44fcd	110	return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
1da177e4 LT	111	}
1da177e4 LT	112
0897831b	113	#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
1da177e4 LT	114	/*
	115	* Hardware does not support non-aligned data transfers, we must verify
	116	* the request.
	117	*/
4be44fcd LB	118	(void)acpi_ut_short_divide((acpi_integer) address, length, NULL,
4be44fcd LB	119	&remainder);
1da177e4	120	if (remainder != 0) {
4be44fcd	121	return_ACPI_STATUS(AE_AML_ALIGNMENT);
1da177e4 LT	122	}
	123	#endif
	124
	125	/*
	126	* Does the request fit into the cached memory mapping?
	127	* Is 1) Address below the current mapping? OR
	128	* 2) Address beyond the current mapping?
	129	*/
	130	if ((address < mem_info->mapped_physical_address) \|\|
4be44fcd LB	131	(((acpi_integer) address + length) > ((acpi_integer)
	132	mem_info->
	133	mapped_physical_address +
	134	mem_info->mapped_length))) {
1da177e4 LT	135	/*
	136	* The request cannot be resolved by the current memory mapping;
	137	* Delete the existing mapping and create a new one.
	138	*/
	139	if (mem_info->mapped_length) {
52fc0b02	140
1da177e4 LT	141	/* Valid mapping, delete it */
1da177e4 LT	142
4be44fcd LB	143	acpi_os_unmap_memory(mem_info->mapped_logical_address,
4be44fcd LB	144	mem_info->mapped_length);
1da177e4 LT	145	}
	146
	147	/*
d410ee51 BM	148	* Attempt to map from the requested address to the end of the region.
	149	* However, we will never map more than one page, nor will we cross
	150	* a page boundary.
1da177e4	151	*/
d410ee51	152	map_length = (acpi_size)
4be44fcd	153	((mem_info->address + mem_info->length) - address);
44f6c012	154
d410ee51 BM	155	/*
	156	* If mapping the entire remaining portion of the region will cross
	157	* a page boundary, just map up to the page boundary, do not cross.
	158	* On some systems, crossing a page boundary while mapping regions
	159	* can cause warnings if the pages have different attributes
	160	* due to resource management
	161	*/
	162	page_boundary_map_length =
	163	ACPI_ROUND_UP(address, ACPI_DEFAULT_PAGE_SIZE) - address;
	164
	165	if (!page_boundary_map_length) {
	166	page_boundary_map_length = ACPI_DEFAULT_PAGE_SIZE;
	167	}
	168
	169	if (map_length > page_boundary_map_length) {
	170	map_length = page_boundary_map_length;
1da177e4 LT	171	}
	172
	173	/* Create a new mapping starting at the address given */
	174
d410ee51	175	mem_info->mapped_logical_address = acpi_os_map_memory((acpi_physical_address) address, map_length);
f3d2e786	176	if (!mem_info->mapped_logical_address) {
b8e4d893 BM	177	ACPI_ERROR((AE_INFO,
b8e4d893 BM	178	"Could not map memory at %8.8X%8.8X, size %X",
b7f9f042	179	ACPI_FORMAT_NATIVE_UINT(address),
d410ee51	180	(u32) map_length));
1da177e4	181	mem_info->mapped_length = 0;
f3d2e786	182	return_ACPI_STATUS(AE_NO_MEMORY);
1da177e4 LT	183	}
	184
	185	/* Save the physical address and mapping size */
	186
	187	mem_info->mapped_physical_address = address;
d410ee51	188	mem_info->mapped_length = map_length;
1da177e4 LT	189	}
	190
	191	/*
	192	* Generate a logical pointer corresponding to the address we want to
	193	* access
	194	*/
	195	logical_addr_ptr = mem_info->mapped_logical_address +
4be44fcd LB	196	((acpi_integer) address -
	197	(acpi_integer) mem_info->mapped_physical_address);
	198
	199	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
8313524a	200	"System-Memory (width %d) R/W %d Address=%8.8X%8.8X\n",
b7f9f042 BM	201	bit_width, function,
b7f9f042 BM	202	ACPI_FORMAT_NATIVE_UINT(address)));
4be44fcd LB	203
	204	/*
	205	* Perform the memory read or write
	206	*
	207	* Note: For machines that do not support non-aligned transfers, the target
	208	* address was checked for alignment above. We do not attempt to break the
	209	* transfer up into smaller (byte-size) chunks because the AML specifically
	210	* asked for a transfer width that the hardware may require.
	211	*/
1da177e4 LT	212	switch (function) {
	213	case ACPI_READ:
	214
	215	*value = 0;
	216	switch (bit_width) {
	217	case 8:
c51a4de8	218	*value = (acpi_integer) ACPI_GET8(logical_addr_ptr);
1da177e4 LT	219	break;
	220
	221	case 16:
c51a4de8	222	*value = (acpi_integer) ACPI_GET16(logical_addr_ptr);
1da177e4 LT	223	break;
	224
	225	case 32:
c51a4de8	226	*value = (acpi_integer) ACPI_GET32(logical_addr_ptr);
1da177e4 LT	227	break;
1da177e4 LT	228
1da177e4	229	case 64:
c51a4de8	230	*value = (acpi_integer) ACPI_GET64(logical_addr_ptr);
1da177e4	231	break;
59fa8505	232
1da177e4 LT	233	default:
	234	/* bit_width was already validated */
	235	break;
	236	}
	237	break;
	238
	239	case ACPI_WRITE:
	240
	241	switch (bit_width) {
	242	case 8:
c51a4de8	243	ACPI_SET8(logical_addr_ptr) = (u8) * value;
1da177e4 LT	244	break;
	245
	246	case 16:
c51a4de8	247	ACPI_SET16(logical_addr_ptr) = (u16) * value;
1da177e4 LT	248	break;
	249
	250	case 32:
c51a4de8	251	ACPI_SET32(logical_addr_ptr) = (u32) * value;
1da177e4 LT	252	break;
1da177e4 LT	253
1da177e4	254	case 64:
c51a4de8	255	ACPI_SET64(logical_addr_ptr) = (u64) * value;
1da177e4	256	break;
1da177e4 LT	257
	258	default:
	259	/* bit_width was already validated */
	260	break;
	261	}
	262	break;
	263
	264	default:
	265	status = AE_BAD_PARAMETER;
	266	break;
	267	}
	268
4be44fcd	269	return_ACPI_STATUS(status);
1da177e4 LT	270	}
1da177e4 LT	271
1da177e4 LT	272	/*******************************************************************************
	273	*
	274	* FUNCTION: acpi_ex_system_io_space_handler
	275	*
	276	* PARAMETERS: Function - Read or Write operation
	277	* Address - Where in the space to read or write
	278	* bit_width - Field width in bits (8, 16, or 32)
	279	* Value - Pointer to in or out value
	280	* handler_context - Pointer to Handler's context
	281	* region_context - Pointer to context specific to the
	282	* accessed region
	283	*
	284	* RETURN: Status
	285	*
	286	* DESCRIPTION: Handler for the System IO address space (Op Region)
	287	*
	288	******************************************************************************/
	289
	290	acpi_status
4be44fcd LB	291	acpi_ex_system_io_space_handler(u32 function,
	292	acpi_physical_address address,
	293	u32 bit_width,
	294	acpi_integer * value,
	295	void handler_context, void region_context)
1da177e4	296	{
4be44fcd LB	297	acpi_status status = AE_OK;
4be44fcd LB	298	u32 value32;
1da177e4	299
b229cf92	300	ACPI_FUNCTION_TRACE(ex_system_io_space_handler);
1da177e4	301
4be44fcd	302	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
8313524a	303	"System-IO (width %d) R/W %d Address=%8.8X%8.8X\n",
b7f9f042 BM	304	bit_width, function,
b7f9f042 BM	305	ACPI_FORMAT_NATIVE_UINT(address)));
1da177e4 LT	306
	307	/* Decode the function parameter */
	308
	309	switch (function) {
	310	case ACPI_READ:
	311
7f071903	312	status = acpi_hw_read_port((acpi_io_address) address,
4be44fcd	313	&value32, bit_width);
1da177e4 LT	314	*value = value32;
	315	break;
	316
	317	case ACPI_WRITE:
	318
7f071903	319	status = acpi_hw_write_port((acpi_io_address) address,
4be44fcd	320	(u32) * value, bit_width);
1da177e4 LT	321	break;
	322
	323	default:
	324	status = AE_BAD_PARAMETER;
	325	break;
	326	}
	327
4be44fcd	328	return_ACPI_STATUS(status);
1da177e4 LT	329	}
1da177e4 LT	330
1da177e4 LT	331	/*******************************************************************************
	332	*
	333	* FUNCTION: acpi_ex_pci_config_space_handler
	334	*
	335	* PARAMETERS: Function - Read or Write operation
	336	* Address - Where in the space to read or write
	337	* bit_width - Field width in bits (8, 16, or 32)
	338	* Value - Pointer to in or out value
	339	* handler_context - Pointer to Handler's context
	340	* region_context - Pointer to context specific to the
	341	* accessed region
	342	*
	343	* RETURN: Status
	344	*
	345	* DESCRIPTION: Handler for the PCI Config address space (Op Region)
	346	*
	347	******************************************************************************/
	348
	349	acpi_status
4be44fcd LB	350	acpi_ex_pci_config_space_handler(u32 function,
	351	acpi_physical_address address,
	352	u32 bit_width,
	353	acpi_integer * value,
	354	void handler_context, void region_context)
1da177e4	355	{
4be44fcd LB	356	acpi_status status = AE_OK;
	357	struct acpi_pci_id *pci_id;
	358	u16 pci_register;
1186974f	359	u32 value32;
1da177e4	360
b229cf92	361	ACPI_FUNCTION_TRACE(ex_pci_config_space_handler);
1da177e4 LT	362
	363	/*
	364	* The arguments to acpi_os(Read\|Write)pci_configuration are:
	365	*
	366	* pci_segment is the PCI bus segment range 0-31
	367	* pci_bus is the PCI bus number range 0-255
	368	* pci_device is the PCI device number range 0-31
	369	* pci_function is the PCI device function number
	370	* pci_register is the Config space register range 0-255 bytes
	371	*
	372	* Value - input value for write, output address for read
	373	*
	374	*/
4be44fcd	375	pci_id = (struct acpi_pci_id *)region_context;
1da177e4 LT	376	pci_register = (u16) (u32) address;
1da177e4 LT	377
4be44fcd	378	ACPI_DEBUG_PRINT((ACPI_DB_INFO,
8313524a	379	"Pci-Config %d (%d) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n",
4be44fcd LB	380	function, bit_width, pci_id->segment, pci_id->bus,
4be44fcd LB	381	pci_id->device, pci_id->function, pci_register));
1da177e4 LT	382
	383	switch (function) {
	384	case ACPI_READ:
	385
4be44fcd	386	status = acpi_os_read_pci_configuration(pci_id, pci_register,
1186974f ML	387	&value32, bit_width);
1186974f ML	388	*value = value32;
1da177e4 LT	389	break;
	390
	391	case ACPI_WRITE:
	392
4be44fcd LB	393	status = acpi_os_write_pci_configuration(pci_id, pci_register,
4be44fcd LB	394	*value, bit_width);
1da177e4 LT	395	break;
	396
	397	default:
	398
	399	status = AE_BAD_PARAMETER;
	400	break;
	401	}
	402
4be44fcd	403	return_ACPI_STATUS(status);
1da177e4 LT	404	}
1da177e4 LT	405
1da177e4 LT	406	/*******************************************************************************
	407	*
	408	* FUNCTION: acpi_ex_cmos_space_handler
	409	*
	410	* PARAMETERS: Function - Read or Write operation
	411	* Address - Where in the space to read or write
	412	* bit_width - Field width in bits (8, 16, or 32)
	413	* Value - Pointer to in or out value
	414	* handler_context - Pointer to Handler's context
	415	* region_context - Pointer to context specific to the
	416	* accessed region
	417	*
	418	* RETURN: Status
	419	*
	420	* DESCRIPTION: Handler for the CMOS address space (Op Region)
	421	*
	422	******************************************************************************/
	423
	424	acpi_status
4be44fcd LB	425	acpi_ex_cmos_space_handler(u32 function,
	426	acpi_physical_address address,
	427	u32 bit_width,
	428	acpi_integer * value,
	429	void handler_context, void region_context)
1da177e4	430	{
4be44fcd	431	acpi_status status = AE_OK;
1da177e4	432
b229cf92	433	ACPI_FUNCTION_TRACE(ex_cmos_space_handler);
1da177e4	434
4be44fcd	435	return_ACPI_STATUS(status);
1da177e4 LT	436	}
1da177e4 LT	437
1da177e4 LT	438	/*******************************************************************************
	439	*
	440	* FUNCTION: acpi_ex_pci_bar_space_handler
	441	*
	442	* PARAMETERS: Function - Read or Write operation
	443	* Address - Where in the space to read or write
	444	* bit_width - Field width in bits (8, 16, or 32)
	445	* Value - Pointer to in or out value
	446	* handler_context - Pointer to Handler's context
	447	* region_context - Pointer to context specific to the
	448	* accessed region
	449	*
	450	* RETURN: Status
	451	*
	452	* DESCRIPTION: Handler for the PCI bar_target address space (Op Region)
	453	*
	454	******************************************************************************/
	455
	456	acpi_status
4be44fcd LB	457	acpi_ex_pci_bar_space_handler(u32 function,
	458	acpi_physical_address address,
	459	u32 bit_width,
	460	acpi_integer * value,
	461	void handler_context, void region_context)
1da177e4	462	{
4be44fcd	463	acpi_status status = AE_OK;
1da177e4	464
b229cf92	465	ACPI_FUNCTION_TRACE(ex_pci_bar_space_handler);
1da177e4	466
4be44fcd	467	return_ACPI_STATUS(status);
1da177e4 LT	468	}
1da177e4 LT	469
1da177e4 LT	470	/*******************************************************************************
	471	*
	472	* FUNCTION: acpi_ex_data_table_space_handler
	473	*
	474	* PARAMETERS: Function - Read or Write operation
	475	* Address - Where in the space to read or write
	476	* bit_width - Field width in bits (8, 16, or 32)
	477	* Value - Pointer to in or out value
	478	* handler_context - Pointer to Handler's context
	479	* region_context - Pointer to context specific to the
	480	* accessed region
	481	*
	482	* RETURN: Status
	483	*
	484	* DESCRIPTION: Handler for the Data Table address space (Op Region)
	485	*
	486	******************************************************************************/
	487
	488	acpi_status
4be44fcd LB	489	acpi_ex_data_table_space_handler(u32 function,
	490	acpi_physical_address address,
	491	u32 bit_width,
	492	acpi_integer * value,
	493	void handler_context, void region_context)
1da177e4	494	{
b229cf92	495	ACPI_FUNCTION_TRACE(ex_data_table_space_handler);
1da177e4	496
44f6c012	497	/* Perform the memory read or write */
1da177e4 LT	498
	499	switch (function) {
	500	case ACPI_READ:
	501
4119532c BM	502	ACPI_MEMCPY(ACPI_CAST_PTR(char, value),
	503	ACPI_PHYSADDR_TO_PTR(address),
	504	ACPI_DIV_8(bit_width));
1da177e4 LT	505	break;
	506
	507	case ACPI_WRITE:
	508	default:
	509
4be44fcd	510	return_ACPI_STATUS(AE_SUPPORT);
1da177e4 LT	511	}
1da177e4 LT	512
4119532c	513	return_ACPI_STATUS(AE_OK);
1da177e4	514	}