c73546e8cb8e8486f1b5299686f0502c10a579aa
[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_xxx_locked.  Any clock operation can call any other
73  * clock operation on any of it's possible parents.
74  *
75  * clk_set_cansleep is used to mark a clock as sleeping.  It is called during
76  * dvfs (Dynamic Voltage and Frequency Scaling) init on any clock that has a
77  * dvfs requirement, and propagated to all possible children of sleeping clock.
78  *
79  * An additional mutex, clock_list_lock, is used to protect the list of all
80  * clocks.
81  *
82  * The clock operations must lock internally to protect against
83  * read-modify-write on registers that are shared by multiple clocks
84  */
85
86 /* FIXME: remove and never ignore overclock */
87 #define IGNORE_PARENT_OVERCLOCK 0
88
89 static DEFINE_MUTEX(clock_list_lock);
90 static LIST_HEAD(clocks);
91
92 #ifndef CONFIG_COMMON_CLK
93 struct clk *tegra_get_clock_by_name(const char *name)
94 {
95         struct clk *c;
96         struct clk *ret = NULL;
97         mutex_lock(&clock_list_lock);
98         list_for_each_entry(c, &clocks, node) {
99                 if (strcmp(c->name, name) == 0) {
100                         ret = c;
101                         break;
102                 }
103         }
104         mutex_unlock(&clock_list_lock);
105         return ret;
106 }
107 EXPORT_SYMBOL(tegra_get_clock_by_name);
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                                     tegra_clk_is_parent_allowed(child, c)) {
193                                         possible_parent = true;
194                                         break;
195                                 }
196                         }
197                 }
198
199                 if (possible_parent)
200                         __clk_set_cansleep(child);
201         }
202
203         c->cansleep = true;
204 }
205
206 /* Must be called before any clk_get calls */
207 void clk_set_cansleep(struct clk *c)
208 {
209
210         mutex_lock(&clock_list_lock);
211         __clk_set_cansleep(c);
212         mutex_unlock(&clock_list_lock);
213 }
214
215 int clk_reparent(struct clk *c, struct clk *parent)
216 {
217         c->parent = parent;
218         return 0;
219 }
220
221 void clk_init(struct clk *c)
222 {
223         clk_lock_init(c);
224
225         if (c->ops && c->ops->init)
226                 c->ops->init(c);
227
228         if (!c->ops || !c->ops->enable) {
229                 c->refcnt++;
230                 c->set = true;
231                 if (c->parent)
232                         c->state = c->parent->state;
233                 else
234                         c->state = ON;
235         }
236         c->stats.last_update = get_jiffies_64();
237
238         mutex_lock(&clock_list_lock);
239         list_add(&c->node, &clocks);
240         mutex_unlock(&clock_list_lock);
241 }
242
243 static int clk_enable_locked(struct clk *c)
244 {
245         int ret = 0;
246
247         if (clk_is_auto_dvfs(c)) {
248                 ret = tegra_dvfs_set_rate(c, clk_get_rate_locked(c));
249                 if (ret)
250                         return ret;
251         }
252
253         if (c->refcnt == 0) {
254                 if (c->parent) {
255                         ret = clk_enable(c->parent);
256                         if (ret)
257                                 return ret;
258                 }
259
260                 if (c->ops && c->ops->enable) {
261                         ret = c->ops->enable(c);
262                         trace_clock_enable(c->name, 1, 0);
263                         if (ret) {
264                                 if (c->parent)
265                                         clk_disable(c->parent);
266                                 return ret;
267                         }
268                         c->state = ON;
269                         c->set = true;
270                 }
271                 clk_stats_update(c);
272         }
273         c->refcnt++;
274
275         return ret;
276 }
277
278
279 int clk_enable(struct clk *c)
280 {
281         int ret = 0;
282         unsigned long flags;
283
284         clk_lock_save(c, &flags);
285         ret = clk_enable_locked(c);
286         clk_unlock_restore(c, &flags);
287         return ret;
288 }
289 EXPORT_SYMBOL(clk_enable);
290
291 static void clk_disable_locked(struct clk *c)
292 {
293         if (c->refcnt == 0) {
294                 WARN(1, "Attempting to disable clock %s with refcnt 0", c->name);
295                 return;
296         }
297         if (c->refcnt == 1) {
298                 if (c->ops && c->ops->disable) {
299                         trace_clock_disable(c->name, 0, 0);
300                         c->ops->disable(c);
301                 }
302                 if (c->parent)
303                         clk_disable(c->parent);
304
305                 c->state = OFF;
306                 clk_stats_update(c);
307         }
308         c->refcnt--;
309
310         if (clk_is_auto_dvfs(c) && c->refcnt == 0)
311                 tegra_dvfs_set_rate(c, 0);
312 }
313
314 void clk_disable(struct clk *c)
315 {
316         unsigned long flags;
317
318         clk_lock_save(c, &flags);
319         clk_disable_locked(c);
320         clk_unlock_restore(c, &flags);
321 }
322 EXPORT_SYMBOL(clk_disable);
323
324 static int clk_rate_change_notify(struct clk *c, unsigned long rate)
325 {
326         if (!c->rate_change_nh)
327                 return -ENOSYS;
328         return raw_notifier_call_chain(c->rate_change_nh, rate, NULL);
329 }
330
331 int clk_set_parent_locked(struct clk *c, struct clk *parent)
332 {
333         int ret = 0;
334         unsigned long new_rate;
335         unsigned long old_rate;
336         bool disable = false;
337
338         if (!c->ops || !c->ops->set_parent) {
339                 ret = -ENOSYS;
340                 goto out;
341         }
342
343         if (!tegra_clk_is_parent_allowed(c, parent)) {
344                 ret = -EINVAL;
345                 goto out;
346         }
347
348         new_rate = clk_predict_rate_from_parent(c, parent);
349         old_rate = clk_get_rate_locked(c);
350
351         if (new_rate > clk_get_max_rate(c)) {
352
353                 pr_err("Failed to set parent %s for %s (violates clock limit"
354                        " %lu)\n", parent->name, c->name, clk_get_max_rate(c));
355 #if !IGNORE_PARENT_OVERCLOCK
356                 ret = -EINVAL;
357                 goto out;
358 #endif
359         }
360
361         /* The new clock control register setting does not take effect if
362          * clock is disabled. Later, when the clock is enabled it would run
363          * for several cycles on the old parent, which may hang h/w if the
364          * parent is already disabled. To guarantee h/w switch to the new
365          * setting enable clock while setting parent.
366          */
367         if ((c->refcnt == 0) && (c->flags & MUX)) {
368                 pr_debug("Setting parent of clock %s with refcnt 0\n", c->name);
369                 ret = clk_enable_locked(c);
370                 if (ret)
371                         goto out;
372                 disable = true;
373         }
374
375         if (clk_is_auto_dvfs(c) && c->refcnt > 0 &&
376                         (!c->parent || new_rate > old_rate)) {
377                 ret = tegra_dvfs_set_rate(c, new_rate);
378                 if (ret)
379                         goto out;
380         }
381
382         ret = c->ops->set_parent(c, parent);
383         if (ret)
384                 goto out;
385
386         if (clk_is_auto_dvfs(c) && c->refcnt > 0 &&
387                         new_rate < old_rate)
388                 ret = tegra_dvfs_set_rate(c, new_rate);
389
390         if (new_rate != old_rate)
391                 clk_rate_change_notify(c, new_rate);
392
393 out:
394         if (disable)
395                 clk_disable_locked(c);
396         return ret;
397 }
398
399
400 int clk_set_parent(struct clk *c, struct clk *parent)
401 {
402         int ret = 0;
403         unsigned long flags;
404
405         clk_lock_save(c, &flags);
406         ret = clk_set_parent_locked(c, parent);
407         clk_unlock_restore(c, &flags);
408
409         return ret;
410 }
411 EXPORT_SYMBOL(clk_set_parent);
412
413 struct clk *clk_get_parent(struct clk *c)
414 {
415         return c->parent;
416 }
417 EXPORT_SYMBOL(clk_get_parent);
418
419 int clk_set_rate_locked(struct clk *c, unsigned long rate)
420 {
421         int ret = 0;
422         unsigned long old_rate, max_rate;
423         long new_rate;
424         bool disable = false;
425
426         old_rate = clk_get_rate_locked(c);
427
428         max_rate = clk_get_max_rate(c);
429         if (rate > max_rate)
430                 rate = max_rate;
431
432         if (c->ops && c->ops->round_rate) {
433                 new_rate = c->ops->round_rate(c, rate);
434
435                 if (new_rate < 0) {
436                         ret = new_rate;
437                         return ret;
438                 }
439
440                 rate = new_rate;
441         }
442
443         /* The new clock control register setting does not take effect if
444          * clock is disabled. Later, when the clock is enabled it would run
445          * for several cycles on the old rate, which may over-clock module
446          * at given voltage. To guarantee h/w switch to the new setting
447          * enable clock while setting rate.
448          */
449         if ((c->refcnt == 0) && (c->flags & (DIV_U71 | DIV_U16)) &&
450                 clk_is_auto_dvfs(c)) {
451                 pr_debug("Setting rate of clock %s with refcnt 0\n", c->name);
452                 ret = clk_enable_locked(c);
453                 if (ret)
454                         goto out;
455                 disable = true;
456         }
457
458         if (clk_is_auto_dvfs(c) && rate > old_rate && c->refcnt > 0) {
459                 ret = tegra_dvfs_set_rate(c, rate);
460                 if (ret)
461                         goto out;
462         }
463
464         trace_clock_set_rate(c->name, rate, 0);
465         ret = c->ops->set_rate(c, rate);
466         if (ret)
467                 goto out;
468
469         if (clk_is_auto_dvfs(c) && rate < old_rate && c->refcnt > 0)
470                 ret = tegra_dvfs_set_rate(c, rate);
471
472         if (rate != old_rate)
473                 clk_rate_change_notify(c, rate);
474
475 out:
476         if (disable)
477                 clk_disable_locked(c);
478         return ret;
479 }
480
481 int clk_set_rate(struct clk *c, unsigned long rate)
482 {
483         unsigned long flags;
484         int ret;
485
486         if (!c->ops || !c->ops->set_rate)
487                 return -ENOSYS;
488
489         clk_lock_save(c, &flags);
490
491         ret = clk_set_rate_locked(c, rate);
492
493         clk_unlock_restore(c, &flags);
494
495         return ret;
496 }
497 EXPORT_SYMBOL(clk_set_rate);
498
499 /* Must be called with clocks lock and all indvidual clock locks held */
500 unsigned long clk_get_rate_all_locked(struct clk *c)
501 {
502         u64 rate;
503         int mul = 1;
504         int div = 1;
505         struct clk *p = c;
506
507         while (p) {
508                 c = p;
509                 if (c->mul != 0 && c->div != 0) {
510                         mul *= c->mul;
511                         div *= c->div;
512                 }
513                 p = c->parent;
514         }
515
516         rate = c->rate;
517         rate *= mul;
518         do_div(rate, div);
519
520         return rate;
521 }
522
523 long clk_round_rate_locked(struct clk *c, unsigned long rate)
524 {
525         unsigned long max_rate;
526         long ret;
527
528         if (!c->ops || !c->ops->round_rate) {
529                 ret = -ENOSYS;
530                 goto out;
531         }
532
533         max_rate = clk_get_max_rate(c);
534         if (rate > max_rate)
535                 rate = max_rate;
536
537         ret = c->ops->round_rate(c, rate);
538
539 out:
540         return ret;
541 }
542
543 long clk_round_rate(struct clk *c, unsigned long rate)
544 {
545         unsigned long flags;
546         long ret;
547
548         clk_lock_save(c, &flags);
549         ret = clk_round_rate_locked(c, rate);
550         clk_unlock_restore(c, &flags);
551         return ret;
552 }
553 EXPORT_SYMBOL(clk_round_rate);
554
555 static int tegra_clk_clip_rate_for_parent(struct clk *c, struct clk *p)
556 {
557         unsigned long flags, max_rate, old_rate, new_rate;
558
559         clk_lock_save(c, &flags);
560
561         max_rate = clk_get_max_rate(c);
562         new_rate = clk_predict_rate_from_parent(c, p);
563         old_rate = clk_get_rate_locked(c);
564
565         clk_unlock_restore(c, &flags);
566
567         if (new_rate > max_rate) {
568                 u64 rate = max_rate;
569                 rate *= old_rate;
570                 do_div(rate, new_rate);
571
572                 return clk_set_rate(c, (unsigned long)rate);
573         }
574         return 0;
575 }
576
577 static int tegra_clk_init_one_from_table(struct tegra_clk_init_table *table)
578 {
579         struct clk *c;
580         struct clk *p;
581
582         int ret = 0;
583
584         c = tegra_get_clock_by_name(table->name);
585
586         if (!c) {
587                 pr_warning("Unable to initialize clock %s\n",
588                         table->name);
589                 return -ENODEV;
590         }
591
592         if (table->parent) {
593                 p = tegra_get_clock_by_name(table->parent);
594                 if (!p) {
595                         pr_warning("Unable to find parent %s of clock %s\n",
596                                 table->parent, table->name);
597                         return -ENODEV;
598                 }
599
600                 if (c->parent != p) {
601                         ret = tegra_clk_clip_rate_for_parent(c, p);
602                         if (ret) {
603                                 pr_warning("Unable to clip rate for parent %s"
604                                            " of clock %s: %d\n",
605                                            table->parent, table->name, ret);
606                                 return -EINVAL;
607                         }
608
609                         ret = clk_set_parent(c, p);
610                         if (ret) {
611                                 pr_warning("Unable to set parent %s of clock %s: %d\n",
612                                         table->parent, table->name, ret);
613                                 return -EINVAL;
614                         }
615                 }
616         }
617
618         if (table->rate && table->rate != clk_get_rate(c)) {
619                 ret = clk_set_rate(c, table->rate);
620                 if (ret) {
621                         pr_warning("Unable to set clock %s to rate %lu: %d\n",
622                                 table->name, table->rate, ret);
623                         return -EINVAL;
624                 }
625         }
626
627         if (table->enabled) {
628                 ret = clk_enable(c);
629                 if (ret) {
630                         pr_warning("Unable to enable clock %s: %d\n",
631                                 table->name, ret);
632                         return -EINVAL;
633                 }
634         }
635
636         return 0;
637 }
638
639 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
640 {
641         for (; table->name; table++)
642                 tegra_clk_init_one_from_table(table);
643 }
644 EXPORT_SYMBOL(tegra_clk_init_from_table);
645
646 void tegra_periph_reset_deassert(struct clk *c)
647 {
648         BUG_ON(!c->ops->reset);
649         c->ops->reset(c, false);
650 }
651 EXPORT_SYMBOL(tegra_periph_reset_deassert);
652
653 void tegra_periph_reset_assert(struct clk *c)
654 {
655         BUG_ON(!c->ops->reset);
656         c->ops->reset(c, true);
657 }
658 EXPORT_SYMBOL(tegra_periph_reset_assert);
659
660 /* Several extended clock configuration bits (e.g., clock routing, clock
661  * phase control) are included in PLL and peripheral clock source
662  * registers. */
663 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
664 {
665         int ret = 0;
666         unsigned long flags;
667
668         spin_lock_irqsave(&c->spinlock, flags);
669
670         if (!c->ops || !c->ops->clk_cfg_ex) {
671                 ret = -ENOSYS;
672                 goto out;
673         }
674         ret = c->ops->clk_cfg_ex(c, p, setting);
675
676 out:
677         spin_unlock_irqrestore(&c->spinlock, flags);
678
679         return ret;
680 }
681
682 int tegra_is_clk_enabled(struct clk *c)
683 {
684         return c->refcnt;
685 }
686 EXPORT_SYMBOL(tegra_is_clk_enabled);
687
688 int tegra_clk_shared_bus_update(struct clk *c)
689 {
690         int ret = 0;
691         unsigned long flags;
692
693         clk_lock_save(c, &flags);
694
695         if (c->ops && c->ops->shared_bus_update)
696                 ret = c->ops->shared_bus_update(c);
697
698         clk_unlock_restore(c, &flags);
699         return ret;
700 }
701
702 /* dvfs initialization may lower default maximum rate */
703 void __init tegra_init_max_rate(struct clk *c, unsigned long max_rate)
704 {
705         struct clk *shared_bus_user;
706
707         if (c->max_rate <= max_rate)
708                 return;
709
710         pr_warning("Lowering %s maximum rate from %lu to %lu\n",
711                 c->name, c->max_rate, max_rate);
712
713         c->max_rate = max_rate;
714         list_for_each_entry(shared_bus_user,
715                             &c->shared_bus_list, u.shared_bus_user.node) {
716                 shared_bus_user->u.shared_bus_user.rate = max_rate;
717                 shared_bus_user->max_rate = max_rate;
718         }
719 }
720
721 void __init tegra_common_init_clock(void)
722 {
723         int ret;
724         struct clk *cpu;
725         struct clk *twd;
726
727         /* The twd clock is a detached child of the CPU complex clock.
728            Force an update of the twd clock after DVFS as updated the
729            CPU clock rate. */
730         cpu = tegra_get_clock_by_name("cpu");
731         twd = tegra_get_clock_by_name("twd");
732         ret = clk_set_rate(twd, clk_get_rate(cpu));
733         if (ret)
734                 pr_err("Failed to set twd clock rate: %d\n", ret);
735         else
736                 pr_debug("TWD clock rate: %ld\n", clk_get_rate(twd));
737 }
738
739 static bool tegra_keep_boot_clocks = false;
740 static int __init tegra_keep_boot_clocks_setup(char *__unused)
741 {
742         tegra_keep_boot_clocks = true;
743         return 1;
744 }
745 __setup("tegra_keep_boot_clocks", tegra_keep_boot_clocks_setup);
746
747 /*
748  * Bootloader may not match kernel restrictions on CPU clock sources.
749  * Make sure CPU clock is sourced from either main or backup parent.
750  */
751 static int tegra_sync_cpu_clock(void)
752 {
753         int ret;
754         unsigned long rate;
755         struct clk *c = tegra_get_clock_by_name("cpu");
756
757         BUG_ON(!c);
758         rate = clk_get_rate(c);
759         ret = clk_set_rate(c, rate);
760         if (ret)
761                 pr_err("%s: Failed to sync CPU at rate %lu\n", __func__, rate);
762         else
763                 pr_info("CPU rate: %lu MHz\n", clk_get_rate(c) / 1000000);
764         return ret;
765 }
766 late_initcall(tegra_sync_cpu_clock);
767
768 /*
769  * Iterate through all clocks, disabling any for which the refcount is 0
770  * but the clock init detected the bootloader left the clock on.
771  */
772 static int __init tegra_init_disable_boot_clocks(void)
773 {
774 #if DISABLE_BOOT_CLOCKS
775         unsigned long flags;
776         struct clk *c;
777
778         mutex_lock(&clock_list_lock);
779
780         list_for_each_entry(c, &clocks, node) {
781                 clk_lock_save(c, &flags);
782                 if (c->refcnt == 0 && c->state == ON &&
783                                 c->ops && c->ops->disable) {
784                         pr_warn_once("%s clocks left on by bootloader:\n",
785                                 tegra_keep_boot_clocks ?
786                                         "Prevented disabling" :
787                                         "Disabling");
788
789                         pr_warn("   %s\n", c->name);
790
791                         if (!tegra_keep_boot_clocks) {
792                                 c->ops->disable(c);
793                                 c->state = OFF;
794                         }
795                 }
796                 clk_unlock_restore(c, &flags);
797         }
798
799         mutex_unlock(&clock_list_lock);
800 #endif
801         return 0;
802 }
803 late_initcall(tegra_init_disable_boot_clocks);
804
805 int tegra_register_clk_rate_notifier(struct clk *c, struct notifier_block *nb)
806 {
807         int ret;
808         unsigned long flags;
809
810         if (!c->rate_change_nh)
811                 return -ENOSYS;
812
813         clk_lock_save(c, &flags);
814         ret = raw_notifier_chain_register(c->rate_change_nh, nb);
815         clk_unlock_restore(c, &flags);
816         return ret;
817 }
818
819 void tegra_unregister_clk_rate_notifier(
820         struct clk *c, struct notifier_block *nb)
821 {
822         unsigned long flags;
823
824         if (!c->rate_change_nh)
825                 return;
826
827         clk_lock_save(c, &flags);
828         raw_notifier_chain_unregister(c->rate_change_nh, nb);
829         clk_unlock_restore(c, &flags);
830 }
831
832 #ifdef CONFIG_DEBUG_FS
833
834 /*
835  * Attempt to lock all the clocks that are marked cansleep
836  * Must be called with irqs enabled
837  */
838 static int __clk_lock_all_mutexes(void)
839 {
840         struct clk *c;
841
842         might_sleep();
843
844         list_for_each_entry(c, &clocks, node)
845                 if (clk_cansleep(c))
846                         if (!mutex_trylock(&c->mutex))
847                                 goto unlock_mutexes;
848
849         return 0;
850
851 unlock_mutexes:
852         list_for_each_entry_continue_reverse(c, &clocks, node)
853                 if (clk_cansleep(c))
854                         mutex_unlock(&c->mutex);
855
856         return -EAGAIN;
857 }
858
859 /*
860  * Attempt to lock all the clocks that are not marked cansleep
861  * Must be called with irqs disabled
862  */
863 static int __clk_lock_all_spinlocks(void)
864 {
865         struct clk *c;
866
867         list_for_each_entry(c, &clocks, node)
868                 if (!clk_cansleep(c))
869                         if (!spin_trylock(&c->spinlock))
870                                 goto unlock_spinlocks;
871
872         return 0;
873
874 unlock_spinlocks:
875         list_for_each_entry_continue_reverse(c, &clocks, node)
876                 if (!clk_cansleep(c))
877                         spin_unlock(&c->spinlock);
878
879         return -EAGAIN;
880 }
881
882 static void __clk_unlock_all_mutexes(void)
883 {
884         struct clk *c;
885
886         list_for_each_entry_reverse(c, &clocks, node)
887                 if (clk_cansleep(c))
888                         mutex_unlock(&c->mutex);
889 }
890
891 static void __clk_unlock_all_spinlocks(void)
892 {
893         struct clk *c;
894
895         list_for_each_entry_reverse(c, &clocks, node)
896                 if (!clk_cansleep(c))
897                         spin_unlock(&c->spinlock);
898 }
899
900 /*
901  * This function retries until it can take all locks, and may take
902  * an arbitrarily long time to complete.
903  * Must be called with irqs enabled, returns with irqs disabled
904  * Must be called with clock_list_lock held
905  */
906 static void clk_lock_all(void)
907 {
908         int ret;
909 retry:
910         ret = __clk_lock_all_mutexes();
911         if (ret)
912                 goto failed_mutexes;
913
914         local_irq_disable();
915
916         ret = __clk_lock_all_spinlocks();
917         if (ret)
918                 goto failed_spinlocks;
919
920         /* All locks taken successfully, return */
921         return;
922
923 failed_spinlocks:
924         local_irq_enable();
925         __clk_unlock_all_mutexes();
926 failed_mutexes:
927         msleep(1);
928         goto retry;
929 }
930
931 /*
932  * Unlocks all clocks after a clk_lock_all
933  * Must be called with irqs disabled, returns with irqs enabled
934  * Must be called with clock_list_lock held
935  */
936 static void clk_unlock_all(void)
937 {
938         __clk_unlock_all_spinlocks();
939
940         local_irq_enable();
941
942         __clk_unlock_all_mutexes();
943 }
944
945 static struct dentry *clk_debugfs_root;
946
947 static void dvfs_show_one(struct seq_file *s, struct dvfs *d, int level)
948 {
949         seq_printf(s, "%*s  %-*s%21s%d mV\n",
950                         level * 3 + 1, "",
951                         30 - level * 3, d->dvfs_rail->reg_id,
952                         "",
953                         d->cur_millivolts);
954 }
955
956 static void clock_tree_show_one(struct seq_file *s, struct clk *c, int level)
957 {
958         struct clk *child;
959         const char *state = "uninit";
960         char div[8] = {0};
961         unsigned long rate = clk_get_rate_all_locked(c);
962         unsigned long max_rate = clk_get_max_rate(c);;
963
964         if (c->state == ON)
965                 state = "on";
966         else if (c->state == OFF)
967                 state = "off";
968
969         if (c->mul != 0 && c->div != 0) {
970                 if (c->mul > c->div) {
971                         int mul = c->mul / c->div;
972                         int mul2 = (c->mul * 10 / c->div) % 10;
973                         int mul3 = (c->mul * 10) % c->div;
974                         if (mul2 == 0 && mul3 == 0)
975                                 snprintf(div, sizeof(div), "x%d", mul);
976                         else if (mul3 == 0)
977                                 snprintf(div, sizeof(div), "x%d.%d", mul, mul2);
978                         else
979                                 snprintf(div, sizeof(div), "x%d.%d..", mul, mul2);
980                 } else {
981                         snprintf(div, sizeof(div), "%d%s", c->div / c->mul,
982                                 (c->div % c->mul) ? ".5" : "");
983                 }
984         }
985
986         seq_printf(s, "%*s%c%c%-*s%c %-6s %-3d %-8s %-10lu",
987                 level * 3 + 1, "",
988                 rate > max_rate ? '!' : ' ',
989                 !c->set ? '*' : ' ',
990                 30 - level * 3, c->name,
991                 c->cansleep ? '$' : ' ',
992                 state, c->refcnt, div, rate);
993         if (c->parent && !list_empty(&c->parent->shared_bus_list))
994                 seq_printf(s, " (%lu)", c->u.shared_bus_user.rate);
995         seq_printf(s, "\n");
996
997         if (c->dvfs)
998                 dvfs_show_one(s, c->dvfs, level + 1);
999
1000         list_for_each_entry(child, &clocks, node) {
1001                 if (child->parent != c)
1002                         continue;
1003
1004                 clock_tree_show_one(s, child, level + 1);
1005         }
1006 }
1007
1008 static int clock_tree_show(struct seq_file *s, void *data)
1009 {
1010         struct clk *c;
1011         seq_printf(s, "   clock                          state  ref div      rate       (shared rate)\n");
1012         seq_printf(s, "------------------------------------------------------------------------------\n");
1013
1014         mutex_lock(&clock_list_lock);
1015
1016         clk_lock_all();
1017
1018         list_for_each_entry(c, &clocks, node)
1019                 if (c->parent == NULL)
1020                         clock_tree_show_one(s, c, 0);
1021
1022         clk_unlock_all();
1023
1024         mutex_unlock(&clock_list_lock);
1025         return 0;
1026 }
1027
1028 static int clock_tree_open(struct inode *inode, struct file *file)
1029 {
1030         return single_open(file, clock_tree_show, inode->i_private);
1031 }
1032
1033 static const struct file_operations clock_tree_fops = {
1034         .open           = clock_tree_open,
1035         .read           = seq_read,
1036         .llseek         = seq_lseek,
1037         .release        = single_release,
1038 };
1039
1040 static void syncevent_one(struct clk *c)
1041 {
1042         struct clk *child;
1043
1044         if (c->state == ON)
1045                 trace_clock_enable(c->name, 1, smp_processor_id());
1046         else
1047                 trace_clock_disable(c->name, 0, smp_processor_id());
1048
1049         trace_clock_set_rate(c->name, clk_get_rate_all_locked(c),
1050                                 smp_processor_id());
1051
1052         list_for_each_entry(child, &clocks, node) {
1053                 if (child->parent != c)
1054                         continue;
1055
1056                 syncevent_one(child);
1057         }
1058 }
1059
1060 static int syncevent_write(struct file *file, const char __user *user_buf,
1061                                 size_t count, loff_t *ppos)
1062 {
1063         struct clk *c;
1064         char buffer[40];
1065         int buf_size;
1066
1067         memset(buffer, 0, sizeof(buffer));
1068         buf_size = min(count, (sizeof(buffer)-1));
1069
1070         if (copy_from_user(buffer, user_buf, buf_size))
1071                 return -EFAULT;
1072
1073         if (!strnicmp("all", buffer, 3)) {
1074                 mutex_lock(&clock_list_lock);
1075
1076                 clk_lock_all();
1077
1078                 list_for_each_entry(c, &clocks, node) {
1079                         if (c->parent == NULL)
1080                                 syncevent_one(c);
1081                 }
1082
1083                 clk_unlock_all();
1084
1085                 mutex_unlock(&clock_list_lock);
1086         }
1087
1088         return count;
1089 }
1090
1091 static const struct file_operations syncevent_fops = {
1092         .write          = syncevent_write,
1093 };
1094
1095 static int possible_parents_show(struct seq_file *s, void *data)
1096 {
1097         struct clk *c = s->private;
1098         int i;
1099
1100         for (i = 0; c->inputs[i].input; i++) {
1101                 char *first = (i == 0) ? "" : " ";
1102                 seq_printf(s, "%s%s", first, c->inputs[i].input->name);
1103         }
1104         seq_printf(s, "\n");
1105         return 0;
1106 }
1107
1108 static int possible_parents_open(struct inode *inode, struct file *file)
1109 {
1110         return single_open(file, possible_parents_show, inode->i_private);
1111 }
1112
1113 static const struct file_operations possible_parents_fops = {
1114         .open           = possible_parents_open,
1115         .read           = seq_read,
1116         .llseek         = seq_lseek,
1117         .release        = single_release,
1118 };
1119
1120 static int parent_show(struct seq_file *s, void *data)
1121 {
1122         struct clk *c = s->private;
1123         struct clk *p = clk_get_parent(c);
1124
1125         seq_printf(s, "%s\n", p ? p->name : "clk_root");
1126         return 0;
1127 }
1128
1129 static int parent_open(struct inode *inode, struct file *file)
1130 {
1131         return single_open(file, parent_show, inode->i_private);
1132 }
1133
1134 static int rate_get(void *data, u64 *val)
1135 {
1136         struct clk *c = (struct clk *)data;
1137         *val = (u64)clk_get_rate(c);
1138         return 0;
1139 }
1140
1141 static int state_get(void *data, u64 *val)
1142 {
1143         struct clk *c = (struct clk *)data;
1144         *val = (u64)((c->state == ON) ? 1 : 0);
1145         return 0;
1146 }
1147
1148 #ifdef CONFIG_TEGRA_CLOCK_DEBUG_WRITE
1149
1150 static const mode_t parent_rate_mode =  S_IRUGO | S_IWUSR;
1151
1152 static ssize_t parent_write(struct file *file,
1153         const char __user *userbuf, size_t count, loff_t *ppos)
1154 {
1155         struct seq_file *s = file->private_data;
1156         struct clk *c = s->private;
1157         struct clk *p = NULL;
1158         char buf[32];
1159
1160         if (sizeof(buf) <= count)
1161                 return -EINVAL;
1162
1163         if (copy_from_user(buf, userbuf, count))
1164                 return -EFAULT;
1165
1166         /* terminate buffer and trim - white spaces may be appended
1167          *  at the end when invoked from shell command line */
1168         buf[count]='\0';
1169         strim(buf);
1170
1171         p = tegra_get_clock_by_name(buf);
1172         if (!p)
1173                 return -EINVAL;
1174
1175         if (clk_set_parent(c, p))
1176                 return -EINVAL;
1177
1178         return count;
1179 }
1180
1181 static const struct file_operations parent_fops = {
1182         .open           = parent_open,
1183         .read           = seq_read,
1184         .write          = parent_write,
1185         .llseek         = seq_lseek,
1186         .release        = single_release,
1187 };
1188
1189 static int rate_set(void *data, u64 val)
1190 {
1191         struct clk *c = (struct clk *)data;
1192         return clk_set_rate(c, (unsigned long)val);
1193 }
1194 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, rate_set, "%llu\n");
1195
1196 static int state_set(void *data, u64 val)
1197 {
1198         struct clk *c = (struct clk *)data;
1199
1200         if (val)
1201                 return clk_enable(c);
1202         else {
1203                 clk_disable(c);
1204                 return 0;
1205         }
1206 }
1207 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, state_set, "%llu\n");
1208
1209 #else
1210
1211 static const mode_t parent_rate_mode =  S_IRUGO;
1212
1213 static const struct file_operations parent_fops = {
1214         .open           = parent_open,
1215         .read           = seq_read,
1216         .llseek         = seq_lseek,
1217         .release        = single_release,
1218 };
1219
1220 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, NULL, "%llu\n");
1221 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, NULL, "%llu\n");
1222 #endif
1223
1224 static int time_on_get(void *data, u64 *val)
1225 {
1226         unsigned long flags;
1227         struct clk *c = (struct clk *)data;
1228
1229         clk_lock_save(c, &flags);
1230         clk_stats_update(c);
1231         *val = cputime64_to_clock_t(c->stats.time_on);
1232         clk_unlock_restore(c, &flags);
1233
1234         return 0;
1235 }
1236 DEFINE_SIMPLE_ATTRIBUTE(time_on_fops, time_on_get, NULL, "%llu\n");
1237
1238 static int possible_rates_show(struct seq_file *s, void *data)
1239 {
1240         struct clk *c = s->private;
1241         long rate = 0;
1242
1243         /* shared bus clock must round up, unless top of range reached */
1244         while (rate <= c->max_rate) {
1245                 long rounded_rate = c->ops->round_rate(c, rate);
1246                 if (IS_ERR_VALUE(rounded_rate) || (rounded_rate <= rate))
1247                         break;
1248
1249                 rate = rounded_rate + 2000;     /* 2kHz resolution */
1250                 seq_printf(s, "%ld ", rounded_rate / 1000);
1251         }
1252         seq_printf(s, "(kHz)\n");
1253         return 0;
1254 }
1255
1256 static int possible_rates_open(struct inode *inode, struct file *file)
1257 {
1258         return single_open(file, possible_rates_show, inode->i_private);
1259 }
1260
1261 static const struct file_operations possible_rates_fops = {
1262         .open           = possible_rates_open,
1263         .read           = seq_read,
1264         .llseek         = seq_lseek,
1265         .release        = single_release,
1266 };
1267
1268 static int clk_debugfs_register_one(struct clk *c)
1269 {
1270         struct dentry *d;
1271
1272         d = debugfs_create_dir(c->name, clk_debugfs_root);
1273         if (!d)
1274                 return -ENOMEM;
1275         c->dent = d;
1276
1277         d = debugfs_create_u8("refcnt", S_IRUGO, c->dent, (u8 *)&c->refcnt);
1278         if (!d)
1279                 goto err_out;
1280
1281         d = debugfs_create_x32("flags", S_IRUGO, c->dent, (u32 *)&c->flags);
1282         if (!d)
1283                 goto err_out;
1284
1285         d = debugfs_create_u32("max", S_IRUGO, c->dent, (u32 *)&c->max_rate);
1286         if (!d)
1287                 goto err_out;
1288
1289         d = debugfs_create_u32("min", S_IRUGO, c->dent, (u32 *)&c->min_rate);
1290         if (!d)
1291                 goto err_out;
1292
1293         d = debugfs_create_file(
1294                 "parent", parent_rate_mode, c->dent, c, &parent_fops);
1295         if (!d)
1296                 goto err_out;
1297
1298         d = debugfs_create_file(
1299                 "rate", parent_rate_mode, c->dent, c, &rate_fops);
1300         if (!d)
1301                 goto err_out;
1302
1303         d = debugfs_create_file(
1304                 "state", parent_rate_mode, c->dent, c, &state_fops);
1305         if (!d)
1306                 goto err_out;
1307
1308         d = debugfs_create_file(
1309                 "time_on", S_IRUGO, c->dent, c, &time_on_fops);
1310         if (!d)
1311                 goto err_out;
1312
1313         if (c->inputs) {
1314                 d = debugfs_create_file("possible_parents", S_IRUGO, c->dent,
1315                         c, &possible_parents_fops);
1316                 if (!d)
1317                         goto err_out;
1318         }
1319
1320         if (c->ops && c->ops->round_rate && c->ops->shared_bus_update) {
1321                 d = debugfs_create_file("possible_rates", S_IRUGO, c->dent,
1322                         c, &possible_rates_fops);
1323                 if (!d)
1324                         goto err_out;
1325         }
1326
1327         return 0;
1328
1329 err_out:
1330         debugfs_remove_recursive(c->dent);
1331         return -ENOMEM;
1332 }
1333
1334 static int clk_debugfs_register(struct clk *c)
1335 {
1336         int err;
1337         struct clk *pa = c->parent;
1338
1339         if (pa && !pa->dent) {
1340                 err = clk_debugfs_register(pa);
1341                 if (err)
1342                         return err;
1343         }
1344
1345         if (!c->dent) {
1346                 err = clk_debugfs_register_one(c);
1347                 if (err)
1348                         return err;
1349         }
1350         return 0;
1351 }
1352
1353 int __init tegra_clk_debugfs_init(void)
1354 {
1355         struct clk *c;
1356         struct dentry *d;
1357         int err = -ENOMEM;
1358
1359         d = debugfs_create_dir("clock", NULL);
1360         if (!d)
1361                 return -ENOMEM;
1362         clk_debugfs_root = d;
1363
1364         d = debugfs_create_file("clock_tree", S_IRUGO, clk_debugfs_root, NULL,
1365                 &clock_tree_fops);
1366         if (!d)
1367                 goto err_out;
1368
1369         d = debugfs_create_file("syncevents", S_IRUGO|S_IWUSR, clk_debugfs_root, NULL,
1370                 &syncevent_fops);
1371
1372         if (dvfs_debugfs_init(clk_debugfs_root))
1373                 goto err_out;
1374
1375         list_for_each_entry(c, &clocks, node) {
1376                 err = clk_debugfs_register(c);
1377                 if (err)
1378                         goto err_out;
1379         }
1380         return 0;
1381 err_out:
1382         debugfs_remove_recursive(clk_debugfs_root);
1383         return err;
1384 }
1385 #endif
1386 #else
1387
1388 void tegra_clk_add(struct clk *clk)
1389 {
1390         struct clk_tegra *c = to_clk_tegra(__clk_get_hw(clk));
1391
1392         mutex_lock(&clock_list_lock);
1393         list_add(&c->node, &clocks);
1394         mutex_unlock(&clock_list_lock);
1395 }
1396
1397 struct clk *tegra_get_clock_by_name(const char *name)
1398 {
1399         struct clk_tegra *c;
1400         struct clk *ret = NULL;
1401         mutex_lock(&clock_list_lock);
1402         list_for_each_entry(c, &clocks, node) {
1403                 if (strcmp(__clk_get_name(c->hw.clk), name) == 0) {
1404                         ret = c->hw.clk;
1405                         break;
1406                 }
1407         }
1408         mutex_unlock(&clock_list_lock);
1409         return ret;
1410 }
1411
1412 static int tegra_clk_init_one_from_table(struct tegra_clk_init_table *table)
1413 {
1414         struct clk *c;
1415         struct clk *p;
1416         struct clk *parent;
1417
1418         int ret = 0;
1419
1420         c = tegra_get_clock_by_name(table->name);
1421
1422         if (!c) {
1423                 pr_warn("Unable to initialize clock %s\n",
1424                         table->name);
1425                 return -ENODEV;
1426         }
1427
1428         parent = clk_get_parent(c);
1429
1430         if (table->parent) {
1431                 p = tegra_get_clock_by_name(table->parent);
1432                 if (!p) {
1433                         pr_warn("Unable to find parent %s of clock %s\n",
1434                                 table->parent, table->name);
1435                         return -ENODEV;
1436                 }
1437
1438                 if (parent != p) {
1439                         ret = clk_set_parent(c, p);
1440                         if (ret) {
1441                                 pr_warn("Unable to set parent %s of clock %s: %d\n",
1442                                         table->parent, table->name, ret);
1443                                 return -EINVAL;
1444                         }
1445                 }
1446         }
1447
1448         if (table->rate && table->rate != clk_get_rate(c)) {
1449                 ret = clk_set_rate(c, table->rate);
1450                 if (ret) {
1451                         pr_warn("Unable to set clock %s to rate %lu: %d\n",
1452                                 table->name, table->rate, ret);
1453                         return -EINVAL;
1454                 }
1455         }
1456
1457         if (table->enabled) {
1458                 ret = clk_prepare_enable(c);
1459                 if (ret) {
1460                         pr_warn("Unable to enable clock %s: %d\n",
1461                                 table->name, ret);
1462                         return -EINVAL;
1463                 }
1464         }
1465
1466         return 0;
1467 }
1468
1469 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
1470 {
1471         for (; table->name; table++)
1472                 tegra_clk_init_one_from_table(table);
1473 }
1474
1475 void tegra_periph_reset_deassert(struct clk *c)
1476 {
1477         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1478         BUG_ON(!clk->reset);
1479         clk->reset(__clk_get_hw(c), false);
1480 }
1481 EXPORT_SYMBOL(tegra_periph_reset_deassert);
1482
1483 void tegra_periph_reset_assert(struct clk *c)
1484 {
1485         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1486         BUG_ON(!clk->reset);
1487         clk->reset(__clk_get_hw(c), true);
1488 }
1489 EXPORT_SYMBOL(tegra_periph_reset_assert);
1490
1491 /* Several extended clock configuration bits (e.g., clock routing, clock
1492  * phase control) are included in PLL and peripheral clock source
1493  * registers. */
1494 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
1495 {
1496         int ret = 0;
1497         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1498
1499         if (!clk->clk_cfg_ex) {
1500                 ret = -ENOSYS;
1501                 goto out;
1502         }
1503         ret = clk->clk_cfg_ex(__clk_get_hw(c), p, setting);
1504
1505 out:
1506         return ret;
1507 }
1508 #endif /* !CONFIG_COMMON_CLK */