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 DEFINE_SHOW_ATTRIBUTE(suspend_stats);
 322
 323 static int __init pm_debugfs_init(void)
 324 {
 325         debugfs_create_file("suspend_stats", S_IFREG | S_IRUGO,
 326                         NULL, NULL, &suspend_stats_fops);
 327         return 0;
 328 }
 329
 330 late_initcall(pm_debugfs_init);
 331 #endif /* CONFIG_DEBUG_FS */
 332
 333 #endif /* CONFIG_PM_SLEEP */
 334
 335 #ifdef CONFIG_PM_SLEEP_DEBUG
 336 /*
 337  * pm_print_times: print time taken by devices to suspend and resume.
 338  *
 339  * show() returns whether printing of suspend and resume times is enabled.
 340  * store() accepts 0 or 1.  0 disables printing and 1 enables it.
 341  */
 342 bool pm_print_times_enabled;
 343
 344 static ssize_t pm_print_times_show(struct kobject *kobj,
 345                                    struct kobj_attribute *attr, char *buf)
 346 {
 347         return sprintf(buf, "%d\n", pm_print_times_enabled);
 348 }
 349
 350 static ssize_t pm_print_times_store(struct kobject *kobj,
 351                                     struct kobj_attribute *attr,
 352                                     const char *buf, size_t n)
 353 {
 354         unsigned long val;
 355
 356         if (kstrtoul(buf, 10, &val))
 357                 return -EINVAL;
 358
 359         if (val > 1)
 360                 return -EINVAL;
 361
 362         pm_print_times_enabled = !!val;
 363         return n;
 364 }
 365
 366 power_attr(pm_print_times);
 367
 368 static inline void pm_print_times_init(void)
 369 {
 370         pm_print_times_enabled = !!initcall_debug;
 371 }
 372
 373 static ssize_t pm_wakeup_irq_show(struct kobject *kobj,
 374                                         struct kobj_attribute *attr,
 375                                         char *buf)
 376 {
 377         return pm_wakeup_irq ? sprintf(buf, "%u\n", pm_wakeup_irq) : -ENODATA;
 378 }
 379
 380 power_attr_ro(pm_wakeup_irq);
 381
 382 bool pm_debug_messages_on __read_mostly;
 383
 384 static ssize_t pm_debug_messages_show(struct kobject *kobj,
 385                                       struct kobj_attribute *attr, char *buf)
 386 {
 387         return sprintf(buf, "%d\n", pm_debug_messages_on);
 388 }
 389
 390 static ssize_t pm_debug_messages_store(struct kobject *kobj,
 391                                        struct kobj_attribute *attr,
 392                                        const char *buf, size_t n)
 393 {
 394         unsigned long val;
 395
 396         if (kstrtoul(buf, 10, &val))
 397                 return -EINVAL;
 398
 399         if (val > 1)
 400                 return -EINVAL;
 401
 402         pm_debug_messages_on = !!val;
 403         return n;
 404 }
 405
 406 power_attr(pm_debug_messages);
 407
 408 /**
 409  * __pm_pr_dbg - Print a suspend debug message to the kernel log.
 410  * @defer: Whether or not to use printk_deferred() to print the message.
 411  * @fmt: Message format.
 412  *
 413  * The message will be emitted if enabled through the pm_debug_messages
 414  * sysfs attribute.
 415  */
 416 void __pm_pr_dbg(bool defer, const char *fmt, ...)
 417 {
 418         struct va_format vaf;
 419         va_list args;
 420
 421         if (!pm_debug_messages_on)
 422                 return;
 423
 424         va_start(args, fmt);
 425
 426         vaf.fmt = fmt;
 427         vaf.va = &args;
 428
 429         if (defer)
 430                 printk_deferred(KERN_DEBUG "PM: %pV", &vaf);
 431         else
 432                 printk(KERN_DEBUG "PM: %pV", &vaf);
 433
 434         va_end(args);
 435 }
 436
 437 #else /* !CONFIG_PM_SLEEP_DEBUG */
 438 static inline void pm_print_times_init(void) {}
 439 #endif /* CONFIG_PM_SLEEP_DEBUG */
 440
 441 struct kobject *power_kobj;
 442
 443 /**
 444  * state - control system sleep states.
 445  *
 446  * show() returns available sleep state labels, which may be "mem", "standby",
 447  * "freeze" and "disk" (hibernation).
 448  * See Documentation/admin-guide/pm/sleep-states.rst for a description of
 449  * what they mean.
 450  *
 451  * store() accepts one of those strings, translates it into the proper
 452  * enumerated value, and initiates a suspend transition.
 453  */
 454 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
 455                           char *buf)
 456 {
 457         char *s = buf;
 458 #ifdef CONFIG_SUSPEND
 459         suspend_state_t i;
 460
 461         for (i = PM_SUSPEND_MIN; i < PM_SUSPEND_MAX; i++)
 462                 if (pm_states[i])
 463                         s += sprintf(s,"%s ", pm_states[i]);
 464
 465 #endif
 466         if (hibernation_available())
 467                 s += sprintf(s, "disk ");
 468         if (s != buf)
 469                 /* convert the last space to a newline */
 470                 *(s-1) = '\n';
 471         return (s - buf);
 472 }
 473
 474 static suspend_state_t decode_state(const char *buf, size_t n)
 475 {
 476 #ifdef CONFIG_SUSPEND
 477         suspend_state_t state;
 478 #endif
 479         char *p;
 480         int len;
 481
 482         p = memchr(buf, '\n', n);
 483         len = p ? p - buf : n;
 484
 485         /* Check hibernation first. */
 486         if (len == 4 && !strncmp(buf, "disk", len))
 487                 return PM_SUSPEND_MAX;
 488
 489 #ifdef CONFIG_SUSPEND
 490         for (state = PM_SUSPEND_MIN; state < PM_SUSPEND_MAX; state++) {
 491                 const char *label = pm_states[state];
 492
 493                 if (label && len == strlen(label) && !strncmp(buf, label, len))
 494                         return state;
 495         }
 496 #endif
 497
 498         return PM_SUSPEND_ON;
 499 }
 500
 501 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
 502                            const char *buf, size_t n)
 503 {
 504         suspend_state_t state;
 505         int error;
 506
 507         error = pm_autosleep_lock();
 508         if (error)
 509                 return error;
 510
 511         if (pm_autosleep_state() > PM_SUSPEND_ON) {
 512                 error = -EBUSY;
 513                 goto out;
 514         }
 515
 516         state = decode_state(buf, n);
 517         if (state < PM_SUSPEND_MAX) {
 518                 if (state == PM_SUSPEND_MEM)
 519                         state = mem_sleep_current;
 520
 521                 error = pm_suspend(state);
 522         } else if (state == PM_SUSPEND_MAX) {
 523                 error = hibernate();
 524         } else {
 525                 error = -EINVAL;
 526         }
 527
 528  out:
 529         pm_autosleep_unlock();
 530         return error ? error : n;
 531 }
 532
 533 power_attr(state);
 534
 535 #ifdef CONFIG_PM_SLEEP
 536 /*
 537  * The 'wakeup_count' attribute, along with the functions defined in
 538  * drivers/base/power/wakeup.c, provides a means by which wakeup events can be
 539  * handled in a non-racy way.
 540  *
 541  * If a wakeup event occurs when the system is in a sleep state, it simply is
 542  * woken up.  In turn, if an event that would wake the system up from a sleep
 543  * state occurs when it is undergoing a transition to that sleep state, the
 544  * transition should be aborted.  Moreover, if such an event occurs when the
 545  * system is in the working state, an attempt to start a transition to the
 546  * given sleep state should fail during certain period after the detection of
 547  * the event.  Using the 'state' attribute alone is not sufficient to satisfy
 548  * these requirements, because a wakeup event may occur exactly when 'state'
 549  * is being written to and may be delivered to user space right before it is
 550  * frozen, so the event will remain only partially processed until the system is
 551  * woken up by another event.  In particular, it won't cause the transition to
 552  * a sleep state to be aborted.
 553  *
 554  * This difficulty may be overcome if user space uses 'wakeup_count' before
 555  * writing to 'state'.  It first should read from 'wakeup_count' and store
 556  * the read value.  Then, after carrying out its own preparations for the system
 557  * transition to a sleep state, it should write the stored value to
 558  * 'wakeup_count'.  If that fails, at least one wakeup event has occurred since
 559  * 'wakeup_count' was read and 'state' should not be written to.  Otherwise, it
 560  * is allowed to write to 'state', but the transition will be aborted if there
 561  * are any wakeup events detected after 'wakeup_count' was written to.
 562  */
 563
 564 static ssize_t wakeup_count_show(struct kobject *kobj,
 565                                 struct kobj_attribute *attr,
 566                                 char *buf)
 567 {
 568         unsigned int val;
 569
 570         return pm_get_wakeup_count(&val, true) ?
 571                 sprintf(buf, "%u\n", val) : -EINTR;
 572 }
 573
 574 static ssize_t wakeup_count_store(struct kobject *kobj,
 575                                 struct kobj_attribute *attr,
 576                                 const char *buf, size_t n)
 577 {
 578         unsigned int val;
 579         int error;
 580
 581         error = pm_autosleep_lock();
 582         if (error)
 583                 return error;
 584
 585         if (pm_autosleep_state() > PM_SUSPEND_ON) {
 586                 error = -EBUSY;
 587                 goto out;
 588         }
 589
 590         error = -EINVAL;
 591         if (sscanf(buf, "%u", &val) == 1) {
 592                 if (pm_save_wakeup_count(val))
 593                         error = n;
 594                 else
 595                         pm_print_active_wakeup_sources();
 596         }
 597
 598  out:
 599         pm_autosleep_unlock();
 600         return error;
 601 }
 602
 603 power_attr(wakeup_count);
 604
 605 #ifdef CONFIG_PM_AUTOSLEEP
 606 static ssize_t autosleep_show(struct kobject *kobj,
 607                               struct kobj_attribute *attr,
 608                               char *buf)
 609 {
 610         suspend_state_t state = pm_autosleep_state();
 611
 612         if (state == PM_SUSPEND_ON)
 613                 return sprintf(buf, "off\n");
 614
 615 #ifdef CONFIG_SUSPEND
 616         if (state < PM_SUSPEND_MAX)
 617                 return sprintf(buf, "%s\n", pm_states[state] ?
 618                                         pm_states[state] : "error");
 619 #endif
 620 #ifdef CONFIG_HIBERNATION
 621         return sprintf(buf, "disk\n");
 622 #else
 623         return sprintf(buf, "error");
 624 #endif
 625 }
 626
 627 static ssize_t autosleep_store(struct kobject *kobj,
 628                                struct kobj_attribute *attr,
 629                                const char *buf, size_t n)
 630 {
 631         suspend_state_t state = decode_state(buf, n);
 632         int error;
 633
 634         if (state == PM_SUSPEND_ON
 635             && strcmp(buf, "off") && strcmp(buf, "off\n"))
 636                 return -EINVAL;
 637
 638         if (state == PM_SUSPEND_MEM)
 639                 state = mem_sleep_current;
 640
 641         error = pm_autosleep_set_state(state);
 642         return error ? error : n;
 643 }
 644
 645 power_attr(autosleep);
 646 #endif /* CONFIG_PM_AUTOSLEEP */
 647
 648 #ifdef CONFIG_PM_WAKELOCKS
 649 static ssize_t wake_lock_show(struct kobject *kobj,
 650                               struct kobj_attribute *attr,
 651                               char *buf)
 652 {
 653         return pm_show_wakelocks(buf, true);
 654 }
 655
 656 static ssize_t wake_lock_store(struct kobject *kobj,
 657                                struct kobj_attribute *attr,
 658                                const char *buf, size_t n)
 659 {
 660         int error = pm_wake_lock(buf);
 661         return error ? error : n;
 662 }
 663
 664 power_attr(wake_lock);
 665
 666 static ssize_t wake_unlock_show(struct kobject *kobj,
 667                                 struct kobj_attribute *attr,
 668                                 char *buf)
 669 {
 670         return pm_show_wakelocks(buf, false);
 671 }
 672
 673 static ssize_t wake_unlock_store(struct kobject *kobj,
 674                                  struct kobj_attribute *attr,
 675                                  const char *buf, size_t n)
 676 {
 677         int error = pm_wake_unlock(buf);
 678         return error ? error : n;
 679 }
 680
 681 power_attr(wake_unlock);
 682
 683 #endif /* CONFIG_PM_WAKELOCKS */
 684 #endif /* CONFIG_PM_SLEEP */
 685
 686 #ifdef CONFIG_PM_TRACE
 687 int pm_trace_enabled;
 688
 689 static ssize_t pm_trace_show(struct kobject *kobj, struct kobj_attribute *attr,
 690                              char *buf)
 691 {
 692         return sprintf(buf, "%d\n", pm_trace_enabled);
 693 }
 694
 695 static ssize_t
 696 pm_trace_store(struct kobject *kobj, struct kobj_attribute *attr,
 697                const char *buf, size_t n)
 698 {
 699         int val;
 700
 701         if (sscanf(buf, "%d", &val) == 1) {
 702                 pm_trace_enabled = !!val;
 703                 if (pm_trace_enabled) {
 704                         pr_warn("PM: Enabling pm_trace changes system date and time during resume.\n"
 705                                 "PM: Correct system time has to be restored manually after resume.\n");
 706                 }
 707                 return n;
 708         }
 709         return -EINVAL;
 710 }
 711
 712 power_attr(pm_trace);
 713
 714 static ssize_t pm_trace_dev_match_show(struct kobject *kobj,
 715                                        struct kobj_attribute *attr,
 716                                        char *buf)
 717 {
 718         return show_trace_dev_match(buf, PAGE_SIZE);
 719 }
 720
 721 power_attr_ro(pm_trace_dev_match);
 722
 723 #endif /* CONFIG_PM_TRACE */
 724
 725 #ifdef CONFIG_FREEZER
 726 static ssize_t pm_freeze_timeout_show(struct kobject *kobj,
 727                                       struct kobj_attribute *attr, char *buf)
 728 {
 729         return sprintf(buf, "%u\n", freeze_timeout_msecs);
 730 }
 731
 732 static ssize_t pm_freeze_timeout_store(struct kobject *kobj,
 733                                        struct kobj_attribute *attr,
 734                                        const char *buf, size_t n)
 735 {
 736         unsigned long val;
 737
 738         if (kstrtoul(buf, 10, &val))
 739                 return -EINVAL;
 740
 741         freeze_timeout_msecs = val;
 742         return n;
 743 }
 744
 745 power_attr(pm_freeze_timeout);
 746
 747 #endif  /* CONFIG_FREEZER*/
 748
 749 static struct attribute * g[] = {
 750         &state_attr.attr,
 751 #ifdef CONFIG_PM_TRACE
 752         &pm_trace_attr.attr,
 753         &pm_trace_dev_match_attr.attr,
 754 #endif
 755 #ifdef CONFIG_PM_SLEEP
 756         &pm_async_attr.attr,
 757         &wakeup_count_attr.attr,
 758 #ifdef CONFIG_SUSPEND
 759         &mem_sleep_attr.attr,
 760 #endif
 761 #ifdef CONFIG_PM_AUTOSLEEP
 762         &autosleep_attr.attr,
 763 #endif
 764 #ifdef CONFIG_PM_WAKELOCKS
 765         &wake_lock_attr.attr,
 766         &wake_unlock_attr.attr,
 767 #endif
 768 #ifdef CONFIG_PM_SLEEP_DEBUG
 769         &pm_test_attr.attr,
 770         &pm_print_times_attr.attr,
 771         &pm_wakeup_irq_attr.attr,
 772         &pm_debug_messages_attr.attr,
 773 #endif
 774 #endif
 775 #ifdef CONFIG_FREEZER
 776         &pm_freeze_timeout_attr.attr,
 777 #endif
 778         NULL,
 779 };
 780
 781 static const struct attribute_group attr_group = {
 782         .attrs = g,
 783 };
 784
 785 struct workqueue_struct *pm_wq;
 786 EXPORT_SYMBOL_GPL(pm_wq);
 787
 788 static int __init pm_start_workqueue(void)
 789 {
 790         pm_wq = alloc_workqueue("pm", WQ_FREEZABLE, 0);
 791
 792         return pm_wq ? 0 : -ENOMEM;
 793 }
 794
 795 static int __init pm_init(void)
 796 {
 797         int error = pm_start_workqueue();
 798         if (error)
 799                 return error;
 800         hibernate_image_size_init();
 801         hibernate_reserved_size_init();
 802         pm_states_init();
 803         power_kobj = kobject_create_and_add("power", NULL);
 804         if (!power_kobj)
 805                 return -ENOMEM;
 806         error = sysfs_create_group(power_kobj, &attr_group);
 807         if (error)
 808                 return error;
 809         pm_print_times_init();
 810         return pm_autosleep_init();
 811 }
 812
 813 core_initcall(pm_init);