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