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