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); 941