kernel/power/main.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * kernel/power/main.c - PM subsystem core functionality.
   4  *
   5  * Copyright (c) 2003 Patrick Mochel
   6  * Copyright (c) 2003 Open Source Development Lab
   7  */
   8
   9 #include <linux/export.h>
  10 #include <linux/kobject.h>
  11 #include <linux/string.h>
  12 #include <linux/pm-trace.h>
  13 #include <linux/workqueue.h>
  14 #include <linux/debugfs.h>
  15 #include <linux/seq_file.h>
  16 #include <linux/suspend.h>
  17 #include <linux/syscalls.h>
  18 #include <linux/pm_runtime.h>
  19
  20 #include "power.h"
  21
  22 #ifdef CONFIG_PM_SLEEP
  23
  24 void lock_system_sleep(void)
  25 {
  26         current->flags |= PF_FREEZER_SKIP;
  27         mutex_lock(&system_transition_mutex);
  28 }
  29 EXPORT_SYMBOL_GPL(lock_system_sleep);
  30
  31 void unlock_system_sleep(void)
  32 {
  33         /*
  34          * Don't use freezer_count() because we don't want the call to
  35          * try_to_freeze() here.
  36          *
  37          * Reason:
  38          * Fundamentally, we just don't need it, because freezing condition
  39          * doesn't come into effect until we release the
  40          * system_transition_mutex lock, since the freezer always works with
  41          * system_transition_mutex held.
  42          *
  43          * More importantly, in the case of hibernation,
  44          * unlock_system_sleep() gets called in snapshot_read() and
  45          * snapshot_write() when the freezing condition is still in effect.
  46          * Which means, if we use try_to_freeze() here, it would make them
  47          * enter the refrigerator, thus causing hibernation to lockup.
  48          */
  49         current->flags &= ~PF_FREEZER_SKIP;
  50         mutex_unlock(&system_transition_mutex);
  51 }
  52 EXPORT_SYMBOL_GPL(unlock_system_sleep);
  53
  54 void ksys_sync_helper(void)
  55 {
  56         ktime_t start;
  57         long elapsed_msecs;
  58
  59         start = ktime_get();
  60         ksys_sync();
  61         elapsed_msecs = ktime_to_ms(ktime_sub(ktime_get(), start));
  62         pr_info("Filesystems sync: %ld.%03ld seconds\n",
  63                 elapsed_msecs / MSEC_PER_SEC, elapsed_msecs % MSEC_PER_SEC);
  64 }
  65 EXPORT_SYMBOL_GPL(ksys_sync_helper);
  66
  67 /* Routines for PM-transition notifications */
  68
  69 static BLOCKING_NOTIFIER_HEAD(pm_chain_head);
  70
  71 int register_pm_notifier(struct notifier_block *nb)
  72 {
  73         return blocking_notifier_chain_register(&pm_chain_head, nb);
  74 }
  75 EXPORT_SYMBOL_GPL(register_pm_notifier);
  76
  77 int unregister_pm_notifier(struct notifier_block *nb)
  78 {
  79         return blocking_notifier_chain_unregister(&pm_chain_head, nb);
  80 }
  81 EXPORT_SYMBOL_GPL(unregister_pm_notifier);
  82
  83 int __pm_notifier_call_chain(unsigned long val, int nr_to_call, int *nr_calls)
  84 {
  85         int ret;
  86
  87         ret = __blocking_notifier_call_chain(&pm_chain_head, val, NULL,
  88                                                 nr_to_call, nr_calls);
  89
  90         return notifier_to_errno(ret);
  91 }
  92 int pm_notifier_call_chain(unsigned long val)
  93 {
  94         return __pm_notifier_call_chain(val, -1, NULL);
  95 }
  96
  97 /* If set, devices may be suspended and resumed asynchronously. */
  98 int pm_async_enabled = 1;
  99
 100 static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
 101                              char *buf)
 102 {
 103         return sprintf(buf, "%d\n", pm_async_enabled);
 104 }
 105
 106 static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr,
 107                               const char *buf, size_t n)
 108 {
 109         unsigned long val;
 110
 111         if (kstrtoul(buf, 10, &val))
 112                 return -EINVAL;
 113
 114         if (val > 1)
 115                 return -EINVAL;
 116
 117         pm_async_enabled = val;
 118         return n;
 119 }
 120
 121 power_attr(pm_async);
 122
 123 #ifdef CONFIG_SUSPEND
 124 static ssize_t mem_sleep_show(struct kobject *kobj, struct kobj_attribute *attr,
 125                               char *buf)
 126 {
 127         char *s = buf;
 128         suspend_state_t i;
 129
 130         for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
 131                 if (mem_sleep_states[i]) {
 132                         const char *label = mem_sleep_states[i];
 133
 134                         if (mem_sleep_current == i)
 135                                 s += sprintf(s, "[%s] ", label);
 136                         else
 137                                 s += sprintf(s, "%s ", label);
 138                 }
 139
 140         /* Convert the last space to a newline if needed. */
 141         if (s != buf)
 142                 *(s-1) = '\n';
 143
 144         return (s - buf);
 145 }
 146
 147 static suspend_state_t decode_suspend_state(const char *buf, size_t n)
 148 {
 149         suspend_state_t state;
 150         char *p;
 151         int len;
 152
 153         p = memchr(buf, '\n', n);
 154         len = p ? p - buf : n;
 155
 156         for (state = PM_SUSPEND_MIN; state < PM_SUSPEND_MAX; state++) {
 157                 const char *label = mem_sleep_states[state];
 158
 159                 if (label && len == strlen(label) && !strncmp(buf, label, len))
 160                         return state;
 161         }
 162
 163         return PM_SUSPEND_ON;
 164 }
 165
 166 static ssize_t mem_sleep_store(struct kobject *kobj, struct kobj_attribute *attr,
 167                                const char *buf, size_t n)
 168 {
 169         suspend_state_t state;
 170         int error;
 171
 172         error = pm_autosleep_lock();
 173         if (error)
 174                 return error;
 175
 176         if (pm_autosleep_state() > PM_SUSPEND_ON) {
 177                 error = -EBUSY;
 178                 goto out;
 179         }
 180
 181         state = decode_suspend_state(buf, n);
 182         if (state < PM_SUSPEND_MAX && state > PM_SUSPEND_ON)
 183                 mem_sleep_current = state;
 184         else
 185                 error = -EINVAL;
 186
 187  out:
 188         pm_autosleep_unlock();
 189         return error ? error : n;
 190 }
 191
 192 power_attr(mem_sleep);
 193 #endif /* CONFIG_SUSPEND */
 194
 195 #ifdef CONFIG_PM_SLEEP_DEBUG
 196 int pm_test_level = TEST_NONE;
 197
 198 static const char * const pm_tests[__TEST_AFTER_LAST] = {
 199         [TEST_NONE] = "none",
 200         [TEST_CORE] = "core",
 201         [TEST_CPUS] = "processors",
 202         [TEST_PLATFORM] = "platform",
 203         [TEST_DEVICES] = "devices",
 204         [TEST_FREEZER] = "freezer",
 205 };
 206
 207 static ssize_t pm_test_show(struct kobject *kobj, struct kobj_attribute *attr,
 208                                 char *buf)
 209 {
 210         char *s = buf;
 211         int level;
 212
 213         for (level = TEST_FIRST; level <= TEST_MAX; level++)
 214                 if (pm_tests[level]) {
 215                         if (level == pm_test_level)
 216                                 s += sprintf(s, "[%s] ", pm_tests[level]);
 217                         else
 218                                 s += sprintf(s, "%s ", pm_tests[level]);
 219                 }
 220
 221         if (s != buf)
 222                 /* convert the last space to a newline */
 223                 *(s-1) = '\n';
 224
 225         return (s - buf);
 226 }
 227
 228 static ssize_t pm_test_store(struct kobject *kobj, struct kobj_attribute *attr,
 229                                 const char *buf, size_t n)
 230 {
 231         const char * const *s;
 232         int level;
 233         char *p;
 234         int len;
 235         int error = -EINVAL;
 236
 237         p = memchr(buf, '\n', n);
 238         len = p ? p - buf : n;
 239
 240         lock_system_sleep();
 241
 242         level = TEST_FIRST;
 243         for (s = &pm_tests[level]; level <= TEST_MAX; s++, level++)
 244                 if (*s && len == strlen(*s) && !strncmp(buf, *s, len)) {
 245                         pm_test_level = level;
 246                         error = 0;
 247                         break;
 248                 }
 249
 250         unlock_system_sleep();
 251
 252         return error ? error : n;
 253 }
 254
 255 power_attr(pm_test);
 256 #endif /* CONFIG_PM_SLEEP_DEBUG */
 257
 258 static char *suspend_step_name(enum suspend_stat_step step)
 259 {
 260         switch (step) {
 261         case SUSPEND_FREEZE:
 262                 return "freeze";
 263         case SUSPEND_PREPARE:
 264                 return "prepare";
 265         case SUSPEND_SUSPEND:
 266                 return "suspend";
 267         case SUSPEND_SUSPEND_NOIRQ:
 268                 return "suspend_noirq";
 269         case SUSPEND_RESUME_NOIRQ:
 270                 return "resume_noirq";
 271         case SUSPEND_RESUME:
 272                 return "resume";
 273         default:
 274                 return "";
 275         }
 276 }
 277
 278 #define suspend_attr(_name)                                     \
 279 static ssize_t _name##_show(struct kobject *kobj,               \
 280                 struct kobj_attribute *attr, char *buf)         \
 281 {                                                               \
 282         return sprintf(buf, "%d\n", suspend_stats._name);       \
 283 }                                                               \
 284 static struct kobj_attribute _name = __ATTR_RO(_name)
 285
 286 suspend_attr(success);
 287 suspend_attr(fail);
 288 suspend_attr(failed_freeze);
 289 suspend_attr(failed_prepare);
 290 suspend_attr(failed_suspend);
 291 suspend_attr(failed_suspend_late);
 292 suspend_attr(failed_suspend_noirq);
 293 suspend_attr(failed_resume);
 294 suspend_attr(failed_resume_early);
 295 suspend_attr(failed_resume_noirq);
 296
 297 static ssize_t last_failed_dev_show(struct kobject *kobj,
 298                 struct kobj_attribute *attr, char *buf)
 299 {
 300         int index;
 301         char *last_failed_dev = NULL;
 302
 303         index = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
 304         index %= REC_FAILED_NUM;
 305         last_failed_dev = suspend_stats.failed_devs[index];
 306
 307         return sprintf(buf, "%s\n", last_failed_dev);
 308 }
 309 static struct kobj_attribute last_failed_dev = __ATTR_RO(last_failed_dev);
 310
 311 static ssize_t last_failed_errno_show(struct kobject *kobj,
 312                 struct kobj_attribute *attr, char *buf)
 313 {
 314         int index;
 315         int last_failed_errno;
 316
 317         index = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1;
 318         index %= REC_FAILED_NUM;
 319         last_failed_errno = suspend_stats.errno[index];
 320
 321         return sprintf(buf, "%d\n", last_failed_errno);
 322 }
 323 static struct kobj_attribute last_failed_errno = __ATTR_RO(last_failed_errno);
 324
 325 static ssize_t last_failed_step_show(struct kobject *kobj,
 326                 struct kobj_attribute *attr, char *buf)
 327 {
 328         int index;
 329         enum suspend_stat_step step;
 330         char *last_failed_step = NULL;
 331
 332         index = suspend_stats.last_failed_step + REC_FAILED_NUM - 1;
 333         index %= REC_FAILED_NUM;
 334         step = suspend_stats.failed_steps[index];
 335         last_failed_step = suspend_step_name(step);
 336
 337         return sprintf(buf, "%s\n", last_failed_step);
 338 }
 339 static struct kobj_attribute last_failed_step = __ATTR_RO(last_failed_step);
 340
 341 static struct attribute *suspend_attrs[] = {
 342         &success.attr,
 343         &fail.attr,
 344         &failed_freeze.attr,
 345         &failed_prepare.attr,
 346         &failed_suspend.attr,
 347         &failed_suspend_late.attr,
 348         &failed_suspend_noirq.attr,
 349         &failed_resume.attr,
 350         &failed_resume_early.attr,
 351         &failed_resume_noirq.attr,
 352         &last_failed_dev.attr,
 353         &last_failed_errno.attr,
 354         &last_failed_step.attr,
 355         NULL,
 356 };
 357
 358 static struct attribute_group suspend_attr_group = {
 359         .name = "suspend_stats",
 360         .attrs = suspend_attrs,
 361 };
 362
 363 #ifdef CONFIG_DEBUG_FS
 364 static int suspend_stats_show(struct seq_file *s, void *unused)
 365 {
 366         int i, index, last_dev, last_errno, last_step;
 367
 368         last_dev = suspend_stats.last_failed_dev + REC_FAILED_NUM - 1;
 369         last_dev %= REC_FAILED_NUM;
 370         last_errno = suspend_stats.last_failed_errno + REC_FAILED_NUM - 1;
 371         last_errno %= REC_FAILED_NUM;
 372         last_step = suspend_stats.last_failed_step + REC_FAILED_NUM - 1;
 373         last_step %= REC_FAILED_NUM;
 374         seq_printf(s, "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n"
 375                         "%s: %d\n%s: %d\n%s: %d\n%s: %d\n%s: %d\n",
 376                         "success", suspend_stats.success,
 377                         "fail", suspend_stats.fail,
 378                         "failed_freeze", suspend_stats.failed_freeze,
 379                         "failed_prepare", suspend_stats.failed_prepare,
 380                         "failed_suspend", suspend_stats.failed_suspend,
 381                         "failed_suspend_late",
 382                                 suspend_stats.failed_suspend_late,
 383                         "failed_suspend_noirq",
 384                                 suspend_stats.failed_suspend_noirq,
 385                         "failed_resume", suspend_stats.failed_resume,
 386                         "failed_resume_early",
 387                                 suspend_stats.failed_resume_early,
 388                         "failed_resume_noirq",
 389                                 suspend_stats.failed_resume_noirq);
 390         seq_printf(s,   "failures:\n  last_failed_dev:\t%-s\n",
 391                         suspend_stats.failed_devs[last_dev]);
 392         for (i = 1; i < REC_FAILED_NUM; i++) {
 393                 index = last_dev + REC_FAILED_NUM - i;
 394                 index %= REC_FAILED_NUM;
 395                 seq_printf(s, "\t\t\t%-s\n",
 396                         suspend_stats.failed_devs[index]);
 397         }
 398         seq_printf(s,   "  last_failed_errno:\t%-d\n",
 399                         suspend_stats.errno[last_errno]);
 400         for (i = 1; i < REC_FAILED_NUM; i++) {
 401                 index = last_errno + REC_FAILED_NUM - i;
 402                 index %= REC_FAILED_NUM;
 403                 seq_printf(s, "\t\t\t%-d\n",
 404                         suspend_stats.errno[index]);
 405         }
 406         seq_printf(s,   "  last_failed_step:\t%-s\n",
 407                         suspend_step_name(
 408                                 suspend_stats.failed_steps[last_step]));
 409         for (i = 1; i < REC_FAILED_NUM; i++) {
 410                 index = last_step + REC_FAILED_NUM - i;
 411                 index %= REC_FAILED_NUM;
 412                 seq_printf(s, "\t\t\t%-s\n",
 413                         suspend_step_name(
 414                                 suspend_stats.failed_steps[index]));
 415         }
 416
 417         return 0;
 418 }
 419 DEFINE_SHOW_ATTRIBUTE(suspend_stats);
 420
 421 static int __init pm_debugfs_init(void)
 422 {
 423         debugfs_create_file("suspend_stats", S_IFREG | S_IRUGO,
 424                         NULL, NULL, &suspend_stats_fops);
 425         return 0;
 426 }
 427
 428 late_initcall(pm_debugfs_init);
 429 #endif /* CONFIG_DEBUG_FS */
 430
 431 #endif /* CONFIG_PM_SLEEP */
 432
 433 #ifdef CONFIG_PM_SLEEP_DEBUG
 434 /*
 435  * pm_print_times: print time taken by devices to suspend and resume.
 436  *
 437  * show() returns whether printing of suspend and resume times is enabled.
 438  * store() accepts 0 or 1.  0 disables printing and 1 enables it.
 439  */
 440 bool pm_print_times_enabled;
 441
 442 static ssize_t pm_print_times_show(struct kobject *kobj,
 443                                    struct kobj_attribute *attr, char *buf)
 444 {
 445         return sprintf(buf, "%d\n", pm_print_times_enabled);
 446 }
 447
 448 static ssize_t pm_print_times_store(struct kobject *kobj,
 449                                     struct kobj_attribute *attr,
 450                                     const char *buf, size_t n)
 451 {
 452         unsigned long val;
 453
 454         if (kstrtoul(buf, 10, &val))
 455                 return -EINVAL;
 456
 457         if (val > 1)
 458                 return -EINVAL;
 459
 460         pm_print_times_enabled = !!val;
 461         return n;
 462 }
 463
 464 power_attr(pm_print_times);
 465
 466 static inline void pm_print_times_init(void)
 467 {
 468         pm_print_times_enabled = !!initcall_debug;
 469 }
 470
 471 static ssize_t pm_wakeup_irq_show(struct kobject *kobj,
 472                                         struct kobj_attribute *attr,
 473                                         char *buf)
 474 {
 475         if (!pm_wakeup_irq())
 476                 return -ENODATA;
 477
 478         return sprintf(buf, "%u\n", pm_wakeup_irq());
 479 }
 480
 481 power_attr_ro(pm_wakeup_irq);
 482
 483 bool pm_debug_messages_on __read_mostly;
 484
 485 static ssize_t pm_debug_messages_show(struct kobject *kobj,
 486                                       struct kobj_attribute *attr, char *buf)
 487 {
 488         return sprintf(buf, "%d\n", pm_debug_messages_on);
 489 }
 490
 491 static ssize_t pm_debug_messages_store(struct kobject *kobj,
 492                                        struct kobj_attribute *attr,
 493                                        const char *buf, size_t n)
 494 {
 495         unsigned long val;
 496
 497         if (kstrtoul(buf, 10, &val))
 498                 return -EINVAL;
 499
 500         if (val > 1)
 501                 return -EINVAL;
 502
 503         pm_debug_messages_on = !!val;
 504         return n;
 505 }
 506
 507 power_attr(pm_debug_messages);
 508
 509 /**
 510  * __pm_pr_dbg - Print a suspend debug message to the kernel log.
 511  * @defer: Whether or not to use printk_deferred() to print the message.
 512  * @fmt: Message format.
 513  *
 514  * The message will be emitted if enabled through the pm_debug_messages
 515  * sysfs attribute.
 516  */
 517 void __pm_pr_dbg(bool defer, const char *fmt, ...)
 518 {
 519         struct va_format vaf;
 520         va_list args;
 521
 522         if (!pm_debug_messages_on)
 523                 return;
 524
 525         va_start(args, fmt);
 526
 527         vaf.fmt = fmt;
 528         vaf.va = &args;
 529
 530         if (defer)
 531                 printk_deferred(KERN_DEBUG "PM: %pV", &vaf);
 532         else
 533                 printk(KERN_DEBUG "PM: %pV", &vaf);
 534
 535         va_end(args);
 536 }
 537
 538 #else /* !CONFIG_PM_SLEEP_DEBUG */
 539 static inline void pm_print_times_init(void) {}
 540 #endif /* CONFIG_PM_SLEEP_DEBUG */
 541
 542 struct kobject *power_kobj;
 543
 544 /**
 545  * state - control system sleep states.
 546  *
 547  * show() returns available sleep state labels, which may be "mem", "standby",
 548  * "freeze" and "disk" (hibernation).
 549  * See Documentation/admin-guide/pm/sleep-states.rst for a description of
 550  * what they mean.
 551  *
 552  * store() accepts one of those strings, translates it into the proper
 553  * enumerated value, and initiates a suspend transition.
 554  */
 555 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
 556                           char *buf)
 557 {
 558         char *s = buf;
 559 #ifdef CONFIG_SUSPEND
 560         suspend_state_t i;
 561
 562         for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
 563                 if (pm_states[i])
 564                         s += sprintf(s,"%s ", pm_states[i]);
 565
 566 #endif
 567         if (hibernation_available())
 568                 s += sprintf(s, "disk ");
 569         if (s != buf)
 570                 /* convert the last space to a newline */
 571                 *(s-1) = '\n';
 572         return (s - buf);
 573 }
 574
 575 static suspend_state_t decode_state(const char *buf, size_t n)
 576 {
 577 #ifdef CONFIG_SUSPEND
 578         suspend_state_t state;
 579 #endif
 580         char *p;
 581         int len;
 582
 583         p = memchr(buf, '\n', n);
 584         len = p ? p - buf : n;
 585
 586         /* Check hibernation first. */
 587         if (len == 4 && str_has_prefix(buf, "disk"))
 588                 return PM_SUSPEND_MAX;
 589
 590 #ifdef CONFIG_SUSPEND
 591         for (state = PM_SUSPEND_MIN; state < PM_SUSPEND_MAX; state++) {
 592                 const char *label = pm_states[state];
 593
 594                 if (label && len == strlen(label) && !strncmp(buf, label, len))
 595                         return state;
 596         }
 597 #endif
 598
 599         return PM_SUSPEND_ON;
 600 }
 601
 602 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
 603                            const char *buf, size_t n)
 604 {
 605         suspend_state_t state;
 606         int error;
 607
 608         error = pm_autosleep_lock();
 609         if (error)
 610                 return error;
 611
 612         if (pm_autosleep_state() > PM_SUSPEND_ON) {
 613                 error = -EBUSY;
 614                 goto out;
 615         }
 616
 617         state = decode_state(buf, n);
 618         if (state < PM_SUSPEND_MAX) {
 619                 if (state == PM_SUSPEND_MEM)
 620                         state = mem_sleep_current;
 621
 622                 error = pm_suspend(state);
 623         } else if (state == PM_SUSPEND_MAX) {
 624                 error = hibernate();
 625         } else {
 626                 error = -EINVAL;
 627         }
 628
 629  out:
 630         pm_autosleep_unlock();
 631         return error ? error : n;
 632 }
 633
 634 power_attr(state);
 635
 636 #ifdef CONFIG_PM_SLEEP
 637 /*
 638  * The 'wakeup_count' attribute, along with the functions defined in
 639  * drivers/base/power/wakeup.c, provides a means by which wakeup events can be
 640  * handled in a non-racy way.
 641  *
 642  * If a wakeup event occurs when the system is in a sleep state, it simply is
 643  * woken up.  In turn, if an event that would wake the system up from a sleep
 644  * state occurs when it is undergoing a transition to that sleep state, the
 645  * transition should be aborted.  Moreover, if such an event occurs when the
 646  * system is in the working state, an attempt to start a transition to the
 647  * given sleep state should fail during certain period after the detection of
 648  * the event.  Using the 'state' attribute alone is not sufficient to satisfy
 649  * these requirements, because a wakeup event may occur exactly when 'state'
 650  * is being written to and may be delivered to user space right before it is
 651  * frozen, so the event will remain only partially processed until the system is
 652  * woken up by another event.  In particular, it won't cause the transition to
 653  * a sleep state to be aborted.
 654  *
 655  * This difficulty may be overcome if user space uses 'wakeup_count' before
 656  * writing to 'state'.  It first should read from 'wakeup_count' and store
 657  * the read value.  Then, after carrying out its own preparations for the system
 658  * transition to a sleep state, it should write the stored value to
 659  * 'wakeup_count'.  If that fails, at least one wakeup event has occurred since
 660  * 'wakeup_count' was read and 'state' should not be written to.  Otherwise, it
 661  * is allowed to write to 'state', but the transition will be aborted if there
 662  * are any wakeup events detected after 'wakeup_count' was written to.
 663  */
 664
 665 static ssize_t wakeup_count_show(struct kobject *kobj,
 666                                 struct kobj_attribute *attr,
 667                                 char *buf)
 668 {
 669         unsigned int val;
 670
 671         return pm_get_wakeup_count(&val, true) ?
 672                 sprintf(buf, "%u\n", val) : -EINTR;
 673 }
 674
 675 static ssize_t wakeup_count_store(struct kobject *kobj,
 676                                 struct kobj_attribute *attr,
 677                                 const char *buf, size_t n)
 678 {
 679         unsigned int val;
 680         int error;
 681
 682         error = pm_autosleep_lock();
 683         if (error)
 684                 return error;
 685
 686         if (pm_autosleep_state() > PM_SUSPEND_ON) {
 687                 error = -EBUSY;
 688                 goto out;
 689         }
 690
 691         error = -EINVAL;
 692         if (sscanf(buf, "%u", &val) == 1) {
 693                 if (pm_save_wakeup_count(val))
 694                         error = n;
 695                 else
 696                         pm_print_active_wakeup_sources();
 697         }
 698
 699  out:
 700         pm_autosleep_unlock();
 701         return error;
 702 }
 703
 704 power_attr(wakeup_count);
 705
 706 #ifdef CONFIG_PM_AUTOSLEEP
 707 static ssize_t autosleep_show(struct kobject *kobj,
 708                               struct kobj_attribute *attr,
 709                               char *buf)
 710 {
 711         suspend_state_t state = pm_autosleep_state();
 712
 713         if (state == PM_SUSPEND_ON)
 714                 return sprintf(buf, "off\n");
 715
 716 #ifdef CONFIG_SUSPEND
 717         if (state < PM_SUSPEND_MAX)
 718                 return sprintf(buf, "%s\n", pm_states[state] ?
 719                                         pm_states[state] : "error");
 720 #endif
 721 #ifdef CONFIG_HIBERNATION
 722         return sprintf(buf, "disk\n");
 723 #else
 724         return sprintf(buf, "error");
 725 #endif
 726 }
 727
 728 static ssize_t autosleep_store(struct kobject *kobj,
 729                                struct kobj_attribute *attr,
 730                                const char *buf, size_t n)
 731 {
 732         suspend_state_t state = decode_state(buf, n);
 733         int error;
 734
 735         if (state == PM_SUSPEND_ON
 736             && strcmp(buf, "off") && strcmp(buf, "off\n"))
 737                 return -EINVAL;
 738
 739         if (state == PM_SUSPEND_MEM)
 740                 state = mem_sleep_current;
 741
 742         error = pm_autosleep_set_state(state);
 743         return error ? error : n;
 744 }
 745
 746 power_attr(autosleep);
 747 #endif /* CONFIG_PM_AUTOSLEEP */
 748
 749 #ifdef CONFIG_PM_WAKELOCKS
 750 static ssize_t wake_lock_show(struct kobject *kobj,
 751                               struct kobj_attribute *attr,
 752                               char *buf)
 753 {
 754         return pm_show_wakelocks(buf, true);
 755 }
 756
 757 static ssize_t wake_lock_store(struct kobject *kobj,
 758                                struct kobj_attribute *attr,
 759                                const char *buf, size_t n)
 760 {
 761         int error = pm_wake_lock(buf);
 762         return error ? error : n;
 763 }
 764
 765 power_attr(wake_lock);
 766
 767 static ssize_t wake_unlock_show(struct kobject *kobj,
 768                                 struct kobj_attribute *attr,
 769                                 char *buf)
 770 {
 771         return pm_show_wakelocks(buf, false);
 772 }
 773
 774 static ssize_t wake_unlock_store(struct kobject *kobj,
 775                                  struct kobj_attribute *attr,
 776                                  const char *buf, size_t n)
 777 {
 778         int error = pm_wake_unlock(buf);
 779         return error ? error : n;
 780 }
 781
 782 power_attr(wake_unlock);
 783
 784 #endif /* CONFIG_PM_WAKELOCKS */
 785 #endif /* CONFIG_PM_SLEEP */
 786
 787 #ifdef CONFIG_PM_TRACE
 788 int pm_trace_enabled;
 789
 790 static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
 791                              char *buf)
 792 {
 793         return sprintf(buf, "%d\n", pm_trace_enabled);
 794 }
 795
 796 static ssize_t
 797 pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
 798                const char *buf, size_t n)
 799 {
 800         int val;
 801
 802         if (sscanf(buf, "%d", &val) == 1) {
 803                 pm_trace_enabled = !!val;
 804                 if (pm_trace_enabled) {
 805                         pr_warn("PM: Enabling pm_trace changes system date and time during resume.\n"
 806                                 "PM: Correct system time has to be restored manually after resume.\n");
 807                 }
 808                 return n;
 809         }
 810         return -EINVAL;
 811 }
 812
 813 power_attr(pm_trace);
 814
 815 static ssize_t pm_trace_dev_match_show(struct kobject *kobj,
 816                                        struct kobj_attribute *attr,
 817                                        char *buf)
 818 {
 819         return show_trace_dev_match(buf, PAGE_SIZE);
 820 }
 821
 822 power_attr_ro(pm_trace_dev_match);
 823
 824 #endif /* CONFIG_PM_TRACE */
 825
 826 #ifdef CONFIG_FREEZER
 827 static ssize_t pm_freeze_timeout_show(struct kobject *kobj,
 828                                       struct kobj_attribute *attr, char *buf)
 829 {
 830         return sprintf(buf, "%u\n", freeze_timeout_msecs);
 831 }
 832
 833 static ssize_t pm_freeze_timeout_store(struct kobject *kobj,
 834                                        struct kobj_attribute *attr,
 835                                        const char *buf, size_t n)
 836 {
 837         unsigned long val;
 838
 839         if (kstrtoul(buf, 10, &val))
 840                 return -EINVAL;
 841
 842         freeze_timeout_msecs = val;
 843         return n;
 844 }
 845
 846 power_attr(pm_freeze_timeout);
 847
 848 #endif  /* CONFIG_FREEZER*/
 849
 850 static struct attribute * g[] = {
 851         &state_attr.attr,
 852 #ifdef CONFIG_PM_TRACE
 853         &pm_trace_attr.attr,
 854         &pm_trace_dev_match_attr.attr,
 855 #endif
 856 #ifdef CONFIG_PM_SLEEP
 857         &pm_async_attr.attr,
 858         &wakeup_count_attr.attr,
 859 #ifdef CONFIG_SUSPEND
 860         &mem_sleep_attr.attr,
 861 #endif
 862 #ifdef CONFIG_PM_AUTOSLEEP
 863         &autosleep_attr.attr,
 864 #endif
 865 #ifdef CONFIG_PM_WAKELOCKS
 866         &wake_lock_attr.attr,
 867         &wake_unlock_attr.attr,
 868 #endif
 869 #ifdef CONFIG_PM_SLEEP_DEBUG
 870         &pm_test_attr.attr,
 871         &pm_print_times_attr.attr,
 872         &pm_wakeup_irq_attr.attr,
 873         &pm_debug_messages_attr.attr,
 874 #endif
 875 #endif
 876 #ifdef CONFIG_FREEZER
 877         &pm_freeze_timeout_attr.attr,
 878 #endif
 879         NULL,
 880 };
 881
 882 static const struct attribute_group attr_group = {
 883         .attrs = g,
 884 };
 885
 886 static const struct attribute_group *attr_groups[] = {
 887         &attr_group,
 888 #ifdef CONFIG_PM_SLEEP
 889         &suspend_attr_group,
 890 #endif
 891         NULL,
 892 };
 893
 894 struct workqueue_struct *pm_wq;
 895 EXPORT_SYMBOL_GPL(pm_wq);
 896
 897 static int __init pm_start_workqueue(void)
 898 {
 899         pm_wq = alloc_workqueue("pm", WQ_FREEZABLE, 0);
 900
 901         return pm_wq ? 0 : -ENOMEM;
 902 }
 903
 904 static int __init pm_init(void)
 905 {
 906         int error = pm_start_workqueue();
 907         if (error)
 908                 return error;
 909         hibernate_image_size_init();
 910         hibernate_reserved_size_init();
 911         pm_states_init();
 912         power_kobj = kobject_create_and_add("power", NULL);
 913         if (!power_kobj)
 914                 return -ENOMEM;
 915         error = sysfs_create_groups(power_kobj, attr_groups);
 916         if (error)
 917                 return error;
 918         pm_print_times_init();
 919         return pm_autosleep_init();
 920 }
 921
 922 core_initcall(pm_init);