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