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         default:                return "(unknown suspend event)";
  38         }
  39 }
  40
  41
  42 /**
  43  *      suspend_device - Save state of one device.
  44  *      @dev:   Device.
  45  *      @state: Power state device is entering.
  46  */
  47
  48 int suspend_device(struct device * dev, pm_message_t state)
  49 {
  50         int error = 0;
  51
  52         down(&dev->sem);
  53         if (dev->power.power_state.event) {
  54                 dev_dbg(dev, "PM: suspend %d-->%d\n",
  55                         dev->power.power_state.event, state.event);
  56         }
  57         if (dev->power.pm_parent
  58                         && dev->power.pm_parent->power.power_state.event) {
  59                 dev_err(dev,
  60                         "PM: suspend %d->%d, parent %s already %d\n",
  61                         dev->power.power_state.event, state.event,
  62                         dev->power.pm_parent->bus_id,
  63                         dev->power.pm_parent->power.power_state.event);
  64         }
  65
  66         dev->power.prev_state = dev->power.power_state;
  67
  68         if (dev->bus && dev->bus->suspend && !dev->power.power_state.event) {
  69                 dev_dbg(dev, "%s%s\n",
  70                         suspend_verb(state.event),
  71                         ((state.event == PM_EVENT_SUSPEND)
  72                                         && device_may_wakeup(dev))
  73                                 ? ", may wakeup"
  74                                 : ""
  75                         );
  76                 error = dev->bus->suspend(dev, state);
  77                 suspend_report_result(dev->bus->suspend, error);
  78         }
  79         up(&dev->sem);
  80         return error;
  81 }
  82
  83
  84 /**
  85  *      device_suspend - Save state and stop all devices in system.
  86  *      @state:         Power state to put each device in.
  87  *
  88  *      Walk the dpm_active list, call ->suspend() for each device, and move
  89  *      it to dpm_off.
  90  *      Check the return value for each. If it returns 0, then we move the
  91  *      the device to the dpm_off list. If it returns -EAGAIN, we move it to
  92  *      the dpm_off_irq list. If we get a different error, try and back out.
  93  *
  94  *      If we hit a failure with any of the devices, call device_resume()
  95  *      above to bring the suspended devices back to life.
  96  *
  97  */
  98
  99 int device_suspend(pm_message_t state)
 100 {
 101         int error = 0;
 102
 103         down(&dpm_sem);
 104         down(&dpm_list_sem);
 105         while (!list_empty(&dpm_active) && error == 0) {
 106                 struct list_head * entry = dpm_active.prev;
 107                 struct device * dev = to_device(entry);
 108
 109                 get_device(dev);
 110                 up(&dpm_list_sem);
 111
 112                 error = suspend_device(dev, state);
 113
 114                 down(&dpm_list_sem);
 115
 116                 /* Check if the device got removed */
 117                 if (!list_empty(&dev->power.entry)) {
 118                         /* Move it to the dpm_off or dpm_off_irq list */
 119                         if (!error) {
 120                                 list_del(&dev->power.entry);
 121                                 list_add(&dev->power.entry, &dpm_off);
 122                         } else if (error == -EAGAIN) {
 123                                 list_del(&dev->power.entry);
 124                                 list_add(&dev->power.entry, &dpm_off_irq);
 125                                 error = 0;
 126                         }
 127                 }
 128                 if (error)
 129                         printk(KERN_ERR "Could not suspend device %s: "
 130                                 "error %d\n", kobject_name(&dev->kobj), error);
 131                 put_device(dev);
 132         }
 133         up(&dpm_list_sem);
 134         if (error) {
 135                 /* we failed... before resuming, bring back devices from
 136                  * dpm_off_irq list back to main dpm_off list, we do want
 137                  * to call resume() on them, in case they partially suspended
 138                  * despite returning -EAGAIN
 139                  */
 140                 while (!list_empty(&dpm_off_irq)) {
 141                         struct list_head * entry = dpm_off_irq.next;
 142                         list_del(entry);
 143                         list_add(entry, &dpm_off);
 144                 }
 145                 dpm_resume();
 146         }
 147         up(&dpm_sem);
 148         return error;
 149 }
 150
 151 EXPORT_SYMBOL_GPL(device_suspend);
 152
 153
 154 /**
 155  *      device_power_down - Shut down special devices.
 156  *      @state:         Power state to enter.
 157  *
 158  *      Walk the dpm_off_irq list, calling ->power_down() for each device that
 159  *      couldn't power down the device with interrupts enabled. When we're
 160  *      done, power down system devices.
 161  */
 162
 163 int device_power_down(pm_message_t state)
 164 {
 165         int error = 0;
 166         struct device * dev;
 167
 168         list_for_each_entry_reverse(dev, &dpm_off_irq, power.entry) {
 169                 if ((error = suspend_device(dev, state)))
 170                         break;
 171         }
 172         if (error)
 173                 goto Error;
 174         if ((error = sysdev_suspend(state)))
 175                 goto Error;
 176  Done:
 177         return error;
 178  Error:
 179         printk(KERN_ERR "Could not power down device %s: "
 180                 "error %d\n", kobject_name(&dev->kobj), error);
 181         dpm_power_up();
 182         goto Done;
 183 }
 184
 185 EXPORT_SYMBOL_GPL(device_power_down);
 186
 187 void __suspend_report_result(const char *function, void *fn, int ret)
 188 {
 189         if (ret) {
 190                 printk(KERN_ERR "%s(): ", function);
 191                 print_fn_descriptor_symbol("%s() returns ", (unsigned long)fn);
 192                 printk("%d\n", ret);
 193         }
 194 }
 195 EXPORT_SYMBOL_GPL(__suspend_report_result);