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