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/syscalls.h> 18 #include <linux/gfp.h> 19 #include <linux/io.h> 20 #include <linux/kernel.h> 21 #include <linux/list.h> 22 #include <linux/mm.h> 23 #include <linux/slab.h> 24 #include <linux/suspend.h> 25 #include <trace/events/power.h> 26 27 #include "power.h" 28 29 const char *const pm_states[PM_SUSPEND_MAX] = { 30 [PM_SUSPEND_STANDBY] = "standby", 31 [PM_SUSPEND_MEM] = "mem", 32 }; 33 34 static const struct platform_suspend_ops *suspend_ops; 35 36 /** 37 * suspend_set_ops - Set the global suspend method table. 38 * @ops: Pointer to ops structure. 39 */ 40 void suspend_set_ops(const struct platform_suspend_ops *ops) 41 { 42 mutex_lock(&pm_mutex); 43 suspend_ops = ops; 44 mutex_unlock(&pm_mutex); 45 } 46 47 bool valid_state(suspend_state_t state) 48 { 49 /* 50 * All states need lowlevel support and need to be valid to the lowlevel 51 * implementation, no valid callback implies that none are valid. 52 */ 53 return suspend_ops && suspend_ops->valid && suspend_ops->valid(state); 54 } 55 56 /** 57 * suspend_valid_only_mem - generic memory-only valid callback 58 * 59 * Platform drivers that implement mem suspend only and only need 60 * to check for that in their .valid callback can use this instead 61 * of rolling their own .valid callback. 62 */ 63 int suspend_valid_only_mem(suspend_state_t state) 64 { 65 return state == PM_SUSPEND_MEM; 66 } 67 68 static int suspend_test(int level) 69 { 70 #ifdef CONFIG_PM_DEBUG 71 if (pm_test_level == level) { 72 printk(KERN_INFO "suspend debug: Waiting for 5 seconds.\n"); 73 mdelay(5000); 74 return 1; 75 } 76 #endif /* !CONFIG_PM_DEBUG */ 77 return 0; 78 } 79 80 /** 81 * suspend_prepare - Do prep work before entering low-power state. 82 * 83 * This is common code that is called for each state that we're entering. 84 * Run suspend notifiers, allocate a console and stop all processes. 85 */ 86 static int suspend_prepare(void) 87 { 88 int error; 89 90 if (!suspend_ops || !suspend_ops->enter) 91 return -EPERM; 92 93 pm_prepare_console(); 94 95 error = pm_notifier_call_chain(PM_SUSPEND_PREPARE); 96 if (error) 97 goto Finish; 98 99 error = usermodehelper_disable(); 100 if (error) 101 goto Finish; 102 103 error = suspend_freeze_processes(); 104 if (!error) 105 return 0; 106 107 suspend_thaw_processes(); 108 usermodehelper_enable(); 109 Finish: 110 pm_notifier_call_chain(PM_POST_SUSPEND); 111 pm_restore_console(); 112 return error; 113 } 114 115 /* default implementation */ 116 void __attribute__ ((weak)) arch_suspend_disable_irqs(void) 117 { 118 local_irq_disable(); 119 } 120 121 /* default implementation */ 122 void __attribute__ ((weak)) arch_suspend_enable_irqs(void) 123 { 124 local_irq_enable(); 125 } 126 127 /** 128 * suspend_enter - enter the desired system sleep state. 129 * @state: state to enter 130 * 131 * This function should be called after devices have been suspended. 132 */ 133 static int suspend_enter(suspend_state_t state) 134 { 135 int error; 136 137 if (suspend_ops->prepare) { 138 error = suspend_ops->prepare(); 139 if (error) 140 goto Platform_finish; 141 } 142 143 error = dpm_suspend_noirq(PMSG_SUSPEND); 144 if (error) { 145 printk(KERN_ERR "PM: Some devices failed to power down\n"); 146 goto Platform_finish; 147 } 148 149 if (suspend_ops->prepare_late) { 150 error = suspend_ops->prepare_late(); 151 if (error) 152 goto Platform_wake; 153 } 154 155 if (suspend_test(TEST_PLATFORM)) 156 goto Platform_wake; 157 158 error = disable_nonboot_cpus(); 159 if (error || suspend_test(TEST_CPUS)) 160 goto Enable_cpus; 161 162 arch_suspend_disable_irqs(); 163 BUG_ON(!irqs_disabled()); 164 165 error = sysdev_suspend(PMSG_SUSPEND); 166 if (!error) { 167 if (!(suspend_test(TEST_CORE) || pm_wakeup_pending())) { 168 error = suspend_ops->enter(state); 169 events_check_enabled = false; 170 } 171 sysdev_resume(); 172 } 173 174 arch_suspend_enable_irqs(); 175 BUG_ON(irqs_disabled()); 176 177 Enable_cpus: 178 enable_nonboot_cpus(); 179 180 Platform_wake: 181 if (suspend_ops->wake) 182 suspend_ops->wake(); 183 184 dpm_resume_noirq(PMSG_RESUME); 185 186 Platform_finish: 187 if (suspend_ops->finish) 188 suspend_ops->finish(); 189 190 return error; 191 } 192 193 /** 194 * suspend_devices_and_enter - suspend devices and enter the desired system 195 * sleep state. 196 * @state: state to enter 197 */ 198 int suspend_devices_and_enter(suspend_state_t state) 199 { 200 int error; 201 202 if (!suspend_ops) 203 return -ENOSYS; 204 205 trace_machine_suspend(state); 206 if (suspend_ops->begin) { 207 error = suspend_ops->begin(state); 208 if (error) 209 goto Close; 210 } 211 suspend_console(); 212 pm_restrict_gfp_mask(); 213 suspend_test_start(); 214 error = dpm_suspend_start(PMSG_SUSPEND); 215 if (error) { 216 printk(KERN_ERR "PM: Some devices failed to suspend\n"); 217 goto Recover_platform; 218 } 219 suspend_test_finish("suspend devices"); 220 if (suspend_test(TEST_DEVICES)) 221 goto Recover_platform; 222 223 suspend_enter(state); 224 225 Resume_devices: 226 suspend_test_start(); 227 dpm_resume_end(PMSG_RESUME); 228 suspend_test_finish("resume devices"); 229 pm_restore_gfp_mask(); 230 resume_console(); 231 Close: 232 if (suspend_ops->end) 233 suspend_ops->end(); 234 trace_machine_suspend(PWR_EVENT_EXIT); 235 return error; 236 237 Recover_platform: 238 if (suspend_ops->recover) 239 suspend_ops->recover(); 240 goto Resume_devices; 241 } 242 243 /** 244 * suspend_finish - Do final work before exiting suspend sequence. 245 * 246 * Call platform code to clean up, restart processes, and free the 247 * console that we've allocated. This is not called for suspend-to-disk. 248 */ 249 static void suspend_finish(void) 250 { 251 suspend_thaw_processes(); 252 usermodehelper_enable(); 253 pm_notifier_call_chain(PM_POST_SUSPEND); 254 pm_restore_console(); 255 } 256 257 /** 258 * enter_state - Do common work of entering low-power state. 259 * @state: pm_state structure for state we're entering. 260 * 261 * Make sure we're the only ones trying to enter a sleep state. Fail 262 * if someone has beat us to it, since we don't want anything weird to 263 * happen when we wake up. 264 * Then, do the setup for suspend, enter the state, and cleaup (after 265 * we've woken up). 266 */ 267 int enter_state(suspend_state_t state) 268 { 269 int error; 270 271 if (!valid_state(state)) 272 return -ENODEV; 273 274 if (!mutex_trylock(&pm_mutex)) 275 return -EBUSY; 276 277 printk(KERN_INFO "PM: Syncing filesystems ... "); 278 sys_sync(); 279 printk("done.\n"); 280 281 pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]); 282 error = suspend_prepare(); 283 if (error) 284 goto Unlock; 285 286 if (suspend_test(TEST_FREEZER)) 287 goto Finish; 288 289 pr_debug("PM: Entering %s sleep\n", pm_states[state]); 290 error = suspend_devices_and_enter(state); 291 292 Finish: 293 pr_debug("PM: Finishing wakeup.\n"); 294 suspend_finish(); 295 Unlock: 296 mutex_unlock(&pm_mutex); 297 return error; 298 } 299 300 /** 301 * pm_suspend - Externally visible function for suspending system. 302 * @state: Enumerated value of state to enter. 303 * 304 * Determine whether or not value is within range, get state 305 * structure, and enter (above). 306 */ 307 int pm_suspend(suspend_state_t state) 308 { 309 if (state > PM_SUSPEND_ON && state <= PM_SUSPEND_MAX) 310 return enter_state(state); 311 return -EINVAL; 312 } 313 EXPORT_SYMBOL(pm_suspend); 314