Merge branch 'pm-acpi' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
[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  *      Return value: preferred power state of the device on success, -ENODEV on
720  *              failure (ie. if there's no 'struct acpi_device' for @dev)
721  *
722  *      Find the lowest power (highest number) ACPI device power state that
723  *      device @dev can be in while the system is in the sleep state represented
724  *      by %acpi_target_sleep_state.  If @wake is nonzero, the device should be
725  *      able to wake up the system from this sleep state.  If @d_min_p is set,
726  *      the highest power (lowest number) device power state of @dev allowed
727  *      in this system sleep state is stored at the location pointed to by it.
728  *
729  *      The caller must ensure that @dev is valid before using this function.
730  *      The caller is also responsible for figuring out if the device is
731  *      supposed to be able to wake up the system and passing this information
732  *      via @wake.
733  */
734
735 int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p)
736 {
737         acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
738         struct acpi_device *adev;
739         char acpi_method[] = "_SxD";
740         unsigned long long d_min, d_max;
741
742         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
743                 printk(KERN_DEBUG "ACPI handle has no context!\n");
744                 return -ENODEV;
745         }
746
747         acpi_method[2] = '0' + acpi_target_sleep_state;
748         /*
749          * If the sleep state is S0, we will return D3, but if the device has
750          * _S0W, we will use the value from _S0W
751          */
752         d_min = ACPI_STATE_D0;
753         d_max = ACPI_STATE_D3;
754
755         /*
756          * If present, _SxD methods return the minimum D-state (highest power
757          * state) we can use for the corresponding S-states.  Otherwise, the
758          * minimum D-state is D0 (ACPI 3.x).
759          *
760          * NOTE: We rely on acpi_evaluate_integer() not clobbering the integer
761          * provided -- that's our fault recovery, we ignore retval.
762          */
763         if (acpi_target_sleep_state > ACPI_STATE_S0)
764                 acpi_evaluate_integer(handle, acpi_method, NULL, &d_min);
765
766         /*
767          * If _PRW says we can wake up the system from the target sleep state,
768          * the D-state returned by _SxD is sufficient for that (we assume a
769          * wakeup-aware driver if wake is set).  Still, if _SxW exists
770          * (ACPI 3.x), it should return the maximum (lowest power) D-state that
771          * can wake the system.  _S0W may be valid, too.
772          */
773         if (acpi_target_sleep_state == ACPI_STATE_S0 ||
774             (device_may_wakeup(dev) && adev->wakeup.flags.valid &&
775              adev->wakeup.sleep_state >= acpi_target_sleep_state)) {
776                 acpi_status status;
777
778                 acpi_method[3] = 'W';
779                 status = acpi_evaluate_integer(handle, acpi_method, NULL,
780                                                 &d_max);
781                 if (ACPI_FAILURE(status)) {
782                         if (acpi_target_sleep_state != ACPI_STATE_S0 ||
783                             status != AE_NOT_FOUND)
784                                 d_max = d_min;
785                 } else if (d_max < d_min) {
786                         /* Warn the user of the broken DSDT */
787                         printk(KERN_WARNING "ACPI: Wrong value from %s\n",
788                                 acpi_method);
789                         /* Sanitize it */
790                         d_min = d_max;
791                 }
792         }
793
794         if (d_min_p)
795                 *d_min_p = d_min;
796         return d_max;
797 }
798 #endif /* CONFIG_PM */
799
800 #ifdef CONFIG_PM_SLEEP
801 /**
802  * acpi_pm_device_run_wake - Enable/disable wake-up for given device.
803  * @phys_dev: Device to enable/disable the platform to wake-up the system for.
804  * @enable: Whether enable or disable the wake-up functionality.
805  *
806  * Find the ACPI device object corresponding to @pci_dev and try to
807  * enable/disable the GPE associated with it.
808  */
809 int acpi_pm_device_run_wake(struct device *phys_dev, bool enable)
810 {
811         struct acpi_device *dev;
812         acpi_handle handle;
813
814         if (!device_run_wake(phys_dev))
815                 return -EINVAL;
816
817         handle = DEVICE_ACPI_HANDLE(phys_dev);
818         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &dev))) {
819                 dev_dbg(phys_dev, "ACPI handle has no context in %s!\n",
820                         __func__);
821                 return -ENODEV;
822         }
823
824         if (enable) {
825                 acpi_enable_wakeup_device_power(dev, ACPI_STATE_S0);
826                 acpi_enable_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number);
827         } else {
828                 acpi_disable_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number);
829                 acpi_disable_wakeup_device_power(dev);
830         }
831
832         return 0;
833 }
834
835 /**
836  *      acpi_pm_device_sleep_wake - enable or disable the system wake-up
837  *                                  capability of given device
838  *      @dev: device to handle
839  *      @enable: 'true' - enable, 'false' - disable the wake-up capability
840  */
841 int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
842 {
843         acpi_handle handle;
844         struct acpi_device *adev;
845         int error;
846
847         if (!device_can_wakeup(dev))
848                 return -EINVAL;
849
850         handle = DEVICE_ACPI_HANDLE(dev);
851         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
852                 dev_dbg(dev, "ACPI handle has no context in %s!\n", __func__);
853                 return -ENODEV;
854         }
855
856         error = enable ?
857                 acpi_enable_wakeup_device_power(adev, acpi_target_sleep_state) :
858                 acpi_disable_wakeup_device_power(adev);
859         if (!error)
860                 dev_info(dev, "wake-up capability %s by ACPI\n",
861                                 enable ? "enabled" : "disabled");
862
863         return error;
864 }
865 #endif  /* CONFIG_PM_SLEEP */
866
867 static void acpi_power_off_prepare(void)
868 {
869         /* Prepare to power off the system */
870         acpi_sleep_prepare(ACPI_STATE_S5);
871         acpi_disable_all_gpes();
872 }
873
874 static void acpi_power_off(void)
875 {
876         /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
877         printk(KERN_DEBUG "%s called\n", __func__);
878         local_irq_disable();
879         acpi_enter_sleep_state(ACPI_STATE_S5, wake_sleep_flags);
880 }
881
882 /*
883  * ACPI 2.0 created the optional _GTS and _BFS,
884  * but industry adoption has been neither rapid nor broad.
885  *
886  * Linux gets into trouble when it executes poorly validated
887  * paths through the BIOS, so disable _GTS and _BFS by default,
888  * but do speak up and offer the option to enable them.
889  */
890 static void __init acpi_gts_bfs_check(void)
891 {
892         acpi_handle dummy;
893
894         if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_PATHNAME__GTS, &dummy)))
895         {
896                 printk(KERN_NOTICE PREFIX "BIOS offers _GTS\n");
897                 printk(KERN_NOTICE PREFIX "If \"acpi.gts=1\" improves suspend, "
898                         "please notify linux-acpi@vger.kernel.org\n");
899         }
900         if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_PATHNAME__BFS, &dummy)))
901         {
902                 printk(KERN_NOTICE PREFIX "BIOS offers _BFS\n");
903                 printk(KERN_NOTICE PREFIX "If \"acpi.bfs=1\" improves resume, "
904                         "please notify linux-acpi@vger.kernel.org\n");
905         }
906 }
907
908 int __init acpi_sleep_init(void)
909 {
910         acpi_status status;
911         u8 type_a, type_b;
912 #ifdef CONFIG_SUSPEND
913         int i = 0;
914
915         dmi_check_system(acpisleep_dmi_table);
916 #endif
917
918         if (acpi_disabled)
919                 return 0;
920
921         sleep_states[ACPI_STATE_S0] = 1;
922         printk(KERN_INFO PREFIX "(supports S0");
923
924 #ifdef CONFIG_SUSPEND
925         for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++) {
926                 status = acpi_get_sleep_type_data(i, &type_a, &type_b);
927                 if (ACPI_SUCCESS(status)) {
928                         sleep_states[i] = 1;
929                         printk(KERN_CONT " S%d", i);
930                 }
931         }
932
933         suspend_set_ops(old_suspend_ordering ?
934                 &acpi_suspend_ops_old : &acpi_suspend_ops);
935 #endif
936
937 #ifdef CONFIG_HIBERNATION
938         status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b);
939         if (ACPI_SUCCESS(status)) {
940                 hibernation_set_ops(old_suspend_ordering ?
941                         &acpi_hibernation_ops_old : &acpi_hibernation_ops);
942                 sleep_states[ACPI_STATE_S4] = 1;
943                 printk(KERN_CONT " S4");
944                 if (!nosigcheck) {
945                         acpi_get_table(ACPI_SIG_FACS, 1,
946                                 (struct acpi_table_header **)&facs);
947                         if (facs)
948                                 s4_hardware_signature =
949                                         facs->hardware_signature;
950                 }
951         }
952 #endif
953         status = acpi_get_sleep_type_data(ACPI_STATE_S5, &type_a, &type_b);
954         if (ACPI_SUCCESS(status)) {
955                 sleep_states[ACPI_STATE_S5] = 1;
956                 printk(KERN_CONT " S5");
957                 pm_power_off_prepare = acpi_power_off_prepare;
958                 pm_power_off = acpi_power_off;
959         }
960         printk(KERN_CONT ")\n");
961         /*
962          * Register the tts_notifier to reboot notifier list so that the _TTS
963          * object can also be evaluated when the system enters S5.
964          */
965         register_reboot_notifier(&tts_notifier);
966         acpi_gts_bfs_check();
967         return 0;
968 }