blob: f172f41858bb877305082c2e512d59848d6fdced [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * kernel/power/main.c - PM subsystem core functionality.
3 *
4 * Copyright (c) 2003 Patrick Mochel
5 * Copyright (c) 2003 Open Source Development Lab
6 *
7 * This file is released under the GPLv2
8 *
9 */
10
Ralf Baechle4cf30342006-12-06 20:36:06 -080011#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/suspend.h>
13#include <linux/kobject.h>
14#include <linux/string.h>
15#include <linux/delay.h>
16#include <linux/errno.h>
Rafael J. Wysocki1bfcf132008-10-15 22:01:21 -070017#include <linux/kmod.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/init.h>
Andrew Morton6cc07192006-06-22 14:47:18 -070019#include <linux/console.h>
Rafael J. Wysockie3920fb2006-09-25 23:32:48 -070020#include <linux/cpu.h>
Rafael J. Wysockic5c6ba42006-09-25 23:32:58 -070021#include <linux/resume-trace.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080022#include <linux/freezer.h>
Christoph Lameter96177292007-02-10 01:43:03 -080023#include <linux/vmstat.h>
Rafael J. Wysocki232b1432007-10-18 03:04:44 -070024#include <linux/syscalls.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
26#include "power.h"
27
Stephen Hemmingera6d70982006-12-06 20:34:35 -080028DEFINE_MUTEX(pm_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Len Brown9f9adec2007-12-13 17:38:03 -050030unsigned int pm_flags;
31EXPORT_SYMBOL(pm_flags);
32
Alan Stern82525752007-11-19 23:49:18 +010033#ifdef CONFIG_PM_SLEEP
34
35/* Routines for PM-transition notifications */
36
37static BLOCKING_NOTIFIER_HEAD(pm_chain_head);
38
39int register_pm_notifier(struct notifier_block *nb)
40{
41 return blocking_notifier_chain_register(&pm_chain_head, nb);
42}
43EXPORT_SYMBOL_GPL(register_pm_notifier);
44
45int unregister_pm_notifier(struct notifier_block *nb)
46{
47 return blocking_notifier_chain_unregister(&pm_chain_head, nb);
48}
49EXPORT_SYMBOL_GPL(unregister_pm_notifier);
50
51int pm_notifier_call_chain(unsigned long val)
52{
53 return (blocking_notifier_call_chain(&pm_chain_head, val, NULL)
54 == NOTIFY_BAD) ? -EINVAL : 0;
55}
56
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +010057#ifdef CONFIG_PM_DEBUG
58int pm_test_level = TEST_NONE;
59
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +010060static const char * const pm_tests[__TEST_AFTER_LAST] = {
61 [TEST_NONE] = "none",
62 [TEST_CORE] = "core",
63 [TEST_CPUS] = "processors",
64 [TEST_PLATFORM] = "platform",
65 [TEST_DEVICES] = "devices",
66 [TEST_FREEZER] = "freezer",
67};
68
Rafael J. Wysocki039a75c2008-01-29 00:29:06 +010069static ssize_t pm_test_show(struct kobject *kobj, struct kobj_attribute *attr,
70 char *buf)
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +010071{
72 char *s = buf;
73 int level;
74
75 for (level = TEST_FIRST; level <= TEST_MAX; level++)
76 if (pm_tests[level]) {
77 if (level == pm_test_level)
78 s += sprintf(s, "[%s] ", pm_tests[level]);
79 else
80 s += sprintf(s, "%s ", pm_tests[level]);
81 }
82
83 if (s != buf)
84 /* convert the last space to a newline */
85 *(s-1) = '\n';
86
87 return (s - buf);
88}
89
Rafael J. Wysocki039a75c2008-01-29 00:29:06 +010090static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
91 const char *buf, size_t n)
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +010092{
93 const char * const *s;
94 int level;
95 char *p;
96 int len;
97 int error = -EINVAL;
98
99 p = memchr(buf, '\n', n);
100 len = p ? p - buf : n;
101
102 mutex_lock(&pm_mutex);
103
104 level = TEST_FIRST;
105 for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++)
106 if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) {
107 pm_test_level = level;
108 error = 0;
109 break;
110 }
111
112 mutex_unlock(&pm_mutex);
113
114 return error ? error : n;
115}
116
117power_attr(pm_test);
Rafael J. Wysocki091d71e2009-01-17 00:10:45 +0100118#endif /* CONFIG_PM_DEBUG */
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100119
Rafael J. Wysocki7671b8a2007-12-14 01:07:13 +0100120#endif /* CONFIG_PM_SLEEP */
Rafael J. Wysocki039a75c2008-01-29 00:29:06 +0100121
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200122#ifdef CONFIG_SUSPEND
123
Rafael J. Wysocki091d71e2009-01-17 00:10:45 +0100124static int suspend_test(int level)
125{
126#ifdef CONFIG_PM_DEBUG
127 if (pm_test_level == level) {
128 printk(KERN_INFO "suspend debug: Waiting for 5 seconds.\n");
129 mdelay(5000);
130 return 1;
131 }
132#endif /* !CONFIG_PM_DEBUG */
133 return 0;
134}
135
David Brownell77437fd2008-07-23 21:28:33 -0700136#ifdef CONFIG_PM_TEST_SUSPEND
137
138/*
139 * We test the system suspend code by setting an RTC wakealarm a short
140 * time in the future, then suspending. Suspending the devices won't
141 * normally take long ... some systems only need a few milliseconds.
142 *
143 * The time it takes is system-specific though, so when we test this
144 * during system bootup we allow a LOT of time.
145 */
146#define TEST_SUSPEND_SECONDS 5
147
148static unsigned long suspend_test_start_time;
149
150static void suspend_test_start(void)
151{
152 /* FIXME Use better timebase than "jiffies", ideally a clocksource.
153 * What we want is a hardware counter that will work correctly even
154 * during the irqs-are-off stages of the suspend/resume cycle...
155 */
156 suspend_test_start_time = jiffies;
157}
158
159static void suspend_test_finish(const char *label)
160{
161 long nj = jiffies - suspend_test_start_time;
162 unsigned msec;
163
164 msec = jiffies_to_msecs(abs(nj));
165 pr_info("PM: %s took %d.%03d seconds\n", label,
166 msec / 1000, msec % 1000);
167
168 /* Warning on suspend means the RTC alarm period needs to be
169 * larger -- the system was sooo slooowwww to suspend that the
170 * alarm (should have) fired before the system went to sleep!
171 *
172 * Warning on either suspend or resume also means the system
173 * has some performance issues. The stack dump of a WARN_ON
174 * is more likely to get the right attention than a printk...
175 */
Arjan van de Vena6a0c4c2008-11-18 06:56:51 -0800176 WARN(msec > (TEST_SUSPEND_SECONDS * 1000), "Component: %s\n", label);
David Brownell77437fd2008-07-23 21:28:33 -0700177}
178
179#else
180
181static void suspend_test_start(void)
182{
183}
184
185static void suspend_test_finish(const char *label)
186{
187}
188
189#endif
190
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200191/* This is just an arbitrary number */
192#define FREE_PAGE_NUMBER (100)
193
Rafael J. Wysockif242d912007-10-18 03:04:41 -0700194static struct platform_suspend_ops *suspend_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
196/**
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700197 * suspend_set_ops - Set the global suspend method table.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 * @ops: Pointer to ops structure.
199 */
200
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700201void suspend_set_ops(struct platform_suspend_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202{
Stephen Hemmingera6d70982006-12-06 20:34:35 -0800203 mutex_lock(&pm_mutex);
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700204 suspend_ops = ops;
Stephen Hemmingera6d70982006-12-06 20:34:35 -0800205 mutex_unlock(&pm_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206}
207
Johannes Berge8c9c502007-04-30 15:09:54 -0700208/**
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700209 * suspend_valid_only_mem - generic memory-only valid callback
Johannes Berge8c9c502007-04-30 15:09:54 -0700210 *
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700211 * Platform drivers that implement mem suspend only and only need
Johannes Berge8c9c502007-04-30 15:09:54 -0700212 * to check for that in their .valid callback can use this instead
213 * of rolling their own .valid callback.
214 */
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700215int suspend_valid_only_mem(suspend_state_t state)
Johannes Berge8c9c502007-04-30 15:09:54 -0700216{
217 return state == PM_SUSPEND_MEM;
218}
219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220/**
221 * suspend_prepare - Do prep work before entering low-power state.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 *
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700223 * This is common code that is called for each state that we're entering.
224 * Run suspend notifiers, allocate a console and stop all processes.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 */
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700226static int suspend_prepare(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227{
Rafael J. Wysockie3920fb2006-09-25 23:32:48 -0700228 int error;
David Shaohua Li5ae947e2005-03-18 16:27:13 -0500229 unsigned int free_pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700231 if (!suspend_ops || !suspend_ops->enter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return -EPERM;
233
Johannes Bergaf258f52008-01-11 01:22:23 +0100234 pm_prepare_console();
235
Rafael J. Wysockib10d9112007-07-19 01:47:36 -0700236 error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
237 if (error)
238 goto Finish;
239
Rafael J. Wysocki1bfcf132008-10-15 22:01:21 -0700240 error = usermodehelper_disable();
241 if (error)
242 goto Finish;
243
Johannes Bergb28f5082008-01-15 23:17:00 -0500244 if (suspend_freeze_processes()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 error = -EAGAIN;
246 goto Thaw;
247 }
248
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700249 free_pages = global_page_state(NR_FREE_PAGES);
250 if (free_pages < FREE_PAGE_NUMBER) {
David Shaohua Li5ae947e2005-03-18 16:27:13 -0500251 pr_debug("PM: free some memory\n");
252 shrink_all_memory(FREE_PAGE_NUMBER - free_pages);
253 if (nr_free_pages() < FREE_PAGE_NUMBER) {
254 error = -ENOMEM;
255 printk(KERN_ERR "PM: No enough memory\n");
David Shaohua Li5ae947e2005-03-18 16:27:13 -0500256 }
257 }
Rafael J. Wysockie3c7db622007-02-10 01:43:31 -0800258 if (!error)
259 return 0;
260
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 Thaw:
Johannes Bergb28f5082008-01-15 23:17:00 -0500262 suspend_thaw_processes();
Rafael J. Wysocki1bfcf132008-10-15 22:01:21 -0700263 usermodehelper_enable();
Rafael J. Wysockib10d9112007-07-19 01:47:36 -0700264 Finish:
265 pm_notifier_call_chain(PM_POST_SUSPEND);
Johannes Bergaf258f52008-01-11 01:22:23 +0100266 pm_restore_console();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 return error;
268}
269
Johannes Berga53c46d2007-04-26 11:43:58 +0200270/* default implementation */
271void __attribute__ ((weak)) arch_suspend_disable_irqs(void)
272{
273 local_irq_disable();
274}
275
276/* default implementation */
277void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
278{
279 local_irq_enable();
280}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700282/**
283 * suspend_enter - enter the desired system sleep state.
284 * @state: state to enter
285 *
286 * This function should be called after devices have been suspended.
287 */
Adrian Bunka065c862007-10-18 03:04:37 -0700288static int suspend_enter(suspend_state_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
Rafael J. Wysocki2ed8d2b2009-03-16 22:34:06 +0100290 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
Rafael J. Wysocki1eede072008-05-20 23:00:01 +0200292 device_pm_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
Rafael J. Wysocki2ed8d2b2009-03-16 22:34:06 +0100294 error = device_power_down(PMSG_SUSPEND);
295 if (error) {
Rafael J. Wysocki465d2b42007-12-08 02:08:38 +0100296 printk(KERN_ERR "PM: Some devices failed to power down\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 goto Done;
298 }
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100299
Rafael J. Wysocki900af0d2009-03-16 22:34:15 +0100300 if (suspend_ops->prepare) {
301 error = suspend_ops->prepare();
302 if (error)
303 goto Power_up_devices;
304 }
305
306 if (suspend_test(TEST_PLATFORM))
307 goto Platfrom_finish;
308
309 error = disable_nonboot_cpus();
310 if (error || suspend_test(TEST_CPUS))
311 goto Enable_cpus;
312
Rafael J. Wysocki2ed8d2b2009-03-16 22:34:06 +0100313 arch_suspend_disable_irqs();
314 BUG_ON(!irqs_disabled());
315
Rafael J. Wysocki770824b2009-02-22 18:38:50 +0100316 error = sysdev_suspend(PMSG_SUSPEND);
317 if (!error) {
318 if (!suspend_test(TEST_CORE))
319 error = suspend_ops->enter(state);
320 sysdev_resume();
321 }
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100322
Johannes Berga53c46d2007-04-26 11:43:58 +0200323 arch_suspend_enable_irqs();
324 BUG_ON(irqs_disabled());
Rafael J. Wysocki2ed8d2b2009-03-16 22:34:06 +0100325
Rafael J. Wysocki900af0d2009-03-16 22:34:15 +0100326 Enable_cpus:
327 enable_nonboot_cpus();
328
329 Platfrom_finish:
330 if (suspend_ops->finish)
331 suspend_ops->finish();
332
333 Power_up_devices:
Rafael J. Wysocki2ed8d2b2009-03-16 22:34:06 +0100334 device_power_up(PMSG_RESUME);
335
336 Done:
Rafael J. Wysocki1eede072008-05-20 23:00:01 +0200337 device_pm_unlock();
Rafael J. Wysocki2ed8d2b2009-03-16 22:34:06 +0100338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 return error;
340}
341
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700342/**
Rafael J. Wysocki9628c0e2007-12-08 02:06:00 +0100343 * suspend_devices_and_enter - suspend devices and enter the desired system
344 * sleep state.
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700345 * @state: state to enter
346 */
347int suspend_devices_and_enter(suspend_state_t state)
348{
Ingo Molnarcbe2f5a2008-11-23 10:37:12 +0100349 int error;
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700350
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700351 if (!suspend_ops)
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700352 return -ENOSYS;
353
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100354 if (suspend_ops->begin) {
355 error = suspend_ops->begin(state);
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700356 if (error)
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100357 goto Close;
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700358 }
359 suspend_console();
David Brownell77437fd2008-07-23 21:28:33 -0700360 suspend_test_start();
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700361 error = device_suspend(PMSG_SUSPEND);
362 if (error) {
Rafael J. Wysocki465d2b42007-12-08 02:08:38 +0100363 printk(KERN_ERR "PM: Some devices failed to suspend\n");
Rafael J. Wysockid8f3de02008-06-12 23:24:06 +0200364 goto Recover_platform;
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700365 }
David Brownell77437fd2008-07-23 21:28:33 -0700366 suspend_test_finish("suspend devices");
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100367 if (suspend_test(TEST_DEVICES))
Rafael J. Wysockid8f3de02008-06-12 23:24:06 +0200368 goto Recover_platform;
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100369
Rafael J. Wysocki900af0d2009-03-16 22:34:15 +0100370 suspend_enter(state);
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100371
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700372 Resume_devices:
David Brownell77437fd2008-07-23 21:28:33 -0700373 suspend_test_start();
Rafael J. Wysocki1eede072008-05-20 23:00:01 +0200374 device_resume(PMSG_RESUME);
David Brownell77437fd2008-07-23 21:28:33 -0700375 suspend_test_finish("resume devices");
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700376 resume_console();
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100377 Close:
378 if (suspend_ops->end)
379 suspend_ops->end();
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700380 return error;
Rafael J. Wysockid8f3de02008-06-12 23:24:06 +0200381
382 Recover_platform:
383 if (suspend_ops->recover)
384 suspend_ops->recover();
385 goto Resume_devices;
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700386}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
388/**
389 * suspend_finish - Do final work before exiting suspend sequence.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 *
391 * Call platform code to clean up, restart processes, and free the
392 * console that we've allocated. This is not called for suspend-to-disk.
393 */
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700394static void suspend_finish(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395{
Johannes Bergb28f5082008-01-15 23:17:00 -0500396 suspend_thaw_processes();
Rafael J. Wysocki1bfcf132008-10-15 22:01:21 -0700397 usermodehelper_enable();
Rafael J. Wysockib10d9112007-07-19 01:47:36 -0700398 pm_notifier_call_chain(PM_POST_SUSPEND);
Johannes Bergaf258f52008-01-11 01:22:23 +0100399 pm_restore_console();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400}
401
402
403
404
Andreas Mohr3b364b82006-06-25 05:47:56 -0700405static const char * const pm_states[PM_SUSPEND_MAX] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 [PM_SUSPEND_STANDBY] = "standby",
407 [PM_SUSPEND_MEM] = "mem",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408};
409
Pavel Machek123d3c12005-11-29 19:34:37 -0800410static inline int valid_state(suspend_state_t state)
411{
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700412 /* All states need lowlevel support and need to be valid
413 * to the lowlevel implementation, no valid callback
Johannes Berg9684e512007-04-30 15:09:55 -0700414 * implies that none are valid. */
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700415 if (!suspend_ops || !suspend_ops->valid || !suspend_ops->valid(state))
Pavel Machek123d3c12005-11-29 19:34:37 -0800416 return 0;
417 return 1;
418}
419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420
421/**
422 * enter_state - Do common work of entering low-power state.
423 * @state: pm_state structure for state we're entering.
424 *
425 * Make sure we're the only ones trying to enter a sleep state. Fail
426 * if someone has beat us to it, since we don't want anything weird to
427 * happen when we wake up.
428 * Then, do the setup for suspend, enter the state, and cleaup (after
429 * we've woken up).
430 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431static int enter_state(suspend_state_t state)
432{
433 int error;
434
Pavel Machek123d3c12005-11-29 19:34:37 -0800435 if (!valid_state(state))
Shaohua Lieb9289e2005-10-30 15:00:01 -0800436 return -ENODEV;
Rafael J. Wysocki232b1432007-10-18 03:04:44 -0700437
Stephen Hemmingera6d70982006-12-06 20:34:35 -0800438 if (!mutex_trylock(&pm_mutex))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 return -EBUSY;
440
Rafael J. Wysocki465d2b42007-12-08 02:08:38 +0100441 printk(KERN_INFO "PM: Syncing filesystems ... ");
Rafael J. Wysocki232b1432007-10-18 03:04:44 -0700442 sys_sync();
443 printk("done.\n");
444
David Brownell82428b62005-05-09 08:07:00 -0700445 pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100446 error = suspend_prepare();
447 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 goto Unlock;
449
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100450 if (suspend_test(TEST_FREEZER))
451 goto Finish;
452
David Brownell82428b62005-05-09 08:07:00 -0700453 pr_debug("PM: Entering %s sleep\n", pm_states[state]);
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700454 error = suspend_devices_and_enter(state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100456 Finish:
David Brownell82428b62005-05-09 08:07:00 -0700457 pr_debug("PM: Finishing wakeup.\n");
Rafael J. Wysocki6c961df2007-07-19 01:47:38 -0700458 suspend_finish();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 Unlock:
Stephen Hemmingera6d70982006-12-06 20:34:35 -0800460 mutex_unlock(&pm_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 return error;
462}
463
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465/**
466 * pm_suspend - Externally visible function for suspending system.
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700467 * @state: Enumerated value of state to enter.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 *
469 * Determine whether or not value is within range, get state
470 * structure, and enter (above).
471 */
472
473int pm_suspend(suspend_state_t state)
474{
Alexey Starikovskiye2a5b422005-03-18 16:20:46 -0500475 if (state > PM_SUSPEND_ON && state <= PM_SUSPEND_MAX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 return enter_state(state);
477 return -EINVAL;
478}
479
Ralf Baechle4cf30342006-12-06 20:36:06 -0800480EXPORT_SYMBOL(pm_suspend);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200482#endif /* CONFIG_SUSPEND */
483
Greg Kroah-Hartmand76e15f2007-11-27 11:28:26 -0800484struct kobject *power_kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486/**
487 * state - control system power state.
488 *
489 * show() returns what states are supported, which is hard-coded to
490 * 'standby' (Power-On Suspend), 'mem' (Suspend-to-RAM), and
491 * 'disk' (Suspend-to-Disk).
492 *
493 * store() accepts one of those strings, translates it into the
494 * proper enumerated value, and initiates a suspend transition.
495 */
496
Kay Sievers386f2752007-11-02 13:47:53 +0100497static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
498 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499{
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200500 char *s = buf;
501#ifdef CONFIG_SUSPEND
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504 for (i = 0; i < PM_SUSPEND_MAX; i++) {
Pavel Machek123d3c12005-11-29 19:34:37 -0800505 if (pm_states[i] && valid_state(i))
506 s += sprintf(s,"%s ", pm_states[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 }
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200508#endif
Rafael J. Wysockib0cb1a12007-07-29 23:24:36 +0200509#ifdef CONFIG_HIBERNATION
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700510 s += sprintf(s, "%s\n", "disk");
511#else
512 if (s != buf)
513 /* convert the last space to a newline */
514 *(s-1) = '\n';
515#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 return (s - buf);
517}
518
Kay Sievers386f2752007-11-02 13:47:53 +0100519static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
520 const char *buf, size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521{
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200522#ifdef CONFIG_SUSPEND
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 suspend_state_t state = PM_SUSPEND_STANDBY;
Andreas Mohr3b364b82006-06-25 05:47:56 -0700524 const char * const *s;
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200525#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 char *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 int len;
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200528 int error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
530 p = memchr(buf, '\n', n);
531 len = p ? p - buf : n;
532
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700533 /* First, check if we are requested to hibernate */
Rafael J. Wysocki8d98a692007-05-16 22:11:19 -0700534 if (len == 4 && !strncmp(buf, "disk", len)) {
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700535 error = hibernate();
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200536 goto Exit;
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700537 }
538
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200539#ifdef CONFIG_SUSPEND
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {
Rafael J. Wysocki8d98a692007-05-16 22:11:19 -0700541 if (*s && len == strlen(*s) && !strncmp(buf, *s, len))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 break;
543 }
dean gaudet47bb7892006-04-27 18:39:17 -0700544 if (state < PM_SUSPEND_MAX && *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 error = enter_state(state);
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200546#endif
547
548 Exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 return error ? error : n;
550}
551
552power_attr(state);
553
Rafael J. Wysockic5c6ba42006-09-25 23:32:58 -0700554#ifdef CONFIG_PM_TRACE
555int pm_trace_enabled;
556
Kay Sievers386f2752007-11-02 13:47:53 +0100557static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
558 char *buf)
Rafael J. Wysockic5c6ba42006-09-25 23:32:58 -0700559{
560 return sprintf(buf, "%d\n", pm_trace_enabled);
561}
562
563static ssize_t
Kay Sievers386f2752007-11-02 13:47:53 +0100564pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
565 const char *buf, size_t n)
Rafael J. Wysockic5c6ba42006-09-25 23:32:58 -0700566{
567 int val;
568
569 if (sscanf(buf, "%d", &val) == 1) {
570 pm_trace_enabled = !!val;
571 return n;
572 }
573 return -EINVAL;
574}
575
576power_attr(pm_trace);
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100577#endif /* CONFIG_PM_TRACE */
Rafael J. Wysockic5c6ba42006-09-25 23:32:58 -0700578
579static struct attribute * g[] = {
580 &state_attr.attr,
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100581#ifdef CONFIG_PM_TRACE
Rafael J. Wysockic5c6ba42006-09-25 23:32:58 -0700582 &pm_trace_attr.attr,
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100583#endif
Rafael J. Wysocki7671b8a2007-12-14 01:07:13 +0100584#if defined(CONFIG_PM_SLEEP) && defined(CONFIG_PM_DEBUG)
Rafael J. Wysocki0e7d56e2007-11-19 23:41:19 +0100585 &pm_test_attr.attr,
586#endif
Rafael J. Wysockic5c6ba42006-09-25 23:32:58 -0700587 NULL,
588};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
590static struct attribute_group attr_group = {
591 .attrs = g,
592};
593
594
595static int __init pm_init(void)
596{
Greg Kroah-Hartmand76e15f2007-11-27 11:28:26 -0800597 power_kobj = kobject_create_and_add("power", NULL);
598 if (!power_kobj)
Greg Kroah-Hartman039a5dc2007-11-01 10:39:50 -0700599 return -ENOMEM;
Greg Kroah-Hartmand76e15f2007-11-27 11:28:26 -0800600 return sysfs_create_group(power_kobj, &attr_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601}
602
603core_initcall(pm_init);
David Brownell77437fd2008-07-23 21:28:33 -0700604
605
606#ifdef CONFIG_PM_TEST_SUSPEND
607
608#include <linux/rtc.h>
609
610/*
611 * To test system suspend, we need a hands-off mechanism to resume the
612 * system. RTCs wake alarms are a common self-contained mechanism.
613 */
614
615static void __init test_wakealarm(struct rtc_device *rtc, suspend_state_t state)
616{
617 static char err_readtime[] __initdata =
618 KERN_ERR "PM: can't read %s time, err %d\n";
619 static char err_wakealarm [] __initdata =
620 KERN_ERR "PM: can't set %s wakealarm, err %d\n";
621 static char err_suspend[] __initdata =
622 KERN_ERR "PM: suspend test failed, error %d\n";
623 static char info_test[] __initdata =
624 KERN_INFO "PM: test RTC wakeup from '%s' suspend\n";
625
626 unsigned long now;
627 struct rtc_wkalrm alm;
628 int status;
629
630 /* this may fail if the RTC hasn't been initialized */
631 status = rtc_read_time(rtc, &alm.time);
632 if (status < 0) {
Kay Sievers81ff86a2009-01-06 10:44:39 -0800633 printk(err_readtime, dev_name(&rtc->dev), status);
David Brownell77437fd2008-07-23 21:28:33 -0700634 return;
635 }
636 rtc_tm_to_time(&alm.time, &now);
637
638 memset(&alm, 0, sizeof alm);
639 rtc_time_to_tm(now + TEST_SUSPEND_SECONDS, &alm.time);
640 alm.enabled = true;
641
642 status = rtc_set_alarm(rtc, &alm);
643 if (status < 0) {
Kay Sievers81ff86a2009-01-06 10:44:39 -0800644 printk(err_wakealarm, dev_name(&rtc->dev), status);
David Brownell77437fd2008-07-23 21:28:33 -0700645 return;
646 }
647
648 if (state == PM_SUSPEND_MEM) {
649 printk(info_test, pm_states[state]);
650 status = pm_suspend(state);
651 if (status == -ENODEV)
652 state = PM_SUSPEND_STANDBY;
653 }
654 if (state == PM_SUSPEND_STANDBY) {
655 printk(info_test, pm_states[state]);
656 status = pm_suspend(state);
657 }
658 if (status < 0)
659 printk(err_suspend, status);
David Brownella2e2e352008-07-25 19:44:38 -0700660
661 /* Some platforms can't detect that the alarm triggered the
662 * wakeup, or (accordingly) disable it after it afterwards.
663 * It's supposed to give oneshot behavior; cope.
664 */
665 alm.enabled = false;
666 rtc_set_alarm(rtc, &alm);
David Brownell77437fd2008-07-23 21:28:33 -0700667}
668
669static int __init has_wakealarm(struct device *dev, void *name_ptr)
670{
671 struct rtc_device *candidate = to_rtc_device(dev);
672
673 if (!candidate->ops->set_alarm)
674 return 0;
675 if (!device_may_wakeup(candidate->dev.parent))
676 return 0;
677
Kay Sievers81ff86a2009-01-06 10:44:39 -0800678 *(const char **)name_ptr = dev_name(dev);
David Brownell77437fd2008-07-23 21:28:33 -0700679 return 1;
680}
681
682/*
683 * Kernel options like "test_suspend=mem" force suspend/resume sanity tests
684 * at startup time. They're normally disabled, for faster boot and because
685 * we can't know which states really work on this particular system.
686 */
687static suspend_state_t test_state __initdata = PM_SUSPEND_ON;
688
689static char warn_bad_state[] __initdata =
690 KERN_WARNING "PM: can't test '%s' suspend state\n";
691
692static int __init setup_test_suspend(char *value)
693{
694 unsigned i;
695
696 /* "=mem" ==> "mem" */
697 value++;
698 for (i = 0; i < PM_SUSPEND_MAX; i++) {
699 if (!pm_states[i])
700 continue;
701 if (strcmp(pm_states[i], value) != 0)
702 continue;
703 test_state = (__force suspend_state_t) i;
704 return 0;
705 }
706 printk(warn_bad_state, value);
707 return 0;
708}
709__setup("test_suspend", setup_test_suspend);
710
711static int __init test_suspend(void)
712{
713 static char warn_no_rtc[] __initdata =
714 KERN_WARNING "PM: no wakealarm-capable RTC driver is ready\n";
715
716 char *pony = NULL;
717 struct rtc_device *rtc = NULL;
718
719 /* PM is initialized by now; is that state testable? */
720 if (test_state == PM_SUSPEND_ON)
721 goto done;
722 if (!valid_state(test_state)) {
723 printk(warn_bad_state, pm_states[test_state]);
724 goto done;
725 }
726
727 /* RTCs have initialized by now too ... can we use one? */
728 class_find_device(rtc_class, NULL, &pony, has_wakealarm);
729 if (pony)
730 rtc = rtc_class_open(pony);
731 if (!rtc) {
732 printk(warn_no_rtc);
733 goto done;
734 }
735
736 /* go for it */
737 test_wakealarm(rtc, test_state);
738 rtc_class_close(rtc);
739done:
740 return 0;
741}
742late_initcall(test_suspend);
743
744#endif /* CONFIG_PM_TEST_SUSPEND */