[deliverable/linux.git] / drivers / cpuidle / driver.c

/*
 * driver.c - driver support
 *
 * (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
 *               Shaohua Li <shaohua.li@intel.com>
 *               Adam Belay <abelay@novell.com>
 *
 * This code is licenced under the GPL.
 */

#include <linux/mutex.h>
#include <linux/module.h>
#include <linux/cpuidle.h>

#include "cpuidle.h"

static struct cpuidle_driver *cpuidle_curr_driver;
DEFINE_SPINLOCK(cpuidle_driver_lock);

static void set_power_states(struct cpuidle_driver *drv)
{
	int i;

	/*
	 * cpuidle driver should set the drv->power_specified bit
	 * before registering if the driver provides
	 * power_usage numbers.
	 *
	 * If power_specified is not set,
	 * we fill in power_usage with decreasing values as the
	 * cpuidle code has an implicit assumption that state Cn
	 * uses less power than C(n-1).
	 *
	 * With CONFIG_ARCH_HAS_CPU_RELAX, C0 is already assigned
	 * an power value of -1.  So we use -2, -3, etc, for other
	 * c-states.
	 */
	for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++)
		drv->states[i].power_usage = -1 - i;
}

/**
 * cpuidle_register_driver - registers a driver
 * @drv: the driver
 */
int cpuidle_register_driver(struct cpuidle_driver *drv)
{
	if (!drv || !drv->state_count)
		return -EINVAL;

	if (cpuidle_disabled())
		return -ENODEV;

	spin_lock(&cpuidle_driver_lock);
	if (cpuidle_curr_driver) {
		spin_unlock(&cpuidle_driver_lock);
		return -EBUSY;
	}

	if (!drv->power_specified)
		set_power_states(drv);

	drv->refcnt = 0;

	cpuidle_curr_driver = drv;

	spin_unlock(&cpuidle_driver_lock);

	return 0;
}
EXPORT_SYMBOL_GPL(cpuidle_register_driver);

/**
 * cpuidle_get_driver - return the current driver
 */
struct cpuidle_driver *cpuidle_get_driver(void)
{
	return cpuidle_curr_driver;
}
EXPORT_SYMBOL_GPL(cpuidle_get_driver);

/**
 * cpuidle_unregister_driver - unregisters a driver
 * @drv: the driver
 */
void cpuidle_unregister_driver(struct cpuidle_driver *drv)
{
	spin_lock(&cpuidle_driver_lock);
	if (drv == cpuidle_curr_driver && !WARN_ON(drv->refcnt > 0))
		cpuidle_curr_driver = NULL;
	spin_unlock(&cpuidle_driver_lock);
}
EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);

struct cpuidle_driver *cpuidle_driver_ref(void)
{
	struct cpuidle_driver *drv;

	spin_lock(&cpuidle_driver_lock);

	drv = cpuidle_curr_driver;
	drv->refcnt++;

	spin_unlock(&cpuidle_driver_lock);
	return drv;
}

void cpuidle_driver_unref(void)
{
	struct cpuidle_driver *drv = cpuidle_curr_driver;

	spin_lock(&cpuidle_driver_lock);

	if (drv && !WARN_ON(drv->refcnt <= 0))
		drv->refcnt--;

	spin_unlock(&cpuidle_driver_lock);
}
Commit	Line	Data
4f86d3a8 LB	1	/*
	2	* driver.c - driver support
	3	*
	4	* (C) 2006-2007 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
	5	* Shaohua Li <shaohua.li@intel.com>
	6	* Adam Belay <abelay@novell.com>
	7	*
	8	* This code is licenced under the GPL.
	9	*/
	10
	11	#include <linux/mutex.h>
	12	#include <linux/module.h>
	13	#include <linux/cpuidle.h>
	14
	15	#include "cpuidle.h"
	16
752138df	17	static struct cpuidle_driver *cpuidle_curr_driver;
4f86d3a8 LB	18	DEFINE_SPINLOCK(cpuidle_driver_lock);
4f86d3a8 LB	19
ed953472	20	static void set_power_states(struct cpuidle_driver *drv)
46bcfad7 DD	21	{
46bcfad7 DD	22	int i;
ed953472	23
46bcfad7 DD	24	/*
	25	* cpuidle driver should set the drv->power_specified bit
	26	* before registering if the driver provides
	27	* power_usage numbers.
	28	*
	29	* If power_specified is not set,
	30	* we fill in power_usage with decreasing values as the
	31	* cpuidle code has an implicit assumption that state Cn
	32	* uses less power than C(n-1).
	33	*
	34	* With CONFIG_ARCH_HAS_CPU_RELAX, C0 is already assigned
	35	* an power value of -1. So we use -2, -3, etc, for other
	36	* c-states.
	37	*/
ed953472 DL	38	for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++)
ed953472 DL	39	drv->states[i].power_usage = -1 - i;
46bcfad7 DD	40	}
46bcfad7 DD	41
4f86d3a8 LB	42	/**
	43	* cpuidle_register_driver - registers a driver
	44	* @drv: the driver
	45	*/
	46	int cpuidle_register_driver(struct cpuidle_driver *drv)
	47	{
fc850f39	48	if (!drv \|\| !drv->state_count)
4f86d3a8 LB	49	return -EINVAL;
4f86d3a8 LB	50
62027aea LB	51	if (cpuidle_disabled())
	52	return -ENODEV;
	53
4f86d3a8 LB	54	spin_lock(&cpuidle_driver_lock);
	55	if (cpuidle_curr_driver) {
	56	spin_unlock(&cpuidle_driver_lock);
	57	return -EBUSY;
	58	}
ed953472 DL	59
	60	if (!drv->power_specified)
	61	set_power_states(drv);
	62
42f67f2a DL	63	drv->refcnt = 0;
42f67f2a DL	64
4f86d3a8	65	cpuidle_curr_driver = drv;
ed953472	66
4f86d3a8 LB	67	spin_unlock(&cpuidle_driver_lock);
	68
	69	return 0;
	70	}
4f86d3a8 LB	71	EXPORT_SYMBOL_GPL(cpuidle_register_driver);
4f86d3a8 LB	72
752138df LB	73	/**
	74	* cpuidle_get_driver - return the current driver
	75	*/
	76	struct cpuidle_driver *cpuidle_get_driver(void)
	77	{
	78	return cpuidle_curr_driver;
	79	}
	80	EXPORT_SYMBOL_GPL(cpuidle_get_driver);
	81
4f86d3a8 LB	82	/**
	83	* cpuidle_unregister_driver - unregisters a driver
	84	* @drv: the driver
	85	*/
	86	void cpuidle_unregister_driver(struct cpuidle_driver *drv)
	87	{
4f86d3a8	88	spin_lock(&cpuidle_driver_lock);
41682032	89	if (drv == cpuidle_curr_driver && !WARN_ON(drv->refcnt > 0))
6e797a07	90	cpuidle_curr_driver = NULL;
4f86d3a8 LB	91	spin_unlock(&cpuidle_driver_lock);
4f86d3a8 LB	92	}
4f86d3a8	93	EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);
6e797a07 RW	94
	95	struct cpuidle_driver *cpuidle_driver_ref(void)
	96	{
	97	struct cpuidle_driver *drv;
	98
	99	spin_lock(&cpuidle_driver_lock);
	100
	101	drv = cpuidle_curr_driver;
42f67f2a	102	drv->refcnt++;
6e797a07 RW	103
	104	spin_unlock(&cpuidle_driver_lock);
	105	return drv;
	106	}
	107
	108	void cpuidle_driver_unref(void)
	109	{
42f67f2a DL	110	struct cpuidle_driver *drv = cpuidle_curr_driver;
42f67f2a DL	111
6e797a07 RW	112	spin_lock(&cpuidle_driver_lock);
6e797a07 RW	113
42f67f2a DL	114	if (drv && !WARN_ON(drv->refcnt <= 0))
42f67f2a DL	115	drv->refcnt--;
6e797a07 RW	116
	117	spin_unlock(&cpuidle_driver_lock);
	118	}