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 35 const char *pm_labels[] = { "mem", "standby", "freeze", NULL }; 36 const char *pm_states[PM_SUSPEND_MAX]; 37 38 unsigned int pm_suspend_global_flags; 39 EXPORT_SYMBOL_GPL(pm_suspend_global_flags); 40 41 static const struct platform_suspend_ops *suspend_ops; 42 static const struct platform_freeze_ops *freeze_ops; 43 static DECLARE_WAIT_QUEUE_HEAD(suspend_freeze_wait_head); 44 45 enum freeze_state __read_mostly suspend_freeze_state; 46 static DEFINE_SPINLOCK(suspend_freeze_lock); 47 48 void freeze_set_ops(const struct platform_freeze_ops *ops) 49 { 50 lock_system_sleep(); 51 freeze_ops = ops; 52 unlock_system_sleep(); 53 } 54 55 static void freeze_begin(void) 56 { 57 suspend_freeze_state = FREEZE_STATE_NONE; 58 } 59 60 static 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 90 void 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 } 101 EXPORT_SYMBOL_GPL(freeze_wake); 102 103 static 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 */ 119 static bool relative_states; 120 121 static 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 */ 134 void 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 } 154 EXPORT_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 */ 163 int suspend_valid_only_mem(suspend_state_t state) 164 { 165 return state == PM_SUSPEND_MEM; 166 } 167 EXPORT_SYMBOL_GPL(suspend_valid_only_mem); 168 169 static bool sleep_state_supported(suspend_state_t state) 170 { 171 return state == PM_SUSPEND_FREEZE || (suspend_ops && suspend_ops->enter); 172 } 173 174 static 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 180 static 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 186 static 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 192 static void platform_resume_noirq(suspend_state_t state) 193 { 194 if (state != PM_SUSPEND_FREEZE && suspend_ops->wake) 195 suspend_ops->wake(); 196 } 197 198 static 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 204 static void platform_resume_finish(suspend_state_t state) 205 { 206 if (state != PM_SUSPEND_FREEZE && suspend_ops->finish) 207 suspend_ops->finish(); 208 } 209 210 static 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 220 static 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 228 static void platform_recover(suspend_state_t state) 229 { 230 if (state != PM_SUSPEND_FREEZE && suspend_ops->recover) 231 suspend_ops->recover(); 232 } 233 234 static 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 241 static unsigned int pm_test_delay = 5; 242 module_param(pm_test_delay, uint, 0644); 243 MODULE_PARM_DESC(pm_test_delay, 244 "Number of seconds to wait before resuming from suspend test"); 245 #endif 246 247 static int suspend_test(int level) 248 { 249 #ifdef CONFIG_PM_DEBUG 250 if (pm_test_level == level) { 251 pr_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 */ 267 static 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 */ 295 void __weak arch_suspend_disable_irqs(void) 296 { 297 local_irq_disable(); 298 } 299 300 /* default implementation */ 301 void __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 */ 313 static 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 pr_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 pr_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 */ 403 int 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 */ 453 static 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 */ 468 static 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_warn("PM: Unsupported test mode for suspend to idle, please choose none/freezer/devices/platform.\n"); 477 return -EAGAIN; 478 } 479 #endif 480 } else if (!valid_state(state)) { 481 return -EINVAL; 482 } 483 if (!mutex_trylock(&pm_mutex)) 484 return -EBUSY; 485 486 if (state == PM_SUSPEND_FREEZE) 487 freeze_begin(); 488 489 #ifndef CONFIG_SUSPEND_SKIP_SYNC 490 trace_suspend_resume(TPS("sync_filesystems"), 0, true); 491 printk(KERN_INFO "PM: Syncing filesystems ... "); 492 sys_sync(); 493 printk("done.\n"); 494 trace_suspend_resume(TPS("sync_filesystems"), 0, false); 495 #endif 496 497 pr_debug("PM: Preparing system for sleep (%s)\n", pm_states[state]); 498 pm_suspend_clear_flags(); 499 error = suspend_prepare(state); 500 if (error) 501 goto Unlock; 502 503 if (suspend_test(TEST_FREEZER)) 504 goto Finish; 505 506 trace_suspend_resume(TPS("suspend_enter"), state, false); 507 pr_debug("PM: Suspending system (%s)\n", pm_states[state]); 508 pm_restrict_gfp_mask(); 509 error = suspend_devices_and_enter(state); 510 pm_restore_gfp_mask(); 511 512 Finish: 513 pr_debug("PM: Finishing wakeup.\n"); 514 suspend_finish(); 515 Unlock: 516 mutex_unlock(&pm_mutex); 517 return error; 518 } 519 520 /** 521 * pm_suspend - Externally visible function for suspending the system. 522 * @state: System sleep state to enter. 523 * 524 * Check if the value of @state represents one of the supported states, 525 * execute enter_state() and update system suspend statistics. 526 */ 527 int pm_suspend(suspend_state_t state) 528 { 529 int error; 530 531 if (state <= PM_SUSPEND_ON || state >= PM_SUSPEND_MAX) 532 return -EINVAL; 533 534 error = enter_state(state); 535 if (error) { 536 suspend_stats.fail++; 537 dpm_save_failed_errno(error); 538 } else { 539 suspend_stats.success++; 540 } 541 return error; 542 } 543 EXPORT_SYMBOL(pm_suspend); 544