772892826ffc88c59e8b2641a665a7f5169e6446
[pandora-kernel.git] / arch / arm / plat-samsung / clock.c
1 /* linux/arch/arm/plat-s3c24xx/clock.c
2  *
3  * Copyright 2004-2005 Simtec Electronics
4  *      Ben Dooks <ben@simtec.co.uk>
5  *
6  * S3C24XX Core clock control support
7  *
8  * Based on, and code from linux/arch/arm/mach-versatile/clock.c
9  **
10  **  Copyright (C) 2004 ARM Limited.
11  **  Written by Deep Blue Solutions Limited.
12  *
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
27 */
28
29 #include <linux/init.h>
30 #include <linux/module.h>
31 #include <linux/kernel.h>
32 #include <linux/list.h>
33 #include <linux/errno.h>
34 #include <linux/err.h>
35 #include <linux/platform_device.h>
36 #include <linux/sysdev.h>
37 #include <linux/interrupt.h>
38 #include <linux/ioport.h>
39 #include <linux/clk.h>
40 #include <linux/spinlock.h>
41 #include <linux/io.h>
42 #if defined(CONFIG_DEBUG_FS)
43 #include <linux/debugfs.h>
44 #endif
45
46 #include <mach/hardware.h>
47 #include <asm/irq.h>
48
49 #include <plat/cpu-freq.h>
50
51 #include <plat/clock.h>
52 #include <plat/cpu.h>
53
54 #include <linux/serial_core.h>
55 #include <plat/regs-serial.h> /* for s3c24xx_uart_devs */
56
57 /* clock information */
58
59 static LIST_HEAD(clocks);
60
61 /* We originally used an mutex here, but some contexts (see resume)
62  * are calling functions such as clk_set_parent() with IRQs disabled
63  * causing an BUG to be triggered.
64  */
65 DEFINE_SPINLOCK(clocks_lock);
66
67 /* enable and disable calls for use with the clk struct */
68
69 static int clk_null_enable(struct clk *clk, int enable)
70 {
71         return 0;
72 }
73
74 static int dev_is_s3c_uart(struct device *dev)
75 {
76         struct platform_device **pdev = s3c24xx_uart_devs;
77         int i;
78         for (i = 0; i < ARRAY_SIZE(s3c24xx_uart_devs); i++, pdev++)
79                 if (*pdev && dev == &(*pdev)->dev)
80                         return 1;
81         return 0;
82 }
83
84 /*
85  * Serial drivers call get_clock() very early, before platform bus
86  * has been set up, this requires a special check to let them get
87  * a proper clock
88  */
89
90 static int dev_is_platform_device(struct device *dev)
91 {
92         return dev->bus == &platform_bus_type ||
93                (dev->bus == NULL && dev_is_s3c_uart(dev));
94 }
95
96 /* Clock API calls */
97
98 struct clk *clk_get(struct device *dev, const char *id)
99 {
100         struct clk *p;
101         struct clk *clk = ERR_PTR(-ENOENT);
102         int idno;
103
104         if (dev == NULL || !dev_is_platform_device(dev))
105                 idno = -1;
106         else
107                 idno = to_platform_device(dev)->id;
108
109         spin_lock(&clocks_lock);
110
111         list_for_each_entry(p, &clocks, list) {
112                 if (p->id == idno &&
113                     strcmp(id, p->name) == 0 &&
114                     try_module_get(p->owner)) {
115                         clk = p;
116                         break;
117                 }
118         }
119
120         /* check for the case where a device was supplied, but the
121          * clock that was being searched for is not device specific */
122
123         if (IS_ERR(clk)) {
124                 list_for_each_entry(p, &clocks, list) {
125                         if (p->id == -1 && strcmp(id, p->name) == 0 &&
126                             try_module_get(p->owner)) {
127                                 clk = p;
128                                 break;
129                         }
130                 }
131         }
132
133         spin_unlock(&clocks_lock);
134         return clk;
135 }
136
137 void clk_put(struct clk *clk)
138 {
139         module_put(clk->owner);
140 }
141
142 int clk_enable(struct clk *clk)
143 {
144         if (IS_ERR(clk) || clk == NULL)
145                 return -EINVAL;
146
147         clk_enable(clk->parent);
148
149         spin_lock(&clocks_lock);
150
151         if ((clk->usage++) == 0)
152                 (clk->enable)(clk, 1);
153
154         spin_unlock(&clocks_lock);
155         return 0;
156 }
157
158 void clk_disable(struct clk *clk)
159 {
160         if (IS_ERR(clk) || clk == NULL)
161                 return;
162
163         spin_lock(&clocks_lock);
164
165         if ((--clk->usage) == 0)
166                 (clk->enable)(clk, 0);
167
168         spin_unlock(&clocks_lock);
169         clk_disable(clk->parent);
170 }
171
172
173 unsigned long clk_get_rate(struct clk *clk)
174 {
175         if (IS_ERR(clk))
176                 return 0;
177
178         if (clk->rate != 0)
179                 return clk->rate;
180
181         if (clk->ops != NULL && clk->ops->get_rate != NULL)
182                 return (clk->ops->get_rate)(clk);
183
184         if (clk->parent != NULL)
185                 return clk_get_rate(clk->parent);
186
187         return clk->rate;
188 }
189
190 long clk_round_rate(struct clk *clk, unsigned long rate)
191 {
192         if (!IS_ERR(clk) && clk->ops && clk->ops->round_rate)
193                 return (clk->ops->round_rate)(clk, rate);
194
195         return rate;
196 }
197
198 int clk_set_rate(struct clk *clk, unsigned long rate)
199 {
200         int ret;
201
202         if (IS_ERR(clk))
203                 return -EINVAL;
204
205         /* We do not default just do a clk->rate = rate as
206          * the clock may have been made this way by choice.
207          */
208
209         WARN_ON(clk->ops == NULL);
210         WARN_ON(clk->ops && clk->ops->set_rate == NULL);
211
212         if (clk->ops == NULL || clk->ops->set_rate == NULL)
213                 return -EINVAL;
214
215         spin_lock(&clocks_lock);
216         ret = (clk->ops->set_rate)(clk, rate);
217         spin_unlock(&clocks_lock);
218
219         return ret;
220 }
221
222 struct clk *clk_get_parent(struct clk *clk)
223 {
224         return clk->parent;
225 }
226
227 int clk_set_parent(struct clk *clk, struct clk *parent)
228 {
229         int ret = 0;
230
231         if (IS_ERR(clk))
232                 return -EINVAL;
233
234         spin_lock(&clocks_lock);
235
236         if (clk->ops && clk->ops->set_parent)
237                 ret = (clk->ops->set_parent)(clk, parent);
238
239         spin_unlock(&clocks_lock);
240
241         return ret;
242 }
243
244 EXPORT_SYMBOL(clk_get);
245 EXPORT_SYMBOL(clk_put);
246 EXPORT_SYMBOL(clk_enable);
247 EXPORT_SYMBOL(clk_disable);
248 EXPORT_SYMBOL(clk_get_rate);
249 EXPORT_SYMBOL(clk_round_rate);
250 EXPORT_SYMBOL(clk_set_rate);
251 EXPORT_SYMBOL(clk_get_parent);
252 EXPORT_SYMBOL(clk_set_parent);
253
254 /* base clocks */
255
256 int clk_default_setrate(struct clk *clk, unsigned long rate)
257 {
258         clk->rate = rate;
259         return 0;
260 }
261
262 struct clk_ops clk_ops_def_setrate = {
263         .set_rate       = clk_default_setrate,
264 };
265
266 struct clk clk_xtal = {
267         .name           = "xtal",
268         .id             = -1,
269         .rate           = 0,
270         .parent         = NULL,
271         .ctrlbit        = 0,
272 };
273
274 struct clk clk_ext = {
275         .name           = "ext",
276         .id             = -1,
277 };
278
279 struct clk clk_epll = {
280         .name           = "epll",
281         .id             = -1,
282 };
283
284 struct clk clk_mpll = {
285         .name           = "mpll",
286         .id             = -1,
287         .ops            = &clk_ops_def_setrate,
288 };
289
290 struct clk clk_upll = {
291         .name           = "upll",
292         .id             = -1,
293         .parent         = NULL,
294         .ctrlbit        = 0,
295 };
296
297 struct clk clk_f = {
298         .name           = "fclk",
299         .id             = -1,
300         .rate           = 0,
301         .parent         = &clk_mpll,
302         .ctrlbit        = 0,
303 };
304
305 struct clk clk_h = {
306         .name           = "hclk",
307         .id             = -1,
308         .rate           = 0,
309         .parent         = NULL,
310         .ctrlbit        = 0,
311         .ops            = &clk_ops_def_setrate,
312 };
313
314 struct clk clk_p = {
315         .name           = "pclk",
316         .id             = -1,
317         .rate           = 0,
318         .parent         = NULL,
319         .ctrlbit        = 0,
320         .ops            = &clk_ops_def_setrate,
321 };
322
323 struct clk clk_usb_bus = {
324         .name           = "usb-bus",
325         .id             = -1,
326         .rate           = 0,
327         .parent         = &clk_upll,
328 };
329
330
331 struct clk s3c24xx_uclk = {
332         .name           = "uclk",
333         .id             = -1,
334 };
335
336 /* initialise the clock system */
337
338 /**
339  * s3c24xx_register_clock() - register a clock
340  * @clk: The clock to register
341  *
342  * Add the specified clock to the list of clocks known by the system.
343  */
344 int s3c24xx_register_clock(struct clk *clk)
345 {
346         if (clk->enable == NULL)
347                 clk->enable = clk_null_enable;
348
349         /* add to the list of available clocks */
350
351         /* Quick check to see if this clock has already been registered. */
352         BUG_ON(clk->list.prev != clk->list.next);
353
354         spin_lock(&clocks_lock);
355         list_add(&clk->list, &clocks);
356         spin_unlock(&clocks_lock);
357
358         return 0;
359 }
360
361 /**
362  * s3c24xx_register_clocks() - register an array of clock pointers
363  * @clks: Pointer to an array of struct clk pointers
364  * @nr_clks: The number of clocks in the @clks array.
365  *
366  * Call s3c24xx_register_clock() for all the clock pointers contained
367  * in the @clks list. Returns the number of failures.
368  */
369 int s3c24xx_register_clocks(struct clk **clks, int nr_clks)
370 {
371         int fails = 0;
372
373         for (; nr_clks > 0; nr_clks--, clks++) {
374                 if (s3c24xx_register_clock(*clks) < 0) {
375                         struct clk *clk = *clks;
376                         printk(KERN_ERR "%s: failed to register %p: %s\n",
377                                __func__, clk, clk->name);
378                         fails++;
379                 }
380         }
381
382         return fails;
383 }
384
385 /**
386  * s3c_register_clocks() - register an array of clocks
387  * @clkp: Pointer to the first clock in the array.
388  * @nr_clks: Number of clocks to register.
389  *
390  * Call s3c24xx_register_clock() on the @clkp array given, printing an
391  * error if it fails to register the clock (unlikely).
392  */
393 void __init s3c_register_clocks(struct clk *clkp, int nr_clks)
394 {
395         int ret;
396
397         for (; nr_clks > 0; nr_clks--, clkp++) {
398                 ret = s3c24xx_register_clock(clkp);
399
400                 if (ret < 0) {
401                         printk(KERN_ERR "Failed to register clock %s (%d)\n",
402                                clkp->name, ret);
403                 }
404         }
405 }
406
407 /**
408  * s3c_disable_clocks() - disable an array of clocks
409  * @clkp: Pointer to the first clock in the array.
410  * @nr_clks: Number of clocks to register.
411  *
412  * for internal use only at initialisation time. disable the clocks in the
413  * @clkp array.
414  */
415
416 void __init s3c_disable_clocks(struct clk *clkp, int nr_clks)
417 {
418         for (; nr_clks > 0; nr_clks--, clkp++)
419                 (clkp->enable)(clkp, 0);
420 }
421
422 /* initialise all the clocks */
423
424 int __init s3c24xx_register_baseclocks(unsigned long xtal)
425 {
426         printk(KERN_INFO "S3C24XX Clocks, Copyright 2004 Simtec Electronics\n");
427
428         clk_xtal.rate = xtal;
429
430         /* register our clocks */
431
432         if (s3c24xx_register_clock(&clk_xtal) < 0)
433                 printk(KERN_ERR "failed to register master xtal\n");
434
435         if (s3c24xx_register_clock(&clk_mpll) < 0)
436                 printk(KERN_ERR "failed to register mpll clock\n");
437
438         if (s3c24xx_register_clock(&clk_upll) < 0)
439                 printk(KERN_ERR "failed to register upll clock\n");
440
441         if (s3c24xx_register_clock(&clk_f) < 0)
442                 printk(KERN_ERR "failed to register cpu fclk\n");
443
444         if (s3c24xx_register_clock(&clk_h) < 0)
445                 printk(KERN_ERR "failed to register cpu hclk\n");
446
447         if (s3c24xx_register_clock(&clk_p) < 0)
448                 printk(KERN_ERR "failed to register cpu pclk\n");
449
450         return 0;
451 }
452
453 #if defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS)
454 /* debugfs support to trace clock tree hierarchy and attributes */
455
456 static struct dentry *clk_debugfs_root;
457
458 static int clk_debugfs_register_one(struct clk *c)
459 {
460         int err;
461         struct dentry *d, *child, *child_tmp;
462         struct clk *pa = c->parent;
463         char s[255];
464         char *p = s;
465
466         p += sprintf(p, "%s", c->name);
467
468         if (c->id >= 0)
469                 sprintf(p, ":%d", c->id);
470
471         d = debugfs_create_dir(s, pa ? pa->dent : clk_debugfs_root);
472         if (!d)
473                 return -ENOMEM;
474
475         c->dent = d;
476
477         d = debugfs_create_u8("usecount", S_IRUGO, c->dent, (u8 *)&c->usage);
478         if (!d) {
479                 err = -ENOMEM;
480                 goto err_out;
481         }
482
483         d = debugfs_create_u32("rate", S_IRUGO, c->dent, (u32 *)&c->rate);
484         if (!d) {
485                 err = -ENOMEM;
486                 goto err_out;
487         }
488         return 0;
489
490 err_out:
491         d = c->dent;
492         list_for_each_entry_safe(child, child_tmp, &d->d_subdirs, d_u.d_child)
493                 debugfs_remove(child);
494         debugfs_remove(c->dent);
495         return err;
496 }
497
498 static int clk_debugfs_register(struct clk *c)
499 {
500         int err;
501         struct clk *pa = c->parent;
502
503         if (pa && !pa->dent) {
504                 err = clk_debugfs_register(pa);
505                 if (err)
506                         return err;
507         }
508
509         if (!c->dent) {
510                 err = clk_debugfs_register_one(c);
511                 if (err)
512                         return err;
513         }
514         return 0;
515 }
516
517 static int __init clk_debugfs_init(void)
518 {
519         struct clk *c;
520         struct dentry *d;
521         int err;
522
523         d = debugfs_create_dir("clock", NULL);
524         if (!d)
525                 return -ENOMEM;
526         clk_debugfs_root = d;
527
528         list_for_each_entry(c, &clocks, list) {
529                 err = clk_debugfs_register(c);
530                 if (err)
531                         goto err_out;
532         }
533         return 0;
534
535 err_out:
536         debugfs_remove_recursive(clk_debugfs_root);
537         return err;
538 }
539 late_initcall(clk_debugfs_init);
540
541 #endif /* defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS) */