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