Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * drivers/base/power/main.c - Where the driver meets power management.
4 : : *
5 : : * Copyright (c) 2003 Patrick Mochel
6 : : * Copyright (c) 2003 Open Source Development Lab
7 : : *
8 : : * The driver model core calls device_pm_add() when a device is registered.
9 : : * This will initialize the embedded device_pm_info object in the device
10 : : * and add it to the list of power-controlled devices. sysfs entries for
11 : : * controlling device power management will also be added.
12 : : *
13 : : * A separate list is used for keeping track of power info, because the power
14 : : * domain dependencies may differ from the ancestral dependencies that the
15 : : * subsystem list maintains.
16 : : */
17 : :
18 : : #define pr_fmt(fmt) "PM: " fmt
19 : :
20 : : #include <linux/device.h>
21 : : #include <linux/export.h>
22 : : #include <linux/mutex.h>
23 : : #include <linux/pm.h>
24 : : #include <linux/pm_runtime.h>
25 : : #include <linux/pm-trace.h>
26 : : #include <linux/pm_wakeirq.h>
27 : : #include <linux/interrupt.h>
28 : : #include <linux/sched.h>
29 : : #include <linux/sched/debug.h>
30 : : #include <linux/async.h>
31 : : #include <linux/suspend.h>
32 : : #include <trace/events/power.h>
33 : : #include <linux/cpufreq.h>
34 : : #include <linux/cpuidle.h>
35 : : #include <linux/devfreq.h>
36 : : #include <linux/timer.h>
37 : :
38 : : #include "../base.h"
39 : : #include "power.h"
40 : :
41 : : typedef int (*pm_callback_t)(struct device *);
42 : :
43 : : /*
44 : : * The entries in the dpm_list list are in a depth first order, simply
45 : : * because children are guaranteed to be discovered after parents, and
46 : : * are inserted at the back of the list on discovery.
47 : : *
48 : : * Since device_pm_add() may be called with a device lock held,
49 : : * we must never try to acquire a device lock while holding
50 : : * dpm_list_mutex.
51 : : */
52 : :
53 : : LIST_HEAD(dpm_list);
54 : : static LIST_HEAD(dpm_prepared_list);
55 : : static LIST_HEAD(dpm_suspended_list);
56 : : static LIST_HEAD(dpm_late_early_list);
57 : : static LIST_HEAD(dpm_noirq_list);
58 : :
59 : : struct suspend_stats suspend_stats;
60 : : static DEFINE_MUTEX(dpm_list_mtx);
61 : : static pm_message_t pm_transition;
62 : :
63 : : static int async_error;
64 : :
65 : 0 : static const char *pm_verb(int event)
66 : : {
67 [ # # # # : 0 : switch (event) {
# # # #
# ]
68 : : case PM_EVENT_SUSPEND:
69 : : return "suspend";
70 : 0 : case PM_EVENT_RESUME:
71 : 0 : return "resume";
72 : 0 : case PM_EVENT_FREEZE:
73 : 0 : return "freeze";
74 : 0 : case PM_EVENT_QUIESCE:
75 : 0 : return "quiesce";
76 : 0 : case PM_EVENT_HIBERNATE:
77 : 0 : return "hibernate";
78 : 0 : case PM_EVENT_THAW:
79 : 0 : return "thaw";
80 : 0 : case PM_EVENT_RESTORE:
81 : 0 : return "restore";
82 : 0 : case PM_EVENT_RECOVER:
83 : 0 : return "recover";
84 : 0 : default:
85 : 0 : return "(unknown PM event)";
86 : : }
87 : : }
88 : :
89 : : /**
90 : : * device_pm_sleep_init - Initialize system suspend-related device fields.
91 : : * @dev: Device object being initialized.
92 : : */
93 : 4056 : void device_pm_sleep_init(struct device *dev)
94 : : {
95 : 4056 : dev->power.is_prepared = false;
96 : 4056 : dev->power.is_suspended = false;
97 : 4056 : dev->power.is_noirq_suspended = false;
98 : 4056 : dev->power.is_late_suspended = false;
99 : 4056 : init_completion(&dev->power.completion);
100 : 4056 : complete_all(&dev->power.completion);
101 : 4056 : dev->power.wakeup = NULL;
102 : 4056 : INIT_LIST_HEAD(&dev->power.entry);
103 : 4056 : }
104 : :
105 : : /**
106 : : * device_pm_lock - Lock the list of active devices used by the PM core.
107 : : */
108 : 13 : void device_pm_lock(void)
109 : : {
110 : 13 : mutex_lock(&dpm_list_mtx);
111 : 13 : }
112 : :
113 : : /**
114 : : * device_pm_unlock - Unlock the list of active devices used by the PM core.
115 : : */
116 : 13 : void device_pm_unlock(void)
117 : : {
118 : 13 : mutex_unlock(&dpm_list_mtx);
119 : 0 : }
120 : :
121 : : /**
122 : : * device_pm_add - Add a device to the PM core's list of active devices.
123 : : * @dev: Device to add to the list.
124 : : */
125 : 3978 : void device_pm_add(struct device *dev)
126 : : {
127 : : /* Skip PM setup/initialization. */
128 [ + + ]: 3978 : if (device_pm_not_required(dev))
129 : : return;
130 : :
131 : 3770 : pr_debug("Adding info for %s:%s\n",
132 : : dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
133 : 3770 : device_pm_check_callbacks(dev);
134 : 3770 : mutex_lock(&dpm_list_mtx);
135 [ + + - + ]: 3770 : if (dev->parent && dev->parent->power.is_prepared)
136 [ # # ]: 0 : dev_warn(dev, "parent %s should not be sleeping\n",
137 : : dev_name(dev->parent));
138 : 3770 : list_add_tail(&dev->power.entry, &dpm_list);
139 : 3770 : dev->power.in_dpm_list = true;
140 : 3770 : mutex_unlock(&dpm_list_mtx);
141 : : }
142 : :
143 : : /**
144 : : * device_pm_remove - Remove a device from the PM core's list of active devices.
145 : : * @dev: Device to be removed from the list.
146 : : */
147 : 13 : void device_pm_remove(struct device *dev)
148 : : {
149 [ - + ]: 13 : if (device_pm_not_required(dev))
150 : : return;
151 : :
152 : 0 : pr_debug("Removing info for %s:%s\n",
153 : : dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
154 : 0 : complete_all(&dev->power.completion);
155 : 0 : mutex_lock(&dpm_list_mtx);
156 : 0 : list_del_init(&dev->power.entry);
157 : 0 : dev->power.in_dpm_list = false;
158 : 0 : mutex_unlock(&dpm_list_mtx);
159 : 0 : device_wakeup_disable(dev);
160 : 0 : pm_runtime_remove(dev);
161 : 0 : device_pm_check_callbacks(dev);
162 : : }
163 : :
164 : : /**
165 : : * device_pm_move_before - Move device in the PM core's list of active devices.
166 : : * @deva: Device to move in dpm_list.
167 : : * @devb: Device @deva should come before.
168 : : */
169 : 0 : void device_pm_move_before(struct device *deva, struct device *devb)
170 : : {
171 : 0 : pr_debug("Moving %s:%s before %s:%s\n",
172 : : deva->bus ? deva->bus->name : "No Bus", dev_name(deva),
173 : : devb->bus ? devb->bus->name : "No Bus", dev_name(devb));
174 : : /* Delete deva from dpm_list and reinsert before devb. */
175 : 0 : list_move_tail(&deva->power.entry, &devb->power.entry);
176 : 0 : }
177 : :
178 : : /**
179 : : * device_pm_move_after - Move device in the PM core's list of active devices.
180 : : * @deva: Device to move in dpm_list.
181 : : * @devb: Device @deva should come after.
182 : : */
183 : 0 : void device_pm_move_after(struct device *deva, struct device *devb)
184 : : {
185 : 0 : pr_debug("Moving %s:%s after %s:%s\n",
186 : : deva->bus ? deva->bus->name : "No Bus", dev_name(deva),
187 : : devb->bus ? devb->bus->name : "No Bus", dev_name(devb));
188 : : /* Delete deva from dpm_list and reinsert after devb. */
189 : 0 : list_move(&deva->power.entry, &devb->power.entry);
190 : 0 : }
191 : :
192 : : /**
193 : : * device_pm_move_last - Move device to end of the PM core's list of devices.
194 : : * @dev: Device to move in dpm_list.
195 : : */
196 : 0 : void device_pm_move_last(struct device *dev)
197 : : {
198 : 0 : pr_debug("Moving %s:%s to end of list\n",
199 : : dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
200 : 0 : list_move_tail(&dev->power.entry, &dpm_list);
201 : 0 : }
202 : :
203 : 0 : static ktime_t initcall_debug_start(struct device *dev, void *cb)
204 : : {
205 [ # # ]: 0 : if (!pm_print_times_enabled)
206 : : return 0;
207 : :
208 [ # # ]: 0 : dev_info(dev, "calling %pS @ %i, parent: %s\n", cb,
209 : : task_pid_nr(current),
210 : : dev->parent ? dev_name(dev->parent) : "none");
211 : 0 : return ktime_get();
212 : : }
213 : :
214 : 0 : static void initcall_debug_report(struct device *dev, ktime_t calltime,
215 : : void *cb, int error)
216 : : {
217 : 0 : ktime_t rettime;
218 : 0 : s64 nsecs;
219 : :
220 [ # # ]: 0 : if (!pm_print_times_enabled)
221 : : return;
222 : :
223 : 0 : rettime = ktime_get();
224 : 0 : nsecs = (s64) ktime_to_ns(ktime_sub(rettime, calltime));
225 : :
226 : 0 : dev_info(dev, "%pS returned %d after %Ld usecs\n", cb, error,
227 : : (unsigned long long)nsecs >> 10);
228 : : }
229 : :
230 : : /**
231 : : * dpm_wait - Wait for a PM operation to complete.
232 : : * @dev: Device to wait for.
233 : : * @async: If unset, wait only if the device's power.async_suspend flag is set.
234 : : */
235 : 0 : static void dpm_wait(struct device *dev, bool async)
236 : : {
237 [ # # ]: 0 : if (!dev)
238 : : return;
239 : :
240 [ # # # # : 0 : if (async || (pm_async_enabled && dev->power.async_suspend))
# # ]
241 : 0 : wait_for_completion(&dev->power.completion);
242 : : }
243 : :
244 : 0 : static int dpm_wait_fn(struct device *dev, void *async_ptr)
245 : : {
246 : 0 : dpm_wait(dev, *((bool *)async_ptr));
247 : 0 : return 0;
248 : : }
249 : :
250 : 0 : static void dpm_wait_for_children(struct device *dev, bool async)
251 : : {
252 : 0 : device_for_each_child(dev, &async, dpm_wait_fn);
253 : : }
254 : :
255 : 0 : static void dpm_wait_for_suppliers(struct device *dev, bool async)
256 : : {
257 : 0 : struct device_link *link;
258 : 0 : int idx;
259 : :
260 : 0 : idx = device_links_read_lock();
261 : :
262 : : /*
263 : : * If the supplier goes away right after we've checked the link to it,
264 : : * we'll wait for its completion to change the state, but that's fine,
265 : : * because the only things that will block as a result are the SRCU
266 : : * callbacks freeing the link objects for the links in the list we're
267 : : * walking.
268 : : */
269 [ # # ]: 0 : list_for_each_entry_rcu(link, &dev->links.suppliers, c_node)
270 [ # # ]: 0 : if (READ_ONCE(link->status) != DL_STATE_DORMANT)
271 : 0 : dpm_wait(link->supplier, async);
272 : :
273 : 0 : device_links_read_unlock(idx);
274 : 0 : }
275 : :
276 : 0 : static bool dpm_wait_for_superior(struct device *dev, bool async)
277 : : {
278 : 0 : struct device *parent;
279 : :
280 : : /*
281 : : * If the device is resumed asynchronously and the parent's callback
282 : : * deletes both the device and the parent itself, the parent object may
283 : : * be freed while this function is running, so avoid that by reference
284 : : * counting the parent once more unless the device has been deleted
285 : : * already (in which case return right away).
286 : : */
287 : 0 : mutex_lock(&dpm_list_mtx);
288 : :
289 [ # # ]: 0 : if (!device_pm_initialized(dev)) {
290 : 0 : mutex_unlock(&dpm_list_mtx);
291 : 0 : return false;
292 : : }
293 : :
294 : 0 : parent = get_device(dev->parent);
295 : :
296 : 0 : mutex_unlock(&dpm_list_mtx);
297 : :
298 : 0 : dpm_wait(parent, async);
299 : 0 : put_device(parent);
300 : :
301 : 0 : dpm_wait_for_suppliers(dev, async);
302 : :
303 : : /*
304 : : * If the parent's callback has deleted the device, attempting to resume
305 : : * it would be invalid, so avoid doing that then.
306 : : */
307 : 0 : return device_pm_initialized(dev);
308 : : }
309 : :
310 : 0 : static void dpm_wait_for_consumers(struct device *dev, bool async)
311 : : {
312 : 0 : struct device_link *link;
313 : 0 : int idx;
314 : :
315 : 0 : idx = device_links_read_lock();
316 : :
317 : : /*
318 : : * The status of a device link can only be changed from "dormant" by a
319 : : * probe, but that cannot happen during system suspend/resume. In
320 : : * theory it can change to "dormant" at that time, but then it is
321 : : * reasonable to wait for the target device anyway (eg. if it goes
322 : : * away, it's better to wait for it to go away completely and then
323 : : * continue instead of trying to continue in parallel with its
324 : : * unregistration).
325 : : */
326 [ # # ]: 0 : list_for_each_entry_rcu(link, &dev->links.consumers, s_node)
327 [ # # ]: 0 : if (READ_ONCE(link->status) != DL_STATE_DORMANT)
328 : 0 : dpm_wait(link->consumer, async);
329 : :
330 : 0 : device_links_read_unlock(idx);
331 : 0 : }
332 : :
333 : 0 : static void dpm_wait_for_subordinate(struct device *dev, bool async)
334 : : {
335 : 0 : dpm_wait_for_children(dev, async);
336 : 0 : dpm_wait_for_consumers(dev, async);
337 : 0 : }
338 : :
339 : : /**
340 : : * pm_op - Return the PM operation appropriate for given PM event.
341 : : * @ops: PM operations to choose from.
342 : : * @state: PM transition of the system being carried out.
343 : : */
344 : 0 : static pm_callback_t pm_op(const struct dev_pm_ops *ops, pm_message_t state)
345 : : {
346 [ # # # # : 0 : switch (state.event) {
# # # ]
347 : : #ifdef CONFIG_SUSPEND
348 : 0 : case PM_EVENT_SUSPEND:
349 : 0 : return ops->suspend;
350 : 0 : case PM_EVENT_RESUME:
351 : 0 : return ops->resume;
352 : : #endif /* CONFIG_SUSPEND */
353 : : #ifdef CONFIG_HIBERNATE_CALLBACKS
354 : 0 : case PM_EVENT_FREEZE:
355 : : case PM_EVENT_QUIESCE:
356 : 0 : return ops->freeze;
357 : 0 : case PM_EVENT_HIBERNATE:
358 : 0 : return ops->poweroff;
359 : 0 : case PM_EVENT_THAW:
360 : : case PM_EVENT_RECOVER:
361 : 0 : return ops->thaw;
362 : 0 : break;
363 : 0 : case PM_EVENT_RESTORE:
364 : 0 : return ops->restore;
365 : : #endif /* CONFIG_HIBERNATE_CALLBACKS */
366 : : }
367 : :
368 : : return NULL;
369 : : }
370 : :
371 : : /**
372 : : * pm_late_early_op - Return the PM operation appropriate for given PM event.
373 : : * @ops: PM operations to choose from.
374 : : * @state: PM transition of the system being carried out.
375 : : *
376 : : * Runtime PM is disabled for @dev while this function is being executed.
377 : : */
378 : 0 : static pm_callback_t pm_late_early_op(const struct dev_pm_ops *ops,
379 : : pm_message_t state)
380 : : {
381 [ # # # # : 0 : switch (state.event) {
# # # ]
382 : : #ifdef CONFIG_SUSPEND
383 : 0 : case PM_EVENT_SUSPEND:
384 : 0 : return ops->suspend_late;
385 : 0 : case PM_EVENT_RESUME:
386 : 0 : return ops->resume_early;
387 : : #endif /* CONFIG_SUSPEND */
388 : : #ifdef CONFIG_HIBERNATE_CALLBACKS
389 : 0 : case PM_EVENT_FREEZE:
390 : : case PM_EVENT_QUIESCE:
391 : 0 : return ops->freeze_late;
392 : 0 : case PM_EVENT_HIBERNATE:
393 : 0 : return ops->poweroff_late;
394 : 0 : case PM_EVENT_THAW:
395 : : case PM_EVENT_RECOVER:
396 : 0 : return ops->thaw_early;
397 : 0 : case PM_EVENT_RESTORE:
398 : 0 : return ops->restore_early;
399 : : #endif /* CONFIG_HIBERNATE_CALLBACKS */
400 : : }
401 : :
402 : : return NULL;
403 : : }
404 : :
405 : : /**
406 : : * pm_noirq_op - Return the PM operation appropriate for given PM event.
407 : : * @ops: PM operations to choose from.
408 : : * @state: PM transition of the system being carried out.
409 : : *
410 : : * The driver of @dev will not receive interrupts while this function is being
411 : : * executed.
412 : : */
413 : 0 : static pm_callback_t pm_noirq_op(const struct dev_pm_ops *ops, pm_message_t state)
414 : : {
415 [ # # # # : 0 : switch (state.event) {
# # # ]
416 : : #ifdef CONFIG_SUSPEND
417 : 0 : case PM_EVENT_SUSPEND:
418 : 0 : return ops->suspend_noirq;
419 : 0 : case PM_EVENT_RESUME:
420 : 0 : return ops->resume_noirq;
421 : : #endif /* CONFIG_SUSPEND */
422 : : #ifdef CONFIG_HIBERNATE_CALLBACKS
423 : 0 : case PM_EVENT_FREEZE:
424 : : case PM_EVENT_QUIESCE:
425 : 0 : return ops->freeze_noirq;
426 : 0 : case PM_EVENT_HIBERNATE:
427 : 0 : return ops->poweroff_noirq;
428 : 0 : case PM_EVENT_THAW:
429 : : case PM_EVENT_RECOVER:
430 : 0 : return ops->thaw_noirq;
431 : 0 : case PM_EVENT_RESTORE:
432 : 0 : return ops->restore_noirq;
433 : : #endif /* CONFIG_HIBERNATE_CALLBACKS */
434 : : }
435 : :
436 : : return NULL;
437 : : }
438 : :
439 : 0 : static void pm_dev_dbg(struct device *dev, pm_message_t state, const char *info)
440 : : {
441 : 0 : dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
442 : : ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?
443 : : ", may wakeup" : "");
444 : : }
445 : :
446 : 0 : static void pm_dev_err(struct device *dev, pm_message_t state, const char *info,
447 : : int error)
448 : : {
449 [ # # ]: 0 : pr_err("Device %s failed to %s%s: error %d\n",
450 : : dev_name(dev), pm_verb(state.event), info, error);
451 : 0 : }
452 : :
453 : 0 : static void dpm_show_time(ktime_t starttime, pm_message_t state, int error,
454 : : const char *info)
455 : : {
456 : 0 : ktime_t calltime;
457 : 0 : u64 usecs64;
458 : 0 : int usecs;
459 : :
460 : 0 : calltime = ktime_get();
461 [ # # ]: 0 : usecs64 = ktime_to_ns(ktime_sub(calltime, starttime));
462 : 0 : do_div(usecs64, NSEC_PER_USEC);
463 : 0 : usecs = usecs64;
464 [ # # ]: 0 : if (usecs == 0)
465 : 0 : usecs = 1;
466 : :
467 [ # # # # : 0 : pm_pr_dbg("%s%s%s of devices %s after %ld.%03ld msecs\n",
# # ]
468 : : info ?: "", info ? " " : "", pm_verb(state.event),
469 : : error ? "aborted" : "complete",
470 : : usecs / USEC_PER_MSEC, usecs % USEC_PER_MSEC);
471 : 0 : }
472 : :
473 : 0 : static int dpm_run_callback(pm_callback_t cb, struct device *dev,
474 : : pm_message_t state, const char *info)
475 : : {
476 : 0 : ktime_t calltime;
477 : 0 : int error;
478 : :
479 [ # # ]: 0 : if (!cb)
480 : : return 0;
481 : :
482 : 0 : calltime = initcall_debug_start(dev, cb);
483 : :
484 : 0 : pm_dev_dbg(dev, state, info);
485 : 0 : trace_device_pm_callback_start(dev, info, state.event);
486 : 0 : error = cb(dev);
487 : 0 : trace_device_pm_callback_end(dev, error);
488 : 0 : suspend_report_result(cb, error);
489 : :
490 : 0 : initcall_debug_report(dev, calltime, cb, error);
491 : :
492 : 0 : return error;
493 : : }
494 : :
495 : : #ifdef CONFIG_DPM_WATCHDOG
496 : : struct dpm_watchdog {
497 : : struct device *dev;
498 : : struct task_struct *tsk;
499 : : struct timer_list timer;
500 : : };
501 : :
502 : : #define DECLARE_DPM_WATCHDOG_ON_STACK(wd) \
503 : : struct dpm_watchdog wd
504 : :
505 : : /**
506 : : * dpm_watchdog_handler - Driver suspend / resume watchdog handler.
507 : : * @t: The timer that PM watchdog depends on.
508 : : *
509 : : * Called when a driver has timed out suspending or resuming.
510 : : * There's not much we can do here to recover so panic() to
511 : : * capture a crash-dump in pstore.
512 : : */
513 : : static void dpm_watchdog_handler(struct timer_list *t)
514 : : {
515 : : struct dpm_watchdog *wd = from_timer(wd, t, timer);
516 : :
517 : : dev_emerg(wd->dev, "**** DPM device timeout ****\n");
518 : : show_stack(wd->tsk, NULL);
519 : : panic("%s %s: unrecoverable failure\n",
520 : : dev_driver_string(wd->dev), dev_name(wd->dev));
521 : : }
522 : :
523 : : /**
524 : : * dpm_watchdog_set - Enable pm watchdog for given device.
525 : : * @wd: Watchdog. Must be allocated on the stack.
526 : : * @dev: Device to handle.
527 : : */
528 : : static void dpm_watchdog_set(struct dpm_watchdog *wd, struct device *dev)
529 : : {
530 : : struct timer_list *timer = &wd->timer;
531 : :
532 : : wd->dev = dev;
533 : : wd->tsk = current;
534 : :
535 : : timer_setup_on_stack(timer, dpm_watchdog_handler, 0);
536 : : /* use same timeout value for both suspend and resume */
537 : : timer->expires = jiffies + HZ * CONFIG_DPM_WATCHDOG_TIMEOUT;
538 : : add_timer(timer);
539 : : }
540 : :
541 : : /**
542 : : * dpm_watchdog_clear - Disable suspend/resume watchdog.
543 : : * @wd: Watchdog to disable.
544 : : */
545 : : static void dpm_watchdog_clear(struct dpm_watchdog *wd)
546 : : {
547 : : struct timer_list *timer = &wd->timer;
548 : :
549 : : del_timer_sync(timer);
550 : : destroy_timer_on_stack(timer);
551 : : }
552 : : #else
553 : : #define DECLARE_DPM_WATCHDOG_ON_STACK(wd)
554 : : #define dpm_watchdog_set(x, y)
555 : : #define dpm_watchdog_clear(x)
556 : : #endif
557 : :
558 : : /*------------------------- Resume routines -------------------------*/
559 : :
560 : : /**
561 : : * suspend_event - Return a "suspend" message for given "resume" one.
562 : : * @resume_msg: PM message representing a system-wide resume transition.
563 : : */
564 : 0 : static pm_message_t suspend_event(pm_message_t resume_msg)
565 : : {
566 : 0 : switch (resume_msg.event) {
567 : : case PM_EVENT_RESUME:
568 : : return PMSG_SUSPEND;
569 : 0 : case PM_EVENT_THAW:
570 : : case PM_EVENT_RESTORE:
571 : 0 : return PMSG_FREEZE;
572 : 0 : case PM_EVENT_RECOVER:
573 : 0 : return PMSG_HIBERNATE;
574 : : }
575 : 0 : return PMSG_ON;
576 : : }
577 : :
578 : : /**
579 : : * dev_pm_may_skip_resume - System-wide device resume optimization check.
580 : : * @dev: Target device.
581 : : *
582 : : * Checks whether or not the device may be left in suspend after a system-wide
583 : : * transition to the working state.
584 : : */
585 : 0 : bool dev_pm_may_skip_resume(struct device *dev)
586 : : {
587 [ # # # # : 0 : return !dev->power.must_resume && pm_transition.event != PM_EVENT_RESTORE;
# # ]
588 : : }
589 : :
590 : 0 : static pm_callback_t dpm_subsys_resume_noirq_cb(struct device *dev,
591 : : pm_message_t state,
592 : : const char **info_p)
593 : : {
594 : 0 : pm_callback_t callback;
595 : 0 : const char *info;
596 : :
597 [ # # ]: 0 : if (dev->pm_domain) {
598 : 0 : info = "noirq power domain ";
599 : 0 : callback = pm_noirq_op(&dev->pm_domain->ops, state);
600 [ # # # # ]: 0 : } else if (dev->type && dev->type->pm) {
601 : 0 : info = "noirq type ";
602 : 0 : callback = pm_noirq_op(dev->type->pm, state);
603 [ # # # # ]: 0 : } else if (dev->class && dev->class->pm) {
604 : 0 : info = "noirq class ";
605 : 0 : callback = pm_noirq_op(dev->class->pm, state);
606 [ # # # # ]: 0 : } else if (dev->bus && dev->bus->pm) {
607 : 0 : info = "noirq bus ";
608 : 0 : callback = pm_noirq_op(dev->bus->pm, state);
609 : : } else {
610 : : return NULL;
611 : : }
612 : :
613 [ # # ]: 0 : if (info_p)
614 : 0 : *info_p = info;
615 : :
616 : : return callback;
617 : : }
618 : :
619 : : static pm_callback_t dpm_subsys_suspend_noirq_cb(struct device *dev,
620 : : pm_message_t state,
621 : : const char **info_p);
622 : :
623 : : static pm_callback_t dpm_subsys_suspend_late_cb(struct device *dev,
624 : : pm_message_t state,
625 : : const char **info_p);
626 : :
627 : : /**
628 : : * device_resume_noirq - Execute a "noirq resume" callback for given device.
629 : : * @dev: Device to handle.
630 : : * @state: PM transition of the system being carried out.
631 : : * @async: If true, the device is being resumed asynchronously.
632 : : *
633 : : * The driver of @dev will not receive interrupts while this function is being
634 : : * executed.
635 : : */
636 : 0 : static int device_resume_noirq(struct device *dev, pm_message_t state, bool async)
637 : : {
638 : 0 : pm_callback_t callback;
639 : 0 : const char *info;
640 : 0 : bool skip_resume;
641 : 0 : int error = 0;
642 : :
643 [ # # ]: 0 : TRACE_DEVICE(dev);
644 [ # # ]: 0 : TRACE_RESUME(0);
645 : :
646 [ # # # # ]: 0 : if (dev->power.syscore || dev->power.direct_complete)
647 : 0 : goto Out;
648 : :
649 [ # # ]: 0 : if (!dev->power.is_noirq_suspended)
650 : 0 : goto Out;
651 : :
652 [ # # ]: 0 : if (!dpm_wait_for_superior(dev, async))
653 : 0 : goto Out;
654 : :
655 [ # # ]: 0 : skip_resume = dev_pm_may_skip_resume(dev);
656 : :
657 : 0 : callback = dpm_subsys_resume_noirq_cb(dev, state, &info);
658 [ # # ]: 0 : if (callback)
659 : 0 : goto Run;
660 : :
661 [ # # ]: 0 : if (skip_resume)
662 : 0 : goto Skip;
663 : :
664 : 0 : if (dev_pm_smart_suspend_and_suspended(dev)) {
665 [ # # # # ]: 0 : pm_message_t suspend_msg = suspend_event(state);
666 : :
667 : : /*
668 : : * If "freeze" callbacks have been skipped during a transition
669 : : * related to hibernation, the subsequent "thaw" callbacks must
670 : : * be skipped too or bad things may happen. Otherwise, resume
671 : : * callbacks are going to be run for the device, so its runtime
672 : : * PM status must be changed to reflect the new state after the
673 : : * transition under way.
674 : : */
675 [ # # # # ]: 0 : if (!dpm_subsys_suspend_late_cb(dev, suspend_msg, NULL) &&
676 : 0 : !dpm_subsys_suspend_noirq_cb(dev, suspend_msg, NULL)) {
677 [ # # ]: 0 : if (state.event == PM_EVENT_THAW) {
678 : 0 : skip_resume = true;
679 : 0 : goto Skip;
680 : : } else {
681 : 0 : pm_runtime_set_active(dev);
682 : : }
683 : : }
684 : : }
685 : :
686 [ # # # # ]: 0 : if (dev->driver && dev->driver->pm) {
687 : 0 : info = "noirq driver ";
688 : 0 : callback = pm_noirq_op(dev->driver->pm, state);
689 : : }
690 : :
691 : 0 : Run:
692 : 0 : error = dpm_run_callback(callback, dev, state, info);
693 : :
694 : 0 : Skip:
695 : 0 : dev->power.is_noirq_suspended = false;
696 : :
697 [ # # ]: 0 : if (skip_resume) {
698 : : /* Make the next phases of resume skip the device. */
699 : 0 : dev->power.is_late_suspended = false;
700 : 0 : dev->power.is_suspended = false;
701 : : /*
702 : : * The device is going to be left in suspend, but it might not
703 : : * have been in runtime suspend before the system suspended, so
704 : : * its runtime PM status needs to be updated to avoid confusing
705 : : * the runtime PM framework when runtime PM is enabled for the
706 : : * device again.
707 : : */
708 : 0 : pm_runtime_set_suspended(dev);
709 : : }
710 : :
711 : 0 : Out:
712 : 0 : complete_all(&dev->power.completion);
713 [ # # ]: 0 : TRACE_RESUME(error);
714 : 0 : return error;
715 : : }
716 : :
717 : 0 : static bool is_async(struct device *dev)
718 : : {
719 [ # # # # : 0 : return dev->power.async_suspend && pm_async_enabled
# # # # ]
720 [ # # # # : 0 : && !pm_trace_is_enabled();
# # # # ]
721 : : }
722 : :
723 : 0 : static bool dpm_async_fn(struct device *dev, async_func_t func)
724 : : {
725 [ # # ]: 0 : reinit_completion(&dev->power.completion);
726 : :
727 [ # # # # ]: 0 : if (is_async(dev)) {
728 : 0 : get_device(dev);
729 : 0 : async_schedule(func, dev);
730 : 0 : return true;
731 : : }
732 : :
733 : : return false;
734 : : }
735 : :
736 : 0 : static void async_resume_noirq(void *data, async_cookie_t cookie)
737 : : {
738 : 0 : struct device *dev = (struct device *)data;
739 : 0 : int error;
740 : :
741 : 0 : error = device_resume_noirq(dev, pm_transition, true);
742 [ # # ]: 0 : if (error)
743 : 0 : pm_dev_err(dev, pm_transition, " async", error);
744 : :
745 : 0 : put_device(dev);
746 : 0 : }
747 : :
748 : 0 : static void dpm_noirq_resume_devices(pm_message_t state)
749 : : {
750 : 0 : struct device *dev;
751 : 0 : ktime_t starttime = ktime_get();
752 : :
753 : 0 : trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, true);
754 : 0 : mutex_lock(&dpm_list_mtx);
755 : 0 : pm_transition = state;
756 : :
757 : : /*
758 : : * Advanced the async threads upfront,
759 : : * in case the starting of async threads is
760 : : * delayed by non-async resuming devices.
761 : : */
762 [ # # ]: 0 : list_for_each_entry(dev, &dpm_noirq_list, power.entry)
763 : 0 : dpm_async_fn(dev, async_resume_noirq);
764 : :
765 [ # # ]: 0 : while (!list_empty(&dpm_noirq_list)) {
766 : 0 : dev = to_device(dpm_noirq_list.next);
767 : 0 : get_device(dev);
768 : 0 : list_move_tail(&dev->power.entry, &dpm_late_early_list);
769 : 0 : mutex_unlock(&dpm_list_mtx);
770 : :
771 [ # # # # ]: 0 : if (!is_async(dev)) {
772 : 0 : int error;
773 : :
774 : 0 : error = device_resume_noirq(dev, state, false);
775 [ # # ]: 0 : if (error) {
776 : 0 : suspend_stats.failed_resume_noirq++;
777 [ # # ]: 0 : dpm_save_failed_step(SUSPEND_RESUME_NOIRQ);
778 [ # # ]: 0 : dpm_save_failed_dev(dev_name(dev));
779 : 0 : pm_dev_err(dev, state, " noirq", error);
780 : : }
781 : : }
782 : :
783 : 0 : mutex_lock(&dpm_list_mtx);
784 : 0 : put_device(dev);
785 : : }
786 : 0 : mutex_unlock(&dpm_list_mtx);
787 : 0 : async_synchronize_full();
788 : 0 : dpm_show_time(starttime, state, 0, "noirq");
789 : 0 : trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, false);
790 : 0 : }
791 : :
792 : : /**
793 : : * dpm_resume_noirq - Execute "noirq resume" callbacks for all devices.
794 : : * @state: PM transition of the system being carried out.
795 : : *
796 : : * Invoke the "noirq" resume callbacks for all devices in dpm_noirq_list and
797 : : * allow device drivers' interrupt handlers to be called.
798 : : */
799 : 0 : void dpm_resume_noirq(pm_message_t state)
800 : : {
801 : 0 : dpm_noirq_resume_devices(state);
802 : :
803 : 0 : resume_device_irqs();
804 : 0 : device_wakeup_disarm_wake_irqs();
805 : :
806 : 0 : cpuidle_resume();
807 : 0 : }
808 : :
809 : 0 : static pm_callback_t dpm_subsys_resume_early_cb(struct device *dev,
810 : : pm_message_t state,
811 : : const char **info_p)
812 : : {
813 : 0 : pm_callback_t callback;
814 : 0 : const char *info;
815 : :
816 [ # # ]: 0 : if (dev->pm_domain) {
817 : 0 : info = "early power domain ";
818 : 0 : callback = pm_late_early_op(&dev->pm_domain->ops, state);
819 [ # # # # ]: 0 : } else if (dev->type && dev->type->pm) {
820 : 0 : info = "early type ";
821 : 0 : callback = pm_late_early_op(dev->type->pm, state);
822 [ # # # # ]: 0 : } else if (dev->class && dev->class->pm) {
823 : 0 : info = "early class ";
824 : 0 : callback = pm_late_early_op(dev->class->pm, state);
825 [ # # # # ]: 0 : } else if (dev->bus && dev->bus->pm) {
826 : 0 : info = "early bus ";
827 : 0 : callback = pm_late_early_op(dev->bus->pm, state);
828 : : } else {
829 : : return NULL;
830 : : }
831 : :
832 [ # # ]: 0 : if (info_p)
833 : 0 : *info_p = info;
834 : :
835 : : return callback;
836 : : }
837 : :
838 : : /**
839 : : * device_resume_early - Execute an "early resume" callback for given device.
840 : : * @dev: Device to handle.
841 : : * @state: PM transition of the system being carried out.
842 : : * @async: If true, the device is being resumed asynchronously.
843 : : *
844 : : * Runtime PM is disabled for @dev while this function is being executed.
845 : : */
846 : 0 : static int device_resume_early(struct device *dev, pm_message_t state, bool async)
847 : : {
848 : 0 : pm_callback_t callback;
849 : 0 : const char *info;
850 : 0 : int error = 0;
851 : :
852 [ # # ]: 0 : TRACE_DEVICE(dev);
853 [ # # ]: 0 : TRACE_RESUME(0);
854 : :
855 [ # # # # ]: 0 : if (dev->power.syscore || dev->power.direct_complete)
856 : 0 : goto Out;
857 : :
858 [ # # ]: 0 : if (!dev->power.is_late_suspended)
859 : 0 : goto Out;
860 : :
861 [ # # ]: 0 : if (!dpm_wait_for_superior(dev, async))
862 : 0 : goto Out;
863 : :
864 : 0 : callback = dpm_subsys_resume_early_cb(dev, state, &info);
865 : :
866 [ # # # # : 0 : if (!callback && dev->driver && dev->driver->pm) {
# # ]
867 : 0 : info = "early driver ";
868 : 0 : callback = pm_late_early_op(dev->driver->pm, state);
869 : : }
870 : :
871 : 0 : error = dpm_run_callback(callback, dev, state, info);
872 : 0 : dev->power.is_late_suspended = false;
873 : :
874 : 0 : Out:
875 [ # # ]: 0 : TRACE_RESUME(error);
876 : :
877 : 0 : pm_runtime_enable(dev);
878 : 0 : complete_all(&dev->power.completion);
879 : 0 : return error;
880 : : }
881 : :
882 : 0 : static void async_resume_early(void *data, async_cookie_t cookie)
883 : : {
884 : 0 : struct device *dev = (struct device *)data;
885 : 0 : int error;
886 : :
887 : 0 : error = device_resume_early(dev, pm_transition, true);
888 [ # # ]: 0 : if (error)
889 : 0 : pm_dev_err(dev, pm_transition, " async", error);
890 : :
891 : 0 : put_device(dev);
892 : 0 : }
893 : :
894 : : /**
895 : : * dpm_resume_early - Execute "early resume" callbacks for all devices.
896 : : * @state: PM transition of the system being carried out.
897 : : */
898 : 0 : void dpm_resume_early(pm_message_t state)
899 : : {
900 : 0 : struct device *dev;
901 : 0 : ktime_t starttime = ktime_get();
902 : :
903 : 0 : trace_suspend_resume(TPS("dpm_resume_early"), state.event, true);
904 : 0 : mutex_lock(&dpm_list_mtx);
905 : 0 : pm_transition = state;
906 : :
907 : : /*
908 : : * Advanced the async threads upfront,
909 : : * in case the starting of async threads is
910 : : * delayed by non-async resuming devices.
911 : : */
912 [ # # ]: 0 : list_for_each_entry(dev, &dpm_late_early_list, power.entry)
913 : 0 : dpm_async_fn(dev, async_resume_early);
914 : :
915 [ # # ]: 0 : while (!list_empty(&dpm_late_early_list)) {
916 : 0 : dev = to_device(dpm_late_early_list.next);
917 : 0 : get_device(dev);
918 : 0 : list_move_tail(&dev->power.entry, &dpm_suspended_list);
919 : 0 : mutex_unlock(&dpm_list_mtx);
920 : :
921 [ # # # # ]: 0 : if (!is_async(dev)) {
922 : 0 : int error;
923 : :
924 : 0 : error = device_resume_early(dev, state, false);
925 [ # # ]: 0 : if (error) {
926 : 0 : suspend_stats.failed_resume_early++;
927 [ # # ]: 0 : dpm_save_failed_step(SUSPEND_RESUME_EARLY);
928 [ # # ]: 0 : dpm_save_failed_dev(dev_name(dev));
929 : 0 : pm_dev_err(dev, state, " early", error);
930 : : }
931 : : }
932 : 0 : mutex_lock(&dpm_list_mtx);
933 : 0 : put_device(dev);
934 : : }
935 : 0 : mutex_unlock(&dpm_list_mtx);
936 : 0 : async_synchronize_full();
937 : 0 : dpm_show_time(starttime, state, 0, "early");
938 : 0 : trace_suspend_resume(TPS("dpm_resume_early"), state.event, false);
939 : 0 : }
940 : :
941 : : /**
942 : : * dpm_resume_start - Execute "noirq" and "early" device callbacks.
943 : : * @state: PM transition of the system being carried out.
944 : : */
945 : 0 : void dpm_resume_start(pm_message_t state)
946 : : {
947 : 0 : dpm_resume_noirq(state);
948 : 0 : dpm_resume_early(state);
949 : 0 : }
950 : : EXPORT_SYMBOL_GPL(dpm_resume_start);
951 : :
952 : : /**
953 : : * device_resume - Execute "resume" callbacks for given device.
954 : : * @dev: Device to handle.
955 : : * @state: PM transition of the system being carried out.
956 : : * @async: If true, the device is being resumed asynchronously.
957 : : */
958 : 0 : static int device_resume(struct device *dev, pm_message_t state, bool async)
959 : : {
960 : 0 : pm_callback_t callback = NULL;
961 : 0 : const char *info = NULL;
962 : 0 : int error = 0;
963 : 0 : DECLARE_DPM_WATCHDOG_ON_STACK(wd);
964 : :
965 [ # # ]: 0 : TRACE_DEVICE(dev);
966 [ # # ]: 0 : TRACE_RESUME(0);
967 : :
968 [ # # ]: 0 : if (dev->power.syscore)
969 : 0 : goto Complete;
970 : :
971 [ # # ]: 0 : if (dev->power.direct_complete) {
972 : : /* Match the pm_runtime_disable() in __device_suspend(). */
973 : 0 : pm_runtime_enable(dev);
974 : 0 : goto Complete;
975 : : }
976 : :
977 [ # # ]: 0 : if (!dpm_wait_for_superior(dev, async))
978 : 0 : goto Complete;
979 : :
980 : 0 : dpm_watchdog_set(&wd, dev);
981 : 0 : device_lock(dev);
982 : :
983 : : /*
984 : : * This is a fib. But we'll allow new children to be added below
985 : : * a resumed device, even if the device hasn't been completed yet.
986 : : */
987 : 0 : dev->power.is_prepared = false;
988 : :
989 [ # # ]: 0 : if (!dev->power.is_suspended)
990 : 0 : goto Unlock;
991 : :
992 [ # # ]: 0 : if (dev->pm_domain) {
993 : 0 : info = "power domain ";
994 : 0 : callback = pm_op(&dev->pm_domain->ops, state);
995 : 0 : goto Driver;
996 : : }
997 : :
998 [ # # # # ]: 0 : if (dev->type && dev->type->pm) {
999 : 0 : info = "type ";
1000 : 0 : callback = pm_op(dev->type->pm, state);
1001 : 0 : goto Driver;
1002 : : }
1003 : :
1004 [ # # # # ]: 0 : if (dev->class && dev->class->pm) {
1005 : 0 : info = "class ";
1006 : 0 : callback = pm_op(dev->class->pm, state);
1007 : 0 : goto Driver;
1008 : : }
1009 : :
1010 [ # # ]: 0 : if (dev->bus) {
1011 [ # # ]: 0 : if (dev->bus->pm) {
1012 : 0 : info = "bus ";
1013 : 0 : callback = pm_op(dev->bus->pm, state);
1014 [ # # ]: 0 : } else if (dev->bus->resume) {
1015 : 0 : info = "legacy bus ";
1016 : 0 : callback = dev->bus->resume;
1017 : 0 : goto End;
1018 : : }
1019 : : }
1020 : :
1021 : 0 : Driver:
1022 [ # # # # : 0 : if (!callback && dev->driver && dev->driver->pm) {
# # ]
1023 : 0 : info = "driver ";
1024 : 0 : callback = pm_op(dev->driver->pm, state);
1025 : : }
1026 : :
1027 : 0 : End:
1028 : 0 : error = dpm_run_callback(callback, dev, state, info);
1029 : 0 : dev->power.is_suspended = false;
1030 : :
1031 : 0 : Unlock:
1032 : 0 : device_unlock(dev);
1033 : 0 : dpm_watchdog_clear(&wd);
1034 : :
1035 : 0 : Complete:
1036 : 0 : complete_all(&dev->power.completion);
1037 : :
1038 [ # # ]: 0 : TRACE_RESUME(error);
1039 : :
1040 : 0 : return error;
1041 : : }
1042 : :
1043 : 0 : static void async_resume(void *data, async_cookie_t cookie)
1044 : : {
1045 : 0 : struct device *dev = (struct device *)data;
1046 : 0 : int error;
1047 : :
1048 : 0 : error = device_resume(dev, pm_transition, true);
1049 [ # # ]: 0 : if (error)
1050 : 0 : pm_dev_err(dev, pm_transition, " async", error);
1051 : 0 : put_device(dev);
1052 : 0 : }
1053 : :
1054 : : /**
1055 : : * dpm_resume - Execute "resume" callbacks for non-sysdev devices.
1056 : : * @state: PM transition of the system being carried out.
1057 : : *
1058 : : * Execute the appropriate "resume" callback for all devices whose status
1059 : : * indicates that they are suspended.
1060 : : */
1061 : 0 : void dpm_resume(pm_message_t state)
1062 : : {
1063 : 0 : struct device *dev;
1064 : 0 : ktime_t starttime = ktime_get();
1065 : :
1066 : 0 : trace_suspend_resume(TPS("dpm_resume"), state.event, true);
1067 : 0 : might_sleep();
1068 : :
1069 : 0 : mutex_lock(&dpm_list_mtx);
1070 : 0 : pm_transition = state;
1071 : 0 : async_error = 0;
1072 : :
1073 [ # # ]: 0 : list_for_each_entry(dev, &dpm_suspended_list, power.entry)
1074 : 0 : dpm_async_fn(dev, async_resume);
1075 : :
1076 [ # # ]: 0 : while (!list_empty(&dpm_suspended_list)) {
1077 : 0 : dev = to_device(dpm_suspended_list.next);
1078 : 0 : get_device(dev);
1079 [ # # # # ]: 0 : if (!is_async(dev)) {
1080 : 0 : int error;
1081 : :
1082 : 0 : mutex_unlock(&dpm_list_mtx);
1083 : :
1084 : 0 : error = device_resume(dev, state, false);
1085 [ # # ]: 0 : if (error) {
1086 : 0 : suspend_stats.failed_resume++;
1087 [ # # ]: 0 : dpm_save_failed_step(SUSPEND_RESUME);
1088 [ # # ]: 0 : dpm_save_failed_dev(dev_name(dev));
1089 : 0 : pm_dev_err(dev, state, "", error);
1090 : : }
1091 : :
1092 : 0 : mutex_lock(&dpm_list_mtx);
1093 : : }
1094 [ # # ]: 0 : if (!list_empty(&dev->power.entry))
1095 : 0 : list_move_tail(&dev->power.entry, &dpm_prepared_list);
1096 : 0 : put_device(dev);
1097 : : }
1098 : 0 : mutex_unlock(&dpm_list_mtx);
1099 : 0 : async_synchronize_full();
1100 : 0 : dpm_show_time(starttime, state, 0, NULL);
1101 : :
1102 : 0 : cpufreq_resume();
1103 : 0 : devfreq_resume();
1104 : 0 : trace_suspend_resume(TPS("dpm_resume"), state.event, false);
1105 : 0 : }
1106 : :
1107 : : /**
1108 : : * device_complete - Complete a PM transition for given device.
1109 : : * @dev: Device to handle.
1110 : : * @state: PM transition of the system being carried out.
1111 : : */
1112 : : static void device_complete(struct device *dev, pm_message_t state)
1113 : : {
1114 : : void (*callback)(struct device *) = NULL;
1115 : : const char *info = NULL;
1116 : :
1117 : : if (dev->power.syscore)
1118 : : return;
1119 : :
1120 : : device_lock(dev);
1121 : :
1122 : : if (dev->pm_domain) {
1123 : : info = "completing power domain ";
1124 : : callback = dev->pm_domain->ops.complete;
1125 : : } else if (dev->type && dev->type->pm) {
1126 : : info = "completing type ";
1127 : : callback = dev->type->pm->complete;
1128 : : } else if (dev->class && dev->class->pm) {
1129 : : info = "completing class ";
1130 : : callback = dev->class->pm->complete;
1131 : : } else if (dev->bus && dev->bus->pm) {
1132 : : info = "completing bus ";
1133 : : callback = dev->bus->pm->complete;
1134 : : }
1135 : :
1136 : : if (!callback && dev->driver && dev->driver->pm) {
1137 : : info = "completing driver ";
1138 : : callback = dev->driver->pm->complete;
1139 : : }
1140 : :
1141 : : if (callback) {
1142 : : pm_dev_dbg(dev, state, info);
1143 : : callback(dev);
1144 : : }
1145 : :
1146 : : device_unlock(dev);
1147 : :
1148 : : pm_runtime_put(dev);
1149 : : }
1150 : :
1151 : : /**
1152 : : * dpm_complete - Complete a PM transition for all non-sysdev devices.
1153 : : * @state: PM transition of the system being carried out.
1154 : : *
1155 : : * Execute the ->complete() callbacks for all devices whose PM status is not
1156 : : * DPM_ON (this allows new devices to be registered).
1157 : : */
1158 : 0 : void dpm_complete(pm_message_t state)
1159 : : {
1160 : 0 : struct list_head list;
1161 : :
1162 : 0 : trace_suspend_resume(TPS("dpm_complete"), state.event, true);
1163 : 0 : might_sleep();
1164 : :
1165 : 0 : INIT_LIST_HEAD(&list);
1166 : 0 : mutex_lock(&dpm_list_mtx);
1167 [ # # ]: 0 : while (!list_empty(&dpm_prepared_list)) {
1168 : 0 : struct device *dev = to_device(dpm_prepared_list.prev);
1169 : :
1170 : 0 : get_device(dev);
1171 : 0 : dev->power.is_prepared = false;
1172 : 0 : list_move(&dev->power.entry, &list);
1173 : 0 : mutex_unlock(&dpm_list_mtx);
1174 : :
1175 : 0 : trace_device_pm_callback_start(dev, "", state.event);
1176 : 0 : device_complete(dev, state);
1177 : 0 : trace_device_pm_callback_end(dev, 0);
1178 : :
1179 : 0 : mutex_lock(&dpm_list_mtx);
1180 : 0 : put_device(dev);
1181 : : }
1182 [ # # ]: 0 : list_splice(&list, &dpm_list);
1183 : 0 : mutex_unlock(&dpm_list_mtx);
1184 : :
1185 : : /* Allow device probing and trigger re-probing of deferred devices */
1186 : 0 : device_unblock_probing();
1187 : 0 : trace_suspend_resume(TPS("dpm_complete"), state.event, false);
1188 : 0 : }
1189 : :
1190 : : /**
1191 : : * dpm_resume_end - Execute "resume" callbacks and complete system transition.
1192 : : * @state: PM transition of the system being carried out.
1193 : : *
1194 : : * Execute "resume" callbacks for all devices and complete the PM transition of
1195 : : * the system.
1196 : : */
1197 : 0 : void dpm_resume_end(pm_message_t state)
1198 : : {
1199 : 0 : dpm_resume(state);
1200 : 0 : dpm_complete(state);
1201 : 0 : }
1202 : : EXPORT_SYMBOL_GPL(dpm_resume_end);
1203 : :
1204 : :
1205 : : /*------------------------- Suspend routines -------------------------*/
1206 : :
1207 : : /**
1208 : : * resume_event - Return a "resume" message for given "suspend" sleep state.
1209 : : * @sleep_state: PM message representing a sleep state.
1210 : : *
1211 : : * Return a PM message representing the resume event corresponding to given
1212 : : * sleep state.
1213 : : */
1214 : 0 : static pm_message_t resume_event(pm_message_t sleep_state)
1215 : : {
1216 : 0 : switch (sleep_state.event) {
1217 : : case PM_EVENT_SUSPEND:
1218 : : return PMSG_RESUME;
1219 : : case PM_EVENT_FREEZE:
1220 : : case PM_EVENT_QUIESCE:
1221 : : return PMSG_RECOVER;
1222 : : case PM_EVENT_HIBERNATE:
1223 : : return PMSG_RESTORE;
1224 : : }
1225 : : return PMSG_ON;
1226 : : }
1227 : :
1228 : 0 : static void dpm_superior_set_must_resume(struct device *dev)
1229 : : {
1230 : 0 : struct device_link *link;
1231 : 0 : int idx;
1232 : :
1233 [ # # ]: 0 : if (dev->parent)
1234 : 0 : dev->parent->power.must_resume = true;
1235 : :
1236 : 0 : idx = device_links_read_lock();
1237 : :
1238 [ # # ]: 0 : list_for_each_entry_rcu(link, &dev->links.suppliers, c_node)
1239 : 0 : link->supplier->power.must_resume = true;
1240 : :
1241 : 0 : device_links_read_unlock(idx);
1242 : 0 : }
1243 : :
1244 : 0 : static pm_callback_t dpm_subsys_suspend_noirq_cb(struct device *dev,
1245 : : pm_message_t state,
1246 : : const char **info_p)
1247 : : {
1248 : 0 : pm_callback_t callback;
1249 : 0 : const char *info;
1250 : :
1251 [ # # ]: 0 : if (dev->pm_domain) {
1252 : 0 : info = "noirq power domain ";
1253 : 0 : callback = pm_noirq_op(&dev->pm_domain->ops, state);
1254 [ # # # # ]: 0 : } else if (dev->type && dev->type->pm) {
1255 : 0 : info = "noirq type ";
1256 : 0 : callback = pm_noirq_op(dev->type->pm, state);
1257 [ # # # # ]: 0 : } else if (dev->class && dev->class->pm) {
1258 : 0 : info = "noirq class ";
1259 : 0 : callback = pm_noirq_op(dev->class->pm, state);
1260 [ # # # # ]: 0 : } else if (dev->bus && dev->bus->pm) {
1261 : 0 : info = "noirq bus ";
1262 : 0 : callback = pm_noirq_op(dev->bus->pm, state);
1263 : : } else {
1264 : : return NULL;
1265 : : }
1266 : :
1267 [ # # ]: 0 : if (info_p)
1268 : 0 : *info_p = info;
1269 : :
1270 : : return callback;
1271 : : }
1272 : :
1273 : 0 : static bool device_must_resume(struct device *dev, pm_message_t state,
1274 : : bool no_subsys_suspend_noirq)
1275 : : {
1276 [ # # ]: 0 : pm_message_t resume_msg = resume_event(state);
1277 : :
1278 : : /*
1279 : : * If all of the device driver's "noirq", "late" and "early" callbacks
1280 : : * are invoked directly by the core, the decision to allow the device to
1281 : : * stay in suspend can be based on its current runtime PM status and its
1282 : : * wakeup settings.
1283 : : */
1284 [ # # # # ]: 0 : if (no_subsys_suspend_noirq &&
1285 [ # # ]: 0 : !dpm_subsys_suspend_late_cb(dev, state, NULL) &&
1286 [ # # ]: 0 : !dpm_subsys_resume_early_cb(dev, resume_msg, NULL) &&
1287 : 0 : !dpm_subsys_resume_noirq_cb(dev, resume_msg, NULL))
1288 [ # # # # ]: 0 : return !pm_runtime_status_suspended(dev) &&
1289 [ # # ]: 0 : (resume_msg.event != PM_EVENT_RESUME ||
1290 [ # # ]: 0 : (device_can_wakeup(dev) && !device_may_wakeup(dev)));
1291 : :
1292 : : /*
1293 : : * The only safe strategy here is to require that if the device may not
1294 : : * be left in suspend, resume callbacks must be invoked for it.
1295 : : */
1296 : 0 : return !dev->power.may_skip_resume;
1297 : : }
1298 : :
1299 : : /**
1300 : : * __device_suspend_noirq - Execute a "noirq suspend" callback for given device.
1301 : : * @dev: Device to handle.
1302 : : * @state: PM transition of the system being carried out.
1303 : : * @async: If true, the device is being suspended asynchronously.
1304 : : *
1305 : : * The driver of @dev will not receive interrupts while this function is being
1306 : : * executed.
1307 : : */
1308 : 0 : static int __device_suspend_noirq(struct device *dev, pm_message_t state, bool async)
1309 : : {
1310 : 0 : pm_callback_t callback;
1311 : 0 : const char *info;
1312 : 0 : bool no_subsys_cb = false;
1313 : 0 : int error = 0;
1314 : :
1315 [ # # ]: 0 : TRACE_DEVICE(dev);
1316 [ # # ]: 0 : TRACE_SUSPEND(0);
1317 : :
1318 : 0 : dpm_wait_for_subordinate(dev, async);
1319 : :
1320 [ # # ]: 0 : if (async_error)
1321 : 0 : goto Complete;
1322 : :
1323 [ # # # # ]: 0 : if (dev->power.syscore || dev->power.direct_complete)
1324 : 0 : goto Complete;
1325 : :
1326 : 0 : callback = dpm_subsys_suspend_noirq_cb(dev, state, &info);
1327 [ # # ]: 0 : if (callback)
1328 : 0 : goto Run;
1329 : :
1330 : 0 : no_subsys_cb = !dpm_subsys_suspend_late_cb(dev, state, NULL);
1331 : :
1332 [ # # ]: 0 : if (dev_pm_smart_suspend_and_suspended(dev) && no_subsys_cb)
1333 : 0 : goto Skip;
1334 : :
1335 [ # # # # ]: 0 : if (dev->driver && dev->driver->pm) {
1336 : 0 : info = "noirq driver ";
1337 : 0 : callback = pm_noirq_op(dev->driver->pm, state);
1338 : : }
1339 : :
1340 : 0 : Run:
1341 : 0 : error = dpm_run_callback(callback, dev, state, info);
1342 [ # # ]: 0 : if (error) {
1343 : 0 : async_error = error;
1344 : 0 : goto Complete;
1345 : : }
1346 : :
1347 : 0 : Skip:
1348 : 0 : dev->power.is_noirq_suspended = true;
1349 : :
1350 [ # # ]: 0 : if (dev_pm_test_driver_flags(dev, DPM_FLAG_LEAVE_SUSPENDED)) {
1351 [ # # ]: 0 : dev->power.must_resume = dev->power.must_resume ||
1352 [ # # # # ]: 0 : atomic_read(&dev->power.usage_count) > 1 ||
1353 : 0 : device_must_resume(dev, state, no_subsys_cb);
1354 : : } else {
1355 : 0 : dev->power.must_resume = true;
1356 : : }
1357 : :
1358 [ # # ]: 0 : if (dev->power.must_resume)
1359 : 0 : dpm_superior_set_must_resume(dev);
1360 : :
1361 : 0 : Complete:
1362 : 0 : complete_all(&dev->power.completion);
1363 [ # # ]: 0 : TRACE_SUSPEND(error);
1364 : 0 : return error;
1365 : : }
1366 : :
1367 : 0 : static void async_suspend_noirq(void *data, async_cookie_t cookie)
1368 : : {
1369 : 0 : struct device *dev = (struct device *)data;
1370 : 0 : int error;
1371 : :
1372 : 0 : error = __device_suspend_noirq(dev, pm_transition, true);
1373 [ # # ]: 0 : if (error) {
1374 [ # # ]: 0 : dpm_save_failed_dev(dev_name(dev));
1375 : 0 : pm_dev_err(dev, pm_transition, " async", error);
1376 : : }
1377 : :
1378 : 0 : put_device(dev);
1379 : 0 : }
1380 : :
1381 : 0 : static int device_suspend_noirq(struct device *dev)
1382 : : {
1383 [ # # ]: 0 : if (dpm_async_fn(dev, async_suspend_noirq))
1384 : : return 0;
1385 : :
1386 : 0 : return __device_suspend_noirq(dev, pm_transition, false);
1387 : : }
1388 : :
1389 : 0 : static int dpm_noirq_suspend_devices(pm_message_t state)
1390 : : {
1391 : 0 : ktime_t starttime = ktime_get();
1392 : 0 : int error = 0;
1393 : :
1394 : 0 : trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, true);
1395 : 0 : mutex_lock(&dpm_list_mtx);
1396 : 0 : pm_transition = state;
1397 : 0 : async_error = 0;
1398 : :
1399 [ # # ]: 0 : while (!list_empty(&dpm_late_early_list)) {
1400 : 0 : struct device *dev = to_device(dpm_late_early_list.prev);
1401 : :
1402 : 0 : get_device(dev);
1403 : 0 : mutex_unlock(&dpm_list_mtx);
1404 : :
1405 : 0 : error = device_suspend_noirq(dev);
1406 : :
1407 : 0 : mutex_lock(&dpm_list_mtx);
1408 [ # # ]: 0 : if (error) {
1409 : 0 : pm_dev_err(dev, state, " noirq", error);
1410 [ # # ]: 0 : dpm_save_failed_dev(dev_name(dev));
1411 : 0 : put_device(dev);
1412 : 0 : break;
1413 : : }
1414 [ # # ]: 0 : if (!list_empty(&dev->power.entry))
1415 : 0 : list_move(&dev->power.entry, &dpm_noirq_list);
1416 : 0 : put_device(dev);
1417 : :
1418 [ # # ]: 0 : if (async_error)
1419 : : break;
1420 : : }
1421 : 0 : mutex_unlock(&dpm_list_mtx);
1422 : 0 : async_synchronize_full();
1423 [ # # ]: 0 : if (!error)
1424 : 0 : error = async_error;
1425 : :
1426 [ # # ]: 0 : if (error) {
1427 : 0 : suspend_stats.failed_suspend_noirq++;
1428 : 0 : dpm_save_failed_step(SUSPEND_SUSPEND_NOIRQ);
1429 : : }
1430 : 0 : dpm_show_time(starttime, state, error, "noirq");
1431 : 0 : trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, false);
1432 : 0 : return error;
1433 : : }
1434 : :
1435 : : /**
1436 : : * dpm_suspend_noirq - Execute "noirq suspend" callbacks for all devices.
1437 : : * @state: PM transition of the system being carried out.
1438 : : *
1439 : : * Prevent device drivers' interrupt handlers from being called and invoke
1440 : : * "noirq" suspend callbacks for all non-sysdev devices.
1441 : : */
1442 : 0 : int dpm_suspend_noirq(pm_message_t state)
1443 : : {
1444 : 0 : int ret;
1445 : :
1446 : 0 : cpuidle_pause();
1447 : :
1448 : 0 : device_wakeup_arm_wake_irqs();
1449 : 0 : suspend_device_irqs();
1450 : :
1451 : 0 : ret = dpm_noirq_suspend_devices(state);
1452 [ # # ]: 0 : if (ret)
1453 [ # # ]: 0 : dpm_resume_noirq(resume_event(state));
1454 : :
1455 : 0 : return ret;
1456 : : }
1457 : :
1458 : 0 : static void dpm_propagate_wakeup_to_parent(struct device *dev)
1459 : : {
1460 : 0 : struct device *parent = dev->parent;
1461 : :
1462 [ # # ]: 0 : if (!parent)
1463 : : return;
1464 : :
1465 : 0 : spin_lock_irq(&parent->power.lock);
1466 : :
1467 [ # # # # ]: 0 : if (dev->power.wakeup_path && !parent->power.ignore_children)
1468 : 0 : parent->power.wakeup_path = true;
1469 : :
1470 : 0 : spin_unlock_irq(&parent->power.lock);
1471 : : }
1472 : :
1473 : 0 : static pm_callback_t dpm_subsys_suspend_late_cb(struct device *dev,
1474 : : pm_message_t state,
1475 : : const char **info_p)
1476 : : {
1477 : 0 : pm_callback_t callback;
1478 : 0 : const char *info;
1479 : :
1480 [ # # ]: 0 : if (dev->pm_domain) {
1481 : 0 : info = "late power domain ";
1482 : 0 : callback = pm_late_early_op(&dev->pm_domain->ops, state);
1483 [ # # # # ]: 0 : } else if (dev->type && dev->type->pm) {
1484 : 0 : info = "late type ";
1485 : 0 : callback = pm_late_early_op(dev->type->pm, state);
1486 [ # # # # ]: 0 : } else if (dev->class && dev->class->pm) {
1487 : 0 : info = "late class ";
1488 : 0 : callback = pm_late_early_op(dev->class->pm, state);
1489 [ # # # # ]: 0 : } else if (dev->bus && dev->bus->pm) {
1490 : 0 : info = "late bus ";
1491 : 0 : callback = pm_late_early_op(dev->bus->pm, state);
1492 : : } else {
1493 : : return NULL;
1494 : : }
1495 : :
1496 [ # # ]: 0 : if (info_p)
1497 : 0 : *info_p = info;
1498 : :
1499 : : return callback;
1500 : : }
1501 : :
1502 : : /**
1503 : : * __device_suspend_late - Execute a "late suspend" callback for given device.
1504 : : * @dev: Device to handle.
1505 : : * @state: PM transition of the system being carried out.
1506 : : * @async: If true, the device is being suspended asynchronously.
1507 : : *
1508 : : * Runtime PM is disabled for @dev while this function is being executed.
1509 : : */
1510 : 0 : static int __device_suspend_late(struct device *dev, pm_message_t state, bool async)
1511 : : {
1512 : 0 : pm_callback_t callback;
1513 : 0 : const char *info;
1514 : 0 : int error = 0;
1515 : :
1516 [ # # ]: 0 : TRACE_DEVICE(dev);
1517 [ # # ]: 0 : TRACE_SUSPEND(0);
1518 : :
1519 : 0 : __pm_runtime_disable(dev, false);
1520 : :
1521 : 0 : dpm_wait_for_subordinate(dev, async);
1522 : :
1523 [ # # ]: 0 : if (async_error)
1524 : 0 : goto Complete;
1525 : :
1526 [ # # ]: 0 : if (pm_wakeup_pending()) {
1527 : 0 : async_error = -EBUSY;
1528 : 0 : goto Complete;
1529 : : }
1530 : :
1531 [ # # # # ]: 0 : if (dev->power.syscore || dev->power.direct_complete)
1532 : 0 : goto Complete;
1533 : :
1534 : 0 : callback = dpm_subsys_suspend_late_cb(dev, state, &info);
1535 [ # # ]: 0 : if (callback)
1536 : 0 : goto Run;
1537 : :
1538 [ # # ]: 0 : if (dev_pm_smart_suspend_and_suspended(dev) &&
1539 : 0 : !dpm_subsys_suspend_noirq_cb(dev, state, NULL))
1540 : 0 : goto Skip;
1541 : :
1542 [ # # # # ]: 0 : if (dev->driver && dev->driver->pm) {
1543 : 0 : info = "late driver ";
1544 : 0 : callback = pm_late_early_op(dev->driver->pm, state);
1545 : : }
1546 : :
1547 : 0 : Run:
1548 : 0 : error = dpm_run_callback(callback, dev, state, info);
1549 [ # # ]: 0 : if (error) {
1550 : 0 : async_error = error;
1551 : 0 : goto Complete;
1552 : : }
1553 : 0 : dpm_propagate_wakeup_to_parent(dev);
1554 : :
1555 : 0 : Skip:
1556 : 0 : dev->power.is_late_suspended = true;
1557 : :
1558 : 0 : Complete:
1559 [ # # ]: 0 : TRACE_SUSPEND(error);
1560 : 0 : complete_all(&dev->power.completion);
1561 : 0 : return error;
1562 : : }
1563 : :
1564 : 0 : static void async_suspend_late(void *data, async_cookie_t cookie)
1565 : : {
1566 : 0 : struct device *dev = (struct device *)data;
1567 : 0 : int error;
1568 : :
1569 : 0 : error = __device_suspend_late(dev, pm_transition, true);
1570 [ # # ]: 0 : if (error) {
1571 [ # # ]: 0 : dpm_save_failed_dev(dev_name(dev));
1572 : 0 : pm_dev_err(dev, pm_transition, " async", error);
1573 : : }
1574 : 0 : put_device(dev);
1575 : 0 : }
1576 : :
1577 : 0 : static int device_suspend_late(struct device *dev)
1578 : : {
1579 [ # # ]: 0 : if (dpm_async_fn(dev, async_suspend_late))
1580 : : return 0;
1581 : :
1582 : 0 : return __device_suspend_late(dev, pm_transition, false);
1583 : : }
1584 : :
1585 : : /**
1586 : : * dpm_suspend_late - Execute "late suspend" callbacks for all devices.
1587 : : * @state: PM transition of the system being carried out.
1588 : : */
1589 : 0 : int dpm_suspend_late(pm_message_t state)
1590 : : {
1591 : 0 : ktime_t starttime = ktime_get();
1592 : 0 : int error = 0;
1593 : :
1594 : 0 : trace_suspend_resume(TPS("dpm_suspend_late"), state.event, true);
1595 : 0 : mutex_lock(&dpm_list_mtx);
1596 : 0 : pm_transition = state;
1597 : 0 : async_error = 0;
1598 : :
1599 [ # # ]: 0 : while (!list_empty(&dpm_suspended_list)) {
1600 : 0 : struct device *dev = to_device(dpm_suspended_list.prev);
1601 : :
1602 : 0 : get_device(dev);
1603 : 0 : mutex_unlock(&dpm_list_mtx);
1604 : :
1605 : 0 : error = device_suspend_late(dev);
1606 : :
1607 : 0 : mutex_lock(&dpm_list_mtx);
1608 [ # # ]: 0 : if (!list_empty(&dev->power.entry))
1609 : 0 : list_move(&dev->power.entry, &dpm_late_early_list);
1610 : :
1611 [ # # ]: 0 : if (error) {
1612 : 0 : pm_dev_err(dev, state, " late", error);
1613 [ # # ]: 0 : dpm_save_failed_dev(dev_name(dev));
1614 : 0 : put_device(dev);
1615 : 0 : break;
1616 : : }
1617 : 0 : put_device(dev);
1618 : :
1619 [ # # ]: 0 : if (async_error)
1620 : : break;
1621 : : }
1622 : 0 : mutex_unlock(&dpm_list_mtx);
1623 : 0 : async_synchronize_full();
1624 [ # # ]: 0 : if (!error)
1625 : 0 : error = async_error;
1626 [ # # ]: 0 : if (error) {
1627 : 0 : suspend_stats.failed_suspend_late++;
1628 [ # # ]: 0 : dpm_save_failed_step(SUSPEND_SUSPEND_LATE);
1629 [ # # ]: 0 : dpm_resume_early(resume_event(state));
1630 : : }
1631 : 0 : dpm_show_time(starttime, state, error, "late");
1632 : 0 : trace_suspend_resume(TPS("dpm_suspend_late"), state.event, false);
1633 : 0 : return error;
1634 : : }
1635 : :
1636 : : /**
1637 : : * dpm_suspend_end - Execute "late" and "noirq" device suspend callbacks.
1638 : : * @state: PM transition of the system being carried out.
1639 : : */
1640 : 0 : int dpm_suspend_end(pm_message_t state)
1641 : : {
1642 : 0 : ktime_t starttime = ktime_get();
1643 : 0 : int error;
1644 : :
1645 : 0 : error = dpm_suspend_late(state);
1646 [ # # ]: 0 : if (error)
1647 : 0 : goto out;
1648 : :
1649 : 0 : error = dpm_suspend_noirq(state);
1650 [ # # ]: 0 : if (error)
1651 [ # # ]: 0 : dpm_resume_early(resume_event(state));
1652 : :
1653 : 0 : out:
1654 : 0 : dpm_show_time(starttime, state, error, "end");
1655 : 0 : return error;
1656 : : }
1657 : : EXPORT_SYMBOL_GPL(dpm_suspend_end);
1658 : :
1659 : : /**
1660 : : * legacy_suspend - Execute a legacy (bus or class) suspend callback for device.
1661 : : * @dev: Device to suspend.
1662 : : * @state: PM transition of the system being carried out.
1663 : : * @cb: Suspend callback to execute.
1664 : : * @info: string description of caller.
1665 : : */
1666 : 0 : static int legacy_suspend(struct device *dev, pm_message_t state,
1667 : : int (*cb)(struct device *dev, pm_message_t state),
1668 : : const char *info)
1669 : : {
1670 : 0 : int error;
1671 : 0 : ktime_t calltime;
1672 : :
1673 : 0 : calltime = initcall_debug_start(dev, cb);
1674 : :
1675 : 0 : trace_device_pm_callback_start(dev, info, state.event);
1676 : 0 : error = cb(dev, state);
1677 : 0 : trace_device_pm_callback_end(dev, error);
1678 : 0 : suspend_report_result(cb, error);
1679 : :
1680 : 0 : initcall_debug_report(dev, calltime, cb, error);
1681 : :
1682 : 0 : return error;
1683 : : }
1684 : :
1685 : 0 : static void dpm_clear_superiors_direct_complete(struct device *dev)
1686 : : {
1687 : 0 : struct device_link *link;
1688 : 0 : int idx;
1689 : :
1690 [ # # ]: 0 : if (dev->parent) {
1691 : 0 : spin_lock_irq(&dev->parent->power.lock);
1692 : 0 : dev->parent->power.direct_complete = false;
1693 : 0 : spin_unlock_irq(&dev->parent->power.lock);
1694 : : }
1695 : :
1696 : 0 : idx = device_links_read_lock();
1697 : :
1698 [ # # ]: 0 : list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) {
1699 : 0 : spin_lock_irq(&link->supplier->power.lock);
1700 : 0 : link->supplier->power.direct_complete = false;
1701 : 0 : spin_unlock_irq(&link->supplier->power.lock);
1702 : : }
1703 : :
1704 : 0 : device_links_read_unlock(idx);
1705 : 0 : }
1706 : :
1707 : : /**
1708 : : * __device_suspend - Execute "suspend" callbacks for given device.
1709 : : * @dev: Device to handle.
1710 : : * @state: PM transition of the system being carried out.
1711 : : * @async: If true, the device is being suspended asynchronously.
1712 : : */
1713 : 0 : static int __device_suspend(struct device *dev, pm_message_t state, bool async)
1714 : : {
1715 : 0 : pm_callback_t callback = NULL;
1716 : 0 : const char *info = NULL;
1717 : 0 : int error = 0;
1718 : 0 : DECLARE_DPM_WATCHDOG_ON_STACK(wd);
1719 : :
1720 [ # # ]: 0 : TRACE_DEVICE(dev);
1721 [ # # ]: 0 : TRACE_SUSPEND(0);
1722 : :
1723 : 0 : dpm_wait_for_subordinate(dev, async);
1724 : :
1725 [ # # ]: 0 : if (async_error) {
1726 : 0 : dev->power.direct_complete = false;
1727 : 0 : goto Complete;
1728 : : }
1729 : :
1730 : : /*
1731 : : * If a device configured to wake up the system from sleep states
1732 : : * has been suspended at run time and there's a resume request pending
1733 : : * for it, this is equivalent to the device signaling wakeup, so the
1734 : : * system suspend operation should be aborted.
1735 : : */
1736 [ # # # # ]: 0 : if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
1737 : 0 : pm_wakeup_event(dev, 0);
1738 : :
1739 [ # # ]: 0 : if (pm_wakeup_pending()) {
1740 : 0 : dev->power.direct_complete = false;
1741 : 0 : async_error = -EBUSY;
1742 : 0 : goto Complete;
1743 : : }
1744 : :
1745 [ # # ]: 0 : if (dev->power.syscore)
1746 : 0 : goto Complete;
1747 : :
1748 : : /* Avoid direct_complete to let wakeup_path propagate. */
1749 [ # # # # : 0 : if (device_may_wakeup(dev) || dev->power.wakeup_path)
# # ]
1750 : 0 : dev->power.direct_complete = false;
1751 : :
1752 [ # # ]: 0 : if (dev->power.direct_complete) {
1753 [ # # ]: 0 : if (pm_runtime_status_suspended(dev)) {
1754 : 0 : pm_runtime_disable(dev);
1755 [ # # ]: 0 : if (pm_runtime_status_suspended(dev)) {
1756 : 0 : pm_dev_dbg(dev, state, "direct-complete ");
1757 : 0 : goto Complete;
1758 : : }
1759 : :
1760 : 0 : pm_runtime_enable(dev);
1761 : : }
1762 : 0 : dev->power.direct_complete = false;
1763 : : }
1764 : :
1765 : 0 : dev->power.may_skip_resume = false;
1766 : 0 : dev->power.must_resume = false;
1767 : :
1768 : 0 : dpm_watchdog_set(&wd, dev);
1769 : 0 : device_lock(dev);
1770 : :
1771 [ # # ]: 0 : if (dev->pm_domain) {
1772 : 0 : info = "power domain ";
1773 : 0 : callback = pm_op(&dev->pm_domain->ops, state);
1774 : 0 : goto Run;
1775 : : }
1776 : :
1777 [ # # # # ]: 0 : if (dev->type && dev->type->pm) {
1778 : 0 : info = "type ";
1779 : 0 : callback = pm_op(dev->type->pm, state);
1780 : 0 : goto Run;
1781 : : }
1782 : :
1783 [ # # # # ]: 0 : if (dev->class && dev->class->pm) {
1784 : 0 : info = "class ";
1785 : 0 : callback = pm_op(dev->class->pm, state);
1786 : 0 : goto Run;
1787 : : }
1788 : :
1789 [ # # ]: 0 : if (dev->bus) {
1790 [ # # ]: 0 : if (dev->bus->pm) {
1791 : 0 : info = "bus ";
1792 : 0 : callback = pm_op(dev->bus->pm, state);
1793 [ # # ]: 0 : } else if (dev->bus->suspend) {
1794 : 0 : pm_dev_dbg(dev, state, "legacy bus ");
1795 : 0 : error = legacy_suspend(dev, state, dev->bus->suspend,
1796 : : "legacy bus ");
1797 : 0 : goto End;
1798 : : }
1799 : : }
1800 : :
1801 : 0 : Run:
1802 [ # # # # : 0 : if (!callback && dev->driver && dev->driver->pm) {
# # ]
1803 : 0 : info = "driver ";
1804 : 0 : callback = pm_op(dev->driver->pm, state);
1805 : : }
1806 : :
1807 : 0 : error = dpm_run_callback(callback, dev, state, info);
1808 : :
1809 : 0 : End:
1810 [ # # ]: 0 : if (!error) {
1811 : 0 : dev->power.is_suspended = true;
1812 [ # # # # ]: 0 : if (device_may_wakeup(dev))
1813 : 0 : dev->power.wakeup_path = true;
1814 : :
1815 : 0 : dpm_propagate_wakeup_to_parent(dev);
1816 : 0 : dpm_clear_superiors_direct_complete(dev);
1817 : : }
1818 : :
1819 : 0 : device_unlock(dev);
1820 : 0 : dpm_watchdog_clear(&wd);
1821 : :
1822 : : Complete:
1823 [ # # ]: 0 : if (error)
1824 : 0 : async_error = error;
1825 : :
1826 : 0 : complete_all(&dev->power.completion);
1827 [ # # ]: 0 : TRACE_SUSPEND(error);
1828 : 0 : return error;
1829 : : }
1830 : :
1831 : 0 : static void async_suspend(void *data, async_cookie_t cookie)
1832 : : {
1833 : 0 : struct device *dev = (struct device *)data;
1834 : 0 : int error;
1835 : :
1836 : 0 : error = __device_suspend(dev, pm_transition, true);
1837 [ # # ]: 0 : if (error) {
1838 [ # # ]: 0 : dpm_save_failed_dev(dev_name(dev));
1839 : 0 : pm_dev_err(dev, pm_transition, " async", error);
1840 : : }
1841 : :
1842 : 0 : put_device(dev);
1843 : 0 : }
1844 : :
1845 : 0 : static int device_suspend(struct device *dev)
1846 : : {
1847 [ # # ]: 0 : if (dpm_async_fn(dev, async_suspend))
1848 : : return 0;
1849 : :
1850 : 0 : return __device_suspend(dev, pm_transition, false);
1851 : : }
1852 : :
1853 : : /**
1854 : : * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
1855 : : * @state: PM transition of the system being carried out.
1856 : : */
1857 : 0 : int dpm_suspend(pm_message_t state)
1858 : : {
1859 : 0 : ktime_t starttime = ktime_get();
1860 : 0 : int error = 0;
1861 : :
1862 : 0 : trace_suspend_resume(TPS("dpm_suspend"), state.event, true);
1863 : 0 : might_sleep();
1864 : :
1865 : 0 : devfreq_suspend();
1866 : 0 : cpufreq_suspend();
1867 : :
1868 : 0 : mutex_lock(&dpm_list_mtx);
1869 : 0 : pm_transition = state;
1870 : 0 : async_error = 0;
1871 [ # # ]: 0 : while (!list_empty(&dpm_prepared_list)) {
1872 : 0 : struct device *dev = to_device(dpm_prepared_list.prev);
1873 : :
1874 : 0 : get_device(dev);
1875 : 0 : mutex_unlock(&dpm_list_mtx);
1876 : :
1877 : 0 : error = device_suspend(dev);
1878 : :
1879 : 0 : mutex_lock(&dpm_list_mtx);
1880 [ # # ]: 0 : if (error) {
1881 : 0 : pm_dev_err(dev, state, "", error);
1882 [ # # ]: 0 : dpm_save_failed_dev(dev_name(dev));
1883 : 0 : put_device(dev);
1884 : 0 : break;
1885 : : }
1886 [ # # ]: 0 : if (!list_empty(&dev->power.entry))
1887 : 0 : list_move(&dev->power.entry, &dpm_suspended_list);
1888 : 0 : put_device(dev);
1889 [ # # ]: 0 : if (async_error)
1890 : : break;
1891 : : }
1892 : 0 : mutex_unlock(&dpm_list_mtx);
1893 : 0 : async_synchronize_full();
1894 [ # # ]: 0 : if (!error)
1895 : 0 : error = async_error;
1896 [ # # ]: 0 : if (error) {
1897 : 0 : suspend_stats.failed_suspend++;
1898 : 0 : dpm_save_failed_step(SUSPEND_SUSPEND);
1899 : : }
1900 : 0 : dpm_show_time(starttime, state, error, NULL);
1901 : 0 : trace_suspend_resume(TPS("dpm_suspend"), state.event, false);
1902 : 0 : return error;
1903 : : }
1904 : :
1905 : : /**
1906 : : * device_prepare - Prepare a device for system power transition.
1907 : : * @dev: Device to handle.
1908 : : * @state: PM transition of the system being carried out.
1909 : : *
1910 : : * Execute the ->prepare() callback(s) for given device. No new children of the
1911 : : * device may be registered after this function has returned.
1912 : : */
1913 : 0 : static int device_prepare(struct device *dev, pm_message_t state)
1914 : : {
1915 : 0 : int (*callback)(struct device *) = NULL;
1916 : 0 : int ret = 0;
1917 : :
1918 [ # # ]: 0 : if (dev->power.syscore)
1919 : : return 0;
1920 : :
1921 [ # # # # : 0 : WARN_ON(!pm_runtime_enabled(dev) &&
# # ]
1922 : : dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND |
1923 : : DPM_FLAG_LEAVE_SUSPENDED));
1924 : :
1925 : : /*
1926 : : * If a device's parent goes into runtime suspend at the wrong time,
1927 : : * it won't be possible to resume the device. To prevent this we
1928 : : * block runtime suspend here, during the prepare phase, and allow
1929 : : * it again during the complete phase.
1930 : : */
1931 : 0 : pm_runtime_get_noresume(dev);
1932 : :
1933 : 0 : device_lock(dev);
1934 : :
1935 : 0 : dev->power.wakeup_path = false;
1936 : :
1937 [ # # ]: 0 : if (dev->power.no_pm_callbacks)
1938 : 0 : goto unlock;
1939 : :
1940 [ # # ]: 0 : if (dev->pm_domain)
1941 : 0 : callback = dev->pm_domain->ops.prepare;
1942 [ # # # # ]: 0 : else if (dev->type && dev->type->pm)
1943 : 0 : callback = dev->type->pm->prepare;
1944 [ # # # # ]: 0 : else if (dev->class && dev->class->pm)
1945 : 0 : callback = dev->class->pm->prepare;
1946 [ # # # # ]: 0 : else if (dev->bus && dev->bus->pm)
1947 : 0 : callback = dev->bus->pm->prepare;
1948 : :
1949 [ # # # # : 0 : if (!callback && dev->driver && dev->driver->pm)
# # ]
1950 : 0 : callback = dev->driver->pm->prepare;
1951 : :
1952 [ # # ]: 0 : if (callback)
1953 : 0 : ret = callback(dev);
1954 : :
1955 : 0 : unlock:
1956 : 0 : device_unlock(dev);
1957 : :
1958 [ # # ]: 0 : if (ret < 0) {
1959 : 0 : suspend_report_result(callback, ret);
1960 : 0 : pm_runtime_put(dev);
1961 : 0 : return ret;
1962 : : }
1963 : : /*
1964 : : * A positive return value from ->prepare() means "this device appears
1965 : : * to be runtime-suspended and its state is fine, so if it really is
1966 : : * runtime-suspended, you can leave it in that state provided that you
1967 : : * will do the same thing with all of its descendants". This only
1968 : : * applies to suspend transitions, however.
1969 : : */
1970 : 0 : spin_lock_irq(&dev->power.lock);
1971 [ # # ]: 0 : dev->power.direct_complete = state.event == PM_EVENT_SUSPEND &&
1972 [ # # # # ]: 0 : ((pm_runtime_suspended(dev) && ret > 0) ||
1973 [ # # ]: 0 : dev->power.no_pm_callbacks) &&
1974 : 0 : !dev_pm_test_driver_flags(dev, DPM_FLAG_NEVER_SKIP);
1975 : 0 : spin_unlock_irq(&dev->power.lock);
1976 : 0 : return 0;
1977 : : }
1978 : :
1979 : : /**
1980 : : * dpm_prepare - Prepare all non-sysdev devices for a system PM transition.
1981 : : * @state: PM transition of the system being carried out.
1982 : : *
1983 : : * Execute the ->prepare() callback(s) for all devices.
1984 : : */
1985 : 0 : int dpm_prepare(pm_message_t state)
1986 : : {
1987 : 0 : int error = 0;
1988 : :
1989 : 0 : trace_suspend_resume(TPS("dpm_prepare"), state.event, true);
1990 : 0 : might_sleep();
1991 : :
1992 : : /*
1993 : : * Give a chance for the known devices to complete their probes, before
1994 : : * disable probing of devices. This sync point is important at least
1995 : : * at boot time + hibernation restore.
1996 : : */
1997 : 0 : wait_for_device_probe();
1998 : : /*
1999 : : * It is unsafe if probing of devices will happen during suspend or
2000 : : * hibernation and system behavior will be unpredictable in this case.
2001 : : * So, let's prohibit device's probing here and defer their probes
2002 : : * instead. The normal behavior will be restored in dpm_complete().
2003 : : */
2004 : 0 : device_block_probing();
2005 : :
2006 : 0 : mutex_lock(&dpm_list_mtx);
2007 [ # # ]: 0 : while (!list_empty(&dpm_list)) {
2008 : 0 : struct device *dev = to_device(dpm_list.next);
2009 : :
2010 : 0 : get_device(dev);
2011 : 0 : mutex_unlock(&dpm_list_mtx);
2012 : :
2013 : 0 : trace_device_pm_callback_start(dev, "", state.event);
2014 : 0 : error = device_prepare(dev, state);
2015 : 0 : trace_device_pm_callback_end(dev, error);
2016 : :
2017 : 0 : mutex_lock(&dpm_list_mtx);
2018 [ # # ]: 0 : if (error) {
2019 [ # # ]: 0 : if (error == -EAGAIN) {
2020 : 0 : put_device(dev);
2021 : 0 : error = 0;
2022 : 0 : continue;
2023 : : }
2024 [ # # ]: 0 : pr_info("Device %s not prepared for power transition: code %d\n",
2025 : : dev_name(dev), error);
2026 : 0 : put_device(dev);
2027 : 0 : break;
2028 : : }
2029 : 0 : dev->power.is_prepared = true;
2030 [ # # ]: 0 : if (!list_empty(&dev->power.entry))
2031 : 0 : list_move_tail(&dev->power.entry, &dpm_prepared_list);
2032 : 0 : put_device(dev);
2033 : : }
2034 : 0 : mutex_unlock(&dpm_list_mtx);
2035 : 0 : trace_suspend_resume(TPS("dpm_prepare"), state.event, false);
2036 : 0 : return error;
2037 : : }
2038 : :
2039 : : /**
2040 : : * dpm_suspend_start - Prepare devices for PM transition and suspend them.
2041 : : * @state: PM transition of the system being carried out.
2042 : : *
2043 : : * Prepare all non-sysdev devices for system PM transition and execute "suspend"
2044 : : * callbacks for them.
2045 : : */
2046 : 0 : int dpm_suspend_start(pm_message_t state)
2047 : : {
2048 : 0 : ktime_t starttime = ktime_get();
2049 : 0 : int error;
2050 : :
2051 : 0 : error = dpm_prepare(state);
2052 [ # # ]: 0 : if (error) {
2053 : 0 : suspend_stats.failed_prepare++;
2054 : 0 : dpm_save_failed_step(SUSPEND_PREPARE);
2055 : : } else
2056 : 0 : error = dpm_suspend(state);
2057 : 0 : dpm_show_time(starttime, state, error, "start");
2058 : 0 : return error;
2059 : : }
2060 : : EXPORT_SYMBOL_GPL(dpm_suspend_start);
2061 : :
2062 : 0 : void __suspend_report_result(const char *function, void *fn, int ret)
2063 : : {
2064 [ # # # # : 0 : if (ret)
# # ]
2065 : 0 : pr_err("%s(): %pS returns %d\n", function, fn, ret);
2066 : 0 : }
2067 : : EXPORT_SYMBOL_GPL(__suspend_report_result);
2068 : :
2069 : : /**
2070 : : * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
2071 : : * @subordinate: Device that needs to wait for @dev.
2072 : : * @dev: Device to wait for.
2073 : : */
2074 : 0 : int device_pm_wait_for_dev(struct device *subordinate, struct device *dev)
2075 : : {
2076 : 0 : dpm_wait(dev, subordinate->power.async_suspend);
2077 : 0 : return async_error;
2078 : : }
2079 : : EXPORT_SYMBOL_GPL(device_pm_wait_for_dev);
2080 : :
2081 : : /**
2082 : : * dpm_for_each_dev - device iterator.
2083 : : * @data: data for the callback.
2084 : : * @fn: function to be called for each device.
2085 : : *
2086 : : * Iterate over devices in dpm_list, and call @fn for each device,
2087 : : * passing it @data.
2088 : : */
2089 : 0 : void dpm_for_each_dev(void *data, void (*fn)(struct device *, void *))
2090 : : {
2091 : 0 : struct device *dev;
2092 : :
2093 [ # # ]: 0 : if (!fn)
2094 : : return;
2095 : :
2096 : 0 : device_pm_lock();
2097 [ # # ]: 0 : list_for_each_entry(dev, &dpm_list, power.entry)
2098 : 0 : fn(dev, data);
2099 : 0 : device_pm_unlock();
2100 : : }
2101 : : EXPORT_SYMBOL_GPL(dpm_for_each_dev);
2102 : :
2103 : 4004 : static bool pm_ops_is_empty(const struct dev_pm_ops *ops)
2104 : : {
2105 [ + + ]: 4004 : if (!ops)
2106 : : return true;
2107 : :
2108 : 1144 : return !ops->prepare &&
2109 [ - + ]: 442 : !ops->suspend &&
2110 [ # # ]: 0 : !ops->suspend_late &&
2111 [ # # ]: 0 : !ops->suspend_noirq &&
2112 [ # # ]: 0 : !ops->resume_noirq &&
2113 [ # # ]: 0 : !ops->resume_early &&
2114 [ + + - - ]: 1404 : !ops->resume &&
2115 [ # # ]: 0 : !ops->complete;
2116 : : }
2117 : :
2118 : 3978 : void device_pm_check_callbacks(struct device *dev)
2119 : : {
2120 : 3978 : spin_lock_irq(&dev->power.lock);
2121 : 7956 : dev->power.no_pm_callbacks =
2122 [ + + ]: 1612 : (!dev->bus || (pm_ops_is_empty(dev->bus->pm) &&
2123 [ + - + - ]: 1027 : !dev->bus->suspend && !dev->bus->resume)) &&
2124 [ + + + + ]: 3393 : (!dev->class || pm_ops_is_empty(dev->class->pm)) &&
2125 [ + + + + ]: 3354 : (!dev->type || pm_ops_is_empty(dev->type->pm)) &&
2126 [ + + - + : 7267 : (!dev->pm_domain || pm_ops_is_empty(&dev->pm_domain->ops)) &&
- - ]
2127 [ + + + + ]: 3289 : (!dev->driver || (pm_ops_is_empty(dev->driver->pm) &&
2128 [ + - + - ]: 13 : !dev->driver->suspend && !dev->driver->resume));
2129 : 3978 : spin_unlock_irq(&dev->power.lock);
2130 : 3978 : }
2131 : :
2132 : 0 : bool dev_pm_smart_suspend_and_suspended(struct device *dev)
2133 : : {
2134 [ # # # # : 0 : return dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) &&
# # # # #
# # # # #
# # # # #
# # # ]
2135 [ # # # # : 0 : pm_runtime_status_suspended(dev);
# # # # ]
2136 : : }
|
