Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
4 : : * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
5 : : *
6 : : * Standard functionality for the common clock API. See Documentation/driver-api/clk.rst
7 : : */
8 : :
9 : : #include <linux/clk.h>
10 : : #include <linux/clk-provider.h>
11 : : #include <linux/clk/clk-conf.h>
12 : : #include <linux/module.h>
13 : : #include <linux/mutex.h>
14 : : #include <linux/spinlock.h>
15 : : #include <linux/err.h>
16 : : #include <linux/list.h>
17 : : #include <linux/slab.h>
18 : : #include <linux/of.h>
19 : : #include <linux/device.h>
20 : : #include <linux/init.h>
21 : : #include <linux/pm_runtime.h>
22 : : #include <linux/sched.h>
23 : : #include <linux/clkdev.h>
24 : :
25 : : #include "clk.h"
26 : :
27 : : static DEFINE_SPINLOCK(enable_lock);
28 : : static DEFINE_MUTEX(prepare_lock);
29 : :
30 : : static struct task_struct *prepare_owner;
31 : : static struct task_struct *enable_owner;
32 : :
33 : : static int prepare_refcnt;
34 : : static int enable_refcnt;
35 : :
36 : : static HLIST_HEAD(clk_root_list);
37 : : static HLIST_HEAD(clk_orphan_list);
38 : : static LIST_HEAD(clk_notifier_list);
39 : :
40 : : static struct hlist_head *all_lists[] = {
41 : : &clk_root_list,
42 : : &clk_orphan_list,
43 : : NULL,
44 : : };
45 : :
46 : : /*** private data structures ***/
47 : :
48 : : struct clk_parent_map {
49 : : const struct clk_hw *hw;
50 : : struct clk_core *core;
51 : : const char *fw_name;
52 : : const char *name;
53 : : int index;
54 : : };
55 : :
56 : : struct clk_core {
57 : : const char *name;
58 : : const struct clk_ops *ops;
59 : : struct clk_hw *hw;
60 : : struct module *owner;
61 : : struct device *dev;
62 : : struct device_node *of_node;
63 : : struct clk_core *parent;
64 : : struct clk_parent_map *parents;
65 : : u8 num_parents;
66 : : u8 new_parent_index;
67 : : unsigned long rate;
68 : : unsigned long req_rate;
69 : : unsigned long new_rate;
70 : : struct clk_core *new_parent;
71 : : struct clk_core *new_child;
72 : : unsigned long flags;
73 : : bool orphan;
74 : : bool rpm_enabled;
75 : : unsigned int enable_count;
76 : : unsigned int prepare_count;
77 : : unsigned int protect_count;
78 : : unsigned long min_rate;
79 : : unsigned long max_rate;
80 : : unsigned long accuracy;
81 : : int phase;
82 : : struct clk_duty duty;
83 : : struct hlist_head children;
84 : : struct hlist_node child_node;
85 : : struct hlist_head clks;
86 : : unsigned int notifier_count;
87 : : #ifdef CONFIG_DEBUG_FS
88 : : struct dentry *dentry;
89 : : struct hlist_node debug_node;
90 : : #endif
91 : : struct kref ref;
92 : : };
93 : :
94 : : #define CREATE_TRACE_POINTS
95 : : #include <trace/events/clk.h>
96 : :
97 : : struct clk {
98 : : struct clk_core *core;
99 : : struct device *dev;
100 : : const char *dev_id;
101 : : const char *con_id;
102 : : unsigned long min_rate;
103 : : unsigned long max_rate;
104 : : unsigned int exclusive_count;
105 : : struct hlist_node clks_node;
106 : : };
107 : :
108 : : /*** runtime pm ***/
109 : 3 : static int clk_pm_runtime_get(struct clk_core *core)
110 : : {
111 : : int ret;
112 : :
113 : 3 : if (!core->rpm_enabled)
114 : : return 0;
115 : :
116 : 0 : ret = pm_runtime_get_sync(core->dev);
117 : 0 : if (ret < 0) {
118 : 0 : pm_runtime_put_noidle(core->dev);
119 : 0 : return ret;
120 : : }
121 : : return 0;
122 : : }
123 : :
124 : : static void clk_pm_runtime_put(struct clk_core *core)
125 : : {
126 : 3 : if (!core->rpm_enabled)
127 : : return;
128 : :
129 : 0 : pm_runtime_put_sync(core->dev);
130 : : }
131 : :
132 : : /*** locking ***/
133 : 3 : static void clk_prepare_lock(void)
134 : : {
135 : 3 : if (!mutex_trylock(&prepare_lock)) {
136 : 0 : if (prepare_owner == current) {
137 : 0 : prepare_refcnt++;
138 : 3 : return;
139 : : }
140 : 0 : mutex_lock(&prepare_lock);
141 : : }
142 : 3 : WARN_ON_ONCE(prepare_owner != NULL);
143 : 3 : WARN_ON_ONCE(prepare_refcnt != 0);
144 : 3 : prepare_owner = current;
145 : 3 : prepare_refcnt = 1;
146 : : }
147 : :
148 : 3 : static void clk_prepare_unlock(void)
149 : : {
150 : 3 : WARN_ON_ONCE(prepare_owner != current);
151 : 3 : WARN_ON_ONCE(prepare_refcnt == 0);
152 : :
153 : 3 : if (--prepare_refcnt)
154 : 3 : return;
155 : 3 : prepare_owner = NULL;
156 : 3 : mutex_unlock(&prepare_lock);
157 : : }
158 : :
159 : 3 : static unsigned long clk_enable_lock(void)
160 : : __acquires(enable_lock)
161 : : {
162 : : unsigned long flags;
163 : :
164 : : /*
165 : : * On UP systems, spin_trylock_irqsave() always returns true, even if
166 : : * we already hold the lock. So, in that case, we rely only on
167 : : * reference counting.
168 : : */
169 : 3 : if (!IS_ENABLED(CONFIG_SMP) ||
170 : 3 : !spin_trylock_irqsave(&enable_lock, flags)) {
171 : 0 : if (enable_owner == current) {
172 : 0 : enable_refcnt++;
173 : : __acquire(enable_lock);
174 : : if (!IS_ENABLED(CONFIG_SMP))
175 : : local_save_flags(flags);
176 : 0 : return flags;
177 : : }
178 : 0 : spin_lock_irqsave(&enable_lock, flags);
179 : : }
180 : 3 : WARN_ON_ONCE(enable_owner != NULL);
181 : 3 : WARN_ON_ONCE(enable_refcnt != 0);
182 : 3 : enable_owner = current;
183 : 3 : enable_refcnt = 1;
184 : 3 : return flags;
185 : : }
186 : :
187 : 3 : static void clk_enable_unlock(unsigned long flags)
188 : : __releases(enable_lock)
189 : : {
190 : 3 : WARN_ON_ONCE(enable_owner != current);
191 : 3 : WARN_ON_ONCE(enable_refcnt == 0);
192 : :
193 : 3 : if (--enable_refcnt) {
194 : : __release(enable_lock);
195 : 3 : return;
196 : : }
197 : 3 : enable_owner = NULL;
198 : : spin_unlock_irqrestore(&enable_lock, flags);
199 : : }
200 : :
201 : : static bool clk_core_rate_is_protected(struct clk_core *core)
202 : : {
203 : 2 : return core->protect_count;
204 : : }
205 : :
206 : 3 : static bool clk_core_is_prepared(struct clk_core *core)
207 : : {
208 : : bool ret = false;
209 : :
210 : : /*
211 : : * .is_prepared is optional for clocks that can prepare
212 : : * fall back to software usage counter if it is missing
213 : : */
214 : 3 : if (!core->ops->is_prepared)
215 : 3 : return core->prepare_count;
216 : :
217 : 2 : if (!clk_pm_runtime_get(core)) {
218 : 2 : ret = core->ops->is_prepared(core->hw);
219 : : clk_pm_runtime_put(core);
220 : : }
221 : :
222 : 2 : return ret;
223 : : }
224 : :
225 : 3 : static bool clk_core_is_enabled(struct clk_core *core)
226 : : {
227 : : bool ret = false;
228 : :
229 : : /*
230 : : * .is_enabled is only mandatory for clocks that gate
231 : : * fall back to software usage counter if .is_enabled is missing
232 : : */
233 : 3 : if (!core->ops->is_enabled)
234 : 3 : return core->enable_count;
235 : :
236 : : /*
237 : : * Check if clock controller's device is runtime active before
238 : : * calling .is_enabled callback. If not, assume that clock is
239 : : * disabled, because we might be called from atomic context, from
240 : : * which pm_runtime_get() is not allowed.
241 : : * This function is called mainly from clk_disable_unused_subtree,
242 : : * which ensures proper runtime pm activation of controller before
243 : : * taking enable spinlock, but the below check is needed if one tries
244 : : * to call it from other places.
245 : : */
246 : 3 : if (core->rpm_enabled) {
247 : 0 : pm_runtime_get_noresume(core->dev);
248 : 0 : if (!pm_runtime_active(core->dev)) {
249 : : ret = false;
250 : : goto done;
251 : : }
252 : : }
253 : :
254 : 3 : ret = core->ops->is_enabled(core->hw);
255 : : done:
256 : 3 : if (core->rpm_enabled)
257 : 0 : pm_runtime_put(core->dev);
258 : :
259 : 3 : return ret;
260 : : }
261 : :
262 : : /*** helper functions ***/
263 : :
264 : 3 : const char *__clk_get_name(const struct clk *clk)
265 : : {
266 : 3 : return !clk ? NULL : clk->core->name;
267 : : }
268 : : EXPORT_SYMBOL_GPL(__clk_get_name);
269 : :
270 : 1 : const char *clk_hw_get_name(const struct clk_hw *hw)
271 : : {
272 : 1 : return hw->core->name;
273 : : }
274 : : EXPORT_SYMBOL_GPL(clk_hw_get_name);
275 : :
276 : 0 : struct clk_hw *__clk_get_hw(struct clk *clk)
277 : : {
278 : 0 : return !clk ? NULL : clk->core->hw;
279 : : }
280 : : EXPORT_SYMBOL_GPL(__clk_get_hw);
281 : :
282 : 0 : unsigned int clk_hw_get_num_parents(const struct clk_hw *hw)
283 : : {
284 : 0 : return hw->core->num_parents;
285 : : }
286 : : EXPORT_SYMBOL_GPL(clk_hw_get_num_parents);
287 : :
288 : 0 : struct clk_hw *clk_hw_get_parent(const struct clk_hw *hw)
289 : : {
290 : 0 : return hw->core->parent ? hw->core->parent->hw : NULL;
291 : : }
292 : : EXPORT_SYMBOL_GPL(clk_hw_get_parent);
293 : :
294 : 3 : static struct clk_core *__clk_lookup_subtree(const char *name,
295 : : struct clk_core *core)
296 : : {
297 : : struct clk_core *child;
298 : : struct clk_core *ret;
299 : :
300 : 3 : if (!strcmp(core->name, name))
301 : : return core;
302 : :
303 : 3 : hlist_for_each_entry(child, &core->children, child_node) {
304 : 3 : ret = __clk_lookup_subtree(name, child);
305 : 3 : if (ret)
306 : 3 : return ret;
307 : : }
308 : :
309 : : return NULL;
310 : : }
311 : :
312 : 3 : static struct clk_core *clk_core_lookup(const char *name)
313 : : {
314 : : struct clk_core *root_clk;
315 : : struct clk_core *ret;
316 : :
317 : 3 : if (!name)
318 : : return NULL;
319 : :
320 : : /* search the 'proper' clk tree first */
321 : 3 : hlist_for_each_entry(root_clk, &clk_root_list, child_node) {
322 : 3 : ret = __clk_lookup_subtree(name, root_clk);
323 : 3 : if (ret)
324 : 3 : return ret;
325 : : }
326 : :
327 : : /* if not found, then search the orphan tree */
328 : 3 : hlist_for_each_entry(root_clk, &clk_orphan_list, child_node) {
329 : 3 : ret = __clk_lookup_subtree(name, root_clk);
330 : 3 : if (ret)
331 : 1 : return ret;
332 : : }
333 : :
334 : : return NULL;
335 : : }
336 : :
337 : : #ifdef CONFIG_OF
338 : : static int of_parse_clkspec(const struct device_node *np, int index,
339 : : const char *name, struct of_phandle_args *out_args);
340 : : static struct clk_hw *
341 : : of_clk_get_hw_from_clkspec(struct of_phandle_args *clkspec);
342 : : #else
343 : : static inline int of_parse_clkspec(const struct device_node *np, int index,
344 : : const char *name,
345 : : struct of_phandle_args *out_args)
346 : : {
347 : : return -ENOENT;
348 : : }
349 : : static inline struct clk_hw *
350 : : of_clk_get_hw_from_clkspec(struct of_phandle_args *clkspec)
351 : : {
352 : : return ERR_PTR(-ENOENT);
353 : : }
354 : : #endif
355 : :
356 : : /**
357 : : * clk_core_get - Find the clk_core parent of a clk
358 : : * @core: clk to find parent of
359 : : * @p_index: parent index to search for
360 : : *
361 : : * This is the preferred method for clk providers to find the parent of a
362 : : * clk when that parent is external to the clk controller. The parent_names
363 : : * array is indexed and treated as a local name matching a string in the device
364 : : * node's 'clock-names' property or as the 'con_id' matching the device's
365 : : * dev_name() in a clk_lookup. This allows clk providers to use their own
366 : : * namespace instead of looking for a globally unique parent string.
367 : : *
368 : : * For example the following DT snippet would allow a clock registered by the
369 : : * clock-controller@c001 that has a clk_init_data::parent_data array
370 : : * with 'xtal' in the 'name' member to find the clock provided by the
371 : : * clock-controller@f00abcd without needing to get the globally unique name of
372 : : * the xtal clk.
373 : : *
374 : : * parent: clock-controller@f00abcd {
375 : : * reg = <0xf00abcd 0xabcd>;
376 : : * #clock-cells = <0>;
377 : : * };
378 : : *
379 : : * clock-controller@c001 {
380 : : * reg = <0xc001 0xf00d>;
381 : : * clocks = <&parent>;
382 : : * clock-names = "xtal";
383 : : * #clock-cells = <1>;
384 : : * };
385 : : *
386 : : * Returns: -ENOENT when the provider can't be found or the clk doesn't
387 : : * exist in the provider or the name can't be found in the DT node or
388 : : * in a clkdev lookup. NULL when the provider knows about the clk but it
389 : : * isn't provided on this system.
390 : : * A valid clk_core pointer when the clk can be found in the provider.
391 : : */
392 : 3 : static struct clk_core *clk_core_get(struct clk_core *core, u8 p_index)
393 : : {
394 : 3 : const char *name = core->parents[p_index].fw_name;
395 : 3 : int index = core->parents[p_index].index;
396 : : struct clk_hw *hw = ERR_PTR(-ENOENT);
397 : 3 : struct device *dev = core->dev;
398 : 3 : const char *dev_id = dev ? dev_name(dev) : NULL;
399 : 3 : struct device_node *np = core->of_node;
400 : : struct of_phandle_args clkspec;
401 : :
402 : 3 : if (np && (name || index >= 0) &&
403 : 0 : !of_parse_clkspec(np, index, name, &clkspec)) {
404 : 0 : hw = of_clk_get_hw_from_clkspec(&clkspec);
405 : 0 : of_node_put(clkspec.np);
406 : 3 : } else if (name) {
407 : : /*
408 : : * If the DT search above couldn't find the provider fallback to
409 : : * looking up via clkdev based clk_lookups.
410 : : */
411 : 0 : hw = clk_find_hw(dev_id, name);
412 : : }
413 : :
414 : 3 : if (IS_ERR(hw))
415 : : return ERR_CAST(hw);
416 : :
417 : 0 : return hw->core;
418 : : }
419 : :
420 : 3 : static void clk_core_fill_parent_index(struct clk_core *core, u8 index)
421 : : {
422 : 3 : struct clk_parent_map *entry = &core->parents[index];
423 : : struct clk_core *parent = ERR_PTR(-ENOENT);
424 : :
425 : 3 : if (entry->hw) {
426 : 0 : parent = entry->hw->core;
427 : : /*
428 : : * We have a direct reference but it isn't registered yet?
429 : : * Orphan it and let clk_reparent() update the orphan status
430 : : * when the parent is registered.
431 : : */
432 : 0 : if (!parent)
433 : : parent = ERR_PTR(-EPROBE_DEFER);
434 : : } else {
435 : 3 : parent = clk_core_get(core, index);
436 : 3 : if (IS_ERR(parent) && PTR_ERR(parent) == -ENOENT && entry->name)
437 : 3 : parent = clk_core_lookup(entry->name);
438 : : }
439 : :
440 : : /* Only cache it if it's not an error */
441 : 3 : if (!IS_ERR(parent))
442 : 3 : entry->core = parent;
443 : 3 : }
444 : :
445 : 3 : static struct clk_core *clk_core_get_parent_by_index(struct clk_core *core,
446 : : u8 index)
447 : : {
448 : 3 : if (!core || index >= core->num_parents || !core->parents)
449 : : return NULL;
450 : :
451 : 3 : if (!core->parents[index].core)
452 : 3 : clk_core_fill_parent_index(core, index);
453 : :
454 : 3 : return core->parents[index].core;
455 : : }
456 : :
457 : : struct clk_hw *
458 : 0 : clk_hw_get_parent_by_index(const struct clk_hw *hw, unsigned int index)
459 : : {
460 : : struct clk_core *parent;
461 : :
462 : 0 : parent = clk_core_get_parent_by_index(hw->core, index);
463 : :
464 : 0 : return !parent ? NULL : parent->hw;
465 : : }
466 : : EXPORT_SYMBOL_GPL(clk_hw_get_parent_by_index);
467 : :
468 : 0 : unsigned int __clk_get_enable_count(struct clk *clk)
469 : : {
470 : 0 : return !clk ? 0 : clk->core->enable_count;
471 : : }
472 : :
473 : : static unsigned long clk_core_get_rate_nolock(struct clk_core *core)
474 : : {
475 : 3 : if (!core)
476 : : return 0;
477 : :
478 : 3 : if (!core->num_parents || core->parent)
479 : 3 : return core->rate;
480 : :
481 : : /*
482 : : * Clk must have a parent because num_parents > 0 but the parent isn't
483 : : * known yet. Best to return 0 as the rate of this clk until we can
484 : : * properly recalc the rate based on the parent's rate.
485 : : */
486 : : return 0;
487 : : }
488 : :
489 : 0 : unsigned long clk_hw_get_rate(const struct clk_hw *hw)
490 : : {
491 : 0 : return clk_core_get_rate_nolock(hw->core);
492 : : }
493 : : EXPORT_SYMBOL_GPL(clk_hw_get_rate);
494 : :
495 : : static unsigned long __clk_get_accuracy(struct clk_core *core)
496 : : {
497 : 3 : if (!core)
498 : : return 0;
499 : :
500 : 0 : return core->accuracy;
501 : : }
502 : :
503 : 0 : unsigned long __clk_get_flags(struct clk *clk)
504 : : {
505 : 0 : return !clk ? 0 : clk->core->flags;
506 : : }
507 : : EXPORT_SYMBOL_GPL(__clk_get_flags);
508 : :
509 : 0 : unsigned long clk_hw_get_flags(const struct clk_hw *hw)
510 : : {
511 : 0 : return hw->core->flags;
512 : : }
513 : : EXPORT_SYMBOL_GPL(clk_hw_get_flags);
514 : :
515 : 0 : bool clk_hw_is_prepared(const struct clk_hw *hw)
516 : : {
517 : 0 : return clk_core_is_prepared(hw->core);
518 : : }
519 : : EXPORT_SYMBOL_GPL(clk_hw_is_prepared);
520 : :
521 : 0 : bool clk_hw_rate_is_protected(const struct clk_hw *hw)
522 : : {
523 : 0 : return clk_core_rate_is_protected(hw->core);
524 : : }
525 : : EXPORT_SYMBOL_GPL(clk_hw_rate_is_protected);
526 : :
527 : 0 : bool clk_hw_is_enabled(const struct clk_hw *hw)
528 : : {
529 : 0 : return clk_core_is_enabled(hw->core);
530 : : }
531 : : EXPORT_SYMBOL_GPL(clk_hw_is_enabled);
532 : :
533 : 0 : bool __clk_is_enabled(struct clk *clk)
534 : : {
535 : 0 : if (!clk)
536 : : return false;
537 : :
538 : 0 : return clk_core_is_enabled(clk->core);
539 : : }
540 : : EXPORT_SYMBOL_GPL(__clk_is_enabled);
541 : :
542 : : static bool mux_is_better_rate(unsigned long rate, unsigned long now,
543 : : unsigned long best, unsigned long flags)
544 : : {
545 : 0 : if (flags & CLK_MUX_ROUND_CLOSEST)
546 : 0 : return abs(now - rate) < abs(best - rate);
547 : :
548 : 0 : return now <= rate && now > best;
549 : : }
550 : :
551 : 0 : int clk_mux_determine_rate_flags(struct clk_hw *hw,
552 : : struct clk_rate_request *req,
553 : : unsigned long flags)
554 : : {
555 : 0 : struct clk_core *core = hw->core, *parent, *best_parent = NULL;
556 : : int i, num_parents, ret;
557 : : unsigned long best = 0;
558 : 0 : struct clk_rate_request parent_req = *req;
559 : :
560 : : /* if NO_REPARENT flag set, pass through to current parent */
561 : 0 : if (core->flags & CLK_SET_RATE_NO_REPARENT) {
562 : 0 : parent = core->parent;
563 : 0 : if (core->flags & CLK_SET_RATE_PARENT) {
564 : 0 : ret = __clk_determine_rate(parent ? parent->hw : NULL,
565 : : &parent_req);
566 : 0 : if (ret)
567 : : return ret;
568 : :
569 : 0 : best = parent_req.rate;
570 : 0 : } else if (parent) {
571 : : best = clk_core_get_rate_nolock(parent);
572 : : } else {
573 : : best = clk_core_get_rate_nolock(core);
574 : : }
575 : :
576 : : goto out;
577 : : }
578 : :
579 : : /* find the parent that can provide the fastest rate <= rate */
580 : 0 : num_parents = core->num_parents;
581 : 0 : for (i = 0; i < num_parents; i++) {
582 : 0 : parent = clk_core_get_parent_by_index(core, i);
583 : 0 : if (!parent)
584 : 0 : continue;
585 : :
586 : 0 : if (core->flags & CLK_SET_RATE_PARENT) {
587 : 0 : parent_req = *req;
588 : 0 : ret = __clk_determine_rate(parent->hw, &parent_req);
589 : 0 : if (ret)
590 : 0 : continue;
591 : : } else {
592 : 0 : parent_req.rate = clk_core_get_rate_nolock(parent);
593 : : }
594 : :
595 : 0 : if (mux_is_better_rate(req->rate, parent_req.rate,
596 : : best, flags)) {
597 : : best_parent = parent;
598 : : best = parent_req.rate;
599 : : }
600 : : }
601 : :
602 : 0 : if (!best_parent)
603 : : return -EINVAL;
604 : :
605 : : out:
606 : 0 : if (best_parent)
607 : 0 : req->best_parent_hw = best_parent->hw;
608 : 0 : req->best_parent_rate = best;
609 : 0 : req->rate = best;
610 : :
611 : 0 : return 0;
612 : : }
613 : : EXPORT_SYMBOL_GPL(clk_mux_determine_rate_flags);
614 : :
615 : 0 : struct clk *__clk_lookup(const char *name)
616 : : {
617 : 0 : struct clk_core *core = clk_core_lookup(name);
618 : :
619 : 0 : return !core ? NULL : core->hw->clk;
620 : : }
621 : :
622 : 2 : static void clk_core_get_boundaries(struct clk_core *core,
623 : : unsigned long *min_rate,
624 : : unsigned long *max_rate)
625 : : {
626 : : struct clk *clk_user;
627 : :
628 : : lockdep_assert_held(&prepare_lock);
629 : :
630 : 2 : *min_rate = core->min_rate;
631 : 2 : *max_rate = core->max_rate;
632 : :
633 : 2 : hlist_for_each_entry(clk_user, &core->clks, clks_node)
634 : 2 : *min_rate = max(*min_rate, clk_user->min_rate);
635 : :
636 : 2 : hlist_for_each_entry(clk_user, &core->clks, clks_node)
637 : 2 : *max_rate = min(*max_rate, clk_user->max_rate);
638 : 2 : }
639 : :
640 : 2 : void clk_hw_set_rate_range(struct clk_hw *hw, unsigned long min_rate,
641 : : unsigned long max_rate)
642 : : {
643 : 2 : hw->core->min_rate = min_rate;
644 : 2 : hw->core->max_rate = max_rate;
645 : 2 : }
646 : : EXPORT_SYMBOL_GPL(clk_hw_set_rate_range);
647 : :
648 : : /*
649 : : * __clk_mux_determine_rate - clk_ops::determine_rate implementation for a mux type clk
650 : : * @hw: mux type clk to determine rate on
651 : : * @req: rate request, also used to return preferred parent and frequencies
652 : : *
653 : : * Helper for finding best parent to provide a given frequency. This can be used
654 : : * directly as a determine_rate callback (e.g. for a mux), or from a more
655 : : * complex clock that may combine a mux with other operations.
656 : : *
657 : : * Returns: 0 on success, -EERROR value on error
658 : : */
659 : 0 : int __clk_mux_determine_rate(struct clk_hw *hw,
660 : : struct clk_rate_request *req)
661 : : {
662 : 0 : return clk_mux_determine_rate_flags(hw, req, 0);
663 : : }
664 : : EXPORT_SYMBOL_GPL(__clk_mux_determine_rate);
665 : :
666 : 0 : int __clk_mux_determine_rate_closest(struct clk_hw *hw,
667 : : struct clk_rate_request *req)
668 : : {
669 : 0 : return clk_mux_determine_rate_flags(hw, req, CLK_MUX_ROUND_CLOSEST);
670 : : }
671 : : EXPORT_SYMBOL_GPL(__clk_mux_determine_rate_closest);
672 : :
673 : : /*** clk api ***/
674 : :
675 : 0 : static void clk_core_rate_unprotect(struct clk_core *core)
676 : : {
677 : : lockdep_assert_held(&prepare_lock);
678 : :
679 : 0 : if (!core)
680 : : return;
681 : :
682 : 0 : if (WARN(core->protect_count == 0,
683 : : "%s already unprotected\n", core->name))
684 : : return;
685 : :
686 : 0 : if (--core->protect_count > 0)
687 : : return;
688 : :
689 : 0 : clk_core_rate_unprotect(core->parent);
690 : : }
691 : :
692 : : static int clk_core_rate_nuke_protect(struct clk_core *core)
693 : : {
694 : : int ret;
695 : :
696 : : lockdep_assert_held(&prepare_lock);
697 : :
698 : 2 : if (!core)
699 : : return -EINVAL;
700 : :
701 : 2 : if (core->protect_count == 0)
702 : : return 0;
703 : :
704 : 0 : ret = core->protect_count;
705 : 0 : core->protect_count = 1;
706 : 0 : clk_core_rate_unprotect(core);
707 : :
708 : : return ret;
709 : : }
710 : :
711 : : /**
712 : : * clk_rate_exclusive_put - release exclusivity over clock rate control
713 : : * @clk: the clk over which the exclusivity is released
714 : : *
715 : : * clk_rate_exclusive_put() completes a critical section during which a clock
716 : : * consumer cannot tolerate any other consumer making any operation on the
717 : : * clock which could result in a rate change or rate glitch. Exclusive clocks
718 : : * cannot have their rate changed, either directly or indirectly due to changes
719 : : * further up the parent chain of clocks. As a result, clocks up parent chain
720 : : * also get under exclusive control of the calling consumer.
721 : : *
722 : : * If exlusivity is claimed more than once on clock, even by the same consumer,
723 : : * the rate effectively gets locked as exclusivity can't be preempted.
724 : : *
725 : : * Calls to clk_rate_exclusive_put() must be balanced with calls to
726 : : * clk_rate_exclusive_get(). Calls to this function may sleep, and do not return
727 : : * error status.
728 : : */
729 : 0 : void clk_rate_exclusive_put(struct clk *clk)
730 : : {
731 : 0 : if (!clk)
732 : 0 : return;
733 : :
734 : 0 : clk_prepare_lock();
735 : :
736 : : /*
737 : : * if there is something wrong with this consumer protect count, stop
738 : : * here before messing with the provider
739 : : */
740 : 0 : if (WARN_ON(clk->exclusive_count <= 0))
741 : : goto out;
742 : :
743 : 0 : clk_core_rate_unprotect(clk->core);
744 : 0 : clk->exclusive_count--;
745 : : out:
746 : 0 : clk_prepare_unlock();
747 : : }
748 : : EXPORT_SYMBOL_GPL(clk_rate_exclusive_put);
749 : :
750 : 0 : static void clk_core_rate_protect(struct clk_core *core)
751 : : {
752 : : lockdep_assert_held(&prepare_lock);
753 : :
754 : 0 : if (!core)
755 : 0 : return;
756 : :
757 : 0 : if (core->protect_count == 0)
758 : 0 : clk_core_rate_protect(core->parent);
759 : :
760 : 0 : core->protect_count++;
761 : : }
762 : :
763 : : static void clk_core_rate_restore_protect(struct clk_core *core, int count)
764 : : {
765 : : lockdep_assert_held(&prepare_lock);
766 : :
767 : 2 : if (!core)
768 : : return;
769 : :
770 : 2 : if (count == 0)
771 : : return;
772 : :
773 : 0 : clk_core_rate_protect(core);
774 : 0 : core->protect_count = count;
775 : : }
776 : :
777 : : /**
778 : : * clk_rate_exclusive_get - get exclusivity over the clk rate control
779 : : * @clk: the clk over which the exclusity of rate control is requested
780 : : *
781 : : * clk_rate_exlusive_get() begins a critical section during which a clock
782 : : * consumer cannot tolerate any other consumer making any operation on the
783 : : * clock which could result in a rate change or rate glitch. Exclusive clocks
784 : : * cannot have their rate changed, either directly or indirectly due to changes
785 : : * further up the parent chain of clocks. As a result, clocks up parent chain
786 : : * also get under exclusive control of the calling consumer.
787 : : *
788 : : * If exlusivity is claimed more than once on clock, even by the same consumer,
789 : : * the rate effectively gets locked as exclusivity can't be preempted.
790 : : *
791 : : * Calls to clk_rate_exclusive_get() should be balanced with calls to
792 : : * clk_rate_exclusive_put(). Calls to this function may sleep.
793 : : * Returns 0 on success, -EERROR otherwise
794 : : */
795 : 0 : int clk_rate_exclusive_get(struct clk *clk)
796 : : {
797 : 0 : if (!clk)
798 : : return 0;
799 : :
800 : 0 : clk_prepare_lock();
801 : 0 : clk_core_rate_protect(clk->core);
802 : 0 : clk->exclusive_count++;
803 : 0 : clk_prepare_unlock();
804 : :
805 : 0 : return 0;
806 : : }
807 : : EXPORT_SYMBOL_GPL(clk_rate_exclusive_get);
808 : :
809 : 3 : static void clk_core_unprepare(struct clk_core *core)
810 : : {
811 : : lockdep_assert_held(&prepare_lock);
812 : :
813 : 3 : if (!core)
814 : : return;
815 : :
816 : 3 : if (WARN(core->prepare_count == 0,
817 : : "%s already unprepared\n", core->name))
818 : : return;
819 : :
820 : 3 : if (WARN(core->prepare_count == 1 && core->flags & CLK_IS_CRITICAL,
821 : : "Unpreparing critical %s\n", core->name))
822 : : return;
823 : :
824 : 3 : if (core->flags & CLK_SET_RATE_GATE)
825 : 0 : clk_core_rate_unprotect(core);
826 : :
827 : 3 : if (--core->prepare_count > 0)
828 : : return;
829 : :
830 : 1 : WARN(core->enable_count > 0, "Unpreparing enabled %s\n", core->name);
831 : :
832 : 1 : trace_clk_unprepare(core);
833 : :
834 : 1 : if (core->ops->unprepare)
835 : 1 : core->ops->unprepare(core->hw);
836 : :
837 : : clk_pm_runtime_put(core);
838 : :
839 : 1 : trace_clk_unprepare_complete(core);
840 : 1 : clk_core_unprepare(core->parent);
841 : : }
842 : :
843 : : static void clk_core_unprepare_lock(struct clk_core *core)
844 : : {
845 : 3 : clk_prepare_lock();
846 : 3 : clk_core_unprepare(core);
847 : 3 : clk_prepare_unlock();
848 : : }
849 : :
850 : : /**
851 : : * clk_unprepare - undo preparation of a clock source
852 : : * @clk: the clk being unprepared
853 : : *
854 : : * clk_unprepare may sleep, which differentiates it from clk_disable. In a
855 : : * simple case, clk_unprepare can be used instead of clk_disable to gate a clk
856 : : * if the operation may sleep. One example is a clk which is accessed over
857 : : * I2c. In the complex case a clk gate operation may require a fast and a slow
858 : : * part. It is this reason that clk_unprepare and clk_disable are not mutually
859 : : * exclusive. In fact clk_disable must be called before clk_unprepare.
860 : : */
861 : 3 : void clk_unprepare(struct clk *clk)
862 : : {
863 : 3 : if (IS_ERR_OR_NULL(clk))
864 : 3 : return;
865 : :
866 : 3 : clk_core_unprepare_lock(clk->core);
867 : : }
868 : : EXPORT_SYMBOL_GPL(clk_unprepare);
869 : :
870 : 3 : static int clk_core_prepare(struct clk_core *core)
871 : : {
872 : : int ret = 0;
873 : :
874 : : lockdep_assert_held(&prepare_lock);
875 : :
876 : 3 : if (!core)
877 : : return 0;
878 : :
879 : 3 : if (core->prepare_count == 0) {
880 : 3 : ret = clk_pm_runtime_get(core);
881 : 3 : if (ret)
882 : : return ret;
883 : :
884 : 3 : ret = clk_core_prepare(core->parent);
885 : 3 : if (ret)
886 : : goto runtime_put;
887 : :
888 : 3 : trace_clk_prepare(core);
889 : :
890 : 3 : if (core->ops->prepare)
891 : 3 : ret = core->ops->prepare(core->hw);
892 : :
893 : 3 : trace_clk_prepare_complete(core);
894 : :
895 : 3 : if (ret)
896 : : goto unprepare;
897 : : }
898 : :
899 : 3 : core->prepare_count++;
900 : :
901 : : /*
902 : : * CLK_SET_RATE_GATE is a special case of clock protection
903 : : * Instead of a consumer claiming exclusive rate control, it is
904 : : * actually the provider which prevents any consumer from making any
905 : : * operation which could result in a rate change or rate glitch while
906 : : * the clock is prepared.
907 : : */
908 : 3 : if (core->flags & CLK_SET_RATE_GATE)
909 : 0 : clk_core_rate_protect(core);
910 : :
911 : : return 0;
912 : : unprepare:
913 : 1 : clk_core_unprepare(core->parent);
914 : : runtime_put:
915 : : clk_pm_runtime_put(core);
916 : 1 : return ret;
917 : : }
918 : :
919 : : static int clk_core_prepare_lock(struct clk_core *core)
920 : : {
921 : : int ret;
922 : :
923 : 3 : clk_prepare_lock();
924 : 3 : ret = clk_core_prepare(core);
925 : 3 : clk_prepare_unlock();
926 : :
927 : : return ret;
928 : : }
929 : :
930 : : /**
931 : : * clk_prepare - prepare a clock source
932 : : * @clk: the clk being prepared
933 : : *
934 : : * clk_prepare may sleep, which differentiates it from clk_enable. In a simple
935 : : * case, clk_prepare can be used instead of clk_enable to ungate a clk if the
936 : : * operation may sleep. One example is a clk which is accessed over I2c. In
937 : : * the complex case a clk ungate operation may require a fast and a slow part.
938 : : * It is this reason that clk_prepare and clk_enable are not mutually
939 : : * exclusive. In fact clk_prepare must be called before clk_enable.
940 : : * Returns 0 on success, -EERROR otherwise.
941 : : */
942 : 3 : int clk_prepare(struct clk *clk)
943 : : {
944 : 3 : if (!clk)
945 : : return 0;
946 : :
947 : 3 : return clk_core_prepare_lock(clk->core);
948 : : }
949 : : EXPORT_SYMBOL_GPL(clk_prepare);
950 : :
951 : 3 : static void clk_core_disable(struct clk_core *core)
952 : : {
953 : : lockdep_assert_held(&enable_lock);
954 : :
955 : 3 : if (!core)
956 : : return;
957 : :
958 : 3 : if (WARN(core->enable_count == 0, "%s already disabled\n", core->name))
959 : : return;
960 : :
961 : 3 : if (WARN(core->enable_count == 1 && core->flags & CLK_IS_CRITICAL,
962 : : "Disabling critical %s\n", core->name))
963 : : return;
964 : :
965 : 3 : if (--core->enable_count > 0)
966 : : return;
967 : :
968 : 3 : trace_clk_disable_rcuidle(core);
969 : :
970 : 3 : if (core->ops->disable)
971 : 0 : core->ops->disable(core->hw);
972 : :
973 : 3 : trace_clk_disable_complete_rcuidle(core);
974 : :
975 : 3 : clk_core_disable(core->parent);
976 : : }
977 : :
978 : 3 : static void clk_core_disable_lock(struct clk_core *core)
979 : : {
980 : : unsigned long flags;
981 : :
982 : 3 : flags = clk_enable_lock();
983 : 3 : clk_core_disable(core);
984 : 3 : clk_enable_unlock(flags);
985 : 3 : }
986 : :
987 : : /**
988 : : * clk_disable - gate a clock
989 : : * @clk: the clk being gated
990 : : *
991 : : * clk_disable must not sleep, which differentiates it from clk_unprepare. In
992 : : * a simple case, clk_disable can be used instead of clk_unprepare to gate a
993 : : * clk if the operation is fast and will never sleep. One example is a
994 : : * SoC-internal clk which is controlled via simple register writes. In the
995 : : * complex case a clk gate operation may require a fast and a slow part. It is
996 : : * this reason that clk_unprepare and clk_disable are not mutually exclusive.
997 : : * In fact clk_disable must be called before clk_unprepare.
998 : : */
999 : 3 : void clk_disable(struct clk *clk)
1000 : : {
1001 : 3 : if (IS_ERR_OR_NULL(clk))
1002 : 3 : return;
1003 : :
1004 : 3 : clk_core_disable_lock(clk->core);
1005 : : }
1006 : : EXPORT_SYMBOL_GPL(clk_disable);
1007 : :
1008 : 3 : static int clk_core_enable(struct clk_core *core)
1009 : : {
1010 : : int ret = 0;
1011 : :
1012 : : lockdep_assert_held(&enable_lock);
1013 : :
1014 : 3 : if (!core)
1015 : : return 0;
1016 : :
1017 : 3 : if (WARN(core->prepare_count == 0,
1018 : : "Enabling unprepared %s\n", core->name))
1019 : : return -ESHUTDOWN;
1020 : :
1021 : 3 : if (core->enable_count == 0) {
1022 : 3 : ret = clk_core_enable(core->parent);
1023 : :
1024 : 3 : if (ret)
1025 : : return ret;
1026 : :
1027 : 3 : trace_clk_enable_rcuidle(core);
1028 : :
1029 : 3 : if (core->ops->enable)
1030 : 0 : ret = core->ops->enable(core->hw);
1031 : :
1032 : 3 : trace_clk_enable_complete_rcuidle(core);
1033 : :
1034 : 3 : if (ret) {
1035 : 0 : clk_core_disable(core->parent);
1036 : 0 : return ret;
1037 : : }
1038 : : }
1039 : :
1040 : 3 : core->enable_count++;
1041 : 3 : return 0;
1042 : : }
1043 : :
1044 : 3 : static int clk_core_enable_lock(struct clk_core *core)
1045 : : {
1046 : : unsigned long flags;
1047 : : int ret;
1048 : :
1049 : 3 : flags = clk_enable_lock();
1050 : 3 : ret = clk_core_enable(core);
1051 : 3 : clk_enable_unlock(flags);
1052 : :
1053 : 3 : return ret;
1054 : : }
1055 : :
1056 : : /**
1057 : : * clk_gate_restore_context - restore context for poweroff
1058 : : * @hw: the clk_hw pointer of clock whose state is to be restored
1059 : : *
1060 : : * The clock gate restore context function enables or disables
1061 : : * the gate clocks based on the enable_count. This is done in cases
1062 : : * where the clock context is lost and based on the enable_count
1063 : : * the clock either needs to be enabled/disabled. This
1064 : : * helps restore the state of gate clocks.
1065 : : */
1066 : 0 : void clk_gate_restore_context(struct clk_hw *hw)
1067 : : {
1068 : 0 : struct clk_core *core = hw->core;
1069 : :
1070 : 0 : if (core->enable_count)
1071 : 0 : core->ops->enable(hw);
1072 : : else
1073 : 0 : core->ops->disable(hw);
1074 : 0 : }
1075 : : EXPORT_SYMBOL_GPL(clk_gate_restore_context);
1076 : :
1077 : 0 : static int clk_core_save_context(struct clk_core *core)
1078 : : {
1079 : : struct clk_core *child;
1080 : : int ret = 0;
1081 : :
1082 : 0 : hlist_for_each_entry(child, &core->children, child_node) {
1083 : 0 : ret = clk_core_save_context(child);
1084 : 0 : if (ret < 0)
1085 : 0 : return ret;
1086 : : }
1087 : :
1088 : 0 : if (core->ops && core->ops->save_context)
1089 : 0 : ret = core->ops->save_context(core->hw);
1090 : :
1091 : 0 : return ret;
1092 : : }
1093 : :
1094 : 0 : static void clk_core_restore_context(struct clk_core *core)
1095 : : {
1096 : : struct clk_core *child;
1097 : :
1098 : 0 : if (core->ops && core->ops->restore_context)
1099 : 0 : core->ops->restore_context(core->hw);
1100 : :
1101 : 0 : hlist_for_each_entry(child, &core->children, child_node)
1102 : 0 : clk_core_restore_context(child);
1103 : 0 : }
1104 : :
1105 : : /**
1106 : : * clk_save_context - save clock context for poweroff
1107 : : *
1108 : : * Saves the context of the clock register for powerstates in which the
1109 : : * contents of the registers will be lost. Occurs deep within the suspend
1110 : : * code. Returns 0 on success.
1111 : : */
1112 : 0 : int clk_save_context(void)
1113 : : {
1114 : : struct clk_core *clk;
1115 : : int ret;
1116 : :
1117 : 0 : hlist_for_each_entry(clk, &clk_root_list, child_node) {
1118 : 0 : ret = clk_core_save_context(clk);
1119 : 0 : if (ret < 0)
1120 : 0 : return ret;
1121 : : }
1122 : :
1123 : 0 : hlist_for_each_entry(clk, &clk_orphan_list, child_node) {
1124 : 0 : ret = clk_core_save_context(clk);
1125 : 0 : if (ret < 0)
1126 : 0 : return ret;
1127 : : }
1128 : :
1129 : : return 0;
1130 : : }
1131 : : EXPORT_SYMBOL_GPL(clk_save_context);
1132 : :
1133 : : /**
1134 : : * clk_restore_context - restore clock context after poweroff
1135 : : *
1136 : : * Restore the saved clock context upon resume.
1137 : : *
1138 : : */
1139 : 0 : void clk_restore_context(void)
1140 : : {
1141 : : struct clk_core *core;
1142 : :
1143 : 0 : hlist_for_each_entry(core, &clk_root_list, child_node)
1144 : 0 : clk_core_restore_context(core);
1145 : :
1146 : 0 : hlist_for_each_entry(core, &clk_orphan_list, child_node)
1147 : 0 : clk_core_restore_context(core);
1148 : 0 : }
1149 : : EXPORT_SYMBOL_GPL(clk_restore_context);
1150 : :
1151 : : /**
1152 : : * clk_enable - ungate a clock
1153 : : * @clk: the clk being ungated
1154 : : *
1155 : : * clk_enable must not sleep, which differentiates it from clk_prepare. In a
1156 : : * simple case, clk_enable can be used instead of clk_prepare to ungate a clk
1157 : : * if the operation will never sleep. One example is a SoC-internal clk which
1158 : : * is controlled via simple register writes. In the complex case a clk ungate
1159 : : * operation may require a fast and a slow part. It is this reason that
1160 : : * clk_enable and clk_prepare are not mutually exclusive. In fact clk_prepare
1161 : : * must be called before clk_enable. Returns 0 on success, -EERROR
1162 : : * otherwise.
1163 : : */
1164 : 3 : int clk_enable(struct clk *clk)
1165 : : {
1166 : 3 : if (!clk)
1167 : : return 0;
1168 : :
1169 : 3 : return clk_core_enable_lock(clk->core);
1170 : : }
1171 : : EXPORT_SYMBOL_GPL(clk_enable);
1172 : :
1173 : 0 : static int clk_core_prepare_enable(struct clk_core *core)
1174 : : {
1175 : : int ret;
1176 : :
1177 : : ret = clk_core_prepare_lock(core);
1178 : 0 : if (ret)
1179 : : return ret;
1180 : :
1181 : 0 : ret = clk_core_enable_lock(core);
1182 : 0 : if (ret)
1183 : : clk_core_unprepare_lock(core);
1184 : :
1185 : 0 : return ret;
1186 : : }
1187 : :
1188 : 0 : static void clk_core_disable_unprepare(struct clk_core *core)
1189 : : {
1190 : 0 : clk_core_disable_lock(core);
1191 : : clk_core_unprepare_lock(core);
1192 : 0 : }
1193 : :
1194 : 3 : static void clk_unprepare_unused_subtree(struct clk_core *core)
1195 : : {
1196 : : struct clk_core *child;
1197 : :
1198 : : lockdep_assert_held(&prepare_lock);
1199 : :
1200 : 3 : hlist_for_each_entry(child, &core->children, child_node)
1201 : 3 : clk_unprepare_unused_subtree(child);
1202 : :
1203 : 3 : if (core->prepare_count)
1204 : : return;
1205 : :
1206 : 3 : if (core->flags & CLK_IGNORE_UNUSED)
1207 : : return;
1208 : :
1209 : 3 : if (clk_pm_runtime_get(core))
1210 : : return;
1211 : :
1212 : 3 : if (clk_core_is_prepared(core)) {
1213 : 2 : trace_clk_unprepare(core);
1214 : 2 : if (core->ops->unprepare_unused)
1215 : 0 : core->ops->unprepare_unused(core->hw);
1216 : 2 : else if (core->ops->unprepare)
1217 : 0 : core->ops->unprepare(core->hw);
1218 : 2 : trace_clk_unprepare_complete(core);
1219 : : }
1220 : :
1221 : : clk_pm_runtime_put(core);
1222 : : }
1223 : :
1224 : 3 : static void clk_disable_unused_subtree(struct clk_core *core)
1225 : : {
1226 : : struct clk_core *child;
1227 : : unsigned long flags;
1228 : :
1229 : : lockdep_assert_held(&prepare_lock);
1230 : :
1231 : 3 : hlist_for_each_entry(child, &core->children, child_node)
1232 : 3 : clk_disable_unused_subtree(child);
1233 : :
1234 : 3 : if (core->flags & CLK_OPS_PARENT_ENABLE)
1235 : 0 : clk_core_prepare_enable(core->parent);
1236 : :
1237 : 3 : if (clk_pm_runtime_get(core))
1238 : : goto unprepare_out;
1239 : :
1240 : 3 : flags = clk_enable_lock();
1241 : :
1242 : 3 : if (core->enable_count)
1243 : : goto unlock_out;
1244 : :
1245 : 3 : if (core->flags & CLK_IGNORE_UNUSED)
1246 : : goto unlock_out;
1247 : :
1248 : : /*
1249 : : * some gate clocks have special needs during the disable-unused
1250 : : * sequence. call .disable_unused if available, otherwise fall
1251 : : * back to .disable
1252 : : */
1253 : 3 : if (clk_core_is_enabled(core)) {
1254 : 1 : trace_clk_disable(core);
1255 : 1 : if (core->ops->disable_unused)
1256 : 0 : core->ops->disable_unused(core->hw);
1257 : 1 : else if (core->ops->disable)
1258 : 1 : core->ops->disable(core->hw);
1259 : 1 : trace_clk_disable_complete(core);
1260 : : }
1261 : :
1262 : : unlock_out:
1263 : 3 : clk_enable_unlock(flags);
1264 : : clk_pm_runtime_put(core);
1265 : : unprepare_out:
1266 : 3 : if (core->flags & CLK_OPS_PARENT_ENABLE)
1267 : 0 : clk_core_disable_unprepare(core->parent);
1268 : 3 : }
1269 : :
1270 : : static bool clk_ignore_unused;
1271 : 0 : static int __init clk_ignore_unused_setup(char *__unused)
1272 : : {
1273 : 0 : clk_ignore_unused = true;
1274 : 0 : return 1;
1275 : : }
1276 : : __setup("clk_ignore_unused", clk_ignore_unused_setup);
1277 : :
1278 : 3 : static int clk_disable_unused(void)
1279 : : {
1280 : : struct clk_core *core;
1281 : :
1282 : 3 : if (clk_ignore_unused) {
1283 : 0 : pr_warn("clk: Not disabling unused clocks\n");
1284 : 0 : return 0;
1285 : : }
1286 : :
1287 : 3 : clk_prepare_lock();
1288 : :
1289 : 3 : hlist_for_each_entry(core, &clk_root_list, child_node)
1290 : 3 : clk_disable_unused_subtree(core);
1291 : :
1292 : 3 : hlist_for_each_entry(core, &clk_orphan_list, child_node)
1293 : 3 : clk_disable_unused_subtree(core);
1294 : :
1295 : 3 : hlist_for_each_entry(core, &clk_root_list, child_node)
1296 : 3 : clk_unprepare_unused_subtree(core);
1297 : :
1298 : 3 : hlist_for_each_entry(core, &clk_orphan_list, child_node)
1299 : 3 : clk_unprepare_unused_subtree(core);
1300 : :
1301 : 3 : clk_prepare_unlock();
1302 : :
1303 : 3 : return 0;
1304 : : }
1305 : : late_initcall_sync(clk_disable_unused);
1306 : :
1307 : 2 : static int clk_core_determine_round_nolock(struct clk_core *core,
1308 : : struct clk_rate_request *req)
1309 : : {
1310 : : long rate;
1311 : :
1312 : : lockdep_assert_held(&prepare_lock);
1313 : :
1314 : 2 : if (!core)
1315 : : return 0;
1316 : :
1317 : : /*
1318 : : * At this point, core protection will be disabled if
1319 : : * - if the provider is not protected at all
1320 : : * - if the calling consumer is the only one which has exclusivity
1321 : : * over the provider
1322 : : */
1323 : 2 : if (clk_core_rate_is_protected(core)) {
1324 : 0 : req->rate = core->rate;
1325 : 2 : } else if (core->ops->determine_rate) {
1326 : 2 : return core->ops->determine_rate(core->hw, req);
1327 : 0 : } else if (core->ops->round_rate) {
1328 : 0 : rate = core->ops->round_rate(core->hw, req->rate,
1329 : : &req->best_parent_rate);
1330 : 0 : if (rate < 0)
1331 : : return rate;
1332 : :
1333 : 0 : req->rate = rate;
1334 : : } else {
1335 : : return -EINVAL;
1336 : : }
1337 : :
1338 : : return 0;
1339 : : }
1340 : :
1341 : 2 : static void clk_core_init_rate_req(struct clk_core * const core,
1342 : : struct clk_rate_request *req)
1343 : : {
1344 : : struct clk_core *parent;
1345 : :
1346 : 2 : if (WARN_ON(!core || !req))
1347 : 2 : return;
1348 : :
1349 : 2 : parent = core->parent;
1350 : 2 : if (parent) {
1351 : 0 : req->best_parent_hw = parent->hw;
1352 : 0 : req->best_parent_rate = parent->rate;
1353 : : } else {
1354 : 2 : req->best_parent_hw = NULL;
1355 : 2 : req->best_parent_rate = 0;
1356 : : }
1357 : : }
1358 : :
1359 : : static bool clk_core_can_round(struct clk_core * const core)
1360 : : {
1361 : 2 : return core->ops->determine_rate || core->ops->round_rate;
1362 : : }
1363 : :
1364 : 2 : static int clk_core_round_rate_nolock(struct clk_core *core,
1365 : : struct clk_rate_request *req)
1366 : : {
1367 : : lockdep_assert_held(&prepare_lock);
1368 : :
1369 : 2 : if (!core) {
1370 : 0 : req->rate = 0;
1371 : 0 : return 0;
1372 : : }
1373 : :
1374 : 2 : clk_core_init_rate_req(core, req);
1375 : :
1376 : 2 : if (clk_core_can_round(core))
1377 : 2 : return clk_core_determine_round_nolock(core, req);
1378 : 0 : else if (core->flags & CLK_SET_RATE_PARENT)
1379 : 0 : return clk_core_round_rate_nolock(core->parent, req);
1380 : :
1381 : 0 : req->rate = core->rate;
1382 : 0 : return 0;
1383 : : }
1384 : :
1385 : : /**
1386 : : * __clk_determine_rate - get the closest rate actually supported by a clock
1387 : : * @hw: determine the rate of this clock
1388 : : * @req: target rate request
1389 : : *
1390 : : * Useful for clk_ops such as .set_rate and .determine_rate.
1391 : : */
1392 : 0 : int __clk_determine_rate(struct clk_hw *hw, struct clk_rate_request *req)
1393 : : {
1394 : 0 : if (!hw) {
1395 : 0 : req->rate = 0;
1396 : 0 : return 0;
1397 : : }
1398 : :
1399 : 0 : return clk_core_round_rate_nolock(hw->core, req);
1400 : : }
1401 : : EXPORT_SYMBOL_GPL(__clk_determine_rate);
1402 : :
1403 : 0 : unsigned long clk_hw_round_rate(struct clk_hw *hw, unsigned long rate)
1404 : : {
1405 : : int ret;
1406 : : struct clk_rate_request req;
1407 : :
1408 : 0 : clk_core_get_boundaries(hw->core, &req.min_rate, &req.max_rate);
1409 : 0 : req.rate = rate;
1410 : :
1411 : 0 : ret = clk_core_round_rate_nolock(hw->core, &req);
1412 : 0 : if (ret)
1413 : : return 0;
1414 : :
1415 : 0 : return req.rate;
1416 : : }
1417 : : EXPORT_SYMBOL_GPL(clk_hw_round_rate);
1418 : :
1419 : : /**
1420 : : * clk_round_rate - round the given rate for a clk
1421 : : * @clk: the clk for which we are rounding a rate
1422 : : * @rate: the rate which is to be rounded
1423 : : *
1424 : : * Takes in a rate as input and rounds it to a rate that the clk can actually
1425 : : * use which is then returned. If clk doesn't support round_rate operation
1426 : : * then the parent rate is returned.
1427 : : */
1428 : 2 : long clk_round_rate(struct clk *clk, unsigned long rate)
1429 : : {
1430 : : struct clk_rate_request req;
1431 : : int ret;
1432 : :
1433 : 2 : if (!clk)
1434 : : return 0;
1435 : :
1436 : 2 : clk_prepare_lock();
1437 : :
1438 : 2 : if (clk->exclusive_count)
1439 : 0 : clk_core_rate_unprotect(clk->core);
1440 : :
1441 : 2 : clk_core_get_boundaries(clk->core, &req.min_rate, &req.max_rate);
1442 : 2 : req.rate = rate;
1443 : :
1444 : 2 : ret = clk_core_round_rate_nolock(clk->core, &req);
1445 : :
1446 : 2 : if (clk->exclusive_count)
1447 : 0 : clk_core_rate_protect(clk->core);
1448 : :
1449 : 2 : clk_prepare_unlock();
1450 : :
1451 : 2 : if (ret)
1452 : : return ret;
1453 : :
1454 : 2 : return req.rate;
1455 : : }
1456 : : EXPORT_SYMBOL_GPL(clk_round_rate);
1457 : :
1458 : : /**
1459 : : * __clk_notify - call clk notifier chain
1460 : : * @core: clk that is changing rate
1461 : : * @msg: clk notifier type (see include/linux/clk.h)
1462 : : * @old_rate: old clk rate
1463 : : * @new_rate: new clk rate
1464 : : *
1465 : : * Triggers a notifier call chain on the clk rate-change notification
1466 : : * for 'clk'. Passes a pointer to the struct clk and the previous
1467 : : * and current rates to the notifier callback. Intended to be called by
1468 : : * internal clock code only. Returns NOTIFY_DONE from the last driver
1469 : : * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
1470 : : * a driver returns that.
1471 : : */
1472 : 0 : static int __clk_notify(struct clk_core *core, unsigned long msg,
1473 : : unsigned long old_rate, unsigned long new_rate)
1474 : : {
1475 : : struct clk_notifier *cn;
1476 : : struct clk_notifier_data cnd;
1477 : : int ret = NOTIFY_DONE;
1478 : :
1479 : 0 : cnd.old_rate = old_rate;
1480 : 0 : cnd.new_rate = new_rate;
1481 : :
1482 : 0 : list_for_each_entry(cn, &clk_notifier_list, node) {
1483 : 0 : if (cn->clk->core == core) {
1484 : 0 : cnd.clk = cn->clk;
1485 : 0 : ret = srcu_notifier_call_chain(&cn->notifier_head, msg,
1486 : : &cnd);
1487 : 0 : if (ret & NOTIFY_STOP_MASK)
1488 : 0 : return ret;
1489 : : }
1490 : : }
1491 : :
1492 : 0 : return ret;
1493 : : }
1494 : :
1495 : : /**
1496 : : * __clk_recalc_accuracies
1497 : : * @core: first clk in the subtree
1498 : : *
1499 : : * Walks the subtree of clks starting with clk and recalculates accuracies as
1500 : : * it goes. Note that if a clk does not implement the .recalc_accuracy
1501 : : * callback then it is assumed that the clock will take on the accuracy of its
1502 : : * parent.
1503 : : */
1504 : 0 : static void __clk_recalc_accuracies(struct clk_core *core)
1505 : : {
1506 : : unsigned long parent_accuracy = 0;
1507 : : struct clk_core *child;
1508 : :
1509 : : lockdep_assert_held(&prepare_lock);
1510 : :
1511 : 0 : if (core->parent)
1512 : 0 : parent_accuracy = core->parent->accuracy;
1513 : :
1514 : 0 : if (core->ops->recalc_accuracy)
1515 : 0 : core->accuracy = core->ops->recalc_accuracy(core->hw,
1516 : : parent_accuracy);
1517 : : else
1518 : 0 : core->accuracy = parent_accuracy;
1519 : :
1520 : 0 : hlist_for_each_entry(child, &core->children, child_node)
1521 : 0 : __clk_recalc_accuracies(child);
1522 : 0 : }
1523 : :
1524 : 0 : static long clk_core_get_accuracy(struct clk_core *core)
1525 : : {
1526 : : unsigned long accuracy;
1527 : :
1528 : 0 : clk_prepare_lock();
1529 : 0 : if (core && (core->flags & CLK_GET_ACCURACY_NOCACHE))
1530 : 0 : __clk_recalc_accuracies(core);
1531 : :
1532 : : accuracy = __clk_get_accuracy(core);
1533 : 0 : clk_prepare_unlock();
1534 : :
1535 : 0 : return accuracy;
1536 : : }
1537 : :
1538 : : /**
1539 : : * clk_get_accuracy - return the accuracy of clk
1540 : : * @clk: the clk whose accuracy is being returned
1541 : : *
1542 : : * Simply returns the cached accuracy of the clk, unless
1543 : : * CLK_GET_ACCURACY_NOCACHE flag is set, which means a recalc_rate will be
1544 : : * issued.
1545 : : * If clk is NULL then returns 0.
1546 : : */
1547 : 0 : long clk_get_accuracy(struct clk *clk)
1548 : : {
1549 : 0 : if (!clk)
1550 : : return 0;
1551 : :
1552 : 0 : return clk_core_get_accuracy(clk->core);
1553 : : }
1554 : : EXPORT_SYMBOL_GPL(clk_get_accuracy);
1555 : :
1556 : 2 : static unsigned long clk_recalc(struct clk_core *core,
1557 : : unsigned long parent_rate)
1558 : : {
1559 : : unsigned long rate = parent_rate;
1560 : :
1561 : 2 : if (core->ops->recalc_rate && !clk_pm_runtime_get(core)) {
1562 : 2 : rate = core->ops->recalc_rate(core->hw, parent_rate);
1563 : : clk_pm_runtime_put(core);
1564 : : }
1565 : 2 : return rate;
1566 : : }
1567 : :
1568 : : /**
1569 : : * __clk_recalc_rates
1570 : : * @core: first clk in the subtree
1571 : : * @msg: notification type (see include/linux/clk.h)
1572 : : *
1573 : : * Walks the subtree of clks starting with clk and recalculates rates as it
1574 : : * goes. Note that if a clk does not implement the .recalc_rate callback then
1575 : : * it is assumed that the clock will take on the rate of its parent.
1576 : : *
1577 : : * clk_recalc_rates also propagates the POST_RATE_CHANGE notification,
1578 : : * if necessary.
1579 : : */
1580 : 2 : static void __clk_recalc_rates(struct clk_core *core, unsigned long msg)
1581 : : {
1582 : : unsigned long old_rate;
1583 : : unsigned long parent_rate = 0;
1584 : : struct clk_core *child;
1585 : :
1586 : : lockdep_assert_held(&prepare_lock);
1587 : :
1588 : 2 : old_rate = core->rate;
1589 : :
1590 : 2 : if (core->parent)
1591 : 0 : parent_rate = core->parent->rate;
1592 : :
1593 : 2 : core->rate = clk_recalc(core, parent_rate);
1594 : :
1595 : : /*
1596 : : * ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE
1597 : : * & ABORT_RATE_CHANGE notifiers
1598 : : */
1599 : 2 : if (core->notifier_count && msg)
1600 : 0 : __clk_notify(core, msg, old_rate, core->rate);
1601 : :
1602 : 2 : hlist_for_each_entry(child, &core->children, child_node)
1603 : 0 : __clk_recalc_rates(child, msg);
1604 : 2 : }
1605 : :
1606 : 3 : static unsigned long clk_core_get_rate(struct clk_core *core)
1607 : : {
1608 : : unsigned long rate;
1609 : :
1610 : 3 : clk_prepare_lock();
1611 : :
1612 : 3 : if (core && (core->flags & CLK_GET_RATE_NOCACHE))
1613 : 2 : __clk_recalc_rates(core, 0);
1614 : :
1615 : : rate = clk_core_get_rate_nolock(core);
1616 : 3 : clk_prepare_unlock();
1617 : :
1618 : 3 : return rate;
1619 : : }
1620 : :
1621 : : /**
1622 : : * clk_get_rate - return the rate of clk
1623 : : * @clk: the clk whose rate is being returned
1624 : : *
1625 : : * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
1626 : : * is set, which means a recalc_rate will be issued.
1627 : : * If clk is NULL then returns 0.
1628 : : */
1629 : 3 : unsigned long clk_get_rate(struct clk *clk)
1630 : : {
1631 : 3 : if (!clk)
1632 : : return 0;
1633 : :
1634 : 3 : return clk_core_get_rate(clk->core);
1635 : : }
1636 : : EXPORT_SYMBOL_GPL(clk_get_rate);
1637 : :
1638 : 0 : static int clk_fetch_parent_index(struct clk_core *core,
1639 : : struct clk_core *parent)
1640 : : {
1641 : : int i;
1642 : :
1643 : 0 : if (!parent)
1644 : : return -EINVAL;
1645 : :
1646 : 0 : for (i = 0; i < core->num_parents; i++) {
1647 : : /* Found it first try! */
1648 : 0 : if (core->parents[i].core == parent)
1649 : 0 : return i;
1650 : :
1651 : : /* Something else is here, so keep looking */
1652 : 0 : if (core->parents[i].core)
1653 : 0 : continue;
1654 : :
1655 : : /* Maybe core hasn't been cached but the hw is all we know? */
1656 : 0 : if (core->parents[i].hw) {
1657 : 0 : if (core->parents[i].hw == parent->hw)
1658 : : break;
1659 : :
1660 : : /* Didn't match, but we're expecting a clk_hw */
1661 : 0 : continue;
1662 : : }
1663 : :
1664 : : /* Maybe it hasn't been cached (clk_set_parent() path) */
1665 : 0 : if (parent == clk_core_get(core, i))
1666 : : break;
1667 : :
1668 : : /* Fallback to comparing globally unique names */
1669 : 0 : if (core->parents[i].name &&
1670 : 0 : !strcmp(parent->name, core->parents[i].name))
1671 : : break;
1672 : : }
1673 : :
1674 : 0 : if (i == core->num_parents)
1675 : : return -EINVAL;
1676 : :
1677 : 0 : core->parents[i].core = parent;
1678 : 0 : return i;
1679 : : }
1680 : :
1681 : : /*
1682 : : * Update the orphan status of @core and all its children.
1683 : : */
1684 : 0 : static void clk_core_update_orphan_status(struct clk_core *core, bool is_orphan)
1685 : : {
1686 : : struct clk_core *child;
1687 : :
1688 : 0 : core->orphan = is_orphan;
1689 : :
1690 : 0 : hlist_for_each_entry(child, &core->children, child_node)
1691 : 0 : clk_core_update_orphan_status(child, is_orphan);
1692 : 0 : }
1693 : :
1694 : 0 : static void clk_reparent(struct clk_core *core, struct clk_core *new_parent)
1695 : : {
1696 : 0 : bool was_orphan = core->orphan;
1697 : :
1698 : : hlist_del(&core->child_node);
1699 : :
1700 : 0 : if (new_parent) {
1701 : 0 : bool becomes_orphan = new_parent->orphan;
1702 : :
1703 : : /* avoid duplicate POST_RATE_CHANGE notifications */
1704 : 0 : if (new_parent->new_child == core)
1705 : 0 : new_parent->new_child = NULL;
1706 : :
1707 : 0 : hlist_add_head(&core->child_node, &new_parent->children);
1708 : :
1709 : 0 : if (was_orphan != becomes_orphan)
1710 : 0 : clk_core_update_orphan_status(core, becomes_orphan);
1711 : : } else {
1712 : 0 : hlist_add_head(&core->child_node, &clk_orphan_list);
1713 : 0 : if (!was_orphan)
1714 : 0 : clk_core_update_orphan_status(core, true);
1715 : : }
1716 : :
1717 : 0 : core->parent = new_parent;
1718 : 0 : }
1719 : :
1720 : 0 : static struct clk_core *__clk_set_parent_before(struct clk_core *core,
1721 : : struct clk_core *parent)
1722 : : {
1723 : : unsigned long flags;
1724 : 0 : struct clk_core *old_parent = core->parent;
1725 : :
1726 : : /*
1727 : : * 1. enable parents for CLK_OPS_PARENT_ENABLE clock
1728 : : *
1729 : : * 2. Migrate prepare state between parents and prevent race with
1730 : : * clk_enable().
1731 : : *
1732 : : * If the clock is not prepared, then a race with
1733 : : * clk_enable/disable() is impossible since we already have the
1734 : : * prepare lock (future calls to clk_enable() need to be preceded by
1735 : : * a clk_prepare()).
1736 : : *
1737 : : * If the clock is prepared, migrate the prepared state to the new
1738 : : * parent and also protect against a race with clk_enable() by
1739 : : * forcing the clock and the new parent on. This ensures that all
1740 : : * future calls to clk_enable() are practically NOPs with respect to
1741 : : * hardware and software states.
1742 : : *
1743 : : * See also: Comment for clk_set_parent() below.
1744 : : */
1745 : :
1746 : : /* enable old_parent & parent if CLK_OPS_PARENT_ENABLE is set */
1747 : 0 : if (core->flags & CLK_OPS_PARENT_ENABLE) {
1748 : 0 : clk_core_prepare_enable(old_parent);
1749 : 0 : clk_core_prepare_enable(parent);
1750 : : }
1751 : :
1752 : : /* migrate prepare count if > 0 */
1753 : 0 : if (core->prepare_count) {
1754 : 0 : clk_core_prepare_enable(parent);
1755 : 0 : clk_core_enable_lock(core);
1756 : : }
1757 : :
1758 : : /* update the clk tree topology */
1759 : 0 : flags = clk_enable_lock();
1760 : 0 : clk_reparent(core, parent);
1761 : 0 : clk_enable_unlock(flags);
1762 : :
1763 : 0 : return old_parent;
1764 : : }
1765 : :
1766 : 0 : static void __clk_set_parent_after(struct clk_core *core,
1767 : : struct clk_core *parent,
1768 : : struct clk_core *old_parent)
1769 : : {
1770 : : /*
1771 : : * Finish the migration of prepare state and undo the changes done
1772 : : * for preventing a race with clk_enable().
1773 : : */
1774 : 0 : if (core->prepare_count) {
1775 : 0 : clk_core_disable_lock(core);
1776 : 0 : clk_core_disable_unprepare(old_parent);
1777 : : }
1778 : :
1779 : : /* re-balance ref counting if CLK_OPS_PARENT_ENABLE is set */
1780 : 0 : if (core->flags & CLK_OPS_PARENT_ENABLE) {
1781 : 0 : clk_core_disable_unprepare(parent);
1782 : 0 : clk_core_disable_unprepare(old_parent);
1783 : : }
1784 : 0 : }
1785 : :
1786 : 0 : static int __clk_set_parent(struct clk_core *core, struct clk_core *parent,
1787 : : u8 p_index)
1788 : : {
1789 : : unsigned long flags;
1790 : : int ret = 0;
1791 : : struct clk_core *old_parent;
1792 : :
1793 : 0 : old_parent = __clk_set_parent_before(core, parent);
1794 : :
1795 : 0 : trace_clk_set_parent(core, parent);
1796 : :
1797 : : /* change clock input source */
1798 : 0 : if (parent && core->ops->set_parent)
1799 : 0 : ret = core->ops->set_parent(core->hw, p_index);
1800 : :
1801 : 0 : trace_clk_set_parent_complete(core, parent);
1802 : :
1803 : 0 : if (ret) {
1804 : 0 : flags = clk_enable_lock();
1805 : 0 : clk_reparent(core, old_parent);
1806 : 0 : clk_enable_unlock(flags);
1807 : 0 : __clk_set_parent_after(core, old_parent, parent);
1808 : :
1809 : 0 : return ret;
1810 : : }
1811 : :
1812 : 0 : __clk_set_parent_after(core, parent, old_parent);
1813 : :
1814 : 0 : return 0;
1815 : : }
1816 : :
1817 : : /**
1818 : : * __clk_speculate_rates
1819 : : * @core: first clk in the subtree
1820 : : * @parent_rate: the "future" rate of clk's parent
1821 : : *
1822 : : * Walks the subtree of clks starting with clk, speculating rates as it
1823 : : * goes and firing off PRE_RATE_CHANGE notifications as necessary.
1824 : : *
1825 : : * Unlike clk_recalc_rates, clk_speculate_rates exists only for sending
1826 : : * pre-rate change notifications and returns early if no clks in the
1827 : : * subtree have subscribed to the notifications. Note that if a clk does not
1828 : : * implement the .recalc_rate callback then it is assumed that the clock will
1829 : : * take on the rate of its parent.
1830 : : */
1831 : 0 : static int __clk_speculate_rates(struct clk_core *core,
1832 : : unsigned long parent_rate)
1833 : : {
1834 : : struct clk_core *child;
1835 : : unsigned long new_rate;
1836 : : int ret = NOTIFY_DONE;
1837 : :
1838 : : lockdep_assert_held(&prepare_lock);
1839 : :
1840 : 0 : new_rate = clk_recalc(core, parent_rate);
1841 : :
1842 : : /* abort rate change if a driver returns NOTIFY_BAD or NOTIFY_STOP */
1843 : 0 : if (core->notifier_count)
1844 : 0 : ret = __clk_notify(core, PRE_RATE_CHANGE, core->rate, new_rate);
1845 : :
1846 : 0 : if (ret & NOTIFY_STOP_MASK) {
1847 : : pr_debug("%s: clk notifier callback for clock %s aborted with error %d\n",
1848 : : __func__, core->name, ret);
1849 : : goto out;
1850 : : }
1851 : :
1852 : 0 : hlist_for_each_entry(child, &core->children, child_node) {
1853 : 0 : ret = __clk_speculate_rates(child, new_rate);
1854 : 0 : if (ret & NOTIFY_STOP_MASK)
1855 : : break;
1856 : : }
1857 : :
1858 : : out:
1859 : 0 : return ret;
1860 : : }
1861 : :
1862 : 2 : static void clk_calc_subtree(struct clk_core *core, unsigned long new_rate,
1863 : : struct clk_core *new_parent, u8 p_index)
1864 : : {
1865 : : struct clk_core *child;
1866 : :
1867 : 2 : core->new_rate = new_rate;
1868 : 2 : core->new_parent = new_parent;
1869 : 2 : core->new_parent_index = p_index;
1870 : : /* include clk in new parent's PRE_RATE_CHANGE notifications */
1871 : 2 : core->new_child = NULL;
1872 : 2 : if (new_parent && new_parent != core->parent)
1873 : 0 : new_parent->new_child = core;
1874 : :
1875 : 2 : hlist_for_each_entry(child, &core->children, child_node) {
1876 : 0 : child->new_rate = clk_recalc(child, new_rate);
1877 : 0 : clk_calc_subtree(child, child->new_rate, NULL, 0);
1878 : : }
1879 : 2 : }
1880 : :
1881 : : /*
1882 : : * calculate the new rates returning the topmost clock that has to be
1883 : : * changed.
1884 : : */
1885 : 2 : static struct clk_core *clk_calc_new_rates(struct clk_core *core,
1886 : : unsigned long rate)
1887 : : {
1888 : : struct clk_core *top = core;
1889 : : struct clk_core *old_parent, *parent;
1890 : : unsigned long best_parent_rate = 0;
1891 : : unsigned long new_rate;
1892 : : unsigned long min_rate;
1893 : : unsigned long max_rate;
1894 : : int p_index = 0;
1895 : : long ret;
1896 : :
1897 : : /* sanity */
1898 : 2 : if (IS_ERR_OR_NULL(core))
1899 : : return NULL;
1900 : :
1901 : : /* save parent rate, if it exists */
1902 : 2 : parent = old_parent = core->parent;
1903 : : if (parent)
1904 : : best_parent_rate = parent->rate;
1905 : :
1906 : 2 : clk_core_get_boundaries(core, &min_rate, &max_rate);
1907 : :
1908 : : /* find the closest rate and parent clk/rate */
1909 : 2 : if (clk_core_can_round(core)) {
1910 : : struct clk_rate_request req;
1911 : :
1912 : 2 : req.rate = rate;
1913 : 2 : req.min_rate = min_rate;
1914 : 2 : req.max_rate = max_rate;
1915 : :
1916 : 2 : clk_core_init_rate_req(core, &req);
1917 : :
1918 : 2 : ret = clk_core_determine_round_nolock(core, &req);
1919 : 2 : if (ret < 0)
1920 : 0 : return NULL;
1921 : :
1922 : 2 : best_parent_rate = req.best_parent_rate;
1923 : 2 : new_rate = req.rate;
1924 : 2 : parent = req.best_parent_hw ? req.best_parent_hw->core : NULL;
1925 : :
1926 : 2 : if (new_rate < min_rate || new_rate > max_rate)
1927 : : return NULL;
1928 : 0 : } else if (!parent || !(core->flags & CLK_SET_RATE_PARENT)) {
1929 : : /* pass-through clock without adjustable parent */
1930 : 0 : core->new_rate = core->rate;
1931 : 0 : return NULL;
1932 : : } else {
1933 : : /* pass-through clock with adjustable parent */
1934 : 0 : top = clk_calc_new_rates(parent, rate);
1935 : 0 : new_rate = parent->new_rate;
1936 : 0 : goto out;
1937 : : }
1938 : :
1939 : : /* some clocks must be gated to change parent */
1940 : 2 : if (parent != old_parent &&
1941 : 0 : (core->flags & CLK_SET_PARENT_GATE) && core->prepare_count) {
1942 : : pr_debug("%s: %s not gated but wants to reparent\n",
1943 : : __func__, core->name);
1944 : : return NULL;
1945 : : }
1946 : :
1947 : : /* try finding the new parent index */
1948 : 2 : if (parent && core->num_parents > 1) {
1949 : 0 : p_index = clk_fetch_parent_index(core, parent);
1950 : 0 : if (p_index < 0) {
1951 : : pr_debug("%s: clk %s can not be parent of clk %s\n",
1952 : : __func__, parent->name, core->name);
1953 : : return NULL;
1954 : : }
1955 : : }
1956 : :
1957 : 2 : if ((core->flags & CLK_SET_RATE_PARENT) && parent &&
1958 : 0 : best_parent_rate != parent->rate)
1959 : 0 : top = clk_calc_new_rates(parent, best_parent_rate);
1960 : :
1961 : : out:
1962 : 2 : clk_calc_subtree(core, new_rate, parent, p_index);
1963 : :
1964 : 2 : return top;
1965 : : }
1966 : :
1967 : : /*
1968 : : * Notify about rate changes in a subtree. Always walk down the whole tree
1969 : : * so that in case of an error we can walk down the whole tree again and
1970 : : * abort the change.
1971 : : */
1972 : 2 : static struct clk_core *clk_propagate_rate_change(struct clk_core *core,
1973 : : unsigned long event)
1974 : : {
1975 : : struct clk_core *child, *tmp_clk, *fail_clk = NULL;
1976 : : int ret = NOTIFY_DONE;
1977 : :
1978 : 2 : if (core->rate == core->new_rate)
1979 : : return NULL;
1980 : :
1981 : 2 : if (core->notifier_count) {
1982 : 0 : ret = __clk_notify(core, event, core->rate, core->new_rate);
1983 : 0 : if (ret & NOTIFY_STOP_MASK)
1984 : : fail_clk = core;
1985 : : }
1986 : :
1987 : 2 : hlist_for_each_entry(child, &core->children, child_node) {
1988 : : /* Skip children who will be reparented to another clock */
1989 : 0 : if (child->new_parent && child->new_parent != core)
1990 : 0 : continue;
1991 : 0 : tmp_clk = clk_propagate_rate_change(child, event);
1992 : 0 : if (tmp_clk)
1993 : : fail_clk = tmp_clk;
1994 : : }
1995 : :
1996 : : /* handle the new child who might not be in core->children yet */
1997 : 2 : if (core->new_child) {
1998 : 0 : tmp_clk = clk_propagate_rate_change(core->new_child, event);
1999 : 0 : if (tmp_clk)
2000 : : fail_clk = tmp_clk;
2001 : : }
2002 : :
2003 : 2 : return fail_clk;
2004 : : }
2005 : :
2006 : : /*
2007 : : * walk down a subtree and set the new rates notifying the rate
2008 : : * change on the way
2009 : : */
2010 : 2 : static void clk_change_rate(struct clk_core *core)
2011 : : {
2012 : : struct clk_core *child;
2013 : : struct hlist_node *tmp;
2014 : : unsigned long old_rate;
2015 : : unsigned long best_parent_rate = 0;
2016 : : bool skip_set_rate = false;
2017 : : struct clk_core *old_parent;
2018 : : struct clk_core *parent = NULL;
2019 : :
2020 : 2 : old_rate = core->rate;
2021 : :
2022 : 2 : if (core->new_parent) {
2023 : : parent = core->new_parent;
2024 : 0 : best_parent_rate = core->new_parent->rate;
2025 : 2 : } else if (core->parent) {
2026 : : parent = core->parent;
2027 : 0 : best_parent_rate = core->parent->rate;
2028 : : }
2029 : :
2030 : 2 : if (clk_pm_runtime_get(core))
2031 : 2 : return;
2032 : :
2033 : 2 : if (core->flags & CLK_SET_RATE_UNGATE) {
2034 : : unsigned long flags;
2035 : :
2036 : 0 : clk_core_prepare(core);
2037 : 0 : flags = clk_enable_lock();
2038 : 0 : clk_core_enable(core);
2039 : 0 : clk_enable_unlock(flags);
2040 : : }
2041 : :
2042 : 2 : if (core->new_parent && core->new_parent != core->parent) {
2043 : 0 : old_parent = __clk_set_parent_before(core, core->new_parent);
2044 : 0 : trace_clk_set_parent(core, core->new_parent);
2045 : :
2046 : 0 : if (core->ops->set_rate_and_parent) {
2047 : : skip_set_rate = true;
2048 : 0 : core->ops->set_rate_and_parent(core->hw, core->new_rate,
2049 : : best_parent_rate,
2050 : : core->new_parent_index);
2051 : 0 : } else if (core->ops->set_parent) {
2052 : 0 : core->ops->set_parent(core->hw, core->new_parent_index);
2053 : : }
2054 : :
2055 : 0 : trace_clk_set_parent_complete(core, core->new_parent);
2056 : 0 : __clk_set_parent_after(core, core->new_parent, old_parent);
2057 : : }
2058 : :
2059 : 2 : if (core->flags & CLK_OPS_PARENT_ENABLE)
2060 : 0 : clk_core_prepare_enable(parent);
2061 : :
2062 : 2 : trace_clk_set_rate(core, core->new_rate);
2063 : :
2064 : 2 : if (!skip_set_rate && core->ops->set_rate)
2065 : 2 : core->ops->set_rate(core->hw, core->new_rate, best_parent_rate);
2066 : :
2067 : 2 : trace_clk_set_rate_complete(core, core->new_rate);
2068 : :
2069 : 2 : core->rate = clk_recalc(core, best_parent_rate);
2070 : :
2071 : 2 : if (core->flags & CLK_SET_RATE_UNGATE) {
2072 : : unsigned long flags;
2073 : :
2074 : 0 : flags = clk_enable_lock();
2075 : 0 : clk_core_disable(core);
2076 : 0 : clk_enable_unlock(flags);
2077 : 0 : clk_core_unprepare(core);
2078 : : }
2079 : :
2080 : 2 : if (core->flags & CLK_OPS_PARENT_ENABLE)
2081 : 0 : clk_core_disable_unprepare(parent);
2082 : :
2083 : 2 : if (core->notifier_count && old_rate != core->rate)
2084 : 0 : __clk_notify(core, POST_RATE_CHANGE, old_rate, core->rate);
2085 : :
2086 : 2 : if (core->flags & CLK_RECALC_NEW_RATES)
2087 : 0 : (void)clk_calc_new_rates(core, core->new_rate);
2088 : :
2089 : : /*
2090 : : * Use safe iteration, as change_rate can actually swap parents
2091 : : * for certain clock types.
2092 : : */
2093 : 2 : hlist_for_each_entry_safe(child, tmp, &core->children, child_node) {
2094 : : /* Skip children who will be reparented to another clock */
2095 : 0 : if (child->new_parent && child->new_parent != core)
2096 : 0 : continue;
2097 : 0 : clk_change_rate(child);
2098 : : }
2099 : :
2100 : : /* handle the new child who might not be in core->children yet */
2101 : 2 : if (core->new_child)
2102 : 0 : clk_change_rate(core->new_child);
2103 : :
2104 : : clk_pm_runtime_put(core);
2105 : : }
2106 : :
2107 : 2 : static unsigned long clk_core_req_round_rate_nolock(struct clk_core *core,
2108 : : unsigned long req_rate)
2109 : : {
2110 : : int ret, cnt;
2111 : : struct clk_rate_request req;
2112 : :
2113 : : lockdep_assert_held(&prepare_lock);
2114 : :
2115 : 2 : if (!core)
2116 : : return 0;
2117 : :
2118 : : /* simulate what the rate would be if it could be freely set */
2119 : : cnt = clk_core_rate_nuke_protect(core);
2120 : 2 : if (cnt < 0)
2121 : 0 : return cnt;
2122 : :
2123 : 2 : clk_core_get_boundaries(core, &req.min_rate, &req.max_rate);
2124 : 2 : req.rate = req_rate;
2125 : :
2126 : 2 : ret = clk_core_round_rate_nolock(core, &req);
2127 : :
2128 : : /* restore the protection */
2129 : : clk_core_rate_restore_protect(core, cnt);
2130 : :
2131 : 2 : return ret ? 0 : req.rate;
2132 : : }
2133 : :
2134 : 2 : static int clk_core_set_rate_nolock(struct clk_core *core,
2135 : : unsigned long req_rate)
2136 : : {
2137 : : struct clk_core *top, *fail_clk;
2138 : : unsigned long rate;
2139 : : int ret = 0;
2140 : :
2141 : 2 : if (!core)
2142 : : return 0;
2143 : :
2144 : 2 : rate = clk_core_req_round_rate_nolock(core, req_rate);
2145 : :
2146 : : /* bail early if nothing to do */
2147 : 2 : if (rate == clk_core_get_rate_nolock(core))
2148 : : return 0;
2149 : :
2150 : : /* fail on a direct rate set of a protected provider */
2151 : 2 : if (clk_core_rate_is_protected(core))
2152 : : return -EBUSY;
2153 : :
2154 : : /* calculate new rates and get the topmost changed clock */
2155 : 2 : top = clk_calc_new_rates(core, req_rate);
2156 : 2 : if (!top)
2157 : : return -EINVAL;
2158 : :
2159 : 2 : ret = clk_pm_runtime_get(core);
2160 : 2 : if (ret)
2161 : : return ret;
2162 : :
2163 : : /* notify that we are about to change rates */
2164 : 2 : fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
2165 : 2 : if (fail_clk) {
2166 : : pr_debug("%s: failed to set %s rate\n", __func__,
2167 : : fail_clk->name);
2168 : 0 : clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
2169 : : ret = -EBUSY;
2170 : 0 : goto err;
2171 : : }
2172 : :
2173 : : /* change the rates */
2174 : 2 : clk_change_rate(top);
2175 : :
2176 : 2 : core->req_rate = req_rate;
2177 : : err:
2178 : : clk_pm_runtime_put(core);
2179 : :
2180 : 2 : return ret;
2181 : : }
2182 : :
2183 : : /**
2184 : : * clk_set_rate - specify a new rate for clk
2185 : : * @clk: the clk whose rate is being changed
2186 : : * @rate: the new rate for clk
2187 : : *
2188 : : * In the simplest case clk_set_rate will only adjust the rate of clk.
2189 : : *
2190 : : * Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to
2191 : : * propagate up to clk's parent; whether or not this happens depends on the
2192 : : * outcome of clk's .round_rate implementation. If *parent_rate is unchanged
2193 : : * after calling .round_rate then upstream parent propagation is ignored. If
2194 : : * *parent_rate comes back with a new rate for clk's parent then we propagate
2195 : : * up to clk's parent and set its rate. Upward propagation will continue
2196 : : * until either a clk does not support the CLK_SET_RATE_PARENT flag or
2197 : : * .round_rate stops requesting changes to clk's parent_rate.
2198 : : *
2199 : : * Rate changes are accomplished via tree traversal that also recalculates the
2200 : : * rates for the clocks and fires off POST_RATE_CHANGE notifiers.
2201 : : *
2202 : : * Returns 0 on success, -EERROR otherwise.
2203 : : */
2204 : 2 : int clk_set_rate(struct clk *clk, unsigned long rate)
2205 : : {
2206 : : int ret;
2207 : :
2208 : 2 : if (!clk)
2209 : : return 0;
2210 : :
2211 : : /* prevent racing with updates to the clock topology */
2212 : 2 : clk_prepare_lock();
2213 : :
2214 : 2 : if (clk->exclusive_count)
2215 : 0 : clk_core_rate_unprotect(clk->core);
2216 : :
2217 : 2 : ret = clk_core_set_rate_nolock(clk->core, rate);
2218 : :
2219 : 2 : if (clk->exclusive_count)
2220 : 0 : clk_core_rate_protect(clk->core);
2221 : :
2222 : 2 : clk_prepare_unlock();
2223 : :
2224 : 2 : return ret;
2225 : : }
2226 : : EXPORT_SYMBOL_GPL(clk_set_rate);
2227 : :
2228 : : /**
2229 : : * clk_set_rate_exclusive - specify a new rate and get exclusive control
2230 : : * @clk: the clk whose rate is being changed
2231 : : * @rate: the new rate for clk
2232 : : *
2233 : : * This is a combination of clk_set_rate() and clk_rate_exclusive_get()
2234 : : * within a critical section
2235 : : *
2236 : : * This can be used initially to ensure that at least 1 consumer is
2237 : : * satisfied when several consumers are competing for exclusivity over the
2238 : : * same clock provider.
2239 : : *
2240 : : * The exclusivity is not applied if setting the rate failed.
2241 : : *
2242 : : * Calls to clk_rate_exclusive_get() should be balanced with calls to
2243 : : * clk_rate_exclusive_put().
2244 : : *
2245 : : * Returns 0 on success, -EERROR otherwise.
2246 : : */
2247 : 0 : int clk_set_rate_exclusive(struct clk *clk, unsigned long rate)
2248 : : {
2249 : : int ret;
2250 : :
2251 : 0 : if (!clk)
2252 : : return 0;
2253 : :
2254 : : /* prevent racing with updates to the clock topology */
2255 : 0 : clk_prepare_lock();
2256 : :
2257 : : /*
2258 : : * The temporary protection removal is not here, on purpose
2259 : : * This function is meant to be used instead of clk_rate_protect,
2260 : : * so before the consumer code path protect the clock provider
2261 : : */
2262 : :
2263 : 0 : ret = clk_core_set_rate_nolock(clk->core, rate);
2264 : 0 : if (!ret) {
2265 : 0 : clk_core_rate_protect(clk->core);
2266 : 0 : clk->exclusive_count++;
2267 : : }
2268 : :
2269 : 0 : clk_prepare_unlock();
2270 : :
2271 : 0 : return ret;
2272 : : }
2273 : : EXPORT_SYMBOL_GPL(clk_set_rate_exclusive);
2274 : :
2275 : : /**
2276 : : * clk_set_rate_range - set a rate range for a clock source
2277 : : * @clk: clock source
2278 : : * @min: desired minimum clock rate in Hz, inclusive
2279 : : * @max: desired maximum clock rate in Hz, inclusive
2280 : : *
2281 : : * Returns success (0) or negative errno.
2282 : : */
2283 : 0 : int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max)
2284 : : {
2285 : : int ret = 0;
2286 : : unsigned long old_min, old_max, rate;
2287 : :
2288 : 0 : if (!clk)
2289 : : return 0;
2290 : :
2291 : 0 : if (min > max) {
2292 : 0 : pr_err("%s: clk %s dev %s con %s: invalid range [%lu, %lu]\n",
2293 : : __func__, clk->core->name, clk->dev_id, clk->con_id,
2294 : : min, max);
2295 : 0 : return -EINVAL;
2296 : : }
2297 : :
2298 : 0 : clk_prepare_lock();
2299 : :
2300 : 0 : if (clk->exclusive_count)
2301 : 0 : clk_core_rate_unprotect(clk->core);
2302 : :
2303 : : /* Save the current values in case we need to rollback the change */
2304 : 0 : old_min = clk->min_rate;
2305 : 0 : old_max = clk->max_rate;
2306 : 0 : clk->min_rate = min;
2307 : 0 : clk->max_rate = max;
2308 : :
2309 : 0 : rate = clk_core_get_rate_nolock(clk->core);
2310 : 0 : if (rate < min || rate > max) {
2311 : : /*
2312 : : * FIXME:
2313 : : * We are in bit of trouble here, current rate is outside the
2314 : : * the requested range. We are going try to request appropriate
2315 : : * range boundary but there is a catch. It may fail for the
2316 : : * usual reason (clock broken, clock protected, etc) but also
2317 : : * because:
2318 : : * - round_rate() was not favorable and fell on the wrong
2319 : : * side of the boundary
2320 : : * - the determine_rate() callback does not really check for
2321 : : * this corner case when determining the rate
2322 : : */
2323 : :
2324 : 0 : if (rate < min)
2325 : : rate = min;
2326 : : else
2327 : : rate = max;
2328 : :
2329 : 0 : ret = clk_core_set_rate_nolock(clk->core, rate);
2330 : 0 : if (ret) {
2331 : : /* rollback the changes */
2332 : 0 : clk->min_rate = old_min;
2333 : 0 : clk->max_rate = old_max;
2334 : : }
2335 : : }
2336 : :
2337 : 0 : if (clk->exclusive_count)
2338 : 0 : clk_core_rate_protect(clk->core);
2339 : :
2340 : 0 : clk_prepare_unlock();
2341 : :
2342 : 0 : return ret;
2343 : : }
2344 : : EXPORT_SYMBOL_GPL(clk_set_rate_range);
2345 : :
2346 : : /**
2347 : : * clk_set_min_rate - set a minimum clock rate for a clock source
2348 : : * @clk: clock source
2349 : : * @rate: desired minimum clock rate in Hz, inclusive
2350 : : *
2351 : : * Returns success (0) or negative errno.
2352 : : */
2353 : 0 : int clk_set_min_rate(struct clk *clk, unsigned long rate)
2354 : : {
2355 : 0 : if (!clk)
2356 : : return 0;
2357 : :
2358 : 0 : return clk_set_rate_range(clk, rate, clk->max_rate);
2359 : : }
2360 : : EXPORT_SYMBOL_GPL(clk_set_min_rate);
2361 : :
2362 : : /**
2363 : : * clk_set_max_rate - set a maximum clock rate for a clock source
2364 : : * @clk: clock source
2365 : : * @rate: desired maximum clock rate in Hz, inclusive
2366 : : *
2367 : : * Returns success (0) or negative errno.
2368 : : */
2369 : 0 : int clk_set_max_rate(struct clk *clk, unsigned long rate)
2370 : : {
2371 : 0 : if (!clk)
2372 : : return 0;
2373 : :
2374 : 0 : return clk_set_rate_range(clk, clk->min_rate, rate);
2375 : : }
2376 : : EXPORT_SYMBOL_GPL(clk_set_max_rate);
2377 : :
2378 : : /**
2379 : : * clk_get_parent - return the parent of a clk
2380 : : * @clk: the clk whose parent gets returned
2381 : : *
2382 : : * Simply returns clk->parent. Returns NULL if clk is NULL.
2383 : : */
2384 : 3 : struct clk *clk_get_parent(struct clk *clk)
2385 : : {
2386 : : struct clk *parent;
2387 : :
2388 : 3 : if (!clk)
2389 : : return NULL;
2390 : :
2391 : 3 : clk_prepare_lock();
2392 : : /* TODO: Create a per-user clk and change callers to call clk_put */
2393 : 3 : parent = !clk->core->parent ? NULL : clk->core->parent->hw->clk;
2394 : 3 : clk_prepare_unlock();
2395 : :
2396 : 3 : return parent;
2397 : : }
2398 : : EXPORT_SYMBOL_GPL(clk_get_parent);
2399 : :
2400 : 3 : static struct clk_core *__clk_init_parent(struct clk_core *core)
2401 : : {
2402 : : u8 index = 0;
2403 : :
2404 : 3 : if (core->num_parents > 1 && core->ops->get_parent)
2405 : 3 : index = core->ops->get_parent(core->hw);
2406 : :
2407 : 3 : return clk_core_get_parent_by_index(core, index);
2408 : : }
2409 : :
2410 : 0 : static void clk_core_reparent(struct clk_core *core,
2411 : : struct clk_core *new_parent)
2412 : : {
2413 : 0 : clk_reparent(core, new_parent);
2414 : 0 : __clk_recalc_accuracies(core);
2415 : 0 : __clk_recalc_rates(core, POST_RATE_CHANGE);
2416 : 0 : }
2417 : :
2418 : 0 : void clk_hw_reparent(struct clk_hw *hw, struct clk_hw *new_parent)
2419 : : {
2420 : 0 : if (!hw)
2421 : 0 : return;
2422 : :
2423 : 0 : clk_core_reparent(hw->core, !new_parent ? NULL : new_parent->core);
2424 : : }
2425 : :
2426 : : /**
2427 : : * clk_has_parent - check if a clock is a possible parent for another
2428 : : * @clk: clock source
2429 : : * @parent: parent clock source
2430 : : *
2431 : : * This function can be used in drivers that need to check that a clock can be
2432 : : * the parent of another without actually changing the parent.
2433 : : *
2434 : : * Returns true if @parent is a possible parent for @clk, false otherwise.
2435 : : */
2436 : 0 : bool clk_has_parent(struct clk *clk, struct clk *parent)
2437 : : {
2438 : : struct clk_core *core, *parent_core;
2439 : : int i;
2440 : :
2441 : : /* NULL clocks should be nops, so return success if either is NULL. */
2442 : 0 : if (!clk || !parent)
2443 : : return true;
2444 : :
2445 : 0 : core = clk->core;
2446 : 0 : parent_core = parent->core;
2447 : :
2448 : : /* Optimize for the case where the parent is already the parent. */
2449 : 0 : if (core->parent == parent_core)
2450 : : return true;
2451 : :
2452 : 0 : for (i = 0; i < core->num_parents; i++)
2453 : 0 : if (!strcmp(core->parents[i].name, parent_core->name))
2454 : : return true;
2455 : :
2456 : : return false;
2457 : : }
2458 : : EXPORT_SYMBOL_GPL(clk_has_parent);
2459 : :
2460 : 0 : static int clk_core_set_parent_nolock(struct clk_core *core,
2461 : : struct clk_core *parent)
2462 : : {
2463 : : int ret = 0;
2464 : : int p_index = 0;
2465 : : unsigned long p_rate = 0;
2466 : :
2467 : : lockdep_assert_held(&prepare_lock);
2468 : :
2469 : 0 : if (!core)
2470 : : return 0;
2471 : :
2472 : 0 : if (core->parent == parent)
2473 : : return 0;
2474 : :
2475 : : /* verify ops for multi-parent clks */
2476 : 0 : if (core->num_parents > 1 && !core->ops->set_parent)
2477 : : return -EPERM;
2478 : :
2479 : : /* check that we are allowed to re-parent if the clock is in use */
2480 : 0 : if ((core->flags & CLK_SET_PARENT_GATE) && core->prepare_count)
2481 : : return -EBUSY;
2482 : :
2483 : 0 : if (clk_core_rate_is_protected(core))
2484 : : return -EBUSY;
2485 : :
2486 : : /* try finding the new parent index */
2487 : 0 : if (parent) {
2488 : 0 : p_index = clk_fetch_parent_index(core, parent);
2489 : 0 : if (p_index < 0) {
2490 : : pr_debug("%s: clk %s can not be parent of clk %s\n",
2491 : : __func__, parent->name, core->name);
2492 : : return p_index;
2493 : : }
2494 : 0 : p_rate = parent->rate;
2495 : : }
2496 : :
2497 : 0 : ret = clk_pm_runtime_get(core);
2498 : 0 : if (ret)
2499 : : return ret;
2500 : :
2501 : : /* propagate PRE_RATE_CHANGE notifications */
2502 : 0 : ret = __clk_speculate_rates(core, p_rate);
2503 : :
2504 : : /* abort if a driver objects */
2505 : 0 : if (ret & NOTIFY_STOP_MASK)
2506 : : goto runtime_put;
2507 : :
2508 : : /* do the re-parent */
2509 : 0 : ret = __clk_set_parent(core, parent, p_index);
2510 : :
2511 : : /* propagate rate an accuracy recalculation accordingly */
2512 : 0 : if (ret) {
2513 : 0 : __clk_recalc_rates(core, ABORT_RATE_CHANGE);
2514 : : } else {
2515 : 0 : __clk_recalc_rates(core, POST_RATE_CHANGE);
2516 : 0 : __clk_recalc_accuracies(core);
2517 : : }
2518 : :
2519 : : runtime_put:
2520 : : clk_pm_runtime_put(core);
2521 : :
2522 : 0 : return ret;
2523 : : }
2524 : :
2525 : 0 : int clk_hw_set_parent(struct clk_hw *hw, struct clk_hw *parent)
2526 : : {
2527 : 0 : return clk_core_set_parent_nolock(hw->core, parent->core);
2528 : : }
2529 : : EXPORT_SYMBOL_GPL(clk_hw_set_parent);
2530 : :
2531 : : /**
2532 : : * clk_set_parent - switch the parent of a mux clk
2533 : : * @clk: the mux clk whose input we are switching
2534 : : * @parent: the new input to clk
2535 : : *
2536 : : * Re-parent clk to use parent as its new input source. If clk is in
2537 : : * prepared state, the clk will get enabled for the duration of this call. If
2538 : : * that's not acceptable for a specific clk (Eg: the consumer can't handle
2539 : : * that, the reparenting is glitchy in hardware, etc), use the
2540 : : * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
2541 : : *
2542 : : * After successfully changing clk's parent clk_set_parent will update the
2543 : : * clk topology, sysfs topology and propagate rate recalculation via
2544 : : * __clk_recalc_rates.
2545 : : *
2546 : : * Returns 0 on success, -EERROR otherwise.
2547 : : */
2548 : 0 : int clk_set_parent(struct clk *clk, struct clk *parent)
2549 : : {
2550 : : int ret;
2551 : :
2552 : 0 : if (!clk)
2553 : : return 0;
2554 : :
2555 : 0 : clk_prepare_lock();
2556 : :
2557 : 0 : if (clk->exclusive_count)
2558 : 0 : clk_core_rate_unprotect(clk->core);
2559 : :
2560 : 0 : ret = clk_core_set_parent_nolock(clk->core,
2561 : : parent ? parent->core : NULL);
2562 : :
2563 : 0 : if (clk->exclusive_count)
2564 : 0 : clk_core_rate_protect(clk->core);
2565 : :
2566 : 0 : clk_prepare_unlock();
2567 : :
2568 : 0 : return ret;
2569 : : }
2570 : : EXPORT_SYMBOL_GPL(clk_set_parent);
2571 : :
2572 : 0 : static int clk_core_set_phase_nolock(struct clk_core *core, int degrees)
2573 : : {
2574 : : int ret = -EINVAL;
2575 : :
2576 : : lockdep_assert_held(&prepare_lock);
2577 : :
2578 : 0 : if (!core)
2579 : : return 0;
2580 : :
2581 : 0 : if (clk_core_rate_is_protected(core))
2582 : : return -EBUSY;
2583 : :
2584 : 0 : trace_clk_set_phase(core, degrees);
2585 : :
2586 : 0 : if (core->ops->set_phase) {
2587 : 0 : ret = core->ops->set_phase(core->hw, degrees);
2588 : 0 : if (!ret)
2589 : 0 : core->phase = degrees;
2590 : : }
2591 : :
2592 : 0 : trace_clk_set_phase_complete(core, degrees);
2593 : :
2594 : 0 : return ret;
2595 : : }
2596 : :
2597 : : /**
2598 : : * clk_set_phase - adjust the phase shift of a clock signal
2599 : : * @clk: clock signal source
2600 : : * @degrees: number of degrees the signal is shifted
2601 : : *
2602 : : * Shifts the phase of a clock signal by the specified
2603 : : * degrees. Returns 0 on success, -EERROR otherwise.
2604 : : *
2605 : : * This function makes no distinction about the input or reference
2606 : : * signal that we adjust the clock signal phase against. For example
2607 : : * phase locked-loop clock signal generators we may shift phase with
2608 : : * respect to feedback clock signal input, but for other cases the
2609 : : * clock phase may be shifted with respect to some other, unspecified
2610 : : * signal.
2611 : : *
2612 : : * Additionally the concept of phase shift does not propagate through
2613 : : * the clock tree hierarchy, which sets it apart from clock rates and
2614 : : * clock accuracy. A parent clock phase attribute does not have an
2615 : : * impact on the phase attribute of a child clock.
2616 : : */
2617 : 0 : int clk_set_phase(struct clk *clk, int degrees)
2618 : : {
2619 : : int ret;
2620 : :
2621 : 0 : if (!clk)
2622 : : return 0;
2623 : :
2624 : : /* sanity check degrees */
2625 : 0 : degrees %= 360;
2626 : 0 : if (degrees < 0)
2627 : 0 : degrees += 360;
2628 : :
2629 : 0 : clk_prepare_lock();
2630 : :
2631 : 0 : if (clk->exclusive_count)
2632 : 0 : clk_core_rate_unprotect(clk->core);
2633 : :
2634 : 0 : ret = clk_core_set_phase_nolock(clk->core, degrees);
2635 : :
2636 : 0 : if (clk->exclusive_count)
2637 : 0 : clk_core_rate_protect(clk->core);
2638 : :
2639 : 0 : clk_prepare_unlock();
2640 : :
2641 : 0 : return ret;
2642 : : }
2643 : : EXPORT_SYMBOL_GPL(clk_set_phase);
2644 : :
2645 : : static int clk_core_get_phase(struct clk_core *core)
2646 : : {
2647 : : int ret;
2648 : :
2649 : : lockdep_assert_held(&prepare_lock);
2650 : 3 : if (!core->ops->get_phase)
2651 : : return 0;
2652 : :
2653 : : /* Always try to update cached phase if possible */
2654 : 0 : ret = core->ops->get_phase(core->hw);
2655 : 0 : if (ret >= 0)
2656 : 0 : core->phase = ret;
2657 : :
2658 : : return ret;
2659 : : }
2660 : :
2661 : : /**
2662 : : * clk_get_phase - return the phase shift of a clock signal
2663 : : * @clk: clock signal source
2664 : : *
2665 : : * Returns the phase shift of a clock node in degrees, otherwise returns
2666 : : * -EERROR.
2667 : : */
2668 : 0 : int clk_get_phase(struct clk *clk)
2669 : : {
2670 : : int ret;
2671 : :
2672 : 0 : if (!clk)
2673 : : return 0;
2674 : :
2675 : 0 : clk_prepare_lock();
2676 : 0 : ret = clk_core_get_phase(clk->core);
2677 : 0 : clk_prepare_unlock();
2678 : :
2679 : 0 : return ret;
2680 : : }
2681 : : EXPORT_SYMBOL_GPL(clk_get_phase);
2682 : :
2683 : : static void clk_core_reset_duty_cycle_nolock(struct clk_core *core)
2684 : : {
2685 : : /* Assume a default value of 50% */
2686 : 3 : core->duty.num = 1;
2687 : 3 : core->duty.den = 2;
2688 : : }
2689 : :
2690 : : static int clk_core_update_duty_cycle_parent_nolock(struct clk_core *core);
2691 : :
2692 : 3 : static int clk_core_update_duty_cycle_nolock(struct clk_core *core)
2693 : : {
2694 : 3 : struct clk_duty *duty = &core->duty;
2695 : : int ret = 0;
2696 : :
2697 : 3 : if (!core->ops->get_duty_cycle)
2698 : 3 : return clk_core_update_duty_cycle_parent_nolock(core);
2699 : :
2700 : 0 : ret = core->ops->get_duty_cycle(core->hw, duty);
2701 : 0 : if (ret)
2702 : : goto reset;
2703 : :
2704 : : /* Don't trust the clock provider too much */
2705 : 0 : if (duty->den == 0 || duty->num > duty->den) {
2706 : : ret = -EINVAL;
2707 : : goto reset;
2708 : : }
2709 : :
2710 : : return 0;
2711 : :
2712 : : reset:
2713 : : clk_core_reset_duty_cycle_nolock(core);
2714 : 0 : return ret;
2715 : : }
2716 : :
2717 : 3 : static int clk_core_update_duty_cycle_parent_nolock(struct clk_core *core)
2718 : : {
2719 : : int ret = 0;
2720 : :
2721 : 3 : if (core->parent &&
2722 : 3 : core->flags & CLK_DUTY_CYCLE_PARENT) {
2723 : 0 : ret = clk_core_update_duty_cycle_nolock(core->parent);
2724 : 0 : memcpy(&core->duty, &core->parent->duty, sizeof(core->duty));
2725 : : } else {
2726 : : clk_core_reset_duty_cycle_nolock(core);
2727 : : }
2728 : :
2729 : 3 : return ret;
2730 : : }
2731 : :
2732 : : static int clk_core_set_duty_cycle_parent_nolock(struct clk_core *core,
2733 : : struct clk_duty *duty);
2734 : :
2735 : 0 : static int clk_core_set_duty_cycle_nolock(struct clk_core *core,
2736 : : struct clk_duty *duty)
2737 : : {
2738 : : int ret;
2739 : :
2740 : : lockdep_assert_held(&prepare_lock);
2741 : :
2742 : 0 : if (clk_core_rate_is_protected(core))
2743 : : return -EBUSY;
2744 : :
2745 : 0 : trace_clk_set_duty_cycle(core, duty);
2746 : :
2747 : 0 : if (!core->ops->set_duty_cycle)
2748 : 0 : return clk_core_set_duty_cycle_parent_nolock(core, duty);
2749 : :
2750 : 0 : ret = core->ops->set_duty_cycle(core->hw, duty);
2751 : 0 : if (!ret)
2752 : 0 : memcpy(&core->duty, duty, sizeof(*duty));
2753 : :
2754 : 0 : trace_clk_set_duty_cycle_complete(core, duty);
2755 : :
2756 : 0 : return ret;
2757 : : }
2758 : :
2759 : 0 : static int clk_core_set_duty_cycle_parent_nolock(struct clk_core *core,
2760 : : struct clk_duty *duty)
2761 : : {
2762 : : int ret = 0;
2763 : :
2764 : 0 : if (core->parent &&
2765 : 0 : core->flags & (CLK_DUTY_CYCLE_PARENT | CLK_SET_RATE_PARENT)) {
2766 : 0 : ret = clk_core_set_duty_cycle_nolock(core->parent, duty);
2767 : 0 : memcpy(&core->duty, &core->parent->duty, sizeof(core->duty));
2768 : : }
2769 : :
2770 : 0 : return ret;
2771 : : }
2772 : :
2773 : : /**
2774 : : * clk_set_duty_cycle - adjust the duty cycle ratio of a clock signal
2775 : : * @clk: clock signal source
2776 : : * @num: numerator of the duty cycle ratio to be applied
2777 : : * @den: denominator of the duty cycle ratio to be applied
2778 : : *
2779 : : * Apply the duty cycle ratio if the ratio is valid and the clock can
2780 : : * perform this operation
2781 : : *
2782 : : * Returns (0) on success, a negative errno otherwise.
2783 : : */
2784 : 0 : int clk_set_duty_cycle(struct clk *clk, unsigned int num, unsigned int den)
2785 : : {
2786 : : int ret;
2787 : : struct clk_duty duty;
2788 : :
2789 : 0 : if (!clk)
2790 : : return 0;
2791 : :
2792 : : /* sanity check the ratio */
2793 : 0 : if (den == 0 || num > den)
2794 : : return -EINVAL;
2795 : :
2796 : 0 : duty.num = num;
2797 : 0 : duty.den = den;
2798 : :
2799 : 0 : clk_prepare_lock();
2800 : :
2801 : 0 : if (clk->exclusive_count)
2802 : 0 : clk_core_rate_unprotect(clk->core);
2803 : :
2804 : 0 : ret = clk_core_set_duty_cycle_nolock(clk->core, &duty);
2805 : :
2806 : 0 : if (clk->exclusive_count)
2807 : 0 : clk_core_rate_protect(clk->core);
2808 : :
2809 : 0 : clk_prepare_unlock();
2810 : :
2811 : 0 : return ret;
2812 : : }
2813 : : EXPORT_SYMBOL_GPL(clk_set_duty_cycle);
2814 : :
2815 : 0 : static int clk_core_get_scaled_duty_cycle(struct clk_core *core,
2816 : : unsigned int scale)
2817 : : {
2818 : : struct clk_duty *duty = &core->duty;
2819 : : int ret;
2820 : :
2821 : 0 : clk_prepare_lock();
2822 : :
2823 : 0 : ret = clk_core_update_duty_cycle_nolock(core);
2824 : 0 : if (!ret)
2825 : 0 : ret = mult_frac(scale, duty->num, duty->den);
2826 : :
2827 : 0 : clk_prepare_unlock();
2828 : :
2829 : 0 : return ret;
2830 : : }
2831 : :
2832 : : /**
2833 : : * clk_get_scaled_duty_cycle - return the duty cycle ratio of a clock signal
2834 : : * @clk: clock signal source
2835 : : * @scale: scaling factor to be applied to represent the ratio as an integer
2836 : : *
2837 : : * Returns the duty cycle ratio of a clock node multiplied by the provided
2838 : : * scaling factor, or negative errno on error.
2839 : : */
2840 : 0 : int clk_get_scaled_duty_cycle(struct clk *clk, unsigned int scale)
2841 : : {
2842 : 0 : if (!clk)
2843 : : return 0;
2844 : :
2845 : 0 : return clk_core_get_scaled_duty_cycle(clk->core, scale);
2846 : : }
2847 : : EXPORT_SYMBOL_GPL(clk_get_scaled_duty_cycle);
2848 : :
2849 : : /**
2850 : : * clk_is_match - check if two clk's point to the same hardware clock
2851 : : * @p: clk compared against q
2852 : : * @q: clk compared against p
2853 : : *
2854 : : * Returns true if the two struct clk pointers both point to the same hardware
2855 : : * clock node. Put differently, returns true if struct clk *p and struct clk *q
2856 : : * share the same struct clk_core object.
2857 : : *
2858 : : * Returns false otherwise. Note that two NULL clks are treated as matching.
2859 : : */
2860 : 0 : bool clk_is_match(const struct clk *p, const struct clk *q)
2861 : : {
2862 : : /* trivial case: identical struct clk's or both NULL */
2863 : 0 : if (p == q)
2864 : : return true;
2865 : :
2866 : : /* true if clk->core pointers match. Avoid dereferencing garbage */
2867 : 0 : if (!IS_ERR_OR_NULL(p) && !IS_ERR_OR_NULL(q))
2868 : 0 : if (p->core == q->core)
2869 : : return true;
2870 : :
2871 : 0 : return false;
2872 : : }
2873 : : EXPORT_SYMBOL_GPL(clk_is_match);
2874 : :
2875 : : /*** debugfs support ***/
2876 : :
2877 : : #ifdef CONFIG_DEBUG_FS
2878 : : #include <linux/debugfs.h>
2879 : :
2880 : : static struct dentry *rootdir;
2881 : : static int inited = 0;
2882 : : static DEFINE_MUTEX(clk_debug_lock);
2883 : : static HLIST_HEAD(clk_debug_list);
2884 : :
2885 : : static struct hlist_head *orphan_list[] = {
2886 : : &clk_orphan_list,
2887 : : NULL,
2888 : : };
2889 : :
2890 : 0 : static void clk_summary_show_one(struct seq_file *s, struct clk_core *c,
2891 : : int level)
2892 : : {
2893 : : int phase;
2894 : :
2895 : 0 : seq_printf(s, "%*s%-*s %7d %8d %8d %11lu %10lu ",
2896 : 0 : level * 3 + 1, "",
2897 : 0 : 30 - level * 3, c->name,
2898 : : c->enable_count, c->prepare_count, c->protect_count,
2899 : : clk_core_get_rate(c), clk_core_get_accuracy(c));
2900 : :
2901 : : phase = clk_core_get_phase(c);
2902 : 0 : if (phase >= 0)
2903 : 0 : seq_printf(s, "%5d", phase);
2904 : : else
2905 : 0 : seq_puts(s, "-----");
2906 : :
2907 : 0 : seq_printf(s, " %6d\n", clk_core_get_scaled_duty_cycle(c, 100000));
2908 : 0 : }
2909 : :
2910 : 0 : static void clk_summary_show_subtree(struct seq_file *s, struct clk_core *c,
2911 : : int level)
2912 : : {
2913 : : struct clk_core *child;
2914 : :
2915 : 0 : clk_summary_show_one(s, c, level);
2916 : :
2917 : 0 : hlist_for_each_entry(child, &c->children, child_node)
2918 : 0 : clk_summary_show_subtree(s, child, level + 1);
2919 : 0 : }
2920 : :
2921 : 0 : static int clk_summary_show(struct seq_file *s, void *data)
2922 : : {
2923 : : struct clk_core *c;
2924 : 0 : struct hlist_head **lists = (struct hlist_head **)s->private;
2925 : :
2926 : 0 : seq_puts(s, " enable prepare protect duty\n");
2927 : 0 : seq_puts(s, " clock count count count rate accuracy phase cycle\n");
2928 : 0 : seq_puts(s, "---------------------------------------------------------------------------------------------\n");
2929 : :
2930 : 0 : clk_prepare_lock();
2931 : :
2932 : 0 : for (; *lists; lists++)
2933 : 0 : hlist_for_each_entry(c, *lists, child_node)
2934 : 0 : clk_summary_show_subtree(s, c, 0);
2935 : :
2936 : 0 : clk_prepare_unlock();
2937 : :
2938 : 0 : return 0;
2939 : : }
2940 : 0 : DEFINE_SHOW_ATTRIBUTE(clk_summary);
2941 : :
2942 : 0 : static void clk_dump_one(struct seq_file *s, struct clk_core *c, int level)
2943 : : {
2944 : : int phase;
2945 : : unsigned long min_rate, max_rate;
2946 : :
2947 : 0 : clk_core_get_boundaries(c, &min_rate, &max_rate);
2948 : :
2949 : : /* This should be JSON format, i.e. elements separated with a comma */
2950 : 0 : seq_printf(s, "\"%s\": { ", c->name);
2951 : 0 : seq_printf(s, "\"enable_count\": %d,", c->enable_count);
2952 : 0 : seq_printf(s, "\"prepare_count\": %d,", c->prepare_count);
2953 : 0 : seq_printf(s, "\"protect_count\": %d,", c->protect_count);
2954 : 0 : seq_printf(s, "\"rate\": %lu,", clk_core_get_rate(c));
2955 : 0 : seq_printf(s, "\"min_rate\": %lu,", min_rate);
2956 : 0 : seq_printf(s, "\"max_rate\": %lu,", max_rate);
2957 : 0 : seq_printf(s, "\"accuracy\": %lu,", clk_core_get_accuracy(c));
2958 : : phase = clk_core_get_phase(c);
2959 : 0 : if (phase >= 0)
2960 : 0 : seq_printf(s, "\"phase\": %d,", phase);
2961 : 0 : seq_printf(s, "\"duty_cycle\": %u",
2962 : : clk_core_get_scaled_duty_cycle(c, 100000));
2963 : 0 : }
2964 : :
2965 : 0 : static void clk_dump_subtree(struct seq_file *s, struct clk_core *c, int level)
2966 : : {
2967 : : struct clk_core *child;
2968 : :
2969 : 0 : clk_dump_one(s, c, level);
2970 : :
2971 : 0 : hlist_for_each_entry(child, &c->children, child_node) {
2972 : 0 : seq_putc(s, ',');
2973 : 0 : clk_dump_subtree(s, child, level + 1);
2974 : : }
2975 : :
2976 : 0 : seq_putc(s, '}');
2977 : 0 : }
2978 : :
2979 : 0 : static int clk_dump_show(struct seq_file *s, void *data)
2980 : : {
2981 : : struct clk_core *c;
2982 : : bool first_node = true;
2983 : 0 : struct hlist_head **lists = (struct hlist_head **)s->private;
2984 : :
2985 : 0 : seq_putc(s, '{');
2986 : 0 : clk_prepare_lock();
2987 : :
2988 : 0 : for (; *lists; lists++) {
2989 : 0 : hlist_for_each_entry(c, *lists, child_node) {
2990 : 0 : if (!first_node)
2991 : 0 : seq_putc(s, ',');
2992 : : first_node = false;
2993 : 0 : clk_dump_subtree(s, c, 0);
2994 : : }
2995 : : }
2996 : :
2997 : 0 : clk_prepare_unlock();
2998 : :
2999 : 0 : seq_puts(s, "}\n");
3000 : 0 : return 0;
3001 : : }
3002 : 0 : DEFINE_SHOW_ATTRIBUTE(clk_dump);
3003 : :
3004 : : static const struct {
3005 : : unsigned long flag;
3006 : : const char *name;
3007 : : } clk_flags[] = {
3008 : : #define ENTRY(f) { f, #f }
3009 : : ENTRY(CLK_SET_RATE_GATE),
3010 : : ENTRY(CLK_SET_PARENT_GATE),
3011 : : ENTRY(CLK_SET_RATE_PARENT),
3012 : : ENTRY(CLK_IGNORE_UNUSED),
3013 : : ENTRY(CLK_GET_RATE_NOCACHE),
3014 : : ENTRY(CLK_SET_RATE_NO_REPARENT),
3015 : : ENTRY(CLK_GET_ACCURACY_NOCACHE),
3016 : : ENTRY(CLK_RECALC_NEW_RATES),
3017 : : ENTRY(CLK_SET_RATE_UNGATE),
3018 : : ENTRY(CLK_IS_CRITICAL),
3019 : : ENTRY(CLK_OPS_PARENT_ENABLE),
3020 : : ENTRY(CLK_DUTY_CYCLE_PARENT),
3021 : : #undef ENTRY
3022 : : };
3023 : :
3024 : 0 : static int clk_flags_show(struct seq_file *s, void *data)
3025 : : {
3026 : 0 : struct clk_core *core = s->private;
3027 : 0 : unsigned long flags = core->flags;
3028 : : unsigned int i;
3029 : :
3030 : 0 : for (i = 0; flags && i < ARRAY_SIZE(clk_flags); i++) {
3031 : 0 : if (flags & clk_flags[i].flag) {
3032 : 0 : seq_printf(s, "%s\n", clk_flags[i].name);
3033 : 0 : flags &= ~clk_flags[i].flag;
3034 : : }
3035 : : }
3036 : 0 : if (flags) {
3037 : : /* Unknown flags */
3038 : 0 : seq_printf(s, "0x%lx\n", flags);
3039 : : }
3040 : :
3041 : 0 : return 0;
3042 : : }
3043 : 0 : DEFINE_SHOW_ATTRIBUTE(clk_flags);
3044 : :
3045 : 0 : static void possible_parent_show(struct seq_file *s, struct clk_core *core,
3046 : : unsigned int i, char terminator)
3047 : : {
3048 : : struct clk_core *parent;
3049 : :
3050 : : /*
3051 : : * Go through the following options to fetch a parent's name.
3052 : : *
3053 : : * 1. Fetch the registered parent clock and use its name
3054 : : * 2. Use the global (fallback) name if specified
3055 : : * 3. Use the local fw_name if provided
3056 : : * 4. Fetch parent clock's clock-output-name if DT index was set
3057 : : *
3058 : : * This may still fail in some cases, such as when the parent is
3059 : : * specified directly via a struct clk_hw pointer, but it isn't
3060 : : * registered (yet).
3061 : : */
3062 : 0 : parent = clk_core_get_parent_by_index(core, i);
3063 : 0 : if (parent)
3064 : 0 : seq_puts(s, parent->name);
3065 : 0 : else if (core->parents[i].name)
3066 : 0 : seq_puts(s, core->parents[i].name);
3067 : 0 : else if (core->parents[i].fw_name)
3068 : 0 : seq_printf(s, "<%s>(fw)", core->parents[i].fw_name);
3069 : 0 : else if (core->parents[i].index >= 0)
3070 : 0 : seq_puts(s,
3071 : : of_clk_get_parent_name(core->of_node,
3072 : : core->parents[i].index));
3073 : : else
3074 : 0 : seq_puts(s, "(missing)");
3075 : :
3076 : 0 : seq_putc(s, terminator);
3077 : 0 : }
3078 : :
3079 : 0 : static int possible_parents_show(struct seq_file *s, void *data)
3080 : : {
3081 : 0 : struct clk_core *core = s->private;
3082 : : int i;
3083 : :
3084 : 0 : for (i = 0; i < core->num_parents - 1; i++)
3085 : 0 : possible_parent_show(s, core, i, ' ');
3086 : :
3087 : 0 : possible_parent_show(s, core, i, '\n');
3088 : :
3089 : 0 : return 0;
3090 : : }
3091 : 0 : DEFINE_SHOW_ATTRIBUTE(possible_parents);
3092 : :
3093 : 0 : static int current_parent_show(struct seq_file *s, void *data)
3094 : : {
3095 : 0 : struct clk_core *core = s->private;
3096 : :
3097 : 0 : if (core->parent)
3098 : 0 : seq_printf(s, "%s\n", core->parent->name);
3099 : :
3100 : 0 : return 0;
3101 : : }
3102 : 0 : DEFINE_SHOW_ATTRIBUTE(current_parent);
3103 : :
3104 : 0 : static int clk_duty_cycle_show(struct seq_file *s, void *data)
3105 : : {
3106 : 0 : struct clk_core *core = s->private;
3107 : : struct clk_duty *duty = &core->duty;
3108 : :
3109 : 0 : seq_printf(s, "%u/%u\n", duty->num, duty->den);
3110 : :
3111 : 0 : return 0;
3112 : : }
3113 : 0 : DEFINE_SHOW_ATTRIBUTE(clk_duty_cycle);
3114 : :
3115 : 0 : static int clk_min_rate_show(struct seq_file *s, void *data)
3116 : : {
3117 : 0 : struct clk_core *core = s->private;
3118 : : unsigned long min_rate, max_rate;
3119 : :
3120 : 0 : clk_prepare_lock();
3121 : 0 : clk_core_get_boundaries(core, &min_rate, &max_rate);
3122 : 0 : clk_prepare_unlock();
3123 : 0 : seq_printf(s, "%lu\n", min_rate);
3124 : :
3125 : 0 : return 0;
3126 : : }
3127 : 0 : DEFINE_SHOW_ATTRIBUTE(clk_min_rate);
3128 : :
3129 : 0 : static int clk_max_rate_show(struct seq_file *s, void *data)
3130 : : {
3131 : 0 : struct clk_core *core = s->private;
3132 : : unsigned long min_rate, max_rate;
3133 : :
3134 : 0 : clk_prepare_lock();
3135 : 0 : clk_core_get_boundaries(core, &min_rate, &max_rate);
3136 : 0 : clk_prepare_unlock();
3137 : 0 : seq_printf(s, "%lu\n", max_rate);
3138 : :
3139 : 0 : return 0;
3140 : : }
3141 : 0 : DEFINE_SHOW_ATTRIBUTE(clk_max_rate);
3142 : :
3143 : 3 : static void clk_debug_create_one(struct clk_core *core, struct dentry *pdentry)
3144 : : {
3145 : : struct dentry *root;
3146 : :
3147 : 3 : if (!core || !pdentry)
3148 : 3 : return;
3149 : :
3150 : 3 : root = debugfs_create_dir(core->name, pdentry);
3151 : 3 : core->dentry = root;
3152 : :
3153 : 3 : debugfs_create_ulong("clk_rate", 0444, root, &core->rate);
3154 : 3 : debugfs_create_file("clk_min_rate", 0444, root, core, &clk_min_rate_fops);
3155 : 3 : debugfs_create_file("clk_max_rate", 0444, root, core, &clk_max_rate_fops);
3156 : 3 : debugfs_create_ulong("clk_accuracy", 0444, root, &core->accuracy);
3157 : 3 : debugfs_create_u32("clk_phase", 0444, root, &core->phase);
3158 : 3 : debugfs_create_file("clk_flags", 0444, root, core, &clk_flags_fops);
3159 : 3 : debugfs_create_u32("clk_prepare_count", 0444, root, &core->prepare_count);
3160 : 3 : debugfs_create_u32("clk_enable_count", 0444, root, &core->enable_count);
3161 : 3 : debugfs_create_u32("clk_protect_count", 0444, root, &core->protect_count);
3162 : 3 : debugfs_create_u32("clk_notifier_count", 0444, root, &core->notifier_count);
3163 : 3 : debugfs_create_file("clk_duty_cycle", 0444, root, core,
3164 : : &clk_duty_cycle_fops);
3165 : :
3166 : 3 : if (core->num_parents > 0)
3167 : 3 : debugfs_create_file("clk_parent", 0444, root, core,
3168 : : ¤t_parent_fops);
3169 : :
3170 : 3 : if (core->num_parents > 1)
3171 : 3 : debugfs_create_file("clk_possible_parents", 0444, root, core,
3172 : : &possible_parents_fops);
3173 : :
3174 : 3 : if (core->ops->debug_init)
3175 : 3 : core->ops->debug_init(core->hw, core->dentry);
3176 : : }
3177 : :
3178 : : /**
3179 : : * clk_debug_register - add a clk node to the debugfs clk directory
3180 : : * @core: the clk being added to the debugfs clk directory
3181 : : *
3182 : : * Dynamically adds a clk to the debugfs clk directory if debugfs has been
3183 : : * initialized. Otherwise it bails out early since the debugfs clk directory
3184 : : * will be created lazily by clk_debug_init as part of a late_initcall.
3185 : : */
3186 : 3 : static void clk_debug_register(struct clk_core *core)
3187 : : {
3188 : 3 : mutex_lock(&clk_debug_lock);
3189 : 3 : hlist_add_head(&core->debug_node, &clk_debug_list);
3190 : 3 : if (inited)
3191 : 3 : clk_debug_create_one(core, rootdir);
3192 : 3 : mutex_unlock(&clk_debug_lock);
3193 : 3 : }
3194 : :
3195 : : /**
3196 : : * clk_debug_unregister - remove a clk node from the debugfs clk directory
3197 : : * @core: the clk being removed from the debugfs clk directory
3198 : : *
3199 : : * Dynamically removes a clk and all its child nodes from the
3200 : : * debugfs clk directory if clk->dentry points to debugfs created by
3201 : : * clk_debug_register in __clk_core_init.
3202 : : */
3203 : 0 : static void clk_debug_unregister(struct clk_core *core)
3204 : : {
3205 : 0 : mutex_lock(&clk_debug_lock);
3206 : : hlist_del_init(&core->debug_node);
3207 : 0 : debugfs_remove_recursive(core->dentry);
3208 : 0 : core->dentry = NULL;
3209 : 0 : mutex_unlock(&clk_debug_lock);
3210 : 0 : }
3211 : :
3212 : : /**
3213 : : * clk_debug_init - lazily populate the debugfs clk directory
3214 : : *
3215 : : * clks are often initialized very early during boot before memory can be
3216 : : * dynamically allocated and well before debugfs is setup. This function
3217 : : * populates the debugfs clk directory once at boot-time when we know that
3218 : : * debugfs is setup. It should only be called once at boot-time, all other clks
3219 : : * added dynamically will be done so with clk_debug_register.
3220 : : */
3221 : 3 : static int __init clk_debug_init(void)
3222 : : {
3223 : : struct clk_core *core;
3224 : :
3225 : 3 : rootdir = debugfs_create_dir("clk", NULL);
3226 : :
3227 : 3 : debugfs_create_file("clk_summary", 0444, rootdir, &all_lists,
3228 : : &clk_summary_fops);
3229 : 3 : debugfs_create_file("clk_dump", 0444, rootdir, &all_lists,
3230 : : &clk_dump_fops);
3231 : 3 : debugfs_create_file("clk_orphan_summary", 0444, rootdir, &orphan_list,
3232 : : &clk_summary_fops);
3233 : 3 : debugfs_create_file("clk_orphan_dump", 0444, rootdir, &orphan_list,
3234 : : &clk_dump_fops);
3235 : :
3236 : 3 : mutex_lock(&clk_debug_lock);
3237 : 3 : hlist_for_each_entry(core, &clk_debug_list, debug_node)
3238 : 3 : clk_debug_create_one(core, rootdir);
3239 : :
3240 : 3 : inited = 1;
3241 : 3 : mutex_unlock(&clk_debug_lock);
3242 : :
3243 : 3 : return 0;
3244 : : }
3245 : : late_initcall(clk_debug_init);
3246 : : #else
3247 : : static inline void clk_debug_register(struct clk_core *core) { }
3248 : : static inline void clk_debug_reparent(struct clk_core *core,
3249 : : struct clk_core *new_parent)
3250 : : {
3251 : : }
3252 : : static inline void clk_debug_unregister(struct clk_core *core)
3253 : : {
3254 : : }
3255 : : #endif
3256 : :
3257 : 3 : static void clk_core_reparent_orphans_nolock(void)
3258 : : {
3259 : : struct clk_core *orphan;
3260 : : struct hlist_node *tmp2;
3261 : :
3262 : : /*
3263 : : * walk the list of orphan clocks and reparent any that newly finds a
3264 : : * parent.
3265 : : */
3266 : 3 : hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
3267 : 3 : struct clk_core *parent = __clk_init_parent(orphan);
3268 : :
3269 : : /*
3270 : : * We need to use __clk_set_parent_before() and _after() to
3271 : : * to properly migrate any prepare/enable count of the orphan
3272 : : * clock. This is important for CLK_IS_CRITICAL clocks, which
3273 : : * are enabled during init but might not have a parent yet.
3274 : : */
3275 : 3 : if (parent) {
3276 : : /* update the clk tree topology */
3277 : 0 : __clk_set_parent_before(orphan, parent);
3278 : 0 : __clk_set_parent_after(orphan, parent, NULL);
3279 : 0 : __clk_recalc_accuracies(orphan);
3280 : 0 : __clk_recalc_rates(orphan, 0);
3281 : : }
3282 : : }
3283 : 3 : }
3284 : :
3285 : : /**
3286 : : * __clk_core_init - initialize the data structures in a struct clk_core
3287 : : * @core: clk_core being initialized
3288 : : *
3289 : : * Initializes the lists in struct clk_core, queries the hardware for the
3290 : : * parent and rate and sets them both.
3291 : : */
3292 : 3 : static int __clk_core_init(struct clk_core *core)
3293 : : {
3294 : : int ret;
3295 : : unsigned long rate;
3296 : :
3297 : 3 : if (!core)
3298 : : return -EINVAL;
3299 : :
3300 : 3 : clk_prepare_lock();
3301 : :
3302 : 3 : ret = clk_pm_runtime_get(core);
3303 : 3 : if (ret)
3304 : : goto unlock;
3305 : :
3306 : : /* check to see if a clock with this name is already registered */
3307 : 3 : if (clk_core_lookup(core->name)) {
3308 : : pr_debug("%s: clk %s already initialized\n",
3309 : : __func__, core->name);
3310 : : ret = -EEXIST;
3311 : : goto out;
3312 : : }
3313 : :
3314 : : /* check that clk_ops are sane. See Documentation/driver-api/clk.rst */
3315 : 3 : if (core->ops->set_rate &&
3316 : 3 : !((core->ops->round_rate || core->ops->determine_rate) &&
3317 : 3 : core->ops->recalc_rate)) {
3318 : 0 : pr_err("%s: %s must implement .round_rate or .determine_rate in addition to .recalc_rate\n",
3319 : : __func__, core->name);
3320 : : ret = -EINVAL;
3321 : 0 : goto out;
3322 : : }
3323 : :
3324 : 3 : if (core->ops->set_parent && !core->ops->get_parent) {
3325 : 0 : pr_err("%s: %s must implement .get_parent & .set_parent\n",
3326 : : __func__, core->name);
3327 : : ret = -EINVAL;
3328 : 0 : goto out;
3329 : : }
3330 : :
3331 : 3 : if (core->num_parents > 1 && !core->ops->get_parent) {
3332 : 0 : pr_err("%s: %s must implement .get_parent as it has multi parents\n",
3333 : : __func__, core->name);
3334 : : ret = -EINVAL;
3335 : 0 : goto out;
3336 : : }
3337 : :
3338 : 3 : if (core->ops->set_rate_and_parent &&
3339 : 3 : !(core->ops->set_parent && core->ops->set_rate)) {
3340 : 0 : pr_err("%s: %s must implement .set_parent & .set_rate\n",
3341 : : __func__, core->name);
3342 : : ret = -EINVAL;
3343 : 0 : goto out;
3344 : : }
3345 : :
3346 : : /*
3347 : : * optional platform-specific magic
3348 : : *
3349 : : * The .init callback is not used by any of the basic clock types, but
3350 : : * exists for weird hardware that must perform initialization magic.
3351 : : * Please consider other ways of solving initialization problems before
3352 : : * using this callback, as its use is discouraged.
3353 : : *
3354 : : * If it exist, this callback should called before any other callback of
3355 : : * the clock
3356 : : */
3357 : 3 : if (core->ops->init)
3358 : 0 : core->ops->init(core->hw);
3359 : :
3360 : :
3361 : 3 : core->parent = __clk_init_parent(core);
3362 : :
3363 : : /*
3364 : : * Populate core->parent if parent has already been clk_core_init'd. If
3365 : : * parent has not yet been clk_core_init'd then place clk in the orphan
3366 : : * list. If clk doesn't have any parents then place it in the root
3367 : : * clk list.
3368 : : *
3369 : : * Every time a new clk is clk_init'd then we walk the list of orphan
3370 : : * clocks and re-parent any that are children of the clock currently
3371 : : * being clk_init'd.
3372 : : */
3373 : 3 : if (core->parent) {
3374 : 3 : hlist_add_head(&core->child_node,
3375 : : &core->parent->children);
3376 : 3 : core->orphan = core->parent->orphan;
3377 : 3 : } else if (!core->num_parents) {
3378 : 3 : hlist_add_head(&core->child_node, &clk_root_list);
3379 : 3 : core->orphan = false;
3380 : : } else {
3381 : 3 : hlist_add_head(&core->child_node, &clk_orphan_list);
3382 : 3 : core->orphan = true;
3383 : : }
3384 : :
3385 : : /*
3386 : : * Set clk's accuracy. The preferred method is to use
3387 : : * .recalc_accuracy. For simple clocks and lazy developers the default
3388 : : * fallback is to use the parent's accuracy. If a clock doesn't have a
3389 : : * parent (or is orphaned) then accuracy is set to zero (perfect
3390 : : * clock).
3391 : : */
3392 : 3 : if (core->ops->recalc_accuracy)
3393 : 3 : core->accuracy = core->ops->recalc_accuracy(core->hw,
3394 : : __clk_get_accuracy(core->parent));
3395 : 3 : else if (core->parent)
3396 : 3 : core->accuracy = core->parent->accuracy;
3397 : : else
3398 : 3 : core->accuracy = 0;
3399 : :
3400 : : /*
3401 : : * Set clk's phase by clk_core_get_phase() caching the phase.
3402 : : * Since a phase is by definition relative to its parent, just
3403 : : * query the current clock phase, or just assume it's in phase.
3404 : : */
3405 : : clk_core_get_phase(core);
3406 : :
3407 : : /*
3408 : : * Set clk's duty cycle.
3409 : : */
3410 : 3 : clk_core_update_duty_cycle_nolock(core);
3411 : :
3412 : : /*
3413 : : * Set clk's rate. The preferred method is to use .recalc_rate. For
3414 : : * simple clocks and lazy developers the default fallback is to use the
3415 : : * parent's rate. If a clock doesn't have a parent (or is orphaned)
3416 : : * then rate is set to zero.
3417 : : */
3418 : 3 : if (core->ops->recalc_rate)
3419 : 3 : rate = core->ops->recalc_rate(core->hw,
3420 : : clk_core_get_rate_nolock(core->parent));
3421 : 3 : else if (core->parent)
3422 : 3 : rate = core->parent->rate;
3423 : : else
3424 : : rate = 0;
3425 : 3 : core->rate = core->req_rate = rate;
3426 : :
3427 : : /*
3428 : : * Enable CLK_IS_CRITICAL clocks so newly added critical clocks
3429 : : * don't get accidentally disabled when walking the orphan tree and
3430 : : * reparenting clocks
3431 : : */
3432 : 3 : if (core->flags & CLK_IS_CRITICAL) {
3433 : : unsigned long flags;
3434 : :
3435 : 3 : ret = clk_core_prepare(core);
3436 : 3 : if (ret)
3437 : : goto out;
3438 : :
3439 : 3 : flags = clk_enable_lock();
3440 : 3 : ret = clk_core_enable(core);
3441 : 3 : clk_enable_unlock(flags);
3442 : 3 : if (ret) {
3443 : 0 : clk_core_unprepare(core);
3444 : 0 : goto out;
3445 : : }
3446 : : }
3447 : :
3448 : 3 : clk_core_reparent_orphans_nolock();
3449 : :
3450 : :
3451 : : kref_init(&core->ref);
3452 : : out:
3453 : : clk_pm_runtime_put(core);
3454 : : unlock:
3455 : 3 : if (ret)
3456 : : hlist_del_init(&core->child_node);
3457 : :
3458 : 3 : clk_prepare_unlock();
3459 : :
3460 : 3 : if (!ret)
3461 : 3 : clk_debug_register(core);
3462 : :
3463 : 3 : return ret;
3464 : : }
3465 : :
3466 : : /**
3467 : : * clk_core_link_consumer - Add a clk consumer to the list of consumers in a clk_core
3468 : : * @core: clk to add consumer to
3469 : : * @clk: consumer to link to a clk
3470 : : */
3471 : 3 : static void clk_core_link_consumer(struct clk_core *core, struct clk *clk)
3472 : : {
3473 : 3 : clk_prepare_lock();
3474 : 3 : hlist_add_head(&clk->clks_node, &core->clks);
3475 : 3 : clk_prepare_unlock();
3476 : 3 : }
3477 : :
3478 : : /**
3479 : : * clk_core_unlink_consumer - Remove a clk consumer from the list of consumers in a clk_core
3480 : : * @clk: consumer to unlink
3481 : : */
3482 : : static void clk_core_unlink_consumer(struct clk *clk)
3483 : : {
3484 : : lockdep_assert_held(&prepare_lock);
3485 : : hlist_del(&clk->clks_node);
3486 : : }
3487 : :
3488 : : /**
3489 : : * alloc_clk - Allocate a clk consumer, but leave it unlinked to the clk_core
3490 : : * @core: clk to allocate a consumer for
3491 : : * @dev_id: string describing device name
3492 : : * @con_id: connection ID string on device
3493 : : *
3494 : : * Returns: clk consumer left unlinked from the consumer list
3495 : : */
3496 : 3 : static struct clk *alloc_clk(struct clk_core *core, const char *dev_id,
3497 : : const char *con_id)
3498 : : {
3499 : : struct clk *clk;
3500 : :
3501 : 3 : clk = kzalloc(sizeof(*clk), GFP_KERNEL);
3502 : 3 : if (!clk)
3503 : : return ERR_PTR(-ENOMEM);
3504 : :
3505 : 3 : clk->core = core;
3506 : 3 : clk->dev_id = dev_id;
3507 : 3 : clk->con_id = kstrdup_const(con_id, GFP_KERNEL);
3508 : 3 : clk->max_rate = ULONG_MAX;
3509 : :
3510 : 3 : return clk;
3511 : : }
3512 : :
3513 : : /**
3514 : : * free_clk - Free a clk consumer
3515 : : * @clk: clk consumer to free
3516 : : *
3517 : : * Note, this assumes the clk has been unlinked from the clk_core consumer
3518 : : * list.
3519 : : */
3520 : : static void free_clk(struct clk *clk)
3521 : : {
3522 : 3 : kfree_const(clk->con_id);
3523 : 3 : kfree(clk);
3524 : : }
3525 : :
3526 : : /**
3527 : : * clk_hw_create_clk: Allocate and link a clk consumer to a clk_core given
3528 : : * a clk_hw
3529 : : * @dev: clk consumer device
3530 : : * @hw: clk_hw associated with the clk being consumed
3531 : : * @dev_id: string describing device name
3532 : : * @con_id: connection ID string on device
3533 : : *
3534 : : * This is the main function used to create a clk pointer for use by clk
3535 : : * consumers. It connects a consumer to the clk_core and clk_hw structures
3536 : : * used by the framework and clk provider respectively.
3537 : : */
3538 : 3 : struct clk *clk_hw_create_clk(struct device *dev, struct clk_hw *hw,
3539 : : const char *dev_id, const char *con_id)
3540 : : {
3541 : : struct clk *clk;
3542 : : struct clk_core *core;
3543 : :
3544 : : /* This is to allow this function to be chained to others */
3545 : 3 : if (IS_ERR_OR_NULL(hw))
3546 : : return ERR_CAST(hw);
3547 : :
3548 : 3 : core = hw->core;
3549 : 3 : clk = alloc_clk(core, dev_id, con_id);
3550 : 3 : if (IS_ERR(clk))
3551 : : return clk;
3552 : 3 : clk->dev = dev;
3553 : :
3554 : 3 : if (!try_module_get(core->owner)) {
3555 : : free_clk(clk);
3556 : 0 : return ERR_PTR(-ENOENT);
3557 : : }
3558 : :
3559 : : kref_get(&core->ref);
3560 : 3 : clk_core_link_consumer(core, clk);
3561 : :
3562 : 3 : return clk;
3563 : : }
3564 : :
3565 : 3 : static int clk_cpy_name(const char **dst_p, const char *src, bool must_exist)
3566 : : {
3567 : : const char *dst;
3568 : :
3569 : 3 : if (!src) {
3570 : 0 : if (must_exist)
3571 : : return -EINVAL;
3572 : 0 : return 0;
3573 : : }
3574 : :
3575 : 3 : *dst_p = dst = kstrdup_const(src, GFP_KERNEL);
3576 : 3 : if (!dst)
3577 : : return -ENOMEM;
3578 : :
3579 : 3 : return 0;
3580 : : }
3581 : :
3582 : 3 : static int clk_core_populate_parent_map(struct clk_core *core,
3583 : : const struct clk_init_data *init)
3584 : : {
3585 : 3 : u8 num_parents = init->num_parents;
3586 : 3 : const char * const *parent_names = init->parent_names;
3587 : 3 : const struct clk_hw **parent_hws = init->parent_hws;
3588 : 3 : const struct clk_parent_data *parent_data = init->parent_data;
3589 : : int i, ret = 0;
3590 : : struct clk_parent_map *parents, *parent;
3591 : :
3592 : 3 : if (!num_parents)
3593 : : return 0;
3594 : :
3595 : : /*
3596 : : * Avoid unnecessary string look-ups of clk_core's possible parents by
3597 : : * having a cache of names/clk_hw pointers to clk_core pointers.
3598 : : */
3599 : 3 : parents = kcalloc(num_parents, sizeof(*parents), GFP_KERNEL);
3600 : 3 : core->parents = parents;
3601 : 3 : if (!parents)
3602 : : return -ENOMEM;
3603 : :
3604 : : /* Copy everything over because it might be __initdata */
3605 : 3 : for (i = 0, parent = parents; i < num_parents; i++, parent++) {
3606 : 3 : parent->index = -1;
3607 : 3 : if (parent_names) {
3608 : : /* throw a WARN if any entries are NULL */
3609 : 3 : WARN(!parent_names[i],
3610 : : "%s: invalid NULL in %s's .parent_names\n",
3611 : : __func__, core->name);
3612 : 3 : ret = clk_cpy_name(&parent->name, parent_names[i],
3613 : : true);
3614 : 0 : } else if (parent_data) {
3615 : 0 : parent->hw = parent_data[i].hw;
3616 : 0 : parent->index = parent_data[i].index;
3617 : 0 : ret = clk_cpy_name(&parent->fw_name,
3618 : : parent_data[i].fw_name, false);
3619 : 0 : if (!ret)
3620 : 0 : ret = clk_cpy_name(&parent->name,
3621 : : parent_data[i].name,
3622 : : false);
3623 : 0 : } else if (parent_hws) {
3624 : 0 : parent->hw = parent_hws[i];
3625 : : } else {
3626 : : ret = -EINVAL;
3627 : 0 : WARN(1, "Must specify parents if num_parents > 0\n");
3628 : : }
3629 : :
3630 : 3 : if (ret) {
3631 : : do {
3632 : 0 : kfree_const(parents[i].name);
3633 : 0 : kfree_const(parents[i].fw_name);
3634 : 0 : } while (--i >= 0);
3635 : 0 : kfree(parents);
3636 : :
3637 : 0 : return ret;
3638 : : }
3639 : : }
3640 : :
3641 : : return 0;
3642 : : }
3643 : :
3644 : 1 : static void clk_core_free_parent_map(struct clk_core *core)
3645 : : {
3646 : 1 : int i = core->num_parents;
3647 : :
3648 : 1 : if (!core->num_parents)
3649 : 1 : return;
3650 : :
3651 : 1 : while (--i >= 0) {
3652 : 1 : kfree_const(core->parents[i].name);
3653 : 1 : kfree_const(core->parents[i].fw_name);
3654 : : }
3655 : :
3656 : 1 : kfree(core->parents);
3657 : : }
3658 : :
3659 : : static struct clk *
3660 : 3 : __clk_register(struct device *dev, struct device_node *np, struct clk_hw *hw)
3661 : : {
3662 : : int ret;
3663 : : struct clk_core *core;
3664 : 3 : const struct clk_init_data *init = hw->init;
3665 : :
3666 : : /*
3667 : : * The init data is not supposed to be used outside of registration path.
3668 : : * Set it to NULL so that provider drivers can't use it either and so that
3669 : : * we catch use of hw->init early on in the core.
3670 : : */
3671 : 3 : hw->init = NULL;
3672 : :
3673 : 3 : core = kzalloc(sizeof(*core), GFP_KERNEL);
3674 : 3 : if (!core) {
3675 : : ret = -ENOMEM;
3676 : : goto fail_out;
3677 : : }
3678 : :
3679 : 3 : core->name = kstrdup_const(init->name, GFP_KERNEL);
3680 : 3 : if (!core->name) {
3681 : : ret = -ENOMEM;
3682 : : goto fail_name;
3683 : : }
3684 : :
3685 : 3 : if (WARN_ON(!init->ops)) {
3686 : : ret = -EINVAL;
3687 : : goto fail_ops;
3688 : : }
3689 : 3 : core->ops = init->ops;
3690 : :
3691 : 3 : if (dev && pm_runtime_enabled(dev))
3692 : 0 : core->rpm_enabled = true;
3693 : 3 : core->dev = dev;
3694 : 3 : core->of_node = np;
3695 : 3 : if (dev && dev->driver)
3696 : 3 : core->owner = dev->driver->owner;
3697 : 3 : core->hw = hw;
3698 : 3 : core->flags = init->flags;
3699 : 3 : core->num_parents = init->num_parents;
3700 : 3 : core->min_rate = 0;
3701 : 3 : core->max_rate = ULONG_MAX;
3702 : 3 : hw->core = core;
3703 : :
3704 : 3 : ret = clk_core_populate_parent_map(core, init);
3705 : 3 : if (ret)
3706 : : goto fail_parents;
3707 : :
3708 : 3 : INIT_HLIST_HEAD(&core->clks);
3709 : :
3710 : : /*
3711 : : * Don't call clk_hw_create_clk() here because that would pin the
3712 : : * provider module to itself and prevent it from ever being removed.
3713 : : */
3714 : 3 : hw->clk = alloc_clk(core, NULL, NULL);
3715 : 3 : if (IS_ERR(hw->clk)) {
3716 : : ret = PTR_ERR(hw->clk);
3717 : 0 : goto fail_create_clk;
3718 : : }
3719 : :
3720 : 3 : clk_core_link_consumer(hw->core, hw->clk);
3721 : :
3722 : 3 : ret = __clk_core_init(core);
3723 : 3 : if (!ret)
3724 : 3 : return hw->clk;
3725 : :
3726 : 1 : clk_prepare_lock();
3727 : 1 : clk_core_unlink_consumer(hw->clk);
3728 : 1 : clk_prepare_unlock();
3729 : :
3730 : 1 : free_clk(hw->clk);
3731 : 1 : hw->clk = NULL;
3732 : :
3733 : : fail_create_clk:
3734 : 1 : clk_core_free_parent_map(core);
3735 : : fail_parents:
3736 : : fail_ops:
3737 : 1 : kfree_const(core->name);
3738 : : fail_name:
3739 : 1 : kfree(core);
3740 : : fail_out:
3741 : 1 : return ERR_PTR(ret);
3742 : : }
3743 : :
3744 : : /**
3745 : : * dev_or_parent_of_node() - Get device node of @dev or @dev's parent
3746 : : * @dev: Device to get device node of
3747 : : *
3748 : : * Return: device node pointer of @dev, or the device node pointer of
3749 : : * @dev->parent if dev doesn't have a device node, or NULL if neither
3750 : : * @dev or @dev->parent have a device node.
3751 : : */
3752 : : static struct device_node *dev_or_parent_of_node(struct device *dev)
3753 : : {
3754 : : struct device_node *np;
3755 : :
3756 : 3 : if (!dev)
3757 : : return NULL;
3758 : :
3759 : : np = dev_of_node(dev);
3760 : 3 : if (!np)
3761 : 0 : np = dev_of_node(dev->parent);
3762 : :
3763 : : return np;
3764 : : }
3765 : :
3766 : : /**
3767 : : * clk_register - allocate a new clock, register it and return an opaque cookie
3768 : : * @dev: device that is registering this clock
3769 : : * @hw: link to hardware-specific clock data
3770 : : *
3771 : : * clk_register is the *deprecated* interface for populating the clock tree with
3772 : : * new clock nodes. Use clk_hw_register() instead.
3773 : : *
3774 : : * Returns: a pointer to the newly allocated struct clk which
3775 : : * cannot be dereferenced by driver code but may be used in conjunction with the
3776 : : * rest of the clock API. In the event of an error clk_register will return an
3777 : : * error code; drivers must test for an error code after calling clk_register.
3778 : : */
3779 : 0 : struct clk *clk_register(struct device *dev, struct clk_hw *hw)
3780 : : {
3781 : 0 : return __clk_register(dev, dev_or_parent_of_node(dev), hw);
3782 : : }
3783 : : EXPORT_SYMBOL_GPL(clk_register);
3784 : :
3785 : : /**
3786 : : * clk_hw_register - register a clk_hw and return an error code
3787 : : * @dev: device that is registering this clock
3788 : : * @hw: link to hardware-specific clock data
3789 : : *
3790 : : * clk_hw_register is the primary interface for populating the clock tree with
3791 : : * new clock nodes. It returns an integer equal to zero indicating success or
3792 : : * less than zero indicating failure. Drivers must test for an error code after
3793 : : * calling clk_hw_register().
3794 : : */
3795 : 3 : int clk_hw_register(struct device *dev, struct clk_hw *hw)
3796 : : {
3797 : 3 : return PTR_ERR_OR_ZERO(__clk_register(dev, dev_or_parent_of_node(dev),
3798 : : hw));
3799 : : }
3800 : : EXPORT_SYMBOL_GPL(clk_hw_register);
3801 : :
3802 : : /*
3803 : : * of_clk_hw_register - register a clk_hw and return an error code
3804 : : * @node: device_node of device that is registering this clock
3805 : : * @hw: link to hardware-specific clock data
3806 : : *
3807 : : * of_clk_hw_register() is the primary interface for populating the clock tree
3808 : : * with new clock nodes when a struct device is not available, but a struct
3809 : : * device_node is. It returns an integer equal to zero indicating success or
3810 : : * less than zero indicating failure. Drivers must test for an error code after
3811 : : * calling of_clk_hw_register().
3812 : : */
3813 : 0 : int of_clk_hw_register(struct device_node *node, struct clk_hw *hw)
3814 : : {
3815 : 0 : return PTR_ERR_OR_ZERO(__clk_register(NULL, node, hw));
3816 : : }
3817 : : EXPORT_SYMBOL_GPL(of_clk_hw_register);
3818 : :
3819 : : /* Free memory allocated for a clock. */
3820 : 0 : static void __clk_release(struct kref *ref)
3821 : : {
3822 : 0 : struct clk_core *core = container_of(ref, struct clk_core, ref);
3823 : :
3824 : : lockdep_assert_held(&prepare_lock);
3825 : :
3826 : 0 : clk_core_free_parent_map(core);
3827 : 0 : kfree_const(core->name);
3828 : 0 : kfree(core);
3829 : 0 : }
3830 : :
3831 : : /*
3832 : : * Empty clk_ops for unregistered clocks. These are used temporarily
3833 : : * after clk_unregister() was called on a clock and until last clock
3834 : : * consumer calls clk_put() and the struct clk object is freed.
3835 : : */
3836 : 0 : static int clk_nodrv_prepare_enable(struct clk_hw *hw)
3837 : : {
3838 : 0 : return -ENXIO;
3839 : : }
3840 : :
3841 : 0 : static void clk_nodrv_disable_unprepare(struct clk_hw *hw)
3842 : : {
3843 : 0 : WARN_ON_ONCE(1);
3844 : 0 : }
3845 : :
3846 : 0 : static int clk_nodrv_set_rate(struct clk_hw *hw, unsigned long rate,
3847 : : unsigned long parent_rate)
3848 : : {
3849 : 0 : return -ENXIO;
3850 : : }
3851 : :
3852 : 0 : static int clk_nodrv_set_parent(struct clk_hw *hw, u8 index)
3853 : : {
3854 : 0 : return -ENXIO;
3855 : : }
3856 : :
3857 : : static const struct clk_ops clk_nodrv_ops = {
3858 : : .enable = clk_nodrv_prepare_enable,
3859 : : .disable = clk_nodrv_disable_unprepare,
3860 : : .prepare = clk_nodrv_prepare_enable,
3861 : : .unprepare = clk_nodrv_disable_unprepare,
3862 : : .set_rate = clk_nodrv_set_rate,
3863 : : .set_parent = clk_nodrv_set_parent,
3864 : : };
3865 : :
3866 : 0 : static void clk_core_evict_parent_cache_subtree(struct clk_core *root,
3867 : : struct clk_core *target)
3868 : : {
3869 : : int i;
3870 : : struct clk_core *child;
3871 : :
3872 : 0 : for (i = 0; i < root->num_parents; i++)
3873 : 0 : if (root->parents[i].core == target)
3874 : 0 : root->parents[i].core = NULL;
3875 : :
3876 : 0 : hlist_for_each_entry(child, &root->children, child_node)
3877 : 0 : clk_core_evict_parent_cache_subtree(child, target);
3878 : 0 : }
3879 : :
3880 : : /* Remove this clk from all parent caches */
3881 : 0 : static void clk_core_evict_parent_cache(struct clk_core *core)
3882 : : {
3883 : : struct hlist_head **lists;
3884 : : struct clk_core *root;
3885 : :
3886 : : lockdep_assert_held(&prepare_lock);
3887 : :
3888 : 0 : for (lists = all_lists; *lists; lists++)
3889 : 0 : hlist_for_each_entry(root, *lists, child_node)
3890 : 0 : clk_core_evict_parent_cache_subtree(root, core);
3891 : :
3892 : 0 : }
3893 : :
3894 : : /**
3895 : : * clk_unregister - unregister a currently registered clock
3896 : : * @clk: clock to unregister
3897 : : */
3898 : 0 : void clk_unregister(struct clk *clk)
3899 : : {
3900 : : unsigned long flags;
3901 : :
3902 : 0 : if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
3903 : 0 : return;
3904 : :
3905 : 0 : clk_debug_unregister(clk->core);
3906 : :
3907 : 0 : clk_prepare_lock();
3908 : :
3909 : 0 : if (clk->core->ops == &clk_nodrv_ops) {
3910 : 0 : pr_err("%s: unregistered clock: %s\n", __func__,
3911 : : clk->core->name);
3912 : 0 : goto unlock;
3913 : : }
3914 : : /*
3915 : : * Assign empty clock ops for consumers that might still hold
3916 : : * a reference to this clock.
3917 : : */
3918 : 0 : flags = clk_enable_lock();
3919 : 0 : clk->core->ops = &clk_nodrv_ops;
3920 : 0 : clk_enable_unlock(flags);
3921 : :
3922 : 0 : if (!hlist_empty(&clk->core->children)) {
3923 : : struct clk_core *child;
3924 : : struct hlist_node *t;
3925 : :
3926 : : /* Reparent all children to the orphan list. */
3927 : 0 : hlist_for_each_entry_safe(child, t, &clk->core->children,
3928 : : child_node)
3929 : 0 : clk_core_set_parent_nolock(child, NULL);
3930 : : }
3931 : :
3932 : 0 : clk_core_evict_parent_cache(clk->core);
3933 : :
3934 : 0 : hlist_del_init(&clk->core->child_node);
3935 : :
3936 : 0 : if (clk->core->prepare_count)
3937 : 0 : pr_warn("%s: unregistering prepared clock: %s\n",
3938 : : __func__, clk->core->name);
3939 : :
3940 : 0 : if (clk->core->protect_count)
3941 : 0 : pr_warn("%s: unregistering protected clock: %s\n",
3942 : : __func__, clk->core->name);
3943 : :
3944 : 0 : kref_put(&clk->core->ref, __clk_release);
3945 : : free_clk(clk);
3946 : : unlock:
3947 : 0 : clk_prepare_unlock();
3948 : : }
3949 : : EXPORT_SYMBOL_GPL(clk_unregister);
3950 : :
3951 : : /**
3952 : : * clk_hw_unregister - unregister a currently registered clk_hw
3953 : : * @hw: hardware-specific clock data to unregister
3954 : : */
3955 : 0 : void clk_hw_unregister(struct clk_hw *hw)
3956 : : {
3957 : 0 : clk_unregister(hw->clk);
3958 : 0 : }
3959 : : EXPORT_SYMBOL_GPL(clk_hw_unregister);
3960 : :
3961 : 0 : static void devm_clk_release(struct device *dev, void *res)
3962 : : {
3963 : 0 : clk_unregister(*(struct clk **)res);
3964 : 0 : }
3965 : :
3966 : 0 : static void devm_clk_hw_release(struct device *dev, void *res)
3967 : : {
3968 : 0 : clk_hw_unregister(*(struct clk_hw **)res);
3969 : 0 : }
3970 : :
3971 : : /**
3972 : : * devm_clk_register - resource managed clk_register()
3973 : : * @dev: device that is registering this clock
3974 : : * @hw: link to hardware-specific clock data
3975 : : *
3976 : : * Managed clk_register(). This function is *deprecated*, use devm_clk_hw_register() instead.
3977 : : *
3978 : : * Clocks returned from this function are automatically clk_unregister()ed on
3979 : : * driver detach. See clk_register() for more information.
3980 : : */
3981 : 0 : struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw)
3982 : : {
3983 : : struct clk *clk;
3984 : : struct clk **clkp;
3985 : :
3986 : : clkp = devres_alloc(devm_clk_release, sizeof(*clkp), GFP_KERNEL);
3987 : 0 : if (!clkp)
3988 : : return ERR_PTR(-ENOMEM);
3989 : :
3990 : 0 : clk = clk_register(dev, hw);
3991 : 0 : if (!IS_ERR(clk)) {
3992 : 0 : *clkp = clk;
3993 : 0 : devres_add(dev, clkp);
3994 : : } else {
3995 : 0 : devres_free(clkp);
3996 : : }
3997 : :
3998 : 0 : return clk;
3999 : : }
4000 : : EXPORT_SYMBOL_GPL(devm_clk_register);
4001 : :
4002 : : /**
4003 : : * devm_clk_hw_register - resource managed clk_hw_register()
4004 : : * @dev: device that is registering this clock
4005 : : * @hw: link to hardware-specific clock data
4006 : : *
4007 : : * Managed clk_hw_register(). Clocks registered by this function are
4008 : : * automatically clk_hw_unregister()ed on driver detach. See clk_hw_register()
4009 : : * for more information.
4010 : : */
4011 : 3 : int devm_clk_hw_register(struct device *dev, struct clk_hw *hw)
4012 : : {
4013 : : struct clk_hw **hwp;
4014 : : int ret;
4015 : :
4016 : : hwp = devres_alloc(devm_clk_hw_release, sizeof(*hwp), GFP_KERNEL);
4017 : 3 : if (!hwp)
4018 : : return -ENOMEM;
4019 : :
4020 : 3 : ret = clk_hw_register(dev, hw);
4021 : 3 : if (!ret) {
4022 : 3 : *hwp = hw;
4023 : 3 : devres_add(dev, hwp);
4024 : : } else {
4025 : 1 : devres_free(hwp);
4026 : : }
4027 : :
4028 : 3 : return ret;
4029 : : }
4030 : : EXPORT_SYMBOL_GPL(devm_clk_hw_register);
4031 : :
4032 : 0 : static int devm_clk_match(struct device *dev, void *res, void *data)
4033 : : {
4034 : : struct clk *c = res;
4035 : 0 : if (WARN_ON(!c))
4036 : : return 0;
4037 : 0 : return c == data;
4038 : : }
4039 : :
4040 : 0 : static int devm_clk_hw_match(struct device *dev, void *res, void *data)
4041 : : {
4042 : : struct clk_hw *hw = res;
4043 : :
4044 : 0 : if (WARN_ON(!hw))
4045 : : return 0;
4046 : 0 : return hw == data;
4047 : : }
4048 : :
4049 : : /**
4050 : : * devm_clk_unregister - resource managed clk_unregister()
4051 : : * @clk: clock to unregister
4052 : : *
4053 : : * Deallocate a clock allocated with devm_clk_register(). Normally
4054 : : * this function will not need to be called and the resource management
4055 : : * code will ensure that the resource is freed.
4056 : : */
4057 : 0 : void devm_clk_unregister(struct device *dev, struct clk *clk)
4058 : : {
4059 : 0 : WARN_ON(devres_release(dev, devm_clk_release, devm_clk_match, clk));
4060 : 0 : }
4061 : : EXPORT_SYMBOL_GPL(devm_clk_unregister);
4062 : :
4063 : : /**
4064 : : * devm_clk_hw_unregister - resource managed clk_hw_unregister()
4065 : : * @dev: device that is unregistering the hardware-specific clock data
4066 : : * @hw: link to hardware-specific clock data
4067 : : *
4068 : : * Unregister a clk_hw registered with devm_clk_hw_register(). Normally
4069 : : * this function will not need to be called and the resource management
4070 : : * code will ensure that the resource is freed.
4071 : : */
4072 : 0 : void devm_clk_hw_unregister(struct device *dev, struct clk_hw *hw)
4073 : : {
4074 : 0 : WARN_ON(devres_release(dev, devm_clk_hw_release, devm_clk_hw_match,
4075 : : hw));
4076 : 0 : }
4077 : : EXPORT_SYMBOL_GPL(devm_clk_hw_unregister);
4078 : :
4079 : : /*
4080 : : * clkdev helpers
4081 : : */
4082 : :
4083 : 3 : void __clk_put(struct clk *clk)
4084 : : {
4085 : : struct module *owner;
4086 : :
4087 : 3 : if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
4088 : 3 : return;
4089 : :
4090 : 3 : clk_prepare_lock();
4091 : :
4092 : : /*
4093 : : * Before calling clk_put, all calls to clk_rate_exclusive_get() from a
4094 : : * given user should be balanced with calls to clk_rate_exclusive_put()
4095 : : * and by that same consumer
4096 : : */
4097 : 3 : if (WARN_ON(clk->exclusive_count)) {
4098 : : /* We voiced our concern, let's sanitize the situation */
4099 : 0 : clk->core->protect_count -= (clk->exclusive_count - 1);
4100 : 0 : clk_core_rate_unprotect(clk->core);
4101 : 0 : clk->exclusive_count = 0;
4102 : : }
4103 : :
4104 : : hlist_del(&clk->clks_node);
4105 : 3 : if (clk->min_rate > clk->core->req_rate ||
4106 : 3 : clk->max_rate < clk->core->req_rate)
4107 : 0 : clk_core_set_rate_nolock(clk->core, clk->core->req_rate);
4108 : :
4109 : 3 : owner = clk->core->owner;
4110 : 3 : kref_put(&clk->core->ref, __clk_release);
4111 : :
4112 : 3 : clk_prepare_unlock();
4113 : :
4114 : 3 : module_put(owner);
4115 : :
4116 : : free_clk(clk);
4117 : : }
4118 : :
4119 : : /*** clk rate change notifiers ***/
4120 : :
4121 : : /**
4122 : : * clk_notifier_register - add a clk rate change notifier
4123 : : * @clk: struct clk * to watch
4124 : : * @nb: struct notifier_block * with callback info
4125 : : *
4126 : : * Request notification when clk's rate changes. This uses an SRCU
4127 : : * notifier because we want it to block and notifier unregistrations are
4128 : : * uncommon. The callbacks associated with the notifier must not
4129 : : * re-enter into the clk framework by calling any top-level clk APIs;
4130 : : * this will cause a nested prepare_lock mutex.
4131 : : *
4132 : : * In all notification cases (pre, post and abort rate change) the original
4133 : : * clock rate is passed to the callback via struct clk_notifier_data.old_rate
4134 : : * and the new frequency is passed via struct clk_notifier_data.new_rate.
4135 : : *
4136 : : * clk_notifier_register() must be called from non-atomic context.
4137 : : * Returns -EINVAL if called with null arguments, -ENOMEM upon
4138 : : * allocation failure; otherwise, passes along the return value of
4139 : : * srcu_notifier_chain_register().
4140 : : */
4141 : 0 : int clk_notifier_register(struct clk *clk, struct notifier_block *nb)
4142 : : {
4143 : : struct clk_notifier *cn;
4144 : : int ret = -ENOMEM;
4145 : :
4146 : 0 : if (!clk || !nb)
4147 : : return -EINVAL;
4148 : :
4149 : 0 : clk_prepare_lock();
4150 : :
4151 : : /* search the list of notifiers for this clk */
4152 : 0 : list_for_each_entry(cn, &clk_notifier_list, node)
4153 : 0 : if (cn->clk == clk)
4154 : : break;
4155 : :
4156 : : /* if clk wasn't in the notifier list, allocate new clk_notifier */
4157 : 0 : if (cn->clk != clk) {
4158 : 0 : cn = kzalloc(sizeof(*cn), GFP_KERNEL);
4159 : 0 : if (!cn)
4160 : : goto out;
4161 : :
4162 : 0 : cn->clk = clk;
4163 : 0 : srcu_init_notifier_head(&cn->notifier_head);
4164 : :
4165 : 0 : list_add(&cn->node, &clk_notifier_list);
4166 : : }
4167 : :
4168 : 0 : ret = srcu_notifier_chain_register(&cn->notifier_head, nb);
4169 : :
4170 : 0 : clk->core->notifier_count++;
4171 : :
4172 : : out:
4173 : 0 : clk_prepare_unlock();
4174 : :
4175 : 0 : return ret;
4176 : : }
4177 : : EXPORT_SYMBOL_GPL(clk_notifier_register);
4178 : :
4179 : : /**
4180 : : * clk_notifier_unregister - remove a clk rate change notifier
4181 : : * @clk: struct clk *
4182 : : * @nb: struct notifier_block * with callback info
4183 : : *
4184 : : * Request no further notification for changes to 'clk' and frees memory
4185 : : * allocated in clk_notifier_register.
4186 : : *
4187 : : * Returns -EINVAL if called with null arguments; otherwise, passes
4188 : : * along the return value of srcu_notifier_chain_unregister().
4189 : : */
4190 : 0 : int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb)
4191 : : {
4192 : : struct clk_notifier *cn = NULL;
4193 : : int ret = -EINVAL;
4194 : :
4195 : 0 : if (!clk || !nb)
4196 : : return -EINVAL;
4197 : :
4198 : 0 : clk_prepare_lock();
4199 : :
4200 : 0 : list_for_each_entry(cn, &clk_notifier_list, node)
4201 : 0 : if (cn->clk == clk)
4202 : : break;
4203 : :
4204 : 0 : if (cn->clk == clk) {
4205 : 0 : ret = srcu_notifier_chain_unregister(&cn->notifier_head, nb);
4206 : :
4207 : 0 : clk->core->notifier_count--;
4208 : :
4209 : : /* XXX the notifier code should handle this better */
4210 : 0 : if (!cn->notifier_head.head) {
4211 : 0 : srcu_cleanup_notifier_head(&cn->notifier_head);
4212 : : list_del(&cn->node);
4213 : 0 : kfree(cn);
4214 : : }
4215 : :
4216 : : } else {
4217 : : ret = -ENOENT;
4218 : : }
4219 : :
4220 : 0 : clk_prepare_unlock();
4221 : :
4222 : 0 : return ret;
4223 : : }
4224 : : EXPORT_SYMBOL_GPL(clk_notifier_unregister);
4225 : :
4226 : : #ifdef CONFIG_OF
4227 : : static void clk_core_reparent_orphans(void)
4228 : : {
4229 : 3 : clk_prepare_lock();
4230 : 3 : clk_core_reparent_orphans_nolock();
4231 : 3 : clk_prepare_unlock();
4232 : : }
4233 : :
4234 : : /**
4235 : : * struct of_clk_provider - Clock provider registration structure
4236 : : * @link: Entry in global list of clock providers
4237 : : * @node: Pointer to device tree node of clock provider
4238 : : * @get: Get clock callback. Returns NULL or a struct clk for the
4239 : : * given clock specifier
4240 : : * @data: context pointer to be passed into @get callback
4241 : : */
4242 : : struct of_clk_provider {
4243 : : struct list_head link;
4244 : :
4245 : : struct device_node *node;
4246 : : struct clk *(*get)(struct of_phandle_args *clkspec, void *data);
4247 : : struct clk_hw *(*get_hw)(struct of_phandle_args *clkspec, void *data);
4248 : : void *data;
4249 : : };
4250 : :
4251 : : extern struct of_device_id __clk_of_table;
4252 : : static const struct of_device_id __clk_of_table_sentinel
4253 : : __used __section(__clk_of_table_end);
4254 : :
4255 : : static LIST_HEAD(of_clk_providers);
4256 : : static DEFINE_MUTEX(of_clk_mutex);
4257 : :
4258 : 0 : struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
4259 : : void *data)
4260 : : {
4261 : 0 : return data;
4262 : : }
4263 : : EXPORT_SYMBOL_GPL(of_clk_src_simple_get);
4264 : :
4265 : 0 : struct clk_hw *of_clk_hw_simple_get(struct of_phandle_args *clkspec, void *data)
4266 : : {
4267 : 0 : return data;
4268 : : }
4269 : : EXPORT_SYMBOL_GPL(of_clk_hw_simple_get);
4270 : :
4271 : 0 : struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data)
4272 : : {
4273 : : struct clk_onecell_data *clk_data = data;
4274 : 0 : unsigned int idx = clkspec->args[0];
4275 : :
4276 : 0 : if (idx >= clk_data->clk_num) {
4277 : 0 : pr_err("%s: invalid clock index %u\n", __func__, idx);
4278 : 0 : return ERR_PTR(-EINVAL);
4279 : : }
4280 : :
4281 : 0 : return clk_data->clks[idx];
4282 : : }
4283 : : EXPORT_SYMBOL_GPL(of_clk_src_onecell_get);
4284 : :
4285 : : struct clk_hw *
4286 : 3 : of_clk_hw_onecell_get(struct of_phandle_args *clkspec, void *data)
4287 : : {
4288 : : struct clk_hw_onecell_data *hw_data = data;
4289 : 3 : unsigned int idx = clkspec->args[0];
4290 : :
4291 : 3 : if (idx >= hw_data->num) {
4292 : 0 : pr_err("%s: invalid index %u\n", __func__, idx);
4293 : 0 : return ERR_PTR(-EINVAL);
4294 : : }
4295 : :
4296 : 3 : return hw_data->hws[idx];
4297 : : }
4298 : : EXPORT_SYMBOL_GPL(of_clk_hw_onecell_get);
4299 : :
4300 : : /**
4301 : : * of_clk_add_provider() - Register a clock provider for a node
4302 : : * @np: Device node pointer associated with clock provider
4303 : : * @clk_src_get: callback for decoding clock
4304 : : * @data: context pointer for @clk_src_get callback.
4305 : : *
4306 : : * This function is *deprecated*. Use of_clk_add_hw_provider() instead.
4307 : : */
4308 : 3 : int of_clk_add_provider(struct device_node *np,
4309 : : struct clk *(*clk_src_get)(struct of_phandle_args *clkspec,
4310 : : void *data),
4311 : : void *data)
4312 : : {
4313 : : struct of_clk_provider *cp;
4314 : : int ret;
4315 : :
4316 : 3 : cp = kzalloc(sizeof(*cp), GFP_KERNEL);
4317 : 3 : if (!cp)
4318 : : return -ENOMEM;
4319 : :
4320 : 3 : cp->node = of_node_get(np);
4321 : 3 : cp->data = data;
4322 : 3 : cp->get = clk_src_get;
4323 : :
4324 : 3 : mutex_lock(&of_clk_mutex);
4325 : 3 : list_add(&cp->link, &of_clk_providers);
4326 : 3 : mutex_unlock(&of_clk_mutex);
4327 : : pr_debug("Added clock from %pOF\n", np);
4328 : :
4329 : : clk_core_reparent_orphans();
4330 : :
4331 : 3 : ret = of_clk_set_defaults(np, true);
4332 : 3 : if (ret < 0)
4333 : 0 : of_clk_del_provider(np);
4334 : :
4335 : 3 : return ret;
4336 : : }
4337 : : EXPORT_SYMBOL_GPL(of_clk_add_provider);
4338 : :
4339 : : /**
4340 : : * of_clk_add_hw_provider() - Register a clock provider for a node
4341 : : * @np: Device node pointer associated with clock provider
4342 : : * @get: callback for decoding clk_hw
4343 : : * @data: context pointer for @get callback.
4344 : : */
4345 : 3 : int of_clk_add_hw_provider(struct device_node *np,
4346 : : struct clk_hw *(*get)(struct of_phandle_args *clkspec,
4347 : : void *data),
4348 : : void *data)
4349 : : {
4350 : : struct of_clk_provider *cp;
4351 : : int ret;
4352 : :
4353 : 3 : cp = kzalloc(sizeof(*cp), GFP_KERNEL);
4354 : 3 : if (!cp)
4355 : : return -ENOMEM;
4356 : :
4357 : 3 : cp->node = of_node_get(np);
4358 : 3 : cp->data = data;
4359 : 3 : cp->get_hw = get;
4360 : :
4361 : 3 : mutex_lock(&of_clk_mutex);
4362 : 3 : list_add(&cp->link, &of_clk_providers);
4363 : 3 : mutex_unlock(&of_clk_mutex);
4364 : : pr_debug("Added clk_hw provider from %pOF\n", np);
4365 : :
4366 : : clk_core_reparent_orphans();
4367 : :
4368 : 3 : ret = of_clk_set_defaults(np, true);
4369 : 3 : if (ret < 0)
4370 : 0 : of_clk_del_provider(np);
4371 : :
4372 : 3 : return ret;
4373 : : }
4374 : : EXPORT_SYMBOL_GPL(of_clk_add_hw_provider);
4375 : :
4376 : 0 : static void devm_of_clk_release_provider(struct device *dev, void *res)
4377 : : {
4378 : 0 : of_clk_del_provider(*(struct device_node **)res);
4379 : 0 : }
4380 : :
4381 : : /*
4382 : : * We allow a child device to use its parent device as the clock provider node
4383 : : * for cases like MFD sub-devices where the child device driver wants to use
4384 : : * devm_*() APIs but not list the device in DT as a sub-node.
4385 : : */
4386 : 3 : static struct device_node *get_clk_provider_node(struct device *dev)
4387 : : {
4388 : : struct device_node *np, *parent_np;
4389 : :
4390 : 3 : np = dev->of_node;
4391 : 3 : parent_np = dev->parent ? dev->parent->of_node : NULL;
4392 : :
4393 : 3 : if (!of_find_property(np, "#clock-cells", NULL))
4394 : 0 : if (of_find_property(parent_np, "#clock-cells", NULL))
4395 : : np = parent_np;
4396 : :
4397 : 3 : return np;
4398 : : }
4399 : :
4400 : : /**
4401 : : * devm_of_clk_add_hw_provider() - Managed clk provider node registration
4402 : : * @dev: Device acting as the clock provider (used for DT node and lifetime)
4403 : : * @get: callback for decoding clk_hw
4404 : : * @data: context pointer for @get callback
4405 : : *
4406 : : * Registers clock provider for given device's node. If the device has no DT
4407 : : * node or if the device node lacks of clock provider information (#clock-cells)
4408 : : * then the parent device's node is scanned for this information. If parent node
4409 : : * has the #clock-cells then it is used in registration. Provider is
4410 : : * automatically released at device exit.
4411 : : *
4412 : : * Return: 0 on success or an errno on failure.
4413 : : */
4414 : 3 : int devm_of_clk_add_hw_provider(struct device *dev,
4415 : : struct clk_hw *(*get)(struct of_phandle_args *clkspec,
4416 : : void *data),
4417 : : void *data)
4418 : : {
4419 : : struct device_node **ptr, *np;
4420 : : int ret;
4421 : :
4422 : : ptr = devres_alloc(devm_of_clk_release_provider, sizeof(*ptr),
4423 : : GFP_KERNEL);
4424 : 3 : if (!ptr)
4425 : : return -ENOMEM;
4426 : :
4427 : 3 : np = get_clk_provider_node(dev);
4428 : 3 : ret = of_clk_add_hw_provider(np, get, data);
4429 : 3 : if (!ret) {
4430 : 3 : *ptr = np;
4431 : 3 : devres_add(dev, ptr);
4432 : : } else {
4433 : 0 : devres_free(ptr);
4434 : : }
4435 : :
4436 : 3 : return ret;
4437 : : }
4438 : : EXPORT_SYMBOL_GPL(devm_of_clk_add_hw_provider);
4439 : :
4440 : : /**
4441 : : * of_clk_del_provider() - Remove a previously registered clock provider
4442 : : * @np: Device node pointer associated with clock provider
4443 : : */
4444 : 0 : void of_clk_del_provider(struct device_node *np)
4445 : : {
4446 : : struct of_clk_provider *cp;
4447 : :
4448 : 0 : mutex_lock(&of_clk_mutex);
4449 : 0 : list_for_each_entry(cp, &of_clk_providers, link) {
4450 : 0 : if (cp->node == np) {
4451 : : list_del(&cp->link);
4452 : 0 : of_node_put(cp->node);
4453 : 0 : kfree(cp);
4454 : 0 : break;
4455 : : }
4456 : : }
4457 : 0 : mutex_unlock(&of_clk_mutex);
4458 : 0 : }
4459 : : EXPORT_SYMBOL_GPL(of_clk_del_provider);
4460 : :
4461 : 0 : static int devm_clk_provider_match(struct device *dev, void *res, void *data)
4462 : : {
4463 : : struct device_node **np = res;
4464 : :
4465 : 0 : if (WARN_ON(!np || !*np))
4466 : : return 0;
4467 : :
4468 : 0 : return *np == data;
4469 : : }
4470 : :
4471 : : /**
4472 : : * devm_of_clk_del_provider() - Remove clock provider registered using devm
4473 : : * @dev: Device to whose lifetime the clock provider was bound
4474 : : */
4475 : 0 : void devm_of_clk_del_provider(struct device *dev)
4476 : : {
4477 : : int ret;
4478 : 0 : struct device_node *np = get_clk_provider_node(dev);
4479 : :
4480 : 0 : ret = devres_release(dev, devm_of_clk_release_provider,
4481 : : devm_clk_provider_match, np);
4482 : :
4483 : 0 : WARN_ON(ret);
4484 : 0 : }
4485 : : EXPORT_SYMBOL(devm_of_clk_del_provider);
4486 : :
4487 : : /**
4488 : : * of_parse_clkspec() - Parse a DT clock specifier for a given device node
4489 : : * @np: device node to parse clock specifier from
4490 : : * @index: index of phandle to parse clock out of. If index < 0, @name is used
4491 : : * @name: clock name to find and parse. If name is NULL, the index is used
4492 : : * @out_args: Result of parsing the clock specifier
4493 : : *
4494 : : * Parses a device node's "clocks" and "clock-names" properties to find the
4495 : : * phandle and cells for the index or name that is desired. The resulting clock
4496 : : * specifier is placed into @out_args, or an errno is returned when there's a
4497 : : * parsing error. The @index argument is ignored if @name is non-NULL.
4498 : : *
4499 : : * Example:
4500 : : *
4501 : : * phandle1: clock-controller@1 {
4502 : : * #clock-cells = <2>;
4503 : : * }
4504 : : *
4505 : : * phandle2: clock-controller@2 {
4506 : : * #clock-cells = <1>;
4507 : : * }
4508 : : *
4509 : : * clock-consumer@3 {
4510 : : * clocks = <&phandle1 1 2 &phandle2 3>;
4511 : : * clock-names = "name1", "name2";
4512 : : * }
4513 : : *
4514 : : * To get a device_node for `clock-controller@2' node you may call this
4515 : : * function a few different ways:
4516 : : *
4517 : : * of_parse_clkspec(clock-consumer@3, -1, "name2", &args);
4518 : : * of_parse_clkspec(clock-consumer@3, 1, NULL, &args);
4519 : : * of_parse_clkspec(clock-consumer@3, 1, "name2", &args);
4520 : : *
4521 : : * Return: 0 upon successfully parsing the clock specifier. Otherwise, -ENOENT
4522 : : * if @name is NULL or -EINVAL if @name is non-NULL and it can't be found in
4523 : : * the "clock-names" property of @np.
4524 : : */
4525 : 3 : static int of_parse_clkspec(const struct device_node *np, int index,
4526 : : const char *name, struct of_phandle_args *out_args)
4527 : : {
4528 : : int ret = -ENOENT;
4529 : :
4530 : : /* Walk up the tree of devices looking for a clock property that matches */
4531 : 3 : while (np) {
4532 : : /*
4533 : : * For named clocks, first look up the name in the
4534 : : * "clock-names" property. If it cannot be found, then index
4535 : : * will be an error code and of_parse_phandle_with_args() will
4536 : : * return -EINVAL.
4537 : : */
4538 : 3 : if (name)
4539 : 3 : index = of_property_match_string(np, "clock-names", name);
4540 : 3 : ret = of_parse_phandle_with_args(np, "clocks", "#clock-cells",
4541 : : index, out_args);
4542 : 3 : if (!ret)
4543 : : break;
4544 : 3 : if (name && index >= 0)
4545 : : break;
4546 : :
4547 : : /*
4548 : : * No matching clock found on this node. If the parent node
4549 : : * has a "clock-ranges" property, then we can try one of its
4550 : : * clocks.
4551 : : */
4552 : 3 : np = np->parent;
4553 : 3 : if (np && !of_get_property(np, "clock-ranges", NULL))
4554 : : break;
4555 : : index = 0;
4556 : : }
4557 : :
4558 : 3 : return ret;
4559 : : }
4560 : :
4561 : : static struct clk_hw *
4562 : 3 : __of_clk_get_hw_from_provider(struct of_clk_provider *provider,
4563 : : struct of_phandle_args *clkspec)
4564 : : {
4565 : : struct clk *clk;
4566 : :
4567 : 3 : if (provider->get_hw)
4568 : 3 : return provider->get_hw(clkspec, provider->data);
4569 : :
4570 : 0 : clk = provider->get(clkspec, provider->data);
4571 : 0 : if (IS_ERR(clk))
4572 : : return ERR_CAST(clk);
4573 : 0 : return __clk_get_hw(clk);
4574 : : }
4575 : :
4576 : : static struct clk_hw *
4577 : 3 : of_clk_get_hw_from_clkspec(struct of_phandle_args *clkspec)
4578 : : {
4579 : : struct of_clk_provider *provider;
4580 : : struct clk_hw *hw = ERR_PTR(-EPROBE_DEFER);
4581 : :
4582 : 3 : if (!clkspec)
4583 : : return ERR_PTR(-EINVAL);
4584 : :
4585 : 3 : mutex_lock(&of_clk_mutex);
4586 : 3 : list_for_each_entry(provider, &of_clk_providers, link) {
4587 : 3 : if (provider->node == clkspec->np) {
4588 : 3 : hw = __of_clk_get_hw_from_provider(provider, clkspec);
4589 : 3 : if (!IS_ERR(hw))
4590 : : break;
4591 : : }
4592 : : }
4593 : 3 : mutex_unlock(&of_clk_mutex);
4594 : :
4595 : 3 : return hw;
4596 : : }
4597 : :
4598 : : /**
4599 : : * of_clk_get_from_provider() - Lookup a clock from a clock provider
4600 : : * @clkspec: pointer to a clock specifier data structure
4601 : : *
4602 : : * This function looks up a struct clk from the registered list of clock
4603 : : * providers, an input is a clock specifier data structure as returned
4604 : : * from the of_parse_phandle_with_args() function call.
4605 : : */
4606 : 0 : struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
4607 : : {
4608 : 0 : struct clk_hw *hw = of_clk_get_hw_from_clkspec(clkspec);
4609 : :
4610 : 0 : return clk_hw_create_clk(NULL, hw, NULL, __func__);
4611 : : }
4612 : : EXPORT_SYMBOL_GPL(of_clk_get_from_provider);
4613 : :
4614 : 3 : struct clk_hw *of_clk_get_hw(struct device_node *np, int index,
4615 : : const char *con_id)
4616 : : {
4617 : : int ret;
4618 : : struct clk_hw *hw;
4619 : : struct of_phandle_args clkspec;
4620 : :
4621 : 3 : ret = of_parse_clkspec(np, index, con_id, &clkspec);
4622 : 3 : if (ret)
4623 : 3 : return ERR_PTR(ret);
4624 : :
4625 : 3 : hw = of_clk_get_hw_from_clkspec(&clkspec);
4626 : 3 : of_node_put(clkspec.np);
4627 : :
4628 : 3 : return hw;
4629 : : }
4630 : :
4631 : 3 : static struct clk *__of_clk_get(struct device_node *np,
4632 : : int index, const char *dev_id,
4633 : : const char *con_id)
4634 : : {
4635 : 3 : struct clk_hw *hw = of_clk_get_hw(np, index, con_id);
4636 : :
4637 : 3 : return clk_hw_create_clk(NULL, hw, dev_id, con_id);
4638 : : }
4639 : :
4640 : 0 : struct clk *of_clk_get(struct device_node *np, int index)
4641 : : {
4642 : 3 : return __of_clk_get(np, index, np->full_name, NULL);
4643 : : }
4644 : : EXPORT_SYMBOL(of_clk_get);
4645 : :
4646 : : /**
4647 : : * of_clk_get_by_name() - Parse and lookup a clock referenced by a device node
4648 : : * @np: pointer to clock consumer node
4649 : : * @name: name of consumer's clock input, or NULL for the first clock reference
4650 : : *
4651 : : * This function parses the clocks and clock-names properties,
4652 : : * and uses them to look up the struct clk from the registered list of clock
4653 : : * providers.
4654 : : */
4655 : 0 : struct clk *of_clk_get_by_name(struct device_node *np, const char *name)
4656 : : {
4657 : 0 : if (!np)
4658 : : return ERR_PTR(-ENOENT);
4659 : :
4660 : 0 : return __of_clk_get(np, 0, np->full_name, name);
4661 : : }
4662 : : EXPORT_SYMBOL(of_clk_get_by_name);
4663 : :
4664 : : /**
4665 : : * of_clk_get_parent_count() - Count the number of clocks a device node has
4666 : : * @np: device node to count
4667 : : *
4668 : : * Returns: The number of clocks that are possible parents of this node
4669 : : */
4670 : 0 : unsigned int of_clk_get_parent_count(struct device_node *np)
4671 : : {
4672 : : int count;
4673 : :
4674 : 0 : count = of_count_phandle_with_args(np, "clocks", "#clock-cells");
4675 : 0 : if (count < 0)
4676 : : return 0;
4677 : :
4678 : 0 : return count;
4679 : : }
4680 : : EXPORT_SYMBOL_GPL(of_clk_get_parent_count);
4681 : :
4682 : 3 : const char *of_clk_get_parent_name(struct device_node *np, int index)
4683 : : {
4684 : : struct of_phandle_args clkspec;
4685 : : struct property *prop;
4686 : : const char *clk_name;
4687 : : const __be32 *vp;
4688 : : u32 pv;
4689 : : int rc;
4690 : : int count;
4691 : : struct clk *clk;
4692 : :
4693 : 3 : rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
4694 : : &clkspec);
4695 : 3 : if (rc)
4696 : : return NULL;
4697 : :
4698 : 3 : index = clkspec.args_count ? clkspec.args[0] : 0;
4699 : : count = 0;
4700 : :
4701 : : /* if there is an indices property, use it to transfer the index
4702 : : * specified into an array offset for the clock-output-names property.
4703 : : */
4704 : 3 : of_property_for_each_u32(clkspec.np, "clock-indices", prop, vp, pv) {
4705 : 0 : if (index == pv) {
4706 : 0 : index = count;
4707 : 0 : break;
4708 : : }
4709 : 0 : count++;
4710 : : }
4711 : : /* We went off the end of 'clock-indices' without finding it */
4712 : 3 : if (prop && !vp)
4713 : : return NULL;
4714 : :
4715 : 3 : if (of_property_read_string_index(clkspec.np, "clock-output-names",
4716 : : index,
4717 : : &clk_name) < 0) {
4718 : : /*
4719 : : * Best effort to get the name if the clock has been
4720 : : * registered with the framework. If the clock isn't
4721 : : * registered, we return the node name as the name of
4722 : : * the clock as long as #clock-cells = 0.
4723 : : */
4724 : 0 : clk = of_clk_get_from_provider(&clkspec);
4725 : 0 : if (IS_ERR(clk)) {
4726 : 0 : if (clkspec.args_count == 0)
4727 : 0 : clk_name = clkspec.np->name;
4728 : : else
4729 : 0 : clk_name = NULL;
4730 : : } else {
4731 : 0 : clk_name = __clk_get_name(clk);
4732 : 0 : clk_put(clk);
4733 : : }
4734 : : }
4735 : :
4736 : :
4737 : 3 : of_node_put(clkspec.np);
4738 : 3 : return clk_name;
4739 : : }
4740 : : EXPORT_SYMBOL_GPL(of_clk_get_parent_name);
4741 : :
4742 : : /**
4743 : : * of_clk_parent_fill() - Fill @parents with names of @np's parents and return
4744 : : * number of parents
4745 : : * @np: Device node pointer associated with clock provider
4746 : : * @parents: pointer to char array that hold the parents' names
4747 : : * @size: size of the @parents array
4748 : : *
4749 : : * Return: number of parents for the clock node.
4750 : : */
4751 : 3 : int of_clk_parent_fill(struct device_node *np, const char **parents,
4752 : : unsigned int size)
4753 : : {
4754 : : unsigned int i = 0;
4755 : :
4756 : 3 : while (i < size && (parents[i] = of_clk_get_parent_name(np, i)) != NULL)
4757 : 3 : i++;
4758 : :
4759 : 3 : return i;
4760 : : }
4761 : : EXPORT_SYMBOL_GPL(of_clk_parent_fill);
4762 : :
4763 : : struct clock_provider {
4764 : : void (*clk_init_cb)(struct device_node *);
4765 : : struct device_node *np;
4766 : : struct list_head node;
4767 : : };
4768 : :
4769 : : /*
4770 : : * This function looks for a parent clock. If there is one, then it
4771 : : * checks that the provider for this parent clock was initialized, in
4772 : : * this case the parent clock will be ready.
4773 : : */
4774 : 3 : static int parent_ready(struct device_node *np)
4775 : : {
4776 : : int i = 0;
4777 : :
4778 : : while (true) {
4779 : : struct clk *clk = of_clk_get(np, i);
4780 : :
4781 : : /* this parent is ready we can check the next one */
4782 : 3 : if (!IS_ERR(clk)) {
4783 : 0 : clk_put(clk);
4784 : 0 : i++;
4785 : 0 : continue;
4786 : : }
4787 : :
4788 : : /* at least one parent is not ready, we exit now */
4789 : 3 : if (PTR_ERR(clk) == -EPROBE_DEFER)
4790 : : return 0;
4791 : :
4792 : : /*
4793 : : * Here we make assumption that the device tree is
4794 : : * written correctly. So an error means that there is
4795 : : * no more parent. As we didn't exit yet, then the
4796 : : * previous parent are ready. If there is no clock
4797 : : * parent, no need to wait for them, then we can
4798 : : * consider their absence as being ready
4799 : : */
4800 : 3 : return 1;
4801 : 0 : }
4802 : : }
4803 : :
4804 : : /**
4805 : : * of_clk_detect_critical() - set CLK_IS_CRITICAL flag from Device Tree
4806 : : * @np: Device node pointer associated with clock provider
4807 : : * @index: clock index
4808 : : * @flags: pointer to top-level framework flags
4809 : : *
4810 : : * Detects if the clock-critical property exists and, if so, sets the
4811 : : * corresponding CLK_IS_CRITICAL flag.
4812 : : *
4813 : : * Do not use this function. It exists only for legacy Device Tree
4814 : : * bindings, such as the one-clock-per-node style that are outdated.
4815 : : * Those bindings typically put all clock data into .dts and the Linux
4816 : : * driver has no clock data, thus making it impossible to set this flag
4817 : : * correctly from the driver. Only those drivers may call
4818 : : * of_clk_detect_critical from their setup functions.
4819 : : *
4820 : : * Return: error code or zero on success
4821 : : */
4822 : 0 : int of_clk_detect_critical(struct device_node *np,
4823 : : int index, unsigned long *flags)
4824 : : {
4825 : : struct property *prop;
4826 : : const __be32 *cur;
4827 : : uint32_t idx;
4828 : :
4829 : 0 : if (!np || !flags)
4830 : : return -EINVAL;
4831 : :
4832 : 0 : of_property_for_each_u32(np, "clock-critical", prop, cur, idx)
4833 : 0 : if (index == idx)
4834 : 0 : *flags |= CLK_IS_CRITICAL;
4835 : :
4836 : : return 0;
4837 : : }
4838 : :
4839 : : /**
4840 : : * of_clk_init() - Scan and init clock providers from the DT
4841 : : * @matches: array of compatible values and init functions for providers.
4842 : : *
4843 : : * This function scans the device tree for matching clock providers
4844 : : * and calls their initialization functions. It also does it by trying
4845 : : * to follow the dependencies.
4846 : : */
4847 : 3 : void __init of_clk_init(const struct of_device_id *matches)
4848 : : {
4849 : : const struct of_device_id *match;
4850 : : struct device_node *np;
4851 : : struct clock_provider *clk_provider, *next;
4852 : : bool is_init_done;
4853 : : bool force = false;
4854 : 3 : LIST_HEAD(clk_provider_list);
4855 : :
4856 : 3 : if (!matches)
4857 : : matches = &__clk_of_table;
4858 : :
4859 : : /* First prepare the list of the clocks providers */
4860 : 3 : for_each_matching_node_and_match(np, matches, &match) {
4861 : : struct clock_provider *parent;
4862 : :
4863 : 3 : if (!of_device_is_available(np))
4864 : 0 : continue;
4865 : :
4866 : 3 : parent = kzalloc(sizeof(*parent), GFP_KERNEL);
4867 : 3 : if (!parent) {
4868 : 0 : list_for_each_entry_safe(clk_provider, next,
4869 : : &clk_provider_list, node) {
4870 : : list_del(&clk_provider->node);
4871 : 0 : of_node_put(clk_provider->np);
4872 : 0 : kfree(clk_provider);
4873 : : }
4874 : 0 : of_node_put(np);
4875 : 3 : return;
4876 : : }
4877 : :
4878 : 3 : parent->clk_init_cb = match->data;
4879 : 3 : parent->np = of_node_get(np);
4880 : 3 : list_add_tail(&parent->node, &clk_provider_list);
4881 : : }
4882 : :
4883 : 3 : while (!list_empty(&clk_provider_list)) {
4884 : : is_init_done = false;
4885 : 3 : list_for_each_entry_safe(clk_provider, next,
4886 : : &clk_provider_list, node) {
4887 : 3 : if (force || parent_ready(clk_provider->np)) {
4888 : :
4889 : : /* Don't populate platform devices */
4890 : 3 : of_node_set_flag(clk_provider->np,
4891 : : OF_POPULATED);
4892 : :
4893 : 3 : clk_provider->clk_init_cb(clk_provider->np);
4894 : 3 : of_clk_set_defaults(clk_provider->np, true);
4895 : :
4896 : : list_del(&clk_provider->node);
4897 : 3 : of_node_put(clk_provider->np);
4898 : 3 : kfree(clk_provider);
4899 : : is_init_done = true;
4900 : : }
4901 : : }
4902 : :
4903 : : /*
4904 : : * We didn't manage to initialize any of the
4905 : : * remaining providers during the last loop, so now we
4906 : : * initialize all the remaining ones unconditionally
4907 : : * in case the clock parent was not mandatory
4908 : : */
4909 : 3 : if (!is_init_done)
4910 : : force = true;
4911 : : }
4912 : : }
4913 : : #endif
|
