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