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 "power.h"
  13
  14 extern int sysdev_suspend(u32 state);
  15
  16 /*
  17  * The entries in the dpm_active list are in a depth first order, simply
  18  * because children are guaranteed to be discovered after parents, and
  19  * are inserted at the back of the list on discovery.
  20  *
  21  * All list on the suspend path are done in reverse order, so we operate
  22  * on the leaves of the device tree (or forests, depending on how you want
  23  * to look at it ;) first. As nodes are removed from the back of the list,
  24  * they are inserted into the front of their destintation lists.
  25  *
  26  * Things are the reverse on the resume path - iterations are done in
  27  * forward order, and nodes are inserted at the back of their destination
  28  * lists. This way, the ancestors will be accessed before their descendents.
  29  */
  30
  31
  32 /**
  33  *      suspend_device - Save state of one device.
  34  *      @dev:   Device.
  35  *      @state: Power state device is entering.
  36  */
  37
  38 int suspend_device(struct device * dev, u32 state)
  39 {
  40         int error = 0;
  41
  42         dev_dbg(dev, "suspending\n");
  43
  44         dev->power.prev_state = dev->power.power_state;
  45
  46         if (dev->bus && dev->bus->suspend && !dev->power.power_state)
  47                 error = dev->bus->suspend(dev,state);
  48
  49         return error;
  50 }
  51
  52
  53 /**
  54  *      device_suspend - Save state and stop all devices in system.
  55  *      @state:         Power state to put each device in.
  56  *
  57  *      Walk the dpm_active list, call ->suspend() for each device, and move
  58  *      it to dpm_off.
  59  *      Check the return value for each. If it returns 0, then we move the
  60  *      the device to the dpm_off list. If it returns -EAGAIN, we move it to
  61  *      the dpm_off_irq list. If we get a different error, try and back out.
  62  *
  63  *      If we hit a failure with any of the devices, call device_resume()
  64  *      above to bring the suspended devices back to life.
  65  *
  66  *      Note this function leaves dpm_sem held to
  67  *      a) block other devices from registering.
  68  *      b) prevent other PM operations from happening after we've begun.
  69  *      c) make sure we're exclusive when we disable interrupts.
  70  *
  71  */
  72
  73 int device_suspend(u32 state)
  74 {
  75         int error = 0;
  76
  77         down(&dpm_sem);
  78         while(!list_empty(&dpm_active)) {
  79                 struct list_head * entry = dpm_active.prev;
  80                 struct device * dev = to_device(entry);
  81                 error = suspend_device(dev,state);
  82
  83                 if (!error) {
  84                         list_del(&dev->power.entry);
  85                         list_add(&dev->power.entry,&dpm_off);
  86                 } else if (error == -EAGAIN) {
  87                         list_del(&dev->power.entry);
  88                         list_add(&dev->power.entry,&dpm_off_irq);
  89                 } else {
  90                         printk(KERN_ERR "Could not suspend device %s: "
  91                                 "error %d\n", kobject_name(&dev->kobj), error);
  92                         goto Error;
  93                 }
  94         }
  95  Done:
  96         up(&dpm_sem);
  97         return error;
  98  Error:
  99         dpm_resume();
 100         goto Done;
 101 }
 102
 103 EXPORT_SYMBOL(device_suspend);
 104
 105
 106 /**
 107  *      device_power_down - Shut down special devices.
 108  *      @state:         Power state to enter.
 109  *
 110  *      Walk the dpm_off_irq list, calling ->power_down() for each device that
 111  *      couldn't power down the device with interrupts enabled. When we're
 112  *      done, power down system devices.
 113  */
 114
 115 int device_power_down(u32 state)
 116 {
 117         int error = 0;
 118         struct device * dev;
 119
 120         list_for_each_entry_reverse(dev,&dpm_off_irq,power.entry) {
 121                 if ((error = suspend_device(dev,state)))
 122                         break;
 123         }
 124         if (error)
 125                 goto Error;
 126         if ((error = sysdev_suspend(state)))
 127                 goto Error;
 128  Done:
 129         return error;
 130  Error:
 131         dpm_power_up();
 132         goto Done;
 133 }
 134
 135 EXPORT_SYMBOL(device_power_down);
 136