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