79715e7fa43e34c9cbf9a4521a657d7bb952f9c6
[linux-3.10.git] / drivers / base / power / wakeup.c
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         unsigned int comb = atomic_read(&combined_event_count);
40
41         *cnt = (comb >> IN_PROGRESS_BITS);
42         *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 void wakeup_source_prepare(struct wakeup_source *ws, const char *name)
65 {
66         if (ws) {
67                 memset(ws, 0, sizeof(*ws));
68                 ws->name = name;
69         }
70 }
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 struct wakeup_source *wakeup_source_create(const char *name)
78 {
79         struct wakeup_source *ws;
80
81         ws = kmalloc(sizeof(*ws), GFP_KERNEL);
82         if (!ws)
83                 return NULL;
84
85         wakeup_source_prepare(ws, name ? kstrdup(name, GFP_KERNEL) : NULL);
86         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 void wakeup_source_drop(struct wakeup_source *ws)
98 {
99         if (!ws)
100                 return;
101
102         del_timer_sync(&ws->timer);
103         __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 void wakeup_source_destroy(struct wakeup_source *ws)
114 {
115         if (!ws)
116                 return;
117
118         wakeup_source_drop(ws);
119         kfree(ws->name);
120         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 void wakeup_source_add(struct wakeup_source *ws)
129 {
130         unsigned long flags;
131
132         if (WARN_ON(!ws))
133                 return;
134
135         spin_lock_init(&ws->lock);
136         setup_timer(&ws->timer, pm_wakeup_timer_fn, (unsigned long)ws);
137         ws->active = false;
138         ws->last_time = ktime_get();
139
140         spin_lock_irqsave(&events_lock, flags);
141         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 void wakeup_source_remove(struct wakeup_source *ws)
151 {
152         unsigned long flags;
153
154         if (WARN_ON(!ws))
155                 return;
156
157         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 struct wakeup_source *wakeup_source_register(const char *name)
169 {
170         struct wakeup_source *ws;
171
172         ws = wakeup_source_create(name);
173         if (ws)
174                 wakeup_source_add(ws);
175
176         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 void wakeup_source_unregister(struct wakeup_source *ws)
185 {
186         if (ws) {
187                 wakeup_source_remove(ws);
188                 wakeup_source_destroy(ws);
189         }
190 }
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 static int device_wakeup_attach(struct device *dev, struct wakeup_source *ws)
201 {
202         spin_lock_irq(&dev->power.lock);
203         if (dev->power.wakeup) {
204                 spin_unlock_irq(&dev->power.lock);
205                 return -EEXIST;
206         }
207         dev->power.wakeup = ws;
208         spin_unlock_irq(&dev->power.lock);
209         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 int device_wakeup_enable(struct device *dev)
219 {
220         struct wakeup_source *ws;
221         int ret;
222
223         if (!dev || !dev->power.can_wakeup)
224                 return -EINVAL;
225
226         ws = wakeup_source_register(dev_name(dev));
227         if (!ws)
228                 return -ENOMEM;
229
230         ret = device_wakeup_attach(dev, ws);
231         if (ret)
232                 wakeup_source_unregister(ws);
233
234         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 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         ws = dev->power.wakeup;
250         dev->power.wakeup = NULL;
251         spin_unlock_irq(&dev->power.lock);
252         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 int device_wakeup_disable(struct device *dev)
263 {
264         struct wakeup_source *ws;
265
266         if (!dev || !dev->power.can_wakeup)
267                 return -EINVAL;
268
269         ws = device_wakeup_detach(dev);
270         if (ws)
271                 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 void device_set_wakeup_capable(struct device *dev, bool capable)
290 {
291         if (!!dev->power.can_wakeup == !!capable)
292                 return;
293
294         if (device_is_registered(dev) && !list_empty(&dev->power.entry)) {
295                 if (capable) {
296                         if (wakeup_sysfs_add(dev))
297                                 return;
298                 } else {
299                         wakeup_sysfs_remove(dev);
300                 }
301         }
302         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 int device_init_wakeup(struct device *dev, bool enable)
318 {
319         int ret = 0;
320
321         if (enable) {
322                 device_set_wakeup_capable(dev, true);
323                 ret = device_wakeup_enable(dev);
324         } else {
325                 device_set_wakeup_capable(dev, false);
326         }
327
328         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 int device_set_wakeup_enable(struct device *dev, bool enable)
337 {
338         if (!dev || !dev->power.can_wakeup)
339                 return -EINVAL;
340
341         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 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         freeze_wake();
390
391         ws->active = true;
392         ws->active_count++;
393         ws->last_time = ktime_get();
394         if (ws->autosleep_enabled)
395                 ws->start_prevent_time = ws->last_time;
396
397         /* Increment the counter of events in progress. */
398         cec = atomic_inc_return(&combined_event_count);
399
400         trace_wakeup_source_activate(ws->name, cec);
401 }
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 static void wakeup_source_report_event(struct wakeup_source *ws)
408 {
409         ws->event_count++;
410         /* This is racy, but the counter is approximate anyway. */
411         if (events_check_enabled)
412                 ws->wakeup_count++;
413
414         if (!ws->active)
415                 wakeup_source_activate(ws);
416 }
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 void __pm_stay_awake(struct wakeup_source *ws)
425 {
426         unsigned long flags;
427
428         if (!ws)
429                 return;
430
431         spin_lock_irqsave(&ws->lock, flags);
432
433         wakeup_source_report_event(ws);
434         del_timer(&ws->timer);
435         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 void pm_stay_awake(struct device *dev)
453 {
454         unsigned long flags;
455
456         if (!dev)
457                 return;
458
459         spin_lock_irqsave(&dev->power.lock, flags);
460         __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 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         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         if (ws->relax_count != ws->active_count) {
501                 ws->relax_count--;
502                 return;
503         }
504
505         ws->active = false;
506
507         now = ktime_get();
508         duration = ktime_sub(now, ws->last_time);
509         ws->total_time = ktime_add(ws->total_time, duration);
510         if (ktime_to_ns(duration) > ktime_to_ns(ws->max_time))
511                 ws->max_time = duration;
512
513         ws->last_time = now;
514         del_timer(&ws->timer);
515         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         cec = atomic_add_return(MAX_IN_PROGRESS, &combined_event_count);
525         trace_wakeup_source_deactivate(ws->name, cec);
526
527         split_counters(&cnt, &inpr);
528         if (!inpr && waitqueue_active(&wakeup_count_wait_queue))
529                 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 void __pm_relax(struct wakeup_source *ws)
542 {
543         unsigned long flags;
544
545         if (!ws)
546                 return;
547
548         spin_lock_irqsave(&ws->lock, flags);
549         if (ws->active)
550                 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 void pm_relax(struct device *dev)
562 {
563         unsigned long flags;
564
565         if (!dev)
566                 return;
567
568         spin_lock_irqsave(&dev->power.lock, flags);
569         __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 static void pm_wakeup_timer_fn(unsigned long data)
583 {
584         struct wakeup_source *ws = (struct wakeup_source *)data;
585         unsigned long flags;
586
587         spin_lock_irqsave(&ws->lock, flags);
588
589         if (ws->active && ws->timer_expires
590             && time_after_eq(jiffies, ws->timer_expires)) {
591                 wakeup_source_deactivate(ws);
592                 ws->expire_count++;
593         }
594
595         spin_unlock_irqrestore(&ws->lock, flags);
596 }
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 void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec)
611 {
612         unsigned long flags;
613         unsigned long expires;
614
615         if (!ws)
616                 return;
617
618         spin_lock_irqsave(&ws->lock, flags);
619
620         wakeup_source_report_event(ws);
621
622         if (!msec) {
623                 wakeup_source_deactivate(ws);
624                 goto unlock;
625         }
626
627         expires = jiffies + msecs_to_jiffies(msec);
628         if (!expires)
629                 expires = 1;
630
631         if (!ws->timer_expires || time_after(expires, ws->timer_expires)) {
632                 mod_timer(&ws->timer, expires);
633                 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 void pm_wakeup_event(struct device *dev, unsigned int msec)
650 {
651         unsigned long flags;
652
653         if (!dev)
654                 return;
655
656         spin_lock_irqsave(&dev->power.lock, flags);
657         __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 static void 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         list_for_each_entry_rcu(ws, &wakeup_sources, entry) {
670                 if (ws->active) {
671                         pr_info("active wakeup source: %s\n", ws->name);
672                         active = 1;
673                 } else if (!active &&
674                            (!last_activity_ws ||
675                             ktime_to_ns(ws->last_time) >
676                             ktime_to_ns(last_activity_ws->last_time))) {
677                         last_activity_ws = ws;
678                 }
679         }
680
681         if (!active && last_activity_ws)
682                 pr_info("last active wakeup source: %s\n",
683                         last_activity_ws->name);
684         rcu_read_unlock();
685 }
686
687 /**
688  * pm_wakeup_pending - Check if power transition in progress should be aborted.
689  *
690  * Compare the current number of registered wakeup events with its preserved
691  * value from the past and return true if new wakeup events have been registered
692  * since the old value was stored.  Also return true if the current number of
693  * wakeup events being processed is different from zero.
694  */
695 bool pm_wakeup_pending(void)
696 {
697         unsigned long flags;
698         bool ret = false;
699
700         spin_lock_irqsave(&events_lock, flags);
701         if (events_check_enabled) {
702                 unsigned int cnt, inpr;
703
704                 split_counters(&cnt, &inpr);
705                 ret = (cnt != saved_count || inpr > 0);
706                 events_check_enabled = !ret;
707         }
708         spin_unlock_irqrestore(&events_lock, flags);
709
710         if (ret)
711                 print_active_wakeup_sources();
712
713         return ret;
714 }
715
716 /**
717  * pm_get_wakeup_count - Read the number of registered wakeup events.
718  * @count: Address to store the value at.
719  * @block: Whether or not to block.
720  *
721  * Store the number of registered wakeup events at the address in @count.  If
722  * @block is set, block until the current number of wakeup events being
723  * processed is zero.
724  *
725  * Return 'false' if the current number of wakeup events being processed is
726  * nonzero.  Otherwise return 'true'.
727  */
728 bool pm_get_wakeup_count(unsigned int *count, bool block)
729 {
730         unsigned int cnt, inpr;
731
732         if (block) {
733                 DEFINE_WAIT(wait);
734
735                 for (;;) {
736                         prepare_to_wait(&wakeup_count_wait_queue, &wait,
737                                         TASK_INTERRUPTIBLE);
738                         split_counters(&cnt, &inpr);
739                         if (inpr == 0 || signal_pending(current))
740                                 break;
741
742                         schedule();
743                 }
744                 finish_wait(&wakeup_count_wait_queue, &wait);
745         }
746
747         split_counters(&cnt, &inpr);
748         *count = cnt;
749         return !inpr;
750 }
751
752 /**
753  * pm_save_wakeup_count - Save the current number of registered wakeup events.
754  * @count: Value to compare with the current number of registered wakeup events.
755  *
756  * If @count is equal to the current number of registered wakeup events and the
757  * current number of wakeup events being processed is zero, store @count as the
758  * old number of registered wakeup events for pm_check_wakeup_events(), enable
759  * wakeup events detection and return 'true'.  Otherwise disable wakeup events
760  * detection and return 'false'.
761  */
762 bool pm_save_wakeup_count(unsigned int count)
763 {
764         unsigned int cnt, inpr;
765         unsigned long flags;
766
767         events_check_enabled = false;
768         spin_lock_irqsave(&events_lock, flags);
769         split_counters(&cnt, &inpr);
770         if (cnt == count && inpr == 0) {
771                 saved_count = count;
772                 events_check_enabled = true;
773         }
774         spin_unlock_irqrestore(&events_lock, flags);
775         return events_check_enabled;
776 }
777
778 #ifdef CONFIG_PM_AUTOSLEEP
779 /**
780  * pm_wakep_autosleep_enabled - Modify autosleep_enabled for all wakeup sources.
781  * @enabled: Whether to set or to clear the autosleep_enabled flags.
782  */
783 void pm_wakep_autosleep_enabled(bool set)
784 {
785         struct wakeup_source *ws;
786         ktime_t now = ktime_get();
787
788         rcu_read_lock();
789         list_for_each_entry_rcu(ws, &wakeup_sources, entry) {
790                 spin_lock_irq(&ws->lock);
791                 if (ws->autosleep_enabled != set) {
792                         ws->autosleep_enabled = set;
793                         if (ws->active) {
794                                 if (set)
795                                         ws->start_prevent_time = now;
796                                 else
797                                         update_prevent_sleep_time(ws, now);
798                         }
799                 }
800                 spin_unlock_irq(&ws->lock);
801         }
802         rcu_read_unlock();
803 }
804 #endif /* CONFIG_PM_AUTOSLEEP */
805
806 static struct dentry *wakeup_sources_stats_dentry;
807
808 /**
809  * print_wakeup_source_stats - Print wakeup source statistics information.
810  * @m: seq_file to print the statistics into.
811  * @ws: Wakeup source object to print the statistics for.
812  */
813 static int print_wakeup_source_stats(struct seq_file *m,
814                                      struct wakeup_source *ws)
815 {
816         unsigned long flags;
817         ktime_t total_time;
818         ktime_t max_time;
819         unsigned long active_count;
820         ktime_t active_time;
821         ktime_t prevent_sleep_time;
822         int ret;
823
824         spin_lock_irqsave(&ws->lock, flags);
825
826         total_time = ws->total_time;
827         max_time = ws->max_time;
828         prevent_sleep_time = ws->prevent_sleep_time;
829         active_count = ws->active_count;
830         if (ws->active) {
831                 ktime_t now = ktime_get();
832
833                 active_time = ktime_sub(now, ws->last_time);
834                 total_time = ktime_add(total_time, active_time);
835                 if (active_time.tv64 > max_time.tv64)
836                         max_time = active_time;
837
838                 if (ws->autosleep_enabled)
839                         prevent_sleep_time = ktime_add(prevent_sleep_time,
840                                 ktime_sub(now, ws->start_prevent_time));
841         } else {
842                 active_time = ktime_set(0, 0);
843         }
844
845         ret = seq_printf(m, "%-12s\t%lu\t\t%lu\t\t%lu\t\t%lu\t\t"
846                         "%lld\t\t%lld\t\t%lld\t\t%lld\t\t%lld\n",
847                         ws->name, active_count, ws->event_count,
848                         ws->wakeup_count, ws->expire_count,
849                         ktime_to_ms(active_time), ktime_to_ms(total_time),
850                         ktime_to_ms(max_time), ktime_to_ms(ws->last_time),
851                         ktime_to_ms(prevent_sleep_time));
852
853         spin_unlock_irqrestore(&ws->lock, flags);
854
855         return ret;
856 }
857
858 /**
859  * wakeup_sources_stats_show - Print wakeup sources statistics information.
860  * @m: seq_file to print the statistics into.
861  */
862 static int wakeup_sources_stats_show(struct seq_file *m, void *unused)
863 {
864         struct wakeup_source *ws;
865
866         seq_puts(m, "name\t\tactive_count\tevent_count\twakeup_count\t"
867                 "expire_count\tactive_since\ttotal_time\tmax_time\t"
868                 "last_change\tprevent_suspend_time\n");
869
870         rcu_read_lock();
871         list_for_each_entry_rcu(ws, &wakeup_sources, entry)
872                 print_wakeup_source_stats(m, ws);
873         rcu_read_unlock();
874
875         return 0;
876 }
877
878 static int wakeup_sources_stats_open(struct inode *inode, struct file *file)
879 {
880         return single_open(file, wakeup_sources_stats_show, NULL);
881 }
882
883 static const struct file_operations wakeup_sources_stats_fops = {
884         .owner = THIS_MODULE,
885         .open = wakeup_sources_stats_open,
886         .read = seq_read,
887         .llseek = seq_lseek,
888         .release = single_release,
889 };
890
891 static int __init wakeup_sources_debugfs_init(void)
892 {
893         wakeup_sources_stats_dentry = debugfs_create_file("wakeup_sources",
894                         S_IRUGO, NULL, NULL, &wakeup_sources_stats_fops);
895         return 0;
896 }
897
898 postcore_initcall(wakeup_sources_debugfs_init);