aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/clk/Kconfig40
-rw-r--r--drivers/clk/Makefile1
-rw-r--r--drivers/clk/clk.c1461
-rw-r--r--include/linux/clk-private.h72
-rw-r--r--include/linux/clk-provider.h173
-rw-r--r--include/linux/clk.h68
6 files changed, 1810 insertions, 5 deletions
diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig
index 9b3cd08cd0ed..2eaf17ed2791 100644
--- a/drivers/clk/Kconfig
+++ b/drivers/clk/Kconfig
@@ -8,3 +8,43 @@ config HAVE_CLK_PREPARE
8 8
9config HAVE_MACH_CLKDEV 9config HAVE_MACH_CLKDEV
10 bool 10 bool
11
12menuconfig COMMON_CLK
13 bool "Common Clock Framework"
14 select HAVE_CLK_PREPARE
15 ---help---
16 The common clock framework is a single definition of struct
17 clk, useful across many platforms, as well as an
18 implementation of the clock API in include/linux/clk.h.
19 Architectures utilizing the common struct clk should select
20 this automatically, but it may be necessary to manually select
21 this option for loadable modules requiring the common clock
22 framework.
23
24 If in doubt, say "N".
25
26if COMMON_CLK
27
28config COMMON_CLK_DISABLE_UNUSED
29 bool "Disabled unused clocks at boot"
30 depends on COMMON_CLK
31 ---help---
32 Traverses the entire clock tree and disables any clocks that are
33 enabled in hardware but have not been enabled by any device drivers.
34 This saves power and keeps the software model of the clock in line
35 with reality.
36
37 If in doubt, say "N".
38
39config COMMON_CLK_DEBUG
40 bool "DebugFS representation of clock tree"
41 depends on COMMON_CLK
42 select DEBUG_FS
43 ---help---
44 Creates a directory hierchy in debugfs for visualizing the clk
45 tree structure. Each directory contains read-only members
46 that export information specific to that clk node: clk_rate,
47 clk_flags, clk_prepare_count, clk_enable_count &
48 clk_notifier_count.
49
50endif
diff --git a/drivers/clk/Makefile b/drivers/clk/Makefile
index 07613fa172c9..ff362c4fb4c3 100644
--- a/drivers/clk/Makefile
+++ b/drivers/clk/Makefile
@@ -1,2 +1,3 @@
1 1
2obj-$(CONFIG_CLKDEV_LOOKUP) += clkdev.o 2obj-$(CONFIG_CLKDEV_LOOKUP) += clkdev.o
3obj-$(CONFIG_COMMON_CLK) += clk.o
diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
new file mode 100644
index 000000000000..9cf6f59e3e19
--- /dev/null
+++ b/drivers/clk/clk.c
@@ -0,0 +1,1461 @@
1/*
2 * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com>
3 * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Standard functionality for the common clock API. See Documentation/clk.txt
10 */
11
12#include <linux/clk-private.h>
13#include <linux/module.h>
14#include <linux/mutex.h>
15#include <linux/spinlock.h>
16#include <linux/err.h>
17#include <linux/list.h>
18#include <linux/slab.h>
19
20static DEFINE_SPINLOCK(enable_lock);
21static DEFINE_MUTEX(prepare_lock);
22
23static HLIST_HEAD(clk_root_list);
24static HLIST_HEAD(clk_orphan_list);
25static LIST_HEAD(clk_notifier_list);
26
27/*** debugfs support ***/
28
29#ifdef CONFIG_COMMON_CLK_DEBUG
30#include <linux/debugfs.h>
31
32static struct dentry *rootdir;
33static struct dentry *orphandir;
34static int inited = 0;
35
36/* caller must hold prepare_lock */
37static int clk_debug_create_one(struct clk *clk, struct dentry *pdentry)
38{
39 struct dentry *d;
40 int ret = -ENOMEM;
41
42 if (!clk || !pdentry) {
43 ret = -EINVAL;
44 goto out;
45 }
46
47 d = debugfs_create_dir(clk->name, pdentry);
48 if (!d)
49 goto out;
50
51 clk->dentry = d;
52
53 d = debugfs_create_u32("clk_rate", S_IRUGO, clk->dentry,
54 (u32 *)&clk->rate);
55 if (!d)
56 goto err_out;
57
58 d = debugfs_create_x32("clk_flags", S_IRUGO, clk->dentry,
59 (u32 *)&clk->flags);
60 if (!d)
61 goto err_out;
62
63 d = debugfs_create_u32("clk_prepare_count", S_IRUGO, clk->dentry,
64 (u32 *)&clk->prepare_count);
65 if (!d)
66 goto err_out;
67
68 d = debugfs_create_u32("clk_enable_count", S_IRUGO, clk->dentry,
69 (u32 *)&clk->enable_count);
70 if (!d)
71 goto err_out;
72
73 d = debugfs_create_u32("clk_notifier_count", S_IRUGO, clk->dentry,
74 (u32 *)&clk->notifier_count);
75 if (!d)
76 goto err_out;
77
78 ret = 0;
79 goto out;
80
81err_out:
82 debugfs_remove(clk->dentry);
83out:
84 return ret;
85}
86
87/* caller must hold prepare_lock */
88static int clk_debug_create_subtree(struct clk *clk, struct dentry *pdentry)
89{
90 struct clk *child;
91 struct hlist_node *tmp;
92 int ret = -EINVAL;;
93
94 if (!clk || !pdentry)
95 goto out;
96
97 ret = clk_debug_create_one(clk, pdentry);
98
99 if (ret)
100 goto out;
101
102 hlist_for_each_entry(child, tmp, &clk->children, child_node)
103 clk_debug_create_subtree(child, clk->dentry);
104
105 ret = 0;
106out:
107 return ret;
108}
109
110/**
111 * clk_debug_register - add a clk node to the debugfs clk tree
112 * @clk: the clk being added to the debugfs clk tree
113 *
114 * Dynamically adds a clk to the debugfs clk tree if debugfs has been
115 * initialized. Otherwise it bails out early since the debugfs clk tree
116 * will be created lazily by clk_debug_init as part of a late_initcall.
117 *
118 * Caller must hold prepare_lock. Only clk_init calls this function (so
119 * far) so this is taken care.
120 */
121static int clk_debug_register(struct clk *clk)
122{
123 struct clk *parent;
124 struct dentry *pdentry;
125 int ret = 0;
126
127 if (!inited)
128 goto out;
129
130 parent = clk->parent;
131
132 /*
133 * Check to see if a clk is a root clk. Also check that it is
134 * safe to add this clk to debugfs
135 */
136 if (!parent)
137 if (clk->flags & CLK_IS_ROOT)
138 pdentry = rootdir;
139 else
140 pdentry = orphandir;
141 else
142 if (parent->dentry)
143 pdentry = parent->dentry;
144 else
145 goto out;
146
147 ret = clk_debug_create_subtree(clk, pdentry);
148
149out:
150 return ret;
151}
152
153/**
154 * clk_debug_init - lazily create the debugfs clk tree visualization
155 *
156 * clks are often initialized very early during boot before memory can
157 * be dynamically allocated and well before debugfs is setup.
158 * clk_debug_init walks the clk tree hierarchy while holding
159 * prepare_lock and creates the topology as part of a late_initcall,
160 * thus insuring that clks initialized very early will still be
161 * represented in the debugfs clk tree. This function should only be
162 * called once at boot-time, and all other clks added dynamically will
163 * be done so with clk_debug_register.
164 */
165static int __init clk_debug_init(void)
166{
167 struct clk *clk;
168 struct hlist_node *tmp;
169
170 rootdir = debugfs_create_dir("clk", NULL);
171
172 if (!rootdir)
173 return -ENOMEM;
174
175 orphandir = debugfs_create_dir("orphans", rootdir);
176
177 if (!orphandir)
178 return -ENOMEM;
179
180 mutex_lock(&prepare_lock);
181
182 hlist_for_each_entry(clk, tmp, &clk_root_list, child_node)
183 clk_debug_create_subtree(clk, rootdir);
184
185 hlist_for_each_entry(clk, tmp, &clk_orphan_list, child_node)
186 clk_debug_create_subtree(clk, orphandir);
187
188 inited = 1;
189
190 mutex_unlock(&prepare_lock);
191
192 return 0;
193}
194late_initcall(clk_debug_init);
195#else
196static inline int clk_debug_register(struct clk *clk) { return 0; }
197#endif /* CONFIG_COMMON_CLK_DEBUG */
198
199#ifdef CONFIG_COMMON_CLK_DISABLE_UNUSED
200/* caller must hold prepare_lock */
201static void clk_disable_unused_subtree(struct clk *clk)
202{
203 struct clk *child;
204 struct hlist_node *tmp;
205 unsigned long flags;
206
207 if (!clk)
208 goto out;
209
210 hlist_for_each_entry(child, tmp, &clk->children, child_node)
211 clk_disable_unused_subtree(child);
212
213 spin_lock_irqsave(&enable_lock, flags);
214
215 if (clk->enable_count)
216 goto unlock_out;
217
218 if (clk->flags & CLK_IGNORE_UNUSED)
219 goto unlock_out;
220
221 if (__clk_is_enabled(clk) && clk->ops->disable)
222 clk->ops->disable(clk->hw);
223
224unlock_out:
225 spin_unlock_irqrestore(&enable_lock, flags);
226
227out:
228 return;
229}
230
231static int clk_disable_unused(void)
232{
233 struct clk *clk;
234 struct hlist_node *tmp;
235
236 mutex_lock(&prepare_lock);
237
238 hlist_for_each_entry(clk, tmp, &clk_root_list, child_node)
239 clk_disable_unused_subtree(clk);
240
241 hlist_for_each_entry(clk, tmp, &clk_orphan_list, child_node)
242 clk_disable_unused_subtree(clk);
243
244 mutex_unlock(&prepare_lock);
245
246 return 0;
247}
248late_initcall(clk_disable_unused);
249#else
250static inline int clk_disable_unused(struct clk *clk) { return 0; }
251#endif /* CONFIG_COMMON_CLK_DISABLE_UNUSED */
252
253/*** helper functions ***/
254
255inline const char *__clk_get_name(struct clk *clk)
256{
257 return !clk ? NULL : clk->name;
258}
259
260inline struct clk_hw *__clk_get_hw(struct clk *clk)
261{
262 return !clk ? NULL : clk->hw;
263}
264
265inline u8 __clk_get_num_parents(struct clk *clk)
266{
267 return !clk ? -EINVAL : clk->num_parents;
268}
269
270inline struct clk *__clk_get_parent(struct clk *clk)
271{
272 return !clk ? NULL : clk->parent;
273}
274
275inline int __clk_get_enable_count(struct clk *clk)
276{
277 return !clk ? -EINVAL : clk->enable_count;
278}
279
280inline int __clk_get_prepare_count(struct clk *clk)
281{
282 return !clk ? -EINVAL : clk->prepare_count;
283}
284
285unsigned long __clk_get_rate(struct clk *clk)
286{
287 unsigned long ret;
288
289 if (!clk) {
290 ret = -EINVAL;
291 goto out;
292 }
293
294 ret = clk->rate;
295
296 if (clk->flags & CLK_IS_ROOT)
297 goto out;
298
299 if (!clk->parent)
300 ret = -ENODEV;
301
302out:
303 return ret;
304}
305
306inline unsigned long __clk_get_flags(struct clk *clk)
307{
308 return !clk ? -EINVAL : clk->flags;
309}
310
311int __clk_is_enabled(struct clk *clk)
312{
313 int ret;
314
315 if (!clk)
316 return -EINVAL;
317
318 /*
319 * .is_enabled is only mandatory for clocks that gate
320 * fall back to software usage counter if .is_enabled is missing
321 */
322 if (!clk->ops->is_enabled) {
323 ret = clk->enable_count ? 1 : 0;
324 goto out;
325 }
326
327 ret = clk->ops->is_enabled(clk->hw);
328out:
329 return ret;
330}
331
332static struct clk *__clk_lookup_subtree(const char *name, struct clk *clk)
333{
334 struct clk *child;
335 struct clk *ret;
336 struct hlist_node *tmp;
337
338 if (!strcmp(clk->name, name))
339 return clk;
340
341 hlist_for_each_entry(child, tmp, &clk->children, child_node) {
342 ret = __clk_lookup_subtree(name, child);
343 if (ret)
344 return ret;
345 }
346
347 return NULL;
348}
349
350struct clk *__clk_lookup(const char *name)
351{
352 struct clk *root_clk;
353 struct clk *ret;
354 struct hlist_node *tmp;
355
356 if (!name)
357 return NULL;
358
359 /* search the 'proper' clk tree first */
360 hlist_for_each_entry(root_clk, tmp, &clk_root_list, child_node) {
361 ret = __clk_lookup_subtree(name, root_clk);
362 if (ret)
363 return ret;
364 }
365
366 /* if not found, then search the orphan tree */
367 hlist_for_each_entry(root_clk, tmp, &clk_orphan_list, child_node) {
368 ret = __clk_lookup_subtree(name, root_clk);
369 if (ret)
370 return ret;
371 }
372
373 return NULL;
374}
375
376/*** clk api ***/
377
378void __clk_unprepare(struct clk *clk)
379{
380 if (!clk)
381 return;
382
383 if (WARN_ON(clk->prepare_count == 0))
384 return;
385
386 if (--clk->prepare_count > 0)
387 return;
388
389 WARN_ON(clk->enable_count > 0);
390
391 if (clk->ops->unprepare)
392 clk->ops->unprepare(clk->hw);
393
394 __clk_unprepare(clk->parent);
395}
396
397/**
398 * clk_unprepare - undo preparation of a clock source
399 * @clk: the clk being unprepare
400 *
401 * clk_unprepare may sleep, which differentiates it from clk_disable. In a
402 * simple case, clk_unprepare can be used instead of clk_disable to gate a clk
403 * if the operation may sleep. One example is a clk which is accessed over
404 * I2c. In the complex case a clk gate operation may require a fast and a slow
405 * part. It is this reason that clk_unprepare and clk_disable are not mutually
406 * exclusive. In fact clk_disable must be called before clk_unprepare.
407 */
408void clk_unprepare(struct clk *clk)
409{
410 mutex_lock(&prepare_lock);
411 __clk_unprepare(clk);
412 mutex_unlock(&prepare_lock);
413}
414EXPORT_SYMBOL_GPL(clk_unprepare);
415
416int __clk_prepare(struct clk *clk)
417{
418 int ret = 0;
419
420 if (!clk)
421 return 0;
422
423 if (clk->prepare_count == 0) {
424 ret = __clk_prepare(clk->parent);
425 if (ret)
426 return ret;
427
428 if (clk->ops->prepare) {
429 ret = clk->ops->prepare(clk->hw);
430 if (ret) {
431 __clk_unprepare(clk->parent);
432 return ret;
433 }
434 }
435 }
436
437 clk->prepare_count++;
438
439 return 0;
440}
441
442/**
443 * clk_prepare - prepare a clock source
444 * @clk: the clk being prepared
445 *
446 * clk_prepare may sleep, which differentiates it from clk_enable. In a simple
447 * case, clk_prepare can be used instead of clk_enable to ungate a clk if the
448 * operation may sleep. One example is a clk which is accessed over I2c. In
449 * the complex case a clk ungate operation may require a fast and a slow part.
450 * It is this reason that clk_prepare and clk_enable are not mutually
451 * exclusive. In fact clk_prepare must be called before clk_enable.
452 * Returns 0 on success, -EERROR otherwise.
453 */
454int clk_prepare(struct clk *clk)
455{
456 int ret;
457
458 mutex_lock(&prepare_lock);
459 ret = __clk_prepare(clk);
460 mutex_unlock(&prepare_lock);
461
462 return ret;
463}
464EXPORT_SYMBOL_GPL(clk_prepare);
465
466static void __clk_disable(struct clk *clk)
467{
468 if (!clk)
469 return;
470
471 if (WARN_ON(clk->enable_count == 0))
472 return;
473
474 if (--clk->enable_count > 0)
475 return;
476
477 if (clk->ops->disable)
478 clk->ops->disable(clk->hw);
479
480 __clk_disable(clk->parent);
481}
482
483/**
484 * clk_disable - gate a clock
485 * @clk: the clk being gated
486 *
487 * clk_disable must not sleep, which differentiates it from clk_unprepare. In
488 * a simple case, clk_disable can be used instead of clk_unprepare to gate a
489 * clk if the operation is fast and will never sleep. One example is a
490 * SoC-internal clk which is controlled via simple register writes. In the
491 * complex case a clk gate operation may require a fast and a slow part. It is
492 * this reason that clk_unprepare and clk_disable are not mutually exclusive.
493 * In fact clk_disable must be called before clk_unprepare.
494 */
495void clk_disable(struct clk *clk)
496{
497 unsigned long flags;
498
499 spin_lock_irqsave(&enable_lock, flags);
500 __clk_disable(clk);
501 spin_unlock_irqrestore(&enable_lock, flags);
502}
503EXPORT_SYMBOL_GPL(clk_disable);
504
505static int __clk_enable(struct clk *clk)
506{
507 int ret = 0;
508
509 if (!clk)
510 return 0;
511
512 if (WARN_ON(clk->prepare_count == 0))
513 return -ESHUTDOWN;
514
515 if (clk->enable_count == 0) {
516 ret = __clk_enable(clk->parent);
517
518 if (ret)
519 return ret;
520
521 if (clk->ops->enable) {
522 ret = clk->ops->enable(clk->hw);
523 if (ret) {
524 __clk_disable(clk->parent);
525 return ret;
526 }
527 }
528 }
529
530 clk->enable_count++;
531 return 0;
532}
533
534/**
535 * clk_enable - ungate a clock
536 * @clk: the clk being ungated
537 *
538 * clk_enable must not sleep, which differentiates it from clk_prepare. In a
539 * simple case, clk_enable can be used instead of clk_prepare to ungate a clk
540 * if the operation will never sleep. One example is a SoC-internal clk which
541 * is controlled via simple register writes. In the complex case a clk ungate
542 * operation may require a fast and a slow part. It is this reason that
543 * clk_enable and clk_prepare are not mutually exclusive. In fact clk_prepare
544 * must be called before clk_enable. Returns 0 on success, -EERROR
545 * otherwise.
546 */
547int clk_enable(struct clk *clk)
548{
549 unsigned long flags;
550 int ret;
551
552 spin_lock_irqsave(&enable_lock, flags);
553 ret = __clk_enable(clk);
554 spin_unlock_irqrestore(&enable_lock, flags);
555
556 return ret;
557}
558EXPORT_SYMBOL_GPL(clk_enable);
559
560/**
561 * clk_get_rate - return the rate of clk
562 * @clk: the clk whose rate is being returned
563 *
564 * Simply returns the cached rate of the clk. Does not query the hardware. If
565 * clk is NULL then returns -EINVAL.
566 */
567unsigned long clk_get_rate(struct clk *clk)
568{
569 unsigned long rate;
570
571 mutex_lock(&prepare_lock);
572 rate = __clk_get_rate(clk);
573 mutex_unlock(&prepare_lock);
574
575 return rate;
576}
577EXPORT_SYMBOL_GPL(clk_get_rate);
578
579/**
580 * __clk_round_rate - round the given rate for a clk
581 * @clk: round the rate of this clock
582 *
583 * Caller must hold prepare_lock. Useful for clk_ops such as .set_rate
584 */
585unsigned long __clk_round_rate(struct clk *clk, unsigned long rate)
586{
587 unsigned long unused;
588
589 if (!clk)
590 return -EINVAL;
591
592 if (!clk->ops->round_rate)
593 return clk->rate;
594
595 if (clk->flags & CLK_SET_RATE_PARENT)
596 return clk->ops->round_rate(clk->hw, rate, &unused);
597 else
598 return clk->ops->round_rate(clk->hw, rate, NULL);
599}
600
601/**
602 * clk_round_rate - round the given rate for a clk
603 * @clk: the clk for which we are rounding a rate
604 * @rate: the rate which is to be rounded
605 *
606 * Takes in a rate as input and rounds it to a rate that the clk can actually
607 * use which is then returned. If clk doesn't support round_rate operation
608 * then the parent rate is returned.
609 */
610long clk_round_rate(struct clk *clk, unsigned long rate)
611{
612 unsigned long ret;
613
614 mutex_lock(&prepare_lock);
615 ret = __clk_round_rate(clk, rate);
616 mutex_unlock(&prepare_lock);
617
618 return ret;
619}
620EXPORT_SYMBOL_GPL(clk_round_rate);
621
622/**
623 * __clk_notify - call clk notifier chain
624 * @clk: struct clk * that is changing rate
625 * @msg: clk notifier type (see include/linux/clk.h)
626 * @old_rate: old clk rate
627 * @new_rate: new clk rate
628 *
629 * Triggers a notifier call chain on the clk rate-change notification
630 * for 'clk'. Passes a pointer to the struct clk and the previous
631 * and current rates to the notifier callback. Intended to be called by
632 * internal clock code only. Returns NOTIFY_DONE from the last driver
633 * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if
634 * a driver returns that.
635 */
636static int __clk_notify(struct clk *clk, unsigned long msg,
637 unsigned long old_rate, unsigned long new_rate)
638{
639 struct clk_notifier *cn;
640 struct clk_notifier_data cnd;
641 int ret = NOTIFY_DONE;
642
643 cnd.clk = clk;
644 cnd.old_rate = old_rate;
645 cnd.new_rate = new_rate;
646
647 list_for_each_entry(cn, &clk_notifier_list, node) {
648 if (cn->clk == clk) {
649 ret = srcu_notifier_call_chain(&cn->notifier_head, msg,
650 &cnd);
651 break;
652 }
653 }
654
655 return ret;
656}
657
658/**
659 * __clk_recalc_rates
660 * @clk: first clk in the subtree
661 * @msg: notification type (see include/linux/clk.h)
662 *
663 * Walks the subtree of clks starting with clk and recalculates rates as it
664 * goes. Note that if a clk does not implement the .recalc_rate callback then
665 * it is assumed that the clock will take on the rate of it's parent.
666 *
667 * clk_recalc_rates also propagates the POST_RATE_CHANGE notification,
668 * if necessary.
669 *
670 * Caller must hold prepare_lock.
671 */
672static void __clk_recalc_rates(struct clk *clk, unsigned long msg)
673{
674 unsigned long old_rate;
675 unsigned long parent_rate = 0;
676 struct hlist_node *tmp;
677 struct clk *child;
678
679 old_rate = clk->rate;
680
681 if (clk->parent)
682 parent_rate = clk->parent->rate;
683
684 if (clk->ops->recalc_rate)
685 clk->rate = clk->ops->recalc_rate(clk->hw, parent_rate);
686 else
687 clk->rate = parent_rate;
688
689 /*
690 * ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE
691 * & ABORT_RATE_CHANGE notifiers
692 */
693 if (clk->notifier_count && msg)
694 __clk_notify(clk, msg, old_rate, clk->rate);
695
696 hlist_for_each_entry(child, tmp, &clk->children, child_node)
697 __clk_recalc_rates(child, msg);
698}
699
700/**
701 * __clk_speculate_rates
702 * @clk: first clk in the subtree
703 * @parent_rate: the "future" rate of clk's parent
704 *
705 * Walks the subtree of clks starting with clk, speculating rates as it
706 * goes and firing off PRE_RATE_CHANGE notifications as necessary.
707 *
708 * Unlike clk_recalc_rates, clk_speculate_rates exists only for sending
709 * pre-rate change notifications and returns early if no clks in the
710 * subtree have subscribed to the notifications. Note that if a clk does not
711 * implement the .recalc_rate callback then it is assumed that the clock will
712 * take on the rate of it's parent.
713 *
714 * Caller must hold prepare_lock.
715 */
716static int __clk_speculate_rates(struct clk *clk, unsigned long parent_rate)
717{
718 struct hlist_node *tmp;
719 struct clk *child;
720 unsigned long new_rate;
721 int ret = NOTIFY_DONE;
722
723 if (clk->ops->recalc_rate)
724 new_rate = clk->ops->recalc_rate(clk->hw, parent_rate);
725 else
726 new_rate = parent_rate;
727
728 /* abort the rate change if a driver returns NOTIFY_BAD */
729 if (clk->notifier_count)
730 ret = __clk_notify(clk, PRE_RATE_CHANGE, clk->rate, new_rate);
731
732 if (ret == NOTIFY_BAD)
733 goto out;
734
735 hlist_for_each_entry(child, tmp, &clk->children, child_node) {
736 ret = __clk_speculate_rates(child, new_rate);
737 if (ret == NOTIFY_BAD)
738 break;
739 }
740
741out:
742 return ret;
743}
744
745static void clk_calc_subtree(struct clk *clk, unsigned long new_rate)
746{
747 struct clk *child;
748 struct hlist_node *tmp;
749
750 clk->new_rate = new_rate;
751
752 hlist_for_each_entry(child, tmp, &clk->children, child_node) {
753 if (child->ops->recalc_rate)
754 child->new_rate = child->ops->recalc_rate(child->hw, new_rate);
755 else
756 child->new_rate = new_rate;
757 clk_calc_subtree(child, child->new_rate);
758 }
759}
760
761/*
762 * calculate the new rates returning the topmost clock that has to be
763 * changed.
764 */
765static struct clk *clk_calc_new_rates(struct clk *clk, unsigned long rate)
766{
767 struct clk *top = clk;
768 unsigned long best_parent_rate = clk->parent->rate;
769 unsigned long new_rate;
770
771 if (!clk->ops->round_rate && !(clk->flags & CLK_SET_RATE_PARENT)) {
772 clk->new_rate = clk->rate;
773 return NULL;
774 }
775
776 if (!clk->ops->round_rate && (clk->flags & CLK_SET_RATE_PARENT)) {
777 top = clk_calc_new_rates(clk->parent, rate);
778 new_rate = clk->new_rate = clk->parent->new_rate;
779
780 goto out;
781 }
782
783 if (clk->flags & CLK_SET_RATE_PARENT)
784 new_rate = clk->ops->round_rate(clk->hw, rate, &best_parent_rate);
785 else
786 new_rate = clk->ops->round_rate(clk->hw, rate, NULL);
787
788 if (best_parent_rate != clk->parent->rate) {
789 top = clk_calc_new_rates(clk->parent, best_parent_rate);
790
791 goto out;
792 }
793
794out:
795 clk_calc_subtree(clk, new_rate);
796
797 return top;
798}
799
800/*
801 * Notify about rate changes in a subtree. Always walk down the whole tree
802 * so that in case of an error we can walk down the whole tree again and
803 * abort the change.
804 */
805static struct clk *clk_propagate_rate_change(struct clk *clk, unsigned long event)
806{
807 struct hlist_node *tmp;
808 struct clk *child, *fail_clk = NULL;
809 int ret = NOTIFY_DONE;
810
811 if (clk->rate == clk->new_rate)
812 return 0;
813
814 if (clk->notifier_count) {
815 ret = __clk_notify(clk, event, clk->rate, clk->new_rate);
816 if (ret == NOTIFY_BAD)
817 fail_clk = clk;
818 }
819
820 hlist_for_each_entry(child, tmp, &clk->children, child_node) {
821 clk = clk_propagate_rate_change(child, event);
822 if (clk)
823 fail_clk = clk;
824 }
825
826 return fail_clk;
827}
828
829/*
830 * walk down a subtree and set the new rates notifying the rate
831 * change on the way
832 */
833static void clk_change_rate(struct clk *clk)
834{
835 struct clk *child;
836 unsigned long old_rate;
837 struct hlist_node *tmp;
838
839 old_rate = clk->rate;
840
841 if (clk->ops->set_rate)
842 clk->ops->set_rate(clk->hw, clk->new_rate);
843
844 if (clk->ops->recalc_rate)
845 clk->rate = clk->ops->recalc_rate(clk->hw,
846 clk->parent->rate);
847 else
848 clk->rate = clk->parent->rate;
849
850 if (clk->notifier_count && old_rate != clk->rate)
851 __clk_notify(clk, POST_RATE_CHANGE, old_rate, clk->rate);
852
853 hlist_for_each_entry(child, tmp, &clk->children, child_node)
854 clk_change_rate(child);
855}
856
857/**
858 * clk_set_rate - specify a new rate for clk
859 * @clk: the clk whose rate is being changed
860 * @rate: the new rate for clk
861 *
862 * In the simplest case clk_set_rate will only change the rate of clk.
863 *
864 * If clk has the CLK_SET_RATE_GATE flag set and it is enabled this call
865 * will fail; only when the clk is disabled will it be able to change
866 * its rate.
867 *
868 * Setting the CLK_SET_RATE_PARENT flag allows clk_set_rate to
869 * recursively propagate up to clk's parent; whether or not this happens
870 * depends on the outcome of clk's .round_rate implementation. If
871 * *parent_rate is 0 after calling .round_rate then upstream parent
872 * propagation is ignored. If *parent_rate comes back with a new rate
873 * for clk's parent then we propagate up to clk's parent and set it's
874 * rate. Upward propagation will continue until either a clk does not
875 * support the CLK_SET_RATE_PARENT flag or .round_rate stops requesting
876 * changes to clk's parent_rate. If there is a failure during upstream
877 * propagation then clk_set_rate will unwind and restore each clk's rate
878 * that had been successfully changed. Afterwards a rate change abort
879 * notification will be propagated downstream, starting from the clk
880 * that failed.
881 *
882 * At the end of all of the rate setting, clk_set_rate internally calls
883 * __clk_recalc_rates and propagates the rate changes downstream,
884 * starting from the highest clk whose rate was changed. This has the
885 * added benefit of propagating post-rate change notifiers.
886 *
887 * Note that while post-rate change and rate change abort notifications
888 * are guaranteed to be sent to a clk only once per call to
889 * clk_set_rate, pre-change notifications will be sent for every clk
890 * whose rate is changed. Stacking pre-change notifications is noisy
891 * for the drivers subscribed to them, but this allows drivers to react
892 * to intermediate clk rate changes up until the point where the final
893 * rate is achieved at the end of upstream propagation.
894 *
895 * Returns 0 on success, -EERROR otherwise.
896 */
897int clk_set_rate(struct clk *clk, unsigned long rate)
898{
899 struct clk *top, *fail_clk;
900 int ret = 0;
901
902 /* prevent racing with updates to the clock topology */
903 mutex_lock(&prepare_lock);
904
905 /* bail early if nothing to do */
906 if (rate == clk->rate)
907 goto out;
908
909 /* calculate new rates and get the topmost changed clock */
910 top = clk_calc_new_rates(clk, rate);
911 if (!top) {
912 ret = -EINVAL;
913 goto out;
914 }
915
916 /* notify that we are about to change rates */
917 fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
918 if (fail_clk) {
919 pr_warn("%s: failed to set %s rate\n", __func__,
920 fail_clk->name);
921 clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
922 ret = -EBUSY;
923 goto out;
924 }
925
926 /* change the rates */
927 clk_change_rate(top);
928
929 mutex_unlock(&prepare_lock);
930
931 return 0;
932out:
933 mutex_unlock(&prepare_lock);
934
935 return ret;
936}
937EXPORT_SYMBOL_GPL(clk_set_rate);
938
939/**
940 * clk_get_parent - return the parent of a clk
941 * @clk: the clk whose parent gets returned
942 *
943 * Simply returns clk->parent. Returns NULL if clk is NULL.
944 */
945struct clk *clk_get_parent(struct clk *clk)
946{
947 struct clk *parent;
948
949 mutex_lock(&prepare_lock);
950 parent = __clk_get_parent(clk);
951 mutex_unlock(&prepare_lock);
952
953 return parent;
954}
955EXPORT_SYMBOL_GPL(clk_get_parent);
956
957/*
958 * .get_parent is mandatory for clocks with multiple possible parents. It is
959 * optional for single-parent clocks. Always call .get_parent if it is
960 * available and WARN if it is missing for multi-parent clocks.
961 *
962 * For single-parent clocks without .get_parent, first check to see if the
963 * .parents array exists, and if so use it to avoid an expensive tree
964 * traversal. If .parents does not exist then walk the tree with __clk_lookup.
965 */
966static struct clk *__clk_init_parent(struct clk *clk)
967{
968 struct clk *ret = NULL;
969 u8 index;
970
971 /* handle the trivial cases */
972
973 if (!clk->num_parents)
974 goto out;
975
976 if (clk->num_parents == 1) {
977 if (IS_ERR_OR_NULL(clk->parent))
978 ret = clk->parent = __clk_lookup(clk->parent_names[0]);
979 ret = clk->parent;
980 goto out;
981 }
982
983 if (!clk->ops->get_parent) {
984 WARN(!clk->ops->get_parent,
985 "%s: multi-parent clocks must implement .get_parent\n",
986 __func__);
987 goto out;
988 };
989
990 /*
991 * Do our best to cache parent clocks in clk->parents. This prevents
992 * unnecessary and expensive calls to __clk_lookup. We don't set
993 * clk->parent here; that is done by the calling function
994 */
995
996 index = clk->ops->get_parent(clk->hw);
997
998 if (!clk->parents)
999 clk->parents =
1000 kmalloc((sizeof(struct clk*) * clk->num_parents),
1001 GFP_KERNEL);
1002
1003 if (!clk->parents)
1004 ret = __clk_lookup(clk->parent_names[index]);
1005 else if (!clk->parents[index])
1006 ret = clk->parents[index] =
1007 __clk_lookup(clk->parent_names[index]);
1008 else
1009 ret = clk->parents[index];
1010
1011out:
1012 return ret;
1013}
1014
1015void __clk_reparent(struct clk *clk, struct clk *new_parent)
1016{
1017#ifdef CONFIG_COMMON_CLK_DEBUG
1018 struct dentry *d;
1019 struct dentry *new_parent_d;
1020#endif
1021
1022 if (!clk || !new_parent)
1023 return;
1024
1025 hlist_del(&clk->child_node);
1026
1027 if (new_parent)
1028 hlist_add_head(&clk->child_node, &new_parent->children);
1029 else
1030 hlist_add_head(&clk->child_node, &clk_orphan_list);
1031
1032#ifdef CONFIG_COMMON_CLK_DEBUG
1033 if (!inited)
1034 goto out;
1035
1036 if (new_parent)
1037 new_parent_d = new_parent->dentry;
1038 else
1039 new_parent_d = orphandir;
1040
1041 d = debugfs_rename(clk->dentry->d_parent, clk->dentry,
1042 new_parent_d, clk->name);
1043 if (d)
1044 clk->dentry = d;
1045 else
1046 pr_debug("%s: failed to rename debugfs entry for %s\n",
1047 __func__, clk->name);
1048out:
1049#endif
1050
1051 clk->parent = new_parent;
1052
1053 __clk_recalc_rates(clk, POST_RATE_CHANGE);
1054}
1055
1056static int __clk_set_parent(struct clk *clk, struct clk *parent)
1057{
1058 struct clk *old_parent;
1059 unsigned long flags;
1060 int ret = -EINVAL;
1061 u8 i;
1062
1063 old_parent = clk->parent;
1064
1065 /* find index of new parent clock using cached parent ptrs */
1066 for (i = 0; i < clk->num_parents; i++)
1067 if (clk->parents[i] == parent)
1068 break;
1069
1070 /*
1071 * find index of new parent clock using string name comparison
1072 * also try to cache the parent to avoid future calls to __clk_lookup
1073 */
1074 if (i == clk->num_parents)
1075 for (i = 0; i < clk->num_parents; i++)
1076 if (!strcmp(clk->parent_names[i], parent->name)) {
1077 clk->parents[i] = __clk_lookup(parent->name);
1078 break;
1079 }
1080
1081 if (i == clk->num_parents) {
1082 pr_debug("%s: clock %s is not a possible parent of clock %s\n",
1083 __func__, parent->name, clk->name);
1084 goto out;
1085 }
1086
1087 /* migrate prepare and enable */
1088 if (clk->prepare_count)
1089 __clk_prepare(parent);
1090
1091 /* FIXME replace with clk_is_enabled(clk) someday */
1092 spin_lock_irqsave(&enable_lock, flags);
1093 if (clk->enable_count)
1094 __clk_enable(parent);
1095 spin_unlock_irqrestore(&enable_lock, flags);
1096
1097 /* change clock input source */
1098 ret = clk->ops->set_parent(clk->hw, i);
1099
1100 /* clean up old prepare and enable */
1101 spin_lock_irqsave(&enable_lock, flags);
1102 if (clk->enable_count)
1103 __clk_disable(old_parent);
1104 spin_unlock_irqrestore(&enable_lock, flags);
1105
1106 if (clk->prepare_count)
1107 __clk_unprepare(old_parent);
1108
1109out:
1110 return ret;
1111}
1112
1113/**
1114 * clk_set_parent - switch the parent of a mux clk
1115 * @clk: the mux clk whose input we are switching
1116 * @parent: the new input to clk
1117 *
1118 * Re-parent clk to use parent as it's new input source. If clk has the
1119 * CLK_SET_PARENT_GATE flag set then clk must be gated for this
1120 * operation to succeed. After successfully changing clk's parent
1121 * clk_set_parent will update the clk topology, sysfs topology and
1122 * propagate rate recalculation via __clk_recalc_rates. Returns 0 on
1123 * success, -EERROR otherwise.
1124 */
1125int clk_set_parent(struct clk *clk, struct clk *parent)
1126{
1127 int ret = 0;
1128
1129 if (!clk || !clk->ops)
1130 return -EINVAL;
1131
1132 if (!clk->ops->set_parent)
1133 return -ENOSYS;
1134
1135 /* prevent racing with updates to the clock topology */
1136 mutex_lock(&prepare_lock);
1137
1138 if (clk->parent == parent)
1139 goto out;
1140
1141 /* propagate PRE_RATE_CHANGE notifications */
1142 if (clk->notifier_count)
1143 ret = __clk_speculate_rates(clk, parent->rate);
1144
1145 /* abort if a driver objects */
1146 if (ret == NOTIFY_STOP)
1147 goto out;
1148
1149 /* only re-parent if the clock is not in use */
1150 if ((clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count)
1151 ret = -EBUSY;
1152 else
1153 ret = __clk_set_parent(clk, parent);
1154
1155 /* propagate ABORT_RATE_CHANGE if .set_parent failed */
1156 if (ret) {
1157 __clk_recalc_rates(clk, ABORT_RATE_CHANGE);
1158 goto out;
1159 }
1160
1161 /* propagate rate recalculation downstream */
1162 __clk_reparent(clk, parent);
1163
1164out:
1165 mutex_unlock(&prepare_lock);
1166
1167 return ret;
1168}
1169EXPORT_SYMBOL_GPL(clk_set_parent);
1170
1171/**
1172 * __clk_init - initialize the data structures in a struct clk
1173 * @dev: device initializing this clk, placeholder for now
1174 * @clk: clk being initialized
1175 *
1176 * Initializes the lists in struct clk, queries the hardware for the
1177 * parent and rate and sets them both.
1178 *
1179 * Any struct clk passed into __clk_init must have the following members
1180 * populated:
1181 * .name
1182 * .ops
1183 * .hw
1184 * .parent_names
1185 * .num_parents
1186 * .flags
1187 *
1188 * Essentially, everything that would normally be passed into clk_register is
1189 * assumed to be initialized already in __clk_init. The other members may be
1190 * populated, but are optional.
1191 *
1192 * __clk_init is only exposed via clk-private.h and is intended for use with
1193 * very large numbers of clocks that need to be statically initialized. It is
1194 * a layering violation to include clk-private.h from any code which implements
1195 * a clock's .ops; as such any statically initialized clock data MUST be in a
1196 * separate C file from the logic that implements it's operations.
1197 */
1198void __clk_init(struct device *dev, struct clk *clk)
1199{
1200 int i;
1201 struct clk *orphan;
1202 struct hlist_node *tmp, *tmp2;
1203
1204 if (!clk)
1205 return;
1206
1207 mutex_lock(&prepare_lock);
1208
1209 /* check to see if a clock with this name is already registered */
1210 if (__clk_lookup(clk->name))
1211 goto out;
1212
1213 /* throw a WARN if any entries in parent_names are NULL */
1214 for (i = 0; i < clk->num_parents; i++)
1215 WARN(!clk->parent_names[i],
1216 "%s: invalid NULL in %s's .parent_names\n",
1217 __func__, clk->name);
1218
1219 /*
1220 * Allocate an array of struct clk *'s to avoid unnecessary string
1221 * look-ups of clk's possible parents. This can fail for clocks passed
1222 * in to clk_init during early boot; thus any access to clk->parents[]
1223 * must always check for a NULL pointer and try to populate it if
1224 * necessary.
1225 *
1226 * If clk->parents is not NULL we skip this entire block. This allows
1227 * for clock drivers to statically initialize clk->parents.
1228 */
1229 if (clk->num_parents && !clk->parents) {
1230 clk->parents = kmalloc((sizeof(struct clk*) * clk->num_parents),
1231 GFP_KERNEL);
1232 /*
1233 * __clk_lookup returns NULL for parents that have not been
1234 * clk_init'd; thus any access to clk->parents[] must check
1235 * for a NULL pointer. We can always perform lazy lookups for
1236 * missing parents later on.
1237 */
1238 if (clk->parents)
1239 for (i = 0; i < clk->num_parents; i++)
1240 clk->parents[i] =
1241 __clk_lookup(clk->parent_names[i]);
1242 }
1243
1244 clk->parent = __clk_init_parent(clk);
1245
1246 /*
1247 * Populate clk->parent if parent has already been __clk_init'd. If
1248 * parent has not yet been __clk_init'd then place clk in the orphan
1249 * list. If clk has set the CLK_IS_ROOT flag then place it in the root
1250 * clk list.
1251 *
1252 * Every time a new clk is clk_init'd then we walk the list of orphan
1253 * clocks and re-parent any that are children of the clock currently
1254 * being clk_init'd.
1255 */
1256 if (clk->parent)
1257 hlist_add_head(&clk->child_node,
1258 &clk->parent->children);
1259 else if (clk->flags & CLK_IS_ROOT)
1260 hlist_add_head(&clk->child_node, &clk_root_list);
1261 else
1262 hlist_add_head(&clk->child_node, &clk_orphan_list);
1263
1264 /*
1265 * Set clk's rate. The preferred method is to use .recalc_rate. For
1266 * simple clocks and lazy developers the default fallback is to use the
1267 * parent's rate. If a clock doesn't have a parent (or is orphaned)
1268 * then rate is set to zero.
1269 */
1270 if (clk->ops->recalc_rate)
1271 clk->rate = clk->ops->recalc_rate(clk->hw,
1272 __clk_get_rate(clk->parent));
1273 else if (clk->parent)
1274 clk->rate = clk->parent->rate;
1275 else
1276 clk->rate = 0;
1277
1278 /*
1279 * walk the list of orphan clocks and reparent any that are children of
1280 * this clock
1281 */
1282 hlist_for_each_entry_safe(orphan, tmp, tmp2, &clk_orphan_list, child_node)
1283 for (i = 0; i < orphan->num_parents; i++)
1284 if (!strcmp(clk->name, orphan->parent_names[i])) {
1285 __clk_reparent(orphan, clk);
1286 break;
1287 }
1288
1289 /*
1290 * optional platform-specific magic
1291 *
1292 * The .init callback is not used by any of the basic clock types, but
1293 * exists for weird hardware that must perform initialization magic.
1294 * Please consider other ways of solving initialization problems before
1295 * using this callback, as it's use is discouraged.
1296 */
1297 if (clk->ops->init)
1298 clk->ops->init(clk->hw);
1299
1300 clk_debug_register(clk);
1301
1302out:
1303 mutex_unlock(&prepare_lock);
1304
1305 return;
1306}
1307
1308/**
1309 * clk_register - allocate a new clock, register it and return an opaque cookie
1310 * @dev: device that is registering this clock
1311 * @name: clock name
1312 * @ops: operations this clock supports
1313 * @hw: link to hardware-specific clock data
1314 * @parent_names: array of string names for all possible parents
1315 * @num_parents: number of possible parents
1316 * @flags: framework-level hints and quirks
1317 *
1318 * clk_register is the primary interface for populating the clock tree with new
1319 * clock nodes. It returns a pointer to the newly allocated struct clk which
1320 * cannot be dereferenced by driver code but may be used in conjuction with the
1321 * rest of the clock API.
1322 */
1323struct clk *clk_register(struct device *dev, const char *name,
1324 const struct clk_ops *ops, struct clk_hw *hw,
1325 char **parent_names, u8 num_parents, unsigned long flags)
1326{
1327 struct clk *clk;
1328
1329 clk = kzalloc(sizeof(*clk), GFP_KERNEL);
1330 if (!clk)
1331 return NULL;
1332
1333 clk->name = name;
1334 clk->ops = ops;
1335 clk->hw = hw;
1336 clk->flags = flags;
1337 clk->parent_names = parent_names;
1338 clk->num_parents = num_parents;
1339 hw->clk = clk;
1340
1341 __clk_init(dev, clk);
1342
1343 return clk;
1344}
1345EXPORT_SYMBOL_GPL(clk_register);
1346
1347/*** clk rate change notifiers ***/
1348
1349/**
1350 * clk_notifier_register - add a clk rate change notifier
1351 * @clk: struct clk * to watch
1352 * @nb: struct notifier_block * with callback info
1353 *
1354 * Request notification when clk's rate changes. This uses an SRCU
1355 * notifier because we want it to block and notifier unregistrations are
1356 * uncommon. The callbacks associated with the notifier must not
1357 * re-enter into the clk framework by calling any top-level clk APIs;
1358 * this will cause a nested prepare_lock mutex.
1359 *
1360 * Pre-change notifier callbacks will be passed the current, pre-change
1361 * rate of the clk via struct clk_notifier_data.old_rate. The new,
1362 * post-change rate of the clk is passed via struct
1363 * clk_notifier_data.new_rate.
1364 *
1365 * Post-change notifiers will pass the now-current, post-change rate of
1366 * the clk in both struct clk_notifier_data.old_rate and struct
1367 * clk_notifier_data.new_rate.
1368 *
1369 * Abort-change notifiers are effectively the opposite of pre-change
1370 * notifiers: the original pre-change clk rate is passed in via struct
1371 * clk_notifier_data.new_rate and the failed post-change rate is passed
1372 * in via struct clk_notifier_data.old_rate.
1373 *
1374 * clk_notifier_register() must be called from non-atomic context.
1375 * Returns -EINVAL if called with null arguments, -ENOMEM upon
1376 * allocation failure; otherwise, passes along the return value of
1377 * srcu_notifier_chain_register().
1378 */
1379int clk_notifier_register(struct clk *clk, struct notifier_block *nb)
1380{
1381 struct clk_notifier *cn;
1382 int ret = -ENOMEM;
1383
1384 if (!clk || !nb)
1385 return -EINVAL;
1386
1387 mutex_lock(&prepare_lock);
1388
1389 /* search the list of notifiers for this clk */
1390 list_for_each_entry(cn, &clk_notifier_list, node)
1391 if (cn->clk == clk)
1392 break;
1393
1394 /* if clk wasn't in the notifier list, allocate new clk_notifier */
1395 if (cn->clk != clk) {
1396 cn = kzalloc(sizeof(struct clk_notifier), GFP_KERNEL);
1397 if (!cn)
1398 goto out;
1399
1400 cn->clk = clk;
1401 srcu_init_notifier_head(&cn->notifier_head);
1402
1403 list_add(&cn->node, &clk_notifier_list);
1404 }
1405
1406 ret = srcu_notifier_chain_register(&cn->notifier_head, nb);
1407
1408 clk->notifier_count++;
1409
1410out:
1411 mutex_unlock(&prepare_lock);
1412
1413 return ret;
1414}
1415EXPORT_SYMBOL_GPL(clk_notifier_register);
1416
1417/**
1418 * clk_notifier_unregister - remove a clk rate change notifier
1419 * @clk: struct clk *
1420 * @nb: struct notifier_block * with callback info
1421 *
1422 * Request no further notification for changes to 'clk' and frees memory
1423 * allocated in clk_notifier_register.
1424 *
1425 * Returns -EINVAL if called with null arguments; otherwise, passes
1426 * along the return value of srcu_notifier_chain_unregister().
1427 */
1428int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb)
1429{
1430 struct clk_notifier *cn = NULL;
1431 int ret = -EINVAL;
1432
1433 if (!clk || !nb)
1434 return -EINVAL;
1435
1436 mutex_lock(&prepare_lock);
1437
1438 list_for_each_entry(cn, &clk_notifier_list, node)
1439 if (cn->clk == clk)
1440 break;
1441
1442 if (cn->clk == clk) {
1443 ret = srcu_notifier_chain_unregister(&cn->notifier_head, nb);
1444
1445 clk->notifier_count--;
1446
1447 /* XXX the notifier code should handle this better */
1448 if (!cn->notifier_head.head) {
1449 srcu_cleanup_notifier_head(&cn->notifier_head);
1450 kfree(cn);
1451 }
1452
1453 } else {
1454 ret = -ENOENT;
1455 }
1456
1457 mutex_unlock(&prepare_lock);
1458
1459 return ret;
1460}
1461EXPORT_SYMBOL_GPL(clk_notifier_unregister);
diff --git a/include/linux/clk-private.h b/include/linux/clk-private.h
new file mode 100644
index 000000000000..e2cce6fa6046
--- /dev/null
+++ b/include/linux/clk-private.h
@@ -0,0 +1,72 @@
1/*
2 * linux/include/linux/clk-private.h
3 *
4 * Copyright (c) 2010-2011 Jeremy Kerr <jeremy.kerr@canonical.com>
5 * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11#ifndef __LINUX_CLK_PRIVATE_H
12#define __LINUX_CLK_PRIVATE_H
13
14#include <linux/clk-provider.h>
15#include <linux/list.h>
16
17/*
18 * WARNING: Do not include clk-private.h from any file that implements struct
19 * clk_ops. Doing so is a layering violation!
20 *
21 * This header exists only to allow for statically initialized clock data. Any
22 * static clock data must be defined in a separate file from the logic that
23 * implements the clock operations for that same data.
24 */
25
26#ifdef CONFIG_COMMON_CLK
27
28struct clk {
29 const char *name;
30 const struct clk_ops *ops;
31 struct clk_hw *hw;
32 struct clk *parent;
33 char **parent_names;
34 struct clk **parents;
35 u8 num_parents;
36 unsigned long rate;
37 unsigned long new_rate;
38 unsigned long flags;
39 unsigned int enable_count;
40 unsigned int prepare_count;
41 struct hlist_head children;
42 struct hlist_node child_node;
43 unsigned int notifier_count;
44#ifdef CONFIG_COMMON_CLK_DEBUG
45 struct dentry *dentry;
46#endif
47};
48
49/**
50 * __clk_init - initialize the data structures in a struct clk
51 * @dev: device initializing this clk, placeholder for now
52 * @clk: clk being initialized
53 *
54 * Initializes the lists in struct clk, queries the hardware for the
55 * parent and rate and sets them both.
56 *
57 * Any struct clk passed into __clk_init must have the following members
58 * populated:
59 * .name
60 * .ops
61 * .hw
62 * .parent_names
63 * .num_parents
64 * .flags
65 *
66 * It is not necessary to call clk_register if __clk_init is used directly with
67 * statically initialized clock data.
68 */
69void __clk_init(struct device *dev, struct clk *clk);
70
71#endif /* CONFIG_COMMON_CLK */
72#endif /* CLK_PRIVATE_H */
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
new file mode 100644
index 000000000000..b18b0e7888a8
--- /dev/null
+++ b/include/linux/clk-provider.h
@@ -0,0 +1,173 @@
1/*
2 * linux/include/linux/clk-provider.h
3 *
4 * Copyright (c) 2010-2011 Jeremy Kerr <jeremy.kerr@canonical.com>
5 * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11#ifndef __LINUX_CLK_PROVIDER_H
12#define __LINUX_CLK_PROVIDER_H
13
14#include <linux/clk.h>
15
16#ifdef CONFIG_COMMON_CLK
17
18/**
19 * struct clk_hw - handle for traversing from a struct clk to its corresponding
20 * hardware-specific structure. struct clk_hw should be declared within struct
21 * clk_foo and then referenced by the struct clk instance that uses struct
22 * clk_foo's clk_ops
23 *
24 * clk: pointer to the struct clk instance that points back to this struct
25 * clk_hw instance
26 */
27struct clk_hw {
28 struct clk *clk;
29};
30
31/*
32 * flags used across common struct clk. these flags should only affect the
33 * top-level framework. custom flags for dealing with hardware specifics
34 * belong in struct clk_foo
35 */
36#define CLK_SET_RATE_GATE BIT(0) /* must be gated across rate change */
37#define CLK_SET_PARENT_GATE BIT(1) /* must be gated across re-parent */
38#define CLK_SET_RATE_PARENT BIT(2) /* propagate rate change up one level */
39#define CLK_IGNORE_UNUSED BIT(3) /* do not gate even if unused */
40#define CLK_IS_ROOT BIT(4) /* root clk, has no parent */
41
42/**
43 * struct clk_ops - Callback operations for hardware clocks; these are to
44 * be provided by the clock implementation, and will be called by drivers
45 * through the clk_* api.
46 *
47 * @prepare: Prepare the clock for enabling. This must not return until
48 * the clock is fully prepared, and it's safe to call clk_enable.
49 * This callback is intended to allow clock implementations to
50 * do any initialisation that may sleep. Called with
51 * prepare_lock held.
52 *
53 * @unprepare: Release the clock from its prepared state. This will typically
54 * undo any work done in the @prepare callback. Called with
55 * prepare_lock held.
56 *
57 * @enable: Enable the clock atomically. This must not return until the
58 * clock is generating a valid clock signal, usable by consumer
59 * devices. Called with enable_lock held. This function must not
60 * sleep.
61 *
62 * @disable: Disable the clock atomically. Called with enable_lock held.
63 * This function must not sleep.
64 *
65 * @recalc_rate Recalculate the rate of this clock, by quering hardware. The
66 * parent rate is an input parameter. It is up to the caller to
67 * insure that the prepare_mutex is held across this call.
68 * Returns the calculated rate. Optional, but recommended - if
69 * this op is not set then clock rate will be initialized to 0.
70 *
71 * @round_rate: Given a target rate as input, returns the closest rate actually
72 * supported by the clock.
73 *
74 * @get_parent: Queries the hardware to determine the parent of a clock. The
75 * return value is a u8 which specifies the index corresponding to
76 * the parent clock. This index can be applied to either the
77 * .parent_names or .parents arrays. In short, this function
78 * translates the parent value read from hardware into an array
79 * index. Currently only called when the clock is initialized by
80 * __clk_init. This callback is mandatory for clocks with
81 * multiple parents. It is optional (and unnecessary) for clocks
82 * with 0 or 1 parents.
83 *
84 * @set_parent: Change the input source of this clock; for clocks with multiple
85 * possible parents specify a new parent by passing in the index
86 * as a u8 corresponding to the parent in either the .parent_names
87 * or .parents arrays. This function in affect translates an
88 * array index into the value programmed into the hardware.
89 * Returns 0 on success, -EERROR otherwise.
90 *
91 * @set_rate: Change the rate of this clock. If this callback returns
92 * CLK_SET_RATE_PARENT, the rate change will be propagated to the
93 * parent clock (which may propagate again if the parent clock
94 * also sets this flag). The requested rate of the parent is
95 * passed back from the callback in the second 'unsigned long *'
96 * argument. Note that it is up to the hardware clock's set_rate
97 * implementation to insure that clocks do not run out of spec
98 * when propgating the call to set_rate up to the parent. One way
99 * to do this is to gate the clock (via clk_disable and/or
100 * clk_unprepare) before calling clk_set_rate, then ungating it
101 * afterward. If your clock also has the CLK_GATE_SET_RATE flag
102 * set then this will insure safety. Returns 0 on success,
103 * -EERROR otherwise.
104 *
105 * The clk_enable/clk_disable and clk_prepare/clk_unprepare pairs allow
106 * implementations to split any work between atomic (enable) and sleepable
107 * (prepare) contexts. If enabling a clock requires code that might sleep,
108 * this must be done in clk_prepare. Clock enable code that will never be
109 * called in a sleepable context may be implement in clk_enable.
110 *
111 * Typically, drivers will call clk_prepare when a clock may be needed later
112 * (eg. when a device is opened), and clk_enable when the clock is actually
113 * required (eg. from an interrupt). Note that clk_prepare MUST have been
114 * called before clk_enable.
115 */
116struct clk_ops {
117 int (*prepare)(struct clk_hw *hw);
118 void (*unprepare)(struct clk_hw *hw);
119 int (*enable)(struct clk_hw *hw);
120 void (*disable)(struct clk_hw *hw);
121 int (*is_enabled)(struct clk_hw *hw);
122 unsigned long (*recalc_rate)(struct clk_hw *hw,
123 unsigned long parent_rate);
124 long (*round_rate)(struct clk_hw *hw, unsigned long,
125 unsigned long *);
126 int (*set_parent)(struct clk_hw *hw, u8 index);
127 u8 (*get_parent)(struct clk_hw *hw);
128 int (*set_rate)(struct clk_hw *hw, unsigned long);
129 void (*init)(struct clk_hw *hw);
130};
131
132
133/**
134 * clk_register - allocate a new clock, register it and return an opaque cookie
135 * @dev: device that is registering this clock
136 * @name: clock name
137 * @ops: operations this clock supports
138 * @hw: link to hardware-specific clock data
139 * @parent_names: array of string names for all possible parents
140 * @num_parents: number of possible parents
141 * @flags: framework-level hints and quirks
142 *
143 * clk_register is the primary interface for populating the clock tree with new
144 * clock nodes. It returns a pointer to the newly allocated struct clk which
145 * cannot be dereferenced by driver code but may be used in conjuction with the
146 * rest of the clock API.
147 */
148struct clk *clk_register(struct device *dev, const char *name,
149 const struct clk_ops *ops, struct clk_hw *hw,
150 char **parent_names, u8 num_parents, unsigned long flags);
151
152/* helper functions */
153const char *__clk_get_name(struct clk *clk);
154struct clk_hw *__clk_get_hw(struct clk *clk);
155u8 __clk_get_num_parents(struct clk *clk);
156struct clk *__clk_get_parent(struct clk *clk);
157inline int __clk_get_enable_count(struct clk *clk);
158inline int __clk_get_prepare_count(struct clk *clk);
159unsigned long __clk_get_rate(struct clk *clk);
160unsigned long __clk_get_flags(struct clk *clk);
161int __clk_is_enabled(struct clk *clk);
162struct clk *__clk_lookup(const char *name);
163
164/*
165 * FIXME clock api without lock protection
166 */
167int __clk_prepare(struct clk *clk);
168void __clk_unprepare(struct clk *clk);
169void __clk_reparent(struct clk *clk, struct clk *new_parent);
170unsigned long __clk_round_rate(struct clk *clk, unsigned long rate);
171
172#endif /* CONFIG_COMMON_CLK */
173#endif /* CLK_PROVIDER_H */
diff --git a/include/linux/clk.h b/include/linux/clk.h
index b9d46fa154b4..b0252726df61 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -3,6 +3,7 @@
3 * 3 *
4 * Copyright (C) 2004 ARM Limited. 4 * Copyright (C) 2004 ARM Limited.
5 * Written by Deep Blue Solutions Limited. 5 * Written by Deep Blue Solutions Limited.
6 * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
6 * 7 *
7 * This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as 9 * it under the terms of the GNU General Public License version 2 as
@@ -12,18 +13,75 @@
12#define __LINUX_CLK_H 13#define __LINUX_CLK_H
13 14
14#include <linux/kernel.h> 15#include <linux/kernel.h>
16#include <linux/notifier.h>
15 17
16struct device; 18struct device;
17 19
18/* 20struct clk;
19 * The base API. 21
22#ifdef CONFIG_COMMON_CLK
23
24/**
25 * DOC: clk notifier callback types
26 *
27 * PRE_RATE_CHANGE - called immediately before the clk rate is changed,
28 * to indicate that the rate change will proceed. Drivers must
29 * immediately terminate any operations that will be affected by the
30 * rate change. Callbacks may either return NOTIFY_DONE or
31 * NOTIFY_STOP.
32 *
33 * ABORT_RATE_CHANGE: called if the rate change failed for some reason
34 * after PRE_RATE_CHANGE. In this case, all registered notifiers on
35 * the clk will be called with ABORT_RATE_CHANGE. Callbacks must
36 * always return NOTIFY_DONE.
37 *
38 * POST_RATE_CHANGE - called after the clk rate change has successfully
39 * completed. Callbacks must always return NOTIFY_DONE.
40 *
20 */ 41 */
42#define PRE_RATE_CHANGE BIT(0)
43#define POST_RATE_CHANGE BIT(1)
44#define ABORT_RATE_CHANGE BIT(2)
21 45
46/**
47 * struct clk_notifier - associate a clk with a notifier
48 * @clk: struct clk * to associate the notifier with
49 * @notifier_head: a blocking_notifier_head for this clk
50 * @node: linked list pointers
51 *
52 * A list of struct clk_notifier is maintained by the notifier code.
53 * An entry is created whenever code registers the first notifier on a
54 * particular @clk. Future notifiers on that @clk are added to the
55 * @notifier_head.
56 */
57struct clk_notifier {
58 struct clk *clk;
59 struct srcu_notifier_head notifier_head;
60 struct list_head node;
61};
22 62
23/* 63/**
24 * struct clk - an machine class defined object / cookie. 64 * struct clk_notifier_data - rate data to pass to the notifier callback
65 * @clk: struct clk * being changed
66 * @old_rate: previous rate of this clk
67 * @new_rate: new rate of this clk
68 *
69 * For a pre-notifier, old_rate is the clk's rate before this rate
70 * change, and new_rate is what the rate will be in the future. For a
71 * post-notifier, old_rate and new_rate are both set to the clk's
72 * current rate (this was done to optimize the implementation).
25 */ 73 */
26struct clk; 74struct clk_notifier_data {
75 struct clk *clk;
76 unsigned long old_rate;
77 unsigned long new_rate;
78};
79
80int clk_notifier_register(struct clk *clk, struct notifier_block *nb);
81
82int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb);
83
84#endif /* !CONFIG_COMMON_CLK */
27 85
28/** 86/**
29 * clk_get - lookup and obtain a reference to a clock producer. 87 * clk_get - lookup and obtain a reference to a clock producer.
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-26 13:42:46 -0500