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