• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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