err.no Git - linux-2.6/blob - drivers/base/power/suspend.c

   1 /*
   2  * suspend.c - Functions for putting devices to sleep.
   3  *
   4  * Copyright (c) 2003 Patrick Mochel
   5  * Copyright (c) 2003 Open Source Development Labs
   6  *
   7  * This file is released under the GPLv2
   8  *
   9  */
  10
  11 #include <linux/device.h>
  12 #include <linux/kallsyms.h>
  13 #include <linux/pm.h>
  14 #include "../base.h"
  15 #include "power.h"
  16
  17 /*
  18  * The entries in the dpm_active list are in a depth first order, simply
  19  * because children are guaranteed to be discovered after parents, and
  20  * are inserted at the back of the list on discovery.
  21  *
  22  * All list on the suspend path are done in reverse order, so we operate
  23  * on the leaves of the device tree (or forests, depending on how you want
  24  * to look at it ;) first. As nodes are removed from the back of the list,
  25  * they are inserted into the front of their destintation lists.
  26  *
  27  * Things are the reverse on the resume path - iterations are done in
  28  * forward order, and nodes are inserted at the back of their destination
  29  * lists. This way, the ancestors will be accessed before their descendents.
  30  */
  31
  32 static inline char *suspend_verb(u32 event)
  33 {
  34         switch (event) {
  35         case PM_EVENT_SUSPEND:  return "suspend";
  36         case PM_EVENT_FREEZE:   return "freeze";
  37         case PM_EVENT_PRETHAW:  return "prethaw";
  38         default:                return "(unknown suspend event)";
  39         }
  40 }
  41
  42
  43 /**
  44  *      suspend_device - Save state of one device.
  45  *      @dev:   Device.
  46  *      @state: Power state device is entering.
  47  */
  48
  49 int suspend_device(struct device * dev, pm_message_t state)
  50 {
  51         int error = 0;
  52
  53         down(&dev->sem);
  54         if (dev->power.power_state.event) {
  55                 dev_dbg(dev, "PM: suspend %d-->%d\n",
  56                         dev->power.power_state.event, state.event);
  57         }
  58         if (dev->power.pm_parent
  59                         && dev->power.pm_parent->power.power_state.event) {
  60                 dev_err(dev,
  61                         "PM: suspend %d->%d, parent %s already %d\n",
  62                         dev->power.power_state.event, state.event,
  63                         dev->power.pm_parent->bus_id,
  64                         dev->power.pm_parent->power.power_state.event);
  65         }
  66
  67         dev->power.prev_state = dev->power.power_state;
  68
  69         if (dev->class && dev->class->suspend && !dev->power.power_state.event) {
  70                 dev_dbg(dev, "class %s%s\n",
  71                         suspend_verb(state.event),
  72                         ((state.event == PM_EVENT_SUSPEND)
  73                                         && device_may_wakeup(dev))
  74                                 ? ", may wakeup"
  75                                 : ""
  76                         );
  77                 error = dev->class->suspend(dev, state);
  78                 suspend_report_result(dev->class->suspend, error);
  79         }
  80
  81         if (!error && dev->bus && dev->bus->suspend && !dev->power.power_state.event) {
  82                 dev_dbg(dev, "%s%s\n",
  83                         suspend_verb(state.event),
  84                         ((state.event == PM_EVENT_SUSPEND)
  85                                         && device_may_wakeup(dev))
  86                                 ? ", may wakeup"
  87                                 : ""
  88                         );
  89                 error = dev->bus->suspend(dev, state);
  90                 suspend_report_result(dev->bus->suspend, error);
  91         }
  92         up(&dev->sem);
  93         return error;
  94 }
  95
  96
  97 /*
  98  * This is called with interrupts off, only a single CPU
  99  * running. We can't do down() on a semaphore (and we don't
 100  * need the protection)
 101  */
 102 static int suspend_device_late(struct device *dev, pm_message_t state)
 103 {
 104         int error = 0;
 105
 106         if (dev->bus && dev->bus->suspend_late && !dev->power.power_state.event) {
 107                 dev_dbg(dev, "LATE %s%s\n",
 108                         suspend_verb(state.event),
 109                         ((state.event == PM_EVENT_SUSPEND)
 110                                         && device_may_wakeup(dev))
 111                                 ? ", may wakeup"
 112                                 : ""
 113                         );
 114                 error = dev->bus->suspend_late(dev, state);
 115                 suspend_report_result(dev->bus->suspend_late, error);
 116         }
 117         return error;
 118 }
 119
 120 /**
 121  *      device_prepare_suspend - save state and prepare to suspend
 122  *
 123  *      NOTE! Devices cannot detach at this point - not only do we
 124  *      hold the device list semaphores over the whole prepare, but
 125  *      the whole point is to do non-invasive preparatory work, not
 126  *      the actual suspend.
 127  */
 128 int device_prepare_suspend(pm_message_t state)
 129 {
 130         int error = 0;
 131         struct device * dev;
 132
 133         down(&dpm_sem);
 134         down(&dpm_list_sem);
 135         list_for_each_entry_reverse(dev, &dpm_active, power.entry) {
 136                 if (!dev->bus || !dev->bus->suspend_prepare)
 137                         continue;
 138                 error = dev->bus->suspend_prepare(dev, state);
 139                 if (error)
 140                         break;
 141         }
 142         up(&dpm_list_sem);
 143         up(&dpm_sem);
 144         return error;
 145 }
 146
 147 /**
 148  *      device_suspend - Save state and stop all devices in system.
 149  *      @state:         Power state to put each device in.
 150  *
 151  *      Walk the dpm_active list, call ->suspend() for each device, and move
 152  *      it to the dpm_off list.
 153  *
 154  *      (For historical reasons, if it returns -EAGAIN, that used to mean
 155  *      that the device would be called again with interrupts disabled.
 156  *      These days, we use the "suspend_late()" callback for that, so we
 157  *      print a warning and consider it an error).
 158  *
 159  *      If we get a different error, try and back out.
 160  *
 161  *      If we hit a failure with any of the devices, call device_resume()
 162  *      above to bring the suspended devices back to life.
 163  *
 164  */
 165
 166 int device_suspend(pm_message_t state)
 167 {
 168         int error = 0;
 169
 170         down(&dpm_sem);
 171         down(&dpm_list_sem);
 172         while (!list_empty(&dpm_active) && error == 0) {
 173                 struct list_head * entry = dpm_active.prev;
 174                 struct device * dev = to_device(entry);
 175
 176                 get_device(dev);
 177                 up(&dpm_list_sem);
 178
 179                 error = suspend_device(dev, state);
 180
 181                 down(&dpm_list_sem);
 182
 183                 /* Check if the device got removed */
 184                 if (!list_empty(&dev->power.entry)) {
 185                         /* Move it to the dpm_off list */
 186                         if (!error)
 187                                 list_move(&dev->power.entry, &dpm_off);
 188                 }
 189                 if (error)
 190                         printk(KERN_ERR "Could not suspend device %s: "
 191                                 "error %d%s\n",
 192                                 kobject_name(&dev->kobj), error,
 193                                 error == -EAGAIN ? " (please convert to suspend_late)" : "");
 194                 put_device(dev);
 195         }
 196         up(&dpm_list_sem);
 197         if (error)
 198                 dpm_resume();
 199
 200         up(&dpm_sem);
 201         return error;
 202 }
 203
 204 EXPORT_SYMBOL_GPL(device_suspend);
 205
 206 /**
 207  *      device_power_down - Shut down special devices.
 208  *      @state:         Power state to enter.
 209  *
 210  *      Walk the dpm_off_irq list, calling ->power_down() for each device that
 211  *      couldn't power down the device with interrupts enabled. When we're
 212  *      done, power down system devices.
 213  */
 214
 215 int device_power_down(pm_message_t state)
 216 {
 217         int error = 0;
 218         struct device * dev;
 219
 220         while (!list_empty(&dpm_off)) {
 221                 struct list_head * entry = dpm_off.prev;
 222
 223                 dev = to_device(entry);
 224                 error = suspend_device_late(dev, state);
 225                 if (error)
 226                         goto Error;
 227                 list_move(&dev->power.entry, &dpm_off_irq);
 228         }
 229
 230         error = sysdev_suspend(state);
 231  Done:
 232         return error;
 233  Error:
 234         printk(KERN_ERR "Could not power down device %s: "
 235                 "error %d\n", kobject_name(&dev->kobj), error);
 236         dpm_power_up();
 237         goto Done;
 238 }
 239
 240 EXPORT_SYMBOL_GPL(device_power_down);
 241
 242 void __suspend_report_result(const char *function, void *fn, int ret)
 243 {
 244         if (ret) {
 245                 printk(KERN_ERR "%s(): ", function);
 246                 print_fn_descriptor_symbol("%s() returns ", (unsigned long)fn);
 247                 printk("%d\n", ret);
 248         }
 249 }
 250 EXPORT_SYMBOL_GPL(__suspend_report_result);