linux/kernel/power/suspend.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * kernel/power/suspend.c - Suspend to RAM and standby functionality.
   4 *
   5 * Copyright (c) 2003 Patrick Mochel
   6 * Copyright (c) 2003 Open Source Development Lab
   7 * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
   8 */
   9
  10#define pr_fmt(fmt) "PM: " fmt
  11
  12#include <linux/string.h>
  13#include <linux/delay.h>
  14#include <linux/errno.h>
  15#include <linux/init.h>
  16#include <linux/console.h>
  17#include <linux/cpu.h>
  18#include <linux/cpuidle.h>
  19#include <linux/gfp.h>
  20#include <linux/io.h>
  21#include <linux/kernel.h>
  22#include <linux/list.h>
  23#include <linux/mm.h>
  24#include <linux/slab.h>
  25#include <linux/export.h>
  26#include <linux/suspend.h>
  27#include <linux/syscore_ops.h>
  28#include <linux/swait.h>
  29#include <linux/ftrace.h>
  30#include <trace/events/power.h>
  31#include <linux/compiler.h>
  32#include <linux/moduleparam.h>
  33
  34#include "power.h"
  35
  36const char * const pm_labels[] = {
  37        [PM_SUSPEND_TO_IDLE] = "freeze",
  38        [PM_SUSPEND_STANDBY] = "standby",
  39        [PM_SUSPEND_MEM] = "mem",
  40};
  41const char *pm_states[PM_SUSPEND_MAX];
  42static const char * const mem_sleep_labels[] = {
  43        [PM_SUSPEND_TO_IDLE] = "s2idle",
  44        [PM_SUSPEND_STANDBY] = "shallow",
  45        [PM_SUSPEND_MEM] = "deep",
  46};
  47const char *mem_sleep_states[PM_SUSPEND_MAX];
  48
  49suspend_state_t mem_sleep_current = PM_SUSPEND_TO_IDLE;
  50suspend_state_t mem_sleep_default = PM_SUSPEND_MAX;
  51suspend_state_t pm_suspend_target_state;
  52EXPORT_SYMBOL_GPL(pm_suspend_target_state);
  53
  54unsigned int pm_suspend_global_flags;
  55EXPORT_SYMBOL_GPL(pm_suspend_global_flags);
  56
  57static const struct platform_suspend_ops *suspend_ops;
  58static const struct platform_s2idle_ops *s2idle_ops;
  59static DECLARE_SWAIT_QUEUE_HEAD(s2idle_wait_head);
  60
  61enum s2idle_states __read_mostly s2idle_state;
  62static DEFINE_RAW_SPINLOCK(s2idle_lock);
  63
  64/**
  65 * pm_suspend_default_s2idle - Check if suspend-to-idle is the default suspend.
  66 *
  67 * Return 'true' if suspend-to-idle has been selected as the default system
  68 * suspend method.
  69 */
  70bool pm_suspend_default_s2idle(void)
  71{
  72        return mem_sleep_current == PM_SUSPEND_TO_IDLE;
  73}
  74EXPORT_SYMBOL_GPL(pm_suspend_default_s2idle);
  75
  76void s2idle_set_ops(const struct platform_s2idle_ops *ops)
  77{
  78        lock_system_sleep();
  79        s2idle_ops = ops;
  80        unlock_system_sleep();
  81}
  82
  83static void s2idle_begin(void)
  84{
  85        s2idle_state = S2IDLE_STATE_NONE;
  86}
  87
  88static void s2idle_enter(void)
  89{
  90        trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_TO_IDLE, true);
  91
  92        raw_spin_lock_irq(&s2idle_lock);
  93        if (pm_wakeup_pending())
  94                goto out;
  95
  96        s2idle_state = S2IDLE_STATE_ENTER;
  97        raw_spin_unlock_irq(&s2idle_lock);
  98
  99        get_online_cpus();
 100        cpuidle_resume();
 101
 102        /* Push all the CPUs into the idle loop. */
 103        wake_up_all_idle_cpus();
 104        /* Make the current CPU wait so it can enter the idle loop too. */
 105        swait_event_exclusive(s2idle_wait_head,
 106                    s2idle_state == S2IDLE_STATE_WAKE);
 107
 108        cpuidle_pause();
 109        put_online_cpus();
 110
 111        raw_spin_lock_irq(&s2idle_lock);
 112
 113 out:
 114        s2idle_state = S2IDLE_STATE_NONE;
 115        raw_spin_unlock_irq(&s2idle_lock);
 116
 117        trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_TO_IDLE, false);
 118}
 119
 120static void s2idle_loop(void)
 121{
 122        pm_pr_dbg("suspend-to-idle\n");
 123
 124        /*
 125         * Suspend-to-idle equals:
 126         * frozen processes + suspended devices + idle processors.
 127         * Thus s2idle_enter() should be called right after all devices have
 128         * been suspended.
 129         *
 130         * Wakeups during the noirq suspend of devices may be spurious, so try
 131         * to avoid them upfront.
 132         */
 133        for (;;) {
 134                if (s2idle_ops && s2idle_ops->wake) {
 135                        if (s2idle_ops->wake())
 136                                break;
 137                } else if (pm_wakeup_pending()) {
 138                        break;
 139                }
 140
 141                pm_wakeup_clear(false);
 142
 143                s2idle_enter();
 144        }
 145
 146        pm_pr_dbg("resume from suspend-to-idle\n");
 147}
 148
 149void s2idle_wake(void)
 150{
 151        unsigned long flags;
 152
 153        raw_spin_lock_irqsave(&s2idle_lock, flags);
 154        if (s2idle_state > S2IDLE_STATE_NONE) {
 155                s2idle_state = S2IDLE_STATE_WAKE;
 156                swake_up_one(&s2idle_wait_head);
 157        }
 158        raw_spin_unlock_irqrestore(&s2idle_lock, flags);
 159}
 160EXPORT_SYMBOL_GPL(s2idle_wake);
 161
 162static bool valid_state(suspend_state_t state)
 163{
 164        /*
 165         * PM_SUSPEND_STANDBY and PM_SUSPEND_MEM states need low level
 166         * support and need to be valid to the low level
 167         * implementation, no valid callback implies that none are valid.
 168         */
 169        return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
 170}
 171
 172void __init pm_states_init(void)
 173{
 174        /* "mem" and "freeze" are always present in /sys/power/state. */
 175        pm_states[PM_SUSPEND_MEM] = pm_labels[PM_SUSPEND_MEM];
 176        pm_states[PM_SUSPEND_TO_IDLE] = pm_labels[PM_SUSPEND_TO_IDLE];
 177        /*
 178         * Suspend-to-idle should be supported even without any suspend_ops,
 179         * initialize mem_sleep_states[] accordingly here.
 180         */
 181        mem_sleep_states[PM_SUSPEND_TO_IDLE] = mem_sleep_labels[PM_SUSPEND_TO_IDLE];
 182}
 183
 184static int __init mem_sleep_default_setup(char *str)
 185{
 186        suspend_state_t state;
 187
 188        for (state = PM_SUSPEND_TO_IDLE; state <= PM_SUSPEND_MEM; state++)
 189                if (mem_sleep_labels[state] &&
 190                    !strcmp(str, mem_sleep_labels[state])) {
 191                        mem_sleep_default = state;
 192                        break;
 193                }
 194
 195        return 1;
 196}
 197__setup("mem_sleep_default=", mem_sleep_default_setup);
 198
 199/**
 200 * suspend_set_ops - Set the global suspend method table.
 201 * @ops: Suspend operations to use.
 202 */
 203void suspend_set_ops(const struct platform_suspend_ops *ops)
 204{
 205        lock_system_sleep();
 206
 207        suspend_ops = ops;
 208
 209        if (valid_state(PM_SUSPEND_STANDBY)) {
 210                mem_sleep_states[PM_SUSPEND_STANDBY] = mem_sleep_labels[PM_SUSPEND_STANDBY];
 211                pm_states[PM_SUSPEND_STANDBY] = pm_labels[PM_SUSPEND_STANDBY];
 212                if (mem_sleep_default == PM_SUSPEND_STANDBY)
 213                        mem_sleep_current = PM_SUSPEND_STANDBY;
 214        }
 215        if (valid_state(PM_SUSPEND_MEM)) {
 216                mem_sleep_states[PM_SUSPEND_MEM] = mem_sleep_labels[PM_SUSPEND_MEM];
 217                if (mem_sleep_default >= PM_SUSPEND_MEM)
 218                        mem_sleep_current = PM_SUSPEND_MEM;
 219        }
 220
 221        unlock_system_sleep();
 222}
 223EXPORT_SYMBOL_GPL(suspend_set_ops);
 224
 225/**
 226 * suspend_valid_only_mem - Generic memory-only valid callback.
 227 * @state: Target system sleep state.
 228 *
 229 * Platform drivers that implement mem suspend only and only need to check for
 230 * that in their .valid() callback can use this instead of rolling their own
 231 * .valid() callback.
 232 */
 233int suspend_valid_only_mem(suspend_state_t state)
 234{
 235        return state == PM_SUSPEND_MEM;
 236}
 237EXPORT_SYMBOL_GPL(suspend_valid_only_mem);
 238
 239static bool sleep_state_supported(suspend_state_t state)
 240{
 241        return state == PM_SUSPEND_TO_IDLE || (suspend_ops && suspend_ops->enter);
 242}
 243
 244static int platform_suspend_prepare(suspend_state_t state)
 245{
 246        return state != PM_SUSPEND_TO_IDLE && suspend_ops->prepare ?
 247                suspend_ops->prepare() : 0;
 248}
 249
 250static int platform_suspend_prepare_late(suspend_state_t state)
 251{
 252        return state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->prepare ?
 253                s2idle_ops->prepare() : 0;
 254}
 255
 256static int platform_suspend_prepare_noirq(suspend_state_t state)
 257{
 258        if (state == PM_SUSPEND_TO_IDLE)
 259                return s2idle_ops && s2idle_ops->prepare_late ?
 260                        s2idle_ops->prepare_late() : 0;
 261
 262        return suspend_ops->prepare_late ? suspend_ops->prepare_late() : 0;
 263}
 264
 265static void platform_resume_noirq(suspend_state_t state)
 266{
 267        if (state == PM_SUSPEND_TO_IDLE) {
 268                if (s2idle_ops && s2idle_ops->restore_early)
 269                        s2idle_ops->restore_early();
 270        } else if (suspend_ops->wake) {
 271                suspend_ops->wake();
 272        }
 273}
 274
 275static void platform_resume_early(suspend_state_t state)
 276{
 277        if (state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->restore)
 278                s2idle_ops->restore();
 279}
 280
 281static void platform_resume_finish(suspend_state_t state)
 282{
 283        if (state != PM_SUSPEND_TO_IDLE && suspend_ops->finish)
 284                suspend_ops->finish();
 285}
 286
 287static int platform_suspend_begin(suspend_state_t state)
 288{
 289        if (state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->begin)
 290                return s2idle_ops->begin();
 291        else if (suspend_ops && suspend_ops->begin)
 292                return suspend_ops->begin(state);
 293        else
 294                return 0;
 295}
 296
 297static void platform_resume_end(suspend_state_t state)
 298{
 299        if (state == PM_SUSPEND_TO_IDLE && s2idle_ops && s2idle_ops->end)
 300                s2idle_ops->end();
 301        else if (suspend_ops && suspend_ops->end)
 302                suspend_ops->end();
 303}
 304
 305static void platform_recover(suspend_state_t state)
 306{
 307        if (state != PM_SUSPEND_TO_IDLE && suspend_ops->recover)
 308                suspend_ops->recover();
 309}
 310
 311static bool platform_suspend_again(suspend_state_t state)
 312{
 313        return state != PM_SUSPEND_TO_IDLE && suspend_ops->suspend_again ?
 314                suspend_ops->suspend_again() : false;
 315}
 316
 317#ifdef CONFIG_PM_DEBUG
 318static unsigned int pm_test_delay = 5;
 319module_param(pm_test_delay, uint, 0644);
 320MODULE_PARM_DESC(pm_test_delay,
 321                 "Number of seconds to wait before resuming from suspend test");
 322#endif
 323
 324static int suspend_test(int level)
 325{
 326#ifdef CONFIG_PM_DEBUG
 327        if (pm_test_level == level) {
 328                pr_info("suspend debug: Waiting for %d second(s).\n",
 329                                pm_test_delay);
 330                mdelay(pm_test_delay * 1000);
 331                return 1;
 332        }
 333#endif /* !CONFIG_PM_DEBUG */
 334        return 0;
 335}
 336
 337/**
 338 * suspend_prepare - Prepare for entering system sleep state.
 339 * @state: Target system sleep state.
 340 *
 341 * Common code run for every system sleep state that can be entered (except for
 342 * hibernation).  Run suspend notifiers, allocate the "suspend" console and
 343 * freeze processes.
 344 */
 345static int suspend_prepare(suspend_state_t state)
 346{
 347        int error;
 348
 349        if (!sleep_state_supported(state))
 350                return -EPERM;
 351
 352        pm_prepare_console();
 353
 354        error = pm_notifier_call_chain_robust(PM_SUSPEND_PREPARE, PM_POST_SUSPEND);
 355        if (error)
 356                goto Restore;
 357
 358        trace_suspend_resume(TPS("freeze_processes"), 0, true);
 359        error = suspend_freeze_processes();
 360        trace_suspend_resume(TPS("freeze_processes"), 0, false);
 361        if (!error)
 362                return 0;
 363
 364        suspend_stats.failed_freeze++;
 365        dpm_save_failed_step(SUSPEND_FREEZE);
 366        pm_notifier_call_chain(PM_POST_SUSPEND);
 367 Restore:
 368        pm_restore_console();
 369        return error;
 370}
 371
 372/* default implementation */
 373void __weak arch_suspend_disable_irqs(void)
 374{
 375        local_irq_disable();
 376}
 377
 378/* default implementation */
 379void __weak arch_suspend_enable_irqs(void)
 380{
 381        local_irq_enable();
 382}
 383
 384/**
 385 * suspend_enter - Make the system enter the given sleep state.
 386 * @state: System sleep state to enter.
 387 * @wakeup: Returns information that the sleep state should not be re-entered.
 388 *
 389 * This function should be called after devices have been suspended.
 390 */
 391static int suspend_enter(suspend_state_t state, bool *wakeup)
 392{
 393        int error;
 394
 395        error = platform_suspend_prepare(state);
 396        if (error)
 397                goto Platform_finish;
 398
 399        error = dpm_suspend_late(PMSG_SUSPEND);
 400        if (error) {
 401                pr_err("late suspend of devices failed\n");
 402                goto Platform_finish;
 403        }
 404        error = platform_suspend_prepare_late(state);
 405        if (error)
 406                goto Devices_early_resume;
 407
 408        error = dpm_suspend_noirq(PMSG_SUSPEND);
 409        if (error) {
 410                pr_err("noirq suspend of devices failed\n");
 411                goto Platform_early_resume;
 412        }
 413        error = platform_suspend_prepare_noirq(state);
 414        if (error)
 415                goto Platform_wake;
 416
 417        if (suspend_test(TEST_PLATFORM))
 418                goto Platform_wake;
 419
 420        if (state == PM_SUSPEND_TO_IDLE) {
 421                s2idle_loop();
 422                goto Platform_wake;
 423        }
 424
 425        error = suspend_disable_secondary_cpus();
 426        if (error || suspend_test(TEST_CPUS))
 427                goto Enable_cpus;
 428
 429        arch_suspend_disable_irqs();
 430        BUG_ON(!irqs_disabled());
 431
 432        system_state = SYSTEM_SUSPEND;
 433
 434        error = syscore_suspend();
 435        if (!error) {
 436                *wakeup = pm_wakeup_pending();
 437                if (!(suspend_test(TEST_CORE) || *wakeup)) {
 438                        trace_suspend_resume(TPS("machine_suspend"),
 439                                state, true);
 440                        error = suspend_ops->enter(state);
 441                        trace_suspend_resume(TPS("machine_suspend"),
 442                                state, false);
 443                } else if (*wakeup) {
 444                        error = -EBUSY;
 445                }
 446                syscore_resume();
 447        }
 448
 449        system_state = SYSTEM_RUNNING;
 450
 451        arch_suspend_enable_irqs();
 452        BUG_ON(irqs_disabled());
 453
 454 Enable_cpus:
 455        suspend_enable_secondary_cpus();
 456
 457 Platform_wake:
 458        platform_resume_noirq(state);
 459        dpm_resume_noirq(PMSG_RESUME);
 460
 461 Platform_early_resume:
 462        platform_resume_early(state);
 463
 464 Devices_early_resume:
 465        dpm_resume_early(PMSG_RESUME);
 466
 467 Platform_finish:
 468        platform_resume_finish(state);
 469        return error;
 470}
 471
 472/**
 473 * suspend_devices_and_enter - Suspend devices and enter system sleep state.
 474 * @state: System sleep state to enter.
 475 */
 476int suspend_devices_and_enter(suspend_state_t state)
 477{
 478        int error;
 479        bool wakeup = false;
 480
 481        if (!sleep_state_supported(state))
 482                return -ENOSYS;
 483
 484        pm_suspend_target_state = state;
 485
 486        if (state == PM_SUSPEND_TO_IDLE)
 487                pm_set_suspend_no_platform();
 488
 489        error = platform_suspend_begin(state);
 490        if (error)
 491                goto Close;
 492
 493        suspend_console();
 494        suspend_test_start();
 495        error = dpm_suspend_start(PMSG_SUSPEND);
 496        if (error) {
 497                pr_err("Some devices failed to suspend, or early wake event detected\n");
 498                goto Recover_platform;
 499        }
 500        suspend_test_finish("suspend devices");
 501        if (suspend_test(TEST_DEVICES))
 502                goto Recover_platform;
 503
 504        do {
 505                error = suspend_enter(state, &wakeup);
 506        } while (!error && !wakeup && platform_suspend_again(state));
 507
 508 Resume_devices:
 509        suspend_test_start();
 510        dpm_resume_end(PMSG_RESUME);
 511        suspend_test_finish("resume devices");
 512        trace_suspend_resume(TPS("resume_console"), state, true);
 513        resume_console();
 514        trace_suspend_resume(TPS("resume_console"), state, false);
 515
 516 Close:
 517        platform_resume_end(state);
 518        pm_suspend_target_state = PM_SUSPEND_ON;
 519        return error;
 520
 521 Recover_platform:
 522        platform_recover(state);
 523        goto Resume_devices;
 524}
 525
 526/**
 527 * suspend_finish - Clean up before finishing the suspend sequence.
 528 *
 529 * Call platform code to clean up, restart processes, and free the console that
 530 * we've allocated. This routine is not called for hibernation.
 531 */
 532static void suspend_finish(void)
 533{
 534        suspend_thaw_processes();
 535        pm_notifier_call_chain(PM_POST_SUSPEND);
 536        pm_restore_console();
 537}
 538
 539/**
 540 * enter_state - Do common work needed to enter system sleep state.
 541 * @state: System sleep state to enter.
 542 *
 543 * Make sure that no one else is trying to put the system into a sleep state.
 544 * Fail if that's not the case.  Otherwise, prepare for system suspend, make the
 545 * system enter the given sleep state and clean up after wakeup.
 546 */
 547static int enter_state(suspend_state_t state)
 548{
 549        int error;
 550
 551        trace_suspend_resume(TPS("suspend_enter"), state, true);
 552        if (state == PM_SUSPEND_TO_IDLE) {
 553#ifdef CONFIG_PM_DEBUG
 554                if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {
 555                        pr_warn("Unsupported test mode for suspend to idle, please choose none/freezer/devices/platform.\n");
 556                        return -EAGAIN;
 557                }
 558#endif
 559        } else if (!valid_state(state)) {
 560                return -EINVAL;
 561        }
 562        if (!mutex_trylock(&system_transition_mutex))
 563                return -EBUSY;
 564
 565        if (state == PM_SUSPEND_TO_IDLE)
 566                s2idle_begin();
 567
 568        if (sync_on_suspend_enabled) {
 569                trace_suspend_resume(TPS("sync_filesystems"), 0, true);
 570                ksys_sync_helper();
 571                trace_suspend_resume(TPS("sync_filesystems"), 0, false);
 572        }
 573
 574        pm_pr_dbg("Preparing system for sleep (%s)\n", mem_sleep_labels[state]);
 575        pm_suspend_clear_flags();
 576        error = suspend_prepare(state);
 577        if (error)
 578                goto Unlock;
 579
 580        if (suspend_test(TEST_FREEZER))
 581                goto Finish;
 582
 583        trace_suspend_resume(TPS("suspend_enter"), state, false);
 584        pm_pr_dbg("Suspending system (%s)\n", mem_sleep_labels[state]);
 585        pm_restrict_gfp_mask();
 586        error = suspend_devices_and_enter(state);
 587        pm_restore_gfp_mask();
 588
 589 Finish:
 590        events_check_enabled = false;
 591        pm_pr_dbg("Finishing wakeup.\n");
 592        suspend_finish();
 593 Unlock:
 594        mutex_unlock(&system_transition_mutex);
 595        return error;
 596}
 597
 598/**
 599 * pm_suspend - Externally visible function for suspending the system.
 600 * @state: System sleep state to enter.
 601 *
 602 * Check if the value of @state represents one of the supported states,
 603 * execute enter_state() and update system suspend statistics.
 604 */
 605int pm_suspend(suspend_state_t state)
 606{
 607        int error;
 608
 609        if (state <= PM_SUSPEND_ON || state >= PM_SUSPEND_MAX)
 610                return -EINVAL;
 611
 612        pr_info("suspend entry (%s)\n", mem_sleep_labels[state]);
 613        error = enter_state(state);
 614        if (error) {
 615                suspend_stats.fail++;
 616                dpm_save_failed_errno(error);
 617        } else {
 618                suspend_stats.success++;
 619        }
 620        pr_info("suspend exit\n");
 621        return error;
 622}
 623EXPORT_SYMBOL(pm_suspend);
 624