main.c 11.3 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
/*
 * sleep.c - ACPI sleep support.
 *
4
 * Copyright (c) 2005 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
Linus Torvalds's avatar
Linus Torvalds committed
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 19 20

#include <asm/io.h>

Linus Torvalds's avatar
Linus Torvalds committed
21 22 23 24 25 26
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>
#include "sleep.h"

u8 sleep_states[ACPI_S_STATE_COUNT];

27
#ifdef CONFIG_PM_SLEEP
28
static u32 acpi_target_sleep_state = ACPI_STATE_S0;
29
#endif
30

31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
int acpi_sleep_prepare(u32 acpi_state)
{
#ifdef CONFIG_ACPI_SLEEP
	/* do we have a wakeup address for S2 and S3? */
	if (acpi_state == ACPI_STATE_S3) {
		if (!acpi_wakeup_address) {
			return -EFAULT;
		}
		acpi_set_firmware_waking_vector((acpi_physical_address)
						virt_to_phys((void *)
							     acpi_wakeup_address));

	}
	ACPI_FLUSH_CPU_CACHE();
	acpi_enable_wakeup_device_prep(acpi_state);
#endif
	acpi_enter_sleep_state_prep(acpi_state);
	return 0;
}

51
#ifdef CONFIG_SUSPEND
52
static struct platform_suspend_ops acpi_pm_ops;
Linus Torvalds's avatar
Linus Torvalds committed
53 54 55 56

extern void do_suspend_lowlevel(void);

static u32 acpi_suspend_states[] = {
57 58 59 60
	[PM_SUSPEND_ON] = ACPI_STATE_S0,
	[PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
	[PM_SUSPEND_MEM] = ACPI_STATE_S3,
	[PM_SUSPEND_MAX] = ACPI_STATE_S5
Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64
};

static int init_8259A_after_S1;

65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
/**
 *	acpi_pm_set_target - Set the target system sleep state to the state
 *		associated with given @pm_state, if supported.
 */

static int acpi_pm_set_target(suspend_state_t pm_state)
{
	u32 acpi_state = acpi_suspend_states[pm_state];
	int error = 0;

	if (sleep_states[acpi_state]) {
		acpi_target_sleep_state = acpi_state;
	} else {
		printk(KERN_ERR "ACPI does not support this state: %d\n",
			pm_state);
		error = -ENOSYS;
	}
	return error;
}

Linus Torvalds's avatar
Linus Torvalds committed
85 86 87
/**
 *	acpi_pm_prepare - Do preliminary suspend work.
 *
88 89
 *	If necessary, set the firmware waking vector and do arch-specific
 *	nastiness to get the wakeup code to the waking vector.
Linus Torvalds's avatar
Linus Torvalds committed
90 91
 */

92
static int acpi_pm_prepare(void)
Linus Torvalds's avatar
Linus Torvalds committed
93
{
94
	int error = acpi_sleep_prepare(acpi_target_sleep_state);
Linus Torvalds's avatar
Linus Torvalds committed
95

96 97 98 99
	if (error)
		acpi_target_sleep_state = ACPI_STATE_S0;

	return error;
Linus Torvalds's avatar
Linus Torvalds committed
100 101 102 103
}

/**
 *	acpi_pm_enter - Actually enter a sleep state.
104
 *	@pm_state: ignored
Linus Torvalds's avatar
Linus Torvalds committed
105
 *
106 107
 *	Flush caches and go to sleep. For STR we have to call arch-specific
 *	assembly, which in turn call acpi_enter_sleep_state().
Linus Torvalds's avatar
Linus Torvalds committed
108 109 110 111 112 113 114
 *	It's unfortunate, but it works. Please fix if you're feeling frisky.
 */

static int acpi_pm_enter(suspend_state_t pm_state)
{
	acpi_status status = AE_OK;
	unsigned long flags = 0;
115
	u32 acpi_state = acpi_target_sleep_state;
Linus Torvalds's avatar
Linus Torvalds committed
116 117 118 119

	ACPI_FLUSH_CPU_CACHE();

	/* Do arch specific saving of state. */
120
	if (acpi_state == ACPI_STATE_S3) {
Linus Torvalds's avatar
Linus Torvalds committed
121
		int error = acpi_save_state_mem();
122 123 124

		if (error) {
			acpi_target_sleep_state = ACPI_STATE_S0;
Linus Torvalds's avatar
Linus Torvalds committed
125
			return error;
126
		}
Linus Torvalds's avatar
Linus Torvalds committed
127 128 129 130
	}

	local_irq_save(flags);
	acpi_enable_wakeup_device(acpi_state);
131 132
	switch (acpi_state) {
	case ACPI_STATE_S1:
Linus Torvalds's avatar
Linus Torvalds committed
133 134 135 136
		barrier();
		status = acpi_enter_sleep_state(acpi_state);
		break;

137
	case ACPI_STATE_S3:
Linus Torvalds's avatar
Linus Torvalds committed
138 139 140
		do_suspend_lowlevel();
		break;
	}
141 142 143 144 145 146 147 148

	/* ACPI 3.0 specs (P62) says that it's the responsabilty
	 * of the OSPM to clear the status bit [ implying that the
	 * POWER_BUTTON event should not reach userspace ]
	 */
	if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3))
		acpi_clear_event(ACPI_EVENT_POWER_BUTTON);

Linus Torvalds's avatar
Linus Torvalds committed
149 150 151
	local_irq_restore(flags);
	printk(KERN_DEBUG "Back to C!\n");

152
	/* restore processor state */
153
	if (acpi_state == ACPI_STATE_S3)
Linus Torvalds's avatar
Linus Torvalds committed
154 155 156 157 158 159 160 161 162 163 164 165
		acpi_restore_state_mem();

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

/**
 *	acpi_pm_finish - Finish up suspend sequence.
 *
 *	This is called after we wake back up (or if entering the sleep state
 *	failed). 
 */

166
static void acpi_pm_finish(void)
Linus Torvalds's avatar
Linus Torvalds committed
167
{
168
	u32 acpi_state = acpi_target_sleep_state;
Linus Torvalds's avatar
Linus Torvalds committed
169 170 171 172 173 174 175

	acpi_leave_sleep_state(acpi_state);
	acpi_disable_wakeup_device(acpi_state);

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

176 177
	acpi_target_sleep_state = ACPI_STATE_S0;

178
#ifdef CONFIG_X86
Linus Torvalds's avatar
Linus Torvalds committed
179 180 181 182
	if (init_8259A_after_S1) {
		printk("Broken toshiba laptop -> kicking interrupts\n");
		init_8259A(0);
	}
183
#endif
Linus Torvalds's avatar
Linus Torvalds committed
184 185
}

186 187
static int acpi_pm_state_valid(suspend_state_t pm_state)
{
188
	u32 acpi_state;
189

190 191 192 193 194 195 196 197 198 199
	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;
	}
200 201
}

202
static struct platform_suspend_ops acpi_pm_ops = {
203
	.valid = acpi_pm_state_valid,
204
	.set_target = acpi_pm_set_target,
205 206 207
	.prepare = acpi_pm_prepare,
	.enter = acpi_pm_enter,
	.finish = acpi_pm_finish,
Linus Torvalds's avatar
Linus Torvalds committed
208 209
};

210 211 212 213
/*
 * Toshiba fails to preserve interrupts over S1, reinitialization
 * of 8259 is needed after S1 resume.
 */
214
static int __init init_ints_after_s1(const struct dmi_system_id *d)
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
{
	printk(KERN_WARNING "%s with broken S1 detected.\n", d->ident);
	init_8259A_after_S1 = 1;
	return 0;
}

static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
	{
	 .callback = init_ints_after_s1,
	 .ident = "Toshiba Satellite 4030cdt",
	 .matches = {DMI_MATCH(DMI_PRODUCT_NAME, "S4030CDT/4.3"),},
	 },
	{},
};
#endif /* CONFIG_SUSPEND */

231
#ifdef CONFIG_HIBERNATION
232 233 234 235 236 237
static int acpi_hibernation_start(void)
{
	acpi_target_sleep_state = ACPI_STATE_S4;
	return 0;
}

238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
static int acpi_hibernation_prepare(void)
{
	return acpi_sleep_prepare(ACPI_STATE_S4);
}

static int acpi_hibernation_enter(void)
{
	acpi_status status = AE_OK;
	unsigned long flags = 0;

	ACPI_FLUSH_CPU_CACHE();

	local_irq_save(flags);
	acpi_enable_wakeup_device(ACPI_STATE_S4);
	/* This shouldn't return.  If it returns, we have a problem */
	status = acpi_enter_sleep_state(ACPI_STATE_S4);
	local_irq_restore(flags);

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

259 260 261 262 263 264 265 266 267
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();
}

268 269
static void acpi_hibernation_finish(void)
{
270 271 272 273 274
	/*
	 * If ACPI is not enabled by the BIOS and the boot kernel, we need to
	 * enable it here.
	 */
	acpi_enable();
275 276 277 278 279
	acpi_leave_sleep_state(ACPI_STATE_S4);
	acpi_disable_wakeup_device(ACPI_STATE_S4);

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

	acpi_target_sleep_state = ACPI_STATE_S0;
282 283
}

284 285 286 287 288 289 290 291 292 293 294 295 296 297
static int acpi_hibernation_pre_restore(void)
{
	acpi_status status;

	status = acpi_hw_disable_all_gpes();

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

static void acpi_hibernation_restore_cleanup(void)
{
	acpi_hw_enable_all_runtime_gpes();
}

298
static struct platform_hibernation_ops acpi_hibernation_ops = {
299 300 301
	.start = acpi_hibernation_start,
	.pre_snapshot = acpi_hibernation_prepare,
	.finish = acpi_hibernation_finish,
302 303
	.prepare = acpi_hibernation_prepare,
	.enter = acpi_hibernation_enter,
304
	.leave = acpi_hibernation_leave,
305 306
	.pre_restore = acpi_hibernation_pre_restore,
	.restore_cleanup = acpi_hibernation_restore_cleanup,
307
};
308
#endif				/* CONFIG_HIBERNATION */
309

310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
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;
}

325
#ifdef CONFIG_PM_SLEEP
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
/**
 *	acpi_pm_device_sleep_state - return preferred power state of ACPI device
 *		in the system sleep state given by %acpi_target_sleep_state
 *	@dev: device to examine
 *	@wake: if set, the device should be able to wake up the system
 *	@d_min_p: used to store the upper limit of allowed states range
 *	Return value: preferred power state of the device on success, -ENODEV on
 *		failure (ie. if there's no 'struct acpi_device' for @dev)
 *
 *	Find the lowest power (highest number) ACPI device power state that
 *	device @dev can be in while the system is in the sleep state represented
 *	by %acpi_target_sleep_state.  If @wake is nonzero, the device should be
 *	able to wake up the system from this sleep state.  If @d_min_p is set,
 *	the highest power (lowest number) device power state of @dev allowed
 *	in this system sleep state is stored at the location pointed to by it.
 *
 *	The caller must ensure that @dev is valid before using this function.
 *	The caller is also responsible for figuring out if the device is
 *	supposed to be able to wake up the system and passing this information
 *	via @wake.
 */

int acpi_pm_device_sleep_state(struct device *dev, int wake, int *d_min_p)
{
	acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
	struct acpi_device *adev;
	char acpi_method[] = "_SxD";
	unsigned long d_min, d_max;

	if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
356
		printk(KERN_DEBUG "ACPI handle has no context!\n");
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
		return -ENODEV;
	}

	acpi_method[2] = '0' + acpi_target_sleep_state;
	/*
	 * If the sleep state is S0, we will return D3, but if the device has
	 * _S0W, we will use the value from _S0W
	 */
	d_min = ACPI_STATE_D0;
	d_max = ACPI_STATE_D3;

	/*
	 * If present, _SxD methods return the minimum D-state (highest power
	 * state) we can use for the corresponding S-states.  Otherwise, the
	 * minimum D-state is D0 (ACPI 3.x).
	 *
	 * NOTE: We rely on acpi_evaluate_integer() not clobbering the integer
	 * provided -- that's our fault recovery, we ignore retval.
	 */
	if (acpi_target_sleep_state > ACPI_STATE_S0)
		acpi_evaluate_integer(handle, acpi_method, NULL, &d_min);

	/*
	 * If _PRW says we can wake up the system from the target sleep state,
	 * the D-state returned by _SxD is sufficient for that (we assume a
	 * wakeup-aware driver if wake is set).  Still, if _SxW exists
	 * (ACPI 3.x), it should return the maximum (lowest power) D-state that
	 * can wake the system.  _S0W may be valid, too.
	 */
	if (acpi_target_sleep_state == ACPI_STATE_S0 ||
	    (wake && adev->wakeup.state.enabled &&
	     adev->wakeup.sleep_state <= acpi_target_sleep_state)) {
		acpi_method[3] = 'W';
		acpi_evaluate_integer(handle, acpi_method, NULL, &d_max);
		/* Sanity check */
		if (d_max < d_min)
			d_min = d_max;
	}

	if (d_min_p)
		*d_min_p = d_min;
	return d_max;
}
400
#endif
401

402 403 404 405 406 407 408 409 410 411 412
static void acpi_power_off_prepare(void)
{
	/* Prepare to power off the system */
	acpi_sleep_prepare(ACPI_STATE_S5);
}

static void acpi_power_off(void)
{
	/* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
	printk("%s called\n", __FUNCTION__);
	local_irq_disable();
413
	acpi_enable_wakeup_device(ACPI_STATE_S5);
414 415 416
	acpi_enter_sleep_state(ACPI_STATE_S5);
}

417
int __init acpi_sleep_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
418
{
419 420 421
	acpi_status status;
	u8 type_a, type_b;
#ifdef CONFIG_SUSPEND
422
	int i = 0;
Linus Torvalds's avatar
Linus Torvalds committed
423 424

	dmi_check_system(acpisleep_dmi_table);
425
#endif
Linus Torvalds's avatar
Linus Torvalds committed
426 427 428 429

	if (acpi_disabled)
		return 0;

430 431 432
	sleep_states[ACPI_STATE_S0] = 1;
	printk(KERN_INFO PREFIX "(supports S0");

433
#ifdef CONFIG_SUSPEND
434
	for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
435 436 437 438 439 440 441
		status = acpi_get_sleep_type_data(i, &type_a, &type_b);
		if (ACPI_SUCCESS(status)) {
			sleep_states[i] = 1;
			printk(" S%d", i);
		}
	}

442
	suspend_set_ops(&acpi_pm_ops);
443
#endif
444

445
#ifdef CONFIG_HIBERNATION
446 447
	status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b);
	if (ACPI_SUCCESS(status)) {
448
		hibernation_set_ops(&acpi_hibernation_ops);
449
		sleep_states[ACPI_STATE_S4] = 1;
450
		printk(" S4");
451
	}
452
#endif
453 454 455 456 457 458 459 460
	status = acpi_get_sleep_type_data(ACPI_STATE_S5, &type_a, &type_b);
	if (ACPI_SUCCESS(status)) {
		sleep_states[ACPI_STATE_S5] = 1;
		printk(" S5");
		pm_power_off_prepare = acpi_power_off_prepare;
		pm_power_off = acpi_power_off;
	}
	printk(")\n");
Linus Torvalds's avatar
Linus Torvalds committed
461 462
	return 0;
}