2018-03-15 07:13:07 +08:00
|
|
|
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
|
2010-12-13 13:36:02 +08:00
|
|
|
/******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* Module Name: evxfgpe - External Interfaces for General Purpose Events (GPEs)
|
|
|
|
|
*
|
2019-01-15 01:55:25 +08:00
|
|
|
* Copyright (C) 2000 - 2019, Intel Corp.
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
2018-03-15 07:13:07 +08:00
|
|
|
*****************************************************************************/
|
2010-12-13 13:36:02 +08:00
|
|
|
|
2013-10-29 09:29:51 +08:00
|
|
|
#define EXPORT_ACPI_INTERFACES
|
|
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
#include <acpi/acpi.h>
|
|
|
|
|
#include "accommon.h"
|
|
|
|
|
#include "acevents.h"
|
|
|
|
|
#include "acnamesp.h"
|
|
|
|
|
|
|
|
|
|
#define _COMPONENT ACPI_EVENTS
|
|
|
|
|
ACPI_MODULE_NAME("evxfgpe")
|
|
|
|
|
|
2012-02-14 18:14:27 +08:00
|
|
|
#if (!ACPI_REDUCED_HARDWARE) /* Entire module */
|
2012-12-19 13:36:49 +08:00
|
|
|
/*******************************************************************************
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
2010-12-13 13:36:15 +08:00
|
|
|
* FUNCTION: acpi_update_all_gpes
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
|
|
|
|
* PARAMETERS: None
|
|
|
|
|
*
|
2010-12-13 13:39:37 +08:00
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Complete GPE initialization and enable all GPEs that have
|
|
|
|
|
* associated _Lxx or _Exx methods and are not pointed to by any
|
|
|
|
|
* device _PRW methods (this indicates that these GPEs are
|
|
|
|
|
* generally intended for system or device wakeup. Such GPEs
|
|
|
|
|
* have to be enabled directly when the devices whose _PRW
|
|
|
|
|
* methods point to them are set up for wakeup signaling.)
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
2010-12-13 13:39:37 +08:00
|
|
|
* NOTE: Should be called after any GPEs are added to the system. Primarily,
|
|
|
|
|
* after the system _PRW methods have been run, but also after a GPE Block
|
|
|
|
|
* Device has been added or if any new GPE methods have been added via a
|
|
|
|
|
* dynamic table load.
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
2010-12-13 13:36:15 +08:00
|
|
|
acpi_status acpi_update_all_gpes(void)
|
2010-12-13 13:36:02 +08:00
|
|
|
{
|
|
|
|
|
acpi_status status;
|
2018-03-15 07:12:59 +08:00
|
|
|
u8 is_polling_needed = FALSE;
|
2010-12-13 13:36:02 +08:00
|
|
|
|
2010-12-13 13:36:15 +08:00
|
|
|
ACPI_FUNCTION_TRACE(acpi_update_all_gpes);
|
2010-12-13 13:36:02 +08:00
|
|
|
|
|
|
|
|
status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
|
return_ACPI_STATUS(status);
|
2010-12-13 13:36:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (acpi_gbl_all_gpes_initialized) {
|
|
|
|
|
goto unlock_and_exit;
|
2010-12-13 13:36:02 +08:00
|
|
|
}
|
|
|
|
|
|
2018-03-15 07:12:59 +08:00
|
|
|
status = acpi_ev_walk_gpe_list(acpi_ev_initialize_gpe_block,
|
|
|
|
|
&is_polling_needed);
|
2010-12-13 13:36:02 +08:00
|
|
|
if (ACPI_SUCCESS(status)) {
|
2010-12-13 13:36:15 +08:00
|
|
|
acpi_gbl_all_gpes_initialized = TRUE;
|
2010-12-13 13:36:02 +08:00
|
|
|
}
|
|
|
|
|
|
2010-12-13 13:36:15 +08:00
|
|
|
unlock_and_exit:
|
2010-12-13 13:36:02 +08:00
|
|
|
(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
|
|
|
|
|
|
2018-03-15 07:12:59 +08:00
|
|
|
if (is_polling_needed && acpi_gbl_all_gpes_initialized) {
|
|
|
|
|
|
|
|
|
|
/* Poll GPEs to handle already triggered events */
|
|
|
|
|
|
|
|
|
|
acpi_ev_gpe_detect(acpi_gbl_gpe_xrupt_list_head);
|
|
|
|
|
}
|
2010-12-13 13:36:02 +08:00
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-13 13:36:15 +08:00
|
|
|
ACPI_EXPORT_SYMBOL(acpi_update_all_gpes)
|
|
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_enable_gpe
|
|
|
|
|
*
|
2014-10-10 10:39:39 +08:00
|
|
|
* PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
|
|
|
|
|
* gpe_number - GPE level within the GPE block
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Add a reference to a GPE. On the first reference, the GPE is
|
|
|
|
|
* hardware-enabled.
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
|
|
|
|
|
{
|
|
|
|
|
acpi_status status = AE_BAD_PARAMETER;
|
|
|
|
|
struct acpi_gpe_event_info *gpe_event_info;
|
|
|
|
|
acpi_cpu_flags flags;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_enable_gpe);
|
|
|
|
|
|
|
|
|
|
flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
|
|
|
|
|
|
2014-07-23 13:11:59 +08:00
|
|
|
/*
|
|
|
|
|
* Ensure that we have a valid GPE number and that there is some way
|
|
|
|
|
* of handling the GPE (handler or a GPE method). In other words, we
|
|
|
|
|
* won't allow a valid GPE to be enabled if there is no way to handle it.
|
|
|
|
|
*/
|
2010-12-13 13:36:02 +08:00
|
|
|
gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
|
|
|
|
|
if (gpe_event_info) {
|
2015-02-05 15:20:29 +08:00
|
|
|
if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) !=
|
2014-07-23 13:11:59 +08:00
|
|
|
ACPI_GPE_DISPATCH_NONE) {
|
ACPICA: Clear status of GPEs on first direct enable
ACPI GPEs (other than the EC one) can be enabled in two situations.
First, the GPEs with existing _Lxx and _Exx methods are enabled
implicitly by ACPICA during system initialization. Second, the
GPEs without these methods (like GPEs listed by _PRW objects for
wakeup devices) need to be enabled directly by the code that is
going to use them (e.g. ACPI power management or device drivers).
In the former case, if the status of a given GPE is set to start
with, its handler method (either _Lxx or _Exx) needs to be invoked
to take care of the events (possibly) signaled before the GPE was
enabled. In the latter case, however, the first caller of
acpi_enable_gpe() for a given GPE should not be expected to care
about any events that might be signaled through it earlier. In
that case, it is better to clear the status of the GPE before
enabling it, to prevent stale events from triggering unwanted
actions (like spurious system resume, for example).
For this reason, modify acpi_ev_add_gpe_reference() to take an
additional boolean argument indicating whether or not the GPE
status needs to be cleared when its reference counter changes from
zero to one and make acpi_enable_gpe() pass TRUE to it through
that new argument.
Fixes: 18996f2db918 ("ACPICA: Events: Stop unconditionally clearing ACPI IRQs during suspend/resume")
Reported-by: Furquan Shaikh <furquan@google.com>
Tested-by: Furquan Shaikh <furquan@google.com>
Tested-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2019-06-17 19:31:45 +08:00
|
|
|
status = acpi_ev_add_gpe_reference(gpe_event_info, TRUE);
|
2018-03-15 07:12:59 +08:00
|
|
|
if (ACPI_SUCCESS(status) &&
|
|
|
|
|
ACPI_GPE_IS_POLLING_NEEDED(gpe_event_info)) {
|
|
|
|
|
|
|
|
|
|
/* Poll edge-triggered GPEs to handle existing events */
|
|
|
|
|
|
|
|
|
|
acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
|
|
|
|
|
(void)acpi_ev_detect_gpe(gpe_device,
|
|
|
|
|
gpe_event_info,
|
|
|
|
|
gpe_number);
|
|
|
|
|
flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
|
|
|
|
|
}
|
2014-07-23 13:11:59 +08:00
|
|
|
} else {
|
|
|
|
|
status = AE_NO_HANDLER;
|
|
|
|
|
}
|
2010-12-13 13:36:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
|
|
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_disable_gpe
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
|
|
|
|
|
* gpe_number - GPE level within the GPE block
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Remove a reference to a GPE. When the last reference is
|
|
|
|
|
* removed, only then is the GPE disabled (for runtime GPEs), or
|
|
|
|
|
* the GPE mask bit disabled (for wake GPEs)
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
|
|
acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
|
|
|
|
|
{
|
|
|
|
|
acpi_status status = AE_BAD_PARAMETER;
|
|
|
|
|
struct acpi_gpe_event_info *gpe_event_info;
|
|
|
|
|
acpi_cpu_flags flags;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_disable_gpe);
|
|
|
|
|
|
|
|
|
|
flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
|
|
|
|
|
|
|
|
|
|
/* Ensure that we have a valid GPE number */
|
|
|
|
|
|
|
|
|
|
gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
|
|
|
|
|
if (gpe_event_info) {
|
2010-12-13 13:36:15 +08:00
|
|
|
status = acpi_ev_remove_gpe_reference(gpe_event_info) ;
|
2010-12-13 13:36:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
2012-12-19 13:37:15 +08:00
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
|
|
|
|
|
|
2015-02-05 16:27:09 +08:00
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_set_gpe
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
|
|
|
|
|
* gpe_number - GPE level within the GPE block
|
|
|
|
|
* action - ACPI_GPE_ENABLE or ACPI_GPE_DISABLE
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Enable or disable an individual GPE. This function bypasses
|
ACPICA: Events: Enable APIs to allow interrupt/polling adaptive request based GPE handling model
ACPICA commit da9a83e1a845f2d7332bdbc0632466b2595e5424
For acpi_set_gpe()/acpi_enable_gpe(), our target is to purify them to be APIs
that can be used for various GPE handling models, so we need them to be
pure GPE enabling APIs. GPE enabling/disabling has 2 use cases:
1. Driver may permanently enable/disable GPEs according to the usage
counts.
1. When upper layers (the users of the driver) submit requests to the
driver, it means they care about the underlying hardware. GPE need
to be enabled for the first request submission and disabled for the
last request completion.
2. When the GPE is shared between 2+ silicon logics. GPE need to be
enabled for either silicon logic's driver and disabled when all of
the drivers are not started.
For these cases, acpi_enable_gpe()/acpi_disable_gpe() should be used. When
the usage count is increased from 0 to 1, the GPE is enabled and it is
disabled when the usage count is decrased from 1 to 0.
2. Driver may temporarily disables the GPE to enter an GPE polling mode and
wants to re-enable it later.
1. Prevent GPE storming: when a driver cannot fully solve the condition
that triggered the GPE in the GPE context, in order not to trigger
GPE storm, driver has to disable GPE to switch into the polling mode
and re-enables it in the non interrupt context after the storming
condition is cleared.
2. Meet throughput requirement: some IO drivers need to poll hardware
again and again until nothing indicated instead of just handling once
for one interruption, this need to be done in the polling mode or the
IO flood may prevent the GPE handler from returning.
3. Meet realtime requirement: in order not to block CPU to handle higher
realtime prioritized GPEs, lower priority GPEs can be handled in the
polling mode.
For these cases, acpi_set_gpe() should be used to switch to/from the
polling mode.
This patch adds unconditional GPE enabling support into acpi_set_gpe() so
that this API can be used by the drivers to switch back from the GPE
polling mode unconditionally.
Originally this function includes GPE clearing logic in it.
First, the GPE clearing is typically used in the GPE handling code to:
1. Acknowledge the GPE when we know there is an edge triggered GPE raised
and is about to handle it, otherwise the unexpected clearing may lead to
a GPE loss;
2. Issue actions after we have handled a level triggered GPE, otherwise
the unexpected clearing may trigger unwanted OSPM actions to the
hardware (for example, clocking in out-dated write FIFO data).
Thus the GPE clearing is not suitable to be used in the GPE enabling APIs.
Second, the combination of acknowledging and enabling may also not be
expected by the hardware drivers. For GPE clearing, we have a seperate API
acpi_clear_gpe(). There are cases drivers do want the 2 operations to be
split. So splitting these 2 operations could facilitates drivers the
maximum possibilities to achieve success. For a combined one, we already
have acpi_finish_gpe() ready to be invoked.
Given the fact that drivers should complete all outstanding requests before
putting themselves into the sleep states, as this API is executed for
outstanding requests, it should also have nothing to do with the
"RUN"/"WAKE" distinguishing. That's why the acpi_set_gpe(ACPI_GPE_ENABLE)
should not be implemented by acpi_hw_low_set_gpe(ACPI_GPE_CONDITIONAL_ENABLE).
This patch thus converts acpi_set_gpe(ACPI_GPE_ENABLE) into
acpi_hw_low_set_gpe(ACPI_GPE_ENABLE) to achieve a seperate GPE enabling API.
Drivers then are encouraged to use this API when they need to switch
to/from the GPE polling mode.
Note that the acpi_set_gpe()/acpi_finish_gpe() should be first introduced to
Linux using a divergence reduction patch before sending a linuxized version
of this patch. Lv Zheng.
Link: https://github.com/acpica/acpica/commit/da9a83e1
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: David E. Box <david.e.box@linux.intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2015-02-05 16:27:15 +08:00
|
|
|
* the reference count mechanism used in the acpi_enable_gpe(),
|
|
|
|
|
* acpi_disable_gpe() interfaces.
|
|
|
|
|
* This API is typically used by the GPE raw handler mode driver
|
|
|
|
|
* to switch between the polling mode and the interrupt mode after
|
|
|
|
|
* the driver has enabled the GPE.
|
|
|
|
|
* The APIs should be invoked in this order:
|
|
|
|
|
* acpi_enable_gpe() <- Ensure the reference count > 0
|
|
|
|
|
* acpi_set_gpe(ACPI_GPE_DISABLE) <- Enter polling mode
|
|
|
|
|
* acpi_set_gpe(ACPI_GPE_ENABLE) <- Leave polling mode
|
|
|
|
|
* acpi_disable_gpe() <- Decrease the reference count
|
|
|
|
|
*
|
|
|
|
|
* Note: If a GPE is shared by 2 silicon components, then both the drivers
|
|
|
|
|
* should support GPE polling mode or disabling the GPE for long period
|
|
|
|
|
* for one driver may break the other. So use it with care since all
|
|
|
|
|
* firmware _Lxx/_Exx handlers currently rely on the GPE interrupt mode.
|
2015-02-05 16:27:09 +08:00
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
acpi_status acpi_set_gpe(acpi_handle gpe_device, u32 gpe_number, u8 action)
|
|
|
|
|
{
|
|
|
|
|
struct acpi_gpe_event_info *gpe_event_info;
|
|
|
|
|
acpi_status status;
|
|
|
|
|
acpi_cpu_flags flags;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_set_gpe);
|
|
|
|
|
|
|
|
|
|
flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
|
|
|
|
|
|
|
|
|
|
/* Ensure that we have a valid GPE number */
|
|
|
|
|
|
|
|
|
|
gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
|
|
|
|
|
if (!gpe_event_info) {
|
|
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Perform the action */
|
|
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
|
case ACPI_GPE_ENABLE:
|
|
|
|
|
|
ACPICA: Events: Enable APIs to allow interrupt/polling adaptive request based GPE handling model
ACPICA commit da9a83e1a845f2d7332bdbc0632466b2595e5424
For acpi_set_gpe()/acpi_enable_gpe(), our target is to purify them to be APIs
that can be used for various GPE handling models, so we need them to be
pure GPE enabling APIs. GPE enabling/disabling has 2 use cases:
1. Driver may permanently enable/disable GPEs according to the usage
counts.
1. When upper layers (the users of the driver) submit requests to the
driver, it means they care about the underlying hardware. GPE need
to be enabled for the first request submission and disabled for the
last request completion.
2. When the GPE is shared between 2+ silicon logics. GPE need to be
enabled for either silicon logic's driver and disabled when all of
the drivers are not started.
For these cases, acpi_enable_gpe()/acpi_disable_gpe() should be used. When
the usage count is increased from 0 to 1, the GPE is enabled and it is
disabled when the usage count is decrased from 1 to 0.
2. Driver may temporarily disables the GPE to enter an GPE polling mode and
wants to re-enable it later.
1. Prevent GPE storming: when a driver cannot fully solve the condition
that triggered the GPE in the GPE context, in order not to trigger
GPE storm, driver has to disable GPE to switch into the polling mode
and re-enables it in the non interrupt context after the storming
condition is cleared.
2. Meet throughput requirement: some IO drivers need to poll hardware
again and again until nothing indicated instead of just handling once
for one interruption, this need to be done in the polling mode or the
IO flood may prevent the GPE handler from returning.
3. Meet realtime requirement: in order not to block CPU to handle higher
realtime prioritized GPEs, lower priority GPEs can be handled in the
polling mode.
For these cases, acpi_set_gpe() should be used to switch to/from the
polling mode.
This patch adds unconditional GPE enabling support into acpi_set_gpe() so
that this API can be used by the drivers to switch back from the GPE
polling mode unconditionally.
Originally this function includes GPE clearing logic in it.
First, the GPE clearing is typically used in the GPE handling code to:
1. Acknowledge the GPE when we know there is an edge triggered GPE raised
and is about to handle it, otherwise the unexpected clearing may lead to
a GPE loss;
2. Issue actions after we have handled a level triggered GPE, otherwise
the unexpected clearing may trigger unwanted OSPM actions to the
hardware (for example, clocking in out-dated write FIFO data).
Thus the GPE clearing is not suitable to be used in the GPE enabling APIs.
Second, the combination of acknowledging and enabling may also not be
expected by the hardware drivers. For GPE clearing, we have a seperate API
acpi_clear_gpe(). There are cases drivers do want the 2 operations to be
split. So splitting these 2 operations could facilitates drivers the
maximum possibilities to achieve success. For a combined one, we already
have acpi_finish_gpe() ready to be invoked.
Given the fact that drivers should complete all outstanding requests before
putting themselves into the sleep states, as this API is executed for
outstanding requests, it should also have nothing to do with the
"RUN"/"WAKE" distinguishing. That's why the acpi_set_gpe(ACPI_GPE_ENABLE)
should not be implemented by acpi_hw_low_set_gpe(ACPI_GPE_CONDITIONAL_ENABLE).
This patch thus converts acpi_set_gpe(ACPI_GPE_ENABLE) into
acpi_hw_low_set_gpe(ACPI_GPE_ENABLE) to achieve a seperate GPE enabling API.
Drivers then are encouraged to use this API when they need to switch
to/from the GPE polling mode.
Note that the acpi_set_gpe()/acpi_finish_gpe() should be first introduced to
Linux using a divergence reduction patch before sending a linuxized version
of this patch. Lv Zheng.
Link: https://github.com/acpica/acpica/commit/da9a83e1
Signed-off-by: Lv Zheng <lv.zheng@intel.com>
Signed-off-by: David E. Box <david.e.box@linux.intel.com>
Signed-off-by: Bob Moore <robert.moore@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2015-02-05 16:27:15 +08:00
|
|
|
status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_ENABLE);
|
2016-08-04 16:43:39 +08:00
|
|
|
gpe_event_info->disable_for_dispatch = FALSE;
|
2015-02-05 16:27:09 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ACPI_GPE_DISABLE:
|
|
|
|
|
|
|
|
|
|
status = acpi_hw_low_set_gpe(gpe_event_info, ACPI_GPE_DISABLE);
|
2016-08-04 16:43:39 +08:00
|
|
|
gpe_event_info->disable_for_dispatch = TRUE;
|
2015-02-05 16:27:09 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
|
|
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unlock_and_exit:
|
|
|
|
|
acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_set_gpe)
|
2010-12-13 13:39:17 +08:00
|
|
|
|
2016-08-04 16:43:39 +08:00
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_mask_gpe
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
|
|
|
|
|
* gpe_number - GPE level within the GPE block
|
|
|
|
|
* is_masked - Whether the GPE is masked or not
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Unconditionally mask/unmask the an individual GPE, ex., to
|
|
|
|
|
* prevent a GPE flooding.
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
acpi_status acpi_mask_gpe(acpi_handle gpe_device, u32 gpe_number, u8 is_masked)
|
|
|
|
|
{
|
|
|
|
|
struct acpi_gpe_event_info *gpe_event_info;
|
|
|
|
|
acpi_status status;
|
|
|
|
|
acpi_cpu_flags flags;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_mask_gpe);
|
|
|
|
|
|
|
|
|
|
flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
|
|
|
|
|
|
|
|
|
|
/* Ensure that we have a valid GPE number */
|
|
|
|
|
|
|
|
|
|
gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
|
|
|
|
|
if (!gpe_event_info) {
|
|
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
status = acpi_ev_mask_gpe(gpe_event_info, is_masked);
|
|
|
|
|
|
|
|
|
|
unlock_and_exit:
|
|
|
|
|
acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_mask_gpe)
|
|
|
|
|
|
2014-07-23 13:12:16 +08:00
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_mark_gpe_for_wake
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
|
|
|
|
|
* gpe_number - GPE level within the GPE block
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Mark a GPE as having the ability to wake the system. Simply
|
|
|
|
|
* sets the ACPI_GPE_CAN_WAKE flag.
|
|
|
|
|
*
|
|
|
|
|
* Some potential callers of acpi_setup_gpe_for_wake may know in advance that
|
|
|
|
|
* there won't be any notify handlers installed for device wake notifications
|
|
|
|
|
* from the given GPE (one example is a button GPE in Linux). For these cases,
|
|
|
|
|
* acpi_mark_gpe_for_wake should be used instead of acpi_setup_gpe_for_wake.
|
|
|
|
|
* This will set the ACPI_GPE_CAN_WAKE flag for the GPE without trying to
|
|
|
|
|
* setup implicit wake notification for it (since there's no handler method).
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
acpi_status acpi_mark_gpe_for_wake(acpi_handle gpe_device, u32 gpe_number)
|
|
|
|
|
{
|
|
|
|
|
struct acpi_gpe_event_info *gpe_event_info;
|
|
|
|
|
acpi_status status = AE_BAD_PARAMETER;
|
|
|
|
|
acpi_cpu_flags flags;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_mark_gpe_for_wake);
|
|
|
|
|
|
|
|
|
|
flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
|
|
|
|
|
|
|
|
|
|
/* Ensure that we have a valid GPE number */
|
|
|
|
|
|
|
|
|
|
gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
|
|
|
|
|
if (gpe_event_info) {
|
|
|
|
|
|
|
|
|
|
/* Mark the GPE as a possible wake event */
|
|
|
|
|
|
|
|
|
|
gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
|
|
|
|
|
status = AE_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_mark_gpe_for_wake)
|
|
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
2010-12-13 13:36:15 +08:00
|
|
|
* FUNCTION: acpi_setup_gpe_for_wake
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
2010-12-13 13:39:17 +08:00
|
|
|
* PARAMETERS: wake_device - Device associated with the GPE (via _PRW)
|
|
|
|
|
* gpe_device - Parent GPE Device. NULL for GPE0/GPE1
|
|
|
|
|
* gpe_number - GPE level within the GPE block
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
2010-12-13 13:39:17 +08:00
|
|
|
* DESCRIPTION: Mark a GPE as having the ability to wake the system. This
|
|
|
|
|
* interface is intended to be used as the host executes the
|
|
|
|
|
* _PRW methods (Power Resources for Wake) in the system tables.
|
|
|
|
|
* Each _PRW appears under a Device Object (The wake_device), and
|
|
|
|
|
* contains the info for the wake GPE associated with the
|
|
|
|
|
* wake_device.
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
2010-12-13 13:39:17 +08:00
|
|
|
acpi_status
|
|
|
|
|
acpi_setup_gpe_for_wake(acpi_handle wake_device,
|
|
|
|
|
acpi_handle gpe_device, u32 gpe_number)
|
2010-12-13 13:36:02 +08:00
|
|
|
{
|
2012-06-29 10:04:17 +08:00
|
|
|
acpi_status status;
|
2010-12-13 13:36:02 +08:00
|
|
|
struct acpi_gpe_event_info *gpe_event_info;
|
2010-12-13 13:39:17 +08:00
|
|
|
struct acpi_namespace_node *device_node;
|
2012-06-29 10:04:17 +08:00
|
|
|
struct acpi_gpe_notify_info *notify;
|
|
|
|
|
struct acpi_gpe_notify_info *new_notify;
|
2010-12-13 13:36:02 +08:00
|
|
|
acpi_cpu_flags flags;
|
|
|
|
|
|
2010-12-13 13:36:15 +08:00
|
|
|
ACPI_FUNCTION_TRACE(acpi_setup_gpe_for_wake);
|
2010-12-13 13:36:02 +08:00
|
|
|
|
2010-12-13 13:39:17 +08:00
|
|
|
/* Parameter Validation */
|
|
|
|
|
|
|
|
|
|
if (!wake_device) {
|
|
|
|
|
/*
|
|
|
|
|
* By forcing wake_device to be valid, we automatically enable the
|
|
|
|
|
* implicit notify feature on all hosts.
|
|
|
|
|
*/
|
|
|
|
|
return_ACPI_STATUS(AE_BAD_PARAMETER);
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-29 10:04:17 +08:00
|
|
|
/* Handle root object case */
|
|
|
|
|
|
|
|
|
|
if (wake_device == ACPI_ROOT_OBJECT) {
|
|
|
|
|
device_node = acpi_gbl_root_node;
|
|
|
|
|
} else {
|
2012-10-31 10:25:45 +08:00
|
|
|
device_node =
|
|
|
|
|
ACPI_CAST_PTR(struct acpi_namespace_node, wake_device);
|
2012-06-29 10:04:17 +08:00
|
|
|
}
|
|
|
|
|
|
2012-12-19 13:36:49 +08:00
|
|
|
/* Validate wake_device is of type Device */
|
2012-06-29 10:04:17 +08:00
|
|
|
|
|
|
|
|
if (device_node->type != ACPI_TYPE_DEVICE) {
|
|
|
|
|
return_ACPI_STATUS (AE_BAD_PARAMETER);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Allocate a new notify object up front, in case it is needed.
|
|
|
|
|
* Memory allocation while holding a spinlock is a big no-no
|
|
|
|
|
* on some hosts.
|
|
|
|
|
*/
|
|
|
|
|
new_notify = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_gpe_notify_info));
|
|
|
|
|
if (!new_notify) {
|
|
|
|
|
return_ACPI_STATUS(AE_NO_MEMORY);
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
|
|
|
|
|
|
|
|
|
|
/* Ensure that we have a valid GPE number */
|
|
|
|
|
|
|
|
|
|
gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
|
2011-02-12 08:39:15 +08:00
|
|
|
if (!gpe_event_info) {
|
2012-06-29 10:04:17 +08:00
|
|
|
status = AE_BAD_PARAMETER;
|
2011-02-12 08:39:15 +08:00
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
2010-12-13 13:39:17 +08:00
|
|
|
|
2011-02-12 08:39:15 +08:00
|
|
|
/*
|
|
|
|
|
* If there is no method or handler for this GPE, then the
|
2012-06-29 10:04:17 +08:00
|
|
|
* wake_device will be notified whenever this GPE fires. This is
|
|
|
|
|
* known as an "implicit notify". Note: The GPE is assumed to be
|
2011-02-12 08:39:15 +08:00
|
|
|
* level-triggered (for windows compatibility).
|
|
|
|
|
*/
|
2015-02-05 15:20:29 +08:00
|
|
|
if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) ==
|
2012-06-29 10:04:17 +08:00
|
|
|
ACPI_GPE_DISPATCH_NONE) {
|
|
|
|
|
/*
|
|
|
|
|
* This is the first device for implicit notify on this GPE.
|
|
|
|
|
* Just set the flags here, and enter the NOTIFY block below.
|
|
|
|
|
*/
|
|
|
|
|
gpe_event_info->flags =
|
|
|
|
|
(ACPI_GPE_DISPATCH_NOTIFY | ACPI_GPE_LEVEL_TRIGGERED);
|
2017-08-10 06:31:58 +08:00
|
|
|
} else if (gpe_event_info->flags & ACPI_GPE_AUTO_ENABLED) {
|
|
|
|
|
/*
|
|
|
|
|
* A reference to this GPE has been added during the GPE block
|
|
|
|
|
* initialization, so drop it now to prevent the GPE from being
|
|
|
|
|
* permanently enabled and clear its ACPI_GPE_AUTO_ENABLED flag.
|
|
|
|
|
*/
|
|
|
|
|
(void)acpi_ev_remove_gpe_reference(gpe_event_info);
|
|
|
|
|
gpe_event_info->flags &= ~ACPI_GPE_AUTO_ENABLED;
|
2011-02-25 02:59:21 +08:00
|
|
|
}
|
|
|
|
|
|
2012-06-29 10:04:17 +08:00
|
|
|
/*
|
|
|
|
|
* If we already have an implicit notify on this GPE, add
|
|
|
|
|
* this device to the notify list.
|
|
|
|
|
*/
|
2015-02-05 15:20:29 +08:00
|
|
|
if (ACPI_GPE_DISPATCH_TYPE(gpe_event_info->flags) ==
|
2012-06-29 10:04:17 +08:00
|
|
|
ACPI_GPE_DISPATCH_NOTIFY) {
|
|
|
|
|
|
|
|
|
|
/* Ensure that the device is not already in the list */
|
|
|
|
|
|
|
|
|
|
notify = gpe_event_info->dispatch.notify_list;
|
|
|
|
|
while (notify) {
|
|
|
|
|
if (notify->device_node == device_node) {
|
|
|
|
|
status = AE_ALREADY_EXISTS;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
notify = notify->next;
|
2011-02-25 02:59:21 +08:00
|
|
|
}
|
|
|
|
|
|
2012-06-29 10:04:17 +08:00
|
|
|
/* Add this device to the notify list for this GPE */
|
|
|
|
|
|
|
|
|
|
new_notify->device_node = device_node;
|
|
|
|
|
new_notify->next = gpe_event_info->dispatch.notify_list;
|
|
|
|
|
gpe_event_info->dispatch.notify_list = new_notify;
|
|
|
|
|
new_notify = NULL;
|
2010-12-13 13:36:02 +08:00
|
|
|
}
|
|
|
|
|
|
2012-06-29 10:04:17 +08:00
|
|
|
/* Mark the GPE as a possible wake event */
|
|
|
|
|
|
2011-02-12 08:39:15 +08:00
|
|
|
gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
|
|
|
|
|
status = AE_OK;
|
|
|
|
|
|
2012-06-29 10:04:17 +08:00
|
|
|
unlock_and_exit:
|
2010-12-13 13:36:02 +08:00
|
|
|
acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
|
2012-06-29 10:04:17 +08:00
|
|
|
|
|
|
|
|
/* Delete the notify object if it was not used above */
|
|
|
|
|
|
|
|
|
|
if (new_notify) {
|
|
|
|
|
ACPI_FREE(new_notify);
|
|
|
|
|
}
|
2010-12-13 13:36:02 +08:00
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
2010-12-13 13:36:15 +08:00
|
|
|
ACPI_EXPORT_SYMBOL(acpi_setup_gpe_for_wake)
|
2010-12-13 13:36:02 +08:00
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
2010-12-13 13:36:15 +08:00
|
|
|
* FUNCTION: acpi_set_gpe_wake_mask
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
|
|
|
|
* PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
|
|
|
|
|
* gpe_number - GPE level within the GPE block
|
2012-07-12 09:40:10 +08:00
|
|
|
* action - Enable or Disable
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
2010-12-13 13:39:37 +08:00
|
|
|
* DESCRIPTION: Set or clear the GPE's wakeup enable mask bit. The GPE must
|
|
|
|
|
* already be marked as a WAKE GPE.
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
2012-10-31 10:25:45 +08:00
|
|
|
acpi_status
|
|
|
|
|
acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action)
|
2010-12-13 13:36:02 +08:00
|
|
|
{
|
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
|
struct acpi_gpe_event_info *gpe_event_info;
|
|
|
|
|
struct acpi_gpe_register_info *gpe_register_info;
|
|
|
|
|
acpi_cpu_flags flags;
|
|
|
|
|
u32 register_bit;
|
|
|
|
|
|
2010-12-13 13:36:15 +08:00
|
|
|
ACPI_FUNCTION_TRACE(acpi_set_gpe_wake_mask);
|
2010-12-13 13:36:02 +08:00
|
|
|
|
|
|
|
|
flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
|
|
|
|
|
|
2010-12-13 13:39:37 +08:00
|
|
|
/*
|
|
|
|
|
* Ensure that we have a valid GPE number and that this GPE is in
|
|
|
|
|
* fact a wake GPE
|
|
|
|
|
*/
|
2010-12-13 13:36:02 +08:00
|
|
|
gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
|
2010-12-13 13:36:15 +08:00
|
|
|
if (!gpe_event_info) {
|
2010-12-13 13:36:02 +08:00
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-13 13:36:15 +08:00
|
|
|
if (!(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
|
|
|
|
|
status = AE_TYPE;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
gpe_register_info = gpe_event_info->register_info;
|
|
|
|
|
if (!gpe_register_info) {
|
|
|
|
|
status = AE_NOT_EXIST;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
2012-08-17 11:10:02 +08:00
|
|
|
register_bit = acpi_hw_get_gpe_register_bit(gpe_event_info);
|
2010-12-13 13:36:02 +08:00
|
|
|
|
|
|
|
|
/* Perform the action */
|
|
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
|
case ACPI_GPE_ENABLE:
|
2013-06-08 08:58:14 +08:00
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
ACPI_SET_BIT(gpe_register_info->enable_for_wake,
|
|
|
|
|
(u8)register_bit);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ACPI_GPE_DISABLE:
|
2013-06-08 08:58:14 +08:00
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
|
|
|
|
|
(u8)register_bit);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
2013-06-08 08:58:14 +08:00
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
ACPI_ERROR((AE_INFO, "%u, Invalid action", action));
|
|
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
unlock_and_exit:
|
|
|
|
|
acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-13 13:36:15 +08:00
|
|
|
ACPI_EXPORT_SYMBOL(acpi_set_gpe_wake_mask)
|
2010-12-13 13:36:02 +08:00
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_clear_gpe
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
|
|
|
|
|
* gpe_number - GPE level within the GPE block
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Clear an ACPI event (general purpose)
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number)
|
|
|
|
|
{
|
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
|
struct acpi_gpe_event_info *gpe_event_info;
|
|
|
|
|
acpi_cpu_flags flags;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_clear_gpe);
|
|
|
|
|
|
|
|
|
|
flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
|
|
|
|
|
|
|
|
|
|
/* Ensure that we have a valid GPE number */
|
|
|
|
|
|
|
|
|
|
gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
|
|
|
|
|
if (!gpe_event_info) {
|
|
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
status = acpi_hw_clear_gpe(gpe_event_info);
|
|
|
|
|
|
|
|
|
|
unlock_and_exit:
|
|
|
|
|
acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_clear_gpe)
|
|
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_get_gpe_status
|
|
|
|
|
*
|
2014-10-10 10:39:39 +08:00
|
|
|
* PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
|
|
|
|
|
* gpe_number - GPE level within the GPE block
|
2012-12-19 13:36:49 +08:00
|
|
|
* event_status - Where the current status of the event
|
|
|
|
|
* will be returned
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
2010-12-13 13:39:37 +08:00
|
|
|
* DESCRIPTION: Get the current status of a GPE (signalled/not_signalled)
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
acpi_status
|
|
|
|
|
acpi_get_gpe_status(acpi_handle gpe_device,
|
|
|
|
|
u32 gpe_number, acpi_event_status *event_status)
|
|
|
|
|
{
|
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
|
struct acpi_gpe_event_info *gpe_event_info;
|
|
|
|
|
acpi_cpu_flags flags;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_get_gpe_status);
|
|
|
|
|
|
|
|
|
|
flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
|
|
|
|
|
|
|
|
|
|
/* Ensure that we have a valid GPE number */
|
|
|
|
|
|
|
|
|
|
gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
|
|
|
|
|
if (!gpe_event_info) {
|
|
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Obtain status on the requested GPE number */
|
|
|
|
|
|
|
|
|
|
status = acpi_hw_get_gpe_status(gpe_event_info, event_status);
|
|
|
|
|
|
2013-10-29 09:30:02 +08:00
|
|
|
unlock_and_exit:
|
2010-12-13 13:36:02 +08:00
|
|
|
acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_get_gpe_status)
|
|
|
|
|
|
2018-05-25 16:30:35 +08:00
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_gispatch_gpe
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: gpe_device - Parent GPE Device. NULL for GPE0/GPE1
|
|
|
|
|
* gpe_number - GPE level within the GPE block
|
|
|
|
|
*
|
2019-07-15 19:03:28 +08:00
|
|
|
* RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED
|
2018-05-25 16:30:35 +08:00
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Detect and dispatch a General Purpose Event to either a function
|
|
|
|
|
* (e.g. EC) or method (e.g. _Lxx/_Exx) handler.
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
2019-07-15 19:03:28 +08:00
|
|
|
u32 acpi_dispatch_gpe(acpi_handle gpe_device, u32 gpe_number)
|
2018-05-25 16:30:35 +08:00
|
|
|
{
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_dispatch_gpe);
|
|
|
|
|
|
2019-07-15 19:03:28 +08:00
|
|
|
return acpi_ev_detect_gpe(gpe_device, NULL, gpe_number);
|
2018-05-25 16:30:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_dispatch_gpe)
|
|
|
|
|
|
2015-02-05 16:27:09 +08:00
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_finish_gpe
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: gpe_device - Namespace node for the GPE Block
|
|
|
|
|
* (NULL for FADT defined GPEs)
|
|
|
|
|
* gpe_number - GPE level within the GPE block
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
2019-02-16 05:36:19 +08:00
|
|
|
* DESCRIPTION: Clear and conditionally re-enable a GPE. This completes the GPE
|
2015-02-05 16:27:09 +08:00
|
|
|
* processing. Intended for use by asynchronous host-installed
|
2019-02-16 05:36:19 +08:00
|
|
|
* GPE handlers. The GPE is only re-enabled if the enable_for_run bit
|
2015-02-05 16:27:09 +08:00
|
|
|
* is set in the GPE info.
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
acpi_status acpi_finish_gpe(acpi_handle gpe_device, u32 gpe_number)
|
|
|
|
|
{
|
|
|
|
|
struct acpi_gpe_event_info *gpe_event_info;
|
|
|
|
|
acpi_status status;
|
|
|
|
|
acpi_cpu_flags flags;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_finish_gpe);
|
|
|
|
|
|
|
|
|
|
flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
|
|
|
|
|
|
|
|
|
|
/* Ensure that we have a valid GPE number */
|
|
|
|
|
|
|
|
|
|
gpe_event_info = acpi_ev_get_gpe_event_info(gpe_device, gpe_number);
|
|
|
|
|
if (!gpe_event_info) {
|
|
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
status = acpi_ev_finish_gpe(gpe_event_info);
|
|
|
|
|
|
|
|
|
|
unlock_and_exit:
|
|
|
|
|
acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_finish_gpe)
|
|
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
/******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_disable_all_gpes
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: None
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Disable and clear all GPEs in all GPE blocks
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
|
|
acpi_status acpi_disable_all_gpes(void)
|
|
|
|
|
{
|
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_disable_all_gpes);
|
|
|
|
|
|
|
|
|
|
status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
status = acpi_hw_disable_all_gpes();
|
|
|
|
|
(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
|
|
|
|
|
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-13 13:36:15 +08:00
|
|
|
ACPI_EXPORT_SYMBOL(acpi_disable_all_gpes)
|
|
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
/******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_enable_all_runtime_gpes
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: None
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Enable all "runtime" GPEs, in all GPE blocks
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
|
|
acpi_status acpi_enable_all_runtime_gpes(void)
|
|
|
|
|
{
|
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_enable_all_runtime_gpes);
|
|
|
|
|
|
|
|
|
|
status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
status = acpi_hw_enable_all_runtime_gpes();
|
|
|
|
|
(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
|
|
|
|
|
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-13 13:36:15 +08:00
|
|
|
ACPI_EXPORT_SYMBOL(acpi_enable_all_runtime_gpes)
|
|
|
|
|
|
2014-09-30 08:25:42 +08:00
|
|
|
/******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_enable_all_wakeup_gpes
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: None
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Enable all "wakeup" GPEs and disable all of the other GPEs, in
|
|
|
|
|
* all GPE blocks.
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
acpi_status acpi_enable_all_wakeup_gpes(void)
|
|
|
|
|
{
|
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_enable_all_wakeup_gpes);
|
|
|
|
|
|
|
|
|
|
status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
status = acpi_hw_enable_all_wakeup_gpes();
|
|
|
|
|
(void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
|
|
|
|
|
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_enable_all_wakeup_gpes)
|
|
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_install_gpe_block
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: gpe_device - Handle to the parent GPE Block Device
|
2012-07-12 09:40:10 +08:00
|
|
|
* gpe_block_address - Address and space_ID
|
2010-12-13 13:36:02 +08:00
|
|
|
* register_count - Number of GPE register pairs in the block
|
|
|
|
|
* interrupt_number - H/W interrupt for the block
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
2010-12-13 13:39:37 +08:00
|
|
|
* DESCRIPTION: Create and Install a block of GPE registers. The GPEs are not
|
|
|
|
|
* enabled here.
|
2010-12-13 13:36:02 +08:00
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
acpi_status
|
|
|
|
|
acpi_install_gpe_block(acpi_handle gpe_device,
|
|
|
|
|
struct acpi_generic_address *gpe_block_address,
|
|
|
|
|
u32 register_count, u32 interrupt_number)
|
|
|
|
|
{
|
2010-12-13 13:36:15 +08:00
|
|
|
acpi_status status;
|
2010-12-13 13:36:02 +08:00
|
|
|
union acpi_operand_object *obj_desc;
|
|
|
|
|
struct acpi_namespace_node *node;
|
|
|
|
|
struct acpi_gpe_block_info *gpe_block;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_install_gpe_block);
|
|
|
|
|
|
|
|
|
|
if ((!gpe_device) || (!gpe_block_address) || (!register_count)) {
|
|
|
|
|
return_ACPI_STATUS(AE_BAD_PARAMETER);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2012-10-31 10:26:01 +08:00
|
|
|
return_ACPI_STATUS(status);
|
2010-12-13 13:36:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
node = acpi_ns_validate_handle(gpe_device);
|
|
|
|
|
if (!node) {
|
|
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-08 09:42:19 +08:00
|
|
|
/* Validate the parent device */
|
|
|
|
|
|
|
|
|
|
if (node->type != ACPI_TYPE_DEVICE) {
|
|
|
|
|
status = AE_TYPE;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (node->object) {
|
|
|
|
|
status = AE_ALREADY_EXISTS;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
/*
|
|
|
|
|
* For user-installed GPE Block Devices, the gpe_block_base_number
|
|
|
|
|
* is always zero
|
|
|
|
|
*/
|
2014-04-30 10:06:15 +08:00
|
|
|
status = acpi_ev_create_gpe_block(node, gpe_block_address->address,
|
|
|
|
|
gpe_block_address->space_id,
|
|
|
|
|
register_count, 0, interrupt_number,
|
|
|
|
|
&gpe_block);
|
2010-12-13 13:36:02 +08:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Install block in the device_object attached to the node */
|
|
|
|
|
|
|
|
|
|
obj_desc = acpi_ns_get_attached_object(node);
|
|
|
|
|
if (!obj_desc) {
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* No object, create a new one (Device nodes do not always have
|
|
|
|
|
* an attached object)
|
|
|
|
|
*/
|
|
|
|
|
obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_DEVICE);
|
|
|
|
|
if (!obj_desc) {
|
|
|
|
|
status = AE_NO_MEMORY;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
status =
|
|
|
|
|
acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_DEVICE);
|
|
|
|
|
|
|
|
|
|
/* Remove local reference to the object */
|
|
|
|
|
|
|
|
|
|
acpi_ut_remove_reference(obj_desc);
|
|
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Now install the GPE block in the device_object */
|
|
|
|
|
|
|
|
|
|
obj_desc->device.gpe_block = gpe_block;
|
|
|
|
|
|
2013-10-29 09:30:02 +08:00
|
|
|
unlock_and_exit:
|
2010-12-13 13:36:02 +08:00
|
|
|
(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_install_gpe_block)
|
|
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_remove_gpe_block
|
|
|
|
|
*
|
|
|
|
|
* PARAMETERS: gpe_device - Handle to the parent GPE Block Device
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Remove a previously installed block of GPE registers
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
|
|
|
|
acpi_status acpi_remove_gpe_block(acpi_handle gpe_device)
|
|
|
|
|
{
|
|
|
|
|
union acpi_operand_object *obj_desc;
|
|
|
|
|
acpi_status status;
|
|
|
|
|
struct acpi_namespace_node *node;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_remove_gpe_block);
|
|
|
|
|
|
|
|
|
|
if (!gpe_device) {
|
|
|
|
|
return_ACPI_STATUS(AE_BAD_PARAMETER);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2012-10-31 10:26:01 +08:00
|
|
|
return_ACPI_STATUS(status);
|
2010-12-13 13:36:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
node = acpi_ns_validate_handle(gpe_device);
|
|
|
|
|
if (!node) {
|
|
|
|
|
status = AE_BAD_PARAMETER;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
2014-02-08 09:42:19 +08:00
|
|
|
/* Validate the parent device */
|
|
|
|
|
|
|
|
|
|
if (node->type != ACPI_TYPE_DEVICE) {
|
|
|
|
|
status = AE_TYPE;
|
|
|
|
|
goto unlock_and_exit;
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-13 13:36:02 +08:00
|
|
|
/* Get the device_object attached to the node */
|
|
|
|
|
|
|
|
|
|
obj_desc = acpi_ns_get_attached_object(node);
|
|
|
|
|
if (!obj_desc || !obj_desc->device.gpe_block) {
|
|
|
|
|
return_ACPI_STATUS(AE_NULL_OBJECT);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Delete the GPE block (but not the device_object) */
|
|
|
|
|
|
|
|
|
|
status = acpi_ev_delete_gpe_block(obj_desc->device.gpe_block);
|
|
|
|
|
if (ACPI_SUCCESS(status)) {
|
|
|
|
|
obj_desc->device.gpe_block = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-29 09:30:02 +08:00
|
|
|
unlock_and_exit:
|
2010-12-13 13:36:02 +08:00
|
|
|
(void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_remove_gpe_block)
|
|
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
|
|
|
*
|
|
|
|
|
* FUNCTION: acpi_get_gpe_device
|
|
|
|
|
*
|
2012-07-12 09:40:10 +08:00
|
|
|
* PARAMETERS: index - System GPE index (0-current_gpe_count)
|
2010-12-13 13:36:02 +08:00
|
|
|
* gpe_device - Where the parent GPE Device is returned
|
|
|
|
|
*
|
|
|
|
|
* RETURN: Status
|
|
|
|
|
*
|
|
|
|
|
* DESCRIPTION: Obtain the GPE device associated with the input index. A NULL
|
|
|
|
|
* gpe device indicates that the gpe number is contained in one of
|
|
|
|
|
* the FADT-defined gpe blocks. Otherwise, the GPE block device.
|
|
|
|
|
*
|
|
|
|
|
******************************************************************************/
|
2016-05-05 12:57:53 +08:00
|
|
|
acpi_status acpi_get_gpe_device(u32 index, acpi_handle *gpe_device)
|
2010-12-13 13:36:02 +08:00
|
|
|
{
|
|
|
|
|
struct acpi_gpe_device_info info;
|
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
|
|
ACPI_FUNCTION_TRACE(acpi_get_gpe_device);
|
|
|
|
|
|
|
|
|
|
if (!gpe_device) {
|
|
|
|
|
return_ACPI_STATUS(AE_BAD_PARAMETER);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (index >= acpi_current_gpe_count) {
|
|
|
|
|
return_ACPI_STATUS(AE_NOT_EXIST);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Setup and walk the GPE list */
|
|
|
|
|
|
|
|
|
|
info.index = index;
|
|
|
|
|
info.status = AE_NOT_EXIST;
|
|
|
|
|
info.gpe_device = NULL;
|
|
|
|
|
info.next_block_base_index = 0;
|
|
|
|
|
|
|
|
|
|
status = acpi_ev_walk_gpe_list(acpi_ev_get_gpe_device, &info);
|
|
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
|
return_ACPI_STATUS(status);
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-13 13:36:15 +08:00
|
|
|
*gpe_device = ACPI_CAST_PTR(acpi_handle, info.gpe_device);
|
2010-12-13 13:36:02 +08:00
|
|
|
return_ACPI_STATUS(info.status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ACPI_EXPORT_SYMBOL(acpi_get_gpe_device)
|
2012-02-14 18:14:27 +08:00
|
|
|
#endif /* !ACPI_REDUCED_HARDWARE */
|