[ARM/tegra] Add Tegra3 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/clkdev.h>
27 #include <linux/clk.h>
28 #include <linux/syscore_ops.h>
29 #include <linux/cpufreq.h>
30
31 #include <mach/iomap.h>
32 #include <mach/pinmux.h>
33
34 #include "clock.h"
35 #include "fuse.h"
36 #include "tegra2_emc.h"
37
38 #define RST_DEVICES                     0x004
39 #define RST_DEVICES_SET                 0x300
40 #define RST_DEVICES_CLR                 0x304
41 #define RST_DEVICES_NUM                 3
42
43 #define CLK_OUT_ENB                     0x010
44 #define CLK_OUT_ENB_SET                 0x320
45 #define CLK_OUT_ENB_CLR                 0x324
46 #define CLK_OUT_ENB_NUM                 3
47
48 #define CLK_MASK_ARM                    0x44
49 #define MISC_CLK_ENB                    0x48
50
51 #define OSC_CTRL                        0x50
52 #define OSC_CTRL_OSC_FREQ_MASK          (3<<30)
53 #define OSC_CTRL_OSC_FREQ_13MHZ         (0<<30)
54 #define OSC_CTRL_OSC_FREQ_19_2MHZ       (1<<30)
55 #define OSC_CTRL_OSC_FREQ_12MHZ         (2<<30)
56 #define OSC_CTRL_OSC_FREQ_26MHZ         (3<<30)
57 #define OSC_CTRL_MASK                   (0x3f2 | OSC_CTRL_OSC_FREQ_MASK)
58
59 #define OSC_FREQ_DET                    0x58
60 #define OSC_FREQ_DET_TRIG               (1<<31)
61
62 #define OSC_FREQ_DET_STATUS             0x5C
63 #define OSC_FREQ_DET_BUSY               (1<<31)
64 #define OSC_FREQ_DET_CNT_MASK           0xFFFF
65
66 #define PERIPH_CLK_SOURCE_I2S1          0x100
67 #define PERIPH_CLK_SOURCE_EMC           0x19c
68 #define PERIPH_CLK_SOURCE_OSC           0x1fc
69 #define PERIPH_CLK_SOURCE_NUM \
70         ((PERIPH_CLK_SOURCE_OSC - PERIPH_CLK_SOURCE_I2S1) / 4)
71
72 #define PERIPH_CLK_SOURCE_MASK          (3<<30)
73 #define PERIPH_CLK_SOURCE_SHIFT         30
74 #define PERIPH_CLK_SOURCE_ENABLE        (1<<28)
75 #define PERIPH_CLK_SOURCE_DIVU71_MASK   0xFF
76 #define PERIPH_CLK_SOURCE_DIVU16_MASK   0xFFFF
77 #define PERIPH_CLK_SOURCE_DIV_SHIFT     0
78
79 #define SDMMC_CLK_INT_FB_SEL            (1 << 23)
80 #define SDMMC_CLK_INT_FB_DLY_SHIFT      16
81 #define SDMMC_CLK_INT_FB_DLY_MASK       (0xF << SDMMC_CLK_INT_FB_DLY_SHIFT)
82
83 #define PLL_BASE                        0x0
84 #define PLL_BASE_BYPASS                 (1<<31)
85 #define PLL_BASE_ENABLE                 (1<<30)
86 #define PLL_BASE_REF_ENABLE             (1<<29)
87 #define PLL_BASE_OVERRIDE               (1<<28)
88 #define PLL_BASE_DIVP_MASK              (0x7<<20)
89 #define PLL_BASE_DIVP_SHIFT             20
90 #define PLL_BASE_DIVN_MASK              (0x3FF<<8)
91 #define PLL_BASE_DIVN_SHIFT             8
92 #define PLL_BASE_DIVM_MASK              (0x1F)
93 #define PLL_BASE_DIVM_SHIFT             0
94
95 #define PLL_OUT_RATIO_MASK              (0xFF<<8)
96 #define PLL_OUT_RATIO_SHIFT             8
97 #define PLL_OUT_OVERRIDE                (1<<2)
98 #define PLL_OUT_CLKEN                   (1<<1)
99 #define PLL_OUT_RESET_DISABLE           (1<<0)
100
101 #define PLL_MISC(c)                     (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
102
103 #define PLL_MISC_DCCON_SHIFT            20
104 #define PLL_MISC_CPCON_SHIFT            8
105 #define PLL_MISC_CPCON_MASK             (0xF<<PLL_MISC_CPCON_SHIFT)
106 #define PLL_MISC_LFCON_SHIFT            4
107 #define PLL_MISC_LFCON_MASK             (0xF<<PLL_MISC_LFCON_SHIFT)
108 #define PLL_MISC_VCOCON_SHIFT           0
109 #define PLL_MISC_VCOCON_MASK            (0xF<<PLL_MISC_VCOCON_SHIFT)
110
111 #define PLLU_BASE_POST_DIV              (1<<20)
112
113 #define PLLD_MISC_CLKENABLE             (1<<30)
114 #define PLLD_MISC_DIV_RST               (1<<23)
115 #define PLLD_MISC_DCCON_SHIFT           12
116
117 #define PLLE_MISC_READY                 (1 << 15)
118
119 #define PERIPH_CLK_TO_ENB_REG(c)        ((c->u.periph.clk_num / 32) * 4)
120 #define PERIPH_CLK_TO_ENB_SET_REG(c)    ((c->u.periph.clk_num / 32) * 8)
121 #define PERIPH_CLK_TO_ENB_BIT(c)        (1 << (c->u.periph.clk_num % 32))
122
123 #define SUPER_CLK_MUX                   0x00
124 #define SUPER_STATE_SHIFT               28
125 #define SUPER_STATE_MASK                (0xF << SUPER_STATE_SHIFT)
126 #define SUPER_STATE_STANDBY             (0x0 << SUPER_STATE_SHIFT)
127 #define SUPER_STATE_IDLE                (0x1 << SUPER_STATE_SHIFT)
128 #define SUPER_STATE_RUN                 (0x2 << SUPER_STATE_SHIFT)
129 #define SUPER_STATE_IRQ                 (0x3 << SUPER_STATE_SHIFT)
130 #define SUPER_STATE_FIQ                 (0x4 << SUPER_STATE_SHIFT)
131 #define SUPER_SOURCE_MASK               0xF
132 #define SUPER_FIQ_SOURCE_SHIFT          12
133 #define SUPER_IRQ_SOURCE_SHIFT          8
134 #define SUPER_RUN_SOURCE_SHIFT          4
135 #define SUPER_IDLE_SOURCE_SHIFT         0
136
137 #define SUPER_CLK_DIVIDER               0x04
138
139 #define BUS_CLK_DISABLE                 (1<<3)
140 #define BUS_CLK_DIV_MASK                0x3
141
142 #define PMC_CTRL                        0x0
143  #define PMC_CTRL_BLINK_ENB             (1 << 7)
144
145 #define PMC_DPD_PADS_ORIDE              0x1c
146  #define PMC_DPD_PADS_ORIDE_BLINK_ENB   (1 << 20)
147
148 #define PMC_BLINK_TIMER_DATA_ON_SHIFT   0
149 #define PMC_BLINK_TIMER_DATA_ON_MASK    0x7fff
150 #define PMC_BLINK_TIMER_ENB             (1 << 15)
151 #define PMC_BLINK_TIMER_DATA_OFF_SHIFT  16
152 #define PMC_BLINK_TIMER_DATA_OFF_MASK   0xffff
153
154 static void __iomem *reg_clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
155 static void __iomem *reg_pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
156
157 /*
158  * Some clocks share a register with other clocks.  Any clock op that
159  * non-atomically modifies a register used by another clock must lock
160  * clock_register_lock first.
161  */
162 static DEFINE_SPINLOCK(clock_register_lock);
163
164 /*
165  * Some peripheral clocks share an enable bit, so refcount the enable bits
166  * in registers CLK_ENABLE_L, CLK_ENABLE_H, and CLK_ENABLE_U
167  */
168 static int tegra_periph_clk_enable_refcount[3 * 32];
169
170 #define clk_writel(value, reg) \
171         __raw_writel(value, (u32)reg_clk_base + (reg))
172 #define clk_readl(reg) \
173         __raw_readl((u32)reg_clk_base + (reg))
174 #define pmc_writel(value, reg) \
175         __raw_writel(value, (u32)reg_pmc_base + (reg))
176 #define pmc_readl(reg) \
177         __raw_readl((u32)reg_pmc_base + (reg))
178
179 unsigned long clk_measure_input_freq(void)
180 {
181         u32 clock_autodetect;
182         clk_writel(OSC_FREQ_DET_TRIG | 1, OSC_FREQ_DET);
183         do {} while (clk_readl(OSC_FREQ_DET_STATUS) & OSC_FREQ_DET_BUSY);
184         clock_autodetect = clk_readl(OSC_FREQ_DET_STATUS);
185         if (clock_autodetect >= 732 - 3 && clock_autodetect <= 732 + 3) {
186                 return 12000000;
187         } else if (clock_autodetect >= 794 - 3 && clock_autodetect <= 794 + 3) {
188                 return 13000000;
189         } else if (clock_autodetect >= 1172 - 3 && clock_autodetect <= 1172 + 3) {
190                 return 19200000;
191         } else if (clock_autodetect >= 1587 - 3 && clock_autodetect <= 1587 + 3) {
192                 return 26000000;
193         } else {
194                 pr_err("%s: Unexpected clock autodetect value %d", __func__, clock_autodetect);
195                 BUG();
196                 return 0;
197         }
198 }
199
200 static int clk_div71_get_divider(unsigned long parent_rate, unsigned long rate)
201 {
202         s64 divider_u71 = parent_rate * 2;
203         divider_u71 += rate - 1;
204         do_div(divider_u71, rate);
205
206         if (divider_u71 - 2 < 0)
207                 return 0;
208
209         if (divider_u71 - 2 > 255)
210                 return -EINVAL;
211
212         return divider_u71 - 2;
213 }
214
215 static int clk_div16_get_divider(unsigned long parent_rate, unsigned long rate)
216 {
217         s64 divider_u16;
218
219         divider_u16 = parent_rate;
220         divider_u16 += rate - 1;
221         do_div(divider_u16, rate);
222
223         if (divider_u16 - 1 < 0)
224                 return 0;
225
226         if (divider_u16 - 1 > 0xFFFF)
227                 return -EINVAL;
228
229         return divider_u16 - 1;
230 }
231
232 /* clk_m functions */
233 static unsigned long tegra2_clk_m_autodetect_rate(struct clk *c)
234 {
235         u32 auto_clock_control = clk_readl(OSC_CTRL) & ~OSC_CTRL_OSC_FREQ_MASK;
236
237         c->rate = clk_measure_input_freq();
238         switch (c->rate) {
239         case 12000000:
240                 auto_clock_control |= OSC_CTRL_OSC_FREQ_12MHZ;
241                 break;
242         case 13000000:
243                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
244                 break;
245         case 19200000:
246                 auto_clock_control |= OSC_CTRL_OSC_FREQ_19_2MHZ;
247                 break;
248         case 26000000:
249                 auto_clock_control |= OSC_CTRL_OSC_FREQ_26MHZ;
250                 break;
251         default:
252                 pr_err("%s: Unexpected clock rate %ld", __func__, c->rate);
253                 BUG();
254         }
255         clk_writel(auto_clock_control, OSC_CTRL);
256         return c->rate;
257 }
258
259 static void tegra2_clk_m_init(struct clk *c)
260 {
261         pr_debug("%s on clock %s\n", __func__, c->name);
262         tegra2_clk_m_autodetect_rate(c);
263 }
264
265 static int tegra2_clk_m_enable(struct clk *c)
266 {
267         pr_debug("%s on clock %s\n", __func__, c->name);
268         return 0;
269 }
270
271 static void tegra2_clk_m_disable(struct clk *c)
272 {
273         pr_debug("%s on clock %s\n", __func__, c->name);
274         BUG();
275 }
276
277 static struct clk_ops tegra_clk_m_ops = {
278         .init           = tegra2_clk_m_init,
279         .enable         = tegra2_clk_m_enable,
280         .disable        = tegra2_clk_m_disable,
281 };
282
283 /* super clock functions */
284 /* "super clocks" on tegra have two-stage muxes and a clock skipping
285  * super divider.  We will ignore the clock skipping divider, since we
286  * can't lower the voltage when using the clock skip, but we can if we
287  * lower the PLL frequency.
288  */
289 static void tegra2_super_clk_init(struct clk *c)
290 {
291         u32 val;
292         int source;
293         int shift;
294         const struct clk_mux_sel *sel;
295         val = clk_readl(c->reg + SUPER_CLK_MUX);
296         c->state = ON;
297         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
298                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
299         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
300                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
301         source = (val >> shift) & SUPER_SOURCE_MASK;
302         for (sel = c->inputs; sel->input != NULL; sel++) {
303                 if (sel->value == source)
304                         break;
305         }
306         BUG_ON(sel->input == NULL);
307         c->parent = sel->input;
308 }
309
310 static int tegra2_super_clk_enable(struct clk *c)
311 {
312         clk_writel(0, c->reg + SUPER_CLK_DIVIDER);
313         return 0;
314 }
315
316 static void tegra2_super_clk_disable(struct clk *c)
317 {
318         pr_debug("%s on clock %s\n", __func__, c->name);
319
320         /* oops - don't disable the CPU clock! */
321         BUG();
322 }
323
324 static int tegra2_super_clk_set_parent(struct clk *c, struct clk *p)
325 {
326         u32 val;
327         const struct clk_mux_sel *sel;
328         int shift;
329
330         val = clk_readl(c->reg + SUPER_CLK_MUX);
331         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
332                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
333         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
334                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
335         for (sel = c->inputs; sel->input != NULL; sel++) {
336                 if (sel->input == p) {
337                         val &= ~(SUPER_SOURCE_MASK << shift);
338                         val |= sel->value << shift;
339
340                         if (c->refcnt)
341                                 clk_enable(p);
342
343                         clk_writel(val, c->reg);
344
345                         if (c->refcnt && c->parent)
346                                 clk_disable(c->parent);
347
348                         clk_reparent(c, p);
349                         return 0;
350                 }
351         }
352         return -EINVAL;
353 }
354
355 /*
356  * Super clocks have "clock skippers" instead of dividers.  Dividing using
357  * a clock skipper does not allow the voltage to be scaled down, so instead
358  * adjust the rate of the parent clock.  This requires that the parent of a
359  * super clock have no other children, otherwise the rate will change
360  * underneath the other children.
361  */
362 static int tegra2_super_clk_set_rate(struct clk *c, unsigned long rate)
363 {
364         return clk_set_rate(c->parent, rate);
365 }
366
367 static struct clk_ops tegra_super_ops = {
368         .init                   = tegra2_super_clk_init,
369         .enable                 = tegra2_super_clk_enable,
370         .disable                = tegra2_super_clk_disable,
371         .set_parent             = tegra2_super_clk_set_parent,
372         .set_rate               = tegra2_super_clk_set_rate,
373 };
374
375 /* virtual cpu clock functions */
376 /* some clocks can not be stopped (cpu, memory bus) while the SoC is running.
377    To change the frequency of these clocks, the parent pll may need to be
378    reprogrammed, so the clock must be moved off the pll, the pll reprogrammed,
379    and then the clock moved back to the pll.  To hide this sequence, a virtual
380    clock handles it.
381  */
382 static void tegra2_cpu_clk_init(struct clk *c)
383 {
384 }
385
386 static int tegra2_cpu_clk_enable(struct clk *c)
387 {
388         return 0;
389 }
390
391 static void tegra2_cpu_clk_disable(struct clk *c)
392 {
393         pr_debug("%s on clock %s\n", __func__, c->name);
394
395         /* oops - don't disable the CPU clock! */
396         BUG();
397 }
398
399 static int tegra2_cpu_clk_set_rate(struct clk *c, unsigned long rate)
400 {
401         int ret;
402         /*
403          * Take an extra reference to the main pll so it doesn't turn
404          * off when we move the cpu off of it
405          */
406         clk_enable(c->u.cpu.main);
407
408         ret = clk_set_parent(c->parent, c->u.cpu.backup);
409         if (ret) {
410                 pr_err("Failed to switch cpu to clock %s\n", c->u.cpu.backup->name);
411                 goto out;
412         }
413
414         if (rate == clk_get_rate(c->u.cpu.backup))
415                 goto out;
416
417         ret = clk_set_rate(c->u.cpu.main, rate);
418         if (ret) {
419                 pr_err("Failed to change cpu pll to %lu\n", rate);
420                 goto out;
421         }
422
423         ret = clk_set_parent(c->parent, c->u.cpu.main);
424         if (ret) {
425                 pr_err("Failed to switch cpu to clock %s\n", c->u.cpu.main->name);
426                 goto out;
427         }
428
429 out:
430         clk_disable(c->u.cpu.main);
431         return ret;
432 }
433
434 static struct clk_ops tegra_cpu_ops = {
435         .init     = tegra2_cpu_clk_init,
436         .enable   = tegra2_cpu_clk_enable,
437         .disable  = tegra2_cpu_clk_disable,
438         .set_rate = tegra2_cpu_clk_set_rate,
439 };
440
441 /* virtual cop clock functions. Used to acquire the fake 'cop' clock to
442  * reset the COP block (i.e. AVP) */
443 static void tegra2_cop_clk_reset(struct clk *c, bool assert)
444 {
445         unsigned long reg = assert ? RST_DEVICES_SET : RST_DEVICES_CLR;
446
447         pr_debug("%s %s\n", __func__, assert ? "assert" : "deassert");
448         clk_writel(1 << 1, reg);
449 }
450
451 static struct clk_ops tegra_cop_ops = {
452         .reset    = tegra2_cop_clk_reset,
453 };
454
455 /* bus clock functions */
456 static void tegra2_bus_clk_init(struct clk *c)
457 {
458         u32 val = clk_readl(c->reg);
459         c->state = ((val >> c->reg_shift) & BUS_CLK_DISABLE) ? OFF : ON;
460         c->div = ((val >> c->reg_shift) & BUS_CLK_DIV_MASK) + 1;
461         c->mul = 1;
462 }
463
464 static int tegra2_bus_clk_enable(struct clk *c)
465 {
466         u32 val;
467         unsigned long flags;
468
469         spin_lock_irqsave(&clock_register_lock, flags);
470
471         val = clk_readl(c->reg);
472         val &= ~(BUS_CLK_DISABLE << c->reg_shift);
473         clk_writel(val, c->reg);
474
475         spin_unlock_irqrestore(&clock_register_lock, flags);
476
477         return 0;
478 }
479
480 static void tegra2_bus_clk_disable(struct clk *c)
481 {
482         u32 val;
483         unsigned long flags;
484
485         spin_lock_irqsave(&clock_register_lock, flags);
486
487         val = clk_readl(c->reg);
488         val |= BUS_CLK_DISABLE << c->reg_shift;
489         clk_writel(val, c->reg);
490
491         spin_unlock_irqrestore(&clock_register_lock, flags);
492 }
493
494 static int tegra2_bus_clk_set_rate(struct clk *c, unsigned long rate)
495 {
496         u32 val;
497         unsigned long parent_rate = clk_get_rate(c->parent);
498         unsigned long flags;
499         int ret = -EINVAL;
500         int i;
501
502         spin_lock_irqsave(&clock_register_lock, flags);
503
504         val = clk_readl(c->reg);
505         for (i = 1; i <= 4; i++) {
506                 if (rate == parent_rate / i) {
507                         val &= ~(BUS_CLK_DIV_MASK << c->reg_shift);
508                         val |= (i - 1) << c->reg_shift;
509                         clk_writel(val, c->reg);
510                         c->div = i;
511                         c->mul = 1;
512                         ret = 0;
513                         break;
514                 }
515         }
516
517         spin_unlock_irqrestore(&clock_register_lock, flags);
518
519         return ret;
520 }
521
522 static struct clk_ops tegra_bus_ops = {
523         .init                   = tegra2_bus_clk_init,
524         .enable                 = tegra2_bus_clk_enable,
525         .disable                = tegra2_bus_clk_disable,
526         .set_rate               = tegra2_bus_clk_set_rate,
527 };
528
529 /* Blink output functions */
530
531 static void tegra2_blink_clk_init(struct clk *c)
532 {
533         u32 val;
534
535         val = pmc_readl(PMC_CTRL);
536         c->state = (val & PMC_CTRL_BLINK_ENB) ? ON : OFF;
537         c->mul = 1;
538         val = pmc_readl(c->reg);
539
540         if (val & PMC_BLINK_TIMER_ENB) {
541                 unsigned int on_off;
542
543                 on_off = (val >> PMC_BLINK_TIMER_DATA_ON_SHIFT) &
544                         PMC_BLINK_TIMER_DATA_ON_MASK;
545                 val >>= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
546                 val &= PMC_BLINK_TIMER_DATA_OFF_MASK;
547                 on_off += val;
548                 /* each tick in the blink timer is 4 32KHz clocks */
549                 c->div = on_off * 4;
550         } else {
551                 c->div = 1;
552         }
553 }
554
555 static int tegra2_blink_clk_enable(struct clk *c)
556 {
557         u32 val;
558
559         val = pmc_readl(PMC_DPD_PADS_ORIDE);
560         pmc_writel(val | PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
561
562         val = pmc_readl(PMC_CTRL);
563         pmc_writel(val | PMC_CTRL_BLINK_ENB, PMC_CTRL);
564
565         return 0;
566 }
567
568 static void tegra2_blink_clk_disable(struct clk *c)
569 {
570         u32 val;
571
572         val = pmc_readl(PMC_CTRL);
573         pmc_writel(val & ~PMC_CTRL_BLINK_ENB, PMC_CTRL);
574
575         val = pmc_readl(PMC_DPD_PADS_ORIDE);
576         pmc_writel(val & ~PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
577 }
578
579 static int tegra2_blink_clk_set_rate(struct clk *c, unsigned long rate)
580 {
581         unsigned long parent_rate = clk_get_rate(c->parent);
582         if (rate >= parent_rate) {
583                 c->div = 1;
584                 pmc_writel(0, c->reg);
585         } else {
586                 unsigned int on_off;
587                 u32 val;
588
589                 on_off = DIV_ROUND_UP(parent_rate / 8, rate);
590                 c->div = on_off * 8;
591
592                 val = (on_off & PMC_BLINK_TIMER_DATA_ON_MASK) <<
593                         PMC_BLINK_TIMER_DATA_ON_SHIFT;
594                 on_off &= PMC_BLINK_TIMER_DATA_OFF_MASK;
595                 on_off <<= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
596                 val |= on_off;
597                 val |= PMC_BLINK_TIMER_ENB;
598                 pmc_writel(val, c->reg);
599         }
600
601         return 0;
602 }
603
604 static struct clk_ops tegra_blink_clk_ops = {
605         .init                   = &tegra2_blink_clk_init,
606         .enable                 = &tegra2_blink_clk_enable,
607         .disable                = &tegra2_blink_clk_disable,
608         .set_rate               = &tegra2_blink_clk_set_rate,
609 };
610
611 /* PLL Functions */
612 static int tegra2_pll_clk_wait_for_lock(struct clk *c)
613 {
614         udelay(c->u.pll.lock_delay);
615
616         return 0;
617 }
618
619 static void tegra2_pll_clk_init(struct clk *c)
620 {
621         u32 val = clk_readl(c->reg + PLL_BASE);
622
623         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
624
625         if (c->flags & PLL_FIXED && !(val & PLL_BASE_OVERRIDE)) {
626                 pr_warning("Clock %s has unknown fixed frequency\n", c->name);
627                 c->mul = 1;
628                 c->div = 1;
629         } else if (val & PLL_BASE_BYPASS) {
630                 c->mul = 1;
631                 c->div = 1;
632         } else {
633                 c->mul = (val & PLL_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
634                 c->div = (val & PLL_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
635                 if (c->flags & PLLU)
636                         c->div *= (val & PLLU_BASE_POST_DIV) ? 1 : 2;
637                 else
638                         c->div *= (val & PLL_BASE_DIVP_MASK) ? 2 : 1;
639         }
640 }
641
642 static int tegra2_pll_clk_enable(struct clk *c)
643 {
644         u32 val;
645         pr_debug("%s on clock %s\n", __func__, c->name);
646
647         val = clk_readl(c->reg + PLL_BASE);
648         val &= ~PLL_BASE_BYPASS;
649         val |= PLL_BASE_ENABLE;
650         clk_writel(val, c->reg + PLL_BASE);
651
652         if (c->flags & PLLD) {
653                 val = clk_readl(c->reg + PLL_MISC(c) + PLL_BASE);
654                 val |= PLLD_MISC_CLKENABLE;
655                 clk_writel(val, c->reg + PLL_MISC(c) + PLL_BASE);
656         }
657
658         tegra2_pll_clk_wait_for_lock(c);
659
660         return 0;
661 }
662
663 static void tegra2_pll_clk_disable(struct clk *c)
664 {
665         u32 val;
666         pr_debug("%s on clock %s\n", __func__, c->name);
667
668         val = clk_readl(c->reg);
669         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
670         clk_writel(val, c->reg);
671
672         if (c->flags & PLLD) {
673                 val = clk_readl(c->reg + PLL_MISC(c) + PLL_BASE);
674                 val &= ~PLLD_MISC_CLKENABLE;
675                 clk_writel(val, c->reg + PLL_MISC(c) + PLL_BASE);
676         }
677 }
678
679 static int tegra2_pll_clk_set_rate(struct clk *c, unsigned long rate)
680 {
681         u32 val;
682         unsigned long input_rate;
683         const struct clk_pll_freq_table *sel;
684
685         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
686
687         input_rate = clk_get_rate(c->parent);
688         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
689                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
690                         c->mul = sel->n;
691                         c->div = sel->m * sel->p;
692
693                         val = clk_readl(c->reg + PLL_BASE);
694                         if (c->flags & PLL_FIXED)
695                                 val |= PLL_BASE_OVERRIDE;
696                         val &= ~(PLL_BASE_DIVP_MASK | PLL_BASE_DIVN_MASK |
697                                  PLL_BASE_DIVM_MASK);
698                         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
699                                 (sel->n << PLL_BASE_DIVN_SHIFT);
700                         BUG_ON(sel->p < 1 || sel->p > 2);
701                         if (c->flags & PLLU) {
702                                 if (sel->p == 1)
703                                         val |= PLLU_BASE_POST_DIV;
704                         } else {
705                                 if (sel->p == 2)
706                                         val |= 1 << PLL_BASE_DIVP_SHIFT;
707                         }
708                         clk_writel(val, c->reg + PLL_BASE);
709
710                         if (c->flags & PLL_HAS_CPCON) {
711                                 val = clk_readl(c->reg + PLL_MISC(c));
712                                 val &= ~PLL_MISC_CPCON_MASK;
713                                 val |= sel->cpcon << PLL_MISC_CPCON_SHIFT;
714                                 clk_writel(val, c->reg + PLL_MISC(c));
715                         }
716
717                         if (c->state == ON)
718                                 tegra2_pll_clk_enable(c);
719
720                         return 0;
721                 }
722         }
723         return -EINVAL;
724 }
725
726 static struct clk_ops tegra_pll_ops = {
727         .init                   = tegra2_pll_clk_init,
728         .enable                 = tegra2_pll_clk_enable,
729         .disable                = tegra2_pll_clk_disable,
730         .set_rate               = tegra2_pll_clk_set_rate,
731 };
732
733 static int tegra2_plle_clk_enable(struct clk *c)
734 {
735         u32 val;
736
737         pr_debug("%s on clock %s\n", __func__, c->name);
738
739         mdelay(1);
740
741         val = clk_readl(c->reg + PLL_BASE);
742         if (!(val & PLLE_MISC_READY))
743                 return -EBUSY;
744
745         val = clk_readl(c->reg + PLL_BASE);
746         val |= PLL_BASE_ENABLE | PLL_BASE_BYPASS;
747         clk_writel(val, c->reg + PLL_BASE);
748
749         return 0;
750 }
751
752 static struct clk_ops tegra_plle_ops = {
753         .init       = tegra2_pll_clk_init,
754         .enable     = tegra2_plle_clk_enable,
755         .set_rate   = tegra2_pll_clk_set_rate,
756 };
757
758 /* Clock divider ops */
759 static void tegra2_pll_div_clk_init(struct clk *c)
760 {
761         u32 val = clk_readl(c->reg);
762         u32 divu71;
763         val >>= c->reg_shift;
764         c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
765         if (!(val & PLL_OUT_RESET_DISABLE))
766                 c->state = OFF;
767
768         if (c->flags & DIV_U71) {
769                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
770                 c->div = (divu71 + 2);
771                 c->mul = 2;
772         } else if (c->flags & DIV_2) {
773                 c->div = 2;
774                 c->mul = 1;
775         } else {
776                 c->div = 1;
777                 c->mul = 1;
778         }
779 }
780
781 static int tegra2_pll_div_clk_enable(struct clk *c)
782 {
783         u32 val;
784         u32 new_val;
785         unsigned long flags;
786
787         pr_debug("%s: %s\n", __func__, c->name);
788         if (c->flags & DIV_U71) {
789                 spin_lock_irqsave(&clock_register_lock, flags);
790                 val = clk_readl(c->reg);
791                 new_val = val >> c->reg_shift;
792                 new_val &= 0xFFFF;
793
794                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
795
796                 val &= ~(0xFFFF << c->reg_shift);
797                 val |= new_val << c->reg_shift;
798                 clk_writel(val, c->reg);
799                 spin_unlock_irqrestore(&clock_register_lock, flags);
800                 return 0;
801         } else if (c->flags & DIV_2) {
802                 BUG_ON(!(c->flags & PLLD));
803                 spin_lock_irqsave(&clock_register_lock, flags);
804                 val = clk_readl(c->reg);
805                 val &= ~PLLD_MISC_DIV_RST;
806                 clk_writel(val, c->reg);
807                 spin_unlock_irqrestore(&clock_register_lock, flags);
808                 return 0;
809         }
810         return -EINVAL;
811 }
812
813 static void tegra2_pll_div_clk_disable(struct clk *c)
814 {
815         u32 val;
816         u32 new_val;
817         unsigned long flags;
818
819         pr_debug("%s: %s\n", __func__, c->name);
820         if (c->flags & DIV_U71) {
821                 spin_lock_irqsave(&clock_register_lock, flags);
822                 val = clk_readl(c->reg);
823                 new_val = val >> c->reg_shift;
824                 new_val &= 0xFFFF;
825
826                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
827
828                 val &= ~(0xFFFF << c->reg_shift);
829                 val |= new_val << c->reg_shift;
830                 clk_writel(val, c->reg);
831                 spin_unlock_irqrestore(&clock_register_lock, flags);
832         } else if (c->flags & DIV_2) {
833                 BUG_ON(!(c->flags & PLLD));
834                 spin_lock_irqsave(&clock_register_lock, flags);
835                 val = clk_readl(c->reg);
836                 val |= PLLD_MISC_DIV_RST;
837                 clk_writel(val, c->reg);
838                 spin_unlock_irqrestore(&clock_register_lock, flags);
839         }
840 }
841
842 static int tegra2_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
843 {
844         u32 val;
845         u32 new_val;
846         int divider_u71;
847         unsigned long parent_rate = clk_get_rate(c->parent);
848         unsigned long flags;
849
850         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
851         if (c->flags & DIV_U71) {
852                 divider_u71 = clk_div71_get_divider(parent_rate, rate);
853                 if (divider_u71 >= 0) {
854                         spin_lock_irqsave(&clock_register_lock, flags);
855                         val = clk_readl(c->reg);
856                         new_val = val >> c->reg_shift;
857                         new_val &= 0xFFFF;
858                         if (c->flags & DIV_U71_FIXED)
859                                 new_val |= PLL_OUT_OVERRIDE;
860                         new_val &= ~PLL_OUT_RATIO_MASK;
861                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
862
863                         val &= ~(0xFFFF << c->reg_shift);
864                         val |= new_val << c->reg_shift;
865                         clk_writel(val, c->reg);
866                         c->div = divider_u71 + 2;
867                         c->mul = 2;
868                         spin_unlock_irqrestore(&clock_register_lock, flags);
869                         return 0;
870                 }
871         } else if (c->flags & DIV_2) {
872                 if (parent_rate == rate * 2)
873                         return 0;
874         }
875         return -EINVAL;
876 }
877
878 static long tegra2_pll_div_clk_round_rate(struct clk *c, unsigned long rate)
879 {
880         int divider;
881         unsigned long parent_rate = clk_get_rate(c->parent);
882         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
883
884         if (c->flags & DIV_U71) {
885                 divider = clk_div71_get_divider(parent_rate, rate);
886                 if (divider < 0)
887                         return divider;
888                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
889         } else if (c->flags & DIV_2) {
890                 return DIV_ROUND_UP(parent_rate, 2);
891         }
892         return -EINVAL;
893 }
894
895 static struct clk_ops tegra_pll_div_ops = {
896         .init                   = tegra2_pll_div_clk_init,
897         .enable                 = tegra2_pll_div_clk_enable,
898         .disable                = tegra2_pll_div_clk_disable,
899         .set_rate               = tegra2_pll_div_clk_set_rate,
900         .round_rate             = tegra2_pll_div_clk_round_rate,
901 };
902
903 /* Periph clk ops */
904
905 static void tegra2_periph_clk_init(struct clk *c)
906 {
907         u32 val = clk_readl(c->reg);
908         const struct clk_mux_sel *mux = 0;
909         const struct clk_mux_sel *sel;
910         if (c->flags & MUX) {
911                 for (sel = c->inputs; sel->input != NULL; sel++) {
912                         if (val >> PERIPH_CLK_SOURCE_SHIFT == sel->value)
913                                 mux = sel;
914                 }
915                 BUG_ON(!mux);
916
917                 c->parent = mux->input;
918         } else {
919                 c->parent = c->inputs[0].input;
920         }
921
922         if (c->flags & DIV_U71) {
923                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
924                 c->div = divu71 + 2;
925                 c->mul = 2;
926         } else if (c->flags & DIV_U16) {
927                 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
928                 c->div = divu16 + 1;
929                 c->mul = 1;
930         } else {
931                 c->div = 1;
932                 c->mul = 1;
933         }
934
935         c->state = ON;
936
937         if (!c->u.periph.clk_num)
938                 return;
939
940         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
941                         PERIPH_CLK_TO_ENB_BIT(c)))
942                 c->state = OFF;
943
944         if (!(c->flags & PERIPH_NO_RESET))
945                 if (clk_readl(RST_DEVICES + PERIPH_CLK_TO_ENB_REG(c)) &
946                                 PERIPH_CLK_TO_ENB_BIT(c))
947                         c->state = OFF;
948 }
949
950 static int tegra2_periph_clk_enable(struct clk *c)
951 {
952         u32 val;
953         unsigned long flags;
954         int refcount;
955         pr_debug("%s on clock %s\n", __func__, c->name);
956
957         if (!c->u.periph.clk_num)
958                 return 0;
959
960         spin_lock_irqsave(&clock_register_lock, flags);
961
962         refcount = tegra_periph_clk_enable_refcount[c->u.periph.clk_num]++;
963
964         if (refcount > 1)
965                 goto out;
966
967         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
968                 CLK_OUT_ENB_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
969         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET))
970                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
971                         RST_DEVICES_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
972         if (c->flags & PERIPH_EMC_ENB) {
973                 /* The EMC peripheral clock has 2 extra enable bits */
974                 /* FIXME: Do they need to be disabled? */
975                 val = clk_readl(c->reg);
976                 val |= 0x3 << 24;
977                 clk_writel(val, c->reg);
978         }
979
980 out:
981         spin_unlock_irqrestore(&clock_register_lock, flags);
982
983         return 0;
984 }
985
986 static void tegra2_periph_clk_disable(struct clk *c)
987 {
988         unsigned long flags;
989
990         pr_debug("%s on clock %s\n", __func__, c->name);
991
992         if (!c->u.periph.clk_num)
993                 return;
994
995         spin_lock_irqsave(&clock_register_lock, flags);
996
997         if (c->refcnt)
998                 tegra_periph_clk_enable_refcount[c->u.periph.clk_num]--;
999
1000         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] == 0)
1001                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1002                         CLK_OUT_ENB_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
1003
1004         spin_unlock_irqrestore(&clock_register_lock, flags);
1005 }
1006
1007 static void tegra2_periph_clk_reset(struct clk *c, bool assert)
1008 {
1009         unsigned long base = assert ? RST_DEVICES_SET : RST_DEVICES_CLR;
1010
1011         pr_debug("%s %s on clock %s\n", __func__,
1012                  assert ? "assert" : "deassert", c->name);
1013
1014         BUG_ON(!c->u.periph.clk_num);
1015
1016         if (!(c->flags & PERIPH_NO_RESET))
1017                 clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1018                            base + PERIPH_CLK_TO_ENB_SET_REG(c));
1019 }
1020
1021 static int tegra2_periph_clk_set_parent(struct clk *c, struct clk *p)
1022 {
1023         u32 val;
1024         const struct clk_mux_sel *sel;
1025         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
1026         for (sel = c->inputs; sel->input != NULL; sel++) {
1027                 if (sel->input == p) {
1028                         val = clk_readl(c->reg);
1029                         val &= ~((c->reg_shift >> 8) << (c->reg_shift & 0xFF));
1030                         val |= (sel->value) << (c->reg_shift & 0xFF);
1031
1032                         if (c->refcnt)
1033                                 clk_enable(p);
1034
1035                         clk_writel(val, c->reg);
1036
1037                         if (c->refcnt && c->parent)
1038                                 clk_disable(c->parent);
1039
1040                         clk_reparent(c, p);
1041                         return 0;
1042                 }
1043         }
1044
1045         return -EINVAL;
1046 }
1047
1048 static int tegra2_periph_clk_set_rate(struct clk *c, unsigned long rate)
1049 {
1050         u32 val;
1051         int divider;
1052         unsigned long parent_rate = clk_get_rate(c->parent);
1053
1054         if (c->flags & DIV_U71) {
1055                 divider = clk_div71_get_divider(parent_rate, rate);
1056                 if (divider >= 0) {
1057                         val = clk_readl(c->reg);
1058                         val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
1059                         val |= divider;
1060                         clk_writel(val, c->reg);
1061                         c->div = divider + 2;
1062                         c->mul = 2;
1063                         return 0;
1064                 }
1065         } else if (c->flags & DIV_U16) {
1066                 divider = clk_div16_get_divider(parent_rate, rate);
1067                 if (divider >= 0) {
1068                         val = clk_readl(c->reg);
1069                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
1070                         val |= divider;
1071                         clk_writel(val, c->reg);
1072                         c->div = divider + 1;
1073                         c->mul = 1;
1074                         return 0;
1075                 }
1076         } else if (parent_rate <= rate) {
1077                 c->div = 1;
1078                 c->mul = 1;
1079                 return 0;
1080         }
1081         return -EINVAL;
1082 }
1083
1084 static long tegra2_periph_clk_round_rate(struct clk *c,
1085         unsigned long rate)
1086 {
1087         int divider;
1088         unsigned long parent_rate = clk_get_rate(c->parent);
1089         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
1090
1091         if (c->flags & DIV_U71) {
1092                 divider = clk_div71_get_divider(parent_rate, rate);
1093                 if (divider < 0)
1094                         return divider;
1095
1096                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
1097         } else if (c->flags & DIV_U16) {
1098                 divider = clk_div16_get_divider(parent_rate, rate);
1099                 if (divider < 0)
1100                         return divider;
1101                 return DIV_ROUND_UP(parent_rate, divider + 1);
1102         }
1103         return -EINVAL;
1104 }
1105
1106 static struct clk_ops tegra_periph_clk_ops = {
1107         .init                   = &tegra2_periph_clk_init,
1108         .enable                 = &tegra2_periph_clk_enable,
1109         .disable                = &tegra2_periph_clk_disable,
1110         .set_parent             = &tegra2_periph_clk_set_parent,
1111         .set_rate               = &tegra2_periph_clk_set_rate,
1112         .round_rate             = &tegra2_periph_clk_round_rate,
1113         .reset                  = &tegra2_periph_clk_reset,
1114 };
1115
1116 /* The SDMMC controllers have extra bits in the clock source register that
1117  * adjust the delay between the clock and data to compenstate for delays
1118  * on the PCB. */
1119 void tegra2_sdmmc_tap_delay(struct clk *c, int delay)
1120 {
1121         u32 reg;
1122
1123         delay = clamp(delay, 0, 15);
1124         reg = clk_readl(c->reg);
1125         reg &= ~SDMMC_CLK_INT_FB_DLY_MASK;
1126         reg |= SDMMC_CLK_INT_FB_SEL;
1127         reg |= delay << SDMMC_CLK_INT_FB_DLY_SHIFT;
1128         clk_writel(reg, c->reg);
1129 }
1130
1131 /* External memory controller clock ops */
1132 static void tegra2_emc_clk_init(struct clk *c)
1133 {
1134         tegra2_periph_clk_init(c);
1135         c->max_rate = clk_get_rate_locked(c);
1136 }
1137
1138 static long tegra2_emc_clk_round_rate(struct clk *c, unsigned long rate)
1139 {
1140         long new_rate = rate;
1141
1142         new_rate = tegra_emc_round_rate(new_rate);
1143         if (new_rate < 0)
1144                 return c->max_rate;
1145
1146         BUG_ON(new_rate != tegra2_periph_clk_round_rate(c, new_rate));
1147
1148         return new_rate;
1149 }
1150
1151 static int tegra2_emc_clk_set_rate(struct clk *c, unsigned long rate)
1152 {
1153         int ret;
1154         /*
1155          * The Tegra2 memory controller has an interlock with the clock
1156          * block that allows memory shadowed registers to be updated,
1157          * and then transfer them to the main registers at the same
1158          * time as the clock update without glitches.
1159          */
1160         ret = tegra_emc_set_rate(rate);
1161         if (ret < 0)
1162                 return ret;
1163
1164         ret = tegra2_periph_clk_set_rate(c, rate);
1165         udelay(1);
1166
1167         return ret;
1168 }
1169
1170 static struct clk_ops tegra_emc_clk_ops = {
1171         .init                   = &tegra2_emc_clk_init,
1172         .enable                 = &tegra2_periph_clk_enable,
1173         .disable                = &tegra2_periph_clk_disable,
1174         .set_parent             = &tegra2_periph_clk_set_parent,
1175         .set_rate               = &tegra2_emc_clk_set_rate,
1176         .round_rate             = &tegra2_emc_clk_round_rate,
1177         .reset                  = &tegra2_periph_clk_reset,
1178 };
1179
1180 /* Clock doubler ops */
1181 static void tegra2_clk_double_init(struct clk *c)
1182 {
1183         c->mul = 2;
1184         c->div = 1;
1185         c->state = ON;
1186
1187         if (!c->u.periph.clk_num)
1188                 return;
1189
1190         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
1191                         PERIPH_CLK_TO_ENB_BIT(c)))
1192                 c->state = OFF;
1193 };
1194
1195 static int tegra2_clk_double_set_rate(struct clk *c, unsigned long rate)
1196 {
1197         if (rate != 2 * clk_get_rate(c->parent))
1198                 return -EINVAL;
1199         c->mul = 2;
1200         c->div = 1;
1201         return 0;
1202 }
1203
1204 static struct clk_ops tegra_clk_double_ops = {
1205         .init                   = &tegra2_clk_double_init,
1206         .enable                 = &tegra2_periph_clk_enable,
1207         .disable                = &tegra2_periph_clk_disable,
1208         .set_rate               = &tegra2_clk_double_set_rate,
1209 };
1210
1211 /* Audio sync clock ops */
1212 static void tegra2_audio_sync_clk_init(struct clk *c)
1213 {
1214         int source;
1215         const struct clk_mux_sel *sel;
1216         u32 val = clk_readl(c->reg);
1217         c->state = (val & (1<<4)) ? OFF : ON;
1218         source = val & 0xf;
1219         for (sel = c->inputs; sel->input != NULL; sel++)
1220                 if (sel->value == source)
1221                         break;
1222         BUG_ON(sel->input == NULL);
1223         c->parent = sel->input;
1224 }
1225
1226 static int tegra2_audio_sync_clk_enable(struct clk *c)
1227 {
1228         clk_writel(0, c->reg);
1229         return 0;
1230 }
1231
1232 static void tegra2_audio_sync_clk_disable(struct clk *c)
1233 {
1234         clk_writel(1, c->reg);
1235 }
1236
1237 static int tegra2_audio_sync_clk_set_parent(struct clk *c, struct clk *p)
1238 {
1239         u32 val;
1240         const struct clk_mux_sel *sel;
1241         for (sel = c->inputs; sel->input != NULL; sel++) {
1242                 if (sel->input == p) {
1243                         val = clk_readl(c->reg);
1244                         val &= ~0xf;
1245                         val |= sel->value;
1246
1247                         if (c->refcnt)
1248                                 clk_enable(p);
1249
1250                         clk_writel(val, c->reg);
1251
1252                         if (c->refcnt && c->parent)
1253                                 clk_disable(c->parent);
1254
1255                         clk_reparent(c, p);
1256                         return 0;
1257                 }
1258         }
1259
1260         return -EINVAL;
1261 }
1262
1263 static struct clk_ops tegra_audio_sync_clk_ops = {
1264         .init       = tegra2_audio_sync_clk_init,
1265         .enable     = tegra2_audio_sync_clk_enable,
1266         .disable    = tegra2_audio_sync_clk_disable,
1267         .set_parent = tegra2_audio_sync_clk_set_parent,
1268 };
1269
1270 /* call this function after pinmux configuration */
1271 static void tegra2_cdev_clk_set_parent(struct clk *c)
1272 {
1273         const struct clk_mux_sel *mux = 0;
1274         const struct clk_mux_sel *sel;
1275         enum tegra_pingroup pg = TEGRA_PINGROUP_CDEV1;
1276         int val;
1277
1278         /* Get pinmux setting for cdev1 and cdev2 from APB_MISC register */
1279         if (!strcmp(c->name, "clk_dev2"))
1280                 pg = TEGRA_PINGROUP_CDEV2;
1281
1282         val = tegra_pinmux_get_func(pg);
1283         for (sel = c->inputs; sel->input != NULL; sel++) {
1284                 if (val == sel->value)
1285                         mux = sel;
1286         }
1287         BUG_ON(!mux);
1288
1289         c->parent = mux->input;
1290 }
1291
1292 /* cdev1 and cdev2 (dap_mclk1 and dap_mclk2) ops */
1293 static void tegra2_cdev_clk_init(struct clk *c)
1294 {
1295         const struct clk_mux_sel *sel;
1296
1297         /* Find max rate from inputs */
1298         for (sel = c->inputs; sel->input != NULL; sel++) {
1299                 c->max_rate = max(sel->input->max_rate, c->max_rate);
1300         }
1301
1302         /* We could un-tristate the cdev1 or cdev2 pingroup here; this is
1303          * currently done in the pinmux code. */
1304         c->state = ON;
1305
1306         BUG_ON(!c->u.periph.clk_num);
1307
1308         if (!(clk_readl(CLK_OUT_ENB + PERIPH_CLK_TO_ENB_REG(c)) &
1309                         PERIPH_CLK_TO_ENB_BIT(c)))
1310                 c->state = OFF;
1311 }
1312
1313 static int tegra2_cdev_clk_enable(struct clk *c)
1314 {
1315         BUG_ON(!c->u.periph.clk_num);
1316
1317         if (!c->parent) {
1318                 /* Set parent from inputs */
1319                 tegra2_cdev_clk_set_parent(c);
1320                 clk_enable(c->parent);
1321         }
1322
1323         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1324                 CLK_OUT_ENB_SET + PERIPH_CLK_TO_ENB_SET_REG(c));
1325         return 0;
1326 }
1327
1328 static void tegra2_cdev_clk_disable(struct clk *c)
1329 {
1330         BUG_ON(!c->u.periph.clk_num);
1331
1332         clk_writel(PERIPH_CLK_TO_ENB_BIT(c),
1333                 CLK_OUT_ENB_CLR + PERIPH_CLK_TO_ENB_SET_REG(c));
1334 }
1335
1336 static struct clk_ops tegra_cdev_clk_ops = {
1337         .init                   = &tegra2_cdev_clk_init,
1338         .enable                 = &tegra2_cdev_clk_enable,
1339         .disable                = &tegra2_cdev_clk_disable,
1340 };
1341
1342 /* shared bus ops */
1343 /*
1344  * Some clocks may have multiple downstream users that need to request a
1345  * higher clock rate.  Shared bus clocks provide a unique shared_bus_user
1346  * clock to each user.  The frequency of the bus is set to the highest
1347  * enabled shared_bus_user clock, with a minimum value set by the
1348  * shared bus.
1349  */
1350 static int tegra_clk_shared_bus_update(struct clk *bus)
1351 {
1352         struct clk *c;
1353         unsigned long rate = bus->min_rate;
1354
1355         list_for_each_entry(c, &bus->shared_bus_list, u.shared_bus_user.node)
1356                 if (c->u.shared_bus_user.enabled)
1357                         rate = max(c->u.shared_bus_user.rate, rate);
1358
1359         if (rate == clk_get_rate_locked(bus))
1360                 return 0;
1361
1362         return clk_set_rate_locked(bus, rate);
1363 };
1364
1365 static void tegra_clk_shared_bus_init(struct clk *c)
1366 {
1367         unsigned long flags;
1368
1369         c->max_rate = c->parent->max_rate;
1370         c->u.shared_bus_user.rate = c->parent->max_rate;
1371         c->state = OFF;
1372         c->set = true;
1373
1374         clk_lock_save(c->parent, &flags);
1375
1376         list_add_tail(&c->u.shared_bus_user.node,
1377                 &c->parent->shared_bus_list);
1378
1379         clk_unlock_restore(c->parent, &flags);
1380 }
1381
1382 static int tegra_clk_shared_bus_set_rate(struct clk *c, unsigned long rate)
1383 {
1384         unsigned long flags;
1385         int ret;
1386         long new_rate = rate;
1387
1388         new_rate = clk_round_rate(c->parent, new_rate);
1389         if (new_rate < 0)
1390                 return new_rate;
1391
1392         clk_lock_save(c->parent, &flags);
1393
1394         c->u.shared_bus_user.rate = new_rate;
1395         ret = tegra_clk_shared_bus_update(c->parent);
1396
1397         clk_unlock_restore(c->parent, &flags);
1398
1399         return ret;
1400 }
1401
1402 static long tegra_clk_shared_bus_round_rate(struct clk *c, unsigned long rate)
1403 {
1404         return clk_round_rate(c->parent, rate);
1405 }
1406
1407 static int tegra_clk_shared_bus_enable(struct clk *c)
1408 {
1409         unsigned long flags;
1410         int ret;
1411
1412         clk_lock_save(c->parent, &flags);
1413
1414         c->u.shared_bus_user.enabled = true;
1415         ret = tegra_clk_shared_bus_update(c->parent);
1416
1417         clk_unlock_restore(c->parent, &flags);
1418
1419         return ret;
1420 }
1421
1422 static void tegra_clk_shared_bus_disable(struct clk *c)
1423 {
1424         unsigned long flags;
1425         int ret;
1426
1427         clk_lock_save(c->parent, &flags);
1428
1429         c->u.shared_bus_user.enabled = false;
1430         ret = tegra_clk_shared_bus_update(c->parent);
1431         WARN_ON_ONCE(ret);
1432
1433         clk_unlock_restore(c->parent, &flags);
1434 }
1435
1436 static struct clk_ops tegra_clk_shared_bus_ops = {
1437         .init = tegra_clk_shared_bus_init,
1438         .enable = tegra_clk_shared_bus_enable,
1439         .disable = tegra_clk_shared_bus_disable,
1440         .set_rate = tegra_clk_shared_bus_set_rate,
1441         .round_rate = tegra_clk_shared_bus_round_rate,
1442 };
1443
1444
1445 /* Clock definitions */
1446 static struct clk tegra_clk_32k = {
1447         .name = "clk_32k",
1448         .rate = 32768,
1449         .ops  = NULL,
1450         .max_rate = 32768,
1451 };
1452
1453 static struct clk_pll_freq_table tegra_pll_s_freq_table[] = {
1454         {32768, 12000000, 366, 1, 1, 0},
1455         {32768, 13000000, 397, 1, 1, 0},
1456         {32768, 19200000, 586, 1, 1, 0},
1457         {32768, 26000000, 793, 1, 1, 0},
1458         {0, 0, 0, 0, 0, 0},
1459 };
1460
1461 static struct clk tegra_pll_s = {
1462         .name      = "pll_s",
1463         .flags     = PLL_ALT_MISC_REG,
1464         .ops       = &tegra_pll_ops,
1465         .parent    = &tegra_clk_32k,
1466         .max_rate  = 26000000,
1467         .reg       = 0xf0,
1468         .u.pll = {
1469                 .input_min = 32768,
1470                 .input_max = 32768,
1471                 .cf_min    = 0, /* FIXME */
1472                 .cf_max    = 0, /* FIXME */
1473                 .vco_min   = 12000000,
1474                 .vco_max   = 26000000,
1475                 .freq_table = tegra_pll_s_freq_table,
1476                 .lock_delay = 300,
1477         },
1478 };
1479
1480 static struct clk_mux_sel tegra_clk_m_sel[] = {
1481         { .input = &tegra_clk_32k, .value = 0},
1482         { .input = &tegra_pll_s,  .value = 1},
1483         { 0, 0},
1484 };
1485
1486 static struct clk tegra_clk_m = {
1487         .name      = "clk_m",
1488         .flags     = ENABLE_ON_INIT,
1489         .ops       = &tegra_clk_m_ops,
1490         .inputs    = tegra_clk_m_sel,
1491         .reg       = 0x1fc,
1492         .reg_shift = 28,
1493         .max_rate  = 26000000,
1494 };
1495
1496 static struct clk_pll_freq_table tegra_pll_c_freq_table[] = {
1497         { 12000000, 522000000, 348, 8, 1, 8},
1498         { 13000000, 522000000, 522, 13, 1, 8},
1499         { 19200000, 522000000, 435, 16, 1, 8},
1500         { 26000000, 522000000, 522, 26, 1, 8},
1501         { 12000000, 598000000, 598, 12, 1, 8},
1502         { 13000000, 598000000, 598, 13, 1, 8},
1503         { 19200000, 598000000, 375, 12, 1, 6},
1504         { 26000000, 598000000, 598, 26, 1, 8},
1505         { 0, 0, 0, 0, 0, 0 },
1506 };
1507
1508 static struct clk tegra_pll_c = {
1509         .name      = "pll_c",
1510         .flags     = PLL_HAS_CPCON,
1511         .ops       = &tegra_pll_ops,
1512         .reg       = 0x80,
1513         .parent    = &tegra_clk_m,
1514         .max_rate  = 600000000,
1515         .u.pll = {
1516                 .input_min = 2000000,
1517                 .input_max = 31000000,
1518                 .cf_min    = 1000000,
1519                 .cf_max    = 6000000,
1520                 .vco_min   = 20000000,
1521                 .vco_max   = 1400000000,
1522                 .freq_table = tegra_pll_c_freq_table,
1523                 .lock_delay = 300,
1524         },
1525 };
1526
1527 static struct clk tegra_pll_c_out1 = {
1528         .name      = "pll_c_out1",
1529         .ops       = &tegra_pll_div_ops,
1530         .flags     = DIV_U71,
1531         .parent    = &tegra_pll_c,
1532         .reg       = 0x84,
1533         .reg_shift = 0,
1534         .max_rate  = 600000000,
1535 };
1536
1537 static struct clk_pll_freq_table tegra_pll_m_freq_table[] = {
1538         { 12000000, 666000000, 666, 12, 1, 8},
1539         { 13000000, 666000000, 666, 13, 1, 8},
1540         { 19200000, 666000000, 555, 16, 1, 8},
1541         { 26000000, 666000000, 666, 26, 1, 8},
1542         { 12000000, 600000000, 600, 12, 1, 8},
1543         { 13000000, 600000000, 600, 13, 1, 8},
1544         { 19200000, 600000000, 375, 12, 1, 6},
1545         { 26000000, 600000000, 600, 26, 1, 8},
1546         { 0, 0, 0, 0, 0, 0 },
1547 };
1548
1549 static struct clk tegra_pll_m = {
1550         .name      = "pll_m",
1551         .flags     = PLL_HAS_CPCON,
1552         .ops       = &tegra_pll_ops,
1553         .reg       = 0x90,
1554         .parent    = &tegra_clk_m,
1555         .max_rate  = 800000000,
1556         .u.pll = {
1557                 .input_min = 2000000,
1558                 .input_max = 31000000,
1559                 .cf_min    = 1000000,
1560                 .cf_max    = 6000000,
1561                 .vco_min   = 20000000,
1562                 .vco_max   = 1200000000,
1563                 .freq_table = tegra_pll_m_freq_table,
1564                 .lock_delay = 300,
1565         },
1566 };
1567
1568 static struct clk tegra_pll_m_out1 = {
1569         .name      = "pll_m_out1",
1570         .ops       = &tegra_pll_div_ops,
1571         .flags     = DIV_U71,
1572         .parent    = &tegra_pll_m,
1573         .reg       = 0x94,
1574         .reg_shift = 0,
1575         .max_rate  = 600000000,
1576 };
1577
1578 static struct clk_pll_freq_table tegra_pll_p_freq_table[] = {
1579         { 12000000, 216000000, 432, 12, 2, 8},
1580         { 13000000, 216000000, 432, 13, 2, 8},
1581         { 19200000, 216000000, 90,   4, 2, 1},
1582         { 26000000, 216000000, 432, 26, 2, 8},
1583         { 12000000, 432000000, 432, 12, 1, 8},
1584         { 13000000, 432000000, 432, 13, 1, 8},
1585         { 19200000, 432000000, 90,   4, 1, 1},
1586         { 26000000, 432000000, 432, 26, 1, 8},
1587         { 0, 0, 0, 0, 0, 0 },
1588 };
1589
1590 static struct clk tegra_pll_p = {
1591         .name      = "pll_p",
1592         .flags     = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
1593         .ops       = &tegra_pll_ops,
1594         .reg       = 0xa0,
1595         .parent    = &tegra_clk_m,
1596         .max_rate  = 432000000,
1597         .u.pll = {
1598                 .input_min = 2000000,
1599                 .input_max = 31000000,
1600                 .cf_min    = 1000000,
1601                 .cf_max    = 6000000,
1602                 .vco_min   = 20000000,
1603                 .vco_max   = 1400000000,
1604                 .freq_table = tegra_pll_p_freq_table,
1605                 .lock_delay = 300,
1606         },
1607 };
1608
1609 static struct clk tegra_pll_p_out1 = {
1610         .name      = "pll_p_out1",
1611         .ops       = &tegra_pll_div_ops,
1612         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1613         .parent    = &tegra_pll_p,
1614         .reg       = 0xa4,
1615         .reg_shift = 0,
1616         .max_rate  = 432000000,
1617 };
1618
1619 static struct clk tegra_pll_p_out2 = {
1620         .name      = "pll_p_out2",
1621         .ops       = &tegra_pll_div_ops,
1622         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1623         .parent    = &tegra_pll_p,
1624         .reg       = 0xa4,
1625         .reg_shift = 16,
1626         .max_rate  = 432000000,
1627 };
1628
1629 static struct clk tegra_pll_p_out3 = {
1630         .name      = "pll_p_out3",
1631         .ops       = &tegra_pll_div_ops,
1632         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1633         .parent    = &tegra_pll_p,
1634         .reg       = 0xa8,
1635         .reg_shift = 0,
1636         .max_rate  = 432000000,
1637 };
1638
1639 static struct clk tegra_pll_p_out4 = {
1640         .name      = "pll_p_out4",
1641         .ops       = &tegra_pll_div_ops,
1642         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1643         .parent    = &tegra_pll_p,
1644         .reg       = 0xa8,
1645         .reg_shift = 16,
1646         .max_rate  = 432000000,
1647 };
1648
1649 static struct clk_pll_freq_table tegra_pll_a_freq_table[] = {
1650         { 28800000, 56448000, 49, 25, 1, 1},
1651         { 28800000, 73728000, 64, 25, 1, 1},
1652         { 28800000, 24000000,  5,  6, 1, 1},
1653         { 0, 0, 0, 0, 0, 0 },
1654 };
1655
1656 static struct clk tegra_pll_a = {
1657         .name      = "pll_a",
1658         .flags     = PLL_HAS_CPCON,
1659         .ops       = &tegra_pll_ops,
1660         .reg       = 0xb0,
1661         .parent    = &tegra_pll_p_out1,
1662         .max_rate  = 73728000,
1663         .u.pll = {
1664                 .input_min = 2000000,
1665                 .input_max = 31000000,
1666                 .cf_min    = 1000000,
1667                 .cf_max    = 6000000,
1668                 .vco_min   = 20000000,
1669                 .vco_max   = 1400000000,
1670                 .freq_table = tegra_pll_a_freq_table,
1671                 .lock_delay = 300,
1672         },
1673 };
1674
1675 static struct clk tegra_pll_a_out0 = {
1676         .name      = "pll_a_out0",
1677         .ops       = &tegra_pll_div_ops,
1678         .flags     = DIV_U71,
1679         .parent    = &tegra_pll_a,
1680         .reg       = 0xb4,
1681         .reg_shift = 0,
1682         .max_rate  = 73728000,
1683 };
1684
1685 static struct clk_pll_freq_table tegra_pll_d_freq_table[] = {
1686         { 12000000, 216000000, 216, 12, 1, 4},
1687         { 13000000, 216000000, 216, 13, 1, 4},
1688         { 19200000, 216000000, 135, 12, 1, 3},
1689         { 26000000, 216000000, 216, 26, 1, 4},
1690
1691         { 12000000,   5000000, 10, 24, 1, 4},
1692         { 12000000,  10000000, 10, 12, 1, 4},
1693         { 12000000, 161500000, 323, 24, 1, 4},
1694         { 12000000, 162000000, 162, 12, 1, 4},
1695
1696         { 12000000, 594000000, 594, 12, 1, 8},
1697         { 13000000, 594000000, 594, 13, 1, 8},
1698         { 19200000, 594000000, 495, 16, 1, 8},
1699         { 26000000, 594000000, 594, 26, 1, 8},
1700
1701         { 12000000, 1000000000, 1000, 12, 1, 12},
1702         { 13000000, 1000000000, 1000, 13, 1, 12},
1703         { 19200000, 1000000000, 625,  12, 1, 8},
1704         { 26000000, 1000000000, 1000, 26, 1, 12},
1705
1706         { 0, 0, 0, 0, 0, 0 },
1707 };
1708
1709 static struct clk tegra_pll_d = {
1710         .name      = "pll_d",
1711         .flags     = PLL_HAS_CPCON | PLLD,
1712         .ops       = &tegra_pll_ops,
1713         .reg       = 0xd0,
1714         .parent    = &tegra_clk_m,
1715         .max_rate  = 1000000000,
1716         .u.pll = {
1717                 .input_min = 2000000,
1718                 .input_max = 40000000,
1719                 .cf_min    = 1000000,
1720                 .cf_max    = 6000000,
1721                 .vco_min   = 40000000,
1722                 .vco_max   = 1000000000,
1723                 .freq_table = tegra_pll_d_freq_table,
1724                 .lock_delay = 1000,
1725         },
1726 };
1727
1728 static struct clk tegra_pll_d_out0 = {
1729         .name      = "pll_d_out0",
1730         .ops       = &tegra_pll_div_ops,
1731         .flags     = DIV_2 | PLLD,
1732         .parent    = &tegra_pll_d,
1733         .max_rate  = 500000000,
1734 };
1735
1736 static struct clk_pll_freq_table tegra_pll_u_freq_table[] = {
1737         { 12000000, 480000000, 960, 12, 2, 0},
1738         { 13000000, 480000000, 960, 13, 2, 0},
1739         { 19200000, 480000000, 200, 4,  2, 0},
1740         { 26000000, 480000000, 960, 26, 2, 0},
1741         { 0, 0, 0, 0, 0, 0 },
1742 };
1743
1744 static struct clk tegra_pll_u = {
1745         .name      = "pll_u",
1746         .flags     = PLLU,
1747         .ops       = &tegra_pll_ops,
1748         .reg       = 0xc0,
1749         .parent    = &tegra_clk_m,
1750         .max_rate  = 480000000,
1751         .u.pll = {
1752                 .input_min = 2000000,
1753                 .input_max = 40000000,
1754                 .cf_min    = 1000000,
1755                 .cf_max    = 6000000,
1756                 .vco_min   = 480000000,
1757                 .vco_max   = 960000000,
1758                 .freq_table = tegra_pll_u_freq_table,
1759                 .lock_delay = 1000,
1760         },
1761 };
1762
1763 static struct clk_pll_freq_table tegra_pll_x_freq_table[] = {
1764         /* 1.2 GHz */
1765         { 12000000, 1200000000, 600,  6,  1, 12},
1766         { 13000000, 1200000000, 923,  10, 1, 12},
1767         { 19200000, 1200000000, 750,  12, 1, 8},
1768         { 26000000, 1200000000, 600,  13, 1, 12},
1769
1770         /* 1 GHz */
1771         { 12000000, 1000000000, 1000, 12, 1, 12},
1772         { 13000000, 1000000000, 1000, 13, 1, 12},
1773         { 19200000, 1000000000, 625,  12, 1, 8},
1774         { 26000000, 1000000000, 1000, 26, 1, 12},
1775
1776         /* 912 MHz */
1777         { 12000000, 912000000,  912,  12, 1, 12},
1778         { 13000000, 912000000,  912,  13, 1, 12},
1779         { 19200000, 912000000,  760,  16, 1, 8},
1780         { 26000000, 912000000,  912,  26, 1, 12},
1781
1782         /* 816 MHz */
1783         { 12000000, 816000000,  816,  12, 1, 12},
1784         { 13000000, 816000000,  816,  13, 1, 12},
1785         { 19200000, 816000000,  680,  16, 1, 8},
1786         { 26000000, 816000000,  816,  26, 1, 12},
1787
1788         /* 760 MHz */
1789         { 12000000, 760000000,  760,  12, 1, 12},
1790         { 13000000, 760000000,  760,  13, 1, 12},
1791         { 19200000, 760000000,  950,  24, 1, 8},
1792         { 26000000, 760000000,  760,  26, 1, 12},
1793
1794         /* 750 MHz */
1795         { 12000000, 750000000,  750,  12, 1, 12},
1796         { 13000000, 750000000,  750,  13, 1, 12},
1797         { 19200000, 750000000,  625,  16, 1, 8},
1798         { 26000000, 750000000,  750,  26, 1, 12},
1799
1800         /* 608 MHz */
1801         { 12000000, 608000000,  608,  12, 1, 12},
1802         { 13000000, 608000000,  608,  13, 1, 12},
1803         { 19200000, 608000000,  380,  12, 1, 8},
1804         { 26000000, 608000000,  608,  26, 1, 12},
1805
1806         /* 456 MHz */
1807         { 12000000, 456000000,  456,  12, 1, 12},
1808         { 13000000, 456000000,  456,  13, 1, 12},
1809         { 19200000, 456000000,  380,  16, 1, 8},
1810         { 26000000, 456000000,  456,  26, 1, 12},
1811
1812         /* 312 MHz */
1813         { 12000000, 312000000,  312,  12, 1, 12},
1814         { 13000000, 312000000,  312,  13, 1, 12},
1815         { 19200000, 312000000,  260,  16, 1, 8},
1816         { 26000000, 312000000,  312,  26, 1, 12},
1817
1818         { 0, 0, 0, 0, 0, 0 },
1819 };
1820
1821 static struct clk tegra_pll_x = {
1822         .name      = "pll_x",
1823         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG,
1824         .ops       = &tegra_pll_ops,
1825         .reg       = 0xe0,
1826         .parent    = &tegra_clk_m,
1827         .max_rate  = 1000000000,
1828         .u.pll = {
1829                 .input_min = 2000000,
1830                 .input_max = 31000000,
1831                 .cf_min    = 1000000,
1832                 .cf_max    = 6000000,
1833                 .vco_min   = 20000000,
1834                 .vco_max   = 1200000000,
1835                 .freq_table = tegra_pll_x_freq_table,
1836                 .lock_delay = 300,
1837         },
1838 };
1839
1840 static struct clk_pll_freq_table tegra_pll_e_freq_table[] = {
1841         { 12000000, 100000000,  200,  24, 1, 0 },
1842         { 0, 0, 0, 0, 0, 0 },
1843 };
1844
1845 static struct clk tegra_pll_e = {
1846         .name      = "pll_e",
1847         .flags     = PLL_ALT_MISC_REG,
1848         .ops       = &tegra_plle_ops,
1849         .parent    = &tegra_clk_m,
1850         .reg       = 0xe8,
1851         .max_rate  = 100000000,
1852         .u.pll = {
1853                 .input_min = 12000000,
1854                 .input_max = 12000000,
1855                 .freq_table = tegra_pll_e_freq_table,
1856         },
1857 };
1858
1859 static struct clk tegra_clk_d = {
1860         .name      = "clk_d",
1861         .flags     = PERIPH_NO_RESET,
1862         .ops       = &tegra_clk_double_ops,
1863         .reg       = 0x34,
1864         .reg_shift = 12,
1865         .parent    = &tegra_clk_m,
1866         .max_rate  = 52000000,
1867         .u.periph  = {
1868                 .clk_num = 90,
1869         },
1870 };
1871
1872 /* initialized before peripheral clocks */
1873 static struct clk_mux_sel mux_audio_sync_clk[8+1];
1874 static const struct audio_sources {
1875         const char *name;
1876         int value;
1877 } mux_audio_sync_clk_sources[] = {
1878         { .name = "spdif_in", .value = 0 },
1879         { .name = "i2s1", .value = 1 },
1880         { .name = "i2s2", .value = 2 },
1881         { .name = "pll_a_out0", .value = 4 },
1882 #if 0 /* FIXME: not implemented */
1883         { .name = "ac97", .value = 3 },
1884         { .name = "ext_audio_clk2", .value = 5 },
1885         { .name = "ext_audio_clk1", .value = 6 },
1886         { .name = "ext_vimclk", .value = 7 },
1887 #endif
1888         { 0, 0 }
1889 };
1890
1891 static struct clk tegra_clk_audio = {
1892         .name      = "audio",
1893         .inputs    = mux_audio_sync_clk,
1894         .reg       = 0x38,
1895         .max_rate  = 73728000,
1896         .ops       = &tegra_audio_sync_clk_ops
1897 };
1898
1899 static struct clk tegra_clk_audio_2x = {
1900         .name      = "audio_2x",
1901         .flags     = PERIPH_NO_RESET,
1902         .max_rate  = 48000000,
1903         .ops       = &tegra_clk_double_ops,
1904         .reg       = 0x34,
1905         .reg_shift = 8,
1906         .parent    = &tegra_clk_audio,
1907         .u.periph = {
1908                 .clk_num = 89,
1909         },
1910 };
1911
1912 struct clk_lookup tegra_audio_clk_lookups[] = {
1913         { .con_id = "audio", .clk = &tegra_clk_audio },
1914         { .con_id = "audio_2x", .clk = &tegra_clk_audio_2x }
1915 };
1916
1917 /* This is called after peripheral clocks are initialized, as the
1918  * audio_sync clock depends on some of the peripheral clocks.
1919  */
1920
1921 static void init_audio_sync_clock_mux(void)
1922 {
1923         int i;
1924         struct clk_mux_sel *sel = mux_audio_sync_clk;
1925         const struct audio_sources *src = mux_audio_sync_clk_sources;
1926         struct clk_lookup *lookup;
1927
1928         for (i = 0; src->name; i++, sel++, src++) {
1929                 sel->input = tegra_get_clock_by_name(src->name);
1930                 if (!sel->input)
1931                         pr_err("%s: could not find clk %s\n", __func__,
1932                                 src->name);
1933                 sel->value = src->value;
1934         }
1935
1936         lookup = tegra_audio_clk_lookups;
1937         for (i = 0; i < ARRAY_SIZE(tegra_audio_clk_lookups); i++, lookup++) {
1938                 clk_init(lookup->clk);
1939                 clkdev_add(lookup);
1940         }
1941 }
1942
1943 static struct clk_mux_sel mux_cclk[] = {
1944         { .input = &tegra_clk_m,        .value = 0},
1945         { .input = &tegra_pll_c,        .value = 1},
1946         { .input = &tegra_clk_32k,      .value = 2},
1947         { .input = &tegra_pll_m,        .value = 3},
1948         { .input = &tegra_pll_p,        .value = 4},
1949         { .input = &tegra_pll_p_out4,   .value = 5},
1950         { .input = &tegra_pll_p_out3,   .value = 6},
1951         { .input = &tegra_clk_d,        .value = 7},
1952         { .input = &tegra_pll_x,        .value = 8},
1953         { 0, 0},
1954 };
1955
1956 static struct clk_mux_sel mux_sclk[] = {
1957         { .input = &tegra_clk_m,        .value = 0},
1958         { .input = &tegra_pll_c_out1,   .value = 1},
1959         { .input = &tegra_pll_p_out4,   .value = 2},
1960         { .input = &tegra_pll_p_out3,   .value = 3},
1961         { .input = &tegra_pll_p_out2,   .value = 4},
1962         { .input = &tegra_clk_d,        .value = 5},
1963         { .input = &tegra_clk_32k,      .value = 6},
1964         { .input = &tegra_pll_m_out1,   .value = 7},
1965         { 0, 0},
1966 };
1967
1968 static struct clk tegra_clk_cclk = {
1969         .name   = "cclk",
1970         .inputs = mux_cclk,
1971         .reg    = 0x20,
1972         .ops    = &tegra_super_ops,
1973         .max_rate = 1000000000,
1974 };
1975
1976 static struct clk tegra_clk_sclk = {
1977         .name   = "sclk",
1978         .inputs = mux_sclk,
1979         .reg    = 0x28,
1980         .ops    = &tegra_super_ops,
1981         .max_rate = 240000000,
1982         .min_rate = 120000000,
1983 };
1984
1985 static struct clk tegra_clk_virtual_cpu = {
1986         .name      = "cpu",
1987         .parent    = &tegra_clk_cclk,
1988         .ops       = &tegra_cpu_ops,
1989         .max_rate  = 1000000000,
1990         .u.cpu = {
1991                 .main      = &tegra_pll_x,
1992                 .backup    = &tegra_pll_p,
1993         },
1994 };
1995
1996 static struct clk tegra_clk_twd = {
1997         .name     = "twd",
1998         .parent   = &tegra_clk_cclk,
1999         .ops      = NULL,
2000         .max_rate = 250000000,
2001         .mul      = 1,
2002         .div      = 4,
2003 };
2004
2005 static struct clk tegra_clk_cop = {
2006         .name      = "cop",
2007         .parent    = &tegra_clk_sclk,
2008         .ops       = &tegra_cop_ops,
2009         .max_rate  = 240000000,
2010 };
2011
2012 static struct clk tegra_clk_hclk = {
2013         .name           = "hclk",
2014         .flags          = DIV_BUS,
2015         .parent         = &tegra_clk_sclk,
2016         .reg            = 0x30,
2017         .reg_shift      = 4,
2018         .ops            = &tegra_bus_ops,
2019         .max_rate       = 240000000,
2020 };
2021
2022 static struct clk tegra_clk_pclk = {
2023         .name           = "pclk",
2024         .flags          = DIV_BUS,
2025         .parent         = &tegra_clk_hclk,
2026         .reg            = 0x30,
2027         .reg_shift      = 0,
2028         .ops            = &tegra_bus_ops,
2029         .max_rate       = 120000000,
2030 };
2031
2032 static struct clk tegra_clk_blink = {
2033         .name           = "blink",
2034         .parent         = &tegra_clk_32k,
2035         .reg            = 0x40,
2036         .ops            = &tegra_blink_clk_ops,
2037         .max_rate       = 32768,
2038 };
2039 static struct clk_mux_sel mux_dev1_clk[] = {
2040         { .input = &tegra_clk_m,        .value = 0 },
2041         { .input = &tegra_pll_a_out0,   .value = 1 },
2042         { .input = &tegra_pll_m_out1,   .value = 2 },
2043         { .input = &tegra_clk_audio,    .value = 3 },
2044         { 0, 0 }
2045 };
2046
2047 static struct clk_mux_sel mux_dev2_clk[] = {
2048         { .input = &tegra_clk_m,        .value = 0 },
2049         { .input = &tegra_clk_hclk,     .value = 1 },
2050         { .input = &tegra_clk_pclk,     .value = 2 },
2051         { .input = &tegra_pll_p_out4,   .value = 3 },
2052         { 0, 0 }
2053 };
2054
2055 /* dap_mclk1, belongs to the cdev1 pingroup. */
2056 static struct clk tegra_clk_cdev1 = {
2057         .name      = "cdev1",
2058         .ops       = &tegra_cdev_clk_ops,
2059         .inputs    = mux_dev1_clk,
2060         .u.periph  = {
2061                 .clk_num = 94,
2062         },
2063         .flags     = MUX,
2064 };
2065
2066 /* dap_mclk2, belongs to the cdev2 pingroup. */
2067 static struct clk tegra_clk_cdev2 = {
2068         .name      = "cdev2",
2069         .ops       = &tegra_cdev_clk_ops,
2070         .inputs    = mux_dev2_clk,
2071         .u.periph  = {
2072                 .clk_num = 93,
2073         },
2074         .flags     = MUX,
2075 };
2076
2077 static struct clk_mux_sel mux_pllm_pllc_pllp_plla[] = {
2078         { .input = &tegra_pll_m, .value = 0},
2079         { .input = &tegra_pll_c, .value = 1},
2080         { .input = &tegra_pll_p, .value = 2},
2081         { .input = &tegra_pll_a_out0, .value = 3},
2082         { 0, 0},
2083 };
2084
2085 static struct clk_mux_sel mux_pllm_pllc_pllp_clkm[] = {
2086         { .input = &tegra_pll_m, .value = 0},
2087         { .input = &tegra_pll_c, .value = 1},
2088         { .input = &tegra_pll_p, .value = 2},
2089         { .input = &tegra_clk_m, .value = 3},
2090         { 0, 0},
2091 };
2092
2093 static struct clk_mux_sel mux_pllp_pllc_pllm_clkm[] = {
2094         { .input = &tegra_pll_p, .value = 0},
2095         { .input = &tegra_pll_c, .value = 1},
2096         { .input = &tegra_pll_m, .value = 2},
2097         { .input = &tegra_clk_m, .value = 3},
2098         { 0, 0},
2099 };
2100
2101 static struct clk_mux_sel mux_pllaout0_audio2x_pllp_clkm[] = {
2102         {.input = &tegra_pll_a_out0, .value = 0},
2103         {.input = &tegra_clk_audio_2x, .value = 1},
2104         {.input = &tegra_pll_p, .value = 2},
2105         {.input = &tegra_clk_m, .value = 3},
2106         { 0, 0},
2107 };
2108
2109 static struct clk_mux_sel mux_pllp_plld_pllc_clkm[] = {
2110         {.input = &tegra_pll_p, .value = 0},
2111         {.input = &tegra_pll_d_out0, .value = 1},
2112         {.input = &tegra_pll_c, .value = 2},
2113         {.input = &tegra_clk_m, .value = 3},
2114         { 0, 0},
2115 };
2116
2117 static struct clk_mux_sel mux_pllp_pllc_audio_clkm_clk32[] = {
2118         {.input = &tegra_pll_p,     .value = 0},
2119         {.input = &tegra_pll_c,     .value = 1},
2120         {.input = &tegra_clk_audio,     .value = 2},
2121         {.input = &tegra_clk_m,     .value = 3},
2122         {.input = &tegra_clk_32k,   .value = 4},
2123         { 0, 0},
2124 };
2125
2126 static struct clk_mux_sel mux_pllp_pllc_pllm[] = {
2127         {.input = &tegra_pll_p,     .value = 0},
2128         {.input = &tegra_pll_c,     .value = 1},
2129         {.input = &tegra_pll_m,     .value = 2},
2130         { 0, 0},
2131 };
2132
2133 static struct clk_mux_sel mux_clk_m[] = {
2134         { .input = &tegra_clk_m, .value = 0},
2135         { 0, 0},
2136 };
2137
2138 static struct clk_mux_sel mux_pllp_out3[] = {
2139         { .input = &tegra_pll_p_out3, .value = 0},
2140         { 0, 0},
2141 };
2142
2143 static struct clk_mux_sel mux_plld_out0[] = {
2144         { .input = &tegra_pll_d_out0, .value = 0},
2145         { 0, 0},
2146 };
2147
2148 static struct clk_mux_sel mux_clk_32k[] = {
2149         { .input = &tegra_clk_32k, .value = 0},
2150         { 0, 0},
2151 };
2152
2153 static struct clk_mux_sel mux_pclk[] = {
2154         { .input = &tegra_clk_pclk, .value = 0},
2155         { 0, 0},
2156 };
2157
2158 static struct clk tegra_clk_emc = {
2159         .name = "emc",
2160         .ops = &tegra_emc_clk_ops,
2161         .reg = 0x19c,
2162         .max_rate = 800000000,
2163         .inputs = mux_pllm_pllc_pllp_clkm,
2164         .flags = MUX | DIV_U71 | PERIPH_EMC_ENB,
2165         .u.periph = {
2166                 .clk_num = 57,
2167         },
2168 };
2169
2170 #define PERIPH_CLK(_name, _dev, _con, _clk_num, _reg, _reg_shift, _max, _inputs, _flags) \
2171         {                                               \
2172                 .name      = _name,                     \
2173                 .lookup    = {                          \
2174                         .dev_id    = _dev,              \
2175                         .con_id    = _con,              \
2176                 },                                      \
2177                 .ops       = &tegra_periph_clk_ops,     \
2178                 .reg       = _reg,                      \
2179                 .reg_shift = _reg_shift,                \
2180                 .inputs    = _inputs,                   \
2181                 .flags     = _flags,                    \
2182                 .max_rate  = _max,                      \
2183                 .u.periph = {                           \
2184                         .clk_num   = _clk_num,          \
2185                 },                                      \
2186         }
2187
2188 #define SHARED_CLK(_name, _dev, _con, _parent)          \
2189         {                                               \
2190                 .name      = _name,                     \
2191                 .lookup    = {                          \
2192                         .dev_id    = _dev,              \
2193                         .con_id    = _con,              \
2194                 },                                      \
2195                 .ops       = &tegra_clk_shared_bus_ops, \
2196                 .parent = _parent,                      \
2197         }
2198
2199 struct clk tegra_list_clks[] = {
2200         PERIPH_CLK("apbdma",    "tegra-dma",            NULL,   34,     0,      0x31E,  108000000, mux_pclk,                    0),
2201         PERIPH_CLK("rtc",       "rtc-tegra",            NULL,   4,      0,      0x31E,  32768,     mux_clk_32k,                 PERIPH_NO_RESET),
2202         PERIPH_CLK("kbc",       "tegra-kbc",            NULL,   36,     0,      0x31E,  32768,     mux_clk_32k, PERIPH_NO_RESET),
2203         PERIPH_CLK("timer",     "timer",                NULL,   5,      0,      0x31E,  26000000,  mux_clk_m,                   0),
2204         PERIPH_CLK("i2s1",      "i2s.0",                NULL,   11,     0x100,  0x31E,  26000000,  mux_pllaout0_audio2x_pllp_clkm,      MUX | DIV_U71),
2205         PERIPH_CLK("i2s2",      "i2s.1",                NULL,   18,     0x104,  0x31E,  26000000,  mux_pllaout0_audio2x_pllp_clkm,      MUX | DIV_U71),
2206         PERIPH_CLK("kfuse",     "kfuse-tegra",          NULL,   40,     0,      0x31E,  26000000,  mux_clk_m,                   0),
2207         PERIPH_CLK("spdif_out", "spdif_out",            NULL,   10,     0x108,  0x31E,  100000000, mux_pllaout0_audio2x_pllp_clkm,      MUX | DIV_U71),
2208         PERIPH_CLK("spdif_in",  "spdif_in",             NULL,   10,     0x10c,  0x31E,  100000000, mux_pllp_pllc_pllm,          MUX | DIV_U71),
2209         PERIPH_CLK("pwm",       "pwm",                  NULL,   17,     0x110,  0x71C,  432000000, mux_pllp_pllc_audio_clkm_clk32,      MUX | DIV_U71),
2210         PERIPH_CLK("spi",       "spi",                  NULL,   43,     0x114,  0x31E,  40000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2211         PERIPH_CLK("xio",       "xio",                  NULL,   45,     0x120,  0x31E,  150000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2212         PERIPH_CLK("twc",       "twc",                  NULL,   16,     0x12c,  0x31E,  150000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2213         PERIPH_CLK("sbc1",      "spi_tegra.0",          NULL,   41,     0x134,  0x31E,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2214         PERIPH_CLK("sbc2",      "spi_tegra.1",          NULL,   44,     0x118,  0x31E,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2215         PERIPH_CLK("sbc3",      "spi_tegra.2",          NULL,   46,     0x11c,  0x31E,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2216         PERIPH_CLK("sbc4",      "spi_tegra.3",          NULL,   68,     0x1b4,  0x31E,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2217         PERIPH_CLK("ide",       "ide",                  NULL,   25,     0x144,  0x31E,  100000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* requires min voltage */
2218         PERIPH_CLK("ndflash",   "tegra_nand",           NULL,   13,     0x160,  0x31E,  164000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2219         PERIPH_CLK("vfir",      "vfir",                 NULL,   7,      0x168,  0x31E,  72000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2220         PERIPH_CLK("sdmmc1",    "sdhci-tegra.0",        NULL,   14,     0x150,  0x31E,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2221         PERIPH_CLK("sdmmc2",    "sdhci-tegra.1",        NULL,   9,      0x154,  0x31E,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2222         PERIPH_CLK("sdmmc3",    "sdhci-tegra.2",        NULL,   69,     0x1bc,  0x31E,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2223         PERIPH_CLK("sdmmc4",    "sdhci-tegra.3",        NULL,   15,     0x164,  0x31E,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2224         PERIPH_CLK("vcp",       "tegra-avp",            "vcp",  29,     0,      0x31E,  250000000, mux_clk_m,                   0),
2225         PERIPH_CLK("bsea",      "tegra-avp",            "bsea", 62,     0,      0x31E,  250000000, mux_clk_m,                   0),
2226         PERIPH_CLK("bsev",      "tegra-aes",            "bsev", 63,     0,      0x31E,  250000000, mux_clk_m,                   0),
2227         PERIPH_CLK("vde",       "tegra-avp",            "vde",  61,     0x1c8,  0x31E,  250000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage and process_id */
2228         PERIPH_CLK("csite",     "csite",                NULL,   73,     0x1d4,  0x31E,  144000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* max rate ??? */
2229         /* FIXME: what is la? */
2230         PERIPH_CLK("la",        "la",                   NULL,   76,     0x1f8,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2231         PERIPH_CLK("owr",       "tegra_w1",             NULL,   71,     0x1cc,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2232         PERIPH_CLK("nor",       "nor",                  NULL,   42,     0x1d0,  0x31E,  92000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* requires min voltage */
2233         PERIPH_CLK("mipi",      "mipi",                 NULL,   50,     0x174,  0x31E,  60000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2234         PERIPH_CLK("i2c1",      "tegra-i2c.0",          NULL,   12,     0x124,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2235         PERIPH_CLK("i2c2",      "tegra-i2c.1",          NULL,   54,     0x198,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2236         PERIPH_CLK("i2c3",      "tegra-i2c.2",          NULL,   67,     0x1b8,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2237         PERIPH_CLK("dvc",       "tegra-i2c.3",          NULL,   47,     0x128,  0x31E,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2238         PERIPH_CLK("i2c1_i2c",  "tegra-i2c.0",          "i2c",  0,      0,      0x31E,  72000000,  mux_pllp_out3,                       0),
2239         PERIPH_CLK("i2c2_i2c",  "tegra-i2c.1",          "i2c",  0,      0,      0x31E,  72000000,  mux_pllp_out3,                       0),
2240         PERIPH_CLK("i2c3_i2c",  "tegra-i2c.2",          "i2c",  0,      0,      0x31E,  72000000,  mux_pllp_out3,                       0),
2241         PERIPH_CLK("dvc_i2c",   "tegra-i2c.3",          "i2c",  0,      0,      0x31E,  72000000,  mux_pllp_out3,                       0),
2242         PERIPH_CLK("uarta",     "uart.0",               NULL,   6,      0x178,  0x31E,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2243         PERIPH_CLK("uartb",     "uart.1",               NULL,   7,      0x17c,  0x31E,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2244         PERIPH_CLK("uartc",     "uart.2",               NULL,   55,     0x1a0,  0x31E,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2245         PERIPH_CLK("uartd",     "uart.3",               NULL,   65,     0x1c0,  0x31E,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2246         PERIPH_CLK("uarte",     "uart.4",               NULL,   66,     0x1c4,  0x31E,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2247         PERIPH_CLK("3d",        "3d",                   NULL,   24,     0x158,  0x31E,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_MANUAL_RESET), /* scales with voltage and process_id */
2248         PERIPH_CLK("2d",        "2d",                   NULL,   21,     0x15c,  0x31E,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2249         PERIPH_CLK("vi",        "tegra_camera",         "vi",   20,     0x148,  0x31E,  150000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2250         PERIPH_CLK("vi_sensor", "tegra_camera",         "vi_sensor",    20,     0x1a8,  0x31E,  150000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_NO_RESET), /* scales with voltage and process_id */
2251         PERIPH_CLK("epp",       "epp",                  NULL,   19,     0x16c,  0x31E,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2252         PERIPH_CLK("mpe",       "mpe",                  NULL,   60,     0x170,  0x31E,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2253         PERIPH_CLK("host1x",    "host1x",               NULL,   28,     0x180,  0x31E,  166000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2254         PERIPH_CLK("cve",       "cve",                  NULL,   49,     0x140,  0x31E,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2255         PERIPH_CLK("tvo",       "tvo",                  NULL,   49,     0x188,  0x31E,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2256         PERIPH_CLK("hdmi",      "hdmi",                 NULL,   51,     0x18c,  0x31E,  600000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2257         PERIPH_CLK("tvdac",     "tvdac",                NULL,   53,     0x194,  0x31E,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2258         PERIPH_CLK("disp1",     "tegradc.0",            NULL,   27,     0x138,  0x31E,  600000000, mux_pllp_plld_pllc_clkm,     MUX), /* scales with voltage and process_id */
2259         PERIPH_CLK("disp2",     "tegradc.1",            NULL,   26,     0x13c,  0x31E,  600000000, mux_pllp_plld_pllc_clkm,     MUX), /* scales with voltage and process_id */
2260         PERIPH_CLK("usbd",      "fsl-tegra-udc",        NULL,   22,     0,      0x31E,  480000000, mux_clk_m,                   0), /* requires min voltage */
2261         PERIPH_CLK("usb2",      "tegra-ehci.1",         NULL,   58,     0,      0x31E,  480000000, mux_clk_m,                   0), /* requires min voltage */
2262         PERIPH_CLK("usb3",      "tegra-ehci.2",         NULL,   59,     0,      0x31E,  480000000, mux_clk_m,                   0), /* requires min voltage */
2263         PERIPH_CLK("dsi",       "dsi",                  NULL,   48,     0,      0x31E,  500000000, mux_plld_out0,               0), /* scales with voltage */
2264         PERIPH_CLK("csi",       "tegra_camera",         "csi",  52,     0,      0x31E,  72000000,  mux_pllp_out3,               0),
2265         PERIPH_CLK("isp",       "tegra_camera",         "isp",  23,     0,      0x31E,  150000000, mux_clk_m,                   0), /* same frequency as VI */
2266         PERIPH_CLK("csus",      "tegra_camera",         "csus", 92,     0,      0x31E,  150000000, mux_clk_m,                   PERIPH_NO_RESET),
2267         PERIPH_CLK("pex",       NULL,                   "pex",  70,     0,      0x31E,  26000000,  mux_clk_m,                   PERIPH_MANUAL_RESET),
2268         PERIPH_CLK("afi",       NULL,                   "afi",  72,     0,      0x31E,  26000000,  mux_clk_m,                   PERIPH_MANUAL_RESET),
2269         PERIPH_CLK("pcie_xclk", NULL,             "pcie_xclk",  74,     0,      0x31E,  26000000,  mux_clk_m,                   PERIPH_MANUAL_RESET),
2270         PERIPH_CLK("stat_mon",  "tegra-stat-mon",       NULL,   37,     0,      0x31E,  26000000,  mux_clk_m,                   0),
2271
2272         SHARED_CLK("avp.sclk",  "tegra-avp",            "sclk", &tegra_clk_sclk),
2273         SHARED_CLK("avp.emc",   "tegra-avp",            "emc",  &tegra_clk_emc),
2274         SHARED_CLK("cpu.emc",   "cpu",                  "emc",  &tegra_clk_emc),
2275         SHARED_CLK("disp1.emc", "tegradc.0",            "emc",  &tegra_clk_emc),
2276         SHARED_CLK("disp2.emc", "tegradc.1",            "emc",  &tegra_clk_emc),
2277         SHARED_CLK("hdmi.emc",  "hdmi",                 "emc",  &tegra_clk_emc),
2278         SHARED_CLK("host.emc",  "tegra_grhost",         "emc",  &tegra_clk_emc),
2279         SHARED_CLK("usbd.emc",  "fsl-tegra-udc",        "emc",  &tegra_clk_emc),
2280         SHARED_CLK("usb1.emc",  "tegra-ehci.0",         "emc",  &tegra_clk_emc),
2281         SHARED_CLK("usb2.emc",  "tegra-ehci.1",         "emc",  &tegra_clk_emc),
2282         SHARED_CLK("usb3.emc",  "tegra-ehci.2",         "emc",  &tegra_clk_emc),
2283 };
2284
2285 #define CLK_DUPLICATE(_name, _dev, _con)                \
2286         {                                               \
2287                 .name   = _name,                        \
2288                 .lookup = {                             \
2289                         .dev_id = _dev,                 \
2290                         .con_id         = _con,         \
2291                 },                                      \
2292         }
2293
2294 /* Some clocks may be used by different drivers depending on the board
2295  * configuration.  List those here to register them twice in the clock lookup
2296  * table under two names.
2297  */
2298 struct clk_duplicate tegra_clk_duplicates[] = {
2299         CLK_DUPLICATE("uarta",  "tegra_uart.0", NULL),
2300         CLK_DUPLICATE("uartb",  "tegra_uart.1", NULL),
2301         CLK_DUPLICATE("uartc",  "tegra_uart.2", NULL),
2302         CLK_DUPLICATE("uartd",  "tegra_uart.3", NULL),
2303         CLK_DUPLICATE("uarte",  "tegra_uart.4", NULL),
2304         CLK_DUPLICATE("usbd", "utmip-pad", NULL),
2305         CLK_DUPLICATE("usbd", "tegra-ehci.0", NULL),
2306         CLK_DUPLICATE("usbd", "tegra-otg", NULL),
2307         CLK_DUPLICATE("hdmi", "tegradc.0", "hdmi"),
2308         CLK_DUPLICATE("hdmi", "tegradc.1", "hdmi"),
2309         CLK_DUPLICATE("dsi", "tegradc.0", "dsi"),
2310         CLK_DUPLICATE("dsi", "tegradc.1", "dsi"),
2311         CLK_DUPLICATE("pwm", "tegra_pwm.0", NULL),
2312         CLK_DUPLICATE("pwm", "tegra_pwm.1", NULL),
2313         CLK_DUPLICATE("pwm", "tegra_pwm.2", NULL),
2314         CLK_DUPLICATE("pwm", "tegra_pwm.3", NULL),
2315         CLK_DUPLICATE("host1x", "tegra_grhost", "host1x"),
2316         CLK_DUPLICATE("2d", "tegra_grhost", "gr2d"),
2317         CLK_DUPLICATE("3d", "tegra_grhost", "gr3d"),
2318         CLK_DUPLICATE("epp", "tegra_grhost", "epp"),
2319         CLK_DUPLICATE("mpe", "tegra_grhost", "mpe"),
2320         CLK_DUPLICATE("cop", "tegra-avp", "cop"),
2321         CLK_DUPLICATE("vde", "tegra-aes", "vde"),
2322         CLK_DUPLICATE("twd", "smp_twd", NULL),
2323         CLK_DUPLICATE("bsea", "tegra-aes", "bsea"),
2324 };
2325
2326 #define CLK(dev, con, ck)       \
2327         {                       \
2328                 .dev_id = dev,  \
2329                 .con_id = con,  \
2330                 .clk = ck,      \
2331         }
2332
2333 struct clk *tegra_ptr_clks[] = {
2334         &tegra_clk_32k,
2335         &tegra_pll_s,
2336         &tegra_clk_m,
2337         &tegra_pll_m,
2338         &tegra_pll_m_out1,
2339         &tegra_pll_c,
2340         &tegra_pll_c_out1,
2341         &tegra_pll_p,
2342         &tegra_pll_p_out1,
2343         &tegra_pll_p_out2,
2344         &tegra_pll_p_out3,
2345         &tegra_pll_p_out4,
2346         &tegra_pll_a,
2347         &tegra_pll_a_out0,
2348         &tegra_pll_d,
2349         &tegra_pll_d_out0,
2350         &tegra_pll_u,
2351         &tegra_pll_x,
2352         &tegra_pll_e,
2353         &tegra_clk_cclk,
2354         &tegra_clk_sclk,
2355         &tegra_clk_hclk,
2356         &tegra_clk_pclk,
2357         &tegra_clk_d,
2358         &tegra_clk_cdev1,
2359         &tegra_clk_cdev2,
2360         &tegra_clk_virtual_cpu,
2361         &tegra_clk_blink,
2362         &tegra_clk_cop,
2363         &tegra_clk_emc,
2364         &tegra_clk_twd,
2365 };
2366
2367 /* For some clocks maximum rate limits depend on tegra2 SKU */
2368 #define RATE_LIMIT(_name, _max_rate, _skus...)  \
2369         {                                       \
2370                 .clk_name       = _name,        \
2371                 .max_rate       = _max_rate,    \
2372                 .sku_ids        = {_skus}       \
2373         }
2374
2375 static struct tegra_sku_rate_limit sku_limits[] =
2376 {
2377         RATE_LIMIT("cpu",       750000000, 0x07, 0x10),
2378         RATE_LIMIT("cclk",      750000000, 0x07, 0x10),
2379         RATE_LIMIT("pll_x",     750000000, 0x07, 0x10),
2380
2381         RATE_LIMIT("cpu",       1000000000, 0x04, 0x08, 0x0F),
2382         RATE_LIMIT("cclk",      1000000000, 0x04, 0x08, 0x0F),
2383         RATE_LIMIT("pll_x",     1000000000, 0x04, 0x08, 0x0F),
2384
2385         RATE_LIMIT("cpu",       1200000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2386         RATE_LIMIT("cclk",      1200000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2387         RATE_LIMIT("pll_x",     1200000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2388
2389         RATE_LIMIT("sclk",      240000000, 0x04, 0x7, 0x08, 0x0F, 0x10),
2390         RATE_LIMIT("hclk",      240000000, 0x04, 0x7, 0x08, 0x0F, 0x10),
2391         RATE_LIMIT("avp.sclk",  240000000, 0x04, 0x7, 0x08, 0x0F, 0x10),
2392         RATE_LIMIT("vde",       240000000, 0x04, 0x7, 0x08, 0x0F, 0x10),
2393         RATE_LIMIT("3d",        300000000, 0x04, 0x7, 0x08, 0x0F, 0x10),
2394
2395         RATE_LIMIT("host1x",    108000000, 0x0F),
2396
2397         RATE_LIMIT("sclk",      300000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2398         RATE_LIMIT("hclk",      300000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2399         RATE_LIMIT("avp.sclk",  300000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2400         RATE_LIMIT("vde",       300000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2401         RATE_LIMIT("3d",        400000000, 0x14, 0x17, 0x18, 0x1B, 0x1C),
2402 };
2403
2404 static void tegra2_init_sku_limits(void)
2405 {
2406         int i, j;
2407         struct clk *c;
2408         int sku_id = tegra_sku_id();
2409
2410         for (i = 0; i < ARRAY_SIZE(sku_limits); i++) {
2411                 struct tegra_sku_rate_limit *limit = &sku_limits[i];
2412
2413                 for (j = 0; (j < MAX_SAME_LIMIT_SKU_IDS) &&
2414                       (limit->sku_ids[j] != 0); j++) {
2415                         if (limit->sku_ids[j] == sku_id) {
2416                                 c = tegra_get_clock_by_name(limit->clk_name);
2417                                 if (!c) {
2418                                         pr_err("%s: Unknown sku clock %s\n",
2419                                                __func__, limit->clk_name);
2420                                         continue;
2421                                 }
2422                                 c->max_rate = limit->max_rate;
2423                         }
2424                 }
2425         }
2426 }
2427
2428 static void tegra2_init_one_clock(struct clk *c)
2429 {
2430         clk_init(c);
2431         INIT_LIST_HEAD(&c->shared_bus_list);
2432         if (!c->lookup.dev_id && !c->lookup.con_id)
2433                 c->lookup.con_id = c->name;
2434         c->lookup.clk = c;
2435         clkdev_add(&c->lookup);
2436 }
2437
2438 #ifdef CONFIG_CPU_FREQ
2439
2440 /*
2441  * Frequency table index must be sequential starting at 0 and frequencies
2442  * must be ascending.
2443  */
2444
2445 static struct cpufreq_frequency_table freq_table_750MHz[] = {
2446         { 0, 216000 },
2447         { 1, 312000 },
2448         { 2, 456000 },
2449         { 3, 608000 },
2450         { 4, 750000 },
2451         { 5, CPUFREQ_TABLE_END },
2452 };
2453
2454 static struct cpufreq_frequency_table freq_table_1p0GHz[] = {
2455         { 0, 216000 },
2456         { 1, 312000 },
2457         { 2, 456000 },
2458         { 3, 608000 },
2459         { 4, 760000 },
2460         { 5, 816000 },
2461         { 6, 912000 },
2462         { 7, 1000000 },
2463         { 8, CPUFREQ_TABLE_END },
2464 };
2465
2466 static struct cpufreq_frequency_table freq_table_1p2GHz[] = {
2467         { 0, 216000 },
2468         { 1, 312000 },
2469         { 2, 456000 },
2470         { 3, 608000 },
2471         { 4, 760000 },
2472         { 5, 816000 },
2473         { 6, 912000 },
2474         { 7, 1000000 },
2475         { 8, 1200000 },
2476         { 9, CPUFREQ_TABLE_END },
2477 };
2478
2479 static struct tegra_cpufreq_table_data cpufreq_tables[] = {
2480         { freq_table_750MHz, 1, 4 },
2481         { freq_table_1p0GHz, 2, 6 },
2482         { freq_table_1p2GHz, 2, 7 },
2483 };
2484
2485 struct tegra_cpufreq_table_data *tegra_cpufreq_table_get(void)
2486 {
2487         int i, ret;
2488         struct clk *cpu_clk = tegra_get_clock_by_name("cpu");
2489
2490         for (i = 0; i < ARRAY_SIZE(cpufreq_tables); i++) {
2491                 struct cpufreq_policy policy;
2492                 ret = cpufreq_frequency_table_cpuinfo(
2493                         &policy, cpufreq_tables[i].freq_table);
2494                 BUG_ON(ret);
2495                 if ((policy.max * 1000) == cpu_clk->max_rate)
2496                         return &cpufreq_tables[i];
2497         }
2498         pr_err("%s: No cpufreq table matching cpu range", __func__);
2499         BUG();
2500         return &cpufreq_tables[0];
2501 }
2502 #endif
2503
2504 #ifdef CONFIG_PM
2505 static u32 clk_rst_suspend[RST_DEVICES_NUM + CLK_OUT_ENB_NUM +
2506                            PERIPH_CLK_SOURCE_NUM + 22];
2507
2508 static int tegra_clk_suspend(void)
2509 {
2510         unsigned long off, i;
2511         u32 *ctx = clk_rst_suspend;
2512
2513         *ctx++ = clk_readl(OSC_CTRL) & OSC_CTRL_MASK;
2514         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_BASE);
2515         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
2516         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_BASE);
2517         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
2518         *ctx++ = clk_readl(tegra_pll_s.reg + PLL_BASE);
2519         *ctx++ = clk_readl(tegra_pll_s.reg + PLL_MISC(&tegra_pll_s));
2520         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_BASE);
2521         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
2522         *ctx++ = clk_readl(tegra_pll_u.reg + PLL_BASE);
2523         *ctx++ = clk_readl(tegra_pll_u.reg + PLL_MISC(&tegra_pll_u));
2524
2525         *ctx++ = clk_readl(tegra_pll_m_out1.reg);
2526         *ctx++ = clk_readl(tegra_pll_a_out0.reg);
2527         *ctx++ = clk_readl(tegra_pll_c_out1.reg);
2528
2529         *ctx++ = clk_readl(tegra_clk_cclk.reg);
2530         *ctx++ = clk_readl(tegra_clk_cclk.reg + SUPER_CLK_DIVIDER);
2531
2532         *ctx++ = clk_readl(tegra_clk_sclk.reg);
2533         *ctx++ = clk_readl(tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
2534         *ctx++ = clk_readl(tegra_clk_pclk.reg);
2535
2536         *ctx++ = clk_readl(tegra_clk_audio.reg);
2537
2538         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
2539                         off += 4) {
2540                 if (off == PERIPH_CLK_SOURCE_EMC)
2541                         continue;
2542                 *ctx++ = clk_readl(off);
2543         }
2544
2545         off = RST_DEVICES;
2546         for (i = 0; i < RST_DEVICES_NUM; i++, off += 4)
2547                 *ctx++ = clk_readl(off);
2548
2549         off = CLK_OUT_ENB;
2550         for (i = 0; i < CLK_OUT_ENB_NUM; i++, off += 4)
2551                 *ctx++ = clk_readl(off);
2552
2553         *ctx++ = clk_readl(MISC_CLK_ENB);
2554         *ctx++ = clk_readl(CLK_MASK_ARM);
2555
2556         BUG_ON(ctx - clk_rst_suspend != ARRAY_SIZE(clk_rst_suspend));
2557
2558         return 0;
2559 }
2560
2561 static void tegra_clk_resume(void)
2562 {
2563         unsigned long off, i;
2564         const u32 *ctx = clk_rst_suspend;
2565         u32 val;
2566
2567         val = clk_readl(OSC_CTRL) & ~OSC_CTRL_MASK;
2568         val |= *ctx++;
2569         clk_writel(val, OSC_CTRL);
2570
2571         clk_writel(*ctx++, tegra_pll_c.reg + PLL_BASE);
2572         clk_writel(*ctx++, tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
2573         clk_writel(*ctx++, tegra_pll_a.reg + PLL_BASE);
2574         clk_writel(*ctx++, tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
2575         clk_writel(*ctx++, tegra_pll_s.reg + PLL_BASE);
2576         clk_writel(*ctx++, tegra_pll_s.reg + PLL_MISC(&tegra_pll_s));
2577         clk_writel(*ctx++, tegra_pll_d.reg + PLL_BASE);
2578         clk_writel(*ctx++, tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
2579         clk_writel(*ctx++, tegra_pll_u.reg + PLL_BASE);
2580         clk_writel(*ctx++, tegra_pll_u.reg + PLL_MISC(&tegra_pll_u));
2581         udelay(1000);
2582
2583         clk_writel(*ctx++, tegra_pll_m_out1.reg);
2584         clk_writel(*ctx++, tegra_pll_a_out0.reg);
2585         clk_writel(*ctx++, tegra_pll_c_out1.reg);
2586
2587         clk_writel(*ctx++, tegra_clk_cclk.reg);
2588         clk_writel(*ctx++, tegra_clk_cclk.reg + SUPER_CLK_DIVIDER);
2589
2590         clk_writel(*ctx++, tegra_clk_sclk.reg);
2591         clk_writel(*ctx++, tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
2592         clk_writel(*ctx++, tegra_clk_pclk.reg);
2593
2594         clk_writel(*ctx++, tegra_clk_audio.reg);
2595
2596         /* enable all clocks before configuring clock sources */
2597         clk_writel(0xbffffff9ul, CLK_OUT_ENB);
2598         clk_writel(0xfefffff7ul, CLK_OUT_ENB + 4);
2599         clk_writel(0x77f01bfful, CLK_OUT_ENB + 8);
2600         wmb();
2601
2602         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
2603                         off += 4) {
2604                 if (off == PERIPH_CLK_SOURCE_EMC)
2605                         continue;
2606                 clk_writel(*ctx++, off);
2607         }
2608         wmb();
2609
2610         off = RST_DEVICES;
2611         for (i = 0; i < RST_DEVICES_NUM; i++, off += 4)
2612                 clk_writel(*ctx++, off);
2613         wmb();
2614
2615         off = CLK_OUT_ENB;
2616         for (i = 0; i < CLK_OUT_ENB_NUM; i++, off += 4)
2617                 clk_writel(*ctx++, off);
2618         wmb();
2619
2620         clk_writel(*ctx++, MISC_CLK_ENB);
2621         clk_writel(*ctx++, CLK_MASK_ARM);
2622 }
2623
2624 #else
2625 #define tegra_clk_suspend NULL
2626 #define tegra_clk_resume NULL
2627 #endif
2628
2629 static struct syscore_ops tegra_clk_syscore_ops = {
2630         .suspend = tegra_clk_suspend,
2631         .resume = tegra_clk_resume,
2632 };
2633
2634 void __init tegra_soc_init_clocks(void)
2635 {
2636         int i;
2637         struct clk *c;
2638
2639         for (i = 0; i < ARRAY_SIZE(tegra_ptr_clks); i++)
2640                 tegra2_init_one_clock(tegra_ptr_clks[i]);
2641
2642         for (i = 0; i < ARRAY_SIZE(tegra_list_clks); i++)
2643                 tegra2_init_one_clock(&tegra_list_clks[i]);
2644
2645         for (i = 0; i < ARRAY_SIZE(tegra_clk_duplicates); i++) {
2646                 c = tegra_get_clock_by_name(tegra_clk_duplicates[i].name);
2647                 if (!c) {
2648                         pr_err("%s: Unknown duplicate clock %s\n", __func__,
2649                                 tegra_clk_duplicates[i].name);
2650                         continue;
2651                 }
2652
2653                 tegra_clk_duplicates[i].lookup.clk = c;
2654                 clkdev_add(&tegra_clk_duplicates[i].lookup);
2655         }
2656
2657         init_audio_sync_clock_mux();
2658         tegra2_init_sku_limits();
2659
2660         register_syscore_ops(&tegra_clk_syscore_ops);
2661 }