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