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