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 list_dev = list_first_entry(&dev_opp->dev_list, struct device_list_opp,
568 _remove_list_dev(list_dev, dev_opp);
570 /* dev_list must be empty now */
571 WARN_ON(!list_empty(&dev_opp->dev_list));
573 list_del_rcu(&dev_opp->node);
574 call_srcu(&dev_opp->srcu_head.srcu, &dev_opp->rcu_head,
579 * _kfree_opp_rcu() - Free OPP RCU handler
582 static void _kfree_opp_rcu(struct rcu_head *head)
584 struct dev_pm_opp *opp = container_of(head, struct dev_pm_opp, rcu_head);
586 kfree_rcu(opp, rcu_head);
590 * _opp_remove() - Remove an OPP from a table definition
591 * @dev_opp: points back to the device_opp struct this opp belongs to
592 * @opp: pointer to the OPP to remove
593 * @notify: OPP_EVENT_REMOVE notification should be sent or not
595 * This function removes an opp definition from the opp list.
597 * Locking: The internal device_opp and opp structures are RCU protected.
598 * It is assumed that the caller holds required mutex for an RCU updater
601 static void _opp_remove(struct device_opp *dev_opp,
602 struct dev_pm_opp *opp, bool notify)
605 * Notify the changes in the availability of the operable
606 * frequency/voltage list.
609 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_REMOVE, opp);
610 opp_debug_remove_one(opp);
611 list_del_rcu(&opp->node);
612 call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);
614 _remove_device_opp(dev_opp);
618 * dev_pm_opp_remove() - Remove an OPP from OPP list
619 * @dev: device for which we do this operation
620 * @freq: OPP to remove with matching 'freq'
622 * This function removes an opp from the opp list.
624 * Locking: The internal device_opp and opp structures are RCU protected.
625 * Hence this function internally uses RCU updater strategy with mutex locks
626 * to keep the integrity of the internal data structures. Callers should ensure
627 * that this function is *NOT* called under RCU protection or in contexts where
628 * mutex cannot be locked.
630 void dev_pm_opp_remove(struct device *dev, unsigned long freq)
632 struct dev_pm_opp *opp;
633 struct device_opp *dev_opp;
636 /* Hold our list modification lock here */
637 mutex_lock(&dev_opp_list_lock);
639 dev_opp = _find_device_opp(dev);
643 list_for_each_entry(opp, &dev_opp->opp_list, node) {
644 if (opp->rate == freq) {
651 dev_warn(dev, "%s: Couldn't find OPP with freq: %lu\n",
656 _opp_remove(dev_opp, opp, true);
658 mutex_unlock(&dev_opp_list_lock);
660 EXPORT_SYMBOL_GPL(dev_pm_opp_remove);
662 static struct dev_pm_opp *_allocate_opp(struct device *dev,
663 struct device_opp **dev_opp)
665 struct dev_pm_opp *opp;
667 /* allocate new OPP node */
668 opp = kzalloc(sizeof(*opp), GFP_KERNEL);
672 INIT_LIST_HEAD(&opp->node);
674 *dev_opp = _add_device_opp(dev);
683 static int _opp_add(struct device *dev, struct dev_pm_opp *new_opp,
684 struct device_opp *dev_opp)
686 struct dev_pm_opp *opp;
687 struct list_head *head = &dev_opp->opp_list;
691 * Insert new OPP in order of increasing frequency and discard if
694 * Need to use &dev_opp->opp_list in the condition part of the 'for'
695 * loop, don't replace it with head otherwise it will become an infinite
698 list_for_each_entry_rcu(opp, &dev_opp->opp_list, node) {
699 if (new_opp->rate > opp->rate) {
704 if (new_opp->rate < opp->rate)
708 dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
709 __func__, opp->rate, opp->u_volt, opp->available,
710 new_opp->rate, new_opp->u_volt, new_opp->available);
712 return opp->available && new_opp->u_volt == opp->u_volt ?
716 new_opp->dev_opp = dev_opp;
717 list_add_rcu(&new_opp->node, head);
719 ret = opp_debug_create_one(new_opp, dev_opp);
721 dev_err(dev, "%s: Failed to register opp to debugfs (%d)\n",
728 * _opp_add_v1() - Allocate a OPP based on v1 bindings.
729 * @dev: device for which we do this operation
730 * @freq: Frequency in Hz for this OPP
731 * @u_volt: Voltage in uVolts for this OPP
732 * @dynamic: Dynamically added OPPs.
734 * This function adds an opp definition to the opp list and returns status.
735 * The opp is made available by default and it can be controlled using
736 * dev_pm_opp_enable/disable functions and may be removed by dev_pm_opp_remove.
738 * NOTE: "dynamic" parameter impacts OPPs added by the dev_pm_opp_of_add_table
739 * and freed by dev_pm_opp_of_remove_table.
741 * Locking: The internal device_opp and opp structures are RCU protected.
742 * Hence this function internally uses RCU updater strategy with mutex locks
743 * to keep the integrity of the internal data structures. Callers should ensure
744 * that this function is *NOT* called under RCU protection or in contexts where
745 * mutex cannot be locked.
749 * Duplicate OPPs (both freq and volt are same) and opp->available
750 * -EEXIST Freq are same and volt are different OR
751 * Duplicate OPPs (both freq and volt are same) and !opp->available
752 * -ENOMEM Memory allocation failure
754 static int _opp_add_v1(struct device *dev, unsigned long freq, long u_volt,
757 struct device_opp *dev_opp;
758 struct dev_pm_opp *new_opp;
761 /* Hold our list modification lock here */
762 mutex_lock(&dev_opp_list_lock);
764 new_opp = _allocate_opp(dev, &dev_opp);
770 /* populate the opp table */
771 new_opp->rate = freq;
772 new_opp->u_volt = u_volt;
773 new_opp->available = true;
774 new_opp->dynamic = dynamic;
776 ret = _opp_add(dev, new_opp, dev_opp);
780 mutex_unlock(&dev_opp_list_lock);
783 * Notify the changes in the availability of the operable
784 * frequency/voltage list.
786 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
790 _opp_remove(dev_opp, new_opp, false);
792 mutex_unlock(&dev_opp_list_lock);
796 /* TODO: Support multiple regulators */
797 static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev)
799 u32 microvolt[3] = {0};
803 /* Missing property isn't a problem, but an invalid entry is */
804 if (!of_find_property(opp->np, "opp-microvolt", NULL))
807 count = of_property_count_u32_elems(opp->np, "opp-microvolt");
809 dev_err(dev, "%s: Invalid opp-microvolt property (%d)\n",
814 /* There can be one or three elements here */
815 if (count != 1 && count != 3) {
816 dev_err(dev, "%s: Invalid number of elements in opp-microvolt property (%d)\n",
821 ret = of_property_read_u32_array(opp->np, "opp-microvolt", microvolt,
824 dev_err(dev, "%s: error parsing opp-microvolt: %d\n", __func__,
829 opp->u_volt = microvolt[0];
830 opp->u_volt_min = microvolt[1];
831 opp->u_volt_max = microvolt[2];
833 if (!of_property_read_u32(opp->np, "opp-microamp", &val))
840 * dev_pm_opp_set_supported_hw() - Set supported platforms
841 * @dev: Device for which supported-hw has to be set.
842 * @versions: Array of hierarchy of versions to match.
843 * @count: Number of elements in the array.
845 * This is required only for the V2 bindings, and it enables a platform to
846 * specify the hierarchy of versions it supports. OPP layer will then enable
847 * OPPs, which are available for those versions, based on its 'opp-supported-hw'
850 * Locking: The internal device_opp and opp structures are RCU protected.
851 * Hence this function internally uses RCU updater strategy with mutex locks
852 * to keep the integrity of the internal data structures. Callers should ensure
853 * that this function is *NOT* called under RCU protection or in contexts where
854 * mutex cannot be locked.
856 int dev_pm_opp_set_supported_hw(struct device *dev, const u32 *versions,
859 struct device_opp *dev_opp;
862 /* Hold our list modification lock here */
863 mutex_lock(&dev_opp_list_lock);
865 dev_opp = _add_device_opp(dev);
871 /* Make sure there are no concurrent readers while updating dev_opp */
872 WARN_ON(!list_empty(&dev_opp->opp_list));
874 /* Do we already have a version hierarchy associated with dev_opp? */
875 if (dev_opp->supported_hw) {
876 dev_err(dev, "%s: Already have supported hardware list\n",
882 dev_opp->supported_hw = kmemdup(versions, count * sizeof(*versions),
884 if (!dev_opp->supported_hw) {
889 dev_opp->supported_hw_count = count;
890 mutex_unlock(&dev_opp_list_lock);
894 _remove_device_opp(dev_opp);
896 mutex_unlock(&dev_opp_list_lock);
900 EXPORT_SYMBOL_GPL(dev_pm_opp_set_supported_hw);
903 * dev_pm_opp_put_supported_hw() - Releases resources blocked for supported hw
904 * @dev: Device for which supported-hw has to be set.
906 * This is required only for the V2 bindings, and is called for a matching
907 * dev_pm_opp_set_supported_hw(). Until this is called, the device_opp structure
910 * Locking: The internal device_opp and opp structures are RCU protected.
911 * Hence this function internally uses RCU updater strategy with mutex locks
912 * to keep the integrity of the internal data structures. Callers should ensure
913 * that this function is *NOT* called under RCU protection or in contexts where
914 * mutex cannot be locked.
916 void dev_pm_opp_put_supported_hw(struct device *dev)
918 struct device_opp *dev_opp;
920 /* Hold our list modification lock here */
921 mutex_lock(&dev_opp_list_lock);
923 /* Check for existing list for 'dev' first */
924 dev_opp = _find_device_opp(dev);
925 if (IS_ERR(dev_opp)) {
926 dev_err(dev, "Failed to find dev_opp: %ld\n", PTR_ERR(dev_opp));
930 /* Make sure there are no concurrent readers while updating dev_opp */
931 WARN_ON(!list_empty(&dev_opp->opp_list));
933 if (!dev_opp->supported_hw) {
934 dev_err(dev, "%s: Doesn't have supported hardware list\n",
939 kfree(dev_opp->supported_hw);
940 dev_opp->supported_hw = NULL;
941 dev_opp->supported_hw_count = 0;
943 /* Try freeing device_opp if this was the last blocking resource */
944 _remove_device_opp(dev_opp);
947 mutex_unlock(&dev_opp_list_lock);
949 EXPORT_SYMBOL_GPL(dev_pm_opp_put_supported_hw);
951 static bool _opp_is_supported(struct device *dev, struct device_opp *dev_opp,
952 struct device_node *np)
954 unsigned int count = dev_opp->supported_hw_count;
958 if (!dev_opp->supported_hw)
962 ret = of_property_read_u32_index(np, "opp-supported-hw", count,
965 dev_warn(dev, "%s: failed to read opp-supported-hw property at index %d: %d\n",
966 __func__, count, ret);
970 /* Both of these are bitwise masks of the versions */
971 if (!(version & dev_opp->supported_hw[count]))
979 * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)
980 * @dev: device for which we do this operation
983 * This function adds an opp definition to the opp list and returns status. The
984 * opp can be controlled using dev_pm_opp_enable/disable functions and may be
985 * removed by dev_pm_opp_remove.
987 * Locking: The internal device_opp and opp structures are RCU protected.
988 * Hence this function internally uses RCU updater strategy with mutex locks
989 * to keep the integrity of the internal data structures. Callers should ensure
990 * that this function is *NOT* called under RCU protection or in contexts where
991 * mutex cannot be locked.
995 * Duplicate OPPs (both freq and volt are same) and opp->available
996 * -EEXIST Freq are same and volt are different OR
997 * Duplicate OPPs (both freq and volt are same) and !opp->available
998 * -ENOMEM Memory allocation failure
999 * -EINVAL Failed parsing the OPP node
1001 static int _opp_add_static_v2(struct device *dev, struct device_node *np)
1003 struct device_opp *dev_opp;
1004 struct dev_pm_opp *new_opp;
1009 /* Hold our list modification lock here */
1010 mutex_lock(&dev_opp_list_lock);
1012 new_opp = _allocate_opp(dev, &dev_opp);
1018 ret = of_property_read_u64(np, "opp-hz", &rate);
1020 dev_err(dev, "%s: opp-hz not found\n", __func__);
1024 /* Check if the OPP supports hardware's hierarchy of versions or not */
1025 if (!_opp_is_supported(dev, dev_opp, np)) {
1026 dev_dbg(dev, "OPP not supported by hardware: %llu\n", rate);
1031 * Rate is defined as an unsigned long in clk API, and so casting
1032 * explicitly to its type. Must be fixed once rate is 64 bit
1033 * guaranteed in clk API.
1035 new_opp->rate = (unsigned long)rate;
1036 new_opp->turbo = of_property_read_bool(np, "turbo-mode");
1039 new_opp->dynamic = false;
1040 new_opp->available = true;
1042 if (!of_property_read_u32(np, "clock-latency-ns", &val))
1043 new_opp->clock_latency_ns = val;
1045 ret = opp_parse_supplies(new_opp, dev);
1049 ret = _opp_add(dev, new_opp, dev_opp);
1053 /* OPP to select on device suspend */
1054 if (of_property_read_bool(np, "opp-suspend")) {
1055 if (dev_opp->suspend_opp) {
1056 dev_warn(dev, "%s: Multiple suspend OPPs found (%lu %lu)\n",
1057 __func__, dev_opp->suspend_opp->rate,
1060 new_opp->suspend = true;
1061 dev_opp->suspend_opp = new_opp;
1065 if (new_opp->clock_latency_ns > dev_opp->clock_latency_ns_max)
1066 dev_opp->clock_latency_ns_max = new_opp->clock_latency_ns;
1068 mutex_unlock(&dev_opp_list_lock);
1070 pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu\n",
1071 __func__, new_opp->turbo, new_opp->rate, new_opp->u_volt,
1072 new_opp->u_volt_min, new_opp->u_volt_max,
1073 new_opp->clock_latency_ns);
1076 * Notify the changes in the availability of the operable
1077 * frequency/voltage list.
1079 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
1083 _opp_remove(dev_opp, new_opp, false);
1085 mutex_unlock(&dev_opp_list_lock);
1090 * dev_pm_opp_add() - Add an OPP table from a table definitions
1091 * @dev: device for which we do this operation
1092 * @freq: Frequency in Hz for this OPP
1093 * @u_volt: Voltage in uVolts for this OPP
1095 * This function adds an opp definition to the opp list and returns status.
1096 * The opp is made available by default and it can be controlled using
1097 * dev_pm_opp_enable/disable functions.
1099 * Locking: The internal device_opp and opp structures are RCU protected.
1100 * Hence this function internally uses RCU updater strategy with mutex locks
1101 * to keep the integrity of the internal data structures. Callers should ensure
1102 * that this function is *NOT* called under RCU protection or in contexts where
1103 * mutex cannot be locked.
1107 * Duplicate OPPs (both freq and volt are same) and opp->available
1108 * -EEXIST Freq are same and volt are different OR
1109 * Duplicate OPPs (both freq and volt are same) and !opp->available
1110 * -ENOMEM Memory allocation failure
1112 int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
1114 return _opp_add_v1(dev, freq, u_volt, true);
1116 EXPORT_SYMBOL_GPL(dev_pm_opp_add);
1119 * _opp_set_availability() - helper to set the availability of an opp
1120 * @dev: device for which we do this operation
1121 * @freq: OPP frequency to modify availability
1122 * @availability_req: availability status requested for this opp
1124 * Set the availability of an OPP with an RCU operation, opp_{enable,disable}
1125 * share a common logic which is isolated here.
1127 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1128 * copy operation, returns 0 if no modification was done OR modification was
1131 * Locking: The internal device_opp and opp structures are RCU protected.
1132 * Hence this function internally uses RCU updater strategy with mutex locks to
1133 * keep the integrity of the internal data structures. Callers should ensure
1134 * that this function is *NOT* called under RCU protection or in contexts where
1135 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1137 static int _opp_set_availability(struct device *dev, unsigned long freq,
1138 bool availability_req)
1140 struct device_opp *dev_opp;
1141 struct dev_pm_opp *new_opp, *tmp_opp, *opp = ERR_PTR(-ENODEV);
1144 /* keep the node allocated */
1145 new_opp = kmalloc(sizeof(*new_opp), GFP_KERNEL);
1149 mutex_lock(&dev_opp_list_lock);
1151 /* Find the device_opp */
1152 dev_opp = _find_device_opp(dev);
1153 if (IS_ERR(dev_opp)) {
1154 r = PTR_ERR(dev_opp);
1155 dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);
1159 /* Do we have the frequency? */
1160 list_for_each_entry(tmp_opp, &dev_opp->opp_list, node) {
1161 if (tmp_opp->rate == freq) {
1171 /* Is update really needed? */
1172 if (opp->available == availability_req)
1174 /* copy the old data over */
1177 /* plug in new node */
1178 new_opp->available = availability_req;
1180 list_replace_rcu(&opp->node, &new_opp->node);
1181 mutex_unlock(&dev_opp_list_lock);
1182 call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);
1184 /* Notify the change of the OPP availability */
1185 if (availability_req)
1186 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ENABLE,
1189 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_DISABLE,
1195 mutex_unlock(&dev_opp_list_lock);
1201 * dev_pm_opp_enable() - Enable a specific OPP
1202 * @dev: device for which we do this operation
1203 * @freq: OPP frequency to enable
1205 * Enables a provided opp. If the operation is valid, this returns 0, else the
1206 * corresponding error value. It is meant to be used for users an OPP available
1207 * after being temporarily made unavailable with dev_pm_opp_disable.
1209 * Locking: The internal device_opp and opp structures are RCU protected.
1210 * Hence this function indirectly uses RCU and mutex locks to keep the
1211 * integrity of the internal data structures. Callers should ensure that
1212 * this function is *NOT* called under RCU protection or in contexts where
1213 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1215 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1216 * copy operation, returns 0 if no modification was done OR modification was
1219 int dev_pm_opp_enable(struct device *dev, unsigned long freq)
1221 return _opp_set_availability(dev, freq, true);
1223 EXPORT_SYMBOL_GPL(dev_pm_opp_enable);
1226 * dev_pm_opp_disable() - Disable a specific OPP
1227 * @dev: device for which we do this operation
1228 * @freq: OPP frequency to disable
1230 * Disables a provided opp. If the operation is valid, this returns
1231 * 0, else the corresponding error value. It is meant to be a temporary
1232 * control by users to make this OPP not available until the circumstances are
1233 * right to make it available again (with a call to dev_pm_opp_enable).
1235 * Locking: The internal device_opp and opp structures are RCU protected.
1236 * Hence this function indirectly uses RCU and mutex locks to keep the
1237 * integrity of the internal data structures. Callers should ensure that
1238 * this function is *NOT* called under RCU protection or in contexts where
1239 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1241 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1242 * copy operation, returns 0 if no modification was done OR modification was
1245 int dev_pm_opp_disable(struct device *dev, unsigned long freq)
1247 return _opp_set_availability(dev, freq, false);
1249 EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
1252 * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
1253 * @dev: device pointer used to lookup device OPPs.
1255 * Return: pointer to notifier head if found, otherwise -ENODEV or
1256 * -EINVAL based on type of error casted as pointer. value must be checked
1257 * with IS_ERR to determine valid pointer or error result.
1259 * Locking: This function must be called under rcu_read_lock(). dev_opp is a RCU
1260 * protected pointer. The reason for the same is that the opp pointer which is
1261 * returned will remain valid for use with opp_get_{voltage, freq} only while
1262 * under the locked area. The pointer returned must be used prior to unlocking
1263 * with rcu_read_unlock() to maintain the integrity of the pointer.
1265 struct srcu_notifier_head *dev_pm_opp_get_notifier(struct device *dev)
1267 struct device_opp *dev_opp = _find_device_opp(dev);
1269 if (IS_ERR(dev_opp))
1270 return ERR_CAST(dev_opp); /* matching type */
1272 return &dev_opp->srcu_head;
1274 EXPORT_SYMBOL_GPL(dev_pm_opp_get_notifier);
1278 * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT
1280 * @dev: device pointer used to lookup device OPPs.
1282 * Free OPPs created using static entries present in DT.
1284 * Locking: The internal device_opp and opp structures are RCU protected.
1285 * Hence this function indirectly uses RCU updater strategy with mutex locks
1286 * to keep the integrity of the internal data structures. Callers should ensure
1287 * that this function is *NOT* called under RCU protection or in contexts where
1288 * mutex cannot be locked.
1290 void dev_pm_opp_of_remove_table(struct device *dev)
1292 struct device_opp *dev_opp;
1293 struct dev_pm_opp *opp, *tmp;
1295 /* Hold our list modification lock here */
1296 mutex_lock(&dev_opp_list_lock);
1298 /* Check for existing list for 'dev' */
1299 dev_opp = _find_device_opp(dev);
1300 if (IS_ERR(dev_opp)) {
1301 int error = PTR_ERR(dev_opp);
1303 if (error != -ENODEV)
1304 WARN(1, "%s: dev_opp: %d\n",
1305 IS_ERR_OR_NULL(dev) ?
1306 "Invalid device" : dev_name(dev),
1311 /* Find if dev_opp manages a single device */
1312 if (list_is_singular(&dev_opp->dev_list)) {
1313 /* Free static OPPs */
1314 list_for_each_entry_safe(opp, tmp, &dev_opp->opp_list, node) {
1316 _opp_remove(dev_opp, opp, true);
1319 _remove_list_dev(_find_list_dev(dev, dev_opp), dev_opp);
1323 mutex_unlock(&dev_opp_list_lock);
1325 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table);
1327 /* Returns opp descriptor node for a device, caller must do of_node_put() */
1328 struct device_node *_of_get_opp_desc_node(struct device *dev)
1331 * TODO: Support for multiple OPP tables.
1333 * There should be only ONE phandle present in "operating-points-v2"
1337 return of_parse_phandle(dev->of_node, "operating-points-v2", 0);
1340 /* Initializes OPP tables based on new bindings */
1341 static int _of_add_opp_table_v2(struct device *dev, struct device_node *opp_np)
1343 struct device_node *np;
1344 struct device_opp *dev_opp;
1345 int ret = 0, count = 0;
1347 mutex_lock(&dev_opp_list_lock);
1349 dev_opp = _managed_opp(opp_np);
1351 /* OPPs are already managed */
1352 if (!_add_list_dev(dev, dev_opp))
1354 mutex_unlock(&dev_opp_list_lock);
1357 mutex_unlock(&dev_opp_list_lock);
1359 /* We have opp-list node now, iterate over it and add OPPs */
1360 for_each_available_child_of_node(opp_np, np) {
1363 ret = _opp_add_static_v2(dev, np);
1365 dev_err(dev, "%s: Failed to add OPP, %d\n", __func__,
1371 /* There should be one of more OPP defined */
1372 if (WARN_ON(!count))
1375 mutex_lock(&dev_opp_list_lock);
1377 dev_opp = _find_device_opp(dev);
1378 if (WARN_ON(IS_ERR(dev_opp))) {
1379 ret = PTR_ERR(dev_opp);
1380 mutex_unlock(&dev_opp_list_lock);
1384 dev_opp->np = opp_np;
1385 dev_opp->shared_opp = of_property_read_bool(opp_np, "opp-shared");
1387 mutex_unlock(&dev_opp_list_lock);
1392 dev_pm_opp_of_remove_table(dev);
1397 /* Initializes OPP tables based on old-deprecated bindings */
1398 static int _of_add_opp_table_v1(struct device *dev)
1400 const struct property *prop;
1404 prop = of_find_property(dev->of_node, "operating-points", NULL);
1411 * Each OPP is a set of tuples consisting of frequency and
1412 * voltage like <freq-kHz vol-uV>.
1414 nr = prop->length / sizeof(u32);
1416 dev_err(dev, "%s: Invalid OPP list\n", __func__);
1422 unsigned long freq = be32_to_cpup(val++) * 1000;
1423 unsigned long volt = be32_to_cpup(val++);
1425 if (_opp_add_v1(dev, freq, volt, false))
1426 dev_warn(dev, "%s: Failed to add OPP %ld\n",
1435 * dev_pm_opp_of_add_table() - Initialize opp table from device tree
1436 * @dev: device pointer used to lookup device OPPs.
1438 * Register the initial OPP table with the OPP library for given device.
1440 * Locking: The internal device_opp and opp structures are RCU protected.
1441 * Hence this function indirectly uses RCU updater strategy with mutex locks
1442 * to keep the integrity of the internal data structures. Callers should ensure
1443 * that this function is *NOT* called under RCU protection or in contexts where
1444 * mutex cannot be locked.
1448 * Duplicate OPPs (both freq and volt are same) and opp->available
1449 * -EEXIST Freq are same and volt are different OR
1450 * Duplicate OPPs (both freq and volt are same) and !opp->available
1451 * -ENOMEM Memory allocation failure
1452 * -ENODEV when 'operating-points' property is not found or is invalid data
1454 * -ENODATA when empty 'operating-points' property is found
1455 * -EINVAL when invalid entries are found in opp-v2 table
1457 int dev_pm_opp_of_add_table(struct device *dev)
1459 struct device_node *opp_np;
1463 * OPPs have two version of bindings now. The older one is deprecated,
1464 * try for the new binding first.
1466 opp_np = _of_get_opp_desc_node(dev);
1469 * Try old-deprecated bindings for backward compatibility with
1472 return _of_add_opp_table_v1(dev);
1475 ret = _of_add_opp_table_v2(dev, opp_np);
1476 of_node_put(opp_np);
1480 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);