brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Generic OPP Interface4 *5 * Copyright (C) 2009-2010 Texas Instruments Incorporated.6 *	Nishanth Menon7 *	Romit Dasgupta8 *	Kevin Hilman9 */10 11#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt12 13#include <linux/clk.h>14#include <linux/errno.h>15#include <linux/err.h>16#include <linux/device.h>17#include <linux/export.h>18#include <linux/pm_domain.h>19#include <linux/regulator/consumer.h>20#include <linux/slab.h>21#include <linux/xarray.h>22 23#include "opp.h"24 25/*26 * The root of the list of all opp-tables. All opp_table structures branch off27 * from here, with each opp_table containing the list of opps it supports in28 * various states of availability.29 */30LIST_HEAD(opp_tables);31 32/* Lock to allow exclusive modification to the device and opp lists */33DEFINE_MUTEX(opp_table_lock);34/* Flag indicating that opp_tables list is being updated at the moment */35static bool opp_tables_busy;36 37/* OPP ID allocator */38static DEFINE_XARRAY_ALLOC1(opp_configs);39 40static bool _find_opp_dev(const struct device *dev, struct opp_table *opp_table)41{42	struct opp_device *opp_dev;43	bool found = false;44 45	mutex_lock(&opp_table->lock);46	list_for_each_entry(opp_dev, &opp_table->dev_list, node)47		if (opp_dev->dev == dev) {48			found = true;49			break;50		}51 52	mutex_unlock(&opp_table->lock);53	return found;54}55 56static struct opp_table *_find_opp_table_unlocked(struct device *dev)57{58	struct opp_table *opp_table;59 60	list_for_each_entry(opp_table, &opp_tables, node) {61		if (_find_opp_dev(dev, opp_table)) {62			_get_opp_table_kref(opp_table);63			return opp_table;64		}65	}66 67	return ERR_PTR(-ENODEV);68}69 70/**71 * _find_opp_table() - find opp_table struct using device pointer72 * @dev:	device pointer used to lookup OPP table73 *74 * Search OPP table for one containing matching device.75 *76 * Return: pointer to 'struct opp_table' if found, otherwise -ENODEV or77 * -EINVAL based on type of error.78 *79 * The callers must call dev_pm_opp_put_opp_table() after the table is used.80 */81struct opp_table *_find_opp_table(struct device *dev)82{83	struct opp_table *opp_table;84 85	if (IS_ERR_OR_NULL(dev)) {86		pr_err("%s: Invalid parameters\n", __func__);87		return ERR_PTR(-EINVAL);88	}89 90	mutex_lock(&opp_table_lock);91	opp_table = _find_opp_table_unlocked(dev);92	mutex_unlock(&opp_table_lock);93 94	return opp_table;95}96 97/*98 * Returns true if multiple clocks aren't there, else returns false with WARN.99 *100 * We don't force clk_count == 1 here as there are users who don't have a clock101 * representation in the OPP table and manage the clock configuration themselves102 * in an platform specific way.103 */104static bool assert_single_clk(struct opp_table *opp_table)105{106	return !WARN_ON(opp_table->clk_count > 1);107}108 109/**110 * dev_pm_opp_get_voltage() - Gets the voltage corresponding to an opp111 * @opp:	opp for which voltage has to be returned for112 *113 * Return: voltage in micro volt corresponding to the opp, else114 * return 0115 *116 * This is useful only for devices with single power supply.117 */118unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp)119{120	if (IS_ERR_OR_NULL(opp)) {121		pr_err("%s: Invalid parameters\n", __func__);122		return 0;123	}124 125	return opp->supplies[0].u_volt;126}127EXPORT_SYMBOL_GPL(dev_pm_opp_get_voltage);128 129/**130 * dev_pm_opp_get_supplies() - Gets the supply information corresponding to an opp131 * @opp:	opp for which voltage has to be returned for132 * @supplies:	Placeholder for copying the supply information.133 *134 * Return: negative error number on failure, 0 otherwise on success after135 * setting @supplies.136 *137 * This can be used for devices with any number of power supplies. The caller138 * must ensure the @supplies array must contain space for each regulator.139 */140int dev_pm_opp_get_supplies(struct dev_pm_opp *opp,141			    struct dev_pm_opp_supply *supplies)142{143	if (IS_ERR_OR_NULL(opp) || !supplies) {144		pr_err("%s: Invalid parameters\n", __func__);145		return -EINVAL;146	}147 148	memcpy(supplies, opp->supplies,149	       sizeof(*supplies) * opp->opp_table->regulator_count);150	return 0;151}152EXPORT_SYMBOL_GPL(dev_pm_opp_get_supplies);153 154/**155 * dev_pm_opp_get_power() - Gets the power corresponding to an opp156 * @opp:	opp for which power has to be returned for157 *158 * Return: power in micro watt corresponding to the opp, else159 * return 0160 *161 * This is useful only for devices with single power supply.162 */163unsigned long dev_pm_opp_get_power(struct dev_pm_opp *opp)164{165	unsigned long opp_power = 0;166	int i;167 168	if (IS_ERR_OR_NULL(opp)) {169		pr_err("%s: Invalid parameters\n", __func__);170		return 0;171	}172	for (i = 0; i < opp->opp_table->regulator_count; i++)173		opp_power += opp->supplies[i].u_watt;174 175	return opp_power;176}177EXPORT_SYMBOL_GPL(dev_pm_opp_get_power);178 179/**180 * dev_pm_opp_get_freq_indexed() - Gets the frequency corresponding to an181 *				   available opp with specified index182 * @opp: opp for which frequency has to be returned for183 * @index: index of the frequency within the required opp184 *185 * Return: frequency in hertz corresponding to the opp with specified index,186 * else return 0187 */188unsigned long dev_pm_opp_get_freq_indexed(struct dev_pm_opp *opp, u32 index)189{190	if (IS_ERR_OR_NULL(opp) || index >= opp->opp_table->clk_count) {191		pr_err("%s: Invalid parameters\n", __func__);192		return 0;193	}194 195	return opp->rates[index];196}197EXPORT_SYMBOL_GPL(dev_pm_opp_get_freq_indexed);198 199/**200 * dev_pm_opp_get_level() - Gets the level corresponding to an available opp201 * @opp:	opp for which level value has to be returned for202 *203 * Return: level read from device tree corresponding to the opp, else204 * return U32_MAX.205 */206unsigned int dev_pm_opp_get_level(struct dev_pm_opp *opp)207{208	if (IS_ERR_OR_NULL(opp) || !opp->available) {209		pr_err("%s: Invalid parameters\n", __func__);210		return 0;211	}212 213	return opp->level;214}215EXPORT_SYMBOL_GPL(dev_pm_opp_get_level);216 217/**218 * dev_pm_opp_get_required_pstate() - Gets the required performance state219 *                                    corresponding to an available opp220 * @opp:	opp for which performance state has to be returned for221 * @index:	index of the required opp222 *223 * Return: performance state read from device tree corresponding to the224 * required opp, else return U32_MAX.225 */226unsigned int dev_pm_opp_get_required_pstate(struct dev_pm_opp *opp,227					    unsigned int index)228{229	if (IS_ERR_OR_NULL(opp) || !opp->available ||230	    index >= opp->opp_table->required_opp_count) {231		pr_err("%s: Invalid parameters\n", __func__);232		return 0;233	}234 235	/* required-opps not fully initialized yet */236	if (lazy_linking_pending(opp->opp_table))237		return 0;238 239	/* The required OPP table must belong to a genpd */240	if (unlikely(!opp->opp_table->required_opp_tables[index]->is_genpd)) {241		pr_err("%s: Performance state is only valid for genpds.\n", __func__);242		return 0;243	}244 245	return opp->required_opps[index]->level;246}247EXPORT_SYMBOL_GPL(dev_pm_opp_get_required_pstate);248 249/**250 * dev_pm_opp_is_turbo() - Returns if opp is turbo OPP or not251 * @opp: opp for which turbo mode is being verified252 *253 * Turbo OPPs are not for normal use, and can be enabled (under certain254 * conditions) for short duration of times to finish high throughput work255 * quickly. Running on them for longer times may overheat the chip.256 *257 * Return: true if opp is turbo opp, else false.258 */259bool dev_pm_opp_is_turbo(struct dev_pm_opp *opp)260{261	if (IS_ERR_OR_NULL(opp) || !opp->available) {262		pr_err("%s: Invalid parameters\n", __func__);263		return false;264	}265 266	return opp->turbo;267}268EXPORT_SYMBOL_GPL(dev_pm_opp_is_turbo);269 270/**271 * dev_pm_opp_get_max_clock_latency() - Get max clock latency in nanoseconds272 * @dev:	device for which we do this operation273 *274 * Return: This function returns the max clock latency in nanoseconds.275 */276unsigned long dev_pm_opp_get_max_clock_latency(struct device *dev)277{278	struct opp_table *opp_table;279	unsigned long clock_latency_ns;280 281	opp_table = _find_opp_table(dev);282	if (IS_ERR(opp_table))283		return 0;284 285	clock_latency_ns = opp_table->clock_latency_ns_max;286 287	dev_pm_opp_put_opp_table(opp_table);288 289	return clock_latency_ns;290}291EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_clock_latency);292 293/**294 * dev_pm_opp_get_max_volt_latency() - Get max voltage latency in nanoseconds295 * @dev: device for which we do this operation296 *297 * Return: This function returns the max voltage latency in nanoseconds.298 */299unsigned long dev_pm_opp_get_max_volt_latency(struct device *dev)300{301	struct opp_table *opp_table;302	struct dev_pm_opp *opp;303	struct regulator *reg;304	unsigned long latency_ns = 0;305	int ret, i, count;306	struct {307		unsigned long min;308		unsigned long max;309	} *uV;310 311	opp_table = _find_opp_table(dev);312	if (IS_ERR(opp_table))313		return 0;314 315	/* Regulator may not be required for the device */316	if (!opp_table->regulators)317		goto put_opp_table;318 319	count = opp_table->regulator_count;320 321	uV = kmalloc_array(count, sizeof(*uV), GFP_KERNEL);322	if (!uV)323		goto put_opp_table;324 325	mutex_lock(&opp_table->lock);326 327	for (i = 0; i < count; i++) {328		uV[i].min = ~0;329		uV[i].max = 0;330 331		list_for_each_entry(opp, &opp_table->opp_list, node) {332			if (!opp->available)333				continue;334 335			if (opp->supplies[i].u_volt_min < uV[i].min)336				uV[i].min = opp->supplies[i].u_volt_min;337			if (opp->supplies[i].u_volt_max > uV[i].max)338				uV[i].max = opp->supplies[i].u_volt_max;339		}340	}341 342	mutex_unlock(&opp_table->lock);343 344	/*345	 * The caller needs to ensure that opp_table (and hence the regulator)346	 * isn't freed, while we are executing this routine.347	 */348	for (i = 0; i < count; i++) {349		reg = opp_table->regulators[i];350		ret = regulator_set_voltage_time(reg, uV[i].min, uV[i].max);351		if (ret > 0)352			latency_ns += ret * 1000;353	}354 355	kfree(uV);356put_opp_table:357	dev_pm_opp_put_opp_table(opp_table);358 359	return latency_ns;360}361EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_volt_latency);362 363/**364 * dev_pm_opp_get_max_transition_latency() - Get max transition latency in365 *					     nanoseconds366 * @dev: device for which we do this operation367 *368 * Return: This function returns the max transition latency, in nanoseconds, to369 * switch from one OPP to other.370 */371unsigned long dev_pm_opp_get_max_transition_latency(struct device *dev)372{373	return dev_pm_opp_get_max_volt_latency(dev) +374		dev_pm_opp_get_max_clock_latency(dev);375}376EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_transition_latency);377 378/**379 * dev_pm_opp_get_suspend_opp_freq() - Get frequency of suspend opp in Hz380 * @dev:	device for which we do this operation381 *382 * Return: This function returns the frequency of the OPP marked as suspend_opp383 * if one is available, else returns 0;384 */385unsigned long dev_pm_opp_get_suspend_opp_freq(struct device *dev)386{387	struct opp_table *opp_table;388	unsigned long freq = 0;389 390	opp_table = _find_opp_table(dev);391	if (IS_ERR(opp_table))392		return 0;393 394	if (opp_table->suspend_opp && opp_table->suspend_opp->available)395		freq = dev_pm_opp_get_freq(opp_table->suspend_opp);396 397	dev_pm_opp_put_opp_table(opp_table);398 399	return freq;400}401EXPORT_SYMBOL_GPL(dev_pm_opp_get_suspend_opp_freq);402 403int _get_opp_count(struct opp_table *opp_table)404{405	struct dev_pm_opp *opp;406	int count = 0;407 408	mutex_lock(&opp_table->lock);409 410	list_for_each_entry(opp, &opp_table->opp_list, node) {411		if (opp->available)412			count++;413	}414 415	mutex_unlock(&opp_table->lock);416 417	return count;418}419 420/**421 * dev_pm_opp_get_opp_count() - Get number of opps available in the opp table422 * @dev:	device for which we do this operation423 *424 * Return: This function returns the number of available opps if there are any,425 * else returns 0 if none or the corresponding error value.426 */427int dev_pm_opp_get_opp_count(struct device *dev)428{429	struct opp_table *opp_table;430	int count;431 432	opp_table = _find_opp_table(dev);433	if (IS_ERR(opp_table)) {434		count = PTR_ERR(opp_table);435		dev_dbg(dev, "%s: OPP table not found (%d)\n",436			__func__, count);437		return count;438	}439 440	count = _get_opp_count(opp_table);441	dev_pm_opp_put_opp_table(opp_table);442 443	return count;444}445EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count);446 447/* Helpers to read keys */448static unsigned long _read_freq(struct dev_pm_opp *opp, int index)449{450	return opp->rates[index];451}452 453static unsigned long _read_level(struct dev_pm_opp *opp, int index)454{455	return opp->level;456}457 458static unsigned long _read_bw(struct dev_pm_opp *opp, int index)459{460	return opp->bandwidth[index].peak;461}462 463/* Generic comparison helpers */464static bool _compare_exact(struct dev_pm_opp **opp, struct dev_pm_opp *temp_opp,465			   unsigned long opp_key, unsigned long key)466{467	if (opp_key == key) {468		*opp = temp_opp;469		return true;470	}471 472	return false;473}474 475static bool _compare_ceil(struct dev_pm_opp **opp, struct dev_pm_opp *temp_opp,476			  unsigned long opp_key, unsigned long key)477{478	if (opp_key >= key) {479		*opp = temp_opp;480		return true;481	}482 483	return false;484}485 486static bool _compare_floor(struct dev_pm_opp **opp, struct dev_pm_opp *temp_opp,487			   unsigned long opp_key, unsigned long key)488{489	if (opp_key > key)490		return true;491 492	*opp = temp_opp;493	return false;494}495 496/* Generic key finding helpers */497static struct dev_pm_opp *_opp_table_find_key(struct opp_table *opp_table,498		unsigned long *key, int index, bool available,499		unsigned long (*read)(struct dev_pm_opp *opp, int index),500		bool (*compare)(struct dev_pm_opp **opp, struct dev_pm_opp *temp_opp,501				unsigned long opp_key, unsigned long key),502		bool (*assert)(struct opp_table *opp_table))503{504	struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);505 506	/* Assert that the requirement is met */507	if (assert && !assert(opp_table))508		return ERR_PTR(-EINVAL);509 510	mutex_lock(&opp_table->lock);511 512	list_for_each_entry(temp_opp, &opp_table->opp_list, node) {513		if (temp_opp->available == available) {514			if (compare(&opp, temp_opp, read(temp_opp, index), *key))515				break;516		}517	}518 519	/* Increment the reference count of OPP */520	if (!IS_ERR(opp)) {521		*key = read(opp, index);522		dev_pm_opp_get(opp);523	}524 525	mutex_unlock(&opp_table->lock);526 527	return opp;528}529 530static struct dev_pm_opp *531_find_key(struct device *dev, unsigned long *key, int index, bool available,532	  unsigned long (*read)(struct dev_pm_opp *opp, int index),533	  bool (*compare)(struct dev_pm_opp **opp, struct dev_pm_opp *temp_opp,534			  unsigned long opp_key, unsigned long key),535	  bool (*assert)(struct opp_table *opp_table))536{537	struct opp_table *opp_table;538	struct dev_pm_opp *opp;539 540	opp_table = _find_opp_table(dev);541	if (IS_ERR(opp_table)) {542		dev_err(dev, "%s: OPP table not found (%ld)\n", __func__,543			PTR_ERR(opp_table));544		return ERR_CAST(opp_table);545	}546 547	opp = _opp_table_find_key(opp_table, key, index, available, read,548				  compare, assert);549 550	dev_pm_opp_put_opp_table(opp_table);551 552	return opp;553}554 555static struct dev_pm_opp *_find_key_exact(struct device *dev,556		unsigned long key, int index, bool available,557		unsigned long (*read)(struct dev_pm_opp *opp, int index),558		bool (*assert)(struct opp_table *opp_table))559{560	/*561	 * The value of key will be updated here, but will be ignored as the562	 * caller doesn't need it.563	 */564	return _find_key(dev, &key, index, available, read, _compare_exact,565			 assert);566}567 568static struct dev_pm_opp *_opp_table_find_key_ceil(struct opp_table *opp_table,569		unsigned long *key, int index, bool available,570		unsigned long (*read)(struct dev_pm_opp *opp, int index),571		bool (*assert)(struct opp_table *opp_table))572{573	return _opp_table_find_key(opp_table, key, index, available, read,574				   _compare_ceil, assert);575}576 577static struct dev_pm_opp *_find_key_ceil(struct device *dev, unsigned long *key,578		int index, bool available,579		unsigned long (*read)(struct dev_pm_opp *opp, int index),580		bool (*assert)(struct opp_table *opp_table))581{582	return _find_key(dev, key, index, available, read, _compare_ceil,583			 assert);584}585 586static struct dev_pm_opp *_find_key_floor(struct device *dev,587		unsigned long *key, int index, bool available,588		unsigned long (*read)(struct dev_pm_opp *opp, int index),589		bool (*assert)(struct opp_table *opp_table))590{591	return _find_key(dev, key, index, available, read, _compare_floor,592			 assert);593}594 595/**596 * dev_pm_opp_find_freq_exact() - search for an exact frequency597 * @dev:		device for which we do this operation598 * @freq:		frequency to search for599 * @available:		true/false - match for available opp600 *601 * Return: Searches for exact match in the opp table and returns pointer to the602 * matching opp if found, else returns ERR_PTR in case of error and should603 * be handled using IS_ERR. Error return values can be:604 * EINVAL:	for bad pointer605 * ERANGE:	no match found for search606 * ENODEV:	if device not found in list of registered devices607 *608 * Note: available is a modifier for the search. if available=true, then the609 * match is for exact matching frequency and is available in the stored OPP610 * table. if false, the match is for exact frequency which is not available.611 *612 * This provides a mechanism to enable an opp which is not available currently613 * or the opposite as well.614 *615 * The callers are required to call dev_pm_opp_put() for the returned OPP after616 * use.617 */618struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,619		unsigned long freq, bool available)620{621	return _find_key_exact(dev, freq, 0, available, _read_freq,622			       assert_single_clk);623}624EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact);625 626/**627 * dev_pm_opp_find_freq_exact_indexed() - Search for an exact freq for the628 *					 clock corresponding to the index629 * @dev:	Device for which we do this operation630 * @freq:	frequency to search for631 * @index:	Clock index632 * @available:	true/false - match for available opp633 *634 * Search for the matching exact OPP for the clock corresponding to the635 * specified index from a starting freq for a device.636 *637 * Return: matching *opp , else returns ERR_PTR in case of error and should be638 * handled using IS_ERR. Error return values can be:639 * EINVAL:	for bad pointer640 * ERANGE:	no match found for search641 * ENODEV:	if device not found in list of registered devices642 *643 * The callers are required to call dev_pm_opp_put() for the returned OPP after644 * use.645 */646struct dev_pm_opp *647dev_pm_opp_find_freq_exact_indexed(struct device *dev, unsigned long freq,648				   u32 index, bool available)649{650	return _find_key_exact(dev, freq, index, available, _read_freq, NULL);651}652EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact_indexed);653 654static noinline struct dev_pm_opp *_find_freq_ceil(struct opp_table *opp_table,655						   unsigned long *freq)656{657	return _opp_table_find_key_ceil(opp_table, freq, 0, true, _read_freq,658					assert_single_clk);659}660 661/**662 * dev_pm_opp_find_freq_ceil() - Search for an rounded ceil freq663 * @dev:	device for which we do this operation664 * @freq:	Start frequency665 *666 * Search for the matching ceil *available* OPP from a starting freq667 * for a device.668 *669 * Return: matching *opp and refreshes *freq accordingly, else returns670 * ERR_PTR in case of error and should be handled using IS_ERR. Error return671 * values can be:672 * EINVAL:	for bad pointer673 * ERANGE:	no match found for search674 * ENODEV:	if device not found in list of registered devices675 *676 * The callers are required to call dev_pm_opp_put() for the returned OPP after677 * use.678 */679struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,680					     unsigned long *freq)681{682	return _find_key_ceil(dev, freq, 0, true, _read_freq, assert_single_clk);683}684EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil);685 686/**687 * dev_pm_opp_find_freq_ceil_indexed() - Search for a rounded ceil freq for the688 *					 clock corresponding to the index689 * @dev:	Device for which we do this operation690 * @freq:	Start frequency691 * @index:	Clock index692 *693 * Search for the matching ceil *available* OPP for the clock corresponding to694 * the specified index from a starting freq for a device.695 *696 * Return: matching *opp and refreshes *freq accordingly, else returns697 * ERR_PTR in case of error and should be handled using IS_ERR. Error return698 * values can be:699 * EINVAL:	for bad pointer700 * ERANGE:	no match found for search701 * ENODEV:	if device not found in list of registered devices702 *703 * The callers are required to call dev_pm_opp_put() for the returned OPP after704 * use.705 */706struct dev_pm_opp *707dev_pm_opp_find_freq_ceil_indexed(struct device *dev, unsigned long *freq,708				  u32 index)709{710	return _find_key_ceil(dev, freq, index, true, _read_freq, NULL);711}712EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil_indexed);713 714/**715 * dev_pm_opp_find_freq_floor() - Search for a rounded floor freq716 * @dev:	device for which we do this operation717 * @freq:	Start frequency718 *719 * Search for the matching floor *available* OPP from a starting freq720 * for a device.721 *722 * Return: matching *opp and refreshes *freq accordingly, else returns723 * ERR_PTR in case of error and should be handled using IS_ERR. Error return724 * values can be:725 * EINVAL:	for bad pointer726 * ERANGE:	no match found for search727 * ENODEV:	if device not found in list of registered devices728 *729 * The callers are required to call dev_pm_opp_put() for the returned OPP after730 * use.731 */732struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,733					      unsigned long *freq)734{735	return _find_key_floor(dev, freq, 0, true, _read_freq, assert_single_clk);736}737EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);738 739/**740 * dev_pm_opp_find_freq_floor_indexed() - Search for a rounded floor freq for the741 *					  clock corresponding to the index742 * @dev:	Device for which we do this operation743 * @freq:	Start frequency744 * @index:	Clock index745 *746 * Search for the matching floor *available* OPP for the clock corresponding to747 * the specified index from a starting freq for a device.748 *749 * Return: matching *opp and refreshes *freq accordingly, else returns750 * ERR_PTR in case of error and should be handled using IS_ERR. Error return751 * values can be:752 * EINVAL:	for bad pointer753 * ERANGE:	no match found for search754 * ENODEV:	if device not found in list of registered devices755 *756 * The callers are required to call dev_pm_opp_put() for the returned OPP after757 * use.758 */759struct dev_pm_opp *760dev_pm_opp_find_freq_floor_indexed(struct device *dev, unsigned long *freq,761				   u32 index)762{763	return _find_key_floor(dev, freq, index, true, _read_freq, NULL);764}765EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor_indexed);766 767/**768 * dev_pm_opp_find_level_exact() - search for an exact level769 * @dev:		device for which we do this operation770 * @level:		level to search for771 *772 * Return: Searches for exact match in the opp table and returns pointer to the773 * matching opp if found, else returns ERR_PTR in case of error and should774 * be handled using IS_ERR. Error return values can be:775 * EINVAL:	for bad pointer776 * ERANGE:	no match found for search777 * ENODEV:	if device not found in list of registered devices778 *779 * The callers are required to call dev_pm_opp_put() for the returned OPP after780 * use.781 */782struct dev_pm_opp *dev_pm_opp_find_level_exact(struct device *dev,783					       unsigned int level)784{785	return _find_key_exact(dev, level, 0, true, _read_level, NULL);786}787EXPORT_SYMBOL_GPL(dev_pm_opp_find_level_exact);788 789/**790 * dev_pm_opp_find_level_ceil() - search for an rounded up level791 * @dev:		device for which we do this operation792 * @level:		level to search for793 *794 * Return: Searches for rounded up match in the opp table and returns pointer795 * to the  matching opp if found, else returns ERR_PTR in case of error and796 * should be handled using IS_ERR. Error return values can be:797 * EINVAL:	for bad pointer798 * ERANGE:	no match found for search799 * ENODEV:	if device not found in list of registered devices800 *801 * The callers are required to call dev_pm_opp_put() for the returned OPP after802 * use.803 */804struct dev_pm_opp *dev_pm_opp_find_level_ceil(struct device *dev,805					      unsigned int *level)806{807	unsigned long temp = *level;808	struct dev_pm_opp *opp;809 810	opp = _find_key_ceil(dev, &temp, 0, true, _read_level, NULL);811	if (IS_ERR(opp))812		return opp;813 814	/* False match */815	if (temp == OPP_LEVEL_UNSET) {816		dev_err(dev, "%s: OPP levels aren't available\n", __func__);817		dev_pm_opp_put(opp);818		return ERR_PTR(-ENODEV);819	}820 821	*level = temp;822	return opp;823}824EXPORT_SYMBOL_GPL(dev_pm_opp_find_level_ceil);825 826/**827 * dev_pm_opp_find_level_floor() - Search for a rounded floor level828 * @dev:	device for which we do this operation829 * @level:	Start level830 *831 * Search for the matching floor *available* OPP from a starting level832 * for a device.833 *834 * Return: matching *opp and refreshes *level accordingly, else returns835 * ERR_PTR in case of error and should be handled using IS_ERR. Error return836 * values can be:837 * EINVAL:	for bad pointer838 * ERANGE:	no match found for search839 * ENODEV:	if device not found in list of registered devices840 *841 * The callers are required to call dev_pm_opp_put() for the returned OPP after842 * use.843 */844struct dev_pm_opp *dev_pm_opp_find_level_floor(struct device *dev,845					       unsigned int *level)846{847	unsigned long temp = *level;848	struct dev_pm_opp *opp;849 850	opp = _find_key_floor(dev, &temp, 0, true, _read_level, NULL);851	*level = temp;852	return opp;853}854EXPORT_SYMBOL_GPL(dev_pm_opp_find_level_floor);855 856/**857 * dev_pm_opp_find_bw_ceil() - Search for a rounded ceil bandwidth858 * @dev:	device for which we do this operation859 * @bw:	start bandwidth860 * @index:	which bandwidth to compare, in case of OPPs with several values861 *862 * Search for the matching floor *available* OPP from a starting bandwidth863 * for a device.864 *865 * Return: matching *opp and refreshes *bw accordingly, else returns866 * ERR_PTR in case of error and should be handled using IS_ERR. Error return867 * values can be:868 * EINVAL:	for bad pointer869 * ERANGE:	no match found for search870 * ENODEV:	if device not found in list of registered devices871 *872 * The callers are required to call dev_pm_opp_put() for the returned OPP after873 * use.874 */875struct dev_pm_opp *dev_pm_opp_find_bw_ceil(struct device *dev, unsigned int *bw,876					   int index)877{878	unsigned long temp = *bw;879	struct dev_pm_opp *opp;880 881	opp = _find_key_ceil(dev, &temp, index, true, _read_bw, NULL);882	*bw = temp;883	return opp;884}885EXPORT_SYMBOL_GPL(dev_pm_opp_find_bw_ceil);886 887/**888 * dev_pm_opp_find_bw_floor() - Search for a rounded floor bandwidth889 * @dev:	device for which we do this operation890 * @bw:	start bandwidth891 * @index:	which bandwidth to compare, in case of OPPs with several values892 *893 * Search for the matching floor *available* OPP from a starting bandwidth894 * for a device.895 *896 * Return: matching *opp and refreshes *bw accordingly, else returns897 * ERR_PTR in case of error and should be handled using IS_ERR. Error return898 * values can be:899 * EINVAL:	for bad pointer900 * ERANGE:	no match found for search901 * ENODEV:	if device not found in list of registered devices902 *903 * The callers are required to call dev_pm_opp_put() for the returned OPP after904 * use.905 */906struct dev_pm_opp *dev_pm_opp_find_bw_floor(struct device *dev,907					    unsigned int *bw, int index)908{909	unsigned long temp = *bw;910	struct dev_pm_opp *opp;911 912	opp = _find_key_floor(dev, &temp, index, true, _read_bw, NULL);913	*bw = temp;914	return opp;915}916EXPORT_SYMBOL_GPL(dev_pm_opp_find_bw_floor);917 918static int _set_opp_voltage(struct device *dev, struct regulator *reg,919			    struct dev_pm_opp_supply *supply)920{921	int ret;922 923	/* Regulator not available for device */924	if (IS_ERR(reg)) {925		dev_dbg(dev, "%s: regulator not available: %ld\n", __func__,926			PTR_ERR(reg));927		return 0;928	}929 930	dev_dbg(dev, "%s: voltages (mV): %lu %lu %lu\n", __func__,931		supply->u_volt_min, supply->u_volt, supply->u_volt_max);932 933	ret = regulator_set_voltage_triplet(reg, supply->u_volt_min,934					    supply->u_volt, supply->u_volt_max);935	if (ret)936		dev_err(dev, "%s: failed to set voltage (%lu %lu %lu mV): %d\n",937			__func__, supply->u_volt_min, supply->u_volt,938			supply->u_volt_max, ret);939 940	return ret;941}942 943static int944_opp_config_clk_single(struct device *dev, struct opp_table *opp_table,945		       struct dev_pm_opp *opp, void *data, bool scaling_down)946{947	unsigned long *target = data;948	unsigned long freq;949	int ret;950 951	/* One of target and opp must be available */952	if (target) {953		freq = *target;954	} else if (opp) {955		freq = opp->rates[0];956	} else {957		WARN_ON(1);958		return -EINVAL;959	}960 961	ret = clk_set_rate(opp_table->clk, freq);962	if (ret) {963		dev_err(dev, "%s: failed to set clock rate: %d\n", __func__,964			ret);965	} else {966		opp_table->current_rate_single_clk = freq;967	}968 969	return ret;970}971 972/*973 * Simple implementation for configuring multiple clocks. Configure clocks in974 * the order in which they are present in the array while scaling up.975 */976int dev_pm_opp_config_clks_simple(struct device *dev,977		struct opp_table *opp_table, struct dev_pm_opp *opp, void *data,978		bool scaling_down)979{980	int ret, i;981 982	if (scaling_down) {983		for (i = opp_table->clk_count - 1; i >= 0; i--) {984			ret = clk_set_rate(opp_table->clks[i], opp->rates[i]);985			if (ret) {986				dev_err(dev, "%s: failed to set clock rate: %d\n", __func__,987					ret);988				return ret;989			}990		}991	} else {992		for (i = 0; i < opp_table->clk_count; i++) {993			ret = clk_set_rate(opp_table->clks[i], opp->rates[i]);994			if (ret) {995				dev_err(dev, "%s: failed to set clock rate: %d\n", __func__,996					ret);997				return ret;998			}999		}1000	}1001 1002	return 0;1003}1004EXPORT_SYMBOL_GPL(dev_pm_opp_config_clks_simple);1005 1006static int _opp_config_regulator_single(struct device *dev,1007			struct dev_pm_opp *old_opp, struct dev_pm_opp *new_opp,1008			struct regulator **regulators, unsigned int count)1009{1010	struct regulator *reg = regulators[0];1011	int ret;1012 1013	/* This function only supports single regulator per device */1014	if (WARN_ON(count > 1)) {1015		dev_err(dev, "multiple regulators are not supported\n");1016		return -EINVAL;1017	}1018 1019	ret = _set_opp_voltage(dev, reg, new_opp->supplies);1020	if (ret)1021		return ret;1022 1023	/*1024	 * Enable the regulator after setting its voltages, otherwise it breaks1025	 * some boot-enabled regulators.1026	 */1027	if (unlikely(!new_opp->opp_table->enabled)) {1028		ret = regulator_enable(reg);1029		if (ret < 0)1030			dev_warn(dev, "Failed to enable regulator: %d", ret);1031	}1032 1033	return 0;1034}1035 1036static int _set_opp_bw(const struct opp_table *opp_table,1037		       struct dev_pm_opp *opp, struct device *dev)1038{1039	u32 avg, peak;1040	int i, ret;1041 1042	if (!opp_table->paths)1043		return 0;1044 1045	for (i = 0; i < opp_table->path_count; i++) {1046		if (!opp) {1047			avg = 0;1048			peak = 0;1049		} else {1050			avg = opp->bandwidth[i].avg;1051			peak = opp->bandwidth[i].peak;1052		}1053		ret = icc_set_bw(opp_table->paths[i], avg, peak);1054		if (ret) {1055			dev_err(dev, "Failed to %s bandwidth[%d]: %d\n",1056				opp ? "set" : "remove", i, ret);1057			return ret;1058		}1059	}1060 1061	return 0;1062}1063 1064static int _set_opp_level(struct device *dev, struct dev_pm_opp *opp)1065{1066	unsigned int level = 0;1067	int ret = 0;1068 1069	if (opp) {1070		if (opp->level == OPP_LEVEL_UNSET)1071			return 0;1072 1073		level = opp->level;1074	}1075 1076	/* Request a new performance state through the device's PM domain. */1077	ret = dev_pm_domain_set_performance_state(dev, level);1078	if (ret)1079		dev_err(dev, "Failed to set performance state %u (%d)\n", level,1080			ret);1081 1082	return ret;1083}1084 1085/* This is only called for PM domain for now */1086static int _set_required_opps(struct device *dev, struct opp_table *opp_table,1087			      struct dev_pm_opp *opp, bool up)1088{1089	struct device **devs = opp_table->required_devs;1090	struct dev_pm_opp *required_opp;1091	int index, target, delta, ret;1092 1093	if (!devs)1094		return 0;1095 1096	/* required-opps not fully initialized yet */1097	if (lazy_linking_pending(opp_table))1098		return -EBUSY;1099 1100	/* Scaling up? Set required OPPs in normal order, else reverse */1101	if (up) {1102		index = 0;1103		target = opp_table->required_opp_count;1104		delta = 1;1105	} else {1106		index = opp_table->required_opp_count - 1;1107		target = -1;1108		delta = -1;1109	}1110 1111	while (index != target) {1112		if (devs[index]) {1113			required_opp = opp ? opp->required_opps[index] : NULL;1114 1115			ret = _set_opp_level(devs[index], required_opp);1116			if (ret)1117				return ret;1118		}1119 1120		index += delta;1121	}1122 1123	return 0;1124}1125 1126static void _find_current_opp(struct device *dev, struct opp_table *opp_table)1127{1128	struct dev_pm_opp *opp = ERR_PTR(-ENODEV);1129	unsigned long freq;1130 1131	if (!IS_ERR(opp_table->clk)) {1132		freq = clk_get_rate(opp_table->clk);1133		opp = _find_freq_ceil(opp_table, &freq);1134	}1135 1136	/*1137	 * Unable to find the current OPP ? Pick the first from the list since1138	 * it is in ascending order, otherwise rest of the code will need to1139	 * make special checks to validate current_opp.1140	 */1141	if (IS_ERR(opp)) {1142		mutex_lock(&opp_table->lock);1143		opp = list_first_entry(&opp_table->opp_list, struct dev_pm_opp, node);1144		dev_pm_opp_get(opp);1145		mutex_unlock(&opp_table->lock);1146	}1147 1148	opp_table->current_opp = opp;1149}1150 1151static int _disable_opp_table(struct device *dev, struct opp_table *opp_table)1152{1153	int ret;1154 1155	if (!opp_table->enabled)1156		return 0;1157 1158	/*1159	 * Some drivers need to support cases where some platforms may1160	 * have OPP table for the device, while others don't and1161	 * opp_set_rate() just needs to behave like clk_set_rate().1162	 */1163	if (!_get_opp_count(opp_table))1164		return 0;1165 1166	ret = _set_opp_bw(opp_table, NULL, dev);1167	if (ret)1168		return ret;1169 1170	if (opp_table->regulators)1171		regulator_disable(opp_table->regulators[0]);1172 1173	ret = _set_opp_level(dev, NULL);1174	if (ret)1175		goto out;1176 1177	ret = _set_required_opps(dev, opp_table, NULL, false);1178 1179out:1180	opp_table->enabled = false;1181	return ret;1182}1183 1184static int _set_opp(struct device *dev, struct opp_table *opp_table,1185		    struct dev_pm_opp *opp, void *clk_data, bool forced)1186{1187	struct dev_pm_opp *old_opp;1188	int scaling_down, ret;1189 1190	if (unlikely(!opp))1191		return _disable_opp_table(dev, opp_table);1192 1193	/* Find the currently set OPP if we don't know already */1194	if (unlikely(!opp_table->current_opp))1195		_find_current_opp(dev, opp_table);1196 1197	old_opp = opp_table->current_opp;1198 1199	/* Return early if nothing to do */1200	if (!forced && old_opp == opp && opp_table->enabled) {1201		dev_dbg_ratelimited(dev, "%s: OPPs are same, nothing to do\n", __func__);1202		return 0;1203	}1204 1205	dev_dbg(dev, "%s: switching OPP: Freq %lu -> %lu Hz, Level %u -> %u, Bw %u -> %u\n",1206		__func__, old_opp->rates[0], opp->rates[0], old_opp->level,1207		opp->level, old_opp->bandwidth ? old_opp->bandwidth[0].peak : 0,1208		opp->bandwidth ? opp->bandwidth[0].peak : 0);1209 1210	scaling_down = _opp_compare_key(opp_table, old_opp, opp);1211	if (scaling_down == -1)1212		scaling_down = 0;1213 1214	/* Scaling up? Configure required OPPs before frequency */1215	if (!scaling_down) {1216		ret = _set_required_opps(dev, opp_table, opp, true);1217		if (ret) {1218			dev_err(dev, "Failed to set required opps: %d\n", ret);1219			return ret;1220		}1221 1222		ret = _set_opp_level(dev, opp);1223		if (ret)1224			return ret;1225 1226		ret = _set_opp_bw(opp_table, opp, dev);1227		if (ret) {1228			dev_err(dev, "Failed to set bw: %d\n", ret);1229			return ret;1230		}1231 1232		if (opp_table->config_regulators) {1233			ret = opp_table->config_regulators(dev, old_opp, opp,1234							   opp_table->regulators,1235							   opp_table->regulator_count);1236			if (ret) {1237				dev_err(dev, "Failed to set regulator voltages: %d\n",1238					ret);1239				return ret;1240			}1241		}1242	}1243 1244	if (opp_table->config_clks) {1245		ret = opp_table->config_clks(dev, opp_table, opp, clk_data, scaling_down);1246		if (ret)1247			return ret;1248	}1249 1250	/* Scaling down? Configure required OPPs after frequency */1251	if (scaling_down) {1252		if (opp_table->config_regulators) {1253			ret = opp_table->config_regulators(dev, old_opp, opp,1254							   opp_table->regulators,1255							   opp_table->regulator_count);1256			if (ret) {1257				dev_err(dev, "Failed to set regulator voltages: %d\n",1258					ret);1259				return ret;1260			}1261		}1262 1263		ret = _set_opp_bw(opp_table, opp, dev);1264		if (ret) {1265			dev_err(dev, "Failed to set bw: %d\n", ret);1266			return ret;1267		}1268 1269		ret = _set_opp_level(dev, opp);1270		if (ret)1271			return ret;1272 1273		ret = _set_required_opps(dev, opp_table, opp, false);1274		if (ret) {1275			dev_err(dev, "Failed to set required opps: %d\n", ret);1276			return ret;1277		}1278	}1279 1280	opp_table->enabled = true;1281	dev_pm_opp_put(old_opp);1282 1283	/* Make sure current_opp doesn't get freed */1284	dev_pm_opp_get(opp);1285	opp_table->current_opp = opp;1286 1287	return ret;1288}1289 1290/**1291 * dev_pm_opp_set_rate() - Configure new OPP based on frequency1292 * @dev:	 device for which we do this operation1293 * @target_freq: frequency to achieve1294 *1295 * This configures the power-supplies to the levels specified by the OPP1296 * corresponding to the target_freq, and programs the clock to a value <=1297 * target_freq, as rounded by clk_round_rate(). Device wanting to run at fmax1298 * provided by the opp, should have already rounded to the target OPP's1299 * frequency.1300 */1301int dev_pm_opp_set_rate(struct device *dev, unsigned long target_freq)1302{1303	struct opp_table *opp_table;1304	unsigned long freq = 0, temp_freq;1305	struct dev_pm_opp *opp = NULL;1306	bool forced = false;1307	int ret;1308 1309	opp_table = _find_opp_table(dev);1310	if (IS_ERR(opp_table)) {1311		dev_err(dev, "%s: device's opp table doesn't exist\n", __func__);1312		return PTR_ERR(opp_table);1313	}1314 1315	if (target_freq) {1316		/*1317		 * For IO devices which require an OPP on some platforms/SoCs1318		 * while just needing to scale the clock on some others1319		 * we look for empty OPP tables with just a clock handle and1320		 * scale only the clk. This makes dev_pm_opp_set_rate()1321		 * equivalent to a clk_set_rate()1322		 */1323		if (!_get_opp_count(opp_table)) {1324			ret = opp_table->config_clks(dev, opp_table, NULL,1325						     &target_freq, false);1326			goto put_opp_table;1327		}1328 1329		freq = clk_round_rate(opp_table->clk, target_freq);1330		if ((long)freq <= 0)1331			freq = target_freq;1332 1333		/*1334		 * The clock driver may support finer resolution of the1335		 * frequencies than the OPP table, don't update the frequency we1336		 * pass to clk_set_rate() here.1337		 */1338		temp_freq = freq;1339		opp = _find_freq_ceil(opp_table, &temp_freq);1340		if (IS_ERR(opp)) {1341			ret = PTR_ERR(opp);1342			dev_err(dev, "%s: failed to find OPP for freq %lu (%d)\n",1343				__func__, freq, ret);1344			goto put_opp_table;1345		}1346 1347		/*1348		 * An OPP entry specifies the highest frequency at which other1349		 * properties of the OPP entry apply. Even if the new OPP is1350		 * same as the old one, we may still reach here for a different1351		 * value of the frequency. In such a case, do not abort but1352		 * configure the hardware to the desired frequency forcefully.1353		 */1354		forced = opp_table->current_rate_single_clk != freq;1355	}1356 1357	ret = _set_opp(dev, opp_table, opp, &freq, forced);1358 1359	if (freq)1360		dev_pm_opp_put(opp);1361 1362put_opp_table:1363	dev_pm_opp_put_opp_table(opp_table);1364	return ret;1365}1366EXPORT_SYMBOL_GPL(dev_pm_opp_set_rate);1367 1368/**1369 * dev_pm_opp_set_opp() - Configure device for OPP1370 * @dev: device for which we do this operation1371 * @opp: OPP to set to1372 *1373 * This configures the device based on the properties of the OPP passed to this1374 * routine.1375 *1376 * Return: 0 on success, a negative error number otherwise.1377 */1378int dev_pm_opp_set_opp(struct device *dev, struct dev_pm_opp *opp)1379{1380	struct opp_table *opp_table;1381	int ret;1382 1383	opp_table = _find_opp_table(dev);1384	if (IS_ERR(opp_table)) {1385		dev_err(dev, "%s: device opp doesn't exist\n", __func__);1386		return PTR_ERR(opp_table);1387	}1388 1389	ret = _set_opp(dev, opp_table, opp, NULL, false);1390	dev_pm_opp_put_opp_table(opp_table);1391 1392	return ret;1393}1394EXPORT_SYMBOL_GPL(dev_pm_opp_set_opp);1395 1396/* OPP-dev Helpers */1397static void _remove_opp_dev(struct opp_device *opp_dev,1398			    struct opp_table *opp_table)1399{1400	opp_debug_unregister(opp_dev, opp_table);1401	list_del(&opp_dev->node);1402	kfree(opp_dev);1403}1404 1405struct opp_device *_add_opp_dev(const struct device *dev,1406				struct opp_table *opp_table)1407{1408	struct opp_device *opp_dev;1409 1410	opp_dev = kzalloc(sizeof(*opp_dev), GFP_KERNEL);1411	if (!opp_dev)1412		return NULL;1413 1414	/* Initialize opp-dev */1415	opp_dev->dev = dev;1416 1417	mutex_lock(&opp_table->lock);1418	list_add(&opp_dev->node, &opp_table->dev_list);1419	mutex_unlock(&opp_table->lock);1420 1421	/* Create debugfs entries for the opp_table */1422	opp_debug_register(opp_dev, opp_table);1423 1424	return opp_dev;1425}1426 1427static struct opp_table *_allocate_opp_table(struct device *dev, int index)1428{1429	struct opp_table *opp_table;1430	struct opp_device *opp_dev;1431	int ret;1432 1433	/*1434	 * Allocate a new OPP table. In the infrequent case where a new1435	 * device is needed to be added, we pay this penalty.1436	 */1437	opp_table = kzalloc(sizeof(*opp_table), GFP_KERNEL);1438	if (!opp_table)1439		return ERR_PTR(-ENOMEM);1440 1441	mutex_init(&opp_table->lock);1442	INIT_LIST_HEAD(&opp_table->dev_list);1443	INIT_LIST_HEAD(&opp_table->lazy);1444 1445	opp_table->clk = ERR_PTR(-ENODEV);1446 1447	/* Mark regulator count uninitialized */1448	opp_table->regulator_count = -1;1449 1450	opp_dev = _add_opp_dev(dev, opp_table);1451	if (!opp_dev) {1452		ret = -ENOMEM;1453		goto err;1454	}1455 1456	_of_init_opp_table(opp_table, dev, index);1457 1458	/* Find interconnect path(s) for the device */1459	ret = dev_pm_opp_of_find_icc_paths(dev, opp_table);1460	if (ret) {1461		if (ret == -EPROBE_DEFER)1462			goto remove_opp_dev;1463 1464		dev_warn(dev, "%s: Error finding interconnect paths: %d\n",1465			 __func__, ret);1466	}1467 1468	BLOCKING_INIT_NOTIFIER_HEAD(&opp_table->head);1469	INIT_LIST_HEAD(&opp_table->opp_list);1470	kref_init(&opp_table->kref);1471 1472	return opp_table;1473 1474remove_opp_dev:1475	_of_clear_opp_table(opp_table);1476	_remove_opp_dev(opp_dev, opp_table);1477	mutex_destroy(&opp_table->lock);1478err:1479	kfree(opp_table);1480	return ERR_PTR(ret);1481}1482 1483void _get_opp_table_kref(struct opp_table *opp_table)1484{1485	kref_get(&opp_table->kref);1486}1487 1488static struct opp_table *_update_opp_table_clk(struct device *dev,1489					       struct opp_table *opp_table,1490					       bool getclk)1491{1492	int ret;1493 1494	/*1495	 * Return early if we don't need to get clk or we have already done it1496	 * earlier.1497	 */1498	if (!getclk || IS_ERR(opp_table) || !IS_ERR(opp_table->clk) ||1499	    opp_table->clks)1500		return opp_table;1501 1502	/* Find clk for the device */1503	opp_table->clk = clk_get(dev, NULL);1504 1505	ret = PTR_ERR_OR_ZERO(opp_table->clk);1506	if (!ret) {1507		opp_table->config_clks = _opp_config_clk_single;1508		opp_table->clk_count = 1;1509		return opp_table;1510	}1511 1512	if (ret == -ENOENT) {1513		/*1514		 * There are few platforms which don't want the OPP core to1515		 * manage device's clock settings. In such cases neither the1516		 * platform provides the clks explicitly to us, nor the DT1517		 * contains a valid clk entry. The OPP nodes in DT may still1518		 * contain "opp-hz" property though, which we need to parse and1519		 * allow the platform to find an OPP based on freq later on.1520		 *1521		 * This is a simple solution to take care of such corner cases,1522		 * i.e. make the clk_count 1, which lets us allocate space for1523		 * frequency in opp->rates and also parse the entries in DT.1524		 */1525		opp_table->clk_count = 1;1526 1527		dev_dbg(dev, "%s: Couldn't find clock: %d\n", __func__, ret);1528		return opp_table;1529	}1530 1531	dev_pm_opp_put_opp_table(opp_table);1532	dev_err_probe(dev, ret, "Couldn't find clock\n");1533 1534	return ERR_PTR(ret);1535}1536 1537/*1538 * We need to make sure that the OPP table for a device doesn't get added twice,1539 * if this routine gets called in parallel with the same device pointer.1540 *1541 * The simplest way to enforce that is to perform everything (find existing1542 * table and if not found, create a new one) under the opp_table_lock, so only1543 * one creator gets access to the same. But that expands the critical section1544 * under the lock and may end up causing circular dependencies with frameworks1545 * like debugfs, interconnect or clock framework as they may be direct or1546 * indirect users of OPP core.1547 *1548 * And for that reason we have to go for a bit tricky implementation here, which1549 * uses the opp_tables_busy flag to indicate if another creator is in the middle1550 * of adding an OPP table and others should wait for it to finish.1551 */1552struct opp_table *_add_opp_table_indexed(struct device *dev, int index,1553					 bool getclk)1554{1555	struct opp_table *opp_table;1556 1557again:1558	mutex_lock(&opp_table_lock);1559 1560	opp_table = _find_opp_table_unlocked(dev);1561	if (!IS_ERR(opp_table))1562		goto unlock;1563 1564	/*1565	 * The opp_tables list or an OPP table's dev_list is getting updated by1566	 * another user, wait for it to finish.1567	 */1568	if (unlikely(opp_tables_busy)) {1569		mutex_unlock(&opp_table_lock);1570		cpu_relax();1571		goto again;1572	}1573 1574	opp_tables_busy = true;1575	opp_table = _managed_opp(dev, index);1576 1577	/* Drop the lock to reduce the size of critical section */1578	mutex_unlock(&opp_table_lock);1579 1580	if (opp_table) {1581		if (!_add_opp_dev(dev, opp_table)) {1582			dev_pm_opp_put_opp_table(opp_table);1583			opp_table = ERR_PTR(-ENOMEM);1584		}1585 1586		mutex_lock(&opp_table_lock);1587	} else {1588		opp_table = _allocate_opp_table(dev, index);1589 1590		mutex_lock(&opp_table_lock);1591		if (!IS_ERR(opp_table))1592			list_add(&opp_table->node, &opp_tables);1593	}1594 1595	opp_tables_busy = false;1596 1597unlock:1598	mutex_unlock(&opp_table_lock);1599 1600	return _update_opp_table_clk(dev, opp_table, getclk);1601}1602 1603static struct opp_table *_add_opp_table(struct device *dev, bool getclk)1604{1605	return _add_opp_table_indexed(dev, 0, getclk);1606}1607 1608struct opp_table *dev_pm_opp_get_opp_table(struct device *dev)1609{1610	return _find_opp_table(dev);1611}1612EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_table);1613 1614static void _opp_table_kref_release(struct kref *kref)1615{1616	struct opp_table *opp_table = container_of(kref, struct opp_table, kref);1617	struct opp_device *opp_dev, *temp;1618	int i;1619 1620	/* Drop the lock as soon as we can */1621	list_del(&opp_table->node);1622	mutex_unlock(&opp_table_lock);1623 1624	if (opp_table->current_opp)1625		dev_pm_opp_put(opp_table->current_opp);1626 1627	_of_clear_opp_table(opp_table);1628 1629	/* Release automatically acquired single clk */1630	if (!IS_ERR(opp_table->clk))1631		clk_put(opp_table->clk);1632 1633	if (opp_table->paths) {1634		for (i = 0; i < opp_table->path_count; i++)1635			icc_put(opp_table->paths[i]);1636		kfree(opp_table->paths);1637	}1638 1639	WARN_ON(!list_empty(&opp_table->opp_list));1640 1641	list_for_each_entry_safe(opp_dev, temp, &opp_table->dev_list, node)1642		_remove_opp_dev(opp_dev, opp_table);1643 1644	mutex_destroy(&opp_table->lock);1645	kfree(opp_table);1646}1647 1648void dev_pm_opp_put_opp_table(struct opp_table *opp_table)1649{1650	kref_put_mutex(&opp_table->kref, _opp_table_kref_release,1651		       &opp_table_lock);1652}1653EXPORT_SYMBOL_GPL(dev_pm_opp_put_opp_table);1654 1655void _opp_free(struct dev_pm_opp *opp)1656{1657	kfree(opp);1658}1659 1660static void _opp_kref_release(struct kref *kref)1661{1662	struct dev_pm_opp *opp = container_of(kref, struct dev_pm_opp, kref);1663	struct opp_table *opp_table = opp->opp_table;1664 1665	list_del(&opp->node);1666	mutex_unlock(&opp_table->lock);1667 1668	/*1669	 * Notify the changes in the availability of the operable1670	 * frequency/voltage list.1671	 */1672	blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_REMOVE, opp);1673	_of_clear_opp(opp_table, opp);1674	opp_debug_remove_one(opp);1675	kfree(opp);1676}1677 1678void dev_pm_opp_get(struct dev_pm_opp *opp)1679{1680	kref_get(&opp->kref);1681}1682 1683void dev_pm_opp_put(struct dev_pm_opp *opp)1684{1685	kref_put_mutex(&opp->kref, _opp_kref_release, &opp->opp_table->lock);1686}1687EXPORT_SYMBOL_GPL(dev_pm_opp_put);1688 1689/**1690 * dev_pm_opp_remove()  - Remove an OPP from OPP table1691 * @dev:	device for which we do this operation1692 * @freq:	OPP to remove with matching 'freq'1693 *1694 * This function removes an opp from the opp table.1695 */1696void dev_pm_opp_remove(struct device *dev, unsigned long freq)1697{1698	struct dev_pm_opp *opp = NULL, *iter;1699	struct opp_table *opp_table;1700 1701	opp_table = _find_opp_table(dev);1702	if (IS_ERR(opp_table))1703		return;1704 1705	if (!assert_single_clk(opp_table))1706		goto put_table;1707 1708	mutex_lock(&opp_table->lock);1709 1710	list_for_each_entry(iter, &opp_table->opp_list, node) {1711		if (iter->rates[0] == freq) {1712			opp = iter;1713			break;1714		}1715	}1716 1717	mutex_unlock(&opp_table->lock);1718 1719	if (opp) {1720		dev_pm_opp_put(opp);1721 1722		/* Drop the reference taken by dev_pm_opp_add() */1723		dev_pm_opp_put_opp_table(opp_table);1724	} else {1725		dev_warn(dev, "%s: Couldn't find OPP with freq: %lu\n",1726			 __func__, freq);1727	}1728 1729put_table:1730	/* Drop the reference taken by _find_opp_table() */1731	dev_pm_opp_put_opp_table(opp_table);1732}1733EXPORT_SYMBOL_GPL(dev_pm_opp_remove);1734 1735static struct dev_pm_opp *_opp_get_next(struct opp_table *opp_table,1736					bool dynamic)1737{1738	struct dev_pm_opp *opp = NULL, *temp;1739 1740	mutex_lock(&opp_table->lock);1741	list_for_each_entry(temp, &opp_table->opp_list, node) {1742		/*1743		 * Refcount must be dropped only once for each OPP by OPP core,1744		 * do that with help of "removed" flag.1745		 */1746		if (!temp->removed && dynamic == temp->dynamic) {1747			opp = temp;1748			break;1749		}1750	}1751 1752	mutex_unlock(&opp_table->lock);1753	return opp;1754}1755 1756/*1757 * Can't call dev_pm_opp_put() from under the lock as debugfs removal needs to1758 * happen lock less to avoid circular dependency issues. This routine must be1759 * called without the opp_table->lock held.1760 */1761static void _opp_remove_all(struct opp_table *opp_table, bool dynamic)1762{1763	struct dev_pm_opp *opp;1764 1765	while ((opp = _opp_get_next(opp_table, dynamic))) {1766		opp->removed = true;1767		dev_pm_opp_put(opp);1768 1769		/* Drop the references taken by dev_pm_opp_add() */1770		if (dynamic)1771			dev_pm_opp_put_opp_table(opp_table);1772	}1773}1774 1775bool _opp_remove_all_static(struct opp_table *opp_table)1776{1777	mutex_lock(&opp_table->lock);1778 1779	if (!opp_table->parsed_static_opps) {1780		mutex_unlock(&opp_table->lock);1781		return false;1782	}1783 1784	if (--opp_table->parsed_static_opps) {1785		mutex_unlock(&opp_table->lock);1786		return true;1787	}1788 1789	mutex_unlock(&opp_table->lock);1790 1791	_opp_remove_all(opp_table, false);1792	return true;1793}1794 1795/**1796 * dev_pm_opp_remove_all_dynamic() - Remove all dynamically created OPPs1797 * @dev:	device for which we do this operation1798 *1799 * This function removes all dynamically created OPPs from the opp table.1800 */1801void dev_pm_opp_remove_all_dynamic(struct device *dev)1802{1803	struct opp_table *opp_table;1804 1805	opp_table = _find_opp_table(dev);1806	if (IS_ERR(opp_table))1807		return;1808 1809	_opp_remove_all(opp_table, true);1810 1811	/* Drop the reference taken by _find_opp_table() */1812	dev_pm_opp_put_opp_table(opp_table);1813}1814EXPORT_SYMBOL_GPL(dev_pm_opp_remove_all_dynamic);1815 1816struct dev_pm_opp *_opp_allocate(struct opp_table *opp_table)1817{1818	struct dev_pm_opp *opp;1819	int supply_count, supply_size, icc_size, clk_size;1820 1821	/* Allocate space for at least one supply */1822	supply_count = opp_table->regulator_count > 0 ?1823			opp_table->regulator_count : 1;1824	supply_size = sizeof(*opp->supplies) * supply_count;1825	clk_size = sizeof(*opp->rates) * opp_table->clk_count;1826	icc_size = sizeof(*opp->bandwidth) * opp_table->path_count;1827 1828	/* allocate new OPP node and supplies structures */1829	opp = kzalloc(sizeof(*opp) + supply_size + clk_size + icc_size, GFP_KERNEL);1830	if (!opp)1831		return NULL;1832 1833	/* Put the supplies, bw and clock at the end of the OPP structure */1834	opp->supplies = (struct dev_pm_opp_supply *)(opp + 1);1835 1836	opp->rates = (unsigned long *)(opp->supplies + supply_count);1837 1838	if (icc_size)1839		opp->bandwidth = (struct dev_pm_opp_icc_bw *)(opp->rates + opp_table->clk_count);1840 1841	INIT_LIST_HEAD(&opp->node);1842 1843	opp->level = OPP_LEVEL_UNSET;1844 1845	return opp;1846}1847 1848static bool _opp_supported_by_regulators(struct dev_pm_opp *opp,1849					 struct opp_table *opp_table)1850{1851	struct regulator *reg;1852	int i;1853 1854	if (!opp_table->regulators)1855		return true;1856 1857	for (i = 0; i < opp_table->regulator_count; i++) {1858		reg = opp_table->regulators[i];1859 1860		if (!regulator_is_supported_voltage(reg,1861					opp->supplies[i].u_volt_min,1862					opp->supplies[i].u_volt_max)) {1863			pr_warn("%s: OPP minuV: %lu maxuV: %lu, not supported by regulator\n",1864				__func__, opp->supplies[i].u_volt_min,1865				opp->supplies[i].u_volt_max);1866			return false;1867		}1868	}1869 1870	return true;1871}1872 1873static int _opp_compare_rate(struct opp_table *opp_table,1874			     struct dev_pm_opp *opp1, struct dev_pm_opp *opp2)1875{1876	int i;1877 1878	for (i = 0; i < opp_table->clk_count; i++) {1879		if (opp1->rates[i] != opp2->rates[i])1880			return opp1->rates[i] < opp2->rates[i] ? -1 : 1;1881	}1882 1883	/* Same rates for both OPPs */1884	return 0;1885}1886 1887static int _opp_compare_bw(struct opp_table *opp_table, struct dev_pm_opp *opp1,1888			   struct dev_pm_opp *opp2)1889{1890	int i;1891 1892	for (i = 0; i < opp_table->path_count; i++) {1893		if (opp1->bandwidth[i].peak != opp2->bandwidth[i].peak)1894			return opp1->bandwidth[i].peak < opp2->bandwidth[i].peak ? -1 : 1;1895	}1896 1897	/* Same bw for both OPPs */1898	return 0;1899}1900 1901/*1902 * Returns1903 * 0: opp1 == opp21904 * 1: opp1 > opp21905 * -1: opp1 < opp21906 */1907int _opp_compare_key(struct opp_table *opp_table, struct dev_pm_opp *opp1,1908		     struct dev_pm_opp *opp2)1909{1910	int ret;1911 1912	ret = _opp_compare_rate(opp_table, opp1, opp2);1913	if (ret)1914		return ret;1915 1916	ret = _opp_compare_bw(opp_table, opp1, opp2);1917	if (ret)1918		return ret;1919 1920	if (opp1->level != opp2->level)1921		return opp1->level < opp2->level ? -1 : 1;1922 1923	/* Duplicate OPPs */1924	return 0;1925}1926 1927static int _opp_is_duplicate(struct device *dev, struct dev_pm_opp *new_opp,1928			     struct opp_table *opp_table,1929			     struct list_head **head)1930{1931	struct dev_pm_opp *opp;1932	int opp_cmp;1933 1934	/*1935	 * Insert new OPP in order of increasing frequency and discard if1936	 * already present.1937	 *1938	 * Need to use &opp_table->opp_list in the condition part of the 'for'1939	 * loop, don't replace it with head otherwise it will become an infinite1940	 * loop.1941	 */1942	list_for_each_entry(opp, &opp_table->opp_list, node) {1943		opp_cmp = _opp_compare_key(opp_table, new_opp, opp);1944		if (opp_cmp > 0) {1945			*head = &opp->node;1946			continue;1947		}1948 1949		if (opp_cmp < 0)1950			return 0;1951 1952		/* Duplicate OPPs */1953		dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",1954			 __func__, opp->rates[0], opp->supplies[0].u_volt,1955			 opp->available, new_opp->rates[0],1956			 new_opp->supplies[0].u_volt, new_opp->available);1957 1958		/* Should we compare voltages for all regulators here ? */1959		return opp->available &&1960		       new_opp->supplies[0].u_volt == opp->supplies[0].u_volt ? -EBUSY : -EEXIST;1961	}1962 1963	return 0;1964}1965 1966void _required_opps_available(struct dev_pm_opp *opp, int count)1967{1968	int i;1969 1970	for (i = 0; i < count; i++) {1971		if (opp->required_opps[i]->available)1972			continue;1973 1974		opp->available = false;1975		pr_warn("%s: OPP not supported by required OPP %pOF (%lu)\n",1976			 __func__, opp->required_opps[i]->np, opp->rates[0]);1977		return;1978	}1979}1980 1981/*1982 * Returns:1983 * 0: On success. And appropriate error message for duplicate OPPs.1984 * -EBUSY: For OPP with same freq/volt and is available. The callers of1985 *  _opp_add() must return 0 if they receive -EBUSY from it. This is to make1986 *  sure we don't print error messages unnecessarily if different parts of1987 *  kernel try to initialize the OPP table.1988 * -EEXIST: For OPP with same freq but different volt or is unavailable. This1989 *  should be considered an error by the callers of _opp_add().1990 */1991int _opp_add(struct device *dev, struct dev_pm_opp *new_opp,1992	     struct opp_table *opp_table)1993{1994	struct list_head *head;1995	int ret;1996 1997	mutex_lock(&opp_table->lock);1998	head = &opp_table->opp_list;1999 2000	ret = _opp_is_duplicate(dev, new_opp, opp_table, &head);2001	if (ret) {2002		mutex_unlock(&opp_table->lock);2003		return ret;2004	}2005 2006	list_add(&new_opp->node, head);2007	mutex_unlock(&opp_table->lock);2008 2009	new_opp->opp_table = opp_table;2010	kref_init(&new_opp->kref);2011 2012	opp_debug_create_one(new_opp, opp_table);2013 2014	if (!_opp_supported_by_regulators(new_opp, opp_table)) {2015		new_opp->available = false;2016		dev_warn(dev, "%s: OPP not supported by regulators (%lu)\n",2017			 __func__, new_opp->rates[0]);2018	}2019 2020	/* required-opps not fully initialized yet */2021	if (lazy_linking_pending(opp_table))2022		return 0;2023 2024	_required_opps_available(new_opp, opp_table->required_opp_count);2025 2026	return 0;2027}2028 2029/**2030 * _opp_add_v1() - Allocate a OPP based on v1 bindings.2031 * @opp_table:	OPP table2032 * @dev:	device for which we do this operation2033 * @data:	The OPP data for the OPP to add2034 * @dynamic:	Dynamically added OPPs.2035 *2036 * This function adds an opp definition to the opp table and returns status.2037 * The opp is made available by default and it can be controlled using2038 * dev_pm_opp_enable/disable functions and may be removed by dev_pm_opp_remove.2039 *2040 * NOTE: "dynamic" parameter impacts OPPs added by the dev_pm_opp_of_add_table2041 * and freed by dev_pm_opp_of_remove_table.2042 *2043 * Return:2044 * 0		On success OR2045 *		Duplicate OPPs (both freq and volt are same) and opp->available2046 * -EEXIST	Freq are same and volt are different OR2047 *		Duplicate OPPs (both freq and volt are same) and !opp->available2048 * -ENOMEM	Memory allocation failure2049 */2050int _opp_add_v1(struct opp_table *opp_table, struct device *dev,2051		struct dev_pm_opp_data *data, bool dynamic)2052{2053	struct dev_pm_opp *new_opp;2054	unsigned long tol, u_volt = data->u_volt;2055	int ret;2056 2057	if (!assert_single_clk(opp_table))2058		return -EINVAL;2059 2060	new_opp = _opp_allocate(opp_table);2061	if (!new_opp)2062		return -ENOMEM;2063 2064	/* populate the opp table */2065	new_opp->rates[0] = data->freq;2066	new_opp->level = data->level;2067	new_opp->turbo = data->turbo;2068	tol = u_volt * opp_table->voltage_tolerance_v1 / 100;2069	new_opp->supplies[0].u_volt = u_volt;2070	new_opp->supplies[0].u_volt_min = u_volt - tol;2071	new_opp->supplies[0].u_volt_max = u_volt + tol;2072	new_opp->available = true;2073	new_opp->dynamic = dynamic;2074 2075	ret = _opp_add(dev, new_opp, opp_table);2076	if (ret) {2077		/* Don't return error for duplicate OPPs */2078		if (ret == -EBUSY)2079			ret = 0;2080		goto free_opp;2081	}2082 2083	/*2084	 * Notify the changes in the availability of the operable2085	 * frequency/voltage list.2086	 */2087	blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ADD, new_opp);2088	return 0;2089 2090free_opp:2091	_opp_free(new_opp);2092 2093	return ret;2094}2095 2096/*2097 * This is required only for the V2 bindings, and it enables a platform to2098 * specify the hierarchy of versions it supports. OPP layer will then enable2099 * OPPs, which are available for those versions, based on its 'opp-supported-hw'2100 * property.2101 */2102static int _opp_set_supported_hw(struct opp_table *opp_table,2103				 const u32 *versions, unsigned int count)2104{2105	/* Another CPU that shares the OPP table has set the property ? */2106	if (opp_table->supported_hw)2107		return 0;2108 2109	opp_table->supported_hw = kmemdup(versions, count * sizeof(*versions),2110					GFP_KERNEL);2111	if (!opp_table->supported_hw)2112		return -ENOMEM;2113 2114	opp_table->supported_hw_count = count;2115 2116	return 0;2117}2118 2119static void _opp_put_supported_hw(struct opp_table *opp_table)2120{2121	if (opp_table->supported_hw) {2122		kfree(opp_table->supported_hw);2123		opp_table->supported_hw = NULL;2124		opp_table->supported_hw_count = 0;2125	}2126}2127 2128/*2129 * This is required only for the V2 bindings, and it enables a platform to2130 * specify the extn to be used for certain property names. The properties to2131 * which the extension will apply are opp-microvolt and opp-microamp. OPP core2132 * should postfix the property name with -<name> while looking for them.2133 */2134static int _opp_set_prop_name(struct opp_table *opp_table, const char *name)2135{2136	/* Another CPU that shares the OPP table has set the property ? */2137	if (!opp_table->prop_name) {2138		opp_table->prop_name = kstrdup(name, GFP_KERNEL);2139		if (!opp_table->prop_name)2140			return -ENOMEM;2141	}2142 2143	return 0;2144}2145 2146static void _opp_put_prop_name(struct opp_table *opp_table)2147{2148	if (opp_table->prop_name) {2149		kfree(opp_table->prop_name);2150		opp_table->prop_name = NULL;2151	}2152}2153 2154/*2155 * In order to support OPP switching, OPP layer needs to know the name of the2156 * device's regulators, as the core would be required to switch voltages as2157 * well.2158 *2159 * This must be called before any OPPs are initialized for the device.2160 */2161static int _opp_set_regulators(struct opp_table *opp_table, struct device *dev,2162			       const char * const names[])2163{2164	const char * const *temp = names;2165	struct regulator *reg;2166	int count = 0, ret, i;2167 2168	/* Count number of regulators */2169	while (*temp++)2170		count++;2171 2172	if (!count)2173		return -EINVAL;2174 2175	/* Another CPU that shares the OPP table has set the regulators ? */2176	if (opp_table->regulators)2177		return 0;2178 2179	opp_table->regulators = kmalloc_array(count,2180					      sizeof(*opp_table->regulators),2181					      GFP_KERNEL);2182	if (!opp_table->regulators)2183		return -ENOMEM;2184 2185	for (i = 0; i < count; i++) {2186		reg = regulator_get_optional(dev, names[i]);2187		if (IS_ERR(reg)) {2188			ret = dev_err_probe(dev, PTR_ERR(reg),2189					    "%s: no regulator (%s) found\n",2190					    __func__, names[i]);2191			goto free_regulators;2192		}2193 2194		opp_table->regulators[i] = reg;2195	}2196 2197	opp_table->regulator_count = count;2198 2199	/* Set generic config_regulators() for single regulators here */2200	if (count == 1)2201		opp_table->config_regulators = _opp_config_regulator_single;2202 2203	return 0;2204 2205free_regulators:2206	while (i != 0)2207		regulator_put(opp_table->regulators[--i]);2208 2209	kfree(opp_table->regulators);2210	opp_table->regulators = NULL;2211	opp_table->regulator_count = -1;2212 2213	return ret;2214}2215 2216static void _opp_put_regulators(struct opp_table *opp_table)2217{2218	int i;2219 2220	if (!opp_table->regulators)2221		return;2222 2223	if (opp_table->enabled) {2224		for (i = opp_table->regulator_count - 1; i >= 0; i--)2225			regulator_disable(opp_table->regulators[i]);2226	}2227 2228	for (i = opp_table->regulator_count - 1; i >= 0; i--)2229		regulator_put(opp_table->regulators[i]);2230 2231	kfree(opp_table->regulators);2232	opp_table->regulators = NULL;2233	opp_table->regulator_count = -1;2234}2235 2236static void _put_clks(struct opp_table *opp_table, int count)2237{2238	int i;2239 2240	for (i = count - 1; i >= 0; i--)2241		clk_put(opp_table->clks[i]);2242 2243	kfree(opp_table->clks);2244	opp_table->clks = NULL;2245}2246 2247/*2248 * In order to support OPP switching, OPP layer needs to get pointers to the2249 * clocks for the device. Simple cases work fine without using this routine2250 * (i.e. by passing connection-id as NULL), but for a device with multiple2251 * clocks available, the OPP core needs to know the exact names of the clks to2252 * use.2253 *2254 * This must be called before any OPPs are initialized for the device.2255 */2256static int _opp_set_clknames(struct opp_table *opp_table, struct device *dev,2257			     const char * const names[],2258			     config_clks_t config_clks)2259{2260	const char * const *temp = names;2261	int count = 0, ret, i;2262	struct clk *clk;2263 2264	/* Count number of clks */2265	while (*temp++)2266		count++;2267 2268	/*2269	 * This is a special case where we have a single clock, whose connection2270	 * id name is NULL, i.e. first two entries are NULL in the array.2271	 */2272	if (!count && !names[1])2273		count = 1;2274 2275	/* Fail early for invalid configurations */2276	if (!count || (!config_clks && count > 1))2277		return -EINVAL;2278 2279	/* Another CPU that shares the OPP table has set the clkname ? */2280	if (opp_table->clks)2281		return 0;2282 2283	opp_table->clks = kmalloc_array(count, sizeof(*opp_table->clks),2284					GFP_KERNEL);2285	if (!opp_table->clks)2286		return -ENOMEM;2287 2288	/* Find clks for the device */2289	for (i = 0; i < count; i++) {2290		clk = clk_get(dev, names[i]);2291		if (IS_ERR(clk)) {2292			ret = dev_err_probe(dev, PTR_ERR(clk),2293					    "%s: Couldn't find clock with name: %s\n",2294					    __func__, names[i]);2295			goto free_clks;2296		}2297 2298		opp_table->clks[i] = clk;2299	}2300 2301	opp_table->clk_count = count;2302	opp_table->config_clks = config_clks;2303 2304	/* Set generic single clk set here */2305	if (count == 1) {2306		if (!opp_table->config_clks)2307			opp_table->config_clks = _opp_config_clk_single;2308 2309		/*2310		 * We could have just dropped the "clk" field and used "clks"2311		 * everywhere. Instead we kept the "clk" field around for2312		 * following reasons:2313		 *2314		 * - avoiding clks[0] everywhere else.2315		 * - not running single clk helpers for multiple clk usecase by2316		 *   mistake.2317		 *2318		 * Since this is single-clk case, just update the clk pointer2319		 * too.2320		 */2321		opp_table->clk = opp_table->clks[0];2322	}2323 2324	return 0;2325 2326free_clks:2327	_put_clks(opp_table, i);2328	return ret;2329}2330 2331static void _opp_put_clknames(struct opp_table *opp_table)2332{2333	if (!opp_table->clks)2334		return;2335 2336	opp_table->config_clks = NULL;2337	opp_table->clk = ERR_PTR(-ENODEV);2338 2339	_put_clks(opp_table, opp_table->clk_count);2340}2341 2342/*2343 * This is useful to support platforms with multiple regulators per device.2344 *2345 * This must be called before any OPPs are initialized for the device.2346 */2347static int _opp_set_config_regulators_helper(struct opp_table *opp_table,2348		struct device *dev, config_regulators_t config_regulators)2349{2350	/* Another CPU that shares the OPP table has set the helper ? */2351	if (!opp_table->config_regulators)2352		opp_table->config_regulators = config_regulators;2353 2354	return 0;2355}2356 2357static void _opp_put_config_regulators_helper(struct opp_table *opp_table)2358{2359	if (opp_table->config_regulators)2360		opp_table->config_regulators = NULL;2361}2362 2363static void _opp_detach_genpd(struct opp_table *opp_table)2364{2365	int index;2366 2367	for (index = 0; index < opp_table->required_opp_count; index++) {2368		if (!opp_table->required_devs[index])2369			continue;2370 2371		dev_pm_domain_detach(opp_table->required_devs[index], false);2372		opp_table->required_devs[index] = NULL;2373	}2374}2375 2376/*2377 * Multiple generic power domains for a device are supported with the help of2378 * virtual genpd devices, which are created for each consumer device - genpd2379 * pair. These are the device structures which are attached to the power domain2380 * and are required by the OPP core to set the performance state of the genpd.2381 * The same API also works for the case where single genpd is available and so2382 * we don't need to support that separately.2383 *2384 * This helper will normally be called by the consumer driver of the device2385 * "dev", as only that has details of the genpd names.2386 *2387 * This helper needs to be called once with a list of all genpd to attach.2388 * Otherwise the original device structure will be used instead by the OPP core.2389 *2390 * The order of entries in the names array must match the order in which2391 * "required-opps" are added in DT.2392 */2393static int _opp_attach_genpd(struct opp_table *opp_table, struct device *dev,2394			const char * const *names, struct device ***virt_devs)2395{2396	struct device *virt_dev, *gdev;2397	struct opp_table *genpd_table;2398	int index = 0, ret = -EINVAL;2399	const char * const *name = names;2400 2401	if (!opp_table->required_devs) {2402		dev_err(dev, "Required OPPs not available, can't attach genpd\n");2403		return -EINVAL;2404	}2405 2406	/* Genpd core takes care of propagation to parent genpd */2407	if (opp_table->is_genpd) {2408		dev_err(dev, "%s: Operation not supported for genpds\n", __func__);2409		return -EOPNOTSUPP;2410	}2411 2412	/* Checking only the first one is enough ? */2413	if (opp_table->required_devs[0])2414		return 0;2415 2416	while (*name) {2417		if (index >= opp_table->required_opp_count) {2418			dev_err(dev, "Index can't be greater than required-opp-count - 1, %s (%d : %d)\n",2419				*name, opp_table->required_opp_count, index);2420			goto err;2421		}2422 2423		virt_dev = dev_pm_domain_attach_by_name(dev, *name);2424		if (IS_ERR_OR_NULL(virt_dev)) {2425			ret = virt_dev ? PTR_ERR(virt_dev) : -ENODEV;2426			dev_err(dev, "Couldn't attach to pm_domain: %d\n", ret);2427			goto err;2428		}2429 2430		/*2431		 * The required_opp_tables parsing is not perfect, as the OPP2432		 * core does the parsing solely based on the DT node pointers.2433		 * The core sets the required_opp_tables entry to the first OPP2434		 * table in the "opp_tables" list, that matches with the node2435		 * pointer.2436		 *2437		 * If the target DT OPP table is used by multiple devices and2438		 * they all create separate instances of 'struct opp_table' from2439		 * it, then it is possible that the required_opp_tables entry2440		 * may be set to the incorrect sibling device.2441		 *2442		 * Cross check it again and fix if required.2443		 */2444		gdev = dev_to_genpd_dev(virt_dev);2445		if (IS_ERR(gdev)) {2446			ret = PTR_ERR(gdev);2447			goto err;2448		}2449 2450		genpd_table = _find_opp_table(gdev);2451		if (!IS_ERR(genpd_table)) {2452			if (genpd_table != opp_table->required_opp_tables[index]) {2453				dev_pm_opp_put_opp_table(opp_table->required_opp_tables[index]);2454				opp_table->required_opp_tables[index] = genpd_table;2455			} else {2456				dev_pm_opp_put_opp_table(genpd_table);2457			}2458		}2459 2460		opp_table->required_devs[index] = virt_dev;2461		index++;2462		name++;2463	}2464 2465	if (virt_devs)2466		*virt_devs = opp_table->required_devs;2467 2468	return 0;2469 2470err:2471	_opp_detach_genpd(opp_table);2472	return ret;2473 2474}2475 2476static int _opp_set_required_devs(struct opp_table *opp_table,2477				  struct device *dev,2478				  struct device **required_devs)2479{2480	int i;2481 2482	if (!opp_table->required_devs) {2483		dev_err(dev, "Required OPPs not available, can't set required devs\n");2484		return -EINVAL;2485	}2486 2487	/* Another device that shares the OPP table has set the required devs ? */2488	if (opp_table->required_devs[0])2489		return 0;2490 2491	for (i = 0; i < opp_table->required_opp_count; i++) {2492		/* Genpd core takes care of propagation to parent genpd */2493		if (required_devs[i] && opp_table->is_genpd &&2494		    opp_table->required_opp_tables[i]->is_genpd) {2495			dev_err(dev, "%s: Operation not supported for genpds\n", __func__);2496			return -EOPNOTSUPP;2497		}2498 2499		opp_table->required_devs[i] = required_devs[i];2500	}2501 2502	return 0;2503}2504 2505static void _opp_put_required_devs(struct opp_table *opp_table)2506{2507	int i;2508 2509	for (i = 0; i < opp_table->required_opp_count; i++)2510		opp_table->required_devs[i] = NULL;2511}2512 2513static void _opp_clear_config(struct opp_config_data *data)2514{2515	if (data->flags & OPP_CONFIG_REQUIRED_DEVS)2516		_opp_put_required_devs(data->opp_table);2517	else if (data->flags & OPP_CONFIG_GENPD)2518		_opp_detach_genpd(data->opp_table);2519 2520	if (data->flags & OPP_CONFIG_REGULATOR)2521		_opp_put_regulators(data->opp_table);2522	if (data->flags & OPP_CONFIG_SUPPORTED_HW)2523		_opp_put_supported_hw(data->opp_table);2524	if (data->flags & OPP_CONFIG_REGULATOR_HELPER)2525		_opp_put_config_regulators_helper(data->opp_table);2526	if (data->flags & OPP_CONFIG_PROP_NAME)2527		_opp_put_prop_name(data->opp_table);2528	if (data->flags & OPP_CONFIG_CLK)2529		_opp_put_clknames(data->opp_table);2530 2531	dev_pm_opp_put_opp_table(data->opp_table);2532	kfree(data);2533}2534 2535/**2536 * dev_pm_opp_set_config() - Set OPP configuration for the device.2537 * @dev: Device for which configuration is being set.2538 * @config: OPP configuration.2539 *2540 * This allows all device OPP configurations to be performed at once.2541 *2542 * This must be called before any OPPs are initialized for the device. This may2543 * be called multiple times for the same OPP table, for example once for each2544 * CPU that share the same table. This must be balanced by the same number of2545 * calls to dev_pm_opp_clear_config() in order to free the OPP table properly.2546 *2547 * This returns a token to the caller, which must be passed to2548 * dev_pm_opp_clear_config() to free the resources later. The value of the2549 * returned token will be >= 1 for success and negative for errors. The minimum2550 * value of 1 is chosen here to make it easy for callers to manage the resource.2551 */2552int dev_pm_opp_set_config(struct device *dev, struct dev_pm_opp_config *config)2553{2554	struct opp_table *opp_table;2555	struct opp_config_data *data;2556	unsigned int id;2557	int ret;2558 2559	data = kmalloc(sizeof(*data), GFP_KERNEL);2560	if (!data)2561		return -ENOMEM;2562 2563	opp_table = _add_opp_table(dev, false);2564	if (IS_ERR(opp_table)) {2565		kfree(data);2566		return PTR_ERR(opp_table);2567	}2568 2569	data->opp_table = opp_table;2570	data->flags = 0;2571 2572	/* This should be called before OPPs are initialized */2573	if (WARN_ON(!list_empty(&opp_table->opp_list))) {2574		ret = -EBUSY;2575		goto err;2576	}2577 2578	/* Configure clocks */2579	if (config->clk_names) {2580		ret = _opp_set_clknames(opp_table, dev, config->clk_names,2581					config->config_clks);2582		if (ret)2583			goto err;2584 2585		data->flags |= OPP_CONFIG_CLK;2586	} else if (config->config_clks) {2587		/* Don't allow config callback without clocks */2588		ret = -EINVAL;2589		goto err;2590	}2591 2592	/* Configure property names */2593	if (config->prop_name) {2594		ret = _opp_set_prop_name(opp_table, config->prop_name);2595		if (ret)2596			goto err;2597 2598		data->flags |= OPP_CONFIG_PROP_NAME;2599	}2600 2601	/* Configure config_regulators helper */2602	if (config->config_regulators) {2603		ret = _opp_set_config_regulators_helper(opp_table, dev,2604						config->config_regulators);2605		if (ret)2606			goto err;2607 2608		data->flags |= OPP_CONFIG_REGULATOR_HELPER;2609	}2610 2611	/* Configure supported hardware */2612	if (config->supported_hw) {2613		ret = _opp_set_supported_hw(opp_table, config->supported_hw,2614					    config->supported_hw_count);2615		if (ret)2616			goto err;2617 2618		data->flags |= OPP_CONFIG_SUPPORTED_HW;2619	}2620 2621	/* Configure supplies */2622	if (config->regulator_names) {2623		ret = _opp_set_regulators(opp_table, dev,2624					  config->regulator_names);2625		if (ret)2626			goto err;2627 2628		data->flags |= OPP_CONFIG_REGULATOR;2629	}2630 2631	/* Attach genpds */2632	if (config->genpd_names) {2633		if (config->required_devs) {2634			ret = -EINVAL;2635			goto err;2636		}2637 2638		ret = _opp_attach_genpd(opp_table, dev, config->genpd_names,2639					config->virt_devs);2640		if (ret)2641			goto err;2642 2643		data->flags |= OPP_CONFIG_GENPD;2644	} else if (config->required_devs) {2645		ret = _opp_set_required_devs(opp_table, dev,2646					     config->required_devs);2647		if (ret)2648			goto err;2649 2650		data->flags |= OPP_CONFIG_REQUIRED_DEVS;2651	}2652 2653	ret = xa_alloc(&opp_configs, &id, data, XA_LIMIT(1, INT_MAX),2654		       GFP_KERNEL);2655	if (ret)2656		goto err;2657 2658	return id;2659 2660err:2661	_opp_clear_config(data);2662	return ret;2663}2664EXPORT_SYMBOL_GPL(dev_pm_opp_set_config);2665 2666/**2667 * dev_pm_opp_clear_config() - Releases resources blocked for OPP configuration.2668 * @token: The token returned by dev_pm_opp_set_config() previously.2669 *2670 * This allows all device OPP configurations to be cleared at once. This must be2671 * called once for each call made to dev_pm_opp_set_config(), in order to free2672 * the OPPs properly.2673 *2674 * Currently the first call itself ends up freeing all the OPP configurations,2675 * while the later ones only drop the OPP table reference. This works well for2676 * now as we would never want to use an half initialized OPP table and want to2677 * remove the configurations together.2678 */2679void dev_pm_opp_clear_config(int token)2680{2681	struct opp_config_data *data;2682 2683	/*2684	 * This lets the callers call this unconditionally and keep their code2685	 * simple.2686	 */2687	if (unlikely(token <= 0))2688		return;2689 2690	data = xa_erase(&opp_configs, token);2691	if (WARN_ON(!data))2692		return;2693 2694	_opp_clear_config(data);2695}2696EXPORT_SYMBOL_GPL(dev_pm_opp_clear_config);2697 2698static void devm_pm_opp_config_release(void *token)2699{2700	dev_pm_opp_clear_config((unsigned long)token);2701}2702 2703/**2704 * devm_pm_opp_set_config() - Set OPP configuration for the device.2705 * @dev: Device for which configuration is being set.2706 * @config: OPP configuration.2707 *2708 * This allows all device OPP configurations to be performed at once.2709 * This is a resource-managed variant of dev_pm_opp_set_config().2710 *2711 * Return: 0 on success and errorno otherwise.2712 */2713int devm_pm_opp_set_config(struct device *dev, struct dev_pm_opp_config *config)2714{2715	int token = dev_pm_opp_set_config(dev, config);2716 2717	if (token < 0)2718		return token;2719 2720	return devm_add_action_or_reset(dev, devm_pm_opp_config_release,2721					(void *) ((unsigned long) token));2722}2723EXPORT_SYMBOL_GPL(devm_pm_opp_set_config);2724 2725/**2726 * dev_pm_opp_xlate_required_opp() - Find required OPP for @src_table OPP.2727 * @src_table: OPP table which has @dst_table as one of its required OPP table.2728 * @dst_table: Required OPP table of the @src_table.2729 * @src_opp: OPP from the @src_table.2730 *2731 * This function returns the OPP (present in @dst_table) pointed out by the2732 * "required-opps" property of the @src_opp (present in @src_table).2733 *2734 * The callers are required to call dev_pm_opp_put() for the returned OPP after2735 * use.2736 *2737 * Return: pointer to 'struct dev_pm_opp' on success and errorno otherwise.2738 */2739struct dev_pm_opp *dev_pm_opp_xlate_required_opp(struct opp_table *src_table,2740						 struct opp_table *dst_table,2741						 struct dev_pm_opp *src_opp)2742{2743	struct dev_pm_opp *opp, *dest_opp = ERR_PTR(-ENODEV);2744	int i;2745 2746	if (!src_table || !dst_table || !src_opp ||2747	    !src_table->required_opp_tables)2748		return ERR_PTR(-EINVAL);2749 2750	/* required-opps not fully initialized yet */2751	if (lazy_linking_pending(src_table))2752		return ERR_PTR(-EBUSY);2753 2754	for (i = 0; i < src_table->required_opp_count; i++) {2755		if (src_table->required_opp_tables[i] == dst_table) {2756			mutex_lock(&src_table->lock);2757 2758			list_for_each_entry(opp, &src_table->opp_list, node) {2759				if (opp == src_opp) {2760					dest_opp = opp->required_opps[i];2761					dev_pm_opp_get(dest_opp);2762					break;2763				}2764			}2765 2766			mutex_unlock(&src_table->lock);2767			break;2768		}2769	}2770 2771	if (IS_ERR(dest_opp)) {2772		pr_err("%s: Couldn't find matching OPP (%p: %p)\n", __func__,2773		       src_table, dst_table);2774	}2775 2776	return dest_opp;2777}2778EXPORT_SYMBOL_GPL(dev_pm_opp_xlate_required_opp);2779 2780/**2781 * dev_pm_opp_xlate_performance_state() - Find required OPP's pstate for src_table.2782 * @src_table: OPP table which has dst_table as one of its required OPP table.2783 * @dst_table: Required OPP table of the src_table.2784 * @pstate: Current performance state of the src_table.2785 *2786 * This Returns pstate of the OPP (present in @dst_table) pointed out by the2787 * "required-opps" property of the OPP (present in @src_table) which has2788 * performance state set to @pstate.2789 *2790 * Return: Zero or positive performance state on success, otherwise negative2791 * value on errors.2792 */2793int dev_pm_opp_xlate_performance_state(struct opp_table *src_table,2794				       struct opp_table *dst_table,2795				       unsigned int pstate)2796{2797	struct dev_pm_opp *opp;2798	int dest_pstate = -EINVAL;2799	int i;2800 2801	/*2802	 * Normally the src_table will have the "required_opps" property set to2803	 * point to one of the OPPs in the dst_table, but in some cases the2804	 * genpd and its master have one to one mapping of performance states2805	 * and so none of them have the "required-opps" property set. Return the2806	 * pstate of the src_table as it is in such cases.2807	 */2808	if (!src_table || !src_table->required_opp_count)2809		return pstate;2810 2811	/* Both OPP tables must belong to genpds */2812	if (unlikely(!src_table->is_genpd || !dst_table->is_genpd)) {2813		pr_err("%s: Performance state is only valid for genpds.\n", __func__);2814		return -EINVAL;2815	}2816 2817	/* required-opps not fully initialized yet */2818	if (lazy_linking_pending(src_table))2819		return -EBUSY;2820 2821	for (i = 0; i < src_table->required_opp_count; i++) {2822		if (src_table->required_opp_tables[i]->np == dst_table->np)2823			break;2824	}2825 2826	if (unlikely(i == src_table->required_opp_count)) {2827		pr_err("%s: Couldn't find matching OPP table (%p: %p)\n",2828		       __func__, src_table, dst_table);2829		return -EINVAL;2830	}2831 2832	mutex_lock(&src_table->lock);2833 2834	list_for_each_entry(opp, &src_table->opp_list, node) {2835		if (opp->level == pstate) {2836			dest_pstate = opp->required_opps[i]->level;2837			goto unlock;2838		}2839	}2840 2841	pr_err("%s: Couldn't find matching OPP (%p: %p)\n", __func__, src_table,2842	       dst_table);2843 2844unlock:2845	mutex_unlock(&src_table->lock);2846 2847	return dest_pstate;2848}2849 2850/**2851 * dev_pm_opp_add_dynamic()  - Add an OPP table from a table definitions2852 * @dev:	The device for which we do this operation2853 * @data:	The OPP data for the OPP to add2854 *2855 * This function adds an opp definition to the opp table and returns status.2856 * The opp is made available by default and it can be controlled using2857 * dev_pm_opp_enable/disable functions.2858 *2859 * Return:2860 * 0		On success OR2861 *		Duplicate OPPs (both freq and volt are same) and opp->available2862 * -EEXIST	Freq are same and volt are different OR2863 *		Duplicate OPPs (both freq and volt are same) and !opp->available2864 * -ENOMEM	Memory allocation failure2865 */2866int dev_pm_opp_add_dynamic(struct device *dev, struct dev_pm_opp_data *data)2867{2868	struct opp_table *opp_table;2869	int ret;2870 2871	opp_table = _add_opp_table(dev, true);2872	if (IS_ERR(opp_table))2873		return PTR_ERR(opp_table);2874 2875	/* Fix regulator count for dynamic OPPs */2876	opp_table->regulator_count = 1;2877 2878	ret = _opp_add_v1(opp_table, dev, data, true);2879	if (ret)2880		dev_pm_opp_put_opp_table(opp_table);2881 2882	return ret;2883}2884EXPORT_SYMBOL_GPL(dev_pm_opp_add_dynamic);2885 2886/**2887 * _opp_set_availability() - helper to set the availability of an opp2888 * @dev:		device for which we do this operation2889 * @freq:		OPP frequency to modify availability2890 * @availability_req:	availability status requested for this opp2891 *2892 * Set the availability of an OPP, opp_{enable,disable} share a common logic2893 * which is isolated here.2894 *2895 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the2896 * copy operation, returns 0 if no modification was done OR modification was2897 * successful.2898 */2899static int _opp_set_availability(struct device *dev, unsigned long freq,2900				 bool availability_req)2901{2902	struct opp_table *opp_table;2903	struct dev_pm_opp *tmp_opp, *opp = ERR_PTR(-ENODEV);2904	int r = 0;2905 2906	/* Find the opp_table */2907	opp_table = _find_opp_table(dev);2908	if (IS_ERR(opp_table)) {2909		r = PTR_ERR(opp_table);2910		dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);2911		return r;2912	}2913 2914	if (!assert_single_clk(opp_table)) {2915		r = -EINVAL;2916		goto put_table;2917	}2918 2919	mutex_lock(&opp_table->lock);2920 2921	/* Do we have the frequency? */2922	list_for_each_entry(tmp_opp, &opp_table->opp_list, node) {2923		if (tmp_opp->rates[0] == freq) {2924			opp = tmp_opp;2925			break;2926		}2927	}2928 2929	if (IS_ERR(opp)) {2930		r = PTR_ERR(opp);2931		goto unlock;2932	}2933 2934	/* Is update really needed? */2935	if (opp->available == availability_req)2936		goto unlock;2937 2938	opp->available = availability_req;2939 2940	dev_pm_opp_get(opp);2941	mutex_unlock(&opp_table->lock);2942 2943	/* Notify the change of the OPP availability */2944	if (availability_req)2945		blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ENABLE,2946					     opp);2947	else2948		blocking_notifier_call_chain(&opp_table->head,2949					     OPP_EVENT_DISABLE, opp);2950 2951	dev_pm_opp_put(opp);2952	goto put_table;2953 2954unlock:2955	mutex_unlock(&opp_table->lock);2956put_table:2957	dev_pm_opp_put_opp_table(opp_table);2958	return r;2959}2960 2961/**2962 * dev_pm_opp_adjust_voltage() - helper to change the voltage of an OPP2963 * @dev:		device for which we do this operation2964 * @freq:		OPP frequency to adjust voltage of2965 * @u_volt:		new OPP target voltage2966 * @u_volt_min:		new OPP min voltage2967 * @u_volt_max:		new OPP max voltage2968 *2969 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the2970 * copy operation, returns 0 if no modifcation was done OR modification was2971 * successful.2972 */2973int dev_pm_opp_adjust_voltage(struct device *dev, unsigned long freq,2974			      unsigned long u_volt, unsigned long u_volt_min,2975			      unsigned long u_volt_max)2976 2977{2978	struct opp_table *opp_table;2979	struct dev_pm_opp *tmp_opp, *opp = ERR_PTR(-ENODEV);2980	int r = 0;2981 2982	/* Find the opp_table */2983	opp_table = _find_opp_table(dev);2984	if (IS_ERR(opp_table)) {2985		r = PTR_ERR(opp_table);2986		dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);2987		return r;2988	}2989 2990	if (!assert_single_clk(opp_table)) {2991		r = -EINVAL;2992		goto put_table;2993	}2994 2995	mutex_lock(&opp_table->lock);2996 2997	/* Do we have the frequency? */2998	list_for_each_entry(tmp_opp, &opp_table->opp_list, node) {2999		if (tmp_opp->rates[0] == freq) {3000			opp = tmp_opp;3001			break;3002		}3003	}3004 3005	if (IS_ERR(opp)) {3006		r = PTR_ERR(opp);3007		goto adjust_unlock;3008	}3009 3010	/* Is update really needed? */3011	if (opp->supplies->u_volt == u_volt)3012		goto adjust_unlock;3013 3014	opp->supplies->u_volt = u_volt;3015	opp->supplies->u_volt_min = u_volt_min;3016	opp->supplies->u_volt_max = u_volt_max;3017 3018	dev_pm_opp_get(opp);3019	mutex_unlock(&opp_table->lock);3020 3021	/* Notify the voltage change of the OPP */3022	blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ADJUST_VOLTAGE,3023				     opp);3024 3025	dev_pm_opp_put(opp);3026	goto put_table;3027 3028adjust_unlock:3029	mutex_unlock(&opp_table->lock);3030put_table:3031	dev_pm_opp_put_opp_table(opp_table);3032	return r;3033}3034EXPORT_SYMBOL_GPL(dev_pm_opp_adjust_voltage);3035 3036/**3037 * dev_pm_opp_sync_regulators() - Sync state of voltage regulators3038 * @dev:	device for which we do this operation3039 *3040 * Sync voltage state of the OPP table regulators.3041 *3042 * Return: 0 on success or a negative error value.3043 */3044int dev_pm_opp_sync_regulators(struct device *dev)3045{3046	struct opp_table *opp_table;3047	struct regulator *reg;3048	int i, ret = 0;3049 3050	/* Device may not have OPP table */3051	opp_table = _find_opp_table(dev);3052	if (IS_ERR(opp_table))3053		return 0;3054 3055	/* Regulator may not be required for the device */3056	if (unlikely(!opp_table->regulators))3057		goto put_table;3058 3059	/* Nothing to sync if voltage wasn't changed */3060	if (!opp_table->enabled)3061		goto put_table;3062 3063	for (i = 0; i < opp_table->regulator_count; i++) {3064		reg = opp_table->regulators[i];3065		ret = regulator_sync_voltage(reg);3066		if (ret)3067			break;3068	}3069put_table:3070	/* Drop reference taken by _find_opp_table() */3071	dev_pm_opp_put_opp_table(opp_table);3072 3073	return ret;3074}3075EXPORT_SYMBOL_GPL(dev_pm_opp_sync_regulators);3076 3077/**3078 * dev_pm_opp_enable() - Enable a specific OPP3079 * @dev:	device for which we do this operation3080 * @freq:	OPP frequency to enable3081 *3082 * Enables a provided opp. If the operation is valid, this returns 0, else the3083 * corresponding error value. It is meant to be used for users an OPP available3084 * after being temporarily made unavailable with dev_pm_opp_disable.3085 *3086 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the3087 * copy operation, returns 0 if no modification was done OR modification was3088 * successful.3089 */3090int dev_pm_opp_enable(struct device *dev, unsigned long freq)3091{3092	return _opp_set_availability(dev, freq, true);3093}3094EXPORT_SYMBOL_GPL(dev_pm_opp_enable);3095 3096/**3097 * dev_pm_opp_disable() - Disable a specific OPP3098 * @dev:	device for which we do this operation3099 * @freq:	OPP frequency to disable3100 *3101 * Disables a provided opp. If the operation is valid, this returns3102 * 0, else the corresponding error value. It is meant to be a temporary3103 * control by users to make this OPP not available until the circumstances are3104 * right to make it available again (with a call to dev_pm_opp_enable).3105 *3106 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the3107 * copy operation, returns 0 if no modification was done OR modification was3108 * successful.3109 */3110int dev_pm_opp_disable(struct device *dev, unsigned long freq)3111{3112	return _opp_set_availability(dev, freq, false);3113}3114EXPORT_SYMBOL_GPL(dev_pm_opp_disable);3115 3116/**3117 * dev_pm_opp_register_notifier() - Register OPP notifier for the device3118 * @dev:	Device for which notifier needs to be registered3119 * @nb:		Notifier block to be registered3120 *3121 * Return: 0 on success or a negative error value.3122 */3123int dev_pm_opp_register_notifier(struct device *dev, struct notifier_block *nb)3124{3125	struct opp_table *opp_table;3126	int ret;3127 3128	opp_table = _find_opp_table(dev);3129	if (IS_ERR(opp_table))3130		return PTR_ERR(opp_table);3131 3132	ret = blocking_notifier_chain_register(&opp_table->head, nb);3133 3134	dev_pm_opp_put_opp_table(opp_table);3135 3136	return ret;3137}3138EXPORT_SYMBOL(dev_pm_opp_register_notifier);3139 3140/**3141 * dev_pm_opp_unregister_notifier() - Unregister OPP notifier for the device3142 * @dev:	Device for which notifier needs to be unregistered3143 * @nb:		Notifier block to be unregistered3144 *3145 * Return: 0 on success or a negative error value.3146 */3147int dev_pm_opp_unregister_notifier(struct device *dev,3148				   struct notifier_block *nb)3149{3150	struct opp_table *opp_table;3151	int ret;3152 3153	opp_table = _find_opp_table(dev);3154	if (IS_ERR(opp_table))3155		return PTR_ERR(opp_table);3156 3157	ret = blocking_notifier_chain_unregister(&opp_table->head, nb);3158 3159	dev_pm_opp_put_opp_table(opp_table);3160 3161	return ret;3162}3163EXPORT_SYMBOL(dev_pm_opp_unregister_notifier);3164 3165/**3166 * dev_pm_opp_remove_table() - Free all OPPs associated with the device3167 * @dev:	device pointer used to lookup OPP table.3168 *3169 * Free both OPPs created using static entries present in DT and the3170 * dynamically added entries.3171 */3172void dev_pm_opp_remove_table(struct device *dev)3173{3174	struct opp_table *opp_table;3175 3176	/* Check for existing table for 'dev' */3177	opp_table = _find_opp_table(dev);3178	if (IS_ERR(opp_table)) {3179		int error = PTR_ERR(opp_table);3180 3181		if (error != -ENODEV)3182			WARN(1, "%s: opp_table: %d\n",3183			     IS_ERR_OR_NULL(dev) ?3184					"Invalid device" : dev_name(dev),3185			     error);3186		return;3187	}3188 3189	/*3190	 * Drop the extra reference only if the OPP table was successfully added3191	 * with dev_pm_opp_of_add_table() earlier.3192	 **/3193	if (_opp_remove_all_static(opp_table))3194		dev_pm_opp_put_opp_table(opp_table);3195 3196	/* Drop reference taken by _find_opp_table() */3197	dev_pm_opp_put_opp_table(opp_table);3198}3199EXPORT_SYMBOL_GPL(dev_pm_opp_remove_table);3200