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