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 19 #ifdef CONFIG_PM_SLEEP 20 21 static int do_scsi_suspend(struct device *dev, const struct dev_pm_ops *pm) 22 { 23 return pm && pm->suspend ? pm->suspend(dev) : 0; 24 } 25 26 static int do_scsi_freeze(struct device *dev, const struct dev_pm_ops *pm) 27 { 28 return pm && pm->freeze ? pm->freeze(dev) : 0; 29 } 30 31 static int do_scsi_poweroff(struct device *dev, const struct dev_pm_ops *pm) 32 { 33 return pm && pm->poweroff ? pm->poweroff(dev) : 0; 34 } 35 36 static int do_scsi_resume(struct device *dev, const struct dev_pm_ops *pm) 37 { 38 return pm && pm->resume ? pm->resume(dev) : 0; 39 } 40 41 static int do_scsi_thaw(struct device *dev, const struct dev_pm_ops *pm) 42 { 43 return pm && pm->thaw ? pm->thaw(dev) : 0; 44 } 45 46 static int do_scsi_restore(struct device *dev, const struct dev_pm_ops *pm) 47 { 48 return pm && pm->restore ? pm->restore(dev) : 0; 49 } 50 51 static int scsi_dev_type_suspend(struct device *dev, 52 int (*cb)(struct device *, const struct dev_pm_ops *)) 53 { 54 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 55 int err; 56 57 /* flush pending in-flight resume operations, suspend is synchronous */ 58 async_synchronize_full_domain(&scsi_sd_pm_domain); 59 60 err = scsi_device_quiesce(to_scsi_device(dev)); 61 if (err == 0) { 62 err = cb(dev, pm); 63 if (err) 64 scsi_device_resume(to_scsi_device(dev)); 65 } 66 dev_dbg(dev, "scsi suspend: %d\n", err); 67 return err; 68 } 69 70 static int scsi_dev_type_resume(struct device *dev, 71 int (*cb)(struct device *, const struct dev_pm_ops *)) 72 { 73 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 74 int err = 0; 75 76 err = cb(dev, pm); 77 scsi_device_resume(to_scsi_device(dev)); 78 dev_dbg(dev, "scsi resume: %d\n", err); 79 80 if (err == 0) { 81 pm_runtime_disable(dev); 82 pm_runtime_set_active(dev); 83 pm_runtime_enable(dev); 84 } 85 86 return err; 87 } 88 89 static int 90 scsi_bus_suspend_common(struct device *dev, 91 int (*cb)(struct device *, const struct dev_pm_ops *)) 92 { 93 int err = 0; 94 95 if (scsi_is_sdev_device(dev)) { 96 /* 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. 101 */ 102 if (pm_runtime_suspended(dev)) 103 return 0; 104 105 err = scsi_dev_type_suspend(dev, cb); 106 } 107 108 return err; 109 } 110 111 static void async_sdev_resume(void *dev, async_cookie_t cookie) 112 { 113 scsi_dev_type_resume(dev, do_scsi_resume); 114 } 115 116 static void async_sdev_thaw(void *dev, async_cookie_t cookie) 117 { 118 scsi_dev_type_resume(dev, do_scsi_thaw); 119 } 120 121 static void async_sdev_restore(void *dev, async_cookie_t cookie) 122 { 123 scsi_dev_type_resume(dev, do_scsi_restore); 124 } 125 126 static int scsi_bus_resume_common(struct device *dev, 127 int (*cb)(struct device *, const struct dev_pm_ops *)) 128 { 129 async_func_t fn; 130 131 if (!scsi_is_sdev_device(dev)) 132 fn = NULL; 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; 139 else 140 fn = NULL; 141 142 if (fn) { 143 async_schedule_domain(fn, dev, &scsi_sd_pm_domain); 144 145 /* 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. 150 */ 151 if (strncmp(scsi_scan_type, "async", 5) != 0) 152 async_synchronize_full_domain(&scsi_sd_pm_domain); 153 } else { 154 pm_runtime_disable(dev); 155 pm_runtime_set_active(dev); 156 pm_runtime_enable(dev); 157 } 158 return 0; 159 } 160 161 static int scsi_bus_prepare(struct device *dev) 162 { 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); 166 167 } else if (scsi_is_host_device(dev)) { 168 /* Wait until async scanning is finished */ 169 scsi_complete_async_scans(); 170 } 171 return 0; 172 } 173 174 static int scsi_bus_suspend(struct device *dev) 175 { 176 return scsi_bus_suspend_common(dev, do_scsi_suspend); 177 } 178 179 static int scsi_bus_resume(struct device *dev) 180 { 181 return scsi_bus_resume_common(dev, do_scsi_resume); 182 } 183 184 static int scsi_bus_freeze(struct device *dev) 185 { 186 return scsi_bus_suspend_common(dev, do_scsi_freeze); 187 } 188 189 static int scsi_bus_thaw(struct device *dev) 190 { 191 return scsi_bus_resume_common(dev, do_scsi_thaw); 192 } 193 194 static int scsi_bus_poweroff(struct device *dev) 195 { 196 return scsi_bus_suspend_common(dev, do_scsi_poweroff); 197 } 198 199 static int scsi_bus_restore(struct device *dev) 200 { 201 return scsi_bus_resume_common(dev, do_scsi_restore); 202 } 203 204 #else /* CONFIG_PM_SLEEP */ 205 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 213 214 #endif /* CONFIG_PM_SLEEP */ 215 216 static int sdev_runtime_suspend(struct device *dev) 217 { 218 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 219 struct scsi_device *sdev = to_scsi_device(dev); 220 int err; 221 222 err = blk_pre_runtime_suspend(sdev->request_queue); 223 if (err) 224 return err; 225 if (pm && pm->runtime_suspend) 226 err = pm->runtime_suspend(dev); 227 blk_post_runtime_suspend(sdev->request_queue, err); 228 229 return err; 230 } 231 232 static int scsi_runtime_suspend(struct device *dev) 233 { 234 int err = 0; 235 236 dev_dbg(dev, "scsi_runtime_suspend\n"); 237 if (scsi_is_sdev_device(dev)) 238 err = sdev_runtime_suspend(dev); 239 240 /* Insert hooks here for targets, hosts, and transport classes */ 241 242 return err; 243 } 244 245 static int sdev_runtime_resume(struct device *dev) 246 { 247 struct scsi_device *sdev = to_scsi_device(dev); 248 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; 249 int err = 0; 250 251 blk_pre_runtime_resume(sdev->request_queue); 252 if (pm && pm->runtime_resume) 253 err = pm->runtime_resume(dev); 254 blk_post_runtime_resume(sdev->request_queue, err); 255 256 return err; 257 } 258 259 static int scsi_runtime_resume(struct device *dev) 260 { 261 int err = 0; 262 263 dev_dbg(dev, "scsi_runtime_resume\n"); 264 if (scsi_is_sdev_device(dev)) 265 err = sdev_runtime_resume(dev); 266 267 /* Insert hooks here for targets, hosts, and transport classes */ 268 269 return err; 270 } 271 272 static int scsi_runtime_idle(struct device *dev) 273 { 274 dev_dbg(dev, "scsi_runtime_idle\n"); 275 276 /* Insert hooks here for targets, hosts, and transport classes */ 277 278 if (scsi_is_sdev_device(dev)) { 279 pm_runtime_mark_last_busy(dev); 280 pm_runtime_autosuspend(dev); 281 return -EBUSY; 282 } 283 284 return 0; 285 } 286 287 int scsi_autopm_get_device(struct scsi_device *sdev) 288 { 289 int err; 290 291 err = pm_runtime_get_sync(&sdev->sdev_gendev); 292 if (err < 0 && err !=-EACCES) 293 pm_runtime_put_sync(&sdev->sdev_gendev); 294 else 295 err = 0; 296 return err; 297 } 298 EXPORT_SYMBOL_GPL(scsi_autopm_get_device); 299 300 void scsi_autopm_put_device(struct scsi_device *sdev) 301 { 302 pm_runtime_put_sync(&sdev->sdev_gendev); 303 } 304 EXPORT_SYMBOL_GPL(scsi_autopm_put_device); 305 306 void scsi_autopm_get_target(struct scsi_target *starget) 307 { 308 pm_runtime_get_sync(&starget->dev); 309 } 310 311 void scsi_autopm_put_target(struct scsi_target *starget) 312 { 313 pm_runtime_put_sync(&starget->dev); 314 } 315 316 int scsi_autopm_get_host(struct Scsi_Host *shost) 317 { 318 int err; 319 320 err = pm_runtime_get_sync(&shost->shost_gendev); 321 if (err < 0 && err !=-EACCES) 322 pm_runtime_put_sync(&shost->shost_gendev); 323 else 324 err = 0; 325 return err; 326 } 327 328 void scsi_autopm_put_host(struct Scsi_Host *shost) 329 { 330 pm_runtime_put_sync(&shost->shost_gendev); 331 } 332 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, 344 }; 345