async: make sure independent async domains can't accidentally entangle
[sfrench/cifs-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/resume-trace.h>
25 #include <linux/rwsem.h>
26 #include <linux/interrupt.h>
27
28 #include "../base.h"
29 #include "power.h"
30
31 /*
32  * The entries in the dpm_list list are in a depth first order, simply
33  * because children are guaranteed to be discovered after parents, and
34  * are inserted at the back of the list on discovery.
35  *
36  * Since device_pm_add() may be called with a device semaphore held,
37  * we must never try to acquire a device semaphore while holding
38  * dpm_list_mutex.
39  */
40
41 LIST_HEAD(dpm_list);
42
43 static DEFINE_MUTEX(dpm_list_mtx);
44
45 /*
46  * Set once the preparation of devices for a PM transition has started, reset
47  * before starting to resume devices.  Protected by dpm_list_mtx.
48  */
49 static bool transition_started;
50
51 /**
52  *      device_pm_lock - lock the list of active devices used by the PM core
53  */
54 void device_pm_lock(void)
55 {
56         mutex_lock(&dpm_list_mtx);
57 }
58
59 /**
60  *      device_pm_unlock - unlock the list of active devices used by the PM core
61  */
62 void device_pm_unlock(void)
63 {
64         mutex_unlock(&dpm_list_mtx);
65 }
66
67 /**
68  *      device_pm_add - add a device to the list of active devices
69  *      @dev:   Device to be added to the list
70  */
71 void device_pm_add(struct device *dev)
72 {
73         pr_debug("PM: Adding info for %s:%s\n",
74                  dev->bus ? dev->bus->name : "No Bus",
75                  kobject_name(&dev->kobj));
76         mutex_lock(&dpm_list_mtx);
77         if (dev->parent) {
78                 if (dev->parent->power.status >= DPM_SUSPENDING)
79                         dev_warn(dev, "parent %s should not be sleeping\n",
80                                  dev_name(dev->parent));
81         } else if (transition_started) {
82                 /*
83                  * We refuse to register parentless devices while a PM
84                  * transition is in progress in order to avoid leaving them
85                  * unhandled down the road
86                  */
87                 dev_WARN(dev, "Parentless device registered during a PM transaction\n");
88         }
89
90         list_add_tail(&dev->power.entry, &dpm_list);
91         mutex_unlock(&dpm_list_mtx);
92 }
93
94 /**
95  *      device_pm_remove - remove a device from the list of active devices
96  *      @dev:   Device to be removed from the list
97  *
98  *      This function also removes the device's PM-related sysfs attributes.
99  */
100 void device_pm_remove(struct device *dev)
101 {
102         pr_debug("PM: Removing info for %s:%s\n",
103                  dev->bus ? dev->bus->name : "No Bus",
104                  kobject_name(&dev->kobj));
105         mutex_lock(&dpm_list_mtx);
106         list_del_init(&dev->power.entry);
107         mutex_unlock(&dpm_list_mtx);
108 }
109
110 /**
111  *      device_pm_move_before - move device in dpm_list
112  *      @deva:  Device to move in dpm_list
113  *      @devb:  Device @deva should come before
114  */
115 void device_pm_move_before(struct device *deva, struct device *devb)
116 {
117         pr_debug("PM: Moving %s:%s before %s:%s\n",
118                  deva->bus ? deva->bus->name : "No Bus",
119                  kobject_name(&deva->kobj),
120                  devb->bus ? devb->bus->name : "No Bus",
121                  kobject_name(&devb->kobj));
122         /* Delete deva from dpm_list and reinsert before devb. */
123         list_move_tail(&deva->power.entry, &devb->power.entry);
124 }
125
126 /**
127  *      device_pm_move_after - move device in dpm_list
128  *      @deva:  Device to move in dpm_list
129  *      @devb:  Device @deva should come after
130  */
131 void device_pm_move_after(struct device *deva, struct device *devb)
132 {
133         pr_debug("PM: Moving %s:%s after %s:%s\n",
134                  deva->bus ? deva->bus->name : "No Bus",
135                  kobject_name(&deva->kobj),
136                  devb->bus ? devb->bus->name : "No Bus",
137                  kobject_name(&devb->kobj));
138         /* Delete deva from dpm_list and reinsert after devb. */
139         list_move(&deva->power.entry, &devb->power.entry);
140 }
141
142 /**
143  *      device_pm_move_last - move device to end of dpm_list
144  *      @dev:   Device to move in dpm_list
145  */
146 void device_pm_move_last(struct device *dev)
147 {
148         pr_debug("PM: Moving %s:%s to end of list\n",
149                  dev->bus ? dev->bus->name : "No Bus",
150                  kobject_name(&dev->kobj));
151         list_move_tail(&dev->power.entry, &dpm_list);
152 }
153
154 /**
155  *      pm_op - execute the PM operation appropiate for given PM event
156  *      @dev:   Device.
157  *      @ops:   PM operations to choose from.
158  *      @state: PM transition of the system being carried out.
159  */
160 static int pm_op(struct device *dev, struct dev_pm_ops *ops,
161                         pm_message_t state)
162 {
163         int error = 0;
164
165         switch (state.event) {
166 #ifdef CONFIG_SUSPEND
167         case PM_EVENT_SUSPEND:
168                 if (ops->suspend) {
169                         error = ops->suspend(dev);
170                         suspend_report_result(ops->suspend, error);
171                 }
172                 break;
173         case PM_EVENT_RESUME:
174                 if (ops->resume) {
175                         error = ops->resume(dev);
176                         suspend_report_result(ops->resume, error);
177                 }
178                 break;
179 #endif /* CONFIG_SUSPEND */
180 #ifdef CONFIG_HIBERNATION
181         case PM_EVENT_FREEZE:
182         case PM_EVENT_QUIESCE:
183                 if (ops->freeze) {
184                         error = ops->freeze(dev);
185                         suspend_report_result(ops->freeze, error);
186                 }
187                 break;
188         case PM_EVENT_HIBERNATE:
189                 if (ops->poweroff) {
190                         error = ops->poweroff(dev);
191                         suspend_report_result(ops->poweroff, error);
192                 }
193                 break;
194         case PM_EVENT_THAW:
195         case PM_EVENT_RECOVER:
196                 if (ops->thaw) {
197                         error = ops->thaw(dev);
198                         suspend_report_result(ops->thaw, error);
199                 }
200                 break;
201         case PM_EVENT_RESTORE:
202                 if (ops->restore) {
203                         error = ops->restore(dev);
204                         suspend_report_result(ops->restore, error);
205                 }
206                 break;
207 #endif /* CONFIG_HIBERNATION */
208         default:
209                 error = -EINVAL;
210         }
211         return error;
212 }
213
214 /**
215  *      pm_noirq_op - execute the PM operation appropiate for given PM event
216  *      @dev:   Device.
217  *      @ops:   PM operations to choose from.
218  *      @state: PM transition of the system being carried out.
219  *
220  *      The operation is executed with interrupts disabled by the only remaining
221  *      functional CPU in the system.
222  */
223 static int pm_noirq_op(struct device *dev, struct dev_pm_ops *ops,
224                         pm_message_t state)
225 {
226         int error = 0;
227
228         switch (state.event) {
229 #ifdef CONFIG_SUSPEND
230         case PM_EVENT_SUSPEND:
231                 if (ops->suspend_noirq) {
232                         error = ops->suspend_noirq(dev);
233                         suspend_report_result(ops->suspend_noirq, error);
234                 }
235                 break;
236         case PM_EVENT_RESUME:
237                 if (ops->resume_noirq) {
238                         error = ops->resume_noirq(dev);
239                         suspend_report_result(ops->resume_noirq, error);
240                 }
241                 break;
242 #endif /* CONFIG_SUSPEND */
243 #ifdef CONFIG_HIBERNATION
244         case PM_EVENT_FREEZE:
245         case PM_EVENT_QUIESCE:
246                 if (ops->freeze_noirq) {
247                         error = ops->freeze_noirq(dev);
248                         suspend_report_result(ops->freeze_noirq, error);
249                 }
250                 break;
251         case PM_EVENT_HIBERNATE:
252                 if (ops->poweroff_noirq) {
253                         error = ops->poweroff_noirq(dev);
254                         suspend_report_result(ops->poweroff_noirq, error);
255                 }
256                 break;
257         case PM_EVENT_THAW:
258         case PM_EVENT_RECOVER:
259                 if (ops->thaw_noirq) {
260                         error = ops->thaw_noirq(dev);
261                         suspend_report_result(ops->thaw_noirq, error);
262                 }
263                 break;
264         case PM_EVENT_RESTORE:
265                 if (ops->restore_noirq) {
266                         error = ops->restore_noirq(dev);
267                         suspend_report_result(ops->restore_noirq, error);
268                 }
269                 break;
270 #endif /* CONFIG_HIBERNATION */
271         default:
272                 error = -EINVAL;
273         }
274         return error;
275 }
276
277 static char *pm_verb(int event)
278 {
279         switch (event) {
280         case PM_EVENT_SUSPEND:
281                 return "suspend";
282         case PM_EVENT_RESUME:
283                 return "resume";
284         case PM_EVENT_FREEZE:
285                 return "freeze";
286         case PM_EVENT_QUIESCE:
287                 return "quiesce";
288         case PM_EVENT_HIBERNATE:
289                 return "hibernate";
290         case PM_EVENT_THAW:
291                 return "thaw";
292         case PM_EVENT_RESTORE:
293                 return "restore";
294         case PM_EVENT_RECOVER:
295                 return "recover";
296         default:
297                 return "(unknown PM event)";
298         }
299 }
300
301 static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info)
302 {
303         dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
304                 ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?
305                 ", may wakeup" : "");
306 }
307
308 static void pm_dev_err(struct device *dev, pm_message_t state, char *info,
309                         int error)
310 {
311         printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n",
312                 kobject_name(&dev->kobj), pm_verb(state.event), info, error);
313 }
314
315 /*------------------------- Resume routines -------------------------*/
316
317 /**
318  *      resume_device_noirq - Power on one device (early resume).
319  *      @dev:   Device.
320  *      @state: PM transition of the system being carried out.
321  *
322  *      Must be called with interrupts disabled.
323  */
324 static int resume_device_noirq(struct device *dev, pm_message_t state)
325 {
326         int error = 0;
327
328         TRACE_DEVICE(dev);
329         TRACE_RESUME(0);
330
331         if (!dev->bus)
332                 goto End;
333
334         if (dev->bus->pm) {
335                 pm_dev_dbg(dev, state, "EARLY ");
336                 error = pm_noirq_op(dev, dev->bus->pm, state);
337         } else if (dev->bus->resume_early) {
338                 pm_dev_dbg(dev, state, "legacy EARLY ");
339                 error = dev->bus->resume_early(dev);
340         }
341  End:
342         TRACE_RESUME(error);
343         return error;
344 }
345
346 /**
347  *      dpm_power_up - Power on all regular (non-sysdev) devices.
348  *      @state: PM transition of the system being carried out.
349  *
350  *      Execute the appropriate "noirq resume" callback for all devices marked
351  *      as DPM_OFF_IRQ.
352  *
353  *      Must be called under dpm_list_mtx.  Device drivers should not receive
354  *      interrupts while it's being executed.
355  */
356 static void dpm_power_up(pm_message_t state)
357 {
358         struct device *dev;
359
360         list_for_each_entry(dev, &dpm_list, power.entry)
361                 if (dev->power.status > DPM_OFF) {
362                         int error;
363
364                         dev->power.status = DPM_OFF;
365                         error = resume_device_noirq(dev, state);
366                         if (error)
367                                 pm_dev_err(dev, state, " early", error);
368                 }
369 }
370
371 /**
372  *      device_power_up - Turn on all devices that need special attention.
373  *      @state: PM transition of the system being carried out.
374  *
375  *      Call the "early" resume handlers and enable device drivers to receive
376  *      interrupts.
377  */
378 void device_power_up(pm_message_t state)
379 {
380         dpm_power_up(state);
381         resume_device_irqs();
382 }
383 EXPORT_SYMBOL_GPL(device_power_up);
384
385 /**
386  *      resume_device - Restore state for one device.
387  *      @dev:   Device.
388  *      @state: PM transition of the system being carried out.
389  */
390 static int resume_device(struct device *dev, pm_message_t state)
391 {
392         int error = 0;
393
394         TRACE_DEVICE(dev);
395         TRACE_RESUME(0);
396
397         down(&dev->sem);
398
399         if (dev->bus) {
400                 if (dev->bus->pm) {
401                         pm_dev_dbg(dev, state, "");
402                         error = pm_op(dev, dev->bus->pm, state);
403                 } else if (dev->bus->resume) {
404                         pm_dev_dbg(dev, state, "legacy ");
405                         error = dev->bus->resume(dev);
406                 }
407                 if (error)
408                         goto End;
409         }
410
411         if (dev->type) {
412                 if (dev->type->pm) {
413                         pm_dev_dbg(dev, state, "type ");
414                         error = pm_op(dev, dev->type->pm, state);
415                 } else if (dev->type->resume) {
416                         pm_dev_dbg(dev, state, "legacy type ");
417                         error = dev->type->resume(dev);
418                 }
419                 if (error)
420                         goto End;
421         }
422
423         if (dev->class) {
424                 if (dev->class->pm) {
425                         pm_dev_dbg(dev, state, "class ");
426                         error = pm_op(dev, dev->class->pm, state);
427                 } else if (dev->class->resume) {
428                         pm_dev_dbg(dev, state, "legacy class ");
429                         error = dev->class->resume(dev);
430                 }
431         }
432  End:
433         up(&dev->sem);
434
435         TRACE_RESUME(error);
436         return error;
437 }
438
439 /**
440  *      dpm_resume - Resume every device.
441  *      @state: PM transition of the system being carried out.
442  *
443  *      Execute the appropriate "resume" callback for all devices the status of
444  *      which indicates that they are inactive.
445  */
446 static void dpm_resume(pm_message_t state)
447 {
448         struct list_head list;
449
450         INIT_LIST_HEAD(&list);
451         mutex_lock(&dpm_list_mtx);
452         transition_started = false;
453         while (!list_empty(&dpm_list)) {
454                 struct device *dev = to_device(dpm_list.next);
455
456                 get_device(dev);
457                 if (dev->power.status >= DPM_OFF) {
458                         int error;
459
460                         dev->power.status = DPM_RESUMING;
461                         mutex_unlock(&dpm_list_mtx);
462
463                         error = resume_device(dev, state);
464
465                         mutex_lock(&dpm_list_mtx);
466                         if (error)
467                                 pm_dev_err(dev, state, "", error);
468                 } else if (dev->power.status == DPM_SUSPENDING) {
469                         /* Allow new children of the device to be registered */
470                         dev->power.status = DPM_RESUMING;
471                 }
472                 if (!list_empty(&dev->power.entry))
473                         list_move_tail(&dev->power.entry, &list);
474                 put_device(dev);
475         }
476         list_splice(&list, &dpm_list);
477         mutex_unlock(&dpm_list_mtx);
478 }
479
480 /**
481  *      complete_device - Complete a PM transition for given device
482  *      @dev:   Device.
483  *      @state: PM transition of the system being carried out.
484  */
485 static void complete_device(struct device *dev, pm_message_t state)
486 {
487         down(&dev->sem);
488
489         if (dev->class && dev->class->pm && dev->class->pm->complete) {
490                 pm_dev_dbg(dev, state, "completing class ");
491                 dev->class->pm->complete(dev);
492         }
493
494         if (dev->type && dev->type->pm && dev->type->pm->complete) {
495                 pm_dev_dbg(dev, state, "completing type ");
496                 dev->type->pm->complete(dev);
497         }
498
499         if (dev->bus && dev->bus->pm && dev->bus->pm->complete) {
500                 pm_dev_dbg(dev, state, "completing ");
501                 dev->bus->pm->complete(dev);
502         }
503
504         up(&dev->sem);
505 }
506
507 /**
508  *      dpm_complete - Complete a PM transition for all devices.
509  *      @state: PM transition of the system being carried out.
510  *
511  *      Execute the ->complete() callbacks for all devices that are not marked
512  *      as DPM_ON.
513  */
514 static void dpm_complete(pm_message_t state)
515 {
516         struct list_head list;
517
518         INIT_LIST_HEAD(&list);
519         mutex_lock(&dpm_list_mtx);
520         while (!list_empty(&dpm_list)) {
521                 struct device *dev = to_device(dpm_list.prev);
522
523                 get_device(dev);
524                 if (dev->power.status > DPM_ON) {
525                         dev->power.status = DPM_ON;
526                         mutex_unlock(&dpm_list_mtx);
527
528                         complete_device(dev, state);
529
530                         mutex_lock(&dpm_list_mtx);
531                 }
532                 if (!list_empty(&dev->power.entry))
533                         list_move(&dev->power.entry, &list);
534                 put_device(dev);
535         }
536         list_splice(&list, &dpm_list);
537         mutex_unlock(&dpm_list_mtx);
538 }
539
540 /**
541  *      device_resume - Restore state of each device in system.
542  *      @state: PM transition of the system being carried out.
543  *
544  *      Resume all the devices, unlock them all, and allow new
545  *      devices to be registered once again.
546  */
547 void device_resume(pm_message_t state)
548 {
549         might_sleep();
550         dpm_resume(state);
551         dpm_complete(state);
552 }
553 EXPORT_SYMBOL_GPL(device_resume);
554
555
556 /*------------------------- Suspend routines -------------------------*/
557
558 /**
559  *      resume_event - return a PM message representing the resume event
560  *                     corresponding to given sleep state.
561  *      @sleep_state: PM message representing a sleep state.
562  */
563 static pm_message_t resume_event(pm_message_t sleep_state)
564 {
565         switch (sleep_state.event) {
566         case PM_EVENT_SUSPEND:
567                 return PMSG_RESUME;
568         case PM_EVENT_FREEZE:
569         case PM_EVENT_QUIESCE:
570                 return PMSG_RECOVER;
571         case PM_EVENT_HIBERNATE:
572                 return PMSG_RESTORE;
573         }
574         return PMSG_ON;
575 }
576
577 /**
578  *      suspend_device_noirq - Shut down one device (late suspend).
579  *      @dev:   Device.
580  *      @state: PM transition of the system being carried out.
581  *
582  *      This is called with interrupts off and only a single CPU running.
583  */
584 static int suspend_device_noirq(struct device *dev, pm_message_t state)
585 {
586         int error = 0;
587
588         if (!dev->bus)
589                 return 0;
590
591         if (dev->bus->pm) {
592                 pm_dev_dbg(dev, state, "LATE ");
593                 error = pm_noirq_op(dev, dev->bus->pm, state);
594         } else if (dev->bus->suspend_late) {
595                 pm_dev_dbg(dev, state, "legacy LATE ");
596                 error = dev->bus->suspend_late(dev, state);
597                 suspend_report_result(dev->bus->suspend_late, error);
598         }
599         return error;
600 }
601
602 /**
603  *      device_power_down - Shut down special devices.
604  *      @state: PM transition of the system being carried out.
605  *
606  *      Prevent device drivers from receiving interrupts and call the "late"
607  *      suspend handlers.
608  *
609  *      Must be called under dpm_list_mtx.
610  */
611 int device_power_down(pm_message_t state)
612 {
613         struct device *dev;
614         int error = 0;
615
616         suspend_device_irqs();
617         list_for_each_entry_reverse(dev, &dpm_list, power.entry) {
618                 error = suspend_device_noirq(dev, state);
619                 if (error) {
620                         pm_dev_err(dev, state, " late", error);
621                         break;
622                 }
623                 dev->power.status = DPM_OFF_IRQ;
624         }
625         if (error)
626                 device_power_up(resume_event(state));
627         return error;
628 }
629 EXPORT_SYMBOL_GPL(device_power_down);
630
631 /**
632  *      suspend_device - Save state of one device.
633  *      @dev:   Device.
634  *      @state: PM transition of the system being carried out.
635  */
636 static int suspend_device(struct device *dev, pm_message_t state)
637 {
638         int error = 0;
639
640         down(&dev->sem);
641
642         if (dev->class) {
643                 if (dev->class->pm) {
644                         pm_dev_dbg(dev, state, "class ");
645                         error = pm_op(dev, dev->class->pm, state);
646                 } else if (dev->class->suspend) {
647                         pm_dev_dbg(dev, state, "legacy class ");
648                         error = dev->class->suspend(dev, state);
649                         suspend_report_result(dev->class->suspend, error);
650                 }
651                 if (error)
652                         goto End;
653         }
654
655         if (dev->type) {
656                 if (dev->type->pm) {
657                         pm_dev_dbg(dev, state, "type ");
658                         error = pm_op(dev, dev->type->pm, state);
659                 } else if (dev->type->suspend) {
660                         pm_dev_dbg(dev, state, "legacy type ");
661                         error = dev->type->suspend(dev, state);
662                         suspend_report_result(dev->type->suspend, error);
663                 }
664                 if (error)
665                         goto End;
666         }
667
668         if (dev->bus) {
669                 if (dev->bus->pm) {
670                         pm_dev_dbg(dev, state, "");
671                         error = pm_op(dev, dev->bus->pm, state);
672                 } else if (dev->bus->suspend) {
673                         pm_dev_dbg(dev, state, "legacy ");
674                         error = dev->bus->suspend(dev, state);
675                         suspend_report_result(dev->bus->suspend, error);
676                 }
677         }
678  End:
679         up(&dev->sem);
680
681         return error;
682 }
683
684 /**
685  *      dpm_suspend - Suspend every device.
686  *      @state: PM transition of the system being carried out.
687  *
688  *      Execute the appropriate "suspend" callbacks for all devices.
689  */
690 static int dpm_suspend(pm_message_t state)
691 {
692         struct list_head list;
693         int error = 0;
694
695         INIT_LIST_HEAD(&list);
696         mutex_lock(&dpm_list_mtx);
697         while (!list_empty(&dpm_list)) {
698                 struct device *dev = to_device(dpm_list.prev);
699
700                 get_device(dev);
701                 mutex_unlock(&dpm_list_mtx);
702
703                 error = suspend_device(dev, state);
704
705                 mutex_lock(&dpm_list_mtx);
706                 if (error) {
707                         pm_dev_err(dev, state, "", error);
708                         put_device(dev);
709                         break;
710                 }
711                 dev->power.status = DPM_OFF;
712                 if (!list_empty(&dev->power.entry))
713                         list_move(&dev->power.entry, &list);
714                 put_device(dev);
715         }
716         list_splice(&list, dpm_list.prev);
717         mutex_unlock(&dpm_list_mtx);
718         return error;
719 }
720
721 /**
722  *      prepare_device - Execute the ->prepare() callback(s) for given device.
723  *      @dev:   Device.
724  *      @state: PM transition of the system being carried out.
725  */
726 static int prepare_device(struct device *dev, pm_message_t state)
727 {
728         int error = 0;
729
730         down(&dev->sem);
731
732         if (dev->bus && dev->bus->pm && dev->bus->pm->prepare) {
733                 pm_dev_dbg(dev, state, "preparing ");
734                 error = dev->bus->pm->prepare(dev);
735                 suspend_report_result(dev->bus->pm->prepare, error);
736                 if (error)
737                         goto End;
738         }
739
740         if (dev->type && dev->type->pm && dev->type->pm->prepare) {
741                 pm_dev_dbg(dev, state, "preparing type ");
742                 error = dev->type->pm->prepare(dev);
743                 suspend_report_result(dev->type->pm->prepare, error);
744                 if (error)
745                         goto End;
746         }
747
748         if (dev->class && dev->class->pm && dev->class->pm->prepare) {
749                 pm_dev_dbg(dev, state, "preparing class ");
750                 error = dev->class->pm->prepare(dev);
751                 suspend_report_result(dev->class->pm->prepare, error);
752         }
753  End:
754         up(&dev->sem);
755
756         return error;
757 }
758
759 /**
760  *      dpm_prepare - Prepare all devices for a PM transition.
761  *      @state: PM transition of the system being carried out.
762  *
763  *      Execute the ->prepare() callback for all devices.
764  */
765 static int dpm_prepare(pm_message_t state)
766 {
767         struct list_head list;
768         int error = 0;
769
770         INIT_LIST_HEAD(&list);
771         mutex_lock(&dpm_list_mtx);
772         transition_started = true;
773         while (!list_empty(&dpm_list)) {
774                 struct device *dev = to_device(dpm_list.next);
775
776                 get_device(dev);
777                 dev->power.status = DPM_PREPARING;
778                 mutex_unlock(&dpm_list_mtx);
779
780                 error = prepare_device(dev, state);
781
782                 mutex_lock(&dpm_list_mtx);
783                 if (error) {
784                         dev->power.status = DPM_ON;
785                         if (error == -EAGAIN) {
786                                 put_device(dev);
787                                 continue;
788                         }
789                         printk(KERN_ERR "PM: Failed to prepare device %s "
790                                 "for power transition: error %d\n",
791                                 kobject_name(&dev->kobj), error);
792                         put_device(dev);
793                         break;
794                 }
795                 dev->power.status = DPM_SUSPENDING;
796                 if (!list_empty(&dev->power.entry))
797                         list_move_tail(&dev->power.entry, &list);
798                 put_device(dev);
799         }
800         list_splice(&list, &dpm_list);
801         mutex_unlock(&dpm_list_mtx);
802         return error;
803 }
804
805 /**
806  *      device_suspend - Save state and stop all devices in system.
807  *      @state: PM transition of the system being carried out.
808  *
809  *      Prepare and suspend all devices.
810  */
811 int device_suspend(pm_message_t state)
812 {
813         int error;
814
815         might_sleep();
816         error = dpm_prepare(state);
817         if (!error)
818                 error = dpm_suspend(state);
819         return error;
820 }
821 EXPORT_SYMBOL_GPL(device_suspend);
822
823 void __suspend_report_result(const char *function, void *fn, int ret)
824 {
825         if (ret)
826                 printk(KERN_ERR "%s(): %pF returns %d\n", function, fn, ret);
827 }
828 EXPORT_SYMBOL_GPL(__suspend_report_result);