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

/*
 *	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>
#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"

static int scsi_dev_type_suspend(struct device *dev, pm_message_t msg)
{
	struct device_driver *drv;
	int err;

	err = scsi_device_quiesce(to_scsi_device(dev));
	if (err == 0) {
		drv = dev->driver;
		if (drv && drv->suspend) {
			err = drv->suspend(dev, msg);
			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)
{
	struct device_driver *drv;
	int err = 0;

	drv = dev->driver;
	if (drv && drv->resume)
		err = drv->resume(dev);
	scsi_device_resume(to_scsi_device(dev));
	dev_dbg(dev, "scsi resume: %d\n", err);
	return err;
}

#ifdef CONFIG_PM_SLEEP

static int scsi_bus_suspend_common(struct device *dev, pm_message_t msg)
{
	int err = 0;

	if (scsi_is_sdev_device(dev)) {
		/*
		 * sd is the only high-level SCSI driver to implement runtime
		 * PM, and sd treats runtime suspend, system suspend, and
		 * system hibernate identically (but not system freeze).
		 */
		if (pm_runtime_suspended(dev)) {
			if (msg.event == PM_EVENT_SUSPEND ||
			    msg.event == PM_EVENT_HIBERNATE)
				return 0;	/* already suspended */

			/* wake up device so that FREEZE will succeed */
			pm_runtime_resume(dev);
		}
		err = scsi_dev_type_suspend(dev, msg);
	}
	return err;
}

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

	if (scsi_is_sdev_device(dev)) {
		/*
		 * Parent device may have runtime suspended as soon as
		 * it is woken up during the system resume.
		 *
		 * Resume it on behalf of child.
		 */
		pm_runtime_get_sync(dev->parent);
		err = scsi_dev_type_resume(dev);
		pm_runtime_put_sync(dev->parent);
	}

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

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, PMSG_SUSPEND);
}

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

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

#else /* CONFIG_PM_SLEEP */

#define scsi_bus_resume_common		NULL
#define scsi_bus_prepare		NULL
#define scsi_bus_suspend		NULL
#define scsi_bus_freeze			NULL
#define scsi_bus_poweroff		NULL

#endif /* CONFIG_PM_SLEEP */

#ifdef CONFIG_PM_RUNTIME

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 = scsi_dev_type_suspend(dev, PMSG_AUTO_SUSPEND);
		if (err == -EAGAIN)
			pm_schedule_suspend(dev, jiffies_to_msecs(
				round_jiffies_up_relative(HZ/10)));
	}

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

	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 = scsi_dev_type_resume(dev);

	/* 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 */

	if (scsi_is_sdev_device(dev))
		err = pm_schedule_suspend(dev, 100);
	else
		err = pm_runtime_suspend(dev);
	return err;
}

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);
}

#else

#define scsi_runtime_suspend	NULL
#define scsi_runtime_resume	NULL
#define scsi_runtime_idle	NULL

#endif /* CONFIG_PM_RUNTIME */

const struct dev_pm_ops scsi_bus_pm_ops = {
	.prepare =		scsi_bus_prepare,
	.suspend =		scsi_bus_suspend,
	.resume =		scsi_bus_resume_common,
	.freeze =		scsi_bus_freeze,
	.thaw =			scsi_bus_resume_common,
	.poweroff =		scsi_bus_poweroff,
	.restore =		scsi_bus_resume_common,
	.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 <stern@rowland.harvard.edu>
	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
	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;
d20ec597	27	if (drv && drv->suspend) {
db5bd1e0	28	err = drv->suspend(dev, msg);
d20ec597 AL	29	if (err)
	30	scsi_device_resume(to_scsi_device(dev));
	31	}
db5bd1e0 AS	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
28640516 LM	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	}
db5bd1e0	70	err = scsi_dev_type_suspend(dev, msg);
28640516	71	}
db5bd1e0 AS	72	return err;
	73	}
	74
	75	static int scsi_bus_resume_common(struct device *dev)
	76	{
	77	int err = 0;
	78
28fd00d4 LM	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);
db5bd1e0	87	err = scsi_dev_type_resume(dev);
28fd00d4 LM	88	pm_runtime_put_sync(dev->parent);
28fd00d4 LM	89	}
bc4f2401 AS	90
	91	if (err == 0) {
	92	pm_runtime_disable(dev);
	93	pm_runtime_set_active(dev);
	94	pm_runtime_enable(dev);
	95	}
db5bd1e0 AS	96	return err;
	97	}
	98
fea6d607 AS	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. */
a7a20d10	103	async_synchronize_full_domain(&scsi_sd_probe_domain);
fea6d607 AS	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
db5bd1e0 AS	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
fea6d607	130	#define scsi_bus_prepare NULL
db5bd1e0 AS	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
bc4f2401 AS	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);
632e270e	189	if (err < 0 && err !=-EACCES)
bc4f2401	190	pm_runtime_put_sync(&sdev->sdev_gendev);
632e270e	191	else
bc4f2401 AS	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);
632e270e	218	if (err < 0 && err !=-EACCES)
bc4f2401	219	pm_runtime_put_sync(&shost->shost_gendev);
632e270e	220	else
bc4f2401 AS	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
db5bd1e0	238	const struct dev_pm_ops scsi_bus_pm_ops = {
fea6d607	239	.prepare = scsi_bus_prepare,
db5bd1e0 AS	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,
bc4f2401 AS	246	.runtime_suspend = scsi_runtime_suspend,
	247	.runtime_resume = scsi_runtime_resume,
	248	.runtime_idle = scsi_runtime_idle,
db5bd1e0	249	};