9be8adf764375df6c51a5749343f15eda6903598
[linux-3.10.git] / arch / arm / mach-tegra / clock.c
1 /*
2  *
3  * Copyright (C) 2010 Google, Inc.
4  * Copyright (c) 2012 NVIDIA CORPORATION.  All rights reserved.
5  *
6  * Author:
7  *      Colin Cross <ccross@google.com>
8  *
9  * Copyright (C) 2010-2011 NVIDIA Corporation
10  *
11  * This software is licensed under the terms of the GNU General Public
12  * License version 2, as published by the Free Software Foundation, and
13  * may be copied, distributed, and modified under those terms.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  */
21
22 #include <linux/kernel.h>
23 #include <linux/clk.h>
24 #include <linux/clkdev.h>
25 #include <linux/debugfs.h>
26 #include <linux/delay.h>
27 #include <linux/init.h>
28 #include <linux/list.h>
29 #include <linux/module.h>
30 #include <linux/seq_file.h>
31 #include <linux/slab.h>
32 #include <linux/clk/tegra.h>
33 #include <linux/uaccess.h>
34 #include <trace/events/power.h>
35
36 #include "board.h"
37 #include "clock.h"
38 #include "dvfs.h"
39
40 /* Global data of Tegra CPU CAR ops */
41 struct tegra_cpu_car_ops *tegra_cpu_car_ops;
42
43 #define DISABLE_BOOT_CLOCKS 1
44
45 /*
46  * Locking:
47  *
48  * Each struct clk has a lock.  Depending on the cansleep flag, that lock
49  * may be a spinlock or a mutex.  For most clocks, the spinlock is sufficient,
50  * and using the spinlock allows the clock to be manipulated from an interrupt
51  * or while holding a spinlock.  Some clocks may need to adjust a regulator
52  * in order to maintain the required voltage for a new frequency.  Those
53  * clocks set the cansleep flag, and take a mutex so that the regulator api
54  * can be used while holding the lock.
55  *
56  * To avoid AB-BA locking problems, locks must always be traversed from child
57  * clock to parent clock.  For example, when enabling a clock, the clock's lock
58  * is taken, and then clk_enable is called on the parent, which take's the
59  * parent clock's lock.  There are two exceptions to this ordering:
60  *  1. When setting a clock as cansleep, in which case the entire list of clocks
61  *     is traversed to set the children as cansleep as well.  This must occur
62  *     during init, before any calls to clk_get, so no other clock locks can
63  *     get taken.
64  *  2. When dumping the clock tree through debugfs.  In this case, clk_lock_all
65  *     is called, which attemps to iterate through the entire list of clocks
66  *     and take every clock lock.  If any call to clk_trylock fails, a locked
67  *     clocks are unlocked, and the process is retried.  When all the locks
68  *     are held, the only clock operation that can be called is
69  *     clk_get_rate_all_locked.
70  *
71  * Within a single clock, no clock operation can call another clock operation
72  * on itself, except for clk_get_rate_locked and clk_set_rate_locked.  Any
73  * clock operation can call any other clock operation on any of it's possible
74  * parents.
75  *
76  * clk_set_cansleep is used to mark a clock as sleeping.  It is called during
77  * dvfs (Dynamic Voltage and Frequency Scaling) init on any clock that has a
78  * dvfs requirement, and propagated to all possible children of sleeping clock.
79  *
80  * An additional mutex, clock_list_lock, is used to protect the list of all
81  * clocks.
82  *
83  * The clock operations must lock internally to protect against
84  * read-modify-write on registers that are shared by multiple clocks
85  */
86
87 /* FIXME: remove and never ignore overclock */
88 #define IGNORE_PARENT_OVERCLOCK 0
89
90 static DEFINE_MUTEX(clock_list_lock);
91 static LIST_HEAD(clocks);
92
93 #ifndef CONFIG_COMMON_CLK
94 struct clk *tegra_get_clock_by_name(const char *name)
95 {
96         struct clk *c;
97         struct clk *ret = NULL;
98         mutex_lock(&clock_list_lock);
99         list_for_each_entry(c, &clocks, node) {
100                 if (strcmp(c->name, name) == 0) {
101                         ret = c;
102                         break;
103                 }
104         }
105         mutex_unlock(&clock_list_lock);
106         return ret;
107 }
108
109 static void clk_stats_update(struct clk *c)
110 {
111         u64 cur_jiffies = get_jiffies_64();
112
113         if (c->refcnt) {
114                 c->stats.time_on = c->stats.time_on +
115                         (jiffies64_to_cputime64(cur_jiffies) -
116                          (c->stats.last_update));
117         }
118
119         c->stats.last_update = cur_jiffies;
120 }
121
122 /* Must be called with clk_lock(c) held */
123 static unsigned long clk_predict_rate_from_parent(struct clk *c, struct clk *p)
124 {
125         u64 rate;
126
127         rate = clk_get_rate(p);
128
129         if (c->mul != 0 && c->div != 0) {
130                 rate *= c->mul;
131                 rate += c->div - 1; /* round up */
132                 do_div(rate, c->div);
133         }
134
135         return rate;
136 }
137
138 unsigned long clk_get_max_rate(struct clk *c)
139 {
140                 return c->max_rate;
141 }
142
143 unsigned long clk_get_min_rate(struct clk *c)
144 {
145                 return c->min_rate;
146 }
147
148 /* Must be called with clk_lock(c) held */
149 unsigned long clk_get_rate_locked(struct clk *c)
150 {
151         unsigned long rate;
152
153         if (c->parent)
154                 rate = clk_predict_rate_from_parent(c, c->parent);
155         else
156                 rate = c->rate;
157
158         return rate;
159 }
160
161 unsigned long clk_get_rate(struct clk *c)
162 {
163         unsigned long flags;
164         unsigned long rate;
165
166         clk_lock_save(c, &flags);
167
168         rate = clk_get_rate_locked(c);
169
170         clk_unlock_restore(c, &flags);
171
172         return rate;
173 }
174 EXPORT_SYMBOL(clk_get_rate);
175
176 static void __clk_set_cansleep(struct clk *c)
177 {
178         struct clk *child;
179         int i;
180         BUG_ON(mutex_is_locked(&c->mutex));
181         BUG_ON(spin_is_locked(&c->spinlock));
182
183         /* Make sure that all possible descendants of sleeping clock are
184            marked as sleeping (to eliminate "sleeping parent - non-sleeping
185            child" relationship */
186         list_for_each_entry(child, &clocks, node) {
187                 bool possible_parent = (child->parent == c);
188
189                 if (!possible_parent && child->inputs) {
190                         for (i = 0; child->inputs[i].input; i++) {
191                                 if (child->inputs[i].input == c) {
192                                         possible_parent = true;
193                                         break;
194                                 }
195                         }
196                 }
197
198                 if (possible_parent)
199                         __clk_set_cansleep(child);
200         }
201
202         c->cansleep = true;
203 }
204
205 /* Must be called before any clk_get calls */
206 void clk_set_cansleep(struct clk *c)
207 {
208
209         mutex_lock(&clock_list_lock);
210         __clk_set_cansleep(c);
211         mutex_unlock(&clock_list_lock);
212 }
213
214 int clk_reparent(struct clk *c, struct clk *parent)
215 {
216         c->parent = parent;
217         return 0;
218 }
219
220 void clk_init(struct clk *c)
221 {
222         clk_lock_init(c);
223
224         if (c->ops && c->ops->init)
225                 c->ops->init(c);
226
227         if (!c->ops || !c->ops->enable) {
228                 c->refcnt++;
229                 c->set = true;
230                 if (c->parent)
231                         c->state = c->parent->state;
232                 else
233                         c->state = ON;
234         }
235         c->stats.last_update = get_jiffies_64();
236
237         mutex_lock(&clock_list_lock);
238         list_add(&c->node, &clocks);
239         mutex_unlock(&clock_list_lock);
240 }
241
242 int clk_enable(struct clk *c)
243 {
244         int ret = 0;
245         unsigned long flags;
246
247         clk_lock_save(c, &flags);
248
249         if (clk_is_auto_dvfs(c)) {
250                 ret = tegra_dvfs_set_rate(c, clk_get_rate_locked(c));
251                 if (ret)
252                         goto out;
253         }
254
255         if (c->refcnt == 0) {
256                 if (c->parent) {
257                         ret = clk_enable(c->parent);
258                         if (ret)
259                                 goto out;
260                 }
261
262                 if (c->ops && c->ops->enable) {
263                         ret = c->ops->enable(c);
264                         trace_clock_enable(c->name, 1, smp_processor_id());
265                         if (ret) {
266                                 if (c->parent)
267                                         clk_disable(c->parent);
268                                 goto out;
269                         }
270                         c->state = ON;
271                         c->set = true;
272                 }
273                 clk_stats_update(c);
274         }
275         c->refcnt++;
276 out:
277         clk_unlock_restore(c, &flags);
278         return ret;
279 }
280 EXPORT_SYMBOL(clk_enable);
281
282 void clk_disable(struct clk *c)
283 {
284         unsigned long flags;
285
286         clk_lock_save(c, &flags);
287
288         if (c->refcnt == 0) {
289                 WARN(1, "Attempting to disable clock %s with refcnt 0", c->name);
290                 clk_unlock_restore(c, &flags);
291                 return;
292         }
293         if (c->refcnt == 1) {
294                 if (c->ops && c->ops->disable) {
295                         trace_clock_disable(c->name, 0, smp_processor_id());
296                         c->ops->disable(c);
297                 }
298                 if (c->parent)
299                         clk_disable(c->parent);
300
301                 c->state = OFF;
302                 clk_stats_update(c);
303         }
304         c->refcnt--;
305
306         if (clk_is_auto_dvfs(c) && c->refcnt == 0)
307                 tegra_dvfs_set_rate(c, 0);
308
309         clk_unlock_restore(c, &flags);
310 }
311 EXPORT_SYMBOL(clk_disable);
312
313 int clk_set_parent(struct clk *c, struct clk *parent)
314 {
315         int ret = 0;
316         unsigned long flags;
317         unsigned long new_rate;
318         unsigned long old_rate;
319
320         clk_lock_save(c, &flags);
321
322         if (!c->ops || !c->ops->set_parent) {
323                 ret = -ENOSYS;
324                 goto out;
325         }
326
327         new_rate = clk_predict_rate_from_parent(c, parent);
328         old_rate = clk_get_rate_locked(c);
329
330         if (new_rate > clk_get_max_rate(c)) {
331
332                 pr_err("Failed to set parent %s for %s (violates clock limit"
333                        " %lu)\n", parent->name, c->name, clk_get_max_rate(c));
334 #if !IGNORE_PARENT_OVERCLOCK
335                 ret = -EINVAL;
336                 goto out;
337 #endif
338         }
339
340         if (clk_is_auto_dvfs(c) && c->refcnt > 0 &&
341                         (!c->parent || new_rate > old_rate)) {
342                 ret = tegra_dvfs_set_rate(c, new_rate);
343                 if (ret)
344                         goto out;
345         }
346
347         ret = c->ops->set_parent(c, parent);
348         if (ret)
349                 goto out;
350
351         if (clk_is_auto_dvfs(c) && c->refcnt > 0 &&
352                         new_rate < old_rate)
353                 ret = tegra_dvfs_set_rate(c, new_rate);
354
355 out:
356         clk_unlock_restore(c, &flags);
357         return ret;
358 }
359 EXPORT_SYMBOL(clk_set_parent);
360
361 struct clk *clk_get_parent(struct clk *c)
362 {
363         return c->parent;
364 }
365 EXPORT_SYMBOL(clk_get_parent);
366
367 int clk_set_rate_locked(struct clk *c, unsigned long rate)
368 {
369         int ret = 0;
370         unsigned long old_rate, max_rate;
371         long new_rate;
372
373         old_rate = clk_get_rate_locked(c);
374
375         max_rate = clk_get_max_rate(c);
376         if (rate > max_rate)
377                 rate = max_rate;
378
379         if (c->ops && c->ops->round_rate) {
380                 new_rate = c->ops->round_rate(c, rate);
381
382                 if (new_rate < 0) {
383                         ret = new_rate;
384                         return ret;
385                 }
386
387                 rate = new_rate;
388         }
389
390         if (clk_is_auto_dvfs(c) && rate > old_rate && c->refcnt > 0) {
391                 ret = tegra_dvfs_set_rate(c, rate);
392                 if (ret)
393                         return ret;
394         }
395
396         trace_clock_set_rate(c->name, rate, smp_processor_id());
397         ret = c->ops->set_rate(c, rate);
398         if (ret)
399                 return ret;
400
401         if (clk_is_auto_dvfs(c) && rate < old_rate && c->refcnt > 0)
402                 ret = tegra_dvfs_set_rate(c, rate);
403
404         return ret;
405 }
406
407 int clk_set_rate(struct clk *c, unsigned long rate)
408 {
409         unsigned long flags;
410         int ret;
411
412         if (!c->ops || !c->ops->set_rate)
413                 return -ENOSYS;
414
415         clk_lock_save(c, &flags);
416
417         ret = clk_set_rate_locked(c, rate);
418
419         clk_unlock_restore(c, &flags);
420
421         return ret;
422 }
423 EXPORT_SYMBOL(clk_set_rate);
424
425 /* Must be called with clocks lock and all indvidual clock locks held */
426 unsigned long clk_get_rate_all_locked(struct clk *c)
427 {
428         u64 rate;
429         int mul = 1;
430         int div = 1;
431         struct clk *p = c;
432
433         while (p) {
434                 c = p;
435                 if (c->mul != 0 && c->div != 0) {
436                         mul *= c->mul;
437                         div *= c->div;
438                 }
439                 p = c->parent;
440         }
441
442         rate = c->rate;
443         rate *= mul;
444         do_div(rate, div);
445
446         return rate;
447 }
448
449 long clk_round_rate(struct clk *c, unsigned long rate)
450 {
451         unsigned long flags, max_rate;
452         long ret;
453
454         clk_lock_save(c, &flags);
455
456         if (!c->ops || !c->ops->round_rate) {
457                 ret = -ENOSYS;
458                 goto out;
459         }
460
461         max_rate = clk_get_max_rate(c);
462         if (rate > max_rate)
463                 rate = max_rate;
464
465         ret = c->ops->round_rate(c, rate);
466
467 out:
468         clk_unlock_restore(c, &flags);
469         return ret;
470 }
471 EXPORT_SYMBOL(clk_round_rate);
472
473 static int tegra_clk_clip_rate_for_parent(struct clk *c, struct clk *p)
474 {
475         unsigned long flags, max_rate, old_rate, new_rate;
476
477         clk_lock_save(c, &flags);
478
479         max_rate = clk_get_max_rate(c);
480         new_rate = clk_predict_rate_from_parent(c, p);
481         old_rate = clk_get_rate_locked(c);
482
483         clk_unlock_restore(c, &flags);
484
485         if (new_rate > max_rate) {
486                 u64 rate = max_rate;
487                 rate *= old_rate;
488                 do_div(rate, new_rate);
489
490                 return clk_set_rate(c, (unsigned long)rate);
491         }
492         return 0;
493 }
494
495 static int tegra_clk_init_one_from_table(struct tegra_clk_init_table *table)
496 {
497         struct clk *c;
498         struct clk *p;
499
500         int ret = 0;
501
502         c = tegra_get_clock_by_name(table->name);
503
504         if (!c) {
505                 pr_warning("Unable to initialize clock %s\n",
506                         table->name);
507                 return -ENODEV;
508         }
509
510         if (table->parent) {
511                 p = tegra_get_clock_by_name(table->parent);
512                 if (!p) {
513                         pr_warning("Unable to find parent %s of clock %s\n",
514                                 table->parent, table->name);
515                         return -ENODEV;
516                 }
517
518                 if (c->parent != p) {
519                         ret = tegra_clk_clip_rate_for_parent(c, p);
520                         if (ret) {
521                                 pr_warning("Unable to clip rate for parent %s"
522                                            " of clock %s: %d\n",
523                                            table->parent, table->name, ret);
524                                 return -EINVAL;
525                         }
526
527                         ret = clk_set_parent(c, p);
528                         if (ret) {
529                                 pr_warning("Unable to set parent %s of clock %s: %d\n",
530                                         table->parent, table->name, ret);
531                                 return -EINVAL;
532                         }
533                 }
534         }
535
536         if (table->rate && table->rate != clk_get_rate(c)) {
537                 ret = clk_set_rate(c, table->rate);
538                 if (ret) {
539                         pr_warning("Unable to set clock %s to rate %lu: %d\n",
540                                 table->name, table->rate, ret);
541                         return -EINVAL;
542                 }
543         }
544
545         if (table->enabled) {
546                 ret = clk_enable(c);
547                 if (ret) {
548                         pr_warning("Unable to enable clock %s: %d\n",
549                                 table->name, ret);
550                         return -EINVAL;
551                 }
552         }
553
554         return 0;
555 }
556
557 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
558 {
559         for (; table->name; table++)
560                 tegra_clk_init_one_from_table(table);
561 }
562 EXPORT_SYMBOL(tegra_clk_init_from_table);
563
564 void tegra_periph_reset_deassert(struct clk *c)
565 {
566         BUG_ON(!c->ops->reset);
567         c->ops->reset(c, false);
568 }
569 EXPORT_SYMBOL(tegra_periph_reset_deassert);
570
571 void tegra_periph_reset_assert(struct clk *c)
572 {
573         BUG_ON(!c->ops->reset);
574         c->ops->reset(c, true);
575 }
576 EXPORT_SYMBOL(tegra_periph_reset_assert);
577
578 /* Several extended clock configuration bits (e.g., clock routing, clock
579  * phase control) are included in PLL and peripheral clock source
580  * registers. */
581 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
582 {
583         int ret = 0;
584         unsigned long flags;
585
586         spin_lock_irqsave(&c->spinlock, flags);
587
588         if (!c->ops || !c->ops->clk_cfg_ex) {
589                 ret = -ENOSYS;
590                 goto out;
591         }
592         ret = c->ops->clk_cfg_ex(c, p, setting);
593
594 out:
595         spin_unlock_irqrestore(&c->spinlock, flags);
596
597         return ret;
598 }
599
600 static bool tegra_keep_boot_clocks = false;
601 static int __init tegra_keep_boot_clocks_setup(char *__unused)
602 {
603         tegra_keep_boot_clocks = true;
604         return 1;
605 }
606 __setup("tegra_keep_boot_clocks", tegra_keep_boot_clocks_setup);
607
608 /*
609  * Bootloader may not match kernel restrictions on CPU clock sources.
610  * Make sure CPU clock is sourced from either main or backup parent.
611  */
612 static int tegra_sync_cpu_clock(void)
613 {
614         int ret;
615         unsigned long rate;
616         struct clk *c = tegra_get_clock_by_name("cpu");
617
618         BUG_ON(!c);
619         rate = clk_get_rate(c);
620         ret = clk_set_rate(c, rate);
621         if (ret)
622                 pr_err("%s: Failed to sync CPU at rate %lu\n", __func__, rate);
623         else
624                 pr_info("CPU rate: %lu MHz\n", clk_get_rate(c) / 1000000);
625         return ret;
626 }
627 late_initcall(tegra_sync_cpu_clock);
628
629 /*
630  * Iterate through all clocks, disabling any for which the refcount is 0
631  * but the clock init detected the bootloader left the clock on.
632  */
633 static int __init tegra_init_disable_boot_clocks(void)
634 {
635 #if DISABLE_BOOT_CLOCKS
636         unsigned long flags;
637         struct clk *c;
638
639         mutex_lock(&clock_list_lock);
640
641         list_for_each_entry(c, &clocks, node) {
642                 clk_lock_save(c, &flags);
643                 if (c->refcnt == 0 && c->state == ON &&
644                                 c->ops && c->ops->disable) {
645                         pr_warn_once("%s clocks left on by bootloader:\n",
646                                 tegra_keep_boot_clocks ?
647                                         "Prevented disabling" :
648                                         "Disabling");
649
650                         pr_warn("   %s\n", c->name);
651
652                         if (!tegra_keep_boot_clocks) {
653                                 c->ops->disable(c);
654                                 c->state = OFF;
655                         }
656                 }
657                 clk_unlock_restore(c, &flags);
658         }
659
660         mutex_unlock(&clock_list_lock);
661 #endif
662         return 0;
663 }
664 late_initcall(tegra_init_disable_boot_clocks);
665
666 #ifdef CONFIG_DEBUG_FS
667
668 /*
669  * Attempt to lock all the clocks that are marked cansleep
670  * Must be called with irqs enabled
671  */
672 static int __clk_lock_all_mutexes(void)
673 {
674         struct clk *c;
675
676         might_sleep();
677
678         list_for_each_entry(c, &clocks, node)
679                 if (clk_cansleep(c))
680                         if (!mutex_trylock(&c->mutex))
681                                 goto unlock_mutexes;
682
683         return 0;
684
685 unlock_mutexes:
686         list_for_each_entry_continue_reverse(c, &clocks, node)
687                 if (clk_cansleep(c))
688                         mutex_unlock(&c->mutex);
689
690         return -EAGAIN;
691 }
692
693 /*
694  * Attempt to lock all the clocks that are not marked cansleep
695  * Must be called with irqs disabled
696  */
697 static int __clk_lock_all_spinlocks(void)
698 {
699         struct clk *c;
700
701         list_for_each_entry(c, &clocks, node)
702                 if (!clk_cansleep(c))
703                         if (!spin_trylock(&c->spinlock))
704                                 goto unlock_spinlocks;
705
706         return 0;
707
708 unlock_spinlocks:
709         list_for_each_entry_continue_reverse(c, &clocks, node)
710                 if (!clk_cansleep(c))
711                         spin_unlock(&c->spinlock);
712
713         return -EAGAIN;
714 }
715
716 static void __clk_unlock_all_mutexes(void)
717 {
718         struct clk *c;
719
720         list_for_each_entry_reverse(c, &clocks, node)
721                 if (clk_cansleep(c))
722                         mutex_unlock(&c->mutex);
723 }
724
725 static void __clk_unlock_all_spinlocks(void)
726 {
727         struct clk *c;
728
729         list_for_each_entry_reverse(c, &clocks, node)
730                 if (!clk_cansleep(c))
731                         spin_unlock(&c->spinlock);
732 }
733
734 /*
735  * This function retries until it can take all locks, and may take
736  * an arbitrarily long time to complete.
737  * Must be called with irqs enabled, returns with irqs disabled
738  * Must be called with clock_list_lock held
739  */
740 static void clk_lock_all(void)
741 {
742         int ret;
743 retry:
744         ret = __clk_lock_all_mutexes();
745         if (ret)
746                 goto failed_mutexes;
747
748         local_irq_disable();
749
750         ret = __clk_lock_all_spinlocks();
751         if (ret)
752                 goto failed_spinlocks;
753
754         /* All locks taken successfully, return */
755         return;
756
757 failed_spinlocks:
758         local_irq_enable();
759         __clk_unlock_all_mutexes();
760 failed_mutexes:
761         msleep(1);
762         goto retry;
763 }
764
765 /*
766  * Unlocks all clocks after a clk_lock_all
767  * Must be called with irqs disabled, returns with irqs enabled
768  * Must be called with clock_list_lock held
769  */
770 static void clk_unlock_all(void)
771 {
772         __clk_unlock_all_spinlocks();
773
774         local_irq_enable();
775
776         __clk_unlock_all_mutexes();
777 }
778
779 static struct dentry *clk_debugfs_root;
780
781 static void dvfs_show_one(struct seq_file *s, struct dvfs *d, int level)
782 {
783         seq_printf(s, "%*s  %-*s%21s%d mV\n",
784                         level * 3 + 1, "",
785                         30 - level * 3, d->dvfs_rail->reg_id,
786                         "",
787                         d->cur_millivolts);
788 }
789
790 static void clock_tree_show_one(struct seq_file *s, struct clk *c, int level)
791 {
792         struct clk *child;
793         const char *state = "uninit";
794         char div[8] = {0};
795         unsigned long rate = clk_get_rate_all_locked(c);
796         unsigned long max_rate = clk_get_max_rate(c);;
797
798         if (c->state == ON)
799                 state = "on";
800         else if (c->state == OFF)
801                 state = "off";
802
803         if (c->mul != 0 && c->div != 0) {
804                 if (c->mul > c->div) {
805                         int mul = c->mul / c->div;
806                         int mul2 = (c->mul * 10 / c->div) % 10;
807                         int mul3 = (c->mul * 10) % c->div;
808                         if (mul2 == 0 && mul3 == 0)
809                                 snprintf(div, sizeof(div), "x%d", mul);
810                         else if (mul3 == 0)
811                                 snprintf(div, sizeof(div), "x%d.%d", mul, mul2);
812                         else
813                                 snprintf(div, sizeof(div), "x%d.%d..", mul, mul2);
814                 } else {
815                         snprintf(div, sizeof(div), "%d%s", c->div / c->mul,
816                                 (c->div % c->mul) ? ".5" : "");
817                 }
818         }
819
820         seq_printf(s, "%*s%c%c%-*s%c %-6s %-3d %-8s %-10lu\n",
821                 level * 3 + 1, "",
822                 rate > max_rate ? '!' : ' ',
823                 !c->set ? '*' : ' ',
824                 30 - level * 3, c->name,
825                 c->cansleep ? '$' : ' ',
826                 state, c->refcnt, div, rate);
827
828         if (c->dvfs)
829                 dvfs_show_one(s, c->dvfs, level + 1);
830
831         list_for_each_entry(child, &clocks, node) {
832                 if (child->parent != c)
833                         continue;
834
835                 clock_tree_show_one(s, child, level + 1);
836         }
837 }
838
839 static int clock_tree_show(struct seq_file *s, void *data)
840 {
841         struct clk *c;
842         seq_printf(s, "   clock                          state  ref div      rate\n");
843         seq_printf(s, "--------------------------------------------------------------\n");
844
845         mutex_lock(&clock_list_lock);
846
847         clk_lock_all();
848
849         list_for_each_entry(c, &clocks, node)
850                 if (c->parent == NULL)
851                         clock_tree_show_one(s, c, 0);
852
853         clk_unlock_all();
854
855         mutex_unlock(&clock_list_lock);
856         return 0;
857 }
858
859 static int clock_tree_open(struct inode *inode, struct file *file)
860 {
861         return single_open(file, clock_tree_show, inode->i_private);
862 }
863
864 static const struct file_operations clock_tree_fops = {
865         .open           = clock_tree_open,
866         .read           = seq_read,
867         .llseek         = seq_lseek,
868         .release        = single_release,
869 };
870
871 static int possible_parents_show(struct seq_file *s, void *data)
872 {
873         struct clk *c = s->private;
874         int i;
875
876         for (i = 0; c->inputs[i].input; i++) {
877                 char *first = (i == 0) ? "" : " ";
878                 seq_printf(s, "%s%s", first, c->inputs[i].input->name);
879         }
880         seq_printf(s, "\n");
881         return 0;
882 }
883
884 static int possible_parents_open(struct inode *inode, struct file *file)
885 {
886         return single_open(file, possible_parents_show, inode->i_private);
887 }
888
889 static const struct file_operations possible_parents_fops = {
890         .open           = possible_parents_open,
891         .read           = seq_read,
892         .llseek         = seq_lseek,
893         .release        = single_release,
894 };
895
896 static int parent_show(struct seq_file *s, void *data)
897 {
898         struct clk *c = s->private;
899         struct clk *p = clk_get_parent(c);
900
901         seq_printf(s, "%s\n", p ? p->name : "clk_root");
902         return 0;
903 }
904
905 static int parent_open(struct inode *inode, struct file *file)
906 {
907         return single_open(file, parent_show, inode->i_private);
908 }
909
910 static int rate_get(void *data, u64 *val)
911 {
912         struct clk *c = (struct clk *)data;
913         *val = (u64)clk_get_rate(c);
914         return 0;
915 }
916
917 static int state_get(void *data, u64 *val)
918 {
919         struct clk *c = (struct clk *)data;
920         *val = (u64)((c->state == ON) ? 1 : 0);
921         return 0;
922 }
923
924 #ifdef CONFIG_TEGRA_CLOCK_DEBUG_WRITE
925
926 static const mode_t parent_rate_mode =  S_IRUGO | S_IWUGO;
927
928 static ssize_t parent_write(struct file *file,
929         const char __user *userbuf, size_t count, loff_t *ppos)
930 {
931         struct seq_file *s = file->private_data;
932         struct clk *c = s->private;
933         struct clk *p = NULL;
934         char buf[32];
935
936         if (sizeof(buf) <= count)
937                 return -EINVAL;
938
939         if (copy_from_user(buf, userbuf, count))
940                 return -EFAULT;
941
942         /* terminate buffer and trim - white spaces may be appended
943          *  at the end when invoked from shell command line */
944         buf[count]='\0';
945         strim(buf);
946
947         p = tegra_get_clock_by_name(buf);
948         if (!p)
949                 return -EINVAL;
950
951         if (clk_set_parent(c, p))
952                 return -EINVAL;
953
954         return count;
955 }
956
957 static const struct file_operations parent_fops = {
958         .open           = parent_open,
959         .read           = seq_read,
960         .write          = parent_write,
961         .llseek         = seq_lseek,
962         .release        = single_release,
963 };
964
965 static int rate_set(void *data, u64 val)
966 {
967         struct clk *c = (struct clk *)data;
968         return clk_set_rate(c, (unsigned long)val);
969 }
970 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, rate_set, "%llu\n");
971
972 static int state_set(void *data, u64 val)
973 {
974         struct clk *c = (struct clk *)data;
975
976         if (val)
977                 return clk_enable(c);
978         else {
979                 clk_disable(c);
980                 return 0;
981         }
982 }
983 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, state_set, "%llu\n");
984
985 #else
986
987 static const mode_t parent_rate_mode =  S_IRUGO;
988
989 static const struct file_operations parent_fops = {
990         .open           = parent_open,
991         .read           = seq_read,
992         .llseek         = seq_lseek,
993         .release        = single_release,
994 };
995
996 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, NULL, "%llu\n");
997 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, NULL, "%llu\n");
998 #endif
999
1000 static int time_on_get(void *data, u64 *val)
1001 {
1002         unsigned long flags;
1003         struct clk *c = (struct clk *)data;
1004
1005         clk_lock_save(c, &flags);
1006         clk_stats_update(c);
1007         *val = cputime64_to_clock_t(c->stats.time_on);
1008         clk_unlock_restore(c, &flags);
1009
1010         return 0;
1011 }
1012 DEFINE_SIMPLE_ATTRIBUTE(time_on_fops, time_on_get, NULL, "%llu\n");
1013
1014 static int clk_debugfs_register_one(struct clk *c)
1015 {
1016         struct dentry *d;
1017
1018         d = debugfs_create_dir(c->name, clk_debugfs_root);
1019         if (!d)
1020                 return -ENOMEM;
1021         c->dent = d;
1022
1023         d = debugfs_create_u8("refcnt", S_IRUGO, c->dent, (u8 *)&c->refcnt);
1024         if (!d)
1025                 goto err_out;
1026
1027         d = debugfs_create_x32("flags", S_IRUGO, c->dent, (u32 *)&c->flags);
1028         if (!d)
1029                 goto err_out;
1030
1031         d = debugfs_create_u32("max", S_IRUGO, c->dent, (u32 *)&c->max_rate);
1032         if (!d)
1033                 goto err_out;
1034
1035         d = debugfs_create_file(
1036                 "parent", parent_rate_mode, c->dent, c, &parent_fops);
1037         if (!d)
1038                 goto err_out;
1039
1040         d = debugfs_create_file(
1041                 "rate", parent_rate_mode, c->dent, c, &rate_fops);
1042         if (!d)
1043                 goto err_out;
1044
1045         d = debugfs_create_file(
1046                 "state", parent_rate_mode, c->dent, c, &state_fops);
1047         if (!d)
1048                 goto err_out;
1049
1050         d = debugfs_create_file(
1051                 "time_on", S_IRUGO, c->dent, c, &time_on_fops);
1052         if (!d)
1053                 goto err_out;
1054
1055         if (c->inputs) {
1056                 d = debugfs_create_file("possible_parents", S_IRUGO, c->dent,
1057                         c, &possible_parents_fops);
1058                 if (!d)
1059                         goto err_out;
1060         }
1061
1062         return 0;
1063
1064 err_out:
1065         debugfs_remove_recursive(c->dent);
1066         return -ENOMEM;
1067 }
1068
1069 static int clk_debugfs_register(struct clk *c)
1070 {
1071         int err;
1072         struct clk *pa = c->parent;
1073
1074         if (pa && !pa->dent) {
1075                 err = clk_debugfs_register(pa);
1076                 if (err)
1077                         return err;
1078         }
1079
1080         if (!c->dent) {
1081                 err = clk_debugfs_register_one(c);
1082                 if (err)
1083                         return err;
1084         }
1085         return 0;
1086 }
1087
1088 int __init tegra_clk_debugfs_init(void)
1089 {
1090         struct clk *c;
1091         struct dentry *d;
1092         int err = -ENOMEM;
1093
1094         d = debugfs_create_dir("clock", NULL);
1095         if (!d)
1096                 return -ENOMEM;
1097         clk_debugfs_root = d;
1098
1099         d = debugfs_create_file("clock_tree", S_IRUGO, clk_debugfs_root, NULL,
1100                 &clock_tree_fops);
1101         if (!d)
1102                 goto err_out;
1103
1104         if (dvfs_debugfs_init(clk_debugfs_root))
1105                 goto err_out;
1106
1107         list_for_each_entry(c, &clocks, node) {
1108                 err = clk_debugfs_register(c);
1109                 if (err)
1110                         goto err_out;
1111         }
1112         return 0;
1113 err_out:
1114         debugfs_remove_recursive(clk_debugfs_root);
1115         return err;
1116 }
1117 #endif
1118 #else
1119
1120 void tegra_clk_add(struct clk *clk)
1121 {
1122         struct clk_tegra *c = to_clk_tegra(__clk_get_hw(clk));
1123
1124         mutex_lock(&clock_list_lock);
1125         list_add(&c->node, &clocks);
1126         mutex_unlock(&clock_list_lock);
1127 }
1128
1129 struct clk *tegra_get_clock_by_name(const char *name)
1130 {
1131         struct clk_tegra *c;
1132         struct clk *ret = NULL;
1133         mutex_lock(&clock_list_lock);
1134         list_for_each_entry(c, &clocks, node) {
1135                 if (strcmp(__clk_get_name(c->hw.clk), name) == 0) {
1136                         ret = c->hw.clk;
1137                         break;
1138                 }
1139         }
1140         mutex_unlock(&clock_list_lock);
1141         return ret;
1142 }
1143
1144 static int tegra_clk_init_one_from_table(struct tegra_clk_init_table *table)
1145 {
1146         struct clk *c;
1147         struct clk *p;
1148         struct clk *parent;
1149
1150         int ret = 0;
1151
1152         c = tegra_get_clock_by_name(table->name);
1153
1154         if (!c) {
1155                 pr_warn("Unable to initialize clock %s\n",
1156                         table->name);
1157                 return -ENODEV;
1158         }
1159
1160         parent = clk_get_parent(c);
1161
1162         if (table->parent) {
1163                 p = tegra_get_clock_by_name(table->parent);
1164                 if (!p) {
1165                         pr_warn("Unable to find parent %s of clock %s\n",
1166                                 table->parent, table->name);
1167                         return -ENODEV;
1168                 }
1169
1170                 if (parent != p) {
1171                         ret = clk_set_parent(c, p);
1172                         if (ret) {
1173                                 pr_warn("Unable to set parent %s of clock %s: %d\n",
1174                                         table->parent, table->name, ret);
1175                                 return -EINVAL;
1176                         }
1177                 }
1178         }
1179
1180         if (table->rate && table->rate != clk_get_rate(c)) {
1181                 ret = clk_set_rate(c, table->rate);
1182                 if (ret) {
1183                         pr_warn("Unable to set clock %s to rate %lu: %d\n",
1184                                 table->name, table->rate, ret);
1185                         return -EINVAL;
1186                 }
1187         }
1188
1189         if (table->enabled) {
1190                 ret = clk_prepare_enable(c);
1191                 if (ret) {
1192                         pr_warn("Unable to enable clock %s: %d\n",
1193                                 table->name, ret);
1194                         return -EINVAL;
1195                 }
1196         }
1197
1198         return 0;
1199 }
1200
1201 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
1202 {
1203         for (; table->name; table++)
1204                 tegra_clk_init_one_from_table(table);
1205 }
1206
1207 void tegra_periph_reset_deassert(struct clk *c)
1208 {
1209         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1210         BUG_ON(!clk->reset);
1211         clk->reset(__clk_get_hw(c), false);
1212 }
1213 EXPORT_SYMBOL(tegra_periph_reset_deassert);
1214
1215 void tegra_periph_reset_assert(struct clk *c)
1216 {
1217         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1218         BUG_ON(!clk->reset);
1219         clk->reset(__clk_get_hw(c), true);
1220 }
1221 EXPORT_SYMBOL(tegra_periph_reset_assert);
1222
1223 /* Several extended clock configuration bits (e.g., clock routing, clock
1224  * phase control) are included in PLL and peripheral clock source
1225  * registers. */
1226 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
1227 {
1228         int ret = 0;
1229         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1230
1231         if (!clk->clk_cfg_ex) {
1232                 ret = -ENOSYS;
1233                 goto out;
1234         }
1235         ret = clk->clk_cfg_ex(__clk_get_hw(c), p, setting);
1236
1237 out:
1238         return ret;
1239 }
1240 #endif /* !CONFIG_COMMON_CLK */