i2c: tegra: rename fast clock and div clock
[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-2012 NVIDIA CORPORATION. All rights reserved.
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; version 2 of the License.
9  *
10  * This program is distributed in the hope that it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
18  *
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/list.h>
24 #include <linux/spinlock.h>
25 #include <linux/delay.h>
26 #include <linux/err.h>
27 #include <linux/io.h>
28 #include <linux/clk.h>
29 #include <linux/cpufreq.h>
30 #include <linux/syscore_ops.h>
31
32 #include <asm/clkdev.h>
33
34 #include <mach/iomap.h>
35 #include <mach/edp.h>
36
37 #include "clock.h"
38 #include "fuse.h"
39 #include "dvfs.h"
40 #include "pm.h"
41 #include "sleep.h"
42 #include "tegra3_emc.h"
43
44 #define RST_DEVICES_L                   0x004
45 #define RST_DEVICES_H                   0x008
46 #define RST_DEVICES_U                   0x00C
47 #define RST_DEVICES_V                   0x358
48 #define RST_DEVICES_W                   0x35C
49 #define RST_DEVICES_SET_L               0x300
50 #define RST_DEVICES_CLR_L               0x304
51 #define RST_DEVICES_SET_V               0x430
52 #define RST_DEVICES_CLR_V               0x434
53 #define RST_DEVICES_NUM                 5
54
55 #define CLK_OUT_ENB_L                   0x010
56 #define CLK_OUT_ENB_H                   0x014
57 #define CLK_OUT_ENB_U                   0x018
58 #define CLK_OUT_ENB_V                   0x360
59 #define CLK_OUT_ENB_W                   0x364
60 #define CLK_OUT_ENB_SET_L               0x320
61 #define CLK_OUT_ENB_CLR_L               0x324
62 #define CLK_OUT_ENB_SET_V               0x440
63 #define CLK_OUT_ENB_CLR_V               0x444
64 #define CLK_OUT_ENB_NUM                 5
65
66 #define RST_DEVICES_V_SWR_CPULP_RST_DIS (0x1 << 1)
67 #define CLK_OUT_ENB_V_CLK_ENB_CPULP_EN  (0x1 << 1)
68
69 #define PERIPH_CLK_TO_BIT(c)            (1 << (c->u.periph.clk_num % 32))
70 #define PERIPH_CLK_TO_RST_REG(c)        \
71         periph_clk_to_reg((c), RST_DEVICES_L, RST_DEVICES_V, 4)
72 #define PERIPH_CLK_TO_RST_SET_REG(c)    \
73         periph_clk_to_reg((c), RST_DEVICES_SET_L, RST_DEVICES_SET_V, 8)
74 #define PERIPH_CLK_TO_RST_CLR_REG(c)    \
75         periph_clk_to_reg((c), RST_DEVICES_CLR_L, RST_DEVICES_CLR_V, 8)
76
77 #define PERIPH_CLK_TO_ENB_REG(c)        \
78         periph_clk_to_reg((c), CLK_OUT_ENB_L, CLK_OUT_ENB_V, 4)
79 #define PERIPH_CLK_TO_ENB_SET_REG(c)    \
80         periph_clk_to_reg((c), CLK_OUT_ENB_SET_L, CLK_OUT_ENB_SET_V, 8)
81 #define PERIPH_CLK_TO_ENB_CLR_REG(c)    \
82         periph_clk_to_reg((c), CLK_OUT_ENB_CLR_L, CLK_OUT_ENB_CLR_V, 8)
83
84 #define CLK_MASK_ARM                    0x44
85 #define MISC_CLK_ENB                    0x48
86
87 #define OSC_CTRL                        0x50
88 #define OSC_CTRL_OSC_FREQ_MASK          (0xF<<28)
89 #define OSC_CTRL_OSC_FREQ_13MHZ         (0x0<<28)
90 #define OSC_CTRL_OSC_FREQ_19_2MHZ       (0x4<<28)
91 #define OSC_CTRL_OSC_FREQ_12MHZ         (0x8<<28)
92 #define OSC_CTRL_OSC_FREQ_26MHZ         (0xC<<28)
93 #define OSC_CTRL_OSC_FREQ_16_8MHZ       (0x1<<28)
94 #define OSC_CTRL_OSC_FREQ_38_4MHZ       (0x5<<28)
95 #define OSC_CTRL_OSC_FREQ_48MHZ         (0x9<<28)
96 #define OSC_CTRL_MASK                   (0x3f2 | OSC_CTRL_OSC_FREQ_MASK)
97
98 #define OSC_CTRL_PLL_REF_DIV_MASK       (3<<26)
99 #define OSC_CTRL_PLL_REF_DIV_1          (0<<26)
100 #define OSC_CTRL_PLL_REF_DIV_2          (1<<26)
101 #define OSC_CTRL_PLL_REF_DIV_4          (2<<26)
102
103 #define PERIPH_CLK_SOURCE_I2S1          0x100
104 #define PERIPH_CLK_SOURCE_EMC           0x19c
105 #define PERIPH_CLK_SOURCE_OSC           0x1fc
106 #define PERIPH_CLK_SOURCE_NUM1 \
107         ((PERIPH_CLK_SOURCE_OSC - PERIPH_CLK_SOURCE_I2S1) / 4)
108
109 #define PERIPH_CLK_SOURCE_G3D2          0x3b0
110 #define PERIPH_CLK_SOURCE_SE            0x42c
111 #define PERIPH_CLK_SOURCE_NUM2 \
112         ((PERIPH_CLK_SOURCE_SE - PERIPH_CLK_SOURCE_G3D2) / 4 + 1)
113
114 #define AUDIO_DLY_CLK                   0x49c
115 #define AUDIO_SYNC_CLK_SPDIF            0x4b4
116 #define PERIPH_CLK_SOURCE_NUM3 \
117         ((AUDIO_SYNC_CLK_SPDIF - AUDIO_DLY_CLK) / 4 + 1)
118
119 #define PERIPH_CLK_SOURCE_NUM           (PERIPH_CLK_SOURCE_NUM1 + \
120                                          PERIPH_CLK_SOURCE_NUM2 + \
121                                          PERIPH_CLK_SOURCE_NUM3)
122
123 #define CPU_SOFTRST_CTRL                0x380
124
125 #define PERIPH_CLK_SOURCE_DIVU71_MASK   0xFF
126 #define PERIPH_CLK_SOURCE_DIVU16_MASK   0xFFFF
127 #define PERIPH_CLK_SOURCE_DIV_SHIFT     0
128 #define PERIPH_CLK_SOURCE_DIVIDLE_SHIFT 8
129 #define PERIPH_CLK_SOURCE_DIVIDLE_VAL   50
130 #define PERIPH_CLK_UART_DIV_ENB         (1<<24)
131 #define PERIPH_CLK_VI_SEL_EX_SHIFT      24
132 #define PERIPH_CLK_VI_SEL_EX_MASK       (0x3<<PERIPH_CLK_VI_SEL_EX_SHIFT)
133 #define PERIPH_CLK_NAND_DIV_EX_ENB      (1<<8)
134 #define PERIPH_CLK_DTV_POLARITY_INV     (1<<25)
135
136 #define AUDIO_SYNC_SOURCE_MASK          0x0F
137 #define AUDIO_SYNC_DISABLE_BIT          0x10
138 #define AUDIO_SYNC_TAP_NIBBLE_SHIFT(c)  ((c->reg_shift - 24) * 4)
139
140 #define PLL_BASE                        0x0
141 #define PLL_BASE_BYPASS                 (1<<31)
142 #define PLL_BASE_ENABLE                 (1<<30)
143 #define PLL_BASE_REF_ENABLE             (1<<29)
144 #define PLL_BASE_OVERRIDE               (1<<28)
145 #define PLL_BASE_LOCK                   (1<<27)
146 #define PLL_BASE_DIVP_MASK              (0x7<<20)
147 #define PLL_BASE_DIVP_SHIFT             20
148 #define PLL_BASE_DIVN_MASK              (0x3FF<<8)
149 #define PLL_BASE_DIVN_SHIFT             8
150 #define PLL_BASE_DIVM_MASK              (0x1F)
151 #define PLL_BASE_DIVM_SHIFT             0
152
153 #define PLL_OUT_RATIO_MASK              (0xFF<<8)
154 #define PLL_OUT_RATIO_SHIFT             8
155 #define PLL_OUT_OVERRIDE                (1<<2)
156 #define PLL_OUT_CLKEN                   (1<<1)
157 #define PLL_OUT_RESET_DISABLE           (1<<0)
158
159 #define PLL_MISC(c)                     \
160         (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
161 #define PLL_MISC_LOCK_ENABLE(c) \
162         (((c)->flags & (PLLU | PLLD)) ? (1<<22) : (1<<18))
163
164 #define PLL_MISC_DCCON_SHIFT            20
165 #define PLL_MISC_CPCON_SHIFT            8
166 #define PLL_MISC_CPCON_MASK             (0xF<<PLL_MISC_CPCON_SHIFT)
167 #define PLL_MISC_LFCON_SHIFT            4
168 #define PLL_MISC_LFCON_MASK             (0xF<<PLL_MISC_LFCON_SHIFT)
169 #define PLL_MISC_VCOCON_SHIFT           0
170 #define PLL_MISC_VCOCON_MASK            (0xF<<PLL_MISC_VCOCON_SHIFT)
171 #define PLLD_MISC_CLKENABLE             (1<<30)
172
173 #define PLLU_BASE_POST_DIV              (1<<20)
174
175 #define PLLD_BASE_DSIB_MUX_SHIFT        25
176 #define PLLD_BASE_DSIB_MUX_MASK         (1<<PLLD_BASE_DSIB_MUX_SHIFT)
177 #define PLLD_BASE_CSI_CLKENABLE         (1<<26)
178 #define PLLD_MISC_DSI_CLKENABLE         (1<<30)
179 #define PLLD_MISC_DIV_RST               (1<<23)
180 #define PLLD_MISC_DCCON_SHIFT           12
181
182 #define PLLDU_LFCON_SET_DIVN            600
183
184 /* FIXME: OUT_OF_TABLE_CPCON per pll */
185 #define OUT_OF_TABLE_CPCON              0x8
186
187 #define SUPER_CLK_MUX                   0x00
188 #define SUPER_STATE_SHIFT               28
189 #define SUPER_STATE_MASK                (0xF << SUPER_STATE_SHIFT)
190 #define SUPER_STATE_STANDBY             (0x0 << SUPER_STATE_SHIFT)
191 #define SUPER_STATE_IDLE                (0x1 << SUPER_STATE_SHIFT)
192 #define SUPER_STATE_RUN                 (0x2 << SUPER_STATE_SHIFT)
193 #define SUPER_STATE_IRQ                 (0x3 << SUPER_STATE_SHIFT)
194 #define SUPER_STATE_FIQ                 (0x4 << SUPER_STATE_SHIFT)
195 #define SUPER_LP_DIV2_BYPASS            (0x1 << 16)
196 #define SUPER_SOURCE_MASK               0xF
197 #define SUPER_FIQ_SOURCE_SHIFT          12
198 #define SUPER_IRQ_SOURCE_SHIFT          8
199 #define SUPER_RUN_SOURCE_SHIFT          4
200 #define SUPER_IDLE_SOURCE_SHIFT         0
201
202 #define SUPER_CLK_DIVIDER               0x04
203 #define SUPER_CLOCK_SKIP_ENABLE         (0x1 << 31)
204 #define SUPER_CLOCK_DIV_U71_SHIFT       16
205 #define SUPER_CLOCK_DIV_U71_MASK        (0xff << SUPER_CLOCK_DIV_U71_SHIFT)
206 #define SUPER_CLOCK_SKIP_MUL_SHIFT      8
207 #define SUPER_CLOCK_SKIP_MUL_MASK       (0xff << SUPER_CLOCK_SKIP_MUL_SHIFT)
208 #define SUPER_CLOCK_SKIP_DIV_SHIFT      0
209 #define SUPER_CLOCK_SKIP_DIV_MASK       (0xff << SUPER_CLOCK_SKIP_DIV_SHIFT)
210 #define SUPER_CLOCK_SKIP_MASK           \
211         (SUPER_CLOCK_SKIP_MUL_MASK | SUPER_CLOCK_SKIP_DIV_MASK)
212 #define SUPER_CLOCK_SKIP_TERM_MAX       256
213
214 #define BUS_CLK_DISABLE                 (1<<3)
215 #define BUS_CLK_DIV_MASK                0x3
216
217 #define PMC_CTRL                        0x0
218  #define PMC_CTRL_BLINK_ENB             (1 << 7)
219
220 #define PMC_DPD_PADS_ORIDE              0x1c
221  #define PMC_DPD_PADS_ORIDE_BLINK_ENB   (1 << 20)
222
223 #define PMC_BLINK_TIMER_DATA_ON_SHIFT   0
224 #define PMC_BLINK_TIMER_DATA_ON_MASK    0x7fff
225 #define PMC_BLINK_TIMER_ENB             (1 << 15)
226 #define PMC_BLINK_TIMER_DATA_OFF_SHIFT  16
227 #define PMC_BLINK_TIMER_DATA_OFF_MASK   0xffff
228
229 #define PMC_PLLP_WB0_OVERRIDE                           0xf8
230 #define PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE               (1 << 12)
231 #define PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE             (1 << 11)
232 #define PMC_PLLM_WB0_OVERRIDE                           0x1dc
233 #define PMC_PLLM_WB0_OVERRIDE_DIVP_MASK                 (0x7<<15)
234 #define PMC_PLLM_WB0_OVERRIDE_DIVP_SHIFT                15
235 #define PMC_PLLM_WB0_OVERRIDE_DIVN_MASK                 (0x3FF<<5)
236 #define PMC_PLLM_WB0_OVERRIDE_DIVN_SHIFT                5
237 #define PMC_PLLM_WB0_OVERRIDE_DIVM_MASK                 (0x1F)
238 #define PMC_PLLM_WB0_OVERRIDE_DIVM_SHIFT                0
239
240 #define UTMIP_PLL_CFG2                                  0x488
241 #define UTMIP_PLL_CFG2_STABLE_COUNT(x)                  (((x) & 0xfff) << 6)
242 #define UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(x)              (((x) & 0x3f) << 18)
243 #define UTMIP_PLL_CFG2_FORCE_PD_SAMP_A_POWERDOWN        (1 << 0)
244 #define UTMIP_PLL_CFG2_FORCE_PD_SAMP_B_POWERDOWN        (1 << 2)
245 #define UTMIP_PLL_CFG2_FORCE_PD_SAMP_C_POWERDOWN        (1 << 4)
246
247 #define UTMIP_PLL_CFG1                                  0x484
248 #define UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(x)              (((x) & 0x1f) << 27)
249 #define UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(x)               (((x) & 0xfff) << 0)
250 #define UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN       (1 << 14)
251 #define UTMIP_PLL_CFG1_FORCE_PLL_ACTIVE_POWERDOWN       (1 << 12)
252 #define UTMIP_PLL_CFG1_FORCE_PLLU_POWERDOWN             (1 << 16)
253
254 #define PLLE_BASE_CML_ENABLE            (1<<31)
255 #define PLLE_BASE_ENABLE                (1<<30)
256 #define PLLE_BASE_DIVCML_SHIFT          24
257 #define PLLE_BASE_DIVCML_MASK           (0xf<<PLLE_BASE_DIVCML_SHIFT)
258 #define PLLE_BASE_DIVP_SHIFT            16
259 #define PLLE_BASE_DIVP_MASK             (0x3f<<PLLE_BASE_DIVP_SHIFT)
260 #define PLLE_BASE_DIVN_SHIFT            8
261 #define PLLE_BASE_DIVN_MASK             (0xFF<<PLLE_BASE_DIVN_SHIFT)
262 #define PLLE_BASE_DIVM_SHIFT            0
263 #define PLLE_BASE_DIVM_MASK             (0xFF<<PLLE_BASE_DIVM_SHIFT)
264 #define PLLE_BASE_DIV_MASK              \
265         (PLLE_BASE_DIVCML_MASK | PLLE_BASE_DIVP_MASK | \
266          PLLE_BASE_DIVN_MASK | PLLE_BASE_DIVM_MASK)
267 #define PLLE_BASE_DIV(m, n, p, cml)             \
268          (((cml)<<PLLE_BASE_DIVCML_SHIFT) | ((p)<<PLLE_BASE_DIVP_SHIFT) | \
269           ((n)<<PLLE_BASE_DIVN_SHIFT) | ((m)<<PLLE_BASE_DIVM_SHIFT))
270
271 #define PLLE_MISC_SETUP_BASE_SHIFT      16
272 #define PLLE_MISC_SETUP_BASE_MASK       (0xFFFF<<PLLE_MISC_SETUP_BASE_SHIFT)
273 #define PLLE_MISC_READY                 (1<<15)
274 #define PLLE_MISC_LOCK                  (1<<11)
275 #define PLLE_MISC_LOCK_ENABLE           (1<<9)
276 #define PLLE_MISC_SETUP_EX_SHIFT        2
277 #define PLLE_MISC_SETUP_EX_MASK         (0x3<<PLLE_MISC_SETUP_EX_SHIFT)
278 #define PLLE_MISC_SETUP_MASK            \
279           (PLLE_MISC_SETUP_BASE_MASK | PLLE_MISC_SETUP_EX_MASK)
280 #define PLLE_MISC_SETUP_VALUE           \
281           ((0x7<<PLLE_MISC_SETUP_BASE_SHIFT) | (0x0<<PLLE_MISC_SETUP_EX_SHIFT))
282
283 #define PLLE_SS_CTRL                    0x68
284 #define PLLE_SS_INCINTRV_SHIFT          24
285 #define PLLE_SS_INCINTRV_MASK           (0x3f<<PLLE_SS_INCINTRV_SHIFT)
286 #define PLLE_SS_INC_SHIFT               16
287 #define PLLE_SS_INC_MASK                (0xff<<PLLE_SS_INC_SHIFT)
288 #define PLLE_SS_MAX_SHIFT               0
289 #define PLLE_SS_MAX_MASK                (0x1ff<<PLLE_SS_MAX_SHIFT)
290 #define PLLE_SS_COEFFICIENTS_MASK       \
291         (PLLE_SS_INCINTRV_MASK | PLLE_SS_INC_MASK | PLLE_SS_MAX_MASK)
292 #define PLLE_SS_COEFFICIENTS_12MHZ      \
293         ((0x18<<PLLE_SS_INCINTRV_SHIFT) | (0x1<<PLLE_SS_INC_SHIFT) | \
294          (0x24<<PLLE_SS_MAX_SHIFT))
295 #define PLLE_SS_DISABLE                 ((1<<14) | (1<<12) | (1<<11) | (1<<10))
296
297 #define PLLE_AUX                        0x48c
298 #define PLLE_AUX_PLLP_SEL               (1<<2)
299 #define PLLE_AUX_CML_SATA_ENABLE        (1<<1)
300 #define PLLE_AUX_CML_PCIE_ENABLE        (1<<0)
301
302 #define PMC_SATA_PWRGT                  0x1ac
303 #define PMC_SATA_PWRGT_PLLE_IDDQ_VALUE  (1<<5)
304 #define PMC_SATA_PWRGT_PLLE_IDDQ_SWCTL  (1<<4)
305
306 #define ROUND_DIVIDER_UP        0
307 #define ROUND_DIVIDER_DOWN      1
308
309 /* PLLP default fixed rate in h/w controlled mode */
310 #define PLLP_DEFAULT_FIXED_RATE         216000000
311
312 /* Threshold to engage CPU clock skipper during CPU rate change */
313 #define SKIPPER_ENGAGE_RATE              800000000
314
315 static void tegra3_pllp_init_dependencies(unsigned long pllp_rate);
316 static int tegra3_clk_shared_bus_update(struct clk *bus);
317 static int tegra3_emc_relock_set_rate(struct clk *emc, unsigned long old_rate,
318         unsigned long new_rate, unsigned long new_pll_rate);
319
320 static unsigned long cpu_stay_on_backup_max;
321 static struct clk *emc_bridge;
322 static struct clk *cpu_mode_sclk;
323
324 static bool detach_shared_bus;
325 module_param(detach_shared_bus, bool, 0644);
326
327 static int skipper_delay = 10;
328 module_param(skipper_delay, int, 0644);
329
330 void tegra3_set_cpu_skipper_delay(int delay)
331 {
332         skipper_delay = delay;
333 }
334
335 /**
336 * Structure defining the fields for USB UTMI clocks Parameters.
337 */
338 struct utmi_clk_param
339 {
340         /* Oscillator Frequency in KHz */
341         u32 osc_frequency;
342         /* UTMIP PLL Enable Delay Count  */
343         u8 enable_delay_count;
344         /* UTMIP PLL Stable count */
345         u8 stable_count;
346         /*  UTMIP PLL Active delay count */
347         u8 active_delay_count;
348         /* UTMIP PLL Xtal frequency count */
349         u8 xtal_freq_count;
350 };
351
352 static const struct utmi_clk_param utmi_parameters[] =
353 {
354 /*      OSC_FREQUENCY,  ENABLE_DLY,     STABLE_CNT,     ACTIVE_DLY,     XTAL_FREQ_CNT */
355         {13000000,      0x02,           0x33,           0x05,           0x7F},
356         {19200000,      0x03,           0x4B,           0x06,           0xBB},
357         {12000000,      0x02,           0x2F,           0x04,           0x76},
358         {26000000,      0x04,           0x66,           0x09,           0xFE},
359         {16800000,      0x03,           0x41,           0x0A,           0xA4},
360 };
361
362 static void __iomem *reg_clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
363 static void __iomem *reg_pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
364 static void __iomem *misc_gp_hidrev_base = IO_ADDRESS(TEGRA_APB_MISC_BASE);
365
366 #define MISC_GP_HIDREV                  0x804
367
368 /*
369  * Some peripheral clocks share an enable bit, so refcount the enable bits
370  * in registers CLK_ENABLE_L, ... CLK_ENABLE_W, and protect refcount updates
371  * with lock
372  */
373 static DEFINE_SPINLOCK(periph_refcount_lock);
374 static int tegra_periph_clk_enable_refcount[CLK_OUT_ENB_NUM * 32];
375
376 #define clk_writel(value, reg) \
377         __raw_writel(value, (u32)reg_clk_base + (reg))
378 #define clk_readl(reg) \
379         __raw_readl((u32)reg_clk_base + (reg))
380 #define pmc_writel(value, reg) \
381         __raw_writel(value, (u32)reg_pmc_base + (reg))
382 #define pmc_readl(reg) \
383         __raw_readl((u32)reg_pmc_base + (reg))
384 #define chipid_readl() \
385         __raw_readl((u32)misc_gp_hidrev_base + MISC_GP_HIDREV)
386
387 #define clk_writel_delay(value, reg)                                    \
388         do {                                                            \
389                 __raw_writel((value), (u32)reg_clk_base + (reg));       \
390                 udelay(2);                                              \
391         } while (0)
392
393
394 static inline int clk_set_div(struct clk *c, u32 n)
395 {
396         return clk_set_rate(c, (clk_get_rate(c->parent) + n-1) / n);
397 }
398
399 static inline u32 periph_clk_to_reg(
400         struct clk *c, u32 reg_L, u32 reg_V, int offs)
401 {
402         u32 reg = c->u.periph.clk_num / 32;
403         BUG_ON(reg >= RST_DEVICES_NUM);
404         if (reg < 3) {
405                 reg = reg_L + (reg * offs);
406         } else {
407                 reg = reg_V + ((reg - 3) * offs);
408         }
409         return reg;
410 }
411
412 static int clk_div_x1_get_divider(unsigned long parent_rate, unsigned long rate,
413                         u32 max_x, u32 flags, u32 round_mode)
414 {
415         s64 divider_ux1 = parent_rate;
416         if (!rate)
417                 return -EINVAL;
418
419         if (!(flags & DIV_U71_INT))
420                 divider_ux1 *= 2;
421
422         if (round_mode == ROUND_DIVIDER_UP)
423                 divider_ux1 += rate - 1;
424         do_div(divider_ux1, rate);
425
426         if (flags & DIV_U71_INT)
427                 divider_ux1 *= 2;
428
429         if (divider_ux1 - 2 < 0)
430                 return 0;
431
432         if (divider_ux1 - 2 > max_x)
433                 return -EINVAL;
434
435         return divider_ux1 - 2;
436 }
437
438 static int clk_div71_get_divider(unsigned long parent_rate, unsigned long rate,
439                                  u32 flags, u32 round_mode)
440 {
441         return clk_div_x1_get_divider(parent_rate, rate, 0xFF,
442                         flags, round_mode);
443 }
444
445 static int clk_div151_get_divider(unsigned long parent_rate, unsigned long rate,
446                                  u32 flags, u32 round_mode)
447 {
448         return clk_div_x1_get_divider(parent_rate, rate, 0xFFFF,
449                         flags, round_mode);
450 }
451
452 static int clk_div16_get_divider(unsigned long parent_rate, unsigned long rate)
453 {
454         s64 divider_u16;
455
456         divider_u16 = parent_rate;
457         if (!rate)
458                 return -EINVAL;
459         divider_u16 += rate - 1;
460         do_div(divider_u16, rate);
461
462         if (divider_u16 - 1 < 0)
463                 return 0;
464
465         if (divider_u16 - 1 > 0xFFFF)
466                 return -EINVAL;
467
468         return divider_u16 - 1;
469 }
470
471 /* clk_m functions */
472 static unsigned long tegra3_clk_m_autodetect_rate(struct clk *c)
473 {
474         u32 osc_ctrl = clk_readl(OSC_CTRL);
475         u32 auto_clock_control = osc_ctrl & ~OSC_CTRL_OSC_FREQ_MASK;
476         u32 pll_ref_div = osc_ctrl & OSC_CTRL_PLL_REF_DIV_MASK;
477
478         c->rate = tegra_clk_measure_input_freq();
479         switch (c->rate) {
480         case 12000000:
481                 auto_clock_control |= OSC_CTRL_OSC_FREQ_12MHZ;
482                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
483                 break;
484         case 13000000:
485                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
486                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
487                 break;
488         case 19200000:
489                 auto_clock_control |= OSC_CTRL_OSC_FREQ_19_2MHZ;
490                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
491                 break;
492         case 26000000:
493                 auto_clock_control |= OSC_CTRL_OSC_FREQ_26MHZ;
494                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
495                 break;
496         case 16800000:
497                 auto_clock_control |= OSC_CTRL_OSC_FREQ_16_8MHZ;
498                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
499                 break;
500         case 38400000:
501                 auto_clock_control |= OSC_CTRL_OSC_FREQ_38_4MHZ;
502                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_2);
503                 break;
504         case 48000000:
505                 auto_clock_control |= OSC_CTRL_OSC_FREQ_48MHZ;
506                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_4);
507                 break;
508         default:
509                 pr_err("%s: Unexpected clock rate %ld", __func__, c->rate);
510                 BUG();
511         }
512         clk_writel(auto_clock_control, OSC_CTRL);
513         return c->rate;
514 }
515
516 static void tegra3_clk_m_init(struct clk *c)
517 {
518         pr_debug("%s on clock %s\n", __func__, c->name);
519         tegra3_clk_m_autodetect_rate(c);
520 }
521
522 static int tegra3_clk_m_enable(struct clk *c)
523 {
524         pr_debug("%s on clock %s\n", __func__, c->name);
525         return 0;
526 }
527
528 static void tegra3_clk_m_disable(struct clk *c)
529 {
530         pr_debug("%s on clock %s\n", __func__, c->name);
531         WARN(1, "Attempting to disable main SoC clock\n");
532 }
533
534 static struct clk_ops tegra_clk_m_ops = {
535         .init           = tegra3_clk_m_init,
536         .enable         = tegra3_clk_m_enable,
537         .disable        = tegra3_clk_m_disable,
538 };
539
540 static struct clk_ops tegra_clk_m_div_ops = {
541         .enable         = tegra3_clk_m_enable,
542 };
543
544 /* PLL reference divider functions */
545 static void tegra3_pll_ref_init(struct clk *c)
546 {
547         u32 pll_ref_div = clk_readl(OSC_CTRL) & OSC_CTRL_PLL_REF_DIV_MASK;
548         pr_debug("%s on clock %s\n", __func__, c->name);
549
550         switch (pll_ref_div) {
551         case OSC_CTRL_PLL_REF_DIV_1:
552                 c->div = 1;
553                 break;
554         case OSC_CTRL_PLL_REF_DIV_2:
555                 c->div = 2;
556                 break;
557         case OSC_CTRL_PLL_REF_DIV_4:
558                 c->div = 4;
559                 break;
560         default:
561                 pr_err("%s: Invalid pll ref divider %d", __func__, pll_ref_div);
562                 BUG();
563         }
564         c->mul = 1;
565         c->state = ON;
566 }
567
568 static struct clk_ops tegra_pll_ref_ops = {
569         .init           = tegra3_pll_ref_init,
570         .enable         = tegra3_clk_m_enable,
571         .disable        = tegra3_clk_m_disable,
572 };
573
574 /* super clock functions */
575 /* "super clocks" on tegra3 have two-stage muxes, fractional 7.1 divider and
576  * clock skipping super divider.  We will ignore the clock skipping divider,
577  * since we can't lower the voltage when using the clock skip, but we can if
578  * we lower the PLL frequency. We will use 7.1 divider for CPU super-clock
579  * only when its parent is a fixed rate PLL, since we can't change PLL rate
580  * in this case.
581  */
582 static void tegra3_super_clk_init(struct clk *c)
583 {
584         u32 val;
585         int source;
586         int shift;
587         const struct clk_mux_sel *sel;
588
589         val = clk_readl(c->reg + SUPER_CLK_MUX);
590         c->state = ON;
591         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
592                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
593         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
594                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
595         source = (val >> shift) & SUPER_SOURCE_MASK;
596         if (c->flags & DIV_2)
597                 source |= val & SUPER_LP_DIV2_BYPASS;
598         for (sel = c->inputs; sel->input != NULL; sel++) {
599                 if (sel->value == source)
600                         break;
601         }
602         BUG_ON(sel->input == NULL);
603         c->parent = sel->input;
604
605         if (c->flags & DIV_U71) {
606                 /* Init safe 7.1 divider value (does not affect PLLX path).
607                    Super skipper is enabled to be ready for emergency throttle,
608                    but set 1:1 */
609                 c->mul = 2;
610                 c->div = 2;
611                 if (!(c->parent->flags & PLLX)) {
612                         val = clk_readl(c->reg + SUPER_CLK_DIVIDER);
613                         val &= SUPER_CLOCK_DIV_U71_MASK;
614                         val >>= SUPER_CLOCK_DIV_U71_SHIFT;
615                         val = max(val, c->u.cclk.div71);
616                         c->u.cclk.div71 = val;
617                         c->div += val;
618                 }
619                 val = SUPER_CLOCK_SKIP_ENABLE +
620                         (c->u.cclk.div71 << SUPER_CLOCK_DIV_U71_SHIFT);
621                 clk_writel(val, c->reg + SUPER_CLK_DIVIDER);
622         }
623         else
624                 clk_writel(0, c->reg + SUPER_CLK_DIVIDER);
625 }
626
627 static int tegra3_super_clk_enable(struct clk *c)
628 {
629         return 0;
630 }
631
632 static void tegra3_super_clk_disable(struct clk *c)
633 {
634         /* since tegra 3 has 2 CPU super clocks - low power lp-mode clock and
635            geared up g-mode super clock - mode switch may request to disable
636            either of them; accept request with no affect on h/w */
637 }
638
639 static int tegra3_super_clk_set_parent(struct clk *c, struct clk *p)
640 {
641         u32 val;
642         const struct clk_mux_sel *sel;
643         int shift;
644
645         val = clk_readl(c->reg + SUPER_CLK_MUX);;
646         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
647                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
648         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
649                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
650         for (sel = c->inputs; sel->input != NULL; sel++) {
651                 if (sel->input == p) {
652                         /* For LP mode super-clock switch between PLLX direct
653                            and divided-by-2 outputs is allowed only when other
654                            than PLLX clock source is current parent */
655                         if ((c->flags & DIV_2) && (p->flags & PLLX) &&
656                             ((sel->value ^ val) & SUPER_LP_DIV2_BYPASS)) {
657                                 if (c->parent->flags & PLLX)
658                                         return -EINVAL;
659                                 val ^= SUPER_LP_DIV2_BYPASS;
660                                 clk_writel_delay(val, c->reg);
661                         }
662                         val &= ~(SUPER_SOURCE_MASK << shift);
663                         val |= (sel->value & SUPER_SOURCE_MASK) << shift;
664
665                         /* 7.1 divider for CPU super-clock does not affect
666                            PLLX path */
667                         if (c->flags & DIV_U71) {
668                                 u32 div = 0;
669                                 if (!(p->flags & PLLX)) {
670                                         div = clk_readl(c->reg +
671                                                         SUPER_CLK_DIVIDER);
672                                         div &= SUPER_CLOCK_DIV_U71_MASK;
673                                         div >>= SUPER_CLOCK_DIV_U71_SHIFT;
674                                 }
675                                 c->div = div + 2;
676                                 c->mul = 2;
677                         }
678
679                         if (c->refcnt)
680                                 clk_enable(p);
681
682                         clk_writel_delay(val, c->reg);
683
684                         if (c->refcnt && c->parent)
685                                 clk_disable(c->parent);
686
687                         clk_reparent(c, p);
688                         return 0;
689                 }
690         }
691         return -EINVAL;
692 }
693
694 static DEFINE_SPINLOCK(super_divider_lock);
695
696 static void tegra3_super_clk_divider_update(struct clk *c, u8 div)
697 {
698         u32 val;
699         unsigned long flags;
700
701         spin_lock_irqsave(&super_divider_lock, flags);
702         val = clk_readl(c->reg + SUPER_CLK_DIVIDER);
703         val &= ~SUPER_CLOCK_DIV_U71_MASK;
704         val |= div << SUPER_CLOCK_DIV_U71_SHIFT;
705         clk_writel(val, c->reg + SUPER_CLK_DIVIDER);
706         spin_unlock_irqrestore(&super_divider_lock, flags);
707         udelay(2);
708 }
709
710 static void tegra3_super_clk_skipper_update(struct clk *c, u8 mul, u8 div)
711 {
712         u32 val;
713         unsigned long flags;
714
715         spin_lock_irqsave(&super_divider_lock, flags);
716         val = clk_readl(c->reg + SUPER_CLK_DIVIDER);
717
718         /* multiplier or divider value = the respective field + 1 */
719         if (mul && div) {
720                 u32 old_mul = ((val & SUPER_CLOCK_SKIP_MUL_MASK) >>
721                                SUPER_CLOCK_SKIP_MUL_SHIFT) + 1;
722                 u32 old_div = ((val & SUPER_CLOCK_SKIP_DIV_MASK) >>
723                                SUPER_CLOCK_SKIP_DIV_SHIFT) + 1;
724
725                 if (mul >= div) {
726                         /* improper fraction is only used to reciprocate the
727                            previous proper one - the division below is exact */
728                         old_mul /= div;
729                         old_div /= mul;
730                 } else {
731                         old_mul *= mul;
732                         old_div *= div;
733                 }
734                 mul = (old_mul <= SUPER_CLOCK_SKIP_TERM_MAX) ?
735                         old_mul : SUPER_CLOCK_SKIP_TERM_MAX;
736                 div = (old_div <= SUPER_CLOCK_SKIP_TERM_MAX) ?
737                         old_div : SUPER_CLOCK_SKIP_TERM_MAX;
738         }
739
740         if (!mul || (mul >= div)) {
741                 mul = 1;
742                 div = 1;
743         }
744         val &= ~SUPER_CLOCK_SKIP_MASK;
745         val |= SUPER_CLOCK_SKIP_ENABLE |
746                 ((mul - 1) << SUPER_CLOCK_SKIP_MUL_SHIFT) |
747                 ((div - 1) << SUPER_CLOCK_SKIP_DIV_SHIFT);
748
749         clk_writel(val, c->reg + SUPER_CLK_DIVIDER);
750         spin_unlock_irqrestore(&super_divider_lock, flags);
751 }
752
753 /*
754  * Do not use super clocks "skippers", since dividing using a clock skipper
755  * does not allow the voltage to be scaled down. Instead adjust the rate of
756  * the parent clock. This requires that the parent of a super clock have no
757  * other children, otherwise the rate will change underneath the other
758  * children. Special case: if fixed rate PLL is CPU super clock parent the
759  * rate of this PLL can't be changed, and it has many other children. In
760  * this case use 7.1 fractional divider to adjust the super clock rate.
761  */
762 static int tegra3_super_clk_set_rate(struct clk *c, unsigned long rate)
763 {
764         if ((c->flags & DIV_U71) && (c->parent->flags & PLL_FIXED)) {
765                 int div = clk_div71_get_divider(c->parent->u.pll.fixed_rate,
766                                         rate, c->flags, ROUND_DIVIDER_DOWN);
767                 if (div < 0)
768                         return div;
769
770                 tegra3_super_clk_divider_update(c, div);
771                 c->u.cclk.div71 = div;
772                 c->div = div + 2;
773                 c->mul = 2;
774                 return 0;
775         }
776         return clk_set_rate(c->parent, rate);
777 }
778
779 static struct clk_ops tegra_super_ops = {
780         .init                   = tegra3_super_clk_init,
781         .enable                 = tegra3_super_clk_enable,
782         .disable                = tegra3_super_clk_disable,
783         .set_parent             = tegra3_super_clk_set_parent,
784         .set_rate               = tegra3_super_clk_set_rate,
785 };
786
787 static int tegra3_twd_clk_set_rate(struct clk *c, unsigned long rate)
788 {
789         /* The input value 'rate' is the clock rate of the CPU complex. */
790         c->rate = (rate * c->mul) / c->div;
791         return 0;
792 }
793
794 static struct clk_ops tegra3_twd_ops = {
795         .set_rate       = tegra3_twd_clk_set_rate,
796 };
797
798 static struct clk tegra3_clk_twd = {
799         /* NOTE: The twd clock must have *NO* parent. It's rate is directly
800                  updated by tegra3_cpu_cmplx_clk_set_rate() because the
801                  frequency change notifer for the twd is called in an
802                  atomic context which cannot take a mutex. */
803         .name     = "twd",
804         .ops      = &tegra3_twd_ops,
805         .max_rate = 1400000000, /* Same as tegra_clk_cpu_cmplx.max_rate */
806         .mul      = 1,
807         .div      = 2,
808 };
809
810 /* virtual cpu clock functions */
811 /* some clocks can not be stopped (cpu, memory bus) while the SoC is running.
812    To change the frequency of these clocks, the parent pll may need to be
813    reprogrammed, so the clock must be moved off the pll, the pll reprogrammed,
814    and then the clock moved back to the pll. Clock skipper maybe temporarily
815    engaged during the switch to limit frequency jumps. To hide this sequence,
816    a virtual clock handles it.
817  */
818 static void tegra3_cpu_clk_init(struct clk *c)
819 {
820         c->state = (!is_lp_cluster() == (c->u.cpu.mode == MODE_G))? ON : OFF;
821 }
822
823 static int tegra3_cpu_clk_enable(struct clk *c)
824 {
825         return 0;
826 }
827
828 static void tegra3_cpu_clk_disable(struct clk *c)
829 {
830         /* since tegra 3 has 2 virtual CPU clocks - low power lp-mode clock
831            and geared up g-mode clock - mode switch may request to disable
832            either of them; accept request with no affect on h/w */
833 }
834
835 static int tegra3_cpu_clk_set_rate(struct clk *c, unsigned long rate)
836 {
837         int ret = 0;
838         bool skipped = false;
839         bool skip = (c->u.cpu.mode == MODE_G) && skipper_delay;
840         bool skip_from_backup = skip && (rate >= SKIPPER_ENGAGE_RATE);
841         bool skip_to_backup =
842                 skip && (clk_get_rate_all_locked(c) >= SKIPPER_ENGAGE_RATE);
843
844         if (c->dvfs) {
845                 if (!c->dvfs->dvfs_rail)
846                         return -ENOSYS;
847                 else if ((!c->dvfs->dvfs_rail->reg) &&
848                           (clk_get_rate_locked(c) < rate)) {
849                         WARN(1, "Increasing CPU rate while regulator is not"
850                                 " ready may overclock CPU\n");
851                         return -ENOSYS;
852                 }
853         }
854
855         /*
856          * Take an extra reference to the main pll so it doesn't turn
857          * off when we move the cpu off of it
858          */
859         clk_enable(c->u.cpu.main);
860
861         if (c->parent->parent != c->u.cpu.backup) {
862                 if (skip_to_backup) {
863                         /* on G CPU use 1/2 skipper step for main <=> backup */
864                         skipped = true;
865                         tegra3_super_clk_skipper_update(c->parent, 1, 2);
866                         udelay(skipper_delay);
867                 }
868
869                 ret = clk_set_parent(c->parent, c->u.cpu.backup);
870                 if (ret) {
871                         pr_err("Failed to switch cpu to clock %s\n",
872                                c->u.cpu.backup->name);
873                         goto out;
874                 }
875
876                 if (skipped && !skip_from_backup) {
877                         skipped = false;
878                         tegra3_super_clk_skipper_update(c->parent, 2, 1);
879                 }
880         }
881
882         if (rate <= cpu_stay_on_backup_max) {
883                 ret = clk_set_rate(c->parent, rate);
884                 if (ret)
885                         pr_err("Failed to set cpu rate %lu on backup source\n",
886                                rate);
887                 goto out;
888         } else {
889                 ret = clk_set_rate(c->parent, c->u.cpu.backup_rate);
890                 if (ret) {
891                         pr_err("Failed to set cpu rate %lu on backup source\n",
892                                c->u.cpu.backup_rate);
893                         goto out;
894                 }
895         }
896
897         if (rate != clk_get_rate(c->u.cpu.main)) {
898                 ret = clk_set_rate(c->u.cpu.main, rate);
899                 if (ret) {
900                         pr_err("Failed to change cpu pll to %lu\n", rate);
901                         goto out;
902                 }
903         }
904
905         if (!skipped && skip_from_backup) {
906                 skipped = true;
907                 tegra3_super_clk_skipper_update(c->parent, 1, 2);
908         }
909
910         ret = clk_set_parent(c->parent, c->u.cpu.main);
911         if (ret) {
912                 pr_err("Failed to switch cpu to clock %s\n", c->u.cpu.main->name);
913                 goto out;
914         }
915
916 out:
917         if (skipped) {
918                 udelay(skipper_delay);
919                 tegra3_super_clk_skipper_update(c->parent, 2, 1);
920         }
921         clk_disable(c->u.cpu.main);
922         return ret;
923 }
924
925 static struct clk_ops tegra_cpu_ops = {
926         .init     = tegra3_cpu_clk_init,
927         .enable   = tegra3_cpu_clk_enable,
928         .disable  = tegra3_cpu_clk_disable,
929         .set_rate = tegra3_cpu_clk_set_rate,
930 };
931
932
933 static void tegra3_cpu_cmplx_clk_init(struct clk *c)
934 {
935         int i = !!is_lp_cluster();
936
937         BUG_ON(c->inputs[0].input->u.cpu.mode != MODE_G);
938         BUG_ON(c->inputs[1].input->u.cpu.mode != MODE_LP);
939         c->parent = c->inputs[i].input;
940 }
941
942 /* cpu complex clock provides second level vitualization (on top of
943    cpu virtual cpu rate control) in order to hide the CPU mode switch
944    sequence */
945 #if PARAMETERIZE_CLUSTER_SWITCH
946 static unsigned int switch_delay;
947 static unsigned int switch_flags;
948 static DEFINE_SPINLOCK(parameters_lock);
949
950 void tegra_cluster_switch_set_parameters(unsigned int us, unsigned int flags)
951 {
952         spin_lock(&parameters_lock);
953         switch_delay = us;
954         switch_flags = flags;
955         spin_unlock(&parameters_lock);
956 }
957 #endif
958
959 static int tegra3_cpu_cmplx_clk_enable(struct clk *c)
960 {
961         return 0;
962 }
963
964 static void tegra3_cpu_cmplx_clk_disable(struct clk *c)
965 {
966         pr_debug("%s on clock %s\n", __func__, c->name);
967
968         /* oops - don't disable the CPU complex clock! */
969         BUG();
970 }
971
972 static int tegra3_cpu_cmplx_clk_set_rate(struct clk *c, unsigned long rate)
973 {
974         unsigned long flags;
975         int ret;
976         struct clk *parent = c->parent;
977
978         if (!parent->ops || !parent->ops->set_rate)
979                 return -ENOSYS;
980
981         clk_lock_save(parent, &flags);
982
983         ret = clk_set_rate_locked(parent, rate);
984
985         /* We can't parent the twd to directly to the CPU complex because
986            the TWD frequency update notifier is called in an atomic context
987            and the CPU frequency update requires a mutex. Update the twd
988            clock rate with the new CPU complex rate. */
989         clk_set_rate(&tegra3_clk_twd, clk_get_rate_locked(parent));
990
991         clk_unlock_restore(parent, &flags);
992
993         return ret;
994 }
995
996 static int tegra3_cpu_cmplx_clk_set_parent(struct clk *c, struct clk *p)
997 {
998         int ret;
999         unsigned int flags, delay;
1000         const struct clk_mux_sel *sel;
1001         unsigned long rate = clk_get_rate(c->parent);
1002
1003         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
1004         BUG_ON(c->parent->u.cpu.mode != (is_lp_cluster() ? MODE_LP : MODE_G));
1005
1006         for (sel = c->inputs; sel->input != NULL; sel++) {
1007                 if (sel->input == p)
1008                         break;
1009         }
1010         if (!sel->input)
1011                 return -EINVAL;
1012
1013 #if PARAMETERIZE_CLUSTER_SWITCH
1014         spin_lock(&parameters_lock);
1015         flags = switch_flags;
1016         delay = switch_delay;
1017         switch_flags = 0;
1018         spin_unlock(&parameters_lock);
1019
1020         if (flags) {
1021                 /* over/under-clocking after switch - allow, but update rate */
1022                 if ((rate > p->max_rate) || (rate < p->min_rate)) {
1023                         unsigned long fl;
1024
1025                         rate = rate > p->max_rate ? p->max_rate : p->min_rate;
1026                         ret = clk_set_rate(c->parent, rate);
1027                         if (ret) {
1028                                 pr_err("%s: Failed to set rate %lu for %s\n",
1029                                         __func__, rate, p->name);
1030                                 return ret;
1031                         }
1032                         clk_lock_save(c->parent, &fl);
1033                         clk_set_rate(&tegra3_clk_twd,
1034                                         clk_get_rate_locked(c->parent));
1035                         clk_unlock_restore(c->parent, &fl);
1036                 }
1037         } else
1038 #endif
1039         {
1040                 if (p == c->parent)             /* already switched - exit*/
1041                         return 0;
1042
1043                 if (rate > p->max_rate) {       /* over-clocking - no switch */
1044                         pr_warn("%s: No %s mode switch to %s at rate %lu\n",
1045                                  __func__, c->name, p->name, rate);
1046                         return -ECANCELED;
1047                 }
1048                 flags = TEGRA_POWER_CLUSTER_IMMEDIATE;
1049                 delay = 0;
1050         }
1051         flags |= (p->u.cpu.mode == MODE_LP) ? TEGRA_POWER_CLUSTER_LP :
1052                 TEGRA_POWER_CLUSTER_G;
1053
1054         clk_enable(cpu_mode_sclk);      /* set SCLK floor for cluster switch */
1055
1056         /* Since in both LP and G mode CPU main and backup sources are the
1057            same, set rate on the new parent just synchronizes super-clock
1058            muxes before mode switch with no PLL re-locking */
1059         ret = clk_set_rate(p, rate);
1060         if (ret) {
1061                 pr_err("%s: Failed to set rate %lu for %s\n",
1062                        __func__, rate, p->name);
1063                 clk_disable(cpu_mode_sclk);
1064                 return ret;
1065         }
1066
1067         /* Enabling new parent scales new mode voltage rail in advanvce
1068            before the switch happens*/
1069         if (c->refcnt)
1070                 clk_enable(p);
1071
1072         /* switch CPU mode */
1073         ret = tegra_cluster_control(delay, flags);
1074         if (ret) {
1075                 if (c->refcnt)
1076                         clk_disable(p);
1077                 pr_err("%s: Failed to switch %s mode to %s\n",
1078                        __func__, c->name, p->name);
1079                 clk_disable(cpu_mode_sclk);
1080                 return ret;
1081         }
1082
1083         /* Disabling old parent scales old mode voltage rail */
1084         if (c->refcnt && c->parent)
1085                 clk_disable(c->parent);
1086
1087         clk_reparent(c, p);
1088         clk_disable(cpu_mode_sclk);
1089         return 0;
1090 }
1091
1092 static long tegra3_cpu_cmplx_round_rate(struct clk *c,
1093         unsigned long rate)
1094 {
1095         if (rate > c->parent->max_rate)
1096                 rate = c->parent->max_rate;
1097         else if (rate < c->parent->min_rate)
1098                 rate = c->parent->min_rate;
1099         return rate;
1100 }
1101
1102 static struct clk_ops tegra_cpu_cmplx_ops = {
1103         .init     = tegra3_cpu_cmplx_clk_init,
1104         .enable   = tegra3_cpu_cmplx_clk_enable,
1105         .disable  = tegra3_cpu_cmplx_clk_disable,
1106         .set_rate = tegra3_cpu_cmplx_clk_set_rate,
1107         .set_parent = tegra3_cpu_cmplx_clk_set_parent,
1108         .round_rate = tegra3_cpu_cmplx_round_rate,
1109 };
1110
1111 /* virtual cop clock functions. Used to acquire the fake 'cop' clock to
1112  * reset the COP block (i.e. AVP) */
1113 static void tegra3_cop_clk_reset(struct clk *c, bool assert)
1114 {
1115         unsigned long reg = assert ? RST_DEVICES_SET_L : RST_DEVICES_CLR_L;
1116
1117         pr_debug("%s %s\n", __func__, assert ? "assert" : "deassert");
1118         clk_writel(1 << 1, reg);
1119 }
1120
1121 static struct clk_ops tegra_cop_ops = {
1122         .reset    = tegra3_cop_clk_reset,
1123 };
1124
1125 /* bus clock functions */
1126 static void tegra3_bus_clk_init(struct clk *c)
1127 {
1128         u32 val = clk_readl(c->reg);
1129         c->state = ((val >> c->reg_shift) & BUS_CLK_DISABLE) ? OFF : ON;
1130         c->div = ((val >> c->reg_shift) & BUS_CLK_DIV_MASK) + 1;
1131         c->mul = 1;
1132 }
1133
1134 static int tegra3_bus_clk_enable(struct clk *c)
1135 {
1136         u32 val = clk_readl(c->reg);
1137         val &= ~(BUS_CLK_DISABLE << c->reg_shift);
1138         clk_writel(val, c->reg);
1139         return 0;
1140 }
1141
1142 static void tegra3_bus_clk_disable(struct clk *c)
1143 {
1144         u32 val = clk_readl(c->reg);
1145         val |= BUS_CLK_DISABLE << c->reg_shift;
1146         clk_writel(val, c->reg);
1147 }
1148
1149 static int tegra3_bus_clk_set_rate(struct clk *c, unsigned long rate)
1150 {
1151         u32 val = clk_readl(c->reg);
1152         unsigned long parent_rate = clk_get_rate(c->parent);
1153         int i;
1154         for (i = 1; i <= 4; i++) {
1155                 if (rate >= parent_rate / i) {
1156                         val &= ~(BUS_CLK_DIV_MASK << c->reg_shift);
1157                         val |= (i - 1) << c->reg_shift;
1158                         clk_writel(val, c->reg);
1159                         c->div = i;
1160                         c->mul = 1;
1161                         return 0;
1162                 }
1163         }
1164         return -EINVAL;
1165 }
1166
1167 static struct clk_ops tegra_bus_ops = {
1168         .init                   = tegra3_bus_clk_init,
1169         .enable                 = tegra3_bus_clk_enable,
1170         .disable                = tegra3_bus_clk_disable,
1171         .set_rate               = tegra3_bus_clk_set_rate,
1172 };
1173
1174 /* Virtual system bus complex clock is used to hide the sequence of
1175    changing sclk/hclk/pclk parents and dividers to configure requested
1176    sclk target rate. */
1177 static void tegra3_sbus_cmplx_init(struct clk *c)
1178 {
1179         unsigned long rate;
1180
1181         c->max_rate = c->parent->max_rate;
1182         c->min_rate = c->parent->min_rate;
1183
1184         /* Threshold must be an exact proper factor of low range parent,
1185            and both low/high range parents have 7.1 fractional dividers */
1186         rate = clk_get_rate(c->u.system.sclk_low->parent);
1187         if (c->u.system.threshold) {
1188                 BUG_ON(c->u.system.threshold > rate) ;
1189                 BUG_ON((rate % c->u.system.threshold) != 0);
1190         }
1191         BUG_ON(!(c->u.system.sclk_low->flags & DIV_U71));
1192         BUG_ON(!(c->u.system.sclk_high->flags & DIV_U71));
1193 }
1194
1195 /* This special sbus round function is implemented because:
1196  *
1197  * (a) fractional dividers can not be used to derive system bus clock with one
1198  * exception: 1 : 2.5 divider is allowed at 1.2V and above (and we do need this
1199  * divider to reach top sbus frequencies from high frequency source).
1200  *
1201  * (b) since sbus is a shared bus, and its frequency is set to the highest
1202  * enabled shared_bus_user clock, the target rate should be rounded up divider
1203  * ladder (if max limit allows it) - for pll_div and peripheral_div common is
1204  * rounding down - special case again.
1205  *
1206  * Note that final rate is trimmed (not rounded up) to avoid spiraling up in
1207  * recursive calls. Lost 1Hz is added in tegra3_sbus_cmplx_set_rate before
1208  * actually setting divider rate.
1209  */
1210 static unsigned long sclk_high_2_5_rate;
1211 static bool sclk_high_2_5_valid;
1212
1213 static long tegra3_sbus_cmplx_round_rate(struct clk *c, unsigned long rate)
1214 {
1215         int i, divider;
1216         unsigned long source_rate, round_rate;
1217         struct clk *new_parent;
1218
1219         rate = max(rate, c->min_rate);
1220
1221         if (!sclk_high_2_5_rate) {
1222                 source_rate = clk_get_rate(c->u.system.sclk_high->parent);
1223                 sclk_high_2_5_rate = 2 * source_rate / 5;
1224                 i = tegra_dvfs_predict_millivolts(c, sclk_high_2_5_rate);
1225                 if (!IS_ERR_VALUE(i) && (i >= 1200) &&
1226                     (sclk_high_2_5_rate <= c->max_rate))
1227                         sclk_high_2_5_valid = true;
1228         }
1229
1230         new_parent = (rate <= c->u.system.threshold) ?
1231                 c->u.system.sclk_low : c->u.system.sclk_high;
1232         source_rate = clk_get_rate(new_parent->parent);
1233
1234         divider = clk_div71_get_divider(source_rate, rate,
1235                 new_parent->flags | DIV_U71_INT, ROUND_DIVIDER_DOWN);
1236         if (divider < 0)
1237                 return divider;
1238
1239         round_rate = source_rate * 2 / (divider + 2);
1240         if (round_rate > c->max_rate) {
1241                 divider += 2;
1242                 round_rate = source_rate * 2 / (divider + 2);
1243         }
1244
1245         if (new_parent == c->u.system.sclk_high) {
1246                 /* Check if 1 : 2.5 ratio provides better approximation */
1247                 if (sclk_high_2_5_valid) {
1248                         if (((sclk_high_2_5_rate < round_rate) &&
1249                             (sclk_high_2_5_rate >= rate)) ||
1250                             ((round_rate < sclk_high_2_5_rate) &&
1251                              (round_rate < rate)))
1252                                 round_rate = sclk_high_2_5_rate;
1253                 }
1254
1255                 if (round_rate <= c->u.system.threshold)
1256                         round_rate = c->u.system.threshold;
1257         }
1258         return round_rate;
1259 }
1260
1261 static int tegra3_sbus_cmplx_set_rate(struct clk *c, unsigned long rate)
1262 {
1263         int ret;
1264         struct clk *new_parent;
1265
1266         /* - select the appropriate sclk parent
1267            - keep hclk at the same rate as sclk
1268            - set pclk at 1:2 rate of hclk unless pclk minimum is violated,
1269              in the latter case switch to 1:1 ratio */
1270
1271         if (rate >= c->u.system.pclk->min_rate * 2) {
1272                 ret = clk_set_div(c->u.system.pclk, 2);
1273                 if (ret) {
1274                         pr_err("Failed to set 1 : 2 pclk divider\n");
1275                         return ret;
1276                 }
1277         }
1278
1279         new_parent = (rate <= c->u.system.threshold) ?
1280                 c->u.system.sclk_low : c->u.system.sclk_high;
1281
1282         ret = clk_set_rate(new_parent, rate + 1);
1283         if (ret) {
1284                 pr_err("Failed to set sclk source %s to %lu\n",
1285                        new_parent->name, rate);
1286                 return ret;
1287         }
1288
1289         if (new_parent != clk_get_parent(c->parent)) {
1290                 ret = clk_set_parent(c->parent, new_parent);
1291                 if (ret) {
1292                         pr_err("Failed to switch sclk source to %s\n",
1293                                new_parent->name);
1294                         return ret;
1295                 }
1296         }
1297
1298         if (rate < c->u.system.pclk->min_rate * 2) {
1299                 ret = clk_set_div(c->u.system.pclk, 1);
1300                 if (ret) {
1301                         pr_err("Failed to set 1 : 1 pclk divider\n");
1302                         return ret;
1303                 }
1304         }
1305
1306         return 0;
1307 }
1308
1309 static struct clk_ops tegra_sbus_cmplx_ops = {
1310         .init = tegra3_sbus_cmplx_init,
1311         .set_rate = tegra3_sbus_cmplx_set_rate,
1312         .round_rate = tegra3_sbus_cmplx_round_rate,
1313         .shared_bus_update = tegra3_clk_shared_bus_update,
1314 };
1315
1316 /* Blink output functions */
1317
1318 static void tegra3_blink_clk_init(struct clk *c)
1319 {
1320         u32 val;
1321
1322         val = pmc_readl(PMC_CTRL);
1323         c->state = (val & PMC_CTRL_BLINK_ENB) ? ON : OFF;
1324         c->mul = 1;
1325         val = pmc_readl(c->reg);
1326
1327         if (val & PMC_BLINK_TIMER_ENB) {
1328                 unsigned int on_off;
1329
1330                 on_off = (val >> PMC_BLINK_TIMER_DATA_ON_SHIFT) &
1331                         PMC_BLINK_TIMER_DATA_ON_MASK;
1332                 val >>= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
1333                 val &= PMC_BLINK_TIMER_DATA_OFF_MASK;
1334                 on_off += val;
1335                 /* each tick in the blink timer is 4 32KHz clocks */
1336                 c->div = on_off * 4;
1337         } else {
1338                 c->div = 1;
1339         }
1340 }
1341
1342 static int tegra3_blink_clk_enable(struct clk *c)
1343 {
1344         u32 val;
1345
1346         val = pmc_readl(PMC_DPD_PADS_ORIDE);
1347         pmc_writel(val | PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
1348
1349         val = pmc_readl(PMC_CTRL);
1350         pmc_writel(val | PMC_CTRL_BLINK_ENB, PMC_CTRL);
1351
1352         return 0;
1353 }
1354
1355 static void tegra3_blink_clk_disable(struct clk *c)
1356 {
1357         u32 val;
1358
1359         val = pmc_readl(PMC_CTRL);
1360         pmc_writel(val & ~PMC_CTRL_BLINK_ENB, PMC_CTRL);
1361
1362         val = pmc_readl(PMC_DPD_PADS_ORIDE);
1363         pmc_writel(val & ~PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
1364 }
1365
1366 static int tegra3_blink_clk_set_rate(struct clk *c, unsigned long rate)
1367 {
1368         unsigned long parent_rate = clk_get_rate(c->parent);
1369         if (rate >= parent_rate) {
1370                 c->div = 1;
1371                 pmc_writel(0, c->reg);
1372         } else {
1373                 unsigned int on_off;
1374                 u32 val;
1375
1376                 on_off = DIV_ROUND_UP(parent_rate / 8, rate);
1377                 c->div = on_off * 8;
1378
1379                 val = (on_off & PMC_BLINK_TIMER_DATA_ON_MASK) <<
1380                         PMC_BLINK_TIMER_DATA_ON_SHIFT;
1381                 on_off &= PMC_BLINK_TIMER_DATA_OFF_MASK;
1382                 on_off <<= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
1383                 val |= on_off;
1384                 val |= PMC_BLINK_TIMER_ENB;
1385                 pmc_writel(val, c->reg);
1386         }
1387
1388         return 0;
1389 }
1390
1391 static struct clk_ops tegra_blink_clk_ops = {
1392         .init                   = &tegra3_blink_clk_init,
1393         .enable                 = &tegra3_blink_clk_enable,
1394         .disable                = &tegra3_blink_clk_disable,
1395         .set_rate               = &tegra3_blink_clk_set_rate,
1396 };
1397
1398 /* PLL Functions */
1399 static int tegra3_pll_clk_wait_for_lock(struct clk *c, u32 lock_reg, u32 lock_bit)
1400 {
1401 #if USE_PLL_LOCK_BITS
1402         int i;
1403         for (i = 0; i < c->u.pll.lock_delay; i++) {
1404                 udelay(2);              /* timeout = 2 * lock time */
1405                 if (clk_readl(lock_reg) & lock_bit) {
1406                         udelay(PLL_POST_LOCK_DELAY);
1407                         return 0;
1408                 }
1409         }
1410         pr_err("Timed out waiting for lock bit on pll %s", c->name);
1411         return -1;
1412 #endif
1413         udelay(c->u.pll.lock_delay);
1414
1415         return 0;
1416 }
1417
1418
1419 static void tegra3_utmi_param_configure(struct clk *c)
1420 {
1421         u32 reg;
1422         int i;
1423         unsigned long main_rate =
1424                 clk_get_rate(c->parent->parent);
1425
1426         for (i = 0; i < ARRAY_SIZE(utmi_parameters); i++) {
1427                 if (main_rate == utmi_parameters[i].osc_frequency) {
1428                         break;
1429                 }
1430         }
1431
1432         if (i >= ARRAY_SIZE(utmi_parameters)) {
1433                 pr_err("%s: Unexpected main rate %lu\n", __func__, main_rate);
1434                 return;
1435         }
1436
1437         reg = clk_readl(UTMIP_PLL_CFG2);
1438
1439         /* Program UTMIP PLL stable and active counts */
1440         /* [FIXME] arclk_rst.h says WRONG! This should be 1ms -> 0x50 Check! */
1441         reg &= ~UTMIP_PLL_CFG2_STABLE_COUNT(~0);
1442         reg |= UTMIP_PLL_CFG2_STABLE_COUNT(
1443                         utmi_parameters[i].stable_count);
1444
1445         reg &= ~UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(~0);
1446
1447         reg |= UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(
1448                         utmi_parameters[i].active_delay_count);
1449
1450         /* Remove power downs from UTMIP PLL control bits */
1451         reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_A_POWERDOWN;
1452         reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_B_POWERDOWN;
1453         reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_C_POWERDOWN;
1454
1455         clk_writel(reg, UTMIP_PLL_CFG2);
1456
1457         /* Program UTMIP PLL delay and oscillator frequency counts */
1458         reg = clk_readl(UTMIP_PLL_CFG1);
1459         reg &= ~UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(~0);
1460
1461         reg |= UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(
1462                 utmi_parameters[i].enable_delay_count);
1463
1464         reg &= ~UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(~0);
1465         reg |= UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(
1466                 utmi_parameters[i].xtal_freq_count);
1467
1468         /* Remove power downs from UTMIP PLL control bits */
1469         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN;
1470         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ACTIVE_POWERDOWN;
1471         reg &= ~UTMIP_PLL_CFG1_FORCE_PLLU_POWERDOWN;
1472
1473         clk_writel(reg, UTMIP_PLL_CFG1);
1474 }
1475
1476 static void tegra3_pll_m_override_update(struct clk *c, bool init)
1477 {
1478         u32 val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
1479
1480         if (!(val & PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE))
1481                 return;
1482
1483         /* override PLLM state with PMC settings */
1484         c->state = (val & PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE) ? ON : OFF;
1485
1486         val = pmc_readl(PMC_PLLM_WB0_OVERRIDE);
1487         c->mul = (val & PMC_PLLM_WB0_OVERRIDE_DIVN_MASK) >>
1488                 PMC_PLLM_WB0_OVERRIDE_DIVN_SHIFT;
1489         c->div = (val & PMC_PLLM_WB0_OVERRIDE_DIVM_MASK) >>
1490                 PMC_PLLM_WB0_OVERRIDE_DIVM_SHIFT;
1491         c->div *= (0x1 << ((val & PMC_PLLM_WB0_OVERRIDE_DIVP_MASK) >>
1492                            PMC_PLLM_WB0_OVERRIDE_DIVP_SHIFT));
1493
1494         /* Save initial override settings in Scratch2 register; will be used by
1495            LP0 entry code to restore PLLM boot configuration */
1496         if (init)
1497                 pmc_writel(val, PMC_SCRATCH2);
1498 }
1499
1500 static void tegra3_pll_clk_init(struct clk *c)
1501 {
1502         u32 val = clk_readl(c->reg + PLL_BASE);
1503
1504         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
1505
1506         if (c->flags & PLL_FIXED && !(val & PLL_BASE_OVERRIDE)) {
1507                 const struct clk_pll_freq_table *sel;
1508                 unsigned long input_rate = clk_get_rate(c->parent);
1509                 c->u.pll.fixed_rate = PLLP_DEFAULT_FIXED_RATE;
1510
1511                 for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
1512                         if (sel->input_rate == input_rate &&
1513                                 sel->output_rate == c->u.pll.fixed_rate) {
1514                                 c->mul = sel->n;
1515                                 c->div = sel->m * sel->p;
1516                                 return;
1517                         }
1518                 }
1519                 pr_err("Clock %s has unknown fixed frequency\n", c->name);
1520                 BUG();
1521         } else if (val & PLL_BASE_BYPASS) {
1522                 c->mul = 1;
1523                 c->div = 1;
1524         } else {
1525                 c->mul = (val & PLL_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
1526                 c->div = (val & PLL_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
1527                 if (c->flags & PLLU)
1528                         c->div *= (val & PLLU_BASE_POST_DIV) ? 1 : 2;
1529                 else
1530                         c->div *= (0x1 << ((val & PLL_BASE_DIVP_MASK) >>
1531                                         PLL_BASE_DIVP_SHIFT));
1532         }
1533
1534         if (c->flags & PLL_FIXED) {
1535                 c->u.pll.fixed_rate = clk_get_rate_locked(c);
1536         }
1537
1538         if (c->flags & PLLU) {
1539                 tegra3_utmi_param_configure(c);
1540         }
1541
1542         if (c->flags & PLLM)
1543                 tegra3_pll_m_override_update(c, true);
1544 }
1545
1546 static int tegra3_pll_clk_enable(struct clk *c)
1547 {
1548         u32 val;
1549         pr_debug("%s on clock %s\n", __func__, c->name);
1550
1551 #if USE_PLL_LOCK_BITS
1552         val = clk_readl(c->reg + PLL_MISC(c));
1553         val |= PLL_MISC_LOCK_ENABLE(c);
1554         clk_writel(val, c->reg + PLL_MISC(c));
1555 #endif
1556         val = clk_readl(c->reg + PLL_BASE);
1557         val &= ~PLL_BASE_BYPASS;
1558         val |= PLL_BASE_ENABLE;
1559         clk_writel(val, c->reg + PLL_BASE);
1560
1561         if (c->flags & PLLM) {
1562                 val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
1563                 val |= PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE;
1564                 pmc_writel(val, PMC_PLLP_WB0_OVERRIDE);
1565                 pmc_readl(PMC_PLLP_WB0_OVERRIDE);
1566         }
1567
1568         tegra3_pll_clk_wait_for_lock(c, c->reg + PLL_BASE, PLL_BASE_LOCK);
1569
1570         return 0;
1571 }
1572
1573 static void tegra3_pll_clk_disable(struct clk *c)
1574 {
1575         u32 val;
1576         pr_debug("%s on clock %s\n", __func__, c->name);
1577
1578         val = clk_readl(c->reg);
1579         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
1580         clk_writel(val, c->reg);
1581
1582         if (c->flags & PLLM) {
1583                 val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
1584                 val &= ~PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE;
1585                 pmc_writel(val, PMC_PLLP_WB0_OVERRIDE);
1586         }
1587 }
1588
1589 static int tegra3_pllm_override_rate(
1590         struct clk *c, const struct clk_pll_freq_table *sel, u32 p_div)
1591 {
1592         u32 val, old_base;
1593
1594         old_base = val = pmc_readl(PMC_PLLM_WB0_OVERRIDE);
1595
1596         /* Keep default CPCON and DCCON in override configuration */
1597         val &= ~(PMC_PLLM_WB0_OVERRIDE_DIVM_MASK |
1598                  PMC_PLLM_WB0_OVERRIDE_DIVN_MASK |
1599                  PMC_PLLM_WB0_OVERRIDE_DIVP_MASK);
1600         val |= (sel->m << PMC_PLLM_WB0_OVERRIDE_DIVM_SHIFT) |
1601                 (sel->n << PMC_PLLM_WB0_OVERRIDE_DIVN_SHIFT) |
1602                 (p_div << PMC_PLLM_WB0_OVERRIDE_DIVP_SHIFT);
1603
1604         if (val != old_base)
1605                 pmc_writel(val, PMC_PLLM_WB0_OVERRIDE);
1606
1607         return 0;
1608 }
1609
1610 static int tegra3_pll_clk_set_rate(struct clk *c, unsigned long rate)
1611 {
1612         u32 val, p_div, old_base;
1613         unsigned long input_rate;
1614         const struct clk_pll_freq_table *sel;
1615         struct clk_pll_freq_table cfg;
1616
1617         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
1618
1619         if (c->flags & PLL_FIXED) {
1620                 int ret = 0;
1621                 if (rate != c->u.pll.fixed_rate) {
1622                         pr_err("%s: Can not change %s fixed rate %lu to %lu\n",
1623                                __func__, c->name, c->u.pll.fixed_rate, rate);
1624                         ret = -EINVAL;
1625                 }
1626                 return ret;
1627         }
1628
1629         if ((c->flags & PLLM) && (c->state == ON)) {
1630                 if (rate != clk_get_rate_locked(c)) {
1631                         pr_err("%s: Can not change memory %s rate in flight\n",
1632                                __func__, c->name);
1633                         return -EINVAL;
1634                 }
1635                 return 0;
1636         }
1637
1638         p_div = 0;
1639         input_rate = clk_get_rate(c->parent);
1640
1641         /* Check if the target rate is tabulated */
1642         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
1643                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
1644                         if (c->flags & PLLU) {
1645                                 BUG_ON(sel->p < 1 || sel->p > 2);
1646                                 if (sel->p == 1)
1647                                         p_div = PLLU_BASE_POST_DIV;
1648                         } else {
1649                                 BUG_ON(sel->p < 1);
1650                                 for (val = sel->p; val > 1; val >>= 1, p_div++);
1651                                 p_div <<= PLL_BASE_DIVP_SHIFT;
1652                         }
1653                         break;
1654                 }
1655         }
1656
1657         /* Configure out-of-table rate */
1658         if (sel->input_rate == 0) {
1659                 unsigned long cfreq;
1660                 BUG_ON(c->flags & PLLU);
1661                 sel = &cfg;
1662
1663                 switch (input_rate) {
1664                 case 12000000:
1665                 case 26000000:
1666                         cfreq = (rate <= 1000000 * 1000) ? 1000000 : 2000000;
1667                         break;
1668                 case 13000000:
1669                         cfreq = (rate <= 1000000 * 1000) ? 1000000 : 2600000;
1670                         break;
1671                 case 16800000:
1672                 case 19200000:
1673                         cfreq = (rate <= 1200000 * 1000) ? 1200000 : 2400000;
1674                         break;
1675                 default:
1676                         if (c->parent->flags & DIV_U71_FIXED) {
1677                                 /* PLLP_OUT1 rate is not in PLLA table */
1678                                 pr_warn("%s: failed %s ref/out rates %lu/%lu\n",
1679                                         __func__, c->name, input_rate, rate);
1680                                 cfreq = input_rate/(input_rate/1000000);
1681                                 break;
1682                         }
1683                         pr_err("%s: Unexpected reference rate %lu\n",
1684                                __func__, input_rate);
1685                         BUG();
1686                 }
1687
1688                 /* Raise VCO to guarantee 0.5% accuracy */
1689                 for (cfg.output_rate = rate; cfg.output_rate < 200 * cfreq;
1690                       cfg.output_rate <<= 1, p_div++);
1691
1692                 cfg.p = 0x1 << p_div;
1693                 cfg.m = input_rate / cfreq;
1694                 cfg.n = cfg.output_rate / cfreq;
1695                 cfg.cpcon = OUT_OF_TABLE_CPCON;
1696
1697                 if ((cfg.m > (PLL_BASE_DIVM_MASK >> PLL_BASE_DIVM_SHIFT)) ||
1698                     (cfg.n > (PLL_BASE_DIVN_MASK >> PLL_BASE_DIVN_SHIFT)) ||
1699                     (p_div > (PLL_BASE_DIVP_MASK >> PLL_BASE_DIVP_SHIFT)) ||
1700                     (cfg.output_rate > c->u.pll.vco_max)) {
1701                         pr_err("%s: Failed to set %s out-of-table rate %lu\n",
1702                                __func__, c->name, rate);
1703                         return -EINVAL;
1704                 }
1705                 p_div <<= PLL_BASE_DIVP_SHIFT;
1706         }
1707
1708         c->mul = sel->n;
1709         c->div = sel->m * sel->p;
1710
1711         if (c->flags & PLLM) {
1712                 val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
1713                 if (val & PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE)
1714                         return tegra3_pllm_override_rate(
1715                                 c, sel, p_div >> PLL_BASE_DIVP_SHIFT);
1716         }
1717
1718         old_base = val = clk_readl(c->reg + PLL_BASE);
1719         val &= ~(PLL_BASE_DIVM_MASK | PLL_BASE_DIVN_MASK |
1720                  ((c->flags & PLLU) ? PLLU_BASE_POST_DIV : PLL_BASE_DIVP_MASK));
1721         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
1722                 (sel->n << PLL_BASE_DIVN_SHIFT) | p_div;
1723         if (val == old_base)
1724                 return 0;
1725
1726         if (c->state == ON) {
1727                 tegra3_pll_clk_disable(c);
1728                 val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
1729         }
1730         clk_writel(val, c->reg + PLL_BASE);
1731
1732         if (c->flags & PLL_HAS_CPCON) {
1733                 val = clk_readl(c->reg + PLL_MISC(c));
1734                 val &= ~PLL_MISC_CPCON_MASK;
1735                 val |= sel->cpcon << PLL_MISC_CPCON_SHIFT;
1736                 if (c->flags & (PLLU | PLLD)) {
1737                         val &= ~PLL_MISC_LFCON_MASK;
1738                         if (sel->n >= PLLDU_LFCON_SET_DIVN)
1739                                 val |= 0x1 << PLL_MISC_LFCON_SHIFT;
1740                 } else if (c->flags & (PLLX | PLLM)) {
1741                         val &= ~(0x1 << PLL_MISC_DCCON_SHIFT);
1742                         if (rate >= (c->u.pll.vco_max >> 1))
1743                                 val |= 0x1 << PLL_MISC_DCCON_SHIFT;
1744                 }
1745                 clk_writel(val, c->reg + PLL_MISC(c));
1746         }
1747
1748         if (c->state == ON)
1749                 tegra3_pll_clk_enable(c);
1750
1751         return 0;
1752 }
1753
1754 static struct clk_ops tegra_pll_ops = {
1755         .init                   = tegra3_pll_clk_init,
1756         .enable                 = tegra3_pll_clk_enable,
1757         .disable                = tegra3_pll_clk_disable,
1758         .set_rate               = tegra3_pll_clk_set_rate,
1759 };
1760
1761 static void tegra3_pllp_clk_init(struct clk *c)
1762 {
1763         tegra3_pll_clk_init(c);
1764         tegra3_pllp_init_dependencies(c->u.pll.fixed_rate);
1765 }
1766
1767 #if defined(CONFIG_PM_SLEEP)
1768 static void tegra3_pllp_clk_resume(struct clk *c)
1769 {
1770         unsigned long rate = c->u.pll.fixed_rate;
1771         tegra3_pll_clk_init(c);
1772         BUG_ON(rate != c->u.pll.fixed_rate);
1773 }
1774 #endif
1775
1776 static struct clk_ops tegra_pllp_ops = {
1777         .init                   = tegra3_pllp_clk_init,
1778         .enable                 = tegra3_pll_clk_enable,
1779         .disable                = tegra3_pll_clk_disable,
1780         .set_rate               = tegra3_pll_clk_set_rate,
1781 };
1782
1783 static int
1784 tegra3_plld_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
1785 {
1786         u32 val, mask, reg;
1787
1788         switch (p) {
1789         case TEGRA_CLK_PLLD_CSI_OUT_ENB:
1790                 mask = PLLD_BASE_CSI_CLKENABLE;
1791                 reg = c->reg + PLL_BASE;
1792                 break;
1793         case TEGRA_CLK_PLLD_DSI_OUT_ENB:
1794                 mask = PLLD_MISC_DSI_CLKENABLE;
1795                 reg = c->reg + PLL_MISC(c);
1796                 break;
1797         case TEGRA_CLK_PLLD_MIPI_MUX_SEL:
1798                 if (!(c->flags & PLL_ALT_MISC_REG)) {
1799                         mask = PLLD_BASE_DSIB_MUX_MASK;
1800                         reg = c->reg + PLL_BASE;
1801                         break;
1802                 }
1803         /* fall through - error since PLLD2 does not have MUX_SEL control */
1804         default:
1805                 return -EINVAL;
1806         }
1807
1808         val = clk_readl(reg);
1809         if (setting)
1810                 val |= mask;
1811         else
1812                 val &= ~mask;
1813         clk_writel(val, reg);
1814         return 0;
1815 }
1816
1817 static struct clk_ops tegra_plld_ops = {
1818         .init                   = tegra3_pll_clk_init,
1819         .enable                 = tegra3_pll_clk_enable,
1820         .disable                = tegra3_pll_clk_disable,
1821         .set_rate               = tegra3_pll_clk_set_rate,
1822         .clk_cfg_ex             = tegra3_plld_clk_cfg_ex,
1823 };
1824
1825 static void tegra3_plle_clk_init(struct clk *c)
1826 {
1827         u32 val;
1828
1829         val = clk_readl(PLLE_AUX);
1830         c->parent = (val & PLLE_AUX_PLLP_SEL) ?
1831                 tegra_get_clock_by_name("pll_p") :
1832                 tegra_get_clock_by_name("pll_ref");
1833
1834         val = clk_readl(c->reg + PLL_BASE);
1835         c->state = (val & PLLE_BASE_ENABLE) ? ON : OFF;
1836         c->mul = (val & PLLE_BASE_DIVN_MASK) >> PLLE_BASE_DIVN_SHIFT;
1837         c->div = (val & PLLE_BASE_DIVM_MASK) >> PLLE_BASE_DIVM_SHIFT;
1838         c->div *= (val & PLLE_BASE_DIVP_MASK) >> PLLE_BASE_DIVP_SHIFT;
1839 }
1840
1841 static void tegra3_plle_clk_disable(struct clk *c)
1842 {
1843         u32 val;
1844         pr_debug("%s on clock %s\n", __func__, c->name);
1845
1846         val = clk_readl(c->reg + PLL_BASE);
1847         val &= ~(PLLE_BASE_CML_ENABLE | PLLE_BASE_ENABLE);
1848         clk_writel(val, c->reg + PLL_BASE);
1849 }
1850
1851 static void tegra3_plle_training(struct clk *c)
1852 {
1853         u32 val;
1854
1855         /* PLLE is already disabled, and setup cleared;
1856          * create falling edge on PLLE IDDQ input */
1857         val = pmc_readl(PMC_SATA_PWRGT);
1858         val |= PMC_SATA_PWRGT_PLLE_IDDQ_VALUE;
1859         pmc_writel(val, PMC_SATA_PWRGT);
1860
1861         val = pmc_readl(PMC_SATA_PWRGT);
1862         val |= PMC_SATA_PWRGT_PLLE_IDDQ_SWCTL;
1863         pmc_writel(val, PMC_SATA_PWRGT);
1864
1865         val = pmc_readl(PMC_SATA_PWRGT);
1866         val &= ~PMC_SATA_PWRGT_PLLE_IDDQ_VALUE;
1867         pmc_writel(val, PMC_SATA_PWRGT);
1868
1869         do {
1870                 val = clk_readl(c->reg + PLL_MISC(c));
1871         } while (!(val & PLLE_MISC_READY));
1872 }
1873
1874 static int tegra3_plle_configure(struct clk *c, bool force_training)
1875 {
1876         u32 val;
1877         const struct clk_pll_freq_table *sel;
1878         unsigned long rate = c->u.pll.fixed_rate;
1879         unsigned long input_rate = clk_get_rate(c->parent);
1880
1881         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
1882                 if (sel->input_rate == input_rate && sel->output_rate == rate)
1883                         break;
1884         }
1885
1886         if (sel->input_rate == 0)
1887                 return -ENOSYS;
1888
1889         /* disable PLLE, clear setup fiels */
1890         tegra3_plle_clk_disable(c);
1891
1892         val = clk_readl(c->reg + PLL_MISC(c));
1893         val &= ~(PLLE_MISC_LOCK_ENABLE | PLLE_MISC_SETUP_MASK);
1894         clk_writel(val, c->reg + PLL_MISC(c));
1895
1896         /* training */
1897         val = clk_readl(c->reg + PLL_MISC(c));
1898         if (force_training || (!(val & PLLE_MISC_READY)))
1899                 tegra3_plle_training(c);
1900
1901         /* configure dividers, setup, disable SS */
1902         val = clk_readl(c->reg + PLL_BASE);
1903         val &= ~PLLE_BASE_DIV_MASK;
1904         val |= PLLE_BASE_DIV(sel->m, sel->n, sel->p, sel->cpcon);
1905         clk_writel(val, c->reg + PLL_BASE);
1906         c->mul = sel->n;
1907         c->div = sel->m * sel->p;
1908
1909         val = clk_readl(c->reg + PLL_MISC(c));
1910         val |= PLLE_MISC_SETUP_VALUE;
1911         val |= PLLE_MISC_LOCK_ENABLE;
1912         clk_writel(val, c->reg + PLL_MISC(c));
1913
1914         val = clk_readl(PLLE_SS_CTRL);
1915         val |= PLLE_SS_DISABLE;
1916         clk_writel(val, PLLE_SS_CTRL);
1917
1918         /* enable and lock PLLE*/
1919         val = clk_readl(c->reg + PLL_BASE);
1920         val |= (PLLE_BASE_CML_ENABLE | PLLE_BASE_ENABLE);
1921         clk_writel(val, c->reg + PLL_BASE);
1922
1923         tegra3_pll_clk_wait_for_lock(c, c->reg + PLL_MISC(c), PLLE_MISC_LOCK);
1924
1925 #if USE_PLLE_SS
1926         /* configure spread spectrum coefficients */
1927         /* FIXME: coefficients for 216MHZ input? */
1928 #ifdef CONFIG_TEGRA_SILICON_PLATFORM
1929         if (input_rate == 12000000)
1930 #endif
1931         {
1932                 val = clk_readl(PLLE_SS_CTRL);
1933                 val &= ~(PLLE_SS_COEFFICIENTS_MASK | PLLE_SS_DISABLE);
1934                 val |= PLLE_SS_COEFFICIENTS_12MHZ;
1935                 clk_writel(val, PLLE_SS_CTRL);
1936         }
1937 #endif
1938         return 0;
1939 }
1940
1941 static int tegra3_plle_clk_enable(struct clk *c)
1942 {
1943         pr_debug("%s on clock %s\n", __func__, c->name);
1944         return tegra3_plle_configure(c, !c->set);
1945 }
1946
1947 static struct clk_ops tegra_plle_ops = {
1948         .init                   = tegra3_plle_clk_init,
1949         .enable                 = tegra3_plle_clk_enable,
1950         .disable                = tegra3_plle_clk_disable,
1951 };
1952
1953 /* Clock divider ops (non-atomic shared register access) */
1954 static DEFINE_SPINLOCK(pll_div_lock);
1955
1956 static int tegra3_pll_div_clk_set_rate(struct clk *c, unsigned long rate);
1957 static void tegra3_pll_div_clk_init(struct clk *c)
1958 {
1959         if (c->flags & DIV_U71) {
1960                 u32 divu71;
1961                 u32 val = clk_readl(c->reg);
1962                 val >>= c->reg_shift;
1963                 c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
1964                 if (!(val & PLL_OUT_RESET_DISABLE))
1965                         c->state = OFF;
1966
1967                 if (c->u.pll_div.default_rate) {
1968                         int ret = tegra3_pll_div_clk_set_rate(
1969                                         c, c->u.pll_div.default_rate);
1970                         if (!ret)
1971                                 return;
1972                 }
1973                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
1974                 c->div = (divu71 + 2);
1975                 c->mul = 2;
1976         } else if (c->flags & DIV_2) {
1977                 c->state = ON;
1978                 if (c->flags & (PLLD | PLLX)) {
1979                         c->div = 2;
1980                         c->mul = 1;
1981                 }
1982                 else
1983                         BUG();
1984         } else {
1985                 c->state = ON;
1986                 c->div = 1;
1987                 c->mul = 1;
1988         }
1989 }
1990
1991 static int tegra3_pll_div_clk_enable(struct clk *c)
1992 {
1993         u32 val;
1994         u32 new_val;
1995         unsigned long flags;
1996
1997         pr_debug("%s: %s\n", __func__, c->name);
1998         if (c->flags & DIV_U71) {
1999                 spin_lock_irqsave(&pll_div_lock, flags);
2000                 val = clk_readl(c->reg);
2001                 new_val = val >> c->reg_shift;
2002                 new_val &= 0xFFFF;
2003
2004                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
2005
2006                 val &= ~(0xFFFF << c->reg_shift);
2007                 val |= new_val << c->reg_shift;
2008                 clk_writel_delay(val, c->reg);
2009                 spin_unlock_irqrestore(&pll_div_lock, flags);
2010                 return 0;
2011         } else if (c->flags & DIV_2) {
2012                 return 0;
2013         }
2014         return -EINVAL;
2015 }
2016
2017 static void tegra3_pll_div_clk_disable(struct clk *c)
2018 {
2019         u32 val;
2020         u32 new_val;
2021         unsigned long flags;
2022
2023         pr_debug("%s: %s\n", __func__, c->name);
2024         if (c->flags & DIV_U71) {
2025                 spin_lock_irqsave(&pll_div_lock, flags);
2026                 val = clk_readl(c->reg);
2027                 new_val = val >> c->reg_shift;
2028                 new_val &= 0xFFFF;
2029
2030                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
2031
2032                 val &= ~(0xFFFF << c->reg_shift);
2033                 val |= new_val << c->reg_shift;
2034                 clk_writel_delay(val, c->reg);
2035                 spin_unlock_irqrestore(&pll_div_lock, flags);
2036         }
2037 }
2038
2039 static int tegra3_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
2040 {
2041         u32 val;
2042         u32 new_val;
2043         int divider_u71;
2044         unsigned long parent_rate = clk_get_rate(c->parent);
2045         unsigned long flags;
2046
2047         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
2048         if (c->flags & DIV_U71) {
2049                 divider_u71 = clk_div71_get_divider(
2050                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
2051                 if (divider_u71 >= 0) {
2052                         spin_lock_irqsave(&pll_div_lock, flags);
2053                         val = clk_readl(c->reg);
2054                         new_val = val >> c->reg_shift;
2055                         new_val &= 0xFFFF;
2056                         if (c->flags & DIV_U71_FIXED)
2057                                 new_val |= PLL_OUT_OVERRIDE;
2058                         new_val &= ~PLL_OUT_RATIO_MASK;
2059                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
2060
2061                         val &= ~(0xFFFF << c->reg_shift);
2062                         val |= new_val << c->reg_shift;
2063                         clk_writel_delay(val, c->reg);
2064                         c->div = divider_u71 + 2;
2065                         c->mul = 2;
2066                         spin_unlock_irqrestore(&pll_div_lock, flags);
2067                         return 0;
2068                 }
2069         } else if (c->flags & DIV_2)
2070                 return clk_set_rate(c->parent, rate * 2);
2071
2072         return -EINVAL;
2073 }
2074
2075 static long tegra3_pll_div_clk_round_rate(struct clk *c, unsigned long rate)
2076 {
2077         int divider;
2078         unsigned long parent_rate = clk_get_rate(c->parent);
2079         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
2080
2081         if (c->flags & DIV_U71) {
2082                 divider = clk_div71_get_divider(
2083                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
2084                 if (divider < 0)
2085                         return divider;
2086                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
2087         } else if (c->flags & DIV_2)
2088                 /* no rounding - fixed DIV_2 dividers pass rate to parent PLL */
2089                 return rate;
2090
2091         return -EINVAL;
2092 }
2093
2094 static struct clk_ops tegra_pll_div_ops = {
2095         .init                   = tegra3_pll_div_clk_init,
2096         .enable                 = tegra3_pll_div_clk_enable,
2097         .disable                = tegra3_pll_div_clk_disable,
2098         .set_rate               = tegra3_pll_div_clk_set_rate,
2099         .round_rate             = tegra3_pll_div_clk_round_rate,
2100 };
2101
2102 /* Periph clk ops */
2103 static inline u32 periph_clk_source_mask(struct clk *c)
2104 {
2105         if (c->flags & MUX8)
2106                  return 7 << 29;
2107         else if (c->flags & MUX_PWM)
2108                 return 3 << 28;
2109         else if (c->flags & MUX_CLK_OUT)
2110                 return 3 << (c->u.periph.clk_num + 4);
2111         else if (c->flags & PLLD)
2112                 return PLLD_BASE_DSIB_MUX_MASK;
2113         else
2114                 return 3 << 30;
2115 }
2116
2117 static inline u32 periph_clk_source_shift(struct clk *c)
2118 {
2119         if (c->flags & MUX8)
2120                  return 29;
2121         else if (c->flags & MUX_PWM)
2122                 return 28;
2123         else if (c->flags & MUX_CLK_OUT)
2124                 return c->u.periph.clk_num + 4;
2125         else if (c->flags & PLLD)
2126                 return PLLD_BASE_DSIB_MUX_SHIFT;
2127         else
2128                 return 30;
2129 }
2130
2131 static void tegra3_periph_clk_init(struct clk *c)
2132 {
2133         u32 val = clk_readl(c->reg);
2134         const struct clk_mux_sel *mux = 0;
2135         const struct clk_mux_sel *sel;
2136         if (c->flags & MUX) {
2137                 for (sel = c->inputs; sel->input != NULL; sel++) {
2138                         if (((val & periph_clk_source_mask(c)) >>
2139                             periph_clk_source_shift(c)) == sel->value)
2140                                 mux = sel;
2141                 }
2142                 BUG_ON(!mux);
2143
2144                 c->parent = mux->input;
2145         } else {
2146                 c->parent = c->inputs[0].input;
2147         }
2148
2149         if (c->flags & DIV_U71) {
2150                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
2151                 if (c->flags & DIV_U71_IDLE) {
2152                         val &= ~(PERIPH_CLK_SOURCE_DIVU71_MASK <<
2153                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
2154                         val |= (PERIPH_CLK_SOURCE_DIVIDLE_VAL <<
2155                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
2156                         clk_writel(val, c->reg);
2157                 }
2158                 c->div = divu71 + 2;
2159                 c->mul = 2;
2160         } else if (c->flags & DIV_U151) {
2161                 u32 divu151 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
2162                 if ((c->flags & DIV_U151_UART) &&
2163                     (!(val & PERIPH_CLK_UART_DIV_ENB))) {
2164                         divu151 = 0;
2165                 }
2166                 c->div = divu151 + 2;
2167                 c->mul = 2;
2168         } else if (c->flags & DIV_U16) {
2169                 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
2170                 c->div = divu16 + 1;
2171                 c->mul = 1;
2172         } else {
2173                 c->div = 1;
2174                 c->mul = 1;
2175         }
2176
2177         c->state = ON;
2178
2179         if (c->flags & PERIPH_NO_ENB)
2180                 return;
2181
2182         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
2183                 c->state = OFF;
2184         if (!(c->flags & PERIPH_NO_RESET))
2185                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c))
2186                         c->state = OFF;
2187 }
2188
2189 static int tegra3_periph_clk_enable(struct clk *c)
2190 {
2191         unsigned long flags;
2192         pr_debug("%s on clock %s\n", __func__, c->name);
2193
2194         if (c->flags & PERIPH_NO_ENB)
2195                 return 0;
2196
2197         spin_lock_irqsave(&periph_refcount_lock, flags);
2198
2199         tegra_periph_clk_enable_refcount[c->u.periph.clk_num]++;
2200         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] > 1) {
2201                 spin_unlock_irqrestore(&periph_refcount_lock, flags);
2202                 return 0;
2203         }
2204
2205         clk_writel_delay(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_SET_REG(c));
2206         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET)) {
2207                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c)) {
2208                         udelay(5);      /* reset propagation delay */
2209                         clk_writel(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_RST_CLR_REG(c));
2210                 }
2211         }
2212         spin_unlock_irqrestore(&periph_refcount_lock, flags);
2213         return 0;
2214 }
2215
2216 static void tegra3_periph_clk_disable(struct clk *c)
2217 {
2218         unsigned long val, flags;
2219         pr_debug("%s on clock %s\n", __func__, c->name);
2220
2221         if (c->flags & PERIPH_NO_ENB)
2222                 return;
2223
2224         spin_lock_irqsave(&periph_refcount_lock, flags);
2225
2226         if (c->refcnt)
2227                 tegra_periph_clk_enable_refcount[c->u.periph.clk_num]--;
2228
2229         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] == 0) {
2230                 /* If peripheral is in the APB bus then read the APB bus to
2231                  * flush the write operation in apb bus. This will avoid the
2232                  * peripheral access after disabling clock*/
2233                 if (c->flags & PERIPH_ON_APB)
2234                         val = chipid_readl();
2235
2236                 clk_writel_delay(
2237                         PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_CLR_REG(c));
2238         }
2239         spin_unlock_irqrestore(&periph_refcount_lock, flags);
2240 }
2241
2242 static void tegra3_periph_clk_reset(struct clk *c, bool assert)
2243 {
2244         unsigned long val;
2245         pr_debug("%s %s on clock %s\n", __func__,
2246                  assert ? "assert" : "deassert", c->name);
2247
2248         if (c->flags & PERIPH_NO_ENB)
2249                 return;
2250
2251         if (!(c->flags & PERIPH_NO_RESET)) {
2252                 if (assert) {
2253                         /* If peripheral is in the APB bus then read the APB
2254                          * bus to flush the write operation in apb bus. This
2255                          * will avoid the peripheral access after disabling
2256                          * clock */
2257                         if (c->flags & PERIPH_ON_APB)
2258                                 val = chipid_readl();
2259
2260                         clk_writel(PERIPH_CLK_TO_BIT(c),
2261                                    PERIPH_CLK_TO_RST_SET_REG(c));
2262                 } else
2263                         clk_writel(PERIPH_CLK_TO_BIT(c),
2264                                    PERIPH_CLK_TO_RST_CLR_REG(c));
2265         }
2266 }
2267
2268 static int tegra3_periph_clk_set_parent(struct clk *c, struct clk *p)
2269 {
2270         u32 val;
2271         const struct clk_mux_sel *sel;
2272         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
2273
2274         if (!(c->flags & MUX))
2275                 return (p == c->parent) ? 0 : (-EINVAL);
2276
2277         for (sel = c->inputs; sel->input != NULL; sel++) {
2278                 if (sel->input == p) {
2279                         val = clk_readl(c->reg);
2280                         val &= ~periph_clk_source_mask(c);
2281                         val |= (sel->value << periph_clk_source_shift(c));
2282
2283                         if (c->refcnt)
2284                                 clk_enable(p);
2285
2286                         clk_writel_delay(val, c->reg);
2287
2288                         if (c->refcnt && c->parent)
2289                                 clk_disable(c->parent);
2290
2291                         clk_reparent(c, p);
2292                         return 0;
2293                 }
2294         }
2295
2296         return -EINVAL;
2297 }
2298
2299 static int tegra3_periph_clk_set_rate(struct clk *c, unsigned long rate)
2300 {
2301         u32 val;
2302         int divider;
2303         unsigned long parent_rate = clk_get_rate(c->parent);
2304
2305         if (c->flags & DIV_U71) {
2306                 divider = clk_div71_get_divider(
2307                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
2308                 if (divider >= 0) {
2309                         val = clk_readl(c->reg);
2310                         val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
2311                         val |= divider;
2312                         clk_writel_delay(val, c->reg);
2313                         c->div = divider + 2;
2314                         c->mul = 2;
2315                         return 0;
2316                 }
2317         } else if (c->flags & DIV_U151) {
2318                 divider = clk_div151_get_divider(
2319                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
2320                 if (divider >= 0) {
2321                         val = clk_readl(c->reg);
2322                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
2323                         val |= divider;
2324                         if (c->flags & DIV_U151_UART) {
2325                                 if (divider)
2326                                         val |= PERIPH_CLK_UART_DIV_ENB;
2327                                 else
2328                                         val &= ~PERIPH_CLK_UART_DIV_ENB;
2329                         }
2330                         clk_writel_delay(val, c->reg);
2331                         c->div = divider + 2;
2332                         c->mul = 2;
2333                         return 0;
2334                 }
2335         } else if (c->flags & DIV_U16) {
2336                 divider = clk_div16_get_divider(parent_rate, rate);
2337                 if (divider >= 0) {
2338                         val = clk_readl(c->reg);
2339                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
2340                         val |= divider;
2341                         clk_writel_delay(val, c->reg);
2342                         c->div = divider + 1;
2343                         c->mul = 1;
2344                         return 0;
2345                 }
2346         } else if (parent_rate <= rate) {
2347                 c->div = 1;
2348                 c->mul = 1;
2349                 return 0;
2350         }
2351         return -EINVAL;
2352 }
2353
2354 static long tegra3_periph_clk_round_rate(struct clk *c,
2355         unsigned long rate)
2356 {
2357         int divider;
2358         unsigned long parent_rate = clk_get_rate(c->parent);
2359         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
2360
2361         if (c->flags & DIV_U71) {
2362                 divider = clk_div71_get_divider(
2363                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
2364                 if (divider < 0)
2365                         return divider;
2366
2367                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
2368         } else if (c->flags & DIV_U151) {
2369                 divider = clk_div151_get_divider(
2370                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
2371                 if (divider < 0)
2372                         return divider;
2373
2374                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
2375         } else if (c->flags & DIV_U16) {
2376                 divider = clk_div16_get_divider(parent_rate, rate);
2377                 if (divider < 0)
2378                         return divider;
2379                 return DIV_ROUND_UP(parent_rate, divider + 1);
2380         }
2381         return -EINVAL;
2382 }
2383
2384 static struct clk_ops tegra_periph_clk_ops = {
2385         .init                   = &tegra3_periph_clk_init,
2386         .enable                 = &tegra3_periph_clk_enable,
2387         .disable                = &tegra3_periph_clk_disable,
2388         .set_parent             = &tegra3_periph_clk_set_parent,
2389         .set_rate               = &tegra3_periph_clk_set_rate,
2390         .round_rate             = &tegra3_periph_clk_round_rate,
2391         .reset                  = &tegra3_periph_clk_reset,
2392 };
2393
2394
2395 /* Periph extended clock configuration ops */
2396 static int
2397 tegra3_vi_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
2398 {
2399         if (p == TEGRA_CLK_VI_INP_SEL) {
2400                 u32 val = clk_readl(c->reg);
2401                 val &= ~PERIPH_CLK_VI_SEL_EX_MASK;
2402                 val |= (setting << PERIPH_CLK_VI_SEL_EX_SHIFT) &
2403                         PERIPH_CLK_VI_SEL_EX_MASK;
2404                 clk_writel(val, c->reg);
2405                 return 0;
2406         }
2407         return -EINVAL;
2408 }
2409
2410 static struct clk_ops tegra_vi_clk_ops = {
2411         .init                   = &tegra3_periph_clk_init,
2412         .enable                 = &tegra3_periph_clk_enable,
2413         .disable                = &tegra3_periph_clk_disable,
2414         .set_parent             = &tegra3_periph_clk_set_parent,
2415         .set_rate               = &tegra3_periph_clk_set_rate,
2416         .round_rate             = &tegra3_periph_clk_round_rate,
2417         .clk_cfg_ex             = &tegra3_vi_clk_cfg_ex,
2418         .reset                  = &tegra3_periph_clk_reset,
2419 };
2420
2421 static int
2422 tegra3_nand_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
2423 {
2424         if (p == TEGRA_CLK_NAND_PAD_DIV2_ENB) {
2425                 u32 val = clk_readl(c->reg);
2426                 if (setting)
2427                         val |= PERIPH_CLK_NAND_DIV_EX_ENB;
2428                 else
2429                         val &= ~PERIPH_CLK_NAND_DIV_EX_ENB;
2430                 clk_writel(val, c->reg);
2431                 return 0;
2432         }
2433         return -EINVAL;
2434 }
2435
2436 static struct clk_ops tegra_nand_clk_ops = {
2437         .init                   = &tegra3_periph_clk_init,
2438         .enable                 = &tegra3_periph_clk_enable,
2439         .disable                = &tegra3_periph_clk_disable,
2440         .set_parent             = &tegra3_periph_clk_set_parent,
2441         .set_rate               = &tegra3_periph_clk_set_rate,
2442         .round_rate             = &tegra3_periph_clk_round_rate,
2443         .clk_cfg_ex             = &tegra3_nand_clk_cfg_ex,
2444         .reset                  = &tegra3_periph_clk_reset,
2445 };
2446
2447
2448 static int
2449 tegra3_dtv_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
2450 {
2451         if (p == TEGRA_CLK_DTV_INVERT) {
2452                 u32 val = clk_readl(c->reg);
2453                 if (setting)
2454                         val |= PERIPH_CLK_DTV_POLARITY_INV;
2455                 else
2456                         val &= ~PERIPH_CLK_DTV_POLARITY_INV;
2457                 clk_writel(val, c->reg);
2458                 return 0;
2459         }
2460         return -EINVAL;
2461 }
2462
2463 static struct clk_ops tegra_dtv_clk_ops = {
2464         .init                   = &tegra3_periph_clk_init,
2465         .enable                 = &tegra3_periph_clk_enable,
2466         .disable                = &tegra3_periph_clk_disable,
2467         .set_parent             = &tegra3_periph_clk_set_parent,
2468         .set_rate               = &tegra3_periph_clk_set_rate,
2469         .round_rate             = &tegra3_periph_clk_round_rate,
2470         .clk_cfg_ex             = &tegra3_dtv_clk_cfg_ex,
2471         .reset                  = &tegra3_periph_clk_reset,
2472 };
2473
2474 static int tegra3_dsib_clk_set_parent(struct clk *c, struct clk *p)
2475 {
2476         const struct clk_mux_sel *sel;
2477         struct clk *d = tegra_get_clock_by_name("pll_d");
2478
2479         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
2480
2481         for (sel = c->inputs; sel->input != NULL; sel++) {
2482                 if (sel->input == p) {
2483                         if (c->refcnt)
2484                                 clk_enable(p);
2485
2486                         /* The DSIB parent selection bit is in PLLD base
2487                            register - can not do direct r-m-w, must be
2488                            protected by PLLD lock */
2489                         tegra_clk_cfg_ex(
2490                                 d, TEGRA_CLK_PLLD_MIPI_MUX_SEL, sel->value);
2491
2492                         if (c->refcnt && c->parent)
2493                                 clk_disable(c->parent);
2494
2495                         clk_reparent(c, p);
2496                         return 0;
2497                 }
2498         }
2499
2500         return -EINVAL;
2501 }
2502
2503 static struct clk_ops tegra_dsib_clk_ops = {
2504         .init                   = &tegra3_periph_clk_init,
2505         .enable                 = &tegra3_periph_clk_enable,
2506         .disable                = &tegra3_periph_clk_disable,
2507         .set_parent             = &tegra3_dsib_clk_set_parent,
2508         .set_rate               = &tegra3_periph_clk_set_rate,
2509         .round_rate             = &tegra3_periph_clk_round_rate,
2510         .reset                  = &tegra3_periph_clk_reset,
2511 };
2512
2513 /* pciex clock support only reset function */
2514 static struct clk_ops tegra_pciex_clk_ops = {
2515         .reset    = tegra3_periph_clk_reset,
2516 };
2517
2518 /* Output clock ops (non-atomic shared register access) */
2519
2520 static DEFINE_SPINLOCK(clk_out_lock);
2521
2522 static void tegra3_clk_out_init(struct clk *c)
2523 {
2524         const struct clk_mux_sel *mux = 0;
2525         const struct clk_mux_sel *sel;
2526         u32 val = pmc_readl(c->reg);
2527
2528         c->state = (val & (0x1 << c->u.periph.clk_num)) ? ON : OFF;
2529         c->mul = 1;
2530         c->div = 1;
2531
2532         for (sel = c->inputs; sel->input != NULL; sel++) {
2533                 if (((val & periph_clk_source_mask(c)) >>
2534                      periph_clk_source_shift(c)) == sel->value)
2535                         mux = sel;
2536         }
2537         BUG_ON(!mux);
2538         c->parent = mux->input;
2539 }
2540
2541 static int tegra3_clk_out_enable(struct clk *c)
2542 {
2543         u32 val;
2544         unsigned long flags;
2545
2546         pr_debug("%s on clock %s\n", __func__, c->name);
2547
2548         spin_lock_irqsave(&clk_out_lock, flags);
2549         val = pmc_readl(c->reg);
2550         val |= (0x1 << c->u.periph.clk_num);
2551         pmc_writel(val, c->reg);
2552         spin_unlock_irqrestore(&clk_out_lock, flags);
2553
2554         return 0;
2555 }
2556
2557 static void tegra3_clk_out_disable(struct clk *c)
2558 {
2559         u32 val;
2560         unsigned long flags;
2561
2562         pr_debug("%s on clock %s\n", __func__, c->name);
2563
2564         spin_lock_irqsave(&clk_out_lock, flags);
2565         val = pmc_readl(c->reg);
2566         val &= ~(0x1 << c->u.periph.clk_num);
2567         pmc_writel(val, c->reg);
2568         spin_unlock_irqrestore(&clk_out_lock, flags);
2569 }
2570
2571 static int tegra3_clk_out_set_parent(struct clk *c, struct clk *p)
2572 {
2573         u32 val;
2574         unsigned long flags;
2575         const struct clk_mux_sel *sel;
2576
2577         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
2578
2579         for (sel = c->inputs; sel->input != NULL; sel++) {
2580                 if (sel->input == p) {
2581                         if (c->refcnt)
2582                                 clk_enable(p);
2583
2584                         spin_lock_irqsave(&clk_out_lock, flags);
2585                         val = pmc_readl(c->reg);
2586                         val &= ~periph_clk_source_mask(c);
2587                         val |= (sel->value << periph_clk_source_shift(c));
2588                         pmc_writel(val, c->reg);
2589                         spin_unlock_irqrestore(&clk_out_lock, flags);
2590
2591                         if (c->refcnt && c->parent)
2592                                 clk_disable(c->parent);
2593
2594                         clk_reparent(c, p);
2595                         return 0;
2596                 }
2597         }
2598         return -EINVAL;
2599 }
2600
2601 static struct clk_ops tegra_clk_out_ops = {
2602         .init                   = &tegra3_clk_out_init,
2603         .enable                 = &tegra3_clk_out_enable,
2604         .disable                = &tegra3_clk_out_disable,
2605         .set_parent             = &tegra3_clk_out_set_parent,
2606 };
2607
2608
2609 /* External memory controller clock ops */
2610 static void tegra3_emc_clk_init(struct clk *c)
2611 {
2612         tegra3_periph_clk_init(c);
2613         tegra_emc_dram_type_init(c);
2614
2615         /* On A01 limit EMC maximum rate to boot frequency;
2616            starting with A02 full PLLM range should be supported */
2617         if (tegra_get_revision() == TEGRA_REVISION_A01)
2618                 c->max_rate = clk_get_rate_locked(c);
2619         else
2620                 c->max_rate = clk_get_rate(c->parent);
2621 }
2622
2623 static long tegra3_emc_clk_round_rate(struct clk *c, unsigned long rate)
2624 {
2625         long new_rate = max(rate, c->min_rate);
2626
2627         new_rate = tegra_emc_round_rate(new_rate);
2628         if (new_rate < 0)
2629                 new_rate = c->max_rate;
2630
2631         return new_rate;
2632 }
2633
2634 static int tegra3_emc_clk_set_rate(struct clk *c, unsigned long rate)
2635 {
2636         int ret;
2637         u32 div_value;
2638         struct clk *p;
2639
2640         /* The tegra3 memory controller has an interlock with the clock
2641          * block that allows memory shadowed registers to be updated,
2642          * and then transfer them to the main registers at the same
2643          * time as the clock update without glitches. During clock change
2644          * operation both clock parent and divider may change simultaneously
2645          * to achieve requested rate. */
2646         p = tegra_emc_predict_parent(rate, &div_value);
2647         div_value += 2;         /* emc has fractional DIV_U71 divider */
2648
2649         /* No matching rate in emc dfs table */
2650         if (IS_ERR(p))
2651                 return PTR_ERR(p);
2652
2653         /* Table rate found, but need to relock source pll */
2654         if (!p)
2655                 return tegra3_emc_relock_set_rate(c, clk_get_rate_locked(c),
2656                                                   rate, rate * (div_value / 2));
2657
2658         if (p == c->parent) {
2659                 if (div_value == c->div)
2660                         return 0;
2661         } else if (c->refcnt)
2662                 clk_enable(p);
2663
2664         ret = tegra_emc_set_rate(rate);
2665         if (ret < 0)
2666                 return ret;
2667
2668         if (p != c->parent) {
2669                 if(c->refcnt && c->parent)
2670                         clk_disable(c->parent);
2671                 clk_reparent(c, p);
2672         }
2673         c->div = div_value;
2674         c->mul = 2;
2675         return 0;
2676 }
2677
2678 static struct clk_ops tegra_emc_clk_ops = {
2679         .init                   = &tegra3_emc_clk_init,
2680         .enable                 = &tegra3_periph_clk_enable,
2681         .disable                = &tegra3_periph_clk_disable,
2682         .set_rate               = &tegra3_emc_clk_set_rate,
2683         .round_rate             = &tegra3_emc_clk_round_rate,
2684         .reset                  = &tegra3_periph_clk_reset,
2685         .shared_bus_update      = &tegra3_clk_shared_bus_update,
2686 };
2687
2688 /* Clock doubler ops (non-atomic shared register access) */
2689 static DEFINE_SPINLOCK(doubler_lock);
2690
2691 static void tegra3_clk_double_init(struct clk *c)
2692 {
2693         u32 val = clk_readl(c->reg);
2694         c->mul = val & (0x1 << c->reg_shift) ? 1 : 2;
2695         c->div = 1;
2696         c->state = ON;
2697         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
2698                 c->state = OFF;
2699 };
2700
2701 static int tegra3_clk_double_set_rate(struct clk *c, unsigned long rate)
2702 {
2703         u32 val;
2704         unsigned long parent_rate = clk_get_rate(c->parent);
2705         unsigned long flags;
2706
2707         if (rate == parent_rate) {
2708                 spin_lock_irqsave(&doubler_lock, flags);
2709                 val = clk_readl(c->reg) | (0x1 << c->reg_shift);
2710                 clk_writel(val, c->reg);
2711                 c->mul = 1;
2712                 c->div = 1;
2713                 spin_unlock_irqrestore(&doubler_lock, flags);
2714                 return 0;
2715         } else if (rate == 2 * parent_rate) {
2716                 spin_lock_irqsave(&doubler_lock, flags);
2717                 val = clk_readl(c->reg) & (~(0x1 << c->reg_shift));
2718                 clk_writel(val, c->reg);
2719                 c->mul = 2;
2720                 c->div = 1;
2721                 spin_unlock_irqrestore(&doubler_lock, flags);
2722                 return 0;
2723         }
2724         return -EINVAL;
2725 }
2726
2727 static struct clk_ops tegra_clk_double_ops = {
2728         .init                   = &tegra3_clk_double_init,
2729         .enable                 = &tegra3_periph_clk_enable,
2730         .disable                = &tegra3_periph_clk_disable,
2731         .set_rate               = &tegra3_clk_double_set_rate,
2732 };
2733
2734 /* Audio sync clock ops */
2735 static int tegra3_sync_source_set_rate(struct clk *c, unsigned long rate)
2736 {
2737         c->rate = rate;
2738         return 0;
2739 }
2740
2741 static struct clk_ops tegra_sync_source_ops = {
2742         .set_rate               = &tegra3_sync_source_set_rate,
2743 };
2744
2745 static void tegra3_audio_sync_clk_init(struct clk *c)
2746 {
2747         int source;
2748         const struct clk_mux_sel *sel;
2749         u32 val = clk_readl(c->reg);
2750         c->state = (val & AUDIO_SYNC_DISABLE_BIT) ? OFF : ON;
2751         source = val & AUDIO_SYNC_SOURCE_MASK;
2752         for (sel = c->inputs; sel->input != NULL; sel++)
2753                 if (sel->value == source)
2754                         break;
2755         BUG_ON(sel->input == NULL);
2756         c->parent = sel->input;
2757 }
2758
2759 static int tegra3_audio_sync_clk_enable(struct clk *c)
2760 {
2761         u32 val = clk_readl(c->reg);
2762         clk_writel((val & (~AUDIO_SYNC_DISABLE_BIT)), c->reg);
2763         return 0;
2764 }
2765
2766 static void tegra3_audio_sync_clk_disable(struct clk *c)
2767 {
2768         u32 val = clk_readl(c->reg);
2769         clk_writel((val | AUDIO_SYNC_DISABLE_BIT), c->reg);
2770 }
2771
2772 static int tegra3_audio_sync_clk_set_parent(struct clk *c, struct clk *p)
2773 {
2774         u32 val;
2775         const struct clk_mux_sel *sel;
2776         for (sel = c->inputs; sel->input != NULL; sel++) {
2777                 if (sel->input == p) {
2778                         val = clk_readl(c->reg);
2779                         val &= ~AUDIO_SYNC_SOURCE_MASK;
2780                         val |= sel->value;
2781
2782                         if (c->refcnt)
2783                                 clk_enable(p);
2784
2785                         clk_writel(val, c->reg);
2786
2787                         if (c->refcnt && c->parent)
2788                                 clk_disable(c->parent);
2789
2790                         clk_reparent(c, p);
2791                         return 0;
2792                 }
2793         }
2794
2795         return -EINVAL;
2796 }
2797
2798 static struct clk_ops tegra_audio_sync_clk_ops = {
2799         .init       = tegra3_audio_sync_clk_init,
2800         .enable     = tegra3_audio_sync_clk_enable,
2801         .disable    = tegra3_audio_sync_clk_disable,
2802         .set_parent = tegra3_audio_sync_clk_set_parent,
2803 };
2804
2805 /* cml0 (pcie), and cml1 (sata) clock ops (non-atomic shared register access) */
2806 static DEFINE_SPINLOCK(cml_lock);
2807
2808 static void tegra3_cml_clk_init(struct clk *c)
2809 {
2810         u32 val = clk_readl(c->reg);
2811         c->state = val & (0x1 << c->u.periph.clk_num) ? ON : OFF;
2812 }
2813
2814 static int tegra3_cml_clk_enable(struct clk *c)
2815 {
2816         u32 val;
2817         unsigned long flags;
2818
2819         spin_lock_irqsave(&cml_lock, flags);
2820         val = clk_readl(c->reg);
2821         val |= (0x1 << c->u.periph.clk_num);
2822         clk_writel(val, c->reg);
2823         spin_unlock_irqrestore(&cml_lock, flags);
2824         return 0;
2825 }
2826
2827 static void tegra3_cml_clk_disable(struct clk *c)
2828 {
2829         u32 val;
2830         unsigned long flags;
2831
2832         spin_lock_irqsave(&cml_lock, flags);
2833         val = clk_readl(c->reg);
2834         val &= ~(0x1 << c->u.periph.clk_num);
2835         clk_writel(val, c->reg);
2836         spin_unlock_irqrestore(&cml_lock, flags);
2837 }
2838
2839 static struct clk_ops tegra_cml_clk_ops = {
2840         .init                   = &tegra3_cml_clk_init,
2841         .enable                 = &tegra3_cml_clk_enable,
2842         .disable                = &tegra3_cml_clk_disable,
2843 };
2844
2845
2846 /* cbus ops */
2847 /*
2848  * Some clocks require dynamic re-locking of source PLL in order to
2849  * achieve frequency scaling granularity that matches characterized
2850  * core voltage steps. The cbus clock creates a shared bus that
2851  * provides a virtual root for such clocks to hide and synchronize
2852  * parent PLL re-locking as well as backup operations.
2853 */
2854
2855 static void tegra3_clk_cbus_init(struct clk *c)
2856 {
2857         c->state = OFF;
2858         c->set = true;
2859         c->shared_bus_backup.bus_rate =
2860                 clk_get_rate(c->shared_bus_backup.input) /
2861                 c->shared_bus_backup.value;
2862 }
2863
2864 static int tegra3_clk_cbus_enable(struct clk *c)
2865 {
2866         return 0;
2867 }
2868
2869 static long tegra3_clk_cbus_round_rate(struct clk *c, unsigned long rate)
2870 {
2871         int i;
2872
2873         if (!c->dvfs)
2874                 return rate;
2875
2876         /* update min now, since no dvfs table was available during init
2877            (skip placeholder entries set to 1 kHz) */
2878         if (!c->min_rate) {
2879                 for (i = 0; i < (c->dvfs->num_freqs - 1); i++) {
2880                         if (c->dvfs->freqs[i] > 1 * c->dvfs->freqs_mult) {
2881                                 c->min_rate = c->dvfs->freqs[i];
2882                                 break;
2883                         }
2884                 }
2885                 BUG_ON(!c->min_rate);
2886         }
2887         rate = max(rate, c->min_rate);
2888
2889         for (i = 0; i < (c->dvfs->num_freqs - 1); i++) {
2890                 unsigned long f = c->dvfs->freqs[i];
2891                 if (f >= rate)
2892                         break;
2893         }
2894         return c->dvfs->freqs[i];
2895 }
2896
2897 static int cbus_switch_one(struct clk *c, struct clk *p, u32 div, bool abort)
2898 {
2899         int ret = 0;
2900
2901         /* set new divider if it is bigger than the current one */
2902         if (c->div < c->mul * div) {
2903                 ret = clk_set_div(c, div);
2904                 if (ret) {
2905                         pr_err("%s: failed to set %s clock divider %u: %d\n",
2906                                __func__, c->name, div, ret);
2907                         if (abort)
2908                                 return ret;
2909                 }
2910         }
2911
2912         ret = clk_set_parent(c, p);
2913         if (ret) {
2914                 pr_err("%s: failed to set %s clock parent %s: %d\n",
2915                        __func__, c->name, p->name, ret);
2916                 if (abort)
2917                         return ret;
2918         }
2919
2920         /* set new divider if it is smaller than the current one */
2921         if (c->div > c->mul * div) {
2922                 ret = clk_set_div(c, div);
2923                 if (ret)
2924                         pr_err("%s: failed to set %s clock divider %u: %d\n",
2925                                __func__, c->name, div, ret);
2926         }
2927
2928         return ret;
2929 }
2930
2931 static int cbus_backup(struct clk *c)
2932 {
2933         int ret;
2934         struct clk *user;
2935
2936         list_for_each_entry(user, &c->shared_bus_list,
2937                         u.shared_bus_user.node) {
2938                 bool enabled = user->u.shared_bus_user.client &&
2939                         (user->u.shared_bus_user.enabled ||
2940                         user->u.shared_bus_user.client->refcnt);
2941                 if (enabled) {
2942                         ret = cbus_switch_one(user->u.shared_bus_user.client,
2943                                               c->shared_bus_backup.input,
2944                                               c->shared_bus_backup.value *
2945                                               user->div, true);
2946                         if (ret)
2947                                 return ret;
2948                 }
2949         }
2950         return 0;
2951 }
2952
2953 static void cbus_restore(struct clk *c)
2954 {
2955         struct clk *user;
2956
2957         list_for_each_entry(user, &c->shared_bus_list,
2958                         u.shared_bus_user.node) {
2959                 bool back = user->u.shared_bus_user.client && (c->parent !=
2960                         user->u.shared_bus_user.client->parent);
2961                 if (back)
2962                         cbus_switch_one(user->u.shared_bus_user.client,
2963                                         c->parent, c->div * user->div, false);
2964         }
2965 }
2966
2967 static int tegra3_clk_cbus_set_rate(struct clk *c, unsigned long rate)
2968 {
2969         int ret;
2970
2971         if (rate == 0)
2972                 return 0;
2973
2974         ret = clk_enable(c->parent);
2975         if (ret) {
2976                 pr_err("%s: failed to enable %s clock: %d\n",
2977                        __func__, c->name, ret);
2978                 return ret;
2979         }
2980
2981         ret = cbus_backup(c);
2982         if (ret)
2983                 goto out;
2984
2985         ret = clk_set_rate(c->parent, rate * c->div);
2986         if (ret) {
2987                 pr_err("%s: failed to set %s clock rate %lu: %d\n",
2988                        __func__, c->name, rate, ret);
2989                 goto out;
2990         }
2991
2992         cbus_restore(c);
2993
2994 out:
2995         clk_disable(c->parent);
2996         return ret;
2997 }
2998
2999 static struct clk_ops tegra_clk_cbus_ops = {
3000         .init = tegra3_clk_cbus_init,
3001         .enable = tegra3_clk_cbus_enable,
3002         .set_rate = tegra3_clk_cbus_set_rate,
3003         .round_rate = tegra3_clk_cbus_round_rate,
3004         .shared_bus_update = tegra3_clk_shared_bus_update,
3005 };
3006
3007 /* shared bus ops */
3008 /*
3009  * Some clocks may have multiple downstream users that need to request a
3010  * higher clock rate.  Shared bus clocks provide a unique shared_bus_user
3011  * clock to each user.  The frequency of the bus is set to the highest
3012  * enabled shared_bus_user clock, with a minimum value set by the
3013  * shared bus.
3014  */
3015
3016 static noinline int shared_bus_set_rate(struct clk *bus, unsigned long rate,
3017                                         unsigned long old_rate)
3018 {
3019         int ret, mv, old_mv;
3020         unsigned long bridge_rate = emc_bridge->u.shared_bus_user.rate;
3021
3022         /* If bridge is not needed (LPDDR2) just set bus rate */
3023         if (tegra_emc_get_dram_type() == DRAM_TYPE_LPDDR2)
3024                 return clk_set_rate_locked(bus, rate);
3025
3026         mv = tegra_dvfs_predict_millivolts(bus, rate);
3027         old_mv = tegra_dvfs_predict_millivolts(bus, old_rate);
3028         if (IS_ERR_VALUE(mv) || IS_ERR_VALUE(old_mv)) {
3029                 pr_err("%s: Failed to predict %s voltage for %lu => %lu\n",
3030                        __func__, bus->name, old_rate, rate);
3031                 return -EINVAL;
3032         }
3033
3034         /* emc bus: set bridge rate as intermediate step when crossing
3035          * bridge threshold in any direction
3036          */
3037         if (bus->flags & PERIPH_EMC_ENB) {
3038                 if (((mv > TEGRA_EMC_BRIDGE_MVOLTS_MIN) &&
3039                      (old_rate < bridge_rate)) ||
3040                     ((old_mv > TEGRA_EMC_BRIDGE_MVOLTS_MIN) &&
3041                      (rate < bridge_rate))) {
3042                         ret = clk_set_rate_locked(bus, bridge_rate);
3043                         if (ret) {
3044                                 pr_err("%s: Failed to set emc bridge rate %lu\n",
3045                                         __func__, bridge_rate);
3046                                 return ret;
3047                         }
3048                 }
3049                 return clk_set_rate_locked(bus, rate);
3050         }
3051
3052         /* sbus and cbus: enable/disable emc bridge user when crossing voltage
3053          * threshold up/down respectively; hence, emc rate is kept above the
3054          * bridge rate as long as any sbus or cbus user requires high voltage
3055          */
3056         if ((mv > TEGRA_EMC_BRIDGE_MVOLTS_MIN) &&
3057             (old_mv <= TEGRA_EMC_BRIDGE_MVOLTS_MIN)) {
3058                 ret = clk_enable(emc_bridge);
3059                 if (ret) {
3060                         pr_err("%s: Failed to enable emc bridge\n", __func__);
3061                         return ret;
3062                 }
3063         }
3064
3065         ret = clk_set_rate_locked(bus, rate);
3066         if (ret)
3067                 return ret;
3068
3069         if ((mv <= TEGRA_EMC_BRIDGE_MVOLTS_MIN) &&
3070             (old_mv > TEGRA_EMC_BRIDGE_MVOLTS_MIN))
3071                 clk_disable(emc_bridge);
3072
3073         return 0;
3074 }
3075
3076 static int tegra3_clk_shared_bus_update(struct clk *bus)
3077 {
3078         struct clk *c;
3079         unsigned long old_rate;
3080         unsigned long rate = bus->min_rate;
3081         unsigned long bw = 0;
3082         unsigned long ceiling = bus->max_rate;
3083         u8 emc_bw_efficiency = tegra_emc_bw_efficiency_boost;
3084
3085         if (detach_shared_bus)
3086                 return 0;
3087
3088         list_for_each_entry(c, &bus->shared_bus_list,
3089                         u.shared_bus_user.node) {
3090                 /* Ignore requests from disabled floor and bw users, and from
3091                  * auto-users riding the bus. Always honor ceiling users, even
3092                  * if they are disabled - we do not want to keep enabled parent
3093                  * bus just because ceiling is set.
3094                  */
3095                 if (c->u.shared_bus_user.enabled ||
3096                     (c->u.shared_bus_user.mode == SHARED_CEILING)) {
3097                         if (!strcmp(c->name, "3d.emc"))
3098                                 emc_bw_efficiency = tegra_emc_bw_efficiency;
3099
3100                         switch (c->u.shared_bus_user.mode) {
3101                         case SHARED_BW:
3102                                 if (bw < bus->max_rate)
3103                                         bw += c->u.shared_bus_user.rate;
3104                                 break;
3105                         case SHARED_CEILING:
3106                                 ceiling = min(c->u.shared_bus_user.rate,
3107                                                ceiling);
3108                                 break;
3109                         case SHARED_AUTO:
3110                         case SHARED_FLOOR:
3111                         default:
3112                                 rate = max(c->u.shared_bus_user.rate, rate);
3113                         }
3114                 }
3115         }
3116
3117         if (bw) {
3118                 if (bus->flags & PERIPH_EMC_ENB) {
3119                         bw = emc_bw_efficiency ?
3120                                 (bw / emc_bw_efficiency) : bus->max_rate;
3121                         bw = (bw < bus->max_rate / 100) ?
3122                                 (bw * 100) : bus->max_rate;
3123                 }
3124                 bw = clk_round_rate_locked(bus, bw);
3125         }
3126         rate = min(max(rate, bw), ceiling);
3127
3128         old_rate = clk_get_rate_locked(bus);
3129         if (rate == old_rate)
3130                 return 0;
3131
3132         return shared_bus_set_rate(bus, rate, old_rate);
3133 };
3134
3135 static void tegra_clk_shared_bus_init(struct clk *c)
3136 {
3137         c->max_rate = c->parent->max_rate;
3138         c->u.shared_bus_user.rate = c->parent->max_rate;
3139         c->state = OFF;
3140         c->set = true;
3141
3142         if (c->u.shared_bus_user.client_id) {
3143                 c->u.shared_bus_user.client =
3144                         tegra_get_clock_by_name(c->u.shared_bus_user.client_id);
3145                 if (!c->u.shared_bus_user.client) {
3146                         pr_err("%s: could not find clk %s\n", __func__,
3147                                c->u.shared_bus_user.client_id);
3148                         return;
3149                 }
3150                 c->u.shared_bus_user.client->flags |=
3151                         c->parent->flags & PERIPH_ON_CBUS;
3152                 c->flags |= c->parent->flags & PERIPH_ON_CBUS;
3153                 c->div = c->u.shared_bus_user.client_div ? : 1;
3154                 c->mul = 1;
3155         }
3156
3157         list_add_tail(&c->u.shared_bus_user.node,
3158                 &c->parent->shared_bus_list);
3159 }
3160
3161 static int tegra_clk_shared_bus_set_rate(struct clk *c, unsigned long rate)
3162 {
3163         c->u.shared_bus_user.rate = rate;
3164         tegra_clk_shared_bus_update(c->parent);
3165         return 0;
3166 }
3167
3168 static long tegra_clk_shared_bus_round_rate(struct clk *c, unsigned long rate)
3169 {
3170         /* auto user follow others, by itself it run at minimum bus rate */
3171         if (c->u.shared_bus_user.mode == SHARED_AUTO)
3172                 rate = 0;
3173
3174         /* BW users should not be rounded until aggregated */
3175         if (c->u.shared_bus_user.mode == SHARED_BW)
3176                 return rate;
3177
3178         return clk_round_rate(c->parent, rate);
3179 }
3180
3181 static int tegra_clk_shared_bus_enable(struct clk *c)
3182 {
3183         c->u.shared_bus_user.enabled = true;
3184         tegra_clk_shared_bus_update(c->parent);
3185         if (c->u.shared_bus_user.client) {
3186                 return clk_enable(c->u.shared_bus_user.client);
3187         }
3188         return 0;
3189 }
3190
3191 static void tegra_clk_shared_bus_disable(struct clk *c)
3192 {
3193         if (c->u.shared_bus_user.client)
3194                 clk_disable(c->u.shared_bus_user.client);
3195         c->u.shared_bus_user.enabled = false;
3196         tegra_clk_shared_bus_update(c->parent);
3197 }
3198
3199 static void tegra_clk_shared_bus_reset(struct clk *c, bool assert)
3200 {
3201         if (c->u.shared_bus_user.client) {
3202                 if (c->u.shared_bus_user.client->ops &&
3203                     c->u.shared_bus_user.client->ops->reset)
3204                         c->u.shared_bus_user.client->ops->reset(
3205                                 c->u.shared_bus_user.client, assert);
3206         }
3207 }
3208
3209 static struct clk_ops tegra_clk_shared_bus_ops = {
3210         .init = tegra_clk_shared_bus_init,
3211         .enable = tegra_clk_shared_bus_enable,
3212         .disable = tegra_clk_shared_bus_disable,
3213         .set_rate = tegra_clk_shared_bus_set_rate,
3214         .round_rate = tegra_clk_shared_bus_round_rate,
3215         .reset = tegra_clk_shared_bus_reset,
3216 };
3217
3218 /* emc bridge ops */
3219 /* On Tegra3 platforms emc configurations for DDR3 low rates can not work
3220  * at high core voltage; the intermediate step (bridge) is mandatory whenever
3221  * core voltage is crossing the threshold: TEGRA_EMC_BRIDGE_MVOLTS_MIN (fixed
3222  * for the entire Tegra3 arch); also emc must run above the bridge rate if any
3223  * other than emc clock requires high voltage. LP CPU, memory, sbus and cbus
3224  * together include all clocks that may require core voltage above threshold
3225  * (other peripherals can reach their maximum rates below threshold). LP CPU
3226  * dependency is taken care of via tegra_emc_to_cpu_ratio() api. Memory clock
3227  * transitions are forced to step through bridge rate; sbus and cbus control
3228  * emc bridge to set emc clock floor as necessary.
3229  *
3230  * EMC bridge is implemented as a special emc shared bus user: initialized at
3231  * minimum rate until updated once by emc dvfs setup; then it is only enabled
3232  * or disabled when sbus and/or cbus voltage is crossing the threshold.
3233  */
3234 static void tegra3_clk_emc_bridge_init(struct clk *c)
3235 {
3236         tegra_clk_shared_bus_init(c);
3237         c->u.shared_bus_user.rate = 0;
3238 }
3239
3240 static int tegra3_clk_emc_bridge_set_rate(struct clk *c, unsigned long rate)
3241 {
3242         if (c->u.shared_bus_user.rate == 0)
3243                 c->u.shared_bus_user.rate = rate;
3244         return 0;
3245 }
3246
3247 static struct clk_ops tegra_clk_emc_bridge_ops = {
3248         .init = tegra3_clk_emc_bridge_init,
3249         .enable = tegra_clk_shared_bus_enable,
3250         .disable = tegra_clk_shared_bus_disable,
3251         .set_rate = tegra3_clk_emc_bridge_set_rate,
3252         .round_rate = tegra_clk_shared_bus_round_rate,
3253 };
3254
3255 /* Clock definitions */
3256 static struct clk tegra_clk_32k = {
3257         .name = "clk_32k",
3258         .rate = 32768,
3259         .ops  = NULL,
3260         .max_rate = 32768,
3261 };
3262
3263 static struct clk tegra_clk_m = {
3264         .name      = "clk_m",
3265         .flags     = ENABLE_ON_INIT,
3266         .ops       = &tegra_clk_m_ops,
3267         .reg       = 0x1fc,
3268         .reg_shift = 28,
3269         .max_rate  = 48000000,
3270 };
3271
3272 static struct clk tegra_clk_m_div2 = {
3273         .name      = "clk_m_div2",
3274         .ops       = &tegra_clk_m_div_ops,
3275         .parent    = &tegra_clk_m,
3276         .mul       = 1,
3277         .div       = 2,
3278         .state     = ON,
3279         .max_rate  = 24000000,
3280 };
3281
3282 static struct clk tegra_clk_m_div4 = {
3283         .name      = "clk_m_div4",
3284         .ops       = &tegra_clk_m_div_ops,
3285         .parent    = &tegra_clk_m,
3286         .mul       = 1,
3287         .div       = 4,
3288         .state     = ON,
3289         .max_rate  = 12000000,
3290 };
3291
3292 static struct clk tegra_pll_ref = {
3293         .name      = "pll_ref",
3294         .flags     = ENABLE_ON_INIT,
3295         .ops       = &tegra_pll_ref_ops,
3296         .parent    = &tegra_clk_m,
3297         .max_rate  = 26000000,
3298 };
3299
3300 static struct clk_pll_freq_table tegra_pll_c_freq_table[] = {
3301         { 12000000, 1200000000, 600,  6, 1, 8},
3302         { 13000000, 1200000000, 923, 10, 1, 8},         /* actual: 1199.9 MHz */
3303         { 16800000, 1200000000, 500,  7, 1, 8},
3304         { 19200000, 1200000000, 500,  8, 1, 8},
3305         { 26000000, 1200000000, 600, 13, 1, 8},
3306
3307         { 12000000, 1040000000, 520,  6, 1, 8},
3308         { 13000000, 1040000000, 480,  6, 1, 8},
3309         { 16800000, 1040000000, 495,  8, 1, 8},         /* actual: 1039.5 MHz */
3310         { 19200000, 1040000000, 325,  6, 1, 6},
3311         { 26000000, 1040000000, 520, 13, 1, 8},
3312
3313         { 12000000, 832000000, 416,  6, 1, 8},
3314         { 13000000, 832000000, 832, 13, 1, 8},
3315         { 16800000, 832000000, 396,  8, 1, 8},          /* actual: 831.6 MHz */
3316         { 19200000, 832000000, 260,  6, 1, 8},
3317         { 26000000, 832000000, 416, 13, 1, 8},
3318
3319         { 12000000, 624000000, 624, 12, 1, 8},
3320         { 13000000, 624000000, 624, 13, 1, 8},
3321         { 16800000, 624000000, 520, 14, 1, 8},
3322         { 19200000, 624000000, 520, 16, 1, 8},
3323         { 26000000, 624000000, 624, 26, 1, 8},
3324
3325         { 12000000, 600000000, 600, 12, 1, 8},
3326         { 13000000, 600000000, 600, 13, 1, 8},
3327         { 16800000, 600000000, 500, 14, 1, 8},
3328         { 19200000, 600000000, 375, 12, 1, 6},
3329         { 26000000, 600000000, 600, 26, 1, 8},
3330
3331         { 12000000, 520000000, 520, 12, 1, 8},
3332         { 13000000, 520000000, 520, 13, 1, 8},
3333         { 16800000, 520000000, 495, 16, 1, 8},          /* actual: 519.75 MHz */
3334         { 19200000, 520000000, 325, 12, 1, 6},
3335         { 26000000, 520000000, 520, 26, 1, 8},
3336
3337         { 12000000, 416000000, 416, 12, 1, 8},
3338         { 13000000, 416000000, 416, 13, 1, 8},
3339         { 16800000, 416000000, 396, 16, 1, 8},          /* actual: 415.8 MHz */
3340         { 19200000, 416000000, 260, 12, 1, 6},
3341         { 26000000, 416000000, 416, 26, 1, 8},
3342         { 0, 0, 0, 0, 0, 0 },
3343 };
3344
3345 static struct clk tegra_pll_c = {
3346         .name      = "pll_c",
3347         .flags     = PLL_HAS_CPCON,
3348         .ops       = &tegra_pll_ops,
3349         .reg       = 0x80,
3350         .parent    = &tegra_pll_ref,
3351         .max_rate  = 1400000000,
3352         .u.pll = {
3353                 .input_min = 2000000,
3354                 .input_max = 31000000,
3355                 .cf_min    = 1000000,
3356                 .cf_max    = 6000000,
3357                 .vco_min   = 20000000,
3358                 .vco_max   = 1400000000,
3359                 .freq_table = tegra_pll_c_freq_table,
3360                 .lock_delay = 300,
3361         },
3362 };
3363
3364 static struct clk tegra_pll_c_out1 = {
3365         .name      = "pll_c_out1",
3366         .ops       = &tegra_pll_div_ops,
3367         .flags     = DIV_U71 | PERIPH_ON_CBUS,
3368         .parent    = &tegra_pll_c,
3369         .reg       = 0x84,
3370         .reg_shift = 0,
3371         .max_rate  = 700000000,
3372 };
3373
3374 static struct clk_pll_freq_table tegra_pll_m_freq_table[] = {
3375         { 12000000, 666000000, 666, 12, 1, 8},
3376         { 13000000, 666000000, 666, 13, 1, 8},
3377         { 16800000, 666000000, 555, 14, 1, 8},
3378         { 19200000, 666000000, 555, 16, 1, 8},
3379         { 26000000, 666000000, 666, 26, 1, 8},
3380         { 12000000, 600000000, 600, 12, 1, 8},
3381         { 13000000, 600000000, 600, 13, 1, 8},
3382         { 16800000, 600000000, 500, 14, 1, 8},
3383         { 19200000, 600000000, 375, 12, 1, 6},
3384         { 26000000, 600000000, 600, 26, 1, 8},
3385         { 0, 0, 0, 0, 0, 0 },
3386 };
3387
3388 static struct clk tegra_pll_m = {
3389         .name      = "pll_m",
3390         .flags     = PLL_HAS_CPCON | PLLM,
3391         .ops       = &tegra_pll_ops,
3392         .reg       = 0x90,
3393         .parent    = &tegra_pll_ref,
3394         .max_rate  = 900000000,
3395         .u.pll = {
3396                 .input_min = 2000000,
3397                 .input_max = 31000000,
3398                 .cf_min    = 1000000,
3399                 .cf_max    = 6000000,
3400                 .vco_min   = 20000000,
3401                 .vco_max   = 1200000000,
3402                 .freq_table = tegra_pll_m_freq_table,
3403                 .lock_delay = 300,
3404         },
3405 };
3406
3407 static struct clk tegra_pll_m_out1 = {
3408         .name      = "pll_m_out1",
3409         .ops       = &tegra_pll_div_ops,
3410         .flags     = DIV_U71,
3411         .parent    = &tegra_pll_m,
3412         .reg       = 0x94,
3413         .reg_shift = 0,
3414         .max_rate  = 600000000,
3415 };
3416
3417 static struct clk_pll_freq_table tegra_pll_p_freq_table[] = {
3418         { 12000000, 216000000, 432, 12, 2, 8},
3419         { 13000000, 216000000, 432, 13, 2, 8},
3420         { 16800000, 216000000, 360, 14, 2, 8},
3421         { 19200000, 216000000, 360, 16, 2, 8},
3422         { 26000000, 216000000, 432, 26, 2, 8},
3423         { 0, 0, 0, 0, 0, 0 },
3424 };
3425
3426 static struct clk tegra_pll_p = {
3427         .name      = "pll_p",
3428         .flags     = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
3429         .ops       = &tegra_pllp_ops,
3430         .reg       = 0xa0,
3431         .parent    = &tegra_pll_ref,
3432         .max_rate  = 432000000,
3433         .u.pll = {
3434                 .input_min = 2000000,
3435                 .input_max = 31000000,
3436                 .cf_min    = 1000000,
3437                 .cf_max    = 6000000,
3438                 .vco_min   = 20000000,
3439                 .vco_max   = 1400000000,
3440                 .freq_table = tegra_pll_p_freq_table,
3441                 .lock_delay = 300,
3442         },
3443 };
3444
3445 static struct clk tegra_pll_p_out1 = {
3446         .name      = "pll_p_out1",
3447         .ops       = &tegra_pll_div_ops,
3448         .flags     = DIV_U71 | DIV_U71_FIXED,
3449         .parent    = &tegra_pll_p,
3450         .reg       = 0xa4,
3451         .reg_shift = 0,
3452         .max_rate  = 432000000,
3453 };
3454
3455 static struct clk tegra_pll_p_out2 = {
3456         .name      = "pll_p_out2",
3457         .ops       = &tegra_pll_div_ops,
3458         .flags     = DIV_U71 | DIV_U71_FIXED,
3459         .parent    = &tegra_pll_p,
3460         .reg       = 0xa4,
3461         .reg_shift = 16,
3462         .max_rate  = 432000000,
3463 };
3464
3465 static struct clk tegra_pll_p_out3 = {
3466         .name      = "pll_p_out3",
3467         .ops       = &tegra_pll_div_ops,
3468         .flags     = DIV_U71 | DIV_U71_FIXED,
3469         .parent    = &tegra_pll_p,
3470         .reg       = 0xa8,
3471         .reg_shift = 0,
3472         .max_rate  = 432000000,
3473 };
3474
3475 static struct clk tegra_pll_p_out4 = {
3476         .name      = "pll_p_out4",
3477         .ops       = &tegra_pll_div_ops,
3478         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
3479         .parent    = &tegra_pll_p,
3480         .reg       = 0xa8,
3481         .reg_shift = 16,
3482         .max_rate  = 432000000,
3483 };
3484
3485 static struct clk_pll_freq_table tegra_pll_a_freq_table[] = {
3486         { 9600000, 564480000, 294, 5, 1, 4},
3487         { 9600000, 552960000, 288, 5, 1, 4},
3488         { 9600000, 24000000,  5,   2, 1, 1},
3489
3490         { 28800000, 56448000, 49, 25, 1, 1},
3491         { 28800000, 73728000, 64, 25, 1, 1},
3492         { 28800000, 24000000,  5,  6, 1, 1},
3493         { 0, 0, 0, 0, 0, 0 },
3494 };
3495
3496 static struct clk tegra_pll_a = {
3497         .name      = "pll_a",
3498         .flags     = PLL_HAS_CPCON,
3499         .ops       = &tegra_pll_ops,
3500         .reg       = 0xb0,
3501         .parent    = &tegra_pll_p_out1,
3502         .max_rate  = 700000000,
3503         .u.pll = {
3504                 .input_min = 2000000,
3505                 .input_max = 31000000,
3506                 .cf_min    = 1000000,
3507                 .cf_max    = 6000000,
3508                 .vco_min   = 20000000,
3509                 .vco_max   = 1400000000,
3510                 .freq_table = tegra_pll_a_freq_table,
3511                 .lock_delay = 300,
3512         },
3513 };
3514
3515 static struct clk tegra_pll_a_out0 = {
3516         .name      = "pll_a_out0",
3517         .ops       = &tegra_pll_div_ops,
3518         .flags     = DIV_U71,
3519         .parent    = &tegra_pll_a,
3520         .reg       = 0xb4,
3521         .reg_shift = 0,
3522         .max_rate  = 100000000,
3523 };
3524
3525 static struct clk_pll_freq_table tegra_pll_d_freq_table[] = {
3526         { 12000000, 216000000, 216, 12, 1, 4},
3527         { 13000000, 216000000, 216, 13, 1, 4},
3528         { 16800000, 216000000, 180, 14, 1, 4},
3529         { 19200000, 216000000, 180, 16, 1, 4},
3530         { 26000000, 216000000, 216, 26, 1, 4},
3531
3532         { 12000000, 594000000, 594, 12, 1, 8},
3533         { 13000000, 594000000, 594, 13, 1, 8},
3534         { 16800000, 594000000, 495, 14, 1, 8},
3535         { 19200000, 594000000, 495, 16, 1, 8},
3536         { 26000000, 594000000, 594, 26, 1, 8},
3537
3538         { 12000000, 1000000000, 1000, 12, 1, 12},
3539         { 13000000, 1000000000, 1000, 13, 1, 12},
3540         { 19200000, 1000000000, 625,  12, 1, 8},
3541         { 26000000, 1000000000, 1000, 26, 1, 12},
3542
3543         { 0, 0, 0, 0, 0, 0 },
3544 };
3545
3546 static struct clk tegra_pll_d = {
3547         .name      = "pll_d",
3548         .flags     = PLL_HAS_CPCON | PLLD,
3549         .ops       = &tegra_plld_ops,
3550         .reg       = 0xd0,
3551         .parent    = &tegra_pll_ref,
3552         .max_rate  = 1000000000,
3553         .u.pll = {
3554                 .input_min = 2000000,
3555                 .input_max = 40000000,
3556                 .cf_min    = 1000000,
3557                 .cf_max    = 6000000,
3558                 .vco_min   = 40000000,
3559                 .vco_max   = 1000000000,
3560                 .freq_table = tegra_pll_d_freq_table,
3561                 .lock_delay = 1000,
3562         },
3563 };
3564
3565 static struct clk tegra_pll_d_out0 = {
3566         .name      = "pll_d_out0",
3567         .ops       = &tegra_pll_div_ops,
3568         .flags     = DIV_2 | PLLD,
3569         .parent    = &tegra_pll_d,
3570         .max_rate  = 500000000,
3571 };
3572
3573 static struct clk tegra_pll_d2 = {
3574         .name      = "pll_d2",
3575         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG | PLLD,
3576         .ops       = &tegra_plld_ops,
3577         .reg       = 0x4b8,
3578         .parent    = &tegra_pll_ref,
3579         .max_rate  = 1000000000,
3580         .u.pll = {
3581                 .input_min = 2000000,
3582                 .input_max = 40000000,
3583                 .cf_min    = 1000000,
3584                 .cf_max    = 6000000,
3585                 .vco_min   = 40000000,
3586                 .vco_max   = 1000000000,
3587                 .freq_table = tegra_pll_d_freq_table,
3588                 .lock_delay = 1000,
3589         },
3590 };
3591
3592 static struct clk tegra_pll_d2_out0 = {
3593         .name      = "pll_d2_out0",
3594         .ops       = &tegra_pll_div_ops,
3595         .flags     = DIV_2 | PLLD,
3596         .parent    = &tegra_pll_d2,
3597         .max_rate  = 500000000,
3598 };
3599
3600 static struct clk_pll_freq_table tegra_pll_u_freq_table[] = {
3601         { 12000000, 480000000, 960, 12, 2, 12},
3602         { 13000000, 480000000, 960, 13, 2, 12},
3603         { 16800000, 480000000, 400, 7,  2, 5},
3604         { 19200000, 480000000, 200, 4,  2, 3},
3605         { 26000000, 480000000, 960, 26, 2, 12},
3606         { 0, 0, 0, 0, 0, 0 },
3607 };
3608
3609 static struct clk tegra_pll_u = {
3610         .name      = "pll_u",
3611         .flags     = PLL_HAS_CPCON | PLLU,
3612         .ops       = &tegra_pll_ops,
3613         .reg       = 0xc0,
3614         .parent    = &tegra_pll_ref,
3615         .max_rate  = 480000000,
3616         .u.pll = {
3617                 .input_min = 2000000,
3618                 .input_max = 40000000,
3619                 .cf_min    = 1000000,
3620                 .cf_max    = 6000000,
3621                 .vco_min   = 480000000,
3622                 .vco_max   = 960000000,
3623                 .freq_table = tegra_pll_u_freq_table,
3624                 .lock_delay = 1000,
3625         },
3626 };
3627
3628 static struct clk_pll_freq_table tegra_pll_x_freq_table[] = {
3629         /* 1.7 GHz */
3630         { 12000000, 1700000000, 850,  6,  1, 8},
3631         { 13000000, 1700000000, 915,  7,  1, 8},        /* actual: 1699.2 MHz */
3632         { 16800000, 1700000000, 708,  7,  1, 8},        /* actual: 1699.2 MHz */
3633         { 19200000, 1700000000, 885,  10, 1, 8},        /* actual: 1699.2 MHz */
3634         { 26000000, 1700000000, 850,  13, 1, 8},
3635
3636         /* 1.6 GHz */
3637         { 12000000, 1600000000, 800,  6,  1, 8},
3638         { 13000000, 1600000000, 738,  6,  1, 8},        /* actual: 1599.0 MHz */
3639         { 16800000, 1600000000, 857,  9,  1, 8},        /* actual: 1599.7 MHz */
3640         { 19200000, 1600000000, 500,  6,  1, 8},
3641         { 26000000, 1600000000, 800,  13, 1, 8},
3642
3643         /* 1.5 GHz */
3644         { 12000000, 1500000000, 750,  6,  1, 8},
3645         { 13000000, 1500000000, 923,  8,  1, 8},        /* actual: 1499.8 MHz */
3646         { 16800000, 1500000000, 625,  7,  1, 8},
3647         { 19200000, 1500000000, 625,  8,  1, 8},
3648         { 26000000, 1500000000, 750,  13, 1, 8},
3649
3650         /* 1.4 GHz */
3651         { 12000000, 1400000000, 700,  6,  1, 8},
3652         { 13000000, 1400000000, 969,  9,  1, 8},        /* actual: 1399.7 MHz */
3653         { 16800000, 1400000000, 1000, 12, 1, 8},
3654         { 19200000, 1400000000, 875,  12, 1, 8},
3655         { 26000000, 1400000000, 700,  13, 1, 8},
3656
3657         /* 1.3 GHz */
3658         { 12000000, 1300000000, 975,  9,  1, 8},
3659         { 13000000, 1300000000, 1000, 10, 1, 8},
3660         { 16800000, 1300000000, 928,  12, 1, 8},        /* actual: 1299.2 MHz */
3661         { 19200000, 1300000000, 812,  12, 1, 8},        /* actual: 1299.2 MHz */
3662         { 26000000, 1300000000, 650,  13, 1, 8},
3663
3664         /* 1.2 GHz */
3665         { 12000000, 1200000000, 1000, 10, 1, 8},
3666         { 13000000, 1200000000, 923,  10, 1, 8},        /* actual: 1199.9 MHz */
3667         { 16800000, 1200000000, 1000, 14, 1, 8},
3668         { 19200000, 1200000000, 1000, 16, 1, 8},
3669         { 26000000, 1200000000, 600,  13, 1, 8},
3670
3671         /* 1.1 GHz */
3672         { 12000000, 1100000000, 825,  9,  1, 8},
3673         { 13000000, 1100000000, 846,  10, 1, 8},        /* actual: 1099.8 MHz */
3674         { 16800000, 1100000000, 982,  15, 1, 8},        /* actual: 1099.8 MHz */
3675         { 19200000, 1100000000, 859,  15, 1, 8},        /* actual: 1099.5 MHz */
3676         { 26000000, 1100000000, 550,  13, 1, 8},
3677
3678         /* 1 GHz */
3679         { 12000000, 1000000000, 1000, 12, 1, 8},
3680         { 13000000, 1000000000, 1000, 13, 1, 8},
3681         { 16800000, 1000000000, 833,  14, 1, 8},        /* actual: 999.6 MHz */
3682         { 19200000, 1000000000, 625,  12, 1, 8},
3683         { 26000000, 1000000000, 1000, 26, 1, 8},
3684
3685         { 0, 0, 0, 0, 0, 0 },
3686 };
3687
3688 static struct clk tegra_pll_x = {
3689         .name      = "pll_x",
3690         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG | PLLX,
3691         .ops       = &tegra_pll_ops,
3692         .reg       = 0xe0,
3693         .parent    = &tegra_pll_ref,
3694         .max_rate  = 1700000000,
3695         .u.pll = {
3696                 .input_min = 2000000,
3697                 .input_max = 31000000,
3698                 .cf_min    = 1000000,
3699                 .cf_max    = 6000000,
3700                 .vco_min   = 20000000,
3701                 .vco_max   = 1700000000,
3702                 .freq_table = tegra_pll_x_freq_table,
3703                 .lock_delay = 300,
3704         },
3705 };
3706
3707 static struct clk tegra_pll_x_out0 = {
3708         .name      = "pll_x_out0",
3709         .ops       = &tegra_pll_div_ops,
3710         .flags     = DIV_2 | PLLX,
3711         .parent    = &tegra_pll_x,
3712         .max_rate  = 850000000,
3713 };
3714
3715
3716 static struct clk_pll_freq_table tegra_pll_e_freq_table[] = {
3717         /* PLLE special case: use cpcon field to store cml divider value */
3718         { 12000000,  100000000, 150, 1,  18, 11},
3719         { 216000000, 100000000, 200, 18, 24, 13},
3720 #ifndef CONFIG_TEGRA_SILICON_PLATFORM
3721         { 13000000,  100000000, 200, 1,  26, 13},
3722 #endif
3723         { 0, 0, 0, 0, 0, 0 },
3724 };
3725
3726 static struct clk tegra_pll_e = {
3727         .name      = "pll_e",
3728         .flags     = PLL_ALT_MISC_REG,
3729         .ops       = &tegra_plle_ops,
3730         .reg       = 0xe8,
3731         .max_rate  = 100000000,
3732         .u.pll = {
3733                 .input_min = 12000000,
3734                 .input_max = 216000000,
3735                 .cf_min    = 12000000,
3736                 .cf_max    = 12000000,
3737                 .vco_min   = 1200000000,
3738                 .vco_max   = 2400000000U,
3739                 .freq_table = tegra_pll_e_freq_table,
3740                 .lock_delay = 300,
3741                 .fixed_rate = 100000000,
3742         },
3743 };
3744
3745 static struct clk tegra_cml0_clk = {
3746         .name      = "cml0",
3747         .parent    = &tegra_pll_e,
3748         .ops       = &tegra_cml_clk_ops,
3749         .reg       = PLLE_AUX,
3750         .max_rate  = 100000000,
3751         .u.periph  = {
3752                 .clk_num = 0,
3753         },
3754 };
3755
3756 static struct clk tegra_cml1_clk = {
3757         .name      = "cml1",
3758         .parent    = &tegra_pll_e,
3759         .ops       = &tegra_cml_clk_ops,
3760         .reg       = PLLE_AUX,
3761         .max_rate  = 100000000,
3762         .u.periph  = {
3763                 .clk_num   = 1,
3764         },
3765 };
3766
3767 static struct clk tegra_pciex_clk = {
3768         .name      = "pciex",
3769         .parent    = &tegra_pll_e,
3770         .ops       = &tegra_pciex_clk_ops,
3771         .max_rate  = 100000000,
3772         .u.periph  = {
3773                 .clk_num   = 74,
3774         },
3775 };
3776
3777 /* Audio sync clocks */
3778 #define SYNC_SOURCE(_id, _dev)                          \
3779         {                                               \
3780                 .name      = #_id "_sync",              \
3781                 .lookup    = {                          \
3782                         .dev_id    = #_dev ,            \
3783                         .con_id    = "ext_audio_sync",  \
3784                 },                                      \
3785                 .rate      = 24000000,                  \
3786                 .max_rate  = 24000000,                  \
3787                 .ops       = &tegra_sync_source_ops     \
3788         }
3789 static struct clk tegra_sync_source_list[] = {
3790         SYNC_SOURCE(spdif_in, tegra30-spdif),
3791         SYNC_SOURCE(i2s0, tegra30-i2s.0),
3792         SYNC_SOURCE(i2s1, tegra30-i2s.1),
3793         SYNC_SOURCE(i2s2, tegra30-i2s.2),
3794         SYNC_SOURCE(i2s3, tegra30-i2s.3),
3795         SYNC_SOURCE(i2s4, tegra30-i2s.4),
3796         SYNC_SOURCE(vimclk, vimclk),
3797 };
3798
3799 static struct clk_mux_sel mux_audio_sync_clk[] =
3800 {
3801         { .input = &tegra_sync_source_list[0],  .value = 0},
3802         { .input = &tegra_sync_source_list[1],  .value = 1},
3803         { .input = &tegra_sync_source_list[2],  .value = 2},
3804         { .input = &tegra_sync_source_list[3],  .value = 3},
3805         { .input = &tegra_sync_source_list[4],  .value = 4},
3806         { .input = &tegra_sync_source_list[5],  .value = 5},
3807         { .input = &tegra_pll_a_out0,           .value = 6},
3808         { .input = &tegra_sync_source_list[6],  .value = 7},
3809         { 0, 0 }
3810 };
3811
3812 #define AUDIO_SYNC_CLK(_id, _dev, _index)               \
3813         {                                               \
3814                 .name      = #_id,                      \
3815                 .lookup    = {                          \
3816                         .dev_id    = #_dev,             \
3817                         .con_id    = "audio_sync",      \
3818                 },                                      \
3819                 .inputs    = mux_audio_sync_clk,        \
3820                 .reg       = 0x4A0 + (_index) * 4,      \
3821                 .max_rate  = 24000000,                  \
3822                 .ops       = &tegra_audio_sync_clk_ops  \
3823         }
3824 static struct clk tegra_clk_audio_list[] = {
3825         AUDIO_SYNC_CLK(audio0, tegra30-i2s.0, 0),
3826         AUDIO_SYNC_CLK(audio1, tegra30-i2s.1, 1),
3827         AUDIO_SYNC_CLK(audio2, tegra30-i2s.2, 2),
3828         AUDIO_SYNC_CLK(audio3, tegra30-i2s.3, 3),
3829         AUDIO_SYNC_CLK(audio4, tegra30-i2s.4, 4),
3830         AUDIO_SYNC_CLK(audio, tegra30-spdif, 5),
3831 };
3832
3833 #define AUDIO_SYNC_2X_CLK(_id, _dev, _index)                    \
3834         {                                                       \
3835                 .name      = #_id "_2x",                        \
3836                 .lookup    = {                                  \
3837                         .dev_id    = #_dev,                     \
3838                         .con_id    = "audio_sync_2x"            \
3839                 },                                              \
3840                 .flags     = PERIPH_NO_RESET,                   \
3841                 .max_rate  = 48000000,                          \
3842                 .ops       = &tegra_clk_double_ops,             \
3843                 .reg       = 0x49C,                             \
3844                 .reg_shift = 24 + (_index),                     \
3845                 .parent    = &tegra_clk_audio_list[(_index)],   \
3846                 .u.periph = {                                   \
3847                         .clk_num = 113 + (_index),              \
3848                 },                                              \
3849         }
3850 static struct clk tegra_clk_audio_2x_list[] = {
3851         AUDIO_SYNC_2X_CLK(audio0, tegra30-i2s.0, 0),
3852         AUDIO_SYNC_2X_CLK(audio1, tegra30-i2s.1, 1),
3853         AUDIO_SYNC_2X_CLK(audio2, tegra30-i2s.2, 2),
3854         AUDIO_SYNC_2X_CLK(audio3, tegra30-i2s.3, 3),
3855         AUDIO_SYNC_2X_CLK(audio4, tegra30-i2s.4, 4),
3856         AUDIO_SYNC_2X_CLK(audio, tegra30-spdif, 5),
3857 };
3858
3859 #define MUX_I2S_SPDIF(_id, _index)                                      \
3860 static struct clk_mux_sel mux_pllaout0_##_id##_2x_pllp_clkm[] = {       \
3861         {.input = &tegra_pll_a_out0, .value = 0},                       \
3862         {.input = &tegra_clk_audio_2x_list[(_index)], .value = 1},      \
3863         {.input = &tegra_pll_p, .value = 2},                            \
3864         {.input = &tegra_clk_m, .value = 3},                            \
3865         { 0, 0},                                                        \
3866 }
3867 MUX_I2S_SPDIF(audio0, 0);
3868 MUX_I2S_SPDIF(audio1, 1);
3869 MUX_I2S_SPDIF(audio2, 2);
3870 MUX_I2S_SPDIF(audio3, 3);
3871 MUX_I2S_SPDIF(audio4, 4);
3872 MUX_I2S_SPDIF(audio, 5);                /* SPDIF */
3873
3874 /* External clock outputs (through PMC) */
3875 #define MUX_EXTERN_OUT(_id)                                             \
3876 static struct clk_mux_sel mux_clkm_clkm2_clkm4_extern##_id[] = {        \
3877         {.input = &tegra_clk_m,         .value = 0},                    \
3878         {.input = &tegra_clk_m_div2,    .value = 1},                    \
3879         {.input = &tegra_clk_m_div4,    .value = 2},                    \
3880         {.input = NULL,                 .value = 3}, /* placeholder */  \
3881         { 0, 0},                                                        \
3882 }
3883 MUX_EXTERN_OUT(1);
3884 MUX_EXTERN_OUT(2);
3885 MUX_EXTERN_OUT(3);
3886
3887 static struct clk_mux_sel *mux_extern_out_list[] = {
3888         mux_clkm_clkm2_clkm4_extern1,
3889         mux_clkm_clkm2_clkm4_extern2,
3890         mux_clkm_clkm2_clkm4_extern3,
3891 };
3892
3893 #define CLK_OUT_CLK(_id)                                        \
3894         {                                                       \
3895                 .name      = "clk_out_" #_id,                   \
3896                 .lookup    = {                                  \
3897                         .dev_id    = "clk_out_" #_id,           \
3898                         .con_id    = "extern" #_id,             \
3899                 },                                              \
3900                 .ops       = &tegra_clk_out_ops,                \
3901                 .reg       = 0x1a8,                             \
3902                 .inputs    = mux_clkm_clkm2_clkm4_extern##_id,  \
3903                 .flags     = MUX_CLK_OUT,                       \
3904                 .max_rate  = 216000000,                         \
3905                 .u.periph = {                                   \
3906                         .clk_num   = (_id - 1) * 8 + 2,         \
3907                 },                                              \
3908         }
3909 static struct clk tegra_clk_out_list[] = {
3910         CLK_OUT_CLK(1),
3911         CLK_OUT_CLK(2),
3912         CLK_OUT_CLK(3),
3913 };
3914
3915 /* called after peripheral external clocks are initialized */
3916 static void init_clk_out_mux(void)
3917 {
3918         int i;
3919         struct clk *c;
3920
3921         /* output clock con_id is the name of peripheral
3922            external clock connected to input 3 of the output mux */
3923         for (i = 0; i < ARRAY_SIZE(tegra_clk_out_list); i++) {
3924                 c = tegra_get_clock_by_name(
3925                         tegra_clk_out_list[i].lookup.con_id);
3926                 if (!c)
3927                         pr_err("%s: could not find clk %s\n", __func__,
3928                                tegra_clk_out_list[i].lookup.con_id);
3929                 mux_extern_out_list[i][3].input = c;
3930         }
3931 }
3932
3933 /* Peripheral muxes */
3934 static struct clk_mux_sel mux_cclk_g[] = {
3935         { .input = &tegra_clk_m,        .value = 0},
3936         { .input = &tegra_pll_c,        .value = 1},
3937         { .input = &tegra_clk_32k,      .value = 2},
3938         { .input = &tegra_pll_m,        .value = 3},
3939         { .input = &tegra_pll_p,        .value = 4},
3940         { .input = &tegra_pll_p_out4,   .value = 5},
3941         { .input = &tegra_pll_p_out3,   .value = 6},
3942         /* { .input = &tegra_clk_d,     .value = 7}, - no use on tegra3 */
3943         { .input = &tegra_pll_x,        .value = 8},
3944         { 0, 0},
3945 };
3946
3947 static struct clk_mux_sel mux_cclk_lp[] = {
3948         { .input = &tegra_clk_m,        .value = 0},
3949         { .input = &tegra_pll_c,        .value = 1},
3950         { .input = &tegra_clk_32k,      .value = 2},
3951         { .input = &tegra_pll_m,        .value = 3},
3952         { .input = &tegra_pll_p,        .value = 4},
3953         { .input = &tegra_pll_p_out4,   .value = 5},
3954         { .input = &tegra_pll_p_out3,   .value = 6},
3955         /* { .input = &tegra_clk_d,     .value = 7}, - no use on tegra3 */
3956         { .input = &tegra_pll_x_out0,   .value = 8},
3957         { .input = &tegra_pll_x,        .value = 8 | SUPER_LP_DIV2_BYPASS},
3958         { 0, 0},
3959 };
3960
3961 static struct clk_mux_sel mux_sclk[] = {
3962         { .input = &tegra_clk_m,        .value = 0},
3963         { .input = &tegra_pll_c_out1,   .value = 1},
3964         { .input = &tegra_pll_p_out4,   .value = 2},
3965         { .input = &tegra_pll_p_out3,   .value = 3},
3966         { .input = &tegra_pll_p_out2,   .value = 4},
3967         /* { .input = &tegra_clk_d,     .value = 5}, - no use on tegra3 */
3968         { .input = &tegra_clk_32k,      .value = 6},
3969         { .input = &tegra_pll_m_out1,   .value = 7},
3970         { 0, 0},
3971 };
3972
3973 static struct clk tegra_clk_cclk_g = {
3974         .name   = "cclk_g",
3975         .flags  = DIV_U71 | DIV_U71_INT,
3976         .inputs = mux_cclk_g,
3977         .reg    = 0x368,
3978         .ops    = &tegra_super_ops,
3979         .max_rate = 1700000000,
3980 };
3981
3982 static struct clk tegra_clk_cclk_lp = {
3983         .name   = "cclk_lp",
3984         .flags  = DIV_2 | DIV_U71 | DIV_U71_INT,
3985         .inputs = mux_cclk_lp,
3986         .reg    = 0x370,
3987         .ops    = &tegra_super_ops,
3988         .max_rate = 620000000,
3989 };
3990
3991 static struct clk tegra_clk_sclk = {
3992         .name   = "sclk",
3993         .inputs = mux_sclk,
3994         .reg    = 0x28,
3995         .ops    = &tegra_super_ops,
3996         .max_rate = 378000000,
3997         .min_rate = 12000000,
3998 };
3999
4000 static struct clk tegra_clk_virtual_cpu_g = {
4001         .name      = "cpu_g",
4002         .parent    = &tegra_clk_cclk_g,
4003         .ops       = &tegra_cpu_ops,
4004         .max_rate  = 1700000000,
4005         .u.cpu = {
4006                 .main      = &tegra_pll_x,
4007                 .backup    = &tegra_pll_p,
4008                 .mode      = MODE_G,
4009         },
4010 };
4011
4012 static struct clk tegra_clk_virtual_cpu_lp = {
4013         .name      = "cpu_lp",
4014         .parent    = &tegra_clk_cclk_lp,
4015         .ops       = &tegra_cpu_ops,
4016         .max_rate  = 620000000,
4017         .u.cpu = {
4018                 .main      = &tegra_pll_x,
4019                 .backup    = &tegra_pll_p,
4020                 .mode      = MODE_LP,
4021         },
4022 };
4023
4024 static struct clk_mux_sel mux_cpu_cmplx[] = {
4025         { .input = &tegra_clk_virtual_cpu_g,    .value = 0},
4026         { .input = &tegra_clk_virtual_cpu_lp,   .value = 1},
4027         { 0, 0},
4028 };
4029
4030 static struct clk tegra_clk_cpu_cmplx = {
4031         .name      = "cpu",
4032         .inputs    = mux_cpu_cmplx,
4033         .ops       = &tegra_cpu_cmplx_ops,
4034         .max_rate  = 1700000000,
4035 };
4036
4037 static struct clk tegra_clk_cop = {
4038         .name      = "cop",
4039         .parent    = &tegra_clk_sclk,
4040         .ops       = &tegra_cop_ops,
4041         .max_rate  = 378000000,
4042 };
4043
4044 static struct clk tegra_clk_hclk = {
4045         .name           = "hclk",
4046         .flags          = DIV_BUS,
4047         .parent         = &tegra_clk_sclk,
4048         .reg            = 0x30,
4049         .reg_shift      = 4,
4050         .ops            = &tegra_bus_ops,
4051         .max_rate       = 378000000,
4052         .min_rate       = 12000000,
4053 };
4054
4055 static struct clk tegra_clk_pclk = {
4056         .name           = "pclk",
4057         .flags          = DIV_BUS,
4058         .parent         = &tegra_clk_hclk,
4059         .reg            = 0x30,
4060         .reg_shift      = 0,
4061         .ops            = &tegra_bus_ops,
4062         .max_rate       = 167000000,
4063         .min_rate       = 12000000,
4064 };
4065
4066 static struct raw_notifier_head sbus_rate_change_nh;
4067
4068 static struct clk tegra_clk_sbus_cmplx = {
4069         .name      = "sbus",
4070         .parent    = &tegra_clk_sclk,
4071         .ops       = &tegra_sbus_cmplx_ops,
4072         .u.system  = {
4073                 .pclk = &tegra_clk_pclk,
4074                 .hclk = &tegra_clk_hclk,
4075                 .sclk_low = &tegra_pll_p_out4,
4076                 .sclk_high = &tegra_pll_m_out1,
4077         },
4078         .rate_change_nh = &sbus_rate_change_nh,
4079 };
4080
4081 static struct clk tegra_clk_blink = {
4082         .name           = "blink",
4083         .parent         = &tegra_clk_32k,
4084         .reg            = 0x40,
4085         .ops            = &tegra_blink_clk_ops,
4086         .max_rate       = 32768,
4087 };
4088
4089 static struct clk_mux_sel mux_pllm_pllc_pllp_plla[] = {
4090         { .input = &tegra_pll_m, .value = 0},
4091         { .input = &tegra_pll_c, .value = 1},
4092         { .input = &tegra_pll_p, .value = 2},
4093         { .input = &tegra_pll_a_out0, .value = 3},
4094         { 0, 0},
4095 };
4096
4097 static struct clk_mux_sel mux_pllm_pllc_pllp_clkm[] = {
4098         { .input = &tegra_pll_m, .value = 0},
4099         { .input = &tegra_pll_c, .value = 1},
4100         { .input = &tegra_pll_p, .value = 2},
4101         { .input = &tegra_clk_m, .value = 3},
4102         { 0, 0},
4103 };
4104
4105 static struct clk_mux_sel mux_pllp_pllc_pllm_clkm[] = {
4106         { .input = &tegra_pll_p, .value = 0},
4107         { .input = &tegra_pll_c, .value = 1},
4108 #ifndef CONFIG_TEGRA_PLLM_RESTRICTED
4109         { .input = &tegra_pll_m, .value = 2},
4110 #endif
4111         { .input = &tegra_clk_m, .value = 3},
4112         { 0, 0},
4113 };
4114
4115 static struct clk_mux_sel mux_pllp_clkm[] = {
4116         { .input = &tegra_pll_p, .value = 0},
4117         { .input = &tegra_clk_m, .value = 3},
4118         { 0, 0},
4119 };
4120
4121 static struct clk_mux_sel mux_pllp_plld_pllc_clkm[] = {
4122         {.input = &tegra_pll_p, .value = 0},
4123         {.input = &tegra_pll_d_out0, .value = 1},
4124         {.input = &tegra_pll_c, .value = 2},
4125         {.input = &tegra_clk_m, .value = 3},
4126         { 0, 0},
4127 };
4128
4129 static struct clk_mux_sel mux_pllp_pllm_plld_plla_pllc_plld2_clkm[] = {
4130         {.input = &tegra_pll_p, .value = 0},
4131 #ifndef CONFIG_TEGRA_PLLM_RESTRICTED
4132         {.input = &tegra_pll_m, .value = 1},
4133 #endif
4134         {.input = &tegra_pll_d_out0, .value = 2},
4135         {.input = &tegra_pll_a_out0, .value = 3},
4136         {.input = &tegra_pll_c, .value = 4},
4137         {.input = &tegra_pll_d2_out0, .value = 5},
4138         {.input = &tegra_clk_m, .value = 6},
4139         { 0, 0},
4140 };
4141
4142 static struct clk_mux_sel mux_plla_pllc_pllp_clkm[] = {
4143         { .input = &tegra_pll_a_out0, .value = 0},
4144         /* { .input = &tegra_pll_c, .value = 1}, no use on tegra3 */
4145         { .input = &tegra_pll_p, .value = 2},
4146         { .input = &tegra_clk_m, .value = 3},
4147         { 0, 0},
4148 };
4149
4150 static struct clk_mux_sel mux_pllp_pllc_clk32_clkm[] = {
4151         {.input = &tegra_pll_p,     .value = 0},
4152         {.input = &tegra_pll_c,     .value = 1},
4153         {.input = &tegra_clk_32k,   .value = 2},
4154         {.input = &tegra_clk_m,     .value = 3},
4155         { 0, 0},
4156 };
4157
4158 static struct clk_mux_sel mux_pllp_pllc_clkm_clk32[] = {
4159         {.input = &tegra_pll_p,     .value = 0},
4160         {.input = &tegra_pll_c,     .value = 1},
4161         {.input = &tegra_clk_m,     .value = 2},
4162         {.input = &tegra_clk_32k,   .value = 3},
4163         { 0, 0},
4164 };
4165
4166 static struct clk_mux_sel mux_pllp_pllc_pllm[] = {
4167         {.input = &tegra_pll_p,     .value = 0},
4168         {.input = &tegra_pll_c,     .value = 1},
4169 #ifndef CONFIG_TEGRA_PLLM_RESTRICTED
4170         {.input = &tegra_pll_m,     .value = 2},
4171 #endif
4172         { 0, 0},
4173 };
4174
4175 static struct clk_mux_sel mux_clk_m[] = {
4176         { .input = &tegra_clk_m, .value = 0},
4177         { 0, 0},
4178 };
4179
4180 static struct clk_mux_sel mux_pllp_out3[] = {
4181         { .input = &tegra_pll_p_out3, .value = 0},
4182         { 0, 0},
4183 };
4184
4185 static struct clk_mux_sel mux_plld_out0[] = {
4186         { .input = &tegra_pll_d_out0, .value = 0},
4187         { 0, 0},
4188 };
4189
4190 static struct clk_mux_sel mux_plld_out0_plld2_out0[] = {
4191         { .input = &tegra_pll_d_out0,  .value = 0},
4192         { .input = &tegra_pll_d2_out0, .value = 1},
4193         { 0, 0},
4194 };
4195
4196 static struct clk_mux_sel mux_clk_32k[] = {
4197         { .input = &tegra_clk_32k, .value = 0},
4198         { 0, 0},
4199 };
4200
4201 static struct clk_mux_sel mux_plla_clk32_pllp_clkm_plle[] = {
4202         { .input = &tegra_pll_a_out0, .value = 0},
4203         { .input = &tegra_clk_32k,    .value = 1},
4204         { .input = &tegra_pll_p,      .value = 2},
4205         { .input = &tegra_clk_m,      .value = 3},
4206         { .input = &tegra_pll_e,      .value = 4},
4207         { 0, 0},
4208 };
4209
4210 static struct raw_notifier_head emc_rate_change_nh;
4211
4212 static struct clk tegra_clk_emc = {
4213         .name = "emc",
4214         .ops = &tegra_emc_clk_ops,
4215         .reg = 0x19c,
4216         .max_rate = 900000000,
4217         .min_rate = 12000000,
4218         .inputs = mux_pllm_pllc_pllp_clkm,
4219         .flags = MUX | DIV_U71 | PERIPH_EMC_ENB,
4220         .u.periph = {
4221                 .clk_num = 57,
4222         },
4223         .shared_bus_backup = {
4224                 .input = &tegra_pll_c,
4225         },
4226         .rate_change_nh = &emc_rate_change_nh,
4227 };
4228
4229 static struct clk tegra_clk_emc_bridge = {
4230         .name      = "bridge.emc",
4231         .ops       = &tegra_clk_emc_bridge_ops,
4232         .parent    = &tegra_clk_emc,
4233 };
4234
4235 static RAW_NOTIFIER_HEAD(cbus_rate_change_nh);
4236
4237 static struct clk tegra_clk_cbus = {
4238         .name      = "cbus",
4239         .parent    = &tegra_pll_c,
4240         .ops       = &tegra_clk_cbus_ops,
4241         .max_rate  = 700000000,
4242         .mul       = 1,
4243         .div       = CONFIG_TEGRA_CBUS_CLOCK_DIVIDER,
4244         .flags     = PERIPH_ON_CBUS,
4245         .shared_bus_backup = {
4246                 .input = &tegra_pll_p,
4247                 .value = 2,
4248         },
4249         .rate_change_nh = &cbus_rate_change_nh,
4250 };
4251
4252 #define PERIPH_CLK(_name, _dev, _con, _clk_num, _reg, _max, _inputs, _flags) \
4253         {                                               \
4254                 .name      = _name,                     \
4255                 .lookup    = {                          \
4256                         .dev_id    = _dev,              \
4257                         .con_id    = _con,              \
4258                 },                                      \
4259                 .ops       = &tegra_periph_clk_ops,     \
4260                 .reg       = _reg,                      \
4261                 .inputs    = _inputs,                   \
4262                 .flags     = _flags,                    \
4263                 .max_rate  = _max,                      \
4264                 .u.periph = {                           \
4265                         .clk_num   = _clk_num,          \
4266                 },                                      \
4267         }
4268
4269 #define PERIPH_CLK_EX(_name, _dev, _con, _clk_num, _reg, _max, _inputs, \
4270                         _flags, _ops)                                   \
4271         {                                               \
4272                 .name      = _name,                     \
4273                 .lookup    = {                          \
4274                         .dev_id    = _dev,              \
4275                         .con_id    = _con,              \
4276                 },                                      \
4277                 .ops       = _ops,                      \
4278                 .reg       = _reg,                      \
4279                 .inputs    = _inputs,                   \
4280                 .flags     = _flags,                    \
4281                 .max_rate  = _max,                      \
4282                 .u.periph = {                           \
4283                         .clk_num   = _clk_num,          \
4284                 },                                      \
4285         }
4286
4287 #define SHARED_CLK(_name, _dev, _con, _parent, _id, _div, _mode)\
4288         {                                               \
4289                 .name      = _name,                     \
4290                 .lookup    = {                          \
4291                         .dev_id    = _dev,              \
4292                         .con_id    = _con,              \
4293                 },                                      \
4294                 .ops       = &tegra_clk_shared_bus_ops, \
4295                 .parent = _parent,                      \
4296                 .u.shared_bus_user = {                  \
4297                         .client_id = _id,               \
4298                         .client_div = _div,             \
4299                         .mode = _mode,                  \
4300                 },                                      \
4301         }
4302 struct clk tegra_list_clks[] = {
4303         PERIPH_CLK("apbdma",    "tegra-dma",            NULL,   34,     0,      26000000,  mux_clk_m,                   0),
4304         PERIPH_CLK("rtc",       "rtc-tegra",            NULL,   4,      0,      32768,     mux_clk_32k,                 PERIPH_NO_RESET | PERIPH_ON_APB),
4305         PERIPH_CLK("kbc",       "tegra-kbc",            NULL,   36,     0,      32768,     mux_clk_32k,                 PERIPH_NO_RESET | PERIPH_ON_APB),
4306         PERIPH_CLK("timer",     "timer",                NULL,   5,      0,      26000000,  mux_clk_m,                   0),
4307         PERIPH_CLK("kfuse",     "kfuse-tegra",          NULL,   40,     0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
4308         PERIPH_CLK("fuse",      "fuse-tegra",           "fuse", 39,     0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
4309         PERIPH_CLK("fuse_burn", "fuse-tegra",           "fuse_burn",    39,     0,      26000000,  mux_clk_m,           PERIPH_ON_APB),
4310         PERIPH_CLK("apbif",     "tegra30-ahub",         "apbif", 107,   0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
4311         PERIPH_CLK("i2s0",      "tegra30-i2s.0",        "i2s",  30,     0x1d8,  26000000,  mux_pllaout0_audio0_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4312         PERIPH_CLK("i2s1",      "tegra30-i2s.1",        "i2s",  11,     0x100,  26000000,  mux_pllaout0_audio1_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4313         PERIPH_CLK("i2s2",      "tegra30-i2s.2",        "i2s",  18,     0x104,  26000000,  mux_pllaout0_audio2_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4314         PERIPH_CLK("i2s3",      "tegra30-i2s.3",        "i2s",  101,    0x3bc,  26000000,  mux_pllaout0_audio3_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4315         PERIPH_CLK("i2s4",      "tegra30-i2s.4",        "i2s",  102,    0x3c0,  26000000,  mux_pllaout0_audio4_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4316         PERIPH_CLK("spdif_out", "tegra30-spdif",        "spdif_out",    10,     0x108,  26000000, mux_pllaout0_audio_2x_pllp_clkm,      MUX | DIV_U71 | PERIPH_ON_APB),
4317         PERIPH_CLK("spdif_in",  "tegra30-spdif",        "spdif_in",     10,     0x10c,  100000000, mux_pllp_pllc_pllm,          MUX | DIV_U71 | PERIPH_ON_APB),
4318         PERIPH_CLK("pwm",       "pwm",                  NULL,   17,     0x110,  408000000, mux_pllp_pllc_clk32_clkm,    MUX | MUX_PWM | DIV_U71 | PERIPH_ON_APB),
4319         PERIPH_CLK("d_audio",   "tegra30-ahub",         "d_audio", 106, 0x3d0,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4320         PERIPH_CLK("dam0",      "tegra30-dam.0",        NULL,   108,    0x3d8,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4321         PERIPH_CLK("dam1",      "tegra30-dam.1",        NULL,   109,    0x3dc,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4322         PERIPH_CLK("dam2",      "tegra30-dam.2",        NULL,   110,    0x3e0,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4323         PERIPH_CLK("hda",       "tegra30-hda",          "hda",   125,   0x428,  108000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4324         PERIPH_CLK("hda2codec_2x",      "tegra30-hda",  "hda2codec",   111,     0x3e4,  48000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4325         PERIPH_CLK("hda2hdmi",  "tegra30-hda",          "hda2hdmi",     128,    0,      48000000,  mux_clk_m,                   PERIPH_ON_APB),
4326         PERIPH_CLK("sbc1",      "spi_tegra.0",          "spi",  41,     0x134,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4327         PERIPH_CLK("sbc2",      "spi_tegra.1",          "spi",  44,     0x118,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4328         PERIPH_CLK("sbc3",      "spi_tegra.2",          "spi",  46,     0x11c,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4329         PERIPH_CLK("sbc4",      "spi_tegra.3",          "spi",  68,     0x1b4,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4330         PERIPH_CLK("sbc5",      "spi_tegra.4",          "spi",  104,    0x3c8,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4331         PERIPH_CLK("sbc6",      "spi_tegra.5",          "spi",  105,    0x3cc,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4332         PERIPH_CLK("sata_oob",  "tegra_sata_oob",       NULL,   123,    0x420,  216000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4333         PERIPH_CLK("sata",      "tegra_sata",           NULL,   124,    0x424,  216000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4334         PERIPH_CLK("sata_cold", "tegra_sata_cold",      NULL,   129,    0,      48000000,  mux_clk_m,                   PERIPH_ON_APB),
4335         PERIPH_CLK_EX("ndflash", "tegra_nand",          NULL,   13,     0x160,  240000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB,  &tegra_nand_clk_ops),
4336         PERIPH_CLK("ndspeed",   "tegra_nand_speed",     NULL,   80,     0x3f8,  240000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4337         PERIPH_CLK("vfir",      "vfir",                 NULL,   7,      0x168,  72000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4338         PERIPH_CLK("sdmmc1",    "sdhci-tegra.0",        NULL,   14,     0x150,  208000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4339         PERIPH_CLK("sdmmc2",    "sdhci-tegra.1",        NULL,   9,      0x154,   50000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4340         PERIPH_CLK("sdmmc3",    "sdhci-tegra.2",        NULL,   69,     0x1bc,  208000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4341         PERIPH_CLK("sdmmc4",    "sdhci-tegra.3",        NULL,   15,     0x164,  102000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4342         PERIPH_CLK("vcp",       "tegra-avp",            "vcp",  29,     0,      250000000, mux_clk_m,                   0),
4343         PERIPH_CLK("bsea",      "tegra-avp",            "bsea", 62,     0,      250000000, mux_clk_m,                   0),
4344         PERIPH_CLK("bsev",      "tegra-aes",            "bsev", 63,     0,      250000000, mux_clk_m,                   0),
4345         PERIPH_CLK("cec",       "tegra_cec",            NULL,   136,    0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
4346         PERIPH_CLK("vde",       "vde",                  NULL,   61,     0x1c8,  600000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | DIV_U71_INT),
4347         PERIPH_CLK("csite",     "csite",                NULL,   73,     0x1d4,  144000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB), /* max rate ??? */
4348         PERIPH_CLK("la",        "la",                   NULL,   76,     0x1f8,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4349         PERIPH_CLK("owr",       "tegra_w1",             NULL,   71,     0x1cc,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4350         PERIPH_CLK("nor",       "tegra-nor",            NULL,   42,     0x1d0,  127000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* requires min voltage */
4351         PERIPH_CLK("mipi",      "mipi",                 NULL,   50,     0x174,  60000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB), /* scales with voltage */
4352         PERIPH_CLK("i2c1",      "tegra-i2c.0",          "div-clk",      12,     0x124,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4353         PERIPH_CLK("i2c2",      "tegra-i2c.1",          "div-clk",      54,     0x198,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4354         PERIPH_CLK("i2c3",      "tegra-i2c.2",          "div-clk",      67,     0x1b8,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4355         PERIPH_CLK("i2c4",      "tegra-i2c.3",          "div-clk",      103,    0x3c4,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4356         PERIPH_CLK("i2c5",      "tegra-i2c.4",          "div-clk",      47,     0x128,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4357         PERIPH_CLK("i2c1-fast", "tegra-i2c.0",          "fast-clk",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4358         PERIPH_CLK("i2c2-fast", "tegra-i2c.1",          "fast-clk",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4359         PERIPH_CLK("i2c3-fast", "tegra-i2c.2",          "fast-clk",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4360         PERIPH_CLK("i2c4-fast", "tegra-i2c.3",          "fast-clk",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4361         PERIPH_CLK("i2c5-fast", "tegra-i2c.4",          "fast-clk",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4362         PERIPH_CLK("uarta",     "tegra_uart.0",         NULL,   6,      0x178,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4363         PERIPH_CLK("uartb",     "tegra_uart.1",         NULL,   7,      0x17c,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4364         PERIPH_CLK("uartc",     "tegra_uart.2",         NULL,   55,     0x1a0,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4365         PERIPH_CLK("uartd",     "tegra_uart.3",         NULL,   65,     0x1c0,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4366         PERIPH_CLK("uarte",     "tegra_uart.4",         NULL,   66,     0x1c4,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4367         PERIPH_CLK("uarta_dbg", "serial8250.0",         "uarta", 6,     0x178,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4368         PERIPH_CLK("uartb_dbg", "serial8250.0",         "uartb", 7,     0x17c,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4369         PERIPH_CLK("uartc_dbg", "serial8250.0",         "uartc", 55,    0x1a0,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4370         PERIPH_CLK("uartd_dbg", "serial8250.0",         "uartd", 65,    0x1c0,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4371         PERIPH_CLK("uarte_dbg", "serial8250.0",         "uarte", 66,    0x1c4,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4372         PERIPH_CLK_EX("vi",     "tegra_camera",         "vi",   20,     0x148,  470000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT,    &tegra_vi_clk_ops),
4373         PERIPH_CLK("vi_sensor", "tegra_camera",         "vi_sensor",    20,     0x1a8,  150000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_NO_RESET),
4374         PERIPH_CLK("3d",        "3d",                   NULL,   24,     0x158,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT | DIV_U71_IDLE | PERIPH_MANUAL_RESET),
4375         PERIPH_CLK("3d2",       "3d2",                  NULL,   98,     0x3b0,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT | DIV_U71_IDLE | PERIPH_MANUAL_RESET),
4376         PERIPH_CLK("2d",        "2d",                   NULL,   21,     0x15c,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT | DIV_U71_IDLE),
4377         PERIPH_CLK("epp",       "epp",                  NULL,   19,     0x16c,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT),
4378         PERIPH_CLK("mpe",       "mpe",                  NULL,   60,     0x170,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT),
4379         PERIPH_CLK("host1x",    "host1x",               NULL,   28,     0x180,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT),
4380         PERIPH_CLK("cve",       "cve",                  NULL,   49,     0x140,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
4381         PERIPH_CLK("tvo",       "tvo",                  NULL,   49,     0x188,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
4382         PERIPH_CLK_EX("dtv",    "dtv",                  NULL,   79,     0x1dc,  250000000, mux_clk_m,                   PERIPH_ON_APB,  &tegra_dtv_clk_ops),
4383         PERIPH_CLK("hdmi",      "hdmi",                 NULL,   51,     0x18c,  148500000, mux_pllp_pllm_plld_plla_pllc_plld2_clkm,     MUX | MUX8 | DIV_U71),
4384         PERIPH_CLK("tvdac",     "tvdac",                NULL,   53,     0x194,  220000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
4385         PERIPH_CLK("disp1",     "tegradc.0",            NULL,   27,     0x138,  600000000, mux_pllp_pllm_plld_plla_pllc_plld2_clkm,     MUX | MUX8),
4386         PERIPH_CLK("disp2",     "tegradc.1",            NULL,   26,     0x13c,  600000000, mux_pllp_pllm_plld_plla_pllc_plld2_clkm,     MUX | MUX8),
4387         PERIPH_CLK("usbd",      "tegra-udc.0",  NULL,   22,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
4388         PERIPH_CLK("usb2",      "tegra-ehci.1",         NULL,   58,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
4389         PERIPH_CLK("usb3",      "tegra-ehci.2",         NULL,   59,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
4390         PERIPH_CLK("dsia",      "tegradc.0",            "dsia", 48,     0,      500000000, mux_plld_out0,               0),
4391         PERIPH_CLK_EX("dsib",   "tegradc.1",            "dsib", 82,     0xd0,   500000000, mux_plld_out0_plld2_out0,    MUX | PLLD,     &tegra_dsib_clk_ops),
4392         PERIPH_CLK("dsi1-fixed", "tegradc.0",           "dsi-fixed",    0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4393         PERIPH_CLK("dsi2-fixed", "tegradc.1",           "dsi-fixed",    0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4394         PERIPH_CLK("csi",       "tegra_camera",         "csi",  52,     0,      102000000, mux_pllp_out3,               0),
4395         PERIPH_CLK("isp",       "tegra_camera",         "isp",  23,     0,      150000000, mux_clk_m,                   0), /* same frequency as VI */
4396         PERIPH_CLK("csus",      "tegra_camera",         "csus", 92,     0,      150000000, mux_clk_m,                   PERIPH_NO_RESET),
4397
4398         PERIPH_CLK("tsensor",   "tegra-tsensor",        NULL,   100,    0x3b8,  216000000, mux_pllp_pllc_clkm_clk32,    MUX | DIV_U71 | PERIPH_ON_APB),
4399         PERIPH_CLK("actmon",    "actmon",               NULL,   119,    0x3e8,  216000000, mux_pllp_pllc_clk32_clkm,    MUX | DIV_U71),
4400         PERIPH_CLK("extern1",   "extern1",              NULL,   120,    0x3ec,  216000000, mux_plla_clk32_pllp_clkm_plle,       MUX | MUX8 | DIV_U71),
4401         PERIPH_CLK("extern2",   "extern2",              NULL,   121,    0x3f0,  216000000, mux_plla_clk32_pllp_clkm_plle,       MUX | MUX8 | DIV_U71),
4402         PERIPH_CLK("extern3",   "extern3",              NULL,   122,    0x3f4,  216000000, mux_plla_clk32_pllp_clkm_plle,       MUX | MUX8 | DIV_U71),
4403         PERIPH_CLK("i2cslow",   "i2cslow",              NULL,   81,     0x3fc,  26000000,  mux_pllp_pllc_clk32_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4404         PERIPH_CLK("pcie",      "tegra-pcie",           "pcie", 70,     0,      250000000, mux_clk_m,                   0),
4405         PERIPH_CLK("afi",       "tegra-pcie",           "afi",  72,     0,      250000000, mux_clk_m,                   0),
4406         PERIPH_CLK("se",        "se",                   NULL,   127,    0x42c,  625000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | DIV_U71_INT | PERIPH_ON_APB),
4407         PERIPH_CLK("mselect",   "mselect",              NULL,   99,     0x3b4,  108000000, mux_pllp_clkm,               MUX | DIV_U71),
4408
4409         SHARED_CLK("avp.sclk",  "tegra-avp",            "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4410         SHARED_CLK("bsea.sclk", "tegra-aes",            "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4411         SHARED_CLK("usbd.sclk", "tegra-udc.0",  "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4412         SHARED_CLK("usb1.sclk", "tegra-ehci.0",         "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4413         SHARED_CLK("usb2.sclk", "tegra-ehci.1",         "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4414         SHARED_CLK("usb3.sclk", "tegra-ehci.2",         "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4415         SHARED_CLK("wake.sclk", "wake_sclk",            "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4416         SHARED_CLK("cpu_mode.sclk","cpu_mode",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4417         SHARED_CLK("mon.avp",   "tegra_actmon",         "avp",  &tegra_clk_sbus_cmplx, NULL, 0, 0),
4418         SHARED_CLK("cap.sclk",  "cap_sclk",             NULL,   &tegra_clk_sbus_cmplx, NULL, 0, SHARED_CEILING),
4419         SHARED_CLK("floor.sclk", "floor_sclk",          NULL,   &tegra_clk_sbus_cmplx, NULL, 0, 0),
4420         SHARED_CLK("sbc1.sclk", "spi_tegra.0",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4421         SHARED_CLK("sbc2.sclk", "spi_tegra.1",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4422         SHARED_CLK("sbc3.sclk", "spi_tegra.2",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4423         SHARED_CLK("sbc4.sclk", "spi_tegra.3",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4424         SHARED_CLK("sbc5.sclk", "spi_tegra.4",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4425         SHARED_CLK("sbc6.sclk", "spi_tegra.5",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4426
4427         SHARED_CLK("avp.emc",   "tegra-avp",            "emc",  &tegra_clk_emc, NULL, 0, 0),
4428         SHARED_CLK("cpu.emc",   "cpu",                  "emc",  &tegra_clk_emc, NULL, 0, 0),
4429         SHARED_CLK("disp1.emc", "tegradc.0",            "emc",  &tegra_clk_emc, NULL, 0, SHARED_BW),
4430         SHARED_CLK("disp2.emc", "tegradc.1",            "emc",  &tegra_clk_emc, NULL, 0, SHARED_BW),
4431         SHARED_CLK("hdmi.emc",  "hdmi",                 "emc",  &tegra_clk_emc, NULL, 0, 0),
4432         SHARED_CLK("usbd.emc",  "tegra-udc.0",  "emc",  &tegra_clk_emc, NULL, 0, 0),
4433         SHARED_CLK("usb1.emc",  "tegra-ehci.0",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4434         SHARED_CLK("usb2.emc",  "tegra-ehci.1",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4435         SHARED_CLK("usb3.emc",  "tegra-ehci.2",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4436         SHARED_CLK("mon.emc",   "tegra_actmon",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4437         SHARED_CLK("cap.emc",   "cap.emc",              NULL,   &tegra_clk_emc, NULL, 0, SHARED_CEILING),
4438         SHARED_CLK("3d.emc",    "tegra_gr3d",           "emc",  &tegra_clk_emc, NULL, 0, 0),
4439         SHARED_CLK("2d.emc",    "tegra_gr2d",           "emc",  &tegra_clk_emc, NULL, 0, 0),
4440         SHARED_CLK("mpe.emc",   "tegra_mpe",            "emc",  &tegra_clk_emc, NULL, 0, 0),
4441         SHARED_CLK("camera.emc", "tegra_camera",        "emc",  &tegra_clk_emc, NULL, 0, SHARED_BW),
4442         SHARED_CLK("sdmmc4.emc", "sdhci-tegra.3",       "emc",  &tegra_clk_emc, NULL, 0, 0),
4443         SHARED_CLK("floor.emc", "floor.emc",            NULL,   &tegra_clk_emc, NULL, 0, 0),
4444
4445         SHARED_CLK("host1x.cbus", "tegra_host1x",       "host1x", &tegra_clk_cbus, "host1x", 2, SHARED_AUTO),
4446         SHARED_CLK("3d.cbus",   "tegra_gr3d",           "gr3d", &tegra_clk_cbus, "3d",  0, 0),
4447         SHARED_CLK("3d2.cbus",  "tegra_gr3d",           "gr3d2", &tegra_clk_cbus, "3d2", 0, 0),
4448         SHARED_CLK("2d.cbus",   "tegra_gr2d",           "gr2d", &tegra_clk_cbus, "2d",  0, 0),
4449         SHARED_CLK("epp.cbus",  "tegra_gr2d",           "epp",  &tegra_clk_cbus, "epp", 0, 0),
4450         SHARED_CLK("mpe.cbus",  "tegra_mpe",            "mpe",  &tegra_clk_cbus, "mpe", 0, 0),
4451         SHARED_CLK("vde.cbus",  "tegra-avp",            "vde",  &tegra_clk_cbus, "vde", 0, 0),
4452 #ifdef CONFIG_TEGRA_SE_ON_CBUS
4453         SHARED_CLK("se.cbus",   "tegra-se",             NULL,   &tegra_clk_cbus, "se",  0, 0),
4454 #endif
4455         SHARED_CLK("cap.cbus",  "cap.cbus",             NULL,   &tegra_clk_cbus, NULL,  0, SHARED_CEILING),
4456         SHARED_CLK("cap.profile.cbus", "profile.cbus",  NULL,   &tegra_clk_cbus, NULL,  0, SHARED_CEILING),
4457         SHARED_CLK("floor.cbus", "floor.cbus",          NULL,   &tegra_clk_cbus, NULL,  0, 0),
4458 };
4459
4460 #define CLK_DUPLICATE(_name, _dev, _con)                \
4461         {                                               \
4462                 .name   = _name,                        \
4463                 .lookup = {                             \
4464                         .dev_id = _dev,                 \
4465                         .con_id         = _con,         \
4466                 },                                      \
4467         }
4468
4469 /* Some clocks may be used by different drivers depending on the board
4470  * configuration.  List those here to register them twice in the clock lookup
4471  * table under two names.
4472  */
4473 struct clk_duplicate tegra_clk_duplicates[] = {
4474         CLK_DUPLICATE("usbd", "utmip-pad", NULL),
4475         CLK_DUPLICATE("usbd", "tegra-ehci.0", NULL),
4476         CLK_DUPLICATE("usbd", "tegra-otg", NULL),
4477         CLK_DUPLICATE("hdmi", "tegradc.0", "hdmi"),
4478         CLK_DUPLICATE("hdmi", "tegradc.1", "hdmi"),
4479         CLK_DUPLICATE("dsib", "tegradc.0", "dsib"),
4480         CLK_DUPLICATE("dsia", "tegradc.1", "dsia"),
4481         CLK_DUPLICATE("pwm", "tegra_pwm.0", NULL),
4482         CLK_DUPLICATE("pwm", "tegra_pwm.1", NULL),
4483         CLK_DUPLICATE("pwm", "tegra_pwm.2", NULL),
4484         CLK_DUPLICATE("pwm", "tegra_pwm.3", NULL),
4485         CLK_DUPLICATE("cop", "tegra-avp", "cop"),
4486         CLK_DUPLICATE("bsev", "tegra-avp", "bsev"),
4487         CLK_DUPLICATE("cop", "nvavp", "cop"),
4488         CLK_DUPLICATE("bsev", "nvavp", "bsev"),
4489         CLK_DUPLICATE("vde", "tegra-aes", "vde"),
4490         CLK_DUPLICATE("bsea", "tegra-aes", "bsea"),
4491         CLK_DUPLICATE("bsea", "nvavp", "bsea"),
4492         CLK_DUPLICATE("cml1", "tegra_sata_cml", NULL),
4493         CLK_DUPLICATE("cml0", "tegra_pcie", "cml"),
4494         CLK_DUPLICATE("pciex", "tegra_pcie", "pciex"),
4495         CLK_DUPLICATE("i2c1", "tegra-i2c-slave.0", NULL),
4496         CLK_DUPLICATE("i2c2", "tegra-i2c-slave.1", NULL),
4497         CLK_DUPLICATE("i2c3", "tegra-i2c-slave.2", NULL),
4498         CLK_DUPLICATE("i2c4", "tegra-i2c-slave.3", NULL),
4499         CLK_DUPLICATE("i2c5", "tegra-i2c-slave.4", NULL),
4500         CLK_DUPLICATE("sbc1", "spi_slave_tegra.0", NULL),
4501         CLK_DUPLICATE("sbc2", "spi_slave_tegra.1", NULL),
4502         CLK_DUPLICATE("sbc3", "spi_slave_tegra.2", NULL),
4503         CLK_DUPLICATE("sbc4", "spi_slave_tegra.3", NULL),
4504         CLK_DUPLICATE("sbc5", "spi_slave_tegra.4", NULL),
4505         CLK_DUPLICATE("sbc6", "spi_slave_tegra.5", NULL),
4506         CLK_DUPLICATE("twd", "smp_twd", NULL),
4507         CLK_DUPLICATE("vcp", "nvavp", "vcp"),
4508         CLK_DUPLICATE("avp.sclk", "nvavp", "sclk"),
4509         CLK_DUPLICATE("avp.emc", "nvavp", "emc"),
4510         CLK_DUPLICATE("vde.cbus", "nvavp", "vde"),
4511         CLK_DUPLICATE("epp.cbus", "tegra_isp", "epp"),
4512 };
4513
4514 struct clk *tegra_ptr_clks[] = {
4515         &tegra_clk_32k,
4516         &tegra_clk_m,
4517         &tegra_clk_m_div2,
4518         &tegra_clk_m_div4,
4519         &tegra_pll_ref,
4520         &tegra_pll_m,
4521         &tegra_pll_m_out1,
4522         &tegra_pll_c,
4523         &tegra_pll_c_out1,
4524         &tegra_pll_p,
4525         &tegra_pll_p_out1,
4526         &tegra_pll_p_out2,
4527         &tegra_pll_p_out3,
4528         &tegra_pll_p_out4,
4529         &tegra_pll_a,
4530         &tegra_pll_a_out0,
4531         &tegra_pll_d,
4532         &tegra_pll_d_out0,
4533         &tegra_pll_d2,
4534         &tegra_pll_d2_out0,
4535         &tegra_pll_u,
4536         &tegra_pll_x,
4537         &tegra_pll_x_out0,
4538         &tegra_pll_e,
4539         &tegra_cml0_clk,
4540         &tegra_cml1_clk,
4541         &tegra_pciex_clk,
4542         &tegra_clk_cclk_g,
4543         &tegra_clk_cclk_lp,
4544         &tegra_clk_sclk,
4545         &tegra_clk_hclk,
4546         &tegra_clk_pclk,
4547         &tegra_clk_virtual_cpu_g,
4548         &tegra_clk_virtual_cpu_lp,
4549         &tegra_clk_cpu_cmplx,
4550         &tegra_clk_blink,
4551         &tegra_clk_cop,
4552         &tegra_clk_sbus_cmplx,
4553         &tegra_clk_emc,
4554         &tegra3_clk_twd,
4555         &tegra_clk_emc_bridge,
4556         &tegra_clk_cbus,
4557 };
4558
4559 static int tegra3_emc_relock_set_rate(struct clk *emc, unsigned long old_rate,
4560         unsigned long new_rate, unsigned long new_pll_rate)
4561 {
4562         int ret;
4563
4564         struct clk *sbus = &tegra_clk_sbus_cmplx;
4565         struct clk *cbus = &tegra_clk_cbus;
4566         struct clk *pll_m = &tegra_pll_m;
4567         unsigned long backup_rate = emc->shared_bus_backup.bus_rate;
4568         unsigned long flags;
4569
4570         bool on_pllm = emc->parent == pll_m;
4571
4572         /*
4573          * Relock procedure pre-conditions:
4574          * - LPDDR2 only
4575          * - EMC clock is enabled, and EMC backup rate is found in DFS table
4576          * - All 3 shared buses: emc, sbus, cbus can sleep
4577          */
4578         if ((tegra_emc_get_dram_type() != DRAM_TYPE_LPDDR2) || !emc->refcnt ||
4579             !backup_rate || (cbus->parent != emc->shared_bus_backup.input) ||
4580             !clk_cansleep(emc) || !clk_cansleep(cbus) || !clk_cansleep(sbus))
4581                 return -ENOSYS;
4582
4583         /* Move sbus from PLLM by setting it at low rate threshold level */
4584         clk_lock_save(sbus, &flags);
4585         if (clk_get_rate_locked(sbus) > sbus->u.system.threshold) {
4586                 ret = clk_set_rate_locked(sbus, sbus->u.system.threshold);
4587                 if (ret)
4588                         goto _sbus_out;
4589         }
4590
4591         /* If PLLM is current EMC parent set cbus to backup rate, and move EMC
4592            to backup PLLC */
4593         if (on_pllm) {
4594                 clk_lock_save(cbus, &flags);
4595                 clk_enable(cbus->parent);
4596                 ret = clk_set_rate_locked(cbus, backup_rate);
4597                 if (ret) {
4598                         clk_disable(cbus->parent);
4599                         goto _cbus_out;
4600                 }
4601
4602                 ret = tegra_emc_backup(backup_rate);
4603                 if (ret) {
4604                         clk_disable(cbus->parent);
4605                         goto _cbus_out;
4606                 }
4607                 clk_disable(emc->parent);
4608                 clk_reparent(emc, cbus->parent);
4609         }
4610
4611         /*
4612          * Re-lock PLLM and switch EMC to it; relocking error indicates that
4613          * PLLM has some other than EMC or sbus client. In this case PLLM has
4614          * not been changed, and we still can safely switch back. Recursive
4615          * tegra3_emc_clk_set_rate() call below will be resolved, since PLLM
4616          * is now matching target rate.
4617          */
4618         ret = clk_set_rate(pll_m, new_pll_rate);
4619         if (ret) {
4620                 if (on_pllm)
4621                         tegra3_emc_clk_set_rate(emc, old_rate);
4622         } else
4623                 ret = tegra3_emc_clk_set_rate(emc, new_rate);
4624
4625
4626 _cbus_out:
4627         if (on_pllm) {
4628                 tegra3_clk_shared_bus_update(cbus);
4629                 clk_unlock_restore(cbus, &flags);
4630         }
4631
4632 _sbus_out:
4633         tegra3_clk_shared_bus_update(sbus);
4634         clk_unlock_restore(sbus, &flags);
4635
4636         return ret;
4637 }
4638
4639 /*
4640  * Backup rate targets for each CPU mode is selected below Fmax(Vmin), and
4641  * high enough to avoid voltage droop when CPU clock is switched between
4642  * backup and main clock sources. Actual backup rates will be rounded based
4643  * on backup source fixed frequency. Maximum stay-on-backup rate will be set
4644  * as a minimum of G and LP backup rates to be supported in both modes.
4645  *
4646  * Sbus threshold must be exact factor of pll_p rate.
4647  */
4648 #define CPU_G_BACKUP_RATE_TARGET        440000000
4649 #define CPU_LP_BACKUP_RATE_TARGET       220000000
4650
4651 static void tegra3_pllp_init_dependencies(unsigned long pllp_rate)
4652 {
4653         u32 div;
4654         unsigned long backup_rate;
4655
4656         switch (pllp_rate) {
4657         case 216000000:
4658                 tegra_pll_p_out1.u.pll_div.default_rate = 28800000;
4659                 tegra_pll_p_out3.u.pll_div.default_rate = 72000000;
4660                 tegra_clk_sbus_cmplx.u.system.threshold = 108000000;
4661                 break;
4662         case 408000000:
4663                 tegra_pll_p_out1.u.pll_div.default_rate = 9600000;
4664                 tegra_pll_p_out3.u.pll_div.default_rate = 102000000;
4665                 tegra_clk_sbus_cmplx.u.system.threshold = 204000000;
4666                 break;
4667         case 204000000:
4668                 tegra_pll_p_out1.u.pll_div.default_rate = 4800000;
4669                 tegra_pll_p_out3.u.pll_div.default_rate = 102000000;
4670                 tegra_clk_sbus_cmplx.u.system.threshold = 204000000;
4671                 break;
4672         default:
4673                 pr_err("tegra: PLLP rate: %lu is not supported\n", pllp_rate);
4674                 BUG();
4675         }
4676         pr_info("tegra: PLLP fixed rate: %lu\n", pllp_rate);
4677
4678         div = DIV_ROUND_UP(pllp_rate, CPU_G_BACKUP_RATE_TARGET);
4679         backup_rate = pllp_rate / div;
4680         tegra_clk_cclk_g.u.cclk.div71 = 2 * div - 2;
4681         tegra_clk_virtual_cpu_g.u.cpu.backup_rate = backup_rate;
4682         cpu_stay_on_backup_max = backup_rate;
4683
4684         div = DIV_ROUND_UP(pllp_rate, CPU_LP_BACKUP_RATE_TARGET);
4685         backup_rate = pllp_rate / div;
4686         tegra_clk_cclk_lp.u.cclk.div71 = 2 * div - 2;
4687         tegra_clk_virtual_cpu_lp.u.cpu.backup_rate = backup_rate;
4688         cpu_stay_on_backup_max = min(cpu_stay_on_backup_max, backup_rate);
4689 }
4690
4691 bool tegra_clk_is_parent_allowed(struct clk *c, struct clk *p)
4692 {
4693         if (c->flags & PERIPH_ON_CBUS)
4694                 return p != &tegra_pll_m;
4695         else
4696                 return p != &tegra_pll_c;
4697
4698         return true;
4699 }
4700
4701 static void tegra3_init_one_clock(struct clk *c)
4702 {
4703         clk_init(c);
4704         INIT_LIST_HEAD(&c->shared_bus_list);
4705         if (!c->lookup.dev_id && !c->lookup.con_id)
4706                 c->lookup.con_id = c->name;
4707         c->lookup.clk = c;
4708         clkdev_add(&c->lookup);
4709 }
4710
4711 /*
4712  * Emergency throttle of G-CPU by setting G-super clock skipper underneath
4713  * clock framework, dvfs, and cpufreq driver s/w layers. Can be called in
4714  * ISR context for EDP events. When releasing throttle, LP-divider is cleared
4715  * just in case it was set as a result of save/restore operations across
4716  * cluster switch (should not happen)
4717  */
4718 void tegra_edp_throttle_cpu_now(u8 factor)
4719 {
4720         if (factor > 1) {
4721                 if (!is_lp_cluster())
4722                         tegra3_super_clk_skipper_update(
4723                                 &tegra_clk_cclk_g, 1, factor);
4724         } else if (factor == 0) {
4725                 tegra3_super_clk_skipper_update(&tegra_clk_cclk_g, 0, 0);
4726                 tegra3_super_clk_skipper_update(&tegra_clk_cclk_lp, 0, 0);
4727         }
4728 }
4729
4730 #ifdef CONFIG_CPU_FREQ
4731
4732 /*
4733  * Frequency table index must be sequential starting at 0 and frequencies
4734  * must be ascending. Re-configurable PLLX is used as a source for rates
4735  * above 204MHz. Rates 204MHz and below are divided down from fixed frequency
4736  * PLLP that may run either at 408MHz or at 204MHz on Tegra3 silicon platforms
4737  * (on FPGA platform PLLP output is reported as 216MHz, but no respective
4738  * tables are provided, since there is no clock scaling on FPGA at all).
4739  */
4740
4741 static struct cpufreq_frequency_table freq_table_300MHz[] = {
4742         { 0, 204000 },
4743         { 1, 300000 },
4744         { 2, CPUFREQ_TABLE_END },
4745 };
4746
4747 static struct cpufreq_frequency_table freq_table_1p0GHz[] = {
4748         { 0,  51000 },
4749         { 1, 102000 },
4750         { 2, 204000 },
4751         { 3, 312000 },
4752         { 4, 456000 },
4753         { 5, 608000 },
4754         { 6, 760000 },
4755         { 7, 816000 },
4756         { 8, 912000 },
4757         { 9, 1000000 },
4758         {10, CPUFREQ_TABLE_END },
4759 };
4760
4761 static struct cpufreq_frequency_table freq_table_1p3GHz[] = {
4762         { 0,   51000 },
4763         { 1,  102000 },
4764         { 2,  204000 },
4765         { 3,  340000 },
4766         { 4,  475000 },
4767         { 5,  640000 },
4768         { 6,  760000 },
4769         { 7,  860000 },
4770         { 8, 1000000 },
4771         { 9, 1100000 },
4772         {10, 1200000 },
4773         {11, 1300000 },
4774         {12, CPUFREQ_TABLE_END },
4775 };
4776
4777 static struct cpufreq_frequency_table freq_table_1p4GHz[] = {
4778         { 0,   51000 },
4779         { 1,  102000 },
4780         { 2,  204000 },
4781         { 3,  370000 },
4782         { 4,  475000 },
4783         { 5,  620000 },
4784         { 6,  760000 },
4785         { 7,  860000 },
4786         { 8, 1000000 },
4787         { 9, 1100000 },
4788         {10, 1200000 },
4789         {11, 1300000 },
4790         {12, 1400000 },
4791         {13, CPUFREQ_TABLE_END },
4792 };
4793
4794 static struct cpufreq_frequency_table freq_table_1p5GHz[] = {
4795         { 0,   51000 },
4796         { 1,  102000 },
4797         { 2,  204000 },
4798         { 3,  340000 },
4799         { 4,  475000 },
4800         { 5,  640000 },
4801         { 6,  760000 },
4802         { 7,  860000 },
4803         { 8, 1000000 },
4804         { 9, 1100000 },
4805         {10, 1200000 },
4806         {11, 1300000 },
4807         {12, 1400000 },
4808         {13, 1500000 },
4809         {14, CPUFREQ_TABLE_END },
4810 };
4811
4812 static struct cpufreq_frequency_table freq_table_1p7GHz[] = {
4813         { 0,   51000 },
4814         { 1,  102000 },
4815         { 2,  204000 },
4816         { 3,  370000 },
4817         { 4,  475000 },
4818         { 5,  620000 },
4819         { 6,  760000 },
4820         { 7,  910000 },
4821         { 8, 1000000 },
4822         { 9, 1150000 },
4823         {10, 1300000 },
4824         {11, 1400000 },
4825         {12, 1500000 },
4826         {13, 1600000 },
4827         {14, 1700000 },
4828         {15, CPUFREQ_TABLE_END },
4829 };
4830
4831 static struct tegra_cpufreq_table_data cpufreq_tables[] = {
4832         { freq_table_300MHz, 0,  1 },
4833         { freq_table_1p0GHz, 2,  8 },
4834         { freq_table_1p3GHz, 2, 10 },
4835         { freq_table_1p4GHz, 2, 11 },
4836         { freq_table_1p5GHz, 2, 12 },
4837         { freq_table_1p7GHz, 2, 12 },
4838 };
4839
4840 static int clip_cpu_rate_limits(
4841         struct tegra_cpufreq_table_data *data,
4842         struct cpufreq_policy *policy,
4843         struct clk *cpu_clk_g,
4844         struct clk *cpu_clk_lp)
4845 {
4846         int idx, ret;
4847         struct cpufreq_frequency_table *freq_table = data->freq_table;
4848
4849         /* clip CPU G mode maximum frequency to table entry */
4850         ret = cpufreq_frequency_table_target(policy, freq_table,
4851                 cpu_clk_g->max_rate / 1000, CPUFREQ_RELATION_H, &idx);
4852         if (ret) {
4853                 pr_err("%s: G CPU max rate %lu outside of cpufreq table",
4854                        __func__, cpu_clk_g->max_rate);
4855                 return ret;
4856         }
4857         cpu_clk_g->max_rate = freq_table[idx].frequency * 1000;
4858         if (cpu_clk_g->max_rate < cpu_clk_lp->max_rate) {
4859                 pr_err("%s: G CPU max rate %lu is below LP CPU max rate %lu",
4860                        __func__, cpu_clk_g->max_rate, cpu_clk_lp->max_rate);
4861                 return -EINVAL;
4862         }
4863
4864         /* clip CPU LP mode maximum frequency to table entry, and
4865            set CPU G mode minimum frequency one table step below */
4866         ret = cpufreq_frequency_table_target(policy, freq_table,
4867                 cpu_clk_lp->max_rate / 1000, CPUFREQ_RELATION_H, &idx);
4868         if (ret || !idx) {
4869                 pr_err("%s: LP CPU max rate %lu %s of cpufreq table", __func__,
4870                        cpu_clk_lp->max_rate, ret ? "outside" : "at the bottom");
4871                 return ret;
4872         }
4873         cpu_clk_lp->max_rate = freq_table[idx].frequency * 1000;
4874         cpu_clk_g->min_rate = freq_table[idx-1].frequency * 1000;
4875         data->suspend_index = idx;
4876         return 0;
4877 }
4878
4879 struct tegra_cpufreq_table_data *tegra_cpufreq_table_get(void)
4880 {
4881         int i, ret;
4882         unsigned long selection_rate;
4883         struct clk *cpu_clk_g = tegra_get_clock_by_name("cpu_g");
4884         struct clk *cpu_clk_lp = tegra_get_clock_by_name("cpu_lp");
4885
4886         /* For table selection use top cpu_g rate in dvfs ladder; selection
4887            rate may exceed cpu max_rate (e.g., because of edp limitations on
4888            cpu voltage) - in any case max_rate will be clipped to the table */
4889         if (cpu_clk_g->dvfs && cpu_clk_g->dvfs->num_freqs)
4890                 selection_rate =
4891                         cpu_clk_g->dvfs->freqs[cpu_clk_g->dvfs->num_freqs - 1];
4892         else
4893                 selection_rate = cpu_clk_g->max_rate;
4894
4895         for (i = 0; i < ARRAY_SIZE(cpufreq_tables); i++) {
4896                 struct cpufreq_policy policy;
4897                 policy.cpu = 0; /* any on-line cpu */
4898                 ret = cpufreq_frequency_table_cpuinfo(
4899                         &policy, cpufreq_tables[i].freq_table);
4900                 if (!ret) {
4901                         if ((policy.max * 1000) == selection_rate) {
4902                                 ret = clip_cpu_rate_limits(
4903                                         &cpufreq_tables[i],
4904                                         &policy, cpu_clk_g, cpu_clk_lp);
4905                                 if (!ret)
4906                                         return &cpufreq_tables[i];
4907                         }
4908                 }
4909         }
4910         WARN(1, "%s: No cpufreq table matching G & LP cpu ranges", __func__);
4911         return NULL;
4912 }
4913
4914 /* On DDR3 platforms there is an implicit dependency in this mapping: when cpu
4915  * exceeds max dvfs level for LP CPU clock at TEGRA_EMC_BRIDGE_MVOLTS_MIN, the
4916  * respective emc rate should be above TEGRA_EMC_BRIDGE_RATE_MIN
4917  */
4918 /* FIXME: explicitly check this dependency */
4919 unsigned long tegra_emc_to_cpu_ratio(unsigned long cpu_rate)
4920 {
4921         static unsigned long emc_max_rate = 0;
4922
4923         if (emc_max_rate == 0)
4924                 emc_max_rate = clk_round_rate(
4925                         tegra_get_clock_by_name("emc"), ULONG_MAX);
4926
4927         /* Vote on memory bus frequency based on cpu frequency;
4928            cpu rate is in kHz, emc rate is in Hz */
4929         if (cpu_rate >= 925000)
4930                 return emc_max_rate;    /* cpu >= 925 MHz, emc max */
4931         else if (cpu_rate >= 450000)
4932                 return emc_max_rate/2;  /* cpu >= 450 MHz, emc max/2 */
4933         else if (cpu_rate >= 250000)
4934                 return 100000000;       /* cpu >= 250 MHz, emc 100 MHz */
4935         else
4936                 return 0;               /* emc min */
4937 }
4938
4939 int tegra_update_mselect_rate(unsigned long cpu_rate)
4940 {
4941         static struct clk *mselect = NULL;
4942
4943         unsigned long mselect_rate;
4944
4945         if (!mselect) {
4946                 mselect = tegra_get_clock_by_name("mselect");
4947                 if (!mselect)
4948                         return -ENODEV;
4949         }
4950
4951         /* Vote on mselect frequency based on cpu frequency:
4952            keep mselect at half of cpu rate up to 102 MHz;
4953            cpu rate is in kHz, mselect rate is in Hz */
4954         mselect_rate = DIV_ROUND_UP(cpu_rate, 2) * 1000;
4955         mselect_rate = min(mselect_rate, 102000000UL);
4956
4957         if (mselect_rate != clk_get_rate(mselect))
4958                 return clk_set_rate(mselect, mselect_rate);
4959
4960         return 0;
4961 }
4962 #endif
4963
4964 #ifdef CONFIG_PM_SLEEP
4965 static u32 clk_rst_suspend[RST_DEVICES_NUM + CLK_OUT_ENB_NUM +
4966                            PERIPH_CLK_SOURCE_NUM + 24];
4967
4968 static int tegra_clk_suspend(void)
4969 {
4970         unsigned long off;
4971         u32 *ctx = clk_rst_suspend;
4972
4973         *ctx++ = clk_readl(OSC_CTRL) & OSC_CTRL_MASK;
4974         *ctx++ = clk_readl(CPU_SOFTRST_CTRL);
4975
4976         *ctx++ = clk_readl(tegra_pll_p_out1.reg);
4977         *ctx++ = clk_readl(tegra_pll_p_out3.reg);
4978
4979         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_BASE);
4980         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
4981         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_BASE);
4982         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
4983         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_BASE);
4984         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
4985         *ctx++ = clk_readl(tegra_pll_d2.reg + PLL_BASE);
4986         *ctx++ = clk_readl(tegra_pll_d2.reg + PLL_MISC(&tegra_pll_d2));
4987
4988         *ctx++ = clk_readl(tegra_pll_m_out1.reg);
4989         *ctx++ = clk_readl(tegra_pll_a_out0.reg);
4990         *ctx++ = clk_readl(tegra_pll_c_out1.reg);
4991
4992         *ctx++ = clk_readl(tegra_clk_cclk_g.reg);
4993         *ctx++ = clk_readl(tegra_clk_cclk_g.reg + SUPER_CLK_DIVIDER);
4994         *ctx++ = clk_readl(tegra_clk_cclk_lp.reg);
4995         *ctx++ = clk_readl(tegra_clk_cclk_lp.reg + SUPER_CLK_DIVIDER);
4996
4997         *ctx++ = clk_readl(tegra_clk_sclk.reg);
4998         *ctx++ = clk_readl(tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
4999         *ctx++ = clk_readl(tegra_clk_pclk.reg);
5000
5001         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
5002                         off += 4) {
5003                 if (off == PERIPH_CLK_SOURCE_EMC)
5004                         continue;
5005                 *ctx++ = clk_readl(off);
5006         }
5007         for (off = PERIPH_CLK_SOURCE_G3D2; off <= PERIPH_CLK_SOURCE_SE;
5008                         off+=4) {
5009                 *ctx++ = clk_readl(off);
5010         }
5011         for (off = AUDIO_DLY_CLK; off <= AUDIO_SYNC_CLK_SPDIF; off+=4) {
5012                 *ctx++ = clk_readl(off);
5013         }
5014
5015         *ctx++ = clk_readl(RST_DEVICES_L);
5016         *ctx++ = clk_readl(RST_DEVICES_H);
5017         *ctx++ = clk_readl(RST_DEVICES_U);
5018         *ctx++ = clk_readl(RST_DEVICES_V);
5019         *ctx++ = clk_readl(RST_DEVICES_W);
5020
5021         *ctx++ = clk_readl(CLK_OUT_ENB_L);
5022         *ctx++ = clk_readl(CLK_OUT_ENB_H);
5023         *ctx++ = clk_readl(CLK_OUT_ENB_U);
5024         *ctx++ = clk_readl(CLK_OUT_ENB_V);
5025         *ctx++ = clk_readl(CLK_OUT_ENB_W);
5026
5027         *ctx++ = clk_readl(MISC_CLK_ENB);
5028         *ctx++ = clk_readl(CLK_MASK_ARM);
5029
5030         return 0;
5031 }
5032
5033 static void tegra_clk_resume(void)
5034 {
5035         unsigned long off;
5036         const u32 *ctx = clk_rst_suspend;
5037         u32 val;
5038         u32 pllc_base;
5039         u32 plla_base;
5040         u32 plld_base;
5041         u32 plld2_base;
5042         u32 pll_p_out12, pll_p_out34;
5043         u32 pll_a_out0, pll_m_out1, pll_c_out1;
5044         struct clk *p;
5045
5046         val = clk_readl(OSC_CTRL) & ~OSC_CTRL_MASK;
5047         val |= *ctx++;
5048         clk_writel(val, OSC_CTRL);
5049         clk_writel(*ctx++, CPU_SOFTRST_CTRL);
5050
5051         /* Since we are going to reset devices and switch clock sources in this
5052          * function, plls and secondary dividers is required to be enabled. The
5053          * actual value will be restored back later. Note that boot plls: pllm,
5054          * pllp, and pllu are already configured and enabled.
5055          */
5056         val = PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
5057         val |= val << 16;
5058         pll_p_out12 = *ctx++;
5059         clk_writel(pll_p_out12 | val, tegra_pll_p_out1.reg);
5060         pll_p_out34 = *ctx++;
5061         clk_writel(pll_p_out34 | val, tegra_pll_p_out3.reg);
5062
5063         pllc_base = *ctx++;
5064         clk_writel(pllc_base | PLL_BASE_ENABLE, tegra_pll_c.reg + PLL_BASE);
5065         clk_writel(*ctx++, tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
5066
5067         plla_base = *ctx++;
5068         clk_writel(plla_base | PLL_BASE_ENABLE, tegra_pll_a.reg + PLL_BASE);
5069         clk_writel(*ctx++, tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
5070
5071         plld_base = *ctx++;
5072         clk_writel(plld_base | PLL_BASE_ENABLE, tegra_pll_d.reg + PLL_BASE);
5073         clk_writel(*ctx++, tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
5074
5075         plld2_base = *ctx++;
5076         clk_writel(plld2_base | PLL_BASE_ENABLE, tegra_pll_d2.reg + PLL_BASE);
5077         clk_writel(*ctx++, tegra_pll_d2.reg + PLL_MISC(&tegra_pll_d2));
5078
5079         udelay(1000);
5080
5081         val = PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
5082         pll_m_out1 = *ctx++;
5083         clk_writel(pll_m_out1 | val, tegra_pll_m_out1.reg);
5084         pll_a_out0 = *ctx++;
5085         clk_writel(pll_a_out0 | val, tegra_pll_a_out0.reg);
5086         pll_c_out1 = *ctx++;
5087         clk_writel(pll_c_out1 | val, tegra_pll_c_out1.reg);
5088
5089         clk_writel(*ctx++, tegra_clk_cclk_g.reg);
5090         clk_writel(*ctx++, tegra_clk_cclk_g.reg + SUPER_CLK_DIVIDER);
5091         clk_writel(*ctx++, tegra_clk_cclk_lp.reg);
5092         clk_writel(*ctx++, tegra_clk_cclk_lp.reg + SUPER_CLK_DIVIDER);
5093
5094         clk_writel(*ctx++, tegra_clk_sclk.reg);
5095         clk_writel(*ctx++, tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
5096         clk_writel(*ctx++, tegra_clk_pclk.reg);
5097
5098         /* enable all clocks before configuring clock sources */
5099         clk_writel(0xfdfffff1ul, CLK_OUT_ENB_L);
5100         clk_writel(0xfefff7f7ul, CLK_OUT_ENB_H);
5101         clk_writel(0x75f79bfful, CLK_OUT_ENB_U);
5102         clk_writel(0xfffffffful, CLK_OUT_ENB_V);
5103         clk_writel(0x00003ffful, CLK_OUT_ENB_W);
5104         wmb();
5105
5106         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
5107                         off += 4) {
5108                 if (off == PERIPH_CLK_SOURCE_EMC)
5109                         continue;
5110                 clk_writel(*ctx++, off);
5111         }
5112         for (off = PERIPH_CLK_SOURCE_G3D2; off <= PERIPH_CLK_SOURCE_SE;
5113                         off += 4) {
5114                 clk_writel(*ctx++, off);
5115         }
5116         for (off = AUDIO_DLY_CLK; off <= AUDIO_SYNC_CLK_SPDIF; off+=4) {
5117                 clk_writel(*ctx++, off);
5118         }
5119         wmb();
5120
5121         clk_writel(*ctx++, RST_DEVICES_L);
5122         clk_writel(*ctx++, RST_DEVICES_H);
5123         clk_writel(*ctx++, RST_DEVICES_U);
5124
5125         /* For LP0 resume, don't reset lpcpu, since we are running from it */
5126         val = *ctx++;
5127         val &= ~RST_DEVICES_V_SWR_CPULP_RST_DIS;
5128         clk_writel(val, RST_DEVICES_V);
5129
5130         clk_writel(*ctx++, RST_DEVICES_W);
5131         wmb();
5132
5133         clk_writel(*ctx++, CLK_OUT_ENB_L);
5134         clk_writel(*ctx++, CLK_OUT_ENB_H);
5135         clk_writel(*ctx++, CLK_OUT_ENB_U);
5136
5137         /* For LP0 resume, clk to lpcpu is required to be on */
5138         val = *ctx++;
5139         val |= CLK_OUT_ENB_V_CLK_ENB_CPULP_EN;
5140         clk_writel(val, CLK_OUT_ENB_V);
5141
5142         clk_writel(*ctx++, CLK_OUT_ENB_W);
5143         wmb();
5144
5145         clk_writel(*ctx++, MISC_CLK_ENB);
5146         clk_writel(*ctx++, CLK_MASK_ARM);
5147
5148         /* Restore back the actual pll and secondary divider values */
5149         /* FIXME: need to root cause why pllc is required to be on
5150          * clk_writel(pllc_base, tegra_pll_c.reg + PLL_BASE);
5151          */
5152         clk_writel(pll_p_out12, tegra_pll_p_out1.reg);
5153         clk_writel(pll_p_out34, tegra_pll_p_out3.reg);
5154
5155         clk_writel(plla_base, tegra_pll_a.reg + PLL_BASE);
5156         clk_writel(plld_base, tegra_pll_d.reg + PLL_BASE);
5157         clk_writel(plld2_base, tegra_pll_d2.reg + PLL_BASE);
5158
5159         clk_writel(pll_m_out1, tegra_pll_m_out1.reg);
5160         clk_writel(pll_a_out0, tegra_pll_a_out0.reg);
5161         clk_writel(pll_c_out1, tegra_pll_c_out1.reg);
5162
5163         /* Since EMC clock is not restored, and may not preserve parent across
5164            suspend, update current state, and mark EMC DFS as out of sync */
5165         tegra3_pll_m_override_update(&tegra_pll_m, false);
5166         p = tegra_clk_emc.parent;
5167         tegra3_periph_clk_init(&tegra_clk_emc);
5168
5169         if (p != tegra_clk_emc.parent) {
5170                 /* FIXME: old parent is left enabled here even if EMC was its
5171                    only child before suspend (never happens on Tegra3) */
5172                 pr_debug("EMC parent(refcount) across suspend: %s(%d) : %s(%d)",
5173                         p->name, p->refcnt, tegra_clk_emc.parent->name,
5174                         tegra_clk_emc.parent->refcnt);
5175
5176                 BUG_ON(!p->refcnt);
5177                 p->refcnt--;
5178
5179                 /* the new parent is enabled by low level code, but ref count
5180                    need to be updated up to the root */
5181                 p = tegra_clk_emc.parent;
5182                 while (p && ((p->refcnt++) == 0))
5183                         p = p->parent;
5184         }
5185         tegra_emc_timing_invalidate();
5186
5187         tegra3_pll_clk_init(&tegra_pll_u); /* Re-init utmi parameters */
5188         tegra3_pllp_clk_resume(&tegra_pll_p); /* Fire a bug if not restored */
5189 }
5190 #else
5191 #define tegra_clk_suspend NULL
5192 #define tegra_clk_resume NULL
5193 #endif
5194
5195 static struct syscore_ops tegra_clk_syscore_ops = {
5196         .suspend = tegra_clk_suspend,
5197         .resume = tegra_clk_resume,
5198 };
5199
5200 #ifdef CONFIG_TEGRA_PREINIT_CLOCKS
5201
5202 #define CLK_RSTENB_DEV_V_0_DAM2_BIT     (1 << 14)
5203 #define CLK_RSTENB_DEV_V_0_DAM1_BIT     (1 << 13)
5204 #define CLK_RSTENB_DEV_V_0_DAM0_BIT     (1 << 12)
5205 #define CLK_RSTENB_DEV_V_0_AUDIO_BIT    (1 << 10)
5206 #define CLK_RSTENB_DEV_V_0_3D2_BIT      (1 << 2)
5207
5208 #define CLK_RSTENB_DEV_L_0_HOST1X_BIT   (1 << 28)
5209 #define CLK_RSTENB_DEV_L_0_DISP1_BIT    (1 << 27)
5210 #define CLK_RSTENB_DEV_L_0_3D_BIT       (1 << 24)
5211 #define CLK_RSTENB_DEV_L_0_2D_BIT       (1 << 21)
5212 #define CLK_RSTENB_DEV_L_0_VI_BIT       (1 << 20)
5213 #define CLK_RSTENB_DEV_L_0_EPP_BIT      (1 << 19)
5214
5215 #define CLK_RSTENB_DEV_H_0_VDE_BIT      (1 << 29)
5216 #define CLK_RSTENB_DEV_H_0_MPE_BIT      (1 << 28)
5217
5218 #define DISP1_CLK_REG_OFFSET            0x138
5219 #define DISP1_CLK_SRC_SHIFT             29
5220 #define DISP1_CLK_SRC_MASK              (0x7 << DISP1_CLK_SRC_SHIFT)
5221 #define DISP1_CLK_SRC_PLLP_OUT0         0
5222 #define DISP1_CLK_SRC_PLLM_OUT0         1
5223 #define DISP1_CLK_SRC_PLLD_OUT0         2
5224 #define DISP1_CLK_SRC_PLLA_OUT0         3
5225 #define DISP1_CLK_SRC_PLLC_OUT0         4
5226 #define DISP1_CLK_SRC_PLLD2_OUT0        5
5227 #define DISP1_CLK_SRC_CLKM              6
5228 #define DISP1_CLK_SRC_DEFAULT (DISP1_CLK_SRC_PLLP_OUT0 << DISP1_CLK_SRC_SHIFT)
5229
5230 #define HOST1X_CLK_REG_OFFSET           0x180
5231 #define HOST1X_CLK_SRC_SHIFT            30
5232 #define HOST1X_CLK_SRC_MASK             (0x3 << HOST1X_CLK_SRC_SHIFT)
5233 #define HOST1X_CLK_SRC_PLLM_OUT0        0
5234 #define HOST1X_CLK_SRC_PLLC_OUT0        1
5235 #define HOST1X_CLK_SRC_PLLP_OUT0        2
5236 #define HOST1X_CLK_SRC_PLLA_OUT0        3
5237 #define HOST1X_CLK_SRC_DEFAULT (\
5238                 HOST1X_CLK_SRC_PLLP_OUT0 << HOST1X_CLK_SRC_SHIFT)
5239 #define HOST1X_CLK_IDLE_DIV_SHIFT       8
5240 #define HOST1X_CLK_IDLE_DIV_MASK        (0xff << HOST1X_CLK_IDLE_DIV_SHIFT)
5241 #define HOST1X_CLK_IDLE_DIV_DEFAULT     (0 << HOST1X_CLK_IDLE_DIV_SHIFT)
5242 #define HOST1X_CLK_DIV_SHIFT            0
5243 #define HOST1X_CLK_DIV_MASK             (0xff << HOST1X_CLK_DIV_SHIFT)
5244 #define HOST1X_CLK_DIV_DEFAULT          (3 << HOST1X_CLK_DIV_SHIFT)
5245
5246 #define AUDIO_CLK_REG_OFFSET            0x3d0
5247 #define DAM0_CLK_REG_OFFSET             0x3d8
5248 #define DAM1_CLK_REG_OFFSET             0x3dc
5249 #define DAM2_CLK_REG_OFFSET             0x3e0
5250 #define AUDIO_CLK_SRC_SHIFT             28
5251 #define AUDIO_CLK_SRC_MASK              (0x0f << AUDIO_CLK_SRC_SHIFT)
5252 #define AUDIO_CLK_SRC_PLLA_OUT0         0x01
5253 #define AUDIO_CLK_SRC_PLLC_OUT0         0x05
5254 #define AUDIO_CLK_SRC_PLLP_OUT0         0x09
5255 #define AUDIO_CLK_SRC_CLKM              0x0d
5256 #define AUDIO_CLK_SRC_DEFAULT (\
5257                 AUDIO_CLK_SRC_CLKM << AUDIO_CLK_SRC_SHIFT)
5258 #define AUDIO_CLK_DIV_SHIFT             0
5259 #define AUDIO_CLK_DIV_MASK              (0xff << AUDIO_CLK_DIV_SHIFT)
5260 #define AUDIO_CLK_DIV_DEFAULT (\
5261                 (0 << AUDIO_CLK_DIV_SHIFT))
5262
5263 #define VCLK_SRC_SHIFT                  30
5264 #define VCLK_SRC_MASK                   (0x3 << VCLK_SRC_SHIFT)
5265 #define VCLK_SRC_PLLM_OUT0              0
5266 #define VCLK_SRC_PLLC_OUT0              1
5267 #define VCLK_SRC_PLLP_OUT0              2
5268 #define VCLK_SRC_PLLA_OUT0              3
5269 #define VCLK_SRC_DEFAULT                (VCLK_SRC_PLLM_OUT0 << VCLK_SRC_SHIFT)
5270 #define VCLK_IDLE_DIV_SHIFT             8
5271 #define VCLK_IDLE_DIV_MASK              (0xff << VCLK_IDLE_DIV_SHIFT)
5272 #define VCLK_IDLE_DIV_DEFAULT           (0 << VCLK_IDLE_DIV_SHIFT)
5273 #define VCLK_DIV_SHIFT                  0
5274 #define VCLK_DIV_MASK                   (0xff << VCLK_DIV_SHIFT)
5275 #define VCLK_DIV_DEFAULT                (0xa << VCLK_DIV_SHIFT)
5276
5277 #define VI_CLK_REG_OFFSET               0x148
5278 #define  VI_CLK_SEL_VI_SENSOR_CLK       (1 << 25)
5279 #define  VI_CLK_SEL_EXTERNAL_CLK        (1 << 24)
5280 #define  VI_SENSOR_CLK_REG_OFFSET       0x1a8
5281 #define G3D_CLK_REG_OFFSET              0x158
5282 #define G2D_CLK_REG_OFFSET              0x15c
5283 #define EPP_CLK_REG_OFFSET              0x16c
5284 #define MPE_CLK_REG_OFFSET              0x170
5285 #define VDE_CLK_REG_OFFSET              0x170
5286 #define G3D2_CLK_REG_OFFSET             0x3b0
5287
5288 static void __init clk_setbit(u32 reg, u32 bit)
5289 {
5290         u32 val = clk_readl(reg);
5291
5292         if ((val & bit) == bit)
5293                 return;
5294         val |= bit;
5295         clk_writel(val, reg);
5296         udelay(2);
5297 }
5298
5299 static void __init clk_clrbit(u32 reg, u32 bit)
5300 {
5301         u32 val = clk_readl(reg);
5302
5303         if ((val & bit) == 0)
5304                 return;
5305         val &= ~bit;
5306         clk_writel(val, reg);
5307         udelay(2);
5308 }
5309
5310 static void __init clk_setbits(u32 reg, u32 bits, u32 mask)
5311 {
5312         u32 val = clk_readl(reg);
5313
5314         if ((val & mask) == bits)
5315                 return;
5316         val &= ~mask;
5317         val |= bits;
5318         clk_writel(val, reg);
5319         udelay(2);
5320 }
5321
5322 static void __init vclk_init(int tag, u32 src, u32 rebit)
5323 {
5324         u32 rst, enb;
5325
5326         switch (tag) {
5327         case 'L':
5328                 rst = RST_DEVICES_L;
5329                 enb = CLK_OUT_ENB_L;
5330                 break;
5331         case 'H':
5332                 rst = RST_DEVICES_H;
5333                 enb = CLK_OUT_ENB_H;
5334                 break;
5335         case 'U':
5336                 rst = RST_DEVICES_U;
5337                 enb = CLK_OUT_ENB_U;
5338                 break;
5339         case 'V':
5340                 rst = RST_DEVICES_V;
5341                 enb = CLK_OUT_ENB_V;
5342                 break;
5343         case 'W':
5344                 rst = RST_DEVICES_W;
5345                 enb = CLK_OUT_ENB_W;
5346                 break;
5347         default:
5348                 /* Quietly ignore. */
5349                 return;
5350         }
5351
5352         clk_setbit(rst, rebit);
5353         clk_clrbit(enb, rebit);
5354         clk_setbits(src, VCLK_SRC_DEFAULT, VCLK_SRC_MASK);
5355         clk_setbits(src, VCLK_DIV_DEFAULT, VCLK_DIV_MASK);
5356         clk_clrbit(rst, rebit);
5357 }
5358
5359 static int __init tegra_soc_preinit_clocks(void)
5360 {
5361         /*
5362          * Make sure host1x clock configuration has:
5363          *      HOST1X_CLK_SRC    : PLLP_OUT0.
5364          *      HOST1X_CLK_DIVISOR: >2 to start from safe enough frequency.
5365          */
5366         clk_setbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_HOST1X_BIT);
5367         clk_setbit(CLK_OUT_ENB_L, CLK_RSTENB_DEV_L_0_HOST1X_BIT);
5368         clk_setbits(HOST1X_CLK_REG_OFFSET,
5369                     HOST1X_CLK_DIV_DEFAULT, HOST1X_CLK_DIV_MASK);
5370         clk_setbits(HOST1X_CLK_REG_OFFSET,
5371                     HOST1X_CLK_IDLE_DIV_DEFAULT, HOST1X_CLK_IDLE_DIV_MASK);
5372         clk_setbits(HOST1X_CLK_REG_OFFSET,
5373                     HOST1X_CLK_SRC_DEFAULT, HOST1X_CLK_SRC_MASK);
5374         clk_clrbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_HOST1X_BIT);
5375
5376         /*
5377          *  Make sure disp1 clock configuration ha:
5378          *      DISP1_CLK_SRC:  DISP1_CLK_SRC_PLLP_OUT0
5379          */
5380         clk_setbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_DISP1_BIT);
5381         clk_setbit(CLK_OUT_ENB_L, CLK_RSTENB_DEV_L_0_DISP1_BIT);
5382         clk_setbits(DISP1_CLK_REG_OFFSET,
5383                     DISP1_CLK_SRC_DEFAULT, DISP1_CLK_SRC_MASK);
5384         clk_clrbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_DISP1_BIT);
5385
5386         /*
5387          *  Make sure dam2 clock configuration has:
5388          *      DAM2_CLK_SRC:   AUDIO_CLK_SRC_CLKM
5389          */
5390         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM2_BIT);
5391         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_DAM2_BIT);
5392         clk_setbits(DAM2_CLK_REG_OFFSET,
5393                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5394         clk_setbits(DAM2_CLK_REG_OFFSET,
5395                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5396         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM2_BIT);
5397
5398         /*
5399          *  Make sure dam1 clock configuration has:
5400          *      DAM1_CLK_SRC:   AUDIO_CLK_SRC_CLKM
5401          */
5402         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM1_BIT);
5403         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_DAM1_BIT);
5404         clk_setbits(DAM1_CLK_REG_OFFSET,
5405                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5406         clk_setbits(DAM1_CLK_REG_OFFSET,
5407                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5408         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM1_BIT);
5409
5410         /*
5411          *  Make sure dam0 clock configuration has:
5412          *      DAM0_CLK_SRC:   AUDIO_CLK_SRC_CLKM
5413          */
5414         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM0_BIT);
5415         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_DAM0_BIT);
5416         clk_setbits(DAM0_CLK_REG_OFFSET,
5417                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5418         clk_setbits(DAM0_CLK_REG_OFFSET,
5419                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5420         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM0_BIT);
5421
5422         /*
5423          *  Make sure d_audio clock configuration has:
5424          *      AUDIO_CLK_SRC:  AUDIO_CLK_SRC_CLKM
5425          */
5426         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_AUDIO_BIT);
5427         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_AUDIO_BIT);
5428         clk_setbits(AUDIO_CLK_REG_OFFSET,
5429                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5430         clk_setbits(AUDIO_CLK_REG_OFFSET,
5431                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5432         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_AUDIO_BIT);
5433
5434         /* Pre-initialize Video clocks. */
5435         vclk_init('L', G3D_CLK_REG_OFFSET, CLK_RSTENB_DEV_L_0_3D_BIT);
5436         vclk_init('L', G2D_CLK_REG_OFFSET, CLK_RSTENB_DEV_L_0_2D_BIT);
5437         vclk_init('L', VI_CLK_REG_OFFSET, CLK_RSTENB_DEV_L_0_VI_BIT);
5438         vclk_init('L', EPP_CLK_REG_OFFSET, CLK_RSTENB_DEV_L_0_EPP_BIT);
5439         vclk_init('H', VDE_CLK_REG_OFFSET, CLK_RSTENB_DEV_H_0_VDE_BIT);
5440         vclk_init('H', MPE_CLK_REG_OFFSET, CLK_RSTENB_DEV_H_0_MPE_BIT);
5441         vclk_init('V', G3D2_CLK_REG_OFFSET, CLK_RSTENB_DEV_V_0_3D2_BIT);
5442
5443         return 0;
5444 }
5445 #endif /* CONFIG_TEGRA_PREINIT_CLOCKS */
5446
5447 void __init tegra_soc_init_clocks(void)
5448 {
5449         int i;
5450         struct clk *c;
5451
5452 #ifdef CONFIG_TEGRA_PREINIT_CLOCKS
5453         tegra_soc_preinit_clocks();
5454 #endif /* CONFIG_TEGRA_PREINIT_CLOCKS */
5455
5456         for (i = 0; i < ARRAY_SIZE(tegra_ptr_clks); i++)
5457                 tegra3_init_one_clock(tegra_ptr_clks[i]);
5458
5459         for (i = 0; i < ARRAY_SIZE(tegra_list_clks); i++)
5460                 tegra3_init_one_clock(&tegra_list_clks[i]);
5461
5462         for (i = 0; i < ARRAY_SIZE(tegra_clk_duplicates); i++) {
5463                 c = tegra_get_clock_by_name(tegra_clk_duplicates[i].name);
5464                 if (!c) {
5465                         pr_err("%s: Unknown duplicate clock %s\n", __func__,
5466                                 tegra_clk_duplicates[i].name);
5467                         continue;
5468                 }
5469
5470                 tegra_clk_duplicates[i].lookup.clk = c;
5471                 clkdev_add(&tegra_clk_duplicates[i].lookup);
5472         }
5473
5474         for (i = 0; i < ARRAY_SIZE(tegra_sync_source_list); i++)
5475                 tegra3_init_one_clock(&tegra_sync_source_list[i]);
5476         for (i = 0; i < ARRAY_SIZE(tegra_clk_audio_list); i++)
5477                 tegra3_init_one_clock(&tegra_clk_audio_list[i]);
5478         for (i = 0; i < ARRAY_SIZE(tegra_clk_audio_2x_list); i++)
5479                 tegra3_init_one_clock(&tegra_clk_audio_2x_list[i]);
5480
5481         init_clk_out_mux();
5482         for (i = 0; i < ARRAY_SIZE(tegra_clk_out_list); i++)
5483                 tegra3_init_one_clock(&tegra_clk_out_list[i]);
5484
5485         emc_bridge = &tegra_clk_emc_bridge;
5486         cpu_mode_sclk = tegra_get_clock_by_name("cpu_mode.sclk");
5487
5488         /* Initialize to default */
5489         tegra_init_cpu_edp_limits(0);
5490
5491         register_syscore_ops(&tegra_clk_syscore_ops);
5492 }