drivers/scsi/scsi_pm.c

   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 static int scsi_dev_type_suspend(struct device *dev, pm_message_t msg)
  20 {
  21         struct device_driver *drv;
  22         int err;
  23
  24         err = scsi_device_quiesce(to_scsi_device(dev));
  25         if (err == 0) {
  26                 drv = dev->driver;
  27                 if (drv && drv->suspend) {
  28                         err = drv->suspend(dev, msg);
  29                         if (err)
  30                                 scsi_device_resume(to_scsi_device(dev));
  31                 }
  32         }
  33         dev_dbg(dev, "scsi suspend: %d\n", err);
  34         return err;
  35 }
  36
  37 static int scsi_dev_type_resume(struct device *dev)
  38 {
  39         struct device_driver *drv;
  40         int err = 0;
  41
  42         drv = dev->driver;
  43         if (drv && drv->resume)
  44                 err = drv->resume(dev);
  45         scsi_device_resume(to_scsi_device(dev));
  46         dev_dbg(dev, "scsi resume: %d\n", err);
  47         return err;
  48 }
  49
  50 #ifdef CONFIG_PM_SLEEP
  51
  52 static int scsi_bus_suspend_common(struct device *dev, pm_message_t msg)
  53 {
  54         int err = 0;
  55
  56         if (scsi_is_sdev_device(dev)) {
  57                 /*
  58                  * sd is the only high-level SCSI driver to implement runtime
  59                  * PM, and sd treats runtime suspend, system suspend, and
  60                  * system hibernate identically (but not system freeze).
  61                  */
  62                 if (pm_runtime_suspended(dev)) {
  63                         if (msg.event == PM_EVENT_SUSPEND ||
  64                             msg.event == PM_EVENT_HIBERNATE)
  65                                 return 0;       /* already suspended */
  66
  67                         /* wake up device so that FREEZE will succeed */
  68                         pm_runtime_resume(dev);
  69                 }
  70                 err = scsi_dev_type_suspend(dev, msg);
  71         }
  72         return err;
  73 }
  74
  75 static int scsi_bus_resume_common(struct device *dev)
  76 {
  77         int err = 0;
  78
  79         if (scsi_is_sdev_device(dev)) {
  80                 /*
  81                  * Parent device may have runtime suspended as soon as
  82                  * it is woken up during the system resume.
  83                  *
  84                  * Resume it on behalf of child.
  85                  */
  86                 pm_runtime_get_sync(dev->parent);
  87                 err = scsi_dev_type_resume(dev);
  88                 pm_runtime_put_sync(dev->parent);
  89         }
  90
  91         if (err == 0) {
  92                 pm_runtime_disable(dev);
  93                 pm_runtime_set_active(dev);
  94                 pm_runtime_enable(dev);
  95         }
  96         return err;
  97 }
  98
  99 static int scsi_bus_prepare(struct device *dev)
 100 {
 101         if (scsi_is_sdev_device(dev)) {
 102                 /* sd probing uses async_schedule.  Wait until it finishes. */
 103                 async_synchronize_full_domain(&scsi_sd_probe_domain);
 104
 105         } else if (scsi_is_host_device(dev)) {
 106                 /* Wait until async scanning is finished */
 107                 scsi_complete_async_scans();
 108         }
 109         return 0;
 110 }
 111
 112 static int scsi_bus_suspend(struct device *dev)
 113 {
 114         return scsi_bus_suspend_common(dev, PMSG_SUSPEND);
 115 }
 116
 117 static int scsi_bus_freeze(struct device *dev)
 118 {
 119         return scsi_bus_suspend_common(dev, PMSG_FREEZE);
 120 }
 121
 122 static int scsi_bus_poweroff(struct device *dev)
 123 {
 124         return scsi_bus_suspend_common(dev, PMSG_HIBERNATE);
 125 }
 126
 127 #else /* CONFIG_PM_SLEEP */
 128
 129 #define scsi_bus_resume_common          NULL
 130 #define scsi_bus_prepare                NULL
 131 #define scsi_bus_suspend                NULL
 132 #define scsi_bus_freeze                 NULL
 133 #define scsi_bus_poweroff               NULL
 134
 135 #endif /* CONFIG_PM_SLEEP */
 136
 137 #ifdef CONFIG_PM_RUNTIME
 138
 139 static int scsi_runtime_suspend(struct device *dev)
 140 {
 141         int err = 0;
 142
 143         dev_dbg(dev, "scsi_runtime_suspend\n");
 144         if (scsi_is_sdev_device(dev)) {
 145                 err = scsi_dev_type_suspend(dev, PMSG_AUTO_SUSPEND);
 146                 if (err == -EAGAIN)
 147                         pm_schedule_suspend(dev, jiffies_to_msecs(
 148                                 round_jiffies_up_relative(HZ/10)));
 149         }
 150
 151         /* Insert hooks here for targets, hosts, and transport classes */
 152
 153         return err;
 154 }
 155
 156 static int scsi_runtime_resume(struct device *dev)
 157 {
 158         int err = 0;
 159
 160         dev_dbg(dev, "scsi_runtime_resume\n");
 161         if (scsi_is_sdev_device(dev))
 162                 err = scsi_dev_type_resume(dev);
 163
 164         /* Insert hooks here for targets, hosts, and transport classes */
 165
 166         return err;
 167 }
 168
 169 static int scsi_runtime_idle(struct device *dev)
 170 {
 171         int err;
 172
 173         dev_dbg(dev, "scsi_runtime_idle\n");
 174
 175         /* Insert hooks here for targets, hosts, and transport classes */
 176
 177         if (scsi_is_sdev_device(dev))
 178                 err = pm_schedule_suspend(dev, 100);
 179         else
 180                 err = pm_runtime_suspend(dev);
 181         return err;
 182 }
 183
 184 int scsi_autopm_get_device(struct scsi_device *sdev)
 185 {
 186         int     err;
 187
 188         err = pm_runtime_get_sync(&sdev->sdev_gendev);
 189         if (err < 0 && err !=-EACCES)
 190                 pm_runtime_put_sync(&sdev->sdev_gendev);
 191         else
 192                 err = 0;
 193         return err;
 194 }
 195 EXPORT_SYMBOL_GPL(scsi_autopm_get_device);
 196
 197 void scsi_autopm_put_device(struct scsi_device *sdev)
 198 {
 199         pm_runtime_put_sync(&sdev->sdev_gendev);
 200 }
 201 EXPORT_SYMBOL_GPL(scsi_autopm_put_device);
 202
 203 void scsi_autopm_get_target(struct scsi_target *starget)
 204 {
 205         pm_runtime_get_sync(&starget->dev);
 206 }
 207
 208 void scsi_autopm_put_target(struct scsi_target *starget)
 209 {
 210         pm_runtime_put_sync(&starget->dev);
 211 }
 212
 213 int scsi_autopm_get_host(struct Scsi_Host *shost)
 214 {
 215         int     err;
 216
 217         err = pm_runtime_get_sync(&shost->shost_gendev);
 218         if (err < 0 && err !=-EACCES)
 219                 pm_runtime_put_sync(&shost->shost_gendev);
 220         else
 221                 err = 0;
 222         return err;
 223 }
 224
 225 void scsi_autopm_put_host(struct Scsi_Host *shost)
 226 {
 227         pm_runtime_put_sync(&shost->shost_gendev);
 228 }
 229
 230 #else
 231
 232 #define scsi_runtime_suspend    NULL
 233 #define scsi_runtime_resume     NULL
 234 #define scsi_runtime_idle       NULL
 235
 236 #endif /* CONFIG_PM_RUNTIME */
 237
 238 const struct dev_pm_ops scsi_bus_pm_ops = {
 239         .prepare =              scsi_bus_prepare,
 240         .suspend =              scsi_bus_suspend,
 241         .resume =               scsi_bus_resume_common,
 242         .freeze =               scsi_bus_freeze,
 243         .thaw =                 scsi_bus_resume_common,
 244         .poweroff =             scsi_bus_poweroff,
 245         .restore =              scsi_bus_resume_common,
 246         .runtime_suspend =      scsi_runtime_suspend,
 247         .runtime_resume =       scsi_runtime_resume,
 248         .runtime_idle =         scsi_runtime_idle,
 249 };