1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Generic OPP OF helpers
4	*
5	* Copyright (C) 2009-2010 Texas Instruments Incorporated.
6	* Nishanth Menon
7	* Romit Dasgupta
8	* Kevin Hilman
9	*/
10
11	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12
13	#include <linux/cpu.h>
14	#include <linux/errno.h>
15	#include <linux/device.h>
16	#include <linux/of.h>
17	#include <linux/pm_domain.h>
18	#include <linux/slab.h>
19	#include <linux/export.h>
20	#include <linux/energy_model.h>
21
22	#include "opp.h"
23
24	/* OPP tables with uninitialized required OPPs, protected by opp_table_lock */
25	static LIST_HEAD(lazy_opp_tables);
26
27	/*
28	* Returns opp descriptor node for a device node, caller must
29	* do of_node_put().
30	*/
31	static struct device_node *_opp_of_get_opp_desc_node(struct device_node *np,
32	int index)
33	{
34	/* "operating-points-v2" can be an array for power domain providers */
35	return of_parse_phandle(np, phandle_name: "operating-points-v2", index);
36	}
37
38	/* Returns opp descriptor node for a device, caller must do of_node_put() */
39	struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev)
40	{
41	return _opp_of_get_opp_desc_node(np: dev->of_node, index: 0);
42	}
43	EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_opp_desc_node);
44
45	struct opp_table *_managed_opp(struct device *dev, int index)
46	{
47	struct opp_table *opp_table, *managed_table = NULL;
48	struct device_node *np;
49
50	np = _opp_of_get_opp_desc_node(np: dev->of_node, index);
51	if (!np)
52	return NULL;
53
54	list_for_each_entry(opp_table, &opp_tables, node) {
55	if (opp_table->np == np) {
56	/*
57	* Multiple devices can point to the same OPP table and
58	* so will have same node-pointer, np.
59	*
60	* But the OPPs will be considered as shared only if the
61	* OPP table contains a "opp-shared" property.
62	*/
63	if (opp_table->shared_opp == OPP_TABLE_ACCESS_SHARED) {
64	_get_opp_table_kref(opp_table);
65	managed_table = opp_table;
66	}
67
68	break;
69	}
70	}
71
72	of_node_put(node: np);
73
74	return managed_table;
75	}
76
77	/* The caller must call dev_pm_opp_put() after the OPP is used */
78	static struct dev_pm_opp *_find_opp_of_np(struct opp_table *opp_table,
79	struct device_node *opp_np)
80	{
81	struct dev_pm_opp *opp;
82
83	mutex_lock(&opp_table->lock);
84
85	list_for_each_entry(opp, &opp_table->opp_list, node) {
86	if (opp->np == opp_np) {
87	dev_pm_opp_get(opp);
88	mutex_unlock(lock: &opp_table->lock);
89	return opp;
90	}
91	}
92
93	mutex_unlock(lock: &opp_table->lock);
94
95	return NULL;
96	}
97
98	static struct device_node *of_parse_required_opp(struct device_node *np,
99	int index)
100	{
101	return of_parse_phandle(np, phandle_name: "required-opps", index);
102	}
103
104	/* The caller must call dev_pm_opp_put_opp_table() after the table is used */
105	static struct opp_table *_find_table_of_opp_np(struct device_node *opp_np)
106	{
107	struct opp_table *opp_table;
108	struct device_node *opp_table_np;
109
110	opp_table_np = of_get_parent(node: opp_np);
111	if (!opp_table_np)
112	goto err;
113
114	/* It is safe to put the node now as all we need now is its address */
115	of_node_put(node: opp_table_np);
116
117	mutex_lock(&opp_table_lock);
118	list_for_each_entry(opp_table, &opp_tables, node) {
119	if (opp_table_np == opp_table->np) {
120	_get_opp_table_kref(opp_table);
121	mutex_unlock(lock: &opp_table_lock);
122	return opp_table;
123	}
124	}
125	mutex_unlock(lock: &opp_table_lock);
126
127	err:
128	return ERR_PTR(error: -ENODEV);
129	}
130
131	/* Free resources previously acquired by _opp_table_alloc_required_tables() */
132	static void _opp_table_free_required_tables(struct opp_table *opp_table)
133	{
134	struct opp_table **required_opp_tables = opp_table->required_opp_tables;
135	int i;
136
137	if (!required_opp_tables)
138	return;
139
140	for (i = 0; i < opp_table->required_opp_count; i++) {
141	if (IS_ERR_OR_NULL(ptr: required_opp_tables[i]))
142	continue;
143
144	dev_pm_opp_put_opp_table(opp_table: required_opp_tables[i]);
145	}
146
147	kfree(objp: required_opp_tables);
148
149	opp_table->required_opp_count = 0;
150	opp_table->required_opp_tables = NULL;
151
152	mutex_lock(&opp_table_lock);
153	list_del(entry: &opp_table->lazy);
154	mutex_unlock(lock: &opp_table_lock);
155	}
156
157	/*
158	* Populate all devices and opp tables which are part of "required-opps" list.
159	* Checking only the first OPP node should be enough.
160	*/
161	static void _opp_table_alloc_required_tables(struct opp_table *opp_table,
162	struct device *dev,
163	struct device_node *opp_np)
164	{
165	struct opp_table **required_opp_tables;
166	struct device_node *required_np, *np;
167	bool lazy = false;
168	int count, i, size;
169
170	/* Traversing the first OPP node is all we need */
171	np = of_get_next_available_child(node: opp_np, NULL);
172	if (!np) {
173	dev_warn(dev, "Empty OPP table\n");
174
175	return;
176	}
177
178	count = of_count_phandle_with_args(np, list_name: "required-opps", NULL);
179	if (count <= 0)
180	goto put_np;
181
182	size = sizeof(*required_opp_tables) + sizeof(*opp_table->required_devs);
183	required_opp_tables = kcalloc(n: count, size, GFP_KERNEL);
184	if (!required_opp_tables)
185	goto put_np;
186
187	opp_table->required_opp_tables = required_opp_tables;
188	opp_table->required_devs = (void *)(required_opp_tables + count);
189	opp_table->required_opp_count = count;
190
191	for (i = 0; i < count; i++) {
192	required_np = of_parse_required_opp(np, index: i);
193	if (!required_np)
194	goto free_required_tables;
195
196	required_opp_tables[i] = _find_table_of_opp_np(opp_np: required_np);
197	of_node_put(node: required_np);
198
199	if (IS_ERR(ptr: required_opp_tables[i]))
200	lazy = true;
201	}
202
203	/* Let's do the linking later on */
204	if (lazy) {
205	/*
206	* The OPP table is not held while allocating the table, take it
207	* now to avoid corruption to the lazy_opp_tables list.
208	*/
209	mutex_lock(&opp_table_lock);
210	list_add(new: &opp_table->lazy, head: &lazy_opp_tables);
211	mutex_unlock(lock: &opp_table_lock);
212	}
213
214	goto put_np;
215
216	free_required_tables:
217	_opp_table_free_required_tables(opp_table);
218	put_np:
219	of_node_put(node: np);
220	}
221
222	void _of_init_opp_table(struct opp_table *opp_table, struct device *dev,
223	int index)
224	{
225	struct device_node *np, *opp_np;
226	u32 val;
227
228	/*
229	* Only required for backward compatibility with v1 bindings, but isn't
230	* harmful for other cases. And so we do it unconditionally.
231	*/
232	np = of_node_get(node: dev->of_node);
233	if (!np)
234	return;
235
236	if (!of_property_read_u32(np, propname: "clock-latency", out_value: &val))
237	opp_table->clock_latency_ns_max = val;
238	of_property_read_u32(np, propname: "voltage-tolerance",
239	out_value: &opp_table->voltage_tolerance_v1);
240
241	if (of_property_present(np, propname: "#power-domain-cells"))
242	opp_table->is_genpd = true;
243
244	/* Get OPP table node */
245	opp_np = _opp_of_get_opp_desc_node(np, index);
246	of_node_put(node: np);
247
248	if (!opp_np)
249	return;
250
251	if (of_property_read_bool(np: opp_np, propname: "opp-shared"))
252	opp_table->shared_opp = OPP_TABLE_ACCESS_SHARED;
253	else
254	opp_table->shared_opp = OPP_TABLE_ACCESS_EXCLUSIVE;
255
256	opp_table->np = opp_np;
257
258	_opp_table_alloc_required_tables(opp_table, dev, opp_np);
259	}
260
261	void _of_clear_opp_table(struct opp_table *opp_table)
262	{
263	_opp_table_free_required_tables(opp_table);
264	of_node_put(node: opp_table->np);
265	}
266
267	/*
268	* Release all resources previously acquired with a call to
269	* _of_opp_alloc_required_opps().
270	*/
271	static void _of_opp_free_required_opps(struct opp_table *opp_table,
272	struct dev_pm_opp *opp)
273	{
274	struct dev_pm_opp **required_opps = opp->required_opps;
275	int i;
276
277	if (!required_opps)
278	return;
279
280	for (i = 0; i < opp_table->required_opp_count; i++) {
281	if (!required_opps[i])
282	continue;
283
284	/* Put the reference back */
285	dev_pm_opp_put(opp: required_opps[i]);
286	}
287
288	opp->required_opps = NULL;
289	kfree(objp: required_opps);
290	}
291
292	void _of_clear_opp(struct opp_table *opp_table, struct dev_pm_opp *opp)
293	{
294	_of_opp_free_required_opps(opp_table, opp);
295	of_node_put(node: opp->np);
296	}
297
298	static int _link_required_opps(struct dev_pm_opp *opp, struct opp_table *opp_table,
299	struct opp_table *required_table, int index)
300	{
301	struct device_node *np;
302
303	np = of_parse_required_opp(np: opp->np, index);
304	if (unlikely(!np))
305	return -ENODEV;
306
307	opp->required_opps[index] = _find_opp_of_np(opp_table: required_table, opp_np: np);
308	of_node_put(node: np);
309
310	if (!opp->required_opps[index]) {
311	pr_err("%s: Unable to find required OPP node: %pOF (%d)\n",
312	__func__, opp->np, index);
313	return -ENODEV;
314	}
315
316	/*
317	* There are two genpd (as required-opp) cases that we need to handle,
318	* devices with a single genpd and ones with multiple genpds.
319	*
320	* The single genpd case requires special handling as we need to use the
321	* same `dev` structure (instead of a virtual one provided by genpd
322	* core) for setting the performance state.
323	*
324	* It doesn't make sense for a device's DT entry to have both
325	* "opp-level" and single "required-opps" entry pointing to a genpd's
326	* OPP, as that would make the OPP core call
327	* dev_pm_domain_set_performance_state() for two different values for
328	* the same device structure. Lets treat single genpd configuration as a
329	* case where the OPP's level is directly available without required-opp
330	* link in the DT.
331	*
332	* Just update the `level` with the right value, which
333	* dev_pm_opp_set_opp() will take care of in the normal path itself.
334	*
335	* There is another case though, where a genpd's OPP table has
336	* required-opps set to a parent genpd. The OPP core expects the user to
337	* set the respective required `struct device` pointer via
338	* dev_pm_opp_set_config().
339	*/
340	if (required_table->is_genpd && opp_table->required_opp_count == 1 &&
341	!opp_table->required_devs[0]) {
342	/* Genpd core takes care of propagation to parent genpd */
343	if (!opp_table->is_genpd) {
344	if (!WARN_ON(opp->level != OPP_LEVEL_UNSET))
345	opp->level = opp->required_opps[0]->level;
346	}
347	}
348
349	return 0;
350	}
351
352	/* Populate all required OPPs which are part of "required-opps" list */
353	static int _of_opp_alloc_required_opps(struct opp_table *opp_table,
354	struct dev_pm_opp *opp)
355	{
356	struct opp_table *required_table;
357	int i, ret, count = opp_table->required_opp_count;
358
359	if (!count)
360	return 0;
361
362	opp->required_opps = kcalloc(n: count, size: sizeof(*opp->required_opps), GFP_KERNEL);
363	if (!opp->required_opps)
364	return -ENOMEM;
365
366	for (i = 0; i < count; i++) {
367	required_table = opp_table->required_opp_tables[i];
368
369	/* Required table not added yet, we will link later */
370	if (IS_ERR_OR_NULL(ptr: required_table))
371	continue;
372
373	ret = _link_required_opps(opp, opp_table, required_table, index: i);
374	if (ret)
375	goto free_required_opps;
376	}
377
378	return 0;
379
380	free_required_opps:
381	_of_opp_free_required_opps(opp_table, opp);
382
383	return ret;
384	}
385
386	/* Link required OPPs for an individual OPP */
387	static int lazy_link_required_opps(struct opp_table *opp_table,
388	struct opp_table *new_table, int index)
389	{
390	struct dev_pm_opp *opp;
391	int ret;
392
393	list_for_each_entry(opp, &opp_table->opp_list, node) {
394	ret = _link_required_opps(opp, opp_table, required_table: new_table, index);
395	if (ret)
396	return ret;
397	}
398
399	return 0;
400	}
401
402	/* Link required OPPs for all OPPs of the newly added OPP table */
403	static void lazy_link_required_opp_table(struct opp_table *new_table)
404	{
405	struct opp_table *opp_table, *temp, **required_opp_tables;
406	struct device_node *required_np, *opp_np, *required_table_np;
407	struct dev_pm_opp *opp;
408	int i, ret;
409
410	mutex_lock(&opp_table_lock);
411
412	list_for_each_entry_safe(opp_table, temp, &lazy_opp_tables, lazy) {
413	bool lazy = false;
414
415	/* opp_np can't be invalid here */
416	opp_np = of_get_next_available_child(node: opp_table->np, NULL);
417
418	for (i = 0; i < opp_table->required_opp_count; i++) {
419	required_opp_tables = opp_table->required_opp_tables;
420
421	/* Required opp-table is already parsed */
422	if (!IS_ERR(ptr: required_opp_tables[i]))
423	continue;
424
425	/* required_np can't be invalid here */
426	required_np = of_parse_required_opp(np: opp_np, index: i);
427	required_table_np = of_get_parent(node: required_np);
428
429	of_node_put(node: required_table_np);
430	of_node_put(node: required_np);
431
432	/*
433	* Newly added table isn't the required opp-table for
434	* opp_table.
435	*/
436	if (required_table_np != new_table->np) {
437	lazy = true;
438	continue;
439	}
440
441	required_opp_tables[i] = new_table;
442	_get_opp_table_kref(opp_table: new_table);
443
444	/* Link OPPs now */
445	ret = lazy_link_required_opps(opp_table, new_table, index: i);
446	if (ret) {
447	/* The OPPs will be marked unusable */
448	lazy = false;
449	break;
450	}
451	}
452
453	of_node_put(node: opp_np);
454
455	/* All required opp-tables found, remove from lazy list */
456	if (!lazy) {
457	list_del_init(entry: &opp_table->lazy);
458
459	list_for_each_entry(opp, &opp_table->opp_list, node)
460	_required_opps_available(opp, count: opp_table->required_opp_count);
461	}
462	}
463
464	mutex_unlock(lock: &opp_table_lock);
465	}
466
467	static int _bandwidth_supported(struct device *dev, struct opp_table *opp_table)
468	{
469	struct device_node *np, *opp_np;
470	struct property *prop;
471
472	if (!opp_table) {
473	np = of_node_get(node: dev->of_node);
474	if (!np)
475	return -ENODEV;
476
477	opp_np = _opp_of_get_opp_desc_node(np, index: 0);
478	of_node_put(node: np);
479	} else {
480	opp_np = of_node_get(node: opp_table->np);
481	}
482
483	/* Lets not fail in case we are parsing opp-v1 bindings */
484	if (!opp_np)
485	return 0;
486
487	/* Checking only first OPP is sufficient */
488	np = of_get_next_available_child(node: opp_np, NULL);
489	of_node_put(node: opp_np);
490	if (!np) {
491	dev_err(dev, "OPP table empty\n");
492	return -EINVAL;
493	}
494
495	prop = of_find_property(np, name: "opp-peak-kBps", NULL);
496	of_node_put(node: np);
497
498	if (!prop || !prop->length)
499	return 0;
500
501	return 1;
502	}
503
504	int dev_pm_opp_of_find_icc_paths(struct device *dev,
505	struct opp_table *opp_table)
506	{
507	struct device_node *np;
508	int ret, i, count, num_paths;
509	struct icc_path **paths;
510
511	ret = _bandwidth_supported(dev, opp_table);
512	if (ret == -EINVAL)
513	return 0; /* Empty OPP table is a valid corner-case, let's not fail */
514	else if (ret <= 0)
515	return ret;
516
517	ret = 0;
518
519	np = of_node_get(node: dev->of_node);
520	if (!np)
521	return 0;
522
523	count = of_count_phandle_with_args(np, list_name: "interconnects",
524	cells_name: "#interconnect-cells");
525	of_node_put(node: np);
526	if (count < 0)
527	return 0;
528
529	/* two phandles when #interconnect-cells = <1> */
530	if (count % 2) {
531	dev_err(dev, "%s: Invalid interconnects values\n", __func__);
532	return -EINVAL;
533	}
534
535	num_paths = count / 2;
536	paths = kcalloc(n: num_paths, size: sizeof(*paths), GFP_KERNEL);
537	if (!paths)
538	return -ENOMEM;
539
540	for (i = 0; i < num_paths; i++) {
541	paths[i] = of_icc_get_by_index(dev, idx: i);
542	if (IS_ERR(ptr: paths[i])) {
543	ret = dev_err_probe(dev, err: PTR_ERR(ptr: paths[i]), fmt: "%s: Unable to get path%d\n", __func__, i);
544	goto err;
545	}
546	}
547
548	if (opp_table) {
549	opp_table->paths = paths;
550	opp_table->path_count = num_paths;
551	return 0;
552	}
553
554	err:
555	while (i--)
556	icc_put(path: paths[i]);
557
558	kfree(objp: paths);
559
560	return ret;
561	}
562	EXPORT_SYMBOL_GPL(dev_pm_opp_of_find_icc_paths);
563
564	static bool _opp_is_supported(struct device *dev, struct opp_table *opp_table,
565	struct device_node *np)
566	{
567	unsigned int levels = opp_table->supported_hw_count;
568	int count, versions, ret, i, j;
569	u32 val;
570
571	if (!opp_table->supported_hw) {
572	/*
573	* In the case that no supported_hw has been set by the
574	* platform but there is an opp-supported-hw value set for
575	* an OPP then the OPP should not be enabled as there is
576	* no way to see if the hardware supports it.
577	*/
578	if (of_property_present(np, propname: "opp-supported-hw"))
579	return false;
580	else
581	return true;
582	}
583
584	count = of_property_count_u32_elems(np, propname: "opp-supported-hw");
585	if (count <= 0 || count % levels) {
586	dev_err(dev, "%s: Invalid opp-supported-hw property (%d)\n",
587	__func__, count);
588	return false;
589	}
590
591	versions = count / levels;
592
593	/* All levels in at least one of the versions should match */
594	for (i = 0; i < versions; i++) {
595	bool supported = true;
596
597	for (j = 0; j < levels; j++) {
598	ret = of_property_read_u32_index(np, propname: "opp-supported-hw",
599	index: i * levels + j, out_value: &val);
600	if (ret) {
601	dev_warn(dev, "%s: failed to read opp-supported-hw property at index %d: %d\n",
602	__func__, i * levels + j, ret);
603	return false;
604	}
605
606	/* Check if the level is supported */
607	if (!(val & opp_table->supported_hw[j])) {
608	supported = false;
609	break;
610	}
611	}
612
613	if (supported)
614	return true;
615	}
616
617	return false;
618	}
619
620	static u32 *_parse_named_prop(struct dev_pm_opp *opp, struct device *dev,
621	struct opp_table *opp_table,
622	const char *prop_type, bool *triplet)
623	{
624	struct property *prop = NULL;
625	char name[NAME_MAX];
626	int count, ret;
627	u32 *out;
628
629	/* Search for "opp-<prop_type>-<name>" */
630	if (opp_table->prop_name) {
631	snprintf(buf: name, size: sizeof(name), fmt: "opp-%s-%s", prop_type,
632	opp_table->prop_name);
633	prop = of_find_property(np: opp->np, name, NULL);
634	}
635
636	if (!prop) {
637	/* Search for "opp-<prop_type>" */
638	snprintf(buf: name, size: sizeof(name), fmt: "opp-%s", prop_type);
639	prop = of_find_property(np: opp->np, name, NULL);
640	if (!prop)
641	return NULL;
642	}
643
644	count = of_property_count_u32_elems(np: opp->np, propname: name);
645	if (count < 0) {
646	dev_err(dev, "%s: Invalid %s property (%d)\n", __func__, name,
647	count);
648	return ERR_PTR(error: count);
649	}
650
651	/*
652	* Initialize regulator_count, if regulator information isn't provided
653	* by the platform. Now that one of the properties is available, fix the
654	* regulator_count to 1.
655	*/
656	if (unlikely(opp_table->regulator_count == -1))
657	opp_table->regulator_count = 1;
658
659	if (count != opp_table->regulator_count &&
660	(!triplet || count != opp_table->regulator_count * 3)) {
661	dev_err(dev, "%s: Invalid number of elements in %s property (%u) with supplies (%d)\n",
662	__func__, prop_type, count, opp_table->regulator_count);
663	return ERR_PTR(error: -EINVAL);
664	}
665
666	out = kmalloc_array(n: count, size: sizeof(*out), GFP_KERNEL);
667	if (!out)
668	return ERR_PTR(error: -EINVAL);
669
670	ret = of_property_read_u32_array(np: opp->np, propname: name, out_values: out, sz: count);
671	if (ret) {
672	dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret);
673	kfree(objp: out);
674	return ERR_PTR(error: -EINVAL);
675	}
676
677	if (triplet)
678	*triplet = count != opp_table->regulator_count;
679
680	return out;
681	}
682
683	static u32 *opp_parse_microvolt(struct dev_pm_opp *opp, struct device *dev,
684	struct opp_table *opp_table, bool *triplet)
685	{
686	u32 *microvolt;
687
688	microvolt = _parse_named_prop(opp, dev, opp_table, prop_type: "microvolt", triplet);
689	if (IS_ERR(ptr: microvolt))
690	return microvolt;
691
692	if (!microvolt) {
693	/*
694	* Missing property isn't a problem, but an invalid
695	* entry is. This property isn't optional if regulator
696	* information is provided. Check only for the first OPP, as
697	* regulator_count may get initialized after that to a valid
698	* value.
699	*/
700	if (list_empty(head: &opp_table->opp_list) &&
701	opp_table->regulator_count > 0) {
702	dev_err(dev, "%s: opp-microvolt missing although OPP managing regulators\n",
703	__func__);
704	return ERR_PTR(error: -EINVAL);
705	}
706	}
707
708	return microvolt;
709	}
710
711	static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev,
712	struct opp_table *opp_table)
713	{
714	u32 *microvolt, *microamp, *microwatt;
715	int ret = 0, i, j;
716	bool triplet;
717
718	microvolt = opp_parse_microvolt(opp, dev, opp_table, triplet: &triplet);
719	if (IS_ERR(ptr: microvolt))
720	return PTR_ERR(ptr: microvolt);
721
722	microamp = _parse_named_prop(opp, dev, opp_table, prop_type: "microamp", NULL);
723	if (IS_ERR(ptr: microamp)) {
724	ret = PTR_ERR(ptr: microamp);
725	goto free_microvolt;
726	}
727
728	microwatt = _parse_named_prop(opp, dev, opp_table, prop_type: "microwatt", NULL);
729	if (IS_ERR(ptr: microwatt)) {
730	ret = PTR_ERR(ptr: microwatt);
731	goto free_microamp;
732	}
733
734	/*
735	* Initialize regulator_count if it is uninitialized and no properties
736	* are found.
737	*/
738	if (unlikely(opp_table->regulator_count == -1)) {
739	opp_table->regulator_count = 0;
740	return 0;
741	}
742
743	for (i = 0, j = 0; i < opp_table->regulator_count; i++) {
744	if (microvolt) {
745	opp->supplies[i].u_volt = microvolt[j++];
746
747	if (triplet) {
748	opp->supplies[i].u_volt_min = microvolt[j++];
749	opp->supplies[i].u_volt_max = microvolt[j++];
750	} else {
751	opp->supplies[i].u_volt_min = opp->supplies[i].u_volt;
752	opp->supplies[i].u_volt_max = opp->supplies[i].u_volt;
753	}
754	}
755
756	if (microamp)
757	opp->supplies[i].u_amp = microamp[i];
758
759	if (microwatt)
760	opp->supplies[i].u_watt = microwatt[i];
761	}
762
763	kfree(objp: microwatt);
764	free_microamp:
765	kfree(objp: microamp);
766	free_microvolt:
767	kfree(objp: microvolt);
768
769	return ret;
770	}
771
772	/**
773	* dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT
774	* entries
775	* @dev: device pointer used to lookup OPP table.
776	*
777	* Free OPPs created using static entries present in DT.
778	*/
779	void dev_pm_opp_of_remove_table(struct device *dev)
780	{
781	dev_pm_opp_remove_table(dev);
782	}
783	EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table);
784
785	static int _read_rate(struct dev_pm_opp *new_opp, struct opp_table *opp_table,
786	struct device_node *np)
787	{
788	struct property *prop;
789	int i, count, ret;
790	u64 *rates;
791
792	prop = of_find_property(np, name: "opp-hz", NULL);
793	if (!prop)
794	return -ENODEV;
795
796	count = prop->length / sizeof(u64);
797	if (opp_table->clk_count != count) {
798	pr_err("%s: Count mismatch between opp-hz and clk_count (%d %d)\n",
799	__func__, count, opp_table->clk_count);
800	return -EINVAL;
801	}
802
803	rates = kmalloc_array(n: count, size: sizeof(*rates), GFP_KERNEL);
804	if (!rates)
805	return -ENOMEM;
806
807	ret = of_property_read_u64_array(np, propname: "opp-hz", out_values: rates, sz: count);
808	if (ret) {
809	pr_err("%s: Error parsing opp-hz: %d\n", __func__, ret);
810	} else {
811	/*
812	* Rate is defined as an unsigned long in clk API, and so
813	* casting explicitly to its type. Must be fixed once rate is 64
814	* bit guaranteed in clk API.
815	*/
816	for (i = 0; i < count; i++) {
817	new_opp->rates[i] = (unsigned long)rates[i];
818
819	/* This will happen for frequencies > 4.29 GHz */
820	WARN_ON(new_opp->rates[i] != rates[i]);
821	}
822	}
823
824	kfree(objp: rates);
825
826	return ret;
827	}
828
829	static int _read_bw(struct dev_pm_opp *new_opp, struct opp_table *opp_table,
830	struct device_node *np, bool peak)
831	{
832	const char *name = peak ? "opp-peak-kBps" : "opp-avg-kBps";
833	struct property *prop;
834	int i, count, ret;
835	u32 *bw;
836
837	prop = of_find_property(np, name, NULL);
838	if (!prop)
839	return -ENODEV;
840
841	count = prop->length / sizeof(u32);
842	if (opp_table->path_count != count) {
843	pr_err("%s: Mismatch between %s and paths (%d %d)\n",
844	__func__, name, count, opp_table->path_count);
845	return -EINVAL;
846	}
847
848	bw = kmalloc_array(n: count, size: sizeof(*bw), GFP_KERNEL);
849	if (!bw)
850	return -ENOMEM;
851
852	ret = of_property_read_u32_array(np, propname: name, out_values: bw, sz: count);
853	if (ret) {
854	pr_err("%s: Error parsing %s: %d\n", __func__, name, ret);
855	goto out;
856	}
857
858	for (i = 0; i < count; i++) {
859	if (peak)
860	new_opp->bandwidth[i].peak = kBps_to_icc(bw[i]);
861	else
862	new_opp->bandwidth[i].avg = kBps_to_icc(bw[i]);
863	}
864
865	out:
866	kfree(objp: bw);
867	return ret;
868	}
869
870	static int _read_opp_key(struct dev_pm_opp *new_opp,
871	struct opp_table *opp_table, struct device_node *np)
872	{
873	bool found = false;
874	int ret;
875
876	ret = _read_rate(new_opp, opp_table, np);
877	if (!ret)
878	found = true;
879	else if (ret != -ENODEV)
880	return ret;
881
882	/*
883	* Bandwidth consists of peak and average (optional) values:
884	* opp-peak-kBps = <path1_value path2_value>;
885	* opp-avg-kBps = <path1_value path2_value>;
886	*/
887	ret = _read_bw(new_opp, opp_table, np, peak: true);
888	if (!ret) {
889	found = true;
890	ret = _read_bw(new_opp, opp_table, np, peak: false);
891	}
892
893	/* The properties were found but we failed to parse them */
894	if (ret && ret != -ENODEV)
895	return ret;
896
897	if (!of_property_read_u32(np, propname: "opp-level", out_value: &new_opp->level))
898	found = true;
899
900	if (found)
901	return 0;
902
903	return ret;
904	}
905
906	/**
907	* _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)
908	* @opp_table: OPP table
909	* @dev: device for which we do this operation
910	* @np: device node
911	*
912	* This function adds an opp definition to the opp table and returns status. The
913	* opp can be controlled using dev_pm_opp_enable/disable functions and may be
914	* removed by dev_pm_opp_remove.
915	*
916	* Return:
917	* Valid OPP pointer:
918	* On success
919	* NULL:
920	* Duplicate OPPs (both freq and volt are same) and opp->available
921	* OR if the OPP is not supported by hardware.
922	* ERR_PTR(-EEXIST):
923	* Freq are same and volt are different OR
924	* Duplicate OPPs (both freq and volt are same) and !opp->available
925	* ERR_PTR(-ENOMEM):
926	* Memory allocation failure
927	* ERR_PTR(-EINVAL):
928	* Failed parsing the OPP node
929	*/
930	static struct dev_pm_opp *_opp_add_static_v2(struct opp_table *opp_table,
931	struct device *dev, struct device_node *np)
932	{
933	struct dev_pm_opp *new_opp;
934	u32 val;
935	int ret;
936
937	new_opp = _opp_allocate(opp_table);
938	if (!new_opp)
939	return ERR_PTR(error: -ENOMEM);
940
941	ret = _read_opp_key(new_opp, opp_table, np);
942	if (ret < 0) {
943	dev_err(dev, "%s: opp key field not found\n", __func__);
944	goto free_opp;
945	}
946
947	/* Check if the OPP supports hardware's hierarchy of versions or not */
948	if (!_opp_is_supported(dev, opp_table, np)) {
949	dev_dbg(dev, "OPP not supported by hardware: %s\n",
950	of_node_full_name(np));
951	goto free_opp;
952	}
953
954	new_opp->turbo = of_property_read_bool(np, propname: "turbo-mode");
955
956	new_opp->np = of_node_get(node: np);
957	new_opp->dynamic = false;
958	new_opp->available = true;
959
960	ret = _of_opp_alloc_required_opps(opp_table, opp: new_opp);
961	if (ret)
962	goto free_opp;
963
964	if (!of_property_read_u32(np, propname: "clock-latency-ns", out_value: &val))
965	new_opp->clock_latency_ns = val;
966
967	ret = opp_parse_supplies(opp: new_opp, dev, opp_table);
968	if (ret)
969	goto free_required_opps;
970
971	ret = _opp_add(dev, new_opp, opp_table);
972	if (ret) {
973	/* Don't return error for duplicate OPPs */
974	if (ret == -EBUSY)
975	ret = 0;
976	goto free_required_opps;
977	}
978
979	/* OPP to select on device suspend */
980	if (of_property_read_bool(np, propname: "opp-suspend")) {
981	if (opp_table->suspend_opp) {
982	/* Pick the OPP with higher rate/bw/level as suspend OPP */
983	if (_opp_compare_key(opp_table, opp1: new_opp, opp2: opp_table->suspend_opp) == 1) {
984	opp_table->suspend_opp->suspend = false;
985	new_opp->suspend = true;
986	opp_table->suspend_opp = new_opp;
987	}
988	} else {
989	new_opp->suspend = true;
990	opp_table->suspend_opp = new_opp;
991	}
992	}
993
994	if (new_opp->clock_latency_ns > opp_table->clock_latency_ns_max)
995	opp_table->clock_latency_ns_max = new_opp->clock_latency_ns;
996
997	pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu level:%u\n",
998	__func__, new_opp->turbo, new_opp->rates[0],
999	new_opp->supplies[0].u_volt, new_opp->supplies[0].u_volt_min,
1000	new_opp->supplies[0].u_volt_max, new_opp->clock_latency_ns,
1001	new_opp->level);
1002
1003	/*
1004	* Notify the changes in the availability of the operable
1005	* frequency/voltage list.
1006	*/
1007	blocking_notifier_call_chain(nh: &opp_table->head, val: OPP_EVENT_ADD, v: new_opp);
1008	return new_opp;
1009
1010	free_required_opps:
1011	_of_opp_free_required_opps(opp_table, opp: new_opp);
1012	free_opp:
1013	_opp_free(opp: new_opp);
1014
1015	return ret ? ERR_PTR(error: ret) : NULL;
1016	}
1017
1018	/* Initializes OPP tables based on new bindings */
1019	static int _of_add_opp_table_v2(struct device *dev, struct opp_table *opp_table)
1020	{
1021	struct device_node *np;
1022	int ret, count = 0;
1023	struct dev_pm_opp *opp;
1024
1025	/* OPP table is already initialized for the device */
1026	mutex_lock(&opp_table->lock);
1027	if (opp_table->parsed_static_opps) {
1028	opp_table->parsed_static_opps++;
1029	mutex_unlock(lock: &opp_table->lock);
1030	return 0;
1031	}
1032
1033	opp_table->parsed_static_opps = 1;
1034	mutex_unlock(lock: &opp_table->lock);
1035
1036	/* We have opp-table node now, iterate over it and add OPPs */
1037	for_each_available_child_of_node(opp_table->np, np) {
1038	opp = _opp_add_static_v2(opp_table, dev, np);
1039	if (IS_ERR(ptr: opp)) {
1040	ret = PTR_ERR(ptr: opp);
1041	dev_err(dev, "%s: Failed to add OPP, %d\n", __func__,
1042	ret);
1043	of_node_put(node: np);
1044	goto remove_static_opp;
1045	} else if (opp) {
1046	count++;
1047	}
1048	}
1049
1050	/* There should be one or more OPPs defined */
1051	if (!count) {
1052	dev_err(dev, "%s: no supported OPPs", __func__);
1053	ret = -ENOENT;
1054	goto remove_static_opp;
1055	}
1056
1057	lazy_link_required_opp_table(new_table: opp_table);
1058
1059	return 0;
1060
1061	remove_static_opp:
1062	_opp_remove_all_static(opp_table);
1063
1064	return ret;
1065	}
1066
1067	/* Initializes OPP tables based on old-deprecated bindings */
1068	static int _of_add_opp_table_v1(struct device *dev, struct opp_table *opp_table)
1069	{
1070	const struct property *prop;
1071	const __be32 *val;
1072	int nr, ret = 0;
1073
1074	mutex_lock(&opp_table->lock);
1075	if (opp_table->parsed_static_opps) {
1076	opp_table->parsed_static_opps++;
1077	mutex_unlock(lock: &opp_table->lock);
1078	return 0;
1079	}
1080
1081	opp_table->parsed_static_opps = 1;
1082	mutex_unlock(lock: &opp_table->lock);
1083
1084	prop = of_find_property(np: dev->of_node, name: "operating-points", NULL);
1085	if (!prop) {
1086	ret = -ENODEV;
1087	goto remove_static_opp;
1088	}
1089	if (!prop->value) {
1090	ret = -ENODATA;
1091	goto remove_static_opp;
1092	}
1093
1094	/*
1095	* Each OPP is a set of tuples consisting of frequency and
1096	* voltage like <freq-kHz vol-uV>.
1097	*/
1098	nr = prop->length / sizeof(u32);
1099	if (nr % 2) {
1100	dev_err(dev, "%s: Invalid OPP table\n", __func__);
1101	ret = -EINVAL;
1102	goto remove_static_opp;
1103	}
1104
1105	val = prop->value;
1106	while (nr) {
1107	unsigned long freq = be32_to_cpup(p: val++) * 1000;
1108	unsigned long volt = be32_to_cpup(p: val++);
1109	struct dev_pm_opp_data data = {
1110	.freq = freq,
1111	.u_volt = volt,
1112	};
1113
1114	ret = _opp_add_v1(opp_table, dev, data: &data, dynamic: false);
1115	if (ret) {
1116	dev_err(dev, "%s: Failed to add OPP %ld (%d)\n",
1117	__func__, data.freq, ret);
1118	goto remove_static_opp;
1119	}
1120	nr -= 2;
1121	}
1122
1123	return 0;
1124
1125	remove_static_opp:
1126	_opp_remove_all_static(opp_table);
1127
1128	return ret;
1129	}
1130
1131	static int _of_add_table_indexed(struct device *dev, int index)
1132	{
1133	struct opp_table *opp_table;
1134	int ret, count;
1135
1136	if (index) {
1137	/*
1138	* If only one phandle is present, then the same OPP table
1139	* applies for all index requests.
1140	*/
1141	count = of_count_phandle_with_args(np: dev->of_node,
1142	list_name: "operating-points-v2", NULL);
1143	if (count == 1)
1144	index = 0;
1145	}
1146
1147	opp_table = _add_opp_table_indexed(dev, index, getclk: true);
1148	if (IS_ERR(ptr: opp_table))
1149	return PTR_ERR(ptr: opp_table);
1150
1151	/*
1152	* OPPs have two version of bindings now. Also try the old (v1)
1153	* bindings for backward compatibility with older dtbs.
1154	*/
1155	if (opp_table->np)
1156	ret = _of_add_opp_table_v2(dev, opp_table);
1157	else
1158	ret = _of_add_opp_table_v1(dev, opp_table);
1159
1160	if (ret)
1161	dev_pm_opp_put_opp_table(opp_table);
1162
1163	return ret;
1164	}
1165
1166	static void devm_pm_opp_of_table_release(void *data)
1167	{
1168	dev_pm_opp_of_remove_table(data);
1169	}
1170
1171	static int _devm_of_add_table_indexed(struct device *dev, int index)
1172	{
1173	int ret;
1174
1175	ret = _of_add_table_indexed(dev, index);
1176	if (ret)
1177	return ret;
1178
1179	return devm_add_action_or_reset(dev, devm_pm_opp_of_table_release, dev);
1180	}
1181
1182	/**
1183	* devm_pm_opp_of_add_table() - Initialize opp table from device tree
1184	* @dev: device pointer used to lookup OPP table.
1185	*
1186	* Register the initial OPP table with the OPP library for given device.
1187	*
1188	* The opp_table structure will be freed after the device is destroyed.
1189	*
1190	* Return:
1191	* 0 On success OR
1192	* Duplicate OPPs (both freq and volt are same) and opp->available
1193	* -EEXIST Freq are same and volt are different OR
1194	* Duplicate OPPs (both freq and volt are same) and !opp->available
1195	* -ENOMEM Memory allocation failure
1196	* -ENODEV when 'operating-points' property is not found or is invalid data
1197	* in device node.
1198	* -ENODATA when empty 'operating-points' property is found
1199	* -EINVAL when invalid entries are found in opp-v2 table
1200	*/
1201	int devm_pm_opp_of_add_table(struct device *dev)
1202	{
1203	return _devm_of_add_table_indexed(dev, index: 0);
1204	}
1205	EXPORT_SYMBOL_GPL(devm_pm_opp_of_add_table);
1206
1207	/**
1208	* dev_pm_opp_of_add_table() - Initialize opp table from device tree
1209	* @dev: device pointer used to lookup OPP table.
1210	*
1211	* Register the initial OPP table with the OPP library for given device.
1212	*
1213	* Return:
1214	* 0 On success OR
1215	* Duplicate OPPs (both freq and volt are same) and opp->available
1216	* -EEXIST Freq are same and volt are different OR
1217	* Duplicate OPPs (both freq and volt are same) and !opp->available
1218	* -ENOMEM Memory allocation failure
1219	* -ENODEV when 'operating-points' property is not found or is invalid data
1220	* in device node.
1221	* -ENODATA when empty 'operating-points' property is found
1222	* -EINVAL when invalid entries are found in opp-v2 table
1223	*/
1224	int dev_pm_opp_of_add_table(struct device *dev)
1225	{
1226	return _of_add_table_indexed(dev, index: 0);
1227	}
1228	EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);
1229
1230	/**
1231	* dev_pm_opp_of_add_table_indexed() - Initialize indexed opp table from device tree
1232	* @dev: device pointer used to lookup OPP table.
1233	* @index: Index number.
1234	*
1235	* Register the initial OPP table with the OPP library for given device only
1236	* using the "operating-points-v2" property.
1237	*
1238	* Return: Refer to dev_pm_opp_of_add_table() for return values.
1239	*/
1240	int dev_pm_opp_of_add_table_indexed(struct device *dev, int index)
1241	{
1242	return _of_add_table_indexed(dev, index);
1243	}
1244	EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_indexed);
1245
1246	/**
1247	* devm_pm_opp_of_add_table_indexed() - Initialize indexed opp table from device tree
1248	* @dev: device pointer used to lookup OPP table.
1249	* @index: Index number.
1250	*
1251	* This is a resource-managed variant of dev_pm_opp_of_add_table_indexed().
1252	*/
1253	int devm_pm_opp_of_add_table_indexed(struct device *dev, int index)
1254	{
1255	return _devm_of_add_table_indexed(dev, index);
1256	}
1257	EXPORT_SYMBOL_GPL(devm_pm_opp_of_add_table_indexed);
1258
1259	/* CPU device specific helpers */
1260
1261	/**
1262	* dev_pm_opp_of_cpumask_remove_table() - Removes OPP table for @cpumask
1263	* @cpumask: cpumask for which OPP table needs to be removed
1264	*
1265	* This removes the OPP tables for CPUs present in the @cpumask.
1266	* This should be used only to remove static entries created from DT.
1267	*/
1268	void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask)
1269	{
1270	_dev_pm_opp_cpumask_remove_table(cpumask, last_cpu: -1);
1271	}
1272	EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_remove_table);
1273
1274	/**
1275	* dev_pm_opp_of_cpumask_add_table() - Adds OPP table for @cpumask
1276	* @cpumask: cpumask for which OPP table needs to be added.
1277	*
1278	* This adds the OPP tables for CPUs present in the @cpumask.
1279	*/
1280	int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask)
1281	{
1282	struct device *cpu_dev;
1283	int cpu, ret;
1284
1285	if (WARN_ON(cpumask_empty(cpumask)))
1286	return -ENODEV;
1287
1288	for_each_cpu(cpu, cpumask) {
1289	cpu_dev = get_cpu_device(cpu);
1290	if (!cpu_dev) {
1291	pr_err("%s: failed to get cpu%d device\n", __func__,
1292	cpu);
1293	ret = -ENODEV;
1294	goto remove_table;
1295	}
1296
1297	ret = dev_pm_opp_of_add_table(cpu_dev);
1298	if (ret) {
1299	/*
1300	* OPP may get registered dynamically, don't print error
1301	* message here.
1302	*/
1303	pr_debug("%s: couldn't find opp table for cpu:%d, %d\n",
1304	__func__, cpu, ret);
1305
1306	goto remove_table;
1307	}
1308	}
1309
1310	return 0;
1311
1312	remove_table:
1313	/* Free all other OPPs */
1314	_dev_pm_opp_cpumask_remove_table(cpumask, last_cpu: cpu);
1315
1316	return ret;
1317	}
1318	EXPORT_SYMBOL_GPL(dev_pm_opp_of_cpumask_add_table);
1319
1320	/*
1321	* Works only for OPP v2 bindings.
1322	*
1323	* Returns -ENOENT if operating-points-v2 bindings aren't supported.
1324	*/
1325	/**
1326	* dev_pm_opp_of_get_sharing_cpus() - Get cpumask of CPUs sharing OPPs with
1327	* @cpu_dev using operating-points-v2
1328	* bindings.
1329	*
1330	* @cpu_dev: CPU device for which we do this operation
1331	* @cpumask: cpumask to update with information of sharing CPUs
1332	*
1333	* This updates the @cpumask with CPUs that are sharing OPPs with @cpu_dev.
1334	*
1335	* Returns -ENOENT if operating-points-v2 isn't present for @cpu_dev.
1336	*/
1337	int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev,
1338	struct cpumask *cpumask)
1339	{
1340	struct device_node *np, *tmp_np, *cpu_np;
1341	int cpu, ret = 0;
1342
1343	/* Get OPP descriptor node */
1344	np = dev_pm_opp_of_get_opp_desc_node(cpu_dev);
1345	if (!np) {
1346	dev_dbg(cpu_dev, "%s: Couldn't find opp node.\n", __func__);
1347	return -ENOENT;
1348	}
1349
1350	cpumask_set_cpu(cpu: cpu_dev->id, dstp: cpumask);
1351
1352	/* OPPs are shared ? */
1353	if (!of_property_read_bool(np, propname: "opp-shared"))
1354	goto put_cpu_node;
1355
1356	for_each_possible_cpu(cpu) {
1357	if (cpu == cpu_dev->id)
1358	continue;
1359
1360	cpu_np = of_cpu_device_node_get(cpu);
1361	if (!cpu_np) {
1362	dev_err(cpu_dev, "%s: failed to get cpu%d node\n",
1363	__func__, cpu);
1364	ret = -ENOENT;
1365	goto put_cpu_node;
1366	}
1367
1368	/* Get OPP descriptor node */
1369	tmp_np = _opp_of_get_opp_desc_node(np: cpu_np, index: 0);
1370	of_node_put(node: cpu_np);
1371	if (!tmp_np) {
1372	pr_err("%pOF: Couldn't find opp node\n", cpu_np);
1373	ret = -ENOENT;
1374	goto put_cpu_node;
1375	}
1376
1377	/* CPUs are sharing opp node */
1378	if (np == tmp_np)
1379	cpumask_set_cpu(cpu, dstp: cpumask);
1380
1381	of_node_put(node: tmp_np);
1382	}
1383
1384	put_cpu_node:
1385	of_node_put(node: np);
1386	return ret;
1387	}
1388	EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus);
1389
1390	/**
1391	* of_get_required_opp_performance_state() - Search for required OPP and return its performance state.
1392	* @np: Node that contains the "required-opps" property.
1393	* @index: Index of the phandle to parse.
1394	*
1395	* Returns the performance state of the OPP pointed out by the "required-opps"
1396	* property at @index in @np.
1397	*
1398	* Return: Zero or positive performance state on success, otherwise negative
1399	* value on errors.
1400	*/
1401	int of_get_required_opp_performance_state(struct device_node *np, int index)
1402	{
1403	struct dev_pm_opp *opp;
1404	struct device_node *required_np;
1405	struct opp_table *opp_table;
1406	int pstate = -EINVAL;
1407
1408	required_np = of_parse_required_opp(np, index);
1409	if (!required_np)
1410	return -ENODEV;
1411
1412	opp_table = _find_table_of_opp_np(opp_np: required_np);
1413	if (IS_ERR(ptr: opp_table)) {
1414	pr_err("%s: Failed to find required OPP table %pOF: %ld\n",
1415	__func__, np, PTR_ERR(opp_table));
1416	goto put_required_np;
1417	}
1418
1419	/* The OPP tables must belong to a genpd */
1420	if (unlikely(!opp_table->is_genpd)) {
1421	pr_err("%s: Performance state is only valid for genpds.\n", __func__);
1422	goto put_required_np;
1423	}
1424
1425	opp = _find_opp_of_np(opp_table, opp_np: required_np);
1426	if (opp) {
1427	if (opp->level == OPP_LEVEL_UNSET) {
1428	pr_err("%s: OPP levels aren't available for %pOF\n",
1429	__func__, np);
1430	} else {
1431	pstate = opp->level;
1432	}
1433	dev_pm_opp_put(opp);
1434
1435	}
1436
1437	dev_pm_opp_put_opp_table(opp_table);
1438
1439	put_required_np:
1440	of_node_put(node: required_np);
1441
1442	return pstate;
1443	}
1444	EXPORT_SYMBOL_GPL(of_get_required_opp_performance_state);
1445
1446	/**
1447	* dev_pm_opp_get_of_node() - Gets the DT node corresponding to an opp
1448	* @opp: opp for which DT node has to be returned for
1449	*
1450	* Return: DT node corresponding to the opp, else 0 on success.
1451	*
1452	* The caller needs to put the node with of_node_put() after using it.
1453	*/
1454	struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
1455	{
1456	if (IS_ERR_OR_NULL(ptr: opp)) {
1457	pr_err("%s: Invalid parameters\n", __func__);
1458	return NULL;
1459	}
1460
1461	return of_node_get(node: opp->np);
1462	}
1463	EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node);
1464
1465	/*
1466	* Callback function provided to the Energy Model framework upon registration.
1467	* It provides the power used by @dev at @kHz if it is the frequency of an
1468	* existing OPP, or at the frequency of the first OPP above @kHz otherwise
1469	* (see dev_pm_opp_find_freq_ceil()). This function updates @kHz to the ceiled
1470	* frequency and @uW to the associated power.
1471	*
1472	* Returns 0 on success or a proper -EINVAL value in case of error.
1473	*/
1474	static int __maybe_unused
1475	_get_dt_power(struct device *dev, unsigned long *uW, unsigned long *kHz)
1476	{
1477	struct dev_pm_opp *opp;
1478	unsigned long opp_freq, opp_power;
1479
1480	/* Find the right frequency and related OPP */
1481	opp_freq = *kHz * 1000;
1482	opp = dev_pm_opp_find_freq_ceil(dev, freq: &opp_freq);
1483	if (IS_ERR(ptr: opp))
1484	return -EINVAL;
1485
1486	opp_power = dev_pm_opp_get_power(opp);
1487	dev_pm_opp_put(opp);
1488	if (!opp_power)
1489	return -EINVAL;
1490
1491	*kHz = opp_freq / 1000;
1492	*uW = opp_power;
1493
1494	return 0;
1495	}
1496
1497	/*
1498	* Callback function provided to the Energy Model framework upon registration.
1499	* This computes the power estimated by @dev at @kHz if it is the frequency
1500	* of an existing OPP, or at the frequency of the first OPP above @kHz otherwise
1501	* (see dev_pm_opp_find_freq_ceil()). This function updates @kHz to the ceiled
1502	* frequency and @uW to the associated power. The power is estimated as
1503	* P = C * V^2 * f with C being the device's capacitance and V and f
1504	* respectively the voltage and frequency of the OPP.
1505	*
1506	* Returns -EINVAL if the power calculation failed because of missing
1507	* parameters, 0 otherwise.
1508	*/
1509	static int __maybe_unused _get_power(struct device *dev, unsigned long *uW,
1510	unsigned long *kHz)
1511	{
1512	struct dev_pm_opp *opp;
1513	struct device_node *np;
1514	unsigned long mV, Hz;
1515	u32 cap;
1516	u64 tmp;
1517	int ret;
1518
1519	np = of_node_get(node: dev->of_node);
1520	if (!np)
1521	return -EINVAL;
1522
1523	ret = of_property_read_u32(np, propname: "dynamic-power-coefficient", out_value: &cap);
1524	of_node_put(node: np);
1525	if (ret)
1526	return -EINVAL;
1527
1528	Hz = *kHz * 1000;
1529	opp = dev_pm_opp_find_freq_ceil(dev, freq: &Hz);
1530	if (IS_ERR(ptr: opp))
1531	return -EINVAL;
1532
1533	mV = dev_pm_opp_get_voltage(opp) / 1000;
1534	dev_pm_opp_put(opp);
1535	if (!mV)
1536	return -EINVAL;
1537
1538	tmp = (u64)cap * mV * mV * (Hz / 1000000);
1539	/* Provide power in micro-Watts */
1540	do_div(tmp, 1000000);
1541
1542	*uW = (unsigned long)tmp;
1543	*kHz = Hz / 1000;
1544
1545	return 0;
1546	}
1547
1548	static bool _of_has_opp_microwatt_property(struct device *dev)
1549	{
1550	unsigned long power, freq = 0;
1551	struct dev_pm_opp *opp;
1552
1553	/* Check if at least one OPP has needed property */
1554	opp = dev_pm_opp_find_freq_ceil(dev, freq: &freq);
1555	if (IS_ERR(ptr: opp))
1556	return false;
1557
1558	power = dev_pm_opp_get_power(opp);
1559	dev_pm_opp_put(opp);
1560	if (!power)
1561	return false;
1562
1563	return true;
1564	}
1565
1566	/**
1567	* dev_pm_opp_of_register_em() - Attempt to register an Energy Model
1568	* @dev : Device for which an Energy Model has to be registered
1569	* @cpus : CPUs for which an Energy Model has to be registered. For
1570	* other type of devices it should be set to NULL.
1571	*
1572	* This checks whether the "dynamic-power-coefficient" devicetree property has
1573	* been specified, and tries to register an Energy Model with it if it has.
1574	* Having this property means the voltages are known for OPPs and the EM
1575	* might be calculated.
1576	*/
1577	int dev_pm_opp_of_register_em(struct device *dev, struct cpumask *cpus)
1578	{
1579	struct em_data_callback em_cb;
1580	struct device_node *np;
1581	int ret, nr_opp;
1582	u32 cap;
1583
1584	if (IS_ERR_OR_NULL(ptr: dev)) {
1585	ret = -EINVAL;
1586	goto failed;
1587	}
1588
1589	nr_opp = dev_pm_opp_get_opp_count(dev);
1590	if (nr_opp <= 0) {
1591	ret = -EINVAL;
1592	goto failed;
1593	}
1594
1595	/* First, try to find more precised Energy Model in DT */
1596	if (_of_has_opp_microwatt_property(dev)) {
1597	EM_SET_ACTIVE_POWER_CB(em_cb, _get_dt_power);
1598	goto register_em;
1599	}
1600
1601	np = of_node_get(node: dev->of_node);
1602	if (!np) {
1603	ret = -EINVAL;
1604	goto failed;
1605	}
1606
1607	/*
1608	* Register an EM only if the 'dynamic-power-coefficient' property is
1609	* set in devicetree. It is assumed the voltage values are known if that
1610	* property is set since it is useless otherwise. If voltages are not
1611	* known, just let the EM registration fail with an error to alert the
1612	* user about the inconsistent configuration.
1613	*/
1614	ret = of_property_read_u32(np, propname: "dynamic-power-coefficient", out_value: &cap);
1615	of_node_put(node: np);
1616	if (ret || !cap) {
1617	dev_dbg(dev, "Couldn't find proper 'dynamic-power-coefficient' in DT\n");
1618	ret = -EINVAL;
1619	goto failed;
1620	}
1621
1622	EM_SET_ACTIVE_POWER_CB(em_cb, _get_power);
1623
1624	register_em:
1625	ret = em_dev_register_perf_domain(dev, nr_states: nr_opp, cb: &em_cb, span: cpus, microwatts: true);
1626	if (ret)
1627	goto failed;
1628
1629	return 0;
1630
1631	failed:
1632	dev_dbg(dev, "Couldn't register Energy Model %d\n", ret);
1633	return ret;
1634	}
1635	EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em);
1636