2010-06-17 08:36:49 -06:00
|
|
|
/*
|
|
|
|
|
* scsi_pm.c Copyright (C) 2010 Alan Stern
|
|
|
|
|
*
|
|
|
|
|
* SCSI dynamic Power Management
|
|
|
|
|
* Initial version: Alan Stern <stern@rowland.harvard.edu>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/pm_runtime.h>
|
2011-05-27 07:37:25 -06:00
|
|
|
#include <linux/export.h>
|
[SCSI] scsi_pm: Fix bug in the SCSI power management handler
This patch (as1520) fixes a bug in the SCSI layer's power management
implementation.
LUN scanning can be carried out asynchronously in do_scan_async(), and
sd uses an asynchronous thread for the time-consuming parts of disk
probing in sd_probe_async(). Currently nothing coordinates these
async threads with system sleep transitions; they can and do attempt
to continue scanning/probing SCSI devices even after the host adapter
has been suspended. As one might expect, the outcome is not ideal.
This is what the "prepare" stage of system suspend was created for.
After the prepare callback has been called for a host, target, or
device, drivers are not allowed to register any children underneath
them. Currently the SCSI prepare callback is not implemented; this
patch rectifies that omission.
For SCSI hosts, the prepare routine calls scsi_complete_async_scans()
to wait until async scanning is finished. It might be slightly more
efficient to wait only until the host in question has been scanned,
but there's currently no way to do that. Besides, during a sleep
transition we will ultimately have to wait until all the host scanning
has finished anyway.
For SCSI devices, the prepare routine calls async_synchronize_full()
to wait until sd probing is finished. The routine does nothing for
SCSI targets, because asynchronous target scanning is done only as
part of host scanning.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
CC: <stable@kernel.org>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2012-02-17 14:25:08 -07:00
|
|
|
#include <linux/async.h>
|
2010-06-17 08:36:49 -06:00
|
|
|
|
|
|
|
|
#include <scsi/scsi.h>
|
|
|
|
|
#include <scsi/scsi_device.h>
|
|
|
|
|
#include <scsi/scsi_driver.h>
|
|
|
|
|
#include <scsi/scsi_host.h>
|
|
|
|
|
|
|
|
|
|
#include "scsi_priv.h"
|
|
|
|
|
|
2012-11-09 00:27:54 -07:00
|
|
|
static int scsi_dev_type_suspend(struct device *dev, int (*cb)(struct device *))
|
2010-06-17 08:36:49 -06:00
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
err = scsi_device_quiesce(to_scsi_device(dev));
|
|
|
|
|
if (err == 0) {
|
2012-11-09 00:27:54 -07:00
|
|
|
if (cb) {
|
|
|
|
|
err = cb(dev);
|
2012-05-15 00:43:00 -06:00
|
|
|
if (err)
|
|
|
|
|
scsi_device_resume(to_scsi_device(dev));
|
|
|
|
|
}
|
2010-06-17 08:36:49 -06:00
|
|
|
}
|
|
|
|
|
dev_dbg(dev, "scsi suspend: %d\n", err);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-09 00:27:54 -07:00
|
|
|
static int scsi_dev_type_resume(struct device *dev, int (*cb)(struct device *))
|
2010-06-17 08:36:49 -06:00
|
|
|
{
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
2012-11-09 00:27:54 -07:00
|
|
|
if (cb)
|
|
|
|
|
err = cb(dev);
|
2010-06-17 08:36:49 -06:00
|
|
|
scsi_device_resume(to_scsi_device(dev));
|
|
|
|
|
dev_dbg(dev, "scsi resume: %d\n", err);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
|
|
2012-11-09 00:27:54 -07:00
|
|
|
static int
|
|
|
|
|
scsi_bus_suspend_common(struct device *dev, int (*cb)(struct device *))
|
2010-06-17 08:36:49 -06:00
|
|
|
{
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
2011-12-04 18:20:25 -07:00
|
|
|
if (scsi_is_sdev_device(dev)) {
|
|
|
|
|
/*
|
2012-11-09 00:27:54 -07:00
|
|
|
* All the high-level SCSI drivers that implement runtime
|
|
|
|
|
* PM treat runtime suspend, system suspend, and system
|
|
|
|
|
* hibernate identically.
|
2011-12-04 18:20:25 -07:00
|
|
|
*/
|
2012-11-09 00:27:54 -07:00
|
|
|
if (pm_runtime_suspended(dev))
|
|
|
|
|
return 0;
|
2011-12-04 18:20:25 -07:00
|
|
|
|
2012-11-09 00:27:54 -07:00
|
|
|
err = scsi_dev_type_suspend(dev, cb);
|
2011-12-04 18:20:25 -07:00
|
|
|
}
|
2012-11-09 00:27:54 -07:00
|
|
|
|
2010-06-17 08:36:49 -06:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-09 00:27:54 -07:00
|
|
|
static int
|
|
|
|
|
scsi_bus_resume_common(struct device *dev, int (*cb)(struct device *))
|
2010-06-17 08:36:49 -06:00
|
|
|
{
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
2012-11-09 00:27:53 -07:00
|
|
|
if (scsi_is_sdev_device(dev))
|
2012-11-09 00:27:54 -07:00
|
|
|
err = scsi_dev_type_resume(dev, cb);
|
2012-11-09 00:27:52 -07:00
|
|
|
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
if (err == 0) {
|
|
|
|
|
pm_runtime_disable(dev);
|
|
|
|
|
pm_runtime_set_active(dev);
|
|
|
|
|
pm_runtime_enable(dev);
|
|
|
|
|
}
|
2010-06-17 08:36:49 -06:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] scsi_pm: Fix bug in the SCSI power management handler
This patch (as1520) fixes a bug in the SCSI layer's power management
implementation.
LUN scanning can be carried out asynchronously in do_scan_async(), and
sd uses an asynchronous thread for the time-consuming parts of disk
probing in sd_probe_async(). Currently nothing coordinates these
async threads with system sleep transitions; they can and do attempt
to continue scanning/probing SCSI devices even after the host adapter
has been suspended. As one might expect, the outcome is not ideal.
This is what the "prepare" stage of system suspend was created for.
After the prepare callback has been called for a host, target, or
device, drivers are not allowed to register any children underneath
them. Currently the SCSI prepare callback is not implemented; this
patch rectifies that omission.
For SCSI hosts, the prepare routine calls scsi_complete_async_scans()
to wait until async scanning is finished. It might be slightly more
efficient to wait only until the host in question has been scanned,
but there's currently no way to do that. Besides, during a sleep
transition we will ultimately have to wait until all the host scanning
has finished anyway.
For SCSI devices, the prepare routine calls async_synchronize_full()
to wait until sd probing is finished. The routine does nothing for
SCSI targets, because asynchronous target scanning is done only as
part of host scanning.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
CC: <stable@kernel.org>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2012-02-17 14:25:08 -07:00
|
|
|
static int scsi_bus_prepare(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
if (scsi_is_sdev_device(dev)) {
|
|
|
|
|
/* sd probing uses async_schedule. Wait until it finishes. */
|
2012-03-22 18:05:11 -06:00
|
|
|
async_synchronize_full_domain(&scsi_sd_probe_domain);
|
[SCSI] scsi_pm: Fix bug in the SCSI power management handler
This patch (as1520) fixes a bug in the SCSI layer's power management
implementation.
LUN scanning can be carried out asynchronously in do_scan_async(), and
sd uses an asynchronous thread for the time-consuming parts of disk
probing in sd_probe_async(). Currently nothing coordinates these
async threads with system sleep transitions; they can and do attempt
to continue scanning/probing SCSI devices even after the host adapter
has been suspended. As one might expect, the outcome is not ideal.
This is what the "prepare" stage of system suspend was created for.
After the prepare callback has been called for a host, target, or
device, drivers are not allowed to register any children underneath
them. Currently the SCSI prepare callback is not implemented; this
patch rectifies that omission.
For SCSI hosts, the prepare routine calls scsi_complete_async_scans()
to wait until async scanning is finished. It might be slightly more
efficient to wait only until the host in question has been scanned,
but there's currently no way to do that. Besides, during a sleep
transition we will ultimately have to wait until all the host scanning
has finished anyway.
For SCSI devices, the prepare routine calls async_synchronize_full()
to wait until sd probing is finished. The routine does nothing for
SCSI targets, because asynchronous target scanning is done only as
part of host scanning.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
CC: <stable@kernel.org>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2012-02-17 14:25:08 -07:00
|
|
|
|
|
|
|
|
} else if (scsi_is_host_device(dev)) {
|
|
|
|
|
/* Wait until async scanning is finished */
|
|
|
|
|
scsi_complete_async_scans();
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-17 08:36:49 -06:00
|
|
|
static int scsi_bus_suspend(struct device *dev)
|
|
|
|
|
{
|
2012-11-09 00:27:54 -07:00
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
|
|
|
|
return scsi_bus_suspend_common(dev, pm ? pm->suspend : NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int scsi_bus_resume(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
|
|
|
|
return scsi_bus_resume_common(dev, pm ? pm->resume : NULL);
|
2010-06-17 08:36:49 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int scsi_bus_freeze(struct device *dev)
|
|
|
|
|
{
|
2012-11-09 00:27:54 -07:00
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
|
|
|
|
return scsi_bus_suspend_common(dev, pm ? pm->freeze : NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int scsi_bus_thaw(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
|
|
|
|
return scsi_bus_resume_common(dev, pm ? pm->thaw : NULL);
|
2010-06-17 08:36:49 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int scsi_bus_poweroff(struct device *dev)
|
|
|
|
|
{
|
2012-11-09 00:27:54 -07:00
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
|
|
|
|
return scsi_bus_suspend_common(dev, pm ? pm->poweroff : NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int scsi_bus_restore(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
|
|
|
|
return scsi_bus_resume_common(dev, pm ? pm->restore : NULL);
|
2010-06-17 08:36:49 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else /* CONFIG_PM_SLEEP */
|
|
|
|
|
|
[SCSI] scsi_pm: Fix bug in the SCSI power management handler
This patch (as1520) fixes a bug in the SCSI layer's power management
implementation.
LUN scanning can be carried out asynchronously in do_scan_async(), and
sd uses an asynchronous thread for the time-consuming parts of disk
probing in sd_probe_async(). Currently nothing coordinates these
async threads with system sleep transitions; they can and do attempt
to continue scanning/probing SCSI devices even after the host adapter
has been suspended. As one might expect, the outcome is not ideal.
This is what the "prepare" stage of system suspend was created for.
After the prepare callback has been called for a host, target, or
device, drivers are not allowed to register any children underneath
them. Currently the SCSI prepare callback is not implemented; this
patch rectifies that omission.
For SCSI hosts, the prepare routine calls scsi_complete_async_scans()
to wait until async scanning is finished. It might be slightly more
efficient to wait only until the host in question has been scanned,
but there's currently no way to do that. Besides, during a sleep
transition we will ultimately have to wait until all the host scanning
has finished anyway.
For SCSI devices, the prepare routine calls async_synchronize_full()
to wait until sd probing is finished. The routine does nothing for
SCSI targets, because asynchronous target scanning is done only as
part of host scanning.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
CC: <stable@kernel.org>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2012-02-17 14:25:08 -07:00
|
|
|
#define scsi_bus_prepare NULL
|
2010-06-17 08:36:49 -06:00
|
|
|
#define scsi_bus_suspend NULL
|
2012-11-09 00:27:54 -07:00
|
|
|
#define scsi_bus_resume NULL
|
2010-06-17 08:36:49 -06:00
|
|
|
#define scsi_bus_freeze NULL
|
2012-11-09 00:27:54 -07:00
|
|
|
#define scsi_bus_thaw NULL
|
2010-06-17 08:36:49 -06:00
|
|
|
#define scsi_bus_poweroff NULL
|
2012-11-09 00:27:54 -07:00
|
|
|
#define scsi_bus_restore NULL
|
2010-06-17 08:36:49 -06:00
|
|
|
|
|
|
|
|
#endif /* CONFIG_PM_SLEEP */
|
|
|
|
|
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
#ifdef CONFIG_PM_RUNTIME
|
|
|
|
|
|
2013-03-22 21:42:28 -06:00
|
|
|
static int sdev_blk_runtime_suspend(struct scsi_device *sdev,
|
|
|
|
|
int (*cb)(struct device *))
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
err = blk_pre_runtime_suspend(sdev->request_queue);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
if (cb)
|
|
|
|
|
err = cb(&sdev->sdev_gendev);
|
|
|
|
|
blk_post_runtime_suspend(sdev->request_queue, err);
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int sdev_runtime_suspend(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
|
|
|
|
int (*cb)(struct device *) = pm ? pm->runtime_suspend : NULL;
|
|
|
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (sdev->request_queue->dev)
|
|
|
|
|
return sdev_blk_runtime_suspend(sdev, cb);
|
|
|
|
|
|
|
|
|
|
err = scsi_dev_type_suspend(dev, cb);
|
|
|
|
|
if (err == -EAGAIN)
|
|
|
|
|
pm_schedule_suspend(dev, jiffies_to_msecs(
|
|
|
|
|
round_jiffies_up_relative(HZ/10)));
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
static int scsi_runtime_suspend(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
dev_dbg(dev, "scsi_runtime_suspend\n");
|
2013-03-22 21:42:28 -06:00
|
|
|
if (scsi_is_sdev_device(dev))
|
|
|
|
|
err = sdev_runtime_suspend(dev);
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
|
|
|
|
|
/* Insert hooks here for targets, hosts, and transport classes */
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-22 21:42:28 -06:00
|
|
|
static int sdev_blk_runtime_resume(struct scsi_device *sdev,
|
|
|
|
|
int (*cb)(struct device *))
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
{
|
|
|
|
|
int err = 0;
|
2013-03-22 21:42:28 -06:00
|
|
|
|
|
|
|
|
blk_pre_runtime_resume(sdev->request_queue);
|
|
|
|
|
if (cb)
|
|
|
|
|
err = cb(&sdev->sdev_gendev);
|
|
|
|
|
blk_post_runtime_resume(sdev->request_queue, err);
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int sdev_runtime_resume(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
2012-11-09 00:27:54 -07:00
|
|
|
const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
|
2013-03-22 21:42:28 -06:00
|
|
|
int (*cb)(struct device *) = pm ? pm->runtime_resume : NULL;
|
|
|
|
|
|
|
|
|
|
if (sdev->request_queue->dev)
|
|
|
|
|
return sdev_blk_runtime_resume(sdev, cb);
|
|
|
|
|
else
|
|
|
|
|
return scsi_dev_type_resume(dev, cb);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int scsi_runtime_resume(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
int err = 0;
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
|
|
|
|
|
dev_dbg(dev, "scsi_runtime_resume\n");
|
|
|
|
|
if (scsi_is_sdev_device(dev))
|
2013-03-22 21:42:28 -06:00
|
|
|
err = sdev_runtime_resume(dev);
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
|
|
|
|
|
/* Insert hooks here for targets, hosts, and transport classes */
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int scsi_runtime_idle(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
dev_dbg(dev, "scsi_runtime_idle\n");
|
|
|
|
|
|
|
|
|
|
/* Insert hooks here for targets, hosts, and transport classes */
|
|
|
|
|
|
2013-03-22 21:42:28 -06:00
|
|
|
if (scsi_is_sdev_device(dev)) {
|
|
|
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
|
|
|
|
|
|
|
|
|
if (sdev->request_queue->dev) {
|
|
|
|
|
pm_runtime_mark_last_busy(dev);
|
|
|
|
|
err = pm_runtime_autosuspend(dev);
|
|
|
|
|
} else {
|
|
|
|
|
err = pm_runtime_suspend(dev);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
err = pm_runtime_suspend(dev);
|
2013-03-22 21:42:28 -06:00
|
|
|
}
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int scsi_autopm_get_device(struct scsi_device *sdev)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
err = pm_runtime_get_sync(&sdev->sdev_gendev);
|
2011-07-01 14:29:15 -06:00
|
|
|
if (err < 0 && err !=-EACCES)
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
pm_runtime_put_sync(&sdev->sdev_gendev);
|
2011-07-01 14:29:15 -06:00
|
|
|
else
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
err = 0;
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(scsi_autopm_get_device);
|
|
|
|
|
|
|
|
|
|
void scsi_autopm_put_device(struct scsi_device *sdev)
|
|
|
|
|
{
|
|
|
|
|
pm_runtime_put_sync(&sdev->sdev_gendev);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(scsi_autopm_put_device);
|
|
|
|
|
|
|
|
|
|
void scsi_autopm_get_target(struct scsi_target *starget)
|
|
|
|
|
{
|
|
|
|
|
pm_runtime_get_sync(&starget->dev);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void scsi_autopm_put_target(struct scsi_target *starget)
|
|
|
|
|
{
|
|
|
|
|
pm_runtime_put_sync(&starget->dev);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int scsi_autopm_get_host(struct Scsi_Host *shost)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
err = pm_runtime_get_sync(&shost->shost_gendev);
|
2011-07-01 14:29:15 -06:00
|
|
|
if (err < 0 && err !=-EACCES)
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
pm_runtime_put_sync(&shost->shost_gendev);
|
2011-07-01 14:29:15 -06:00
|
|
|
else
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
err = 0;
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void scsi_autopm_put_host(struct Scsi_Host *shost)
|
|
|
|
|
{
|
|
|
|
|
pm_runtime_put_sync(&shost->shost_gendev);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
#define scsi_runtime_suspend NULL
|
|
|
|
|
#define scsi_runtime_resume NULL
|
|
|
|
|
#define scsi_runtime_idle NULL
|
|
|
|
|
|
|
|
|
|
#endif /* CONFIG_PM_RUNTIME */
|
|
|
|
|
|
2010-06-17 08:36:49 -06:00
|
|
|
const struct dev_pm_ops scsi_bus_pm_ops = {
|
[SCSI] scsi_pm: Fix bug in the SCSI power management handler
This patch (as1520) fixes a bug in the SCSI layer's power management
implementation.
LUN scanning can be carried out asynchronously in do_scan_async(), and
sd uses an asynchronous thread for the time-consuming parts of disk
probing in sd_probe_async(). Currently nothing coordinates these
async threads with system sleep transitions; they can and do attempt
to continue scanning/probing SCSI devices even after the host adapter
has been suspended. As one might expect, the outcome is not ideal.
This is what the "prepare" stage of system suspend was created for.
After the prepare callback has been called for a host, target, or
device, drivers are not allowed to register any children underneath
them. Currently the SCSI prepare callback is not implemented; this
patch rectifies that omission.
For SCSI hosts, the prepare routine calls scsi_complete_async_scans()
to wait until async scanning is finished. It might be slightly more
efficient to wait only until the host in question has been scanned,
but there's currently no way to do that. Besides, during a sleep
transition we will ultimately have to wait until all the host scanning
has finished anyway.
For SCSI devices, the prepare routine calls async_synchronize_full()
to wait until sd probing is finished. The routine does nothing for
SCSI targets, because asynchronous target scanning is done only as
part of host scanning.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
CC: <stable@kernel.org>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
2012-02-17 14:25:08 -07:00
|
|
|
.prepare = scsi_bus_prepare,
|
2010-06-17 08:36:49 -06:00
|
|
|
.suspend = scsi_bus_suspend,
|
2012-11-09 00:27:54 -07:00
|
|
|
.resume = scsi_bus_resume,
|
2010-06-17 08:36:49 -06:00
|
|
|
.freeze = scsi_bus_freeze,
|
2012-11-09 00:27:54 -07:00
|
|
|
.thaw = scsi_bus_thaw,
|
2010-06-17 08:36:49 -06:00
|
|
|
.poweroff = scsi_bus_poweroff,
|
2012-11-09 00:27:54 -07:00
|
|
|
.restore = scsi_bus_restore,
|
[SCSI] implement runtime Power Management
This patch (as1398b) adds runtime PM support to the SCSI layer. Only
the machanism is provided; use of it is up to the various high-level
drivers, and the patch doesn't change any of them. Except for sg --
the patch expicitly prevents a device from being runtime-suspended
while its sg device file is open.
The implementation is simplistic. In general, hosts and targets are
automatically suspended when all their children are asleep, but for
them the runtime-suspend code doesn't actually do anything. (A host's
runtime PM status is propagated up the device tree, though, so a
runtime-PM-aware lower-level driver could power down the host adapter
hardware at the appropriate times.) There are comments indicating
where a transport class might be notified or some other hooks added.
LUNs are runtime-suspended by calling the drivers' existing suspend
handlers (and likewise for runtime-resume). Somewhat arbitrarily, the
implementation delays for 100 ms before suspending an eligible LUN.
This is because there typically are occasions during bootup when the
same device file is opened and closed several times in quick
succession.
The way this all works is that the SCSI core increments a device's
PM-usage count when it is registered. If a high-level driver does
nothing then the device will not be eligible for runtime-suspend
because of the elevated usage count. If a high-level driver wants to
use runtime PM then it can call scsi_autopm_put_device() in its probe
routine to decrement the usage count and scsi_autopm_get_device() in
its remove routine to restore the original count.
Hosts, targets, and LUNs are not suspended while they are being probed
or removed, or while the error handler is running. In fact, a fairly
large part of the patch consists of code to make sure that things
aren't suspended at such times.
[jejb: fix up compile issues in PM config variations]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@suse.de>
2010-06-17 08:41:42 -06:00
|
|
|
.runtime_suspend = scsi_runtime_suspend,
|
|
|
|
|
.runtime_resume = scsi_runtime_resume,
|
|
|
|
|
.runtime_idle = scsi_runtime_idle,
|
2010-06-17 08:36:49 -06:00
|
|
|
};
|