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