ARM: tegra: power: Add dynamic CPU regulator mode control
[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
722         if (table->enabled) {
723                 ret = tegra_clk_prepare_enable(c);
724                 if (ret) {
725                         pr_warning("Unable to enable clock %s: %d\n",
726                                 table->name, ret);
727                         return -EINVAL;
728                 }
729         }
730
731         if (table->parent) {
732                 p = tegra_get_clock_by_name(table->parent);
733                 if (!p) {
734                         pr_warning("Unable to find parent %s of clock %s\n",
735                                 table->parent, table->name);
736                         return -ENODEV;
737                 }
738
739                 if (c->parent != p) {
740                         ret = tegra_clk_clip_rate_for_parent(c, p);
741                         if (ret) {
742                                 pr_warning("Unable to clip rate for parent %s"
743                                            " of clock %s: %d\n",
744                                            table->parent, table->name, ret);
745                                 return -EINVAL;
746                         }
747
748                         ret = clk_set_parent(c, p);
749                         if (ret) {
750                                 pr_warning("Unable to set parent %s of clock %s: %d\n",
751                                         table->parent, table->name, ret);
752                                 return -EINVAL;
753                         }
754                 }
755         }
756
757         if (table->rate && table->rate != clk_get_rate(c)) {
758                 ret = clk_set_rate(c, table->rate);
759                 if (ret) {
760                         pr_warning("Unable to set clock %s to rate %lu: %d\n",
761                                 table->name, table->rate, ret);
762                         return -EINVAL;
763                 }
764         }
765
766         return 0;
767 }
768
769 /*
770  * If table refer pll directly it can be scaled only if all its children are OFF
771  */
772 static bool tegra_can_scale_pll_direct(struct clk *pll)
773 {
774         bool can_scale = true;
775         struct clk *c;
776
777         mutex_lock(&clock_list_lock);
778
779         list_for_each_entry(c, &clocks, node) {
780                 if ((clk_get_parent(c) == pll) && (c->state == ON)) {
781                         WARN(1, "tegra: failed initialize %s: in use by %s\n",
782                              pll->name, c->name);
783                         can_scale = false;
784                         break;
785                 }
786         }
787         mutex_unlock(&clock_list_lock);
788         return can_scale;
789 }
790
791 /*
792  * If table entry refer pll as cbus parent it can be scaled as long as all its
793  * children are cbus users (that will be switched to cbus backup during scaling)
794  */
795 static bool tegra_can_scale_pll_cbus(struct clk *pll)
796 {
797         bool can_scale = true;
798         struct clk *c;
799
800         mutex_lock(&clock_list_lock);
801
802         list_for_each_entry(c, &clocks, node) {
803                 if ((clk_get_parent(c) == pll) &&
804                     !(c->flags & PERIPH_ON_CBUS)) {
805                         WARN(1, "tegra: failed initialize %s: in use by %s\n",
806                              pll->name, c->name);
807                         can_scale = false;
808                         break;
809                 }
810         }
811         mutex_unlock(&clock_list_lock);
812         return can_scale;
813 }
814
815 static int tegra_clk_init_cbus_pll_one(struct tegra_clk_init_table *table)
816 {
817         bool can_scale = true;
818         struct clk *pll;
819         struct clk *c = tegra_get_clock_by_name(table->name);
820         if (!c)
821                 return tegra_clk_init_one_from_table(table);
822
823         if (c->flags & PERIPH_ON_CBUS) {
824                 /* table entry refer pllc/c2/c3 indirectly as cbus parent */
825                 pll = clk_get_parent(c);
826                 can_scale = tegra_can_scale_pll_cbus(pll);
827         } else if (c->state == ON) {
828                 /* table entry refer pllc/c2/c3 directly, and it is ON */
829                 pll = c;
830                 can_scale = tegra_can_scale_pll_direct(pll);
831         }
832
833         if (can_scale)
834                 return tegra_clk_init_one_from_table(table);
835         return -EBUSY;
836 }
837
838 void tegra_clk_init_cbus_plls_from_table(struct tegra_clk_init_table *table)
839 {
840         for (; table->name; table++)
841                 tegra_clk_init_cbus_pll_one(table);
842 }
843
844 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
845 {
846         for (; table->name; table++)
847                 tegra_clk_init_one_from_table(table);
848 }
849 EXPORT_SYMBOL(tegra_clk_init_from_table);
850
851 void tegra_periph_reset_deassert(struct clk *c)
852 {
853         BUG_ON(!c->ops->reset);
854         c->ops->reset(c, false);
855 }
856 EXPORT_SYMBOL(tegra_periph_reset_deassert);
857
858 void tegra_periph_reset_assert(struct clk *c)
859 {
860         BUG_ON(!c->ops->reset);
861         c->ops->reset(c, true);
862 }
863 EXPORT_SYMBOL(tegra_periph_reset_assert);
864
865 int tegra_is_clk_enabled(struct clk *c)
866 {
867         return c->refcnt;
868 }
869 EXPORT_SYMBOL(tegra_is_clk_enabled);
870
871 int tegra_clk_shared_bus_update(struct clk *c)
872 {
873         int ret = 0;
874         unsigned long flags;
875
876         clk_lock_save(c, &flags);
877
878         if (c->ops && c->ops->shared_bus_update)
879                 ret = c->ops->shared_bus_update(c);
880
881         clk_unlock_restore(c, &flags);
882         return ret;
883 }
884
885 /* dvfs initialization may lower default maximum rate */
886 void tegra_init_max_rate(struct clk *c, unsigned long max_rate)
887 {
888         struct clk *shared_bus_user;
889
890         if (c->max_rate <= max_rate)
891                 return;
892
893         /* skip message if shared bus user */
894         if (!c->parent || !c->parent->ops || !c->parent->ops->shared_bus_update)
895                 pr_info("Lowering %s maximum rate from %lu to %lu\n",
896                         c->name, c->max_rate, max_rate);
897
898         c->max_rate = max_rate;
899         list_for_each_entry(shared_bus_user,
900                             &c->shared_bus_list, u.shared_bus_user.node) {
901                 if (shared_bus_user->u.shared_bus_user.rate > max_rate)
902                         shared_bus_user->u.shared_bus_user.rate = max_rate;
903                 tegra_init_max_rate(shared_bus_user, max_rate);
904         }
905 }
906
907 /* Use boot rate as emc monitor output until actual monitoring starts */
908 void __init tegra_clk_preset_emc_monitor(unsigned long rate)
909 {
910         struct clk *c = tegra_get_clock_by_name("mon.emc");
911
912         if (c) {
913                 c->u.shared_bus_user.rate = rate;
914                 clk_enable(c);
915         }
916 }
917
918 /*
919  * Set osc (safe) rate. Called only for peripherals left after boot under reset
920  * (peripherals that are taken out of reset by boot-loader must be at safe rate
921  * already - that will be checked by tegra_clk_verify_rates()).
922  */
923 void tegra_periph_clk_safe_rate_init(struct clk *c)
924 {
925         int ret;
926         unsigned long rate = tegra_clk_measure_input_freq();
927
928         if (c->boot_rate || (clk_get_rate(c->parent) <= rate))
929                 return;
930
931         if (c->ops && c->ops->set_rate && (c->flags & PERIPH_DIV)) {
932                 ret = c->ops->set_rate(c, rate);
933                 if (ret)
934                         pr_err("%s: failed to init %s rate %lu\n",
935                                __func__, c->name, rate);
936         }
937 }
938
939 static void __init tegra_clk_verify_rates(void)
940 {
941         struct clk *c;
942         unsigned long rate;
943
944         mutex_lock(&clock_list_lock);
945
946         list_for_each_entry(c, &clocks, node) {
947                 rate = clk_get_rate(c);
948                 if (rate > clk_get_max_rate(c))
949                         WARN(1, "tegra: %s boot rate %lu exceeds max rate %lu\n",
950                              c->name, rate, clk_get_max_rate(c));
951                 c->boot_rate = rate;
952         }
953         mutex_unlock(&clock_list_lock);
954 }
955
956 void __init tegra_common_init_clock(void)
957 {
958 #if defined(CONFIG_HAVE_ARM_TWD) || defined(CONFIG_ARM_ARCH_TIMER)
959         tegra_cpu_timer_init();
960 #endif
961         tegra_clk_verify_rates();
962 }
963
964 void __init tegra_clk_verify_parents(void)
965 {
966         struct clk *c;
967         struct clk *p;
968
969         mutex_lock(&clock_list_lock);
970
971         list_for_each_entry(c, &clocks, node) {
972                 p = clk_get_parent(c);
973                 if (!tegra_clk_is_parent_allowed(c, p))
974                         WARN(1, "tegra: parent %s is not allowed for %s\n",
975                              p->name, c->name);
976         }
977         mutex_unlock(&clock_list_lock);
978 }
979
980 static bool tegra_keep_boot_clocks = false;
981 static int __init tegra_keep_boot_clocks_setup(char *__unused)
982 {
983         tegra_keep_boot_clocks = true;
984         return 1;
985 }
986 __setup("tegra_keep_boot_clocks", tegra_keep_boot_clocks_setup);
987
988 /*
989  * Bootloader may not match kernel restrictions on CPU clock sources.
990  * Make sure CPU clock is sourced from either main or backup parent.
991  */
992 static int __init tegra_sync_cpu_clock(void)
993 {
994         int ret;
995         unsigned long rate;
996         struct clk *c = tegra_get_clock_by_name("cpu");
997
998         BUG_ON(!c);
999         rate = clk_get_rate(c);
1000         ret = clk_set_rate(c, rate);
1001         if (ret)
1002                 pr_err("%s: Failed to sync CPU at rate %lu\n", __func__, rate);
1003         else
1004                 pr_info("CPU rate: %lu MHz\n", clk_get_rate(c) / 1000000);
1005         return ret;
1006 }
1007
1008 /*
1009  * Iterate through all clocks, disabling any for which the refcount is 0
1010  * but the clock init detected the bootloader left the clock on.
1011  */
1012 static int __init tegra_init_disable_boot_clocks(void)
1013 {
1014 #if DISABLE_BOOT_CLOCKS
1015         unsigned long flags;
1016         struct clk *c;
1017
1018         mutex_lock(&clock_list_lock);
1019
1020         list_for_each_entry(c, &clocks, node) {
1021                 clk_lock_save(c, &flags);
1022                 if (c->refcnt == 0 && c->state == ON &&
1023                                 c->ops && c->ops->disable) {
1024                         pr_warn_once("%s clocks left on by bootloader:\n",
1025                                 tegra_keep_boot_clocks ?
1026                                         "Prevented disabling" :
1027                                         "Disabling");
1028
1029                         pr_warn("   %s\n", c->name);
1030
1031                         if (!tegra_keep_boot_clocks) {
1032                                 c->ops->disable(c);
1033                                 c->state = OFF;
1034                         }
1035                 }
1036                 clk_unlock_restore(c, &flags);
1037         }
1038
1039         mutex_unlock(&clock_list_lock);
1040 #endif
1041         return 0;
1042 }
1043
1044 /* Get ready DFLL clock source (if available) for CPU */
1045 static int __init tegra_dfll_cpu_start(void)
1046 {
1047         unsigned long flags;
1048         struct clk *c = tegra_get_clock_by_name("cpu");
1049         struct clk *dfll_cpu = tegra_get_clock_by_name("dfll_cpu");
1050
1051         BUG_ON(!c);
1052         clk_lock_save(c, &flags);
1053
1054         if (dfll_cpu && dfll_cpu->ops && dfll_cpu->ops->init)
1055                 dfll_cpu->ops->init(dfll_cpu);
1056
1057         clk_unlock_restore(c, &flags);
1058         return 0;
1059 }
1060
1061 static int __init tegra_clk_late_init(void)
1062 {
1063         bool init_dfll_first = tegra_dvfs_is_dfll_bypass();
1064
1065         tegra_init_disable_boot_clocks(); /* must before dvfs late init */
1066
1067         /*
1068          * Initialize dfll first if it provides bypass to regulator for legacy
1069          * dvfs; otherwise legacy dvfs controls cpu voltage independently, and
1070          * initialized before dfll.
1071          */
1072         if (init_dfll_first)
1073                 tegra_dfll_cpu_start();
1074         if (!tegra_dvfs_late_init() && !init_dfll_first)
1075                 tegra_dfll_cpu_start();
1076
1077         tegra_sync_cpu_clock();         /* after attempt to get dfll ready */
1078         tegra_update_cpu_edp_limits();
1079         return 0;
1080 }
1081 late_initcall(tegra_clk_late_init);
1082
1083
1084 /* Several extended clock configuration bits (e.g., clock routing, clock
1085  * phase control) are included in PLL and peripheral clock source
1086  * registers. */
1087 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
1088 {
1089         int ret = 0;
1090         unsigned long flags;
1091
1092         clk_lock_save(c, &flags);
1093
1094         if (!c->ops || !c->ops->clk_cfg_ex) {
1095                 ret = -ENOSYS;
1096                 goto out;
1097         }
1098         ret = c->ops->clk_cfg_ex(c, p, setting);
1099
1100 out:
1101         clk_unlock_restore(c, &flags);
1102         return ret;
1103 }
1104 EXPORT_SYMBOL(tegra_clk_cfg_ex);
1105
1106 int tegra_register_clk_rate_notifier(struct clk *c, struct notifier_block *nb)
1107 {
1108         int ret;
1109         unsigned long flags;
1110
1111         if (!c->rate_change_nh)
1112                 return -ENOSYS;
1113
1114         clk_lock_save(c, &flags);
1115         ret = raw_notifier_chain_register(c->rate_change_nh, nb);
1116         clk_unlock_restore(c, &flags);
1117         return ret;
1118 }
1119
1120 void tegra_unregister_clk_rate_notifier(
1121         struct clk *c, struct notifier_block *nb)
1122 {
1123         unsigned long flags;
1124
1125         if (!c->rate_change_nh)
1126                 return;
1127
1128         clk_lock_save(c, &flags);
1129         raw_notifier_chain_unregister(c->rate_change_nh, nb);
1130         clk_unlock_restore(c, &flags);
1131 }
1132
1133 int tegra_clk_register_export_ops(struct clk *c,
1134                                   struct tegra_clk_export_ops *ops)
1135 {
1136         unsigned long flags;
1137
1138         clk_lock_save(c, &flags);
1139         c->u.export_clk.ops = ops;
1140         if (c->ops && c->ops->init)
1141                 c->ops->init(c);
1142         clk_unlock_restore(c, &flags);
1143
1144         return 0;
1145 }
1146
1147 #define OSC_FREQ_DET                    0x58
1148 #define OSC_FREQ_DET_TRIG               BIT(31)
1149
1150 #define OSC_FREQ_DET_STATUS             0x5C
1151 #define OSC_FREQ_DET_BUSY               BIT(31)
1152 #define OSC_FREQ_DET_CNT_MASK           0xFFFF
1153
1154 unsigned long tegra_clk_measure_input_freq(void)
1155 {
1156         u32 clock_autodetect;
1157         void __iomem *clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
1158
1159         if (osc_freq)
1160                 return osc_freq;
1161
1162         writel(OSC_FREQ_DET_TRIG | 1,
1163                 (void *)((uintptr_t)clk_base + OSC_FREQ_DET));
1164         do {} while (readl(
1165                 (void *)((uintptr_t)clk_base + OSC_FREQ_DET_STATUS))
1166                 & OSC_FREQ_DET_BUSY);
1167
1168         clock_autodetect = readl(
1169                 (void *)((uintptr_t)clk_base + OSC_FREQ_DET_STATUS));
1170         if (clock_autodetect >= 732 - 3 && clock_autodetect <= 732 + 3) {
1171                 osc_freq = 12000000;
1172         } else if (clock_autodetect >= 794 - 3 && clock_autodetect <= 794 + 3) {
1173                 osc_freq = 13000000;
1174         } else if (clock_autodetect >= 1172 - 3 && clock_autodetect <= 1172 + 3) {
1175                 osc_freq = 19200000;
1176         } else if (clock_autodetect >= 1587 - 3 && clock_autodetect <= 1587 + 3) {
1177                 osc_freq = 26000000;
1178 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
1179         } else if (clock_autodetect >= 1025 - 3 && clock_autodetect <= 1025 + 3) {
1180                 osc_freq = 16800000;
1181         } else if (clock_autodetect >= 2344 - 3 && clock_autodetect <= 2344 + 3) {
1182                 osc_freq = 38400000;
1183         } else if (clock_autodetect >= 2928 - 3 && clock_autodetect <= 2928 + 3) {
1184                 osc_freq = 48000000;
1185         } else if (tegra_platform_is_qt()) {
1186                 if (clock_autodetect >= 2 && clock_autodetect <= 9)
1187                         osc_freq = 115200;
1188                 else if (clock_autodetect >= 13 && clock_autodetect <= 15)
1189                         osc_freq = 230400;
1190 #endif
1191         } else {
1192                 pr_err("%s: Unexpected clock autodetect value %d", __func__, clock_autodetect);
1193         }
1194
1195         BUG_ON(osc_freq == 0);
1196
1197         return osc_freq;
1198 }
1199
1200 #ifdef CONFIG_DEBUG_FS
1201
1202 /*
1203  * Attempt to lock all the clocks that are marked cansleep
1204  * Must be called with irqs enabled
1205  */
1206 static int __clk_lock_all_mutexes(void)
1207 {
1208         struct clk *c;
1209
1210         might_sleep();
1211
1212         list_for_each_entry(c, &clocks, node)
1213                 if (clk_cansleep(c))
1214                         if (!mutex_trylock(&c->mutex))
1215                                 goto unlock_mutexes;
1216
1217         return 0;
1218
1219 unlock_mutexes:
1220         list_for_each_entry_continue_reverse(c, &clocks, node)
1221                 if (clk_cansleep(c))
1222                         mutex_unlock(&c->mutex);
1223
1224         return -EAGAIN;
1225 }
1226
1227 /*
1228  * Attempt to lock all the clocks that are not marked cansleep
1229  * Must be called with irqs disabled
1230  */
1231 static int __clk_lock_all_spinlocks(void)
1232 {
1233         struct clk *c;
1234
1235         list_for_each_entry(c, &clocks, node)
1236                 if (!clk_cansleep(c))
1237                         if (!spin_trylock(&c->spinlock))
1238                                 goto unlock_spinlocks;
1239
1240         return 0;
1241
1242 unlock_spinlocks:
1243         list_for_each_entry_continue_reverse(c, &clocks, node)
1244                 if (!clk_cansleep(c))
1245                         spin_unlock(&c->spinlock);
1246
1247         return -EAGAIN;
1248 }
1249
1250 static void __clk_unlock_all_mutexes(void)
1251 {
1252         struct clk *c;
1253
1254         list_for_each_entry_reverse(c, &clocks, node)
1255                 if (clk_cansleep(c))
1256                         mutex_unlock(&c->mutex);
1257 }
1258
1259 static void __clk_unlock_all_spinlocks(void)
1260 {
1261         struct clk *c;
1262
1263         list_for_each_entry_reverse(c, &clocks, node)
1264                 if (!clk_cansleep(c))
1265                         spin_unlock(&c->spinlock);
1266 }
1267
1268 /*
1269  * This function retries until it can take all locks, and may take
1270  * an arbitrarily long time to complete.
1271  * Must be called with irqs enabled, returns with irqs disabled
1272  * Must be called with clock_list_lock held
1273  */
1274 static void clk_lock_all(void)
1275 {
1276         int ret;
1277 retry:
1278         ret = __clk_lock_all_mutexes();
1279         if (ret)
1280                 goto failed_mutexes;
1281
1282         local_irq_disable();
1283
1284         ret = __clk_lock_all_spinlocks();
1285         if (ret)
1286                 goto failed_spinlocks;
1287
1288         /* All locks taken successfully, return */
1289         return;
1290
1291 failed_spinlocks:
1292         local_irq_enable();
1293         __clk_unlock_all_mutexes();
1294 failed_mutexes:
1295         msleep(1);
1296         goto retry;
1297 }
1298
1299 /*
1300  * Unlocks all clocks after a clk_lock_all
1301  * Must be called with irqs disabled, returns with irqs enabled
1302  * Must be called with clock_list_lock held
1303  */
1304 static void clk_unlock_all(void)
1305 {
1306         __clk_unlock_all_spinlocks();
1307
1308         local_irq_enable();
1309
1310         __clk_unlock_all_mutexes();
1311 }
1312
1313 static struct dentry *clk_debugfs_root;
1314
1315 static void dvfs_show_one(struct seq_file *s, struct dvfs *d, int level)
1316 {
1317         seq_printf(s, "%*s  %-*s%21s%d mV\n",
1318                         level * 3 + 1, "",
1319                         35 - level * 3, d->dvfs_rail->reg_id,
1320                         "",
1321                         d->cur_millivolts);
1322 }
1323
1324 static void clock_tree_show_one(struct seq_file *s, struct clk *c, int level)
1325 {
1326         struct clk *child;
1327         const char *state = "uninit";
1328         char div[8] = {0};
1329         unsigned long rate = clk_get_rate_all_locked(c);
1330         unsigned long max_rate = clk_get_max_rate(c);;
1331
1332         if (c->state == ON)
1333                 state = "on";
1334         else if (c->state == OFF)
1335                 state = "off";
1336
1337         if (c->mul != 0 && c->div != 0) {
1338                 if (c->mul > c->div) {
1339                         int mul = c->mul / c->div;
1340                         int mul2 = (c->mul * 10 / c->div) % 10;
1341                         int mul3 = (c->mul * 10) % c->div;
1342                         if (mul2 == 0 && mul3 == 0)
1343                                 snprintf(div, sizeof(div), "x%d", mul);
1344                         else if (mul3 == 0)
1345                                 snprintf(div, sizeof(div), "x%d.%d", mul, mul2);
1346                         else
1347                                 snprintf(div, sizeof(div), "x%d.%d..", mul, mul2);
1348                 } else {
1349                         snprintf(div, sizeof(div), "%d%s", c->div / c->mul,
1350                                 (c->div % c->mul) ? ".5" : "");
1351                 }
1352         }
1353
1354         seq_printf(s, "%*s%c%c%-*s%c %-6s %-3d %-8s %-10lu",
1355                 level * 3 + 1, "",
1356                 rate > max_rate ? '!' : ' ',
1357                 !c->set ? '*' : ' ',
1358                 35 - level * 3, c->name,
1359                 c->cansleep ? '$' : ' ',
1360                 state, c->refcnt, div, rate);
1361         if (c->parent && !list_empty(&c->parent->shared_bus_list)) {
1362                 enum shared_bus_users_mode mode = c->u.shared_bus_user.mode;
1363                 unsigned long request = c->u.shared_bus_user.rate;
1364                 seq_printf(s, " (%lu", request);
1365
1366                 switch (mode) {
1367                 case SHARED_BW:
1368                         seq_printf(s, " / %lu+)",
1369                                    request / tegra_emc_bw_efficiency * 100);
1370                         break;
1371                 case SHARED_ISO_BW:
1372                         seq_printf(s, " / %lu / %lu+)",
1373                                    request / tegra_emc_bw_efficiency * 100,
1374                                    request / tegra_emc_iso_share * 100);
1375                         break;
1376                 case SHARED_CEILING_BUT_ISO:
1377                 case SHARED_CEILING:
1378                         seq_printf(s, "%s)", "^");
1379                         break;
1380                 default:
1381                         seq_printf(s, ")");
1382                 }
1383         }
1384         seq_printf(s, "\n");
1385
1386         if (c->dvfs)
1387                 dvfs_show_one(s, c->dvfs, level + 1);
1388
1389         list_for_each_entry(child, &clocks, node) {
1390                 if (child->parent != c)
1391                         continue;
1392
1393                 clock_tree_show_one(s, child, level + 1);
1394         }
1395 }
1396
1397 static int clock_tree_show(struct seq_file *s, void *data)
1398 {
1399         struct clk *c;
1400         seq_printf(s, "   clock                               state  ref div      rate       (shared req / bw_margin / iso_margin)\n");
1401         seq_printf(s, "-----------------------------------------------------------------------------------------------------------\n");
1402
1403         mutex_lock(&clock_list_lock);
1404         if (!tegra_platform_is_fpga())
1405                 clk_lock_all();
1406         list_for_each_entry(c, &clocks, node)
1407                 if (c->parent == NULL)
1408                         clock_tree_show_one(s, c, 0);
1409         if (!tegra_platform_is_fpga())
1410                 clk_unlock_all();
1411         mutex_unlock(&clock_list_lock);
1412         return 0;
1413 }
1414
1415 static int clock_tree_open(struct inode *inode, struct file *file)
1416 {
1417         return single_open(file, clock_tree_show, inode->i_private);
1418 }
1419
1420 static const struct file_operations clock_tree_fops = {
1421         .open           = clock_tree_open,
1422         .read           = seq_read,
1423         .llseek         = seq_lseek,
1424         .release        = single_release,
1425 };
1426
1427 static void syncevent_one(struct clk *c)
1428 {
1429         struct clk *child;
1430
1431         if (c->state == ON)
1432                 trace_clock_enable(c->name, 1, smp_processor_id());
1433         else
1434                 trace_clock_disable(c->name, 0, smp_processor_id());
1435
1436         trace_clock_set_rate(c->name, clk_get_rate_all_locked(c),
1437                                 smp_processor_id());
1438
1439         list_for_each_entry(child, &clocks, node) {
1440                 if (child->parent != c)
1441                         continue;
1442
1443                 syncevent_one(child);
1444         }
1445 }
1446
1447 static int syncevent_write(struct file *file, const char __user *user_buf,
1448                                 size_t count, loff_t *ppos)
1449 {
1450         struct clk *c;
1451         char buffer[40];
1452         int buf_size;
1453
1454         memset(buffer, 0, sizeof(buffer));
1455         buf_size = min(count, (sizeof(buffer)-1));
1456
1457         if (copy_from_user(buffer, user_buf, buf_size))
1458                 return -EFAULT;
1459
1460         if (!strnicmp("all", buffer, 3)) {
1461                 mutex_lock(&clock_list_lock);
1462
1463                 clk_lock_all();
1464
1465                 list_for_each_entry(c, &clocks, node) {
1466                         if (c->parent == NULL)
1467                                 syncevent_one(c);
1468                 }
1469
1470                 clk_unlock_all();
1471
1472                 mutex_unlock(&clock_list_lock);
1473         }
1474
1475         return count;
1476 }
1477
1478 static const struct file_operations syncevent_fops = {
1479         .write          = syncevent_write,
1480 };
1481
1482 static int possible_parents_show(struct seq_file *s, void *data)
1483 {
1484         struct clk *c = s->private;
1485         int i;
1486         bool first = true;
1487
1488         for (i = 0; c->inputs[i].input; i++) {
1489                 if (tegra_clk_is_parent_allowed(c, c->inputs[i].input)) {
1490                         seq_printf(s, "%s%s", first ? "" : " ",
1491                                    c->inputs[i].input->name);
1492                         first = false;
1493                 }
1494         }
1495         seq_printf(s, "\n");
1496         return 0;
1497 }
1498
1499 static int possible_parents_open(struct inode *inode, struct file *file)
1500 {
1501         return single_open(file, possible_parents_show, inode->i_private);
1502 }
1503
1504 static const struct file_operations possible_parents_fops = {
1505         .open           = possible_parents_open,
1506         .read           = seq_read,
1507         .llseek         = seq_lseek,
1508         .release        = single_release,
1509 };
1510
1511 static int parent_show(struct seq_file *s, void *data)
1512 {
1513         struct clk *c = s->private;
1514         struct clk *p = clk_get_parent(c);
1515
1516         seq_printf(s, "%s\n", p ? p->name : "clk_root");
1517         return 0;
1518 }
1519
1520 static int parent_open(struct inode *inode, struct file *file)
1521 {
1522         return single_open(file, parent_show, inode->i_private);
1523 }
1524
1525 static int rate_get(void *data, u64 *val)
1526 {
1527         struct clk *c = (struct clk *)data;
1528         *val = (u64)clk_get_rate(c);
1529         return 0;
1530 }
1531
1532 static int state_get(void *data, u64 *val)
1533 {
1534         struct clk *c = (struct clk *)data;
1535         *val = (u64)((c->state == ON) ? 1 : 0);
1536         return 0;
1537 }
1538
1539 static int max_get(void *data, u64 *val)
1540 {
1541         struct clk *c = (struct clk *)data;
1542         *val = (u64)clk_get_max_rate(c);
1543         return 0;
1544 }
1545
1546 #ifdef CONFIG_TEGRA_CLOCK_DEBUG_WRITE
1547
1548 static const mode_t parent_rate_mode =  S_IRUGO | S_IWUSR;
1549
1550 static ssize_t parent_write(struct file *file,
1551         const char __user *userbuf, size_t count, loff_t *ppos)
1552 {
1553         struct seq_file *s = file->private_data;
1554         struct clk *c = s->private;
1555         struct clk *p = NULL;
1556         char buf[32];
1557
1558         if (sizeof(buf) <= count)
1559                 return -EINVAL;
1560
1561         if (copy_from_user(buf, userbuf, count))
1562                 return -EFAULT;
1563
1564         /* terminate buffer and trim - white spaces may be appended
1565          *  at the end when invoked from shell command line */
1566         buf[count]='\0';
1567         strim(buf);
1568
1569         p = tegra_get_clock_by_name(buf);
1570         if (!p)
1571                 return -EINVAL;
1572
1573         if (clk_set_parent(c, p))
1574                 return -EINVAL;
1575
1576         return count;
1577 }
1578
1579 static const struct file_operations parent_fops = {
1580         .open           = parent_open,
1581         .read           = seq_read,
1582         .write          = parent_write,
1583         .llseek         = seq_lseek,
1584         .release        = single_release,
1585 };
1586
1587 static int rate_set(void *data, u64 val)
1588 {
1589         struct clk *c = (struct clk *)data;
1590         return clk_set_rate(c, (unsigned long)val);
1591 }
1592 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, rate_set, "%llu\n");
1593
1594 static int state_set(void *data, u64 val)
1595 {
1596         struct clk *c = (struct clk *)data;
1597
1598         if (val)
1599                 return tegra_clk_prepare_enable(c);
1600         else {
1601                 tegra_clk_disable_unprepare(c);
1602                 return 0;
1603         }
1604 }
1605 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, state_set, "%llu\n");
1606
1607 static int _max_set(struct clk *c, unsigned long val)
1608 {
1609         int i;
1610
1611         c->max_rate = val;
1612
1613         if (c->dvfs && c->dvfs->max_millivolts) {
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                 }
1618         }
1619         return 0;
1620 }
1621
1622 #ifdef CONFIG_TEGRA_CLOCK_DEBUG_FUNC
1623 int tegra_clk_set_max(struct clk *c, unsigned long rate)
1624 {
1625         return _max_set(c, rate);
1626 }
1627 EXPORT_SYMBOL(tegra_clk_set_max);
1628 #endif
1629
1630 static int max_set(void *data, u64 val)
1631 {
1632         struct clk *c = (struct clk *)data;
1633         return _max_set(c, (unsigned long)val);
1634 }
1635 DEFINE_SIMPLE_ATTRIBUTE(max_fops, max_get, max_set, "%llu\n");
1636
1637 #else
1638
1639 static const mode_t parent_rate_mode =  S_IRUGO;
1640
1641 static const struct file_operations parent_fops = {
1642         .open           = parent_open,
1643         .read           = seq_read,
1644         .llseek         = seq_lseek,
1645         .release        = single_release,
1646 };
1647
1648 DEFINE_SIMPLE_ATTRIBUTE(rate_fops, rate_get, NULL, "%llu\n");
1649 DEFINE_SIMPLE_ATTRIBUTE(state_fops, state_get, NULL, "%llu\n");
1650 DEFINE_SIMPLE_ATTRIBUTE(max_fops, max_get, NULL, "%llu\n");
1651 #endif
1652
1653 static int time_on_get(void *data, u64 *val)
1654 {
1655         unsigned long flags;
1656         struct clk *c = (struct clk *)data;
1657
1658         clk_lock_save(c, &flags);
1659         clk_stats_update(c);
1660         *val = cputime64_to_clock_t(c->stats.time_on);
1661         clk_unlock_restore(c, &flags);
1662
1663         return 0;
1664 }
1665 DEFINE_SIMPLE_ATTRIBUTE(time_on_fops, time_on_get, NULL, "%llu\n");
1666
1667 static int possible_rates_show(struct seq_file *s, void *data)
1668 {
1669         struct clk *c = s->private;
1670         long rate = 0;
1671
1672         /* shared bus clock must round up, unless top of range reached */
1673         while (rate <= c->max_rate) {
1674                 unsigned long rounded_rate = c->ops->round_rate(c, rate);
1675                 if (IS_ERR_VALUE(rounded_rate) || (rounded_rate <= rate))
1676                         break;
1677
1678                 rate = rounded_rate + 2000;     /* 2kHz resolution */
1679                 seq_printf(s, "%ld ", rounded_rate / 1000);
1680         }
1681         seq_printf(s, "(kHz)\n");
1682         return 0;
1683 }
1684
1685 static int possible_rates_open(struct inode *inode, struct file *file)
1686 {
1687         return single_open(file, possible_rates_show, inode->i_private);
1688 }
1689
1690 static const struct file_operations possible_rates_fops = {
1691         .open           = possible_rates_open,
1692         .read           = seq_read,
1693         .llseek         = seq_lseek,
1694         .release        = single_release,
1695 };
1696
1697 static int clk_debugfs_register_one(struct clk *c)
1698 {
1699         struct dentry *d;
1700
1701         d = debugfs_create_dir(c->name, clk_debugfs_root);
1702         if (!d)
1703                 return -ENOMEM;
1704         c->dent = d;
1705
1706         d = debugfs_create_u8("refcnt", S_IRUGO, c->dent, (u8 *)&c->refcnt);
1707         if (!d)
1708                 goto err_out;
1709
1710         d = debugfs_create_x32("flags", S_IRUGO, c->dent, (u32 *)&c->flags);
1711         if (!d)
1712                 goto err_out;
1713
1714         d = debugfs_create_x32("shared_bus_flags", S_IRUGO, c->dent,
1715                                (u32 *)&c->shared_bus_flags);
1716         if (!d)
1717                 goto err_out;
1718
1719         d = debugfs_create_file(
1720                 "max", parent_rate_mode, c->dent, c, &max_fops);
1721         if (!d)
1722                 goto err_out;
1723
1724         d = debugfs_create_u32("min", S_IRUGO, c->dent, (u32 *)&c->min_rate);
1725         if (!d)
1726                 goto err_out;
1727
1728         d = debugfs_create_file(
1729                 "parent", parent_rate_mode, c->dent, c, &parent_fops);
1730         if (!d)
1731                 goto err_out;
1732
1733         d = debugfs_create_file(
1734                 "rate", parent_rate_mode, c->dent, c, &rate_fops);
1735         if (!d)
1736                 goto err_out;
1737
1738         d = debugfs_create_file(
1739                 "state", parent_rate_mode, c->dent, c, &state_fops);
1740         if (!d)
1741                 goto err_out;
1742
1743         d = debugfs_create_file(
1744                 "time_on", S_IRUGO, c->dent, c, &time_on_fops);
1745         if (!d)
1746                 goto err_out;
1747
1748         if (c->inputs) {
1749                 d = debugfs_create_file("possible_parents", S_IRUGO, c->dent,
1750                         c, &possible_parents_fops);
1751                 if (!d)
1752                         goto err_out;
1753         }
1754
1755         /* show possible rates only of the top-most shared buses */
1756         if ((c->ops && c->ops->round_rate && c->ops->shared_bus_update) &&
1757             !(c->parent && c->parent->ops && c->parent->ops->round_rate &&
1758                c->parent->ops->shared_bus_update)) {
1759                 d = debugfs_create_file("possible_rates", S_IRUGO, c->dent,
1760                         c, &possible_rates_fops);
1761                 if (!d)
1762                         goto err_out;
1763         }
1764
1765         return 0;
1766
1767 err_out:
1768         debugfs_remove_recursive(c->dent);
1769         return -ENOMEM;
1770 }
1771
1772 static int clk_debugfs_register(struct clk *c)
1773 {
1774         int err;
1775         struct clk *pa = c->parent;
1776
1777         if (pa && !pa->dent) {
1778                 err = clk_debugfs_register(pa);
1779                 if (err)
1780                         return err;
1781         }
1782
1783         if (!c->dent) {
1784                 err = clk_debugfs_register_one(c);
1785                 if (err)
1786                         return err;
1787         }
1788         return 0;
1789 }
1790
1791 int __init tegra_clk_debugfs_init(void)
1792 {
1793         struct clk *c;
1794         struct dentry *d;
1795         int err = -ENOMEM;
1796
1797         d = debugfs_create_dir("clock", NULL);
1798         if (!d)
1799                 return -ENOMEM;
1800         clk_debugfs_root = d;
1801
1802         d = debugfs_create_file("clock_tree", S_IRUGO, clk_debugfs_root, NULL,
1803                 &clock_tree_fops);
1804         if (!d)
1805                 goto err_out;
1806
1807         d = debugfs_create_file("syncevents", S_IRUGO|S_IWUSR, clk_debugfs_root, NULL,
1808                 &syncevent_fops);
1809
1810         if (!d || dvfs_debugfs_init(clk_debugfs_root))
1811                 goto err_out;
1812
1813         list_for_each_entry(c, &clocks, node) {
1814                 err = clk_debugfs_register(c);
1815                 if (err)
1816                         goto err_out;
1817         }
1818         return 0;
1819 err_out:
1820         debugfs_remove_recursive(clk_debugfs_root);
1821         return err;
1822 }
1823 #endif
1824 #else
1825
1826 void tegra_clk_add(struct clk *clk)
1827 {
1828         struct clk_tegra *c = to_clk_tegra(__clk_get_hw(clk));
1829
1830         mutex_lock(&clock_list_lock);
1831         list_add(&c->node, &clocks);
1832         mutex_unlock(&clock_list_lock);
1833 }
1834
1835 struct clk *tegra_get_clock_by_name(const char *name)
1836 {
1837         struct clk_tegra *c;
1838         struct clk *ret = NULL;
1839         mutex_lock(&clock_list_lock);
1840         list_for_each_entry(c, &clocks, node) {
1841                 if (strcmp(__clk_get_name(c->hw.clk), name) == 0) {
1842                         ret = c->hw.clk;
1843                         break;
1844                 }
1845         }
1846         mutex_unlock(&clock_list_lock);
1847         return ret;
1848 }
1849
1850 static int tegra_clk_init_one_from_table(struct tegra_clk_init_table *table)
1851 {
1852         struct clk *c;
1853         struct clk *p;
1854         struct clk *parent;
1855
1856         int ret = 0;
1857
1858         c = tegra_get_clock_by_name(table->name);
1859
1860         if (!c) {
1861                 pr_warn("Unable to initialize clock %s\n",
1862                         table->name);
1863                 return -ENODEV;
1864         }
1865
1866         parent = clk_get_parent(c);
1867
1868         if (table->parent) {
1869                 p = tegra_get_clock_by_name(table->parent);
1870                 if (!p) {
1871                         pr_warn("Unable to find parent %s of clock %s\n",
1872                                 table->parent, table->name);
1873                         return -ENODEV;
1874                 }
1875
1876                 if (parent != p) {
1877                         ret = clk_set_parent(c, p);
1878                         if (ret) {
1879                                 pr_warn("Unable to set parent %s of clock %s: %d\n",
1880                                         table->parent, table->name, ret);
1881                                 return -EINVAL;
1882                         }
1883                 }
1884         }
1885
1886         if (table->rate && table->rate != clk_get_rate(c)) {
1887                 ret = clk_set_rate(c, table->rate);
1888                 if (ret) {
1889                         pr_warn("Unable to set clock %s to rate %lu: %d\n",
1890                                 table->name, table->rate, ret);
1891                         return -EINVAL;
1892                 }
1893         }
1894
1895         if (table->enabled) {
1896                 ret = clk_prepare_enable(c);
1897                 if (ret) {
1898                         pr_warn("Unable to enable clock %s: %d\n",
1899                                 table->name, ret);
1900                         return -EINVAL;
1901                 }
1902         }
1903
1904         return 0;
1905 }
1906
1907 void tegra_clk_init_from_table(struct tegra_clk_init_table *table)
1908 {
1909         for (; table->name; table++)
1910                 tegra_clk_init_one_from_table(table);
1911 }
1912
1913 void tegra_periph_reset_deassert(struct clk *c)
1914 {
1915         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1916         BUG_ON(!clk->reset);
1917         clk->reset(__clk_get_hw(c), false);
1918 }
1919 EXPORT_SYMBOL(tegra_periph_reset_deassert);
1920
1921 void tegra_periph_reset_assert(struct clk *c)
1922 {
1923         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1924         BUG_ON(!clk->reset);
1925         clk->reset(__clk_get_hw(c), true);
1926 }
1927 EXPORT_SYMBOL(tegra_periph_reset_assert);
1928
1929 /* Several extended clock configuration bits (e.g., clock routing, clock
1930  * phase control) are included in PLL and peripheral clock source
1931  * registers. */
1932 int tegra_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
1933 {
1934         int ret = 0;
1935         struct clk_tegra *clk = to_clk_tegra(__clk_get_hw(c));
1936
1937         if (!clk->clk_cfg_ex) {
1938                 ret = -ENOSYS;
1939                 goto out;
1940         }
1941         ret = clk->clk_cfg_ex(__clk_get_hw(c), p, setting);
1942
1943 out:
1944         return ret;
1945 }
1946 #endif /* !CONFIG_COMMON_CLK */