2 * Clock and PLL control for DaVinci devices
4 * Copyright (C) 2006-2007 Texas Instruments.
5 * Copyright (C) 2008-2009 Deep Root Systems, LLC
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
13 #include <linux/module.h>
14 #include <linux/kernel.h>
15 #include <linux/init.h>
16 #include <linux/errno.h>
17 #include <linux/clk.h>
18 #include <linux/err.h>
19 #include <linux/mutex.h>
20 #include <linux/platform_device.h>
23 #include <mach/hardware.h>
26 #include <mach/cputype.h>
29 static LIST_HEAD(clocks
);
30 static DEFINE_MUTEX(clocks_mutex
);
31 static DEFINE_SPINLOCK(clockfw_lock
);
33 static unsigned psc_domain(struct clk
*clk
)
35 return (clk
->flags
& PSC_DSP
)
36 ? DAVINCI_GPSC_DSPDOMAIN
37 : DAVINCI_GPSC_ARMDOMAIN
;
40 static void __clk_enable(struct clk
*clk
)
43 __clk_enable(clk
->parent
);
44 if (clk
->usecount
++ == 0 && (clk
->flags
& CLK_PSC
))
45 davinci_psc_config(psc_domain(clk
), clk
->psc_ctlr
,
49 static void __clk_disable(struct clk
*clk
)
51 if (WARN_ON(clk
->usecount
== 0))
53 if (--clk
->usecount
== 0 && !(clk
->flags
& CLK_PLL
))
54 davinci_psc_config(psc_domain(clk
), clk
->psc_ctlr
,
57 __clk_disable(clk
->parent
);
60 int clk_enable(struct clk
*clk
)
64 if (clk
== NULL
|| IS_ERR(clk
))
67 spin_lock_irqsave(&clockfw_lock
, flags
);
69 spin_unlock_irqrestore(&clockfw_lock
, flags
);
73 EXPORT_SYMBOL(clk_enable
);
75 void clk_disable(struct clk
*clk
)
79 if (clk
== NULL
|| IS_ERR(clk
))
82 spin_lock_irqsave(&clockfw_lock
, flags
);
84 spin_unlock_irqrestore(&clockfw_lock
, flags
);
86 EXPORT_SYMBOL(clk_disable
);
88 unsigned long clk_get_rate(struct clk
*clk
)
90 if (clk
== NULL
|| IS_ERR(clk
))
95 EXPORT_SYMBOL(clk_get_rate
);
97 long clk_round_rate(struct clk
*clk
, unsigned long rate
)
99 if (clk
== NULL
|| IS_ERR(clk
))
104 EXPORT_SYMBOL(clk_round_rate
);
106 int clk_set_rate(struct clk
*clk
, unsigned long rate
)
108 if (clk
== NULL
|| IS_ERR(clk
))
111 /* changing the clk rate is not supported */
114 EXPORT_SYMBOL(clk_set_rate
);
116 int clk_register(struct clk
*clk
)
118 if (clk
== NULL
|| IS_ERR(clk
))
121 if (WARN(clk
->parent
&& !clk
->parent
->rate
,
122 "CLK: %s parent %s has no rate!\n",
123 clk
->name
, clk
->parent
->name
))
126 INIT_LIST_HEAD(&clk
->children
);
128 mutex_lock(&clocks_mutex
);
129 list_add_tail(&clk
->node
, &clocks
);
131 list_add_tail(&clk
->childnode
, &clk
->parent
->children
);
132 mutex_unlock(&clocks_mutex
);
134 /* If rate is already set, use it */
138 /* Else, see if there is a way to calculate it */
140 clk
->rate
= clk
->recalc(clk
);
142 /* Otherwise, default to parent rate */
143 else if (clk
->parent
)
144 clk
->rate
= clk
->parent
->rate
;
148 EXPORT_SYMBOL(clk_register
);
150 void clk_unregister(struct clk
*clk
)
152 if (clk
== NULL
|| IS_ERR(clk
))
155 mutex_lock(&clocks_mutex
);
156 list_del(&clk
->node
);
157 list_del(&clk
->childnode
);
158 mutex_unlock(&clocks_mutex
);
160 EXPORT_SYMBOL(clk_unregister
);
162 #ifdef CONFIG_DAVINCI_RESET_CLOCKS
164 * Disable any unused clocks left on by the bootloader
166 static int __init
clk_disable_unused(void)
170 spin_lock_irq(&clockfw_lock
);
171 list_for_each_entry(ck
, &clocks
, node
) {
172 if (ck
->usecount
> 0)
174 if (!(ck
->flags
& CLK_PSC
))
177 /* ignore if in Disabled or SwRstDisable states */
178 if (!davinci_psc_is_clk_active(ck
->psc_ctlr
, ck
->lpsc
))
181 pr_info("Clocks: disable unused %s\n", ck
->name
);
182 davinci_psc_config(psc_domain(ck
), ck
->psc_ctlr
, ck
->lpsc
, 0);
184 spin_unlock_irq(&clockfw_lock
);
188 late_initcall(clk_disable_unused
);
191 static unsigned long clk_sysclk_recalc(struct clk
*clk
)
194 struct pll_data
*pll
;
195 unsigned long rate
= clk
->rate
;
197 /* If this is the PLL base clock, no more calculations needed */
201 if (WARN_ON(!clk
->parent
))
204 rate
= clk
->parent
->rate
;
206 /* Otherwise, the parent must be a PLL */
207 if (WARN_ON(!clk
->parent
->pll_data
))
210 pll
= clk
->parent
->pll_data
;
212 /* If pre-PLL, source clock is before the multiplier and divider(s) */
213 if (clk
->flags
& PRE_PLL
)
214 rate
= pll
->input_rate
;
219 v
= __raw_readl(pll
->base
+ clk
->div_reg
);
221 plldiv
= (v
& PLLDIV_RATIO_MASK
) + 1;
229 static unsigned long clk_leafclk_recalc(struct clk
*clk
)
231 if (WARN_ON(!clk
->parent
))
234 return clk
->parent
->rate
;
237 static unsigned long clk_pllclk_recalc(struct clk
*clk
)
239 u32 ctrl
, mult
= 1, prediv
= 1, postdiv
= 1;
241 struct pll_data
*pll
= clk
->pll_data
;
242 unsigned long rate
= clk
->rate
;
244 pll
->base
= IO_ADDRESS(pll
->phys_base
);
245 ctrl
= __raw_readl(pll
->base
+ PLLCTL
);
246 rate
= pll
->input_rate
= clk
->parent
->rate
;
248 if (ctrl
& PLLCTL_PLLEN
) {
250 mult
= __raw_readl(pll
->base
+ PLLM
);
251 if (cpu_is_davinci_dm365())
252 mult
= 2 * (mult
& PLLM_PLLM_MASK
);
254 mult
= (mult
& PLLM_PLLM_MASK
) + 1;
258 if (pll
->flags
& PLL_HAS_PREDIV
) {
259 prediv
= __raw_readl(pll
->base
+ PREDIV
);
260 if (prediv
& PLLDIV_EN
)
261 prediv
= (prediv
& PLLDIV_RATIO_MASK
) + 1;
266 /* pre-divider is fixed, but (some?) chips won't report that */
267 if (cpu_is_davinci_dm355() && pll
->num
== 1)
270 if (pll
->flags
& PLL_HAS_POSTDIV
) {
271 postdiv
= __raw_readl(pll
->base
+ POSTDIV
);
272 if (postdiv
& PLLDIV_EN
)
273 postdiv
= (postdiv
& PLLDIV_RATIO_MASK
) + 1;
284 pr_debug("PLL%d: input = %lu MHz [ ",
285 pll
->num
, clk
->parent
->rate
/ 1000000);
289 pr_debug("/ %d ", prediv
);
291 pr_debug("* %d ", mult
);
293 pr_debug("/ %d ", postdiv
);
294 pr_debug("] --> %lu MHz output.\n", rate
/ 1000000);
299 int __init
davinci_clk_init(struct davinci_clk
*clocks
)
301 struct davinci_clk
*c
;
304 for (c
= clocks
; c
->lk
.clk
; c
++) {
309 /* Check if clock is a PLL */
311 clk
->recalc
= clk_pllclk_recalc
;
313 /* Else, if it is a PLL-derived clock */
314 else if (clk
->flags
& CLK_PLL
)
315 clk
->recalc
= clk_sysclk_recalc
;
317 /* Otherwise, it is a leaf clock (PSC clock) */
318 else if (clk
->parent
)
319 clk
->recalc
= clk_leafclk_recalc
;
323 clk
->rate
= clk
->recalc(clk
);
326 clk
->flags
|= CLK_PSC
;
331 /* Turn on clocks that Linux doesn't otherwise manage */
332 if (clk
->flags
& ALWAYS_ENABLED
)
339 #ifdef CONFIG_PROC_FS
340 #include <linux/proc_fs.h>
341 #include <linux/seq_file.h>
343 static void *davinci_ck_start(struct seq_file
*m
, loff_t
*pos
)
345 return *pos
< 1 ? (void *)1 : NULL
;
348 static void *davinci_ck_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
354 static void davinci_ck_stop(struct seq_file
*m
, void *v
)
358 #define CLKNAME_MAX 10 /* longest clock name */
363 dump_clock(struct seq_file
*s
, unsigned nest
, struct clk
*parent
)
366 char buf
[CLKNAME_MAX
+ NEST_DELTA
* NEST_MAX
];
370 if (parent
->flags
& CLK_PLL
)
372 else if (parent
->flags
& CLK_PSC
)
377 /* <nest spaces> name <pad to end> */
378 memset(buf
, ' ', sizeof(buf
) - 1);
379 buf
[sizeof(buf
) - 1] = 0;
380 i
= strlen(parent
->name
);
381 memcpy(buf
+ nest
, parent
->name
,
382 min(i
, (unsigned)(sizeof(buf
) - 1 - nest
)));
384 seq_printf(s
, "%s users=%2d %-3s %9ld Hz\n",
385 buf
, parent
->usecount
, state
, clk_get_rate(parent
));
386 /* REVISIT show device associations too */
388 /* cost is now small, but not linear... */
389 list_for_each_entry(clk
, &parent
->children
, childnode
) {
390 dump_clock(s
, nest
+ NEST_DELTA
, clk
);
394 static int davinci_ck_show(struct seq_file
*m
, void *v
)
396 /* Show clock tree; we know the main oscillator is first.
397 * We trust nonzero usecounts equate to PSC enables...
399 mutex_lock(&clocks_mutex
);
400 if (!list_empty(&clocks
))
401 dump_clock(m
, 0, list_first_entry(&clocks
, struct clk
, node
));
402 mutex_unlock(&clocks_mutex
);
407 static const struct seq_operations davinci_ck_op
= {
408 .start
= davinci_ck_start
,
409 .next
= davinci_ck_next
,
410 .stop
= davinci_ck_stop
,
411 .show
= davinci_ck_show
414 static int davinci_ck_open(struct inode
*inode
, struct file
*file
)
416 return seq_open(file
, &davinci_ck_op
);
419 static const struct file_operations proc_davinci_ck_operations
= {
420 .open
= davinci_ck_open
,
423 .release
= seq_release
,
426 static int __init
davinci_ck_proc_init(void)
428 proc_create("davinci_clocks", 0, NULL
, &proc_davinci_ck_operations
);
432 __initcall(davinci_ck_proc_init
);
433 #endif /* CONFIG_DEBUG_PROC_FS */