[ARM] tegra: Add clock support
[linux-2.6.git] / arch / arm / mach-tegra / tegra2_clocks.c
1 /*
2  * arch/arm/mach-tegra/tegra2_clocks.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  *
6  * Author:
7  *      Colin Cross <ccross@google.com>
8  *
9  * This software is licensed under the terms of the GNU General Public
10  * License version 2, as published by the Free Software Foundation, and
11  * may be copied, distributed, and modified under those terms.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  */
19
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/list.h>
23 #include <linux/spinlock.h>
24 #include <linux/delay.h>
25 #include <linux/io.h>
26 #include <linux/hrtimer.h>
27
28 #include <asm/clkdev.h>
29
30 #include <mach/iomap.h>
31
32 #include "clock.h"
33
34 #define RST_DEVICES                     0x004
35 #define RST_DEVICES_SET                 0x300
36 #define RST_DEVICES_CLR                 0x304
37
38 #define CLK_OUT_ENB                     0x010
39 #define CLK_OUT_ENB_SET                 0x320
40 #define CLK_OUT_ENB_CLR                 0x324
41
42 #define OSC_CTRL                        0x50
43 #define OSC_CTRL_OSC_FREQ_MASK          (3<<30)
44 #define OSC_CTRL_OSC_FREQ_13MHZ         (0<<30)
45 #define OSC_CTRL_OSC_FREQ_19_2MHZ       (1<<30)
46 #define OSC_CTRL_OSC_FREQ_12MHZ         (2<<30)
47 #define OSC_CTRL_OSC_FREQ_26MHZ         (3<<30)
48
49 #define OSC_FREQ_DET                    0x58
50 #define OSC_FREQ_DET_TRIG               (1<<31)
51
52 #define OSC_FREQ_DET_STATUS             0x5C
53 #define OSC_FREQ_DET_BUSY               (1<<31)
54 #define OSC_FREQ_DET_CNT_MASK           0xFFFF
55
56 #define PERIPH_CLK_SOURCE_MASK          (3<<30)
57 #define PERIPH_CLK_SOURCE_SHIFT         30
58 #define PERIPH_CLK_SOURCE_ENABLE        (1<<28)
59 #define PERIPH_CLK_SOURCE_DIV_MASK      0xFF
60 #define PERIPH_CLK_SOURCE_DIV_SHIFT     0
61
62 #define PLL_BASE                        0x0
63 #define PLL_BASE_BYPASS                 (1<<31)
64 #define PLL_BASE_ENABLE                 (1<<30)
65 #define PLL_BASE_REF_ENABLE             (1<<29)
66 #define PLL_BASE_OVERRIDE               (1<<28)
67 #define PLL_BASE_LOCK                   (1<<27)
68 #define PLL_BASE_DIVP_MASK              (0x7<<20)
69 #define PLL_BASE_DIVP_SHIFT             20
70 #define PLL_BASE_DIVN_MASK              (0x3FF<<8)
71 #define PLL_BASE_DIVN_SHIFT             8
72 #define PLL_BASE_DIVM_MASK              (0x1F)
73 #define PLL_BASE_DIVM_SHIFT             0
74
75 #define PLL_OUT_RATIO_MASK              (0xFF<<8)
76 #define PLL_OUT_RATIO_SHIFT             8
77 #define PLL_OUT_OVERRIDE                (1<<2)
78 #define PLL_OUT_CLKEN                   (1<<1)
79 #define PLL_OUT_RESET_DISABLE           (1<<0)
80
81 #define PLL_MISC(c)                     (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
82 #define PLL_MISC_DCCON_SHIFT            20
83 #define PLL_MISC_LOCK_ENABLE            (1<<18)
84 #define PLL_MISC_CPCON_SHIFT            8
85 #define PLL_MISC_CPCON_MASK             (0xF<<PLL_MISC_CPCON_SHIFT)
86 #define PLL_MISC_LFCON_SHIFT            4
87 #define PLL_MISC_LFCON_MASK             (0xF<<PLL_MISC_LFCON_SHIFT)
88 #define PLL_MISC_VCOCON_SHIFT           0
89 #define PLL_MISC_VCOCON_MASK            (0xF<<PLL_MISC_VCOCON_SHIFT)
90
91 #define PLLD_MISC_CLKENABLE             (1<<30)
92 #define PLLD_MISC_DIV_RST               (1<<23)
93 #define PLLD_MISC_DCCON_SHIFT           12
94
95 #define PERIPH_CLK_TO_ENB_REG(c)        ((c->clk_num / 32) * 4)
96 #define PERIPH_CLK_TO_ENB_SET_REG(c)    ((c->clk_num / 32) * 8)
97 #define PERIPH_CLK_TO_ENB_BIT(c)        (1 << (c->clk_num % 32))
98
99 #define SUPER_CLK_MUX                   0x00
100 #define SUPER_STATE_SHIFT               28
101 #define SUPER_STATE_MASK                (0xF << SUPER_STATE_SHIFT)
102 #define SUPER_STATE_STANDBY             (0x0 << SUPER_STATE_SHIFT)
103 #define SUPER_STATE_IDLE                (0x1 << SUPER_STATE_SHIFT)
104 #define SUPER_STATE_RUN                 (0x2 << SUPER_STATE_SHIFT)
105 #define SUPER_STATE_IRQ                 (0x3 << SUPER_STATE_SHIFT)
106 #define SUPER_STATE_FIQ                 (0x4 << SUPER_STATE_SHIFT)
107 #define SUPER_SOURCE_MASK               0xF
108 #define SUPER_FIQ_SOURCE_SHIFT          12
109 #define SUPER_IRQ_SOURCE_SHIFT          8
110 #define SUPER_RUN_SOURCE_SHIFT          4
111 #define SUPER_IDLE_SOURCE_SHIFT         0
112
113 #define SUPER_CLK_DIVIDER               0x04
114
115 #define BUS_CLK_DISABLE                 (1<<3)
116 #define BUS_CLK_DIV_MASK                0x3
117
118 static void __iomem *reg_clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
119
120 #define clk_writel(value, reg) \
121         __raw_writel(value, (u32)reg_clk_base + (reg))
122 #define clk_readl(reg) \
123         __raw_readl((u32)reg_clk_base + (reg))
124
125 unsigned long clk_measure_input_freq(void)
126 {
127         u32 clock_autodetect;
128         clk_writel(OSC_FREQ_DET_TRIG | 1, OSC_FREQ_DET);
129         do {} while (clk_readl(OSC_FREQ_DET_STATUS) & OSC_FREQ_DET_BUSY);
130         clock_autodetect = clk_readl(OSC_FREQ_DET_STATUS);
131         if (clock_autodetect >= 732 - 3 && clock_autodetect <= 732 + 3) {
132                 return 12000000;
133         } else if (clock_autodetect >= 794 - 3 && clock_autodetect <= 794 + 3) {
134                 return 13000000;
135         } else if (clock_autodetect >= 1172 - 3 && clock_autodetect <= 1172 + 3) {
136                 return 19200000;
137         } else if (clock_autodetect >= 1587 - 3 && clock_autodetect <= 1587 + 3) {
138                 return 26000000;
139         } else {
140                 pr_err("%s: Unexpected clock autodetect value %d", __func__, clock_autodetect);
141                 BUG();
142                 return 0;
143         }
144 }
145
146 static int clk_div71_get_divider(struct clk *c, unsigned long rate)
147 {
148         unsigned long divider_u71;
149
150         divider_u71 = DIV_ROUND_UP(c->rate * 2, rate);
151
152         if (divider_u71 - 2 > 255 || divider_u71 - 2 < 0)
153                 return -EINVAL;
154
155         return divider_u71 - 2;
156 }
157
158 static unsigned long tegra2_clk_recalculate_rate(struct clk *c)
159 {
160         unsigned long rate;
161         rate = c->parent->rate;
162
163         if (c->mul != 0 && c->div != 0)
164                 c->rate = rate * c->mul / c->div;
165         else
166                 c->rate = rate;
167         return c->rate;
168 }
169
170
171 /* clk_m functions */
172 static unsigned long tegra2_clk_m_autodetect_rate(struct clk *c)
173 {
174         u32 auto_clock_control = clk_readl(OSC_CTRL) & ~OSC_CTRL_OSC_FREQ_MASK;
175
176         c->rate = clk_measure_input_freq();
177         switch (c->rate) {
178         case 12000000:
179                 auto_clock_control |= OSC_CTRL_OSC_FREQ_12MHZ;
180                 break;
181         case 13000000:
182                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
183                 break;
184         case 19200000:
185                 auto_clock_control |= OSC_CTRL_OSC_FREQ_19_2MHZ;
186                 break;
187         case 26000000:
188                 auto_clock_control |= OSC_CTRL_OSC_FREQ_26MHZ;
189                 break;
190         default:
191                 pr_err("%s: Unexpected clock rate %ld", __func__, c->rate);
192                 BUG();
193         }
194         clk_writel(auto_clock_control, OSC_CTRL);
195         return c->rate;
196 }
197
198 static void tegra2_clk_m_init(struct clk *c)
199 {
200         pr_debug("%s on clock %s\n", __func__, c->name);
201         tegra2_clk_m_autodetect_rate(c);
202 }
203
204 static int tegra2_clk_m_enable(struct clk *c)
205 {
206         pr_debug("%s on clock %s\n", __func__, c->name);
207         return 0;
208 }
209
210 static void tegra2_clk_m_disable(struct clk *c)
211 {
212         pr_debug("%s on clock %s\n", __func__, c->name);
213         BUG();
214 }
215
216 static struct clk_ops tegra_clk_m_ops = {
217         .init           = tegra2_clk_m_init,
218         .enable         = tegra2_clk_m_enable,
219         .disable        = tegra2_clk_m_disable,
220 };
221
222 /* super clock functions */
223 /* "super clocks" on tegra have two-stage muxes and a clock skipping
224  * super divider.  We will ignore the clock skipping divider, since we
225  * can't lower the voltage when using the clock skip, but we can if we
226  * lower the PLL frequency.
227  */
228 static void tegra2_super_clk_init(struct clk *c)
229 {
230         u32 val;
231         int source;
232         int shift;
233         const struct clk_mux_sel *sel;
234         val = clk_readl(c->reg + SUPER_CLK_MUX);
235         c->state = ON;
236         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
237                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
238         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
239                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
240         source = (val >> shift) & SUPER_SOURCE_MASK;
241         for (sel = c->inputs; sel->input != NULL; sel++) {
242                 if (sel->value == source)
243                         break;
244         }
245         BUG_ON(sel->input == NULL);
246         c->parent = sel->input;
247         tegra2_clk_recalculate_rate(c);
248 }
249
250 static int tegra2_super_clk_enable(struct clk *c)
251 {
252         clk_writel(0, c->reg + SUPER_CLK_DIVIDER);
253         return 0;
254 }
255
256 static void tegra2_super_clk_disable(struct clk *c)
257 {
258         pr_debug("%s on clock %s\n", __func__, c->name);
259
260         /* oops - don't disable the CPU clock! */
261         BUG();
262 }
263
264 static int tegra2_super_clk_set_parent(struct clk *c, struct clk *p)
265 {
266         u32 val;
267         const struct clk_mux_sel *sel;
268         int shift;
269         val = clk_readl(c->reg + SUPER_CLK_MUX);;
270         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
271                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
272         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
273                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
274         for (sel = c->inputs; sel->input != NULL; sel++) {
275                 if (sel->input == p) {
276                         clk_reparent(c, p);
277                         val &= ~(SUPER_SOURCE_MASK << shift);
278                         val |= sel->value << shift;
279                         clk_writel(val, c->reg);
280                         c->rate = c->parent->rate;
281                         return 0;
282                 }
283         }
284         return -EINVAL;
285 }
286
287 static struct clk_ops tegra_super_ops = {
288         .init                   = tegra2_super_clk_init,
289         .enable                 = tegra2_super_clk_enable,
290         .disable                = tegra2_super_clk_disable,
291         .set_parent             = tegra2_super_clk_set_parent,
292         .recalculate_rate       = tegra2_clk_recalculate_rate,
293 };
294
295 /* bus clock functions */
296 static void tegra2_bus_clk_init(struct clk *c)
297 {
298         u32 val = clk_readl(c->reg);
299         c->state = ((val >> c->reg_shift) & BUS_CLK_DISABLE) ? OFF : ON;
300         c->div = ((val >> c->reg_shift) & BUS_CLK_DIV_MASK) + 1;
301         c->mul = 1;
302         tegra2_clk_recalculate_rate(c);
303 }
304
305 static int tegra2_bus_clk_enable(struct clk *c)
306 {
307         u32 val = clk_readl(c->reg);
308         val &= ~(BUS_CLK_DISABLE << c->reg_shift);
309         clk_writel(val, c->reg);
310         return 0;
311 }
312
313 static void tegra2_bus_clk_disable(struct clk *c)
314 {
315         u32 val = clk_readl(c->reg);
316         val |= BUS_CLK_DISABLE << c->reg_shift;
317         clk_writel(val, c->reg);
318 }
319
320 static int tegra2_bus_clk_set_rate(struct clk *c, unsigned long rate)
321 {
322         u32 val = clk_readl(c->reg);
323         unsigned long parent_rate = c->parent->rate;
324         int i;
325         for (i = 1; i <= 4; i++) {
326                 if (rate == parent_rate / i) {
327                         val &= ~(BUS_CLK_DIV_MASK << c->reg_shift);
328                         val |= (i - 1) << c->reg_shift;
329                         clk_writel(val, c->reg);
330                         c->div = i;
331                         c->mul = 1;
332                         return 0;
333                 }
334         }
335         return -EINVAL;
336 }
337
338 static struct clk_ops tegra_bus_ops = {
339         .init                   = tegra2_bus_clk_init,
340         .enable                 = tegra2_bus_clk_enable,
341         .disable                = tegra2_bus_clk_disable,
342         .set_rate               = tegra2_bus_clk_set_rate,
343         .recalculate_rate       = tegra2_clk_recalculate_rate,
344 };
345
346 /* PLL Functions */
347 static unsigned long tegra2_pll_clk_recalculate_rate(struct clk *c)
348 {
349         u64 rate;
350         rate = c->parent->rate;
351         rate *= c->n;
352         do_div(rate, c->m);
353         if (c->p == 2)
354                 rate >>= 1;
355         c->rate = rate;
356         return c->rate;
357 }
358
359 static int tegra2_pll_clk_wait_for_lock(struct clk *c)
360 {
361         ktime_t before;
362
363         before = ktime_get();
364         while (!(clk_readl(c->reg + PLL_BASE) & PLL_BASE_LOCK)) {
365                 if (ktime_us_delta(ktime_get(), before) > 5000) {
366                         pr_err("Timed out waiting for lock bit on pll %s",
367                                 c->name);
368                         return -1;
369                 }
370         }
371
372         return 0;
373 }
374
375 static void tegra2_pll_clk_init(struct clk *c)
376 {
377         u32 val = clk_readl(c->reg + PLL_BASE);
378
379         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
380
381         if (c->flags & PLL_FIXED && !(val & PLL_BASE_OVERRIDE)) {
382                 pr_warning("Clock %s has unknown fixed frequency\n", c->name);
383                 c->n = 1;
384                 c->m = 0;
385                 c->p = 1;
386         } else if (val & PLL_BASE_BYPASS) {
387                 c->n = 1;
388                 c->m = 1;
389                 c->p = 1;
390         } else {
391                 c->n = (val & PLL_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
392                 c->m = (val & PLL_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
393                 c->p = (val & PLL_BASE_DIVP_MASK) ? 2 : 1;
394         }
395
396         val = clk_readl(c->reg + PLL_MISC(c));
397         if (c->flags & PLL_HAS_CPCON)
398                 c->cpcon = (val & PLL_MISC_CPCON_MASK) >> PLL_MISC_CPCON_SHIFT;
399
400         tegra2_pll_clk_recalculate_rate(c);
401 }
402
403 static int tegra2_pll_clk_enable(struct clk *c)
404 {
405         u32 val;
406         pr_debug("%s on clock %s\n", __func__, c->name);
407
408         val = clk_readl(c->reg + PLL_BASE);
409         val &= ~PLL_BASE_BYPASS;
410         val |= PLL_BASE_ENABLE;
411         clk_writel(val, c->reg + PLL_BASE);
412
413         val = clk_readl(c->reg + PLL_MISC(c));
414         val |= PLL_MISC_LOCK_ENABLE;
415         clk_writel(val, c->reg + PLL_MISC(c));
416
417         tegra2_pll_clk_wait_for_lock(c);
418
419         return 0;
420 }
421
422 static void tegra2_pll_clk_disable(struct clk *c)
423 {
424         u32 val;
425         pr_debug("%s on clock %s\n", __func__, c->name);
426
427         val = clk_readl(c->reg);
428         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
429         clk_writel(val, c->reg);
430 }
431
432 static int tegra2_pll_clk_set_rate(struct clk *c, unsigned long rate)
433 {
434         u32 val;
435         unsigned long input_rate;
436         const struct clk_pll_table *sel;
437
438         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
439         BUG_ON(c->refcnt != 0);
440
441         input_rate = c->parent->rate;
442         for (sel = c->pll_table; sel->input_rate != 0; sel++) {
443                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
444                         c->n = sel->n;
445                         c->m = sel->m;
446                         c->p = sel->p;
447                         c->cpcon = sel->cpcon;
448
449                         val = clk_readl(c->reg + PLL_BASE);
450                         if (c->flags & PLL_FIXED)
451                                 val |= PLL_BASE_OVERRIDE;
452                         val &= ~(PLL_BASE_DIVP_MASK | PLL_BASE_DIVN_MASK |
453                                  PLL_BASE_DIVM_MASK);
454                         val |= (c->m << PLL_BASE_DIVM_SHIFT) |
455                                 (c->n << PLL_BASE_DIVN_SHIFT);
456                         BUG_ON(c->p > 2);
457                         if (c->p == 2)
458                                 val |= 1 << PLL_BASE_DIVP_SHIFT;
459                         clk_writel(val, c->reg + PLL_BASE);
460
461                         if (c->flags & PLL_HAS_CPCON) {
462                                 val = c->cpcon << PLL_MISC_CPCON_SHIFT;
463                                 val |= PLL_MISC_LOCK_ENABLE;
464                                 clk_writel(val, c->reg + PLL_MISC(c));
465                         }
466
467                         if (c->state == ON)
468                                 tegra2_pll_clk_enable(c);
469
470                         c->rate = rate;
471                         return 0;
472                 }
473         }
474         return -EINVAL;
475 }
476
477 static struct clk_ops tegra_pll_ops = {
478         .init                   = tegra2_pll_clk_init,
479         .enable                 = tegra2_pll_clk_enable,
480         .disable                = tegra2_pll_clk_disable,
481         .set_rate               = tegra2_pll_clk_set_rate,
482         .recalculate_rate       = tegra2_pll_clk_recalculate_rate,
483 };
484
485 /* Clock divider ops */
486 static void tegra2_pll_div_clk_init(struct clk *c)
487 {
488         u32 val = clk_readl(c->reg);
489         u32 divu71;
490         val >>= c->reg_shift;
491         c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
492         if (!(val & PLL_OUT_RESET_DISABLE))
493                 c->state = OFF;
494
495         if (c->flags & DIV_U71) {
496                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
497                 c->div = (divu71 + 2);
498                 c->mul = 2;
499         } else if (c->flags & DIV_2) {
500                 c->div = 2;
501                 c->mul = 1;
502         } else {
503                 c->div = 1;
504                 c->mul = 1;
505         }
506
507         tegra2_clk_recalculate_rate(c);
508 }
509
510 static int tegra2_pll_div_clk_enable(struct clk *c)
511 {
512         u32 val;
513         u32 new_val;
514
515         pr_debug("%s: %s\n", __func__, c->name);
516         if (c->flags & DIV_U71) {
517                 val = clk_readl(c->reg);
518                 new_val = val >> c->reg_shift;
519                 new_val &= 0xFFFF;
520
521                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
522
523                 val &= ~(0xFFFF << c->reg_shift);
524                 val |= new_val << c->reg_shift;
525                 clk_writel(val, c->reg);
526                 return 0;
527         } else if (c->flags & DIV_2) {
528                 BUG_ON(!(c->flags & PLLD));
529                 val = clk_readl(c->reg);
530                 val &= ~PLLD_MISC_DIV_RST;
531                 clk_writel(val, c->reg);
532                 return 0;
533         }
534         return -EINVAL;
535 }
536
537 static void tegra2_pll_div_clk_disable(struct clk *c)
538 {
539         u32 val;
540         u32 new_val;
541
542         pr_debug("%s: %s\n", __func__, c->name);
543         if (c->flags & DIV_U71) {
544                 val = clk_readl(c->reg);
545                 new_val = val >> c->reg_shift;
546                 new_val &= 0xFFFF;
547
548                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
549
550                 val &= ~(0xFFFF << c->reg_shift);
551                 val |= new_val << c->reg_shift;
552                 clk_writel(val, c->reg);
553         } else if (c->flags & DIV_2) {
554                 BUG_ON(!(c->flags & PLLD));
555                 val = clk_readl(c->reg);
556                 val |= PLLD_MISC_DIV_RST;
557                 clk_writel(val, c->reg);
558         }
559 }
560
561 static int tegra2_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
562 {
563         u32 val;
564         u32 new_val;
565         int divider_u71;
566         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
567         if (c->flags & DIV_U71) {
568                 divider_u71 = clk_div71_get_divider(c->parent, rate);
569                 if (divider_u71 >= 0) {
570                         val = clk_readl(c->reg);
571                         new_val = val >> c->reg_shift;
572                         new_val &= 0xFFFF;
573                         if (c->flags & DIV_U71_FIXED)
574                                 new_val |= PLL_OUT_OVERRIDE;
575                         new_val &= ~PLL_OUT_RATIO_MASK;
576                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
577
578                         val &= ~(0xFFFF << c->reg_shift);
579                         val |= new_val << c->reg_shift;
580                         clk_writel(val, c->reg);
581                         c->div = divider_u71 + 2;
582                         c->mul = 2;
583                         tegra2_clk_recalculate_rate(c);
584                         return 0;
585                 }
586         } else if (c->flags & DIV_2) {
587                 if (c->parent->rate == rate * 2) {
588                         c->rate = rate;
589                         return 0;
590                 }
591         }
592         return -EINVAL;
593 }
594
595
596 static struct clk_ops tegra_pll_div_ops = {
597         .init                   = tegra2_pll_div_clk_init,
598         .enable                 = tegra2_pll_div_clk_enable,
599         .disable                = tegra2_pll_div_clk_disable,
600         .set_rate               = tegra2_pll_div_clk_set_rate,
601         .recalculate_rate       = tegra2_clk_recalculate_rate,
602 };
603
604 /* Periph clk ops */
605
606 static void tegra2_periph_clk_init(struct clk *c)
607 {
608         u32 val = clk_readl(c->reg);
609         const struct clk_mux_sel *mux = 0;
610         const struct clk_mux_sel *sel;
611         if (c->flags & MUX) {
612                 for (sel = c->inputs; sel->input != NULL; sel++) {
613                         if (val >> PERIPH_CLK_SOURCE_SHIFT == sel->value)
614                                 mux = sel;
615                 }
616                 BUG_ON(!mux);
617
618                 c->parent = mux->input;
619         } else {
620                 c->parent = c->inputs[0].input;
621         }
622
623         if (c->flags & DIV_U71) {
624                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIV_MASK;
625                 c->div = divu71 + 2;
626                 c->mul = 2;
627         } else {
628                 c->div = 1;
629                 c->mul = 1;
630         }
631
632         c->state = ON;
633         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
634                         PERIPH_CLK_TO_ENB_BIT(c)))
635                 c->state = OFF;
636         if (!(c->flags & PERIPH_NO_RESET))
637                 if (clk_readl(RST_DEVICES + PERIPH_CLK_TO_ENB_REG(c)) &
638                                 PERIPH_CLK_TO_ENB_BIT(c))
639                         c->state = OFF;
640         tegra2_clk_recalculate_rate(c);
641 }
642
643 static int tegra2_periph_clk_enable(struct clk *c)
644 {
645         u32 val;
646         pr_debug("%s on clock %s\n", __func__, c->name);
647
648         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
649                 CLK_OUT_ENB_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
650         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET))
651                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
652                         RST_DEVICES_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
653         if (c->flags & PERIPH_EMC_ENB) {
654                 /* The EMC peripheral clock has 2 extra enable bits */
655                 /* FIXME: Do they need to be disabled? */
656                 val = clk_readl(c->reg);
657                 val |= 0x3 << 24;
658                 clk_writel(val, c->reg);
659         }
660         return 0;
661 }
662
663 static void tegra2_periph_clk_disable(struct clk *c)
664 {
665         pr_debug("%s on clock %s\n", __func__, c->name);
666
667         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
668                 CLK_OUT_ENB_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
669 }
670
671 void tegra2_periph_reset_deassert(struct clk *c)
672 {
673         pr_debug("%s on clock %s\n", __func__, c->name);
674         if (!(c->flags & PERIPH_NO_RESET))
675                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
676                         RST_DEVICES_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
677 }
678
679 void tegra2_periph_reset_assert(struct clk *c)
680 {
681         pr_debug("%s on clock %s\n", __func__, c->name);
682         if (!(c->flags & PERIPH_NO_RESET))
683                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
684                         RST_DEVICES_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
685 }
686
687
688 static int tegra2_periph_clk_set_parent(struct clk *c, struct clk *p)
689 {
690         u32 val;
691         const struct clk_mux_sel *sel;
692         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
693         for (sel = c->inputs; sel->input != NULL; sel++) {
694                 if (sel->input == p) {
695                         clk_reparent(c, p);
696                         val = clk_readl(c->reg);
697                         val &= ~PERIPH_CLK_SOURCE_MASK;
698                         val |= (sel->value) << PERIPH_CLK_SOURCE_SHIFT;
699                         clk_writel(val, c->reg);
700                         c->rate = c->parent->rate;
701                         return 0;
702                 }
703         }
704
705         return -EINVAL;
706 }
707
708 static int tegra2_periph_clk_set_rate(struct clk *c, unsigned long rate)
709 {
710         u32 val;
711         int divider_u71;
712         pr_debug("%s: %lu\n", __func__, rate);
713         if (c->flags & DIV_U71) {
714                 divider_u71 = clk_div71_get_divider(c->parent, rate);
715                 if (divider_u71 >= 0) {
716                         val = clk_readl(c->reg);
717                         val &= ~PERIPH_CLK_SOURCE_DIV_MASK;
718                         val |= divider_u71;
719                         clk_writel(val, c->reg);
720                         c->div = divider_u71 + 2;
721                         c->mul = 2;
722                         tegra2_clk_recalculate_rate(c);
723                         return 0;
724                 }
725         }
726         return -EINVAL;
727 }
728
729 static struct clk_ops tegra_periph_clk_ops = {
730         .init                   = &tegra2_periph_clk_init,
731         .enable                 = &tegra2_periph_clk_enable,
732         .disable                = &tegra2_periph_clk_disable,
733         .set_parent             = &tegra2_periph_clk_set_parent,
734         .set_rate               = &tegra2_periph_clk_set_rate,
735         .recalculate_rate       = &tegra2_clk_recalculate_rate,
736 };
737
738 /* Clock doubler ops */
739 static void tegra2_clk_double_init(struct clk *c)
740 {
741         c->mul = 2;
742         c->div = 1;
743         c->state = ON;
744         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
745                         PERIPH_CLK_TO_ENB_BIT(c)))
746                 c->state = OFF;
747         tegra2_clk_recalculate_rate(c);
748 };
749
750 static struct clk_ops tegra_clk_double_ops = {
751         .init                   = &tegra2_clk_double_init,
752         .enable                 = &tegra2_periph_clk_enable,
753         .disable                = &tegra2_periph_clk_disable,
754         .recalculate_rate       = &tegra2_clk_recalculate_rate,
755 };
756
757 /* Clock definitions */
758 static struct clk tegra_clk_32k = {
759         .name = "clk_32k",
760         .rate = 32678,
761         .ops  = NULL,
762 };
763
764 static struct clk_pll_table tegra_pll_s_table[] = {
765         {32768, 12000000, 366, 1, 1, 0},
766         {32768, 13000000, 397, 1, 1, 0},
767         {32768, 19200000, 586, 1, 1, 0},
768         {32768, 26000000, 793, 1, 1, 0},
769         {0, 0, 0, 0, 0, 0},
770 };
771
772 static struct clk tegra_pll_s = {
773         .name      = "pll_s",
774         .flags     = PLL_ALT_MISC_REG,
775         .ops       = &tegra_pll_ops,
776         .reg       = 0xf0,
777         .input_min = 32768,
778         .input_max = 32768,
779         .parent    = &tegra_clk_32k,
780         .cf_min    = 0, /* FIXME */
781         .cf_max    = 0, /* FIXME */
782         .vco_min   = 12000000,
783         .vco_max   = 26000000,
784         .pll_table = tegra_pll_s_table,
785 };
786
787 static struct clk_mux_sel tegra_clk_m_sel[] = {
788         { .input = &tegra_clk_32k, .value = 0},
789         { .input = &tegra_pll_s,  .value = 1},
790         { 0, 0},
791 };
792 static struct clk tegra_clk_m = {
793         .name      = "clk_m",
794         .flags     = ENABLE_ON_INIT,
795         .ops       = &tegra_clk_m_ops,
796         .inputs    = tegra_clk_m_sel,
797         .reg       = 0x1fc,
798         .reg_mask  = (1<<28),
799         .reg_shift = 28,
800 };
801
802 static struct clk_pll_table tegra_pll_c_table[] = {
803         { 0, 0, 0, 0, 0, 0 },
804 };
805
806 static struct clk tegra_pll_c = {
807         .name      = "pll_c",
808         .flags     = PLL_HAS_CPCON,
809         .ops       = &tegra_pll_ops,
810         .reg       = 0x80,
811         .input_min = 2000000,
812         .input_max = 31000000,
813         .parent    = &tegra_clk_m,
814         .cf_min    = 1000000,
815         .cf_max    = 6000000,
816         .vco_min   = 20000000,
817         .vco_max   = 1400000000,
818         .pll_table = tegra_pll_c_table,
819 };
820
821 static struct clk tegra_pll_c_out1 = {
822         .name      = "pll_c_out1",
823         .ops       = &tegra_pll_div_ops,
824         .flags     = DIV_U71,
825         .parent    = &tegra_pll_c,
826         .reg       = 0x84,
827         .reg_shift = 0,
828 };
829
830 static struct clk_pll_table tegra_pll_m_table[] = {
831         { 0, 0, 0, 0, 0, 0 },
832 };
833
834 static struct clk tegra_pll_m = {
835         .name      = "pll_m",
836         .flags     = PLL_HAS_CPCON,
837         .ops       = &tegra_pll_ops,
838         .reg       = 0x90,
839         .input_min = 2000000,
840         .input_max = 31000000,
841         .parent    = &tegra_clk_m,
842         .cf_min    = 1000000,
843         .cf_max    = 6000000,
844         .vco_min   = 20000000,
845         .vco_max   = 1200000000,
846         .pll_table = tegra_pll_m_table,
847 };
848
849 static struct clk tegra_pll_m_out1 = {
850         .name      = "pll_m_out1",
851         .ops       = &tegra_pll_div_ops,
852         .flags     = DIV_U71,
853         .parent    = &tegra_pll_m,
854         .reg       = 0x94,
855         .reg_shift = 0,
856 };
857
858 static struct clk_pll_table tegra_pll_p_table[] = {
859         { 12000000, 216000000, 432, 12, 2, 8},
860         { 13000000, 216000000, 432, 13, 2, 8},
861         { 19200000, 216000000, 90,   4, 2, 1},
862         { 26000000, 216000000, 432, 26, 2, 8},
863         { 12000000, 432000000, 432, 12, 1, 8},
864         { 13000000, 432000000, 432, 13, 1, 8},
865         { 19200000, 432000000, 90,   4, 1, 1},
866         { 26000000, 432000000, 432, 26, 1, 8},
867         { 0, 0, 0, 0, 0, 0 },
868 };
869
870 static struct clk tegra_pll_p = {
871         .name      = "pll_p",
872         .flags     = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
873         .ops       = &tegra_pll_ops,
874         .reg       = 0xa0,
875         .input_min = 2000000,
876         .input_max = 31000000,
877         .parent    = &tegra_clk_m,
878         .cf_min    = 1000000,
879         .cf_max    = 6000000,
880         .vco_min   = 20000000,
881         .vco_max   = 1400000000,
882         .pll_table = tegra_pll_p_table,
883 };
884
885 static struct clk tegra_pll_p_out1 = {
886         .name      = "pll_p_out1",
887         .ops       = &tegra_pll_div_ops,
888         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
889         .parent    = &tegra_pll_p,
890         .reg       = 0xa4,
891         .reg_shift = 0,
892 };
893
894 static struct clk tegra_pll_p_out2 = {
895         .name      = "pll_p_out2",
896         .ops       = &tegra_pll_div_ops,
897         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
898         .parent    = &tegra_pll_p,
899         .reg       = 0xa4,
900         .reg_shift = 16,
901 };
902
903 static struct clk tegra_pll_p_out3 = {
904         .name      = "pll_p_out3",
905         .ops       = &tegra_pll_div_ops,
906         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
907         .parent    = &tegra_pll_p,
908         .reg       = 0xa8,
909         .reg_shift = 0,
910 };
911
912 static struct clk tegra_pll_p_out4 = {
913         .name      = "pll_p_out4",
914         .ops       = &tegra_pll_div_ops,
915         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
916         .parent    = &tegra_pll_p,
917         .reg       = 0xa8,
918         .reg_shift = 16,
919 };
920
921 static struct clk_pll_table tegra_pll_a_table[] = {
922         { 28800000, 56448000, 49, 25, 1, 1},
923         { 28800000, 73728000, 64, 25, 1, 1},
924         { 28800000, 11289600, 49, 25, 1, 1},
925         { 28800000, 12288000, 64, 25, 1, 1},
926         { 0, 0, 0, 0, 0, 0 },
927 };
928
929 static struct clk tegra_pll_a = {
930         .name      = "pll_a",
931         .flags     = PLL_HAS_CPCON,
932         .ops       = &tegra_pll_ops,
933         .reg       = 0xb0,
934         .input_min = 2000000,
935         .input_max = 31000000,
936         .parent    = &tegra_pll_p_out1,
937         .cf_min    = 1000000,
938         .cf_max    = 6000000,
939         .vco_min   = 20000000,
940         .vco_max   = 1400000000,
941         .pll_table = tegra_pll_a_table,
942 };
943
944 static struct clk tegra_pll_a_out0 = {
945         .name      = "pll_a_out0",
946         .ops       = &tegra_pll_div_ops,
947         .flags     = DIV_U71,
948         .parent    = &tegra_pll_a,
949         .reg       = 0xb4,
950         .reg_shift = 0,
951 };
952
953 static struct clk_pll_table tegra_pll_d_table[] = {
954         { 12000000, 1000000000, 1000, 12, 1, 12},
955         { 13000000, 1000000000, 1000, 13, 1, 12},
956         { 19200000, 1000000000, 625,  12, 1, 8},
957         { 26000000, 1000000000, 1000, 26, 1, 12},
958         { 0, 0, 0, 0, 0, 0 },
959 };
960
961 static struct clk tegra_pll_d = {
962         .name      = "pll_d",
963         .flags     = PLL_HAS_CPCON | PLLD,
964         .ops       = &tegra_pll_ops,
965         .reg       = 0xd0,
966         .input_min = 2000000,
967         .input_max = 40000000,
968         .parent    = &tegra_clk_m,
969         .cf_min    = 1000000,
970         .cf_max    = 6000000,
971         .vco_min   = 40000000,
972         .vco_max   = 1000000000,
973         .pll_table = tegra_pll_d_table,
974 };
975
976 static struct clk tegra_pll_d_out0 = {
977         .name      = "pll_d_out0",
978         .ops       = &tegra_pll_div_ops,
979         .flags     = DIV_2 | PLLD,
980         .parent    = &tegra_pll_d,
981 };
982
983 static struct clk_pll_table tegra_pll_u_table[] = {
984         { 12000000, 480000000, 960, 12, 1, 0},
985         { 13000000, 480000000, 960, 13, 1, 0},
986         { 19200000, 480000000, 200, 4,  1, 0},
987         { 26000000, 480000000, 960, 26, 1, 0},
988         { 0, 0, 0, 0, 0, 0 },
989 };
990
991 static struct clk tegra_pll_u = {
992         .name      = "pll_u",
993         .flags     = 0,
994         .ops       = &tegra_pll_ops,
995         .reg       = 0xc0,
996         .input_min = 2000000,
997         .input_max = 40000000,
998         .parent    = &tegra_clk_m,
999         .cf_min    = 1000000,
1000         .cf_max    = 6000000,
1001         .vco_min   = 480000000,
1002         .vco_max   = 960000000,
1003         .pll_table = tegra_pll_u_table,
1004 };
1005
1006 static struct clk_pll_table tegra_pll_x_table[] = {
1007         { 12000000, 1000000000, 1000, 12, 1, 12},
1008         { 13000000, 1000000000, 1000, 13, 1, 12},
1009         { 19200000, 1000000000, 625,  12, 1, 8},
1010         { 26000000, 1000000000, 1000, 26, 1, 12},
1011         { 12000000, 750000000,  750,  12, 1, 12},
1012         { 13000000, 750000000,  750,  13, 1, 12},
1013         { 19200000, 750000000,  625,  16, 1, 8},
1014         { 26000000, 750000000,  750,  26, 1, 12},
1015         { 0, 0, 0, 0, 0, 0 },
1016 };
1017
1018 static struct clk tegra_pll_x = {
1019         .name      = "pll_x",
1020         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG,
1021         .ops       = &tegra_pll_ops,
1022         .reg       = 0xe0,
1023         .input_min = 2000000,
1024         .input_max = 31000000,
1025         .parent    = &tegra_clk_m,
1026         .cf_min    = 1000000,
1027         .cf_max    = 6000000,
1028         .vco_min   = 20000000,
1029         .vco_max   = 1200000000,
1030         .pll_table = tegra_pll_x_table,
1031 };
1032
1033 static struct clk tegra_clk_d = {
1034         .name      = "clk_d",
1035         .flags     = PERIPH_NO_RESET,
1036         .ops       = &tegra_clk_double_ops,
1037         .clk_num   = 90,
1038         .reg       = 0x34,
1039         .reg_shift = 12,
1040         .parent    = &tegra_clk_m,
1041 };
1042
1043 /* FIXME: need tegra_audio
1044 static struct clk tegra_clk_audio_2x = {
1045         .name      = "clk_d",
1046         .flags     = PERIPH_NO_RESET,
1047         .ops       = &tegra_clk_double_ops,
1048         .clk_num   = 89,
1049         .reg       = 0x34,
1050         .reg_shift = 8,
1051         .parent    = &tegra_audio,
1052 }
1053 */
1054
1055 static struct clk_mux_sel mux_cclk[] = {
1056         { .input = &tegra_clk_m,        .value = 0},
1057         { .input = &tegra_pll_c,        .value = 1},
1058         { .input = &tegra_clk_32k,      .value = 2},
1059         { .input = &tegra_pll_m,        .value = 3},
1060         { .input = &tegra_pll_p,        .value = 4},
1061         { .input = &tegra_pll_p_out4,   .value = 5},
1062         { .input = &tegra_pll_p_out3,   .value = 6},
1063         { .input = &tegra_clk_d,        .value = 7},
1064         { .input = &tegra_pll_x,        .value = 8},
1065         { 0, 0},
1066 };
1067
1068 static struct clk_mux_sel mux_sclk[] = {
1069         { .input = &tegra_clk_m,        .value = 0},
1070         { .input = &tegra_pll_c_out1,   .value = 1},
1071         { .input = &tegra_pll_p_out4,   .value = 2},
1072         { .input = &tegra_pll_p_out3,   .value = 3},
1073         { .input = &tegra_pll_p_out2,   .value = 4},
1074         { .input = &tegra_clk_d,        .value = 5},
1075         { .input = &tegra_clk_32k,      .value = 6},
1076         { .input = &tegra_pll_m_out1,   .value = 7},
1077         { 0, 0},
1078 };
1079
1080 static struct clk tegra_clk_cpu = {
1081         .name   = "cpu",
1082         .inputs = mux_cclk,
1083         .reg    = 0x20,
1084         .ops    = &tegra_super_ops,
1085 };
1086
1087 static struct clk tegra_clk_sys = {
1088         .name   = "sys",
1089         .inputs = mux_sclk,
1090         .reg    = 0x28,
1091         .ops    = &tegra_super_ops,
1092 };
1093
1094 static struct clk tegra_clk_hclk = {
1095         .name           = "hclk",
1096         .flags          = DIV_BUS,
1097         .parent         = &tegra_clk_sys,
1098         .reg            = 0x30,
1099         .reg_shift      = 4,
1100         .ops            = &tegra_bus_ops,
1101 };
1102
1103 static struct clk tegra_clk_pclk = {
1104         .name           = "pclk",
1105         .flags          = DIV_BUS,
1106         .parent         = &tegra_clk_hclk,
1107         .reg            = 0x30,
1108         .reg_shift      = 0,
1109         .ops            = &tegra_bus_ops,
1110 };
1111
1112 static struct clk_mux_sel mux_pllm_pllc_pllp_plla[] = {
1113         { .input = &tegra_pll_m, .value = 0},
1114         { .input = &tegra_pll_c, .value = 1},
1115         { .input = &tegra_pll_p, .value = 2},
1116         { .input = &tegra_pll_a_out0, .value = 3},
1117         { 0, 0},
1118 };
1119
1120 static struct clk_mux_sel mux_pllm_pllc_pllp_clkm[] = {
1121         { .input = &tegra_pll_m, .value = 0},
1122         { .input = &tegra_pll_c, .value = 1},
1123         { .input = &tegra_pll_p, .value = 2},
1124         { .input = &tegra_clk_m, .value = 3},
1125         { 0, 0},
1126 };
1127
1128 static struct clk_mux_sel mux_pllp_pllc_pllm_clkm[] = {
1129         { .input = &tegra_pll_p, .value = 0},
1130         { .input = &tegra_pll_c, .value = 1},
1131         { .input = &tegra_pll_m, .value = 2},
1132         { .input = &tegra_clk_m, .value = 3},
1133         { 0, 0},
1134 };
1135
1136 static struct clk_mux_sel mux_plla_audio_pllp_clkm[] = {
1137         {.input = &tegra_pll_a, .value = 0},
1138         /* FIXME: no mux defined for tegra_audio
1139         {.input = &tegra_audio, .value = 1},*/
1140         {.input = &tegra_pll_p, .value = 2},
1141         {.input = &tegra_clk_m, .value = 3},
1142         { 0, 0},
1143 };
1144
1145 static struct clk_mux_sel mux_pllp_plld_pllc_clkm[] = {
1146         {.input = &tegra_pll_p, .value = 0},
1147         {.input = &tegra_pll_d_out0, .value = 1},
1148         {.input = &tegra_pll_c, .value = 2},
1149         {.input = &tegra_clk_m, .value = 3},
1150         { 0, 0},
1151 };
1152
1153 static struct clk_mux_sel mux_pllp_pllc_audio_clkm_clk32[] = {
1154         {.input = &tegra_pll_p,     .value = 0},
1155         {.input = &tegra_pll_c,     .value = 1},
1156         /* FIXME: no mux defined for tegra_audio
1157         {.input = &tegra_audio,     .value = 2},*/
1158         {.input = &tegra_clk_m,     .value = 3},
1159         {.input = &tegra_clk_32k,   .value = 4},
1160         { 0, 0},
1161 };
1162
1163 static struct clk_mux_sel mux_pllp_pllc_pllm[] = {
1164         {.input = &tegra_pll_p,     .value = 0},
1165         {.input = &tegra_pll_c,     .value = 1},
1166         {.input = &tegra_pll_m,     .value = 2},
1167         { 0, 0},
1168 };
1169
1170 static struct clk_mux_sel mux_clk_m[] = {
1171         { .input = &tegra_clk_m, .value = 0},
1172         { 0, 0},
1173 };
1174
1175 static struct clk_mux_sel mux_pllp_out3[] = {
1176         { .input = &tegra_pll_p_out3, .value = 0},
1177         { 0, 0},
1178 };
1179
1180 static struct clk_mux_sel mux_plld[] = {
1181         { .input = &tegra_pll_d, .value = 0},
1182         { 0, 0},
1183 };
1184
1185 static struct clk_mux_sel mux_clk_32k[] = {
1186         { .input = &tegra_clk_32k, .value = 0},
1187         { 0, 0},
1188 };
1189
1190 #define PERIPH_CLK(_name, _dev, _con, _clk_num, _reg, _inputs, _flags) \
1191         {                                               \
1192                 .name      = _name,                     \
1193                 .lookup    = {                          \
1194                         .dev_id    = _dev,              \
1195                         .con_id    = _con,              \
1196                 },                                      \
1197                 .ops       = &tegra_periph_clk_ops,     \
1198                 .clk_num   = _clk_num,                  \
1199                 .reg       = _reg,                      \
1200                 .inputs    = _inputs,                   \
1201                 .flags     = _flags,                    \
1202         }
1203
1204 struct clk tegra_periph_clks[] = {
1205         PERIPH_CLK("rtc",       "rtc-tegra",            NULL,   4,      0,      mux_clk_32k,                    PERIPH_NO_RESET),
1206         PERIPH_CLK("timer",     "timer",                NULL,   5,      0,      mux_clk_m,                      0),
1207         PERIPH_CLK("i2s1",      "i2s.0",                NULL,   11,     0x100,  mux_plla_audio_pllp_clkm,       MUX | DIV_U71),
1208         PERIPH_CLK("i2s2",      "i2s.1",                NULL,   18,     0x104,  mux_plla_audio_pllp_clkm,       MUX | DIV_U71),
1209         /* FIXME: spdif has 2 clocks but 1 enable */
1210         PERIPH_CLK("spdif_out", "spdif_out",            NULL,   10,     0x108,  mux_plla_audio_pllp_clkm,       MUX | DIV_U71),
1211         PERIPH_CLK("spdif_in",  "spdif_in",             NULL,   10,     0x10c,  mux_pllp_pllc_pllm,             MUX | DIV_U71),
1212         PERIPH_CLK("pwm",       "pwm",                  NULL,   17,     0x110,  mux_pllp_pllc_audio_clkm_clk32, MUX | DIV_U71),
1213         PERIPH_CLK("spi",       "spi",                  NULL,   43,     0x114,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1214         PERIPH_CLK("xio",       "xio",                  NULL,   45,     0x120,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1215         PERIPH_CLK("twc",       "twc",                  NULL,   16,     0x12c,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1216         PERIPH_CLK("sbc1",      "spi_tegra.0",          NULL,   41,     0x134,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1217         PERIPH_CLK("sbc2",      "spi_tegra.1",          NULL,   44,     0x118,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1218         PERIPH_CLK("sbc3",      "spi_tegra.2",          NULL,   46,     0x11c,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1219         PERIPH_CLK("sbc4",      "spi_tegra.3",          NULL,   68,     0x1b4,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1220         PERIPH_CLK("ide",       "ide",                  NULL,   25,     0x144,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1221         PERIPH_CLK("ndflash",   "tegra_nand",           NULL,   13,     0x160,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1222         /* FIXME: vfir shares an enable with uartb */
1223         PERIPH_CLK("vfir",      "vfir",                 NULL,   7,      0x168,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1224         PERIPH_CLK("sdmmc1",    "sdhci-tegra.0",        NULL,   14,     0x150,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1225         PERIPH_CLK("sdmmc2",    "sdhci-tegra.1",        NULL,   9,      0x154,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1226         PERIPH_CLK("sdmmc3",    "sdhci-tegra.2",        NULL,   69,     0x1bc,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1227         PERIPH_CLK("sdmmc4",    "sdhci-tegra.3",        NULL,   15,     0x160,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1228         PERIPH_CLK("vde",       "vde",                  NULL,   61,     0x1c8,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1229         PERIPH_CLK("csite",     "csite",                NULL,   73,     0x1d4,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1230         /* FIXME: what is la? */
1231         PERIPH_CLK("la",        "la",                   NULL,   76,     0x1f8,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1232         PERIPH_CLK("owr",       "owr",                  NULL,   71,     0x1cc,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1233         PERIPH_CLK("nor",       "nor",                  NULL,   42,     0x1d0,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1234         PERIPH_CLK("mipi",      "mipi",                 NULL,   50,     0x174,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1235         PERIPH_CLK("i2c1",      "tegra-i2c.0",          NULL,   12,     0x124,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1236         PERIPH_CLK("i2c2",      "tegra-i2c.1",          NULL,   54,     0x198,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1237         PERIPH_CLK("i2c3",      "tegra-i2c.2",          NULL,   67,     0x1b8,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1238         PERIPH_CLK("dvc",       "tegra-i2c.3",          NULL,   47,     0x128,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1239         PERIPH_CLK("i2c1_i2c",  "tegra-i2c.0",          "i2c",  0,      0,      mux_pllp_out3,                  0),
1240         PERIPH_CLK("i2c2_i2c",  "tegra-i2c.1",          "i2c",  0,      0,      mux_pllp_out3,                  0),
1241         PERIPH_CLK("i2c3_i2c",  "tegra-i2c.2",          "i2c",  0,      0,      mux_pllp_out3,                  0),
1242         PERIPH_CLK("dvc_i2c",   "tegra-i2c.3",          "i2c",  0,      0,      mux_pllp_out3,                  0),
1243         PERIPH_CLK("uarta",     "uart.0",               NULL,   6,      0x178,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1244         PERIPH_CLK("uartb",     "uart.1",               NULL,   7,      0x17c,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1245         PERIPH_CLK("uartc",     "uart.2",               NULL,   55,     0x1a0,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1246         PERIPH_CLK("uartd",     "uart.3",               NULL,   65,     0x1c0,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1247         PERIPH_CLK("uarte",     "uart.4",               NULL,   66,     0x1c4,  mux_pllp_pllc_pllm_clkm,        MUX | DIV_U71),
1248         PERIPH_CLK("3d",        "3d",                   NULL,   24,     0x158,  mux_pllm_pllc_pllp_plla,        MUX | DIV_U71 | PERIPH_MANUAL_RESET),
1249         PERIPH_CLK("2d",        "2d",                   NULL,   21,     0x15c,  mux_pllm_pllc_pllp_plla,        MUX | DIV_U71),
1250         /* FIXME: vi and vi_sensor share an enable */
1251         PERIPH_CLK("vi",        "vi",                   NULL,   20,     0x148,  mux_pllm_pllc_pllp_plla,        MUX | DIV_U71),
1252         PERIPH_CLK("vi_sensor", "vi_sensor",            NULL,   20,     0x1a8,  mux_pllm_pllc_pllp_plla,        MUX | DIV_U71),
1253         PERIPH_CLK("epp",       "epp",                  NULL,   19,     0x16c,  mux_pllm_pllc_pllp_plla,        MUX | DIV_U71),
1254         PERIPH_CLK("mpe",       "mpe",                  NULL,   60,     0x170,  mux_pllm_pllc_pllp_plla,        MUX | DIV_U71),
1255         PERIPH_CLK("host1x",    "host1x",               NULL,   28,     0x180,  mux_pllm_pllc_pllp_plla,        MUX | DIV_U71),
1256         /* FIXME: cve and tvo share an enable   */
1257         PERIPH_CLK("cve",       "cve",                  NULL,   49,     0x140,  mux_pllp_plld_pllc_clkm,        MUX | DIV_U71),
1258         PERIPH_CLK("tvo",       "tvo",                  NULL,   49,     0x188,  mux_pllp_plld_pllc_clkm,        MUX | DIV_U71),
1259         PERIPH_CLK("hdmi",      "hdmi",                 NULL,   51,     0x18c,  mux_pllp_plld_pllc_clkm,        MUX | DIV_U71),
1260         PERIPH_CLK("tvdac",     "tvdac",                NULL,   53,     0x194,  mux_pllp_plld_pllc_clkm,        MUX | DIV_U71),
1261         PERIPH_CLK("disp1",     "tegrafb.0",            NULL,   27,     0x138,  mux_pllp_plld_pllc_clkm,        MUX | DIV_U71),
1262         PERIPH_CLK("disp2",     "tegrafb.1",            NULL,   26,     0x13c,  mux_pllp_plld_pllc_clkm,        MUX | DIV_U71),
1263         PERIPH_CLK("usbd",      "fsl-tegra-udc",        NULL,   22,     0,      mux_clk_m,                      0),
1264         PERIPH_CLK("usb2",      "usb.1",                NULL,   58,     0,      mux_clk_m,                      0),
1265         PERIPH_CLK("usb3",      "usb.2",                NULL,   59,     0,      mux_clk_m,                      0),
1266         PERIPH_CLK("emc",       "emc",                  NULL,   57,     0x19c,  mux_pllm_pllc_pllp_clkm,        MUX | DIV_U71 | PERIPH_EMC_ENB),
1267         PERIPH_CLK("dsi",       "dsi",                  NULL,   48,     0,      mux_plld,                       0),
1268 };
1269
1270 #define CLK_DUPLICATE(_name, _dev, _con)                \
1271         {                                               \
1272                 .name   = _name,                        \
1273                 .lookup = {                             \
1274                         .dev_id = _dev,                 \
1275                         .con_id         = _con,         \
1276                 },                                      \
1277         }
1278
1279 /* Some clocks may be used by different drivers depending on the board
1280  * configuration.  List those here to register them twice in the clock lookup
1281  * table under two names.
1282  */
1283 struct clk_duplicate tegra_clk_duplicates[] = {
1284         CLK_DUPLICATE("uarta",  "tegra_uart.0", NULL),
1285         CLK_DUPLICATE("uartb",  "tegra_uart.1", NULL),
1286         CLK_DUPLICATE("uartc",  "tegra_uart.2", NULL),
1287         CLK_DUPLICATE("uartd",  "tegra_uart.3", NULL),
1288         CLK_DUPLICATE("uarte",  "tegra_uart.4", NULL),
1289 };
1290
1291 #define CLK(dev, con, ck)       \
1292         {                       \
1293                 .dev_id = dev,  \
1294                 .con_id = con,  \
1295                 .clk = ck,      \
1296         }
1297
1298 struct clk_lookup tegra_clk_lookups[] = {
1299         /* external root sources */
1300         CLK(NULL,       "32k_clk",      &tegra_clk_32k),
1301         CLK(NULL,       "pll_s",        &tegra_pll_s),
1302         CLK(NULL,       "clk_m",        &tegra_clk_m),
1303         CLK(NULL,       "pll_m",        &tegra_pll_m),
1304         CLK(NULL,       "pll_m_out1",   &tegra_pll_m_out1),
1305         CLK(NULL,       "pll_c",        &tegra_pll_c),
1306         CLK(NULL,       "pll_c_out1",   &tegra_pll_c_out1),
1307         CLK(NULL,       "pll_p",        &tegra_pll_p),
1308         CLK(NULL,       "pll_p_out1",   &tegra_pll_p_out1),
1309         CLK(NULL,       "pll_p_out2",   &tegra_pll_p_out2),
1310         CLK(NULL,       "pll_p_out3",   &tegra_pll_p_out3),
1311         CLK(NULL,       "pll_p_out4",   &tegra_pll_p_out4),
1312         CLK(NULL,       "pll_a",        &tegra_pll_a),
1313         CLK(NULL,       "pll_a_out0",   &tegra_pll_a_out0),
1314         CLK(NULL,       "pll_d",        &tegra_pll_d),
1315         CLK(NULL,       "pll_d_out0",   &tegra_pll_d_out0),
1316         CLK(NULL,       "pll_u",        &tegra_pll_u),
1317         CLK(NULL,       "pll_x",        &tegra_pll_x),
1318         CLK(NULL,       "cpu",          &tegra_clk_cpu),
1319         CLK(NULL,       "sys",          &tegra_clk_sys),
1320         CLK(NULL,       "hclk",         &tegra_clk_hclk),
1321         CLK(NULL,       "pclk",         &tegra_clk_pclk),
1322         CLK(NULL,       "clk_d",        &tegra_clk_d),
1323 };
1324
1325 void __init tegra2_init_clocks(void)
1326 {
1327         int i;
1328         struct clk_lookup *cl;
1329         struct clk *c;
1330         struct clk_duplicate *cd;
1331
1332         for (i = 0; i < ARRAY_SIZE(tegra_clk_lookups); i++) {
1333                 cl = &tegra_clk_lookups[i];
1334                 clk_init(cl->clk);
1335                 clkdev_add(cl);
1336         }
1337
1338         for (i = 0; i < ARRAY_SIZE(tegra_periph_clks); i++) {
1339                 c = &tegra_periph_clks[i];
1340                 cl = &c->lookup;
1341                 cl->clk = c;
1342
1343                 clk_init(cl->clk);
1344                 clkdev_add(cl);
1345         }
1346
1347         for (i = 0; i < ARRAY_SIZE(tegra_clk_duplicates); i++) {
1348                 cd = &tegra_clk_duplicates[i];
1349                 c = tegra_get_clock_by_name(cd->name);
1350                 if (c) {
1351                         cl = &cd->lookup;
1352                         cl->clk = c;
1353                         clkdev_add(cl);
1354                 } else {
1355                         pr_err("%s: Unknown duplicate clock %s\n", __func__,
1356                                 cd->name);
1357                 }
1358         }
1359 }