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