main.c 36 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473
  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/resume-trace.h>
  26. #include <linux/interrupt.h>
  27. #include <linux/sched.h>
  28. #include <linux/async.h>
  29. #include <linux/suspend.h>
  30. #include <trace/events/power.h>
  31. #include <linux/cpuidle.h>
  32. #include <linux/timer.h>
  33. #include <linux/wakeup_reason.h>
  34. #include "../base.h"
  35. #include "power.h"
  36. typedef int (*pm_callback_t)(struct device *);
  37. /*
  38. * The entries in the dpm_list list are in a depth first order, simply
  39. * because children are guaranteed to be discovered after parents, and
  40. * are inserted at the back of the list on discovery.
  41. *
  42. * Since device_pm_add() may be called with a device lock held,
  43. * we must never try to acquire a device lock while holding
  44. * dpm_list_mutex.
  45. */
  46. LIST_HEAD(dpm_list);
  47. static LIST_HEAD(dpm_prepared_list);
  48. static LIST_HEAD(dpm_suspended_list);
  49. static LIST_HEAD(dpm_late_early_list);
  50. static LIST_HEAD(dpm_noirq_list);
  51. struct suspend_stats suspend_stats;
  52. static DEFINE_MUTEX(dpm_list_mtx);
  53. static pm_message_t pm_transition;
  54. struct dpm_watchdog {
  55. struct device *dev;
  56. struct task_struct *tsk;
  57. struct timer_list timer;
  58. };
  59. static int async_error;
  60. static char *pm_verb(int event)
  61. {
  62. switch (event) {
  63. case PM_EVENT_SUSPEND:
  64. return "suspend";
  65. case PM_EVENT_RESUME:
  66. return "resume";
  67. case PM_EVENT_FREEZE:
  68. return "freeze";
  69. case PM_EVENT_QUIESCE:
  70. return "quiesce";
  71. case PM_EVENT_HIBERNATE:
  72. return "hibernate";
  73. case PM_EVENT_THAW:
  74. return "thaw";
  75. case PM_EVENT_RESTORE:
  76. return "restore";
  77. case PM_EVENT_RECOVER:
  78. return "recover";
  79. default:
  80. return "(unknown PM event)";
  81. }
  82. }
  83. /**
  84. * device_pm_sleep_init - Initialize system suspend-related device fields.
  85. * @dev: Device object being initialized.
  86. */
  87. void device_pm_sleep_init(struct device *dev)
  88. {
  89. dev->power.is_prepared = false;
  90. dev->power.is_suspended = false;
  91. init_completion(&dev->power.completion);
  92. complete_all(&dev->power.completion);
  93. dev->power.wakeup = NULL;
  94. INIT_LIST_HEAD(&dev->power.entry);
  95. }
  96. /**
  97. * device_pm_lock - Lock the list of active devices used by the PM core.
  98. */
  99. void device_pm_lock(void)
  100. {
  101. mutex_lock(&dpm_list_mtx);
  102. }
  103. /**
  104. * device_pm_unlock - Unlock the list of active devices used by the PM core.
  105. */
  106. void device_pm_unlock(void)
  107. {
  108. mutex_unlock(&dpm_list_mtx);
  109. }
  110. /**
  111. * device_pm_add - Add a device to the PM core's list of active devices.
  112. * @dev: Device to add to the list.
  113. */
  114. void device_pm_add(struct device *dev)
  115. {
  116. pr_debug("PM: Adding info for %s:%s\n",
  117. dev->bus ? dev->bus->name : "No Bus", dev_name(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. mutex_unlock(&dpm_list_mtx);
  124. }
  125. /**
  126. * device_pm_remove - Remove a device from the PM core's list of active devices.
  127. * @dev: Device to be removed from the list.
  128. */
  129. void device_pm_remove(struct device *dev)
  130. {
  131. pr_debug("PM: Removing info for %s:%s\n",
  132. dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
  133. complete_all(&dev->power.completion);
  134. mutex_lock(&dpm_list_mtx);
  135. list_del_init(&dev->power.entry);
  136. mutex_unlock(&dpm_list_mtx);
  137. device_wakeup_disable(dev);
  138. pm_runtime_remove(dev);
  139. }
  140. /**
  141. * device_pm_move_before - Move device in the PM core's list of active devices.
  142. * @deva: Device to move in dpm_list.
  143. * @devb: Device @deva should come before.
  144. */
  145. void device_pm_move_before(struct device *deva, struct device *devb)
  146. {
  147. pr_debug("PM: Moving %s:%s before %s:%s\n",
  148. deva->bus ? deva->bus->name : "No Bus", dev_name(deva),
  149. devb->bus ? devb->bus->name : "No Bus", dev_name(devb));
  150. /* Delete deva from dpm_list and reinsert before devb. */
  151. list_move_tail(&deva->power.entry, &devb->power.entry);
  152. }
  153. /**
  154. * device_pm_move_after - Move device in the PM core's list of active devices.
  155. * @deva: Device to move in dpm_list.
  156. * @devb: Device @deva should come after.
  157. */
  158. void device_pm_move_after(struct device *deva, struct device *devb)
  159. {
  160. pr_debug("PM: Moving %s:%s after %s:%s\n",
  161. deva->bus ? deva->bus->name : "No Bus", dev_name(deva),
  162. devb->bus ? devb->bus->name : "No Bus", dev_name(devb));
  163. /* Delete deva from dpm_list and reinsert after devb. */
  164. list_move(&deva->power.entry, &devb->power.entry);
  165. }
  166. /**
  167. * device_pm_move_last - Move device to end of the PM core's list of devices.
  168. * @dev: Device to move in dpm_list.
  169. */
  170. void device_pm_move_last(struct device *dev)
  171. {
  172. pr_debug("PM: Moving %s:%s to end of list\n",
  173. dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
  174. list_move_tail(&dev->power.entry, &dpm_list);
  175. }
  176. static ktime_t initcall_debug_start(struct device *dev)
  177. {
  178. ktime_t calltime = ktime_set(0, 0);
  179. if (pm_print_times_enabled) {
  180. pr_info("calling %s+ @ %i, parent: %s\n",
  181. dev_name(dev), task_pid_nr(current),
  182. dev->parent ? dev_name(dev->parent) : "none");
  183. calltime = ktime_get();
  184. }
  185. return calltime;
  186. }
  187. static void initcall_debug_report(struct device *dev, ktime_t calltime,
  188. int error, pm_message_t state, char *info)
  189. {
  190. ktime_t rettime;
  191. s64 nsecs;
  192. rettime = ktime_get();
  193. nsecs = (s64) ktime_to_ns(ktime_sub(rettime, calltime));
  194. if (pm_print_times_enabled) {
  195. pr_info("call %s+ returned %d after %Ld usecs\n", dev_name(dev),
  196. error, (unsigned long long)nsecs >> 10);
  197. }
  198. trace_device_pm_report_time(dev, info, nsecs, pm_verb(state.event),
  199. error);
  200. }
  201. /**
  202. * dpm_wait - Wait for a PM operation to complete.
  203. * @dev: Device to wait for.
  204. * @async: If unset, wait only if the device's power.async_suspend flag is set.
  205. */
  206. static void dpm_wait(struct device *dev, bool async)
  207. {
  208. if (!dev)
  209. return;
  210. if (async || (pm_async_enabled && dev->power.async_suspend))
  211. wait_for_completion(&dev->power.completion);
  212. }
  213. static int dpm_wait_fn(struct device *dev, void *async_ptr)
  214. {
  215. dpm_wait(dev, *((bool *)async_ptr));
  216. return 0;
  217. }
  218. static void dpm_wait_for_children(struct device *dev, bool async)
  219. {
  220. device_for_each_child(dev, &async, dpm_wait_fn);
  221. }
  222. /**
  223. * pm_op - Return the PM operation appropriate for given PM event.
  224. * @ops: PM operations to choose from.
  225. * @state: PM transition of the system being carried out.
  226. */
  227. static pm_callback_t pm_op(const struct dev_pm_ops *ops, pm_message_t state)
  228. {
  229. switch (state.event) {
  230. #ifdef CONFIG_SUSPEND
  231. case PM_EVENT_SUSPEND:
  232. return ops->suspend;
  233. case PM_EVENT_RESUME:
  234. return ops->resume;
  235. #endif /* CONFIG_SUSPEND */
  236. #ifdef CONFIG_HIBERNATE_CALLBACKS
  237. case PM_EVENT_FREEZE:
  238. case PM_EVENT_QUIESCE:
  239. return ops->freeze;
  240. case PM_EVENT_HIBERNATE:
  241. return ops->poweroff;
  242. case PM_EVENT_THAW:
  243. case PM_EVENT_RECOVER:
  244. return ops->thaw;
  245. break;
  246. case PM_EVENT_RESTORE:
  247. return ops->restore;
  248. #endif /* CONFIG_HIBERNATE_CALLBACKS */
  249. }
  250. return NULL;
  251. }
  252. /**
  253. * pm_late_early_op - Return the PM operation appropriate for given PM event.
  254. * @ops: PM operations to choose from.
  255. * @state: PM transition of the system being carried out.
  256. *
  257. * Runtime PM is disabled for @dev while this function is being executed.
  258. */
  259. static pm_callback_t pm_late_early_op(const struct dev_pm_ops *ops,
  260. pm_message_t state)
  261. {
  262. switch (state.event) {
  263. #ifdef CONFIG_SUSPEND
  264. case PM_EVENT_SUSPEND:
  265. return ops->suspend_late;
  266. case PM_EVENT_RESUME:
  267. return ops->resume_early;
  268. #endif /* CONFIG_SUSPEND */
  269. #ifdef CONFIG_HIBERNATE_CALLBACKS
  270. case PM_EVENT_FREEZE:
  271. case PM_EVENT_QUIESCE:
  272. return ops->freeze_late;
  273. case PM_EVENT_HIBERNATE:
  274. return ops->poweroff_late;
  275. case PM_EVENT_THAW:
  276. case PM_EVENT_RECOVER:
  277. return ops->thaw_early;
  278. case PM_EVENT_RESTORE:
  279. return ops->restore_early;
  280. #endif /* CONFIG_HIBERNATE_CALLBACKS */
  281. }
  282. return NULL;
  283. }
  284. /**
  285. * pm_noirq_op - Return the PM operation appropriate for given PM event.
  286. * @ops: PM operations to choose from.
  287. * @state: PM transition of the system being carried out.
  288. *
  289. * The driver of @dev will not receive interrupts while this function is being
  290. * executed.
  291. */
  292. static pm_callback_t pm_noirq_op(const struct dev_pm_ops *ops, pm_message_t state)
  293. {
  294. switch (state.event) {
  295. #ifdef CONFIG_SUSPEND
  296. case PM_EVENT_SUSPEND:
  297. return ops->suspend_noirq;
  298. case PM_EVENT_RESUME:
  299. return ops->resume_noirq;
  300. #endif /* CONFIG_SUSPEND */
  301. #ifdef CONFIG_HIBERNATE_CALLBACKS
  302. case PM_EVENT_FREEZE:
  303. case PM_EVENT_QUIESCE:
  304. return ops->freeze_noirq;
  305. case PM_EVENT_HIBERNATE:
  306. return ops->poweroff_noirq;
  307. case PM_EVENT_THAW:
  308. case PM_EVENT_RECOVER:
  309. return ops->thaw_noirq;
  310. case PM_EVENT_RESTORE:
  311. return ops->restore_noirq;
  312. #endif /* CONFIG_HIBERNATE_CALLBACKS */
  313. }
  314. return NULL;
  315. }
  316. static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info)
  317. {
  318. dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
  319. ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?
  320. ", may wakeup" : "");
  321. }
  322. static void pm_dev_err(struct device *dev, pm_message_t state, char *info,
  323. int error)
  324. {
  325. printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n",
  326. dev_name(dev), pm_verb(state.event), info, error);
  327. }
  328. static void dpm_show_time(ktime_t starttime, pm_message_t state, char *info)
  329. {
  330. ktime_t calltime;
  331. u64 usecs64;
  332. int usecs;
  333. calltime = ktime_get();
  334. usecs64 = ktime_to_ns(ktime_sub(calltime, starttime));
  335. do_div(usecs64, NSEC_PER_USEC);
  336. usecs = usecs64;
  337. if (usecs == 0)
  338. usecs = 1;
  339. pr_info("PM: %s%s%s of devices complete after %ld.%03ld msecs\n",
  340. info ?: "", info ? " " : "", pm_verb(state.event),
  341. usecs / USEC_PER_MSEC, usecs % USEC_PER_MSEC);
  342. }
  343. static int dpm_run_callback(pm_callback_t cb, struct device *dev,
  344. pm_message_t state, char *info)
  345. {
  346. ktime_t calltime;
  347. int error;
  348. if (!cb)
  349. return 0;
  350. calltime = initcall_debug_start(dev);
  351. pm_dev_dbg(dev, state, info);
  352. error = cb(dev);
  353. suspend_report_result(cb, error);
  354. initcall_debug_report(dev, calltime, error, state, info);
  355. return error;
  356. }
  357. /**
  358. * dpm_wd_handler - Driver suspend / resume watchdog handler.
  359. *
  360. * Called when a driver has timed out suspending or resuming.
  361. * There's not much we can do here to recover so BUG() out for
  362. * a crash-dump
  363. */
  364. static void dpm_wd_handler(unsigned long data)
  365. {
  366. struct dpm_watchdog *wd = (void *)data;
  367. struct device *dev = wd->dev;
  368. struct task_struct *tsk = wd->tsk;
  369. dev_emerg(dev, "**** DPM device timeout ****\n");
  370. show_stack(tsk, NULL);
  371. BUG();
  372. }
  373. /**
  374. * dpm_wd_set - Enable pm watchdog for given device.
  375. * @wd: Watchdog. Must be allocated on the stack.
  376. * @dev: Device to handle.
  377. */
  378. static void dpm_wd_set(struct dpm_watchdog *wd, struct device *dev)
  379. {
  380. struct timer_list *timer = &wd->timer;
  381. wd->dev = dev;
  382. wd->tsk = get_current();
  383. init_timer_on_stack(timer);
  384. timer->expires = jiffies + HZ * 12;
  385. timer->function = dpm_wd_handler;
  386. timer->data = (unsigned long)wd;
  387. add_timer(timer);
  388. }
  389. /**
  390. * dpm_wd_clear - Disable pm watchdog.
  391. * @wd: Watchdog to disable.
  392. */
  393. static void dpm_wd_clear(struct dpm_watchdog *wd)
  394. {
  395. struct timer_list *timer = &wd->timer;
  396. del_timer_sync(timer);
  397. destroy_timer_on_stack(timer);
  398. }
  399. /*------------------------- Resume routines -------------------------*/
  400. /**
  401. * device_resume_noirq - Execute an "early resume" callback for given device.
  402. * @dev: Device to handle.
  403. * @state: PM transition of the system being carried out.
  404. *
  405. * The driver of @dev will not receive interrupts while this function is being
  406. * executed.
  407. */
  408. static int device_resume_noirq(struct device *dev, pm_message_t state)
  409. {
  410. pm_callback_t callback = NULL;
  411. char *info = NULL;
  412. int error = 0;
  413. TRACE_DEVICE(dev);
  414. TRACE_RESUME(0);
  415. if (dev->power.syscore)
  416. goto Out;
  417. if (dev->pm_domain) {
  418. info = "noirq power domain ";
  419. callback = pm_noirq_op(&dev->pm_domain->ops, state);
  420. } else if (dev->type && dev->type->pm) {
  421. info = "noirq type ";
  422. callback = pm_noirq_op(dev->type->pm, state);
  423. } else if (dev->class && dev->class->pm) {
  424. info = "noirq class ";
  425. callback = pm_noirq_op(dev->class->pm, state);
  426. } else if (dev->bus && dev->bus->pm) {
  427. info = "noirq bus ";
  428. callback = pm_noirq_op(dev->bus->pm, state);
  429. }
  430. if (!callback && dev->driver && dev->driver->pm) {
  431. info = "noirq driver ";
  432. callback = pm_noirq_op(dev->driver->pm, state);
  433. }
  434. error = dpm_run_callback(callback, dev, state, info);
  435. Out:
  436. TRACE_RESUME(error);
  437. return error;
  438. }
  439. /**
  440. * dpm_resume_noirq - Execute "noirq resume" callbacks for all devices.
  441. * @state: PM transition of the system being carried out.
  442. *
  443. * Call the "noirq" resume handlers for all devices in dpm_noirq_list and
  444. * enable device drivers to receive interrupts.
  445. */
  446. static void dpm_resume_noirq(pm_message_t state)
  447. {
  448. ktime_t starttime = ktime_get();
  449. mutex_lock(&dpm_list_mtx);
  450. while (!list_empty(&dpm_noirq_list)) {
  451. struct device *dev = to_device(dpm_noirq_list.next);
  452. int error;
  453. get_device(dev);
  454. list_move_tail(&dev->power.entry, &dpm_late_early_list);
  455. mutex_unlock(&dpm_list_mtx);
  456. error = device_resume_noirq(dev, state);
  457. if (error) {
  458. suspend_stats.failed_resume_noirq++;
  459. dpm_save_failed_step(SUSPEND_RESUME_NOIRQ);
  460. dpm_save_failed_dev(dev_name(dev));
  461. pm_dev_err(dev, state, " noirq", error);
  462. }
  463. mutex_lock(&dpm_list_mtx);
  464. put_device(dev);
  465. }
  466. mutex_unlock(&dpm_list_mtx);
  467. dpm_show_time(starttime, state, "noirq");
  468. resume_device_irqs();
  469. cpuidle_resume();
  470. }
  471. /**
  472. * device_resume_early - Execute an "early resume" callback for given device.
  473. * @dev: Device to handle.
  474. * @state: PM transition of the system being carried out.
  475. *
  476. * Runtime PM is disabled for @dev while this function is being executed.
  477. */
  478. static int device_resume_early(struct device *dev, pm_message_t state)
  479. {
  480. pm_callback_t callback = NULL;
  481. char *info = NULL;
  482. int error = 0;
  483. TRACE_DEVICE(dev);
  484. TRACE_RESUME(0);
  485. if (dev->power.syscore)
  486. goto Out;
  487. if (dev->pm_domain) {
  488. info = "early power domain ";
  489. callback = pm_late_early_op(&dev->pm_domain->ops, state);
  490. } else if (dev->type && dev->type->pm) {
  491. info = "early type ";
  492. callback = pm_late_early_op(dev->type->pm, state);
  493. } else if (dev->class && dev->class->pm) {
  494. info = "early class ";
  495. callback = pm_late_early_op(dev->class->pm, state);
  496. } else if (dev->bus && dev->bus->pm) {
  497. info = "early bus ";
  498. callback = pm_late_early_op(dev->bus->pm, state);
  499. }
  500. if (!callback && dev->driver && dev->driver->pm) {
  501. info = "early driver ";
  502. callback = pm_late_early_op(dev->driver->pm, state);
  503. }
  504. error = dpm_run_callback(callback, dev, state, info);
  505. Out:
  506. TRACE_RESUME(error);
  507. pm_runtime_enable(dev);
  508. return error;
  509. }
  510. /**
  511. * dpm_resume_early - Execute "early resume" callbacks for all devices.
  512. * @state: PM transition of the system being carried out.
  513. */
  514. static void dpm_resume_early(pm_message_t state)
  515. {
  516. ktime_t starttime = ktime_get();
  517. mutex_lock(&dpm_list_mtx);
  518. while (!list_empty(&dpm_late_early_list)) {
  519. struct device *dev = to_device(dpm_late_early_list.next);
  520. int error;
  521. get_device(dev);
  522. list_move_tail(&dev->power.entry, &dpm_suspended_list);
  523. mutex_unlock(&dpm_list_mtx);
  524. error = device_resume_early(dev, state);
  525. if (error) {
  526. suspend_stats.failed_resume_early++;
  527. dpm_save_failed_step(SUSPEND_RESUME_EARLY);
  528. dpm_save_failed_dev(dev_name(dev));
  529. pm_dev_err(dev, state, " early", error);
  530. }
  531. mutex_lock(&dpm_list_mtx);
  532. put_device(dev);
  533. }
  534. mutex_unlock(&dpm_list_mtx);
  535. dpm_show_time(starttime, state, "early");
  536. }
  537. /**
  538. * dpm_resume_start - Execute "noirq" and "early" device callbacks.
  539. * @state: PM transition of the system being carried out.
  540. */
  541. void dpm_resume_start(pm_message_t state)
  542. {
  543. dpm_resume_noirq(state);
  544. dpm_resume_early(state);
  545. }
  546. EXPORT_SYMBOL_GPL(dpm_resume_start);
  547. /**
  548. * device_resume - Execute "resume" callbacks for given device.
  549. * @dev: Device to handle.
  550. * @state: PM transition of the system being carried out.
  551. * @async: If true, the device is being resumed asynchronously.
  552. */
  553. static int device_resume(struct device *dev, pm_message_t state, bool async)
  554. {
  555. pm_callback_t callback = NULL;
  556. char *info = NULL;
  557. int error = 0;
  558. struct dpm_watchdog wd;
  559. TRACE_DEVICE(dev);
  560. TRACE_RESUME(0);
  561. if (dev->power.syscore)
  562. goto Complete;
  563. dpm_wait(dev->parent, async);
  564. device_lock(dev);
  565. /*
  566. * This is a fib. But we'll allow new children to be added below
  567. * a resumed device, even if the device hasn't been completed yet.
  568. */
  569. dev->power.is_prepared = false;
  570. dpm_wd_set(&wd, dev);
  571. if (!dev->power.is_suspended)
  572. goto Unlock;
  573. if (dev->pm_domain) {
  574. info = "power domain ";
  575. callback = pm_op(&dev->pm_domain->ops, state);
  576. goto Driver;
  577. }
  578. if (dev->type && dev->type->pm) {
  579. info = "type ";
  580. callback = pm_op(dev->type->pm, state);
  581. goto Driver;
  582. }
  583. if (dev->class) {
  584. if (dev->class->pm) {
  585. info = "class ";
  586. callback = pm_op(dev->class->pm, state);
  587. goto Driver;
  588. } else if (dev->class->resume) {
  589. info = "legacy class ";
  590. callback = dev->class->resume;
  591. goto End;
  592. }
  593. }
  594. if (dev->bus) {
  595. if (dev->bus->pm) {
  596. info = "bus ";
  597. callback = pm_op(dev->bus->pm, state);
  598. } else if (dev->bus->resume) {
  599. info = "legacy bus ";
  600. callback = dev->bus->resume;
  601. goto End;
  602. }
  603. }
  604. Driver:
  605. if (!callback && dev->driver && dev->driver->pm) {
  606. info = "driver ";
  607. callback = pm_op(dev->driver->pm, state);
  608. }
  609. End:
  610. error = dpm_run_callback(callback, dev, state, info);
  611. dev->power.is_suspended = false;
  612. Unlock:
  613. device_unlock(dev);
  614. dpm_wd_clear(&wd);
  615. Complete:
  616. complete_all(&dev->power.completion);
  617. TRACE_RESUME(error);
  618. return error;
  619. }
  620. static void async_resume(void *data, async_cookie_t cookie)
  621. {
  622. struct device *dev = (struct device *)data;
  623. int error;
  624. error = device_resume(dev, pm_transition, true);
  625. if (error)
  626. pm_dev_err(dev, pm_transition, " async", error);
  627. put_device(dev);
  628. }
  629. static bool is_async(struct device *dev)
  630. {
  631. return dev->power.async_suspend && pm_async_enabled
  632. && !pm_trace_is_enabled();
  633. }
  634. /**
  635. * dpm_resume - Execute "resume" callbacks for non-sysdev devices.
  636. * @state: PM transition of the system being carried out.
  637. *
  638. * Execute the appropriate "resume" callback for all devices whose status
  639. * indicates that they are suspended.
  640. */
  641. void dpm_resume(pm_message_t state)
  642. {
  643. struct device *dev;
  644. ktime_t starttime = ktime_get();
  645. might_sleep();
  646. mutex_lock(&dpm_list_mtx);
  647. pm_transition = state;
  648. async_error = 0;
  649. list_for_each_entry(dev, &dpm_suspended_list, power.entry) {
  650. INIT_COMPLETION(dev->power.completion);
  651. if (is_async(dev)) {
  652. get_device(dev);
  653. async_schedule(async_resume, dev);
  654. }
  655. }
  656. while (!list_empty(&dpm_suspended_list)) {
  657. dev = to_device(dpm_suspended_list.next);
  658. get_device(dev);
  659. if (!is_async(dev)) {
  660. int error;
  661. mutex_unlock(&dpm_list_mtx);
  662. error = device_resume(dev, state, false);
  663. if (error) {
  664. suspend_stats.failed_resume++;
  665. dpm_save_failed_step(SUSPEND_RESUME);
  666. dpm_save_failed_dev(dev_name(dev));
  667. pm_dev_err(dev, state, "", error);
  668. }
  669. mutex_lock(&dpm_list_mtx);
  670. }
  671. if (!list_empty(&dev->power.entry))
  672. list_move_tail(&dev->power.entry, &dpm_prepared_list);
  673. put_device(dev);
  674. }
  675. mutex_unlock(&dpm_list_mtx);
  676. async_synchronize_full();
  677. dpm_show_time(starttime, state, NULL);
  678. }
  679. /**
  680. * device_complete - Complete a PM transition for given device.
  681. * @dev: Device to handle.
  682. * @state: PM transition of the system being carried out.
  683. */
  684. static void device_complete(struct device *dev, pm_message_t state)
  685. {
  686. void (*callback)(struct device *) = NULL;
  687. char *info = NULL;
  688. if (dev->power.syscore)
  689. return;
  690. device_lock(dev);
  691. if (dev->pm_domain) {
  692. info = "completing power domain ";
  693. callback = dev->pm_domain->ops.complete;
  694. } else if (dev->type && dev->type->pm) {
  695. info = "completing type ";
  696. callback = dev->type->pm->complete;
  697. } else if (dev->class && dev->class->pm) {
  698. info = "completing class ";
  699. callback = dev->class->pm->complete;
  700. } else if (dev->bus && dev->bus->pm) {
  701. info = "completing bus ";
  702. callback = dev->bus->pm->complete;
  703. }
  704. if (!callback && dev->driver && dev->driver->pm) {
  705. info = "completing driver ";
  706. callback = dev->driver->pm->complete;
  707. }
  708. if (callback) {
  709. pm_dev_dbg(dev, state, info);
  710. callback(dev);
  711. }
  712. device_unlock(dev);
  713. pm_runtime_put(dev);
  714. }
  715. /**
  716. * dpm_complete - Complete a PM transition for all non-sysdev devices.
  717. * @state: PM transition of the system being carried out.
  718. *
  719. * Execute the ->complete() callbacks for all devices whose PM status is not
  720. * DPM_ON (this allows new devices to be registered).
  721. */
  722. void dpm_complete(pm_message_t state)
  723. {
  724. struct list_head list;
  725. might_sleep();
  726. INIT_LIST_HEAD(&list);
  727. mutex_lock(&dpm_list_mtx);
  728. while (!list_empty(&dpm_prepared_list)) {
  729. struct device *dev = to_device(dpm_prepared_list.prev);
  730. get_device(dev);
  731. dev->power.is_prepared = false;
  732. list_move(&dev->power.entry, &list);
  733. mutex_unlock(&dpm_list_mtx);
  734. device_complete(dev, state);
  735. mutex_lock(&dpm_list_mtx);
  736. put_device(dev);
  737. }
  738. list_splice(&list, &dpm_list);
  739. mutex_unlock(&dpm_list_mtx);
  740. }
  741. /**
  742. * dpm_resume_end - Execute "resume" callbacks and complete system transition.
  743. * @state: PM transition of the system being carried out.
  744. *
  745. * Execute "resume" callbacks for all devices and complete the PM transition of
  746. * the system.
  747. */
  748. void dpm_resume_end(pm_message_t state)
  749. {
  750. dpm_resume(state);
  751. dpm_complete(state);
  752. }
  753. EXPORT_SYMBOL_GPL(dpm_resume_end);
  754. /*------------------------- Suspend routines -------------------------*/
  755. /**
  756. * resume_event - Return a "resume" message for given "suspend" sleep state.
  757. * @sleep_state: PM message representing a sleep state.
  758. *
  759. * Return a PM message representing the resume event corresponding to given
  760. * sleep state.
  761. */
  762. static pm_message_t resume_event(pm_message_t sleep_state)
  763. {
  764. switch (sleep_state.event) {
  765. case PM_EVENT_SUSPEND:
  766. return PMSG_RESUME;
  767. case PM_EVENT_FREEZE:
  768. case PM_EVENT_QUIESCE:
  769. return PMSG_RECOVER;
  770. case PM_EVENT_HIBERNATE:
  771. return PMSG_RESTORE;
  772. }
  773. return PMSG_ON;
  774. }
  775. /**
  776. * device_suspend_noirq - Execute a "late suspend" callback for given device.
  777. * @dev: Device to handle.
  778. * @state: PM transition of the system being carried out.
  779. *
  780. * The driver of @dev will not receive interrupts while this function is being
  781. * executed.
  782. */
  783. static int device_suspend_noirq(struct device *dev, pm_message_t state)
  784. {
  785. pm_callback_t callback = NULL;
  786. char *info = NULL;
  787. if (dev->power.syscore)
  788. return 0;
  789. if (dev->pm_domain) {
  790. info = "noirq power domain ";
  791. callback = pm_noirq_op(&dev->pm_domain->ops, state);
  792. } else if (dev->type && dev->type->pm) {
  793. info = "noirq type ";
  794. callback = pm_noirq_op(dev->type->pm, state);
  795. } else if (dev->class && dev->class->pm) {
  796. info = "noirq class ";
  797. callback = pm_noirq_op(dev->class->pm, state);
  798. } else if (dev->bus && dev->bus->pm) {
  799. info = "noirq bus ";
  800. callback = pm_noirq_op(dev->bus->pm, state);
  801. }
  802. if (!callback && dev->driver && dev->driver->pm) {
  803. info = "noirq driver ";
  804. callback = pm_noirq_op(dev->driver->pm, state);
  805. }
  806. return dpm_run_callback(callback, dev, state, info);
  807. }
  808. /**
  809. * dpm_suspend_noirq - Execute "noirq suspend" callbacks for all devices.
  810. * @state: PM transition of the system being carried out.
  811. *
  812. * Prevent device drivers from receiving interrupts and call the "noirq" suspend
  813. * handlers for all non-sysdev devices.
  814. */
  815. static int dpm_suspend_noirq(pm_message_t state)
  816. {
  817. ktime_t starttime = ktime_get();
  818. char suspend_abort[MAX_SUSPEND_ABORT_LEN];
  819. int error = 0;
  820. cpuidle_pause();
  821. suspend_device_irqs();
  822. mutex_lock(&dpm_list_mtx);
  823. while (!list_empty(&dpm_late_early_list)) {
  824. struct device *dev = to_device(dpm_late_early_list.prev);
  825. get_device(dev);
  826. mutex_unlock(&dpm_list_mtx);
  827. error = device_suspend_noirq(dev, state);
  828. mutex_lock(&dpm_list_mtx);
  829. if (error) {
  830. pm_dev_err(dev, state, " noirq", error);
  831. suspend_stats.failed_suspend_noirq++;
  832. dpm_save_failed_step(SUSPEND_SUSPEND_NOIRQ);
  833. dpm_save_failed_dev(dev_name(dev));
  834. put_device(dev);
  835. break;
  836. }
  837. if (!list_empty(&dev->power.entry))
  838. list_move(&dev->power.entry, &dpm_noirq_list);
  839. put_device(dev);
  840. if (pm_wakeup_pending()) {
  841. pm_get_active_wakeup_sources(suspend_abort,
  842. MAX_SUSPEND_ABORT_LEN);
  843. log_suspend_abort_reason(suspend_abort);
  844. error = -EBUSY;
  845. break;
  846. }
  847. }
  848. mutex_unlock(&dpm_list_mtx);
  849. if (error)
  850. dpm_resume_noirq(resume_event(state));
  851. else
  852. dpm_show_time(starttime, state, "noirq");
  853. return error;
  854. }
  855. /**
  856. * device_suspend_late - Execute a "late suspend" callback for given device.
  857. * @dev: Device to handle.
  858. * @state: PM transition of the system being carried out.
  859. *
  860. * Runtime PM is disabled for @dev while this function is being executed.
  861. */
  862. static int device_suspend_late(struct device *dev, pm_message_t state)
  863. {
  864. pm_callback_t callback = NULL;
  865. char *info = NULL;
  866. __pm_runtime_disable(dev, false);
  867. if (dev->power.syscore)
  868. return 0;
  869. if (dev->pm_domain) {
  870. info = "late power domain ";
  871. callback = pm_late_early_op(&dev->pm_domain->ops, state);
  872. } else if (dev->type && dev->type->pm) {
  873. info = "late type ";
  874. callback = pm_late_early_op(dev->type->pm, state);
  875. } else if (dev->class && dev->class->pm) {
  876. info = "late class ";
  877. callback = pm_late_early_op(dev->class->pm, state);
  878. } else if (dev->bus && dev->bus->pm) {
  879. info = "late bus ";
  880. callback = pm_late_early_op(dev->bus->pm, state);
  881. }
  882. if (!callback && dev->driver && dev->driver->pm) {
  883. info = "late driver ";
  884. callback = pm_late_early_op(dev->driver->pm, state);
  885. }
  886. return dpm_run_callback(callback, dev, state, info);
  887. }
  888. /**
  889. * dpm_suspend_late - Execute "late suspend" callbacks for all devices.
  890. * @state: PM transition of the system being carried out.
  891. */
  892. static int dpm_suspend_late(pm_message_t state)
  893. {
  894. ktime_t starttime = ktime_get();
  895. char suspend_abort[MAX_SUSPEND_ABORT_LEN];
  896. int error = 0;
  897. mutex_lock(&dpm_list_mtx);
  898. while (!list_empty(&dpm_suspended_list)) {
  899. struct device *dev = to_device(dpm_suspended_list.prev);
  900. get_device(dev);
  901. mutex_unlock(&dpm_list_mtx);
  902. error = device_suspend_late(dev, state);
  903. mutex_lock(&dpm_list_mtx);
  904. if (error) {
  905. pm_dev_err(dev, state, " late", error);
  906. suspend_stats.failed_suspend_late++;
  907. dpm_save_failed_step(SUSPEND_SUSPEND_LATE);
  908. dpm_save_failed_dev(dev_name(dev));
  909. put_device(dev);
  910. break;
  911. }
  912. if (!list_empty(&dev->power.entry))
  913. list_move(&dev->power.entry, &dpm_late_early_list);
  914. put_device(dev);
  915. if (pm_wakeup_pending()) {
  916. pm_get_active_wakeup_sources(suspend_abort,
  917. MAX_SUSPEND_ABORT_LEN);
  918. log_suspend_abort_reason(suspend_abort);
  919. error = -EBUSY;
  920. break;
  921. }
  922. }
  923. mutex_unlock(&dpm_list_mtx);
  924. if (error)
  925. dpm_resume_early(resume_event(state));
  926. else
  927. dpm_show_time(starttime, state, "late");
  928. return error;
  929. }
  930. /**
  931. * dpm_suspend_end - Execute "late" and "noirq" device suspend callbacks.
  932. * @state: PM transition of the system being carried out.
  933. */
  934. int dpm_suspend_end(pm_message_t state)
  935. {
  936. int error = dpm_suspend_late(state);
  937. if (error)
  938. return error;
  939. error = dpm_suspend_noirq(state);
  940. if (error) {
  941. dpm_resume_early(resume_event(state));
  942. return error;
  943. }
  944. return 0;
  945. }
  946. EXPORT_SYMBOL_GPL(dpm_suspend_end);
  947. /**
  948. * legacy_suspend - Execute a legacy (bus or class) suspend callback for device.
  949. * @dev: Device to suspend.
  950. * @state: PM transition of the system being carried out.
  951. * @cb: Suspend callback to execute.
  952. */
  953. static int legacy_suspend(struct device *dev, pm_message_t state,
  954. int (*cb)(struct device *dev, pm_message_t state),
  955. char *info)
  956. {
  957. int error;
  958. ktime_t calltime;
  959. calltime = initcall_debug_start(dev);
  960. error = cb(dev, state);
  961. suspend_report_result(cb, error);
  962. initcall_debug_report(dev, calltime, error, state, info);
  963. return error;
  964. }
  965. /**
  966. * device_suspend - Execute "suspend" callbacks for given device.
  967. * @dev: Device to handle.
  968. * @state: PM transition of the system being carried out.
  969. * @async: If true, the device is being suspended asynchronously.
  970. */
  971. static int __device_suspend(struct device *dev, pm_message_t state, bool async)
  972. {
  973. pm_callback_t callback = NULL;
  974. char *info = NULL;
  975. int error = 0;
  976. struct dpm_watchdog wd;
  977. char suspend_abort[MAX_SUSPEND_ABORT_LEN];
  978. dpm_wait_for_children(dev, async);
  979. if (async_error)
  980. goto Complete;
  981. /*
  982. * Wait for possible runtime PM transitions of the device in progress
  983. * to complete and if there's a runtime resume request pending for it,
  984. * resume it before proceeding with invoking the system-wide suspend
  985. * callbacks for it.
  986. *
  987. * If the system-wide suspend callbacks below change the configuration
  988. * of the device, they must disable runtime PM for it or otherwise
  989. * ensure that its runtime-resume callbacks will not be confused by that
  990. * change in case they are invoked going forward.
  991. */
  992. pm_runtime_barrier(dev);
  993. if (pm_wakeup_pending()) {
  994. pm_get_active_wakeup_sources(suspend_abort,
  995. MAX_SUSPEND_ABORT_LEN);
  996. log_suspend_abort_reason(suspend_abort);
  997. async_error = -EBUSY;
  998. goto Complete;
  999. }
  1000. dpm_wd_set(&wd, dev);
  1001. if (dev->power.syscore)
  1002. goto Complete;
  1003. device_lock(dev);
  1004. if (dev->pm_domain) {
  1005. info = "power domain ";
  1006. callback = pm_op(&dev->pm_domain->ops, state);
  1007. goto Run;
  1008. }
  1009. if (dev->type && dev->type->pm) {
  1010. info = "type ";
  1011. callback = pm_op(dev->type->pm, state);
  1012. goto Run;
  1013. }
  1014. if (dev->class) {
  1015. if (dev->class->pm) {
  1016. info = "class ";
  1017. callback = pm_op(dev->class->pm, state);
  1018. goto Run;
  1019. } else if (dev->class->suspend) {
  1020. pm_dev_dbg(dev, state, "legacy class ");
  1021. error = legacy_suspend(dev, state, dev->class->suspend,
  1022. "legacy class ");
  1023. goto End;
  1024. }
  1025. }
  1026. if (dev->bus) {
  1027. if (dev->bus->pm) {
  1028. info = "bus ";
  1029. callback = pm_op(dev->bus->pm, state);
  1030. } else if (dev->bus->suspend) {
  1031. pm_dev_dbg(dev, state, "legacy bus ");
  1032. error = legacy_suspend(dev, state, dev->bus->suspend,
  1033. "legacy bus ");
  1034. goto End;
  1035. }
  1036. }
  1037. Run:
  1038. if (!callback && dev->driver && dev->driver->pm) {
  1039. info = "driver ";
  1040. callback = pm_op(dev->driver->pm, state);
  1041. }
  1042. error = dpm_run_callback(callback, dev, state, info);
  1043. End:
  1044. if (!error) {
  1045. dev->power.is_suspended = true;
  1046. if (dev->power.wakeup_path
  1047. && dev->parent && !dev->parent->power.ignore_children)
  1048. dev->parent->power.wakeup_path = true;
  1049. }
  1050. device_unlock(dev);
  1051. dpm_wd_clear(&wd);
  1052. Complete:
  1053. complete_all(&dev->power.completion);
  1054. if (error)
  1055. async_error = error;
  1056. return error;
  1057. }
  1058. static void async_suspend(void *data, async_cookie_t cookie)
  1059. {
  1060. struct device *dev = (struct device *)data;
  1061. int error;
  1062. error = __device_suspend(dev, pm_transition, true);
  1063. if (error) {
  1064. dpm_save_failed_dev(dev_name(dev));
  1065. pm_dev_err(dev, pm_transition, " async", error);
  1066. }
  1067. put_device(dev);
  1068. }
  1069. static int device_suspend(struct device *dev)
  1070. {
  1071. INIT_COMPLETION(dev->power.completion);
  1072. if (pm_async_enabled && dev->power.async_suspend) {
  1073. get_device(dev);
  1074. async_schedule(async_suspend, dev);
  1075. return 0;
  1076. }
  1077. return __device_suspend(dev, pm_transition, false);
  1078. }
  1079. /**
  1080. * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
  1081. * @state: PM transition of the system being carried out.
  1082. */
  1083. int dpm_suspend(pm_message_t state)
  1084. {
  1085. ktime_t starttime = ktime_get();
  1086. int error = 0;
  1087. might_sleep();
  1088. mutex_lock(&dpm_list_mtx);
  1089. pm_transition = state;
  1090. async_error = 0;
  1091. while (!list_empty(&dpm_prepared_list)) {
  1092. struct device *dev = to_device(dpm_prepared_list.prev);
  1093. get_device(dev);
  1094. mutex_unlock(&dpm_list_mtx);
  1095. error = device_suspend(dev);
  1096. mutex_lock(&dpm_list_mtx);
  1097. if (error) {
  1098. pm_dev_err(dev, state, "", error);
  1099. dpm_save_failed_dev(dev_name(dev));
  1100. put_device(dev);
  1101. break;
  1102. }
  1103. if (!list_empty(&dev->power.entry))
  1104. list_move(&dev->power.entry, &dpm_suspended_list);
  1105. put_device(dev);
  1106. if (async_error)
  1107. break;
  1108. }
  1109. mutex_unlock(&dpm_list_mtx);
  1110. async_synchronize_full();
  1111. if (!error)
  1112. error = async_error;
  1113. if (error) {
  1114. suspend_stats.failed_suspend++;
  1115. dpm_save_failed_step(SUSPEND_SUSPEND);
  1116. } else
  1117. dpm_show_time(starttime, state, NULL);
  1118. return error;
  1119. }
  1120. /**
  1121. * device_prepare - Prepare a device for system power transition.
  1122. * @dev: Device to handle.
  1123. * @state: PM transition of the system being carried out.
  1124. *
  1125. * Execute the ->prepare() callback(s) for given device. No new children of the
  1126. * device may be registered after this function has returned.
  1127. */
  1128. static int device_prepare(struct device *dev, pm_message_t state)
  1129. {
  1130. int (*callback)(struct device *) = NULL;
  1131. char *info = NULL;
  1132. int error = 0;
  1133. /*
  1134. * If a device's parent goes into runtime suspend at the wrong time,
  1135. * it won't be possible to resume the device. To prevent this we
  1136. * block runtime suspend here, during the prepare phase, and allow
  1137. * it again during the complete phase.
  1138. */
  1139. pm_runtime_get_noresume(dev);
  1140. if (dev->power.syscore)
  1141. return 0;
  1142. device_lock(dev);
  1143. dev->power.wakeup_path = device_may_wakeup(dev);
  1144. if (dev->pm_domain) {
  1145. info = "preparing power domain ";
  1146. callback = dev->pm_domain->ops.prepare;
  1147. } else if (dev->type && dev->type->pm) {
  1148. info = "preparing type ";
  1149. callback = dev->type->pm->prepare;
  1150. } else if (dev->class && dev->class->pm) {
  1151. info = "preparing class ";
  1152. callback = dev->class->pm->prepare;
  1153. } else if (dev->bus && dev->bus->pm) {
  1154. info = "preparing bus ";
  1155. callback = dev->bus->pm->prepare;
  1156. }
  1157. if (!callback && dev->driver && dev->driver->pm) {
  1158. info = "preparing driver ";
  1159. callback = dev->driver->pm->prepare;
  1160. }
  1161. if (callback) {
  1162. error = callback(dev);
  1163. suspend_report_result(callback, error);
  1164. }
  1165. device_unlock(dev);
  1166. if (error)
  1167. pm_runtime_put(dev);
  1168. return error;
  1169. }
  1170. /**
  1171. * dpm_prepare - Prepare all non-sysdev devices for a system PM transition.
  1172. * @state: PM transition of the system being carried out.
  1173. *
  1174. * Execute the ->prepare() callback(s) for all devices.
  1175. */
  1176. int dpm_prepare(pm_message_t state)
  1177. {
  1178. int error = 0;
  1179. might_sleep();
  1180. mutex_lock(&dpm_list_mtx);
  1181. while (!list_empty(&dpm_list)) {
  1182. struct device *dev = to_device(dpm_list.next);
  1183. get_device(dev);
  1184. mutex_unlock(&dpm_list_mtx);
  1185. error = device_prepare(dev, state);
  1186. mutex_lock(&dpm_list_mtx);
  1187. if (error) {
  1188. if (error == -EAGAIN) {
  1189. put_device(dev);
  1190. error = 0;
  1191. continue;
  1192. }
  1193. printk(KERN_INFO "PM: Device %s not prepared "
  1194. "for power transition: code %d\n",
  1195. dev_name(dev), error);
  1196. put_device(dev);
  1197. break;
  1198. }
  1199. dev->power.is_prepared = true;
  1200. if (!list_empty(&dev->power.entry))
  1201. list_move_tail(&dev->power.entry, &dpm_prepared_list);
  1202. put_device(dev);
  1203. }
  1204. mutex_unlock(&dpm_list_mtx);
  1205. return error;
  1206. }
  1207. /**
  1208. * dpm_suspend_start - Prepare devices for PM transition and suspend them.
  1209. * @state: PM transition of the system being carried out.
  1210. *
  1211. * Prepare all non-sysdev devices for system PM transition and execute "suspend"
  1212. * callbacks for them.
  1213. */
  1214. int dpm_suspend_start(pm_message_t state)
  1215. {
  1216. int error;
  1217. error = dpm_prepare(state);
  1218. if (error) {
  1219. suspend_stats.failed_prepare++;
  1220. dpm_save_failed_step(SUSPEND_PREPARE);
  1221. } else
  1222. error = dpm_suspend(state);
  1223. return error;
  1224. }
  1225. EXPORT_SYMBOL_GPL(dpm_suspend_start);
  1226. void __suspend_report_result(const char *function, void *fn, int ret)
  1227. {
  1228. if (ret)
  1229. printk(KERN_ERR "%s(): %pF returns %d\n", function, fn, ret);
  1230. }
  1231. EXPORT_SYMBOL_GPL(__suspend_report_result);
  1232. /**
  1233. * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
  1234. * @dev: Device to wait for.
  1235. * @subordinate: Device that needs to wait for @dev.
  1236. */
  1237. int device_pm_wait_for_dev(struct device *subordinate, struct device *dev)
  1238. {
  1239. dpm_wait(dev, subordinate->power.async_suspend);
  1240. return async_error;
  1241. }
  1242. EXPORT_SYMBOL_GPL(device_pm_wait_for_dev);
  1243. /**
  1244. * dpm_for_each_dev - device iterator.
  1245. * @data: data for the callback.
  1246. * @fn: function to be called for each device.
  1247. *
  1248. * Iterate over devices in dpm_list, and call @fn for each device,
  1249. * passing it @data.
  1250. */
  1251. void dpm_for_each_dev(void *data, void (*fn)(struct device *, void *))
  1252. {
  1253. struct device *dev;
  1254. if (!fn)
  1255. return;
  1256. device_pm_lock();
  1257. list_for_each_entry(dev, &dpm_list, power.entry)
  1258. fn(dev, data);
  1259. device_pm_unlock();
  1260. }
  1261. EXPORT_SYMBOL_GPL(dpm_for_each_dev);