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