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

Commit 79d22364 authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

Merge branch 'irq-pm' 

* irq-pm:
  genirq / PM: describe IRQF_COND_SUSPEND
  tty: serial: atmel: rework interrupt and wakeup handling
  watchdog: at91sam9: request the irq with IRQF_NO_SUSPEND
  clk: at91: implement suspend/resume for the PMC irqchip
  rtc: at91rm9200: rework wakeup and interrupt handling
  rtc: at91sam9: rework wakeup and interrupt handling
  PM / wakeup: export pm_system_wakeup symbol
  genirq / PM: Add flag for shared NO_SUSPEND interrupt lines
  genirq / PM: better describe IRQF_NO_SUSPEND semantics
parents eef16e43 7438b633

Documentation/power/suspend-and-interrupts.txt

+17 −5
Original line number Diff line number Diff line
@@ -40,8 +40,10 @@ but also to IPIs and to some other special-purpose interrupts. 


The IRQF_NO_SUSPEND flag is used to indicate that to the IRQ subsystem when

requesting a special-purpose interrupt.  It causes suspend_device_irqs() to

leave the corresponding IRQ enabled so as to allow the interrupt to work all

the time as expected.

leave the corresponding IRQ enabled so as to allow the interrupt to work as

expected during the suspend-resume cycle, but does not guarantee that the

interrupt will wake the system from a suspended state -- for such cases it is

necessary to use enable_irq_wake().



Note that the IRQF_NO_SUSPEND flag affects the entire IRQ and not just one

user of it.  Thus, if the IRQ is shared, all of the interrupt handlers installed
@@ -110,8 +112,9 @@ any special interrupt handling logic for it to work. 
IRQF_NO_SUSPEND and enable_irq_wake()

-------------------------------------



There are no valid reasons to use both enable_irq_wake() and the IRQF_NO_SUSPEND

flag on the same IRQ.

There are very few valid reasons to use both enable_irq_wake() and the

IRQF_NO_SUSPEND flag on the same IRQ, and it is never valid to use both for the

same device.



First of all, if the IRQ is not shared, the rules for handling IRQF_NO_SUSPEND

interrupts (interrupt handlers are invoked after suspend_device_irqs()) are
@@ -120,4 +123,13 @@ handlers are not invoked after suspend_device_irqs()). 


Second, both enable_irq_wake() and IRQF_NO_SUSPEND apply to entire IRQs and not

to individual interrupt handlers, so sharing an IRQ between a system wakeup

interrupt source and an IRQF_NO_SUSPEND interrupt source does not make sense.
 
interrupt source and an IRQF_NO_SUSPEND interrupt source does not generally

make sense.



In rare cases an IRQ can be shared between a wakeup device driver and an

IRQF_NO_SUSPEND user. In order for this to be safe, the wakeup device driver

must be able to discern spurious IRQs from genuine wakeup events (signalling

the latter to the core with pm_system_wakeup()), must use enable_irq_wake() to

ensure that the IRQ will function as a wakeup source, and must request the IRQ

with IRQF_COND_SUSPEND to tell the core that it meets these requirements. If

these requirements are not met, it is not valid to use IRQF_COND_SUSPEND.

drivers/base/power/wakeup.c

+1 −0
Original line number Diff line number Diff line
@@ -730,6 +730,7 @@ void pm_system_wakeup(void) 
	pm_abort_suspend = true;

	freeze_wake();

}

EXPORT_SYMBOL_GPL(pm_system_wakeup);



void pm_wakeup_clear(void)

{

drivers/clk/at91/pmc.c

+19 −1
Original line number Diff line number Diff line
@@ -89,12 +89,29 @@ static int pmc_irq_set_type(struct irq_data *d, unsigned type) 
	return 0;

}



static void pmc_irq_suspend(struct irq_data *d)

{

	struct at91_pmc *pmc = irq_data_get_irq_chip_data(d);



	pmc->imr = pmc_read(pmc, AT91_PMC_IMR);

	pmc_write(pmc, AT91_PMC_IDR, pmc->imr);

}



static void pmc_irq_resume(struct irq_data *d)

{

	struct at91_pmc *pmc = irq_data_get_irq_chip_data(d);



	pmc_write(pmc, AT91_PMC_IER, pmc->imr);

}



static struct irq_chip pmc_irq = {

	.name = "PMC",

	.irq_disable = pmc_irq_mask,

	.irq_mask = pmc_irq_mask,

	.irq_unmask = pmc_irq_unmask,

	.irq_set_type = pmc_irq_set_type,

	.irq_suspend = pmc_irq_suspend,

	.irq_resume = pmc_irq_resume,

};



static struct lock_class_key pmc_lock_class;
@@ -224,7 +241,8 @@ static struct at91_pmc *__init at91_pmc_init(struct device_node *np, 
		goto out_free_pmc;



	pmc_write(pmc, AT91_PMC_IDR, 0xffffffff);

	if (request_irq(pmc->virq, pmc_irq_handler, IRQF_SHARED, "pmc", pmc))

	if (request_irq(pmc->virq, pmc_irq_handler,

			IRQF_SHARED | IRQF_COND_SUSPEND, "pmc", pmc))

		goto out_remove_irqdomain;



	return pmc;

drivers/clk/at91/pmc.h

+1 −0
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ struct at91_pmc { 
	spinlock_t lock;

	const struct at91_pmc_caps *caps;

	struct irq_domain *irqdomain;

	u32 imr;

};



static inline void pmc_lock(struct at91_pmc *pmc)

drivers/rtc/rtc-at91rm9200.c

+48 −14
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ 
#include <linux/io.h>

#include <linux/of.h>

#include <linux/of_device.h>

#include <linux/suspend.h>

#include <linux/uaccess.h>



#include "rtc-at91rm9200.h"
@@ -54,6 +55,10 @@ static void __iomem *at91_rtc_regs; 
static int irq;

static DEFINE_SPINLOCK(at91_rtc_lock);

static u32 at91_rtc_shadow_imr;

static bool suspended;

static DEFINE_SPINLOCK(suspended_lock);

static unsigned long cached_events;

static u32 at91_rtc_imr;



static void at91_rtc_write_ier(u32 mask)

{
@@ -290,7 +295,9 @@ static irqreturn_t at91_rtc_interrupt(int irq, void *dev_id) 
	struct rtc_device *rtc = platform_get_drvdata(pdev);

	unsigned int rtsr;

	unsigned long events = 0;

	int ret = IRQ_NONE;



	spin_lock(&suspended_lock);

	rtsr = at91_rtc_read(AT91_RTC_SR) & at91_rtc_read_imr();

	if (rtsr) {		/* this interrupt is shared!  Is it ours? */

		if (rtsr & AT91_RTC_ALARM)
@@ -304,14 +311,22 @@ static irqreturn_t at91_rtc_interrupt(int irq, void *dev_id) 


		at91_rtc_write(AT91_RTC_SCCR, rtsr);	/* clear status reg */



		if (!suspended) {

			rtc_update_irq(rtc, 1, events);



		dev_dbg(&pdev->dev, "%s(): num=%ld, events=0x%02lx\n", __func__,

			events >> 8, events & 0x000000FF);

			dev_dbg(&pdev->dev, "%s(): num=%ld, events=0x%02lx\n",

				__func__, events >> 8, events & 0x000000FF);

		} else {

			cached_events |= events;

			at91_rtc_write_idr(at91_rtc_imr);

			pm_system_wakeup();

		}



		return IRQ_HANDLED;

		ret = IRQ_HANDLED;

	}

	return IRQ_NONE;		/* not handled */

	spin_lock(&suspended_lock);



	return ret;

}



static const struct at91_rtc_config at91rm9200_config = {
@@ -401,7 +416,7 @@ static int __init at91_rtc_probe(struct platform_device *pdev) 
					AT91_RTC_CALEV);



	ret = devm_request_irq(&pdev->dev, irq, at91_rtc_interrupt,

				IRQF_SHARED,

			       IRQF_SHARED | IRQF_COND_SUSPEND,

			       "at91_rtc", pdev);

	if (ret) {

		dev_err(&pdev->dev, "IRQ %d already in use.\n", irq);
@@ -454,8 +469,6 @@ static void at91_rtc_shutdown(struct platform_device *pdev) 


/* AT91RM9200 RTC Power management control */



static u32 at91_rtc_imr;



static int at91_rtc_suspend(struct device *dev)

{

	/* this IRQ is shared with DBGU and other hardware which isn't
@@ -464,20 +477,41 @@ static int at91_rtc_suspend(struct device *dev) 
	at91_rtc_imr = at91_rtc_read_imr()

			& (AT91_RTC_ALARM|AT91_RTC_SECEV);

	if (at91_rtc_imr) {

		if (device_may_wakeup(dev))

		if (device_may_wakeup(dev)) {

			unsigned long flags;



			enable_irq_wake(irq);

		else



			spin_lock_irqsave(&suspended_lock, flags);

			suspended = true;

			spin_unlock_irqrestore(&suspended_lock, flags);

		} else {

			at91_rtc_write_idr(at91_rtc_imr);

		}

	}

	return 0;

}



static int at91_rtc_resume(struct device *dev)

{

	struct rtc_device *rtc = dev_get_drvdata(dev);



	if (at91_rtc_imr) {

		if (device_may_wakeup(dev))

		if (device_may_wakeup(dev)) {

			unsigned long flags;



			spin_lock_irqsave(&suspended_lock, flags);



			if (cached_events) {

				rtc_update_irq(rtc, 1, cached_events);

				cached_events = 0;

			}



			suspended = false;

			spin_unlock_irqrestore(&suspended_lock, flags);



			disable_irq_wake(irq);

		else

		}

		at91_rtc_write_ier(at91_rtc_imr);

	}

	return 0;