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