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 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 104 static int 105 scsi_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 126 static void async_sdev_resume(void *dev, async_cookie_t cookie) 127 { 128 scsi_dev_type_resume(dev, do_scsi_resume); 129 } 130 131 static void async_sdev_thaw(void *dev, async_cookie_t cookie) 132 { 133 scsi_dev_type_resume(dev, do_scsi_thaw); 134 } 135 136 static void async_sdev_restore(void *dev, async_cookie_t cookie) 137 { 138 scsi_dev_type_resume(dev, do_scsi_restore); 139 } 140 141 static 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 176 static 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 189 static int scsi_bus_suspend(struct device *dev) 190 { 191 return scsi_bus_suspend_common(dev, do_scsi_suspend); 192 } 193 194 static int scsi_bus_resume(struct device *dev) 195 { 196 return scsi_bus_resume_common(dev, do_scsi_resume); 197 } 198 199 static int scsi_bus_freeze(struct device *dev) 200 { 201 return scsi_bus_suspend_common(dev, do_scsi_freeze); 202 } 203 204 static int scsi_bus_thaw(struct device *dev) 205 { 206 return scsi_bus_resume_common(dev, do_scsi_thaw); 207 } 208 209 static int scsi_bus_poweroff(struct device *dev) 210 { 211 return scsi_bus_suspend_common(dev, do_scsi_poweroff); 212 } 213 214 static 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 231 static 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 247 static 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 260 static 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 274 static 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 287 static 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 302 int 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 } 313 EXPORT_SYMBOL_GPL(scsi_autopm_get_device); 314 315 void scsi_autopm_put_device(struct scsi_device *sdev) 316 { 317 pm_runtime_put_sync(&sdev->sdev_gendev); 318 } 319 EXPORT_SYMBOL_GPL(scsi_autopm_put_device); 320 321 void scsi_autopm_get_target(struct scsi_target *starget) 322 { 323 pm_runtime_get_sync(&starget->dev); 324 } 325 326 void scsi_autopm_put_target(struct scsi_target *starget) 327 { 328 pm_runtime_put_sync(&starget->dev); 329 } 330 331 int 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 343 void scsi_autopm_put_host(struct Scsi_Host *shost) 344 { 345 pm_runtime_put_sync(&shost->shost_gendev); 346 } 347 348 const 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