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