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