kernel/power/main.c

   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
   6  *
   7  * This file is released under the GPLv2
   8  *
   9  */
  10
  11 #include <linux/kobject.h>
  12 #include <linux/string.h>
  13 #include <linux/resume-trace.h>
  14 #include <linux/workqueue.h>
  15
  16 #include "power.h"
  17
  18 DEFINE_MUTEX(pm_mutex);
  19
  20 #ifdef CONFIG_PM_SLEEP
  21
  22 /* Routines for PM-transition notifications */
  23
  24 static BLOCKING_NOTIFIER_HEAD(pm_chain_head);
  25
  26 int register_pm_notifier(struct notifier_block *nb)
  27 {
  28         return blocking_notifier_chain_register(&pm_chain_head, nb);
  29 }
  30 EXPORT_SYMBOL_GPL(register_pm_notifier);
  31
  32 int unregister_pm_notifier(struct notifier_block *nb)
  33 {
  34         return blocking_notifier_chain_unregister(&pm_chain_head, nb);
  35 }
  36 EXPORT_SYMBOL_GPL(unregister_pm_notifier);
  37
  38 int pm_notifier_call_chain(unsigned long val)
  39 {
  40         int ret = blocking_notifier_call_chain(&pm_chain_head, val, NULL);
  41
  42         return notifier_to_errno(ret);
  43 }
  44
  45 /* If set, devices may be suspended and resumed asynchronously. */
  46 int pm_async_enabled = 1;
  47
  48 static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
  49                              char *buf)
  50 {
  51         return sprintf(buf, "%d\n", pm_async_enabled);
  52 }
  53
  54 static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr,
  55                               const char *buf, size_t n)
  56 {
  57         unsigned long val;
  58
  59         if (strict_strtoul(buf, 10, &val))
  60                 return -EINVAL;
  61
  62         if (val > 1)
  63                 return -EINVAL;
  64
  65         pm_async_enabled = val;
  66         return n;
  67 }
  68
  69 power_attr(pm_async);
  70
  71 #ifdef CONFIG_PM_DEBUG
  72 int pm_test_level = TEST_NONE;
  73
  74 static const char * const pm_tests[__TEST_AFTER_LAST] = {
  75         [TEST_NONE] = "none",
  76         [TEST_CORE] = "core",
  77         [TEST_CPUS] = "processors",
  78         [TEST_PLATFORM] = "platform",
  79         [TEST_DEVICES] = "devices",
  80         [TEST_FREEZER] = "freezer",
  81 };
  82
  83 static ssize_t pm_test_show(struct kobject *kobj, struct kobj_attribute *attr,
  84                                 char *buf)
  85 {
  86         char *s = buf;
  87         int level;
  88
  89         for (level = TEST_FIRST; level <= TEST_MAX; level++)
  90                 if (pm_tests[level]) {
  91                         if (level == pm_test_level)
  92                                 s += sprintf(s, "[%s] ", pm_tests[level]);
  93                         else
  94                                 s += sprintf(s, "%s ", pm_tests[level]);
  95                 }
  96
  97         if (s != buf)
  98                 /* convert the last space to a newline */
  99                 *(s-1) = '\n';
 100
 101         return (s - buf);
 102 }
 103
 104 static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
 105                                 const char *buf, size_t n)
 106 {
 107         const char * const *s;
 108         int level;
 109         char *p;
 110         int len;
 111         int error = -EINVAL;
 112
 113         p = memchr(buf, '\n', n);
 114         len = p ? p - buf : n;
 115
 116         mutex_lock(&pm_mutex);
 117
 118         level = TEST_FIRST;
 119         for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++)
 120                 if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) {
 121                         pm_test_level = level;
 122                         error = 0;
 123                         break;
 124                 }
 125
 126         mutex_unlock(&pm_mutex);
 127
 128         return error ? error : n;
 129 }
 130
 131 power_attr(pm_test);
 132 #endif /* CONFIG_PM_DEBUG */
 133
 134 #endif /* CONFIG_PM_SLEEP */
 135
 136 struct kobject *power_kobj;
 137
 138 /**
 139  *      state - control system power state.
 140  *
 141  *      show() returns what states are supported, which is hard-coded to
 142  *      'standby' (Power-On Suspend), 'mem' (Suspend-to-RAM), and
 143  *      'disk' (Suspend-to-Disk).
 144  *
 145  *      store() accepts one of those strings, translates it into the
 146  *      proper enumerated value, and initiates a suspend transition.
 147  */
 148 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
 149                           char *buf)
 150 {
 151         char *s = buf;
 152 #ifdef CONFIG_SUSPEND
 153         int i;
 154
 155         for (i = 0; i < PM_SUSPEND_MAX; i++) {
 156                 if (pm_states[i] && valid_state(i))
 157                         s += sprintf(s,"%s ", pm_states[i]);
 158         }
 159 #endif
 160 #ifdef CONFIG_HIBERNATION
 161         s += sprintf(s, "%s\n", "disk");
 162 #else
 163         if (s != buf)
 164                 /* convert the last space to a newline */
 165                 *(s-1) = '\n';
 166 #endif
 167         return (s - buf);
 168 }
 169
 170 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
 171                            const char *buf, size_t n)
 172 {
 173 #ifdef CONFIG_SUSPEND
 174         suspend_state_t state = PM_SUSPEND_STANDBY;
 175         const char * const *s;
 176 #endif
 177         char *p;
 178         int len;
 179         int error = -EINVAL;
 180
 181         p = memchr(buf, '\n', n);
 182         len = p ? p - buf : n;
 183
 184         /* First, check if we are requested to hibernate */
 185         if (len == 4 && !strncmp(buf, "disk", len)) {
 186                 error = hibernate();
 187   goto Exit;
 188         }
 189
 190 #ifdef CONFIG_SUSPEND
 191         for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {
 192                 if (*s && len == strlen(*s) && !strncmp(buf, *s, len))
 193                         break;
 194         }
 195         if (state < PM_SUSPEND_MAX && *s)
 196                 error = enter_state(state);
 197 #endif
 198
 199  Exit:
 200         return error ? error : n;
 201 }
 202
 203 power_attr(state);
 204
 205 #ifdef CONFIG_PM_SLEEP
 206 /*
 207  * The 'wakeup_count' attribute, along with the functions defined in
 208  * drivers/base/power/wakeup.c, provides a means by which wakeup events can be
 209  * handled in a non-racy way.
 210  *
 211  * If a wakeup event occurs when the system is in a sleep state, it simply is
 212  * woken up.  In turn, if an event that would wake the system up from a sleep
 213  * state occurs when it is undergoing a transition to that sleep state, the
 214  * transition should be aborted.  Moreover, if such an event occurs when the
 215  * system is in the working state, an attempt to start a transition to the
 216  * given sleep state should fail during certain period after the detection of
 217  * the event.  Using the 'state' attribute alone is not sufficient to satisfy
 218  * these requirements, because a wakeup event may occur exactly when 'state'
 219  * is being written to and may be delivered to user space right before it is
 220  * frozen, so the event will remain only partially processed until the system is
 221  * woken up by another event.  In particular, it won't cause the transition to
 222  * a sleep state to be aborted.
 223  *
 224  * This difficulty may be overcome if user space uses 'wakeup_count' before
 225  * writing to 'state'.  It first should read from 'wakeup_count' and store
 226  * the read value.  Then, after carrying out its own preparations for the system
 227  * transition to a sleep state, it should write the stored value to
 228  * 'wakeup_count'.  If that fails, at least one wakeup event has occurred since
 229  * 'wakeup_count' was read and 'state' should not be written to.  Otherwise, it
 230  * is allowed to write to 'state', but the transition will be aborted if there
 231  * are any wakeup events detected after 'wakeup_count' was written to.
 232  */
 233
 234 static ssize_t wakeup_count_show(struct kobject *kobj,
 235                                 struct kobj_attribute *attr,
 236                                 char *buf)
 237 {
 238         unsigned int val;
 239
 240         return pm_get_wakeup_count(&val) ? sprintf(buf, "%u\n", val) : -EINTR;
 241 }
 242
 243 static ssize_t wakeup_count_store(struct kobject *kobj,
 244                                 struct kobj_attribute *attr,
 245                                 const char *buf, size_t n)
 246 {
 247         unsigned int val;
 248
 249         if (sscanf(buf, "%u", &val) == 1) {
 250                 if (pm_save_wakeup_count(val))
 251                         return n;
 252         }
 253         return -EINVAL;
 254 }
 255
 256 power_attr(wakeup_count);
 257 #endif /* CONFIG_PM_SLEEP */
 258
 259 #ifdef CONFIG_PM_TRACE
 260 int pm_trace_enabled;
 261
 262 static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
 263                              char *buf)
 264 {
 265         return sprintf(buf, "%d\n", pm_trace_enabled);
 266 }
 267
 268 static ssize_t
 269 pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
 270                const char *buf, size_t n)
 271 {
 272         int val;
 273
 274         if (sscanf(buf, "%d", &val) == 1) {
 275                 pm_trace_enabled = !!val;
 276                 return n;
 277         }
 278         return -EINVAL;
 279 }
 280
 281 power_attr(pm_trace);
 282
 283 static ssize_t pm_trace_dev_match_show(struct kobject *kobj,
 284                                        struct kobj_attribute *attr,
 285                                        char *buf)
 286 {
 287         return show_trace_dev_match(buf, PAGE_SIZE);
 288 }
 289
 290 static ssize_t
 291 pm_trace_dev_match_store(struct kobject *kobj, struct kobj_attribute *attr,
 292                          const char *buf, size_t n)
 293 {
 294         return -EINVAL;
 295 }
 296
 297 power_attr(pm_trace_dev_match);
 298
 299 #endif /* CONFIG_PM_TRACE */
 300
 301 static struct attribute * g[] = {
 302         &state_attr.attr,
 303 #ifdef CONFIG_PM_TRACE
 304         &pm_trace_attr.attr,
 305         &pm_trace_dev_match_attr.attr,
 306 #endif
 307 #ifdef CONFIG_PM_SLEEP
 308         &pm_async_attr.attr,
 309         &wakeup_count_attr.attr,
 310 #ifdef CONFIG_PM_DEBUG
 311         &pm_test_attr.attr,
 312 #endif
 313 #endif
 314         NULL,
 315 };
 316
 317 static struct attribute_group attr_group = {
 318         .attrs = g,
 319 };
 320
 321 #ifdef CONFIG_PM_RUNTIME
 322 struct workqueue_struct *pm_wq;
 323 EXPORT_SYMBOL_GPL(pm_wq);
 324
 325 static int __init pm_start_workqueue(void)
 326 {
 327         pm_wq = alloc_workqueue("pm", WQ_FREEZABLE, 0);
 328
 329         return pm_wq ? 0 : -ENOMEM;
 330 }
 331 #else
 332 static inline int pm_start_workqueue(void) { return 0; }
 333 #endif
 334
 335 static int __init pm_init(void)
 336 {
 337         int error = pm_start_workqueue();
 338         if (error)
 339                 return error;
 340         hibernate_image_size_init();
 341         hibernate_reserved_size_init();
 342         power_kobj = kobject_create_and_add("power", NULL);
 343         if (!power_kobj)
 344                 return -ENOMEM;
 345         return sysfs_create_group(power_kobj, &attr_group);
 346 }
 347
 348 core_initcall(pm_init);