[deliverable/linux.git] / drivers / base / power / generic_ops.c

/*
 * drivers/base/power/generic_ops.c - Generic PM callbacks for subsystems
 *
 * Copyright (c) 2010 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
 *
 * This file is released under the GPLv2.
 */

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

#ifdef CONFIG_PM_RUNTIME
/**
 * pm_generic_runtime_idle - Generic runtime idle callback for subsystems.
 * @dev: Device to handle.
 *
 * If PM operations are defined for the @dev's driver and they include
 * ->runtime_idle(), execute it and return its error code, if nonzero.
 * Otherwise, execute pm_runtime_suspend() for the device and return 0.
 */
int pm_generic_runtime_idle(struct device *dev)
{
	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

	if (pm && pm->runtime_idle) {
		int ret = pm->runtime_idle(dev);
		if (ret)
			return ret;
	}

	pm_runtime_suspend(dev);
	return 0;
}
EXPORT_SYMBOL_GPL(pm_generic_runtime_idle);

/**
 * pm_generic_runtime_suspend - Generic runtime suspend callback for subsystems.
 * @dev: Device to suspend.
 *
 * If PM operations are defined for the @dev's driver and they include
 * ->runtime_suspend(), execute it and return its error code.  Otherwise,
 * return 0.
 */
int pm_generic_runtime_suspend(struct device *dev)
{
	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
	int ret;

	ret = pm && pm->runtime_suspend ? pm->runtime_suspend(dev) : 0;

	return ret;
}
EXPORT_SYMBOL_GPL(pm_generic_runtime_suspend);

/**
 * pm_generic_runtime_resume - Generic runtime resume callback for subsystems.
 * @dev: Device to resume.
 *
 * If PM operations are defined for the @dev's driver and they include
 * ->runtime_resume(), execute it and return its error code.  Otherwise,
 * return 0.
 */
int pm_generic_runtime_resume(struct device *dev)
{
	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
	int ret;

	ret = pm && pm->runtime_resume ? pm->runtime_resume(dev) : 0;

	return ret;
}
EXPORT_SYMBOL_GPL(pm_generic_runtime_resume);
#endif /* CONFIG_PM_RUNTIME */

#ifdef CONFIG_PM_SLEEP
/**
 * pm_generic_prepare - Generic routine preparing a device for power transition.
 * @dev: Device to prepare.
 *
 * Prepare a device for a system-wide power transition.
 */
int pm_generic_prepare(struct device *dev)
{
	struct device_driver *drv = dev->driver;
	int ret = 0;

	if (drv && drv->pm && drv->pm->prepare)
		ret = drv->pm->prepare(dev);

	return ret;
}

/**
 * __pm_generic_call - Generic suspend/freeze/poweroff/thaw subsystem callback.
 * @dev: Device to handle.
 * @event: PM transition of the system under way.
 * @bool: Whether or not this is the "noirq" stage.
 *
 * Execute the PM callback corresponding to @event provided by the driver of
 * @dev, if defined, and return its error code.    Return 0 if the callback is
 * not present.
 */
static int __pm_generic_call(struct device *dev, int event, bool noirq)
{
	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
	int (*callback)(struct device *);

	if (!pm)
		return 0;

	switch (event) {
	case PM_EVENT_SUSPEND:
		callback = noirq ? pm->suspend_noirq : pm->suspend;
		break;
	case PM_EVENT_FREEZE:
		callback = noirq ? pm->freeze_noirq : pm->freeze;
		break;
	case PM_EVENT_HIBERNATE:
		callback = noirq ? pm->poweroff_noirq : pm->poweroff;
		break;
	case PM_EVENT_RESUME:
		callback = noirq ? pm->resume_noirq : pm->resume;
		break;
	case PM_EVENT_THAW:
		callback = noirq ? pm->thaw_noirq : pm->thaw;
		break;
	case PM_EVENT_RESTORE:
		callback = noirq ? pm->restore_noirq : pm->restore;
		break;
	default:
		callback = NULL;
		break;
	}

	return callback ? callback(dev) : 0;
}

/**
 * pm_generic_suspend_noirq - Generic suspend_noirq callback for subsystems.
 * @dev: Device to suspend.
 */
int pm_generic_suspend_noirq(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_SUSPEND, true);
}
EXPORT_SYMBOL_GPL(pm_generic_suspend_noirq);

/**
 * pm_generic_suspend - Generic suspend callback for subsystems.
 * @dev: Device to suspend.
 */
int pm_generic_suspend(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_SUSPEND, false);
}
EXPORT_SYMBOL_GPL(pm_generic_suspend);

/**
 * pm_generic_freeze_noirq - Generic freeze_noirq callback for subsystems.
 * @dev: Device to freeze.
 */
int pm_generic_freeze_noirq(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_FREEZE, true);
}
EXPORT_SYMBOL_GPL(pm_generic_freeze_noirq);

/**
 * pm_generic_freeze - Generic freeze callback for subsystems.
 * @dev: Device to freeze.
 */
int pm_generic_freeze(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_FREEZE, false);
}
EXPORT_SYMBOL_GPL(pm_generic_freeze);

/**
 * pm_generic_poweroff_noirq - Generic poweroff_noirq callback for subsystems.
 * @dev: Device to handle.
 */
int pm_generic_poweroff_noirq(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_HIBERNATE, true);
}
EXPORT_SYMBOL_GPL(pm_generic_poweroff_noirq);

/**
 * pm_generic_poweroff - Generic poweroff callback for subsystems.
 * @dev: Device to handle.
 */
int pm_generic_poweroff(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_HIBERNATE, false);
}
EXPORT_SYMBOL_GPL(pm_generic_poweroff);

/**
 * pm_generic_thaw_noirq - Generic thaw_noirq callback for subsystems.
 * @dev: Device to thaw.
 */
int pm_generic_thaw_noirq(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_THAW, true);
}
EXPORT_SYMBOL_GPL(pm_generic_thaw_noirq);

/**
 * pm_generic_thaw - Generic thaw callback for subsystems.
 * @dev: Device to thaw.
 */
int pm_generic_thaw(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_THAW, false);
}
EXPORT_SYMBOL_GPL(pm_generic_thaw);

/**
 * pm_generic_resume_noirq - Generic resume_noirq callback for subsystems.
 * @dev: Device to resume.
 */
int pm_generic_resume_noirq(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_RESUME, true);
}
EXPORT_SYMBOL_GPL(pm_generic_resume_noirq);

/**
 * pm_generic_resume - Generic resume callback for subsystems.
 * @dev: Device to resume.
 */
int pm_generic_resume(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_RESUME, false);
}
EXPORT_SYMBOL_GPL(pm_generic_resume);

/**
 * pm_generic_restore_noirq - Generic restore_noirq callback for subsystems.
 * @dev: Device to restore.
 */
int pm_generic_restore_noirq(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_RESTORE, true);
}
EXPORT_SYMBOL_GPL(pm_generic_restore_noirq);

/**
 * pm_generic_restore - Generic restore callback for subsystems.
 * @dev: Device to restore.
 */
int pm_generic_restore(struct device *dev)
{
	return __pm_generic_call(dev, PM_EVENT_RESTORE, false);
}
EXPORT_SYMBOL_GPL(pm_generic_restore);

/**
 * pm_generic_complete - Generic routine competing a device power transition.
 * @dev: Device to handle.
 *
 * Complete a device power transition during a system-wide power transition.
 */
void pm_generic_complete(struct device *dev)
{
	struct device_driver *drv = dev->driver;

	if (drv && drv->pm && drv->pm->complete)
		drv->pm->complete(dev);

	/*
	 * Let runtime PM try to suspend devices that haven't been in use before
	 * going into the system-wide sleep state we're resuming from.
	 */
	pm_runtime_idle(dev);
}
#endif /* CONFIG_PM_SLEEP */
Commit	Line	Data
d690b2cd RW	1	/*
	2	* drivers/base/power/generic_ops.c - Generic PM callbacks for subsystems
	3	*
	4	* Copyright (c) 2010 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
	5	*
	6	* This file is released under the GPLv2.
	7	*/
	8
	9	#include <linux/pm.h>
	10	#include <linux/pm_runtime.h>
1b6bc32f	11	#include <linux/export.h>
d690b2cd RW	12
	13	#ifdef CONFIG_PM_RUNTIME
	14	/**
	15	* pm_generic_runtime_idle - Generic runtime idle callback for subsystems.
	16	* @dev: Device to handle.
	17	*
	18	* If PM operations are defined for the @dev's driver and they include
	19	* ->runtime_idle(), execute it and return its error code, if nonzero.
	20	* Otherwise, execute pm_runtime_suspend() for the device and return 0.
	21	*/
	22	int pm_generic_runtime_idle(struct device *dev)
	23	{
	24	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
	25
	26	if (pm && pm->runtime_idle) {
	27	int ret = pm->runtime_idle(dev);
	28	if (ret)
	29	return ret;
	30	}
	31
	32	pm_runtime_suspend(dev);
	33	return 0;
	34	}
	35	EXPORT_SYMBOL_GPL(pm_generic_runtime_idle);
	36
	37	/**
	38	* pm_generic_runtime_suspend - Generic runtime suspend callback for subsystems.
	39	* @dev: Device to suspend.
	40	*
	41	* If PM operations are defined for the @dev's driver and they include
	42	* ->runtime_suspend(), execute it and return its error code. Otherwise,
6675bc05	43	* return 0.
d690b2cd RW	44	*/
	45	int pm_generic_runtime_suspend(struct device *dev)
	46	{
	47	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
	48	int ret;
	49
05aa55dd	50	ret = pm && pm->runtime_suspend ? pm->runtime_suspend(dev) : 0;
d690b2cd RW	51
	52	return ret;
	53	}
	54	EXPORT_SYMBOL_GPL(pm_generic_runtime_suspend);
	55
	56	/**
	57	* pm_generic_runtime_resume - Generic runtime resume callback for subsystems.
	58	* @dev: Device to resume.
	59	*
	60	* If PM operations are defined for the @dev's driver and they include
	61	* ->runtime_resume(), execute it and return its error code. Otherwise,
6675bc05	62	* return 0.
d690b2cd RW	63	*/
	64	int pm_generic_runtime_resume(struct device *dev)
	65	{
	66	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
	67	int ret;
	68
05aa55dd	69	ret = pm && pm->runtime_resume ? pm->runtime_resume(dev) : 0;
d690b2cd RW	70
	71	return ret;
	72	}
	73	EXPORT_SYMBOL_GPL(pm_generic_runtime_resume);
	74	#endif /* CONFIG_PM_RUNTIME */
	75
	76	#ifdef CONFIG_PM_SLEEP
6538df80 RW	77	/**
	78	* pm_generic_prepare - Generic routine preparing a device for power transition.
	79	* @dev: Device to prepare.
	80	*
	81	* Prepare a device for a system-wide power transition.
	82	*/
	83	int pm_generic_prepare(struct device *dev)
	84	{
	85	struct device_driver *drv = dev->driver;
	86	int ret = 0;
	87
	88	if (drv && drv->pm && drv->pm->prepare)
	89	ret = drv->pm->prepare(dev);
	90
	91	return ret;
	92	}
	93
d690b2cd RW	94	/**
	95	* __pm_generic_call - Generic suspend/freeze/poweroff/thaw subsystem callback.
	96	* @dev: Device to handle.
	97	* @event: PM transition of the system under way.
e5291928	98	* @bool: Whether or not this is the "noirq" stage.
d690b2cd	99	*
1eac8111	100	* Execute the PM callback corresponding to @event provided by the driver of
8ca6d9bc RW	101	* @dev, if defined, and return its error code. Return 0 if the callback is
8ca6d9bc RW	102	* not present.
d690b2cd	103	*/
e5291928	104	static int __pm_generic_call(struct device *dev, int event, bool noirq)
d690b2cd RW	105	{
	106	const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
	107	int (callback)(struct device );
	108
8ca6d9bc	109	if (!pm)
d690b2cd RW	110	return 0;
	111
	112	switch (event) {
	113	case PM_EVENT_SUSPEND:
e5291928	114	callback = noirq ? pm->suspend_noirq : pm->suspend;
d690b2cd RW	115	break;
d690b2cd RW	116	case PM_EVENT_FREEZE:
e5291928	117	callback = noirq ? pm->freeze_noirq : pm->freeze;
d690b2cd RW	118	break;
d690b2cd RW	119	case PM_EVENT_HIBERNATE:
e5291928	120	callback = noirq ? pm->poweroff_noirq : pm->poweroff;
d690b2cd	121	break;
1eac8111 RW	122	case PM_EVENT_RESUME:
	123	callback = noirq ? pm->resume_noirq : pm->resume;
	124	break;
d690b2cd	125	case PM_EVENT_THAW:
e5291928	126	callback = noirq ? pm->thaw_noirq : pm->thaw;
d690b2cd	127	break;
1eac8111 RW	128	case PM_EVENT_RESTORE:
	129	callback = noirq ? pm->restore_noirq : pm->restore;
	130	break;
d690b2cd RW	131	default:
	132	callback = NULL;
	133	break;
	134	}
	135
	136	return callback ? callback(dev) : 0;
	137	}
	138
e5291928 RW	139	/**
	140	* pm_generic_suspend_noirq - Generic suspend_noirq callback for subsystems.
	141	* @dev: Device to suspend.
	142	*/
	143	int pm_generic_suspend_noirq(struct device *dev)
	144	{
	145	return __pm_generic_call(dev, PM_EVENT_SUSPEND, true);
	146	}
	147	EXPORT_SYMBOL_GPL(pm_generic_suspend_noirq);
	148
d690b2cd RW	149	/**
	150	* pm_generic_suspend - Generic suspend callback for subsystems.
	151	* @dev: Device to suspend.
	152	*/
	153	int pm_generic_suspend(struct device *dev)
	154	{
e5291928	155	return __pm_generic_call(dev, PM_EVENT_SUSPEND, false);
d690b2cd RW	156	}
	157	EXPORT_SYMBOL_GPL(pm_generic_suspend);
	158
e5291928 RW	159	/**
	160	* pm_generic_freeze_noirq - Generic freeze_noirq callback for subsystems.
	161	* @dev: Device to freeze.
	162	*/
	163	int pm_generic_freeze_noirq(struct device *dev)
	164	{
	165	return __pm_generic_call(dev, PM_EVENT_FREEZE, true);
	166	}
	167	EXPORT_SYMBOL_GPL(pm_generic_freeze_noirq);
	168
d690b2cd RW	169	/**
	170	* pm_generic_freeze - Generic freeze callback for subsystems.
	171	* @dev: Device to freeze.
	172	*/
	173	int pm_generic_freeze(struct device *dev)
	174	{
e5291928	175	return __pm_generic_call(dev, PM_EVENT_FREEZE, false);
d690b2cd RW	176	}
	177	EXPORT_SYMBOL_GPL(pm_generic_freeze);
	178
e5291928 RW	179	/**
	180	* pm_generic_poweroff_noirq - Generic poweroff_noirq callback for subsystems.
	181	* @dev: Device to handle.
	182	*/
	183	int pm_generic_poweroff_noirq(struct device *dev)
	184	{
	185	return __pm_generic_call(dev, PM_EVENT_HIBERNATE, true);
	186	}
	187	EXPORT_SYMBOL_GPL(pm_generic_poweroff_noirq);
	188
d690b2cd RW	189	/**
	190	* pm_generic_poweroff - Generic poweroff callback for subsystems.
	191	* @dev: Device to handle.
	192	*/
	193	int pm_generic_poweroff(struct device *dev)
	194	{
e5291928	195	return __pm_generic_call(dev, PM_EVENT_HIBERNATE, false);
d690b2cd RW	196	}
	197	EXPORT_SYMBOL_GPL(pm_generic_poweroff);
	198
e5291928 RW	199	/**
	200	* pm_generic_thaw_noirq - Generic thaw_noirq callback for subsystems.
	201	* @dev: Device to thaw.
	202	*/
	203	int pm_generic_thaw_noirq(struct device *dev)
	204	{
	205	return __pm_generic_call(dev, PM_EVENT_THAW, true);
	206	}
	207	EXPORT_SYMBOL_GPL(pm_generic_thaw_noirq);
	208
d690b2cd RW	209	/**
	210	* pm_generic_thaw - Generic thaw callback for subsystems.
	211	* @dev: Device to thaw.
	212	*/
	213	int pm_generic_thaw(struct device *dev)
	214	{
e5291928	215	return __pm_generic_call(dev, PM_EVENT_THAW, false);
d690b2cd RW	216	}
	217	EXPORT_SYMBOL_GPL(pm_generic_thaw);
	218
e5291928 RW	219	/**
	220	* pm_generic_resume_noirq - Generic resume_noirq callback for subsystems.
	221	* @dev: Device to resume.
	222	*/
	223	int pm_generic_resume_noirq(struct device *dev)
	224	{
1eac8111	225	return __pm_generic_call(dev, PM_EVENT_RESUME, true);
e5291928 RW	226	}
	227	EXPORT_SYMBOL_GPL(pm_generic_resume_noirq);
	228
d690b2cd RW	229	/**
	230	* pm_generic_resume - Generic resume callback for subsystems.
	231	* @dev: Device to resume.
	232	*/
	233	int pm_generic_resume(struct device *dev)
	234	{
1eac8111	235	return __pm_generic_call(dev, PM_EVENT_RESUME, false);
d690b2cd RW	236	}
	237	EXPORT_SYMBOL_GPL(pm_generic_resume);
	238
e5291928 RW	239	/**
	240	* pm_generic_restore_noirq - Generic restore_noirq callback for subsystems.
	241	* @dev: Device to restore.
	242	*/
	243	int pm_generic_restore_noirq(struct device *dev)
	244	{
1eac8111	245	return __pm_generic_call(dev, PM_EVENT_RESTORE, true);
e5291928 RW	246	}
	247	EXPORT_SYMBOL_GPL(pm_generic_restore_noirq);
	248
d690b2cd RW	249	/**
	250	* pm_generic_restore - Generic restore callback for subsystems.
	251	* @dev: Device to restore.
	252	*/
	253	int pm_generic_restore(struct device *dev)
	254	{
1eac8111	255	return __pm_generic_call(dev, PM_EVENT_RESTORE, false);
d690b2cd RW	256	}
d690b2cd RW	257	EXPORT_SYMBOL_GPL(pm_generic_restore);
6538df80 RW	258
	259	/**
	260	* pm_generic_complete - Generic routine competing a device power transition.
	261	* @dev: Device to handle.
	262	*
	263	* Complete a device power transition during a system-wide power transition.
	264	*/
	265	void pm_generic_complete(struct device *dev)
	266	{
	267	struct device_driver *drv = dev->driver;
	268
	269	if (drv && drv->pm && drv->pm->complete)
	270	drv->pm->complete(dev);
	271
	272	/*
	273	* Let runtime PM try to suspend devices that haven't been in use before
	274	* going into the system-wide sleep state we're resuming from.
	275	*/
	276	pm_runtime_idle(dev);
	277	}
d690b2cd	278	#endif /* CONFIG_PM_SLEEP */