1/*
2 * linux/kernel/irq/pm.c
3 *
4 * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
5 *
6 * This file contains power management functions related to interrupts.
7 */
8
9#include <linux/irq.h>
10#include <linux/module.h>
11#include <linux/interrupt.h>
12#include <linux/suspend.h>
13#include <linux/syscore_ops.h>
14
15#include "internals.h"
16
17bool irq_pm_check_wakeup(struct irq_desc *desc)
18{
19	if (irqd_is_wakeup_armed(&desc->irq_data)) {
20		irqd_clear(&desc->irq_data, IRQD_WAKEUP_ARMED);
21		desc->istate |= IRQS_SUSPENDED | IRQS_PENDING;
22		desc->depth++;
23		irq_disable(desc);
24		pm_system_wakeup();
25		return true;
26	}
27	return false;
28}
29
30/*
31 * Called from __setup_irq() with desc->lock held after @action has
32 * been installed in the action chain.
33 */
34void irq_pm_install_action(struct irq_desc *desc, struct irqaction *action)
35{
36	desc->nr_actions++;
37
38	if (action->flags & IRQF_FORCE_RESUME)
39		desc->force_resume_depth++;
40
41	WARN_ON_ONCE(desc->force_resume_depth &&
42		     desc->force_resume_depth != desc->nr_actions);
43
44	if (action->flags & IRQF_NO_SUSPEND)
45		desc->no_suspend_depth++;
46	else if (action->flags & IRQF_COND_SUSPEND)
47		desc->cond_suspend_depth++;
48
49	WARN_ON_ONCE(desc->no_suspend_depth &&
50		     (desc->no_suspend_depth +
51			desc->cond_suspend_depth) != desc->nr_actions);
52}
53
54/*
55 * Called from __free_irq() with desc->lock held after @action has
56 * been removed from the action chain.
57 */
58void irq_pm_remove_action(struct irq_desc *desc, struct irqaction *action)
59{
60	desc->nr_actions--;
61
62	if (action->flags & IRQF_FORCE_RESUME)
63		desc->force_resume_depth--;
64
65	if (action->flags & IRQF_NO_SUSPEND)
66		desc->no_suspend_depth--;
67	else if (action->flags & IRQF_COND_SUSPEND)
68		desc->cond_suspend_depth--;
69}
70
71static bool suspend_device_irq(struct irq_desc *desc, int irq)
72{
73	if (!desc->action || desc->no_suspend_depth)
74		return false;
75
76	if (irqd_is_wakeup_set(&desc->irq_data)) {
77		irqd_set(&desc->irq_data, IRQD_WAKEUP_ARMED);
78		/*
79		 * We return true here to force the caller to issue
80		 * synchronize_irq(). We need to make sure that the
81		 * IRQD_WAKEUP_ARMED is visible before we return from
82		 * suspend_device_irqs().
83		 */
84		return true;
85	}
86
87	desc->istate |= IRQS_SUSPENDED;
88	__disable_irq(desc, irq);
89
90	/*
91	 * Hardware which has no wakeup source configuration facility
92	 * requires that the non wakeup interrupts are masked at the
93	 * chip level. The chip implementation indicates that with
94	 * IRQCHIP_MASK_ON_SUSPEND.
95	 */
96	if (irq_desc_get_chip(desc)->flags & IRQCHIP_MASK_ON_SUSPEND)
97		mask_irq(desc);
98	return true;
99}
100
101/**
102 * suspend_device_irqs - disable all currently enabled interrupt lines
103 *
104 * During system-wide suspend or hibernation device drivers need to be
105 * prevented from receiving interrupts and this function is provided
106 * for this purpose.
107 *
108 * So we disable all interrupts and mark them IRQS_SUSPENDED except
109 * for those which are unused, those which are marked as not
110 * suspendable via an interrupt request with the flag IRQF_NO_SUSPEND
111 * set and those which are marked as active wakeup sources.
112 *
113 * The active wakeup sources are handled by the flow handler entry
114 * code which checks for the IRQD_WAKEUP_ARMED flag, suspends the
115 * interrupt and notifies the pm core about the wakeup.
116 */
117void suspend_device_irqs(void)
118{
119	struct irq_desc *desc;
120	int irq;
121
122	for_each_irq_desc(irq, desc) {
123		unsigned long flags;
124		bool sync;
125
126		raw_spin_lock_irqsave(&desc->lock, flags);
127		sync = suspend_device_irq(desc, irq);
128		raw_spin_unlock_irqrestore(&desc->lock, flags);
129
130		if (sync)
131			synchronize_irq(irq);
132	}
133}
134EXPORT_SYMBOL_GPL(suspend_device_irqs);
135
136static void resume_irq(struct irq_desc *desc, int irq)
137{
138	irqd_clear(&desc->irq_data, IRQD_WAKEUP_ARMED);
139
140	if (desc->istate & IRQS_SUSPENDED)
141		goto resume;
142
143	/* Force resume the interrupt? */
144	if (!desc->force_resume_depth)
145		return;
146
147	/* Pretend that it got disabled ! */
148	desc->depth++;
149resume:
150	desc->istate &= ~IRQS_SUSPENDED;
151	__enable_irq(desc, irq);
152}
153
154static void resume_irqs(bool want_early)
155{
156	struct irq_desc *desc;
157	int irq;
158
159	for_each_irq_desc(irq, desc) {
160		unsigned long flags;
161		bool is_early = desc->action &&
162			desc->action->flags & IRQF_EARLY_RESUME;
163
164		if (!is_early && want_early)
165			continue;
166
167		raw_spin_lock_irqsave(&desc->lock, flags);
168		resume_irq(desc, irq);
169		raw_spin_unlock_irqrestore(&desc->lock, flags);
170	}
171}
172
173/**
174 * irq_pm_syscore_ops - enable interrupt lines early
175 *
176 * Enable all interrupt lines with %IRQF_EARLY_RESUME set.
177 */
178static void irq_pm_syscore_resume(void)
179{
180	resume_irqs(true);
181}
182
183static struct syscore_ops irq_pm_syscore_ops = {
184	.resume		= irq_pm_syscore_resume,
185};
186
187static int __init irq_pm_init_ops(void)
188{
189	register_syscore_ops(&irq_pm_syscore_ops);
190	return 0;
191}
192
193device_initcall(irq_pm_init_ops);
194
195/**
196 * resume_device_irqs - enable interrupt lines disabled by suspend_device_irqs()
197 *
198 * Enable all non-%IRQF_EARLY_RESUME interrupt lines previously
199 * disabled by suspend_device_irqs() that have the IRQS_SUSPENDED flag
200 * set as well as those with %IRQF_FORCE_RESUME.
201 */
202void resume_device_irqs(void)
203{
204	resume_irqs(false);
205}
206EXPORT_SYMBOL_GPL(resume_device_irqs);
207