1 /* 2 * drivers/base/power/generic_ops.c - Generic PM callbacks for subsystems 3 * 4 * Copyright (c) 2010 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc. 5 * 6 * This file is released under the GPLv2. 7 */ 8 9 #include <linux/pm.h> 10 #include <linux/pm_runtime.h> 11 #include <linux/export.h> 12 13 #ifdef CONFIG_PM_RUNTIME 14 /** 15 * pm_generic_runtime_idle - Generic runtime idle callback for subsystems. 16 * @dev: Device to handle. 17 * 18 * If PM operations are defined for the @dev's driver and they include 19 * ->runtime_idle(), execute it and return its error code, if nonzero. 20 * Otherwise, execute pm_runtime_suspend() for the device and return 0. 21 */ 22 int pm_generic_runtime_idle(struct device *dev) 23 { 24 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 25 26 if (pm && pm->runtime_idle) { 27 int ret = pm->runtime_idle(dev); 28 if (ret) 29 return ret; 30 } 31 32 pm_runtime_suspend(dev); 33 return 0; 34 } 35 EXPORT_SYMBOL_GPL(pm_generic_runtime_idle); 36 37 /** 38 * pm_generic_runtime_suspend - Generic runtime suspend callback for subsystems. 39 * @dev: Device to suspend. 40 * 41 * If PM operations are defined for the @dev's driver and they include 42 * ->runtime_suspend(), execute it and return its error code. Otherwise, 43 * return 0. 44 */ 45 int pm_generic_runtime_suspend(struct device *dev) 46 { 47 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 48 int ret; 49 50 ret = pm && pm->runtime_suspend ? pm->runtime_suspend(dev) : 0; 51 52 return ret; 53 } 54 EXPORT_SYMBOL_GPL(pm_generic_runtime_suspend); 55 56 /** 57 * pm_generic_runtime_resume - Generic runtime resume callback for subsystems. 58 * @dev: Device to resume. 59 * 60 * If PM operations are defined for the @dev's driver and they include 61 * ->runtime_resume(), execute it and return its error code. Otherwise, 62 * return 0. 63 */ 64 int pm_generic_runtime_resume(struct device *dev) 65 { 66 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 67 int ret; 68 69 ret = pm && pm->runtime_resume ? pm->runtime_resume(dev) : 0; 70 71 return ret; 72 } 73 EXPORT_SYMBOL_GPL(pm_generic_runtime_resume); 74 #endif /* CONFIG_PM_RUNTIME */ 75 76 #ifdef CONFIG_PM_SLEEP 77 /** 78 * pm_generic_prepare - Generic routine preparing a device for power transition. 79 * @dev: Device to prepare. 80 * 81 * Prepare a device for a system-wide power transition. 82 */ 83 int pm_generic_prepare(struct device *dev) 84 { 85 struct device_driver *drv = dev->driver; 86 int ret = 0; 87 88 if (drv && drv->pm && drv->pm->prepare) 89 ret = drv->pm->prepare(dev); 90 91 return ret; 92 } 93 94 /** 95 * __pm_generic_call - Generic suspend/freeze/poweroff/thaw subsystem callback. 96 * @dev: Device to handle. 97 * @event: PM transition of the system under way. 98 * @bool: Whether or not this is the "noirq" stage. 99 * 100 * If the device has not been suspended at run time, execute the 101 * suspend/freeze/poweroff/thaw callback provided by its driver, if defined, and 102 * return its error code. Otherwise, return zero. 103 */ 104 static int __pm_generic_call(struct device *dev, int event, bool noirq) 105 { 106 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 107 int (*callback)(struct device *); 108 109 if (!pm || pm_runtime_suspended(dev)) 110 return 0; 111 112 switch (event) { 113 case PM_EVENT_SUSPEND: 114 callback = noirq ? pm->suspend_noirq : pm->suspend; 115 break; 116 case PM_EVENT_FREEZE: 117 callback = noirq ? pm->freeze_noirq : pm->freeze; 118 break; 119 case PM_EVENT_HIBERNATE: 120 callback = noirq ? pm->poweroff_noirq : pm->poweroff; 121 break; 122 case PM_EVENT_THAW: 123 callback = noirq ? pm->thaw_noirq : pm->thaw; 124 break; 125 default: 126 callback = NULL; 127 break; 128 } 129 130 return callback ? callback(dev) : 0; 131 } 132 133 /** 134 * pm_generic_suspend_noirq - Generic suspend_noirq callback for subsystems. 135 * @dev: Device to suspend. 136 */ 137 int pm_generic_suspend_noirq(struct device *dev) 138 { 139 return __pm_generic_call(dev, PM_EVENT_SUSPEND, true); 140 } 141 EXPORT_SYMBOL_GPL(pm_generic_suspend_noirq); 142 143 /** 144 * pm_generic_suspend - Generic suspend callback for subsystems. 145 * @dev: Device to suspend. 146 */ 147 int pm_generic_suspend(struct device *dev) 148 { 149 return __pm_generic_call(dev, PM_EVENT_SUSPEND, false); 150 } 151 EXPORT_SYMBOL_GPL(pm_generic_suspend); 152 153 /** 154 * pm_generic_freeze_noirq - Generic freeze_noirq callback for subsystems. 155 * @dev: Device to freeze. 156 */ 157 int pm_generic_freeze_noirq(struct device *dev) 158 { 159 return __pm_generic_call(dev, PM_EVENT_FREEZE, true); 160 } 161 EXPORT_SYMBOL_GPL(pm_generic_freeze_noirq); 162 163 /** 164 * pm_generic_freeze - Generic freeze callback for subsystems. 165 * @dev: Device to freeze. 166 */ 167 int pm_generic_freeze(struct device *dev) 168 { 169 return __pm_generic_call(dev, PM_EVENT_FREEZE, false); 170 } 171 EXPORT_SYMBOL_GPL(pm_generic_freeze); 172 173 /** 174 * pm_generic_poweroff_noirq - Generic poweroff_noirq callback for subsystems. 175 * @dev: Device to handle. 176 */ 177 int pm_generic_poweroff_noirq(struct device *dev) 178 { 179 return __pm_generic_call(dev, PM_EVENT_HIBERNATE, true); 180 } 181 EXPORT_SYMBOL_GPL(pm_generic_poweroff_noirq); 182 183 /** 184 * pm_generic_poweroff - Generic poweroff callback for subsystems. 185 * @dev: Device to handle. 186 */ 187 int pm_generic_poweroff(struct device *dev) 188 { 189 return __pm_generic_call(dev, PM_EVENT_HIBERNATE, false); 190 } 191 EXPORT_SYMBOL_GPL(pm_generic_poweroff); 192 193 /** 194 * pm_generic_thaw_noirq - Generic thaw_noirq callback for subsystems. 195 * @dev: Device to thaw. 196 */ 197 int pm_generic_thaw_noirq(struct device *dev) 198 { 199 return __pm_generic_call(dev, PM_EVENT_THAW, true); 200 } 201 EXPORT_SYMBOL_GPL(pm_generic_thaw_noirq); 202 203 /** 204 * pm_generic_thaw - Generic thaw callback for subsystems. 205 * @dev: Device to thaw. 206 */ 207 int pm_generic_thaw(struct device *dev) 208 { 209 return __pm_generic_call(dev, PM_EVENT_THAW, false); 210 } 211 EXPORT_SYMBOL_GPL(pm_generic_thaw); 212 213 /** 214 * __pm_generic_resume - Generic resume/restore callback for subsystems. 215 * @dev: Device to handle. 216 * @event: PM transition of the system under way. 217 * @bool: Whether or not this is the "noirq" stage. 218 * 219 * Execute the resume/resotre callback provided by the @dev's driver, if 220 * defined. If it returns 0, change the device's runtime PM status to 'active'. 221 * Return the callback's error code. 222 */ 223 static int __pm_generic_resume(struct device *dev, int event, bool noirq) 224 { 225 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 226 int (*callback)(struct device *); 227 int ret; 228 229 if (!pm) 230 return 0; 231 232 switch (event) { 233 case PM_EVENT_RESUME: 234 callback = noirq ? pm->resume_noirq : pm->resume; 235 break; 236 case PM_EVENT_RESTORE: 237 callback = noirq ? pm->restore_noirq : pm->restore; 238 break; 239 default: 240 callback = NULL; 241 break; 242 } 243 244 if (!callback) 245 return 0; 246 247 ret = callback(dev); 248 if (!ret && !noirq && pm_runtime_enabled(dev)) { 249 pm_runtime_disable(dev); 250 pm_runtime_set_active(dev); 251 pm_runtime_enable(dev); 252 } 253 254 return ret; 255 } 256 257 /** 258 * pm_generic_resume_noirq - Generic resume_noirq callback for subsystems. 259 * @dev: Device to resume. 260 */ 261 int pm_generic_resume_noirq(struct device *dev) 262 { 263 return __pm_generic_resume(dev, PM_EVENT_RESUME, true); 264 } 265 EXPORT_SYMBOL_GPL(pm_generic_resume_noirq); 266 267 /** 268 * pm_generic_resume - Generic resume callback for subsystems. 269 * @dev: Device to resume. 270 */ 271 int pm_generic_resume(struct device *dev) 272 { 273 return __pm_generic_resume(dev, PM_EVENT_RESUME, false); 274 } 275 EXPORT_SYMBOL_GPL(pm_generic_resume); 276 277 /** 278 * pm_generic_restore_noirq - Generic restore_noirq callback for subsystems. 279 * @dev: Device to restore. 280 */ 281 int pm_generic_restore_noirq(struct device *dev) 282 { 283 return __pm_generic_resume(dev, PM_EVENT_RESTORE, true); 284 } 285 EXPORT_SYMBOL_GPL(pm_generic_restore_noirq); 286 287 /** 288 * pm_generic_restore - Generic restore callback for subsystems. 289 * @dev: Device to restore. 290 */ 291 int pm_generic_restore(struct device *dev) 292 { 293 return __pm_generic_resume(dev, PM_EVENT_RESTORE, false); 294 } 295 EXPORT_SYMBOL_GPL(pm_generic_restore); 296 297 /** 298 * pm_generic_complete - Generic routine competing a device power transition. 299 * @dev: Device to handle. 300 * 301 * Complete a device power transition during a system-wide power transition. 302 */ 303 void pm_generic_complete(struct device *dev) 304 { 305 struct device_driver *drv = dev->driver; 306 307 if (drv && drv->pm && drv->pm->complete) 308 drv->pm->complete(dev); 309 310 /* 311 * Let runtime PM try to suspend devices that haven't been in use before 312 * going into the system-wide sleep state we're resuming from. 313 */ 314 pm_runtime_idle(dev); 315 } 316 #endif /* CONFIG_PM_SLEEP */ 317 318 struct dev_pm_ops generic_subsys_pm_ops = { 319 #ifdef CONFIG_PM_SLEEP 320 .prepare = pm_generic_prepare, 321 .suspend = pm_generic_suspend, 322 .suspend_noirq = pm_generic_suspend_noirq, 323 .resume = pm_generic_resume, 324 .resume_noirq = pm_generic_resume_noirq, 325 .freeze = pm_generic_freeze, 326 .freeze_noirq = pm_generic_freeze_noirq, 327 .thaw = pm_generic_thaw, 328 .thaw_noirq = pm_generic_thaw_noirq, 329 .poweroff = pm_generic_poweroff, 330 .poweroff_noirq = pm_generic_poweroff_noirq, 331 .restore = pm_generic_restore, 332 .restore_noirq = pm_generic_restore_noirq, 333 .complete = pm_generic_complete, 334 #endif 335 #ifdef CONFIG_PM_RUNTIME 336 .runtime_suspend = pm_generic_runtime_suspend, 337 .runtime_resume = pm_generic_runtime_resume, 338 .runtime_idle = pm_generic_runtime_idle, 339 #endif 340 }; 341 EXPORT_SYMBOL_GPL(generic_subsys_pm_ops); 342