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