drivers/base/power/generic_ops.c

   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  * Execute the PM callback corresponding to @event provided by the driver of
 101  * @dev, if defined, and return its error code.    Return 0 if the callback is
 102  * not present.
 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)
 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_RESUME:
 123                 callback = noirq ? pm->resume_noirq : pm->resume;
 124                 break;
 125         case PM_EVENT_THAW:
 126                 callback = noirq ? pm->thaw_noirq : pm->thaw;
 127                 break;
 128         case PM_EVENT_RESTORE:
 129                 callback = noirq ? pm->restore_noirq : pm->restore;
 130                 break;
 131         default:
 132                 callback = NULL;
 133                 break;
 134         }
 135
 136         return callback ? callback(dev) : 0;
 137 }
 138
 139 /**
 140  * pm_generic_suspend_noirq - Generic suspend_noirq callback for subsystems.
 141  * @dev: Device to suspend.
 142  */
 143 int pm_generic_suspend_noirq(struct device *dev)
 144 {
 145         return __pm_generic_call(dev, PM_EVENT_SUSPEND, true);
 146 }
 147 EXPORT_SYMBOL_GPL(pm_generic_suspend_noirq);
 148
 149 /**
 150  * pm_generic_suspend - Generic suspend callback for subsystems.
 151  * @dev: Device to suspend.
 152  */
 153 int pm_generic_suspend(struct device *dev)
 154 {
 155         return __pm_generic_call(dev, PM_EVENT_SUSPEND, false);
 156 }
 157 EXPORT_SYMBOL_GPL(pm_generic_suspend);
 158
 159 /**
 160  * pm_generic_freeze_noirq - Generic freeze_noirq callback for subsystems.
 161  * @dev: Device to freeze.
 162  */
 163 int pm_generic_freeze_noirq(struct device *dev)
 164 {
 165         return __pm_generic_call(dev, PM_EVENT_FREEZE, true);
 166 }
 167 EXPORT_SYMBOL_GPL(pm_generic_freeze_noirq);
 168
 169 /**
 170  * pm_generic_freeze - Generic freeze callback for subsystems.
 171  * @dev: Device to freeze.
 172  */
 173 int pm_generic_freeze(struct device *dev)
 174 {
 175         return __pm_generic_call(dev, PM_EVENT_FREEZE, false);
 176 }
 177 EXPORT_SYMBOL_GPL(pm_generic_freeze);
 178
 179 /**
 180  * pm_generic_poweroff_noirq - Generic poweroff_noirq callback for subsystems.
 181  * @dev: Device to handle.
 182  */
 183 int pm_generic_poweroff_noirq(struct device *dev)
 184 {
 185         return __pm_generic_call(dev, PM_EVENT_HIBERNATE, true);
 186 }
 187 EXPORT_SYMBOL_GPL(pm_generic_poweroff_noirq);
 188
 189 /**
 190  * pm_generic_poweroff - Generic poweroff callback for subsystems.
 191  * @dev: Device to handle.
 192  */
 193 int pm_generic_poweroff(struct device *dev)
 194 {
 195         return __pm_generic_call(dev, PM_EVENT_HIBERNATE, false);
 196 }
 197 EXPORT_SYMBOL_GPL(pm_generic_poweroff);
 198
 199 /**
 200  * pm_generic_thaw_noirq - Generic thaw_noirq callback for subsystems.
 201  * @dev: Device to thaw.
 202  */
 203 int pm_generic_thaw_noirq(struct device *dev)
 204 {
 205         return __pm_generic_call(dev, PM_EVENT_THAW, true);
 206 }
 207 EXPORT_SYMBOL_GPL(pm_generic_thaw_noirq);
 208
 209 /**
 210  * pm_generic_thaw - Generic thaw callback for subsystems.
 211  * @dev: Device to thaw.
 212  */
 213 int pm_generic_thaw(struct device *dev)
 214 {
 215         return __pm_generic_call(dev, PM_EVENT_THAW, false);
 216 }
 217 EXPORT_SYMBOL_GPL(pm_generic_thaw);
 218
 219 /**
 220  * pm_generic_resume_noirq - Generic resume_noirq callback for subsystems.
 221  * @dev: Device to resume.
 222  */
 223 int pm_generic_resume_noirq(struct device *dev)
 224 {
 225         return __pm_generic_call(dev, PM_EVENT_RESUME, true);
 226 }
 227 EXPORT_SYMBOL_GPL(pm_generic_resume_noirq);
 228
 229 /**
 230  * pm_generic_resume - Generic resume callback for subsystems.
 231  * @dev: Device to resume.
 232  */
 233 int pm_generic_resume(struct device *dev)
 234 {
 235         return __pm_generic_call(dev, PM_EVENT_RESUME, false);
 236 }
 237 EXPORT_SYMBOL_GPL(pm_generic_resume);
 238
 239 /**
 240  * pm_generic_restore_noirq - Generic restore_noirq callback for subsystems.
 241  * @dev: Device to restore.
 242  */
 243 int pm_generic_restore_noirq(struct device *dev)
 244 {
 245         return __pm_generic_call(dev, PM_EVENT_RESTORE, true);
 246 }
 247 EXPORT_SYMBOL_GPL(pm_generic_restore_noirq);
 248
 249 /**
 250  * pm_generic_restore - Generic restore callback for subsystems.
 251  * @dev: Device to restore.
 252  */
 253 int pm_generic_restore(struct device *dev)
 254 {
 255         return __pm_generic_call(dev, PM_EVENT_RESTORE, false);
 256 }
 257 EXPORT_SYMBOL_GPL(pm_generic_restore);
 258
 259 /**
 260  * pm_generic_complete - Generic routine competing a device power transition.
 261  * @dev: Device to handle.
 262  *
 263  * Complete a device power transition during a system-wide power transition.
 264  */
 265 void pm_generic_complete(struct device *dev)
 266 {
 267         struct device_driver *drv = dev->driver;
 268
 269         if (drv && drv->pm && drv->pm->complete)
 270                 drv->pm->complete(dev);
 271
 272         /*
 273          * Let runtime PM try to suspend devices that haven't been in use before
 274          * going into the system-wide sleep state we're resuming from.
 275          */
 276         pm_runtime_idle(dev);
 277 }
 278 #endif /* CONFIG_PM_SLEEP */