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