1
2
3
4
5
6
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
23
24
25bool events_check_enabled __read_mostly;
26
27
28
29
30
31
32static 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
37static 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
46static unsigned int saved_count;
47
48static DEFINE_SPINLOCK(events_lock);
49
50static void pm_wakeup_timer_fn(unsigned long data);
51
52static LIST_HEAD(wakeup_sources);
53
54static DECLARE_WAIT_QUEUE_HEAD(wakeup_count_wait_queue);
55
56
57
58
59
60
61
62
63
64void 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}
71EXPORT_SYMBOL_GPL(wakeup_source_prepare);
72
73
74
75
76
77struct 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}
88EXPORT_SYMBOL_GPL(wakeup_source_create);
89
90
91
92
93
94
95
96
97void 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}
105EXPORT_SYMBOL_GPL(wakeup_source_drop);
106
107
108
109
110
111
112
113void 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}
122EXPORT_SYMBOL_GPL(wakeup_source_destroy);
123
124
125
126
127
128void 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}
144EXPORT_SYMBOL_GPL(wakeup_source_add);
145
146
147
148
149
150void 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}
162EXPORT_SYMBOL_GPL(wakeup_source_remove);
163
164
165
166
167
168struct 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}
178EXPORT_SYMBOL_GPL(wakeup_source_register);
179
180
181
182
183
184void wakeup_source_unregister(struct wakeup_source *ws)
185{
186 if (ws) {
187 wakeup_source_remove(ws);
188 wakeup_source_destroy(ws);
189 }
190}
191EXPORT_SYMBOL_GPL(wakeup_source_unregister);
192
193
194
195
196
197
198
199
200static 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
214
215
216
217
218int 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}
236EXPORT_SYMBOL_GPL(device_wakeup_enable);
237
238
239
240
241
242
243
244static 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
257
258
259
260
261
262int 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}
275EXPORT_SYMBOL_GPL(device_wakeup_disable);
276
277
278
279
280
281
282
283
284
285
286
287
288
289void 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}
304EXPORT_SYMBOL_GPL(device_set_wakeup_capable);
305
306
307
308
309
310
311
312
313
314
315
316
317int 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}
330EXPORT_SYMBOL_GPL(device_init_wakeup);
331
332
333
334
335
336int 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}
343EXPORT_SYMBOL_GPL(device_set_wakeup_enable);
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381static void wakeup_source_activate(struct wakeup_source *ws)
382{
383 unsigned int cec;
384
385
386
387
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
398 cec = atomic_inc_return(&combined_event_count);
399
400 trace_wakeup_source_activate(ws->name, cec);
401}
402
403
404
405
406
407static void wakeup_source_report_event(struct wakeup_source *ws)
408{
409 ws->event_count++;
410
411 if (events_check_enabled)
412 ws->wakeup_count++;
413
414 if (!ws->active)
415 wakeup_source_activate(ws);
416}
417
418
419
420
421
422
423
424void __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}
439EXPORT_SYMBOL_GPL(__pm_stay_awake);
440
441
442
443
444
445
446
447
448
449
450
451
452void 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}
463EXPORT_SYMBOL_GPL(pm_stay_awake);
464
465#ifdef CONFIG_PM_AUTOSLEEP
466static 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
472static inline void update_prevent_sleep_time(struct wakeup_source *ws,
473 ktime_t now) {}
474#endif
475
476
477
478
479
480
481
482
483
484static 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
493
494
495
496
497
498
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
522
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
534
535
536
537
538
539
540
541void __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}
553EXPORT_SYMBOL_GPL(__pm_relax);
554
555
556
557
558
559
560
561void 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}
572EXPORT_SYMBOL_GPL(pm_relax);
573
574
575
576
577
578
579
580
581
582static 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
600
601
602
603
604
605
606
607
608
609
610void __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}
639EXPORT_SYMBOL_GPL(__pm_wakeup_event);
640
641
642
643
644
645
646
647
648
649void 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}
660EXPORT_SYMBOL_GPL(pm_wakeup_event);
661
662static 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
689
690
691
692
693
694
695bool 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
718
719
720
721
722
723
724
725
726
727
728bool 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
754
755
756
757
758
759
760
761
762bool 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
781
782
783void 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
805
806static struct dentry *wakeup_sources_stats_dentry;
807
808
809
810
811
812
813static 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
860
861
862static 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
878static int wakeup_sources_stats_open(struct inode *inode, struct file *file)
879{
880 return single_open(file, wakeup_sources_stats_show, NULL);
881}
882
883static 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
891static 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
898postcore_initcall(wakeup_sources_debugfs_init);
899