Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit d30dc9abb4aacfd4df3f486f22bcbc0531b73283

Authored by Alexey Starikovskiy 2007-10-01 02:39:36 +0800

Committed by Len Brown 2007-10-10 13:00:26 +0800

Exists in master and in 7 other branches

ACPICA: hw: remove use_lock flag from acpi_hw_register_{read, write}

use_lock flag is used once for acpi_hw_register_read, and never for
acpi_hw_register_write. It will greatly simplify understanding of
locking if we just drop this use_lock altogether, and wrap the only call
to ..._read in lock/unlock.

Signed-off-by: Alexey Starikovskiy <astarikovskiy@suse.de>
Signed-off-by: Len Brown <len.brown@intel.com>

Showing 4 changed files with 48 additions and 78 deletions Inline Diff

drivers/acpi/events/evevent.c
drivers/acpi/hardware/hwregs.c
drivers/acpi/hardware/hwsleep.c
include/acpi/achware.h

drivers/acpi/events/evevent.c

Diff comments View file @ d30dc9a

 /******************************************************************************
  *
  * Module Name: evevent - Fixed Event handling and dispatch
  *
  *****************************************************************************/
 /*
  * Copyright (C) 2000 - 2007, 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/acevents.h>
 #define _COMPONENT          ACPI_EVENTS
 ACPI_MODULE_NAME("evevent")
 /* Local prototypes */
 static acpi_status acpi_ev_fixed_event_initialize(void);
 static u32 acpi_ev_fixed_event_dispatch(u32 event);
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_initialize_events
  *
  * PARAMETERS:  None
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Initialize global data structures for ACPI events (Fixed, GPE)
  *
  ******************************************************************************/
 acpi_status acpi_ev_initialize_events(void)
 {
 	acpi_status status;
 	ACPI_FUNCTION_TRACE(ev_initialize_events);
 	/*
 	 * Initialize the Fixed and General Purpose Events. This is done prior to
 	 * enabling SCIs to prevent interrupts from occurring before the handlers are
 	 * installed.
 	 */
 	status = acpi_ev_fixed_event_initialize();
 	if (ACPI_FAILURE(status)) {
 		ACPI_EXCEPTION((AE_INFO, status,
 				"Unable to initialize fixed events"));
 		return_ACPI_STATUS(status);
 	}
 	status = acpi_ev_gpe_initialize();
 	if (ACPI_FAILURE(status)) {
 		ACPI_EXCEPTION((AE_INFO, status,
 				"Unable to initialize general purpose events"));
 		return_ACPI_STATUS(status);
 	}
 	return_ACPI_STATUS(status);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_install_fadt_gpes
  *
  * PARAMETERS:  None
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Completes initialization of the FADT-defined GPE blocks
  *              (0 and 1). This causes the _PRW methods to be run, so the HW
  *              must be fully initialized at this point, including global lock
  *              support.
  *
  ******************************************************************************/
 acpi_status acpi_ev_install_fadt_gpes(void)
 {
 	acpi_status status;
 	ACPI_FUNCTION_TRACE(ev_install_fadt_gpes);
 	/* Namespace must be locked */
 	status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
 	if (ACPI_FAILURE(status)) {
 		return (status);
 	}
 	/* FADT GPE Block 0 */
 	(void)acpi_ev_initialize_gpe_block(acpi_gbl_fadt_gpe_device,
 					   acpi_gbl_gpe_fadt_blocks[0]);
 	/* FADT GPE Block 1 */
 	(void)acpi_ev_initialize_gpe_block(acpi_gbl_fadt_gpe_device,
 					   acpi_gbl_gpe_fadt_blocks[1]);
 	(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 	return_ACPI_STATUS(AE_OK);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_install_xrupt_handlers
  *
  * PARAMETERS:  None
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Install interrupt handlers for the SCI and Global Lock
  *
  ******************************************************************************/
 acpi_status acpi_ev_install_xrupt_handlers(void)
 {
 	acpi_status status;
 	ACPI_FUNCTION_TRACE(ev_install_xrupt_handlers);
 	/* Install the SCI handler */
 	status = acpi_ev_install_sci_handler();
 	if (ACPI_FAILURE(status)) {
 		ACPI_EXCEPTION((AE_INFO, status,
 				"Unable to install System Control Interrupt handler"));
 		return_ACPI_STATUS(status);
 	}
 	/* Install the handler for the Global Lock */
 	status = acpi_ev_init_global_lock_handler();
 	if (ACPI_FAILURE(status)) {
 		ACPI_EXCEPTION((AE_INFO, status,
 				"Unable to initialize Global Lock handler"));
 		return_ACPI_STATUS(status);
 	}
 	acpi_gbl_events_initialized = TRUE;
 	return_ACPI_STATUS(status);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_fixed_event_initialize
  *
  * PARAMETERS:  None
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Install the fixed event handlers and enable the fixed events.
  *
  ******************************************************************************/
 static acpi_status acpi_ev_fixed_event_initialize(void)
 {
 	acpi_native_uint i;
 	acpi_status status;
 	/*
 	 * Initialize the structure that keeps track of fixed event handlers
 	 * and enable the fixed events.
 	 */
 	for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
 		acpi_gbl_fixed_event_handlers[i].handler = NULL;
 		acpi_gbl_fixed_event_handlers[i].context = NULL;
 		/* Enable the fixed event */
 		if (acpi_gbl_fixed_event_info[i].enable_register_id != 0xFF) {
 			status =
 			    acpi_set_register(acpi_gbl_fixed_event_info[i].
 					      enable_register_id, 0);
 			if (ACPI_FAILURE(status)) {
 				return (status);
 			}
 		}
 	}
 	return (AE_OK);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_fixed_event_detect
  *
  * PARAMETERS:  None
  *
  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
  *
  * DESCRIPTION: Checks the PM status register for active fixed events
  *
  ******************************************************************************/
 u32 acpi_ev_fixed_event_detect(void)
 {
 	u32 int_status = ACPI_INTERRUPT_NOT_HANDLED;
 	u32 fixed_status;
 	u32 fixed_enable;
 	acpi_native_uint i;
 	ACPI_FUNCTION_NAME(ev_fixed_event_detect);
 	/*
 	 * Read the fixed feature status and enable registers, as all the cases
 	 * depend on their values.  Ignore errors here.
 	 */
-	(void)acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+	(void)acpi_hw_register_read(ACPI_REGISTER_PM1_STATUS, &fixed_status);
-				    ACPI_REGISTER_PM1_STATUS, &fixed_status);
+	(void)acpi_hw_register_read(ACPI_REGISTER_PM1_ENABLE, &fixed_enable);
-	(void)acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
-				    ACPI_REGISTER_PM1_ENABLE, &fixed_enable);
 	ACPI_DEBUG_PRINT((ACPI_DB_INTERRUPTS,
 			  "Fixed Event Block: Enable %08X Status %08X\n",
 			  fixed_enable, fixed_status));
 	/*
 	 * Check for all possible Fixed Events and dispatch those that are active
 	 */
 	for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++) {
 		/* Both the status and enable bits must be on for this event */
 		if ((fixed_status & acpi_gbl_fixed_event_info[i].
 		     status_bit_mask)
 		    && (fixed_enable & acpi_gbl_fixed_event_info[i].
 			enable_bit_mask)) {
 			/* Found an active (signalled) event */
 			int_status |= acpi_ev_fixed_event_dispatch((u32) i);
 		}
 	}
 	return (int_status);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_fixed_event_dispatch
  *
  * PARAMETERS:  Event               - Event type
  *
  * RETURN:      INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
  *
  * DESCRIPTION: Clears the status bit for the requested event, calls the
  *              handler that previously registered for the event.
  *
  ******************************************************************************/
 static u32 acpi_ev_fixed_event_dispatch(u32 event)
 {
 	ACPI_FUNCTION_ENTRY();
 	/* Clear the status bit */
 	(void)acpi_set_register(acpi_gbl_fixed_event_info[event].
 				status_register_id, 1);
 	/*
 	 * Make sure we've got a handler.  If not, report an error.
 	 * The event is disabled to prevent further interrupts.
 	 */
 	if (NULL == acpi_gbl_fixed_event_handlers[event].handler) {
 		(void)acpi_set_register(acpi_gbl_fixed_event_info[event].
 					enable_register_id, 0);
 		ACPI_ERROR((AE_INFO,
 			    "No installed handler for fixed event [%08X]",
 			    event));
 		return (ACPI_INTERRUPT_NOT_HANDLED);
 	}
 	/* Invoke the Fixed Event handler */
 	return ((acpi_gbl_fixed_event_handlers[event].
 		 handler) (acpi_gbl_fixed_event_handlers[event].context));
 }

drivers/acpi/hardware/hwregs.c

Diff comments View file @ d30dc9a

 /*******************************************************************************
  *
  * Module Name: hwregs - Read/write access functions for the various ACPI
  *                       control and status registers.
  *
  ******************************************************************************/
 /*
  * Copyright (C) 2000 - 2007, 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/acnamesp.h>
 #include <acpi/acevents.h>
 #define _COMPONENT          ACPI_HARDWARE
 ACPI_MODULE_NAME("hwregs")
 /*******************************************************************************
  *
  * FUNCTION:    acpi_hw_clear_acpi_status
  *
  * PARAMETERS:  None
  *
  * RETURN:      None
  *
  * DESCRIPTION: Clears all fixed and general purpose status bits
  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
  *
  ******************************************************************************/
 acpi_status acpi_hw_clear_acpi_status(void)
 {
 	acpi_status status;
 	acpi_cpu_flags lock_flags = 0;
 	ACPI_FUNCTION_TRACE(hw_clear_acpi_status);
 	ACPI_DEBUG_PRINT((ACPI_DB_IO, "About to write %04X to %04X\n",
 			  ACPI_BITMASK_ALL_FIXED_STATUS,
 			  (u16) acpi_gbl_FADT.xpm1a_event_block.address));
 	lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
-	status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+	status = acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS,
-					ACPI_REGISTER_PM1_STATUS,
 					ACPI_BITMASK_ALL_FIXED_STATUS);
 	if (ACPI_FAILURE(status)) {
 		goto unlock_and_exit;
 	}
 	/* Clear the fixed events */
 	if (acpi_gbl_FADT.xpm1b_event_block.address) {
 		status =
 		    acpi_hw_low_level_write(16, ACPI_BITMASK_ALL_FIXED_STATUS,
 					    &acpi_gbl_FADT.xpm1b_event_block);
 		if (ACPI_FAILURE(status)) {
 			goto unlock_and_exit;
 		}
 	}
 	/* Clear the GPE Bits in all GPE registers in all GPE blocks */
 	status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block);
       unlock_and_exit:
 	acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
 	return_ACPI_STATUS(status);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_sleep_type_data
  *
  * PARAMETERS:  sleep_state         - Numeric sleep state
  *              *sleep_type_a        - Where SLP_TYPa is returned
  *              *sleep_type_b        - Where SLP_TYPb is returned
  *
  * RETURN:      Status - ACPI status
  *
  * DESCRIPTION: Obtain the SLP_TYPa and SLP_TYPb values for the requested sleep
  *              state.
  *
  ******************************************************************************/
 acpi_status
 acpi_get_sleep_type_data(u8 sleep_state, u8 * sleep_type_a, u8 * sleep_type_b)
 {
 	acpi_status status = AE_OK;
 	struct acpi_evaluate_info *info;
 	ACPI_FUNCTION_TRACE(acpi_get_sleep_type_data);
 	/* Validate parameters */
 	if ((sleep_state > ACPI_S_STATES_MAX) || !sleep_type_a || !sleep_type_b) {
 		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 	/* Allocate the evaluation information block */
 	info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
 	if (!info) {
 		return_ACPI_STATUS(AE_NO_MEMORY);
 	}
 	info->pathname =
 	    ACPI_CAST_PTR(char, acpi_gbl_sleep_state_names[sleep_state]);
 	/* Evaluate the namespace object containing the values for this state */
 	status = acpi_ns_evaluate(info);
 	if (ACPI_FAILURE(status)) {
 		ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 				  "%s while evaluating SleepState [%s]\n",
 				  acpi_format_exception(status),
 				  info->pathname));
 		goto cleanup;
 	}
 	/* Must have a return object */
 	if (!info->return_object) {
 		ACPI_ERROR((AE_INFO, "No Sleep State object returned from [%s]",
 			    info->pathname));
 		status = AE_NOT_EXIST;
 	}
 	/* It must be of type Package */
 	else if (ACPI_GET_OBJECT_TYPE(info->return_object) != ACPI_TYPE_PACKAGE) {
 		ACPI_ERROR((AE_INFO,
 			    "Sleep State return object is not a Package"));
 		status = AE_AML_OPERAND_TYPE;
 	}
 	/*
 	 * The package must have at least two elements. NOTE (March 2005): This
 	 * goes against the current ACPI spec which defines this object as a
 	 * package with one encoded DWORD element. However, existing practice
 	 * by BIOS vendors seems to be to have 2 or more elements, at least
 	 * one per sleep type (A/B).
 	 */
 	else if (info->return_object->package.count < 2) {
 		ACPI_ERROR((AE_INFO,
 			    "Sleep State return package does not have at least two elements"));
 		status = AE_AML_NO_OPERAND;
 	}
 	/* The first two elements must both be of type Integer */
 	else if ((ACPI_GET_OBJECT_TYPE(info->return_object->package.elements[0])
 		  != ACPI_TYPE_INTEGER) ||
 		 (ACPI_GET_OBJECT_TYPE(info->return_object->package.elements[1])
 		  != ACPI_TYPE_INTEGER)) {
 		ACPI_ERROR((AE_INFO,
 			    "Sleep State return package elements are not both Integers (%s, %s)",
 			    acpi_ut_get_object_type_name(info->return_object->
 							 package.elements[0]),
 			    acpi_ut_get_object_type_name(info->return_object->
 							 package.elements[1])));
 		status = AE_AML_OPERAND_TYPE;
 	} else {
 		/* Valid _Sx_ package size, type, and value */
 		*sleep_type_a = (u8)
 		    (info->return_object->package.elements[0])->integer.value;
 		*sleep_type_b = (u8)
 		    (info->return_object->package.elements[1])->integer.value;
 	}
 	if (ACPI_FAILURE(status)) {
 		ACPI_EXCEPTION((AE_INFO, status,
 				"While evaluating SleepState [%s], bad Sleep object %p type %s",
 				info->pathname, info->return_object,
 				acpi_ut_get_object_type_name(info->
 							     return_object)));
 	}
 	acpi_ut_remove_reference(info->return_object);
       cleanup:
 	ACPI_FREE(info);
 	return_ACPI_STATUS(status);
 }
 ACPI_EXPORT_SYMBOL(acpi_get_sleep_type_data)
 /*******************************************************************************
  *
  * FUNCTION:    acpi_hw_get_register_bit_mask
  *
  * PARAMETERS:  register_id         - Index of ACPI Register to access
  *
  * RETURN:      The bitmask to be used when accessing the register
  *
  * DESCRIPTION: Map register_id into a register bitmask.
  *
  ******************************************************************************/
 struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id)
 {
 	ACPI_FUNCTION_ENTRY();
 	if (register_id > ACPI_BITREG_MAX) {
 		ACPI_ERROR((AE_INFO, "Invalid BitRegister ID: %X",
 			    register_id));
 		return (NULL);
 	}
 	return (&acpi_gbl_bit_register_info[register_id]);
 }
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_register
  *
  * PARAMETERS:  register_id     - ID of ACPI bit_register to access
  *              return_value    - Value that was read from the register
  *
  * RETURN:      Status and the value read from specified Register. Value
  *              returned is normalized to bit0 (is shifted all the way right)
  *
  * DESCRIPTION: ACPI bit_register read function.
  *
  ******************************************************************************/
-acpi_status acpi_get_register(u32 register_id, u32 * return_value)
+acpi_status acpi_get_register_unlocked(u32 register_id, u32 * return_value)
 {
 	u32 register_value = 0;
 	struct acpi_bit_register_info *bit_reg_info;
 	acpi_status status;
 	ACPI_FUNCTION_TRACE(acpi_get_register);
 	/* Get the info structure corresponding to the requested ACPI Register */
 	bit_reg_info = acpi_hw_get_bit_register_info(register_id);
 	if (!bit_reg_info) {
 		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 	/* Read from the register */
-	status = acpi_hw_register_read(ACPI_MTX_LOCK,
+	status = acpi_hw_register_read(bit_reg_info->parent_register,
-				       bit_reg_info->parent_register,
 				       &register_value);
 	if (ACPI_SUCCESS(status)) {
 		/* Normalize the value that was read */
 		register_value =
 		    ((register_value & bit_reg_info->access_bit_mask)
 		     >> bit_reg_info->bit_position);
 		*return_value = register_value;
 		ACPI_DEBUG_PRINT((ACPI_DB_IO, "Read value %8.8X register %X\n",
 				  register_value,
 				  bit_reg_info->parent_register));
 	}
 	return_ACPI_STATUS(status);
 }
+acpi_status acpi_get_register(u32 register_id, u32 * return_value)
+{
+	acpi_status status;
+	acpi_cpu_flags flags;
+	flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
+	status = acpi_get_register_unlocked(register_id, return_value);
+	acpi_os_release_lock(acpi_gbl_hardware_lock, flags);
+	return status;
+}
 ACPI_EXPORT_SYMBOL(acpi_get_register)
 /*******************************************************************************
  *
  * FUNCTION:    acpi_set_register
  *
  * PARAMETERS:  register_id     - ID of ACPI bit_register to access
  *              Value           - (only used on write) value to write to the
  *                                Register, NOT pre-normalized to the bit pos
  *
  * RETURN:      Status
  *
  * DESCRIPTION: ACPI Bit Register write function.
  *
  ******************************************************************************/
 acpi_status acpi_set_register(u32 register_id, u32 value)
 {
 	u32 register_value = 0;
 	struct acpi_bit_register_info *bit_reg_info;
 	acpi_status status;
 	acpi_cpu_flags lock_flags;
 	ACPI_FUNCTION_TRACE_U32(acpi_set_register, register_id);
 	/* Get the info structure corresponding to the requested ACPI Register */
 	bit_reg_info = acpi_hw_get_bit_register_info(register_id);
 	if (!bit_reg_info) {
 		ACPI_ERROR((AE_INFO, "Bad ACPI HW RegisterId: %X",
 			    register_id));
 		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 	lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
 	/* Always do a register read first so we can insert the new bits  */
-	status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+	status = acpi_hw_register_read(bit_reg_info->parent_register,
-				       bit_reg_info->parent_register,
 				       &register_value);
 	if (ACPI_FAILURE(status)) {
 		goto unlock_and_exit;
 	}
 	/*
 	 * Decode the Register ID
 	 * Register ID = [Register block ID] | [bit ID]
 	 *
 	 * Check bit ID to fine locate Register offset.
 	 * Check Mask to determine Register offset, and then read-write.
 	 */
 	switch (bit_reg_info->parent_register) {
 	case ACPI_REGISTER_PM1_STATUS:
 		/*
 		 * Status Registers are different from the rest. Clear by
 		 * writing 1, and writing 0 has no effect. So, the only relevant
 		 * information is the single bit we're interested in, all others should
 		 * be written as 0 so they will be left unchanged.
 		 */
 		value = ACPI_REGISTER_PREPARE_BITS(value,
 						   bit_reg_info->bit_position,
 						   bit_reg_info->
 						   access_bit_mask);
 		if (value) {
-			status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+			status = acpi_hw_register_write(ACPI_REGISTER_PM1_STATUS,
-							ACPI_REGISTER_PM1_STATUS,
 							(u16) value);
 			register_value = 0;
 		}
 		break;
 	case ACPI_REGISTER_PM1_ENABLE:
 		ACPI_REGISTER_INSERT_VALUE(register_value,
 					   bit_reg_info->bit_position,
 					   bit_reg_info->access_bit_mask,
 					   value);
-		status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+		status = acpi_hw_register_write(ACPI_REGISTER_PM1_ENABLE,
-						ACPI_REGISTER_PM1_ENABLE,
 						(u16) register_value);
 		break;
 	case ACPI_REGISTER_PM1_CONTROL:
 		/*
 		 * Write the PM1 Control register.
 		 * Note that at this level, the fact that there are actually TWO
 		 * registers (A and B - and B may not exist) is abstracted.
 		 */
 		ACPI_DEBUG_PRINT((ACPI_DB_IO, "PM1 control: Read %X\n",
 				  register_value));
 		ACPI_REGISTER_INSERT_VALUE(register_value,
 					   bit_reg_info->bit_position,
 					   bit_reg_info->access_bit_mask,
 					   value);
-		status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+		status = acpi_hw_register_write(ACPI_REGISTER_PM1_CONTROL,
-						ACPI_REGISTER_PM1_CONTROL,
 						(u16) register_value);
 		break;
 	case ACPI_REGISTER_PM2_CONTROL:
-		status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+		status = acpi_hw_register_read(ACPI_REGISTER_PM2_CONTROL,
-					       ACPI_REGISTER_PM2_CONTROL,
 					       &register_value);
 		if (ACPI_FAILURE(status)) {
 			goto unlock_and_exit;
 		}
 		ACPI_DEBUG_PRINT((ACPI_DB_IO,
 				  "PM2 control: Read %X from %8.8X%8.8X\n",
 				  register_value,
 				  ACPI_FORMAT_UINT64(acpi_gbl_FADT.
 						     xpm2_control_block.
 						     address)));
 		ACPI_REGISTER_INSERT_VALUE(register_value,
 					   bit_reg_info->bit_position,
 					   bit_reg_info->access_bit_mask,
 					   value);
 		ACPI_DEBUG_PRINT((ACPI_DB_IO,
 				  "About to write %4.4X to %8.8X%8.8X\n",
 				  register_value,
 				  ACPI_FORMAT_UINT64(acpi_gbl_FADT.
 						     xpm2_control_block.
 						     address)));
-		status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+		status = acpi_hw_register_write(ACPI_REGISTER_PM2_CONTROL,
-						ACPI_REGISTER_PM2_CONTROL,
 						(u8) (register_value));
 		break;
 	default:
 		break;
 	}
       unlock_and_exit:
 	acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
 	/* Normalize the value that was read */
 	ACPI_DEBUG_EXEC(register_value =
 			((register_value & bit_reg_info->access_bit_mask) >>
 			 bit_reg_info->bit_position));
 	ACPI_DEBUG_PRINT((ACPI_DB_IO,
 			  "Set bits: %8.8X actual %8.8X register %X\n", value,
 			  register_value, bit_reg_info->parent_register));
 	return_ACPI_STATUS(status);
 }
 ACPI_EXPORT_SYMBOL(acpi_set_register)
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_register_read
  *
- * PARAMETERS:  use_lock            - Lock hardware? True/False
+ * PARAMETERS:  register_id         - ACPI Register ID
- *              register_id         - ACPI Register ID
  *              return_value        - Where the register value is returned
  *
  * RETURN:      Status and the value read.
  *
  * DESCRIPTION: Read from the specified ACPI register
  *
  ******************************************************************************/
 acpi_status
-acpi_hw_register_read(u8 use_lock, u32 register_id, u32 * return_value)
+acpi_hw_register_read(u32 register_id, u32 * return_value)
 {
 	u32 value1 = 0;
 	u32 value2 = 0;
 	acpi_status status;
-	acpi_cpu_flags lock_flags = 0;
 	ACPI_FUNCTION_TRACE(hw_register_read);
-	if (ACPI_MTX_LOCK == use_lock) {
-		lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
-	}
 	switch (register_id) {
 	case ACPI_REGISTER_PM1_STATUS:	/* 16-bit access */
 		status =
 		    acpi_hw_low_level_read(16, &value1,
 					   &acpi_gbl_FADT.xpm1a_event_block);
 		if (ACPI_FAILURE(status)) {
-			goto unlock_and_exit;
+			goto exit;
 		}
 		/* PM1B is optional */
 		status =
 		    acpi_hw_low_level_read(16, &value2,
 					   &acpi_gbl_FADT.xpm1b_event_block);
 		value1 |= value2;
 		break;
 	case ACPI_REGISTER_PM1_ENABLE:	/* 16-bit access */
 		status =
 		    acpi_hw_low_level_read(16, &value1, &acpi_gbl_xpm1a_enable);
 		if (ACPI_FAILURE(status)) {
-			goto unlock_and_exit;
+			goto exit;
 		}
 		/* PM1B is optional */
 		status =
 		    acpi_hw_low_level_read(16, &value2, &acpi_gbl_xpm1b_enable);
 		value1 |= value2;
 		break;
 	case ACPI_REGISTER_PM1_CONTROL:	/* 16-bit access */
 		status =
 		    acpi_hw_low_level_read(16, &value1,
 					   &acpi_gbl_FADT.xpm1a_control_block);
 		if (ACPI_FAILURE(status)) {
-			goto unlock_and_exit;
+			goto exit;
 		}
 		status =
 		    acpi_hw_low_level_read(16, &value2,
 					   &acpi_gbl_FADT.xpm1b_control_block);
 		value1 |= value2;
 		break;
 	case ACPI_REGISTER_PM2_CONTROL:	/* 8-bit access */
 		status =
 		    acpi_hw_low_level_read(8, &value1,
 					   &acpi_gbl_FADT.xpm2_control_block);
 		break;
 	case ACPI_REGISTER_PM_TIMER:	/* 32-bit access */
 		status =
 		    acpi_hw_low_level_read(32, &value1,
 					   &acpi_gbl_FADT.xpm_timer_block);
 		break;
 	case ACPI_REGISTER_SMI_COMMAND_BLOCK:	/* 8-bit access */
 		status =
 		    acpi_os_read_port(acpi_gbl_FADT.smi_command, &value1, 8);
 		break;
 	default:
 		ACPI_ERROR((AE_INFO, "Unknown Register ID: %X", register_id));
 		status = AE_BAD_PARAMETER;
 		break;
 	}
-      unlock_and_exit:
+      exit:
-	if (ACPI_MTX_LOCK == use_lock) {
-		acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
-	}
 	if (ACPI_SUCCESS(status)) {
 		*return_value = value1;
 	}
 	return_ACPI_STATUS(status);
 }
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_register_write
  *
- * PARAMETERS:  use_lock            - Lock hardware? True/False
+ * PARAMETERS:  register_id         - ACPI Register ID
- *              register_id         - ACPI Register ID
  *              Value               - The value to write
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Write to the specified ACPI register
  *
  * NOTE: In accordance with the ACPI specification, this function automatically
  * preserves the value of the following bits, meaning that these bits cannot be
  * changed via this interface:
  *
  * PM1_CONTROL[0] = SCI_EN
  * PM1_CONTROL[9]
  * PM1_STATUS[11]
  *
  * ACPI References:
  * 1) Hardware Ignored Bits: When software writes to a register with ignored
  *      bit fields, it preserves the ignored bit fields
  * 2) SCI_EN: OSPM always preserves this bit position
  *
  ******************************************************************************/
-acpi_status acpi_hw_register_write(u8 use_lock, u32 register_id, u32 value)
+acpi_status acpi_hw_register_write(u32 register_id, u32 value)
 {
 	acpi_status status;
-	acpi_cpu_flags lock_flags = 0;
 	u32 read_value;
 	ACPI_FUNCTION_TRACE(hw_register_write);
-	if (ACPI_MTX_LOCK == use_lock) {
-		lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
-	}
 	switch (register_id) {
 	case ACPI_REGISTER_PM1_STATUS:	/* 16-bit access */
 		/* Perform a read first to preserve certain bits (per ACPI spec) */
-		status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+		status = acpi_hw_register_read(ACPI_REGISTER_PM1_STATUS,
-					       ACPI_REGISTER_PM1_STATUS,
 					       &read_value);
 		if (ACPI_FAILURE(status)) {
-			goto unlock_and_exit;
+			goto exit;
 		}
 		/* Insert the bits to be preserved */
 		ACPI_INSERT_BITS(value, ACPI_PM1_STATUS_PRESERVED_BITS,
 				 read_value);
 		/* Now we can write the data */
 		status =
 		    acpi_hw_low_level_write(16, value,
 					    &acpi_gbl_FADT.xpm1a_event_block);
 		if (ACPI_FAILURE(status)) {
-			goto unlock_and_exit;
+			goto exit;
 		}
 		/* PM1B is optional */
 		status =
 		    acpi_hw_low_level_write(16, value,
 					    &acpi_gbl_FADT.xpm1b_event_block);
 		break;
 	case ACPI_REGISTER_PM1_ENABLE:	/* 16-bit access */
 		status =
 		    acpi_hw_low_level_write(16, value, &acpi_gbl_xpm1a_enable);
 		if (ACPI_FAILURE(status)) {
-			goto unlock_and_exit;
+			goto exit;
 		}
 		/* PM1B is optional */
 		status =
 		    acpi_hw_low_level_write(16, value, &acpi_gbl_xpm1b_enable);
 		break;
 	case ACPI_REGISTER_PM1_CONTROL:	/* 16-bit access */
 		/*
 		 * Perform a read first to preserve certain bits (per ACPI spec)
 		 */
-		status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+		status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL,
-					       ACPI_REGISTER_PM1_CONTROL,
 					       &read_value);
 		if (ACPI_FAILURE(status)) {
-			goto unlock_and_exit;
+			goto exit;
 		}
 		/* Insert the bits to be preserved */
 		ACPI_INSERT_BITS(value, ACPI_PM1_CONTROL_PRESERVED_BITS,
 				 read_value);
 		/* Now we can write the data */
 		status =
 		    acpi_hw_low_level_write(16, value,
 					    &acpi_gbl_FADT.xpm1a_control_block);
 		if (ACPI_FAILURE(status)) {
-			goto unlock_and_exit;
+			goto exit;
 		}
 		status =
 		    acpi_hw_low_level_write(16, value,
 					    &acpi_gbl_FADT.xpm1b_control_block);
 		break;
 	case ACPI_REGISTER_PM1A_CONTROL:	/* 16-bit access */
 		status =
 		    acpi_hw_low_level_write(16, value,
 					    &acpi_gbl_FADT.xpm1a_control_block);
 		break;
 	case ACPI_REGISTER_PM1B_CONTROL:	/* 16-bit access */
 		status =
 		    acpi_hw_low_level_write(16, value,
 					    &acpi_gbl_FADT.xpm1b_control_block);
 		break;
 	case ACPI_REGISTER_PM2_CONTROL:	/* 8-bit access */
 		status =
 		    acpi_hw_low_level_write(8, value,
 					    &acpi_gbl_FADT.xpm2_control_block);
 		break;
 	case ACPI_REGISTER_PM_TIMER:	/* 32-bit access */
 		status =
 		    acpi_hw_low_level_write(32, value,
 					    &acpi_gbl_FADT.xpm_timer_block);
 		break;
 	case ACPI_REGISTER_SMI_COMMAND_BLOCK:	/* 8-bit access */
 		/* SMI_CMD is currently always in IO space */
 		status =
 		    acpi_os_write_port(acpi_gbl_FADT.smi_command, value, 8);
 		break;
 	default:
 		status = AE_BAD_PARAMETER;
 		break;
 	}
-      unlock_and_exit:
+      exit:
-	if (ACPI_MTX_LOCK == use_lock) {
-		acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
-	}
 	return_ACPI_STATUS(status);
 }
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_low_level_read
  *
  * PARAMETERS:  Width               - 8, 16, or 32
  *              Value               - Where the value is returned
  *              Reg                 - GAS register structure
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Read from either memory or IO space.
  *
  ******************************************************************************/
 acpi_status
 acpi_hw_low_level_read(u32 width, u32 * value, struct acpi_generic_address *reg)
 {
 	u64 address;
 	acpi_status status;
 	ACPI_FUNCTION_NAME(hw_low_level_read);
 	/*
 	 * Must have a valid pointer to a GAS structure, and
 	 * a non-zero address within. However, don't return an error
 	 * because the PM1A/B code must not fail if B isn't present.
 	 */
 	if (!reg) {
 		return (AE_OK);
 	}
 	/* Get a local copy of the address. Handles possible alignment issues */
 	ACPI_MOVE_64_TO_64(&address, &reg->address);
 	if (!address) {
 		return (AE_OK);
 	}
 	*value = 0;
 	/*
 	 * Two address spaces supported: Memory or IO.
 	 * PCI_Config is not supported here because the GAS struct is insufficient
 	 */
 	switch (reg->space_id) {
 	case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 		status = acpi_os_read_memory((acpi_physical_address) address,
 					     value, width);
 		break;
 	case ACPI_ADR_SPACE_SYSTEM_IO:
 		status =
 		    acpi_os_read_port((acpi_io_address) address, value, width);
 		break;
 	default:
 		ACPI_ERROR((AE_INFO,
 			    "Unsupported address space: %X", reg->space_id));
 		return (AE_BAD_PARAMETER);
 	}
 	ACPI_DEBUG_PRINT((ACPI_DB_IO,
 			  "Read:  %8.8X width %2d from %8.8X%8.8X (%s)\n",
 			  *value, width, ACPI_FORMAT_UINT64(address),
 			  acpi_ut_get_region_name(reg->space_id)));
 	return (status);
 }
 /******************************************************************************
  *
  * FUNCTION:    acpi_hw_low_level_write
  *
  * PARAMETERS:  Width               - 8, 16, or 32
  *              Value               - To be written
  *              Reg                 - GAS register structure
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Write to either memory or IO space.
  *
  ******************************************************************************/
 acpi_status
 acpi_hw_low_level_write(u32 width, u32 value, struct acpi_generic_address * reg)
 {
 	u64 address;
 	acpi_status status;
 	ACPI_FUNCTION_NAME(hw_low_level_write);
 	/*
 	 * Must have a valid pointer to a GAS structure, and
 	 * a non-zero address within. However, don't return an error
 	 * because the PM1A/B code must not fail if B isn't present.
 	 */
 	if (!reg) {
 		return (AE_OK);
 	}
 	/* Get a local copy of the address. Handles possible alignment issues */
 	ACPI_MOVE_64_TO_64(&address, &reg->address);
 	if (!address) {
 		return (AE_OK);
 	}
 	/*
 	 * Two address spaces supported: Memory or IO.
 	 * PCI_Config is not supported here because the GAS struct is insufficient
 	 */
 	switch (reg->space_id) {
 	case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 		status = acpi_os_write_memory((acpi_physical_address) address,
 					      value, width);
 		break;
 	case ACPI_ADR_SPACE_SYSTEM_IO:
 		status = acpi_os_write_port((acpi_io_address) address, value,
 					    width);
 		break;
 	default:
 		ACPI_ERROR((AE_INFO,
 			    "Unsupported address space: %X", reg->space_id));
 		return (AE_BAD_PARAMETER);

drivers/acpi/hardware/hwsleep.c

Diff comments View file @ d30dc9a

 /******************************************************************************
  *
  * Name: hwsleep.c - ACPI Hardware Sleep/Wake Interface
  *
  *****************************************************************************/
 /*
  * Copyright (C) 2000 - 2007, 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/actables.h>
 #define _COMPONENT          ACPI_HARDWARE
 ACPI_MODULE_NAME("hwsleep")
 /*******************************************************************************
  *
  * FUNCTION:    acpi_set_firmware_waking_vector
  *
  * PARAMETERS:  physical_address    - Physical address of ACPI real mode
  *                                    entry point.
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Access function for the firmware_waking_vector field in FACS
  *
  ******************************************************************************/
 acpi_status
 acpi_set_firmware_waking_vector(acpi_physical_address physical_address)
 {
 	struct acpi_table_facs *facs;
 	acpi_status status;
 	ACPI_FUNCTION_TRACE(acpi_set_firmware_waking_vector);
 	/* Get the FACS */
 	status =
 	    acpi_get_table_by_index(ACPI_TABLE_INDEX_FACS,
 				    (struct acpi_table_header **)&facs);
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	/* Set the vector */
 	if ((facs->length < 32) || (!(facs->xfirmware_waking_vector))) {
 		/*
 		 * ACPI 1.0 FACS or short table or optional X_ field is zero
 		 */
 		facs->firmware_waking_vector = (u32) physical_address;
 	} else {
 		/*
 		 * ACPI 2.0 FACS with valid X_ field
 		 */
 		facs->xfirmware_waking_vector = physical_address;
 	}
 	return_ACPI_STATUS(AE_OK);
 }
 ACPI_EXPORT_SYMBOL(acpi_set_firmware_waking_vector)
 /*******************************************************************************
  *
  * FUNCTION:    acpi_get_firmware_waking_vector
  *
  * PARAMETERS:  *physical_address   - Where the contents of
  *                                    the firmware_waking_vector field of
  *                                    the FACS will be returned.
  *
  * RETURN:      Status, vector
  *
  * DESCRIPTION: Access function for the firmware_waking_vector field in FACS
  *
  ******************************************************************************/
 #ifdef ACPI_FUTURE_USAGE
 acpi_status
 acpi_get_firmware_waking_vector(acpi_physical_address * physical_address)
 {
 	struct acpi_table_facs *facs;
 	acpi_status status;
 	ACPI_FUNCTION_TRACE(acpi_get_firmware_waking_vector);
 	if (!physical_address) {
 		return_ACPI_STATUS(AE_BAD_PARAMETER);
 	}
 	/* Get the FACS */
 	status =
 	    acpi_get_table_by_index(ACPI_TABLE_INDEX_FACS,
 				    (struct acpi_table_header **)&facs);
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	/* Get the vector */
 	if ((facs->length < 32) || (!(facs->xfirmware_waking_vector))) {
 		/*
 		 * ACPI 1.0 FACS or short table or optional X_ field is zero
 		 */
 		*physical_address =
 		    (acpi_physical_address) facs->firmware_waking_vector;
 	} else {
 		/*
 		 * ACPI 2.0 FACS with valid X_ field
 		 */
 		*physical_address =
 		    (acpi_physical_address) facs->xfirmware_waking_vector;
 	}
 	return_ACPI_STATUS(AE_OK);
 }
 ACPI_EXPORT_SYMBOL(acpi_get_firmware_waking_vector)
 #endif
 /*******************************************************************************
  *
  * FUNCTION:    acpi_enter_sleep_state_prep
  *
  * PARAMETERS:  sleep_state         - Which sleep state to enter
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Prepare to enter a system sleep state (see ACPI 2.0 spec p 231)
  *              This function must execute with interrupts enabled.
  *              We break sleeping into 2 stages so that OSPM can handle
  *              various OS-specific tasks between the two steps.
  *
  ******************************************************************************/
 acpi_status acpi_enter_sleep_state_prep(u8 sleep_state)
 {
 	acpi_status status;
 	struct acpi_object_list arg_list;
 	union acpi_object arg;
 	ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_prep);
 	/*
 	 * _PSW methods could be run here to enable wake-on keyboard, LAN, etc.
 	 */
 	status = acpi_get_sleep_type_data(sleep_state,
 					  &acpi_gbl_sleep_type_a,
 					  &acpi_gbl_sleep_type_b);
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	/* Setup parameter object */
 	arg_list.count = 1;
 	arg_list.pointer = &arg;
 	arg.type = ACPI_TYPE_INTEGER;
 	arg.integer.value = sleep_state;
 	/* Run the _PTS and _GTS methods */
 	status = acpi_evaluate_object(NULL, METHOD_NAME__PTS, &arg_list, NULL);
 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 		return_ACPI_STATUS(status);
 	}
 	status = acpi_evaluate_object(NULL, METHOD_NAME__GTS, &arg_list, NULL);
 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 		return_ACPI_STATUS(status);
 	}
 	/* Setup the argument to _SST */
 	switch (sleep_state) {
 	case ACPI_STATE_S0:
 		arg.integer.value = ACPI_SST_WORKING;
 		break;
 	case ACPI_STATE_S1:
 	case ACPI_STATE_S2:
 	case ACPI_STATE_S3:
 		arg.integer.value = ACPI_SST_SLEEPING;
 		break;
 	case ACPI_STATE_S4:
 		arg.integer.value = ACPI_SST_SLEEP_CONTEXT;
 		break;
 	default:
 		arg.integer.value = ACPI_SST_INDICATOR_OFF;	/* Default is off */
 		break;
 	}
 	/* Set the system indicators to show the desired sleep state. */
 	status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL);
 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 		ACPI_EXCEPTION((AE_INFO, status,
 				"While executing method _SST"));
 	}
 	/*
 	 * 1) Disable/Clear all GPEs
 	 */
 	status = acpi_hw_disable_all_gpes();
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	return_ACPI_STATUS(AE_OK);
 }
 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_prep)
 /*******************************************************************************
  *
  * FUNCTION:    acpi_enter_sleep_state
  *
  * PARAMETERS:  sleep_state         - Which sleep state to enter
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Enter a system sleep state (see ACPI 2.0 spec p 231)
  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
  *
  ******************************************************************************/
 acpi_status asmlinkage acpi_enter_sleep_state(u8 sleep_state)
 {
 	u32 PM1Acontrol;
 	u32 PM1Bcontrol;
 	struct acpi_bit_register_info *sleep_type_reg_info;
 	struct acpi_bit_register_info *sleep_enable_reg_info;
 	u32 in_value;
 	acpi_status status;
 	ACPI_FUNCTION_TRACE(acpi_enter_sleep_state);
 	if ((acpi_gbl_sleep_type_a > ACPI_SLEEP_TYPE_MAX) ||
 	    (acpi_gbl_sleep_type_b > ACPI_SLEEP_TYPE_MAX)) {
 		ACPI_ERROR((AE_INFO, "Sleep values out of range: A=%X B=%X",
 			    acpi_gbl_sleep_type_a, acpi_gbl_sleep_type_b));
 		return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
 	}
 	sleep_type_reg_info =
 	    acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE_A);
 	sleep_enable_reg_info =
 	    acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE);
 	/* Clear wake status */
 	status = acpi_set_register(ACPI_BITREG_WAKE_STATUS, 1);
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	/* Clear all fixed and general purpose status bits */
 	status = acpi_hw_clear_acpi_status();
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	/*
 	 * 2) Enable all wakeup GPEs
 	 */
 	status = acpi_hw_disable_all_gpes();
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	acpi_gbl_system_awake_and_running = FALSE;
 	status = acpi_hw_enable_all_wakeup_gpes();
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	/* Get current value of PM1A control */
-	status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+	status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL, &PM1Acontrol);
-				       ACPI_REGISTER_PM1_CONTROL, &PM1Acontrol);
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	ACPI_DEBUG_PRINT((ACPI_DB_INIT,
 			  "Entering sleep state [S%d]\n", sleep_state));
 	/* Clear SLP_EN and SLP_TYP fields */
 	PM1Acontrol &= ~(sleep_type_reg_info->access_bit_mask |
 			 sleep_enable_reg_info->access_bit_mask);
 	PM1Bcontrol = PM1Acontrol;
 	/* Insert SLP_TYP bits */
 	PM1Acontrol |=
 	    (acpi_gbl_sleep_type_a << sleep_type_reg_info->bit_position);
 	PM1Bcontrol |=
 	    (acpi_gbl_sleep_type_b << sleep_type_reg_info->bit_position);
 	/*
 	 * We split the writes of SLP_TYP and SLP_EN to workaround
 	 * poorly implemented hardware.
 	 */
 	/* Write #1: fill in SLP_TYP data */
-	status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+	status = acpi_hw_register_write(ACPI_REGISTER_PM1A_CONTROL,
-					ACPI_REGISTER_PM1A_CONTROL,
 					PM1Acontrol);
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
-	status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+	status = acpi_hw_register_write(ACPI_REGISTER_PM1B_CONTROL,
-					ACPI_REGISTER_PM1B_CONTROL,
 					PM1Bcontrol);
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	/* Insert SLP_ENABLE bit */
 	PM1Acontrol |= sleep_enable_reg_info->access_bit_mask;
 	PM1Bcontrol |= sleep_enable_reg_info->access_bit_mask;
 	/* Write #2: SLP_TYP + SLP_EN */
 	ACPI_FLUSH_CPU_CACHE();
-	status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+	status = acpi_hw_register_write(ACPI_REGISTER_PM1A_CONTROL,
-					ACPI_REGISTER_PM1A_CONTROL,
 					PM1Acontrol);
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
-	status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+	status = acpi_hw_register_write(ACPI_REGISTER_PM1B_CONTROL,
-					ACPI_REGISTER_PM1B_CONTROL,
 					PM1Bcontrol);
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	if (sleep_state > ACPI_STATE_S3) {
 		/*
 		 * We wanted to sleep > S3, but it didn't happen (by virtue of the
 		 * fact that we are still executing!)
 		 *
 		 * Wait ten seconds, then try again. This is to get S4/S5 to work on
 		 * all machines.
 		 *
 		 * We wait so long to allow chipsets that poll this reg very slowly to
 		 * still read the right value. Ideally, this block would go
 		 * away entirely.
 		 */
 		acpi_os_stall(10000000);
-		status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+		status = acpi_hw_register_write(ACPI_REGISTER_PM1_CONTROL,
-						ACPI_REGISTER_PM1_CONTROL,
 						sleep_enable_reg_info->
 						access_bit_mask);
 		if (ACPI_FAILURE(status)) {
 			return_ACPI_STATUS(status);
 		}
 	}
 	/* Wait until we enter sleep state */
 	do {
 		status = acpi_get_register(ACPI_BITREG_WAKE_STATUS, &in_value);
 		if (ACPI_FAILURE(status)) {
 			return_ACPI_STATUS(status);
 		}
 		/* Spin until we wake */
 	} while (!in_value);
 	return_ACPI_STATUS(AE_OK);
 }
 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state)
 /*******************************************************************************
  *
  * FUNCTION:    acpi_enter_sleep_state_s4bios
  *
  * PARAMETERS:  None
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Perform a S4 bios request.
  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
  *
  ******************************************************************************/
 acpi_status asmlinkage acpi_enter_sleep_state_s4bios(void)
 {
 	u32 in_value;
 	acpi_status status;
 	ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_s4bios);
 	status = acpi_set_register(ACPI_BITREG_WAKE_STATUS, 1);
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	status = acpi_hw_clear_acpi_status();
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	/*
 	 * 1) Disable/Clear all GPEs
 	 * 2) Enable all wakeup GPEs
 	 */
 	status = acpi_hw_disable_all_gpes();
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	acpi_gbl_system_awake_and_running = FALSE;
 	status = acpi_hw_enable_all_wakeup_gpes();
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	ACPI_FLUSH_CPU_CACHE();
 	status = acpi_os_write_port(acpi_gbl_FADT.smi_command,
 				    (u32) acpi_gbl_FADT.S4bios_request, 8);
 	do {
 		acpi_os_stall(1000);
 		status = acpi_get_register(ACPI_BITREG_WAKE_STATUS, &in_value);
 		if (ACPI_FAILURE(status)) {
 			return_ACPI_STATUS(status);
 		}
 	} while (!in_value);
 	return_ACPI_STATUS(AE_OK);
 }
 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios)
 /*******************************************************************************
  *
  * FUNCTION:    acpi_leave_sleep_state
  *
  * PARAMETERS:  sleep_state         - Which sleep state we just exited
  *
  * RETURN:      Status
  *
  * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep
  *              Called with interrupts ENABLED.
  *
  ******************************************************************************/
 acpi_status acpi_leave_sleep_state(u8 sleep_state)
 {
 	struct acpi_object_list arg_list;
 	union acpi_object arg;
 	acpi_status status;
 	struct acpi_bit_register_info *sleep_type_reg_info;
 	struct acpi_bit_register_info *sleep_enable_reg_info;
 	u32 PM1Acontrol;
 	u32 PM1Bcontrol;
 	ACPI_FUNCTION_TRACE(acpi_leave_sleep_state);
 	/*
 	 * Set SLP_TYPE and SLP_EN to state S0.
 	 * This is unclear from the ACPI Spec, but it is required
 	 * by some machines.
 	 */
 	status = acpi_get_sleep_type_data(ACPI_STATE_S0,
 					  &acpi_gbl_sleep_type_a,
 					  &acpi_gbl_sleep_type_b);
 	if (ACPI_SUCCESS(status)) {
 		sleep_type_reg_info =
 		    acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE_A);
 		sleep_enable_reg_info =
 		    acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE);
 		/* Get current value of PM1A control */
-		status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
+		status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL,
-					       ACPI_REGISTER_PM1_CONTROL,
 					       &PM1Acontrol);
 		if (ACPI_SUCCESS(status)) {
 			/* Clear SLP_EN and SLP_TYP fields */
 			PM1Acontrol &= ~(sleep_type_reg_info->access_bit_mask |
 					 sleep_enable_reg_info->
 					 access_bit_mask);
 			PM1Bcontrol = PM1Acontrol;
 			/* Insert SLP_TYP bits */
 			PM1Acontrol |=
 			    (acpi_gbl_sleep_type_a << sleep_type_reg_info->
 			     bit_position);
 			PM1Bcontrol |=
 			    (acpi_gbl_sleep_type_b << sleep_type_reg_info->
 			     bit_position);
 			/* Just ignore any errors */
-			(void)acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+			(void)acpi_hw_register_write(ACPI_REGISTER_PM1A_CONTROL,
-						     ACPI_REGISTER_PM1A_CONTROL,
 						     PM1Acontrol);
-			(void)acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
+			(void)acpi_hw_register_write(ACPI_REGISTER_PM1B_CONTROL,
-						     ACPI_REGISTER_PM1B_CONTROL,
 						     PM1Bcontrol);
 		}
 	}
 	/* Ensure enter_sleep_state_prep -> enter_sleep_state ordering */
 	acpi_gbl_sleep_type_a = ACPI_SLEEP_TYPE_INVALID;
 	/* Setup parameter object */
 	arg_list.count = 1;
 	arg_list.pointer = &arg;
 	arg.type = ACPI_TYPE_INTEGER;
 	/* Ignore any errors from these methods */
 	arg.integer.value = ACPI_SST_WAKING;
 	status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL);
 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 		ACPI_EXCEPTION((AE_INFO, status, "During Method _SST"));
 	}
 	arg.integer.value = sleep_state;
 	status = acpi_evaluate_object(NULL, METHOD_NAME__BFS, &arg_list, NULL);
 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 		ACPI_EXCEPTION((AE_INFO, status, "During Method _BFS"));
 	}
 	/*
 	 * GPEs must be enabled before _WAK is called as GPEs
 	 * might get fired there
 	 *
 	 * Restore the GPEs:
 	 * 1) Disable/Clear all GPEs
 	 * 2) Enable all runtime GPEs
 	 */
 	status = acpi_hw_disable_all_gpes();
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	status = acpi_hw_enable_all_runtime_gpes();
 	if (ACPI_FAILURE(status)) {
 		return_ACPI_STATUS(status);
 	}
 	status = acpi_evaluate_object(NULL, METHOD_NAME__WAK, &arg_list, NULL);
 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 		ACPI_EXCEPTION((AE_INFO, status, "During Method _WAK"));
 	}
 	/* TBD: _WAK "sometimes" returns stuff - do we want to look at it? */
 	acpi_gbl_system_awake_and_running = TRUE;
 	/* Enable power button */
 	(void)
 	    acpi_set_register(acpi_gbl_fixed_event_info
 			      [ACPI_EVENT_POWER_BUTTON].enable_register_id, 1);
 	(void)
 	    acpi_set_register(acpi_gbl_fixed_event_info
 			      [ACPI_EVENT_POWER_BUTTON].status_register_id, 1);
 	arg.integer.value = ACPI_SST_WORKING;
 	status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL);
 	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
 		ACPI_EXCEPTION((AE_INFO, status, "During Method _SST"));
 	}
 	return_ACPI_STATUS(status);
 }
 ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state)

include/acpi/achware.h

Diff comments View file @ d30dc9a

1	/******************************************************************************	1	/******************************************************************************
2	*	2	*
3	* Name: achware.h -- hardware specific interfaces	3	* Name: achware.h -- hardware specific interfaces
4	*	4	*
5	*****************************************************************************/	5	*****************************************************************************/
6		6
7	/*	7	/*
8	* Copyright (C) 2000 - 2007, R. Byron Moore	8	* Copyright (C) 2000 - 2007, R. Byron Moore
9	* All rights reserved.	9	* All rights reserved.
10	*	10	*
11	* Redistribution and use in source and binary forms, with or without	11	* Redistribution and use in source and binary forms, with or without
12	* modification, are permitted provided that the following conditions	12	* modification, are permitted provided that the following conditions
13	* are met:	13	* are met:
14	* 1. Redistributions of source code must retain the above copyright	14	* 1. Redistributions of source code must retain the above copyright
15	* notice, this list of conditions, and the following disclaimer,	15	* notice, this list of conditions, and the following disclaimer,
16	* without modification.	16	* without modification.
17	* 2. Redistributions in binary form must reproduce at minimum a disclaimer	17	* 2. Redistributions in binary form must reproduce at minimum a disclaimer
18	* substantially similar to the "NO WARRANTY" disclaimer below	18	* substantially similar to the "NO WARRANTY" disclaimer below
19	* ("Disclaimer") and any redistribution must be conditioned upon	19	* ("Disclaimer") and any redistribution must be conditioned upon
20	* including a substantially similar Disclaimer requirement for further	20	* including a substantially similar Disclaimer requirement for further
21	* binary redistribution.	21	* binary redistribution.
22	* 3. Neither the names of the above-listed copyright holders nor the names	22	* 3. Neither the names of the above-listed copyright holders nor the names
23	* of any contributors may be used to endorse or promote products derived	23	* of any contributors may be used to endorse or promote products derived
24	* from this software without specific prior written permission.	24	* from this software without specific prior written permission.
25	*	25	*
26	* Alternatively, this software may be distributed under the terms of the	26	* Alternatively, this software may be distributed under the terms of the
27	* GNU General Public License ("GPL") version 2 as published by the Free	27	* GNU General Public License ("GPL") version 2 as published by the Free
28	* Software Foundation.	28	* Software Foundation.
29	*	29	*
30	* NO WARRANTY	30	* NO WARRANTY
31	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS	31	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT	32	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR	33	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT	34	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35	* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL	35	* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS	36	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)	37	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,	38	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING	39	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE	40	* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41	* POSSIBILITY OF SUCH DAMAGES.	41	* POSSIBILITY OF SUCH DAMAGES.
42	*/	42	*/
43		43
44	#ifndef __ACHWARE_H__	44	#ifndef __ACHWARE_H__
45	#define __ACHWARE_H__	45	#define __ACHWARE_H__
46		46
47	/* PM Timer ticks per second (HZ) */	47	/* PM Timer ticks per second (HZ) */
48		48
49	#define PM_TIMER_FREQUENCY 3579545	49	#define PM_TIMER_FREQUENCY 3579545
50		50
51	/* Values for the _SST reserved method */	51	/* Values for the _SST reserved method */
52		52
53	#define ACPI_SST_INDICATOR_OFF 0	53	#define ACPI_SST_INDICATOR_OFF 0
54	#define ACPI_SST_WORKING 1	54	#define ACPI_SST_WORKING 1
55	#define ACPI_SST_WAKING 2	55	#define ACPI_SST_WAKING 2
56	#define ACPI_SST_SLEEPING 3	56	#define ACPI_SST_SLEEPING 3
57	#define ACPI_SST_SLEEP_CONTEXT 4	57	#define ACPI_SST_SLEEP_CONTEXT 4
58		58
59	/* Prototypes */	59	/* Prototypes */
60		60
61	/*	61	/*
62	* hwacpi - high level functions	62	* hwacpi - high level functions
63	*/	63	*/
64	acpi_status acpi_hw_set_mode(u32 mode);	64	acpi_status acpi_hw_set_mode(u32 mode);
65		65
66	u32 acpi_hw_get_mode(void);	66	u32 acpi_hw_get_mode(void);
67		67
68	/*	68	/*
69	* hwregs - ACPI Register I/O	69	* hwregs - ACPI Register I/O
70	*/	70	*/
71	struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id);	71	struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id);
72		72
73	acpi_status	73	acpi_status
74	acpi_hw_register_read(u8 use_lock, u32 register_id, u32 * return_value);	74	acpi_hw_register_read(u32 register_id, u32 * return_value);
75		75
76	acpi_status acpi_hw_register_write(u8 use_lock, u32 register_id, u32 value);	76	acpi_status acpi_hw_register_write(u32 register_id, u32 value);
77		77
78	acpi_status	78	acpi_status
79	acpi_hw_low_level_read(u32 width,	79	acpi_hw_low_level_read(u32 width,
80	u32 * value, struct acpi_generic_address *reg);	80	u32 * value, struct acpi_generic_address *reg);
81		81
82	acpi_status	82	acpi_status
83	acpi_hw_low_level_write(u32 width, u32 value, struct acpi_generic_address *reg);	83	acpi_hw_low_level_write(u32 width, u32 value, struct acpi_generic_address *reg);
84		84
85	acpi_status acpi_hw_clear_acpi_status(void);	85	acpi_status acpi_hw_clear_acpi_status(void);
86		86
87	/*	87	/*
88	* hwgpe - GPE support	88	* hwgpe - GPE support
89	*/	89	*/
90	acpi_status	90	acpi_status
91	acpi_hw_write_gpe_enable_reg(struct acpi_gpe_event_info *gpe_event_info);	91	acpi_hw_write_gpe_enable_reg(struct acpi_gpe_event_info *gpe_event_info);
92		92
93	acpi_status	93	acpi_status
94	acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,	94	acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
95	struct acpi_gpe_block_info *gpe_block);	95	struct acpi_gpe_block_info *gpe_block);
96		96
97	acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info *gpe_event_info);	97	acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info *gpe_event_info);
98		98
99	acpi_status	99	acpi_status
100	acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,	100	acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
101	struct acpi_gpe_block_info *gpe_block);	101	struct acpi_gpe_block_info *gpe_block);
102		102
103	#ifdef ACPI_FUTURE_USAGE	103	#ifdef ACPI_FUTURE_USAGE
104	acpi_status	104	acpi_status
105	acpi_hw_get_gpe_status(struct acpi_gpe_event_info *gpe_event_info,	105	acpi_hw_get_gpe_status(struct acpi_gpe_event_info *gpe_event_info,
106	acpi_event_status * event_status);	106	acpi_event_status * event_status);
107	#endif /* ACPI_FUTURE_USAGE */	107	#endif /* ACPI_FUTURE_USAGE */
108		108
109	acpi_status acpi_hw_disable_all_gpes(void);	109	acpi_status acpi_hw_disable_all_gpes(void);
110		110
111	acpi_status acpi_hw_enable_all_runtime_gpes(void);	111	acpi_status acpi_hw_enable_all_runtime_gpes(void);
112		112
113	acpi_status acpi_hw_enable_all_wakeup_gpes(void);	113	acpi_status acpi_hw_enable_all_wakeup_gpes(void);
114		114
115	acpi_status	115	acpi_status
116	acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,	116	acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
117	struct acpi_gpe_block_info *gpe_block);	117	struct acpi_gpe_block_info *gpe_block);
118		118
119	#ifdef ACPI_FUTURE_USAGE	119	#ifdef ACPI_FUTURE_USAGE
120	/*	120	/*
121	* hwtimer - ACPI Timer prototypes	121	* hwtimer - ACPI Timer prototypes
122	*/	122	*/
123	acpi_status acpi_get_timer_resolution(u32 * resolution);	123	acpi_status acpi_get_timer_resolution(u32 * resolution);
124		124
125	acpi_status acpi_get_timer(u32 * ticks);	125	acpi_status acpi_get_timer(u32 * ticks);
126		126
127	acpi_status	127	acpi_status
128	acpi_get_timer_duration(u32 start_ticks, u32 end_ticks, u32 * time_elapsed);	128	acpi_get_timer_duration(u32 start_ticks, u32 end_ticks, u32 * time_elapsed);
129	#endif /* ACPI_FUTURE_USAGE */	129	#endif /* ACPI_FUTURE_USAGE */
130		130
131	#endif /* __ACHWARE_H__ */	131	#endif /* __ACHWARE_H__ */
132		132