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 32static 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 49int 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->type && dev->type->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->type->suspend(dev, state); 90 suspend_report_result(dev->type->suspend, error); 91 } 92 93 if (!error && dev->bus && dev->bus->suspend && !dev->power.power_state.event) { 94 dev_dbg(dev, "%s%s\n", 95 suspend_verb(state.event), 96 ((state.event == PM_EVENT_SUSPEND) 97 && device_may_wakeup(dev)) 98 ? ", may wakeup" 99 : "" 100 ); 101 error = dev->bus->suspend(dev, state); 102 suspend_report_result(dev->bus->suspend, error); 103 } 104 up(&dev->sem); 105 return error; 106} 107 108 109/* 110 * This is called with interrupts off, only a single CPU 111 * running. We can't do down() on a semaphore (and we don't 112 * need the protection) 113 */ 114static int suspend_device_late(struct device *dev, pm_message_t state) 115{ 116 int error = 0; 117 118 if (dev->bus && dev->bus->suspend_late && !dev->power.power_state.event) { 119 dev_dbg(dev, "LATE %s%s\n", 120 suspend_verb(state.event), 121 ((state.event == PM_EVENT_SUSPEND) 122 && device_may_wakeup(dev)) 123 ? ", may wakeup" 124 : "" 125 ); 126 error = dev->bus->suspend_late(dev, state); 127 suspend_report_result(dev->bus->suspend_late, error); 128 } 129 return error; 130} 131 132/** 133 * device_suspend - Save state and stop all devices in system. 134 * @state: Power state to put each device in. 135 * 136 * Walk the dpm_active list, call ->suspend() for each device, and move 137 * it to the dpm_off list. 138 * 139 * (For historical reasons, if it returns -EAGAIN, that used to mean 140 * that the device would be called again with interrupts disabled. 141 * These days, we use the "suspend_late()" callback for that, so we 142 * print a warning and consider it an error). 143 * 144 * If we get a different error, try and back out. 145 * 146 * If we hit a failure with any of the devices, call device_resume() 147 * above to bring the suspended devices back to life. 148 * 149 */ 150 151int device_suspend(pm_message_t state) 152{ 153 int error = 0; 154 155 might_sleep(); 156 down(&dpm_sem); 157 down(&dpm_list_sem); 158 while (!list_empty(&dpm_active) && error == 0) { 159 struct list_head * entry = dpm_active.prev; 160 struct device * dev = to_device(entry); 161 162 get_device(dev); 163 up(&dpm_list_sem); 164 165 error = suspend_device(dev, state); 166 167 down(&dpm_list_sem); 168 169 /* Check if the device got removed */ 170 if (!list_empty(&dev->power.entry)) { 171 /* Move it to the dpm_off list */ 172 if (!error) 173 list_move(&dev->power.entry, &dpm_off); 174 } 175 if (error) 176 printk(KERN_ERR "Could not suspend device %s: " 177 "error %d%s\n", 178 kobject_name(&dev->kobj), error, 179 error == -EAGAIN ? " (please convert to suspend_late)" : ""); 180 put_device(dev); 181 } 182 up(&dpm_list_sem); 183 if (error) 184 dpm_resume(); 185 186 up(&dpm_sem); 187 return error; 188} 189 190EXPORT_SYMBOL_GPL(device_suspend); 191 192/** 193 * device_power_down - Shut down special devices. 194 * @state: Power state to enter. 195 * 196 * Walk the dpm_off_irq list, calling ->power_down() for each device that 197 * couldn't power down the device with interrupts enabled. When we're 198 * done, power down system devices. 199 */ 200 201int device_power_down(pm_message_t state) 202{ 203 int error = 0; 204 struct device * dev; 205 206 while (!list_empty(&dpm_off)) { 207 struct list_head * entry = dpm_off.prev; 208 209 dev = to_device(entry); 210 error = suspend_device_late(dev, state); 211 if (error) 212 goto Error; 213 list_move(&dev->power.entry, &dpm_off_irq); 214 } 215 216 error = sysdev_suspend(state); 217 Done: 218 return error; 219 Error: 220 printk(KERN_ERR "Could not power down device %s: " 221 "error %d\n", kobject_name(&dev->kobj), error); 222 dpm_power_up(); 223 goto Done; 224} 225 226EXPORT_SYMBOL_GPL(device_power_down); 227 228void __suspend_report_result(const char *function, void *fn, int ret) 229{ 230 if (ret) { 231 printk(KERN_ERR "%s(): ", function); 232 print_fn_descriptor_symbol("%s() returns ", (unsigned long)fn); 233 printk("%d\n", ret); 234 } 235} 236EXPORT_SYMBOL_GPL(__suspend_report_result); 237