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/vt_kern.h>
  12 #include <linux/device.h>
  13 #include <linux/kallsyms.h>
  14 #include <linux/pm.h>
  15 #include "../base.h"
  16 #include "power.h"
  17
  18 /*
  19  * The entries in the dpm_active list are in a depth first order, simply
  20  * because children are guaranteed to be discovered after parents, and
  21  * are inserted at the back of the list on discovery.
  22  *
  23  * All list on the suspend path are done in reverse order, so we operate
  24  * on the leaves of the device tree (or forests, depending on how you want
  25  * to look at it ;) first. As nodes are removed from the back of the list,
  26  * they are inserted into the front of their destintation lists.
  27  *
  28  * Things are the reverse on the resume path - iterations are done in
  29  * forward order, and nodes are inserted at the back of their destination
  30  * lists. This way, the ancestors will be accessed before their descendents.
  31  */
  32
  33
  34 /**
  35  *      suspend_device - Save state of one device.
  36  *      @dev:   Device.
  37  *      @state: Power state device is entering.
  38  */
  39
  40 int suspend_device(struct device * dev, pm_message_t state)
  41 {
  42         int error = 0;
  43
  44         down(&dev->sem);
  45         if (dev->power.power_state.event) {
  46                 dev_dbg(dev, "PM: suspend %d-->%d\n",
  47                         dev->power.power_state.event, state.event);
  48         }
  49         if (dev->power.pm_parent
  50                         && dev->power.pm_parent->power.power_state.event) {
  51                 dev_err(dev,
  52                         "PM: suspend %d->%d, parent %s already %d\n",
  53                         dev->power.power_state.event, state.event,
  54                         dev->power.pm_parent->bus_id,
  55                         dev->power.pm_parent->power.power_state.event);
  56         }
  57
  58         dev->power.prev_state = dev->power.power_state;
  59
  60         if (dev->bus && dev->bus->suspend && !dev->power.power_state.event) {
  61                 dev_dbg(dev, "suspending\n");
  62                 error = dev->bus->suspend(dev, state);
  63                 suspend_report_result(dev->bus->suspend, error);
  64         }
  65         up(&dev->sem);
  66         return error;
  67 }
  68
  69 /**
  70  *      device_suspend - Save state and stop all devices in system.
  71  *      @state:         Power state to put each device in.
  72  *
  73  *      Walk the dpm_active list, call ->suspend() for each device, and move
  74  *      it to dpm_off.
  75  *      Check the return value for each. If it returns 0, then we move the
  76  *      the device to the dpm_off list. If it returns -EAGAIN, we move it to
  77  *      the dpm_off_irq list. If we get a different error, try and back out.
  78  *
  79  *      If we hit a failure with any of the devices, call device_resume()
  80  *      above to bring the suspended devices back to life.
  81  *
  82  */
  83
  84 int device_suspend(pm_message_t state)
  85 {
  86         int error = 0;
  87
  88         if (!is_console_suspend_safe())
  89                 return -EINVAL;
  90
  91         down(&dpm_sem);
  92         down(&dpm_list_sem);
  93         while (!list_empty(&dpm_active) && error == 0) {
  94                 struct list_head * entry = dpm_active.prev;
  95                 struct device * dev = to_device(entry);
  96
  97                 get_device(dev);
  98                 up(&dpm_list_sem);
  99
 100                 error = suspend_device(dev, state);
 101
 102                 down(&dpm_list_sem);
 103
 104                 /* Check if the device got removed */
 105                 if (!list_empty(&dev->power.entry)) {
 106                         /* Move it to the dpm_off or dpm_off_irq list */
 107                         if (!error) {
 108                                 list_del(&dev->power.entry);
 109                                 list_add(&dev->power.entry, &dpm_off);
 110                         } else if (error == -EAGAIN) {
 111                                 list_del(&dev->power.entry);
 112                                 list_add(&dev->power.entry, &dpm_off_irq);
 113                                 error = 0;
 114                         }
 115                 }
 116                 if (error)
 117                         printk(KERN_ERR "Could not suspend device %s: "
 118                                 "error %d\n", kobject_name(&dev->kobj), error);
 119                 put_device(dev);
 120         }
 121         up(&dpm_list_sem);
 122         if (error) {
 123                 /* we failed... before resuming, bring back devices from
 124                  * dpm_off_irq list back to main dpm_off list, we do want
 125                  * to call resume() on them, in case they partially suspended
 126                  * despite returning -EAGAIN
 127                  */
 128                 while (!list_empty(&dpm_off_irq)) {
 129                         struct list_head * entry = dpm_off_irq.next;
 130                         list_del(entry);
 131                         list_add(entry, &dpm_off);
 132                 }
 133                 dpm_resume();
 134         }
 135         up(&dpm_sem);
 136         return error;
 137 }
 138
 139 EXPORT_SYMBOL_GPL(device_suspend);
 140
 141
 142 /**
 143  *      device_power_down - Shut down special devices.
 144  *      @state:         Power state to enter.
 145  *
 146  *      Walk the dpm_off_irq list, calling ->power_down() for each device that
 147  *      couldn't power down the device with interrupts enabled. When we're
 148  *      done, power down system devices.
 149  */
 150
 151 int device_power_down(pm_message_t state)
 152 {
 153         int error = 0;
 154         struct device * dev;
 155
 156         list_for_each_entry_reverse(dev, &dpm_off_irq, power.entry) {
 157                 if ((error = suspend_device(dev, state)))
 158                         break;
 159         }
 160         if (error)
 161                 goto Error;
 162         if ((error = sysdev_suspend(state)))
 163                 goto Error;
 164  Done:
 165         return error;
 166  Error:
 167         printk(KERN_ERR "Could not power down device %s: "
 168                 "error %d\n", kobject_name(&dev->kobj), error);
 169         dpm_power_up();
 170         goto Done;
 171 }
 172
 173 EXPORT_SYMBOL_GPL(device_power_down);
 174
 175 void __suspend_report_result(const char *function, void *fn, int ret)
 176 {
 177         if (ret) {
 178                 printk(KERN_ERR "%s(): ", function);
 179                 print_fn_descriptor_symbol("%s() returns ", (unsigned long)fn);
 180                 printk("%d\n", ret);
 181         }
 182 }
 183 EXPORT_SYMBOL_GPL(__suspend_report_result);