Branch data Line data Source code
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/export.h>
14 : : #include <linux/suspend.h>
15 : : #include <linux/seq_file.h>
16 : : #include <linux/debugfs.h>
17 : : #include <trace/events/power.h>
18 : :
19 : : #include "power.h"
20 : :
21 : : /*
22 : : * If set, the suspend/hibernate code will abort transitions to a sleep state
23 : : * if wakeup events are registered during or immediately before the transition.
24 : : */
25 : : bool events_check_enabled __read_mostly;
26 : :
27 : : /*
28 : : * Combined counters of registered wakeup events and wakeup events in progress.
29 : : * They need to be modified together atomically, so it's better to use one
30 : : * atomic variable to hold them both.
31 : : */
32 : : static atomic_t combined_event_count = ATOMIC_INIT(0);
33 : :
34 : : #define IN_PROGRESS_BITS (sizeof(int) * 4)
35 : : #define MAX_IN_PROGRESS ((1 << IN_PROGRESS_BITS) - 1)
36 : :
37 : : static void split_counters(unsigned int *cnt, unsigned int *inpr)
38 : : {
39 : 32935 : unsigned int comb = atomic_read(&combined_event_count);
40 : :
41 : 0 : *cnt = (comb >> IN_PROGRESS_BITS);
42 : 32935 : *inpr = comb & MAX_IN_PROGRESS;
43 : : }
44 : :
45 : : /* A preserved old value of the events counter. */
46 : : static unsigned int saved_count;
47 : :
48 : : static DEFINE_SPINLOCK(events_lock);
49 : :
50 : : static void pm_wakeup_timer_fn(unsigned long data);
51 : :
52 : : static LIST_HEAD(wakeup_sources);
53 : :
54 : : static DECLARE_WAIT_QUEUE_HEAD(wakeup_count_wait_queue);
55 : :
56 : : /**
57 : : * wakeup_source_prepare - Prepare a new wakeup source for initialization.
58 : : * @ws: Wakeup source to prepare.
59 : : * @name: Pointer to the name of the new wakeup source.
60 : : *
61 : : * Callers must ensure that the @name string won't be freed when @ws is still in
62 : : * use.
63 : : */
64 : 0 : void wakeup_source_prepare(struct wakeup_source *ws, const char *name)
65 : : {
66 [ # # ][ # # ]: 0 : if (ws) {
67 : 0 : memset(ws, 0, sizeof(*ws));
68 : 0 : ws->name = name;
69 : : }
70 : 0 : }
71 : : EXPORT_SYMBOL_GPL(wakeup_source_prepare);
72 : :
73 : : /**
74 : : * wakeup_source_create - Create a struct wakeup_source object.
75 : : * @name: Name of the new wakeup source.
76 : : */
77 : 0 : struct wakeup_source *wakeup_source_create(const char *name)
78 : : {
79 : : struct wakeup_source *ws;
80 : :
81 : : ws = kmalloc(sizeof(*ws), GFP_KERNEL);
82 [ # # ]: 0 : if (!ws)
83 : : return NULL;
84 : :
85 [ # # ]: 0 : wakeup_source_prepare(ws, name ? kstrdup(name, GFP_KERNEL) : NULL);
86 : 0 : return ws;
87 : : }
88 : : EXPORT_SYMBOL_GPL(wakeup_source_create);
89 : :
90 : : /**
91 : : * wakeup_source_drop - Prepare a struct wakeup_source object for destruction.
92 : : * @ws: Wakeup source to prepare for destruction.
93 : : *
94 : : * Callers must ensure that __pm_stay_awake() or __pm_wakeup_event() will never
95 : : * be run in parallel with this function for the same wakeup source object.
96 : : */
97 : 0 : void wakeup_source_drop(struct wakeup_source *ws)
98 : : {
99 [ # # ]: 0 : if (!ws)
100 : 0 : return;
101 : :
102 : 0 : del_timer_sync(&ws->timer);
103 : 0 : __pm_relax(ws);
104 : : }
105 : : EXPORT_SYMBOL_GPL(wakeup_source_drop);
106 : :
107 : : /**
108 : : * wakeup_source_destroy - Destroy a struct wakeup_source object.
109 : : * @ws: Wakeup source to destroy.
110 : : *
111 : : * Use only for wakeup source objects created with wakeup_source_create().
112 : : */
113 : 0 : void wakeup_source_destroy(struct wakeup_source *ws)
114 : : {
115 [ # # ]: 0 : if (!ws)
116 : 0 : return;
117 : :
118 : 0 : wakeup_source_drop(ws);
119 : 0 : kfree(ws->name);
120 : 0 : kfree(ws);
121 : : }
122 : : EXPORT_SYMBOL_GPL(wakeup_source_destroy);
123 : :
124 : : /**
125 : : * wakeup_source_add - Add given object to the list of wakeup sources.
126 : : * @ws: Wakeup source object to add to the list.
127 : : */
128 : 0 : void wakeup_source_add(struct wakeup_source *ws)
129 : : {
130 : : unsigned long flags;
131 : :
132 [ # # ][ # # ]: 0 : if (WARN_ON(!ws))
133 : 0 : return;
134 : :
135 : 0 : spin_lock_init(&ws->lock);
136 : 0 : setup_timer(&ws->timer, pm_wakeup_timer_fn, (unsigned long)ws);
137 : 0 : ws->active = false;
138 : 0 : ws->last_time = ktime_get();
139 : :
140 : 0 : spin_lock_irqsave(&events_lock, flags);
141 : 0 : list_add_rcu(&ws->entry, &wakeup_sources);
142 : : spin_unlock_irqrestore(&events_lock, flags);
143 : : }
144 : : EXPORT_SYMBOL_GPL(wakeup_source_add);
145 : :
146 : : /**
147 : : * wakeup_source_remove - Remove given object from the wakeup sources list.
148 : : * @ws: Wakeup source object to remove from the list.
149 : : */
150 : 0 : void wakeup_source_remove(struct wakeup_source *ws)
151 : : {
152 : : unsigned long flags;
153 : :
154 [ # # ][ # # ]: 0 : if (WARN_ON(!ws))
155 : 0 : return;
156 : :
157 : 0 : spin_lock_irqsave(&events_lock, flags);
158 : : list_del_rcu(&ws->entry);
159 : : spin_unlock_irqrestore(&events_lock, flags);
160 : : synchronize_rcu();
161 : : }
162 : : EXPORT_SYMBOL_GPL(wakeup_source_remove);
163 : :
164 : : /**
165 : : * wakeup_source_register - Create wakeup source and add it to the list.
166 : : * @name: Name of the wakeup source to register.
167 : : */
168 : 0 : struct wakeup_source *wakeup_source_register(const char *name)
169 : : {
170 : : struct wakeup_source *ws;
171 : :
172 : 0 : ws = wakeup_source_create(name);
173 [ # # ]: 0 : if (ws)
174 : 0 : wakeup_source_add(ws);
175 : :
176 : 0 : return ws;
177 : : }
178 : : EXPORT_SYMBOL_GPL(wakeup_source_register);
179 : :
180 : : /**
181 : : * wakeup_source_unregister - Remove wakeup source from the list and remove it.
182 : : * @ws: Wakeup source object to unregister.
183 : : */
184 : 0 : void wakeup_source_unregister(struct wakeup_source *ws)
185 : : {
186 [ - + ]: 93 : if (ws) {
187 : 0 : wakeup_source_remove(ws);
188 : 0 : wakeup_source_destroy(ws);
189 : : }
190 : 0 : }
191 : : EXPORT_SYMBOL_GPL(wakeup_source_unregister);
192 : :
193 : : /**
194 : : * device_wakeup_attach - Attach a wakeup source object to a device object.
195 : : * @dev: Device to handle.
196 : : * @ws: Wakeup source object to attach to @dev.
197 : : *
198 : : * This causes @dev to be treated as a wakeup device.
199 : : */
200 : 0 : static int device_wakeup_attach(struct device *dev, struct wakeup_source *ws)
201 : : {
202 : : spin_lock_irq(&dev->power.lock);
203 [ # # ]: 0 : if (dev->power.wakeup) {
204 : : spin_unlock_irq(&dev->power.lock);
205 : 0 : return -EEXIST;
206 : : }
207 : 0 : dev->power.wakeup = ws;
208 : : spin_unlock_irq(&dev->power.lock);
209 : 0 : return 0;
210 : : }
211 : :
212 : : /**
213 : : * device_wakeup_enable - Enable given device to be a wakeup source.
214 : : * @dev: Device to handle.
215 : : *
216 : : * Create a wakeup source object, register it and attach it to @dev.
217 : : */
218 : 0 : int device_wakeup_enable(struct device *dev)
219 : : {
220 : : struct wakeup_source *ws;
221 : : int ret;
222 : :
223 [ # # ][ # # ]: 0 : if (!dev || !dev->power.can_wakeup)
224 : : return -EINVAL;
225 : :
226 : 0 : ws = wakeup_source_register(dev_name(dev));
227 [ # # ]: 0 : if (!ws)
228 : : return -ENOMEM;
229 : :
230 : 0 : ret = device_wakeup_attach(dev, ws);
231 [ # # ]: 0 : if (ret)
232 : 0 : wakeup_source_unregister(ws);
233 : :
234 : 0 : return ret;
235 : : }
236 : : EXPORT_SYMBOL_GPL(device_wakeup_enable);
237 : :
238 : : /**
239 : : * device_wakeup_detach - Detach a device's wakeup source object from it.
240 : : * @dev: Device to detach the wakeup source object from.
241 : : *
242 : : * After it returns, @dev will not be treated as a wakeup device any more.
243 : : */
244 : 0 : static struct wakeup_source *device_wakeup_detach(struct device *dev)
245 : : {
246 : : struct wakeup_source *ws;
247 : :
248 : : spin_lock_irq(&dev->power.lock);
249 : 2 : ws = dev->power.wakeup;
250 : 2 : dev->power.wakeup = NULL;
251 : : spin_unlock_irq(&dev->power.lock);
252 : 2 : return ws;
253 : : }
254 : :
255 : : /**
256 : : * device_wakeup_disable - Do not regard a device as a wakeup source any more.
257 : : * @dev: Device to handle.
258 : : *
259 : : * Detach the @dev's wakeup source object from it, unregister this wakeup source
260 : : * object and destroy it.
261 : : */
262 : 0 : int device_wakeup_disable(struct device *dev)
263 : : {
264 : : struct wakeup_source *ws;
265 : :
266 [ + - ][ + + ]: 16 : if (!dev || !dev->power.can_wakeup)
267 : : return -EINVAL;
268 : :
269 : 2 : ws = device_wakeup_detach(dev);
270 [ - + ]: 2 : if (ws)
271 : 0 : wakeup_source_unregister(ws);
272 : :
273 : : return 0;
274 : : }
275 : : EXPORT_SYMBOL_GPL(device_wakeup_disable);
276 : :
277 : : /**
278 : : * device_set_wakeup_capable - Set/reset device wakeup capability flag.
279 : : * @dev: Device to handle.
280 : : * @capable: Whether or not @dev is capable of waking up the system from sleep.
281 : : *
282 : : * If @capable is set, set the @dev's power.can_wakeup flag and add its
283 : : * wakeup-related attributes to sysfs. Otherwise, unset the @dev's
284 : : * power.can_wakeup flag and remove its wakeup-related attributes from sysfs.
285 : : *
286 : : * This function may sleep and it can't be called from any context where
287 : : * sleeping is not allowed.
288 : : */
289 : 0 : void device_set_wakeup_capable(struct device *dev, bool capable)
290 : : {
291 [ + + ]: 12 : if (!!dev->power.can_wakeup == !!capable)
292 : : return;
293 : :
294 [ + - ][ + - ]: 2 : if (device_is_registered(dev) && !list_empty(&dev->power.entry)) {
295 [ + - ]: 2 : if (capable) {
296 [ + - ]: 2 : if (wakeup_sysfs_add(dev))
297 : : return;
298 : : } else {
299 : 0 : wakeup_sysfs_remove(dev);
300 : : }
301 : : }
302 : 2 : dev->power.can_wakeup = capable;
303 : : }
304 : : EXPORT_SYMBOL_GPL(device_set_wakeup_capable);
305 : :
306 : : /**
307 : : * device_init_wakeup - Device wakeup initialization.
308 : : * @dev: Device to handle.
309 : : * @enable: Whether or not to enable @dev as a wakeup device.
310 : : *
311 : : * By default, most devices should leave wakeup disabled. The exceptions are
312 : : * devices that everyone expects to be wakeup sources: keyboards, power buttons,
313 : : * possibly network interfaces, etc. Also, devices that don't generate their
314 : : * own wakeup requests but merely forward requests from one bus to another
315 : : * (like PCI bridges) should have wakeup enabled by default.
316 : : */
317 : 0 : int device_init_wakeup(struct device *dev, bool enable)
318 : : {
319 : : int ret = 0;
320 : :
321 [ - + ]: 2 : if (enable) {
322 : 0 : device_set_wakeup_capable(dev, true);
323 : 0 : ret = device_wakeup_enable(dev);
324 : : } else {
325 : 2 : device_set_wakeup_capable(dev, false);
326 : : }
327 : :
328 : 2 : return ret;
329 : : }
330 : : EXPORT_SYMBOL_GPL(device_init_wakeup);
331 : :
332 : : /**
333 : : * device_set_wakeup_enable - Enable or disable a device to wake up the system.
334 : : * @dev: Device to handle.
335 : : */
336 : 0 : int device_set_wakeup_enable(struct device *dev, bool enable)
337 : : {
338 [ # # ][ # # ]: 0 : if (!dev || !dev->power.can_wakeup)
339 : : return -EINVAL;
340 : :
341 [ # # ]: 0 : return enable ? device_wakeup_enable(dev) : device_wakeup_disable(dev);
342 : : }
343 : : EXPORT_SYMBOL_GPL(device_set_wakeup_enable);
344 : :
345 : : /*
346 : : * The functions below use the observation that each wakeup event starts a
347 : : * period in which the system should not be suspended. The moment this period
348 : : * will end depends on how the wakeup event is going to be processed after being
349 : : * detected and all of the possible cases can be divided into two distinct
350 : : * groups.
351 : : *
352 : : * First, a wakeup event may be detected by the same functional unit that will
353 : : * carry out the entire processing of it and possibly will pass it to user space
354 : : * for further processing. In that case the functional unit that has detected
355 : : * the event may later "close" the "no suspend" period associated with it
356 : : * directly as soon as it has been dealt with. The pair of pm_stay_awake() and
357 : : * pm_relax(), balanced with each other, is supposed to be used in such
358 : : * situations.
359 : : *
360 : : * Second, a wakeup event may be detected by one functional unit and processed
361 : : * by another one. In that case the unit that has detected it cannot really
362 : : * "close" the "no suspend" period associated with it, unless it knows in
363 : : * advance what's going to happen to the event during processing. This
364 : : * knowledge, however, may not be available to it, so it can simply specify time
365 : : * to wait before the system can be suspended and pass it as the second
366 : : * argument of pm_wakeup_event().
367 : : *
368 : : * It is valid to call pm_relax() after pm_wakeup_event(), in which case the
369 : : * "no suspend" period will be ended either by the pm_relax(), or by the timer
370 : : * function executed when the timer expires, whichever comes first.
371 : : */
372 : :
373 : : /**
374 : : * wakup_source_activate - Mark given wakeup source as active.
375 : : * @ws: Wakeup source to handle.
376 : : *
377 : : * Update the @ws' statistics and, if @ws has just been activated, notify the PM
378 : : * core of the event by incrementing the counter of of wakeup events being
379 : : * processed.
380 : : */
381 : 0 : static void wakeup_source_activate(struct wakeup_source *ws)
382 : : {
383 : : unsigned int cec;
384 : :
385 : : /*
386 : : * active wakeup source should bring the system
387 : : * out of PM_SUSPEND_FREEZE state
388 : : */
389 : 32935 : freeze_wake();
390 : :
391 : 32935 : ws->active = true;
392 : 32935 : ws->active_count++;
393 : 32935 : ws->last_time = ktime_get();
394 [ - + ]: 32935 : if (ws->autosleep_enabled)
395 : 0 : ws->start_prevent_time = ws->last_time;
396 : :
397 : : /* Increment the counter of events in progress. */
398 : 32935 : cec = atomic_inc_return(&combined_event_count);
399 : :
400 : 32935 : trace_wakeup_source_activate(ws->name, cec);
401 : 0 : }
402 : :
403 : : /**
404 : : * wakeup_source_report_event - Report wakeup event using the given source.
405 : : * @ws: Wakeup source to report the event for.
406 : : */
407 : 0 : static void wakeup_source_report_event(struct wakeup_source *ws)
408 : : {
409 : 32935 : ws->event_count++;
410 : : /* This is racy, but the counter is approximate anyway. */
411 [ - + ]: 32935 : if (events_check_enabled)
412 : 0 : ws->wakeup_count++;
413 : :
414 [ + - ]: 32935 : if (!ws->active)
415 : 32935 : wakeup_source_activate(ws);
416 : 0 : }
417 : :
418 : : /**
419 : : * __pm_stay_awake - Notify the PM core of a wakeup event.
420 : : * @ws: Wakeup source object associated with the source of the event.
421 : : *
422 : : * It is safe to call this function from interrupt context.
423 : : */
424 : 0 : void __pm_stay_awake(struct wakeup_source *ws)
425 : : {
426 : : unsigned long flags;
427 : :
428 [ + - ]: 32935 : if (!ws)
429 : 0 : return;
430 : :
431 : 32935 : spin_lock_irqsave(&ws->lock, flags);
432 : :
433 : 32935 : wakeup_source_report_event(ws);
434 : 32935 : del_timer(&ws->timer);
435 : 32935 : ws->timer_expires = 0;
436 : :
437 : : spin_unlock_irqrestore(&ws->lock, flags);
438 : : }
439 : : EXPORT_SYMBOL_GPL(__pm_stay_awake);
440 : :
441 : : /**
442 : : * pm_stay_awake - Notify the PM core that a wakeup event is being processed.
443 : : * @dev: Device the wakeup event is related to.
444 : : *
445 : : * Notify the PM core of a wakeup event (signaled by @dev) by calling
446 : : * __pm_stay_awake for the @dev's wakeup source object.
447 : : *
448 : : * Call this function after detecting of a wakeup event if pm_relax() is going
449 : : * to be called directly after processing the event (and possibly passing it to
450 : : * user space for further processing).
451 : : */
452 : 0 : void pm_stay_awake(struct device *dev)
453 : : {
454 : : unsigned long flags;
455 : :
456 [ + - ]: 1 : if (!dev)
457 : 0 : return;
458 : :
459 : 1 : spin_lock_irqsave(&dev->power.lock, flags);
460 : 1 : __pm_stay_awake(dev->power.wakeup);
461 : : spin_unlock_irqrestore(&dev->power.lock, flags);
462 : : }
463 : : EXPORT_SYMBOL_GPL(pm_stay_awake);
464 : :
465 : : #ifdef CONFIG_PM_AUTOSLEEP
466 : : static void update_prevent_sleep_time(struct wakeup_source *ws, ktime_t now)
467 : : {
468 : : ktime_t delta = ktime_sub(now, ws->start_prevent_time);
469 : : ws->prevent_sleep_time = ktime_add(ws->prevent_sleep_time, delta);
470 : : }
471 : : #else
472 : : static inline void update_prevent_sleep_time(struct wakeup_source *ws,
473 : : ktime_t now) {}
474 : : #endif
475 : :
476 : : /**
477 : : * wakup_source_deactivate - Mark given wakeup source as inactive.
478 : : * @ws: Wakeup source to handle.
479 : : *
480 : : * Update the @ws' statistics and notify the PM core that the wakeup source has
481 : : * become inactive by decrementing the counter of wakeup events being processed
482 : : * and incrementing the counter of registered wakeup events.
483 : : */
484 : 0 : static void wakeup_source_deactivate(struct wakeup_source *ws)
485 : : {
486 : : unsigned int cnt, inpr, cec;
487 : : ktime_t duration;
488 : : ktime_t now;
489 : :
490 : 32935 : ws->relax_count++;
491 : : /*
492 : : * __pm_relax() may be called directly or from a timer function.
493 : : * If it is called directly right after the timer function has been
494 : : * started, but before the timer function calls __pm_relax(), it is
495 : : * possible that __pm_stay_awake() will be called in the meantime and
496 : : * will set ws->active. Then, ws->active may be cleared immediately
497 : : * by the __pm_relax() called from the timer function, but in such a
498 : : * case ws->relax_count will be different from ws->active_count.
499 : : */
500 [ - + ]: 32935 : if (ws->relax_count != ws->active_count) {
501 : 0 : ws->relax_count--;
502 : 0 : return;
503 : : }
504 : :
505 : 32935 : ws->active = false;
506 : :
507 : 32935 : now = ktime_get();
508 : 32935 : duration = ktime_sub(now, ws->last_time);
509 : 32935 : ws->total_time = ktime_add(ws->total_time, duration);
510 [ + + ]: 32935 : if (ktime_to_ns(duration) > ktime_to_ns(ws->max_time))
511 : 8 : ws->max_time = duration;
512 : :
513 : 32935 : ws->last_time = now;
514 : 32935 : del_timer(&ws->timer);
515 : 32935 : ws->timer_expires = 0;
516 : :
517 : : if (ws->autosleep_enabled)
518 : : update_prevent_sleep_time(ws, now);
519 : :
520 : : /*
521 : : * Increment the counter of registered wakeup events and decrement the
522 : : * couter of wakeup events in progress simultaneously.
523 : : */
524 : 32935 : cec = atomic_add_return(MAX_IN_PROGRESS, &combined_event_count);
525 : 32935 : trace_wakeup_source_deactivate(ws->name, cec);
526 : :
527 : : split_counters(&cnt, &inpr);
528 [ + + ][ - + ]: 65870 : if (!inpr && waitqueue_active(&wakeup_count_wait_queue))
529 : 32935 : wake_up(&wakeup_count_wait_queue);
530 : : }
531 : :
532 : : /**
533 : : * __pm_relax - Notify the PM core that processing of a wakeup event has ended.
534 : : * @ws: Wakeup source object associated with the source of the event.
535 : : *
536 : : * Call this function for wakeup events whose processing started with calling
537 : : * __pm_stay_awake().
538 : : *
539 : : * It is safe to call it from interrupt context.
540 : : */
541 : 0 : void __pm_relax(struct wakeup_source *ws)
542 : : {
543 : : unsigned long flags;
544 : :
545 [ + + ]: 36492 : if (!ws)
546 : 36492 : return;
547 : :
548 : 32935 : spin_lock_irqsave(&ws->lock, flags);
549 [ + - ]: 32935 : if (ws->active)
550 : 32935 : wakeup_source_deactivate(ws);
551 : : spin_unlock_irqrestore(&ws->lock, flags);
552 : : }
553 : : EXPORT_SYMBOL_GPL(__pm_relax);
554 : :
555 : : /**
556 : : * pm_relax - Notify the PM core that processing of a wakeup event has ended.
557 : : * @dev: Device that signaled the event.
558 : : *
559 : : * Execute __pm_relax() for the @dev's wakeup source object.
560 : : */
561 : 0 : void pm_relax(struct device *dev)
562 : : {
563 : : unsigned long flags;
564 : :
565 [ + - ]: 1 : if (!dev)
566 : 0 : return;
567 : :
568 : 1 : spin_lock_irqsave(&dev->power.lock, flags);
569 : 1 : __pm_relax(dev->power.wakeup);
570 : : spin_unlock_irqrestore(&dev->power.lock, flags);
571 : : }
572 : : EXPORT_SYMBOL_GPL(pm_relax);
573 : :
574 : : /**
575 : : * pm_wakeup_timer_fn - Delayed finalization of a wakeup event.
576 : : * @data: Address of the wakeup source object associated with the event source.
577 : : *
578 : : * Call wakeup_source_deactivate() for the wakeup source whose address is stored
579 : : * in @data if it is currently active and its timer has not been canceled and
580 : : * the expiration time of the timer is not in future.
581 : : */
582 : 0 : static void pm_wakeup_timer_fn(unsigned long data)
583 : : {
584 : 0 : struct wakeup_source *ws = (struct wakeup_source *)data;
585 : : unsigned long flags;
586 : :
587 : 0 : spin_lock_irqsave(&ws->lock, flags);
588 : :
589 [ # # ][ # # ]: 0 : if (ws->active && ws->timer_expires
590 [ # # ]: 0 : && time_after_eq(jiffies, ws->timer_expires)) {
591 : 0 : wakeup_source_deactivate(ws);
592 : 0 : ws->expire_count++;
593 : : }
594 : :
595 : : spin_unlock_irqrestore(&ws->lock, flags);
596 : 0 : }
597 : :
598 : : /**
599 : : * __pm_wakeup_event - Notify the PM core of a wakeup event.
600 : : * @ws: Wakeup source object associated with the event source.
601 : : * @msec: Anticipated event processing time (in milliseconds).
602 : : *
603 : : * Notify the PM core of a wakeup event whose source is @ws that will take
604 : : * approximately @msec milliseconds to be processed by the kernel. If @ws is
605 : : * not active, activate it. If @msec is nonzero, set up the @ws' timer to
606 : : * execute pm_wakeup_timer_fn() in future.
607 : : *
608 : : * It is safe to call this function from interrupt context.
609 : : */
610 : 0 : void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec)
611 : : {
612 : : unsigned long flags;
613 : : unsigned long expires;
614 : :
615 [ # # ]: 0 : if (!ws)
616 : 0 : return;
617 : :
618 : 0 : spin_lock_irqsave(&ws->lock, flags);
619 : :
620 : 0 : wakeup_source_report_event(ws);
621 : :
622 [ # # ]: 0 : if (!msec) {
623 : 0 : wakeup_source_deactivate(ws);
624 : 0 : goto unlock;
625 : : }
626 : :
627 : 0 : expires = jiffies + msecs_to_jiffies(msec);
628 [ # # ]: 0 : if (!expires)
629 : : expires = 1;
630 : :
631 [ # # ][ # # ]: 0 : if (!ws->timer_expires || time_after(expires, ws->timer_expires)) {
632 : 0 : mod_timer(&ws->timer, expires);
633 : 0 : ws->timer_expires = expires;
634 : : }
635 : :
636 : : unlock:
637 : : spin_unlock_irqrestore(&ws->lock, flags);
638 : : }
639 : : EXPORT_SYMBOL_GPL(__pm_wakeup_event);
640 : :
641 : :
642 : : /**
643 : : * pm_wakeup_event - Notify the PM core of a wakeup event.
644 : : * @dev: Device the wakeup event is related to.
645 : : * @msec: Anticipated event processing time (in milliseconds).
646 : : *
647 : : * Call __pm_wakeup_event() for the @dev's wakeup source object.
648 : : */
649 : 0 : void pm_wakeup_event(struct device *dev, unsigned int msec)
650 : : {
651 : : unsigned long flags;
652 : :
653 [ # # ]: 0 : if (!dev)
654 : 0 : return;
655 : :
656 : 0 : spin_lock_irqsave(&dev->power.lock, flags);
657 : 0 : __pm_wakeup_event(dev->power.wakeup, msec);
658 : : spin_unlock_irqrestore(&dev->power.lock, flags);
659 : : }
660 : : EXPORT_SYMBOL_GPL(pm_wakeup_event);
661 : :
662 : 0 : void pm_print_active_wakeup_sources(void)
663 : : {
664 : : struct wakeup_source *ws;
665 : : int active = 0;
666 : : struct wakeup_source *last_activity_ws = NULL;
667 : :
668 : : rcu_read_lock();
669 [ # # ]: 0 : list_for_each_entry_rcu(ws, &wakeup_sources, entry) {
670 [ # # ]: 0 : if (ws->active) {
671 : 0 : pr_info("active wakeup source: %s\n", ws->name);
672 : : active = 1;
673 [ # # ][ # # ]: 0 : } else if (!active &&
674 [ # # ]: 0 : (!last_activity_ws ||
675 : 0 : ktime_to_ns(ws->last_time) >
676 : 0 : ktime_to_ns(last_activity_ws->last_time))) {
677 : : last_activity_ws = ws;
678 : : }
679 : : }
680 : :
681 [ # # ]: 0 : if (!active && last_activity_ws)
682 : 0 : pr_info("last active wakeup source: %s\n",
683 : : last_activity_ws->name);
684 : : rcu_read_unlock();
685 : 0 : }
686 : : EXPORT_SYMBOL_GPL(pm_print_active_wakeup_sources);
687 : :
688 : : /**
689 : : * pm_wakeup_pending - Check if power transition in progress should be aborted.
690 : : *
691 : : * Compare the current number of registered wakeup events with its preserved
692 : : * value from the past and return true if new wakeup events have been registered
693 : : * since the old value was stored. Also return true if the current number of
694 : : * wakeup events being processed is different from zero.
695 : : */
696 : 0 : bool pm_wakeup_pending(void)
697 : : {
698 : : unsigned long flags;
699 : : bool ret = false;
700 : :
701 : 0 : spin_lock_irqsave(&events_lock, flags);
702 [ # # ]: 0 : if (events_check_enabled) {
703 : : unsigned int cnt, inpr;
704 : :
705 : : split_counters(&cnt, &inpr);
706 [ # # ][ # # ]: 0 : ret = (cnt != saved_count || inpr > 0);
707 : 0 : events_check_enabled = !ret;
708 : : }
709 : : spin_unlock_irqrestore(&events_lock, flags);
710 : :
711 [ # # ]: 0 : if (ret) {
712 : 0 : pr_info("PM: Wakeup pending, aborting suspend\n");
713 : 0 : pm_print_active_wakeup_sources();
714 : : }
715 : :
716 : 0 : return ret;
717 : : }
718 : :
719 : : /**
720 : : * pm_get_wakeup_count - Read the number of registered wakeup events.
721 : : * @count: Address to store the value at.
722 : : * @block: Whether or not to block.
723 : : *
724 : : * Store the number of registered wakeup events at the address in @count. If
725 : : * @block is set, block until the current number of wakeup events being
726 : : * processed is zero.
727 : : *
728 : : * Return 'false' if the current number of wakeup events being processed is
729 : : * nonzero. Otherwise return 'true'.
730 : : */
731 : 0 : bool pm_get_wakeup_count(unsigned int *count, bool block)
732 : : {
733 : : unsigned int cnt, inpr;
734 : :
735 [ # # ]: 0 : if (block) {
736 : 0 : DEFINE_WAIT(wait);
737 : :
738 : : for (;;) {
739 : 0 : prepare_to_wait(&wakeup_count_wait_queue, &wait,
740 : : TASK_INTERRUPTIBLE);
741 : : split_counters(&cnt, &inpr);
742 [ # # ][ # # ]: 0 : if (inpr == 0 || signal_pending(current))
743 : : break;
744 : :
745 : 0 : schedule();
746 : 0 : }
747 : 0 : finish_wait(&wakeup_count_wait_queue, &wait);
748 : : }
749 : :
750 : : split_counters(&cnt, &inpr);
751 : 0 : *count = cnt;
752 : 0 : return !inpr;
753 : : }
754 : :
755 : : /**
756 : : * pm_save_wakeup_count - Save the current number of registered wakeup events.
757 : : * @count: Value to compare with the current number of registered wakeup events.
758 : : *
759 : : * If @count is equal to the current number of registered wakeup events and the
760 : : * current number of wakeup events being processed is zero, store @count as the
761 : : * old number of registered wakeup events for pm_check_wakeup_events(), enable
762 : : * wakeup events detection and return 'true'. Otherwise disable wakeup events
763 : : * detection and return 'false'.
764 : : */
765 : 0 : bool pm_save_wakeup_count(unsigned int count)
766 : : {
767 : : unsigned int cnt, inpr;
768 : : unsigned long flags;
769 : :
770 : 0 : events_check_enabled = false;
771 : 0 : spin_lock_irqsave(&events_lock, flags);
772 : : split_counters(&cnt, &inpr);
773 [ # # ][ # # ]: 0 : if (cnt == count && inpr == 0) {
774 : 0 : saved_count = count;
775 : 0 : events_check_enabled = true;
776 : : }
777 : : spin_unlock_irqrestore(&events_lock, flags);
778 : 0 : return events_check_enabled;
779 : : }
780 : :
781 : : #ifdef CONFIG_PM_AUTOSLEEP
782 : : /**
783 : : * pm_wakep_autosleep_enabled - Modify autosleep_enabled for all wakeup sources.
784 : : * @enabled: Whether to set or to clear the autosleep_enabled flags.
785 : : */
786 : : void pm_wakep_autosleep_enabled(bool set)
787 : : {
788 : : struct wakeup_source *ws;
789 : : ktime_t now = ktime_get();
790 : :
791 : : rcu_read_lock();
792 : : list_for_each_entry_rcu(ws, &wakeup_sources, entry) {
793 : : spin_lock_irq(&ws->lock);
794 : : if (ws->autosleep_enabled != set) {
795 : : ws->autosleep_enabled = set;
796 : : if (ws->active) {
797 : : if (set)
798 : : ws->start_prevent_time = now;
799 : : else
800 : : update_prevent_sleep_time(ws, now);
801 : : }
802 : : }
803 : : spin_unlock_irq(&ws->lock);
804 : : }
805 : : rcu_read_unlock();
806 : : }
807 : : #endif /* CONFIG_PM_AUTOSLEEP */
808 : :
809 : : static struct dentry *wakeup_sources_stats_dentry;
810 : :
811 : : /**
812 : : * print_wakeup_source_stats - Print wakeup source statistics information.
813 : : * @m: seq_file to print the statistics into.
814 : : * @ws: Wakeup source object to print the statistics for.
815 : : */
816 : 0 : static int print_wakeup_source_stats(struct seq_file *m,
817 : : struct wakeup_source *ws)
818 : : {
819 : : unsigned long flags;
820 : : ktime_t total_time;
821 : : ktime_t max_time;
822 : : unsigned long active_count;
823 : : ktime_t active_time;
824 : : ktime_t prevent_sleep_time;
825 : : int ret;
826 : :
827 : 0 : spin_lock_irqsave(&ws->lock, flags);
828 : :
829 : 0 : total_time = ws->total_time;
830 : 0 : max_time = ws->max_time;
831 : 0 : prevent_sleep_time = ws->prevent_sleep_time;
832 : 0 : active_count = ws->active_count;
833 [ # # ]: 0 : if (ws->active) {
834 : 0 : ktime_t now = ktime_get();
835 : :
836 : 0 : active_time = ktime_sub(now, ws->last_time);
837 : 0 : total_time = ktime_add(total_time, active_time);
838 [ # # ]: 0 : if (active_time.tv64 > max_time.tv64)
839 : : max_time = active_time;
840 : :
841 [ # # ]: 0 : if (ws->autosleep_enabled)
842 : 0 : prevent_sleep_time = ktime_add(prevent_sleep_time,
843 : : ktime_sub(now, ws->start_prevent_time));
844 : : } else {
845 : : active_time = ktime_set(0, 0);
846 : : }
847 : :
848 : 0 : ret = seq_printf(m, "%-12s\t%lu\t\t%lu\t\t%lu\t\t%lu\t\t"
849 : : "%lld\t\t%lld\t\t%lld\t\t%lld\t\t%lld\n",
850 : : ws->name, active_count, ws->event_count,
851 : : ws->wakeup_count, ws->expire_count,
852 : : ktime_to_ms(active_time), ktime_to_ms(total_time),
853 : : ktime_to_ms(max_time), ktime_to_ms(ws->last_time),
854 : : ktime_to_ms(prevent_sleep_time));
855 : :
856 : : spin_unlock_irqrestore(&ws->lock, flags);
857 : :
858 : 0 : return ret;
859 : : }
860 : :
861 : : /**
862 : : * wakeup_sources_stats_show - Print wakeup sources statistics information.
863 : : * @m: seq_file to print the statistics into.
864 : : */
865 : 0 : static int wakeup_sources_stats_show(struct seq_file *m, void *unused)
866 : : {
867 : : struct wakeup_source *ws;
868 : :
869 : 0 : seq_puts(m, "name\t\tactive_count\tevent_count\twakeup_count\t"
870 : : "expire_count\tactive_since\ttotal_time\tmax_time\t"
871 : : "last_change\tprevent_suspend_time\n");
872 : :
873 : : rcu_read_lock();
874 [ # # ]: 0 : list_for_each_entry_rcu(ws, &wakeup_sources, entry)
875 : 0 : print_wakeup_source_stats(m, ws);
876 : : rcu_read_unlock();
877 : :
878 : 0 : return 0;
879 : : }
880 : :
881 : 0 : static int wakeup_sources_stats_open(struct inode *inode, struct file *file)
882 : : {
883 : 0 : return single_open(file, wakeup_sources_stats_show, NULL);
884 : : }
885 : :
886 : : static const struct file_operations wakeup_sources_stats_fops = {
887 : : .owner = THIS_MODULE,
888 : : .open = wakeup_sources_stats_open,
889 : : .read = seq_read,
890 : : .llseek = seq_lseek,
891 : : .release = single_release,
892 : : };
893 : :
894 : 0 : static int __init wakeup_sources_debugfs_init(void)
895 : : {
896 : 0 : wakeup_sources_stats_dentry = debugfs_create_file("wakeup_sources",
897 : : S_IRUGO, NULL, NULL, &wakeup_sources_stats_fops);
898 : 0 : return 0;
899 : : }
900 : :
901 : : postcore_initcall(wakeup_sources_debugfs_init);
|
