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