2 * scsi_pm.c Copyright (C) 2010 Alan Stern
4 * SCSI dynamic Power Management
5 * Initial version: Alan Stern <stern@rowland.harvard.edu>
8 #include <linux/pm_runtime.h>
9 #include <linux/export.h>
10 #include <linux/async.h>
12 #include <scsi/scsi.h>
13 #include <scsi/scsi_device.h>
14 #include <scsi/scsi_driver.h>
15 #include <scsi/scsi_host.h>
17 #include "scsi_priv.h"
19 #ifdef CONFIG_PM_SLEEP
21 static int do_scsi_suspend(struct device
*dev
, const struct dev_pm_ops
*pm
)
23 return pm
&& pm
->suspend
? pm
->suspend(dev
) : 0;
26 static int do_scsi_freeze(struct device
*dev
, const struct dev_pm_ops
*pm
)
28 return pm
&& pm
->freeze
? pm
->freeze(dev
) : 0;
31 static int do_scsi_poweroff(struct device
*dev
, const struct dev_pm_ops
*pm
)
33 return pm
&& pm
->poweroff
? pm
->poweroff(dev
) : 0;
36 static int do_scsi_resume(struct device
*dev
, const struct dev_pm_ops
*pm
)
38 return pm
&& pm
->resume
? pm
->resume(dev
) : 0;
41 static int do_scsi_thaw(struct device
*dev
, const struct dev_pm_ops
*pm
)
43 return pm
&& pm
->thaw
? pm
->thaw(dev
) : 0;
46 static int do_scsi_restore(struct device
*dev
, const struct dev_pm_ops
*pm
)
48 return pm
&& pm
->restore
? pm
->restore(dev
) : 0;
51 static int scsi_dev_type_suspend(struct device
*dev
,
52 int (*cb
)(struct device
*, const struct dev_pm_ops
*))
54 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
57 /* flush pending in-flight resume operations, suspend is synchronous */
58 async_synchronize_full_domain(&scsi_sd_pm_domain
);
60 err
= scsi_device_quiesce(to_scsi_device(dev
));
64 scsi_device_resume(to_scsi_device(dev
));
66 dev_dbg(dev
, "scsi suspend: %d\n", err
);
70 static int scsi_dev_type_resume(struct device
*dev
,
71 int (*cb
)(struct device
*, const struct dev_pm_ops
*))
73 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
77 scsi_device_resume(to_scsi_device(dev
));
78 dev_dbg(dev
, "scsi resume: %d\n", err
);
81 pm_runtime_disable(dev
);
82 pm_runtime_set_active(dev
);
83 pm_runtime_enable(dev
);
90 scsi_bus_suspend_common(struct device
*dev
,
91 int (*cb
)(struct device
*, const struct dev_pm_ops
*))
95 if (scsi_is_sdev_device(dev
)) {
97 * All the high-level SCSI drivers that implement runtime
98 * PM treat runtime suspend, system suspend, and system
99 * hibernate nearly identically. In all cases the requirements
100 * for runtime suspension are stricter.
102 if (pm_runtime_suspended(dev
))
105 err
= scsi_dev_type_suspend(dev
, cb
);
111 static void async_sdev_resume(void *dev
, async_cookie_t cookie
)
113 scsi_dev_type_resume(dev
, do_scsi_resume
);
116 static void async_sdev_thaw(void *dev
, async_cookie_t cookie
)
118 scsi_dev_type_resume(dev
, do_scsi_thaw
);
121 static void async_sdev_restore(void *dev
, async_cookie_t cookie
)
123 scsi_dev_type_resume(dev
, do_scsi_restore
);
126 static int scsi_bus_resume_common(struct device
*dev
,
127 int (*cb
)(struct device
*, const struct dev_pm_ops
*))
131 if (!scsi_is_sdev_device(dev
))
133 else if (cb
== do_scsi_resume
)
134 fn
= async_sdev_resume
;
135 else if (cb
== do_scsi_thaw
)
136 fn
= async_sdev_thaw
;
137 else if (cb
== do_scsi_restore
)
138 fn
= async_sdev_restore
;
143 async_schedule_domain(fn
, dev
, &scsi_sd_pm_domain
);
146 * If a user has disabled async probing a likely reason
147 * is due to a storage enclosure that does not inject
148 * staggered spin-ups. For safety, make resume
149 * synchronous as well in that case.
151 if (strncmp(scsi_scan_type
, "async", 5) != 0)
152 async_synchronize_full_domain(&scsi_sd_pm_domain
);
154 pm_runtime_disable(dev
);
155 pm_runtime_set_active(dev
);
156 pm_runtime_enable(dev
);
161 static int scsi_bus_prepare(struct device
*dev
)
163 if (scsi_is_sdev_device(dev
)) {
164 /* sd probing uses async_schedule. Wait until it finishes. */
165 async_synchronize_full_domain(&scsi_sd_probe_domain
);
167 } else if (scsi_is_host_device(dev
)) {
168 /* Wait until async scanning is finished */
169 scsi_complete_async_scans();
174 static int scsi_bus_suspend(struct device
*dev
)
176 return scsi_bus_suspend_common(dev
, do_scsi_suspend
);
179 static int scsi_bus_resume(struct device
*dev
)
181 return scsi_bus_resume_common(dev
, do_scsi_resume
);
184 static int scsi_bus_freeze(struct device
*dev
)
186 return scsi_bus_suspend_common(dev
, do_scsi_freeze
);
189 static int scsi_bus_thaw(struct device
*dev
)
191 return scsi_bus_resume_common(dev
, do_scsi_thaw
);
194 static int scsi_bus_poweroff(struct device
*dev
)
196 return scsi_bus_suspend_common(dev
, do_scsi_poweroff
);
199 static int scsi_bus_restore(struct device
*dev
)
201 return scsi_bus_resume_common(dev
, do_scsi_restore
);
204 #else /* CONFIG_PM_SLEEP */
206 #define scsi_bus_prepare NULL
207 #define scsi_bus_suspend NULL
208 #define scsi_bus_resume NULL
209 #define scsi_bus_freeze NULL
210 #define scsi_bus_thaw NULL
211 #define scsi_bus_poweroff NULL
212 #define scsi_bus_restore NULL
214 #endif /* CONFIG_PM_SLEEP */
216 static int sdev_runtime_suspend(struct device
*dev
)
218 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
219 struct scsi_device
*sdev
= to_scsi_device(dev
);
222 if (pm
&& pm
->runtime_suspend
) {
223 err
= blk_pre_runtime_suspend(sdev
->request_queue
);
226 err
= pm
->runtime_suspend(dev
);
227 blk_post_runtime_suspend(sdev
->request_queue
, err
);
232 static int scsi_runtime_suspend(struct device
*dev
)
236 dev_dbg(dev
, "scsi_runtime_suspend\n");
237 if (scsi_is_sdev_device(dev
))
238 err
= sdev_runtime_suspend(dev
);
240 /* Insert hooks here for targets, hosts, and transport classes */
245 static int sdev_runtime_resume(struct device
*dev
)
247 struct scsi_device
*sdev
= to_scsi_device(dev
);
248 const struct dev_pm_ops
*pm
= dev
->driver
? dev
->driver
->pm
: NULL
;
251 if (pm
&& pm
->runtime_resume
) {
252 blk_pre_runtime_resume(sdev
->request_queue
);
253 err
= pm
->runtime_resume(dev
);
254 blk_post_runtime_resume(sdev
->request_queue
, err
);
259 static int scsi_runtime_resume(struct device
*dev
)
263 dev_dbg(dev
, "scsi_runtime_resume\n");
264 if (scsi_is_sdev_device(dev
))
265 err
= sdev_runtime_resume(dev
);
267 /* Insert hooks here for targets, hosts, and transport classes */
272 static int scsi_runtime_idle(struct device
*dev
)
274 dev_dbg(dev
, "scsi_runtime_idle\n");
276 /* Insert hooks here for targets, hosts, and transport classes */
278 if (scsi_is_sdev_device(dev
)) {
279 pm_runtime_mark_last_busy(dev
);
280 pm_runtime_autosuspend(dev
);
287 int scsi_autopm_get_device(struct scsi_device
*sdev
)
291 err
= pm_runtime_get_sync(&sdev
->sdev_gendev
);
292 if (err
< 0 && err
!=-EACCES
)
293 pm_runtime_put_sync(&sdev
->sdev_gendev
);
298 EXPORT_SYMBOL_GPL(scsi_autopm_get_device
);
300 void scsi_autopm_put_device(struct scsi_device
*sdev
)
302 pm_runtime_put_sync(&sdev
->sdev_gendev
);
304 EXPORT_SYMBOL_GPL(scsi_autopm_put_device
);
306 void scsi_autopm_get_target(struct scsi_target
*starget
)
308 pm_runtime_get_sync(&starget
->dev
);
311 void scsi_autopm_put_target(struct scsi_target
*starget
)
313 pm_runtime_put_sync(&starget
->dev
);
316 int scsi_autopm_get_host(struct Scsi_Host
*shost
)
320 err
= pm_runtime_get_sync(&shost
->shost_gendev
);
321 if (err
< 0 && err
!=-EACCES
)
322 pm_runtime_put_sync(&shost
->shost_gendev
);
328 void scsi_autopm_put_host(struct Scsi_Host
*shost
)
330 pm_runtime_put_sync(&shost
->shost_gendev
);
333 const struct dev_pm_ops scsi_bus_pm_ops
= {
334 .prepare
= scsi_bus_prepare
,
335 .suspend
= scsi_bus_suspend
,
336 .resume
= scsi_bus_resume
,
337 .freeze
= scsi_bus_freeze
,
338 .thaw
= scsi_bus_thaw
,
339 .poweroff
= scsi_bus_poweroff
,
340 .restore
= scsi_bus_restore
,
341 .runtime_suspend
= scsi_runtime_suspend
,
342 .runtime_resume
= scsi_runtime_resume
,
343 .runtime_idle
= scsi_runtime_idle
,