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