projects/linux·blob master · refs

239 lines · 5.7 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * drivers/base/power/generic_ops.c - Generic PM callbacks for subsystems
4 *
5 * Copyright (c) 2010 Rafael J. Wysocki <[email protected]>, Novell Inc.
6 */
7#include <linux/pm.h>
8#include <linux/pm_runtime.h>
9#include <linux/export.h>
10
11#define CALL_PM_OP(dev, op) \
12({ \
13 struct device *_dev = (dev); \
14 const struct dev_pm_ops *pm = _dev->driver ? _dev->driver->pm : NULL; \
15 pm && pm->op ? pm->op(_dev) : 0; \
16})
17
18#ifdef CONFIG_PM
19/**
20 * pm_generic_runtime_suspend - Generic runtime suspend callback for subsystems.
21 * @dev: Device to suspend.
22 *
23 * If PM operations are defined for the @dev's driver and they include
24 * ->runtime_suspend(), execute it and return its error code. Otherwise,
25 * return 0.
26 */
27int pm_generic_runtime_suspend(struct device *dev)
28{
29 return CALL_PM_OP(dev, runtime_suspend);
30}
31EXPORT_SYMBOL_GPL(pm_generic_runtime_suspend);
32
33/**
34 * pm_generic_runtime_resume - Generic runtime resume callback for subsystems.
35 * @dev: Device to resume.
36 *
37 * If PM operations are defined for the @dev's driver and they include
38 * ->runtime_resume(), execute it and return its error code. Otherwise,
39 * return 0.
40 */
41int pm_generic_runtime_resume(struct device *dev)
42{
43 return CALL_PM_OP(dev, runtime_resume);
44}
45EXPORT_SYMBOL_GPL(pm_generic_runtime_resume);
46#endif /* CONFIG_PM */
47
48#ifdef CONFIG_PM_SLEEP
49/**
50 * pm_generic_prepare - Generic routine preparing a device for power transition.
51 * @dev: Device to prepare.
52 *
53 * Prepare a device for a system-wide power transition.
54 */
55int pm_generic_prepare(struct device *dev)
56{
57 struct device_driver *drv = dev->driver;
58 int ret = 0;
59
60 if (drv && drv->pm && drv->pm->prepare)
61 ret = drv->pm->prepare(dev);
62
63 return ret;
64}
65
66/**
67 * pm_generic_suspend_noirq - Generic suspend_noirq callback for subsystems.
68 * @dev: Device to suspend.
69 */
70int pm_generic_suspend_noirq(struct device *dev)
71{
72 return CALL_PM_OP(dev, suspend_noirq);
73}
74EXPORT_SYMBOL_GPL(pm_generic_suspend_noirq);
75
76/**
77 * pm_generic_suspend_late - Generic suspend_late callback for subsystems.
78 * @dev: Device to suspend.
79 */
80int pm_generic_suspend_late(struct device *dev)
81{
82 return CALL_PM_OP(dev, suspend_late);
83}
84EXPORT_SYMBOL_GPL(pm_generic_suspend_late);
85
86/**
87 * pm_generic_suspend - Generic suspend callback for subsystems.
88 * @dev: Device to suspend.
89 */
90int pm_generic_suspend(struct device *dev)
91{
92 return CALL_PM_OP(dev, suspend);
93}
94EXPORT_SYMBOL_GPL(pm_generic_suspend);
95
96/**
97 * pm_generic_freeze_noirq - Generic freeze_noirq callback for subsystems.
98 * @dev: Device to freeze.
99 */
100int pm_generic_freeze_noirq(struct device *dev)
101{
102 return CALL_PM_OP(dev, freeze_noirq);
103}
104EXPORT_SYMBOL_GPL(pm_generic_freeze_noirq);
105
106/**
107 * pm_generic_freeze - Generic freeze callback for subsystems.
108 * @dev: Device to freeze.
109 */
110int pm_generic_freeze(struct device *dev)
111{
112 return CALL_PM_OP(dev, freeze);
113}
114EXPORT_SYMBOL_GPL(pm_generic_freeze);
115
116/**
117 * pm_generic_poweroff_noirq - Generic poweroff_noirq callback for subsystems.
118 * @dev: Device to handle.
119 */
120int pm_generic_poweroff_noirq(struct device *dev)
121{
122 return CALL_PM_OP(dev, poweroff_noirq);
123}
124EXPORT_SYMBOL_GPL(pm_generic_poweroff_noirq);
125
126/**
127 * pm_generic_poweroff_late - Generic poweroff_late callback for subsystems.
128 * @dev: Device to handle.
129 */
130int pm_generic_poweroff_late(struct device *dev)
131{
132 return CALL_PM_OP(dev, poweroff_late);
133}
134EXPORT_SYMBOL_GPL(pm_generic_poweroff_late);
135
136/**
137 * pm_generic_poweroff - Generic poweroff callback for subsystems.
138 * @dev: Device to handle.
139 */
140int pm_generic_poweroff(struct device *dev)
141{
142 return CALL_PM_OP(dev, poweroff);
143}
144EXPORT_SYMBOL_GPL(pm_generic_poweroff);
145
146/**
147 * pm_generic_thaw_noirq - Generic thaw_noirq callback for subsystems.
148 * @dev: Device to thaw.
149 */
150int pm_generic_thaw_noirq(struct device *dev)
151{
152 return CALL_PM_OP(dev, thaw_noirq);
153}
154EXPORT_SYMBOL_GPL(pm_generic_thaw_noirq);
155
156/**
157 * pm_generic_thaw - Generic thaw callback for subsystems.
158 * @dev: Device to thaw.
159 */
160int pm_generic_thaw(struct device *dev)
161{
162 return CALL_PM_OP(dev, thaw);
163}
164EXPORT_SYMBOL_GPL(pm_generic_thaw);
165
166/**
167 * pm_generic_resume_noirq - Generic resume_noirq callback for subsystems.
168 * @dev: Device to resume.
169 */
170int pm_generic_resume_noirq(struct device *dev)
171{
172 return CALL_PM_OP(dev, resume_noirq);
173}
174EXPORT_SYMBOL_GPL(pm_generic_resume_noirq);
175
176/**
177 * pm_generic_resume_early - Generic resume_early callback for subsystems.
178 * @dev: Device to resume.
179 */
180int pm_generic_resume_early(struct device *dev)
181{
182 return CALL_PM_OP(dev, resume_early);
183}
184EXPORT_SYMBOL_GPL(pm_generic_resume_early);
185
186/**
187 * pm_generic_resume - Generic resume callback for subsystems.
188 * @dev: Device to resume.
189 */
190int pm_generic_resume(struct device *dev)
191{
192 return CALL_PM_OP(dev, resume);
193}
194EXPORT_SYMBOL_GPL(pm_generic_resume);
195
196/**
197 * pm_generic_restore_noirq - Generic restore_noirq callback for subsystems.
198 * @dev: Device to restore.
199 */
200int pm_generic_restore_noirq(struct device *dev)
201{
202 return CALL_PM_OP(dev, restore_noirq);
203}
204EXPORT_SYMBOL_GPL(pm_generic_restore_noirq);
205
206/**
207 * pm_generic_restore_early - Generic restore_early callback for subsystems.
208 * @dev: Device to resume.
209 */
210int pm_generic_restore_early(struct device *dev)
211{
212 return CALL_PM_OP(dev, restore_early);
213}
214EXPORT_SYMBOL_GPL(pm_generic_restore_early);
215
216/**
217 * pm_generic_restore - Generic restore callback for subsystems.
218 * @dev: Device to restore.
219 */
220int pm_generic_restore(struct device *dev)
221{
222 return CALL_PM_OP(dev, restore);
223}
224EXPORT_SYMBOL_GPL(pm_generic_restore);
225
226/**
227 * pm_generic_complete - Generic routine completing a device power transition.
228 * @dev: Device to handle.
229 *
230 * Complete a device power transition during a system-wide power transition.
231 */
232void pm_generic_complete(struct device *dev)
233{
234 struct device_driver *drv = dev->driver;
235
236 if (drv && drv->pm && drv->pm->complete)
237 drv->pm->complete(dev);
238}
239#endif /* CONFIG_PM_SLEEP */