[linux-block.git] / drivers / base / power / opp / cpu.c

/*
 * Generic OPP helper interface for CPU device
 *
 * Copyright (C) 2009-2014 Texas Instruments Incorporated.
 *	Nishanth Menon
 *	Romit Dasgupta
 *	Kevin Hilman
 *
 * 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.
 */
#include <linux/cpu.h>
#include <linux/cpufreq.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/export.h>
#include <linux/of.h>
#include <linux/slab.h>

#include "opp.h"

#ifdef CONFIG_CPU_FREQ

/**
 * dev_pm_opp_init_cpufreq_table() - create a cpufreq table for a device
 * @dev:	device for which we do this operation
 * @table:	Cpufreq table returned back to caller
 *
 * Generate a cpufreq table for a provided device- this assumes that the
 * opp list is already initialized and ready for usage.
 *
 * This function allocates required memory for the cpufreq table. It is
 * expected that the caller does the required maintenance such as freeing
 * the table as required.
 *
 * Returns -EINVAL for bad pointers, -ENODEV if the device is not found, -ENOMEM
 * if no memory available for the operation (table is not populated), returns 0
 * if successful and table is populated.
 *
 * WARNING: It is  important for the callers to ensure refreshing their copy of
 * the table if any of the mentioned functions have been invoked in the interim.
 *
 * Locking: The internal device_opp and opp structures are RCU protected.
 * Since we just use the regular accessor functions to access the internal data
 * structures, we use RCU read lock inside this function. As a result, users of
 * this function DONOT need to use explicit locks for invoking.
 */
int dev_pm_opp_init_cpufreq_table(struct device *dev,
				  struct cpufreq_frequency_table **table)
{
	struct dev_pm_opp *opp;
	struct cpufreq_frequency_table *freq_table = NULL;
	int i, max_opps, ret = 0;
	unsigned long rate;

	rcu_read_lock();

	max_opps = dev_pm_opp_get_opp_count(dev);
	if (max_opps <= 0) {
		ret = max_opps ? max_opps : -ENODATA;
		goto out;
	}

	freq_table = kcalloc((max_opps + 1), sizeof(*freq_table), GFP_ATOMIC);
	if (!freq_table) {
		ret = -ENOMEM;
		goto out;
	}

	for (i = 0, rate = 0; i < max_opps; i++, rate++) {
		/* find next rate */
		opp = dev_pm_opp_find_freq_ceil(dev, &rate);
		if (IS_ERR(opp)) {
			ret = PTR_ERR(opp);
			goto out;
		}
		freq_table[i].driver_data = i;
		freq_table[i].frequency = rate / 1000;

		/* Is Boost/turbo opp ? */
		if (dev_pm_opp_is_turbo(opp))
			freq_table[i].flags = CPUFREQ_BOOST_FREQ;
	}

	freq_table[i].driver_data = i;
	freq_table[i].frequency = CPUFREQ_TABLE_END;

	*table = &freq_table[0];

out:
	rcu_read_unlock();
	if (ret)
		kfree(freq_table);

	return ret;
}
EXPORT_SYMBOL_GPL(dev_pm_opp_init_cpufreq_table);

/**
 * dev_pm_opp_free_cpufreq_table() - free the cpufreq table
 * @dev:	device for which we do this operation
 * @table:	table to free
 *
 * Free up the table allocated by dev_pm_opp_init_cpufreq_table
 */
void dev_pm_opp_free_cpufreq_table(struct device *dev,
				   struct cpufreq_frequency_table **table)
{
	if (!table)
		return;

	kfree(*table);
	*table = NULL;
}
EXPORT_SYMBOL_GPL(dev_pm_opp_free_cpufreq_table);
#endif	/* CONFIG_CPU_FREQ */

/* Required only for V1 bindings, as v2 can manage it from DT itself */
int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, cpumask_var_t cpumask)
{
	struct device_list_opp *list_dev;
	struct device_opp *dev_opp;
	struct device *dev;
	int cpu, ret = 0;

	rcu_read_lock();

	dev_opp = _find_device_opp(cpu_dev);
	if (IS_ERR(dev_opp)) {
		ret = -EINVAL;
		goto out_rcu_read_unlock;
	}

	for_each_cpu(cpu, cpumask) {
		if (cpu == cpu_dev->id)
			continue;

		dev = get_cpu_device(cpu);
		if (!dev) {
			dev_err(cpu_dev, "%s: failed to get cpu%d device\n",
				__func__, cpu);
			continue;
		}

		list_dev = _add_list_dev(dev, dev_opp);
		if (!list_dev) {
			dev_err(dev, "%s: failed to add list-dev for cpu%d device\n",
				__func__, cpu);
			continue;
		}
	}
out_rcu_read_unlock:
	rcu_read_unlock();

	return 0;
}
EXPORT_SYMBOL_GPL(dev_pm_opp_set_sharing_cpus);

#ifdef CONFIG_OF
void dev_pm_opp_of_cpumask_remove_table(cpumask_var_t cpumask)
{
	struct device *cpu_dev;
	int cpu;

	WARN_ON(cpumask_empty(cpumask));

	for_each_cpu(cpu, cpumask) {
		cpu_dev = get_cpu_device(cpu);
		if (!cpu_dev) {
			pr_err("%s: failed to get cpu%d device\n", __func__,
			       cpu);
			continue;
		}

		dev_pm_opp_of_remove_table(cpu_dev);
	}
}
EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_remove_table);

int dev_pm_opp_of_cpumask_add_table(cpumask_var_t cpumask)
{
	struct device *cpu_dev;
	int cpu, ret = 0;

	WARN_ON(cpumask_empty(cpumask));

	for_each_cpu(cpu, cpumask) {
		cpu_dev = get_cpu_device(cpu);
		if (!cpu_dev) {
			pr_err("%s: failed to get cpu%d device\n", __func__,
			       cpu);
			continue;
		}

		ret = dev_pm_opp_of_add_table(cpu_dev);
		if (ret) {
			pr_err("%s: couldn't find opp table for cpu:%d, %d\n",
			       __func__, cpu, ret);

			/* Free all other OPPs */
			dev_pm_opp_of_cpumask_remove_table(cpumask);
			break;
		}
	}

	return ret;
}
EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_add_table);

/*
 * Works only for OPP v2 bindings.
 *
 * cpumask should be already set to mask of cpu_dev->id.
 * Returns -ENOENT if operating-points-v2 bindings aren't supported.
 */
int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, cpumask_var_t cpumask)
{
	struct device_node *np, *tmp_np;
	struct device *tcpu_dev;
	int cpu, ret = 0;

	/* Get OPP descriptor node */
	np = _of_get_opp_desc_node(cpu_dev);
	if (!np) {
		dev_dbg(cpu_dev, "%s: Couldn't find opp node: %ld\n", __func__,
			PTR_ERR(np));
		return -ENOENT;
	}

	/* OPPs are shared ? */
	if (!of_property_read_bool(np, "opp-shared"))
		goto put_cpu_node;

	for_each_possible_cpu(cpu) {
		if (cpu == cpu_dev->id)
			continue;

		tcpu_dev = get_cpu_device(cpu);
		if (!tcpu_dev) {
			dev_err(cpu_dev, "%s: failed to get cpu%d device\n",
				__func__, cpu);
			ret = -ENODEV;
			goto put_cpu_node;
		}

		/* Get OPP descriptor node */
		tmp_np = _of_get_opp_desc_node(tcpu_dev);
		if (!tmp_np) {
			dev_err(tcpu_dev, "%s: Couldn't find opp node: %ld\n",
				__func__, PTR_ERR(tmp_np));
			ret = PTR_ERR(tmp_np);
			goto put_cpu_node;
		}

		/* CPUs are sharing opp node */
		if (np == tmp_np)
			cpumask_set_cpu(cpu, cpumask);

		of_node_put(tmp_np);
	}

put_cpu_node:
	of_node_put(np);
	return ret;
}
EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus);
#endif
Commit	Line	Data
a0dd7b79	1	/*
33692dc3	2	* Generic OPP helper interface for CPU device
a0dd7b79 NM	3	*
	4	* Copyright (C) 2009-2014 Texas Instruments Incorporated.
	5	* Nishanth Menon
	6	* Romit Dasgupta
	7	* Kevin Hilman
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*/
f59d3ee8	13	#include <linux/cpu.h>
a0dd7b79	14	#include <linux/cpufreq.h>
a0dd7b79 NM	15	#include <linux/err.h>
	16	#include <linux/errno.h>
	17	#include <linux/export.h>
f59d3ee8	18	#include <linux/of.h>
a0dd7b79 NM	19	#include <linux/slab.h>
a0dd7b79 NM	20
f59d3ee8 VK	21	#include "opp.h"
f59d3ee8 VK	22
33692dc3	23	#ifdef CONFIG_CPU_FREQ
f59d3ee8	24
a0dd7b79 NM	25	/**
	26	* dev_pm_opp_init_cpufreq_table() - create a cpufreq table for a device
	27	* @dev: device for which we do this operation
	28	* @table: Cpufreq table returned back to caller
	29	*
	30	* Generate a cpufreq table for a provided device- this assumes that the
	31	* opp list is already initialized and ready for usage.
	32	*
	33	* This function allocates required memory for the cpufreq table. It is
	34	* expected that the caller does the required maintenance such as freeing
	35	* the table as required.
	36	*
	37	* Returns -EINVAL for bad pointers, -ENODEV if the device is not found, -ENOMEM
	38	* if no memory available for the operation (table is not populated), returns 0
	39	* if successful and table is populated.
	40	*
	41	* WARNING: It is important for the callers to ensure refreshing their copy of
	42	* the table if any of the mentioned functions have been invoked in the interim.
	43	*
	44	* Locking: The internal device_opp and opp structures are RCU protected.
	45	* Since we just use the regular accessor functions to access the internal data
	46	* structures, we use RCU read lock inside this function. As a result, users of
	47	* this function DONOT need to use explicit locks for invoking.
	48	*/
	49	int dev_pm_opp_init_cpufreq_table(struct device *dev,
	50	struct cpufreq_frequency_table **table)
	51	{
	52	struct dev_pm_opp *opp;
	53	struct cpufreq_frequency_table *freq_table = NULL;
	54	int i, max_opps, ret = 0;
	55	unsigned long rate;
	56
	57	rcu_read_lock();
	58
	59	max_opps = dev_pm_opp_get_opp_count(dev);
	60	if (max_opps <= 0) {
	61	ret = max_opps ? max_opps : -ENODATA;
	62	goto out;
	63	}
	64
d3599920	65	freq_table = kcalloc((max_opps + 1), sizeof(*freq_table), GFP_ATOMIC);
a0dd7b79 NM	66	if (!freq_table) {
	67	ret = -ENOMEM;
	68	goto out;
	69	}
	70
	71	for (i = 0, rate = 0; i < max_opps; i++, rate++) {
	72	/* find next rate */
	73	opp = dev_pm_opp_find_freq_ceil(dev, &rate);
	74	if (IS_ERR(opp)) {
	75	ret = PTR_ERR(opp);
	76	goto out;
	77	}
	78	freq_table[i].driver_data = i;
	79	freq_table[i].frequency = rate / 1000;
79eea44a BZ	80
	81	/* Is Boost/turbo opp ? */
	82	if (dev_pm_opp_is_turbo(opp))
	83	freq_table[i].flags = CPUFREQ_BOOST_FREQ;
a0dd7b79 NM	84	}
	85
	86	freq_table[i].driver_data = i;
	87	freq_table[i].frequency = CPUFREQ_TABLE_END;
	88
	89	*table = &freq_table[0];
	90
	91	out:
	92	rcu_read_unlock();
	93	if (ret)
	94	kfree(freq_table);
	95
	96	return ret;
	97	}
	98	EXPORT_SYMBOL_GPL(dev_pm_opp_init_cpufreq_table);
	99
	100	/**
	101	* dev_pm_opp_free_cpufreq_table() - free the cpufreq table
	102	* @dev: device for which we do this operation
	103	* @table: table to free
	104	*
	105	* Free up the table allocated by dev_pm_opp_init_cpufreq_table
	106	*/
	107	void dev_pm_opp_free_cpufreq_table(struct device *dev,
	108	struct cpufreq_frequency_table **table)
	109	{
	110	if (!table)
	111	return;
	112
	113	kfree(*table);
	114	*table = NULL;
	115	}
	116	EXPORT_SYMBOL_GPL(dev_pm_opp_free_cpufreq_table);
33692dc3	117	#endif /* CONFIG_CPU_FREQ */
f59d3ee8 VK	118
	119	/* Required only for V1 bindings, as v2 can manage it from DT itself */
	120	int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, cpumask_var_t cpumask)
	121	{
	122	struct device_list_opp *list_dev;
	123	struct device_opp *dev_opp;
	124	struct device *dev;
	125	int cpu, ret = 0;
	126
	127	rcu_read_lock();
	128
	129	dev_opp = _find_device_opp(cpu_dev);
	130	if (IS_ERR(dev_opp)) {
	131	ret = -EINVAL;
	132	goto out_rcu_read_unlock;
	133	}
	134
	135	for_each_cpu(cpu, cpumask) {
	136	if (cpu == cpu_dev->id)
	137	continue;
	138
	139	dev = get_cpu_device(cpu);
	140	if (!dev) {
	141	dev_err(cpu_dev, "%s: failed to get cpu%d device\n",
	142	__func__, cpu);
	143	continue;
	144	}
	145
	146	list_dev = _add_list_dev(dev, dev_opp);
	147	if (!list_dev) {
	148	dev_err(dev, "%s: failed to add list-dev for cpu%d device\n",
	149	__func__, cpu);
	150	continue;
	151	}
	152	}
	153	out_rcu_read_unlock:
	154	rcu_read_unlock();
	155
	156	return 0;
	157	}
	158	EXPORT_SYMBOL_GPL(dev_pm_opp_set_sharing_cpus);
	159
	160	#ifdef CONFIG_OF
	161	void dev_pm_opp_of_cpumask_remove_table(cpumask_var_t cpumask)
	162	{
	163	struct device *cpu_dev;
	164	int cpu;
	165
	166	WARN_ON(cpumask_empty(cpumask));
	167
	168	for_each_cpu(cpu, cpumask) {
	169	cpu_dev = get_cpu_device(cpu);
	170	if (!cpu_dev) {
	171	pr_err("%s: failed to get cpu%d device\n", __func__,
	172	cpu);
	173	continue;
	174	}
	175
	176	dev_pm_opp_of_remove_table(cpu_dev);
	177	}
	178	}
	179	EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_remove_table);
	180
	181	int dev_pm_opp_of_cpumask_add_table(cpumask_var_t cpumask)
182	{
183	struct device *cpu_dev;
184	int cpu, ret = 0;
185
186	WARN_ON(cpumask_empty(cpumask));
187
188	for_each_cpu(cpu, cpumask) {
189	cpu_dev = get_cpu_device(cpu);
190	if (!cpu_dev) {
191	pr_err("%s: failed to get cpu%d device\n", __func__,
192	cpu);
193	continue;
194	}
195
196	ret = dev_pm_opp_of_add_table(cpu_dev);
197	if (ret) {
198	pr_err("%s: couldn't find opp table for cpu:%d, %d\n",
199	__func__, cpu, ret);
200
201	/* Free all other OPPs */
202	dev_pm_opp_of_cpumask_remove_table(cpumask);
203	break;
204	}
205	}
206
207	return ret;
208	}
209	EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_add_table);
210
211	/*
212	* Works only for OPP v2 bindings.
213	*
214	* cpumask should be already set to mask of cpu_dev->id.
215	* Returns -ENOENT if operating-points-v2 bindings aren't supported.
216	*/
217	int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, cpumask_var_t cpumask)
218	{
219	struct device_node np, tmp_np;
220	struct device *tcpu_dev;
221	int cpu, ret = 0;
222
223	/* Get OPP descriptor node */
224	np = _of_get_opp_desc_node(cpu_dev);
225	if (!np) {
226	dev_dbg(cpu_dev, "%s: Couldn't find opp node: %ld\n", __func__,
227	PTR_ERR(np));
228	return -ENOENT;
229	}
230
231	/* OPPs are shared ? */
232	if (!of_property_read_bool(np, "opp-shared"))
233	goto put_cpu_node;
234
235	for_each_possible_cpu(cpu) {
236	if (cpu == cpu_dev->id)
237	continue;
238
239	tcpu_dev = get_cpu_device(cpu);
240	if (!tcpu_dev) {
241	dev_err(cpu_dev, "%s: failed to get cpu%d device\n",
242	__func__, cpu);
243	ret = -ENODEV;
244	goto put_cpu_node;
245	}
246
247	/* Get OPP descriptor node */
248	tmp_np = _of_get_opp_desc_node(tcpu_dev);
249	if (!tmp_np) {
250	dev_err(tcpu_dev, "%s: Couldn't find opp node: %ld\n",
251	__func__, PTR_ERR(tmp_np));
252	ret = PTR_ERR(tmp_np);
253	goto put_cpu_node;
254	}
255
256	/* CPUs are sharing opp node */
257	if (np == tmp_np)
258	cpumask_set_cpu(cpu, cpumask);
259
260	of_node_put(tmp_np);
261	}
262
263	put_cpu_node:
264	of_node_put(np);
265	return ret;
266	}
267	EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus);
268	#endif