Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 03f408a1 authored by Chunfeng Yun's avatar Chunfeng Yun Committed by Greg Kroah-Hartman
Browse files

PM / wakeirq: support enabling wake-up irq after runtime_suspend called 



[ Upstream commit 259714100d98b50bf04d36a21bf50ca8b829fc11 ]

When the dedicated wake IRQ is level trigger, and it uses the
device's low-power status as the wakeup source, that means if the
device is not in low-power state, the wake IRQ will be triggered
if enabled; For this case, need enable the wake IRQ after running
the device's ->runtime_suspend() which make it enter low-power state.

e.g.
Assume the wake IRQ is a low level trigger type, and the wakeup
signal comes from the low-power status of the device.
The wakeup signal is low level at running time (0), and becomes
high level when the device enters low-power state (runtime_suspend
(1) is called), a wakeup event at (2) make the device exit low-power
state, then the wakeup signal also becomes low level.

                ------------------
               |           ^     ^|
----------------           |     | --------------
 |<---(0)--->|<--(1)--|   (3)   (2)    (4)

if enable the wake IRQ before running runtime_suspend during (0),
a wake IRQ will arise, it causes resume immediately;
it works if enable wake IRQ ( e.g. at (3) or (4)) after running
->runtime_suspend().

This patch introduces a new status WAKE_IRQ_DEDICATED_REVERSE to
optionally support enabling wake IRQ after running ->runtime_suspend().

Suggested-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
Signed-off-by: default avatarChunfeng Yun <chunfeng.yun@mediatek.com>
Signed-off-by: default avatarRafael J. Wysocki <rafael.j.wysocki@intel.com>
Stable-dep-of: 8527beb12087 ("PM: sleep: wakeirq: fix wake irq arming")
Signed-off-by: default avatarSasha Levin <sashal@kernel.org>
parent 8e8f05cd

drivers/base/power/power.h

+5 −2
Original line number Original line Diff line number Diff line
@@ -24,8 +24,10 @@ extern void pm_runtime_remove(struct device *dev); 




#define WAKE_IRQ_DEDICATED_ALLOCATED	BIT(0)

#define WAKE_IRQ_DEDICATED_ALLOCATED	BIT(0)

#define WAKE_IRQ_DEDICATED_MANAGED	BIT(1)

#define WAKE_IRQ_DEDICATED_MANAGED	BIT(1)

#define WAKE_IRQ_DEDICATED_REVERSE	BIT(2)

#define WAKE_IRQ_DEDICATED_MASK		(WAKE_IRQ_DEDICATED_ALLOCATED | \

#define WAKE_IRQ_DEDICATED_MASK		(WAKE_IRQ_DEDICATED_ALLOCATED | \

					 WAKE_IRQ_DEDICATED_MANAGED)

					 WAKE_IRQ_DEDICATED_MANAGED | \

					 WAKE_IRQ_DEDICATED_REVERSE)





struct wake_irq {

struct wake_irq {

	struct device *dev;

	struct device *dev;
@@ -38,7 +40,8 @@ extern void dev_pm_arm_wake_irq(struct wake_irq *wirq); 
extern void dev_pm_disarm_wake_irq(struct wake_irq *wirq);

extern void dev_pm_disarm_wake_irq(struct wake_irq *wirq);

extern void dev_pm_enable_wake_irq_check(struct device *dev,

extern void dev_pm_enable_wake_irq_check(struct device *dev,

					 bool can_change_status);

					 bool can_change_status);

extern void dev_pm_disable_wake_irq_check(struct device *dev);

extern void dev_pm_disable_wake_irq_check(struct device *dev, bool cond_disable);

extern void dev_pm_enable_wake_irq_complete(struct device *dev);





#ifdef CONFIG_PM_SLEEP

#ifdef CONFIG_PM_SLEEP

drivers/base/power/runtime.c

+4 −2
Original line number Original line Diff line number Diff line
@@ -606,6 +606,8 @@ static int rpm_suspend(struct device *dev, int rpmflags) 
	if (retval)

	if (retval)

		goto fail;

		goto fail;





	dev_pm_enable_wake_irq_complete(dev);



 no_callback:

 no_callback:

	__update_runtime_status(dev, RPM_SUSPENDED);

	__update_runtime_status(dev, RPM_SUSPENDED);

	pm_runtime_deactivate_timer(dev);

	pm_runtime_deactivate_timer(dev);
@@ -640,7 +642,7 @@ static int rpm_suspend(struct device *dev, int rpmflags) 
	return retval;

	return retval;





 fail:

 fail:

	dev_pm_disable_wake_irq_check(dev);

	dev_pm_disable_wake_irq_check(dev, true);

	__update_runtime_status(dev, RPM_ACTIVE);

	__update_runtime_status(dev, RPM_ACTIVE);

	dev->power.deferred_resume = false;

	dev->power.deferred_resume = false;

	wake_up_all(&dev->power.wait_queue);

	wake_up_all(&dev->power.wait_queue);
@@ -823,7 +825,7 @@ static int rpm_resume(struct device *dev, int rpmflags) 




	callback = RPM_GET_CALLBACK(dev, runtime_resume);

	callback = RPM_GET_CALLBACK(dev, runtime_resume);





	dev_pm_disable_wake_irq_check(dev);

	dev_pm_disable_wake_irq_check(dev, false);

	retval = rpm_callback(callback, dev);

	retval = rpm_callback(callback, dev);

	if (retval) {

	if (retval) {

		__update_runtime_status(dev, RPM_SUSPENDED);

		__update_runtime_status(dev, RPM_SUSPENDED);

drivers/base/power/wakeirq.c

+80 −21
Original line number Original line Diff line number Diff line
@@ -156,24 +156,7 @@ static irqreturn_t handle_threaded_wake_irq(int irq, void *_wirq) 
	return IRQ_HANDLED;

	return IRQ_HANDLED;

}

}





/**

static int __dev_pm_set_dedicated_wake_irq(struct device *dev, int irq, unsigned int flag)

 * 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;

	struct wake_irq *wirq;

	int err;

	int err;
@@ -211,7 +194,7 @@ int dev_pm_set_dedicated_wake_irq(struct device *dev, int irq) 
	if (err)

	if (err)

		goto err_free_irq;

		goto err_free_irq;





	wirq->status = WAKE_IRQ_DEDICATED_ALLOCATED;

	wirq->status = WAKE_IRQ_DEDICATED_ALLOCATED | flag;





	return err;

	return err;
@@ -224,8 +207,57 @@ int dev_pm_set_dedicated_wake_irq(struct device *dev, int irq) 




	return err;

	return err;

}

}





/**

 * 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)

{

	return __dev_pm_set_dedicated_wake_irq(dev, irq, 0);

}

EXPORT_SYMBOL_GPL(dev_pm_set_dedicated_wake_irq);

EXPORT_SYMBOL_GPL(dev_pm_set_dedicated_wake_irq);





/**

 * dev_pm_set_dedicated_wake_irq_reverse - Request a dedicated wake-up interrupt

 *                                         with reverse enable ordering

 * @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. It sets

 * the status of WAKE_IRQ_DEDICATED_REVERSE to tell rpm_suspend()

 * to enable dedicated wake-up interrupt after running the runtime suspend

 * callback for @dev.

 *

 * 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_reverse(struct device *dev, int irq)

{

	return __dev_pm_set_dedicated_wake_irq(dev, irq, WAKE_IRQ_DEDICATED_REVERSE);

}

EXPORT_SYMBOL_GPL(dev_pm_set_dedicated_wake_irq_reverse);



/**

/**

 * dev_pm_enable_wake_irq - Enable device wake-up interrupt

 * dev_pm_enable_wake_irq - Enable device wake-up interrupt

 * @dev: Device

 * @dev: Device
@@ -296,27 +328,54 @@ void dev_pm_enable_wake_irq_check(struct device *dev, 
	return;

	return;





enable:

enable:

	if (!can_change_status || !(wirq->status & WAKE_IRQ_DEDICATED_REVERSE))

		enable_irq(wirq->irq);

		enable_irq(wirq->irq);

}

}





/**

/**

 * dev_pm_disable_wake_irq_check - Checks and disables wake-up interrupt

 * dev_pm_disable_wake_irq_check - Checks and disables wake-up interrupt

 * @dev: Device

 * @dev: Device

 * @cond_disable: if set, also check WAKE_IRQ_DEDICATED_REVERSE

 *

 *

 * Disables wake-up interrupt conditionally based on status.

 * Disables wake-up interrupt conditionally based on status.

 * Should be only called from rpm_suspend() and rpm_resume() path.

 * Should be only called from rpm_suspend() and rpm_resume() path.

 */

 */

void dev_pm_disable_wake_irq_check(struct device *dev)

void dev_pm_disable_wake_irq_check(struct device *dev, bool cond_disable)

{

{

	struct wake_irq *wirq = dev->power.wakeirq;

	struct wake_irq *wirq = dev->power.wakeirq;





	if (!wirq || !((wirq->status & WAKE_IRQ_DEDICATED_MASK)))

	if (!wirq || !((wirq->status & WAKE_IRQ_DEDICATED_MASK)))

		return;

		return;





	if (cond_disable && (wirq->status & WAKE_IRQ_DEDICATED_REVERSE))

		return;



	if (wirq->status & WAKE_IRQ_DEDICATED_MANAGED)

	if (wirq->status & WAKE_IRQ_DEDICATED_MANAGED)

		disable_irq_nosync(wirq->irq);

		disable_irq_nosync(wirq->irq);

}

}





/**

 * dev_pm_enable_wake_irq_complete - enable wake IRQ not enabled before

 * @dev: Device using the wake IRQ

 *

 * Enable wake IRQ conditionally based on status, mainly used if want to

 * enable wake IRQ after running ->runtime_suspend() which depends on

 * WAKE_IRQ_DEDICATED_REVERSE.

 *

 * Should be only called from rpm_suspend() path.

 */

void dev_pm_enable_wake_irq_complete(struct device *dev)

{

	struct wake_irq *wirq = dev->power.wakeirq;



	if (!wirq || !(wirq->status & WAKE_IRQ_DEDICATED_MASK))

		return;



	if (wirq->status & WAKE_IRQ_DEDICATED_MANAGED &&

	    wirq->status & WAKE_IRQ_DEDICATED_REVERSE)

		enable_irq(wirq->irq);

}



/**

/**

 * dev_pm_arm_wake_irq - Arm device wake-up

 * dev_pm_arm_wake_irq - Arm device wake-up

 * @wirq: Device wake-up interrupt

 * @wirq: Device wake-up interrupt

include/linux/pm_wakeirq.h

+7 −2
Original line number Original line Diff line number Diff line
@@ -17,8 +17,8 @@ 
#ifdef CONFIG_PM

#ifdef CONFIG_PM





extern int dev_pm_set_wake_irq(struct device *dev, int irq);

extern int dev_pm_set_wake_irq(struct device *dev, int irq);

extern int dev_pm_set_dedicated_wake_irq(struct device *dev,

extern int dev_pm_set_dedicated_wake_irq(struct device *dev, int irq);

					 int irq);

extern int dev_pm_set_dedicated_wake_irq_reverse(struct device *dev, int irq);

extern void dev_pm_clear_wake_irq(struct device *dev);

extern void dev_pm_clear_wake_irq(struct device *dev);

extern void dev_pm_enable_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);

extern void dev_pm_disable_wake_irq(struct device *dev);
@@ -35,6 +35,11 @@ static inline int dev_pm_set_dedicated_wake_irq(struct device *dev, int irq) 
	return 0;

	return 0;

}

}





static inline int dev_pm_set_dedicated_wake_irq_reverse(struct device *dev, int irq)

{

	return 0;

}



static inline void dev_pm_clear_wake_irq(struct device *dev)

static inline void dev_pm_clear_wake_irq(struct device *dev)

{

{

}

}