Merge branches 'pm-cpuidle' and 'pm-cpufreq' (a91e99e2) · Commits · 戴 / test

drivers/cpufreq/cpufreq-dt.c

+17 −4

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@
		#include <linux/cpu.h>
		#include <linux/cpu_cooling.h>
		#include <linux/cpufreq.h>
		#include <linux/cpufreq-dt.h>
		#include <linux/cpumask.h>
		#include <linux/err.h>
		#include <linux/module.h>
		@@ -146,7 +147,7 @@ try_again:
		goto try_again;
		}

		dev_warn(cpu_dev, "failed to get cpu%d regulator: %ld\n",
		dev_dbg(cpu_dev, "no regulator for cpu%d: %ld\n",
		cpu, PTR_ERR(cpu_reg));
		}

		@@ -178,6 +179,7 @@ try_again:

		static int cpufreq_init(struct cpufreq_policy *policy)
		{
		struct cpufreq_dt_platform_data *pd;
		struct cpufreq_frequency_table *freq_table;
		struct thermal_cooling_device *cdev;
		struct device_node *np;
		@@ -265,9 +267,18 @@ static int cpufreq_init(struct cpufreq_policy *policy)
		policy->driver_data = priv;

		policy->clk = cpu_clk;
		ret = cpufreq_generic_init(policy, freq_table, transition_latency);
		if (ret)
		ret = cpufreq_table_validate_and_show(policy, freq_table);
		if (ret) {
		dev_err(cpu_dev, "%s: invalid frequency table: %d\n", __func__,
		ret);
		goto out_cooling_unregister;
		}

		policy->cpuinfo.transition_latency = transition_latency;

		pd = cpufreq_get_driver_data();
		if (pd && !pd->independent_clocks)
		cpumask_setall(policy->cpus);

		of_node_put(np);

		@@ -335,6 +346,8 @@ static int dt_cpufreq_probe(struct platform_device *pdev)
		if (!IS_ERR(cpu_reg))
		regulator_put(cpu_reg);

		dt_cpufreq_driver.driver_data = dev_get_platdata(&pdev->dev);

		ret = cpufreq_register_driver(&dt_cpufreq_driver);
		if (ret)
		dev_err(cpu_dev, "failed register driver: %d\n", ret);

drivers/cpufreq/cpufreq.c

+32 −6

Original line number	Diff line number	Diff line
		@@ -512,7 +512,18 @@ show_one(cpuinfo_max_freq, cpuinfo.max_freq);
		show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
		show_one(scaling_min_freq, min);
		show_one(scaling_max_freq, max);
		show_one(scaling_cur_freq, cur);

		static ssize_t show_scaling_cur_freq(
		struct cpufreq_policy policy, char buf)
		{
		ssize_t ret;

		if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
		ret = sprintf(buf, "%u\n", cpufreq_driver->get(policy->cpu));
		else
		ret = sprintf(buf, "%u\n", policy->cur);
		return ret;
		}

		static int cpufreq_set_policy(struct cpufreq_policy *policy,
		struct cpufreq_policy *new_policy);
		@@ -906,11 +917,11 @@ static int cpufreq_add_dev_interface(struct cpufreq_policy *policy,
		if (ret)
		goto err_out_kobj_put;
		}
		if (has_target()) {

		ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
		if (ret)
		goto err_out_kobj_put;
		}

		if (cpufreq_driver->bios_limit) {
		ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
		if (ret)
		@@ -1731,6 +1742,21 @@ const char *cpufreq_get_current_driver(void)
		}
		EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);

		/**
		* cpufreq_get_driver_data - return current driver data
		*
		* Return the private data of the currently loaded cpufreq
		* driver, or NULL if no cpufreq driver is loaded.
		*/
		void *cpufreq_get_driver_data(void)
		{
		if (cpufreq_driver)
		return cpufreq_driver->driver_data;

		return NULL;
		}
		EXPORT_SYMBOL_GPL(cpufreq_get_driver_data);

		/*********************************************************************
		* NOTIFIER LISTS INTERFACE *
		*********************************************************************/

drivers/cpufreq/intel_pstate.c

+88 −22

Original line number	Diff line number	Diff line
		@@ -52,6 +52,17 @@ static inline int32_t div_fp(int32_t x, int32_t y)
		return div_s64((int64_t)x << FRAC_BITS, y);
		}

		static inline int ceiling_fp(int32_t x)
		{
		int mask, ret;

		ret = fp_toint(x);
		mask = (1 << FRAC_BITS) - 1;
		if (x & mask)
		ret += 1;
		return ret;
		}

		struct sample {
		int32_t core_pct_busy;
		u64 aperf;
		@@ -64,6 +75,7 @@ struct pstate_data {
		int current_pstate;
		int min_pstate;
		int max_pstate;
		int scaling;
		int turbo_pstate;
		};

		@@ -113,6 +125,7 @@ struct pstate_funcs {
		int (*get_max)(void);
		int (*get_min)(void);
		int (*get_turbo)(void);
		int (*get_scaling)(void);
		void (set)(struct cpudata, int pstate);
		void (get_vid)(struct cpudata );
		};
		@@ -138,6 +151,7 @@ struct perf_limits {

		static struct perf_limits limits = {
		.no_turbo = 0,
		.turbo_disabled = 0,
		.max_perf_pct = 100,
		.max_perf = int_tofp(1),
		.min_perf_pct = 0,
		@@ -218,6 +232,18 @@ static inline void intel_pstate_reset_all_pid(void)
		}
		}

		static inline void update_turbo_state(void)
		{
		u64 misc_en;
		struct cpudata *cpu;

		cpu = all_cpu_data[0];
		rdmsrl(MSR_IA32_MISC_ENABLE, misc_en);
		limits.turbo_disabled =
		(misc_en & MSR_IA32_MISC_ENABLE_TURBO_DISABLE \|\|
		cpu->pstate.max_pstate == cpu->pstate.turbo_pstate);
		}

		/************************ debugfs begin **********************/
		static int pid_param_set(void *data, u64 val)
		{
		@@ -274,6 +300,20 @@ static void __init intel_pstate_debug_expose_params(void)
		return sprintf(buf, "%u\n", limits.object); \
		}

		static ssize_t show_no_turbo(struct kobject *kobj,
		struct attribute attr, char buf)
		{
		ssize_t ret;

		update_turbo_state();
		if (limits.turbo_disabled)
		ret = sprintf(buf, "%u\n", limits.turbo_disabled);
		else
		ret = sprintf(buf, "%u\n", limits.no_turbo);

		return ret;
		}

		static ssize_t store_no_turbo(struct kobject a, struct attribute b,
		const char *buf, size_t count)
		{
		@@ -283,11 +323,14 @@ static ssize_t store_no_turbo(struct kobject a, struct attribute b,
		ret = sscanf(buf, "%u", &input);
		if (ret != 1)
		return -EINVAL;
		limits.no_turbo = clamp_t(int, input, 0 , 1);

		update_turbo_state();
		if (limits.turbo_disabled) {
		pr_warn("Turbo disabled by BIOS or unavailable on processor\n");
		limits.no_turbo = limits.turbo_disabled;
		return -EPERM;
		}
		limits.no_turbo = clamp_t(int, input, 0, 1);

		return count;
		}

		@@ -323,7 +366,6 @@ static ssize_t store_min_perf_pct(struct kobject a, struct attribute b,
		return count;
		}

		show_one(no_turbo, no_turbo);
		show_one(max_perf_pct, max_perf_pct);
		show_one(min_perf_pct, min_perf_pct);

		@@ -394,7 +436,7 @@ static void byt_set_pstate(struct cpudata *cpudata, int pstate)
		cpudata->vid.ratio);

		vid_fp = clamp_t(int32_t, vid_fp, cpudata->vid.min, cpudata->vid.max);
		vid = fp_toint(vid_fp);
		vid = ceiling_fp(vid_fp);

		if (pstate > cpudata->pstate.max_pstate)
		vid = cpudata->vid.turbo;
		@@ -404,6 +446,22 @@ static void byt_set_pstate(struct cpudata *cpudata, int pstate)
		wrmsrl(MSR_IA32_PERF_CTL, val);
		}

		#define BYT_BCLK_FREQS 5
		static int byt_freq_table[BYT_BCLK_FREQS] = { 833, 1000, 1333, 1167, 800};

		static int byt_get_scaling(void)
		{
		u64 value;
		int i;

		rdmsrl(MSR_FSB_FREQ, value);
		i = value & 0x3;

		BUG_ON(i > BYT_BCLK_FREQS);

		return byt_freq_table[i] * 100;
		}

		static void byt_get_vid(struct cpudata *cpudata)
		{
		u64 value;
		@@ -449,6 +507,11 @@ static int core_get_turbo_pstate(void)
		return ret;
		}

		static inline int core_get_scaling(void)
		{
		return 100000;
		}

		static void core_set_pstate(struct cpudata *cpudata, int pstate)
		{
		u64 val;
		@@ -473,6 +536,7 @@ static struct cpu_defaults core_params = {
		.get_max = core_get_max_pstate,
		.get_min = core_get_min_pstate,
		.get_turbo = core_get_turbo_pstate,
		.get_scaling = core_get_scaling,
		.set = core_set_pstate,
		},
		};
		@@ -491,6 +555,7 @@ static struct cpu_defaults byt_params = {
		.get_min = byt_get_min_pstate,
		.get_turbo = byt_get_turbo_pstate,
		.set = byt_set_pstate,
		.get_scaling = byt_get_scaling,
		.get_vid = byt_get_vid,
		},
		};
		@@ -501,7 +566,7 @@ static void intel_pstate_get_min_max(struct cpudata cpu, int min, int *max)
		int max_perf_adj;
		int min_perf;

		if (limits.no_turbo)
		if (limits.no_turbo \|\| limits.turbo_disabled)
		max_perf = cpu->pstate.max_pstate;

		max_perf_adj = fp_toint(mul_fp(int_tofp(max_perf), limits.max_perf));
		@@ -516,6 +581,8 @@ static void intel_pstate_set_pstate(struct cpudata *cpu, int pstate)
		{
		int max_perf, min_perf;

		update_turbo_state();

		intel_pstate_get_min_max(cpu, &min_perf, &max_perf);

		pstate = clamp_t(int, pstate, min_perf, max_perf);
		@@ -523,7 +590,7 @@ static void intel_pstate_set_pstate(struct cpudata *cpu, int pstate)
		if (pstate == cpu->pstate.current_pstate)
		return;

		trace_cpu_frequency(pstate * 100000, cpu->cpu);
		trace_cpu_frequency(pstate * cpu->pstate.scaling, cpu->cpu);

		cpu->pstate.current_pstate = pstate;

		@@ -535,6 +602,7 @@ static void intel_pstate_get_cpu_pstates(struct cpudata *cpu)
		cpu->pstate.min_pstate = pstate_funcs.get_min();
		cpu->pstate.max_pstate = pstate_funcs.get_max();
		cpu->pstate.turbo_pstate = pstate_funcs.get_turbo();
		cpu->pstate.scaling = pstate_funcs.get_scaling();

		if (pstate_funcs.get_vid)
		pstate_funcs.get_vid(cpu);
		@@ -550,7 +618,9 @@ static inline void intel_pstate_calc_busy(struct cpudata *cpu)
		core_pct = div64_u64(core_pct, int_tofp(sample->mperf));

		sample->freq = fp_toint(
		mul_fp(int_tofp(cpu->pstate.max_pstate * 1000), core_pct));
		mul_fp(int_tofp(
		cpu->pstate.max_pstate * cpu->pstate.scaling / 100),
		core_pct));

		sample->core_pct_busy = (int32_t)core_pct;
		}
		@@ -671,7 +741,9 @@ static int intel_pstate_init_cpu(unsigned int cpunum)
		{
		struct cpudata *cpu;

		all_cpu_data[cpunum] = kzalloc(sizeof(struct cpudata), GFP_KERNEL);
		if (!all_cpu_data[cpunum])
		all_cpu_data[cpunum] = kzalloc(sizeof(struct cpudata),
		GFP_KERNEL);
		if (!all_cpu_data[cpunum])
		return -ENOMEM;

		@@ -714,9 +786,10 @@ static int intel_pstate_set_policy(struct cpufreq_policy *policy)
		if (policy->policy == CPUFREQ_POLICY_PERFORMANCE) {
		limits.min_perf_pct = 100;
		limits.min_perf = int_tofp(1);
		limits.max_policy_pct = 100;
		limits.max_perf_pct = 100;
		limits.max_perf = int_tofp(1);
		limits.no_turbo = limits.turbo_disabled;
		limits.no_turbo = 0;
		return 0;
		}
		limits.min_perf_pct = (policy->min * 100) / policy->cpuinfo.max_freq;
		@@ -751,15 +824,12 @@ static void intel_pstate_stop_cpu(struct cpufreq_policy *policy)

		del_timer_sync(&all_cpu_data[cpu_num]->timer);
		intel_pstate_set_pstate(cpu, cpu->pstate.min_pstate);
		kfree(all_cpu_data[cpu_num]);
		all_cpu_data[cpu_num] = NULL;
		}

		static int intel_pstate_cpu_init(struct cpufreq_policy *policy)
		{
		struct cpudata *cpu;
		int rc;
		u64 misc_en;

		rc = intel_pstate_init_cpu(policy->cpu);
		if (rc)
		@@ -767,23 +837,18 @@ static int intel_pstate_cpu_init(struct cpufreq_policy *policy)

		cpu = all_cpu_data[policy->cpu];

		rdmsrl(MSR_IA32_MISC_ENABLE, misc_en);
		if (misc_en & MSR_IA32_MISC_ENABLE_TURBO_DISABLE \|\|
		cpu->pstate.max_pstate == cpu->pstate.turbo_pstate) {
		limits.turbo_disabled = 1;
		limits.no_turbo = 1;
		}
		if (limits.min_perf_pct == 100 && limits.max_perf_pct == 100)
		policy->policy = CPUFREQ_POLICY_PERFORMANCE;
		else
		policy->policy = CPUFREQ_POLICY_POWERSAVE;

		policy->min = cpu->pstate.min_pstate * 100000;
		policy->max = cpu->pstate.turbo_pstate * 100000;
		policy->min = cpu->pstate.min_pstate * cpu->pstate.scaling;
		policy->max = cpu->pstate.turbo_pstate * cpu->pstate.scaling;

		/* cpuinfo and default policy values */
		policy->cpuinfo.min_freq = cpu->pstate.min_pstate * 100000;
		policy->cpuinfo.max_freq = cpu->pstate.turbo_pstate * 100000;
		policy->cpuinfo.min_freq = cpu->pstate.min_pstate * cpu->pstate.scaling;
		policy->cpuinfo.max_freq =
		cpu->pstate.turbo_pstate * cpu->pstate.scaling;
		policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL;
		cpumask_set_cpu(policy->cpu, policy->cpus);

		@@ -841,6 +906,7 @@ static void copy_cpu_funcs(struct pstate_funcs *funcs)
		pstate_funcs.get_max = funcs->get_max;
		pstate_funcs.get_min = funcs->get_min;
		pstate_funcs.get_turbo = funcs->get_turbo;
		pstate_funcs.get_scaling = funcs->get_scaling;
		pstate_funcs.set = funcs->set;
		pstate_funcs.get_vid = funcs->get_vid;
		}

drivers/cpuidle/cpuidle-powernv.c

+22 −5

Original line number	Diff line number	Diff line
		@@ -163,7 +163,8 @@ static int powernv_add_idle_states(void)
		int nr_idle_states = 1; /* Snooze */
		int dt_idle_states;
		const __be32 *idle_state_flags;
		u32 len_flags, flags;
		const __be32 *idle_state_latency;
		u32 len_flags, flags, latency_ns;
		int i;

		/* Currently we have snooze statically defined */
		@@ -180,18 +181,32 @@ static int powernv_add_idle_states(void)
		return nr_idle_states;
		}

		idle_state_latency = of_get_property(power_mgt,
		"ibm,cpu-idle-state-latencies-ns", NULL);
		if (!idle_state_latency) {
		pr_warn("DT-PowerMgmt: missing ibm,cpu-idle-state-latencies-ns\n");
		return nr_idle_states;
		}

		dt_idle_states = len_flags / sizeof(u32);

		for (i = 0; i < dt_idle_states; i++) {

		flags = be32_to_cpu(idle_state_flags[i]);

		/* Cpuidle accepts exit_latency in us and we estimate
		* target residency to be 10x exit_latency
		*/
		latency_ns = be32_to_cpu(idle_state_latency[i]);
		if (flags & IDLE_USE_INST_NAP) {
		/* Add NAP state */
		strcpy(powernv_states[nr_idle_states].name, "Nap");
		strcpy(powernv_states[nr_idle_states].desc, "Nap");
		powernv_states[nr_idle_states].flags = CPUIDLE_FLAG_TIME_VALID;
		powernv_states[nr_idle_states].exit_latency = 10;
		powernv_states[nr_idle_states].target_residency = 100;
		powernv_states[nr_idle_states].exit_latency =
		((unsigned int)latency_ns) / 1000;
		powernv_states[nr_idle_states].target_residency =
		((unsigned int)latency_ns / 100);
		powernv_states[nr_idle_states].enter = &nap_loop;
		nr_idle_states++;
		}
		@@ -202,8 +217,10 @@ static int powernv_add_idle_states(void)
		strcpy(powernv_states[nr_idle_states].desc, "FastSleep");
		powernv_states[nr_idle_states].flags =
		CPUIDLE_FLAG_TIME_VALID \| CPUIDLE_FLAG_TIMER_STOP;
		powernv_states[nr_idle_states].exit_latency = 300;
		powernv_states[nr_idle_states].target_residency = 1000000;
		powernv_states[nr_idle_states].exit_latency =
		((unsigned int)latency_ns) / 1000;
		powernv_states[nr_idle_states].target_residency =
		((unsigned int)latency_ns / 100);
		powernv_states[nr_idle_states].enter = &fastsleep_loop;
		nr_idle_states++;
		}

include/linux/cpufreq-dt.h

0 → 100644

+22 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 Marvell
		* Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 as
		* published by the Free Software Foundation.
		*/

		#ifndef __CPUFREQ_DT_H__
		#define __CPUFREQ_DT_H__

		struct cpufreq_dt_platform_data {
		/*
		* True when each CPU has its own clock to control its
		* frequency, false when all CPUs are controlled by a single
		* clock.
		*/
		bool independent_clocks;
		};

		#endif /* __CPUFREQ_DT_H__ */

Admin message