[ARM/tegra] Add Tegra3 support
[linux-2.6.git] / arch / arm / mach-tegra / tegra3_clocks.c
1 /*
2  * arch/arm/mach-tegra/tegra3_clocks.c
3  *
4  * Copyright (C) 2010 NVIDIA Corporation
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with this program; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19  *
20  */
21
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/list.h>
25 #include <linux/spinlock.h>
26 #include <linux/delay.h>
27 #include <linux/io.h>
28 #include <linux/clk.h>
29
30 #include <asm/clkdev.h>
31
32 #include <mach/iomap.h>
33
34 #include "clock.h"
35 #include "fuse.h"
36 #include "pm.h"
37
38 #define RST_DEVICES_L                   0x004
39 #define RST_DEVICES_H                   0x008
40 #define RST_DEVICES_U                   0x00C
41 #define RST_DEVICES_V                   0x358
42 #define RST_DEVICES_W                   0x35C
43 #define RST_DEVICES_SET_L               0x300
44 #define RST_DEVICES_CLR_L               0x304
45 #define RST_DEVICES_SET_V               0x430
46 #define RST_DEVICES_CLR_V               0x434
47 #define RST_DEVICES_NUM                 5
48
49 #define CLK_OUT_ENB_L                   0x010
50 #define CLK_OUT_ENB_H                   0x014
51 #define CLK_OUT_ENB_U                   0x018
52 #define CLK_OUT_ENB_V                   0x360
53 #define CLK_OUT_ENB_W                   0x364
54 #define CLK_OUT_ENB_SET_L               0x320
55 #define CLK_OUT_ENB_CLR_L               0x324
56 #define CLK_OUT_ENB_SET_V               0x440
57 #define CLK_OUT_ENB_CLR_V               0x444
58 #define CLK_OUT_ENB_NUM                 5
59
60 #define PERIPH_CLK_TO_BIT(c)            (1 << (c->u.periph.clk_num % 32))
61 #define PERIPH_CLK_TO_RST_REG(c)        \
62         periph_clk_to_reg((c), RST_DEVICES_L, RST_DEVICES_V, 4)
63 #define PERIPH_CLK_TO_RST_SET_REG(c)    \
64         periph_clk_to_reg((c), RST_DEVICES_SET_L, RST_DEVICES_SET_V, 8)
65 #define PERIPH_CLK_TO_RST_CLR_REG(c)    \
66         periph_clk_to_reg((c), RST_DEVICES_CLR_L, RST_DEVICES_CLR_V, 8)
67
68 #define PERIPH_CLK_TO_ENB_REG(c)        \
69         periph_clk_to_reg((c), CLK_OUT_ENB_L, CLK_OUT_ENB_V, 4)
70 #define PERIPH_CLK_TO_ENB_SET_REG(c)    \
71         periph_clk_to_reg((c), CLK_OUT_ENB_SET_L, CLK_OUT_ENB_SET_V, 8)
72 #define PERIPH_CLK_TO_ENB_CLR_REG(c)    \
73         periph_clk_to_reg((c), CLK_OUT_ENB_CLR_L, CLK_OUT_ENB_CLR_V, 8)
74
75 #define CLK_MASK_ARM                    0x44
76 #define MISC_CLK_ENB                    0x48
77
78 #define OSC_CTRL                        0x50
79 #define OSC_CTRL_OSC_FREQ_MASK          (0xF<<28)
80 #define OSC_CTRL_OSC_FREQ_13MHZ         (0x0<<28)
81 #define OSC_CTRL_OSC_FREQ_19_2MHZ       (0x4<<28)
82 #define OSC_CTRL_OSC_FREQ_12MHZ         (0x8<<28)
83 #define OSC_CTRL_OSC_FREQ_26MHZ         (0xC<<28)
84 #define OSC_CTRL_OSC_FREQ_16_8MHZ       (0x1<<28)
85 #define OSC_CTRL_OSC_FREQ_38_4MHZ       (0x5<<28)
86 #define OSC_CTRL_OSC_FREQ_48MHZ         (0x9<<28)
87 #define OSC_CTRL_MASK                   (0x3f2 | OSC_CTRL_OSC_FREQ_MASK)
88
89 #define OSC_CTRL_PLL_REF_DIV_MASK       (3<<26)
90 #define OSC_CTRL_PLL_REF_DIV_1          (0<<26)
91 #define OSC_CTRL_PLL_REF_DIV_2          (1<<26)
92 #define OSC_CTRL_PLL_REF_DIV_4          (2<<26)
93
94 #define OSC_FREQ_DET                    0x58
95 #define OSC_FREQ_DET_TRIG               (1<<31)
96
97 #define OSC_FREQ_DET_STATUS             0x5C
98 #define OSC_FREQ_DET_BUSY               (1<<31)
99 #define OSC_FREQ_DET_CNT_MASK           0xFFFF
100
101 #define PERIPH_CLK_SOURCE_I2S1          0x100
102 #define PERIPH_CLK_SOURCE_EMC           0x19c
103 #define PERIPH_CLK_SOURCE_OSC           0x1fc
104 #define PERIPH_CLK_SOURCE_NUM1 \
105         ((PERIPH_CLK_SOURCE_OSC - PERIPH_CLK_SOURCE_I2S1) / 4)
106
107 #define PERIPH_CLK_SOURCE_G3D2          0x3b0
108 #define PERIPH_CLK_SOURCE_SE            0x42c
109 #define PERIPH_CLK_SOURCE_NUM2 \
110         ((PERIPH_CLK_SOURCE_G3D2 - PERIPH_CLK_SOURCE_SE) / 4)
111
112 #define PERIPH_CLK_SOURCE_NUM           (PERIPH_CLK_SOURCE_NUM1 + \
113                                          PERIPH_CLK_SOURCE_NUM2)
114
115 #define PERIPH_CLK_SOURCE_MASK(c)       \
116         (((c)->flags & MUX8) ? (7<<29) :\
117                 (((c)->flags & MUX_PWM) ? (3 << 28) : (3<<30)))
118 #define PERIPH_CLK_SOURCE_SHIFT(c)      \
119         (((c)->flags & MUX8) ? 29 : (((c)->flags & MUX_PWM) ? 28 : 30))
120 #define PERIPH_CLK_SOURCE_DIVU71_MASK   0xFF
121 #define PERIPH_CLK_SOURCE_DIVU16_MASK   0xFFFF
122 #define PERIPH_CLK_SOURCE_DIV_SHIFT     0
123
124 #define AUDIO_SYNC_SOURCE_MASK          0x0F
125 #define AUDIO_SYNC_DISABLE_BIT          0x10
126 #define AUDIO_SYNC_TAP_NIBBLE_SHIFT(c)  ((c->reg_shift - 24) * 4)
127
128 #define PLL_BASE                        0x0
129 #define PLL_BASE_BYPASS                 (1<<31)
130 #define PLL_BASE_ENABLE                 (1<<30)
131 #define PLL_BASE_REF_ENABLE             (1<<29)
132 #define PLL_BASE_OVERRIDE               (1<<28)
133 #define PLL_BASE_LOCK                   (1<<27)
134 #define PLL_BASE_DIVP_MASK              (0x7<<20)
135 #define PLL_BASE_DIVP_SHIFT             20
136 #define PLL_BASE_DIVN_MASK              (0x3FF<<8)
137 #define PLL_BASE_DIVN_SHIFT             8
138 #define PLL_BASE_DIVM_MASK              (0x1F)
139 #define PLL_BASE_DIVM_SHIFT             0
140
141 #define PLL_OUT_RATIO_MASK              (0xFF<<8)
142 #define PLL_OUT_RATIO_SHIFT             8
143 #define PLL_OUT_OVERRIDE                (1<<2)
144 #define PLL_OUT_CLKEN                   (1<<1)
145 #define PLL_OUT_RESET_DISABLE           (1<<0)
146
147 #define PLL_MISC(c)                     (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
148 #define PLL_MISC_LOCK_ENABLE(c)         \
149         (((c)->flags & (PLLU | PLLD)) ? (1<<22) : (1<<18))
150
151 #define PLL_MISC_DCCON_SHIFT            20
152 #define PLL_MISC_CPCON_SHIFT            8
153 #define PLL_MISC_CPCON_MASK             (0xF<<PLL_MISC_CPCON_SHIFT)
154 #define PLL_MISC_LFCON_SHIFT            4
155 #define PLL_MISC_LFCON_MASK             (0xF<<PLL_MISC_LFCON_SHIFT)
156 #define PLL_MISC_VCOCON_SHIFT           0
157 #define PLL_MISC_VCOCON_MASK            (0xF<<PLL_MISC_VCOCON_SHIFT)
158
159 #define PLLU_BASE_POST_DIV              (1<<20)
160
161 #define PLLD_MISC_CLKENABLE             (1<<30)
162 #define PLLD_MISC_DIV_RST               (1<<23)
163 #define PLLD_MISC_DCCON_SHIFT           12
164
165 #define SUPER_CLK_MUX                   0x00
166 #define SUPER_STATE_SHIFT               28
167 #define SUPER_STATE_MASK                (0xF << SUPER_STATE_SHIFT)
168 #define SUPER_STATE_STANDBY             (0x0 << SUPER_STATE_SHIFT)
169 #define SUPER_STATE_IDLE                (0x1 << SUPER_STATE_SHIFT)
170 #define SUPER_STATE_RUN                 (0x2 << SUPER_STATE_SHIFT)
171 #define SUPER_STATE_IRQ                 (0x3 << SUPER_STATE_SHIFT)
172 #define SUPER_STATE_FIQ                 (0x4 << SUPER_STATE_SHIFT)
173 #define SUPER_SOURCE_MASK               0xF
174 #define SUPER_FIQ_SOURCE_SHIFT          12
175 #define SUPER_IRQ_SOURCE_SHIFT          8
176 #define SUPER_RUN_SOURCE_SHIFT          4
177 #define SUPER_IDLE_SOURCE_SHIFT         0
178
179 #define SUPER_CLK_DIVIDER               0x04
180 #define IS_PLLX_DIV2_BYPASS             (clk_readl(0x370) & (1<<16))
181 /* FIXME: replace with global is_lp_cluster() ? */
182 #define IS_LP_CLUSTER                   (flow_readl(0x2c) & 1)
183
184 #define BUS_CLK_DISABLE                 (1<<3)
185 #define BUS_CLK_DIV_MASK                0x3
186
187 #define PMC_CTRL                        0x0
188  #define PMC_CTRL_BLINK_ENB             (1 << 7)
189
190 #define PMC_DPD_PADS_ORIDE              0x1c
191  #define PMC_DPD_PADS_ORIDE_BLINK_ENB   (1 << 20)
192
193 #define PMC_BLINK_TIMER_DATA_ON_SHIFT   0
194 #define PMC_BLINK_TIMER_DATA_ON_MASK    0x7fff
195 #define PMC_BLINK_TIMER_ENB             (1 << 15)
196 #define PMC_BLINK_TIMER_DATA_OFF_SHIFT  16
197 #define PMC_BLINK_TIMER_DATA_OFF_MASK   0xffff
198
199 static void __iomem *reg_clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
200 static void __iomem *reg_pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
201 static void __iomem *reg_flow_base = IO_ADDRESS(TEGRA_FLOW_CTRL_BASE);
202
203 /*
204  * Some peripheral clocks share an enable bit, so refcount the enable bits
205  * in registers CLK_ENABLE_L, ... CLK_ENABLE_W
206  */
207 static int tegra_periph_clk_enable_refcount[CLK_OUT_ENB_NUM * 32];
208
209 #define clk_writel(value, reg) \
210         __raw_writel(value, (u32)reg_clk_base + (reg))
211 #define clk_readl(reg) \
212         __raw_readl((u32)reg_clk_base + (reg))
213 #define pmc_writel(value, reg) \
214         __raw_writel(value, (u32)reg_pmc_base + (reg))
215 #define pmc_readl(reg) \
216         __raw_readl((u32)reg_pmc_base + (reg))
217 #define flow_readl(reg) \
218         __raw_readl((u32)reg_flow_base + (reg))
219
220 static inline u32 periph_clk_to_reg(
221         struct clk *c, u32 reg_L, u32 reg_V, int offs)
222 {
223         u32 reg = c->u.periph.clk_num / 32;
224         BUG_ON(reg >= RST_DEVICES_NUM);
225         if (reg < 3) {
226                 reg = reg_L + (reg * offs);
227         } else {
228                 reg = reg_V + ((reg - 3) * offs);
229         }
230         return reg;
231 }
232
233 unsigned long clk_measure_input_freq(void)
234 {
235         u32 clock_autodetect;
236         clk_writel(OSC_FREQ_DET_TRIG | 1, OSC_FREQ_DET);
237         do {} while (clk_readl(OSC_FREQ_DET_STATUS) & OSC_FREQ_DET_BUSY);
238         clock_autodetect = clk_readl(OSC_FREQ_DET_STATUS);
239         if (clock_autodetect >= 732 - 3 && clock_autodetect <= 732 + 3) {
240                 return 12000000;
241         } else if (clock_autodetect >= 794 - 3 && clock_autodetect <= 794 + 3) {
242                 return 13000000;
243         } else if (clock_autodetect >= 1172 - 3 && clock_autodetect <= 1172 + 3) {
244                 return 19200000;
245         } else if (clock_autodetect >= 1587 - 3 && clock_autodetect <= 1587 + 3) {
246                 return 26000000;
247         } else if (clock_autodetect >= 1025 - 3 && clock_autodetect <= 1025 + 3) {
248                 return 16800000;
249         } else if (clock_autodetect >= 2344 - 3 && clock_autodetect <= 2344 + 3) {
250                 return 38400000;
251         } else if (clock_autodetect >= 2928 - 3 && clock_autodetect <= 2928 + 3) {
252                 return 48000000;
253         } else {
254                 pr_err("%s: Unexpected clock autodetect value %d", __func__, clock_autodetect);
255                 BUG();
256                 return 0;
257         }
258 }
259
260 static int clk_div71_get_divider(unsigned long parent_rate, unsigned long rate)
261 {
262         s64 divider_u71 = parent_rate * 2;
263         divider_u71 += rate - 1;
264         do_div(divider_u71, rate);
265
266         if (divider_u71 - 2 < 0)
267                 return 0;
268
269         if (divider_u71 - 2 > 255)
270                 return -EINVAL;
271
272         return divider_u71 - 2;
273 }
274
275 static int clk_div16_get_divider(unsigned long parent_rate, unsigned long rate)
276 {
277         s64 divider_u16;
278
279         divider_u16 = parent_rate;
280         divider_u16 += rate - 1;
281         do_div(divider_u16, rate);
282
283         if (divider_u16 - 1 < 0)
284                 return 0;
285
286         if (divider_u16 - 1 > 255)
287                 return -EINVAL;
288
289         return divider_u16 - 1;
290 }
291
292 /* clk_m functions */
293 static unsigned long tegra3_clk_m_autodetect_rate(struct clk *c)
294 {
295         u32 osc_ctrl = clk_readl(OSC_CTRL);
296         u32 auto_clock_control = osc_ctrl & ~OSC_CTRL_OSC_FREQ_MASK;
297         u32 pll_ref_div = osc_ctrl & OSC_CTRL_PLL_REF_DIV_MASK;
298
299         c->rate = clk_measure_input_freq();
300         switch (c->rate) {
301         case 12000000:
302                 auto_clock_control |= OSC_CTRL_OSC_FREQ_12MHZ;
303                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
304                 break;
305         case 13000000:
306                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
307                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
308                 break;
309         case 19200000:
310                 auto_clock_control |= OSC_CTRL_OSC_FREQ_19_2MHZ;
311                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
312                 break;
313         case 26000000:
314                 auto_clock_control |= OSC_CTRL_OSC_FREQ_26MHZ;
315                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
316                 break;
317         case 16800000:
318                 auto_clock_control |= OSC_CTRL_OSC_FREQ_16_8MHZ;
319                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
320                 break;
321         case 38400000:
322                 auto_clock_control |= OSC_CTRL_OSC_FREQ_38_4MHZ;
323                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_2);
324                 break;
325         case 48000000:
326                 auto_clock_control |= OSC_CTRL_OSC_FREQ_48MHZ;
327                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_4);
328                 break;
329         default:
330                 pr_err("%s: Unexpected clock rate %ld", __func__, c->rate);
331                 BUG();
332         }
333         clk_writel(auto_clock_control, OSC_CTRL);
334         return c->rate;
335 }
336
337 static void tegra3_clk_m_init(struct clk *c)
338 {
339         pr_debug("%s on clock %s\n", __func__, c->name);
340         tegra3_clk_m_autodetect_rate(c);
341 }
342
343 static int tegra3_clk_m_enable(struct clk *c)
344 {
345         pr_debug("%s on clock %s\n", __func__, c->name);
346         return 0;
347 }
348
349 static void tegra3_clk_m_disable(struct clk *c)
350 {
351         pr_debug("%s on clock %s\n", __func__, c->name);
352         BUG();
353 }
354
355 static struct clk_ops tegra_clk_m_ops = {
356         .init           = tegra3_clk_m_init,
357         .enable         = tegra3_clk_m_enable,
358         .disable        = tegra3_clk_m_disable,
359 };
360
361 /* PLL reference divider functions */
362 static void tegra3_pll_ref_init(struct clk *c)
363 {
364         u32 pll_ref_div = clk_readl(OSC_CTRL) & OSC_CTRL_PLL_REF_DIV_MASK;
365         pr_debug("%s on clock %s\n", __func__, c->name);
366
367         switch (pll_ref_div) {
368         case OSC_CTRL_PLL_REF_DIV_1:
369                 c->div = 1;
370                 break;
371         case OSC_CTRL_PLL_REF_DIV_2:
372                 c->div = 2;
373                 break;
374         case OSC_CTRL_PLL_REF_DIV_4:
375                 c->div = 4;
376                 break;
377         default:
378                 pr_err("%s: Invalid pll ref divider %d", __func__, pll_ref_div);
379                 BUG();
380         }
381         c->mul = 1;
382         c->state = ON;
383 }
384
385 static struct clk_ops tegra_pll_ref_ops = {
386         .init           = tegra3_pll_ref_init,
387         .enable         = tegra3_clk_m_enable,
388         .disable        = tegra3_clk_m_disable,
389 };
390
391 /* super clock functions */
392 /* "super clocks" on tegra have two-stage muxes and a clock skipping
393  * super divider.  We will ignore the clock skipping divider, since we
394  * can't lower the voltage when using the clock skip, but we can if we
395  * lower the PLL frequency.
396  */
397 static void tegra3_super_clk_init(struct clk *c)
398 {
399         u32 val;
400         int source;
401         int shift;
402         const struct clk_mux_sel *sel;
403         val = clk_readl(c->reg + SUPER_CLK_MUX);
404         c->state = ON;
405         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
406                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
407         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
408                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
409         source = (val >> shift) & SUPER_SOURCE_MASK;
410         for (sel = c->inputs; sel->input != NULL; sel++) {
411                 if (sel->value == source)
412                         break;
413         }
414         BUG_ON(sel->input == NULL);
415         c->parent = sel->input;
416
417         INIT_LIST_HEAD(&c->u.shared_bus.list);
418 }
419
420 static int tegra3_super_clk_enable(struct clk *c)
421 {
422         clk_writel(0, c->reg + SUPER_CLK_DIVIDER);
423         return 0;
424 }
425
426 static void tegra3_super_clk_disable(struct clk *c)
427 {
428         pr_debug("%s on clock %s\n", __func__, c->name);
429
430         /* oops - don't disable the CPU clock! */
431         BUG();
432 }
433
434 static int tegra3_super_clk_set_parent(struct clk *c, struct clk *p)
435 {
436         u32 val;
437         const struct clk_mux_sel *sel;
438         int shift;
439
440         val = clk_readl(c->reg + SUPER_CLK_MUX);;
441         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
442                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
443         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
444                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
445         for (sel = c->inputs; sel->input != NULL; sel++) {
446                 if (sel->input == p) {
447                         val &= ~(SUPER_SOURCE_MASK << shift);
448                         val |= sel->value << shift;
449
450                         if (c->refcnt)
451                                 clk_enable(p);
452
453                         clk_writel(val, c->reg);
454
455                         if (c->refcnt && c->parent)
456                                 clk_disable(c->parent);
457
458                         clk_reparent(c, p);
459                         return 0;
460                 }
461         }
462         return -EINVAL;
463 }
464
465 /*
466  * Super clocks have "clock skippers" instead of dividers.  Dividing using
467  * a clock skipper does not allow the voltage to be scaled down, so instead
468  * adjust the rate of the parent clock.  This requires that the parent of a
469  * super clock have no other children, otherwise the rate will change
470  * underneath the other children.
471  */
472 static int tegra3_super_clk_set_rate(struct clk *c, unsigned long rate)
473 {
474         return clk_set_rate(c->parent, rate);
475 }
476
477 static struct clk_ops tegra_super_ops = {
478         .init                   = tegra3_super_clk_init,
479         .enable                 = tegra3_super_clk_enable,
480         .disable                = tegra3_super_clk_disable,
481         .set_parent             = tegra3_super_clk_set_parent,
482         .set_rate               = tegra3_super_clk_set_rate,
483 };
484
485 /* virtual cpu clock functions */
486 /* some clocks can not be stopped (cpu, memory bus) while the SoC is running.
487    To change the frequency of these clocks, the parent pll may need to be
488    reprogrammed, so the clock must be moved off the pll, the pll reprogrammed,
489    and then the clock moved back to the pll.  To hide this sequence, a virtual
490    clock handles it.
491  */
492 static void tegra3_cpu_clk_init(struct clk *c)
493 {
494         /* FIXME: max limits for different SKUs */
495 }
496
497 static int tegra3_cpu_clk_enable(struct clk *c)
498 {
499         return 0;
500 }
501
502 static void tegra3_cpu_clk_disable(struct clk *c)
503 {
504         pr_debug("%s on clock %s\n", __func__, c->name);
505
506         /* oops - don't disable the CPU clock! */
507         BUG();
508 }
509
510 static int tegra3_cpu_clk_set_rate(struct clk *c, unsigned long rate)
511 {
512         int ret;
513         /*
514          * Take an extra reference to the main pll so it doesn't turn
515          * off when we move the cpu off of it
516          */
517         clk_enable(c->u.cpu.main);
518
519         ret = clk_set_parent(c->parent, c->u.cpu.backup);
520         if (ret) {
521                 pr_err("Failed to switch cpu to clock %s\n", c->u.cpu.backup->name);
522                 goto out;
523         }
524
525         if (rate == clk_get_rate(c->u.cpu.backup))
526                 goto out;
527
528         ret = clk_set_rate(c->u.cpu.main, rate);
529         if (ret) {
530                 pr_err("Failed to change cpu pll to %lu\n", rate);
531                 goto out;
532         }
533
534         ret = clk_set_parent(c->parent, c->u.cpu.main);
535         if (ret) {
536                 pr_err("Failed to switch cpu to clock %s\n", c->u.cpu.main->name);
537                 goto out;
538         }
539
540 out:
541         clk_disable(c->u.cpu.main);
542         return ret;
543 }
544
545 static unsigned long tegra3_cpu_get_max_rate(struct clk *c)
546 {
547         if (IS_LP_CLUSTER)
548                 return c->u.cpu.lp_max_rate;
549         else
550                 return c->max_rate;
551 }
552
553 static struct clk_ops tegra_cpu_ops = {
554         .init     = tegra3_cpu_clk_init,
555         .enable   = tegra3_cpu_clk_enable,
556         .disable  = tegra3_cpu_clk_disable,
557         .set_rate = tegra3_cpu_clk_set_rate,
558         .get_max_rate = tegra3_cpu_get_max_rate,
559 };
560
561 /* virtual cop clock functions. Used to acquire the fake 'cop' clock to
562  * reset the COP block (i.e. AVP) */
563 static void tegra3_cop_clk_reset(struct clk *c, bool assert)
564 {
565         unsigned long reg = assert ? RST_DEVICES_SET_L : RST_DEVICES_CLR_L;
566
567         pr_debug("%s %s\n", __func__, assert ? "assert" : "deassert");
568         clk_writel(1 << 1, reg);
569 }
570
571 static struct clk_ops tegra_cop_ops = {
572         .reset    = tegra3_cop_clk_reset,
573 };
574
575 /* bus clock functions */
576 static void tegra3_bus_clk_init(struct clk *c)
577 {
578         u32 val = clk_readl(c->reg);
579         c->state = ((val >> c->reg_shift) & BUS_CLK_DISABLE) ? OFF : ON;
580         c->div = ((val >> c->reg_shift) & BUS_CLK_DIV_MASK) + 1;
581         c->mul = 1;
582 }
583
584 static int tegra3_bus_clk_enable(struct clk *c)
585 {
586         u32 val = clk_readl(c->reg);
587         val &= ~(BUS_CLK_DISABLE << c->reg_shift);
588         clk_writel(val, c->reg);
589         return 0;
590 }
591
592 static void tegra3_bus_clk_disable(struct clk *c)
593 {
594         u32 val = clk_readl(c->reg);
595         val |= BUS_CLK_DISABLE << c->reg_shift;
596         clk_writel(val, c->reg);
597 }
598
599 static int tegra3_bus_clk_set_rate(struct clk *c, unsigned long rate)
600 {
601         u32 val = clk_readl(c->reg);
602         unsigned long parent_rate = clk_get_rate(c->parent);
603         int i;
604         for (i = 1; i <= 4; i++) {
605                 if (rate == parent_rate / i) {
606                         val &= ~(BUS_CLK_DIV_MASK << c->reg_shift);
607                         val |= (i - 1) << c->reg_shift;
608                         clk_writel(val, c->reg);
609                         c->div = i;
610                         c->mul = 1;
611                         return 0;
612                 }
613         }
614         return -EINVAL;
615 }
616
617 static struct clk_ops tegra_bus_ops = {
618         .init                   = tegra3_bus_clk_init,
619         .enable                 = tegra3_bus_clk_enable,
620         .disable                = tegra3_bus_clk_disable,
621         .set_rate               = tegra3_bus_clk_set_rate,
622 };
623
624 /* Blink output functions */
625
626 static void tegra3_blink_clk_init(struct clk *c)
627 {
628         u32 val;
629
630         val = pmc_readl(PMC_CTRL);
631         c->state = (val & PMC_CTRL_BLINK_ENB) ? ON : OFF;
632         c->mul = 1;
633         val = pmc_readl(c->reg);
634
635         if (val & PMC_BLINK_TIMER_ENB) {
636                 unsigned int on_off;
637
638                 on_off = (val >> PMC_BLINK_TIMER_DATA_ON_SHIFT) &
639                         PMC_BLINK_TIMER_DATA_ON_MASK;
640                 val >>= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
641                 val &= PMC_BLINK_TIMER_DATA_OFF_MASK;
642                 on_off += val;
643                 /* each tick in the blink timer is 4 32KHz clocks */
644                 c->div = on_off * 4;
645         } else {
646                 c->div = 1;
647         }
648 }
649
650 static int tegra3_blink_clk_enable(struct clk *c)
651 {
652         u32 val;
653
654         val = pmc_readl(PMC_DPD_PADS_ORIDE);
655         pmc_writel(val | PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
656
657         val = pmc_readl(PMC_CTRL);
658         pmc_writel(val | PMC_CTRL_BLINK_ENB, PMC_CTRL);
659
660         return 0;
661 }
662
663 static void tegra3_blink_clk_disable(struct clk *c)
664 {
665         u32 val;
666
667         val = pmc_readl(PMC_CTRL);
668         pmc_writel(val & ~PMC_CTRL_BLINK_ENB, PMC_CTRL);
669
670         val = pmc_readl(PMC_DPD_PADS_ORIDE);
671         pmc_writel(val & ~PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
672 }
673
674 static int tegra3_blink_clk_set_rate(struct clk *c, unsigned long rate)
675 {
676         unsigned long parent_rate = clk_get_rate(c->parent);
677         if (rate >= parent_rate) {
678                 c->div = 1;
679                 pmc_writel(0, c->reg);
680         } else {
681                 unsigned int on_off;
682                 u32 val;
683
684                 on_off = DIV_ROUND_UP(parent_rate / 8, rate);
685                 c->div = on_off * 8;
686
687                 val = (on_off & PMC_BLINK_TIMER_DATA_ON_MASK) <<
688                         PMC_BLINK_TIMER_DATA_ON_SHIFT;
689                 on_off &= PMC_BLINK_TIMER_DATA_OFF_MASK;
690                 on_off <<= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
691                 val |= on_off;
692                 val |= PMC_BLINK_TIMER_ENB;
693                 pmc_writel(val, c->reg);
694         }
695
696         return 0;
697 }
698
699 static struct clk_ops tegra_blink_clk_ops = {
700         .init                   = &tegra3_blink_clk_init,
701         .enable                 = &tegra3_blink_clk_enable,
702         .disable                = &tegra3_blink_clk_disable,
703         .set_rate               = &tegra3_blink_clk_set_rate,
704 };
705
706 /* PLL Functions */
707 static int tegra3_pll_clk_wait_for_lock(struct clk *c)
708 {
709 #if USE_PLL_LOCK_BITS
710         int i;
711         for (i = 0; i < c->u.pll.lock_delay; i++) {
712                 if (clk_readl(c->reg + PLL_BASE) & PLL_BASE_LOCK)
713                         return 0;
714                 udelay(2);              /* timeout = 2 * lock time */
715         }
716         pr_err("Timed out waiting for lock bit on pll %s", c->name);
717         return -1;
718 #endif
719         udelay(c->u.pll.lock_delay);
720
721         return 0;
722 }
723
724 static void tegra3_pll_clk_init(struct clk *c)
725 {
726         u32 val = clk_readl(c->reg + PLL_BASE);
727
728         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
729
730         if (c->flags & PLL_FIXED && !(val & PLL_BASE_OVERRIDE)) {
731                 const struct clk_pll_freq_table *sel;
732                 unsigned long input_rate = clk_get_rate(c->parent);
733                 for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
734                         if (sel->input_rate == input_rate &&
735                                 sel->output_rate == c->u.pll.fixed_rate) {
736                                 c->mul = sel->n;
737                                 c->div = sel->m * sel->p;
738                                 return;
739                         }
740                 }
741                 pr_warning("Clock %s has unknown fixed frequency\n", c->name);
742                 c->mul = 1;
743                 c->div = 1;
744         } else if (val & PLL_BASE_BYPASS) {
745                 c->mul = 1;
746                 c->div = 1;
747         } else {
748                 c->mul = (val & PLL_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
749                 c->div = (val & PLL_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
750                 if (c->flags & PLLU)
751                         c->div *= (val & PLLU_BASE_POST_DIV) ? 1 : 2;
752                 else
753                         c->div *= (val & PLL_BASE_DIVP_MASK) ? 2 : 1;
754         }
755 }
756
757 static int tegra3_pll_clk_enable(struct clk *c)
758 {
759         u32 val;
760         pr_debug("%s on clock %s\n", __func__, c->name);
761
762 #if USE_PLL_LOCK_BITS
763         val = clk_readl(c->reg + PLL_MISC(c));
764         val |= PLL_MISC_LOCK_ENABLE(c);
765         clk_writel(val, c->reg + PLL_MISC(c));
766 #endif
767         val = clk_readl(c->reg + PLL_BASE);
768         val &= ~PLL_BASE_BYPASS;
769         val |= PLL_BASE_ENABLE;
770         clk_writel(val, c->reg + PLL_BASE);
771
772         tegra3_pll_clk_wait_for_lock(c);
773
774         return 0;
775 }
776
777 static void tegra3_pll_clk_disable(struct clk *c)
778 {
779         u32 val;
780         pr_debug("%s on clock %s\n", __func__, c->name);
781
782         val = clk_readl(c->reg);
783         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
784         clk_writel(val, c->reg);
785 }
786
787 static int tegra3_pll_clk_set_rate(struct clk *c, unsigned long rate)
788 {
789         u32 val;
790         unsigned long input_rate;
791         const struct clk_pll_freq_table *sel;
792
793         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
794
795         if (c->flags & PLL_FIXED) {
796                 val = clk_readl(c->reg + PLL_BASE);
797                 if (!(val & PLL_BASE_OVERRIDE) && (rate == c->u.pll.fixed_rate))
798                         return 0;
799         }
800
801         /* FIXME: out-of-table set rate for PLLs */
802         input_rate = clk_get_rate(c->parent);
803         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
804                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
805                         c->mul = sel->n;
806                         c->div = sel->m * sel->p;
807
808                         val = clk_readl(c->reg + PLL_BASE);
809                         if (c->flags & PLL_FIXED)
810                         {
811                                 BUG();
812                                 val |= PLL_BASE_OVERRIDE;
813                         }
814                         val &= ~(PLL_BASE_DIVP_MASK | PLL_BASE_DIVN_MASK |
815                                  PLL_BASE_DIVM_MASK);
816                         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
817                                 (sel->n << PLL_BASE_DIVN_SHIFT);
818                         BUG_ON(sel->p < 1 || sel->p > 2);
819                         if (c->flags & PLLU) {
820                                 if (sel->p == 1)
821                                         val |= PLLU_BASE_POST_DIV;
822                         } else {
823                                 if (sel->p == 2)
824                                         val |= 1 << PLL_BASE_DIVP_SHIFT;
825                         }
826                         clk_writel(val, c->reg + PLL_BASE);
827
828                         if (c->flags & PLL_HAS_CPCON) {
829                                 val = clk_readl(c->reg + PLL_MISC(c));
830                                 val &= ~PLL_MISC_CPCON_MASK;
831                                 val |= sel->cpcon << PLL_MISC_CPCON_SHIFT;
832                                 clk_writel(val, c->reg + PLL_MISC(c));
833                         }
834
835                         if (c->state == ON)
836                                 tegra3_pll_clk_enable(c);
837
838                         return 0;
839                 }
840         }
841         return -EINVAL;
842 }
843
844 static struct clk_ops tegra_pll_ops = {
845         .init                   = tegra3_pll_clk_init,
846         .enable                 = tegra3_pll_clk_enable,
847         .disable                = tegra3_pll_clk_disable,
848         .set_rate               = tegra3_pll_clk_set_rate,
849 };
850
851 /* Clock divider ops */
852 static void tegra3_pll_div_clk_init(struct clk *c)
853 {
854         u32 val = clk_readl(c->reg);
855         u32 divu71;
856         val >>= c->reg_shift;
857         c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
858         if (!(val & PLL_OUT_RESET_DISABLE))
859                 c->state = OFF;
860
861         if (c->flags & DIV_U71) {
862                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
863                 c->div = (divu71 + 2);
864                 c->mul = 2;
865         } else if (c->flags & DIV_2) {
866                 if (c->flags & PLLD) {
867                         c->div = 2;
868                         c->mul = 1;
869                 }
870                 else if (c->flags & PLLX) {
871                         c->div = (IS_LP_CLUSTER &&
872                                         (!IS_PLLX_DIV2_BYPASS)) ? 2 : 1;
873                         c->mul = 1;
874                 }
875                 else
876                         BUG();
877         } else {
878                 c->div = 1;
879                 c->mul = 1;
880         }
881 }
882
883 static int tegra3_pll_div_clk_enable(struct clk *c)
884 {
885         u32 val;
886         u32 new_val;
887
888         pr_debug("%s: %s\n", __func__, c->name);
889         if (c->flags & DIV_U71) {
890                 val = clk_readl(c->reg);
891                 new_val = val >> c->reg_shift;
892                 new_val &= 0xFFFF;
893
894                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
895
896                 val &= ~(0xFFFF << c->reg_shift);
897                 val |= new_val << c->reg_shift;
898                 clk_writel(val, c->reg);
899                 return 0;
900         } else if (c->flags & DIV_2) {
901                 return 0;
902         }
903         return -EINVAL;
904 }
905
906 static void tegra3_pll_div_clk_disable(struct clk *c)
907 {
908         u32 val;
909         u32 new_val;
910
911         pr_debug("%s: %s\n", __func__, c->name);
912         if (c->flags & DIV_U71) {
913                 val = clk_readl(c->reg);
914                 new_val = val >> c->reg_shift;
915                 new_val &= 0xFFFF;
916
917                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
918
919                 val &= ~(0xFFFF << c->reg_shift);
920                 val |= new_val << c->reg_shift;
921                 clk_writel(val, c->reg);
922         }
923 }
924
925 static int tegra3_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
926 {
927         u32 val;
928         u32 new_val;
929         int divider_u71;
930         unsigned long parent_rate = clk_get_rate(c->parent);
931
932         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
933         if (c->flags & DIV_U71) {
934                 divider_u71 = clk_div71_get_divider(parent_rate, rate);
935                 if (divider_u71 >= 0) {
936                         val = clk_readl(c->reg);
937                         new_val = val >> c->reg_shift;
938                         new_val &= 0xFFFF;
939                         if (c->flags & DIV_U71_FIXED)
940                                 new_val |= PLL_OUT_OVERRIDE;
941                         new_val &= ~PLL_OUT_RATIO_MASK;
942                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
943
944                         val &= ~(0xFFFF << c->reg_shift);
945                         val |= new_val << c->reg_shift;
946                         clk_writel(val, c->reg);
947                         c->div = divider_u71 + 2;
948                         c->mul = 2;
949                         return 0;
950                 }
951         } else if (c->flags & DIV_2) {
952                 if (c->flags & PLLD) {
953                         return clk_set_rate(c->parent, rate * 2);
954                 }
955                 else if (c->flags & PLLX) {
956                         if (IS_LP_CLUSTER && (!IS_PLLX_DIV2_BYPASS))
957                                 rate *= 2;
958                         return clk_set_rate(c->parent, rate);
959                 }
960         }
961         return -EINVAL;
962 }
963
964 static long tegra3_pll_div_clk_round_rate(struct clk *c, unsigned long rate)
965 {
966         int divider;
967         unsigned long parent_rate = clk_get_rate(c->parent);
968         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
969
970         if (c->flags & DIV_U71) {
971                 divider = clk_div71_get_divider(parent_rate, rate);
972                 if (divider < 0)
973                         return divider;
974                 return parent_rate * 2 / (divider + 2);
975         }
976         return -EINVAL;
977 }
978
979 static void tegra3_pllx_div_clk_recalculate_rate(struct clk *c)
980 {
981         c->div = (IS_LP_CLUSTER && (!IS_PLLX_DIV2_BYPASS)) ? 2 : 1;
982 }
983
984 static struct clk_ops tegra_pll_div_ops = {
985         .init                   = tegra3_pll_div_clk_init,
986         .enable                 = tegra3_pll_div_clk_enable,
987         .disable                = tegra3_pll_div_clk_disable,
988         .set_rate               = tegra3_pll_div_clk_set_rate,
989         .round_rate             = tegra3_pll_div_clk_round_rate,
990 };
991
992 static struct clk_ops tegra_plld_div_ops = {
993         .init                   = tegra3_pll_div_clk_init,
994         .enable                 = tegra3_pll_div_clk_enable,
995         .disable                = tegra3_pll_div_clk_disable,
996         .set_rate               = tegra3_pll_div_clk_set_rate,
997 };
998
999 static struct clk_ops tegra_pllx_div_ops = {
1000         .init                   = tegra3_pll_div_clk_init,
1001         .enable                 = tegra3_pll_div_clk_enable,
1002         .disable                = tegra3_pll_div_clk_disable,
1003         .set_rate               = tegra3_pll_div_clk_set_rate,
1004         .recalculate_rate = tegra3_pllx_div_clk_recalculate_rate,
1005 };
1006
1007 /* Periph clk ops */
1008
1009 static void tegra3_periph_clk_init(struct clk *c)
1010 {
1011         u32 val = clk_readl(c->reg);
1012         const struct clk_mux_sel *mux = 0;
1013         const struct clk_mux_sel *sel;
1014         if (c->flags & (MUX | MUX_PWM | MUX8)) {
1015                 for (sel = c->inputs; sel->input != NULL; sel++) {
1016                         if (val >> PERIPH_CLK_SOURCE_SHIFT(c) == sel->value)
1017                                 mux = sel;
1018                 }
1019                 BUG_ON(!mux);
1020
1021                 c->parent = mux->input;
1022         } else {
1023                 c->parent = c->inputs[0].input;
1024         }
1025
1026         if (c->flags & DIV_U71) {
1027                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
1028                 c->div = divu71 + 2;
1029                 c->mul = 2;
1030         } else if (c->flags & DIV_U16) {
1031                 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
1032                 c->div = divu16 + 1;
1033                 c->mul = 1;
1034         } else {
1035                 c->div = 1;
1036                 c->mul = 1;
1037         }
1038
1039         c->state = ON;
1040         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
1041                 c->state = OFF;
1042         if (!(c->flags & PERIPH_NO_RESET))
1043                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c))
1044                         c->state = OFF;
1045 }
1046
1047 static int tegra3_periph_clk_enable(struct clk *c)
1048 {
1049         u32 val;
1050         pr_debug("%s on clock %s\n", __func__, c->name);
1051
1052         tegra_periph_clk_enable_refcount[c->u.periph.clk_num]++;
1053         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] > 1)
1054                 return 0;
1055
1056         clk_writel(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_SET_REG(c));
1057         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET)) {
1058                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c)) {
1059                         udelay(5);      /* reset propagation delay */
1060                         clk_writel(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_RST_CLR_REG(c));
1061                 }
1062         }
1063         if (c->flags & PERIPH_EMC_ENB) {
1064                 /* The EMC peripheral clock has 2 extra enable bits */
1065                 /* FIXME: Do they need to be disabled? */
1066                 val = clk_readl(c->reg);
1067                 val |= 0x3 << 24;
1068                 clk_writel(val, c->reg);
1069         }
1070         return 0;
1071 }
1072
1073 static void tegra3_periph_clk_disable(struct clk *c)
1074 {
1075         pr_debug("%s on clock %s\n", __func__, c->name);
1076
1077         if (c->refcnt)
1078                 tegra_periph_clk_enable_refcount[c->u.periph.clk_num]--;
1079
1080         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] == 0)
1081                 clk_writel(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_CLR_REG(c));
1082 }
1083
1084 static void tegra3_periph_clk_reset(struct clk *c, bool assert)
1085 {
1086         pr_debug("%s %s on clock %s\n", __func__,
1087                  assert ? "assert" : "deassert", c->name);
1088
1089         if (!(c->flags & PERIPH_NO_RESET)) {
1090                 if (assert)
1091                         clk_writel(PERIPH_CLK_TO_BIT(c),
1092                                    PERIPH_CLK_TO_RST_SET_REG(c));
1093                 else
1094                         clk_writel(PERIPH_CLK_TO_BIT(c),
1095                                    PERIPH_CLK_TO_RST_CLR_REG(c));
1096         }
1097 }
1098
1099 static int tegra3_periph_clk_set_parent(struct clk *c, struct clk *p)
1100 {
1101         u32 val;
1102         const struct clk_mux_sel *sel;
1103         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
1104         for (sel = c->inputs; sel->input != NULL; sel++) {
1105                 if (sel->input == p) {
1106                         val = clk_readl(c->reg);
1107                         val &= ~PERIPH_CLK_SOURCE_MASK(c);
1108                         val |= (sel->value) << PERIPH_CLK_SOURCE_SHIFT(c);
1109
1110                         if (c->refcnt)
1111                                 clk_enable(p);
1112
1113                         clk_writel(val, c->reg);
1114
1115                         if (c->refcnt && c->parent)
1116                                 clk_disable(c->parent);
1117
1118                         clk_reparent(c, p);
1119                         return 0;
1120                 }
1121         }
1122
1123         return -EINVAL;
1124 }
1125
1126 static int tegra3_periph_clk_set_rate(struct clk *c, unsigned long rate)
1127 {
1128         u32 val;
1129         int divider;
1130         unsigned long parent_rate = clk_get_rate(c->parent);
1131
1132         if (c->flags & DIV_U71) {
1133                 divider = clk_div71_get_divider(parent_rate, rate);
1134                 if (divider >= 0) {
1135                         val = clk_readl(c->reg);
1136                         val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
1137                         val |= divider;
1138                         clk_writel(val, c->reg);
1139                         c->div = divider + 2;
1140                         c->mul = 2;
1141                         return 0;
1142                 }
1143         } else if (c->flags & DIV_U16) {
1144                 divider = clk_div16_get_divider(parent_rate, rate);
1145                 if (divider >= 0) {
1146                         val = clk_readl(c->reg);
1147                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
1148                         val |= divider;
1149                         clk_writel(val, c->reg);
1150                         c->div = divider + 1;
1151                         c->mul = 1;
1152                         return 0;
1153                 }
1154         } else if (parent_rate <= rate) {
1155                 c->div = 1;
1156                 c->mul = 1;
1157                 return 0;
1158         }
1159         return -EINVAL;
1160 }
1161
1162 static long tegra3_periph_clk_round_rate(struct clk *c,
1163         unsigned long rate)
1164 {
1165         int divider;
1166         unsigned long parent_rate = clk_get_rate(c->parent);
1167         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
1168
1169         if (c->flags & DIV_U71) {
1170                 divider = clk_div71_get_divider(parent_rate, rate);
1171                 if (divider < 0)
1172                         return divider;
1173
1174                 return parent_rate * 2 / (divider + 2);
1175         } else if (c->flags & DIV_U16) {
1176                 divider = clk_div16_get_divider(parent_rate, rate);
1177                 if (divider < 0)
1178                         return divider;
1179                 return parent_rate / (divider + 1);
1180         }
1181         return -EINVAL;
1182 }
1183
1184 static struct clk_ops tegra_periph_clk_ops = {
1185         .init                   = &tegra3_periph_clk_init,
1186         .enable                 = &tegra3_periph_clk_enable,
1187         .disable                = &tegra3_periph_clk_disable,
1188         .set_parent             = &tegra3_periph_clk_set_parent,
1189         .set_rate               = &tegra3_periph_clk_set_rate,
1190         .round_rate             = &tegra3_periph_clk_round_rate,
1191         .reset                  = &tegra3_periph_clk_reset,
1192 };
1193
1194 /* Clock doubler ops */
1195 static void tegra3_clk_double_init(struct clk *c)
1196 {
1197         u32 val = clk_readl(c->reg);
1198         c->mul = val & (0x1 << c->reg_shift) ? 1 : 2;
1199         c->div = 1;
1200         c->state = ON;
1201         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
1202                 c->state = OFF;
1203 };
1204
1205 static int tegra3_clk_double_set_rate(struct clk *c, unsigned long rate)
1206 {
1207         u32 val;
1208         unsigned long parent_rate = clk_get_rate(c->parent);
1209         if (rate == parent_rate) {
1210                 val = clk_readl(c->reg) | (0x1 << c->reg_shift);
1211                 clk_writel(val, c->reg);
1212                 c->mul = 1;
1213                 c->div = 1;
1214                 return 0;
1215         } else if (rate == 2 * parent_rate) {
1216                 val = clk_readl(c->reg) & (~(0x1 << c->reg_shift));
1217                 clk_writel(val, c->reg);
1218                 c->mul = 2;
1219                 c->div = 1;
1220                 return 0;
1221         }
1222         return -EINVAL;
1223 }
1224
1225 static struct clk_ops tegra_clk_double_ops = {
1226         .init                   = &tegra3_clk_double_init,
1227         .enable                 = &tegra3_periph_clk_enable,
1228         .disable                = &tegra3_periph_clk_disable,
1229         .set_rate               = &tegra3_clk_double_set_rate,
1230 };
1231
1232 /* Audio sync clock ops */
1233 static void tegra3_audio_sync_clk_init(struct clk *c)
1234 {
1235         int source;
1236         const struct clk_mux_sel *sel;
1237         u32 val = clk_readl(c->reg);
1238         c->state = (val & AUDIO_SYNC_DISABLE_BIT) ? OFF : ON;
1239         source = val & AUDIO_SYNC_SOURCE_MASK;
1240         for (sel = c->inputs; sel->input != NULL; sel++)
1241                 if (sel->value == source)
1242                         break;
1243         BUG_ON(sel->input == NULL);
1244         c->parent = sel->input;
1245 }
1246
1247 static int tegra3_audio_sync_clk_enable(struct clk *c)
1248 {
1249         u32 val = clk_readl(c->reg);
1250         clk_writel((val & (~AUDIO_SYNC_DISABLE_BIT)), c->reg);
1251         return 0;
1252 }
1253
1254 static void tegra3_audio_sync_clk_disable(struct clk *c)
1255 {
1256         u32 val = clk_readl(c->reg);
1257         clk_writel((val | AUDIO_SYNC_DISABLE_BIT), c->reg);
1258 }
1259
1260 static int tegra3_audio_sync_clk_set_parent(struct clk *c, struct clk *p)
1261 {
1262         u32 val;
1263         const struct clk_mux_sel *sel;
1264         for (sel = c->inputs; sel->input != NULL; sel++) {
1265                 if (sel->input == p) {
1266                         val = clk_readl(c->reg);
1267                         val &= ~AUDIO_SYNC_SOURCE_MASK;
1268                         val |= sel->value;
1269
1270                         if (c->refcnt)
1271                                 clk_enable(p);
1272
1273                         clk_writel(val, c->reg);
1274
1275                         if (c->refcnt && c->parent)
1276                                 clk_disable(c->parent);
1277
1278                         clk_reparent(c, p);
1279                         return 0;
1280                 }
1281         }
1282
1283         return -EINVAL;
1284 }
1285
1286 static struct clk_ops tegra_audio_sync_clk_ops = {
1287         .init       = tegra3_audio_sync_clk_init,
1288         .enable     = tegra3_audio_sync_clk_enable,
1289         .disable    = tegra3_audio_sync_clk_disable,
1290         .set_parent = tegra3_audio_sync_clk_set_parent,
1291 };
1292
1293 /* cdev1 and cdev2 (dap_mclk1 and dap_mclk2) ops */
1294
1295 static void tegra3_cdev_clk_init(struct clk *c)
1296 {
1297         /* We could un-tristate the cdev1 or cdev2 pingroup here; this is
1298          * currently done in the pinmux code. */
1299         c->state = ON;
1300         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
1301                 c->state = OFF;
1302 }
1303
1304 static int tegra3_cdev_clk_enable(struct clk *c)
1305 {
1306         clk_writel(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_SET_REG(c));
1307         return 0;
1308 }
1309
1310 static void tegra3_cdev_clk_disable(struct clk *c)
1311 {
1312         clk_writel(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_CLR_REG(c));
1313 }
1314
1315 static struct clk_ops tegra_cdev_clk_ops = {
1316         .init                   = &tegra3_cdev_clk_init,
1317         .enable                 = &tegra3_cdev_clk_enable,
1318         .disable                = &tegra3_cdev_clk_disable,
1319 };
1320
1321 /* shared bus ops */
1322 /*
1323  * Some clocks may have multiple downstream users that need to request a
1324  * higher clock rate.  Shared bus clocks provide a unique shared_bus_user
1325  * clock to each user.  The frequency of the bus is set to the highest
1326  * enabled shared_bus_user clock, with a minimum value set by the
1327  * shared bus.
1328  */
1329 static void tegra_clk_shared_bus_update(struct clk *bus)
1330 {
1331         struct clk *c;
1332         unsigned long rate = bus->u.shared_bus.min_rate;
1333
1334         list_for_each_entry(c, &bus->u.shared_bus.list,
1335                         u.shared_bus_user.node) {
1336                 if (c->u.shared_bus_user.enabled)
1337                         rate = max(c->u.shared_bus_user.rate, rate);
1338         }
1339
1340         clk_set_rate(bus, rate);
1341 };
1342
1343 static void tegra_clk_shared_bus_init(struct clk *c)
1344 {
1345         c->max_rate = c->parent->max_rate;
1346         c->u.shared_bus_user.rate = c->parent->max_rate;
1347         c->state = OFF;
1348         c->set = true;
1349
1350         list_add_tail(&c->u.shared_bus_user.node,
1351                 &c->parent->u.shared_bus.list);
1352 }
1353
1354 static int tegra_clk_shared_bus_set_rate(struct clk *c, unsigned long rate)
1355 {
1356         c->u.shared_bus_user.rate = rate;
1357         tegra_clk_shared_bus_update(c->parent);
1358         return 0;
1359 }
1360
1361 static int tegra_clk_shared_bus_enable(struct clk *c)
1362 {
1363         c->u.shared_bus_user.enabled = true;
1364         tegra_clk_shared_bus_update(c->parent);
1365         return 0;
1366 }
1367
1368 static void tegra_clk_shared_bus_disable(struct clk *c)
1369 {
1370         c->u.shared_bus_user.enabled = false;
1371         tegra_clk_shared_bus_update(c->parent);
1372 }
1373
1374 static struct clk_ops tegra_clk_shared_bus_ops = {
1375         .init = tegra_clk_shared_bus_init,
1376         .enable = tegra_clk_shared_bus_enable,
1377         .disable = tegra_clk_shared_bus_disable,
1378         .set_rate = tegra_clk_shared_bus_set_rate,
1379 };
1380
1381
1382 /* Clock definitions */
1383 static struct clk tegra_clk_32k = {
1384         .name = "clk_32k",
1385         .rate = 32768,
1386         .ops  = NULL,
1387         .max_rate = 32768,
1388 };
1389
1390 static struct clk tegra_clk_m = {
1391         .name      = "clk_m",
1392         .flags     = ENABLE_ON_INIT,
1393         .ops       = &tegra_clk_m_ops,
1394         .reg       = 0x1fc,
1395         .reg_shift = 28,
1396         .max_rate  = 48000000,
1397 };
1398
1399 static struct clk tegra_pll_ref = {
1400         .name      = "pll_ref",
1401         .flags     = ENABLE_ON_INIT,
1402         .ops       = &tegra_pll_ref_ops,
1403         .parent    = &tegra_clk_m,
1404         .max_rate  = 26000000,
1405 };
1406
1407 static struct clk_pll_freq_table tegra_pll_c_freq_table[] = {
1408         { 12000000, 600000000, 600, 12, 1, 8},
1409         { 13000000, 600000000, 600, 13, 1, 8},
1410         { 16800000, 600000000, 500, 14, 1, 8},
1411         { 19200000, 600000000, 375, 12, 1, 6},
1412         { 26000000, 600000000, 600, 26, 1, 8},
1413         { 0, 0, 0, 0, 0, 0 },
1414 };
1415
1416 static struct clk tegra_pll_c = {
1417         .name      = "pll_c",
1418         .flags     = PLL_HAS_CPCON,
1419         .ops       = &tegra_pll_ops,
1420         .reg       = 0x80,
1421         .parent    = &tegra_pll_ref,
1422         .max_rate  = 600000000,
1423         .u.pll = {
1424                 .input_min = 2000000,
1425                 .input_max = 31000000,
1426                 .cf_min    = 1000000,
1427                 .cf_max    = 6000000,
1428                 .vco_min   = 20000000,
1429                 .vco_max   = 1400000000,
1430                 .freq_table = tegra_pll_c_freq_table,
1431                 .lock_delay = 300,
1432         },
1433 };
1434
1435 static struct clk tegra_pll_c_out1 = {
1436         .name      = "pll_c_out1",
1437         .ops       = &tegra_pll_div_ops,
1438         .flags     = DIV_U71,
1439         .parent    = &tegra_pll_c,
1440         .reg       = 0x84,
1441         .reg_shift = 0,
1442         .max_rate  = 600000000,
1443 };
1444
1445 static struct clk_pll_freq_table tegra_pll_m_freq_table[] = {
1446         { 12000000, 666000000, 666, 12, 1, 8},
1447         { 13000000, 666000000, 666, 13, 1, 8},
1448         { 16800000, 666000000, 555, 14, 1, 8},
1449         { 19200000, 666000000, 555, 16, 1, 8},
1450         { 26000000, 666000000, 666, 26, 1, 8},
1451         { 12000000, 600000000, 600, 12, 1, 8},
1452         { 13000000, 600000000, 600, 13, 1, 8},
1453         { 16800000, 600000000, 500, 14, 1, 8},
1454         { 19200000, 600000000, 375, 12, 1, 6},
1455         { 26000000, 600000000, 600, 26, 1, 8},
1456         { 0, 0, 0, 0, 0, 0 },
1457 };
1458
1459 static struct clk tegra_pll_m = {
1460         .name      = "pll_m",
1461         .flags     = PLL_HAS_CPCON,
1462         .ops       = &tegra_pll_ops,
1463         .reg       = 0x90,
1464         .parent    = &tegra_pll_ref,
1465         .max_rate  = 800000000,
1466         .u.pll = {
1467                 .input_min = 2000000,
1468                 .input_max = 31000000,
1469                 .cf_min    = 1000000,
1470                 .cf_max    = 6000000,
1471                 .vco_min   = 20000000,
1472                 .vco_max   = 1200000000,
1473                 .freq_table = tegra_pll_m_freq_table,
1474                 .lock_delay = 300,
1475         },
1476 };
1477
1478 static struct clk tegra_pll_m_out1 = {
1479         .name      = "pll_m_out1",
1480         .ops       = &tegra_pll_div_ops,
1481         .flags     = DIV_U71,
1482         .parent    = &tegra_pll_m,
1483         .reg       = 0x94,
1484         .reg_shift = 0,
1485         .max_rate  = 600000000,
1486 };
1487
1488 static struct clk_pll_freq_table tegra_pll_p_freq_table[] = {
1489         { 12000000, 216000000, 432, 12, 2, 8},
1490         { 13000000, 216000000, 432, 13, 2, 8},
1491         { 16800000, 216000000, 360, 14, 2, 8},
1492         { 19200000, 216000000, 360, 16, 2, 8},
1493         { 26000000, 216000000, 432, 26, 2, 8},
1494         { 0, 0, 0, 0, 0, 0 },
1495 };
1496
1497 static struct clk tegra_pll_p = {
1498         .name      = "pll_p",
1499         .flags     = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
1500         .ops       = &tegra_pll_ops,
1501         .reg       = 0xa0,
1502         .parent    = &tegra_pll_ref,
1503         .max_rate  = 432000000,
1504         .u.pll = {
1505                 .input_min = 2000000,
1506                 .input_max = 31000000,
1507                 .cf_min    = 1000000,
1508                 .cf_max    = 6000000,
1509                 .vco_min   = 20000000,
1510                 .vco_max   = 1400000000,
1511                 .freq_table = tegra_pll_p_freq_table,
1512                 .lock_delay = 300,
1513                 .fixed_rate = 216000000,
1514         },
1515 };
1516
1517 static struct clk tegra_pll_p_out1 = {
1518         .name      = "pll_p_out1",
1519         .ops       = &tegra_pll_div_ops,
1520         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1521         .parent    = &tegra_pll_p,
1522         .reg       = 0xa4,
1523         .reg_shift = 0,
1524         .max_rate  = 432000000,
1525 };
1526
1527 static struct clk tegra_pll_p_out2 = {
1528         .name      = "pll_p_out2",
1529         .ops       = &tegra_pll_div_ops,
1530         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1531         .parent    = &tegra_pll_p,
1532         .reg       = 0xa4,
1533         .reg_shift = 16,
1534         .max_rate  = 432000000,
1535 };
1536
1537 static struct clk tegra_pll_p_out3 = {
1538         .name      = "pll_p_out3",
1539         .ops       = &tegra_pll_div_ops,
1540         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1541         .parent    = &tegra_pll_p,
1542         .reg       = 0xa8,
1543         .reg_shift = 0,
1544         .max_rate  = 432000000,
1545 };
1546
1547 static struct clk tegra_pll_p_out4 = {
1548         .name      = "pll_p_out4",
1549         .ops       = &tegra_pll_div_ops,
1550         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
1551         .parent    = &tegra_pll_p,
1552         .reg       = 0xa8,
1553         .reg_shift = 16,
1554         .max_rate  = 432000000,
1555 };
1556
1557 static struct clk_pll_freq_table tegra_pll_a_freq_table[] = {
1558         { 28800000, 56448000, 49, 25, 1, 1},
1559         { 28800000, 73728000, 64, 25, 1, 1},
1560         { 28800000, 11289600, 49, 25, 1, 1},    /* actual: 56.448MHz */
1561         { 28800000, 12288000, 64, 25, 1, 1},    /* actual: 73.728MHz */
1562         { 28800000, 24000000,  5,  6, 1, 1},
1563         { 0, 0, 0, 0, 0, 0 },
1564 };
1565
1566 static struct clk tegra_pll_a = {
1567         .name      = "pll_a",
1568         .flags     = PLL_HAS_CPCON,
1569         .ops       = &tegra_pll_ops,
1570         .reg       = 0xb0,
1571         .parent    = &tegra_pll_p_out1,
1572         .max_rate  = 56448000,
1573         .u.pll = {
1574                 .input_min = 2000000,
1575                 .input_max = 31000000,
1576                 .cf_min    = 1000000,
1577                 .cf_max    = 6000000,
1578                 .vco_min   = 20000000,
1579                 .vco_max   = 1400000000,
1580                 .freq_table = tegra_pll_a_freq_table,
1581                 .lock_delay = 300,
1582         },
1583 };
1584
1585 static struct clk tegra_pll_a_out0 = {
1586         .name      = "pll_a_out0",
1587         .ops       = &tegra_pll_div_ops,
1588         .flags     = DIV_U71,
1589         .parent    = &tegra_pll_a,
1590         .reg       = 0xb4,
1591         .reg_shift = 0,
1592         .max_rate  = 56448000,
1593 };
1594
1595 static struct clk_pll_freq_table tegra_pll_d_freq_table[] = {
1596         { 12000000, 216000000, 216, 12, 1, 4},
1597         { 13000000, 216000000, 216, 13, 1, 4},
1598         { 16800000, 216000000, 180, 14, 1, 4},
1599         { 19200000, 216000000, 180, 16, 1, 4},
1600         { 26000000, 216000000, 216, 26, 1, 4},
1601
1602         { 12000000, 594000000, 594, 12, 1, 8},
1603         { 13000000, 594000000, 594, 13, 1, 8},
1604         { 16800000, 594000000, 495, 14, 1, 8},
1605         { 19200000, 594000000, 495, 16, 1, 8},
1606         { 26000000, 594000000, 594, 26, 1, 8},
1607
1608         { 12000000, 1000000000, 1000, 12, 1, 12},
1609         { 13000000, 1000000000, 1000, 13, 1, 12},
1610         { 19200000, 1000000000, 625,  12, 1, 8},
1611         { 26000000, 1000000000, 1000, 26, 1, 12},
1612
1613         { 0, 0, 0, 0, 0, 0 },
1614 };
1615
1616 static struct clk tegra_pll_d = {
1617         .name      = "pll_d",
1618         .flags     = PLL_HAS_CPCON | PLLD,
1619         .ops       = &tegra_pll_ops,
1620         .reg       = 0xd0,
1621         .parent    = &tegra_pll_ref,
1622         .max_rate  = 1000000000,
1623         .u.pll = {
1624                 .input_min = 2000000,
1625                 .input_max = 40000000,
1626                 .cf_min    = 1000000,
1627                 .cf_max    = 6000000,
1628                 .vco_min   = 40000000,
1629                 .vco_max   = 1000000000,
1630                 .freq_table = tegra_pll_d_freq_table,
1631                 .lock_delay = 1000,
1632         },
1633 };
1634
1635 static struct clk tegra_pll_d_out0 = {
1636         .name      = "pll_d_out0",
1637         .ops       = &tegra_plld_div_ops,
1638         .flags     = DIV_2 | PLLD,
1639         .parent    = &tegra_pll_d,
1640         .max_rate  = 500000000,
1641 };
1642
1643 static struct clk_pll_freq_table tegra_pll_u_freq_table[] = {
1644         { 12000000, 480000000, 960, 12, 2, 12},
1645         { 13000000, 480000000, 960, 13, 2, 12},
1646         { 16800000, 480000000, 400, 7,  2, 5},
1647         { 19200000, 480000000, 200, 4,  2, 3},
1648         { 26000000, 480000000, 960, 26, 2, 12},
1649         { 0, 0, 0, 0, 0, 0 },
1650 };
1651
1652 static struct clk tegra_pll_u = {
1653         .name      = "pll_u",
1654         .flags     = PLL_HAS_CPCON | PLLU,
1655         .ops       = &tegra_pll_ops,
1656         .reg       = 0xc0,
1657         .parent    = &tegra_pll_ref,
1658         .max_rate  = 480000000,
1659         .u.pll = {
1660                 .input_min = 2000000,
1661                 .input_max = 40000000,
1662                 .cf_min    = 1000000,
1663                 .cf_max    = 6000000,
1664                 .vco_min   = 480000000,
1665                 .vco_max   = 960000000,
1666                 .freq_table = tegra_pll_u_freq_table,
1667                 .lock_delay = 1000,
1668         },
1669 };
1670
1671 /* FIXME: cpcon values */
1672 static struct clk_pll_freq_table tegra_pll_x_freq_table[] = {
1673         /* 1 GHz */
1674         { 12000000, 1000000000, 1000, 12, 1, 12},
1675         { 13000000, 1000000000, 1000, 13, 1, 12},
1676         { 16800000, 1000000000, 952,  16, 1, 12},       /* actual: 999.6 MHz */
1677         { 19200000, 1000000000, 625,  12, 1, 8},
1678         { 26000000, 1000000000, 1000, 26, 1, 12},
1679
1680         /* 912 MHz */
1681         { 12000000, 912000000,  912,  12, 1, 12},
1682         { 13000000, 912000000,  912,  13, 1, 12},
1683         { 16800000, 912000000,  760,  14, 1, 8},
1684         { 19200000, 912000000,  760,  16, 1, 8},
1685         { 26000000, 912000000,  912,  26, 1, 12},
1686
1687         /* 816 MHz */
1688         { 12000000, 816000000,  816,  12, 1, 12},
1689         { 13000000, 816000000,  816,  13, 1, 12},
1690         { 16800000, 816000000,  680,  14, 1, 8},
1691         { 19200000, 816000000,  680,  16, 1, 8},
1692         { 26000000, 816000000,  816,  26, 1, 12},
1693
1694         /* 760 MHz */
1695         { 12000000, 760000000,  760,  12, 1, 12},
1696         { 13000000, 760000000,  760,  13, 1, 12},
1697         { 16800000, 760000000,  723,  16, 1, 8},        /* actual: 759.15 MHz */
1698         { 19200000, 760000000,  475,  12, 1, 8},
1699         { 26000000, 760000000,  760,  26, 1, 12},
1700
1701         /* 624 MHz */
1702         { 12000000, 624000000,  624,  12, 1, 12},
1703         { 13000000, 624000000,  624,  13, 1, 12},
1704         { 16800000, 624000000,  520,  14, 1, 8},
1705         { 19200000, 624000000,  520,  16, 1, 8},
1706         { 26000000, 624000000,  624,  26, 1, 12},
1707
1708         /* 608 MHz */
1709         { 12000000, 608000000,  608,  12, 1, 12},
1710         { 13000000, 608000000,  608,  13, 1, 12},
1711         { 16800000, 608000000,  579,  16, 1, 8},        /* actual: 607.95 MHz */
1712         { 19200000, 608000000,  380,  12, 1, 8},
1713         { 26000000, 608000000,  608,  26, 1, 12},
1714
1715         /* 456 MHz */
1716         { 12000000, 456000000,  456,  12, 1, 12},
1717         { 13000000, 456000000,  456,  13, 1, 12},
1718         { 16800000, 456000000,  380,  14, 1, 8},
1719         { 19200000, 456000000,  380,  16, 1, 8},
1720         { 26000000, 456000000,  456,  26, 1, 12},
1721
1722         /* 312 MHz */
1723         { 12000000, 312000000,  312,  12, 1, 12},
1724         { 13000000, 312000000,  312,  13, 1, 12},
1725         { 16800000, 312000000,  260,  14, 1, 8},
1726         { 19200000, 312000000,  260,  16, 1, 8},
1727         { 26000000, 312000000,  312,  26, 1, 12},
1728
1729         { 0, 0, 0, 0, 0, 0 },
1730 };
1731
1732 static struct clk tegra_pll_x = {
1733         .name      = "pll_x",
1734         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG | PLLX,
1735         .ops       = &tegra_pll_ops,
1736         .reg       = 0xe0,
1737         .parent    = &tegra_pll_ref,
1738         .max_rate  = 1000000000,
1739         .u.pll = {
1740                 .input_min = 2000000,
1741                 .input_max = 31000000,
1742                 .cf_min    = 1000000,
1743                 .cf_max    = 6000000,
1744                 .vco_min   = 20000000,
1745                 .vco_max   = 1200000000,
1746                 .freq_table = tegra_pll_x_freq_table,
1747                 .lock_delay = 300,
1748         },
1749 };
1750
1751 static struct clk tegra_pll_x_out0 = {
1752         .name      = "pll_x_out0",
1753         .ops       = &tegra_pllx_div_ops,
1754         .flags     = DIV_2 | PLLX,
1755         .parent    = &tegra_pll_x,
1756         .max_rate  = 1000000000,
1757 };
1758
1759 /* dap_mclk1, belongs to the cdev1 pingroup. */
1760 static struct clk tegra_dev1_clk = {
1761         .name      = "clk_dev1",
1762         .ops       = &tegra_cdev_clk_ops,
1763         .rate      = 26000000,
1764         .max_rate  = 26000000,
1765         .u.periph  = {
1766                 .clk_num = 94,
1767         },
1768 };
1769
1770 /* dap_mclk2, belongs to the cdev2 pingroup. */
1771 static struct clk tegra_dev2_clk = {
1772         .name      = "clk_dev2",
1773         .ops       = &tegra_cdev_clk_ops,
1774         .rate      = 26000000,
1775         .max_rate  = 26000000,
1776         .u.periph  = {
1777                 .clk_num   = 93,
1778         },
1779 };
1780
1781 /* initialized before peripheral clocks */
1782 static struct clk_mux_sel mux_audio_sync_clk[AUDIO_SYNC_SOURCE_MASK+1+1];
1783 static const struct audio_sources {
1784         const char *name;
1785         int value;
1786 } mux_audio_sync_clk_sources[] = {
1787         { .name = "spdif_in", .value = 0 },
1788         { .name = "i2s0", .value = 1 },
1789         { .name = "i2s1", .value = 2 },
1790         { .name = "i2s2", .value = 3 },
1791         { .name = "i2s3", .value = 4 },
1792         { .name = "i2s4", .value = 5 },
1793         { .name = "pll_a_out0", .value = 6 },
1794 #if 0 /* FIXME: not implemented */
1795         { .name = "ext_vimclk", .value = 7 },
1796 #endif
1797 #if 1 /* FIXME: for debugging on tegra2 - to be removed */
1798         { .name = "pll_a_out0", .value = 7 },
1799         { .name = "pll_a_out0", .value = 8 },
1800         { .name = "pll_a_out0", .value = 9 },
1801         { .name = "pll_a_out0", .value =10 },
1802         { .name = "pll_a_out0", .value =11 },
1803         { .name = "pll_a_out0", .value =12 },
1804         { .name = "pll_a_out0", .value =13 },
1805         { .name = "pll_a_out0", .value =14 },
1806         { .name = "pll_a_out0", .value =15 },
1807 #endif
1808         { 0, 0 }
1809 };
1810
1811 #define AUDIO_SYNC_CLK(_id, _index)                     \
1812         {                                               \
1813                 .name      = #_id,                      \
1814                 .inputs    = mux_audio_sync_clk,        \
1815                 .reg       = 0x4A0 + (_index) * 4,      \
1816                 .max_rate  = 24000000,                  \
1817                 .ops       = &tegra_audio_sync_clk_ops  \
1818         }
1819 static struct clk tegra_clk_audio_list[] = {
1820         AUDIO_SYNC_CLK(audio0, 0),
1821         AUDIO_SYNC_CLK(audio1, 1),
1822         AUDIO_SYNC_CLK(audio2, 2),
1823         AUDIO_SYNC_CLK(audio3, 3),
1824         AUDIO_SYNC_CLK(audio4, 4),
1825         AUDIO_SYNC_CLK(audio, 5),       /* SPDIF */
1826 };
1827
1828 #define AUDIO_SYNC_2X_CLK(_id, _index)                          \
1829         {                                                       \
1830                 .name      = #_id "_2x",                        \
1831                 .flags     = PERIPH_NO_RESET,                   \
1832                 .max_rate  = 48000000,                          \
1833                 .ops       = &tegra_clk_double_ops,             \
1834                 .reg       = 0x49C,                             \
1835                 .reg_shift = 24 + (_index),                     \
1836                 .parent    = &tegra_clk_audio_list[(_index)],   \
1837                 .u.periph = {                                   \
1838                         .clk_num = 113 + (_index),              \
1839                 },                                              \
1840         }
1841 static struct clk tegra_clk_audio_2x_list[] = {
1842         AUDIO_SYNC_2X_CLK(audio0, 0),
1843         AUDIO_SYNC_2X_CLK(audio1, 1),
1844         AUDIO_SYNC_2X_CLK(audio2, 2),
1845         AUDIO_SYNC_2X_CLK(audio3, 3),
1846         AUDIO_SYNC_2X_CLK(audio4, 4),
1847         AUDIO_SYNC_2X_CLK(audio, 5),    /* SPDIF */
1848 };
1849
1850 #define MUX_I2S_SPDIF(_id, _index)                                      \
1851 static struct clk_mux_sel mux_pllaout0_##_id##_2x_pllp_clkm[] = {       \
1852         {.input = &tegra_pll_a_out0, .value = 0},                       \
1853         {.input = &tegra_clk_audio_2x_list[(_index)], .value = 1},      \
1854         {.input = &tegra_pll_p, .value = 2},                            \
1855         {.input = &tegra_clk_m, .value = 3},                            \
1856         { 0, 0},                                                        \
1857 }
1858 MUX_I2S_SPDIF(audio0, 0);
1859 MUX_I2S_SPDIF(audio1, 1);
1860 MUX_I2S_SPDIF(audio2, 2);
1861 MUX_I2S_SPDIF(audio3, 3);
1862 MUX_I2S_SPDIF(audio4, 4);
1863 MUX_I2S_SPDIF(audio, 5);                /* SPDIF */
1864
1865 /* This is called after peripheral clocks are initialized, as the
1866  * audio_sync clock depends on some of the peripheral clocks.
1867  */
1868
1869 static void init_audio_sync_clock_mux(void)
1870 {
1871         int i;
1872         struct clk_mux_sel *sel = mux_audio_sync_clk;
1873         const struct audio_sources *src = mux_audio_sync_clk_sources;
1874
1875         for (i = 0; src->name; i++, sel++, src++) {
1876                 sel->input = tegra_get_clock_by_name(src->name);
1877                 if (!sel->input)
1878                         pr_err("%s: could not find clk %s\n", __func__,
1879                                 src->name);
1880                 sel->value = src->value;
1881         }
1882 }
1883
1884 static struct clk_mux_sel mux_cclk[] = {
1885         { .input = &tegra_clk_m,        .value = 0},
1886         { .input = &tegra_pll_c,        .value = 1},
1887         { .input = &tegra_clk_32k,      .value = 2},
1888         { .input = &tegra_pll_m,        .value = 3},
1889         { .input = &tegra_pll_p,        .value = 4},
1890         { .input = &tegra_pll_p_out4,   .value = 5},
1891         { .input = &tegra_pll_p_out3,   .value = 6},
1892         /* { .input = &tegra_clk_d,     .value = 7}, - no use on tegra3 */
1893         { .input = &tegra_pll_x_out0,   .value = 8},
1894         { 0, 0},
1895 };
1896
1897 static struct clk_mux_sel mux_sclk[] = {
1898         { .input = &tegra_clk_m,        .value = 0},
1899         { .input = &tegra_pll_c_out1,   .value = 1},
1900         { .input = &tegra_pll_p_out4,   .value = 2},
1901         { .input = &tegra_pll_p_out3,   .value = 3},
1902         { .input = &tegra_pll_p_out2,   .value = 4},
1903         /* { .input = &tegra_clk_d,     .value = 5}, - no use on tegra3 */
1904         { .input = &tegra_clk_32k,      .value = 6},
1905         { .input = &tegra_pll_m_out1,   .value = 7},
1906         { 0, 0},
1907 };
1908
1909 static struct clk tegra_clk_cclk = {
1910         .name   = "cclk",
1911         .inputs = mux_cclk,
1912         .reg    = 0x20,
1913         .ops    = &tegra_super_ops,
1914         .max_rate = 1000000000,
1915 };
1916
1917 static struct clk tegra_clk_sclk = {
1918         .name   = "sclk",
1919         .inputs = mux_sclk,
1920         .reg    = 0x28,
1921         .ops    = &tegra_super_ops,
1922         .max_rate = 240000000,
1923         .u.shared_bus = {
1924                 .min_rate = 120000000,
1925         },
1926 };
1927
1928 static struct clk tegra_clk_virtual_cpu = {
1929         .name      = "cpu",
1930         .parent    = &tegra_clk_cclk,
1931         .ops       = &tegra_cpu_ops,
1932         .max_rate  = 1000000000,
1933         .u.cpu = {
1934                 .main      = &tegra_pll_x_out0,
1935                 .backup    = &tegra_pll_p,
1936                 .lp_max_rate = 456000000,
1937         },
1938 };
1939
1940 static struct clk tegra_clk_cop = {
1941         .name      = "cop",
1942         .parent    = &tegra_clk_sclk,
1943         .ops       = &tegra_cop_ops,
1944         .max_rate  = 240000000,
1945 };
1946
1947 static struct clk tegra_clk_hclk = {
1948         .name           = "hclk",
1949         .flags          = DIV_BUS,
1950         .parent         = &tegra_clk_sclk,
1951         .reg            = 0x30,
1952         .reg_shift      = 4,
1953         .ops            = &tegra_bus_ops,
1954         .max_rate       = 240000000,
1955 };
1956
1957 static struct clk tegra_clk_pclk = {
1958         .name           = "pclk",
1959         .flags          = DIV_BUS,
1960         .parent         = &tegra_clk_hclk,
1961         .reg            = 0x30,
1962         .reg_shift      = 0,
1963         .ops            = &tegra_bus_ops,
1964         .max_rate       = 120000000,
1965 };
1966
1967 static struct clk tegra_clk_blink = {
1968         .name           = "blink",
1969         .parent         = &tegra_clk_32k,
1970         .reg            = 0x40,
1971         .ops            = &tegra_blink_clk_ops,
1972         .max_rate       = 32768,
1973 };
1974
1975 static struct clk_mux_sel mux_pllm_pllc_pllp_plla[] = {
1976         { .input = &tegra_pll_m, .value = 0},
1977         { .input = &tegra_pll_c, .value = 1},
1978         { .input = &tegra_pll_p, .value = 2},
1979         { .input = &tegra_pll_a_out0, .value = 3},
1980         { 0, 0},
1981 };
1982
1983 static struct clk_mux_sel mux_pllm_pllc_pllp_clkm[] = {
1984         { .input = &tegra_pll_m, .value = 0},
1985         { .input = &tegra_pll_c, .value = 1},
1986         { .input = &tegra_pll_p, .value = 2},
1987         { .input = &tegra_clk_m, .value = 3},
1988         { 0, 0},
1989 };
1990
1991 static struct clk_mux_sel mux_pllp_pllc_pllm_clkm[] = {
1992         { .input = &tegra_pll_p, .value = 0},
1993         { .input = &tegra_pll_c, .value = 1},
1994         { .input = &tegra_pll_m, .value = 2},
1995         { .input = &tegra_clk_m, .value = 3},
1996         { 0, 0},
1997 };
1998
1999 static struct clk_mux_sel mux_pllp_plld_pllc_clkm[] = {
2000         {.input = &tegra_pll_p, .value = 0},
2001         {.input = &tegra_pll_d_out0, .value = 1},
2002         {.input = &tegra_pll_c, .value = 2},
2003         {.input = &tegra_clk_m, .value = 3},
2004         { 0, 0},
2005 };
2006
2007 /* FIXME: add plld2 */
2008 static struct clk_mux_sel mux_pllp_pllm_plld_plla_pllc_clkm[] = {
2009         {.input = &tegra_pll_p, .value = 0},
2010         {.input = &tegra_pll_m, .value = 1},
2011         {.input = &tegra_pll_d_out0, .value = 2},
2012         {.input = &tegra_pll_a_out0, .value = 3},
2013         {.input = &tegra_pll_c, .value = 4},
2014         {.input = &tegra_clk_m, .value = 6},
2015         { 0, 0},
2016 };
2017
2018 static struct clk_mux_sel mux_plla_pllc_pllp_clkm[] = {
2019         { .input = &tegra_pll_a_out0, .value = 0},
2020         { .input = &tegra_pll_c, .value = 1},
2021         { .input = &tegra_pll_p, .value = 2},
2022         { .input = &tegra_clk_m, .value = 3},
2023         { 0, 0},
2024 };
2025
2026 static struct clk_mux_sel mux_pllp_pllc_clk32_clkm[] = {
2027         {.input = &tegra_pll_p,     .value = 0},
2028         {.input = &tegra_pll_c,     .value = 1},
2029         {.input = &tegra_clk_32k,   .value = 2},
2030         {.input = &tegra_clk_m,     .value = 3},
2031         { 0, 0},
2032 };
2033
2034 static struct clk_mux_sel mux_pllp_pllc_pllm[] = {
2035         {.input = &tegra_pll_p,     .value = 0},
2036         {.input = &tegra_pll_c,     .value = 1},
2037         {.input = &tegra_pll_m,     .value = 2},
2038         { 0, 0},
2039 };
2040
2041 static struct clk_mux_sel mux_clk_m[] = {
2042         { .input = &tegra_clk_m, .value = 0},
2043         { 0, 0},
2044 };
2045
2046 static struct clk_mux_sel mux_pllp_out3[] = {
2047         { .input = &tegra_pll_p_out3, .value = 0},
2048         { 0, 0},
2049 };
2050
2051 static struct clk_mux_sel mux_plld_out0[] = {
2052         { .input = &tegra_pll_d_out0, .value = 0},
2053         { 0, 0},
2054 };
2055
2056 static struct clk_mux_sel mux_clk_32k[] = {
2057         { .input = &tegra_clk_32k, .value = 0},
2058         { 0, 0},
2059 };
2060
2061 #define PERIPH_CLK(_name, _dev, _con, _clk_num, _reg, _max, _inputs, _flags) \
2062         {                                               \
2063                 .name      = _name,                     \
2064                 .lookup    = {                          \
2065                         .dev_id    = _dev,              \
2066                         .con_id    = _con,              \
2067                 },                                      \
2068                 .ops       = &tegra_periph_clk_ops,     \
2069                 .reg       = _reg,                      \
2070                 .inputs    = _inputs,                   \
2071                 .flags     = _flags,                    \
2072                 .max_rate  = _max,                      \
2073                 .u.periph = {                           \
2074                         .clk_num   = _clk_num,          \
2075                 },                                      \
2076         }
2077
2078 #define SHARED_CLK(_name, _dev, _con, _parent)          \
2079         {                                               \
2080                 .name      = _name,                     \
2081                 .lookup    = {                          \
2082                         .dev_id    = _dev,              \
2083                         .con_id    = _con,              \
2084                 },                                      \
2085                 .ops       = &tegra_clk_shared_bus_ops, \
2086                 .parent = _parent,                      \
2087         }
2088
2089 struct clk tegra_list_clks[] = {
2090         PERIPH_CLK("rtc",       "rtc-tegra",            NULL,   4,      0,      32768,     mux_clk_32k,                 PERIPH_NO_RESET),
2091         PERIPH_CLK("timer",     "timer",                NULL,   5,      0,      26000000,  mux_clk_m,                   0),
2092         PERIPH_CLK("i2s0",      "i2s.4",                NULL,   30,     0x1d8,  26000000,  mux_pllaout0_audio0_2x_pllp_clkm,    MUX | DIV_U71),
2093         PERIPH_CLK("i2s1",      "i2s.0",                NULL,   11,     0x100,  26000000,  mux_pllaout0_audio1_2x_pllp_clkm,    MUX | DIV_U71),
2094         PERIPH_CLK("i2s2",      "i2s.1",                NULL,   18,     0x104,  26000000,  mux_pllaout0_audio2_2x_pllp_clkm,    MUX | DIV_U71),
2095         PERIPH_CLK("i2s3",      "i2s.2",                NULL,   101,    0x3bc,  26000000,  mux_pllaout0_audio3_2x_pllp_clkm,    MUX | DIV_U71),
2096         PERIPH_CLK("i2s4",      "i2s.3",                NULL,   102,    0x3c0,  26000000,  mux_pllaout0_audio4_2x_pllp_clkm,    MUX | DIV_U71),
2097         PERIPH_CLK("spdif_out", "spdif_out",            NULL,   10,     0x108,  100000000, mux_pllaout0_audio_2x_pllp_clkm,     MUX | DIV_U71),
2098         PERIPH_CLK("spdif_in",  "spdif_in",             NULL,   10,     0x10c,  100000000, mux_pllp_pllc_pllm,          MUX | DIV_U71),
2099         PERIPH_CLK("pwm",       "pwm",                  NULL,   17,     0x110,  432000000, mux_pllp_pllc_clk32_clkm,    MUX_PWM | DIV_U71),
2100         PERIPH_CLK("d_audio",   "d_audio",              NULL,   106,    0x3d0,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71),
2101         PERIPH_CLK("dam0",      "dam.0",                NULL,   108,    0x3d8,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71),
2102         PERIPH_CLK("dam1",      "dam.1",                NULL,   109,    0x3dc,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71),
2103         PERIPH_CLK("dam2",      "dam.2",                NULL,   110,    0x3e0,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71),
2104         PERIPH_CLK("hda",       "hda",                  NULL,   125,    0x428,  48000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2105         PERIPH_CLK("xio",       "xio",                  NULL,   45,     0x120,  150000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2106         PERIPH_CLK("twc",       "twc",                  NULL,   16,     0x12c,  150000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2107         PERIPH_CLK("sbc1",      "spi_tegra.0",          NULL,   41,     0x134,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2108         PERIPH_CLK("sbc2",      "spi_tegra.1",          NULL,   44,     0x118,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2109         PERIPH_CLK("sbc3",      "spi_tegra.2",          NULL,   46,     0x11c,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2110         PERIPH_CLK("sbc4",      "spi_tegra.3",          NULL,   68,     0x1b4,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2111         PERIPH_CLK("sbc5",      "spi_tegra.4",          NULL,   104,    0x3c8,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2112         PERIPH_CLK("sbc6",      "spi_tegra.5",          NULL,   105,    0x3cc,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2113         PERIPH_CLK("sata_oob",  "sata",                 NULL,   123,    0x420,  100000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2114         PERIPH_CLK("sata",      "sata",                 NULL,   124,    0x424,  100000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2115         PERIPH_CLK("ndflash",   "tegra_nand",           NULL,   13,     0x160,  164000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2116         PERIPH_CLK("vfir",      "vfir",                 NULL,   7,      0x168,  72000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2117         PERIPH_CLK("sdmmc1",    "sdhci-tegra.0",        NULL,   14,     0x150,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2118         PERIPH_CLK("sdmmc2",    "sdhci-tegra.1",        NULL,   9,      0x154,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2119         PERIPH_CLK("sdmmc3",    "sdhci-tegra.2",        NULL,   69,     0x1bc,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2120         PERIPH_CLK("sdmmc4",    "sdhci-tegra.3",        NULL,   15,     0x164,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2121         PERIPH_CLK("vcp",       "tegra-avp",            "vcp",  29,     0,      250000000, mux_clk_m,                   0),
2122         PERIPH_CLK("bsea",      "tegra-avp",            "bsea", 62,     0,      250000000, mux_clk_m,                   0),
2123         PERIPH_CLK("vde",       "tegra-avp",            "vde",  61,     0x1c8,  250000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage and process_id */
2124         PERIPH_CLK("csite",     "csite",                NULL,   73,     0x1d4,  144000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* max rate ??? */
2125         /* FIXME: what is la? */
2126         PERIPH_CLK("la",        "la",                   NULL,   76,     0x1f8,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2127         PERIPH_CLK("owr",       "tegra_w1",             NULL,   71,     0x1cc,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
2128         PERIPH_CLK("nor",       "nor",                  NULL,   42,     0x1d0,  92000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* requires min voltage */
2129         PERIPH_CLK("mipi",      "mipi",                 NULL,   50,     0x174,  60000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
2130         PERIPH_CLK("i2c1",      "tegra-i2c.0",          NULL,   12,     0x124,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2131         PERIPH_CLK("i2c2",      "tegra-i2c.1",          NULL,   54,     0x198,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2132         PERIPH_CLK("i2c3",      "tegra-i2c.2",          NULL,   67,     0x1b8,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2133         PERIPH_CLK("i2c4",      "tegra-i2c.3",          NULL,   47,     0x128,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2134         PERIPH_CLK("i2c5",      "tegra-i2c.4",          NULL,   103,    0x3c4,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U16),
2135         PERIPH_CLK("i2c1_i2c",  "tegra-i2c.0",          "i2c",  0,      0,      72000000,  mux_pllp_out3,               0),
2136         PERIPH_CLK("i2c2_i2c",  "tegra-i2c.1",          "i2c",  0,      0,      72000000,  mux_pllp_out3,               0),
2137         PERIPH_CLK("i2c3_i2c",  "tegra-i2c.2",          "i2c",  0,      0,      72000000,  mux_pllp_out3,               0),
2138         PERIPH_CLK("i2c4_i2c",  "tegra-i2c.3",          "i2c",  0,      0,      72000000,  mux_pllp_out3,               0),
2139         PERIPH_CLK("i2c5_i2c",  "tegra-i2c.4",          "i2c",  0,      0,      72000000,  mux_pllp_out3,               0),
2140         PERIPH_CLK("uarta",     "uart.0",               NULL,   6,      0x178,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2141         PERIPH_CLK("uartb",     "uart.1",               NULL,   7,      0x17c,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2142         PERIPH_CLK("uartc",     "uart.2",               NULL,   55,     0x1a0,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2143         PERIPH_CLK("uartd",     "uart.3",               NULL,   65,     0x1c0,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2144         PERIPH_CLK("uarte",     "uart.4",               NULL,   66,     0x1c4,  600000000, mux_pllp_pllc_pllm_clkm,     MUX),
2145         PERIPH_CLK("3d",        "3d",                   NULL,   24,     0x158,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_MANUAL_RESET), /* scales with voltage and process_id */
2146         PERIPH_CLK("3d2",       "3d2",                  NULL,   98,     0x3b0,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_MANUAL_RESET), /* scales with voltage and process_id */
2147         PERIPH_CLK("2d",        "2d",                   NULL,   21,     0x15c,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2148         PERIPH_CLK("vi",        "tegra_camera",         "vi",   20,     0x148,  150000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2149         PERIPH_CLK("vi_sensor", "tegra_camera",         "vi_sensor",    20,     0x1a8,  150000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_NO_RESET), /* scales with voltage and process_id */
2150         PERIPH_CLK("epp",       "epp",                  NULL,   19,     0x16c,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2151         PERIPH_CLK("mpe",       "mpe",                  NULL,   60,     0x170,  250000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2152         PERIPH_CLK("host1x",    "host1x",               NULL,   28,     0x180,  166000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71), /* scales with voltage and process_id */
2153         PERIPH_CLK("cve",       "cve",                  NULL,   49,     0x140,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2154         PERIPH_CLK("tvo",       "tvo",                  NULL,   49,     0x188,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2155         PERIPH_CLK("hdmi",      "hdmi",                 NULL,   51,     0x18c,  600000000, mux_pllp_pllm_plld_plla_pllc_clkm,   MUX8 | DIV_U71), /* requires min voltage */
2156         PERIPH_CLK("tvdac",     "tvdac",                NULL,   53,     0x194,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
2157         PERIPH_CLK("disp1",     "tegradc.0",            NULL,   27,     0x138,  600000000, mux_pllp_pllm_plld_plla_pllc_clkm,   MUX8), /* scales with voltage and process_id */
2158         PERIPH_CLK("disp2",     "tegradc.1",            NULL,   26,     0x13c,  600000000, mux_pllp_pllm_plld_plla_pllc_clkm,   MUX8), /* scales with voltage and process_id */
2159         PERIPH_CLK("usbd",      "fsl-tegra-udc",        NULL,   22,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
2160         PERIPH_CLK("usb2",      "tegra-ehci.1",         NULL,   58,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
2161         PERIPH_CLK("usb3",      "tegra-ehci.2",         NULL,   59,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
2162         PERIPH_CLK("emc",       "emc",                  NULL,   57,     0x19c,  800000000, mux_pllm_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_EMC_ENB),
2163         PERIPH_CLK("dsi",       "dsi",                  NULL,   48,     0,      500000000, mux_plld_out0,               0), /* scales with voltage */
2164         PERIPH_CLK("csi",       "tegra_camera",         "csi",  52,     0,      72000000,  mux_pllp_out3,               0),
2165         PERIPH_CLK("isp",       "tegra_camera",         "isp",  23,     0,      150000000, mux_clk_m,                   0), /* same frequency as VI */
2166         PERIPH_CLK("csus",      "tegra_camera",         "csus", 92,     0,      150000000, mux_clk_m,                   PERIPH_NO_RESET),
2167
2168         SHARED_CLK("avp.sclk",  "tegra-avp",            "sclk", &tegra_clk_sclk),
2169 };
2170
2171 #define CLK_DUPLICATE(_name, _dev, _con)                \
2172         {                                               \
2173                 .name   = _name,                        \
2174                 .lookup = {                             \
2175                         .dev_id = _dev,                 \
2176                         .con_id         = _con,         \
2177                 },                                      \
2178         }
2179
2180 /* Some clocks may be used by different drivers depending on the board
2181  * configuration.  List those here to register them twice in the clock lookup
2182  * table under two names.
2183  */
2184 struct clk_duplicate tegra_clk_duplicates[] = {
2185         CLK_DUPLICATE("uarta",  "tegra_uart.0", NULL),
2186         CLK_DUPLICATE("uartb",  "tegra_uart.1", NULL),
2187         CLK_DUPLICATE("uartc",  "tegra_uart.2", NULL),
2188         CLK_DUPLICATE("uartd",  "tegra_uart.3", NULL),
2189         CLK_DUPLICATE("uarte",  "tegra_uart.4", NULL),
2190         CLK_DUPLICATE("usbd", "utmip-pad", NULL),
2191         CLK_DUPLICATE("usbd", "tegra-ehci.0", NULL),
2192         CLK_DUPLICATE("usbd", "tegra-otg", NULL),
2193         CLK_DUPLICATE("hdmi", "tegradc.0", "hdmi"),
2194         CLK_DUPLICATE("hdmi", "tegradc.1", "hdmi"),
2195         CLK_DUPLICATE("pwm", "tegra_pwm.0", NULL),
2196         CLK_DUPLICATE("pwm", "tegra_pwm.1", NULL),
2197         CLK_DUPLICATE("pwm", "tegra_pwm.2", NULL),
2198         CLK_DUPLICATE("pwm", "tegra_pwm.3", NULL),
2199         CLK_DUPLICATE("host1x", "tegra_grhost", "host1x"),
2200         CLK_DUPLICATE("2d", "tegra_grhost", "gr2d"),
2201         CLK_DUPLICATE("3d", "tegra_grhost", "gr3d"),
2202         CLK_DUPLICATE("epp", "tegra_grhost", "epp"),
2203         CLK_DUPLICATE("mpe", "tegra_grhost", "mpe"),
2204         CLK_DUPLICATE("cop", "tegra-avp", "cop"),
2205 };
2206
2207 struct clk *tegra_ptr_clks[] = {
2208         &tegra_clk_32k,
2209         &tegra_clk_m,
2210         &tegra_pll_ref,
2211         &tegra_pll_m,
2212         &tegra_pll_m_out1,
2213         &tegra_pll_c,
2214         &tegra_pll_c_out1,
2215         &tegra_pll_p,
2216         &tegra_pll_p_out1,
2217         &tegra_pll_p_out2,
2218         &tegra_pll_p_out3,
2219         &tegra_pll_p_out4,
2220         &tegra_pll_a,
2221         &tegra_pll_a_out0,
2222         &tegra_pll_d,
2223         &tegra_pll_d_out0,
2224         &tegra_pll_u,
2225         &tegra_pll_x,
2226         &tegra_pll_x_out0,
2227         &tegra_clk_cclk,
2228         &tegra_clk_sclk,
2229         &tegra_clk_hclk,
2230         &tegra_clk_pclk,
2231         &tegra_dev1_clk,
2232         &tegra_dev2_clk,
2233         &tegra_clk_virtual_cpu,
2234         &tegra_clk_blink,
2235         &tegra_clk_cop,
2236 };
2237
2238 static void tegra3_init_one_clock(struct clk *c)
2239 {
2240         clk_init(c);
2241         if (!c->lookup.dev_id && !c->lookup.con_id)
2242                 c->lookup.con_id = c->name;
2243         c->lookup.clk = c;
2244         clkdev_add(&c->lookup);
2245 }
2246
2247 //FIXME: void __init tegra3_init_clocks(void)
2248 void __init tegra_soc_init_clocks(void)
2249 {
2250         int i;
2251         struct clk *c;
2252
2253         for (i = 0; i < ARRAY_SIZE(tegra_ptr_clks); i++)
2254                 tegra3_init_one_clock(tegra_ptr_clks[i]);
2255
2256         for (i = 0; i < ARRAY_SIZE(tegra_list_clks); i++)
2257                 tegra3_init_one_clock(&tegra_list_clks[i]);
2258
2259         for (i = 0; i < ARRAY_SIZE(tegra_clk_duplicates); i++) {
2260                 c = tegra_get_clock_by_name(tegra_clk_duplicates[i].name);
2261                 if (!c) {
2262                         pr_err("%s: Unknown duplicate clock %s\n", __func__,
2263                                 tegra_clk_duplicates[i].name);
2264                         continue;
2265                 }
2266
2267                 tegra_clk_duplicates[i].lookup.clk = c;
2268                 clkdev_add(&tegra_clk_duplicates[i].lookup);
2269         }
2270
2271         init_audio_sync_clock_mux();
2272         for (i = 0; i < ARRAY_SIZE(tegra_clk_audio_list); i++)
2273                 tegra3_init_one_clock(&tegra_clk_audio_list[i]);
2274         for (i = 0; i < ARRAY_SIZE(tegra_clk_audio_2x_list); i++)
2275                 tegra3_init_one_clock(&tegra_clk_audio_2x_list[i]);
2276 }
2277
2278 #ifdef CONFIG_PM
2279 static u32 clk_rst_suspend[RST_DEVICES_NUM + CLK_OUT_ENB_NUM +
2280                            PERIPH_CLK_SOURCE_NUM + 15];
2281
2282 void tegra_clk_suspend(void)
2283 {
2284         unsigned long off;
2285         u32 *ctx = clk_rst_suspend;
2286
2287         *ctx++ = clk_readl(OSC_CTRL) & OSC_CTRL_MASK;
2288         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_BASE);
2289         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
2290         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_BASE);
2291         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
2292
2293         *ctx++ = clk_readl(tegra_pll_m_out1.reg);
2294         *ctx++ = clk_readl(tegra_pll_a_out0.reg);
2295         *ctx++ = clk_readl(tegra_pll_c_out1.reg);
2296
2297         *ctx++ = clk_readl(tegra_clk_cclk.reg);
2298         *ctx++ = clk_readl(tegra_clk_cclk.reg + SUPER_CLK_DIVIDER);
2299
2300         *ctx++ = clk_readl(tegra_clk_sclk.reg);
2301         *ctx++ = clk_readl(tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
2302         *ctx++ = clk_readl(tegra_clk_pclk.reg);
2303
2304         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
2305                         off += 4) {
2306                 if (off == PERIPH_CLK_SOURCE_EMC)
2307                         continue;
2308                 *ctx++ = clk_readl(off);
2309         }
2310         for (off = PERIPH_CLK_SOURCE_G3D2; off <= PERIPH_CLK_SOURCE_SE;
2311                         off+=4) {
2312                 *ctx++ = clk_readl(off);
2313         }
2314
2315         *ctx++ = clk_readl(RST_DEVICES_L);
2316         *ctx++ = clk_readl(RST_DEVICES_H);
2317         *ctx++ = clk_readl(RST_DEVICES_U);
2318         *ctx++ = clk_readl(RST_DEVICES_V);
2319         *ctx++ = clk_readl(RST_DEVICES_W);
2320
2321         *ctx++ = clk_readl(CLK_OUT_ENB_L);
2322         *ctx++ = clk_readl(CLK_OUT_ENB_H);
2323         *ctx++ = clk_readl(CLK_OUT_ENB_U);
2324         *ctx++ = clk_readl(CLK_OUT_ENB_V);
2325         *ctx++ = clk_readl(CLK_OUT_ENB_W);
2326
2327         *ctx++ = clk_readl(MISC_CLK_ENB);
2328         *ctx++ = clk_readl(CLK_MASK_ARM);
2329 }
2330
2331 void tegra_clk_resume(void)
2332 {
2333         unsigned long off;
2334         const u32 *ctx = clk_rst_suspend;
2335         u32 val;
2336
2337         val = clk_readl(OSC_CTRL) & ~OSC_CTRL_MASK;
2338         val |= *ctx++;
2339         clk_writel(val, OSC_CTRL);
2340
2341         /* FIXME: add plld, and wait for lock */
2342         clk_writel(*ctx++, tegra_pll_c.reg + PLL_BASE);
2343         clk_writel(*ctx++, tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
2344         clk_writel(*ctx++, tegra_pll_a.reg + PLL_BASE);
2345         clk_writel(*ctx++, tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
2346         udelay(300);
2347
2348         clk_writel(*ctx++, tegra_pll_m_out1.reg);
2349         clk_writel(*ctx++, tegra_pll_a_out0.reg);
2350         clk_writel(*ctx++, tegra_pll_c_out1.reg);
2351
2352         clk_writel(*ctx++, tegra_clk_cclk.reg);
2353         clk_writel(*ctx++, tegra_clk_cclk.reg + SUPER_CLK_DIVIDER);
2354
2355         clk_writel(*ctx++, tegra_clk_sclk.reg);
2356         clk_writel(*ctx++, tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
2357         clk_writel(*ctx++, tegra_clk_pclk.reg);
2358
2359         /* enable all clocks before configuring clock sources */
2360         clk_writel(0xfdfffff1ul, CLK_OUT_ENB_L);
2361         clk_writel(0xfefff7f7ul, CLK_OUT_ENB_H);
2362         clk_writel(0x75f79bfful, CLK_OUT_ENB_U);
2363         clk_writel(0xfffffffful, CLK_OUT_ENB_V);
2364         clk_writel(0x00003ffful, CLK_OUT_ENB_W);
2365         wmb();
2366
2367         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
2368                         off += 4) {
2369                 if (off == PERIPH_CLK_SOURCE_EMC)
2370                         continue;
2371                 clk_writel(*ctx++, off);
2372         }
2373         for (off = PERIPH_CLK_SOURCE_G3D2; off <= PERIPH_CLK_SOURCE_SE;
2374                         off += 4) {
2375                 clk_writel(*ctx++, off);
2376         }
2377         wmb();
2378
2379         clk_writel(*ctx++, RST_DEVICES_L);
2380         clk_writel(*ctx++, RST_DEVICES_H);
2381         clk_writel(*ctx++, RST_DEVICES_U);
2382         clk_writel(*ctx++, RST_DEVICES_V);
2383         clk_writel(*ctx++, RST_DEVICES_W);
2384         wmb();
2385
2386         clk_writel(*ctx++, CLK_OUT_ENB_L);
2387         clk_writel(*ctx++, CLK_OUT_ENB_H);
2388         clk_writel(*ctx++, CLK_OUT_ENB_U);
2389         clk_writel(*ctx++, CLK_OUT_ENB_V);
2390         clk_writel(*ctx++, CLK_OUT_ENB_W);
2391         wmb();
2392
2393         clk_writel(*ctx++, MISC_CLK_ENB);
2394         clk_writel(*ctx++, CLK_MASK_ARM);
2395 }
2396 #endif