1 // SPDX-License-Identifier: GPL-2.0-only
3 * Generic OPP Interface
5 * Copyright (C) 2009-2010 Texas Instruments Incorporated.
11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13 #include <linux/clk.h>
14 #include <linux/errno.h>
15 #include <linux/err.h>
16 #include <linux/slab.h>
17 #include <linux/device.h>
18 #include <linux/export.h>
19 #include <linux/pm_domain.h>
20 #include <linux/regulator/consumer.h>
25 * The root of the list of all opp-tables. All opp_table structures branch off
26 * from here, with each opp_table containing the list of opps it supports in
27 * various states of availability.
29 LIST_HEAD(opp_tables
);
30 /* Lock to allow exclusive modification to the device and opp lists */
31 DEFINE_MUTEX(opp_table_lock
);
33 static struct opp_device
*_find_opp_dev(const struct device
*dev
,
34 struct opp_table
*opp_table
)
36 struct opp_device
*opp_dev
;
38 list_for_each_entry(opp_dev
, &opp_table
->dev_list
, node
)
39 if (opp_dev
->dev
== dev
)
45 static struct opp_table
*_find_opp_table_unlocked(struct device
*dev
)
47 struct opp_table
*opp_table
;
50 list_for_each_entry(opp_table
, &opp_tables
, node
) {
51 mutex_lock(&opp_table
->lock
);
52 found
= !!_find_opp_dev(dev
, opp_table
);
53 mutex_unlock(&opp_table
->lock
);
56 _get_opp_table_kref(opp_table
);
62 return ERR_PTR(-ENODEV
);
66 * _find_opp_table() - find opp_table struct using device pointer
67 * @dev: device pointer used to lookup OPP table
69 * Search OPP table for one containing matching device.
71 * Return: pointer to 'struct opp_table' if found, otherwise -ENODEV or
72 * -EINVAL based on type of error.
74 * The callers must call dev_pm_opp_put_opp_table() after the table is used.
76 struct opp_table
*_find_opp_table(struct device
*dev
)
78 struct opp_table
*opp_table
;
80 if (IS_ERR_OR_NULL(dev
)) {
81 pr_err("%s: Invalid parameters\n", __func__
);
82 return ERR_PTR(-EINVAL
);
85 mutex_lock(&opp_table_lock
);
86 opp_table
= _find_opp_table_unlocked(dev
);
87 mutex_unlock(&opp_table_lock
);
93 * dev_pm_opp_get_voltage() - Gets the voltage corresponding to an opp
94 * @opp: opp for which voltage has to be returned for
96 * Return: voltage in micro volt corresponding to the opp, else
99 * This is useful only for devices with single power supply.
101 unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp
*opp
)
103 if (IS_ERR_OR_NULL(opp
)) {
104 pr_err("%s: Invalid parameters\n", __func__
);
108 return opp
->supplies
[0].u_volt
;
110 EXPORT_SYMBOL_GPL(dev_pm_opp_get_voltage
);
113 * dev_pm_opp_get_freq() - Gets the frequency corresponding to an available opp
114 * @opp: opp for which frequency has to be returned for
116 * Return: frequency in hertz corresponding to the opp, else
119 unsigned long dev_pm_opp_get_freq(struct dev_pm_opp
*opp
)
121 if (IS_ERR_OR_NULL(opp
) || !opp
->available
) {
122 pr_err("%s: Invalid parameters\n", __func__
);
128 EXPORT_SYMBOL_GPL(dev_pm_opp_get_freq
);
131 * dev_pm_opp_get_level() - Gets the level corresponding to an available opp
132 * @opp: opp for which level value has to be returned for
134 * Return: level read from device tree corresponding to the opp, else
137 unsigned int dev_pm_opp_get_level(struct dev_pm_opp
*opp
)
139 if (IS_ERR_OR_NULL(opp
) || !opp
->available
) {
140 pr_err("%s: Invalid parameters\n", __func__
);
146 EXPORT_SYMBOL_GPL(dev_pm_opp_get_level
);
149 * dev_pm_opp_is_turbo() - Returns if opp is turbo OPP or not
150 * @opp: opp for which turbo mode is being verified
152 * Turbo OPPs are not for normal use, and can be enabled (under certain
153 * conditions) for short duration of times to finish high throughput work
154 * quickly. Running on them for longer times may overheat the chip.
156 * Return: true if opp is turbo opp, else false.
158 bool dev_pm_opp_is_turbo(struct dev_pm_opp
*opp
)
160 if (IS_ERR_OR_NULL(opp
) || !opp
->available
) {
161 pr_err("%s: Invalid parameters\n", __func__
);
167 EXPORT_SYMBOL_GPL(dev_pm_opp_is_turbo
);
170 * dev_pm_opp_get_max_clock_latency() - Get max clock latency in nanoseconds
171 * @dev: device for which we do this operation
173 * Return: This function returns the max clock latency in nanoseconds.
175 unsigned long dev_pm_opp_get_max_clock_latency(struct device
*dev
)
177 struct opp_table
*opp_table
;
178 unsigned long clock_latency_ns
;
180 opp_table
= _find_opp_table(dev
);
181 if (IS_ERR(opp_table
))
184 clock_latency_ns
= opp_table
->clock_latency_ns_max
;
186 dev_pm_opp_put_opp_table(opp_table
);
188 return clock_latency_ns
;
190 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_clock_latency
);
193 * dev_pm_opp_get_max_volt_latency() - Get max voltage latency in nanoseconds
194 * @dev: device for which we do this operation
196 * Return: This function returns the max voltage latency in nanoseconds.
198 unsigned long dev_pm_opp_get_max_volt_latency(struct device
*dev
)
200 struct opp_table
*opp_table
;
201 struct dev_pm_opp
*opp
;
202 struct regulator
*reg
;
203 unsigned long latency_ns
= 0;
210 opp_table
= _find_opp_table(dev
);
211 if (IS_ERR(opp_table
))
214 /* Regulator may not be required for the device */
215 if (!opp_table
->regulators
)
218 count
= opp_table
->regulator_count
;
220 uV
= kmalloc_array(count
, sizeof(*uV
), GFP_KERNEL
);
224 mutex_lock(&opp_table
->lock
);
226 for (i
= 0; i
< count
; i
++) {
230 list_for_each_entry(opp
, &opp_table
->opp_list
, node
) {
234 if (opp
->supplies
[i
].u_volt_min
< uV
[i
].min
)
235 uV
[i
].min
= opp
->supplies
[i
].u_volt_min
;
236 if (opp
->supplies
[i
].u_volt_max
> uV
[i
].max
)
237 uV
[i
].max
= opp
->supplies
[i
].u_volt_max
;
241 mutex_unlock(&opp_table
->lock
);
244 * The caller needs to ensure that opp_table (and hence the regulator)
245 * isn't freed, while we are executing this routine.
247 for (i
= 0; i
< count
; i
++) {
248 reg
= opp_table
->regulators
[i
];
249 ret
= regulator_set_voltage_time(reg
, uV
[i
].min
, uV
[i
].max
);
251 latency_ns
+= ret
* 1000;
256 dev_pm_opp_put_opp_table(opp_table
);
260 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_volt_latency
);
263 * dev_pm_opp_get_max_transition_latency() - Get max transition latency in
265 * @dev: device for which we do this operation
267 * Return: This function returns the max transition latency, in nanoseconds, to
268 * switch from one OPP to other.
270 unsigned long dev_pm_opp_get_max_transition_latency(struct device
*dev
)
272 return dev_pm_opp_get_max_volt_latency(dev
) +
273 dev_pm_opp_get_max_clock_latency(dev
);
275 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_transition_latency
);
278 * dev_pm_opp_get_suspend_opp_freq() - Get frequency of suspend opp in Hz
279 * @dev: device for which we do this operation
281 * Return: This function returns the frequency of the OPP marked as suspend_opp
282 * if one is available, else returns 0;
284 unsigned long dev_pm_opp_get_suspend_opp_freq(struct device
*dev
)
286 struct opp_table
*opp_table
;
287 unsigned long freq
= 0;
289 opp_table
= _find_opp_table(dev
);
290 if (IS_ERR(opp_table
))
293 if (opp_table
->suspend_opp
&& opp_table
->suspend_opp
->available
)
294 freq
= dev_pm_opp_get_freq(opp_table
->suspend_opp
);
296 dev_pm_opp_put_opp_table(opp_table
);
300 EXPORT_SYMBOL_GPL(dev_pm_opp_get_suspend_opp_freq
);
302 int _get_opp_count(struct opp_table
*opp_table
)
304 struct dev_pm_opp
*opp
;
307 mutex_lock(&opp_table
->lock
);
309 list_for_each_entry(opp
, &opp_table
->opp_list
, node
) {
314 mutex_unlock(&opp_table
->lock
);
320 * dev_pm_opp_get_opp_count() - Get number of opps available in the opp table
321 * @dev: device for which we do this operation
323 * Return: This function returns the number of available opps if there are any,
324 * else returns 0 if none or the corresponding error value.
326 int dev_pm_opp_get_opp_count(struct device
*dev
)
328 struct opp_table
*opp_table
;
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 count
= _get_opp_count(opp_table
);
340 dev_pm_opp_put_opp_table(opp_table
);
344 EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count
);
347 * dev_pm_opp_find_freq_exact() - search for an exact frequency
348 * @dev: device for which we do this operation
349 * @freq: frequency to search for
350 * @available: true/false - match for available opp
352 * Return: Searches for exact match in the opp table and returns pointer to the
353 * matching opp if found, else returns ERR_PTR in case of error and should
354 * be handled using IS_ERR. Error return values can be:
355 * EINVAL: for bad pointer
356 * ERANGE: no match found for search
357 * ENODEV: if device not found in list of registered devices
359 * Note: available is a modifier for the search. if available=true, then the
360 * match is for exact matching frequency and is available in the stored OPP
361 * table. if false, the match is for exact frequency which is not available.
363 * This provides a mechanism to enable an opp which is not available currently
364 * or the opposite as well.
366 * The callers are required to call dev_pm_opp_put() for the returned OPP after
369 struct dev_pm_opp
*dev_pm_opp_find_freq_exact(struct device
*dev
,
373 struct opp_table
*opp_table
;
374 struct dev_pm_opp
*temp_opp
, *opp
= ERR_PTR(-ERANGE
);
376 opp_table
= _find_opp_table(dev
);
377 if (IS_ERR(opp_table
)) {
378 int r
= PTR_ERR(opp_table
);
380 dev_err(dev
, "%s: OPP table not found (%d)\n", __func__
, r
);
384 mutex_lock(&opp_table
->lock
);
386 list_for_each_entry(temp_opp
, &opp_table
->opp_list
, node
) {
387 if (temp_opp
->available
== available
&&
388 temp_opp
->rate
== freq
) {
391 /* Increment the reference count of OPP */
397 mutex_unlock(&opp_table
->lock
);
398 dev_pm_opp_put_opp_table(opp_table
);
402 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact
);
405 * dev_pm_opp_find_level_exact() - search for an exact level
406 * @dev: device for which we do this operation
407 * @level: level to search for
409 * Return: Searches for exact match in the opp table and returns pointer to the
410 * matching opp if found, else returns ERR_PTR in case of error and should
411 * be handled using IS_ERR. Error return values can be:
412 * EINVAL: for bad pointer
413 * ERANGE: no match found for search
414 * ENODEV: if device not found in list of registered devices
416 * The callers are required to call dev_pm_opp_put() for the returned OPP after
419 struct dev_pm_opp
*dev_pm_opp_find_level_exact(struct device
*dev
,
422 struct opp_table
*opp_table
;
423 struct dev_pm_opp
*temp_opp
, *opp
= ERR_PTR(-ERANGE
);
425 opp_table
= _find_opp_table(dev
);
426 if (IS_ERR(opp_table
)) {
427 int r
= PTR_ERR(opp_table
);
429 dev_err(dev
, "%s: OPP table not found (%d)\n", __func__
, r
);
433 mutex_lock(&opp_table
->lock
);
435 list_for_each_entry(temp_opp
, &opp_table
->opp_list
, node
) {
436 if (temp_opp
->level
== level
) {
439 /* Increment the reference count of OPP */
445 mutex_unlock(&opp_table
->lock
);
446 dev_pm_opp_put_opp_table(opp_table
);
450 EXPORT_SYMBOL_GPL(dev_pm_opp_find_level_exact
);
452 static noinline
struct dev_pm_opp
*_find_freq_ceil(struct opp_table
*opp_table
,
455 struct dev_pm_opp
*temp_opp
, *opp
= ERR_PTR(-ERANGE
);
457 mutex_lock(&opp_table
->lock
);
459 list_for_each_entry(temp_opp
, &opp_table
->opp_list
, node
) {
460 if (temp_opp
->available
&& temp_opp
->rate
>= *freq
) {
464 /* Increment the reference count of OPP */
470 mutex_unlock(&opp_table
->lock
);
476 * dev_pm_opp_find_freq_ceil() - Search for an rounded ceil freq
477 * @dev: device for which we do this operation
478 * @freq: Start frequency
480 * Search for the matching ceil *available* OPP from a starting freq
483 * Return: matching *opp and refreshes *freq accordingly, else returns
484 * ERR_PTR in case of error and should be handled using IS_ERR. Error return
486 * EINVAL: for bad pointer
487 * ERANGE: no match found for search
488 * ENODEV: if device not found in list of registered devices
490 * The callers are required to call dev_pm_opp_put() for the returned OPP after
493 struct dev_pm_opp
*dev_pm_opp_find_freq_ceil(struct device
*dev
,
496 struct opp_table
*opp_table
;
497 struct dev_pm_opp
*opp
;
500 dev_err(dev
, "%s: Invalid argument freq=%p\n", __func__
, freq
);
501 return ERR_PTR(-EINVAL
);
504 opp_table
= _find_opp_table(dev
);
505 if (IS_ERR(opp_table
))
506 return ERR_CAST(opp_table
);
508 opp
= _find_freq_ceil(opp_table
, freq
);
510 dev_pm_opp_put_opp_table(opp_table
);
514 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil
);
517 * dev_pm_opp_find_freq_floor() - Search for a rounded floor freq
518 * @dev: device for which we do this operation
519 * @freq: Start frequency
521 * Search for the matching floor *available* OPP from a starting freq
524 * Return: matching *opp and refreshes *freq accordingly, else returns
525 * ERR_PTR in case of error and should be handled using IS_ERR. Error return
527 * EINVAL: for bad pointer
528 * ERANGE: no match found for search
529 * ENODEV: if device not found in list of registered devices
531 * The callers are required to call dev_pm_opp_put() for the returned OPP after
534 struct dev_pm_opp
*dev_pm_opp_find_freq_floor(struct device
*dev
,
537 struct opp_table
*opp_table
;
538 struct dev_pm_opp
*temp_opp
, *opp
= ERR_PTR(-ERANGE
);
541 dev_err(dev
, "%s: Invalid argument freq=%p\n", __func__
, freq
);
542 return ERR_PTR(-EINVAL
);
545 opp_table
= _find_opp_table(dev
);
546 if (IS_ERR(opp_table
))
547 return ERR_CAST(opp_table
);
549 mutex_lock(&opp_table
->lock
);
551 list_for_each_entry(temp_opp
, &opp_table
->opp_list
, node
) {
552 if (temp_opp
->available
) {
553 /* go to the next node, before choosing prev */
554 if (temp_opp
->rate
> *freq
)
561 /* Increment the reference count of OPP */
564 mutex_unlock(&opp_table
->lock
);
565 dev_pm_opp_put_opp_table(opp_table
);
572 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor
);
575 * dev_pm_opp_find_freq_ceil_by_volt() - Find OPP with highest frequency for
577 * @dev: Device for which we do this operation.
578 * @u_volt: Target voltage.
580 * Search for OPP with highest (ceil) frequency and has voltage <= u_volt.
582 * Return: matching *opp, else returns ERR_PTR in case of error which should be
583 * handled using IS_ERR.
585 * Error return values can be:
586 * EINVAL: bad parameters
588 * The callers are required to call dev_pm_opp_put() for the returned OPP after
591 struct dev_pm_opp
*dev_pm_opp_find_freq_ceil_by_volt(struct device
*dev
,
592 unsigned long u_volt
)
594 struct opp_table
*opp_table
;
595 struct dev_pm_opp
*temp_opp
, *opp
= ERR_PTR(-ERANGE
);
597 if (!dev
|| !u_volt
) {
598 dev_err(dev
, "%s: Invalid argument volt=%lu\n", __func__
,
600 return ERR_PTR(-EINVAL
);
603 opp_table
= _find_opp_table(dev
);
604 if (IS_ERR(opp_table
))
605 return ERR_CAST(opp_table
);
607 mutex_lock(&opp_table
->lock
);
609 list_for_each_entry(temp_opp
, &opp_table
->opp_list
, node
) {
610 if (temp_opp
->available
) {
611 if (temp_opp
->supplies
[0].u_volt
> u_volt
)
617 /* Increment the reference count of OPP */
621 mutex_unlock(&opp_table
->lock
);
622 dev_pm_opp_put_opp_table(opp_table
);
626 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil_by_volt
);
628 static int _set_opp_voltage(struct device
*dev
, struct regulator
*reg
,
629 struct dev_pm_opp_supply
*supply
)
633 /* Regulator not available for device */
635 dev_dbg(dev
, "%s: regulator not available: %ld\n", __func__
,
640 dev_dbg(dev
, "%s: voltages (mV): %lu %lu %lu\n", __func__
,
641 supply
->u_volt_min
, supply
->u_volt
, supply
->u_volt_max
);
643 ret
= regulator_set_voltage_triplet(reg
, supply
->u_volt_min
,
644 supply
->u_volt
, supply
->u_volt_max
);
646 dev_err(dev
, "%s: failed to set voltage (%lu %lu %lu mV): %d\n",
647 __func__
, supply
->u_volt_min
, supply
->u_volt
,
648 supply
->u_volt_max
, ret
);
653 static inline int _generic_set_opp_clk_only(struct device
*dev
, struct clk
*clk
,
658 ret
= clk_set_rate(clk
, freq
);
660 dev_err(dev
, "%s: failed to set clock rate: %d\n", __func__
,
667 static int _generic_set_opp_regulator(const struct opp_table
*opp_table
,
669 unsigned long old_freq
,
671 struct dev_pm_opp_supply
*old_supply
,
672 struct dev_pm_opp_supply
*new_supply
)
674 struct regulator
*reg
= opp_table
->regulators
[0];
677 /* This function only supports single regulator per device */
678 if (WARN_ON(opp_table
->regulator_count
> 1)) {
679 dev_err(dev
, "multiple regulators are not supported\n");
683 /* Scaling up? Scale voltage before frequency */
684 if (freq
>= old_freq
) {
685 ret
= _set_opp_voltage(dev
, reg
, new_supply
);
687 goto restore_voltage
;
690 /* Change frequency */
691 ret
= _generic_set_opp_clk_only(dev
, opp_table
->clk
, freq
);
693 goto restore_voltage
;
695 /* Scaling down? Scale voltage after frequency */
696 if (freq
< old_freq
) {
697 ret
= _set_opp_voltage(dev
, reg
, new_supply
);
705 if (_generic_set_opp_clk_only(dev
, opp_table
->clk
, old_freq
))
706 dev_err(dev
, "%s: failed to restore old-freq (%lu Hz)\n",
709 /* This shouldn't harm even if the voltages weren't updated earlier */
711 _set_opp_voltage(dev
, reg
, old_supply
);
716 static int _set_opp_custom(const struct opp_table
*opp_table
,
717 struct device
*dev
, unsigned long old_freq
,
719 struct dev_pm_opp_supply
*old_supply
,
720 struct dev_pm_opp_supply
*new_supply
)
722 struct dev_pm_set_opp_data
*data
;
725 data
= opp_table
->set_opp_data
;
726 data
->regulators
= opp_table
->regulators
;
727 data
->regulator_count
= opp_table
->regulator_count
;
728 data
->clk
= opp_table
->clk
;
731 data
->old_opp
.rate
= old_freq
;
732 size
= sizeof(*old_supply
) * opp_table
->regulator_count
;
734 memset(data
->old_opp
.supplies
, 0, size
);
736 memcpy(data
->old_opp
.supplies
, old_supply
, size
);
738 data
->new_opp
.rate
= freq
;
739 memcpy(data
->new_opp
.supplies
, new_supply
, size
);
741 return opp_table
->set_opp(data
);
744 /* This is only called for PM domain for now */
745 static int _set_required_opps(struct device
*dev
,
746 struct opp_table
*opp_table
,
747 struct dev_pm_opp
*opp
)
749 struct opp_table
**required_opp_tables
= opp_table
->required_opp_tables
;
750 struct device
**genpd_virt_devs
= opp_table
->genpd_virt_devs
;
754 if (!required_opp_tables
)
757 /* Single genpd case */
758 if (!genpd_virt_devs
) {
759 pstate
= likely(opp
) ? opp
->required_opps
[0]->pstate
: 0;
760 ret
= dev_pm_genpd_set_performance_state(dev
, pstate
);
762 dev_err(dev
, "Failed to set performance state of %s: %d (%d)\n",
763 dev_name(dev
), pstate
, ret
);
768 /* Multiple genpd case */
771 * Acquire genpd_virt_dev_lock to make sure we don't use a genpd_dev
772 * after it is freed from another thread.
774 mutex_lock(&opp_table
->genpd_virt_dev_lock
);
776 for (i
= 0; i
< opp_table
->required_opp_count
; i
++) {
777 pstate
= likely(opp
) ? opp
->required_opps
[i
]->pstate
: 0;
779 if (!genpd_virt_devs
[i
])
782 ret
= dev_pm_genpd_set_performance_state(genpd_virt_devs
[i
], pstate
);
784 dev_err(dev
, "Failed to set performance rate of %s: %d (%d)\n",
785 dev_name(genpd_virt_devs
[i
]), pstate
, ret
);
789 mutex_unlock(&opp_table
->genpd_virt_dev_lock
);
795 * dev_pm_opp_set_rate() - Configure new OPP based on frequency
796 * @dev: device for which we do this operation
797 * @target_freq: frequency to achieve
799 * This configures the power-supplies to the levels specified by the OPP
800 * corresponding to the target_freq, and programs the clock to a value <=
801 * target_freq, as rounded by clk_round_rate(). Device wanting to run at fmax
802 * provided by the opp, should have already rounded to the target OPP's
805 int dev_pm_opp_set_rate(struct device
*dev
, unsigned long target_freq
)
807 struct opp_table
*opp_table
;
808 unsigned long freq
, old_freq
, temp_freq
;
809 struct dev_pm_opp
*old_opp
, *opp
;
813 opp_table
= _find_opp_table(dev
);
814 if (IS_ERR(opp_table
)) {
815 dev_err(dev
, "%s: device opp doesn't exist\n", __func__
);
816 return PTR_ERR(opp_table
);
819 if (unlikely(!target_freq
)) {
820 if (opp_table
->required_opp_tables
) {
821 ret
= _set_required_opps(dev
, opp_table
, NULL
);
822 } else if (!_get_opp_count(opp_table
)) {
825 dev_err(dev
, "target frequency can't be 0\n");
832 clk
= opp_table
->clk
;
834 dev_err(dev
, "%s: No clock available for the device\n",
840 freq
= clk_round_rate(clk
, target_freq
);
844 old_freq
= clk_get_rate(clk
);
846 /* Return early if nothing to do */
847 if (old_freq
== freq
) {
848 dev_dbg(dev
, "%s: old/new frequencies (%lu Hz) are same, nothing to do\n",
855 * For IO devices which require an OPP on some platforms/SoCs
856 * while just needing to scale the clock on some others
857 * we look for empty OPP tables with just a clock handle and
858 * scale only the clk. This makes dev_pm_opp_set_rate()
859 * equivalent to a clk_set_rate()
861 if (!_get_opp_count(opp_table
)) {
862 ret
= _generic_set_opp_clk_only(dev
, clk
, freq
);
866 temp_freq
= old_freq
;
867 old_opp
= _find_freq_ceil(opp_table
, &temp_freq
);
868 if (IS_ERR(old_opp
)) {
869 dev_err(dev
, "%s: failed to find current OPP for freq %lu (%ld)\n",
870 __func__
, old_freq
, PTR_ERR(old_opp
));
874 opp
= _find_freq_ceil(opp_table
, &temp_freq
);
877 dev_err(dev
, "%s: failed to find OPP for freq %lu (%d)\n",
878 __func__
, freq
, ret
);
882 dev_dbg(dev
, "%s: switching OPP: %lu Hz --> %lu Hz\n", __func__
,
885 /* Scaling up? Configure required OPPs before frequency */
886 if (freq
>= old_freq
) {
887 ret
= _set_required_opps(dev
, opp_table
, opp
);
892 if (opp_table
->set_opp
) {
893 ret
= _set_opp_custom(opp_table
, dev
, old_freq
, freq
,
894 IS_ERR(old_opp
) ? NULL
: old_opp
->supplies
,
896 } else if (opp_table
->regulators
) {
897 ret
= _generic_set_opp_regulator(opp_table
, dev
, old_freq
, freq
,
898 IS_ERR(old_opp
) ? NULL
: old_opp
->supplies
,
901 /* Only frequency scaling */
902 ret
= _generic_set_opp_clk_only(dev
, clk
, freq
);
905 /* Scaling down? Configure required OPPs after frequency */
906 if (!ret
&& freq
< old_freq
) {
907 ret
= _set_required_opps(dev
, opp_table
, opp
);
909 dev_err(dev
, "Failed to set required opps: %d\n", ret
);
915 if (!IS_ERR(old_opp
))
916 dev_pm_opp_put(old_opp
);
918 dev_pm_opp_put_opp_table(opp_table
);
921 EXPORT_SYMBOL_GPL(dev_pm_opp_set_rate
);
923 /* OPP-dev Helpers */
924 static void _remove_opp_dev(struct opp_device
*opp_dev
,
925 struct opp_table
*opp_table
)
927 opp_debug_unregister(opp_dev
, opp_table
);
928 list_del(&opp_dev
->node
);
932 static struct opp_device
*_add_opp_dev_unlocked(const struct device
*dev
,
933 struct opp_table
*opp_table
)
935 struct opp_device
*opp_dev
;
937 opp_dev
= kzalloc(sizeof(*opp_dev
), GFP_KERNEL
);
941 /* Initialize opp-dev */
944 list_add(&opp_dev
->node
, &opp_table
->dev_list
);
946 /* Create debugfs entries for the opp_table */
947 opp_debug_register(opp_dev
, opp_table
);
952 struct opp_device
*_add_opp_dev(const struct device
*dev
,
953 struct opp_table
*opp_table
)
955 struct opp_device
*opp_dev
;
957 mutex_lock(&opp_table
->lock
);
958 opp_dev
= _add_opp_dev_unlocked(dev
, opp_table
);
959 mutex_unlock(&opp_table
->lock
);
964 static struct opp_table
*_allocate_opp_table(struct device
*dev
, int index
)
966 struct opp_table
*opp_table
;
967 struct opp_device
*opp_dev
;
971 * Allocate a new OPP table. In the infrequent case where a new
972 * device is needed to be added, we pay this penalty.
974 opp_table
= kzalloc(sizeof(*opp_table
), GFP_KERNEL
);
978 mutex_init(&opp_table
->lock
);
979 mutex_init(&opp_table
->genpd_virt_dev_lock
);
980 INIT_LIST_HEAD(&opp_table
->dev_list
);
982 /* Mark regulator count uninitialized */
983 opp_table
->regulator_count
= -1;
985 opp_dev
= _add_opp_dev(dev
, opp_table
);
991 _of_init_opp_table(opp_table
, dev
, index
);
993 /* Find clk for the device */
994 opp_table
->clk
= clk_get(dev
, NULL
);
995 if (IS_ERR(opp_table
->clk
)) {
996 ret
= PTR_ERR(opp_table
->clk
);
997 if (ret
!= -EPROBE_DEFER
)
998 dev_dbg(dev
, "%s: Couldn't find clock: %d\n", __func__
,
1002 BLOCKING_INIT_NOTIFIER_HEAD(&opp_table
->head
);
1003 INIT_LIST_HEAD(&opp_table
->opp_list
);
1004 kref_init(&opp_table
->kref
);
1006 /* Secure the device table modification */
1007 list_add(&opp_table
->node
, &opp_tables
);
1011 void _get_opp_table_kref(struct opp_table
*opp_table
)
1013 kref_get(&opp_table
->kref
);
1016 static struct opp_table
*_opp_get_opp_table(struct device
*dev
, int index
)
1018 struct opp_table
*opp_table
;
1020 /* Hold our table modification lock here */
1021 mutex_lock(&opp_table_lock
);
1023 opp_table
= _find_opp_table_unlocked(dev
);
1024 if (!IS_ERR(opp_table
))
1027 opp_table
= _managed_opp(dev
, index
);
1029 if (!_add_opp_dev_unlocked(dev
, opp_table
)) {
1030 dev_pm_opp_put_opp_table(opp_table
);
1036 opp_table
= _allocate_opp_table(dev
, index
);
1039 mutex_unlock(&opp_table_lock
);
1044 struct opp_table
*dev_pm_opp_get_opp_table(struct device
*dev
)
1046 return _opp_get_opp_table(dev
, 0);
1048 EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_table
);
1050 struct opp_table
*dev_pm_opp_get_opp_table_indexed(struct device
*dev
,
1053 return _opp_get_opp_table(dev
, index
);
1056 static void _opp_table_kref_release(struct kref
*kref
)
1058 struct opp_table
*opp_table
= container_of(kref
, struct opp_table
, kref
);
1059 struct opp_device
*opp_dev
, *temp
;
1061 _of_clear_opp_table(opp_table
);
1064 if (!IS_ERR(opp_table
->clk
))
1065 clk_put(opp_table
->clk
);
1067 WARN_ON(!list_empty(&opp_table
->opp_list
));
1069 list_for_each_entry_safe(opp_dev
, temp
, &opp_table
->dev_list
, node
) {
1071 * The OPP table is getting removed, drop the performance state
1074 if (opp_table
->genpd_performance_state
)
1075 dev_pm_genpd_set_performance_state((struct device
*)(opp_dev
->dev
), 0);
1077 _remove_opp_dev(opp_dev
, opp_table
);
1080 mutex_destroy(&opp_table
->genpd_virt_dev_lock
);
1081 mutex_destroy(&opp_table
->lock
);
1082 list_del(&opp_table
->node
);
1085 mutex_unlock(&opp_table_lock
);
1088 void dev_pm_opp_put_opp_table(struct opp_table
*opp_table
)
1090 kref_put_mutex(&opp_table
->kref
, _opp_table_kref_release
,
1093 EXPORT_SYMBOL_GPL(dev_pm_opp_put_opp_table
);
1095 void _opp_free(struct dev_pm_opp
*opp
)
1100 static void _opp_kref_release(struct dev_pm_opp
*opp
,
1101 struct opp_table
*opp_table
)
1104 * Notify the changes in the availability of the operable
1105 * frequency/voltage list.
1107 blocking_notifier_call_chain(&opp_table
->head
, OPP_EVENT_REMOVE
, opp
);
1108 _of_opp_free_required_opps(opp_table
, opp
);
1109 opp_debug_remove_one(opp
);
1110 list_del(&opp
->node
);
1114 static void _opp_kref_release_unlocked(struct kref
*kref
)
1116 struct dev_pm_opp
*opp
= container_of(kref
, struct dev_pm_opp
, kref
);
1117 struct opp_table
*opp_table
= opp
->opp_table
;
1119 _opp_kref_release(opp
, opp_table
);
1122 static void _opp_kref_release_locked(struct kref
*kref
)
1124 struct dev_pm_opp
*opp
= container_of(kref
, struct dev_pm_opp
, kref
);
1125 struct opp_table
*opp_table
= opp
->opp_table
;
1127 _opp_kref_release(opp
, opp_table
);
1128 mutex_unlock(&opp_table
->lock
);
1131 void dev_pm_opp_get(struct dev_pm_opp
*opp
)
1133 kref_get(&opp
->kref
);
1136 void dev_pm_opp_put(struct dev_pm_opp
*opp
)
1138 kref_put_mutex(&opp
->kref
, _opp_kref_release_locked
,
1139 &opp
->opp_table
->lock
);
1141 EXPORT_SYMBOL_GPL(dev_pm_opp_put
);
1143 static void dev_pm_opp_put_unlocked(struct dev_pm_opp
*opp
)
1145 kref_put(&opp
->kref
, _opp_kref_release_unlocked
);
1149 * dev_pm_opp_remove() - Remove an OPP from OPP table
1150 * @dev: device for which we do this operation
1151 * @freq: OPP to remove with matching 'freq'
1153 * This function removes an opp from the opp table.
1155 void dev_pm_opp_remove(struct device
*dev
, unsigned long freq
)
1157 struct dev_pm_opp
*opp
;
1158 struct opp_table
*opp_table
;
1161 opp_table
= _find_opp_table(dev
);
1162 if (IS_ERR(opp_table
))
1165 mutex_lock(&opp_table
->lock
);
1167 list_for_each_entry(opp
, &opp_table
->opp_list
, node
) {
1168 if (opp
->rate
== freq
) {
1174 mutex_unlock(&opp_table
->lock
);
1177 dev_pm_opp_put(opp
);
1179 /* Drop the reference taken by dev_pm_opp_add() */
1180 dev_pm_opp_put_opp_table(opp_table
);
1182 dev_warn(dev
, "%s: Couldn't find OPP with freq: %lu\n",
1186 /* Drop the reference taken by _find_opp_table() */
1187 dev_pm_opp_put_opp_table(opp_table
);
1189 EXPORT_SYMBOL_GPL(dev_pm_opp_remove
);
1191 void _opp_remove_all_static(struct opp_table
*opp_table
)
1193 struct dev_pm_opp
*opp
, *tmp
;
1195 mutex_lock(&opp_table
->lock
);
1197 if (!opp_table
->parsed_static_opps
|| --opp_table
->parsed_static_opps
)
1200 list_for_each_entry_safe(opp
, tmp
, &opp_table
->opp_list
, node
) {
1202 dev_pm_opp_put_unlocked(opp
);
1206 mutex_unlock(&opp_table
->lock
);
1210 * dev_pm_opp_remove_all_dynamic() - Remove all dynamically created OPPs
1211 * @dev: device for which we do this operation
1213 * This function removes all dynamically created OPPs from the opp table.
1215 void dev_pm_opp_remove_all_dynamic(struct device
*dev
)
1217 struct opp_table
*opp_table
;
1218 struct dev_pm_opp
*opp
, *temp
;
1221 opp_table
= _find_opp_table(dev
);
1222 if (IS_ERR(opp_table
))
1225 mutex_lock(&opp_table
->lock
);
1226 list_for_each_entry_safe(opp
, temp
, &opp_table
->opp_list
, node
) {
1228 dev_pm_opp_put_unlocked(opp
);
1232 mutex_unlock(&opp_table
->lock
);
1234 /* Drop the references taken by dev_pm_opp_add() */
1236 dev_pm_opp_put_opp_table(opp_table
);
1238 /* Drop the reference taken by _find_opp_table() */
1239 dev_pm_opp_put_opp_table(opp_table
);
1241 EXPORT_SYMBOL_GPL(dev_pm_opp_remove_all_dynamic
);
1243 struct dev_pm_opp
*_opp_allocate(struct opp_table
*table
)
1245 struct dev_pm_opp
*opp
;
1246 int count
, supply_size
;
1248 /* Allocate space for at least one supply */
1249 count
= table
->regulator_count
> 0 ? table
->regulator_count
: 1;
1250 supply_size
= sizeof(*opp
->supplies
) * count
;
1252 /* allocate new OPP node and supplies structures */
1253 opp
= kzalloc(sizeof(*opp
) + supply_size
, GFP_KERNEL
);
1257 /* Put the supplies at the end of the OPP structure as an empty array */
1258 opp
->supplies
= (struct dev_pm_opp_supply
*)(opp
+ 1);
1259 INIT_LIST_HEAD(&opp
->node
);
1264 static bool _opp_supported_by_regulators(struct dev_pm_opp
*opp
,
1265 struct opp_table
*opp_table
)
1267 struct regulator
*reg
;
1270 if (!opp_table
->regulators
)
1273 for (i
= 0; i
< opp_table
->regulator_count
; i
++) {
1274 reg
= opp_table
->regulators
[i
];
1276 if (!regulator_is_supported_voltage(reg
,
1277 opp
->supplies
[i
].u_volt_min
,
1278 opp
->supplies
[i
].u_volt_max
)) {
1279 pr_warn("%s: OPP minuV: %lu maxuV: %lu, not supported by regulator\n",
1280 __func__
, opp
->supplies
[i
].u_volt_min
,
1281 opp
->supplies
[i
].u_volt_max
);
1289 static int _opp_is_duplicate(struct device
*dev
, struct dev_pm_opp
*new_opp
,
1290 struct opp_table
*opp_table
,
1291 struct list_head
**head
)
1293 struct dev_pm_opp
*opp
;
1296 * Insert new OPP in order of increasing frequency and discard if
1299 * Need to use &opp_table->opp_list in the condition part of the 'for'
1300 * loop, don't replace it with head otherwise it will become an infinite
1303 list_for_each_entry(opp
, &opp_table
->opp_list
, node
) {
1304 if (new_opp
->rate
> opp
->rate
) {
1309 if (new_opp
->rate
< opp
->rate
)
1312 /* Duplicate OPPs */
1313 dev_warn(dev
, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
1314 __func__
, opp
->rate
, opp
->supplies
[0].u_volt
,
1315 opp
->available
, new_opp
->rate
,
1316 new_opp
->supplies
[0].u_volt
, new_opp
->available
);
1318 /* Should we compare voltages for all regulators here ? */
1319 return opp
->available
&&
1320 new_opp
->supplies
[0].u_volt
== opp
->supplies
[0].u_volt
? -EBUSY
: -EEXIST
;
1328 * 0: On success. And appropriate error message for duplicate OPPs.
1329 * -EBUSY: For OPP with same freq/volt and is available. The callers of
1330 * _opp_add() must return 0 if they receive -EBUSY from it. This is to make
1331 * sure we don't print error messages unnecessarily if different parts of
1332 * kernel try to initialize the OPP table.
1333 * -EEXIST: For OPP with same freq but different volt or is unavailable. This
1334 * should be considered an error by the callers of _opp_add().
1336 int _opp_add(struct device
*dev
, struct dev_pm_opp
*new_opp
,
1337 struct opp_table
*opp_table
, bool rate_not_available
)
1339 struct list_head
*head
;
1342 mutex_lock(&opp_table
->lock
);
1343 head
= &opp_table
->opp_list
;
1345 if (likely(!rate_not_available
)) {
1346 ret
= _opp_is_duplicate(dev
, new_opp
, opp_table
, &head
);
1348 mutex_unlock(&opp_table
->lock
);
1353 list_add(&new_opp
->node
, head
);
1354 mutex_unlock(&opp_table
->lock
);
1356 new_opp
->opp_table
= opp_table
;
1357 kref_init(&new_opp
->kref
);
1359 opp_debug_create_one(new_opp
, opp_table
);
1361 if (!_opp_supported_by_regulators(new_opp
, opp_table
)) {
1362 new_opp
->available
= false;
1363 dev_warn(dev
, "%s: OPP not supported by regulators (%lu)\n",
1364 __func__
, new_opp
->rate
);
1371 * _opp_add_v1() - Allocate a OPP based on v1 bindings.
1372 * @opp_table: OPP table
1373 * @dev: device for which we do this operation
1374 * @freq: Frequency in Hz for this OPP
1375 * @u_volt: Voltage in uVolts for this OPP
1376 * @dynamic: Dynamically added OPPs.
1378 * This function adds an opp definition to the opp table and returns status.
1379 * The opp is made available by default and it can be controlled using
1380 * dev_pm_opp_enable/disable functions and may be removed by dev_pm_opp_remove.
1382 * NOTE: "dynamic" parameter impacts OPPs added by the dev_pm_opp_of_add_table
1383 * and freed by dev_pm_opp_of_remove_table.
1387 * Duplicate OPPs (both freq and volt are same) and opp->available
1388 * -EEXIST Freq are same and volt are different OR
1389 * Duplicate OPPs (both freq and volt are same) and !opp->available
1390 * -ENOMEM Memory allocation failure
1392 int _opp_add_v1(struct opp_table
*opp_table
, struct device
*dev
,
1393 unsigned long freq
, long u_volt
, bool dynamic
)
1395 struct dev_pm_opp
*new_opp
;
1399 new_opp
= _opp_allocate(opp_table
);
1403 /* populate the opp table */
1404 new_opp
->rate
= freq
;
1405 tol
= u_volt
* opp_table
->voltage_tolerance_v1
/ 100;
1406 new_opp
->supplies
[0].u_volt
= u_volt
;
1407 new_opp
->supplies
[0].u_volt_min
= u_volt
- tol
;
1408 new_opp
->supplies
[0].u_volt_max
= u_volt
+ tol
;
1409 new_opp
->available
= true;
1410 new_opp
->dynamic
= dynamic
;
1412 ret
= _opp_add(dev
, new_opp
, opp_table
, false);
1414 /* Don't return error for duplicate OPPs */
1421 * Notify the changes in the availability of the operable
1422 * frequency/voltage list.
1424 blocking_notifier_call_chain(&opp_table
->head
, OPP_EVENT_ADD
, new_opp
);
1434 * dev_pm_opp_set_supported_hw() - Set supported platforms
1435 * @dev: Device for which supported-hw has to be set.
1436 * @versions: Array of hierarchy of versions to match.
1437 * @count: Number of elements in the array.
1439 * This is required only for the V2 bindings, and it enables a platform to
1440 * specify the hierarchy of versions it supports. OPP layer will then enable
1441 * OPPs, which are available for those versions, based on its 'opp-supported-hw'
1444 struct opp_table
*dev_pm_opp_set_supported_hw(struct device
*dev
,
1445 const u32
*versions
, unsigned int count
)
1447 struct opp_table
*opp_table
;
1449 opp_table
= dev_pm_opp_get_opp_table(dev
);
1451 return ERR_PTR(-ENOMEM
);
1453 /* Make sure there are no concurrent readers while updating opp_table */
1454 WARN_ON(!list_empty(&opp_table
->opp_list
));
1456 /* Another CPU that shares the OPP table has set the property ? */
1457 if (opp_table
->supported_hw
)
1460 opp_table
->supported_hw
= kmemdup(versions
, count
* sizeof(*versions
),
1462 if (!opp_table
->supported_hw
) {
1463 dev_pm_opp_put_opp_table(opp_table
);
1464 return ERR_PTR(-ENOMEM
);
1467 opp_table
->supported_hw_count
= count
;
1471 EXPORT_SYMBOL_GPL(dev_pm_opp_set_supported_hw
);
1474 * dev_pm_opp_put_supported_hw() - Releases resources blocked for supported hw
1475 * @opp_table: OPP table returned by dev_pm_opp_set_supported_hw().
1477 * This is required only for the V2 bindings, and is called for a matching
1478 * dev_pm_opp_set_supported_hw(). Until this is called, the opp_table structure
1479 * will not be freed.
1481 void dev_pm_opp_put_supported_hw(struct opp_table
*opp_table
)
1483 /* Make sure there are no concurrent readers while updating opp_table */
1484 WARN_ON(!list_empty(&opp_table
->opp_list
));
1486 kfree(opp_table
->supported_hw
);
1487 opp_table
->supported_hw
= NULL
;
1488 opp_table
->supported_hw_count
= 0;
1490 dev_pm_opp_put_opp_table(opp_table
);
1492 EXPORT_SYMBOL_GPL(dev_pm_opp_put_supported_hw
);
1495 * dev_pm_opp_set_prop_name() - Set prop-extn name
1496 * @dev: Device for which the prop-name has to be set.
1497 * @name: name to postfix to properties.
1499 * This is required only for the V2 bindings, and it enables a platform to
1500 * specify the extn to be used for certain property names. The properties to
1501 * which the extension will apply are opp-microvolt and opp-microamp. OPP core
1502 * should postfix the property name with -<name> while looking for them.
1504 struct opp_table
*dev_pm_opp_set_prop_name(struct device
*dev
, const char *name
)
1506 struct opp_table
*opp_table
;
1508 opp_table
= dev_pm_opp_get_opp_table(dev
);
1510 return ERR_PTR(-ENOMEM
);
1512 /* Make sure there are no concurrent readers while updating opp_table */
1513 WARN_ON(!list_empty(&opp_table
->opp_list
));
1515 /* Another CPU that shares the OPP table has set the property ? */
1516 if (opp_table
->prop_name
)
1519 opp_table
->prop_name
= kstrdup(name
, GFP_KERNEL
);
1520 if (!opp_table
->prop_name
) {
1521 dev_pm_opp_put_opp_table(opp_table
);
1522 return ERR_PTR(-ENOMEM
);
1527 EXPORT_SYMBOL_GPL(dev_pm_opp_set_prop_name
);
1530 * dev_pm_opp_put_prop_name() - Releases resources blocked for prop-name
1531 * @opp_table: OPP table returned by dev_pm_opp_set_prop_name().
1533 * This is required only for the V2 bindings, and is called for a matching
1534 * dev_pm_opp_set_prop_name(). Until this is called, the opp_table structure
1535 * will not be freed.
1537 void dev_pm_opp_put_prop_name(struct opp_table
*opp_table
)
1539 /* Make sure there are no concurrent readers while updating opp_table */
1540 WARN_ON(!list_empty(&opp_table
->opp_list
));
1542 kfree(opp_table
->prop_name
);
1543 opp_table
->prop_name
= NULL
;
1545 dev_pm_opp_put_opp_table(opp_table
);
1547 EXPORT_SYMBOL_GPL(dev_pm_opp_put_prop_name
);
1549 static int _allocate_set_opp_data(struct opp_table
*opp_table
)
1551 struct dev_pm_set_opp_data
*data
;
1552 int len
, count
= opp_table
->regulator_count
;
1554 if (WARN_ON(!opp_table
->regulators
))
1557 /* space for set_opp_data */
1558 len
= sizeof(*data
);
1560 /* space for old_opp.supplies and new_opp.supplies */
1561 len
+= 2 * sizeof(struct dev_pm_opp_supply
) * count
;
1563 data
= kzalloc(len
, GFP_KERNEL
);
1567 data
->old_opp
.supplies
= (void *)(data
+ 1);
1568 data
->new_opp
.supplies
= data
->old_opp
.supplies
+ count
;
1570 opp_table
->set_opp_data
= data
;
1575 static void _free_set_opp_data(struct opp_table
*opp_table
)
1577 kfree(opp_table
->set_opp_data
);
1578 opp_table
->set_opp_data
= NULL
;
1582 * dev_pm_opp_set_regulators() - Set regulator names for the device
1583 * @dev: Device for which regulator name is being set.
1584 * @names: Array of pointers to the names of the regulator.
1585 * @count: Number of regulators.
1587 * In order to support OPP switching, OPP layer needs to know the name of the
1588 * device's regulators, as the core would be required to switch voltages as
1591 * This must be called before any OPPs are initialized for the device.
1593 struct opp_table
*dev_pm_opp_set_regulators(struct device
*dev
,
1594 const char * const names
[],
1597 struct opp_table
*opp_table
;
1598 struct regulator
*reg
;
1601 opp_table
= dev_pm_opp_get_opp_table(dev
);
1603 return ERR_PTR(-ENOMEM
);
1605 /* This should be called before OPPs are initialized */
1606 if (WARN_ON(!list_empty(&opp_table
->opp_list
))) {
1611 /* Another CPU that shares the OPP table has set the regulators ? */
1612 if (opp_table
->regulators
)
1615 opp_table
->regulators
= kmalloc_array(count
,
1616 sizeof(*opp_table
->regulators
),
1618 if (!opp_table
->regulators
) {
1623 for (i
= 0; i
< count
; i
++) {
1624 reg
= regulator_get_optional(dev
, names
[i
]);
1627 if (ret
!= -EPROBE_DEFER
)
1628 dev_err(dev
, "%s: no regulator (%s) found: %d\n",
1629 __func__
, names
[i
], ret
);
1630 goto free_regulators
;
1633 opp_table
->regulators
[i
] = reg
;
1636 opp_table
->regulator_count
= count
;
1638 /* Allocate block only once to pass to set_opp() routines */
1639 ret
= _allocate_set_opp_data(opp_table
);
1641 goto free_regulators
;
1647 regulator_put(opp_table
->regulators
[--i
]);
1649 kfree(opp_table
->regulators
);
1650 opp_table
->regulators
= NULL
;
1651 opp_table
->regulator_count
= -1;
1653 dev_pm_opp_put_opp_table(opp_table
);
1655 return ERR_PTR(ret
);
1657 EXPORT_SYMBOL_GPL(dev_pm_opp_set_regulators
);
1660 * dev_pm_opp_put_regulators() - Releases resources blocked for regulator
1661 * @opp_table: OPP table returned from dev_pm_opp_set_regulators().
1663 void dev_pm_opp_put_regulators(struct opp_table
*opp_table
)
1667 if (!opp_table
->regulators
)
1670 /* Make sure there are no concurrent readers while updating opp_table */
1671 WARN_ON(!list_empty(&opp_table
->opp_list
));
1673 for (i
= opp_table
->regulator_count
- 1; i
>= 0; i
--)
1674 regulator_put(opp_table
->regulators
[i
]);
1676 _free_set_opp_data(opp_table
);
1678 kfree(opp_table
->regulators
);
1679 opp_table
->regulators
= NULL
;
1680 opp_table
->regulator_count
= -1;
1683 dev_pm_opp_put_opp_table(opp_table
);
1685 EXPORT_SYMBOL_GPL(dev_pm_opp_put_regulators
);
1688 * dev_pm_opp_set_clkname() - Set clk name for the device
1689 * @dev: Device for which clk name is being set.
1692 * In order to support OPP switching, OPP layer needs to get pointer to the
1693 * clock for the device. Simple cases work fine without using this routine (i.e.
1694 * by passing connection-id as NULL), but for a device with multiple clocks
1695 * available, the OPP core needs to know the exact name of the clk to use.
1697 * This must be called before any OPPs are initialized for the device.
1699 struct opp_table
*dev_pm_opp_set_clkname(struct device
*dev
, const char *name
)
1701 struct opp_table
*opp_table
;
1704 opp_table
= dev_pm_opp_get_opp_table(dev
);
1706 return ERR_PTR(-ENOMEM
);
1708 /* This should be called before OPPs are initialized */
1709 if (WARN_ON(!list_empty(&opp_table
->opp_list
))) {
1714 /* Already have default clk set, free it */
1715 if (!IS_ERR(opp_table
->clk
))
1716 clk_put(opp_table
->clk
);
1718 /* Find clk for the device */
1719 opp_table
->clk
= clk_get(dev
, name
);
1720 if (IS_ERR(opp_table
->clk
)) {
1721 ret
= PTR_ERR(opp_table
->clk
);
1722 if (ret
!= -EPROBE_DEFER
) {
1723 dev_err(dev
, "%s: Couldn't find clock: %d\n", __func__
,
1732 dev_pm_opp_put_opp_table(opp_table
);
1734 return ERR_PTR(ret
);
1736 EXPORT_SYMBOL_GPL(dev_pm_opp_set_clkname
);
1739 * dev_pm_opp_put_clkname() - Releases resources blocked for clk.
1740 * @opp_table: OPP table returned from dev_pm_opp_set_clkname().
1742 void dev_pm_opp_put_clkname(struct opp_table
*opp_table
)
1744 /* Make sure there are no concurrent readers while updating opp_table */
1745 WARN_ON(!list_empty(&opp_table
->opp_list
));
1747 clk_put(opp_table
->clk
);
1748 opp_table
->clk
= ERR_PTR(-EINVAL
);
1750 dev_pm_opp_put_opp_table(opp_table
);
1752 EXPORT_SYMBOL_GPL(dev_pm_opp_put_clkname
);
1755 * dev_pm_opp_register_set_opp_helper() - Register custom set OPP helper
1756 * @dev: Device for which the helper is getting registered.
1757 * @set_opp: Custom set OPP helper.
1759 * This is useful to support complex platforms (like platforms with multiple
1760 * regulators per device), instead of the generic OPP set rate helper.
1762 * This must be called before any OPPs are initialized for the device.
1764 struct opp_table
*dev_pm_opp_register_set_opp_helper(struct device
*dev
,
1765 int (*set_opp
)(struct dev_pm_set_opp_data
*data
))
1767 struct opp_table
*opp_table
;
1770 return ERR_PTR(-EINVAL
);
1772 opp_table
= dev_pm_opp_get_opp_table(dev
);
1774 return ERR_PTR(-ENOMEM
);
1776 /* This should be called before OPPs are initialized */
1777 if (WARN_ON(!list_empty(&opp_table
->opp_list
))) {
1778 dev_pm_opp_put_opp_table(opp_table
);
1779 return ERR_PTR(-EBUSY
);
1782 /* Another CPU that shares the OPP table has set the helper ? */
1783 if (!opp_table
->set_opp
)
1784 opp_table
->set_opp
= set_opp
;
1788 EXPORT_SYMBOL_GPL(dev_pm_opp_register_set_opp_helper
);
1791 * dev_pm_opp_unregister_set_opp_helper() - Releases resources blocked for
1793 * @opp_table: OPP table returned from dev_pm_opp_register_set_opp_helper().
1795 * Release resources blocked for platform specific set_opp helper.
1797 void dev_pm_opp_unregister_set_opp_helper(struct opp_table
*opp_table
)
1799 /* Make sure there are no concurrent readers while updating opp_table */
1800 WARN_ON(!list_empty(&opp_table
->opp_list
));
1802 opp_table
->set_opp
= NULL
;
1803 dev_pm_opp_put_opp_table(opp_table
);
1805 EXPORT_SYMBOL_GPL(dev_pm_opp_unregister_set_opp_helper
);
1807 static void _opp_detach_genpd(struct opp_table
*opp_table
)
1811 for (index
= 0; index
< opp_table
->required_opp_count
; index
++) {
1812 if (!opp_table
->genpd_virt_devs
[index
])
1815 dev_pm_domain_detach(opp_table
->genpd_virt_devs
[index
], false);
1816 opp_table
->genpd_virt_devs
[index
] = NULL
;
1819 kfree(opp_table
->genpd_virt_devs
);
1820 opp_table
->genpd_virt_devs
= NULL
;
1824 * dev_pm_opp_attach_genpd - Attach genpd(s) for the device and save virtual device pointer
1825 * @dev: Consumer device for which the genpd is getting attached.
1826 * @names: Null terminated array of pointers containing names of genpd to attach.
1827 * @virt_devs: Pointer to return the array of virtual devices.
1829 * Multiple generic power domains for a device are supported with the help of
1830 * virtual genpd devices, which are created for each consumer device - genpd
1831 * pair. These are the device structures which are attached to the power domain
1832 * and are required by the OPP core to set the performance state of the genpd.
1833 * The same API also works for the case where single genpd is available and so
1834 * we don't need to support that separately.
1836 * This helper will normally be called by the consumer driver of the device
1837 * "dev", as only that has details of the genpd names.
1839 * This helper needs to be called once with a list of all genpd to attach.
1840 * Otherwise the original device structure will be used instead by the OPP core.
1842 * The order of entries in the names array must match the order in which
1843 * "required-opps" are added in DT.
1845 struct opp_table
*dev_pm_opp_attach_genpd(struct device
*dev
,
1846 const char **names
, struct device
***virt_devs
)
1848 struct opp_table
*opp_table
;
1849 struct device
*virt_dev
;
1850 int index
= 0, ret
= -EINVAL
;
1851 const char **name
= names
;
1853 opp_table
= dev_pm_opp_get_opp_table(dev
);
1855 return ERR_PTR(-ENOMEM
);
1858 * If the genpd's OPP table isn't already initialized, parsing of the
1859 * required-opps fail for dev. We should retry this after genpd's OPP
1862 if (!opp_table
->required_opp_count
) {
1863 ret
= -EPROBE_DEFER
;
1867 mutex_lock(&opp_table
->genpd_virt_dev_lock
);
1869 opp_table
->genpd_virt_devs
= kcalloc(opp_table
->required_opp_count
,
1870 sizeof(*opp_table
->genpd_virt_devs
),
1872 if (!opp_table
->genpd_virt_devs
)
1876 if (index
>= opp_table
->required_opp_count
) {
1877 dev_err(dev
, "Index can't be greater than required-opp-count - 1, %s (%d : %d)\n",
1878 *name
, opp_table
->required_opp_count
, index
);
1882 if (opp_table
->genpd_virt_devs
[index
]) {
1883 dev_err(dev
, "Genpd virtual device already set %s\n",
1888 virt_dev
= dev_pm_domain_attach_by_name(dev
, *name
);
1889 if (IS_ERR(virt_dev
)) {
1890 ret
= PTR_ERR(virt_dev
);
1891 dev_err(dev
, "Couldn't attach to pm_domain: %d\n", ret
);
1895 opp_table
->genpd_virt_devs
[index
] = virt_dev
;
1901 *virt_devs
= opp_table
->genpd_virt_devs
;
1902 mutex_unlock(&opp_table
->genpd_virt_dev_lock
);
1907 _opp_detach_genpd(opp_table
);
1909 mutex_unlock(&opp_table
->genpd_virt_dev_lock
);
1912 dev_pm_opp_put_opp_table(opp_table
);
1914 return ERR_PTR(ret
);
1916 EXPORT_SYMBOL_GPL(dev_pm_opp_attach_genpd
);
1919 * dev_pm_opp_detach_genpd() - Detach genpd(s) from the device.
1920 * @opp_table: OPP table returned by dev_pm_opp_attach_genpd().
1922 * This detaches the genpd(s), resets the virtual device pointers, and puts the
1925 void dev_pm_opp_detach_genpd(struct opp_table
*opp_table
)
1928 * Acquire genpd_virt_dev_lock to make sure virt_dev isn't getting
1931 mutex_lock(&opp_table
->genpd_virt_dev_lock
);
1932 _opp_detach_genpd(opp_table
);
1933 mutex_unlock(&opp_table
->genpd_virt_dev_lock
);
1935 dev_pm_opp_put_opp_table(opp_table
);
1937 EXPORT_SYMBOL_GPL(dev_pm_opp_detach_genpd
);
1940 * dev_pm_opp_xlate_performance_state() - Find required OPP's pstate for src_table.
1941 * @src_table: OPP table which has dst_table as one of its required OPP table.
1942 * @dst_table: Required OPP table of the src_table.
1943 * @pstate: Current performance state of the src_table.
1945 * This Returns pstate of the OPP (present in @dst_table) pointed out by the
1946 * "required-opps" property of the OPP (present in @src_table) which has
1947 * performance state set to @pstate.
1949 * Return: Zero or positive performance state on success, otherwise negative
1952 int dev_pm_opp_xlate_performance_state(struct opp_table
*src_table
,
1953 struct opp_table
*dst_table
,
1954 unsigned int pstate
)
1956 struct dev_pm_opp
*opp
;
1957 int dest_pstate
= -EINVAL
;
1964 * Normally the src_table will have the "required_opps" property set to
1965 * point to one of the OPPs in the dst_table, but in some cases the
1966 * genpd and its master have one to one mapping of performance states
1967 * and so none of them have the "required-opps" property set. Return the
1968 * pstate of the src_table as it is in such cases.
1970 if (!src_table
->required_opp_count
)
1973 for (i
= 0; i
< src_table
->required_opp_count
; i
++) {
1974 if (src_table
->required_opp_tables
[i
]->np
== dst_table
->np
)
1978 if (unlikely(i
== src_table
->required_opp_count
)) {
1979 pr_err("%s: Couldn't find matching OPP table (%p: %p)\n",
1980 __func__
, src_table
, dst_table
);
1984 mutex_lock(&src_table
->lock
);
1986 list_for_each_entry(opp
, &src_table
->opp_list
, node
) {
1987 if (opp
->pstate
== pstate
) {
1988 dest_pstate
= opp
->required_opps
[i
]->pstate
;
1993 pr_err("%s: Couldn't find matching OPP (%p: %p)\n", __func__
, src_table
,
1997 mutex_unlock(&src_table
->lock
);
2003 * dev_pm_opp_add() - Add an OPP table from a table definitions
2004 * @dev: device for which we do this operation
2005 * @freq: Frequency in Hz for this OPP
2006 * @u_volt: Voltage in uVolts for this OPP
2008 * This function adds an opp definition to the opp table and returns status.
2009 * The opp is made available by default and it can be controlled using
2010 * dev_pm_opp_enable/disable functions.
2014 * Duplicate OPPs (both freq and volt are same) and opp->available
2015 * -EEXIST Freq are same and volt are different OR
2016 * Duplicate OPPs (both freq and volt are same) and !opp->available
2017 * -ENOMEM Memory allocation failure
2019 int dev_pm_opp_add(struct device
*dev
, unsigned long freq
, unsigned long u_volt
)
2021 struct opp_table
*opp_table
;
2024 opp_table
= dev_pm_opp_get_opp_table(dev
);
2028 /* Fix regulator count for dynamic OPPs */
2029 opp_table
->regulator_count
= 1;
2031 ret
= _opp_add_v1(opp_table
, dev
, freq
, u_volt
, true);
2033 dev_pm_opp_put_opp_table(opp_table
);
2037 EXPORT_SYMBOL_GPL(dev_pm_opp_add
);
2040 * _opp_set_availability() - helper to set the availability of an opp
2041 * @dev: device for which we do this operation
2042 * @freq: OPP frequency to modify availability
2043 * @availability_req: availability status requested for this opp
2045 * Set the availability of an OPP, opp_{enable,disable} share a common logic
2046 * which is isolated here.
2048 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
2049 * copy operation, returns 0 if no modification was done OR modification was
2052 static int _opp_set_availability(struct device
*dev
, unsigned long freq
,
2053 bool availability_req
)
2055 struct opp_table
*opp_table
;
2056 struct dev_pm_opp
*tmp_opp
, *opp
= ERR_PTR(-ENODEV
);
2059 /* Find the opp_table */
2060 opp_table
= _find_opp_table(dev
);
2061 if (IS_ERR(opp_table
)) {
2062 r
= PTR_ERR(opp_table
);
2063 dev_warn(dev
, "%s: Device OPP not found (%d)\n", __func__
, r
);
2067 mutex_lock(&opp_table
->lock
);
2069 /* Do we have the frequency? */
2070 list_for_each_entry(tmp_opp
, &opp_table
->opp_list
, node
) {
2071 if (tmp_opp
->rate
== freq
) {
2082 /* Is update really needed? */
2083 if (opp
->available
== availability_req
)
2086 opp
->available
= availability_req
;
2088 dev_pm_opp_get(opp
);
2089 mutex_unlock(&opp_table
->lock
);
2091 /* Notify the change of the OPP availability */
2092 if (availability_req
)
2093 blocking_notifier_call_chain(&opp_table
->head
, OPP_EVENT_ENABLE
,
2096 blocking_notifier_call_chain(&opp_table
->head
,
2097 OPP_EVENT_DISABLE
, opp
);
2099 dev_pm_opp_put(opp
);
2103 mutex_unlock(&opp_table
->lock
);
2105 dev_pm_opp_put_opp_table(opp_table
);
2110 * dev_pm_opp_adjust_voltage() - helper to change the voltage of an OPP
2111 * @dev: device for which we do this operation
2112 * @freq: OPP frequency to adjust voltage of
2113 * @u_volt: new OPP target voltage
2114 * @u_volt_min: new OPP min voltage
2115 * @u_volt_max: new OPP max voltage
2117 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
2118 * copy operation, returns 0 if no modifcation was done OR modification was
2121 int dev_pm_opp_adjust_voltage(struct device
*dev
, unsigned long freq
,
2122 unsigned long u_volt
, unsigned long u_volt_min
,
2123 unsigned long u_volt_max
)
2126 struct opp_table
*opp_table
;
2127 struct dev_pm_opp
*tmp_opp
, *opp
= ERR_PTR(-ENODEV
);
2130 /* Find the opp_table */
2131 opp_table
= _find_opp_table(dev
);
2132 if (IS_ERR(opp_table
)) {
2133 r
= PTR_ERR(opp_table
);
2134 dev_warn(dev
, "%s: Device OPP not found (%d)\n", __func__
, r
);
2138 mutex_lock(&opp_table
->lock
);
2140 /* Do we have the frequency? */
2141 list_for_each_entry(tmp_opp
, &opp_table
->opp_list
, node
) {
2142 if (tmp_opp
->rate
== freq
) {
2153 /* Is update really needed? */
2154 if (opp
->supplies
->u_volt
== u_volt
)
2157 opp
->supplies
->u_volt
= u_volt
;
2158 opp
->supplies
->u_volt_min
= u_volt_min
;
2159 opp
->supplies
->u_volt_max
= u_volt_max
;
2161 dev_pm_opp_get(opp
);
2162 mutex_unlock(&opp_table
->lock
);
2164 /* Notify the voltage change of the OPP */
2165 blocking_notifier_call_chain(&opp_table
->head
, OPP_EVENT_ADJUST_VOLTAGE
,
2168 dev_pm_opp_put(opp
);
2169 goto adjust_put_table
;
2172 mutex_unlock(&opp_table
->lock
);
2174 dev_pm_opp_put_opp_table(opp_table
);
2179 * dev_pm_opp_enable() - Enable a specific OPP
2180 * @dev: device for which we do this operation
2181 * @freq: OPP frequency to enable
2183 * Enables a provided opp. If the operation is valid, this returns 0, else the
2184 * corresponding error value. It is meant to be used for users an OPP available
2185 * after being temporarily made unavailable with dev_pm_opp_disable.
2187 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
2188 * copy operation, returns 0 if no modification was done OR modification was
2191 int dev_pm_opp_enable(struct device
*dev
, unsigned long freq
)
2193 return _opp_set_availability(dev
, freq
, true);
2195 EXPORT_SYMBOL_GPL(dev_pm_opp_enable
);
2198 * dev_pm_opp_disable() - Disable a specific OPP
2199 * @dev: device for which we do this operation
2200 * @freq: OPP frequency to disable
2202 * Disables a provided opp. If the operation is valid, this returns
2203 * 0, else the corresponding error value. It is meant to be a temporary
2204 * control by users to make this OPP not available until the circumstances are
2205 * right to make it available again (with a call to dev_pm_opp_enable).
2207 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
2208 * copy operation, returns 0 if no modification was done OR modification was
2211 int dev_pm_opp_disable(struct device
*dev
, unsigned long freq
)
2213 return _opp_set_availability(dev
, freq
, false);
2215 EXPORT_SYMBOL_GPL(dev_pm_opp_disable
);
2218 * dev_pm_opp_register_notifier() - Register OPP notifier for the device
2219 * @dev: Device for which notifier needs to be registered
2220 * @nb: Notifier block to be registered
2222 * Return: 0 on success or a negative error value.
2224 int dev_pm_opp_register_notifier(struct device
*dev
, struct notifier_block
*nb
)
2226 struct opp_table
*opp_table
;
2229 opp_table
= _find_opp_table(dev
);
2230 if (IS_ERR(opp_table
))
2231 return PTR_ERR(opp_table
);
2233 ret
= blocking_notifier_chain_register(&opp_table
->head
, nb
);
2235 dev_pm_opp_put_opp_table(opp_table
);
2239 EXPORT_SYMBOL(dev_pm_opp_register_notifier
);
2242 * dev_pm_opp_unregister_notifier() - Unregister OPP notifier for the device
2243 * @dev: Device for which notifier needs to be unregistered
2244 * @nb: Notifier block to be unregistered
2246 * Return: 0 on success or a negative error value.
2248 int dev_pm_opp_unregister_notifier(struct device
*dev
,
2249 struct notifier_block
*nb
)
2251 struct opp_table
*opp_table
;
2254 opp_table
= _find_opp_table(dev
);
2255 if (IS_ERR(opp_table
))
2256 return PTR_ERR(opp_table
);
2258 ret
= blocking_notifier_chain_unregister(&opp_table
->head
, nb
);
2260 dev_pm_opp_put_opp_table(opp_table
);
2264 EXPORT_SYMBOL(dev_pm_opp_unregister_notifier
);
2266 void _dev_pm_opp_find_and_remove_table(struct device
*dev
)
2268 struct opp_table
*opp_table
;
2270 /* Check for existing table for 'dev' */
2271 opp_table
= _find_opp_table(dev
);
2272 if (IS_ERR(opp_table
)) {
2273 int error
= PTR_ERR(opp_table
);
2275 if (error
!= -ENODEV
)
2276 WARN(1, "%s: opp_table: %d\n",
2277 IS_ERR_OR_NULL(dev
) ?
2278 "Invalid device" : dev_name(dev
),
2283 _opp_remove_all_static(opp_table
);
2285 /* Drop reference taken by _find_opp_table() */
2286 dev_pm_opp_put_opp_table(opp_table
);
2288 /* Drop reference taken while the OPP table was added */
2289 dev_pm_opp_put_opp_table(opp_table
);
2293 * dev_pm_opp_remove_table() - Free all OPPs associated with the device
2294 * @dev: device pointer used to lookup OPP table.
2296 * Free both OPPs created using static entries present in DT and the
2297 * dynamically added entries.
2299 void dev_pm_opp_remove_table(struct device
*dev
)
2301 _dev_pm_opp_find_and_remove_table(dev
);
2303 EXPORT_SYMBOL_GPL(dev_pm_opp_remove_table
);