On Wed, 2008-07-02 at 00:08 +0200, Rafael J. Wysocki wrote:
> From: Rafael J. Wysocki <rjw@xxxxxxx>
>
> PCI ACPI: Rework PCI handling of wake-up (rev. 4)
>
> * Introduce function acpi_pm_device_sleep_wake() for enabling and
> disabling the system wake-up capability of devices that are power
> manageable by ACPI.
>
> * Introduce function acpi_bus_can_wakeup() allowing other (dependent)
> subsystems to check if ACPI is able to enable the system wake-up
> capability of given device.
>
> * Introduce callback .sleep_wake() in struct pci_platform_pm_ops and
> for the ACPI PCI 'driver' make it use acpi_pm_device_sleep_wake().
>
> * Introduce callback .can_wakeup() in struct pci_platform_pm_ops and
> for the ACPI 'driver' make it use acpi_bus_can_wakeup().
>
> * Move the PME# handlig code out of pci_enable_wake() and split it
> into two functions, pci_pme_capable() and pci_pme_active(),
> allowing the caller to check if given device is capable of
> generating PME# from given power state and to enable/disable the
> device's PME# functionality, respectively.
>
> * Modify pci_enable_wake() to use the new ACPI callbacks and the new
> PME#-related functions.
>
> * Drop the generic .platform_enable_wakeup() callback that is not
> used any more.
>
> * Introduce device_set_wakeup_capable() that will set the
> power.can_wakeup flag of given device.
>
> * Rework PCI device PM initialization so that, if given device is
> capable of generating wake-up events, either natively through the
> PME# mechanism, or with the help of the platform, its
> power.can_wakeup flag is set and its power.should_wakeup flag is
> unset as appropriate.
>
> * Make ACPI set the power.can_wakeup flag for devices found to be
> wake-up capable by it.
>
> * Make the ACPI wake-up code enable/disable GPEs for devices that
> have the wakeup.flags.prepared flag set (which means that their
> wake-up power has been enabled).
>
> Signed-off-by: Rafael J. Wysocki <rjw@xxxxxxx>
> ---
> drivers/acpi/bus.c | 11 ++
> drivers/acpi/glue.c | 2
> drivers/acpi/sleep/main.c | 25 ++++++
> drivers/acpi/sleep/wakeup.c | 11 +-
> drivers/base/power/sysfs.c | 3
> drivers/pci/pci-acpi.c | 19 ++++
> drivers/pci/pci.c | 169 ++++++++++++++++++++++++++++++++------------
> drivers/pci/pci.h | 8 ++
> drivers/pci/probe.c | 47 ------------
> include/acpi/acpi_bus.h | 2
> include/linux/pm_wakeup.h | 26 +-----
> 11 files changed, 207 insertions(+), 116 deletions(-)
>
> Index: linux-next/drivers/acpi/sleep/main.c
> ===================================================================
> --- linux-next.orig/drivers/acpi/sleep/main.c
> +++ linux-next/drivers/acpi/sleep/main.c
> @@ -467,6 +467,31 @@ int acpi_pm_device_sleep_state(struct de
> *d_min_p = d_min;
> return d_max;
> }
> +
> +/**
> + * acpi_pm_device_sleep_wake - enable or disable the system wake-up
> + * capability of given device
> + * @dev: device to handle
> + * @enable: 'true' - enable, 'false' - disable the wake-up capability
> + */
> +int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
> +{
> + acpi_handle handle;
> + struct acpi_device *adev;
> +
> + if (!device_may_wakeup(dev))
> + return -EINVAL;
> +
> + handle = DEVICE_ACPI_HANDLE(dev);
> + if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
> + printk(KERN_DEBUG "ACPI handle has no context!\n");
> + return -ENODEV;
> + }
> +
> + return enable ?
> + acpi_enable_wakeup_device_power(adev, acpi_target_sleep_state) :
> + acpi_disable_wakeup_device_power(adev);
> +}
> #endif
>
> static void acpi_power_off_prepare(void)
> Index: linux-next/drivers/pci/pci-acpi.c
> ===================================================================
> --- linux-next.orig/drivers/pci/pci-acpi.c
> +++ linux-next/drivers/pci/pci-acpi.c
> @@ -299,10 +299,29 @@ static int acpi_pci_set_power_state(stru
> return error;
> }
>
> +static bool acpi_pci_can_wakeup(struct pci_dev *dev)
> +{
> + acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev);
> +
> + return handle ? acpi_bus_can_wakeup(handle) : false;
> +}
> +
> +static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable)
> +{
> + int error = acpi_pm_device_sleep_wake(&dev->dev, enable);
> +
> + if (!error)
> + printk(KERN_INFO "PCI: Wake-up capability of %s %s by ACPI\n",
> + pci_name(dev), enable ? "enabled" : "disabled");
> + return error;
> +}
> +
> static struct pci_platform_pm_ops acpi_pci_platform_pm = {
> .is_manageable = acpi_pci_power_manageable,
> .set_state = acpi_pci_set_power_state,
> .choose_state = acpi_pci_choose_state,
> + .can_wakeup = acpi_pci_can_wakeup,
> + .sleep_wake = acpi_pci_sleep_wake,
> };
>
> /* ACPI bus type */
> Index: linux-next/drivers/pci/pci.h
> ===================================================================
> --- linux-next.orig/drivers/pci/pci.h
> +++ linux-next/drivers/pci/pci.h
> @@ -17,6 +17,11 @@ extern void pci_cleanup_rom(struct pci_d
> * platform; to be used during system-wide transitions from a
> * sleeping state to the working state and vice versa
> *
> + * @can_wakeup - returns 'true' if given device is capable of waking up the
> + * system from a sleeping state
> + *
> + * @sleep_wake - enables/disables the system wake up capability of given device
> + *
> * If given platform is generally capable of power managing PCI devices, all of
> * these callbacks are mandatory.
> */
> @@ -24,9 +29,12 @@ struct pci_platform_pm_ops {
> bool (*is_manageable)(struct pci_dev *dev);
> int (*set_state)(struct pci_dev *dev, pci_power_t state);
> pci_power_t (*choose_state)(struct pci_dev *dev);
> + bool (*can_wakeup)(struct pci_dev *dev);
> + int (*sleep_wake)(struct pci_dev *dev, bool enable);
> };
>
> extern int pci_set_platform_pm(struct pci_platform_pm_ops *ops);
> +extern void pci_pm_init(struct pci_dev *dev);
>
> extern int pci_user_read_config_byte(struct pci_dev *dev, int where, u8 *val);
> extern int pci_user_read_config_word(struct pci_dev *dev, int where, u16 *val);
> Index: linux-next/include/acpi/acpi_bus.h
> ===================================================================
> --- linux-next.orig/include/acpi/acpi_bus.h
> +++ linux-next/include/acpi/acpi_bus.h
> @@ -337,6 +337,7 @@ int acpi_bus_get_status(struct acpi_devi
> int acpi_bus_get_power(acpi_handle handle, int *state);
> int acpi_bus_set_power(acpi_handle handle, int state);
> bool acpi_bus_power_manageable(acpi_handle handle);
> +bool acpi_bus_can_wakeup(acpi_handle handle);
> #ifdef CONFIG_ACPI_PROC_EVENT
> int acpi_bus_generate_proc_event(struct acpi_device *device, u8 type, int data);
> int acpi_bus_generate_proc_event4(const char *class, const char *bid, u8 type, int data);
> @@ -379,6 +380,7 @@ acpi_handle acpi_get_pci_rootbridge_hand
>
> #ifdef CONFIG_PM_SLEEP
> int acpi_pm_device_sleep_state(struct device *, int *);
> +int acpi_pm_device_sleep_wake(struct device *, bool);
> #else /* !CONFIG_PM_SLEEP */
> static inline int acpi_pm_device_sleep_state(struct device *d, int *p)
> {
> Index: linux-next/drivers/pci/pci.c
> ===================================================================
> --- linux-next.orig/drivers/pci/pci.c
> +++ linux-next/drivers/pci/pci.c
> @@ -380,7 +380,8 @@ static struct pci_platform_pm_ops *pci_p
>
> int pci_set_platform_pm(struct pci_platform_pm_ops *ops)
> {
> - if (!ops->is_manageable || !ops->set_state || !ops->choose_state)
> + if (!ops->is_manageable || !ops->set_state || !ops->choose_state
> + || !ops->sleep_wake || !ops->can_wakeup)
> return -EINVAL;
> pci_platform_pm = ops;
> return 0;
> @@ -403,6 +404,17 @@ static inline pci_power_t platform_pci_c
> pci_platform_pm->choose_state(dev) : PCI_POWER_ERROR;
> }
>
> +static inline bool platform_pci_can_wakeup(struct pci_dev *dev)
> +{
> + return pci_platform_pm ? pci_platform_pm->can_wakeup(dev) : false;
> +}
> +
> +static inline int platform_pci_sleep_wake(struct pci_dev *dev, bool enable)
> +{
> + return pci_platform_pm ?
> + pci_platform_pm->sleep_wake(dev, enable) : -ENODEV;
> +}
> +
> /**
> * pci_raw_set_power_state - Use PCI PM registers to set the power state of
> * given PCI device
> @@ -1036,6 +1048,56 @@ int pci_set_pcie_reset_state(struct pci_
> }
>
> /**
> + * pci_pme_capable - check the capability of PCI device to generate PME#
> + * @dev: PCI device to handle.
> + * @pm: PCI PM capability offset of the device.
> + * @state: PCI state from which device will issue PME#.
> + */
> +static bool pci_pme_capable(struct pci_dev *dev, int pm, pci_power_t state)
> +{
> + u16 pmc;
> +
> + if (!pm)
> + return false;
> +
> + /* Check device's ability to generate PME# from given state */
> + pci_read_config_word(dev, pm + PCI_PM_PMC, &pmc);
> +
> + pmc &= PCI_PM_CAP_PME_MASK;
> + pmc >>= ffs(PCI_PM_CAP_PME_MASK) - 1; /* First bit of mask */
> +
> + return !!(pmc & (1 << state));
> +}
> +
> +/**
> + * pci_pme_active - enable or disable PCI device's PME# function
> + * @dev: PCI device to handle.
> + * @pm: PCI PM capability offset of the device.
> + * @enable: 'true' to enable PME# generation; 'false' to disable it.
> + *
> + * The caller must verify that the device is capable of generating PME# before
> + * calling this function with @enable equal to 'true'.
> + */
> +static void pci_pme_active(struct pci_dev *dev, int pm, bool enable)
> +{
> + u16 pmcsr;
> +
> + if (!pm)
> + return;
> +
> + pci_read_config_word(dev, pm + PCI_PM_CTRL, &pmcsr);
> + /* Clear PME_Status by writing 1 to it and enable PME# */
> + pmcsr |= PCI_PM_CTRL_PME_STATUS | PCI_PM_CTRL_PME_ENABLE;
> + if (!enable)
> + pmcsr &= ~PCI_PM_CTRL_PME_ENABLE;
> +
> + pci_write_config_word(dev, pm + PCI_PM_CTRL, pmcsr);
> +
> + printk(KERN_INFO "PCI: PME# from device %s %s\n", pci_name(dev),
> + enable ? "enabled" : "disabled");
> +}
> +
> +/**
> * pci_enable_wake - enable PCI device as wakeup event source
> * @dev: PCI device affected
> * @state: PCI state from which device will issue wakeup events
> @@ -1046,66 +1108,83 @@ int pci_set_pcie_reset_state(struct pci_
> * called automatically by this routine.
> *
> * Devices with legacy power management (no standard PCI PM capabilities)
> - * always require such platform hooks. Depending on the platform, devices
> - * supporting the standard PCI PME# signal may require such platform hooks;
> - * they always update bits in config space to allow PME# generation.
> - *
> - * -EIO is returned if the device can't ever be a wakeup event source.
> - * -EINVAL is returned if the device can't generate wakeup events from
> - * the specified PCI state. Returns zero if the operation is successful.
> + * always require such platform hooks.
> + *
> + * RETURN VALUE:
> + * 0 is returned on success
> + * -EINVAL is returned if device is not supposed to wake up the system
> + * Error code depending on the platform is returned if both the platform and
> + * the native mechanism fail to enable the generation of wake-up events
> */
> int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int enable)
> {
> int pm;
> - int status;
> - u16 value;
> + int error = 0;
> + bool pme_done = false;
> +
> + if (!device_may_wakeup(&dev->dev))
> + return -EINVAL;
>
> - /* Note that drivers should verify device_may_wakeup(&dev->dev)
> - * before calling this function. Platform code should report
> - * errors when drivers try to enable wakeup on devices that
> - * can't issue wakeups, or on which wakeups were disabled by
> - * userspace updating the /sys/devices.../power/wakeup file.
> + /*
> + * According to "PCI System Architecture" 4th ed. by Tom Shanley & Don
> + * Anderson we should be doing PME# wake enable followed by ACPI wake
> + * enable. To disable wake-up we call the platform first, for symmetry.
> */
>
> - status = call_platform_enable_wakeup(&dev->dev, enable);
> + if (!enable && platform_pci_can_wakeup(dev))
> + error = platform_pci_sleep_wake(dev, false);
>
> - /* find PCI PM capability in list */
> pm = pci_find_capability(dev, PCI_CAP_ID_PM);
> + if (!enable || pci_pme_capable(dev, pm, state)) {
> + pci_pme_active(dev, pm, enable);
> + pme_done = true;
> + }
>
> - /* If device doesn't support PM Capabilities, but caller wants to
> - * disable wake events, it's a NOP. Otherwise fail unless the
> - * platform hooks handled this legacy device already.
> - */
> - if (!pm)
> - return enable ? status : 0;
> + if (enable && platform_pci_can_wakeup(dev))
> + error = platform_pci_sleep_wake(dev, true);
>
> + return pme_done ? 0 : error;
> +}
> +
> +/**
> + * pci_pm_init - Initialize PM functions of given PCI device
> + * @dev: PCI device to handle.
> + */
> +void pci_pm_init(struct pci_dev *dev)
> +{
> + int pm;
> + u16 pmc;
> +
> + /* find PCI PM capability in list */
> + pm = pci_find_capability(dev, PCI_CAP_ID_PM);
> + if (!pm)
> + return;
> /* Check device's ability to generate PME# */
> - pci_read_config_word(dev,pm+PCI_PM_PMC,&value);
> + pci_read_config_word(dev, pm + PCI_PM_PMC, &pmc);
>
> - value &= PCI_PM_CAP_PME_MASK;
> - value >>= ffs(PCI_PM_CAP_PME_MASK) - 1; /* First bit of mask */
> + if ((pmc & PCI_PM_CAP_VER_MASK) > 3) {
> + dev_err(&dev->dev, "unsupported PM cap regs version (%u)\n",
> + pmc & PCI_PM_CAP_VER_MASK);
> + return;
> + }
>
> - /* Check if it can generate PME# from requested state. */
> - if (!value || !(value & (1 << state))) {
> - /* if it can't, revert what the platform hook changed,
> - * always reporting the base "EINVAL, can't PME#" error
> + if (pmc & PCI_PM_CAP_PME_MASK) {
> + dev_printk(KERN_INFO, &dev->dev,
> + "PME# supported from%s%s%s%s%s\n",
> + (pmc & PCI_PM_CAP_PME_D0) ? " D0" : "",
> + (pmc & PCI_PM_CAP_PME_D1) ? " D1" : "",
> + (pmc & PCI_PM_CAP_PME_D2) ? " D2" : "",
> + (pmc & PCI_PM_CAP_PME_D3) ? " D3hot" : "",
> + (pmc & PCI_PM_CAP_PME_D3cold) ? " D3cold" : "");
> + /*
> + * Make device's PM flags reflect the wake-up capability, but
> + * let the user space enable it to wake up the system as needed.
> */
> - if (enable)
> - call_platform_enable_wakeup(&dev->dev, 0);
> - return enable ? -EINVAL : 0;
> + device_set_wakeup_capable(&dev->dev, true);
> + device_set_wakeup_enable(&dev->dev, false);
> + /* Disable the PME# generation functionality */
> + pci_pme_active(dev, pm, false);
Agree. The dev.power.should_wakeup is unset for the PCI device that
supports PME. When it is required to wakeup the sleeping system, user
space can set the flag of dev->power.should_wakeup again.
But the device_init_wakeup(dev, 1) is still called in some
drivers, which means that dev->power.should_wakeup is set. For example:
USB driver for USB host controllers.
> }
> -
> - pci_read_config_word(dev, pm + PCI_PM_CTRL, &value);
> -
> - /* Clear PME_Status by writing 1 to it and enable PME# */
> - value |= PCI_PM_CTRL_PME_STATUS | PCI_PM_CTRL_PME_ENABLE;
> -
> - if (!enable)
> - value &= ~PCI_PM_CTRL_PME_ENABLE;
> -
> - pci_write_config_word(dev, pm + PCI_PM_CTRL, value);
> -
> - return 0;
> }
>
> int
> Index: linux-next/include/linux/pm_wakeup.h
> ===================================================================
> --- linux-next.orig/include/linux/pm_wakeup.h
> +++ linux-next/include/linux/pm_wakeup.h
> @@ -35,6 +35,11 @@ static inline void device_init_wakeup(st
> dev->power.can_wakeup = dev->power.should_wakeup = !!val;
> }
>
> +static inline void device_set_wakeup_capable(struct device *dev, int val)
> +{
> + dev->power.can_wakeup = !!val;
> +}
> +
> static inline int device_can_wakeup(struct device *dev)
> {
> return dev->power.can_wakeup;
> @@ -47,21 +52,7 @@ static inline void device_set_wakeup_ena
>
> static inline int device_may_wakeup(struct device *dev)
> {
> - return dev->power.can_wakeup & dev->power.should_wakeup;
> -}
> -
> -/*
> - * Platform hook to activate device wakeup capability, if that's not already
> - * handled by enable_irq_wake() etc.
> - * Returns zero on success, else negative errno
> - */
> -extern int (*platform_enable_wakeup)(struct device *dev, int is_on);
> -
> -static inline int call_platform_enable_wakeup(struct device *dev, int is_on)
> -{
> - if (platform_enable_wakeup)
> - return (*platform_enable_wakeup)(dev, is_on);
> - return 0;
> + return dev->power.can_wakeup && dev->power.should_wakeup;
> }
>
> #else /* !CONFIG_PM */
> @@ -80,11 +71,6 @@ static inline int device_can_wakeup(stru
> #define device_set_wakeup_enable(dev, val) do {} while (0)
> #define device_may_wakeup(dev) 0
>
> -static inline int call_platform_enable_wakeup(struct device *dev, int is_on)
> -{
> - return 0;
> -}
> -
> #endif /* !CONFIG_PM */
>
> #endif /* _LINUX_PM_WAKEUP_H */
> Index: linux-next/drivers/base/power/sysfs.c
> ===================================================================
> --- linux-next.orig/drivers/base/power/sysfs.c
> +++ linux-next/drivers/base/power/sysfs.c
> @@ -6,9 +6,6 @@
> #include <linux/string.h>
> #include "power.h"
>
> -int (*platform_enable_wakeup)(struct device *dev, int is_on);
> -
> -
> /*
> * wakeup - Report/change current wakeup option for device
> *
> Index: linux-next/drivers/acpi/bus.c
> ===================================================================
> --- linux-next.orig/drivers/acpi/bus.c
> +++ linux-next/drivers/acpi/bus.c
> @@ -306,6 +306,17 @@ bool acpi_bus_power_manageable(acpi_hand
>
> EXPORT_SYMBOL(acpi_bus_power_manageable);
>
> +bool acpi_bus_can_wakeup(acpi_handle handle)
> +{
> + struct acpi_device *device;
> + int result;
> +
> + result = acpi_bus_get_device(handle, &device);
> + return result ? false : device->wakeup.flags.valid;
> +}
> +
> +EXPORT_SYMBOL(acpi_bus_can_wakeup);
> +
> /* --------------------------------------------------------------------------
> Event Management
> -------------------------------------------------------------------------- */
> Index: linux-next/drivers/pci/probe.c
> ===================================================================
> --- linux-next.orig/drivers/pci/probe.c
> +++ linux-next/drivers/pci/probe.c
> @@ -860,49 +860,6 @@ int pci_cfg_space_size_ext(struct pci_de
> return PCI_CFG_SPACE_SIZE;
> }
>
> -/**
> - * pci_disable_pme - Disable the PME function of PCI device
> - * @dev: PCI device affected
> - * -EINVAL is returned if PCI device doesn't support PME.
> - * Zero is returned if the PME is supported and can be disabled.
> - */
> -static int pci_disable_pme(struct pci_dev *dev)
> -{
> - int pm;
> - u16 value;
> -
> - /* find PCI PM capability in list */
> - pm = pci_find_capability(dev, PCI_CAP_ID_PM);
> -
> - /* If device doesn't support PM Capabilities, it means that PME is
> - * not supported.
> - */
> - if (!pm)
> - return -EINVAL;
> - /* Check device's ability to generate PME# */
> - pci_read_config_word(dev, pm + PCI_PM_PMC, &value);
> -
> - value &= PCI_PM_CAP_PME_MASK;
> - /* Check if it can generate PME# */
> - if (!value) {
> - /*
> - * If it is zero, it means that PME is still unsupported
> - * although there exists the PM capability.
> - */
> - return -EINVAL;
> - }
> -
> - pci_read_config_word(dev, pm + PCI_PM_CTRL, &value);
> -
> - /* Clear PME_Status by writing 1 to it */
> - value |= PCI_PM_CTRL_PME_STATUS ;
> - /* Disable PME enable bit */
> - value &= ~PCI_PM_CTRL_PME_ENABLE;
> - pci_write_config_word(dev, pm + PCI_PM_CTRL, value);
> -
> - return 0;
> -}
> -
> int pci_cfg_space_size(struct pci_dev *dev)
> {
> int pos;
> @@ -1010,7 +967,6 @@ static struct pci_dev *pci_scan_device(s
> }
>
> pci_vpd_pci22_init(dev);
> - pci_disable_pme(dev);
>
> return dev;
> }
> @@ -1031,6 +987,9 @@ void pci_device_add(struct pci_dev *dev,
> /* Fix up broken headers */
> pci_fixup_device(pci_fixup_header, dev);
>
> + /* Initialize power management of the device */
> + pci_pm_init(dev);
> +
> /*
> * Add the device to our list of discovered devices
> * and the bus list for fixup functions, etc.
> Index: linux-next/drivers/acpi/glue.c
> ===================================================================
> --- linux-next.orig/drivers/acpi/glue.c
> +++ linux-next/drivers/acpi/glue.c
> @@ -165,6 +165,8 @@ static int acpi_bind_one(struct device *
> "firmware_node");
> ret = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
> "physical_node");
> + if (acpi_dev->wakeup.flags.valid)
> + device_set_wakeup_capable(dev, true);
> }
>
> return 0;
> Index: linux-next/drivers/acpi/sleep/wakeup.c
> ===================================================================
> --- linux-next.orig/drivers/acpi/sleep/wakeup.c
> +++ linux-next/drivers/acpi/sleep/wakeup.c
> @@ -66,13 +66,15 @@ void acpi_enable_wakeup_device(u8 sleep_
> list_for_each_safe(node, next, &acpi_wakeup_device_list) {
> struct acpi_device *dev =
> container_of(node, struct acpi_device, wakeup_list);
> +
> if (!dev->wakeup.flags.valid)
> continue;
> +
> /* If users want to disable run-wake GPE,
> * we only disable it for wake and leave it for runtime
> */
> - if (!dev->wakeup.state.enabled ||
> - sleep_state > (u32) dev->wakeup.sleep_state) {
> + if ((!dev->wakeup.state.enabled && !dev->wakeup.flags.prepared)
> + || sleep_state > (u32) dev->wakeup.sleep_state) {
> if (dev->wakeup.flags.run_wake) {
> spin_unlock(&acpi_device_lock);
> /* set_gpe_type will disable GPE, leave it like that */
If the dev->wakeup.flags.preprared is introduced, it seems that the
problem becomes more complex. Whether acpi_enable_wakeup_device_power is
called is related with the flags of dev->wakeup.state.enabled.
If the dev->wakeup.state.enabled is set, the
acpi_enable_wakeup_device_power will be called, in which the
dev->wakeup.flags.prepared is set. Otherwise the
dev->wakeup.flags.prepared is still unset.
In such case it seems that whether the GPE is enabled is related with
the dev->wakeup.state.enabled.
Of course it is also OK.
Thanks.
Yakui
> @@ -110,8 +112,9 @@ void acpi_disable_wakeup_device(u8 sleep
>
> if (!dev->wakeup.flags.valid)
> continue;
> - if (!dev->wakeup.state.enabled ||
> - sleep_state > (u32) dev->wakeup.sleep_state) {
> +
> + if ((!dev->wakeup.state.enabled && !dev->wakeup.flags.prepared)
> + || sleep_state > (u32) dev->wakeup.sleep_state) {
> if (dev->wakeup.flags.run_wake) {
> spin_unlock(&acpi_device_lock);
> acpi_set_gpe_type(dev->wakeup.gpe_device,
_______________________________________________
linux-pm mailing list
linux-pm@xxxxxxxxxxxxxxxxxxxxxxxxxx
https://lists.linux-foundation.org/mailman/listinfo/linux-pm
