[ARM] tegra: clock: Add dvfs support, bug fixes, and cleanups
[linux-2.6.git] / arch / arm / mach-tegra / clock.c
1 /*
2  *
3  * Copyright (C) 2010 Google, Inc.
4  *
5  * Author:
6  *      Colin Cross <ccross@google.com>
7  *
8  * This software is licensed under the terms of the GNU General Public
9  * License version 2, as published by the Free Software Foundation, and
10  * may be copied, distributed, and modified under those terms.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  */
18
19 #include <linux/kernel.h>
20 #include <linux/clk.h>
21 #include <linux/list.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/debugfs.h>
25 #include <linux/slab.h>
26 #include <linux/seq_file.h>
27 #include <linux/regulator/consumer.h>
28 #include <asm/clkdev.h>
29
30 #include "clock.h"
31 #include "board.h"
32 #include "fuse.h"
33
34 static LIST_HEAD(clocks);
35
36 static DEFINE_SPINLOCK(clock_lock);
37 static DEFINE_MUTEX(dvfs_lock);
38
39 static int clk_is_dvfs(struct clk *c)
40 {
41         return (c->dvfs != NULL);
42 };
43
44 static int dvfs_set_rate(struct dvfs *d, unsigned long rate)
45 {
46         struct dvfs_table *t;
47
48         if (d->table == NULL)
49                 return -ENODEV;
50
51         for (t = d->table; t->rate != 0; t++) {
52                 if (rate <= t->rate) {
53                         if (!d->reg)
54                                 return 0;
55
56                         return regulator_set_voltage(d->reg,
57                                 t->millivolts * 1000,
58                                 d->max_millivolts * 1000);
59                 }
60         }
61
62         return -EINVAL;
63 }
64
65 static void dvfs_init(struct clk *c)
66 {
67         int process_id;
68         int i;
69         struct dvfs_table *table;
70
71         process_id = c->dvfs->cpu ? tegra_core_process_id() :
72                 tegra_cpu_process_id();
73
74         for (i = 0; i < c->dvfs->process_id_table_length; i++)
75                 if (process_id == c->dvfs->process_id_table[i].process_id)
76                         c->dvfs->table = c->dvfs->process_id_table[i].table;
77
78         if (c->dvfs->table == NULL) {
79                 pr_err("Failed to find dvfs table for clock %s process %d\n",
80                         c->name, process_id);
81                 return;
82         }
83
84         c->dvfs->max_millivolts = 0;
85         for (table = c->dvfs->table; table->rate != 0; table++)
86                 if (c->dvfs->max_millivolts < table->millivolts)
87                         c->dvfs->max_millivolts = table->millivolts;
88
89         c->dvfs->reg = regulator_get(NULL, c->dvfs->reg_id);
90
91         if (IS_ERR(c->dvfs->reg)) {
92                 pr_err("Failed to get regulator %s for clock %s\n",
93                         c->dvfs->reg_id, c->name);
94                 c->dvfs->reg = NULL;
95                 return;
96         }
97
98         if (c->refcnt > 0)
99                 dvfs_set_rate(c->dvfs, c->rate);
100 }
101
102 struct clk *tegra_get_clock_by_name(const char *name)
103 {
104         struct clk *c;
105         struct clk *ret = NULL;
106         unsigned long flags;
107         spin_lock_irqsave(&clock_lock, flags);
108         list_for_each_entry(c, &clocks, node) {
109                 if (strcmp(c->name, name) == 0) {
110                         ret = c;
111                         break;
112                 }
113         }
114         spin_unlock_irqrestore(&clock_lock, flags);
115         return ret;
116 }
117
118 static void clk_recalculate_rate(struct clk *c)
119 {
120         u64 rate;
121
122         if (!c->parent)
123                 return;
124
125         rate = c->parent->rate;
126
127         if (c->mul != 0 && c->div != 0) {
128                 rate = rate * c->mul;
129                 do_div(rate, c->div);
130         }
131
132         if (rate > c->max_rate)
133                 pr_warn("clocks: Set clock %s to rate %llu, max is %lu\n",
134                         c->name, rate, c->max_rate);
135
136         c->rate = rate;
137 }
138
139 int clk_reparent(struct clk *c, struct clk *parent)
140 {
141         pr_debug("%s: %s\n", __func__, c->name);
142         c->parent = parent;
143         list_del(&c->sibling);
144         list_add_tail(&c->sibling, &parent->children);
145         return 0;
146 }
147
148 static void propagate_rate(struct clk *c)
149 {
150         struct clk *clkp;
151         pr_debug("%s: %s\n", __func__, c->name);
152         list_for_each_entry(clkp, &c->children, sibling) {
153                 pr_debug("   %s\n", clkp->name);
154                 clk_recalculate_rate(clkp);
155                 propagate_rate(clkp);
156         }
157 }
158
159 void clk_init(struct clk *c)
160 {
161         unsigned long flags;
162
163         pr_debug("%s: %s\n", __func__, c->name);
164
165         spin_lock_irqsave(&clock_lock, flags);
166
167         INIT_LIST_HEAD(&c->children);
168         INIT_LIST_HEAD(&c->sibling);
169
170         if (c->ops && c->ops->init)
171                 c->ops->init(c);
172
173         clk_recalculate_rate(c);
174
175         list_add(&c->node, &clocks);
176
177         if (c->parent)
178                 list_add_tail(&c->sibling, &c->parent->children);
179
180         spin_unlock_irqrestore(&clock_lock, flags);
181 }
182
183 int clk_enable_locked(struct clk *c)
184 {
185         int ret;
186         pr_debug("%s: %s\n", __func__, c->name);
187         if (c->refcnt == 0) {
188                 if (c->parent) {
189                         ret = clk_enable_locked(c->parent);
190                         if (ret)
191                                 return ret;
192                 }
193
194                 if (c->ops && c->ops->enable) {
195                         ret = c->ops->enable(c);
196                         if (ret) {
197                                 if (c->parent)
198                                         clk_disable_locked(c->parent);
199                                 return ret;
200                         }
201                         c->state = ON;
202 #ifdef CONFIG_DEBUG_FS
203                         c->set = 1;
204 #endif
205                 }
206         }
207         c->refcnt++;
208
209         return 0;
210 }
211
212 int clk_enable_cansleep(struct clk *c)
213 {
214         int ret;
215         unsigned long flags;
216
217         mutex_lock(&dvfs_lock);
218
219         if (clk_is_dvfs(c) && c->refcnt > 0)
220                 dvfs_set_rate(c->dvfs, c->rate);
221
222         spin_lock_irqsave(&clock_lock, flags);
223         ret = clk_enable_locked(c);
224         spin_unlock_irqrestore(&clock_lock, flags);
225
226         mutex_unlock(&dvfs_lock);
227
228         return ret;
229 }
230 EXPORT_SYMBOL(clk_enable_cansleep);
231
232 int clk_enable(struct clk *c)
233 {
234         int ret;
235         unsigned long flags;
236
237         if (clk_is_dvfs(c))
238                 BUG();
239
240         spin_lock_irqsave(&clock_lock, flags);
241         ret = clk_enable_locked(c);
242         spin_unlock_irqrestore(&clock_lock, flags);
243
244         return ret;
245 }
246 EXPORT_SYMBOL(clk_enable);
247
248 void clk_disable_locked(struct clk *c)
249 {
250         pr_debug("%s: %s\n", __func__, c->name);
251         if (c->refcnt == 0) {
252                 WARN(1, "Attempting to disable clock %s with refcnt 0", c->name);
253                 return;
254         }
255         if (c->refcnt == 1) {
256                 if (c->ops && c->ops->disable)
257                         c->ops->disable(c);
258
259                 if (c->parent)
260                         clk_disable_locked(c->parent);
261
262                 c->state = OFF;
263         }
264         c->refcnt--;
265 }
266
267 void clk_disable_cansleep(struct clk *c)
268 {
269         unsigned long flags;
270
271         mutex_lock(&dvfs_lock);
272
273         spin_lock_irqsave(&clock_lock, flags);
274         clk_disable_locked(c);
275         spin_unlock_irqrestore(&clock_lock, flags);
276
277         if (clk_is_dvfs(c) && c->refcnt == 0)
278                 dvfs_set_rate(c->dvfs, c->rate);
279
280         mutex_unlock(&dvfs_lock);
281 }
282 EXPORT_SYMBOL(clk_disable_cansleep);
283
284 void clk_disable(struct clk *c)
285 {
286         unsigned long flags;
287
288         if (clk_is_dvfs(c))
289                 BUG();
290
291         spin_lock_irqsave(&clock_lock, flags);
292         clk_disable_locked(c);
293         spin_unlock_irqrestore(&clock_lock, flags);
294 }
295 EXPORT_SYMBOL(clk_disable);
296
297 int clk_set_parent_locked(struct clk *c, struct clk *parent)
298 {
299         int ret;
300
301         pr_debug("%s: %s\n", __func__, c->name);
302
303         if (!c->ops || !c->ops->set_parent)
304                 return -ENOSYS;
305
306         ret = c->ops->set_parent(c, parent);
307
308         if (ret)
309                 return ret;
310
311         clk_recalculate_rate(c);
312
313         propagate_rate(c);
314
315         return 0;
316 }
317
318 int clk_set_parent(struct clk *c, struct clk *parent)
319 {
320         int ret;
321         unsigned long flags;
322         spin_lock_irqsave(&clock_lock, flags);
323         ret = clk_set_parent_locked(c, parent);
324         spin_unlock_irqrestore(&clock_lock, flags);
325         return ret;
326 }
327 EXPORT_SYMBOL(clk_set_parent);
328
329 struct clk *clk_get_parent(struct clk *c)
330 {
331         return c->parent;
332 }
333 EXPORT_SYMBOL(clk_get_parent);
334
335 int clk_set_rate_locked(struct clk *c, unsigned long rate)
336 {
337         int ret;
338
339         if (rate > c->max_rate)
340                 rate = c->max_rate;
341
342         if (!c->ops || !c->ops->set_rate)
343                 return -ENOSYS;
344
345         ret = c->ops->set_rate(c, rate);
346
347         if (ret)
348                 return ret;
349
350         clk_recalculate_rate(c);
351
352         propagate_rate(c);
353
354         return 0;
355 }
356
357 int clk_set_rate_cansleep(struct clk *c, unsigned long rate)
358 {
359         int ret = 0;
360         unsigned long flags;
361
362         pr_debug("%s: %s\n", __func__, c->name);
363
364         mutex_lock(&dvfs_lock);
365
366         if (rate > c->rate)
367                 ret = dvfs_set_rate(c->dvfs, rate);
368         if (ret)
369                 goto out;
370
371         spin_lock_irqsave(&clock_lock, flags);
372         ret = clk_set_rate_locked(c, rate);
373         spin_unlock_irqrestore(&clock_lock, flags);
374
375         if (ret)
376                 goto out;
377
378         ret = dvfs_set_rate(c->dvfs, rate);
379
380 out:
381         mutex_unlock(&dvfs_lock);
382         return ret;
383 }
384 EXPORT_SYMBOL(clk_set_rate_cansleep);
385
386 int clk_set_rate(struct clk *c, unsigned long rate)
387 {
388         int ret = 0;
389         unsigned long flags;
390
391         pr_debug("%s: %s\n", __func__, c->name);
392
393         if (clk_is_dvfs(c))
394                 BUG();
395
396         spin_lock_irqsave(&clock_lock, flags);
397         ret = clk_set_rate_locked(c, rate);
398         spin_unlock_irqrestore(&clock_lock, flags);
399
400         return ret;
401 }
402 EXPORT_SYMBOL(clk_set_rate);
403
404 unsigned long clk_get_rate(struct clk *c)
405 {
406         unsigned long flags;
407         unsigned long ret;
408
409         spin_lock_irqsave(&clock_lock, flags);
410
411         pr_debug("%s: %s\n", __func__, c->name);
412
413         ret = c->rate;
414
415         spin_unlock_irqrestore(&clock_lock, flags);
416         return ret;
417 }
418 EXPORT_SYMBOL(clk_get_rate);
419
420 long clk_round_rate(struct clk *c, unsigned long rate)
421 {
422         pr_debug("%s: %s\n", __func__, c->name);
423
424         if (!c->ops || !c->ops->round_rate)
425                 return -ENOSYS;
426
427         if (rate > c->max_rate)
428                 rate = c->max_rate;
429
430         return c->ops->round_rate(c, rate);
431 }
432 EXPORT_SYMBOL(clk_round_rate);
433
434 static int tegra_clk_init_one_from_table(struct tegra_clk_init_table *table)
435 {
436         struct clk *c;
437         struct clk *p;
438
439         int ret = 0;
440
441         c = tegra_get_clock_by_name(table->name);
442
443         if (!c) {
444                 pr_warning("Unable to initialize clock %s\n",
445                         table->name);
446                 return -ENODEV;
447         }
448
449         if (table->parent) {
450                 p = tegra_get_clock_by_name(table->parent);
451                 if (!p) {
452                         pr_warning("Unable to find parent %s of clock %s\n",
453                                 table->parent, table->name);
454                         return -ENODEV;
455                 }
456
457                 if (c->parent != p) {
458                         ret = clk_set_parent(c, p);
459                         if (ret) {
460                                 pr_warning("Unable to set parent %s of clock %s: %d\n",
461                                         table->parent, table->name, ret);
462                                 return -EINVAL;
463                         }
464                 }
465         }
466
467         if (table->rate && table->rate != clk_get_rate(c)) {
468                 ret = clk_set_rate(c, table->rate);
469                 if (ret) {
470                         pr_warning("Unable to set clock %s to rate %lu: %d\n",
471                                 table->name, table->rate, ret);
472                         return -EINVAL;
473                 }
474         }
475
476         if (table->enabled) {
477                 ret = clk_enable(c);
478                 if (ret) {
479                         pr_warning("Unable to enable clock %s: %d\n",
480                                 table->name, ret);
481                         return -EINVAL;
482                 }
483         }
484
485         return 0;
486 }
487
488 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
489 {
490         for (; table->name; table++)
491                 tegra_clk_init_one_from_table(table);
492 }
493 EXPORT_SYMBOL(tegra_clk_init_from_table);
494
495 void tegra_periph_reset_deassert(struct clk *c)
496 {
497         tegra2_periph_reset_deassert(c);
498 }
499 EXPORT_SYMBOL(tegra_periph_reset_deassert);
500
501 void tegra_periph_reset_assert(struct clk *c)
502 {
503         tegra2_periph_reset_assert(c);
504 }
505 EXPORT_SYMBOL(tegra_periph_reset_assert);
506
507 void __init tegra_init_clock(void)
508 {
509         tegra2_init_clocks();
510 }
511
512 int __init tegra_init_dvfs(void)
513 {
514         struct clk *c, *safe;
515
516         mutex_lock(&dvfs_lock);
517
518         list_for_each_entry_safe(c, safe, &clocks, node)
519                 if (c->dvfs)
520                         dvfs_init(c);
521
522         mutex_unlock(&dvfs_lock);
523
524         return 0;
525 }
526
527 late_initcall(tegra_init_dvfs);
528
529 #ifdef CONFIG_DEBUG_FS
530 static struct dentry *clk_debugfs_root;
531
532
533 static void clock_tree_show_one(struct seq_file *s, struct clk *c, int level)
534 {
535         struct clk *child;
536         struct clk *safe;
537         const char *state = "uninit";
538         char div[8] = {0};
539
540         if (c->state == ON)
541                 state = "on";
542         else if (c->state == OFF)
543                 state = "off";
544
545         if (c->mul != 0 && c->div != 0) {
546                 if (c->mul > c->div) {
547                         int mul = c->mul / c->div;
548                         int mul2 = (c->mul * 10 / c->div) % 10;
549                         int mul3 = (c->mul * 10) % c->div;
550                         if (mul2 == 0 && mul3 == 0)
551                                 snprintf(div, sizeof(div), "x%d", mul);
552                         else if (mul3 == 0)
553                                 snprintf(div, sizeof(div), "x%d.%d", mul, mul2);
554                         else
555                                 snprintf(div, sizeof(div), "x%d.%d..", mul, mul2);
556                 } else {
557                         snprintf(div, sizeof(div), "%d%s", c->div / c->mul,
558                                 (c->div % c->mul) ? ".5" : "");
559                 }
560         }
561
562         seq_printf(s, "%*s%c%c%-*s %-6s %-3d %-8s %-10lu\n",
563                 level * 3 + 1, "",
564                 c->rate > c->max_rate ? '!' : ' ',
565                 !c->set ? '*' : ' ',
566                 30 - level * 3, c->name,
567                 state, c->refcnt, div, c->rate);
568         list_for_each_entry_safe(child, safe, &c->children, sibling) {
569                 clock_tree_show_one(s, child, level + 1);
570         }
571 }
572
573 static int clock_tree_show(struct seq_file *s, void *data)
574 {
575         struct clk *c;
576         unsigned long flags;
577         seq_printf(s, "   clock                          state  ref div      rate\n");
578         seq_printf(s, "--------------------------------------------------------------\n");
579         spin_lock_irqsave(&clock_lock, flags);
580         list_for_each_entry(c, &clocks, node)
581                 if (c->parent == NULL)
582                         clock_tree_show_one(s, c, 0);
583         spin_unlock_irqrestore(&clock_lock, flags);
584         return 0;
585 }
586
587 static int clock_tree_open(struct inode *inode, struct file *file)
588 {
589         return single_open(file, clock_tree_show, inode->i_private);
590 }
591
592 static const struct file_operations clock_tree_fops = {
593         .open           = clock_tree_open,
594         .read           = seq_read,
595         .llseek         = seq_lseek,
596         .release        = single_release,
597 };
598
599 static int possible_parents_show(struct seq_file *s, void *data)
600 {
601         struct clk *c = s->private;
602         int i;
603
604         for (i = 0; c->inputs[i].input; i++) {
605                 char *first = (i == 0) ? "" : " ";
606                 seq_printf(s, "%s%s", first, c->inputs[i].input->name);
607         }
608         seq_printf(s, "\n");
609         return 0;
610 }
611
612 static int possible_parents_open(struct inode *inode, struct file *file)
613 {
614         return single_open(file, possible_parents_show, inode->i_private);
615 }
616
617 static const struct file_operations possible_parents_fops = {
618         .open           = possible_parents_open,
619         .read           = seq_read,
620         .llseek         = seq_lseek,
621         .release        = single_release,
622 };
623
624 static int clk_debugfs_register_one(struct clk *c)
625 {
626         struct dentry *d, *child, *child_tmp;
627
628         d = debugfs_create_dir(c->name, clk_debugfs_root);
629         if (!d)
630                 return -ENOMEM;
631         c->dent = d;
632
633         d = debugfs_create_u8("refcnt", S_IRUGO, c->dent, (u8 *)&c->refcnt);
634         if (!d)
635                 goto err_out;
636
637         d = debugfs_create_u32("rate", S_IRUGO, c->dent, (u32 *)&c->rate);
638         if (!d)
639                 goto err_out;
640
641         d = debugfs_create_x32("flags", S_IRUGO, c->dent, (u32 *)&c->flags);
642         if (!d)
643                 goto err_out;
644
645         if (c->inputs) {
646                 d = debugfs_create_file("possible_parents", S_IRUGO, c->dent,
647                         c, &possible_parents_fops);
648                 if (!d)
649                         goto err_out;
650         }
651
652         return 0;
653
654 err_out:
655         d = c->dent;
656         list_for_each_entry_safe(child, child_tmp, &d->d_subdirs, d_u.d_child)
657                 debugfs_remove(child);
658         debugfs_remove(c->dent);
659         return -ENOMEM;
660 }
661
662 static int clk_debugfs_register(struct clk *c)
663 {
664         int err;
665         struct clk *pa = c->parent;
666
667         if (pa && !pa->dent) {
668                 err = clk_debugfs_register(pa);
669                 if (err)
670                         return err;
671         }
672
673         if (!c->dent) {
674                 err = clk_debugfs_register_one(c);
675                 if (err)
676                         return err;
677         }
678         return 0;
679 }
680
681 static int __init clk_debugfs_init(void)
682 {
683         struct clk *c;
684         struct dentry *d;
685         int err = -ENOMEM;
686
687         d = debugfs_create_dir("clock", NULL);
688         if (!d)
689                 return -ENOMEM;
690         clk_debugfs_root = d;
691
692         d = debugfs_create_file("clock_tree", S_IRUGO, clk_debugfs_root, NULL,
693                 &clock_tree_fops);
694         if (!d)
695                 goto err_out;
696
697         list_for_each_entry(c, &clocks, node) {
698                 err = clk_debugfs_register(c);
699                 if (err)
700                         goto err_out;
701         }
702         return 0;
703 err_out:
704         debugfs_remove_recursive(clk_debugfs_root);
705         return err;
706 }
707
708 late_initcall(clk_debugfs_init);
709 #endif