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