[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);
int cpuidle_driver_refcount;

static void __cpuidle_register_driver(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.
	 */
	if (!drv->power_specified) {
		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;
	}
	__cpuidle_register_driver(drv);
	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)
{
	if (drv != cpuidle_curr_driver) {
		WARN(1, "invalid cpuidle_unregister_driver(%s)\n",
			drv->name);
		return;
	}

	spin_lock(&cpuidle_driver_lock);

	if (!WARN_ON(cpuidle_driver_refcount > 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;
	cpuidle_driver_refcount++;

	spin_unlock(&cpuidle_driver_lock);
	return drv;
}

void cpuidle_driver_unref(void)
{
	spin_lock(&cpuidle_driver_lock);

	if (!WARN_ON(cpuidle_driver_refcount <= 0))
		cpuidle_driver_refcount--;

	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	18	DEFINE_SPINLOCK(cpuidle_driver_lock);
6e797a07	19	int cpuidle_driver_refcount;
4f86d3a8	20
46bcfad7 DD	21	static void __cpuidle_register_driver(struct cpuidle_driver *drv)
	22	{
	23	int i;
	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	*/
	38	if (!drv->power_specified) {
	39	for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++)
	40	drv->states[i].power_usage = -1 - i;
	41	}
	42	}
	43
	44
4f86d3a8 LB	45	/**
	46	* cpuidle_register_driver - registers a driver
	47	* @drv: the driver
	48	*/
	49	int cpuidle_register_driver(struct cpuidle_driver *drv)
	50	{
fc850f39	51	if (!drv \|\| !drv->state_count)
4f86d3a8 LB	52	return -EINVAL;
4f86d3a8 LB	53
62027aea LB	54	if (cpuidle_disabled())
	55	return -ENODEV;
	56
4f86d3a8 LB	57	spin_lock(&cpuidle_driver_lock);
	58	if (cpuidle_curr_driver) {
	59	spin_unlock(&cpuidle_driver_lock);
	60	return -EBUSY;
	61	}
46bcfad7	62	__cpuidle_register_driver(drv);
4f86d3a8 LB	63	cpuidle_curr_driver = drv;
	64	spin_unlock(&cpuidle_driver_lock);
	65
	66	return 0;
	67	}
	68
	69	EXPORT_SYMBOL_GPL(cpuidle_register_driver);
	70
752138df LB	71	/**
	72	* cpuidle_get_driver - return the current driver
	73	*/
	74	struct cpuidle_driver *cpuidle_get_driver(void)
	75	{
	76	return cpuidle_curr_driver;
	77	}
	78	EXPORT_SYMBOL_GPL(cpuidle_get_driver);
	79
4f86d3a8 LB	80	/**
	81	* cpuidle_unregister_driver - unregisters a driver
	82	* @drv: the driver
	83	*/
	84	void cpuidle_unregister_driver(struct cpuidle_driver *drv)
	85	{
c0d64cb0 LB	86	if (drv != cpuidle_curr_driver) {
	87	WARN(1, "invalid cpuidle_unregister_driver(%s)\n",
	88	drv->name);
4f86d3a8	89	return;
c0d64cb0	90	}
4f86d3a8 LB	91
4f86d3a8 LB	92	spin_lock(&cpuidle_driver_lock);
6e797a07 RW	93
	94	if (!WARN_ON(cpuidle_driver_refcount > 0))
	95	cpuidle_curr_driver = NULL;
	96
4f86d3a8 LB	97	spin_unlock(&cpuidle_driver_lock);
	98	}
	99
	100	EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);
6e797a07 RW	101
	102	struct cpuidle_driver *cpuidle_driver_ref(void)
	103	{
	104	struct cpuidle_driver *drv;
	105
	106	spin_lock(&cpuidle_driver_lock);
	107
	108	drv = cpuidle_curr_driver;
	109	cpuidle_driver_refcount++;
	110
	111	spin_unlock(&cpuidle_driver_lock);
	112	return drv;
	113	}
	114
	115	void cpuidle_driver_unref(void)
	116	{
	117	spin_lock(&cpuidle_driver_lock);
	118
	119	if (!WARN_ON(cpuidle_driver_refcount <= 0))
	120	cpuidle_driver_refcount--;
	121
	122	spin_unlock(&cpuidle_driver_lock);
	123	}