base/power/generic_ops.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * drivers/base/power/generic_ops.c - Generic PM callbacks for subsystems
0004  *
0005  * Copyright (c) 2010 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
0006  */
0007 #include <linux/pm.h>
0008 #include <linux/pm_runtime.h>
0009 #include <linux/export.h>
0010
0011 #ifdef CONFIG_PM
0012 /**
0013  * pm_generic_runtime_suspend - Generic runtime suspend callback for subsystems.
0014  * @dev: Device to suspend.
0015  *
0016  * If PM operations are defined for the @dev's driver and they include
0017  * ->runtime_suspend(), execute it and return its error code.  Otherwise,
0018  * return 0.
0019  */
0020 int pm_generic_runtime_suspend(struct device *dev)
0021 {
0022     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0023     int ret;
0024
0025     ret = pm && pm->runtime_suspend ? pm->runtime_suspend(dev) : 0;
0026
0027     return ret;
0028 }
0029 EXPORT_SYMBOL_GPL(pm_generic_runtime_suspend);
0030
0031 /**
0032  * pm_generic_runtime_resume - Generic runtime resume callback for subsystems.
0033  * @dev: Device to resume.
0034  *
0035  * If PM operations are defined for the @dev's driver and they include
0036  * ->runtime_resume(), execute it and return its error code.  Otherwise,
0037  * return 0.
0038  */
0039 int pm_generic_runtime_resume(struct device *dev)
0040 {
0041     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0042     int ret;
0043
0044     ret = pm && pm->runtime_resume ? pm->runtime_resume(dev) : 0;
0045
0046     return ret;
0047 }
0048 EXPORT_SYMBOL_GPL(pm_generic_runtime_resume);
0049 #endif /* CONFIG_PM */
0050
0051 #ifdef CONFIG_PM_SLEEP
0052 /**
0053  * pm_generic_prepare - Generic routine preparing a device for power transition.
0054  * @dev: Device to prepare.
0055  *
0056  * Prepare a device for a system-wide power transition.
0057  */
0058 int pm_generic_prepare(struct device *dev)
0059 {
0060     struct device_driver *drv = dev->driver;
0061     int ret = 0;
0062
0063     if (drv && drv->pm && drv->pm->prepare)
0064         ret = drv->pm->prepare(dev);
0065
0066     return ret;
0067 }
0068
0069 /**
0070  * pm_generic_suspend_noirq - Generic suspend_noirq callback for subsystems.
0071  * @dev: Device to suspend.
0072  */
0073 int pm_generic_suspend_noirq(struct device *dev)
0074 {
0075     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0076
0077     return pm && pm->suspend_noirq ? pm->suspend_noirq(dev) : 0;
0078 }
0079 EXPORT_SYMBOL_GPL(pm_generic_suspend_noirq);
0080
0081 /**
0082  * pm_generic_suspend_late - Generic suspend_late callback for subsystems.
0083  * @dev: Device to suspend.
0084  */
0085 int pm_generic_suspend_late(struct device *dev)
0086 {
0087     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0088
0089     return pm && pm->suspend_late ? pm->suspend_late(dev) : 0;
0090 }
0091 EXPORT_SYMBOL_GPL(pm_generic_suspend_late);
0092
0093 /**
0094  * pm_generic_suspend - Generic suspend callback for subsystems.
0095  * @dev: Device to suspend.
0096  */
0097 int pm_generic_suspend(struct device *dev)
0098 {
0099     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0100
0101     return pm && pm->suspend ? pm->suspend(dev) : 0;
0102 }
0103 EXPORT_SYMBOL_GPL(pm_generic_suspend);
0104
0105 /**
0106  * pm_generic_freeze_noirq - Generic freeze_noirq callback for subsystems.
0107  * @dev: Device to freeze.
0108  */
0109 int pm_generic_freeze_noirq(struct device *dev)
0110 {
0111     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0112
0113     return pm && pm->freeze_noirq ? pm->freeze_noirq(dev) : 0;
0114 }
0115 EXPORT_SYMBOL_GPL(pm_generic_freeze_noirq);
0116
0117 /**
0118  * pm_generic_freeze_late - Generic freeze_late callback for subsystems.
0119  * @dev: Device to freeze.
0120  */
0121 int pm_generic_freeze_late(struct device *dev)
0122 {
0123     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0124
0125     return pm && pm->freeze_late ? pm->freeze_late(dev) : 0;
0126 }
0127 EXPORT_SYMBOL_GPL(pm_generic_freeze_late);
0128
0129 /**
0130  * pm_generic_freeze - Generic freeze callback for subsystems.
0131  * @dev: Device to freeze.
0132  */
0133 int pm_generic_freeze(struct device *dev)
0134 {
0135     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0136
0137     return pm && pm->freeze ? pm->freeze(dev) : 0;
0138 }
0139 EXPORT_SYMBOL_GPL(pm_generic_freeze);
0140
0141 /**
0142  * pm_generic_poweroff_noirq - Generic poweroff_noirq callback for subsystems.
0143  * @dev: Device to handle.
0144  */
0145 int pm_generic_poweroff_noirq(struct device *dev)
0146 {
0147     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0148
0149     return pm && pm->poweroff_noirq ? pm->poweroff_noirq(dev) : 0;
0150 }
0151 EXPORT_SYMBOL_GPL(pm_generic_poweroff_noirq);
0152
0153 /**
0154  * pm_generic_poweroff_late - Generic poweroff_late callback for subsystems.
0155  * @dev: Device to handle.
0156  */
0157 int pm_generic_poweroff_late(struct device *dev)
0158 {
0159     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0160
0161     return pm && pm->poweroff_late ? pm->poweroff_late(dev) : 0;
0162 }
0163 EXPORT_SYMBOL_GPL(pm_generic_poweroff_late);
0164
0165 /**
0166  * pm_generic_poweroff - Generic poweroff callback for subsystems.
0167  * @dev: Device to handle.
0168  */
0169 int pm_generic_poweroff(struct device *dev)
0170 {
0171     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0172
0173     return pm && pm->poweroff ? pm->poweroff(dev) : 0;
0174 }
0175 EXPORT_SYMBOL_GPL(pm_generic_poweroff);
0176
0177 /**
0178  * pm_generic_thaw_noirq - Generic thaw_noirq callback for subsystems.
0179  * @dev: Device to thaw.
0180  */
0181 int pm_generic_thaw_noirq(struct device *dev)
0182 {
0183     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0184
0185     return pm && pm->thaw_noirq ? pm->thaw_noirq(dev) : 0;
0186 }
0187 EXPORT_SYMBOL_GPL(pm_generic_thaw_noirq);
0188
0189 /**
0190  * pm_generic_thaw_early - Generic thaw_early callback for subsystems.
0191  * @dev: Device to thaw.
0192  */
0193 int pm_generic_thaw_early(struct device *dev)
0194 {
0195     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0196
0197     return pm && pm->thaw_early ? pm->thaw_early(dev) : 0;
0198 }
0199 EXPORT_SYMBOL_GPL(pm_generic_thaw_early);
0200
0201 /**
0202  * pm_generic_thaw - Generic thaw callback for subsystems.
0203  * @dev: Device to thaw.
0204  */
0205 int pm_generic_thaw(struct device *dev)
0206 {
0207     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0208
0209     return pm && pm->thaw ? pm->thaw(dev) : 0;
0210 }
0211 EXPORT_SYMBOL_GPL(pm_generic_thaw);
0212
0213 /**
0214  * pm_generic_resume_noirq - Generic resume_noirq callback for subsystems.
0215  * @dev: Device to resume.
0216  */
0217 int pm_generic_resume_noirq(struct device *dev)
0218 {
0219     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0220
0221     return pm && pm->resume_noirq ? pm->resume_noirq(dev) : 0;
0222 }
0223 EXPORT_SYMBOL_GPL(pm_generic_resume_noirq);
0224
0225 /**
0226  * pm_generic_resume_early - Generic resume_early callback for subsystems.
0227  * @dev: Device to resume.
0228  */
0229 int pm_generic_resume_early(struct device *dev)
0230 {
0231     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0232
0233     return pm && pm->resume_early ? pm->resume_early(dev) : 0;
0234 }
0235 EXPORT_SYMBOL_GPL(pm_generic_resume_early);
0236
0237 /**
0238  * pm_generic_resume - Generic resume callback for subsystems.
0239  * @dev: Device to resume.
0240  */
0241 int pm_generic_resume(struct device *dev)
0242 {
0243     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0244
0245     return pm && pm->resume ? pm->resume(dev) : 0;
0246 }
0247 EXPORT_SYMBOL_GPL(pm_generic_resume);
0248
0249 /**
0250  * pm_generic_restore_noirq - Generic restore_noirq callback for subsystems.
0251  * @dev: Device to restore.
0252  */
0253 int pm_generic_restore_noirq(struct device *dev)
0254 {
0255     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0256
0257     return pm && pm->restore_noirq ? pm->restore_noirq(dev) : 0;
0258 }
0259 EXPORT_SYMBOL_GPL(pm_generic_restore_noirq);
0260
0261 /**
0262  * pm_generic_restore_early - Generic restore_early callback for subsystems.
0263  * @dev: Device to resume.
0264  */
0265 int pm_generic_restore_early(struct device *dev)
0266 {
0267     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0268
0269     return pm && pm->restore_early ? pm->restore_early(dev) : 0;
0270 }
0271 EXPORT_SYMBOL_GPL(pm_generic_restore_early);
0272
0273 /**
0274  * pm_generic_restore - Generic restore callback for subsystems.
0275  * @dev: Device to restore.
0276  */
0277 int pm_generic_restore(struct device *dev)
0278 {
0279     const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
0280
0281     return pm && pm->restore ? pm->restore(dev) : 0;
0282 }
0283 EXPORT_SYMBOL_GPL(pm_generic_restore);
0284
0285 /**
0286  * pm_generic_complete - Generic routine completing a device power transition.
0287  * @dev: Device to handle.
0288  *
0289  * Complete a device power transition during a system-wide power transition.
0290  */
0291 void pm_generic_complete(struct device *dev)
0292 {
0293     struct device_driver *drv = dev->driver;
0294
0295     if (drv && drv->pm && drv->pm->complete)
0296         drv->pm->complete(dev);
0297 }
0298 #endif /* CONFIG_PM_SLEEP */