[ARM] 3142/1: OMAP 2/5: Update files common to omap1 and omap2
[linux-2.6] / arch / arm / plat-omap / clock.c
1 /*
2  *  linux/arch/arm/plat-omap/clock.c
3  *
4  *  Copyright (C) 2004 - 2005 Nokia corporation
5  *  Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
6  *
7  *  Modified for omap shared clock framework by Tony Lindgren <tony@atomide.com>
8  *
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  */
13 #include <linux/version.h>
14 #include <linux/config.h>
15 #include <linux/kernel.h>
16 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/list.h>
19 #include <linux/errno.h>
20 #include <linux/err.h>
21 #include <linux/string.h>
22
23 #include <asm/io.h>
24 #include <asm/semaphore.h>
25 #include <asm/hardware/clock.h>
26
27 #include <asm/arch/clock.h>
28
29 LIST_HEAD(clocks);
30 static DECLARE_MUTEX(clocks_sem);
31 DEFINE_SPINLOCK(clockfw_lock);
32
33 static struct clk_functions *arch_clock;
34
35 /*-------------------------------------------------------------------------
36  * Standard clock functions defined in asm/hardware/clock.h
37  *-------------------------------------------------------------------------*/
38
39 struct clk * clk_get(struct device *dev, const char *id)
40 {
41         struct clk *p, *clk = ERR_PTR(-ENOENT);
42
43         down(&clocks_sem);
44         list_for_each_entry(p, &clocks, node) {
45                 if (strcmp(id, p->name) == 0 && try_module_get(p->owner)) {
46                         clk = p;
47                         break;
48                 }
49         }
50         up(&clocks_sem);
51
52         return clk;
53 }
54 EXPORT_SYMBOL(clk_get);
55
56 int clk_enable(struct clk *clk)
57 {
58         unsigned long flags;
59         int ret = 0;
60
61         spin_lock_irqsave(&clockfw_lock, flags);
62         if (clk->enable)
63                 ret = clk->enable(clk);
64         else if (arch_clock->clk_enable)
65                 ret = arch_clock->clk_enable(clk);
66         else
67                 printk(KERN_ERR "Could not enable clock %s\n", clk->name);
68         spin_unlock_irqrestore(&clockfw_lock, flags);
69
70         return ret;
71 }
72 EXPORT_SYMBOL(clk_enable);
73
74 void clk_disable(struct clk *clk)
75 {
76         unsigned long flags;
77
78         spin_lock_irqsave(&clockfw_lock, flags);
79         if (clk->disable)
80                 clk->disable(clk);
81         else if (arch_clock->clk_disable)
82                 arch_clock->clk_disable(clk);
83         else
84                 printk(KERN_ERR "Could not disable clock %s\n", clk->name);
85         spin_unlock_irqrestore(&clockfw_lock, flags);
86 }
87 EXPORT_SYMBOL(clk_disable);
88
89 int clk_use(struct clk *clk)
90 {
91         unsigned long flags;
92         int ret = 0;
93
94         spin_lock_irqsave(&clockfw_lock, flags);
95         if (arch_clock->clk_use)
96                 ret = arch_clock->clk_use(clk);
97         spin_unlock_irqrestore(&clockfw_lock, flags);
98
99         return ret;
100 }
101 EXPORT_SYMBOL(clk_use);
102
103 void clk_unuse(struct clk *clk)
104 {
105         unsigned long flags;
106
107         spin_lock_irqsave(&clockfw_lock, flags);
108         if (arch_clock->clk_unuse)
109                 arch_clock->clk_unuse(clk);
110         spin_unlock_irqrestore(&clockfw_lock, flags);
111 }
112 EXPORT_SYMBOL(clk_unuse);
113
114 int clk_get_usecount(struct clk *clk)
115 {
116         unsigned long flags;
117         int ret = 0;
118
119         spin_lock_irqsave(&clockfw_lock, flags);
120         ret = clk->usecount;
121         spin_unlock_irqrestore(&clockfw_lock, flags);
122
123         return ret;
124 }
125 EXPORT_SYMBOL(clk_get_usecount);
126
127 unsigned long clk_get_rate(struct clk *clk)
128 {
129         unsigned long flags;
130         unsigned long ret = 0;
131
132         spin_lock_irqsave(&clockfw_lock, flags);
133         ret = clk->rate;
134         spin_unlock_irqrestore(&clockfw_lock, flags);
135
136         return ret;
137 }
138 EXPORT_SYMBOL(clk_get_rate);
139
140 void clk_put(struct clk *clk)
141 {
142         if (clk && !IS_ERR(clk))
143                 module_put(clk->owner);
144 }
145 EXPORT_SYMBOL(clk_put);
146
147 /*-------------------------------------------------------------------------
148  * Optional clock functions defined in asm/hardware/clock.h
149  *-------------------------------------------------------------------------*/
150
151 long clk_round_rate(struct clk *clk, unsigned long rate)
152 {
153         unsigned long flags;
154         long ret = 0;
155
156         spin_lock_irqsave(&clockfw_lock, flags);
157         if (arch_clock->clk_round_rate)
158                 ret = arch_clock->clk_round_rate(clk, rate);
159         spin_unlock_irqrestore(&clockfw_lock, flags);
160
161         return ret;
162 }
163 EXPORT_SYMBOL(clk_round_rate);
164
165 int clk_set_rate(struct clk *clk, unsigned long rate)
166 {
167         unsigned long flags;
168         int ret = 0;
169
170         spin_lock_irqsave(&clockfw_lock, flags);
171         if (arch_clock->clk_set_rate)
172                 ret = arch_clock->clk_set_rate(clk, rate);
173         spin_unlock_irqrestore(&clockfw_lock, flags);
174
175         return ret;
176 }
177 EXPORT_SYMBOL(clk_set_rate);
178
179 int clk_set_parent(struct clk *clk, struct clk *parent)
180 {
181         unsigned long flags;
182         int ret = 0;
183
184         spin_lock_irqsave(&clockfw_lock, flags);
185         if (arch_clock->clk_set_parent)
186                 ret =  arch_clock->clk_set_parent(clk, parent);
187         spin_unlock_irqrestore(&clockfw_lock, flags);
188
189         return ret;
190 }
191 EXPORT_SYMBOL(clk_set_parent);
192
193 struct clk *clk_get_parent(struct clk *clk)
194 {
195         unsigned long flags;
196         struct clk * ret = NULL;
197
198         spin_lock_irqsave(&clockfw_lock, flags);
199         if (arch_clock->clk_get_parent)
200                 ret = arch_clock->clk_get_parent(clk);
201         spin_unlock_irqrestore(&clockfw_lock, flags);
202
203         return ret;
204 }
205 EXPORT_SYMBOL(clk_get_parent);
206
207 /*-------------------------------------------------------------------------
208  * OMAP specific clock functions shared between omap1 and omap2
209  *-------------------------------------------------------------------------*/
210
211 unsigned int __initdata mpurate;
212
213 /*
214  * By default we use the rate set by the bootloader.
215  * You can override this with mpurate= cmdline option.
216  */
217 static int __init omap_clk_setup(char *str)
218 {
219         get_option(&str, &mpurate);
220
221         if (!mpurate)
222                 return 1;
223
224         if (mpurate < 1000)
225                 mpurate *= 1000000;
226
227         return 1;
228 }
229 __setup("mpurate=", omap_clk_setup);
230
231 /* Used for clocks that always have same value as the parent clock */
232 void followparent_recalc(struct clk *clk)
233 {
234         clk->rate = clk->parent->rate;
235 }
236
237 /* Propagate rate to children */
238 void propagate_rate(struct clk * tclk)
239 {
240         struct clk *clkp;
241
242         list_for_each_entry(clkp, &clocks, node) {
243                 if (likely(clkp->parent != tclk))
244                         continue;
245                 if (likely((u32)clkp->recalc))
246                         clkp->recalc(clkp);
247         }
248 }
249
250 int clk_register(struct clk *clk)
251 {
252         down(&clocks_sem);
253         list_add(&clk->node, &clocks);
254         if (clk->init)
255                 clk->init(clk);
256         up(&clocks_sem);
257
258         return 0;
259 }
260 EXPORT_SYMBOL(clk_register);
261
262 void clk_unregister(struct clk *clk)
263 {
264         down(&clocks_sem);
265         list_del(&clk->node);
266         up(&clocks_sem);
267 }
268 EXPORT_SYMBOL(clk_unregister);
269
270 void clk_deny_idle(struct clk *clk)
271 {
272         unsigned long flags;
273
274         spin_lock_irqsave(&clockfw_lock, flags);
275         if (arch_clock->clk_deny_idle)
276                 arch_clock->clk_deny_idle(clk);
277         spin_unlock_irqrestore(&clockfw_lock, flags);
278 }
279 EXPORT_SYMBOL(clk_deny_idle);
280
281 void clk_allow_idle(struct clk *clk)
282 {
283         unsigned long flags;
284
285         spin_lock_irqsave(&clockfw_lock, flags);
286         if (arch_clock->clk_allow_idle)
287                 arch_clock->clk_allow_idle(clk);
288         spin_unlock_irqrestore(&clockfw_lock, flags);
289 }
290 EXPORT_SYMBOL(clk_allow_idle);
291
292 /*-------------------------------------------------------------------------*/
293
294 int __init clk_init(struct clk_functions * custom_clocks)
295 {
296         if (!custom_clocks) {
297                 printk(KERN_ERR "No custom clock functions registered\n");
298                 BUG();
299         }
300
301         arch_clock = custom_clocks;
302
303         return 0;
304 }