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 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/err.h>
17 #include <linux/slab.h>
18 #include <linux/device.h>
19 #include <linux/list.h>
20 #include <linux/rculist.h>
21 #include <linux/rcupdate.h>
22 #include <linux/pm_opp.h>
24 #include <linux/export.h>
27 * Internal data structure organization with the OPP layer library is as
30 * |- device 1 (represents voltage domain 1)
31 * | |- opp 1 (availability, freq, voltage)
35 * |- device 2 (represents the next voltage domain)
37 * `- device m (represents mth voltage domain)
38 * device 1, 2.. are represented by dev_opp structure while each opp
39 * is represented by the opp structure.
43 * struct dev_pm_opp - Generic OPP description structure
44 * @node: opp list node. The nodes are maintained throughout the lifetime
45 * of boot. It is expected only an optimal set of OPPs are
46 * added to the library by the SoC framework.
47 * RCU usage: opp list is traversed with RCU locks. node
48 * modification is possible realtime, hence the modifications
49 * are protected by the dev_opp_list_lock for integrity.
50 * IMPORTANT: the opp nodes should be maintained in increasing
52 * @dynamic: not-created from static DT entries.
53 * @available: true/false - marks if this OPP as available or not
54 * @rate: Frequency in hertz
55 * @u_volt: Nominal voltage in microvolts corresponding to this OPP
56 * @dev_opp: points back to the device_opp struct this opp belongs to
57 * @rcu_head: RCU callback head used for deferred freeing
59 * This structure stores the OPP information for a given device.
62 struct list_head node;
69 struct device_opp *dev_opp;
70 struct rcu_head rcu_head;
74 * struct device_opp - Device opp structure
75 * @node: list node - contains the devices with OPPs that
76 * have been registered. Nodes once added are not modified in this
78 * RCU usage: nodes are not modified in the list of device_opp,
79 * however addition is possible and is secured by dev_opp_list_lock
80 * @dev: device pointer
81 * @srcu_head: notifier head to notify the OPP availability changes.
82 * @rcu_head: RCU callback head used for deferred freeing
83 * @opp_list: list of opps
85 * This is an internal data structure maintaining the link to opps attached to
86 * a device. This structure is not meant to be shared to users as it is
87 * meant for book keeping and private to OPP library.
89 * Because the opp structures can be used from both rcu and srcu readers, we
90 * need to wait for the grace period of both of them before freeing any
91 * resources. And so we have used kfree_rcu() from within call_srcu() handlers.
94 struct list_head node;
97 struct srcu_notifier_head srcu_head;
98 struct rcu_head rcu_head;
99 struct list_head opp_list;
103 * The root of the list of all devices. All device_opp structures branch off
104 * from here, with each device_opp containing the list of opp it supports in
105 * various states of availability.
107 static LIST_HEAD(dev_opp_list);
108 /* Lock to allow exclusive modification to the device and opp lists */
109 static DEFINE_MUTEX(dev_opp_list_lock);
112 * find_device_opp() - find device_opp struct using device pointer
113 * @dev: device pointer used to lookup device OPPs
115 * Search list of device OPPs for one containing matching device. Does a RCU
116 * reader operation to grab the pointer needed.
118 * Returns pointer to 'struct device_opp' if found, otherwise -ENODEV or
119 * -EINVAL based on type of error.
121 * Locking: This function must be called under rcu_read_lock(). device_opp
122 * is a RCU protected pointer. This means that device_opp is valid as long
123 * as we are under RCU lock.
125 static struct device_opp *find_device_opp(struct device *dev)
127 struct device_opp *tmp_dev_opp, *dev_opp = ERR_PTR(-ENODEV);
129 if (unlikely(IS_ERR_OR_NULL(dev))) {
130 pr_err("%s: Invalid parameters\n", __func__);
131 return ERR_PTR(-EINVAL);
134 list_for_each_entry_rcu(tmp_dev_opp, &dev_opp_list, node) {
135 if (tmp_dev_opp->dev == dev) {
136 dev_opp = tmp_dev_opp;
145 * dev_pm_opp_get_voltage() - Gets the voltage corresponding to an available opp
146 * @opp: opp for which voltage has to be returned for
148 * Return voltage in micro volt corresponding to the opp, else
151 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
152 * protected pointer. This means that opp which could have been fetched by
153 * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
154 * under RCU lock. The pointer returned by the opp_find_freq family must be
155 * used in the same section as the usage of this function with the pointer
156 * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
159 unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp)
161 struct dev_pm_opp *tmp_opp;
164 tmp_opp = rcu_dereference(opp);
165 if (unlikely(IS_ERR_OR_NULL(tmp_opp)) || !tmp_opp->available)
166 pr_err("%s: Invalid parameters\n", __func__);
172 EXPORT_SYMBOL_GPL(dev_pm_opp_get_voltage);
175 * dev_pm_opp_get_freq() - Gets the frequency corresponding to an available opp
176 * @opp: opp for which frequency has to be returned for
178 * Return frequency in hertz corresponding to the opp, else
181 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
182 * protected pointer. This means that opp which could have been fetched by
183 * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
184 * under RCU lock. The pointer returned by the opp_find_freq family must be
185 * used in the same section as the usage of this function with the pointer
186 * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
189 unsigned long dev_pm_opp_get_freq(struct dev_pm_opp *opp)
191 struct dev_pm_opp *tmp_opp;
194 tmp_opp = rcu_dereference(opp);
195 if (unlikely(IS_ERR_OR_NULL(tmp_opp)) || !tmp_opp->available)
196 pr_err("%s: Invalid parameters\n", __func__);
202 EXPORT_SYMBOL_GPL(dev_pm_opp_get_freq);
205 * dev_pm_opp_get_opp_count() - Get number of opps available in the opp list
206 * @dev: device for which we do this operation
208 * This function returns the number of available opps if there are any,
209 * else returns 0 if none or the corresponding error value.
211 * Locking: This function must be called under rcu_read_lock(). This function
212 * internally references two RCU protected structures: device_opp and opp which
213 * are safe as long as we are under a common RCU locked section.
215 int dev_pm_opp_get_opp_count(struct device *dev)
217 struct device_opp *dev_opp;
218 struct dev_pm_opp *temp_opp;
221 dev_opp = find_device_opp(dev);
222 if (IS_ERR(dev_opp)) {
223 int r = PTR_ERR(dev_opp);
224 dev_err(dev, "%s: device OPP not found (%d)\n", __func__, r);
228 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
229 if (temp_opp->available)
235 EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count);
238 * dev_pm_opp_find_freq_exact() - search for an exact frequency
239 * @dev: device for which we do this operation
240 * @freq: frequency to search for
241 * @available: true/false - match for available opp
243 * Searches for exact match in the opp list and returns pointer to the matching
244 * opp if found, else returns ERR_PTR in case of error and should be handled
245 * using IS_ERR. Error return values can be:
246 * EINVAL: for bad pointer
247 * ERANGE: no match found for search
248 * ENODEV: if device not found in list of registered devices
250 * Note: available is a modifier for the search. if available=true, then the
251 * match is for exact matching frequency and is available in the stored OPP
252 * table. if false, the match is for exact frequency which is not available.
254 * This provides a mechanism to enable an opp which is not available currently
255 * or the opposite as well.
257 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
258 * protected pointer. The reason for the same is that the opp pointer which is
259 * returned will remain valid for use with opp_get_{voltage, freq} only while
260 * under the locked area. The pointer returned must be used prior to unlocking
261 * with rcu_read_unlock() to maintain the integrity of the pointer.
263 struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,
267 struct device_opp *dev_opp;
268 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
270 dev_opp = find_device_opp(dev);
271 if (IS_ERR(dev_opp)) {
272 int r = PTR_ERR(dev_opp);
273 dev_err(dev, "%s: device OPP not found (%d)\n", __func__, r);
277 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
278 if (temp_opp->available == available &&
279 temp_opp->rate == freq) {
287 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact);
290 * dev_pm_opp_find_freq_ceil() - Search for an rounded ceil freq
291 * @dev: device for which we do this operation
292 * @freq: Start frequency
294 * Search for the matching ceil *available* OPP from a starting freq
297 * Returns matching *opp and refreshes *freq accordingly, else returns
298 * ERR_PTR in case of error and should be handled using IS_ERR. Error return
300 * EINVAL: for bad pointer
301 * ERANGE: no match found for search
302 * ENODEV: if device not found in list of registered devices
304 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
305 * protected pointer. The reason for the same is that the opp pointer which is
306 * returned will remain valid for use with opp_get_{voltage, freq} only while
307 * under the locked area. The pointer returned must be used prior to unlocking
308 * with rcu_read_unlock() to maintain the integrity of the pointer.
310 struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
313 struct device_opp *dev_opp;
314 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
317 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
318 return ERR_PTR(-EINVAL);
321 dev_opp = find_device_opp(dev);
323 return ERR_CAST(dev_opp);
325 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
326 if (temp_opp->available && temp_opp->rate >= *freq) {
335 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil);
338 * dev_pm_opp_find_freq_floor() - Search for a rounded floor freq
339 * @dev: device for which we do this operation
340 * @freq: Start frequency
342 * Search for the matching floor *available* OPP from a starting freq
345 * Returns matching *opp and refreshes *freq accordingly, else returns
346 * ERR_PTR in case of error and should be handled using IS_ERR. Error return
348 * EINVAL: for bad pointer
349 * ERANGE: no match found for search
350 * ENODEV: if device not found in list of registered devices
352 * Locking: This function must be called under rcu_read_lock(). opp is a rcu
353 * protected pointer. The reason for the same is that the opp pointer which is
354 * returned will remain valid for use with opp_get_{voltage, freq} only while
355 * under the locked area. The pointer returned must be used prior to unlocking
356 * with rcu_read_unlock() to maintain the integrity of the pointer.
358 struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
361 struct device_opp *dev_opp;
362 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
365 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
366 return ERR_PTR(-EINVAL);
369 dev_opp = find_device_opp(dev);
371 return ERR_CAST(dev_opp);
373 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
374 if (temp_opp->available) {
375 /* go to the next node, before choosing prev */
376 if (temp_opp->rate > *freq)
387 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
389 static struct device_opp *add_device_opp(struct device *dev)
391 struct device_opp *dev_opp;
394 * Allocate a new device OPP table. In the infrequent case where a new
395 * device is needed to be added, we pay this penalty.
397 dev_opp = kzalloc(sizeof(*dev_opp), GFP_KERNEL);
402 srcu_init_notifier_head(&dev_opp->srcu_head);
403 INIT_LIST_HEAD(&dev_opp->opp_list);
405 /* Secure the device list modification */
406 list_add_rcu(&dev_opp->node, &dev_opp_list);
410 static int dev_pm_opp_add_dynamic(struct device *dev, unsigned long freq,
411 unsigned long u_volt, bool dynamic)
413 struct device_opp *dev_opp = NULL;
414 struct dev_pm_opp *opp, *new_opp;
415 struct list_head *head;
418 /* allocate new OPP node */
419 new_opp = kzalloc(sizeof(*new_opp), GFP_KERNEL);
421 dev_warn(dev, "%s: Unable to create new OPP node\n", __func__);
425 /* Hold our list modification lock here */
426 mutex_lock(&dev_opp_list_lock);
428 /* populate the opp table */
429 new_opp->rate = freq;
430 new_opp->u_volt = u_volt;
431 new_opp->available = true;
432 new_opp->dynamic = dynamic;
434 /* Check for existing list for 'dev' */
435 dev_opp = find_device_opp(dev);
436 if (IS_ERR(dev_opp)) {
437 dev_opp = add_device_opp(dev);
443 head = &dev_opp->opp_list;
448 * Insert new OPP in order of increasing frequency
449 * and discard if already present
451 head = &dev_opp->opp_list;
452 list_for_each_entry_rcu(opp, &dev_opp->opp_list, node) {
453 if (new_opp->rate <= opp->rate)
459 /* Duplicate OPPs ? */
460 if (new_opp->rate == opp->rate) {
461 ret = opp->available && new_opp->u_volt == opp->u_volt ?
464 dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
465 __func__, opp->rate, opp->u_volt, opp->available,
466 new_opp->rate, new_opp->u_volt, new_opp->available);
471 new_opp->dev_opp = dev_opp;
472 list_add_rcu(&new_opp->node, head);
473 mutex_unlock(&dev_opp_list_lock);
476 * Notify the changes in the availability of the operable
477 * frequency/voltage list.
479 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
483 mutex_unlock(&dev_opp_list_lock);
489 * dev_pm_opp_add() - Add an OPP table from a table definitions
490 * @dev: device for which we do this operation
491 * @freq: Frequency in Hz for this OPP
492 * @u_volt: Voltage in uVolts for this OPP
494 * This function adds an opp definition to the opp list and returns status.
495 * The opp is made available by default and it can be controlled using
496 * dev_pm_opp_enable/disable functions.
498 * Locking: The internal device_opp and opp structures are RCU protected.
499 * Hence this function internally uses RCU updater strategy with mutex locks
500 * to keep the integrity of the internal data structures. Callers should ensure
501 * that this function is *NOT* called under RCU protection or in contexts where
502 * mutex cannot be locked.
506 * Duplicate OPPs (both freq and volt are same) and opp->available
507 * -EEXIST: Freq are same and volt are different OR
508 * Duplicate OPPs (both freq and volt are same) and !opp->available
509 * -ENOMEM: Memory allocation failure
511 int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
513 return dev_pm_opp_add_dynamic(dev, freq, u_volt, true);
515 EXPORT_SYMBOL_GPL(dev_pm_opp_add);
517 static void kfree_opp_rcu(struct rcu_head *head)
519 struct dev_pm_opp *opp = container_of(head, struct dev_pm_opp, rcu_head);
521 kfree_rcu(opp, rcu_head);
524 static void kfree_device_rcu(struct rcu_head *head)
526 struct device_opp *device_opp = container_of(head, struct device_opp, rcu_head);
528 kfree_rcu(device_opp, rcu_head);
531 static void __dev_pm_opp_remove(struct device_opp *dev_opp,
532 struct dev_pm_opp *opp)
535 * Notify the changes in the availability of the operable
536 * frequency/voltage list.
538 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_REMOVE, opp);
539 list_del_rcu(&opp->node);
540 call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, kfree_opp_rcu);
542 if (list_empty(&dev_opp->opp_list)) {
543 list_del_rcu(&dev_opp->node);
544 call_srcu(&dev_opp->srcu_head.srcu, &dev_opp->rcu_head,
550 * dev_pm_opp_remove() - Remove an OPP from OPP list
551 * @dev: device for which we do this operation
552 * @freq: OPP to remove with matching 'freq'
554 * This function removes an opp from the opp list.
556 void dev_pm_opp_remove(struct device *dev, unsigned long freq)
558 struct dev_pm_opp *opp;
559 struct device_opp *dev_opp;
562 /* Hold our list modification lock here */
563 mutex_lock(&dev_opp_list_lock);
565 dev_opp = find_device_opp(dev);
569 list_for_each_entry(opp, &dev_opp->opp_list, node) {
570 if (opp->rate == freq) {
577 dev_warn(dev, "%s: Couldn't find OPP with freq: %lu\n",
582 __dev_pm_opp_remove(dev_opp, opp);
584 mutex_unlock(&dev_opp_list_lock);
586 EXPORT_SYMBOL_GPL(dev_pm_opp_remove);
589 * opp_set_availability() - helper to set the availability of an opp
590 * @dev: device for which we do this operation
591 * @freq: OPP frequency to modify availability
592 * @availability_req: availability status requested for this opp
594 * Set the availability of an OPP with an RCU operation, opp_{enable,disable}
595 * share a common logic which is isolated here.
597 * Returns -EINVAL for bad pointers, -ENOMEM if no memory available for the
598 * copy operation, returns 0 if no modifcation was done OR modification was
601 * Locking: The internal device_opp and opp structures are RCU protected.
602 * Hence this function internally uses RCU updater strategy with mutex locks to
603 * keep the integrity of the internal data structures. Callers should ensure
604 * that this function is *NOT* called under RCU protection or in contexts where
605 * mutex locking or synchronize_rcu() blocking calls cannot be used.
607 static int opp_set_availability(struct device *dev, unsigned long freq,
608 bool availability_req)
610 struct device_opp *dev_opp;
611 struct dev_pm_opp *new_opp, *tmp_opp, *opp = ERR_PTR(-ENODEV);
614 /* keep the node allocated */
615 new_opp = kmalloc(sizeof(*new_opp), GFP_KERNEL);
617 dev_warn(dev, "%s: Unable to create OPP\n", __func__);
621 mutex_lock(&dev_opp_list_lock);
623 /* Find the device_opp */
624 dev_opp = find_device_opp(dev);
625 if (IS_ERR(dev_opp)) {
626 r = PTR_ERR(dev_opp);
627 dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);
631 /* Do we have the frequency? */
632 list_for_each_entry(tmp_opp, &dev_opp->opp_list, node) {
633 if (tmp_opp->rate == freq) {
643 /* Is update really needed? */
644 if (opp->available == availability_req)
646 /* copy the old data over */
649 /* plug in new node */
650 new_opp->available = availability_req;
652 list_replace_rcu(&opp->node, &new_opp->node);
653 mutex_unlock(&dev_opp_list_lock);
654 call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, kfree_opp_rcu);
656 /* Notify the change of the OPP availability */
657 if (availability_req)
658 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ENABLE,
661 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_DISABLE,
667 mutex_unlock(&dev_opp_list_lock);
673 * dev_pm_opp_enable() - Enable a specific OPP
674 * @dev: device for which we do this operation
675 * @freq: OPP frequency to enable
677 * Enables a provided opp. If the operation is valid, this returns 0, else the
678 * corresponding error value. It is meant to be used for users an OPP available
679 * after being temporarily made unavailable with dev_pm_opp_disable.
681 * Locking: The internal device_opp and opp structures are RCU protected.
682 * Hence this function indirectly uses RCU and mutex locks to keep the
683 * integrity of the internal data structures. Callers should ensure that
684 * this function is *NOT* called under RCU protection or in contexts where
685 * mutex locking or synchronize_rcu() blocking calls cannot be used.
687 int dev_pm_opp_enable(struct device *dev, unsigned long freq)
689 return opp_set_availability(dev, freq, true);
691 EXPORT_SYMBOL_GPL(dev_pm_opp_enable);
694 * dev_pm_opp_disable() - Disable a specific OPP
695 * @dev: device for which we do this operation
696 * @freq: OPP frequency to disable
698 * Disables a provided opp. If the operation is valid, this returns
699 * 0, else the corresponding error value. It is meant to be a temporary
700 * control by users to make this OPP not available until the circumstances are
701 * right to make it available again (with a call to dev_pm_opp_enable).
703 * Locking: The internal device_opp and opp structures are RCU protected.
704 * Hence this function indirectly uses RCU and mutex locks to keep the
705 * integrity of the internal data structures. Callers should ensure that
706 * this function is *NOT* called under RCU protection or in contexts where
707 * mutex locking or synchronize_rcu() blocking calls cannot be used.
709 int dev_pm_opp_disable(struct device *dev, unsigned long freq)
711 return opp_set_availability(dev, freq, false);
713 EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
716 * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
717 * @dev: device pointer used to lookup device OPPs.
719 struct srcu_notifier_head *dev_pm_opp_get_notifier(struct device *dev)
721 struct device_opp *dev_opp = find_device_opp(dev);
724 return ERR_CAST(dev_opp); /* matching type */
726 return &dev_opp->srcu_head;
731 * of_init_opp_table() - Initialize opp table from device tree
732 * @dev: device pointer used to lookup device OPPs.
734 * Register the initial OPP table with the OPP library for given device.
736 int of_init_opp_table(struct device *dev)
738 const struct property *prop;
742 prop = of_find_property(dev->of_node, "operating-points", NULL);
749 * Each OPP is a set of tuples consisting of frequency and
750 * voltage like <freq-kHz vol-uV>.
752 nr = prop->length / sizeof(u32);
754 dev_err(dev, "%s: Invalid OPP list\n", __func__);
760 unsigned long freq = be32_to_cpup(val++) * 1000;
761 unsigned long volt = be32_to_cpup(val++);
763 if (dev_pm_opp_add_dynamic(dev, freq, volt, false))
764 dev_warn(dev, "%s: Failed to add OPP %ld\n",
771 EXPORT_SYMBOL_GPL(of_init_opp_table);
774 * of_free_opp_table() - Free OPP table entries created from static DT entries
775 * @dev: device pointer used to lookup device OPPs.
777 * Free OPPs created using static entries present in DT.
779 void of_free_opp_table(struct device *dev)
781 struct device_opp *dev_opp;
782 struct dev_pm_opp *opp, *tmp;
784 /* Check for existing list for 'dev' */
785 dev_opp = find_device_opp(dev);
786 if (WARN(IS_ERR(dev_opp), "%s: dev_opp: %ld\n", dev_name(dev),
790 /* Hold our list modification lock here */
791 mutex_lock(&dev_opp_list_lock);
793 /* Free static OPPs */
794 list_for_each_entry_safe(opp, tmp, &dev_opp->opp_list, node) {
796 __dev_pm_opp_remove(dev_opp, opp);
799 mutex_unlock(&dev_opp_list_lock);
801 EXPORT_SYMBOL_GPL(of_free_opp_table);