Merge branch 'sh-latest' of git://git.kernel.org/pub/scm/linux/kernel/git/lethal...
[pandora-kernel.git] / drivers / sh / clk / core.c
1 /*
2  * SuperH clock framework
3  *
4  *  Copyright (C) 2005 - 2010  Paul Mundt
5  *
6  * This clock framework is derived from the OMAP version by:
7  *
8  *      Copyright (C) 2004 - 2008 Nokia Corporation
9  *      Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
10  *
11  *  Modified for omap shared clock framework by Tony Lindgren <tony@atomide.com>
12  *
13  * This file is subject to the terms and conditions of the GNU General Public
14  * License.  See the file "COPYING" in the main directory of this archive
15  * for more details.
16  */
17 #define pr_fmt(fmt) "clock: " fmt
18
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/module.h>
22 #include <linux/mutex.h>
23 #include <linux/list.h>
24 #include <linux/syscore_ops.h>
25 #include <linux/seq_file.h>
26 #include <linux/err.h>
27 #include <linux/io.h>
28 #include <linux/debugfs.h>
29 #include <linux/cpufreq.h>
30 #include <linux/clk.h>
31 #include <linux/sh_clk.h>
32
33 static LIST_HEAD(clock_list);
34 static DEFINE_SPINLOCK(clock_lock);
35 static DEFINE_MUTEX(clock_list_sem);
36
37 /* clock disable operations are not passed on to hardware during boot */
38 static int allow_disable;
39
40 void clk_rate_table_build(struct clk *clk,
41                           struct cpufreq_frequency_table *freq_table,
42                           int nr_freqs,
43                           struct clk_div_mult_table *src_table,
44                           unsigned long *bitmap)
45 {
46         unsigned long mult, div;
47         unsigned long freq;
48         int i;
49
50         clk->nr_freqs = nr_freqs;
51
52         for (i = 0; i < nr_freqs; i++) {
53                 div = 1;
54                 mult = 1;
55
56                 if (src_table->divisors && i < src_table->nr_divisors)
57                         div = src_table->divisors[i];
58
59                 if (src_table->multipliers && i < src_table->nr_multipliers)
60                         mult = src_table->multipliers[i];
61
62                 if (!div || !mult || (bitmap && !test_bit(i, bitmap)))
63                         freq = CPUFREQ_ENTRY_INVALID;
64                 else
65                         freq = clk->parent->rate * mult / div;
66
67                 freq_table[i].index = i;
68                 freq_table[i].frequency = freq;
69         }
70
71         /* Termination entry */
72         freq_table[i].index = i;
73         freq_table[i].frequency = CPUFREQ_TABLE_END;
74 }
75
76 struct clk_rate_round_data;
77
78 struct clk_rate_round_data {
79         unsigned long rate;
80         unsigned int min, max;
81         long (*func)(unsigned int, struct clk_rate_round_data *);
82         void *arg;
83 };
84
85 #define for_each_frequency(pos, r, freq)                        \
86         for (pos = r->min, freq = r->func(pos, r);              \
87              pos <= r->max; pos++, freq = r->func(pos, r))      \
88                 if (unlikely(freq == 0))                        \
89                         ;                                       \
90                 else
91
92 static long clk_rate_round_helper(struct clk_rate_round_data *rounder)
93 {
94         unsigned long rate_error, rate_error_prev = ~0UL;
95         unsigned long highest, lowest, freq;
96         long rate_best_fit = -ENOENT;
97         int i;
98
99         highest = 0;
100         lowest = ~0UL;
101
102         for_each_frequency(i, rounder, freq) {
103                 if (freq > highest)
104                         highest = freq;
105                 if (freq < lowest)
106                         lowest = freq;
107
108                 rate_error = abs(freq - rounder->rate);
109                 if (rate_error < rate_error_prev) {
110                         rate_best_fit = freq;
111                         rate_error_prev = rate_error;
112                 }
113
114                 if (rate_error == 0)
115                         break;
116         }
117
118         if (rounder->rate >= highest)
119                 rate_best_fit = highest;
120         if (rounder->rate <= lowest)
121                 rate_best_fit = lowest;
122
123         return rate_best_fit;
124 }
125
126 static long clk_rate_table_iter(unsigned int pos,
127                                 struct clk_rate_round_data *rounder)
128 {
129         struct cpufreq_frequency_table *freq_table = rounder->arg;
130         unsigned long freq = freq_table[pos].frequency;
131
132         if (freq == CPUFREQ_ENTRY_INVALID)
133                 freq = 0;
134
135         return freq;
136 }
137
138 long clk_rate_table_round(struct clk *clk,
139                           struct cpufreq_frequency_table *freq_table,
140                           unsigned long rate)
141 {
142         struct clk_rate_round_data table_round = {
143                 .min    = 0,
144                 .max    = clk->nr_freqs - 1,
145                 .func   = clk_rate_table_iter,
146                 .arg    = freq_table,
147                 .rate   = rate,
148         };
149
150         if (clk->nr_freqs < 1)
151                 return -ENOSYS;
152
153         return clk_rate_round_helper(&table_round);
154 }
155
156 static long clk_rate_div_range_iter(unsigned int pos,
157                                     struct clk_rate_round_data *rounder)
158 {
159         return clk_get_rate(rounder->arg) / pos;
160 }
161
162 long clk_rate_div_range_round(struct clk *clk, unsigned int div_min,
163                               unsigned int div_max, unsigned long rate)
164 {
165         struct clk_rate_round_data div_range_round = {
166                 .min    = div_min,
167                 .max    = div_max,
168                 .func   = clk_rate_div_range_iter,
169                 .arg    = clk_get_parent(clk),
170                 .rate   = rate,
171         };
172
173         return clk_rate_round_helper(&div_range_round);
174 }
175
176 int clk_rate_table_find(struct clk *clk,
177                         struct cpufreq_frequency_table *freq_table,
178                         unsigned long rate)
179 {
180         int i;
181
182         for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
183                 unsigned long freq = freq_table[i].frequency;
184
185                 if (freq == CPUFREQ_ENTRY_INVALID)
186                         continue;
187
188                 if (freq == rate)
189                         return i;
190         }
191
192         return -ENOENT;
193 }
194
195 /* Used for clocks that always have same value as the parent clock */
196 unsigned long followparent_recalc(struct clk *clk)
197 {
198         return clk->parent ? clk->parent->rate : 0;
199 }
200
201 int clk_reparent(struct clk *child, struct clk *parent)
202 {
203         list_del_init(&child->sibling);
204         if (parent)
205                 list_add(&child->sibling, &parent->children);
206         child->parent = parent;
207
208         /* now do the debugfs renaming to reattach the child
209            to the proper parent */
210
211         return 0;
212 }
213
214 /* Propagate rate to children */
215 void propagate_rate(struct clk *tclk)
216 {
217         struct clk *clkp;
218
219         list_for_each_entry(clkp, &tclk->children, sibling) {
220                 if (clkp->ops && clkp->ops->recalc)
221                         clkp->rate = clkp->ops->recalc(clkp);
222
223                 propagate_rate(clkp);
224         }
225 }
226
227 static void __clk_disable(struct clk *clk)
228 {
229         if (WARN(!clk->usecount, "Trying to disable clock %p with 0 usecount\n",
230                  clk))
231                 return;
232
233         if (!(--clk->usecount)) {
234                 if (likely(allow_disable && clk->ops && clk->ops->disable))
235                         clk->ops->disable(clk);
236                 if (likely(clk->parent))
237                         __clk_disable(clk->parent);
238         }
239 }
240
241 void clk_disable(struct clk *clk)
242 {
243         unsigned long flags;
244
245         if (!clk)
246                 return;
247
248         spin_lock_irqsave(&clock_lock, flags);
249         __clk_disable(clk);
250         spin_unlock_irqrestore(&clock_lock, flags);
251 }
252 EXPORT_SYMBOL_GPL(clk_disable);
253
254 static int __clk_enable(struct clk *clk)
255 {
256         int ret = 0;
257
258         if (clk->usecount++ == 0) {
259                 if (clk->parent) {
260                         ret = __clk_enable(clk->parent);
261                         if (unlikely(ret))
262                                 goto err;
263                 }
264
265                 if (clk->ops && clk->ops->enable) {
266                         ret = clk->ops->enable(clk);
267                         if (ret) {
268                                 if (clk->parent)
269                                         __clk_disable(clk->parent);
270                                 goto err;
271                         }
272                 }
273         }
274
275         return ret;
276 err:
277         clk->usecount--;
278         return ret;
279 }
280
281 int clk_enable(struct clk *clk)
282 {
283         unsigned long flags;
284         int ret;
285
286         if (!clk)
287                 return -EINVAL;
288
289         spin_lock_irqsave(&clock_lock, flags);
290         ret = __clk_enable(clk);
291         spin_unlock_irqrestore(&clock_lock, flags);
292
293         return ret;
294 }
295 EXPORT_SYMBOL_GPL(clk_enable);
296
297 static LIST_HEAD(root_clks);
298
299 /**
300  * recalculate_root_clocks - recalculate and propagate all root clocks
301  *
302  * Recalculates all root clocks (clocks with no parent), which if the
303  * clock's .recalc is set correctly, should also propagate their rates.
304  * Called at init.
305  */
306 void recalculate_root_clocks(void)
307 {
308         struct clk *clkp;
309
310         list_for_each_entry(clkp, &root_clks, sibling) {
311                 if (clkp->ops && clkp->ops->recalc)
312                         clkp->rate = clkp->ops->recalc(clkp);
313                 propagate_rate(clkp);
314         }
315 }
316
317 static struct clk_mapping dummy_mapping;
318
319 static struct clk *lookup_root_clock(struct clk *clk)
320 {
321         while (clk->parent)
322                 clk = clk->parent;
323
324         return clk;
325 }
326
327 static int clk_establish_mapping(struct clk *clk)
328 {
329         struct clk_mapping *mapping = clk->mapping;
330
331         /*
332          * Propagate mappings.
333          */
334         if (!mapping) {
335                 struct clk *clkp;
336
337                 /*
338                  * dummy mapping for root clocks with no specified ranges
339                  */
340                 if (!clk->parent) {
341                         clk->mapping = &dummy_mapping;
342                         return 0;
343                 }
344
345                 /*
346                  * If we're on a child clock and it provides no mapping of its
347                  * own, inherit the mapping from its root clock.
348                  */
349                 clkp = lookup_root_clock(clk);
350                 mapping = clkp->mapping;
351                 BUG_ON(!mapping);
352         }
353
354         /*
355          * Establish initial mapping.
356          */
357         if (!mapping->base && mapping->phys) {
358                 kref_init(&mapping->ref);
359
360                 mapping->base = ioremap_nocache(mapping->phys, mapping->len);
361                 if (unlikely(!mapping->base))
362                         return -ENXIO;
363         } else if (mapping->base) {
364                 /*
365                  * Bump the refcount for an existing mapping
366                  */
367                 kref_get(&mapping->ref);
368         }
369
370         clk->mapping = mapping;
371         return 0;
372 }
373
374 static void clk_destroy_mapping(struct kref *kref)
375 {
376         struct clk_mapping *mapping;
377
378         mapping = container_of(kref, struct clk_mapping, ref);
379
380         iounmap(mapping->base);
381 }
382
383 static void clk_teardown_mapping(struct clk *clk)
384 {
385         struct clk_mapping *mapping = clk->mapping;
386
387         /* Nothing to do */
388         if (mapping == &dummy_mapping)
389                 return;
390
391         kref_put(&mapping->ref, clk_destroy_mapping);
392         clk->mapping = NULL;
393 }
394
395 int clk_register(struct clk *clk)
396 {
397         int ret;
398
399         if (IS_ERR_OR_NULL(clk))
400                 return -EINVAL;
401
402         /*
403          * trap out already registered clocks
404          */
405         if (clk->node.next || clk->node.prev)
406                 return 0;
407
408         mutex_lock(&clock_list_sem);
409
410         INIT_LIST_HEAD(&clk->children);
411         clk->usecount = 0;
412
413         ret = clk_establish_mapping(clk);
414         if (unlikely(ret))
415                 goto out_unlock;
416
417         if (clk->parent)
418                 list_add(&clk->sibling, &clk->parent->children);
419         else
420                 list_add(&clk->sibling, &root_clks);
421
422         list_add(&clk->node, &clock_list);
423
424 #ifdef CONFIG_SH_CLK_CPG_LEGACY
425         if (clk->ops && clk->ops->init)
426                 clk->ops->init(clk);
427 #endif
428
429 out_unlock:
430         mutex_unlock(&clock_list_sem);
431
432         return ret;
433 }
434 EXPORT_SYMBOL_GPL(clk_register);
435
436 void clk_unregister(struct clk *clk)
437 {
438         mutex_lock(&clock_list_sem);
439         list_del(&clk->sibling);
440         list_del(&clk->node);
441         clk_teardown_mapping(clk);
442         mutex_unlock(&clock_list_sem);
443 }
444 EXPORT_SYMBOL_GPL(clk_unregister);
445
446 void clk_enable_init_clocks(void)
447 {
448         struct clk *clkp;
449
450         list_for_each_entry(clkp, &clock_list, node)
451                 if (clkp->flags & CLK_ENABLE_ON_INIT)
452                         clk_enable(clkp);
453 }
454
455 unsigned long clk_get_rate(struct clk *clk)
456 {
457         return clk->rate;
458 }
459 EXPORT_SYMBOL_GPL(clk_get_rate);
460
461 int clk_set_rate(struct clk *clk, unsigned long rate)
462 {
463         int ret = -EOPNOTSUPP;
464         unsigned long flags;
465
466         spin_lock_irqsave(&clock_lock, flags);
467
468         if (likely(clk->ops && clk->ops->set_rate)) {
469                 ret = clk->ops->set_rate(clk, rate);
470                 if (ret != 0)
471                         goto out_unlock;
472         } else {
473                 clk->rate = rate;
474                 ret = 0;
475         }
476
477         if (clk->ops && clk->ops->recalc)
478                 clk->rate = clk->ops->recalc(clk);
479
480         propagate_rate(clk);
481
482 out_unlock:
483         spin_unlock_irqrestore(&clock_lock, flags);
484
485         return ret;
486 }
487 EXPORT_SYMBOL_GPL(clk_set_rate);
488
489 int clk_set_parent(struct clk *clk, struct clk *parent)
490 {
491         unsigned long flags;
492         int ret = -EINVAL;
493
494         if (!parent || !clk)
495                 return ret;
496         if (clk->parent == parent)
497                 return 0;
498
499         spin_lock_irqsave(&clock_lock, flags);
500         if (clk->usecount == 0) {
501                 if (clk->ops->set_parent)
502                         ret = clk->ops->set_parent(clk, parent);
503                 else
504                         ret = clk_reparent(clk, parent);
505
506                 if (ret == 0) {
507                         if (clk->ops->recalc)
508                                 clk->rate = clk->ops->recalc(clk);
509                         pr_debug("set parent of %p to %p (new rate %ld)\n",
510                                  clk, clk->parent, clk->rate);
511                         propagate_rate(clk);
512                 }
513         } else
514                 ret = -EBUSY;
515         spin_unlock_irqrestore(&clock_lock, flags);
516
517         return ret;
518 }
519 EXPORT_SYMBOL_GPL(clk_set_parent);
520
521 struct clk *clk_get_parent(struct clk *clk)
522 {
523         return clk->parent;
524 }
525 EXPORT_SYMBOL_GPL(clk_get_parent);
526
527 long clk_round_rate(struct clk *clk, unsigned long rate)
528 {
529         if (likely(clk->ops && clk->ops->round_rate)) {
530                 unsigned long flags, rounded;
531
532                 spin_lock_irqsave(&clock_lock, flags);
533                 rounded = clk->ops->round_rate(clk, rate);
534                 spin_unlock_irqrestore(&clock_lock, flags);
535
536                 return rounded;
537         }
538
539         return clk_get_rate(clk);
540 }
541 EXPORT_SYMBOL_GPL(clk_round_rate);
542
543 long clk_round_parent(struct clk *clk, unsigned long target,
544                       unsigned long *best_freq, unsigned long *parent_freq,
545                       unsigned int div_min, unsigned int div_max)
546 {
547         struct cpufreq_frequency_table *freq, *best = NULL;
548         unsigned long error = ULONG_MAX, freq_high, freq_low, div;
549         struct clk *parent = clk_get_parent(clk);
550
551         if (!parent) {
552                 *parent_freq = 0;
553                 *best_freq = clk_round_rate(clk, target);
554                 return abs(target - *best_freq);
555         }
556
557         for (freq = parent->freq_table; freq->frequency != CPUFREQ_TABLE_END;
558              freq++) {
559                 if (freq->frequency == CPUFREQ_ENTRY_INVALID)
560                         continue;
561
562                 if (unlikely(freq->frequency / target <= div_min - 1)) {
563                         unsigned long freq_max;
564
565                         freq_max = (freq->frequency + div_min / 2) / div_min;
566                         if (error > target - freq_max) {
567                                 error = target - freq_max;
568                                 best = freq;
569                                 if (best_freq)
570                                         *best_freq = freq_max;
571                         }
572
573                         pr_debug("too low freq %u, error %lu\n", freq->frequency,
574                                  target - freq_max);
575
576                         if (!error)
577                                 break;
578
579                         continue;
580                 }
581
582                 if (unlikely(freq->frequency / target >= div_max)) {
583                         unsigned long freq_min;
584
585                         freq_min = (freq->frequency + div_max / 2) / div_max;
586                         if (error > freq_min - target) {
587                                 error = freq_min - target;
588                                 best = freq;
589                                 if (best_freq)
590                                         *best_freq = freq_min;
591                         }
592
593                         pr_debug("too high freq %u, error %lu\n", freq->frequency,
594                                  freq_min - target);
595
596                         if (!error)
597                                 break;
598
599                         continue;
600                 }
601
602                 div = freq->frequency / target;
603                 freq_high = freq->frequency / div;
604                 freq_low = freq->frequency / (div + 1);
605
606                 if (freq_high - target < error) {
607                         error = freq_high - target;
608                         best = freq;
609                         if (best_freq)
610                                 *best_freq = freq_high;
611                 }
612
613                 if (target - freq_low < error) {
614                         error = target - freq_low;
615                         best = freq;
616                         if (best_freq)
617                                 *best_freq = freq_low;
618                 }
619
620                 pr_debug("%u / %lu = %lu, / %lu = %lu, best %lu, parent %u\n",
621                          freq->frequency, div, freq_high, div + 1, freq_low,
622                          *best_freq, best->frequency);
623
624                 if (!error)
625                         break;
626         }
627
628         if (parent_freq)
629                 *parent_freq = best->frequency;
630
631         return error;
632 }
633 EXPORT_SYMBOL_GPL(clk_round_parent);
634
635 #ifdef CONFIG_PM
636 static void clks_core_resume(void)
637 {
638         struct clk *clkp;
639
640         list_for_each_entry(clkp, &clock_list, node) {
641                 if (likely(clkp->usecount && clkp->ops)) {
642                         unsigned long rate = clkp->rate;
643
644                         if (likely(clkp->ops->set_parent))
645                                 clkp->ops->set_parent(clkp,
646                                         clkp->parent);
647                         if (likely(clkp->ops->set_rate))
648                                 clkp->ops->set_rate(clkp, rate);
649                         else if (likely(clkp->ops->recalc))
650                                 clkp->rate = clkp->ops->recalc(clkp);
651                 }
652         }
653 }
654
655 static struct syscore_ops clks_syscore_ops = {
656         .resume = clks_core_resume,
657 };
658
659 static int __init clk_syscore_init(void)
660 {
661         register_syscore_ops(&clks_syscore_ops);
662
663         return 0;
664 }
665 subsys_initcall(clk_syscore_init);
666 #endif
667
668 /*
669  *      debugfs support to trace clock tree hierarchy and attributes
670  */
671 static struct dentry *clk_debugfs_root;
672
673 static int clk_debugfs_register_one(struct clk *c)
674 {
675         int err;
676         struct dentry *d;
677         struct clk *pa = c->parent;
678         char s[255];
679         char *p = s;
680
681         p += sprintf(p, "%p", c);
682         d = debugfs_create_dir(s, pa ? pa->dentry : clk_debugfs_root);
683         if (!d)
684                 return -ENOMEM;
685         c->dentry = d;
686
687         d = debugfs_create_u8("usecount", S_IRUGO, c->dentry, (u8 *)&c->usecount);
688         if (!d) {
689                 err = -ENOMEM;
690                 goto err_out;
691         }
692         d = debugfs_create_u32("rate", S_IRUGO, c->dentry, (u32 *)&c->rate);
693         if (!d) {
694                 err = -ENOMEM;
695                 goto err_out;
696         }
697         d = debugfs_create_x32("flags", S_IRUGO, c->dentry, (u32 *)&c->flags);
698         if (!d) {
699                 err = -ENOMEM;
700                 goto err_out;
701         }
702         return 0;
703
704 err_out:
705         debugfs_remove_recursive(c->dentry);
706         return err;
707 }
708
709 static int clk_debugfs_register(struct clk *c)
710 {
711         int err;
712         struct clk *pa = c->parent;
713
714         if (pa && !pa->dentry) {
715                 err = clk_debugfs_register(pa);
716                 if (err)
717                         return err;
718         }
719
720         if (!c->dentry) {
721                 err = clk_debugfs_register_one(c);
722                 if (err)
723                         return err;
724         }
725         return 0;
726 }
727
728 static int __init clk_debugfs_init(void)
729 {
730         struct clk *c;
731         struct dentry *d;
732         int err;
733
734         d = debugfs_create_dir("clock", NULL);
735         if (!d)
736                 return -ENOMEM;
737         clk_debugfs_root = d;
738
739         list_for_each_entry(c, &clock_list, node) {
740                 err = clk_debugfs_register(c);
741                 if (err)
742                         goto err_out;
743         }
744         return 0;
745 err_out:
746         debugfs_remove_recursive(clk_debugfs_root);
747         return err;
748 }
749 late_initcall(clk_debugfs_init);
750
751 static int __init clk_late_init(void)
752 {
753         unsigned long flags;
754         struct clk *clk;
755
756         /* disable all clocks with zero use count */
757         mutex_lock(&clock_list_sem);
758         spin_lock_irqsave(&clock_lock, flags);
759
760         list_for_each_entry(clk, &clock_list, node)
761                 if (!clk->usecount && clk->ops && clk->ops->disable)
762                         clk->ops->disable(clk);
763
764         /* from now on allow clock disable operations */
765         allow_disable = 1;
766
767         spin_unlock_irqrestore(&clock_lock, flags);
768         mutex_unlock(&clock_list_sem);
769         return 0;
770 }
771 late_initcall(clk_late_init);