PageRenderTime 81ms CodeModel.GetById 35ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/base/power/main.c

https://bitbucket.org/emiliolopez/linux
C | 1867 lines | 1264 code | 281 blank | 322 comment | 225 complexity | 88169ea3820e2e7009f9787d3e866236 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
  1. /*
  2. * drivers/base/power/main.c - Where the driver meets power management.
  3. *
  4. * Copyright (c) 2003 Patrick Mochel
  5. * Copyright (c) 2003 Open Source Development Lab
  6. *
  7. * This file is released under the GPLv2
  8. *
  9. *
  10. * The driver model core calls device_pm_add() when a device is registered.
  11. * This will initialize the embedded device_pm_info object in the device
  12. * and add it to the list of power-controlled devices. sysfs entries for
  13. * controlling device power management will also be added.
  14. *
  15. * A separate list is used for keeping track of power info, because the power
  16. * domain dependencies may differ from the ancestral dependencies that the
  17. * subsystem list maintains.
  18. */
  19. #include <linux/device.h>
  20. #include <linux/kallsyms.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/timer.h>
  36. #include "../base.h"
  37. #include "power.h"
  38. typedef int (*pm_callback_t)(struct device *);
  39. /*
  40. * The entries in the dpm_list list are in a depth first order, simply
  41. * because children are guaranteed to be discovered after parents, and
  42. * are inserted at the back of the list on discovery.
  43. *
  44. * Since device_pm_add() may be called with a device lock held,
  45. * we must never try to acquire a device lock while holding
  46. * dpm_list_mutex.
  47. */
  48. LIST_HEAD(dpm_list);
  49. static LIST_HEAD(dpm_prepared_list);
  50. static LIST_HEAD(dpm_suspended_list);
  51. static LIST_HEAD(dpm_late_early_list);
  52. static LIST_HEAD(dpm_noirq_list);
  53. struct suspend_stats suspend_stats;
  54. static DEFINE_MUTEX(dpm_list_mtx);
  55. static pm_message_t pm_transition;
  56. static int async_error;
  57. static const char *pm_verb(int event)
  58. {
  59. switch (event) {
  60. case PM_EVENT_SUSPEND:
  61. return "suspend";
  62. case PM_EVENT_RESUME:
  63. return "resume";
  64. case PM_EVENT_FREEZE:
  65. return "freeze";
  66. case PM_EVENT_QUIESCE:
  67. return "quiesce";
  68. case PM_EVENT_HIBERNATE:
  69. return "hibernate";
  70. case PM_EVENT_THAW:
  71. return "thaw";
  72. case PM_EVENT_RESTORE:
  73. return "restore";
  74. case PM_EVENT_RECOVER:
  75. return "recover";
  76. default:
  77. return "(unknown PM event)";
  78. }
  79. }
  80. /**
  81. * device_pm_sleep_init - Initialize system suspend-related device fields.
  82. * @dev: Device object being initialized.
  83. */
  84. void device_pm_sleep_init(struct device *dev)
  85. {
  86. dev->power.is_prepared = false;
  87. dev->power.is_suspended = false;
  88. dev->power.is_noirq_suspended = false;
  89. dev->power.is_late_suspended = false;
  90. init_completion(&dev->power.completion);
  91. complete_all(&dev->power.completion);
  92. dev->power.wakeup = NULL;
  93. INIT_LIST_HEAD(&dev->power.entry);
  94. }
  95. /**
  96. * device_pm_lock - Lock the list of active devices used by the PM core.
  97. */
  98. void device_pm_lock(void)
  99. {
  100. mutex_lock(&dpm_list_mtx);
  101. }
  102. /**
  103. * device_pm_unlock - Unlock the list of active devices used by the PM core.
  104. */
  105. void device_pm_unlock(void)
  106. {
  107. mutex_unlock(&dpm_list_mtx);
  108. }
  109. /**
  110. * device_pm_add - Add a device to the PM core's list of active devices.
  111. * @dev: Device to add to the list.
  112. */
  113. void device_pm_add(struct device *dev)
  114. {
  115. pr_debug("PM: Adding info for %s:%s\n",
  116. dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
  117. device_pm_check_callbacks(dev);
  118. mutex_lock(&dpm_list_mtx);
  119. if (dev->parent && dev->parent->power.is_prepared)
  120. dev_warn(dev, "parent %s should not be sleeping\n",
  121. dev_name(dev->parent));
  122. list_add_tail(&dev->power.entry, &dpm_list);
  123. dev->power.in_dpm_list = true;
  124. mutex_unlock(&dpm_list_mtx);
  125. }
  126. /**
  127. * device_pm_remove - Remove a device from the PM core's list of active devices.
  128. * @dev: Device to be removed from the list.
  129. */
  130. void device_pm_remove(struct device *dev)
  131. {
  132. pr_debug("PM: Removing info for %s:%s\n",
  133. dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
  134. complete_all(&dev->power.completion);
  135. mutex_lock(&dpm_list_mtx);
  136. list_del_init(&dev->power.entry);
  137. dev->power.in_dpm_list = false;
  138. mutex_unlock(&dpm_list_mtx);
  139. device_wakeup_disable(dev);
  140. pm_runtime_remove(dev);
  141. device_pm_check_callbacks(dev);
  142. }
  143. /**
  144. * device_pm_move_before - Move device in the PM core's list of active devices.
  145. * @deva: Device to move in dpm_list.
  146. * @devb: Device @deva should come before.
  147. */
  148. void device_pm_move_before(struct device *deva, struct device *devb)
  149. {
  150. pr_debug("PM: Moving %s:%s before %s:%s\n",
  151. deva->bus ? deva->bus->name : "No Bus", dev_name(deva),
  152. devb->bus ? devb->bus->name : "No Bus", dev_name(devb));
  153. /* Delete deva from dpm_list and reinsert before devb. */
  154. list_move_tail(&deva->power.entry, &devb->power.entry);
  155. }
  156. /**
  157. * device_pm_move_after - Move device in the PM core's list of active devices.
  158. * @deva: Device to move in dpm_list.
  159. * @devb: Device @deva should come after.
  160. */
  161. void device_pm_move_after(struct device *deva, struct device *devb)
  162. {
  163. pr_debug("PM: Moving %s:%s after %s:%s\n",
  164. deva->bus ? deva->bus->name : "No Bus", dev_name(deva),
  165. devb->bus ? devb->bus->name : "No Bus", dev_name(devb));
  166. /* Delete deva from dpm_list and reinsert after devb. */
  167. list_move(&deva->power.entry, &devb->power.entry);
  168. }
  169. /**
  170. * device_pm_move_last - Move device to end of the PM core's list of devices.
  171. * @dev: Device to move in dpm_list.
  172. */
  173. void device_pm_move_last(struct device *dev)
  174. {
  175. pr_debug("PM: Moving %s:%s to end of list\n",
  176. dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
  177. list_move_tail(&dev->power.entry, &dpm_list);
  178. }
  179. static ktime_t initcall_debug_start(struct device *dev)
  180. {
  181. ktime_t calltime = 0;
  182. if (pm_print_times_enabled) {
  183. pr_info("calling %s+ @ %i, parent: %s\n",
  184. dev_name(dev), task_pid_nr(current),
  185. dev->parent ? dev_name(dev->parent) : "none");
  186. calltime = ktime_get();
  187. }
  188. return calltime;
  189. }
  190. static void initcall_debug_report(struct device *dev, ktime_t calltime,
  191. int error, pm_message_t state,
  192. const char *info)
  193. {
  194. ktime_t rettime;
  195. s64 nsecs;
  196. rettime = ktime_get();
  197. nsecs = (s64) ktime_to_ns(ktime_sub(rettime, calltime));
  198. if (pm_print_times_enabled) {
  199. pr_info("call %s+ returned %d after %Ld usecs\n", dev_name(dev),
  200. error, (unsigned long long)nsecs >> 10);
  201. }
  202. }
  203. /**
  204. * dpm_wait - Wait for a PM operation to complete.
  205. * @dev: Device to wait for.
  206. * @async: If unset, wait only if the device's power.async_suspend flag is set.
  207. */
  208. static void dpm_wait(struct device *dev, bool async)
  209. {
  210. if (!dev)
  211. return;
  212. if (async || (pm_async_enabled && dev->power.async_suspend))
  213. wait_for_completion(&dev->power.completion);
  214. }
  215. static int dpm_wait_fn(struct device *dev, void *async_ptr)
  216. {
  217. dpm_wait(dev, *((bool *)async_ptr));
  218. return 0;
  219. }
  220. static void dpm_wait_for_children(struct device *dev, bool async)
  221. {
  222. device_for_each_child(dev, &async, dpm_wait_fn);
  223. }
  224. static void dpm_wait_for_suppliers(struct device *dev, bool async)
  225. {
  226. struct device_link *link;
  227. int idx;
  228. idx = device_links_read_lock();
  229. /*
  230. * If the supplier goes away right after we've checked the link to it,
  231. * we'll wait for its completion to change the state, but that's fine,
  232. * because the only things that will block as a result are the SRCU
  233. * callbacks freeing the link objects for the links in the list we're
  234. * walking.
  235. */
  236. list_for_each_entry_rcu(link, &dev->links.suppliers, c_node)
  237. if (READ_ONCE(link->status) != DL_STATE_DORMANT)
  238. dpm_wait(link->supplier, async);
  239. device_links_read_unlock(idx);
  240. }
  241. static void dpm_wait_for_superior(struct device *dev, bool async)
  242. {
  243. dpm_wait(dev->parent, async);
  244. dpm_wait_for_suppliers(dev, async);
  245. }
  246. static void dpm_wait_for_consumers(struct device *dev, bool async)
  247. {
  248. struct device_link *link;
  249. int idx;
  250. idx = device_links_read_lock();
  251. /*
  252. * The status of a device link can only be changed from "dormant" by a
  253. * probe, but that cannot happen during system suspend/resume. In
  254. * theory it can change to "dormant" at that time, but then it is
  255. * reasonable to wait for the target device anyway (eg. if it goes
  256. * away, it's better to wait for it to go away completely and then
  257. * continue instead of trying to continue in parallel with its
  258. * unregistration).
  259. */
  260. list_for_each_entry_rcu(link, &dev->links.consumers, s_node)
  261. if (READ_ONCE(link->status) != DL_STATE_DORMANT)
  262. dpm_wait(link->consumer, async);
  263. device_links_read_unlock(idx);
  264. }
  265. static void dpm_wait_for_subordinate(struct device *dev, bool async)
  266. {
  267. dpm_wait_for_children(dev, async);
  268. dpm_wait_for_consumers(dev, async);
  269. }
  270. /**
  271. * pm_op - Return the PM operation appropriate for given PM event.
  272. * @ops: PM operations to choose from.
  273. * @state: PM transition of the system being carried out.
  274. */
  275. static pm_callback_t pm_op(const struct dev_pm_ops *ops, pm_message_t state)
  276. {
  277. switch (state.event) {
  278. #ifdef CONFIG_SUSPEND
  279. case PM_EVENT_SUSPEND:
  280. return ops->suspend;
  281. case PM_EVENT_RESUME:
  282. return ops->resume;
  283. #endif /* CONFIG_SUSPEND */
  284. #ifdef CONFIG_HIBERNATE_CALLBACKS
  285. case PM_EVENT_FREEZE:
  286. case PM_EVENT_QUIESCE:
  287. return ops->freeze;
  288. case PM_EVENT_HIBERNATE:
  289. return ops->poweroff;
  290. case PM_EVENT_THAW:
  291. case PM_EVENT_RECOVER:
  292. return ops->thaw;
  293. break;
  294. case PM_EVENT_RESTORE:
  295. return ops->restore;
  296. #endif /* CONFIG_HIBERNATE_CALLBACKS */
  297. }
  298. return NULL;
  299. }
  300. /**
  301. * pm_late_early_op - Return the PM operation appropriate for given PM event.
  302. * @ops: PM operations to choose from.
  303. * @state: PM transition of the system being carried out.
  304. *
  305. * Runtime PM is disabled for @dev while this function is being executed.
  306. */
  307. static pm_callback_t pm_late_early_op(const struct dev_pm_ops *ops,
  308. pm_message_t state)
  309. {
  310. switch (state.event) {
  311. #ifdef CONFIG_SUSPEND
  312. case PM_EVENT_SUSPEND:
  313. return ops->suspend_late;
  314. case PM_EVENT_RESUME:
  315. return ops->resume_early;
  316. #endif /* CONFIG_SUSPEND */
  317. #ifdef CONFIG_HIBERNATE_CALLBACKS
  318. case PM_EVENT_FREEZE:
  319. case PM_EVENT_QUIESCE:
  320. return ops->freeze_late;
  321. case PM_EVENT_HIBERNATE:
  322. return ops->poweroff_late;
  323. case PM_EVENT_THAW:
  324. case PM_EVENT_RECOVER:
  325. return ops->thaw_early;
  326. case PM_EVENT_RESTORE:
  327. return ops->restore_early;
  328. #endif /* CONFIG_HIBERNATE_CALLBACKS */
  329. }
  330. return NULL;
  331. }
  332. /**
  333. * pm_noirq_op - Return the PM operation appropriate for given PM event.
  334. * @ops: PM operations to choose from.
  335. * @state: PM transition of the system being carried out.
  336. *
  337. * The driver of @dev will not receive interrupts while this function is being
  338. * executed.
  339. */
  340. static pm_callback_t pm_noirq_op(const struct dev_pm_ops *ops, pm_message_t state)
  341. {
  342. switch (state.event) {
  343. #ifdef CONFIG_SUSPEND
  344. case PM_EVENT_SUSPEND:
  345. return ops->suspend_noirq;
  346. case PM_EVENT_RESUME:
  347. return ops->resume_noirq;
  348. #endif /* CONFIG_SUSPEND */
  349. #ifdef CONFIG_HIBERNATE_CALLBACKS
  350. case PM_EVENT_FREEZE:
  351. case PM_EVENT_QUIESCE:
  352. return ops->freeze_noirq;
  353. case PM_EVENT_HIBERNATE:
  354. return ops->poweroff_noirq;
  355. case PM_EVENT_THAW:
  356. case PM_EVENT_RECOVER:
  357. return ops->thaw_noirq;
  358. case PM_EVENT_RESTORE:
  359. return ops->restore_noirq;
  360. #endif /* CONFIG_HIBERNATE_CALLBACKS */
  361. }
  362. return NULL;
  363. }
  364. static void pm_dev_dbg(struct device *dev, pm_message_t state, const char *info)
  365. {
  366. dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
  367. ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?
  368. ", may wakeup" : "");
  369. }
  370. static void pm_dev_err(struct device *dev, pm_message_t state, const char *info,
  371. int error)
  372. {
  373. printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n",
  374. dev_name(dev), pm_verb(state.event), info, error);
  375. }
  376. static void dpm_show_time(ktime_t starttime, pm_message_t state, int error,
  377. const char *info)
  378. {
  379. ktime_t calltime;
  380. u64 usecs64;
  381. int usecs;
  382. calltime = ktime_get();
  383. usecs64 = ktime_to_ns(ktime_sub(calltime, starttime));
  384. do_div(usecs64, NSEC_PER_USEC);
  385. usecs = usecs64;
  386. if (usecs == 0)
  387. usecs = 1;
  388. pm_pr_dbg("%s%s%s of devices %s after %ld.%03ld msecs\n",
  389. info ?: "", info ? " " : "", pm_verb(state.event),
  390. error ? "aborted" : "complete",
  391. usecs / USEC_PER_MSEC, usecs % USEC_PER_MSEC);
  392. }
  393. static int dpm_run_callback(pm_callback_t cb, struct device *dev,
  394. pm_message_t state, const char *info)
  395. {
  396. ktime_t calltime;
  397. int error;
  398. if (!cb)
  399. return 0;
  400. calltime = initcall_debug_start(dev);
  401. pm_dev_dbg(dev, state, info);
  402. trace_device_pm_callback_start(dev, info, state.event);
  403. error = cb(dev);
  404. trace_device_pm_callback_end(dev, error);
  405. suspend_report_result(cb, error);
  406. initcall_debug_report(dev, calltime, error, state, info);
  407. return error;
  408. }
  409. #ifdef CONFIG_DPM_WATCHDOG
  410. struct dpm_watchdog {
  411. struct device *dev;
  412. struct task_struct *tsk;
  413. struct timer_list timer;
  414. };
  415. #define DECLARE_DPM_WATCHDOG_ON_STACK(wd) \
  416. struct dpm_watchdog wd
  417. /**
  418. * dpm_watchdog_handler - Driver suspend / resume watchdog handler.
  419. * @data: Watchdog object address.
  420. *
  421. * Called when a driver has timed out suspending or resuming.
  422. * There's not much we can do here to recover so panic() to
  423. * capture a crash-dump in pstore.
  424. */
  425. static void dpm_watchdog_handler(struct timer_list *t)
  426. {
  427. struct dpm_watchdog *wd = from_timer(wd, t, timer);
  428. dev_emerg(wd->dev, "**** DPM device timeout ****\n");
  429. show_stack(wd->tsk, NULL);
  430. panic("%s %s: unrecoverable failure\n",
  431. dev_driver_string(wd->dev), dev_name(wd->dev));
  432. }
  433. /**
  434. * dpm_watchdog_set - Enable pm watchdog for given device.
  435. * @wd: Watchdog. Must be allocated on the stack.
  436. * @dev: Device to handle.
  437. */
  438. static void dpm_watchdog_set(struct dpm_watchdog *wd, struct device *dev)
  439. {
  440. struct timer_list *timer = &wd->timer;
  441. wd->dev = dev;
  442. wd->tsk = current;
  443. timer_setup_on_stack(timer, dpm_watchdog_handler, 0);
  444. /* use same timeout value for both suspend and resume */
  445. timer->expires = jiffies + HZ * CONFIG_DPM_WATCHDOG_TIMEOUT;
  446. add_timer(timer);
  447. }
  448. /**
  449. * dpm_watchdog_clear - Disable suspend/resume watchdog.
  450. * @wd: Watchdog to disable.
  451. */
  452. static void dpm_watchdog_clear(struct dpm_watchdog *wd)
  453. {
  454. struct timer_list *timer = &wd->timer;
  455. del_timer_sync(timer);
  456. destroy_timer_on_stack(timer);
  457. }
  458. #else
  459. #define DECLARE_DPM_WATCHDOG_ON_STACK(wd)
  460. #define dpm_watchdog_set(x, y)
  461. #define dpm_watchdog_clear(x)
  462. #endif
  463. /*------------------------- Resume routines -------------------------*/
  464. /**
  465. * device_resume_noirq - Execute a "noirq resume" callback for given device.
  466. * @dev: Device to handle.
  467. * @state: PM transition of the system being carried out.
  468. * @async: If true, the device is being resumed asynchronously.
  469. *
  470. * The driver of @dev will not receive interrupts while this function is being
  471. * executed.
  472. */
  473. static int device_resume_noirq(struct device *dev, pm_message_t state, bool async)
  474. {
  475. pm_callback_t callback = NULL;
  476. const char *info = NULL;
  477. int error = 0;
  478. TRACE_DEVICE(dev);
  479. TRACE_RESUME(0);
  480. if (dev->power.syscore || dev->power.direct_complete)
  481. goto Out;
  482. if (!dev->power.is_noirq_suspended)
  483. goto Out;
  484. dpm_wait_for_superior(dev, async);
  485. if (dev->pm_domain) {
  486. info = "noirq power domain ";
  487. callback = pm_noirq_op(&dev->pm_domain->ops, state);
  488. } else if (dev->type && dev->type->pm) {
  489. info = "noirq type ";
  490. callback = pm_noirq_op(dev->type->pm, state);
  491. } else if (dev->class && dev->class->pm) {
  492. info = "noirq class ";
  493. callback = pm_noirq_op(dev->class->pm, state);
  494. } else if (dev->bus && dev->bus->pm) {
  495. info = "noirq bus ";
  496. callback = pm_noirq_op(dev->bus->pm, state);
  497. }
  498. if (!callback && dev->driver && dev->driver->pm) {
  499. info = "noirq driver ";
  500. callback = pm_noirq_op(dev->driver->pm, state);
  501. }
  502. error = dpm_run_callback(callback, dev, state, info);
  503. dev->power.is_noirq_suspended = false;
  504. Out:
  505. complete_all(&dev->power.completion);
  506. TRACE_RESUME(error);
  507. return error;
  508. }
  509. static bool is_async(struct device *dev)
  510. {
  511. return dev->power.async_suspend && pm_async_enabled
  512. && !pm_trace_is_enabled();
  513. }
  514. static void async_resume_noirq(void *data, async_cookie_t cookie)
  515. {
  516. struct device *dev = (struct device *)data;
  517. int error;
  518. error = device_resume_noirq(dev, pm_transition, true);
  519. if (error)
  520. pm_dev_err(dev, pm_transition, " async", error);
  521. put_device(dev);
  522. }
  523. void dpm_noirq_resume_devices(pm_message_t state)
  524. {
  525. struct device *dev;
  526. ktime_t starttime = ktime_get();
  527. trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, true);
  528. mutex_lock(&dpm_list_mtx);
  529. pm_transition = state;
  530. /*
  531. * Advanced the async threads upfront,
  532. * in case the starting of async threads is
  533. * delayed by non-async resuming devices.
  534. */
  535. list_for_each_entry(dev, &dpm_noirq_list, power.entry) {
  536. reinit_completion(&dev->power.completion);
  537. if (is_async(dev)) {
  538. get_device(dev);
  539. async_schedule(async_resume_noirq, dev);
  540. }
  541. }
  542. while (!list_empty(&dpm_noirq_list)) {
  543. dev = to_device(dpm_noirq_list.next);
  544. get_device(dev);
  545. list_move_tail(&dev->power.entry, &dpm_late_early_list);
  546. mutex_unlock(&dpm_list_mtx);
  547. if (!is_async(dev)) {
  548. int error;
  549. error = device_resume_noirq(dev, state, false);
  550. if (error) {
  551. suspend_stats.failed_resume_noirq++;
  552. dpm_save_failed_step(SUSPEND_RESUME_NOIRQ);
  553. dpm_save_failed_dev(dev_name(dev));
  554. pm_dev_err(dev, state, " noirq", error);
  555. }
  556. }
  557. mutex_lock(&dpm_list_mtx);
  558. put_device(dev);
  559. }
  560. mutex_unlock(&dpm_list_mtx);
  561. async_synchronize_full();
  562. dpm_show_time(starttime, state, 0, "noirq");
  563. trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, false);
  564. }
  565. void dpm_noirq_end(void)
  566. {
  567. resume_device_irqs();
  568. device_wakeup_disarm_wake_irqs();
  569. cpuidle_resume();
  570. }
  571. /**
  572. * dpm_resume_noirq - Execute "noirq resume" callbacks for all devices.
  573. * @state: PM transition of the system being carried out.
  574. *
  575. * Invoke the "noirq" resume callbacks for all devices in dpm_noirq_list and
  576. * allow device drivers' interrupt handlers to be called.
  577. */
  578. void dpm_resume_noirq(pm_message_t state)
  579. {
  580. dpm_noirq_resume_devices(state);
  581. dpm_noirq_end();
  582. }
  583. /**
  584. * device_resume_early - Execute an "early resume" callback for given device.
  585. * @dev: Device to handle.
  586. * @state: PM transition of the system being carried out.
  587. * @async: If true, the device is being resumed asynchronously.
  588. *
  589. * Runtime PM is disabled for @dev while this function is being executed.
  590. */
  591. static int device_resume_early(struct device *dev, pm_message_t state, bool async)
  592. {
  593. pm_callback_t callback = NULL;
  594. const char *info = NULL;
  595. int error = 0;
  596. TRACE_DEVICE(dev);
  597. TRACE_RESUME(0);
  598. if (dev->power.syscore || dev->power.direct_complete)
  599. goto Out;
  600. if (!dev->power.is_late_suspended)
  601. goto Out;
  602. dpm_wait_for_superior(dev, async);
  603. if (dev->pm_domain) {
  604. info = "early power domain ";
  605. callback = pm_late_early_op(&dev->pm_domain->ops, state);
  606. } else if (dev->type && dev->type->pm) {
  607. info = "early type ";
  608. callback = pm_late_early_op(dev->type->pm, state);
  609. } else if (dev->class && dev->class->pm) {
  610. info = "early class ";
  611. callback = pm_late_early_op(dev->class->pm, state);
  612. } else if (dev->bus && dev->bus->pm) {
  613. info = "early bus ";
  614. callback = pm_late_early_op(dev->bus->pm, state);
  615. }
  616. if (!callback && dev->driver && dev->driver->pm) {
  617. info = "early driver ";
  618. callback = pm_late_early_op(dev->driver->pm, state);
  619. }
  620. error = dpm_run_callback(callback, dev, state, info);
  621. dev->power.is_late_suspended = false;
  622. Out:
  623. TRACE_RESUME(error);
  624. pm_runtime_enable(dev);
  625. complete_all(&dev->power.completion);
  626. return error;
  627. }
  628. static void async_resume_early(void *data, async_cookie_t cookie)
  629. {
  630. struct device *dev = (struct device *)data;
  631. int error;
  632. error = device_resume_early(dev, pm_transition, true);
  633. if (error)
  634. pm_dev_err(dev, pm_transition, " async", error);
  635. put_device(dev);
  636. }
  637. /**
  638. * dpm_resume_early - Execute "early resume" callbacks for all devices.
  639. * @state: PM transition of the system being carried out.
  640. */
  641. void dpm_resume_early(pm_message_t state)
  642. {
  643. struct device *dev;
  644. ktime_t starttime = ktime_get();
  645. trace_suspend_resume(TPS("dpm_resume_early"), state.event, true);
  646. mutex_lock(&dpm_list_mtx);
  647. pm_transition = state;
  648. /*
  649. * Advanced the async threads upfront,
  650. * in case the starting of async threads is
  651. * delayed by non-async resuming devices.
  652. */
  653. list_for_each_entry(dev, &dpm_late_early_list, power.entry) {
  654. reinit_completion(&dev->power.completion);
  655. if (is_async(dev)) {
  656. get_device(dev);
  657. async_schedule(async_resume_early, dev);
  658. }
  659. }
  660. while (!list_empty(&dpm_late_early_list)) {
  661. dev = to_device(dpm_late_early_list.next);
  662. get_device(dev);
  663. list_move_tail(&dev->power.entry, &dpm_suspended_list);
  664. mutex_unlock(&dpm_list_mtx);
  665. if (!is_async(dev)) {
  666. int error;
  667. error = device_resume_early(dev, state, false);
  668. if (error) {
  669. suspend_stats.failed_resume_early++;
  670. dpm_save_failed_step(SUSPEND_RESUME_EARLY);
  671. dpm_save_failed_dev(dev_name(dev));
  672. pm_dev_err(dev, state, " early", error);
  673. }
  674. }
  675. mutex_lock(&dpm_list_mtx);
  676. put_device(dev);
  677. }
  678. mutex_unlock(&dpm_list_mtx);
  679. async_synchronize_full();
  680. dpm_show_time(starttime, state, 0, "early");
  681. trace_suspend_resume(TPS("dpm_resume_early"), state.event, false);
  682. }
  683. /**
  684. * dpm_resume_start - Execute "noirq" and "early" device callbacks.
  685. * @state: PM transition of the system being carried out.
  686. */
  687. void dpm_resume_start(pm_message_t state)
  688. {
  689. dpm_resume_noirq(state);
  690. dpm_resume_early(state);
  691. }
  692. EXPORT_SYMBOL_GPL(dpm_resume_start);
  693. /**
  694. * device_resume - Execute "resume" callbacks for given device.
  695. * @dev: Device to handle.
  696. * @state: PM transition of the system being carried out.
  697. * @async: If true, the device is being resumed asynchronously.
  698. */
  699. static int device_resume(struct device *dev, pm_message_t state, bool async)
  700. {
  701. pm_callback_t callback = NULL;
  702. const char *info = NULL;
  703. int error = 0;
  704. DECLARE_DPM_WATCHDOG_ON_STACK(wd);
  705. TRACE_DEVICE(dev);
  706. TRACE_RESUME(0);
  707. if (dev->power.syscore)
  708. goto Complete;
  709. if (dev->power.direct_complete) {
  710. /* Match the pm_runtime_disable() in __device_suspend(). */
  711. pm_runtime_enable(dev);
  712. goto Complete;
  713. }
  714. dpm_wait_for_superior(dev, async);
  715. dpm_watchdog_set(&wd, dev);
  716. device_lock(dev);
  717. /*
  718. * This is a fib. But we'll allow new children to be added below
  719. * a resumed device, even if the device hasn't been completed yet.
  720. */
  721. dev->power.is_prepared = false;
  722. if (!dev->power.is_suspended)
  723. goto Unlock;
  724. if (dev->pm_domain) {
  725. info = "power domain ";
  726. callback = pm_op(&dev->pm_domain->ops, state);
  727. goto Driver;
  728. }
  729. if (dev->type && dev->type->pm) {
  730. info = "type ";
  731. callback = pm_op(dev->type->pm, state);
  732. goto Driver;
  733. }
  734. if (dev->class && dev->class->pm) {
  735. info = "class ";
  736. callback = pm_op(dev->class->pm, state);
  737. goto Driver;
  738. }
  739. if (dev->bus) {
  740. if (dev->bus->pm) {
  741. info = "bus ";
  742. callback = pm_op(dev->bus->pm, state);
  743. } else if (dev->bus->resume) {
  744. info = "legacy bus ";
  745. callback = dev->bus->resume;
  746. goto End;
  747. }
  748. }
  749. Driver:
  750. if (!callback && dev->driver && dev->driver->pm) {
  751. info = "driver ";
  752. callback = pm_op(dev->driver->pm, state);
  753. }
  754. End:
  755. error = dpm_run_callback(callback, dev, state, info);
  756. dev->power.is_suspended = false;
  757. Unlock:
  758. device_unlock(dev);
  759. dpm_watchdog_clear(&wd);
  760. Complete:
  761. complete_all(&dev->power.completion);
  762. TRACE_RESUME(error);
  763. return error;
  764. }
  765. static void async_resume(void *data, async_cookie_t cookie)
  766. {
  767. struct device *dev = (struct device *)data;
  768. int error;
  769. error = device_resume(dev, pm_transition, true);
  770. if (error)
  771. pm_dev_err(dev, pm_transition, " async", error);
  772. put_device(dev);
  773. }
  774. /**
  775. * dpm_resume - Execute "resume" callbacks for non-sysdev devices.
  776. * @state: PM transition of the system being carried out.
  777. *
  778. * Execute the appropriate "resume" callback for all devices whose status
  779. * indicates that they are suspended.
  780. */
  781. void dpm_resume(pm_message_t state)
  782. {
  783. struct device *dev;
  784. ktime_t starttime = ktime_get();
  785. trace_suspend_resume(TPS("dpm_resume"), state.event, true);
  786. might_sleep();
  787. mutex_lock(&dpm_list_mtx);
  788. pm_transition = state;
  789. async_error = 0;
  790. list_for_each_entry(dev, &dpm_suspended_list, power.entry) {
  791. reinit_completion(&dev->power.completion);
  792. if (is_async(dev)) {
  793. get_device(dev);
  794. async_schedule(async_resume, dev);
  795. }
  796. }
  797. while (!list_empty(&dpm_suspended_list)) {
  798. dev = to_device(dpm_suspended_list.next);
  799. get_device(dev);
  800. if (!is_async(dev)) {
  801. int error;
  802. mutex_unlock(&dpm_list_mtx);
  803. error = device_resume(dev, state, false);
  804. if (error) {
  805. suspend_stats.failed_resume++;
  806. dpm_save_failed_step(SUSPEND_RESUME);
  807. dpm_save_failed_dev(dev_name(dev));
  808. pm_dev_err(dev, state, "", error);
  809. }
  810. mutex_lock(&dpm_list_mtx);
  811. }
  812. if (!list_empty(&dev->power.entry))
  813. list_move_tail(&dev->power.entry, &dpm_prepared_list);
  814. put_device(dev);
  815. }
  816. mutex_unlock(&dpm_list_mtx);
  817. async_synchronize_full();
  818. dpm_show_time(starttime, state, 0, NULL);
  819. cpufreq_resume();
  820. trace_suspend_resume(TPS("dpm_resume"), state.event, false);
  821. }
  822. /**
  823. * device_complete - Complete a PM transition for given device.
  824. * @dev: Device to handle.
  825. * @state: PM transition of the system being carried out.
  826. */
  827. static void device_complete(struct device *dev, pm_message_t state)
  828. {
  829. void (*callback)(struct device *) = NULL;
  830. const char *info = NULL;
  831. if (dev->power.syscore)
  832. return;
  833. device_lock(dev);
  834. if (dev->pm_domain) {
  835. info = "completing power domain ";
  836. callback = dev->pm_domain->ops.complete;
  837. } else if (dev->type && dev->type->pm) {
  838. info = "completing type ";
  839. callback = dev->type->pm->complete;
  840. } else if (dev->class && dev->class->pm) {
  841. info = "completing class ";
  842. callback = dev->class->pm->complete;
  843. } else if (dev->bus && dev->bus->pm) {
  844. info = "completing bus ";
  845. callback = dev->bus->pm->complete;
  846. }
  847. if (!callback && dev->driver && dev->driver->pm) {
  848. info = "completing driver ";
  849. callback = dev->driver->pm->complete;
  850. }
  851. if (callback) {
  852. pm_dev_dbg(dev, state, info);
  853. callback(dev);
  854. }
  855. device_unlock(dev);
  856. pm_runtime_put(dev);
  857. }
  858. /**
  859. * dpm_complete - Complete a PM transition for all non-sysdev devices.
  860. * @state: PM transition of the system being carried out.
  861. *
  862. * Execute the ->complete() callbacks for all devices whose PM status is not
  863. * DPM_ON (this allows new devices to be registered).
  864. */
  865. void dpm_complete(pm_message_t state)
  866. {
  867. struct list_head list;
  868. trace_suspend_resume(TPS("dpm_complete"), state.event, true);
  869. might_sleep();
  870. INIT_LIST_HEAD(&list);
  871. mutex_lock(&dpm_list_mtx);
  872. while (!list_empty(&dpm_prepared_list)) {
  873. struct device *dev = to_device(dpm_prepared_list.prev);
  874. get_device(dev);
  875. dev->power.is_prepared = false;
  876. list_move(&dev->power.entry, &list);
  877. mutex_unlock(&dpm_list_mtx);
  878. trace_device_pm_callback_start(dev, "", state.event);
  879. device_complete(dev, state);
  880. trace_device_pm_callback_end(dev, 0);
  881. mutex_lock(&dpm_list_mtx);
  882. put_device(dev);
  883. }
  884. list_splice(&list, &dpm_list);
  885. mutex_unlock(&dpm_list_mtx);
  886. /* Allow device probing and trigger re-probing of deferred devices */
  887. device_unblock_probing();
  888. trace_suspend_resume(TPS("dpm_complete"), state.event, false);
  889. }
  890. /**
  891. * dpm_resume_end - Execute "resume" callbacks and complete system transition.
  892. * @state: PM transition of the system being carried out.
  893. *
  894. * Execute "resume" callbacks for all devices and complete the PM transition of
  895. * the system.
  896. */
  897. void dpm_resume_end(pm_message_t state)
  898. {
  899. dpm_resume(state);
  900. dpm_complete(state);
  901. }
  902. EXPORT_SYMBOL_GPL(dpm_resume_end);
  903. /*------------------------- Suspend routines -------------------------*/
  904. /**
  905. * resume_event - Return a "resume" message for given "suspend" sleep state.
  906. * @sleep_state: PM message representing a sleep state.
  907. *
  908. * Return a PM message representing the resume event corresponding to given
  909. * sleep state.
  910. */
  911. static pm_message_t resume_event(pm_message_t sleep_state)
  912. {
  913. switch (sleep_state.event) {
  914. case PM_EVENT_SUSPEND:
  915. return PMSG_RESUME;
  916. case PM_EVENT_FREEZE:
  917. case PM_EVENT_QUIESCE:
  918. return PMSG_RECOVER;
  919. case PM_EVENT_HIBERNATE:
  920. return PMSG_RESTORE;
  921. }
  922. return PMSG_ON;
  923. }
  924. /**
  925. * __device_suspend_noirq - Execute a "noirq suspend" callback for given device.
  926. * @dev: Device to handle.
  927. * @state: PM transition of the system being carried out.
  928. * @async: If true, the device is being suspended asynchronously.
  929. *
  930. * The driver of @dev will not receive interrupts while this function is being
  931. * executed.
  932. */
  933. static int __device_suspend_noirq(struct device *dev, pm_message_t state, bool async)
  934. {
  935. pm_callback_t callback = NULL;
  936. const char *info = NULL;
  937. int error = 0;
  938. TRACE_DEVICE(dev);
  939. TRACE_SUSPEND(0);
  940. dpm_wait_for_subordinate(dev, async);
  941. if (async_error)
  942. goto Complete;
  943. if (pm_wakeup_pending()) {
  944. async_error = -EBUSY;
  945. goto Complete;
  946. }
  947. if (dev->power.syscore || dev->power.direct_complete)
  948. goto Complete;
  949. if (dev->pm_domain) {
  950. info = "noirq power domain ";
  951. callback = pm_noirq_op(&dev->pm_domain->ops, state);
  952. } else if (dev->type && dev->type->pm) {
  953. info = "noirq type ";
  954. callback = pm_noirq_op(dev->type->pm, state);
  955. } else if (dev->class && dev->class->pm) {
  956. info = "noirq class ";
  957. callback = pm_noirq_op(dev->class->pm, state);
  958. } else if (dev->bus && dev->bus->pm) {
  959. info = "noirq bus ";
  960. callback = pm_noirq_op(dev->bus->pm, state);
  961. }
  962. if (!callback && dev->driver && dev->driver->pm) {
  963. info = "noirq driver ";
  964. callback = pm_noirq_op(dev->driver->pm, state);
  965. }
  966. error = dpm_run_callback(callback, dev, state, info);
  967. if (!error)
  968. dev->power.is_noirq_suspended = true;
  969. else
  970. async_error = error;
  971. Complete:
  972. complete_all(&dev->power.completion);
  973. TRACE_SUSPEND(error);
  974. return error;
  975. }
  976. static void async_suspend_noirq(void *data, async_cookie_t cookie)
  977. {
  978. struct device *dev = (struct device *)data;
  979. int error;
  980. error = __device_suspend_noirq(dev, pm_transition, true);
  981. if (error) {
  982. dpm_save_failed_dev(dev_name(dev));
  983. pm_dev_err(dev, pm_transition, " async", error);
  984. }
  985. put_device(dev);
  986. }
  987. static int device_suspend_noirq(struct device *dev)
  988. {
  989. reinit_completion(&dev->power.completion);
  990. if (is_async(dev)) {
  991. get_device(dev);
  992. async_schedule(async_suspend_noirq, dev);
  993. return 0;
  994. }
  995. return __device_suspend_noirq(dev, pm_transition, false);
  996. }
  997. void dpm_noirq_begin(void)
  998. {
  999. cpuidle_pause();
  1000. device_wakeup_arm_wake_irqs();
  1001. suspend_device_irqs();
  1002. }
  1003. int dpm_noirq_suspend_devices(pm_message_t state)
  1004. {
  1005. ktime_t starttime = ktime_get();
  1006. int error = 0;
  1007. trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, true);
  1008. mutex_lock(&dpm_list_mtx);
  1009. pm_transition = state;
  1010. async_error = 0;
  1011. while (!list_empty(&dpm_late_early_list)) {
  1012. struct device *dev = to_device(dpm_late_early_list.prev);
  1013. get_device(dev);
  1014. mutex_unlock(&dpm_list_mtx);
  1015. error = device_suspend_noirq(dev);
  1016. mutex_lock(&dpm_list_mtx);
  1017. if (error) {
  1018. pm_dev_err(dev, state, " noirq", error);
  1019. dpm_save_failed_dev(dev_name(dev));
  1020. put_device(dev);
  1021. break;
  1022. }
  1023. if (!list_empty(&dev->power.entry))
  1024. list_move(&dev->power.entry, &dpm_noirq_list);
  1025. put_device(dev);
  1026. if (async_error)
  1027. break;
  1028. }
  1029. mutex_unlock(&dpm_list_mtx);
  1030. async_synchronize_full();
  1031. if (!error)
  1032. error = async_error;
  1033. if (error) {
  1034. suspend_stats.failed_suspend_noirq++;
  1035. dpm_save_failed_step(SUSPEND_SUSPEND_NOIRQ);
  1036. }
  1037. dpm_show_time(starttime, state, error, "noirq");
  1038. trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, false);
  1039. return error;
  1040. }
  1041. /**
  1042. * dpm_suspend_noirq - Execute "noirq suspend" callbacks for all devices.
  1043. * @state: PM transition of the system being carried out.
  1044. *
  1045. * Prevent device drivers' interrupt handlers from being called and invoke
  1046. * "noirq" suspend callbacks for all non-sysdev devices.
  1047. */
  1048. int dpm_suspend_noirq(pm_message_t state)
  1049. {
  1050. int ret;
  1051. dpm_noirq_begin();
  1052. ret = dpm_noirq_suspend_devices(state);
  1053. if (ret)
  1054. dpm_resume_noirq(resume_event(state));
  1055. return ret;
  1056. }
  1057. /**
  1058. * __device_suspend_late - Execute a "late suspend" callback for given device.
  1059. * @dev: Device to handle.
  1060. * @state: PM transition of the system being carried out.
  1061. * @async: If true, the device is being suspended asynchronously.
  1062. *
  1063. * Runtime PM is disabled for @dev while this function is being executed.
  1064. */
  1065. static int __device_suspend_late(struct device *dev, pm_message_t state, bool async)
  1066. {
  1067. pm_callback_t callback = NULL;
  1068. const char *info = NULL;
  1069. int error = 0;
  1070. TRACE_DEVICE(dev);
  1071. TRACE_SUSPEND(0);
  1072. __pm_runtime_disable(dev, false);
  1073. dpm_wait_for_subordinate(dev, async);
  1074. if (async_error)
  1075. goto Complete;
  1076. if (pm_wakeup_pending()) {
  1077. async_error = -EBUSY;
  1078. goto Complete;
  1079. }
  1080. if (dev->power.syscore || dev->power.direct_complete)
  1081. goto Complete;
  1082. if (dev->pm_domain) {
  1083. info = "late power domain ";
  1084. callback = pm_late_early_op(&dev->pm_domain->ops, state);
  1085. } else if (dev->type && dev->type->pm) {
  1086. info = "late type ";
  1087. callback = pm_late_early_op(dev->type->pm, state);
  1088. } else if (dev->class && dev->class->pm) {
  1089. info = "late class ";
  1090. callback = pm_late_early_op(dev->class->pm, state);
  1091. } else if (dev->bus && dev->bus->pm) {
  1092. info = "late bus ";
  1093. callback = pm_late_early_op(dev->bus->pm, state);
  1094. }
  1095. if (!callback && dev->driver && dev->driver->pm) {
  1096. info = "late driver ";
  1097. callback = pm_late_early_op(dev->driver->pm, state);
  1098. }
  1099. error = dpm_run_callback(callback, dev, state, info);
  1100. if (!error)
  1101. dev->power.is_late_suspended = true;
  1102. else
  1103. async_error = error;
  1104. Complete:
  1105. TRACE_SUSPEND(error);
  1106. complete_all(&dev->power.completion);
  1107. return error;
  1108. }
  1109. static void async_suspend_late(void *data, async_cookie_t cookie)
  1110. {
  1111. struct device *dev = (struct device *)data;
  1112. int error;
  1113. error = __device_suspend_late(dev, pm_transition, true);
  1114. if (error) {
  1115. dpm_save_failed_dev(dev_name(dev));
  1116. pm_dev_err(dev, pm_transition, " async", error);
  1117. }
  1118. put_device(dev);
  1119. }
  1120. static int device_suspend_late(struct device *dev)
  1121. {
  1122. reinit_completion(&dev->power.completion);
  1123. if (is_async(dev)) {
  1124. get_device(dev);
  1125. async_schedule(async_suspend_late, dev);
  1126. return 0;
  1127. }
  1128. return __device_suspend_late(dev, pm_transition, false);
  1129. }
  1130. /**
  1131. * dpm_suspend_late - Execute "late suspend" callbacks for all devices.
  1132. * @state: PM transition of the system being carried out.
  1133. */
  1134. int dpm_suspend_late(pm_message_t state)
  1135. {
  1136. ktime_t starttime = ktime_get();
  1137. int error = 0;
  1138. trace_suspend_resume(TPS("dpm_suspend_late"), state.event, true);
  1139. mutex_lock(&dpm_list_mtx);
  1140. pm_transition = state;
  1141. async_error = 0;
  1142. while (!list_empty(&dpm_suspended_list)) {
  1143. struct device *dev = to_device(dpm_suspended_list.prev);
  1144. get_device(dev);
  1145. mutex_unlock(&dpm_list_mtx);
  1146. error = device_suspend_late(dev);
  1147. mutex_lock(&dpm_list_mtx);
  1148. if (!list_empty(&dev->power.entry))
  1149. list_move(&dev->power.entry, &dpm_late_early_list);
  1150. if (error) {
  1151. pm_dev_err(dev, state, " late", error);
  1152. dpm_save_failed_dev(dev_name(dev));
  1153. put_device(dev);
  1154. break;
  1155. }
  1156. put_device(dev);
  1157. if (async_error)
  1158. break;
  1159. }
  1160. mutex_unlock(&dpm_list_mtx);
  1161. async_synchronize_full();
  1162. if (!error)
  1163. error = async_error;
  1164. if (error) {
  1165. suspend_stats.failed_suspend_late++;
  1166. dpm_save_failed_step(SUSPEND_SUSPEND_LATE);
  1167. dpm_resume_early(resume_event(state));
  1168. }
  1169. dpm_show_time(starttime, state, error, "late");
  1170. trace_suspend_resume(TPS("dpm_suspend_late"), state.event, false);
  1171. return error;
  1172. }
  1173. /**
  1174. * dpm_suspend_end - Execute "late" and "noirq" device suspend callbacks.
  1175. * @state: PM transition of the system being carried out.
  1176. */
  1177. int dpm_suspend_end(pm_message_t state)
  1178. {
  1179. int error = dpm_suspend_late(state);
  1180. if (error)
  1181. return error;
  1182. error = dpm_suspend_noirq(state);
  1183. if (error) {
  1184. dpm_resume_early(resume_event(state));
  1185. return error;
  1186. }
  1187. return 0;
  1188. }
  1189. EXPORT_SYMBOL_GPL(dpm_suspend_end);
  1190. /**
  1191. * legacy_suspend - Execute a legacy (bus or class) suspend callback for device.
  1192. * @dev: Device to suspend.
  1193. * @state: PM transition of the system being carried out.
  1194. * @cb: Suspend callback to execute.
  1195. * @info: string description of caller.
  1196. */
  1197. static int legacy_suspend(struct device *dev, pm_message_t state,
  1198. int (*cb)(struct device *dev, pm_message_t state),
  1199. const char *info)
  1200. {
  1201. int error;
  1202. ktime_t calltime;
  1203. calltime = initcall_debug_start(dev);
  1204. trace_device_pm_callback_start(dev, info, state.event);
  1205. error = cb(dev, state);
  1206. trace_device_pm_callback_end(dev, error);
  1207. suspend_report_result(cb, error);
  1208. initcall_debug_report(dev, calltime, error, state, info);
  1209. return error;
  1210. }
  1211. static void dpm_clear_suppliers_direct_complete(struct device *dev)
  1212. {
  1213. struct device_link *link;
  1214. int idx;
  1215. idx = device_links_read_lock();
  1216. list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) {
  1217. spin_lock_irq(&link->supplier->power.lock);
  1218. link->supplier->power.direct_complete = false;
  1219. spin_unlock_irq(&link->supplier->power.lock);
  1220. }
  1221. device_links_read_unlock(idx);
  1222. }
  1223. /**
  1224. * __device_suspend - Execute "suspend" callbacks for given device.
  1225. * @dev: Device to handle.
  1226. * @state: PM transition of the system being carried out.
  1227. * @async: If true, the device is being suspended asynchronously.
  1228. */
  1229. static int __device_suspend(struct device *dev, pm_message_t state, bool async)
  1230. {
  1231. pm_callback_t callback = NULL;
  1232. const char *info = NULL;
  1233. int error = 0;
  1234. DECLARE_DPM_WATCHDOG_ON_STACK(wd);
  1235. TRACE_DEVICE(dev);
  1236. TRACE_SUSPEND(0);
  1237. dpm_wait_for_subordinate(dev, async);
  1238. if (async_error)
  1239. goto Complete;
  1240. /*
  1241. * If a device configured to wake up the system from sleep states
  1242. * has been suspended at run time and there's a resume request pending
  1243. * for it, this is equivalent to the device signaling wakeup, so the
  1244. * system suspend operation should be aborted.
  1245. */
  1246. if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
  1247. pm_wakeup_event(dev, 0);
  1248. if (pm_wakeup_pending()) {
  1249. async_error = -EBUSY;
  1250. goto Complete;
  1251. }
  1252. if (dev->power.syscore)
  1253. goto Complete;
  1254. if (dev->power.direct_complete) {
  1255. if (pm_runtime_status_suspended(dev)) {
  1256. pm_runtime_disable(dev);
  1257. if (pm_runtime_status_suspended(dev))
  1258. goto Complete;
  1259. pm_runtime_enable(dev);
  1260. }
  1261. dev->power.direct_complete = false;
  1262. }
  1263. dpm_watchdog_set(&wd, dev);
  1264. device_lock(dev);
  1265. if (dev->pm_domain) {
  1266. info = "power domain ";
  1267. callback = pm_op(&dev->pm_domain->ops, state);
  1268. goto Run;
  1269. }
  1270. if (dev->type && dev->type->pm) {
  1271. info = "type ";
  1272. callback = pm_op(dev->type->pm, state);
  1273. goto Run;
  1274. }
  1275. if (dev->class && dev->class->pm) {
  1276. info = "class ";
  1277. callback = pm_op(dev->class->pm, state);
  1278. goto Run;
  1279. }
  1280. if (dev->bus) {
  1281. if (dev->bus->pm) {
  1282. info = "bus ";
  1283. callback = pm_op(dev->bus->pm, state);
  1284. } else if (dev->bus->suspend) {
  1285. pm_dev_dbg(dev, state, "legacy bus ");
  1286. error = legacy_suspend(dev, state, dev->bus->suspend,
  1287. "legacy bus ");
  1288. goto End;
  1289. }
  1290. }
  1291. Run:
  1292. if (!callback && dev->driver && dev->driver->pm) {
  1293. info = "driver ";
  1294. callback = pm_op(dev->driver->pm, state);
  1295. }
  1296. error = dpm_run_callback(callback, dev, state, info);
  1297. End:
  1298. if (!error) {
  1299. struct device *parent = dev->parent;
  1300. dev->power.is_suspended = true;
  1301. if (parent) {
  1302. spin_lock_irq(&parent->power.lock);
  1303. dev->parent->power.direct_complete = false;
  1304. if (dev->power.wakeup_path
  1305. && !dev->parent->power.ignore_children)
  1306. dev->parent->power.wakeup_path = true;
  1307. spin_unlock_irq(&parent->power.lock);
  1308. }
  1309. dpm_clear_suppliers_direct_complete(dev);
  1310. }
  1311. device_unlock(dev);
  1312. dpm_watchdog_clear(&wd);
  1313. Complete:
  1314. if (error)
  1315. async_error = error;
  1316. complete_all(&dev->power.completion);
  1317. TRACE_SUSPEND(error);
  1318. return error;
  1319. }
  1320. static void async_suspend(void *data, async_cookie_t cookie)
  1321. {
  1322. struct device *dev = (struct device *)data;
  1323. int error;
  1324. error = __device_suspend(dev, pm_transition, true);
  1325. if (error) {
  1326. dpm_save_failed_dev(dev_name(dev));
  1327. pm_dev_err(dev, pm_transition, " async", error);
  1328. }
  1329. put_device(dev);
  1330. }
  1331. static int device_suspend(struct device *dev)
  1332. {
  1333. reinit_completion(&dev->power.completion);
  1334. if (is_async(dev)) {
  1335. get_device(dev);
  1336. async_schedule(async_suspend, dev);
  1337. return 0;
  1338. }
  1339. return __device_suspend(dev, pm_transition, false);
  1340. }
  1341. /**
  1342. * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
  1343. * @state: PM transition of the system being carried out.
  1344. */
  1345. int dpm_suspend(pm_message_t state)
  1346. {
  1347. ktime_t starttime = ktime_get();
  1348. int error = 0;
  1349. trace_suspend_resume(TPS("dpm_suspend"), state.event, true);
  1350. might_sleep();
  1351. cpufreq_suspend();
  1352. mutex_lock(&dpm_list_mtx);
  1353. pm_transition = state;
  1354. async_error = 0;
  1355. while (!list_empty(&dpm_prepared_list)) {
  1356. struct device *dev = to_device(dpm_prepared_list.prev);
  1357. get_device(dev);
  1358. mutex_unlock(&dpm_list_mtx);
  1359. error = device_suspend(dev);
  1360. mutex_lock(&dpm_list_mtx);
  1361. if (error) {
  1362. pm_dev_err(dev, state, "", error);
  1363. dpm_save_failed_dev(dev_name(dev));
  1364. put_device(dev);
  1365. break;
  1366. }
  1367. if (!list_empty(&dev->power.entry))
  1368. list_move(&dev->power.entry, &dpm_suspended_list);
  1369. put_device(dev);
  1370. if (async_error)
  1371. break;
  1372. }
  1373. mutex_unlock(&dpm_list_mtx);
  1374. async_synchronize_full();
  1375. if (!error)
  1376. error = async_error;
  1377. if (error) {
  1378. suspend_stats.failed_suspend++;
  1379. dpm_save_failed_step(SUSPEND_SUSPEND);
  1380. }
  1381. dpm_show_time(starttime, state, error, NULL);
  1382. trace_suspend_resume(TPS("dpm_suspend"), state.event, false);
  1383. return error;
  1384. }
  1385. /**
  1386. * device_prepare - Prepare a device for system power transition.
  1387. * @dev: Device to handle.
  1388. * @state: PM transition of the system being carried out.
  1389. *
  1390. * Execute the ->prepare() callback(s) for given device. No new children of the
  1391. * device may be registered after this function has returned.
  1392. */
  1393. static int device_prepare(struct device *dev, pm_message_t state)
  1394. {
  1395. int (*callback)(struct device *) = NULL;
  1396. int ret = 0;
  1397. if (dev->power.syscore)
  1398. return 0;
  1399. WARN_ON(dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) &&
  1400. !pm_runtime_enabled(dev));
  1401. /*
  1402. * If a device's parent goes into runtime suspend at the wrong time,
  1403. * it won't be possible to resume the device. To prevent this we
  1404. * block runtime suspend here, during the prepare phase, and allow
  1405. * it again during the complete phase.
  1406. */
  1407. pm_runtime_get_noresume(dev);
  1408. device_lock(dev);
  1409. dev->power.wakeup_path = device_may_wakeup(dev);
  1410. if (dev->power.no_pm_callbacks) {
  1411. ret = 1; /* Let device go direct_complete */
  1412. goto unlock;
  1413. }
  1414. if (dev->pm_domain)
  1415. callback = dev->pm_domain->ops.prepare;
  1416. else if (dev->type && dev->type->pm)
  1417. callback = dev->type->pm->prepare;
  1418. else if (dev->class && dev->class->pm)
  1419. callback = dev->class->pm->prepare;
  1420. else if (dev->bus && dev->bus->pm)
  1421. callback = dev->bus->pm->prepare;
  1422. if (!callback && dev->driver && dev->driver->pm)
  1423. callback = dev->driver->pm->prepare;
  1424. if (callback)
  1425. ret = callback(dev);
  1426. unlock:
  1427. device_unlock(dev);
  1428. if (ret < 0) {
  1429. suspend_report_result(callback, ret);
  1430. pm_runtime_put(dev);
  1431. return ret;
  1432. }
  1433. /*
  1434. * A positive return value from ->prepare() means "this device appears
  1435. * to be runtime-suspended and its state is fine, so if it really is
  1436. * runtime-suspended, you can leave it in that state provided that you
  1437. * will do the same thing with all of its descendants". This only
  1438. * applies to suspend transitions, however.
  1439. */
  1440. spin_lock_irq(&dev->power.lock);
  1441. dev->power.direct_complete = state.event == PM_EVENT_SUSPEND &&
  1442. pm_runtime_suspended(dev) && ret > 0 &&
  1443. !dev_pm_test_driver_flags(dev, DPM_FLAG_NEVER_SKIP);
  1444. spin_unlock_irq(&dev->power.lock);
  1445. return 0;
  1446. }
  1447. /**
  1448. * dpm_prepare - Prepare all non-sysdev devices for a system PM transition.
  1449. * @state: PM transition of the system being carried out.
  1450. *
  1451. * Execute the ->prepare() callback(s) for all devices.
  1452. */
  1453. int dpm_prepare(pm_message_t state)
  1454. {
  1455. int error = 0;
  1456. trace_suspend_resume(TPS("dpm_prepare"), state.event, true);
  1457. might_sleep();
  1458. /*
  1459. * Give a chance for the known devices to complete their probes, before
  1460. * disable probing of devices. This sync point is important at least
  1461. * at boot time + hibernation restore.
  1462. */
  1463. wait_for_device_probe();
  1464. /*
  1465. * It is unsafe if probing of devices will happen during suspend or
  1466. * hibernation and system behavior will be unpredictable in this case.
  1467. * So, let's prohibit device's probing here and defer their probes
  1468. * instead. The normal behavior will be restored in dpm_complete().
  1469. */
  1470. device_block_probing();
  1471. mutex_lock(&dpm_list_mtx);
  1472. while (!list_empty(&dpm_list)) {
  1473. struct device *dev = to_device(dpm_list.next);
  1474. get_device(dev);
  1475. mutex_unlock(&dpm_list_mtx);
  1476. trace_device_pm_callback_start(dev, "", state.event);
  1477. error = device_prepare(dev, state);
  1478. trace_device_pm_callback_end(dev, error);
  1479. mutex_lock(&dpm_list_mtx);
  1480. if (error) {
  1481. if (error == -EAGAIN) {
  1482. put_device(dev);
  1483. error = 0;
  1484. continue;
  1485. }
  1486. printk(KERN_INFO "PM: Device %s not prepared "
  1487. "for power transition: code %d\n",
  1488. dev_name(dev), error);
  1489. put_device(dev);
  1490. break;
  1491. }
  1492. dev->power.is_prepared = true;
  1493. if (!list_empty(&dev->power.entry))
  1494. list_move_tail(&dev->power.entry, &dpm_prepared_list);
  1495. put_device(dev);
  1496. }
  1497. mutex_unlock(&dpm_list_mtx);
  1498. trace_suspend_resume(TPS("dpm_prepare"), state.event, false);
  1499. return error;
  1500. }
  1501. /**
  1502. * dpm_suspend_start - Prepare devices for PM transition and suspend them.
  1503. * @state: PM transition of the system being carried out.
  1504. *
  1505. * Prepare all non-sysdev devices for system PM transition and execute "suspend"
  1506. * callbacks for them.
  1507. */
  1508. int dpm_suspend_start(pm_message_t state)
  1509. {
  1510. int error;
  1511. error = dpm_prepare(state);
  1512. if (error) {
  1513. suspend_stats.failed_prepare++;
  1514. dpm_save_failed_step(SUSPEND_PREPARE);
  1515. } else
  1516. error = dpm_suspend(state);
  1517. return error;
  1518. }
  1519. EXPORT_SYMBOL_GPL(dpm_suspend_start);
  1520. void __suspend_report_result(const char *function, void *fn, int ret)
  1521. {
  1522. if (ret)
  1523. printk(KERN_ERR "%s(): %pF returns %d\n", function, fn, ret);
  1524. }
  1525. EXPORT_SYMBOL_GPL(__suspend_report_result);
  1526. /**
  1527. * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
  1528. * @dev: Device to wait for.
  1529. * @subordinate: Device that needs to wait for @dev.
  1530. */
  1531. int device_pm_wait_for_dev(struct device *subordinate, struct device *dev)
  1532. {
  1533. dpm_wait(dev, subordinate->power.async_suspend);
  1534. return async_error;
  1535. }
  1536. EXPORT_SYMBOL_GPL(device_pm_wait_for_dev);
  1537. /**
  1538. * dpm_for_each_dev - device iterator.
  1539. * @data: data for the callback.
  1540. * @fn: function to be called for each device.
  1541. *
  1542. * Iterate over devices in dpm_list, and call @fn for each device,
  1543. * passing it @data.
  1544. */
  1545. void dpm_for_each_dev(void *data, void (*fn)(struct device *, void *))
  1546. {
  1547. struct device *dev;
  1548. if (!fn)
  1549. return;
  1550. device_pm_lock();
  1551. list_for_each_entry(dev, &dpm_list, power.entry)
  1552. fn(dev, data);
  1553. device_pm_unlock();
  1554. }
  1555. EXPORT_SYMBOL_GPL(dpm_for_each_dev);
  1556. static bool pm_ops_is_empty(const struct dev_pm_ops *ops)
  1557. {
  1558. if (!ops)
  1559. return true;
  1560. return !ops->prepare &&
  1561. !ops->suspend &&
  1562. !ops->suspend_late &&
  1563. !ops->suspend_noirq &&
  1564. !ops->resume_noirq &&
  1565. !ops->resume_early &&
  1566. !ops->resume &&
  1567. !ops->complete;
  1568. }
  1569. void device_pm_check_callbacks(struct device *dev)
  1570. {
  1571. spin_lock_irq(&dev->power.lock);
  1572. dev->power.no_pm_callbacks =
  1573. (!dev->bus || (pm_ops_is_empty(dev->bus->pm) &&
  1574. !dev->bus->suspend && !dev->bus->resume)) &&
  1575. (!dev->class || pm_ops_is_empty(dev->class->pm)) &&
  1576. (!dev->type || pm_ops_is_empty(dev->type->pm)) &&
  1577. (!dev->pm_domain || pm_ops_is_empty(&dev->pm_domain->ops)) &&
  1578. (!dev->driver || (pm_ops_is_empty(dev->driver->pm) &&
  1579. !dev->driver->suspend && !dev->driver->resume));
  1580. spin_unlock_irq(&dev->power.lock);
  1581. }
  1582. bool dev_pm_smart_suspend_and_suspended(struct device *dev)
  1583. {
  1584. return dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) &&
  1585. pm_runtime_status_suspended(dev);
  1586. }