Update copyrights
[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
33 #include <mach/clk.h>
34
35 #include "board.h"
36 #include "clock.h"
37 #include "dvfs.h"
38
39 #define DISABLE_BOOT_CLOCKS 1
40
41 /*
42  * Locking:
43  *
44  * Each struct clk has a lock.  Depending on the cansleep flag, that lock
45  * may be a spinlock or a mutex.  For most clocks, the spinlock is sufficient,
46  * and using the spinlock allows the clock to be manipulated from an interrupt
47  * or while holding a spinlock.  Some clocks may need to adjust a regulator
48  * in order to maintain the required voltage for a new frequency.  Those
49  * clocks set the cansleep flag, and take a mutex so that the regulator api
50  * can be used while holding the lock.
51  *
52  * To avoid AB-BA locking problems, locks must always be traversed from child
53  * clock to parent clock.  For example, when enabling a clock, the clock's lock
54  * is taken, and then clk_enable is called on the parent, which take's the
55  * parent clock's lock.  There are two exceptions to this ordering:
56  *  1. When setting a clock as cansleep, in which case the entire list of clocks
57  *     is traversed to set the children as cansleep as well.  This must occur
58  *     during init, before any calls to clk_get, so no other clock locks can
59  *     get taken.
60  *  2. When dumping the clock tree through debugfs.  In this case, clk_lock_all
61  *     is called, which attemps to iterate through the entire list of clocks
62  *     and take every clock lock.  If any call to clk_trylock fails, a locked
63  *     clocks are unlocked, and the process is retried.  When all the locks
64  *     are held, the only clock operation that can be called is
65  *     clk_get_rate_all_locked.
66  *
67  * Within a single clock, no clock operation can call another clock operation
68  * on itself, except for clk_get_rate_locked and clk_set_rate_locked.  Any
69  * clock operation can call any other clock operation on any of it's possible
70  * 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.  It can only be called on clocks that are the sole parent
75  * of all of their child clocks, meaning the child clock can not be reparented
76  * onto a different, possibly non-sleeping, clock.  This is inherently true
77  * of all leaf clocks in the clock tree
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 struct clk *tegra_get_clock_by_name(const char *name)
93 {
94         struct clk *c;
95         struct clk *ret = NULL;
96         mutex_lock(&clock_list_lock);
97         list_for_each_entry(c, &clocks, node) {
98                 if (strcmp(c->name, name) == 0) {
99                         ret = c;
100                         break;
101                 }
102         }
103         mutex_unlock(&clock_list_lock);
104         return ret;
105 }
106
107 /* Must be called with clk_lock(c) held */
108 static unsigned long clk_predict_rate_from_parent(struct clk *c, struct clk *p)
109 {
110         u64 rate;
111
112         rate = clk_get_rate(p);
113
114         if (c->ops && c->ops->recalculate_rate)
115                 c->ops->recalculate_rate(c);
116
117         if (c->mul != 0 && c->div != 0) {
118                 rate *= c->mul;
119                 rate += c->div - 1; /* round up */
120                 do_div(rate, c->div);
121         }
122
123         return rate;
124 }
125
126 static unsigned long clk_get_max_rate(struct clk *c)
127 {
128         if (c->ops && c->ops->get_max_rate)
129                 return c->ops->get_max_rate(c);
130         else
131                 return c->max_rate;
132 }
133
134 /* Must be called with clk_lock(c) held */
135 unsigned long clk_get_rate_locked(struct clk *c)
136 {
137         unsigned long rate;
138
139         if (c->parent)
140                 rate = clk_predict_rate_from_parent(c, c->parent);
141         else
142                 rate = c->rate;
143
144         return rate;
145 }
146
147 unsigned long clk_get_rate(struct clk *c)
148 {
149         unsigned long flags;
150         unsigned long rate;
151
152         clk_lock_save(c, &flags);
153
154         rate = clk_get_rate_locked(c);
155
156         clk_unlock_restore(c, &flags);
157
158         return rate;
159 }
160 EXPORT_SYMBOL(clk_get_rate);
161
162 static void __clk_set_cansleep(struct clk *c)
163 {
164         struct clk *child;
165         BUG_ON(mutex_is_locked(&c->mutex));
166         BUG_ON(spin_is_locked(&c->spinlock));
167
168         list_for_each_entry(child, &clocks, node) {
169                 if (child->parent != c)
170                         continue;
171
172                 WARN(child->ops && child->ops->set_parent,
173                         "can't make child clock %s of %s "
174                         "sleepable if it's parent could change",
175                         child->name, c->name);
176
177                 __clk_set_cansleep(child);
178         }
179
180         c->cansleep = true;
181 }
182
183 /* Must be called before any clk_get calls */
184 void clk_set_cansleep(struct clk *c)
185 {
186
187         mutex_lock(&clock_list_lock);
188         __clk_set_cansleep(c);
189         mutex_unlock(&clock_list_lock);
190 }
191
192 int clk_reparent(struct clk *c, struct clk *parent)
193 {
194         c->parent = parent;
195         return 0;
196 }
197
198 void clk_init(struct clk *c)
199 {
200         clk_lock_init(c);
201
202         if (c->ops && c->ops->init)
203                 c->ops->init(c);
204
205         if (!c->ops || !c->ops->enable) {
206                 c->refcnt++;
207                 c->set = true;
208                 if (c->parent)
209                         c->state = c->parent->state;
210                 else
211                         c->state = ON;
212         }
213
214         mutex_lock(&clock_list_lock);
215         list_add(&c->node, &clocks);
216         mutex_unlock(&clock_list_lock);
217 }
218
219 int clk_enable(struct clk *c)
220 {
221         int ret = 0;
222         unsigned long flags;
223
224         clk_lock_save(c, &flags);
225
226         if (clk_is_auto_dvfs(c)) {
227                 ret = tegra_dvfs_set_rate(c, clk_get_rate_locked(c));
228                 if (ret)
229                         goto out;
230         }
231
232         if (c->refcnt == 0) {
233                 if (c->parent) {
234                         ret = clk_enable(c->parent);
235                         if (ret)
236                                 goto out;
237                 }
238
239                 if (c->ops && c->ops->enable) {
240                         ret = c->ops->enable(c);
241                         if (ret) {
242                                 if (c->parent)
243                                         clk_disable(c->parent);
244                                 goto out;
245                         }
246                         c->state = ON;
247                         c->set = true;
248                 }
249         }
250         c->refcnt++;
251 out:
252         clk_unlock_restore(c, &flags);
253         return ret;
254 }
255 EXPORT_SYMBOL(clk_enable);
256
257 void clk_disable(struct clk *c)
258 {
259         unsigned long flags;
260
261         clk_lock_save(c, &flags);
262
263         if (c->refcnt == 0) {
264                 WARN(1, "Attempting to disable clock %s with refcnt 0", c->name);
265                 clk_unlock_restore(c, &flags);
266                 return;
267         }
268         if (c->refcnt == 1) {
269                 if (c->ops && c->ops->disable)
270                         c->ops->disable(c);
271
272                 if (c->parent)
273                         clk_disable(c->parent);
274
275                 c->state = OFF;
276         }
277         c->refcnt--;
278
279         if (clk_is_auto_dvfs(c) && c->refcnt == 0)
280                 tegra_dvfs_set_rate(c, 0);
281
282         clk_unlock_restore(c, &flags);
283 }
284 EXPORT_SYMBOL(clk_disable);
285
286 int clk_set_parent(struct clk *c, struct clk *parent)
287 {
288         int ret = 0;
289         unsigned long flags;
290         unsigned long new_rate;
291         unsigned long old_rate;
292
293         clk_lock_save(c, &flags);
294
295         if (!c->ops || !c->ops->set_parent) {
296                 ret = -ENOSYS;
297                 goto out;
298         }
299
300         new_rate = clk_predict_rate_from_parent(c, parent);
301         old_rate = clk_get_rate_locked(c);
302
303         if (new_rate > clk_get_max_rate(c)) {
304
305                 pr_err("Failed to set parent %s for %s (violates clock limit"
306                        " %lu)\n", parent->name, c->name, clk_get_max_rate(c));
307 #if !IGNORE_PARENT_OVERCLOCK
308                 ret = -EINVAL;
309                 goto out;
310 #endif
311         }
312
313         if (clk_is_auto_dvfs(c) && c->refcnt > 0 &&
314                         (!c->parent || new_rate > old_rate)) {
315                 ret = tegra_dvfs_set_rate(c, new_rate);
316                 if (ret)
317                         goto out;
318         }
319
320         ret = c->ops->set_parent(c, parent);
321         if (ret)
322                 goto out;
323
324         if (clk_is_auto_dvfs(c) && c->refcnt > 0 &&
325                         new_rate < old_rate)
326                 ret = tegra_dvfs_set_rate(c, new_rate);
327
328 out:
329         clk_unlock_restore(c, &flags);
330         return ret;
331 }
332 EXPORT_SYMBOL(clk_set_parent);
333
334 struct clk *clk_get_parent(struct clk *c)
335 {
336         return c->parent;
337 }
338 EXPORT_SYMBOL(clk_get_parent);
339
340 int clk_set_rate_locked(struct clk *c, unsigned long rate)
341 {
342         int ret = 0;
343         unsigned long old_rate, max_rate;
344         long new_rate;
345
346         old_rate = clk_get_rate_locked(c);
347
348         max_rate = clk_get_max_rate(c);
349         if (rate > max_rate)
350                 rate = max_rate;
351
352         if (c->ops && c->ops->round_rate) {
353                 new_rate = c->ops->round_rate(c, rate);
354
355                 if (new_rate < 0) {
356                         ret = new_rate;
357                         return ret;
358                 }
359
360                 rate = new_rate;
361         }
362
363         if (clk_is_auto_dvfs(c) && rate > old_rate && c->refcnt > 0) {
364                 ret = tegra_dvfs_set_rate(c, rate);
365                 if (ret)
366                         return ret;
367         }
368
369         ret = c->ops->set_rate(c, rate);
370         if (ret)
371                 return ret;
372
373         if (clk_is_auto_dvfs(c) && rate < old_rate && c->refcnt > 0)
374                 ret = tegra_dvfs_set_rate(c, rate);
375
376         return ret;
377 }
378
379 int clk_set_rate(struct clk *c, unsigned long rate)
380 {
381         unsigned long flags;
382         int ret;
383
384         if (!c->ops || !c->ops->set_rate)
385                 return -ENOSYS;
386
387         clk_lock_save(c, &flags);
388
389         ret = clk_set_rate_locked(c, rate);
390
391         clk_unlock_restore(c, &flags);
392
393         return ret;
394 }
395 EXPORT_SYMBOL(clk_set_rate);
396
397 /* Must be called with clocks lock and all indvidual clock locks held */
398 unsigned long clk_get_rate_all_locked(struct clk *c)
399 {
400         u64 rate;
401         int mul = 1;
402         int div = 1;
403         struct clk *p = c;
404
405         while (p) {
406                 c = p;
407                 if (c->ops && c->ops->recalculate_rate)
408                         c->ops->recalculate_rate(c);
409                 if (c->mul != 0 && c->div != 0) {
410                         mul *= c->mul;
411                         div *= c->div;
412                 }
413                 p = c->parent;
414         }
415
416         rate = c->rate;
417         rate *= mul;
418         do_div(rate, div);
419
420         return rate;
421 }
422
423 long clk_round_rate(struct clk *c, unsigned long rate)
424 {
425         unsigned long flags, max_rate;
426         long ret;
427
428         clk_lock_save(c, &flags);
429
430         if (!c->ops || !c->ops->round_rate) {
431                 ret = -ENOSYS;
432                 goto out;
433         }
434
435         max_rate = clk_get_max_rate(c);
436         if (rate > max_rate)
437                 rate = max_rate;
438
439         ret = c->ops->round_rate(c, rate);
440
441 out:
442         clk_unlock_restore(c, &flags);
443         return ret;
444 }
445 EXPORT_SYMBOL(clk_round_rate);
446
447 static int tegra_clk_clip_rate_for_parent(struct clk *c, struct clk *p)
448 {
449         unsigned long flags, max_rate, old_rate, new_rate;
450
451         clk_lock_save(c, flags);
452
453         max_rate = clk_get_max_rate(c);
454         new_rate = clk_predict_rate_from_parent(c, p);
455         old_rate = clk_get_rate_locked(c);
456
457         clk_unlock_restore(c, flags);
458
459         if (new_rate > max_rate) {
460                 u64 rate = max_rate;
461                 rate *= old_rate;
462                 do_div(rate, new_rate);
463
464                 return clk_set_rate(c, (unsigned long)rate);
465         }
466         return 0;
467 }
468
469 static int tegra_clk_init_one_from_table(struct tegra_clk_init_table *table)
470 {
471         struct clk *c;
472         struct clk *p;
473
474         int ret = 0;
475
476         c = tegra_get_clock_by_name(table->name);
477
478         if (!c) {
479                 pr_warning("Unable to initialize clock %s\n",
480                         table->name);
481                 return -ENODEV;
482         }
483
484         if (table->parent) {
485                 p = tegra_get_clock_by_name(table->parent);
486                 if (!p) {
487                         pr_warning("Unable to find parent %s of clock %s\n",
488                                 table->parent, table->name);
489                         return -ENODEV;
490                 }
491
492                 if (c->parent != p) {
493                         ret = tegra_clk_clip_rate_for_parent(c, p);
494                         if (ret) {
495                                 pr_warning("Unable to clip rate for parent %s"
496                                            " of clock %s: %d\n",
497                                            table->parent, table->name, ret);
498                                 return -EINVAL;
499                         }
500
501                         ret = clk_set_parent(c, p);
502                         if (ret) {
503                                 pr_warning("Unable to set parent %s of clock %s: %d\n",
504                                         table->parent, table->name, ret);
505                                 return -EINVAL;
506                         }
507                 }
508         }
509
510         if (table->rate && table->rate != clk_get_rate(c)) {
511                 ret = clk_set_rate(c, table->rate);
512                 if (ret) {
513                         pr_warning("Unable to set clock %s to rate %lu: %d\n",
514                                 table->name, table->rate, ret);
515                         return -EINVAL;
516                 }
517         }
518
519         if (table->enabled) {
520                 ret = clk_enable(c);
521                 if (ret) {
522                         pr_warning("Unable to enable clock %s: %d\n",
523                                 table->name, ret);
524                         return -EINVAL;
525                 }
526         }
527
528         return 0;
529 }
530
531 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
532 {
533         for (; table->name; table++)
534                 tegra_clk_init_one_from_table(table);
535 }
536 EXPORT_SYMBOL(tegra_clk_init_from_table);
537
538 void tegra_periph_reset_deassert(struct clk *c)
539 {
540         BUG_ON(!c->ops->reset);
541         c->ops->reset(c, false);
542 }
543 EXPORT_SYMBOL(tegra_periph_reset_deassert);
544
545 void tegra_periph_reset_assert(struct clk *c)
546 {
547         BUG_ON(!c->ops->reset);
548         c->ops->reset(c, true);
549 }
550 EXPORT_SYMBOL(tegra_periph_reset_assert);
551
552 void __init tegra_init_clock(void)
553 {
554         tegra_soc_init_clocks();
555         tegra_soc_init_dvfs();
556 }
557
558 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
559 /* On tegra 2 SoC the SDMMC clock source register have extra bits that
560  * adjust the SDMMC controller delay between the clock and data to
561  * compenstate  for delays on the PCB. */
562 void tegra_sdmmc_tap_delay(struct clk *c, int delay) {
563         unsigned long flags;
564
565         clk_lock_save(c, flags);
566         tegra2_sdmmc_tap_delay(c, delay);
567
568         clk_unlock_restore(c, flags);
569 }
570 #endif
571
572 static bool tegra_keep_boot_clocks = false;
573 static int __init tegra_keep_boot_clocks_setup(char *__unused)
574 {
575         tegra_keep_boot_clocks = true;
576         return 1;
577 }
578 __setup("tegra_keep_boot_clocks", tegra_keep_boot_clocks_setup);
579
580 /*
581  * Iterate through all clocks, disabling any for which the refcount is 0
582  * but the clock init detected the bootloader left the clock on.
583  */
584 static int __init tegra_init_disable_boot_clocks(void)
585 {
586 #if DISABLE_BOOT_CLOCKS
587         unsigned long flags;
588         struct clk *c;
589
590         mutex_lock(&clock_list_lock);
591
592         list_for_each_entry(c, &clocks, node) {
593                 clk_lock_save(c, &flags);
594                 if (c->refcnt == 0 && c->state == ON &&
595                                 c->ops && c->ops->disable) {
596                         pr_warn_once("%s clocks left on by bootloader:\n",
597                                 tegra_keep_boot_clocks ?
598                                         "Prevented disabling" :
599                                         "Disabling");
600
601                         pr_warn("   %s\n", c->name);
602
603                         if (!tegra_keep_boot_clocks) {
604                                 c->ops->disable(c);
605                                 c->state = OFF;
606                         }
607                 }
608                 clk_unlock_restore(c, &flags);
609         }
610
611         mutex_unlock(&clock_list_lock);
612 #endif
613         return 0;
614 }
615 late_initcall(tegra_init_disable_boot_clocks);
616
617 /* Several extended clock configuration bits (e.g., clock routing, clock
618  * phase control) are included in PLL and peripheral clock source
619  * registers. */
620 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
621 {
622         int ret = 0;
623         unsigned long flags;
624
625         clk_lock_save(c, flags);
626
627         if (!c->ops || !c->ops->clk_cfg_ex) {
628                 ret = -ENOSYS;
629                 goto out;
630         }
631         ret = c->ops->clk_cfg_ex(c, p, setting);
632
633 out:
634         clk_unlock_restore(c, flags);
635         return ret;
636 }
637
638 #ifdef CONFIG_DEBUG_FS
639
640 /*
641  * Attempt to lock all the clocks that are marked cansleep
642  * Must be called with irqs enabled
643  */
644 static int __clk_lock_all_mutexes(void)
645 {
646         struct clk *c;
647
648         might_sleep();
649
650         list_for_each_entry(c, &clocks, node)
651                 if (clk_cansleep(c))
652                         if (!mutex_trylock(&c->mutex))
653                                 goto unlock_mutexes;
654
655         return 0;
656
657 unlock_mutexes:
658         list_for_each_entry_continue_reverse(c, &clocks, node)
659                 if (clk_cansleep(c))
660                         mutex_unlock(&c->mutex);
661
662         return -EAGAIN;
663 }
664
665 /*
666  * Attempt to lock all the clocks that are not marked cansleep
667  * Must be called with irqs disabled
668  */
669 static int __clk_lock_all_spinlocks(void)
670 {
671         struct clk *c;
672
673         list_for_each_entry(c, &clocks, node)
674                 if (!clk_cansleep(c))
675                         if (!spin_trylock(&c->spinlock))
676                                 goto unlock_spinlocks;
677
678         return 0;
679
680 unlock_spinlocks:
681         list_for_each_entry_continue_reverse(c, &clocks, node)
682                 if (!clk_cansleep(c))
683                         spin_unlock(&c->spinlock);
684
685         return -EAGAIN;
686 }
687
688 static void __clk_unlock_all_mutexes(void)
689 {
690         struct clk *c;
691
692         list_for_each_entry_reverse(c, &clocks, node)
693                 if (clk_cansleep(c))
694                         mutex_unlock(&c->mutex);
695 }
696
697 static void __clk_unlock_all_spinlocks(void)
698 {
699         struct clk *c;
700
701         list_for_each_entry_reverse(c, &clocks, node)
702                 if (!clk_cansleep(c))
703                         spin_unlock(&c->spinlock);
704 }
705
706 /*
707  * This function retries until it can take all locks, and may take
708  * an arbitrarily long time to complete.
709  * Must be called with irqs enabled, returns with irqs disabled
710  * Must be called with clock_list_lock held
711  */
712 static void clk_lock_all(void)
713 {
714         int ret;
715 retry:
716         ret = __clk_lock_all_mutexes();
717         if (ret)
718                 goto failed_mutexes;
719
720         local_irq_disable();
721
722         ret = __clk_lock_all_spinlocks();
723         if (ret)
724                 goto failed_spinlocks;
725
726         /* All locks taken successfully, return */
727         return;
728
729 failed_spinlocks:
730         local_irq_enable();
731         __clk_unlock_all_mutexes();
732 failed_mutexes:
733         msleep(1);
734         goto retry;
735 }
736
737 /*
738  * Unlocks all clocks after a clk_lock_all
739  * Must be called with irqs disabled, returns with irqs enabled
740  * Must be called with clock_list_lock held
741  */
742 static void clk_unlock_all(void)
743 {
744         __clk_unlock_all_spinlocks();
745
746         local_irq_enable();
747
748         __clk_unlock_all_mutexes();
749 }
750
751 static struct dentry *clk_debugfs_root;
752
753 static void dvfs_show_one(struct seq_file *s, struct dvfs *d, int level)
754 {
755         seq_printf(s, "%*s  %-*s%21s%d mV\n",
756                         level * 3 + 1, "",
757                         30 - level * 3, d->dvfs_rail->reg_id,
758                         "",
759                         d->cur_millivolts);
760 }
761
762 static void clock_tree_show_one(struct seq_file *s, struct clk *c, int level)
763 {
764         struct clk *child;
765         const char *state = "uninit";
766         char div[8] = {0};
767         unsigned long rate = clk_get_rate_all_locked(c);
768         unsigned long max_rate = clk_get_max_rate(c);;
769
770         if (c->state == ON)
771                 state = "on";
772         else if (c->state == OFF)
773                 state = "off";
774
775         if (c->mul != 0 && c->div != 0) {
776                 if (c->mul > c->div) {
777                         int mul = c->mul / c->div;
778                         int mul2 = (c->mul * 10 / c->div) % 10;
779                         int mul3 = (c->mul * 10) % c->div;
780                         if (mul2 == 0 && mul3 == 0)
781                                 snprintf(div, sizeof(div), "x%d", mul);
782                         else if (mul3 == 0)
783                                 snprintf(div, sizeof(div), "x%d.%d", mul, mul2);
784                         else
785                                 snprintf(div, sizeof(div), "x%d.%d..", mul, mul2);
786                 } else {
787                         snprintf(div, sizeof(div), "%d%s", c->div / c->mul,
788                                 (c->div % c->mul) ? ".5" : "");
789                 }
790         }
791
792         seq_printf(s, "%*s%c%c%-*s %-6s %-3d %-8s %-10lu\n",
793                 level * 3 + 1, "",
794                 rate > max_rate ? '!' : ' ',
795                 !c->set ? '*' : ' ',
796                 30 - level * 3, c->name,
797                 state, c->refcnt, div, rate);
798
799         if (c->dvfs)
800                 dvfs_show_one(s, c->dvfs, level + 1);
801
802         list_for_each_entry(child, &clocks, node) {
803                 if (child->parent != c)
804                         continue;
805
806                 clock_tree_show_one(s, child, level + 1);
807         }
808 }
809
810 static int clock_tree_show(struct seq_file *s, void *data)
811 {
812         struct clk *c;
813         seq_printf(s, "   clock                          state  ref div      rate\n");
814         seq_printf(s, "--------------------------------------------------------------\n");
815
816         mutex_lock(&clock_list_lock);
817
818         clk_lock_all();
819
820         list_for_each_entry(c, &clocks, node)
821                 if (c->parent == NULL)
822                         clock_tree_show_one(s, c, 0);
823
824         clk_unlock_all();
825
826         mutex_unlock(&clock_list_lock);
827         return 0;
828 }
829
830 static int clock_tree_open(struct inode *inode, struct file *file)
831 {
832         return single_open(file, clock_tree_show, inode->i_private);
833 }
834
835 static const struct file_operations clock_tree_fops = {
836         .open           = clock_tree_open,
837         .read           = seq_read,
838         .llseek         = seq_lseek,
839         .release        = single_release,
840 };
841
842 static int possible_parents_show(struct seq_file *s, void *data)
843 {
844         struct clk *c = s->private;
845         int i;
846
847         for (i = 0; c->inputs[i].input; i++) {
848                 char *first = (i == 0) ? "" : " ";
849                 seq_printf(s, "%s%s", first, c->inputs[i].input->name);
850         }
851         seq_printf(s, "\n");
852         return 0;
853 }
854
855 static int possible_parents_open(struct inode *inode, struct file *file)
856 {
857         return single_open(file, possible_parents_show, inode->i_private);
858 }
859
860 static const struct file_operations possible_parents_fops = {
861         .open           = possible_parents_open,
862         .read           = seq_read,
863         .llseek         = seq_lseek,
864         .release        = single_release,
865 };
866
867 static int parent_show(struct seq_file *s, void *data)
868 {
869         struct clk *c = s->private;
870         struct clk *p = clk_get_parent(c);
871
872         seq_printf(s, "%s\n", p ? p->name : "clk_root");
873         return 0;
874 }
875
876 static int parent_open(struct inode *inode, struct file *file)
877 {
878         return single_open(file, parent_show, inode->i_private);
879 }
880
881 static int rate_get(void *data, u64 *val)
882 {
883         struct clk *c = (struct clk *)data;
884         *val = (u64)clk_get_rate(c);
885         return 0;
886 }
887
888 static int state_get(void *data, u64 *val)
889 {
890         struct clk *c = (struct clk *)data;
891         *val = (u64)((c->state == ON) ? 1 : 0);
892         return 0;
893 }
894
895 #ifdef CONFIG_TEGRA_CLOCK_DEBUG_WRITE
896
897 static const mode_t parent_rate_mode =  S_IRUGO | S_IWUGO;
898
899 static ssize_t parent_write(struct file *file,
900         const char __user *userbuf, size_t count, loff_t *ppos)
901 {
902         struct seq_file *s = file->private_data;
903         struct clk *c = s->private;
904         struct clk *p = NULL;
905         char buf[32];
906
907         if (sizeof(buf) <= count)
908                 return -EINVAL;
909
910         if (copy_from_user(buf, userbuf, count))
911                 return -EFAULT;
912
913         /* terminate buffer and trim - white spaces may be appended
914          *  at the end when invoked from shell command line */
915         buf[count]='\0';
916         strim(buf);
917
918         p = tegra_get_clock_by_name(buf);
919         if (!p)
920                 return -EINVAL;
921
922         if (clk_set_parent(c, p))
923                 return -EINVAL;
924
925         return count;
926 }
927
928 static const struct file_operations parent_fops = {
929         .open           = parent_open,
930         .read           = seq_read,
931         .write          = parent_write,
932         .llseek         = seq_lseek,
933         .release        = single_release,
934 };
935
936 static int rate_set(void *data, u64 val)
937 {
938         struct clk *c = (struct clk *)data;
939         return clk_set_rate(c, (unsigned long)val);
940 }
941 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, rate_set, "%llu\n");
942
943 static int state_set(void *data, u64 val)
944 {
945         struct clk *c = (struct clk *)data;
946
947         if (val)
948                 return clk_enable(c);
949         else {
950                 clk_disable(c);
951                 return 0;
952         }
953 }
954 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, state_set, "%llu\n");
955
956 #else
957
958 static const mode_t parent_rate_mode =  S_IRUGO;
959
960 static const struct file_operations parent_fops = {
961         .open           = parent_open,
962         .read           = seq_read,
963         .llseek         = seq_lseek,
964         .release        = single_release,
965 };
966
967 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, NULL, "%llu\n");
968 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, NULL, "%llu\n");
969 #endif
970
971 static int clk_debugfs_register_one(struct clk *c)
972 {
973         struct dentry *d;
974
975         d = debugfs_create_dir(c->name, clk_debugfs_root);
976         if (!d)
977                 return -ENOMEM;
978         c->dent = d;
979
980         d = debugfs_create_u8("refcnt", S_IRUGO, c->dent, (u8 *)&c->refcnt);
981         if (!d)
982                 goto err_out;
983
984         d = debugfs_create_x32("flags", S_IRUGO, c->dent, (u32 *)&c->flags);
985         if (!d)
986                 goto err_out;
987
988         d = debugfs_create_u32("max", S_IRUGO, c->dent, (u32 *)&c->max_rate);
989         if (!d)
990                 goto err_out;
991
992         d = debugfs_create_file(
993                 "parent", parent_rate_mode, c->dent, c, &parent_fops);
994         if (!d)
995                 goto err_out;
996
997         d = debugfs_create_file(
998                 "rate", parent_rate_mode, c->dent, c, &rate_fops);
999         if (!d)
1000                 goto err_out;
1001
1002         d = debugfs_create_file(
1003                 "state", parent_rate_mode, c->dent, c, &state_fops);
1004         if (!d)
1005                 goto err_out;
1006
1007         if (c->inputs) {
1008                 d = debugfs_create_file("possible_parents", S_IRUGO, c->dent,
1009                         c, &possible_parents_fops);
1010                 if (!d)
1011                         goto err_out;
1012         }
1013
1014         return 0;
1015
1016 err_out:
1017         debugfs_remove_recursive(c->dent);
1018         return -ENOMEM;
1019 }
1020
1021 static int clk_debugfs_register(struct clk *c)
1022 {
1023         int err;
1024         struct clk *pa = c->parent;
1025
1026         if (pa && !pa->dent) {
1027                 err = clk_debugfs_register(pa);
1028                 if (err)
1029                         return err;
1030         }
1031
1032         if (!c->dent) {
1033                 err = clk_debugfs_register_one(c);
1034                 if (err)
1035                         return err;
1036         }
1037         return 0;
1038 }
1039
1040 static int __init clk_debugfs_init(void)
1041 {
1042         struct clk *c;
1043         struct dentry *d;
1044         int err = -ENOMEM;
1045
1046         d = debugfs_create_dir("clock", NULL);
1047         if (!d)
1048                 return -ENOMEM;
1049         clk_debugfs_root = d;
1050
1051         d = debugfs_create_file("clock_tree", S_IRUGO, clk_debugfs_root, NULL,
1052                 &clock_tree_fops);
1053         if (!d)
1054                 goto err_out;
1055
1056         if (dvfs_debugfs_init(clk_debugfs_root))
1057                 goto err_out;
1058
1059         list_for_each_entry(c, &clocks, node) {
1060                 err = clk_debugfs_register(c);
1061                 if (err)
1062                         goto err_out;
1063         }
1064         return 0;
1065 err_out:
1066         debugfs_remove_recursive(clk_debugfs_root);
1067         return err;
1068 }
1069
1070 late_initcall(clk_debugfs_init);
1071 #endif