ARM: tegra: power: Set Tegra3 CPU/core rail nominal voltage
[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 /* dvfs initialization may lower default maximum rate */
601 void __init tegra_init_max_rate(struct clk *c, unsigned long max_rate)
602 {
603         struct clk *shared_bus_user;
604
605         if (c->max_rate <= max_rate)
606                 return;
607
608         pr_warning("Lowering %s maximum rate from %lu to %lu\n",
609                 c->name, c->max_rate, max_rate);
610
611         c->max_rate = max_rate;
612         list_for_each_entry(shared_bus_user,
613                             &c->shared_bus_list, u.shared_bus_user.node) {
614                 shared_bus_user->max_rate = max_rate;
615         }
616 }
617
618 static bool tegra_keep_boot_clocks = false;
619 static int __init tegra_keep_boot_clocks_setup(char *__unused)
620 {
621         tegra_keep_boot_clocks = true;
622         return 1;
623 }
624 __setup("tegra_keep_boot_clocks", tegra_keep_boot_clocks_setup);
625
626 /*
627  * Bootloader may not match kernel restrictions on CPU clock sources.
628  * Make sure CPU clock is sourced from either main or backup parent.
629  */
630 static int tegra_sync_cpu_clock(void)
631 {
632         int ret;
633         unsigned long rate;
634         struct clk *c = tegra_get_clock_by_name("cpu");
635
636         BUG_ON(!c);
637         rate = clk_get_rate(c);
638         ret = clk_set_rate(c, rate);
639         if (ret)
640                 pr_err("%s: Failed to sync CPU at rate %lu\n", __func__, rate);
641         else
642                 pr_info("CPU rate: %lu MHz\n", clk_get_rate(c) / 1000000);
643         return ret;
644 }
645 late_initcall(tegra_sync_cpu_clock);
646
647 /*
648  * Iterate through all clocks, disabling any for which the refcount is 0
649  * but the clock init detected the bootloader left the clock on.
650  */
651 static int __init tegra_init_disable_boot_clocks(void)
652 {
653 #if DISABLE_BOOT_CLOCKS
654         unsigned long flags;
655         struct clk *c;
656
657         mutex_lock(&clock_list_lock);
658
659         list_for_each_entry(c, &clocks, node) {
660                 clk_lock_save(c, &flags);
661                 if (c->refcnt == 0 && c->state == ON &&
662                                 c->ops && c->ops->disable) {
663                         pr_warn_once("%s clocks left on by bootloader:\n",
664                                 tegra_keep_boot_clocks ?
665                                         "Prevented disabling" :
666                                         "Disabling");
667
668                         pr_warn("   %s\n", c->name);
669
670                         if (!tegra_keep_boot_clocks) {
671                                 c->ops->disable(c);
672                                 c->state = OFF;
673                         }
674                 }
675                 clk_unlock_restore(c, &flags);
676         }
677
678         mutex_unlock(&clock_list_lock);
679 #endif
680         return 0;
681 }
682 late_initcall(tegra_init_disable_boot_clocks);
683
684 #ifdef CONFIG_DEBUG_FS
685
686 /*
687  * Attempt to lock all the clocks that are marked cansleep
688  * Must be called with irqs enabled
689  */
690 static int __clk_lock_all_mutexes(void)
691 {
692         struct clk *c;
693
694         might_sleep();
695
696         list_for_each_entry(c, &clocks, node)
697                 if (clk_cansleep(c))
698                         if (!mutex_trylock(&c->mutex))
699                                 goto unlock_mutexes;
700
701         return 0;
702
703 unlock_mutexes:
704         list_for_each_entry_continue_reverse(c, &clocks, node)
705                 if (clk_cansleep(c))
706                         mutex_unlock(&c->mutex);
707
708         return -EAGAIN;
709 }
710
711 /*
712  * Attempt to lock all the clocks that are not marked cansleep
713  * Must be called with irqs disabled
714  */
715 static int __clk_lock_all_spinlocks(void)
716 {
717         struct clk *c;
718
719         list_for_each_entry(c, &clocks, node)
720                 if (!clk_cansleep(c))
721                         if (!spin_trylock(&c->spinlock))
722                                 goto unlock_spinlocks;
723
724         return 0;
725
726 unlock_spinlocks:
727         list_for_each_entry_continue_reverse(c, &clocks, node)
728                 if (!clk_cansleep(c))
729                         spin_unlock(&c->spinlock);
730
731         return -EAGAIN;
732 }
733
734 static void __clk_unlock_all_mutexes(void)
735 {
736         struct clk *c;
737
738         list_for_each_entry_reverse(c, &clocks, node)
739                 if (clk_cansleep(c))
740                         mutex_unlock(&c->mutex);
741 }
742
743 static void __clk_unlock_all_spinlocks(void)
744 {
745         struct clk *c;
746
747         list_for_each_entry_reverse(c, &clocks, node)
748                 if (!clk_cansleep(c))
749                         spin_unlock(&c->spinlock);
750 }
751
752 /*
753  * This function retries until it can take all locks, and may take
754  * an arbitrarily long time to complete.
755  * Must be called with irqs enabled, returns with irqs disabled
756  * Must be called with clock_list_lock held
757  */
758 static void clk_lock_all(void)
759 {
760         int ret;
761 retry:
762         ret = __clk_lock_all_mutexes();
763         if (ret)
764                 goto failed_mutexes;
765
766         local_irq_disable();
767
768         ret = __clk_lock_all_spinlocks();
769         if (ret)
770                 goto failed_spinlocks;
771
772         /* All locks taken successfully, return */
773         return;
774
775 failed_spinlocks:
776         local_irq_enable();
777         __clk_unlock_all_mutexes();
778 failed_mutexes:
779         msleep(1);
780         goto retry;
781 }
782
783 /*
784  * Unlocks all clocks after a clk_lock_all
785  * Must be called with irqs disabled, returns with irqs enabled
786  * Must be called with clock_list_lock held
787  */
788 static void clk_unlock_all(void)
789 {
790         __clk_unlock_all_spinlocks();
791
792         local_irq_enable();
793
794         __clk_unlock_all_mutexes();
795 }
796
797 static struct dentry *clk_debugfs_root;
798
799 static void dvfs_show_one(struct seq_file *s, struct dvfs *d, int level)
800 {
801         seq_printf(s, "%*s  %-*s%21s%d mV\n",
802                         level * 3 + 1, "",
803                         30 - level * 3, d->dvfs_rail->reg_id,
804                         "",
805                         d->cur_millivolts);
806 }
807
808 static void clock_tree_show_one(struct seq_file *s, struct clk *c, int level)
809 {
810         struct clk *child;
811         const char *state = "uninit";
812         char div[8] = {0};
813         unsigned long rate = clk_get_rate_all_locked(c);
814         unsigned long max_rate = clk_get_max_rate(c);;
815
816         if (c->state == ON)
817                 state = "on";
818         else if (c->state == OFF)
819                 state = "off";
820
821         if (c->mul != 0 && c->div != 0) {
822                 if (c->mul > c->div) {
823                         int mul = c->mul / c->div;
824                         int mul2 = (c->mul * 10 / c->div) % 10;
825                         int mul3 = (c->mul * 10) % c->div;
826                         if (mul2 == 0 && mul3 == 0)
827                                 snprintf(div, sizeof(div), "x%d", mul);
828                         else if (mul3 == 0)
829                                 snprintf(div, sizeof(div), "x%d.%d", mul, mul2);
830                         else
831                                 snprintf(div, sizeof(div), "x%d.%d..", mul, mul2);
832                 } else {
833                         snprintf(div, sizeof(div), "%d%s", c->div / c->mul,
834                                 (c->div % c->mul) ? ".5" : "");
835                 }
836         }
837
838         seq_printf(s, "%*s%c%c%-*s%c %-6s %-3d %-8s %-10lu\n",
839                 level * 3 + 1, "",
840                 rate > max_rate ? '!' : ' ',
841                 !c->set ? '*' : ' ',
842                 30 - level * 3, c->name,
843                 c->cansleep ? '$' : ' ',
844                 state, c->refcnt, div, rate);
845
846         if (c->dvfs)
847                 dvfs_show_one(s, c->dvfs, level + 1);
848
849         list_for_each_entry(child, &clocks, node) {
850                 if (child->parent != c)
851                         continue;
852
853                 clock_tree_show_one(s, child, level + 1);
854         }
855 }
856
857 static int clock_tree_show(struct seq_file *s, void *data)
858 {
859         struct clk *c;
860         seq_printf(s, "   clock                          state  ref div      rate\n");
861         seq_printf(s, "--------------------------------------------------------------\n");
862
863         mutex_lock(&clock_list_lock);
864
865         clk_lock_all();
866
867         list_for_each_entry(c, &clocks, node)
868                 if (c->parent == NULL)
869                         clock_tree_show_one(s, c, 0);
870
871         clk_unlock_all();
872
873         mutex_unlock(&clock_list_lock);
874         return 0;
875 }
876
877 static int clock_tree_open(struct inode *inode, struct file *file)
878 {
879         return single_open(file, clock_tree_show, inode->i_private);
880 }
881
882 static const struct file_operations clock_tree_fops = {
883         .open           = clock_tree_open,
884         .read           = seq_read,
885         .llseek         = seq_lseek,
886         .release        = single_release,
887 };
888
889 static int possible_parents_show(struct seq_file *s, void *data)
890 {
891         struct clk *c = s->private;
892         int i;
893
894         for (i = 0; c->inputs[i].input; i++) {
895                 char *first = (i == 0) ? "" : " ";
896                 seq_printf(s, "%s%s", first, c->inputs[i].input->name);
897         }
898         seq_printf(s, "\n");
899         return 0;
900 }
901
902 static int possible_parents_open(struct inode *inode, struct file *file)
903 {
904         return single_open(file, possible_parents_show, inode->i_private);
905 }
906
907 static const struct file_operations possible_parents_fops = {
908         .open           = possible_parents_open,
909         .read           = seq_read,
910         .llseek         = seq_lseek,
911         .release        = single_release,
912 };
913
914 static int parent_show(struct seq_file *s, void *data)
915 {
916         struct clk *c = s->private;
917         struct clk *p = clk_get_parent(c);
918
919         seq_printf(s, "%s\n", p ? p->name : "clk_root");
920         return 0;
921 }
922
923 static int parent_open(struct inode *inode, struct file *file)
924 {
925         return single_open(file, parent_show, inode->i_private);
926 }
927
928 static int rate_get(void *data, u64 *val)
929 {
930         struct clk *c = (struct clk *)data;
931         *val = (u64)clk_get_rate(c);
932         return 0;
933 }
934
935 static int state_get(void *data, u64 *val)
936 {
937         struct clk *c = (struct clk *)data;
938         *val = (u64)((c->state == ON) ? 1 : 0);
939         return 0;
940 }
941
942 #ifdef CONFIG_TEGRA_CLOCK_DEBUG_WRITE
943
944 static const mode_t parent_rate_mode =  S_IRUGO | S_IWUGO;
945
946 static ssize_t parent_write(struct file *file,
947         const char __user *userbuf, size_t count, loff_t *ppos)
948 {
949         struct seq_file *s = file->private_data;
950         struct clk *c = s->private;
951         struct clk *p = NULL;
952         char buf[32];
953
954         if (sizeof(buf) <= count)
955                 return -EINVAL;
956
957         if (copy_from_user(buf, userbuf, count))
958                 return -EFAULT;
959
960         /* terminate buffer and trim - white spaces may be appended
961          *  at the end when invoked from shell command line */
962         buf[count]='\0';
963         strim(buf);
964
965         p = tegra_get_clock_by_name(buf);
966         if (!p)
967                 return -EINVAL;
968
969         if (clk_set_parent(c, p))
970                 return -EINVAL;
971
972         return count;
973 }
974
975 static const struct file_operations parent_fops = {
976         .open           = parent_open,
977         .read           = seq_read,
978         .write          = parent_write,
979         .llseek         = seq_lseek,
980         .release        = single_release,
981 };
982
983 static int rate_set(void *data, u64 val)
984 {
985         struct clk *c = (struct clk *)data;
986         return clk_set_rate(c, (unsigned long)val);
987 }
988 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, rate_set, "%llu\n");
989
990 static int state_set(void *data, u64 val)
991 {
992         struct clk *c = (struct clk *)data;
993
994         if (val)
995                 return clk_enable(c);
996         else {
997                 clk_disable(c);
998                 return 0;
999         }
1000 }
1001 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, state_set, "%llu\n");
1002
1003 #else
1004
1005 static const mode_t parent_rate_mode =  S_IRUGO;
1006
1007 static const struct file_operations parent_fops = {
1008         .open           = parent_open,
1009         .read           = seq_read,
1010         .llseek         = seq_lseek,
1011         .release        = single_release,
1012 };
1013
1014 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, NULL, "%llu\n");
1015 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, NULL, "%llu\n");
1016 #endif
1017
1018 static int time_on_get(void *data, u64 *val)
1019 {
1020         unsigned long flags;
1021         struct clk *c = (struct clk *)data;
1022
1023         clk_lock_save(c, &flags);
1024         clk_stats_update(c);
1025         *val = cputime64_to_clock_t(c->stats.time_on);
1026         clk_unlock_restore(c, &flags);
1027
1028         return 0;
1029 }
1030 DEFINE_SIMPLE_ATTRIBUTE(time_on_fops, time_on_get, NULL, "%llu\n");
1031
1032 static int clk_debugfs_register_one(struct clk *c)
1033 {
1034         struct dentry *d;
1035
1036         d = debugfs_create_dir(c->name, clk_debugfs_root);
1037         if (!d)
1038                 return -ENOMEM;
1039         c->dent = d;
1040
1041         d = debugfs_create_u8("refcnt", S_IRUGO, c->dent, (u8 *)&c->refcnt);
1042         if (!d)
1043                 goto err_out;
1044
1045         d = debugfs_create_x32("flags", S_IRUGO, c->dent, (u32 *)&c->flags);
1046         if (!d)
1047                 goto err_out;
1048
1049         d = debugfs_create_u32("max", S_IRUGO, c->dent, (u32 *)&c->max_rate);
1050         if (!d)
1051                 goto err_out;
1052
1053         d = debugfs_create_file(
1054                 "parent", parent_rate_mode, c->dent, c, &parent_fops);
1055         if (!d)
1056                 goto err_out;
1057
1058         d = debugfs_create_file(
1059                 "rate", parent_rate_mode, c->dent, c, &rate_fops);
1060         if (!d)
1061                 goto err_out;
1062
1063         d = debugfs_create_file(
1064                 "state", parent_rate_mode, c->dent, c, &state_fops);
1065         if (!d)
1066                 goto err_out;
1067
1068         d = debugfs_create_file(
1069                 "time_on", S_IRUGO, c->dent, c, &time_on_fops);
1070         if (!d)
1071                 goto err_out;
1072
1073         if (c->inputs) {
1074                 d = debugfs_create_file("possible_parents", S_IRUGO, c->dent,
1075                         c, &possible_parents_fops);
1076                 if (!d)
1077                         goto err_out;
1078         }
1079
1080         return 0;
1081
1082 err_out:
1083         debugfs_remove_recursive(c->dent);
1084         return -ENOMEM;
1085 }
1086
1087 static int clk_debugfs_register(struct clk *c)
1088 {
1089         int err;
1090         struct clk *pa = c->parent;
1091
1092         if (pa && !pa->dent) {
1093                 err = clk_debugfs_register(pa);
1094                 if (err)
1095                         return err;
1096         }
1097
1098         if (!c->dent) {
1099                 err = clk_debugfs_register_one(c);
1100                 if (err)
1101                         return err;
1102         }
1103         return 0;
1104 }
1105
1106 int __init tegra_clk_debugfs_init(void)
1107 {
1108         struct clk *c;
1109         struct dentry *d;
1110         int err = -ENOMEM;
1111
1112         d = debugfs_create_dir("clock", NULL);
1113         if (!d)
1114                 return -ENOMEM;
1115         clk_debugfs_root = d;
1116
1117         d = debugfs_create_file("clock_tree", S_IRUGO, clk_debugfs_root, NULL,
1118                 &clock_tree_fops);
1119         if (!d)
1120                 goto err_out;
1121
1122         if (dvfs_debugfs_init(clk_debugfs_root))
1123                 goto err_out;
1124
1125         list_for_each_entry(c, &clocks, node) {
1126                 err = clk_debugfs_register(c);
1127                 if (err)
1128                         goto err_out;
1129         }
1130         return 0;
1131 err_out:
1132         debugfs_remove_recursive(clk_debugfs_root);
1133         return err;
1134 }
1135 #endif
1136 #else
1137
1138 void tegra_clk_add(struct clk *clk)
1139 {
1140         struct clk_tegra *c = to_clk_tegra(__clk_get_hw(clk));
1141
1142         mutex_lock(&clock_list_lock);
1143         list_add(&c->node, &clocks);
1144         mutex_unlock(&clock_list_lock);
1145 }
1146
1147 struct clk *tegra_get_clock_by_name(const char *name)
1148 {
1149         struct clk_tegra *c;
1150         struct clk *ret = NULL;
1151         mutex_lock(&clock_list_lock);
1152         list_for_each_entry(c, &clocks, node) {
1153                 if (strcmp(__clk_get_name(c->hw.clk), name) == 0) {
1154                         ret = c->hw.clk;
1155                         break;
1156                 }
1157         }
1158         mutex_unlock(&clock_list_lock);
1159         return ret;
1160 }
1161
1162 static int tegra_clk_init_one_from_table(struct tegra_clk_init_table *table)
1163 {
1164         struct clk *c;
1165         struct clk *p;
1166         struct clk *parent;
1167
1168         int ret = 0;
1169
1170         c = tegra_get_clock_by_name(table->name);
1171
1172         if (!c) {
1173                 pr_warn("Unable to initialize clock %s\n",
1174                         table->name);
1175                 return -ENODEV;
1176         }
1177
1178         parent = clk_get_parent(c);
1179
1180         if (table->parent) {
1181                 p = tegra_get_clock_by_name(table->parent);
1182                 if (!p) {
1183                         pr_warn("Unable to find parent %s of clock %s\n",
1184                                 table->parent, table->name);
1185                         return -ENODEV;
1186                 }
1187
1188                 if (parent != p) {
1189                         ret = clk_set_parent(c, p);
1190                         if (ret) {
1191                                 pr_warn("Unable to set parent %s of clock %s: %d\n",
1192                                         table->parent, table->name, ret);
1193                                 return -EINVAL;
1194                         }
1195                 }
1196         }
1197
1198         if (table->rate && table->rate != clk_get_rate(c)) {
1199                 ret = clk_set_rate(c, table->rate);
1200                 if (ret) {
1201                         pr_warn("Unable to set clock %s to rate %lu: %d\n",
1202                                 table->name, table->rate, ret);
1203                         return -EINVAL;
1204                 }
1205         }
1206
1207         if (table->enabled) {
1208                 ret = clk_prepare_enable(c);
1209                 if (ret) {
1210                         pr_warn("Unable to enable clock %s: %d\n",
1211                                 table->name, ret);
1212                         return -EINVAL;
1213                 }
1214         }
1215
1216         return 0;
1217 }
1218
1219 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
1220 {
1221         for (; table->name; table++)
1222                 tegra_clk_init_one_from_table(table);
1223 }
1224
1225 void tegra_periph_reset_deassert(struct clk *c)
1226 {
1227         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1228         BUG_ON(!clk->reset);
1229         clk->reset(__clk_get_hw(c), false);
1230 }
1231 EXPORT_SYMBOL(tegra_periph_reset_deassert);
1232
1233 void tegra_periph_reset_assert(struct clk *c)
1234 {
1235         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1236         BUG_ON(!clk->reset);
1237         clk->reset(__clk_get_hw(c), true);
1238 }
1239 EXPORT_SYMBOL(tegra_periph_reset_assert);
1240
1241 /* Several extended clock configuration bits (e.g., clock routing, clock
1242  * phase control) are included in PLL and peripheral clock source
1243  * registers. */
1244 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
1245 {
1246         int ret = 0;
1247         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1248
1249         if (!clk->clk_cfg_ex) {
1250                 ret = -ENOSYS;
1251                 goto out;
1252         }
1253         ret = clk->clk_cfg_ex(__clk_get_hw(c), p, setting);
1254
1255 out:
1256         return ret;
1257 }
1258 #endif /* !CONFIG_COMMON_CLK */