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