kernel/power/suspend.c

   1 /*
   2  * kernel/power/suspend.c - Suspend to RAM and standby functionality.
   3  *
   4  * Copyright (c) 2003 Patrick Mochel
   5  * Copyright (c) 2003 Open Source Development Lab
   6  * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
   7  *
   8  * This file is released under the GPLv2.
   9  */
  10
  11 #include <linux/string.h>
  12 #include <linux/delay.h>
  13 #include <linux/errno.h>
  14 #include <linux/init.h>
  15 #include <linux/console.h>
  16 #include <linux/cpu.h>
  17 #include <linux/cpuidle.h>
  18 #include <linux/syscalls.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/ftrace.h>
  29 #include <trace/events/power.h>
  30 #include <linux/compiler.h>
  31
  32 #include "power.h"
  33
  34 static const char *pm_labels[] = { "mem", "standby", "freeze", };
  35 const char *pm_states[PM_SUSPEND_MAX];
  36
  37 static const struct platform_suspend_ops *suspend_ops;
  38 static const struct platform_freeze_ops *freeze_ops;
  39 static DECLARE_WAIT_QUEUE_HEAD(suspend_freeze_wait_head);
  40 static bool suspend_freeze_wake;
  41
  42 void freeze_set_ops(const struct platform_freeze_ops *ops)
  43 {
  44         lock_system_sleep();
  45         freeze_ops = ops;
  46         unlock_system_sleep();
  47 }
  48
  49 static void freeze_begin(void)
  50 {
  51         suspend_freeze_wake = false;
  52 }
  53
  54 static void freeze_enter(void)
  55 {
  56         cpuidle_use_deepest_state(true);
  57         cpuidle_resume();
  58         wait_event(suspend_freeze_wait_head, suspend_freeze_wake);
  59         cpuidle_pause();
  60         cpuidle_use_deepest_state(false);
  61 }
  62
  63 void freeze_wake(void)
  64 {
  65         suspend_freeze_wake = true;
  66         wake_up(&suspend_freeze_wait_head);
  67 }
  68 EXPORT_SYMBOL_GPL(freeze_wake);
  69
  70 static bool valid_state(suspend_state_t state)
  71 {
  72         /*
  73          * PM_SUSPEND_STANDBY and PM_SUSPEND_MEM states need low level
  74          * support and need to be valid to the low level
  75          * implementation, no valid callback implies that none are valid.
  76          */
  77         return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
  78 }
  79
  80 /*
  81  * If this is set, the "mem" label always corresponds to the deepest sleep state
  82  * available, the "standby" label corresponds to the second deepest sleep state
  83  * available (if any), and the "freeze" label corresponds to the remaining
  84  * available sleep state (if there is one).
  85  */
  86 static bool relative_states;
  87
  88 static int __init sleep_states_setup(char *str)
  89 {
  90         relative_states = !strncmp(str, "1", 1);
  91         pm_states[PM_SUSPEND_FREEZE] = pm_labels[relative_states ? 0 : 2];
  92         return 1;
  93 }
  94
  95 __setup("relative_sleep_states=", sleep_states_setup);
  96
  97 /**
  98  * suspend_set_ops - Set the global suspend method table.
  99  * @ops: Suspend operations to use.
 100  */
 101 void suspend_set_ops(const struct platform_suspend_ops *ops)
 102 {
 103         suspend_state_t i;
 104         int j = 0;
 105
 106         lock_system_sleep();
 107
 108         suspend_ops = ops;
 109         for (i = PM_SUSPEND_MEM; i >= PM_SUSPEND_STANDBY; i--)
 110                 if (valid_state(i)) {
 111                         pm_states[i] = pm_labels[j++];
 112                 } else if (!relative_states) {
 113                         pm_states[i] = NULL;
 114                         j++;
 115                 }
 116
 117         pm_states[PM_SUSPEND_FREEZE] = pm_labels[j];
 118
 119         unlock_system_sleep();
 120 }
 121 EXPORT_SYMBOL_GPL(suspend_set_ops);
 122
 123 /**
 124  * suspend_valid_only_mem - Generic memory-only valid callback.
 125  *
 126  * Platform drivers that implement mem suspend only and only need to check for
 127  * that in their .valid() callback can use this instead of rolling their own
 128  * .valid() callback.
 129  */
 130 int suspend_valid_only_mem(suspend_state_t state)
 131 {
 132         return state == PM_SUSPEND_MEM;
 133 }
 134 EXPORT_SYMBOL_GPL(suspend_valid_only_mem);
 135
 136 static bool sleep_state_supported(suspend_state_t state)
 137 {
 138         return state == PM_SUSPEND_FREEZE || (suspend_ops && suspend_ops->enter);
 139 }
 140
 141 static int platform_suspend_prepare(suspend_state_t state)
 142 {
 143         return state != PM_SUSPEND_FREEZE && suspend_ops->prepare ?
 144                 suspend_ops->prepare() : 0;
 145 }
 146
 147 static int platform_suspend_prepare_late(suspend_state_t state)
 148 {
 149         return state != PM_SUSPEND_FREEZE && suspend_ops->prepare_late ?
 150                 suspend_ops->prepare_late() : 0;
 151 }
 152
 153 static void platform_suspend_wake(suspend_state_t state)
 154 {
 155         if (state != PM_SUSPEND_FREEZE && suspend_ops->wake)
 156                 suspend_ops->wake();
 157 }
 158
 159 static void platform_suspend_finish(suspend_state_t state)
 160 {
 161         if (state != PM_SUSPEND_FREEZE && suspend_ops->finish)
 162                 suspend_ops->finish();
 163 }
 164
 165 static int platform_suspend_begin(suspend_state_t state)
 166 {
 167         if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->begin)
 168                 return freeze_ops->begin();
 169         else if (suspend_ops->begin)
 170                 return suspend_ops->begin(state);
 171         else
 172                 return 0;
 173 }
 174
 175 static void platform_suspend_end(suspend_state_t state)
 176 {
 177         if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->end)
 178                 freeze_ops->end();
 179         else if (suspend_ops->end)
 180                 suspend_ops->end();
 181 }
 182
 183 static void platform_suspend_recover(suspend_state_t state)
 184 {
 185         if (state != PM_SUSPEND_FREEZE && suspend_ops->recover)
 186                 suspend_ops->recover();
 187 }
 188
 189 static bool platform_suspend_again(suspend_state_t state)
 190 {
 191         return state != PM_SUSPEND_FREEZE && suspend_ops->suspend_again ?
 192                 suspend_ops->suspend_again() : false;
 193 }
 194
 195 static int suspend_test(int level)
 196 {
 197 #ifdef CONFIG_PM_DEBUG
 198         if (pm_test_level == level) {
 199                 printk(KERN_INFO "suspend debug: Waiting for 5 seconds.\n");
 200                 mdelay(5000);
 201                 return 1;
 202         }
 203 #endif /* !CONFIG_PM_DEBUG */
 204         return 0;
 205 }
 206
 207 /**
 208  * suspend_prepare - Prepare for entering system sleep state.
 209  *
 210  * Common code run for every system sleep state that can be entered (except for
 211  * hibernation).  Run suspend notifiers, allocate the "suspend" console and
 212  * freeze processes.
 213  */
 214 static int suspend_prepare(suspend_state_t state)
 215 {
 216         int error;
 217
 218         if (!sleep_state_supported(state))
 219                 return -EPERM;
 220
 221         pm_prepare_console();
 222
 223         error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
 224         if (error)
 225                 goto Finish;
 226
 227         trace_suspend_resume(TPS("freeze_processes"), 0, true);
 228         error = suspend_freeze_processes();
 229         trace_suspend_resume(TPS("freeze_processes"), 0, false);
 230         if (!error)
 231                 return 0;
 232
 233         suspend_stats.failed_freeze++;
 234         dpm_save_failed_step(SUSPEND_FREEZE);
 235  Finish:
 236         pm_notifier_call_chain(PM_POST_SUSPEND);
 237         pm_restore_console();
 238         return error;
 239 }
 240
 241 /* default implementation */
 242 void __weak arch_suspend_disable_irqs(void)
 243 {
 244         local_irq_disable();
 245 }
 246
 247 /* default implementation */
 248 void __weak arch_suspend_enable_irqs(void)
 249 {
 250         local_irq_enable();
 251 }
 252
 253 /**
 254  * suspend_enter - Make the system enter the given sleep state.
 255  * @state: System sleep state to enter.
 256  * @wakeup: Returns information that the sleep state should not be re-entered.
 257  *
 258  * This function should be called after devices have been suspended.
 259  */
 260 static int suspend_enter(suspend_state_t state, bool *wakeup)
 261 {
 262         int error;
 263
 264         error = platform_suspend_prepare(state);
 265         if (error)
 266                 goto Platform_finish;
 267
 268         error = dpm_suspend_end(PMSG_SUSPEND);
 269         if (error) {
 270                 printk(KERN_ERR "PM: Some devices failed to power down\n");
 271                 goto Platform_finish;
 272         }
 273         error = platform_suspend_prepare_late(state);
 274         if (error)
 275                 goto Platform_wake;
 276
 277         if (suspend_test(TEST_PLATFORM))
 278                 goto Platform_wake;
 279
 280         /*
 281          * PM_SUSPEND_FREEZE equals
 282          * frozen processes + suspended devices + idle processors.
 283          * Thus we should invoke freeze_enter() soon after
 284          * all the devices are suspended.
 285          */
 286         if (state == PM_SUSPEND_FREEZE) {
 287                 trace_suspend_resume(TPS("machine_suspend"), state, true);
 288                 freeze_enter();
 289                 trace_suspend_resume(TPS("machine_suspend"), state, false);
 290                 goto Platform_wake;
 291         }
 292
 293         ftrace_stop();
 294         error = disable_nonboot_cpus();
 295         if (error || suspend_test(TEST_CPUS))
 296                 goto Enable_cpus;
 297
 298         arch_suspend_disable_irqs();
 299         BUG_ON(!irqs_disabled());
 300
 301         error = syscore_suspend();
 302         if (!error) {
 303                 *wakeup = pm_wakeup_pending();
 304                 if (!(suspend_test(TEST_CORE) || *wakeup)) {
 305                         trace_suspend_resume(TPS("machine_suspend"),
 306                                 state, true);
 307                         error = suspend_ops->enter(state);
 308                         trace_suspend_resume(TPS("machine_suspend"),
 309                                 state, false);
 310                         events_check_enabled = false;
 311                 }
 312                 syscore_resume();
 313         }
 314
 315         arch_suspend_enable_irqs();
 316         BUG_ON(irqs_disabled());
 317
 318  Enable_cpus:
 319         enable_nonboot_cpus();
 320         ftrace_start();
 321
 322  Platform_wake:
 323         platform_suspend_wake(state);
 324         dpm_resume_start(PMSG_RESUME);
 325
 326  Platform_finish:
 327         platform_suspend_finish(state);
 328         return error;
 329 }
 330
 331 /**
 332  * suspend_devices_and_enter - Suspend devices and enter system sleep state.
 333  * @state: System sleep state to enter.
 334  */
 335 int suspend_devices_and_enter(suspend_state_t state)
 336 {
 337         int error;
 338         bool wakeup = false;
 339
 340         if (!sleep_state_supported(state))
 341                 return -ENOSYS;
 342
 343         error = platform_suspend_begin(state);
 344         if (error)
 345                 goto Close;
 346
 347         suspend_console();
 348         suspend_test_start();
 349         error = dpm_suspend_start(PMSG_SUSPEND);
 350         if (error) {
 351                 pr_err("PM: Some devices failed to suspend, or early wake event detected\n");
 352                 goto Recover_platform;
 353         }
 354         suspend_test_finish("suspend devices");
 355         if (suspend_test(TEST_DEVICES))
 356                 goto Recover_platform;
 357
 358         do {
 359                 error = suspend_enter(state, &wakeup);
 360         } while (!error && !wakeup && platform_suspend_again(state));
 361
 362  Resume_devices:
 363         suspend_test_start();
 364         dpm_resume_end(PMSG_RESUME);
 365         suspend_test_finish("resume devices");
 366         resume_console();
 367
 368  Close:
 369         platform_suspend_end(state);
 370         return error;
 371
 372  Recover_platform:
 373         platform_suspend_recover(state);
 374         goto Resume_devices;
 375 }
 376
 377 /**
 378  * suspend_finish - Clean up before finishing the suspend sequence.
 379  *
 380  * Call platform code to clean up, restart processes, and free the console that
 381  * we've allocated. This routine is not called for hibernation.
 382  */
 383 static void suspend_finish(void)
 384 {
 385         suspend_thaw_processes();
 386         pm_notifier_call_chain(PM_POST_SUSPEND);
 387         pm_restore_console();
 388 }
 389
 390 /**
 391  * enter_state - Do common work needed to enter system sleep state.
 392  * @state: System sleep state to enter.
 393  *
 394  * Make sure that no one else is trying to put the system into a sleep state.
 395  * Fail if that's not the case.  Otherwise, prepare for system suspend, make the
 396  * system enter the given sleep state and clean up after wakeup.
 397  */
 398 static int enter_state(suspend_state_t state)
 399 {
 400         int error;
 401
 402         trace_suspend_resume(TPS("suspend_enter"), state, true);
 403         if (state == PM_SUSPEND_FREEZE) {
 404 #ifdef CONFIG_PM_DEBUG
 405                 if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {
 406                         pr_warning("PM: Unsupported test mode for freeze state,"
 407                                    "please choose none/freezer/devices/platform.\n");
 408                         return -EAGAIN;
 409                 }
 410 #endif
 411         } else if (!valid_state(state)) {
 412                 return -EINVAL;
 413         }
 414         if (!mutex_trylock(&pm_mutex))
 415                 return -EBUSY;
 416
 417         if (state == PM_SUSPEND_FREEZE)
 418                 freeze_begin();
 419
 420         trace_suspend_resume(TPS("sync_filesystems"), 0, true);
 421         printk(KERN_INFO "PM: Syncing filesystems ... ");
 422         sys_sync();
 423         printk("done.\n");
 424         trace_suspend_resume(TPS("sync_filesystems"), 0, false);
 425
 426         pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
 427         error = suspend_prepare(state);
 428         if (error)
 429                 goto Unlock;
 430
 431         if (suspend_test(TEST_FREEZER))
 432                 goto Finish;
 433
 434         trace_suspend_resume(TPS("suspend_enter"), state, false);
 435         pr_debug("PM: Entering %s sleep\n", pm_states[state]);
 436         pm_restrict_gfp_mask();
 437         error = suspend_devices_and_enter(state);
 438         pm_restore_gfp_mask();
 439
 440  Finish:
 441         pr_debug("PM: Finishing wakeup.\n");
 442         suspend_finish();
 443  Unlock:
 444         mutex_unlock(&pm_mutex);
 445         return error;
 446 }
 447
 448 /**
 449  * pm_suspend - Externally visible function for suspending the system.
 450  * @state: System sleep state to enter.
 451  *
 452  * Check if the value of @state represents one of the supported states,
 453  * execute enter_state() and update system suspend statistics.
 454  */
 455 int pm_suspend(suspend_state_t state)
 456 {
 457         int error;
 458
 459         if (state <= PM_SUSPEND_ON || state >= PM_SUSPEND_MAX)
 460                 return -EINVAL;
 461
 462         error = enter_state(state);
 463         if (error) {
 464                 suspend_stats.fail++;
 465                 dpm_save_failed_errno(error);
 466         } else {
 467                 suspend_stats.success++;
 468         }
 469         return error;
 470 }
 471 EXPORT_SYMBOL(pm_suspend);