Merge remote-tracking branches 'asoc/fix/adau1761', 'asoc/fix/fsl', 'asoc/fix/intel...
[firefly-linux-kernel-4.4.55.git] / drivers / acpi / sleep.c
1 /*
2  * sleep.c - ACPI sleep support.
3  *
4  * Copyright (c) 2005 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
5  * Copyright (c) 2004 David Shaohua Li <shaohua.li@intel.com>
6  * Copyright (c) 2000-2003 Patrick Mochel
7  * Copyright (c) 2003 Open Source Development Lab
8  *
9  * This file is released under the GPLv2.
10  *
11  */
12
13 #include <linux/delay.h>
14 #include <linux/irq.h>
15 #include <linux/dmi.h>
16 #include <linux/device.h>
17 #include <linux/interrupt.h>
18 #include <linux/suspend.h>
19 #include <linux/reboot.h>
20 #include <linux/acpi.h>
21 #include <linux/module.h>
22 #include <asm/io.h>
23 #include <trace/events/power.h>
24
25 #include "internal.h"
26 #include "sleep.h"
27
28 static u8 sleep_states[ACPI_S_STATE_COUNT];
29
30 static void acpi_sleep_tts_switch(u32 acpi_state)
31 {
32         acpi_status status;
33
34         status = acpi_execute_simple_method(NULL, "\\_TTS", acpi_state);
35         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
36                 /*
37                  * OS can't evaluate the _TTS object correctly. Some warning
38                  * message will be printed. But it won't break anything.
39                  */
40                 printk(KERN_NOTICE "Failure in evaluating _TTS object\n");
41         }
42 }
43
44 static int tts_notify_reboot(struct notifier_block *this,
45                         unsigned long code, void *x)
46 {
47         acpi_sleep_tts_switch(ACPI_STATE_S5);
48         return NOTIFY_DONE;
49 }
50
51 static struct notifier_block tts_notifier = {
52         .notifier_call  = tts_notify_reboot,
53         .next           = NULL,
54         .priority       = 0,
55 };
56
57 static int acpi_sleep_prepare(u32 acpi_state)
58 {
59 #ifdef CONFIG_ACPI_SLEEP
60         /* do we have a wakeup address for S2 and S3? */
61         if (acpi_state == ACPI_STATE_S3) {
62                 if (!acpi_wakeup_address)
63                         return -EFAULT;
64                 acpi_set_firmware_waking_vector(acpi_wakeup_address);
65
66         }
67         ACPI_FLUSH_CPU_CACHE();
68 #endif
69         printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
70                 acpi_state);
71         acpi_enable_wakeup_devices(acpi_state);
72         acpi_enter_sleep_state_prep(acpi_state);
73         return 0;
74 }
75
76 static bool acpi_sleep_state_supported(u8 sleep_state)
77 {
78         acpi_status status;
79         u8 type_a, type_b;
80
81         status = acpi_get_sleep_type_data(sleep_state, &type_a, &type_b);
82         return ACPI_SUCCESS(status) && (!acpi_gbl_reduced_hardware
83                 || (acpi_gbl_FADT.sleep_control.address
84                         && acpi_gbl_FADT.sleep_status.address));
85 }
86
87 #ifdef CONFIG_ACPI_SLEEP
88 static u32 acpi_target_sleep_state = ACPI_STATE_S0;
89
90 u32 acpi_target_system_state(void)
91 {
92         return acpi_target_sleep_state;
93 }
94 EXPORT_SYMBOL_GPL(acpi_target_system_state);
95
96 static bool pwr_btn_event_pending;
97
98 /*
99  * The ACPI specification wants us to save NVS memory regions during hibernation
100  * and to restore them during the subsequent resume.  Windows does that also for
101  * suspend to RAM.  However, it is known that this mechanism does not work on
102  * all machines, so we allow the user to disable it with the help of the
103  * 'acpi_sleep=nonvs' kernel command line option.
104  */
105 static bool nvs_nosave;
106
107 void __init acpi_nvs_nosave(void)
108 {
109         nvs_nosave = true;
110 }
111
112 /*
113  * The ACPI specification wants us to save NVS memory regions during hibernation
114  * but says nothing about saving NVS during S3.  Not all versions of Windows
115  * save NVS on S3 suspend either, and it is clear that not all systems need
116  * NVS to be saved at S3 time.  To improve suspend/resume time, allow the
117  * user to disable saving NVS on S3 if their system does not require it, but
118  * continue to save/restore NVS for S4 as specified.
119  */
120 static bool nvs_nosave_s3;
121
122 void __init acpi_nvs_nosave_s3(void)
123 {
124         nvs_nosave_s3 = true;
125 }
126
127 /*
128  * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
129  * user to request that behavior by using the 'acpi_old_suspend_ordering'
130  * kernel command line option that causes the following variable to be set.
131  */
132 static bool old_suspend_ordering;
133
134 void __init acpi_old_suspend_ordering(void)
135 {
136         old_suspend_ordering = true;
137 }
138
139 static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
140 {
141         acpi_old_suspend_ordering();
142         return 0;
143 }
144
145 static int __init init_nvs_nosave(const struct dmi_system_id *d)
146 {
147         acpi_nvs_nosave();
148         return 0;
149 }
150
151 static struct dmi_system_id acpisleep_dmi_table[] __initdata = {
152         {
153         .callback = init_old_suspend_ordering,
154         .ident = "Abit KN9 (nForce4 variant)",
155         .matches = {
156                 DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"),
157                 DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"),
158                 },
159         },
160         {
161         .callback = init_old_suspend_ordering,
162         .ident = "HP xw4600 Workstation",
163         .matches = {
164                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
165                 DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"),
166                 },
167         },
168         {
169         .callback = init_old_suspend_ordering,
170         .ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
171         .matches = {
172                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."),
173                 DMI_MATCH(DMI_BOARD_NAME, "M2N8L"),
174                 },
175         },
176         {
177         .callback = init_old_suspend_ordering,
178         .ident = "Panasonic CF51-2L",
179         .matches = {
180                 DMI_MATCH(DMI_BOARD_VENDOR,
181                                 "Matsushita Electric Industrial Co.,Ltd."),
182                 DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
183                 },
184         },
185         {
186         .callback = init_nvs_nosave,
187         .ident = "Sony Vaio VGN-FW41E_H",
188         .matches = {
189                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
190                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW41E_H"),
191                 },
192         },
193         {
194         .callback = init_nvs_nosave,
195         .ident = "Sony Vaio VGN-FW21E",
196         .matches = {
197                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
198                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21E"),
199                 },
200         },
201         {
202         .callback = init_nvs_nosave,
203         .ident = "Sony Vaio VGN-FW21M",
204         .matches = {
205                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
206                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21M"),
207                 },
208         },
209         {
210         .callback = init_nvs_nosave,
211         .ident = "Sony Vaio VPCEB17FX",
212         .matches = {
213                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
214                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB17FX"),
215                 },
216         },
217         {
218         .callback = init_nvs_nosave,
219         .ident = "Sony Vaio VGN-SR11M",
220         .matches = {
221                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
222                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"),
223                 },
224         },
225         {
226         .callback = init_nvs_nosave,
227         .ident = "Everex StepNote Series",
228         .matches = {
229                 DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."),
230                 DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"),
231                 },
232         },
233         {
234         .callback = init_nvs_nosave,
235         .ident = "Sony Vaio VPCEB1Z1E",
236         .matches = {
237                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
238                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
239                 },
240         },
241         {
242         .callback = init_nvs_nosave,
243         .ident = "Sony Vaio VGN-NW130D",
244         .matches = {
245                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
246                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
247                 },
248         },
249         {
250         .callback = init_nvs_nosave,
251         .ident = "Sony Vaio VPCCW29FX",
252         .matches = {
253                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
254                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCCW29FX"),
255                 },
256         },
257         {
258         .callback = init_nvs_nosave,
259         .ident = "Averatec AV1020-ED2",
260         .matches = {
261                 DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
262                 DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
263                 },
264         },
265         {
266         .callback = init_old_suspend_ordering,
267         .ident = "Asus A8N-SLI DELUXE",
268         .matches = {
269                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
270                 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI DELUXE"),
271                 },
272         },
273         {
274         .callback = init_old_suspend_ordering,
275         .ident = "Asus A8N-SLI Premium",
276         .matches = {
277                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
278                 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI Premium"),
279                 },
280         },
281         {
282         .callback = init_nvs_nosave,
283         .ident = "Sony Vaio VGN-SR26GN_P",
284         .matches = {
285                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
286                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR26GN_P"),
287                 },
288         },
289         {
290         .callback = init_nvs_nosave,
291         .ident = "Sony Vaio VPCEB1S1E",
292         .matches = {
293                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
294                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1S1E"),
295                 },
296         },
297         {
298         .callback = init_nvs_nosave,
299         .ident = "Sony Vaio VGN-FW520F",
300         .matches = {
301                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
302                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW520F"),
303                 },
304         },
305         {
306         .callback = init_nvs_nosave,
307         .ident = "Asus K54C",
308         .matches = {
309                 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
310                 DMI_MATCH(DMI_PRODUCT_NAME, "K54C"),
311                 },
312         },
313         {
314         .callback = init_nvs_nosave,
315         .ident = "Asus K54HR",
316         .matches = {
317                 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
318                 DMI_MATCH(DMI_PRODUCT_NAME, "K54HR"),
319                 },
320         },
321         {},
322 };
323
324 static void acpi_sleep_dmi_check(void)
325 {
326         int year;
327
328         if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year >= 2012)
329                 acpi_nvs_nosave_s3();
330
331         dmi_check_system(acpisleep_dmi_table);
332 }
333
334 /**
335  * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
336  */
337 static int acpi_pm_freeze(void)
338 {
339         acpi_disable_all_gpes();
340         acpi_os_wait_events_complete();
341         acpi_ec_block_transactions();
342         return 0;
343 }
344
345 /**
346  * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
347  */
348 static int acpi_pm_pre_suspend(void)
349 {
350         acpi_pm_freeze();
351         return suspend_nvs_save();
352 }
353
354 /**
355  *      __acpi_pm_prepare - Prepare the platform to enter the target state.
356  *
357  *      If necessary, set the firmware waking vector and do arch-specific
358  *      nastiness to get the wakeup code to the waking vector.
359  */
360 static int __acpi_pm_prepare(void)
361 {
362         int error = acpi_sleep_prepare(acpi_target_sleep_state);
363         if (error)
364                 acpi_target_sleep_state = ACPI_STATE_S0;
365
366         return error;
367 }
368
369 /**
370  *      acpi_pm_prepare - Prepare the platform to enter the target sleep
371  *              state and disable the GPEs.
372  */
373 static int acpi_pm_prepare(void)
374 {
375         int error = __acpi_pm_prepare();
376         if (!error)
377                 error = acpi_pm_pre_suspend();
378
379         return error;
380 }
381
382 static int find_powerf_dev(struct device *dev, void *data)
383 {
384         struct acpi_device *device = to_acpi_device(dev);
385         const char *hid = acpi_device_hid(device);
386
387         return !strcmp(hid, ACPI_BUTTON_HID_POWERF);
388 }
389
390 /**
391  *      acpi_pm_finish - Instruct the platform to leave a sleep state.
392  *
393  *      This is called after we wake back up (or if entering the sleep state
394  *      failed).
395  */
396 static void acpi_pm_finish(void)
397 {
398         struct device *pwr_btn_dev;
399         u32 acpi_state = acpi_target_sleep_state;
400
401         acpi_ec_unblock_transactions();
402         suspend_nvs_free();
403
404         if (acpi_state == ACPI_STATE_S0)
405                 return;
406
407         printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
408                 acpi_state);
409         acpi_disable_wakeup_devices(acpi_state);
410         acpi_leave_sleep_state(acpi_state);
411
412         /* reset firmware waking vector */
413         acpi_set_firmware_waking_vector((acpi_physical_address) 0);
414
415         acpi_target_sleep_state = ACPI_STATE_S0;
416
417         acpi_resume_power_resources();
418
419         /* If we were woken with the fixed power button, provide a small
420          * hint to userspace in the form of a wakeup event on the fixed power
421          * button device (if it can be found).
422          *
423          * We delay the event generation til now, as the PM layer requires
424          * timekeeping to be running before we generate events. */
425         if (!pwr_btn_event_pending)
426                 return;
427
428         pwr_btn_event_pending = false;
429         pwr_btn_dev = bus_find_device(&acpi_bus_type, NULL, NULL,
430                                       find_powerf_dev);
431         if (pwr_btn_dev) {
432                 pm_wakeup_event(pwr_btn_dev, 0);
433                 put_device(pwr_btn_dev);
434         }
435 }
436
437 /**
438  * acpi_pm_start - Start system PM transition.
439  */
440 static void acpi_pm_start(u32 acpi_state)
441 {
442         acpi_target_sleep_state = acpi_state;
443         acpi_sleep_tts_switch(acpi_target_sleep_state);
444         acpi_scan_lock_acquire();
445 }
446
447 /**
448  * acpi_pm_end - Finish up system PM transition.
449  */
450 static void acpi_pm_end(void)
451 {
452         acpi_scan_lock_release();
453         /*
454          * This is necessary in case acpi_pm_finish() is not called during a
455          * failing transition to a sleep state.
456          */
457         acpi_target_sleep_state = ACPI_STATE_S0;
458         acpi_sleep_tts_switch(acpi_target_sleep_state);
459 }
460 #else /* !CONFIG_ACPI_SLEEP */
461 #define acpi_target_sleep_state ACPI_STATE_S0
462 static inline void acpi_sleep_dmi_check(void) {}
463 #endif /* CONFIG_ACPI_SLEEP */
464
465 #ifdef CONFIG_SUSPEND
466 static u32 acpi_suspend_states[] = {
467         [PM_SUSPEND_ON] = ACPI_STATE_S0,
468         [PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
469         [PM_SUSPEND_MEM] = ACPI_STATE_S3,
470         [PM_SUSPEND_MAX] = ACPI_STATE_S5
471 };
472
473 /**
474  *      acpi_suspend_begin - Set the target system sleep state to the state
475  *              associated with given @pm_state, if supported.
476  */
477 static int acpi_suspend_begin(suspend_state_t pm_state)
478 {
479         u32 acpi_state = acpi_suspend_states[pm_state];
480         int error;
481
482         error = (nvs_nosave || nvs_nosave_s3) ? 0 : suspend_nvs_alloc();
483         if (error)
484                 return error;
485
486         if (!sleep_states[acpi_state]) {
487                 pr_err("ACPI does not support sleep state S%u\n", acpi_state);
488                 return -ENOSYS;
489         }
490
491         acpi_pm_start(acpi_state);
492         return 0;
493 }
494
495 /**
496  *      acpi_suspend_enter - Actually enter a sleep state.
497  *      @pm_state: ignored
498  *
499  *      Flush caches and go to sleep. For STR we have to call arch-specific
500  *      assembly, which in turn call acpi_enter_sleep_state().
501  *      It's unfortunate, but it works. Please fix if you're feeling frisky.
502  */
503 static int acpi_suspend_enter(suspend_state_t pm_state)
504 {
505         acpi_status status = AE_OK;
506         u32 acpi_state = acpi_target_sleep_state;
507         int error;
508
509         ACPI_FLUSH_CPU_CACHE();
510
511         trace_suspend_resume(TPS("acpi_suspend"), acpi_state, true);
512         switch (acpi_state) {
513         case ACPI_STATE_S1:
514                 barrier();
515                 status = acpi_enter_sleep_state(acpi_state);
516                 break;
517
518         case ACPI_STATE_S3:
519                 if (!acpi_suspend_lowlevel)
520                         return -ENOSYS;
521                 error = acpi_suspend_lowlevel();
522                 if (error)
523                         return error;
524                 pr_info(PREFIX "Low-level resume complete\n");
525                 break;
526         }
527         trace_suspend_resume(TPS("acpi_suspend"), acpi_state, false);
528
529         /* This violates the spec but is required for bug compatibility. */
530         acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
531
532         /* Reprogram control registers */
533         acpi_leave_sleep_state_prep(acpi_state);
534
535         /* ACPI 3.0 specs (P62) says that it's the responsibility
536          * of the OSPM to clear the status bit [ implying that the
537          * POWER_BUTTON event should not reach userspace ]
538          *
539          * However, we do generate a small hint for userspace in the form of
540          * a wakeup event. We flag this condition for now and generate the
541          * event later, as we're currently too early in resume to be able to
542          * generate wakeup events.
543          */
544         if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) {
545                 acpi_event_status pwr_btn_status = ACPI_EVENT_FLAG_DISABLED;
546
547                 acpi_get_event_status(ACPI_EVENT_POWER_BUTTON, &pwr_btn_status);
548
549                 if (pwr_btn_status & ACPI_EVENT_FLAG_SET) {
550                         acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
551                         /* Flag for later */
552                         pwr_btn_event_pending = true;
553                 }
554         }
555
556         /*
557          * Disable and clear GPE status before interrupt is enabled. Some GPEs
558          * (like wakeup GPE) haven't handler, this can avoid such GPE misfire.
559          * acpi_leave_sleep_state will reenable specific GPEs later
560          */
561         acpi_disable_all_gpes();
562         /* Allow EC transactions to happen. */
563         acpi_ec_unblock_transactions_early();
564
565         suspend_nvs_restore();
566
567         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
568 }
569
570 static int acpi_suspend_state_valid(suspend_state_t pm_state)
571 {
572         u32 acpi_state;
573
574         switch (pm_state) {
575         case PM_SUSPEND_ON:
576         case PM_SUSPEND_STANDBY:
577         case PM_SUSPEND_MEM:
578                 acpi_state = acpi_suspend_states[pm_state];
579
580                 return sleep_states[acpi_state];
581         default:
582                 return 0;
583         }
584 }
585
586 static const struct platform_suspend_ops acpi_suspend_ops = {
587         .valid = acpi_suspend_state_valid,
588         .begin = acpi_suspend_begin,
589         .prepare_late = acpi_pm_prepare,
590         .enter = acpi_suspend_enter,
591         .wake = acpi_pm_finish,
592         .end = acpi_pm_end,
593 };
594
595 /**
596  *      acpi_suspend_begin_old - Set the target system sleep state to the
597  *              state associated with given @pm_state, if supported, and
598  *              execute the _PTS control method.  This function is used if the
599  *              pre-ACPI 2.0 suspend ordering has been requested.
600  */
601 static int acpi_suspend_begin_old(suspend_state_t pm_state)
602 {
603         int error = acpi_suspend_begin(pm_state);
604         if (!error)
605                 error = __acpi_pm_prepare();
606
607         return error;
608 }
609
610 /*
611  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
612  * been requested.
613  */
614 static const struct platform_suspend_ops acpi_suspend_ops_old = {
615         .valid = acpi_suspend_state_valid,
616         .begin = acpi_suspend_begin_old,
617         .prepare_late = acpi_pm_pre_suspend,
618         .enter = acpi_suspend_enter,
619         .wake = acpi_pm_finish,
620         .end = acpi_pm_end,
621         .recover = acpi_pm_finish,
622 };
623
624 static int acpi_freeze_begin(void)
625 {
626         acpi_scan_lock_acquire();
627         return 0;
628 }
629
630 static int acpi_freeze_prepare(void)
631 {
632         acpi_enable_all_wakeup_gpes();
633         enable_irq_wake(acpi_gbl_FADT.sci_interrupt);
634         return 0;
635 }
636
637 static void acpi_freeze_restore(void)
638 {
639         disable_irq_wake(acpi_gbl_FADT.sci_interrupt);
640         acpi_enable_all_runtime_gpes();
641 }
642
643 static void acpi_freeze_end(void)
644 {
645         acpi_scan_lock_release();
646 }
647
648 static const struct platform_freeze_ops acpi_freeze_ops = {
649         .begin = acpi_freeze_begin,
650         .prepare = acpi_freeze_prepare,
651         .restore = acpi_freeze_restore,
652         .end = acpi_freeze_end,
653 };
654
655 static void acpi_sleep_suspend_setup(void)
656 {
657         int i;
658
659         for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++)
660                 if (acpi_sleep_state_supported(i))
661                         sleep_states[i] = 1;
662
663         suspend_set_ops(old_suspend_ordering ?
664                 &acpi_suspend_ops_old : &acpi_suspend_ops);
665         freeze_set_ops(&acpi_freeze_ops);
666 }
667
668 #else /* !CONFIG_SUSPEND */
669 static inline void acpi_sleep_suspend_setup(void) {}
670 #endif /* !CONFIG_SUSPEND */
671
672 #ifdef CONFIG_HIBERNATION
673 static unsigned long s4_hardware_signature;
674 static struct acpi_table_facs *facs;
675 static bool nosigcheck;
676
677 void __init acpi_no_s4_hw_signature(void)
678 {
679         nosigcheck = true;
680 }
681
682 static int acpi_hibernation_begin(void)
683 {
684         int error;
685
686         error = nvs_nosave ? 0 : suspend_nvs_alloc();
687         if (!error)
688                 acpi_pm_start(ACPI_STATE_S4);
689
690         return error;
691 }
692
693 static int acpi_hibernation_enter(void)
694 {
695         acpi_status status = AE_OK;
696
697         ACPI_FLUSH_CPU_CACHE();
698
699         /* This shouldn't return.  If it returns, we have a problem */
700         status = acpi_enter_sleep_state(ACPI_STATE_S4);
701         /* Reprogram control registers */
702         acpi_leave_sleep_state_prep(ACPI_STATE_S4);
703
704         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
705 }
706
707 static void acpi_hibernation_leave(void)
708 {
709         /*
710          * If ACPI is not enabled by the BIOS and the boot kernel, we need to
711          * enable it here.
712          */
713         acpi_enable();
714         /* Reprogram control registers */
715         acpi_leave_sleep_state_prep(ACPI_STATE_S4);
716         /* Check the hardware signature */
717         if (facs && s4_hardware_signature != facs->hardware_signature)
718                 pr_crit("ACPI: Hardware changed while hibernated, success doubtful!\n");
719         /* Restore the NVS memory area */
720         suspend_nvs_restore();
721         /* Allow EC transactions to happen. */
722         acpi_ec_unblock_transactions_early();
723 }
724
725 static void acpi_pm_thaw(void)
726 {
727         acpi_ec_unblock_transactions();
728         acpi_enable_all_runtime_gpes();
729 }
730
731 static const struct platform_hibernation_ops acpi_hibernation_ops = {
732         .begin = acpi_hibernation_begin,
733         .end = acpi_pm_end,
734         .pre_snapshot = acpi_pm_prepare,
735         .finish = acpi_pm_finish,
736         .prepare = acpi_pm_prepare,
737         .enter = acpi_hibernation_enter,
738         .leave = acpi_hibernation_leave,
739         .pre_restore = acpi_pm_freeze,
740         .restore_cleanup = acpi_pm_thaw,
741 };
742
743 /**
744  *      acpi_hibernation_begin_old - Set the target system sleep state to
745  *              ACPI_STATE_S4 and execute the _PTS control method.  This
746  *              function is used if the pre-ACPI 2.0 suspend ordering has been
747  *              requested.
748  */
749 static int acpi_hibernation_begin_old(void)
750 {
751         int error;
752         /*
753          * The _TTS object should always be evaluated before the _PTS object.
754          * When the old_suspended_ordering is true, the _PTS object is
755          * evaluated in the acpi_sleep_prepare.
756          */
757         acpi_sleep_tts_switch(ACPI_STATE_S4);
758
759         error = acpi_sleep_prepare(ACPI_STATE_S4);
760
761         if (!error) {
762                 if (!nvs_nosave)
763                         error = suspend_nvs_alloc();
764                 if (!error) {
765                         acpi_target_sleep_state = ACPI_STATE_S4;
766                         acpi_scan_lock_acquire();
767                 }
768         }
769         return error;
770 }
771
772 /*
773  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
774  * been requested.
775  */
776 static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
777         .begin = acpi_hibernation_begin_old,
778         .end = acpi_pm_end,
779         .pre_snapshot = acpi_pm_pre_suspend,
780         .prepare = acpi_pm_freeze,
781         .finish = acpi_pm_finish,
782         .enter = acpi_hibernation_enter,
783         .leave = acpi_hibernation_leave,
784         .pre_restore = acpi_pm_freeze,
785         .restore_cleanup = acpi_pm_thaw,
786         .recover = acpi_pm_finish,
787 };
788
789 static void acpi_sleep_hibernate_setup(void)
790 {
791         if (!acpi_sleep_state_supported(ACPI_STATE_S4))
792                 return;
793
794         hibernation_set_ops(old_suspend_ordering ?
795                         &acpi_hibernation_ops_old : &acpi_hibernation_ops);
796         sleep_states[ACPI_STATE_S4] = 1;
797         if (nosigcheck)
798                 return;
799
800         acpi_get_table(ACPI_SIG_FACS, 1, (struct acpi_table_header **)&facs);
801         if (facs)
802                 s4_hardware_signature = facs->hardware_signature;
803 }
804 #else /* !CONFIG_HIBERNATION */
805 static inline void acpi_sleep_hibernate_setup(void) {}
806 #endif /* !CONFIG_HIBERNATION */
807
808 int acpi_suspend(u32 acpi_state)
809 {
810         suspend_state_t states[] = {
811                 [1] = PM_SUSPEND_STANDBY,
812                 [3] = PM_SUSPEND_MEM,
813                 [5] = PM_SUSPEND_MAX
814         };
815
816         if (acpi_state < 6 && states[acpi_state])
817                 return pm_suspend(states[acpi_state]);
818         if (acpi_state == 4)
819                 return hibernate();
820         return -EINVAL;
821 }
822
823 static void acpi_power_off_prepare(void)
824 {
825         /* Prepare to power off the system */
826         acpi_sleep_prepare(ACPI_STATE_S5);
827         acpi_disable_all_gpes();
828 }
829
830 static void acpi_power_off(void)
831 {
832         /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
833         printk(KERN_DEBUG "%s called\n", __func__);
834         local_irq_disable();
835         acpi_enter_sleep_state(ACPI_STATE_S5);
836 }
837
838 int __init acpi_sleep_init(void)
839 {
840         char supported[ACPI_S_STATE_COUNT * 3 + 1];
841         char *pos = supported;
842         int i;
843
844         acpi_sleep_dmi_check();
845
846         sleep_states[ACPI_STATE_S0] = 1;
847
848         acpi_sleep_suspend_setup();
849         acpi_sleep_hibernate_setup();
850
851         if (acpi_sleep_state_supported(ACPI_STATE_S5)) {
852                 sleep_states[ACPI_STATE_S5] = 1;
853                 pm_power_off_prepare = acpi_power_off_prepare;
854                 pm_power_off = acpi_power_off;
855         }
856
857         supported[0] = 0;
858         for (i = 0; i < ACPI_S_STATE_COUNT; i++) {
859                 if (sleep_states[i])
860                         pos += sprintf(pos, " S%d", i);
861         }
862         pr_info(PREFIX "(supports%s)\n", supported);
863
864         /*
865          * Register the tts_notifier to reboot notifier list so that the _TTS
866          * object can also be evaluated when the system enters S5.
867          */
868         register_reboot_notifier(&tts_notifier);
869         return 0;
870 }