Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * kernel/power/main.c - PM subsystem core functionality. |
| 3 | * |
| 4 | * Copyright (c) 2003 Patrick Mochel |
| 5 | * Copyright (c) 2003 Open Source Development Lab |
Srivatsa S. Bhat | 341d416 | 2011-11-19 14:39:01 +0100 | [diff] [blame] | 6 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | * This file is released under the GPLv2 |
| 8 | * |
| 9 | */ |
| 10 | |
Paul Gortmaker | 6e5fdee | 2011-05-26 16:00:52 -0400 | [diff] [blame] | 11 | #include <linux/export.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | #include <linux/kobject.h> |
| 13 | #include <linux/string.h> |
Rafael J. Wysocki | c5c6ba4 | 2006-09-25 23:32:58 -0700 | [diff] [blame] | 14 | #include <linux/resume-trace.h> |
Rafael J. Wysocki | 5e928f7 | 2009-08-18 23:38:32 +0200 | [diff] [blame] | 15 | #include <linux/workqueue.h> |
ShuoX Liu | 2a77c46 | 2011-08-10 23:01:26 +0200 | [diff] [blame] | 16 | #include <linux/debugfs.h> |
| 17 | #include <linux/seq_file.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | |
| 19 | #include "power.h" |
| 20 | |
Stephen Hemminger | a6d7098 | 2006-12-06 20:34:35 -0800 | [diff] [blame] | 21 | DEFINE_MUTEX(pm_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | |
Rafael J. Wysocki | cd51e61c | 2011-02-11 00:04:52 +0100 | [diff] [blame] | 23 | #ifdef CONFIG_PM_SLEEP |
| 24 | |
Alan Stern | 8252575 | 2007-11-19 23:49:18 +0100 | [diff] [blame] | 25 | /* Routines for PM-transition notifications */ |
| 26 | |
| 27 | static BLOCKING_NOTIFIER_HEAD(pm_chain_head); |
| 28 | |
| 29 | int register_pm_notifier(struct notifier_block *nb) |
| 30 | { |
| 31 | return blocking_notifier_chain_register(&pm_chain_head, nb); |
| 32 | } |
| 33 | EXPORT_SYMBOL_GPL(register_pm_notifier); |
| 34 | |
| 35 | int unregister_pm_notifier(struct notifier_block *nb) |
| 36 | { |
| 37 | return blocking_notifier_chain_unregister(&pm_chain_head, nb); |
| 38 | } |
| 39 | EXPORT_SYMBOL_GPL(unregister_pm_notifier); |
| 40 | |
| 41 | int pm_notifier_call_chain(unsigned long val) |
| 42 | { |
Akinobu Mita | f0c077a | 2011-07-08 20:53:36 +0200 | [diff] [blame] | 43 | int ret = blocking_notifier_call_chain(&pm_chain_head, val, NULL); |
| 44 | |
| 45 | return notifier_to_errno(ret); |
Alan Stern | 8252575 | 2007-11-19 23:49:18 +0100 | [diff] [blame] | 46 | } |
| 47 | |
Rafael J. Wysocki | 0e06b4a | 2010-01-23 22:25:15 +0100 | [diff] [blame] | 48 | /* If set, devices may be suspended and resumed asynchronously. */ |
| 49 | int pm_async_enabled = 1; |
| 50 | |
| 51 | static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr, |
| 52 | char *buf) |
| 53 | { |
| 54 | return sprintf(buf, "%d\n", pm_async_enabled); |
| 55 | } |
| 56 | |
| 57 | static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr, |
| 58 | const char *buf, size_t n) |
| 59 | { |
| 60 | unsigned long val; |
| 61 | |
| 62 | if (strict_strtoul(buf, 10, &val)) |
| 63 | return -EINVAL; |
| 64 | |
| 65 | if (val > 1) |
| 66 | return -EINVAL; |
| 67 | |
| 68 | pm_async_enabled = val; |
| 69 | return n; |
| 70 | } |
| 71 | |
| 72 | power_attr(pm_async); |
| 73 | |
Rafael J. Wysocki | 0e7d56e | 2007-11-19 23:41:19 +0100 | [diff] [blame] | 74 | #ifdef CONFIG_PM_DEBUG |
| 75 | int pm_test_level = TEST_NONE; |
| 76 | |
Rafael J. Wysocki | 0e7d56e | 2007-11-19 23:41:19 +0100 | [diff] [blame] | 77 | static const char * const pm_tests[__TEST_AFTER_LAST] = { |
| 78 | [TEST_NONE] = "none", |
| 79 | [TEST_CORE] = "core", |
| 80 | [TEST_CPUS] = "processors", |
| 81 | [TEST_PLATFORM] = "platform", |
| 82 | [TEST_DEVICES] = "devices", |
| 83 | [TEST_FREEZER] = "freezer", |
| 84 | }; |
| 85 | |
Rafael J. Wysocki | 039a75c | 2008-01-29 00:29:06 +0100 | [diff] [blame] | 86 | static ssize_t pm_test_show(struct kobject *kobj, struct kobj_attribute *attr, |
| 87 | char *buf) |
Rafael J. Wysocki | 0e7d56e | 2007-11-19 23:41:19 +0100 | [diff] [blame] | 88 | { |
| 89 | char *s = buf; |
| 90 | int level; |
| 91 | |
| 92 | for (level = TEST_FIRST; level <= TEST_MAX; level++) |
| 93 | if (pm_tests[level]) { |
| 94 | if (level == pm_test_level) |
| 95 | s += sprintf(s, "[%s] ", pm_tests[level]); |
| 96 | else |
| 97 | s += sprintf(s, "%s ", pm_tests[level]); |
| 98 | } |
| 99 | |
| 100 | if (s != buf) |
| 101 | /* convert the last space to a newline */ |
| 102 | *(s-1) = '\n'; |
| 103 | |
| 104 | return (s - buf); |
| 105 | } |
| 106 | |
Rafael J. Wysocki | 039a75c | 2008-01-29 00:29:06 +0100 | [diff] [blame] | 107 | static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr, |
| 108 | const char *buf, size_t n) |
Rafael J. Wysocki | 0e7d56e | 2007-11-19 23:41:19 +0100 | [diff] [blame] | 109 | { |
| 110 | const char * const *s; |
| 111 | int level; |
| 112 | char *p; |
| 113 | int len; |
| 114 | int error = -EINVAL; |
| 115 | |
| 116 | p = memchr(buf, '\n', n); |
| 117 | len = p ? p - buf : n; |
| 118 | |
Srivatsa S. Bhat | bcda53f | 2011-12-07 22:29:54 +0100 | [diff] [blame] | 119 | lock_system_sleep(); |
Rafael J. Wysocki | 0e7d56e | 2007-11-19 23:41:19 +0100 | [diff] [blame] | 120 | |
| 121 | level = TEST_FIRST; |
| 122 | for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++) |
| 123 | if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) { |
| 124 | pm_test_level = level; |
| 125 | error = 0; |
| 126 | break; |
| 127 | } |
| 128 | |
Srivatsa S. Bhat | bcda53f | 2011-12-07 22:29:54 +0100 | [diff] [blame] | 129 | unlock_system_sleep(); |
Rafael J. Wysocki | 0e7d56e | 2007-11-19 23:41:19 +0100 | [diff] [blame] | 130 | |
| 131 | return error ? error : n; |
| 132 | } |
| 133 | |
| 134 | power_attr(pm_test); |
Rafael J. Wysocki | 091d71e | 2009-01-17 00:10:45 +0100 | [diff] [blame] | 135 | #endif /* CONFIG_PM_DEBUG */ |
Rafael J. Wysocki | 0e7d56e | 2007-11-19 23:41:19 +0100 | [diff] [blame] | 136 | |
ShuoX Liu | 2a77c46 | 2011-08-10 23:01:26 +0200 | [diff] [blame] | 137 | #ifdef CONFIG_DEBUG_FS |
| 138 | static char *suspend_step_name(enum suspend_stat_step step) |
| 139 | { |
| 140 | switch (step) { |
| 141 | case SUSPEND_FREEZE: |
| 142 | return "freeze"; |
| 143 | case SUSPEND_PREPARE: |
| 144 | return "prepare"; |
| 145 | case SUSPEND_SUSPEND: |
| 146 | return "suspend"; |
| 147 | case SUSPEND_SUSPEND_NOIRQ: |
| 148 | return "suspend_noirq"; |
| 149 | case SUSPEND_RESUME_NOIRQ: |
| 150 | return "resume_noirq"; |
| 151 | case SUSPEND_RESUME: |
| 152 | return "resume"; |
| 153 | default: |
| 154 | return ""; |
| 155 | } |
| 156 | } |
| 157 | |
| 158 | static int suspend_stats_show(struct seq_file *s, void *unused) |
| 159 | { |
| 160 | int i, index, last_dev, last_errno, last_step; |
| 161 | |
| 162 | last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1; |
| 163 | last_dev %= REC_FAILED_NUM; |
| 164 | last_errno = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1; |
| 165 | last_errno %= REC_FAILED_NUM; |
| 166 | last_step = suspend_stats.last_failed_step + REC_FAILED_NUM - 1; |
| 167 | last_step %= REC_FAILED_NUM; |
Rafael J. Wysocki | cf579df | 2012-01-29 20:38:29 +0100 | [diff] [blame] | 168 | seq_printf(s, "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n" |
| 169 | "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n", |
ShuoX Liu | 2a77c46 | 2011-08-10 23:01:26 +0200 | [diff] [blame] | 170 | "success", suspend_stats.success, |
| 171 | "fail", suspend_stats.fail, |
| 172 | "failed_freeze", suspend_stats.failed_freeze, |
| 173 | "failed_prepare", suspend_stats.failed_prepare, |
| 174 | "failed_suspend", suspend_stats.failed_suspend, |
Rafael J. Wysocki | cf579df | 2012-01-29 20:38:29 +0100 | [diff] [blame] | 175 | "failed_suspend_late", |
| 176 | suspend_stats.failed_suspend_late, |
ShuoX Liu | 2a77c46 | 2011-08-10 23:01:26 +0200 | [diff] [blame] | 177 | "failed_suspend_noirq", |
| 178 | suspend_stats.failed_suspend_noirq, |
| 179 | "failed_resume", suspend_stats.failed_resume, |
Rafael J. Wysocki | cf579df | 2012-01-29 20:38:29 +0100 | [diff] [blame] | 180 | "failed_resume_early", |
| 181 | suspend_stats.failed_resume_early, |
ShuoX Liu | 2a77c46 | 2011-08-10 23:01:26 +0200 | [diff] [blame] | 182 | "failed_resume_noirq", |
| 183 | suspend_stats.failed_resume_noirq); |
| 184 | seq_printf(s, "failures:\n last_failed_dev:\t%-s\n", |
| 185 | suspend_stats.failed_devs[last_dev]); |
| 186 | for (i = 1; i < REC_FAILED_NUM; i++) { |
| 187 | index = last_dev + REC_FAILED_NUM - i; |
| 188 | index %= REC_FAILED_NUM; |
| 189 | seq_printf(s, "\t\t\t%-s\n", |
| 190 | suspend_stats.failed_devs[index]); |
| 191 | } |
| 192 | seq_printf(s, " last_failed_errno:\t%-d\n", |
| 193 | suspend_stats.errno[last_errno]); |
| 194 | for (i = 1; i < REC_FAILED_NUM; i++) { |
| 195 | index = last_errno + REC_FAILED_NUM - i; |
| 196 | index %= REC_FAILED_NUM; |
| 197 | seq_printf(s, "\t\t\t%-d\n", |
| 198 | suspend_stats.errno[index]); |
| 199 | } |
| 200 | seq_printf(s, " last_failed_step:\t%-s\n", |
| 201 | suspend_step_name( |
| 202 | suspend_stats.failed_steps[last_step])); |
| 203 | for (i = 1; i < REC_FAILED_NUM; i++) { |
| 204 | index = last_step + REC_FAILED_NUM - i; |
| 205 | index %= REC_FAILED_NUM; |
| 206 | seq_printf(s, "\t\t\t%-s\n", |
| 207 | suspend_step_name( |
| 208 | suspend_stats.failed_steps[index])); |
| 209 | } |
| 210 | |
| 211 | return 0; |
| 212 | } |
| 213 | |
| 214 | static int suspend_stats_open(struct inode *inode, struct file *file) |
| 215 | { |
| 216 | return single_open(file, suspend_stats_show, NULL); |
| 217 | } |
| 218 | |
| 219 | static const struct file_operations suspend_stats_operations = { |
| 220 | .open = suspend_stats_open, |
| 221 | .read = seq_read, |
| 222 | .llseek = seq_lseek, |
| 223 | .release = single_release, |
| 224 | }; |
| 225 | |
| 226 | static int __init pm_debugfs_init(void) |
| 227 | { |
| 228 | debugfs_create_file("suspend_stats", S_IFREG | S_IRUGO, |
| 229 | NULL, NULL, &suspend_stats_operations); |
| 230 | return 0; |
| 231 | } |
| 232 | |
| 233 | late_initcall(pm_debugfs_init); |
| 234 | #endif /* CONFIG_DEBUG_FS */ |
| 235 | |
Rafael J. Wysocki | ca12310 | 2011-08-11 22:38:12 +0200 | [diff] [blame] | 236 | #endif /* CONFIG_PM_SLEEP */ |
| 237 | |
Greg Kroah-Hartman | d76e15f | 2007-11-27 11:28:26 -0800 | [diff] [blame] | 238 | struct kobject *power_kobj; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 239 | |
| 240 | /** |
| 241 | * state - control system power state. |
| 242 | * |
| 243 | * show() returns what states are supported, which is hard-coded to |
| 244 | * 'standby' (Power-On Suspend), 'mem' (Suspend-to-RAM), and |
| 245 | * 'disk' (Suspend-to-Disk). |
| 246 | * |
Srivatsa S. Bhat | 341d416 | 2011-11-19 14:39:01 +0100 | [diff] [blame] | 247 | * store() accepts one of those strings, translates it into the |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | * proper enumerated value, and initiates a suspend transition. |
| 249 | */ |
Kay Sievers | 386f275 | 2007-11-02 13:47:53 +0100 | [diff] [blame] | 250 | static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr, |
| 251 | char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | { |
Rafael J. Wysocki | 296699d | 2007-07-29 23:27:18 +0200 | [diff] [blame] | 253 | char *s = buf; |
| 254 | #ifdef CONFIG_SUSPEND |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | |
| 257 | for (i = 0; i < PM_SUSPEND_MAX; i++) { |
Pavel Machek | 123d3c1 | 2005-11-29 19:34:37 -0800 | [diff] [blame] | 258 | if (pm_states[i] && valid_state(i)) |
| 259 | s += sprintf(s,"%s ", pm_states[i]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | } |
Rafael J. Wysocki | 296699d | 2007-07-29 23:27:18 +0200 | [diff] [blame] | 261 | #endif |
Rafael J. Wysocki | b0cb1a1 | 2007-07-29 23:24:36 +0200 | [diff] [blame] | 262 | #ifdef CONFIG_HIBERNATION |
Rafael J. Wysocki | a3d25c2 | 2007-05-09 02:33:18 -0700 | [diff] [blame] | 263 | s += sprintf(s, "%s\n", "disk"); |
| 264 | #else |
| 265 | if (s != buf) |
| 266 | /* convert the last space to a newline */ |
| 267 | *(s-1) = '\n'; |
| 268 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | return (s - buf); |
| 270 | } |
| 271 | |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 272 | static suspend_state_t decode_state(const char *buf, size_t n) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 273 | { |
Rafael J. Wysocki | 296699d | 2007-07-29 23:27:18 +0200 | [diff] [blame] | 274 | #ifdef CONFIG_SUSPEND |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 275 | suspend_state_t state = PM_SUSPEND_STANDBY; |
Andreas Mohr | 3b364b8 | 2006-06-25 05:47:56 -0700 | [diff] [blame] | 276 | const char * const *s; |
Rafael J. Wysocki | 296699d | 2007-07-29 23:27:18 +0200 | [diff] [blame] | 277 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | char *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | int len; |
| 280 | |
| 281 | p = memchr(buf, '\n', n); |
| 282 | len = p ? p - buf : n; |
| 283 | |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 284 | /* Check hibernation first. */ |
| 285 | if (len == 4 && !strncmp(buf, "disk", len)) |
| 286 | return PM_SUSPEND_MAX; |
Rafael J. Wysocki | a3d25c2 | 2007-05-09 02:33:18 -0700 | [diff] [blame] | 287 | |
Rafael J. Wysocki | 296699d | 2007-07-29 23:27:18 +0200 | [diff] [blame] | 288 | #ifdef CONFIG_SUSPEND |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 289 | for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) |
| 290 | if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) |
| 291 | return state; |
Rafael J. Wysocki | 296699d | 2007-07-29 23:27:18 +0200 | [diff] [blame] | 292 | #endif |
| 293 | |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 294 | return PM_SUSPEND_ON; |
| 295 | } |
| 296 | |
| 297 | static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr, |
| 298 | const char *buf, size_t n) |
| 299 | { |
| 300 | suspend_state_t state; |
| 301 | int error; |
| 302 | |
| 303 | error = pm_autosleep_lock(); |
| 304 | if (error) |
| 305 | return error; |
| 306 | |
| 307 | if (pm_autosleep_state() > PM_SUSPEND_ON) { |
| 308 | error = -EBUSY; |
| 309 | goto out; |
| 310 | } |
| 311 | |
| 312 | state = decode_state(buf, n); |
| 313 | if (state < PM_SUSPEND_MAX) |
| 314 | error = pm_suspend(state); |
| 315 | else if (state == PM_SUSPEND_MAX) |
| 316 | error = hibernate(); |
| 317 | else |
| 318 | error = -EINVAL; |
| 319 | |
| 320 | out: |
| 321 | pm_autosleep_unlock(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | return error ? error : n; |
| 323 | } |
| 324 | |
| 325 | power_attr(state); |
| 326 | |
Rafael J. Wysocki | c125e96 | 2010-07-05 22:43:53 +0200 | [diff] [blame] | 327 | #ifdef CONFIG_PM_SLEEP |
| 328 | /* |
| 329 | * The 'wakeup_count' attribute, along with the functions defined in |
| 330 | * drivers/base/power/wakeup.c, provides a means by which wakeup events can be |
| 331 | * handled in a non-racy way. |
| 332 | * |
| 333 | * If a wakeup event occurs when the system is in a sleep state, it simply is |
| 334 | * woken up. In turn, if an event that would wake the system up from a sleep |
| 335 | * state occurs when it is undergoing a transition to that sleep state, the |
| 336 | * transition should be aborted. Moreover, if such an event occurs when the |
| 337 | * system is in the working state, an attempt to start a transition to the |
| 338 | * given sleep state should fail during certain period after the detection of |
| 339 | * the event. Using the 'state' attribute alone is not sufficient to satisfy |
| 340 | * these requirements, because a wakeup event may occur exactly when 'state' |
| 341 | * is being written to and may be delivered to user space right before it is |
| 342 | * frozen, so the event will remain only partially processed until the system is |
| 343 | * woken up by another event. In particular, it won't cause the transition to |
| 344 | * a sleep state to be aborted. |
| 345 | * |
| 346 | * This difficulty may be overcome if user space uses 'wakeup_count' before |
| 347 | * writing to 'state'. It first should read from 'wakeup_count' and store |
| 348 | * the read value. Then, after carrying out its own preparations for the system |
| 349 | * transition to a sleep state, it should write the stored value to |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 350 | * 'wakeup_count'. If that fails, at least one wakeup event has occurred since |
Rafael J. Wysocki | c125e96 | 2010-07-05 22:43:53 +0200 | [diff] [blame] | 351 | * 'wakeup_count' was read and 'state' should not be written to. Otherwise, it |
| 352 | * is allowed to write to 'state', but the transition will be aborted if there |
| 353 | * are any wakeup events detected after 'wakeup_count' was written to. |
| 354 | */ |
| 355 | |
| 356 | static ssize_t wakeup_count_show(struct kobject *kobj, |
| 357 | struct kobj_attribute *attr, |
| 358 | char *buf) |
| 359 | { |
Rafael J. Wysocki | 074037e | 2010-09-22 22:09:10 +0200 | [diff] [blame] | 360 | unsigned int val; |
Rafael J. Wysocki | c125e96 | 2010-07-05 22:43:53 +0200 | [diff] [blame] | 361 | |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 362 | return pm_get_wakeup_count(&val, true) ? |
| 363 | sprintf(buf, "%u\n", val) : -EINTR; |
Rafael J. Wysocki | c125e96 | 2010-07-05 22:43:53 +0200 | [diff] [blame] | 364 | } |
| 365 | |
| 366 | static ssize_t wakeup_count_store(struct kobject *kobj, |
| 367 | struct kobj_attribute *attr, |
| 368 | const char *buf, size_t n) |
| 369 | { |
Rafael J. Wysocki | 074037e | 2010-09-22 22:09:10 +0200 | [diff] [blame] | 370 | unsigned int val; |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 371 | int error; |
Rafael J. Wysocki | c125e96 | 2010-07-05 22:43:53 +0200 | [diff] [blame] | 372 | |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 373 | error = pm_autosleep_lock(); |
| 374 | if (error) |
| 375 | return error; |
| 376 | |
| 377 | if (pm_autosleep_state() > PM_SUSPEND_ON) { |
| 378 | error = -EBUSY; |
| 379 | goto out; |
| 380 | } |
| 381 | |
| 382 | error = -EINVAL; |
Rafael J. Wysocki | 074037e | 2010-09-22 22:09:10 +0200 | [diff] [blame] | 383 | if (sscanf(buf, "%u", &val) == 1) { |
Rafael J. Wysocki | c125e96 | 2010-07-05 22:43:53 +0200 | [diff] [blame] | 384 | if (pm_save_wakeup_count(val)) |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 385 | error = n; |
Rafael J. Wysocki | c125e96 | 2010-07-05 22:43:53 +0200 | [diff] [blame] | 386 | } |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 387 | |
| 388 | out: |
| 389 | pm_autosleep_unlock(); |
| 390 | return error; |
Rafael J. Wysocki | c125e96 | 2010-07-05 22:43:53 +0200 | [diff] [blame] | 391 | } |
| 392 | |
| 393 | power_attr(wakeup_count); |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 394 | |
| 395 | #ifdef CONFIG_PM_AUTOSLEEP |
| 396 | static ssize_t autosleep_show(struct kobject *kobj, |
| 397 | struct kobj_attribute *attr, |
| 398 | char *buf) |
| 399 | { |
| 400 | suspend_state_t state = pm_autosleep_state(); |
| 401 | |
| 402 | if (state == PM_SUSPEND_ON) |
| 403 | return sprintf(buf, "off\n"); |
| 404 | |
| 405 | #ifdef CONFIG_SUSPEND |
| 406 | if (state < PM_SUSPEND_MAX) |
| 407 | return sprintf(buf, "%s\n", valid_state(state) ? |
| 408 | pm_states[state] : "error"); |
| 409 | #endif |
| 410 | #ifdef CONFIG_HIBERNATION |
| 411 | return sprintf(buf, "disk\n"); |
| 412 | #else |
| 413 | return sprintf(buf, "error"); |
| 414 | #endif |
| 415 | } |
| 416 | |
| 417 | static ssize_t autosleep_store(struct kobject *kobj, |
| 418 | struct kobj_attribute *attr, |
| 419 | const char *buf, size_t n) |
| 420 | { |
| 421 | suspend_state_t state = decode_state(buf, n); |
| 422 | int error; |
| 423 | |
| 424 | if (state == PM_SUSPEND_ON |
Arve Hjønnevåg | 040e5bf | 2012-05-04 00:14:21 +0200 | [diff] [blame] | 425 | && strcmp(buf, "off") && strcmp(buf, "off\n")) |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 426 | return -EINVAL; |
| 427 | |
| 428 | error = pm_autosleep_set_state(state); |
| 429 | return error ? error : n; |
| 430 | } |
| 431 | |
| 432 | power_attr(autosleep); |
| 433 | #endif /* CONFIG_PM_AUTOSLEEP */ |
Rafael J. Wysocki | b86ff982 | 2012-04-29 22:53:42 +0200 | [diff] [blame] | 434 | |
| 435 | #ifdef CONFIG_PM_WAKELOCKS |
| 436 | static ssize_t wake_lock_show(struct kobject *kobj, |
| 437 | struct kobj_attribute *attr, |
| 438 | char *buf) |
| 439 | { |
| 440 | return pm_show_wakelocks(buf, true); |
| 441 | } |
| 442 | |
| 443 | static ssize_t wake_lock_store(struct kobject *kobj, |
| 444 | struct kobj_attribute *attr, |
| 445 | const char *buf, size_t n) |
| 446 | { |
| 447 | int error = pm_wake_lock(buf); |
| 448 | return error ? error : n; |
| 449 | } |
| 450 | |
| 451 | power_attr(wake_lock); |
| 452 | |
| 453 | static ssize_t wake_unlock_show(struct kobject *kobj, |
| 454 | struct kobj_attribute *attr, |
| 455 | char *buf) |
| 456 | { |
| 457 | return pm_show_wakelocks(buf, false); |
| 458 | } |
| 459 | |
| 460 | static ssize_t wake_unlock_store(struct kobject *kobj, |
| 461 | struct kobj_attribute *attr, |
| 462 | const char *buf, size_t n) |
| 463 | { |
| 464 | int error = pm_wake_unlock(buf); |
| 465 | return error ? error : n; |
| 466 | } |
| 467 | |
| 468 | power_attr(wake_unlock); |
| 469 | |
| 470 | #endif /* CONFIG_PM_WAKELOCKS */ |
Rafael J. Wysocki | c125e96 | 2010-07-05 22:43:53 +0200 | [diff] [blame] | 471 | #endif /* CONFIG_PM_SLEEP */ |
| 472 | |
Rafael J. Wysocki | c5c6ba4 | 2006-09-25 23:32:58 -0700 | [diff] [blame] | 473 | #ifdef CONFIG_PM_TRACE |
| 474 | int pm_trace_enabled; |
| 475 | |
Kay Sievers | 386f275 | 2007-11-02 13:47:53 +0100 | [diff] [blame] | 476 | static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr, |
| 477 | char *buf) |
Rafael J. Wysocki | c5c6ba4 | 2006-09-25 23:32:58 -0700 | [diff] [blame] | 478 | { |
| 479 | return sprintf(buf, "%d\n", pm_trace_enabled); |
| 480 | } |
| 481 | |
| 482 | static ssize_t |
Kay Sievers | 386f275 | 2007-11-02 13:47:53 +0100 | [diff] [blame] | 483 | pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr, |
| 484 | const char *buf, size_t n) |
Rafael J. Wysocki | c5c6ba4 | 2006-09-25 23:32:58 -0700 | [diff] [blame] | 485 | { |
| 486 | int val; |
| 487 | |
| 488 | if (sscanf(buf, "%d", &val) == 1) { |
| 489 | pm_trace_enabled = !!val; |
| 490 | return n; |
| 491 | } |
| 492 | return -EINVAL; |
| 493 | } |
| 494 | |
| 495 | power_attr(pm_trace); |
James Hogan | d33ac60 | 2010-10-12 00:00:25 +0200 | [diff] [blame] | 496 | |
| 497 | static ssize_t pm_trace_dev_match_show(struct kobject *kobj, |
| 498 | struct kobj_attribute *attr, |
| 499 | char *buf) |
| 500 | { |
| 501 | return show_trace_dev_match(buf, PAGE_SIZE); |
| 502 | } |
| 503 | |
| 504 | static ssize_t |
| 505 | pm_trace_dev_match_store(struct kobject *kobj, struct kobj_attribute *attr, |
| 506 | const char *buf, size_t n) |
| 507 | { |
| 508 | return -EINVAL; |
| 509 | } |
| 510 | |
| 511 | power_attr(pm_trace_dev_match); |
| 512 | |
Rafael J. Wysocki | 0e7d56e | 2007-11-19 23:41:19 +0100 | [diff] [blame] | 513 | #endif /* CONFIG_PM_TRACE */ |
Rafael J. Wysocki | c5c6ba4 | 2006-09-25 23:32:58 -0700 | [diff] [blame] | 514 | |
| 515 | static struct attribute * g[] = { |
| 516 | &state_attr.attr, |
Rafael J. Wysocki | 0e7d56e | 2007-11-19 23:41:19 +0100 | [diff] [blame] | 517 | #ifdef CONFIG_PM_TRACE |
Rafael J. Wysocki | c5c6ba4 | 2006-09-25 23:32:58 -0700 | [diff] [blame] | 518 | &pm_trace_attr.attr, |
James Hogan | d33ac60 | 2010-10-12 00:00:25 +0200 | [diff] [blame] | 519 | &pm_trace_dev_match_attr.attr, |
Rafael J. Wysocki | 0e7d56e | 2007-11-19 23:41:19 +0100 | [diff] [blame] | 520 | #endif |
Rafael J. Wysocki | 0e06b4a | 2010-01-23 22:25:15 +0100 | [diff] [blame] | 521 | #ifdef CONFIG_PM_SLEEP |
| 522 | &pm_async_attr.attr, |
Rafael J. Wysocki | c125e96 | 2010-07-05 22:43:53 +0200 | [diff] [blame] | 523 | &wakeup_count_attr.attr, |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 524 | #ifdef CONFIG_PM_AUTOSLEEP |
| 525 | &autosleep_attr.attr, |
| 526 | #endif |
Rafael J. Wysocki | b86ff982 | 2012-04-29 22:53:42 +0200 | [diff] [blame] | 527 | #ifdef CONFIG_PM_WAKELOCKS |
| 528 | &wake_lock_attr.attr, |
| 529 | &wake_unlock_attr.attr, |
| 530 | #endif |
Rafael J. Wysocki | 0e06b4a | 2010-01-23 22:25:15 +0100 | [diff] [blame] | 531 | #ifdef CONFIG_PM_DEBUG |
Rafael J. Wysocki | 0e7d56e | 2007-11-19 23:41:19 +0100 | [diff] [blame] | 532 | &pm_test_attr.attr, |
| 533 | #endif |
Rafael J. Wysocki | 0e06b4a | 2010-01-23 22:25:15 +0100 | [diff] [blame] | 534 | #endif |
Rafael J. Wysocki | c5c6ba4 | 2006-09-25 23:32:58 -0700 | [diff] [blame] | 535 | NULL, |
| 536 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 537 | |
| 538 | static struct attribute_group attr_group = { |
| 539 | .attrs = g, |
| 540 | }; |
| 541 | |
Rafael J. Wysocki | 5e928f7 | 2009-08-18 23:38:32 +0200 | [diff] [blame] | 542 | #ifdef CONFIG_PM_RUNTIME |
| 543 | struct workqueue_struct *pm_wq; |
Alan Stern | 7b199ca | 2009-12-03 20:22:21 +0100 | [diff] [blame] | 544 | EXPORT_SYMBOL_GPL(pm_wq); |
Rafael J. Wysocki | 5e928f7 | 2009-08-18 23:38:32 +0200 | [diff] [blame] | 545 | |
| 546 | static int __init pm_start_workqueue(void) |
| 547 | { |
Tejun Heo | 58a69cb | 2011-02-16 09:25:31 +0100 | [diff] [blame] | 548 | pm_wq = alloc_workqueue("pm", WQ_FREEZABLE, 0); |
Rafael J. Wysocki | 5e928f7 | 2009-08-18 23:38:32 +0200 | [diff] [blame] | 549 | |
| 550 | return pm_wq ? 0 : -ENOMEM; |
| 551 | } |
| 552 | #else |
| 553 | static inline int pm_start_workqueue(void) { return 0; } |
| 554 | #endif |
| 555 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 556 | static int __init pm_init(void) |
| 557 | { |
Rafael J. Wysocki | 5e928f7 | 2009-08-18 23:38:32 +0200 | [diff] [blame] | 558 | int error = pm_start_workqueue(); |
| 559 | if (error) |
| 560 | return error; |
Rafael J. Wysocki | ac5c24ec | 2010-09-20 19:44:56 +0200 | [diff] [blame] | 561 | hibernate_image_size_init(); |
Rafael J. Wysocki | ddeb648 | 2011-05-15 11:38:48 +0200 | [diff] [blame] | 562 | hibernate_reserved_size_init(); |
Greg Kroah-Hartman | d76e15f | 2007-11-27 11:28:26 -0800 | [diff] [blame] | 563 | power_kobj = kobject_create_and_add("power", NULL); |
| 564 | if (!power_kobj) |
Greg Kroah-Hartman | 039a5dc | 2007-11-01 10:39:50 -0700 | [diff] [blame] | 565 | return -ENOMEM; |
Rafael J. Wysocki | 7483b4a | 2012-04-29 22:53:22 +0200 | [diff] [blame] | 566 | error = sysfs_create_group(power_kobj, &attr_group); |
| 567 | if (error) |
| 568 | return error; |
| 569 | return pm_autosleep_init(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 570 | } |
| 571 | |
| 572 | core_initcall(pm_init); |