]>
Commit | Line | Data |
---|---|---|
52a65ff5 | 1 | // SPDX-License-Identifier: GPL-2.0 |
0a0c5168 | 2 | /* |
0a0c5168 RW |
3 | * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc. |
4 | * | |
5 | * This file contains power management functions related to interrupts. | |
6 | */ | |
7 | ||
8 | #include <linux/irq.h> | |
9 | #include <linux/module.h> | |
10 | #include <linux/interrupt.h> | |
9ce7a258 | 11 | #include <linux/suspend.h> |
9bab0b7f | 12 | #include <linux/syscore_ops.h> |
0a0c5168 RW |
13 | |
14 | #include "internals.h" | |
15 | ||
9ce7a258 TG |
16 | bool irq_pm_check_wakeup(struct irq_desc *desc) |
17 | { | |
18 | if (irqd_is_wakeup_armed(&desc->irq_data)) { | |
19 | irqd_clear(&desc->irq_data, IRQD_WAKEUP_ARMED); | |
20 | desc->istate |= IRQS_SUSPENDED | IRQS_PENDING; | |
21 | desc->depth++; | |
22 | irq_disable(desc); | |
a6f5f0dd | 23 | pm_system_irq_wakeup(irq_desc_get_irq(desc)); |
9ce7a258 TG |
24 | return true; |
25 | } | |
26 | return false; | |
27 | } | |
28 | ||
cab303be TG |
29 | /* |
30 | * Called from __setup_irq() with desc->lock held after @action has | |
31 | * been installed in the action chain. | |
32 | */ | |
33 | void irq_pm_install_action(struct irq_desc *desc, struct irqaction *action) | |
34 | { | |
35 | desc->nr_actions++; | |
36 | ||
37 | if (action->flags & IRQF_FORCE_RESUME) | |
38 | desc->force_resume_depth++; | |
39 | ||
40 | WARN_ON_ONCE(desc->force_resume_depth && | |
41 | desc->force_resume_depth != desc->nr_actions); | |
42 | ||
43 | if (action->flags & IRQF_NO_SUSPEND) | |
44 | desc->no_suspend_depth++; | |
17f48034 RW |
45 | else if (action->flags & IRQF_COND_SUSPEND) |
46 | desc->cond_suspend_depth++; | |
cab303be TG |
47 | |
48 | WARN_ON_ONCE(desc->no_suspend_depth && | |
17f48034 RW |
49 | (desc->no_suspend_depth + |
50 | desc->cond_suspend_depth) != desc->nr_actions); | |
cab303be TG |
51 | } |
52 | ||
53 | /* | |
54 | * Called from __free_irq() with desc->lock held after @action has | |
55 | * been removed from the action chain. | |
56 | */ | |
57 | void irq_pm_remove_action(struct irq_desc *desc, struct irqaction *action) | |
58 | { | |
59 | desc->nr_actions--; | |
60 | ||
61 | if (action->flags & IRQF_FORCE_RESUME) | |
62 | desc->force_resume_depth--; | |
63 | ||
64 | if (action->flags & IRQF_NO_SUSPEND) | |
65 | desc->no_suspend_depth--; | |
17f48034 RW |
66 | else if (action->flags & IRQF_COND_SUSPEND) |
67 | desc->cond_suspend_depth--; | |
cab303be TG |
68 | } |
69 | ||
b80f5f3f | 70 | static bool suspend_device_irq(struct irq_desc *desc) |
8df2e02c | 71 | { |
90428a8e MS |
72 | unsigned long chipflags = irq_desc_get_chip(desc)->flags; |
73 | struct irq_data *irqd = &desc->irq_data; | |
74 | ||
4717f133 GS |
75 | if (!desc->action || irq_desc_is_chained(desc) || |
76 | desc->no_suspend_depth) | |
c4df606c | 77 | return false; |
8df2e02c | 78 | |
90428a8e MS |
79 | if (irqd_is_wakeup_set(irqd)) { |
80 | irqd_set(irqd, IRQD_WAKEUP_ARMED); | |
81 | ||
82 | if ((chipflags & IRQCHIP_ENABLE_WAKEUP_ON_SUSPEND) && | |
83 | irqd_irq_disabled(irqd)) { | |
84 | /* | |
85 | * Interrupt marked for wakeup is in disabled state. | |
86 | * Enable interrupt here to unmask/enable in irqchip | |
87 | * to be able to resume with such interrupts. | |
88 | */ | |
89 | __enable_irq(desc); | |
90 | irqd_set(irqd, IRQD_IRQ_ENABLED_ON_SUSPEND); | |
91 | } | |
9ce7a258 TG |
92 | /* |
93 | * We return true here to force the caller to issue | |
94 | * synchronize_irq(). We need to make sure that the | |
95 | * IRQD_WAKEUP_ARMED is visible before we return from | |
96 | * suspend_device_irqs(). | |
97 | */ | |
98 | return true; | |
99 | } | |
b76f1674 | 100 | |
8df2e02c | 101 | desc->istate |= IRQS_SUSPENDED; |
79ff1cda | 102 | __disable_irq(desc); |
092fadd5 TG |
103 | |
104 | /* | |
105 | * Hardware which has no wakeup source configuration facility | |
106 | * requires that the non wakeup interrupts are masked at the | |
107 | * chip level. The chip implementation indicates that with | |
108 | * IRQCHIP_MASK_ON_SUSPEND. | |
109 | */ | |
90428a8e | 110 | if (chipflags & IRQCHIP_MASK_ON_SUSPEND) |
092fadd5 | 111 | mask_irq(desc); |
c4df606c | 112 | return true; |
8df2e02c TG |
113 | } |
114 | ||
0a0c5168 RW |
115 | /** |
116 | * suspend_device_irqs - disable all currently enabled interrupt lines | |
117 | * | |
8df2e02c TG |
118 | * During system-wide suspend or hibernation device drivers need to be |
119 | * prevented from receiving interrupts and this function is provided | |
120 | * for this purpose. | |
121 | * | |
122 | * So we disable all interrupts and mark them IRQS_SUSPENDED except | |
9ce7a258 | 123 | * for those which are unused, those which are marked as not |
8df2e02c | 124 | * suspendable via an interrupt request with the flag IRQF_NO_SUSPEND |
9ce7a258 TG |
125 | * set and those which are marked as active wakeup sources. |
126 | * | |
127 | * The active wakeup sources are handled by the flow handler entry | |
128 | * code which checks for the IRQD_WAKEUP_ARMED flag, suspends the | |
129 | * interrupt and notifies the pm core about the wakeup. | |
0a0c5168 RW |
130 | */ |
131 | void suspend_device_irqs(void) | |
132 | { | |
133 | struct irq_desc *desc; | |
134 | int irq; | |
135 | ||
136 | for_each_irq_desc(irq, desc) { | |
137 | unsigned long flags; | |
c4df606c | 138 | bool sync; |
0a0c5168 | 139 | |
3c646f2c N |
140 | if (irq_settings_is_nested_thread(desc)) |
141 | continue; | |
239007b8 | 142 | raw_spin_lock_irqsave(&desc->lock, flags); |
b80f5f3f | 143 | sync = suspend_device_irq(desc); |
239007b8 | 144 | raw_spin_unlock_irqrestore(&desc->lock, flags); |
0a0c5168 | 145 | |
c4df606c | 146 | if (sync) |
0a0c5168 | 147 | synchronize_irq(irq); |
c4df606c | 148 | } |
0a0c5168 RW |
149 | } |
150 | EXPORT_SYMBOL_GPL(suspend_device_irqs); | |
151 | ||
b80f5f3f | 152 | static void resume_irq(struct irq_desc *desc) |
8df2e02c | 153 | { |
90428a8e MS |
154 | struct irq_data *irqd = &desc->irq_data; |
155 | ||
156 | irqd_clear(irqd, IRQD_WAKEUP_ARMED); | |
157 | ||
158 | if (irqd_is_enabled_on_suspend(irqd)) { | |
159 | /* | |
160 | * Interrupt marked for wakeup was enabled during suspend | |
161 | * entry. Disable such interrupts to restore them back to | |
162 | * original state. | |
163 | */ | |
164 | __disable_irq(desc); | |
165 | irqd_clear(irqd, IRQD_IRQ_ENABLED_ON_SUSPEND); | |
166 | } | |
b76f1674 | 167 | |
8df2e02c TG |
168 | if (desc->istate & IRQS_SUSPENDED) |
169 | goto resume; | |
170 | ||
5417de22 TG |
171 | /* Force resume the interrupt? */ |
172 | if (!desc->force_resume_depth) | |
8df2e02c TG |
173 | return; |
174 | ||
175 | /* Pretend that it got disabled ! */ | |
176 | desc->depth++; | |
a696712c JG |
177 | irq_state_set_disabled(desc); |
178 | irq_state_set_masked(desc); | |
8df2e02c TG |
179 | resume: |
180 | desc->istate &= ~IRQS_SUSPENDED; | |
79ff1cda | 181 | __enable_irq(desc); |
8df2e02c TG |
182 | } |
183 | ||
9bab0b7f | 184 | static void resume_irqs(bool want_early) |
0a0c5168 RW |
185 | { |
186 | struct irq_desc *desc; | |
187 | int irq; | |
188 | ||
189 | for_each_irq_desc(irq, desc) { | |
190 | unsigned long flags; | |
9bab0b7f IC |
191 | bool is_early = desc->action && |
192 | desc->action->flags & IRQF_EARLY_RESUME; | |
193 | ||
ac01810c | 194 | if (!is_early && want_early) |
9bab0b7f | 195 | continue; |
3c646f2c N |
196 | if (irq_settings_is_nested_thread(desc)) |
197 | continue; | |
0a0c5168 | 198 | |
239007b8 | 199 | raw_spin_lock_irqsave(&desc->lock, flags); |
b80f5f3f | 200 | resume_irq(desc); |
239007b8 | 201 | raw_spin_unlock_irqrestore(&desc->lock, flags); |
0a0c5168 RW |
202 | } |
203 | } | |
9bab0b7f | 204 | |
3a79bc63 RW |
205 | /** |
206 | * rearm_wake_irq - rearm a wakeup interrupt line after signaling wakeup | |
207 | * @irq: Interrupt to rearm | |
208 | */ | |
209 | void rearm_wake_irq(unsigned int irq) | |
210 | { | |
211 | unsigned long flags; | |
212 | struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL); | |
213 | ||
e27b1636 | 214 | if (!desc) |
3a79bc63 RW |
215 | return; |
216 | ||
e27b1636 GR |
217 | if (!(desc->istate & IRQS_SUSPENDED) || |
218 | !irqd_is_wakeup_set(&desc->irq_data)) | |
219 | goto unlock; | |
220 | ||
3a79bc63 RW |
221 | desc->istate &= ~IRQS_SUSPENDED; |
222 | irqd_set(&desc->irq_data, IRQD_WAKEUP_ARMED); | |
223 | __enable_irq(desc); | |
224 | ||
e27b1636 | 225 | unlock: |
3a79bc63 RW |
226 | irq_put_desc_busunlock(desc, flags); |
227 | } | |
228 | ||
9bab0b7f IC |
229 | /** |
230 | * irq_pm_syscore_ops - enable interrupt lines early | |
231 | * | |
232 | * Enable all interrupt lines with %IRQF_EARLY_RESUME set. | |
233 | */ | |
234 | static void irq_pm_syscore_resume(void) | |
235 | { | |
236 | resume_irqs(true); | |
237 | } | |
238 | ||
239 | static struct syscore_ops irq_pm_syscore_ops = { | |
240 | .resume = irq_pm_syscore_resume, | |
241 | }; | |
242 | ||
243 | static int __init irq_pm_init_ops(void) | |
244 | { | |
245 | register_syscore_ops(&irq_pm_syscore_ops); | |
246 | return 0; | |
247 | } | |
248 | ||
249 | device_initcall(irq_pm_init_ops); | |
250 | ||
251 | /** | |
252 | * resume_device_irqs - enable interrupt lines disabled by suspend_device_irqs() | |
253 | * | |
254 | * Enable all non-%IRQF_EARLY_RESUME interrupt lines previously | |
255 | * disabled by suspend_device_irqs() that have the IRQS_SUSPENDED flag | |
256 | * set as well as those with %IRQF_FORCE_RESUME. | |
257 | */ | |
258 | void resume_device_irqs(void) | |
259 | { | |
260 | resume_irqs(false); | |
261 | } | |
0a0c5168 | 262 | EXPORT_SYMBOL_GPL(resume_device_irqs); |