2 * drivers/sh/clk.c - SuperH clock framework
4 * Copyright (C) 2005 - 2009 Paul Mundt
6 * This clock framework is derived from the OMAP version by:
8 * Copyright (C) 2004 - 2008 Nokia Corporation
9 * Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
11 * Modified for omap shared clock framework by Tony Lindgren <tony@atomide.com>
13 * This file is subject to the terms and conditions of the GNU General Public
14 * License. See the file "COPYING" in the main directory of this archive
17 #include <linux/kernel.h>
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/mutex.h>
21 #include <linux/list.h>
22 #include <linux/kobject.h>
23 #include <linux/sysdev.h>
24 #include <linux/seq_file.h>
25 #include <linux/err.h>
26 #include <linux/platform_device.h>
27 #include <linux/debugfs.h>
28 #include <linux/cpufreq.h>
29 #include <linux/clk.h>
30 #include <linux/sh_clk.h>
32 static LIST_HEAD(clock_list
);
33 static DEFINE_SPINLOCK(clock_lock
);
34 static DEFINE_MUTEX(clock_list_sem
);
36 void clk_rate_table_build(struct clk
*clk
,
37 struct cpufreq_frequency_table
*freq_table
,
39 struct clk_div_mult_table
*src_table
,
40 unsigned long *bitmap
)
42 unsigned long mult
, div
;
46 for (i
= 0; i
< nr_freqs
; i
++) {
50 if (src_table
->divisors
&& i
< src_table
->nr_divisors
)
51 div
= src_table
->divisors
[i
];
53 if (src_table
->multipliers
&& i
< src_table
->nr_multipliers
)
54 mult
= src_table
->multipliers
[i
];
56 if (!div
|| !mult
|| (bitmap
&& !test_bit(i
, bitmap
)))
57 freq
= CPUFREQ_ENTRY_INVALID
;
59 freq
= clk
->parent
->rate
* mult
/ div
;
61 freq_table
[i
].index
= i
;
62 freq_table
[i
].frequency
= freq
;
65 /* Termination entry */
66 freq_table
[i
].index
= i
;
67 freq_table
[i
].frequency
= CPUFREQ_TABLE_END
;
70 long clk_rate_table_round(struct clk
*clk
,
71 struct cpufreq_frequency_table
*freq_table
,
74 unsigned long rate_error
, rate_error_prev
= ~0UL;
75 unsigned long rate_best_fit
= rate
;
76 unsigned long highest
, lowest
;
81 for (i
= 0; freq_table
[i
].frequency
!= CPUFREQ_TABLE_END
; i
++) {
82 unsigned long freq
= freq_table
[i
].frequency
;
84 if (freq
== CPUFREQ_ENTRY_INVALID
)
92 rate_error
= abs(freq
- rate
);
93 if (rate_error
< rate_error_prev
) {
95 rate_error_prev
= rate_error
;
103 rate_best_fit
= highest
;
105 rate_best_fit
= lowest
;
107 return rate_best_fit
;
110 int clk_rate_table_find(struct clk
*clk
,
111 struct cpufreq_frequency_table
*freq_table
,
116 for (i
= 0; freq_table
[i
].frequency
!= CPUFREQ_TABLE_END
; i
++) {
117 unsigned long freq
= freq_table
[i
].frequency
;
119 if (freq
== CPUFREQ_ENTRY_INVALID
)
129 /* Used for clocks that always have same value as the parent clock */
130 unsigned long followparent_recalc(struct clk
*clk
)
132 return clk
->parent
? clk
->parent
->rate
: 0;
135 int clk_reparent(struct clk
*child
, struct clk
*parent
)
137 list_del_init(&child
->sibling
);
139 list_add(&child
->sibling
, &parent
->children
);
140 child
->parent
= parent
;
142 /* now do the debugfs renaming to reattach the child
143 to the proper parent */
148 /* Propagate rate to children */
149 void propagate_rate(struct clk
*tclk
)
153 list_for_each_entry(clkp
, &tclk
->children
, sibling
) {
154 if (clkp
->ops
&& clkp
->ops
->recalc
)
155 clkp
->rate
= clkp
->ops
->recalc(clkp
);
157 propagate_rate(clkp
);
161 static void __clk_disable(struct clk
*clk
)
163 if (clk
->usecount
== 0) {
164 printk(KERN_ERR
"Trying disable clock %s with 0 usecount\n",
170 if (!(--clk
->usecount
)) {
171 if (likely(clk
->ops
&& clk
->ops
->disable
))
172 clk
->ops
->disable(clk
);
173 if (likely(clk
->parent
))
174 __clk_disable(clk
->parent
);
178 void clk_disable(struct clk
*clk
)
185 spin_lock_irqsave(&clock_lock
, flags
);
187 spin_unlock_irqrestore(&clock_lock
, flags
);
189 EXPORT_SYMBOL_GPL(clk_disable
);
191 static int __clk_enable(struct clk
*clk
)
195 if (clk
->usecount
++ == 0) {
197 ret
= __clk_enable(clk
->parent
);
202 if (clk
->ops
&& clk
->ops
->enable
) {
203 ret
= clk
->ops
->enable(clk
);
206 __clk_disable(clk
->parent
);
218 int clk_enable(struct clk
*clk
)
226 spin_lock_irqsave(&clock_lock
, flags
);
227 ret
= __clk_enable(clk
);
228 spin_unlock_irqrestore(&clock_lock
, flags
);
232 EXPORT_SYMBOL_GPL(clk_enable
);
234 static LIST_HEAD(root_clks
);
237 * recalculate_root_clocks - recalculate and propagate all root clocks
239 * Recalculates all root clocks (clocks with no parent), which if the
240 * clock's .recalc is set correctly, should also propagate their rates.
243 void recalculate_root_clocks(void)
247 list_for_each_entry(clkp
, &root_clks
, sibling
) {
248 if (clkp
->ops
&& clkp
->ops
->recalc
)
249 clkp
->rate
= clkp
->ops
->recalc(clkp
);
250 propagate_rate(clkp
);
254 int clk_register(struct clk
*clk
)
256 if (clk
== NULL
|| IS_ERR(clk
))
260 * trap out already registered clocks
262 if (clk
->node
.next
|| clk
->node
.prev
)
265 mutex_lock(&clock_list_sem
);
267 INIT_LIST_HEAD(&clk
->children
);
271 list_add(&clk
->sibling
, &clk
->parent
->children
);
273 list_add(&clk
->sibling
, &root_clks
);
275 list_add(&clk
->node
, &clock_list
);
276 if (clk
->ops
&& clk
->ops
->init
)
278 mutex_unlock(&clock_list_sem
);
282 EXPORT_SYMBOL_GPL(clk_register
);
284 void clk_unregister(struct clk
*clk
)
286 mutex_lock(&clock_list_sem
);
287 list_del(&clk
->sibling
);
288 list_del(&clk
->node
);
289 mutex_unlock(&clock_list_sem
);
291 EXPORT_SYMBOL_GPL(clk_unregister
);
293 void clk_enable_init_clocks(void)
297 list_for_each_entry(clkp
, &clock_list
, node
)
298 if (clkp
->flags
& CLK_ENABLE_ON_INIT
)
302 unsigned long clk_get_rate(struct clk
*clk
)
306 EXPORT_SYMBOL_GPL(clk_get_rate
);
308 int clk_set_rate(struct clk
*clk
, unsigned long rate
)
310 return clk_set_rate_ex(clk
, rate
, 0);
312 EXPORT_SYMBOL_GPL(clk_set_rate
);
314 int clk_set_rate_ex(struct clk
*clk
, unsigned long rate
, int algo_id
)
316 int ret
= -EOPNOTSUPP
;
319 spin_lock_irqsave(&clock_lock
, flags
);
321 if (likely(clk
->ops
&& clk
->ops
->set_rate
)) {
322 ret
= clk
->ops
->set_rate(clk
, rate
, algo_id
);
330 if (clk
->ops
&& clk
->ops
->recalc
)
331 clk
->rate
= clk
->ops
->recalc(clk
);
336 spin_unlock_irqrestore(&clock_lock
, flags
);
340 EXPORT_SYMBOL_GPL(clk_set_rate_ex
);
342 int clk_set_parent(struct clk
*clk
, struct clk
*parent
)
349 if (clk
->parent
== parent
)
352 spin_lock_irqsave(&clock_lock
, flags
);
353 if (clk
->usecount
== 0) {
354 if (clk
->ops
->set_parent
)
355 ret
= clk
->ops
->set_parent(clk
, parent
);
357 ret
= clk_reparent(clk
, parent
);
360 pr_debug("clock: set parent of %s to %s (new rate %ld)\n",
361 clk
->name
, clk
->parent
->name
, clk
->rate
);
362 if (clk
->ops
->recalc
)
363 clk
->rate
= clk
->ops
->recalc(clk
);
368 spin_unlock_irqrestore(&clock_lock
, flags
);
372 EXPORT_SYMBOL_GPL(clk_set_parent
);
374 struct clk
*clk_get_parent(struct clk
*clk
)
378 EXPORT_SYMBOL_GPL(clk_get_parent
);
380 long clk_round_rate(struct clk
*clk
, unsigned long rate
)
382 if (likely(clk
->ops
&& clk
->ops
->round_rate
)) {
383 unsigned long flags
, rounded
;
385 spin_lock_irqsave(&clock_lock
, flags
);
386 rounded
= clk
->ops
->round_rate(clk
, rate
);
387 spin_unlock_irqrestore(&clock_lock
, flags
);
392 return clk_get_rate(clk
);
394 EXPORT_SYMBOL_GPL(clk_round_rate
);
397 static int clks_sysdev_suspend(struct sys_device
*dev
, pm_message_t state
)
399 static pm_message_t prev_state
;
402 switch (state
.event
) {
404 /* Resumeing from hibernation */
405 if (prev_state
.event
!= PM_EVENT_FREEZE
)
408 list_for_each_entry(clkp
, &clock_list
, node
) {
409 if (likely(clkp
->ops
)) {
410 unsigned long rate
= clkp
->rate
;
412 if (likely(clkp
->ops
->set_parent
))
413 clkp
->ops
->set_parent(clkp
,
415 if (likely(clkp
->ops
->set_rate
))
416 clkp
->ops
->set_rate(clkp
,
418 else if (likely(clkp
->ops
->recalc
))
419 clkp
->rate
= clkp
->ops
->recalc(clkp
);
423 case PM_EVENT_FREEZE
:
425 case PM_EVENT_SUSPEND
:
433 static int clks_sysdev_resume(struct sys_device
*dev
)
435 return clks_sysdev_suspend(dev
, PMSG_ON
);
438 static struct sysdev_class clks_sysdev_class
= {
442 static struct sysdev_driver clks_sysdev_driver
= {
443 .suspend
= clks_sysdev_suspend
,
444 .resume
= clks_sysdev_resume
,
447 static struct sys_device clks_sysdev_dev
= {
448 .cls
= &clks_sysdev_class
,
451 static int __init
clk_sysdev_init(void)
453 sysdev_class_register(&clks_sysdev_class
);
454 sysdev_driver_register(&clks_sysdev_class
, &clks_sysdev_driver
);
455 sysdev_register(&clks_sysdev_dev
);
459 subsys_initcall(clk_sysdev_init
);
463 * debugfs support to trace clock tree hierarchy and attributes
465 static struct dentry
*clk_debugfs_root
;
467 static int clk_debugfs_register_one(struct clk
*c
)
470 struct dentry
*d
, *child
, *child_tmp
;
471 struct clk
*pa
= c
->parent
;
475 p
+= sprintf(p
, "%s", c
->name
);
477 sprintf(p
, ":%d", c
->id
);
478 d
= debugfs_create_dir(s
, pa
? pa
->dentry
: clk_debugfs_root
);
483 d
= debugfs_create_u8("usecount", S_IRUGO
, c
->dentry
, (u8
*)&c
->usecount
);
488 d
= debugfs_create_u32("rate", S_IRUGO
, c
->dentry
, (u32
*)&c
->rate
);
493 d
= debugfs_create_x32("flags", S_IRUGO
, c
->dentry
, (u32
*)&c
->flags
);
502 list_for_each_entry_safe(child
, child_tmp
, &d
->d_subdirs
, d_u
.d_child
)
503 debugfs_remove(child
);
504 debugfs_remove(c
->dentry
);
508 static int clk_debugfs_register(struct clk
*c
)
511 struct clk
*pa
= c
->parent
;
513 if (pa
&& !pa
->dentry
) {
514 err
= clk_debugfs_register(pa
);
519 if (!c
->dentry
&& c
->name
) {
520 err
= clk_debugfs_register_one(c
);
527 static int __init
clk_debugfs_init(void)
533 d
= debugfs_create_dir("clock", NULL
);
536 clk_debugfs_root
= d
;
538 list_for_each_entry(c
, &clock_list
, node
) {
539 err
= clk_debugfs_register(c
);
545 debugfs_remove_recursive(clk_debugfs_root
);
548 late_initcall(clk_debugfs_init
);