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