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#include <linux/moduleparam.h> 32 33#include "power.h" 34 35const char *pm_labels[] = { "mem", "standby", "freeze", NULL }; 36const char *pm_states[PM_SUSPEND_MAX]; 37 38unsigned int pm_suspend_global_flags; 39EXPORT_SYMBOL_GPL(pm_suspend_global_flags); 40 41static const struct platform_suspend_ops *suspend_ops; 42static const struct platform_freeze_ops *freeze_ops; 43static DECLARE_WAIT_QUEUE_HEAD(suspend_freeze_wait_head); 44 45enum freeze_state __read_mostly suspend_freeze_state; 46static DEFINE_SPINLOCK(suspend_freeze_lock); 47 48void freeze_set_ops(const struct platform_freeze_ops *ops) 49{ 50 lock_system_sleep(); 51 freeze_ops = ops; 52 unlock_system_sleep(); 53} 54 55static void freeze_begin(void) 56{ 57 suspend_freeze_state = FREEZE_STATE_NONE; 58} 59 60static void freeze_enter(void) 61{ 62 spin_lock_irq(&suspend_freeze_lock); 63 if (pm_wakeup_pending()) 64 goto out; 65 66 suspend_freeze_state = FREEZE_STATE_ENTER; 67 spin_unlock_irq(&suspend_freeze_lock); 68 69 get_online_cpus(); 70 cpuidle_resume(); 71 72 /* Push all the CPUs into the idle loop. */ 73 wake_up_all_idle_cpus(); 74 pr_debug("PM: suspend-to-idle\n"); 75 /* Make the current CPU wait so it can enter the idle loop too. */ 76 wait_event(suspend_freeze_wait_head, 77 suspend_freeze_state == FREEZE_STATE_WAKE); 78 pr_debug("PM: resume from suspend-to-idle\n"); 79 80 cpuidle_pause(); 81 put_online_cpus(); 82 83 spin_lock_irq(&suspend_freeze_lock); 84 85 out: 86 suspend_freeze_state = FREEZE_STATE_NONE; 87 spin_unlock_irq(&suspend_freeze_lock); 88} 89 90void freeze_wake(void) 91{ 92 unsigned long flags; 93 94 spin_lock_irqsave(&suspend_freeze_lock, flags); 95 if (suspend_freeze_state > FREEZE_STATE_NONE) { 96 suspend_freeze_state = FREEZE_STATE_WAKE; 97 wake_up(&suspend_freeze_wait_head); 98 } 99 spin_unlock_irqrestore(&suspend_freeze_lock, flags); 100} 101EXPORT_SYMBOL_GPL(freeze_wake); 102 103static bool valid_state(suspend_state_t state) 104{ 105 /* 106 * PM_SUSPEND_STANDBY and PM_SUSPEND_MEM states need low level 107 * support and need to be valid to the low level 108 * implementation, no valid callback implies that none are valid. 109 */ 110 return suspend_ops && suspend_ops->valid && suspend_ops->valid(state); 111} 112 113/* 114 * If this is set, the "mem" label always corresponds to the deepest sleep state 115 * available, the "standby" label corresponds to the second deepest sleep state 116 * available (if any), and the "freeze" label corresponds to the remaining 117 * available sleep state (if there is one). 118 */ 119static bool relative_states; 120 121static int __init sleep_states_setup(char *str) 122{ 123 relative_states = !strncmp(str, "1", 1); 124 pm_states[PM_SUSPEND_FREEZE] = pm_labels[relative_states ? 0 : 2]; 125 return 1; 126} 127 128__setup("relative_sleep_states=", sleep_states_setup); 129 130/** 131 * suspend_set_ops - Set the global suspend method table. 132 * @ops: Suspend operations to use. 133 */ 134void suspend_set_ops(const struct platform_suspend_ops *ops) 135{ 136 suspend_state_t i; 137 int j = 0; 138 139 lock_system_sleep(); 140 141 suspend_ops = ops; 142 for (i = PM_SUSPEND_MEM; i >= PM_SUSPEND_STANDBY; i--) 143 if (valid_state(i)) { 144 pm_states[i] = pm_labels[j++]; 145 } else if (!relative_states) { 146 pm_states[i] = NULL; 147 j++; 148 } 149 150 pm_states[PM_SUSPEND_FREEZE] = pm_labels[j]; 151 152 unlock_system_sleep(); 153} 154EXPORT_SYMBOL_GPL(suspend_set_ops); 155 156/** 157 * suspend_valid_only_mem - Generic memory-only valid callback. 158 * 159 * Platform drivers that implement mem suspend only and only need to check for 160 * that in their .valid() callback can use this instead of rolling their own 161 * .valid() callback. 162 */ 163int suspend_valid_only_mem(suspend_state_t state) 164{ 165 return state == PM_SUSPEND_MEM; 166} 167EXPORT_SYMBOL_GPL(suspend_valid_only_mem); 168 169static bool sleep_state_supported(suspend_state_t state) 170{ 171 return state == PM_SUSPEND_FREEZE || (suspend_ops && suspend_ops->enter); 172} 173 174static int platform_suspend_prepare(suspend_state_t state) 175{ 176 return state != PM_SUSPEND_FREEZE && suspend_ops->prepare ? 177 suspend_ops->prepare() : 0; 178} 179 180static int platform_suspend_prepare_late(suspend_state_t state) 181{ 182 return state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->prepare ? 183 freeze_ops->prepare() : 0; 184} 185 186static int platform_suspend_prepare_noirq(suspend_state_t state) 187{ 188 return state != PM_SUSPEND_FREEZE && suspend_ops->prepare_late ? 189 suspend_ops->prepare_late() : 0; 190} 191 192static void platform_resume_noirq(suspend_state_t state) 193{ 194 if (state != PM_SUSPEND_FREEZE && suspend_ops->wake) 195 suspend_ops->wake(); 196} 197 198static void platform_resume_early(suspend_state_t state) 199{ 200 if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->restore) 201 freeze_ops->restore(); 202} 203 204static void platform_resume_finish(suspend_state_t state) 205{ 206 if (state != PM_SUSPEND_FREEZE && suspend_ops->finish) 207 suspend_ops->finish(); 208} 209 210static int platform_suspend_begin(suspend_state_t state) 211{ 212 if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->begin) 213 return freeze_ops->begin(); 214 else if (suspend_ops->begin) 215 return suspend_ops->begin(state); 216 else 217 return 0; 218} 219 220static void platform_resume_end(suspend_state_t state) 221{ 222 if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->end) 223 freeze_ops->end(); 224 else if (suspend_ops->end) 225 suspend_ops->end(); 226} 227 228static void platform_recover(suspend_state_t state) 229{ 230 if (state != PM_SUSPEND_FREEZE && suspend_ops->recover) 231 suspend_ops->recover(); 232} 233 234static bool platform_suspend_again(suspend_state_t state) 235{ 236 return state != PM_SUSPEND_FREEZE && suspend_ops->suspend_again ? 237 suspend_ops->suspend_again() : false; 238} 239 240#ifdef CONFIG_PM_DEBUG 241static unsigned int pm_test_delay = 5; 242module_param(pm_test_delay, uint, 0644); 243MODULE_PARM_DESC(pm_test_delay, 244 "Number of seconds to wait before resuming from suspend test"); 245#endif 246 247static int suspend_test(int level) 248{ 249#ifdef CONFIG_PM_DEBUG 250 if (pm_test_level == level) { 251 printk(KERN_INFO "suspend debug: Waiting for %d second(s).\n", 252 pm_test_delay); 253 mdelay(pm_test_delay * 1000); 254 return 1; 255 } 256#endif /* !CONFIG_PM_DEBUG */ 257 return 0; 258} 259 260/** 261 * suspend_prepare - Prepare for entering system sleep state. 262 * 263 * Common code run for every system sleep state that can be entered (except for 264 * hibernation). Run suspend notifiers, allocate the "suspend" console and 265 * freeze processes. 266 */ 267static int suspend_prepare(suspend_state_t state) 268{ 269 int error; 270 271 if (!sleep_state_supported(state)) 272 return -EPERM; 273 274 pm_prepare_console(); 275 276 error = pm_notifier_call_chain(PM_SUSPEND_PREPARE); 277 if (error) 278 goto Finish; 279 280 trace_suspend_resume(TPS("freeze_processes"), 0, true); 281 error = suspend_freeze_processes(); 282 trace_suspend_resume(TPS("freeze_processes"), 0, false); 283 if (!error) 284 return 0; 285 286 suspend_stats.failed_freeze++; 287 dpm_save_failed_step(SUSPEND_FREEZE); 288 Finish: 289 pm_notifier_call_chain(PM_POST_SUSPEND); 290 pm_restore_console(); 291 return error; 292} 293 294/* default implementation */ 295void __weak arch_suspend_disable_irqs(void) 296{ 297 local_irq_disable(); 298} 299 300/* default implementation */ 301void __weak arch_suspend_enable_irqs(void) 302{ 303 local_irq_enable(); 304} 305 306/** 307 * suspend_enter - Make the system enter the given sleep state. 308 * @state: System sleep state to enter. 309 * @wakeup: Returns information that the sleep state should not be re-entered. 310 * 311 * This function should be called after devices have been suspended. 312 */ 313static int suspend_enter(suspend_state_t state, bool *wakeup) 314{ 315 int error; 316 317 error = platform_suspend_prepare(state); 318 if (error) 319 goto Platform_finish; 320 321 error = dpm_suspend_late(PMSG_SUSPEND); 322 if (error) { 323 printk(KERN_ERR "PM: late suspend of devices failed\n"); 324 goto Platform_finish; 325 } 326 error = platform_suspend_prepare_late(state); 327 if (error) 328 goto Devices_early_resume; 329 330 error = dpm_suspend_noirq(PMSG_SUSPEND); 331 if (error) { 332 printk(KERN_ERR "PM: noirq suspend of devices failed\n"); 333 goto Platform_early_resume; 334 } 335 error = platform_suspend_prepare_noirq(state); 336 if (error) 337 goto Platform_wake; 338 339 if (suspend_test(TEST_PLATFORM)) 340 goto Platform_wake; 341 342 /* 343 * PM_SUSPEND_FREEZE equals 344 * frozen processes + suspended devices + idle processors. 345 * Thus we should invoke freeze_enter() soon after 346 * all the devices are suspended. 347 */ 348 if (state == PM_SUSPEND_FREEZE) { 349 trace_suspend_resume(TPS("machine_suspend"), state, true); 350 freeze_enter(); 351 trace_suspend_resume(TPS("machine_suspend"), state, false); 352 goto Platform_wake; 353 } 354 355 error = disable_nonboot_cpus(); 356 if (error || suspend_test(TEST_CPUS)) 357 goto Enable_cpus; 358 359 arch_suspend_disable_irqs(); 360 BUG_ON(!irqs_disabled()); 361 362 error = syscore_suspend(); 363 if (!error) { 364 *wakeup = pm_wakeup_pending(); 365 if (!(suspend_test(TEST_CORE) || *wakeup)) { 366 trace_suspend_resume(TPS("machine_suspend"), 367 state, true); 368 error = suspend_ops->enter(state); 369 trace_suspend_resume(TPS("machine_suspend"), 370 state, false); 371 events_check_enabled = false; 372 } else if (*wakeup) { 373 error = -EBUSY; 374 } 375 syscore_resume(); 376 } 377 378 arch_suspend_enable_irqs(); 379 BUG_ON(irqs_disabled()); 380 381 Enable_cpus: 382 enable_nonboot_cpus(); 383 384 Platform_wake: 385 platform_resume_noirq(state); 386 dpm_resume_noirq(PMSG_RESUME); 387 388 Platform_early_resume: 389 platform_resume_early(state); 390 391 Devices_early_resume: 392 dpm_resume_early(PMSG_RESUME); 393 394 Platform_finish: 395 platform_resume_finish(state); 396 return error; 397} 398 399/** 400 * suspend_devices_and_enter - Suspend devices and enter system sleep state. 401 * @state: System sleep state to enter. 402 */ 403int suspend_devices_and_enter(suspend_state_t state) 404{ 405 int error; 406 bool wakeup = false; 407 408 if (!sleep_state_supported(state)) 409 return -ENOSYS; 410 411 error = platform_suspend_begin(state); 412 if (error) 413 goto Close; 414 415 suspend_console(); 416 suspend_test_start(); 417 error = dpm_suspend_start(PMSG_SUSPEND); 418 if (error) { 419 pr_err("PM: Some devices failed to suspend, or early wake event detected\n"); 420 goto Recover_platform; 421 } 422 suspend_test_finish("suspend devices"); 423 if (suspend_test(TEST_DEVICES)) 424 goto Recover_platform; 425 426 do { 427 error = suspend_enter(state, &wakeup); 428 } while (!error && !wakeup && platform_suspend_again(state)); 429 430 Resume_devices: 431 suspend_test_start(); 432 dpm_resume_end(PMSG_RESUME); 433 suspend_test_finish("resume devices"); 434 trace_suspend_resume(TPS("resume_console"), state, true); 435 resume_console(); 436 trace_suspend_resume(TPS("resume_console"), state, false); 437 438 Close: 439 platform_resume_end(state); 440 return error; 441 442 Recover_platform: 443 platform_recover(state); 444 goto Resume_devices; 445} 446 447/** 448 * suspend_finish - Clean up before finishing the suspend sequence. 449 * 450 * Call platform code to clean up, restart processes, and free the console that 451 * we've allocated. This routine is not called for hibernation. 452 */ 453static void suspend_finish(void) 454{ 455 suspend_thaw_processes(); 456 pm_notifier_call_chain(PM_POST_SUSPEND); 457 pm_restore_console(); 458} 459 460/** 461 * enter_state - Do common work needed to enter system sleep state. 462 * @state: System sleep state to enter. 463 * 464 * Make sure that no one else is trying to put the system into a sleep state. 465 * Fail if that's not the case. Otherwise, prepare for system suspend, make the 466 * system enter the given sleep state and clean up after wakeup. 467 */ 468static int enter_state(suspend_state_t state) 469{ 470 int error; 471 472 trace_suspend_resume(TPS("suspend_enter"), state, true); 473 if (state == PM_SUSPEND_FREEZE) { 474#ifdef CONFIG_PM_DEBUG 475 if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) { 476 pr_warning("PM: Unsupported test mode for suspend to idle," 477 "please choose none/freezer/devices/platform.\n"); 478 return -EAGAIN; 479 } 480#endif 481 } else if (!valid_state(state)) { 482 return -EINVAL; 483 } 484 if (!mutex_trylock(&pm_mutex)) 485 return -EBUSY; 486 487 if (state == PM_SUSPEND_FREEZE) 488 freeze_begin(); 489 490#ifndef CONFIG_SUSPEND_SKIP_SYNC 491 trace_suspend_resume(TPS("sync_filesystems"), 0, true); 492 printk(KERN_INFO "PM: Syncing filesystems ... "); 493 sys_sync(); 494 printk("done.\n"); 495 trace_suspend_resume(TPS("sync_filesystems"), 0, false); 496#endif 497 498 pr_debug("PM: Preparing system for sleep (%s)\n", pm_states[state]); 499 pm_suspend_clear_flags(); 500 error = suspend_prepare(state); 501 if (error) 502 goto Unlock; 503 504 if (suspend_test(TEST_FREEZER)) 505 goto Finish; 506 507 trace_suspend_resume(TPS("suspend_enter"), state, false); 508 pr_debug("PM: Suspending system (%s)\n", pm_states[state]); 509 pm_restrict_gfp_mask(); 510 error = suspend_devices_and_enter(state); 511 pm_restore_gfp_mask(); 512 513 Finish: 514 pr_debug("PM: Finishing wakeup.\n"); 515 suspend_finish(); 516 Unlock: 517 mutex_unlock(&pm_mutex); 518 return error; 519} 520 521/** 522 * pm_suspend - Externally visible function for suspending the system. 523 * @state: System sleep state to enter. 524 * 525 * Check if the value of @state represents one of the supported states, 526 * execute enter_state() and update system suspend statistics. 527 */ 528int pm_suspend(suspend_state_t state) 529{ 530 int error; 531 532 if (state <= PM_SUSPEND_ON || state >= PM_SUSPEND_MAX) 533 return -EINVAL; 534 535 error = enter_state(state); 536 if (error) { 537 suspend_stats.fail++; 538 dpm_save_failed_errno(error); 539 } else { 540 suspend_stats.success++; 541 } 542 return error; 543} 544EXPORT_SYMBOL(pm_suspend); 545