Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
f47b72a1 VK |
2 | /* |
3 | * Generic OPP OF helpers | |
4 | * | |
5 | * Copyright (C) 2009-2010 Texas Instruments Incorporated. | |
6 | * Nishanth Menon | |
7 | * Romit Dasgupta | |
8 | * Kevin Hilman | |
f47b72a1 VK |
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> | |
cd6f0f51 | 16 | #include <linux/of.h> |
3ba98324 | 17 | #include <linux/pm_domain.h> |
dfbe4678 | 18 | #include <linux/slab.h> |
f47b72a1 | 19 | #include <linux/export.h> |
a4f342b9 | 20 | #include <linux/energy_model.h> |
f47b72a1 VK |
21 | |
22 | #include "opp.h" | |
23 | ||
64aaeb70 | 24 | /* OPP tables with uninitialized required OPPs, protected by opp_table_lock */ |
167eb2bd VK |
25 | static LIST_HEAD(lazy_opp_tables); |
26 | ||
f06ed90e VK |
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, "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(dev->of_node, 0); | |
42 | } | |
43 | EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_opp_desc_node); | |
44 | ||
283d55e6 | 45 | struct opp_table *_managed_opp(struct device *dev, int index) |
f47b72a1 | 46 | { |
b83c1899 | 47 | struct opp_table *opp_table, *managed_table = NULL; |
283d55e6 | 48 | struct device_node *np; |
b83c1899 | 49 | |
283d55e6 VK |
50 | np = _opp_of_get_opp_desc_node(dev->of_node, index); |
51 | if (!np) | |
52 | return NULL; | |
f47b72a1 | 53 | |
052c6f19 | 54 | list_for_each_entry(opp_table, &opp_tables, node) { |
f47b72a1 VK |
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 | */ | |
b83c1899 VK |
63 | if (opp_table->shared_opp == OPP_TABLE_ACCESS_SHARED) { |
64 | _get_opp_table_kref(opp_table); | |
65 | managed_table = opp_table; | |
66 | } | |
79ee2e8f | 67 | |
b83c1899 | 68 | break; |
f47b72a1 VK |
69 | } |
70 | } | |
71 | ||
283d55e6 | 72 | of_node_put(np); |
b83c1899 VK |
73 | |
74 | return managed_table; | |
f47b72a1 VK |
75 | } |
76 | ||
5d6d106f VK |
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 | ||
5d6d106f VK |
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(&opp_table->lock); | |
89 | return opp; | |
90 | } | |
91 | } | |
92 | ||
93 | mutex_unlock(&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 | { | |
020d86fc | 101 | return of_parse_phandle(np, "required-opps", index); |
5d6d106f VK |
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; | |
699e21e4 | 108 | struct device_node *opp_table_np; |
5d6d106f | 109 | |
699e21e4 VK |
110 | opp_table_np = of_get_parent(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(opp_table_np); | |
116 | ||
27c09484 | 117 | mutex_lock(&opp_table_lock); |
5d6d106f | 118 | list_for_each_entry(opp_table, &opp_tables, node) { |
699e21e4 | 119 | if (opp_table_np == opp_table->np) { |
5d6d106f | 120 | _get_opp_table_kref(opp_table); |
27c09484 | 121 | mutex_unlock(&opp_table_lock); |
5d6d106f VK |
122 | return opp_table; |
123 | } | |
124 | } | |
27c09484 | 125 | mutex_unlock(&opp_table_lock); |
5d6d106f | 126 | |
699e21e4 | 127 | err: |
5d6d106f VK |
128 | return ERR_PTR(-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(required_opp_tables[i])) | |
7eba0c76 | 142 | continue; |
5d6d106f VK |
143 | |
144 | dev_pm_opp_put_opp_table(required_opp_tables[i]); | |
145 | } | |
146 | ||
147 | kfree(required_opp_tables); | |
148 | ||
149 | opp_table->required_opp_count = 0; | |
150 | opp_table->required_opp_tables = NULL; | |
64aaeb70 VK |
151 | |
152 | mutex_lock(&opp_table_lock); | |
7eba0c76 | 153 | list_del(&opp_table->lazy); |
64aaeb70 | 154 | mutex_unlock(&opp_table_lock); |
5d6d106f VK |
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; | |
7eba0c76 | 167 | bool lazy = false; |
e37440e7 | 168 | int count, i, size; |
5d6d106f VK |
169 | |
170 | /* Traversing the first OPP node is all we need */ | |
171 | np = of_get_next_available_child(opp_np, NULL); | |
172 | if (!np) { | |
6ee70e8c NM |
173 | dev_warn(dev, "Empty OPP table\n"); |
174 | ||
5d6d106f VK |
175 | return; |
176 | } | |
177 | ||
178 | count = of_count_phandle_with_args(np, "required-opps", NULL); | |
8b7912f4 | 179 | if (count <= 0) |
5d6d106f VK |
180 | goto put_np; |
181 | ||
e37440e7 VK |
182 | size = sizeof(*required_opp_tables) + sizeof(*opp_table->required_devs); |
183 | required_opp_tables = kcalloc(count, size, GFP_KERNEL); | |
c0ab9e08 | 184 | if (!required_opp_tables) |
5d6d106f VK |
185 | goto put_np; |
186 | ||
187 | opp_table->required_opp_tables = required_opp_tables; | |
e37440e7 | 188 | opp_table->required_devs = (void *)(required_opp_tables + count); |
5d6d106f VK |
189 | opp_table->required_opp_count = count; |
190 | ||
191 | for (i = 0; i < count; i++) { | |
192 | required_np = of_parse_required_opp(np, i); | |
193 | if (!required_np) | |
194 | goto free_required_tables; | |
195 | ||
196 | required_opp_tables[i] = _find_table_of_opp_np(required_np); | |
197 | of_node_put(required_np); | |
198 | ||
4fa82a87 | 199 | if (IS_ERR(required_opp_tables[i])) |
7eba0c76 | 200 | lazy = true; |
5d6d106f VK |
201 | } |
202 | ||
7eba0c76 | 203 | /* Let's do the linking later on */ |
64aaeb70 VK |
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); | |
7eba0c76 | 210 | list_add(&opp_table->lazy, &lazy_opp_tables); |
64aaeb70 | 211 | mutex_unlock(&opp_table_lock); |
8e6db129 | 212 | } |
7eba0c76 | 213 | |
5d6d106f VK |
214 | goto put_np; |
215 | ||
216 | free_required_tables: | |
217 | _opp_table_free_required_tables(opp_table); | |
218 | put_np: | |
219 | of_node_put(np); | |
220 | } | |
221 | ||
eb7c8743 VK |
222 | void _of_init_opp_table(struct opp_table *opp_table, struct device *dev, |
223 | int index) | |
f47b72a1 | 224 | { |
f06ed90e VK |
225 | struct device_node *np, *opp_np; |
226 | u32 val; | |
f47b72a1 VK |
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(dev->of_node); | |
f06ed90e VK |
233 | if (!np) |
234 | return; | |
235 | ||
236 | if (!of_property_read_u32(np, "clock-latency", &val)) | |
237 | opp_table->clock_latency_ns_max = val; | |
238 | of_property_read_u32(np, "voltage-tolerance", | |
239 | &opp_table->voltage_tolerance_v1); | |
240 | ||
e9eadc28 | 241 | if (of_property_present(np, "#power-domain-cells")) |
61d8e7c7 VK |
242 | opp_table->is_genpd = true; |
243 | ||
f06ed90e VK |
244 | /* Get OPP table node */ |
245 | opp_np = _opp_of_get_opp_desc_node(np, index); | |
246 | of_node_put(np); | |
247 | ||
248 | if (!opp_np) | |
249 | return; | |
250 | ||
251 | if (of_property_read_bool(opp_np, "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 | ||
5d6d106f | 258 | _opp_table_alloc_required_tables(opp_table, dev, opp_np); |
f47b72a1 VK |
259 | } |
260 | ||
5d6d106f VK |
261 | void _of_clear_opp_table(struct opp_table *opp_table) |
262 | { | |
263 | _opp_table_free_required_tables(opp_table); | |
ce736cf7 | 264 | of_node_put(opp_table->np); |
5d6d106f VK |
265 | } |
266 | ||
da544b61 VK |
267 | /* |
268 | * Release all resources previously acquired with a call to | |
269 | * _of_opp_alloc_required_opps(). | |
270 | */ | |
3466ea2c LH |
271 | static void _of_opp_free_required_opps(struct opp_table *opp_table, |
272 | struct dev_pm_opp *opp) | |
da544b61 VK |
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]) | |
7eba0c76 | 282 | continue; |
da544b61 VK |
283 | |
284 | /* Put the reference back */ | |
285 | dev_pm_opp_put(required_opps[i]); | |
286 | } | |
287 | ||
da544b61 | 288 | opp->required_opps = NULL; |
7eba0c76 | 289 | kfree(required_opps); |
da544b61 VK |
290 | } |
291 | ||
3466ea2c LH |
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(opp->np); | |
296 | } | |
297 | ||
6d366d0e | 298 | static int _link_required_opps(struct dev_pm_opp *opp, struct opp_table *opp_table, |
96104046 VK |
299 | struct opp_table *required_table, int index) |
300 | { | |
301 | struct device_node *np; | |
302 | ||
303 | np = of_parse_required_opp(opp->np, index); | |
304 | if (unlikely(!np)) | |
305 | return -ENODEV; | |
306 | ||
307 | opp->required_opps[index] = _find_opp_of_np(required_table, np); | |
308 | of_node_put(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 | ||
6d366d0e VK |
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. | |
e37440e7 VK |
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(). | |
6d366d0e VK |
339 | */ |
340 | if (required_table->is_genpd && opp_table->required_opp_count == 1 && | |
e37440e7 | 341 | !opp_table->required_devs[0]) { |
92514143 VK |
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 | } | |
6d366d0e VK |
347 | } |
348 | ||
96104046 VK |
349 | return 0; |
350 | } | |
351 | ||
da544b61 VK |
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 | { | |
da544b61 | 356 | struct opp_table *required_table; |
da544b61 VK |
357 | int i, ret, count = opp_table->required_opp_count; |
358 | ||
359 | if (!count) | |
360 | return 0; | |
361 | ||
96104046 VK |
362 | opp->required_opps = kcalloc(count, sizeof(*opp->required_opps), GFP_KERNEL); |
363 | if (!opp->required_opps) | |
da544b61 VK |
364 | return -ENOMEM; |
365 | ||
da544b61 VK |
366 | for (i = 0; i < count; i++) { |
367 | required_table = opp_table->required_opp_tables[i]; | |
368 | ||
7eba0c76 VK |
369 | /* Required table not added yet, we will link later */ |
370 | if (IS_ERR_OR_NULL(required_table)) | |
371 | continue; | |
372 | ||
6d366d0e | 373 | ret = _link_required_opps(opp, opp_table, required_table, i); |
96104046 | 374 | if (ret) |
da544b61 | 375 | goto free_required_opps; |
da544b61 VK |
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 | ||
7eba0c76 VK |
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 | { | |
7eba0c76 | 390 | struct dev_pm_opp *opp; |
96104046 | 391 | int ret; |
7eba0c76 VK |
392 | |
393 | list_for_each_entry(opp, &opp_table->opp_list, node) { | |
6d366d0e | 394 | ret = _link_required_opps(opp, opp_table, new_table, index); |
96104046 VK |
395 | if (ret) |
396 | return ret; | |
7eba0c76 VK |
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 | ||
7eba0c76 VK |
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(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(required_opp_tables[i])) | |
423 | continue; | |
424 | ||
425 | /* required_np can't be invalid here */ | |
426 | required_np = of_parse_required_opp(opp_np, i); | |
427 | required_table_np = of_get_parent(required_np); | |
428 | ||
429 | of_node_put(required_table_np); | |
430 | of_node_put(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(new_table); | |
443 | ||
444 | /* Link OPPs now */ | |
445 | ret = lazy_link_required_opps(opp_table, new_table, i); | |
446 | if (ret) { | |
447 | /* The OPPs will be marked unusable */ | |
448 | lazy = false; | |
449 | break; | |
450 | } | |
451 | } | |
452 | ||
453 | of_node_put(opp_np); | |
454 | ||
455 | /* All required opp-tables found, remove from lazy list */ | |
456 | if (!lazy) { | |
ac9fd3c8 | 457 | list_del_init(&opp_table->lazy); |
7eba0c76 VK |
458 | |
459 | list_for_each_entry(opp, &opp_table->opp_list, node) | |
460 | _required_opps_available(opp, opp_table->required_opp_count); | |
461 | } | |
462 | } | |
463 | ||
464 | mutex_unlock(&opp_table_lock); | |
465 | } | |
466 | ||
45679f9b SS |
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(dev->of_node); | |
474 | if (!np) | |
475 | return -ENODEV; | |
476 | ||
477 | opp_np = _opp_of_get_opp_desc_node(np, 0); | |
478 | of_node_put(np); | |
479 | } else { | |
480 | opp_np = of_node_get(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(opp_np, NULL); | |
907ed123 | 489 | of_node_put(opp_np); |
45679f9b SS |
490 | if (!np) { |
491 | dev_err(dev, "OPP table empty\n"); | |
492 | return -EINVAL; | |
493 | } | |
45679f9b SS |
494 | |
495 | prop = of_find_property(np, "opp-peak-kBps", NULL); | |
496 | of_node_put(np); | |
497 | ||
498 | if (!prop || !prop->length) | |
499 | return 0; | |
500 | ||
501 | return 1; | |
502 | } | |
503 | ||
6d3f922c GD |
504 | int dev_pm_opp_of_find_icc_paths(struct device *dev, |
505 | struct opp_table *opp_table) | |
506 | { | |
507 | struct device_node *np; | |
45679f9b | 508 | int ret, i, count, num_paths; |
6d3f922c GD |
509 | struct icc_path **paths; |
510 | ||
45679f9b | 511 | ret = _bandwidth_supported(dev, opp_table); |
6ee70e8c NM |
512 | if (ret == -EINVAL) |
513 | return 0; /* Empty OPP table is a valid corner-case, let's not fail */ | |
514 | else if (ret <= 0) | |
45679f9b SS |
515 | return ret; |
516 | ||
517 | ret = 0; | |
518 | ||
6d3f922c GD |
519 | np = of_node_get(dev->of_node); |
520 | if (!np) | |
521 | return 0; | |
522 | ||
523 | count = of_count_phandle_with_args(np, "interconnects", | |
524 | "#interconnect-cells"); | |
525 | of_node_put(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(num_paths, 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, i); | |
542 | if (IS_ERR(paths[i])) { | |
5fb2864c | 543 | ret = dev_err_probe(dev, PTR_ERR(paths[i]), "%s: Unable to get path%d\n", __func__, i); |
6d3f922c GD |
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(paths[i]); | |
557 | ||
558 | kfree(paths); | |
559 | ||
560 | return ret; | |
561 | } | |
562 | EXPORT_SYMBOL_GPL(dev_pm_opp_of_find_icc_paths); | |
563 | ||
f47b72a1 VK |
564 | static bool _opp_is_supported(struct device *dev, struct opp_table *opp_table, |
565 | struct device_node *np) | |
566 | { | |
0ff25c99 VK |
567 | unsigned int levels = opp_table->supported_hw_count; |
568 | int count, versions, ret, i, j; | |
569 | u32 val; | |
f47b72a1 | 570 | |
a4ee4545 DG |
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 | */ | |
e9eadc28 | 578 | if (of_property_present(np, "opp-supported-hw")) |
a4ee4545 DG |
579 | return false; |
580 | else | |
581 | return true; | |
582 | } | |
f47b72a1 | 583 | |
0ff25c99 VK |
584 | count = of_property_count_u32_elems(np, "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, "opp-supported-hw", | |
599 | i * levels + j, &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 | } | |
f47b72a1 VK |
611 | } |
612 | ||
0ff25c99 VK |
613 | if (supported) |
614 | return true; | |
f47b72a1 VK |
615 | } |
616 | ||
0ff25c99 | 617 | return false; |
f47b72a1 VK |
618 | } |
619 | ||
e5acb199 VK |
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) | |
f47b72a1 | 623 | { |
f47b72a1 VK |
624 | struct property *prop = NULL; |
625 | char name[NAME_MAX]; | |
e5acb199 VK |
626 | int count, ret; |
627 | u32 *out; | |
f47b72a1 | 628 | |
e5acb199 | 629 | /* Search for "opp-<prop_type>-<name>" */ |
f47b72a1 | 630 | if (opp_table->prop_name) { |
e5acb199 | 631 | snprintf(name, sizeof(name), "opp-%s-%s", prop_type, |
f47b72a1 VK |
632 | opp_table->prop_name); |
633 | prop = of_find_property(opp->np, name, NULL); | |
634 | } | |
635 | ||
636 | if (!prop) { | |
e5acb199 VK |
637 | /* Search for "opp-<prop_type>" */ |
638 | snprintf(name, sizeof(name), "opp-%s", prop_type); | |
f47b72a1 | 639 | prop = of_find_property(opp->np, name, NULL); |
e5acb199 VK |
640 | if (!prop) |
641 | return NULL; | |
f47b72a1 VK |
642 | } |
643 | ||
e5acb199 VK |
644 | count = of_property_count_u32_elems(opp->np, name); |
645 | if (count < 0) { | |
646 | dev_err(dev, "%s: Invalid %s property (%d)\n", __func__, name, | |
647 | count); | |
648 | return ERR_PTR(count); | |
46f48aca VK |
649 | } |
650 | ||
e5acb199 VK |
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(-EINVAL); | |
f47b72a1 VK |
664 | } |
665 | ||
e5acb199 VK |
666 | out = kmalloc_array(count, sizeof(*out), GFP_KERNEL); |
667 | if (!out) | |
668 | return ERR_PTR(-EINVAL); | |
f47b72a1 | 669 | |
e5acb199 | 670 | ret = of_property_read_u32_array(opp->np, name, out, count); |
f47b72a1 VK |
671 | if (ret) { |
672 | dev_err(dev, "%s: error parsing %s: %d\n", __func__, name, ret); | |
e5acb199 VK |
673 | kfree(out); |
674 | return ERR_PTR(-EINVAL); | |
f47b72a1 VK |
675 | } |
676 | ||
e5acb199 VK |
677 | if (triplet) |
678 | *triplet = count != opp_table->regulator_count; | |
f47b72a1 | 679 | |
e5acb199 VK |
680 | return out; |
681 | } | |
f47b72a1 | 682 | |
e5acb199 VK |
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; | |
dfbe4678 | 687 | |
e5acb199 VK |
688 | microvolt = _parse_named_prop(opp, dev, opp_table, "microvolt", triplet); |
689 | if (IS_ERR(microvolt)) | |
690 | return microvolt; | |
dfbe4678 | 691 | |
e5acb199 VK |
692 | if (!microvolt) { |
693 | /* | |
694 | * Missing property isn't a problem, but an invalid | |
695 | * entry is. This property isn't optional if regulator | |
2eedf62e JC |
696 | * information is provided. Check only for the first OPP, as |
697 | * regulator_count may get initialized after that to a valid | |
698 | * value. | |
e5acb199 | 699 | */ |
2eedf62e JC |
700 | if (list_empty(&opp_table->opp_list) && |
701 | opp_table->regulator_count > 0) { | |
e5acb199 VK |
702 | dev_err(dev, "%s: opp-microvolt missing although OPP managing regulators\n", |
703 | __func__); | |
704 | return ERR_PTR(-EINVAL); | |
dfbe4678 VK |
705 | } |
706 | } | |
707 | ||
e5acb199 VK |
708 | return microvolt; |
709 | } | |
4f9a7a1d | 710 | |
e5acb199 VK |
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; | |
4f9a7a1d | 717 | |
e5acb199 | 718 | microvolt = opp_parse_microvolt(opp, dev, opp_table, &triplet); |
2eedf62e | 719 | if (IS_ERR(microvolt)) |
e5acb199 | 720 | return PTR_ERR(microvolt); |
4f9a7a1d | 721 | |
e5acb199 VK |
722 | microamp = _parse_named_prop(opp, dev, opp_table, "microamp", NULL); |
723 | if (IS_ERR(microamp)) { | |
724 | ret = PTR_ERR(microamp); | |
725 | goto free_microvolt; | |
726 | } | |
4f9a7a1d | 727 | |
e5acb199 VK |
728 | microwatt = _parse_named_prop(opp, dev, opp_table, "microwatt", NULL); |
729 | if (IS_ERR(microwatt)) { | |
730 | ret = PTR_ERR(microwatt); | |
731 | goto free_microamp; | |
4f9a7a1d LL |
732 | } |
733 | ||
2eedf62e JC |
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 | ||
e5acb199 | 743 | for (i = 0, j = 0; i < opp_table->regulator_count; i++) { |
2eedf62e JC |
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 | } | |
dfbe4678 VK |
754 | } |
755 | ||
756 | if (microamp) | |
757 | opp->supplies[i].u_amp = microamp[i]; | |
4f9a7a1d LL |
758 | |
759 | if (microwatt) | |
760 | opp->supplies[i].u_watt = microwatt[i]; | |
dfbe4678 VK |
761 | } |
762 | ||
4f9a7a1d | 763 | kfree(microwatt); |
dfbe4678 VK |
764 | free_microamp: |
765 | kfree(microamp); | |
766 | free_microvolt: | |
767 | kfree(microvolt); | |
768 | ||
769 | return ret; | |
f47b72a1 VK |
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. | |
f47b72a1 VK |
778 | */ |
779 | void dev_pm_opp_of_remove_table(struct device *dev) | |
780 | { | |
8aaf6264 | 781 | dev_pm_opp_remove_table(dev); |
f47b72a1 VK |
782 | } |
783 | EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table); | |
784 | ||
2083da24 VK |
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, "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(count, sizeof(*rates), GFP_KERNEL); | |
804 | if (!rates) | |
805 | return -ENOMEM; | |
806 | ||
807 | ret = of_property_read_u64_array(np, "opp-hz", rates, 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(rates); | |
825 | ||
826 | return ret; | |
827 | } | |
828 | ||
d6134583 | 829 | static int _read_bw(struct dev_pm_opp *new_opp, struct opp_table *opp_table, |
120e117b | 830 | struct device_node *np, bool peak) |
6d3f922c GD |
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); | |
d6134583 | 842 | if (opp_table->path_count != count) { |
120e117b | 843 | pr_err("%s: Mismatch between %s and paths (%d %d)\n", |
d6134583 | 844 | __func__, name, count, opp_table->path_count); |
120e117b GD |
845 | return -EINVAL; |
846 | } | |
847 | ||
6d3f922c GD |
848 | bw = kmalloc_array(count, sizeof(*bw), GFP_KERNEL); |
849 | if (!bw) | |
850 | return -ENOMEM; | |
851 | ||
852 | ret = of_property_read_u32_array(np, name, bw, 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(bw); | |
867 | return ret; | |
868 | } | |
869 | ||
4768914b VK |
870 | static int _read_opp_key(struct dev_pm_opp *new_opp, |
871 | struct opp_table *opp_table, struct device_node *np) | |
6c591eec | 872 | { |
6d3f922c | 873 | bool found = false; |
6c591eec SK |
874 | int ret; |
875 | ||
2083da24 VK |
876 | ret = _read_rate(new_opp, opp_table, np); |
877 | if (!ret) | |
6d3f922c | 878 | found = true; |
2083da24 VK |
879 | else if (ret != -ENODEV) |
880 | return ret; | |
6c591eec | 881 | |
6d3f922c GD |
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 | */ | |
d6134583 | 887 | ret = _read_bw(new_opp, opp_table, np, true); |
6d3f922c GD |
888 | if (!ret) { |
889 | found = true; | |
d6134583 | 890 | ret = _read_bw(new_opp, opp_table, np, false); |
6d3f922c GD |
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, "opp-level", &new_opp->level)) | |
898 | found = true; | |
899 | ||
900 | if (found) | |
901 | return 0; | |
6c591eec SK |
902 | |
903 | return ret; | |
904 | } | |
905 | ||
f47b72a1 VK |
906 | /** |
907 | * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings) | |
8cd2f6e8 | 908 | * @opp_table: OPP table |
f47b72a1 VK |
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 | * | |
f47b72a1 | 916 | * Return: |
deac8703 DG |
917 | * Valid OPP pointer: |
918 | * On success | |
919 | * NULL: | |
f47b72a1 | 920 | * Duplicate OPPs (both freq and volt are same) and opp->available |
deac8703 DG |
921 | * OR if the OPP is not supported by hardware. |
922 | * ERR_PTR(-EEXIST): | |
923 | * Freq are same and volt are different OR | |
f47b72a1 | 924 | * Duplicate OPPs (both freq and volt are same) and !opp->available |
deac8703 DG |
925 | * ERR_PTR(-ENOMEM): |
926 | * Memory allocation failure | |
927 | * ERR_PTR(-EINVAL): | |
928 | * Failed parsing the OPP node | |
f47b72a1 | 929 | */ |
deac8703 DG |
930 | static struct dev_pm_opp *_opp_add_static_v2(struct opp_table *opp_table, |
931 | struct device *dev, struct device_node *np) | |
f47b72a1 | 932 | { |
f47b72a1 | 933 | struct dev_pm_opp *new_opp; |
f47b72a1 VK |
934 | u32 val; |
935 | int ret; | |
936 | ||
8cd2f6e8 VK |
937 | new_opp = _opp_allocate(opp_table); |
938 | if (!new_opp) | |
deac8703 | 939 | return ERR_PTR(-ENOMEM); |
f47b72a1 | 940 | |
4768914b | 941 | ret = _read_opp_key(new_opp, opp_table, np); |
4fa82a87 | 942 | if (ret < 0) { |
6c591eec SK |
943 | dev_err(dev, "%s: opp key field not found\n", __func__); |
944 | goto free_opp; | |
f47b72a1 VK |
945 | } |
946 | ||
947 | /* Check if the OPP supports hardware's hierarchy of versions or not */ | |
948 | if (!_opp_is_supported(dev, opp_table, np)) { | |
2083da24 VK |
949 | dev_dbg(dev, "OPP not supported by hardware: %s\n", |
950 | of_node_full_name(np)); | |
f47b72a1 VK |
951 | goto free_opp; |
952 | } | |
953 | ||
f47b72a1 VK |
954 | new_opp->turbo = of_property_read_bool(np, "turbo-mode"); |
955 | ||
3466ea2c | 956 | new_opp->np = of_node_get(np); |
f47b72a1 VK |
957 | new_opp->dynamic = false; |
958 | new_opp->available = true; | |
959 | ||
da544b61 VK |
960 | ret = _of_opp_alloc_required_opps(opp_table, new_opp); |
961 | if (ret) | |
962 | goto free_opp; | |
963 | ||
f47b72a1 VK |
964 | if (!of_property_read_u32(np, "clock-latency-ns", &val)) |
965 | new_opp->clock_latency_ns = val; | |
966 | ||
967 | ret = opp_parse_supplies(new_opp, dev, opp_table); | |
968 | if (ret) | |
da544b61 | 969 | goto free_required_opps; |
f47b72a1 | 970 | |
4768914b | 971 | ret = _opp_add(dev, new_opp, opp_table); |
7f8538eb VK |
972 | if (ret) { |
973 | /* Don't return error for duplicate OPPs */ | |
974 | if (ret == -EBUSY) | |
975 | ret = 0; | |
da544b61 | 976 | goto free_required_opps; |
7f8538eb | 977 | } |
f47b72a1 VK |
978 | |
979 | /* OPP to select on device suspend */ | |
980 | if (of_property_read_bool(np, "opp-suspend")) { | |
981 | if (opp_table->suspend_opp) { | |
8bdac14b | 982 | /* Pick the OPP with higher rate/bw/level as suspend OPP */ |
2083da24 | 983 | if (_opp_compare_key(opp_table, new_opp, opp_table->suspend_opp) == 1) { |
45275517 AH |
984 | opp_table->suspend_opp->suspend = false; |
985 | new_opp->suspend = true; | |
986 | opp_table->suspend_opp = new_opp; | |
987 | } | |
f47b72a1 VK |
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 | ||
b6ecd5d4 | 997 | pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu level:%u\n", |
2083da24 | 998 | __func__, new_opp->turbo, new_opp->rates[0], |
dfbe4678 | 999 | new_opp->supplies[0].u_volt, new_opp->supplies[0].u_volt_min, |
b6ecd5d4 DO |
1000 | new_opp->supplies[0].u_volt_max, new_opp->clock_latency_ns, |
1001 | new_opp->level); | |
f47b72a1 VK |
1002 | |
1003 | /* | |
1004 | * Notify the changes in the availability of the operable | |
1005 | * frequency/voltage list. | |
1006 | */ | |
052c6f19 | 1007 | blocking_notifier_call_chain(&opp_table->head, OPP_EVENT_ADD, new_opp); |
deac8703 | 1008 | return new_opp; |
f47b72a1 | 1009 | |
da544b61 VK |
1010 | free_required_opps: |
1011 | _of_opp_free_required_opps(opp_table, new_opp); | |
f47b72a1 | 1012 | free_opp: |
8cd2f6e8 VK |
1013 | _opp_free(new_opp); |
1014 | ||
27ff8187 | 1015 | return ret ? ERR_PTR(ret) : NULL; |
f47b72a1 VK |
1016 | } |
1017 | ||
1018 | /* Initializes OPP tables based on new bindings */ | |
5ed4cecd | 1019 | static int _of_add_opp_table_v2(struct device *dev, struct opp_table *opp_table) |
f47b72a1 VK |
1020 | { |
1021 | struct device_node *np; | |
a5663c9b | 1022 | int ret, count = 0; |
3ba98324 | 1023 | struct dev_pm_opp *opp; |
f47b72a1 | 1024 | |
283d55e6 | 1025 | /* OPP table is already initialized for the device */ |
03758d60 | 1026 | mutex_lock(&opp_table->lock); |
283d55e6 | 1027 | if (opp_table->parsed_static_opps) { |
03758d60 VK |
1028 | opp_table->parsed_static_opps++; |
1029 | mutex_unlock(&opp_table->lock); | |
283d55e6 VK |
1030 | return 0; |
1031 | } | |
1032 | ||
03758d60 VK |
1033 | opp_table->parsed_static_opps = 1; |
1034 | mutex_unlock(&opp_table->lock); | |
b19c2355 | 1035 | |
f47b72a1 | 1036 | /* We have opp-table node now, iterate over it and add OPPs */ |
5ed4cecd | 1037 | for_each_available_child_of_node(opp_table->np, np) { |
deac8703 DG |
1038 | opp = _opp_add_static_v2(opp_table, dev, np); |
1039 | if (IS_ERR(opp)) { | |
1040 | ret = PTR_ERR(opp); | |
f47b72a1 VK |
1041 | dev_err(dev, "%s: Failed to add OPP, %d\n", __func__, |
1042 | ret); | |
7978db34 | 1043 | of_node_put(np); |
03758d60 | 1044 | goto remove_static_opp; |
deac8703 DG |
1045 | } else if (opp) { |
1046 | count++; | |
f47b72a1 VK |
1047 | } |
1048 | } | |
1049 | ||
335ffab3 MM |
1050 | /* There should be one or more OPPs defined */ |
1051 | if (!count) { | |
1052 | dev_err(dev, "%s: no supported OPPs", __func__); | |
ba003319 | 1053 | ret = -ENOENT; |
03758d60 | 1054 | goto remove_static_opp; |
ba003319 | 1055 | } |
f47b72a1 | 1056 | |
7eba0c76 VK |
1057 | lazy_link_required_opp_table(opp_table); |
1058 | ||
cdd6ed90 | 1059 | return 0; |
ba003319 | 1060 | |
03758d60 VK |
1061 | remove_static_opp: |
1062 | _opp_remove_all_static(opp_table); | |
ba003319 VK |
1063 | |
1064 | return ret; | |
f47b72a1 VK |
1065 | } |
1066 | ||
1067 | /* Initializes OPP tables based on old-deprecated bindings */ | |
5ed4cecd | 1068 | static int _of_add_opp_table_v1(struct device *dev, struct opp_table *opp_table) |
f47b72a1 VK |
1069 | { |
1070 | const struct property *prop; | |
1071 | const __be32 *val; | |
8cd2f6e8 | 1072 | int nr, ret = 0; |
f47b72a1 | 1073 | |
90d46d71 VK |
1074 | mutex_lock(&opp_table->lock); |
1075 | if (opp_table->parsed_static_opps) { | |
1076 | opp_table->parsed_static_opps++; | |
1077 | mutex_unlock(&opp_table->lock); | |
1078 | return 0; | |
1079 | } | |
1080 | ||
1081 | opp_table->parsed_static_opps = 1; | |
1082 | mutex_unlock(&opp_table->lock); | |
1083 | ||
f47b72a1 | 1084 | prop = of_find_property(dev->of_node, "operating-points", NULL); |
90d46d71 VK |
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 | } | |
f47b72a1 VK |
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__); | |
90d46d71 VK |
1101 | ret = -EINVAL; |
1102 | goto remove_static_opp; | |
f47b72a1 VK |
1103 | } |
1104 | ||
1105 | val = prop->value; | |
1106 | while (nr) { | |
184ff4f7 NC |
1107 | unsigned long freq = be32_to_cpup(val++) * 1000; |
1108 | unsigned long volt = be32_to_cpup(val++); | |
248a38d5 | 1109 | struct dev_pm_opp_data data = { |
184ff4f7 NC |
1110 | .freq = freq, |
1111 | .u_volt = volt, | |
248a38d5 | 1112 | }; |
f47b72a1 | 1113 | |
248a38d5 | 1114 | ret = _opp_add_v1(opp_table, dev, &data, false); |
04a86a84 VK |
1115 | if (ret) { |
1116 | dev_err(dev, "%s: Failed to add OPP %ld (%d)\n", | |
248a38d5 | 1117 | __func__, data.freq, ret); |
90d46d71 | 1118 | goto remove_static_opp; |
04a86a84 | 1119 | } |
f47b72a1 VK |
1120 | nr -= 2; |
1121 | } | |
1122 | ||
1f6620f8 VK |
1123 | return 0; |
1124 | ||
90d46d71 VK |
1125 | remove_static_opp: |
1126 | _opp_remove_all_static(opp_table); | |
1127 | ||
8cd2f6e8 | 1128 | return ret; |
f47b72a1 VK |
1129 | } |
1130 | ||
1e5fb384 | 1131 | static int _of_add_table_indexed(struct device *dev, int index) |
f47b72a1 | 1132 | { |
5ed4cecd | 1133 | struct opp_table *opp_table; |
406e4765 | 1134 | int ret, count; |
f47b72a1 | 1135 | |
406e4765 VK |
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(dev->of_node, | |
1142 | "operating-points-v2", NULL); | |
1143 | if (count == 1) | |
1144 | index = 0; | |
1145 | } | |
1146 | ||
1e5fb384 | 1147 | opp_table = _add_opp_table_indexed(dev, index, true); |
dd461cd9 SG |
1148 | if (IS_ERR(opp_table)) |
1149 | return PTR_ERR(opp_table); | |
5ed4cecd | 1150 | |
f47b72a1 | 1151 | /* |
5ed4cecd VK |
1152 | * OPPs have two version of bindings now. Also try the old (v1) |
1153 | * bindings for backward compatibility with older dtbs. | |
f47b72a1 | 1154 | */ |
5ed4cecd VK |
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); | |
f47b72a1 | 1159 | |
5ed4cecd VK |
1160 | if (ret) |
1161 | dev_pm_opp_put_opp_table(opp_table); | |
f47b72a1 VK |
1162 | |
1163 | return ret; | |
1164 | } | |
f47b72a1 | 1165 | |
3d5cfbb6 YL |
1166 | static void devm_pm_opp_of_table_release(void *data) |
1167 | { | |
1168 | dev_pm_opp_of_remove_table(data); | |
1169 | } | |
1170 | ||
1e5fb384 | 1171 | static int _devm_of_add_table_indexed(struct device *dev, int index) |
e69709f6 DO |
1172 | { |
1173 | int ret; | |
1174 | ||
1e5fb384 | 1175 | ret = _of_add_table_indexed(dev, index); |
e69709f6 DO |
1176 | if (ret) |
1177 | return ret; | |
1178 | ||
1179 | return devm_add_action_or_reset(dev, devm_pm_opp_of_table_release, dev); | |
1180 | } | |
1181 | ||
3d5cfbb6 YL |
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 | { | |
1e5fb384 | 1203 | return _devm_of_add_table_indexed(dev, 0); |
3d5cfbb6 YL |
1204 | } |
1205 | EXPORT_SYMBOL_GPL(devm_pm_opp_of_add_table); | |
1206 | ||
fa9b274f | 1207 | /** |
406e4765 | 1208 | * dev_pm_opp_of_add_table() - Initialize opp table from device tree |
fa9b274f | 1209 | * @dev: device pointer used to lookup OPP table. |
fa9b274f | 1210 | * |
406e4765 | 1211 | * Register the initial OPP table with the OPP library for given device. |
fa9b274f VK |
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 | */ | |
406e4765 | 1224 | int dev_pm_opp_of_add_table(struct device *dev) |
fa9b274f | 1225 | { |
1e5fb384 | 1226 | return _of_add_table_indexed(dev, 0); |
406e4765 VK |
1227 | } |
1228 | EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table); | |
fa9b274f | 1229 | |
406e4765 VK |
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 | { | |
1e5fb384 | 1242 | return _of_add_table_indexed(dev, index); |
fa9b274f VK |
1243 | } |
1244 | EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table_indexed); | |
1245 | ||
e69709f6 DO |
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 | { | |
1e5fb384 | 1255 | return _devm_of_add_table_indexed(dev, index); |
e69709f6 DO |
1256 | } |
1257 | EXPORT_SYMBOL_GPL(devm_pm_opp_of_add_table_indexed); | |
1258 | ||
f47b72a1 VK |
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. | |
f47b72a1 VK |
1267 | */ |
1268 | void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask) | |
1269 | { | |
2a4eb735 | 1270 | _dev_pm_opp_cpumask_remove_table(cpumask, -1); |
f47b72a1 VK |
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. | |
f47b72a1 VK |
1279 | */ |
1280 | int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask) | |
1281 | { | |
1282 | struct device *cpu_dev; | |
50b6b87c | 1283 | int cpu, ret; |
f47b72a1 | 1284 | |
50b6b87c VK |
1285 | if (WARN_ON(cpumask_empty(cpumask))) |
1286 | return -ENODEV; | |
f47b72a1 VK |
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); | |
50b6b87c VK |
1293 | ret = -ENODEV; |
1294 | goto remove_table; | |
f47b72a1 VK |
1295 | } |
1296 | ||
1297 | ret = dev_pm_opp_of_add_table(cpu_dev); | |
1298 | if (ret) { | |
5b60697c VK |
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); | |
f47b72a1 | 1305 | |
50b6b87c | 1306 | goto remove_table; |
f47b72a1 VK |
1307 | } |
1308 | } | |
1309 | ||
50b6b87c VK |
1310 | return 0; |
1311 | ||
1312 | remove_table: | |
1313 | /* Free all other OPPs */ | |
1314 | _dev_pm_opp_cpumask_remove_table(cpumask, cpu); | |
1315 | ||
f47b72a1 VK |
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. | |
f47b72a1 VK |
1336 | */ |
1337 | int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, | |
1338 | struct cpumask *cpumask) | |
1339 | { | |
76279291 | 1340 | struct device_node *np, *tmp_np, *cpu_np; |
f47b72a1 VK |
1341 | int cpu, ret = 0; |
1342 | ||
1343 | /* Get OPP descriptor node */ | |
0764c604 | 1344 | np = dev_pm_opp_of_get_opp_desc_node(cpu_dev); |
f47b72a1 | 1345 | if (!np) { |
349aa92e | 1346 | dev_dbg(cpu_dev, "%s: Couldn't find opp node.\n", __func__); |
f47b72a1 VK |
1347 | return -ENOENT; |
1348 | } | |
1349 | ||
1350 | cpumask_set_cpu(cpu_dev->id, cpumask); | |
1351 | ||
1352 | /* OPPs are shared ? */ | |
1353 | if (!of_property_read_bool(np, "opp-shared")) | |
1354 | goto put_cpu_node; | |
1355 | ||
1356 | for_each_possible_cpu(cpu) { | |
1357 | if (cpu == cpu_dev->id) | |
1358 | continue; | |
1359 | ||
9867999f | 1360 | cpu_np = of_cpu_device_node_get(cpu); |
76279291 WR |
1361 | if (!cpu_np) { |
1362 | dev_err(cpu_dev, "%s: failed to get cpu%d node\n", | |
f47b72a1 | 1363 | __func__, cpu); |
76279291 | 1364 | ret = -ENOENT; |
f47b72a1 VK |
1365 | goto put_cpu_node; |
1366 | } | |
1367 | ||
1368 | /* Get OPP descriptor node */ | |
fa9b274f | 1369 | tmp_np = _opp_of_get_opp_desc_node(cpu_np, 0); |
9867999f | 1370 | of_node_put(cpu_np); |
f47b72a1 | 1371 | if (!tmp_np) { |
76279291 | 1372 | pr_err("%pOF: Couldn't find opp node\n", cpu_np); |
f47b72a1 VK |
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, cpumask); | |
1380 | ||
1381 | of_node_put(tmp_np); | |
1382 | } | |
1383 | ||
1384 | put_cpu_node: | |
1385 | of_node_put(np); | |
1386 | return ret; | |
1387 | } | |
1388 | EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus); | |
a88bd2a5 VK |
1389 | |
1390 | /** | |
4c6a343e | 1391 | * of_get_required_opp_performance_state() - Search for required OPP and return its performance state. |
a88bd2a5 | 1392 | * @np: Node that contains the "required-opps" property. |
4c6a343e | 1393 | * @index: Index of the phandle to parse. |
a88bd2a5 | 1394 | * |
4c6a343e VK |
1395 | * Returns the performance state of the OPP pointed out by the "required-opps" |
1396 | * property at @index in @np. | |
a88bd2a5 | 1397 | * |
2feb5a89 VK |
1398 | * Return: Zero or positive performance state on success, otherwise negative |
1399 | * value on errors. | |
a88bd2a5 | 1400 | */ |
2feb5a89 | 1401 | int of_get_required_opp_performance_state(struct device_node *np, int index) |
a88bd2a5 | 1402 | { |
4c6a343e | 1403 | struct dev_pm_opp *opp; |
a88bd2a5 VK |
1404 | struct device_node *required_np; |
1405 | struct opp_table *opp_table; | |
2feb5a89 | 1406 | int pstate = -EINVAL; |
a88bd2a5 | 1407 | |
4c6a343e VK |
1408 | required_np = of_parse_required_opp(np, index); |
1409 | if (!required_np) | |
020d86fc | 1410 | return -ENODEV; |
a88bd2a5 | 1411 | |
4c6a343e VK |
1412 | opp_table = _find_table_of_opp_np(required_np); |
1413 | if (IS_ERR(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; | |
a88bd2a5 VK |
1417 | } |
1418 | ||
84cb7ff3 VK |
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 | ||
4c6a343e VK |
1425 | opp = _find_opp_of_np(opp_table, required_np); |
1426 | if (opp) { | |
073d3d2c VK |
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 | } | |
4c6a343e | 1433 | dev_pm_opp_put(opp); |
073d3d2c | 1434 | |
a88bd2a5 VK |
1435 | } |
1436 | ||
4c6a343e | 1437 | dev_pm_opp_put_opp_table(opp_table); |
a88bd2a5 | 1438 | |
4c6a343e | 1439 | put_required_np: |
a88bd2a5 | 1440 | of_node_put(required_np); |
a88bd2a5 | 1441 | |
4c6a343e | 1442 | return pstate; |
a88bd2a5 | 1443 | } |
4c6a343e | 1444 | EXPORT_SYMBOL_GPL(of_get_required_opp_performance_state); |
e2f4b5f8 VK |
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(opp)) { | |
1457 | pr_err("%s: Invalid parameters\n", __func__); | |
1458 | return NULL; | |
1459 | } | |
1460 | ||
1461 | return of_node_get(opp->np); | |
1462 | } | |
1463 | EXPORT_SYMBOL_GPL(dev_pm_opp_get_of_node); | |
a4f342b9 | 1464 | |
32bf8bc9 LL |
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 | |
ae6ccaa6 | 1470 | * frequency and @uW to the associated power. |
32bf8bc9 LL |
1471 | * |
1472 | * Returns 0 on success or a proper -EINVAL value in case of error. | |
1473 | */ | |
1474 | static int __maybe_unused | |
ae6ccaa6 | 1475 | _get_dt_power(struct device *dev, unsigned long *uW, unsigned long *kHz) |
32bf8bc9 LL |
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, &opp_freq); | |
1483 | if (IS_ERR(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; | |
ae6ccaa6 | 1492 | *uW = opp_power; |
32bf8bc9 LL |
1493 | |
1494 | return 0; | |
1495 | } | |
1496 | ||
a4f342b9 QP |
1497 | /* |
1498 | * Callback function provided to the Energy Model framework upon registration. | |
0e0ffa85 | 1499 | * This computes the power estimated by @dev at @kHz if it is the frequency |
a4f342b9 QP |
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 | |
ae6ccaa6 | 1502 | * frequency and @uW to the associated power. The power is estimated as |
0e0ffa85 LL |
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. | |
a4f342b9 | 1505 | * |
0e0ffa85 LL |
1506 | * Returns -EINVAL if the power calculation failed because of missing |
1507 | * parameters, 0 otherwise. | |
a4f342b9 | 1508 | */ |
ae6ccaa6 | 1509 | static int __maybe_unused _get_power(struct device *dev, unsigned long *uW, |
75a3a99a | 1510 | unsigned long *kHz) |
a4f342b9 | 1511 | { |
a4f342b9 QP |
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 | ||
0e0ffa85 | 1519 | np = of_node_get(dev->of_node); |
a4f342b9 QP |
1520 | if (!np) |
1521 | return -EINVAL; | |
1522 | ||
1523 | ret = of_property_read_u32(np, "dynamic-power-coefficient", &cap); | |
1524 | of_node_put(np); | |
1525 | if (ret) | |
1526 | return -EINVAL; | |
1527 | ||
1528 | Hz = *kHz * 1000; | |
0e0ffa85 | 1529 | opp = dev_pm_opp_find_freq_ceil(dev, &Hz); |
a4f342b9 QP |
1530 | if (IS_ERR(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); | |
ae6ccaa6 LL |
1539 | /* Provide power in micro-Watts */ |
1540 | do_div(tmp, 1000000); | |
a4f342b9 | 1541 | |
ae6ccaa6 | 1542 | *uW = (unsigned long)tmp; |
a4f342b9 QP |
1543 | *kHz = Hz / 1000; |
1544 | ||
1545 | return 0; | |
1546 | } | |
1547 | ||
32bf8bc9 LL |
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); | |
1555 | if (IS_ERR(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 | ||
a4f342b9 QP |
1566 | /** |
1567 | * dev_pm_opp_of_register_em() - Attempt to register an Energy Model | |
0e0ffa85 LL |
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. | |
a4f342b9 QP |
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. | |
0e0ffa85 LL |
1574 | * Having this property means the voltages are known for OPPs and the EM |
1575 | * might be calculated. | |
a4f342b9 | 1576 | */ |
0e0ffa85 | 1577 | int dev_pm_opp_of_register_em(struct device *dev, struct cpumask *cpus) |
a4f342b9 | 1578 | { |
32bf8bc9 | 1579 | struct em_data_callback em_cb; |
a4f342b9 | 1580 | struct device_node *np; |
0e0ffa85 | 1581 | int ret, nr_opp; |
a4f342b9 QP |
1582 | u32 cap; |
1583 | ||
0e0ffa85 LL |
1584 | if (IS_ERR_OR_NULL(dev)) { |
1585 | ret = -EINVAL; | |
1586 | goto failed; | |
1587 | } | |
a4f342b9 | 1588 | |
0e0ffa85 LL |
1589 | nr_opp = dev_pm_opp_get_opp_count(dev); |
1590 | if (nr_opp <= 0) { | |
1591 | ret = -EINVAL; | |
1592 | goto failed; | |
1593 | } | |
a4f342b9 | 1594 | |
32bf8bc9 LL |
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 | ||
0e0ffa85 LL |
1601 | np = of_node_get(dev->of_node); |
1602 | if (!np) { | |
1603 | ret = -EINVAL; | |
1604 | goto failed; | |
1605 | } | |
a4f342b9 QP |
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, "dynamic-power-coefficient", &cap); | |
1615 | of_node_put(np); | |
0e0ffa85 LL |
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 | } | |
a4f342b9 | 1621 | |
32bf8bc9 LL |
1622 | EM_SET_ACTIVE_POWER_CB(em_cb, _get_power); |
1623 | ||
1624 | register_em: | |
c250d50f | 1625 | ret = em_dev_register_perf_domain(dev, nr_opp, &em_cb, cpus, true); |
0e0ffa85 LL |
1626 | if (ret) |
1627 | goto failed; | |
a4f342b9 | 1628 | |
0e0ffa85 LL |
1629 | return 0; |
1630 | ||
1631 | failed: | |
1632 | dev_dbg(dev, "Couldn't register Energy Model %d\n", ret); | |
1633 | return ret; | |
a4f342b9 QP |
1634 | } |
1635 | EXPORT_SYMBOL_GPL(dev_pm_opp_of_register_em); |