[deliverable/linux.git] / drivers / cpufreq / cpufreq-dt.c

/*
 * Copyright (C) 2012 Freescale Semiconductor, Inc.
 *
 * Copyright (C) 2014 Linaro.
 * Viresh Kumar <viresh.kumar@linaro.org>
 *
 * The OPP code in function set_target() is reused from
 * drivers/cpufreq/omap-cpufreq.c
 *
 * 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.
 */

#define pr_fmt(fmt)	KBUILD_MODNAME ": " fmt

#include <linux/clk.h>
#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>
#include <linux/of.h>
#include <linux/pm_opp.h>
#include <linux/platform_device.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/thermal.h>

struct private_data {
	struct device *cpu_dev;
	struct regulator *cpu_reg;
	struct thermal_cooling_device *cdev;
	unsigned int voltage_tolerance; /* in percentage */
};

static struct freq_attr *cpufreq_dt_attr[] = {
	&cpufreq_freq_attr_scaling_available_freqs,
	NULL,   /* Extra space for boost-attr if required */
	NULL,
};

static int set_target(struct cpufreq_policy *policy, unsigned int index)
{
	struct dev_pm_opp *opp;
	struct cpufreq_frequency_table *freq_table = policy->freq_table;
	struct clk *cpu_clk = policy->clk;
	struct private_data *priv = policy->driver_data;
	struct device *cpu_dev = priv->cpu_dev;
	struct regulator *cpu_reg = priv->cpu_reg;
	unsigned long volt = 0, volt_old = 0, tol = 0;
	unsigned int old_freq, new_freq;
	long freq_Hz, freq_exact;
	int ret;

	freq_Hz = clk_round_rate(cpu_clk, freq_table[index].frequency * 1000);
	if (freq_Hz <= 0)
		freq_Hz = freq_table[index].frequency * 1000;

	freq_exact = freq_Hz;
	new_freq = freq_Hz / 1000;
	old_freq = clk_get_rate(cpu_clk) / 1000;

	if (!IS_ERR(cpu_reg)) {
		unsigned long opp_freq;

		rcu_read_lock();
		opp = dev_pm_opp_find_freq_ceil(cpu_dev, &freq_Hz);
		if (IS_ERR(opp)) {
			rcu_read_unlock();
			dev_err(cpu_dev, "failed to find OPP for %ld\n",
				freq_Hz);
			return PTR_ERR(opp);
		}
		volt = dev_pm_opp_get_voltage(opp);
		opp_freq = dev_pm_opp_get_freq(opp);
		rcu_read_unlock();
		tol = volt * priv->voltage_tolerance / 100;
		volt_old = regulator_get_voltage(cpu_reg);
		dev_dbg(cpu_dev, "Found OPP: %ld kHz, %ld uV\n",
			opp_freq / 1000, volt);
	}

	dev_dbg(cpu_dev, "%u MHz, %ld mV --> %u MHz, %ld mV\n",
		old_freq / 1000, (volt_old > 0) ? volt_old / 1000 : -1,
		new_freq / 1000, volt ? volt / 1000 : -1);

	/* scaling up?  scale voltage before frequency */
	if (!IS_ERR(cpu_reg) && new_freq > old_freq) {
		ret = regulator_set_voltage_tol(cpu_reg, volt, tol);
		if (ret) {
			dev_err(cpu_dev, "failed to scale voltage up: %d\n",
				ret);
			return ret;
		}
	}

	ret = clk_set_rate(cpu_clk, freq_exact);
	if (ret) {
		dev_err(cpu_dev, "failed to set clock rate: %d\n", ret);
		if (!IS_ERR(cpu_reg) && volt_old > 0)
			regulator_set_voltage_tol(cpu_reg, volt_old, tol);
		return ret;
	}

	/* scaling down?  scale voltage after frequency */
	if (!IS_ERR(cpu_reg) && new_freq < old_freq) {
		ret = regulator_set_voltage_tol(cpu_reg, volt, tol);
		if (ret) {
			dev_err(cpu_dev, "failed to scale voltage down: %d\n",
				ret);
			clk_set_rate(cpu_clk, old_freq * 1000);
		}
	}

	return ret;
}

static int allocate_resources(int cpu, struct device **cdev,
			      struct regulator **creg, struct clk **cclk)
{
	struct device *cpu_dev;
	struct regulator *cpu_reg;
	struct clk *cpu_clk;
	int ret = 0;
	char *reg_cpu0 = "cpu0", *reg_cpu = "cpu", *reg;

	cpu_dev = get_cpu_device(cpu);
	if (!cpu_dev) {
		pr_err("failed to get cpu%d device\n", cpu);
		return -ENODEV;
	}

	/* Try "cpu0" for older DTs */
	if (!cpu)
		reg = reg_cpu0;
	else
		reg = reg_cpu;

try_again:
	cpu_reg = regulator_get_optional(cpu_dev, reg);
	if (IS_ERR(cpu_reg)) {
		/*
		 * If cpu's regulator supply node is present, but regulator is
		 * not yet registered, we should try defering probe.
		 */
		if (PTR_ERR(cpu_reg) == -EPROBE_DEFER) {
			dev_dbg(cpu_dev, "cpu%d regulator not ready, retry\n",
				cpu);
			return -EPROBE_DEFER;
		}

		/* Try with "cpu-supply" */
		if (reg == reg_cpu0) {
			reg = reg_cpu;
			goto try_again;
		}

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

	cpu_clk = clk_get(cpu_dev, NULL);
	if (IS_ERR(cpu_clk)) {
		/* put regulator */
		if (!IS_ERR(cpu_reg))
			regulator_put(cpu_reg);

		ret = PTR_ERR(cpu_clk);

		/*
		 * If cpu's clk node is present, but clock is not yet
		 * registered, we should try defering probe.
		 */
		if (ret == -EPROBE_DEFER)
			dev_dbg(cpu_dev, "cpu%d clock not ready, retry\n", cpu);
		else
			dev_err(cpu_dev, "failed to get cpu%d clock: %d\n", cpu,
				ret);
	} else {
		*cdev = cpu_dev;
		*creg = cpu_reg;
		*cclk = cpu_clk;
	}

	return ret;
}

static int cpufreq_init(struct cpufreq_policy *policy)
{
	struct cpufreq_frequency_table *freq_table;
	struct device_node *np;
	struct private_data *priv;
	struct device *cpu_dev;
	struct regulator *cpu_reg;
	struct clk *cpu_clk;
	struct dev_pm_opp *suspend_opp;
	unsigned long min_uV = ~0, max_uV = 0;
	unsigned int transition_latency;
	bool need_update = false;
	int ret;

	ret = allocate_resources(policy->cpu, &cpu_dev, &cpu_reg, &cpu_clk);
	if (ret) {
		pr_err("%s: Failed to allocate resources: %d\n", __func__, ret);
		return ret;
	}

	np = of_node_get(cpu_dev->of_node);
	if (!np) {
		dev_err(cpu_dev, "failed to find cpu%d node\n", policy->cpu);
		ret = -ENOENT;
		goto out_put_reg_clk;
	}

	/* Get OPP-sharing information from "operating-points-v2" bindings */
	ret = of_get_cpus_sharing_opps(cpu_dev, policy->cpus);
	if (ret) {
		/*
		 * operating-points-v2 not supported, fallback to old method of
		 * finding shared-OPPs for backward compatibility.
		 */
		if (ret == -ENOENT)
			need_update = true;
		else
			goto out_node_put;
	}

	/*
	 * Initialize OPP tables for all policy->cpus. They will be shared by
	 * all CPUs which have marked their CPUs shared with OPP bindings.
	 *
	 * For platforms not using operating-points-v2 bindings, we do this
	 * before updating policy->cpus. Otherwise, we will end up creating
	 * duplicate OPPs for policy->cpus.
	 *
	 * OPPs might be populated at runtime, don't check for error here
	 */
	of_cpumask_init_opp_table(policy->cpus);

	/*
	 * But we need OPP table to function so if it is not there let's
	 * give platform code chance to provide it for us.
	 */
	ret = dev_pm_opp_get_opp_count(cpu_dev);
	if (ret <= 0) {
		pr_debug("OPP table is not ready, deferring probe\n");
		ret = -EPROBE_DEFER;
		goto out_free_opp;
	}

	if (need_update) {
		struct cpufreq_dt_platform_data *pd = cpufreq_get_driver_data();

		if (!pd || !pd->independent_clocks)
			cpumask_setall(policy->cpus);

		/*
		 * OPP tables are initialized only for policy->cpu, do it for
		 * others as well.
		 */
		ret = set_cpus_sharing_opps(cpu_dev, policy->cpus);
		if (ret)
			dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n",
				__func__, ret);

		of_property_read_u32(np, "clock-latency", &transition_latency);
	} else {
		transition_latency = dev_pm_opp_get_max_clock_latency(cpu_dev);
	}

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv) {
		ret = -ENOMEM;
		goto out_free_opp;
	}

	of_property_read_u32(np, "voltage-tolerance", &priv->voltage_tolerance);

	if (!transition_latency)
		transition_latency = CPUFREQ_ETERNAL;

	if (!IS_ERR(cpu_reg)) {
		unsigned long opp_freq = 0;

		/*
		 * Disable any OPPs where the connected regulator isn't able to
		 * provide the specified voltage and record minimum and maximum
		 * voltage levels.
		 */
		while (1) {
			struct dev_pm_opp *opp;
			unsigned long opp_uV, tol_uV;

			rcu_read_lock();
			opp = dev_pm_opp_find_freq_ceil(cpu_dev, &opp_freq);
			if (IS_ERR(opp)) {
				rcu_read_unlock();
				break;
			}
			opp_uV = dev_pm_opp_get_voltage(opp);
			rcu_read_unlock();

			tol_uV = opp_uV * priv->voltage_tolerance / 100;
			if (regulator_is_supported_voltage(cpu_reg,
							   opp_uV - tol_uV,
							   opp_uV + tol_uV)) {
				if (opp_uV < min_uV)
					min_uV = opp_uV;
				if (opp_uV > max_uV)
					max_uV = opp_uV;
			} else {
				dev_pm_opp_disable(cpu_dev, opp_freq);
			}

			opp_freq++;
		}

		ret = regulator_set_voltage_time(cpu_reg, min_uV, max_uV);
		if (ret > 0)
			transition_latency += ret * 1000;
	}

	ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
	if (ret) {
		pr_err("failed to init cpufreq table: %d\n", ret);
		goto out_free_priv;
	}

	priv->cpu_dev = cpu_dev;
	priv->cpu_reg = cpu_reg;
	policy->driver_data = priv;

	policy->clk = cpu_clk;

	rcu_read_lock();
	suspend_opp = dev_pm_opp_get_suspend_opp(cpu_dev);
	if (suspend_opp)
		policy->suspend_freq = dev_pm_opp_get_freq(suspend_opp) / 1000;
	rcu_read_unlock();

	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_free_cpufreq_table;
	}

	/* Support turbo/boost mode */
	if (policy_has_boost_freq(policy)) {
		/* This gets disabled by core on driver unregister */
		ret = cpufreq_enable_boost_support();
		if (ret)
			goto out_free_cpufreq_table;
		cpufreq_dt_attr[1] = &cpufreq_freq_attr_scaling_boost_freqs;
	}

	policy->cpuinfo.transition_latency = transition_latency;

	of_node_put(np);

	return 0;

out_free_cpufreq_table:
	dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
out_free_priv:
	kfree(priv);
out_free_opp:
	of_cpumask_free_opp_table(policy->cpus);
out_node_put:
	of_node_put(np);
out_put_reg_clk:
	clk_put(cpu_clk);
	if (!IS_ERR(cpu_reg))
		regulator_put(cpu_reg);

	return ret;
}

static int cpufreq_exit(struct cpufreq_policy *policy)
{
	struct private_data *priv = policy->driver_data;

	cpufreq_cooling_unregister(priv->cdev);
	dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
	of_cpumask_free_opp_table(policy->related_cpus);
	clk_put(policy->clk);
	if (!IS_ERR(priv->cpu_reg))
		regulator_put(priv->cpu_reg);
	kfree(priv);

	return 0;
}

static void cpufreq_ready(struct cpufreq_policy *policy)
{
	struct private_data *priv = policy->driver_data;
	struct device_node *np = of_node_get(priv->cpu_dev->of_node);

	if (WARN_ON(!np))
		return;

	/*
	 * For now, just loading the cooling device;
	 * thermal DT code takes care of matching them.
	 */
	if (of_find_property(np, "#cooling-cells", NULL)) {
		priv->cdev = of_cpufreq_cooling_register(np,
							 policy->related_cpus);
		if (IS_ERR(priv->cdev)) {
			dev_err(priv->cpu_dev,
				"running cpufreq without cooling device: %ld\n",
				PTR_ERR(priv->cdev));

			priv->cdev = NULL;
		}
	}

	of_node_put(np);
}

static struct cpufreq_driver dt_cpufreq_driver = {
	.flags = CPUFREQ_STICKY | CPUFREQ_NEED_INITIAL_FREQ_CHECK,
	.verify = cpufreq_generic_frequency_table_verify,
	.target_index = set_target,
	.get = cpufreq_generic_get,
	.init = cpufreq_init,
	.exit = cpufreq_exit,
	.ready = cpufreq_ready,
	.name = "cpufreq-dt",
	.attr = cpufreq_dt_attr,
	.suspend = cpufreq_generic_suspend,
};

static int dt_cpufreq_probe(struct platform_device *pdev)
{
	struct device *cpu_dev;
	struct regulator *cpu_reg;
	struct clk *cpu_clk;
	int ret;

	/*
	 * All per-cluster (CPUs sharing clock/voltages) initialization is done
	 * from ->init(). In probe(), we just need to make sure that clk and
	 * regulators are available. Else defer probe and retry.
	 *
	 * FIXME: Is checking this only for CPU0 sufficient ?
	 */
	ret = allocate_resources(0, &cpu_dev, &cpu_reg, &cpu_clk);
	if (ret)
		return ret;

	clk_put(cpu_clk);
	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);

	return ret;
}

static int dt_cpufreq_remove(struct platform_device *pdev)
{
	cpufreq_unregister_driver(&dt_cpufreq_driver);
	return 0;
}

static struct platform_driver dt_cpufreq_platdrv = {
	.driver = {
		.name	= "cpufreq-dt",
	},
	.probe		= dt_cpufreq_probe,
	.remove		= dt_cpufreq_remove,
};
module_platform_driver(dt_cpufreq_platdrv);

MODULE_ALIAS("platform:cpufreq-dt");
MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
MODULE_DESCRIPTION("Generic cpufreq driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
95ceafd4 SG	1	/*
	2	* Copyright (C) 2012 Freescale Semiconductor, Inc.
	3	*
748c8766 VK	4	* Copyright (C) 2014 Linaro.
	5	* Viresh Kumar <viresh.kumar@linaro.org>
	6	*
bbcf0719	7	* The OPP code in function set_target() is reused from
95ceafd4 SG	8	* drivers/cpufreq/omap-cpufreq.c
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*/
	14
	15	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	16
	17	#include <linux/clk.h>
e1825b25	18	#include <linux/cpu.h>
77cff592	19	#include <linux/cpu_cooling.h>
95ceafd4	20	#include <linux/cpufreq.h>
34e5a527	21	#include <linux/cpufreq-dt.h>
77cff592	22	#include <linux/cpumask.h>
95ceafd4 SG	23	#include <linux/err.h>
	24	#include <linux/module.h>
	25	#include <linux/of.h>
e4db1c74	26	#include <linux/pm_opp.h>
5553f9e2	27	#include <linux/platform_device.h>
95ceafd4 SG	28	#include <linux/regulator/consumer.h>
95ceafd4 SG	29	#include <linux/slab.h>
77cff592	30	#include <linux/thermal.h>
95ceafd4	31
d2f31f1d VK	32	struct private_data {
	33	struct device *cpu_dev;
	34	struct regulator *cpu_reg;
	35	struct thermal_cooling_device *cdev;
	36	unsigned int voltage_tolerance; /* in percentage */
	37	};
95ceafd4	38
21c36d35 BZ	39	static struct freq_attr *cpufreq_dt_attr[] = {
	40	&cpufreq_freq_attr_scaling_available_freqs,
	41	NULL, /* Extra space for boost-attr if required */
	42	NULL,
	43	};
	44
bbcf0719	45	static int set_target(struct cpufreq_policy *policy, unsigned int index)
95ceafd4	46	{
47d43ba7	47	struct dev_pm_opp *opp;
d2f31f1d VK	48	struct cpufreq_frequency_table *freq_table = policy->freq_table;
	49	struct clk *cpu_clk = policy->clk;
	50	struct private_data *priv = policy->driver_data;
	51	struct device *cpu_dev = priv->cpu_dev;
	52	struct regulator *cpu_reg = priv->cpu_reg;
5df60559	53	unsigned long volt = 0, volt_old = 0, tol = 0;
d4019f0a	54	unsigned int old_freq, new_freq;
0ca68436	55	long freq_Hz, freq_exact;
95ceafd4 SG	56	int ret;
95ceafd4 SG	57
95ceafd4	58	freq_Hz = clk_round_rate(cpu_clk, freq_table[index].frequency * 1000);
2209b0c9	59	if (freq_Hz <= 0)
95ceafd4	60	freq_Hz = freq_table[index].frequency * 1000;
95ceafd4	61
d4019f0a VK	62	freq_exact = freq_Hz;
	63	new_freq = freq_Hz / 1000;
	64	old_freq = clk_get_rate(cpu_clk) / 1000;
95ceafd4	65
4a511de9	66	if (!IS_ERR(cpu_reg)) {
0a1e879d SW	67	unsigned long opp_freq;
0a1e879d SW	68
78e8eb8f	69	rcu_read_lock();
5d4879cd	70	opp = dev_pm_opp_find_freq_ceil(cpu_dev, &freq_Hz);
95ceafd4	71	if (IS_ERR(opp)) {
78e8eb8f	72	rcu_read_unlock();
fbd48ca5 VK	73	dev_err(cpu_dev, "failed to find OPP for %ld\n",
fbd48ca5 VK	74	freq_Hz);
d4019f0a	75	return PTR_ERR(opp);
95ceafd4	76	}
5d4879cd	77	volt = dev_pm_opp_get_voltage(opp);
0a1e879d	78	opp_freq = dev_pm_opp_get_freq(opp);
78e8eb8f	79	rcu_read_unlock();
d2f31f1d	80	tol = volt * priv->voltage_tolerance / 100;
95ceafd4	81	volt_old = regulator_get_voltage(cpu_reg);
0a1e879d SW	82	dev_dbg(cpu_dev, "Found OPP: %ld kHz, %ld uV\n",
0a1e879d SW	83	opp_freq / 1000, volt);
95ceafd4 SG	84	}
95ceafd4 SG	85
fbd48ca5	86	dev_dbg(cpu_dev, "%u MHz, %ld mV --> %u MHz, %ld mV\n",
8197bb1b	87	old_freq / 1000, (volt_old > 0) ? volt_old / 1000 : -1,
fbd48ca5	88	new_freq / 1000, volt ? volt / 1000 : -1);
95ceafd4 SG	89
95ceafd4 SG	90	/* scaling up? scale voltage before frequency */
d4019f0a	91	if (!IS_ERR(cpu_reg) && new_freq > old_freq) {
95ceafd4 SG	92	ret = regulator_set_voltage_tol(cpu_reg, volt, tol);
95ceafd4 SG	93	if (ret) {
fbd48ca5 VK	94	dev_err(cpu_dev, "failed to scale voltage up: %d\n",
fbd48ca5 VK	95	ret);
d4019f0a	96	return ret;
95ceafd4 SG	97	}
	98	}
	99
0ca68436	100	ret = clk_set_rate(cpu_clk, freq_exact);
95ceafd4	101	if (ret) {
fbd48ca5	102	dev_err(cpu_dev, "failed to set clock rate: %d\n", ret);
8197bb1b	103	if (!IS_ERR(cpu_reg) && volt_old > 0)
95ceafd4	104	regulator_set_voltage_tol(cpu_reg, volt_old, tol);
d4019f0a	105	return ret;
95ceafd4 SG	106	}
	107
	108	/* scaling down? scale voltage after frequency */
d4019f0a	109	if (!IS_ERR(cpu_reg) && new_freq < old_freq) {
95ceafd4 SG	110	ret = regulator_set_voltage_tol(cpu_reg, volt, tol);
95ceafd4 SG	111	if (ret) {
fbd48ca5 VK	112	dev_err(cpu_dev, "failed to scale voltage down: %d\n",
fbd48ca5 VK	113	ret);
d4019f0a	114	clk_set_rate(cpu_clk, old_freq * 1000);
95ceafd4 SG	115	}
	116	}
	117
fd143b4d	118	return ret;
95ceafd4 SG	119	}
95ceafd4 SG	120
95b61058	121	static int allocate_resources(int cpu, struct device **cdev,
d2f31f1d	122	struct regulator creg, struct clk cclk)
95ceafd4	123	{
d2f31f1d VK	124	struct device *cpu_dev;
	125	struct regulator *cpu_reg;
	126	struct clk *cpu_clk;
	127	int ret = 0;
2d2c5e0e	128	char reg_cpu0 = "cpu0", reg_cpu = "cpu", *reg;
95ceafd4	129
95b61058	130	cpu_dev = get_cpu_device(cpu);
e1825b25	131	if (!cpu_dev) {
95b61058	132	pr_err("failed to get cpu%d device\n", cpu);
e1825b25 SK	133	return -ENODEV;
e1825b25 SK	134	}
6754f556	135
2d2c5e0e	136	/* Try "cpu0" for older DTs */
95b61058 VK	137	if (!cpu)
	138	reg = reg_cpu0;
	139	else
	140	reg = reg_cpu;
2d2c5e0e VK	141
	142	try_again:
	143	cpu_reg = regulator_get_optional(cpu_dev, reg);
fc31d6f5 NM	144	if (IS_ERR(cpu_reg)) {
fc31d6f5 NM	145	/*
95b61058	146	* If cpu's regulator supply node is present, but regulator is
fc31d6f5 NM	147	* not yet registered, we should try defering probe.
	148	*/
	149	if (PTR_ERR(cpu_reg) == -EPROBE_DEFER) {
95b61058 VK	150	dev_dbg(cpu_dev, "cpu%d regulator not ready, retry\n",
95b61058 VK	151	cpu);
d2f31f1d	152	return -EPROBE_DEFER;
fc31d6f5	153	}
2d2c5e0e VK	154
	155	/* Try with "cpu-supply" */
	156	if (reg == reg_cpu0) {
	157	reg = reg_cpu;
	158	goto try_again;
	159	}
	160
a00de1ab TP	161	dev_dbg(cpu_dev, "no regulator for cpu%d: %ld\n",
a00de1ab TP	162	cpu, PTR_ERR(cpu_reg));
fc31d6f5 NM	163	}
fc31d6f5 NM	164
e3beb0ac	165	cpu_clk = clk_get(cpu_dev, NULL);
95ceafd4	166	if (IS_ERR(cpu_clk)) {
d2f31f1d VK	167	/* put regulator */
	168	if (!IS_ERR(cpu_reg))
	169	regulator_put(cpu_reg);
	170
95ceafd4	171	ret = PTR_ERR(cpu_clk);
48a8624b VK	172
	173	/*
	174	* If cpu's clk node is present, but clock is not yet
	175	* registered, we should try defering probe.
	176	*/
	177	if (ret == -EPROBE_DEFER)
95b61058	178	dev_dbg(cpu_dev, "cpu%d clock not ready, retry\n", cpu);
48a8624b	179	else
71796210 AK	180	dev_err(cpu_dev, "failed to get cpu%d clock: %d\n", cpu,
71796210 AK	181	ret);
d2f31f1d VK	182	} else {
	183	*cdev = cpu_dev;
	184	*creg = cpu_reg;
	185	*cclk = cpu_clk;
	186	}
	187
	188	return ret;
	189	}
	190
bbcf0719	191	static int cpufreq_init(struct cpufreq_policy *policy)
d2f31f1d VK	192	{
d2f31f1d VK	193	struct cpufreq_frequency_table *freq_table;
d2f31f1d VK	194	struct device_node *np;
	195	struct private_data *priv;
	196	struct device *cpu_dev;
	197	struct regulator *cpu_reg;
	198	struct clk *cpu_clk;
953ba9ff	199	struct dev_pm_opp *suspend_opp;
045ee45c	200	unsigned long min_uV = ~0, max_uV = 0;
d2f31f1d	201	unsigned int transition_latency;
2e02d872	202	bool need_update = false;
d2f31f1d VK	203	int ret;
d2f31f1d VK	204
95b61058	205	ret = allocate_resources(policy->cpu, &cpu_dev, &cpu_reg, &cpu_clk);
d2f31f1d	206	if (ret) {
edd52b1c	207	pr_err("%s: Failed to allocate resources: %d\n", __func__, ret);
d2f31f1d VK	208	return ret;
d2f31f1d VK	209	}
48a8624b	210
d2f31f1d VK	211	np = of_node_get(cpu_dev->of_node);
	212	if (!np) {
	213	dev_err(cpu_dev, "failed to find cpu%d node\n", policy->cpu);
	214	ret = -ENOENT;
	215	goto out_put_reg_clk;
95ceafd4 SG	216	}
95ceafd4 SG	217
2e02d872 VK	218	/* Get OPP-sharing information from "operating-points-v2" bindings */
	219	ret = of_get_cpus_sharing_opps(cpu_dev, policy->cpus);
	220	if (ret) {
	221	/*
	222	* operating-points-v2 not supported, fallback to old method of
	223	* finding shared-OPPs for backward compatibility.
	224	*/
	225	if (ret == -ENOENT)
	226	need_update = true;
	227	else
	228	goto out_node_put;
	229	}
	230
	231	/*
	232	* Initialize OPP tables for all policy->cpus. They will be shared by
	233	* all CPUs which have marked their CPUs shared with OPP bindings.
	234	*
	235	* For platforms not using operating-points-v2 bindings, we do this
	236	* before updating policy->cpus. Otherwise, we will end up creating
	237	* duplicate OPPs for policy->cpus.
	238	*
	239	* OPPs might be populated at runtime, don't check for error here
	240	*/
	241	of_cpumask_init_opp_table(policy->cpus);
	242
7d5d0c8b VK	243	/*
	244	* But we need OPP table to function so if it is not there let's
	245	* give platform code chance to provide it for us.
	246	*/
	247	ret = dev_pm_opp_get_opp_count(cpu_dev);
	248	if (ret <= 0) {
	249	pr_debug("OPP table is not ready, deferring probe\n");
	250	ret = -EPROBE_DEFER;
	251	goto out_free_opp;
	252	}
	253
2e02d872 VK	254	if (need_update) {
	255	struct cpufreq_dt_platform_data *pd = cpufreq_get_driver_data();
	256
	257	if (!pd \|\| !pd->independent_clocks)
	258	cpumask_setall(policy->cpus);
	259
	260	/*
	261	* OPP tables are initialized only for policy->cpu, do it for
	262	* others as well.
	263	*/
8bc86284 VK	264	ret = set_cpus_sharing_opps(cpu_dev, policy->cpus);
	265	if (ret)
	266	dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n",
	267	__func__, ret);
2e02d872 VK	268
	269	of_property_read_u32(np, "clock-latency", &transition_latency);
	270	} else {
	271	transition_latency = dev_pm_opp_get_max_clock_latency(cpu_dev);
	272	}
95ceafd4	273
d2f31f1d VK	274	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	275	if (!priv) {
	276	ret = -ENOMEM;
2f0f609f	277	goto out_free_opp;
95ceafd4 SG	278	}
95ceafd4 SG	279
d2f31f1d	280	of_property_read_u32(np, "voltage-tolerance", &priv->voltage_tolerance);
95ceafd4	281
2e02d872	282	if (!transition_latency)
95ceafd4 SG	283	transition_latency = CPUFREQ_ETERNAL;
95ceafd4 SG	284
43c638e3	285	if (!IS_ERR(cpu_reg)) {
045ee45c	286	unsigned long opp_freq = 0;
95ceafd4 SG	287
95ceafd4 SG	288	/*
045ee45c LS	289	* Disable any OPPs where the connected regulator isn't able to
	290	* provide the specified voltage and record minimum and maximum
	291	* voltage levels.
95ceafd4	292	*/
045ee45c LS	293	while (1) {
	294	struct dev_pm_opp *opp;
	295	unsigned long opp_uV, tol_uV;
	296
	297	rcu_read_lock();
	298	opp = dev_pm_opp_find_freq_ceil(cpu_dev, &opp_freq);
	299	if (IS_ERR(opp)) {
	300	rcu_read_unlock();
	301	break;
	302	}
	303	opp_uV = dev_pm_opp_get_voltage(opp);
	304	rcu_read_unlock();
	305
	306	tol_uV = opp_uV * priv->voltage_tolerance / 100;
a2022001 VK	307	if (regulator_is_supported_voltage(cpu_reg,
a2022001 VK	308	opp_uV - tol_uV,
045ee45c LS	309	opp_uV + tol_uV)) {
	310	if (opp_uV < min_uV)
	311	min_uV = opp_uV;
	312	if (opp_uV > max_uV)
	313	max_uV = opp_uV;
	314	} else {
	315	dev_pm_opp_disable(cpu_dev, opp_freq);
	316	}
	317
	318	opp_freq++;
	319	}
	320
95ceafd4 SG	321	ret = regulator_set_voltage_time(cpu_reg, min_uV, max_uV);
	322	if (ret > 0)
	323	transition_latency += ret * 1000;
	324	}
	325
045ee45c LS	326	ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
	327	if (ret) {
	328	pr_err("failed to init cpufreq table: %d\n", ret);
	329	goto out_free_priv;
	330	}
	331
d2f31f1d VK	332	priv->cpu_dev = cpu_dev;
	333	priv->cpu_reg = cpu_reg;
	334	policy->driver_data = priv;
	335
	336	policy->clk = cpu_clk;
953ba9ff BZ	337
	338	rcu_read_lock();
	339	suspend_opp = dev_pm_opp_get_suspend_opp(cpu_dev);
	340	if (suspend_opp)
	341	policy->suspend_freq = dev_pm_opp_get_freq(suspend_opp) / 1000;
	342	rcu_read_unlock();
	343
34e5a527 TP	344	ret = cpufreq_table_validate_and_show(policy, freq_table);
	345	if (ret) {
	346	dev_err(cpu_dev, "%s: invalid frequency table: %d\n", __func__,
	347	ret);
9a004428	348	goto out_free_cpufreq_table;
d15fa862 VK	349	}
	350
	351	/* Support turbo/boost mode */
	352	if (policy_has_boost_freq(policy)) {
	353	/* This gets disabled by core on driver unregister */
	354	ret = cpufreq_enable_boost_support();
	355	if (ret)
	356	goto out_free_cpufreq_table;
21c36d35	357	cpufreq_dt_attr[1] = &cpufreq_freq_attr_scaling_boost_freqs;
34e5a527 TP	358	}
	359
	360	policy->cpuinfo.transition_latency = transition_latency;
	361
f9739d27 LS	362	of_node_put(np);
f9739d27 LS	363
95ceafd4 SG	364	return 0;
95ceafd4 SG	365
9a004428	366	out_free_cpufreq_table:
5d4879cd	367	dev_pm_opp_free_cpufreq_table(cpu_dev, &freq_table);
045ee45c LS	368	out_free_priv:
045ee45c LS	369	kfree(priv);
2f0f609f	370	out_free_opp:
2e02d872 VK	371	of_cpumask_free_opp_table(policy->cpus);
2e02d872 VK	372	out_node_put:
d2f31f1d VK	373	of_node_put(np);
d2f31f1d VK	374	out_put_reg_clk:
ed4b053c	375	clk_put(cpu_clk);
e3beb0ac LS	376	if (!IS_ERR(cpu_reg))
e3beb0ac LS	377	regulator_put(cpu_reg);
d2f31f1d VK	378
	379	return ret;
	380	}
	381
bbcf0719	382	static int cpufreq_exit(struct cpufreq_policy *policy)
d2f31f1d VK	383	{
	384	struct private_data *priv = policy->driver_data;
	385
17ad13ba	386	cpufreq_cooling_unregister(priv->cdev);
d2f31f1d	387	dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
2e02d872	388	of_cpumask_free_opp_table(policy->related_cpus);
d2f31f1d VK	389	clk_put(policy->clk);
	390	if (!IS_ERR(priv->cpu_reg))
	391	regulator_put(priv->cpu_reg);
	392	kfree(priv);
	393
	394	return 0;
	395	}
	396
9a004428 VK	397	static void cpufreq_ready(struct cpufreq_policy *policy)
	398	{
	399	struct private_data *priv = policy->driver_data;
	400	struct device_node *np = of_node_get(priv->cpu_dev->of_node);
	401
	402	if (WARN_ON(!np))
	403	return;
	404
	405	/*
	406	* For now, just loading the cooling device;
	407	* thermal DT code takes care of matching them.
	408	*/
	409	if (of_find_property(np, "#cooling-cells", NULL)) {
	410	priv->cdev = of_cpufreq_cooling_register(np,
	411	policy->related_cpus);
	412	if (IS_ERR(priv->cdev)) {
	413	dev_err(priv->cpu_dev,
	414	"running cpufreq without cooling device: %ld\n",
	415	PTR_ERR(priv->cdev));
	416
	417	priv->cdev = NULL;
	418	}
	419	}
	420
	421	of_node_put(np);
	422	}
	423
bbcf0719	424	static struct cpufreq_driver dt_cpufreq_driver = {
d2f31f1d VK	425	.flags = CPUFREQ_STICKY \| CPUFREQ_NEED_INITIAL_FREQ_CHECK,
d2f31f1d VK	426	.verify = cpufreq_generic_frequency_table_verify,
bbcf0719	427	.target_index = set_target,
d2f31f1d	428	.get = cpufreq_generic_get,
bbcf0719 VK	429	.init = cpufreq_init,
bbcf0719 VK	430	.exit = cpufreq_exit,
9a004428	431	.ready = cpufreq_ready,
bbcf0719	432	.name = "cpufreq-dt",
21c36d35	433	.attr = cpufreq_dt_attr,
953ba9ff	434	.suspend = cpufreq_generic_suspend,
d2f31f1d VK	435	};
d2f31f1d VK	436
bbcf0719	437	static int dt_cpufreq_probe(struct platform_device *pdev)
d2f31f1d VK	438	{
	439	struct device *cpu_dev;
	440	struct regulator *cpu_reg;
	441	struct clk *cpu_clk;
	442	int ret;
	443
	444	/*
	445	* All per-cluster (CPUs sharing clock/voltages) initialization is done
	446	* from ->init(). In probe(), we just need to make sure that clk and
	447	* regulators are available. Else defer probe and retry.
	448	*
	449	* FIXME: Is checking this only for CPU0 sufficient ?
	450	*/
95b61058	451	ret = allocate_resources(0, &cpu_dev, &cpu_reg, &cpu_clk);
d2f31f1d VK	452	if (ret)
	453	return ret;
	454
	455	clk_put(cpu_clk);
	456	if (!IS_ERR(cpu_reg))
	457	regulator_put(cpu_reg);
	458
34e5a527 TP	459	dt_cpufreq_driver.driver_data = dev_get_platdata(&pdev->dev);
34e5a527 TP	460
bbcf0719	461	ret = cpufreq_register_driver(&dt_cpufreq_driver);
d2f31f1d VK	462	if (ret)
	463	dev_err(cpu_dev, "failed register driver: %d\n", ret);
	464
95ceafd4 SG	465	return ret;
95ceafd4 SG	466	}
5553f9e2	467
bbcf0719	468	static int dt_cpufreq_remove(struct platform_device *pdev)
5553f9e2	469	{
bbcf0719	470	cpufreq_unregister_driver(&dt_cpufreq_driver);
5553f9e2 SG	471	return 0;
	472	}
	473
bbcf0719	474	static struct platform_driver dt_cpufreq_platdrv = {
5553f9e2	475	.driver = {
bbcf0719	476	.name = "cpufreq-dt",
5553f9e2	477	},
bbcf0719 VK	478	.probe = dt_cpufreq_probe,
bbcf0719 VK	479	.remove = dt_cpufreq_remove,
5553f9e2	480	};
bbcf0719	481	module_platform_driver(dt_cpufreq_platdrv);
95ceafd4	482
07949bf9	483	MODULE_ALIAS("platform:cpufreq-dt");
748c8766	484	MODULE_AUTHOR("Viresh Kumar <viresh.kumar@linaro.org>");
95ceafd4	485	MODULE_AUTHOR("Shawn Guo <shawn.guo@linaro.org>");
bbcf0719	486	MODULE_DESCRIPTION("Generic cpufreq driver");
95ceafd4	487	MODULE_LICENSE("GPL");