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