[net-next-2.6.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 <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);
	}
	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))
		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))
		err = scsi_dev_type_resume(dev);

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

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_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)
		pm_runtime_put_sync(&sdev->sdev_gendev);
	else if (err > 0)
		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)
		pm_runtime_put_sync(&shost->shost_gendev);
	else if (err > 0)
		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 = {
	.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>
	9
	10	#include <scsi/scsi.h>
	11	#include <scsi/scsi_device.h>
	12	#include <scsi/scsi_driver.h>
	13	#include <scsi/scsi_host.h>
	14
	15	#include "scsi_priv.h"
	16
	17	static int scsi_dev_type_suspend(struct device *dev, pm_message_t msg)
	18	{
	19	struct device_driver *drv;
	20	int err;
	21
	22	err = scsi_device_quiesce(to_scsi_device(dev));
	23	if (err == 0) {
	24	drv = dev->driver;
	25	if (drv && drv->suspend)
	26	err = drv->suspend(dev, msg);
	27	}
	28	dev_dbg(dev, "scsi suspend: %d\n", err);
	29	return err;
	30	}
	31
	32	static int scsi_dev_type_resume(struct device *dev)
	33	{
	34	struct device_driver *drv;
	35	int err = 0;
	36
	37	drv = dev->driver;
	38	if (drv && drv->resume)
	39	err = drv->resume(dev);
	40	scsi_device_resume(to_scsi_device(dev));
	41	dev_dbg(dev, "scsi resume: %d\n", err);
	42	return err;
	43	}
	44
	45	#ifdef CONFIG_PM_SLEEP
	46
	47	static int scsi_bus_suspend_common(struct device *dev, pm_message_t msg)
	48	{
	49	int err = 0;
	50
	51	if (scsi_is_sdev_device(dev))
	52	err = scsi_dev_type_suspend(dev, msg);
	53	return err;
	54	}
	55
	56	static int scsi_bus_resume_common(struct device *dev)
	57	{
	58	int err = 0;
	59
	60	if (scsi_is_sdev_device(dev))
	61	err = scsi_dev_type_resume(dev);
bc4f2401 AS	62
	63	if (err == 0) {
	64	pm_runtime_disable(dev);
	65	pm_runtime_set_active(dev);
	66	pm_runtime_enable(dev);
	67	}
db5bd1e0 AS	68	return err;
	69	}
	70
	71	static int scsi_bus_suspend(struct device *dev)
	72	{
	73	return scsi_bus_suspend_common(dev, PMSG_SUSPEND);
	74	}
	75
	76	static int scsi_bus_freeze(struct device *dev)
	77	{
	78	return scsi_bus_suspend_common(dev, PMSG_FREEZE);
	79	}
	80
	81	static int scsi_bus_poweroff(struct device *dev)
	82	{
	83	return scsi_bus_suspend_common(dev, PMSG_HIBERNATE);
	84	}
	85
	86	#else /* CONFIG_PM_SLEEP */
	87
	88	#define scsi_bus_resume_common NULL
	89	#define scsi_bus_suspend NULL
	90	#define scsi_bus_freeze NULL
	91	#define scsi_bus_poweroff NULL
	92
	93	#endif /* CONFIG_PM_SLEEP */
	94
bc4f2401 AS	95	#ifdef CONFIG_PM_RUNTIME
	96
	97	static int scsi_runtime_suspend(struct device *dev)
	98	{
	99	int err = 0;
	100
	101	dev_dbg(dev, "scsi_runtime_suspend\n");
	102	if (scsi_is_sdev_device(dev)) {
	103	err = scsi_dev_type_suspend(dev, PMSG_AUTO_SUSPEND);
	104	if (err == -EAGAIN)
	105	pm_schedule_suspend(dev, jiffies_to_msecs(
	106	round_jiffies_up_relative(HZ/10)));
	107	}
	108
	109	/* Insert hooks here for targets, hosts, and transport classes */
	110
	111	return err;
	112	}
	113
	114	static int scsi_runtime_resume(struct device *dev)
	115	{
	116	int err = 0;
	117
	118	dev_dbg(dev, "scsi_runtime_resume\n");
	119	if (scsi_is_sdev_device(dev))
	120	err = scsi_dev_type_resume(dev);
	121
	122	/* Insert hooks here for targets, hosts, and transport classes */
	123
	124	return err;
	125	}
	126
	127	static int scsi_runtime_idle(struct device *dev)
	128	{
	129	int err;
	130
	131	dev_dbg(dev, "scsi_runtime_idle\n");
	132
	133	/* Insert hooks here for targets, hosts, and transport classes */
	134
	135	if (scsi_is_sdev_device(dev))
	136	err = pm_schedule_suspend(dev, 100);
	137	else
	138	err = pm_runtime_suspend(dev);
	139	return err;
	140	}
	141
	142	int scsi_autopm_get_device(struct scsi_device *sdev)
	143	{
	144	int err;
	145
	146	err = pm_runtime_get_sync(&sdev->sdev_gendev);
	147	if (err < 0)
	148	pm_runtime_put_sync(&sdev->sdev_gendev);
	149	else if (err > 0)
	150	err = 0;
	151	return err;
	152	}
	153	EXPORT_SYMBOL_GPL(scsi_autopm_get_device);
	154
	155	void scsi_autopm_put_device(struct scsi_device *sdev)
	156	{
	157	pm_runtime_put_sync(&sdev->sdev_gendev);
	158	}
159	EXPORT_SYMBOL_GPL(scsi_autopm_put_device);
160
161	void scsi_autopm_get_target(struct scsi_target *starget)
162	{
163	pm_runtime_get_sync(&starget->dev);
164	}
165
166	void scsi_autopm_put_target(struct scsi_target *starget)
167	{
168	pm_runtime_put_sync(&starget->dev);
169	}
170
171	int scsi_autopm_get_host(struct Scsi_Host *shost)
172	{
173	int err;
174
175	err = pm_runtime_get_sync(&shost->shost_gendev);
176	if (err < 0)
177	pm_runtime_put_sync(&shost->shost_gendev);
178	else if (err > 0)
179	err = 0;
180	return err;
181	}
182
183	void scsi_autopm_put_host(struct Scsi_Host *shost)
184	{
185	pm_runtime_put_sync(&shost->shost_gendev);
186	}
187
188	#else
189
190	#define scsi_runtime_suspend NULL
191	#define scsi_runtime_resume NULL
192	#define scsi_runtime_idle NULL
193
194	#endif /* CONFIG_PM_RUNTIME */
195
db5bd1e0 AS	196	const struct dev_pm_ops scsi_bus_pm_ops = {
	197	.suspend = scsi_bus_suspend,
	198	.resume = scsi_bus_resume_common,
	199	.freeze = scsi_bus_freeze,
	200	.thaw = scsi_bus_resume_common,
	201	.poweroff = scsi_bus_poweroff,
	202	.restore = scsi_bus_resume_common,
bc4f2401 AS	203	.runtime_suspend = scsi_runtime_suspend,
	204	.runtime_resume = scsi_runtime_resume,
	205	.runtime_idle = scsi_runtime_idle,
db5bd1e0	206	};