2 * Generic OPP OF helpers
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/cpu.h>
17 #include <linux/errno.h>
18 #include <linux/device.h>
20 #include <linux/export.h>
24 static struct opp_table *_managed_opp(const struct device_node *np)
26 struct opp_table *opp_table;
28 list_for_each_entry_rcu(opp_table, &opp_tables, node) {
29 if (opp_table->np == np) {
31 * Multiple devices can point to the same OPP table and
32 * so will have same node-pointer, np.
34 * But the OPPs will be considered as shared only if the
35 * OPP table contains a "opp-shared" property.
37 if (opp_table->shared_opp == OPP_TABLE_ACCESS_SHARED)
47 void _of_init_opp_table(struct opp_table *opp_table, struct device *dev)
49 struct device_node *np;
52 * Only required for backward compatibility with v1 bindings, but isn't
53 * harmful for other cases. And so we do it unconditionally.
55 np = of_node_get(dev->of_node);
59 if (!of_property_read_u32(np, "clock-latency", &val))
60 opp_table->clock_latency_ns_max = val;
61 of_property_read_u32(np, "voltage-tolerance",
62 &opp_table->voltage_tolerance_v1);
67 static bool _opp_is_supported(struct device *dev, struct opp_table *opp_table,
68 struct device_node *np)
70 unsigned int count = opp_table->supported_hw_count;
74 if (!opp_table->supported_hw)
78 ret = of_property_read_u32_index(np, "opp-supported-hw", count,
81 dev_warn(dev, "%s: failed to read opp-supported-hw property at index %d: %d\n",
82 __func__, count, ret);
86 /* Both of these are bitwise masks of the versions */
87 if (!(version & opp_table->supported_hw[count]))
94 /* TODO: Support multiple regulators */
95 static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev,
96 struct opp_table *opp_table)
98 u32 microvolt[3] = {0};
101 struct property *prop = NULL;
104 /* Search for "opp-microvolt-<name>" */
105 if (opp_table->prop_name) {
106 snprintf(name, sizeof(name), "opp-microvolt-%s",
107 opp_table->prop_name);
108 prop = of_find_property(opp->np, name, NULL);
112 /* Search for "opp-microvolt" */
113 sprintf(name, "opp-microvolt");
114 prop = of_find_property(opp->np, name, NULL);
116 /* Missing property isn't a problem, but an invalid entry is */
121 count = of_property_count_u32_elems(opp->np, name);
123 dev_err(dev, "%s: Invalid %s property (%d)\n",
124 __func__, name, count);
128 /* There can be one or three elements here */
129 if (count != 1 && count != 3) {
130 dev_err(dev, "%s: Invalid number of elements in %s property (%d)\n",
131 __func__, name, count);
135 ret = of_property_read_u32_array(opp->np, name, microvolt, count);
137 dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret);
141 opp->u_volt = microvolt[0];
144 opp->u_volt_min = opp->u_volt;
145 opp->u_volt_max = opp->u_volt;
147 opp->u_volt_min = microvolt[1];
148 opp->u_volt_max = microvolt[2];
151 /* Search for "opp-microamp-<name>" */
153 if (opp_table->prop_name) {
154 snprintf(name, sizeof(name), "opp-microamp-%s",
155 opp_table->prop_name);
156 prop = of_find_property(opp->np, name, NULL);
160 /* Search for "opp-microamp" */
161 sprintf(name, "opp-microamp");
162 prop = of_find_property(opp->np, name, NULL);
165 if (prop && !of_property_read_u32(opp->np, name, &val))
172 * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT
174 * @dev: device pointer used to lookup OPP table.
176 * Free OPPs created using static entries present in DT.
178 * Locking: The internal opp_table and opp structures are RCU protected.
179 * Hence this function indirectly uses RCU updater strategy with mutex locks
180 * to keep the integrity of the internal data structures. Callers should ensure
181 * that this function is *NOT* called under RCU protection or in contexts where
182 * mutex cannot be locked.
184 void dev_pm_opp_of_remove_table(struct device *dev)
186 _dev_pm_opp_remove_table(dev, false);
188 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table);
190 /* Returns opp descriptor node for a device, caller must do of_node_put() */
191 struct device_node *_of_get_opp_desc_node(struct device *dev)
194 * TODO: Support for multiple OPP tables.
196 * There should be only ONE phandle present in "operating-points-v2"
200 return of_parse_phandle(dev->of_node, "operating-points-v2", 0);
204 * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)
205 * @dev: device for which we do this operation
208 * This function adds an opp definition to the opp table and returns status. The
209 * opp can be controlled using dev_pm_opp_enable/disable functions and may be
210 * removed by dev_pm_opp_remove.
212 * Locking: The internal opp_table and opp structures are RCU protected.
213 * Hence this function internally uses RCU updater strategy with mutex locks
214 * to keep the integrity of the internal data structures. Callers should ensure
215 * that this function is *NOT* called under RCU protection or in contexts where
216 * mutex cannot be locked.
220 * Duplicate OPPs (both freq and volt are same) and opp->available
221 * -EEXIST Freq are same and volt are different OR
222 * Duplicate OPPs (both freq and volt are same) and !opp->available
223 * -ENOMEM Memory allocation failure
224 * -EINVAL Failed parsing the OPP node
226 static int _opp_add_static_v2(struct device *dev, struct device_node *np)
228 struct opp_table *opp_table;
229 struct dev_pm_opp *new_opp;
234 /* Hold our table modification lock here */
235 mutex_lock(&opp_table_lock);
237 new_opp = _allocate_opp(dev, &opp_table);
243 ret = of_property_read_u64(np, "opp-hz", &rate);
245 dev_err(dev, "%s: opp-hz not found\n", __func__);
249 /* Check if the OPP supports hardware's hierarchy of versions or not */
250 if (!_opp_is_supported(dev, opp_table, np)) {
251 dev_dbg(dev, "OPP not supported by hardware: %llu\n", rate);
256 * Rate is defined as an unsigned long in clk API, and so casting
257 * explicitly to its type. Must be fixed once rate is 64 bit
258 * guaranteed in clk API.
260 new_opp->rate = (unsigned long)rate;
261 new_opp->turbo = of_property_read_bool(np, "turbo-mode");
264 new_opp->dynamic = false;
265 new_opp->available = true;
267 if (!of_property_read_u32(np, "clock-latency-ns", &val))
268 new_opp->clock_latency_ns = val;
270 ret = opp_parse_supplies(new_opp, dev, opp_table);
274 ret = _opp_add(dev, new_opp, opp_table);
278 /* OPP to select on device suspend */
279 if (of_property_read_bool(np, "opp-suspend")) {
280 if (opp_table->suspend_opp) {
281 dev_warn(dev, "%s: Multiple suspend OPPs found (%lu %lu)\n",
282 __func__, opp_table->suspend_opp->rate,
285 new_opp->suspend = true;
286 opp_table->suspend_opp = new_opp;
290 if (new_opp->clock_latency_ns > opp_table->clock_latency_ns_max)
291 opp_table->clock_latency_ns_max = new_opp->clock_latency_ns;
293 mutex_unlock(&opp_table_lock);
295 pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu\n",
296 __func__, new_opp->turbo, new_opp->rate, new_opp->u_volt,
297 new_opp->u_volt_min, new_opp->u_volt_max,
298 new_opp->clock_latency_ns);
301 * Notify the changes in the availability of the operable
302 * frequency/voltage list.
304 srcu_notifier_call_chain(&opp_table->srcu_head, OPP_EVENT_ADD, new_opp);
308 _opp_remove(opp_table, new_opp, false);
310 mutex_unlock(&opp_table_lock);
314 /* Initializes OPP tables based on new bindings */
315 static int _of_add_opp_table_v2(struct device *dev, struct device_node *opp_np)
317 struct device_node *np;
318 struct opp_table *opp_table;
319 int ret = 0, count = 0;
321 mutex_lock(&opp_table_lock);
323 opp_table = _managed_opp(opp_np);
325 /* OPPs are already managed */
326 if (!_add_opp_dev(dev, opp_table))
328 mutex_unlock(&opp_table_lock);
331 mutex_unlock(&opp_table_lock);
333 /* We have opp-table node now, iterate over it and add OPPs */
334 for_each_available_child_of_node(opp_np, np) {
337 ret = _opp_add_static_v2(dev, np);
339 dev_err(dev, "%s: Failed to add OPP, %d\n", __func__,
345 /* There should be one of more OPP defined */
349 mutex_lock(&opp_table_lock);
351 opp_table = _find_opp_table(dev);
352 if (WARN_ON(IS_ERR(opp_table))) {
353 ret = PTR_ERR(opp_table);
354 mutex_unlock(&opp_table_lock);
358 opp_table->np = opp_np;
359 if (of_property_read_bool(opp_np, "opp-shared"))
360 opp_table->shared_opp = OPP_TABLE_ACCESS_SHARED;
362 opp_table->shared_opp = OPP_TABLE_ACCESS_EXCLUSIVE;
364 mutex_unlock(&opp_table_lock);
369 dev_pm_opp_of_remove_table(dev);
374 /* Initializes OPP tables based on old-deprecated bindings */
375 static int _of_add_opp_table_v1(struct device *dev)
377 const struct property *prop;
381 prop = of_find_property(dev->of_node, "operating-points", NULL);
388 * Each OPP is a set of tuples consisting of frequency and
389 * voltage like <freq-kHz vol-uV>.
391 nr = prop->length / sizeof(u32);
393 dev_err(dev, "%s: Invalid OPP table\n", __func__);
399 unsigned long freq = be32_to_cpup(val++) * 1000;
400 unsigned long volt = be32_to_cpup(val++);
402 if (_opp_add_v1(dev, freq, volt, false))
403 dev_warn(dev, "%s: Failed to add OPP %ld\n",
412 * dev_pm_opp_of_add_table() - Initialize opp table from device tree
413 * @dev: device pointer used to lookup OPP table.
415 * Register the initial OPP table with the OPP library for given device.
417 * Locking: The internal opp_table and opp structures are RCU protected.
418 * Hence this function indirectly uses RCU updater strategy with mutex locks
419 * to keep the integrity of the internal data structures. Callers should ensure
420 * that this function is *NOT* called under RCU protection or in contexts where
421 * mutex cannot be locked.
425 * Duplicate OPPs (both freq and volt are same) and opp->available
426 * -EEXIST Freq are same and volt are different OR
427 * Duplicate OPPs (both freq and volt are same) and !opp->available
428 * -ENOMEM Memory allocation failure
429 * -ENODEV when 'operating-points' property is not found or is invalid data
431 * -ENODATA when empty 'operating-points' property is found
432 * -EINVAL when invalid entries are found in opp-v2 table
434 int dev_pm_opp_of_add_table(struct device *dev)
436 struct device_node *opp_np;
440 * OPPs have two version of bindings now. The older one is deprecated,
441 * try for the new binding first.
443 opp_np = _of_get_opp_desc_node(dev);
446 * Try old-deprecated bindings for backward compatibility with
449 return _of_add_opp_table_v1(dev);
452 ret = _of_add_opp_table_v2(dev, opp_np);
457 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);
459 /* CPU device specific helpers */
462 * dev_pm_opp_of_cpumask_remove_table() - Removes OPP table for @cpumask
463 * @cpumask: cpumask for which OPP table needs to be removed
465 * This removes the OPP tables for CPUs present in the @cpumask.
466 * This should be used only to remove static entries created from DT.
468 * Locking: The internal opp_table and opp structures are RCU protected.
469 * Hence this function internally uses RCU updater strategy with mutex locks
470 * to keep the integrity of the internal data structures. Callers should ensure
471 * that this function is *NOT* called under RCU protection or in contexts where
472 * mutex cannot be locked.
474 void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask)
476 _dev_pm_opp_cpumask_remove_table(cpumask, true);
478 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_remove_table);
481 * dev_pm_opp_of_cpumask_add_table() - Adds OPP table for @cpumask
482 * @cpumask: cpumask for which OPP table needs to be added.
484 * This adds the OPP tables for CPUs present in the @cpumask.
486 * Locking: The internal opp_table and opp structures are RCU protected.
487 * Hence this function internally uses RCU updater strategy with mutex locks
488 * to keep the integrity of the internal data structures. Callers should ensure
489 * that this function is *NOT* called under RCU protection or in contexts where
490 * mutex cannot be locked.
492 int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask)
494 struct device *cpu_dev;
497 WARN_ON(cpumask_empty(cpumask));
499 for_each_cpu(cpu, cpumask) {
500 cpu_dev = get_cpu_device(cpu);
502 pr_err("%s: failed to get cpu%d device\n", __func__,
507 ret = dev_pm_opp_of_add_table(cpu_dev);
509 pr_err("%s: couldn't find opp table for cpu:%d, %d\n",
512 /* Free all other OPPs */
513 dev_pm_opp_of_cpumask_remove_table(cpumask);
520 EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_add_table);
523 * Works only for OPP v2 bindings.
525 * Returns -ENOENT if operating-points-v2 bindings aren't supported.
528 * dev_pm_opp_of_get_sharing_cpus() - Get cpumask of CPUs sharing OPPs with
529 * @cpu_dev using operating-points-v2
532 * @cpu_dev: CPU device for which we do this operation
533 * @cpumask: cpumask to update with information of sharing CPUs
535 * This updates the @cpumask with CPUs that are sharing OPPs with @cpu_dev.
537 * Returns -ENOENT if operating-points-v2 isn't present for @cpu_dev.
539 * Locking: The internal opp_table and opp structures are RCU protected.
540 * Hence this function internally uses RCU updater strategy with mutex locks
541 * to keep the integrity of the internal data structures. Callers should ensure
542 * that this function is *NOT* called under RCU protection or in contexts where
543 * mutex cannot be locked.
545 int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev,
546 struct cpumask *cpumask)
548 struct device_node *np, *tmp_np;
549 struct device *tcpu_dev;
552 /* Get OPP descriptor node */
553 np = _of_get_opp_desc_node(cpu_dev);
555 dev_dbg(cpu_dev, "%s: Couldn't find cpu_dev node.\n", __func__);
559 cpumask_set_cpu(cpu_dev->id, cpumask);
561 /* OPPs are shared ? */
562 if (!of_property_read_bool(np, "opp-shared"))
565 for_each_possible_cpu(cpu) {
566 if (cpu == cpu_dev->id)
569 tcpu_dev = get_cpu_device(cpu);
571 dev_err(cpu_dev, "%s: failed to get cpu%d device\n",
577 /* Get OPP descriptor node */
578 tmp_np = _of_get_opp_desc_node(tcpu_dev);
580 dev_err(tcpu_dev, "%s: Couldn't find tcpu_dev node.\n",
586 /* CPUs are sharing opp node */
588 cpumask_set_cpu(cpu, cpumask);
597 EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus);