2 * Generic OPP Interface
4 * Copyright (C) 2009-2010 Texas Instruments Incorporated.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16 #include <linux/clk.h>
17 #include <linux/errno.h>
18 #include <linux/err.h>
19 #include <linux/slab.h>
20 #include <linux/device.h>
21 #include <linux/export.h>
22 #include <linux/regulator/consumer.h>
27 * The root of the list of all opp-tables. All opp_table structures branch off
28 * from here, with each opp_table containing the list of opps it supports in
29 * various states of availability.
31 LIST_HEAD(opp_tables);
32 /* Lock to allow exclusive modification to the device and opp lists */
33 DEFINE_MUTEX(opp_table_lock);
35 #define opp_rcu_lockdep_assert() \
37 RCU_LOCKDEP_WARN(!rcu_read_lock_held() && \
38 !lockdep_is_held(&opp_table_lock), \
39 "Missing rcu_read_lock() or " \
40 "opp_table_lock protection"); \
43 static struct opp_device *_find_opp_dev(const struct device *dev,
44 struct opp_table *opp_table)
46 struct opp_device *opp_dev;
48 list_for_each_entry(opp_dev, &opp_table->dev_list, node)
49 if (opp_dev->dev == dev)
56 * _find_opp_table() - find opp_table struct using device pointer
57 * @dev: device pointer used to lookup OPP table
59 * Search OPP table for one containing matching device. Does a RCU reader
60 * operation to grab the pointer needed.
62 * Return: pointer to 'struct opp_table' if found, otherwise -ENODEV or
63 * -EINVAL based on type of error.
65 * Locking: For readers, this function must be called under rcu_read_lock().
66 * opp_table is a RCU protected pointer, which means that opp_table is valid
67 * as long as we are under RCU lock.
69 * For Writers, this function must be called with opp_table_lock held.
71 struct opp_table *_find_opp_table(struct device *dev)
73 struct opp_table *opp_table;
75 opp_rcu_lockdep_assert();
77 if (IS_ERR_OR_NULL(dev)) {
78 pr_err("%s: Invalid parameters\n", __func__);
79 return ERR_PTR(-EINVAL);
82 list_for_each_entry_rcu(opp_table, &opp_tables, node)
83 if (_find_opp_dev(dev, opp_table))
86 return ERR_PTR(-ENODEV);
90 * dev_pm_opp_get_voltage() - Gets the voltage corresponding to an opp
91 * @opp: opp for which voltage has to be returned for
93 * Return: voltage in micro volt corresponding to the opp, else
96 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
97 * protected pointer. This means that opp which could have been fetched by
98 * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
99 * under RCU lock. The pointer returned by the opp_find_freq family must be
100 * used in the same section as the usage of this function with the pointer
101 * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
104 unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp)
106 struct dev_pm_opp *tmp_opp;
109 opp_rcu_lockdep_assert();
111 tmp_opp = rcu_dereference(opp);
112 if (IS_ERR_OR_NULL(tmp_opp))
113 pr_err("%s: Invalid parameters\n", __func__);
119 EXPORT_SYMBOL_GPL(dev_pm_opp_get_voltage);
122 * dev_pm_opp_get_freq() - Gets the frequency corresponding to an available opp
123 * @opp: opp for which frequency has to be returned for
125 * Return: frequency in hertz corresponding to the opp, else
128 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
129 * protected pointer. This means that opp which could have been fetched by
130 * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
131 * under RCU lock. The pointer returned by the opp_find_freq family must be
132 * used in the same section as the usage of this function with the pointer
133 * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
136 unsigned long dev_pm_opp_get_freq(struct dev_pm_opp *opp)
138 struct dev_pm_opp *tmp_opp;
141 opp_rcu_lockdep_assert();
143 tmp_opp = rcu_dereference(opp);
144 if (IS_ERR_OR_NULL(tmp_opp) || !tmp_opp->available)
145 pr_err("%s: Invalid parameters\n", __func__);
151 EXPORT_SYMBOL_GPL(dev_pm_opp_get_freq);
154 * dev_pm_opp_is_turbo() - Returns if opp is turbo OPP or not
155 * @opp: opp for which turbo mode is being verified
157 * Turbo OPPs are not for normal use, and can be enabled (under certain
158 * conditions) for short duration of times to finish high throughput work
159 * quickly. Running on them for longer times may overheat the chip.
161 * Return: true if opp is turbo opp, else false.
163 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
164 * protected pointer. This means that opp which could have been fetched by
165 * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
166 * under RCU lock. The pointer returned by the opp_find_freq family must be
167 * used in the same section as the usage of this function with the pointer
168 * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
171 bool dev_pm_opp_is_turbo(struct dev_pm_opp *opp)
173 struct dev_pm_opp *tmp_opp;
175 opp_rcu_lockdep_assert();
177 tmp_opp = rcu_dereference(opp);
178 if (IS_ERR_OR_NULL(tmp_opp) || !tmp_opp->available) {
179 pr_err("%s: Invalid parameters\n", __func__);
183 return tmp_opp->turbo;
185 EXPORT_SYMBOL_GPL(dev_pm_opp_is_turbo);
188 * dev_pm_opp_get_max_clock_latency() - Get max clock latency in nanoseconds
189 * @dev: device for which we do this operation
191 * Return: This function returns the max clock latency in nanoseconds.
193 * Locking: This function takes rcu_read_lock().
195 unsigned long dev_pm_opp_get_max_clock_latency(struct device *dev)
197 struct opp_table *opp_table;
198 unsigned long clock_latency_ns;
202 opp_table = _find_opp_table(dev);
203 if (IS_ERR(opp_table))
204 clock_latency_ns = 0;
206 clock_latency_ns = opp_table->clock_latency_ns_max;
209 return clock_latency_ns;
211 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_clock_latency);
214 * dev_pm_opp_get_max_volt_latency() - Get max voltage latency in nanoseconds
215 * @dev: device for which we do this operation
217 * Return: This function returns the max voltage latency in nanoseconds.
219 * Locking: This function takes rcu_read_lock().
221 unsigned long dev_pm_opp_get_max_volt_latency(struct device *dev)
223 struct opp_table *opp_table;
224 struct dev_pm_opp *opp;
225 struct regulator *reg;
226 unsigned long latency_ns = 0;
227 unsigned long min_uV = ~0, max_uV = 0;
232 opp_table = _find_opp_table(dev);
233 if (IS_ERR(opp_table)) {
238 reg = opp_table->regulator;
240 /* Regulator may not be required for device */
245 list_for_each_entry_rcu(opp, &opp_table->opp_list, node) {
249 if (opp->u_volt_min < min_uV)
250 min_uV = opp->u_volt_min;
251 if (opp->u_volt_max > max_uV)
252 max_uV = opp->u_volt_max;
258 * The caller needs to ensure that opp_table (and hence the regulator)
259 * isn't freed, while we are executing this routine.
261 ret = regulator_set_voltage_time(reg, min_uV, max_uV);
263 latency_ns = ret * 1000;
267 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_volt_latency);
270 * dev_pm_opp_get_max_transition_latency() - Get max transition latency in
272 * @dev: device for which we do this operation
274 * Return: This function returns the max transition latency, in nanoseconds, to
275 * switch from one OPP to other.
277 * Locking: This function takes rcu_read_lock().
279 unsigned long dev_pm_opp_get_max_transition_latency(struct device *dev)
281 return dev_pm_opp_get_max_volt_latency(dev) +
282 dev_pm_opp_get_max_clock_latency(dev);
284 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_transition_latency);
287 * dev_pm_opp_get_suspend_opp() - Get suspend opp
288 * @dev: device for which we do this operation
290 * Return: This function returns pointer to the suspend opp if it is
291 * defined and available, otherwise it returns NULL.
293 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
294 * protected pointer. The reason for the same is that the opp pointer which is
295 * returned will remain valid for use with opp_get_{voltage, freq} only while
296 * under the locked area. The pointer returned must be used prior to unlocking
297 * with rcu_read_unlock() to maintain the integrity of the pointer.
299 struct dev_pm_opp *dev_pm_opp_get_suspend_opp(struct device *dev)
301 struct opp_table *opp_table;
303 opp_rcu_lockdep_assert();
305 opp_table = _find_opp_table(dev);
306 if (IS_ERR(opp_table) || !opp_table->suspend_opp ||
307 !opp_table->suspend_opp->available)
310 return opp_table->suspend_opp;
312 EXPORT_SYMBOL_GPL(dev_pm_opp_get_suspend_opp);
315 * dev_pm_opp_get_opp_count() - Get number of opps available in the opp table
316 * @dev: device for which we do this operation
318 * Return: This function returns the number of available opps if there are any,
319 * else returns 0 if none or the corresponding error value.
321 * Locking: This function takes rcu_read_lock().
323 int dev_pm_opp_get_opp_count(struct device *dev)
325 struct opp_table *opp_table;
326 struct dev_pm_opp *temp_opp;
331 opp_table = _find_opp_table(dev);
332 if (IS_ERR(opp_table)) {
333 count = PTR_ERR(opp_table);
334 dev_dbg(dev, "%s: OPP table not found (%d)\n",
339 list_for_each_entry_rcu(temp_opp, &opp_table->opp_list, node) {
340 if (temp_opp->available)
348 EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count);
351 * dev_pm_opp_find_freq_exact() - search for an exact frequency
352 * @dev: device for which we do this operation
353 * @freq: frequency to search for
354 * @available: true/false - match for available opp
356 * Return: Searches for exact match in the opp table and returns pointer to the
357 * matching opp if found, else returns ERR_PTR in case of error and should
358 * be handled using IS_ERR. Error return values can be:
359 * EINVAL: for bad pointer
360 * ERANGE: no match found for search
361 * ENODEV: if device not found in list of registered devices
363 * Note: available is a modifier for the search. if available=true, then the
364 * match is for exact matching frequency and is available in the stored OPP
365 * table. if false, the match is for exact frequency which is not available.
367 * This provides a mechanism to enable an opp which is not available currently
368 * or the opposite as well.
370 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
371 * protected pointer. The reason for the same is that the opp pointer which is
372 * returned will remain valid for use with opp_get_{voltage, freq} only while
373 * under the locked area. The pointer returned must be used prior to unlocking
374 * with rcu_read_unlock() to maintain the integrity of the pointer.
376 struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,
380 struct opp_table *opp_table;
381 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
383 opp_rcu_lockdep_assert();
385 opp_table = _find_opp_table(dev);
386 if (IS_ERR(opp_table)) {
387 int r = PTR_ERR(opp_table);
389 dev_err(dev, "%s: OPP table not found (%d)\n", __func__, r);
393 list_for_each_entry_rcu(temp_opp, &opp_table->opp_list, node) {
394 if (temp_opp->available == available &&
395 temp_opp->rate == freq) {
403 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact);
405 static noinline struct dev_pm_opp *_find_freq_ceil(struct opp_table *opp_table,
408 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
410 list_for_each_entry_rcu(temp_opp, &opp_table->opp_list, node) {
411 if (temp_opp->available && temp_opp->rate >= *freq) {
422 * dev_pm_opp_find_freq_ceil() - Search for an rounded ceil freq
423 * @dev: device for which we do this operation
424 * @freq: Start frequency
426 * Search for the matching ceil *available* OPP from a starting freq
429 * Return: matching *opp and refreshes *freq accordingly, else returns
430 * ERR_PTR in case of error and should be handled using IS_ERR. Error return
432 * EINVAL: for bad pointer
433 * ERANGE: no match found for search
434 * ENODEV: if device not found in list of registered devices
436 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
437 * protected pointer. The reason for the same is that the opp pointer which is
438 * returned will remain valid for use with opp_get_{voltage, freq} only while
439 * under the locked area. The pointer returned must be used prior to unlocking
440 * with rcu_read_unlock() to maintain the integrity of the pointer.
442 struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
445 struct opp_table *opp_table;
447 opp_rcu_lockdep_assert();
450 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
451 return ERR_PTR(-EINVAL);
454 opp_table = _find_opp_table(dev);
455 if (IS_ERR(opp_table))
456 return ERR_CAST(opp_table);
458 return _find_freq_ceil(opp_table, freq);
460 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil);
463 * dev_pm_opp_find_freq_floor() - Search for a rounded floor freq
464 * @dev: device for which we do this operation
465 * @freq: Start frequency
467 * Search for the matching floor *available* OPP from a starting freq
470 * Return: matching *opp and refreshes *freq accordingly, else returns
471 * ERR_PTR in case of error and should be handled using IS_ERR. Error return
473 * EINVAL: for bad pointer
474 * ERANGE: no match found for search
475 * ENODEV: if device not found in list of registered devices
477 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
478 * protected pointer. The reason for the same is that the opp pointer which is
479 * returned will remain valid for use with opp_get_{voltage, freq} only while
480 * under the locked area. The pointer returned must be used prior to unlocking
481 * with rcu_read_unlock() to maintain the integrity of the pointer.
483 struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
486 struct opp_table *opp_table;
487 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
489 opp_rcu_lockdep_assert();
492 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
493 return ERR_PTR(-EINVAL);
496 opp_table = _find_opp_table(dev);
497 if (IS_ERR(opp_table))
498 return ERR_CAST(opp_table);
500 list_for_each_entry_rcu(temp_opp, &opp_table->opp_list, node) {
501 if (temp_opp->available) {
502 /* go to the next node, before choosing prev */
503 if (temp_opp->rate > *freq)
514 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
517 * The caller needs to ensure that opp_table (and hence the clk) isn't freed,
518 * while clk returned here is used.
520 static struct clk *_get_opp_clk(struct device *dev)
522 struct opp_table *opp_table;
527 opp_table = _find_opp_table(dev);
528 if (IS_ERR(opp_table)) {
529 dev_err(dev, "%s: device opp doesn't exist\n", __func__);
530 clk = ERR_CAST(opp_table);
534 clk = opp_table->clk;
536 dev_err(dev, "%s: No clock available for the device\n",
544 static int _set_opp_voltage(struct device *dev, struct regulator *reg,
545 unsigned long u_volt, unsigned long u_volt_min,
546 unsigned long u_volt_max)
550 /* Regulator not available for device */
552 dev_dbg(dev, "%s: regulator not available: %ld\n", __func__,
557 dev_dbg(dev, "%s: voltages (mV): %lu %lu %lu\n", __func__, u_volt_min,
560 ret = regulator_set_voltage_triplet(reg, u_volt_min, u_volt,
563 dev_err(dev, "%s: failed to set voltage (%lu %lu %lu mV): %d\n",
564 __func__, u_volt_min, u_volt, u_volt_max, ret);
570 * dev_pm_opp_set_rate() - Configure new OPP based on frequency
571 * @dev: device for which we do this operation
572 * @target_freq: frequency to achieve
574 * This configures the power-supplies and clock source to the levels specified
575 * by the OPP corresponding to the target_freq.
577 * Locking: This function takes rcu_read_lock().
579 int dev_pm_opp_set_rate(struct device *dev, unsigned long target_freq)
581 struct opp_table *opp_table;
582 struct dev_pm_opp *old_opp, *opp;
583 struct regulator *reg;
585 unsigned long freq, old_freq;
586 unsigned long u_volt, u_volt_min, u_volt_max;
587 unsigned long old_u_volt, old_u_volt_min, old_u_volt_max;
590 if (unlikely(!target_freq)) {
591 dev_err(dev, "%s: Invalid target frequency %lu\n", __func__,
596 clk = _get_opp_clk(dev);
600 freq = clk_round_rate(clk, target_freq);
604 old_freq = clk_get_rate(clk);
606 /* Return early if nothing to do */
607 if (old_freq == freq) {
608 dev_dbg(dev, "%s: old/new frequencies (%lu Hz) are same, nothing to do\n",
615 opp_table = _find_opp_table(dev);
616 if (IS_ERR(opp_table)) {
617 dev_err(dev, "%s: device opp doesn't exist\n", __func__);
619 return PTR_ERR(opp_table);
622 old_opp = _find_freq_ceil(opp_table, &old_freq);
623 if (IS_ERR(old_opp)) {
624 dev_err(dev, "%s: failed to find current OPP for freq %lu (%ld)\n",
625 __func__, old_freq, PTR_ERR(old_opp));
628 opp = _find_freq_ceil(opp_table, &freq);
631 dev_err(dev, "%s: failed to find OPP for freq %lu (%d)\n",
632 __func__, freq, ret);
637 if (IS_ERR(old_opp)) {
640 old_u_volt = old_opp->u_volt;
641 old_u_volt_min = old_opp->u_volt_min;
642 old_u_volt_max = old_opp->u_volt_max;
645 u_volt = opp->u_volt;
646 u_volt_min = opp->u_volt_min;
647 u_volt_max = opp->u_volt_max;
649 reg = opp_table->regulator;
653 /* Scaling up? Scale voltage before frequency */
654 if (freq >= old_freq) {
655 ret = _set_opp_voltage(dev, reg, u_volt, u_volt_min,
658 goto restore_voltage;
661 /* Change frequency */
663 dev_dbg(dev, "%s: switching OPP: %lu Hz --> %lu Hz\n",
664 __func__, old_freq, freq);
666 ret = clk_set_rate(clk, freq);
668 dev_err(dev, "%s: failed to set clock rate: %d\n", __func__,
670 goto restore_voltage;
673 /* Scaling down? Scale voltage after frequency */
674 if (freq < old_freq) {
675 ret = _set_opp_voltage(dev, reg, u_volt, u_volt_min,
684 if (clk_set_rate(clk, old_freq))
685 dev_err(dev, "%s: failed to restore old-freq (%lu Hz)\n",
688 /* This shouldn't harm even if the voltages weren't updated earlier */
690 _set_opp_voltage(dev, reg, old_u_volt, old_u_volt_min,
696 EXPORT_SYMBOL_GPL(dev_pm_opp_set_rate);
698 /* OPP-dev Helpers */
699 static void _kfree_opp_dev_rcu(struct rcu_head *head)
701 struct opp_device *opp_dev;
703 opp_dev = container_of(head, struct opp_device, rcu_head);
704 kfree_rcu(opp_dev, rcu_head);
707 static void _remove_opp_dev(struct opp_device *opp_dev,
708 struct opp_table *opp_table)
710 opp_debug_unregister(opp_dev, opp_table);
711 list_del(&opp_dev->node);
712 call_srcu(&opp_table->srcu_head.srcu, &opp_dev->rcu_head,
716 struct opp_device *_add_opp_dev(const struct device *dev,
717 struct opp_table *opp_table)
719 struct opp_device *opp_dev;
722 opp_dev = kzalloc(sizeof(*opp_dev), GFP_KERNEL);
726 /* Initialize opp-dev */
728 list_add_rcu(&opp_dev->node, &opp_table->dev_list);
730 /* Create debugfs entries for the opp_table */
731 ret = opp_debug_register(opp_dev, opp_table);
733 dev_err(dev, "%s: Failed to register opp debugfs (%d)\n",
740 * _add_opp_table() - Find OPP table or allocate a new one
741 * @dev: device for which we do this operation
743 * It tries to find an existing table first, if it couldn't find one, it
744 * allocates a new OPP table and returns that.
746 * Return: valid opp_table pointer if success, else NULL.
748 static struct opp_table *_add_opp_table(struct device *dev)
750 struct opp_table *opp_table;
751 struct opp_device *opp_dev;
754 /* Check for existing table for 'dev' first */
755 opp_table = _find_opp_table(dev);
756 if (!IS_ERR(opp_table))
760 * Allocate a new OPP table. In the infrequent case where a new
761 * device is needed to be added, we pay this penalty.
763 opp_table = kzalloc(sizeof(*opp_table), GFP_KERNEL);
767 INIT_LIST_HEAD(&opp_table->dev_list);
769 opp_dev = _add_opp_dev(dev, opp_table);
775 _of_init_opp_table(opp_table, dev);
777 /* Set regulator to a non-NULL error value */
778 opp_table->regulator = ERR_PTR(-ENXIO);
780 /* Find clk for the device */
781 opp_table->clk = clk_get(dev, NULL);
782 if (IS_ERR(opp_table->clk)) {
783 ret = PTR_ERR(opp_table->clk);
784 if (ret != -EPROBE_DEFER)
785 dev_dbg(dev, "%s: Couldn't find clock: %d\n", __func__,
789 srcu_init_notifier_head(&opp_table->srcu_head);
790 INIT_LIST_HEAD(&opp_table->opp_list);
792 /* Secure the device table modification */
793 list_add_rcu(&opp_table->node, &opp_tables);
798 * _kfree_device_rcu() - Free opp_table RCU handler
801 static void _kfree_device_rcu(struct rcu_head *head)
803 struct opp_table *opp_table = container_of(head, struct opp_table,
806 kfree_rcu(opp_table, rcu_head);
810 * _remove_opp_table() - Removes a OPP table
811 * @opp_table: OPP table to be removed.
813 * Removes/frees OPP table if it doesn't contain any OPPs.
815 static void _remove_opp_table(struct opp_table *opp_table)
817 struct opp_device *opp_dev;
819 if (!list_empty(&opp_table->opp_list))
822 if (opp_table->supported_hw)
825 if (opp_table->prop_name)
828 if (!IS_ERR(opp_table->regulator))
832 if (!IS_ERR(opp_table->clk))
833 clk_put(opp_table->clk);
835 opp_dev = list_first_entry(&opp_table->dev_list, struct opp_device,
838 _remove_opp_dev(opp_dev, opp_table);
840 /* dev_list must be empty now */
841 WARN_ON(!list_empty(&opp_table->dev_list));
843 list_del_rcu(&opp_table->node);
844 call_srcu(&opp_table->srcu_head.srcu, &opp_table->rcu_head,
849 * _kfree_opp_rcu() - Free OPP RCU handler
852 static void _kfree_opp_rcu(struct rcu_head *head)
854 struct dev_pm_opp *opp = container_of(head, struct dev_pm_opp, rcu_head);
856 kfree_rcu(opp, rcu_head);
860 * _opp_remove() - Remove an OPP from a table definition
861 * @opp_table: points back to the opp_table struct this opp belongs to
862 * @opp: pointer to the OPP to remove
863 * @notify: OPP_EVENT_REMOVE notification should be sent or not
865 * This function removes an opp definition from the opp table.
867 * Locking: The internal opp_table and opp structures are RCU protected.
868 * It is assumed that the caller holds required mutex for an RCU updater
871 void _opp_remove(struct opp_table *opp_table, struct dev_pm_opp *opp,
875 * Notify the changes in the availability of the operable
876 * frequency/voltage list.
879 srcu_notifier_call_chain(&opp_table->srcu_head,
880 OPP_EVENT_REMOVE, opp);
881 opp_debug_remove_one(opp);
882 list_del_rcu(&opp->node);
883 call_srcu(&opp_table->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);
885 _remove_opp_table(opp_table);
889 * dev_pm_opp_remove() - Remove an OPP from OPP table
890 * @dev: device for which we do this operation
891 * @freq: OPP to remove with matching 'freq'
893 * This function removes an opp from the opp table.
895 * Locking: The internal opp_table and opp structures are RCU protected.
896 * Hence this function internally uses RCU updater strategy with mutex locks
897 * to keep the integrity of the internal data structures. Callers should ensure
898 * that this function is *NOT* called under RCU protection or in contexts where
899 * mutex cannot be locked.
901 void dev_pm_opp_remove(struct device *dev, unsigned long freq)
903 struct dev_pm_opp *opp;
904 struct opp_table *opp_table;
907 /* Hold our table modification lock here */
908 mutex_lock(&opp_table_lock);
910 opp_table = _find_opp_table(dev);
911 if (IS_ERR(opp_table))
914 list_for_each_entry(opp, &opp_table->opp_list, node) {
915 if (opp->rate == freq) {
922 dev_warn(dev, "%s: Couldn't find OPP with freq: %lu\n",
927 _opp_remove(opp_table, opp, true);
929 mutex_unlock(&opp_table_lock);
931 EXPORT_SYMBOL_GPL(dev_pm_opp_remove);
933 struct dev_pm_opp *_allocate_opp(struct device *dev,
934 struct opp_table **opp_table)
936 struct dev_pm_opp *opp;
938 /* allocate new OPP node */
939 opp = kzalloc(sizeof(*opp), GFP_KERNEL);
943 INIT_LIST_HEAD(&opp->node);
945 *opp_table = _add_opp_table(dev);
954 static bool _opp_supported_by_regulators(struct dev_pm_opp *opp,
955 struct opp_table *opp_table)
957 struct regulator *reg = opp_table->regulator;
960 !regulator_is_supported_voltage(reg, opp->u_volt_min,
962 pr_warn("%s: OPP minuV: %lu maxuV: %lu, not supported by regulator\n",
963 __func__, opp->u_volt_min, opp->u_volt_max);
970 int _opp_add(struct device *dev, struct dev_pm_opp *new_opp,
971 struct opp_table *opp_table)
973 struct dev_pm_opp *opp;
974 struct list_head *head = &opp_table->opp_list;
978 * Insert new OPP in order of increasing frequency and discard if
981 * Need to use &opp_table->opp_list in the condition part of the 'for'
982 * loop, don't replace it with head otherwise it will become an infinite
985 list_for_each_entry_rcu(opp, &opp_table->opp_list, node) {
986 if (new_opp->rate > opp->rate) {
991 if (new_opp->rate < opp->rate)
995 dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
996 __func__, opp->rate, opp->u_volt, opp->available,
997 new_opp->rate, new_opp->u_volt, new_opp->available);
999 return opp->available && new_opp->u_volt == opp->u_volt ?
1003 new_opp->opp_table = opp_table;
1004 list_add_rcu(&new_opp->node, head);
1006 ret = opp_debug_create_one(new_opp, opp_table);
1008 dev_err(dev, "%s: Failed to register opp to debugfs (%d)\n",
1011 if (!_opp_supported_by_regulators(new_opp, opp_table)) {
1012 new_opp->available = false;
1013 dev_warn(dev, "%s: OPP not supported by regulators (%lu)\n",
1014 __func__, new_opp->rate);
1021 * _opp_add_v1() - Allocate a OPP based on v1 bindings.
1022 * @dev: device for which we do this operation
1023 * @freq: Frequency in Hz for this OPP
1024 * @u_volt: Voltage in uVolts for this OPP
1025 * @dynamic: Dynamically added OPPs.
1027 * This function adds an opp definition to the opp table and returns status.
1028 * The opp is made available by default and it can be controlled using
1029 * dev_pm_opp_enable/disable functions and may be removed by dev_pm_opp_remove.
1031 * NOTE: "dynamic" parameter impacts OPPs added by the dev_pm_opp_of_add_table
1032 * and freed by dev_pm_opp_of_remove_table.
1034 * Locking: The internal opp_table and opp structures are RCU protected.
1035 * Hence this function internally uses RCU updater strategy with mutex locks
1036 * to keep the integrity of the internal data structures. Callers should ensure
1037 * that this function is *NOT* called under RCU protection or in contexts where
1038 * mutex cannot be locked.
1042 * Duplicate OPPs (both freq and volt are same) and opp->available
1043 * -EEXIST Freq are same and volt are different OR
1044 * Duplicate OPPs (both freq and volt are same) and !opp->available
1045 * -ENOMEM Memory allocation failure
1047 int _opp_add_v1(struct device *dev, unsigned long freq, long u_volt,
1050 struct opp_table *opp_table;
1051 struct dev_pm_opp *new_opp;
1055 /* Hold our table modification lock here */
1056 mutex_lock(&opp_table_lock);
1058 new_opp = _allocate_opp(dev, &opp_table);
1064 /* populate the opp table */
1065 new_opp->rate = freq;
1066 tol = u_volt * opp_table->voltage_tolerance_v1 / 100;
1067 new_opp->u_volt = u_volt;
1068 new_opp->u_volt_min = u_volt - tol;
1069 new_opp->u_volt_max = u_volt + tol;
1070 new_opp->available = true;
1071 new_opp->dynamic = dynamic;
1073 ret = _opp_add(dev, new_opp, opp_table);
1077 mutex_unlock(&opp_table_lock);
1080 * Notify the changes in the availability of the operable
1081 * frequency/voltage list.
1083 srcu_notifier_call_chain(&opp_table->srcu_head, OPP_EVENT_ADD, new_opp);
1087 _opp_remove(opp_table, new_opp, false);
1089 mutex_unlock(&opp_table_lock);
1094 * dev_pm_opp_set_supported_hw() - Set supported platforms
1095 * @dev: Device for which supported-hw has to be set.
1096 * @versions: Array of hierarchy of versions to match.
1097 * @count: Number of elements in the array.
1099 * This is required only for the V2 bindings, and it enables a platform to
1100 * specify the hierarchy of versions it supports. OPP layer will then enable
1101 * OPPs, which are available for those versions, based on its 'opp-supported-hw'
1104 * Locking: The internal opp_table and opp structures are RCU protected.
1105 * Hence this function internally uses RCU updater strategy with mutex locks
1106 * to keep the integrity of the internal data structures. Callers should ensure
1107 * that this function is *NOT* called under RCU protection or in contexts where
1108 * mutex cannot be locked.
1110 int dev_pm_opp_set_supported_hw(struct device *dev, const u32 *versions,
1113 struct opp_table *opp_table;
1116 /* Hold our table modification lock here */
1117 mutex_lock(&opp_table_lock);
1119 opp_table = _add_opp_table(dev);
1125 /* Make sure there are no concurrent readers while updating opp_table */
1126 WARN_ON(!list_empty(&opp_table->opp_list));
1128 /* Do we already have a version hierarchy associated with opp_table? */
1129 if (opp_table->supported_hw) {
1130 dev_err(dev, "%s: Already have supported hardware list\n",
1136 opp_table->supported_hw = kmemdup(versions, count * sizeof(*versions),
1138 if (!opp_table->supported_hw) {
1143 opp_table->supported_hw_count = count;
1144 mutex_unlock(&opp_table_lock);
1148 _remove_opp_table(opp_table);
1150 mutex_unlock(&opp_table_lock);
1154 EXPORT_SYMBOL_GPL(dev_pm_opp_set_supported_hw);
1157 * dev_pm_opp_put_supported_hw() - Releases resources blocked for supported hw
1158 * @dev: Device for which supported-hw has to be put.
1160 * This is required only for the V2 bindings, and is called for a matching
1161 * dev_pm_opp_set_supported_hw(). Until this is called, the opp_table structure
1162 * will not be freed.
1164 * Locking: The internal opp_table and opp structures are RCU protected.
1165 * Hence this function internally uses RCU updater strategy with mutex locks
1166 * to keep the integrity of the internal data structures. Callers should ensure
1167 * that this function is *NOT* called under RCU protection or in contexts where
1168 * mutex cannot be locked.
1170 void dev_pm_opp_put_supported_hw(struct device *dev)
1172 struct opp_table *opp_table;
1174 /* Hold our table modification lock here */
1175 mutex_lock(&opp_table_lock);
1177 /* Check for existing table for 'dev' first */
1178 opp_table = _find_opp_table(dev);
1179 if (IS_ERR(opp_table)) {
1180 dev_err(dev, "Failed to find opp_table: %ld\n",
1181 PTR_ERR(opp_table));
1185 /* Make sure there are no concurrent readers while updating opp_table */
1186 WARN_ON(!list_empty(&opp_table->opp_list));
1188 if (!opp_table->supported_hw) {
1189 dev_err(dev, "%s: Doesn't have supported hardware list\n",
1194 kfree(opp_table->supported_hw);
1195 opp_table->supported_hw = NULL;
1196 opp_table->supported_hw_count = 0;
1198 /* Try freeing opp_table if this was the last blocking resource */
1199 _remove_opp_table(opp_table);
1202 mutex_unlock(&opp_table_lock);
1204 EXPORT_SYMBOL_GPL(dev_pm_opp_put_supported_hw);
1207 * dev_pm_opp_set_prop_name() - Set prop-extn name
1208 * @dev: Device for which the prop-name has to be set.
1209 * @name: name to postfix to properties.
1211 * This is required only for the V2 bindings, and it enables a platform to
1212 * specify the extn to be used for certain property names. The properties to
1213 * which the extension will apply are opp-microvolt and opp-microamp. OPP core
1214 * should postfix the property name with -<name> while looking for them.
1216 * Locking: The internal opp_table and opp structures are RCU protected.
1217 * Hence this function internally uses RCU updater strategy with mutex locks
1218 * to keep the integrity of the internal data structures. Callers should ensure
1219 * that this function is *NOT* called under RCU protection or in contexts where
1220 * mutex cannot be locked.
1222 int dev_pm_opp_set_prop_name(struct device *dev, const char *name)
1224 struct opp_table *opp_table;
1227 /* Hold our table modification lock here */
1228 mutex_lock(&opp_table_lock);
1230 opp_table = _add_opp_table(dev);
1236 /* Make sure there are no concurrent readers while updating opp_table */
1237 WARN_ON(!list_empty(&opp_table->opp_list));
1239 /* Do we already have a prop-name associated with opp_table? */
1240 if (opp_table->prop_name) {
1241 dev_err(dev, "%s: Already have prop-name %s\n", __func__,
1242 opp_table->prop_name);
1247 opp_table->prop_name = kstrdup(name, GFP_KERNEL);
1248 if (!opp_table->prop_name) {
1253 mutex_unlock(&opp_table_lock);
1257 _remove_opp_table(opp_table);
1259 mutex_unlock(&opp_table_lock);
1263 EXPORT_SYMBOL_GPL(dev_pm_opp_set_prop_name);
1266 * dev_pm_opp_put_prop_name() - Releases resources blocked for prop-name
1267 * @dev: Device for which the prop-name has to be put.
1269 * This is required only for the V2 bindings, and is called for a matching
1270 * dev_pm_opp_set_prop_name(). Until this is called, the opp_table structure
1271 * will not be freed.
1273 * Locking: The internal opp_table and opp structures are RCU protected.
1274 * Hence this function internally uses RCU updater strategy with mutex locks
1275 * to keep the integrity of the internal data structures. Callers should ensure
1276 * that this function is *NOT* called under RCU protection or in contexts where
1277 * mutex cannot be locked.
1279 void dev_pm_opp_put_prop_name(struct device *dev)
1281 struct opp_table *opp_table;
1283 /* Hold our table modification lock here */
1284 mutex_lock(&opp_table_lock);
1286 /* Check for existing table for 'dev' first */
1287 opp_table = _find_opp_table(dev);
1288 if (IS_ERR(opp_table)) {
1289 dev_err(dev, "Failed to find opp_table: %ld\n",
1290 PTR_ERR(opp_table));
1294 /* Make sure there are no concurrent readers while updating opp_table */
1295 WARN_ON(!list_empty(&opp_table->opp_list));
1297 if (!opp_table->prop_name) {
1298 dev_err(dev, "%s: Doesn't have a prop-name\n", __func__);
1302 kfree(opp_table->prop_name);
1303 opp_table->prop_name = NULL;
1305 /* Try freeing opp_table if this was the last blocking resource */
1306 _remove_opp_table(opp_table);
1309 mutex_unlock(&opp_table_lock);
1311 EXPORT_SYMBOL_GPL(dev_pm_opp_put_prop_name);
1314 * dev_pm_opp_set_regulator() - Set regulator name for the device
1315 * @dev: Device for which regulator name is being set.
1316 * @name: Name of the regulator.
1318 * In order to support OPP switching, OPP layer needs to know the name of the
1319 * device's regulator, as the core would be required to switch voltages as well.
1321 * This must be called before any OPPs are initialized for the device.
1323 * Locking: The internal opp_table and opp structures are RCU protected.
1324 * Hence this function internally uses RCU updater strategy with mutex locks
1325 * to keep the integrity of the internal data structures. Callers should ensure
1326 * that this function is *NOT* called under RCU protection or in contexts where
1327 * mutex cannot be locked.
1329 struct opp_table *dev_pm_opp_set_regulator(struct device *dev, const char *name)
1331 struct opp_table *opp_table;
1332 struct regulator *reg;
1335 mutex_lock(&opp_table_lock);
1337 opp_table = _add_opp_table(dev);
1343 /* This should be called before OPPs are initialized */
1344 if (WARN_ON(!list_empty(&opp_table->opp_list))) {
1349 /* Already have a regulator set */
1350 if (WARN_ON(!IS_ERR(opp_table->regulator))) {
1354 /* Allocate the regulator */
1355 reg = regulator_get_optional(dev, name);
1358 if (ret != -EPROBE_DEFER)
1359 dev_err(dev, "%s: no regulator (%s) found: %d\n",
1360 __func__, name, ret);
1364 opp_table->regulator = reg;
1366 mutex_unlock(&opp_table_lock);
1370 _remove_opp_table(opp_table);
1372 mutex_unlock(&opp_table_lock);
1374 return ERR_PTR(ret);
1376 EXPORT_SYMBOL_GPL(dev_pm_opp_set_regulator);
1379 * dev_pm_opp_put_regulator() - Releases resources blocked for regulator
1380 * @opp_table: OPP table returned from dev_pm_opp_set_regulator().
1382 * Locking: The internal opp_table and opp structures are RCU protected.
1383 * Hence this function internally uses RCU updater strategy with mutex locks
1384 * to keep the integrity of the internal data structures. Callers should ensure
1385 * that this function is *NOT* called under RCU protection or in contexts where
1386 * mutex cannot be locked.
1388 void dev_pm_opp_put_regulator(struct opp_table *opp_table)
1390 mutex_lock(&opp_table_lock);
1392 if (IS_ERR(opp_table->regulator)) {
1393 pr_err("%s: Doesn't have regulator set\n", __func__);
1397 /* Make sure there are no concurrent readers while updating opp_table */
1398 WARN_ON(!list_empty(&opp_table->opp_list));
1400 regulator_put(opp_table->regulator);
1401 opp_table->regulator = ERR_PTR(-ENXIO);
1403 /* Try freeing opp_table if this was the last blocking resource */
1404 _remove_opp_table(opp_table);
1407 mutex_unlock(&opp_table_lock);
1409 EXPORT_SYMBOL_GPL(dev_pm_opp_put_regulator);
1412 * dev_pm_opp_add() - Add an OPP table from a table definitions
1413 * @dev: device for which we do this operation
1414 * @freq: Frequency in Hz for this OPP
1415 * @u_volt: Voltage in uVolts for this OPP
1417 * This function adds an opp definition to the opp table and returns status.
1418 * The opp is made available by default and it can be controlled using
1419 * dev_pm_opp_enable/disable functions.
1421 * Locking: The internal opp_table and opp structures are RCU protected.
1422 * Hence this function internally uses RCU updater strategy with mutex locks
1423 * to keep the integrity of the internal data structures. Callers should ensure
1424 * that this function is *NOT* called under RCU protection or in contexts where
1425 * mutex cannot be locked.
1429 * Duplicate OPPs (both freq and volt are same) and opp->available
1430 * -EEXIST Freq are same and volt are different OR
1431 * Duplicate OPPs (both freq and volt are same) and !opp->available
1432 * -ENOMEM Memory allocation failure
1434 int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
1436 return _opp_add_v1(dev, freq, u_volt, true);
1438 EXPORT_SYMBOL_GPL(dev_pm_opp_add);
1441 * _opp_set_availability() - helper to set the availability of an opp
1442 * @dev: device for which we do this operation
1443 * @freq: OPP frequency to modify availability
1444 * @availability_req: availability status requested for this opp
1446 * Set the availability of an OPP with an RCU operation, opp_{enable,disable}
1447 * share a common logic which is isolated here.
1449 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1450 * copy operation, returns 0 if no modification was done OR modification was
1453 * Locking: The internal opp_table and opp structures are RCU protected.
1454 * Hence this function internally uses RCU updater strategy with mutex locks to
1455 * keep the integrity of the internal data structures. Callers should ensure
1456 * that this function is *NOT* called under RCU protection or in contexts where
1457 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1459 static int _opp_set_availability(struct device *dev, unsigned long freq,
1460 bool availability_req)
1462 struct opp_table *opp_table;
1463 struct dev_pm_opp *new_opp, *tmp_opp, *opp = ERR_PTR(-ENODEV);
1466 /* keep the node allocated */
1467 new_opp = kmalloc(sizeof(*new_opp), GFP_KERNEL);
1471 mutex_lock(&opp_table_lock);
1473 /* Find the opp_table */
1474 opp_table = _find_opp_table(dev);
1475 if (IS_ERR(opp_table)) {
1476 r = PTR_ERR(opp_table);
1477 dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);
1481 /* Do we have the frequency? */
1482 list_for_each_entry(tmp_opp, &opp_table->opp_list, node) {
1483 if (tmp_opp->rate == freq) {
1493 /* Is update really needed? */
1494 if (opp->available == availability_req)
1496 /* copy the old data over */
1499 /* plug in new node */
1500 new_opp->available = availability_req;
1502 list_replace_rcu(&opp->node, &new_opp->node);
1503 mutex_unlock(&opp_table_lock);
1504 call_srcu(&opp_table->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);
1506 /* Notify the change of the OPP availability */
1507 if (availability_req)
1508 srcu_notifier_call_chain(&opp_table->srcu_head,
1509 OPP_EVENT_ENABLE, new_opp);
1511 srcu_notifier_call_chain(&opp_table->srcu_head,
1512 OPP_EVENT_DISABLE, new_opp);
1517 mutex_unlock(&opp_table_lock);
1523 * dev_pm_opp_enable() - Enable a specific OPP
1524 * @dev: device for which we do this operation
1525 * @freq: OPP frequency to enable
1527 * Enables a provided opp. If the operation is valid, this returns 0, else the
1528 * corresponding error value. It is meant to be used for users an OPP available
1529 * after being temporarily made unavailable with dev_pm_opp_disable.
1531 * Locking: The internal opp_table and opp structures are RCU protected.
1532 * Hence this function indirectly uses RCU and mutex locks to keep the
1533 * integrity of the internal data structures. Callers should ensure that
1534 * this function is *NOT* called under RCU protection or in contexts where
1535 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1537 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1538 * copy operation, returns 0 if no modification was done OR modification was
1541 int dev_pm_opp_enable(struct device *dev, unsigned long freq)
1543 return _opp_set_availability(dev, freq, true);
1545 EXPORT_SYMBOL_GPL(dev_pm_opp_enable);
1548 * dev_pm_opp_disable() - Disable a specific OPP
1549 * @dev: device for which we do this operation
1550 * @freq: OPP frequency to disable
1552 * Disables a provided opp. If the operation is valid, this returns
1553 * 0, else the corresponding error value. It is meant to be a temporary
1554 * control by users to make this OPP not available until the circumstances are
1555 * right to make it available again (with a call to dev_pm_opp_enable).
1557 * Locking: The internal opp_table and opp structures are RCU protected.
1558 * Hence this function indirectly uses RCU and mutex locks to keep the
1559 * integrity of the internal data structures. Callers should ensure that
1560 * this function is *NOT* called under RCU protection or in contexts where
1561 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1563 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1564 * copy operation, returns 0 if no modification was done OR modification was
1567 int dev_pm_opp_disable(struct device *dev, unsigned long freq)
1569 return _opp_set_availability(dev, freq, false);
1571 EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
1574 * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
1575 * @dev: device pointer used to lookup OPP table.
1577 * Return: pointer to notifier head if found, otherwise -ENODEV or
1578 * -EINVAL based on type of error casted as pointer. value must be checked
1579 * with IS_ERR to determine valid pointer or error result.
1581 * Locking: This function must be called under rcu_read_lock(). opp_table is a
1582 * RCU protected pointer. The reason for the same is that the opp pointer which
1583 * is returned will remain valid for use with opp_get_{voltage, freq} only while
1584 * under the locked area. The pointer returned must be used prior to unlocking
1585 * with rcu_read_unlock() to maintain the integrity of the pointer.
1587 struct srcu_notifier_head *dev_pm_opp_get_notifier(struct device *dev)
1589 struct opp_table *opp_table = _find_opp_table(dev);
1591 if (IS_ERR(opp_table))
1592 return ERR_CAST(opp_table); /* matching type */
1594 return &opp_table->srcu_head;
1596 EXPORT_SYMBOL_GPL(dev_pm_opp_get_notifier);
1599 * Free OPPs either created using static entries present in DT or even the
1600 * dynamically added entries based on remove_all param.
1602 void _dev_pm_opp_remove_table(struct device *dev, bool remove_all)
1604 struct opp_table *opp_table;
1605 struct dev_pm_opp *opp, *tmp;
1607 /* Hold our table modification lock here */
1608 mutex_lock(&opp_table_lock);
1610 /* Check for existing table for 'dev' */
1611 opp_table = _find_opp_table(dev);
1612 if (IS_ERR(opp_table)) {
1613 int error = PTR_ERR(opp_table);
1615 if (error != -ENODEV)
1616 WARN(1, "%s: opp_table: %d\n",
1617 IS_ERR_OR_NULL(dev) ?
1618 "Invalid device" : dev_name(dev),
1623 /* Find if opp_table manages a single device */
1624 if (list_is_singular(&opp_table->dev_list)) {
1625 /* Free static OPPs */
1626 list_for_each_entry_safe(opp, tmp, &opp_table->opp_list, node) {
1627 if (remove_all || !opp->dynamic)
1628 _opp_remove(opp_table, opp, true);
1631 _remove_opp_dev(_find_opp_dev(dev, opp_table), opp_table);
1635 mutex_unlock(&opp_table_lock);
1639 * dev_pm_opp_remove_table() - Free all OPPs associated with the device
1640 * @dev: device pointer used to lookup OPP table.
1642 * Free both OPPs created using static entries present in DT and the
1643 * dynamically added entries.
1645 * Locking: The internal opp_table and opp structures are RCU protected.
1646 * Hence this function indirectly uses RCU updater strategy with mutex locks
1647 * to keep the integrity of the internal data structures. Callers should ensure
1648 * that this function is *NOT* called under RCU protection or in contexts where
1649 * mutex cannot be locked.
1651 void dev_pm_opp_remove_table(struct device *dev)
1653 _dev_pm_opp_remove_table(dev, true);
1655 EXPORT_SYMBOL_GPL(dev_pm_opp_remove_table);