main.c 10.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10
/*
 * kernel/power/main.c - PM subsystem core functionality.
 *
 * Copyright (c) 2003 Patrick Mochel
 * Copyright (c) 2003 Open Source Development Lab
 * 
 * This file is released under the GPLv2
 *
 */

11
#include <linux/module.h>
L
Linus Torvalds 已提交
12 13 14 15 16 17
#include <linux/suspend.h>
#include <linux/kobject.h>
#include <linux/string.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/init.h>
18
#include <linux/console.h>
19
#include <linux/cpu.h>
20
#include <linux/resume-trace.h>
21
#include <linux/freezer.h>
C
Christoph Lameter 已提交
22
#include <linux/vmstat.h>
23
#include <linux/syscalls.h>
L
Linus Torvalds 已提交
24 25 26

#include "power.h"

27 28
BLOCKING_NOTIFIER_HEAD(pm_chain_head);

29
DEFINE_MUTEX(pm_mutex);
L
Linus Torvalds 已提交
30

31 32 33
unsigned int pm_flags;
EXPORT_SYMBOL(pm_flags);

34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
#ifdef CONFIG_PM_DEBUG
int pm_test_level = TEST_NONE;

static int suspend_test(int level)
{
	if (pm_test_level == level) {
		printk(KERN_INFO "suspend debug: Waiting for 5 seconds.\n");
		mdelay(5000);
		return 1;
	}
	return 0;
}

static const char * const pm_tests[__TEST_AFTER_LAST] = {
	[TEST_NONE] = "none",
	[TEST_CORE] = "core",
	[TEST_CPUS] = "processors",
	[TEST_PLATFORM] = "platform",
	[TEST_DEVICES] = "devices",
	[TEST_FREEZER] = "freezer",
};

56 57
static ssize_t pm_test_show(struct kobject *kobj, struct kobj_attribute *attr,
				char *buf)
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
{
	char *s = buf;
	int level;

	for (level = TEST_FIRST; level <= TEST_MAX; level++)
		if (pm_tests[level]) {
			if (level == pm_test_level)
				s += sprintf(s, "[%s] ", pm_tests[level]);
			else
				s += sprintf(s, "%s ", pm_tests[level]);
		}

	if (s != buf)
		/* convert the last space to a newline */
		*(s-1) = '\n';

	return (s - buf);
}

77 78
static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
				const char *buf, size_t n)
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
{
	const char * const *s;
	int level;
	char *p;
	int len;
	int error = -EINVAL;

	p = memchr(buf, '\n', n);
	len = p ? p - buf : n;

	mutex_lock(&pm_mutex);

	level = TEST_FIRST;
	for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++)
		if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) {
			pm_test_level = level;
			error = 0;
			break;
		}

	mutex_unlock(&pm_mutex);

	return error ? error : n;
}

power_attr(pm_test);
#else /* !CONFIG_PM_DEBUG */
static inline int suspend_test(int level) { return 0; }
#endif /* !CONFIG_PM_DEBUG */

109

110 111 112 113 114
#ifdef CONFIG_SUSPEND

/* This is just an arbitrary number */
#define FREE_PAGE_NUMBER (100)

R
Rafael J. Wysocki 已提交
115
static struct platform_suspend_ops *suspend_ops;
L
Linus Torvalds 已提交
116 117

/**
118
 *	suspend_set_ops - Set the global suspend method table.
L
Linus Torvalds 已提交
119 120 121
 *	@ops:	Pointer to ops structure.
 */

122
void suspend_set_ops(struct platform_suspend_ops *ops)
L
Linus Torvalds 已提交
123
{
124
	mutex_lock(&pm_mutex);
125
	suspend_ops = ops;
126
	mutex_unlock(&pm_mutex);
L
Linus Torvalds 已提交
127 128
}

129
/**
130
 * suspend_valid_only_mem - generic memory-only valid callback
131
 *
132
 * Platform drivers that implement mem suspend only and only need
133 134 135
 * to check for that in their .valid callback can use this instead
 * of rolling their own .valid callback.
 */
136
int suspend_valid_only_mem(suspend_state_t state)
137 138 139 140
{
	return state == PM_SUSPEND_MEM;
}

L
Linus Torvalds 已提交
141 142 143
/**
 *	suspend_prepare - Do prep work before entering low-power state.
 *
144 145
 *	This is common code that is called for each state that we're entering.
 *	Run suspend notifiers, allocate a console and stop all processes.
L
Linus Torvalds 已提交
146
 */
147
static int suspend_prepare(void)
L
Linus Torvalds 已提交
148
{
149
	int error;
D
David Shaohua Li 已提交
150
	unsigned int free_pages;
L
Linus Torvalds 已提交
151

152
	if (!suspend_ops || !suspend_ops->enter)
L
Linus Torvalds 已提交
153 154
		return -EPERM;

155 156 157 158
	error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
	if (error)
		goto Finish;

L
Linus Torvalds 已提交
159 160 161 162 163 164 165
	pm_prepare_console();

	if (freeze_processes()) {
		error = -EAGAIN;
		goto Thaw;
	}

166 167
	free_pages = global_page_state(NR_FREE_PAGES);
	if (free_pages < FREE_PAGE_NUMBER) {
D
David Shaohua Li 已提交
168 169 170 171 172 173 174
		pr_debug("PM: free some memory\n");
		shrink_all_memory(FREE_PAGE_NUMBER - free_pages);
		if (nr_free_pages() < FREE_PAGE_NUMBER) {
			error = -ENOMEM;
			printk(KERN_ERR "PM: No enough memory\n");
		}
	}
175 176 177
	if (!error)
		return 0;

L
Linus Torvalds 已提交
178 179 180
 Thaw:
	thaw_processes();
	pm_restore_console();
181 182
 Finish:
	pm_notifier_call_chain(PM_POST_SUSPEND);
L
Linus Torvalds 已提交
183 184 185
	return error;
}

186 187 188 189 190 191 192 193 194 195 196
/* default implementation */
void __attribute__ ((weak)) arch_suspend_disable_irqs(void)
{
	local_irq_disable();
}

/* default implementation */
void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
{
	local_irq_enable();
}
L
Linus Torvalds 已提交
197

198 199 200 201 202 203
/**
 *	suspend_enter - enter the desired system sleep state.
 *	@state:		state to enter
 *
 *	This function should be called after devices have been suspended.
 */
204
static int suspend_enter(suspend_state_t state)
L
Linus Torvalds 已提交
205 206 207
{
	int error = 0;

208 209
	arch_suspend_disable_irqs();
	BUG_ON(!irqs_disabled());
L
Linus Torvalds 已提交
210 211 212 213 214

	if ((error = device_power_down(PMSG_SUSPEND))) {
		printk(KERN_ERR "Some devices failed to power down\n");
		goto Done;
	}
215 216 217 218

	if (!suspend_test(TEST_CORE))
		error = suspend_ops->enter(state);

L
Linus Torvalds 已提交
219 220
	device_power_up();
 Done:
221 222
	arch_suspend_enable_irqs();
	BUG_ON(irqs_disabled());
L
Linus Torvalds 已提交
223 224 225
	return error;
}

226 227 228 229 230 231 232 233 234
/**
 *	suspend_devices_and_enter - suspend devices and enter the desired system sleep
 *			  state.
 *	@state:		  state to enter
 */
int suspend_devices_and_enter(suspend_state_t state)
{
	int error;

235
	if (!suspend_ops)
236 237
		return -ENOSYS;

238 239
	if (suspend_ops->set_target) {
		error = suspend_ops->set_target(state);
240 241 242 243 244 245 246 247 248
		if (error)
			return error;
	}
	suspend_console();
	error = device_suspend(PMSG_SUSPEND);
	if (error) {
		printk(KERN_ERR "Some devices failed to suspend\n");
		goto Resume_console;
	}
249 250 251 252

	if (suspend_test(TEST_DEVICES))
		goto Resume_devices;

253
	if (suspend_ops->prepare) {
254
		error = suspend_ops->prepare();
255 256 257
		if (error)
			goto Resume_devices;
	}
258 259 260 261

	if (suspend_test(TEST_PLATFORM))
		goto Finish;

262
	error = disable_nonboot_cpus();
263
	if (!error && !suspend_test(TEST_CPUS))
264 265 266
		suspend_enter(state);

	enable_nonboot_cpus();
267
 Finish:
268 269
	if (suspend_ops->finish)
		suspend_ops->finish();
270 271 272 273 274 275
 Resume_devices:
	device_resume();
 Resume_console:
	resume_console();
	return error;
}
L
Linus Torvalds 已提交
276 277 278 279 280 281 282

/**
 *	suspend_finish - Do final work before exiting suspend sequence.
 *
 *	Call platform code to clean up, restart processes, and free the 
 *	console that we've allocated. This is not called for suspend-to-disk.
 */
283
static void suspend_finish(void)
L
Linus Torvalds 已提交
284 285 286
{
	thaw_processes();
	pm_restore_console();
287
	pm_notifier_call_chain(PM_POST_SUSPEND);
L
Linus Torvalds 已提交
288 289 290 291 292
}




293
static const char * const pm_states[PM_SUSPEND_MAX] = {
L
Linus Torvalds 已提交
294 295 296 297
	[PM_SUSPEND_STANDBY]	= "standby",
	[PM_SUSPEND_MEM]	= "mem",
};

298 299
static inline int valid_state(suspend_state_t state)
{
300 301
	/* All states need lowlevel support and need to be valid
	 * to the lowlevel implementation, no valid callback
302
	 * implies that none are valid. */
303
	if (!suspend_ops || !suspend_ops->valid || !suspend_ops->valid(state))
304 305 306 307
		return 0;
	return 1;
}

L
Linus Torvalds 已提交
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322

/**
 *	enter_state - Do common work of entering low-power state.
 *	@state:		pm_state structure for state we're entering.
 *
 *	Make sure we're the only ones trying to enter a sleep state. Fail
 *	if someone has beat us to it, since we don't want anything weird to
 *	happen when we wake up.
 *	Then, do the setup for suspend, enter the state, and cleaup (after
 *	we've woken up).
 */
static int enter_state(suspend_state_t state)
{
	int error;

323
	if (!valid_state(state))
324
		return -ENODEV;
325

326
	if (!mutex_trylock(&pm_mutex))
L
Linus Torvalds 已提交
327 328
		return -EBUSY;

329 330 331 332
	printk("Syncing filesystems ... ");
	sys_sync();
	printk("done.\n");

333
	pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
334 335
	error = suspend_prepare();
	if (error)
L
Linus Torvalds 已提交
336 337
		goto Unlock;

338 339 340
	if (suspend_test(TEST_FREEZER))
		goto Finish;

341
	pr_debug("PM: Entering %s sleep\n", pm_states[state]);
342
	error = suspend_devices_and_enter(state);
L
Linus Torvalds 已提交
343

344
 Finish:
345
	pr_debug("PM: Finishing wakeup.\n");
346
	suspend_finish();
L
Linus Torvalds 已提交
347
 Unlock:
348
	mutex_unlock(&pm_mutex);
L
Linus Torvalds 已提交
349 350 351 352 353 354
	return error;
}


/**
 *	pm_suspend - Externally visible function for suspending system.
355
 *	@state:		Enumerated value of state to enter.
L
Linus Torvalds 已提交
356 357 358 359 360 361 362
 *
 *	Determine whether or not value is within range, get state 
 *	structure, and enter (above).
 */

int pm_suspend(suspend_state_t state)
{
A
Alexey Starikovskiy 已提交
363
	if (state > PM_SUSPEND_ON && state <= PM_SUSPEND_MAX)
L
Linus Torvalds 已提交
364 365 366 367
		return enter_state(state);
	return -EINVAL;
}

368
EXPORT_SYMBOL(pm_suspend);
L
Linus Torvalds 已提交
369

370 371
#endif /* CONFIG_SUSPEND */

372
struct kobject *power_kobj;
L
Linus Torvalds 已提交
373 374 375 376 377 378 379 380 381 382 383 384

/**
 *	state - control system power state.
 *
 *	show() returns what states are supported, which is hard-coded to
 *	'standby' (Power-On Suspend), 'mem' (Suspend-to-RAM), and
 *	'disk' (Suspend-to-Disk).
 *
 *	store() accepts one of those strings, translates it into the 
 *	proper enumerated value, and initiates a suspend transition.
 */

385 386
static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
			  char *buf)
L
Linus Torvalds 已提交
387
{
388 389
	char *s = buf;
#ifdef CONFIG_SUSPEND
L
Linus Torvalds 已提交
390 391 392
	int i;

	for (i = 0; i < PM_SUSPEND_MAX; i++) {
393 394
		if (pm_states[i] && valid_state(i))
			s += sprintf(s,"%s ", pm_states[i]);
L
Linus Torvalds 已提交
395
	}
396
#endif
397
#ifdef CONFIG_HIBERNATION
398 399 400 401 402 403
	s += sprintf(s, "%s\n", "disk");
#else
	if (s != buf)
		/* convert the last space to a newline */
		*(s-1) = '\n';
#endif
L
Linus Torvalds 已提交
404 405 406
	return (s - buf);
}

407 408
static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
			   const char *buf, size_t n)
L
Linus Torvalds 已提交
409
{
410
#ifdef CONFIG_SUSPEND
L
Linus Torvalds 已提交
411
	suspend_state_t state = PM_SUSPEND_STANDBY;
412
	const char * const *s;
413
#endif
L
Linus Torvalds 已提交
414 415
	char *p;
	int len;
416
	int error = -EINVAL;
L
Linus Torvalds 已提交
417 418 419 420

	p = memchr(buf, '\n', n);
	len = p ? p - buf : n;

421
	/* First, check if we are requested to hibernate */
R
Rafael J. Wysocki 已提交
422
	if (len == 4 && !strncmp(buf, "disk", len)) {
423
		error = hibernate();
424
  goto Exit;
425 426
	}

427
#ifdef CONFIG_SUSPEND
L
Linus Torvalds 已提交
428
	for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {
R
Rafael J. Wysocki 已提交
429
		if (*s && len == strlen(*s) && !strncmp(buf, *s, len))
L
Linus Torvalds 已提交
430 431
			break;
	}
432
	if (state < PM_SUSPEND_MAX && *s)
L
Linus Torvalds 已提交
433
		error = enter_state(state);
434 435 436
#endif

 Exit:
L
Linus Torvalds 已提交
437 438 439 440 441
	return error ? error : n;
}

power_attr(state);

442 443 444
#ifdef CONFIG_PM_TRACE
int pm_trace_enabled;

445 446
static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
			     char *buf)
447 448 449 450 451
{
	return sprintf(buf, "%d\n", pm_trace_enabled);
}

static ssize_t
452 453
pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
	       const char *buf, size_t n)
454 455 456 457 458 459 460 461 462 463 464
{
	int val;

	if (sscanf(buf, "%d", &val) == 1) {
		pm_trace_enabled = !!val;
		return n;
	}
	return -EINVAL;
}

power_attr(pm_trace);
465
#endif /* CONFIG_PM_TRACE */
466 467 468

static struct attribute * g[] = {
	&state_attr.attr,
469
#ifdef CONFIG_PM_TRACE
470
	&pm_trace_attr.attr,
471 472 473 474
#endif
#ifdef CONFIG_PM_DEBUG
	&pm_test_attr.attr,
#endif
475 476
	NULL,
};
L
Linus Torvalds 已提交
477 478 479 480 481 482 483 484

static struct attribute_group attr_group = {
	.attrs = g,
};


static int __init pm_init(void)
{
485 486
	power_kobj = kobject_create_and_add("power", NULL);
	if (!power_kobj)
487
		return -ENOMEM;
488
	return sysfs_create_group(power_kobj, &attr_group);
L
Linus Torvalds 已提交
489 490 491
}

core_initcall(pm_init);