Release 4.12 drivers/cpuidle/driver.c

Directory: drivers/cpuidle
/*
 * 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/sched.h>
#include <linux/sched/idle.h>
#include <linux/cpuidle.h>
#include <linux/cpumask.h>
#include <linux/tick.h>
#include <linux/cpu.h>

#include "cpuidle.h"


DEFINE_SPINLOCK(cpuidle_driver_lock);

#ifdef CONFIG_CPU_IDLE_MULTIPLE_DRIVERS

static DEFINE_PER_CPU(struct cpuidle_driver *, cpuidle_drivers);

/**
 * __cpuidle_get_cpu_driver - return the cpuidle driver tied to a CPU.
 * @cpu: the CPU handled by the driver
 *
 * Returns a pointer to struct cpuidle_driver or NULL if no driver has been
 * registered for @cpu.
 */


static struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)
{
	return per_cpu(cpuidle_drivers, cpu);
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 19 100.00% 3 100.00%
Total 19 100.00% 3 100.00%

/**
 * __cpuidle_unset_driver - unset per CPU driver variables.
 * @drv: a valid pointer to a struct cpuidle_driver
 *
 * For each CPU in the driver's CPU mask, unset the registered driver per CPU
 * variable. If @drv is different from the registered driver, the corresponding
 * variable is not cleared.
 */


static inline void __cpuidle_unset_driver(struct cpuidle_driver *drv)
{
	int cpu;

	for_each_cpu(cpu, drv->cpumask) {

		if (drv != __cpuidle_get_cpu_driver(cpu))
			continue;

		per_cpu(cpuidle_drivers, cpu) = NULL;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 34 80.95% 4 80.00%
Len Brown 8 19.05% 1 20.00%
Total 42 100.00% 5 100.00%

/**
 * __cpuidle_set_driver - set per CPU driver variables for the given driver.
 * @drv: a valid pointer to a struct cpuidle_driver
 *
 * For each CPU in the driver's cpumask, unset the registered driver per CPU
 * to @drv.
 *
 * Returns 0 on success, -EBUSY if the CPUs have driver(s) already.
 */


static inline int __cpuidle_set_driver(struct cpuidle_driver *drv)
{
	int cpu;

	for_each_cpu(cpu, drv->cpumask) {

		if (__cpuidle_get_cpu_driver(cpu)) {
			__cpuidle_unset_driver(drv);
			return -EBUSY;
		}

		per_cpu(cpuidle_drivers, cpu) = drv;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 52 98.11% 5 83.33%
Deepthi Dharwar 1 1.89% 1 16.67%
Total 53 100.00% 6 100.00%

#else


static struct cpuidle_driver *cpuidle_curr_driver;

/**
 * __cpuidle_get_cpu_driver - return the global cpuidle driver pointer.
 * @cpu: ignored without the multiple driver support
 *
 * Return a pointer to a struct cpuidle_driver object or NULL if no driver was
 * previously registered.
 */


static inline struct cpuidle_driver *__cpuidle_get_cpu_driver(int cpu)
{
	return cpuidle_curr_driver;
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 15 100.00% 2 100.00%
Total 15 100.00% 2 100.00%

/**
 * __cpuidle_set_driver - assign the global cpuidle driver variable.
 * @drv: pointer to a struct cpuidle_driver object
 *
 * Returns 0 on success, -EBUSY if the driver is already registered.
 */


static inline int __cpuidle_set_driver(struct cpuidle_driver *drv)
{
	if (cpuidle_curr_driver)
		return -EBUSY;

	cpuidle_curr_driver = drv;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 27 100.00% 2 100.00%
Total 27 100.00% 2 100.00%

/**
 * __cpuidle_unset_driver - unset the global cpuidle driver variable.
 * @drv: a pointer to a struct cpuidle_driver
 *
 * Reset the global cpuidle variable to NULL.  If @drv does not match the
 * registered driver, do nothing.
 */


static inline void __cpuidle_unset_driver(struct cpuidle_driver *drv)
{
	if (drv == cpuidle_curr_driver)
		cpuidle_curr_driver = NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 22 100.00% 2 100.00%
Total 22 100.00% 2 100.00%

#endif

/**
 * cpuidle_setup_broadcast_timer - enable/disable the broadcast timer on a cpu
 * @arg: a void pointer used to match the SMP cross call API
 *
 * If @arg is NULL broadcast is disabled otherwise enabled
 *
 * This function is executed per CPU by an SMP cross call.  It's not
 * supposed to be called directly.
 */


static void cpuidle_setup_broadcast_timer(void *arg)
{
	if (arg)
		tick_broadcast_enable();
	else
		tick_broadcast_disable();
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 12 57.14% 2 66.67%
Thomas Gleixner 9 42.86% 1 33.33%
Total 21 100.00% 3 100.00%

/**
 * __cpuidle_driver_init - initialize the driver's internal data
 * @drv: a valid pointer to a struct cpuidle_driver
 */


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

	drv->refcnt = 0;

	/*
         * Use all possible CPUs as the default, because if the kernel boots
         * with some CPUs offline and then we online one of them, the CPU
         * notifier has to know which driver to assign.
         */
	if (!drv->cpumask)
		drv->cpumask = (struct cpumask *)cpu_possible_mask;

	/*
         * Look for the timer stop flag in the different states, so that we know
         * if the broadcast timer has to be set up.  The loop is in the reverse
         * order, because usually one of the deeper states have this flag set.
         */
	for (i = drv->state_count - 1; i >= 0 ; i--) {
		if (drv->states[i].flags & CPUIDLE_FLAG_TIMER_STOP) {
			drv->bctimer = 1;
			break;
		}
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 76 93.83% 4 50.00%
Viresh Kumar 4 4.94% 3 37.50%
Deepthi Dharwar 1 1.23% 1 12.50%
Total 81 100.00% 8 100.00%

#ifdef CONFIG_ARCH_HAS_CPU_RELAX


static int __cpuidle poll_idle(struct cpuidle_device *dev,
			       struct cpuidle_driver *drv, int index)
{
	local_irq_enable();
	if (!current_set_polling_and_test()) {
		while (!need_resched())
			cpu_relax();
	}
	current_clr_polling();

	return index;
}

Contributors
Person Tokens Prop Commits CommitProp
Viresh Kumar 34 73.91% 1 33.33%
Andrew Lutomirski 11 23.91% 1 33.33%
Chris Metcalf 1 2.17% 1 33.33%
Total 46 100.00% 3 100.00%



static void poll_idle_init(struct cpuidle_driver *drv)
{
	struct cpuidle_state *state = &drv->states[0];

	snprintf(state->name, CPUIDLE_NAME_LEN, "POLL");
	snprintf(state->desc, CPUIDLE_DESC_LEN, "CPUIDLE CORE POLL IDLE");
	state->exit_latency = 0;
	state->target_residency = 0;
	state->power_usage = -1;
	state->enter = poll_idle;
	state->disabled = false;
}
Contributors
Person Tokens Prop Commits CommitProp
Viresh Kumar 77 100.00% 1 100.00%
Total 77 100.00% 1 100.00%

#else


static void poll_idle_init(struct cpuidle_driver *drv) {}
Contributors
Person Tokens Prop Commits CommitProp
Viresh Kumar 10 100.00% 1 100.00%
Total 10 100.00% 1 100.00%

#endif /* !CONFIG_ARCH_HAS_CPU_RELAX */

/**
 * __cpuidle_register_driver: register the driver
 * @drv: a valid pointer to a struct cpuidle_driver
 *
 * Do some sanity checks, initialize the driver, assign the driver to the
 * global cpuidle driver variable(s) and set up the broadcast timer if the
 * cpuidle driver has some states that shut down the local timer.
 *
 * Returns 0 on success, a negative error code otherwise:
 *  * -EINVAL if the driver pointer is NULL or no idle states are available
 *  * -ENODEV if the cpuidle framework is disabled
 *  * -EBUSY if the driver is already assigned to the global variable(s)
 */


static int __cpuidle_register_driver(struct cpuidle_driver *drv)
{
	int ret;

	if (!drv || !drv->state_count)
		return -EINVAL;

	ret = cpuidle_coupled_state_verify(drv);
	if (ret)
		return ret;

	if (cpuidle_disabled())
		return -ENODEV;

	__cpuidle_driver_init(drv);

	ret = __cpuidle_set_driver(drv);
	if (ret)
		return ret;

	if (drv->bctimer)
		on_each_cpu_mask(drv->cpumask, cpuidle_setup_broadcast_timer,
				 (void *)1, 1);

	poll_idle_init(drv);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 72 71.29% 3 42.86%
Xunlei Pang 14 13.86% 1 14.29%
Len Brown 9 8.91% 1 14.29%
Viresh Kumar 5 4.95% 1 14.29%
Thomas Gleixner 1 0.99% 1 14.29%
Total 101 100.00% 7 100.00%

/**
 * __cpuidle_unregister_driver - unregister the driver
 * @drv: a valid pointer to a struct cpuidle_driver
 *
 * Check if the driver is no longer in use, reset the global cpuidle driver
 * variable(s) and disable the timer broadcast notification mechanism if it was
 * in use.
 *
 */


static void __cpuidle_unregister_driver(struct cpuidle_driver *drv)
{
	if (WARN_ON(drv->refcnt > 0))
		return;

	if (drv->bctimer) {
		drv->bctimer = 0;
		on_each_cpu_mask(drv->cpumask, cpuidle_setup_broadcast_timer,
				 NULL, 1);
	}

	__cpuidle_unset_driver(drv);
}

Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 51 92.73% 2 50.00%
Len Brown 3 5.45% 1 25.00%
Thomas Gleixner 1 1.82% 1 25.00%
Total 55 100.00% 4 100.00%

/**
 * cpuidle_register_driver - registers a driver
 * @drv: a pointer to a valid struct cpuidle_driver
 *
 * Register the driver under a lock to prevent concurrent attempts to
 * [un]register the driver from occuring at the same time.
 *
 * Returns 0 on success, a negative error code (returned by
 * __cpuidle_register_driver()) otherwise.
 */


int cpuidle_register_driver(struct cpuidle_driver *drv)
{
	int ret;

	spin_lock(&cpuidle_driver_lock);
	ret = __cpuidle_register_driver(drv);
	spin_unlock(&cpuidle_driver_lock);

	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cpuidle_register_driver);

/**
 * cpuidle_unregister_driver - unregisters a driver
 * @drv: a pointer to a valid struct cpuidle_driver
 *
 * Unregisters the cpuidle driver under a lock to prevent concurrent attempts
 * to [un]register the driver from occuring at the same time.  @drv has to
 * match the currently registered driver.
 */


void cpuidle_unregister_driver(struct cpuidle_driver *drv)
{
	spin_lock(&cpuidle_driver_lock);
	__cpuidle_unregister_driver(drv);
	spin_unlock(&cpuidle_driver_lock);
}
Contributors
Person Tokens Prop Commits CommitProp
Len Brown 23 85.19% 1 25.00%
Rafael J. Wysocki 2 7.41% 1 25.00%
Daniel Lezcano 2 7.41% 2 50.00%
Total 27 100.00% 4 100.00%


EXPORT_SYMBOL_GPL(cpuidle_unregister_driver);

/**
 * cpuidle_get_driver - return the driver tied to the current CPU.
 *
 * Returns a struct cpuidle_driver pointer, or NULL if no driver is registered.
 */


struct cpuidle_driver *cpuidle_get_driver(void)
{
	struct cpuidle_driver *drv;
	int cpu;

	cpu = get_cpu();
	drv = __cpuidle_get_cpu_driver(cpu);
	put_cpu();

	return drv;
}
Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cpuidle_get_driver);

/**
 * cpuidle_get_cpu_driver - return the driver registered for a CPU.
 * @dev: a valid pointer to a struct cpuidle_device
 *
 * Returns a struct cpuidle_driver pointer, or NULL if no driver is registered
 * for the CPU associated with @dev.
 */


struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev)
{
	if (!dev)
		return NULL;

	return __cpuidle_get_cpu_driver(dev->cpu);
}
Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 28 100.00% 2 100.00%
Total 28 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(cpuidle_get_cpu_driver);

/**
 * cpuidle_driver_ref - get a reference to the driver.
 *
 * Increment the reference counter of the cpuidle driver associated with
 * the current CPU.
 *
 * Returns a pointer to the driver, or NULL if the current CPU has no driver.
 */


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

	spin_lock(&cpuidle_driver_lock);

	drv = cpuidle_get_driver();
	if (drv)
		drv->refcnt++;

	spin_unlock(&cpuidle_driver_lock);
	return drv;
}

Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 34 79.07% 1 25.00%
Daniel Lezcano 5 11.63% 2 50.00%
Daniel Fu 4 9.30% 1 25.00%
Total 43 100.00% 4 100.00%

/**
 * cpuidle_driver_unref - puts down the refcount for the driver
 *
 * Decrement the reference counter of the cpuidle driver associated with
 * the current CPU.
 */


void cpuidle_driver_unref(void)
{
	struct cpuidle_driver *drv;

	spin_lock(&cpuidle_driver_lock);

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

	spin_unlock(&cpuidle_driver_lock);
}
Contributors
Person Tokens Prop Commits CommitProp
Rafael J. Wysocki 30 62.50% 1 33.33%
Daniel Lezcano 13 27.08% 1 33.33%
Viresh Kumar 5 10.42% 1 33.33%
Total 48 100.00% 3 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
Daniel Lezcano 550 62.15% 8 34.78%
Viresh Kumar 148 16.72% 5 21.74%
Len Brown 70 7.91% 2 8.70%
Rafael J. Wysocki 66 7.46% 1 4.35%
Xunlei Pang 14 1.58% 1 4.35%
Thomas Gleixner 13 1.47% 1 4.35%
Andrew Lutomirski 11 1.24% 1 4.35%
Chris Metcalf 4 0.45% 1 4.35%
Daniel Fu 4 0.45% 1 4.35%
Ingo Molnar 3 0.34% 1 4.35%
Deepthi Dharwar 2 0.23% 1 4.35%
Total 885 100.00% 23 100.00%
Directory: drivers/cpuidle

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Daniel Lezcano	19	100.00%	3	100.00%
Total	19	100.00%	3	100.00%
cregit-Linux how code gets into the kernel

Release 4.12 drivers/cpuidle/driver.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
