clk: clk_set_parent() with current parent shouldn't fail
[sfrench/cifs-2.6.git] / drivers / clk / clk.c
1 /*
2  * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
3  * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  *
9  * Standard functionality for the common clock API.  See Documentation/clk.txt
10  */
11
12 #include <linux/clk-provider.h>
13 #include <linux/clk/clk-conf.h>
14 #include <linux/module.h>
15 #include <linux/mutex.h>
16 #include <linux/spinlock.h>
17 #include <linux/err.h>
18 #include <linux/list.h>
19 #include <linux/slab.h>
20 #include <linux/of.h>
21 #include <linux/device.h>
22 #include <linux/init.h>
23 #include <linux/sched.h>
24
25 #include "clk.h"
26
27 static DEFINE_SPINLOCK(enable_lock);
28 static DEFINE_MUTEX(prepare_lock);
29
30 static struct task_struct *prepare_owner;
31 static struct task_struct *enable_owner;
32
33 static int prepare_refcnt;
34 static int enable_refcnt;
35
36 static HLIST_HEAD(clk_root_list);
37 static HLIST_HEAD(clk_orphan_list);
38 static LIST_HEAD(clk_notifier_list);
39
40 static long clk_core_get_accuracy(struct clk_core *clk);
41 static unsigned long clk_core_get_rate(struct clk_core *clk);
42 static int clk_core_get_phase(struct clk_core *clk);
43 static bool clk_core_is_prepared(struct clk_core *clk);
44 static bool clk_core_is_enabled(struct clk_core *clk);
45 static struct clk_core *clk_core_lookup(const char *name);
46
47 /***    private data structures    ***/
48
49 struct clk_core {
50         const char              *name;
51         const struct clk_ops    *ops;
52         struct clk_hw           *hw;
53         struct module           *owner;
54         struct clk_core         *parent;
55         const char              **parent_names;
56         struct clk_core         **parents;
57         u8                      num_parents;
58         u8                      new_parent_index;
59         unsigned long           rate;
60         unsigned long           req_rate;
61         unsigned long           new_rate;
62         struct clk_core         *new_parent;
63         struct clk_core         *new_child;
64         unsigned long           flags;
65         unsigned int            enable_count;
66         unsigned int            prepare_count;
67         unsigned long           accuracy;
68         int                     phase;
69         struct hlist_head       children;
70         struct hlist_node       child_node;
71         struct hlist_node       debug_node;
72         struct hlist_head       clks;
73         unsigned int            notifier_count;
74 #ifdef CONFIG_DEBUG_FS
75         struct dentry           *dentry;
76 #endif
77         struct kref             ref;
78 };
79
80 #define CREATE_TRACE_POINTS
81 #include <trace/events/clk.h>
82
83 struct clk {
84         struct clk_core *core;
85         const char *dev_id;
86         const char *con_id;
87         unsigned long min_rate;
88         unsigned long max_rate;
89         struct hlist_node child_node;
90 };
91
92 /***           locking             ***/
93 static void clk_prepare_lock(void)
94 {
95         if (!mutex_trylock(&prepare_lock)) {
96                 if (prepare_owner == current) {
97                         prepare_refcnt++;
98                         return;
99                 }
100                 mutex_lock(&prepare_lock);
101         }
102         WARN_ON_ONCE(prepare_owner != NULL);
103         WARN_ON_ONCE(prepare_refcnt != 0);
104         prepare_owner = current;
105         prepare_refcnt = 1;
106 }
107
108 static void clk_prepare_unlock(void)
109 {
110         WARN_ON_ONCE(prepare_owner != current);
111         WARN_ON_ONCE(prepare_refcnt == 0);
112
113         if (--prepare_refcnt)
114                 return;
115         prepare_owner = NULL;
116         mutex_unlock(&prepare_lock);
117 }
118
119 static unsigned long clk_enable_lock(void)
120 {
121         unsigned long flags;
122
123         if (!spin_trylock_irqsave(&enable_lock, flags)) {
124                 if (enable_owner == current) {
125                         enable_refcnt++;
126                         return flags;
127                 }
128                 spin_lock_irqsave(&enable_lock, flags);
129         }
130         WARN_ON_ONCE(enable_owner != NULL);
131         WARN_ON_ONCE(enable_refcnt != 0);
132         enable_owner = current;
133         enable_refcnt = 1;
134         return flags;
135 }
136
137 static void clk_enable_unlock(unsigned long flags)
138 {
139         WARN_ON_ONCE(enable_owner != current);
140         WARN_ON_ONCE(enable_refcnt == 0);
141
142         if (--enable_refcnt)
143                 return;
144         enable_owner = NULL;
145         spin_unlock_irqrestore(&enable_lock, flags);
146 }
147
148 /***        debugfs support        ***/
149
150 #ifdef CONFIG_DEBUG_FS
151 #include <linux/debugfs.h>
152
153 static struct dentry *rootdir;
154 static int inited = 0;
155 static DEFINE_MUTEX(clk_debug_lock);
156 static HLIST_HEAD(clk_debug_list);
157
158 static struct hlist_head *all_lists[] = {
159         &clk_root_list,
160         &clk_orphan_list,
161         NULL,
162 };
163
164 static struct hlist_head *orphan_list[] = {
165         &clk_orphan_list,
166         NULL,
167 };
168
169 static void clk_summary_show_one(struct seq_file *s, struct clk_core *c,
170                                  int level)
171 {
172         if (!c)
173                 return;
174
175         seq_printf(s, "%*s%-*s %11d %12d %11lu %10lu %-3d\n",
176                    level * 3 + 1, "",
177                    30 - level * 3, c->name,
178                    c->enable_count, c->prepare_count, clk_core_get_rate(c),
179                    clk_core_get_accuracy(c), clk_core_get_phase(c));
180 }
181
182 static void clk_summary_show_subtree(struct seq_file *s, struct clk_core *c,
183                                      int level)
184 {
185         struct clk_core *child;
186
187         if (!c)
188                 return;
189
190         clk_summary_show_one(s, c, level);
191
192         hlist_for_each_entry(child, &c->children, child_node)
193                 clk_summary_show_subtree(s, child, level + 1);
194 }
195
196 static int clk_summary_show(struct seq_file *s, void *data)
197 {
198         struct clk_core *c;
199         struct hlist_head **lists = (struct hlist_head **)s->private;
200
201         seq_puts(s, "   clock                         enable_cnt  prepare_cnt        rate   accuracy   phase\n");
202         seq_puts(s, "----------------------------------------------------------------------------------------\n");
203
204         clk_prepare_lock();
205
206         for (; *lists; lists++)
207                 hlist_for_each_entry(c, *lists, child_node)
208                         clk_summary_show_subtree(s, c, 0);
209
210         clk_prepare_unlock();
211
212         return 0;
213 }
214
215
216 static int clk_summary_open(struct inode *inode, struct file *file)
217 {
218         return single_open(file, clk_summary_show, inode->i_private);
219 }
220
221 static const struct file_operations clk_summary_fops = {
222         .open           = clk_summary_open,
223         .read           = seq_read,
224         .llseek         = seq_lseek,
225         .release        = single_release,
226 };
227
228 static void clk_dump_one(struct seq_file *s, struct clk_core *c, int level)
229 {
230         if (!c)
231                 return;
232
233         seq_printf(s, "\"%s\": { ", c->name);
234         seq_printf(s, "\"enable_count\": %d,", c->enable_count);
235         seq_printf(s, "\"prepare_count\": %d,", c->prepare_count);
236         seq_printf(s, "\"rate\": %lu", clk_core_get_rate(c));
237         seq_printf(s, "\"accuracy\": %lu", clk_core_get_accuracy(c));
238         seq_printf(s, "\"phase\": %d", clk_core_get_phase(c));
239 }
240
241 static void clk_dump_subtree(struct seq_file *s, struct clk_core *c, int level)
242 {
243         struct clk_core *child;
244
245         if (!c)
246                 return;
247
248         clk_dump_one(s, c, level);
249
250         hlist_for_each_entry(child, &c->children, child_node) {
251                 seq_printf(s, ",");
252                 clk_dump_subtree(s, child, level + 1);
253         }
254
255         seq_printf(s, "}");
256 }
257
258 static int clk_dump(struct seq_file *s, void *data)
259 {
260         struct clk_core *c;
261         bool first_node = true;
262         struct hlist_head **lists = (struct hlist_head **)s->private;
263
264         seq_printf(s, "{");
265
266         clk_prepare_lock();
267
268         for (; *lists; lists++) {
269                 hlist_for_each_entry(c, *lists, child_node) {
270                         if (!first_node)
271                                 seq_puts(s, ",");
272                         first_node = false;
273                         clk_dump_subtree(s, c, 0);
274                 }
275         }
276
277         clk_prepare_unlock();
278
279         seq_printf(s, "}");
280         return 0;
281 }
282
283
284 static int clk_dump_open(struct inode *inode, struct file *file)
285 {
286         return single_open(file, clk_dump, inode->i_private);
287 }
288
289 static const struct file_operations clk_dump_fops = {
290         .open           = clk_dump_open,
291         .read           = seq_read,
292         .llseek         = seq_lseek,
293         .release        = single_release,
294 };
295
296 static int clk_debug_create_one(struct clk_core *clk, struct dentry *pdentry)
297 {
298         struct dentry *d;
299         int ret = -ENOMEM;
300
301         if (!clk || !pdentry) {
302                 ret = -EINVAL;
303                 goto out;
304         }
305
306         d = debugfs_create_dir(clk->name, pdentry);
307         if (!d)
308                 goto out;
309
310         clk->dentry = d;
311
312         d = debugfs_create_u32("clk_rate", S_IRUGO, clk->dentry,
313                         (u32 *)&clk->rate);
314         if (!d)
315                 goto err_out;
316
317         d = debugfs_create_u32("clk_accuracy", S_IRUGO, clk->dentry,
318                         (u32 *)&clk->accuracy);
319         if (!d)
320                 goto err_out;
321
322         d = debugfs_create_u32("clk_phase", S_IRUGO, clk->dentry,
323                         (u32 *)&clk->phase);
324         if (!d)
325                 goto err_out;
326
327         d = debugfs_create_x32("clk_flags", S_IRUGO, clk->dentry,
328                         (u32 *)&clk->flags);
329         if (!d)
330                 goto err_out;
331
332         d = debugfs_create_u32("clk_prepare_count", S_IRUGO, clk->dentry,
333                         (u32 *)&clk->prepare_count);
334         if (!d)
335                 goto err_out;
336
337         d = debugfs_create_u32("clk_enable_count", S_IRUGO, clk->dentry,
338                         (u32 *)&clk->enable_count);
339         if (!d)
340                 goto err_out;
341
342         d = debugfs_create_u32("clk_notifier_count", S_IRUGO, clk->dentry,
343                         (u32 *)&clk->notifier_count);
344         if (!d)
345                 goto err_out;
346
347         if (clk->ops->debug_init) {
348                 ret = clk->ops->debug_init(clk->hw, clk->dentry);
349                 if (ret)
350                         goto err_out;
351         }
352
353         ret = 0;
354         goto out;
355
356 err_out:
357         debugfs_remove_recursive(clk->dentry);
358         clk->dentry = NULL;
359 out:
360         return ret;
361 }
362
363 /**
364  * clk_debug_register - add a clk node to the debugfs clk tree
365  * @clk: the clk being added to the debugfs clk tree
366  *
367  * Dynamically adds a clk to the debugfs clk tree if debugfs has been
368  * initialized.  Otherwise it bails out early since the debugfs clk tree
369  * will be created lazily by clk_debug_init as part of a late_initcall.
370  */
371 static int clk_debug_register(struct clk_core *clk)
372 {
373         int ret = 0;
374
375         mutex_lock(&clk_debug_lock);
376         hlist_add_head(&clk->debug_node, &clk_debug_list);
377
378         if (!inited)
379                 goto unlock;
380
381         ret = clk_debug_create_one(clk, rootdir);
382 unlock:
383         mutex_unlock(&clk_debug_lock);
384
385         return ret;
386 }
387
388  /**
389  * clk_debug_unregister - remove a clk node from the debugfs clk tree
390  * @clk: the clk being removed from the debugfs clk tree
391  *
392  * Dynamically removes a clk and all it's children clk nodes from the
393  * debugfs clk tree if clk->dentry points to debugfs created by
394  * clk_debug_register in __clk_init.
395  */
396 static void clk_debug_unregister(struct clk_core *clk)
397 {
398         mutex_lock(&clk_debug_lock);
399         hlist_del_init(&clk->debug_node);
400         debugfs_remove_recursive(clk->dentry);
401         clk->dentry = NULL;
402         mutex_unlock(&clk_debug_lock);
403 }
404
405 struct dentry *clk_debugfs_add_file(struct clk_hw *hw, char *name, umode_t mode,
406                                 void *data, const struct file_operations *fops)
407 {
408         struct dentry *d = NULL;
409
410         if (hw->core->dentry)
411                 d = debugfs_create_file(name, mode, hw->core->dentry, data,
412                                         fops);
413
414         return d;
415 }
416 EXPORT_SYMBOL_GPL(clk_debugfs_add_file);
417
418 /**
419  * clk_debug_init - lazily create the debugfs clk tree visualization
420  *
421  * clks are often initialized very early during boot before memory can
422  * be dynamically allocated and well before debugfs is setup.
423  * clk_debug_init walks the clk tree hierarchy while holding
424  * prepare_lock and creates the topology as part of a late_initcall,
425  * thus insuring that clks initialized very early will still be
426  * represented in the debugfs clk tree.  This function should only be
427  * called once at boot-time, and all other clks added dynamically will
428  * be done so with clk_debug_register.
429  */
430 static int __init clk_debug_init(void)
431 {
432         struct clk_core *clk;
433         struct dentry *d;
434
435         rootdir = debugfs_create_dir("clk", NULL);
436
437         if (!rootdir)
438                 return -ENOMEM;
439
440         d = debugfs_create_file("clk_summary", S_IRUGO, rootdir, &all_lists,
441                                 &clk_summary_fops);
442         if (!d)
443                 return -ENOMEM;
444
445         d = debugfs_create_file("clk_dump", S_IRUGO, rootdir, &all_lists,
446                                 &clk_dump_fops);
447         if (!d)
448                 return -ENOMEM;
449
450         d = debugfs_create_file("clk_orphan_summary", S_IRUGO, rootdir,
451                                 &orphan_list, &clk_summary_fops);
452         if (!d)
453                 return -ENOMEM;
454
455         d = debugfs_create_file("clk_orphan_dump", S_IRUGO, rootdir,
456                                 &orphan_list, &clk_dump_fops);
457         if (!d)
458                 return -ENOMEM;
459
460         mutex_lock(&clk_debug_lock);
461         hlist_for_each_entry(clk, &clk_debug_list, debug_node)
462                 clk_debug_create_one(clk, rootdir);
463
464         inited = 1;
465         mutex_unlock(&clk_debug_lock);
466
467         return 0;
468 }
469 late_initcall(clk_debug_init);
470 #else
471 static inline int clk_debug_register(struct clk_core *clk) { return 0; }
472 static inline void clk_debug_reparent(struct clk_core *clk,
473                                       struct clk_core *new_parent)
474 {
475 }
476 static inline void clk_debug_unregister(struct clk_core *clk)
477 {
478 }
479 #endif
480
481 /* caller must hold prepare_lock */
482 static void clk_unprepare_unused_subtree(struct clk_core *clk)
483 {
484         struct clk_core *child;
485
486         lockdep_assert_held(&prepare_lock);
487
488         hlist_for_each_entry(child, &clk->children, child_node)
489                 clk_unprepare_unused_subtree(child);
490
491         if (clk->prepare_count)
492                 return;
493
494         if (clk->flags & CLK_IGNORE_UNUSED)
495                 return;
496
497         if (clk_core_is_prepared(clk)) {
498                 trace_clk_unprepare(clk);
499                 if (clk->ops->unprepare_unused)
500                         clk->ops->unprepare_unused(clk->hw);
501                 else if (clk->ops->unprepare)
502                         clk->ops->unprepare(clk->hw);
503                 trace_clk_unprepare_complete(clk);
504         }
505 }
506
507 /* caller must hold prepare_lock */
508 static void clk_disable_unused_subtree(struct clk_core *clk)
509 {
510         struct clk_core *child;
511         unsigned long flags;
512
513         lockdep_assert_held(&prepare_lock);
514
515         hlist_for_each_entry(child, &clk->children, child_node)
516                 clk_disable_unused_subtree(child);
517
518         flags = clk_enable_lock();
519
520         if (clk->enable_count)
521                 goto unlock_out;
522
523         if (clk->flags & CLK_IGNORE_UNUSED)
524                 goto unlock_out;
525
526         /*
527          * some gate clocks have special needs during the disable-unused
528          * sequence.  call .disable_unused if available, otherwise fall
529          * back to .disable
530          */
531         if (clk_core_is_enabled(clk)) {
532                 trace_clk_disable(clk);
533                 if (clk->ops->disable_unused)
534                         clk->ops->disable_unused(clk->hw);
535                 else if (clk->ops->disable)
536                         clk->ops->disable(clk->hw);
537                 trace_clk_disable_complete(clk);
538         }
539
540 unlock_out:
541         clk_enable_unlock(flags);
542 }
543
544 static bool clk_ignore_unused;
545 static int __init clk_ignore_unused_setup(char *__unused)
546 {
547         clk_ignore_unused = true;
548         return 1;
549 }
550 __setup("clk_ignore_unused", clk_ignore_unused_setup);
551
552 static int clk_disable_unused(void)
553 {
554         struct clk_core *clk;
555
556         if (clk_ignore_unused) {
557                 pr_warn("clk: Not disabling unused clocks\n");
558                 return 0;
559         }
560
561         clk_prepare_lock();
562
563         hlist_for_each_entry(clk, &clk_root_list, child_node)
564                 clk_disable_unused_subtree(clk);
565
566         hlist_for_each_entry(clk, &clk_orphan_list, child_node)
567                 clk_disable_unused_subtree(clk);
568
569         hlist_for_each_entry(clk, &clk_root_list, child_node)
570                 clk_unprepare_unused_subtree(clk);
571
572         hlist_for_each_entry(clk, &clk_orphan_list, child_node)
573                 clk_unprepare_unused_subtree(clk);
574
575         clk_prepare_unlock();
576
577         return 0;
578 }
579 late_initcall_sync(clk_disable_unused);
580
581 /***    helper functions   ***/
582
583 const char *__clk_get_name(struct clk *clk)
584 {
585         return !clk ? NULL : clk->core->name;
586 }
587 EXPORT_SYMBOL_GPL(__clk_get_name);
588
589 struct clk_hw *__clk_get_hw(struct clk *clk)
590 {
591         return !clk ? NULL : clk->core->hw;
592 }
593 EXPORT_SYMBOL_GPL(__clk_get_hw);
594
595 u8 __clk_get_num_parents(struct clk *clk)
596 {
597         return !clk ? 0 : clk->core->num_parents;
598 }
599 EXPORT_SYMBOL_GPL(__clk_get_num_parents);
600
601 struct clk *__clk_get_parent(struct clk *clk)
602 {
603         if (!clk)
604                 return NULL;
605
606         /* TODO: Create a per-user clk and change callers to call clk_put */
607         return !clk->core->parent ? NULL : clk->core->parent->hw->clk;
608 }
609 EXPORT_SYMBOL_GPL(__clk_get_parent);
610
611 static struct clk_core *clk_core_get_parent_by_index(struct clk_core *clk,
612                                                          u8 index)
613 {
614         if (!clk || index >= clk->num_parents)
615                 return NULL;
616         else if (!clk->parents)
617                 return clk_core_lookup(clk->parent_names[index]);
618         else if (!clk->parents[index])
619                 return clk->parents[index] =
620                         clk_core_lookup(clk->parent_names[index]);
621         else
622                 return clk->parents[index];
623 }
624
625 struct clk *clk_get_parent_by_index(struct clk *clk, u8 index)
626 {
627         struct clk_core *parent;
628
629         if (!clk)
630                 return NULL;
631
632         parent = clk_core_get_parent_by_index(clk->core, index);
633
634         return !parent ? NULL : parent->hw->clk;
635 }
636 EXPORT_SYMBOL_GPL(clk_get_parent_by_index);
637
638 unsigned int __clk_get_enable_count(struct clk *clk)
639 {
640         return !clk ? 0 : clk->core->enable_count;
641 }
642
643 static unsigned long clk_core_get_rate_nolock(struct clk_core *clk)
644 {
645         unsigned long ret;
646
647         if (!clk) {
648                 ret = 0;
649                 goto out;
650         }
651
652         ret = clk->rate;
653
654         if (clk->flags & CLK_IS_ROOT)
655                 goto out;
656
657         if (!clk->parent)
658                 ret = 0;
659
660 out:
661         return ret;
662 }
663
664 unsigned long __clk_get_rate(struct clk *clk)
665 {
666         if (!clk)
667                 return 0;
668
669         return clk_core_get_rate_nolock(clk->core);
670 }
671 EXPORT_SYMBOL_GPL(__clk_get_rate);
672
673 static unsigned long __clk_get_accuracy(struct clk_core *clk)
674 {
675         if (!clk)
676                 return 0;
677
678         return clk->accuracy;
679 }
680
681 unsigned long __clk_get_flags(struct clk *clk)
682 {
683         return !clk ? 0 : clk->core->flags;
684 }
685 EXPORT_SYMBOL_GPL(__clk_get_flags);
686
687 static bool clk_core_is_prepared(struct clk_core *clk)
688 {
689         int ret;
690
691         if (!clk)
692                 return false;
693
694         /*
695          * .is_prepared is optional for clocks that can prepare
696          * fall back to software usage counter if it is missing
697          */
698         if (!clk->ops->is_prepared) {
699                 ret = clk->prepare_count ? 1 : 0;
700                 goto out;
701         }
702
703         ret = clk->ops->is_prepared(clk->hw);
704 out:
705         return !!ret;
706 }
707
708 bool __clk_is_prepared(struct clk *clk)
709 {
710         if (!clk)
711                 return false;
712
713         return clk_core_is_prepared(clk->core);
714 }
715
716 static bool clk_core_is_enabled(struct clk_core *clk)
717 {
718         int ret;
719
720         if (!clk)
721                 return false;
722
723         /*
724          * .is_enabled is only mandatory for clocks that gate
725          * fall back to software usage counter if .is_enabled is missing
726          */
727         if (!clk->ops->is_enabled) {
728                 ret = clk->enable_count ? 1 : 0;
729                 goto out;
730         }
731
732         ret = clk->ops->is_enabled(clk->hw);
733 out:
734         return !!ret;
735 }
736
737 bool __clk_is_enabled(struct clk *clk)
738 {
739         if (!clk)
740                 return false;
741
742         return clk_core_is_enabled(clk->core);
743 }
744 EXPORT_SYMBOL_GPL(__clk_is_enabled);
745
746 static struct clk_core *__clk_lookup_subtree(const char *name,
747                                              struct clk_core *clk)
748 {
749         struct clk_core *child;
750         struct clk_core *ret;
751
752         if (!strcmp(clk->name, name))
753                 return clk;
754
755         hlist_for_each_entry(child, &clk->children, child_node) {
756                 ret = __clk_lookup_subtree(name, child);
757                 if (ret)
758                         return ret;
759         }
760
761         return NULL;
762 }
763
764 static struct clk_core *clk_core_lookup(const char *name)
765 {
766         struct clk_core *root_clk;
767         struct clk_core *ret;
768
769         if (!name)
770                 return NULL;
771
772         /* search the 'proper' clk tree first */
773         hlist_for_each_entry(root_clk, &clk_root_list, child_node) {
774                 ret = __clk_lookup_subtree(name, root_clk);
775                 if (ret)
776                         return ret;
777         }
778
779         /* if not found, then search the orphan tree */
780         hlist_for_each_entry(root_clk, &clk_orphan_list, child_node) {
781                 ret = __clk_lookup_subtree(name, root_clk);
782                 if (ret)
783                         return ret;
784         }
785
786         return NULL;
787 }
788
789 static bool mux_is_better_rate(unsigned long rate, unsigned long now,
790                            unsigned long best, unsigned long flags)
791 {
792         if (flags & CLK_MUX_ROUND_CLOSEST)
793                 return abs(now - rate) < abs(best - rate);
794
795         return now <= rate && now > best;
796 }
797
798 static long
799 clk_mux_determine_rate_flags(struct clk_hw *hw, unsigned long rate,
800                              unsigned long min_rate,
801                              unsigned long max_rate,
802                              unsigned long *best_parent_rate,
803                              struct clk_hw **best_parent_p,
804                              unsigned long flags)
805 {
806         struct clk_core *core = hw->core, *parent, *best_parent = NULL;
807         int i, num_parents;
808         unsigned long parent_rate, best = 0;
809
810         /* if NO_REPARENT flag set, pass through to current parent */
811         if (core->flags & CLK_SET_RATE_NO_REPARENT) {
812                 parent = core->parent;
813                 if (core->flags & CLK_SET_RATE_PARENT)
814                         best = __clk_determine_rate(parent ? parent->hw : NULL,
815                                                     rate, min_rate, max_rate);
816                 else if (parent)
817                         best = clk_core_get_rate_nolock(parent);
818                 else
819                         best = clk_core_get_rate_nolock(core);
820                 goto out;
821         }
822
823         /* find the parent that can provide the fastest rate <= rate */
824         num_parents = core->num_parents;
825         for (i = 0; i < num_parents; i++) {
826                 parent = clk_core_get_parent_by_index(core, i);
827                 if (!parent)
828                         continue;
829                 if (core->flags & CLK_SET_RATE_PARENT)
830                         parent_rate = __clk_determine_rate(parent->hw, rate,
831                                                            min_rate,
832                                                            max_rate);
833                 else
834                         parent_rate = clk_core_get_rate_nolock(parent);
835                 if (mux_is_better_rate(rate, parent_rate, best, flags)) {
836                         best_parent = parent;
837                         best = parent_rate;
838                 }
839         }
840
841 out:
842         if (best_parent)
843                 *best_parent_p = best_parent->hw;
844         *best_parent_rate = best;
845
846         return best;
847 }
848
849 struct clk *__clk_lookup(const char *name)
850 {
851         struct clk_core *core = clk_core_lookup(name);
852
853         return !core ? NULL : core->hw->clk;
854 }
855
856 static void clk_core_get_boundaries(struct clk_core *clk,
857                                     unsigned long *min_rate,
858                                     unsigned long *max_rate)
859 {
860         struct clk *clk_user;
861
862         *min_rate = 0;
863         *max_rate = ULONG_MAX;
864
865         hlist_for_each_entry(clk_user, &clk->clks, child_node)
866                 *min_rate = max(*min_rate, clk_user->min_rate);
867
868         hlist_for_each_entry(clk_user, &clk->clks, child_node)
869                 *max_rate = min(*max_rate, clk_user->max_rate);
870 }
871
872 /*
873  * Helper for finding best parent to provide a given frequency. This can be used
874  * directly as a determine_rate callback (e.g. for a mux), or from a more
875  * complex clock that may combine a mux with other operations.
876  */
877 long __clk_mux_determine_rate(struct clk_hw *hw, unsigned long rate,
878                               unsigned long min_rate,
879                               unsigned long max_rate,
880                               unsigned long *best_parent_rate,
881                               struct clk_hw **best_parent_p)
882 {
883         return clk_mux_determine_rate_flags(hw, rate, min_rate, max_rate,
884                                             best_parent_rate,
885                                             best_parent_p, 0);
886 }
887 EXPORT_SYMBOL_GPL(__clk_mux_determine_rate);
888
889 long __clk_mux_determine_rate_closest(struct clk_hw *hw, unsigned long rate,
890                               unsigned long min_rate,
891                               unsigned long max_rate,
892                               unsigned long *best_parent_rate,
893                               struct clk_hw **best_parent_p)
894 {
895         return clk_mux_determine_rate_flags(hw, rate, min_rate, max_rate,
896                                             best_parent_rate,
897                                             best_parent_p,
898                                             CLK_MUX_ROUND_CLOSEST);
899 }
900 EXPORT_SYMBOL_GPL(__clk_mux_determine_rate_closest);
901
902 /***        clk api        ***/
903
904 static void clk_core_unprepare(struct clk_core *clk)
905 {
906         if (!clk)
907                 return;
908
909         if (WARN_ON(clk->prepare_count == 0))
910                 return;
911
912         if (--clk->prepare_count > 0)
913                 return;
914
915         WARN_ON(clk->enable_count > 0);
916
917         trace_clk_unprepare(clk);
918
919         if (clk->ops->unprepare)
920                 clk->ops->unprepare(clk->hw);
921
922         trace_clk_unprepare_complete(clk);
923         clk_core_unprepare(clk->parent);
924 }
925
926 /**
927  * clk_unprepare - undo preparation of a clock source
928  * @clk: the clk being unprepared
929  *
930  * clk_unprepare may sleep, which differentiates it from clk_disable.  In a
931  * simple case, clk_unprepare can be used instead of clk_disable to gate a clk
932  * if the operation may sleep.  One example is a clk which is accessed over
933  * I2c.  In the complex case a clk gate operation may require a fast and a slow
934  * part.  It is this reason that clk_unprepare and clk_disable are not mutually
935  * exclusive.  In fact clk_disable must be called before clk_unprepare.
936  */
937 void clk_unprepare(struct clk *clk)
938 {
939         if (IS_ERR_OR_NULL(clk))
940                 return;
941
942         clk_prepare_lock();
943         clk_core_unprepare(clk->core);
944         clk_prepare_unlock();
945 }
946 EXPORT_SYMBOL_GPL(clk_unprepare);
947
948 static int clk_core_prepare(struct clk_core *clk)
949 {
950         int ret = 0;
951
952         if (!clk)
953                 return 0;
954
955         if (clk->prepare_count == 0) {
956                 ret = clk_core_prepare(clk->parent);
957                 if (ret)
958                         return ret;
959
960                 trace_clk_prepare(clk);
961
962                 if (clk->ops->prepare)
963                         ret = clk->ops->prepare(clk->hw);
964
965                 trace_clk_prepare_complete(clk);
966
967                 if (ret) {
968                         clk_core_unprepare(clk->parent);
969                         return ret;
970                 }
971         }
972
973         clk->prepare_count++;
974
975         return 0;
976 }
977
978 /**
979  * clk_prepare - prepare a clock source
980  * @clk: the clk being prepared
981  *
982  * clk_prepare may sleep, which differentiates it from clk_enable.  In a simple
983  * case, clk_prepare can be used instead of clk_enable to ungate a clk if the
984  * operation may sleep.  One example is a clk which is accessed over I2c.  In
985  * the complex case a clk ungate operation may require a fast and a slow part.
986  * It is this reason that clk_prepare and clk_enable are not mutually
987  * exclusive.  In fact clk_prepare must be called before clk_enable.
988  * Returns 0 on success, -EERROR otherwise.
989  */
990 int clk_prepare(struct clk *clk)
991 {
992         int ret;
993
994         if (!clk)
995                 return 0;
996
997         clk_prepare_lock();
998         ret = clk_core_prepare(clk->core);
999         clk_prepare_unlock();
1000
1001         return ret;
1002 }
1003 EXPORT_SYMBOL_GPL(clk_prepare);
1004
1005 static void clk_core_disable(struct clk_core *clk)
1006 {
1007         if (!clk)
1008                 return;
1009
1010         if (WARN_ON(clk->enable_count == 0))
1011                 return;
1012
1013         if (--clk->enable_count > 0)
1014                 return;
1015
1016         trace_clk_disable(clk);
1017
1018         if (clk->ops->disable)
1019                 clk->ops->disable(clk->hw);
1020
1021         trace_clk_disable_complete(clk);
1022
1023         clk_core_disable(clk->parent);
1024 }
1025
1026 static void __clk_disable(struct clk *clk)
1027 {
1028         if (!clk)
1029                 return;
1030
1031         clk_core_disable(clk->core);
1032 }
1033
1034 /**
1035  * clk_disable - gate a clock
1036  * @clk: the clk being gated
1037  *
1038  * clk_disable must not sleep, which differentiates it from clk_unprepare.  In
1039  * a simple case, clk_disable can be used instead of clk_unprepare to gate a
1040  * clk if the operation is fast and will never sleep.  One example is a
1041  * SoC-internal clk which is controlled via simple register writes.  In the
1042  * complex case a clk gate operation may require a fast and a slow part.  It is
1043  * this reason that clk_unprepare and clk_disable are not mutually exclusive.
1044  * In fact clk_disable must be called before clk_unprepare.
1045  */
1046 void clk_disable(struct clk *clk)
1047 {
1048         unsigned long flags;
1049
1050         if (IS_ERR_OR_NULL(clk))
1051                 return;
1052
1053         flags = clk_enable_lock();
1054         __clk_disable(clk);
1055         clk_enable_unlock(flags);
1056 }
1057 EXPORT_SYMBOL_GPL(clk_disable);
1058
1059 static int clk_core_enable(struct clk_core *clk)
1060 {
1061         int ret = 0;
1062
1063         if (!clk)
1064                 return 0;
1065
1066         if (WARN_ON(clk->prepare_count == 0))
1067                 return -ESHUTDOWN;
1068
1069         if (clk->enable_count == 0) {
1070                 ret = clk_core_enable(clk->parent);
1071
1072                 if (ret)
1073                         return ret;
1074
1075                 trace_clk_enable(clk);
1076
1077                 if (clk->ops->enable)
1078                         ret = clk->ops->enable(clk->hw);
1079
1080                 trace_clk_enable_complete(clk);
1081
1082                 if (ret) {
1083                         clk_core_disable(clk->parent);
1084                         return ret;
1085                 }
1086         }
1087
1088         clk->enable_count++;
1089         return 0;
1090 }
1091
1092 static int __clk_enable(struct clk *clk)
1093 {
1094         if (!clk)
1095                 return 0;
1096
1097         return clk_core_enable(clk->core);
1098 }
1099
1100 /**
1101  * clk_enable - ungate a clock
1102  * @clk: the clk being ungated
1103  *
1104  * clk_enable must not sleep, which differentiates it from clk_prepare.  In a
1105  * simple case, clk_enable can be used instead of clk_prepare to ungate a clk
1106  * if the operation will never sleep.  One example is a SoC-internal clk which
1107  * is controlled via simple register writes.  In the complex case a clk ungate
1108  * operation may require a fast and a slow part.  It is this reason that
1109  * clk_enable and clk_prepare are not mutually exclusive.  In fact clk_prepare
1110  * must be called before clk_enable.  Returns 0 on success, -EERROR
1111  * otherwise.
1112  */
1113 int clk_enable(struct clk *clk)
1114 {
1115         unsigned long flags;
1116         int ret;
1117
1118         flags = clk_enable_lock();
1119         ret = __clk_enable(clk);
1120         clk_enable_unlock(flags);
1121
1122         return ret;
1123 }
1124 EXPORT_SYMBOL_GPL(clk_enable);
1125
1126 static unsigned long clk_core_round_rate_nolock(struct clk_core *clk,
1127                                                 unsigned long rate,
1128                                                 unsigned long min_rate,
1129                                                 unsigned long max_rate)
1130 {
1131         unsigned long parent_rate = 0;
1132         struct clk_core *parent;
1133         struct clk_hw *parent_hw;
1134
1135         lockdep_assert_held(&prepare_lock);
1136
1137         if (!clk)
1138                 return 0;
1139
1140         parent = clk->parent;
1141         if (parent)
1142                 parent_rate = parent->rate;
1143
1144         if (clk->ops->determine_rate) {
1145                 parent_hw = parent ? parent->hw : NULL;
1146                 return clk->ops->determine_rate(clk->hw, rate,
1147                                                 min_rate, max_rate,
1148                                                 &parent_rate, &parent_hw);
1149         } else if (clk->ops->round_rate)
1150                 return clk->ops->round_rate(clk->hw, rate, &parent_rate);
1151         else if (clk->flags & CLK_SET_RATE_PARENT)
1152                 return clk_core_round_rate_nolock(clk->parent, rate, min_rate,
1153                                                   max_rate);
1154         else
1155                 return clk->rate;
1156 }
1157
1158 /**
1159  * __clk_determine_rate - get the closest rate actually supported by a clock
1160  * @hw: determine the rate of this clock
1161  * @rate: target rate
1162  * @min_rate: returned rate must be greater than this rate
1163  * @max_rate: returned rate must be less than this rate
1164  *
1165  * Caller must hold prepare_lock.  Useful for clk_ops such as .set_rate and
1166  * .determine_rate.
1167  */
1168 unsigned long __clk_determine_rate(struct clk_hw *hw,
1169                                    unsigned long rate,
1170                                    unsigned long min_rate,
1171                                    unsigned long max_rate)
1172 {
1173         if (!hw)
1174                 return 0;
1175
1176         return clk_core_round_rate_nolock(hw->core, rate, min_rate, max_rate);
1177 }
1178 EXPORT_SYMBOL_GPL(__clk_determine_rate);
1179
1180 /**
1181  * __clk_round_rate - round the given rate for a clk
1182  * @clk: round the rate of this clock
1183  * @rate: the rate which is to be rounded
1184  *
1185  * Caller must hold prepare_lock.  Useful for clk_ops such as .set_rate
1186  */
1187 unsigned long __clk_round_rate(struct clk *clk, unsigned long rate)
1188 {
1189         unsigned long min_rate;
1190         unsigned long max_rate;
1191
1192         if (!clk)
1193                 return 0;
1194
1195         clk_core_get_boundaries(clk->core, &min_rate, &max_rate);
1196
1197         return clk_core_round_rate_nolock(clk->core, rate, min_rate, max_rate);
1198 }
1199 EXPORT_SYMBOL_GPL(__clk_round_rate);
1200
1201 /**
1202  * clk_round_rate - round the given rate for a clk
1203  * @clk: the clk for which we are rounding a rate
1204  * @rate: the rate which is to be rounded
1205  *
1206  * Takes in a rate as input and rounds it to a rate that the clk can actually
1207  * use which is then returned.  If clk doesn't support round_rate operation
1208  * then the parent rate is returned.
1209  */
1210 long clk_round_rate(struct clk *clk, unsigned long rate)
1211 {
1212         unsigned long ret;
1213
1214         if (!clk)
1215                 return 0;
1216
1217         clk_prepare_lock();
1218         ret = __clk_round_rate(clk, rate);
1219         clk_prepare_unlock();
1220
1221         return ret;
1222 }
1223 EXPORT_SYMBOL_GPL(clk_round_rate);
1224
1225 /**
1226  * __clk_notify - call clk notifier chain
1227  * @clk: struct clk * that is changing rate
1228  * @msg: clk notifier type (see include/linux/clk.h)
1229  * @old_rate: old clk rate
1230  * @new_rate: new clk rate
1231  *
1232  * Triggers a notifier call chain on the clk rate-change notification
1233  * for 'clk'.  Passes a pointer to the struct clk and the previous
1234  * and current rates to the notifier callback.  Intended to be called by
1235  * internal clock code only.  Returns NOTIFY_DONE from the last driver
1236  * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
1237  * a driver returns that.
1238  */
1239 static int __clk_notify(struct clk_core *clk, unsigned long msg,
1240                 unsigned long old_rate, unsigned long new_rate)
1241 {
1242         struct clk_notifier *cn;
1243         struct clk_notifier_data cnd;
1244         int ret = NOTIFY_DONE;
1245
1246         cnd.old_rate = old_rate;
1247         cnd.new_rate = new_rate;
1248
1249         list_for_each_entry(cn, &clk_notifier_list, node) {
1250                 if (cn->clk->core == clk) {
1251                         cnd.clk = cn->clk;
1252                         ret = srcu_notifier_call_chain(&cn->notifier_head, msg,
1253                                         &cnd);
1254                 }
1255         }
1256
1257         return ret;
1258 }
1259
1260 /**
1261  * __clk_recalc_accuracies
1262  * @clk: first clk in the subtree
1263  *
1264  * Walks the subtree of clks starting with clk and recalculates accuracies as
1265  * it goes.  Note that if a clk does not implement the .recalc_accuracy
1266  * callback then it is assumed that the clock will take on the accuracy of it's
1267  * parent.
1268  *
1269  * Caller must hold prepare_lock.
1270  */
1271 static void __clk_recalc_accuracies(struct clk_core *clk)
1272 {
1273         unsigned long parent_accuracy = 0;
1274         struct clk_core *child;
1275
1276         lockdep_assert_held(&prepare_lock);
1277
1278         if (clk->parent)
1279                 parent_accuracy = clk->parent->accuracy;
1280
1281         if (clk->ops->recalc_accuracy)
1282                 clk->accuracy = clk->ops->recalc_accuracy(clk->hw,
1283                                                           parent_accuracy);
1284         else
1285                 clk->accuracy = parent_accuracy;
1286
1287         hlist_for_each_entry(child, &clk->children, child_node)
1288                 __clk_recalc_accuracies(child);
1289 }
1290
1291 static long clk_core_get_accuracy(struct clk_core *clk)
1292 {
1293         unsigned long accuracy;
1294
1295         clk_prepare_lock();
1296         if (clk && (clk->flags & CLK_GET_ACCURACY_NOCACHE))
1297                 __clk_recalc_accuracies(clk);
1298
1299         accuracy = __clk_get_accuracy(clk);
1300         clk_prepare_unlock();
1301
1302         return accuracy;
1303 }
1304
1305 /**
1306  * clk_get_accuracy - return the accuracy of clk
1307  * @clk: the clk whose accuracy is being returned
1308  *
1309  * Simply returns the cached accuracy of the clk, unless
1310  * CLK_GET_ACCURACY_NOCACHE flag is set, which means a recalc_rate will be
1311  * issued.
1312  * If clk is NULL then returns 0.
1313  */
1314 long clk_get_accuracy(struct clk *clk)
1315 {
1316         if (!clk)
1317                 return 0;
1318
1319         return clk_core_get_accuracy(clk->core);
1320 }
1321 EXPORT_SYMBOL_GPL(clk_get_accuracy);
1322
1323 static unsigned long clk_recalc(struct clk_core *clk,
1324                                 unsigned long parent_rate)
1325 {
1326         if (clk->ops->recalc_rate)
1327                 return clk->ops->recalc_rate(clk->hw, parent_rate);
1328         return parent_rate;
1329 }
1330
1331 /**
1332  * __clk_recalc_rates
1333  * @clk: first clk in the subtree
1334  * @msg: notification type (see include/linux/clk.h)
1335  *
1336  * Walks the subtree of clks starting with clk and recalculates rates as it
1337  * goes.  Note that if a clk does not implement the .recalc_rate callback then
1338  * it is assumed that the clock will take on the rate of its parent.
1339  *
1340  * clk_recalc_rates also propagates the POST_RATE_CHANGE notification,
1341  * if necessary.
1342  *
1343  * Caller must hold prepare_lock.
1344  */
1345 static void __clk_recalc_rates(struct clk_core *clk, unsigned long msg)
1346 {
1347         unsigned long old_rate;
1348         unsigned long parent_rate = 0;
1349         struct clk_core *child;
1350
1351         lockdep_assert_held(&prepare_lock);
1352
1353         old_rate = clk->rate;
1354
1355         if (clk->parent)
1356                 parent_rate = clk->parent->rate;
1357
1358         clk->rate = clk_recalc(clk, parent_rate);
1359
1360         /*
1361          * ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE
1362          * & ABORT_RATE_CHANGE notifiers
1363          */
1364         if (clk->notifier_count && msg)
1365                 __clk_notify(clk, msg, old_rate, clk->rate);
1366
1367         hlist_for_each_entry(child, &clk->children, child_node)
1368                 __clk_recalc_rates(child, msg);
1369 }
1370
1371 static unsigned long clk_core_get_rate(struct clk_core *clk)
1372 {
1373         unsigned long rate;
1374
1375         clk_prepare_lock();
1376
1377         if (clk && (clk->flags & CLK_GET_RATE_NOCACHE))
1378                 __clk_recalc_rates(clk, 0);
1379
1380         rate = clk_core_get_rate_nolock(clk);
1381         clk_prepare_unlock();
1382
1383         return rate;
1384 }
1385 EXPORT_SYMBOL_GPL(clk_core_get_rate);
1386
1387 /**
1388  * clk_get_rate - return the rate of clk
1389  * @clk: the clk whose rate is being returned
1390  *
1391  * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
1392  * is set, which means a recalc_rate will be issued.
1393  * If clk is NULL then returns 0.
1394  */
1395 unsigned long clk_get_rate(struct clk *clk)
1396 {
1397         if (!clk)
1398                 return 0;
1399
1400         return clk_core_get_rate(clk->core);
1401 }
1402 EXPORT_SYMBOL_GPL(clk_get_rate);
1403
1404 static int clk_fetch_parent_index(struct clk_core *clk,
1405                                   struct clk_core *parent)
1406 {
1407         int i;
1408
1409         if (!clk->parents) {
1410                 clk->parents = kcalloc(clk->num_parents,
1411                                         sizeof(struct clk *), GFP_KERNEL);
1412                 if (!clk->parents)
1413                         return -ENOMEM;
1414         }
1415
1416         /*
1417          * find index of new parent clock using cached parent ptrs,
1418          * or if not yet cached, use string name comparison and cache
1419          * them now to avoid future calls to clk_core_lookup.
1420          */
1421         for (i = 0; i < clk->num_parents; i++) {
1422                 if (clk->parents[i] == parent)
1423                         return i;
1424
1425                 if (clk->parents[i])
1426                         continue;
1427
1428                 if (!strcmp(clk->parent_names[i], parent->name)) {
1429                         clk->parents[i] = clk_core_lookup(parent->name);
1430                         return i;
1431                 }
1432         }
1433
1434         return -EINVAL;
1435 }
1436
1437 static void clk_reparent(struct clk_core *clk, struct clk_core *new_parent)
1438 {
1439         hlist_del(&clk->child_node);
1440
1441         if (new_parent) {
1442                 /* avoid duplicate POST_RATE_CHANGE notifications */
1443                 if (new_parent->new_child == clk)
1444                         new_parent->new_child = NULL;
1445
1446                 hlist_add_head(&clk->child_node, &new_parent->children);
1447         } else {
1448                 hlist_add_head(&clk->child_node, &clk_orphan_list);
1449         }
1450
1451         clk->parent = new_parent;
1452 }
1453
1454 static struct clk_core *__clk_set_parent_before(struct clk_core *clk,
1455                                            struct clk_core *parent)
1456 {
1457         unsigned long flags;
1458         struct clk_core *old_parent = clk->parent;
1459
1460         /*
1461          * Migrate prepare state between parents and prevent race with
1462          * clk_enable().
1463          *
1464          * If the clock is not prepared, then a race with
1465          * clk_enable/disable() is impossible since we already have the
1466          * prepare lock (future calls to clk_enable() need to be preceded by
1467          * a clk_prepare()).
1468          *
1469          * If the clock is prepared, migrate the prepared state to the new
1470          * parent and also protect against a race with clk_enable() by
1471          * forcing the clock and the new parent on.  This ensures that all
1472          * future calls to clk_enable() are practically NOPs with respect to
1473          * hardware and software states.
1474          *
1475          * See also: Comment for clk_set_parent() below.
1476          */
1477         if (clk->prepare_count) {
1478                 clk_core_prepare(parent);
1479                 clk_core_enable(parent);
1480                 clk_core_enable(clk);
1481         }
1482
1483         /* update the clk tree topology */
1484         flags = clk_enable_lock();
1485         clk_reparent(clk, parent);
1486         clk_enable_unlock(flags);
1487
1488         return old_parent;
1489 }
1490
1491 static void __clk_set_parent_after(struct clk_core *core,
1492                                    struct clk_core *parent,
1493                                    struct clk_core *old_parent)
1494 {
1495         /*
1496          * Finish the migration of prepare state and undo the changes done
1497          * for preventing a race with clk_enable().
1498          */
1499         if (core->prepare_count) {
1500                 clk_core_disable(core);
1501                 clk_core_disable(old_parent);
1502                 clk_core_unprepare(old_parent);
1503         }
1504 }
1505
1506 static int __clk_set_parent(struct clk_core *clk, struct clk_core *parent,
1507                             u8 p_index)
1508 {
1509         unsigned long flags;
1510         int ret = 0;
1511         struct clk_core *old_parent;
1512
1513         old_parent = __clk_set_parent_before(clk, parent);
1514
1515         trace_clk_set_parent(clk, parent);
1516
1517         /* change clock input source */
1518         if (parent && clk->ops->set_parent)
1519                 ret = clk->ops->set_parent(clk->hw, p_index);
1520
1521         trace_clk_set_parent_complete(clk, parent);
1522
1523         if (ret) {
1524                 flags = clk_enable_lock();
1525                 clk_reparent(clk, old_parent);
1526                 clk_enable_unlock(flags);
1527
1528                 if (clk->prepare_count) {
1529                         clk_core_disable(clk);
1530                         clk_core_disable(parent);
1531                         clk_core_unprepare(parent);
1532                 }
1533                 return ret;
1534         }
1535
1536         __clk_set_parent_after(clk, parent, old_parent);
1537
1538         return 0;
1539 }
1540
1541 /**
1542  * __clk_speculate_rates
1543  * @clk: first clk in the subtree
1544  * @parent_rate: the "future" rate of clk's parent
1545  *
1546  * Walks the subtree of clks starting with clk, speculating rates as it
1547  * goes and firing off PRE_RATE_CHANGE notifications as necessary.
1548  *
1549  * Unlike clk_recalc_rates, clk_speculate_rates exists only for sending
1550  * pre-rate change notifications and returns early if no clks in the
1551  * subtree have subscribed to the notifications.  Note that if a clk does not
1552  * implement the .recalc_rate callback then it is assumed that the clock will
1553  * take on the rate of its parent.
1554  *
1555  * Caller must hold prepare_lock.
1556  */
1557 static int __clk_speculate_rates(struct clk_core *clk,
1558                                  unsigned long parent_rate)
1559 {
1560         struct clk_core *child;
1561         unsigned long new_rate;
1562         int ret = NOTIFY_DONE;
1563
1564         lockdep_assert_held(&prepare_lock);
1565
1566         new_rate = clk_recalc(clk, parent_rate);
1567
1568         /* abort rate change if a driver returns NOTIFY_BAD or NOTIFY_STOP */
1569         if (clk->notifier_count)
1570                 ret = __clk_notify(clk, PRE_RATE_CHANGE, clk->rate, new_rate);
1571
1572         if (ret & NOTIFY_STOP_MASK) {
1573                 pr_debug("%s: clk notifier callback for clock %s aborted with error %d\n",
1574                                 __func__, clk->name, ret);
1575                 goto out;
1576         }
1577
1578         hlist_for_each_entry(child, &clk->children, child_node) {
1579                 ret = __clk_speculate_rates(child, new_rate);
1580                 if (ret & NOTIFY_STOP_MASK)
1581                         break;
1582         }
1583
1584 out:
1585         return ret;
1586 }
1587
1588 static void clk_calc_subtree(struct clk_core *clk, unsigned long new_rate,
1589                              struct clk_core *new_parent, u8 p_index)
1590 {
1591         struct clk_core *child;
1592
1593         clk->new_rate = new_rate;
1594         clk->new_parent = new_parent;
1595         clk->new_parent_index = p_index;
1596         /* include clk in new parent's PRE_RATE_CHANGE notifications */
1597         clk->new_child = NULL;
1598         if (new_parent && new_parent != clk->parent)
1599                 new_parent->new_child = clk;
1600
1601         hlist_for_each_entry(child, &clk->children, child_node) {
1602                 child->new_rate = clk_recalc(child, new_rate);
1603                 clk_calc_subtree(child, child->new_rate, NULL, 0);
1604         }
1605 }
1606
1607 /*
1608  * calculate the new rates returning the topmost clock that has to be
1609  * changed.
1610  */
1611 static struct clk_core *clk_calc_new_rates(struct clk_core *clk,
1612                                            unsigned long rate)
1613 {
1614         struct clk_core *top = clk;
1615         struct clk_core *old_parent, *parent;
1616         struct clk_hw *parent_hw;
1617         unsigned long best_parent_rate = 0;
1618         unsigned long new_rate;
1619         unsigned long min_rate;
1620         unsigned long max_rate;
1621         int p_index = 0;
1622
1623         /* sanity */
1624         if (IS_ERR_OR_NULL(clk))
1625                 return NULL;
1626
1627         /* save parent rate, if it exists */
1628         parent = old_parent = clk->parent;
1629         if (parent)
1630                 best_parent_rate = parent->rate;
1631
1632         clk_core_get_boundaries(clk, &min_rate, &max_rate);
1633
1634         /* find the closest rate and parent clk/rate */
1635         if (clk->ops->determine_rate) {
1636                 parent_hw = parent ? parent->hw : NULL;
1637                 new_rate = clk->ops->determine_rate(clk->hw, rate,
1638                                                     min_rate,
1639                                                     max_rate,
1640                                                     &best_parent_rate,
1641                                                     &parent_hw);
1642                 parent = parent_hw ? parent_hw->core : NULL;
1643         } else if (clk->ops->round_rate) {
1644                 new_rate = clk->ops->round_rate(clk->hw, rate,
1645                                                 &best_parent_rate);
1646                 if (new_rate < min_rate || new_rate > max_rate)
1647                         return NULL;
1648         } else if (!parent || !(clk->flags & CLK_SET_RATE_PARENT)) {
1649                 /* pass-through clock without adjustable parent */
1650                 clk->new_rate = clk->rate;
1651                 return NULL;
1652         } else {
1653                 /* pass-through clock with adjustable parent */
1654                 top = clk_calc_new_rates(parent, rate);
1655                 new_rate = parent->new_rate;
1656                 goto out;
1657         }
1658
1659         /* some clocks must be gated to change parent */
1660         if (parent != old_parent &&
1661             (clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count) {
1662                 pr_debug("%s: %s not gated but wants to reparent\n",
1663                          __func__, clk->name);
1664                 return NULL;
1665         }
1666
1667         /* try finding the new parent index */
1668         if (parent && clk->num_parents > 1) {
1669                 p_index = clk_fetch_parent_index(clk, parent);
1670                 if (p_index < 0) {
1671                         pr_debug("%s: clk %s can not be parent of clk %s\n",
1672                                  __func__, parent->name, clk->name);
1673                         return NULL;
1674                 }
1675         }
1676
1677         if ((clk->flags & CLK_SET_RATE_PARENT) && parent &&
1678             best_parent_rate != parent->rate)
1679                 top = clk_calc_new_rates(parent, best_parent_rate);
1680
1681 out:
1682         clk_calc_subtree(clk, new_rate, parent, p_index);
1683
1684         return top;
1685 }
1686
1687 /*
1688  * Notify about rate changes in a subtree. Always walk down the whole tree
1689  * so that in case of an error we can walk down the whole tree again and
1690  * abort the change.
1691  */
1692 static struct clk_core *clk_propagate_rate_change(struct clk_core *clk,
1693                                                   unsigned long event)
1694 {
1695         struct clk_core *child, *tmp_clk, *fail_clk = NULL;
1696         int ret = NOTIFY_DONE;
1697
1698         if (clk->rate == clk->new_rate)
1699                 return NULL;
1700
1701         if (clk->notifier_count) {
1702                 ret = __clk_notify(clk, event, clk->rate, clk->new_rate);
1703                 if (ret & NOTIFY_STOP_MASK)
1704                         fail_clk = clk;
1705         }
1706
1707         hlist_for_each_entry(child, &clk->children, child_node) {
1708                 /* Skip children who will be reparented to another clock */
1709                 if (child->new_parent && child->new_parent != clk)
1710                         continue;
1711                 tmp_clk = clk_propagate_rate_change(child, event);
1712                 if (tmp_clk)
1713                         fail_clk = tmp_clk;
1714         }
1715
1716         /* handle the new child who might not be in clk->children yet */
1717         if (clk->new_child) {
1718                 tmp_clk = clk_propagate_rate_change(clk->new_child, event);
1719                 if (tmp_clk)
1720                         fail_clk = tmp_clk;
1721         }
1722
1723         return fail_clk;
1724 }
1725
1726 /*
1727  * walk down a subtree and set the new rates notifying the rate
1728  * change on the way
1729  */
1730 static void clk_change_rate(struct clk_core *clk)
1731 {
1732         struct clk_core *child;
1733         struct hlist_node *tmp;
1734         unsigned long old_rate;
1735         unsigned long best_parent_rate = 0;
1736         bool skip_set_rate = false;
1737         struct clk_core *old_parent;
1738
1739         old_rate = clk->rate;
1740
1741         if (clk->new_parent)
1742                 best_parent_rate = clk->new_parent->rate;
1743         else if (clk->parent)
1744                 best_parent_rate = clk->parent->rate;
1745
1746         if (clk->new_parent && clk->new_parent != clk->parent) {
1747                 old_parent = __clk_set_parent_before(clk, clk->new_parent);
1748                 trace_clk_set_parent(clk, clk->new_parent);
1749
1750                 if (clk->ops->set_rate_and_parent) {
1751                         skip_set_rate = true;
1752                         clk->ops->set_rate_and_parent(clk->hw, clk->new_rate,
1753                                         best_parent_rate,
1754                                         clk->new_parent_index);
1755                 } else if (clk->ops->set_parent) {
1756                         clk->ops->set_parent(clk->hw, clk->new_parent_index);
1757                 }
1758
1759                 trace_clk_set_parent_complete(clk, clk->new_parent);
1760                 __clk_set_parent_after(clk, clk->new_parent, old_parent);
1761         }
1762
1763         trace_clk_set_rate(clk, clk->new_rate);
1764
1765         if (!skip_set_rate && clk->ops->set_rate)
1766                 clk->ops->set_rate(clk->hw, clk->new_rate, best_parent_rate);
1767
1768         trace_clk_set_rate_complete(clk, clk->new_rate);
1769
1770         clk->rate = clk_recalc(clk, best_parent_rate);
1771
1772         if (clk->notifier_count && old_rate != clk->rate)
1773                 __clk_notify(clk, POST_RATE_CHANGE, old_rate, clk->rate);
1774
1775         /*
1776          * Use safe iteration, as change_rate can actually swap parents
1777          * for certain clock types.
1778          */
1779         hlist_for_each_entry_safe(child, tmp, &clk->children, child_node) {
1780                 /* Skip children who will be reparented to another clock */
1781                 if (child->new_parent && child->new_parent != clk)
1782                         continue;
1783                 clk_change_rate(child);
1784         }
1785
1786         /* handle the new child who might not be in clk->children yet */
1787         if (clk->new_child)
1788                 clk_change_rate(clk->new_child);
1789 }
1790
1791 static int clk_core_set_rate_nolock(struct clk_core *clk,
1792                                     unsigned long req_rate)
1793 {
1794         struct clk_core *top, *fail_clk;
1795         unsigned long rate = req_rate;
1796         int ret = 0;
1797
1798         if (!clk)
1799                 return 0;
1800
1801         /* bail early if nothing to do */
1802         if (rate == clk_core_get_rate_nolock(clk))
1803                 return 0;
1804
1805         if ((clk->flags & CLK_SET_RATE_GATE) && clk->prepare_count)
1806                 return -EBUSY;
1807
1808         /* calculate new rates and get the topmost changed clock */
1809         top = clk_calc_new_rates(clk, rate);
1810         if (!top)
1811                 return -EINVAL;
1812
1813         /* notify that we are about to change rates */
1814         fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
1815         if (fail_clk) {
1816                 pr_debug("%s: failed to set %s rate\n", __func__,
1817                                 fail_clk->name);
1818                 clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
1819                 return -EBUSY;
1820         }
1821
1822         /* change the rates */
1823         clk_change_rate(top);
1824
1825         clk->req_rate = req_rate;
1826
1827         return ret;
1828 }
1829
1830 /**
1831  * clk_set_rate - specify a new rate for clk
1832  * @clk: the clk whose rate is being changed
1833  * @rate: the new rate for clk
1834  *
1835  * In the simplest case clk_set_rate will only adjust the rate of clk.
1836  *
1837  * Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to
1838  * propagate up to clk's parent; whether or not this happens depends on the
1839  * outcome of clk's .round_rate implementation.  If *parent_rate is unchanged
1840  * after calling .round_rate then upstream parent propagation is ignored.  If
1841  * *parent_rate comes back with a new rate for clk's parent then we propagate
1842  * up to clk's parent and set its rate.  Upward propagation will continue
1843  * until either a clk does not support the CLK_SET_RATE_PARENT flag or
1844  * .round_rate stops requesting changes to clk's parent_rate.
1845  *
1846  * Rate changes are accomplished via tree traversal that also recalculates the
1847  * rates for the clocks and fires off POST_RATE_CHANGE notifiers.
1848  *
1849  * Returns 0 on success, -EERROR otherwise.
1850  */
1851 int clk_set_rate(struct clk *clk, unsigned long rate)
1852 {
1853         int ret;
1854
1855         if (!clk)
1856                 return 0;
1857
1858         /* prevent racing with updates to the clock topology */
1859         clk_prepare_lock();
1860
1861         ret = clk_core_set_rate_nolock(clk->core, rate);
1862
1863         clk_prepare_unlock();
1864
1865         return ret;
1866 }
1867 EXPORT_SYMBOL_GPL(clk_set_rate);
1868
1869 /**
1870  * clk_set_rate_range - set a rate range for a clock source
1871  * @clk: clock source
1872  * @min: desired minimum clock rate in Hz, inclusive
1873  * @max: desired maximum clock rate in Hz, inclusive
1874  *
1875  * Returns success (0) or negative errno.
1876  */
1877 int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max)
1878 {
1879         int ret = 0;
1880
1881         if (!clk)
1882                 return 0;
1883
1884         if (min > max) {
1885                 pr_err("%s: clk %s dev %s con %s: invalid range [%lu, %lu]\n",
1886                        __func__, clk->core->name, clk->dev_id, clk->con_id,
1887                        min, max);
1888                 return -EINVAL;
1889         }
1890
1891         clk_prepare_lock();
1892
1893         if (min != clk->min_rate || max != clk->max_rate) {
1894                 clk->min_rate = min;
1895                 clk->max_rate = max;
1896                 ret = clk_core_set_rate_nolock(clk->core, clk->core->req_rate);
1897         }
1898
1899         clk_prepare_unlock();
1900
1901         return ret;
1902 }
1903 EXPORT_SYMBOL_GPL(clk_set_rate_range);
1904
1905 /**
1906  * clk_set_min_rate - set a minimum clock rate for a clock source
1907  * @clk: clock source
1908  * @rate: desired minimum clock rate in Hz, inclusive
1909  *
1910  * Returns success (0) or negative errno.
1911  */
1912 int clk_set_min_rate(struct clk *clk, unsigned long rate)
1913 {
1914         if (!clk)
1915                 return 0;
1916
1917         return clk_set_rate_range(clk, rate, clk->max_rate);
1918 }
1919 EXPORT_SYMBOL_GPL(clk_set_min_rate);
1920
1921 /**
1922  * clk_set_max_rate - set a maximum clock rate for a clock source
1923  * @clk: clock source
1924  * @rate: desired maximum clock rate in Hz, inclusive
1925  *
1926  * Returns success (0) or negative errno.
1927  */
1928 int clk_set_max_rate(struct clk *clk, unsigned long rate)
1929 {
1930         if (!clk)
1931                 return 0;
1932
1933         return clk_set_rate_range(clk, clk->min_rate, rate);
1934 }
1935 EXPORT_SYMBOL_GPL(clk_set_max_rate);
1936
1937 /**
1938  * clk_get_parent - return the parent of a clk
1939  * @clk: the clk whose parent gets returned
1940  *
1941  * Simply returns clk->parent.  Returns NULL if clk is NULL.
1942  */
1943 struct clk *clk_get_parent(struct clk *clk)
1944 {
1945         struct clk *parent;
1946
1947         clk_prepare_lock();
1948         parent = __clk_get_parent(clk);
1949         clk_prepare_unlock();
1950
1951         return parent;
1952 }
1953 EXPORT_SYMBOL_GPL(clk_get_parent);
1954
1955 /*
1956  * .get_parent is mandatory for clocks with multiple possible parents.  It is
1957  * optional for single-parent clocks.  Always call .get_parent if it is
1958  * available and WARN if it is missing for multi-parent clocks.
1959  *
1960  * For single-parent clocks without .get_parent, first check to see if the
1961  * .parents array exists, and if so use it to avoid an expensive tree
1962  * traversal.  If .parents does not exist then walk the tree.
1963  */
1964 static struct clk_core *__clk_init_parent(struct clk_core *clk)
1965 {
1966         struct clk_core *ret = NULL;
1967         u8 index;
1968
1969         /* handle the trivial cases */
1970
1971         if (!clk->num_parents)
1972                 goto out;
1973
1974         if (clk->num_parents == 1) {
1975                 if (IS_ERR_OR_NULL(clk->parent))
1976                         clk->parent = clk_core_lookup(clk->parent_names[0]);
1977                 ret = clk->parent;
1978                 goto out;
1979         }
1980
1981         if (!clk->ops->get_parent) {
1982                 WARN(!clk->ops->get_parent,
1983                         "%s: multi-parent clocks must implement .get_parent\n",
1984                         __func__);
1985                 goto out;
1986         };
1987
1988         /*
1989          * Do our best to cache parent clocks in clk->parents.  This prevents
1990          * unnecessary and expensive lookups.  We don't set clk->parent here;
1991          * that is done by the calling function.
1992          */
1993
1994         index = clk->ops->get_parent(clk->hw);
1995
1996         if (!clk->parents)
1997                 clk->parents =
1998                         kcalloc(clk->num_parents, sizeof(struct clk *),
1999                                         GFP_KERNEL);
2000
2001         ret = clk_core_get_parent_by_index(clk, index);
2002
2003 out:
2004         return ret;
2005 }
2006
2007 static void clk_core_reparent(struct clk_core *clk,
2008                                   struct clk_core *new_parent)
2009 {
2010         clk_reparent(clk, new_parent);
2011         __clk_recalc_accuracies(clk);
2012         __clk_recalc_rates(clk, POST_RATE_CHANGE);
2013 }
2014
2015 /**
2016  * clk_has_parent - check if a clock is a possible parent for another
2017  * @clk: clock source
2018  * @parent: parent clock source
2019  *
2020  * This function can be used in drivers that need to check that a clock can be
2021  * the parent of another without actually changing the parent.
2022  *
2023  * Returns true if @parent is a possible parent for @clk, false otherwise.
2024  */
2025 bool clk_has_parent(struct clk *clk, struct clk *parent)
2026 {
2027         struct clk_core *core, *parent_core;
2028         unsigned int i;
2029
2030         /* NULL clocks should be nops, so return success if either is NULL. */
2031         if (!clk || !parent)
2032                 return true;
2033
2034         core = clk->core;
2035         parent_core = parent->core;
2036
2037         /* Optimize for the case where the parent is already the parent. */
2038         if (core->parent == parent_core)
2039                 return true;
2040
2041         for (i = 0; i < core->num_parents; i++)
2042                 if (strcmp(core->parent_names[i], parent_core->name) == 0)
2043                         return true;
2044
2045         return false;
2046 }
2047 EXPORT_SYMBOL_GPL(clk_has_parent);
2048
2049 static int clk_core_set_parent(struct clk_core *clk, struct clk_core *parent)
2050 {
2051         int ret = 0;
2052         int p_index = 0;
2053         unsigned long p_rate = 0;
2054
2055         if (!clk)
2056                 return 0;
2057
2058         /* prevent racing with updates to the clock topology */
2059         clk_prepare_lock();
2060
2061         if (clk->parent == parent)
2062                 goto out;
2063
2064         /* verify ops for for multi-parent clks */
2065         if ((clk->num_parents > 1) && (!clk->ops->set_parent)) {
2066                 ret = -ENOSYS;
2067                 goto out;
2068         }
2069
2070         /* check that we are allowed to re-parent if the clock is in use */
2071         if ((clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count) {
2072                 ret = -EBUSY;
2073                 goto out;
2074         }
2075
2076         /* try finding the new parent index */
2077         if (parent) {
2078                 p_index = clk_fetch_parent_index(clk, parent);
2079                 p_rate = parent->rate;
2080                 if (p_index < 0) {
2081                         pr_debug("%s: clk %s can not be parent of clk %s\n",
2082                                         __func__, parent->name, clk->name);
2083                         ret = p_index;
2084                         goto out;
2085                 }
2086         }
2087
2088         /* propagate PRE_RATE_CHANGE notifications */
2089         ret = __clk_speculate_rates(clk, p_rate);
2090
2091         /* abort if a driver objects */
2092         if (ret & NOTIFY_STOP_MASK)
2093                 goto out;
2094
2095         /* do the re-parent */
2096         ret = __clk_set_parent(clk, parent, p_index);
2097
2098         /* propagate rate an accuracy recalculation accordingly */
2099         if (ret) {
2100                 __clk_recalc_rates(clk, ABORT_RATE_CHANGE);
2101         } else {
2102                 __clk_recalc_rates(clk, POST_RATE_CHANGE);
2103                 __clk_recalc_accuracies(clk);
2104         }
2105
2106 out:
2107         clk_prepare_unlock();
2108
2109         return ret;
2110 }
2111
2112 /**
2113  * clk_set_parent - switch the parent of a mux clk
2114  * @clk: the mux clk whose input we are switching
2115  * @parent: the new input to clk
2116  *
2117  * Re-parent clk to use parent as its new input source.  If clk is in
2118  * prepared state, the clk will get enabled for the duration of this call. If
2119  * that's not acceptable for a specific clk (Eg: the consumer can't handle
2120  * that, the reparenting is glitchy in hardware, etc), use the
2121  * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
2122  *
2123  * After successfully changing clk's parent clk_set_parent will update the
2124  * clk topology, sysfs topology and propagate rate recalculation via
2125  * __clk_recalc_rates.
2126  *
2127  * Returns 0 on success, -EERROR otherwise.
2128  */
2129 int clk_set_parent(struct clk *clk, struct clk *parent)
2130 {
2131         if (!clk)
2132                 return 0;
2133
2134         return clk_core_set_parent(clk->core, parent ? parent->core : NULL);
2135 }
2136 EXPORT_SYMBOL_GPL(clk_set_parent);
2137
2138 /**
2139  * clk_set_phase - adjust the phase shift of a clock signal
2140  * @clk: clock signal source
2141  * @degrees: number of degrees the signal is shifted
2142  *
2143  * Shifts the phase of a clock signal by the specified
2144  * degrees. Returns 0 on success, -EERROR otherwise.
2145  *
2146  * This function makes no distinction about the input or reference
2147  * signal that we adjust the clock signal phase against. For example
2148  * phase locked-loop clock signal generators we may shift phase with
2149  * respect to feedback clock signal input, but for other cases the
2150  * clock phase may be shifted with respect to some other, unspecified
2151  * signal.
2152  *
2153  * Additionally the concept of phase shift does not propagate through
2154  * the clock tree hierarchy, which sets it apart from clock rates and
2155  * clock accuracy. A parent clock phase attribute does not have an
2156  * impact on the phase attribute of a child clock.
2157  */
2158 int clk_set_phase(struct clk *clk, int degrees)
2159 {
2160         int ret = -EINVAL;
2161
2162         if (!clk)
2163                 return 0;
2164
2165         /* sanity check degrees */
2166         degrees %= 360;
2167         if (degrees < 0)
2168                 degrees += 360;
2169
2170         clk_prepare_lock();
2171
2172         trace_clk_set_phase(clk->core, degrees);
2173
2174         if (clk->core->ops->set_phase)
2175                 ret = clk->core->ops->set_phase(clk->core->hw, degrees);
2176
2177         trace_clk_set_phase_complete(clk->core, degrees);
2178
2179         if (!ret)
2180                 clk->core->phase = degrees;
2181
2182         clk_prepare_unlock();
2183
2184         return ret;
2185 }
2186 EXPORT_SYMBOL_GPL(clk_set_phase);
2187
2188 static int clk_core_get_phase(struct clk_core *clk)
2189 {
2190         int ret = 0;
2191
2192         if (!clk)
2193                 goto out;
2194
2195         clk_prepare_lock();
2196         ret = clk->phase;
2197         clk_prepare_unlock();
2198
2199 out:
2200         return ret;
2201 }
2202 EXPORT_SYMBOL_GPL(clk_get_phase);
2203
2204 /**
2205  * clk_get_phase - return the phase shift of a clock signal
2206  * @clk: clock signal source
2207  *
2208  * Returns the phase shift of a clock node in degrees, otherwise returns
2209  * -EERROR.
2210  */
2211 int clk_get_phase(struct clk *clk)
2212 {
2213         if (!clk)
2214                 return 0;
2215
2216         return clk_core_get_phase(clk->core);
2217 }
2218
2219 /**
2220  * __clk_init - initialize the data structures in a struct clk
2221  * @dev:        device initializing this clk, placeholder for now
2222  * @clk:        clk being initialized
2223  *
2224  * Initializes the lists in struct clk_core, queries the hardware for the
2225  * parent and rate and sets them both.
2226  */
2227 static int __clk_init(struct device *dev, struct clk *clk_user)
2228 {
2229         int i, ret = 0;
2230         struct clk_core *orphan;
2231         struct hlist_node *tmp2;
2232         struct clk_core *clk;
2233         unsigned long rate;
2234
2235         if (!clk_user)
2236                 return -EINVAL;
2237
2238         clk = clk_user->core;
2239
2240         clk_prepare_lock();
2241
2242         /* check to see if a clock with this name is already registered */
2243         if (clk_core_lookup(clk->name)) {
2244                 pr_debug("%s: clk %s already initialized\n",
2245                                 __func__, clk->name);
2246                 ret = -EEXIST;
2247                 goto out;
2248         }
2249
2250         /* check that clk_ops are sane.  See Documentation/clk.txt */
2251         if (clk->ops->set_rate &&
2252             !((clk->ops->round_rate || clk->ops->determine_rate) &&
2253               clk->ops->recalc_rate)) {
2254                 pr_warning("%s: %s must implement .round_rate or .determine_rate in addition to .recalc_rate\n",
2255                                 __func__, clk->name);
2256                 ret = -EINVAL;
2257                 goto out;
2258         }
2259
2260         if (clk->ops->set_parent && !clk->ops->get_parent) {
2261                 pr_warning("%s: %s must implement .get_parent & .set_parent\n",
2262                                 __func__, clk->name);
2263                 ret = -EINVAL;
2264                 goto out;
2265         }
2266
2267         if (clk->ops->set_rate_and_parent &&
2268                         !(clk->ops->set_parent && clk->ops->set_rate)) {
2269                 pr_warn("%s: %s must implement .set_parent & .set_rate\n",
2270                                 __func__, clk->name);
2271                 ret = -EINVAL;
2272                 goto out;
2273         }
2274
2275         /* throw a WARN if any entries in parent_names are NULL */
2276         for (i = 0; i < clk->num_parents; i++)
2277                 WARN(!clk->parent_names[i],
2278                                 "%s: invalid NULL in %s's .parent_names\n",
2279                                 __func__, clk->name);
2280
2281         /*
2282          * Allocate an array of struct clk *'s to avoid unnecessary string
2283          * look-ups of clk's possible parents.  This can fail for clocks passed
2284          * in to clk_init during early boot; thus any access to clk->parents[]
2285          * must always check for a NULL pointer and try to populate it if
2286          * necessary.
2287          *
2288          * If clk->parents is not NULL we skip this entire block.  This allows
2289          * for clock drivers to statically initialize clk->parents.
2290          */
2291         if (clk->num_parents > 1 && !clk->parents) {
2292                 clk->parents = kcalloc(clk->num_parents, sizeof(struct clk *),
2293                                         GFP_KERNEL);
2294                 /*
2295                  * clk_core_lookup returns NULL for parents that have not been
2296                  * clk_init'd; thus any access to clk->parents[] must check
2297                  * for a NULL pointer.  We can always perform lazy lookups for
2298                  * missing parents later on.
2299                  */
2300                 if (clk->parents)
2301                         for (i = 0; i < clk->num_parents; i++)
2302                                 clk->parents[i] =
2303                                         clk_core_lookup(clk->parent_names[i]);
2304         }
2305
2306         clk->parent = __clk_init_parent(clk);
2307
2308         /*
2309          * Populate clk->parent if parent has already been __clk_init'd.  If
2310          * parent has not yet been __clk_init'd then place clk in the orphan
2311          * list.  If clk has set the CLK_IS_ROOT flag then place it in the root
2312          * clk list.
2313          *
2314          * Every time a new clk is clk_init'd then we walk the list of orphan
2315          * clocks and re-parent any that are children of the clock currently
2316          * being clk_init'd.
2317          */
2318         if (clk->parent)
2319                 hlist_add_head(&clk->child_node,
2320                                 &clk->parent->children);
2321         else if (clk->flags & CLK_IS_ROOT)
2322                 hlist_add_head(&clk->child_node, &clk_root_list);
2323         else
2324                 hlist_add_head(&clk->child_node, &clk_orphan_list);
2325
2326         /*
2327          * Set clk's accuracy.  The preferred method is to use
2328          * .recalc_accuracy. For simple clocks and lazy developers the default
2329          * fallback is to use the parent's accuracy.  If a clock doesn't have a
2330          * parent (or is orphaned) then accuracy is set to zero (perfect
2331          * clock).
2332          */
2333         if (clk->ops->recalc_accuracy)
2334                 clk->accuracy = clk->ops->recalc_accuracy(clk->hw,
2335                                         __clk_get_accuracy(clk->parent));
2336         else if (clk->parent)
2337                 clk->accuracy = clk->parent->accuracy;
2338         else
2339                 clk->accuracy = 0;
2340
2341         /*
2342          * Set clk's phase.
2343          * Since a phase is by definition relative to its parent, just
2344          * query the current clock phase, or just assume it's in phase.
2345          */
2346         if (clk->ops->get_phase)
2347                 clk->phase = clk->ops->get_phase(clk->hw);
2348         else
2349                 clk->phase = 0;
2350
2351         /*
2352          * Set clk's rate.  The preferred method is to use .recalc_rate.  For
2353          * simple clocks and lazy developers the default fallback is to use the
2354          * parent's rate.  If a clock doesn't have a parent (or is orphaned)
2355          * then rate is set to zero.
2356          */
2357         if (clk->ops->recalc_rate)
2358                 rate = clk->ops->recalc_rate(clk->hw,
2359                                 clk_core_get_rate_nolock(clk->parent));
2360         else if (clk->parent)
2361                 rate = clk->parent->rate;
2362         else
2363                 rate = 0;
2364         clk->rate = clk->req_rate = rate;
2365
2366         /*
2367          * walk the list of orphan clocks and reparent any that are children of
2368          * this clock
2369          */
2370         hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
2371                 if (orphan->num_parents && orphan->ops->get_parent) {
2372                         i = orphan->ops->get_parent(orphan->hw);
2373                         if (!strcmp(clk->name, orphan->parent_names[i]))
2374                                 clk_core_reparent(orphan, clk);
2375                         continue;
2376                 }
2377
2378                 for (i = 0; i < orphan->num_parents; i++)
2379                         if (!strcmp(clk->name, orphan->parent_names[i])) {
2380                                 clk_core_reparent(orphan, clk);
2381                                 break;
2382                         }
2383          }
2384
2385         /*
2386          * optional platform-specific magic
2387          *
2388          * The .init callback is not used by any of the basic clock types, but
2389          * exists for weird hardware that must perform initialization magic.
2390          * Please consider other ways of solving initialization problems before
2391          * using this callback, as its use is discouraged.
2392          */
2393         if (clk->ops->init)
2394                 clk->ops->init(clk->hw);
2395
2396         kref_init(&clk->ref);
2397 out:
2398         clk_prepare_unlock();
2399
2400         if (!ret)
2401                 clk_debug_register(clk);
2402
2403         return ret;
2404 }
2405
2406 struct clk *__clk_create_clk(struct clk_hw *hw, const char *dev_id,
2407                              const char *con_id)
2408 {
2409         struct clk *clk;
2410
2411         /* This is to allow this function to be chained to others */
2412         if (!hw || IS_ERR(hw))
2413                 return (struct clk *) hw;
2414
2415         clk = kzalloc(sizeof(*clk), GFP_KERNEL);
2416         if (!clk)
2417                 return ERR_PTR(-ENOMEM);
2418
2419         clk->core = hw->core;
2420         clk->dev_id = dev_id;
2421         clk->con_id = con_id;
2422         clk->max_rate = ULONG_MAX;
2423
2424         clk_prepare_lock();
2425         hlist_add_head(&clk->child_node, &hw->core->clks);
2426         clk_prepare_unlock();
2427
2428         return clk;
2429 }
2430
2431 void __clk_free_clk(struct clk *clk)
2432 {
2433         clk_prepare_lock();
2434         hlist_del(&clk->child_node);
2435         clk_prepare_unlock();
2436
2437         kfree(clk);
2438 }
2439
2440 /**
2441  * clk_register - allocate a new clock, register it and return an opaque cookie
2442  * @dev: device that is registering this clock
2443  * @hw: link to hardware-specific clock data
2444  *
2445  * clk_register is the primary interface for populating the clock tree with new
2446  * clock nodes.  It returns a pointer to the newly allocated struct clk which
2447  * cannot be dereferenced by driver code but may be used in conjuction with the
2448  * rest of the clock API.  In the event of an error clk_register will return an
2449  * error code; drivers must test for an error code after calling clk_register.
2450  */
2451 struct clk *clk_register(struct device *dev, struct clk_hw *hw)
2452 {
2453         int i, ret;
2454         struct clk_core *clk;
2455
2456         clk = kzalloc(sizeof(*clk), GFP_KERNEL);
2457         if (!clk) {
2458                 pr_err("%s: could not allocate clk\n", __func__);
2459                 ret = -ENOMEM;
2460                 goto fail_out;
2461         }
2462
2463         clk->name = kstrdup_const(hw->init->name, GFP_KERNEL);
2464         if (!clk->name) {
2465                 pr_err("%s: could not allocate clk->name\n", __func__);
2466                 ret = -ENOMEM;
2467                 goto fail_name;
2468         }
2469         clk->ops = hw->init->ops;
2470         if (dev && dev->driver)
2471                 clk->owner = dev->driver->owner;
2472         clk->hw = hw;
2473         clk->flags = hw->init->flags;
2474         clk->num_parents = hw->init->num_parents;
2475         hw->core = clk;
2476
2477         /* allocate local copy in case parent_names is __initdata */
2478         clk->parent_names = kcalloc(clk->num_parents, sizeof(char *),
2479                                         GFP_KERNEL);
2480
2481         if (!clk->parent_names) {
2482                 pr_err("%s: could not allocate clk->parent_names\n", __func__);
2483                 ret = -ENOMEM;
2484                 goto fail_parent_names;
2485         }
2486
2487
2488         /* copy each string name in case parent_names is __initdata */
2489         for (i = 0; i < clk->num_parents; i++) {
2490                 clk->parent_names[i] = kstrdup_const(hw->init->parent_names[i],
2491                                                 GFP_KERNEL);
2492                 if (!clk->parent_names[i]) {
2493                         pr_err("%s: could not copy parent_names\n", __func__);
2494                         ret = -ENOMEM;
2495                         goto fail_parent_names_copy;
2496                 }
2497         }
2498
2499         INIT_HLIST_HEAD(&clk->clks);
2500
2501         hw->clk = __clk_create_clk(hw, NULL, NULL);
2502         if (IS_ERR(hw->clk)) {
2503                 pr_err("%s: could not allocate per-user clk\n", __func__);
2504                 ret = PTR_ERR(hw->clk);
2505                 goto fail_parent_names_copy;
2506         }
2507
2508         ret = __clk_init(dev, hw->clk);
2509         if (!ret)
2510                 return hw->clk;
2511
2512         __clk_free_clk(hw->clk);
2513         hw->clk = NULL;
2514
2515 fail_parent_names_copy:
2516         while (--i >= 0)
2517                 kfree_const(clk->parent_names[i]);
2518         kfree(clk->parent_names);
2519 fail_parent_names:
2520         kfree_const(clk->name);
2521 fail_name:
2522         kfree(clk);
2523 fail_out:
2524         return ERR_PTR(ret);
2525 }
2526 EXPORT_SYMBOL_GPL(clk_register);
2527
2528 /*
2529  * Free memory allocated for a clock.
2530  * Caller must hold prepare_lock.
2531  */
2532 static void __clk_release(struct kref *ref)
2533 {
2534         struct clk_core *clk = container_of(ref, struct clk_core, ref);
2535         int i = clk->num_parents;
2536
2537         lockdep_assert_held(&prepare_lock);
2538
2539         kfree(clk->parents);
2540         while (--i >= 0)
2541                 kfree_const(clk->parent_names[i]);
2542
2543         kfree(clk->parent_names);
2544         kfree_const(clk->name);
2545         kfree(clk);
2546 }
2547
2548 /*
2549  * Empty clk_ops for unregistered clocks. These are used temporarily
2550  * after clk_unregister() was called on a clock and until last clock
2551  * consumer calls clk_put() and the struct clk object is freed.
2552  */
2553 static int clk_nodrv_prepare_enable(struct clk_hw *hw)
2554 {
2555         return -ENXIO;
2556 }
2557
2558 static void clk_nodrv_disable_unprepare(struct clk_hw *hw)
2559 {
2560         WARN_ON_ONCE(1);
2561 }
2562
2563 static int clk_nodrv_set_rate(struct clk_hw *hw, unsigned long rate,
2564                                         unsigned long parent_rate)
2565 {
2566         return -ENXIO;
2567 }
2568
2569 static int clk_nodrv_set_parent(struct clk_hw *hw, u8 index)
2570 {
2571         return -ENXIO;
2572 }
2573
2574 static const struct clk_ops clk_nodrv_ops = {
2575         .enable         = clk_nodrv_prepare_enable,
2576         .disable        = clk_nodrv_disable_unprepare,
2577         .prepare        = clk_nodrv_prepare_enable,
2578         .unprepare      = clk_nodrv_disable_unprepare,
2579         .set_rate       = clk_nodrv_set_rate,
2580         .set_parent     = clk_nodrv_set_parent,
2581 };
2582
2583 /**
2584  * clk_unregister - unregister a currently registered clock
2585  * @clk: clock to unregister
2586  */
2587 void clk_unregister(struct clk *clk)
2588 {
2589         unsigned long flags;
2590
2591         if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
2592                 return;
2593
2594         clk_debug_unregister(clk->core);
2595
2596         clk_prepare_lock();
2597
2598         if (clk->core->ops == &clk_nodrv_ops) {
2599                 pr_err("%s: unregistered clock: %s\n", __func__,
2600                        clk->core->name);
2601                 return;
2602         }
2603         /*
2604          * Assign empty clock ops for consumers that might still hold
2605          * a reference to this clock.
2606          */
2607         flags = clk_enable_lock();
2608         clk->core->ops = &clk_nodrv_ops;
2609         clk_enable_unlock(flags);
2610
2611         if (!hlist_empty(&clk->core->children)) {
2612                 struct clk_core *child;
2613                 struct hlist_node *t;
2614
2615                 /* Reparent all children to the orphan list. */
2616                 hlist_for_each_entry_safe(child, t, &clk->core->children,
2617                                           child_node)
2618                         clk_core_set_parent(child, NULL);
2619         }
2620
2621         hlist_del_init(&clk->core->child_node);
2622
2623         if (clk->core->prepare_count)
2624                 pr_warn("%s: unregistering prepared clock: %s\n",
2625                                         __func__, clk->core->name);
2626         kref_put(&clk->core->ref, __clk_release);
2627
2628         clk_prepare_unlock();
2629 }
2630 EXPORT_SYMBOL_GPL(clk_unregister);
2631
2632 static void devm_clk_release(struct device *dev, void *res)
2633 {
2634         clk_unregister(*(struct clk **)res);
2635 }
2636
2637 /**
2638  * devm_clk_register - resource managed clk_register()
2639  * @dev: device that is registering this clock
2640  * @hw: link to hardware-specific clock data
2641  *
2642  * Managed clk_register(). Clocks returned from this function are
2643  * automatically clk_unregister()ed on driver detach. See clk_register() for
2644  * more information.
2645  */
2646 struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw)
2647 {
2648         struct clk *clk;
2649         struct clk **clkp;
2650
2651         clkp = devres_alloc(devm_clk_release, sizeof(*clkp), GFP_KERNEL);
2652         if (!clkp)
2653                 return ERR_PTR(-ENOMEM);
2654
2655         clk = clk_register(dev, hw);
2656         if (!IS_ERR(clk)) {
2657                 *clkp = clk;
2658                 devres_add(dev, clkp);
2659         } else {
2660                 devres_free(clkp);
2661         }
2662
2663         return clk;
2664 }
2665 EXPORT_SYMBOL_GPL(devm_clk_register);
2666
2667 static int devm_clk_match(struct device *dev, void *res, void *data)
2668 {
2669         struct clk *c = res;
2670         if (WARN_ON(!c))
2671                 return 0;
2672         return c == data;
2673 }
2674
2675 /**
2676  * devm_clk_unregister - resource managed clk_unregister()
2677  * @clk: clock to unregister
2678  *
2679  * Deallocate a clock allocated with devm_clk_register(). Normally
2680  * this function will not need to be called and the resource management
2681  * code will ensure that the resource is freed.
2682  */
2683 void devm_clk_unregister(struct device *dev, struct clk *clk)
2684 {
2685         WARN_ON(devres_release(dev, devm_clk_release, devm_clk_match, clk));
2686 }
2687 EXPORT_SYMBOL_GPL(devm_clk_unregister);
2688
2689 /*
2690  * clkdev helpers
2691  */
2692 int __clk_get(struct clk *clk)
2693 {
2694         struct clk_core *core = !clk ? NULL : clk->core;
2695
2696         if (core) {
2697                 if (!try_module_get(core->owner))
2698                         return 0;
2699
2700                 kref_get(&core->ref);
2701         }
2702         return 1;
2703 }
2704
2705 void __clk_put(struct clk *clk)
2706 {
2707         struct module *owner;
2708
2709         if (!clk || WARN_ON_ONCE(IS_ERR(clk)))
2710                 return;
2711
2712         clk_prepare_lock();
2713
2714         hlist_del(&clk->child_node);
2715         if (clk->min_rate > clk->core->req_rate ||
2716             clk->max_rate < clk->core->req_rate)
2717                 clk_core_set_rate_nolock(clk->core, clk->core->req_rate);
2718
2719         owner = clk->core->owner;
2720         kref_put(&clk->core->ref, __clk_release);
2721
2722         clk_prepare_unlock();
2723
2724         module_put(owner);
2725
2726         kfree(clk);
2727 }
2728
2729 /***        clk rate change notifiers        ***/
2730
2731 /**
2732  * clk_notifier_register - add a clk rate change notifier
2733  * @clk: struct clk * to watch
2734  * @nb: struct notifier_block * with callback info
2735  *
2736  * Request notification when clk's rate changes.  This uses an SRCU
2737  * notifier because we want it to block and notifier unregistrations are
2738  * uncommon.  The callbacks associated with the notifier must not
2739  * re-enter into the clk framework by calling any top-level clk APIs;
2740  * this will cause a nested prepare_lock mutex.
2741  *
2742  * In all notification cases cases (pre, post and abort rate change) the
2743  * original clock rate is passed to the callback via struct
2744  * clk_notifier_data.old_rate and the new frequency is passed via struct
2745  * clk_notifier_data.new_rate.
2746  *
2747  * clk_notifier_register() must be called from non-atomic context.
2748  * Returns -EINVAL if called with null arguments, -ENOMEM upon
2749  * allocation failure; otherwise, passes along the return value of
2750  * srcu_notifier_chain_register().
2751  */
2752 int clk_notifier_register(struct clk *clk, struct notifier_block *nb)
2753 {
2754         struct clk_notifier *cn;
2755         int ret = -ENOMEM;
2756
2757         if (!clk || !nb)
2758                 return -EINVAL;
2759
2760         clk_prepare_lock();
2761
2762         /* search the list of notifiers for this clk */
2763         list_for_each_entry(cn, &clk_notifier_list, node)
2764                 if (cn->clk == clk)
2765                         break;
2766
2767         /* if clk wasn't in the notifier list, allocate new clk_notifier */
2768         if (cn->clk != clk) {
2769                 cn = kzalloc(sizeof(struct clk_notifier), GFP_KERNEL);
2770                 if (!cn)
2771                         goto out;
2772
2773                 cn->clk = clk;
2774                 srcu_init_notifier_head(&cn->notifier_head);
2775
2776                 list_add(&cn->node, &clk_notifier_list);
2777         }
2778
2779         ret = srcu_notifier_chain_register(&cn->notifier_head, nb);
2780
2781         clk->core->notifier_count++;
2782
2783 out:
2784         clk_prepare_unlock();
2785
2786         return ret;
2787 }
2788 EXPORT_SYMBOL_GPL(clk_notifier_register);
2789
2790 /**
2791  * clk_notifier_unregister - remove a clk rate change notifier
2792  * @clk: struct clk *
2793  * @nb: struct notifier_block * with callback info
2794  *
2795  * Request no further notification for changes to 'clk' and frees memory
2796  * allocated in clk_notifier_register.
2797  *
2798  * Returns -EINVAL if called with null arguments; otherwise, passes
2799  * along the return value of srcu_notifier_chain_unregister().
2800  */
2801 int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb)
2802 {
2803         struct clk_notifier *cn = NULL;
2804         int ret = -EINVAL;
2805
2806         if (!clk || !nb)
2807                 return -EINVAL;
2808
2809         clk_prepare_lock();
2810
2811         list_for_each_entry(cn, &clk_notifier_list, node)
2812                 if (cn->clk == clk)
2813                         break;
2814
2815         if (cn->clk == clk) {
2816                 ret = srcu_notifier_chain_unregister(&cn->notifier_head, nb);
2817
2818                 clk->core->notifier_count--;
2819
2820                 /* XXX the notifier code should handle this better */
2821                 if (!cn->notifier_head.head) {
2822                         srcu_cleanup_notifier_head(&cn->notifier_head);
2823                         list_del(&cn->node);
2824                         kfree(cn);
2825                 }
2826
2827         } else {
2828                 ret = -ENOENT;
2829         }
2830
2831         clk_prepare_unlock();
2832
2833         return ret;
2834 }
2835 EXPORT_SYMBOL_GPL(clk_notifier_unregister);
2836
2837 #ifdef CONFIG_OF
2838 /**
2839  * struct of_clk_provider - Clock provider registration structure
2840  * @link: Entry in global list of clock providers
2841  * @node: Pointer to device tree node of clock provider
2842  * @get: Get clock callback.  Returns NULL or a struct clk for the
2843  *       given clock specifier
2844  * @data: context pointer to be passed into @get callback
2845  */
2846 struct of_clk_provider {
2847         struct list_head link;
2848
2849         struct device_node *node;
2850         struct clk *(*get)(struct of_phandle_args *clkspec, void *data);
2851         void *data;
2852 };
2853
2854 static const struct of_device_id __clk_of_table_sentinel
2855         __used __section(__clk_of_table_end);
2856
2857 static LIST_HEAD(of_clk_providers);
2858 static DEFINE_MUTEX(of_clk_mutex);
2859
2860 /* of_clk_provider list locking helpers */
2861 void of_clk_lock(void)
2862 {
2863         mutex_lock(&of_clk_mutex);
2864 }
2865
2866 void of_clk_unlock(void)
2867 {
2868         mutex_unlock(&of_clk_mutex);
2869 }
2870
2871 struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
2872                                      void *data)
2873 {
2874         return data;
2875 }
2876 EXPORT_SYMBOL_GPL(of_clk_src_simple_get);
2877
2878 struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data)
2879 {
2880         struct clk_onecell_data *clk_data = data;
2881         unsigned int idx = clkspec->args[0];
2882
2883         if (idx >= clk_data->clk_num) {
2884                 pr_err("%s: invalid clock index %d\n", __func__, idx);
2885                 return ERR_PTR(-EINVAL);
2886         }
2887
2888         return clk_data->clks[idx];
2889 }
2890 EXPORT_SYMBOL_GPL(of_clk_src_onecell_get);
2891
2892 /**
2893  * of_clk_add_provider() - Register a clock provider for a node
2894  * @np: Device node pointer associated with clock provider
2895  * @clk_src_get: callback for decoding clock
2896  * @data: context pointer for @clk_src_get callback.
2897  */
2898 int of_clk_add_provider(struct device_node *np,
2899                         struct clk *(*clk_src_get)(struct of_phandle_args *clkspec,
2900                                                    void *data),
2901                         void *data)
2902 {
2903         struct of_clk_provider *cp;
2904         int ret;
2905
2906         cp = kzalloc(sizeof(struct of_clk_provider), GFP_KERNEL);
2907         if (!cp)
2908                 return -ENOMEM;
2909
2910         cp->node = of_node_get(np);
2911         cp->data = data;
2912         cp->get = clk_src_get;
2913
2914         mutex_lock(&of_clk_mutex);
2915         list_add(&cp->link, &of_clk_providers);
2916         mutex_unlock(&of_clk_mutex);
2917         pr_debug("Added clock from %s\n", np->full_name);
2918
2919         ret = of_clk_set_defaults(np, true);
2920         if (ret < 0)
2921                 of_clk_del_provider(np);
2922
2923         return ret;
2924 }
2925 EXPORT_SYMBOL_GPL(of_clk_add_provider);
2926
2927 /**
2928  * of_clk_del_provider() - Remove a previously registered clock provider
2929  * @np: Device node pointer associated with clock provider
2930  */
2931 void of_clk_del_provider(struct device_node *np)
2932 {
2933         struct of_clk_provider *cp;
2934
2935         mutex_lock(&of_clk_mutex);
2936         list_for_each_entry(cp, &of_clk_providers, link) {
2937                 if (cp->node == np) {
2938                         list_del(&cp->link);
2939                         of_node_put(cp->node);
2940                         kfree(cp);
2941                         break;
2942                 }
2943         }
2944         mutex_unlock(&of_clk_mutex);
2945 }
2946 EXPORT_SYMBOL_GPL(of_clk_del_provider);
2947
2948 struct clk *__of_clk_get_from_provider(struct of_phandle_args *clkspec,
2949                                        const char *dev_id, const char *con_id)
2950 {
2951         struct of_clk_provider *provider;
2952         struct clk *clk = ERR_PTR(-EPROBE_DEFER);
2953
2954         /* Check if we have such a provider in our array */
2955         list_for_each_entry(provider, &of_clk_providers, link) {
2956                 if (provider->node == clkspec->np)
2957                         clk = provider->get(clkspec, provider->data);
2958                 if (!IS_ERR(clk)) {
2959                         clk = __clk_create_clk(__clk_get_hw(clk), dev_id,
2960                                                con_id);
2961
2962                         if (!IS_ERR(clk) && !__clk_get(clk)) {
2963                                 __clk_free_clk(clk);
2964                                 clk = ERR_PTR(-ENOENT);
2965                         }
2966
2967                         break;
2968                 }
2969         }
2970
2971         return clk;
2972 }
2973
2974 struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
2975 {
2976         struct clk *clk;
2977
2978         mutex_lock(&of_clk_mutex);
2979         clk = __of_clk_get_from_provider(clkspec, NULL, __func__);
2980         mutex_unlock(&of_clk_mutex);
2981
2982         return clk;
2983 }
2984
2985 int of_clk_get_parent_count(struct device_node *np)
2986 {
2987         return of_count_phandle_with_args(np, "clocks", "#clock-cells");
2988 }
2989 EXPORT_SYMBOL_GPL(of_clk_get_parent_count);
2990
2991 const char *of_clk_get_parent_name(struct device_node *np, int index)
2992 {
2993         struct of_phandle_args clkspec;
2994         struct property *prop;
2995         const char *clk_name;
2996         const __be32 *vp;
2997         u32 pv;
2998         int rc;
2999         int count;
3000
3001         if (index < 0)
3002                 return NULL;
3003
3004         rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index,
3005                                         &clkspec);
3006         if (rc)
3007                 return NULL;
3008
3009         index = clkspec.args_count ? clkspec.args[0] : 0;
3010         count = 0;
3011
3012         /* if there is an indices property, use it to transfer the index
3013          * specified into an array offset for the clock-output-names property.
3014          */
3015         of_property_for_each_u32(clkspec.np, "clock-indices", prop, vp, pv) {
3016                 if (index == pv) {
3017                         index = count;
3018                         break;
3019                 }
3020                 count++;
3021         }
3022
3023         if (of_property_read_string_index(clkspec.np, "clock-output-names",
3024                                           index,
3025                                           &clk_name) < 0)
3026                 clk_name = clkspec.np->name;
3027
3028         of_node_put(clkspec.np);
3029         return clk_name;
3030 }
3031 EXPORT_SYMBOL_GPL(of_clk_get_parent_name);
3032
3033 struct clock_provider {
3034         of_clk_init_cb_t clk_init_cb;
3035         struct device_node *np;
3036         struct list_head node;
3037 };
3038
3039 static LIST_HEAD(clk_provider_list);
3040
3041 /*
3042  * This function looks for a parent clock. If there is one, then it
3043  * checks that the provider for this parent clock was initialized, in
3044  * this case the parent clock will be ready.
3045  */
3046 static int parent_ready(struct device_node *np)
3047 {
3048         int i = 0;
3049
3050         while (true) {
3051                 struct clk *clk = of_clk_get(np, i);
3052
3053                 /* this parent is ready we can check the next one */
3054                 if (!IS_ERR(clk)) {
3055                         clk_put(clk);
3056                         i++;
3057                         continue;
3058                 }
3059
3060                 /* at least one parent is not ready, we exit now */
3061                 if (PTR_ERR(clk) == -EPROBE_DEFER)
3062                         return 0;
3063
3064                 /*
3065                  * Here we make assumption that the device tree is
3066                  * written correctly. So an error means that there is
3067                  * no more parent. As we didn't exit yet, then the
3068                  * previous parent are ready. If there is no clock
3069                  * parent, no need to wait for them, then we can
3070                  * consider their absence as being ready
3071                  */
3072                 return 1;
3073         }
3074 }
3075
3076 /**
3077  * of_clk_init() - Scan and init clock providers from the DT
3078  * @matches: array of compatible values and init functions for providers.
3079  *
3080  * This function scans the device tree for matching clock providers
3081  * and calls their initialization functions. It also does it by trying
3082  * to follow the dependencies.
3083  */
3084 void __init of_clk_init(const struct of_device_id *matches)
3085 {
3086         const struct of_device_id *match;
3087         struct device_node *np;
3088         struct clock_provider *clk_provider, *next;
3089         bool is_init_done;
3090         bool force = false;
3091
3092         if (!matches)
3093                 matches = &__clk_of_table;
3094
3095         /* First prepare the list of the clocks providers */
3096         for_each_matching_node_and_match(np, matches, &match) {
3097                 struct clock_provider *parent =
3098                         kzalloc(sizeof(struct clock_provider),  GFP_KERNEL);
3099
3100                 parent->clk_init_cb = match->data;
3101                 parent->np = np;
3102                 list_add_tail(&parent->node, &clk_provider_list);
3103         }
3104
3105         while (!list_empty(&clk_provider_list)) {
3106                 is_init_done = false;
3107                 list_for_each_entry_safe(clk_provider, next,
3108                                         &clk_provider_list, node) {
3109                         if (force || parent_ready(clk_provider->np)) {
3110
3111                                 clk_provider->clk_init_cb(clk_provider->np);
3112                                 of_clk_set_defaults(clk_provider->np, true);
3113
3114                                 list_del(&clk_provider->node);
3115                                 kfree(clk_provider);
3116                                 is_init_done = true;
3117                         }
3118                 }
3119
3120                 /*
3121                  * We didn't manage to initialize any of the
3122                  * remaining providers during the last loop, so now we
3123                  * initialize all the remaining ones unconditionally
3124                  * in case the clock parent was not mandatory
3125                  */
3126                 if (!is_init_done)
3127                         force = true;
3128         }
3129 }
3130 #endif