]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/acpi/sleep.c
ACPI / PM: Introduce efi poweroff for HW-full platforms without _S5
[mirror_ubuntu-artful-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>
a8d46b9e 17#include <linux/interrupt.h>
1da177e4 18#include <linux/suspend.h>
e49f711c 19#include <linux/reboot.h>
d1ee4335 20#include <linux/acpi.h>
a2ef5c4f 21#include <linux/module.h>
504997cf 22#include <linux/syscore_ops.h>
f216cc37 23#include <asm/io.h>
bb3632c6 24#include <trace/events/power.h>
f216cc37 25
e60cc7a6 26#include "internal.h"
1da177e4
LT
27#include "sleep.h"
28
13737181
CY
29/*
30 * Some HW-full platforms do not have _S5, so they may need
31 * to leverage efi power off for a shutdown.
32 */
33bool acpi_no_s5;
01eac60b 34static u8 sleep_states[ACPI_S_STATE_COUNT];
1da177e4 35
e49f711c
ZY
36static void acpi_sleep_tts_switch(u32 acpi_state)
37{
0db98202 38 acpi_status status;
e49f711c 39
0db98202 40 status = acpi_execute_simple_method(NULL, "\\_TTS", acpi_state);
e49f711c
ZY
41 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
42 /*
43 * OS can't evaluate the _TTS object correctly. Some warning
44 * message will be printed. But it won't break anything.
45 */
46 printk(KERN_NOTICE "Failure in evaluating _TTS object\n");
47 }
48}
49
50static int tts_notify_reboot(struct notifier_block *this,
51 unsigned long code, void *x)
52{
53 acpi_sleep_tts_switch(ACPI_STATE_S5);
54 return NOTIFY_DONE;
55}
56
57static struct notifier_block tts_notifier = {
58 .notifier_call = tts_notify_reboot,
59 .next = NULL,
60 .priority = 0,
61};
62
c9b6c8f6 63static int acpi_sleep_prepare(u32 acpi_state)
2f3f2226
AS
64{
65#ifdef CONFIG_ACPI_SLEEP
66 /* do we have a wakeup address for S2 and S3? */
67 if (acpi_state == ACPI_STATE_S3) {
319b6ffc 68 if (!acpi_wakeup_address)
2f3f2226 69 return -EFAULT;
e3e9b577 70 acpi_set_waking_vector(acpi_wakeup_address);
2f3f2226
AS
71
72 }
73 ACPI_FLUSH_CPU_CACHE();
2f3f2226 74#endif
c9b6c8f6
RW
75 printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
76 acpi_state);
78f5f023 77 acpi_enable_wakeup_devices(acpi_state);
2f3f2226
AS
78 acpi_enter_sleep_state_prep(acpi_state);
79 return 0;
80}
81
a4e90bed
RW
82static bool acpi_sleep_state_supported(u8 sleep_state)
83{
84 acpi_status status;
85 u8 type_a, type_b;
86
87 status = acpi_get_sleep_type_data(sleep_state, &type_a, &type_b);
88 return ACPI_SUCCESS(status) && (!acpi_gbl_reduced_hardware
89 || (acpi_gbl_FADT.sleep_control.address
90 && acpi_gbl_FADT.sleep_status.address));
91}
92
5d1e072b 93#ifdef CONFIG_ACPI_SLEEP
091aad6a 94static u32 acpi_target_sleep_state = ACPI_STATE_S0;
a6ae7594
RW
95
96u32 acpi_target_system_state(void)
97{
98 return acpi_target_sleep_state;
99}
fad16dd9 100EXPORT_SYMBOL_GPL(acpi_target_system_state);
a6ae7594 101
a5ca7345 102static bool pwr_btn_event_pending;
091aad6a 103
72ad5d77
RW
104/*
105 * The ACPI specification wants us to save NVS memory regions during hibernation
106 * and to restore them during the subsequent resume. Windows does that also for
107 * suspend to RAM. However, it is known that this mechanism does not work on
108 * all machines, so we allow the user to disable it with the help of the
109 * 'acpi_sleep=nonvs' kernel command line option.
110 */
111static bool nvs_nosave;
112
113void __init acpi_nvs_nosave(void)
114{
115 nvs_nosave = true;
116}
117
1bad2f19
KCA
118/*
119 * The ACPI specification wants us to save NVS memory regions during hibernation
120 * but says nothing about saving NVS during S3. Not all versions of Windows
121 * save NVS on S3 suspend either, and it is clear that not all systems need
122 * NVS to be saved at S3 time. To improve suspend/resume time, allow the
123 * user to disable saving NVS on S3 if their system does not require it, but
124 * continue to save/restore NVS for S4 as specified.
125 */
126static bool nvs_nosave_s3;
127
128void __init acpi_nvs_nosave_s3(void)
129{
130 nvs_nosave_s3 = true;
131}
132
d8f3de0d
RW
133/*
134 * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
135 * user to request that behavior by using the 'acpi_old_suspend_ordering'
136 * kernel command line option that causes the following variable to be set.
137 */
138static bool old_suspend_ordering;
139
140void __init acpi_old_suspend_ordering(void)
141{
142 old_suspend_ordering = true;
143}
144
0ac1b1d7
ZR
145static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
146{
147 acpi_old_suspend_ordering();
148 return 0;
149}
150
151static int __init init_nvs_nosave(const struct dmi_system_id *d)
152{
153 acpi_nvs_nosave();
154 return 0;
155}
156
3e4376ff 157static struct dmi_system_id acpisleep_dmi_table[] __initdata = {
0ac1b1d7
ZR
158 {
159 .callback = init_old_suspend_ordering,
160 .ident = "Abit KN9 (nForce4 variant)",
161 .matches = {
162 DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"),
163 DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"),
164 },
165 },
166 {
167 .callback = init_old_suspend_ordering,
168 .ident = "HP xw4600 Workstation",
169 .matches = {
170 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
171 DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"),
172 },
173 },
174 {
175 .callback = init_old_suspend_ordering,
176 .ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
177 .matches = {
178 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."),
179 DMI_MATCH(DMI_BOARD_NAME, "M2N8L"),
180 },
181 },
182 {
183 .callback = init_old_suspend_ordering,
184 .ident = "Panasonic CF51-2L",
185 .matches = {
186 DMI_MATCH(DMI_BOARD_VENDOR,
187 "Matsushita Electric Industrial Co.,Ltd."),
188 DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
189 },
190 },
191 {
192 .callback = init_nvs_nosave,
66f2fda9
JS
193 .ident = "Sony Vaio VGN-FW41E_H",
194 .matches = {
195 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
196 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW41E_H"),
197 },
198 },
199 {
200 .callback = init_nvs_nosave,
0ac1b1d7
ZR
201 .ident = "Sony Vaio VGN-FW21E",
202 .matches = {
203 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
204 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21E"),
205 },
206 },
207 {
208 .callback = init_nvs_nosave,
469dd1c4
FV
209 .ident = "Sony Vaio VGN-FW21M",
210 .matches = {
211 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
212 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21M"),
213 },
214 },
215 {
216 .callback = init_nvs_nosave,
0ac1b1d7
ZR
217 .ident = "Sony Vaio VPCEB17FX",
218 .matches = {
219 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
220 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB17FX"),
221 },
222 },
223 {
224 .callback = init_nvs_nosave,
225 .ident = "Sony Vaio VGN-SR11M",
226 .matches = {
227 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
228 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"),
229 },
230 },
231 {
232 .callback = init_nvs_nosave,
233 .ident = "Everex StepNote Series",
234 .matches = {
235 DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."),
236 DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"),
237 },
238 },
239 {
240 .callback = init_nvs_nosave,
241 .ident = "Sony Vaio VPCEB1Z1E",
242 .matches = {
243 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
244 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
245 },
246 },
247 {
248 .callback = init_nvs_nosave,
249 .ident = "Sony Vaio VGN-NW130D",
250 .matches = {
251 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
252 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
253 },
254 },
255 {
256 .callback = init_nvs_nosave,
257 .ident = "Sony Vaio VPCCW29FX",
258 .matches = {
259 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
260 DMI_MATCH(DMI_PRODUCT_NAME, "VPCCW29FX"),
261 },
262 },
263 {
264 .callback = init_nvs_nosave,
265 .ident = "Averatec AV1020-ED2",
266 .matches = {
267 DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
268 DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
269 },
270 },
271 {
272 .callback = init_old_suspend_ordering,
273 .ident = "Asus A8N-SLI DELUXE",
274 .matches = {
275 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
276 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI DELUXE"),
277 },
278 },
279 {
280 .callback = init_old_suspend_ordering,
281 .ident = "Asus A8N-SLI Premium",
282 .matches = {
283 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
284 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI Premium"),
285 },
286 },
287 {
288 .callback = init_nvs_nosave,
289 .ident = "Sony Vaio VGN-SR26GN_P",
290 .matches = {
291 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
292 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR26GN_P"),
293 },
294 },
295 {
296 .callback = init_nvs_nosave,
297 .ident = "Sony Vaio VPCEB1S1E",
298 .matches = {
299 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
300 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1S1E"),
301 },
302 },
303 {
304 .callback = init_nvs_nosave,
305 .ident = "Sony Vaio VGN-FW520F",
306 .matches = {
307 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
308 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW520F"),
309 },
310 },
311 {
312 .callback = init_nvs_nosave,
313 .ident = "Asus K54C",
314 .matches = {
315 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
316 DMI_MATCH(DMI_PRODUCT_NAME, "K54C"),
317 },
318 },
319 {
320 .callback = init_nvs_nosave,
321 .ident = "Asus K54HR",
322 .matches = {
323 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
324 DMI_MATCH(DMI_PRODUCT_NAME, "K54HR"),
325 },
326 },
327 {},
328};
329
8b691c9c 330static void __init acpi_sleep_dmi_check(void)
0ac1b1d7 331{
821d6f03
LT
332 int year;
333
334 if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year >= 2012)
335 acpi_nvs_nosave_s3();
336
0ac1b1d7
ZR
337 dmi_check_system(acpisleep_dmi_table);
338}
339
d8f3de0d 340/**
d5a64513 341 * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
d8f3de0d 342 */
d5a64513 343static int acpi_pm_freeze(void)
d8f3de0d 344{
3d97e426 345 acpi_disable_all_gpes();
bd6f10a5 346 acpi_os_wait_events_complete();
fe955682 347 acpi_ec_block_transactions();
d8f3de0d
RW
348 return 0;
349}
350
c5f7a1bb
RW
351/**
352 * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
353 */
354static int acpi_pm_pre_suspend(void)
355{
356 acpi_pm_freeze();
26fcaf60 357 return suspend_nvs_save();
c5f7a1bb
RW
358}
359
d8f3de0d
RW
360/**
361 * __acpi_pm_prepare - Prepare the platform to enter the target state.
362 *
363 * If necessary, set the firmware waking vector and do arch-specific
364 * nastiness to get the wakeup code to the waking vector.
365 */
366static int __acpi_pm_prepare(void)
367{
368 int error = acpi_sleep_prepare(acpi_target_sleep_state);
d8f3de0d
RW
369 if (error)
370 acpi_target_sleep_state = ACPI_STATE_S0;
c5f7a1bb 371
d8f3de0d
RW
372 return error;
373}
374
375/**
376 * acpi_pm_prepare - Prepare the platform to enter the target sleep
377 * state and disable the GPEs.
378 */
379static int acpi_pm_prepare(void)
380{
381 int error = __acpi_pm_prepare();
d8f3de0d 382 if (!error)
26fcaf60 383 error = acpi_pm_pre_suspend();
d5a64513 384
d8f3de0d
RW
385 return error;
386}
387
c10d7a13
DD
388static int find_powerf_dev(struct device *dev, void *data)
389{
390 struct acpi_device *device = to_acpi_device(dev);
391 const char *hid = acpi_device_hid(device);
392
393 return !strcmp(hid, ACPI_BUTTON_HID_POWERF);
394}
395
d8f3de0d
RW
396/**
397 * acpi_pm_finish - Instruct the platform to leave a sleep state.
398 *
399 * This is called after we wake back up (or if entering the sleep state
400 * failed).
401 */
402static void acpi_pm_finish(void)
403{
c10d7a13 404 struct device *pwr_btn_dev;
d8f3de0d
RW
405 u32 acpi_state = acpi_target_sleep_state;
406
42de5532 407 acpi_ec_unblock_transactions();
d551d81d 408 suspend_nvs_free();
2a6b6976 409
d8f3de0d
RW
410 if (acpi_state == ACPI_STATE_S0)
411 return;
1da177e4 412
d8f3de0d
RW
413 printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
414 acpi_state);
78f5f023 415 acpi_disable_wakeup_devices(acpi_state);
d8f3de0d
RW
416 acpi_leave_sleep_state(acpi_state);
417
418 /* reset firmware waking vector */
e3e9b577 419 acpi_set_waking_vector(0);
d8f3de0d
RW
420
421 acpi_target_sleep_state = ACPI_STATE_S0;
c10d7a13 422
781d737c
RW
423 acpi_resume_power_resources();
424
c10d7a13
DD
425 /* If we were woken with the fixed power button, provide a small
426 * hint to userspace in the form of a wakeup event on the fixed power
427 * button device (if it can be found).
428 *
429 * We delay the event generation til now, as the PM layer requires
430 * timekeeping to be running before we generate events. */
431 if (!pwr_btn_event_pending)
432 return;
433
434 pwr_btn_event_pending = false;
435 pwr_btn_dev = bus_find_device(&acpi_bus_type, NULL, NULL,
436 find_powerf_dev);
437 if (pwr_btn_dev) {
438 pm_wakeup_event(pwr_btn_dev, 0);
439 put_device(pwr_btn_dev);
440 }
d8f3de0d
RW
441}
442
443/**
ad07277e
RW
444 * acpi_pm_start - Start system PM transition.
445 */
446static void acpi_pm_start(u32 acpi_state)
447{
448 acpi_target_sleep_state = acpi_state;
449 acpi_sleep_tts_switch(acpi_target_sleep_state);
450 acpi_scan_lock_acquire();
451}
452
453/**
454 * acpi_pm_end - Finish up system PM transition.
d8f3de0d
RW
455 */
456static void acpi_pm_end(void)
457{
ad07277e 458 acpi_scan_lock_release();
d8f3de0d
RW
459 /*
460 * This is necessary in case acpi_pm_finish() is not called during a
461 * failing transition to a sleep state.
462 */
463 acpi_target_sleep_state = ACPI_STATE_S0;
e49f711c 464 acpi_sleep_tts_switch(acpi_target_sleep_state);
d8f3de0d 465}
92daa7b5
RW
466#else /* !CONFIG_ACPI_SLEEP */
467#define acpi_target_sleep_state ACPI_STATE_S0
0ac1b1d7 468static inline void acpi_sleep_dmi_check(void) {}
5d1e072b 469#endif /* CONFIG_ACPI_SLEEP */
1da177e4 470
d8f3de0d 471#ifdef CONFIG_SUSPEND
1da177e4 472static u32 acpi_suspend_states[] = {
e2a5b420
AS
473 [PM_SUSPEND_ON] = ACPI_STATE_S0,
474 [PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
475 [PM_SUSPEND_MEM] = ACPI_STATE_S3,
e2a5b420 476 [PM_SUSPEND_MAX] = ACPI_STATE_S5
1da177e4
LT
477};
478
e9b3aba8 479/**
2c6e33c3 480 * acpi_suspend_begin - Set the target system sleep state to the state
e9b3aba8
RW
481 * associated with given @pm_state, if supported.
482 */
2c6e33c3 483static int acpi_suspend_begin(suspend_state_t pm_state)
e9b3aba8
RW
484{
485 u32 acpi_state = acpi_suspend_states[pm_state];
ad07277e 486 int error;
e9b3aba8 487
1bad2f19 488 error = (nvs_nosave || nvs_nosave_s3) ? 0 : suspend_nvs_alloc();
2a6b6976
MG
489 if (error)
490 return error;
491
ad07277e
RW
492 if (!sleep_states[acpi_state]) {
493 pr_err("ACPI does not support sleep state S%u\n", acpi_state);
494 return -ENOSYS;
e9b3aba8 495 }
ef25ba04
RW
496 if (acpi_state > ACPI_STATE_S1)
497 pm_set_suspend_via_firmware();
ad07277e
RW
498
499 acpi_pm_start(acpi_state);
500 return 0;
e9b3aba8
RW
501}
502
1da177e4 503/**
2c6e33c3 504 * acpi_suspend_enter - Actually enter a sleep state.
e9b3aba8 505 * @pm_state: ignored
1da177e4 506 *
50ad147a
RW
507 * Flush caches and go to sleep. For STR we have to call arch-specific
508 * assembly, which in turn call acpi_enter_sleep_state().
1da177e4
LT
509 * It's unfortunate, but it works. Please fix if you're feeling frisky.
510 */
2c6e33c3 511static int acpi_suspend_enter(suspend_state_t pm_state)
1da177e4
LT
512{
513 acpi_status status = AE_OK;
e9b3aba8 514 u32 acpi_state = acpi_target_sleep_state;
979f11b0 515 int error;
1da177e4
LT
516
517 ACPI_FLUSH_CPU_CACHE();
518
bb3632c6 519 trace_suspend_resume(TPS("acpi_suspend"), acpi_state, true);
e9b3aba8
RW
520 switch (acpi_state) {
521 case ACPI_STATE_S1:
1da177e4 522 barrier();
3f6f49c7 523 status = acpi_enter_sleep_state(acpi_state);
1da177e4
LT
524 break;
525
e9b3aba8 526 case ACPI_STATE_S3:
d6a77ead
KRW
527 if (!acpi_suspend_lowlevel)
528 return -ENOSYS;
f1a2003e 529 error = acpi_suspend_lowlevel();
979f11b0
RW
530 if (error)
531 return error;
7a63f08b 532 pr_info(PREFIX "Low-level resume complete\n");
ef25ba04 533 pm_set_resume_via_firmware();
1da177e4 534 break;
1da177e4 535 }
bb3632c6 536 trace_suspend_resume(TPS("acpi_suspend"), acpi_state, false);
872d83d0 537
b6dacf63
MG
538 /* This violates the spec but is required for bug compatibility. */
539 acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
65df7847 540
3f6f49c7
LB
541 /* Reprogram control registers */
542 acpi_leave_sleep_state_prep(acpi_state);
c95d47a8 543
23b168d4 544 /* ACPI 3.0 specs (P62) says that it's the responsibility
872d83d0
AP
545 * of the OSPM to clear the status bit [ implying that the
546 * POWER_BUTTON event should not reach userspace ]
c10d7a13
DD
547 *
548 * However, we do generate a small hint for userspace in the form of
549 * a wakeup event. We flag this condition for now and generate the
550 * event later, as we're currently too early in resume to be able to
551 * generate wakeup events.
872d83d0 552 */
c10d7a13 553 if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) {
51468a9d 554 acpi_event_status pwr_btn_status = ACPI_EVENT_FLAG_DISABLED;
c10d7a13
DD
555
556 acpi_get_event_status(ACPI_EVENT_POWER_BUTTON, &pwr_btn_status);
557
558 if (pwr_btn_status & ACPI_EVENT_FLAG_SET) {
559 acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
560 /* Flag for later */
561 pwr_btn_event_pending = true;
562 }
563 }
872d83d0 564
a3627f67
SL
565 /*
566 * Disable and clear GPE status before interrupt is enabled. Some GPEs
567 * (like wakeup GPE) haven't handler, this can avoid such GPE misfire.
568 * acpi_leave_sleep_state will reenable specific GPEs later
569 */
3d97e426 570 acpi_disable_all_gpes();
d5a64513 571 /* Allow EC transactions to happen. */
fe955682 572 acpi_ec_unblock_transactions_early();
a3627f67 573
2a6b6976
MG
574 suspend_nvs_restore();
575
1da177e4
LT
576 return ACPI_SUCCESS(status) ? 0 : -EFAULT;
577}
578
2c6e33c3 579static int acpi_suspend_state_valid(suspend_state_t pm_state)
eb9289eb 580{
e8c9c502 581 u32 acpi_state;
eb9289eb 582
e8c9c502
JB
583 switch (pm_state) {
584 case PM_SUSPEND_ON:
585 case PM_SUSPEND_STANDBY:
586 case PM_SUSPEND_MEM:
587 acpi_state = acpi_suspend_states[pm_state];
588
589 return sleep_states[acpi_state];
590 default:
591 return 0;
592 }
eb9289eb
SL
593}
594
2f55ac07 595static const struct platform_suspend_ops acpi_suspend_ops = {
2c6e33c3
LB
596 .valid = acpi_suspend_state_valid,
597 .begin = acpi_suspend_begin,
6a7c7eaf 598 .prepare_late = acpi_pm_prepare,
2c6e33c3 599 .enter = acpi_suspend_enter,
618d7fd0 600 .wake = acpi_pm_finish,
d8f3de0d
RW
601 .end = acpi_pm_end,
602};
603
604/**
605 * acpi_suspend_begin_old - Set the target system sleep state to the
606 * state associated with given @pm_state, if supported, and
607 * execute the _PTS control method. This function is used if the
608 * pre-ACPI 2.0 suspend ordering has been requested.
609 */
610static int acpi_suspend_begin_old(suspend_state_t pm_state)
611{
612 int error = acpi_suspend_begin(pm_state);
d8f3de0d
RW
613 if (!error)
614 error = __acpi_pm_prepare();
c5f7a1bb 615
d8f3de0d
RW
616 return error;
617}
618
619/*
620 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
621 * been requested.
622 */
2f55ac07 623static const struct platform_suspend_ops acpi_suspend_ops_old = {
d8f3de0d
RW
624 .valid = acpi_suspend_state_valid,
625 .begin = acpi_suspend_begin_old,
c5f7a1bb 626 .prepare_late = acpi_pm_pre_suspend,
2c6e33c3 627 .enter = acpi_suspend_enter,
618d7fd0 628 .wake = acpi_pm_finish,
d8f3de0d
RW
629 .end = acpi_pm_end,
630 .recover = acpi_pm_finish,
1da177e4 631};
02040f0b 632
1f0b6386
RW
633static int acpi_freeze_begin(void)
634{
635 acpi_scan_lock_acquire();
636 return 0;
637}
638
a8d46b9e
RW
639static int acpi_freeze_prepare(void)
640{
7b02ccea 641 acpi_enable_wakeup_devices(ACPI_STATE_S0);
a8d46b9e 642 acpi_enable_all_wakeup_gpes();
c52fa70c 643 acpi_os_wait_events_complete();
8c01275e
CY
644 if (acpi_sci_irq_valid())
645 enable_irq_wake(acpi_sci_irq);
a8d46b9e
RW
646 return 0;
647}
648
649static void acpi_freeze_restore(void)
650{
7b02ccea 651 acpi_disable_wakeup_devices(ACPI_STATE_S0);
8c01275e
CY
652 if (acpi_sci_irq_valid())
653 disable_irq_wake(acpi_sci_irq);
a8d46b9e
RW
654 acpi_enable_all_runtime_gpes();
655}
656
1f0b6386
RW
657static void acpi_freeze_end(void)
658{
659 acpi_scan_lock_release();
660}
661
662static const struct platform_freeze_ops acpi_freeze_ops = {
663 .begin = acpi_freeze_begin,
a8d46b9e
RW
664 .prepare = acpi_freeze_prepare,
665 .restore = acpi_freeze_restore,
1f0b6386
RW
666 .end = acpi_freeze_end,
667};
668
02040f0b
RW
669static void acpi_sleep_suspend_setup(void)
670{
671 int i;
672
a4e90bed
RW
673 for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++)
674 if (acpi_sleep_state_supported(i))
02040f0b 675 sleep_states[i] = 1;
02040f0b
RW
676
677 suspend_set_ops(old_suspend_ordering ?
678 &acpi_suspend_ops_old : &acpi_suspend_ops);
1f0b6386 679 freeze_set_ops(&acpi_freeze_ops);
02040f0b 680}
1f0b6386 681
02040f0b
RW
682#else /* !CONFIG_SUSPEND */
683static inline void acpi_sleep_suspend_setup(void) {}
684#endif /* !CONFIG_SUSPEND */
296699de 685
504997cf
SH
686#ifdef CONFIG_PM_SLEEP
687static u32 saved_bm_rld;
688
689static int acpi_save_bm_rld(void)
690{
691 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld);
692 return 0;
693}
694
695static void acpi_restore_bm_rld(void)
696{
697 u32 resumed_bm_rld = 0;
698
699 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld);
700 if (resumed_bm_rld == saved_bm_rld)
701 return;
702
703 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
704}
705
706static struct syscore_ops acpi_sleep_syscore_ops = {
707 .suspend = acpi_save_bm_rld,
708 .resume = acpi_restore_bm_rld,
709};
710
711void acpi_sleep_syscore_init(void)
712{
713 register_syscore_ops(&acpi_sleep_syscore_ops);
714}
715#else
716static inline void acpi_sleep_syscore_init(void) {}
717#endif /* CONFIG_PM_SLEEP */
718
b0cb1a19 719#ifdef CONFIG_HIBERNATION
bdfe6b7c
SL
720static unsigned long s4_hardware_signature;
721static struct acpi_table_facs *facs;
722static bool nosigcheck;
723
724void __init acpi_no_s4_hw_signature(void)
725{
726 nosigcheck = true;
727}
728
caea99ef 729static int acpi_hibernation_begin(void)
74f270af 730{
3f4b0ef7
RW
731 int error;
732
72ad5d77 733 error = nvs_nosave ? 0 : suspend_nvs_alloc();
ad07277e
RW
734 if (!error)
735 acpi_pm_start(ACPI_STATE_S4);
3f4b0ef7
RW
736
737 return error;
738}
739
a3d25c27
RW
740static int acpi_hibernation_enter(void)
741{
742 acpi_status status = AE_OK;
a3d25c27
RW
743
744 ACPI_FLUSH_CPU_CACHE();
745
a3d25c27 746 /* This shouldn't return. If it returns, we have a problem */
3f6f49c7
LB
747 status = acpi_enter_sleep_state(ACPI_STATE_S4);
748 /* Reprogram control registers */
749 acpi_leave_sleep_state_prep(ACPI_STATE_S4);
a3d25c27
RW
750
751 return ACPI_SUCCESS(status) ? 0 : -EFAULT;
752}
753
c7e0831d
RW
754static void acpi_hibernation_leave(void)
755{
fbda4b38 756 pm_set_resume_via_firmware();
c7e0831d
RW
757 /*
758 * If ACPI is not enabled by the BIOS and the boot kernel, we need to
759 * enable it here.
760 */
761 acpi_enable();
3f6f49c7
LB
762 /* Reprogram control registers */
763 acpi_leave_sleep_state_prep(ACPI_STATE_S4);
bdfe6b7c 764 /* Check the hardware signature */
5c551e62
ON
765 if (facs && s4_hardware_signature != facs->hardware_signature)
766 pr_crit("ACPI: Hardware changed while hibernated, success doubtful!\n");
3f4b0ef7 767 /* Restore the NVS memory area */
dd4c4f17 768 suspend_nvs_restore();
d5a64513 769 /* Allow EC transactions to happen. */
fe955682 770 acpi_ec_unblock_transactions_early();
c7e0831d
RW
771}
772
d5a64513 773static void acpi_pm_thaw(void)
f6bb13aa 774{
fe955682 775 acpi_ec_unblock_transactions();
3d97e426 776 acpi_enable_all_runtime_gpes();
a3d25c27
RW
777}
778
073ef1f6 779static const struct platform_hibernation_ops acpi_hibernation_ops = {
d8f3de0d
RW
780 .begin = acpi_hibernation_begin,
781 .end = acpi_pm_end,
c5f7a1bb 782 .pre_snapshot = acpi_pm_prepare,
2a6b6976 783 .finish = acpi_pm_finish,
d8f3de0d
RW
784 .prepare = acpi_pm_prepare,
785 .enter = acpi_hibernation_enter,
786 .leave = acpi_hibernation_leave,
d5a64513
RW
787 .pre_restore = acpi_pm_freeze,
788 .restore_cleanup = acpi_pm_thaw,
d8f3de0d 789};
caea99ef 790
d8f3de0d
RW
791/**
792 * acpi_hibernation_begin_old - Set the target system sleep state to
793 * ACPI_STATE_S4 and execute the _PTS control method. This
794 * function is used if the pre-ACPI 2.0 suspend ordering has been
795 * requested.
796 */
797static int acpi_hibernation_begin_old(void)
a634cc10 798{
e49f711c
ZY
799 int error;
800 /*
801 * The _TTS object should always be evaluated before the _PTS object.
802 * When the old_suspended_ordering is true, the _PTS object is
803 * evaluated in the acpi_sleep_prepare.
804 */
805 acpi_sleep_tts_switch(ACPI_STATE_S4);
806
807 error = acpi_sleep_prepare(ACPI_STATE_S4);
a634cc10 808
3f4b0ef7 809 if (!error) {
72ad5d77 810 if (!nvs_nosave)
dd4c4f17 811 error = suspend_nvs_alloc();
ad07277e 812 if (!error) {
3f4b0ef7 813 acpi_target_sleep_state = ACPI_STATE_S4;
ad07277e
RW
814 acpi_scan_lock_acquire();
815 }
3f4b0ef7
RW
816 }
817 return error;
818}
819
d8f3de0d
RW
820/*
821 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
822 * been requested.
823 */
073ef1f6 824static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
d8f3de0d
RW
825 .begin = acpi_hibernation_begin_old,
826 .end = acpi_pm_end,
c5f7a1bb 827 .pre_snapshot = acpi_pm_pre_suspend,
d5a64513 828 .prepare = acpi_pm_freeze,
2a6b6976 829 .finish = acpi_pm_finish,
a3d25c27 830 .enter = acpi_hibernation_enter,
c7e0831d 831 .leave = acpi_hibernation_leave,
d5a64513
RW
832 .pre_restore = acpi_pm_freeze,
833 .restore_cleanup = acpi_pm_thaw,
d8f3de0d 834 .recover = acpi_pm_finish,
a3d25c27 835};
02040f0b
RW
836
837static void acpi_sleep_hibernate_setup(void)
838{
a4e90bed 839 if (!acpi_sleep_state_supported(ACPI_STATE_S4))
02040f0b
RW
840 return;
841
842 hibernation_set_ops(old_suspend_ordering ?
843 &acpi_hibernation_ops_old : &acpi_hibernation_ops);
844 sleep_states[ACPI_STATE_S4] = 1;
02040f0b
RW
845 if (nosigcheck)
846 return;
847
848 acpi_get_table(ACPI_SIG_FACS, 1, (struct acpi_table_header **)&facs);
849 if (facs)
850 s4_hardware_signature = facs->hardware_signature;
851}
852#else /* !CONFIG_HIBERNATION */
853static inline void acpi_sleep_hibernate_setup(void) {}
854#endif /* !CONFIG_HIBERNATION */
a3d25c27 855
f216cc37
AS
856static void acpi_power_off_prepare(void)
857{
858 /* Prepare to power off the system */
859 acpi_sleep_prepare(ACPI_STATE_S5);
3d97e426 860 acpi_disable_all_gpes();
c52fa70c 861 acpi_os_wait_events_complete();
f216cc37
AS
862}
863
864static void acpi_power_off(void)
865{
866 /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
4d939155 867 printk(KERN_DEBUG "%s called\n", __func__);
f216cc37 868 local_irq_disable();
3f6f49c7 869 acpi_enter_sleep_state(ACPI_STATE_S5);
96f15efc
LB
870}
871
aafbcd16 872int __init acpi_sleep_init(void)
1da177e4 873{
ed4cf5b2
JP
874 char supported[ACPI_S_STATE_COUNT * 3 + 1];
875 char *pos = supported;
876 int i;
1da177e4 877
0ac1b1d7
ZR
878 acpi_sleep_dmi_check();
879
5a50fe70 880 sleep_states[ACPI_STATE_S0] = 1;
5a50fe70 881
504997cf 882 acpi_sleep_syscore_init();
02040f0b
RW
883 acpi_sleep_suspend_setup();
884 acpi_sleep_hibernate_setup();
1da177e4 885
a4e90bed 886 if (acpi_sleep_state_supported(ACPI_STATE_S5)) {
f216cc37 887 sleep_states[ACPI_STATE_S5] = 1;
f216cc37
AS
888 pm_power_off_prepare = acpi_power_off_prepare;
889 pm_power_off = acpi_power_off;
13737181
CY
890 } else {
891 acpi_no_s5 = true;
f216cc37 892 }
ed4cf5b2
JP
893
894 supported[0] = 0;
895 for (i = 0; i < ACPI_S_STATE_COUNT; i++) {
896 if (sleep_states[i])
897 pos += sprintf(pos, " S%d", i);
898 }
899 pr_info(PREFIX "(supports%s)\n", supported);
900
e49f711c
ZY
901 /*
902 * Register the tts_notifier to reboot notifier list so that the _TTS
903 * object can also be evaluated when the system enters S5.
904 */
905 register_reboot_notifier(&tts_notifier);
1da177e4
LT
906 return 0;
907}