ab167a2f8cd9bdcc072240e051652922b7b32e0a
[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 #ifdef CONFIG_ARM_ARCH_TIMER
710         tegra_init_early_timer()
711 #else
712         tegra_twd_init();
713 #endif
714 }
715
716 static bool tegra_keep_boot_clocks = false;
717 static int __init tegra_keep_boot_clocks_setup(char *__unused)
718 {
719         tegra_keep_boot_clocks = true;
720         return 1;
721 }
722 __setup("tegra_keep_boot_clocks", tegra_keep_boot_clocks_setup);
723
724 /*
725  * Bootloader may not match kernel restrictions on CPU clock sources.
726  * Make sure CPU clock is sourced from either main or backup parent.
727  */
728 static int tegra_sync_cpu_clock(void)
729 {
730         int ret;
731         unsigned long rate;
732         struct clk *c = tegra_get_clock_by_name("cpu");
733
734         BUG_ON(!c);
735         rate = clk_get_rate(c);
736         ret = clk_set_rate(c, rate);
737         if (ret)
738                 pr_err("%s: Failed to sync CPU at rate %lu\n", __func__, rate);
739         else
740                 pr_info("CPU rate: %lu MHz\n", clk_get_rate(c) / 1000000);
741         return ret;
742 }
743 late_initcall(tegra_sync_cpu_clock);
744
745 /*
746  * Iterate through all clocks, disabling any for which the refcount is 0
747  * but the clock init detected the bootloader left the clock on.
748  */
749 static int __init tegra_init_disable_boot_clocks(void)
750 {
751 #if DISABLE_BOOT_CLOCKS
752         unsigned long flags;
753         struct clk *c;
754
755         mutex_lock(&clock_list_lock);
756
757         list_for_each_entry(c, &clocks, node) {
758                 clk_lock_save(c, &flags);
759                 if (c->refcnt == 0 && c->state == ON &&
760                                 c->ops && c->ops->disable) {
761                         pr_warn_once("%s clocks left on by bootloader:\n",
762                                 tegra_keep_boot_clocks ?
763                                         "Prevented disabling" :
764                                         "Disabling");
765
766                         pr_warn("   %s\n", c->name);
767
768                         if (!tegra_keep_boot_clocks) {
769                                 c->ops->disable(c);
770                                 c->state = OFF;
771                         }
772                 }
773                 clk_unlock_restore(c, &flags);
774         }
775
776         mutex_unlock(&clock_list_lock);
777 #endif
778         return 0;
779 }
780 late_initcall(tegra_init_disable_boot_clocks);
781
782 /* Several extended clock configuration bits (e.g., clock routing, clock
783  * phase control) are included in PLL and peripheral clock source
784  * registers. */
785 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
786 {
787         int ret = 0;
788         unsigned long flags;
789
790         spin_lock_irqsave(&c->spinlock, flags);
791
792         if (!c->ops || !c->ops->clk_cfg_ex) {
793                 ret = -ENOSYS;
794                 goto out;
795         }
796         ret = c->ops->clk_cfg_ex(c, p, setting);
797
798 out:
799         spin_unlock_irqrestore(&c->spinlock, flags);
800         return ret;
801 }
802
803 int tegra_register_clk_rate_notifier(struct clk *c, struct notifier_block *nb)
804 {
805         int ret;
806         unsigned long flags;
807
808         if (!c->rate_change_nh)
809                 return -ENOSYS;
810
811         clk_lock_save(c, &flags);
812         ret = raw_notifier_chain_register(c->rate_change_nh, nb);
813         clk_unlock_restore(c, &flags);
814         return ret;
815 }
816
817 void tegra_unregister_clk_rate_notifier(
818         struct clk *c, struct notifier_block *nb)
819 {
820         unsigned long flags;
821
822         if (!c->rate_change_nh)
823                 return;
824
825         clk_lock_save(c, &flags);
826         raw_notifier_chain_unregister(c->rate_change_nh, nb);
827         clk_unlock_restore(c, &flags);
828 }
829
830 #define OSC_FREQ_DET                    0x58
831 #define OSC_FREQ_DET_TRIG               BIT(31)
832
833 #define OSC_FREQ_DET_STATUS             0x5C
834 #define OSC_FREQ_DET_BUSY               BIT(31)
835 #define OSC_FREQ_DET_CNT_MASK           0xFFFF
836
837 unsigned long tegra_clk_measure_input_freq(void)
838 {
839         u32 clock_autodetect;
840         void __iomem *clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
841
842         writel(OSC_FREQ_DET_TRIG | 1, clk_base + OSC_FREQ_DET);
843         do {} while (readl(clk_base + OSC_FREQ_DET_STATUS) & OSC_FREQ_DET_BUSY);
844
845         clock_autodetect = readl(clk_base + OSC_FREQ_DET_STATUS);
846         if (clock_autodetect >= 732 - 3 && clock_autodetect <= 732 + 3) {
847                 return 12000000;
848         } else if (clock_autodetect >= 794 - 3 && clock_autodetect <= 794 + 3) {
849                 return 13000000;
850         } else if (clock_autodetect >= 1172 - 3 && clock_autodetect <= 1172 + 3) {
851                 return 19200000;
852         } else if (clock_autodetect >= 1587 - 3 && clock_autodetect <= 1587 + 3) {
853                 return 26000000;
854 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
855         } else if (clock_autodetect >= 1025 - 3 && clock_autodetect <= 1025 + 3) {
856                 return 16800000;
857         } else if (clock_autodetect >= 2344 - 3 && clock_autodetect <= 2344 + 3) {
858                 return 38400000;
859         } else if (clock_autodetect >= 2928 - 3 && clock_autodetect <= 2928 + 3) {
860                 return 48000000;
861 #ifdef CONFIG_ARCH_TEGRA_11x_SOC
862         } else if (tegra_revision == TEGRA_REVISION_QT) {
863                 if (clock_autodetect >= 2 && clock_autodetect <= 9)
864                         return 115200;
865                 else if (clock_autodetect >= 13 && clock_autodetect <= 15)
866                         return 230400;
867 #endif
868 #endif
869         } else {
870                 pr_err("%s: Unexpected clock autodetect value %d", __func__, clock_autodetect);
871         }
872
873         BUG();
874         return 0;
875 }
876
877 #ifdef CONFIG_DEBUG_FS
878
879 /*
880  * Attempt to lock all the clocks that are marked cansleep
881  * Must be called with irqs enabled
882  */
883 static int __clk_lock_all_mutexes(void)
884 {
885         struct clk *c;
886
887         might_sleep();
888
889         list_for_each_entry(c, &clocks, node)
890                 if (clk_cansleep(c))
891                         if (!mutex_trylock(&c->mutex))
892                                 goto unlock_mutexes;
893
894         return 0;
895
896 unlock_mutexes:
897         list_for_each_entry_continue_reverse(c, &clocks, node)
898                 if (clk_cansleep(c))
899                         mutex_unlock(&c->mutex);
900
901         return -EAGAIN;
902 }
903
904 /*
905  * Attempt to lock all the clocks that are not marked cansleep
906  * Must be called with irqs disabled
907  */
908 static int __clk_lock_all_spinlocks(void)
909 {
910         struct clk *c;
911
912         list_for_each_entry(c, &clocks, node)
913                 if (!clk_cansleep(c))
914                         if (!spin_trylock(&c->spinlock))
915                                 goto unlock_spinlocks;
916
917         return 0;
918
919 unlock_spinlocks:
920         list_for_each_entry_continue_reverse(c, &clocks, node)
921                 if (!clk_cansleep(c))
922                         spin_unlock(&c->spinlock);
923
924         return -EAGAIN;
925 }
926
927 static void __clk_unlock_all_mutexes(void)
928 {
929         struct clk *c;
930
931         list_for_each_entry_reverse(c, &clocks, node)
932                 if (clk_cansleep(c))
933                         mutex_unlock(&c->mutex);
934 }
935
936 static void __clk_unlock_all_spinlocks(void)
937 {
938         struct clk *c;
939
940         list_for_each_entry_reverse(c, &clocks, node)
941                 if (!clk_cansleep(c))
942                         spin_unlock(&c->spinlock);
943 }
944
945 /*
946  * This function retries until it can take all locks, and may take
947  * an arbitrarily long time to complete.
948  * Must be called with irqs enabled, returns with irqs disabled
949  * Must be called with clock_list_lock held
950  */
951 static void clk_lock_all(void)
952 {
953         int ret;
954 retry:
955         ret = __clk_lock_all_mutexes();
956         if (ret)
957                 goto failed_mutexes;
958
959         local_irq_disable();
960
961         ret = __clk_lock_all_spinlocks();
962         if (ret)
963                 goto failed_spinlocks;
964
965         /* All locks taken successfully, return */
966         return;
967
968 failed_spinlocks:
969         local_irq_enable();
970         __clk_unlock_all_mutexes();
971 failed_mutexes:
972         msleep(1);
973         goto retry;
974 }
975
976 /*
977  * Unlocks all clocks after a clk_lock_all
978  * Must be called with irqs disabled, returns with irqs enabled
979  * Must be called with clock_list_lock held
980  */
981 static void clk_unlock_all(void)
982 {
983         __clk_unlock_all_spinlocks();
984
985         local_irq_enable();
986
987         __clk_unlock_all_mutexes();
988 }
989
990 static struct dentry *clk_debugfs_root;
991
992 static void dvfs_show_one(struct seq_file *s, struct dvfs *d, int level)
993 {
994         seq_printf(s, "%*s  %-*s%21s%d mV\n",
995                         level * 3 + 1, "",
996                         30 - level * 3, d->dvfs_rail->reg_id,
997                         "",
998                         d->cur_millivolts);
999 }
1000
1001 static void clock_tree_show_one(struct seq_file *s, struct clk *c, int level)
1002 {
1003         struct clk *child;
1004         const char *state = "uninit";
1005         char div[8] = {0};
1006         unsigned long rate = clk_get_rate_all_locked(c);
1007         unsigned long max_rate = clk_get_max_rate(c);;
1008
1009         if (c->state == ON)
1010                 state = "on";
1011         else if (c->state == OFF)
1012                 state = "off";
1013
1014         if (c->mul != 0 && c->div != 0) {
1015                 if (c->mul > c->div) {
1016                         int mul = c->mul / c->div;
1017                         int mul2 = (c->mul * 10 / c->div) % 10;
1018                         int mul3 = (c->mul * 10) % c->div;
1019                         if (mul2 == 0 && mul3 == 0)
1020                                 snprintf(div, sizeof(div), "x%d", mul);
1021                         else if (mul3 == 0)
1022                                 snprintf(div, sizeof(div), "x%d.%d", mul, mul2);
1023                         else
1024                                 snprintf(div, sizeof(div), "x%d.%d..", mul, mul2);
1025                 } else {
1026                         snprintf(div, sizeof(div), "%d%s", c->div / c->mul,
1027                                 (c->div % c->mul) ? ".5" : "");
1028                 }
1029         }
1030
1031         seq_printf(s, "%*s%c%c%-*s%c %-6s %-3d %-8s %-10lu",
1032                 level * 3 + 1, "",
1033                 rate > max_rate ? '!' : ' ',
1034                 !c->set ? '*' : ' ',
1035                 30 - level * 3, c->name,
1036                 c->cansleep ? '$' : ' ',
1037                 state, c->refcnt, div, rate);
1038         if (c->parent && !list_empty(&c->parent->shared_bus_list))
1039                 seq_printf(s, " (%lu)", c->u.shared_bus_user.rate);
1040         seq_printf(s, "\n");
1041
1042         if (c->dvfs)
1043                 dvfs_show_one(s, c->dvfs, level + 1);
1044
1045         list_for_each_entry(child, &clocks, node) {
1046                 if (child->parent != c)
1047                         continue;
1048
1049                 clock_tree_show_one(s, child, level + 1);
1050         }
1051 }
1052
1053 static int clock_tree_show(struct seq_file *s, void *data)
1054 {
1055         struct clk *c;
1056         seq_printf(s, "   clock                          state  ref div      rate       (shared rate)\n");
1057         seq_printf(s, "------------------------------------------------------------------------------\n");
1058
1059         mutex_lock(&clock_list_lock);
1060 #ifndef CONFIG_TEGRA_FPGA_PLATFORM
1061         clk_lock_all();
1062 #endif
1063         list_for_each_entry(c, &clocks, node)
1064                 if (c->parent == NULL)
1065                         clock_tree_show_one(s, c, 0);
1066 #ifndef CONFIG_TEGRA_FPGA_PLATFORM
1067         clk_unlock_all();
1068 #endif
1069         mutex_unlock(&clock_list_lock);
1070         return 0;
1071 }
1072
1073 static int clock_tree_open(struct inode *inode, struct file *file)
1074 {
1075         return single_open(file, clock_tree_show, inode->i_private);
1076 }
1077
1078 static const struct file_operations clock_tree_fops = {
1079         .open           = clock_tree_open,
1080         .read           = seq_read,
1081         .llseek         = seq_lseek,
1082         .release        = single_release,
1083 };
1084
1085 static void syncevent_one(struct clk *c)
1086 {
1087         struct clk *child;
1088
1089         if (c->state == ON)
1090                 trace_clock_enable(c->name, 1, smp_processor_id());
1091         else
1092                 trace_clock_disable(c->name, 0, smp_processor_id());
1093
1094         trace_clock_set_rate(c->name, clk_get_rate_all_locked(c),
1095                                 smp_processor_id());
1096
1097         list_for_each_entry(child, &clocks, node) {
1098                 if (child->parent != c)
1099                         continue;
1100
1101                 syncevent_one(child);
1102         }
1103 }
1104
1105 static int syncevent_write(struct file *file, const char __user *user_buf,
1106                                 size_t count, loff_t *ppos)
1107 {
1108         struct clk *c;
1109         char buffer[40];
1110         int buf_size;
1111
1112         memset(buffer, 0, sizeof(buffer));
1113         buf_size = min(count, (sizeof(buffer)-1));
1114
1115         if (copy_from_user(buffer, user_buf, buf_size))
1116                 return -EFAULT;
1117
1118         if (!strnicmp("all", buffer, 3)) {
1119                 mutex_lock(&clock_list_lock);
1120
1121                 clk_lock_all();
1122
1123                 list_for_each_entry(c, &clocks, node) {
1124                         if (c->parent == NULL)
1125                                 syncevent_one(c);
1126                 }
1127
1128                 clk_unlock_all();
1129
1130                 mutex_unlock(&clock_list_lock);
1131         }
1132
1133         return count;
1134 }
1135
1136 static const struct file_operations syncevent_fops = {
1137         .write          = syncevent_write,
1138 };
1139
1140 static int possible_parents_show(struct seq_file *s, void *data)
1141 {
1142         struct clk *c = s->private;
1143         int i;
1144
1145         for (i = 0; c->inputs[i].input; i++) {
1146                 char *first = (i == 0) ? "" : " ";
1147                 seq_printf(s, "%s%s", first, c->inputs[i].input->name);
1148         }
1149         seq_printf(s, "\n");
1150         return 0;
1151 }
1152
1153 static int possible_parents_open(struct inode *inode, struct file *file)
1154 {
1155         return single_open(file, possible_parents_show, inode->i_private);
1156 }
1157
1158 static const struct file_operations possible_parents_fops = {
1159         .open           = possible_parents_open,
1160         .read           = seq_read,
1161         .llseek         = seq_lseek,
1162         .release        = single_release,
1163 };
1164
1165 static int parent_show(struct seq_file *s, void *data)
1166 {
1167         struct clk *c = s->private;
1168         struct clk *p = clk_get_parent(c);
1169
1170         seq_printf(s, "%s\n", p ? p->name : "clk_root");
1171         return 0;
1172 }
1173
1174 static int parent_open(struct inode *inode, struct file *file)
1175 {
1176         return single_open(file, parent_show, inode->i_private);
1177 }
1178
1179 static int rate_get(void *data, u64 *val)
1180 {
1181         struct clk *c = (struct clk *)data;
1182         *val = (u64)clk_get_rate(c);
1183         return 0;
1184 }
1185
1186 static int state_get(void *data, u64 *val)
1187 {
1188         struct clk *c = (struct clk *)data;
1189         *val = (u64)((c->state == ON) ? 1 : 0);
1190         return 0;
1191 }
1192
1193 #ifdef CONFIG_TEGRA_CLOCK_DEBUG_WRITE
1194
1195 static const mode_t parent_rate_mode =  S_IRUGO | S_IWUSR;
1196
1197 static ssize_t parent_write(struct file *file,
1198         const char __user *userbuf, size_t count, loff_t *ppos)
1199 {
1200         struct seq_file *s = file->private_data;
1201         struct clk *c = s->private;
1202         struct clk *p = NULL;
1203         char buf[32];
1204
1205         if (sizeof(buf) <= count)
1206                 return -EINVAL;
1207
1208         if (copy_from_user(buf, userbuf, count))
1209                 return -EFAULT;
1210
1211         /* terminate buffer and trim - white spaces may be appended
1212          *  at the end when invoked from shell command line */
1213         buf[count]='\0';
1214         strim(buf);
1215
1216         p = tegra_get_clock_by_name(buf);
1217         if (!p)
1218                 return -EINVAL;
1219
1220         if (clk_set_parent(c, p))
1221                 return -EINVAL;
1222
1223         return count;
1224 }
1225
1226 static const struct file_operations parent_fops = {
1227         .open           = parent_open,
1228         .read           = seq_read,
1229         .write          = parent_write,
1230         .llseek         = seq_lseek,
1231         .release        = single_release,
1232 };
1233
1234 static int rate_set(void *data, u64 val)
1235 {
1236         struct clk *c = (struct clk *)data;
1237         return clk_set_rate(c, (unsigned long)val);
1238 }
1239 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, rate_set, "%llu\n");
1240
1241 static int state_set(void *data, u64 val)
1242 {
1243         struct clk *c = (struct clk *)data;
1244
1245         if (val)
1246                 return clk_enable(c);
1247         else {
1248                 clk_disable(c);
1249                 return 0;
1250         }
1251 }
1252 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, state_set, "%llu\n");
1253
1254 #else
1255
1256 static const mode_t parent_rate_mode =  S_IRUGO;
1257
1258 static const struct file_operations parent_fops = {
1259         .open           = parent_open,
1260         .read           = seq_read,
1261         .llseek         = seq_lseek,
1262         .release        = single_release,
1263 };
1264
1265 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, NULL, "%llu\n");
1266 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, NULL, "%llu\n");
1267 #endif
1268
1269 static int time_on_get(void *data, u64 *val)
1270 {
1271         unsigned long flags;
1272         struct clk *c = (struct clk *)data;
1273
1274         clk_lock_save(c, &flags);
1275         clk_stats_update(c);
1276         *val = cputime64_to_clock_t(c->stats.time_on);
1277         clk_unlock_restore(c, &flags);
1278
1279         return 0;
1280 }
1281 DEFINE_SIMPLE_ATTRIBUTE(time_on_fops, time_on_get, NULL, "%llu\n");
1282
1283 static int possible_rates_show(struct seq_file *s, void *data)
1284 {
1285         struct clk *c = s->private;
1286         long rate = 0;
1287
1288         /* shared bus clock must round up, unless top of range reached */
1289         while (rate <= c->max_rate) {
1290                 long rounded_rate = c->ops->round_rate(c, rate);
1291                 if (IS_ERR_VALUE(rounded_rate) || (rounded_rate <= rate))
1292                         break;
1293
1294                 rate = rounded_rate + 2000;     /* 2kHz resolution */
1295                 seq_printf(s, "%ld ", rounded_rate / 1000);
1296         }
1297         seq_printf(s, "(kHz)\n");
1298         return 0;
1299 }
1300
1301 static int possible_rates_open(struct inode *inode, struct file *file)
1302 {
1303         return single_open(file, possible_rates_show, inode->i_private);
1304 }
1305
1306 static const struct file_operations possible_rates_fops = {
1307         .open           = possible_rates_open,
1308         .read           = seq_read,
1309         .llseek         = seq_lseek,
1310         .release        = single_release,
1311 };
1312
1313 static int clk_debugfs_register_one(struct clk *c)
1314 {
1315         struct dentry *d;
1316
1317         d = debugfs_create_dir(c->name, clk_debugfs_root);
1318         if (!d)
1319                 return -ENOMEM;
1320         c->dent = d;
1321
1322         d = debugfs_create_u8("refcnt", S_IRUGO, c->dent, (u8 *)&c->refcnt);
1323         if (!d)
1324                 goto err_out;
1325
1326         d = debugfs_create_x32("flags", S_IRUGO, c->dent, (u32 *)&c->flags);
1327         if (!d)
1328                 goto err_out;
1329
1330         d = debugfs_create_u32("max", S_IRUGO, c->dent, (u32 *)&c->max_rate);
1331         if (!d)
1332                 goto err_out;
1333
1334         d = debugfs_create_u32("min", S_IRUGO, c->dent, (u32 *)&c->min_rate);
1335         if (!d)
1336                 goto err_out;
1337
1338         d = debugfs_create_file(
1339                 "parent", parent_rate_mode, c->dent, c, &parent_fops);
1340         if (!d)
1341                 goto err_out;
1342
1343         d = debugfs_create_file(
1344                 "rate", parent_rate_mode, c->dent, c, &rate_fops);
1345         if (!d)
1346                 goto err_out;
1347
1348         d = debugfs_create_file(
1349                 "state", parent_rate_mode, c->dent, c, &state_fops);
1350         if (!d)
1351                 goto err_out;
1352
1353         d = debugfs_create_file(
1354                 "time_on", S_IRUGO, c->dent, c, &time_on_fops);
1355         if (!d)
1356                 goto err_out;
1357
1358         if (c->inputs) {
1359                 d = debugfs_create_file("possible_parents", S_IRUGO, c->dent,
1360                         c, &possible_parents_fops);
1361                 if (!d)
1362                         goto err_out;
1363         }
1364
1365         if (c->ops && c->ops->round_rate && c->ops->shared_bus_update) {
1366                 d = debugfs_create_file("possible_rates", S_IRUGO, c->dent,
1367                         c, &possible_rates_fops);
1368                 if (!d)
1369                         goto err_out;
1370         }
1371
1372         return 0;
1373
1374 err_out:
1375         debugfs_remove_recursive(c->dent);
1376         return -ENOMEM;
1377 }
1378
1379 static int clk_debugfs_register(struct clk *c)
1380 {
1381         int err;
1382         struct clk *pa = c->parent;
1383
1384         if (pa && !pa->dent) {
1385                 err = clk_debugfs_register(pa);
1386                 if (err)
1387                         return err;
1388         }
1389
1390         if (!c->dent) {
1391                 err = clk_debugfs_register_one(c);
1392                 if (err)
1393                         return err;
1394         }
1395         return 0;
1396 }
1397
1398 int __init tegra_clk_debugfs_init(void)
1399 {
1400         struct clk *c;
1401         struct dentry *d;
1402         int err = -ENOMEM;
1403
1404         d = debugfs_create_dir("clock", NULL);
1405         if (!d)
1406                 return -ENOMEM;
1407         clk_debugfs_root = d;
1408
1409         d = debugfs_create_file("clock_tree", S_IRUGO, clk_debugfs_root, NULL,
1410                 &clock_tree_fops);
1411         if (!d)
1412                 goto err_out;
1413
1414         d = debugfs_create_file("syncevents", S_IRUGO|S_IWUSR, clk_debugfs_root, NULL,
1415                 &syncevent_fops);
1416
1417         if (dvfs_debugfs_init(clk_debugfs_root))
1418                 goto err_out;
1419
1420         list_for_each_entry(c, &clocks, node) {
1421                 err = clk_debugfs_register(c);
1422                 if (err)
1423                         goto err_out;
1424         }
1425         return 0;
1426 err_out:
1427         debugfs_remove_recursive(clk_debugfs_root);
1428         return err;
1429 }
1430 #endif
1431 #else
1432
1433 void tegra_clk_add(struct clk *clk)
1434 {
1435         struct clk_tegra *c = to_clk_tegra(__clk_get_hw(clk));
1436
1437         mutex_lock(&clock_list_lock);
1438         list_add(&c->node, &clocks);
1439         mutex_unlock(&clock_list_lock);
1440 }
1441
1442 struct clk *tegra_get_clock_by_name(const char *name)
1443 {
1444         struct clk_tegra *c;
1445         struct clk *ret = NULL;
1446         mutex_lock(&clock_list_lock);
1447         list_for_each_entry(c, &clocks, node) {
1448                 if (strcmp(__clk_get_name(c->hw.clk), name) == 0) {
1449                         ret = c->hw.clk;
1450                         break;
1451                 }
1452         }
1453         mutex_unlock(&clock_list_lock);
1454         return ret;
1455 }
1456
1457 static int tegra_clk_init_one_from_table(struct tegra_clk_init_table *table)
1458 {
1459         struct clk *c;
1460         struct clk *p;
1461         struct clk *parent;
1462
1463         int ret = 0;
1464
1465         c = tegra_get_clock_by_name(table->name);
1466
1467         if (!c) {
1468                 pr_warn("Unable to initialize clock %s\n",
1469                         table->name);
1470                 return -ENODEV;
1471         }
1472
1473         parent = clk_get_parent(c);
1474
1475         if (table->parent) {
1476                 p = tegra_get_clock_by_name(table->parent);
1477                 if (!p) {
1478                         pr_warn("Unable to find parent %s of clock %s\n",
1479                                 table->parent, table->name);
1480                         return -ENODEV;
1481                 }
1482
1483                 if (parent != p) {
1484                         ret = clk_set_parent(c, p);
1485                         if (ret) {
1486                                 pr_warn("Unable to set parent %s of clock %s: %d\n",
1487                                         table->parent, table->name, ret);
1488                                 return -EINVAL;
1489                         }
1490                 }
1491         }
1492
1493         if (table->rate && table->rate != clk_get_rate(c)) {
1494                 ret = clk_set_rate(c, table->rate);
1495                 if (ret) {
1496                         pr_warn("Unable to set clock %s to rate %lu: %d\n",
1497                                 table->name, table->rate, ret);
1498                         return -EINVAL;
1499                 }
1500         }
1501
1502         if (table->enabled) {
1503                 ret = clk_prepare_enable(c);
1504                 if (ret) {
1505                         pr_warn("Unable to enable clock %s: %d\n",
1506                                 table->name, ret);
1507                         return -EINVAL;
1508                 }
1509         }
1510
1511         return 0;
1512 }
1513
1514 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
1515 {
1516         for (; table->name; table++)
1517                 tegra_clk_init_one_from_table(table);
1518 }
1519
1520 void tegra_periph_reset_deassert(struct clk *c)
1521 {
1522         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1523         BUG_ON(!clk->reset);
1524         clk->reset(__clk_get_hw(c), false);
1525 }
1526 EXPORT_SYMBOL(tegra_periph_reset_deassert);
1527
1528 void tegra_periph_reset_assert(struct clk *c)
1529 {
1530         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1531         BUG_ON(!clk->reset);
1532         clk->reset(__clk_get_hw(c), true);
1533 }
1534 EXPORT_SYMBOL(tegra_periph_reset_assert);
1535
1536 /* Several extended clock configuration bits (e.g., clock routing, clock
1537  * phase control) are included in PLL and peripheral clock source
1538  * registers. */
1539 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
1540 {
1541         int ret = 0;
1542         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1543
1544         if (!clk->clk_cfg_ex) {
1545                 ret = -ENOSYS;
1546                 goto out;
1547         }
1548         ret = clk->clk_cfg_ex(__clk_get_hw(c), p, setting);
1549
1550 out:
1551         return ret;
1552 }
1553 #endif /* !CONFIG_COMMON_CLK */