1 /*
2 * Generic OPP Interface
3 *
4 * Copyright (C) 2009-2010 Texas Instruments Incorporated.
5 * Nishanth Menon
6 * Romit Dasgupta
7 * Kevin Hilman
8 *
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.
12 */
13
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15
16 #include <linux/errno.h>
17 #include <linux/err.h>
18 #include <linux/slab.h>
19 #include <linux/device.h>
20 #include <linux/of.h>
21 #include <linux/export.h>
22
23 #include "opp.h"
24
25 /*
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.
29 */
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);
33
34 #define opp_rcu_lockdep_assert() \
35 do { \
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"); \
40 } while (0)
41
_find_list_dev(const struct device * dev,struct device_opp * dev_opp)42 static struct device_list_opp *_find_list_dev(const struct device *dev,
43 struct device_opp *dev_opp)
44 {
45 struct device_list_opp *list_dev;
46
47 list_for_each_entry(list_dev, &dev_opp->dev_list, node)
48 if (list_dev->dev == dev)
49 return list_dev;
50
51 return NULL;
52 }
53
_managed_opp(const struct device_node * np)54 static struct device_opp *_managed_opp(const struct device_node *np)
55 {
56 struct device_opp *dev_opp;
57
58 list_for_each_entry_rcu(dev_opp, &dev_opp_list, node) {
59 if (dev_opp->np == np) {
60 /*
61 * Multiple devices can point to the same OPP table and
62 * so will have same node-pointer, np.
63 *
64 * But the OPPs will be considered as shared only if the
65 * OPP table contains a "opp-shared" property.
66 */
67 return dev_opp->shared_opp ? dev_opp : NULL;
68 }
69 }
70
71 return NULL;
72 }
73
74 /**
75 * _find_device_opp() - find device_opp struct using device pointer
76 * @dev: device pointer used to lookup device OPPs
77 *
78 * Search list of device OPPs for one containing matching device. Does a RCU
79 * reader operation to grab the pointer needed.
80 *
81 * Return: pointer to 'struct device_opp' if found, otherwise -ENODEV or
82 * -EINVAL based on type of error.
83 *
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.
87 *
88 * For Writers, this function must be called with dev_opp_list_lock held.
89 */
_find_device_opp(struct device * dev)90 struct device_opp *_find_device_opp(struct device *dev)
91 {
92 struct device_opp *dev_opp;
93
94 opp_rcu_lockdep_assert();
95
96 if (IS_ERR_OR_NULL(dev)) {
97 pr_err("%s: Invalid parameters\n", __func__);
98 return ERR_PTR(-EINVAL);
99 }
100
101 list_for_each_entry_rcu(dev_opp, &dev_opp_list, node)
102 if (_find_list_dev(dev, dev_opp))
103 return dev_opp;
104
105 return ERR_PTR(-ENODEV);
106 }
107
108 /**
109 * dev_pm_opp_get_voltage() - Gets the voltage corresponding to an opp
110 * @opp: opp for which voltage has to be returned for
111 *
112 * Return: voltage in micro volt corresponding to the opp, else
113 * return 0
114 *
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
121 * pointer.
122 */
dev_pm_opp_get_voltage(struct dev_pm_opp * opp)123 unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp)
124 {
125 struct dev_pm_opp *tmp_opp;
126 unsigned long v = 0;
127
128 opp_rcu_lockdep_assert();
129
130 tmp_opp = rcu_dereference(opp);
131 if (IS_ERR_OR_NULL(tmp_opp))
132 pr_err("%s: Invalid parameters\n", __func__);
133 else
134 v = tmp_opp->u_volt;
135
136 return v;
137 }
138 EXPORT_SYMBOL_GPL(dev_pm_opp_get_voltage);
139
140 /**
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
143 *
144 * Return: frequency in hertz corresponding to the opp, else
145 * return 0
146 *
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
153 * pointer.
154 */
dev_pm_opp_get_freq(struct dev_pm_opp * opp)155 unsigned long dev_pm_opp_get_freq(struct dev_pm_opp *opp)
156 {
157 struct dev_pm_opp *tmp_opp;
158 unsigned long f = 0;
159
160 opp_rcu_lockdep_assert();
161
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__);
165 else
166 f = tmp_opp->rate;
167
168 return f;
169 }
170 EXPORT_SYMBOL_GPL(dev_pm_opp_get_freq);
171
172 /**
173 * dev_pm_opp_is_turbo() - Returns if opp is turbo OPP or not
174 * @opp: opp for which turbo mode is being verified
175 *
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.
179 *
180 * Return: true if opp is turbo opp, else false.
181 *
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
188 * pointer.
189 */
dev_pm_opp_is_turbo(struct dev_pm_opp * opp)190 bool dev_pm_opp_is_turbo(struct dev_pm_opp *opp)
191 {
192 struct dev_pm_opp *tmp_opp;
193
194 opp_rcu_lockdep_assert();
195
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__);
199 return false;
200 }
201
202 return tmp_opp->turbo;
203 }
204 EXPORT_SYMBOL_GPL(dev_pm_opp_is_turbo);
205
206 /**
207 * dev_pm_opp_get_max_clock_latency() - Get max clock latency in nanoseconds
208 * @dev: device for which we do this operation
209 *
210 * Return: This function returns the max clock latency in nanoseconds.
211 *
212 * Locking: This function takes rcu_read_lock().
213 */
dev_pm_opp_get_max_clock_latency(struct device * dev)214 unsigned long dev_pm_opp_get_max_clock_latency(struct device *dev)
215 {
216 struct device_opp *dev_opp;
217 unsigned long clock_latency_ns;
218
219 rcu_read_lock();
220
221 dev_opp = _find_device_opp(dev);
222 if (IS_ERR(dev_opp))
223 clock_latency_ns = 0;
224 else
225 clock_latency_ns = dev_opp->clock_latency_ns_max;
226
227 rcu_read_unlock();
228 return clock_latency_ns;
229 }
230 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_clock_latency);
231
232 /**
233 * dev_pm_opp_get_suspend_opp() - Get suspend opp
234 * @dev: device for which we do this operation
235 *
236 * Return: This function returns pointer to the suspend opp if it is
237 * defined and available, otherwise it returns NULL.
238 *
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.
244 */
dev_pm_opp_get_suspend_opp(struct device * dev)245 struct dev_pm_opp *dev_pm_opp_get_suspend_opp(struct device *dev)
246 {
247 struct device_opp *dev_opp;
248
249 opp_rcu_lockdep_assert();
250
251 dev_opp = _find_device_opp(dev);
252 if (IS_ERR(dev_opp) || !dev_opp->suspend_opp ||
253 !dev_opp->suspend_opp->available)
254 return NULL;
255
256 return dev_opp->suspend_opp;
257 }
258 EXPORT_SYMBOL_GPL(dev_pm_opp_get_suspend_opp);
259
260 /**
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
263 *
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.
266 *
267 * Locking: This function takes rcu_read_lock().
268 */
dev_pm_opp_get_opp_count(struct device * dev)269 int dev_pm_opp_get_opp_count(struct device *dev)
270 {
271 struct device_opp *dev_opp;
272 struct dev_pm_opp *temp_opp;
273 int count = 0;
274
275 rcu_read_lock();
276
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",
281 __func__, count);
282 goto out_unlock;
283 }
284
285 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
286 if (temp_opp->available)
287 count++;
288 }
289
290 out_unlock:
291 rcu_read_unlock();
292 return count;
293 }
294 EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count);
295
296 /**
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
301 *
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
308 *
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.
312 *
313 * This provides a mechanism to enable an opp which is not available currently
314 * or the opposite as well.
315 *
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.
321 */
dev_pm_opp_find_freq_exact(struct device * dev,unsigned long freq,bool available)322 struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,
323 unsigned long freq,
324 bool available)
325 {
326 struct device_opp *dev_opp;
327 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
328
329 opp_rcu_lockdep_assert();
330
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);
335 return ERR_PTR(r);
336 }
337
338 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
339 if (temp_opp->available == available &&
340 temp_opp->rate == freq) {
341 opp = temp_opp;
342 break;
343 }
344 }
345
346 return opp;
347 }
348 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact);
349
350 /**
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
354 *
355 * Search for the matching ceil *available* OPP from a starting freq
356 * for a device.
357 *
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
360 * values can be:
361 * EINVAL: for bad pointer
362 * ERANGE: no match found for search
363 * ENODEV: if device not found in list of registered devices
364 *
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.
370 */
dev_pm_opp_find_freq_ceil(struct device * dev,unsigned long * freq)371 struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
372 unsigned long *freq)
373 {
374 struct device_opp *dev_opp;
375 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
376
377 opp_rcu_lockdep_assert();
378
379 if (!dev || !freq) {
380 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
381 return ERR_PTR(-EINVAL);
382 }
383
384 dev_opp = _find_device_opp(dev);
385 if (IS_ERR(dev_opp))
386 return ERR_CAST(dev_opp);
387
388 list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
389 if (temp_opp->available && temp_opp->rate >= *freq) {
390 opp = temp_opp;
391 *freq = opp->rate;
392 break;
393 }
394 }
395
396 return opp;
397 }
398 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil);
399
400 /**
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
404 *
405 * Search for the matching floor *available* OPP from a starting freq
406 * for a device.
407 *
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
410 * values can be:
411 * EINVAL: for bad pointer
412 * ERANGE: no match found for search
413 * ENODEV: if device not found in list of registered devices
414 *
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.
420 */
dev_pm_opp_find_freq_floor(struct device * dev,unsigned long * freq)421 struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
422 unsigned long *freq)
423 {
424 struct device_opp *dev_opp;
425 struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
426
427 opp_rcu_lockdep_assert();
428
429 if (!dev || !freq) {
430 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
431 return ERR_PTR(-EINVAL);
432 }
433
434 dev_opp = _find_device_opp(dev);
435 if (IS_ERR(dev_opp))
436 return ERR_CAST(dev_opp);
437
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)
442 break;
443 else
444 opp = temp_opp;
445 }
446 }
447 if (!IS_ERR(opp))
448 *freq = opp->rate;
449
450 return opp;
451 }
452 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
453
454 /* List-dev Helpers */
_kfree_list_dev_rcu(struct rcu_head * head)455 static void _kfree_list_dev_rcu(struct rcu_head *head)
456 {
457 struct device_list_opp *list_dev;
458
459 list_dev = container_of(head, struct device_list_opp, rcu_head);
460 kfree_rcu(list_dev, rcu_head);
461 }
462
_remove_list_dev(struct device_list_opp * list_dev,struct device_opp * dev_opp)463 static void _remove_list_dev(struct device_list_opp *list_dev,
464 struct device_opp *dev_opp)
465 {
466 list_del(&list_dev->node);
467 call_srcu(&dev_opp->srcu_head.srcu, &list_dev->rcu_head,
468 _kfree_list_dev_rcu);
469 }
470
_add_list_dev(const struct device * dev,struct device_opp * dev_opp)471 struct device_list_opp *_add_list_dev(const struct device *dev,
472 struct device_opp *dev_opp)
473 {
474 struct device_list_opp *list_dev;
475
476 list_dev = kzalloc(sizeof(*list_dev), GFP_KERNEL);
477 if (!list_dev)
478 return NULL;
479
480 /* Initialize list-dev */
481 list_dev->dev = dev;
482 list_add_rcu(&list_dev->node, &dev_opp->dev_list);
483
484 return list_dev;
485 }
486
487 /**
488 * _add_device_opp() - Find device OPP table or allocate a new one
489 * @dev: device for which we do this operation
490 *
491 * It tries to find an existing table first, if it couldn't find one, it
492 * allocates a new OPP table and returns that.
493 *
494 * Return: valid device_opp pointer if success, else NULL.
495 */
_add_device_opp(struct device * dev)496 static struct device_opp *_add_device_opp(struct device *dev)
497 {
498 struct device_opp *dev_opp;
499 struct device_list_opp *list_dev;
500
501 /* Check for existing list for 'dev' first */
502 dev_opp = _find_device_opp(dev);
503 if (!IS_ERR(dev_opp))
504 return dev_opp;
505
506 /*
507 * Allocate a new device OPP table. In the infrequent case where a new
508 * device is needed to be added, we pay this penalty.
509 */
510 dev_opp = kzalloc(sizeof(*dev_opp), GFP_KERNEL);
511 if (!dev_opp)
512 return NULL;
513
514 INIT_LIST_HEAD(&dev_opp->dev_list);
515
516 list_dev = _add_list_dev(dev, dev_opp);
517 if (!list_dev) {
518 kfree(dev_opp);
519 return NULL;
520 }
521
522 srcu_init_notifier_head(&dev_opp->srcu_head);
523 INIT_LIST_HEAD(&dev_opp->opp_list);
524
525 /* Secure the device list modification */
526 list_add_rcu(&dev_opp->node, &dev_opp_list);
527 return dev_opp;
528 }
529
530 /**
531 * _kfree_device_rcu() - Free device_opp RCU handler
532 * @head: RCU head
533 */
_kfree_device_rcu(struct rcu_head * head)534 static void _kfree_device_rcu(struct rcu_head *head)
535 {
536 struct device_opp *device_opp = container_of(head, struct device_opp, rcu_head);
537
538 kfree_rcu(device_opp, rcu_head);
539 }
540
541 /**
542 * _remove_device_opp() - Removes a device OPP table
543 * @dev_opp: device OPP table to be removed.
544 *
545 * Removes/frees device OPP table it it doesn't contain any OPPs.
546 */
_remove_device_opp(struct device_opp * dev_opp)547 static void _remove_device_opp(struct device_opp *dev_opp)
548 {
549 struct device_list_opp *list_dev;
550
551 if (!list_empty(&dev_opp->opp_list))
552 return;
553
554 list_dev = list_first_entry(&dev_opp->dev_list, struct device_list_opp,
555 node);
556
557 _remove_list_dev(list_dev, dev_opp);
558
559 /* dev_list must be empty now */
560 WARN_ON(!list_empty(&dev_opp->dev_list));
561
562 list_del_rcu(&dev_opp->node);
563 call_srcu(&dev_opp->srcu_head.srcu, &dev_opp->rcu_head,
564 _kfree_device_rcu);
565 }
566
567 /**
568 * _kfree_opp_rcu() - Free OPP RCU handler
569 * @head: RCU head
570 */
_kfree_opp_rcu(struct rcu_head * head)571 static void _kfree_opp_rcu(struct rcu_head *head)
572 {
573 struct dev_pm_opp *opp = container_of(head, struct dev_pm_opp, rcu_head);
574
575 kfree_rcu(opp, rcu_head);
576 }
577
578 /**
579 * _opp_remove() - Remove an OPP from a table definition
580 * @dev_opp: points back to the device_opp struct this opp belongs to
581 * @opp: pointer to the OPP to remove
582 * @notify: OPP_EVENT_REMOVE notification should be sent or not
583 *
584 * This function removes an opp definition from the opp list.
585 *
586 * Locking: The internal device_opp and opp structures are RCU protected.
587 * It is assumed that the caller holds required mutex for an RCU updater
588 * strategy.
589 */
_opp_remove(struct device_opp * dev_opp,struct dev_pm_opp * opp,bool notify)590 static void _opp_remove(struct device_opp *dev_opp,
591 struct dev_pm_opp *opp, bool notify)
592 {
593 /*
594 * Notify the changes in the availability of the operable
595 * frequency/voltage list.
596 */
597 if (notify)
598 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_REMOVE, opp);
599 list_del_rcu(&opp->node);
600 call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);
601
602 _remove_device_opp(dev_opp);
603 }
604
605 /**
606 * dev_pm_opp_remove() - Remove an OPP from OPP list
607 * @dev: device for which we do this operation
608 * @freq: OPP to remove with matching 'freq'
609 *
610 * This function removes an opp from the opp list.
611 *
612 * Locking: The internal device_opp and opp structures are RCU protected.
613 * Hence this function internally uses RCU updater strategy with mutex locks
614 * to keep the integrity of the internal data structures. Callers should ensure
615 * that this function is *NOT* called under RCU protection or in contexts where
616 * mutex cannot be locked.
617 */
dev_pm_opp_remove(struct device * dev,unsigned long freq)618 void dev_pm_opp_remove(struct device *dev, unsigned long freq)
619 {
620 struct dev_pm_opp *opp;
621 struct device_opp *dev_opp;
622 bool found = false;
623
624 /* Hold our list modification lock here */
625 mutex_lock(&dev_opp_list_lock);
626
627 dev_opp = _find_device_opp(dev);
628 if (IS_ERR(dev_opp))
629 goto unlock;
630
631 list_for_each_entry(opp, &dev_opp->opp_list, node) {
632 if (opp->rate == freq) {
633 found = true;
634 break;
635 }
636 }
637
638 if (!found) {
639 dev_warn(dev, "%s: Couldn't find OPP with freq: %lu\n",
640 __func__, freq);
641 goto unlock;
642 }
643
644 _opp_remove(dev_opp, opp, true);
645 unlock:
646 mutex_unlock(&dev_opp_list_lock);
647 }
648 EXPORT_SYMBOL_GPL(dev_pm_opp_remove);
649
_allocate_opp(struct device * dev,struct device_opp ** dev_opp)650 static struct dev_pm_opp *_allocate_opp(struct device *dev,
651 struct device_opp **dev_opp)
652 {
653 struct dev_pm_opp *opp;
654
655 /* allocate new OPP node */
656 opp = kzalloc(sizeof(*opp), GFP_KERNEL);
657 if (!opp)
658 return NULL;
659
660 INIT_LIST_HEAD(&opp->node);
661
662 *dev_opp = _add_device_opp(dev);
663 if (!*dev_opp) {
664 kfree(opp);
665 return NULL;
666 }
667
668 return opp;
669 }
670
_opp_add(struct device * dev,struct dev_pm_opp * new_opp,struct device_opp * dev_opp)671 static int _opp_add(struct device *dev, struct dev_pm_opp *new_opp,
672 struct device_opp *dev_opp)
673 {
674 struct dev_pm_opp *opp;
675 struct list_head *head = &dev_opp->opp_list;
676
677 /*
678 * Insert new OPP in order of increasing frequency and discard if
679 * already present.
680 *
681 * Need to use &dev_opp->opp_list in the condition part of the 'for'
682 * loop, don't replace it with head otherwise it will become an infinite
683 * loop.
684 */
685 list_for_each_entry_rcu(opp, &dev_opp->opp_list, node) {
686 if (new_opp->rate > opp->rate) {
687 head = &opp->node;
688 continue;
689 }
690
691 if (new_opp->rate < opp->rate)
692 break;
693
694 /* Duplicate OPPs */
695 dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
696 __func__, opp->rate, opp->u_volt, opp->available,
697 new_opp->rate, new_opp->u_volt, new_opp->available);
698
699 return opp->available && new_opp->u_volt == opp->u_volt ?
700 0 : -EEXIST;
701 }
702
703 new_opp->dev_opp = dev_opp;
704 list_add_rcu(&new_opp->node, head);
705
706 return 0;
707 }
708
709 /**
710 * _opp_add_v1() - Allocate a OPP based on v1 bindings.
711 * @dev: device for which we do this operation
712 * @freq: Frequency in Hz for this OPP
713 * @u_volt: Voltage in uVolts for this OPP
714 * @dynamic: Dynamically added OPPs.
715 *
716 * This function adds an opp definition to the opp list and returns status.
717 * The opp is made available by default and it can be controlled using
718 * dev_pm_opp_enable/disable functions and may be removed by dev_pm_opp_remove.
719 *
720 * NOTE: "dynamic" parameter impacts OPPs added by the dev_pm_opp_of_add_table
721 * and freed by dev_pm_opp_of_remove_table.
722 *
723 * Locking: The internal device_opp and opp structures are RCU protected.
724 * Hence this function internally uses RCU updater strategy with mutex locks
725 * to keep the integrity of the internal data structures. Callers should ensure
726 * that this function is *NOT* called under RCU protection or in contexts where
727 * mutex cannot be locked.
728 *
729 * Return:
730 * 0 On success OR
731 * Duplicate OPPs (both freq and volt are same) and opp->available
732 * -EEXIST Freq are same and volt are different OR
733 * Duplicate OPPs (both freq and volt are same) and !opp->available
734 * -ENOMEM Memory allocation failure
735 */
_opp_add_v1(struct device * dev,unsigned long freq,long u_volt,bool dynamic)736 static int _opp_add_v1(struct device *dev, unsigned long freq, long u_volt,
737 bool dynamic)
738 {
739 struct device_opp *dev_opp;
740 struct dev_pm_opp *new_opp;
741 int ret;
742
743 /* Hold our list modification lock here */
744 mutex_lock(&dev_opp_list_lock);
745
746 new_opp = _allocate_opp(dev, &dev_opp);
747 if (!new_opp) {
748 ret = -ENOMEM;
749 goto unlock;
750 }
751
752 /* populate the opp table */
753 new_opp->rate = freq;
754 new_opp->u_volt = u_volt;
755 new_opp->available = true;
756 new_opp->dynamic = dynamic;
757
758 ret = _opp_add(dev, new_opp, dev_opp);
759 if (ret)
760 goto free_opp;
761
762 mutex_unlock(&dev_opp_list_lock);
763
764 /*
765 * Notify the changes in the availability of the operable
766 * frequency/voltage list.
767 */
768 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
769 return 0;
770
771 free_opp:
772 _opp_remove(dev_opp, new_opp, false);
773 unlock:
774 mutex_unlock(&dev_opp_list_lock);
775 return ret;
776 }
777
778 /* TODO: Support multiple regulators */
opp_parse_supplies(struct dev_pm_opp * opp,struct device * dev)779 static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev)
780 {
781 u32 microvolt[3] = {0};
782 u32 val;
783 int count, ret;
784
785 /* Missing property isn't a problem, but an invalid entry is */
786 if (!of_find_property(opp->np, "opp-microvolt", NULL))
787 return 0;
788
789 count = of_property_count_u32_elems(opp->np, "opp-microvolt");
790 if (count < 0) {
791 dev_err(dev, "%s: Invalid opp-microvolt property (%d)\n",
792 __func__, count);
793 return count;
794 }
795
796 /* There can be one or three elements here */
797 if (count != 1 && count != 3) {
798 dev_err(dev, "%s: Invalid number of elements in opp-microvolt property (%d)\n",
799 __func__, count);
800 return -EINVAL;
801 }
802
803 ret = of_property_read_u32_array(opp->np, "opp-microvolt", microvolt,
804 count);
805 if (ret) {
806 dev_err(dev, "%s: error parsing opp-microvolt: %d\n", __func__,
807 ret);
808 return -EINVAL;
809 }
810
811 opp->u_volt = microvolt[0];
812
813 if (count == 1) {
814 opp->u_volt_min = opp->u_volt;
815 opp->u_volt_max = opp->u_volt;
816 } else {
817 opp->u_volt_min = microvolt[1];
818 opp->u_volt_max = microvolt[2];
819 }
820
821 if (!of_property_read_u32(opp->np, "opp-microamp", &val))
822 opp->u_amp = val;
823
824 return 0;
825 }
826
827 /**
828 * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)
829 * @dev: device for which we do this operation
830 * @np: device node
831 *
832 * This function adds an opp definition to the opp list and returns status. The
833 * opp can be controlled using dev_pm_opp_enable/disable functions and may be
834 * removed by dev_pm_opp_remove.
835 *
836 * Locking: The internal device_opp and opp structures are RCU protected.
837 * Hence this function internally uses RCU updater strategy with mutex locks
838 * to keep the integrity of the internal data structures. Callers should ensure
839 * that this function is *NOT* called under RCU protection or in contexts where
840 * mutex cannot be locked.
841 *
842 * Return:
843 * 0 On success OR
844 * Duplicate OPPs (both freq and volt are same) and opp->available
845 * -EEXIST Freq are same and volt are different OR
846 * Duplicate OPPs (both freq and volt are same) and !opp->available
847 * -ENOMEM Memory allocation failure
848 * -EINVAL Failed parsing the OPP node
849 */
_opp_add_static_v2(struct device * dev,struct device_node * np)850 static int _opp_add_static_v2(struct device *dev, struct device_node *np)
851 {
852 struct device_opp *dev_opp;
853 struct dev_pm_opp *new_opp;
854 u64 rate;
855 u32 val;
856 int ret;
857
858 /* Hold our list modification lock here */
859 mutex_lock(&dev_opp_list_lock);
860
861 new_opp = _allocate_opp(dev, &dev_opp);
862 if (!new_opp) {
863 ret = -ENOMEM;
864 goto unlock;
865 }
866
867 ret = of_property_read_u64(np, "opp-hz", &rate);
868 if (ret < 0) {
869 dev_err(dev, "%s: opp-hz not found\n", __func__);
870 goto free_opp;
871 }
872
873 /*
874 * Rate is defined as an unsigned long in clk API, and so casting
875 * explicitly to its type. Must be fixed once rate is 64 bit
876 * guaranteed in clk API.
877 */
878 new_opp->rate = (unsigned long)rate;
879 new_opp->turbo = of_property_read_bool(np, "turbo-mode");
880
881 new_opp->np = np;
882 new_opp->dynamic = false;
883 new_opp->available = true;
884
885 if (!of_property_read_u32(np, "clock-latency-ns", &val))
886 new_opp->clock_latency_ns = val;
887
888 ret = opp_parse_supplies(new_opp, dev);
889 if (ret)
890 goto free_opp;
891
892 ret = _opp_add(dev, new_opp, dev_opp);
893 if (ret)
894 goto free_opp;
895
896 /* OPP to select on device suspend */
897 if (of_property_read_bool(np, "opp-suspend")) {
898 if (dev_opp->suspend_opp)
899 dev_warn(dev, "%s: Multiple suspend OPPs found (%lu %lu)\n",
900 __func__, dev_opp->suspend_opp->rate,
901 new_opp->rate);
902 else
903 dev_opp->suspend_opp = new_opp;
904 }
905
906 if (new_opp->clock_latency_ns > dev_opp->clock_latency_ns_max)
907 dev_opp->clock_latency_ns_max = new_opp->clock_latency_ns;
908
909 mutex_unlock(&dev_opp_list_lock);
910
911 pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu\n",
912 __func__, new_opp->turbo, new_opp->rate, new_opp->u_volt,
913 new_opp->u_volt_min, new_opp->u_volt_max,
914 new_opp->clock_latency_ns);
915
916 /*
917 * Notify the changes in the availability of the operable
918 * frequency/voltage list.
919 */
920 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
921 return 0;
922
923 free_opp:
924 _opp_remove(dev_opp, new_opp, false);
925 unlock:
926 mutex_unlock(&dev_opp_list_lock);
927 return ret;
928 }
929
930 /**
931 * dev_pm_opp_add() - Add an OPP table from a table definitions
932 * @dev: device for which we do this operation
933 * @freq: Frequency in Hz for this OPP
934 * @u_volt: Voltage in uVolts for this OPP
935 *
936 * This function adds an opp definition to the opp list and returns status.
937 * The opp is made available by default and it can be controlled using
938 * dev_pm_opp_enable/disable functions.
939 *
940 * Locking: The internal device_opp and opp structures are RCU protected.
941 * Hence this function internally uses RCU updater strategy with mutex locks
942 * to keep the integrity of the internal data structures. Callers should ensure
943 * that this function is *NOT* called under RCU protection or in contexts where
944 * mutex cannot be locked.
945 *
946 * Return:
947 * 0 On success OR
948 * Duplicate OPPs (both freq and volt are same) and opp->available
949 * -EEXIST Freq are same and volt are different OR
950 * Duplicate OPPs (both freq and volt are same) and !opp->available
951 * -ENOMEM Memory allocation failure
952 */
dev_pm_opp_add(struct device * dev,unsigned long freq,unsigned long u_volt)953 int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
954 {
955 return _opp_add_v1(dev, freq, u_volt, true);
956 }
957 EXPORT_SYMBOL_GPL(dev_pm_opp_add);
958
959 /**
960 * _opp_set_availability() - helper to set the availability of an opp
961 * @dev: device for which we do this operation
962 * @freq: OPP frequency to modify availability
963 * @availability_req: availability status requested for this opp
964 *
965 * Set the availability of an OPP with an RCU operation, opp_{enable,disable}
966 * share a common logic which is isolated here.
967 *
968 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
969 * copy operation, returns 0 if no modification was done OR modification was
970 * successful.
971 *
972 * Locking: The internal device_opp and opp structures are RCU protected.
973 * Hence this function internally uses RCU updater strategy with mutex locks to
974 * keep the integrity of the internal data structures. Callers should ensure
975 * that this function is *NOT* called under RCU protection or in contexts where
976 * mutex locking or synchronize_rcu() blocking calls cannot be used.
977 */
_opp_set_availability(struct device * dev,unsigned long freq,bool availability_req)978 static int _opp_set_availability(struct device *dev, unsigned long freq,
979 bool availability_req)
980 {
981 struct device_opp *dev_opp;
982 struct dev_pm_opp *new_opp, *tmp_opp, *opp = ERR_PTR(-ENODEV);
983 int r = 0;
984
985 /* keep the node allocated */
986 new_opp = kmalloc(sizeof(*new_opp), GFP_KERNEL);
987 if (!new_opp)
988 return -ENOMEM;
989
990 mutex_lock(&dev_opp_list_lock);
991
992 /* Find the device_opp */
993 dev_opp = _find_device_opp(dev);
994 if (IS_ERR(dev_opp)) {
995 r = PTR_ERR(dev_opp);
996 dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);
997 goto unlock;
998 }
999
1000 /* Do we have the frequency? */
1001 list_for_each_entry(tmp_opp, &dev_opp->opp_list, node) {
1002 if (tmp_opp->rate == freq) {
1003 opp = tmp_opp;
1004 break;
1005 }
1006 }
1007 if (IS_ERR(opp)) {
1008 r = PTR_ERR(opp);
1009 goto unlock;
1010 }
1011
1012 /* Is update really needed? */
1013 if (opp->available == availability_req)
1014 goto unlock;
1015 /* copy the old data over */
1016 *new_opp = *opp;
1017
1018 /* plug in new node */
1019 new_opp->available = availability_req;
1020
1021 list_replace_rcu(&opp->node, &new_opp->node);
1022 mutex_unlock(&dev_opp_list_lock);
1023 call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);
1024
1025 /* Notify the change of the OPP availability */
1026 if (availability_req)
1027 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ENABLE,
1028 new_opp);
1029 else
1030 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_DISABLE,
1031 new_opp);
1032
1033 return 0;
1034
1035 unlock:
1036 mutex_unlock(&dev_opp_list_lock);
1037 kfree(new_opp);
1038 return r;
1039 }
1040
1041 /**
1042 * dev_pm_opp_enable() - Enable a specific OPP
1043 * @dev: device for which we do this operation
1044 * @freq: OPP frequency to enable
1045 *
1046 * Enables a provided opp. If the operation is valid, this returns 0, else the
1047 * corresponding error value. It is meant to be used for users an OPP available
1048 * after being temporarily made unavailable with dev_pm_opp_disable.
1049 *
1050 * Locking: The internal device_opp and opp structures are RCU protected.
1051 * Hence this function indirectly uses RCU and mutex locks to keep the
1052 * integrity of the internal data structures. Callers should ensure that
1053 * this function is *NOT* called under RCU protection or in contexts where
1054 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1055 *
1056 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1057 * copy operation, returns 0 if no modification was done OR modification was
1058 * successful.
1059 */
dev_pm_opp_enable(struct device * dev,unsigned long freq)1060 int dev_pm_opp_enable(struct device *dev, unsigned long freq)
1061 {
1062 return _opp_set_availability(dev, freq, true);
1063 }
1064 EXPORT_SYMBOL_GPL(dev_pm_opp_enable);
1065
1066 /**
1067 * dev_pm_opp_disable() - Disable a specific OPP
1068 * @dev: device for which we do this operation
1069 * @freq: OPP frequency to disable
1070 *
1071 * Disables a provided opp. If the operation is valid, this returns
1072 * 0, else the corresponding error value. It is meant to be a temporary
1073 * control by users to make this OPP not available until the circumstances are
1074 * right to make it available again (with a call to dev_pm_opp_enable).
1075 *
1076 * Locking: The internal device_opp and opp structures are RCU protected.
1077 * Hence this function indirectly uses RCU and mutex locks to keep the
1078 * integrity of the internal data structures. Callers should ensure that
1079 * this function is *NOT* called under RCU protection or in contexts where
1080 * mutex locking or synchronize_rcu() blocking calls cannot be used.
1081 *
1082 * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1083 * copy operation, returns 0 if no modification was done OR modification was
1084 * successful.
1085 */
dev_pm_opp_disable(struct device * dev,unsigned long freq)1086 int dev_pm_opp_disable(struct device *dev, unsigned long freq)
1087 {
1088 return _opp_set_availability(dev, freq, false);
1089 }
1090 EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
1091
1092 /**
1093 * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
1094 * @dev: device pointer used to lookup device OPPs.
1095 *
1096 * Return: pointer to notifier head if found, otherwise -ENODEV or
1097 * -EINVAL based on type of error casted as pointer. value must be checked
1098 * with IS_ERR to determine valid pointer or error result.
1099 *
1100 * Locking: This function must be called under rcu_read_lock(). dev_opp is a RCU
1101 * protected pointer. The reason for the same is that the opp pointer which is
1102 * returned will remain valid for use with opp_get_{voltage, freq} only while
1103 * under the locked area. The pointer returned must be used prior to unlocking
1104 * with rcu_read_unlock() to maintain the integrity of the pointer.
1105 */
dev_pm_opp_get_notifier(struct device * dev)1106 struct srcu_notifier_head *dev_pm_opp_get_notifier(struct device *dev)
1107 {
1108 struct device_opp *dev_opp = _find_device_opp(dev);
1109
1110 if (IS_ERR(dev_opp))
1111 return ERR_CAST(dev_opp); /* matching type */
1112
1113 return &dev_opp->srcu_head;
1114 }
1115 EXPORT_SYMBOL_GPL(dev_pm_opp_get_notifier);
1116
1117 #ifdef CONFIG_OF
1118 /**
1119 * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT
1120 * entries
1121 * @dev: device pointer used to lookup device OPPs.
1122 *
1123 * Free OPPs created using static entries present in DT.
1124 *
1125 * Locking: The internal device_opp and opp structures are RCU protected.
1126 * Hence this function indirectly uses RCU updater strategy with mutex locks
1127 * to keep the integrity of the internal data structures. Callers should ensure
1128 * that this function is *NOT* called under RCU protection or in contexts where
1129 * mutex cannot be locked.
1130 */
dev_pm_opp_of_remove_table(struct device * dev)1131 void dev_pm_opp_of_remove_table(struct device *dev)
1132 {
1133 struct device_opp *dev_opp;
1134 struct dev_pm_opp *opp, *tmp;
1135
1136 /* Hold our list modification lock here */
1137 mutex_lock(&dev_opp_list_lock);
1138
1139 /* Check for existing list for 'dev' */
1140 dev_opp = _find_device_opp(dev);
1141 if (IS_ERR(dev_opp)) {
1142 int error = PTR_ERR(dev_opp);
1143
1144 if (error != -ENODEV)
1145 WARN(1, "%s: dev_opp: %d\n",
1146 IS_ERR_OR_NULL(dev) ?
1147 "Invalid device" : dev_name(dev),
1148 error);
1149 goto unlock;
1150 }
1151
1152 /* Find if dev_opp manages a single device */
1153 if (list_is_singular(&dev_opp->dev_list)) {
1154 /* Free static OPPs */
1155 list_for_each_entry_safe(opp, tmp, &dev_opp->opp_list, node) {
1156 if (!opp->dynamic)
1157 _opp_remove(dev_opp, opp, true);
1158 }
1159 } else {
1160 _remove_list_dev(_find_list_dev(dev, dev_opp), dev_opp);
1161 }
1162
1163 unlock:
1164 mutex_unlock(&dev_opp_list_lock);
1165 }
1166 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table);
1167
1168 /* Returns opp descriptor node for a device, caller must do of_node_put() */
_of_get_opp_desc_node(struct device * dev)1169 struct device_node *_of_get_opp_desc_node(struct device *dev)
1170 {
1171 /*
1172 * TODO: Support for multiple OPP tables.
1173 *
1174 * There should be only ONE phandle present in "operating-points-v2"
1175 * property.
1176 */
1177
1178 return of_parse_phandle(dev->of_node, "operating-points-v2", 0);
1179 }
1180
1181 /* Initializes OPP tables based on new bindings */
_of_add_opp_table_v2(struct device * dev,struct device_node * opp_np)1182 static int _of_add_opp_table_v2(struct device *dev, struct device_node *opp_np)
1183 {
1184 struct device_node *np;
1185 struct device_opp *dev_opp;
1186 int ret = 0, count = 0;
1187
1188 mutex_lock(&dev_opp_list_lock);
1189
1190 dev_opp = _managed_opp(opp_np);
1191 if (dev_opp) {
1192 /* OPPs are already managed */
1193 if (!_add_list_dev(dev, dev_opp))
1194 ret = -ENOMEM;
1195 mutex_unlock(&dev_opp_list_lock);
1196 return ret;
1197 }
1198 mutex_unlock(&dev_opp_list_lock);
1199
1200 /* We have opp-list node now, iterate over it and add OPPs */
1201 for_each_available_child_of_node(opp_np, np) {
1202 count++;
1203
1204 ret = _opp_add_static_v2(dev, np);
1205 if (ret) {
1206 dev_err(dev, "%s: Failed to add OPP, %d\n", __func__,
1207 ret);
1208 of_node_put(np);
1209 goto free_table;
1210 }
1211 }
1212
1213 /* There should be one of more OPP defined */
1214 if (WARN_ON(!count))
1215 return -ENOENT;
1216
1217 mutex_lock(&dev_opp_list_lock);
1218
1219 dev_opp = _find_device_opp(dev);
1220 if (WARN_ON(IS_ERR(dev_opp))) {
1221 ret = PTR_ERR(dev_opp);
1222 mutex_unlock(&dev_opp_list_lock);
1223 goto free_table;
1224 }
1225
1226 dev_opp->np = opp_np;
1227 dev_opp->shared_opp = of_property_read_bool(opp_np, "opp-shared");
1228
1229 mutex_unlock(&dev_opp_list_lock);
1230
1231 return 0;
1232
1233 free_table:
1234 dev_pm_opp_of_remove_table(dev);
1235
1236 return ret;
1237 }
1238
1239 /* Initializes OPP tables based on old-deprecated bindings */
_of_add_opp_table_v1(struct device * dev)1240 static int _of_add_opp_table_v1(struct device *dev)
1241 {
1242 const struct property *prop;
1243 const __be32 *val;
1244 int nr;
1245
1246 prop = of_find_property(dev->of_node, "operating-points", NULL);
1247 if (!prop)
1248 return -ENODEV;
1249 if (!prop->value)
1250 return -ENODATA;
1251
1252 /*
1253 * Each OPP is a set of tuples consisting of frequency and
1254 * voltage like <freq-kHz vol-uV>.
1255 */
1256 nr = prop->length / sizeof(u32);
1257 if (nr % 2) {
1258 dev_err(dev, "%s: Invalid OPP list\n", __func__);
1259 return -EINVAL;
1260 }
1261
1262 val = prop->value;
1263 while (nr) {
1264 unsigned long freq = be32_to_cpup(val++) * 1000;
1265 unsigned long volt = be32_to_cpup(val++);
1266
1267 if (_opp_add_v1(dev, freq, volt, false))
1268 dev_warn(dev, "%s: Failed to add OPP %ld\n",
1269 __func__, freq);
1270 nr -= 2;
1271 }
1272
1273 return 0;
1274 }
1275
1276 /**
1277 * dev_pm_opp_of_add_table() - Initialize opp table from device tree
1278 * @dev: device pointer used to lookup device OPPs.
1279 *
1280 * Register the initial OPP table with the OPP library for given device.
1281 *
1282 * Locking: The internal device_opp and opp structures are RCU protected.
1283 * Hence this function indirectly uses RCU updater strategy with mutex locks
1284 * to keep the integrity of the internal data structures. Callers should ensure
1285 * that this function is *NOT* called under RCU protection or in contexts where
1286 * mutex cannot be locked.
1287 *
1288 * Return:
1289 * 0 On success OR
1290 * Duplicate OPPs (both freq and volt are same) and opp->available
1291 * -EEXIST Freq are same and volt are different OR
1292 * Duplicate OPPs (both freq and volt are same) and !opp->available
1293 * -ENOMEM Memory allocation failure
1294 * -ENODEV when 'operating-points' property is not found or is invalid data
1295 * in device node.
1296 * -ENODATA when empty 'operating-points' property is found
1297 * -EINVAL when invalid entries are found in opp-v2 table
1298 */
dev_pm_opp_of_add_table(struct device * dev)1299 int dev_pm_opp_of_add_table(struct device *dev)
1300 {
1301 struct device_node *opp_np;
1302 int ret;
1303
1304 /*
1305 * OPPs have two version of bindings now. The older one is deprecated,
1306 * try for the new binding first.
1307 */
1308 opp_np = _of_get_opp_desc_node(dev);
1309 if (!opp_np) {
1310 /*
1311 * Try old-deprecated bindings for backward compatibility with
1312 * older dtbs.
1313 */
1314 return _of_add_opp_table_v1(dev);
1315 }
1316
1317 ret = _of_add_opp_table_v2(dev, opp_np);
1318 of_node_put(opp_np);
1319
1320 return ret;
1321 }
1322 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);
1323 #endif
1324