2 * linux/arch/arm/plat-omap/clock.c
4 * Copyright (C) 2004 - 2008 Nokia corporation
5 * Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
7 * Modified for omap shared clock framework by Tony Lindgren <tony@atomide.com>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/list.h>
16 #include <linux/errno.h>
17 #include <linux/err.h>
18 #include <linux/string.h>
19 #include <linux/clk.h>
20 #include <linux/mutex.h>
21 #include <linux/cpufreq.h>
22 #include <linux/debugfs.h>
25 #include <plat/clock.h>
27 static LIST_HEAD(clocks
);
28 static DEFINE_MUTEX(clocks_mutex
);
29 static DEFINE_SPINLOCK(clockfw_lock
);
31 static struct clk_functions
*arch_clock
;
34 * Standard clock functions defined in include/linux/clk.h
37 int clk_enable(struct clk
*clk
)
42 if (clk
== NULL
|| IS_ERR(clk
))
45 if (!arch_clock
|| !arch_clock
->clk_enable
)
48 spin_lock_irqsave(&clockfw_lock
, flags
);
49 ret
= arch_clock
->clk_enable(clk
);
50 spin_unlock_irqrestore(&clockfw_lock
, flags
);
54 EXPORT_SYMBOL(clk_enable
);
56 void clk_disable(struct clk
*clk
)
60 if (clk
== NULL
|| IS_ERR(clk
))
63 if (!arch_clock
|| !arch_clock
->clk_disable
)
66 spin_lock_irqsave(&clockfw_lock
, flags
);
67 if (clk
->usecount
== 0) {
68 pr_err("Trying disable clock %s with 0 usecount\n",
74 arch_clock
->clk_disable(clk
);
77 spin_unlock_irqrestore(&clockfw_lock
, flags
);
79 EXPORT_SYMBOL(clk_disable
);
81 unsigned long clk_get_rate(struct clk
*clk
)
86 if (clk
== NULL
|| IS_ERR(clk
))
89 spin_lock_irqsave(&clockfw_lock
, flags
);
91 spin_unlock_irqrestore(&clockfw_lock
, flags
);
95 EXPORT_SYMBOL(clk_get_rate
);
98 * Optional clock functions defined in include/linux/clk.h
101 long clk_round_rate(struct clk
*clk
, unsigned long rate
)
106 if (clk
== NULL
|| IS_ERR(clk
))
109 if (!arch_clock
|| !arch_clock
->clk_round_rate
)
112 spin_lock_irqsave(&clockfw_lock
, flags
);
113 ret
= arch_clock
->clk_round_rate(clk
, rate
);
114 spin_unlock_irqrestore(&clockfw_lock
, flags
);
118 EXPORT_SYMBOL(clk_round_rate
);
120 int clk_set_rate(struct clk
*clk
, unsigned long rate
)
125 if (clk
== NULL
|| IS_ERR(clk
))
128 if (!arch_clock
|| !arch_clock
->clk_set_rate
)
131 spin_lock_irqsave(&clockfw_lock
, flags
);
132 ret
= arch_clock
->clk_set_rate(clk
, rate
);
135 spin_unlock_irqrestore(&clockfw_lock
, flags
);
139 EXPORT_SYMBOL(clk_set_rate
);
141 int clk_set_parent(struct clk
*clk
, struct clk
*parent
)
146 if (clk
== NULL
|| IS_ERR(clk
) || parent
== NULL
|| IS_ERR(parent
))
149 if (!arch_clock
|| !arch_clock
->clk_set_parent
)
152 spin_lock_irqsave(&clockfw_lock
, flags
);
153 if (clk
->usecount
== 0) {
154 ret
= arch_clock
->clk_set_parent(clk
, parent
);
159 spin_unlock_irqrestore(&clockfw_lock
, flags
);
163 EXPORT_SYMBOL(clk_set_parent
);
165 struct clk
*clk_get_parent(struct clk
*clk
)
169 EXPORT_SYMBOL(clk_get_parent
);
172 * OMAP specific clock functions shared between omap1 and omap2
175 int __initdata mpurate
;
178 * By default we use the rate set by the bootloader.
179 * You can override this with mpurate= cmdline option.
181 static int __init
omap_clk_setup(char *str
)
183 get_option(&str
, &mpurate
);
193 __setup("mpurate=", omap_clk_setup
);
195 /* Used for clocks that always have same value as the parent clock */
196 unsigned long followparent_recalc(struct clk
*clk
)
198 return clk
->parent
->rate
;
202 * Used for clocks that have the same value as the parent clock,
203 * divided by some factor
205 unsigned long omap_fixed_divisor_recalc(struct clk
*clk
)
207 WARN_ON(!clk
->fixed_div
);
209 return clk
->parent
->rate
/ clk
->fixed_div
;
212 void clk_reparent(struct clk
*child
, struct clk
*parent
)
214 list_del_init(&child
->sibling
);
216 list_add(&child
->sibling
, &parent
->children
);
217 child
->parent
= parent
;
219 /* now do the debugfs renaming to reattach the child
220 to the proper parent */
223 /* Propagate rate to children */
224 void propagate_rate(struct clk
*tclk
)
228 list_for_each_entry(clkp
, &tclk
->children
, sibling
) {
230 clkp
->rate
= clkp
->recalc(clkp
);
231 propagate_rate(clkp
);
235 static LIST_HEAD(root_clks
);
238 * recalculate_root_clocks - recalculate and propagate all root clocks
240 * Recalculates all root clocks (clocks with no parent), which if the
241 * clock's .recalc is set correctly, should also propagate their rates.
244 void recalculate_root_clocks(void)
248 list_for_each_entry(clkp
, &root_clks
, sibling
) {
250 clkp
->rate
= clkp
->recalc(clkp
);
251 propagate_rate(clkp
);
256 * clk_preinit - initialize any fields in the struct clk before clk init
257 * @clk: struct clk * to initialize
259 * Initialize any struct clk fields needed before normal clk initialization
260 * can run. No return value.
262 void clk_preinit(struct clk
*clk
)
264 INIT_LIST_HEAD(&clk
->children
);
267 int clk_register(struct clk
*clk
)
269 if (clk
== NULL
|| IS_ERR(clk
))
273 * trap out already registered clocks
275 if (clk
->node
.next
|| clk
->node
.prev
)
278 mutex_lock(&clocks_mutex
);
280 list_add(&clk
->sibling
, &clk
->parent
->children
);
282 list_add(&clk
->sibling
, &root_clks
);
284 list_add(&clk
->node
, &clocks
);
287 mutex_unlock(&clocks_mutex
);
291 EXPORT_SYMBOL(clk_register
);
293 void clk_unregister(struct clk
*clk
)
295 if (clk
== NULL
|| IS_ERR(clk
))
298 mutex_lock(&clocks_mutex
);
299 list_del(&clk
->sibling
);
300 list_del(&clk
->node
);
301 mutex_unlock(&clocks_mutex
);
303 EXPORT_SYMBOL(clk_unregister
);
305 void clk_enable_init_clocks(void)
309 list_for_each_entry(clkp
, &clocks
, node
) {
310 if (clkp
->flags
& ENABLE_ON_INIT
)
316 * omap_clk_get_by_name - locate OMAP struct clk by its name
317 * @name: name of the struct clk to locate
319 * Locate an OMAP struct clk by its name. Assumes that struct clk
320 * names are unique. Returns NULL if not found or a pointer to the
321 * struct clk if found.
323 struct clk
*omap_clk_get_by_name(const char *name
)
326 struct clk
*ret
= NULL
;
328 mutex_lock(&clocks_mutex
);
330 list_for_each_entry(c
, &clocks
, node
) {
331 if (!strcmp(c
->name
, name
)) {
337 mutex_unlock(&clocks_mutex
);
342 int omap_clk_enable_autoidle_all(void)
347 spin_lock_irqsave(&clockfw_lock
, flags
);
349 list_for_each_entry(c
, &clocks
, node
)
350 if (c
->ops
->allow_idle
)
351 c
->ops
->allow_idle(c
);
353 spin_unlock_irqrestore(&clockfw_lock
, flags
);
358 int omap_clk_disable_autoidle_all(void)
363 spin_lock_irqsave(&clockfw_lock
, flags
);
365 list_for_each_entry(c
, &clocks
, node
)
366 if (c
->ops
->deny_idle
)
367 c
->ops
->deny_idle(c
);
369 spin_unlock_irqrestore(&clockfw_lock
, flags
);
377 static int clkll_enable_null(struct clk
*clk
)
382 static void clkll_disable_null(struct clk
*clk
)
386 const struct clkops clkops_null
= {
387 .enable
= clkll_enable_null
,
388 .disable
= clkll_disable_null
,
394 * Used for clock aliases that are needed on some OMAPs, but not others
396 struct clk dummy_ck
= {
401 #ifdef CONFIG_CPU_FREQ
402 void clk_init_cpufreq_table(struct cpufreq_frequency_table
**table
)
406 if (!arch_clock
|| !arch_clock
->clk_init_cpufreq_table
)
409 spin_lock_irqsave(&clockfw_lock
, flags
);
410 arch_clock
->clk_init_cpufreq_table(table
);
411 spin_unlock_irqrestore(&clockfw_lock
, flags
);
414 void clk_exit_cpufreq_table(struct cpufreq_frequency_table
**table
)
418 if (!arch_clock
|| !arch_clock
->clk_exit_cpufreq_table
)
421 spin_lock_irqsave(&clockfw_lock
, flags
);
422 arch_clock
->clk_exit_cpufreq_table(table
);
423 spin_unlock_irqrestore(&clockfw_lock
, flags
);
431 #ifdef CONFIG_OMAP_RESET_CLOCKS
433 * Disable any unused clocks left on by the bootloader
435 static int __init
clk_disable_unused(void)
440 if (!arch_clock
|| !arch_clock
->clk_disable_unused
)
443 pr_info("clock: disabling unused clocks to save power\n");
444 list_for_each_entry(ck
, &clocks
, node
) {
445 if (ck
->ops
== &clkops_null
)
448 if (ck
->usecount
> 0 || !ck
->enable_reg
)
451 spin_lock_irqsave(&clockfw_lock
, flags
);
452 arch_clock
->clk_disable_unused(ck
);
453 spin_unlock_irqrestore(&clockfw_lock
, flags
);
458 late_initcall(clk_disable_unused
);
459 late_initcall(omap_clk_enable_autoidle_all
);
462 int __init
clk_init(struct clk_functions
* custom_clocks
)
464 if (!custom_clocks
) {
465 pr_err("No custom clock functions registered\n");
469 arch_clock
= custom_clocks
;
474 #if defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS)
476 * debugfs support to trace clock tree hierarchy and attributes
478 static struct dentry
*clk_debugfs_root
;
480 static int clk_debugfs_register_one(struct clk
*c
)
483 struct dentry
*d
, *child
, *child_tmp
;
484 struct clk
*pa
= c
->parent
;
488 p
+= sprintf(p
, "%s", c
->name
);
489 d
= debugfs_create_dir(s
, pa
? pa
->dent
: clk_debugfs_root
);
494 d
= debugfs_create_u8("usecount", S_IRUGO
, c
->dent
, (u8
*)&c
->usecount
);
499 d
= debugfs_create_u32("rate", S_IRUGO
, c
->dent
, (u32
*)&c
->rate
);
504 d
= debugfs_create_x32("flags", S_IRUGO
, c
->dent
, (u32
*)&c
->flags
);
513 list_for_each_entry_safe(child
, child_tmp
, &d
->d_subdirs
, d_u
.d_child
)
514 debugfs_remove(child
);
515 debugfs_remove(c
->dent
);
519 static int clk_debugfs_register(struct clk
*c
)
522 struct clk
*pa
= c
->parent
;
524 if (pa
&& !pa
->dent
) {
525 err
= clk_debugfs_register(pa
);
531 err
= clk_debugfs_register_one(c
);
538 static int __init
clk_debugfs_init(void)
544 d
= debugfs_create_dir("clock", NULL
);
547 clk_debugfs_root
= d
;
549 list_for_each_entry(c
, &clocks
, node
) {
550 err
= clk_debugfs_register(c
);
556 debugfs_remove_recursive(clk_debugfs_root
);
559 late_initcall(clk_debugfs_init
);
561 #endif /* defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS) */