xref: /openbmc/linux/drivers/acpi/sleep.c (revision 590b516e)
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 <linux/syscore_ops.h>
23 #include <asm/io.h>
24 #include <trace/events/power.h>
25 
26 #include "internal.h"
27 #include "sleep.h"
28 
29 /*
30  * Some HW-full platforms do not have _S5, so they may need
31  * to leverage efi power off for a shutdown.
32  */
33 bool acpi_no_s5;
34 static u8 sleep_states[ACPI_S_STATE_COUNT];
35 
36 static void acpi_sleep_tts_switch(u32 acpi_state)
37 {
38 	acpi_status status;
39 
40 	status = acpi_execute_simple_method(NULL, "\\_TTS", acpi_state);
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 
50 static 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 
57 static struct notifier_block tts_notifier = {
58 	.notifier_call	= tts_notify_reboot,
59 	.next		= NULL,
60 	.priority	= 0,
61 };
62 
63 static int acpi_sleep_prepare(u32 acpi_state)
64 {
65 #ifdef CONFIG_ACPI_SLEEP
66 	/* do we have a wakeup address for S2 and S3? */
67 	if (acpi_state == ACPI_STATE_S3) {
68 		if (!acpi_wakeup_address)
69 			return -EFAULT;
70 		acpi_set_waking_vector(acpi_wakeup_address);
71 
72 	}
73 	ACPI_FLUSH_CPU_CACHE();
74 #endif
75 	printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
76 		acpi_state);
77 	acpi_enable_wakeup_devices(acpi_state);
78 	acpi_enter_sleep_state_prep(acpi_state);
79 	return 0;
80 }
81 
82 static 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 
93 #ifdef CONFIG_ACPI_SLEEP
94 static u32 acpi_target_sleep_state = ACPI_STATE_S0;
95 
96 u32 acpi_target_system_state(void)
97 {
98 	return acpi_target_sleep_state;
99 }
100 EXPORT_SYMBOL_GPL(acpi_target_system_state);
101 
102 static bool pwr_btn_event_pending;
103 
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  */
111 static bool nvs_nosave;
112 
113 void __init acpi_nvs_nosave(void)
114 {
115 	nvs_nosave = true;
116 }
117 
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  */
126 static bool nvs_nosave_s3;
127 
128 void __init acpi_nvs_nosave_s3(void)
129 {
130 	nvs_nosave_s3 = true;
131 }
132 
133 static int __init init_nvs_save_s3(const struct dmi_system_id *d)
134 {
135 	nvs_nosave_s3 = false;
136 	return 0;
137 }
138 
139 /*
140  * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
141  * user to request that behavior by using the 'acpi_old_suspend_ordering'
142  * kernel command line option that causes the following variable to be set.
143  */
144 static bool old_suspend_ordering;
145 
146 void __init acpi_old_suspend_ordering(void)
147 {
148 	old_suspend_ordering = true;
149 }
150 
151 static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
152 {
153 	acpi_old_suspend_ordering();
154 	return 0;
155 }
156 
157 static int __init init_nvs_nosave(const struct dmi_system_id *d)
158 {
159 	acpi_nvs_nosave();
160 	return 0;
161 }
162 
163 static bool acpi_sleep_no_lps0;
164 
165 static int __init init_no_lps0(const struct dmi_system_id *d)
166 {
167 	acpi_sleep_no_lps0 = true;
168 	return 0;
169 }
170 
171 static const struct dmi_system_id acpisleep_dmi_table[] __initconst = {
172 	{
173 	.callback = init_old_suspend_ordering,
174 	.ident = "Abit KN9 (nForce4 variant)",
175 	.matches = {
176 		DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"),
177 		DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"),
178 		},
179 	},
180 	{
181 	.callback = init_old_suspend_ordering,
182 	.ident = "HP xw4600 Workstation",
183 	.matches = {
184 		DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
185 		DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"),
186 		},
187 	},
188 	{
189 	.callback = init_old_suspend_ordering,
190 	.ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
191 	.matches = {
192 		DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."),
193 		DMI_MATCH(DMI_BOARD_NAME, "M2N8L"),
194 		},
195 	},
196 	{
197 	.callback = init_old_suspend_ordering,
198 	.ident = "Panasonic CF51-2L",
199 	.matches = {
200 		DMI_MATCH(DMI_BOARD_VENDOR,
201 				"Matsushita Electric Industrial Co.,Ltd."),
202 		DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
203 		},
204 	},
205 	{
206 	.callback = init_nvs_nosave,
207 	.ident = "Sony Vaio VGN-FW41E_H",
208 	.matches = {
209 		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
210 		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW41E_H"),
211 		},
212 	},
213 	{
214 	.callback = init_nvs_nosave,
215 	.ident = "Sony Vaio VGN-FW21E",
216 	.matches = {
217 		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
218 		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21E"),
219 		},
220 	},
221 	{
222 	.callback = init_nvs_nosave,
223 	.ident = "Sony Vaio VGN-FW21M",
224 	.matches = {
225 		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
226 		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21M"),
227 		},
228 	},
229 	{
230 	.callback = init_nvs_nosave,
231 	.ident = "Sony Vaio VPCEB17FX",
232 	.matches = {
233 		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
234 		DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB17FX"),
235 		},
236 	},
237 	{
238 	.callback = init_nvs_nosave,
239 	.ident = "Sony Vaio VGN-SR11M",
240 	.matches = {
241 		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
242 		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"),
243 		},
244 	},
245 	{
246 	.callback = init_nvs_nosave,
247 	.ident = "Everex StepNote Series",
248 	.matches = {
249 		DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."),
250 		DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"),
251 		},
252 	},
253 	{
254 	.callback = init_nvs_nosave,
255 	.ident = "Sony Vaio VPCEB1Z1E",
256 	.matches = {
257 		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
258 		DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
259 		},
260 	},
261 	{
262 	.callback = init_nvs_nosave,
263 	.ident = "Sony Vaio VGN-NW130D",
264 	.matches = {
265 		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
266 		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
267 		},
268 	},
269 	{
270 	.callback = init_nvs_nosave,
271 	.ident = "Sony Vaio VPCCW29FX",
272 	.matches = {
273 		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
274 		DMI_MATCH(DMI_PRODUCT_NAME, "VPCCW29FX"),
275 		},
276 	},
277 	{
278 	.callback = init_nvs_nosave,
279 	.ident = "Averatec AV1020-ED2",
280 	.matches = {
281 		DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
282 		DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
283 		},
284 	},
285 	{
286 	.callback = init_old_suspend_ordering,
287 	.ident = "Asus A8N-SLI DELUXE",
288 	.matches = {
289 		DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
290 		DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI DELUXE"),
291 		},
292 	},
293 	{
294 	.callback = init_old_suspend_ordering,
295 	.ident = "Asus A8N-SLI Premium",
296 	.matches = {
297 		DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
298 		DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI Premium"),
299 		},
300 	},
301 	{
302 	.callback = init_nvs_nosave,
303 	.ident = "Sony Vaio VGN-SR26GN_P",
304 	.matches = {
305 		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
306 		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR26GN_P"),
307 		},
308 	},
309 	{
310 	.callback = init_nvs_nosave,
311 	.ident = "Sony Vaio VPCEB1S1E",
312 	.matches = {
313 		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
314 		DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1S1E"),
315 		},
316 	},
317 	{
318 	.callback = init_nvs_nosave,
319 	.ident = "Sony Vaio VGN-FW520F",
320 	.matches = {
321 		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
322 		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW520F"),
323 		},
324 	},
325 	{
326 	.callback = init_nvs_nosave,
327 	.ident = "Asus K54C",
328 	.matches = {
329 		DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
330 		DMI_MATCH(DMI_PRODUCT_NAME, "K54C"),
331 		},
332 	},
333 	{
334 	.callback = init_nvs_nosave,
335 	.ident = "Asus K54HR",
336 	.matches = {
337 		DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
338 		DMI_MATCH(DMI_PRODUCT_NAME, "K54HR"),
339 		},
340 	},
341 	{
342 	.callback = init_nvs_save_s3,
343 	.ident = "Asus 1025C",
344 	.matches = {
345 		DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
346 		DMI_MATCH(DMI_PRODUCT_NAME, "1025C"),
347 		},
348 	},
349 	/*
350 	 * https://bugzilla.kernel.org/show_bug.cgi?id=189431
351 	 * Lenovo G50-45 is a platform later than 2012, but needs nvs memory
352 	 * saving during S3.
353 	 */
354 	{
355 	.callback = init_nvs_save_s3,
356 	.ident = "Lenovo G50-45",
357 	.matches = {
358 		DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
359 		DMI_MATCH(DMI_PRODUCT_NAME, "80E3"),
360 		},
361 	},
362 	/*
363 	 * https://bugzilla.kernel.org/show_bug.cgi?id=196907
364 	 * Some Dell XPS13 9360 cannot do suspend-to-idle using the Low Power
365 	 * S0 Idle firmware interface.
366 	 */
367 	{
368 	.callback = init_no_lps0,
369 	.ident = "Dell XPS13 9360",
370 	.matches = {
371 		DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
372 		DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9360"),
373 		},
374 	},
375 	/*
376 	 * ThinkPad X1 Tablet(2016) cannot do suspend-to-idle using
377 	 * the Low Power S0 Idle firmware interface (see
378 	 * https://bugzilla.kernel.org/show_bug.cgi?id=199057).
379 	 */
380 	{
381 	.callback = init_no_lps0,
382 	.ident = "ThinkPad X1 Tablet(2016)",
383 	.matches = {
384 		DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
385 		DMI_MATCH(DMI_PRODUCT_NAME, "20GGA00L00"),
386 		},
387 	},
388 	{},
389 };
390 
391 static bool ignore_blacklist;
392 
393 void __init acpi_sleep_no_blacklist(void)
394 {
395 	ignore_blacklist = true;
396 }
397 
398 static void __init acpi_sleep_dmi_check(void)
399 {
400 	if (ignore_blacklist)
401 		return;
402 
403 	if (dmi_get_bios_year() >= 2012)
404 		acpi_nvs_nosave_s3();
405 
406 	dmi_check_system(acpisleep_dmi_table);
407 }
408 
409 /**
410  * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
411  */
412 static int acpi_pm_freeze(void)
413 {
414 	acpi_disable_all_gpes();
415 	acpi_os_wait_events_complete();
416 	acpi_ec_block_transactions();
417 	return 0;
418 }
419 
420 /**
421  * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
422  */
423 static int acpi_pm_pre_suspend(void)
424 {
425 	acpi_pm_freeze();
426 	return suspend_nvs_save();
427 }
428 
429 /**
430  *	__acpi_pm_prepare - Prepare the platform to enter the target state.
431  *
432  *	If necessary, set the firmware waking vector and do arch-specific
433  *	nastiness to get the wakeup code to the waking vector.
434  */
435 static int __acpi_pm_prepare(void)
436 {
437 	int error = acpi_sleep_prepare(acpi_target_sleep_state);
438 	if (error)
439 		acpi_target_sleep_state = ACPI_STATE_S0;
440 
441 	return error;
442 }
443 
444 /**
445  *	acpi_pm_prepare - Prepare the platform to enter the target sleep
446  *		state and disable the GPEs.
447  */
448 static int acpi_pm_prepare(void)
449 {
450 	int error = __acpi_pm_prepare();
451 	if (!error)
452 		error = acpi_pm_pre_suspend();
453 
454 	return error;
455 }
456 
457 static int find_powerf_dev(struct device *dev, void *data)
458 {
459 	struct acpi_device *device = to_acpi_device(dev);
460 	const char *hid = acpi_device_hid(device);
461 
462 	return !strcmp(hid, ACPI_BUTTON_HID_POWERF);
463 }
464 
465 /**
466  *	acpi_pm_finish - Instruct the platform to leave a sleep state.
467  *
468  *	This is called after we wake back up (or if entering the sleep state
469  *	failed).
470  */
471 static void acpi_pm_finish(void)
472 {
473 	struct device *pwr_btn_dev;
474 	u32 acpi_state = acpi_target_sleep_state;
475 
476 	acpi_ec_unblock_transactions();
477 	suspend_nvs_free();
478 
479 	if (acpi_state == ACPI_STATE_S0)
480 		return;
481 
482 	printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
483 		acpi_state);
484 	acpi_disable_wakeup_devices(acpi_state);
485 	acpi_leave_sleep_state(acpi_state);
486 
487 	/* reset firmware waking vector */
488 	acpi_set_waking_vector(0);
489 
490 	acpi_target_sleep_state = ACPI_STATE_S0;
491 
492 	acpi_resume_power_resources();
493 
494 	/* If we were woken with the fixed power button, provide a small
495 	 * hint to userspace in the form of a wakeup event on the fixed power
496 	 * button device (if it can be found).
497 	 *
498 	 * We delay the event generation til now, as the PM layer requires
499 	 * timekeeping to be running before we generate events. */
500 	if (!pwr_btn_event_pending)
501 		return;
502 
503 	pwr_btn_event_pending = false;
504 	pwr_btn_dev = bus_find_device(&acpi_bus_type, NULL, NULL,
505 				      find_powerf_dev);
506 	if (pwr_btn_dev) {
507 		pm_wakeup_event(pwr_btn_dev, 0);
508 		put_device(pwr_btn_dev);
509 	}
510 }
511 
512 /**
513  * acpi_pm_start - Start system PM transition.
514  */
515 static void acpi_pm_start(u32 acpi_state)
516 {
517 	acpi_target_sleep_state = acpi_state;
518 	acpi_sleep_tts_switch(acpi_target_sleep_state);
519 	acpi_scan_lock_acquire();
520 }
521 
522 /**
523  * acpi_pm_end - Finish up system PM transition.
524  */
525 static void acpi_pm_end(void)
526 {
527 	acpi_turn_off_unused_power_resources();
528 	acpi_scan_lock_release();
529 	/*
530 	 * This is necessary in case acpi_pm_finish() is not called during a
531 	 * failing transition to a sleep state.
532 	 */
533 	acpi_target_sleep_state = ACPI_STATE_S0;
534 	acpi_sleep_tts_switch(acpi_target_sleep_state);
535 }
536 #else /* !CONFIG_ACPI_SLEEP */
537 #define acpi_target_sleep_state	ACPI_STATE_S0
538 #define acpi_sleep_no_lps0	(false)
539 static inline void acpi_sleep_dmi_check(void) {}
540 #endif /* CONFIG_ACPI_SLEEP */
541 
542 #ifdef CONFIG_SUSPEND
543 static u32 acpi_suspend_states[] = {
544 	[PM_SUSPEND_ON] = ACPI_STATE_S0,
545 	[PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
546 	[PM_SUSPEND_MEM] = ACPI_STATE_S3,
547 	[PM_SUSPEND_MAX] = ACPI_STATE_S5
548 };
549 
550 /**
551  *	acpi_suspend_begin - Set the target system sleep state to the state
552  *		associated with given @pm_state, if supported.
553  */
554 static int acpi_suspend_begin(suspend_state_t pm_state)
555 {
556 	u32 acpi_state = acpi_suspend_states[pm_state];
557 	int error;
558 
559 	error = (nvs_nosave || nvs_nosave_s3) ? 0 : suspend_nvs_alloc();
560 	if (error)
561 		return error;
562 
563 	if (!sleep_states[acpi_state]) {
564 		pr_err("ACPI does not support sleep state S%u\n", acpi_state);
565 		return -ENOSYS;
566 	}
567 	if (acpi_state > ACPI_STATE_S1)
568 		pm_set_suspend_via_firmware();
569 
570 	acpi_pm_start(acpi_state);
571 	return 0;
572 }
573 
574 /**
575  *	acpi_suspend_enter - Actually enter a sleep state.
576  *	@pm_state: ignored
577  *
578  *	Flush caches and go to sleep. For STR we have to call arch-specific
579  *	assembly, which in turn call acpi_enter_sleep_state().
580  *	It's unfortunate, but it works. Please fix if you're feeling frisky.
581  */
582 static int acpi_suspend_enter(suspend_state_t pm_state)
583 {
584 	acpi_status status = AE_OK;
585 	u32 acpi_state = acpi_target_sleep_state;
586 	int error;
587 
588 	ACPI_FLUSH_CPU_CACHE();
589 
590 	trace_suspend_resume(TPS("acpi_suspend"), acpi_state, true);
591 	switch (acpi_state) {
592 	case ACPI_STATE_S1:
593 		barrier();
594 		status = acpi_enter_sleep_state(acpi_state);
595 		break;
596 
597 	case ACPI_STATE_S3:
598 		if (!acpi_suspend_lowlevel)
599 			return -ENOSYS;
600 		error = acpi_suspend_lowlevel();
601 		if (error)
602 			return error;
603 		pr_info(PREFIX "Low-level resume complete\n");
604 		pm_set_resume_via_firmware();
605 		break;
606 	}
607 	trace_suspend_resume(TPS("acpi_suspend"), acpi_state, false);
608 
609 	/* This violates the spec but is required for bug compatibility. */
610 	acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
611 
612 	/* Reprogram control registers */
613 	acpi_leave_sleep_state_prep(acpi_state);
614 
615 	/* ACPI 3.0 specs (P62) says that it's the responsibility
616 	 * of the OSPM to clear the status bit [ implying that the
617 	 * POWER_BUTTON event should not reach userspace ]
618 	 *
619 	 * However, we do generate a small hint for userspace in the form of
620 	 * a wakeup event. We flag this condition for now and generate the
621 	 * event later, as we're currently too early in resume to be able to
622 	 * generate wakeup events.
623 	 */
624 	if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) {
625 		acpi_event_status pwr_btn_status = ACPI_EVENT_FLAG_DISABLED;
626 
627 		acpi_get_event_status(ACPI_EVENT_POWER_BUTTON, &pwr_btn_status);
628 
629 		if (pwr_btn_status & ACPI_EVENT_FLAG_STATUS_SET) {
630 			acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
631 			/* Flag for later */
632 			pwr_btn_event_pending = true;
633 		}
634 	}
635 
636 	/*
637 	 * Disable and clear GPE status before interrupt is enabled. Some GPEs
638 	 * (like wakeup GPE) haven't handler, this can avoid such GPE misfire.
639 	 * acpi_leave_sleep_state will reenable specific GPEs later
640 	 */
641 	acpi_disable_all_gpes();
642 	/* Allow EC transactions to happen. */
643 	acpi_ec_unblock_transactions();
644 
645 	suspend_nvs_restore();
646 
647 	return ACPI_SUCCESS(status) ? 0 : -EFAULT;
648 }
649 
650 static int acpi_suspend_state_valid(suspend_state_t pm_state)
651 {
652 	u32 acpi_state;
653 
654 	switch (pm_state) {
655 	case PM_SUSPEND_ON:
656 	case PM_SUSPEND_STANDBY:
657 	case PM_SUSPEND_MEM:
658 		acpi_state = acpi_suspend_states[pm_state];
659 
660 		return sleep_states[acpi_state];
661 	default:
662 		return 0;
663 	}
664 }
665 
666 static const struct platform_suspend_ops acpi_suspend_ops = {
667 	.valid = acpi_suspend_state_valid,
668 	.begin = acpi_suspend_begin,
669 	.prepare_late = acpi_pm_prepare,
670 	.enter = acpi_suspend_enter,
671 	.wake = acpi_pm_finish,
672 	.end = acpi_pm_end,
673 };
674 
675 /**
676  *	acpi_suspend_begin_old - Set the target system sleep state to the
677  *		state associated with given @pm_state, if supported, and
678  *		execute the _PTS control method.  This function is used if the
679  *		pre-ACPI 2.0 suspend ordering has been requested.
680  */
681 static int acpi_suspend_begin_old(suspend_state_t pm_state)
682 {
683 	int error = acpi_suspend_begin(pm_state);
684 	if (!error)
685 		error = __acpi_pm_prepare();
686 
687 	return error;
688 }
689 
690 /*
691  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
692  * been requested.
693  */
694 static const struct platform_suspend_ops acpi_suspend_ops_old = {
695 	.valid = acpi_suspend_state_valid,
696 	.begin = acpi_suspend_begin_old,
697 	.prepare_late = acpi_pm_pre_suspend,
698 	.enter = acpi_suspend_enter,
699 	.wake = acpi_pm_finish,
700 	.end = acpi_pm_end,
701 	.recover = acpi_pm_finish,
702 };
703 
704 static bool s2idle_in_progress;
705 static bool s2idle_wakeup;
706 
707 /*
708  * On platforms supporting the Low Power S0 Idle interface there is an ACPI
709  * device object with the PNP0D80 compatible device ID (System Power Management
710  * Controller) and a specific _DSM method under it.  That method, if present,
711  * can be used to indicate to the platform that the OS is transitioning into a
712  * low-power state in which certain types of activity are not desirable or that
713  * it is leaving such a state, which allows the platform to adjust its operation
714  * mode accordingly.
715  */
716 static const struct acpi_device_id lps0_device_ids[] = {
717 	{"PNP0D80", },
718 	{"", },
719 };
720 
721 #define ACPI_LPS0_DSM_UUID	"c4eb40a0-6cd2-11e2-bcfd-0800200c9a66"
722 
723 #define ACPI_LPS0_GET_DEVICE_CONSTRAINTS	1
724 #define ACPI_LPS0_SCREEN_OFF	3
725 #define ACPI_LPS0_SCREEN_ON	4
726 #define ACPI_LPS0_ENTRY		5
727 #define ACPI_LPS0_EXIT		6
728 
729 static acpi_handle lps0_device_handle;
730 static guid_t lps0_dsm_guid;
731 static char lps0_dsm_func_mask;
732 
733 /* Device constraint entry structure */
734 struct lpi_device_info {
735 	char *name;
736 	int enabled;
737 	union acpi_object *package;
738 };
739 
740 /* Constraint package structure */
741 struct lpi_device_constraint {
742 	int uid;
743 	int min_dstate;
744 	int function_states;
745 };
746 
747 struct lpi_constraints {
748 	acpi_handle handle;
749 	int min_dstate;
750 };
751 
752 static struct lpi_constraints *lpi_constraints_table;
753 static int lpi_constraints_table_size;
754 
755 static void lpi_device_get_constraints(void)
756 {
757 	union acpi_object *out_obj;
758 	int i;
759 
760 	out_obj = acpi_evaluate_dsm_typed(lps0_device_handle, &lps0_dsm_guid,
761 					  1, ACPI_LPS0_GET_DEVICE_CONSTRAINTS,
762 					  NULL, ACPI_TYPE_PACKAGE);
763 
764 	acpi_handle_debug(lps0_device_handle, "_DSM function 1 eval %s\n",
765 			  out_obj ? "successful" : "failed");
766 
767 	if (!out_obj)
768 		return;
769 
770 	lpi_constraints_table = kcalloc(out_obj->package.count,
771 					sizeof(*lpi_constraints_table),
772 					GFP_KERNEL);
773 	if (!lpi_constraints_table)
774 		goto free_acpi_buffer;
775 
776 	acpi_handle_debug(lps0_device_handle, "LPI: constraints list begin:\n");
777 
778 	for (i = 0; i < out_obj->package.count; i++) {
779 		struct lpi_constraints *constraint;
780 		acpi_status status;
781 		union acpi_object *package = &out_obj->package.elements[i];
782 		struct lpi_device_info info = { };
783 		int package_count = 0, j;
784 
785 		if (!package)
786 			continue;
787 
788 		for (j = 0; j < package->package.count; ++j) {
789 			union acpi_object *element =
790 					&(package->package.elements[j]);
791 
792 			switch (element->type) {
793 			case ACPI_TYPE_INTEGER:
794 				info.enabled = element->integer.value;
795 				break;
796 			case ACPI_TYPE_STRING:
797 				info.name = element->string.pointer;
798 				break;
799 			case ACPI_TYPE_PACKAGE:
800 				package_count = element->package.count;
801 				info.package = element->package.elements;
802 				break;
803 			}
804 		}
805 
806 		if (!info.enabled || !info.package || !info.name)
807 			continue;
808 
809 		constraint = &lpi_constraints_table[lpi_constraints_table_size];
810 
811 		status = acpi_get_handle(NULL, info.name, &constraint->handle);
812 		if (ACPI_FAILURE(status))
813 			continue;
814 
815 		acpi_handle_debug(lps0_device_handle,
816 				  "index:%d Name:%s\n", i, info.name);
817 
818 		constraint->min_dstate = -1;
819 
820 		for (j = 0; j < package_count; ++j) {
821 			union acpi_object *info_obj = &info.package[j];
822 			union acpi_object *cnstr_pkg;
823 			union acpi_object *obj;
824 			struct lpi_device_constraint dev_info;
825 
826 			switch (info_obj->type) {
827 			case ACPI_TYPE_INTEGER:
828 				/* version */
829 				break;
830 			case ACPI_TYPE_PACKAGE:
831 				if (info_obj->package.count < 2)
832 					break;
833 
834 				cnstr_pkg = info_obj->package.elements;
835 				obj = &cnstr_pkg[0];
836 				dev_info.uid = obj->integer.value;
837 				obj = &cnstr_pkg[1];
838 				dev_info.min_dstate = obj->integer.value;
839 
840 				acpi_handle_debug(lps0_device_handle,
841 					"uid:%d min_dstate:%s\n",
842 					dev_info.uid,
843 					acpi_power_state_string(dev_info.min_dstate));
844 
845 				constraint->min_dstate = dev_info.min_dstate;
846 				break;
847 			}
848 		}
849 
850 		if (constraint->min_dstate < 0) {
851 			acpi_handle_debug(lps0_device_handle,
852 					  "Incomplete constraint defined\n");
853 			continue;
854 		}
855 
856 		lpi_constraints_table_size++;
857 	}
858 
859 	acpi_handle_debug(lps0_device_handle, "LPI: constraints list end\n");
860 
861 free_acpi_buffer:
862 	ACPI_FREE(out_obj);
863 }
864 
865 static void lpi_check_constraints(void)
866 {
867 	int i;
868 
869 	for (i = 0; i < lpi_constraints_table_size; ++i) {
870 		acpi_handle handle = lpi_constraints_table[i].handle;
871 		struct acpi_device *adev;
872 
873 		if (!handle || acpi_bus_get_device(handle, &adev))
874 			continue;
875 
876 		acpi_handle_debug(handle,
877 			"LPI: required min power state:%s current power state:%s\n",
878 			acpi_power_state_string(lpi_constraints_table[i].min_dstate),
879 			acpi_power_state_string(adev->power.state));
880 
881 		if (!adev->flags.power_manageable) {
882 			acpi_handle_info(handle, "LPI: Device not power manageable\n");
883 			lpi_constraints_table[i].handle = NULL;
884 			continue;
885 		}
886 
887 		if (adev->power.state < lpi_constraints_table[i].min_dstate)
888 			acpi_handle_info(handle,
889 				"LPI: Constraint not met; min power state:%s current power state:%s\n",
890 				acpi_power_state_string(lpi_constraints_table[i].min_dstate),
891 				acpi_power_state_string(adev->power.state));
892 	}
893 }
894 
895 static void acpi_sleep_run_lps0_dsm(unsigned int func)
896 {
897 	union acpi_object *out_obj;
898 
899 	if (!(lps0_dsm_func_mask & (1 << func)))
900 		return;
901 
902 	out_obj = acpi_evaluate_dsm(lps0_device_handle, &lps0_dsm_guid, 1, func, NULL);
903 	ACPI_FREE(out_obj);
904 
905 	acpi_handle_debug(lps0_device_handle, "_DSM function %u evaluation %s\n",
906 			  func, out_obj ? "successful" : "failed");
907 }
908 
909 static int lps0_device_attach(struct acpi_device *adev,
910 			      const struct acpi_device_id *not_used)
911 {
912 	union acpi_object *out_obj;
913 
914 	if (lps0_device_handle)
915 		return 0;
916 
917 	if (acpi_sleep_no_lps0) {
918 		acpi_handle_info(adev->handle,
919 				 "Low Power S0 Idle interface disabled\n");
920 		return 0;
921 	}
922 
923 	if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0))
924 		return 0;
925 
926 	guid_parse(ACPI_LPS0_DSM_UUID, &lps0_dsm_guid);
927 	/* Check if the _DSM is present and as expected. */
928 	out_obj = acpi_evaluate_dsm(adev->handle, &lps0_dsm_guid, 1, 0, NULL);
929 	if (out_obj && out_obj->type == ACPI_TYPE_BUFFER) {
930 		char bitmask = *(char *)out_obj->buffer.pointer;
931 
932 		lps0_dsm_func_mask = bitmask;
933 		lps0_device_handle = adev->handle;
934 		/*
935 		 * Use suspend-to-idle by default if the default
936 		 * suspend mode was not set from the command line.
937 		 */
938 		if (mem_sleep_default > PM_SUSPEND_MEM)
939 			mem_sleep_current = PM_SUSPEND_TO_IDLE;
940 
941 		acpi_handle_debug(adev->handle, "_DSM function mask: 0x%x\n",
942 				  bitmask);
943 	} else {
944 		acpi_handle_debug(adev->handle,
945 				  "_DSM function 0 evaluation failed\n");
946 	}
947 	ACPI_FREE(out_obj);
948 
949 	lpi_device_get_constraints();
950 
951 	return 0;
952 }
953 
954 static struct acpi_scan_handler lps0_handler = {
955 	.ids = lps0_device_ids,
956 	.attach = lps0_device_attach,
957 };
958 
959 static int acpi_s2idle_begin(void)
960 {
961 	acpi_scan_lock_acquire();
962 	s2idle_in_progress = true;
963 	return 0;
964 }
965 
966 static int acpi_s2idle_prepare(void)
967 {
968 	if (lps0_device_handle) {
969 		acpi_sleep_run_lps0_dsm(ACPI_LPS0_SCREEN_OFF);
970 		acpi_sleep_run_lps0_dsm(ACPI_LPS0_ENTRY);
971 	}
972 
973 	if (acpi_sci_irq_valid())
974 		enable_irq_wake(acpi_sci_irq);
975 
976 	return 0;
977 }
978 
979 static void acpi_s2idle_wake(void)
980 {
981 
982 	if (pm_debug_messages_on)
983 		lpi_check_constraints();
984 
985 	/*
986 	 * If IRQD_WAKEUP_ARMED is not set for the SCI at this point, it means
987 	 * that the SCI has triggered while suspended, so cancel the wakeup in
988 	 * case it has not been a wakeup event (the GPEs will be checked later).
989 	 */
990 	if (acpi_sci_irq_valid() &&
991 	    !irqd_is_wakeup_armed(irq_get_irq_data(acpi_sci_irq))) {
992 		pm_system_cancel_wakeup();
993 		s2idle_wakeup = true;
994 		/*
995 		 * On some platforms with the LPS0 _DSM device noirq resume
996 		 * takes too much time for EC wakeup events to survive, so look
997 		 * for them now.
998 		 */
999 		if (lps0_device_handle)
1000 			acpi_ec_dispatch_gpe();
1001 	}
1002 }
1003 
1004 static void acpi_s2idle_sync(void)
1005 {
1006 	/*
1007 	 * Process all pending events in case there are any wakeup ones.
1008 	 *
1009 	 * The EC driver uses the system workqueue and an additional special
1010 	 * one, so those need to be flushed too.
1011 	 */
1012 	acpi_os_wait_events_complete();	/* synchronize SCI IRQ handling */
1013 	acpi_ec_flush_work();
1014 	acpi_os_wait_events_complete();	/* synchronize Notify handling */
1015 	s2idle_wakeup = false;
1016 }
1017 
1018 static void acpi_s2idle_restore(void)
1019 {
1020 	if (acpi_sci_irq_valid())
1021 		disable_irq_wake(acpi_sci_irq);
1022 
1023 	if (lps0_device_handle) {
1024 		acpi_sleep_run_lps0_dsm(ACPI_LPS0_EXIT);
1025 		acpi_sleep_run_lps0_dsm(ACPI_LPS0_SCREEN_ON);
1026 	}
1027 }
1028 
1029 static void acpi_s2idle_end(void)
1030 {
1031 	s2idle_in_progress = false;
1032 	acpi_scan_lock_release();
1033 }
1034 
1035 static const struct platform_s2idle_ops acpi_s2idle_ops = {
1036 	.begin = acpi_s2idle_begin,
1037 	.prepare = acpi_s2idle_prepare,
1038 	.wake = acpi_s2idle_wake,
1039 	.sync = acpi_s2idle_sync,
1040 	.restore = acpi_s2idle_restore,
1041 	.end = acpi_s2idle_end,
1042 };
1043 
1044 static void acpi_sleep_suspend_setup(void)
1045 {
1046 	int i;
1047 
1048 	for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++)
1049 		if (acpi_sleep_state_supported(i))
1050 			sleep_states[i] = 1;
1051 
1052 	suspend_set_ops(old_suspend_ordering ?
1053 		&acpi_suspend_ops_old : &acpi_suspend_ops);
1054 
1055 	acpi_scan_add_handler(&lps0_handler);
1056 	s2idle_set_ops(&acpi_s2idle_ops);
1057 }
1058 
1059 #else /* !CONFIG_SUSPEND */
1060 #define s2idle_in_progress	(false)
1061 #define s2idle_wakeup		(false)
1062 #define lps0_device_handle	(NULL)
1063 static inline void acpi_sleep_suspend_setup(void) {}
1064 #endif /* !CONFIG_SUSPEND */
1065 
1066 bool acpi_s2idle_wakeup(void)
1067 {
1068 	return s2idle_wakeup;
1069 }
1070 
1071 bool acpi_sleep_no_ec_events(void)
1072 {
1073 	return !s2idle_in_progress || !lps0_device_handle;
1074 }
1075 
1076 #ifdef CONFIG_PM_SLEEP
1077 static u32 saved_bm_rld;
1078 
1079 static int  acpi_save_bm_rld(void)
1080 {
1081 	acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld);
1082 	return 0;
1083 }
1084 
1085 static void  acpi_restore_bm_rld(void)
1086 {
1087 	u32 resumed_bm_rld = 0;
1088 
1089 	acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld);
1090 	if (resumed_bm_rld == saved_bm_rld)
1091 		return;
1092 
1093 	acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
1094 }
1095 
1096 static struct syscore_ops acpi_sleep_syscore_ops = {
1097 	.suspend = acpi_save_bm_rld,
1098 	.resume = acpi_restore_bm_rld,
1099 };
1100 
1101 static void acpi_sleep_syscore_init(void)
1102 {
1103 	register_syscore_ops(&acpi_sleep_syscore_ops);
1104 }
1105 #else
1106 static inline void acpi_sleep_syscore_init(void) {}
1107 #endif /* CONFIG_PM_SLEEP */
1108 
1109 #ifdef CONFIG_HIBERNATION
1110 static unsigned long s4_hardware_signature;
1111 static struct acpi_table_facs *facs;
1112 static bool nosigcheck;
1113 
1114 void __init acpi_no_s4_hw_signature(void)
1115 {
1116 	nosigcheck = true;
1117 }
1118 
1119 static int acpi_hibernation_begin(void)
1120 {
1121 	int error;
1122 
1123 	error = nvs_nosave ? 0 : suspend_nvs_alloc();
1124 	if (!error)
1125 		acpi_pm_start(ACPI_STATE_S4);
1126 
1127 	return error;
1128 }
1129 
1130 static int acpi_hibernation_enter(void)
1131 {
1132 	acpi_status status = AE_OK;
1133 
1134 	ACPI_FLUSH_CPU_CACHE();
1135 
1136 	/* This shouldn't return.  If it returns, we have a problem */
1137 	status = acpi_enter_sleep_state(ACPI_STATE_S4);
1138 	/* Reprogram control registers */
1139 	acpi_leave_sleep_state_prep(ACPI_STATE_S4);
1140 
1141 	return ACPI_SUCCESS(status) ? 0 : -EFAULT;
1142 }
1143 
1144 static void acpi_hibernation_leave(void)
1145 {
1146 	pm_set_resume_via_firmware();
1147 	/*
1148 	 * If ACPI is not enabled by the BIOS and the boot kernel, we need to
1149 	 * enable it here.
1150 	 */
1151 	acpi_enable();
1152 	/* Reprogram control registers */
1153 	acpi_leave_sleep_state_prep(ACPI_STATE_S4);
1154 	/* Check the hardware signature */
1155 	if (facs && s4_hardware_signature != facs->hardware_signature)
1156 		pr_crit("ACPI: Hardware changed while hibernated, success doubtful!\n");
1157 	/* Restore the NVS memory area */
1158 	suspend_nvs_restore();
1159 	/* Allow EC transactions to happen. */
1160 	acpi_ec_unblock_transactions();
1161 }
1162 
1163 static void acpi_pm_thaw(void)
1164 {
1165 	acpi_ec_unblock_transactions();
1166 	acpi_enable_all_runtime_gpes();
1167 }
1168 
1169 static const struct platform_hibernation_ops acpi_hibernation_ops = {
1170 	.begin = acpi_hibernation_begin,
1171 	.end = acpi_pm_end,
1172 	.pre_snapshot = acpi_pm_prepare,
1173 	.finish = acpi_pm_finish,
1174 	.prepare = acpi_pm_prepare,
1175 	.enter = acpi_hibernation_enter,
1176 	.leave = acpi_hibernation_leave,
1177 	.pre_restore = acpi_pm_freeze,
1178 	.restore_cleanup = acpi_pm_thaw,
1179 };
1180 
1181 /**
1182  *	acpi_hibernation_begin_old - Set the target system sleep state to
1183  *		ACPI_STATE_S4 and execute the _PTS control method.  This
1184  *		function is used if the pre-ACPI 2.0 suspend ordering has been
1185  *		requested.
1186  */
1187 static int acpi_hibernation_begin_old(void)
1188 {
1189 	int error;
1190 	/*
1191 	 * The _TTS object should always be evaluated before the _PTS object.
1192 	 * When the old_suspended_ordering is true, the _PTS object is
1193 	 * evaluated in the acpi_sleep_prepare.
1194 	 */
1195 	acpi_sleep_tts_switch(ACPI_STATE_S4);
1196 
1197 	error = acpi_sleep_prepare(ACPI_STATE_S4);
1198 
1199 	if (!error) {
1200 		if (!nvs_nosave)
1201 			error = suspend_nvs_alloc();
1202 		if (!error) {
1203 			acpi_target_sleep_state = ACPI_STATE_S4;
1204 			acpi_scan_lock_acquire();
1205 		}
1206 	}
1207 	return error;
1208 }
1209 
1210 /*
1211  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
1212  * been requested.
1213  */
1214 static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
1215 	.begin = acpi_hibernation_begin_old,
1216 	.end = acpi_pm_end,
1217 	.pre_snapshot = acpi_pm_pre_suspend,
1218 	.prepare = acpi_pm_freeze,
1219 	.finish = acpi_pm_finish,
1220 	.enter = acpi_hibernation_enter,
1221 	.leave = acpi_hibernation_leave,
1222 	.pre_restore = acpi_pm_freeze,
1223 	.restore_cleanup = acpi_pm_thaw,
1224 	.recover = acpi_pm_finish,
1225 };
1226 
1227 static void acpi_sleep_hibernate_setup(void)
1228 {
1229 	if (!acpi_sleep_state_supported(ACPI_STATE_S4))
1230 		return;
1231 
1232 	hibernation_set_ops(old_suspend_ordering ?
1233 			&acpi_hibernation_ops_old : &acpi_hibernation_ops);
1234 	sleep_states[ACPI_STATE_S4] = 1;
1235 	if (nosigcheck)
1236 		return;
1237 
1238 	acpi_get_table(ACPI_SIG_FACS, 1, (struct acpi_table_header **)&facs);
1239 	if (facs)
1240 		s4_hardware_signature = facs->hardware_signature;
1241 }
1242 #else /* !CONFIG_HIBERNATION */
1243 static inline void acpi_sleep_hibernate_setup(void) {}
1244 #endif /* !CONFIG_HIBERNATION */
1245 
1246 static void acpi_power_off_prepare(void)
1247 {
1248 	/* Prepare to power off the system */
1249 	acpi_sleep_prepare(ACPI_STATE_S5);
1250 	acpi_disable_all_gpes();
1251 	acpi_os_wait_events_complete();
1252 }
1253 
1254 static void acpi_power_off(void)
1255 {
1256 	/* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
1257 	printk(KERN_DEBUG "%s called\n", __func__);
1258 	local_irq_disable();
1259 	acpi_enter_sleep_state(ACPI_STATE_S5);
1260 }
1261 
1262 int __init acpi_sleep_init(void)
1263 {
1264 	char supported[ACPI_S_STATE_COUNT * 3 + 1];
1265 	char *pos = supported;
1266 	int i;
1267 
1268 	acpi_sleep_dmi_check();
1269 
1270 	sleep_states[ACPI_STATE_S0] = 1;
1271 
1272 	acpi_sleep_syscore_init();
1273 	acpi_sleep_suspend_setup();
1274 	acpi_sleep_hibernate_setup();
1275 
1276 	if (acpi_sleep_state_supported(ACPI_STATE_S5)) {
1277 		sleep_states[ACPI_STATE_S5] = 1;
1278 		pm_power_off_prepare = acpi_power_off_prepare;
1279 		pm_power_off = acpi_power_off;
1280 	} else {
1281 		acpi_no_s5 = true;
1282 	}
1283 
1284 	supported[0] = 0;
1285 	for (i = 0; i < ACPI_S_STATE_COUNT; i++) {
1286 		if (sleep_states[i])
1287 			pos += sprintf(pos, " S%d", i);
1288 	}
1289 	pr_info(PREFIX "(supports%s)\n", supported);
1290 
1291 	/*
1292 	 * Register the tts_notifier to reboot notifier list so that the _TTS
1293 	 * object can also be evaluated when the system enters S5.
1294 	 */
1295 	register_reboot_notifier(&tts_notifier);
1296 	return 0;
1297 }
1298