sleep.c 18.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 * sleep.c - ACPI sleep support.
 *
4
 * Copyright (c) 2005 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
L
Linus Torvalds 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17
 * Copyright (c) 2004 David Shaohua Li <shaohua.li@intel.com>
 * Copyright (c) 2000-2003 Patrick Mochel
 * Copyright (c) 2003 Open Source Development Lab
 *
 * This file is released under the GPLv2.
 *
 */

#include <linux/delay.h>
#include <linux/irq.h>
#include <linux/dmi.h>
#include <linux/device.h>
#include <linux/suspend.h>
18
#include <linux/reboot.h>
19
#include <linux/acpi.h>
20
#include <linux/module.h>
21 22 23

#include <asm/io.h>

L
Linus Torvalds 已提交
24 25
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>
26 27

#include "internal.h"
L
Linus Torvalds 已提交
28 29
#include "sleep.h"

30
static u8 sleep_states[ACPI_S_STATE_COUNT];
L
Linus Torvalds 已提交
31

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
static void acpi_sleep_tts_switch(u32 acpi_state)
{
	union acpi_object in_arg = { ACPI_TYPE_INTEGER };
	struct acpi_object_list arg_list = { 1, &in_arg };
	acpi_status status = AE_OK;

	in_arg.integer.value = acpi_state;
	status = acpi_evaluate_object(NULL, "\\_TTS", &arg_list, NULL);
	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
		/*
		 * OS can't evaluate the _TTS object correctly. Some warning
		 * message will be printed. But it won't break anything.
		 */
		printk(KERN_NOTICE "Failure in evaluating _TTS object\n");
	}
}

static int tts_notify_reboot(struct notifier_block *this,
			unsigned long code, void *x)
{
	acpi_sleep_tts_switch(ACPI_STATE_S5);
	return NOTIFY_DONE;
}

static struct notifier_block tts_notifier = {
	.notifier_call	= tts_notify_reboot,
	.next		= NULL,
	.priority	= 0,
};

62
static int acpi_sleep_prepare(u32 acpi_state)
63 64 65 66
{
#ifdef CONFIG_ACPI_SLEEP
	/* do we have a wakeup address for S2 and S3? */
	if (acpi_state == ACPI_STATE_S3) {
67
		if (!acpi_wakeup_address)
68
			return -EFAULT;
69
		acpi_set_firmware_waking_vector(acpi_wakeup_address);
70 71 72 73

	}
	ACPI_FLUSH_CPU_CACHE();
#endif
74 75
	printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
		acpi_state);
76
	acpi_enable_wakeup_devices(acpi_state);
77 78 79 80
	acpi_enter_sleep_state_prep(acpi_state);
	return 0;
}

81
#ifdef CONFIG_ACPI_SLEEP
82
static u32 acpi_target_sleep_state = ACPI_STATE_S0;
83 84 85 86 87 88

u32 acpi_target_system_state(void)
{
	return acpi_target_sleep_state;
}

89
static bool pwr_btn_event_pending;
90

91 92 93 94 95 96 97 98 99 100 101 102 103 104
/*
 * The ACPI specification wants us to save NVS memory regions during hibernation
 * and to restore them during the subsequent resume.  Windows does that also for
 * suspend to RAM.  However, it is known that this mechanism does not work on
 * all machines, so we allow the user to disable it with the help of the
 * 'acpi_sleep=nonvs' kernel command line option.
 */
static bool nvs_nosave;

void __init acpi_nvs_nosave(void)
{
	nvs_nosave = true;
}

105 106 107 108 109 110 111 112 113 114 115 116 117
/*
 * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
 * user to request that behavior by using the 'acpi_old_suspend_ordering'
 * kernel command line option that causes the following variable to be set.
 */
static bool old_suspend_ordering;

void __init acpi_old_suspend_ordering(void)
{
	old_suspend_ordering = true;
}

/**
118
 * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
119
 */
120
static int acpi_pm_freeze(void)
121
{
122
	acpi_disable_all_gpes();
123
	acpi_os_wait_events_complete();
124
	acpi_ec_block_transactions();
125 126 127
	return 0;
}

128 129 130 131 132 133
/**
 * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
 */
static int acpi_pm_pre_suspend(void)
{
	acpi_pm_freeze();
134
	return suspend_nvs_save();
135 136
}

137 138 139 140 141 142 143 144 145 146 147
/**
 *	__acpi_pm_prepare - Prepare the platform to enter the target state.
 *
 *	If necessary, set the firmware waking vector and do arch-specific
 *	nastiness to get the wakeup code to the waking vector.
 */
static int __acpi_pm_prepare(void)
{
	int error = acpi_sleep_prepare(acpi_target_sleep_state);
	if (error)
		acpi_target_sleep_state = ACPI_STATE_S0;
148

149 150 151 152 153 154 155 156 157 158 159
	return error;
}

/**
 *	acpi_pm_prepare - Prepare the platform to enter the target sleep
 *		state and disable the GPEs.
 */
static int acpi_pm_prepare(void)
{
	int error = __acpi_pm_prepare();
	if (!error)
160
		error = acpi_pm_pre_suspend();
161

162 163 164
	return error;
}

165 166 167 168 169 170 171 172
static int find_powerf_dev(struct device *dev, void *data)
{
	struct acpi_device *device = to_acpi_device(dev);
	const char *hid = acpi_device_hid(device);

	return !strcmp(hid, ACPI_BUTTON_HID_POWERF);
}

173 174 175 176 177 178 179 180
/**
 *	acpi_pm_finish - Instruct the platform to leave a sleep state.
 *
 *	This is called after we wake back up (or if entering the sleep state
 *	failed).
 */
static void acpi_pm_finish(void)
{
181
	struct device *pwr_btn_dev;
182 183
	u32 acpi_state = acpi_target_sleep_state;

184
	acpi_ec_unblock_transactions();
185
	suspend_nvs_free();
186

187 188
	if (acpi_state == ACPI_STATE_S0)
		return;
L
Linus Torvalds 已提交
189

190 191
	printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
		acpi_state);
192
	acpi_disable_wakeup_devices(acpi_state);
193 194 195 196 197 198
	acpi_leave_sleep_state(acpi_state);

	/* reset firmware waking vector */
	acpi_set_firmware_waking_vector((acpi_physical_address) 0);

	acpi_target_sleep_state = ACPI_STATE_S0;
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215

	/* If we were woken with the fixed power button, provide a small
	 * hint to userspace in the form of a wakeup event on the fixed power
	 * button device (if it can be found).
	 *
	 * We delay the event generation til now, as the PM layer requires
	 * timekeeping to be running before we generate events. */
	if (!pwr_btn_event_pending)
		return;

	pwr_btn_event_pending = false;
	pwr_btn_dev = bus_find_device(&acpi_bus_type, NULL, NULL,
				      find_powerf_dev);
	if (pwr_btn_dev) {
		pm_wakeup_event(pwr_btn_dev, 0);
		put_device(pwr_btn_dev);
	}
216 217 218 219 220 221 222 223 224 225 226 227
}

/**
 *	acpi_pm_end - Finish up suspend sequence.
 */
static void acpi_pm_end(void)
{
	/*
	 * This is necessary in case acpi_pm_finish() is not called during a
	 * failing transition to a sleep state.
	 */
	acpi_target_sleep_state = ACPI_STATE_S0;
228
	acpi_sleep_tts_switch(acpi_target_sleep_state);
229
}
230 231
#else /* !CONFIG_ACPI_SLEEP */
#define acpi_target_sleep_state	ACPI_STATE_S0
232
#endif /* CONFIG_ACPI_SLEEP */
L
Linus Torvalds 已提交
233

234
#ifdef CONFIG_SUSPEND
L
Linus Torvalds 已提交
235
static u32 acpi_suspend_states[] = {
236 237 238 239
	[PM_SUSPEND_ON] = ACPI_STATE_S0,
	[PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
	[PM_SUSPEND_MEM] = ACPI_STATE_S3,
	[PM_SUSPEND_MAX] = ACPI_STATE_S5
L
Linus Torvalds 已提交
240 241
};

242
/**
243
 *	acpi_suspend_begin - Set the target system sleep state to the state
244 245
 *		associated with given @pm_state, if supported.
 */
246
static int acpi_suspend_begin(suspend_state_t pm_state)
247 248 249 250
{
	u32 acpi_state = acpi_suspend_states[pm_state];
	int error = 0;

251
	error = nvs_nosave ? 0 : suspend_nvs_alloc();
252 253 254
	if (error)
		return error;

255 256
	if (sleep_states[acpi_state]) {
		acpi_target_sleep_state = acpi_state;
257
		acpi_sleep_tts_switch(acpi_target_sleep_state);
258 259 260 261 262 263 264 265
	} else {
		printk(KERN_ERR "ACPI does not support this state: %d\n",
			pm_state);
		error = -ENOSYS;
	}
	return error;
}

L
Linus Torvalds 已提交
266
/**
267
 *	acpi_suspend_enter - Actually enter a sleep state.
268
 *	@pm_state: ignored
L
Linus Torvalds 已提交
269
 *
270 271
 *	Flush caches and go to sleep. For STR we have to call arch-specific
 *	assembly, which in turn call acpi_enter_sleep_state().
L
Linus Torvalds 已提交
272 273
 *	It's unfortunate, but it works. Please fix if you're feeling frisky.
 */
274
static int acpi_suspend_enter(suspend_state_t pm_state)
L
Linus Torvalds 已提交
275 276
{
	acpi_status status = AE_OK;
277
	u32 acpi_state = acpi_target_sleep_state;
278
	int error;
L
Linus Torvalds 已提交
279 280 281

	ACPI_FLUSH_CPU_CACHE();

282 283
	switch (acpi_state) {
	case ACPI_STATE_S1:
L
Linus Torvalds 已提交
284
		barrier();
285
		status = acpi_enter_sleep_state(acpi_state);
L
Linus Torvalds 已提交
286 287
		break;

288
	case ACPI_STATE_S3:
289
		error = acpi_suspend_lowlevel();
290 291
		if (error)
			return error;
292
		pr_info(PREFIX "Low-level resume complete\n");
L
Linus Torvalds 已提交
293 294
		break;
	}
295

296 297
	/* This violates the spec but is required for bug compatibility. */
	acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
298

299 300
	/* Reprogram control registers */
	acpi_leave_sleep_state_prep(acpi_state);
301

P
Pavel Machek 已提交
302
	/* ACPI 3.0 specs (P62) says that it's the responsibility
303 304
	 * of the OSPM to clear the status bit [ implying that the
	 * POWER_BUTTON event should not reach userspace ]
305 306 307 308 309
	 *
	 * However, we do generate a small hint for userspace in the form of
	 * a wakeup event. We flag this condition for now and generate the
	 * event later, as we're currently too early in resume to be able to
	 * generate wakeup events.
310
	 */
311 312 313 314 315 316 317 318 319 320 321
	if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) {
		acpi_event_status pwr_btn_status;

		acpi_get_event_status(ACPI_EVENT_POWER_BUTTON, &pwr_btn_status);

		if (pwr_btn_status & ACPI_EVENT_FLAG_SET) {
			acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
			/* Flag for later */
			pwr_btn_event_pending = true;
		}
	}
322

323 324 325 326 327
	/*
	 * Disable and clear GPE status before interrupt is enabled. Some GPEs
	 * (like wakeup GPE) haven't handler, this can avoid such GPE misfire.
	 * acpi_leave_sleep_state will reenable specific GPEs later
	 */
328
	acpi_disable_all_gpes();
329
	/* Allow EC transactions to happen. */
330
	acpi_ec_unblock_transactions_early();
331

332 333
	suspend_nvs_restore();

L
Linus Torvalds 已提交
334 335 336
	return ACPI_SUCCESS(status) ? 0 : -EFAULT;
}

337
static int acpi_suspend_state_valid(suspend_state_t pm_state)
338
{
339
	u32 acpi_state;
340

341 342 343 344 345 346 347 348 349 350
	switch (pm_state) {
	case PM_SUSPEND_ON:
	case PM_SUSPEND_STANDBY:
	case PM_SUSPEND_MEM:
		acpi_state = acpi_suspend_states[pm_state];

		return sleep_states[acpi_state];
	default:
		return 0;
	}
351 352
}

353
static const struct platform_suspend_ops acpi_suspend_ops = {
354 355
	.valid = acpi_suspend_state_valid,
	.begin = acpi_suspend_begin,
356
	.prepare_late = acpi_pm_prepare,
357
	.enter = acpi_suspend_enter,
358
	.wake = acpi_pm_finish,
359 360 361 362 363 364 365 366 367 368 369 370 371 372
	.end = acpi_pm_end,
};

/**
 *	acpi_suspend_begin_old - Set the target system sleep state to the
 *		state associated with given @pm_state, if supported, and
 *		execute the _PTS control method.  This function is used if the
 *		pre-ACPI 2.0 suspend ordering has been requested.
 */
static int acpi_suspend_begin_old(suspend_state_t pm_state)
{
	int error = acpi_suspend_begin(pm_state);
	if (!error)
		error = __acpi_pm_prepare();
373

374 375 376 377 378 379 380
	return error;
}

/*
 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
 * been requested.
 */
381
static const struct platform_suspend_ops acpi_suspend_ops_old = {
382 383
	.valid = acpi_suspend_state_valid,
	.begin = acpi_suspend_begin_old,
384
	.prepare_late = acpi_pm_pre_suspend,
385
	.enter = acpi_suspend_enter,
386
	.wake = acpi_pm_finish,
387 388
	.end = acpi_pm_end,
	.recover = acpi_pm_finish,
L
Linus Torvalds 已提交
389
};
390 391 392 393 394 395 396

static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
{
	old_suspend_ordering = true;
	return 0;
}

397 398 399 400 401 402
static int __init init_nvs_nosave(const struct dmi_system_id *d)
{
	acpi_nvs_nosave();
	return 0;
}

403 404 405 406 407 408 409 410 411
static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
	{
	.callback = init_old_suspend_ordering,
	.ident = "Abit KN9 (nForce4 variant)",
	.matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"),
		DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"),
		},
	},
412 413 414 415 416 417 418 419
	{
	.callback = init_old_suspend_ordering,
	.ident = "HP xw4600 Workstation",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
		DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"),
		},
	},
420
	{
421 422 423 424 425 426 427
	.callback = init_old_suspend_ordering,
	.ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
	.matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."),
		DMI_MATCH(DMI_BOARD_NAME, "M2N8L"),
		},
	},
428
	{
429 430 431 432 433 434 435 436
	.callback = init_old_suspend_ordering,
	.ident = "Panasonic CF51-2L",
	.matches = {
		DMI_MATCH(DMI_BOARD_VENDOR,
				"Matsushita Electric Industrial Co.,Ltd."),
		DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
		},
	},
437 438
	{
	.callback = init_nvs_nosave,
439 440 441 442 443 444 445 446
	.ident = "Sony Vaio VGN-FW21E",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21E"),
		},
	},
	{
	.callback = init_nvs_nosave,
447 448 449 450 451 452 453 454
	.ident = "Sony Vaio VPCEB17FX",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
		DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB17FX"),
		},
	},
	{
	.callback = init_nvs_nosave,
455 456 457 458 459 460 461 462 463 464 465 466 467 468
	.ident = "Sony Vaio VGN-SR11M",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"),
		},
	},
	{
	.callback = init_nvs_nosave,
	.ident = "Everex StepNote Series",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."),
		DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"),
		},
	},
469 470 471 472 473 474 475 476
	{
	.callback = init_nvs_nosave,
	.ident = "Sony Vaio VPCEB1Z1E",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
		DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
		},
	},
477 478 479 480 481 482 483 484
	{
	.callback = init_nvs_nosave,
	.ident = "Sony Vaio VGN-NW130D",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
		},
	},
485 486
	{
	.callback = init_nvs_nosave,
487 488 489 490 491 492 493 494
	.ident = "Sony Vaio VPCCW29FX",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
		DMI_MATCH(DMI_PRODUCT_NAME, "VPCCW29FX"),
		},
	},
	{
	.callback = init_nvs_nosave,
495 496 497 498 499 500
	.ident = "Averatec AV1020-ED2",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
		DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
		},
	},
501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
	{
	.callback = init_old_suspend_ordering,
	.ident = "Asus A8N-SLI DELUXE",
	.matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
		DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI DELUXE"),
		},
	},
	{
	.callback = init_old_suspend_ordering,
	.ident = "Asus A8N-SLI Premium",
	.matches = {
		DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
		DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI Premium"),
		},
	},
517 518 519 520 521 522 523 524
	{
	.callback = init_nvs_nosave,
	.ident = "Sony Vaio VGN-SR26GN_P",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR26GN_P"),
		},
	},
525 526 527 528 529 530 531 532
	{
	.callback = init_nvs_nosave,
	.ident = "Sony Vaio VGN-FW520F",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW520F"),
		},
	},
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
	{
	.callback = init_nvs_nosave,
	.ident = "Asus K54C",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
		DMI_MATCH(DMI_PRODUCT_NAME, "K54C"),
		},
	},
	{
	.callback = init_nvs_nosave,
	.ident = "Asus K54HR",
	.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
		DMI_MATCH(DMI_PRODUCT_NAME, "K54HR"),
		},
	},
549 550
	{},
};
551 552
#endif /* CONFIG_SUSPEND */

553
#ifdef CONFIG_HIBERNATION
554 555 556 557 558 559 560 561 562
static unsigned long s4_hardware_signature;
static struct acpi_table_facs *facs;
static bool nosigcheck;

void __init acpi_no_s4_hw_signature(void)
{
	nosigcheck = true;
}

563
static int acpi_hibernation_begin(void)
564
{
565 566
	int error;

567
	error = nvs_nosave ? 0 : suspend_nvs_alloc();
568 569 570 571 572 573 574 575
	if (!error) {
		acpi_target_sleep_state = ACPI_STATE_S4;
		acpi_sleep_tts_switch(acpi_target_sleep_state);
	}

	return error;
}

576 577 578 579 580 581 582
static int acpi_hibernation_enter(void)
{
	acpi_status status = AE_OK;

	ACPI_FLUSH_CPU_CACHE();

	/* This shouldn't return.  If it returns, we have a problem */
583 584 585
	status = acpi_enter_sleep_state(ACPI_STATE_S4);
	/* Reprogram control registers */
	acpi_leave_sleep_state_prep(ACPI_STATE_S4);
586 587 588 589

	return ACPI_SUCCESS(status) ? 0 : -EFAULT;
}

590 591 592 593 594 595 596
static void acpi_hibernation_leave(void)
{
	/*
	 * If ACPI is not enabled by the BIOS and the boot kernel, we need to
	 * enable it here.
	 */
	acpi_enable();
597 598
	/* Reprogram control registers */
	acpi_leave_sleep_state_prep(ACPI_STATE_S4);
599 600 601 602 603 604
	/* Check the hardware signature */
	if (facs && s4_hardware_signature != facs->hardware_signature) {
		printk(KERN_EMERG "ACPI: Hardware changed while hibernated, "
			"cannot resume!\n");
		panic("ACPI S4 hardware signature mismatch");
	}
605
	/* Restore the NVS memory area */
606
	suspend_nvs_restore();
607
	/* Allow EC transactions to happen. */
608
	acpi_ec_unblock_transactions_early();
609 610
}

611
static void acpi_pm_thaw(void)
612
{
613
	acpi_ec_unblock_transactions();
614
	acpi_enable_all_runtime_gpes();
615 616
}

617
static const struct platform_hibernation_ops acpi_hibernation_ops = {
618 619
	.begin = acpi_hibernation_begin,
	.end = acpi_pm_end,
620
	.pre_snapshot = acpi_pm_prepare,
621
	.finish = acpi_pm_finish,
622 623 624
	.prepare = acpi_pm_prepare,
	.enter = acpi_hibernation_enter,
	.leave = acpi_hibernation_leave,
625 626
	.pre_restore = acpi_pm_freeze,
	.restore_cleanup = acpi_pm_thaw,
627
};
628

629 630 631 632 633 634 635
/**
 *	acpi_hibernation_begin_old - Set the target system sleep state to
 *		ACPI_STATE_S4 and execute the _PTS control method.  This
 *		function is used if the pre-ACPI 2.0 suspend ordering has been
 *		requested.
 */
static int acpi_hibernation_begin_old(void)
636
{
637 638 639 640 641 642 643 644 645
	int error;
	/*
	 * The _TTS object should always be evaluated before the _PTS object.
	 * When the old_suspended_ordering is true, the _PTS object is
	 * evaluated in the acpi_sleep_prepare.
	 */
	acpi_sleep_tts_switch(ACPI_STATE_S4);

	error = acpi_sleep_prepare(ACPI_STATE_S4);
646

647
	if (!error) {
648
		if (!nvs_nosave)
649
			error = suspend_nvs_alloc();
650 651 652 653 654 655
		if (!error)
			acpi_target_sleep_state = ACPI_STATE_S4;
	}
	return error;
}

656 657 658 659
/*
 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
 * been requested.
 */
660
static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
661 662
	.begin = acpi_hibernation_begin_old,
	.end = acpi_pm_end,
663
	.pre_snapshot = acpi_pm_pre_suspend,
664
	.prepare = acpi_pm_freeze,
665
	.finish = acpi_pm_finish,
666
	.enter = acpi_hibernation_enter,
667
	.leave = acpi_hibernation_leave,
668 669
	.pre_restore = acpi_pm_freeze,
	.restore_cleanup = acpi_pm_thaw,
670
	.recover = acpi_pm_finish,
671
};
672
#endif /* CONFIG_HIBERNATION */
673

674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
int acpi_suspend(u32 acpi_state)
{
	suspend_state_t states[] = {
		[1] = PM_SUSPEND_STANDBY,
		[3] = PM_SUSPEND_MEM,
		[5] = PM_SUSPEND_MAX
	};

	if (acpi_state < 6 && states[acpi_state])
		return pm_suspend(states[acpi_state]);
	if (acpi_state == 4)
		return hibernate();
	return -EINVAL;
}

689 690 691 692
static void acpi_power_off_prepare(void)
{
	/* Prepare to power off the system */
	acpi_sleep_prepare(ACPI_STATE_S5);
693
	acpi_disable_all_gpes();
694 695 696 697 698
}

static void acpi_power_off(void)
{
	/* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
699
	printk(KERN_DEBUG "%s called\n", __func__);
700
	local_irq_disable();
701
	acpi_enter_sleep_state(ACPI_STATE_S5);
702 703
}

704
int __init acpi_sleep_init(void)
L
Linus Torvalds 已提交
705
{
706 707 708
	acpi_status status;
	u8 type_a, type_b;
#ifdef CONFIG_SUSPEND
709
	int i = 0;
710 711

	dmi_check_system(acpisleep_dmi_table);
712
#endif
L
Linus Torvalds 已提交
713 714 715 716

	if (acpi_disabled)
		return 0;

717 718 719
	sleep_states[ACPI_STATE_S0] = 1;
	printk(KERN_INFO PREFIX "(supports S0");

720
#ifdef CONFIG_SUSPEND
721
	for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++) {
L
Linus Torvalds 已提交
722 723 724
		status = acpi_get_sleep_type_data(i, &type_a, &type_b);
		if (ACPI_SUCCESS(status)) {
			sleep_states[i] = 1;
725
			printk(KERN_CONT " S%d", i);
L
Linus Torvalds 已提交
726 727 728
		}
	}

729 730
	suspend_set_ops(old_suspend_ordering ?
		&acpi_suspend_ops_old : &acpi_suspend_ops);
731
#endif
732

733
#ifdef CONFIG_HIBERNATION
734 735
	status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b);
	if (ACPI_SUCCESS(status)) {
736 737
		hibernation_set_ops(old_suspend_ordering ?
			&acpi_hibernation_ops_old : &acpi_hibernation_ops);
738
		sleep_states[ACPI_STATE_S4] = 1;
739
		printk(KERN_CONT " S4");
740
		if (!nosigcheck) {
741
			acpi_get_table(ACPI_SIG_FACS, 1,
742 743 744 745 746
				(struct acpi_table_header **)&facs);
			if (facs)
				s4_hardware_signature =
					facs->hardware_signature;
		}
747
	}
748
#endif
749 750 751
	status = acpi_get_sleep_type_data(ACPI_STATE_S5, &type_a, &type_b);
	if (ACPI_SUCCESS(status)) {
		sleep_states[ACPI_STATE_S5] = 1;
752
		printk(KERN_CONT " S5");
753 754 755
		pm_power_off_prepare = acpi_power_off_prepare;
		pm_power_off = acpi_power_off;
	}
756
	printk(KERN_CONT ")\n");
757 758 759 760 761
	/*
	 * Register the tts_notifier to reboot notifier list so that the _TTS
	 * object can also be evaluated when the system enters S5.
	 */
	register_reboot_notifier(&tts_notifier);
L
Linus Torvalds 已提交
762 763
	return 0;
}
新手
引导
客服 返回
顶部