aa51756fd4d695b359ee5c6117e7c9d00fddf183
[sfrench/cifs-2.6.git] / drivers / clk / clk.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
4  * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
5  *
6  * Standard functionality for the common clock API.  See Documentation/driver-api/clk.rst
7  */
8
9 #include <linux/clk.h>
10 #include <linux/clk-provider.h>
11 #include <linux/clk/clk-conf.h>
12 #include <linux/module.h>
13 #include <linux/mutex.h>
14 #include <linux/spinlock.h>
15 #include <linux/err.h>
16 #include <linux/list.h>
17 #include <linux/slab.h>
18 #include <linux/of.h>
19 #include <linux/device.h>
20 #include <linux/init.h>
21 #include <linux/pm_runtime.h>
22 #include <linux/sched.h>
23 #include <linux/clkdev.h>
24
25 #include "clk.h"
26
27 static DEFINE_SPINLOCK(enable_lock);
28 static DEFINE_MUTEX(prepare_lock);
29
30 static struct task_struct *prepare_owner;
31 static struct task_struct *enable_owner;
32
33 static int prepare_refcnt;
34 static int enable_refcnt;
35
36 static HLIST_HEAD(clk_root_list);
37 static HLIST_HEAD(clk_orphan_list);
38 static LIST_HEAD(clk_notifier_list);
39
40 /***    private data structures    ***/
41
42 struct clk_parent_map {
43         const struct clk_hw     *hw;
44         struct clk_core         *core;
45         const char              *fw_name;
46         const char              *name;
47         int                     index;
48 };
49
50 struct clk_core {
51         const char              *name;
52         const struct clk_ops    *ops;
53         struct clk_hw           *hw;
54         struct module           *owner;
55         struct device           *dev;
56         struct device_node      *of_node;
57         struct clk_core         *parent;
58         struct clk_parent_map   *parents;
59         u8                      num_parents;
60         u8                      new_parent_index;
61         unsigned long           rate;
62         unsigned long           req_rate;
63         unsigned long           new_rate;
64         struct clk_core         *new_parent;
65         struct clk_core         *new_child;
66         unsigned long           flags;
67         bool                    orphan;
68         bool                    rpm_enabled;
69         unsigned int            enable_count;
70         unsigned int            prepare_count;
71         unsigned int            protect_count;
72         unsigned long           min_rate;
73         unsigned long           max_rate;
74         unsigned long           accuracy;
75         int                     phase;
76         struct clk_duty         duty;
77         struct hlist_head       children;
78         struct hlist_node       child_node;
79         struct hlist_head       clks;
80         unsigned int            notifier_count;
81 #ifdef CONFIG_DEBUG_FS
82         struct dentry           *dentry;
83         struct hlist_node       debug_node;
84 #endif
85         struct kref             ref;
86 };
87
88 #define CREATE_TRACE_POINTS
89 #include <trace/events/clk.h>
90
91 struct clk {
92         struct clk_core *core;
93         struct device *dev;
94         const char *dev_id;
95         const char *con_id;
96         unsigned long min_rate;
97         unsigned long max_rate;
98         unsigned int exclusive_count;
99         struct hlist_node clks_node;
100 };
101
102 /***           runtime pm          ***/
103 static int clk_pm_runtime_get(struct clk_core *core)
104 {
105         int ret;
106
107         if (!core->rpm_enabled)
108                 return 0;
109
110         ret = pm_runtime_get_sync(core->dev);
111         return ret < 0 ? ret : 0;
112 }
113
114 static void clk_pm_runtime_put(struct clk_core *core)
115 {
116         if (!core->rpm_enabled)
117                 return;
118
119         pm_runtime_put_sync(core->dev);
120 }
121
122 /***           locking             ***/
123 static void clk_prepare_lock(void)
124 {
125         if (!mutex_trylock(&prepare_lock)) {
126                 if (prepare_owner == current) {
127                         prepare_refcnt++;
128                         return;
129                 }
130                 mutex_lock(&prepare_lock);
131         }
132         WARN_ON_ONCE(prepare_owner != NULL);
133         WARN_ON_ONCE(prepare_refcnt != 0);
134         prepare_owner = current;
135         prepare_refcnt = 1;
136 }
137
138 static void clk_prepare_unlock(void)
139 {
140         WARN_ON_ONCE(prepare_owner != current);
141         WARN_ON_ONCE(prepare_refcnt == 0);
142
143         if (--prepare_refcnt)
144                 return;
145         prepare_owner = NULL;
146         mutex_unlock(&prepare_lock);
147 }
148
149 static unsigned long clk_enable_lock(void)
150         __acquires(enable_lock)
151 {
152         unsigned long flags;
153
154         /*
155          * On UP systems, spin_trylock_irqsave() always returns true, even if
156          * we already hold the lock. So, in that case, we rely only on
157          * reference counting.
158          */
159         if (!IS_ENABLED(CONFIG_SMP) ||
160             !spin_trylock_irqsave(&enable_lock, flags)) {
161                 if (enable_owner == current) {
162                         enable_refcnt++;
163                         __acquire(enable_lock);
164                         if (!IS_ENABLED(CONFIG_SMP))
165                                 local_save_flags(flags);
166                         return flags;
167                 }
168                 spin_lock_irqsave(&enable_lock, flags);
169         }
170         WARN_ON_ONCE(enable_owner != NULL);
171         WARN_ON_ONCE(enable_refcnt != 0);
172         enable_owner = current;
173         enable_refcnt = 1;
174         return flags;
175 }
176
177 static void clk_enable_unlock(unsigned long flags)
178         __releases(enable_lock)
179 {
180         WARN_ON_ONCE(enable_owner != current);
181         WARN_ON_ONCE(enable_refcnt == 0);
182
183         if (--enable_refcnt) {
184                 __release(enable_lock);
185                 return;
186         }
187         enable_owner = NULL;
188         spin_unlock_irqrestore(&enable_lock, flags);
189 }
190
191 static bool clk_core_rate_is_protected(struct clk_core *core)
192 {
193         return core->protect_count;
194 }
195
196 static bool clk_core_is_prepared(struct clk_core *core)
197 {
198         bool ret = false;
199
200         /*
201          * .is_prepared is optional for clocks that can prepare
202          * fall back to software usage counter if it is missing
203          */
204         if (!core->ops->is_prepared)
205                 return core->prepare_count;
206
207         if (!clk_pm_runtime_get(core)) {
208                 ret = core->ops->is_prepared(core->hw);
209                 clk_pm_runtime_put(core);
210         }
211
212         return ret;
213 }
214
215 static bool clk_core_is_enabled(struct clk_core *core)
216 {
217         bool ret = false;
218
219         /*
220          * .is_enabled is only mandatory for clocks that gate
221          * fall back to software usage counter if .is_enabled is missing
222          */
223         if (!core->ops->is_enabled)
224                 return core->enable_count;
225
226         /*
227          * Check if clock controller's device is runtime active before
228          * calling .is_enabled callback. If not, assume that clock is
229          * disabled, because we might be called from atomic context, from
230          * which pm_runtime_get() is not allowed.
231          * This function is called mainly from clk_disable_unused_subtree,
232          * which ensures proper runtime pm activation of controller before
233          * taking enable spinlock, but the below check is needed if one tries
234          * to call it from other places.
235          */
236         if (core->rpm_enabled) {
237                 pm_runtime_get_noresume(core->dev);
238                 if (!pm_runtime_active(core->dev)) {
239                         ret = false;
240                         goto done;
241                 }
242         }
243
244         ret = core->ops->is_enabled(core->hw);
245 done:
246         if (core->rpm_enabled)
247                 pm_runtime_put(core->dev);
248
249         return ret;
250 }
251
252 /***    helper functions   ***/
253
254 const char *__clk_get_name(const struct clk *clk)
255 {
256         return !clk ? NULL : clk->core->name;
257 }
258 EXPORT_SYMBOL_GPL(__clk_get_name);
259
260 const char *clk_hw_get_name(const struct clk_hw *hw)
261 {
262         return hw->core->name;
263 }
264 EXPORT_SYMBOL_GPL(clk_hw_get_name);
265
266 struct clk_hw *__clk_get_hw(struct clk *clk)
267 {
268         return !clk ? NULL : clk->core->hw;
269 }
270 EXPORT_SYMBOL_GPL(__clk_get_hw);
271
272 unsigned int clk_hw_get_num_parents(const struct clk_hw *hw)
273 {
274         return hw->core->num_parents;
275 }
276 EXPORT_SYMBOL_GPL(clk_hw_get_num_parents);
277
278 struct clk_hw *clk_hw_get_parent(const struct clk_hw *hw)
279 {
280         return hw->core->parent ? hw->core->parent->hw : NULL;
281 }
282 EXPORT_SYMBOL_GPL(clk_hw_get_parent);
283
284 static struct clk_core *__clk_lookup_subtree(const char *name,
285                                              struct clk_core *core)
286 {
287         struct clk_core *child;
288         struct clk_core *ret;
289
290         if (!strcmp(core->name, name))
291                 return core;
292
293         hlist_for_each_entry(child, &core->children, child_node) {
294                 ret = __clk_lookup_subtree(name, child);
295                 if (ret)
296                         return ret;
297         }
298
299         return NULL;
300 }
301
302 static struct clk_core *clk_core_lookup(const char *name)
303 {
304         struct clk_core *root_clk;
305         struct clk_core *ret;
306
307         if (!name)
308                 return NULL;
309
310         /* search the 'proper' clk tree first */
311         hlist_for_each_entry(root_clk, &clk_root_list, child_node) {
312                 ret = __clk_lookup_subtree(name, root_clk);
313                 if (ret)
314                         return ret;
315         }
316
317         /* if not found, then search the orphan tree */
318         hlist_for_each_entry(root_clk, &clk_orphan_list, child_node) {
319                 ret = __clk_lookup_subtree(name, root_clk);
320                 if (ret)
321                         return ret;
322         }
323
324         return NULL;
325 }
326
327 /**
328  * clk_core_get - Find the clk_core parent of a clk
329  * @core: clk to find parent of
330  * @p_index: parent index to search for
331  *
332  * This is the preferred method for clk providers to find the parent of a
333  * clk when that parent is external to the clk controller. The parent_names
334  * array is indexed and treated as a local name matching a string in the device
335  * node's 'clock-names' property or as the 'con_id' matching the device's
336  * dev_name() in a clk_lookup. This allows clk providers to use their own
337  * namespace instead of looking for a globally unique parent string.
338  *
339  * For example the following DT snippet would allow a clock registered by the
340  * clock-controller@c001 that has a clk_init_data::parent_data array
341  * with 'xtal' in the 'name' member to find the clock provided by the
342  * clock-controller@f00abcd without needing to get the globally unique name of
343  * the xtal clk.
344  *
345  *      parent: clock-controller@f00abcd {
346  *              reg = <0xf00abcd 0xabcd>;
347  *              #clock-cells = <0>;
348  *      };
349  *
350  *      clock-controller@c001 {
351  *              reg = <0xc001 0xf00d>;
352  *              clocks = <&parent>;
353  *              clock-names = "xtal";
354  *              #clock-cells = <1>;
355  *      };
356  *
357  * Returns: -ENOENT when the provider can't be found or the clk doesn't
358  * exist in the provider. -EINVAL when the name can't be found. NULL when the
359  * provider knows about the clk but it isn't provided on this system.
360  * A valid clk_core pointer when the clk can be found in the provider.
361  */
362 static struct clk_core *clk_core_get(struct clk_core *core, u8 p_index)
363 {
364         const char *name = core->parents[p_index].fw_name;
365         int index = core->parents[p_index].index;
366         struct clk_hw *hw = ERR_PTR(-ENOENT);
367         struct device *dev = core->dev;
368         const char *dev_id = dev ? dev_name(dev) : NULL;
369         struct device_node *np = core->of_node;
370
371         if (np && index >= 0)
372                 hw = of_clk_get_hw(np, index, name);
373
374         /*
375          * If the DT search above couldn't find the provider or the provider
376          * didn't know about this clk, fallback to looking up via clkdev based
377          * clk_lookups
378          */
379         if (PTR_ERR(hw) == -ENOENT && name)
380                 hw = clk_find_hw(dev_id, name);
381
382         if (IS_ERR(hw))
383                 return ERR_CAST(hw);
384
385         return hw->core;
386 }
387
388 static void clk_core_fill_parent_index(struct clk_core *core, u8 index)
389 {
390         struct clk_parent_map *entry = &core->parents[index];
391         struct clk_core *parent = ERR_PTR(-ENOENT);
392
393         if (entry->hw) {
394                 parent = entry->hw->core;
395                 /*
396                  * We have a direct reference but it isn't registered yet?
397                  * Orphan it and let clk_reparent() update the orphan status
398                  * when the parent is registered.
399                  */
400                 if (!parent)
401                         parent = ERR_PTR(-EPROBE_DEFER);
402         } else {
403                 parent = clk_core_get(core, index);
404                 if (IS_ERR(parent) && PTR_ERR(parent) == -ENOENT)
405                         parent = clk_core_lookup(entry->name);
406         }
407
408         /* Only cache it if it's not an error */
409         if (!IS_ERR(parent))
410                 entry->core = parent;
411 }
412
413 static struct clk_core *clk_core_get_parent_by_index(struct clk_core *core,
414                                                          u8 index)
415 {
416         if (!core || index >= core->num_parents || !core->parents)
417                 return NULL;
418
419         if (!core->parents[index].core)
420                 clk_core_fill_parent_index(core, index);
421
422         return core->parents[index].core;
423 }
424
425 struct clk_hw *
426 clk_hw_get_parent_by_index(const struct clk_hw *hw, unsigned int index)
427 {
428         struct clk_core *parent;
429
430         parent = clk_core_get_parent_by_index(hw->core, index);
431
432         return !parent ? NULL : parent->hw;
433 }
434 EXPORT_SYMBOL_GPL(clk_hw_get_parent_by_index);
435
436 unsigned int __clk_get_enable_count(struct clk *clk)
437 {
438         return !clk ? 0 : clk->core->enable_count;
439 }
440
441 static unsigned long clk_core_get_rate_nolock(struct clk_core *core)
442 {
443         if (!core)
444                 return 0;
445
446         if (!core->num_parents || core->parent)
447                 return core->rate;
448
449         /*
450          * Clk must have a parent because num_parents > 0 but the parent isn't
451          * known yet. Best to return 0 as the rate of this clk until we can
452          * properly recalc the rate based on the parent's rate.
453          */
454         return 0;
455 }
456
457 unsigned long clk_hw_get_rate(const struct clk_hw *hw)
458 {
459         return clk_core_get_rate_nolock(hw->core);
460 }
461 EXPORT_SYMBOL_GPL(clk_hw_get_rate);
462
463 static unsigned long __clk_get_accuracy(struct clk_core *core)
464 {
465         if (!core)
466                 return 0;
467
468         return core->accuracy;
469 }
470
471 unsigned long __clk_get_flags(struct clk *clk)
472 {
473         return !clk ? 0 : clk->core->flags;
474 }
475 EXPORT_SYMBOL_GPL(__clk_get_flags);
476
477 unsigned long clk_hw_get_flags(const struct clk_hw *hw)
478 {
479         return hw->core->flags;
480 }
481 EXPORT_SYMBOL_GPL(clk_hw_get_flags);
482
483 bool clk_hw_is_prepared(const struct clk_hw *hw)
484 {
485         return clk_core_is_prepared(hw->core);
486 }
487 EXPORT_SYMBOL_GPL(clk_hw_is_prepared);
488
489 bool clk_hw_rate_is_protected(const struct clk_hw *hw)
490 {
491         return clk_core_rate_is_protected(hw->core);
492 }
493 EXPORT_SYMBOL_GPL(clk_hw_rate_is_protected);
494
495 bool clk_hw_is_enabled(const struct clk_hw *hw)
496 {
497         return clk_core_is_enabled(hw->core);
498 }
499 EXPORT_SYMBOL_GPL(clk_hw_is_enabled);
500
501 bool __clk_is_enabled(struct clk *clk)
502 {
503         if (!clk)
504                 return false;
505
506         return clk_core_is_enabled(clk->core);
507 }
508 EXPORT_SYMBOL_GPL(__clk_is_enabled);
509
510 static bool mux_is_better_rate(unsigned long rate, unsigned long now,
511                            unsigned long best, unsigned long flags)
512 {
513         if (flags & CLK_MUX_ROUND_CLOSEST)
514                 return abs(now - rate) < abs(best - rate);
515
516         return now <= rate && now > best;
517 }
518
519 int clk_mux_determine_rate_flags(struct clk_hw *hw,
520                                  struct clk_rate_request *req,
521                                  unsigned long flags)
522 {
523         struct clk_core *core = hw->core, *parent, *best_parent = NULL;
524         int i, num_parents, ret;
525         unsigned long best = 0;
526         struct clk_rate_request parent_req = *req;
527
528         /* if NO_REPARENT flag set, pass through to current parent */
529         if (core->flags & CLK_SET_RATE_NO_REPARENT) {
530                 parent = core->parent;
531                 if (core->flags & CLK_SET_RATE_PARENT) {
532                         ret = __clk_determine_rate(parent ? parent->hw : NULL,
533                                                    &parent_req);
534                         if (ret)
535                                 return ret;
536
537                         best = parent_req.rate;
538                 } else if (parent) {
539                         best = clk_core_get_rate_nolock(parent);
540                 } else {
541                         best = clk_core_get_rate_nolock(core);
542                 }
543
544                 goto out;
545         }
546
547         /* find the parent that can provide the fastest rate <= rate */
548         num_parents = core->num_parents;
549         for (i = 0; i < num_parents; i++) {
550                 parent = clk_core_get_parent_by_index(core, i);
551                 if (!parent)
552                         continue;
553
554                 if (core->flags & CLK_SET_RATE_PARENT) {
555                         parent_req = *req;
556                         ret = __clk_determine_rate(parent->hw, &parent_req);
557                         if (ret)
558                                 continue;
559                 } else {
560                         parent_req.rate = clk_core_get_rate_nolock(parent);
561                 }
562
563                 if (mux_is_better_rate(req->rate, parent_req.rate,
564                                        best, flags)) {
565                         best_parent = parent;
566                         best = parent_req.rate;
567                 }
568         }
569
570         if (!best_parent)
571                 return -EINVAL;
572
573 out:
574         if (best_parent)
575                 req->best_parent_hw = best_parent->hw;
576         req->best_parent_rate = best;
577         req->rate = best;
578
579         return 0;
580 }
581 EXPORT_SYMBOL_GPL(clk_mux_determine_rate_flags);
582
583 struct clk *__clk_lookup(const char *name)
584 {
585         struct clk_core *core = clk_core_lookup(name);
586
587         return !core ? NULL : core->hw->clk;
588 }
589
590 static void clk_core_get_boundaries(struct clk_core *core,
591                                     unsigned long *min_rate,
592                                     unsigned long *max_rate)
593 {
594         struct clk *clk_user;
595
596         *min_rate = core->min_rate;
597         *max_rate = core->max_rate;
598
599         hlist_for_each_entry(clk_user, &core->clks, clks_node)
600                 *min_rate = max(*min_rate, clk_user->min_rate);
601
602         hlist_for_each_entry(clk_user, &core->clks, clks_node)
603                 *max_rate = min(*max_rate, clk_user->max_rate);
604 }
605
606 void clk_hw_set_rate_range(struct clk_hw *hw, unsigned long min_rate,
607                            unsigned long max_rate)
608 {
609         hw->core->min_rate = min_rate;
610         hw->core->max_rate = max_rate;
611 }
612 EXPORT_SYMBOL_GPL(clk_hw_set_rate_range);
613
614 /*
615  * __clk_mux_determine_rate - clk_ops::determine_rate implementation for a mux type clk
616  * @hw: mux type clk to determine rate on
617  * @req: rate request, also used to return preferred parent and frequencies
618  *
619  * Helper for finding best parent to provide a given frequency. This can be used
620  * directly as a determine_rate callback (e.g. for a mux), or from a more
621  * complex clock that may combine a mux with other operations.
622  *
623  * Returns: 0 on success, -EERROR value on error
624  */
625 int __clk_mux_determine_rate(struct clk_hw *hw,
626                              struct clk_rate_request *req)
627 {
628         return clk_mux_determine_rate_flags(hw, req, 0);
629 }
630 EXPORT_SYMBOL_GPL(__clk_mux_determine_rate);
631
632 int __clk_mux_determine_rate_closest(struct clk_hw *hw,
633                                      struct clk_rate_request *req)
634 {
635         return clk_mux_determine_rate_flags(hw, req, CLK_MUX_ROUND_CLOSEST);
636 }
637 EXPORT_SYMBOL_GPL(__clk_mux_determine_rate_closest);
638
639 /***        clk api        ***/
640
641 static void clk_core_rate_unprotect(struct clk_core *core)
642 {
643         lockdep_assert_held(&prepare_lock);
644
645         if (!core)
646                 return;
647
648         if (WARN(core->protect_count == 0,
649             "%s already unprotected\n", core->name))
650                 return;
651
652         if (--core->protect_count > 0)
653                 return;
654
655         clk_core_rate_unprotect(core->parent);
656 }
657
658 static int clk_core_rate_nuke_protect(struct clk_core *core)
659 {
660         int ret;
661
662         lockdep_assert_held(&prepare_lock);
663
664         if (!core)
665                 return -EINVAL;
666
667         if (core->protect_count == 0)
668                 return 0;
669
670         ret = core->protect_count;
671         core->protect_count = 1;
672         clk_core_rate_unprotect(core);
673
674         return ret;
675 }
676
677 /**
678  * clk_rate_exclusive_put - release exclusivity over clock rate control
679  * @clk: the clk over which the exclusivity is released
680  *
681  * clk_rate_exclusive_put() completes a critical section during which a clock
682  * consumer cannot tolerate any other consumer making any operation on the
683  * clock which could result in a rate change or rate glitch. Exclusive clocks
684  * cannot have their rate changed, either directly or indirectly due to changes
685  * further up the parent chain of clocks. As a result, clocks up parent chain
686  * also get under exclusive control of the calling consumer.
687  *
688  * If exlusivity is claimed more than once on clock, even by the same consumer,
689  * the rate effectively gets locked as exclusivity can't be preempted.
690  *
691  * Calls to clk_rate_exclusive_put() must be balanced with calls to
692  * clk_rate_exclusive_get(). Calls to this function may sleep, and do not return
693  * error status.
694  */
695 void clk_rate_exclusive_put(struct clk *clk)
696 {
697         if (!clk)
698                 return;
699
700         clk_prepare_lock();
701
702         /*
703          * if there is something wrong with this consumer protect count, stop
704          * here before messing with the provider
705          */
706         if (WARN_ON(clk->exclusive_count <= 0))
707                 goto out;
708
709         clk_core_rate_unprotect(clk->core);
710         clk->exclusive_count--;
711 out:
712         clk_prepare_unlock();
713 }
714 EXPORT_SYMBOL_GPL(clk_rate_exclusive_put);
715
716 static void clk_core_rate_protect(struct clk_core *core)
717 {
718         lockdep_assert_held(&prepare_lock);
719
720         if (!core)
721                 return;
722
723         if (core->protect_count == 0)
724                 clk_core_rate_protect(core->parent);
725
726         core->protect_count++;
727 }
728
729 static void clk_core_rate_restore_protect(struct clk_core *core, int count)
730 {
731         lockdep_assert_held(&prepare_lock);
732
733         if (!core)
734                 return;
735
736         if (count == 0)
737                 return;
738
739         clk_core_rate_protect(core);
740         core->protect_count = count;
741 }
742
743 /**
744  * clk_rate_exclusive_get - get exclusivity over the clk rate control
745  * @clk: the clk over which the exclusity of rate control is requested
746  *
747  * clk_rate_exlusive_get() begins a critical section during which a clock
748  * consumer cannot tolerate any other consumer making any operation on the
749  * clock which could result in a rate change or rate glitch. Exclusive clocks
750  * cannot have their rate changed, either directly or indirectly due to changes
751  * further up the parent chain of clocks. As a result, clocks up parent chain
752  * also get under exclusive control of the calling consumer.
753  *
754  * If exlusivity is claimed more than once on clock, even by the same consumer,
755  * the rate effectively gets locked as exclusivity can't be preempted.
756  *
757  * Calls to clk_rate_exclusive_get() should be balanced with calls to
758  * clk_rate_exclusive_put(). Calls to this function may sleep.
759  * Returns 0 on success, -EERROR otherwise
760  */
761 int clk_rate_exclusive_get(struct clk *clk)
762 {
763         if (!clk)
764                 return 0;
765
766         clk_prepare_lock();
767         clk_core_rate_protect(clk->core);
768         clk->exclusive_count++;
769         clk_prepare_unlock();
770
771         return 0;
772 }
773 EXPORT_SYMBOL_GPL(clk_rate_exclusive_get);
774
775 static void clk_core_unprepare(struct clk_core *core)
776 {
777         lockdep_assert_held(&prepare_lock);
778
779         if (!core)
780                 return;
781
782         if (WARN(core->prepare_count == 0,
783             "%s already unprepared\n", core->name))
784                 return;
785
786         if (WARN(core->prepare_count == 1 && core->flags & CLK_IS_CRITICAL,
787             "Unpreparing critical %s\n", core->name))
788                 return;
789
790         if (core->flags & CLK_SET_RATE_GATE)
791                 clk_core_rate_unprotect(core);
792
793         if (--core->prepare_count > 0)
794                 return;
795
796         WARN(core->enable_count > 0, "Unpreparing enabled %s\n", core->name);
797
798         trace_clk_unprepare(core);
799
800         if (core->ops->unprepare)
801                 core->ops->unprepare(core->hw);
802
803         clk_pm_runtime_put(core);
804
805         trace_clk_unprepare_complete(core);
806         clk_core_unprepare(core->parent);
807 }
808
809 static void clk_core_unprepare_lock(struct clk_core *core)
810 {
811         clk_prepare_lock();
812         clk_core_unprepare(core);
813         clk_prepare_unlock();
814 }
815
816 /**
817  * clk_unprepare - undo preparation of a clock source
818  * @clk: the clk being unprepared
819  *
820  * clk_unprepare may sleep, which differentiates it from clk_disable.  In a
821  * simple case, clk_unprepare can be used instead of clk_disable to gate a clk
822  * if the operation may sleep.  One example is a clk which is accessed over
823  * I2c.  In the complex case a clk gate operation may require a fast and a slow
824  * part.  It is this reason that clk_unprepare and clk_disable are not mutually
825  * exclusive.  In fact clk_disable must be called before clk_unprepare.
826  */
827 void clk_unprepare(struct clk *clk)
828 {
829         if (IS_ERR_OR_NULL(clk))
830                 return;
831
832         clk_core_unprepare_lock(clk->core);
833 }
834 EXPORT_SYMBOL_GPL(clk_unprepare);
835
836 static int clk_core_prepare(struct clk_core *core)
837 {
838         int ret = 0;
839
840         lockdep_assert_held(&prepare_lock);
841
842         if (!core)
843                 return 0;
844
845         if (core->prepare_count == 0) {
846                 ret = clk_pm_runtime_get(core);
847                 if (ret)
848                         return ret;
849
850                 ret = clk_core_prepare(core->parent);
851                 if (ret)
852                         goto runtime_put;
853
854                 trace_clk_prepare(core);
855
856                 if (core->ops->prepare)
857                         ret = core->ops->prepare(core->hw);
858
859                 trace_clk_prepare_complete(core);
860
861                 if (ret)
862                         goto unprepare;
863         }
864
865         core->prepare_count++;
866
867         /*
868          * CLK_SET_RATE_GATE is a special case of clock protection
869          * Instead of a consumer claiming exclusive rate control, it is
870          * actually the provider which prevents any consumer from making any
871          * operation which could result in a rate change or rate glitch while
872          * the clock is prepared.
873          */
874         if (core->flags & CLK_SET_RATE_GATE)
875                 clk_core_rate_protect(core);
876
877         return 0;
878 unprepare:
879         clk_core_unprepare(core->parent);
880 runtime_put:
881         clk_pm_runtime_put(core);
882         return ret;
883 }
884
885 static int clk_core_prepare_lock(struct clk_core *core)
886 {
887         int ret;
888
889         clk_prepare_lock();
890         ret = clk_core_prepare(core);
891         clk_prepare_unlock();
892
893         return ret;
894 }
895
896 /**
897  * clk_prepare - prepare a clock source
898  * @clk: the clk being prepared
899  *
900  * clk_prepare may sleep, which differentiates it from clk_enable.  In a simple
901  * case, clk_prepare can be used instead of clk_enable to ungate a clk if the
902  * operation may sleep.  One example is a clk which is accessed over I2c.  In
903  * the complex case a clk ungate operation may require a fast and a slow part.
904  * It is this reason that clk_prepare and clk_enable are not mutually
905  * exclusive.  In fact clk_prepare must be called before clk_enable.
906  * Returns 0 on success, -EERROR otherwise.
907  */
908 int clk_prepare(struct clk *clk)
909 {
910         if (!clk)
911                 return 0;
912
913         return clk_core_prepare_lock(clk->core);
914 }
915 EXPORT_SYMBOL_GPL(clk_prepare);
916
917 static void clk_core_disable(struct clk_core *core)
918 {
919         lockdep_assert_held(&enable_lock);
920
921         if (!core)
922                 return;
923
924         if (WARN(core->enable_count == 0, "%s already disabled\n", core->name))
925                 return;
926
927         if (WARN(core->enable_count == 1 && core->flags & CLK_IS_CRITICAL,
928             "Disabling critical %s\n", core->name))
929                 return;
930
931         if (--core->enable_count > 0)
932                 return;
933
934         trace_clk_disable_rcuidle(core);
935
936         if (core->ops->disable)
937                 core->ops->disable(core->hw);
938
939         trace_clk_disable_complete_rcuidle(core);
940
941         clk_core_disable(core->parent);
942 }
943
944 static void clk_core_disable_lock(struct clk_core *core)
945 {
946         unsigned long flags;
947
948         flags = clk_enable_lock();
949         clk_core_disable(core);
950         clk_enable_unlock(flags);
951 }
952
953 /**
954  * clk_disable - gate a clock
955  * @clk: the clk being gated
956  *
957  * clk_disable must not sleep, which differentiates it from clk_unprepare.  In
958  * a simple case, clk_disable can be used instead of clk_unprepare to gate a
959  * clk if the operation is fast and will never sleep.  One example is a
960  * SoC-internal clk which is controlled via simple register writes.  In the
961  * complex case a clk gate operation may require a fast and a slow part.  It is
962  * this reason that clk_unprepare and clk_disable are not mutually exclusive.
963  * In fact clk_disable must be called before clk_unprepare.
964  */
965 void clk_disable(struct clk *clk)
966 {
967         if (IS_ERR_OR_NULL(clk))
968                 return;
969
970         clk_core_disable_lock(clk->core);
971 }
972 EXPORT_SYMBOL_GPL(clk_disable);
973
974 static int clk_core_enable(struct clk_core *core)
975 {
976         int ret = 0;
977
978         lockdep_assert_held(&enable_lock);
979
980         if (!core)
981                 return 0;
982
983         if (WARN(core->prepare_count == 0,
984             "Enabling unprepared %s\n", core->name))
985                 return -ESHUTDOWN;
986
987         if (core->enable_count == 0) {
988                 ret = clk_core_enable(core->parent);
989
990                 if (ret)
991                         return ret;
992
993                 trace_clk_enable_rcuidle(core);
994
995                 if (core->ops->enable)
996                         ret = core->ops->enable(core->hw);
997
998                 trace_clk_enable_complete_rcuidle(core);
999
1000                 if (ret) {
1001                         clk_core_disable(core->parent);
1002                         return ret;
1003                 }
1004         }
1005
1006         core->enable_count++;
1007         return 0;
1008 }
1009
1010 static int clk_core_enable_lock(struct clk_core *core)
1011 {
1012         unsigned long flags;
1013         int ret;
1014
1015         flags = clk_enable_lock();
1016         ret = clk_core_enable(core);
1017         clk_enable_unlock(flags);
1018
1019         return ret;
1020 }
1021
1022 /**
1023  * clk_gate_restore_context - restore context for poweroff
1024  * @hw: the clk_hw pointer of clock whose state is to be restored
1025  *
1026  * The clock gate restore context function enables or disables
1027  * the gate clocks based on the enable_count. This is done in cases
1028  * where the clock context is lost and based on the enable_count
1029  * the clock either needs to be enabled/disabled. This
1030  * helps restore the state of gate clocks.
1031  */
1032 void clk_gate_restore_context(struct clk_hw *hw)
1033 {
1034         struct clk_core *core = hw->core;
1035
1036         if (core->enable_count)
1037                 core->ops->enable(hw);
1038         else
1039                 core->ops->disable(hw);
1040 }
1041 EXPORT_SYMBOL_GPL(clk_gate_restore_context);
1042
1043 static int clk_core_save_context(struct clk_core *core)
1044 {
1045         struct clk_core *child;
1046         int ret = 0;
1047
1048         hlist_for_each_entry(child, &core->children, child_node) {
1049                 ret = clk_core_save_context(child);
1050                 if (ret < 0)
1051                         return ret;
1052         }
1053
1054         if (core->ops && core->ops->save_context)
1055                 ret = core->ops->save_context(core->hw);
1056
1057         return ret;
1058 }
1059
1060 static void clk_core_restore_context(struct clk_core *core)
1061 {
1062         struct clk_core *child;
1063
1064         if (core->ops && core->ops->restore_context)
1065                 core->ops->restore_context(core->hw);
1066
1067         hlist_for_each_entry(child, &core->children, child_node)
1068                 clk_core_restore_context(child);
1069 }
1070
1071 /**
1072  * clk_save_context - save clock context for poweroff
1073  *
1074  * Saves the context of the clock register for powerstates in which the
1075  * contents of the registers will be lost. Occurs deep within the suspend
1076  * code.  Returns 0 on success.
1077  */
1078 int clk_save_context(void)
1079 {
1080         struct clk_core *clk;
1081         int ret;
1082
1083         hlist_for_each_entry(clk, &clk_root_list, child_node) {
1084                 ret = clk_core_save_context(clk);
1085                 if (ret < 0)
1086                         return ret;
1087         }
1088
1089         hlist_for_each_entry(clk, &clk_orphan_list, child_node) {
1090                 ret = clk_core_save_context(clk);
1091                 if (ret < 0)
1092                         return ret;
1093         }
1094
1095         return 0;
1096 }
1097 EXPORT_SYMBOL_GPL(clk_save_context);
1098
1099 /**
1100  * clk_restore_context - restore clock context after poweroff
1101  *
1102  * Restore the saved clock context upon resume.
1103  *
1104  */
1105 void clk_restore_context(void)
1106 {
1107         struct clk_core *core;
1108
1109         hlist_for_each_entry(core, &clk_root_list, child_node)
1110                 clk_core_restore_context(core);
1111
1112         hlist_for_each_entry(core, &clk_orphan_list, child_node)
1113                 clk_core_restore_context(core);
1114 }
1115 EXPORT_SYMBOL_GPL(clk_restore_context);
1116
1117 /**
1118  * clk_enable - ungate a clock
1119  * @clk: the clk being ungated
1120  *
1121  * clk_enable must not sleep, which differentiates it from clk_prepare.  In a
1122  * simple case, clk_enable can be used instead of clk_prepare to ungate a clk
1123  * if the operation will never sleep.  One example is a SoC-internal clk which
1124  * is controlled via simple register writes.  In the complex case a clk ungate
1125  * operation may require a fast and a slow part.  It is this reason that
1126  * clk_enable and clk_prepare are not mutually exclusive.  In fact clk_prepare
1127  * must be called before clk_enable.  Returns 0 on success, -EERROR
1128  * otherwise.
1129  */
1130 int clk_enable(struct clk *clk)
1131 {
1132         if (!clk)
1133                 return 0;
1134
1135         return clk_core_enable_lock(clk->core);
1136 }
1137 EXPORT_SYMBOL_GPL(clk_enable);
1138
1139 static int clk_core_prepare_enable(struct clk_core *core)
1140 {
1141         int ret;
1142
1143         ret = clk_core_prepare_lock(core);
1144         if (ret)
1145                 return ret;
1146
1147         ret = clk_core_enable_lock(core);
1148         if (ret)
1149                 clk_core_unprepare_lock(core);
1150
1151         return ret;
1152 }
1153
1154 static void clk_core_disable_unprepare(struct clk_core *core)
1155 {
1156         clk_core_disable_lock(core);
1157         clk_core_unprepare_lock(core);
1158 }
1159
1160 static void clk_unprepare_unused_subtree(struct clk_core *core)
1161 {
1162         struct clk_core *child;
1163
1164         lockdep_assert_held(&prepare_lock);
1165
1166         hlist_for_each_entry(child, &core->children, child_node)
1167                 clk_unprepare_unused_subtree(child);
1168
1169         if (core->prepare_count)
1170                 return;
1171
1172         if (core->flags & CLK_IGNORE_UNUSED)
1173                 return;
1174
1175         if (clk_pm_runtime_get(core))
1176                 return;
1177
1178         if (clk_core_is_prepared(core)) {
1179                 trace_clk_unprepare(core);
1180                 if (core->ops->unprepare_unused)
1181                         core->ops->unprepare_unused(core->hw);
1182                 else if (core->ops->unprepare)
1183                         core->ops->unprepare(core->hw);
1184                 trace_clk_unprepare_complete(core);
1185         }
1186
1187         clk_pm_runtime_put(core);
1188 }
1189
1190 static void clk_disable_unused_subtree(struct clk_core *core)
1191 {
1192         struct clk_core *child;
1193         unsigned long flags;
1194
1195         lockdep_assert_held(&prepare_lock);
1196
1197         hlist_for_each_entry(child, &core->children, child_node)
1198                 clk_disable_unused_subtree(child);
1199
1200         if (core->flags & CLK_OPS_PARENT_ENABLE)
1201                 clk_core_prepare_enable(core->parent);
1202
1203         if (clk_pm_runtime_get(core))
1204                 goto unprepare_out;
1205
1206         flags = clk_enable_lock();
1207
1208         if (core->enable_count)
1209                 goto unlock_out;
1210
1211         if (core->flags & CLK_IGNORE_UNUSED)
1212                 goto unlock_out;
1213
1214         /*
1215          * some gate clocks have special needs during the disable-unused
1216          * sequence.  call .disable_unused if available, otherwise fall
1217          * back to .disable
1218          */
1219         if (clk_core_is_enabled(core)) {
1220                 trace_clk_disable(core);
1221                 if (core->ops->disable_unused)
1222                         core->ops->disable_unused(core->hw);
1223                 else if (core->ops->disable)
1224                         core->ops->disable(core->hw);
1225                 trace_clk_disable_complete(core);
1226         }
1227
1228 unlock_out:
1229         clk_enable_unlock(flags);
1230         clk_pm_runtime_put(core);
1231 unprepare_out:
1232         if (core->flags & CLK_OPS_PARENT_ENABLE)
1233                 clk_core_disable_unprepare(core->parent);
1234 }
1235
1236 static bool clk_ignore_unused;
1237 static int __init clk_ignore_unused_setup(char *__unused)
1238 {
1239         clk_ignore_unused = true;
1240         return 1;
1241 }
1242 __setup("clk_ignore_unused", clk_ignore_unused_setup);
1243
1244 static int clk_disable_unused(void)
1245 {
1246         struct clk_core *core;
1247
1248         if (clk_ignore_unused) {
1249                 pr_warn("clk: Not disabling unused clocks\n");
1250                 return 0;
1251         }
1252
1253         clk_prepare_lock();
1254
1255         hlist_for_each_entry(core, &clk_root_list, child_node)
1256                 clk_disable_unused_subtree(core);
1257
1258         hlist_for_each_entry(core, &clk_orphan_list, child_node)
1259                 clk_disable_unused_subtree(core);
1260
1261         hlist_for_each_entry(core, &clk_root_list, child_node)
1262                 clk_unprepare_unused_subtree(core);
1263
1264         hlist_for_each_entry(core, &clk_orphan_list, child_node)
1265                 clk_unprepare_unused_subtree(core);
1266
1267         clk_prepare_unlock();
1268
1269         return 0;
1270 }
1271 late_initcall_sync(clk_disable_unused);
1272
1273 static int clk_core_determine_round_nolock(struct clk_core *core,
1274                                            struct clk_rate_request *req)
1275 {
1276         long rate;
1277
1278         lockdep_assert_held(&prepare_lock);
1279
1280         if (!core)
1281                 return 0;
1282
1283         /*
1284          * At this point, core protection will be disabled if
1285          * - if the provider is not protected at all
1286          * - if the calling consumer is the only one which has exclusivity
1287          *   over the provider
1288          */
1289         if (clk_core_rate_is_protected(core)) {
1290                 req->rate = core->rate;
1291         } else if (core->ops->determine_rate) {
1292                 return core->ops->determine_rate(core->hw, req);
1293         } else if (core->ops->round_rate) {
1294                 rate = core->ops->round_rate(core->hw, req->rate,
1295                                              &req->best_parent_rate);
1296                 if (rate < 0)
1297                         return rate;
1298
1299                 req->rate = rate;
1300         } else {
1301                 return -EINVAL;
1302         }
1303
1304         return 0;
1305 }
1306
1307 static void clk_core_init_rate_req(struct clk_core * const core,
1308                                    struct clk_rate_request *req)
1309 {
1310         struct clk_core *parent;
1311
1312         if (WARN_ON(!core || !req))
1313                 return;
1314
1315         parent = core->parent;
1316         if (parent) {
1317                 req->best_parent_hw = parent->hw;
1318                 req->best_parent_rate = parent->rate;
1319         } else {
1320                 req->best_parent_hw = NULL;
1321                 req->best_parent_rate = 0;
1322         }
1323 }
1324
1325 static bool clk_core_can_round(struct clk_core * const core)
1326 {
1327         if (core->ops->determine_rate || core->ops->round_rate)
1328                 return true;
1329
1330         return false;
1331 }
1332
1333 static int clk_core_round_rate_nolock(struct clk_core *core,
1334                                       struct clk_rate_request *req)
1335 {
1336         lockdep_assert_held(&prepare_lock);
1337
1338         if (!core) {
1339                 req->rate = 0;
1340                 return 0;
1341         }
1342
1343         clk_core_init_rate_req(core, req);
1344
1345         if (clk_core_can_round(core))
1346                 return clk_core_determine_round_nolock(core, req);
1347         else if (core->flags & CLK_SET_RATE_PARENT)
1348                 return clk_core_round_rate_nolock(core->parent, req);
1349
1350         req->rate = core->rate;
1351         return 0;
1352 }
1353
1354 /**
1355  * __clk_determine_rate - get the closest rate actually supported by a clock
1356  * @hw: determine the rate of this clock
1357  * @req: target rate request
1358  *
1359  * Useful for clk_ops such as .set_rate and .determine_rate.
1360  */
1361 int __clk_determine_rate(struct clk_hw *hw, struct clk_rate_request *req)
1362 {
1363         if (!hw) {
1364                 req->rate = 0;
1365                 return 0;
1366         }
1367
1368         return clk_core_round_rate_nolock(hw->core, req);
1369 }
1370 EXPORT_SYMBOL_GPL(__clk_determine_rate);
1371
1372 unsigned long clk_hw_round_rate(struct clk_hw *hw, unsigned long rate)
1373 {
1374         int ret;
1375         struct clk_rate_request req;
1376
1377         clk_core_get_boundaries(hw->core, &req.min_rate, &req.max_rate);
1378         req.rate = rate;
1379
1380         ret = clk_core_round_rate_nolock(hw->core, &req);
1381         if (ret)
1382                 return 0;
1383
1384         return req.rate;
1385 }
1386 EXPORT_SYMBOL_GPL(clk_hw_round_rate);
1387
1388 /**
1389  * clk_round_rate - round the given rate for a clk
1390  * @clk: the clk for which we are rounding a rate
1391  * @rate: the rate which is to be rounded
1392  *
1393  * Takes in a rate as input and rounds it to a rate that the clk can actually
1394  * use which is then returned.  If clk doesn't support round_rate operation
1395  * then the parent rate is returned.
1396  */
1397 long clk_round_rate(struct clk *clk, unsigned long rate)
1398 {
1399         struct clk_rate_request req;
1400         int ret;
1401
1402         if (!clk)
1403                 return 0;
1404
1405         clk_prepare_lock();
1406
1407         if (clk->exclusive_count)
1408                 clk_core_rate_unprotect(clk->core);
1409
1410         clk_core_get_boundaries(clk->core, &req.min_rate, &req.max_rate);
1411         req.rate = rate;
1412
1413         ret = clk_core_round_rate_nolock(clk->core, &req);
1414
1415         if (clk->exclusive_count)
1416                 clk_core_rate_protect(clk->core);
1417
1418         clk_prepare_unlock();
1419
1420         if (ret)
1421                 return ret;
1422
1423         return req.rate;
1424 }
1425 EXPORT_SYMBOL_GPL(clk_round_rate);
1426
1427 /**
1428  * __clk_notify - call clk notifier chain
1429  * @core: clk that is changing rate
1430  * @msg: clk notifier type (see include/linux/clk.h)
1431  * @old_rate: old clk rate
1432  * @new_rate: new clk rate
1433  *
1434  * Triggers a notifier call chain on the clk rate-change notification
1435  * for 'clk'.  Passes a pointer to the struct clk and the previous
1436  * and current rates to the notifier callback.  Intended to be called by
1437  * internal clock code only.  Returns NOTIFY_DONE from the last driver
1438  * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
1439  * a driver returns that.
1440  */
1441 static int __clk_notify(struct clk_core *core, unsigned long msg,
1442                 unsigned long old_rate, unsigned long new_rate)
1443 {
1444         struct clk_notifier *cn;
1445         struct clk_notifier_data cnd;
1446         int ret = NOTIFY_DONE;
1447
1448         cnd.old_rate = old_rate;
1449         cnd.new_rate = new_rate;
1450
1451         list_for_each_entry(cn, &clk_notifier_list, node) {
1452                 if (cn->clk->core == core) {
1453                         cnd.clk = cn->clk;
1454                         ret = srcu_notifier_call_chain(&cn->notifier_head, msg,
1455                                         &cnd);
1456                         if (ret & NOTIFY_STOP_MASK)
1457                                 return ret;
1458                 }
1459         }
1460
1461         return ret;
1462 }
1463
1464 /**
1465  * __clk_recalc_accuracies
1466  * @core: first clk in the subtree
1467  *
1468  * Walks the subtree of clks starting with clk and recalculates accuracies as
1469  * it goes.  Note that if a clk does not implement the .recalc_accuracy
1470  * callback then it is assumed that the clock will take on the accuracy of its
1471  * parent.
1472  */
1473 static void __clk_recalc_accuracies(struct clk_core *core)
1474 {
1475         unsigned long parent_accuracy = 0;
1476         struct clk_core *child;
1477
1478         lockdep_assert_held(&prepare_lock);
1479
1480         if (core->parent)
1481                 parent_accuracy = core->parent->accuracy;
1482
1483         if (core->ops->recalc_accuracy)
1484                 core->accuracy = core->ops->recalc_accuracy(core->hw,
1485                                                           parent_accuracy);
1486         else
1487                 core->accuracy = parent_accuracy;
1488
1489         hlist_for_each_entry(child, &core->children, child_node)
1490                 __clk_recalc_accuracies(child);
1491 }
1492
1493 static long clk_core_get_accuracy(struct clk_core *core)
1494 {
1495         unsigned long accuracy;
1496
1497         clk_prepare_lock();
1498         if (core && (core->flags & CLK_GET_ACCURACY_NOCACHE))
1499                 __clk_recalc_accuracies(core);
1500
1501         accuracy = __clk_get_accuracy(core);
1502         clk_prepare_unlock();
1503
1504         return accuracy;
1505 }
1506
1507 /**
1508  * clk_get_accuracy - return the accuracy of clk
1509  * @clk: the clk whose accuracy is being returned
1510  *
1511  * Simply returns the cached accuracy of the clk, unless
1512  * CLK_GET_ACCURACY_NOCACHE flag is set, which means a recalc_rate will be
1513  * issued.
1514  * If clk is NULL then returns 0.
1515  */
1516 long clk_get_accuracy(struct clk *clk)
1517 {
1518         if (!clk)
1519                 return 0;
1520
1521         return clk_core_get_accuracy(clk->core);
1522 }
1523 EXPORT_SYMBOL_GPL(clk_get_accuracy);
1524
1525 static unsigned long clk_recalc(struct clk_core *core,
1526                                 unsigned long parent_rate)
1527 {
1528         unsigned long rate = parent_rate;
1529
1530         if (core->ops->recalc_rate && !clk_pm_runtime_get(core)) {
1531                 rate = core->ops->recalc_rate(core->hw, parent_rate);
1532                 clk_pm_runtime_put(core);
1533         }
1534         return rate;
1535 }
1536
1537 /**
1538  * __clk_recalc_rates
1539  * @core: first clk in the subtree
1540  * @msg: notification type (see include/linux/clk.h)
1541  *
1542  * Walks the subtree of clks starting with clk and recalculates rates as it
1543  * goes.  Note that if a clk does not implement the .recalc_rate callback then
1544  * it is assumed that the clock will take on the rate of its parent.
1545  *
1546  * clk_recalc_rates also propagates the POST_RATE_CHANGE notification,
1547  * if necessary.
1548  */
1549 static void __clk_recalc_rates(struct clk_core *core, unsigned long msg)
1550 {
1551         unsigned long old_rate;
1552         unsigned long parent_rate = 0;
1553         struct clk_core *child;
1554
1555         lockdep_assert_held(&prepare_lock);
1556
1557         old_rate = core->rate;
1558
1559         if (core->parent)
1560                 parent_rate = core->parent->rate;
1561
1562         core->rate = clk_recalc(core, parent_rate);
1563
1564         /*
1565          * ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE
1566          * & ABORT_RATE_CHANGE notifiers
1567          */
1568         if (core->notifier_count && msg)
1569                 __clk_notify(core, msg, old_rate, core->rate);
1570
1571         hlist_for_each_entry(child, &core->children, child_node)
1572                 __clk_recalc_rates(child, msg);
1573 }
1574
1575 static unsigned long clk_core_get_rate(struct clk_core *core)
1576 {
1577         unsigned long rate;
1578
1579         clk_prepare_lock();
1580
1581         if (core && (core->flags & CLK_GET_RATE_NOCACHE))
1582                 __clk_recalc_rates(core, 0);
1583
1584         rate = clk_core_get_rate_nolock(core);
1585         clk_prepare_unlock();
1586
1587         return rate;
1588 }
1589
1590 /**
1591  * clk_get_rate - return the rate of clk
1592  * @clk: the clk whose rate is being returned
1593  *
1594  * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
1595  * is set, which means a recalc_rate will be issued.
1596  * If clk is NULL then returns 0.
1597  */
1598 unsigned long clk_get_rate(struct clk *clk)
1599 {
1600         if (!clk)
1601                 return 0;
1602
1603         return clk_core_get_rate(clk->core);
1604 }
1605 EXPORT_SYMBOL_GPL(clk_get_rate);
1606
1607 static int clk_fetch_parent_index(struct clk_core *core,
1608                                   struct clk_core *parent)
1609 {
1610         int i;
1611
1612         if (!parent)
1613                 return -EINVAL;
1614
1615         for (i = 0; i < core->num_parents; i++) {
1616                 /* Found it first try! */
1617                 if (core->parents[i].core == parent)
1618                         return i;
1619
1620                 /* Something else is here, so keep looking */
1621                 if (core->parents[i].core)
1622                         continue;
1623
1624                 /* Maybe core hasn't been cached but the hw is all we know? */
1625                 if (core->parents[i].hw) {
1626                         if (core->parents[i].hw == parent->hw)
1627                                 break;
1628
1629                         /* Didn't match, but we're expecting a clk_hw */
1630                         continue;
1631                 }
1632
1633                 /* Maybe it hasn't been cached (clk_set_parent() path) */
1634                 if (parent == clk_core_get(core, i))
1635                         break;
1636
1637                 /* Fallback to comparing globally unique names */
1638                 if (!strcmp(parent->name, core->parents[i].name))
1639                         break;
1640         }
1641
1642         if (i == core->num_parents)
1643                 return -EINVAL;
1644
1645         core->parents[i].core = parent;
1646         return i;
1647 }
1648
1649 /*
1650  * Update the orphan status of @core and all its children.
1651  */
1652 static void clk_core_update_orphan_status(struct clk_core *core, bool is_orphan)
1653 {
1654         struct clk_core *child;
1655
1656         core->orphan = is_orphan;
1657
1658         hlist_for_each_entry(child, &core->children, child_node)
1659                 clk_core_update_orphan_status(child, is_orphan);
1660 }
1661
1662 static void clk_reparent(struct clk_core *core, struct clk_core *new_parent)
1663 {
1664         bool was_orphan = core->orphan;
1665
1666         hlist_del(&core->child_node);
1667
1668         if (new_parent) {
1669                 bool becomes_orphan = new_parent->orphan;
1670
1671                 /* avoid duplicate POST_RATE_CHANGE notifications */
1672                 if (new_parent->new_child == core)
1673                         new_parent->new_child = NULL;
1674
1675                 hlist_add_head(&core->child_node, &new_parent->children);
1676
1677                 if (was_orphan != becomes_orphan)
1678                         clk_core_update_orphan_status(core, becomes_orphan);
1679         } else {
1680                 hlist_add_head(&core->child_node, &clk_orphan_list);
1681                 if (!was_orphan)
1682                         clk_core_update_orphan_status(core, true);
1683         }
1684
1685         core->parent = new_parent;
1686 }
1687
1688 static struct clk_core *__clk_set_parent_before(struct clk_core *core,
1689                                            struct clk_core *parent)
1690 {
1691         unsigned long flags;
1692         struct clk_core *old_parent = core->parent;
1693
1694         /*
1695          * 1. enable parents for CLK_OPS_PARENT_ENABLE clock
1696          *
1697          * 2. Migrate prepare state between parents and prevent race with
1698          * clk_enable().
1699          *
1700          * If the clock is not prepared, then a race with
1701          * clk_enable/disable() is impossible since we already have the
1702          * prepare lock (future calls to clk_enable() need to be preceded by
1703          * a clk_prepare()).
1704          *
1705          * If the clock is prepared, migrate the prepared state to the new
1706          * parent and also protect against a race with clk_enable() by
1707          * forcing the clock and the new parent on.  This ensures that all
1708          * future calls to clk_enable() are practically NOPs with respect to
1709          * hardware and software states.
1710          *
1711          * See also: Comment for clk_set_parent() below.
1712          */
1713
1714         /* enable old_parent & parent if CLK_OPS_PARENT_ENABLE is set */
1715         if (core->flags & CLK_OPS_PARENT_ENABLE) {
1716                 clk_core_prepare_enable(old_parent);
1717                 clk_core_prepare_enable(parent);
1718         }
1719
1720         /* migrate prepare count if > 0 */
1721         if (core->prepare_count) {
1722                 clk_core_prepare_enable(parent);
1723                 clk_core_enable_lock(core);
1724         }
1725
1726         /* update the clk tree topology */
1727         flags = clk_enable_lock();
1728         clk_reparent(core, parent);
1729         clk_enable_unlock(flags);
1730
1731         return old_parent;
1732 }
1733
1734 static void __clk_set_parent_after(struct clk_core *core,
1735                                    struct clk_core *parent,
1736                                    struct clk_core *old_parent)
1737 {
1738         /*
1739          * Finish the migration of prepare state and undo the changes done
1740          * for preventing a race with clk_enable().
1741          */
1742         if (core->prepare_count) {
1743                 clk_core_disable_lock(core);
1744                 clk_core_disable_unprepare(old_parent);
1745         }
1746
1747         /* re-balance ref counting if CLK_OPS_PARENT_ENABLE is set */
1748         if (core->flags & CLK_OPS_PARENT_ENABLE) {
1749                 clk_core_disable_unprepare(parent);
1750                 clk_core_disable_unprepare(old_parent);
1751         }
1752 }
1753
1754 static int __clk_set_parent(struct clk_core *core, struct clk_core *parent,
1755                             u8 p_index)
1756 {
1757         unsigned long flags;
1758         int ret = 0;
1759         struct clk_core *old_parent;
1760
1761         old_parent = __clk_set_parent_before(core, parent);
1762
1763         trace_clk_set_parent(core, parent);
1764
1765         /* change clock input source */
1766         if (parent && core->ops->set_parent)
1767                 ret = core->ops->set_parent(core->hw, p_index);
1768
1769         trace_clk_set_parent_complete(core, parent);
1770
1771         if (ret) {
1772                 flags = clk_enable_lock();
1773                 clk_reparent(core, old_parent);
1774                 clk_enable_unlock(flags);
1775                 __clk_set_parent_after(core, old_parent, parent);
1776
1777                 return ret;
1778         }
1779
1780         __clk_set_parent_after(core, parent, old_parent);
1781
1782         return 0;
1783 }
1784
1785 /**
1786  * __clk_speculate_rates
1787  * @core: first clk in the subtree
1788  * @parent_rate: the "future" rate of clk's parent
1789  *
1790  * Walks the subtree of clks starting with clk, speculating rates as it
1791  * goes and firing off PRE_RATE_CHANGE notifications as necessary.
1792  *
1793  * Unlike clk_recalc_rates, clk_speculate_rates exists only for sending
1794  * pre-rate change notifications and returns early if no clks in the
1795  * subtree have subscribed to the notifications.  Note that if a clk does not
1796  * implement the .recalc_rate callback then it is assumed that the clock will
1797  * take on the rate of its parent.
1798  */
1799 static int __clk_speculate_rates(struct clk_core *core,
1800                                  unsigned long parent_rate)
1801 {
1802         struct clk_core *child;
1803         unsigned long new_rate;
1804         int ret = NOTIFY_DONE;
1805
1806         lockdep_assert_held(&prepare_lock);
1807
1808         new_rate = clk_recalc(core, parent_rate);
1809
1810         /* abort rate change if a driver returns NOTIFY_BAD or NOTIFY_STOP */
1811         if (core->notifier_count)
1812                 ret = __clk_notify(core, PRE_RATE_CHANGE, core->rate, new_rate);
1813
1814         if (ret & NOTIFY_STOP_MASK) {
1815                 pr_debug("%s: clk notifier callback for clock %s aborted with error %d\n",
1816                                 __func__, core->name, ret);
1817                 goto out;
1818         }
1819
1820         hlist_for_each_entry(child, &core->children, child_node) {
1821                 ret = __clk_speculate_rates(child, new_rate);
1822                 if (ret & NOTIFY_STOP_MASK)
1823                         break;
1824         }
1825
1826 out:
1827         return ret;
1828 }
1829
1830 static void clk_calc_subtree(struct clk_core *core, unsigned long new_rate,
1831                              struct clk_core *new_parent, u8 p_index)
1832 {
1833         struct clk_core *child;
1834
1835         core->new_rate = new_rate;
1836         core->new_parent = new_parent;
1837         core->new_parent_index = p_index;
1838         /* include clk in new parent's PRE_RATE_CHANGE notifications */
1839         core->new_child = NULL;
1840         if (new_parent && new_parent != core->parent)
1841                 new_parent->new_child = core;
1842
1843         hlist_for_each_entry(child, &core->children, child_node) {
1844                 child->new_rate = clk_recalc(child, new_rate);
1845                 clk_calc_subtree(child, child->new_rate, NULL, 0);
1846         }
1847 }
1848
1849 /*
1850  * calculate the new rates returning the topmost clock that has to be
1851  * changed.
1852  */
1853 static struct clk_core *clk_calc_new_rates(struct clk_core *core,
1854                                            unsigned long rate)
1855 {
1856         struct clk_core *top = core;
1857         struct clk_core *old_parent, *parent;
1858         unsigned long best_parent_rate = 0;
1859         unsigned long new_rate;
1860         unsigned long min_rate;
1861         unsigned long max_rate;
1862         int p_index = 0;
1863         long ret;
1864
1865         /* sanity */
1866         if (IS_ERR_OR_NULL(core))
1867                 return NULL;
1868
1869         /* save parent rate, if it exists */
1870         parent = old_parent = core->parent;
1871         if (parent)
1872                 best_parent_rate = parent->rate;
1873
1874         clk_core_get_boundaries(core, &min_rate, &max_rate);
1875
1876         /* find the closest rate and parent clk/rate */
1877         if (clk_core_can_round(core)) {
1878                 struct clk_rate_request req;
1879
1880                 req.rate = rate;
1881                 req.min_rate = min_rate;
1882                 req.max_rate = max_rate;
1883
1884                 clk_core_init_rate_req(core, &req);
1885
1886                 ret = clk_core_determine_round_nolock(core, &req);
1887                 if (ret < 0)
1888                         return NULL;
1889
1890                 best_parent_rate = req.best_parent_rate;
1891                 new_rate = req.rate;
1892                 parent = req.best_parent_hw ? req.best_parent_hw->core : NULL;
1893
1894                 if (new_rate < min_rate || new_rate > max_rate)
1895                         return NULL;
1896         } else if (!parent || !(core->flags & CLK_SET_RATE_PARENT)) {
1897                 /* pass-through clock without adjustable parent */
1898                 core->new_rate = core->rate;
1899                 return NULL;
1900         } else {
1901                 /* pass-through clock with adjustable parent */
1902                 top = clk_calc_new_rates(parent, rate);
1903                 new_rate = parent->new_rate;
1904                 goto out;
1905         }
1906
1907         /* some clocks must be gated to change parent */
1908         if (parent != old_parent &&
1909             (core->flags & CLK_SET_PARENT_GATE) && core->prepare_count) {
1910                 pr_debug("%s: %s not gated but wants to reparent\n",
1911                          __func__, core->name);
1912                 return NULL;
1913         }
1914
1915         /* try finding the new parent index */
1916         if (parent && core->num_parents > 1) {
1917                 p_index = clk_fetch_parent_index(core, parent);
1918                 if (p_index < 0) {
1919                         pr_debug("%s: clk %s can not be parent of clk %s\n",
1920                                  __func__, parent->name, core->name);
1921                         return NULL;
1922                 }
1923         }
1924
1925         if ((core->flags & CLK_SET_RATE_PARENT) && parent &&
1926             best_parent_rate != parent->rate)
1927                 top = clk_calc_new_rates(parent, best_parent_rate);
1928
1929 out:
1930         clk_calc_subtree(core, new_rate, parent, p_index);
1931
1932         return top;
1933 }
1934
1935 /*
1936  * Notify about rate changes in a subtree. Always walk down the whole tree
1937  * so that in case of an error we can walk down the whole tree again and
1938  * abort the change.
1939  */
1940 static struct clk_core *clk_propagate_rate_change(struct clk_core *core,
1941                                                   unsigned long event)
1942 {
1943         struct clk_core *child, *tmp_clk, *fail_clk = NULL;
1944         int ret = NOTIFY_DONE;
1945
1946         if (core->rate == core->new_rate)
1947                 return NULL;
1948
1949         if (core->notifier_count) {
1950                 ret = __clk_notify(core, event, core->rate, core->new_rate);
1951                 if (ret & NOTIFY_STOP_MASK)
1952                         fail_clk = core;
1953         }
1954
1955         hlist_for_each_entry(child, &core->children, child_node) {
1956                 /* Skip children who will be reparented to another clock */
1957                 if (child->new_parent && child->new_parent != core)
1958                         continue;
1959                 tmp_clk = clk_propagate_rate_change(child, event);
1960                 if (tmp_clk)
1961                         fail_clk = tmp_clk;
1962         }
1963
1964         /* handle the new child who might not be in core->children yet */
1965         if (core->new_child) {
1966                 tmp_clk = clk_propagate_rate_change(core->new_child, event);
1967                 if (tmp_clk)
1968                         fail_clk = tmp_clk;
1969         }
1970
1971         return fail_clk;
1972 }
1973
1974 /*
1975  * walk down a subtree and set the new rates notifying the rate
1976  * change on the way
1977  */
1978 static void clk_change_rate(struct clk_core *core)
1979 {
1980         struct clk_core *child;
1981         struct hlist_node *tmp;
1982         unsigned long old_rate;
1983         unsigned long best_parent_rate = 0;
1984         bool skip_set_rate = false;
1985         struct clk_core *old_parent;
1986         struct clk_core *parent = NULL;
1987
1988         old_rate = core->rate;
1989
1990         if (core->new_parent) {
1991                 parent = core->new_parent;
1992                 best_parent_rate = core->new_parent->rate;
1993         } else if (core->parent) {
1994                 parent = core->parent;
1995                 best_parent_rate = core->parent->rate;
1996         }
1997
1998         if (clk_pm_runtime_get(core))
1999                 return;
2000
2001         if (core->flags & CLK_SET_RATE_UNGATE) {
2002                 unsigned long flags;
2003
2004                 clk_core_prepare(core);
2005                 flags = clk_enable_lock();
2006                 clk_core_enable(core);
2007                 clk_enable_unlock(flags);
2008         }
2009
2010         if (core->new_parent && core->new_parent != core->parent) {
2011                 old_parent = __clk_set_parent_before(core, core->new_parent);
2012                 trace_clk_set_parent(core, core->new_parent);
2013
2014                 if (core->ops->set_rate_and_parent) {
2015                         skip_set_rate = true;
2016                         core->ops->set_rate_and_parent(core->hw, core->new_rate,
2017                                         best_parent_rate,
2018                                         core->new_parent_index);
2019                 } else if (core->ops->set_parent) {
2020                         core->ops->set_parent(core->hw, core->new_parent_index);
2021                 }
2022
2023                 trace_clk_set_parent_complete(core, core->new_parent);
2024                 __clk_set_parent_after(core, core->new_parent, old_parent);
2025         }
2026
2027         if (core->flags & CLK_OPS_PARENT_ENABLE)
2028                 clk_core_prepare_enable(parent);
2029
2030         trace_clk_set_rate(core, core->new_rate);
2031
2032         if (!skip_set_rate && core->ops->set_rate)
2033                 core->ops->set_rate(core->hw, core->new_rate, best_parent_rate);
2034
2035         trace_clk_set_rate_complete(core, core->new_rate);
2036
2037         core->rate = clk_recalc(core, best_parent_rate);
2038
2039         if (core->flags & CLK_SET_RATE_UNGATE) {
2040                 unsigned long flags;
2041
2042                 flags = clk_enable_lock();
2043                 clk_core_disable(core);
2044                 clk_enable_unlock(flags);
2045                 clk_core_unprepare(core);
2046         }
2047
2048         if (core->flags & CLK_OPS_PARENT_ENABLE)
2049                 clk_core_disable_unprepare(parent);
2050
2051         if (core->notifier_count && old_rate != core->rate)
2052                 __clk_notify(core, POST_RATE_CHANGE, old_rate, core->rate);
2053
2054         if (core->flags & CLK_RECALC_NEW_RATES)
2055                 (void)clk_calc_new_rates(core, core->new_rate);
2056
2057         /*
2058          * Use safe iteration, as change_rate can actually swap parents
2059          * for certain clock types.
2060          */
2061         hlist_for_each_entry_safe(child, tmp, &core->children, child_node) {
2062                 /* Skip children who will be reparented to another clock */
2063                 if (child->new_parent && child->new_parent != core)
2064                         continue;
2065                 clk_change_rate(child);
2066         }
2067
2068         /* handle the new child who might not be in core->children yet */
2069         if (core->new_child)
2070                 clk_change_rate(core->new_child);
2071
2072         clk_pm_runtime_put(core);
2073 }
2074
2075 static unsigned long clk_core_req_round_rate_nolock(struct clk_core *core,
2076                                                      unsigned long req_rate)
2077 {
2078         int ret, cnt;
2079         struct clk_rate_request req;
2080
2081         lockdep_assert_held(&prepare_lock);
2082
2083         if (!core)
2084                 return 0;
2085
2086         /* simulate what the rate would be if it could be freely set */
2087         cnt = clk_core_rate_nuke_protect(core);
2088         if (cnt < 0)
2089                 return cnt;
2090
2091         clk_core_get_boundaries(core, &req.min_rate, &req.max_rate);
2092         req.rate = req_rate;
2093
2094         ret = clk_core_round_rate_nolock(core, &req);
2095
2096         /* restore the protection */
2097         clk_core_rate_restore_protect(core, cnt);
2098
2099         return ret ? 0 : req.rate;
2100 }
2101
2102 static int clk_core_set_rate_nolock(struct clk_core *core,
2103                                     unsigned long req_rate)
2104 {
2105         struct clk_core *top, *fail_clk;
2106         unsigned long rate;
2107         int ret = 0;
2108
2109         if (!core)
2110                 return 0;
2111
2112         rate = clk_core_req_round_rate_nolock(core, req_rate);
2113
2114         /* bail early if nothing to do */
2115         if (rate == clk_core_get_rate_nolock(core))
2116                 return 0;
2117
2118         /* fail on a direct rate set of a protected provider */
2119         if (clk_core_rate_is_protected(core))
2120                 return -EBUSY;
2121
2122         /* calculate new rates and get the topmost changed clock */
2123         top = clk_calc_new_rates(core, req_rate);
2124         if (!top)
2125                 return -EINVAL;
2126
2127         ret = clk_pm_runtime_get(core);
2128         if (ret)
2129                 return ret;
2130
2131         /* notify that we are about to change rates */
2132         fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
2133         if (fail_clk) {
2134                 pr_debug("%s: failed to set %s rate\n", __func__,
2135                                 fail_clk->name);
2136                 clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
2137                 ret = -EBUSY;
2138                 goto err;
2139         }
2140
2141         /* change the rates */
2142         clk_change_rate(top);
2143
2144         core->req_rate = req_rate;
2145 err:
2146         clk_pm_runtime_put(core);
2147
2148         return ret;
2149 }
2150
2151 /**
2152  * clk_set_rate - specify a new rate for clk
2153  * @clk: the clk whose rate is being changed
2154  * @rate: the new rate for clk
2155  *
2156  * In the simplest case clk_set_rate will only adjust the rate of clk.
2157  *
2158  * Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to
2159  * propagate up to clk's parent; whether or not this happens depends on the
2160  * outcome of clk's .round_rate implementation.  If *parent_rate is unchanged
2161  * after calling .round_rate then upstream parent propagation is ignored.  If
2162  * *parent_rate comes back with a new rate for clk's parent then we propagate
2163  * up to clk's parent and set its rate.  Upward propagation will continue
2164  * until either a clk does not support the CLK_SET_RATE_PARENT flag or
2165  * .round_rate stops requesting changes to clk's parent_rate.
2166  *
2167  * Rate changes are accomplished via tree traversal that also recalculates the
2168  * rates for the clocks and fires off POST_RATE_CHANGE notifiers.
2169  *
2170  * Returns 0 on success, -EERROR otherwise.
2171  */
2172 int clk_set_rate(struct clk *clk, unsigned long rate)
2173 {
2174         int ret;
2175
2176         if (!clk)
2177                 return 0;
2178
2179         /* prevent racing with updates to the clock topology */
2180         clk_prepare_lock();
2181
2182         if (clk->exclusive_count)
2183                 clk_core_rate_unprotect(clk->core);
2184
2185         ret = clk_core_set_rate_nolock(clk->core, rate);
2186
2187         if (clk->exclusive_count)
2188                 clk_core_rate_protect(clk->core);
2189
2190         clk_prepare_unlock();
2191
2192         return ret;
2193 }
2194 EXPORT_SYMBOL_GPL(clk_set_rate);
2195
2196 /**
2197  * clk_set_rate_exclusive - specify a new rate get exclusive control
2198  * @clk: the clk whose rate is being changed
2199  * @rate: the new rate for clk
2200  *
2201  * This is a combination of clk_set_rate() and clk_rate_exclusive_get()
2202  * within a critical section
2203  *
2204  * This can be used initially to ensure that at least 1 consumer is
2205  * statisfied when several consumers are competing for exclusivity over the
2206  * same clock provider.
2207  *
2208  * The exclusivity is not applied if setting the rate failed.
2209  *
2210  * Calls to clk_rate_exclusive_get() should be balanced with calls to
2211  * clk_rate_exclusive_put().
2212  *
2213  * Returns 0 on success, -EERROR otherwise.
2214  */
2215 int clk_set_rate_exclusive(struct clk *clk, unsigned long rate)
2216 {
2217         int ret;
2218
2219         if (!clk)
2220                 return 0;
2221
2222         /* prevent racing with updates to the clock topology */
2223         clk_prepare_lock();
2224
2225         /*
2226          * The temporary protection removal is not here, on purpose
2227          * This function is meant to be used instead of clk_rate_protect,
2228          * so before the consumer code path protect the clock provider
2229          */
2230
2231         ret = clk_core_set_rate_nolock(clk->core, rate);
2232         if (!ret) {
2233                 clk_core_rate_protect(clk->core);
2234                 clk->exclusive_count++;
2235         }
2236
2237         clk_prepare_unlock();
2238
2239         return ret;
2240 }
2241 EXPORT_SYMBOL_GPL(clk_set_rate_exclusive);
2242
2243 /**
2244  * clk_set_rate_range - set a rate range for a clock source
2245  * @clk: clock source
2246  * @min: desired minimum clock rate in Hz, inclusive
2247  * @max: desired maximum clock rate in Hz, inclusive
2248  *
2249  * Returns success (0) or negative errno.
2250  */
2251 int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max)
2252 {
2253         int ret = 0;
2254         unsigned long old_min, old_max, rate;
2255
2256         if (!clk)
2257                 return 0;
2258
2259         if (min > max) {
2260                 pr_err("%s: clk %s dev %s con %s: invalid range [%lu, %lu]\n",
2261                        __func__, clk->core->name, clk->dev_id, clk->con_id,
2262                        min, max);
2263                 return -EINVAL;
2264         }
2265
2266         clk_prepare_lock();
2267
2268         if (clk->exclusive_count)
2269                 clk_core_rate_unprotect(clk->core);
2270
2271         /* Save the current values in case we need to rollback the change */
2272         old_min = clk->min_rate;
2273         old_max = clk->max_rate;
2274         clk->min_rate = min;
2275         clk->max_rate = max;
2276
2277         rate = clk_core_get_rate_nolock(clk->core);
2278         if (rate < min || rate > max) {
2279                 /*
2280                  * FIXME:
2281                  * We are in bit of trouble here, current rate is outside the
2282                  * the requested range. We are going try to request appropriate
2283                  * range boundary but there is a catch. It may fail for the
2284                  * usual reason (clock broken, clock protected, etc) but also
2285                  * because:
2286                  * - round_rate() was not favorable and fell on the wrong
2287                  *   side of the boundary
2288                  * - the determine_rate() callback does not really check for
2289                  *   this corner case when determining the rate
2290                  */
2291
2292                 if (rate < min)
2293                         rate = min;
2294                 else
2295                         rate = max;
2296
2297                 ret = clk_core_set_rate_nolock(clk->core, rate);
2298                 if (ret) {
2299                         /* rollback the changes */
2300                         clk->min_rate = old_min;
2301                         clk->max_rate = old_max;
2302                 }
2303         }
2304
2305         if (clk->exclusive_count)
2306                 clk_core_rate_protect(clk->core);
2307
2308         clk_prepare_unlock();
2309
2310         return ret;
2311 }
2312 EXPORT_SYMBOL_GPL(clk_set_rate_range);
2313
2314 /**
2315  * clk_set_min_rate - set a minimum clock rate for a clock source
2316  * @clk: clock source
2317  * @rate: desired minimum clock rate in Hz, inclusive
2318  *
2319  * Returns success (0) or negative errno.
2320  */
2321 int clk_set_min_rate(struct clk *clk, unsigned long rate)
2322 {
2323         if (!clk)
2324                 return 0;
2325
2326         return clk_set_rate_range(clk, rate, clk->max_rate);
2327 }
2328 EXPORT_SYMBOL_GPL(clk_set_min_rate);
2329
2330 /**
2331  * clk_set_max_rate - set a maximum clock rate for a clock source
2332  * @clk: clock source
2333  * @rate: desired maximum clock rate in Hz, inclusive
2334  *
2335  * Returns success (0) or negative errno.
2336  */
2337 int clk_set_max_rate(struct clk *clk, unsigned long rate)
2338 {
2339         if (!clk)
2340                 return 0;
2341
2342         return clk_set_rate_range(clk, clk->min_rate, rate);
2343 }
2344 EXPORT_SYMBOL_GPL(clk_set_max_rate);
2345
2346 /**
2347  * clk_get_parent - return the parent of a clk
2348  * @clk: the clk whose parent gets returned
2349  *
2350  * Simply returns clk->parent.  Returns NULL if clk is NULL.
2351  */
2352 struct clk *clk_get_parent(struct clk *clk)
2353 {
2354         struct clk *parent;
2355
2356         if (!clk)
2357                 return NULL;
2358
2359         clk_prepare_lock();
2360         /* TODO: Create a per-user clk and change callers to call clk_put */
2361         parent = !clk->core->parent ? NULL : clk->core->parent->hw->clk;
2362         clk_prepare_unlock();
2363
2364         return parent;
2365 }
2366 EXPORT_SYMBOL_GPL(clk_get_parent);
2367
2368 static struct clk_core *__clk_init_parent(struct clk_core *core)
2369 {
2370         u8 index = 0;
2371
2372         if (core->num_parents > 1 && core->ops->get_parent)
2373                 index = core->ops->get_parent(core->hw);
2374
2375         return clk_core_get_parent_by_index(core, index);
2376 }
2377
2378 static void clk_core_reparent(struct clk_core *core,
2379                                   struct clk_core *new_parent)
2380 {
2381         clk_reparent(core, new_parent);
2382         __clk_recalc_accuracies(core);
2383         __clk_recalc_rates(core, POST_RATE_CHANGE);
2384 }
2385
2386 void clk_hw_reparent(struct clk_hw *hw, struct clk_hw *new_parent)
2387 {
2388         if (!hw)
2389                 return;
2390
2391         clk_core_reparent(hw->core, !new_parent ? NULL : new_parent->core);
2392 }
2393
2394 /**
2395  * clk_has_parent - check if a clock is a possible parent for another
2396  * @clk: clock source
2397  * @parent: parent clock source
2398  *
2399  * This function can be used in drivers that need to check that a clock can be
2400  * the parent of another without actually changing the parent.
2401  *
2402  * Returns true if @parent is a possible parent for @clk, false otherwise.
2403  */
2404 bool clk_has_parent(struct clk *clk, struct clk *parent)
2405 {
2406         struct clk_core *core, *parent_core;
2407         int i;
2408
2409         /* NULL clocks should be nops, so return success if either is NULL. */
2410         if (!clk || !parent)
2411                 return true;
2412
2413         core = clk->core;
2414         parent_core = parent->core;
2415
2416         /* Optimize for the case where the parent is already the parent. */
2417         if (core->parent == parent_core)
2418                 return true;
2419
2420         for (i = 0; i < core->num_parents; i++)
2421                 if (!strcmp(core->parents[i].name, parent_core->name))
2422                         return true;
2423
2424         return false;
2425 }
2426 EXPORT_SYMBOL_GPL(clk_has_parent);
2427
2428 static int clk_core_set_parent_nolock(struct clk_core *core,
2429                                       struct clk_core *parent)
2430 {
2431         int ret = 0;
2432         int p_index = 0;
2433         unsigned long p_rate = 0;
2434
2435         lockdep_assert_held(&prepare_lock);
2436
2437         if (!core)
2438                 return 0;
2439
2440         if (core->parent == parent)
2441                 return 0;
2442
2443         /* verify ops for for multi-parent clks */
2444         if (core->num_parents > 1 && !core->ops->set_parent)
2445                 return -EPERM;
2446
2447         /* check that we are allowed to re-parent if the clock is in use */
2448         if ((core->flags & CLK_SET_PARENT_GATE) && core->prepare_count)
2449                 return -EBUSY;
2450
2451         if (clk_core_rate_is_protected(core))
2452                 return -EBUSY;
2453
2454         /* try finding the new parent index */
2455         if (parent) {
2456                 p_index = clk_fetch_parent_index(core, parent);
2457                 if (p_index < 0) {
2458                         pr_debug("%s: clk %s can not be parent of clk %s\n",
2459                                         __func__, parent->name, core->name);
2460                         return p_index;
2461                 }
2462                 p_rate = parent->rate;
2463         }
2464
2465         ret = clk_pm_runtime_get(core);
2466         if (ret)
2467                 return ret;
2468
2469         /* propagate PRE_RATE_CHANGE notifications */
2470         ret = __clk_speculate_rates(core, p_rate);
2471
2472         /* abort if a driver objects */
2473         if (ret & NOTIFY_STOP_MASK)
2474                 goto runtime_put;
2475
2476         /* do the re-parent */
2477         ret = __clk_set_parent(core, parent, p_index);
2478
2479         /* propagate rate an accuracy recalculation accordingly */
2480         if (ret) {
2481                 __clk_recalc_rates(core, ABORT_RATE_CHANGE);
2482         } else {
2483                 __clk_recalc_rates(core, POST_RATE_CHANGE);
2484                 __clk_recalc_accuracies(core);
2485         }
2486
2487 runtime_put:
2488         clk_pm_runtime_put(core);
2489
2490         return ret;
2491 }
2492
2493 /**
2494  * clk_set_parent - switch the parent of a mux clk
2495  * @clk: the mux clk whose input we are switching
2496  * @parent: the new input to clk
2497  *
2498  * Re-parent clk to use parent as its new input source.  If clk is in
2499  * prepared state, the clk will get enabled for the duration of this call. If
2500  * that's not acceptable for a specific clk (Eg: the consumer can't handle
2501  * that, the reparenting is glitchy in hardware, etc), use the
2502  * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
2503  *
2504  * After successfully changing clk's parent clk_set_parent will update the
2505  * clk topology, sysfs topology and propagate rate recalculation via
2506  * __clk_recalc_rates.
2507  *
2508  * Returns 0 on success, -EERROR otherwise.
2509  */
2510 int clk_set_parent(struct clk *clk, struct clk *parent)
2511 {
2512         int ret;
2513
2514         if (!clk)
2515                 return 0;
2516
2517         clk_prepare_lock();
2518
2519         if (clk->exclusive_count)
2520                 clk_core_rate_unprotect(clk->core);
2521
2522         ret = clk_core_set_parent_nolock(clk->core,
2523                                          parent ? parent->core : NULL);
2524
2525         if (clk->exclusive_count)
2526                 clk_core_rate_protect(clk->core);
2527
2528         clk_prepare_unlock();
2529
2530         return ret;
2531 }
2532 EXPORT_SYMBOL_GPL(clk_set_parent);
2533
2534 static int clk_core_set_phase_nolock(struct clk_core *core, int degrees)
2535 {
2536         int ret = -EINVAL;
2537
2538         lockdep_assert_held(&prepare_lock);
2539
2540         if (!core)
2541                 return 0;
2542
2543         if (clk_core_rate_is_protected(core))
2544                 return -EBUSY;
2545
2546         trace_clk_set_phase(core, degrees);
2547
2548         if (core->ops->set_phase) {
2549                 ret = core->ops->set_phase(core->hw, degrees);
2550                 if (!ret)
2551                         core->phase = degrees;
2552         }
2553
2554         trace_clk_set_phase_complete(core, degrees);
2555
2556         return ret;
2557 }
2558
2559 /**
2560  * clk_set_phase - adjust the phase shift of a clock signal
2561  * @clk: clock signal source
2562  * @degrees: number of degrees the signal is shifted
2563  *
2564  * Shifts the phase of a clock signal by the specified
2565  * degrees. Returns 0 on success, -EERROR otherwise.
2566  *
2567  * This function makes no distinction about the input or reference
2568  * signal that we adjust the clock signal phase against. For example
2569  * phase locked-loop clock signal generators we may shift phase with
2570  * respect to feedback clock signal input, but for other cases the
2571  * clock phase may be shifted with respect to some other, unspecified
2572  * signal.
2573  *
2574  * Additionally the concept of phase shift does not propagate through
2575  * the clock tree hierarchy, which sets it apart from clock rates and
2576  * clock accuracy. A parent clock phase attribute does not have an
2577  * impact on the phase attribute of a child clock.
2578  */
2579 int clk_set_phase(struct clk *clk, int degrees)
2580 {
2581         int ret;
2582
2583         if (!clk)
2584                 return 0;
2585
2586         /* sanity check degrees */
2587         degrees %= 360;
2588         if (degrees < 0)
2589                 degrees += 360;
2590
2591         clk_prepare_lock();
2592
2593         if (clk->exclusive_count)
2594                 clk_core_rate_unprotect(clk->core);
2595
2596         ret = clk_core_set_phase_nolock(clk->core, degrees);
2597
2598         if (clk->exclusive_count)
2599                 clk_core_rate_protect(clk->core);
2600
2601         clk_prepare_unlock();
2602
2603         return ret;
2604 }
2605 EXPORT_SYMBOL_GPL(clk_set_phase);
2606
2607 static int clk_core_get_phase(struct clk_core *core)
2608 {
2609         int ret;
2610
2611         clk_prepare_lock();
2612         /* Always try to update cached phase if possible */
2613         if (core->ops->get_phase)
2614                 core->phase = core->ops->get_phase(core->hw);
2615         ret = core->phase;
2616         clk_prepare_unlock();
2617
2618         return ret;
2619 }
2620
2621 /**
2622  * clk_get_phase - return the phase shift of a clock signal
2623  * @clk: clock signal source
2624  *
2625  * Returns the phase shift of a clock node in degrees, otherwise returns
2626  * -EERROR.
2627  */
2628 int clk_get_phase(struct clk *clk)
2629 {
2630         if (!clk)
2631                 return 0;
2632
2633         return clk_core_get_phase(clk->core);
2634 }
2635 EXPORT_SYMBOL_GPL(clk_get_phase);
2636
2637 static void clk_core_reset_duty_cycle_nolock(struct clk_core *core)
2638 {
2639         /* Assume a default value of 50% */
2640         core->duty.num = 1;
2641         core->duty.den = 2;
2642 }
2643
2644 static int clk_core_update_duty_cycle_parent_nolock(struct clk_core *core);
2645
2646 static int clk_core_update_duty_cycle_nolock(struct clk_core *core)
2647 {
2648         struct clk_duty *duty = &core->duty;
2649         int ret = 0;
2650
2651         if (!core->ops->get_duty_cycle)
2652                 return clk_core_update_duty_cycle_parent_nolock(core);
2653
2654         ret = core->ops->get_duty_cycle(core->hw, duty);
2655         if (ret)
2656                 goto reset;
2657
2658         /* Don't trust the clock provider too much */
2659         if (duty->den == 0 || duty->num > duty->den) {
2660                 ret = -EINVAL;
2661                 goto reset;
2662         }
2663
2664         return 0;
2665
2666 reset:
2667         clk_core_reset_duty_cycle_nolock(core);
2668         return ret;
2669 }
2670
2671 static int clk_core_update_duty_cycle_parent_nolock(struct clk_core *core)
2672 {
2673         int ret = 0;
2674
2675         if (core->parent &&
2676             core->flags & CLK_DUTY_CYCLE_PARENT) {
2677                 ret = clk_core_update_duty_cycle_nolock(core->parent);
2678                 memcpy(&core->duty, &core->parent->duty, sizeof(core->duty));
2679         } else {
2680                 clk_core_reset_duty_cycle_nolock(core);
2681         }
2682
2683         return ret;
2684 }
2685
2686 static int clk_core_set_duty_cycle_parent_nolock(struct clk_core *core,
2687                                                  struct clk_duty *duty);
2688
2689 static int clk_core_set_duty_cycle_nolock(struct clk_core *core,
2690                                           struct clk_duty *duty)
2691 {
2692         int ret;
2693
2694         lockdep_assert_held(&prepare_lock);
2695
2696         if (clk_core_rate_is_protected(core))
2697                 return -EBUSY;
2698
2699         trace_clk_set_duty_cycle(core, duty);
2700
2701         if (!core->ops->set_duty_cycle)
2702                 return clk_core_set_duty_cycle_parent_nolock(core, duty);
2703
2704         ret = core->ops->set_duty_cycle(core->hw, duty);
2705         if (!ret)
2706                 memcpy(&core->duty, duty, sizeof(*duty));
2707
2708         trace_clk_set_duty_cycle_complete(core, duty);
2709
2710         return ret;
2711 }
2712
2713 static int clk_core_set_duty_cycle_parent_nolock(struct clk_core *core,
2714                                                  struct clk_duty *duty)
2715 {
2716         int ret = 0;
2717
2718         if (core->parent &&
2719             core->flags & (CLK_DUTY_CYCLE_PARENT | CLK_SET_RATE_PARENT)) {
2720                 ret = clk_core_set_duty_cycle_nolock(core->parent, duty);
2721                 memcpy(&core->duty, &core->parent->duty, sizeof(core->duty));
2722         }
2723
2724         return ret;
2725 }
2726
2727 /**
2728  * clk_set_duty_cycle - adjust the duty cycle ratio of a clock signal
2729  * @clk: clock signal source
2730  * @num: numerator of the duty cycle ratio to be applied
2731  * @den: denominator of the duty cycle ratio to be applied
2732  *
2733  * Apply the duty cycle ratio if the ratio is valid and the clock can
2734  * perform this operation
2735  *
2736  * Returns (0) on success, a negative errno otherwise.
2737  */
2738 int clk_set_duty_cycle(struct clk *clk, unsigned int num, unsigned int den)
2739 {
2740         int ret;
2741         struct clk_duty duty;
2742
2743         if (!clk)
2744                 return 0;
2745
2746         /* sanity check the ratio */
2747         if (den == 0 || num > den)
2748                 return -EINVAL;
2749
2750         duty.num = num;
2751         duty.den = den;
2752
2753         clk_prepare_lock();
2754
2755         if (clk->exclusive_count)
2756                 clk_core_rate_unprotect(clk->core);
2757
2758         ret = clk_core_set_duty_cycle_nolock(clk->core, &duty);
2759
2760         if (clk->exclusive_count)
2761                 clk_core_rate_protect(clk->core);
2762
2763         clk_prepare_unlock();
2764
2765         return ret;
2766 }
2767 EXPORT_SYMBOL_GPL(clk_set_duty_cycle);
2768
2769 static int clk_core_get_scaled_duty_cycle(struct clk_core *core,
2770                                           unsigned int scale)
2771 {
2772         struct clk_duty *duty = &core->duty;
2773         int ret;
2774
2775         clk_prepare_lock();
2776
2777         ret = clk_core_update_duty_cycle_nolock(core);
2778         if (!ret)
2779                 ret = mult_frac(scale, duty->num, duty->den);
2780
2781         clk_prepare_unlock();
2782
2783         return ret;
2784 }
2785
2786 /**
2787  * clk_get_scaled_duty_cycle - return the duty cycle ratio of a clock signal
2788  * @clk: clock signal source
2789  * @scale: scaling factor to be applied to represent the ratio as an integer
2790  *
2791  * Returns the duty cycle ratio of a clock node multiplied by the provided
2792  * scaling factor, or negative errno on error.
2793  */
2794 int clk_get_scaled_duty_cycle(struct clk *clk, unsigned int scale)
2795 {
2796         if (!clk)
2797                 return 0;
2798
2799         return clk_core_get_scaled_duty_cycle(clk->core, scale);
2800 }
2801 EXPORT_SYMBOL_GPL(clk_get_scaled_duty_cycle);
2802
2803 /**
2804  * clk_is_match - check if two clk's point to the same hardware clock
2805  * @p: clk compared against q
2806  * @q: clk compared against p
2807  *
2808  * Returns true if the two struct clk pointers both point to the same hardware
2809  * clock node. Put differently, returns true if struct clk *p and struct clk *q
2810  * share the same struct clk_core object.
2811  *
2812  * Returns false otherwise. Note that two NULL clks are treated as matching.
2813  */
2814 bool clk_is_match(const struct clk *p, const struct clk *q)
2815 {
2816         /* trivial case: identical struct clk's or both NULL */
2817         if (p == q)
2818                 return true;
2819
2820         /* true if clk->core pointers match. Avoid dereferencing garbage */
2821         if (!IS_ERR_OR_NULL(p) && !IS_ERR_OR_NULL(q))
2822                 if (p->core == q->core)
2823                         return true;
2824
2825         return false;
2826 }
2827 EXPORT_SYMBOL_GPL(clk_is_match);
2828
2829 /***        debugfs support        ***/
2830
2831 #ifdef CONFIG_DEBUG_FS
2832 #include <linux/debugfs.h>
2833
2834 static struct dentry *rootdir;
2835 static int inited = 0;
2836 static DEFINE_MUTEX(clk_debug_lock);
2837 static HLIST_HEAD(clk_debug_list);
2838
2839 static struct hlist_head *all_lists[] = {
2840         &clk_root_list,
2841         &clk_orphan_list,
2842         NULL,
2843 };
2844
2845 static struct hlist_head *orphan_list[] = {
2846         &clk_orphan_list,
2847         NULL,
2848 };
2849
2850 static void clk_summary_show_one(struct seq_file *s, struct clk_core *c,
2851                                  int level)
2852 {
2853         if (!c)
2854                 return;
2855
2856         seq_printf(s, "%*s%-*s %7d %8d %8d %11lu %10lu %5d %6d\n",
2857                    level * 3 + 1, "",
2858                    30 - level * 3, c->name,
2859                    c->enable_count, c->prepare_count, c->protect_count,
2860                    clk_core_get_rate(c), clk_core_get_accuracy(c),
2861                    clk_core_get_phase(c),
2862                    clk_core_get_scaled_duty_cycle(c, 100000));
2863 }
2864
2865 static void clk_summary_show_subtree(struct seq_file *s, struct clk_core *c,
2866                                      int level)
2867 {
2868         struct clk_core *child;
2869
2870         if (!c)
2871                 return;
2872
2873         clk_summary_show_one(s, c, level);
2874
2875         hlist_for_each_entry(child, &c->children, child_node)
2876                 clk_summary_show_subtree(s, child, level + 1);
2877 }
2878
2879 static int clk_summary_show(struct seq_file *s, void *data)
2880 {
2881         struct clk_core *c;
2882         struct hlist_head **lists = (struct hlist_head **)s->private;
2883
2884         seq_puts(s, "                                 enable  prepare  protect                                duty\n");
2885         seq_puts(s, "   clock                          count    count    count        rate   accuracy phase  cycle\n");
2886         seq_puts(s, "---------------------------------------------------------------------------------------------\n");
2887
2888         clk_prepare_lock();
2889
2890         for (; *lists; lists++)
2891                 hlist_for_each_entry(c, *lists, child_node)
2892                         clk_summary_show_subtree(s, c, 0);
2893
2894         clk_prepare_unlock();
2895
2896         return 0;
2897 }
2898 DEFINE_SHOW_ATTRIBUTE(clk_summary);
2899
2900 static void clk_dump_one(struct seq_file *s, struct clk_core *c, int level)
2901 {
2902         if (!c)
2903                 return;
2904
2905         /* This should be JSON format, i.e. elements separated with a comma */
2906         seq_printf(s, "\"%s\": { ", c->name);
2907         seq_printf(s, "\"enable_count\": %d,", c->enable_count);
2908         seq_printf(s, "\"prepare_count\": %d,", c->prepare_count);
2909         seq_printf(s, "\"protect_count\": %d,", c->protect_count);
2910         seq_printf(s, "\"rate\": %lu,", clk_core_get_rate(c));
2911         seq_printf(s, "\"accuracy\": %lu,", clk_core_get_accuracy(c));
2912         seq_printf(s, "\"phase\": %d,", clk_core_get_phase(c));
2913         seq_printf(s, "\"duty_cycle\": %u",
2914                    clk_core_get_scaled_duty_cycle(c, 100000));
2915 }
2916
2917 static void clk_dump_subtree(struct seq_file *s, struct clk_core *c, int level)
2918 {
2919         struct clk_core *child;
2920
2921         if (!c)
2922                 return;
2923
2924         clk_dump_one(s, c, level);
2925
2926         hlist_for_each_entry(child, &c->children, child_node) {
2927                 seq_putc(s, ',');
2928                 clk_dump_subtree(s, child, level + 1);
2929         }
2930
2931         seq_putc(s, '}');
2932 }
2933
2934 static int clk_dump_show(struct seq_file *s, void *data)
2935 {
2936         struct clk_core *c;
2937         bool first_node = true;
2938         struct hlist_head **lists = (struct hlist_head **)s->private;
2939
2940         seq_putc(s, '{');
2941         clk_prepare_lock();
2942
2943         for (; *lists; lists++) {
2944                 hlist_for_each_entry(c, *lists, child_node) {
2945                         if (!first_node)
2946                                 seq_putc(s, ',');
2947                         first_node = false;
2948                         clk_dump_subtree(s, c, 0);
2949                 }
2950         }
2951
2952         clk_prepare_unlock();
2953
2954         seq_puts(s, "}\n");
2955         return 0;
2956 }
2957 DEFINE_SHOW_ATTRIBUTE(clk_dump);
2958
2959 static const struct {
2960         unsigned long flag;
2961         const char *name;
2962 } clk_flags[] = {
2963 #define ENTRY(f) { f, #f }
2964         ENTRY(CLK_SET_RATE_GATE),
2965         ENTRY(CLK_SET_PARENT_GATE),
2966         ENTRY(CLK_SET_RATE_PARENT),
2967         ENTRY(CLK_IGNORE_UNUSED),
2968         ENTRY(CLK_GET_RATE_NOCACHE),
2969         ENTRY(CLK_SET_RATE_NO_REPARENT),
2970         ENTRY(CLK_GET_ACCURACY_NOCACHE),
2971         ENTRY(CLK_RECALC_NEW_RATES),
2972         ENTRY(CLK_SET_RATE_UNGATE),
2973         ENTRY(CLK_IS_CRITICAL),
2974         ENTRY(CLK_OPS_PARENT_ENABLE),
2975         ENTRY(CLK_DUTY_CYCLE_PARENT),
2976 #undef ENTRY
2977 };
2978
2979 static int clk_flags_show(struct seq_file *s, void *data)
2980 {
2981         struct clk_core *core = s->private;
2982         unsigned long flags = core->flags;
2983         unsigned int i;
2984
2985         for (i = 0; flags && i < ARRAY_SIZE(clk_flags); i++) {
2986                 if (flags & clk_flags[i].flag) {
2987                         seq_printf(s, "%s\n", clk_flags[i].name);
2988                         flags &= ~clk_flags[i].flag;
2989                 }
2990         }
2991         if (flags) {
2992                 /* Unknown flags */
2993                 seq_printf(s, "0x%lx\n", flags);
2994         }
2995
2996         return 0;
2997 }
2998 DEFINE_SHOW_ATTRIBUTE(clk_flags);
2999
3000 static int possible_parents_show(struct seq_file *s, void *data)
3001 {
3002         struct clk_core *core = s->private;
3003         int i;
3004
3005         for (i = 0; i < core->num_parents - 1; i++)
3006                 seq_printf(s, "%s ", core->parents[i].name);
3007
3008         seq_printf(s, "%s\n", core->parents[i].name);
3009
3010         return 0;
3011 }
3012 DEFINE_SHOW_ATTRIBUTE(possible_parents);
3013
3014 static int clk_duty_cycle_show(struct seq_file *s, void *data)
3015 {
3016         struct clk_core *core = s->private;
3017         struct clk_duty *duty = &core->duty;
3018
3019         seq_printf(s, "%u/%u\n", duty->num, duty->den);
3020
3021         return 0;
3022 }
3023 DEFINE_SHOW_ATTRIBUTE(clk_duty_cycle);
3024
3025 static void clk_debug_create_one(struct clk_core *core, struct dentry *pdentry)
3026 {
3027         struct dentry *root;
3028
3029         if (!core || !pdentry)
3030                 return;
3031
3032         root = debugfs_create_dir(core->name, pdentry);
3033         core->dentry = root;
3034
3035         debugfs_create_ulong("clk_rate", 0444, root, &core->rate);
3036         debugfs_create_ulong("clk_accuracy", 0444, root, &core->accuracy);
3037         debugfs_create_u32("clk_phase", 0444, root, &core->phase);
3038         debugfs_create_file("clk_flags", 0444, root, core, &clk_flags_fops);
3039         debugfs_create_u32("clk_prepare_count", 0444, root, &core->prepare_count);
3040         debugfs_create_u32("clk_enable_count", 0444, root, &core->enable_count);
3041         debugfs_create_u32("clk_protect_count", 0444, root, &core->protect_count);
3042         debugfs_create_u32("clk_notifier_count", 0444, root, &core->notifier_count);
3043         debugfs_create_file("clk_duty_cycle", 0444, root, core,
3044                             &clk_duty_cycle_fops);
3045
3046         if (core->num_parents > 1)
3047                 debugfs_create_file("clk_possible_parents", 0444, root, core,
3048                                     &possible_parents_fops);
3049
3050         if (core->ops->debug_init)
3051                 core->ops->debug_init(core->hw, core->dentry);
3052 }
3053
3054 /**
3055  * clk_debug_register - add a clk node to the debugfs clk directory
3056  * @core: the clk being added to the debugfs clk directory
3057  *
3058  * Dynamically adds a clk to the debugfs clk directory if debugfs has been
3059  * initialized.  Otherwise it bails out early since the debugfs clk directory
3060  * will be created lazily by clk_debug_init as part of a late_initcall.
3061  */
3062 static void clk_debug_register(struct clk_core *core)
3063 {
3064         mutex_lock(&clk_debug_lock);
3065         hlist_add_head(&core->debug_node, &clk_debug_list);
3066         if (inited)
3067                 clk_debug_create_one(core, rootdir);
3068         mutex_unlock(&clk_debug_lock);
3069 }
3070
3071  /**
3072  * clk_debug_unregister - remove a clk node from the debugfs clk directory
3073  * @core: the clk being removed from the debugfs clk directory
3074  *
3075  * Dynamically removes a clk and all its child nodes from the
3076  * debugfs clk directory if clk->dentry points to debugfs created by
3077  * clk_debug_register in __clk_core_init.
3078  */
3079 static void clk_debug_unregister(struct clk_core *core)
3080 {
3081         mutex_lock(&clk_debug_lock);
3082         hlist_del_init(&core->debug_node);
3083         debugfs_remove_recursive(core->dentry);
3084         core->dentry = NULL;
3085         mutex_unlock(&clk_debug_lock);
3086 }
3087
3088 /**
3089  * clk_debug_init - lazily populate the debugfs clk directory
3090  *
3091  * clks are often initialized very early during boot before memory can be
3092  * dynamically allocated and well before debugfs is setup. This function
3093  * populates the debugfs clk directory once at boot-time when we know that
3094  * debugfs is setup. It should only be called once at boot-time, all other clks
3095  * added dynamically will be done so with clk_debug_register.
3096  */
3097 static int __init clk_debug_init(void)
3098 {
3099         struct clk_core *core;
3100
3101         rootdir = debugfs_create_dir("clk", NULL);
3102
3103         debugfs_create_file("clk_summary", 0444, rootdir, &all_lists,
3104                             &clk_summary_fops);
3105         debugfs_create_file("clk_dump", 0444, rootdir, &all_lists,
3106                             &clk_dump_fops);
3107         debugfs_create_file("clk_orphan_summary", 0444, rootdir, &orphan_list,
3108                             &clk_summary_fops);
3109         debugfs_create_file("clk_orphan_dump", 0444, rootdir, &orphan_list,
3110                             &clk_dump_fops);
3111
3112         mutex_lock(&clk_debug_lock);
3113         hlist_for_each_entry(core, &clk_debug_list, debug_node)
3114                 clk_debug_create_one(core, rootdir);
3115
3116         inited = 1;
3117         mutex_unlock(&clk_debug_lock);
3118
3119         return 0;
3120 }
3121 late_initcall(clk_debug_init);
3122 #else
3123 static inline void clk_debug_register(struct clk_core *core) { }
3124 static inline void clk_debug_reparent(struct clk_core *core,
3125                                       struct clk_core *new_parent)
3126 {
3127 }
3128 static inline void clk_debug_unregister(struct clk_core *core)
3129 {
3130 }
3131 #endif
3132
3133 /**
3134  * __clk_core_init - initialize the data structures in a struct clk_core
3135  * @core:       clk_core being initialized
3136  *
3137  * Initializes the lists in struct clk_core, queries the hardware for the
3138  * parent and rate and sets them both.
3139  */
3140 static int __clk_core_init(struct clk_core *core)
3141 {
3142         int ret;
3143         struct clk_core *orphan;
3144         struct hlist_node *tmp2;
3145         unsigned long rate;
3146
3147         if (!core)
3148                 return -EINVAL;
3149
3150         clk_prepare_lock();
3151
3152         ret = clk_pm_runtime_get(core);
3153         if (ret)
3154                 goto unlock;
3155
3156         /* check to see if a clock with this name is already registered */
3157         if (clk_core_lookup(core->name)) {
3158                 pr_debug("%s: clk %s already initialized\n",
3159                                 __func__, core->name);
3160                 ret = -EEXIST;
3161                 goto out;
3162         }
3163
3164         /* check that clk_ops are sane.  See Documentation/driver-api/clk.rst */
3165         if (core->ops->set_rate &&
3166             !((core->ops->round_rate || core->ops->determine_rate) &&
3167               core->ops->recalc_rate)) {
3168                 pr_err("%s: %s must implement .round_rate or .determine_rate in addition to .recalc_rate\n",
3169                        __func__, core->name);
3170                 ret = -EINVAL;
3171                 goto out;
3172         }
3173
3174         if (core->ops->set_parent && !core->ops->get_parent) {
3175                 pr_err("%s: %s must implement .get_parent & .set_parent\n",
3176                        __func__, core->name);
3177                 ret = -EINVAL;
3178                 goto out;
3179         }
3180
3181         if (core->num_parents > 1 && !core->ops->get_parent) {
3182                 pr_err("%s: %s must implement .get_parent as it has multi parents\n",
3183                        __func__, core->name);
3184                 ret = -EINVAL;
3185                 goto out;
3186         }
3187
3188         if (core->ops->set_rate_and_parent &&
3189                         !(core->ops->set_parent && core->ops->set_rate)) {
3190                 pr_err("%s: %s must implement .set_parent & .set_rate\n",
3191                                 __func__, core->name);
3192                 ret = -EINVAL;
3193                 goto out;
3194         }
3195
3196         core->parent = __clk_init_parent(core);
3197
3198         /*
3199          * Populate core->parent if parent has already been clk_core_init'd. If
3200          * parent has not yet been clk_core_init'd then place clk in the orphan
3201          * list.  If clk doesn't have any parents then place it in the root
3202          * clk list.
3203          *
3204          * Every time a new clk is clk_init'd then we walk the list of orphan
3205          * clocks and re-parent any that are children of the clock currently
3206          * being clk_init'd.
3207          */
3208         if (core->parent) {
3209                 hlist_add_head(&core->child_node,
3210                                 &core->parent->children);
3211                 core->orphan = core->parent->orphan;
3212         } else if (!core->num_parents) {
3213                 hlist_add_head(&core->child_node, &clk_root_list);
3214                 core->orphan = false;
3215         } else {
3216                 hlist_add_head(&core->child_node, &clk_orphan_list);
3217                 core->orphan = true;
3218         }
3219
3220         /*
3221          * optional platform-specific magic
3222          *
3223          * The .init callback is not used by any of the basic clock types, but
3224          * exists for weird hardware that must perform initialization magic.
3225          * Please consider other ways of solving initialization problems before
3226          * using this callback, as its use is discouraged.
3227          */
3228         if (core->ops->init)
3229                 core->ops->init(core->hw);
3230
3231         /*
3232          * Set clk's accuracy.  The preferred method is to use
3233          * .recalc_accuracy. For simple clocks and lazy developers the default
3234          * fallback is to use the parent's accuracy.  If a clock doesn't have a
3235          * parent (or is orphaned) then accuracy is set to zero (perfect
3236          * clock).
3237          */
3238         if (core->ops->recalc_accuracy)
3239                 core->accuracy = core->ops->recalc_accuracy(core->hw,
3240                                         __clk_get_accuracy(core->parent));
3241         else if (core->parent)
3242                 core->accuracy = core->parent->accuracy;
3243         else
3244                 core->accuracy = 0;
3245
3246         /*
3247          * Set clk's phase.
3248          * Since a phase is by definition relative to its parent, just
3249          * query the current clock phase, or just assume it's in phase.
3250          */
3251         if (core->ops->get_phase)
3252                 core->phase = core->ops->get_phase(core->hw);
3253         else
3254                 core->phase = 0;
3255
3256         /*
3257          * Set clk's duty cycle.
3258          */
3259         clk_core_update_duty_cycle_nolock(core);
3260
3261         /*
3262          * Set clk's rate.  The preferred method is to use .recalc_rate.  For
3263          * simple clocks and lazy developers the default fallback is to use the
3264          * parent's rate.  If a clock doesn't have a parent (or is orphaned)
3265          * then rate is set to zero.
3266          */
3267         if (core->ops->recalc_rate)
3268                 rate = core->ops->recalc_rate(core->hw,
3269                                 clk_core_get_rate_nolock(core->parent));
3270         else if (core->parent)
3271                 rate = core->parent->rate;
3272         else
3273                 rate = 0;
3274         core->rate = core->req_rate = rate;
3275
3276         /*
3277          * Enable CLK_IS_CRITICAL clocks so newly added critical clocks
3278          * don't get accidentally disabled when walking the orphan tree and
3279          * reparenting clocks
3280          */
3281         if (core->flags & CLK_IS_CRITICAL) {
3282                 unsigned long flags;
3283
3284                 clk_core_prepare(core);
3285
3286                 flags = clk_enable_lock();
3287                 clk_core_enable(core);
3288                 clk_enable_unlock(flags);
3289         }
3290
3291         /*
3292          * walk the list of orphan clocks and reparent any that newly finds a
3293          * parent.
3294          */
3295         hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) {
3296                 struct clk_core *parent = __clk_init_parent(orphan);
3297
3298                 /*
3299                  * We need to use __clk_set_parent_before() and _after() to
3300                  * to properly migrate any prepare/enable count of the orphan
3301                  * clock. This is important for CLK_IS_CRITICAL clocks, which
3302                  * are enabled during init but might not have a parent yet.
3303                  */
3304                 if (parent) {
3305                         /* update the clk tree topology */
3306                         __clk_set_parent_before(orphan, parent);
3307                         __clk_set_parent_after(orphan, parent, NULL);
3308                         __clk_recalc_accuracies(orphan);
3309                         __clk_recalc_rates(orphan, 0);
3310                 }
3311         }
3312
3313         kref_init(&core->ref);
3314 out:
3315         clk_pm_runtime_put(core);
3316 unlock:
3317         clk_prepare_unlock();
3318
3319         if (!ret)
3320                 clk_debug_register(core);
3321
3322         return ret;
3323 }
3324
3325 /**
3326  * clk_core_link_consumer - Add a clk consumer to the list of consumers in a clk_core
3327  * @core: clk to add consumer to
3328  * @clk: consumer to link to a clk
3329  */
3330 static void clk_core_link_consumer(struct clk_core *core, struct clk *clk)
3331 {
3332         clk_prepare_lock();
3333         hlist_add_head(&clk->clks_node, &core->clks);
3334         clk_prepare_unlock();
3335 }
3336
3337 /**
3338  * clk_core_unlink_consumer - Remove a clk consumer from the list of consumers in a clk_core
3339  * @clk: consumer to unlink
3340  */
3341 static void clk_core_unlink_consumer(struct clk *clk)
3342 {
3343         lockdep_assert_held(&prepare_lock);
3344         hlist_del(&clk->clks_node);
3345 }
3346
3347 /**
3348  * alloc_clk - Allocate a clk consumer, but leave it unlinked to the clk_core
3349  * @core: clk to allocate a consumer for
3350  * @dev_id: string describing device name
3351  * @con_id: connection ID string on device
3352  *
3353  * Returns: clk consumer left unlinked from the consumer list
3354  */
3355 static struct clk *alloc_clk(struct clk_core *core, const char *dev_id,
3356                              const char *con_id)
3357 {
3358         struct clk *clk;
3359
3360         clk = kzalloc(sizeof(*clk), GFP_KERNEL);
3361         if (!clk)
3362                 return ERR_PTR(-ENOMEM);
3363
3364         clk->core = core;
3365         clk->dev_id = dev_id;
3366         clk->con_id = kstrdup_const(con_id, GFP_KERNEL);
3367         clk->max_rate = ULONG_MAX;
3368
3369         return clk;
3370 }
3371
3372 /**
3373  * free_clk - Free a clk consumer
3374  * @clk: clk consumer to free
3375  *
3376  * Note, this assumes the clk has been unlinked from the clk_core consumer
3377  * list.
3378  */
3379 static void free_clk(struct clk *clk)
3380 {
3381         kfree_const(clk->con_id);
3382         kfree(clk);
3383 }
3384
3385 /**
3386  * clk_hw_create_clk: Allocate and link a clk consumer to a clk_core given
3387  * a clk_hw
3388  * @dev: clk consumer device
3389  * @hw: clk_hw associated with the clk being consumed
3390  * @dev_id: string describing device name
3391  * @con_id: connection ID string on device
3392  *
3393  * This is the main function used to create a clk pointer for use by clk
3394  * consumers. It connects a consumer to the clk_core and clk_hw structures
3395  * used by the framework and clk provider respectively.
3396  */
3397 struct clk *clk_hw_create_clk(struct device *dev, struct clk_hw *hw,
3398                               const char *dev_id, const char *con_id)
3399 {
3400         struct clk *clk;
3401         struct clk_core *core;
3402
3403         /* This is to allow this function to be chained to others */
3404         if (IS_ERR_OR_NULL(hw))
3405                 return ERR_CAST(hw);
3406
3407         core = hw->core;
3408         clk = alloc_clk(core, dev_id, con_id);
3409         if (IS_ERR(clk))
3410                 return clk;
3411         clk->dev = dev;
3412
3413         if (!try_module_get(core->owner)) {
3414                 free_clk(clk);
3415                 return ERR_PTR(-ENOENT);
3416         }
3417
3418         kref_get(&core->ref);
3419         clk_core_link_consumer(core, clk);
3420
3421         return clk;
3422 }
3423
3424 static int clk_cpy_name(const char **dst_p, const char *src, bool must_exist)
3425 {
3426         const char *dst;
3427
3428         if (!src) {
3429                 if (must_exist)
3430                         return -EINVAL;
3431                 return 0;
3432         }
3433
3434         *dst_p = dst = kstrdup_const(src, GFP_KERNEL);
3435         if (!dst)
3436                 return -ENOMEM;
3437
3438         return 0;
3439 }
3440
3441 static int clk_core_populate_parent_map(struct clk_core *core)
3442 {
3443         const struct clk_init_data *init = core->hw->init;
3444         u8 num_parents = init->num_parents;
3445         const char * const *parent_names = init->parent_names;
3446         const struct clk_hw **parent_hws = init->parent_hws;
3447         const struct clk_parent_data *parent_data = init->parent_data;
3448         int i, ret = 0;
3449         struct clk_parent_map *parents, *parent;
3450
3451         if (!num_parents)
3452                 return 0;
3453
3454         /*
3455          * Avoid unnecessary string look-ups of clk_core's possible parents by
3456          * having a cache of names/clk_hw pointers to clk_core pointers.
3457          */
3458         parents = kcalloc(num_parents, sizeof(*parents), GFP_KERNEL);
3459         core->parents = parents;
3460         if (!parents)
3461                 return -ENOMEM;
3462
3463         /* Copy everything over because it might be __initdata */
3464         for (i = 0, parent = parents; i < num_parents; i++, parent++) {
3465                 parent->index = -1;
3466                 if (parent_names) {
3467                         /* throw a WARN if any entries are NULL */
3468                         WARN(!parent_names[i],
3469                                 "%s: invalid NULL in %s's .parent_names\n",
3470                                 __func__, core->name);
3471                         ret = clk_cpy_name(&parent->name, parent_names[i],
3472                                            true);
3473                 } else if (parent_data) {
3474                         parent->hw = parent_data[i].hw;
3475                         parent->index = parent_data[i].index;
3476                         ret = clk_cpy_name(&parent->fw_name,
3477                                            parent_data[i].fw_name, false);
3478                         if (!ret)
3479                                 ret = clk_cpy_name(&parent->name,
3480                                                    parent_data[i].name,
3481                                                    false);
3482                 } else if (parent_hws) {
3483                         parent->hw = parent_hws[i];
3484                 } else {
3485                         ret = -EINVAL;
3486                         WARN(1, "Must specify parents if num_parents > 0\n");
3487                 }
3488
3489                 if (ret) {
3490                         do {
3491                                 kfree_const(parents[i].name);
3492                                 kfree_const(parents[i].fw_name);
3493                         } while (--i >= 0);