1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
4 * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
6 * Standard functionality for the common clock API. See Documentation/driver-api/clk.rst
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>
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>
27 static DEFINE_SPINLOCK(enable_lock
);
28 static DEFINE_MUTEX(prepare_lock
);
30 static struct task_struct
*prepare_owner
;
31 static struct task_struct
*enable_owner
;
33 static int prepare_refcnt
;
34 static int enable_refcnt
;
36 static HLIST_HEAD(clk_root_list
);
37 static HLIST_HEAD(clk_orphan_list
);
38 static LIST_HEAD(clk_notifier_list
);
40 /*** private data structures ***/
42 struct clk_parent_map
{
43 const struct clk_hw
*hw
;
44 struct clk_core
*core
;
52 const struct clk_ops
*ops
;
56 struct device_node
*of_node
;
57 struct clk_core
*parent
;
58 struct clk_parent_map
*parents
;
62 unsigned long req_rate
;
63 unsigned long new_rate
;
64 struct clk_core
*new_parent
;
65 struct clk_core
*new_child
;
69 unsigned int enable_count
;
70 unsigned int prepare_count
;
71 unsigned int protect_count
;
72 unsigned long min_rate
;
73 unsigned long max_rate
;
74 unsigned long accuracy
;
77 struct hlist_head children
;
78 struct hlist_node child_node
;
79 struct hlist_head clks
;
80 unsigned int notifier_count
;
81 #ifdef CONFIG_DEBUG_FS
82 struct dentry
*dentry
;
83 struct hlist_node debug_node
;
88 #define CREATE_TRACE_POINTS
89 #include <trace/events/clk.h>
92 struct clk_core
*core
;
96 unsigned long min_rate
;
97 unsigned long max_rate
;
98 unsigned int exclusive_count
;
99 struct hlist_node clks_node
;
103 static int clk_pm_runtime_get(struct clk_core
*core
)
107 if (!core
->rpm_enabled
)
110 ret
= pm_runtime_get_sync(core
->dev
);
111 return ret
< 0 ? ret
: 0;
114 static void clk_pm_runtime_put(struct clk_core
*core
)
116 if (!core
->rpm_enabled
)
119 pm_runtime_put_sync(core
->dev
);
123 static void clk_prepare_lock(void)
125 if (!mutex_trylock(&prepare_lock
)) {
126 if (prepare_owner
== current
) {
130 mutex_lock(&prepare_lock
);
132 WARN_ON_ONCE(prepare_owner
!= NULL
);
133 WARN_ON_ONCE(prepare_refcnt
!= 0);
134 prepare_owner
= current
;
138 static void clk_prepare_unlock(void)
140 WARN_ON_ONCE(prepare_owner
!= current
);
141 WARN_ON_ONCE(prepare_refcnt
== 0);
143 if (--prepare_refcnt
)
145 prepare_owner
= NULL
;
146 mutex_unlock(&prepare_lock
);
149 static unsigned long clk_enable_lock(void)
150 __acquires(enable_lock
)
155 * On UP systems, spin_trylock_irqsave() always returns true, even if
156 * we already hold the lock. So, in that case, we rely only on
157 * reference counting.
159 if (!IS_ENABLED(CONFIG_SMP
) ||
160 !spin_trylock_irqsave(&enable_lock
, flags
)) {
161 if (enable_owner
== current
) {
163 __acquire(enable_lock
);
164 if (!IS_ENABLED(CONFIG_SMP
))
165 local_save_flags(flags
);
168 spin_lock_irqsave(&enable_lock
, flags
);
170 WARN_ON_ONCE(enable_owner
!= NULL
);
171 WARN_ON_ONCE(enable_refcnt
!= 0);
172 enable_owner
= current
;
177 static void clk_enable_unlock(unsigned long flags
)
178 __releases(enable_lock
)
180 WARN_ON_ONCE(enable_owner
!= current
);
181 WARN_ON_ONCE(enable_refcnt
== 0);
183 if (--enable_refcnt
) {
184 __release(enable_lock
);
188 spin_unlock_irqrestore(&enable_lock
, flags
);
191 static bool clk_core_rate_is_protected(struct clk_core
*core
)
193 return core
->protect_count
;
196 static bool clk_core_is_prepared(struct clk_core
*core
)
201 * .is_prepared is optional for clocks that can prepare
202 * fall back to software usage counter if it is missing
204 if (!core
->ops
->is_prepared
)
205 return core
->prepare_count
;
207 if (!clk_pm_runtime_get(core
)) {
208 ret
= core
->ops
->is_prepared(core
->hw
);
209 clk_pm_runtime_put(core
);
215 static bool clk_core_is_enabled(struct clk_core
*core
)
220 * .is_enabled is only mandatory for clocks that gate
221 * fall back to software usage counter if .is_enabled is missing
223 if (!core
->ops
->is_enabled
)
224 return core
->enable_count
;
227 * Check if clock controller's device is runtime active before
228 * calling .is_enabled callback. If not, assume that clock is
229 * disabled, because we might be called from atomic context, from
230 * which pm_runtime_get() is not allowed.
231 * This function is called mainly from clk_disable_unused_subtree,
232 * which ensures proper runtime pm activation of controller before
233 * taking enable spinlock, but the below check is needed if one tries
234 * to call it from other places.
236 if (core
->rpm_enabled
) {
237 pm_runtime_get_noresume(core
->dev
);
238 if (!pm_runtime_active(core
->dev
)) {
244 ret
= core
->ops
->is_enabled(core
->hw
);
246 if (core
->rpm_enabled
)
247 pm_runtime_put(core
->dev
);
252 /*** helper functions ***/
254 const char *__clk_get_name(const struct clk
*clk
)
256 return !clk
? NULL
: clk
->core
->name
;
258 EXPORT_SYMBOL_GPL(__clk_get_name
);
260 const char *clk_hw_get_name(const struct clk_hw
*hw
)
262 return hw
->core
->name
;
264 EXPORT_SYMBOL_GPL(clk_hw_get_name
);
266 struct clk_hw
*__clk_get_hw(struct clk
*clk
)
268 return !clk
? NULL
: clk
->core
->hw
;
270 EXPORT_SYMBOL_GPL(__clk_get_hw
);
272 unsigned int clk_hw_get_num_parents(const struct clk_hw
*hw
)
274 return hw
->core
->num_parents
;
276 EXPORT_SYMBOL_GPL(clk_hw_get_num_parents
);
278 struct clk_hw
*clk_hw_get_parent(const struct clk_hw
*hw
)
280 return hw
->core
->parent
? hw
->core
->parent
->hw
: NULL
;
282 EXPORT_SYMBOL_GPL(clk_hw_get_parent
);
284 static struct clk_core
*__clk_lookup_subtree(const char *name
,
285 struct clk_core
*core
)
287 struct clk_core
*child
;
288 struct clk_core
*ret
;
290 if (!strcmp(core
->name
, name
))
293 hlist_for_each_entry(child
, &core
->children
, child_node
) {
294 ret
= __clk_lookup_subtree(name
, child
);
302 static struct clk_core
*clk_core_lookup(const char *name
)
304 struct clk_core
*root_clk
;
305 struct clk_core
*ret
;
310 /* search the 'proper' clk tree first */
311 hlist_for_each_entry(root_clk
, &clk_root_list
, child_node
) {
312 ret
= __clk_lookup_subtree(name
, root_clk
);
317 /* if not found, then search the orphan tree */
318 hlist_for_each_entry(root_clk
, &clk_orphan_list
, child_node
) {
319 ret
= __clk_lookup_subtree(name
, root_clk
);
328 static int of_parse_clkspec(const struct device_node
*np
, int index
,
329 const char *name
, struct of_phandle_args
*out_args
);
330 static struct clk_hw
*
331 of_clk_get_hw_from_clkspec(struct of_phandle_args
*clkspec
);
333 static inline int of_parse_clkspec(const struct device_node
*np
, int index
,
335 struct of_phandle_args
*out_args
)
339 static inline struct clk_hw
*
340 of_clk_get_hw_from_clkspec(struct of_phandle_args
*clkspec
)
342 return ERR_PTR(-ENOENT
);
347 * clk_core_get - Find the clk_core parent of a clk
348 * @core: clk to find parent of
349 * @p_index: parent index to search for
351 * This is the preferred method for clk providers to find the parent of a
352 * clk when that parent is external to the clk controller. The parent_names
353 * array is indexed and treated as a local name matching a string in the device
354 * node's 'clock-names' property or as the 'con_id' matching the device's
355 * dev_name() in a clk_lookup. This allows clk providers to use their own
356 * namespace instead of looking for a globally unique parent string.
358 * For example the following DT snippet would allow a clock registered by the
359 * clock-controller@c001 that has a clk_init_data::parent_data array
360 * with 'xtal' in the 'name' member to find the clock provided by the
361 * clock-controller@f00abcd without needing to get the globally unique name of
364 * parent: clock-controller@f00abcd {
365 * reg = <0xf00abcd 0xabcd>;
366 * #clock-cells = <0>;
369 * clock-controller@c001 {
370 * reg = <0xc001 0xf00d>;
371 * clocks = <&parent>;
372 * clock-names = "xtal";
373 * #clock-cells = <1>;
376 * Returns: -ENOENT when the provider can't be found or the clk doesn't
377 * exist in the provider or the name can't be found in the DT node or
378 * in a clkdev lookup. NULL when the provider knows about the clk but it
379 * isn't provided on this system.
380 * A valid clk_core pointer when the clk can be found in the provider.
382 static struct clk_core
*clk_core_get(struct clk_core
*core
, u8 p_index
)
384 const char *name
= core
->parents
[p_index
].fw_name
;
385 int index
= core
->parents
[p_index
].index
;
386 struct clk_hw
*hw
= ERR_PTR(-ENOENT
);
387 struct device
*dev
= core
->dev
;
388 const char *dev_id
= dev
? dev_name(dev
) : NULL
;
389 struct device_node
*np
= core
->of_node
;
390 struct of_phandle_args clkspec
;
392 if (np
&& (name
|| index
>= 0) &&
393 !of_parse_clkspec(np
, index
, name
, &clkspec
)) {
394 hw
= of_clk_get_hw_from_clkspec(&clkspec
);
395 of_node_put(clkspec
.np
);
398 * If the DT search above couldn't find the provider fallback to
399 * looking up via clkdev based clk_lookups.
401 hw
= clk_find_hw(dev_id
, name
);
410 static void clk_core_fill_parent_index(struct clk_core
*core
, u8 index
)
412 struct clk_parent_map
*entry
= &core
->parents
[index
];
413 struct clk_core
*parent
= ERR_PTR(-ENOENT
);
416 parent
= entry
->hw
->core
;
418 * We have a direct reference but it isn't registered yet?
419 * Orphan it and let clk_reparent() update the orphan status
420 * when the parent is registered.
423 parent
= ERR_PTR(-EPROBE_DEFER
);
425 parent
= clk_core_get(core
, index
);
426 if (IS_ERR(parent
) && PTR_ERR(parent
) == -ENOENT
&& entry
->name
)
427 parent
= clk_core_lookup(entry
->name
);
430 /* Only cache it if it's not an error */
432 entry
->core
= parent
;
435 static struct clk_core
*clk_core_get_parent_by_index(struct clk_core
*core
,
438 if (!core
|| index
>= core
->num_parents
|| !core
->parents
)
441 if (!core
->parents
[index
].core
)
442 clk_core_fill_parent_index(core
, index
);
444 return core
->parents
[index
].core
;
448 clk_hw_get_parent_by_index(const struct clk_hw
*hw
, unsigned int index
)
450 struct clk_core
*parent
;
452 parent
= clk_core_get_parent_by_index(hw
->core
, index
);
454 return !parent
? NULL
: parent
->hw
;
456 EXPORT_SYMBOL_GPL(clk_hw_get_parent_by_index
);
458 unsigned int __clk_get_enable_count(struct clk
*clk
)
460 return !clk
? 0 : clk
->core
->enable_count
;
463 static unsigned long clk_core_get_rate_nolock(struct clk_core
*core
)
468 if (!core
->num_parents
|| core
->parent
)
472 * Clk must have a parent because num_parents > 0 but the parent isn't
473 * known yet. Best to return 0 as the rate of this clk until we can
474 * properly recalc the rate based on the parent's rate.
479 unsigned long clk_hw_get_rate(const struct clk_hw
*hw
)
481 return clk_core_get_rate_nolock(hw
->core
);
483 EXPORT_SYMBOL_GPL(clk_hw_get_rate
);
485 static unsigned long __clk_get_accuracy(struct clk_core
*core
)
490 return core
->accuracy
;
493 unsigned long __clk_get_flags(struct clk
*clk
)
495 return !clk
? 0 : clk
->core
->flags
;
497 EXPORT_SYMBOL_GPL(__clk_get_flags
);
499 unsigned long clk_hw_get_flags(const struct clk_hw
*hw
)
501 return hw
->core
->flags
;
503 EXPORT_SYMBOL_GPL(clk_hw_get_flags
);
505 bool clk_hw_is_prepared(const struct clk_hw
*hw
)
507 return clk_core_is_prepared(hw
->core
);
509 EXPORT_SYMBOL_GPL(clk_hw_is_prepared
);
511 bool clk_hw_rate_is_protected(const struct clk_hw
*hw
)
513 return clk_core_rate_is_protected(hw
->core
);
515 EXPORT_SYMBOL_GPL(clk_hw_rate_is_protected
);
517 bool clk_hw_is_enabled(const struct clk_hw
*hw
)
519 return clk_core_is_enabled(hw
->core
);
521 EXPORT_SYMBOL_GPL(clk_hw_is_enabled
);
523 bool __clk_is_enabled(struct clk
*clk
)
528 return clk_core_is_enabled(clk
->core
);
530 EXPORT_SYMBOL_GPL(__clk_is_enabled
);
532 static bool mux_is_better_rate(unsigned long rate
, unsigned long now
,
533 unsigned long best
, unsigned long flags
)
535 if (flags
& CLK_MUX_ROUND_CLOSEST
)
536 return abs(now
- rate
) < abs(best
- rate
);
538 return now
<= rate
&& now
> best
;
541 int clk_mux_determine_rate_flags(struct clk_hw
*hw
,
542 struct clk_rate_request
*req
,
545 struct clk_core
*core
= hw
->core
, *parent
, *best_parent
= NULL
;
546 int i
, num_parents
, ret
;
547 unsigned long best
= 0;
548 struct clk_rate_request parent_req
= *req
;
550 /* if NO_REPARENT flag set, pass through to current parent */
551 if (core
->flags
& CLK_SET_RATE_NO_REPARENT
) {
552 parent
= core
->parent
;
553 if (core
->flags
& CLK_SET_RATE_PARENT
) {
554 ret
= __clk_determine_rate(parent
? parent
->hw
: NULL
,
559 best
= parent_req
.rate
;
561 best
= clk_core_get_rate_nolock(parent
);
563 best
= clk_core_get_rate_nolock(core
);
569 /* find the parent that can provide the fastest rate <= rate */
570 num_parents
= core
->num_parents
;
571 for (i
= 0; i
< num_parents
; i
++) {
572 parent
= clk_core_get_parent_by_index(core
, i
);
576 if (core
->flags
& CLK_SET_RATE_PARENT
) {
578 ret
= __clk_determine_rate(parent
->hw
, &parent_req
);
582 parent_req
.rate
= clk_core_get_rate_nolock(parent
);
585 if (mux_is_better_rate(req
->rate
, parent_req
.rate
,
587 best_parent
= parent
;
588 best
= parent_req
.rate
;
597 req
->best_parent_hw
= best_parent
->hw
;
598 req
->best_parent_rate
= best
;
603 EXPORT_SYMBOL_GPL(clk_mux_determine_rate_flags
);
605 struct clk
*__clk_lookup(const char *name
)
607 struct clk_core
*core
= clk_core_lookup(name
);
609 return !core
? NULL
: core
->hw
->clk
;
612 static void clk_core_get_boundaries(struct clk_core
*core
,
613 unsigned long *min_rate
,
614 unsigned long *max_rate
)
616 struct clk
*clk_user
;
618 *min_rate
= core
->min_rate
;
619 *max_rate
= core
->max_rate
;
621 hlist_for_each_entry(clk_user
, &core
->clks
, clks_node
)
622 *min_rate
= max(*min_rate
, clk_user
->min_rate
);
624 hlist_for_each_entry(clk_user
, &core
->clks
, clks_node
)
625 *max_rate
= min(*max_rate
, clk_user
->max_rate
);
628 void clk_hw_set_rate_range(struct clk_hw
*hw
, unsigned long min_rate
,
629 unsigned long max_rate
)
631 hw
->core
->min_rate
= min_rate
;
632 hw
->core
->max_rate
= max_rate
;
634 EXPORT_SYMBOL_GPL(clk_hw_set_rate_range
);
637 * __clk_mux_determine_rate - clk_ops::determine_rate implementation for a mux type clk
638 * @hw: mux type clk to determine rate on
639 * @req: rate request, also used to return preferred parent and frequencies
641 * Helper for finding best parent to provide a given frequency. This can be used
642 * directly as a determine_rate callback (e.g. for a mux), or from a more
643 * complex clock that may combine a mux with other operations.
645 * Returns: 0 on success, -EERROR value on error
647 int __clk_mux_determine_rate(struct clk_hw
*hw
,
648 struct clk_rate_request
*req
)
650 return clk_mux_determine_rate_flags(hw
, req
, 0);
652 EXPORT_SYMBOL_GPL(__clk_mux_determine_rate
);
654 int __clk_mux_determine_rate_closest(struct clk_hw
*hw
,
655 struct clk_rate_request
*req
)
657 return clk_mux_determine_rate_flags(hw
, req
, CLK_MUX_ROUND_CLOSEST
);
659 EXPORT_SYMBOL_GPL(__clk_mux_determine_rate_closest
);
663 static void clk_core_rate_unprotect(struct clk_core
*core
)
665 lockdep_assert_held(&prepare_lock
);
670 if (WARN(core
->protect_count
== 0,
671 "%s already unprotected\n", core
->name
))
674 if (--core
->protect_count
> 0)
677 clk_core_rate_unprotect(core
->parent
);
680 static int clk_core_rate_nuke_protect(struct clk_core
*core
)
684 lockdep_assert_held(&prepare_lock
);
689 if (core
->protect_count
== 0)
692 ret
= core
->protect_count
;
693 core
->protect_count
= 1;
694 clk_core_rate_unprotect(core
);
700 * clk_rate_exclusive_put - release exclusivity over clock rate control
701 * @clk: the clk over which the exclusivity is released
703 * clk_rate_exclusive_put() completes a critical section during which a clock
704 * consumer cannot tolerate any other consumer making any operation on the
705 * clock which could result in a rate change or rate glitch. Exclusive clocks
706 * cannot have their rate changed, either directly or indirectly due to changes
707 * further up the parent chain of clocks. As a result, clocks up parent chain
708 * also get under exclusive control of the calling consumer.
710 * If exlusivity is claimed more than once on clock, even by the same consumer,
711 * the rate effectively gets locked as exclusivity can't be preempted.
713 * Calls to clk_rate_exclusive_put() must be balanced with calls to
714 * clk_rate_exclusive_get(). Calls to this function may sleep, and do not return
717 void clk_rate_exclusive_put(struct clk
*clk
)
725 * if there is something wrong with this consumer protect count, stop
726 * here before messing with the provider
728 if (WARN_ON(clk
->exclusive_count
<= 0))
731 clk_core_rate_unprotect(clk
->core
);
732 clk
->exclusive_count
--;
734 clk_prepare_unlock();
736 EXPORT_SYMBOL_GPL(clk_rate_exclusive_put
);
738 static void clk_core_rate_protect(struct clk_core
*core
)
740 lockdep_assert_held(&prepare_lock
);
745 if (core
->protect_count
== 0)
746 clk_core_rate_protect(core
->parent
);
748 core
->protect_count
++;
751 static void clk_core_rate_restore_protect(struct clk_core
*core
, int count
)
753 lockdep_assert_held(&prepare_lock
);
761 clk_core_rate_protect(core
);
762 core
->protect_count
= count
;
766 * clk_rate_exclusive_get - get exclusivity over the clk rate control
767 * @clk: the clk over which the exclusity of rate control is requested
769 * clk_rate_exlusive_get() begins a critical section during which a clock
770 * consumer cannot tolerate any other consumer making any operation on the
771 * clock which could result in a rate change or rate glitch. Exclusive clocks
772 * cannot have their rate changed, either directly or indirectly due to changes
773 * further up the parent chain of clocks. As a result, clocks up parent chain
774 * also get under exclusive control of the calling consumer.
776 * If exlusivity is claimed more than once on clock, even by the same consumer,
777 * the rate effectively gets locked as exclusivity can't be preempted.
779 * Calls to clk_rate_exclusive_get() should be balanced with calls to
780 * clk_rate_exclusive_put(). Calls to this function may sleep.
781 * Returns 0 on success, -EERROR otherwise
783 int clk_rate_exclusive_get(struct clk
*clk
)
789 clk_core_rate_protect(clk
->core
);
790 clk
->exclusive_count
++;
791 clk_prepare_unlock();
795 EXPORT_SYMBOL_GPL(clk_rate_exclusive_get
);
797 static void clk_core_unprepare(struct clk_core
*core
)
799 lockdep_assert_held(&prepare_lock
);
804 if (WARN(core
->prepare_count
== 0,
805 "%s already unprepared\n", core
->name
))
808 if (WARN(core
->prepare_count
== 1 && core
->flags
& CLK_IS_CRITICAL
,
809 "Unpreparing critical %s\n", core
->name
))
812 if (core
->flags
& CLK_SET_RATE_GATE
)
813 clk_core_rate_unprotect(core
);
815 if (--core
->prepare_count
> 0)
818 WARN(core
->enable_count
> 0, "Unpreparing enabled %s\n", core
->name
);
820 trace_clk_unprepare(core
);
822 if (core
->ops
->unprepare
)
823 core
->ops
->unprepare(core
->hw
);
825 clk_pm_runtime_put(core
);
827 trace_clk_unprepare_complete(core
);
828 clk_core_unprepare(core
->parent
);
831 static void clk_core_unprepare_lock(struct clk_core
*core
)
834 clk_core_unprepare(core
);
835 clk_prepare_unlock();
839 * clk_unprepare - undo preparation of a clock source
840 * @clk: the clk being unprepared
842 * clk_unprepare may sleep, which differentiates it from clk_disable. In a
843 * simple case, clk_unprepare can be used instead of clk_disable to gate a clk
844 * if the operation may sleep. One example is a clk which is accessed over
845 * I2c. In the complex case a clk gate operation may require a fast and a slow
846 * part. It is this reason that clk_unprepare and clk_disable are not mutually
847 * exclusive. In fact clk_disable must be called before clk_unprepare.
849 void clk_unprepare(struct clk
*clk
)
851 if (IS_ERR_OR_NULL(clk
))
854 clk_core_unprepare_lock(clk
->core
);
856 EXPORT_SYMBOL_GPL(clk_unprepare
);
858 static int clk_core_prepare(struct clk_core
*core
)
862 lockdep_assert_held(&prepare_lock
);
867 if (core
->prepare_count
== 0) {
868 ret
= clk_pm_runtime_get(core
);
872 ret
= clk_core_prepare(core
->parent
);
876 trace_clk_prepare(core
);
878 if (core
->ops
->prepare
)
879 ret
= core
->ops
->prepare(core
->hw
);
881 trace_clk_prepare_complete(core
);
887 core
->prepare_count
++;
890 * CLK_SET_RATE_GATE is a special case of clock protection
891 * Instead of a consumer claiming exclusive rate control, it is
892 * actually the provider which prevents any consumer from making any
893 * operation which could result in a rate change or rate glitch while
894 * the clock is prepared.
896 if (core
->flags
& CLK_SET_RATE_GATE
)
897 clk_core_rate_protect(core
);
901 clk_core_unprepare(core
->parent
);
903 clk_pm_runtime_put(core
);
907 static int clk_core_prepare_lock(struct clk_core
*core
)
912 ret
= clk_core_prepare(core
);
913 clk_prepare_unlock();
919 * clk_prepare - prepare a clock source
920 * @clk: the clk being prepared
922 * clk_prepare may sleep, which differentiates it from clk_enable. In a simple
923 * case, clk_prepare can be used instead of clk_enable to ungate a clk if the
924 * operation may sleep. One example is a clk which is accessed over I2c. In
925 * the complex case a clk ungate operation may require a fast and a slow part.
926 * It is this reason that clk_prepare and clk_enable are not mutually
927 * exclusive. In fact clk_prepare must be called before clk_enable.
928 * Returns 0 on success, -EERROR otherwise.
930 int clk_prepare(struct clk
*clk
)
935 return clk_core_prepare_lock(clk
->core
);
937 EXPORT_SYMBOL_GPL(clk_prepare
);
939 static void clk_core_disable(struct clk_core
*core
)
941 lockdep_assert_held(&enable_lock
);
946 if (WARN(core
->enable_count
== 0, "%s already disabled\n", core
->name
))
949 if (WARN(core
->enable_count
== 1 && core
->flags
& CLK_IS_CRITICAL
,
950 "Disabling critical %s\n", core
->name
))
953 if (--core
->enable_count
> 0)
956 trace_clk_disable_rcuidle(core
);
958 if (core
->ops
->disable
)
959 core
->ops
->disable(core
->hw
);
961 trace_clk_disable_complete_rcuidle(core
);
963 clk_core_disable(core
->parent
);
966 static void clk_core_disable_lock(struct clk_core
*core
)
970 flags
= clk_enable_lock();
971 clk_core_disable(core
);
972 clk_enable_unlock(flags
);
976 * clk_disable - gate a clock
977 * @clk: the clk being gated
979 * clk_disable must not sleep, which differentiates it from clk_unprepare. In
980 * a simple case, clk_disable can be used instead of clk_unprepare to gate a
981 * clk if the operation is fast and will never sleep. One example is a
982 * SoC-internal clk which is controlled via simple register writes. In the
983 * complex case a clk gate operation may require a fast and a slow part. It is
984 * this reason that clk_unprepare and clk_disable are not mutually exclusive.
985 * In fact clk_disable must be called before clk_unprepare.
987 void clk_disable(struct clk
*clk
)
989 if (IS_ERR_OR_NULL(clk
))
992 clk_core_disable_lock(clk
->core
);
994 EXPORT_SYMBOL_GPL(clk_disable
);
996 static int clk_core_enable(struct clk_core
*core
)
1000 lockdep_assert_held(&enable_lock
);
1005 if (WARN(core
->prepare_count
== 0,
1006 "Enabling unprepared %s\n", core
->name
))
1009 if (core
->enable_count
== 0) {
1010 ret
= clk_core_enable(core
->parent
);
1015 trace_clk_enable_rcuidle(core
);
1017 if (core
->ops
->enable
)
1018 ret
= core
->ops
->enable(core
->hw
);
1020 trace_clk_enable_complete_rcuidle(core
);
1023 clk_core_disable(core
->parent
);
1028 core
->enable_count
++;
1032 static int clk_core_enable_lock(struct clk_core
*core
)
1034 unsigned long flags
;
1037 flags
= clk_enable_lock();
1038 ret
= clk_core_enable(core
);
1039 clk_enable_unlock(flags
);
1045 * clk_gate_restore_context - restore context for poweroff
1046 * @hw: the clk_hw pointer of clock whose state is to be restored
1048 * The clock gate restore context function enables or disables
1049 * the gate clocks based on the enable_count. This is done in cases
1050 * where the clock context is lost and based on the enable_count
1051 * the clock either needs to be enabled/disabled. This
1052 * helps restore the state of gate clocks.
1054 void clk_gate_restore_context(struct clk_hw
*hw
)
1056 struct clk_core
*core
= hw
->core
;
1058 if (core
->enable_count
)
1059 core
->ops
->enable(hw
);
1061 core
->ops
->disable(hw
);
1063 EXPORT_SYMBOL_GPL(clk_gate_restore_context
);
1065 static int clk_core_save_context(struct clk_core
*core
)
1067 struct clk_core
*child
;
1070 hlist_for_each_entry(child
, &core
->children
, child_node
) {
1071 ret
= clk_core_save_context(child
);
1076 if (core
->ops
&& core
->ops
->save_context
)
1077 ret
= core
->ops
->save_context(core
->hw
);
1082 static void clk_core_restore_context(struct clk_core
*core
)
1084 struct clk_core
*child
;
1086 if (core
->ops
&& core
->ops
->restore_context
)
1087 core
->ops
->restore_context(core
->hw
);
1089 hlist_for_each_entry(child
, &core
->children
, child_node
)
1090 clk_core_restore_context(child
);
1094 * clk_save_context - save clock context for poweroff
1096 * Saves the context of the clock register for powerstates in which the
1097 * contents of the registers will be lost. Occurs deep within the suspend
1098 * code. Returns 0 on success.
1100 int clk_save_context(void)
1102 struct clk_core
*clk
;
1105 hlist_for_each_entry(clk
, &clk_root_list
, child_node
) {
1106 ret
= clk_core_save_context(clk
);
1111 hlist_for_each_entry(clk
, &clk_orphan_list
, child_node
) {
1112 ret
= clk_core_save_context(clk
);
1119 EXPORT_SYMBOL_GPL(clk_save_context
);
1122 * clk_restore_context - restore clock context after poweroff
1124 * Restore the saved clock context upon resume.
1127 void clk_restore_context(void)
1129 struct clk_core
*core
;
1131 hlist_for_each_entry(core
, &clk_root_list
, child_node
)
1132 clk_core_restore_context(core
);
1134 hlist_for_each_entry(core
, &clk_orphan_list
, child_node
)
1135 clk_core_restore_context(core
);
1137 EXPORT_SYMBOL_GPL(clk_restore_context
);
1140 * clk_enable - ungate a clock
1141 * @clk: the clk being ungated
1143 * clk_enable must not sleep, which differentiates it from clk_prepare. In a
1144 * simple case, clk_enable can be used instead of clk_prepare to ungate a clk
1145 * if the operation will never sleep. One example is a SoC-internal clk which
1146 * is controlled via simple register writes. In the complex case a clk ungate
1147 * operation may require a fast and a slow part. It is this reason that
1148 * clk_enable and clk_prepare are not mutually exclusive. In fact clk_prepare
1149 * must be called before clk_enable. Returns 0 on success, -EERROR
1152 int clk_enable(struct clk
*clk
)
1157 return clk_core_enable_lock(clk
->core
);
1159 EXPORT_SYMBOL_GPL(clk_enable
);
1161 static int clk_core_prepare_enable(struct clk_core
*core
)
1165 ret
= clk_core_prepare_lock(core
);
1169 ret
= clk_core_enable_lock(core
);
1171 clk_core_unprepare_lock(core
);
1176 static void clk_core_disable_unprepare(struct clk_core
*core
)
1178 clk_core_disable_lock(core
);
1179 clk_core_unprepare_lock(core
);
1182 static void clk_unprepare_unused_subtree(struct clk_core
*core
)
1184 struct clk_core
*child
;
1186 lockdep_assert_held(&prepare_lock
);
1188 hlist_for_each_entry(child
, &core
->children
, child_node
)
1189 clk_unprepare_unused_subtree(child
);
1191 if (core
->prepare_count
)
1194 if (core
->flags
& CLK_IGNORE_UNUSED
)
1197 if (clk_pm_runtime_get(core
))
1200 if (clk_core_is_prepared(core
)) {
1201 trace_clk_unprepare(core
);
1202 if (core
->ops
->unprepare_unused
)
1203 core
->ops
->unprepare_unused(core
->hw
);
1204 else if (core
->ops
->unprepare
)
1205 core
->ops
->unprepare(core
->hw
);
1206 trace_clk_unprepare_complete(core
);
1209 clk_pm_runtime_put(core
);
1212 static void clk_disable_unused_subtree(struct clk_core
*core
)
1214 struct clk_core
*child
;
1215 unsigned long flags
;
1217 lockdep_assert_held(&prepare_lock
);
1219 hlist_for_each_entry(child
, &core
->children
, child_node
)
1220 clk_disable_unused_subtree(child
);
1222 if (core
->flags
& CLK_OPS_PARENT_ENABLE
)
1223 clk_core_prepare_enable(core
->parent
);
1225 if (clk_pm_runtime_get(core
))
1228 flags
= clk_enable_lock();
1230 if (core
->enable_count
)
1233 if (core
->flags
& CLK_IGNORE_UNUSED
)
1237 * some gate clocks have special needs during the disable-unused
1238 * sequence. call .disable_unused if available, otherwise fall
1241 if (clk_core_is_enabled(core
)) {
1242 trace_clk_disable(core
);
1243 if (core
->ops
->disable_unused
)
1244 core
->ops
->disable_unused(core
->hw
);
1245 else if (core
->ops
->disable
)
1246 core
->ops
->disable(core
->hw
);
1247 trace_clk_disable_complete(core
);
1251 clk_enable_unlock(flags
);
1252 clk_pm_runtime_put(core
);
1254 if (core
->flags
& CLK_OPS_PARENT_ENABLE
)
1255 clk_core_disable_unprepare(core
->parent
);
1258 static bool clk_ignore_unused
;
1259 static int __init
clk_ignore_unused_setup(char *__unused
)
1261 clk_ignore_unused
= true;
1264 __setup("clk_ignore_unused", clk_ignore_unused_setup
);
1266 static int clk_disable_unused(void)
1268 struct clk_core
*core
;
1270 if (clk_ignore_unused
) {
1271 pr_warn("clk: Not disabling unused clocks\n");
1277 hlist_for_each_entry(core
, &clk_root_list
, child_node
)
1278 clk_disable_unused_subtree(core
);
1280 hlist_for_each_entry(core
, &clk_orphan_list
, child_node
)
1281 clk_disable_unused_subtree(core
);
1283 hlist_for_each_entry(core
, &clk_root_list
, child_node
)
1284 clk_unprepare_unused_subtree(core
);
1286 hlist_for_each_entry(core
, &clk_orphan_list
, child_node
)
1287 clk_unprepare_unused_subtree(core
);
1289 clk_prepare_unlock();
1293 late_initcall_sync(clk_disable_unused
);
1295 static int clk_core_determine_round_nolock(struct clk_core
*core
,
1296 struct clk_rate_request
*req
)
1300 lockdep_assert_held(&prepare_lock
);
1306 * At this point, core protection will be disabled if
1307 * - if the provider is not protected at all
1308 * - if the calling consumer is the only one which has exclusivity
1311 if (clk_core_rate_is_protected(core
)) {
1312 req
->rate
= core
->rate
;
1313 } else if (core
->ops
->determine_rate
) {
1314 return core
->ops
->determine_rate(core
->hw
, req
);
1315 } else if (core
->ops
->round_rate
) {
1316 rate
= core
->ops
->round_rate(core
->hw
, req
->rate
,
1317 &req
->best_parent_rate
);
1329 static void clk_core_init_rate_req(struct clk_core
* const core
,
1330 struct clk_rate_request
*req
)
1332 struct clk_core
*parent
;
1334 if (WARN_ON(!core
|| !req
))
1337 parent
= core
->parent
;
1339 req
->best_parent_hw
= parent
->hw
;
1340 req
->best_parent_rate
= parent
->rate
;
1342 req
->best_parent_hw
= NULL
;
1343 req
->best_parent_rate
= 0;
1347 static bool clk_core_can_round(struct clk_core
* const core
)
1349 return core
->ops
->determine_rate
|| core
->ops
->round_rate
;
1352 static int clk_core_round_rate_nolock(struct clk_core
*core
,
1353 struct clk_rate_request
*req
)
1355 lockdep_assert_held(&prepare_lock
);
1362 clk_core_init_rate_req(core
, req
);
1364 if (clk_core_can_round(core
))
1365 return clk_core_determine_round_nolock(core
, req
);
1366 else if (core
->flags
& CLK_SET_RATE_PARENT
)
1367 return clk_core_round_rate_nolock(core
->parent
, req
);
1369 req
->rate
= core
->rate
;
1374 * __clk_determine_rate - get the closest rate actually supported by a clock
1375 * @hw: determine the rate of this clock
1376 * @req: target rate request
1378 * Useful for clk_ops such as .set_rate and .determine_rate.
1380 int __clk_determine_rate(struct clk_hw
*hw
, struct clk_rate_request
*req
)
1387 return clk_core_round_rate_nolock(hw
->core
, req
);
1389 EXPORT_SYMBOL_GPL(__clk_determine_rate
);
1391 unsigned long clk_hw_round_rate(struct clk_hw
*hw
, unsigned long rate
)
1394 struct clk_rate_request req
;
1396 clk_core_get_boundaries(hw
->core
, &req
.min_rate
, &req
.max_rate
);
1399 ret
= clk_core_round_rate_nolock(hw
->core
, &req
);
1405 EXPORT_SYMBOL_GPL(clk_hw_round_rate
);
1408 * clk_round_rate - round the given rate for a clk
1409 * @clk: the clk for which we are rounding a rate
1410 * @rate: the rate which is to be rounded
1412 * Takes in a rate as input and rounds it to a rate that the clk can actually
1413 * use which is then returned. If clk doesn't support round_rate operation
1414 * then the parent rate is returned.
1416 long clk_round_rate(struct clk
*clk
, unsigned long rate
)
1418 struct clk_rate_request req
;
1426 if (clk
->exclusive_count
)
1427 clk_core_rate_unprotect(clk
->core
);
1429 clk_core_get_boundaries(clk
->core
, &req
.min_rate
, &req
.max_rate
);
1432 ret
= clk_core_round_rate_nolock(clk
->core
, &req
);
1434 if (clk
->exclusive_count
)
1435 clk_core_rate_protect(clk
->core
);
1437 clk_prepare_unlock();
1444 EXPORT_SYMBOL_GPL(clk_round_rate
);
1447 * __clk_notify - call clk notifier chain
1448 * @core: clk that is changing rate
1449 * @msg: clk notifier type (see include/linux/clk.h)
1450 * @old_rate: old clk rate
1451 * @new_rate: new clk rate
1453 * Triggers a notifier call chain on the clk rate-change notification
1454 * for 'clk'. Passes a pointer to the struct clk and the previous
1455 * and current rates to the notifier callback. Intended to be called by
1456 * internal clock code only. Returns NOTIFY_DONE from the last driver
1457 * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
1458 * a driver returns that.
1460 static int __clk_notify(struct clk_core
*core
, unsigned long msg
,
1461 unsigned long old_rate
, unsigned long new_rate
)
1463 struct clk_notifier
*cn
;
1464 struct clk_notifier_data cnd
;
1465 int ret
= NOTIFY_DONE
;
1467 cnd
.old_rate
= old_rate
;
1468 cnd
.new_rate
= new_rate
;
1470 list_for_each_entry(cn
, &clk_notifier_list
, node
) {
1471 if (cn
->clk
->core
== core
) {
1473 ret
= srcu_notifier_call_chain(&cn
->notifier_head
, msg
,
1475 if (ret
& NOTIFY_STOP_MASK
)
1484 * __clk_recalc_accuracies
1485 * @core: first clk in the subtree
1487 * Walks the subtree of clks starting with clk and recalculates accuracies as
1488 * it goes. Note that if a clk does not implement the .recalc_accuracy
1489 * callback then it is assumed that the clock will take on the accuracy of its
1492 static void __clk_recalc_accuracies(struct clk_core
*core
)
1494 unsigned long parent_accuracy
= 0;
1495 struct clk_core
*child
;
1497 lockdep_assert_held(&prepare_lock
);
1500 parent_accuracy
= core
->parent
->accuracy
;
1502 if (core
->ops
->recalc_accuracy
)
1503 core
->accuracy
= core
->ops
->recalc_accuracy(core
->hw
,
1506 core
->accuracy
= parent_accuracy
;
1508 hlist_for_each_entry(child
, &core
->children
, child_node
)
1509 __clk_recalc_accuracies(child
);
1512 static long clk_core_get_accuracy(struct clk_core
*core
)
1514 unsigned long accuracy
;
1517 if (core
&& (core
->flags
& CLK_GET_ACCURACY_NOCACHE
))
1518 __clk_recalc_accuracies(core
);
1520 accuracy
= __clk_get_accuracy(core
);
1521 clk_prepare_unlock();
1527 * clk_get_accuracy - return the accuracy of clk
1528 * @clk: the clk whose accuracy is being returned
1530 * Simply returns the cached accuracy of the clk, unless
1531 * CLK_GET_ACCURACY_NOCACHE flag is set, which means a recalc_rate will be
1533 * If clk is NULL then returns 0.
1535 long clk_get_accuracy(struct clk
*clk
)
1540 return clk_core_get_accuracy(clk
->core
);
1542 EXPORT_SYMBOL_GPL(clk_get_accuracy
);
1544 static unsigned long clk_recalc(struct clk_core
*core
,
1545 unsigned long parent_rate
)
1547 unsigned long rate
= parent_rate
;
1549 if (core
->ops
->recalc_rate
&& !clk_pm_runtime_get(core
)) {
1550 rate
= core
->ops
->recalc_rate(core
->hw
, parent_rate
);
1551 clk_pm_runtime_put(core
);
1557 * __clk_recalc_rates
1558 * @core: first clk in the subtree
1559 * @msg: notification type (see include/linux/clk.h)
1561 * Walks the subtree of clks starting with clk and recalculates rates as it
1562 * goes. Note that if a clk does not implement the .recalc_rate callback then
1563 * it is assumed that the clock will take on the rate of its parent.
1565 * clk_recalc_rates also propagates the POST_RATE_CHANGE notification,
1568 static void __clk_recalc_rates(struct clk_core
*core
, unsigned long msg
)
1570 unsigned long old_rate
;
1571 unsigned long parent_rate
= 0;
1572 struct clk_core
*child
;
1574 lockdep_assert_held(&prepare_lock
);
1576 old_rate
= core
->rate
;
1579 parent_rate
= core
->parent
->rate
;
1581 core
->rate
= clk_recalc(core
, parent_rate
);
1584 * ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE
1585 * & ABORT_RATE_CHANGE notifiers
1587 if (core
->notifier_count
&& msg
)
1588 __clk_notify(core
, msg
, old_rate
, core
->rate
);
1590 hlist_for_each_entry(child
, &core
->children
, child_node
)
1591 __clk_recalc_rates(child
, msg
);
1594 static unsigned long clk_core_get_rate(struct clk_core
*core
)
1600 if (core
&& (core
->flags
& CLK_GET_RATE_NOCACHE
))
1601 __clk_recalc_rates(core
, 0);
1603 rate
= clk_core_get_rate_nolock(core
);
1604 clk_prepare_unlock();
1610 * clk_get_rate - return the rate of clk
1611 * @clk: the clk whose rate is being returned
1613 * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag
1614 * is set, which means a recalc_rate will be issued.
1615 * If clk is NULL then returns 0.
1617 unsigned long clk_get_rate(struct clk
*clk
)
1622 return clk_core_get_rate(clk
->core
);
1624 EXPORT_SYMBOL_GPL(clk_get_rate
);
1626 static int clk_fetch_parent_index(struct clk_core
*core
,
1627 struct clk_core
*parent
)
1634 for (i
= 0; i
< core
->num_parents
; i
++) {
1635 /* Found it first try! */
1636 if (core
->parents
[i
].core
== parent
)
1639 /* Something else is here, so keep looking */
1640 if (core
->parents
[i
].core
)
1643 /* Maybe core hasn't been cached but the hw is all we know? */
1644 if (core
->parents
[i
].hw
) {
1645 if (core
->parents
[i
].hw
== parent
->hw
)
1648 /* Didn't match, but we're expecting a clk_hw */
1652 /* Maybe it hasn't been cached (clk_set_parent() path) */
1653 if (parent
== clk_core_get(core
, i
))
1656 /* Fallback to comparing globally unique names */
1657 if (core
->parents
[i
].name
&&
1658 !strcmp(parent
->name
, core
->parents
[i
].name
))
1662 if (i
== core
->num_parents
)
1665 core
->parents
[i
].core
= parent
;
1670 * Update the orphan status of @core and all its children.
1672 static void clk_core_update_orphan_status(struct clk_core
*core
, bool is_orphan
)
1674 struct clk_core
*child
;
1676 core
->orphan
= is_orphan
;
1678 hlist_for_each_entry(child
, &core
->children
, child_node
)
1679 clk_core_update_orphan_status(child
, is_orphan
);
1682 static void clk_reparent(struct clk_core
*core
, struct clk_core
*new_parent
)
1684 bool was_orphan
= core
->orphan
;
1686 hlist_del(&core
->child_node
);
1689 bool becomes_orphan
= new_parent
->orphan
;
1691 /* avoid duplicate POST_RATE_CHANGE notifications */
1692 if (new_parent
->new_child
== core
)
1693 new_parent
->new_child
= NULL
;
1695 hlist_add_head(&core
->child_node
, &new_parent
->children
);
1697 if (was_orphan
!= becomes_orphan
)
1698 clk_core_update_orphan_status(core
, becomes_orphan
);
1700 hlist_add_head(&core
->child_node
, &clk_orphan_list
);
1702 clk_core_update_orphan_status(core
, true);
1705 core
->parent
= new_parent
;
1708 static struct clk_core
*__clk_set_parent_before(struct clk_core
*core
,
1709 struct clk_core
*parent
)
1711 unsigned long flags
;
1712 struct clk_core
*old_parent
= core
->parent
;
1715 * 1. enable parents for CLK_OPS_PARENT_ENABLE clock
1717 * 2. Migrate prepare state between parents and prevent race with
1720 * If the clock is not prepared, then a race with
1721 * clk_enable/disable() is impossible since we already have the
1722 * prepare lock (future calls to clk_enable() need to be preceded by
1725 * If the clock is prepared, migrate the prepared state to the new
1726 * parent and also protect against a race with clk_enable() by
1727 * forcing the clock and the new parent on. This ensures that all
1728 * future calls to clk_enable() are practically NOPs with respect to
1729 * hardware and software states.
1731 * See also: Comment for clk_set_parent() below.
1734 /* enable old_parent & parent if CLK_OPS_PARENT_ENABLE is set */
1735 if (core
->flags
& CLK_OPS_PARENT_ENABLE
) {
1736 clk_core_prepare_enable(old_parent
);
1737 clk_core_prepare_enable(parent
);
1740 /* migrate prepare count if > 0 */
1741 if (core
->prepare_count
) {
1742 clk_core_prepare_enable(parent
);
1743 clk_core_enable_lock(core
);
1746 /* update the clk tree topology */
1747 flags
= clk_enable_lock();
1748 clk_reparent(core
, parent
);
1749 clk_enable_unlock(flags
);
1754 static void __clk_set_parent_after(struct clk_core
*core
,
1755 struct clk_core
*parent
,
1756 struct clk_core
*old_parent
)
1759 * Finish the migration of prepare state and undo the changes done
1760 * for preventing a race with clk_enable().
1762 if (core
->prepare_count
) {
1763 clk_core_disable_lock(core
);
1764 clk_core_disable_unprepare(old_parent
);
1767 /* re-balance ref counting if CLK_OPS_PARENT_ENABLE is set */
1768 if (core
->flags
& CLK_OPS_PARENT_ENABLE
) {
1769 clk_core_disable_unprepare(parent
);
1770 clk_core_disable_unprepare(old_parent
);
1774 static int __clk_set_parent(struct clk_core
*core
, struct clk_core
*parent
,
1777 unsigned long flags
;
1779 struct clk_core
*old_parent
;
1781 old_parent
= __clk_set_parent_before(core
, parent
);
1783 trace_clk_set_parent(core
, parent
);
1785 /* change clock input source */
1786 if (parent
&& core
->ops
->set_parent
)
1787 ret
= core
->ops
->set_parent(core
->hw
, p_index
);
1789 trace_clk_set_parent_complete(core
, parent
);
1792 flags
= clk_enable_lock();
1793 clk_reparent(core
, old_parent
);
1794 clk_enable_unlock(flags
);
1795 __clk_set_parent_after(core
, old_parent
, parent
);
1800 __clk_set_parent_after(core
, parent
, old_parent
);
1806 * __clk_speculate_rates
1807 * @core: first clk in the subtree
1808 * @parent_rate: the "future" rate of clk's parent
1810 * Walks the subtree of clks starting with clk, speculating rates as it
1811 * goes and firing off PRE_RATE_CHANGE notifications as necessary.
1813 * Unlike clk_recalc_rates, clk_speculate_rates exists only for sending
1814 * pre-rate change notifications and returns early if no clks in the
1815 * subtree have subscribed to the notifications. Note that if a clk does not
1816 * implement the .recalc_rate callback then it is assumed that the clock will
1817 * take on the rate of its parent.
1819 static int __clk_speculate_rates(struct clk_core
*core
,
1820 unsigned long parent_rate
)
1822 struct clk_core
*child
;
1823 unsigned long new_rate
;
1824 int ret
= NOTIFY_DONE
;
1826 lockdep_assert_held(&prepare_lock
);
1828 new_rate
= clk_recalc(core
, parent_rate
);
1830 /* abort rate change if a driver returns NOTIFY_BAD or NOTIFY_STOP */
1831 if (core
->notifier_count
)
1832 ret
= __clk_notify(core
, PRE_RATE_CHANGE
, core
->rate
, new_rate
);
1834 if (ret
& NOTIFY_STOP_MASK
) {
1835 pr_debug("%s: clk notifier callback for clock %s aborted with error %d\n",
1836 __func__
, core
->name
, ret
);
1840 hlist_for_each_entry(child
, &core
->children
, child_node
) {
1841 ret
= __clk_speculate_rates(child
, new_rate
);
1842 if (ret
& NOTIFY_STOP_MASK
)
1850 static void clk_calc_subtree(struct clk_core
*core
, unsigned long new_rate
,
1851 struct clk_core
*new_parent
, u8 p_index
)
1853 struct clk_core
*child
;
1855 core
->new_rate
= new_rate
;
1856 core
->new_parent
= new_parent
;
1857 core
->new_parent_index
= p_index
;
1858 /* include clk in new parent's PRE_RATE_CHANGE notifications */
1859 core
->new_child
= NULL
;
1860 if (new_parent
&& new_parent
!= core
->parent
)
1861 new_parent
->new_child
= core
;
1863 hlist_for_each_entry(child
, &core
->children
, child_node
) {
1864 child
->new_rate
= clk_recalc(child
, new_rate
);
1865 clk_calc_subtree(child
, child
->new_rate
, NULL
, 0);
1870 * calculate the new rates returning the topmost clock that has to be
1873 static struct clk_core
*clk_calc_new_rates(struct clk_core
*core
,
1876 struct clk_core
*top
= core
;
1877 struct clk_core
*old_parent
, *parent
;
1878 unsigned long best_parent_rate
= 0;
1879 unsigned long new_rate
;
1880 unsigned long min_rate
;
1881 unsigned long max_rate
;
1886 if (IS_ERR_OR_NULL(core
))
1889 /* save parent rate, if it exists */
1890 parent
= old_parent
= core
->parent
;
1892 best_parent_rate
= parent
->rate
;
1894 clk_core_get_boundaries(core
, &min_rate
, &max_rate
);
1896 /* find the closest rate and parent clk/rate */
1897 if (clk_core_can_round(core
)) {
1898 struct clk_rate_request req
;
1901 req
.min_rate
= min_rate
;
1902 req
.max_rate
= max_rate
;
1904 clk_core_init_rate_req(core
, &req
);
1906 ret
= clk_core_determine_round_nolock(core
, &req
);
1910 best_parent_rate
= req
.best_parent_rate
;
1911 new_rate
= req
.rate
;
1912 parent
= req
.best_parent_hw
? req
.best_parent_hw
->core
: NULL
;
1914 if (new_rate
< min_rate
|| new_rate
> max_rate
)
1916 } else if (!parent
|| !(core
->flags
& CLK_SET_RATE_PARENT
)) {
1917 /* pass-through clock without adjustable parent */
1918 core
->new_rate
= core
->rate
;
1921 /* pass-through clock with adjustable parent */
1922 top
= clk_calc_new_rates(parent
, rate
);
1923 new_rate
= parent
->new_rate
;
1927 /* some clocks must be gated to change parent */
1928 if (parent
!= old_parent
&&
1929 (core
->flags
& CLK_SET_PARENT_GATE
) && core
->prepare_count
) {
1930 pr_debug("%s: %s not gated but wants to reparent\n",
1931 __func__
, core
->name
);
1935 /* try finding the new parent index */
1936 if (parent
&& core
->num_parents
> 1) {
1937 p_index
= clk_fetch_parent_index(core
, parent
);
1939 pr_debug("%s: clk %s can not be parent of clk %s\n",
1940 __func__
, parent
->name
, core
->name
);
1945 if ((core
->flags
& CLK_SET_RATE_PARENT
) && parent
&&
1946 best_parent_rate
!= parent
->rate
)
1947 top
= clk_calc_new_rates(parent
, best_parent_rate
);
1950 clk_calc_subtree(core
, new_rate
, parent
, p_index
);
1956 * Notify about rate changes in a subtree. Always walk down the whole tree
1957 * so that in case of an error we can walk down the whole tree again and
1960 static struct clk_core
*clk_propagate_rate_change(struct clk_core
*core
,
1961 unsigned long event
)
1963 struct clk_core
*child
, *tmp_clk
, *fail_clk
= NULL
;
1964 int ret
= NOTIFY_DONE
;
1966 if (core
->rate
== core
->new_rate
)
1969 if (core
->notifier_count
) {
1970 ret
= __clk_notify(core
, event
, core
->rate
, core
->new_rate
);
1971 if (ret
& NOTIFY_STOP_MASK
)
1975 hlist_for_each_entry(child
, &core
->children
, child_node
) {
1976 /* Skip children who will be reparented to another clock */
1977 if (child
->new_parent
&& child
->new_parent
!= core
)
1979 tmp_clk
= clk_propagate_rate_change(child
, event
);
1984 /* handle the new child who might not be in core->children yet */
1985 if (core
->new_child
) {
1986 tmp_clk
= clk_propagate_rate_change(core
->new_child
, event
);
1995 * walk down a subtree and set the new rates notifying the rate
1998 static void clk_change_rate(struct clk_core
*core
)
2000 struct clk_core
*child
;
2001 struct hlist_node
*tmp
;
2002 unsigned long old_rate
;
2003 unsigned long best_parent_rate
= 0;
2004 bool skip_set_rate
= false;
2005 struct clk_core
*old_parent
;
2006 struct clk_core
*parent
= NULL
;
2008 old_rate
= core
->rate
;
2010 if (core
->new_parent
) {
2011 parent
= core
->new_parent
;
2012 best_parent_rate
= core
->new_parent
->rate
;
2013 } else if (core
->parent
) {
2014 parent
= core
->parent
;
2015 best_parent_rate
= core
->parent
->rate
;
2018 if (clk_pm_runtime_get(core
))
2021 if (core
->flags
& CLK_SET_RATE_UNGATE
) {
2022 unsigned long flags
;
2024 clk_core_prepare(core
);
2025 flags
= clk_enable_lock();
2026 clk_core_enable(core
);
2027 clk_enable_unlock(flags
);
2030 if (core
->new_parent
&& core
->new_parent
!= core
->parent
) {
2031 old_parent
= __clk_set_parent_before(core
, core
->new_parent
);
2032 trace_clk_set_parent(core
, core
->new_parent
);
2034 if (core
->ops
->set_rate_and_parent
) {
2035 skip_set_rate
= true;
2036 core
->ops
->set_rate_and_parent(core
->hw
, core
->new_rate
,
2038 core
->new_parent_index
);
2039 } else if (core
->ops
->set_parent
) {
2040 core
->ops
->set_parent(core
->hw
, core
->new_parent_index
);
2043 trace_clk_set_parent_complete(core
, core
->new_parent
);
2044 __clk_set_parent_after(core
, core
->new_parent
, old_parent
);
2047 if (core
->flags
& CLK_OPS_PARENT_ENABLE
)
2048 clk_core_prepare_enable(parent
);
2050 trace_clk_set_rate(core
, core
->new_rate
);
2052 if (!skip_set_rate
&& core
->ops
->set_rate
)
2053 core
->ops
->set_rate(core
->hw
, core
->new_rate
, best_parent_rate
);
2055 trace_clk_set_rate_complete(core
, core
->new_rate
);
2057 core
->rate
= clk_recalc(core
, best_parent_rate
);
2059 if (core
->flags
& CLK_SET_RATE_UNGATE
) {
2060 unsigned long flags
;
2062 flags
= clk_enable_lock();
2063 clk_core_disable(core
);
2064 clk_enable_unlock(flags
);
2065 clk_core_unprepare(core
);
2068 if (core
->flags
& CLK_OPS_PARENT_ENABLE
)
2069 clk_core_disable_unprepare(parent
);
2071 if (core
->notifier_count
&& old_rate
!= core
->rate
)
2072 __clk_notify(core
, POST_RATE_CHANGE
, old_rate
, core
->rate
);
2074 if (core
->flags
& CLK_RECALC_NEW_RATES
)
2075 (void)clk_calc_new_rates(core
, core
->new_rate
);
2078 * Use safe iteration, as change_rate can actually swap parents
2079 * for certain clock types.
2081 hlist_for_each_entry_safe(child
, tmp
, &core
->children
, child_node
) {
2082 /* Skip children who will be reparented to another clock */
2083 if (child
->new_parent
&& child
->new_parent
!= core
)
2085 clk_change_rate(child
);
2088 /* handle the new child who might not be in core->children yet */
2089 if (core
->new_child
)
2090 clk_change_rate(core
->new_child
);
2092 clk_pm_runtime_put(core
);
2095 static unsigned long clk_core_req_round_rate_nolock(struct clk_core
*core
,
2096 unsigned long req_rate
)
2099 struct clk_rate_request req
;
2101 lockdep_assert_held(&prepare_lock
);
2106 /* simulate what the rate would be if it could be freely set */
2107 cnt
= clk_core_rate_nuke_protect(core
);
2111 clk_core_get_boundaries(core
, &req
.min_rate
, &req
.max_rate
);
2112 req
.rate
= req_rate
;
2114 ret
= clk_core_round_rate_nolock(core
, &req
);
2116 /* restore the protection */
2117 clk_core_rate_restore_protect(core
, cnt
);
2119 return ret
? 0 : req
.rate
;
2122 static int clk_core_set_rate_nolock(struct clk_core
*core
,
2123 unsigned long req_rate
)
2125 struct clk_core
*top
, *fail_clk
;
2132 rate
= clk_core_req_round_rate_nolock(core
, req_rate
);
2134 /* bail early if nothing to do */
2135 if (rate
== clk_core_get_rate_nolock(core
))
2138 /* fail on a direct rate set of a protected provider */
2139 if (clk_core_rate_is_protected(core
))
2142 /* calculate new rates and get the topmost changed clock */
2143 top
= clk_calc_new_rates(core
, req_rate
);
2147 ret
= clk_pm_runtime_get(core
);
2151 /* notify that we are about to change rates */
2152 fail_clk
= clk_propagate_rate_change(top
, PRE_RATE_CHANGE
);
2154 pr_debug("%s: failed to set %s rate\n", __func__
,
2156 clk_propagate_rate_change(top
, ABORT_RATE_CHANGE
);
2161 /* change the rates */
2162 clk_change_rate(top
);
2164 core
->req_rate
= req_rate
;
2166 clk_pm_runtime_put(core
);
2172 * clk_set_rate - specify a new rate for clk
2173 * @clk: the clk whose rate is being changed
2174 * @rate: the new rate for clk
2176 * In the simplest case clk_set_rate will only adjust the rate of clk.
2178 * Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to
2179 * propagate up to clk's parent; whether or not this happens depends on the
2180 * outcome of clk's .round_rate implementation. If *parent_rate is unchanged
2181 * after calling .round_rate then upstream parent propagation is ignored. If
2182 * *parent_rate comes back with a new rate for clk's parent then we propagate
2183 * up to clk's parent and set its rate. Upward propagation will continue
2184 * until either a clk does not support the CLK_SET_RATE_PARENT flag or
2185 * .round_rate stops requesting changes to clk's parent_rate.
2187 * Rate changes are accomplished via tree traversal that also recalculates the
2188 * rates for the clocks and fires off POST_RATE_CHANGE notifiers.
2190 * Returns 0 on success, -EERROR otherwise.
2192 int clk_set_rate(struct clk
*clk
, unsigned long rate
)
2199 /* prevent racing with updates to the clock topology */
2202 if (clk
->exclusive_count
)
2203 clk_core_rate_unprotect(clk
->core
);
2205 ret
= clk_core_set_rate_nolock(clk
->core
, rate
);
2207 if (clk
->exclusive_count
)
2208 clk_core_rate_protect(clk
->core
);
2210 clk_prepare_unlock();
2214 EXPORT_SYMBOL_GPL(clk_set_rate
);
2217 * clk_set_rate_exclusive - specify a new rate and get exclusive control
2218 * @clk: the clk whose rate is being changed
2219 * @rate: the new rate for clk
2221 * This is a combination of clk_set_rate() and clk_rate_exclusive_get()
2222 * within a critical section
2224 * This can be used initially to ensure that at least 1 consumer is
2225 * satisfied when several consumers are competing for exclusivity over the
2226 * same clock provider.
2228 * The exclusivity is not applied if setting the rate failed.
2230 * Calls to clk_rate_exclusive_get() should be balanced with calls to
2231 * clk_rate_exclusive_put().
2233 * Returns 0 on success, -EERROR otherwise.
2235 int clk_set_rate_exclusive(struct clk
*clk
, unsigned long rate
)
2242 /* prevent racing with updates to the clock topology */
2246 * The temporary protection removal is not here, on purpose
2247 * This function is meant to be used instead of clk_rate_protect,
2248 * so before the consumer code path protect the clock provider
2251 ret
= clk_core_set_rate_nolock(clk
->core
, rate
);
2253 clk_core_rate_protect(clk
->core
);
2254 clk
->exclusive_count
++;
2257 clk_prepare_unlock();
2261 EXPORT_SYMBOL_GPL(clk_set_rate_exclusive
);
2264 * clk_set_rate_range - set a rate range for a clock source
2265 * @clk: clock source
2266 * @min: desired minimum clock rate in Hz, inclusive
2267 * @max: desired maximum clock rate in Hz, inclusive
2269 * Returns success (0) or negative errno.
2271 int clk_set_rate_range(struct clk
*clk
, unsigned long min
, unsigned long max
)
2274 unsigned long old_min
, old_max
, rate
;
2280 pr_err("%s: clk %s dev %s con %s: invalid range [%lu, %lu]\n",
2281 __func__
, clk
->core
->name
, clk
->dev_id
, clk
->con_id
,
2288 if (clk
->exclusive_count
)
2289 clk_core_rate_unprotect(clk
->core
);
2291 /* Save the current values in case we need to rollback the change */
2292 old_min
= clk
->min_rate
;
2293 old_max
= clk
->max_rate
;
2294 clk
->min_rate
= min
;
2295 clk
->max_rate
= max
;
2297 rate
= clk_core_get_rate_nolock(clk
->core
);
2298 if (rate
< min
|| rate
> max
) {
2301 * We are in bit of trouble here, current rate is outside the
2302 * the requested range. We are going try to request appropriate
2303 * range boundary but there is a catch. It may fail for the
2304 * usual reason (clock broken, clock protected, etc) but also
2306 * - round_rate() was not favorable and fell on the wrong
2307 * side of the boundary
2308 * - the determine_rate() callback does not really check for
2309 * this corner case when determining the rate
2317 ret
= clk_core_set_rate_nolock(clk
->core
, rate
);
2319 /* rollback the changes */
2320 clk
->min_rate
= old_min
;
2321 clk
->max_rate
= old_max
;
2325 if (clk
->exclusive_count
)
2326 clk_core_rate_protect(clk
->core
);
2328 clk_prepare_unlock();
2332 EXPORT_SYMBOL_GPL(clk_set_rate_range
);
2335 * clk_set_min_rate - set a minimum clock rate for a clock source
2336 * @clk: clock source
2337 * @rate: desired minimum clock rate in Hz, inclusive
2339 * Returns success (0) or negative errno.
2341 int clk_set_min_rate(struct clk
*clk
, unsigned long rate
)
2346 return clk_set_rate_range(clk
, rate
, clk
->max_rate
);
2348 EXPORT_SYMBOL_GPL(clk_set_min_rate
);
2351 * clk_set_max_rate - set a maximum clock rate for a clock source
2352 * @clk: clock source
2353 * @rate: desired maximum clock rate in Hz, inclusive
2355 * Returns success (0) or negative errno.
2357 int clk_set_max_rate(struct clk
*clk
, unsigned long rate
)
2362 return clk_set_rate_range(clk
, clk
->min_rate
, rate
);
2364 EXPORT_SYMBOL_GPL(clk_set_max_rate
);
2367 * clk_get_parent - return the parent of a clk
2368 * @clk: the clk whose parent gets returned
2370 * Simply returns clk->parent. Returns NULL if clk is NULL.
2372 struct clk
*clk_get_parent(struct clk
*clk
)
2380 /* TODO: Create a per-user clk and change callers to call clk_put */
2381 parent
= !clk
->core
->parent
? NULL
: clk
->core
->parent
->hw
->clk
;
2382 clk_prepare_unlock();
2386 EXPORT_SYMBOL_GPL(clk_get_parent
);
2388 static struct clk_core
*__clk_init_parent(struct clk_core
*core
)
2392 if (core
->num_parents
> 1 && core
->ops
->get_parent
)
2393 index
= core
->ops
->get_parent(core
->hw
);
2395 return clk_core_get_parent_by_index(core
, index
);
2398 static void clk_core_reparent(struct clk_core
*core
,
2399 struct clk_core
*new_parent
)
2401 clk_reparent(core
, new_parent
);
2402 __clk_recalc_accuracies(core
);
2403 __clk_recalc_rates(core
, POST_RATE_CHANGE
);
2406 void clk_hw_reparent(struct clk_hw
*hw
, struct clk_hw
*new_parent
)
2411 clk_core_reparent(hw
->core
, !new_parent
? NULL
: new_parent
->core
);
2415 * clk_has_parent - check if a clock is a possible parent for another
2416 * @clk: clock source
2417 * @parent: parent clock source
2419 * This function can be used in drivers that need to check that a clock can be
2420 * the parent of another without actually changing the parent.
2422 * Returns true if @parent is a possible parent for @clk, false otherwise.
2424 bool clk_has_parent(struct clk
*clk
, struct clk
*parent
)
2426 struct clk_core
*core
, *parent_core
;
2429 /* NULL clocks should be nops, so return success if either is NULL. */
2430 if (!clk
|| !parent
)
2434 parent_core
= parent
->core
;
2436 /* Optimize for the case where the parent is already the parent. */
2437 if (core
->parent
== parent_core
)
2440 for (i
= 0; i
< core
->num_parents
; i
++)
2441 if (!strcmp(core
->parents
[i
].name
, parent_core
->name
))
2446 EXPORT_SYMBOL_GPL(clk_has_parent
);
2448 static int clk_core_set_parent_nolock(struct clk_core
*core
,
2449 struct clk_core
*parent
)
2453 unsigned long p_rate
= 0;
2455 lockdep_assert_held(&prepare_lock
);
2460 if (core
->parent
== parent
)
2463 /* verify ops for for multi-parent clks */
2464 if (core
->num_parents
> 1 && !core
->ops
->set_parent
)
2467 /* check that we are allowed to re-parent if the clock is in use */
2468 if ((core
->flags
& CLK_SET_PARENT_GATE
) && core
->prepare_count
)
2471 if (clk_core_rate_is_protected(core
))
2474 /* try finding the new parent index */
2476 p_index
= clk_fetch_parent_index(core
, parent
);
2478 pr_debug("%s: clk %s can not be parent of clk %s\n",
2479 __func__
, parent
->name
, core
->name
);
2482 p_rate
= parent
->rate
;
2485 ret
= clk_pm_runtime_get(core
);
2489 /* propagate PRE_RATE_CHANGE notifications */
2490 ret
= __clk_speculate_rates(core
, p_rate
);
2492 /* abort if a driver objects */
2493 if (ret
& NOTIFY_STOP_MASK
)
2496 /* do the re-parent */
2497 ret
= __clk_set_parent(core
, parent
, p_index
);
2499 /* propagate rate an accuracy recalculation accordingly */
2501 __clk_recalc_rates(core
, ABORT_RATE_CHANGE
);
2503 __clk_recalc_rates(core
, POST_RATE_CHANGE
);
2504 __clk_recalc_accuracies(core
);
2508 clk_pm_runtime_put(core
);
2514 * clk_set_parent - switch the parent of a mux clk
2515 * @clk: the mux clk whose input we are switching
2516 * @parent: the new input to clk
2518 * Re-parent clk to use parent as its new input source. If clk is in
2519 * prepared state, the clk will get enabled for the duration of this call. If
2520 * that's not acceptable for a specific clk (Eg: the consumer can't handle
2521 * that, the reparenting is glitchy in hardware, etc), use the
2522 * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared.
2524 * After successfully changing clk's parent clk_set_parent will update the
2525 * clk topology, sysfs topology and propagate rate recalculation via
2526 * __clk_recalc_rates.
2528 * Returns 0 on success, -EERROR otherwise.
2530 int clk_set_parent(struct clk
*clk
, struct clk
*parent
)
2539 if (clk
->exclusive_count
)
2540 clk_core_rate_unprotect(clk
->core
);
2542 ret
= clk_core_set_parent_nolock(clk
->core
,
2543 parent
? parent
->core
: NULL
);
2545 if (clk
->exclusive_count
)
2546 clk_core_rate_protect(clk
->core
);
2548 clk_prepare_unlock();
2552 EXPORT_SYMBOL_GPL(clk_set_parent
);
2554 static int clk_core_set_phase_nolock(struct clk_core
*core
, int degrees
)
2558 lockdep_assert_held(&prepare_lock
);
2563 if (clk_core_rate_is_protected(core
))
2566 trace_clk_set_phase(core
, degrees
);
2568 if (core
->ops
->set_phase
) {
2569 ret
= core
->ops
->set_phase(core
->hw
, degrees
);
2571 core
->phase
= degrees
;
2574 trace_clk_set_phase_complete(core
, degrees
);
2580 * clk_set_phase - adjust the phase shift of a clock signal
2581 * @clk: clock signal source
2582 * @degrees: number of degrees the signal is shifted
2584 * Shifts the phase of a clock signal by the specified
2585 * degrees. Returns 0 on success, -EERROR otherwise.
2587 * This function makes no distinction about the input or reference
2588 * signal that we adjust the clock signal phase against. For example
2589 * phase locked-loop clock signal generators we may shift phase with
2590 * respect to feedback clock signal input, but for other cases the
2591 * clock phase may be shifted with respect to some other, unspecified
2594 * Additionally the concept of phase shift does not propagate through
2595 * the clock tree hierarchy, which sets it apart from clock rates and
2596 * clock accuracy. A parent clock phase attribute does not have an
2597 * impact on the phase attribute of a child clock.
2599 int clk_set_phase(struct clk
*clk
, int degrees
)
2606 /* sanity check degrees */
2613 if (clk
->exclusive_count
)
2614 clk_core_rate_unprotect(clk
->core
);
2616 ret
= clk_core_set_phase_nolock(clk
->core
, degrees
);
2618 if (clk
->exclusive_count
)
2619 clk_core_rate_protect(clk
->core
);
2621 clk_prepare_unlock();
2625 EXPORT_SYMBOL_GPL(clk_set_phase
);
2627 static int clk_core_get_phase(struct clk_core
*core
)
2632 /* Always try to update cached phase if possible */
2633 if (core
->ops
->get_phase
)
2634 core
->phase
= core
->ops
->get_phase(core
->hw
);
2636 clk_prepare_unlock();
2642 * clk_get_phase - return the phase shift of a clock signal
2643 * @clk: clock signal source
2645 * Returns the phase shift of a clock node in degrees, otherwise returns
2648 int clk_get_phase(struct clk
*clk
)
2653 return clk_core_get_phase(clk
->core
);
2655 EXPORT_SYMBOL_GPL(clk_get_phase
);
2657 static void clk_core_reset_duty_cycle_nolock(struct clk_core
*core
)
2659 /* Assume a default value of 50% */
2664 static int clk_core_update_duty_cycle_parent_nolock(struct clk_core
*core
);
2666 static int clk_core_update_duty_cycle_nolock(struct clk_core
*core
)
2668 struct clk_duty
*duty
= &core
->duty
;
2671 if (!core
->ops
->get_duty_cycle
)
2672 return clk_core_update_duty_cycle_parent_nolock(core
);
2674 ret
= core
->ops
->get_duty_cycle(core
->hw
, duty
);
2678 /* Don't trust the clock provider too much */
2679 if (duty
->den
== 0 || duty
->num
> duty
->den
) {
2687 clk_core_reset_duty_cycle_nolock(core
);
2691 static int clk_core_update_duty_cycle_parent_nolock(struct clk_core
*core
)
2696 core
->flags
& CLK_DUTY_CYCLE_PARENT
) {
2697 ret
= clk_core_update_duty_cycle_nolock(core
->parent
);
2698 memcpy(&core
->duty
, &core
->parent
->duty
, sizeof(core
->duty
));
2700 clk_core_reset_duty_cycle_nolock(core
);
2706 static int clk_core_set_duty_cycle_parent_nolock(struct clk_core
*core
,
2707 struct clk_duty
*duty
);
2709 static int clk_core_set_duty_cycle_nolock(struct clk_core
*core
,
2710 struct clk_duty
*duty
)
2714 lockdep_assert_held(&prepare_lock
);
2716 if (clk_core_rate_is_protected(core
))
2719 trace_clk_set_duty_cycle(core
, duty
);
2721 if (!core
->ops
->set_duty_cycle
)
2722 return clk_core_set_duty_cycle_parent_nolock(core
, duty
);
2724 ret
= core
->ops
->set_duty_cycle(core
->hw
, duty
);
2726 memcpy(&core
->duty
, duty
, sizeof(*duty
));
2728 trace_clk_set_duty_cycle_complete(core
, duty
);
2733 static int clk_core_set_duty_cycle_parent_nolock(struct clk_core
*core
,
2734 struct clk_duty
*duty
)
2739 core
->flags
& (CLK_DUTY_CYCLE_PARENT
| CLK_SET_RATE_PARENT
)) {
2740 ret
= clk_core_set_duty_cycle_nolock(core
->parent
, duty
);
2741 memcpy(&core
->duty
, &core
->parent
->duty
, sizeof(core
->duty
));
2748 * clk_set_duty_cycle - adjust the duty cycle ratio of a clock signal
2749 * @clk: clock signal source
2750 * @num: numerator of the duty cycle ratio to be applied
2751 * @den: denominator of the duty cycle ratio to be applied
2753 * Apply the duty cycle ratio if the ratio is valid and the clock can
2754 * perform this operation
2756 * Returns (0) on success, a negative errno otherwise.
2758 int clk_set_duty_cycle(struct clk
*clk
, unsigned int num
, unsigned int den
)
2761 struct clk_duty duty
;
2766 /* sanity check the ratio */
2767 if (den
== 0 || num
> den
)
2775 if (clk
->exclusive_count
)
2776 clk_core_rate_unprotect(clk
->core
);
2778 ret
= clk_core_set_duty_cycle_nolock(clk
->core
, &duty
);
2780 if (clk
->exclusive_count
)
2781 clk_core_rate_protect(clk
->core
);
2783 clk_prepare_unlock();
2787 EXPORT_SYMBOL_GPL(clk_set_duty_cycle
);
2789 static int clk_core_get_scaled_duty_cycle(struct clk_core
*core
,
2792 struct clk_duty
*duty
= &core
->duty
;
2797 ret
= clk_core_update_duty_cycle_nolock(core
);
2799 ret
= mult_frac(scale
, duty
->num
, duty
->den
);
2801 clk_prepare_unlock();
2807 * clk_get_scaled_duty_cycle - return the duty cycle ratio of a clock signal
2808 * @clk: clock signal source
2809 * @scale: scaling factor to be applied to represent the ratio as an integer
2811 * Returns the duty cycle ratio of a clock node multiplied by the provided
2812 * scaling factor, or negative errno on error.
2814 int clk_get_scaled_duty_cycle(struct clk
*clk
, unsigned int scale
)
2819 return clk_core_get_scaled_duty_cycle(clk
->core
, scale
);
2821 EXPORT_SYMBOL_GPL(clk_get_scaled_duty_cycle
);
2824 * clk_is_match - check if two clk's point to the same hardware clock
2825 * @p: clk compared against q
2826 * @q: clk compared against p
2828 * Returns true if the two struct clk pointers both point to the same hardware
2829 * clock node. Put differently, returns true if struct clk *p and struct clk *q
2830 * share the same struct clk_core object.
2832 * Returns false otherwise. Note that two NULL clks are treated as matching.
2834 bool clk_is_match(const struct clk
*p
, const struct clk
*q
)
2836 /* trivial case: identical struct clk's or both NULL */
2840 /* true if clk->core pointers match. Avoid dereferencing garbage */
2841 if (!IS_ERR_OR_NULL(p
) && !IS_ERR_OR_NULL(q
))
2842 if (p
->core
== q
->core
)
2847 EXPORT_SYMBOL_GPL(clk_is_match
);
2849 /*** debugfs support ***/
2851 #ifdef CONFIG_DEBUG_FS
2852 #include <linux/debugfs.h>
2854 static struct dentry
*rootdir
;
2855 static int inited
= 0;
2856 static DEFINE_MUTEX(clk_debug_lock
);
2857 static HLIST_HEAD(clk_debug_list
);
2859 static struct hlist_head
*all_lists
[] = {
2865 static struct hlist_head
*orphan_list
[] = {
2870 static void clk_summary_show_one(struct seq_file
*s
, struct clk_core
*c
,
2876 seq_printf(s
, "%*s%-*s %7d %8d %8d %11lu %10lu %5d %6d\n",
2878 30 - level
* 3, c
->name
,
2879 c
->enable_count
, c
->prepare_count
, c
->protect_count
,
2880 clk_core_get_rate(c
), clk_core_get_accuracy(c
),
2881 clk_core_get_phase(c
),
2882 clk_core_get_scaled_duty_cycle(c
, 100000));
2885 static void clk_summary_show_subtree(struct seq_file
*s
, struct clk_core
*c
,
2888 struct clk_core
*child
;
2893 clk_summary_show_one(s
, c
, level
);
2895 hlist_for_each_entry(child
, &c
->children
, child_node
)
2896 clk_summary_show_subtree(s
, child
, level
+ 1);
2899 static int clk_summary_show(struct seq_file
*s
, void *data
)
2902 struct hlist_head
**lists
= (struct hlist_head
**)s
->private;
2904 seq_puts(s
, " enable prepare protect duty\n");
2905 seq_puts(s
, " clock count count count rate accuracy phase cycle\n");
2906 seq_puts(s
, "---------------------------------------------------------------------------------------------\n");
2910 for (; *lists
; lists
++)
2911 hlist_for_each_entry(c
, *lists
, child_node
)
2912 clk_summary_show_subtree(s
, c
, 0);
2914 clk_prepare_unlock();
2918 DEFINE_SHOW_ATTRIBUTE(clk_summary
);
2920 static void clk_dump_one(struct seq_file
*s
, struct clk_core
*c
, int level
)
2925 /* This should be JSON format, i.e. elements separated with a comma */
2926 seq_printf(s
, "\"%s\": { ", c
->name
);
2927 seq_printf(s
, "\"enable_count\": %d,", c
->enable_count
);
2928 seq_printf(s
, "\"prepare_count\": %d,", c
->prepare_count
);
2929 seq_printf(s
, "\"protect_count\": %d,", c
->protect_count
);
2930 seq_printf(s
, "\"rate\": %lu,", clk_core_get_rate(c
));
2931 seq_printf(s
, "\"accuracy\": %lu,", clk_core_get_accuracy(c
));
2932 seq_printf(s
, "\"phase\": %d,", clk_core_get_phase(c
));
2933 seq_printf(s
, "\"duty_cycle\": %u",
2934 clk_core_get_scaled_duty_cycle(c
, 100000));
2937 static void clk_dump_subtree(struct seq_file
*s
, struct clk_core
*c
, int level
)
2939 struct clk_core
*child
;
2944 clk_dump_one(s
, c
, level
);
2946 hlist_for_each_entry(child
, &c
->children
, child_node
) {
2948 clk_dump_subtree(s
, child
, level
+ 1);
2954 static int clk_dump_show(struct seq_file
*s
, void *data
)
2957 bool first_node
= true;
2958 struct hlist_head
**lists
= (struct hlist_head
**)s
->private;
2963 for (; *lists
; lists
++) {
2964 hlist_for_each_entry(c
, *lists
, child_node
) {
2968 clk_dump_subtree(s
, c
, 0);
2972 clk_prepare_unlock();
2977 DEFINE_SHOW_ATTRIBUTE(clk_dump
);
2979 static const struct {
2983 #define ENTRY(f) { f, #f }
2984 ENTRY(CLK_SET_RATE_GATE
),
2985 ENTRY(CLK_SET_PARENT_GATE
),
2986 ENTRY(CLK_SET_RATE_PARENT
),
2987 ENTRY(CLK_IGNORE_UNUSED
),
2988 ENTRY(CLK_GET_RATE_NOCACHE
),
2989 ENTRY(CLK_SET_RATE_NO_REPARENT
),
2990 ENTRY(CLK_GET_ACCURACY_NOCACHE
),
2991 ENTRY(CLK_RECALC_NEW_RATES
),
2992 ENTRY(CLK_SET_RATE_UNGATE
),
2993 ENTRY(CLK_IS_CRITICAL
),
2994 ENTRY(CLK_OPS_PARENT_ENABLE
),
2995 ENTRY(CLK_DUTY_CYCLE_PARENT
),
2999 static int clk_flags_show(struct seq_file
*s
, void *data
)
3001 struct clk_core
*core
= s
->private;
3002 unsigned long flags
= core
->flags
;
3005 for (i
= 0; flags
&& i
< ARRAY_SIZE(clk_flags
); i
++) {
3006 if (flags
& clk_flags
[i
].flag
) {
3007 seq_printf(s
, "%s\n", clk_flags
[i
].name
);
3008 flags
&= ~clk_flags
[i
].flag
;
3013 seq_printf(s
, "0x%lx\n", flags
);
3018 DEFINE_SHOW_ATTRIBUTE(clk_flags
);
3020 static void possible_parent_show(struct seq_file
*s
, struct clk_core
*core
,
3021 unsigned int i
, char terminator
)
3023 struct clk_core
*parent
;
3026 * Go through the following options to fetch a parent's name.
3028 * 1. Fetch the registered parent clock and use its name
3029 * 2. Use the global (fallback) name if specified
3030 * 3. Use the local fw_name if provided
3031 * 4. Fetch parent clock's clock-output-name if DT index was set
3033 * This may still fail in some cases, such as when the parent is
3034 * specified directly via a struct clk_hw pointer, but it isn't
3037 parent
= clk_core_get_parent_by_index(core
, i
);
3039 seq_printf(s
, "%s", parent
->name
);
3040 else if (core
->parents
[i
].name
)
3041 seq_printf(s
, "%s", core
->parents
[i
].name
);
3042 else if (core
->parents
[i
].fw_name
)
3043 seq_printf(s
, "<%s>(fw)", core
->parents
[i
].fw_name
);
3044 else if (core
->parents
[i
].index
>= 0)
3046 of_clk_get_parent_name(core
->of_node
,
3047 core
->parents
[i
].index
));
3049 seq_puts(s
, "(missing)");
3051 seq_putc(s
, terminator
);
3054 static int possible_parents_show(struct seq_file
*s
, void *data
)
3056 struct clk_core
*core
= s
->private;
3059 for (i
= 0; i
< core
->num_parents
- 1; i
++)
3060 possible_parent_show(s
, core
, i
, ' ');
3062 possible_parent_show(s
, core
, i
, '\n');
3066 DEFINE_SHOW_ATTRIBUTE(possible_parents
);
3068 static int current_parent_show(struct seq_file
*s
, void *data
)
3070 struct clk_core
*core
= s
->private;
3073 seq_printf(s
, "%s\n", core
->parent
->name
);
3077 DEFINE_SHOW_ATTRIBUTE(current_parent
);
3079 static int clk_duty_cycle_show(struct seq_file
*s
, void *data
)
3081 struct clk_core
*core
= s
->private;
3082 struct clk_duty
*duty
= &core
->duty
;
3084 seq_printf(s
, "%u/%u\n", duty
->num
, duty
->den
);
3088 DEFINE_SHOW_ATTRIBUTE(clk_duty_cycle
);
3090 static void clk_debug_create_one(struct clk_core
*core
, struct dentry
*pdentry
)
3092 struct dentry
*root
;
3094 if (!core
|| !pdentry
)
3097 root
= debugfs_create_dir(core
->name
, pdentry
);
3098 core
->dentry
= root
;
3100 debugfs_create_ulong("clk_rate", 0444, root
, &core
->rate
);
3101 debugfs_create_ulong("clk_accuracy", 0444, root
, &core
->accuracy
);
3102 debugfs_create_u32("clk_phase", 0444, root
, &core
->phase
);
3103 debugfs_create_file("clk_flags", 0444, root
, core
, &clk_flags_fops
);
3104 debugfs_create_u32("clk_prepare_count", 0444, root
, &core
->prepare_count
);
3105 debugfs_create_u32("clk_enable_count", 0444, root
, &core
->enable_count
);
3106 debugfs_create_u32("clk_protect_count", 0444, root
, &core
->protect_count
);
3107 debugfs_create_u32("clk_notifier_count", 0444, root
, &core
->notifier_count
);
3108 debugfs_create_file("clk_duty_cycle", 0444, root
, core
,
3109 &clk_duty_cycle_fops
);
3111 if (core
->num_parents
> 0)
3112 debugfs_create_file("clk_parent", 0444, root
, core
,
3113 ¤t_parent_fops
);
3115 if (core
->num_parents
> 1)
3116 debugfs_create_file("clk_possible_parents", 0444, root
, core
,
3117 &possible_parents_fops
);
3119 if (core
->ops
->debug_init
)
3120 core
->ops
->debug_init(core
->hw
, core
->dentry
);
3124 * clk_debug_register - add a clk node to the debugfs clk directory
3125 * @core: the clk being added to the debugfs clk directory
3127 * Dynamically adds a clk to the debugfs clk directory if debugfs has been
3128 * initialized. Otherwise it bails out early since the debugfs clk directory
3129 * will be created lazily by clk_debug_init as part of a late_initcall.
3131 static void clk_debug_register(struct clk_core
*core
)
3133 mutex_lock(&clk_debug_lock
);
3134 hlist_add_head(&core
->debug_node
, &clk_debug_list
);
3136 clk_debug_create_one(core
, rootdir
);
3137 mutex_unlock(&clk_debug_lock
);
3141 * clk_debug_unregister - remove a clk node from the debugfs clk directory
3142 * @core: the clk being removed from the debugfs clk directory
3144 * Dynamically removes a clk and all its child nodes from the
3145 * debugfs clk directory if clk->dentry points to debugfs created by
3146 * clk_debug_register in __clk_core_init.
3148 static void clk_debug_unregister(struct clk_core
*core
)
3150 mutex_lock(&clk_debug_lock
);
3151 hlist_del_init(&core
->debug_node
);
3152 debugfs_remove_recursive(core
->dentry
);
3153 core
->dentry
= NULL
;
3154 mutex_unlock(&clk_debug_lock
);
3158 * clk_debug_init - lazily populate the debugfs clk directory
3160 * clks are often initialized very early during boot before memory can be
3161 * dynamically allocated and well before debugfs is setup. This function
3162 * populates the debugfs clk directory once at boot-time when we know that
3163 * debugfs is setup. It should only be called once at boot-time, all other clks
3164 * added dynamically will be done so with clk_debug_register.
3166 static int __init
clk_debug_init(void)
3168 struct clk_core
*core
;
3170 rootdir
= debugfs_create_dir("clk", NULL
);
3172 debugfs_create_file("clk_summary", 0444, rootdir
, &all_lists
,
3174 debugfs_create_file("clk_dump", 0444, rootdir
, &all_lists
,
3176 debugfs_create_file("clk_orphan_summary", 0444, rootdir
, &orphan_list
,
3178 debugfs_create_file("clk_orphan_dump", 0444, rootdir
, &orphan_list
,
3181 mutex_lock(&clk_debug_lock
);
3182 hlist_for_each_entry(core
, &clk_debug_list
, debug_node
)
3183 clk_debug_create_one(core
, rootdir
);
3186 mutex_unlock(&clk_debug_lock
);
3190 late_initcall(clk_debug_init
);
3192 static inline void clk_debug_register(struct clk_core
*core
) { }
3193 static inline void clk_debug_reparent(struct clk_core
*core
,
3194 struct clk_core
*new_parent
)
3197 static inline void clk_debug_unregister(struct clk_core
*core
)
3203 * __clk_core_init - initialize the data structures in a struct clk_core
3204 * @core: clk_core being initialized
3206 * Initializes the lists in struct clk_core, queries the hardware for the
3207 * parent and rate and sets them both.
3209 static int __clk_core_init(struct clk_core
*core
)
3212 struct clk_core
*orphan
;
3213 struct hlist_node
*tmp2
;
3221 ret
= clk_pm_runtime_get(core
);
3225 /* check to see if a clock with this name is already registered */
3226 if (clk_core_lookup(core
->name
)) {
3227 pr_debug("%s: clk %s already initialized\n",
3228 __func__
, core
->name
);
3233 /* check that clk_ops are sane. See Documentation/driver-api/clk.rst */
3234 if (core
->ops
->set_rate
&&
3235 !((core
->ops
->round_rate
|| core
->ops
->determine_rate
) &&
3236 core
->ops
->recalc_rate
)) {
3237 pr_err("%s: %s must implement .round_rate or .determine_rate in addition to .recalc_rate\n",
3238 __func__
, core
->name
);
3243 if (core
->ops
->set_parent
&& !core
->ops
->get_parent
) {
3244 pr_err("%s: %s must implement .get_parent & .set_parent\n",
3245 __func__
, core
->name
);
3250 if (core
->num_parents
> 1 && !core
->ops
->get_parent
) {
3251 pr_err("%s: %s must implement .get_parent as it has multi parents\n",
3252 __func__
, core
->name
);
3257 if (core
->ops
->set_rate_and_parent
&&
3258 !(core
->ops
->set_parent
&& core
->ops
->set_rate
)) {
3259 pr_err("%s: %s must implement .set_parent & .set_rate\n",
3260 __func__
, core
->name
);
3265 core
->parent
= __clk_init_parent(core
);
3268 * Populate core->parent if parent has already been clk_core_init'd. If
3269 * parent has not yet been clk_core_init'd then place clk in the orphan
3270 * list. If clk doesn't have any parents then place it in the root
3273 * Every time a new clk is clk_init'd then we walk the list of orphan
3274 * clocks and re-parent any that are children of the clock currently
3278 hlist_add_head(&core
->child_node
,
3279 &core
->parent
->children
);
3280 core
->orphan
= core
->parent
->orphan
;
3281 } else if (!core
->num_parents
) {
3282 hlist_add_head(&core
->child_node
, &clk_root_list
);
3283 core
->orphan
= false;
3285 hlist_add_head(&core
->child_node
, &clk_orphan_list
);
3286 core
->orphan
= true;
3290 * optional platform-specific magic
3292 * The .init callback is not used by any of the basic clock types, but
3293 * exists for weird hardware that must perform initialization magic.
3294 * Please consider other ways of solving initialization problems before
3295 * using this callback, as its use is discouraged.
3297 if (core
->ops
->init
)
3298 core
->ops
->init(core
->hw
);
3301 * Set clk's accuracy. The preferred method is to use
3302 * .recalc_accuracy. For simple clocks and lazy developers the default
3303 * fallback is to use the parent's accuracy. If a clock doesn't have a
3304 * parent (or is orphaned) then accuracy is set to zero (perfect
3307 if (core
->ops
->recalc_accuracy
)
3308 core
->accuracy
= core
->ops
->recalc_accuracy(core
->hw
,
3309 __clk_get_accuracy(core
->parent
));
3310 else if (core
->parent
)
3311 core
->accuracy
= core
->parent
->accuracy
;
3317 * Since a phase is by definition relative to its parent, just
3318 * query the current clock phase, or just assume it's in phase.
3320 if (core
->ops
->get_phase
)
3321 core
->phase
= core
->ops
->get_phase(core
->hw
);
3326 * Set clk's duty cycle.
3328 clk_core_update_duty_cycle_nolock(core
);
3331 * Set clk's rate. The preferred method is to use .recalc_rate. For
3332 * simple clocks and lazy developers the default fallback is to use the
3333 * parent's rate. If a clock doesn't have a parent (or is orphaned)
3334 * then rate is set to zero.
3336 if (core
->ops
->recalc_rate
)
3337 rate
= core
->ops
->recalc_rate(core
->hw
,
3338 clk_core_get_rate_nolock(core
->parent
));
3339 else if (core
->parent
)
3340 rate
= core
->parent
->rate
;
3343 core
->rate
= core
->req_rate
= rate
;
3346 * Enable CLK_IS_CRITICAL clocks so newly added critical clocks
3347 * don't get accidentally disabled when walking the orphan tree and
3348 * reparenting clocks
3350 if (core
->flags
& CLK_IS_CRITICAL
) {
3351 unsigned long flags
;
3353 clk_core_prepare(core
);
3355 flags
= clk_enable_lock();
3356 clk_core_enable(core
);
3357 clk_enable_unlock(flags
);
3361 * walk the list of orphan clocks and reparent any that newly finds a
3364 hlist_for_each_entry_safe(orphan
, tmp2
, &clk_orphan_list
, child_node
) {
3365 struct clk_core
*parent
= __clk_init_parent(orphan
);
3368 * We need to use __clk_set_parent_before() and _after() to
3369 * to properly migrate any prepare/enable count of the orphan
3370 * clock. This is important for CLK_IS_CRITICAL clocks, which
3371 * are enabled during init but might not have a parent yet.
3374 /* update the clk tree topology */
3375 __clk_set_parent_before(orphan
, parent
);
3376 __clk_set_parent_after(orphan
, parent
, NULL
);
3377 __clk_recalc_accuracies(orphan
);
3378 __clk_recalc_rates(orphan
, 0);
3382 kref_init(&core
->ref
);
3384 clk_pm_runtime_put(core
);
3386 clk_prepare_unlock();
3389 clk_debug_register(core
);
3395 * clk_core_link_consumer - Add a clk consumer to the list of consumers in a clk_core
3396 * @core: clk to add consumer to
3397 * @clk: consumer to link to a clk
3399 static void clk_core_link_consumer(struct clk_core
*core
, struct clk
*clk
)
3402 hlist_add_head(&clk
->clks_node
, &core
->clks
);
3403 clk_prepare_unlock();
3407 * clk_core_unlink_consumer - Remove a clk consumer from the list of consumers in a clk_core
3408 * @clk: consumer to unlink
3410 static void clk_core_unlink_consumer(struct clk
*clk
)
3412 lockdep_assert_held(&prepare_lock
);
3413 hlist_del(&clk
->clks_node
);
3417 * alloc_clk - Allocate a clk consumer, but leave it unlinked to the clk_core
3418 * @core: clk to allocate a consumer for
3419 * @dev_id: string describing device name
3420 * @con_id: connection ID string on device
3422 * Returns: clk consumer left unlinked from the consumer list
3424 static struct clk
*alloc_clk(struct clk_core
*core
, const char *dev_id
,
3429 clk
= kzalloc(sizeof(*clk
), GFP_KERNEL
);
3431 return ERR_PTR(-ENOMEM
);
3434 clk
->dev_id
= dev_id
;
3435 clk
->con_id
= kstrdup_const(con_id
, GFP_KERNEL
);
3436 clk
->max_rate
= ULONG_MAX
;
3442 * free_clk - Free a clk consumer
3443 * @clk: clk consumer to free
3445 * Note, this assumes the clk has been unlinked from the clk_core consumer
3448 static void free_clk(struct clk
*clk
)
3450 kfree_const(clk
->con_id
);
3455 * clk_hw_create_clk: Allocate and link a clk consumer to a clk_core given
3457 * @dev: clk consumer device
3458 * @hw: clk_hw associated with the clk being consumed
3459 * @dev_id: string describing device name
3460 * @con_id: connection ID string on device
3462 * This is the main function used to create a clk pointer for use by clk
3463 * consumers. It connects a consumer to the clk_core and clk_hw structures
3464 * used by the framework and clk provider respectively.
3466 struct clk
*clk_hw_create_clk(struct device
*dev
, struct clk_hw
*hw
,
3467 const char *dev_id
, const char *con_id
)
3470 struct clk_core
*core
;
3472 /* This is to allow this function to be chained to others */
3473 if (IS_ERR_OR_NULL(hw
))
3474 return ERR_CAST(hw
);
3477 clk
= alloc_clk(core
, dev_id
, con_id
);
3482 if (!try_module_get(core
->owner
)) {
3484 return ERR_PTR(-ENOENT
);
3487 kref_get(&core
->ref
);
3488 clk_core_link_consumer(core
, clk
);
3493 static int clk_cpy_name(const char **dst_p
, const char *src
, bool must_exist
)
3503 *dst_p
= dst
= kstrdup_const(src
, GFP_KERNEL
);
3510 static int clk_core_populate_parent_map(struct clk_core
*core
)
3512 const struct clk_init_data
*init
= core
->hw
->init
;
3513 u8 num_parents
= init
->num_parents
;
3514 const char * const *parent_names
= init
->parent_names
;
3515 const struct clk_hw
**parent_hws
= init
->parent_hws
;
3516 const struct clk_parent_data
*parent_data
= init
->parent_data
;
3518 struct clk_parent_map
*parents
, *parent
;
3524 * Avoid unnecessary string look-ups of clk_core's possible parents by
3525 * having a cache of names/clk_hw pointers to clk_core pointers.
3527 parents
= kcalloc(num_parents
, sizeof(*parents
), GFP_KERNEL
);
3528 core
->parents
= parents
;
3532 /* Copy everything over because it might be __initdata */
3533 for (i
= 0, parent
= parents
; i
< num_parents
; i
++, parent
++) {
3536 /* throw a WARN if any entries are NULL */
3537 WARN(!parent_names
[i
],
3538 "%s: invalid NULL in %s's .parent_names\n",
3539 __func__
, core
->name
);
3540 ret
= clk_cpy_name(&parent
->name
, parent_names
[i
],
3542 } else if (parent_data
) {
3543 parent
->hw
= parent_data
[i
].hw
;
3544 parent
->index
= parent_data
[i
].index
;
3545 ret
= clk_cpy_name(&parent
->fw_name
,
3546 parent_data
[i
].fw_name
, false);
3548 ret
= clk_cpy_name(&parent
->name
,
3549 parent_data
[i
].name
,
3551 } else if (parent_hws
) {
3552 parent
->hw
= parent_hws
[i
];
3555 WARN(1, "Must specify parents if num_parents > 0\n");
3560 kfree_const(parents
[i
].name
);
3561 kfree_const(parents
[i
].fw_name
);
3572 static void clk_core_free_parent_map(struct clk_core
*core
)
3574 int i
= core
->num_parents
;
3576 if (!core
->num_parents
)
3580 kfree_const(core
->parents
[i
].name
);
3581 kfree_const(core
->parents
[i
].fw_name
);
3584 kfree(core
->parents
);
3588 __clk_register(struct device
*dev
, struct device_node
*np
, struct clk_hw
*hw
)
3591 struct clk_core
*core
;
3593 core
= kzalloc(sizeof(*core
), GFP_KERNEL
);
3599 core
->name
= kstrdup_const(hw
->init
->name
, GFP_KERNEL
);
3605 if (WARN_ON(!hw
->init
->ops
)) {
3609 core
->ops
= hw
->init
->ops
;
3611 if (dev
&& pm_runtime_enabled(dev
))
3612 core
->rpm_enabled
= true;
3615 if (dev
&& dev
->driver
)
3616 core
->owner
= dev
->driver
->owner
;
3618 core
->flags
= hw
->init
->flags
;
3619 core
->num_parents
= hw
->init
->num_parents
;
3621 core
->max_rate
= ULONG_MAX
;
3624 ret
= clk_core_populate_parent_map(core
);
3628 INIT_HLIST_HEAD(&core
->clks
);
3631 * Don't call clk_hw_create_clk() here because that would pin the
3632 * provider module to itself and prevent it from ever being removed.
3634 hw
->clk
= alloc_clk(core
, NULL
, NULL
);
3635 if (IS_ERR(hw
->clk
)) {
3636 ret
= PTR_ERR(hw
->clk
);
3637 goto fail_create_clk
;
3640 clk_core_link_consumer(hw
->core
, hw
->clk
);
3642 ret
= __clk_core_init(core
);
3647 clk_core_unlink_consumer(hw
->clk
);
3648 clk_prepare_unlock();
3654 clk_core_free_parent_map(core
);
3657 kfree_const(core
->name
);
3661 return ERR_PTR(ret
);
3665 * clk_register - allocate a new clock, register it and return an opaque cookie
3666 * @dev: device that is registering this clock
3667 * @hw: link to hardware-specific clock data
3669 * clk_register is the *deprecated* interface for populating the clock tree with
3670 * new clock nodes. Use clk_hw_register() instead.
3672 * Returns: a pointer to the newly allocated struct clk which
3673 * cannot be dereferenced by driver code but may be used in conjunction with the
3674 * rest of the clock API. In the event of an error clk_register will return an
3675 * error code; drivers must test for an error code after calling clk_register.
3677 struct clk
*clk_register(struct device
*dev
, struct clk_hw
*hw
)
3679 return __clk_register(dev
, dev_of_node(dev
), hw
);
3681 EXPORT_SYMBOL_GPL(clk_register
);
3684 * clk_hw_register - register a clk_hw and return an error code
3685 * @dev: device that is registering this clock
3686 * @hw: link to hardware-specific clock data
3688 * clk_hw_register is the primary interface for populating the clock tree with
3689 * new clock nodes. It returns an integer equal to zero indicating success or
3690 * less than zero indicating failure. Drivers must test for an error code after
3691 * calling clk_hw_register().
3693 int clk_hw_register(struct device
*dev
, struct clk_hw
*hw
)
3695 return PTR_ERR_OR_ZERO(__clk_register(dev
, dev_of_node(dev
), hw
));
3697 EXPORT_SYMBOL_GPL(clk_hw_register
);
3700 * of_clk_hw_register - register a clk_hw and return an error code
3701 * @node: device_node of device that is registering this clock
3702 * @hw: link to hardware-specific clock data
3704 * of_clk_hw_register() is the primary interface for populating the clock tree
3705 * with new clock nodes when a struct device is not available, but a struct
3706 * device_node is. It returns an integer equal to zero indicating success or
3707 * less than zero indicating failure. Drivers must test for an error code after
3708 * calling of_clk_hw_register().
3710 int of_clk_hw_register(struct device_node
*node
, struct clk_hw
*hw
)
3712 return PTR_ERR_OR_ZERO(__clk_register(NULL
, node
, hw
));
3714 EXPORT_SYMBOL_GPL(of_clk_hw_register
);
3716 /* Free memory allocated for a clock. */
3717 static void __clk_release(struct kref
*ref
)
3719 struct clk_core
*core
= container_of(ref
, struct clk_core
, ref
);
3721 lockdep_assert_held(&prepare_lock
);
3723 clk_core_free_parent_map(core
);
3724 kfree_const(core
->name
);
3729 * Empty clk_ops for unregistered clocks. These are used temporarily
3730 * after clk_unregister() was called on a clock and until last clock
3731 * consumer calls clk_put() and the struct clk object is freed.
3733 static int clk_nodrv_prepare_enable(struct clk_hw
*hw
)
3738 static void clk_nodrv_disable_unprepare(struct clk_hw
*hw
)
3743 static int clk_nodrv_set_rate(struct clk_hw
*hw
, unsigned long rate
,
3744 unsigned long parent_rate
)
3749 static int clk_nodrv_set_parent(struct clk_hw
*hw
, u8 index
)
3754 static const struct clk_ops clk_nodrv_ops
= {
3755 .enable
= clk_nodrv_prepare_enable
,
3756 .disable
= clk_nodrv_disable_unprepare
,
3757 .prepare
= clk_nodrv_prepare_enable
,
3758 .unprepare
= clk_nodrv_disable_unprepare
,
3759 .set_rate
= clk_nodrv_set_rate
,
3760 .set_parent
= clk_nodrv_set_parent
,
3764 * clk_unregister - unregister a currently registered clock
3765 * @clk: clock to unregister
3767 void clk_unregister(struct clk
*clk
)
3769 unsigned long flags
;
3771 if (!clk
|| WARN_ON_ONCE(IS_ERR(clk
)))
3774 clk_debug_unregister(clk
->core
);
3778 if (clk
->core
->ops
== &clk_nodrv_ops
) {
3779 pr_err("%s: unregistered clock: %s\n", __func__
,
3784 * Assign empty clock ops for consumers that might still hold
3785 * a reference to this clock.
3787 flags
= clk_enable_lock();
3788 clk
->core
->ops
= &clk_nodrv_ops
;
3789 clk_enable_unlock(flags
);
3791 if (!hlist_empty(&clk
->core
->children
)) {
3792 struct clk_core
*child
;
3793 struct hlist_node
*t
;
3795 /* Reparent all children to the orphan list. */
3796 hlist_for_each_entry_safe(child
, t
, &clk
->core
->children
,
3798 clk_core_set_parent_nolock(child
, NULL
);
3801 hlist_del_init(&clk
->core
->child_node
);
3803 if (clk
->core
->prepare_count
)
3804 pr_warn("%s: unregistering prepared clock: %s\n",
3805 __func__
, clk
->core
->name
);
3807 if (clk
->core
->protect_count
)
3808 pr_warn("%s: unregistering protected clock: %s\n",
3809 __func__
, clk
->core
->name
);
3811 kref_put(&clk
->core
->ref
, __clk_release
);
3813 clk_prepare_unlock();
3815 EXPORT_SYMBOL_GPL(clk_unregister
);
3818 * clk_hw_unregister - unregister a currently registered clk_hw
3819 * @hw: hardware-specific clock data to unregister
3821 void clk_hw_unregister(struct clk_hw
*hw
)
3823 clk_unregister(hw
->clk
);
3825 EXPORT_SYMBOL_GPL(clk_hw_unregister
);
3827 static void devm_clk_release(struct device
*dev
, void *res
)
3829 clk_unregister(*(struct clk
**)res
);
3832 static void devm_clk_hw_release(struct device
*dev
, void *res
)
3834 clk_hw_unregister(*(struct clk_hw
**)res
);
3838 * devm_clk_register - resource managed clk_register()
3839 * @dev: device that is registering this clock
3840 * @hw: link to hardware-specific clock data
3842 * Managed clk_register(). This function is *deprecated*, use devm_clk_hw_register() instead.
3844 * Clocks returned from this function are automatically clk_unregister()ed on
3845 * driver detach. See clk_register() for more information.
3847 struct clk
*devm_clk_register(struct device
*dev
, struct clk_hw
*hw
)
3852 clkp
= devres_alloc(devm_clk_release
, sizeof(*clkp
), GFP_KERNEL
);
3854 return ERR_PTR(-ENOMEM
);
3856 clk
= clk_register(dev
, hw
);
3859 devres_add(dev
, clkp
);
3866 EXPORT_SYMBOL_GPL(devm_clk_register
);
3869 * devm_clk_hw_register - resource managed clk_hw_register()
3870 * @dev: device that is registering this clock
3871 * @hw: link to hardware-specific clock data
3873 * Managed clk_hw_register(). Clocks registered by this function are
3874 * automatically clk_hw_unregister()ed on driver detach. See clk_hw_register()
3875 * for more information.
3877 int devm_clk_hw_register(struct device
*dev
, struct clk_hw
*hw
)
3879 struct clk_hw
**hwp
;
3882 hwp
= devres_alloc(devm_clk_hw_release
, sizeof(*hwp
), GFP_KERNEL
);
3886 ret
= clk_hw_register(dev
, hw
);
3889 devres_add(dev
, hwp
);
3896 EXPORT_SYMBOL_GPL(devm_clk_hw_register
);
3898 static int devm_clk_match(struct device
*dev
, void *res
, void *data
)
3900 struct clk
*c
= res
;
3906 static int devm_clk_hw_match(struct device
*dev
, void *res
, void *data
)
3908 struct clk_hw
*hw
= res
;
3916 * devm_clk_unregister - resource managed clk_unregister()
3917 * @clk: clock to unregister
3919 * Deallocate a clock allocated with devm_clk_register(). Normally
3920 * this function will not need to be called and the resource management
3921 * code will ensure that the resource is freed.
3923 void devm_clk_unregister(struct device
*dev
, struct clk
*clk
)
3925 WARN_ON(devres_release(dev
, devm_clk_release
, devm_clk_match
, clk
));
3927 EXPORT_SYMBOL_GPL(devm_clk_unregister
);
3930 * devm_clk_hw_unregister - resource managed clk_hw_unregister()
3931 * @dev: device that is unregistering the hardware-specific clock data
3932 * @hw: link to hardware-specific clock data
3934 * Unregister a clk_hw registered with devm_clk_hw_register(). Normally
3935 * this function will not need to be called and the resource management
3936 * code will ensure that the resource is freed.
3938 void devm_clk_hw_unregister(struct device
*dev
, struct clk_hw
*hw
)
3940 WARN_ON(devres_release(dev
, devm_clk_hw_release
, devm_clk_hw_match
,
3943 EXPORT_SYMBOL_GPL(devm_clk_hw_unregister
);
3949 void __clk_put(struct clk
*clk
)
3951 struct module
*owner
;
3953 if (!clk
|| WARN_ON_ONCE(IS_ERR(clk
)))
3959 * Before calling clk_put, all calls to clk_rate_exclusive_get() from a
3960 * given user should be balanced with calls to clk_rate_exclusive_put()
3961 * and by that same consumer
3963 if (WARN_ON(clk
->exclusive_count
)) {
3964 /* We voiced our concern, let's sanitize the situation */
3965 clk
->core
->protect_count
-= (clk
->exclusive_count
- 1);
3966 clk_core_rate_unprotect(clk
->core
);
3967 clk
->exclusive_count
= 0;
3970 hlist_del(&clk
->clks_node
);
3971 if (clk
->min_rate
> clk
->core
->req_rate
||
3972 clk
->max_rate
< clk
->core
->req_rate
)
3973 clk_core_set_rate_nolock(clk
->core
, clk
->core
->req_rate
);
3975 owner
= clk
->core
->owner
;
3976 kref_put(&clk
->core
->ref
, __clk_release
);
3978 clk_prepare_unlock();
3985 /*** clk rate change notifiers ***/
3988 * clk_notifier_register - add a clk rate change notifier
3989 * @clk: struct clk * to watch
3990 * @nb: struct notifier_block * with callback info
3992 * Request notification when clk's rate changes. This uses an SRCU
3993 * notifier because we want it to block and notifier unregistrations are
3994 * uncommon. The callbacks associated with the notifier must not
3995 * re-enter into the clk framework by calling any top-level clk APIs;
3996 * this will cause a nested prepare_lock mutex.
3998 * In all notification cases (pre, post and abort rate change) the original
3999 * clock rate is passed to the callback via struct clk_notifier_data.old_rate
4000 * and the new frequency is passed via struct clk_notifier_data.new_rate.
4002 * clk_notifier_register() must be called from non-atomic context.
4003 * Returns -EINVAL if called with null arguments, -ENOMEM upon
4004 * allocation failure; otherwise, passes along the return value of
4005 * srcu_notifier_chain_register().
4007 int clk_notifier_register(struct clk
*clk
, struct notifier_block
*nb
)
4009 struct clk_notifier
*cn
;
4017 /* search the list of notifiers for this clk */
4018 list_for_each_entry(cn
, &clk_notifier_list
, node
)
4022 /* if clk wasn't in the notifier list, allocate new clk_notifier */
4023 if (cn
->clk
!= clk
) {
4024 cn
= kzalloc(sizeof(*cn
), GFP_KERNEL
);
4029 srcu_init_notifier_head(&cn
->notifier_head
);
4031 list_add(&cn
->node
, &clk_notifier_list
);
4034 ret
= srcu_notifier_chain_register(&cn
->notifier_head
, nb
);
4036 clk
->core
->notifier_count
++;
4039 clk_prepare_unlock();
4043 EXPORT_SYMBOL_GPL(clk_notifier_register
);
4046 * clk_notifier_unregister - remove a clk rate change notifier
4047 * @clk: struct clk *
4048 * @nb: struct notifier_block * with callback info
4050 * Request no further notification for changes to 'clk' and frees memory
4051 * allocated in clk_notifier_register.
4053 * Returns -EINVAL if called with null arguments; otherwise, passes
4054 * along the return value of srcu_notifier_chain_unregister().
4056 int clk_notifier_unregister(struct clk
*clk
, struct notifier_block
*nb
)
4058 struct clk_notifier
*cn
= NULL
;
4066 list_for_each_entry(cn
, &clk_notifier_list
, node
)
4070 if (cn
->clk
== clk
) {
4071 ret
= srcu_notifier_chain_unregister(&cn
->notifier_head
, nb
);
4073 clk
->core
->notifier_count
--;
4075 /* XXX the notifier code should handle this better */
4076 if (!cn
->notifier_head
.head
) {
4077 srcu_cleanup_notifier_head(&cn
->notifier_head
);
4078 list_del(&cn
->node
);
4086 clk_prepare_unlock();
4090 EXPORT_SYMBOL_GPL(clk_notifier_unregister
);
4094 * struct of_clk_provider - Clock provider registration structure
4095 * @link: Entry in global list of clock providers
4096 * @node: Pointer to device tree node of clock provider
4097 * @get: Get clock callback. Returns NULL or a struct clk for the
4098 * given clock specifier
4099 * @data: context pointer to be passed into @get callback
4101 struct of_clk_provider
{
4102 struct list_head link
;
4104 struct device_node
*node
;
4105 struct clk
*(*get
)(struct of_phandle_args
*clkspec
, void *data
);
4106 struct clk_hw
*(*get_hw
)(struct of_phandle_args
*clkspec
, void *data
);
4110 extern struct of_device_id __clk_of_table
;
4111 static const struct of_device_id __clk_of_table_sentinel
4112 __used
__section(__clk_of_table_end
);
4114 static LIST_HEAD(of_clk_providers
);
4115 static DEFINE_MUTEX(of_clk_mutex
);
4117 struct clk
*of_clk_src_simple_get(struct of_phandle_args
*clkspec
,
4122 EXPORT_SYMBOL_GPL(of_clk_src_simple_get
);
4124 struct clk_hw
*of_clk_hw_simple_get(struct of_phandle_args
*clkspec
, void *data
)
4128 EXPORT_SYMBOL_GPL(of_clk_hw_simple_get
);
4130 struct clk
*of_clk_src_onecell_get(struct of_phandle_args
*clkspec
, void *data
)
4132 struct clk_onecell_data
*clk_data
= data
;
4133 unsigned int idx
= clkspec
->args
[0];
4135 if (idx
>= clk_data
->clk_num
) {
4136 pr_err("%s: invalid clock index %u\n", __func__
, idx
);
4137 return ERR_PTR(-EINVAL
);
4140 return clk_data
->clks
[idx
];
4142 EXPORT_SYMBOL_GPL(of_clk_src_onecell_get
);
4145 of_clk_hw_onecell_get(struct of_phandle_args
*clkspec
, void *data
)
4147 struct clk_hw_onecell_data
*hw_data
= data
;
4148 unsigned int idx
= clkspec
->args
[0];
4150 if (idx
>= hw_data
->num
) {
4151 pr_err("%s: invalid index %u\n", __func__
, idx
);
4152 return ERR_PTR(-EINVAL
);
4155 return hw_data
->hws
[idx
];
4157 EXPORT_SYMBOL_GPL(of_clk_hw_onecell_get
);
4160 * of_clk_add_provider() - Register a clock provider for a node
4161 * @np: Device node pointer associated with clock provider
4162 * @clk_src_get: callback for decoding clock
4163 * @data: context pointer for @clk_src_get callback.
4165 * This function is *deprecated*. Use of_clk_add_hw_provider() instead.
4167 int of_clk_add_provider(struct device_node
*np
,
4168 struct clk
*(*clk_src_get
)(struct of_phandle_args
*clkspec
,
4172 struct of_clk_provider
*cp
;
4175 cp
= kzalloc(sizeof(*cp
), GFP_KERNEL
);
4179 cp
->node
= of_node_get(np
);
4181 cp
->get
= clk_src_get
;
4183 mutex_lock(&of_clk_mutex
);
4184 list_add(&cp
->link
, &of_clk_providers
);
4185 mutex_unlock(&of_clk_mutex
);
4186 pr_debug("Added clock from %pOF\n", np
);
4188 ret
= of_clk_set_defaults(np
, true);
4190 of_clk_del_provider(np
);
4194 EXPORT_SYMBOL_GPL(of_clk_add_provider
);
4197 * of_clk_add_hw_provider() - Register a clock provider for a node
4198 * @np: Device node pointer associated with clock provider
4199 * @get: callback for decoding clk_hw
4200 * @data: context pointer for @get callback.
4202 int of_clk_add_hw_provider(struct device_node
*np
,
4203 struct clk_hw
*(*get
)(struct of_phandle_args
*clkspec
,
4207 struct of_clk_provider
*cp
;
4210 cp
= kzalloc(sizeof(*cp
), GFP_KERNEL
);
4214 cp
->node
= of_node_get(np
);
4218 mutex_lock(&of_clk_mutex
);
4219 list_add(&cp
->link
, &of_clk_providers
);
4220 mutex_unlock(&of_clk_mutex
);
4221 pr_debug("Added clk_hw provider from %pOF\n", np
);
4223 ret
= of_clk_set_defaults(np
, true);
4225 of_clk_del_provider(np
);
4229 EXPORT_SYMBOL_GPL(of_clk_add_hw_provider
);
4231 static void devm_of_clk_release_provider(struct device
*dev
, void *res
)
4233 of_clk_del_provider(*(struct device_node
**)res
);
4237 * We allow a child device to use its parent device as the clock provider node
4238 * for cases like MFD sub-devices where the child device driver wants to use
4239 * devm_*() APIs but not list the device in DT as a sub-node.
4241 static struct device_node
*get_clk_provider_node(struct device
*dev
)
4243 struct device_node
*np
, *parent_np
;
4246 parent_np
= dev
->parent
? dev
->parent
->of_node
: NULL
;
4248 if (!of_find_property(np
, "#clock-cells", NULL
))
4249 if (of_find_property(parent_np
, "#clock-cells", NULL
))
4256 * devm_of_clk_add_hw_provider() - Managed clk provider node registration
4257 * @dev: Device acting as the clock provider (used for DT node and lifetime)
4258 * @get: callback for decoding clk_hw
4259 * @data: context pointer for @get callback
4261 * Registers clock provider for given device's node. If the device has no DT
4262 * node or if the device node lacks of clock provider information (#clock-cells)
4263 * then the parent device's node is scanned for this information. If parent node
4264 * has the #clock-cells then it is used in registration. Provider is
4265 * automatically released at device exit.
4267 * Return: 0 on success or an errno on failure.
4269 int devm_of_clk_add_hw_provider(struct device
*dev
,
4270 struct clk_hw
*(*get
)(struct of_phandle_args
*clkspec
,
4274 struct device_node
**ptr
, *np
;
4277 ptr
= devres_alloc(devm_of_clk_release_provider
, sizeof(*ptr
),
4282 np
= get_clk_provider_node(dev
);
4283 ret
= of_clk_add_hw_provider(np
, get
, data
);
4286 devres_add(dev
, ptr
);
4293 EXPORT_SYMBOL_GPL(devm_of_clk_add_hw_provider
);
4296 * of_clk_del_provider() - Remove a previously registered clock provider
4297 * @np: Device node pointer associated with clock provider
4299 void of_clk_del_provider(struct device_node
*np
)
4301 struct of_clk_provider
*cp
;
4303 mutex_lock(&of_clk_mutex
);
4304 list_for_each_entry(cp
, &of_clk_providers
, link
) {
4305 if (cp
->node
== np
) {
4306 list_del(&cp
->link
);
4307 of_node_put(cp
->node
);
4312 mutex_unlock(&of_clk_mutex
);
4314 EXPORT_SYMBOL_GPL(of_clk_del_provider
);
4316 static int devm_clk_provider_match(struct device
*dev
, void *res
, void *data
)
4318 struct device_node
**np
= res
;
4320 if (WARN_ON(!np
|| !*np
))
4327 * devm_of_clk_del_provider() - Remove clock provider registered using devm
4328 * @dev: Device to whose lifetime the clock provider was bound
4330 void devm_of_clk_del_provider(struct device
*dev
)
4333 struct device_node
*np
= get_clk_provider_node(dev
);
4335 ret
= devres_release(dev
, devm_of_clk_release_provider
,
4336 devm_clk_provider_match
, np
);
4340 EXPORT_SYMBOL(devm_of_clk_del_provider
);
4343 * Beware the return values when np is valid, but no clock provider is found.
4344 * If name == NULL, the function returns -ENOENT.
4345 * If name != NULL, the function returns -EINVAL. This is because
4346 * of_parse_phandle_with_args() is called even if of_property_match_string()
4349 static int of_parse_clkspec(const struct device_node
*np
, int index
,
4350 const char *name
, struct of_phandle_args
*out_args
)
4354 /* Walk up the tree of devices looking for a clock property that matches */
4357 * For named clocks, first look up the name in the
4358 * "clock-names" property. If it cannot be found, then index
4359 * will be an error code and of_parse_phandle_with_args() will
4363 index
= of_property_match_string(np
, "clock-names", name
);
4364 ret
= of_parse_phandle_with_args(np
, "clocks", "#clock-cells",
4368 if (name
&& index
>= 0)
4372 * No matching clock found on this node. If the parent node
4373 * has a "clock-ranges" property, then we can try one of its
4377 if (np
&& !of_get_property(np
, "clock-ranges", NULL
))
4385 static struct clk_hw
*
4386 __of_clk_get_hw_from_provider(struct of_clk_provider
*provider
,
4387 struct of_phandle_args
*clkspec
)
4391 if (provider
->get_hw
)
4392 return provider
->get_hw(clkspec
, provider
->data
);
4394 clk
= provider
->get(clkspec
, provider
->data
);
4396 return ERR_CAST(clk
);
4397 return __clk_get_hw(clk
);
4400 static struct clk_hw
*
4401 of_clk_get_hw_from_clkspec(struct of_phandle_args
*clkspec
)
4403 struct of_clk_provider
*provider
;
4404 struct clk_hw
*hw
= ERR_PTR(-EPROBE_DEFER
);
4407 return ERR_PTR(-EINVAL
);
4409 mutex_lock(&of_clk_mutex
);
4410 list_for_each_entry(provider
, &of_clk_providers
, link
) {
4411 if (provider
->node
== clkspec
->np
) {
4412 hw
= __of_clk_get_hw_from_provider(provider
, clkspec
);
4417 mutex_unlock(&of_clk_mutex
);
4423 * of_clk_get_from_provider() - Lookup a clock from a clock provider
4424 * @clkspec: pointer to a clock specifier data structure
4426 * This function looks up a struct clk from the registered list of clock
4427 * providers, an input is a clock specifier data structure as returned
4428 * from the of_parse_phandle_with_args() function call.
4430 struct clk
*of_clk_get_from_provider(struct of_phandle_args
*clkspec
)
4432 struct clk_hw
*hw
= of_clk_get_hw_from_clkspec(clkspec
);
4434 return clk_hw_create_clk(NULL
, hw
, NULL
, __func__
);
4436 EXPORT_SYMBOL_GPL(of_clk_get_from_provider
);
4438 struct clk_hw
*of_clk_get_hw(struct device_node
*np
, int index
,
4443 struct of_phandle_args clkspec
;
4445 ret
= of_parse_clkspec(np
, index
, con_id
, &clkspec
);
4447 return ERR_PTR(ret
);
4449 hw
= of_clk_get_hw_from_clkspec(&clkspec
);
4450 of_node_put(clkspec
.np
);
4455 static struct clk
*__of_clk_get(struct device_node
*np
,
4456 int index
, const char *dev_id
,
4459 struct clk_hw
*hw
= of_clk_get_hw(np
, index
, con_id
);
4461 return clk_hw_create_clk(NULL
, hw
, dev_id
, con_id
);
4464 struct clk
*of_clk_get(struct device_node
*np
, int index
)
4466 return __of_clk_get(np
, index
, np
->full_name
, NULL
);
4468 EXPORT_SYMBOL(of_clk_get
);
4471 * of_clk_get_by_name() - Parse and lookup a clock referenced by a device node
4472 * @np: pointer to clock consumer node
4473 * @name: name of consumer's clock input, or NULL for the first clock reference
4475 * This function parses the clocks and clock-names properties,
4476 * and uses them to look up the struct clk from the registered list of clock
4479 struct clk
*of_clk_get_by_name(struct device_node
*np
, const char *name
)
4482 return ERR_PTR(-ENOENT
);
4484 return __of_clk_get(np
, 0, np
->full_name
, name
);
4486 EXPORT_SYMBOL(of_clk_get_by_name
);
4489 * of_clk_get_parent_count() - Count the number of clocks a device node has
4490 * @np: device node to count
4492 * Returns: The number of clocks that are possible parents of this node
4494 unsigned int of_clk_get_parent_count(struct device_node
*np
)
4498 count
= of_count_phandle_with_args(np
, "clocks", "#clock-cells");
4504 EXPORT_SYMBOL_GPL(of_clk_get_parent_count
);
4506 const char *of_clk_get_parent_name(struct device_node
*np
, int index
)
4508 struct of_phandle_args clkspec
;
4509 struct property
*prop
;
4510 const char *clk_name
;
4517 rc
= of_parse_phandle_with_args(np
, "clocks", "#clock-cells", index
,
4522 index
= clkspec
.args_count
? clkspec
.args
[0] : 0;
4525 /* if there is an indices property, use it to transfer the index
4526 * specified into an array offset for the clock-output-names property.
4528 of_property_for_each_u32(clkspec
.np
, "clock-indices", prop
, vp
, pv
) {
4535 /* We went off the end of 'clock-indices' without finding it */
4539 if (of_property_read_string_index(clkspec
.np
, "clock-output-names",
4543 * Best effort to get the name if the clock has been
4544 * registered with the framework. If the clock isn't
4545 * registered, we return the node name as the name of
4546 * the clock as long as #clock-cells = 0.
4548 clk
= of_clk_get_from_provider(&clkspec
);
4550 if (clkspec
.args_count
== 0)
4551 clk_name
= clkspec
.np
->name
;
4555 clk_name
= __clk_get_name(clk
);
4561 of_node_put(clkspec
.np
);
4564 EXPORT_SYMBOL_GPL(of_clk_get_parent_name
);
4567 * of_clk_parent_fill() - Fill @parents with names of @np's parents and return
4569 * @np: Device node pointer associated with clock provider
4570 * @parents: pointer to char array that hold the parents' names
4571 * @size: size of the @parents array
4573 * Return: number of parents for the clock node.
4575 int of_clk_parent_fill(struct device_node
*np
, const char **parents
,
4580 while (i
< size
&& (parents
[i
] = of_clk_get_parent_name(np
, i
)) != NULL
)
4585 EXPORT_SYMBOL_GPL(of_clk_parent_fill
);
4587 struct clock_provider
{
4588 void (*clk_init_cb
)(struct device_node
*);
4589 struct device_node
*np
;
4590 struct list_head node
;
4594 * This function looks for a parent clock. If there is one, then it
4595 * checks that the provider for this parent clock was initialized, in
4596 * this case the parent clock will be ready.
4598 static int parent_ready(struct device_node
*np
)
4603 struct clk
*clk
= of_clk_get(np
, i
);
4605 /* this parent is ready we can check the next one */
4612 /* at least one parent is not ready, we exit now */
4613 if (PTR_ERR(clk
) == -EPROBE_DEFER
)
4617 * Here we make assumption that the device tree is
4618 * written correctly. So an error means that there is
4619 * no more parent. As we didn't exit yet, then the
4620 * previous parent are ready. If there is no clock
4621 * parent, no need to wait for them, then we can
4622 * consider their absence as being ready
4629 * of_clk_detect_critical() - set CLK_IS_CRITICAL flag from Device Tree
4630 * @np: Device node pointer associated with clock provider
4631 * @index: clock index
4632 * @flags: pointer to top-level framework flags
4634 * Detects if the clock-critical property exists and, if so, sets the
4635 * corresponding CLK_IS_CRITICAL flag.
4637 * Do not use this function. It exists only for legacy Device Tree
4638 * bindings, such as the one-clock-per-node style that are outdated.
4639 * Those bindings typically put all clock data into .dts and the Linux
4640 * driver has no clock data, thus making it impossible to set this flag
4641 * correctly from the driver. Only those drivers may call
4642 * of_clk_detect_critical from their setup functions.
4644 * Return: error code or zero on success
4646 int of_clk_detect_critical(struct device_node
*np
,
4647 int index
, unsigned long *flags
)
4649 struct property
*prop
;
4656 of_property_for_each_u32(np
, "clock-critical", prop
, cur
, idx
)
4658 *flags
|= CLK_IS_CRITICAL
;
4664 * of_clk_init() - Scan and init clock providers from the DT
4665 * @matches: array of compatible values and init functions for providers.
4667 * This function scans the device tree for matching clock providers
4668 * and calls their initialization functions. It also does it by trying
4669 * to follow the dependencies.
4671 void __init
of_clk_init(const struct of_device_id
*matches
)
4673 const struct of_device_id
*match
;
4674 struct device_node
*np
;
4675 struct clock_provider
*clk_provider
, *next
;
4678 LIST_HEAD(clk_provider_list
);
4681 matches
= &__clk_of_table
;
4683 /* First prepare the list of the clocks providers */
4684 for_each_matching_node_and_match(np
, matches
, &match
) {
4685 struct clock_provider
*parent
;
4687 if (!of_device_is_available(np
))
4690 parent
= kzalloc(sizeof(*parent
), GFP_KERNEL
);
4692 list_for_each_entry_safe(clk_provider
, next
,
4693 &clk_provider_list
, node
) {
4694 list_del(&clk_provider
->node
);
4695 of_node_put(clk_provider
->np
);
4696 kfree(clk_provider
);
4702 parent
->clk_init_cb
= match
->data
;
4703 parent
->np
= of_node_get(np
);
4704 list_add_tail(&parent
->node
, &clk_provider_list
);
4707 while (!list_empty(&clk_provider_list
)) {
4708 is_init_done
= false;
4709 list_for_each_entry_safe(clk_provider
, next
,
4710 &clk_provider_list
, node
) {
4711 if (force
|| parent_ready(clk_provider
->np
)) {
4713 /* Don't populate platform devices */
4714 of_node_set_flag(clk_provider
->np
,
4717 clk_provider
->clk_init_cb(clk_provider
->np
);
4718 of_clk_set_defaults(clk_provider
->np
, true);
4720 list_del(&clk_provider
->node
);
4721 of_node_put(clk_provider
->np
);
4722 kfree(clk_provider
);
4723 is_init_done
= true;
4728 * We didn't manage to initialize any of the
4729 * remaining providers during the last loop, so now we
4730 * initialize all the remaining ones unconditionally
4731 * in case the clock parent was not mandatory