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