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>
22 #include <linux/export.h>
23 #include <linux/regulator/consumer.h>
28 * The root of the list of all opp-tables. All opp_table structures branch off
29 * from here, with each opp_table containing the list of opps it supports in
30 * various states of availability.
32 static LIST_HEAD(opp_tables
);
33 /* Lock to allow exclusive modification to the device and opp lists */
34 DEFINE_MUTEX(opp_table_lock
);
36 #define opp_rcu_lockdep_assert() \
38 RCU_LOCKDEP_WARN(!rcu_read_lock_held() && \
39 !lockdep_is_held(&opp_table_lock), \
40 "Missing rcu_read_lock() or " \
41 "opp_table_lock protection"); \
44 static struct opp_device
*_find_opp_dev(const struct device
*dev
,
45 struct opp_table
*opp_table
)
47 struct opp_device
*opp_dev
;
49 list_for_each_entry(opp_dev
, &opp_table
->dev_list
, node
)
50 if (opp_dev
->dev
== dev
)
56 static struct opp_table
*_managed_opp(const struct device_node
*np
)
58 struct opp_table
*opp_table
;
60 list_for_each_entry_rcu(opp_table
, &opp_tables
, node
) {
61 if (opp_table
->np
== np
) {
63 * Multiple devices can point to the same OPP table and
64 * so will have same node-pointer, np.
66 * But the OPPs will be considered as shared only if the
67 * OPP table contains a "opp-shared" property.
69 return opp_table
->shared_opp
? opp_table
: NULL
;
77 * _find_opp_table() - find opp_table struct using device pointer
78 * @dev: device pointer used to lookup OPP table
80 * Search OPP table for one containing matching device. Does a RCU reader
81 * operation to grab the pointer needed.
83 * Return: pointer to 'struct opp_table' if found, otherwise -ENODEV or
84 * -EINVAL based on type of error.
86 * Locking: For readers, this function must be called under rcu_read_lock().
87 * opp_table is a RCU protected pointer, which means that opp_table is valid
88 * as long as we are under RCU lock.
90 * For Writers, this function must be called with opp_table_lock held.
92 struct opp_table
*_find_opp_table(struct device
*dev
)
94 struct opp_table
*opp_table
;
96 opp_rcu_lockdep_assert();
98 if (IS_ERR_OR_NULL(dev
)) {
99 pr_err("%s: Invalid parameters\n", __func__
);
100 return ERR_PTR(-EINVAL
);
103 list_for_each_entry_rcu(opp_table
, &opp_tables
, node
)
104 if (_find_opp_dev(dev
, opp_table
))
107 return ERR_PTR(-ENODEV
);
111 * dev_pm_opp_get_voltage() - Gets the voltage corresponding to an opp
112 * @opp: opp for which voltage has to be returned for
114 * Return: voltage in micro volt corresponding to the opp, else
117 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
118 * protected pointer. This means that opp which could have been fetched by
119 * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
120 * under RCU lock. The pointer returned by the opp_find_freq family must be
121 * used in the same section as the usage of this function with the pointer
122 * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
125 unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp
*opp
)
127 struct dev_pm_opp
*tmp_opp
;
130 opp_rcu_lockdep_assert();
132 tmp_opp
= rcu_dereference(opp
);
133 if (IS_ERR_OR_NULL(tmp_opp
))
134 pr_err("%s: Invalid parameters\n", __func__
);
140 EXPORT_SYMBOL_GPL(dev_pm_opp_get_voltage
);
143 * dev_pm_opp_get_freq() - Gets the frequency corresponding to an available opp
144 * @opp: opp for which frequency has to be returned for
146 * Return: frequency in hertz corresponding to the opp, else
149 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
150 * protected pointer. This means that opp which could have been fetched by
151 * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
152 * under RCU lock. The pointer returned by the opp_find_freq family must be
153 * used in the same section as the usage of this function with the pointer
154 * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
157 unsigned long dev_pm_opp_get_freq(struct dev_pm_opp
*opp
)
159 struct dev_pm_opp
*tmp_opp
;
162 opp_rcu_lockdep_assert();
164 tmp_opp
= rcu_dereference(opp
);
165 if (IS_ERR_OR_NULL(tmp_opp
) || !tmp_opp
->available
)
166 pr_err("%s: Invalid parameters\n", __func__
);
172 EXPORT_SYMBOL_GPL(dev_pm_opp_get_freq
);
175 * dev_pm_opp_is_turbo() - Returns if opp is turbo OPP or not
176 * @opp: opp for which turbo mode is being verified
178 * Turbo OPPs are not for normal use, and can be enabled (under certain
179 * conditions) for short duration of times to finish high throughput work
180 * quickly. Running on them for longer times may overheat the chip.
182 * Return: true if opp is turbo opp, else false.
184 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
185 * protected pointer. This means that opp which could have been fetched by
186 * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
187 * under RCU lock. The pointer returned by the opp_find_freq family must be
188 * used in the same section as the usage of this function with the pointer
189 * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
192 bool dev_pm_opp_is_turbo(struct dev_pm_opp
*opp
)
194 struct dev_pm_opp
*tmp_opp
;
196 opp_rcu_lockdep_assert();
198 tmp_opp
= rcu_dereference(opp
);
199 if (IS_ERR_OR_NULL(tmp_opp
) || !tmp_opp
->available
) {
200 pr_err("%s: Invalid parameters\n", __func__
);
204 return tmp_opp
->turbo
;
206 EXPORT_SYMBOL_GPL(dev_pm_opp_is_turbo
);
209 * dev_pm_opp_get_max_clock_latency() - Get max clock latency in nanoseconds
210 * @dev: device for which we do this operation
212 * Return: This function returns the max clock latency in nanoseconds.
214 * Locking: This function takes rcu_read_lock().
216 unsigned long dev_pm_opp_get_max_clock_latency(struct device
*dev
)
218 struct opp_table
*opp_table
;
219 unsigned long clock_latency_ns
;
223 opp_table
= _find_opp_table(dev
);
224 if (IS_ERR(opp_table
))
225 clock_latency_ns
= 0;
227 clock_latency_ns
= opp_table
->clock_latency_ns_max
;
230 return clock_latency_ns
;
232 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_clock_latency
);
235 * dev_pm_opp_get_max_volt_latency() - Get max voltage latency in nanoseconds
236 * @dev: device for which we do this operation
238 * Return: This function returns the max voltage latency in nanoseconds.
240 * Locking: This function takes rcu_read_lock().
242 unsigned long dev_pm_opp_get_max_volt_latency(struct device
*dev
)
244 struct opp_table
*opp_table
;
245 struct dev_pm_opp
*opp
;
246 struct regulator
*reg
;
247 unsigned long latency_ns
= 0;
248 unsigned long min_uV
= ~0, max_uV
= 0;
253 opp_table
= _find_opp_table(dev
);
254 if (IS_ERR(opp_table
)) {
259 reg
= opp_table
->regulator
;
261 /* Regulator may not be required for device */
263 dev_err(dev
, "%s: Invalid regulator (%ld)\n", __func__
,
269 list_for_each_entry_rcu(opp
, &opp_table
->opp_list
, node
) {
273 if (opp
->u_volt_min
< min_uV
)
274 min_uV
= opp
->u_volt_min
;
275 if (opp
->u_volt_max
> max_uV
)
276 max_uV
= opp
->u_volt_max
;
282 * The caller needs to ensure that opp_table (and hence the regulator)
283 * isn't freed, while we are executing this routine.
285 ret
= regulator_set_voltage_time(reg
, min_uV
, max_uV
);
287 latency_ns
= ret
* 1000;
291 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_volt_latency
);
294 * dev_pm_opp_get_max_transition_latency() - Get max transition latency in
296 * @dev: device for which we do this operation
298 * Return: This function returns the max transition latency, in nanoseconds, to
299 * switch from one OPP to other.
301 * Locking: This function takes rcu_read_lock().
303 unsigned long dev_pm_opp_get_max_transition_latency(struct device
*dev
)
305 return dev_pm_opp_get_max_volt_latency(dev
) +
306 dev_pm_opp_get_max_clock_latency(dev
);
308 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_transition_latency
);
311 * dev_pm_opp_get_suspend_opp() - Get suspend opp
312 * @dev: device for which we do this operation
314 * Return: This function returns pointer to the suspend opp if it is
315 * defined and available, otherwise it returns NULL.
317 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
318 * protected pointer. The reason for the same is that the opp pointer which is
319 * returned will remain valid for use with opp_get_{voltage, freq} only while
320 * under the locked area. The pointer returned must be used prior to unlocking
321 * with rcu_read_unlock() to maintain the integrity of the pointer.
323 struct dev_pm_opp
*dev_pm_opp_get_suspend_opp(struct device
*dev
)
325 struct opp_table
*opp_table
;
327 opp_rcu_lockdep_assert();
329 opp_table
= _find_opp_table(dev
);
330 if (IS_ERR(opp_table
) || !opp_table
->suspend_opp
||
331 !opp_table
->suspend_opp
->available
)
334 return opp_table
->suspend_opp
;
336 EXPORT_SYMBOL_GPL(dev_pm_opp_get_suspend_opp
);
339 * dev_pm_opp_get_opp_count() - Get number of opps available in the opp table
340 * @dev: device for which we do this operation
342 * Return: This function returns the number of available opps if there are any,
343 * else returns 0 if none or the corresponding error value.
345 * Locking: This function takes rcu_read_lock().
347 int dev_pm_opp_get_opp_count(struct device
*dev
)
349 struct opp_table
*opp_table
;
350 struct dev_pm_opp
*temp_opp
;
355 opp_table
= _find_opp_table(dev
);
356 if (IS_ERR(opp_table
)) {
357 count
= PTR_ERR(opp_table
);
358 dev_err(dev
, "%s: OPP table not found (%d)\n",
363 list_for_each_entry_rcu(temp_opp
, &opp_table
->opp_list
, node
) {
364 if (temp_opp
->available
)
372 EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count
);
375 * dev_pm_opp_find_freq_exact() - search for an exact frequency
376 * @dev: device for which we do this operation
377 * @freq: frequency to search for
378 * @available: true/false - match for available opp
380 * Return: Searches for exact match in the opp table and returns pointer to the
381 * matching opp if found, else returns ERR_PTR in case of error and should
382 * be handled using IS_ERR. Error return values can be:
383 * EINVAL: for bad pointer
384 * ERANGE: no match found for search
385 * ENODEV: if device not found in list of registered devices
387 * Note: available is a modifier for the search. if available=true, then the
388 * match is for exact matching frequency and is available in the stored OPP
389 * table. if false, the match is for exact frequency which is not available.
391 * This provides a mechanism to enable an opp which is not available currently
392 * or the opposite as well.
394 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
395 * protected pointer. The reason for the same is that the opp pointer which is
396 * returned will remain valid for use with opp_get_{voltage, freq} only while
397 * under the locked area. The pointer returned must be used prior to unlocking
398 * with rcu_read_unlock() to maintain the integrity of the pointer.
400 struct dev_pm_opp
*dev_pm_opp_find_freq_exact(struct device
*dev
,
404 struct opp_table
*opp_table
;
405 struct dev_pm_opp
*temp_opp
, *opp
= ERR_PTR(-ERANGE
);
407 opp_rcu_lockdep_assert();
409 opp_table
= _find_opp_table(dev
);
410 if (IS_ERR(opp_table
)) {
411 int r
= PTR_ERR(opp_table
);
413 dev_err(dev
, "%s: OPP table not found (%d)\n", __func__
, r
);
417 list_for_each_entry_rcu(temp_opp
, &opp_table
->opp_list
, node
) {
418 if (temp_opp
->available
== available
&&
419 temp_opp
->rate
== freq
) {
427 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact
);
430 * dev_pm_opp_find_freq_ceil() - Search for an rounded ceil freq
431 * @dev: device for which we do this operation
432 * @freq: Start frequency
434 * Search for the matching ceil *available* OPP from a starting freq
437 * Return: matching *opp and refreshes *freq accordingly, else returns
438 * ERR_PTR in case of error and should be handled using IS_ERR. Error return
440 * EINVAL: for bad pointer
441 * ERANGE: no match found for search
442 * ENODEV: if device not found in list of registered devices
444 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
445 * protected pointer. The reason for the same is that the opp pointer which is
446 * returned will remain valid for use with opp_get_{voltage, freq} only while
447 * under the locked area. The pointer returned must be used prior to unlocking
448 * with rcu_read_unlock() to maintain the integrity of the pointer.
450 struct dev_pm_opp
*dev_pm_opp_find_freq_ceil(struct device
*dev
,
453 struct opp_table
*opp_table
;
454 struct dev_pm_opp
*temp_opp
, *opp
= ERR_PTR(-ERANGE
);
456 opp_rcu_lockdep_assert();
459 dev_err(dev
, "%s: Invalid argument freq=%p\n", __func__
, freq
);
460 return ERR_PTR(-EINVAL
);
463 opp_table
= _find_opp_table(dev
);
464 if (IS_ERR(opp_table
))
465 return ERR_CAST(opp_table
);
467 list_for_each_entry_rcu(temp_opp
, &opp_table
->opp_list
, node
) {
468 if (temp_opp
->available
&& temp_opp
->rate
>= *freq
) {
477 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil
);
480 * dev_pm_opp_find_freq_floor() - Search for a rounded floor freq
481 * @dev: device for which we do this operation
482 * @freq: Start frequency
484 * Search for the matching floor *available* OPP from a starting freq
487 * Return: matching *opp and refreshes *freq accordingly, else returns
488 * ERR_PTR in case of error and should be handled using IS_ERR. Error return
490 * EINVAL: for bad pointer
491 * ERANGE: no match found for search
492 * ENODEV: if device not found in list of registered devices
494 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
495 * protected pointer. The reason for the same is that the opp pointer which is
496 * returned will remain valid for use with opp_get_{voltage, freq} only while
497 * under the locked area. The pointer returned must be used prior to unlocking
498 * with rcu_read_unlock() to maintain the integrity of the pointer.
500 struct dev_pm_opp
*dev_pm_opp_find_freq_floor(struct device
*dev
,
503 struct opp_table
*opp_table
;
504 struct dev_pm_opp
*temp_opp
, *opp
= ERR_PTR(-ERANGE
);
506 opp_rcu_lockdep_assert();
509 dev_err(dev
, "%s: Invalid argument freq=%p\n", __func__
, freq
);
510 return ERR_PTR(-EINVAL
);
513 opp_table
= _find_opp_table(dev
);
514 if (IS_ERR(opp_table
))
515 return ERR_CAST(opp_table
);
517 list_for_each_entry_rcu(temp_opp
, &opp_table
->opp_list
, node
) {
518 if (temp_opp
->available
) {
519 /* go to the next node, before choosing prev */
520 if (temp_opp
->rate
> *freq
)
531 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor
);
534 * The caller needs to ensure that opp_table (and hence the clk) isn't freed,
535 * while clk returned here is used.
537 static struct clk
*_get_opp_clk(struct device
*dev
)
539 struct opp_table
*opp_table
;
544 opp_table
= _find_opp_table(dev
);
545 if (IS_ERR(opp_table
)) {
546 dev_err(dev
, "%s: device opp doesn't exist\n", __func__
);
547 clk
= ERR_CAST(opp_table
);
551 clk
= opp_table
->clk
;
553 dev_err(dev
, "%s: No clock available for the device\n",
561 static int _set_opp_voltage(struct device
*dev
, struct regulator
*reg
,
562 unsigned long u_volt
, unsigned long u_volt_min
,
563 unsigned long u_volt_max
)
567 /* Regulator not available for device */
569 dev_dbg(dev
, "%s: regulator not available: %ld\n", __func__
,
574 dev_dbg(dev
, "%s: voltages (mV): %lu %lu %lu\n", __func__
, u_volt_min
,
577 ret
= regulator_set_voltage_triplet(reg
, u_volt_min
, u_volt
,
580 dev_err(dev
, "%s: failed to set voltage (%lu %lu %lu mV): %d\n",
581 __func__
, u_volt_min
, u_volt
, u_volt_max
, ret
);
587 * dev_pm_opp_set_rate() - Configure new OPP based on frequency
588 * @dev: device for which we do this operation
589 * @target_freq: frequency to achieve
591 * This configures the power-supplies and clock source to the levels specified
592 * by the OPP corresponding to the target_freq.
594 * Locking: This function takes rcu_read_lock().
596 int dev_pm_opp_set_rate(struct device
*dev
, unsigned long target_freq
)
598 struct opp_table
*opp_table
;
599 struct dev_pm_opp
*old_opp
, *opp
;
600 struct regulator
*reg
;
602 unsigned long freq
, old_freq
;
603 unsigned long u_volt
, u_volt_min
, u_volt_max
;
604 unsigned long ou_volt
, ou_volt_min
, ou_volt_max
;
607 if (unlikely(!target_freq
)) {
608 dev_err(dev
, "%s: Invalid target frequency %lu\n", __func__
,
613 clk
= _get_opp_clk(dev
);
617 freq
= clk_round_rate(clk
, target_freq
);
621 old_freq
= clk_get_rate(clk
);
623 /* Return early if nothing to do */
624 if (old_freq
== freq
) {
625 dev_dbg(dev
, "%s: old/new frequencies (%lu Hz) are same, nothing to do\n",
632 opp_table
= _find_opp_table(dev
);
633 if (IS_ERR(opp_table
)) {
634 dev_err(dev
, "%s: device opp doesn't exist\n", __func__
);
636 return PTR_ERR(opp_table
);
639 old_opp
= dev_pm_opp_find_freq_ceil(dev
, &old_freq
);
640 if (!IS_ERR(old_opp
)) {
641 ou_volt
= old_opp
->u_volt
;
642 ou_volt_min
= old_opp
->u_volt_min
;
643 ou_volt_max
= old_opp
->u_volt_max
;
645 dev_err(dev
, "%s: failed to find current OPP for freq %lu (%ld)\n",
646 __func__
, old_freq
, PTR_ERR(old_opp
));
649 opp
= dev_pm_opp_find_freq_ceil(dev
, &freq
);
652 dev_err(dev
, "%s: failed to find OPP for freq %lu (%d)\n",
653 __func__
, freq
, ret
);
658 u_volt
= opp
->u_volt
;
659 u_volt_min
= opp
->u_volt_min
;
660 u_volt_max
= opp
->u_volt_max
;
662 reg
= opp_table
->regulator
;
666 /* Scaling up? Scale voltage before frequency */
667 if (freq
> old_freq
) {
668 ret
= _set_opp_voltage(dev
, reg
, u_volt
, u_volt_min
,
671 goto restore_voltage
;
674 /* Change frequency */
676 dev_dbg(dev
, "%s: switching OPP: %lu Hz --> %lu Hz\n",
677 __func__
, old_freq
, freq
);
679 ret
= clk_set_rate(clk
, freq
);
681 dev_err(dev
, "%s: failed to set clock rate: %d\n", __func__
,
683 goto restore_voltage
;
686 /* Scaling down? Scale voltage after frequency */
687 if (freq
< old_freq
) {
688 ret
= _set_opp_voltage(dev
, reg
, u_volt
, u_volt_min
,
697 if (clk_set_rate(clk
, old_freq
))
698 dev_err(dev
, "%s: failed to restore old-freq (%lu Hz)\n",
701 /* This shouldn't harm even if the voltages weren't updated earlier */
702 if (!IS_ERR(old_opp
))
703 _set_opp_voltage(dev
, reg
, ou_volt
, ou_volt_min
, ou_volt_max
);
707 EXPORT_SYMBOL_GPL(dev_pm_opp_set_rate
);
709 /* OPP-dev Helpers */
710 static void _kfree_opp_dev_rcu(struct rcu_head
*head
)
712 struct opp_device
*opp_dev
;
714 opp_dev
= container_of(head
, struct opp_device
, rcu_head
);
715 kfree_rcu(opp_dev
, rcu_head
);
718 static void _remove_opp_dev(struct opp_device
*opp_dev
,
719 struct opp_table
*opp_table
)
721 opp_debug_unregister(opp_dev
, opp_table
);
722 list_del(&opp_dev
->node
);
723 call_srcu(&opp_table
->srcu_head
.srcu
, &opp_dev
->rcu_head
,
727 struct opp_device
*_add_opp_dev(const struct device
*dev
,
728 struct opp_table
*opp_table
)
730 struct opp_device
*opp_dev
;
733 opp_dev
= kzalloc(sizeof(*opp_dev
), GFP_KERNEL
);
737 /* Initialize opp-dev */
739 list_add_rcu(&opp_dev
->node
, &opp_table
->dev_list
);
741 /* Create debugfs entries for the opp_table */
742 ret
= opp_debug_register(opp_dev
, opp_table
);
744 dev_err(dev
, "%s: Failed to register opp debugfs (%d)\n",
751 * _add_opp_table() - Find OPP table or allocate a new one
752 * @dev: device for which we do this operation
754 * It tries to find an existing table first, if it couldn't find one, it
755 * allocates a new OPP table and returns that.
757 * Return: valid opp_table pointer if success, else NULL.
759 static struct opp_table
*_add_opp_table(struct device
*dev
)
761 struct opp_table
*opp_table
;
762 struct opp_device
*opp_dev
;
763 struct device_node
*np
;
766 /* Check for existing table for 'dev' first */
767 opp_table
= _find_opp_table(dev
);
768 if (!IS_ERR(opp_table
))
772 * Allocate a new OPP table. In the infrequent case where a new
773 * device is needed to be added, we pay this penalty.
775 opp_table
= kzalloc(sizeof(*opp_table
), GFP_KERNEL
);
779 INIT_LIST_HEAD(&opp_table
->dev_list
);
781 opp_dev
= _add_opp_dev(dev
, opp_table
);
788 * Only required for backward compatibility with v1 bindings, but isn't
789 * harmful for other cases. And so we do it unconditionally.
791 np
= of_node_get(dev
->of_node
);
795 if (!of_property_read_u32(np
, "clock-latency", &val
))
796 opp_table
->clock_latency_ns_max
= val
;
797 of_property_read_u32(np
, "voltage-tolerance",
798 &opp_table
->voltage_tolerance_v1
);
802 /* Set regulator to a non-NULL error value */
803 opp_table
->regulator
= ERR_PTR(-ENXIO
);
805 /* Find clk for the device */
806 opp_table
->clk
= clk_get(dev
, NULL
);
807 if (IS_ERR(opp_table
->clk
)) {
808 ret
= PTR_ERR(opp_table
->clk
);
809 if (ret
!= -EPROBE_DEFER
)
810 dev_dbg(dev
, "%s: Couldn't find clock: %d\n", __func__
,
814 srcu_init_notifier_head(&opp_table
->srcu_head
);
815 INIT_LIST_HEAD(&opp_table
->opp_list
);
817 /* Secure the device table modification */
818 list_add_rcu(&opp_table
->node
, &opp_tables
);
823 * _kfree_device_rcu() - Free opp_table RCU handler
826 static void _kfree_device_rcu(struct rcu_head
*head
)
828 struct opp_table
*opp_table
= container_of(head
, struct opp_table
,
831 kfree_rcu(opp_table
, rcu_head
);
835 * _remove_opp_table() - Removes a OPP table
836 * @opp_table: OPP table to be removed.
838 * Removes/frees OPP table if it doesn't contain any OPPs.
840 static void _remove_opp_table(struct opp_table
*opp_table
)
842 struct opp_device
*opp_dev
;
844 if (!list_empty(&opp_table
->opp_list
))
847 if (opp_table
->supported_hw
)
850 if (opp_table
->prop_name
)
853 if (!IS_ERR(opp_table
->regulator
))
857 if (!IS_ERR(opp_table
->clk
))
858 clk_put(opp_table
->clk
);
860 opp_dev
= list_first_entry(&opp_table
->dev_list
, struct opp_device
,
863 _remove_opp_dev(opp_dev
, opp_table
);
865 /* dev_list must be empty now */
866 WARN_ON(!list_empty(&opp_table
->dev_list
));
868 list_del_rcu(&opp_table
->node
);
869 call_srcu(&opp_table
->srcu_head
.srcu
, &opp_table
->rcu_head
,
874 * _kfree_opp_rcu() - Free OPP RCU handler
877 static void _kfree_opp_rcu(struct rcu_head
*head
)
879 struct dev_pm_opp
*opp
= container_of(head
, struct dev_pm_opp
, rcu_head
);
881 kfree_rcu(opp
, rcu_head
);
885 * _opp_remove() - Remove an OPP from a table definition
886 * @opp_table: points back to the opp_table struct this opp belongs to
887 * @opp: pointer to the OPP to remove
888 * @notify: OPP_EVENT_REMOVE notification should be sent or not
890 * This function removes an opp definition from the opp table.
892 * Locking: The internal opp_table and opp structures are RCU protected.
893 * It is assumed that the caller holds required mutex for an RCU updater
896 static void _opp_remove(struct opp_table
*opp_table
,
897 struct dev_pm_opp
*opp
, bool notify
)
900 * Notify the changes in the availability of the operable
901 * frequency/voltage list.
904 srcu_notifier_call_chain(&opp_table
->srcu_head
,
905 OPP_EVENT_REMOVE
, opp
);
906 opp_debug_remove_one(opp
);
907 list_del_rcu(&opp
->node
);
908 call_srcu(&opp_table
->srcu_head
.srcu
, &opp
->rcu_head
, _kfree_opp_rcu
);
910 _remove_opp_table(opp_table
);
914 * dev_pm_opp_remove() - Remove an OPP from OPP table
915 * @dev: device for which we do this operation
916 * @freq: OPP to remove with matching 'freq'
918 * This function removes an opp from the opp table.
920 * Locking: The internal opp_table and opp structures are RCU protected.
921 * Hence this function internally uses RCU updater strategy with mutex locks
922 * to keep the integrity of the internal data structures. Callers should ensure
923 * that this function is *NOT* called under RCU protection or in contexts where
924 * mutex cannot be locked.
926 void dev_pm_opp_remove(struct device
*dev
, unsigned long freq
)
928 struct dev_pm_opp
*opp
;
929 struct opp_table
*opp_table
;
932 /* Hold our table modification lock here */
933 mutex_lock(&opp_table_lock
);
935 opp_table
= _find_opp_table(dev
);
936 if (IS_ERR(opp_table
))
939 list_for_each_entry(opp
, &opp_table
->opp_list
, node
) {
940 if (opp
->rate
== freq
) {
947 dev_warn(dev
, "%s: Couldn't find OPP with freq: %lu\n",
952 _opp_remove(opp_table
, opp
, true);
954 mutex_unlock(&opp_table_lock
);
956 EXPORT_SYMBOL_GPL(dev_pm_opp_remove
);
958 static struct dev_pm_opp
*_allocate_opp(struct device
*dev
,
959 struct opp_table
**opp_table
)
961 struct dev_pm_opp
*opp
;
963 /* allocate new OPP node */
964 opp
= kzalloc(sizeof(*opp
), GFP_KERNEL
);
968 INIT_LIST_HEAD(&opp
->node
);
970 *opp_table
= _add_opp_table(dev
);
979 static bool _opp_supported_by_regulators(struct dev_pm_opp
*opp
,
980 struct opp_table
*opp_table
)
982 struct regulator
*reg
= opp_table
->regulator
;
985 !regulator_is_supported_voltage(reg
, opp
->u_volt_min
,
987 pr_warn("%s: OPP minuV: %lu maxuV: %lu, not supported by regulator\n",
988 __func__
, opp
->u_volt_min
, opp
->u_volt_max
);
995 static int _opp_add(struct device
*dev
, struct dev_pm_opp
*new_opp
,
996 struct opp_table
*opp_table
)
998 struct dev_pm_opp
*opp
;
999 struct list_head
*head
= &opp_table
->opp_list
;
1003 * Insert new OPP in order of increasing frequency and discard if
1006 * Need to use &opp_table->opp_list in the condition part of the 'for'
1007 * loop, don't replace it with head otherwise it will become an infinite
1010 list_for_each_entry_rcu(opp
, &opp_table
->opp_list
, node
) {
1011 if (new_opp
->rate
> opp
->rate
) {
1016 if (new_opp
->rate
< opp
->rate
)
1019 /* Duplicate OPPs */
1020 dev_warn(dev
, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
1021 __func__
, opp
->rate
, opp
->u_volt
, opp
->available
,
1022 new_opp
->rate
, new_opp
->u_volt
, new_opp
->available
);
1024 return opp
->available
&& new_opp
->u_volt
== opp
->u_volt
?
1028 new_opp
->opp_table
= opp_table
;
1029 list_add_rcu(&new_opp
->node
, head
);
1031 ret
= opp_debug_create_one(new_opp
, opp_table
);
1033 dev_err(dev
, "%s: Failed to register opp to debugfs (%d)\n",
1036 if (!_opp_supported_by_regulators(new_opp
, opp_table
)) {
1037 new_opp
->available
= false;
1038 dev_warn(dev
, "%s: OPP not supported by regulators (%lu)\n",
1039 __func__
, new_opp
->rate
);
1046 * _opp_add_v1() - Allocate a OPP based on v1 bindings.
1047 * @dev: device for which we do this operation
1048 * @freq: Frequency in Hz for this OPP
1049 * @u_volt: Voltage in uVolts for this OPP
1050 * @dynamic: Dynamically added OPPs.
1052 * This function adds an opp definition to the opp table and returns status.
1053 * The opp is made available by default and it can be controlled using
1054 * dev_pm_opp_enable/disable functions and may be removed by dev_pm_opp_remove.
1056 * NOTE: "dynamic" parameter impacts OPPs added by the dev_pm_opp_of_add_table
1057 * and freed by dev_pm_opp_of_remove_table.
1059 * Locking: The internal opp_table and opp structures are RCU protected.
1060 * Hence this function internally uses RCU updater strategy with mutex locks
1061 * to keep the integrity of the internal data structures. Callers should ensure
1062 * that this function is *NOT* called under RCU protection or in contexts where
1063 * mutex cannot be locked.
1067 * Duplicate OPPs (both freq and volt are same) and opp->available
1068 * -EEXIST Freq are same and volt are different OR
1069 * Duplicate OPPs (both freq and volt are same) and !opp->available
1070 * -ENOMEM Memory allocation failure
1072 static int _opp_add_v1(struct device
*dev
, unsigned long freq
, long u_volt
,
1075 struct opp_table
*opp_table
;
1076 struct dev_pm_opp
*new_opp
;
1080 /* Hold our table modification lock here */
1081 mutex_lock(&opp_table_lock
);
1083 new_opp
= _allocate_opp(dev
, &opp_table
);
1089 /* populate the opp table */
1090 new_opp
->rate
= freq
;
1091 tol
= u_volt
* opp_table
->voltage_tolerance_v1
/ 100;
1092 new_opp
->u_volt
= u_volt
;
1093 new_opp
->u_volt_min
= u_volt
- tol
;
1094 new_opp
->u_volt_max
= u_volt
+ tol
;
1095 new_opp
->available
= true;
1096 new_opp
->dynamic
= dynamic
;
1098 ret
= _opp_add(dev
, new_opp
, opp_table
);
1102 mutex_unlock(&opp_table_lock
);
1105 * Notify the changes in the availability of the operable
1106 * frequency/voltage list.
1108 srcu_notifier_call_chain(&opp_table
->srcu_head
, OPP_EVENT_ADD
, new_opp
);
1112 _opp_remove(opp_table
, new_opp
, false);
1114 mutex_unlock(&opp_table_lock
);
1118 /* TODO: Support multiple regulators */
1119 static int opp_parse_supplies(struct dev_pm_opp
*opp
, struct device
*dev
,
1120 struct opp_table
*opp_table
)
1122 u32 microvolt
[3] = {0};
1125 struct property
*prop
= NULL
;
1126 char name
[NAME_MAX
];
1128 /* Search for "opp-microvolt-<name>" */
1129 if (opp_table
->prop_name
) {
1130 snprintf(name
, sizeof(name
), "opp-microvolt-%s",
1131 opp_table
->prop_name
);
1132 prop
= of_find_property(opp
->np
, name
, NULL
);
1136 /* Search for "opp-microvolt" */
1137 sprintf(name
, "opp-microvolt");
1138 prop
= of_find_property(opp
->np
, name
, NULL
);
1140 /* Missing property isn't a problem, but an invalid entry is */
1145 count
= of_property_count_u32_elems(opp
->np
, name
);
1147 dev_err(dev
, "%s: Invalid %s property (%d)\n",
1148 __func__
, name
, count
);
1152 /* There can be one or three elements here */
1153 if (count
!= 1 && count
!= 3) {
1154 dev_err(dev
, "%s: Invalid number of elements in %s property (%d)\n",
1155 __func__
, name
, count
);
1159 ret
= of_property_read_u32_array(opp
->np
, name
, microvolt
, count
);
1161 dev_err(dev
, "%s: error parsing %s: %d\n", __func__
, name
, ret
);
1165 opp
->u_volt
= microvolt
[0];
1168 opp
->u_volt_min
= opp
->u_volt
;
1169 opp
->u_volt_max
= opp
->u_volt
;
1171 opp
->u_volt_min
= microvolt
[1];
1172 opp
->u_volt_max
= microvolt
[2];
1175 /* Search for "opp-microamp-<name>" */
1177 if (opp_table
->prop_name
) {
1178 snprintf(name
, sizeof(name
), "opp-microamp-%s",
1179 opp_table
->prop_name
);
1180 prop
= of_find_property(opp
->np
, name
, NULL
);
1184 /* Search for "opp-microamp" */
1185 sprintf(name
, "opp-microamp");
1186 prop
= of_find_property(opp
->np
, name
, NULL
);
1189 if (prop
&& !of_property_read_u32(opp
->np
, name
, &val
))
1196 * dev_pm_opp_set_supported_hw() - Set supported platforms
1197 * @dev: Device for which supported-hw has to be set.
1198 * @versions: Array of hierarchy of versions to match.
1199 * @count: Number of elements in the array.
1201 * This is required only for the V2 bindings, and it enables a platform to
1202 * specify the hierarchy of versions it supports. OPP layer will then enable
1203 * OPPs, which are available for those versions, based on its 'opp-supported-hw'
1206 * Locking: The internal opp_table and opp structures are RCU protected.
1207 * Hence this function internally uses RCU updater strategy with mutex locks
1208 * to keep the integrity of the internal data structures. Callers should ensure
1209 * that this function is *NOT* called under RCU protection or in contexts where
1210 * mutex cannot be locked.
1212 int dev_pm_opp_set_supported_hw(struct device
*dev
, const u32
*versions
,
1215 struct opp_table
*opp_table
;
1218 /* Hold our table modification lock here */
1219 mutex_lock(&opp_table_lock
);
1221 opp_table
= _add_opp_table(dev
);
1227 /* Make sure there are no concurrent readers while updating opp_table */
1228 WARN_ON(!list_empty(&opp_table
->opp_list
));
1230 /* Do we already have a version hierarchy associated with opp_table? */
1231 if (opp_table
->supported_hw
) {
1232 dev_err(dev
, "%s: Already have supported hardware list\n",
1238 opp_table
->supported_hw
= kmemdup(versions
, count
* sizeof(*versions
),
1240 if (!opp_table
->supported_hw
) {
1245 opp_table
->supported_hw_count
= count
;
1246 mutex_unlock(&opp_table_lock
);
1250 _remove_opp_table(opp_table
);
1252 mutex_unlock(&opp_table_lock
);
1256 EXPORT_SYMBOL_GPL(dev_pm_opp_set_supported_hw
);
1259 * dev_pm_opp_put_supported_hw() - Releases resources blocked for supported hw
1260 * @dev: Device for which supported-hw has to be put.
1262 * This is required only for the V2 bindings, and is called for a matching
1263 * dev_pm_opp_set_supported_hw(). Until this is called, the opp_table structure
1264 * will not be freed.
1266 * Locking: The internal opp_table and opp structures are RCU protected.
1267 * Hence this function internally uses RCU updater strategy with mutex locks
1268 * to keep the integrity of the internal data structures. Callers should ensure
1269 * that this function is *NOT* called under RCU protection or in contexts where
1270 * mutex cannot be locked.
1272 void dev_pm_opp_put_supported_hw(struct device
*dev
)
1274 struct opp_table
*opp_table
;
1276 /* Hold our table modification lock here */
1277 mutex_lock(&opp_table_lock
);
1279 /* Check for existing table for 'dev' first */
1280 opp_table
= _find_opp_table(dev
);
1281 if (IS_ERR(opp_table
)) {
1282 dev_err(dev
, "Failed to find opp_table: %ld\n",
1283 PTR_ERR(opp_table
));
1287 /* Make sure there are no concurrent readers while updating opp_table */
1288 WARN_ON(!list_empty(&opp_table
->opp_list
));
1290 if (!opp_table
->supported_hw
) {
1291 dev_err(dev
, "%s: Doesn't have supported hardware list\n",
1296 kfree(opp_table
->supported_hw
);
1297 opp_table
->supported_hw
= NULL
;
1298 opp_table
->supported_hw_count
= 0;
1300 /* Try freeing opp_table if this was the last blocking resource */
1301 _remove_opp_table(opp_table
);
1304 mutex_unlock(&opp_table_lock
);
1306 EXPORT_SYMBOL_GPL(dev_pm_opp_put_supported_hw
);
1309 * dev_pm_opp_set_prop_name() - Set prop-extn name
1310 * @dev: Device for which the prop-name has to be set.
1311 * @name: name to postfix to properties.
1313 * This is required only for the V2 bindings, and it enables a platform to
1314 * specify the extn to be used for certain property names. The properties to
1315 * which the extension will apply are opp-microvolt and opp-microamp. OPP core
1316 * should postfix the property name with -<name> while looking for them.
1318 * Locking: The internal opp_table and opp structures are RCU protected.
1319 * Hence this function internally uses RCU updater strategy with mutex locks
1320 * to keep the integrity of the internal data structures. Callers should ensure
1321 * that this function is *NOT* called under RCU protection or in contexts where
1322 * mutex cannot be locked.
1324 int dev_pm_opp_set_prop_name(struct device
*dev
, const char *name
)
1326 struct opp_table
*opp_table
;
1329 /* Hold our table modification lock here */
1330 mutex_lock(&opp_table_lock
);
1332 opp_table
= _add_opp_table(dev
);
1338 /* Make sure there are no concurrent readers while updating opp_table */
1339 WARN_ON(!list_empty(&opp_table
->opp_list
));
1341 /* Do we already have a prop-name associated with opp_table? */
1342 if (opp_table
->prop_name
) {
1343 dev_err(dev
, "%s: Already have prop-name %s\n", __func__
,
1344 opp_table
->prop_name
);
1349 opp_table
->prop_name
= kstrdup(name
, GFP_KERNEL
);
1350 if (!opp_table
->prop_name
) {
1355 mutex_unlock(&opp_table_lock
);
1359 _remove_opp_table(opp_table
);
1361 mutex_unlock(&opp_table_lock
);
1365 EXPORT_SYMBOL_GPL(dev_pm_opp_set_prop_name
);
1368 * dev_pm_opp_put_prop_name() - Releases resources blocked for prop-name
1369 * @dev: Device for which the prop-name has to be put.
1371 * This is required only for the V2 bindings, and is called for a matching
1372 * dev_pm_opp_set_prop_name(). Until this is called, the opp_table structure
1373 * will not be freed.
1375 * Locking: The internal opp_table and opp structures are RCU protected.
1376 * Hence this function internally uses RCU updater strategy with mutex locks
1377 * to keep the integrity of the internal data structures. Callers should ensure
1378 * that this function is *NOT* called under RCU protection or in contexts where
1379 * mutex cannot be locked.
1381 void dev_pm_opp_put_prop_name(struct device
*dev
)
1383 struct opp_table
*opp_table
;
1385 /* Hold our table modification lock here */
1386 mutex_lock(&opp_table_lock
);
1388 /* Check for existing table for 'dev' first */
1389 opp_table
= _find_opp_table(dev
);
1390 if (IS_ERR(opp_table
)) {
1391 dev_err(dev
, "Failed to find opp_table: %ld\n",
1392 PTR_ERR(opp_table
));
1396 /* Make sure there are no concurrent readers while updating opp_table */
1397 WARN_ON(!list_empty(&opp_table
->opp_list
));
1399 if (!opp_table
->prop_name
) {
1400 dev_err(dev
, "%s: Doesn't have a prop-name\n", __func__
);
1404 kfree(opp_table
->prop_name
);
1405 opp_table
->prop_name
= NULL
;
1407 /* Try freeing opp_table if this was the last blocking resource */
1408 _remove_opp_table(opp_table
);
1411 mutex_unlock(&opp_table_lock
);
1413 EXPORT_SYMBOL_GPL(dev_pm_opp_put_prop_name
);
1416 * dev_pm_opp_set_regulator() - Set regulator name for the device
1417 * @dev: Device for which regulator name is being set.
1418 * @name: Name of the regulator.
1420 * In order to support OPP switching, OPP layer needs to know the name of the
1421 * device's regulator, as the core would be required to switch voltages as well.
1423 * This must be called before any OPPs are initialized for the device.
1425 * Locking: The internal opp_table and opp structures are RCU protected.
1426 * Hence this function internally uses RCU updater strategy with mutex locks
1427 * to keep the integrity of the internal data structures. Callers should ensure
1428 * that this function is *NOT* called under RCU protection or in contexts where
1429 * mutex cannot be locked.
1431 int dev_pm_opp_set_regulator(struct device
*dev
, const char *name
)
1433 struct opp_table
*opp_table
;
1434 struct regulator
*reg
;
1437 mutex_lock(&opp_table_lock
);
1439 opp_table
= _add_opp_table(dev
);
1445 /* This should be called before OPPs are initialized */
1446 if (WARN_ON(!list_empty(&opp_table
->opp_list
))) {
1451 /* Already have a regulator set */
1452 if (WARN_ON(!IS_ERR(opp_table
->regulator
))) {
1456 /* Allocate the regulator */
1457 reg
= regulator_get_optional(dev
, name
);
1460 if (ret
!= -EPROBE_DEFER
)
1461 dev_err(dev
, "%s: no regulator (%s) found: %d\n",
1462 __func__
, name
, ret
);
1466 opp_table
->regulator
= reg
;
1468 mutex_unlock(&opp_table_lock
);
1472 _remove_opp_table(opp_table
);
1474 mutex_unlock(&opp_table_lock
);
1478 EXPORT_SYMBOL_GPL(dev_pm_opp_set_regulator
);
1481 * dev_pm_opp_put_regulator() - Releases resources blocked for regulator
1482 * @dev: Device for which regulator was set.
1484 * Locking: The internal opp_table and opp structures are RCU protected.
1485 * Hence this function internally uses RCU updater strategy with mutex locks
1486 * to keep the integrity of the internal data structures. Callers should ensure
1487 * that this function is *NOT* called under RCU protection or in contexts where
1488 * mutex cannot be locked.
1490 void dev_pm_opp_put_regulator(struct device
*dev
)
1492 struct opp_table
*opp_table
;
1494 mutex_lock(&opp_table_lock
);
1496 /* Check for existing table for 'dev' first */
1497 opp_table
= _find_opp_table(dev
);
1498 if (IS_ERR(opp_table
)) {
1499 dev_err(dev
, "Failed to find opp_table: %ld\n",
1500 PTR_ERR(opp_table
));
1504 if (IS_ERR(opp_table
->regulator
)) {
1505 dev_err(dev
, "%s: Doesn't have regulator set\n", __func__
);
1509 /* Make sure there are no concurrent readers while updating opp_table */
1510 WARN_ON(!list_empty(&opp_table
->opp_list
));
1512 regulator_put(opp_table
->regulator
);
1513 opp_table
->regulator
= ERR_PTR(-ENXIO
);
1515 /* Try freeing opp_table if this was the last blocking resource */
1516 _remove_opp_table(opp_table
);
1519 mutex_unlock(&opp_table_lock
);
1521 EXPORT_SYMBOL_GPL(dev_pm_opp_put_regulator
);
1523 static bool _opp_is_supported(struct device
*dev
, struct opp_table
*opp_table
,
1524 struct device_node
*np
)
1526 unsigned int count
= opp_table
->supported_hw_count
;
1530 if (!opp_table
->supported_hw
)
1534 ret
= of_property_read_u32_index(np
, "opp-supported-hw", count
,
1537 dev_warn(dev
, "%s: failed to read opp-supported-hw property at index %d: %d\n",
1538 __func__
, count
, ret
);
1542 /* Both of these are bitwise masks of the versions */
1543 if (!(version
& opp_table
->supported_hw
[count
]))
1551 * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)
1552 * @dev: device for which we do this operation
1555 * This function adds an opp definition to the opp table and returns status. The
1556 * opp can be controlled using dev_pm_opp_enable/disable functions and may be
1557 * removed by dev_pm_opp_remove.
1559 * Locking: The internal opp_table and opp structures are RCU protected.
1560 * Hence this function internally uses RCU updater strategy with mutex locks
1561 * to keep the integrity of the internal data structures. Callers should ensure
1562 * that this function is *NOT* called under RCU protection or in contexts where
1563 * mutex cannot be locked.
1567 * Duplicate OPPs (both freq and volt are same) and opp->available
1568 * -EEXIST Freq are same and volt are different OR
1569 * Duplicate OPPs (both freq and volt are same) and !opp->available
1570 * -ENOMEM Memory allocation failure
1571 * -EINVAL Failed parsing the OPP node
1573 static int _opp_add_static_v2(struct device
*dev
, struct device_node
*np
)
1575 struct opp_table
*opp_table
;
1576 struct dev_pm_opp
*new_opp
;
1581 /* Hold our table modification lock here */
1582 mutex_lock(&opp_table_lock
);
1584 new_opp
= _allocate_opp(dev
, &opp_table
);
1590 ret
= of_property_read_u64(np
, "opp-hz", &rate
);
1592 dev_err(dev
, "%s: opp-hz not found\n", __func__
);
1596 /* Check if the OPP supports hardware's hierarchy of versions or not */
1597 if (!_opp_is_supported(dev
, opp_table
, np
)) {
1598 dev_dbg(dev
, "OPP not supported by hardware: %llu\n", rate
);
1603 * Rate is defined as an unsigned long in clk API, and so casting
1604 * explicitly to its type. Must be fixed once rate is 64 bit
1605 * guaranteed in clk API.
1607 new_opp
->rate
= (unsigned long)rate
;
1608 new_opp
->turbo
= of_property_read_bool(np
, "turbo-mode");
1611 new_opp
->dynamic
= false;
1612 new_opp
->available
= true;
1614 if (!of_property_read_u32(np
, "clock-latency-ns", &val
))
1615 new_opp
->clock_latency_ns
= val
;
1617 ret
= opp_parse_supplies(new_opp
, dev
, opp_table
);
1621 ret
= _opp_add(dev
, new_opp
, opp_table
);
1625 /* OPP to select on device suspend */
1626 if (of_property_read_bool(np
, "opp-suspend")) {
1627 if (opp_table
->suspend_opp
) {
1628 dev_warn(dev
, "%s: Multiple suspend OPPs found (%lu %lu)\n",
1629 __func__
, opp_table
->suspend_opp
->rate
,
1632 new_opp
->suspend
= true;
1633 opp_table
->suspend_opp
= new_opp
;
1637 if (new_opp
->clock_latency_ns
> opp_table
->clock_latency_ns_max
)
1638 opp_table
->clock_latency_ns_max
= new_opp
->clock_latency_ns
;
1640 mutex_unlock(&opp_table_lock
);
1642 pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu\n",
1643 __func__
, new_opp
->turbo
, new_opp
->rate
, new_opp
->u_volt
,
1644 new_opp
->u_volt_min
, new_opp
->u_volt_max
,
1645 new_opp
->clock_latency_ns
);
1648 * Notify the changes in the availability of the operable
1649 * frequency/voltage list.
1651 srcu_notifier_call_chain(&opp_table
->srcu_head
, OPP_EVENT_ADD
, new_opp
);
1655 _opp_remove(opp_table
, new_opp
, false);
1657 mutex_unlock(&opp_table_lock
);
1662 * dev_pm_opp_add() - Add an OPP table from a table definitions
1663 * @dev: device for which we do this operation
1664 * @freq: Frequency in Hz for this OPP
1665 * @u_volt: Voltage in uVolts for this OPP
1667 * This function adds an opp definition to the opp table and returns status.
1668 * The opp is made available by default and it can be controlled using
1669 * dev_pm_opp_enable/disable functions.
1671 * Locking: The internal opp_table and opp structures are RCU protected.
1672 * Hence this function internally uses RCU updater strategy with mutex locks
1673 * to keep the integrity of the internal data structures. Callers should ensure
1674 * that this function is *NOT* called under RCU protection or in contexts where
1675 * mutex cannot be locked.
1679 * Duplicate OPPs (both freq and volt are same) and opp->available
1680 * -EEXIST Freq are same and volt are different OR
1681 * Duplicate OPPs (both freq and volt are same) and !opp->available
1682 * -ENOMEM Memory allocation failure
1684 int dev_pm_opp_add(struct device
*dev
, unsigned long freq
, unsigned long u_volt
)
1686 return _opp_add_v1(dev
, freq
, u_volt
, true);
1688 EXPORT_SYMBOL_GPL(dev_pm_opp_add
);
1691 * _opp_set_availability() - helper to set the availability of an opp
1692 * @dev: device for which we do this operation
1693 * @freq: OPP frequency to modify availability
1694 * @availability_req: availability status requested for this opp
1696 * Set the availability of an OPP with an RCU operation, opp_{enable,disable}
1697 * share a common logic which is isolated here.
1699 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1700 * copy operation, returns 0 if no modification was done OR modification was
1703 * Locking: The internal opp_table and opp structures are RCU protected.
1704 * Hence this function internally uses RCU updater strategy with mutex locks to
1705 * keep the integrity of the internal data structures. Callers should ensure
1706 * that this function is *NOT* called under RCU protection or in contexts where
1707 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1709 static int _opp_set_availability(struct device
*dev
, unsigned long freq
,
1710 bool availability_req
)
1712 struct opp_table
*opp_table
;
1713 struct dev_pm_opp
*new_opp
, *tmp_opp
, *opp
= ERR_PTR(-ENODEV
);
1716 /* keep the node allocated */
1717 new_opp
= kmalloc(sizeof(*new_opp
), GFP_KERNEL
);
1721 mutex_lock(&opp_table_lock
);
1723 /* Find the opp_table */
1724 opp_table
= _find_opp_table(dev
);
1725 if (IS_ERR(opp_table
)) {
1726 r
= PTR_ERR(opp_table
);
1727 dev_warn(dev
, "%s: Device OPP not found (%d)\n", __func__
, r
);
1731 /* Do we have the frequency? */
1732 list_for_each_entry(tmp_opp
, &opp_table
->opp_list
, node
) {
1733 if (tmp_opp
->rate
== freq
) {
1743 /* Is update really needed? */
1744 if (opp
->available
== availability_req
)
1746 /* copy the old data over */
1749 /* plug in new node */
1750 new_opp
->available
= availability_req
;
1752 list_replace_rcu(&opp
->node
, &new_opp
->node
);
1753 mutex_unlock(&opp_table_lock
);
1754 call_srcu(&opp_table
->srcu_head
.srcu
, &opp
->rcu_head
, _kfree_opp_rcu
);
1756 /* Notify the change of the OPP availability */
1757 if (availability_req
)
1758 srcu_notifier_call_chain(&opp_table
->srcu_head
,
1759 OPP_EVENT_ENABLE
, new_opp
);
1761 srcu_notifier_call_chain(&opp_table
->srcu_head
,
1762 OPP_EVENT_DISABLE
, new_opp
);
1767 mutex_unlock(&opp_table_lock
);
1773 * dev_pm_opp_enable() - Enable a specific OPP
1774 * @dev: device for which we do this operation
1775 * @freq: OPP frequency to enable
1777 * Enables a provided opp. If the operation is valid, this returns 0, else the
1778 * corresponding error value. It is meant to be used for users an OPP available
1779 * after being temporarily made unavailable with dev_pm_opp_disable.
1781 * Locking: The internal opp_table and opp structures are RCU protected.
1782 * Hence this function indirectly uses RCU and mutex locks to keep the
1783 * integrity of the internal data structures. Callers should ensure that
1784 * this function is *NOT* called under RCU protection or in contexts where
1785 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1787 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1788 * copy operation, returns 0 if no modification was done OR modification was
1791 int dev_pm_opp_enable(struct device
*dev
, unsigned long freq
)
1793 return _opp_set_availability(dev
, freq
, true);
1795 EXPORT_SYMBOL_GPL(dev_pm_opp_enable
);
1798 * dev_pm_opp_disable() - Disable a specific OPP
1799 * @dev: device for which we do this operation
1800 * @freq: OPP frequency to disable
1802 * Disables a provided opp. If the operation is valid, this returns
1803 * 0, else the corresponding error value. It is meant to be a temporary
1804 * control by users to make this OPP not available until the circumstances are
1805 * right to make it available again (with a call to dev_pm_opp_enable).
1807 * Locking: The internal opp_table and opp structures are RCU protected.
1808 * Hence this function indirectly uses RCU and mutex locks to keep the
1809 * integrity of the internal data structures. Callers should ensure that
1810 * this function is *NOT* called under RCU protection or in contexts where
1811 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1813 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1814 * copy operation, returns 0 if no modification was done OR modification was
1817 int dev_pm_opp_disable(struct device
*dev
, unsigned long freq
)
1819 return _opp_set_availability(dev
, freq
, false);
1821 EXPORT_SYMBOL_GPL(dev_pm_opp_disable
);
1824 * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
1825 * @dev: device pointer used to lookup OPP table.
1827 * Return: pointer to notifier head if found, otherwise -ENODEV or
1828 * -EINVAL based on type of error casted as pointer. value must be checked
1829 * with IS_ERR to determine valid pointer or error result.
1831 * Locking: This function must be called under rcu_read_lock(). opp_table is a
1832 * RCU protected pointer. The reason for the same is that the opp pointer which
1833 * is returned will remain valid for use with opp_get_{voltage, freq} only while
1834 * under the locked area. The pointer returned must be used prior to unlocking
1835 * with rcu_read_unlock() to maintain the integrity of the pointer.
1837 struct srcu_notifier_head
*dev_pm_opp_get_notifier(struct device
*dev
)
1839 struct opp_table
*opp_table
= _find_opp_table(dev
);
1841 if (IS_ERR(opp_table
))
1842 return ERR_CAST(opp_table
); /* matching type */
1844 return &opp_table
->srcu_head
;
1846 EXPORT_SYMBOL_GPL(dev_pm_opp_get_notifier
);
1850 * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT
1852 * @dev: device pointer used to lookup OPP table.
1854 * Free OPPs created using static entries present in DT.
1856 * Locking: The internal opp_table and opp structures are RCU protected.
1857 * Hence this function indirectly uses RCU updater strategy with mutex locks
1858 * to keep the integrity of the internal data structures. Callers should ensure
1859 * that this function is *NOT* called under RCU protection or in contexts where
1860 * mutex cannot be locked.
1862 void dev_pm_opp_of_remove_table(struct device
*dev
)
1864 struct opp_table
*opp_table
;
1865 struct dev_pm_opp
*opp
, *tmp
;
1867 /* Hold our table modification lock here */
1868 mutex_lock(&opp_table_lock
);
1870 /* Check for existing table for 'dev' */
1871 opp_table
= _find_opp_table(dev
);
1872 if (IS_ERR(opp_table
)) {
1873 int error
= PTR_ERR(opp_table
);
1875 if (error
!= -ENODEV
)
1876 WARN(1, "%s: opp_table: %d\n",
1877 IS_ERR_OR_NULL(dev
) ?
1878 "Invalid device" : dev_name(dev
),
1883 /* Find if opp_table manages a single device */
1884 if (list_is_singular(&opp_table
->dev_list
)) {
1885 /* Free static OPPs */
1886 list_for_each_entry_safe(opp
, tmp
, &opp_table
->opp_list
, node
) {
1888 _opp_remove(opp_table
, opp
, true);
1891 _remove_opp_dev(_find_opp_dev(dev
, opp_table
), opp_table
);
1895 mutex_unlock(&opp_table_lock
);
1897 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table
);
1899 /* Returns opp descriptor node for a device, caller must do of_node_put() */
1900 struct device_node
*_of_get_opp_desc_node(struct device
*dev
)
1903 * TODO: Support for multiple OPP tables.
1905 * There should be only ONE phandle present in "operating-points-v2"
1909 return of_parse_phandle(dev
->of_node
, "operating-points-v2", 0);
1912 /* Initializes OPP tables based on new bindings */
1913 static int _of_add_opp_table_v2(struct device
*dev
, struct device_node
*opp_np
)
1915 struct device_node
*np
;
1916 struct opp_table
*opp_table
;
1917 int ret
= 0, count
= 0;
1919 mutex_lock(&opp_table_lock
);
1921 opp_table
= _managed_opp(opp_np
);
1923 /* OPPs are already managed */
1924 if (!_add_opp_dev(dev
, opp_table
))
1926 mutex_unlock(&opp_table_lock
);
1929 mutex_unlock(&opp_table_lock
);
1931 /* We have opp-table node now, iterate over it and add OPPs */
1932 for_each_available_child_of_node(opp_np
, np
) {
1935 ret
= _opp_add_static_v2(dev
, np
);
1937 dev_err(dev
, "%s: Failed to add OPP, %d\n", __func__
,
1943 /* There should be one of more OPP defined */
1944 if (WARN_ON(!count
))
1947 mutex_lock(&opp_table_lock
);
1949 opp_table
= _find_opp_table(dev
);
1950 if (WARN_ON(IS_ERR(opp_table
))) {
1951 ret
= PTR_ERR(opp_table
);
1952 mutex_unlock(&opp_table_lock
);
1956 opp_table
->np
= opp_np
;
1957 opp_table
->shared_opp
= of_property_read_bool(opp_np
, "opp-shared");
1959 mutex_unlock(&opp_table_lock
);
1964 dev_pm_opp_of_remove_table(dev
);
1969 /* Initializes OPP tables based on old-deprecated bindings */
1970 static int _of_add_opp_table_v1(struct device
*dev
)
1972 const struct property
*prop
;
1976 prop
= of_find_property(dev
->of_node
, "operating-points", NULL
);
1983 * Each OPP is a set of tuples consisting of frequency and
1984 * voltage like <freq-kHz vol-uV>.
1986 nr
= prop
->length
/ sizeof(u32
);
1988 dev_err(dev
, "%s: Invalid OPP table\n", __func__
);
1994 unsigned long freq
= be32_to_cpup(val
++) * 1000;
1995 unsigned long volt
= be32_to_cpup(val
++);
1997 if (_opp_add_v1(dev
, freq
, volt
, false))
1998 dev_warn(dev
, "%s: Failed to add OPP %ld\n",
2007 * dev_pm_opp_of_add_table() - Initialize opp table from device tree
2008 * @dev: device pointer used to lookup OPP table.
2010 * Register the initial OPP table with the OPP library for given device.
2012 * Locking: The internal opp_table and opp structures are RCU protected.
2013 * Hence this function indirectly uses RCU updater strategy with mutex locks
2014 * to keep the integrity of the internal data structures. Callers should ensure
2015 * that this function is *NOT* called under RCU protection or in contexts where
2016 * mutex cannot be locked.
2020 * Duplicate OPPs (both freq and volt are same) and opp->available
2021 * -EEXIST Freq are same and volt are different OR
2022 * Duplicate OPPs (both freq and volt are same) and !opp->available
2023 * -ENOMEM Memory allocation failure
2024 * -ENODEV when 'operating-points' property is not found or is invalid data
2026 * -ENODATA when empty 'operating-points' property is found
2027 * -EINVAL when invalid entries are found in opp-v2 table
2029 int dev_pm_opp_of_add_table(struct device
*dev
)
2031 struct device_node
*opp_np
;
2035 * OPPs have two version of bindings now. The older one is deprecated,
2036 * try for the new binding first.
2038 opp_np
= _of_get_opp_desc_node(dev
);
2041 * Try old-deprecated bindings for backward compatibility with
2044 return _of_add_opp_table_v1(dev
);
2047 ret
= _of_add_opp_table_v2(dev
, opp_np
);
2048 of_node_put(opp_np
);
2052 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table
);