Re: [PATCH RFC 1/2] thermal/cpu idle cooling: Introduce cpu idle cooling driver

[Daniel Lezcano <daniel.lezcano@linaro.org>]

On Tue, Jun 06, 2017 at 09:11:35AM +0530, viresh kumar wrote:
> + Daniel

Hi Viresh,

thanks for the head up.

Before going deeply in the review, I have a dumb question:

Why isn't this mechanism implemented at the scheduler level?


> On 05-06-17, 17:07, Tao Wang wrote:
> > cpu idle cooling driver performs synchronized idle injection across
> > all cpu in same cluster, offers a new method to cooling down cpu,
> > that is similar to intel_power_clamp driver, but is basically
> > designed for ARM platform.
> > Each cluster has its own idle cooling device, each core has its own
> > idle injection thread, idle injection thread use play_idle to enter
> > idle. In order to reach deepest idle state, all cores are aligned by
> > jiffies. the injected idle ratio can be controlled through cooling
> > device interface.
> > 
> > Signed-off-by: Tao Wang <kevin.wangtao@hisilicon.com>
> > ---
> >  drivers/thermal/Kconfig            |   13 +
> >  drivers/thermal/Makefile           |    3 +
> >  drivers/thermal/cpu_idle_cooling.c |  648 ++++++++++++++++++++++++++++++++++++
> >  3 files changed, 664 insertions(+)
> >  create mode 100644 drivers/thermal/cpu_idle_cooling.c
> > 
> > diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
> > index b5b5fac..f78e85c 100644
> > --- a/drivers/thermal/Kconfig
> > +++ b/drivers/thermal/Kconfig
> > @@ -154,6 +154,19 @@ config CPU_THERMAL
> >  
> >  	  If you want this support, you should say Y here.
> >  
> > +config CPU_IDLE_THERMAL
> > +	tristate "generic cpu idle cooling support"
> > +	depends on CPU_FREQ
> > +	help
> > +	  This implements the generic cpu cooling mechanism through idle
> > +	  injection.
> > +
> > +	  This will throttle cpu by injecting specified idle time in
> > +	  a fixed cycle. All cpu in same cluster will enter idle synchronously
> > +	  to reach deepest idle state when injecting idle.
> > +
> > +	  If you want this support, you should say Y here.
> > +
> >  config CLOCK_THERMAL
> >  	bool "Generic clock cooling support"
> >  	depends on COMMON_CLK
> > diff --git a/drivers/thermal/Makefile b/drivers/thermal/Makefile
> > index 094d703..a4db66e 100644
> > --- a/drivers/thermal/Makefile
> > +++ b/drivers/thermal/Makefile
> > @@ -26,6 +26,9 @@ thermal_sys-$(CONFIG_CLOCK_THERMAL)	+= clock_cooling.o
> >  # devfreq cooling
> >  thermal_sys-$(CONFIG_DEVFREQ_THERMAL) += devfreq_cooling.o
> >  
> > +# cpu idle cooling
> > +obj-$(CONFIG_CPU_IDLE_THERMAL)	+= cpu_idle_cooling.o
> > +
> >  # platform thermal drivers
> >  obj-y				+= broadcom/
> >  obj-$(CONFIG_QCOM_SPMI_TEMP_ALARM)	+= qcom-spmi-temp-alarm.o
> > diff --git a/drivers/thermal/cpu_idle_cooling.c b/drivers/thermal/cpu_idle_cooling.c
> > new file mode 100644
> > index 0000000..89a15c5
> > --- /dev/null
> > +++ b/drivers/thermal/cpu_idle_cooling.c
> > @@ -0,0 +1,648 @@
> > +/*
> > + *  linux/drivers/thermal/cpu_idle_cooling.c
> > + *
> > + *  Copyright (C) 2017  Tao Wang <kevin.wangtao@hisilicon.com>
> > + *
> > + *  This program is free software; you can redistribute it and/or modify
> > + *  it under the terms of the GNU General Public License as published by
> > + *  the Free Software Foundation; version 2 of the License.
> > + *
> > + *  This program is distributed in the hope that it will be useful,
> > + *  but WITHOUT ANY WARRANTY; without even the implied warranty of
> > + *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> > + *  GNU General Public License for more details.
> > + *
> > + *  You should have received a copy of the GNU General Public License
> > + *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
> > + */
> > +
> > +#include <linux/module.h>
> > +#include <linux/kernel.h>
> > +#include <linux/kernel_stat.h>
> > +#include <linux/delay.h>
> > +#include <linux/kthread.h>
> > +#include <linux/freezer.h>
> > +#include <linux/cpu.h>
> > +#include <linux/topology.h>
> > +#include <linux/cpufreq.h>
> > +#include <linux/cpumask.h>
> > +#include <linux/cpuidle.h>
> > +#include <linux/thermal.h>
> > +#include <linux/sched.h>
> > +#include <uapi/linux/sched/types.h>
> > +#include <linux/slab.h>
> > +#include <linux/tick.h>
> > +#include <linux/wait.h>
> > +#include <linux/sched/rt.h>
> > +
> > +#define MAX_TARGET_RATIO		(50U)
> > +
> > +#define DEFAULT_WINDOW_SIZE		(1)
> > +#define DEFAULT_DURATION_JIFFIES	(20)
> > +
> > +struct cpu_idle_cooling_device {
> > +	int id;
> > +	struct thermal_cooling_device *cooling_dev;
> > +	wait_queue_head_t wait_queue;
> > +
> > +	/* The cpu assigned to collect stat and update
> > +	 * control parameters. default to BSP but BSP
> > +	 * can be offlined.
> > +	 */
> > +	unsigned long control_cpu;
> > +
> > +	unsigned int set_target_ratio;
> > +	unsigned int current_ratio;
> > +	unsigned int control_ratio;
> > +	unsigned int duration;
> > +	unsigned int window_size;
> > +
> > +	cpumask_var_t related_cpus;
> > +	cpumask_var_t injected_cpus;
> > +	struct list_head node;
> > +	bool should_skip;
> > +	bool clamping;
> > +};
> > +
> > +static LIST_HEAD(cpu_idle_cooling_dev_list);
> > +static DEFINE_PER_CPU(struct task_struct *, idle_injection_thread_ptr);
> > +static DEFINE_MUTEX(cpu_idle_cooling_lock);
> > +
> > +unsigned long idle_time[NR_CPUS] = {0};
> > +unsigned long time_stamp[NR_CPUS] = {0};
> > +static enum cpuhp_state hp_state;
> > +
> > +#define STORE_PARAM(param, min, max)			\
> > +static ssize_t store_##param(struct device *dev,	\
> > +	struct device_attribute *attr,			\
> > +	const char *buf, size_t count)			\
> > +{									\
> > +	unsigned int new_value;						\
> > +	struct thermal_cooling_device *cdev;				\
> > +	struct cpu_idle_cooling_device *idle_cooling_dev;		\
> > +									\
> > +	if (dev == NULL || attr == NULL)				\
> > +		return 0;						\
> > +									\
> > +	if (kstrtouint(buf, 10, &new_value))				\
> > +		return -EINVAL;						\
> > +									\
> > +	if (new_value > max || new_value < min) {			\
> > +		pr_err("Out of range %u, between %d-%d\n",		\
> > +			new_value, min, max);				\
> > +		return -EINVAL;						\
> > +	}								\
> > +									\
> > +	cdev = container_of(dev, struct thermal_cooling_device, device);\
> > +	idle_cooling_dev = cdev->devdata;				\
> > +	idle_cooling_dev->param = new_value;				\
> > +									\
> > +	/* make new value visible to other cpus */			\
> > +	smp_mb();							\
> > +									\
> > +	return count;							\
> > +}
> > +
> > +STORE_PARAM(duration, 10, 500);
> > +STORE_PARAM(window_size, 1, 10);
> > +
> > +#define SHOW_PARAM(param)				\
> > +static ssize_t show_##param(struct device *dev,		\
> > +	struct device_attribute *attr, char *buf)	\
> > +{									\
> > +	struct thermal_cooling_device *cdev;				\
> > +	struct cpu_idle_cooling_device *idle_cooling_dev;		\
> > +									\
> > +	if (dev == NULL || attr == NULL)				\
> > +		return 0;						\
> > +									\
> > +	cdev = container_of(dev, struct thermal_cooling_device, device);\
> > +	idle_cooling_dev = cdev->devdata;				\
> > +									\
> > +	return snprintf(buf, 12UL, "%d\n",				\
> > +					idle_cooling_dev->param);	\
> > +}
> > +
> > +SHOW_PARAM(duration);
> > +SHOW_PARAM(window_size);
> > +
> > +static DEVICE_ATTR(duration, 0644, show_duration, store_duration);
> > +static DEVICE_ATTR(window_size, 0644, show_window_size, store_window_size);
> > +
> > +static struct cpu_idle_cooling_device *
> > +get_cpu_idle_cooling_dev(unsigned long cpu)
> > +{
> > +	struct cpu_idle_cooling_device *idle_cooling_dev;
> > +
> > +	list_for_each_entry(idle_cooling_dev,
> > +		&cpu_idle_cooling_dev_list, node) {
> > +		if (cpumask_test_cpu(cpu, idle_cooling_dev->related_cpus))
> > +			return idle_cooling_dev;
> > +	}
> > +
> > +	return NULL;
> > +}
> > +
> > +#define K_P		10
> > +#define MAX_COMP	10
> > +static unsigned int get_compensation(unsigned int current_ratio,
> > +		unsigned int target_ratio, unsigned int control_ratio)
> > +{
> > +	unsigned int comp;
> > +
> > +	comp = abs(current_ratio - target_ratio) * K_P / 10;
> > +	if (comp > MAX_COMP)
> > +		comp = MAX_COMP;
> > +
> > +	if (current_ratio > target_ratio) {
> > +		if (control_ratio > comp)
> > +			comp = control_ratio - comp;
> > +		else
> > +			comp = 1;
> > +	} else {
> > +		if (control_ratio + comp < MAX_TARGET_RATIO)
> > +			comp = control_ratio + comp;
> > +		else
> > +			comp = MAX_TARGET_RATIO;
> > +
> > +		if (comp > (target_ratio * 6 / 5))
> > +			comp = target_ratio * 6 / 5;
> > +	}
> > +
> > +	return comp;
> > +}
> > +
> > +static void update_stats(struct cpu_idle_cooling_device *idle_cooling_dev)
> > +{
> > +	unsigned long cpu;
> > +	u64 now, now_idle, delta_time, delta_idle;
> > +	u64 min_idle_ratio = 100;
> > +	u64 idle_ratio = 0;
> > +
> > +	for_each_cpu(cpu, idle_cooling_dev->related_cpus) {
> > +		now_idle = get_cpu_idle_time(cpu, &now, 0);
> > +		delta_idle = now_idle - idle_time[cpu];
> > +		delta_time = now - time_stamp[cpu];
> > +		idle_time[cpu] = now_idle;
> > +		time_stamp[cpu] = now;
> > +
> > +		if (delta_idle >= delta_time || !cpu_online(cpu))
> > +			now_idle = 100;
> > +		else if (delta_time)
> > +			now_idle = div64_u64(100 * delta_idle, delta_time);
> > +		else
> > +			return;
> > +
> > +		if (now_idle < min_idle_ratio)
> > +			min_idle_ratio = now_idle;
> > +
> > +		idle_ratio += now_idle;
> > +	}
> > +
> > +	idle_ratio /= cpumask_weight(idle_cooling_dev->related_cpus);
> > +	if (idle_ratio > MAX_TARGET_RATIO)
> > +		idle_ratio = min_idle_ratio;
> > +
> > +	if (idle_cooling_dev->should_skip)
> > +		idle_ratio = (idle_cooling_dev->current_ratio + idle_ratio) / 2;
> > +
> > +	idle_cooling_dev->current_ratio = (unsigned int)idle_ratio;
> > +	idle_cooling_dev->control_ratio = get_compensation(idle_ratio,
> > +				idle_cooling_dev->set_target_ratio,
> > +				idle_cooling_dev->control_ratio);
> > +	idle_cooling_dev->should_skip =
> > +			(idle_ratio > (2 * idle_cooling_dev->set_target_ratio));
> > +	/* make new control_ratio and should skip flag visible to other cpus */
> > +	smp_mb();
> > +}
> > +
> > +static void inject_idle_fn(struct cpu_idle_cooling_device *idle_cooling_dev)
> > +{
> > +	long sleeptime, guard;
> > +	unsigned int interval_ms; /* jiffies to sleep for each attempt */
> > +	unsigned long target_jiffies;
> > +	unsigned int duration_ms = idle_cooling_dev->duration;
> > +	unsigned long duration_jiffies = msecs_to_jiffies(duration_ms);
> > +
> > +	guard = DIV_ROUND_UP(duration_jiffies * (90 - MAX_TARGET_RATIO), 100);
> > +
> > +	/* align idle time */
> > +	target_jiffies = roundup(jiffies, duration_jiffies);
> > +	sleeptime = target_jiffies - jiffies;
> > +	if (sleeptime < guard)
> > +		sleeptime += duration_jiffies;
> > +
> > +	if (sleeptime > 0)
> > +		schedule_timeout_interruptible(sleeptime);
> > +
> > +	interval_ms = duration_ms * idle_cooling_dev->control_ratio / 100;
> > +
> > +	if (idle_cooling_dev->should_skip)
> > +		return;
> > +
> > +	if (interval_ms)
> > +		play_idle(interval_ms);
> > +}
> > +
> > +static int idle_injection_thread(void *arg)
> > +{
> > +	unsigned long cpunr = (unsigned long)arg;
> > +	struct sched_param param = { .sched_priority = MAX_USER_RT_PRIO/2 };
> > +	unsigned int count = 0;
> > +	struct cpu_idle_cooling_device *idle_cooling_dev;
> > +
> > +	set_freezable();
> > +
> > +	sched_setscheduler(current, SCHED_FIFO, &param);
> > +
> > +	mutex_lock(&cpu_idle_cooling_lock);
> > +	idle_cooling_dev = get_cpu_idle_cooling_dev(cpunr);
> > +	mutex_unlock(&cpu_idle_cooling_lock);
> > +
> > +	while (!kthread_should_stop()) {
> > +		wait_event_interruptible(idle_cooling_dev->wait_queue,
> > +			(idle_cooling_dev->clamping && cpu_online(cpunr)) ||
> > +			kthread_should_stop());
> > +
> > +		if (kthread_should_stop())
> > +			break;
> > +
> > +		/* rebind thread to cpu */
> > +		if (set_cpus_allowed_ptr(current, cpumask_of(cpunr)))
> > +			continue;
> > +
> > +		try_to_freeze();
> > +
> > +		while (idle_cooling_dev->clamping &&
> > +			cpu_online(cpunr)) {
> > +			try_to_freeze();
> > +
> > +			count++;
> > +			/*
> > +			 * only elected controlling cpu can collect stats
> > +			 * and update control parameters.
> > +			 */
> > +			if (cpunr == idle_cooling_dev->control_cpu
> > +				&& !(count % idle_cooling_dev->window_size))
> > +				update_stats(idle_cooling_dev);
> > +
> > +			inject_idle_fn(idle_cooling_dev);
> > +		}
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static int create_idle_thread(struct cpu_idle_cooling_device *idle_cooling_dev)
> > +{
> > +	unsigned long cpu;
> > +	struct task_struct *thread;
> > +
> > +	init_waitqueue_head(&idle_cooling_dev->wait_queue);
> > +
> > +	/* start one thread per online cpu */
> > +	for_each_cpu(cpu, idle_cooling_dev->related_cpus) {
> > +		thread = kthread_create_on_node(idle_injection_thread,
> > +						(void *) cpu,
> > +						cpu_to_node(cpu),
> > +						"kidle_inject/%lu", cpu);
> > +		/* bind to cpu here */
> > +		if (likely(!IS_ERR(thread))) {
> > +			cpumask_set_cpu(cpu, idle_cooling_dev->injected_cpus);
> > +			kthread_bind(thread, cpu);
> > +			wake_up_process(thread);
> > +			per_cpu(idle_injection_thread_ptr, cpu) = thread;
> > +		} else {
> > +			return -ENOMEM;
> > +		}
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static void stop_idle_thread(struct cpu_idle_cooling_device *idle_cooling_dev)
> > +{
> > +	unsigned long cpu;
> > +	struct task_struct **percpu_thread;
> > +
> > +	idle_cooling_dev->clamping = false;
> > +	/*
> > +	 * make clamping visible to other cpus and give per cpu threads
> > +	 * sometime to exit, or gets killed later.
> > +	 */
> > +	smp_mb();
> > +	msleep(idle_cooling_dev->duration);
> > +	for_each_cpu(cpu, idle_cooling_dev->injected_cpus) {
> > +		pr_debug("idle inject thread for cpu %lu alive, kill\n", cpu);
> > +		percpu_thread = per_cpu_ptr(&idle_injection_thread_ptr, cpu);
> > +		if (!IS_ERR_OR_NULL(*percpu_thread)) {
> > +			kthread_stop(*percpu_thread);
> > +			*percpu_thread = NULL;
> > +		}
> > +		cpumask_clear_cpu(cpu, idle_cooling_dev->injected_cpus);
> > +	}
> > +}
> > +
> > +static int idle_injection_cpu_online(unsigned int cpu)
> > +{
> > +	struct cpu_idle_cooling_device *idle_cooling_dev;
> > +
> > +	idle_cooling_dev = get_cpu_idle_cooling_dev(cpu);
> > +	if (idle_cooling_dev) {
> > +		/* prefer BSP as controlling CPU */
> > +		if (cpu == cpumask_first(idle_cooling_dev->injected_cpus)
> > +			|| !cpu_online(idle_cooling_dev->control_cpu)) {
> > +			idle_cooling_dev->control_cpu = cpu;
> > +			/* make new control_cpu visible to other cpus */
> > +			smp_mb();
> > +		}
> > +		wake_up_interruptible(&idle_cooling_dev->wait_queue);
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static int idle_injection_cpu_predown(unsigned int cpu)
> > +{
> > +	struct cpu_idle_cooling_device *idle_cooling_dev;
> > +
> > +	idle_cooling_dev = get_cpu_idle_cooling_dev(cpu);
> > +	if (idle_cooling_dev) {
> > +		if (cpu == idle_cooling_dev->control_cpu) {
> > +			cpu = cpumask_next_and(-1,
> > +				idle_cooling_dev->injected_cpus,
> > +				cpu_online_mask);
> > +
> > +			if (cpu < nr_cpu_ids)
> > +				idle_cooling_dev->control_cpu = cpu;
> > +			/* make new control_cpu visible to other cpus */
> > +			smp_mb();
> > +		}
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static int idle_get_max_state(struct thermal_cooling_device *cdev,
> > +				 unsigned long *state)
> > +{
> > +	*state = MAX_TARGET_RATIO;
> > +
> > +	return 0;
> > +}
> > +
> > +static int idle_get_cur_state(struct thermal_cooling_device *cdev,
> > +				 unsigned long *state)
> > +{
> > +	struct cpu_idle_cooling_device *idle_cooling_dev = cdev->devdata;
> > +
> > +	if (true == idle_cooling_dev->clamping)
> > +		*state = (unsigned long)idle_cooling_dev->current_ratio;
> > +	else
> > +		*state = 0; /* indicates invalid state */
> > +
> > +	return 0;
> > +}
> > +
> > +static int idle_set_cur_state(struct thermal_cooling_device *cdev,
> > +				 unsigned long new_target_ratio)
> > +{
> > +	struct cpu_idle_cooling_device *idle_cooling_dev = cdev->devdata;
> > +	int ret = 0;
> > +
> > +	mutex_lock(&cdev->lock);
> > +
> > +	new_target_ratio = clamp(new_target_ratio, 0UL,
> > +				(unsigned long) MAX_TARGET_RATIO);
> > +	if (idle_cooling_dev->set_target_ratio == 0
> > +		&& new_target_ratio > 0) {
> > +		idle_cooling_dev->set_target_ratio =
> > +			(unsigned int) new_target_ratio;
> > +		idle_cooling_dev->control_ratio =
> > +			idle_cooling_dev->set_target_ratio;
> > +		idle_cooling_dev->current_ratio =
> > +			idle_cooling_dev->set_target_ratio;
> > +		idle_cooling_dev->clamping = true;
> > +		wake_up_interruptible(&idle_cooling_dev->wait_queue);
> > +	} else if (idle_cooling_dev->set_target_ratio > 0) {
> > +		if (new_target_ratio == 0) {
> > +			idle_cooling_dev->set_target_ratio = 0;
> > +			idle_cooling_dev->clamping = false;
> > +			/* make clamping visible to other cpus */
> > +			smp_mb();
> > +		} else	/* adjust currently running */ {
> > +			idle_cooling_dev->set_target_ratio =
> > +				(unsigned int) new_target_ratio;
> > +			/* make new set_target_ratio visible to other cpus */
> > +			smp_mb();
> > +		}
> > +	}
> > +
> > +	mutex_unlock(&cdev->lock);
> > +
> > +	return ret;
> > +}
> > +
> > +static struct thermal_cooling_device_ops cpu_idle_injection_cooling_ops = {
> > +	.get_max_state = idle_get_max_state,
> > +	.get_cur_state = idle_get_cur_state,
> > +	.set_cur_state = idle_set_cur_state,
> > +};
> > +
> > +unsigned long get_max_idle_state(const struct cpumask *clip_cpus)
> > +{
> > +	return MAX_TARGET_RATIO;
> > +}
> > +EXPORT_SYMBOL_GPL(get_max_idle_state);
> > +
> > +void set_idle_state(const struct cpumask *clip_cpus, unsigned long idle_ratio)
> > +{
> > +	struct cpu_idle_cooling_device *idle_cooling_dev;
> > +
> > +	mutex_lock(&cpu_idle_cooling_lock);
> > +	list_for_each_entry(idle_cooling_dev,
> > +		&cpu_idle_cooling_dev_list, node) {
> > +		if (cpumask_subset(idle_cooling_dev->related_cpus, clip_cpus))
> > +			idle_set_cur_state(idle_cooling_dev->cooling_dev,
> > +					idle_ratio);
> > +	}
> > +	mutex_unlock(&cpu_idle_cooling_lock);
> > +}
> > +EXPORT_SYMBOL_GPL(set_idle_state);
> > +
> > +struct thermal_cooling_device * __init
> > +cpu_idle_cooling_register(const struct cpumask *clip_cpus)
> > +{
> > +	struct cpu_idle_cooling_device *idle_cooling_dev;
> > +	struct thermal_cooling_device *ret;
> > +	unsigned long cpu;
> > +	char dev_name[THERMAL_NAME_LENGTH];
> > +
> > +	if (cpumask_empty(clip_cpus))
> > +		return ERR_PTR(-ENOMEM);
> > +
> > +	mutex_lock(&cpu_idle_cooling_lock);
> > +	get_online_cpus();
> > +	list_for_each_entry(idle_cooling_dev,
> > +		&cpu_idle_cooling_dev_list, node) {
> > +		if (cpumask_intersects(idle_cooling_dev->related_cpus,
> > +			clip_cpus)) {
> > +			ret = ERR_PTR(-EINVAL);
> > +			goto exit_unlock;
> > +		}
> > +	}
> > +
> > +	idle_cooling_dev = kzalloc(sizeof(*idle_cooling_dev), GFP_KERNEL);
> > +	if (!idle_cooling_dev) {
> > +		ret = ERR_PTR(-ENOMEM);
> > +		goto exit_unlock;
> > +	}
> > +
> > +	if (!zalloc_cpumask_var(&idle_cooling_dev->related_cpus, GFP_KERNEL)) {
> > +		ret = ERR_PTR(-ENOMEM);
> > +		goto exit_free_dev;
> > +	}
> > +
> > +	if (!zalloc_cpumask_var(&idle_cooling_dev->injected_cpus, GFP_KERNEL)) {
> > +		ret = ERR_PTR(-ENOMEM);
> > +		goto exit_free_related_cpus;
> > +	}
> > +
> > +	cpumask_copy(idle_cooling_dev->related_cpus, clip_cpus);
> > +	cpu = cpumask_first(clip_cpus);
> > +	idle_cooling_dev->control_cpu = cpu;
> > +	idle_cooling_dev->id = topology_physical_package_id(cpu);
> > +	idle_cooling_dev->window_size = DEFAULT_WINDOW_SIZE;
> > +	idle_cooling_dev->duration = jiffies_to_msecs(DEFAULT_DURATION_JIFFIES);
> > +
> > +	if (create_idle_thread(idle_cooling_dev)) {
> > +		ret = ERR_PTR(-ENOMEM);
> > +		goto exit_free_injected_cpus;
> > +	}
> > +
> > +	snprintf(dev_name, sizeof(dev_name), "thermal-cpuidle-%d",
> > +		 idle_cooling_dev->id);
> > +	ret = thermal_cooling_device_register(dev_name,
> > +					idle_cooling_dev,
> > +					&cpu_idle_injection_cooling_ops);
> > +	if (IS_ERR(ret))
> > +		goto exit_stop_thread;
> > +
> > +	idle_cooling_dev->cooling_dev = ret;
> > +
> > +	if (device_create_file(&idle_cooling_dev->cooling_dev->device,
> > +		&dev_attr_duration)) {
> > +		ret = ERR_PTR(-ENOMEM);
> > +		goto exit_unregister_cdev;
> > +	}
> > +
> > +	if (device_create_file(&idle_cooling_dev->cooling_dev->device,
> > +		&dev_attr_window_size)) {
> > +		ret = ERR_PTR(-ENOMEM);
> > +		goto exit_remove_duration_attr;
> > +	}
> > +
> > +	list_add(&idle_cooling_dev->node, &cpu_idle_cooling_dev_list);
> > +
> > +	goto exit_unlock;
> > +
> > +exit_remove_duration_attr:
> > +	device_remove_file(&idle_cooling_dev->cooling_dev->device,
> > +			&dev_attr_duration);
> > +exit_unregister_cdev:
> > +	thermal_cooling_device_unregister(idle_cooling_dev->cooling_dev);
> > +exit_stop_thread:
> > +	stop_idle_thread(idle_cooling_dev);
> > +exit_free_injected_cpus:
> > +	free_cpumask_var(idle_cooling_dev->injected_cpus);
> > +exit_free_related_cpus:
> > +	free_cpumask_var(idle_cooling_dev->related_cpus);
> > +exit_free_dev:
> > +	kfree(idle_cooling_dev);
> > +exit_unlock:
> > +	put_online_cpus();
> > +	mutex_unlock(&cpu_idle_cooling_lock);
> > +	return ret;
> > +}
> > +
> > +void cpu_idle_cooling_unregister(struct thermal_cooling_device *cdev)
> > +{
> > +	struct cpu_idle_cooling_device *idle_cooling_dev;
> > +
> > +	if (IS_ERR_OR_NULL(cdev))
> > +		return;
> > +
> > +	idle_cooling_dev = cdev->devdata;
> > +
> > +	mutex_lock(&cpu_idle_cooling_lock);
> > +	get_online_cpus();
> > +	list_del(&idle_cooling_dev->node);
> > +	put_online_cpus();
> > +	mutex_unlock(&cpu_idle_cooling_lock);
> > +
> > +	device_remove_file(&cdev->device, &dev_attr_window_size);
> > +	device_remove_file(&cdev->device, &dev_attr_duration);
> > +	thermal_cooling_device_unregister(idle_cooling_dev->cooling_dev);
> > +
> > +	stop_idle_thread(idle_cooling_dev);
> > +	free_cpumask_var(idle_cooling_dev->injected_cpus);
> > +	free_cpumask_var(idle_cooling_dev->related_cpus);
> > +	kfree(idle_cooling_dev);
> > +}
> > +
> > +static void __cpu_idle_cooling_exit(void)
> > +{
> > +	struct cpu_idle_cooling_device *idle_cooling_dev;
> > +
> > +	while (!list_empty(&cpu_idle_cooling_dev_list)) {
> > +		idle_cooling_dev = list_first_entry(&cpu_idle_cooling_dev_list,
> > +				struct cpu_idle_cooling_device, node);
> > +		cpu_idle_cooling_unregister(idle_cooling_dev->cooling_dev);
> > +	}
> > +
> > +	if (hp_state > 0)
> > +		cpuhp_remove_state_nocalls(hp_state);
> > +}
> > +
> > +static int __init cpu_idle_cooling_init(void)
> > +{
> > +	struct thermal_cooling_device *ret;
> > +	cpumask_t rest_cpu_mask = CPU_MASK_ALL;
> > +	const struct cpumask *register_cpu_mask;
> > +
> > +	hp_state = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN,
> > +			"thermal/cpu_idle_cooling:online",
> > +			idle_injection_cpu_online,
> > +			idle_injection_cpu_predown);
> > +	if (hp_state < 0)
> > +		return hp_state;
> > +
> > +	do {
> > +		register_cpu_mask =
> > +			topology_core_cpumask(cpumask_first(&rest_cpu_mask));
> > +
> > +		if (cpumask_empty(register_cpu_mask))
> > +			break;
> > +
> > +		ret = cpu_idle_cooling_register(register_cpu_mask);
> > +		if (IS_ERR(ret)) {
> > +			__cpu_idle_cooling_exit();
> > +			return -ENOMEM;
> > +		}
> > +	} while (cpumask_andnot(&rest_cpu_mask,
> > +				&rest_cpu_mask,
> > +				register_cpu_mask));
> > +
> > +	return 0;
> > +}
> > +module_init(cpu_idle_cooling_init);
> > +
> > +static void __exit cpu_idle_cooling_exit(void)
> > +{
> > +	__cpu_idle_cooling_exit();
> > +}
> > +module_exit(cpu_idle_cooling_exit);
> > +
> > +MODULE_LICENSE("GPL v2");
> > +MODULE_AUTHOR("Tao Wang <kevin.wangtao@hisilicon.com>");
> > +MODULE_DESCRIPTION("CPU Idle Cooling Driver for ARM Platform");
> > -- 
> > 1.7.9.5
> 
> -- 
> viresh

-- 

 <http://www.linaro.org/> Linaro.org │ Open source software for ARM SoCs

Follow Linaro:  <http://www.facebook.com/pages/Linaro> Facebook |
<http://twitter.com/#!/linaroorg> Twitter |
<http://www.linaro.org/linaro-blog/> Blog