mirror of
https://github.com/torvalds/linux.git
synced 2024-12-25 04:11:49 +00:00
18996f2db9
Unconditionally clearing ACPI IRQs during suspend/resume can lead to unexpected IRQ losts. This patch fixes this issue by removing such IRQ clearing code. If this patch triggers regression, the regression should be in the GPE handlers that cannot correctly determine some spurious triggered events as no-ops. Please report any regression related to this commit to the ACPI component on kernel bugzilla. Lv Zheng. Link: https://bugzilla.kernel.org/show_bug.cgi?id=196249 Signed-off-by: Lv Zheng <lv.zheng@intel.com> Reported-and-tested-by: Eric Bakula-Davis <ericbakuladavis@gmail.com> Tested-by: Mika Westerberg <mika.westerberg@linux.intel.com> Signed-off-by: Erik Schmauss <erik.schmauss@intel.com> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
548 lines
15 KiB
C
548 lines
15 KiB
C
/******************************************************************************
|
|
*
|
|
* Module Name: hwgpe - Low level GPE enable/disable/clear functions
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* Copyright (C) 2000 - 2018, 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);
|
|
|
|
static acpi_status
|
|
acpi_hw_gpe_enable_write(u8 enable_mask,
|
|
struct acpi_gpe_register_info *gpe_register_info);
|
|
|
|
/******************************************************************************
|
|
*
|
|
* 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.
|
|
* The enable_mask field of the involved GPE register must be
|
|
* updated by the caller if necessary.
|
|
*
|
|
******************************************************************************/
|
|
|
|
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 = AE_OK;
|
|
u64 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 corresponding enable_mask bit is set */
|
|
|
|
if (!(register_bit & gpe_register_info->enable_mask)) {
|
|
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", action));
|
|
return (AE_BAD_PARAMETER);
|
|
}
|
|
|
|
if (!(register_bit & gpe_register_info->mask_for_run)) {
|
|
|
|
/* 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)
|
|
{
|
|
u64 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);
|
|
}
|
|
|
|
/* GPE currently handled? */
|
|
|
|
if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) !=
|
|
ACPI_GPE_DISPATCH_NONE) {
|
|
local_event_status |= ACPI_EVENT_FLAG_HAS_HANDLER;
|
|
}
|
|
|
|
/* 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 currently masked? (masked for runtime?) */
|
|
|
|
if (register_bit & gpe_register_info->mask_for_run) {
|
|
local_event_status |= ACPI_EVENT_FLAG_MASKED;
|
|
}
|
|
|
|
/* GPE enabled for wake? */
|
|
|
|
if (register_bit & gpe_register_info->enable_for_wake) {
|
|
local_event_status |= ACPI_EVENT_FLAG_WAKE_ENABLED;
|
|
}
|
|
|
|
/* GPE currently enabled (enable bit == 1)? */
|
|
|
|
status = acpi_hw_read(&in_byte, &gpe_register_info->enable_address);
|
|
if (ACPI_FAILURE(status)) {
|
|
return (status);
|
|
}
|
|
|
|
if (register_bit & in_byte) {
|
|
local_event_status |= ACPI_EVENT_FLAG_ENABLE_SET;
|
|
}
|
|
|
|
/* 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_STATUS_SET;
|
|
}
|
|
|
|
/* Set return value */
|
|
|
|
(*event_status) = local_event_status;
|
|
return (AE_OK);
|
|
}
|
|
|
|
/******************************************************************************
|
|
*
|
|
* FUNCTION: acpi_hw_gpe_enable_write
|
|
*
|
|
* PARAMETERS: enable_mask - Bit mask to write to the GPE register
|
|
* gpe_register_info - Gpe Register info
|
|
*
|
|
* RETURN: Status
|
|
*
|
|
* DESCRIPTION: Write the enable mask byte to the given GPE register.
|
|
*
|
|
******************************************************************************/
|
|
|
|
static acpi_status
|
|
acpi_hw_gpe_enable_write(u8 enable_mask,
|
|
struct acpi_gpe_register_info *gpe_register_info)
|
|
{
|
|
acpi_status status;
|
|
|
|
gpe_register_info->enable_mask = enable_mask;
|
|
|
|
status = acpi_hw_write(enable_mask, &gpe_register_info->enable_address);
|
|
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_gpe_enable_write(0x00,
|
|
&gpe_block->register_info[i]);
|
|
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;
|
|
struct acpi_gpe_register_info *gpe_register_info;
|
|
u8 enable_mask;
|
|
|
|
/* NOTE: assumes that all GPEs are currently disabled */
|
|
|
|
/* Examine each GPE Register within the block */
|
|
|
|
for (i = 0; i < gpe_block->register_count; i++) {
|
|
gpe_register_info = &gpe_block->register_info[i];
|
|
if (!gpe_register_info->enable_for_run) {
|
|
continue;
|
|
}
|
|
|
|
/* Enable all "runtime" GPEs in this register */
|
|
|
|
enable_mask = gpe_register_info->enable_for_run &
|
|
~gpe_register_info->mask_for_run;
|
|
status =
|
|
acpi_hw_gpe_enable_write(enable_mask, gpe_register_info);
|
|
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;
|
|
struct acpi_gpe_register_info *gpe_register_info;
|
|
|
|
/* Examine each GPE Register within the block */
|
|
|
|
for (i = 0; i < gpe_block->register_count; i++) {
|
|
gpe_register_info = &gpe_block->register_info[i];
|
|
|
|
/*
|
|
* Enable all "wake" GPEs in this register and disable the
|
|
* remaining ones.
|
|
*/
|
|
|
|
status =
|
|
acpi_hw_gpe_enable_write(gpe_register_info->enable_for_wake,
|
|
gpe_register_info);
|
|
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);
|
|
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 */
|