Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
b9158556 | 2 | * linux/arch/arm/plat-omap/clock.c |
1da177e4 | 3 | * |
137b3ee2 | 4 | * Copyright (C) 2004 - 2008 Nokia corporation |
1da177e4 LT |
5 | * Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com> |
6 | * | |
1a8bfa1e TL |
7 | * Modified for omap shared clock framework by Tony Lindgren <tony@atomide.com> |
8 | * | |
1da177e4 LT |
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. | |
12 | */ | |
1da177e4 | 13 | #include <linux/kernel.h> |
1a8bfa1e | 14 | #include <linux/init.h> |
1da177e4 LT |
15 | #include <linux/list.h> |
16 | #include <linux/errno.h> | |
dc28094b | 17 | #include <linux/export.h> |
1da177e4 | 18 | #include <linux/err.h> |
4e57b681 | 19 | #include <linux/string.h> |
f8ce2547 | 20 | #include <linux/clk.h> |
00431707 | 21 | #include <linux/mutex.h> |
b851cb28 | 22 | #include <linux/cpufreq.h> |
fced80c7 | 23 | #include <linux/io.h> |
1da177e4 | 24 | |
ce491cf8 | 25 | #include <plat/clock.h> |
1da177e4 | 26 | |
7df3450e | 27 | static LIST_HEAD(clocks); |
00431707 | 28 | static DEFINE_MUTEX(clocks_mutex); |
7df3450e | 29 | static DEFINE_SPINLOCK(clockfw_lock); |
1da177e4 | 30 | |
1a8bfa1e | 31 | static struct clk_functions *arch_clock; |
1da177e4 | 32 | |
3587aeb0 | 33 | /* |
f07adc59 | 34 | * Standard clock functions defined in include/linux/clk.h |
3587aeb0 | 35 | */ |
1da177e4 | 36 | |
1da177e4 LT |
37 | int clk_enable(struct clk *clk) |
38 | { | |
39 | unsigned long flags; | |
e07f469d | 40 | int ret; |
1da177e4 | 41 | |
b824efae TL |
42 | if (clk == NULL || IS_ERR(clk)) |
43 | return -EINVAL; | |
44 | ||
e07f469d PW |
45 | if (!arch_clock || !arch_clock->clk_enable) |
46 | return -EINVAL; | |
47 | ||
1da177e4 | 48 | spin_lock_irqsave(&clockfw_lock, flags); |
e07f469d | 49 | ret = arch_clock->clk_enable(clk); |
1da177e4 | 50 | spin_unlock_irqrestore(&clockfw_lock, flags); |
1a8bfa1e | 51 | |
1da177e4 LT |
52 | return ret; |
53 | } | |
54 | EXPORT_SYMBOL(clk_enable); | |
55 | ||
1da177e4 LT |
56 | void clk_disable(struct clk *clk) |
57 | { | |
58 | unsigned long flags; | |
59 | ||
b824efae TL |
60 | if (clk == NULL || IS_ERR(clk)) |
61 | return; | |
62 | ||
e07f469d PW |
63 | if (!arch_clock || !arch_clock->clk_disable) |
64 | return; | |
65 | ||
1da177e4 | 66 | spin_lock_irqsave(&clockfw_lock, flags); |
7cf95774 | 67 | if (clk->usecount == 0) { |
6041c27f | 68 | pr_err("Trying disable clock %s with 0 usecount\n", |
7cf95774 TL |
69 | clk->name); |
70 | WARN_ON(1); | |
71 | goto out; | |
72 | } | |
73 | ||
e07f469d | 74 | arch_clock->clk_disable(clk); |
7cf95774 TL |
75 | |
76 | out: | |
1da177e4 LT |
77 | spin_unlock_irqrestore(&clockfw_lock, flags); |
78 | } | |
79 | EXPORT_SYMBOL(clk_disable); | |
80 | ||
1a8bfa1e | 81 | unsigned long clk_get_rate(struct clk *clk) |
1da177e4 | 82 | { |
1a8bfa1e | 83 | unsigned long flags; |
e07f469d | 84 | unsigned long ret; |
1da177e4 | 85 | |
b824efae TL |
86 | if (clk == NULL || IS_ERR(clk)) |
87 | return 0; | |
88 | ||
1a8bfa1e TL |
89 | spin_lock_irqsave(&clockfw_lock, flags); |
90 | ret = clk->rate; | |
91 | spin_unlock_irqrestore(&clockfw_lock, flags); | |
1da177e4 | 92 | |
1a8bfa1e | 93 | return ret; |
1da177e4 | 94 | } |
1a8bfa1e | 95 | EXPORT_SYMBOL(clk_get_rate); |
1da177e4 | 96 | |
3587aeb0 | 97 | /* |
f07adc59 | 98 | * Optional clock functions defined in include/linux/clk.h |
3587aeb0 | 99 | */ |
bb13b5fd | 100 | |
1da177e4 LT |
101 | long clk_round_rate(struct clk *clk, unsigned long rate) |
102 | { | |
1a8bfa1e | 103 | unsigned long flags; |
e07f469d | 104 | long ret; |
1da177e4 | 105 | |
b824efae | 106 | if (clk == NULL || IS_ERR(clk)) |
e07f469d PW |
107 | return 0; |
108 | ||
109 | if (!arch_clock || !arch_clock->clk_round_rate) | |
110 | return 0; | |
b824efae | 111 | |
1a8bfa1e | 112 | spin_lock_irqsave(&clockfw_lock, flags); |
e07f469d | 113 | ret = arch_clock->clk_round_rate(clk, rate); |
1a8bfa1e | 114 | spin_unlock_irqrestore(&clockfw_lock, flags); |
1da177e4 | 115 | |
1a8bfa1e | 116 | return ret; |
1da177e4 LT |
117 | } |
118 | EXPORT_SYMBOL(clk_round_rate); | |
119 | ||
1a8bfa1e | 120 | int clk_set_rate(struct clk *clk, unsigned long rate) |
1da177e4 | 121 | { |
1a8bfa1e | 122 | unsigned long flags; |
b824efae TL |
123 | int ret = -EINVAL; |
124 | ||
125 | if (clk == NULL || IS_ERR(clk)) | |
126 | return ret; | |
bb13b5fd | 127 | |
e07f469d PW |
128 | if (!arch_clock || !arch_clock->clk_set_rate) |
129 | return ret; | |
130 | ||
1a8bfa1e | 131 | spin_lock_irqsave(&clockfw_lock, flags); |
e07f469d PW |
132 | ret = arch_clock->clk_set_rate(clk, rate); |
133 | if (ret == 0) | |
3f0a820c | 134 | propagate_rate(clk); |
1a8bfa1e | 135 | spin_unlock_irqrestore(&clockfw_lock, flags); |
1da177e4 | 136 | |
1a8bfa1e | 137 | return ret; |
1da177e4 | 138 | } |
1a8bfa1e | 139 | EXPORT_SYMBOL(clk_set_rate); |
1da177e4 | 140 | |
1a8bfa1e | 141 | int clk_set_parent(struct clk *clk, struct clk *parent) |
1da177e4 | 142 | { |
1a8bfa1e | 143 | unsigned long flags; |
b824efae TL |
144 | int ret = -EINVAL; |
145 | ||
146 | if (clk == NULL || IS_ERR(clk) || parent == NULL || IS_ERR(parent)) | |
147 | return ret; | |
1da177e4 | 148 | |
e07f469d PW |
149 | if (!arch_clock || !arch_clock->clk_set_parent) |
150 | return ret; | |
151 | ||
1a8bfa1e | 152 | spin_lock_irqsave(&clockfw_lock, flags); |
4da37821 | 153 | if (clk->usecount == 0) { |
e07f469d PW |
154 | ret = arch_clock->clk_set_parent(clk, parent); |
155 | if (ret == 0) | |
4da37821 | 156 | propagate_rate(clk); |
4da37821 RK |
157 | } else |
158 | ret = -EBUSY; | |
1a8bfa1e | 159 | spin_unlock_irqrestore(&clockfw_lock, flags); |
1da177e4 | 160 | |
1a8bfa1e | 161 | return ret; |
1da177e4 | 162 | } |
1a8bfa1e | 163 | EXPORT_SYMBOL(clk_set_parent); |
1da177e4 | 164 | |
1a8bfa1e | 165 | struct clk *clk_get_parent(struct clk *clk) |
1da177e4 | 166 | { |
2e777bf1 | 167 | return clk->parent; |
1da177e4 | 168 | } |
1a8bfa1e | 169 | EXPORT_SYMBOL(clk_get_parent); |
1da177e4 | 170 | |
3587aeb0 | 171 | /* |
1a8bfa1e | 172 | * OMAP specific clock functions shared between omap1 and omap2 |
3587aeb0 | 173 | */ |
1da177e4 | 174 | |
d3730192 | 175 | int __initdata mpurate; |
1da177e4 | 176 | |
1a8bfa1e TL |
177 | /* |
178 | * By default we use the rate set by the bootloader. | |
179 | * You can override this with mpurate= cmdline option. | |
180 | */ | |
181 | static int __init omap_clk_setup(char *str) | |
1da177e4 | 182 | { |
1a8bfa1e | 183 | get_option(&str, &mpurate); |
1da177e4 | 184 | |
1a8bfa1e TL |
185 | if (!mpurate) |
186 | return 1; | |
1da177e4 | 187 | |
1a8bfa1e TL |
188 | if (mpurate < 1000) |
189 | mpurate *= 1000000; | |
1da177e4 | 190 | |
1a8bfa1e | 191 | return 1; |
1da177e4 | 192 | } |
1a8bfa1e | 193 | __setup("mpurate=", omap_clk_setup); |
1da177e4 | 194 | |
1a8bfa1e | 195 | /* Used for clocks that always have same value as the parent clock */ |
8b9dbc16 | 196 | unsigned long followparent_recalc(struct clk *clk) |
1da177e4 | 197 | { |
8b9dbc16 | 198 | return clk->parent->rate; |
1da177e4 LT |
199 | } |
200 | ||
e9b98f60 PW |
201 | /* |
202 | * Used for clocks that have the same value as the parent clock, | |
203 | * divided by some factor | |
204 | */ | |
205 | unsigned long omap_fixed_divisor_recalc(struct clk *clk) | |
206 | { | |
207 | WARN_ON(!clk->fixed_div); | |
208 | ||
209 | return clk->parent->rate / clk->fixed_div; | |
210 | } | |
211 | ||
3f0a820c RK |
212 | void clk_reparent(struct clk *child, struct clk *parent) |
213 | { | |
214 | list_del_init(&child->sibling); | |
215 | if (parent) | |
216 | list_add(&child->sibling, &parent->children); | |
217 | child->parent = parent; | |
218 | ||
219 | /* now do the debugfs renaming to reattach the child | |
220 | to the proper parent */ | |
221 | } | |
222 | ||
1a8bfa1e | 223 | /* Propagate rate to children */ |
3587aeb0 | 224 | void propagate_rate(struct clk *tclk) |
1da177e4 | 225 | { |
1a8bfa1e | 226 | struct clk *clkp; |
1da177e4 | 227 | |
3f0a820c | 228 | list_for_each_entry(clkp, &tclk->children, sibling) { |
9a5fedac | 229 | if (clkp->recalc) |
8b9dbc16 | 230 | clkp->rate = clkp->recalc(clkp); |
3f0a820c | 231 | propagate_rate(clkp); |
1a8bfa1e | 232 | } |
1da177e4 LT |
233 | } |
234 | ||
3f0a820c RK |
235 | static LIST_HEAD(root_clks); |
236 | ||
6b8858a9 PW |
237 | /** |
238 | * recalculate_root_clocks - recalculate and propagate all root clocks | |
239 | * | |
240 | * Recalculates all root clocks (clocks with no parent), which if the | |
241 | * clock's .recalc is set correctly, should also propagate their rates. | |
242 | * Called at init. | |
243 | */ | |
244 | void recalculate_root_clocks(void) | |
245 | { | |
246 | struct clk *clkp; | |
247 | ||
3f0a820c RK |
248 | list_for_each_entry(clkp, &root_clks, sibling) { |
249 | if (clkp->recalc) | |
8b9dbc16 | 250 | clkp->rate = clkp->recalc(clkp); |
3f0a820c | 251 | propagate_rate(clkp); |
6b8858a9 PW |
252 | } |
253 | } | |
254 | ||
c8088112 | 255 | /** |
79716870 | 256 | * clk_preinit - initialize any fields in the struct clk before clk init |
c8088112 PW |
257 | * @clk: struct clk * to initialize |
258 | * | |
259 | * Initialize any struct clk fields needed before normal clk initialization | |
260 | * can run. No return value. | |
261 | */ | |
79716870 | 262 | void clk_preinit(struct clk *clk) |
3f0a820c RK |
263 | { |
264 | INIT_LIST_HEAD(&clk->children); | |
265 | } | |
266 | ||
1da177e4 LT |
267 | int clk_register(struct clk *clk) |
268 | { | |
b824efae TL |
269 | if (clk == NULL || IS_ERR(clk)) |
270 | return -EINVAL; | |
271 | ||
dbb674d5 RK |
272 | /* |
273 | * trap out already registered clocks | |
274 | */ | |
275 | if (clk->node.next || clk->node.prev) | |
276 | return 0; | |
277 | ||
00431707 | 278 | mutex_lock(&clocks_mutex); |
3f0a820c RK |
279 | if (clk->parent) |
280 | list_add(&clk->sibling, &clk->parent->children); | |
281 | else | |
282 | list_add(&clk->sibling, &root_clks); | |
283 | ||
1da177e4 LT |
284 | list_add(&clk->node, &clocks); |
285 | if (clk->init) | |
286 | clk->init(clk); | |
00431707 | 287 | mutex_unlock(&clocks_mutex); |
1a8bfa1e | 288 | |
1da177e4 LT |
289 | return 0; |
290 | } | |
291 | EXPORT_SYMBOL(clk_register); | |
292 | ||
293 | void clk_unregister(struct clk *clk) | |
294 | { | |
b824efae TL |
295 | if (clk == NULL || IS_ERR(clk)) |
296 | return; | |
297 | ||
00431707 | 298 | mutex_lock(&clocks_mutex); |
3f0a820c | 299 | list_del(&clk->sibling); |
1da177e4 | 300 | list_del(&clk->node); |
00431707 | 301 | mutex_unlock(&clocks_mutex); |
1da177e4 LT |
302 | } |
303 | EXPORT_SYMBOL(clk_unregister); | |
304 | ||
6b8858a9 PW |
305 | void clk_enable_init_clocks(void) |
306 | { | |
307 | struct clk *clkp; | |
308 | ||
309 | list_for_each_entry(clkp, &clocks, node) { | |
310 | if (clkp->flags & ENABLE_ON_INIT) | |
311 | clk_enable(clkp); | |
312 | } | |
313 | } | |
6b8858a9 | 314 | |
58e846fe RN |
315 | int omap_clk_enable_autoidle_all(void) |
316 | { | |
317 | struct clk *c; | |
318 | unsigned long flags; | |
319 | ||
320 | spin_lock_irqsave(&clockfw_lock, flags); | |
321 | ||
322 | list_for_each_entry(c, &clocks, node) | |
323 | if (c->ops->allow_idle) | |
324 | c->ops->allow_idle(c); | |
325 | ||
326 | spin_unlock_irqrestore(&clockfw_lock, flags); | |
327 | ||
328 | return 0; | |
329 | } | |
330 | ||
331 | int omap_clk_disable_autoidle_all(void) | |
332 | { | |
333 | struct clk *c; | |
334 | unsigned long flags; | |
335 | ||
336 | spin_lock_irqsave(&clockfw_lock, flags); | |
337 | ||
338 | list_for_each_entry(c, &clocks, node) | |
339 | if (c->ops->deny_idle) | |
340 | c->ops->deny_idle(c); | |
341 | ||
342 | spin_unlock_irqrestore(&clockfw_lock, flags); | |
343 | ||
344 | return 0; | |
345 | } | |
346 | ||
897dcded RK |
347 | /* |
348 | * Low level helpers | |
349 | */ | |
350 | static int clkll_enable_null(struct clk *clk) | |
351 | { | |
352 | return 0; | |
353 | } | |
354 | ||
355 | static void clkll_disable_null(struct clk *clk) | |
356 | { | |
357 | } | |
358 | ||
359 | const struct clkops clkops_null = { | |
360 | .enable = clkll_enable_null, | |
361 | .disable = clkll_disable_null, | |
362 | }; | |
363 | ||
7c43d547 SS |
364 | /* |
365 | * Dummy clock | |
366 | * | |
367 | * Used for clock aliases that are needed on some OMAPs, but not others | |
368 | */ | |
369 | struct clk dummy_ck = { | |
370 | .name = "dummy", | |
371 | .ops = &clkops_null, | |
372 | }; | |
373 | ||
3587aeb0 PW |
374 | /* |
375 | * | |
376 | */ | |
bb13b5fd | 377 | |
90afd5cb TL |
378 | #ifdef CONFIG_OMAP_RESET_CLOCKS |
379 | /* | |
380 | * Disable any unused clocks left on by the bootloader | |
381 | */ | |
382 | static int __init clk_disable_unused(void) | |
383 | { | |
384 | struct clk *ck; | |
385 | unsigned long flags; | |
386 | ||
e07f469d PW |
387 | if (!arch_clock || !arch_clock->clk_disable_unused) |
388 | return 0; | |
389 | ||
6041c27f | 390 | pr_info("clock: disabling unused clocks to save power\n"); |
0eb4fd9b NM |
391 | |
392 | spin_lock_irqsave(&clockfw_lock, flags); | |
90afd5cb | 393 | list_for_each_entry(ck, &clocks, node) { |
897dcded RK |
394 | if (ck->ops == &clkops_null) |
395 | continue; | |
396 | ||
3587aeb0 | 397 | if (ck->usecount > 0 || !ck->enable_reg) |
90afd5cb TL |
398 | continue; |
399 | ||
e07f469d | 400 | arch_clock->clk_disable_unused(ck); |
90afd5cb | 401 | } |
0eb4fd9b | 402 | spin_unlock_irqrestore(&clockfw_lock, flags); |
90afd5cb TL |
403 | |
404 | return 0; | |
405 | } | |
406 | late_initcall(clk_disable_unused); | |
b80b956d | 407 | late_initcall(omap_clk_enable_autoidle_all); |
90afd5cb TL |
408 | #endif |
409 | ||
1a8bfa1e | 410 | int __init clk_init(struct clk_functions * custom_clocks) |
bb13b5fd | 411 | { |
1a8bfa1e | 412 | if (!custom_clocks) { |
6041c27f | 413 | pr_err("No custom clock functions registered\n"); |
1a8bfa1e | 414 | BUG(); |
bb13b5fd TL |
415 | } |
416 | ||
1a8bfa1e TL |
417 | arch_clock = custom_clocks; |
418 | ||
bb13b5fd TL |
419 | return 0; |
420 | } | |
6b8858a9 | 421 | |
137b3ee2 HD |
422 | #if defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS) |
423 | /* | |
424 | * debugfs support to trace clock tree hierarchy and attributes | |
425 | */ | |
a5302572 JH |
426 | |
427 | #include <linux/debugfs.h> | |
428 | #include <linux/seq_file.h> | |
429 | ||
137b3ee2 HD |
430 | static struct dentry *clk_debugfs_root; |
431 | ||
a5302572 JH |
432 | static int clk_dbg_show_summary(struct seq_file *s, void *unused) |
433 | { | |
434 | struct clk *c; | |
435 | struct clk *pa; | |
436 | ||
6bc07d6a | 437 | mutex_lock(&clocks_mutex); |
a5302572 JH |
438 | seq_printf(s, "%-30s %-30s %-10s %s\n", |
439 | "clock-name", "parent-name", "rate", "use-count"); | |
440 | ||
441 | list_for_each_entry(c, &clocks, node) { | |
442 | pa = c->parent; | |
443 | seq_printf(s, "%-30s %-30s %-10lu %d\n", | |
444 | c->name, pa ? pa->name : "none", c->rate, c->usecount); | |
445 | } | |
6bc07d6a | 446 | mutex_unlock(&clocks_mutex); |
a5302572 JH |
447 | |
448 | return 0; | |
449 | } | |
450 | ||
451 | static int clk_dbg_open(struct inode *inode, struct file *file) | |
452 | { | |
453 | return single_open(file, clk_dbg_show_summary, inode->i_private); | |
454 | } | |
455 | ||
456 | static const struct file_operations debug_clock_fops = { | |
457 | .open = clk_dbg_open, | |
458 | .read = seq_read, | |
459 | .llseek = seq_lseek, | |
460 | .release = single_release, | |
461 | }; | |
462 | ||
137b3ee2 HD |
463 | static int clk_debugfs_register_one(struct clk *c) |
464 | { | |
465 | int err; | |
12520c43 | 466 | struct dentry *d; |
137b3ee2 | 467 | struct clk *pa = c->parent; |
137b3ee2 | 468 | |
c066b65a | 469 | d = debugfs_create_dir(c->name, pa ? pa->dent : clk_debugfs_root); |
e621f266 Z |
470 | if (!d) |
471 | return -ENOMEM; | |
137b3ee2 HD |
472 | c->dent = d; |
473 | ||
474 | d = debugfs_create_u8("usecount", S_IRUGO, c->dent, (u8 *)&c->usecount); | |
e621f266 Z |
475 | if (!d) { |
476 | err = -ENOMEM; | |
137b3ee2 HD |
477 | goto err_out; |
478 | } | |
479 | d = debugfs_create_u32("rate", S_IRUGO, c->dent, (u32 *)&c->rate); | |
e621f266 Z |
480 | if (!d) { |
481 | err = -ENOMEM; | |
137b3ee2 HD |
482 | goto err_out; |
483 | } | |
484 | d = debugfs_create_x32("flags", S_IRUGO, c->dent, (u32 *)&c->flags); | |
e621f266 Z |
485 | if (!d) { |
486 | err = -ENOMEM; | |
137b3ee2 HD |
487 | goto err_out; |
488 | } | |
489 | return 0; | |
490 | ||
491 | err_out: | |
12520c43 | 492 | debugfs_remove_recursive(c->dent); |
137b3ee2 HD |
493 | return err; |
494 | } | |
495 | ||
496 | static int clk_debugfs_register(struct clk *c) | |
497 | { | |
498 | int err; | |
499 | struct clk *pa = c->parent; | |
500 | ||
501 | if (pa && !pa->dent) { | |
502 | err = clk_debugfs_register(pa); | |
503 | if (err) | |
504 | return err; | |
505 | } | |
506 | ||
507 | if (!c->dent) { | |
508 | err = clk_debugfs_register_one(c); | |
509 | if (err) | |
510 | return err; | |
511 | } | |
512 | return 0; | |
513 | } | |
514 | ||
515 | static int __init clk_debugfs_init(void) | |
516 | { | |
517 | struct clk *c; | |
518 | struct dentry *d; | |
519 | int err; | |
520 | ||
521 | d = debugfs_create_dir("clock", NULL); | |
e621f266 Z |
522 | if (!d) |
523 | return -ENOMEM; | |
137b3ee2 HD |
524 | clk_debugfs_root = d; |
525 | ||
526 | list_for_each_entry(c, &clocks, node) { | |
527 | err = clk_debugfs_register(c); | |
528 | if (err) | |
529 | goto err_out; | |
530 | } | |
a5302572 JH |
531 | |
532 | d = debugfs_create_file("summary", S_IRUGO, | |
533 | d, NULL, &debug_clock_fops); | |
534 | if (!d) | |
535 | return -ENOMEM; | |
536 | ||
137b3ee2 HD |
537 | return 0; |
538 | err_out: | |
ca4caa4e | 539 | debugfs_remove_recursive(clk_debugfs_root); |
137b3ee2 HD |
540 | return err; |
541 | } | |
542 | late_initcall(clk_debugfs_init); | |
543 | ||
544 | #endif /* defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS) */ |