[linux-block.git] / drivers / acpi / acpica / hwgpe.c


/******************************************************************************
 *
 * Module Name: hwgpe - Low level GPE enable/disable/clear functions
 *
 *****************************************************************************/

/*
 * Copyright (C) 2000 - 2012, 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 "acevents.h"

#define _COMPONENT          ACPI_HARDWARE
ACPI_MODULE_NAME("hwgpe")
#if (!ACPI_REDUCED_HARDWARE)	/* Entire module */
/* Local prototypes */
static acpi_status
acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
				struct acpi_gpe_block_info *gpe_block,
				void *context);

/******************************************************************************
 *
 * FUNCTION:	acpi_hw_get_gpe_register_bit
 *
 * PARAMETERS:	gpe_event_info	    - Info block for the GPE
 *
 * RETURN:	Register mask with a one in the GPE bit position
 *
 * DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
 *              correct position for the input GPE.
 *
 ******************************************************************************/

u32 acpi_hw_get_gpe_register_bit(struct acpi_gpe_event_info *gpe_event_info)
{
	return (u32)1 << (gpe_event_info->gpe_number -
		 gpe_event_info->register_info->base_gpe_number);
}

/******************************************************************************
 *
 * FUNCTION:	acpi_hw_low_set_gpe
 *
 * PARAMETERS:	gpe_event_info	    - Info block for the GPE to be disabled
 *		action		    - Enable or disable
 *
 * RETURN:	Status
 *
 * DESCRIPTION: Enable or disable a single GPE in the parent enable register.
 *
 ******************************************************************************/

acpi_status
acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action)
{
	struct acpi_gpe_register_info *gpe_register_info;
	acpi_status status;
	u32 enable_mask;
	u32 register_bit;

	ACPI_FUNCTION_ENTRY();

	/* Get the info block for the entire GPE register */

	gpe_register_info = gpe_event_info->register_info;
	if (!gpe_register_info) {
		return (AE_NOT_EXIST);
	}

	/* Get current value of the enable register that contains this GPE */

	status = acpi_hw_read(&enable_mask, &gpe_register_info->enable_address);
	if (ACPI_FAILURE(status)) {
		return (status);
	}

	/* Set or clear just the bit that corresponds to this GPE */

	register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
	switch (action) {
	case ACPI_GPE_CONDITIONAL_ENABLE:

		/* Only enable if the enable_for_run bit is set */

		if (!(register_bit & gpe_register_info->enable_for_run)) {
			return (AE_BAD_PARAMETER);
		}

		/*lint -fallthrough */

	case ACPI_GPE_ENABLE:
		ACPI_SET_BIT(enable_mask, register_bit);
		break;

	case ACPI_GPE_DISABLE:
		ACPI_CLEAR_BIT(enable_mask, register_bit);
		break;

	default:
		ACPI_ERROR((AE_INFO, "Invalid GPE Action, %u\n", action));
		return (AE_BAD_PARAMETER);
	}

	/* Write the updated enable mask */

	status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address);
	return (status);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_clear_gpe
 *
 * PARAMETERS:  gpe_event_info      - Info block for the GPE to be cleared
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Clear the status bit for a single GPE.
 *
 ******************************************************************************/

acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)
{
	struct acpi_gpe_register_info *gpe_register_info;
	acpi_status status;
	u32 register_bit;

	ACPI_FUNCTION_ENTRY();

	/* Get the info block for the entire GPE register */

	gpe_register_info = gpe_event_info->register_info;
	if (!gpe_register_info) {
		return (AE_NOT_EXIST);
	}

	/*
	 * Write a one to the appropriate bit in the status register to
	 * clear this GPE.
	 */
	register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);

	status = acpi_hw_write(register_bit,
			       &gpe_register_info->status_address);

	return (status);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_get_gpe_status
 *
 * PARAMETERS:  gpe_event_info      - Info block for the GPE to queried
 *              event_status        - Where the GPE status is returned
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Return the status of a single GPE.
 *
 ******************************************************************************/

acpi_status
acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,
		       acpi_event_status * event_status)
{
	u32 in_byte;
	u32 register_bit;
	struct acpi_gpe_register_info *gpe_register_info;
	acpi_event_status local_event_status = 0;
	acpi_status status;

	ACPI_FUNCTION_ENTRY();

	if (!event_status) {
		return (AE_BAD_PARAMETER);
	}

	/* Get the info block for the entire GPE register */

	gpe_register_info = gpe_event_info->register_info;

	/* Get the register bitmask for this GPE */

	register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);

	/* GPE currently enabled? (enabled for runtime?) */

	if (register_bit & gpe_register_info->enable_for_run) {
		local_event_status |= ACPI_EVENT_FLAG_ENABLED;
	}

	/* GPE enabled for wake? */

	if (register_bit & gpe_register_info->enable_for_wake) {
		local_event_status |= ACPI_EVENT_FLAG_WAKE_ENABLED;
	}

	/* GPE currently active (status bit == 1)? */

	status = acpi_hw_read(&in_byte, &gpe_register_info->status_address);
	if (ACPI_FAILURE(status)) {
		return (status);
	}

	if (register_bit & in_byte) {
		local_event_status |= ACPI_EVENT_FLAG_SET;
	}

	/* Set return value */

	(*event_status) = local_event_status;
	return (AE_OK);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_disable_gpe_block
 *
 * PARAMETERS:  gpe_xrupt_info      - GPE Interrupt info
 *              gpe_block           - Gpe Block info
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Disable all GPEs within a single GPE block
 *
 ******************************************************************************/

acpi_status
acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
			  struct acpi_gpe_block_info *gpe_block, void *context)
{
	u32 i;
	acpi_status status;

	/* Examine each GPE Register within the block */

	for (i = 0; i < gpe_block->register_count; i++) {

		/* Disable all GPEs in this register */

		status =
		    acpi_hw_write(0x00,
				  &gpe_block->register_info[i].enable_address);
		if (ACPI_FAILURE(status)) {
			return (status);
		}
	}

	return (AE_OK);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_clear_gpe_block
 *
 * PARAMETERS:  gpe_xrupt_info      - GPE Interrupt info
 *              gpe_block           - Gpe Block info
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Clear status bits for all GPEs within a single GPE block
 *
 ******************************************************************************/

acpi_status
acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
			struct acpi_gpe_block_info *gpe_block, void *context)
{
	u32 i;
	acpi_status status;

	/* Examine each GPE Register within the block */

	for (i = 0; i < gpe_block->register_count; i++) {

		/* Clear status on all GPEs in this register */

		status =
		    acpi_hw_write(0xFF,
				  &gpe_block->register_info[i].status_address);
		if (ACPI_FAILURE(status)) {
			return (status);
		}
	}

	return (AE_OK);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_enable_runtime_gpe_block
 *
 * PARAMETERS:  gpe_xrupt_info      - GPE Interrupt info
 *              gpe_block           - Gpe Block info
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
 *              combination wake/run GPEs.
 *
 ******************************************************************************/

acpi_status
acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
				 struct acpi_gpe_block_info *gpe_block, void *context)
{
	u32 i;
	acpi_status status;

	/* NOTE: assumes that all GPEs are currently disabled */

	/* Examine each GPE Register within the block */

	for (i = 0; i < gpe_block->register_count; i++) {
		if (!gpe_block->register_info[i].enable_for_run) {
			continue;
		}

		/* Enable all "runtime" GPEs in this register */

		status =
		    acpi_hw_write(gpe_block->register_info[i].enable_for_run,
				  &gpe_block->register_info[i].enable_address);
		if (ACPI_FAILURE(status)) {
			return (status);
		}
	}

	return (AE_OK);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_enable_wakeup_gpe_block
 *
 * PARAMETERS:  gpe_xrupt_info      - GPE Interrupt info
 *              gpe_block           - Gpe Block info
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
 *              combination wake/run GPEs.
 *
 ******************************************************************************/

static acpi_status
acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
				struct acpi_gpe_block_info *gpe_block,
				void *context)
{
	u32 i;
	acpi_status status;

	/* Examine each GPE Register within the block */

	for (i = 0; i < gpe_block->register_count; i++) {
		if (!gpe_block->register_info[i].enable_for_wake) {
			continue;
		}

		/* Enable all "wake" GPEs in this register */

		status =
		    acpi_hw_write(gpe_block->register_info[i].enable_for_wake,
				  &gpe_block->register_info[i].enable_address);
		if (ACPI_FAILURE(status)) {
			return (status);
		}
	}

	return (AE_OK);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_disable_all_gpes
 *
 * PARAMETERS:  None
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Disable and clear all GPEs in all GPE blocks
 *
 ******************************************************************************/

acpi_status acpi_hw_disable_all_gpes(void)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(hw_disable_all_gpes);

	status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
	status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
	return_ACPI_STATUS(status);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_enable_all_runtime_gpes
 *
 * PARAMETERS:  None
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
 *
 ******************************************************************************/

acpi_status acpi_hw_enable_all_runtime_gpes(void)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(hw_enable_all_runtime_gpes);

	status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block, NULL);
	return_ACPI_STATUS(status);
}

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_enable_all_wakeup_gpes
 *
 * PARAMETERS:  None
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
 *
 ******************************************************************************/

acpi_status acpi_hw_enable_all_wakeup_gpes(void)
{
	acpi_status status;

	ACPI_FUNCTION_TRACE(hw_enable_all_wakeup_gpes);

	status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block, NULL);
	return_ACPI_STATUS(status);
}

#endif				/* !ACPI_REDUCED_HARDWARE */
Commit	Line	Data
1da177e4 LT	1
	2	/******************************************************************************
	3	*
	4	* Module Name: hwgpe - Low level GPE enable/disable/clear functions
	5	*
	6	*****************************************************************************/
	7
	8	/*
77848130	9	* Copyright (C) 2000 - 2012, 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
	45	#include <acpi/acpi.h>
e2f7a777 LB	46	#include "accommon.h"
e2f7a777 LB	47	#include "acevents.h"
1da177e4 LT	48
1da177e4 LT	49	#define _COMPONENT ACPI_HARDWARE
4be44fcd	50	ACPI_MODULE_NAME("hwgpe")
33620c54	51	#if (!ACPI_REDUCED_HARDWARE) /* Entire module */
44f6c012	52	/* Local prototypes */
44f6c012	53	static acpi_status
4be44fcd	54	acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
e97d6bf1 BM	55	struct acpi_gpe_block_info *gpe_block,
e97d6bf1 BM	56	void *context);
1da177e4	57
e4e9a735 RW	58	/******************************************************************************
e4e9a735 RW	59	*
b76df673	60	* FUNCTION: acpi_hw_get_gpe_register_bit
e4e9a735 RW	61	*
e4e9a735 RW	62	* PARAMETERS: gpe_event_info - Info block for the GPE
e4e9a735	63	*
da503373	64	* RETURN: Register mask with a one in the GPE bit position
e4e9a735	65	*
da503373 LM	66	* DESCRIPTION: Compute the register mask for this GPE. One bit is set in the
da503373 LM	67	* correct position for the input GPE.
e4e9a735 RW	68	*
	69	******************************************************************************/
	70
1d94e1e8	71	u32 acpi_hw_get_gpe_register_bit(struct acpi_gpe_event_info *gpe_event_info)
e4e9a735 RW	72	{
e4e9a735 RW	73	return (u32)1 << (gpe_event_info->gpe_number -
1d94e1e8	74	gpe_event_info->register_info->base_gpe_number);
e4e9a735 RW	75	}
e4e9a735 RW	76
e38e8a07 BM	77	/******************************************************************************
e38e8a07 BM	78	*
fd247447	79	* FUNCTION: acpi_hw_low_set_gpe
e38e8a07 BM	80	*
e38e8a07 BM	81	* PARAMETERS: gpe_event_info - Info block for the GPE to be disabled
fd247447	82	* action - Enable or disable
e38e8a07 BM	83	*
	84	* RETURN: Status
	85	*
da503373	86	* DESCRIPTION: Enable or disable a single GPE in the parent enable register.
e38e8a07 BM	87	*
	88	******************************************************************************/
	89
fd247447	90	acpi_status
da503373	91	acpi_hw_low_set_gpe(struct acpi_gpe_event_info *gpe_event_info, u32 action)
e38e8a07 BM	92	{
	93	struct acpi_gpe_register_info *gpe_register_info;
	94	acpi_status status;
	95	u32 enable_mask;
e4e9a735	96	u32 register_bit;
e38e8a07	97
fd247447 RW	98	ACPI_FUNCTION_ENTRY();
fd247447 RW	99
e38e8a07 BM	100	/* Get the info block for the entire GPE register */
	101
	102	gpe_register_info = gpe_event_info->register_info;
	103	if (!gpe_register_info) {
	104	return (AE_NOT_EXIST);
	105	}
	106
	107	/* Get current value of the enable register that contains this GPE */
	108
c6b5774c	109	status = acpi_hw_read(&enable_mask, &gpe_register_info->enable_address);
e38e8a07 BM	110	if (ACPI_FAILURE(status)) {
	111	return (status);
	112	}
	113
da503373	114	/* Set or clear just the bit that corresponds to this GPE */
e38e8a07	115
1d94e1e8	116	register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
fd247447	117	switch (action) {
3a37898d	118	case ACPI_GPE_CONDITIONAL_ENABLE:
da503373 LM	119
	120	/* Only enable if the enable_for_run bit is set */
	121
	122	if (!(register_bit & gpe_register_info->enable_for_run)) {
c9a8bbb7	123	return (AE_BAD_PARAMETER);
da503373 LM	124	}
	125
	126	/lint -fallthrough /
c9a8bbb7	127
fd247447 RW	128	case ACPI_GPE_ENABLE:
	129	ACPI_SET_BIT(enable_mask, register_bit);
	130	break;
	131
	132	case ACPI_GPE_DISABLE:
	133	ACPI_CLEAR_BIT(enable_mask, register_bit);
	134	break;
	135
	136	default:
da503373	137	ACPI_ERROR((AE_INFO, "Invalid GPE Action, %u\n", action));
fd247447 RW	138	return (AE_BAD_PARAMETER);
fd247447 RW	139	}
e38e8a07 BM	140
	141	/* Write the updated enable mask */
	142
c6b5774c	143	status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address);
e38e8a07 BM	144	return (status);
	145	}
	146
1da177e4 LT	147	/******************************************************************************
	148	*
	149	* FUNCTION: acpi_hw_clear_gpe
	150	*
	151	* PARAMETERS: gpe_event_info - Info block for the GPE to be cleared
	152	*
	153	* RETURN: Status
	154	*
	155	* DESCRIPTION: Clear the status bit for a single GPE.
	156	*
	157	******************************************************************************/
	158
4be44fcd	159	acpi_status acpi_hw_clear_gpe(struct acpi_gpe_event_info * gpe_event_info)
1da177e4	160	{
e4e9a735	161	struct acpi_gpe_register_info *gpe_register_info;
4be44fcd	162	acpi_status status;
e4e9a735	163	u32 register_bit;
1da177e4	164
4be44fcd	165	ACPI_FUNCTION_ENTRY();
1da177e4	166
e4e9a735 RW	167	/* Get the info block for the entire GPE register */
	168
	169	gpe_register_info = gpe_event_info->register_info;
	170	if (!gpe_register_info) {
	171	return (AE_NOT_EXIST);
	172	}
	173
1da177e4 LT	174	/*
	175	* Write a one to the appropriate bit in the status register to
	176	* clear this GPE.
	177	*/
1d94e1e8	178	register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
da503373	179
c6b5774c	180	status = acpi_hw_write(register_bit,
e4e9a735	181	&gpe_register_info->status_address);
1da177e4 LT	182
	183	return (status);
	184	}
	185
1da177e4 LT	186	/******************************************************************************
	187	*
	188	* FUNCTION: acpi_hw_get_gpe_status
	189	*
	190	* PARAMETERS: gpe_event_info - Info block for the GPE to queried
	191	* event_status - Where the GPE status is returned
	192	*
	193	* RETURN: Status
	194	*
	195	* DESCRIPTION: Return the status of a single GPE.
	196	*
	197	******************************************************************************/
44f6c012	198
1da177e4	199	acpi_status
4be44fcd LB	200	acpi_hw_get_gpe_status(struct acpi_gpe_event_info * gpe_event_info,
4be44fcd LB	201	acpi_event_status * event_status)
1da177e4	202	{
4be44fcd	203	u32 in_byte;
e4e9a735	204	u32 register_bit;
4be44fcd	205	struct acpi_gpe_register_info *gpe_register_info;
4be44fcd	206	acpi_event_status local_event_status = 0;
da503373	207	acpi_status status;
1da177e4	208
4be44fcd	209	ACPI_FUNCTION_ENTRY();
1da177e4 LT	210
	211	if (!event_status) {
	212	return (AE_BAD_PARAMETER);
	213	}
	214
	215	/* Get the info block for the entire GPE register */
	216
	217	gpe_register_info = gpe_event_info->register_info;
	218
	219	/* Get the register bitmask for this GPE */
	220
1d94e1e8	221	register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
1da177e4 LT	222
	223	/* GPE currently enabled? (enabled for runtime?) */
	224
	225	if (register_bit & gpe_register_info->enable_for_run) {
	226	local_event_status \|= ACPI_EVENT_FLAG_ENABLED;
	227	}
	228
	229	/* GPE enabled for wake? */
	230
	231	if (register_bit & gpe_register_info->enable_for_wake) {
	232	local_event_status \|= ACPI_EVENT_FLAG_WAKE_ENABLED;
	233	}
	234
	235	/* GPE currently active (status bit == 1)? */
	236
c6b5774c	237	status = acpi_hw_read(&in_byte, &gpe_register_info->status_address);
4be44fcd	238	if (ACPI_FAILURE(status)) {
2147d3f0	239	return (status);
1da177e4 LT	240	}
	241
	242	if (register_bit & in_byte) {
	243	local_event_status \|= ACPI_EVENT_FLAG_SET;
	244	}
	245
	246	/* Set return value */
	247
	248	(*event_status) = local_event_status;
2147d3f0	249	return (AE_OK);
1da177e4	250	}
1da177e4 LT	251
	252	/******************************************************************************
	253	*
	254	* FUNCTION: acpi_hw_disable_gpe_block
	255	*
	256	* PARAMETERS: gpe_xrupt_info - GPE Interrupt info
	257	* gpe_block - Gpe Block info
	258	*
	259	* RETURN: Status
	260	*
44f6c012	261	* DESCRIPTION: Disable all GPEs within a single GPE block
1da177e4 LT	262	*
	263	******************************************************************************/
	264
	265	acpi_status
e97d6bf1 BM	266	acpi_hw_disable_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
e97d6bf1 BM	267	struct acpi_gpe_block_info gpe_block, void context)
1da177e4	268	{
4be44fcd LB	269	u32 i;
4be44fcd LB	270	acpi_status status;
1da177e4 LT	271
	272	/* Examine each GPE Register within the block */
	273
	274	for (i = 0; i < gpe_block->register_count; i++) {
52fc0b02	275
1da177e4 LT	276	/* Disable all GPEs in this register */
1da177e4 LT	277
ecfbbc7b	278	status =
c6b5774c BM	279	acpi_hw_write(0x00,
c6b5774c BM	280	&gpe_block->register_info[i].enable_address);
4be44fcd	281	if (ACPI_FAILURE(status)) {
1da177e4 LT	282	return (status);
	283	}
	284	}
	285
	286	return (AE_OK);
	287	}
	288
1da177e4 LT	289	/******************************************************************************
	290	*
	291	* FUNCTION: acpi_hw_clear_gpe_block
	292	*
	293	* PARAMETERS: gpe_xrupt_info - GPE Interrupt info
	294	* gpe_block - Gpe Block info
	295	*
	296	* RETURN: Status
	297	*
44f6c012	298	* DESCRIPTION: Clear status bits for all GPEs within a single GPE block
1da177e4 LT	299	*
	300	******************************************************************************/
	301
	302	acpi_status
e97d6bf1 BM	303	acpi_hw_clear_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
e97d6bf1 BM	304	struct acpi_gpe_block_info gpe_block, void context)
1da177e4	305	{
4be44fcd LB	306	u32 i;
4be44fcd LB	307	acpi_status status;
1da177e4 LT	308
	309	/* Examine each GPE Register within the block */
	310
	311	for (i = 0; i < gpe_block->register_count; i++) {
52fc0b02	312
1da177e4 LT	313	/* Clear status on all GPEs in this register */
1da177e4 LT	314
ecfbbc7b	315	status =
c6b5774c BM	316	acpi_hw_write(0xFF,
c6b5774c BM	317	&gpe_block->register_info[i].status_address);
4be44fcd	318	if (ACPI_FAILURE(status)) {
1da177e4 LT	319	return (status);
	320	}
	321	}
	322
	323	return (AE_OK);
	324	}
	325
1da177e4 LT	326	/******************************************************************************
	327	*
	328	* FUNCTION: acpi_hw_enable_runtime_gpe_block
	329	*
	330	* PARAMETERS: gpe_xrupt_info - GPE Interrupt info
	331	* gpe_block - Gpe Block info
	332	*
	333	* RETURN: Status
	334	*
44f6c012 RM	335	* DESCRIPTION: Enable all "runtime" GPEs within a single GPE block. Includes
44f6c012 RM	336	* combination wake/run GPEs.
1da177e4 LT	337	*
	338	******************************************************************************/
	339
	340	acpi_status
e97d6bf1 BM	341	acpi_hw_enable_runtime_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
e97d6bf1 BM	342	struct acpi_gpe_block_info gpe_block, void context)
1da177e4	343	{
4be44fcd LB	344	u32 i;
4be44fcd LB	345	acpi_status status;
1da177e4 LT	346
	347	/* NOTE: assumes that all GPEs are currently disabled */
	348
	349	/* Examine each GPE Register within the block */
	350
	351	for (i = 0; i < gpe_block->register_count; i++) {
	352	if (!gpe_block->register_info[i].enable_for_run) {
	353	continue;
	354	}
	355
	356	/* Enable all "runtime" GPEs in this register */
	357
c6b5774c BM	358	status =
	359	acpi_hw_write(gpe_block->register_info[i].enable_for_run,
	360	&gpe_block->register_info[i].enable_address);
4be44fcd	361	if (ACPI_FAILURE(status)) {
1da177e4 LT	362	return (status);
	363	}
	364	}
	365
	366	return (AE_OK);
	367	}
	368
1da177e4 LT	369	/******************************************************************************
	370	*
	371	* FUNCTION: acpi_hw_enable_wakeup_gpe_block
	372	*
	373	* PARAMETERS: gpe_xrupt_info - GPE Interrupt info
	374	* gpe_block - Gpe Block info
	375	*
	376	* RETURN: Status
	377	*
44f6c012 RM	378	* DESCRIPTION: Enable all "wake" GPEs within a single GPE block. Includes
44f6c012 RM	379	* combination wake/run GPEs.
1da177e4 LT	380	*
	381	******************************************************************************/
	382
44f6c012	383	static acpi_status
4be44fcd	384	acpi_hw_enable_wakeup_gpe_block(struct acpi_gpe_xrupt_info *gpe_xrupt_info,
e97d6bf1 BM	385	struct acpi_gpe_block_info *gpe_block,
e97d6bf1 BM	386	void *context)
1da177e4	387	{
4be44fcd LB	388	u32 i;
4be44fcd LB	389	acpi_status status;
1da177e4 LT	390
	391	/* Examine each GPE Register within the block */
	392
	393	for (i = 0; i < gpe_block->register_count; i++) {
	394	if (!gpe_block->register_info[i].enable_for_wake) {
	395	continue;
	396	}
	397
	398	/* Enable all "wake" GPEs in this register */
	399
c6b5774c BM	400	status =
	401	acpi_hw_write(gpe_block->register_info[i].enable_for_wake,
	402	&gpe_block->register_info[i].enable_address);
4be44fcd	403	if (ACPI_FAILURE(status)) {
1da177e4 LT	404	return (status);
	405	}
	406	}
	407
	408	return (AE_OK);
	409	}
	410
1da177e4 LT	411	/******************************************************************************
	412	*
	413	* FUNCTION: acpi_hw_disable_all_gpes
	414	*
73459f73	415	* PARAMETERS: None
1da177e4 LT	416	*
	417	* RETURN: Status
	418	*
44f6c012	419	* DESCRIPTION: Disable and clear all GPEs in all GPE blocks
1da177e4 LT	420	*
	421	******************************************************************************/
	422
4be44fcd	423	acpi_status acpi_hw_disable_all_gpes(void)
1da177e4	424	{
4be44fcd	425	acpi_status status;
1da177e4	426
b229cf92	427	ACPI_FUNCTION_TRACE(hw_disable_all_gpes);
1da177e4	428
e97d6bf1 BM	429	status = acpi_ev_walk_gpe_list(acpi_hw_disable_gpe_block, NULL);
e97d6bf1 BM	430	status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block, NULL);
4be44fcd	431	return_ACPI_STATUS(status);
1da177e4 LT	432	}
1da177e4 LT	433
1da177e4 LT	434	/******************************************************************************
	435	*
	436	* FUNCTION: acpi_hw_enable_all_runtime_gpes
	437	*
73459f73	438	* PARAMETERS: None
1da177e4 LT	439	*
	440	* RETURN: Status
	441	*
44f6c012	442	* DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
1da177e4 LT	443	*
	444	******************************************************************************/
	445
4be44fcd	446	acpi_status acpi_hw_enable_all_runtime_gpes(void)
1da177e4	447	{
4be44fcd	448	acpi_status status;
1da177e4	449
b229cf92	450	ACPI_FUNCTION_TRACE(hw_enable_all_runtime_gpes);
1da177e4	451
e97d6bf1	452	status = acpi_ev_walk_gpe_list(acpi_hw_enable_runtime_gpe_block, NULL);
4be44fcd	453	return_ACPI_STATUS(status);
1da177e4 LT	454	}
1da177e4 LT	455
1da177e4 LT	456	/******************************************************************************
	457	*
	458	* FUNCTION: acpi_hw_enable_all_wakeup_gpes
	459	*
73459f73	460	* PARAMETERS: None
1da177e4 LT	461	*
	462	* RETURN: Status
	463	*
44f6c012	464	* DESCRIPTION: Enable all "wakeup" GPEs, in all GPE blocks
1da177e4 LT	465	*
	466	******************************************************************************/
	467
4be44fcd	468	acpi_status acpi_hw_enable_all_wakeup_gpes(void)
1da177e4	469	{
4be44fcd	470	acpi_status status;
1da177e4	471
b229cf92	472	ACPI_FUNCTION_TRACE(hw_enable_all_wakeup_gpes);
1da177e4	473
e97d6bf1	474	status = acpi_ev_walk_gpe_list(acpi_hw_enable_wakeup_gpe_block, NULL);
4be44fcd	475	return_ACPI_STATUS(status);
1da177e4	476	}
33620c54 BM	477
33620c54 BM	478	#endif /* !ACPI_REDUCED_HARDWARE */