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