20 #include <linux/device.h>
22 #include <linux/export.h>
28 #include <linux/sched.h>
57 static int async_error;
65 dev->
power.is_prepared =
false;
66 dev->
power.is_suspended =
false;
67 init_completion(&dev->
power.completion);
70 INIT_LIST_HEAD(&dev->
power.entry);
95 pr_debug(
"PM: Adding info for %s:%s\n",
96 dev->
bus ? dev->
bus->name :
"No Bus", dev_name(dev));
99 dev_warn(dev,
"parent %s should not be sleeping\n",
112 pr_debug(
"PM: Removing info for %s:%s\n",
113 dev->
bus ? dev->
bus->name :
"No Bus", dev_name(dev));
117 list_del_init(&dev->
power.entry);
130 pr_debug(
"PM: Moving %s:%s before %s:%s\n",
131 deva->
bus ? deva->
bus->name :
"No Bus", dev_name(deva),
132 devb->
bus ? devb->
bus->name :
"No Bus", dev_name(devb));
134 list_move_tail(&deva->
power.entry, &devb->
power.entry);
144 pr_debug(
"PM: Moving %s:%s after %s:%s\n",
145 deva->
bus ? deva->
bus->name :
"No Bus", dev_name(deva),
146 devb->
bus ? devb->
bus->name :
"No Bus", dev_name(devb));
148 list_move(&deva->
power.entry, &devb->
power.entry);
157 pr_debug(
"PM: Moving %s:%s to end of list\n",
158 dev->
bus ? dev->
bus->name :
"No Bus", dev_name(dev));
159 list_move_tail(&dev->
power.entry, &dpm_list);
164 ktime_t calltime = ktime_set(0, 0);
167 pr_info(
"calling %s+ @ %i, parent: %s\n",
168 dev_name(dev), task_pid_nr(
current),
176 static void initcall_debug_report(
struct device *dev,
ktime_t calltime,
183 delta = ktime_sub(rettime, calltime);
184 pr_info(
"call %s+ returned %d after %Ld usecs\n", dev_name(dev),
185 error, (
unsigned long long)ktime_to_ns(delta) >> 10);
194 static void dpm_wait(
struct device *dev,
bool async)
199 if (async || (pm_async_enabled && dev->
power.async_suspend))
203 static int dpm_wait_fn(
struct device *dev,
void *async_ptr)
205 dpm_wait(dev, *((
bool *)async_ptr));
209 static void dpm_wait_for_children(
struct device *dev,
bool async)
221 switch (state.
event) {
222 #ifdef CONFIG_SUSPEND
228 #ifdef CONFIG_HIBERNATE_CALLBACKS
256 switch (state.
event) {
257 #ifdef CONFIG_SUSPEND
263 #ifdef CONFIG_HIBERNATE_CALLBACKS
290 switch (state.
event) {
291 #ifdef CONFIG_SUSPEND
297 #ifdef CONFIG_HIBERNATE_CALLBACKS
314 static char *pm_verb(
int event)
334 return "(unknown PM event)";
342 ", may wakeup" :
"");
349 dev_name(dev), pm_verb(state.
event), info, error);
359 usecs64 = ktime_to_ns(ktime_sub(calltime, starttime));
364 pr_info(
"PM: %s%s%s of devices complete after %ld.%03ld msecs\n",
365 info ?:
"", info ?
" " :
"", pm_verb(state.
event),
378 calltime = initcall_debug_start(dev);
380 pm_dev_dbg(dev, state, info);
384 initcall_debug_report(dev, calltime, error);
408 if (dev->
power.syscore)
412 info =
"noirq power domain ";
413 callback = pm_noirq_op(&dev->
pm_domain->ops, state);
414 }
else if (dev->
type && dev->
type->pm) {
415 info =
"noirq type ";
416 callback = pm_noirq_op(dev->
type->pm, state);
418 info =
"noirq class ";
419 callback = pm_noirq_op(dev->
class->pm, state);
420 }
else if (dev->
bus && dev->
bus->pm) {
422 callback = pm_noirq_op(dev->
bus->pm, state);
426 info =
"noirq driver ";
427 callback = pm_noirq_op(dev->
driver->pm, state);
430 error = dpm_run_callback(callback, dev, state, info);
449 while (!list_empty(&dpm_noirq_list)) {
454 list_move_tail(&dev->
power.entry, &dpm_late_early_list);
457 error = device_resume_noirq(dev, state);
461 dpm_save_failed_dev(dev_name(dev));
462 pm_dev_err(dev, state,
" noirq", error);
469 dpm_show_time(starttime, state,
"noirq");
490 if (dev->
power.syscore)
494 info =
"early power domain ";
495 callback = pm_late_early_op(&dev->
pm_domain->ops, state);
496 }
else if (dev->
type && dev->
type->pm) {
497 info =
"early type ";
498 callback = pm_late_early_op(dev->
type->pm, state);
500 info =
"early class ";
501 callback = pm_late_early_op(dev->
class->pm, state);
502 }
else if (dev->
bus && dev->
bus->pm) {
504 callback = pm_late_early_op(dev->
bus->pm, state);
508 info =
"early driver ";
509 callback = pm_late_early_op(dev->
driver->pm, state);
512 error = dpm_run_callback(callback, dev, state, info);
528 while (!list_empty(&dpm_late_early_list)) {
533 list_move_tail(&dev->
power.entry, &dpm_suspended_list);
536 error = device_resume_early(dev, state);
540 dpm_save_failed_dev(dev_name(dev));
541 pm_dev_err(dev, state,
" early", error);
548 dpm_show_time(starttime, state,
"early");
557 dpm_resume_noirq(state);
558 dpm_resume_early(state);
577 if (dev->
power.syscore)
580 dpm_wait(dev->
parent, async);
587 dev->
power.is_prepared =
false;
589 if (!dev->
power.is_suspended)
595 info =
"power domain ";
596 callback = pm_op(&dev->
pm_domain->ops, state);
602 callback = pm_op(dev->
type->pm, state);
607 if (dev->
class->pm) {
609 callback = pm_op(dev->
class->pm, state);
611 }
else if (dev->
class->resume) {
612 info =
"legacy class ";
613 callback = dev->
class->resume;
621 callback = pm_op(dev->
bus->pm, state);
622 }
else if (dev->
bus->resume) {
623 info =
"legacy bus ";
624 callback = dev->
bus->resume;
632 callback = pm_op(dev->
driver->pm, state);
636 error = dpm_run_callback(callback, dev, state, info);
637 dev->
power.is_suspended =
false;
655 error = device_resume(dev, pm_transition,
true);
657 pm_dev_err(dev, pm_transition,
" async", error);
661 static bool is_async(
struct device *dev)
663 return dev->
power.async_suspend && pm_async_enabled
664 && !pm_trace_is_enabled();
682 pm_transition =
state;
693 while (!list_empty(&dpm_suspended_list)) {
694 dev =
to_device(dpm_suspended_list.next);
696 if (!is_async(dev)) {
701 error = device_resume(dev, state,
false);
705 dpm_save_failed_dev(dev_name(dev));
706 pm_dev_err(dev, state,
"", error);
711 if (!list_empty(&dev->
power.entry))
712 list_move_tail(&dev->
power.entry, &dpm_prepared_list);
717 dpm_show_time(starttime, state,
NULL);
730 if (dev->
power.syscore)
736 info =
"completing power domain ";
738 }
else if (dev->
type && dev->
type->pm) {
739 info =
"completing type ";
740 callback = dev->
type->pm->complete;
742 info =
"completing class ";
743 callback = dev->
class->pm->complete;
744 }
else if (dev->
bus && dev->
bus->pm) {
745 info =
"completing bus ";
746 callback = dev->
bus->pm->complete;
750 info =
"completing driver ";
751 callback = dev->
driver->pm->complete;
755 pm_dev_dbg(dev, state, info);
761 pm_runtime_put_sync(dev);
777 INIT_LIST_HEAD(&list);
779 while (!list_empty(&dpm_prepared_list)) {
783 dev->
power.is_prepared =
false;
784 list_move(&dev->
power.entry, &list);
787 device_complete(dev, state);
792 list_splice(&list, &dpm_list);
822 switch (sleep_state.
event) {
847 if (dev->
power.syscore)
851 info =
"noirq power domain ";
852 callback = pm_noirq_op(&dev->
pm_domain->ops, state);
853 }
else if (dev->
type && dev->
type->pm) {
854 info =
"noirq type ";
855 callback = pm_noirq_op(dev->
type->pm, state);
857 info =
"noirq class ";
858 callback = pm_noirq_op(dev->
class->pm, state);
859 }
else if (dev->
bus && dev->
bus->pm) {
861 callback = pm_noirq_op(dev->
bus->pm, state);
865 info =
"noirq driver ";
866 callback = pm_noirq_op(dev->
driver->pm, state);
869 return dpm_run_callback(callback, dev, state, info);
887 while (!list_empty(&dpm_late_early_list)) {
893 error = device_suspend_noirq(dev, state);
897 pm_dev_err(dev, state,
" noirq", error);
900 dpm_save_failed_dev(dev_name(dev));
904 if (!list_empty(&dev->
power.entry))
905 list_move(&dev->
power.entry, &dpm_noirq_list);
915 dpm_resume_noirq(resume_event(state));
917 dpm_show_time(starttime, state,
"noirq");
933 if (dev->
power.syscore)
937 info =
"late power domain ";
938 callback = pm_late_early_op(&dev->
pm_domain->ops, state);
939 }
else if (dev->
type && dev->
type->pm) {
941 callback = pm_late_early_op(dev->
type->pm, state);
943 info =
"late class ";
944 callback = pm_late_early_op(dev->
class->pm, state);
945 }
else if (dev->
bus && dev->
bus->pm) {
947 callback = pm_late_early_op(dev->
bus->pm, state);
951 info =
"late driver ";
952 callback = pm_late_early_op(dev->
driver->pm, state);
955 return dpm_run_callback(callback, dev, state, info);
968 while (!list_empty(&dpm_suspended_list)) {
974 error = device_suspend_late(dev, state);
978 pm_dev_err(dev, state,
" late", error);
981 dpm_save_failed_dev(dev_name(dev));
985 if (!list_empty(&dev->
power.entry))
986 list_move(&dev->
power.entry, &dpm_late_early_list);
996 dpm_resume_early(resume_event(state));
998 dpm_show_time(starttime, state,
"late");
1009 int error = dpm_suspend_late(state);
1013 error = dpm_suspend_noirq(state);
1015 dpm_resume_early(resume_event(state));
1035 calltime = initcall_debug_start(dev);
1037 error = cb(dev, state);
1040 initcall_debug_report(dev, calltime, error);
1057 dpm_wait_for_children(dev, async);
1072 async_error = -
EBUSY;
1076 if (dev->
power.syscore)
1082 info =
"power domain ";
1083 callback = pm_op(&dev->
pm_domain->ops, state);
1089 callback = pm_op(dev->
type->pm, state);
1094 if (dev->
class->pm) {
1096 callback = pm_op(dev->
class->pm, state);
1098 }
else if (dev->
class->suspend) {
1099 pm_dev_dbg(dev, state,
"legacy class ");
1100 error = legacy_suspend(dev, state, dev->
class->suspend);
1108 callback = pm_op(dev->
bus->pm, state);
1109 }
else if (dev->
bus->suspend) {
1110 pm_dev_dbg(dev, state,
"legacy bus ");
1111 error = legacy_suspend(dev, state, dev->
bus->suspend);
1119 callback = pm_op(dev->
driver->pm, state);
1122 error = dpm_run_callback(callback, dev, state, info);
1126 dev->
power.is_suspended =
true;
1127 if (dev->
power.wakeup_path
1129 dev->
parent->power.wakeup_path =
true;
1138 async_error =
error;
1139 else if (dev->
power.is_suspended)
1150 error = __device_suspend(dev, pm_transition,
true);
1152 dpm_save_failed_dev(dev_name(dev));
1153 pm_dev_err(dev, pm_transition,
" async", error);
1159 static int device_suspend(
struct device *dev)
1163 if (pm_async_enabled && dev->
power.async_suspend) {
1169 return __device_suspend(dev, pm_transition,
false);
1184 pm_transition =
state;
1186 while (!list_empty(&dpm_prepared_list)) {
1192 error = device_suspend(dev);
1196 pm_dev_err(dev, state,
"", error);
1197 dpm_save_failed_dev(dev_name(dev));
1201 if (!list_empty(&dev->
power.entry))
1202 list_move(&dev->
power.entry, &dpm_suspended_list);
1210 error = async_error;
1215 dpm_show_time(starttime, state,
NULL);
1233 if (dev->
power.syscore)
1242 pm_runtime_get_noresume(dev);
1246 dev->
power.wakeup_path = device_may_wakeup(dev);
1249 info =
"preparing power domain ";
1251 }
else if (dev->
type && dev->
type->pm) {
1252 info =
"preparing type ";
1253 callback = dev->
type->pm->prepare;
1255 info =
"preparing class ";
1256 callback = dev->
class->pm->prepare;
1257 }
else if (dev->
bus && dev->
bus->pm) {
1258 info =
"preparing bus ";
1259 callback = dev->
bus->pm->prepare;
1263 info =
"preparing driver ";
1264 callback = dev->
driver->pm->prepare;
1290 while (!list_empty(&dpm_list)) {
1296 error = device_prepare(dev, state);
1306 "for power transition: code %d\n",
1307 dev_name(dev), error);
1311 dev->
power.is_prepared =
true;
1312 if (!list_empty(&dev->
power.entry))
1313 list_move_tail(&dev->
power.entry, &dpm_prepared_list);
1355 dpm_wait(dev, subordinate->
power.async_suspend);