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