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#include <linux/blk-pm.h>
12
13#include <scsi/scsi.h>
14#include <scsi/scsi_device.h>
15#include <scsi/scsi_driver.h>
16#include <scsi/scsi_host.h>
17
18#include "scsi_priv.h"
19
20#ifdef CONFIG_PM_SLEEP
21
22static int do_scsi_suspend(struct device *dev, const struct dev_pm_ops *pm)
23{
24 return pm && pm->suspend ? pm->suspend(dev) : 0;
25}
26
27static int do_scsi_freeze(struct device *dev, const struct dev_pm_ops *pm)
28{
29 return pm && pm->freeze ? pm->freeze(dev) : 0;
30}
31
32static int do_scsi_poweroff(struct device *dev, const struct dev_pm_ops *pm)
33{
34 return pm && pm->poweroff ? pm->poweroff(dev) : 0;
35}
36
37static int do_scsi_resume(struct device *dev, const struct dev_pm_ops *pm)
38{
39 return pm && pm->resume ? pm->resume(dev) : 0;
40}
41
42static int do_scsi_thaw(struct device *dev, const struct dev_pm_ops *pm)
43{
44 return pm && pm->thaw ? pm->thaw(dev) : 0;
45}
46
47static int do_scsi_restore(struct device *dev, const struct dev_pm_ops *pm)
48{
49 return pm && pm->restore ? pm->restore(dev) : 0;
50}
51
52static int scsi_dev_type_suspend(struct device *dev,
53 int (*cb)(struct device *, const struct dev_pm_ops *))
54{
55 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
56 int err;
57
58 /* flush pending in-flight resume operations, suspend is synchronous */
59 async_synchronize_full_domain(&scsi_sd_pm_domain);
60
61 err = scsi_device_quiesce(to_scsi_device(dev));
62 if (err == 0) {
63 err = cb(dev, pm);
64 if (err)
65 scsi_device_resume(to_scsi_device(dev));
66 }
67 dev_dbg(dev, "scsi suspend: %d\n", err);
68 return err;
69}
70
71static int scsi_dev_type_resume(struct device *dev,
72 int (*cb)(struct device *, const struct dev_pm_ops *))
73{
74 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
75 int err = 0;
76
77 err = cb(dev, pm);
78 scsi_device_resume(to_scsi_device(dev));
79 dev_dbg(dev, "scsi resume: %d\n", err);
80
81 if (err == 0) {
82 pm_runtime_disable(dev);
83 err = pm_runtime_set_active(dev);
84 pm_runtime_enable(dev);
85
86 /*
87 * Forcibly set runtime PM status of request queue to "active"
88 * to make sure we can again get requests from the queue
89 * (see also blk_pm_peek_request()).
90 *
91 * The resume hook will correct runtime PM status of the disk.
92 */
93 if (!err && scsi_is_sdev_device(dev)) {
94 struct scsi_device *sdev = to_scsi_device(dev);
95
96 if (sdev->request_queue->dev)
97 blk_set_runtime_active(sdev->request_queue);
98 }
99 }
100
101 return err;
102}
103
104static int
105scsi_bus_suspend_common(struct device *dev,
106 int (*cb)(struct device *, const struct dev_pm_ops *))
107{
108 int err = 0;
109
110 if (scsi_is_sdev_device(dev)) {
111 /*
112 * All the high-level SCSI drivers that implement runtime
113 * PM treat runtime suspend, system suspend, and system
114 * hibernate nearly identically. In all cases the requirements
115 * for runtime suspension are stricter.
116 */
117 if (pm_runtime_suspended(dev))
118 return 0;
119
120 err = scsi_dev_type_suspend(dev, cb);
121 }
122
123 return err;
124}
125
126static void async_sdev_resume(void *dev, async_cookie_t cookie)
127{
128 scsi_dev_type_resume(dev, do_scsi_resume);
129}
130
131static void async_sdev_thaw(void *dev, async_cookie_t cookie)
132{
133 scsi_dev_type_resume(dev, do_scsi_thaw);
134}
135
136static void async_sdev_restore(void *dev, async_cookie_t cookie)
137{
138 scsi_dev_type_resume(dev, do_scsi_restore);
139}
140
141static int scsi_bus_resume_common(struct device *dev,
142 int (*cb)(struct device *, const struct dev_pm_ops *))
143{
144 async_func_t fn;
145
146 if (!scsi_is_sdev_device(dev))
147 fn = NULL;
148 else if (cb == do_scsi_resume)
149 fn = async_sdev_resume;
150 else if (cb == do_scsi_thaw)
151 fn = async_sdev_thaw;
152 else if (cb == do_scsi_restore)
153 fn = async_sdev_restore;
154 else
155 fn = NULL;
156
157 if (fn) {
158 async_schedule_domain(fn, dev, &scsi_sd_pm_domain);
159
160 /*
161 * If a user has disabled async probing a likely reason
162 * is due to a storage enclosure that does not inject
163 * staggered spin-ups. For safety, make resume
164 * synchronous as well in that case.
165 */
166 if (strncmp(scsi_scan_type, "async", 5) != 0)
167 async_synchronize_full_domain(&scsi_sd_pm_domain);
168 } else {
169 pm_runtime_disable(dev);
170 pm_runtime_set_active(dev);
171 pm_runtime_enable(dev);
172 }
173 return 0;
174}
175
176static int scsi_bus_prepare(struct device *dev)
177{
178 if (scsi_is_sdev_device(dev)) {
179 /* sd probing uses async_schedule. Wait until it finishes. */
180 async_synchronize_full_domain(&scsi_sd_probe_domain);
181
182 } else if (scsi_is_host_device(dev)) {
183 /* Wait until async scanning is finished */
184 scsi_complete_async_scans();
185 }
186 return 0;
187}
188
189static int scsi_bus_suspend(struct device *dev)
190{
191 return scsi_bus_suspend_common(dev, do_scsi_suspend);
192}
193
194static int scsi_bus_resume(struct device *dev)
195{
196 return scsi_bus_resume_common(dev, do_scsi_resume);
197}
198
199static int scsi_bus_freeze(struct device *dev)
200{
201 return scsi_bus_suspend_common(dev, do_scsi_freeze);
202}
203
204static int scsi_bus_thaw(struct device *dev)
205{
206 return scsi_bus_resume_common(dev, do_scsi_thaw);
207}
208
209static int scsi_bus_poweroff(struct device *dev)
210{
211 return scsi_bus_suspend_common(dev, do_scsi_poweroff);
212}
213
214static int scsi_bus_restore(struct device *dev)
215{
216 return scsi_bus_resume_common(dev, do_scsi_restore);
217}
218
219#else /* CONFIG_PM_SLEEP */
220
221#define scsi_bus_prepare NULL
222#define scsi_bus_suspend NULL
223#define scsi_bus_resume NULL
224#define scsi_bus_freeze NULL
225#define scsi_bus_thaw NULL
226#define scsi_bus_poweroff NULL
227#define scsi_bus_restore NULL
228
229#endif /* CONFIG_PM_SLEEP */
230
231static int sdev_runtime_suspend(struct device *dev)
232{
233 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
234 struct scsi_device *sdev = to_scsi_device(dev);
235 int err = 0;
236
237 err = blk_pre_runtime_suspend(sdev->request_queue);
238 if (err)
239 return err;
240 if (pm && pm->runtime_suspend)
241 err = pm->runtime_suspend(dev);
242 blk_post_runtime_suspend(sdev->request_queue, err);
243
244 return err;
245}
246
247static int scsi_runtime_suspend(struct device *dev)
248{
249 int err = 0;
250
251 dev_dbg(dev, "scsi_runtime_suspend\n");
252 if (scsi_is_sdev_device(dev))
253 err = sdev_runtime_suspend(dev);
254
255 /* Insert hooks here for targets, hosts, and transport classes */
256
257 return err;
258}
259
260static int sdev_runtime_resume(struct device *dev)
261{
262 struct scsi_device *sdev = to_scsi_device(dev);
263 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
264 int err = 0;
265
266 blk_pre_runtime_resume(sdev->request_queue);
267 if (pm && pm->runtime_resume)
268 err = pm->runtime_resume(dev);
269 blk_post_runtime_resume(sdev->request_queue, err);
270
271 return err;
272}
273
274static int scsi_runtime_resume(struct device *dev)
275{
276 int err = 0;
277
278 dev_dbg(dev, "scsi_runtime_resume\n");
279 if (scsi_is_sdev_device(dev))
280 err = sdev_runtime_resume(dev);
281
282 /* Insert hooks here for targets, hosts, and transport classes */
283
284 return err;
285}
286
287static int scsi_runtime_idle(struct device *dev)
288{
289 dev_dbg(dev, "scsi_runtime_idle\n");
290
291 /* Insert hooks here for targets, hosts, and transport classes */
292
293 if (scsi_is_sdev_device(dev)) {
294 pm_runtime_mark_last_busy(dev);
295 pm_runtime_autosuspend(dev);
296 return -EBUSY;
297 }
298
299 return 0;
300}
301
302int scsi_autopm_get_device(struct scsi_device *sdev)
303{
304 int err;
305
306 err = pm_runtime_get_sync(&sdev->sdev_gendev);
307 if (err < 0 && err !=-EACCES)
308 pm_runtime_put_sync(&sdev->sdev_gendev);
309 else
310 err = 0;
311 return err;
312}
313EXPORT_SYMBOL_GPL(scsi_autopm_get_device);
314
315void scsi_autopm_put_device(struct scsi_device *sdev)
316{
317 pm_runtime_put_sync(&sdev->sdev_gendev);
318}
319EXPORT_SYMBOL_GPL(scsi_autopm_put_device);
320
321void scsi_autopm_get_target(struct scsi_target *starget)
322{
323 pm_runtime_get_sync(&starget->dev);
324}
325
326void scsi_autopm_put_target(struct scsi_target *starget)
327{
328 pm_runtime_put_sync(&starget->dev);
329}
330
331int scsi_autopm_get_host(struct Scsi_Host *shost)
332{
333 int err;
334
335 err = pm_runtime_get_sync(&shost->shost_gendev);
336 if (err < 0 && err !=-EACCES)
337 pm_runtime_put_sync(&shost->shost_gendev);
338 else
339 err = 0;
340 return err;
341}
342
343void scsi_autopm_put_host(struct Scsi_Host *shost)
344{
345 pm_runtime_put_sync(&shost->shost_gendev);
346}
347
348const struct dev_pm_ops scsi_bus_pm_ops = {
349 .prepare = scsi_bus_prepare,
350 .suspend = scsi_bus_suspend,
351 .resume = scsi_bus_resume,
352 .freeze = scsi_bus_freeze,
353 .thaw = scsi_bus_thaw,
354 .poweroff = scsi_bus_poweroff,
355 .restore = scsi_bus_restore,
356 .runtime_suspend = scsi_runtime_suspend,
357 .runtime_resume = scsi_runtime_resume,
358 .runtime_idle = scsi_runtime_idle,
359};
360