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


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

/*
 * Copyright (C) 2000 - 2008, 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")

/* 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_low_disable_gpe
 *
 * PARAMETERS:	gpe_event_info	    - Info block for the GPE to be disabled
 *
 * RETURN:	Status
 *
 * DESCRIPTION: Disable a single GPE in the enable register.
 *
 ******************************************************************************/

acpi_status acpi_hw_low_disable_gpe(struct acpi_gpe_event_info *gpe_event_info)
{
	struct acpi_gpe_register_info *gpe_register_info;
	acpi_status status;
	u32 enable_mask;

	/* 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);
	}

	/* Clear just the bit that corresponds to this GPE */

	ACPI_CLEAR_BIT(enable_mask, ((u32)1 <<
				     (gpe_event_info->gpe_number -
				      gpe_register_info->base_gpe_number)));

	/* Write the updated enable mask */

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

/******************************************************************************
 *
 * FUNCTION:    acpi_hw_write_gpe_enable_reg
 *
 * PARAMETERS:  gpe_event_info      - Info block for the GPE to be enabled
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Write a GPE enable register.  Note: The bit for this GPE must
 *              already be cleared or set in the parent register
 *              enable_for_run mask.
 *
 ******************************************************************************/

acpi_status
acpi_hw_write_gpe_enable_reg(struct acpi_gpe_event_info * gpe_event_info)
{
	struct acpi_gpe_register_info *gpe_register_info;
	acpi_status status;

	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 the entire GPE (runtime) enable register */

	status = acpi_hw_write(gpe_register_info->enable_for_run,
			       &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)
{
	acpi_status status;
	u8 register_bit;

	ACPI_FUNCTION_ENTRY();

	register_bit = (u8)(1 <<
			    (gpe_event_info->gpe_number -
			     gpe_event_info->register_info->base_gpe_number));

	/*
	 * Write a one to the appropriate bit in the status register to
	 * clear this GPE.
	 */
	status = acpi_hw_write(register_bit,
			       &gpe_event_info->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;
	u8 register_bit;
	struct acpi_gpe_register_info *gpe_register_info;
	acpi_status status;
	acpi_event_status local_event_status = 0;

	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 = (u8)(1 <<
			    (gpe_event_info->gpe_number -
			     gpe_event_info->register_info->base_gpe_number));

	/* 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)) {
		goto unlock_and_exit;
	}

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

	/* Set return value */

	(*event_status) = local_event_status;

      unlock_and_exit:
	return (status);
}

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