2009-03-16 15:33:49 -06:00
|
|
|
/*
|
|
|
|
* linux/kernel/irq/pm.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
|
|
|
|
*
|
|
|
|
* This file contains power management functions related to interrupts.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/irq.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/interrupt.h>
|
2014-08-29 06:00:16 -06:00
|
|
|
#include <linux/suspend.h>
|
2011-10-03 08:37:00 -06:00
|
|
|
#include <linux/syscore_ops.h>
|
2009-03-16 15:33:49 -06:00
|
|
|
|
|
|
|
#include "internals.h"
|
|
|
|
|
2014-08-29 06:00:16 -06:00
|
|
|
bool irq_pm_check_wakeup(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
if (irqd_is_wakeup_armed(&desc->irq_data)) {
|
|
|
|
irqd_clear(&desc->irq_data, IRQD_WAKEUP_ARMED);
|
|
|
|
desc->istate |= IRQS_SUSPENDED | IRQS_PENDING;
|
|
|
|
desc->depth++;
|
|
|
|
irq_disable(desc);
|
|
|
|
pm_system_wakeup();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-08-28 03:44:31 -06:00
|
|
|
/*
|
|
|
|
* Called from __setup_irq() with desc->lock held after @action has
|
|
|
|
* been installed in the action chain.
|
|
|
|
*/
|
|
|
|
void irq_pm_install_action(struct irq_desc *desc, struct irqaction *action)
|
|
|
|
{
|
|
|
|
desc->nr_actions++;
|
|
|
|
|
|
|
|
if (action->flags & IRQF_FORCE_RESUME)
|
|
|
|
desc->force_resume_depth++;
|
|
|
|
|
|
|
|
WARN_ON_ONCE(desc->force_resume_depth &&
|
|
|
|
desc->force_resume_depth != desc->nr_actions);
|
|
|
|
|
|
|
|
if (action->flags & IRQF_NO_SUSPEND)
|
|
|
|
desc->no_suspend_depth++;
|
genirq / PM: Add flag for shared NO_SUSPEND interrupt lines
It currently is required that all users of NO_SUSPEND interrupt
lines pass the IRQF_NO_SUSPEND flag when requesting the IRQ or the
WARN_ON_ONCE() in irq_pm_install_action() will trigger. That is
done to warn about situations in which unprepared interrupt handlers
may be run unnecessarily for suspended devices and may attempt to
access those devices by mistake. However, it may cause drivers
that have no technical reasons for using IRQF_NO_SUSPEND to set
that flag just because they happen to share the interrupt line
with something like a timer.
Moreover, the generic handling of wakeup interrupts introduced by
commit 9ce7a25849e8 (genirq: Simplify wakeup mechanism) only works
for IRQs without any NO_SUSPEND users, so the drivers of wakeup
devices needing to use shared NO_SUSPEND interrupt lines for
signaling system wakeup generally have to detect wakeup in their
interrupt handlers. Thus if they happen to share an interrupt line
with a NO_SUSPEND user, they also need to request that their
interrupt handlers be run after suspend_device_irqs().
In both cases the reason for using IRQF_NO_SUSPEND is not because
the driver in question has a genuine need to run its interrupt
handler after suspend_device_irqs(), but because it happens to
share the line with some other NO_SUSPEND user. Otherwise, the
driver would do without IRQF_NO_SUSPEND just fine.
To make it possible to specify that condition explicitly, introduce
a new IRQ action handler flag for shared IRQs, IRQF_COND_SUSPEND,
that, when set, will indicate to the IRQ core that the interrupt
user is generally fine with suspending the IRQ, but it also can
tolerate handler invocations after suspend_device_irqs() and, in
particular, it is capable of detecting system wakeup and triggering
it as appropriate from its interrupt handler.
That will allow us to work around a problem with a shared timer
interrupt line on at91 platforms.
Link: http://marc.info/?l=linux-kernel&m=142252777602084&w=2
Link: http://marc.info/?t=142252775300011&r=1&w=2
Link: https://lkml.org/lkml/2014/12/15/552
Reported-by: Boris Brezillon <boris.brezillon@free-electrons.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Mark Rutland <mark.rutland@arm.com>
2015-02-26 16:07:55 -07:00
|
|
|
else if (action->flags & IRQF_COND_SUSPEND)
|
|
|
|
desc->cond_suspend_depth++;
|
2014-08-28 03:44:31 -06:00
|
|
|
|
|
|
|
WARN_ON_ONCE(desc->no_suspend_depth &&
|
genirq / PM: Add flag for shared NO_SUSPEND interrupt lines
It currently is required that all users of NO_SUSPEND interrupt
lines pass the IRQF_NO_SUSPEND flag when requesting the IRQ or the
WARN_ON_ONCE() in irq_pm_install_action() will trigger. That is
done to warn about situations in which unprepared interrupt handlers
may be run unnecessarily for suspended devices and may attempt to
access those devices by mistake. However, it may cause drivers
that have no technical reasons for using IRQF_NO_SUSPEND to set
that flag just because they happen to share the interrupt line
with something like a timer.
Moreover, the generic handling of wakeup interrupts introduced by
commit 9ce7a25849e8 (genirq: Simplify wakeup mechanism) only works
for IRQs without any NO_SUSPEND users, so the drivers of wakeup
devices needing to use shared NO_SUSPEND interrupt lines for
signaling system wakeup generally have to detect wakeup in their
interrupt handlers. Thus if they happen to share an interrupt line
with a NO_SUSPEND user, they also need to request that their
interrupt handlers be run after suspend_device_irqs().
In both cases the reason for using IRQF_NO_SUSPEND is not because
the driver in question has a genuine need to run its interrupt
handler after suspend_device_irqs(), but because it happens to
share the line with some other NO_SUSPEND user. Otherwise, the
driver would do without IRQF_NO_SUSPEND just fine.
To make it possible to specify that condition explicitly, introduce
a new IRQ action handler flag for shared IRQs, IRQF_COND_SUSPEND,
that, when set, will indicate to the IRQ core that the interrupt
user is generally fine with suspending the IRQ, but it also can
tolerate handler invocations after suspend_device_irqs() and, in
particular, it is capable of detecting system wakeup and triggering
it as appropriate from its interrupt handler.
That will allow us to work around a problem with a shared timer
interrupt line on at91 platforms.
Link: http://marc.info/?l=linux-kernel&m=142252777602084&w=2
Link: http://marc.info/?t=142252775300011&r=1&w=2
Link: https://lkml.org/lkml/2014/12/15/552
Reported-by: Boris Brezillon <boris.brezillon@free-electrons.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Mark Rutland <mark.rutland@arm.com>
2015-02-26 16:07:55 -07:00
|
|
|
(desc->no_suspend_depth +
|
|
|
|
desc->cond_suspend_depth) != desc->nr_actions);
|
2014-08-28 03:44:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called from __free_irq() with desc->lock held after @action has
|
|
|
|
* been removed from the action chain.
|
|
|
|
*/
|
|
|
|
void irq_pm_remove_action(struct irq_desc *desc, struct irqaction *action)
|
|
|
|
{
|
|
|
|
desc->nr_actions--;
|
|
|
|
|
|
|
|
if (action->flags & IRQF_FORCE_RESUME)
|
|
|
|
desc->force_resume_depth--;
|
|
|
|
|
|
|
|
if (action->flags & IRQF_NO_SUSPEND)
|
|
|
|
desc->no_suspend_depth--;
|
genirq / PM: Add flag for shared NO_SUSPEND interrupt lines
It currently is required that all users of NO_SUSPEND interrupt
lines pass the IRQF_NO_SUSPEND flag when requesting the IRQ or the
WARN_ON_ONCE() in irq_pm_install_action() will trigger. That is
done to warn about situations in which unprepared interrupt handlers
may be run unnecessarily for suspended devices and may attempt to
access those devices by mistake. However, it may cause drivers
that have no technical reasons for using IRQF_NO_SUSPEND to set
that flag just because they happen to share the interrupt line
with something like a timer.
Moreover, the generic handling of wakeup interrupts introduced by
commit 9ce7a25849e8 (genirq: Simplify wakeup mechanism) only works
for IRQs without any NO_SUSPEND users, so the drivers of wakeup
devices needing to use shared NO_SUSPEND interrupt lines for
signaling system wakeup generally have to detect wakeup in their
interrupt handlers. Thus if they happen to share an interrupt line
with a NO_SUSPEND user, they also need to request that their
interrupt handlers be run after suspend_device_irqs().
In both cases the reason for using IRQF_NO_SUSPEND is not because
the driver in question has a genuine need to run its interrupt
handler after suspend_device_irqs(), but because it happens to
share the line with some other NO_SUSPEND user. Otherwise, the
driver would do without IRQF_NO_SUSPEND just fine.
To make it possible to specify that condition explicitly, introduce
a new IRQ action handler flag for shared IRQs, IRQF_COND_SUSPEND,
that, when set, will indicate to the IRQ core that the interrupt
user is generally fine with suspending the IRQ, but it also can
tolerate handler invocations after suspend_device_irqs() and, in
particular, it is capable of detecting system wakeup and triggering
it as appropriate from its interrupt handler.
That will allow us to work around a problem with a shared timer
interrupt line on at91 platforms.
Link: http://marc.info/?l=linux-kernel&m=142252777602084&w=2
Link: http://marc.info/?t=142252775300011&r=1&w=2
Link: https://lkml.org/lkml/2014/12/15/552
Reported-by: Boris Brezillon <boris.brezillon@free-electrons.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Acked-by: Mark Rutland <mark.rutland@arm.com>
2015-02-26 16:07:55 -07:00
|
|
|
else if (action->flags & IRQF_COND_SUSPEND)
|
|
|
|
desc->cond_suspend_depth--;
|
2014-08-28 03:44:31 -06:00
|
|
|
}
|
|
|
|
|
2014-08-28 14:50:43 -06:00
|
|
|
static bool suspend_device_irq(struct irq_desc *desc, int irq)
|
2014-08-28 03:49:28 -06:00
|
|
|
{
|
2014-08-28 07:48:59 -06:00
|
|
|
if (!desc->action || desc->no_suspend_depth)
|
2014-08-28 14:50:43 -06:00
|
|
|
return false;
|
2014-08-28 03:49:28 -06:00
|
|
|
|
2014-08-29 06:00:16 -06:00
|
|
|
if (irqd_is_wakeup_set(&desc->irq_data)) {
|
2014-08-29 05:54:09 -06:00
|
|
|
irqd_set(&desc->irq_data, IRQD_WAKEUP_ARMED);
|
2014-08-29 06:00:16 -06:00
|
|
|
/*
|
|
|
|
* We return true here to force the caller to issue
|
|
|
|
* synchronize_irq(). We need to make sure that the
|
|
|
|
* IRQD_WAKEUP_ARMED is visible before we return from
|
|
|
|
* suspend_device_irqs().
|
|
|
|
*/
|
|
|
|
return true;
|
|
|
|
}
|
2014-08-29 05:54:09 -06:00
|
|
|
|
2014-08-28 03:49:28 -06:00
|
|
|
desc->istate |= IRQS_SUSPENDED;
|
2015-06-23 11:52:36 -06:00
|
|
|
__disable_irq(desc);
|
2014-08-28 08:49:43 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Hardware which has no wakeup source configuration facility
|
|
|
|
* requires that the non wakeup interrupts are masked at the
|
|
|
|
* chip level. The chip implementation indicates that with
|
|
|
|
* IRQCHIP_MASK_ON_SUSPEND.
|
|
|
|
*/
|
|
|
|
if (irq_desc_get_chip(desc)->flags & IRQCHIP_MASK_ON_SUSPEND)
|
|
|
|
mask_irq(desc);
|
2014-08-28 14:50:43 -06:00
|
|
|
return true;
|
2014-08-28 03:49:28 -06:00
|
|
|
}
|
|
|
|
|
2009-03-16 15:33:49 -06:00
|
|
|
/**
|
|
|
|
* suspend_device_irqs - disable all currently enabled interrupt lines
|
|
|
|
*
|
2014-08-28 03:49:28 -06:00
|
|
|
* During system-wide suspend or hibernation device drivers need to be
|
|
|
|
* prevented from receiving interrupts and this function is provided
|
|
|
|
* for this purpose.
|
|
|
|
*
|
|
|
|
* So we disable all interrupts and mark them IRQS_SUSPENDED except
|
2014-08-29 06:00:16 -06:00
|
|
|
* for those which are unused, those which are marked as not
|
2014-08-28 03:49:28 -06:00
|
|
|
* suspendable via an interrupt request with the flag IRQF_NO_SUSPEND
|
2014-08-29 06:00:16 -06:00
|
|
|
* set and those which are marked as active wakeup sources.
|
|
|
|
*
|
|
|
|
* The active wakeup sources are handled by the flow handler entry
|
|
|
|
* code which checks for the IRQD_WAKEUP_ARMED flag, suspends the
|
|
|
|
* interrupt and notifies the pm core about the wakeup.
|
2009-03-16 15:33:49 -06:00
|
|
|
*/
|
|
|
|
void suspend_device_irqs(void)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc;
|
|
|
|
int irq;
|
|
|
|
|
|
|
|
for_each_irq_desc(irq, desc) {
|
|
|
|
unsigned long flags;
|
2014-08-28 14:50:43 -06:00
|
|
|
bool sync;
|
2009-03-16 15:33:49 -06:00
|
|
|
|
2015-05-16 23:19:34 -06:00
|
|
|
if (irq_settings_is_nested_thread(desc))
|
|
|
|
continue;
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
2014-08-28 14:50:43 -06:00
|
|
|
sync = suspend_device_irq(desc, irq);
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
2009-03-16 15:33:49 -06:00
|
|
|
|
2014-08-28 14:50:43 -06:00
|
|
|
if (sync)
|
2009-03-16 15:33:49 -06:00
|
|
|
synchronize_irq(irq);
|
2014-08-28 14:50:43 -06:00
|
|
|
}
|
2009-03-16 15:33:49 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(suspend_device_irqs);
|
|
|
|
|
2014-08-28 03:49:28 -06:00
|
|
|
static void resume_irq(struct irq_desc *desc, int irq)
|
|
|
|
{
|
2014-08-29 05:54:09 -06:00
|
|
|
irqd_clear(&desc->irq_data, IRQD_WAKEUP_ARMED);
|
|
|
|
|
2014-08-28 03:49:28 -06:00
|
|
|
if (desc->istate & IRQS_SUSPENDED)
|
|
|
|
goto resume;
|
|
|
|
|
2014-08-28 07:48:59 -06:00
|
|
|
/* Force resume the interrupt? */
|
|
|
|
if (!desc->force_resume_depth)
|
2014-08-28 03:49:28 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* Pretend that it got disabled ! */
|
|
|
|
desc->depth++;
|
|
|
|
resume:
|
|
|
|
desc->istate &= ~IRQS_SUSPENDED;
|
2015-06-23 11:52:36 -06:00
|
|
|
__enable_irq(desc);
|
2014-08-28 03:49:28 -06:00
|
|
|
}
|
|
|
|
|
2011-10-03 08:37:00 -06:00
|
|
|
static void resume_irqs(bool want_early)
|
2009-03-16 15:33:49 -06:00
|
|
|
{
|
|
|
|
struct irq_desc *desc;
|
|
|
|
int irq;
|
|
|
|
|
|
|
|
for_each_irq_desc(irq, desc) {
|
|
|
|
unsigned long flags;
|
2011-10-03 08:37:00 -06:00
|
|
|
bool is_early = desc->action &&
|
|
|
|
desc->action->flags & IRQF_EARLY_RESUME;
|
|
|
|
|
2013-11-25 07:09:47 -07:00
|
|
|
if (!is_early && want_early)
|
2011-10-03 08:37:00 -06:00
|
|
|
continue;
|
2015-05-16 23:19:34 -06:00
|
|
|
if (irq_settings_is_nested_thread(desc))
|
|
|
|
continue;
|
2009-03-16 15:33:49 -06:00
|
|
|
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
2014-08-28 03:49:28 -06:00
|
|
|
resume_irq(desc, irq);
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
2009-03-16 15:33:49 -06:00
|
|
|
}
|
|
|
|
}
|
2011-10-03 08:37:00 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_pm_syscore_ops - enable interrupt lines early
|
|
|
|
*
|
|
|
|
* Enable all interrupt lines with %IRQF_EARLY_RESUME set.
|
|
|
|
*/
|
|
|
|
static void irq_pm_syscore_resume(void)
|
|
|
|
{
|
|
|
|
resume_irqs(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct syscore_ops irq_pm_syscore_ops = {
|
|
|
|
.resume = irq_pm_syscore_resume,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init irq_pm_init_ops(void)
|
|
|
|
{
|
|
|
|
register_syscore_ops(&irq_pm_syscore_ops);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
device_initcall(irq_pm_init_ops);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* resume_device_irqs - enable interrupt lines disabled by suspend_device_irqs()
|
|
|
|
*
|
|
|
|
* Enable all non-%IRQF_EARLY_RESUME interrupt lines previously
|
|
|
|
* disabled by suspend_device_irqs() that have the IRQS_SUSPENDED flag
|
|
|
|
* set as well as those with %IRQF_FORCE_RESUME.
|
|
|
|
*/
|
|
|
|
void resume_device_irqs(void)
|
|
|
|
{
|
|
|
|
resume_irqs(false);
|
|
|
|
}
|
2009-03-16 15:33:49 -06:00
|
|
|
EXPORT_SYMBOL_GPL(resume_device_irqs);
|