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