ARM: tegra: dvfs: Add interface to set fmax at vmin
[linux-3.10.git] / arch / arm / mach-tegra / clock.c
1 /*
2  *
3  * Copyright (C) 2010 Google, Inc.
4  *
5  * Author:
6  *      Colin Cross <ccross@google.com>
7  *
8  * Copyright (c) 2010-2013, NVIDIA CORPORATION.  All rights reserved.
9  *
10  * This software is licensed under the terms of the GNU General Public
11  * License version 2, as published by the Free Software Foundation, and
12  * may be copied, distributed, and modified under those terms.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/clk.h>
23 #include <linux/clkdev.h>
24 #include <linux/debugfs.h>
25 #include <linux/delay.h>
26 #include <linux/init.h>
27 #include <linux/list.h>
28 #include <linux/lockdep.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 <linux/tegra-soc.h>
38 #include <trace/events/power.h>
39 #include <linux/tegra-timer.h>
40
41 #include <mach/edp.h>
42
43 #include "board.h"
44 #include "clock.h"
45 #include "dvfs.h"
46 #include "iomap.h"
47 #include "tegra_emc.h"
48 #include "cpu-tegra.h"
49
50 /* Global data of Tegra CPU CAR ops */
51 struct tegra_cpu_car_ops *tegra_cpu_car_ops;
52
53 #define DISABLE_BOOT_CLOCKS 1
54
55 /*
56  * Locking:
57  *
58  * Each struct clk has a lock.  Depending on the cansleep flag, that lock
59  * may be a spinlock or a mutex.  For most clocks, the spinlock is sufficient,
60  * and using the spinlock allows the clock to be manipulated from an interrupt
61  * or while holding a spinlock.  Some clocks may need to adjust a regulator
62  * in order to maintain the required voltage for a new frequency.  Those
63  * clocks set the cansleep flag, and take a mutex so that the regulator api
64  * can be used while holding the lock.
65  *
66  * To avoid AB-BA locking problems, locks must always be traversed from child
67  * clock to parent clock.  For example, when enabling a clock, the clock's lock
68  * is taken, and then clk_enable is called on the parent, which take's the
69  * parent clock's lock.  There are two exceptions to this ordering:
70  *  1. When setting a clock as cansleep, in which case the entire list of clocks
71  *     is traversed to set the children as cansleep as well.  This must occur
72  *     during init, before any calls to clk_get, so no other clock locks can
73  *     get taken.
74  *  2. When dumping the clock tree through debugfs.  In this case, clk_lock_all
75  *     is called, which attemps to iterate through the entire list of clocks
76  *     and take every clock lock.  If any call to clk_trylock fails, a locked
77  *     clocks are unlocked, and the process is retried.  When all the locks
78  *     are held, the only clock operation that can be called is
79  *     clk_get_rate_all_locked.
80  *
81  * Within a single clock, no clock operation can call another clock operation
82  * on itself, except for clk_xxx_locked.  Any clock operation can call any other
83  * clock operation on any of it's possible parents.
84  *
85  * clk_set_cansleep is used to mark a clock as sleeping.  It is called during
86  * dvfs (Dynamic Voltage and Frequency Scaling) init on any clock that has a
87  * dvfs requirement, and propagated to all possible children of sleeping clock.
88  *
89  * An additional mutex, clock_list_lock, is used to protect the list of all
90  * clocks.
91  *
92  * The clock operations must lock internally to protect against
93  * read-modify-write on registers that are shared by multiple clocks
94  */
95
96 /* FIXME: remove and never ignore overclock */
97 #define IGNORE_PARENT_OVERCLOCK 0
98
99 static DEFINE_MUTEX(clock_list_lock);
100 static LIST_HEAD(clocks);
101 static unsigned long osc_freq;
102
103 #ifndef CONFIG_COMMON_CLK
104 struct clk *tegra_get_clock_by_name(const char *name)
105 {
106         struct clk *c;
107         struct clk *ret = NULL;
108         mutex_lock(&clock_list_lock);
109         list_for_each_entry(c, &clocks, node) {
110                 if (strcmp(c->name, name) == 0) {
111                         ret = c;
112                         break;
113                 }
114         }
115         mutex_unlock(&clock_list_lock);
116         return ret;
117 }
118 EXPORT_SYMBOL(tegra_get_clock_by_name);
119
120 static void clk_stats_update(struct clk *c)
121 {
122         u64 cur_jiffies = get_jiffies_64();
123
124         if (c->refcnt) {
125                 c->stats.time_on = c->stats.time_on +
126                         (jiffies64_to_cputime64(cur_jiffies) -
127                          (c->stats.last_update));
128         }
129
130         c->stats.last_update = cur_jiffies;
131 }
132
133 /* Must be called with clk_lock(c) held */
134 static unsigned long clk_predict_rate_from_parent(struct clk *c, struct clk *p)
135 {
136         u64 rate;
137
138         rate = clk_get_rate(p);
139
140         if (c->mul != 0 && c->div != 0) {
141                 rate *= c->mul;
142                 rate += c->div - 1; /* round up */
143                 do_div(rate, c->div);
144         }
145
146         return rate;
147 }
148
149 unsigned long clk_get_max_rate(struct clk *c)
150 {
151                 return c->max_rate;
152 }
153
154 unsigned long clk_get_min_rate(struct clk *c)
155 {
156                 return c->min_rate;
157 }
158
159 bool tegra_is_clk_initialized(struct clk *c)
160 {
161         return c->state != UNINITIALIZED;
162 }
163
164 /* Must be called with clk_lock(c) held */
165 unsigned long clk_get_rate_locked(struct clk *c)
166 {
167         unsigned long rate;
168
169         if (c->parent)
170                 rate = clk_predict_rate_from_parent(c, c->parent);
171         else
172                 rate = c->rate;
173
174         return rate;
175 }
176
177 unsigned long clk_get_rate(struct clk *c)
178 {
179         unsigned long flags;
180         unsigned long rate;
181
182         clk_lock_save(c, &flags);
183
184         rate = clk_get_rate_locked(c);
185
186         clk_unlock_restore(c, &flags);
187
188         return rate;
189 }
190 EXPORT_SYMBOL(clk_get_rate);
191
192 static void __clk_set_cansleep(struct clk *c)
193 {
194         struct clk *child;
195         int i;
196         BUG_ON(mutex_is_locked(&c->mutex));
197         BUG_ON(spin_is_locked(&c->spinlock));
198
199         /* Make sure that all possible descendants of sleeping clock are
200            marked as sleeping (to eliminate "sleeping parent - non-sleeping
201            child" relationship */
202         list_for_each_entry(child, &clocks, node) {
203                 bool possible_parent = (child->parent == c);
204
205                 if (!possible_parent && child->inputs) {
206                         for (i = 0; child->inputs[i].input; i++) {
207                                 if ((child->inputs[i].input == c) &&
208                                     tegra_clk_is_parent_allowed(child, c)) {
209                                         possible_parent = true;
210                                         break;
211                                 }
212                         }
213                 }
214
215                 if (possible_parent)
216                         __clk_set_cansleep(child);
217         }
218
219         c->cansleep = true;
220 }
221
222 /* Must be called before any clk_get calls */
223 void clk_set_cansleep(struct clk *c)
224 {
225
226         mutex_lock(&clock_list_lock);
227         __clk_set_cansleep(c);
228         mutex_unlock(&clock_list_lock);
229 }
230
231 int clk_reparent(struct clk *c, struct clk *parent)
232 {
233         c->parent = parent;
234         return 0;
235 }
236
237 void clk_init(struct clk *c)
238 {
239         clk_lock_init(c);
240
241         if (c->ops && c->ops->init)
242                 c->ops->init(c);
243
244         if (!c->ops || !c->ops->enable) {
245                 c->refcnt++;
246                 c->set = true;
247                 if (c->parent)
248                         c->state = c->parent->state;
249                 else
250                         c->state = ON;
251         }
252         c->stats.last_update = get_jiffies_64();
253
254 #ifdef CONFIG_LOCKDEP
255         lockdep_set_class_and_name(&c->mutex, &c->lockdep_class, c->name);
256         lockdep_set_class_and_name(&c->spinlock, &c->lockdep_class, c->name);
257 #endif
258
259         mutex_lock(&clock_list_lock);
260         list_add(&c->node, &clocks);
261         mutex_unlock(&clock_list_lock);
262 }
263
264 static int clk_enable_locked(struct clk *c)
265 {
266         int ret = 0;
267
268         if (clk_is_auto_dvfs(c)) {
269                 ret = tegra_dvfs_set_rate(c, clk_get_rate_locked(c));
270                 if (ret)
271                         return ret;
272         }
273
274         if (c->refcnt == 0) {
275                 if (!(c->flags & BUS_RATE_LIMIT) && c->parent) {
276                         ret = tegra_clk_prepare_enable(c->parent);
277                         if (ret)
278                                 return ret;
279                 }
280
281                 if (c->ops && c->ops->enable) {
282                         ret = c->ops->enable(c);
283                         trace_clock_enable(c->name, 1, 0);
284                         if (ret) {
285                                 if (c->parent)
286                                         tegra_clk_disable_unprepare(c->parent);
287                                 return ret;
288                         }
289                         c->state = ON;
290                         c->set = true;
291                 }
292                 clk_stats_update(c);
293         }
294         c->refcnt++;
295
296         return ret;
297 }
298
299 static void clk_disable_locked(struct clk *c)
300 {
301         if (c->refcnt == 0) {
302                 WARN(1, "Attempting to disable clock %s with refcnt 0", c->name);
303                 return;
304         }
305         if (c->refcnt == 1) {
306                 if (c->ops && c->ops->disable) {
307                         trace_clock_disable(c->name, 0, 0);
308                         c->ops->disable(c);
309                 }
310                 if (!(c->flags & BUS_RATE_LIMIT) && c->parent)
311                         tegra_clk_disable_unprepare(c->parent);
312
313                 c->state = OFF;
314                 clk_stats_update(c);
315         }
316         c->refcnt--;
317
318         if (clk_is_auto_dvfs(c) && c->refcnt == 0)
319                 tegra_dvfs_set_rate(c, 0);
320 }
321
322 #ifdef CONFIG_HAVE_CLK_PREPARE
323 /*
324  * The clk_enable/clk_disable may be called in atomic context, so they must not
325  * hold mutex. On the other hand clk_prepare/clk_unprepare can hold a mutex,
326  * as these APIs are called only in non-atomic context. Since tegra clock have
327  * "cansleep" attributte that indicates if clock requires preparation, we can
328  * split the interfaces respectively: do all work on sleeping clocks only in
329  * clk_prepare/clk_unprepare, and do all work for non-sleeping clocks only in
330  * clk_enable/clk_disable APIs. Calling "empty" APIs on either type of clocks
331  * is allowed as well, and actually expected, since clients may not know the
332  * clock attributes. However, calling clk_enable on non-prepared sleeping clock
333  * would fail.
334  */
335 int clk_prepare(struct clk *c)
336 {
337         int ret = 0;
338         unsigned long flags;
339
340         if (!clk_cansleep(c))
341                 return 0;
342
343         clk_lock_save(c, &flags);
344         ret = clk_enable_locked(c);
345         clk_unlock_restore(c, &flags);
346         return ret;
347 }
348 EXPORT_SYMBOL(clk_prepare);
349
350 int clk_enable(struct clk *c)
351 {
352         int ret = 0;
353         unsigned long flags;
354
355         if (clk_cansleep(c)) {
356                 if (WARN_ON(c->refcnt == 0))
357                         return -ENOSYS;
358                 return 0;
359         }
360
361         clk_lock_save(c, &flags);
362         ret = clk_enable_locked(c);
363         clk_unlock_restore(c, &flags);
364         return ret;
365 }
366 EXPORT_SYMBOL(clk_enable);
367
368 void clk_unprepare(struct clk *c)
369 {
370         unsigned long flags;
371
372         if (!clk_cansleep(c))
373                 return;
374
375         clk_lock_save(c, &flags);
376         clk_disable_locked(c);
377         clk_unlock_restore(c, &flags);
378 }
379 EXPORT_SYMBOL(clk_unprepare);
380
381 void clk_disable(struct clk *c)
382 {
383         unsigned long flags;
384
385         if (clk_cansleep(c))
386                 return;
387
388         clk_lock_save(c, &flags);
389         clk_disable_locked(c);
390         clk_unlock_restore(c, &flags);
391 }
392 EXPORT_SYMBOL(clk_disable);
393 #else
394 int clk_enable(struct clk *c)
395 {
396         int ret = 0;
397         unsigned long flags;
398
399         clk_lock_save(c, &flags);
400         ret = clk_enable_locked(c);
401         clk_unlock_restore(c, &flags);
402         return ret;
403 }
404 EXPORT_SYMBOL(clk_enable);
405
406 void clk_disable(struct clk *c)
407 {
408         unsigned long flags;
409
410         clk_lock_save(c, &flags);
411         clk_disable_locked(c);
412         clk_unlock_restore(c, &flags);
413 }
414 EXPORT_SYMBOL(clk_disable);
415 #endif
416
417 int clk_rate_change_notify(struct clk *c, unsigned long rate)
418 {
419         if (!c->rate_change_nh)
420                 return -ENOSYS;
421         return raw_notifier_call_chain(c->rate_change_nh, rate, NULL);
422 }
423
424 int clk_set_parent_locked(struct clk *c, struct clk *parent)
425 {
426         int ret = 0;
427         unsigned long new_rate;
428         unsigned long old_rate;
429         bool disable = false;
430
431         if (!c->ops || !c->ops->set_parent) {
432                 ret = -ENOSYS;
433                 goto out;
434         }
435
436         if (!tegra_clk_is_parent_allowed(c, parent)) {
437                 ret = -EINVAL;
438                 goto out;
439         }
440
441         new_rate = clk_predict_rate_from_parent(c, parent);
442         old_rate = clk_get_rate_locked(c);
443
444         if ((new_rate > clk_get_max_rate(c)) &&
445                 (!parent->ops || !parent->ops->shared_bus_update)) {
446
447                 pr_err("Failed to set parent %s for %s (violates clock limit"
448                        " %lu)\n", parent->name, c->name, clk_get_max_rate(c));
449 #if !IGNORE_PARENT_OVERCLOCK
450                 ret = -EINVAL;
451                 goto out;
452 #endif
453         }
454
455         /* The new clock control register setting does not take effect if
456          * clock is disabled. Later, when the clock is enabled it would run
457          * for several cycles on the old parent, which may hang h/w if the
458          * parent is already disabled. To guarantee h/w switch to the new
459          * setting enable clock while setting parent.
460          */
461         if ((c->refcnt == 0) && (c->flags & MUX)) {
462                 pr_debug("Setting parent of clock %s with refcnt 0\n", c->name);
463                 ret = clk_enable_locked(c);
464                 if (ret)
465                         goto out;
466                 disable = true;
467         }
468
469         if (clk_is_auto_dvfs(c) && c->refcnt > 0 &&
470                         (!c->parent || new_rate > old_rate)) {
471                 ret = tegra_dvfs_set_rate(c, new_rate);
472                 if (ret)
473                         goto out;
474         }
475
476         ret = c->ops->set_parent(c, parent);
477         if (ret)
478                 goto out;
479
480         trace_clock_set_parent(c->name, parent->name);
481
482         if (clk_is_auto_dvfs(c) && c->refcnt > 0 &&
483                         new_rate < old_rate)
484                 ret = tegra_dvfs_set_rate(c, new_rate);
485
486         if (new_rate != old_rate)
487                 clk_rate_change_notify(c, new_rate);
488
489 out:
490         if (disable)
491                 clk_disable_locked(c);
492         return ret;
493 }
494
495
496 int clk_set_parent(struct clk *c, struct clk *parent)
497 {
498         int ret = 0;
499         unsigned long flags;
500
501         clk_lock_save(c, &flags);
502         ret = clk_set_parent_locked(c, parent);
503         clk_unlock_restore(c, &flags);
504
505         return ret;
506 }
507 EXPORT_SYMBOL(clk_set_parent);
508
509 struct clk *clk_get_parent(struct clk *c)
510 {
511         return c->parent;
512 }
513 EXPORT_SYMBOL(clk_get_parent);
514
515 int clk_set_rate_locked(struct clk *c, unsigned long rate)
516 {
517         int ret = 0;
518         unsigned long old_rate, max_rate;
519         unsigned long new_rate;
520         bool disable = false;
521
522         if (!c->ops || !c->ops->set_rate)
523                 return -ENOSYS;
524
525         old_rate = clk_get_rate_locked(c);
526
527         max_rate = clk_get_max_rate(c);
528         if (rate > max_rate)
529                 rate = max_rate;
530
531         if (c->ops && c->ops->round_rate) {
532                 new_rate = c->ops->round_rate(c, rate);
533
534                 if (IS_ERR_VALUE(new_rate)) {
535                         ret = new_rate;
536                         return ret;
537                 }
538
539                 rate = new_rate;
540         }
541
542         /* The new clock control register setting does not take effect if
543          * clock is disabled. Later, when the clock is enabled it would run
544          * for several cycles on the old rate, which may over-clock module
545          * at given voltage. To guarantee h/w switch to the new setting
546          * enable clock while setting rate.
547          */
548         if ((c->refcnt == 0) && (c->flags & (DIV_U71 | DIV_U16)) &&
549                 clk_is_auto_dvfs(c)) {
550                 pr_debug("Setting rate of clock %s with refcnt 0\n", c->name);
551                 ret = clk_enable_locked(c);
552                 if (ret)
553                         goto out;
554                 disable = true;
555         }
556
557         if (clk_is_auto_dvfs(c) && rate > old_rate && c->refcnt > 0) {
558                 ret = tegra_dvfs_set_rate(c, rate);
559                 if (ret)
560                         goto out;
561         }
562
563         trace_clock_set_rate(c->name, rate, 0);
564         ret = c->ops->set_rate(c, rate);
565         if (ret)
566                 goto out;
567
568         if (clk_is_auto_dvfs(c) && rate < old_rate && c->refcnt > 0)
569                 ret = tegra_dvfs_set_rate(c, rate);
570
571         if (rate != old_rate)
572                 clk_rate_change_notify(c, rate);
573
574 out:
575         if (disable)
576                 clk_disable_locked(c);
577         return ret;
578 }
579
580 int clk_set_rate(struct clk *c, unsigned long rate)
581 {
582         unsigned long flags;
583         int ret;
584
585         if (!c->ops || !c->ops->set_rate)
586                 return -ENOSYS;
587
588         trace_clock_set_start(c->name, rate, raw_smp_processor_id());
589
590         clk_lock_save(c, &flags);
591
592         ret = clk_set_rate_locked(c, rate);
593
594         clk_unlock_restore(c, &flags);
595
596         trace_clock_set_done(c->name, rate, raw_smp_processor_id());
597
598         return ret;
599 }
600 EXPORT_SYMBOL(clk_set_rate);
601
602 /* Must be called with clocks lock and all indvidual clock locks held */
603 unsigned long clk_get_rate_all_locked(struct clk *c)
604 {
605         u64 rate;
606         int mul = 1;
607         int div = 1;
608         struct clk *p = c;
609
610         while (p) {
611                 c = p;
612                 if (c->mul != 0 && c->div != 0) {
613                         mul *= c->mul;
614                         div *= c->div;
615                 }
616                 p = c->parent;
617         }
618
619         rate = c->rate;
620         rate *= mul;
621         do_div(rate, div);
622
623         return rate;
624 }
625
626 long clk_round_rate_locked(struct clk *c, unsigned long rate)
627 {
628         unsigned long max_rate;
629         long ret;
630
631         if (!c->ops || !c->ops->round_rate) {
632                 ret = -ENOSYS;
633                 goto out;
634         }
635
636         max_rate = clk_get_max_rate(c);
637         if (rate > max_rate)
638                 rate = max_rate;
639
640         ret = c->ops->round_rate(c, rate);
641
642 out:
643         return ret;
644 }
645
646 long clk_round_rate(struct clk *c, unsigned long rate)
647 {
648         unsigned long flags;
649         long ret;
650
651         clk_lock_save(c, &flags);
652         ret = clk_round_rate_locked(c, rate);
653         clk_unlock_restore(c, &flags);
654         return ret;
655 }
656 EXPORT_SYMBOL(clk_round_rate);
657
658 static int tegra_clk_clip_rate_for_parent(struct clk *c, struct clk *p)
659 {
660         unsigned long flags, max_rate, old_rate, new_rate;
661
662         clk_lock_save(c, &flags);
663
664         max_rate = clk_get_max_rate(c);
665         new_rate = clk_predict_rate_from_parent(c, p);
666         old_rate = clk_get_rate_locked(c);
667
668         clk_unlock_restore(c, &flags);
669
670         if (new_rate > max_rate) {
671                 u64 rate = max_rate;
672                 rate *= old_rate;
673                 do_div(rate, new_rate);
674
675                 return clk_set_rate(c, (unsigned long)rate);
676         }
677         return 0;
678 }
679
680 #ifdef CONFIG_TEGRA_PRE_SILICON_SUPPORT
681 static int tegra_clk_platform_mask(void)
682 {
683         int mask;
684
685         mask = tegra_platform_is_silicon() ?  TEGRA_CLK_INIT_PLATFORM_SI : 0;
686         mask |= tegra_platform_is_qt() ? TEGRA_CLK_INIT_PLATFORM_QT : 0;
687         mask |= tegra_platform_is_fpga() ?  TEGRA_CLK_INIT_PLATFORM_FPGA : 0;
688         mask |= tegra_platform_is_linsim() ? TEGRA_CLK_INIT_PLATFORM_LINSIM : 0;
689         mask |= tegra_cpu_is_asim() ? TEGRA_CLK_INIT_CPU_ASIM : 0;
690
691         return mask;
692 }
693 #endif
694
695 static int tegra_clk_init_one_from_table(struct tegra_clk_init_table *table)
696 {
697         struct clk *c;
698         struct clk *p;
699
700         int ret = 0;
701
702         /* Skip if clock not enabled for this platform */
703 #ifdef CONFIG_TEGRA_PRE_SILICON_SUPPORT
704         if (table->platform != TEGRA_CLK_INIT_PLATFORM_ALL) {
705                 if ((table->platform & tegra_clk_platform_mask()) == 0)
706                         return 0;
707         }
708 #endif
709
710         c = tegra_get_clock_by_name(table->name);
711
712         if (!c) {
713                 pr_warning("Unable to initialize clock %s\n",
714                         table->name);
715                 return -ENODEV;
716         }
717
718         if (table->rate && c->parent && c->parent->ops &&
719             c->parent->ops->shared_bus_update) {
720                         c->u.shared_bus_user.rate = table->rate;
721                         if (!table->enabled)
722                                 return 0;
723         }
724
725         if (table->enabled) {
726                 ret = tegra_clk_prepare_enable(c);
727                 if (ret) {
728                         pr_warning("Unable to enable clock %s: %d\n",
729                                 table->name, ret);
730                         return -EINVAL;
731                 }
732         }
733
734         if (table->parent) {
735                 p = tegra_get_clock_by_name(table->parent);
736                 if (!p) {
737                         pr_warning("Unable to find parent %s of clock %s\n",
738                                 table->parent, table->name);
739                         return -ENODEV;
740                 }
741
742                 if (c->parent != p) {
743                         ret = tegra_clk_clip_rate_for_parent(c, p);
744                         if (ret) {
745                                 pr_warning("Unable to clip rate for parent %s"
746                                            " of clock %s: %d\n",
747                                            table->parent, table->name, ret);
748                                 return -EINVAL;
749                         }
750
751                         ret = clk_set_parent(c, p);
752                         if (ret) {
753                                 pr_warning("Unable to set parent %s of clock %s: %d\n",
754                                         table->parent, table->name, ret);
755                                 return -EINVAL;
756                         }
757                 }
758         }
759
760         if (table->rate && table->rate != clk_get_rate(c)) {
761                 ret = clk_set_rate(c, table->rate);
762                 if (ret) {
763                         pr_warning("Unable to set clock %s to rate %lu: %d\n",
764                                 table->name, table->rate, ret);
765                         return -EINVAL;
766                 }
767         }
768
769         return 0;
770 }
771
772 /*
773  * If table refer pll directly it can be scaled only if all its children are OFF
774  */
775 static bool tegra_can_scale_pll_direct(struct clk *pll)
776 {
777         bool can_scale = true;
778         struct clk *c;
779
780         mutex_lock(&clock_list_lock);
781
782         list_for_each_entry(c, &clocks, node) {
783                 if ((clk_get_parent(c) == pll) && (c->state == ON)) {
784                         WARN(1, "tegra: failed initialize %s: in use by %s\n",
785                              pll->name, c->name);
786                         can_scale = false;
787                         break;
788                 }
789         }
790         mutex_unlock(&clock_list_lock);
791         return can_scale;
792 }
793
794 /*
795  * If table entry refer pll as cbus parent it can be scaled as long as all its
796  * children are cbus users (that will be switched to cbus backup during scaling)
797  */
798 static bool tegra_can_scale_pll_cbus(struct clk *pll)
799 {
800         bool can_scale = true;
801         struct clk *c;
802
803         mutex_lock(&clock_list_lock);
804
805         list_for_each_entry(c, &clocks, node) {
806                 if ((clk_get_parent(c) == pll) &&
807                     !(c->flags & PERIPH_ON_CBUS)) {
808                         WARN(1, "tegra: failed initialize %s: in use by %s\n",
809                              pll->name, c->name);
810                         can_scale = false;
811                         break;
812                 }
813         }
814         mutex_unlock(&clock_list_lock);
815         return can_scale;
816 }
817
818 static int tegra_clk_init_cbus_pll_one(struct tegra_clk_init_table *table)
819 {
820         bool can_scale = true;
821         struct clk *pll;
822         struct clk *c = tegra_get_clock_by_name(table->name);
823         if (!c)
824                 return tegra_clk_init_one_from_table(table);
825
826         if (c->flags & PERIPH_ON_CBUS) {
827                 /* table entry refer pllc/c2/c3 indirectly as cbus parent */
828                 pll = clk_get_parent(c);
829                 can_scale = tegra_can_scale_pll_cbus(pll);
830         } else if (c->state == ON) {
831                 /* table entry refer pllc/c2/c3 directly, and it is ON */
832                 pll = c;
833                 can_scale = tegra_can_scale_pll_direct(pll);
834         }
835
836         if (can_scale)
837                 return tegra_clk_init_one_from_table(table);
838         return -EBUSY;
839 }
840
841 void tegra_clk_init_cbus_plls_from_table(struct tegra_clk_init_table *table)
842 {
843         for (; table->name; table++)
844                 tegra_clk_init_cbus_pll_one(table);
845 }
846
847 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
848 {
849         for (; table->name; table++)
850                 tegra_clk_init_one_from_table(table);
851 }
852 EXPORT_SYMBOL(tegra_clk_init_from_table);
853
854 void tegra_periph_reset_deassert(struct clk *c)
855 {
856         BUG_ON(!c->ops->reset);
857         c->ops->reset(c, false);
858 }
859 EXPORT_SYMBOL(tegra_periph_reset_deassert);
860
861 void tegra_periph_reset_assert(struct clk *c)
862 {
863         BUG_ON(!c->ops->reset);
864         c->ops->reset(c, true);
865 }
866 EXPORT_SYMBOL(tegra_periph_reset_assert);
867
868 int tegra_is_clk_enabled(struct clk *c)
869 {
870         return c->refcnt;
871 }
872 EXPORT_SYMBOL(tegra_is_clk_enabled);
873
874 int tegra_clk_shared_bus_update(struct clk *c)
875 {
876         int ret = 0;
877         unsigned long flags;
878
879         clk_lock_save(c, &flags);
880
881         if (c->ops && c->ops->shared_bus_update)
882                 ret = c->ops->shared_bus_update(c);
883
884         clk_unlock_restore(c, &flags);
885         return ret;
886 }
887
888 /* dvfs initialization may lower default maximum rate */
889 void tegra_init_max_rate(struct clk *c, unsigned long max_rate)
890 {
891         struct clk *shared_bus_user;
892
893         if (c->max_rate <= max_rate)
894                 return;
895
896         /* skip message if shared bus user */
897         if (!c->parent || !c->parent->ops || !c->parent->ops->shared_bus_update)
898                 pr_info("Lowering %s maximum rate from %lu to %lu\n",
899                         c->name, c->max_rate, max_rate);
900
901         c->max_rate = max_rate;
902         list_for_each_entry(shared_bus_user,
903                             &c->shared_bus_list, u.shared_bus_user.node) {
904                 if (shared_bus_user->u.shared_bus_user.rate > max_rate)
905                         shared_bus_user->u.shared_bus_user.rate = max_rate;
906                 tegra_init_max_rate(shared_bus_user, max_rate);
907         }
908 }
909
910 /* Use boot rate as emc monitor output until actual monitoring starts */
911 void __init tegra_clk_preset_emc_monitor(unsigned long rate)
912 {
913         struct clk *c = tegra_get_clock_by_name("mon.emc");
914
915         if (c) {
916                 c->u.shared_bus_user.rate = rate;
917                 clk_enable(c);
918         }
919 }
920
921 /*
922  * Set osc (safe) rate. Called only for peripherals left after boot under reset
923  * (peripherals that are taken out of reset by boot-loader must be at safe rate
924  * already - that will be checked by tegra_clk_verify_rates()).
925  */
926 void tegra_periph_clk_safe_rate_init(struct clk *c)
927 {
928         int ret;
929         unsigned long rate = tegra_clk_measure_input_freq();
930
931         if (c->boot_rate || (clk_get_rate(c->parent) <= rate))
932                 return;
933
934         if (c->ops && c->ops->set_rate && (c->flags & PERIPH_DIV)) {
935                 ret = c->ops->set_rate(c, rate);
936                 if (ret)
937                         pr_err("%s: failed to init %s rate %lu\n",
938                                __func__, c->name, rate);
939         }
940 }
941
942 static void __init tegra_clk_verify_rates(void)
943 {
944         struct clk *c;
945         unsigned long rate;
946
947         mutex_lock(&clock_list_lock);
948
949         list_for_each_entry(c, &clocks, node) {
950                 rate = clk_get_rate(c);
951                 if (rate > clk_get_max_rate(c))
952                         WARN(1, "tegra: %s boot rate %lu exceeds max rate %lu\n",
953                              c->name, rate, clk_get_max_rate(c));
954                 c->boot_rate = rate;
955         }
956         mutex_unlock(&clock_list_lock);
957 }
958
959 void __init tegra_common_init_clock(void)
960 {
961 #if defined(CONFIG_HAVE_ARM_TWD) || defined(CONFIG_ARM_ARCH_TIMER)
962         tegra_cpu_timer_init();
963 #endif
964         tegra_clk_verify_rates();
965 }
966
967 void __init tegra_clk_verify_parents(void)
968 {
969         struct clk *c;
970         struct clk *p;
971
972         mutex_lock(&clock_list_lock);
973
974         list_for_each_entry(c, &clocks, node) {
975                 p = clk_get_parent(c);
976                 if (!tegra_clk_is_parent_allowed(c, p))
977                         WARN(1, "tegra: parent %s is not allowed for %s\n",
978                              p->name, c->name);
979         }
980         mutex_unlock(&clock_list_lock);
981 }
982
983 static bool tegra_keep_boot_clocks = false;
984 static int __init tegra_keep_boot_clocks_setup(char *__unused)
985 {
986         tegra_keep_boot_clocks = true;
987         return 1;
988 }
989 __setup("tegra_keep_boot_clocks", tegra_keep_boot_clocks_setup);
990
991 /*
992  * Iterate through all clocks, disabling any for which the refcount is 0
993  * but the clock init detected the bootloader left the clock on.
994  */
995 static int __init tegra_init_disable_boot_clocks(void)
996 {
997 #if DISABLE_BOOT_CLOCKS
998         unsigned long flags;
999         struct clk *c;
1000
1001         mutex_lock(&clock_list_lock);
1002
1003         list_for_each_entry(c, &clocks, node) {
1004                 clk_lock_save(c, &flags);
1005                 if (c->refcnt == 0 && c->state == ON &&
1006                                 c->ops && c->ops->disable) {
1007                         pr_warn_once("%s clocks left on by bootloader:\n",
1008                                 tegra_keep_boot_clocks ?
1009                                         "Prevented disabling" :
1010                                         "Disabling");
1011
1012                         pr_warn("   %s\n", c->name);
1013
1014                         if (!tegra_keep_boot_clocks) {
1015                                 c->ops->disable(c);
1016                                 c->state = OFF;
1017                         }
1018                 }
1019                 clk_unlock_restore(c, &flags);
1020         }
1021
1022         mutex_unlock(&clock_list_lock);
1023 #endif
1024         return 0;
1025 }
1026
1027 /* Get ready DVFS rails and DFLL clock source (if available) for CPU */
1028 static int __init tegra_dvfs_rail_start_scaling(void)
1029 {
1030         int ret;
1031         unsigned long flags, rate;
1032         struct clk *c = tegra_get_clock_by_name("cpu");
1033         struct clk *dfll_cpu = tegra_get_clock_by_name("dfll_cpu");
1034         bool init_dfll_first = tegra_dvfs_is_dfll_bypass();
1035
1036         BUG_ON(!c);
1037         clk_lock_save(c, &flags);
1038
1039         /*
1040          * Initialize dfll first if it provides bypass to regulator for legacy
1041          * dvfs; otherwise legacy dvfs controls cpu voltage independently, and
1042          * initialized before dfll.
1043          */
1044         if (init_dfll_first) {
1045                 if (dfll_cpu && dfll_cpu->ops && dfll_cpu->ops->init)
1046                         dfll_cpu->ops->init(dfll_cpu);
1047         }
1048
1049         ret = tegra_dvfs_rail_connect_regulators();
1050         if (!ret && !init_dfll_first) {
1051                 if (dfll_cpu && dfll_cpu->ops && dfll_cpu->ops->init)
1052                         dfll_cpu->ops->init(dfll_cpu);
1053         }
1054
1055         /*
1056          * Bootloader may not match kernel restrictions on CPU clock sources.
1057          * Make sure CPU clock is sourced from either main or backup parent.
1058          */
1059         rate = clk_get_rate_locked(c);
1060         if (clk_set_rate_locked(c, rate))
1061                 pr_err("%s: Failed to sync CPU at rate %lu\n", __func__, rate);
1062         else
1063                 pr_info("CPU rate: %lu MHz\n", clk_get_rate_locked(c)/1000000);
1064
1065         clk_unlock_restore(c, &flags);
1066         return ret;
1067 }
1068
1069 static int __init tegra_clk_late_init(void)
1070 {
1071         tegra_init_disable_boot_clocks();       /* must before dvfs start */
1072         if (!tegra_dvfs_rail_start_scaling())           /* CPU lock protected */
1073                 tegra_dvfs_rail_register_notifiers();   /* not under CPU lock */
1074         tegra_update_cpu_edp_limits();
1075         return 0;
1076 }
1077 late_initcall(tegra_clk_late_init);
1078
1079
1080 /* Several extended clock configuration bits (e.g., clock routing, clock
1081  * phase control) are included in PLL and peripheral clock source
1082  * registers. */
1083 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
1084 {
1085         int ret = 0;
1086         unsigned long flags;
1087
1088         clk_lock_save(c, &flags);
1089
1090         if (!c->ops || !c->ops->clk_cfg_ex) {
1091                 ret = -ENOSYS;
1092                 goto out;
1093         }
1094         ret = c->ops->clk_cfg_ex(c, p, setting);
1095
1096 out:
1097         clk_unlock_restore(c, &flags);
1098         return ret;
1099 }
1100 EXPORT_SYMBOL(tegra_clk_cfg_ex);
1101
1102 int tegra_register_clk_rate_notifier(struct clk *c, struct notifier_block *nb)
1103 {
1104         int ret;
1105         unsigned long flags;
1106
1107         if (!c->rate_change_nh)
1108                 return -ENOSYS;
1109
1110         clk_lock_save(c, &flags);
1111         ret = raw_notifier_chain_register(c->rate_change_nh, nb);
1112         clk_unlock_restore(c, &flags);
1113         return ret;
1114 }
1115
1116 void tegra_unregister_clk_rate_notifier(
1117         struct clk *c, struct notifier_block *nb)
1118 {
1119         unsigned long flags;
1120
1121         if (!c->rate_change_nh)
1122                 return;
1123
1124         clk_lock_save(c, &flags);
1125         raw_notifier_chain_unregister(c->rate_change_nh, nb);
1126         clk_unlock_restore(c, &flags);
1127 }
1128
1129 int tegra_clk_register_export_ops(struct clk *c,
1130                                   struct tegra_clk_export_ops *ops)
1131 {
1132         unsigned long flags;
1133
1134         clk_lock_save(c, &flags);
1135         c->u.export_clk.ops = ops;
1136         if (c->ops && c->ops->init)
1137                 c->ops->init(c);
1138         clk_unlock_restore(c, &flags);
1139
1140         return 0;
1141 }
1142
1143 #define OSC_FREQ_DET                    0x58
1144 #define OSC_FREQ_DET_TRIG               BIT(31)
1145
1146 #define OSC_FREQ_DET_STATUS             0x5C
1147 #define OSC_FREQ_DET_BUSY               BIT(31)
1148 #define OSC_FREQ_DET_CNT_MASK           0xFFFF
1149
1150 unsigned long tegra_clk_measure_input_freq(void)
1151 {
1152         u32 clock_autodetect;
1153         void __iomem *clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
1154
1155         if (osc_freq)
1156                 return osc_freq;
1157
1158         writel(OSC_FREQ_DET_TRIG | 1,
1159                 (void *)((uintptr_t)clk_base + OSC_FREQ_DET));
1160         do {} while (readl(
1161                 (void *)((uintptr_t)clk_base + OSC_FREQ_DET_STATUS))
1162                 & OSC_FREQ_DET_BUSY);
1163
1164         clock_autodetect = readl(
1165                 (void *)((uintptr_t)clk_base + OSC_FREQ_DET_STATUS));
1166         if (clock_autodetect >= 732 - 3 && clock_autodetect <= 732 + 3) {
1167                 osc_freq = 12000000;
1168         } else if (clock_autodetect >= 794 - 3 && clock_autodetect <= 794 + 3) {
1169                 osc_freq = 13000000;
1170         } else if (clock_autodetect >= 1172 - 3 && clock_autodetect <= 1172 + 3) {
1171                 osc_freq = 19200000;
1172         } else if (clock_autodetect >= 1587 - 3 && clock_autodetect <= 1587 + 3) {
1173                 osc_freq = 26000000;
1174 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
1175         } else if (clock_autodetect >= 1025 - 3 && clock_autodetect <= 1025 + 3) {
1176                 osc_freq = 16800000;
1177         } else if (clock_autodetect >= 2344 - 3 && clock_autodetect <= 2344 + 3) {
1178                 osc_freq = 38400000;
1179         } else if (clock_autodetect >= 2928 - 3 && clock_autodetect <= 2928 + 3) {
1180                 osc_freq = 48000000;
1181         } else if (tegra_platform_is_qt()) {
1182                 if (clock_autodetect >= 2 && clock_autodetect <= 9)
1183                         osc_freq = 115200;
1184                 else if (clock_autodetect >= 13 && clock_autodetect <= 15)
1185                         osc_freq = 230400;
1186 #endif
1187         } else {
1188                 pr_err("%s: Unexpected clock autodetect value %d", __func__, clock_autodetect);
1189         }
1190
1191         BUG_ON(osc_freq == 0);
1192
1193         return osc_freq;
1194 }
1195
1196 #ifdef CONFIG_DEBUG_FS
1197
1198 /*
1199  * Attempt to lock all the clocks that are marked cansleep
1200  * Must be called with irqs enabled
1201  */
1202 static int __clk_lock_all_mutexes(void)
1203 {
1204         struct clk *c;
1205
1206         might_sleep();
1207
1208         list_for_each_entry(c, &clocks, node)
1209                 if (clk_cansleep(c))
1210                         if (!mutex_trylock(&c->mutex))
1211                                 goto unlock_mutexes;
1212
1213         return 0;
1214
1215 unlock_mutexes:
1216         list_for_each_entry_continue_reverse(c, &clocks, node)
1217                 if (clk_cansleep(c))
1218                         mutex_unlock(&c->mutex);
1219
1220         return -EAGAIN;
1221 }
1222
1223 /*
1224  * Attempt to lock all the clocks that are not marked cansleep
1225  * Must be called with irqs disabled
1226  */
1227 static int __clk_lock_all_spinlocks(void)
1228 {
1229         struct clk *c;
1230
1231         list_for_each_entry(c, &clocks, node)
1232                 if (!clk_cansleep(c))
1233                         if (!spin_trylock(&c->spinlock))
1234                                 goto unlock_spinlocks;
1235
1236         return 0;
1237
1238 unlock_spinlocks:
1239         list_for_each_entry_continue_reverse(c, &clocks, node)
1240                 if (!clk_cansleep(c))
1241                         spin_unlock(&c->spinlock);
1242
1243         return -EAGAIN;
1244 }
1245
1246 static void __clk_unlock_all_mutexes(void)
1247 {
1248         struct clk *c;
1249
1250         list_for_each_entry_reverse(c, &clocks, node)
1251                 if (clk_cansleep(c))
1252                         mutex_unlock(&c->mutex);
1253 }
1254
1255 static void __clk_unlock_all_spinlocks(void)
1256 {
1257         struct clk *c;
1258
1259         list_for_each_entry_reverse(c, &clocks, node)
1260                 if (!clk_cansleep(c))
1261                         spin_unlock(&c->spinlock);
1262 }
1263
1264 /*
1265  * This function retries until it can take all locks, and may take
1266  * an arbitrarily long time to complete.
1267  * Must be called with irqs enabled, returns with irqs disabled
1268  * Must be called with clock_list_lock held
1269  */
1270 static void clk_lock_all(void)
1271 {
1272         int ret;
1273 retry:
1274         ret = __clk_lock_all_mutexes();
1275         if (ret)
1276                 goto failed_mutexes;
1277
1278         local_irq_disable();
1279
1280         ret = __clk_lock_all_spinlocks();
1281         if (ret)
1282                 goto failed_spinlocks;
1283
1284         /* All locks taken successfully, return */
1285         return;
1286
1287 failed_spinlocks:
1288         local_irq_enable();
1289         __clk_unlock_all_mutexes();
1290 failed_mutexes:
1291         msleep(1);
1292         goto retry;
1293 }
1294
1295 /*
1296  * Unlocks all clocks after a clk_lock_all
1297  * Must be called with irqs disabled, returns with irqs enabled
1298  * Must be called with clock_list_lock held
1299  */
1300 static void clk_unlock_all(void)
1301 {
1302         __clk_unlock_all_spinlocks();
1303
1304         local_irq_enable();
1305
1306         __clk_unlock_all_mutexes();
1307 }
1308
1309 static struct dentry *clk_debugfs_root;
1310
1311 static void dvfs_show_one(struct seq_file *s, struct dvfs *d, int level)
1312 {
1313         seq_printf(s, "%*s  %-*s%21s%d mV\n",
1314                         level * 3 + 1, "",
1315                         35 - level * 3, d->dvfs_rail->reg_id,
1316                         "",
1317                         d->cur_millivolts);
1318 }
1319
1320 static void clock_tree_show_one(struct seq_file *s, struct clk *c, int level)
1321 {
1322         struct clk *child;
1323         const char *state = "uninit";
1324         char div[8] = {0};
1325         unsigned long rate = clk_get_rate_all_locked(c);
1326         unsigned long max_rate = clk_get_max_rate(c);;
1327
1328         if (c->state == ON)
1329                 state = "on";
1330         else if (c->state == OFF)
1331                 state = "off";
1332
1333         if (c->mul != 0 && c->div != 0) {
1334                 if (c->mul > c->div) {
1335                         int mul = c->mul / c->div;
1336                         int mul2 = (c->mul * 10 / c->div) % 10;
1337                         int mul3 = (c->mul * 10) % c->div;
1338                         if (mul2 == 0 && mul3 == 0)
1339                                 snprintf(div, sizeof(div), "x%d", mul);
1340                         else if (mul3 == 0)
1341                                 snprintf(div, sizeof(div), "x%d.%d", mul, mul2);
1342                         else
1343                                 snprintf(div, sizeof(div), "x%d.%d..", mul, mul2);
1344                 } else {
1345                         snprintf(div, sizeof(div), "%d%s", c->div / c->mul,
1346                                 (c->div % c->mul) ? ".5" : "");
1347                 }
1348         }
1349
1350         seq_printf(s, "%*s%c%c%-*s%c %-6s %-3d %-8s %-10lu",
1351                 level * 3 + 1, "",
1352                 rate > max_rate ? '!' : ' ',
1353                 !c->set ? '*' : ' ',
1354                 35 - level * 3, c->name,
1355                 c->cansleep ? '$' : ' ',
1356                 state, c->refcnt, div, rate);
1357         if (c->parent && !list_empty(&c->parent->shared_bus_list)) {
1358                 enum shared_bus_users_mode mode = c->u.shared_bus_user.mode;
1359                 unsigned long request = c->u.shared_bus_user.rate;
1360                 seq_printf(s, " (%lu", request);
1361
1362                 switch (mode) {
1363                 case SHARED_BW:
1364                         seq_printf(s, " / %lu+)",
1365                                    request / tegra_emc_bw_efficiency * 100);
1366                         break;
1367                 case SHARED_ISO_BW:
1368                         seq_printf(s, " / %lu / %lu+)",
1369                                    request / tegra_emc_bw_efficiency * 100,
1370                                    request / tegra_emc_iso_share * 100);
1371                         break;
1372                 case SHARED_CEILING_BUT_ISO:
1373                 case SHARED_CEILING:
1374                         seq_printf(s, "%s)", "^");
1375                         break;
1376                 default:
1377                         seq_printf(s, ")");
1378                 }
1379         }
1380         seq_printf(s, "\n");
1381
1382         if (c->dvfs)
1383                 dvfs_show_one(s, c->dvfs, level + 1);
1384
1385         list_for_each_entry(child, &clocks, node) {
1386                 if (child->parent != c)
1387                         continue;
1388
1389                 clock_tree_show_one(s, child, level + 1);
1390         }
1391 }
1392
1393 static int clock_tree_show(struct seq_file *s, void *data)
1394 {
1395         struct clk *c;
1396         seq_printf(s, "   clock                               state  ref div      rate       (shared req / bw_margin / iso_margin)\n");
1397         seq_printf(s, "-----------------------------------------------------------------------------------------------------------\n");
1398
1399         mutex_lock(&clock_list_lock);
1400         if (!tegra_platform_is_fpga())
1401                 clk_lock_all();
1402         list_for_each_entry(c, &clocks, node)
1403                 if (c->parent == NULL)
1404                         clock_tree_show_one(s, c, 0);
1405         if (!tegra_platform_is_fpga())
1406                 clk_unlock_all();
1407         mutex_unlock(&clock_list_lock);
1408         return 0;
1409 }
1410
1411 static int clock_tree_open(struct inode *inode, struct file *file)
1412 {
1413         return single_open(file, clock_tree_show, inode->i_private);
1414 }
1415
1416 static const struct file_operations clock_tree_fops = {
1417         .open           = clock_tree_open,
1418         .read           = seq_read,
1419         .llseek         = seq_lseek,
1420         .release        = single_release,
1421 };
1422
1423 static void syncevent_one(struct clk *c)
1424 {
1425         struct clk *child;
1426
1427         if (c->state == ON)
1428                 trace_clock_enable(c->name, 1, smp_processor_id());
1429         else
1430                 trace_clock_disable(c->name, 0, smp_processor_id());
1431
1432         trace_clock_set_rate(c->name, clk_get_rate_all_locked(c),
1433                                 smp_processor_id());
1434
1435         list_for_each_entry(child, &clocks, node) {
1436                 if (child->parent != c)
1437                         continue;
1438
1439                 syncevent_one(child);
1440         }
1441 }
1442
1443 static int syncevent_write(struct file *file, const char __user *user_buf,
1444                                 size_t count, loff_t *ppos)
1445 {
1446         struct clk *c;
1447         char buffer[40];
1448         int buf_size;
1449
1450         memset(buffer, 0, sizeof(buffer));
1451         buf_size = min(count, (sizeof(buffer)-1));
1452
1453         if (copy_from_user(buffer, user_buf, buf_size))
1454                 return -EFAULT;
1455
1456         if (!strnicmp("all", buffer, 3)) {
1457                 mutex_lock(&clock_list_lock);
1458
1459                 clk_lock_all();
1460
1461                 list_for_each_entry(c, &clocks, node) {
1462                         if (c->parent == NULL)
1463                                 syncevent_one(c);
1464                 }
1465
1466                 clk_unlock_all();
1467
1468                 mutex_unlock(&clock_list_lock);
1469         }
1470
1471         return count;
1472 }
1473
1474 static const struct file_operations syncevent_fops = {
1475         .write          = syncevent_write,
1476 };
1477
1478 static int possible_parents_show(struct seq_file *s, void *data)
1479 {
1480         struct clk *c = s->private;
1481         int i;
1482         bool first = true;
1483
1484         for (i = 0; c->inputs[i].input; i++) {
1485                 if (tegra_clk_is_parent_allowed(c, c->inputs[i].input)) {
1486                         seq_printf(s, "%s%s", first ? "" : " ",
1487                                    c->inputs[i].input->name);
1488                         first = false;
1489                 }
1490         }
1491         seq_printf(s, "\n");
1492         return 0;
1493 }
1494
1495 static int possible_parents_open(struct inode *inode, struct file *file)
1496 {
1497         return single_open(file, possible_parents_show, inode->i_private);
1498 }
1499
1500 static const struct file_operations possible_parents_fops = {
1501         .open           = possible_parents_open,
1502         .read           = seq_read,
1503         .llseek         = seq_lseek,
1504         .release        = single_release,
1505 };
1506
1507 static int parent_show(struct seq_file *s, void *data)
1508 {
1509         struct clk *c = s->private;
1510         struct clk *p = clk_get_parent(c);
1511
1512         seq_printf(s, "%s\n", p ? p->name : "clk_root");
1513         return 0;
1514 }
1515
1516 static int parent_open(struct inode *inode, struct file *file)
1517 {
1518         return single_open(file, parent_show, inode->i_private);
1519 }
1520
1521 static int rate_get(void *data, u64 *val)
1522 {
1523         struct clk *c = (struct clk *)data;
1524         *val = (u64)clk_get_rate(c);
1525         return 0;
1526 }
1527
1528 static int state_get(void *data, u64 *val)
1529 {
1530         struct clk *c = (struct clk *)data;
1531         *val = (u64)((c->state == ON) ? 1 : 0);
1532         return 0;
1533 }
1534
1535 static int max_get(void *data, u64 *val)
1536 {
1537         struct clk *c = (struct clk *)data;
1538         *val = (u64)clk_get_max_rate(c);
1539         return 0;
1540 }
1541
1542 #ifdef CONFIG_TEGRA_CLOCK_DEBUG_WRITE
1543
1544 static const mode_t parent_rate_mode =  S_IRUGO | S_IWUSR;
1545
1546 static ssize_t parent_write(struct file *file,
1547         const char __user *userbuf, size_t count, loff_t *ppos)
1548 {
1549         struct seq_file *s = file->private_data;
1550         struct clk *c = s->private;
1551         struct clk *p = NULL;
1552         char buf[32];
1553
1554         if (sizeof(buf) <= count)
1555                 return -EINVAL;
1556
1557         if (copy_from_user(buf, userbuf, count))
1558                 return -EFAULT;
1559
1560         /* terminate buffer and trim - white spaces may be appended
1561          *  at the end when invoked from shell command line */
1562         buf[count]='\0';
1563         strim(buf);
1564
1565         p = tegra_get_clock_by_name(buf);
1566         if (!p)
1567                 return -EINVAL;
1568
1569         if (clk_set_parent(c, p))
1570                 return -EINVAL;
1571
1572         return count;
1573 }
1574
1575 static const struct file_operations parent_fops = {
1576         .open           = parent_open,
1577         .read           = seq_read,
1578         .write          = parent_write,
1579         .llseek         = seq_lseek,
1580         .release        = single_release,
1581 };
1582
1583 static int rate_set(void *data, u64 val)
1584 {
1585         struct clk *c = (struct clk *)data;
1586         return clk_set_rate(c, (unsigned long)val);
1587 }
1588 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, rate_set, "%llu\n");
1589
1590 static int state_set(void *data, u64 val)
1591 {
1592         struct clk *c = (struct clk *)data;
1593
1594         if (val)
1595                 return tegra_clk_prepare_enable(c);
1596         else {
1597                 tegra_clk_disable_unprepare(c);
1598                 return 0;
1599         }
1600 }
1601 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, state_set, "%llu\n");
1602
1603 static int _max_set(struct clk *c, unsigned long val)
1604 {
1605         int i;
1606         bool found = false;
1607         c->max_rate = val;
1608
1609         if (c->dvfs && c->dvfs->max_millivolts) {
1610                 /* Walk through dvfs freqs table and set freq of ith item to
1611                  * max_rate if found its dvfs voltage equals to max dvfs voltage
1612                  * otherwise set freq of last item to max_rate
1613                  */
1614                 for (i = 0; i < c->dvfs->num_freqs; i++) {
1615                         if (c->dvfs->millivolts[i] == c->dvfs->max_millivolts) {
1616                                 c->dvfs->freqs[i] = c->max_rate;
1617                                 found = true;
1618                         }
1619                 }
1620                 if (!found)
1621                         c->dvfs->freqs[i-1] = c->max_rate;
1622         }
1623         return 0;
1624 }
1625
1626 #ifdef CONFIG_TEGRA_CLOCK_DEBUG_FUNC
1627 int tegra_clk_set_max(struct clk *c, unsigned long rate)
1628 {
1629         return _max_set(c, rate);
1630 }
1631 EXPORT_SYMBOL(tegra_clk_set_max);
1632 #endif
1633
1634 static int max_set(void *data, u64 val)
1635 {
1636         struct clk *c = (struct clk *)data;
1637         return _max_set(c, (unsigned long)val);
1638 }
1639 DEFINE_SIMPLE_ATTRIBUTE(max_fops, max_get, max_set, "%llu\n");
1640
1641 #else
1642
1643 static const mode_t parent_rate_mode =  S_IRUGO;
1644
1645 static const struct file_operations parent_fops = {
1646         .open           = parent_open,
1647         .read           = seq_read,
1648         .llseek         = seq_lseek,
1649         .release        = single_release,
1650 };
1651
1652 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, NULL, "%llu\n");
1653 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, NULL, "%llu\n");
1654 DEFINE_SIMPLE_ATTRIBUTE(max_fops, max_get, NULL, "%llu\n");
1655 #endif
1656
1657 static int time_on_get(void *data, u64 *val)
1658 {
1659         unsigned long flags;
1660         struct clk *c = (struct clk *)data;
1661
1662         clk_lock_save(c, &flags);
1663         clk_stats_update(c);
1664         *val = cputime64_to_clock_t(c->stats.time_on);
1665         clk_unlock_restore(c, &flags);
1666
1667         return 0;
1668 }
1669 DEFINE_SIMPLE_ATTRIBUTE(time_on_fops, time_on_get, NULL, "%llu\n");
1670
1671 static int possible_rates_show(struct seq_file *s, void *data)
1672 {
1673         struct clk *c = s->private;
1674         long rate = 0;
1675
1676         /* shared bus clock must round up, unless top of range reached */
1677         while (rate <= c->max_rate) {
1678                 unsigned long rounded_rate = c->ops->round_rate(c, rate);
1679                 if (IS_ERR_VALUE(rounded_rate) || (rounded_rate <= rate))
1680                         break;
1681
1682                 rate = rounded_rate + 2000;     /* 2kHz resolution */
1683                 seq_printf(s, "%ld ", rounded_rate / 1000);
1684         }
1685         seq_printf(s, "(kHz)\n");
1686         return 0;
1687 }
1688
1689 static int possible_rates_open(struct inode *inode, struct file *file)
1690 {
1691         return single_open(file, possible_rates_show, inode->i_private);
1692 }
1693
1694 static const struct file_operations possible_rates_fops = {
1695         .open           = possible_rates_open,
1696         .read           = seq_read,
1697         .llseek         = seq_lseek,
1698         .release        = single_release,
1699 };
1700
1701 static int use_alt_freq_get(void *data, u64 *val)
1702 {
1703         struct clk *c = (struct clk *)data;
1704         *val = c->dvfs->use_alt_freqs;
1705         return 0;
1706 }
1707 static int use_alt_freq_set(void *data, u64 val)
1708 {
1709         struct clk *c = (struct clk *)data;
1710         return tegra_dvfs_use_alt_freqs_on_clk(c, val);
1711 }
1712 DEFINE_SIMPLE_ATTRIBUTE(use_alt_freq_fops,
1713                         use_alt_freq_get, use_alt_freq_set, "%llu\n");
1714
1715 static ssize_t fmax_at_vmin_write(struct file *file,
1716         const char __user *userbuf, size_t count, loff_t *ppos)
1717 {
1718         struct clk *c = file->f_path.dentry->d_inode->i_private;
1719         unsigned long f_max;
1720         int v_min;
1721         char buf[32];
1722
1723         if (sizeof(buf) <= count)
1724                 return -EINVAL;
1725
1726         if (copy_from_user(buf, userbuf, count))
1727                 return -EFAULT;
1728
1729         /* terminate buffer and trim - white spaces may be appended
1730          *  at the end when invoked from shell command line */
1731         buf[count] = '\0';
1732         strim(buf);
1733
1734         if (sscanf(buf, "%lu_at_%d", &f_max, &v_min) != 2)
1735                 return -EINVAL;
1736
1737         tegra_dvfs_set_fmax_at_vmin(c, f_max, v_min);
1738
1739         return count;
1740 }
1741
1742 static const struct file_operations fmax_at_vmin_fops = {
1743         .write          = fmax_at_vmin_write,
1744 };
1745
1746 static int clk_debugfs_register_one(struct clk *c)
1747 {
1748         struct dentry *d;
1749
1750         d = debugfs_create_dir(c->name, clk_debugfs_root);
1751         if (!d)
1752                 return -ENOMEM;
1753         c->dent = d;
1754
1755         d = debugfs_create_u8("refcnt", S_IRUGO, c->dent, (u8 *)&c->refcnt);
1756         if (!d)
1757                 goto err_out;
1758
1759         d = debugfs_create_x32("flags", S_IRUGO, c->dent, (u32 *)&c->flags);
1760         if (!d)
1761                 goto err_out;
1762
1763         d = debugfs_create_x32("shared_bus_flags", S_IRUGO, c->dent,
1764                                (u32 *)&c->shared_bus_flags);
1765         if (!d)
1766                 goto err_out;
1767
1768         d = debugfs_create_file(
1769                 "max", parent_rate_mode, c->dent, c, &max_fops);
1770         if (!d)
1771                 goto err_out;
1772
1773         d = debugfs_create_u32("min", S_IRUGO, c->dent, (u32 *)&c->min_rate);
1774         if (!d)
1775                 goto err_out;
1776
1777         d = debugfs_create_file(
1778                 "parent", parent_rate_mode, c->dent, c, &parent_fops);
1779         if (!d)
1780                 goto err_out;
1781
1782         d = debugfs_create_file(
1783                 "rate", parent_rate_mode, c->dent, c, &rate_fops);
1784         if (!d)
1785                 goto err_out;
1786
1787         d = debugfs_create_file(
1788                 "state", parent_rate_mode, c->dent, c, &state_fops);
1789         if (!d)
1790                 goto err_out;
1791
1792         d = debugfs_create_file(
1793                 "time_on", S_IRUGO, c->dent, c, &time_on_fops);
1794         if (!d)
1795                 goto err_out;
1796
1797         if (c->inputs) {
1798                 d = debugfs_create_file("possible_parents", S_IRUGO, c->dent,
1799                         c, &possible_parents_fops);
1800                 if (!d)
1801                         goto err_out;
1802         }
1803
1804         /* show possible rates only of the top-most shared buses */
1805         if ((c->ops && c->ops->round_rate && c->ops->shared_bus_update) &&
1806             !(c->parent && c->parent->ops && c->parent->ops->round_rate &&
1807                c->parent->ops->shared_bus_update)) {
1808                 d = debugfs_create_file("possible_rates", S_IRUGO, c->dent,
1809                         c, &possible_rates_fops);
1810                 if (!d)
1811                         goto err_out;
1812         }
1813
1814         if (c->dvfs) {
1815                 d = debugfs_create_file("use_alt_freq", S_IRUGO | S_IWUSR,
1816                         c->dent, c, &use_alt_freq_fops);
1817                 if (!d)
1818                         goto err_out;
1819         }
1820
1821         if (c->dvfs && c->dvfs->can_override) {
1822                 d = debugfs_create_file("fmax_at_vmin", S_IWUSR, c->dent,
1823                         c, &fmax_at_vmin_fops);
1824                 if (!d)
1825                         goto err_out;
1826         }
1827
1828         return 0;
1829
1830 err_out:
1831         debugfs_remove_recursive(c->dent);
1832         return -ENOMEM;
1833 }
1834
1835 static int clk_debugfs_register(struct clk *c)
1836 {
1837         int err;
1838         struct clk *pa = c->parent;
1839
1840         if (pa && !pa->dent) {
1841                 err = clk_debugfs_register(pa);
1842                 if (err)
1843                         return err;
1844         }
1845
1846         if (!c->dent) {
1847                 err = clk_debugfs_register_one(c);
1848                 if (err)
1849                         return err;
1850         }
1851         return 0;
1852 }
1853
1854 int __init tegra_clk_debugfs_init(void)
1855 {
1856         struct clk *c;
1857         struct dentry *d;
1858         int err = -ENOMEM;
1859
1860         d = debugfs_create_dir("clock", NULL);
1861         if (!d)
1862                 return -ENOMEM;
1863         clk_debugfs_root = d;
1864
1865         d = debugfs_create_file("clock_tree", S_IRUGO, clk_debugfs_root, NULL,
1866                 &clock_tree_fops);
1867         if (!d)
1868                 goto err_out;
1869
1870         d = debugfs_create_file("syncevents", S_IRUGO|S_IWUSR, clk_debugfs_root, NULL,
1871                 &syncevent_fops);
1872
1873         if (!d || dvfs_debugfs_init(clk_debugfs_root))
1874                 goto err_out;
1875
1876         list_for_each_entry(c, &clocks, node) {
1877                 err = clk_debugfs_register(c);
1878                 if (err)
1879                         goto err_out;
1880         }
1881         return 0;
1882 err_out:
1883         debugfs_remove_recursive(clk_debugfs_root);
1884         return err;
1885 }
1886 #endif
1887 #else
1888
1889 void tegra_clk_add(struct clk *clk)
1890 {
1891         struct clk_tegra *c = to_clk_tegra(__clk_get_hw(clk));
1892
1893         mutex_lock(&clock_list_lock);
1894         list_add(&c->node, &clocks);
1895         mutex_unlock(&clock_list_lock);
1896 }
1897
1898 struct clk *tegra_get_clock_by_name(const char *name)
1899 {
1900         struct clk_tegra *c;
1901         struct clk *ret = NULL;
1902         mutex_lock(&clock_list_lock);
1903         list_for_each_entry(c, &clocks, node) {
1904                 if (strcmp(__clk_get_name(c->hw.clk), name) == 0) {
1905                         ret = c->hw.clk;
1906                         break;
1907                 }
1908         }
1909         mutex_unlock(&clock_list_lock);
1910         return ret;
1911 }
1912
1913 static int tegra_clk_init_one_from_table(struct tegra_clk_init_table *table)
1914 {
1915         struct clk *c;
1916         struct clk *p;
1917         struct clk *parent;
1918
1919         int ret = 0;
1920
1921         c = tegra_get_clock_by_name(table->name);
1922
1923         if (!c) {
1924                 pr_warn("Unable to initialize clock %s\n",
1925                         table->name);
1926                 return -ENODEV;
1927         }
1928
1929         parent = clk_get_parent(c);
1930
1931         if (table->parent) {
1932                 p = tegra_get_clock_by_name(table->parent);
1933                 if (!p) {
1934                         pr_warn("Unable to find parent %s of clock %s\n",
1935                                 table->parent, table->name);
1936                         return -ENODEV;
1937                 }
1938
1939                 if (parent != p) {
1940                         ret = clk_set_parent(c, p);
1941                         if (ret) {
1942                                 pr_warn("Unable to set parent %s of clock %s: %d\n",
1943                                         table->parent, table->name, ret);
1944                                 return -EINVAL;
1945                         }
1946                 }
1947         }
1948
1949         if (table->rate && table->rate != clk_get_rate(c)) {
1950                 ret = clk_set_rate(c, table->rate);
1951                 if (ret) {
1952                         pr_warn("Unable to set clock %s to rate %lu: %d\n",
1953                                 table->name, table->rate, ret);
1954                         return -EINVAL;
1955                 }
1956         }
1957
1958         if (table->enabled) {
1959                 ret = clk_prepare_enable(c);
1960                 if (ret) {
1961                         pr_warn("Unable to enable clock %s: %d\n",
1962                                 table->name, ret);
1963                         return -EINVAL;
1964                 }
1965         }
1966
1967         return 0;
1968 }
1969
1970 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
1971 {
1972         for (; table->name; table++)
1973                 tegra_clk_init_one_from_table(table);
1974 }
1975
1976 void tegra_periph_reset_deassert(struct clk *c)
1977 {
1978         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1979         BUG_ON(!clk->reset);
1980         clk->reset(__clk_get_hw(c), false);
1981 }
1982 EXPORT_SYMBOL(tegra_periph_reset_deassert);
1983
1984 void tegra_periph_reset_assert(struct clk *c)
1985 {
1986         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1987         BUG_ON(!clk->reset);
1988         clk->reset(__clk_get_hw(c), true);
1989 }
1990 EXPORT_SYMBOL(tegra_periph_reset_assert);
1991
1992 /* Several extended clock configuration bits (e.g., clock routing, clock
1993  * phase control) are included in PLL and peripheral clock source
1994  * registers. */
1995 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
1996 {
1997         int ret = 0;
1998         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1999
2000         if (!clk->clk_cfg_ex) {
2001                 ret = -ENOSYS;
2002                 goto out;
2003         }
2004         ret = clk->clk_cfg_ex(__clk_get_hw(c), p, setting);
2005
2006 out:
2007         return ret;
2008 }
2009 #endif /* !CONFIG_COMMON_CLK */