On Tuesday, May 19, 2015 11:18:42 AM Tony Lindgren wrote:
> * Tony Lindgren <tony@xxxxxxxxxxx> [150519 08:21]:
> > * Rafael J. Wysocki <rjw@xxxxxxxxxxxxx> [150519 07:02]:
> > > On Tuesday, May 19, 2015 04:04:43 PM Rafael J. Wysocki wrote:
> > > > On Monday, May 18, 2015 04:44:01 PM Tony Lindgren wrote:
> > > > >
> > > > > We can replace it with just the following init and exit
> > > > > time code:
> > > > >
> > > > > ...
> > > > > device_init_wakeup(dev, true);
> > > > > dev_pm_set_wake_irq(dev, irq);
> > > > > ...
> > > > > dev_pm_clear_wake_irq(dev);
> > > > > device_init_wakeup(dev, false);
> > > > > ...
> > > > >
> > > > > And for hardware with dedicated wake-up interrupts:
> > > > >
> > > > > ...
> > > > > device_init_wakeup(dev, true);
> > > > > dev_pm_set_dedicated_wake_irq(dev, irq);
> > > > > ...
> > > > > dev_pm_clear_wake_irq(dev);
> > > > > device_init_wakeup(dev, false);
> > > > > ...
> > > > >
> > > > > For now, let's only enable it for select PM_WAKEIRQ.
> > > >
> > > > Why? What would be wrong with doing that unconditionally?
> >
> > No reason to make it conditional any longer. it's there from
> > the earlier version that only handled the dedicated wake IRQS.
> >
> > > I mean, what about making it depend on CONFIG_PM directly?
> >
> > OK let's do that.
>
> Here's the patch updated and now using just CONFIG_PM.
This one looks really good. :-)
If it doesn't depend on anything, I can apply it right away, so please let me
know.
> 8< ---------------------------
> From: Tony Lindgren <tony@xxxxxxxxxxx>
> Date: Mon, 18 May 2015 15:40:29 -0700
> Subject: [PATCH] PM / Wakeirq: Add automated device wake IRQ handling
>
> Turns out we can automate the handling for the device_may_wakeup()
> quite a bit by using the kernel wakeup source list as suggested
> by Rafael J. Wysocki <rjw@xxxxxxxxxxxxx>.
>
> And as some hardware has separate dedicated wake-up interrupt
> in addition to the IO interrupt, we can automate the handling by
> adding a generic threaded interrupt handler that just calls the
> device PM runtime to wake up the device.
>
> This allows dropping code from device drivers as we currently
> are doing it in multiple ways, and often wrong.
>
> For most drivers, we should be able to drop the following
> boilerplate code from runtime_suspend and runtime_resume
> functions:
>
> ...
> device_init_wakeup(dev, true);
> ...
> if (device_may_wakeup(dev))
> enable_irq_wake(irq);
> ...
> if (device_may_wakeup(dev))
> disable_irq_wake(irq);
> ...
> device_init_wakeup(dev, false);
> ...
>
> We can replace it with just the following init and exit
> time code:
>
> ...
> device_init_wakeup(dev, true);
> dev_pm_set_wake_irq(dev, irq);
> ...
> dev_pm_clear_wake_irq(dev);
> device_init_wakeup(dev, false);
> ...
>
> And for hardware with dedicated wake-up interrupts:
>
> ...
> device_init_wakeup(dev, true);
> dev_pm_set_dedicated_wake_irq(dev, irq);
> ...
> dev_pm_clear_wake_irq(dev);
> device_init_wakeup(dev, false);
> ...
>
> Signed-off-by: Tony Lindgren <tony@xxxxxxxxxxx>
>
> diff --git a/drivers/base/power/Makefile b/drivers/base/power/Makefile
> index 1cb8544..f94a6cc 100644
> --- a/drivers/base/power/Makefile
> +++ b/drivers/base/power/Makefile
> @@ -1,4 +1,4 @@
> -obj-$(CONFIG_PM) += sysfs.o generic_ops.o common.o qos.o runtime.o
> +obj-$(CONFIG_PM) += sysfs.o generic_ops.o common.o qos.o runtime.o wakeirq.o
> obj-$(CONFIG_PM_SLEEP) += main.o wakeup.o
> obj-$(CONFIG_PM_TRACE_RTC) += trace.o
> obj-$(CONFIG_PM_OPP) += opp.o
> diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
> index 3d874ec..6f2515c 100644
> --- a/drivers/base/power/main.c
> +++ b/drivers/base/power/main.c
> @@ -24,6 +24,7 @@
> #include <linux/pm.h>
> #include <linux/pm_runtime.h>
> #include <linux/pm-trace.h>
> +#include <linux/pm_wakeirq.h>
> #include <linux/interrupt.h>
> #include <linux/sched.h>
> #include <linux/async.h>
> @@ -587,6 +588,7 @@ void dpm_resume_noirq(pm_message_t state)
> async_synchronize_full();
> dpm_show_time(starttime, state, "noirq");
> resume_device_irqs();
> + device_wakeup_disarm_wake_irqs();
> cpuidle_resume();
> trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, false);
> }
> @@ -1104,6 +1106,7 @@ int dpm_suspend_noirq(pm_message_t state)
>
> trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, true);
> cpuidle_pause();
> + device_wakeup_arm_wake_irqs();
> suspend_device_irqs();
> mutex_lock(&dpm_list_mtx);
> pm_transition = state;
> diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
> index b6b8a27..f1a5d95 100644
> --- a/drivers/base/power/power.h
> +++ b/drivers/base/power/power.h
> @@ -20,6 +20,46 @@ static inline void pm_runtime_early_init(struct device *dev)
> extern void pm_runtime_init(struct device *dev);
> extern void pm_runtime_remove(struct device *dev);
>
> +struct wake_irq {
> + struct device *dev;
> + int irq;
> + bool dedicated_irq:1;
> +};
> +
> +extern void dev_pm_arm_wake_irq(struct wake_irq *wirq);
> +extern void dev_pm_disarm_wake_irq(struct wake_irq *wirq);
> +
> +#ifdef CONFIG_PM_SLEEP
> +
> +extern int device_wakeup_attach_irq(struct device *dev,
> + struct wake_irq *wakeirq);
> +extern void device_wakeup_detach_irq(struct device *dev);
> +extern void device_wakeup_arm_wake_irqs(void);
> +extern void device_wakeup_disarm_wake_irqs(void);
> +
> +#else
> +
> +static inline int
> +device_wakeup_attach_irq(struct device *dev,
> + struct wake_irq *wakeirq)
> +{
> + return 0;
> +}
> +
> +static inline void device_wakeup_detach_irq(struct device *dev)
> +{
> +}
> +
> +static inline void device_wakeup_arm_wake_irqs(void)
> +{
> +}
> +
> +static inline void device_wakeup_disarm_wake_irqs(void)
> +{
> +}
> +
> +#endif /* CONFIG_PM_SLEEP */
> +
> /*
> * sysfs.c
> */
> @@ -52,6 +92,14 @@ static inline void wakeup_sysfs_remove(struct device *dev) {}
> static inline int pm_qos_sysfs_add(struct device *dev) { return 0; }
> static inline void pm_qos_sysfs_remove(struct device *dev) {}
>
> +static inline void dev_pm_arm_wake_irq(struct wake_irq *wirq)
> +{
> +}
> +
> +static inline void dev_pm_disarm_wake_irq(struct wake_irq *wirq)
> +{
> +}
> +
> #endif
>
> #ifdef CONFIG_PM_SLEEP
> diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
> index 4ffe4a2..e1a10a0 100644
> --- a/drivers/base/power/runtime.c
> +++ b/drivers/base/power/runtime.c
> @@ -10,6 +10,7 @@
> #include <linux/sched.h>
> #include <linux/export.h>
> #include <linux/pm_runtime.h>
> +#include <linux/pm_wakeirq.h>
> #include <trace/events/rpm.h>
> #include "power.h"
>
> @@ -514,6 +515,7 @@ static int rpm_suspend(struct device *dev, int rpmflags)
>
> callback = RPM_GET_CALLBACK(dev, runtime_suspend);
>
> + dev_pm_enable_wake_irq(dev);
> retval = rpm_callback(callback, dev);
> if (retval)
> goto fail;
> @@ -552,6 +554,7 @@ static int rpm_suspend(struct device *dev, int rpmflags)
> return retval;
>
> fail:
> + dev_pm_disable_wake_irq(dev);
> __update_runtime_status(dev, RPM_ACTIVE);
> dev->power.deferred_resume = false;
> wake_up_all(&dev->power.wait_queue);
> @@ -734,10 +737,12 @@ static int rpm_resume(struct device *dev, int rpmflags)
>
> callback = RPM_GET_CALLBACK(dev, runtime_resume);
>
> + dev_pm_disable_wake_irq(dev);
> retval = rpm_callback(callback, dev);
> if (retval) {
> __update_runtime_status(dev, RPM_SUSPENDED);
> pm_runtime_cancel_pending(dev);
> + dev_pm_enable_wake_irq(dev);
> } else {
> no_callback:
> __update_runtime_status(dev, RPM_ACTIVE);
> diff --git a/drivers/base/power/wakeirq.c b/drivers/base/power/wakeirq.c
> new file mode 100644
> index 0000000..7470004
> --- /dev/null
> +++ b/drivers/base/power/wakeirq.c
> @@ -0,0 +1,273 @@
> +/*
> + * wakeirq.c - Device wakeirq helper functions
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
> + * kind, whether express or implied; without even the implied warranty
> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + */
> +
> +#include <linux/device.h>
> +#include <linux/interrupt.h>
> +#include <linux/irq.h>
> +#include <linux/slab.h>
> +#include <linux/pm_runtime.h>
> +#include <linux/pm_wakeirq.h>
> +
> +#include "power.h"
> +
> +/**
> + * dev_pm_attach_wake_irq - Attach device interrupt as a wake IRQ
> + * @dev: Device entry
> + * @irq: Device wake-up capable interrupt
> + * @wirq: Wake irq specific data
> + *
> + * Internal function to attach either a device IO interrupt or a
> + * dedicated wake-up interrupt as a wake IRQ.
> + */
> +static int dev_pm_attach_wake_irq(struct device *dev, int irq,
> + struct wake_irq *wirq)
> +{
> + unsigned long flags;
> + int err;
> +
> + if (!dev || !wirq)
> + return -EINVAL;
> +
> + spin_lock_irqsave(&dev->power.lock, flags);
> + if (dev_WARN_ONCE(dev, dev->power.wakeirq,
> + "wake irq already initialized\n")) {
> + spin_unlock_irqrestore(&dev->power.lock, flags);
> + return -EEXIST;
> + }
> +
> + dev->power.wakeirq = wirq;
> + spin_unlock_irqrestore(&dev->power.lock, flags);
> +
> + err = device_wakeup_attach_irq(dev, wirq);
> + if (err)
> + return err;
> +
> + return 0;
> +}
> +
> +/**
> + * dev_pm_set_wake_irq - Attach device IO interrupt as wake IRQ
> + * @dev: Device entry
> + * @irq: Device IO interrupt
> + *
> + * Attach a device IO interrupt as a wake IRQ. The wake IRQ gets
> + * automatically configured for wake-up from suspend based
> + * on the device specific sysfs wakeup entry. Typically called
> + * during driver probe after calling device_init_wakeup().
> + */
> +int dev_pm_set_wake_irq(struct device *dev, int irq)
> +{
> + struct wake_irq *wirq;
> + int err;
> +
> + wirq = kzalloc(sizeof(*wirq), GFP_KERNEL);
> + if (!wirq)
> + return -ENOMEM;
> +
> + wirq->dev = dev;
> + wirq->irq = irq;
> +
> + err = dev_pm_attach_wake_irq(dev, irq, wirq);
> + if (err)
> + kfree(wirq);
> +
> + return err;
> +}
> +EXPORT_SYMBOL_GPL(dev_pm_set_wake_irq);
> +
> +/**
> + * dev_pm_clear_wake_irq - Detach a device IO interrupt wake IRQ
> + * @dev: Device entry
> + *
> + * Detach a device wake IRQ and free resources.
> + *
> + * Note that it's OK for drivers to call this without calling
> + * dev_pm_set_wake_irq() as all the driver instances may not have
> + * a wake IRQ configured. This avoid adding wake IRQ specific
> + * checks into the drivers.
> + */
> +void dev_pm_clear_wake_irq(struct device *dev)
> +{
> + struct wake_irq *wirq = dev->power.wakeirq;
> + unsigned long flags;
> +
> + if (!wirq)
> + return;
> +
> + spin_lock_irqsave(&dev->power.lock, flags);
> + dev->power.wakeirq = NULL;
> + spin_unlock_irqrestore(&dev->power.lock, flags);
> +
> + device_wakeup_detach_irq(dev);
> + if (wirq->dedicated_irq)
> + free_irq(wirq->irq, wirq);
> + kfree(wirq);
> +}
> +EXPORT_SYMBOL_GPL(dev_pm_clear_wake_irq);
> +
> +/**
> + * handle_threaded_wake_irq - Handler for dedicated wake-up interrupts
> + * @irq: Device specific dedicated wake-up interrupt
> + * @_wirq: Wake IRQ data
> + *
> + * Some devices have a separate wake-up interrupt in addition to the
> + * device IO interrupt. The wake-up interrupt signals that a device
> + * should be woken up from it's idle state. This handler uses device
> + * specific pm_runtime functions to wake the device, and then it's
> + * up to the device to do whatever it needs to. Note that as the
> + * device may need to restore context and start up regulators, we
> + * use a threaded IRQ.
> + *
> + * Also note that we are not resending the lost device interrupts.
> + * We assume that the wake-up interrupt just needs to wake-up the
> + * device, and then device's pm_runtime_resume() can deal with the
> + * situation.
> + */
> +static irqreturn_t handle_threaded_wake_irq(int irq, void *_wirq)
> +{
> + struct wake_irq *wirq = _wirq;
> + int res;
> +
> + /* We don't want RPM_ASYNC or RPM_NOWAIT here */
> + res = pm_runtime_resume(wirq->dev);
> + if (res < 0)
> + dev_warn(wirq->dev,
> + "wake IRQ with no resume: %i\n", res);
> +
> + return IRQ_HANDLED;
> +}
> +
> +/**
> + * dev_pm_set_dedicated_wake_irq - Request a dedicated wake-up interrupt
> + * @dev: Device entry
> + * @irq: Device wake-up interrupt
> + *
> + * Unless your hardware has separate wake-up interrupts in addition
> + * to the device IO interrupts, you don't need this.
> + *
> + * Sets up a threaded interrupt handler for a device that has
> + * a dedicated wake-up interrupt in addition to the device IO
> + * interrupt.
> + *
> + * The interrupt starts disabled, and needs to be managed for
> + * the device by the bus code or the device driver using
> + * dev_pm_enable_wake_irq() and dev_pm_disable_wake_irq()
> + * functions.
> + */
> +int dev_pm_set_dedicated_wake_irq(struct device *dev, int irq)
> +{
> + struct wake_irq *wirq;
> + int err;
> +
> + wirq = kzalloc(sizeof(*wirq), GFP_KERNEL);
> + if (!wirq)
> + return -ENOMEM;
> +
> + wirq->dev = dev;
> + wirq->irq = irq;
> + wirq->dedicated_irq = true;
> + irq_set_status_flags(irq, IRQ_NOAUTOEN);
> +
> + /*
> + * Consumer device may need to power up and restore state
> + * so we use a threaded irq.
> + */
> + err = request_threaded_irq(irq, NULL, handle_threaded_wake_irq,
> + IRQF_ONESHOT, dev_name(dev), wirq);
> + if (err)
> + goto err_free;
> +
> + err = dev_pm_attach_wake_irq(dev, irq, wirq);
> + if (err)
> + goto err_free_irq;
> +
> + return err;
> +
> +err_free_irq:
> + free_irq(irq, wirq);
> +err_free:
> + kfree(wirq);
> +
> + return err;
> +}
> +EXPORT_SYMBOL_GPL(dev_pm_set_dedicated_wake_irq);
> +
> +/**
> + * dev_pm_enable_wake_irq - Enable device wake-up interrupt
> + * @dev: Device
> + *
> + * Called from the bus code or the device driver for
> + * runtime_suspend() to enable the wake-up interrupt while
> + * the device is running.
> + *
> + * Note that for runtime_suspend()) the wake-up interrupts
> + * should be unconditionally enabled unlike for suspend()
> + * that is conditional.
> + */
> +void dev_pm_enable_wake_irq(struct device *dev)
> +{
> + struct wake_irq *wirq = dev->power.wakeirq;
> +
> + if (wirq && wirq->dedicated_irq)
> + enable_irq(wirq->irq);
> +}
> +EXPORT_SYMBOL_GPL(dev_pm_enable_wake_irq);
> +
> +/**
> + * dev_pm_disable_wake_irq - Disable device wake-up interrupt
> + * @dev: Device
> + *
> + * Called from the bus code or the device driver for
> + * runtime_resume() to disable the wake-up interrupt while
> + * the device is running.
> + */
> +void dev_pm_disable_wake_irq(struct device *dev)
> +{
> + struct wake_irq *wirq = dev->power.wakeirq;
> +
> + if (wirq && wirq->dedicated_irq)
> + disable_irq_nosync(wirq->irq);
> +}
> +EXPORT_SYMBOL_GPL(dev_pm_disable_wake_irq);
> +
> +/**
> + * dev_pm_arm_wake_irq - Arm device wake-up
> + * @wirq: Device wake-up interrupt
> + *
> + * Sets up the wake-up event conditionally based on the
> + * device_may_wake().
> + */
> +void dev_pm_arm_wake_irq(struct wake_irq *wirq)
> +{
> + if (!wirq)
> + return;
> +
> + if (device_may_wakeup(wirq->dev))
> + enable_irq_wake(wirq->irq);
> +}
> +
> +/**
> + * dev_pm_disarm_wake_irq - Disarm device wake-up
> + * @wirq: Device wake-up interrupt
> + *
> + * Clears up the wake-up event conditionally based on the
> + * device_may_wake().
> + */
> +void dev_pm_disarm_wake_irq(struct wake_irq *wirq)
> +{
> + if (!wirq)
> + return;
> +
> + if (device_may_wakeup(wirq->dev))
> + disable_irq_wake(wirq->irq);
> +}
> diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
> index 7726200..7332ebc 100644
> --- a/drivers/base/power/wakeup.c
> +++ b/drivers/base/power/wakeup.c
> @@ -14,6 +14,7 @@
> #include <linux/suspend.h>
> #include <linux/seq_file.h>
> #include <linux/debugfs.h>
> +#include <linux/pm_wakeirq.h>
> #include <trace/events/power.h>
>
> #include "power.h"
> @@ -239,6 +240,97 @@ int device_wakeup_enable(struct device *dev)
> EXPORT_SYMBOL_GPL(device_wakeup_enable);
>
> /**
> + * device_wakeup_attach_irq - Attach a wakeirq to a wakeup source
> + * @dev: Device to handle
> + * @wakeirq: Device specific wakeirq entry
> + *
> + * Attach a device wakeirq to the wakeup source so the device
> + * wake IRQ can be configured automatically for suspend and
> + * resume.
> + */
> +int device_wakeup_attach_irq(struct device *dev,
> + struct wake_irq *wakeirq)
> +{
> + struct wakeup_source *ws;
> + int ret = 0;
> +
> + spin_lock_irq(&dev->power.lock);
> + ws = dev->power.wakeup;
> + if (!ws) {
> + dev_err(dev, "forgot to call call device_init_wakeup?\n");
> + ret = -EINVAL;
> + goto unlock;
> + }
> +
> + if (ws->wakeirq) {
> + ret = -EEXIST;
> + goto unlock;
> + }
> +
> + ws->wakeirq = wakeirq;
> +
> +unlock:
> + spin_unlock_irq(&dev->power.lock);
> +
> + return ret;
> +}
> +
> +/**
> + * device_wakeup_detach_irq - Detach a wakeirq from a wakeup source
> + * @dev: Device to handle
> + *
> + * Removes a device wakeirq from the wakeup source.
> + */
> +void device_wakeup_detach_irq(struct device *dev)
> +{
> + struct wakeup_source *ws;
> +
> + spin_lock_irq(&dev->power.lock);
> + ws = dev->power.wakeup;
> + if (!ws)
> + goto unlock;
> +
> + ws->wakeirq = NULL;
> +
> +unlock:
> + spin_unlock_irq(&dev->power.lock);
> +}
> +
> +/**
> + * device_wakeup_arm_wake_irqs(void)
> + *
> + * Itereates over the list of device wakeirqs to arm them.
> + */
> +void device_wakeup_arm_wake_irqs(void)
> +{
> + struct wakeup_source *ws;
> +
> + rcu_read_lock();
> + list_for_each_entry_rcu(ws, &wakeup_sources, entry) {
> + if (ws->wakeirq)
> + dev_pm_arm_wake_irq(ws->wakeirq);
> + }
> + rcu_read_unlock();
> +}
> +
> +/**
> + * device_wakeup_disarm_wake_irqs(void)
> + *
> + * Itereates over the list of device wakeirqs to disarm them.
> + */
> +void device_wakeup_disarm_wake_irqs(void)
> +{
> + struct wakeup_source *ws;
> +
> + rcu_read_lock();
> + list_for_each_entry_rcu(ws, &wakeup_sources, entry) {
> + if (ws->wakeirq)
> + dev_pm_disarm_wake_irq(ws->wakeirq);
> + }
> + rcu_read_unlock();
> +}
> +
> +/**
> * device_wakeup_detach - Detach a device's wakeup source object from it.
> * @dev: Device to detach the wakeup source object from.
> *
> diff --git a/include/linux/pm.h b/include/linux/pm.h
> index 2d29c64..1c4ed0c 100644
> --- a/include/linux/pm.h
> +++ b/include/linux/pm.h
> @@ -529,6 +529,7 @@ enum rpm_request {
> };
>
> struct wakeup_source;
> +struct wake_irq;
> struct pm_domain_data;
>
> struct pm_subsys_data {
> @@ -568,6 +569,7 @@ struct dev_pm_info {
> unsigned long timer_expires;
> struct work_struct work;
> wait_queue_head_t wait_queue;
> + struct wake_irq *wakeirq;
> atomic_t usage_count;
> atomic_t child_count;
> unsigned int disable_depth:3;
> diff --git a/include/linux/pm_wakeirq.h b/include/linux/pm_wakeirq.h
> new file mode 100644
> index 0000000..4046fa1
> --- /dev/null
> +++ b/include/linux/pm_wakeirq.h
> @@ -0,0 +1,52 @@
> +/*
> + * pm_wakeirq.h - Device wakeirq helper functions
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed "as is" WITHOUT ANY WARRANTY of any
> + * kind, whether express or implied; without even the implied warranty
> + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + */
> +
> +#ifndef _LINUX_PM_WAKEIRQ_H
> +#define _LINUX_PM_WAKEIRQ_H
> +
> +#ifdef CONFIG_PM
> +
> +extern int dev_pm_set_wake_irq(struct device *dev, int irq);
> +extern int dev_pm_set_dedicated_wake_irq(struct device *dev,
> + int irq);
> +extern void dev_pm_clear_wake_irq(struct device *dev);
> +extern void dev_pm_enable_wake_irq(struct device *dev);
> +extern void dev_pm_disable_wake_irq(struct device *dev);
> +
> +#else /* !CONFIG_PM */
> +
> +static inline int dev_pm_set_wake_irq(struct device *dev, int irq)
> +{
> + return 0;
> +}
> +
> +static inline int dev_pm_set_dedicated__wake_irq(struct device *dev,
> + int irq)
> +{
> + return 0;
> +}
> +
> +static inline void dev_pm_clear_wake_irq(struct device *dev)
> +{
> +}
> +
> +static inline void dev_pm_enable_wake_irq(struct device *dev)
> +{
> +}
> +
> +static inline void dev_pm_disable_wake_irq(struct device *dev)
> +{
> +}
> +
> +#endif /* CONFIG_PM */
> +#endif /* _LINUX_PM_WAKEIRQ_H */
> diff --git a/include/linux/pm_wakeup.h b/include/linux/pm_wakeup.h
> index a0f7080..a344793 100644
> --- a/include/linux/pm_wakeup.h
> +++ b/include/linux/pm_wakeup.h
> @@ -28,9 +28,17 @@
>
> #include <linux/types.h>
>
> +struct wake_irq;
> +
> /**
> * struct wakeup_source - Representation of wakeup sources
> *
> + * @name: Name of the wakeup source
> + * @entry: Wakeup source list entry
> + * @lock: Wakeup source lock
> + * @wakeirq: Optional device specific wakeirq
> + * @timer: Wakeup timer list
> + * @timer_expires: Wakeup timer expiration
> * @total_time: Total time this wakeup source has been active.
> * @max_time: Maximum time this wakeup source has been continuously active.
> * @last_time: Monotonic clock when the wakeup source's was touched last time.
> @@ -47,6 +55,7 @@ struct wakeup_source {
> const char *name;
> struct list_head entry;
> spinlock_t lock;
> + struct wake_irq *wakeirq;
> struct timer_list timer;
> unsigned long timer_expires;
> ktime_t total_time;
--
I speak only for myself.
Rafael J. Wysocki, Intel Open Source Technology Center.
--
To unsubscribe from this list: send the line "unsubscribe linux-serial" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
