1 /*
2 * scsi_pm.c Copyright (C) 2010 Alan Stern
3 *
4 * SCSI dynamic Power Management
5 * Initial version: Alan Stern <stern@rowland.harvard.edu>
6 */
7
8 #include <linux/pm_runtime.h>
9 #include <linux/export.h>
10 #include <linux/async.h>
11
12 #include <scsi/scsi.h>
13 #include <scsi/scsi_device.h>
14 #include <scsi/scsi_driver.h>
15 #include <scsi/scsi_host.h>
16
17 #include "scsi_priv.h"
18
scsi_dev_type_suspend(struct device * dev,int (* cb)(struct device *))19 static int scsi_dev_type_suspend(struct device *dev, int (*cb)(struct device *))
20 {
21 int err;
22
23 err = scsi_device_quiesce(to_scsi_device(dev));
24 if (err == 0) {
25 if (cb) {
26 err = cb(dev);
27 if (err)
28 scsi_device_resume(to_scsi_device(dev));
29 }
30 }
31 dev_dbg(dev, "scsi suspend: %d\n", err);
32 return err;
33 }
34
scsi_dev_type_resume(struct device * dev,int (* cb)(struct device *))35 static int scsi_dev_type_resume(struct device *dev, int (*cb)(struct device *))
36 {
37 int err = 0;
38
39 if (cb)
40 err = cb(dev);
41 scsi_device_resume(to_scsi_device(dev));
42 dev_dbg(dev, "scsi resume: %d\n", err);
43 return err;
44 }
45
46 #ifdef CONFIG_PM_SLEEP
47
48 static int
scsi_bus_suspend_common(struct device * dev,int (* cb)(struct device *))49 scsi_bus_suspend_common(struct device *dev, int (*cb)(struct device *))
50 {
51 int err = 0;
52
53 if (scsi_is_sdev_device(dev)) {
54 /*
55 * All the high-level SCSI drivers that implement runtime
56 * PM treat runtime suspend, system suspend, and system
57 * hibernate identically.
58 */
59 if (pm_runtime_suspended(dev))
60 return 0;
61
62 err = scsi_dev_type_suspend(dev, cb);
63 }
64
65 return err;
66 }
67
68 static int
scsi_bus_resume_common(struct device * dev,int (* cb)(struct device *))69 scsi_bus_resume_common(struct device *dev, int (*cb)(struct device *))
70 {
71 int err = 0;
72
73 if (scsi_is_sdev_device(dev))
74 err = scsi_dev_type_resume(dev, cb);
75
76 if (err == 0) {
77 pm_runtime_disable(dev);
78 pm_runtime_set_active(dev);
79 pm_runtime_enable(dev);
80 }
81 return err;
82 }
83
scsi_bus_prepare(struct device * dev)84 static int scsi_bus_prepare(struct device *dev)
85 {
86 if (scsi_is_sdev_device(dev)) {
87 /* sd probing uses async_schedule. Wait until it finishes. */
88 async_synchronize_full_domain(&scsi_sd_probe_domain);
89
90 } else if (scsi_is_host_device(dev)) {
91 /* Wait until async scanning is finished */
92 scsi_complete_async_scans();
93 }
94 return 0;
95 }
96
scsi_bus_suspend(struct device * dev)97 static int scsi_bus_suspend(struct device *dev)
98 {
99 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
100 return scsi_bus_suspend_common(dev, pm ? pm->suspend : NULL);
101 }
102
scsi_bus_resume(struct device * dev)103 static int scsi_bus_resume(struct device *dev)
104 {
105 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
106 return scsi_bus_resume_common(dev, pm ? pm->resume : NULL);
107 }
108
scsi_bus_freeze(struct device * dev)109 static int scsi_bus_freeze(struct device *dev)
110 {
111 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
112 return scsi_bus_suspend_common(dev, pm ? pm->freeze : NULL);
113 }
114
scsi_bus_thaw(struct device * dev)115 static int scsi_bus_thaw(struct device *dev)
116 {
117 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
118 return scsi_bus_resume_common(dev, pm ? pm->thaw : NULL);
119 }
120
scsi_bus_poweroff(struct device * dev)121 static int scsi_bus_poweroff(struct device *dev)
122 {
123 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
124 return scsi_bus_suspend_common(dev, pm ? pm->poweroff : NULL);
125 }
126
scsi_bus_restore(struct device * dev)127 static int scsi_bus_restore(struct device *dev)
128 {
129 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
130 return scsi_bus_resume_common(dev, pm ? pm->restore : NULL);
131 }
132
133 #else /* CONFIG_PM_SLEEP */
134
135 #define scsi_bus_prepare NULL
136 #define scsi_bus_suspend NULL
137 #define scsi_bus_resume NULL
138 #define scsi_bus_freeze NULL
139 #define scsi_bus_thaw NULL
140 #define scsi_bus_poweroff NULL
141 #define scsi_bus_restore NULL
142
143 #endif /* CONFIG_PM_SLEEP */
144
145 #ifdef CONFIG_PM_RUNTIME
146
sdev_blk_runtime_suspend(struct scsi_device * sdev,int (* cb)(struct device *))147 static int sdev_blk_runtime_suspend(struct scsi_device *sdev,
148 int (*cb)(struct device *))
149 {
150 int err;
151
152 err = blk_pre_runtime_suspend(sdev->request_queue);
153 if (err)
154 return err;
155 if (cb)
156 err = cb(&sdev->sdev_gendev);
157 blk_post_runtime_suspend(sdev->request_queue, err);
158
159 return err;
160 }
161
sdev_runtime_suspend(struct device * dev)162 static int sdev_runtime_suspend(struct device *dev)
163 {
164 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
165 int (*cb)(struct device *) = pm ? pm->runtime_suspend : NULL;
166 struct scsi_device *sdev = to_scsi_device(dev);
167 int err;
168
169 if (sdev->request_queue->dev)
170 return sdev_blk_runtime_suspend(sdev, cb);
171
172 err = scsi_dev_type_suspend(dev, cb);
173 if (err == -EAGAIN)
174 pm_schedule_suspend(dev, jiffies_to_msecs(
175 round_jiffies_up_relative(HZ/10)));
176 return err;
177 }
178
scsi_runtime_suspend(struct device * dev)179 static int scsi_runtime_suspend(struct device *dev)
180 {
181 int err = 0;
182
183 dev_dbg(dev, "scsi_runtime_suspend\n");
184 if (scsi_is_sdev_device(dev))
185 err = sdev_runtime_suspend(dev);
186
187 /* Insert hooks here for targets, hosts, and transport classes */
188
189 return err;
190 }
191
sdev_blk_runtime_resume(struct scsi_device * sdev,int (* cb)(struct device *))192 static int sdev_blk_runtime_resume(struct scsi_device *sdev,
193 int (*cb)(struct device *))
194 {
195 int err = 0;
196
197 blk_pre_runtime_resume(sdev->request_queue);
198 if (cb)
199 err = cb(&sdev->sdev_gendev);
200 blk_post_runtime_resume(sdev->request_queue, err);
201
202 return err;
203 }
204
sdev_runtime_resume(struct device * dev)205 static int sdev_runtime_resume(struct device *dev)
206 {
207 struct scsi_device *sdev = to_scsi_device(dev);
208 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
209 int (*cb)(struct device *) = pm ? pm->runtime_resume : NULL;
210
211 if (sdev->request_queue->dev)
212 return sdev_blk_runtime_resume(sdev, cb);
213 else
214 return scsi_dev_type_resume(dev, cb);
215 }
216
scsi_runtime_resume(struct device * dev)217 static int scsi_runtime_resume(struct device *dev)
218 {
219 int err = 0;
220
221 dev_dbg(dev, "scsi_runtime_resume\n");
222 if (scsi_is_sdev_device(dev))
223 err = sdev_runtime_resume(dev);
224
225 /* Insert hooks here for targets, hosts, and transport classes */
226
227 return err;
228 }
229
scsi_runtime_idle(struct device * dev)230 static int scsi_runtime_idle(struct device *dev)
231 {
232 int err;
233
234 dev_dbg(dev, "scsi_runtime_idle\n");
235
236 /* Insert hooks here for targets, hosts, and transport classes */
237
238 if (scsi_is_sdev_device(dev)) {
239 struct scsi_device *sdev = to_scsi_device(dev);
240
241 if (sdev->request_queue->dev) {
242 pm_runtime_mark_last_busy(dev);
243 err = pm_runtime_autosuspend(dev);
244 } else {
245 err = pm_runtime_suspend(dev);
246 }
247 } else {
248 err = pm_runtime_suspend(dev);
249 }
250 return err;
251 }
252
scsi_autopm_get_device(struct scsi_device * sdev)253 int scsi_autopm_get_device(struct scsi_device *sdev)
254 {
255 int err;
256
257 err = pm_runtime_get_sync(&sdev->sdev_gendev);
258 if (err < 0 && err !=-EACCES)
259 pm_runtime_put_sync(&sdev->sdev_gendev);
260 else
261 err = 0;
262 return err;
263 }
264 EXPORT_SYMBOL_GPL(scsi_autopm_get_device);
265
scsi_autopm_put_device(struct scsi_device * sdev)266 void scsi_autopm_put_device(struct scsi_device *sdev)
267 {
268 pm_runtime_put_sync(&sdev->sdev_gendev);
269 }
270 EXPORT_SYMBOL_GPL(scsi_autopm_put_device);
271
scsi_autopm_get_target(struct scsi_target * starget)272 void scsi_autopm_get_target(struct scsi_target *starget)
273 {
274 pm_runtime_get_sync(&starget->dev);
275 }
276
scsi_autopm_put_target(struct scsi_target * starget)277 void scsi_autopm_put_target(struct scsi_target *starget)
278 {
279 pm_runtime_put_sync(&starget->dev);
280 }
281
scsi_autopm_get_host(struct Scsi_Host * shost)282 int scsi_autopm_get_host(struct Scsi_Host *shost)
283 {
284 int err;
285
286 err = pm_runtime_get_sync(&shost->shost_gendev);
287 if (err < 0 && err !=-EACCES)
288 pm_runtime_put_sync(&shost->shost_gendev);
289 else
290 err = 0;
291 return err;
292 }
293
scsi_autopm_put_host(struct Scsi_Host * shost)294 void scsi_autopm_put_host(struct Scsi_Host *shost)
295 {
296 pm_runtime_put_sync(&shost->shost_gendev);
297 }
298
299 #else
300
301 #define scsi_runtime_suspend NULL
302 #define scsi_runtime_resume NULL
303 #define scsi_runtime_idle NULL
304
305 #endif /* CONFIG_PM_RUNTIME */
306
307 const struct dev_pm_ops scsi_bus_pm_ops = {
308 .prepare = scsi_bus_prepare,
309 .suspend = scsi_bus_suspend,
310 .resume = scsi_bus_resume,
311 .freeze = scsi_bus_freeze,
312 .thaw = scsi_bus_thaw,
313 .poweroff = scsi_bus_poweroff,
314 .restore = scsi_bus_restore,
315 .runtime_suspend = scsi_runtime_suspend,
316 .runtime_resume = scsi_runtime_resume,
317 .runtime_idle = scsi_runtime_idle,
318 };
319