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