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