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/errno.h>
17 #include <linux/err.h>
18 #include <linux/slab.h>
19 #include <linux/device.h>
21 #include <linux/export.h>
26 * The root of the list of all devices. All device_opp structures branch off
27 * from here, with each device_opp containing the list of opp it supports in
28 * various states of availability.
30 static LIST_HEAD(dev_opp_list);
31 /* Lock to allow exclusive modification to the device and opp lists */
32 DEFINE_MUTEX(dev_opp_list_lock);
34 #define opp_rcu_lockdep_assert() \
36 RCU_LOCKDEP_WARN(!rcu_read_lock_held() && \
37 !lockdep_is_held(&dev_opp_list_lock), \
38 "Missing rcu_read_lock() or " \
39 "dev_opp_list_lock protection"); \
42 static struct device_list_opp *_find_list_dev(const struct device *dev,
43 struct device_opp *dev_opp)
45 struct device_list_opp *list_dev;
47 list_for_each_entry(list_dev, &dev_opp->dev_list, node)
48 if (list_dev->dev == dev)
54 static struct device_opp *_managed_opp(const struct device_node *np)
56 struct device_opp *dev_opp;
58 list_for_each_entry_rcu(dev_opp, &dev_opp_list, node) {
59 if (dev_opp->np == np) {
61 * Multiple devices can point to the same OPP table and
62 * so will have same node-pointer, np.
64 * But the OPPs will be considered as shared only if the
65 * OPP table contains a "opp-shared" property.
67 return dev_opp->shared_opp ? dev_opp : NULL;
75 * _find_device_opp() - find device_opp struct using device pointer
76 * @dev: device pointer used to lookup device OPPs
78 * Search list of device OPPs for one containing matching device. Does a RCU
79 * reader operation to grab the pointer needed.
81 * Return: pointer to 'struct device_opp' if found, otherwise -ENODEV or
82 * -EINVAL based on type of error.
84 * Locking: For readers, this function must be called under rcu_read_lock().
85 * device_opp is a RCU protected pointer, which means that device_opp is valid
86 * as long as we are under RCU lock.
88 * For Writers, this function must be called with dev_opp_list_lock held.
90 struct device_opp *_find_device_opp(struct device *dev)
92 struct device_opp *dev_opp;
94 opp_rcu_lockdep_assert();
96 if (IS_ERR_OR_NULL(dev)) {
97 pr_err("%s: Invalid parameters\n", __func__);
98 return ERR_PTR(-EINVAL);
101 list_for_each_entry_rcu(dev_opp, &dev_opp_list, node)
102 if (_find_list_dev(dev, dev_opp))
105 return ERR_PTR(-ENODEV);
109 * dev_pm_opp_get_voltage() - Gets the voltage corresponding to an opp
110 * @opp: opp for which voltage has to be returned for
112 * Return: voltage in micro volt corresponding to the opp, else
115 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
116 * protected pointer. This means that opp which could have been fetched by
117 * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
118 * under RCU lock. The pointer returned by the opp_find_freq family must be
119 * used in the same section as the usage of this function with the pointer
120 * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
123 unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp)
125 struct dev_pm_opp *tmp_opp;
128 opp_rcu_lockdep_assert();
130 tmp_opp = rcu_dereference(opp);
131 if (IS_ERR_OR_NULL(tmp_opp))
132 pr_err("%s: Invalid parameters\n", __func__);
138 EXPORT_SYMBOL_GPL(dev_pm_opp_get_voltage);
141 * dev_pm_opp_get_freq() - Gets the frequency corresponding to an available opp
142 * @opp: opp for which frequency has to be returned for
144 * Return: frequency in hertz corresponding to the opp, else
147 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
148 * protected pointer. This means that opp which could have been fetched by
149 * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
150 * under RCU lock. The pointer returned by the opp_find_freq family must be
151 * used in the same section as the usage of this function with the pointer
152 * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
155 unsigned long dev_pm_opp_get_freq(struct dev_pm_opp *opp)
157 struct dev_pm_opp *tmp_opp;
160 opp_rcu_lockdep_assert();
162 tmp_opp = rcu_dereference(opp);
163 if (IS_ERR_OR_NULL(tmp_opp) || !tmp_opp->available)
164 pr_err("%s: Invalid parameters\n", __func__);
170 EXPORT_SYMBOL_GPL(dev_pm_opp_get_freq);
173 * dev_pm_opp_is_turbo() - Returns if opp is turbo OPP or not
174 * @opp: opp for which turbo mode is being verified
176 * Turbo OPPs are not for normal use, and can be enabled (under certain
177 * conditions) for short duration of times to finish high throughput work
178 * quickly. Running on them for longer times may overheat the chip.
180 * Return: true if opp is turbo opp, else false.
182 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
183 * protected pointer. This means that opp which could have been fetched by
184 * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
185 * under RCU lock. The pointer returned by the opp_find_freq family must be
186 * used in the same section as the usage of this function with the pointer
187 * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
190 bool dev_pm_opp_is_turbo(struct dev_pm_opp *opp)
192 struct dev_pm_opp *tmp_opp;
194 opp_rcu_lockdep_assert();
196 tmp_opp = rcu_dereference(opp);
197 if (IS_ERR_OR_NULL(tmp_opp) || !tmp_opp->available) {
198 pr_err("%s: Invalid parameters\n", __func__);
202 return tmp_opp->turbo;
204 EXPORT_SYMBOL_GPL(dev_pm_opp_is_turbo);
207 * dev_pm_opp_get_max_clock_latency() - Get max clock latency in nanoseconds
208 * @dev: device for which we do this operation
210 * Return: This function returns the max clock latency in nanoseconds.
212 * Locking: This function takes rcu_read_lock().
214 unsigned long dev_pm_opp_get_max_clock_latency(struct device *dev)
216 struct device_opp *dev_opp;
217 unsigned long clock_latency_ns;
221 dev_opp = _find_device_opp(dev);
223 clock_latency_ns = 0;
225 clock_latency_ns = dev_opp->clock_latency_ns_max;
228 return clock_latency_ns;
230 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_clock_latency);
233 * dev_pm_opp_get_suspend_opp() - Get suspend opp
234 * @dev: device for which we do this operation
236 * Return: This function returns pointer to the suspend opp if it is
237 * defined and available, otherwise it returns NULL.
239 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
240 * protected pointer. The reason for the same is that the opp pointer which is
241 * returned will remain valid for use with opp_get_{voltage, freq} only while
242 * under the locked area. The pointer returned must be used prior to unlocking
243 * with rcu_read_unlock() to maintain the integrity of the pointer.
245 struct dev_pm_opp *dev_pm_opp_get_suspend_opp(struct device *dev)
247 struct device_opp *dev_opp;
249 opp_rcu_lockdep_assert();
251 dev_opp = _find_device_opp(dev);
252 if (IS_ERR(dev_opp) || !dev_opp->suspend_opp ||
253 !dev_opp->suspend_opp->available)
256 return dev_opp->suspend_opp;
258 EXPORT_SYMBOL_GPL(dev_pm_opp_get_suspend_opp);
261 * dev_pm_opp_get_opp_count() - Get number of opps available in the opp list
262 * @dev: device for which we do this operation
264 * Return: This function returns the number of available opps if there are any,
265 * else returns 0 if none or the corresponding error value.
267 * Locking: This function takes rcu_read_lock().
269 int dev_pm_opp_get_opp_count(struct device *dev)
271 struct device_opp *dev_opp;
272 struct dev_pm_opp *temp_opp;
277 dev_opp = _find_device_opp(dev);
278 if (IS_ERR(dev_opp)) {
279 count = PTR_ERR(dev_opp);
280 dev_err(dev, "%s: device OPP not found (%d)\n",
285 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
286 if (temp_opp->available)
294 EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count);
297 * dev_pm_opp_find_freq_exact() - search for an exact frequency
298 * @dev: device for which we do this operation
299 * @freq: frequency to search for
300 * @available: true/false - match for available opp
302 * Return: Searches for exact match in the opp list and returns pointer to the
303 * matching opp if found, else returns ERR_PTR in case of error and should
304 * be handled using IS_ERR. Error return values can be:
305 * EINVAL: for bad pointer
306 * ERANGE: no match found for search
307 * ENODEV: if device not found in list of registered devices
309 * Note: available is a modifier for the search. if available=true, then the
310 * match is for exact matching frequency and is available in the stored OPP
311 * table. if false, the match is for exact frequency which is not available.
313 * This provides a mechanism to enable an opp which is not available currently
314 * or the opposite as well.
316 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
317 * protected pointer. The reason for the same is that the opp pointer which is
318 * returned will remain valid for use with opp_get_{voltage, freq} only while
319 * under the locked area. The pointer returned must be used prior to unlocking
320 * with rcu_read_unlock() to maintain the integrity of the pointer.
322 struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,
326 struct device_opp *dev_opp;
327 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
329 opp_rcu_lockdep_assert();
331 dev_opp = _find_device_opp(dev);
332 if (IS_ERR(dev_opp)) {
333 int r = PTR_ERR(dev_opp);
334 dev_err(dev, "%s: device OPP not found (%d)\n", __func__, r);
338 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
339 if (temp_opp->available == available &&
340 temp_opp->rate == freq) {
348 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact);
351 * dev_pm_opp_find_freq_ceil() - Search for an rounded ceil freq
352 * @dev: device for which we do this operation
353 * @freq: Start frequency
355 * Search for the matching ceil *available* OPP from a starting freq
358 * Return: matching *opp and refreshes *freq accordingly, else returns
359 * ERR_PTR in case of error and should be handled using IS_ERR. Error return
361 * EINVAL: for bad pointer
362 * ERANGE: no match found for search
363 * ENODEV: if device not found in list of registered devices
365 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
366 * protected pointer. The reason for the same is that the opp pointer which is
367 * returned will remain valid for use with opp_get_{voltage, freq} only while
368 * under the locked area. The pointer returned must be used prior to unlocking
369 * with rcu_read_unlock() to maintain the integrity of the pointer.
371 struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
374 struct device_opp *dev_opp;
375 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
377 opp_rcu_lockdep_assert();
380 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
381 return ERR_PTR(-EINVAL);
384 dev_opp = _find_device_opp(dev);
386 return ERR_CAST(dev_opp);
388 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
389 if (temp_opp->available && temp_opp->rate >= *freq) {
398 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil);
401 * dev_pm_opp_find_freq_floor() - Search for a rounded floor freq
402 * @dev: device for which we do this operation
403 * @freq: Start frequency
405 * Search for the matching floor *available* OPP from a starting freq
408 * Return: matching *opp and refreshes *freq accordingly, else returns
409 * ERR_PTR in case of error and should be handled using IS_ERR. Error return
411 * EINVAL: for bad pointer
412 * ERANGE: no match found for search
413 * ENODEV: if device not found in list of registered devices
415 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
416 * protected pointer. The reason for the same is that the opp pointer which is
417 * returned will remain valid for use with opp_get_{voltage, freq} only while
418 * under the locked area. The pointer returned must be used prior to unlocking
419 * with rcu_read_unlock() to maintain the integrity of the pointer.
421 struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
424 struct device_opp *dev_opp;
425 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
427 opp_rcu_lockdep_assert();
430 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
431 return ERR_PTR(-EINVAL);
434 dev_opp = _find_device_opp(dev);
436 return ERR_CAST(dev_opp);
438 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
439 if (temp_opp->available) {
440 /* go to the next node, before choosing prev */
441 if (temp_opp->rate > *freq)
452 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
454 /* List-dev Helpers */
455 static void _kfree_list_dev_rcu(struct rcu_head *head)
457 struct device_list_opp *list_dev;
459 list_dev = container_of(head, struct device_list_opp, rcu_head);
460 kfree_rcu(list_dev, rcu_head);
463 static void _remove_list_dev(struct device_list_opp *list_dev,
464 struct device_opp *dev_opp)
466 opp_debug_unregister(list_dev, dev_opp);
467 list_del(&list_dev->node);
468 call_srcu(&dev_opp->srcu_head.srcu, &list_dev->rcu_head,
469 _kfree_list_dev_rcu);
472 struct device_list_opp *_add_list_dev(const struct device *dev,
473 struct device_opp *dev_opp)
475 struct device_list_opp *list_dev;
478 list_dev = kzalloc(sizeof(*list_dev), GFP_KERNEL);
482 /* Initialize list-dev */
484 list_add_rcu(&list_dev->node, &dev_opp->dev_list);
486 /* Create debugfs entries for the dev_opp */
487 ret = opp_debug_register(list_dev, dev_opp);
489 dev_err(dev, "%s: Failed to register opp debugfs (%d)\n",
496 * _add_device_opp() - Find device OPP table or allocate a new one
497 * @dev: device for which we do this operation
499 * It tries to find an existing table first, if it couldn't find one, it
500 * allocates a new OPP table and returns that.
502 * Return: valid device_opp pointer if success, else NULL.
504 static struct device_opp *_add_device_opp(struct device *dev)
506 struct device_opp *dev_opp;
507 struct device_list_opp *list_dev;
509 /* Check for existing list for 'dev' first */
510 dev_opp = _find_device_opp(dev);
511 if (!IS_ERR(dev_opp))
515 * Allocate a new device OPP table. In the infrequent case where a new
516 * device is needed to be added, we pay this penalty.
518 dev_opp = kzalloc(sizeof(*dev_opp), GFP_KERNEL);
522 INIT_LIST_HEAD(&dev_opp->dev_list);
524 list_dev = _add_list_dev(dev, dev_opp);
530 srcu_init_notifier_head(&dev_opp->srcu_head);
531 INIT_LIST_HEAD(&dev_opp->opp_list);
533 /* Secure the device list modification */
534 list_add_rcu(&dev_opp->node, &dev_opp_list);
539 * _kfree_device_rcu() - Free device_opp RCU handler
542 static void _kfree_device_rcu(struct rcu_head *head)
544 struct device_opp *device_opp = container_of(head, struct device_opp, rcu_head);
546 kfree_rcu(device_opp, rcu_head);
550 * _remove_device_opp() - Removes a device OPP table
551 * @dev_opp: device OPP table to be removed.
553 * Removes/frees device OPP table it it doesn't contain any OPPs.
555 static void _remove_device_opp(struct device_opp *dev_opp)
557 struct device_list_opp *list_dev;
559 if (!list_empty(&dev_opp->opp_list))
562 if (dev_opp->supported_hw)
565 if (dev_opp->prop_name)
568 list_dev = list_first_entry(&dev_opp->dev_list, struct device_list_opp,
571 _remove_list_dev(list_dev, dev_opp);
573 /* dev_list must be empty now */
574 WARN_ON(!list_empty(&dev_opp->dev_list));
576 list_del_rcu(&dev_opp->node);
577 call_srcu(&dev_opp->srcu_head.srcu, &dev_opp->rcu_head,
582 * _kfree_opp_rcu() - Free OPP RCU handler
585 static void _kfree_opp_rcu(struct rcu_head *head)
587 struct dev_pm_opp *opp = container_of(head, struct dev_pm_opp, rcu_head);
589 kfree_rcu(opp, rcu_head);
593 * _opp_remove() - Remove an OPP from a table definition
594 * @dev_opp: points back to the device_opp struct this opp belongs to
595 * @opp: pointer to the OPP to remove
596 * @notify: OPP_EVENT_REMOVE notification should be sent or not
598 * This function removes an opp definition from the opp list.
600 * Locking: The internal device_opp and opp structures are RCU protected.
601 * It is assumed that the caller holds required mutex for an RCU updater
604 static void _opp_remove(struct device_opp *dev_opp,
605 struct dev_pm_opp *opp, bool notify)
608 * Notify the changes in the availability of the operable
609 * frequency/voltage list.
612 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_REMOVE, opp);
613 opp_debug_remove_one(opp);
614 list_del_rcu(&opp->node);
615 call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);
617 _remove_device_opp(dev_opp);
621 * dev_pm_opp_remove() - Remove an OPP from OPP list
622 * @dev: device for which we do this operation
623 * @freq: OPP to remove with matching 'freq'
625 * This function removes an opp from the opp list.
627 * Locking: The internal device_opp and opp structures are RCU protected.
628 * Hence this function internally uses RCU updater strategy with mutex locks
629 * to keep the integrity of the internal data structures. Callers should ensure
630 * that this function is *NOT* called under RCU protection or in contexts where
631 * mutex cannot be locked.
633 void dev_pm_opp_remove(struct device *dev, unsigned long freq)
635 struct dev_pm_opp *opp;
636 struct device_opp *dev_opp;
639 /* Hold our list modification lock here */
640 mutex_lock(&dev_opp_list_lock);
642 dev_opp = _find_device_opp(dev);
646 list_for_each_entry(opp, &dev_opp->opp_list, node) {
647 if (opp->rate == freq) {
654 dev_warn(dev, "%s: Couldn't find OPP with freq: %lu\n",
659 _opp_remove(dev_opp, opp, true);
661 mutex_unlock(&dev_opp_list_lock);
663 EXPORT_SYMBOL_GPL(dev_pm_opp_remove);
665 static struct dev_pm_opp *_allocate_opp(struct device *dev,
666 struct device_opp **dev_opp)
668 struct dev_pm_opp *opp;
670 /* allocate new OPP node */
671 opp = kzalloc(sizeof(*opp), GFP_KERNEL);
675 INIT_LIST_HEAD(&opp->node);
677 *dev_opp = _add_device_opp(dev);
686 static int _opp_add(struct device *dev, struct dev_pm_opp *new_opp,
687 struct device_opp *dev_opp)
689 struct dev_pm_opp *opp;
690 struct list_head *head = &dev_opp->opp_list;
694 * Insert new OPP in order of increasing frequency and discard if
697 * Need to use &dev_opp->opp_list in the condition part of the 'for'
698 * loop, don't replace it with head otherwise it will become an infinite
701 list_for_each_entry_rcu(opp, &dev_opp->opp_list, node) {
702 if (new_opp->rate > opp->rate) {
707 if (new_opp->rate < opp->rate)
711 dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
712 __func__, opp->rate, opp->u_volt, opp->available,
713 new_opp->rate, new_opp->u_volt, new_opp->available);
715 return opp->available && new_opp->u_volt == opp->u_volt ?
719 new_opp->dev_opp = dev_opp;
720 list_add_rcu(&new_opp->node, head);
722 ret = opp_debug_create_one(new_opp, dev_opp);
724 dev_err(dev, "%s: Failed to register opp to debugfs (%d)\n",
731 * _opp_add_v1() - Allocate a OPP based on v1 bindings.
732 * @dev: device for which we do this operation
733 * @freq: Frequency in Hz for this OPP
734 * @u_volt: Voltage in uVolts for this OPP
735 * @dynamic: Dynamically added OPPs.
737 * This function adds an opp definition to the opp list and returns status.
738 * The opp is made available by default and it can be controlled using
739 * dev_pm_opp_enable/disable functions and may be removed by dev_pm_opp_remove.
741 * NOTE: "dynamic" parameter impacts OPPs added by the dev_pm_opp_of_add_table
742 * and freed by dev_pm_opp_of_remove_table.
744 * Locking: The internal device_opp and opp structures are RCU protected.
745 * Hence this function internally uses RCU updater strategy with mutex locks
746 * to keep the integrity of the internal data structures. Callers should ensure
747 * that this function is *NOT* called under RCU protection or in contexts where
748 * mutex cannot be locked.
752 * Duplicate OPPs (both freq and volt are same) and opp->available
753 * -EEXIST Freq are same and volt are different OR
754 * Duplicate OPPs (both freq and volt are same) and !opp->available
755 * -ENOMEM Memory allocation failure
757 static int _opp_add_v1(struct device *dev, unsigned long freq, long u_volt,
760 struct device_opp *dev_opp;
761 struct dev_pm_opp *new_opp;
764 /* Hold our list modification lock here */
765 mutex_lock(&dev_opp_list_lock);
767 new_opp = _allocate_opp(dev, &dev_opp);
773 /* populate the opp table */
774 new_opp->rate = freq;
775 new_opp->u_volt = u_volt;
776 new_opp->available = true;
777 new_opp->dynamic = dynamic;
779 ret = _opp_add(dev, new_opp, dev_opp);
783 mutex_unlock(&dev_opp_list_lock);
786 * Notify the changes in the availability of the operable
787 * frequency/voltage list.
789 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
793 _opp_remove(dev_opp, new_opp, false);
795 mutex_unlock(&dev_opp_list_lock);
799 /* TODO: Support multiple regulators */
800 static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev,
801 struct device_opp *dev_opp)
803 u32 microvolt[3] = {0};
806 struct property *prop = NULL;
809 /* Search for "opp-microvolt-<name>" */
810 if (dev_opp->prop_name) {
811 snprintf(name, sizeof(name), "opp-microvolt-%s",
813 prop = of_find_property(opp->np, name, NULL);
817 /* Search for "opp-microvolt" */
818 sprintf(name, "opp-microvolt");
819 prop = of_find_property(opp->np, name, NULL);
821 /* Missing property isn't a problem, but an invalid entry is */
826 count = of_property_count_u32_elems(opp->np, name);
828 dev_err(dev, "%s: Invalid %s property (%d)\n",
829 __func__, name, count);
833 /* There can be one or three elements here */
834 if (count != 1 && count != 3) {
835 dev_err(dev, "%s: Invalid number of elements in %s property (%d)\n",
836 __func__, name, count);
840 ret = of_property_read_u32_array(opp->np, name, microvolt, count);
842 dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret);
846 opp->u_volt = microvolt[0];
847 opp->u_volt_min = microvolt[1];
848 opp->u_volt_max = microvolt[2];
850 /* Search for "opp-microamp-<name>" */
852 if (dev_opp->prop_name) {
853 snprintf(name, sizeof(name), "opp-microamp-%s",
855 prop = of_find_property(opp->np, name, NULL);
859 /* Search for "opp-microamp" */
860 sprintf(name, "opp-microamp");
861 prop = of_find_property(opp->np, name, NULL);
864 if (prop && !of_property_read_u32(opp->np, name, &val))
871 * dev_pm_opp_set_supported_hw() - Set supported platforms
872 * @dev: Device for which supported-hw has to be set.
873 * @versions: Array of hierarchy of versions to match.
874 * @count: Number of elements in the array.
876 * This is required only for the V2 bindings, and it enables a platform to
877 * specify the hierarchy of versions it supports. OPP layer will then enable
878 * OPPs, which are available for those versions, based on its 'opp-supported-hw'
881 * Locking: The internal device_opp and opp structures are RCU protected.
882 * Hence this function internally uses RCU updater strategy with mutex locks
883 * to keep the integrity of the internal data structures. Callers should ensure
884 * that this function is *NOT* called under RCU protection or in contexts where
885 * mutex cannot be locked.
887 int dev_pm_opp_set_supported_hw(struct device *dev, const u32 *versions,
890 struct device_opp *dev_opp;
893 /* Hold our list modification lock here */
894 mutex_lock(&dev_opp_list_lock);
896 dev_opp = _add_device_opp(dev);
902 /* Make sure there are no concurrent readers while updating dev_opp */
903 WARN_ON(!list_empty(&dev_opp->opp_list));
905 /* Do we already have a version hierarchy associated with dev_opp? */
906 if (dev_opp->supported_hw) {
907 dev_err(dev, "%s: Already have supported hardware list\n",
913 dev_opp->supported_hw = kmemdup(versions, count * sizeof(*versions),
915 if (!dev_opp->supported_hw) {
920 dev_opp->supported_hw_count = count;
921 mutex_unlock(&dev_opp_list_lock);
925 _remove_device_opp(dev_opp);
927 mutex_unlock(&dev_opp_list_lock);
931 EXPORT_SYMBOL_GPL(dev_pm_opp_set_supported_hw);
934 * dev_pm_opp_put_supported_hw() - Releases resources blocked for supported hw
935 * @dev: Device for which supported-hw has to be set.
937 * This is required only for the V2 bindings, and is called for a matching
938 * dev_pm_opp_set_supported_hw(). Until this is called, the device_opp structure
941 * Locking: The internal device_opp and opp structures are RCU protected.
942 * Hence this function internally uses RCU updater strategy with mutex locks
943 * to keep the integrity of the internal data structures. Callers should ensure
944 * that this function is *NOT* called under RCU protection or in contexts where
945 * mutex cannot be locked.
947 void dev_pm_opp_put_supported_hw(struct device *dev)
949 struct device_opp *dev_opp;
951 /* Hold our list modification lock here */
952 mutex_lock(&dev_opp_list_lock);
954 /* Check for existing list for 'dev' first */
955 dev_opp = _find_device_opp(dev);
956 if (IS_ERR(dev_opp)) {
957 dev_err(dev, "Failed to find dev_opp: %ld\n", PTR_ERR(dev_opp));
961 /* Make sure there are no concurrent readers while updating dev_opp */
962 WARN_ON(!list_empty(&dev_opp->opp_list));
964 if (!dev_opp->supported_hw) {
965 dev_err(dev, "%s: Doesn't have supported hardware list\n",
970 kfree(dev_opp->supported_hw);
971 dev_opp->supported_hw = NULL;
972 dev_opp->supported_hw_count = 0;
974 /* Try freeing device_opp if this was the last blocking resource */
975 _remove_device_opp(dev_opp);
978 mutex_unlock(&dev_opp_list_lock);
980 EXPORT_SYMBOL_GPL(dev_pm_opp_put_supported_hw);
983 * dev_pm_opp_set_prop_name() - Set prop-extn name
984 * @dev: Device for which the regulator has to be set.
985 * @name: name to postfix to properties.
987 * This is required only for the V2 bindings, and it enables a platform to
988 * specify the extn to be used for certain property names. The properties to
989 * which the extension will apply are opp-microvolt and opp-microamp. OPP core
990 * should postfix the property name with -<name> while looking for them.
992 * Locking: The internal device_opp and opp structures are RCU protected.
993 * Hence this function internally uses RCU updater strategy with mutex locks
994 * to keep the integrity of the internal data structures. Callers should ensure
995 * that this function is *NOT* called under RCU protection or in contexts where
996 * mutex cannot be locked.
998 int dev_pm_opp_set_prop_name(struct device *dev, const char *name)
1000 struct device_opp *dev_opp;
1003 /* Hold our list modification lock here */
1004 mutex_lock(&dev_opp_list_lock);
1006 dev_opp = _add_device_opp(dev);
1012 /* Make sure there are no concurrent readers while updating dev_opp */
1013 WARN_ON(!list_empty(&dev_opp->opp_list));
1015 /* Do we already have a prop-name associated with dev_opp? */
1016 if (dev_opp->prop_name) {
1017 dev_err(dev, "%s: Already have prop-name %s\n", __func__,
1018 dev_opp->prop_name);
1023 dev_opp->prop_name = kstrdup(name, GFP_KERNEL);
1024 if (!dev_opp->prop_name) {
1029 mutex_unlock(&dev_opp_list_lock);
1033 _remove_device_opp(dev_opp);
1035 mutex_unlock(&dev_opp_list_lock);
1039 EXPORT_SYMBOL_GPL(dev_pm_opp_set_prop_name);
1042 * dev_pm_opp_put_prop_name() - Releases resources blocked for prop-name
1043 * @dev: Device for which the regulator has to be set.
1045 * This is required only for the V2 bindings, and is called for a matching
1046 * dev_pm_opp_set_prop_name(). Until this is called, the device_opp structure
1047 * will not be freed.
1049 * Locking: The internal device_opp and opp structures are RCU protected.
1050 * Hence this function internally uses RCU updater strategy with mutex locks
1051 * to keep the integrity of the internal data structures. Callers should ensure
1052 * that this function is *NOT* called under RCU protection or in contexts where
1053 * mutex cannot be locked.
1055 void dev_pm_opp_put_prop_name(struct device *dev)
1057 struct device_opp *dev_opp;
1059 /* Hold our list modification lock here */
1060 mutex_lock(&dev_opp_list_lock);
1062 /* Check for existing list for 'dev' first */
1063 dev_opp = _find_device_opp(dev);
1064 if (IS_ERR(dev_opp)) {
1065 dev_err(dev, "Failed to find dev_opp: %ld\n", PTR_ERR(dev_opp));
1069 /* Make sure there are no concurrent readers while updating dev_opp */
1070 WARN_ON(!list_empty(&dev_opp->opp_list));
1072 if (!dev_opp->prop_name) {
1073 dev_err(dev, "%s: Doesn't have a prop-name\n", __func__);
1077 kfree(dev_opp->prop_name);
1078 dev_opp->prop_name = NULL;
1080 /* Try freeing device_opp if this was the last blocking resource */
1081 _remove_device_opp(dev_opp);
1084 mutex_unlock(&dev_opp_list_lock);
1086 EXPORT_SYMBOL_GPL(dev_pm_opp_put_prop_name);
1088 static bool _opp_is_supported(struct device *dev, struct device_opp *dev_opp,
1089 struct device_node *np)
1091 unsigned int count = dev_opp->supported_hw_count;
1095 if (!dev_opp->supported_hw)
1099 ret = of_property_read_u32_index(np, "opp-supported-hw", count,
1102 dev_warn(dev, "%s: failed to read opp-supported-hw property at index %d: %d\n",
1103 __func__, count, ret);
1107 /* Both of these are bitwise masks of the versions */
1108 if (!(version & dev_opp->supported_hw[count]))
1116 * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)
1117 * @dev: device for which we do this operation
1120 * This function adds an opp definition to the opp list and returns status. The
1121 * opp can be controlled using dev_pm_opp_enable/disable functions and may be
1122 * removed by dev_pm_opp_remove.
1124 * Locking: The internal device_opp and opp structures are RCU protected.
1125 * Hence this function internally uses RCU updater strategy with mutex locks
1126 * to keep the integrity of the internal data structures. Callers should ensure
1127 * that this function is *NOT* called under RCU protection or in contexts where
1128 * mutex cannot be locked.
1132 * Duplicate OPPs (both freq and volt are same) and opp->available
1133 * -EEXIST Freq are same and volt are different OR
1134 * Duplicate OPPs (both freq and volt are same) and !opp->available
1135 * -ENOMEM Memory allocation failure
1136 * -EINVAL Failed parsing the OPP node
1138 static int _opp_add_static_v2(struct device *dev, struct device_node *np)
1140 struct device_opp *dev_opp;
1141 struct dev_pm_opp *new_opp;
1146 /* Hold our list modification lock here */
1147 mutex_lock(&dev_opp_list_lock);
1149 new_opp = _allocate_opp(dev, &dev_opp);
1155 ret = of_property_read_u64(np, "opp-hz", &rate);
1157 dev_err(dev, "%s: opp-hz not found\n", __func__);
1161 /* Check if the OPP supports hardware's hierarchy of versions or not */
1162 if (!_opp_is_supported(dev, dev_opp, np)) {
1163 dev_dbg(dev, "OPP not supported by hardware: %llu\n", rate);
1168 * Rate is defined as an unsigned long in clk API, and so casting
1169 * explicitly to its type. Must be fixed once rate is 64 bit
1170 * guaranteed in clk API.
1172 new_opp->rate = (unsigned long)rate;
1173 new_opp->turbo = of_property_read_bool(np, "turbo-mode");
1176 new_opp->dynamic = false;
1177 new_opp->available = true;
1179 if (!of_property_read_u32(np, "clock-latency-ns", &val))
1180 new_opp->clock_latency_ns = val;
1182 ret = opp_parse_supplies(new_opp, dev, dev_opp);
1186 ret = _opp_add(dev, new_opp, dev_opp);
1190 /* OPP to select on device suspend */
1191 if (of_property_read_bool(np, "opp-suspend")) {
1192 if (dev_opp->suspend_opp) {
1193 dev_warn(dev, "%s: Multiple suspend OPPs found (%lu %lu)\n",
1194 __func__, dev_opp->suspend_opp->rate,
1197 new_opp->suspend = true;
1198 dev_opp->suspend_opp = new_opp;
1202 if (new_opp->clock_latency_ns > dev_opp->clock_latency_ns_max)
1203 dev_opp->clock_latency_ns_max = new_opp->clock_latency_ns;
1205 mutex_unlock(&dev_opp_list_lock);
1207 pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu\n",
1208 __func__, new_opp->turbo, new_opp->rate, new_opp->u_volt,
1209 new_opp->u_volt_min, new_opp->u_volt_max,
1210 new_opp->clock_latency_ns);
1213 * Notify the changes in the availability of the operable
1214 * frequency/voltage list.
1216 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
1220 _opp_remove(dev_opp, new_opp, false);
1222 mutex_unlock(&dev_opp_list_lock);
1227 * dev_pm_opp_add() - Add an OPP table from a table definitions
1228 * @dev: device for which we do this operation
1229 * @freq: Frequency in Hz for this OPP
1230 * @u_volt: Voltage in uVolts for this OPP
1232 * This function adds an opp definition to the opp list and returns status.
1233 * The opp is made available by default and it can be controlled using
1234 * dev_pm_opp_enable/disable functions.
1236 * Locking: The internal device_opp and opp structures are RCU protected.
1237 * Hence this function internally uses RCU updater strategy with mutex locks
1238 * to keep the integrity of the internal data structures. Callers should ensure
1239 * that this function is *NOT* called under RCU protection or in contexts where
1240 * mutex cannot be locked.
1244 * Duplicate OPPs (both freq and volt are same) and opp->available
1245 * -EEXIST Freq are same and volt are different OR
1246 * Duplicate OPPs (both freq and volt are same) and !opp->available
1247 * -ENOMEM Memory allocation failure
1249 int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
1251 return _opp_add_v1(dev, freq, u_volt, true);
1253 EXPORT_SYMBOL_GPL(dev_pm_opp_add);
1256 * _opp_set_availability() - helper to set the availability of an opp
1257 * @dev: device for which we do this operation
1258 * @freq: OPP frequency to modify availability
1259 * @availability_req: availability status requested for this opp
1261 * Set the availability of an OPP with an RCU operation, opp_{enable,disable}
1262 * share a common logic which is isolated here.
1264 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1265 * copy operation, returns 0 if no modification was done OR modification was
1268 * Locking: The internal device_opp and opp structures are RCU protected.
1269 * Hence this function internally uses RCU updater strategy with mutex locks to
1270 * keep the integrity of the internal data structures. Callers should ensure
1271 * that this function is *NOT* called under RCU protection or in contexts where
1272 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1274 static int _opp_set_availability(struct device *dev, unsigned long freq,
1275 bool availability_req)
1277 struct device_opp *dev_opp;
1278 struct dev_pm_opp *new_opp, *tmp_opp, *opp = ERR_PTR(-ENODEV);
1281 /* keep the node allocated */
1282 new_opp = kmalloc(sizeof(*new_opp), GFP_KERNEL);
1286 mutex_lock(&dev_opp_list_lock);
1288 /* Find the device_opp */
1289 dev_opp = _find_device_opp(dev);
1290 if (IS_ERR(dev_opp)) {
1291 r = PTR_ERR(dev_opp);
1292 dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);
1296 /* Do we have the frequency? */
1297 list_for_each_entry(tmp_opp, &dev_opp->opp_list, node) {
1298 if (tmp_opp->rate == freq) {
1308 /* Is update really needed? */
1309 if (opp->available == availability_req)
1311 /* copy the old data over */
1314 /* plug in new node */
1315 new_opp->available = availability_req;
1317 list_replace_rcu(&opp->node, &new_opp->node);
1318 mutex_unlock(&dev_opp_list_lock);
1319 call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);
1321 /* Notify the change of the OPP availability */
1322 if (availability_req)
1323 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ENABLE,
1326 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_DISABLE,
1332 mutex_unlock(&dev_opp_list_lock);
1338 * dev_pm_opp_enable() - Enable a specific OPP
1339 * @dev: device for which we do this operation
1340 * @freq: OPP frequency to enable
1342 * Enables a provided opp. If the operation is valid, this returns 0, else the
1343 * corresponding error value. It is meant to be used for users an OPP available
1344 * after being temporarily made unavailable with dev_pm_opp_disable.
1346 * Locking: The internal device_opp and opp structures are RCU protected.
1347 * Hence this function indirectly uses RCU and mutex locks to keep the
1348 * integrity of the internal data structures. Callers should ensure that
1349 * this function is *NOT* called under RCU protection or in contexts where
1350 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1352 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1353 * copy operation, returns 0 if no modification was done OR modification was
1356 int dev_pm_opp_enable(struct device *dev, unsigned long freq)
1358 return _opp_set_availability(dev, freq, true);
1360 EXPORT_SYMBOL_GPL(dev_pm_opp_enable);
1363 * dev_pm_opp_disable() - Disable a specific OPP
1364 * @dev: device for which we do this operation
1365 * @freq: OPP frequency to disable
1367 * Disables a provided opp. If the operation is valid, this returns
1368 * 0, else the corresponding error value. It is meant to be a temporary
1369 * control by users to make this OPP not available until the circumstances are
1370 * right to make it available again (with a call to dev_pm_opp_enable).
1372 * Locking: The internal device_opp and opp structures are RCU protected.
1373 * Hence this function indirectly uses RCU and mutex locks to keep the
1374 * integrity of the internal data structures. Callers should ensure that
1375 * this function is *NOT* called under RCU protection or in contexts where
1376 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1378 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1379 * copy operation, returns 0 if no modification was done OR modification was
1382 int dev_pm_opp_disable(struct device *dev, unsigned long freq)
1384 return _opp_set_availability(dev, freq, false);
1386 EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
1389 * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
1390 * @dev: device pointer used to lookup device OPPs.
1392 * Return: pointer to notifier head if found, otherwise -ENODEV or
1393 * -EINVAL based on type of error casted as pointer. value must be checked
1394 * with IS_ERR to determine valid pointer or error result.
1396 * Locking: This function must be called under rcu_read_lock(). dev_opp is a RCU
1397 * protected pointer. The reason for the same is that the opp pointer which is
1398 * returned will remain valid for use with opp_get_{voltage, freq} only while
1399 * under the locked area. The pointer returned must be used prior to unlocking
1400 * with rcu_read_unlock() to maintain the integrity of the pointer.
1402 struct srcu_notifier_head *dev_pm_opp_get_notifier(struct device *dev)
1404 struct device_opp *dev_opp = _find_device_opp(dev);
1406 if (IS_ERR(dev_opp))
1407 return ERR_CAST(dev_opp); /* matching type */
1409 return &dev_opp->srcu_head;
1411 EXPORT_SYMBOL_GPL(dev_pm_opp_get_notifier);
1415 * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT
1417 * @dev: device pointer used to lookup device OPPs.
1419 * Free OPPs created using static entries present in DT.
1421 * Locking: The internal device_opp and opp structures are RCU protected.
1422 * Hence this function indirectly uses RCU updater strategy with mutex locks
1423 * to keep the integrity of the internal data structures. Callers should ensure
1424 * that this function is *NOT* called under RCU protection or in contexts where
1425 * mutex cannot be locked.
1427 void dev_pm_opp_of_remove_table(struct device *dev)
1429 struct device_opp *dev_opp;
1430 struct dev_pm_opp *opp, *tmp;
1432 /* Hold our list modification lock here */
1433 mutex_lock(&dev_opp_list_lock);
1435 /* Check for existing list for 'dev' */
1436 dev_opp = _find_device_opp(dev);
1437 if (IS_ERR(dev_opp)) {
1438 int error = PTR_ERR(dev_opp);
1440 if (error != -ENODEV)
1441 WARN(1, "%s: dev_opp: %d\n",
1442 IS_ERR_OR_NULL(dev) ?
1443 "Invalid device" : dev_name(dev),
1448 /* Find if dev_opp manages a single device */
1449 if (list_is_singular(&dev_opp->dev_list)) {
1450 /* Free static OPPs */
1451 list_for_each_entry_safe(opp, tmp, &dev_opp->opp_list, node) {
1453 _opp_remove(dev_opp, opp, true);
1456 _remove_list_dev(_find_list_dev(dev, dev_opp), dev_opp);
1460 mutex_unlock(&dev_opp_list_lock);
1462 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table);
1464 /* Returns opp descriptor node for a device, caller must do of_node_put() */
1465 struct device_node *_of_get_opp_desc_node(struct device *dev)
1468 * TODO: Support for multiple OPP tables.
1470 * There should be only ONE phandle present in "operating-points-v2"
1474 return of_parse_phandle(dev->of_node, "operating-points-v2", 0);
1477 /* Initializes OPP tables based on new bindings */
1478 static int _of_add_opp_table_v2(struct device *dev, struct device_node *opp_np)
1480 struct device_node *np;
1481 struct device_opp *dev_opp;
1482 int ret = 0, count = 0;
1484 mutex_lock(&dev_opp_list_lock);
1486 dev_opp = _managed_opp(opp_np);
1488 /* OPPs are already managed */
1489 if (!_add_list_dev(dev, dev_opp))
1491 mutex_unlock(&dev_opp_list_lock);
1494 mutex_unlock(&dev_opp_list_lock);
1496 /* We have opp-list node now, iterate over it and add OPPs */
1497 for_each_available_child_of_node(opp_np, np) {
1500 ret = _opp_add_static_v2(dev, np);
1502 dev_err(dev, "%s: Failed to add OPP, %d\n", __func__,
1508 /* There should be one of more OPP defined */
1509 if (WARN_ON(!count))
1512 mutex_lock(&dev_opp_list_lock);
1514 dev_opp = _find_device_opp(dev);
1515 if (WARN_ON(IS_ERR(dev_opp))) {
1516 ret = PTR_ERR(dev_opp);
1517 mutex_unlock(&dev_opp_list_lock);
1521 dev_opp->np = opp_np;
1522 dev_opp->shared_opp = of_property_read_bool(opp_np, "opp-shared");
1524 mutex_unlock(&dev_opp_list_lock);
1529 dev_pm_opp_of_remove_table(dev);
1534 /* Initializes OPP tables based on old-deprecated bindings */
1535 static int _of_add_opp_table_v1(struct device *dev)
1537 const struct property *prop;
1541 prop = of_find_property(dev->of_node, "operating-points", NULL);
1548 * Each OPP is a set of tuples consisting of frequency and
1549 * voltage like <freq-kHz vol-uV>.
1551 nr = prop->length / sizeof(u32);
1553 dev_err(dev, "%s: Invalid OPP list\n", __func__);
1559 unsigned long freq = be32_to_cpup(val++) * 1000;
1560 unsigned long volt = be32_to_cpup(val++);
1562 if (_opp_add_v1(dev, freq, volt, false))
1563 dev_warn(dev, "%s: Failed to add OPP %ld\n",
1572 * dev_pm_opp_of_add_table() - Initialize opp table from device tree
1573 * @dev: device pointer used to lookup device OPPs.
1575 * Register the initial OPP table with the OPP library for given device.
1577 * Locking: The internal device_opp and opp structures are RCU protected.
1578 * Hence this function indirectly uses RCU updater strategy with mutex locks
1579 * to keep the integrity of the internal data structures. Callers should ensure
1580 * that this function is *NOT* called under RCU protection or in contexts where
1581 * mutex cannot be locked.
1585 * Duplicate OPPs (both freq and volt are same) and opp->available
1586 * -EEXIST Freq are same and volt are different OR
1587 * Duplicate OPPs (both freq and volt are same) and !opp->available
1588 * -ENOMEM Memory allocation failure
1589 * -ENODEV when 'operating-points' property is not found or is invalid data
1591 * -ENODATA when empty 'operating-points' property is found
1592 * -EINVAL when invalid entries are found in opp-v2 table
1594 int dev_pm_opp_of_add_table(struct device *dev)
1596 struct device_node *opp_np;
1600 * OPPs have two version of bindings now. The older one is deprecated,
1601 * try for the new binding first.
1603 opp_np = _of_get_opp_desc_node(dev);
1606 * Try old-deprecated bindings for backward compatibility with
1609 return _of_add_opp_table_v1(dev);
1612 ret = _of_add_opp_table_v2(dev, opp_np);
1613 of_node_put(opp_np);
1617 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);