1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/acpi.h>
14#include <linux/export.h>
15#include <linux/mutex.h>
16#include <linux/pm_qos.h>
17#include <linux/pm_domain.h>
18#include <linux/pm_runtime.h>
19#include <linux/suspend.h>
20
21#include "internal.h"
22
23#define _COMPONENT ACPI_POWER_COMPONENT
24ACPI_MODULE_NAME("device_pm");
25
26
27
28
29
30const char *acpi_power_state_string(int state)
31{
32 switch (state) {
33 case ACPI_STATE_D0:
34 return "D0";
35 case ACPI_STATE_D1:
36 return "D1";
37 case ACPI_STATE_D2:
38 return "D2";
39 case ACPI_STATE_D3_HOT:
40 return "D3hot";
41 case ACPI_STATE_D3_COLD:
42 return "D3cold";
43 default:
44 return "(unknown)";
45 }
46}
47
48static int acpi_dev_pm_explicit_get(struct acpi_device *device, int *state)
49{
50 unsigned long long psc;
51 acpi_status status;
52
53 status = acpi_evaluate_integer(device->handle, "_PSC", NULL, &psc);
54 if (ACPI_FAILURE(status))
55 return -ENODEV;
56
57 *state = psc;
58 return 0;
59}
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75int acpi_device_get_power(struct acpi_device *device, int *state)
76{
77 int result = ACPI_STATE_UNKNOWN;
78 int error;
79
80 if (!device || !state)
81 return -EINVAL;
82
83 if (!device->flags.power_manageable) {
84
85 *state = device->parent ?
86 device->parent->power.state : ACPI_STATE_D0;
87 goto out;
88 }
89
90
91
92
93
94 if (device->power.flags.power_resources) {
95 error = acpi_power_get_inferred_state(device, &result);
96 if (error)
97 return error;
98 }
99 if (device->power.flags.explicit_get) {
100 int psc;
101
102 error = acpi_dev_pm_explicit_get(device, &psc);
103 if (error)
104 return error;
105
106
107
108
109
110
111
112
113
114 if (psc > result && psc < ACPI_STATE_D3_COLD)
115 result = psc;
116 else if (result == ACPI_STATE_UNKNOWN)
117 result = psc > ACPI_STATE_D2 ? ACPI_STATE_D3_HOT : psc;
118 }
119
120
121
122
123
124
125 if (!device->power.flags.ignore_parent && device->parent
126 && device->parent->power.state == ACPI_STATE_UNKNOWN
127 && result == ACPI_STATE_D0)
128 device->parent->power.state = ACPI_STATE_D0;
129
130 *state = result;
131
132 out:
133 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is %s\n",
134 device->pnp.bus_id, acpi_power_state_string(*state)));
135
136 return 0;
137}
138
139static int acpi_dev_pm_explicit_set(struct acpi_device *adev, int state)
140{
141 if (adev->power.states[state].flags.explicit_set) {
142 char method[5] = { '_', 'P', 'S', '0' + state, '\0' };
143 acpi_status status;
144
145 status = acpi_evaluate_object(adev->handle, method, NULL, NULL);
146 if (ACPI_FAILURE(status))
147 return -ENODEV;
148 }
149 return 0;
150}
151
152
153
154
155
156
157
158
159
160int acpi_device_set_power(struct acpi_device *device, int state)
161{
162 int target_state = state;
163 int result = 0;
164
165 if (!device || !device->flags.power_manageable
166 || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
167 return -EINVAL;
168
169
170
171
172 if (state > ACPI_STATE_D0 && state == device->power.state) {
173 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already in %s\n",
174 device->pnp.bus_id,
175 acpi_power_state_string(state)));
176 return 0;
177 }
178
179 if (state == ACPI_STATE_D3_COLD) {
180
181
182
183
184 state = ACPI_STATE_D3_HOT;
185
186 if (!device->power.states[ACPI_STATE_D3_COLD].flags.valid)
187 target_state = state;
188 } else if (!device->power.states[state].flags.valid) {
189 dev_warn(&device->dev, "Power state %s not supported\n",
190 acpi_power_state_string(state));
191 return -ENODEV;
192 }
193
194 if (!device->power.flags.ignore_parent &&
195 device->parent && (state < device->parent->power.state)) {
196 dev_warn(&device->dev,
197 "Cannot transition to power state %s for parent in %s\n",
198 acpi_power_state_string(state),
199 acpi_power_state_string(device->parent->power.state));
200 return -ENODEV;
201 }
202
203
204
205
206
207
208
209
210 if (state > ACPI_STATE_D0) {
211
212
213
214
215 if (state < device->power.state) {
216 dev_warn(&device->dev, "Cannot transition from %s to %s\n",
217 acpi_power_state_string(device->power.state),
218 acpi_power_state_string(state));
219 return -ENODEV;
220 }
221
222
223
224
225
226 if (device->power.state < ACPI_STATE_D3_HOT) {
227 result = acpi_dev_pm_explicit_set(device, state);
228 if (result)
229 goto end;
230 }
231
232 if (device->power.flags.power_resources)
233 result = acpi_power_transition(device, target_state);
234 } else {
235 int cur_state = device->power.state;
236
237 if (device->power.flags.power_resources) {
238 result = acpi_power_transition(device, ACPI_STATE_D0);
239 if (result)
240 goto end;
241 }
242
243 if (cur_state == ACPI_STATE_D0) {
244 int psc;
245
246
247 if (!device->power.flags.explicit_get)
248 return 0;
249
250
251
252
253
254
255
256
257
258
259
260
261 result = acpi_dev_pm_explicit_get(device, &psc);
262 if (result || psc == ACPI_STATE_D0)
263 return 0;
264 }
265
266 result = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
267 }
268
269 end:
270 if (result) {
271 dev_warn(&device->dev, "Failed to change power state to %s\n",
272 acpi_power_state_string(state));
273 } else {
274 device->power.state = target_state;
275 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
276 "Device [%s] transitioned to %s\n",
277 device->pnp.bus_id,
278 acpi_power_state_string(state)));
279 }
280
281 return result;
282}
283EXPORT_SYMBOL(acpi_device_set_power);
284
285int acpi_bus_set_power(acpi_handle handle, int state)
286{
287 struct acpi_device *device;
288 int result;
289
290 result = acpi_bus_get_device(handle, &device);
291 if (result)
292 return result;
293
294 return acpi_device_set_power(device, state);
295}
296EXPORT_SYMBOL(acpi_bus_set_power);
297
298int acpi_bus_init_power(struct acpi_device *device)
299{
300 int state;
301 int result;
302
303 if (!device)
304 return -EINVAL;
305
306 device->power.state = ACPI_STATE_UNKNOWN;
307 if (!acpi_device_is_present(device)) {
308 device->flags.initialized = false;
309 return -ENXIO;
310 }
311
312 result = acpi_device_get_power(device, &state);
313 if (result)
314 return result;
315
316 if (state < ACPI_STATE_D3_COLD && device->power.flags.power_resources) {
317
318 result = acpi_power_on_resources(device, state);
319 if (result)
320 return result;
321
322 if (state == ACPI_STATE_D0) {
323
324
325
326
327
328
329
330
331 result = acpi_dev_pm_explicit_set(device, state);
332 if (result)
333 return result;
334 }
335 } else if (state == ACPI_STATE_UNKNOWN) {
336
337
338
339
340
341
342 state = ACPI_STATE_D0;
343 }
344 device->power.state = state;
345 return 0;
346}
347
348
349
350
351
352
353
354
355
356int acpi_device_fix_up_power(struct acpi_device *device)
357{
358 int ret = 0;
359
360 if (!device->power.flags.power_resources
361 && !device->power.flags.explicit_get
362 && device->power.state == ACPI_STATE_D0)
363 ret = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
364
365 return ret;
366}
367EXPORT_SYMBOL_GPL(acpi_device_fix_up_power);
368
369int acpi_device_update_power(struct acpi_device *device, int *state_p)
370{
371 int state;
372 int result;
373
374 if (device->power.state == ACPI_STATE_UNKNOWN) {
375 result = acpi_bus_init_power(device);
376 if (!result && state_p)
377 *state_p = device->power.state;
378
379 return result;
380 }
381
382 result = acpi_device_get_power(device, &state);
383 if (result)
384 return result;
385
386 if (state == ACPI_STATE_UNKNOWN) {
387 state = ACPI_STATE_D0;
388 result = acpi_device_set_power(device, state);
389 if (result)
390 return result;
391 } else {
392 if (device->power.flags.power_resources) {
393
394
395
396
397 result = acpi_power_transition(device, state);
398 if (result)
399 return result;
400 }
401 device->power.state = state;
402 }
403 if (state_p)
404 *state_p = state;
405
406 return 0;
407}
408EXPORT_SYMBOL_GPL(acpi_device_update_power);
409
410int acpi_bus_update_power(acpi_handle handle, int *state_p)
411{
412 struct acpi_device *device;
413 int result;
414
415 result = acpi_bus_get_device(handle, &device);
416 return result ? result : acpi_device_update_power(device, state_p);
417}
418EXPORT_SYMBOL_GPL(acpi_bus_update_power);
419
420bool acpi_bus_power_manageable(acpi_handle handle)
421{
422 struct acpi_device *device;
423 int result;
424
425 result = acpi_bus_get_device(handle, &device);
426 return result ? false : device->flags.power_manageable;
427}
428EXPORT_SYMBOL(acpi_bus_power_manageable);
429
430#ifdef CONFIG_PM
431static DEFINE_MUTEX(acpi_pm_notifier_lock);
432static DEFINE_MUTEX(acpi_pm_notifier_install_lock);
433
434void acpi_pm_wakeup_event(struct device *dev)
435{
436 pm_wakeup_dev_event(dev, 0, acpi_s2idle_wakeup());
437}
438EXPORT_SYMBOL_GPL(acpi_pm_wakeup_event);
439
440static void acpi_pm_notify_handler(acpi_handle handle, u32 val, void *not_used)
441{
442 struct acpi_device *adev;
443
444 if (val != ACPI_NOTIFY_DEVICE_WAKE)
445 return;
446
447 acpi_handle_debug(handle, "Wake notify\n");
448
449 adev = acpi_bus_get_acpi_device(handle);
450 if (!adev)
451 return;
452
453 mutex_lock(&acpi_pm_notifier_lock);
454
455 if (adev->wakeup.flags.notifier_present) {
456 pm_wakeup_ws_event(adev->wakeup.ws, 0, acpi_s2idle_wakeup());
457 if (adev->wakeup.context.func) {
458 acpi_handle_debug(handle, "Running %pS for %s\n",
459 adev->wakeup.context.func,
460 dev_name(adev->wakeup.context.dev));
461 adev->wakeup.context.func(&adev->wakeup.context);
462 }
463 }
464
465 mutex_unlock(&acpi_pm_notifier_lock);
466
467 acpi_bus_put_acpi_device(adev);
468}
469
470
471
472
473
474
475
476
477
478
479
480
481acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev,
482 void (*func)(struct acpi_device_wakeup_context *context))
483{
484 acpi_status status = AE_ALREADY_EXISTS;
485
486 if (!dev && !func)
487 return AE_BAD_PARAMETER;
488
489 mutex_lock(&acpi_pm_notifier_install_lock);
490
491 if (adev->wakeup.flags.notifier_present)
492 goto out;
493
494 status = acpi_install_notify_handler(adev->handle, ACPI_SYSTEM_NOTIFY,
495 acpi_pm_notify_handler, NULL);
496 if (ACPI_FAILURE(status))
497 goto out;
498
499 mutex_lock(&acpi_pm_notifier_lock);
500 adev->wakeup.ws = wakeup_source_register(dev_name(&adev->dev));
501 adev->wakeup.context.dev = dev;
502 adev->wakeup.context.func = func;
503 adev->wakeup.flags.notifier_present = true;
504 mutex_unlock(&acpi_pm_notifier_lock);
505
506 out:
507 mutex_unlock(&acpi_pm_notifier_install_lock);
508 return status;
509}
510
511
512
513
514
515acpi_status acpi_remove_pm_notifier(struct acpi_device *adev)
516{
517 acpi_status status = AE_BAD_PARAMETER;
518
519 mutex_lock(&acpi_pm_notifier_install_lock);
520
521 if (!adev->wakeup.flags.notifier_present)
522 goto out;
523
524 status = acpi_remove_notify_handler(adev->handle,
525 ACPI_SYSTEM_NOTIFY,
526 acpi_pm_notify_handler);
527 if (ACPI_FAILURE(status))
528 goto out;
529
530 mutex_lock(&acpi_pm_notifier_lock);
531 adev->wakeup.context.func = NULL;
532 adev->wakeup.context.dev = NULL;
533 wakeup_source_unregister(adev->wakeup.ws);
534 adev->wakeup.flags.notifier_present = false;
535 mutex_unlock(&acpi_pm_notifier_lock);
536
537 out:
538 mutex_unlock(&acpi_pm_notifier_install_lock);
539 return status;
540}
541
542bool acpi_bus_can_wakeup(acpi_handle handle)
543{
544 struct acpi_device *device;
545 int result;
546
547 result = acpi_bus_get_device(handle, &device);
548 return result ? false : device->wakeup.flags.valid;
549}
550EXPORT_SYMBOL(acpi_bus_can_wakeup);
551
552bool acpi_pm_device_can_wakeup(struct device *dev)
553{
554 struct acpi_device *adev = ACPI_COMPANION(dev);
555
556 return adev ? acpi_device_can_wakeup(adev) : false;
557}
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev,
581 u32 target_state, int *d_min_p, int *d_max_p)
582{
583 char method[] = { '_', 'S', '0' + target_state, 'D', '\0' };
584 acpi_handle handle = adev->handle;
585 unsigned long long ret;
586 int d_min, d_max;
587 bool wakeup = false;
588 bool has_sxd = false;
589 acpi_status status;
590
591
592
593
594
595
596
597 d_min = ACPI_STATE_D0;
598 d_max = ACPI_STATE_D3_COLD;
599
600
601
602
603
604
605 if (target_state > ACPI_STATE_S0) {
606
607
608
609
610 ret = d_min;
611 status = acpi_evaluate_integer(handle, method, NULL, &ret);
612 if ((ACPI_FAILURE(status) && status != AE_NOT_FOUND)
613 || ret > ACPI_STATE_D3_COLD)
614 return -ENODATA;
615
616
617
618
619
620
621 if (!adev->power.states[ret].flags.valid) {
622 if (ret == ACPI_STATE_D3_HOT)
623 ret = ACPI_STATE_D3_COLD;
624 else
625 return -ENODATA;
626 }
627
628 if (status == AE_OK)
629 has_sxd = true;
630
631 d_min = ret;
632 wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid
633 && adev->wakeup.sleep_state >= target_state;
634 } else {
635 wakeup = adev->wakeup.flags.valid;
636 }
637
638
639
640
641
642
643
644
645 if (wakeup) {
646 method[3] = 'W';
647 status = acpi_evaluate_integer(handle, method, NULL, &ret);
648 if (status == AE_NOT_FOUND) {
649
650
651
652
653 if (has_sxd && target_state > ACPI_STATE_S0)
654 d_max = d_min;
655 } else if (ACPI_SUCCESS(status) && ret <= ACPI_STATE_D3_COLD) {
656
657 if (!adev->power.states[ret].flags.valid)
658 ret = ACPI_STATE_D3_COLD;
659
660 d_max = ret > d_min ? ret : d_min;
661 } else {
662 return -ENODATA;
663 }
664 }
665
666 if (d_min_p)
667 *d_min_p = d_min;
668
669 if (d_max_p)
670 *d_max_p = d_max;
671
672 return 0;
673}
674
675
676
677
678
679
680
681
682
683
684
685
686int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in)
687{
688 struct acpi_device *adev;
689 int ret, d_min, d_max;
690
691 if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3_COLD)
692 return -EINVAL;
693
694 if (d_max_in > ACPI_STATE_D2) {
695 enum pm_qos_flags_status stat;
696
697 stat = dev_pm_qos_flags(dev, PM_QOS_FLAG_NO_POWER_OFF);
698 if (stat == PM_QOS_FLAGS_ALL)
699 d_max_in = ACPI_STATE_D2;
700 }
701
702 adev = ACPI_COMPANION(dev);
703 if (!adev) {
704 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
705 return -ENODEV;
706 }
707
708 ret = acpi_dev_pm_get_state(dev, adev, acpi_target_system_state(),
709 &d_min, &d_max);
710 if (ret)
711 return ret;
712
713 if (d_max_in < d_min)
714 return -EINVAL;
715
716 if (d_max > d_max_in) {
717 for (d_max = d_max_in; d_max > d_min; d_max--) {
718 if (adev->power.states[d_max].flags.valid)
719 break;
720 }
721 }
722
723 if (d_min_p)
724 *d_min_p = d_min;
725
726 return d_max;
727}
728EXPORT_SYMBOL(acpi_pm_device_sleep_state);
729
730
731
732
733
734static void acpi_pm_notify_work_func(struct acpi_device_wakeup_context *context)
735{
736 struct device *dev = context->dev;
737
738 if (dev) {
739 pm_wakeup_event(dev, 0);
740 pm_request_resume(dev);
741 }
742}
743
744static DEFINE_MUTEX(acpi_wakeup_lock);
745
746static int __acpi_device_wakeup_enable(struct acpi_device *adev,
747 u32 target_state, int max_count)
748{
749 struct acpi_device_wakeup *wakeup = &adev->wakeup;
750 acpi_status status;
751 int error = 0;
752
753 mutex_lock(&acpi_wakeup_lock);
754
755 if (wakeup->enable_count >= max_count)
756 goto out;
757
758 if (wakeup->enable_count > 0)
759 goto inc;
760
761 error = acpi_enable_wakeup_device_power(adev, target_state);
762 if (error)
763 goto out;
764
765 status = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);
766 if (ACPI_FAILURE(status)) {
767 acpi_disable_wakeup_device_power(adev);
768 error = -EIO;
769 goto out;
770 }
771
772 acpi_handle_debug(adev->handle, "GPE%2X enabled for wakeup\n",
773 (unsigned int)wakeup->gpe_number);
774
775inc:
776 wakeup->enable_count++;
777
778out:
779 mutex_unlock(&acpi_wakeup_lock);
780 return error;
781}
782
783
784
785
786
787
788
789
790
791
792
793
794
795static int acpi_device_wakeup_enable(struct acpi_device *adev, u32 target_state)
796{
797 return __acpi_device_wakeup_enable(adev, target_state, 1);
798}
799
800
801
802
803
804
805
806
807
808
809static void acpi_device_wakeup_disable(struct acpi_device *adev)
810{
811 struct acpi_device_wakeup *wakeup = &adev->wakeup;
812
813 mutex_lock(&acpi_wakeup_lock);
814
815 if (!wakeup->enable_count)
816 goto out;
817
818 acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);
819 acpi_disable_wakeup_device_power(adev);
820
821 wakeup->enable_count--;
822
823out:
824 mutex_unlock(&acpi_wakeup_lock);
825}
826
827static int __acpi_pm_set_device_wakeup(struct device *dev, bool enable,
828 int max_count)
829{
830 struct acpi_device *adev;
831 int error;
832
833 adev = ACPI_COMPANION(dev);
834 if (!adev) {
835 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
836 return -ENODEV;
837 }
838
839 if (!acpi_device_can_wakeup(adev))
840 return -EINVAL;
841
842 if (!enable) {
843 acpi_device_wakeup_disable(adev);
844 dev_dbg(dev, "Wakeup disabled by ACPI\n");
845 return 0;
846 }
847
848 error = __acpi_device_wakeup_enable(adev, acpi_target_system_state(),
849 max_count);
850 if (!error)
851 dev_dbg(dev, "Wakeup enabled by ACPI\n");
852
853 return error;
854}
855
856
857
858
859
860
861int acpi_pm_set_device_wakeup(struct device *dev, bool enable)
862{
863 return __acpi_pm_set_device_wakeup(dev, enable, 1);
864}
865EXPORT_SYMBOL_GPL(acpi_pm_set_device_wakeup);
866
867
868
869
870
871
872int acpi_pm_set_bridge_wakeup(struct device *dev, bool enable)
873{
874 return __acpi_pm_set_device_wakeup(dev, enable, INT_MAX);
875}
876EXPORT_SYMBOL_GPL(acpi_pm_set_bridge_wakeup);
877
878
879
880
881
882
883
884static int acpi_dev_pm_low_power(struct device *dev, struct acpi_device *adev,
885 u32 system_state)
886{
887 int ret, state;
888
889 if (!acpi_device_power_manageable(adev))
890 return 0;
891
892 ret = acpi_dev_pm_get_state(dev, adev, system_state, NULL, &state);
893 return ret ? ret : acpi_device_set_power(adev, state);
894}
895
896
897
898
899
900static int acpi_dev_pm_full_power(struct acpi_device *adev)
901{
902 return acpi_device_power_manageable(adev) ?
903 acpi_device_set_power(adev, ACPI_STATE_D0) : 0;
904}
905
906
907
908
909
910
911
912
913
914
915
916int acpi_dev_suspend(struct device *dev, bool wakeup)
917{
918 struct acpi_device *adev = ACPI_COMPANION(dev);
919 u32 target_state = acpi_target_system_state();
920 int error;
921
922 if (!adev)
923 return 0;
924
925 if (wakeup && acpi_device_can_wakeup(adev)) {
926 error = acpi_device_wakeup_enable(adev, target_state);
927 if (error)
928 return -EAGAIN;
929 } else {
930 wakeup = false;
931 }
932
933 error = acpi_dev_pm_low_power(dev, adev, target_state);
934 if (error && wakeup)
935 acpi_device_wakeup_disable(adev);
936
937 return error;
938}
939EXPORT_SYMBOL_GPL(acpi_dev_suspend);
940
941
942
943
944
945
946
947
948int acpi_dev_resume(struct device *dev)
949{
950 struct acpi_device *adev = ACPI_COMPANION(dev);
951 int error;
952
953 if (!adev)
954 return 0;
955
956 error = acpi_dev_pm_full_power(adev);
957 acpi_device_wakeup_disable(adev);
958 return error;
959}
960EXPORT_SYMBOL_GPL(acpi_dev_resume);
961
962
963
964
965
966
967
968
969int acpi_subsys_runtime_suspend(struct device *dev)
970{
971 int ret = pm_generic_runtime_suspend(dev);
972 return ret ? ret : acpi_dev_suspend(dev, true);
973}
974EXPORT_SYMBOL_GPL(acpi_subsys_runtime_suspend);
975
976
977
978
979
980
981
982
983int acpi_subsys_runtime_resume(struct device *dev)
984{
985 int ret = acpi_dev_resume(dev);
986 return ret ? ret : pm_generic_runtime_resume(dev);
987}
988EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume);
989
990#ifdef CONFIG_PM_SLEEP
991static bool acpi_dev_needs_resume(struct device *dev, struct acpi_device *adev)
992{
993 u32 sys_target = acpi_target_system_state();
994 int ret, state;
995
996 if (!pm_runtime_suspended(dev) || !adev || (adev->wakeup.flags.valid &&
997 device_may_wakeup(dev) != !!adev->wakeup.prepare_count))
998 return true;
999
1000 if (sys_target == ACPI_STATE_S0)
1001 return false;
1002
1003 if (adev->power.flags.dsw_present)
1004 return true;
1005
1006 ret = acpi_dev_pm_get_state(dev, adev, sys_target, NULL, &state);
1007 if (ret)
1008 return true;
1009
1010 return state != adev->power.state;
1011}
1012
1013
1014
1015
1016
1017int acpi_subsys_prepare(struct device *dev)
1018{
1019 struct acpi_device *adev = ACPI_COMPANION(dev);
1020
1021 if (dev->driver && dev->driver->pm && dev->driver->pm->prepare) {
1022 int ret = dev->driver->pm->prepare(dev);
1023
1024 if (ret < 0)
1025 return ret;
1026
1027 if (!ret && dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_PREPARE))
1028 return 0;
1029 }
1030
1031 return !acpi_dev_needs_resume(dev, adev);
1032}
1033EXPORT_SYMBOL_GPL(acpi_subsys_prepare);
1034
1035
1036
1037
1038
1039void acpi_subsys_complete(struct device *dev)
1040{
1041 pm_generic_complete(dev);
1042
1043
1044
1045
1046
1047 if (pm_runtime_suspended(dev) && pm_resume_via_firmware())
1048 pm_request_resume(dev);
1049}
1050EXPORT_SYMBOL_GPL(acpi_subsys_complete);
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061int acpi_subsys_suspend(struct device *dev)
1062{
1063 if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
1064 acpi_dev_needs_resume(dev, ACPI_COMPANION(dev)))
1065 pm_runtime_resume(dev);
1066
1067 return pm_generic_suspend(dev);
1068}
1069EXPORT_SYMBOL_GPL(acpi_subsys_suspend);
1070
1071
1072
1073
1074
1075
1076
1077
1078int acpi_subsys_suspend_late(struct device *dev)
1079{
1080 int ret;
1081
1082 if (dev_pm_smart_suspend_and_suspended(dev))
1083 return 0;
1084
1085 ret = pm_generic_suspend_late(dev);
1086 return ret ? ret : acpi_dev_suspend(dev, device_may_wakeup(dev));
1087}
1088EXPORT_SYMBOL_GPL(acpi_subsys_suspend_late);
1089
1090
1091
1092
1093
1094int acpi_subsys_suspend_noirq(struct device *dev)
1095{
1096 int ret;
1097
1098 if (dev_pm_smart_suspend_and_suspended(dev)) {
1099 dev->power.may_skip_resume = true;
1100 return 0;
1101 }
1102
1103 ret = pm_generic_suspend_noirq(dev);
1104 if (ret)
1105 return ret;
1106
1107
1108
1109
1110
1111
1112
1113
1114 dev->power.may_skip_resume = device_may_wakeup(dev) ||
1115 !device_can_wakeup(dev);
1116
1117 return 0;
1118}
1119EXPORT_SYMBOL_GPL(acpi_subsys_suspend_noirq);
1120
1121
1122
1123
1124
1125static int acpi_subsys_resume_noirq(struct device *dev)
1126{
1127 if (dev_pm_may_skip_resume(dev))
1128 return 0;
1129
1130
1131
1132
1133
1134
1135 if (dev_pm_smart_suspend_and_suspended(dev))
1136 pm_runtime_set_active(dev);
1137
1138 return pm_generic_resume_noirq(dev);
1139}
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149static int acpi_subsys_resume_early(struct device *dev)
1150{
1151 int ret = acpi_dev_resume(dev);
1152 return ret ? ret : pm_generic_resume_early(dev);
1153}
1154
1155
1156
1157
1158
1159int acpi_subsys_freeze(struct device *dev)
1160{
1161
1162
1163
1164
1165
1166
1167
1168
1169 pm_runtime_resume(dev);
1170
1171 return pm_generic_freeze(dev);
1172}
1173EXPORT_SYMBOL_GPL(acpi_subsys_freeze);
1174
1175
1176
1177
1178
1179int acpi_subsys_restore_early(struct device *dev)
1180{
1181 int ret = acpi_dev_resume(dev);
1182 return ret ? ret : pm_generic_restore_early(dev);
1183}
1184EXPORT_SYMBOL_GPL(acpi_subsys_restore_early);
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195int acpi_subsys_poweroff(struct device *dev)
1196{
1197 if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
1198 acpi_dev_needs_resume(dev, ACPI_COMPANION(dev)))
1199 pm_runtime_resume(dev);
1200
1201 return pm_generic_poweroff(dev);
1202}
1203EXPORT_SYMBOL_GPL(acpi_subsys_poweroff);
1204
1205
1206
1207
1208
1209
1210
1211
1212static int acpi_subsys_poweroff_late(struct device *dev)
1213{
1214 int ret;
1215
1216 if (dev_pm_smart_suspend_and_suspended(dev))
1217 return 0;
1218
1219 ret = pm_generic_poweroff_late(dev);
1220 if (ret)
1221 return ret;
1222
1223 return acpi_dev_suspend(dev, device_may_wakeup(dev));
1224}
1225
1226
1227
1228
1229
1230static int acpi_subsys_poweroff_noirq(struct device *dev)
1231{
1232 if (dev_pm_smart_suspend_and_suspended(dev))
1233 return 0;
1234
1235 return pm_generic_poweroff_noirq(dev);
1236}
1237#endif
1238
1239static struct dev_pm_domain acpi_general_pm_domain = {
1240 .ops = {
1241 .runtime_suspend = acpi_subsys_runtime_suspend,
1242 .runtime_resume = acpi_subsys_runtime_resume,
1243#ifdef CONFIG_PM_SLEEP
1244 .prepare = acpi_subsys_prepare,
1245 .complete = acpi_subsys_complete,
1246 .suspend = acpi_subsys_suspend,
1247 .suspend_late = acpi_subsys_suspend_late,
1248 .suspend_noirq = acpi_subsys_suspend_noirq,
1249 .resume_noirq = acpi_subsys_resume_noirq,
1250 .resume_early = acpi_subsys_resume_early,
1251 .freeze = acpi_subsys_freeze,
1252 .poweroff = acpi_subsys_poweroff,
1253 .poweroff_late = acpi_subsys_poweroff_late,
1254 .poweroff_noirq = acpi_subsys_poweroff_noirq,
1255 .restore_early = acpi_subsys_restore_early,
1256#endif
1257 },
1258};
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272static void acpi_dev_pm_detach(struct device *dev, bool power_off)
1273{
1274 struct acpi_device *adev = ACPI_COMPANION(dev);
1275
1276 if (adev && dev->pm_domain == &acpi_general_pm_domain) {
1277 dev_pm_domain_set(dev, NULL);
1278 acpi_remove_pm_notifier(adev);
1279 if (power_off) {
1280
1281
1282
1283
1284
1285
1286 dev_pm_qos_hide_latency_limit(dev);
1287 dev_pm_qos_hide_flags(dev);
1288 acpi_device_wakeup_disable(adev);
1289 acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
1290 }
1291 }
1292}
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310int acpi_dev_pm_attach(struct device *dev, bool power_on)
1311{
1312 struct acpi_device *adev = ACPI_COMPANION(dev);
1313
1314 if (!adev)
1315 return 0;
1316
1317
1318
1319
1320
1321
1322 if (!acpi_device_is_first_physical_node(adev, dev))
1323 return 0;
1324
1325 acpi_add_pm_notifier(adev, dev, acpi_pm_notify_work_func);
1326 dev_pm_domain_set(dev, &acpi_general_pm_domain);
1327 if (power_on) {
1328 acpi_dev_pm_full_power(adev);
1329 acpi_device_wakeup_disable(adev);
1330 }
1331
1332 dev->pm_domain->detach = acpi_dev_pm_detach;
1333 return 1;
1334}
1335EXPORT_SYMBOL_GPL(acpi_dev_pm_attach);
1336#endif
1337