unknown changes from android-tegra-nv-3.4
[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         unsigned int cnt, inpr;
700
701         /**
702          * HACK: return true if event is in progress even though
703          * check is not enabled. This causes suspend to abort
704          * if wake_lock is acquired before starting suspend
705          * process and user has not enabled check. This HACK is for
706          * android wake locks to work.
707          */
708         spin_lock_irqsave(&events_lock, flags);
709         split_counters(&cnt, &inpr);
710         if (events_check_enabled) {
711                 ret = (cnt != saved_count || inpr > 0);
712                 events_check_enabled = !ret;
713         } else if (inpr > 0) {
714                 ret = true;
715         }
716         spin_unlock_irqrestore(&events_lock, flags);
717
718         if (ret)
719                 print_active_wakeup_sources();
720
721         return ret;
722 }
723
724 /**
725  * pm_get_wakeup_count - Read the number of registered wakeup events.
726  * @count: Address to store the value at.
727  * @block: Whether or not to block.
728  *
729  * Store the number of registered wakeup events at the address in @count.  If
730  * @block is set, block until the current number of wakeup events being
731  * processed is zero.
732  *
733  * Return 'false' if the current number of wakeup events being processed is
734  * nonzero.  Otherwise return 'true'.
735  */
736 bool pm_get_wakeup_count(unsigned int *count, bool block)
737 {
738         unsigned int cnt, inpr;
739
740         if (block) {
741                 DEFINE_WAIT(wait);
742
743                 for (;;) {
744                         prepare_to_wait(&wakeup_count_wait_queue, &wait,
745                                         TASK_INTERRUPTIBLE);
746                         split_counters(&cnt, &inpr);
747                         if (inpr == 0 || signal_pending(current))
748                                 break;
749
750                         schedule();
751                 }
752                 finish_wait(&wakeup_count_wait_queue, &wait);
753         }
754
755         split_counters(&cnt, &inpr);
756         *count = cnt;
757         return !inpr;
758 }
759
760 /**
761  * pm_save_wakeup_count - Save the current number of registered wakeup events.
762  * @count: Value to compare with the current number of registered wakeup events.
763  *
764  * If @count is equal to the current number of registered wakeup events and the
765  * current number of wakeup events being processed is zero, store @count as the
766  * old number of registered wakeup events for pm_check_wakeup_events(), enable
767  * wakeup events detection and return 'true'.  Otherwise disable wakeup events
768  * detection and return 'false'.
769  */
770 bool pm_save_wakeup_count(unsigned int count)
771 {
772         unsigned int cnt, inpr;
773         unsigned long flags;
774
775         events_check_enabled = false;
776         spin_lock_irqsave(&events_lock, flags);
777         split_counters(&cnt, &inpr);
778         if (cnt == count && inpr == 0) {
779                 saved_count = count;
780                 events_check_enabled = true;
781         }
782         spin_unlock_irqrestore(&events_lock, flags);
783         return events_check_enabled;
784 }
785
786 #ifdef CONFIG_PM_AUTOSLEEP
787 /**
788  * pm_wakep_autosleep_enabled - Modify autosleep_enabled for all wakeup sources.
789  * @enabled: Whether to set or to clear the autosleep_enabled flags.
790  */
791 void pm_wakep_autosleep_enabled(bool set)
792 {
793         struct wakeup_source *ws;
794         ktime_t now = ktime_get();
795
796         rcu_read_lock();
797         list_for_each_entry_rcu(ws, &wakeup_sources, entry) {
798                 spin_lock_irq(&ws->lock);
799                 if (ws->autosleep_enabled != set) {
800                         ws->autosleep_enabled = set;
801                         if (ws->active) {
802                                 if (set)
803                                         ws->start_prevent_time = now;
804                                 else
805                                         update_prevent_sleep_time(ws, now);
806                         }
807                 }
808                 spin_unlock_irq(&ws->lock);
809         }
810         rcu_read_unlock();
811 }
812 #endif /* CONFIG_PM_AUTOSLEEP */
813
814 static struct dentry *wakeup_sources_stats_dentry;
815
816 /**
817  * print_wakeup_source_stats - Print wakeup source statistics information.
818  * @m: seq_file to print the statistics into.
819  * @ws: Wakeup source object to print the statistics for.
820  */
821 static int print_wakeup_source_stats(struct seq_file *m,
822                                      struct wakeup_source *ws)
823 {
824         unsigned long flags;
825         ktime_t total_time;
826         ktime_t max_time;
827         unsigned long active_count;
828         ktime_t active_time;
829         ktime_t prevent_sleep_time;
830         int ret;
831
832         spin_lock_irqsave(&ws->lock, flags);
833
834         total_time = ws->total_time;
835         max_time = ws->max_time;
836         prevent_sleep_time = ws->prevent_sleep_time;
837         active_count = ws->active_count;
838         if (ws->active) {
839                 ktime_t now = ktime_get();
840
841                 active_time = ktime_sub(now, ws->last_time);
842                 total_time = ktime_add(total_time, active_time);
843                 if (active_time.tv64 > max_time.tv64)
844                         max_time = active_time;
845
846                 if (ws->autosleep_enabled)
847                         prevent_sleep_time = ktime_add(prevent_sleep_time,
848                                 ktime_sub(now, ws->start_prevent_time));
849         } else {
850                 active_time = ktime_set(0, 0);
851         }
852
853         ret = seq_printf(m, "%-12s\t%lu\t\t%lu\t\t%lu\t\t%lu\t\t"
854                         "%lld\t\t%lld\t\t%lld\t\t%lld\t\t%lld\n",
855                         ws->name, active_count, ws->event_count,
856                         ws->wakeup_count, ws->expire_count,
857                         ktime_to_ms(active_time), ktime_to_ms(total_time),
858                         ktime_to_ms(max_time), ktime_to_ms(ws->last_time),
859                         ktime_to_ms(prevent_sleep_time));
860
861         spin_unlock_irqrestore(&ws->lock, flags);
862
863         return ret;
864 }
865
866 /**
867  * wakeup_sources_stats_show - Print wakeup sources statistics information.
868  * @m: seq_file to print the statistics into.
869  */
870 static int wakeup_sources_stats_show(struct seq_file *m, void *unused)
871 {
872         struct wakeup_source *ws;
873
874         seq_puts(m, "name\t\tactive_count\tevent_count\twakeup_count\t"
875                 "expire_count\tactive_since\ttotal_time\tmax_time\t"
876                 "last_change\tprevent_suspend_time\n");
877
878         rcu_read_lock();
879         list_for_each_entry_rcu(ws, &wakeup_sources, entry)
880                 print_wakeup_source_stats(m, ws);
881         rcu_read_unlock();
882
883         return 0;
884 }
885
886 static int wakeup_sources_stats_open(struct inode *inode, struct file *file)
887 {
888         return single_open(file, wakeup_sources_stats_show, NULL);
889 }
890
891 static const struct file_operations wakeup_sources_stats_fops = {
892         .owner = THIS_MODULE,
893         .open = wakeup_sources_stats_open,
894         .read = seq_read,
895         .llseek = seq_lseek,
896         .release = single_release,
897 };
898
899 static int __init wakeup_sources_debugfs_init(void)
900 {
901         wakeup_sources_stats_dentry = debugfs_create_file("wakeup_sources",
902                         S_IRUGO, NULL, NULL, &wakeup_sources_stats_fops);
903         return 0;
904 }
905
906 postcore_initcall(wakeup_sources_debugfs_init);