]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * drivers/base/power/wakeup.c - System wakeup events framework | |
3 | * | |
4 | * Copyright (c) 2010 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc. | |
5 | * | |
6 | * This file is released under the GPLv2. | |
7 | */ | |
8 | ||
9 | #include <linux/device.h> | |
10 | #include <linux/slab.h> | |
11 | #include <linux/sched.h> | |
12 | #include <linux/capability.h> | |
13 | #include <linux/suspend.h> | |
14 | #include <linux/pm.h> | |
15 | ||
16 | /* | |
17 | * If set, the suspend/hibernate code will abort transitions to a sleep state | |
18 | * if wakeup events are registered during or immediately before the transition. | |
19 | */ | |
20 | bool events_check_enabled; | |
21 | ||
22 | /* The counter of registered wakeup events. */ | |
23 | static unsigned long event_count; | |
24 | /* A preserved old value of event_count. */ | |
25 | static unsigned long saved_event_count; | |
26 | /* The counter of wakeup events being processed. */ | |
27 | static unsigned long events_in_progress; | |
28 | ||
29 | static DEFINE_SPINLOCK(events_lock); | |
30 | ||
31 | /* | |
32 | * The functions below use the observation that each wakeup event starts a | |
33 | * period in which the system should not be suspended. The moment this period | |
34 | * will end depends on how the wakeup event is going to be processed after being | |
35 | * detected and all of the possible cases can be divided into two distinct | |
36 | * groups. | |
37 | * | |
38 | * First, a wakeup event may be detected by the same functional unit that will | |
39 | * carry out the entire processing of it and possibly will pass it to user space | |
40 | * for further processing. In that case the functional unit that has detected | |
41 | * the event may later "close" the "no suspend" period associated with it | |
42 | * directly as soon as it has been dealt with. The pair of pm_stay_awake() and | |
43 | * pm_relax(), balanced with each other, is supposed to be used in such | |
44 | * situations. | |
45 | * | |
46 | * Second, a wakeup event may be detected by one functional unit and processed | |
47 | * by another one. In that case the unit that has detected it cannot really | |
48 | * "close" the "no suspend" period associated with it, unless it knows in | |
49 | * advance what's going to happen to the event during processing. This | |
50 | * knowledge, however, may not be available to it, so it can simply specify time | |
51 | * to wait before the system can be suspended and pass it as the second | |
52 | * argument of pm_wakeup_event(). | |
53 | */ | |
54 | ||
55 | /** | |
56 | * pm_stay_awake - Notify the PM core that a wakeup event is being processed. | |
57 | * @dev: Device the wakeup event is related to. | |
58 | * | |
59 | * Notify the PM core of a wakeup event (signaled by @dev) by incrementing the | |
60 | * counter of wakeup events being processed. If @dev is not NULL, the counter | |
61 | * of wakeup events related to @dev is incremented too. | |
62 | * | |
63 | * Call this function after detecting of a wakeup event if pm_relax() is going | |
64 | * to be called directly after processing the event (and possibly passing it to | |
65 | * user space for further processing). | |
66 | * | |
67 | * It is safe to call this function from interrupt context. | |
68 | */ | |
69 | void pm_stay_awake(struct device *dev) | |
70 | { | |
71 | unsigned long flags; | |
72 | ||
73 | spin_lock_irqsave(&events_lock, flags); | |
74 | if (dev) | |
75 | dev->power.wakeup_count++; | |
76 | ||
77 | events_in_progress++; | |
78 | spin_unlock_irqrestore(&events_lock, flags); | |
79 | } | |
80 | ||
81 | /** | |
82 | * pm_relax - Notify the PM core that processing of a wakeup event has ended. | |
83 | * | |
84 | * Notify the PM core that a wakeup event has been processed by decrementing | |
85 | * the counter of wakeup events being processed and incrementing the counter | |
86 | * of registered wakeup events. | |
87 | * | |
88 | * Call this function for wakeup events whose processing started with calling | |
89 | * pm_stay_awake(). | |
90 | * | |
91 | * It is safe to call it from interrupt context. | |
92 | */ | |
93 | void pm_relax(void) | |
94 | { | |
95 | unsigned long flags; | |
96 | ||
97 | spin_lock_irqsave(&events_lock, flags); | |
98 | if (events_in_progress) { | |
99 | events_in_progress--; | |
100 | event_count++; | |
101 | } | |
102 | spin_unlock_irqrestore(&events_lock, flags); | |
103 | } | |
104 | ||
105 | /** | |
106 | * pm_wakeup_work_fn - Deferred closing of a wakeup event. | |
107 | * | |
108 | * Execute pm_relax() for a wakeup event detected in the past and free the | |
109 | * work item object used for queuing up the work. | |
110 | */ | |
111 | static void pm_wakeup_work_fn(struct work_struct *work) | |
112 | { | |
113 | struct delayed_work *dwork = to_delayed_work(work); | |
114 | ||
115 | pm_relax(); | |
116 | kfree(dwork); | |
117 | } | |
118 | ||
119 | /** | |
120 | * pm_wakeup_event - Notify the PM core of a wakeup event. | |
121 | * @dev: Device the wakeup event is related to. | |
122 | * @msec: Anticipated event processing time (in milliseconds). | |
123 | * | |
124 | * Notify the PM core of a wakeup event (signaled by @dev) that will take | |
125 | * approximately @msec milliseconds to be processed by the kernel. Increment | |
126 | * the counter of wakeup events being processed and queue up a work item | |
127 | * that will execute pm_relax() for the event after @msec milliseconds. If @dev | |
128 | * is not NULL, the counter of wakeup events related to @dev is incremented too. | |
129 | * | |
130 | * It is safe to call this function from interrupt context. | |
131 | */ | |
132 | void pm_wakeup_event(struct device *dev, unsigned int msec) | |
133 | { | |
134 | unsigned long flags; | |
135 | struct delayed_work *dwork; | |
136 | ||
137 | dwork = msec ? kzalloc(sizeof(*dwork), GFP_ATOMIC) : NULL; | |
138 | ||
139 | spin_lock_irqsave(&events_lock, flags); | |
140 | if (dev) | |
141 | dev->power.wakeup_count++; | |
142 | ||
143 | if (dwork) { | |
144 | INIT_DELAYED_WORK(dwork, pm_wakeup_work_fn); | |
145 | schedule_delayed_work(dwork, msecs_to_jiffies(msec)); | |
146 | ||
147 | events_in_progress++; | |
148 | } else { | |
149 | event_count++; | |
150 | } | |
151 | spin_unlock_irqrestore(&events_lock, flags); | |
152 | } | |
153 | ||
154 | /** | |
155 | * pm_check_wakeup_events - Check for new wakeup events. | |
156 | * | |
157 | * Compare the current number of registered wakeup events with its preserved | |
158 | * value from the past to check if new wakeup events have been registered since | |
159 | * the old value was stored. Check if the current number of wakeup events being | |
160 | * processed is zero. | |
161 | */ | |
162 | bool pm_check_wakeup_events(void) | |
163 | { | |
164 | unsigned long flags; | |
165 | bool ret = true; | |
166 | ||
167 | spin_lock_irqsave(&events_lock, flags); | |
168 | if (events_check_enabled) { | |
169 | ret = (event_count == saved_event_count) && !events_in_progress; | |
170 | events_check_enabled = ret; | |
171 | } | |
172 | spin_unlock_irqrestore(&events_lock, flags); | |
173 | return ret; | |
174 | } | |
175 | ||
176 | /** | |
177 | * pm_get_wakeup_count - Read the number of registered wakeup events. | |
178 | * @count: Address to store the value at. | |
179 | * | |
180 | * Store the number of registered wakeup events at the address in @count. Block | |
181 | * if the current number of wakeup events being processed is nonzero. | |
182 | * | |
183 | * Return false if the wait for the number of wakeup events being processed to | |
184 | * drop down to zero has been interrupted by a signal (and the current number | |
185 | * of wakeup events being processed is still nonzero). Otherwise return true. | |
186 | */ | |
187 | bool pm_get_wakeup_count(unsigned long *count) | |
188 | { | |
189 | bool ret; | |
190 | ||
191 | spin_lock_irq(&events_lock); | |
192 | if (capable(CAP_SYS_ADMIN)) | |
193 | events_check_enabled = false; | |
194 | ||
195 | while (events_in_progress && !signal_pending(current)) { | |
196 | spin_unlock_irq(&events_lock); | |
197 | ||
198 | schedule_timeout_interruptible(msecs_to_jiffies(100)); | |
199 | ||
200 | spin_lock_irq(&events_lock); | |
201 | } | |
202 | *count = event_count; | |
203 | ret = !events_in_progress; | |
204 | spin_unlock_irq(&events_lock); | |
205 | return ret; | |
206 | } | |
207 | ||
208 | /** | |
209 | * pm_save_wakeup_count - Save the current number of registered wakeup events. | |
210 | * @count: Value to compare with the current number of registered wakeup events. | |
211 | * | |
212 | * If @count is equal to the current number of registered wakeup events and the | |
213 | * current number of wakeup events being processed is zero, store @count as the | |
214 | * old number of registered wakeup events to be used by pm_check_wakeup_events() | |
215 | * and return true. Otherwise return false. | |
216 | */ | |
217 | bool pm_save_wakeup_count(unsigned long count) | |
218 | { | |
219 | bool ret = false; | |
220 | ||
221 | spin_lock_irq(&events_lock); | |
222 | if (count == event_count && !events_in_progress) { | |
223 | saved_event_count = count; | |
224 | events_check_enabled = true; | |
225 | ret = true; | |
226 | } | |
227 | spin_unlock_irq(&events_lock); | |
228 | return ret; | |
229 | } |