[linux.git] / drivers / scsi / scsi_pm.c

/*
 *	scsi_pm.c	Copyright (C) 2010 Alan Stern
 *
 *	SCSI dynamic Power Management
 *		Initial version: Alan Stern <[email protected]>
 */

#include <linux/pm_runtime.h>
#include <linux/export.h>
#include <linux/async.h>

#include <scsi/scsi.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_driver.h>
#include <scsi/scsi_host.h>

#include "scsi_priv.h"

#ifdef CONFIG_PM_SLEEP

static int do_scsi_suspend(struct device *dev, const struct dev_pm_ops *pm)
{
	return pm && pm->suspend ? pm->suspend(dev) : 0;
}

static int do_scsi_freeze(struct device *dev, const struct dev_pm_ops *pm)
{
	return pm && pm->freeze ? pm->freeze(dev) : 0;
}

static int do_scsi_poweroff(struct device *dev, const struct dev_pm_ops *pm)
{
	return pm && pm->poweroff ? pm->poweroff(dev) : 0;
}

static int do_scsi_resume(struct device *dev, const struct dev_pm_ops *pm)
{
	return pm && pm->resume ? pm->resume(dev) : 0;
}

static int do_scsi_thaw(struct device *dev, const struct dev_pm_ops *pm)
{
	return pm && pm->thaw ? pm->thaw(dev) : 0;
}

static int do_scsi_restore(struct device *dev, const struct dev_pm_ops *pm)
{
	return pm && pm->restore ? pm->restore(dev) : 0;
}

static int scsi_dev_type_suspend(struct device *dev,
		int (*cb)(struct device *, const struct dev_pm_ops *))
{
	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
	int err;

	/* flush pending in-flight resume operations, suspend is synchronous */
	async_synchronize_full_domain(&scsi_sd_pm_domain);

	err = scsi_device_quiesce(to_scsi_device(dev));
	if (err == 0) {
		err = cb(dev, pm);
		if (err)
			scsi_device_resume(to_scsi_device(dev));
	}
	dev_dbg(dev, "scsi suspend: %d\n", err);
	return err;
}

static int scsi_dev_type_resume(struct device *dev,
		int (*cb)(struct device *, const struct dev_pm_ops *))
{
	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
	int err = 0;

	err = cb(dev, pm);
	scsi_device_resume(to_scsi_device(dev));
	dev_dbg(dev, "scsi resume: %d\n", err);

	if (err == 0) {
		pm_runtime_disable(dev);
		pm_runtime_set_active(dev);
		pm_runtime_enable(dev);
	}

	return err;
}

static int
scsi_bus_suspend_common(struct device *dev,
		int (*cb)(struct device *, const struct dev_pm_ops *))
{
	int err = 0;

	if (scsi_is_sdev_device(dev)) {
		/*
		 * All the high-level SCSI drivers that implement runtime
		 * PM treat runtime suspend, system suspend, and system
		 * hibernate nearly identically. In all cases the requirements
		 * for runtime suspension are stricter.
		 */
		if (pm_runtime_suspended(dev))
			return 0;

		err = scsi_dev_type_suspend(dev, cb);
	}

	return err;
}

static void async_sdev_resume(void *dev, async_cookie_t cookie)
{
	scsi_dev_type_resume(dev, do_scsi_resume);
}

static void async_sdev_thaw(void *dev, async_cookie_t cookie)
{
	scsi_dev_type_resume(dev, do_scsi_thaw);
}

static void async_sdev_restore(void *dev, async_cookie_t cookie)
{
	scsi_dev_type_resume(dev, do_scsi_restore);
}

static int scsi_bus_resume_common(struct device *dev,
		int (*cb)(struct device *, const struct dev_pm_ops *))
{
	async_func_t fn;

	if (!scsi_is_sdev_device(dev))
		fn = NULL;
	else if (cb == do_scsi_resume)
		fn = async_sdev_resume;
	else if (cb == do_scsi_thaw)
		fn = async_sdev_thaw;
	else if (cb == do_scsi_restore)
		fn = async_sdev_restore;
	else
		fn = NULL;

	/*
	 * Forcibly set runtime PM status of request queue to "active" to
	 * make sure we can again get requests from the queue (see also
	 * blk_pm_peek_request()).
	 *
	 * The resume hook will correct runtime PM status of the disk.
	 */
	if (scsi_is_sdev_device(dev) && pm_runtime_suspended(dev))
		blk_set_runtime_active(to_scsi_device(dev)->request_queue);

	if (fn) {
		async_schedule_domain(fn, dev, &scsi_sd_pm_domain);

		/*
		 * If a user has disabled async probing a likely reason
		 * is due to a storage enclosure that does not inject
		 * staggered spin-ups.  For safety, make resume
		 * synchronous as well in that case.
		 */
		if (strncmp(scsi_scan_type, "async", 5) != 0)
			async_synchronize_full_domain(&scsi_sd_pm_domain);
	} else {
		pm_runtime_disable(dev);
		pm_runtime_set_active(dev);
		pm_runtime_enable(dev);
	}
	return 0;
}

static int scsi_bus_prepare(struct device *dev)
{
	if (scsi_is_sdev_device(dev)) {
		/* sd probing uses async_schedule.  Wait until it finishes. */
		async_synchronize_full_domain(&scsi_sd_probe_domain);

	} else if (scsi_is_host_device(dev)) {
		/* Wait until async scanning is finished */
		scsi_complete_async_scans();
	}
	return 0;
}

static int scsi_bus_suspend(struct device *dev)
{
	return scsi_bus_suspend_common(dev, do_scsi_suspend);
}

static int scsi_bus_resume(struct device *dev)
{
	return scsi_bus_resume_common(dev, do_scsi_resume);
}

static int scsi_bus_freeze(struct device *dev)
{
	return scsi_bus_suspend_common(dev, do_scsi_freeze);
}

static int scsi_bus_thaw(struct device *dev)
{
	return scsi_bus_resume_common(dev, do_scsi_thaw);
}

static int scsi_bus_poweroff(struct device *dev)
{
	return scsi_bus_suspend_common(dev, do_scsi_poweroff);
}

static int scsi_bus_restore(struct device *dev)
{
	return scsi_bus_resume_common(dev, do_scsi_restore);
}

#else /* CONFIG_PM_SLEEP */

#define scsi_bus_prepare		NULL
#define scsi_bus_suspend		NULL
#define scsi_bus_resume			NULL
#define scsi_bus_freeze			NULL
#define scsi_bus_thaw			NULL
#define scsi_bus_poweroff		NULL
#define scsi_bus_restore		NULL

#endif /* CONFIG_PM_SLEEP */

static int sdev_runtime_suspend(struct device *dev)
{
	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
	struct scsi_device *sdev = to_scsi_device(dev);
	int err = 0;

	err = blk_pre_runtime_suspend(sdev->request_queue);
	if (err)
		return err;
	if (pm && pm->runtime_suspend)
		err = pm->runtime_suspend(dev);
	blk_post_runtime_suspend(sdev->request_queue, err);

	return err;
}

static int scsi_runtime_suspend(struct device *dev)
{
	int err = 0;

	dev_dbg(dev, "scsi_runtime_suspend\n");
	if (scsi_is_sdev_device(dev))
		err = sdev_runtime_suspend(dev);

	/* Insert hooks here for targets, hosts, and transport classes */

	return err;
}

static int sdev_runtime_resume(struct device *dev)
{
	struct scsi_device *sdev = to_scsi_device(dev);
	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
	int err = 0;

	blk_pre_runtime_resume(sdev->request_queue);
	if (pm && pm->runtime_resume)
		err = pm->runtime_resume(dev);
	blk_post_runtime_resume(sdev->request_queue, err);

	return err;
}

static int scsi_runtime_resume(struct device *dev)
{
	int err = 0;

	dev_dbg(dev, "scsi_runtime_resume\n");
	if (scsi_is_sdev_device(dev))
		err = sdev_runtime_resume(dev);

	/* Insert hooks here for targets, hosts, and transport classes */

	return err;
}

static int scsi_runtime_idle(struct device *dev)
{
	dev_dbg(dev, "scsi_runtime_idle\n");

	/* Insert hooks here for targets, hosts, and transport classes */

	if (scsi_is_sdev_device(dev)) {
		pm_runtime_mark_last_busy(dev);
		pm_runtime_autosuspend(dev);
		return -EBUSY;
	}

	return 0;
}

int scsi_autopm_get_device(struct scsi_device *sdev)
{
	int	err;

	err = pm_runtime_get_sync(&sdev->sdev_gendev);
	if (err < 0 && err !=-EACCES)
		pm_runtime_put_sync(&sdev->sdev_gendev);
	else
		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);
	if (err < 0 && err !=-EACCES)
		pm_runtime_put_sync(&shost->shost_gendev);
	else
		err = 0;
	return err;
}

void scsi_autopm_put_host(struct Scsi_Host *shost)
{
	pm_runtime_put_sync(&shost->shost_gendev);
}

const struct dev_pm_ops scsi_bus_pm_ops = {
	.prepare =		scsi_bus_prepare,
	.suspend =		scsi_bus_suspend,
	.resume =		scsi_bus_resume,
	.freeze =		scsi_bus_freeze,
	.thaw =			scsi_bus_thaw,
	.poweroff =		scsi_bus_poweroff,
	.restore =		scsi_bus_restore,
	.runtime_suspend =	scsi_runtime_suspend,
	.runtime_resume =	scsi_runtime_resume,
	.runtime_idle =		scsi_runtime_idle,
};
Commit	Line	Data
db5bd1e0 AS	1	/*
	2	* scsi_pm.c Copyright (C) 2010 Alan Stern
	3	*
	4	* SCSI dynamic Power Management
	5	* Initial version: Alan Stern <[email protected]>
	6	*/
	7
	8	#include <linux/pm_runtime.h>
09703660	9	#include <linux/export.h>
fea6d607	10	#include <linux/async.h>
db5bd1e0 AS	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
6627b38f AL	19	#ifdef CONFIG_PM_SLEEP
6627b38f AL	20
3c31b52f	21	static int do_scsi_suspend(struct device dev, const struct dev_pm_ops pm)
db5bd1e0	22	{
3c31b52f DW	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;
db5bd1e0 AS	55	int err;
db5bd1e0 AS	56
3c31b52f DW	57	/* flush pending in-flight resume operations, suspend is synchronous */
	58	async_synchronize_full_domain(&scsi_sd_pm_domain);
	59
db5bd1e0 AS	60	err = scsi_device_quiesce(to_scsi_device(dev));
db5bd1e0 AS	61	if (err == 0) {
3c31b52f DW	62	err = cb(dev, pm);
	63	if (err)
	64	scsi_device_resume(to_scsi_device(dev));
db5bd1e0 AS	65	}
	66	dev_dbg(dev, "scsi suspend: %d\n", err);
	67	return err;
	68	}
	69
3c31b52f DW	70	static int scsi_dev_type_resume(struct device *dev,
3c31b52f DW	71	int (cb)(struct device , const struct dev_pm_ops *))
db5bd1e0	72	{
3c31b52f	73	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
db5bd1e0 AS	74	int err = 0;
db5bd1e0 AS	75
3c31b52f	76	err = cb(dev, pm);
db5bd1e0 AS	77	scsi_device_resume(to_scsi_device(dev));
db5bd1e0 AS	78	dev_dbg(dev, "scsi resume: %d\n", err);
3c31b52f DW	79
	80	if (err == 0) {
	81	pm_runtime_disable(dev);
	82	pm_runtime_set_active(dev);
	83	pm_runtime_enable(dev);
	84	}
	85
db5bd1e0 AS	86	return err;
	87	}
	88
80d2fd48	89	static int
3c31b52f DW	90	scsi_bus_suspend_common(struct device *dev,
3c31b52f DW	91	int (cb)(struct device , const struct dev_pm_ops *))
db5bd1e0 AS	92	{
	93	int err = 0;
	94
28640516 LM	95	if (scsi_is_sdev_device(dev)) {
28640516 LM	96	/*
80d2fd48 AL	97	* All the high-level SCSI drivers that implement runtime
80d2fd48 AL	98	* PM treat runtime suspend, system suspend, and system
95897910 ON	99	* hibernate nearly identically. In all cases the requirements
95897910 ON	100	* for runtime suspension are stricter.
28640516	101	*/
80d2fd48 AL	102	if (pm_runtime_suspended(dev))
80d2fd48 AL	103	return 0;
28640516	104
80d2fd48	105	err = scsi_dev_type_suspend(dev, cb);
28640516	106	}
80d2fd48	107
db5bd1e0 AS	108	return err;
	109	}
	110
3c31b52f	111	static void async_sdev_resume(void *dev, async_cookie_t cookie)
db5bd1e0	112	{
3c31b52f DW	113	scsi_dev_type_resume(dev, do_scsi_resume);
3c31b52f DW	114	}
db5bd1e0	115
3c31b52f DW	116	static void async_sdev_thaw(void *dev, async_cookie_t cookie)
	117	{
	118	scsi_dev_type_resume(dev, do_scsi_thaw);
	119	}
63347905	120
3c31b52f DW	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
356fd266 MW	142	/*
	143	* Forcibly set runtime PM status of request queue to "active" to
	144	* make sure we can again get requests from the queue (see also
	145	* blk_pm_peek_request()).
	146	*
	147	* The resume hook will correct runtime PM status of the disk.
	148	*/
	149	if (scsi_is_sdev_device(dev) && pm_runtime_suspended(dev))
	150	blk_set_runtime_active(to_scsi_device(dev)->request_queue);
	151
3c31b52f DW	152	if (fn) {
	153	async_schedule_domain(fn, dev, &scsi_sd_pm_domain);
	154
	155	/*
	156	* If a user has disabled async probing a likely reason
	157	* is due to a storage enclosure that does not inject
	158	* staggered spin-ups. For safety, make resume
	159	* synchronous as well in that case.
	160	*/
	161	if (strncmp(scsi_scan_type, "async", 5) != 0)
	162	async_synchronize_full_domain(&scsi_sd_pm_domain);
	163	} else {
bc4f2401 AS	164	pm_runtime_disable(dev);
	165	pm_runtime_set_active(dev);
	166	pm_runtime_enable(dev);
	167	}
3c31b52f	168	return 0;
db5bd1e0 AS	169	}
db5bd1e0 AS	170
fea6d607 AS	171	static int scsi_bus_prepare(struct device *dev)
	172	{
	173	if (scsi_is_sdev_device(dev)) {
	174	/* sd probing uses async_schedule. Wait until it finishes. */
a7a20d10	175	async_synchronize_full_domain(&scsi_sd_probe_domain);
fea6d607 AS	176
	177	} else if (scsi_is_host_device(dev)) {
	178	/* Wait until async scanning is finished */
	179	scsi_complete_async_scans();
	180	}
	181	return 0;
	182	}
	183
db5bd1e0 AS	184	static int scsi_bus_suspend(struct device *dev)
db5bd1e0 AS	185	{
3c31b52f	186	return scsi_bus_suspend_common(dev, do_scsi_suspend);
80d2fd48 AL	187	}
	188
	189	static int scsi_bus_resume(struct device *dev)
	190	{
3c31b52f	191	return scsi_bus_resume_common(dev, do_scsi_resume);
db5bd1e0 AS	192	}
	193
	194	static int scsi_bus_freeze(struct device *dev)
	195	{
3c31b52f	196	return scsi_bus_suspend_common(dev, do_scsi_freeze);
80d2fd48 AL	197	}
	198
	199	static int scsi_bus_thaw(struct device *dev)
	200	{
3c31b52f	201	return scsi_bus_resume_common(dev, do_scsi_thaw);
db5bd1e0 AS	202	}
	203
	204	static int scsi_bus_poweroff(struct device *dev)
	205	{
3c31b52f	206	return scsi_bus_suspend_common(dev, do_scsi_poweroff);
80d2fd48 AL	207	}
	208
	209	static int scsi_bus_restore(struct device *dev)
	210	{
3c31b52f	211	return scsi_bus_resume_common(dev, do_scsi_restore);
db5bd1e0 AS	212	}
	213
	214	#else /* CONFIG_PM_SLEEP */
	215
fea6d607	216	#define scsi_bus_prepare NULL
db5bd1e0	217	#define scsi_bus_suspend NULL
80d2fd48	218	#define scsi_bus_resume NULL
db5bd1e0	219	#define scsi_bus_freeze NULL
80d2fd48	220	#define scsi_bus_thaw NULL
db5bd1e0	221	#define scsi_bus_poweroff NULL
80d2fd48	222	#define scsi_bus_restore NULL
db5bd1e0 AS	223
	224	#endif /* CONFIG_PM_SLEEP */
	225
6627b38f	226	static int sdev_runtime_suspend(struct device *dev)
6df339a5	227	{
6627b38f AL	228	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
6627b38f AL	229	struct scsi_device *sdev = to_scsi_device(dev);
49718f0f	230	int err = 0;
6df339a5	231
1c69d3b6 KX	232	err = blk_pre_runtime_suspend(sdev->request_queue);
	233	if (err)
	234	return err;
	235	if (pm && pm->runtime_suspend)
6627b38f	236	err = pm->runtime_suspend(dev);
1c69d3b6 KX	237	blk_post_runtime_suspend(sdev->request_queue, err);
1c69d3b6 KX	238
6df339a5 LM	239	return err;
	240	}
	241
bc4f2401 AS	242	static int scsi_runtime_suspend(struct device *dev)
	243	{
	244	int err = 0;
	245
	246	dev_dbg(dev, "scsi_runtime_suspend\n");
6df339a5 LM	247	if (scsi_is_sdev_device(dev))
6df339a5 LM	248	err = sdev_runtime_suspend(dev);
bc4f2401 AS	249
	250	/* Insert hooks here for targets, hosts, and transport classes */
	251
	252	return err;
	253	}
	254
6627b38f	255	static int sdev_runtime_resume(struct device *dev)
bc4f2401	256	{
6627b38f AL	257	struct scsi_device *sdev = to_scsi_device(dev);
6627b38f AL	258	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
bc4f2401	259	int err = 0;
6df339a5	260
1c69d3b6 KX	261	blk_pre_runtime_resume(sdev->request_queue);
1c69d3b6 KX	262	if (pm && pm->runtime_resume)
6627b38f	263	err = pm->runtime_resume(dev);
1c69d3b6 KX	264	blk_post_runtime_resume(sdev->request_queue, err);
1c69d3b6 KX	265
6df339a5 LM	266	return err;
	267	}
	268
6df339a5 LM	269	static int scsi_runtime_resume(struct device *dev)
	270	{
	271	int err = 0;
bc4f2401 AS	272
	273	dev_dbg(dev, "scsi_runtime_resume\n");
	274	if (scsi_is_sdev_device(dev))
6df339a5	275	err = sdev_runtime_resume(dev);
bc4f2401 AS	276
	277	/* Insert hooks here for targets, hosts, and transport classes */
	278
	279	return err;
	280	}
	281
	282	static int scsi_runtime_idle(struct device *dev)
	283	{
bc4f2401 AS	284	dev_dbg(dev, "scsi_runtime_idle\n");
	285
	286	/* Insert hooks here for targets, hosts, and transport classes */
	287
6df339a5	288	if (scsi_is_sdev_device(dev)) {
6627b38f AL	289	pm_runtime_mark_last_busy(dev);
	290	pm_runtime_autosuspend(dev);
	291	return -EBUSY;
6df339a5	292	}
6627b38f	293
45f0a85c	294	return 0;
bc4f2401 AS	295	}
	296
	297	int scsi_autopm_get_device(struct scsi_device *sdev)
	298	{
	299	int err;
	300
	301	err = pm_runtime_get_sync(&sdev->sdev_gendev);
632e270e	302	if (err < 0 && err !=-EACCES)
bc4f2401	303	pm_runtime_put_sync(&sdev->sdev_gendev);
632e270e	304	else
bc4f2401 AS	305	err = 0;
	306	return err;
	307	}
	308	EXPORT_SYMBOL_GPL(scsi_autopm_get_device);
	309
	310	void scsi_autopm_put_device(struct scsi_device *sdev)
	311	{
	312	pm_runtime_put_sync(&sdev->sdev_gendev);
	313	}
	314	EXPORT_SYMBOL_GPL(scsi_autopm_put_device);
	315
	316	void scsi_autopm_get_target(struct scsi_target *starget)
	317	{
	318	pm_runtime_get_sync(&starget->dev);
	319	}
	320
	321	void scsi_autopm_put_target(struct scsi_target *starget)
	322	{
	323	pm_runtime_put_sync(&starget->dev);
	324	}
	325
	326	int scsi_autopm_get_host(struct Scsi_Host *shost)
	327	{
	328	int err;
	329
	330	err = pm_runtime_get_sync(&shost->shost_gendev);
632e270e	331	if (err < 0 && err !=-EACCES)
bc4f2401	332	pm_runtime_put_sync(&shost->shost_gendev);
632e270e	333	else
bc4f2401 AS	334	err = 0;
	335	return err;
	336	}
	337
	338	void scsi_autopm_put_host(struct Scsi_Host *shost)
	339	{
	340	pm_runtime_put_sync(&shost->shost_gendev);
	341	}
	342
db5bd1e0	343	const struct dev_pm_ops scsi_bus_pm_ops = {
fea6d607	344	.prepare = scsi_bus_prepare,
db5bd1e0	345	.suspend = scsi_bus_suspend,
80d2fd48	346	.resume = scsi_bus_resume,
db5bd1e0	347	.freeze = scsi_bus_freeze,
80d2fd48	348	.thaw = scsi_bus_thaw,
db5bd1e0	349	.poweroff = scsi_bus_poweroff,
80d2fd48	350	.restore = scsi_bus_restore,
bc4f2401 AS	351	.runtime_suspend = scsi_runtime_suspend,
	352	.runtime_resume = scsi_runtime_resume,
	353	.runtime_idle = scsi_runtime_idle,
db5bd1e0	354	};