828a806ff99f0dab9b5223c48d73e104130d9283
[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 struct clk tegra_clk_cbus = {
4236         .name      = "cbus",
4237         .parent    = &tegra_pll_c,
4238         .ops       = &tegra_clk_cbus_ops,
4239         .max_rate  = 700000000,
4240         .mul       = 1,
4241         .div       = CONFIG_TEGRA_CBUS_CLOCK_DIVIDER,
4242         .flags     = PERIPH_ON_CBUS,
4243         .shared_bus_backup = {
4244                 .input = &tegra_pll_p,
4245                 .value = 2,
4246         }
4247 };
4248
4249 #define PERIPH_CLK(_name, _dev, _con, _clk_num, _reg, _max, _inputs, _flags) \
4250         {                                               \
4251                 .name      = _name,                     \
4252                 .lookup    = {                          \
4253                         .dev_id    = _dev,              \
4254                         .con_id    = _con,              \
4255                 },                                      \
4256                 .ops       = &tegra_periph_clk_ops,     \
4257                 .reg       = _reg,                      \
4258                 .inputs    = _inputs,                   \
4259                 .flags     = _flags,                    \
4260                 .max_rate  = _max,                      \
4261                 .u.periph = {                           \
4262                         .clk_num   = _clk_num,          \
4263                 },                                      \
4264         }
4265
4266 #define PERIPH_CLK_EX(_name, _dev, _con, _clk_num, _reg, _max, _inputs, \
4267                         _flags, _ops)                                   \
4268         {                                               \
4269                 .name      = _name,                     \
4270                 .lookup    = {                          \
4271                         .dev_id    = _dev,              \
4272                         .con_id    = _con,              \
4273                 },                                      \
4274                 .ops       = _ops,                      \
4275                 .reg       = _reg,                      \
4276                 .inputs    = _inputs,                   \
4277                 .flags     = _flags,                    \
4278                 .max_rate  = _max,                      \
4279                 .u.periph = {                           \
4280                         .clk_num   = _clk_num,          \
4281                 },                                      \
4282         }
4283
4284 #define SHARED_CLK(_name, _dev, _con, _parent, _id, _div, _mode)\
4285         {                                               \
4286                 .name      = _name,                     \
4287                 .lookup    = {                          \
4288                         .dev_id    = _dev,              \
4289                         .con_id    = _con,              \
4290                 },                                      \
4291                 .ops       = &tegra_clk_shared_bus_ops, \
4292                 .parent = _parent,                      \
4293                 .u.shared_bus_user = {                  \
4294                         .client_id = _id,               \
4295                         .client_div = _div,             \
4296                         .mode = _mode,                  \
4297                 },                                      \
4298         }
4299 struct clk tegra_list_clks[] = {
4300         PERIPH_CLK("apbdma",    "tegra-dma",            NULL,   34,     0,      26000000,  mux_clk_m,                   0),
4301         PERIPH_CLK("rtc",       "rtc-tegra",            NULL,   4,      0,      32768,     mux_clk_32k,                 PERIPH_NO_RESET | PERIPH_ON_APB),
4302         PERIPH_CLK("kbc",       "tegra-kbc",            NULL,   36,     0,      32768,     mux_clk_32k,                 PERIPH_NO_RESET | PERIPH_ON_APB),
4303         PERIPH_CLK("timer",     "timer",                NULL,   5,      0,      26000000,  mux_clk_m,                   0),
4304         PERIPH_CLK("kfuse",     "kfuse-tegra",          NULL,   40,     0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
4305         PERIPH_CLK("fuse",      "fuse-tegra",           "fuse", 39,     0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
4306         PERIPH_CLK("fuse_burn", "fuse-tegra",           "fuse_burn",    39,     0,      26000000,  mux_clk_m,           PERIPH_ON_APB),
4307         PERIPH_CLK("apbif",     "tegra30-ahub",         "apbif", 107,   0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
4308         PERIPH_CLK("i2s0",      "tegra30-i2s.0",        "i2s",  30,     0x1d8,  26000000,  mux_pllaout0_audio0_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4309         PERIPH_CLK("i2s1",      "tegra30-i2s.1",        "i2s",  11,     0x100,  26000000,  mux_pllaout0_audio1_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4310         PERIPH_CLK("i2s2",      "tegra30-i2s.2",        "i2s",  18,     0x104,  26000000,  mux_pllaout0_audio2_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4311         PERIPH_CLK("i2s3",      "tegra30-i2s.3",        "i2s",  101,    0x3bc,  26000000,  mux_pllaout0_audio3_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4312         PERIPH_CLK("i2s4",      "tegra30-i2s.4",        "i2s",  102,    0x3c0,  26000000,  mux_pllaout0_audio4_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4313         PERIPH_CLK("spdif_out", "tegra30-spdif",        "spdif_out",    10,     0x108,  26000000, mux_pllaout0_audio_2x_pllp_clkm,      MUX | DIV_U71 | PERIPH_ON_APB),
4314         PERIPH_CLK("spdif_in",  "tegra30-spdif",        "spdif_in",     10,     0x10c,  100000000, mux_pllp_pllc_pllm,          MUX | DIV_U71 | PERIPH_ON_APB),
4315         PERIPH_CLK("pwm",       "pwm",                  NULL,   17,     0x110,  408000000, mux_pllp_pllc_clk32_clkm,    MUX | MUX_PWM | DIV_U71 | PERIPH_ON_APB),
4316         PERIPH_CLK("d_audio",   "tegra30-ahub",         "d_audio", 106, 0x3d0,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4317         PERIPH_CLK("dam0",      "tegra30-dam.0",        NULL,   108,    0x3d8,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4318         PERIPH_CLK("dam1",      "tegra30-dam.1",        NULL,   109,    0x3dc,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4319         PERIPH_CLK("dam2",      "tegra30-dam.2",        NULL,   110,    0x3e0,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4320         PERIPH_CLK("hda",       "tegra30-hda",          "hda",   125,   0x428,  108000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4321         PERIPH_CLK("hda2codec_2x",      "tegra30-hda",  "hda2codec",   111,     0x3e4,  48000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4322         PERIPH_CLK("hda2hdmi",  "tegra30-hda",          "hda2hdmi",     128,    0,      48000000,  mux_clk_m,                   PERIPH_ON_APB),
4323         PERIPH_CLK("sbc1",      "spi_tegra.0",          "spi",  41,     0x134,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4324         PERIPH_CLK("sbc2",      "spi_tegra.1",          "spi",  44,     0x118,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4325         PERIPH_CLK("sbc3",      "spi_tegra.2",          "spi",  46,     0x11c,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4326         PERIPH_CLK("sbc4",      "spi_tegra.3",          "spi",  68,     0x1b4,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4327         PERIPH_CLK("sbc5",      "spi_tegra.4",          "spi",  104,    0x3c8,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4328         PERIPH_CLK("sbc6",      "spi_tegra.5",          "spi",  105,    0x3cc,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4329         PERIPH_CLK("sata_oob",  "tegra_sata_oob",       NULL,   123,    0x420,  216000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4330         PERIPH_CLK("sata",      "tegra_sata",           NULL,   124,    0x424,  216000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4331         PERIPH_CLK("sata_cold", "tegra_sata_cold",      NULL,   129,    0,      48000000,  mux_clk_m,                   PERIPH_ON_APB),
4332         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),
4333         PERIPH_CLK("ndspeed",   "tegra_nand_speed",     NULL,   80,     0x3f8,  240000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4334         PERIPH_CLK("vfir",      "vfir",                 NULL,   7,      0x168,  72000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4335         PERIPH_CLK("sdmmc1",    "sdhci-tegra.0",        NULL,   14,     0x150,  208000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4336         PERIPH_CLK("sdmmc2",    "sdhci-tegra.1",        NULL,   9,      0x154,   50000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4337         PERIPH_CLK("sdmmc3",    "sdhci-tegra.2",        NULL,   69,     0x1bc,  208000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4338         PERIPH_CLK("sdmmc4",    "sdhci-tegra.3",        NULL,   15,     0x164,  102000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4339         PERIPH_CLK("vcp",       "tegra-avp",            "vcp",  29,     0,      250000000, mux_clk_m,                   0),
4340         PERIPH_CLK("bsea",      "tegra-avp",            "bsea", 62,     0,      250000000, mux_clk_m,                   0),
4341         PERIPH_CLK("bsev",      "tegra-aes",            "bsev", 63,     0,      250000000, mux_clk_m,                   0),
4342         PERIPH_CLK("cec",       "tegra_cec",            NULL,   136,    0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
4343         PERIPH_CLK("vde",       "vde",                  NULL,   61,     0x1c8,  600000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | DIV_U71_INT),
4344         PERIPH_CLK("csite",     "csite",                NULL,   73,     0x1d4,  144000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB), /* max rate ??? */
4345         PERIPH_CLK("la",        "la",                   NULL,   76,     0x1f8,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4346         PERIPH_CLK("owr",       "tegra_w1",             NULL,   71,     0x1cc,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4347         PERIPH_CLK("nor",       "tegra-nor",            NULL,   42,     0x1d0,  127000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* requires min voltage */
4348         PERIPH_CLK("mipi",      "mipi",                 NULL,   50,     0x174,  60000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB), /* scales with voltage */
4349         PERIPH_CLK("i2c1",      "tegra-i2c.0",          "i2c-div",      12,     0x124,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4350         PERIPH_CLK("i2c2",      "tegra-i2c.1",          "i2c-div",      54,     0x198,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4351         PERIPH_CLK("i2c3",      "tegra-i2c.2",          "i2c-div",      67,     0x1b8,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4352         PERIPH_CLK("i2c4",      "tegra-i2c.3",          "i2c-div",      103,    0x3c4,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4353         PERIPH_CLK("i2c5",      "tegra-i2c.4",          "i2c-div",      47,     0x128,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4354         PERIPH_CLK("i2c1-fast", "tegra-i2c.0",          "i2c-fast",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4355         PERIPH_CLK("i2c2-fast", "tegra-i2c.1",          "i2c-fast",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4356         PERIPH_CLK("i2c3-fast", "tegra-i2c.2",          "i2c-fast",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4357         PERIPH_CLK("i2c4-fast", "tegra-i2c.3",          "i2c-fast",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4358         PERIPH_CLK("i2c5-fast", "tegra-i2c.4",          "i2c-fast",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4359         PERIPH_CLK("uarta",     "tegra_uart.0",         NULL,   6,      0x178,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4360         PERIPH_CLK("uartb",     "tegra_uart.1",         NULL,   7,      0x17c,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4361         PERIPH_CLK("uartc",     "tegra_uart.2",         NULL,   55,     0x1a0,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4362         PERIPH_CLK("uartd",     "tegra_uart.3",         NULL,   65,     0x1c0,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4363         PERIPH_CLK("uarte",     "tegra_uart.4",         NULL,   66,     0x1c4,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4364         PERIPH_CLK("uarta_dbg", "serial8250.0",         "uarta", 6,     0x178,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4365         PERIPH_CLK("uartb_dbg", "serial8250.0",         "uartb", 7,     0x17c,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4366         PERIPH_CLK("uartc_dbg", "serial8250.0",         "uartc", 55,    0x1a0,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4367         PERIPH_CLK("uartd_dbg", "serial8250.0",         "uartd", 65,    0x1c0,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4368         PERIPH_CLK("uarte_dbg", "serial8250.0",         "uarte", 66,    0x1c4,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4369         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),
4370         PERIPH_CLK("vi_sensor", "tegra_camera",         "vi_sensor",    20,     0x1a8,  150000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_NO_RESET),
4371         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),
4372         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),
4373         PERIPH_CLK("2d",        "2d",                   NULL,   21,     0x15c,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT | DIV_U71_IDLE),
4374         PERIPH_CLK("epp",       "epp",                  NULL,   19,     0x16c,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT),
4375         PERIPH_CLK("mpe",       "mpe",                  NULL,   60,     0x170,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT),
4376         PERIPH_CLK("host1x",    "host1x",               NULL,   28,     0x180,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT),
4377         PERIPH_CLK("cve",       "cve",                  NULL,   49,     0x140,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
4378         PERIPH_CLK("tvo",       "tvo",                  NULL,   49,     0x188,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
4379         PERIPH_CLK_EX("dtv",    "dtv",                  NULL,   79,     0x1dc,  250000000, mux_clk_m,                   PERIPH_ON_APB,  &tegra_dtv_clk_ops),
4380         PERIPH_CLK("hdmi",      "hdmi",                 NULL,   51,     0x18c,  148500000, mux_pllp_pllm_plld_plla_pllc_plld2_clkm,     MUX | MUX8 | DIV_U71),
4381         PERIPH_CLK("tvdac",     "tvdac",                NULL,   53,     0x194,  220000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
4382         PERIPH_CLK("disp1",     "tegradc.0",            NULL,   27,     0x138,  600000000, mux_pllp_pllm_plld_plla_pllc_plld2_clkm,     MUX | MUX8),
4383         PERIPH_CLK("disp2",     "tegradc.1",            NULL,   26,     0x13c,  600000000, mux_pllp_pllm_plld_plla_pllc_plld2_clkm,     MUX | MUX8),
4384         PERIPH_CLK("usbd",      "tegra-udc.0",  NULL,   22,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
4385         PERIPH_CLK("usb2",      "tegra-ehci.1",         NULL,   58,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
4386         PERIPH_CLK("usb3",      "tegra-ehci.2",         NULL,   59,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
4387         PERIPH_CLK("dsia",      "tegradc.0",            "dsia", 48,     0,      500000000, mux_plld_out0,               0),
4388         PERIPH_CLK_EX("dsib",   "tegradc.1",            "dsib", 82,     0xd0,   500000000, mux_plld_out0_plld2_out0,    MUX | PLLD,     &tegra_dsib_clk_ops),
4389         PERIPH_CLK("dsi1-fixed", "tegradc.0",           "dsi-fixed",    0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4390         PERIPH_CLK("dsi2-fixed", "tegradc.1",           "dsi-fixed",    0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4391         PERIPH_CLK("csi",       "tegra_camera",         "csi",  52,     0,      102000000, mux_pllp_out3,               0),
4392         PERIPH_CLK("isp",       "tegra_camera",         "isp",  23,     0,      150000000, mux_clk_m,                   0), /* same frequency as VI */
4393         PERIPH_CLK("csus",      "tegra_camera",         "csus", 92,     0,      150000000, mux_clk_m,                   PERIPH_NO_RESET),
4394
4395         PERIPH_CLK("tsensor",   "tegra-tsensor",        NULL,   100,    0x3b8,  216000000, mux_pllp_pllc_clkm_clk32,    MUX | DIV_U71 | PERIPH_ON_APB),
4396         PERIPH_CLK("actmon",    "actmon",               NULL,   119,    0x3e8,  216000000, mux_pllp_pllc_clk32_clkm,    MUX | DIV_U71),
4397         PERIPH_CLK("extern1",   "extern1",              NULL,   120,    0x3ec,  216000000, mux_plla_clk32_pllp_clkm_plle,       MUX | MUX8 | DIV_U71),
4398         PERIPH_CLK("extern2",   "extern2",              NULL,   121,    0x3f0,  216000000, mux_plla_clk32_pllp_clkm_plle,       MUX | MUX8 | DIV_U71),
4399         PERIPH_CLK("extern3",   "extern3",              NULL,   122,    0x3f4,  216000000, mux_plla_clk32_pllp_clkm_plle,       MUX | MUX8 | DIV_U71),
4400         PERIPH_CLK("i2cslow",   "i2cslow",              NULL,   81,     0x3fc,  26000000,  mux_pllp_pllc_clk32_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4401         PERIPH_CLK("pcie",      "tegra-pcie",           "pcie", 70,     0,      250000000, mux_clk_m,                   0),
4402         PERIPH_CLK("afi",       "tegra-pcie",           "afi",  72,     0,      250000000, mux_clk_m,                   0),
4403         PERIPH_CLK("se",        "se",                   NULL,   127,    0x42c,  625000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | DIV_U71_INT | PERIPH_ON_APB),
4404         PERIPH_CLK("mselect",   "mselect",              NULL,   99,     0x3b4,  108000000, mux_pllp_clkm,               MUX | DIV_U71),
4405
4406         SHARED_CLK("avp.sclk",  "tegra-avp",            "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4407         SHARED_CLK("bsea.sclk", "tegra-aes",            "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4408         SHARED_CLK("usbd.sclk", "tegra-udc.0",  "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4409         SHARED_CLK("usb1.sclk", "tegra-ehci.0",         "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4410         SHARED_CLK("usb2.sclk", "tegra-ehci.1",         "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4411         SHARED_CLK("usb3.sclk", "tegra-ehci.2",         "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4412         SHARED_CLK("wake.sclk", "wake_sclk",            "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4413         SHARED_CLK("cpu_mode.sclk","cpu_mode",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4414         SHARED_CLK("mon.avp",   "tegra_actmon",         "avp",  &tegra_clk_sbus_cmplx, NULL, 0, 0),
4415         SHARED_CLK("cap.sclk",  "cap_sclk",             NULL,   &tegra_clk_sbus_cmplx, NULL, 0, SHARED_CEILING),
4416         SHARED_CLK("floor.sclk", "floor_sclk",          NULL,   &tegra_clk_sbus_cmplx, NULL, 0, 0),
4417         SHARED_CLK("sbc1.sclk", "spi_tegra.0",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4418         SHARED_CLK("sbc2.sclk", "spi_tegra.1",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4419         SHARED_CLK("sbc3.sclk", "spi_tegra.2",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4420         SHARED_CLK("sbc4.sclk", "spi_tegra.3",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4421         SHARED_CLK("sbc5.sclk", "spi_tegra.4",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4422         SHARED_CLK("sbc6.sclk", "spi_tegra.5",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4423
4424         SHARED_CLK("avp.emc",   "tegra-avp",            "emc",  &tegra_clk_emc, NULL, 0, 0),
4425         SHARED_CLK("cpu.emc",   "cpu",                  "emc",  &tegra_clk_emc, NULL, 0, 0),
4426         SHARED_CLK("disp1.emc", "tegradc.0",            "emc",  &tegra_clk_emc, NULL, 0, SHARED_BW),
4427         SHARED_CLK("disp2.emc", "tegradc.1",            "emc",  &tegra_clk_emc, NULL, 0, SHARED_BW),
4428         SHARED_CLK("hdmi.emc",  "hdmi",                 "emc",  &tegra_clk_emc, NULL, 0, 0),
4429         SHARED_CLK("usbd.emc",  "tegra-udc.0",  "emc",  &tegra_clk_emc, NULL, 0, 0),
4430         SHARED_CLK("usb1.emc",  "tegra-ehci.0",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4431         SHARED_CLK("usb2.emc",  "tegra-ehci.1",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4432         SHARED_CLK("usb3.emc",  "tegra-ehci.2",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4433         SHARED_CLK("mon.emc",   "tegra_actmon",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4434         SHARED_CLK("cap.emc",   "cap.emc",              NULL,   &tegra_clk_emc, NULL, 0, SHARED_CEILING),
4435         SHARED_CLK("3d.emc",    "tegra_gr3d",           "emc",  &tegra_clk_emc, NULL, 0, 0),
4436         SHARED_CLK("2d.emc",    "tegra_gr2d",           "emc",  &tegra_clk_emc, NULL, 0, 0),
4437         SHARED_CLK("mpe.emc",   "tegra_mpe",            "emc",  &tegra_clk_emc, NULL, 0, 0),
4438         SHARED_CLK("camera.emc", "tegra_camera",        "emc",  &tegra_clk_emc, NULL, 0, SHARED_BW),
4439         SHARED_CLK("sdmmc4.emc", "sdhci-tegra.3",       "emc",  &tegra_clk_emc, NULL, 0, 0),
4440         SHARED_CLK("floor.emc", "floor.emc",            NULL,   &tegra_clk_emc, NULL, 0, 0),
4441
4442         SHARED_CLK("host1x.cbus", "tegra_host1x",       "host1x", &tegra_clk_cbus, "host1x", 2, SHARED_AUTO),
4443         SHARED_CLK("3d.cbus",   "tegra_gr3d",           "gr3d", &tegra_clk_cbus, "3d",  0, 0),
4444         SHARED_CLK("3d2.cbus",  "tegra_gr3d",           "gr3d2", &tegra_clk_cbus, "3d2", 0, 0),
4445         SHARED_CLK("2d.cbus",   "tegra_gr2d",           "gr2d", &tegra_clk_cbus, "2d",  0, 0),
4446         SHARED_CLK("epp.cbus",  "tegra_gr2d",           "epp",  &tegra_clk_cbus, "epp", 0, 0),
4447         SHARED_CLK("mpe.cbus",  "tegra_mpe",            "mpe",  &tegra_clk_cbus, "mpe", 0, 0),
4448         SHARED_CLK("vde.cbus",  "tegra-avp",            "vde",  &tegra_clk_cbus, "vde", 0, 0),
4449 #ifdef CONFIG_TEGRA_SE_ON_CBUS
4450         SHARED_CLK("se.cbus",   "tegra-se",             NULL,   &tegra_clk_cbus, "se",  0, 0),
4451 #endif
4452         SHARED_CLK("cap.cbus",  "cap.cbus",             NULL,   &tegra_clk_cbus, NULL,  0, SHARED_CEILING),
4453         SHARED_CLK("cap.profile.cbus", "profile.cbus",  NULL,   &tegra_clk_cbus, NULL,  0, SHARED_CEILING),
4454         SHARED_CLK("floor.cbus", "floor.cbus",          NULL,   &tegra_clk_cbus, NULL,  0, 0),
4455 };
4456
4457 #define CLK_DUPLICATE(_name, _dev, _con)                \
4458         {                                               \
4459                 .name   = _name,                        \
4460                 .lookup = {                             \
4461                         .dev_id = _dev,                 \
4462                         .con_id         = _con,         \
4463                 },                                      \
4464         }
4465
4466 /* Some clocks may be used by different drivers depending on the board
4467  * configuration.  List those here to register them twice in the clock lookup
4468  * table under two names.
4469  */
4470 struct clk_duplicate tegra_clk_duplicates[] = {
4471         CLK_DUPLICATE("usbd", "utmip-pad", NULL),
4472         CLK_DUPLICATE("usbd", "tegra-ehci.0", NULL),
4473         CLK_DUPLICATE("usbd", "tegra-otg", NULL),
4474         CLK_DUPLICATE("hdmi", "tegradc.0", "hdmi"),
4475         CLK_DUPLICATE("hdmi", "tegradc.1", "hdmi"),
4476         CLK_DUPLICATE("dsib", "tegradc.0", "dsib"),
4477         CLK_DUPLICATE("dsia", "tegradc.1", "dsia"),
4478         CLK_DUPLICATE("pwm", "tegra_pwm.0", NULL),
4479         CLK_DUPLICATE("pwm", "tegra_pwm.1", NULL),
4480         CLK_DUPLICATE("pwm", "tegra_pwm.2", NULL),
4481         CLK_DUPLICATE("pwm", "tegra_pwm.3", NULL),
4482         CLK_DUPLICATE("cop", "tegra-avp", "cop"),
4483         CLK_DUPLICATE("bsev", "tegra-avp", "bsev"),
4484         CLK_DUPLICATE("cop", "nvavp", "cop"),
4485         CLK_DUPLICATE("bsev", "nvavp", "bsev"),
4486         CLK_DUPLICATE("vde", "tegra-aes", "vde"),
4487         CLK_DUPLICATE("bsea", "tegra-aes", "bsea"),
4488         CLK_DUPLICATE("bsea", "nvavp", "bsea"),
4489         CLK_DUPLICATE("cml1", "tegra_sata_cml", NULL),
4490         CLK_DUPLICATE("cml0", "tegra_pcie", "cml"),
4491         CLK_DUPLICATE("pciex", "tegra_pcie", "pciex"),
4492         CLK_DUPLICATE("i2c1", "tegra-i2c-slave.0", NULL),
4493         CLK_DUPLICATE("i2c2", "tegra-i2c-slave.1", NULL),
4494         CLK_DUPLICATE("i2c3", "tegra-i2c-slave.2", NULL),
4495         CLK_DUPLICATE("i2c4", "tegra-i2c-slave.3", NULL),
4496         CLK_DUPLICATE("i2c5", "tegra-i2c-slave.4", NULL),
4497         CLK_DUPLICATE("sbc1", "spi_slave_tegra.0", NULL),
4498         CLK_DUPLICATE("sbc2", "spi_slave_tegra.1", NULL),
4499         CLK_DUPLICATE("sbc3", "spi_slave_tegra.2", NULL),
4500         CLK_DUPLICATE("sbc4", "spi_slave_tegra.3", NULL),
4501         CLK_DUPLICATE("sbc5", "spi_slave_tegra.4", NULL),
4502         CLK_DUPLICATE("sbc6", "spi_slave_tegra.5", NULL),
4503         CLK_DUPLICATE("twd", "smp_twd", NULL),
4504         CLK_DUPLICATE("vcp", "nvavp", "vcp"),
4505         CLK_DUPLICATE("avp.sclk", "nvavp", "sclk"),
4506         CLK_DUPLICATE("avp.emc", "nvavp", "emc"),
4507         CLK_DUPLICATE("vde.cbus", "nvavp", "vde"),
4508         CLK_DUPLICATE("epp.cbus", "tegra_isp", "epp"),
4509 };
4510
4511 struct clk *tegra_ptr_clks[] = {
4512         &tegra_clk_32k,
4513         &tegra_clk_m,
4514         &tegra_clk_m_div2,
4515         &tegra_clk_m_div4,
4516         &tegra_pll_ref,
4517         &tegra_pll_m,
4518         &tegra_pll_m_out1,
4519         &tegra_pll_c,
4520         &tegra_pll_c_out1,
4521         &tegra_pll_p,
4522         &tegra_pll_p_out1,
4523         &tegra_pll_p_out2,
4524         &tegra_pll_p_out3,
4525         &tegra_pll_p_out4,
4526         &tegra_pll_a,
4527         &tegra_pll_a_out0,
4528         &tegra_pll_d,
4529         &tegra_pll_d_out0,
4530         &tegra_pll_d2,
4531         &tegra_pll_d2_out0,
4532         &tegra_pll_u,
4533         &tegra_pll_x,
4534         &tegra_pll_x_out0,
4535         &tegra_pll_e,
4536         &tegra_cml0_clk,
4537         &tegra_cml1_clk,
4538         &tegra_pciex_clk,
4539         &tegra_clk_cclk_g,
4540         &tegra_clk_cclk_lp,
4541         &tegra_clk_sclk,
4542         &tegra_clk_hclk,
4543         &tegra_clk_pclk,
4544         &tegra_clk_virtual_cpu_g,
4545         &tegra_clk_virtual_cpu_lp,
4546         &tegra_clk_cpu_cmplx,
4547         &tegra_clk_blink,
4548         &tegra_clk_cop,
4549         &tegra_clk_sbus_cmplx,
4550         &tegra_clk_emc,
4551         &tegra3_clk_twd,
4552         &tegra_clk_emc_bridge,
4553         &tegra_clk_cbus,
4554 };
4555
4556 static int tegra3_emc_relock_set_rate(struct clk *emc, unsigned long old_rate,
4557         unsigned long new_rate, unsigned long new_pll_rate)
4558 {
4559         int ret;
4560
4561         struct clk *sbus = &tegra_clk_sbus_cmplx;
4562         struct clk *cbus = &tegra_clk_cbus;
4563         struct clk *pll_m = &tegra_pll_m;
4564         unsigned long backup_rate = emc->shared_bus_backup.bus_rate;
4565         unsigned long flags;
4566
4567         bool on_pllm = emc->parent == pll_m;
4568
4569         /*
4570          * Relock procedure pre-conditions:
4571          * - LPDDR2 only
4572          * - EMC clock is enabled, and EMC backup rate is found in DFS table
4573          * - All 3 shared buses: emc, sbus, cbus can sleep
4574          */
4575         if ((tegra_emc_get_dram_type() != DRAM_TYPE_LPDDR2) || !emc->refcnt ||
4576             !backup_rate || (cbus->parent != emc->shared_bus_backup.input) ||
4577             !clk_cansleep(emc) || !clk_cansleep(cbus) || !clk_cansleep(sbus))
4578                 return -ENOSYS;
4579
4580         /* Move sbus from PLLM by setting it at low rate threshold level */
4581         clk_lock_save(sbus, &flags);
4582         if (clk_get_rate_locked(sbus) > sbus->u.system.threshold) {
4583                 ret = clk_set_rate_locked(sbus, sbus->u.system.threshold);
4584                 if (ret)
4585                         goto _sbus_out;
4586         }
4587
4588         /* If PLLM is current EMC parent set cbus to backup rate, and move EMC
4589            to backup PLLC */
4590         if (on_pllm) {
4591                 clk_lock_save(cbus, &flags);
4592                 clk_enable(cbus->parent);
4593                 ret = clk_set_rate_locked(cbus, backup_rate);
4594                 if (ret) {
4595                         clk_disable(cbus->parent);
4596                         goto _cbus_out;
4597                 }
4598
4599                 ret = tegra_emc_backup(backup_rate);
4600                 if (ret) {
4601                         clk_disable(cbus->parent);
4602                         goto _cbus_out;
4603                 }
4604                 clk_disable(emc->parent);
4605                 clk_reparent(emc, cbus->parent);
4606         }
4607
4608         /*
4609          * Re-lock PLLM and switch EMC to it; relocking error indicates that
4610          * PLLM has some other than EMC or sbus client. In this case PLLM has
4611          * not been changed, and we still can safely switch back. Recursive
4612          * tegra3_emc_clk_set_rate() call below will be resolved, since PLLM
4613          * is now matching target rate.
4614          */
4615         ret = clk_set_rate(pll_m, new_pll_rate);
4616         if (ret) {
4617                 if (on_pllm)
4618                         tegra3_emc_clk_set_rate(emc, old_rate);
4619         } else
4620                 ret = tegra3_emc_clk_set_rate(emc, new_rate);
4621
4622
4623 _cbus_out:
4624         if (on_pllm) {
4625                 tegra3_clk_shared_bus_update(cbus);
4626                 clk_unlock_restore(cbus, &flags);
4627         }
4628
4629 _sbus_out:
4630         tegra3_clk_shared_bus_update(sbus);
4631         clk_unlock_restore(sbus, &flags);
4632
4633         return ret;
4634 }
4635
4636 /*
4637  * Backup rate targets for each CPU mode is selected below Fmax(Vmin), and
4638  * high enough to avoid voltage droop when CPU clock is switched between
4639  * backup and main clock sources. Actual backup rates will be rounded based
4640  * on backup source fixed frequency. Maximum stay-on-backup rate will be set
4641  * as a minimum of G and LP backup rates to be supported in both modes.
4642  *
4643  * Sbus threshold must be exact factor of pll_p rate.
4644  */
4645 #define CPU_G_BACKUP_RATE_TARGET        440000000
4646 #define CPU_LP_BACKUP_RATE_TARGET       220000000
4647
4648 static void tegra3_pllp_init_dependencies(unsigned long pllp_rate)
4649 {
4650         u32 div;
4651         unsigned long backup_rate;
4652
4653         switch (pllp_rate) {
4654         case 216000000:
4655                 tegra_pll_p_out1.u.pll_div.default_rate = 28800000;
4656                 tegra_pll_p_out3.u.pll_div.default_rate = 72000000;
4657                 tegra_clk_sbus_cmplx.u.system.threshold = 108000000;
4658                 break;
4659         case 408000000:
4660                 tegra_pll_p_out1.u.pll_div.default_rate = 9600000;
4661                 tegra_pll_p_out3.u.pll_div.default_rate = 102000000;
4662                 tegra_clk_sbus_cmplx.u.system.threshold = 204000000;
4663                 break;
4664         case 204000000:
4665                 tegra_pll_p_out1.u.pll_div.default_rate = 4800000;
4666                 tegra_pll_p_out3.u.pll_div.default_rate = 102000000;
4667                 tegra_clk_sbus_cmplx.u.system.threshold = 204000000;
4668                 break;
4669         default:
4670                 pr_err("tegra: PLLP rate: %lu is not supported\n", pllp_rate);
4671                 BUG();
4672         }
4673         pr_info("tegra: PLLP fixed rate: %lu\n", pllp_rate);
4674
4675         div = DIV_ROUND_UP(pllp_rate, CPU_G_BACKUP_RATE_TARGET);
4676         backup_rate = pllp_rate / div;
4677         tegra_clk_cclk_g.u.cclk.div71 = 2 * div - 2;
4678         tegra_clk_virtual_cpu_g.u.cpu.backup_rate = backup_rate;
4679         cpu_stay_on_backup_max = backup_rate;
4680
4681         div = DIV_ROUND_UP(pllp_rate, CPU_LP_BACKUP_RATE_TARGET);
4682         backup_rate = pllp_rate / div;
4683         tegra_clk_cclk_lp.u.cclk.div71 = 2 * div - 2;
4684         tegra_clk_virtual_cpu_lp.u.cpu.backup_rate = backup_rate;
4685         cpu_stay_on_backup_max = min(cpu_stay_on_backup_max, backup_rate);
4686 }
4687
4688 bool tegra_clk_is_parent_allowed(struct clk *c, struct clk *p)
4689 {
4690         if (c->flags & PERIPH_ON_CBUS)
4691                 return p != &tegra_pll_m;
4692         else
4693                 return p != &tegra_pll_c;
4694
4695         return true;
4696 }
4697
4698 static void tegra3_init_one_clock(struct clk *c)
4699 {
4700         clk_init(c);
4701         INIT_LIST_HEAD(&c->shared_bus_list);
4702         if (!c->lookup.dev_id && !c->lookup.con_id)
4703                 c->lookup.con_id = c->name;
4704         c->lookup.clk = c;
4705         clkdev_add(&c->lookup);
4706 }
4707
4708 /*
4709  * Emergency throttle of G-CPU by setting G-super clock skipper underneath
4710  * clock framework, dvfs, and cpufreq driver s/w layers. Can be called in
4711  * ISR context for EDP events. When releasing throttle, LP-divider is cleared
4712  * just in case it was set as a result of save/restore operations across
4713  * cluster switch (should not happen)
4714  */
4715 void tegra_edp_throttle_cpu_now(u8 factor)
4716 {
4717         if (factor > 1) {
4718                 if (!is_lp_cluster())
4719                         tegra3_super_clk_skipper_update(
4720                                 &tegra_clk_cclk_g, 1, factor);
4721         } else if (factor == 0) {
4722                 tegra3_super_clk_skipper_update(&tegra_clk_cclk_g, 0, 0);
4723                 tegra3_super_clk_skipper_update(&tegra_clk_cclk_lp, 0, 0);
4724         }
4725 }
4726
4727 #ifdef CONFIG_CPU_FREQ
4728
4729 /*
4730  * Frequency table index must be sequential starting at 0 and frequencies
4731  * must be ascending. Re-configurable PLLX is used as a source for rates
4732  * above 204MHz. Rates 204MHz and below are divided down from fixed frequency
4733  * PLLP that may run either at 408MHz or at 204MHz on Tegra3 silicon platforms
4734  * (on FPGA platform PLLP output is reported as 216MHz, but no respective
4735  * tables are provided, since there is no clock scaling on FPGA at all).
4736  */
4737
4738 static struct cpufreq_frequency_table freq_table_300MHz[] = {
4739         { 0, 204000 },
4740         { 1, 300000 },
4741         { 2, CPUFREQ_TABLE_END },
4742 };
4743
4744 static struct cpufreq_frequency_table freq_table_1p0GHz[] = {
4745         { 0,  51000 },
4746         { 1, 102000 },
4747         { 2, 204000 },
4748         { 3, 312000 },
4749         { 4, 456000 },
4750         { 5, 608000 },
4751         { 6, 760000 },
4752         { 7, 816000 },
4753         { 8, 912000 },
4754         { 9, 1000000 },
4755         {10, CPUFREQ_TABLE_END },
4756 };
4757
4758 static struct cpufreq_frequency_table freq_table_1p3GHz[] = {
4759         { 0,   51000 },
4760         { 1,  102000 },
4761         { 2,  204000 },
4762         { 3,  340000 },
4763         { 4,  475000 },
4764         { 5,  640000 },
4765         { 6,  760000 },
4766         { 7,  860000 },
4767         { 8, 1000000 },
4768         { 9, 1100000 },
4769         {10, 1200000 },
4770         {11, 1300000 },
4771         {12, CPUFREQ_TABLE_END },
4772 };
4773
4774 static struct cpufreq_frequency_table freq_table_1p4GHz[] = {
4775         { 0,   51000 },
4776         { 1,  102000 },
4777         { 2,  204000 },
4778         { 3,  370000 },
4779         { 4,  475000 },
4780         { 5,  620000 },
4781         { 6,  760000 },
4782         { 7,  860000 },
4783         { 8, 1000000 },
4784         { 9, 1100000 },
4785         {10, 1200000 },
4786         {11, 1300000 },
4787         {12, 1400000 },
4788         {13, CPUFREQ_TABLE_END },
4789 };
4790
4791 static struct cpufreq_frequency_table freq_table_1p5GHz[] = {
4792         { 0,   51000 },
4793         { 1,  102000 },
4794         { 2,  204000 },
4795         { 3,  340000 },
4796         { 4,  475000 },
4797         { 5,  640000 },
4798         { 6,  760000 },
4799         { 7,  860000 },
4800         { 8, 1000000 },
4801         { 9, 1100000 },
4802         {10, 1200000 },
4803         {11, 1300000 },
4804         {12, 1400000 },
4805         {13, 1500000 },
4806         {14, CPUFREQ_TABLE_END },
4807 };
4808
4809 static struct cpufreq_frequency_table freq_table_1p7GHz[] = {
4810         { 0,   51000 },
4811         { 1,  102000 },
4812         { 2,  204000 },
4813         { 3,  370000 },
4814         { 4,  475000 },
4815         { 5,  620000 },
4816         { 6,  760000 },
4817         { 7,  910000 },
4818         { 8, 1000000 },
4819         { 9, 1150000 },
4820         {10, 1300000 },
4821         {11, 1400000 },
4822         {12, 1500000 },
4823         {13, 1600000 },
4824         {14, 1700000 },
4825         {15, CPUFREQ_TABLE_END },
4826 };
4827
4828 static struct tegra_cpufreq_table_data cpufreq_tables[] = {
4829         { freq_table_300MHz, 0,  1 },
4830         { freq_table_1p0GHz, 2,  8 },
4831         { freq_table_1p3GHz, 2, 10 },
4832         { freq_table_1p4GHz, 2, 11 },
4833         { freq_table_1p5GHz, 2, 12 },
4834         { freq_table_1p7GHz, 2, 12 },
4835 };
4836
4837 static int clip_cpu_rate_limits(
4838         struct tegra_cpufreq_table_data *data,
4839         struct cpufreq_policy *policy,
4840         struct clk *cpu_clk_g,
4841         struct clk *cpu_clk_lp)
4842 {
4843         int idx, ret;
4844         struct cpufreq_frequency_table *freq_table = data->freq_table;
4845
4846         /* clip CPU G mode maximum frequency to table entry */
4847         ret = cpufreq_frequency_table_target(policy, freq_table,
4848                 cpu_clk_g->max_rate / 1000, CPUFREQ_RELATION_H, &idx);
4849         if (ret) {
4850                 pr_err("%s: G CPU max rate %lu outside of cpufreq table",
4851                        __func__, cpu_clk_g->max_rate);
4852                 return ret;
4853         }
4854         cpu_clk_g->max_rate = freq_table[idx].frequency * 1000;
4855         if (cpu_clk_g->max_rate < cpu_clk_lp->max_rate) {
4856                 pr_err("%s: G CPU max rate %lu is below LP CPU max rate %lu",
4857                        __func__, cpu_clk_g->max_rate, cpu_clk_lp->max_rate);
4858                 return -EINVAL;
4859         }
4860
4861         /* clip CPU LP mode maximum frequency to table entry, and
4862            set CPU G mode minimum frequency one table step below */
4863         ret = cpufreq_frequency_table_target(policy, freq_table,
4864                 cpu_clk_lp->max_rate / 1000, CPUFREQ_RELATION_H, &idx);
4865         if (ret || !idx) {
4866                 pr_err("%s: LP CPU max rate %lu %s of cpufreq table", __func__,
4867                        cpu_clk_lp->max_rate, ret ? "outside" : "at the bottom");
4868                 return ret;
4869         }
4870         cpu_clk_lp->max_rate = freq_table[idx].frequency * 1000;
4871         cpu_clk_g->min_rate = freq_table[idx-1].frequency * 1000;
4872         data->suspend_index = idx;
4873         return 0;
4874 }
4875
4876 struct tegra_cpufreq_table_data *tegra_cpufreq_table_get(void)
4877 {
4878         int i, ret;
4879         unsigned long selection_rate;
4880         struct clk *cpu_clk_g = tegra_get_clock_by_name("cpu_g");
4881         struct clk *cpu_clk_lp = tegra_get_clock_by_name("cpu_lp");
4882
4883         /* For table selection use top cpu_g rate in dvfs ladder; selection
4884            rate may exceed cpu max_rate (e.g., because of edp limitations on
4885            cpu voltage) - in any case max_rate will be clipped to the table */
4886         if (cpu_clk_g->dvfs && cpu_clk_g->dvfs->num_freqs)
4887                 selection_rate =
4888                         cpu_clk_g->dvfs->freqs[cpu_clk_g->dvfs->num_freqs - 1];
4889         else
4890                 selection_rate = cpu_clk_g->max_rate;
4891
4892         for (i = 0; i < ARRAY_SIZE(cpufreq_tables); i++) {
4893                 struct cpufreq_policy policy;
4894                 policy.cpu = 0; /* any on-line cpu */
4895                 ret = cpufreq_frequency_table_cpuinfo(
4896                         &policy, cpufreq_tables[i].freq_table);
4897                 if (!ret) {
4898                         if ((policy.max * 1000) == selection_rate) {
4899                                 ret = clip_cpu_rate_limits(
4900                                         &cpufreq_tables[i],
4901                                         &policy, cpu_clk_g, cpu_clk_lp);
4902                                 if (!ret)
4903                                         return &cpufreq_tables[i];
4904                         }
4905                 }
4906         }
4907         WARN(1, "%s: No cpufreq table matching G & LP cpu ranges", __func__);
4908         return NULL;
4909 }
4910
4911 /* On DDR3 platforms there is an implicit dependency in this mapping: when cpu
4912  * exceeds max dvfs level for LP CPU clock at TEGRA_EMC_BRIDGE_MVOLTS_MIN, the
4913  * respective emc rate should be above TEGRA_EMC_BRIDGE_RATE_MIN
4914  */
4915 /* FIXME: explicitly check this dependency */
4916 unsigned long tegra_emc_to_cpu_ratio(unsigned long cpu_rate)
4917 {
4918         static unsigned long emc_max_rate = 0;
4919
4920         if (emc_max_rate == 0)
4921                 emc_max_rate = clk_round_rate(
4922                         tegra_get_clock_by_name("emc"), ULONG_MAX);
4923
4924         /* Vote on memory bus frequency based on cpu frequency;
4925            cpu rate is in kHz, emc rate is in Hz */
4926         if (cpu_rate >= 925000)
4927                 return emc_max_rate;    /* cpu >= 925 MHz, emc max */
4928         else if (cpu_rate >= 450000)
4929                 return emc_max_rate/2;  /* cpu >= 450 MHz, emc max/2 */
4930         else if (cpu_rate >= 250000)
4931                 return 100000000;       /* cpu >= 250 MHz, emc 100 MHz */
4932         else
4933                 return 0;               /* emc min */
4934 }
4935
4936 int tegra_update_mselect_rate(unsigned long cpu_rate)
4937 {
4938         static struct clk *mselect = NULL;
4939
4940         unsigned long mselect_rate;
4941
4942         if (!mselect) {
4943                 mselect = tegra_get_clock_by_name("mselect");
4944                 if (!mselect)
4945                         return -ENODEV;
4946         }
4947
4948         /* Vote on mselect frequency based on cpu frequency:
4949            keep mselect at half of cpu rate up to 102 MHz;
4950            cpu rate is in kHz, mselect rate is in Hz */
4951         mselect_rate = DIV_ROUND_UP(cpu_rate, 2) * 1000;
4952         mselect_rate = min(mselect_rate, 102000000UL);
4953
4954         if (mselect_rate != clk_get_rate(mselect))
4955                 return clk_set_rate(mselect, mselect_rate);
4956
4957         return 0;
4958 }
4959 #endif
4960
4961 #ifdef CONFIG_PM_SLEEP
4962 static u32 clk_rst_suspend[RST_DEVICES_NUM + CLK_OUT_ENB_NUM +
4963                            PERIPH_CLK_SOURCE_NUM + 24];
4964
4965 static int tegra_clk_suspend(void)
4966 {
4967         unsigned long off;
4968         u32 *ctx = clk_rst_suspend;
4969
4970         *ctx++ = clk_readl(OSC_CTRL) & OSC_CTRL_MASK;
4971         *ctx++ = clk_readl(CPU_SOFTRST_CTRL);
4972
4973         *ctx++ = clk_readl(tegra_pll_p_out1.reg);
4974         *ctx++ = clk_readl(tegra_pll_p_out3.reg);
4975
4976         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_BASE);
4977         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
4978         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_BASE);
4979         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
4980         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_BASE);
4981         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
4982         *ctx++ = clk_readl(tegra_pll_d2.reg + PLL_BASE);
4983         *ctx++ = clk_readl(tegra_pll_d2.reg + PLL_MISC(&tegra_pll_d2));
4984
4985         *ctx++ = clk_readl(tegra_pll_m_out1.reg);
4986         *ctx++ = clk_readl(tegra_pll_a_out0.reg);
4987         *ctx++ = clk_readl(tegra_pll_c_out1.reg);
4988
4989         *ctx++ = clk_readl(tegra_clk_cclk_g.reg);
4990         *ctx++ = clk_readl(tegra_clk_cclk_g.reg + SUPER_CLK_DIVIDER);
4991         *ctx++ = clk_readl(tegra_clk_cclk_lp.reg);
4992         *ctx++ = clk_readl(tegra_clk_cclk_lp.reg + SUPER_CLK_DIVIDER);
4993
4994         *ctx++ = clk_readl(tegra_clk_sclk.reg);
4995         *ctx++ = clk_readl(tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
4996         *ctx++ = clk_readl(tegra_clk_pclk.reg);
4997
4998         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
4999                         off += 4) {
5000                 if (off == PERIPH_CLK_SOURCE_EMC)
5001                         continue;
5002                 *ctx++ = clk_readl(off);
5003         }
5004         for (off = PERIPH_CLK_SOURCE_G3D2; off <= PERIPH_CLK_SOURCE_SE;
5005                         off+=4) {
5006                 *ctx++ = clk_readl(off);
5007         }
5008         for (off = AUDIO_DLY_CLK; off <= AUDIO_SYNC_CLK_SPDIF; off+=4) {
5009                 *ctx++ = clk_readl(off);
5010         }
5011
5012         *ctx++ = clk_readl(RST_DEVICES_L);
5013         *ctx++ = clk_readl(RST_DEVICES_H);
5014         *ctx++ = clk_readl(RST_DEVICES_U);
5015         *ctx++ = clk_readl(RST_DEVICES_V);
5016         *ctx++ = clk_readl(RST_DEVICES_W);
5017
5018         *ctx++ = clk_readl(CLK_OUT_ENB_L);
5019         *ctx++ = clk_readl(CLK_OUT_ENB_H);
5020         *ctx++ = clk_readl(CLK_OUT_ENB_U);
5021         *ctx++ = clk_readl(CLK_OUT_ENB_V);
5022         *ctx++ = clk_readl(CLK_OUT_ENB_W);
5023
5024         *ctx++ = clk_readl(MISC_CLK_ENB);
5025         *ctx++ = clk_readl(CLK_MASK_ARM);
5026
5027         return 0;
5028 }
5029
5030 static void tegra_clk_resume(void)
5031 {
5032         unsigned long off;
5033         const u32 *ctx = clk_rst_suspend;
5034         u32 val;
5035         u32 pllc_base;
5036         u32 plla_base;
5037         u32 plld_base;
5038         u32 plld2_base;
5039         u32 pll_p_out12, pll_p_out34;
5040         u32 pll_a_out0, pll_m_out1, pll_c_out1;
5041         struct clk *p;
5042
5043         val = clk_readl(OSC_CTRL) & ~OSC_CTRL_MASK;
5044         val |= *ctx++;
5045         clk_writel(val, OSC_CTRL);
5046         clk_writel(*ctx++, CPU_SOFTRST_CTRL);
5047
5048         /* Since we are going to reset devices and switch clock sources in this
5049          * function, plls and secondary dividers is required to be enabled. The
5050          * actual value will be restored back later. Note that boot plls: pllm,
5051          * pllp, and pllu are already configured and enabled.
5052          */
5053         val = PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
5054         val |= val << 16;
5055         pll_p_out12 = *ctx++;
5056         clk_writel(pll_p_out12 | val, tegra_pll_p_out1.reg);
5057         pll_p_out34 = *ctx++;
5058         clk_writel(pll_p_out34 | val, tegra_pll_p_out3.reg);
5059
5060         pllc_base = *ctx++;
5061         clk_writel(pllc_base | PLL_BASE_ENABLE, tegra_pll_c.reg + PLL_BASE);
5062         clk_writel(*ctx++, tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
5063
5064         plla_base = *ctx++;
5065         clk_writel(plla_base | PLL_BASE_ENABLE, tegra_pll_a.reg + PLL_BASE);
5066         clk_writel(*ctx++, tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
5067
5068         plld_base = *ctx++;
5069         clk_writel(plld_base | PLL_BASE_ENABLE, tegra_pll_d.reg + PLL_BASE);
5070         clk_writel(*ctx++, tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
5071
5072         plld2_base = *ctx++;
5073         clk_writel(plld2_base | PLL_BASE_ENABLE, tegra_pll_d2.reg + PLL_BASE);
5074         clk_writel(*ctx++, tegra_pll_d2.reg + PLL_MISC(&tegra_pll_d2));
5075
5076         udelay(1000);
5077
5078         val = PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
5079         pll_m_out1 = *ctx++;
5080         clk_writel(pll_m_out1 | val, tegra_pll_m_out1.reg);
5081         pll_a_out0 = *ctx++;
5082         clk_writel(pll_a_out0 | val, tegra_pll_a_out0.reg);
5083         pll_c_out1 = *ctx++;
5084         clk_writel(pll_c_out1 | val, tegra_pll_c_out1.reg);
5085
5086         clk_writel(*ctx++, tegra_clk_cclk_g.reg);
5087         clk_writel(*ctx++, tegra_clk_cclk_g.reg + SUPER_CLK_DIVIDER);
5088         clk_writel(*ctx++, tegra_clk_cclk_lp.reg);
5089         clk_writel(*ctx++, tegra_clk_cclk_lp.reg + SUPER_CLK_DIVIDER);
5090
5091         clk_writel(*ctx++, tegra_clk_sclk.reg);
5092         clk_writel(*ctx++, tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
5093         clk_writel(*ctx++, tegra_clk_pclk.reg);
5094
5095         /* enable all clocks before configuring clock sources */
5096         clk_writel(0xfdfffff1ul, CLK_OUT_ENB_L);
5097         clk_writel(0xfefff7f7ul, CLK_OUT_ENB_H);
5098         clk_writel(0x75f79bfful, CLK_OUT_ENB_U);
5099         clk_writel(0xfffffffful, CLK_OUT_ENB_V);
5100         clk_writel(0x00003ffful, CLK_OUT_ENB_W);
5101         wmb();
5102
5103         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
5104                         off += 4) {
5105                 if (off == PERIPH_CLK_SOURCE_EMC)
5106                         continue;
5107                 clk_writel(*ctx++, off);
5108         }
5109         for (off = PERIPH_CLK_SOURCE_G3D2; off <= PERIPH_CLK_SOURCE_SE;
5110                         off += 4) {
5111                 clk_writel(*ctx++, off);
5112         }
5113         for (off = AUDIO_DLY_CLK; off <= AUDIO_SYNC_CLK_SPDIF; off+=4) {
5114                 clk_writel(*ctx++, off);
5115         }
5116         wmb();
5117
5118         clk_writel(*ctx++, RST_DEVICES_L);
5119         clk_writel(*ctx++, RST_DEVICES_H);
5120         clk_writel(*ctx++, RST_DEVICES_U);
5121
5122         /* For LP0 resume, don't reset lpcpu, since we are running from it */
5123         val = *ctx++;
5124         val &= ~RST_DEVICES_V_SWR_CPULP_RST_DIS;
5125         clk_writel(val, RST_DEVICES_V);
5126
5127         clk_writel(*ctx++, RST_DEVICES_W);
5128         wmb();
5129
5130         clk_writel(*ctx++, CLK_OUT_ENB_L);
5131         clk_writel(*ctx++, CLK_OUT_ENB_H);
5132         clk_writel(*ctx++, CLK_OUT_ENB_U);
5133
5134         /* For LP0 resume, clk to lpcpu is required to be on */
5135         val = *ctx++;
5136         val |= CLK_OUT_ENB_V_CLK_ENB_CPULP_EN;
5137         clk_writel(val, CLK_OUT_ENB_V);
5138
5139         clk_writel(*ctx++, CLK_OUT_ENB_W);
5140         wmb();
5141
5142         clk_writel(*ctx++, MISC_CLK_ENB);
5143         clk_writel(*ctx++, CLK_MASK_ARM);
5144
5145         /* Restore back the actual pll and secondary divider values */
5146         /* FIXME: need to root cause why pllc is required to be on
5147          * clk_writel(pllc_base, tegra_pll_c.reg + PLL_BASE);
5148          */
5149         clk_writel(pll_p_out12, tegra_pll_p_out1.reg);
5150         clk_writel(pll_p_out34, tegra_pll_p_out3.reg);
5151
5152         clk_writel(plla_base, tegra_pll_a.reg + PLL_BASE);
5153         clk_writel(plld_base, tegra_pll_d.reg + PLL_BASE);
5154         clk_writel(plld2_base, tegra_pll_d2.reg + PLL_BASE);
5155
5156         clk_writel(pll_m_out1, tegra_pll_m_out1.reg);
5157         clk_writel(pll_a_out0, tegra_pll_a_out0.reg);
5158         clk_writel(pll_c_out1, tegra_pll_c_out1.reg);
5159
5160         /* Since EMC clock is not restored, and may not preserve parent across
5161            suspend, update current state, and mark EMC DFS as out of sync */
5162         tegra3_pll_m_override_update(&tegra_pll_m, false);
5163         p = tegra_clk_emc.parent;
5164         tegra3_periph_clk_init(&tegra_clk_emc);
5165
5166         if (p != tegra_clk_emc.parent) {
5167                 /* FIXME: old parent is left enabled here even if EMC was its
5168                    only child before suspend (never happens on Tegra3) */
5169                 pr_debug("EMC parent(refcount) across suspend: %s(%d) : %s(%d)",
5170                         p->name, p->refcnt, tegra_clk_emc.parent->name,
5171                         tegra_clk_emc.parent->refcnt);
5172
5173                 BUG_ON(!p->refcnt);
5174                 p->refcnt--;
5175
5176                 /* the new parent is enabled by low level code, but ref count
5177                    need to be updated up to the root */
5178                 p = tegra_clk_emc.parent;
5179                 while (p && ((p->refcnt++) == 0))
5180                         p = p->parent;
5181         }
5182         tegra_emc_timing_invalidate();
5183
5184         tegra3_pll_clk_init(&tegra_pll_u); /* Re-init utmi parameters */
5185         tegra3_pllp_clk_resume(&tegra_pll_p); /* Fire a bug if not restored */
5186 }
5187 #else
5188 #define tegra_clk_suspend NULL
5189 #define tegra_clk_resume NULL
5190 #endif
5191
5192 static struct syscore_ops tegra_clk_syscore_ops = {
5193         .suspend = tegra_clk_suspend,
5194         .resume = tegra_clk_resume,
5195 };
5196
5197 #ifdef CONFIG_TEGRA_PREINIT_CLOCKS
5198
5199 #define CLK_RSTENB_DEV_V_0_DAM2_BIT     (1 << 14)
5200 #define CLK_RSTENB_DEV_V_0_DAM1_BIT     (1 << 13)
5201 #define CLK_RSTENB_DEV_V_0_DAM0_BIT     (1 << 12)
5202 #define CLK_RSTENB_DEV_V_0_AUDIO_BIT    (1 << 10)
5203 #define CLK_RSTENB_DEV_V_0_3D2_BIT      (1 << 2)
5204
5205 #define CLK_RSTENB_DEV_L_0_HOST1X_BIT   (1 << 28)
5206 #define CLK_RSTENB_DEV_L_0_DISP1_BIT    (1 << 27)
5207 #define CLK_RSTENB_DEV_L_0_3D_BIT       (1 << 24)
5208 #define CLK_RSTENB_DEV_L_0_2D_BIT       (1 << 21)
5209 #define CLK_RSTENB_DEV_L_0_VI_BIT       (1 << 20)
5210 #define CLK_RSTENB_DEV_L_0_EPP_BIT      (1 << 19)
5211
5212 #define CLK_RSTENB_DEV_H_0_VDE_BIT      (1 << 29)
5213 #define CLK_RSTENB_DEV_H_0_MPE_BIT      (1 << 28)
5214
5215 #define DISP1_CLK_REG_OFFSET            0x138
5216 #define DISP1_CLK_SRC_SHIFT             29
5217 #define DISP1_CLK_SRC_MASK              (0x7 << DISP1_CLK_SRC_SHIFT)
5218 #define DISP1_CLK_SRC_PLLP_OUT0         0
5219 #define DISP1_CLK_SRC_PLLM_OUT0         1
5220 #define DISP1_CLK_SRC_PLLD_OUT0         2
5221 #define DISP1_CLK_SRC_PLLA_OUT0         3
5222 #define DISP1_CLK_SRC_PLLC_OUT0         4
5223 #define DISP1_CLK_SRC_PLLD2_OUT0        5
5224 #define DISP1_CLK_SRC_CLKM              6
5225 #define DISP1_CLK_SRC_DEFAULT (DISP1_CLK_SRC_PLLP_OUT0 << DISP1_CLK_SRC_SHIFT)
5226
5227 #define HOST1X_CLK_REG_OFFSET           0x180
5228 #define HOST1X_CLK_SRC_SHIFT            30
5229 #define HOST1X_CLK_SRC_MASK             (0x3 << HOST1X_CLK_SRC_SHIFT)
5230 #define HOST1X_CLK_SRC_PLLM_OUT0        0
5231 #define HOST1X_CLK_SRC_PLLC_OUT0        1
5232 #define HOST1X_CLK_SRC_PLLP_OUT0        2
5233 #define HOST1X_CLK_SRC_PLLA_OUT0        3
5234 #define HOST1X_CLK_SRC_DEFAULT (\
5235                 HOST1X_CLK_SRC_PLLP_OUT0 << HOST1X_CLK_SRC_SHIFT)
5236 #define HOST1X_CLK_IDLE_DIV_SHIFT       8
5237 #define HOST1X_CLK_IDLE_DIV_MASK        (0xff << HOST1X_CLK_IDLE_DIV_SHIFT)
5238 #define HOST1X_CLK_IDLE_DIV_DEFAULT     (0 << HOST1X_CLK_IDLE_DIV_SHIFT)
5239 #define HOST1X_CLK_DIV_SHIFT            0
5240 #define HOST1X_CLK_DIV_MASK             (0xff << HOST1X_CLK_DIV_SHIFT)
5241 #define HOST1X_CLK_DIV_DEFAULT          (3 << HOST1X_CLK_DIV_SHIFT)
5242
5243 #define AUDIO_CLK_REG_OFFSET            0x3d0
5244 #define DAM0_CLK_REG_OFFSET             0x3d8
5245 #define DAM1_CLK_REG_OFFSET             0x3dc
5246 #define DAM2_CLK_REG_OFFSET             0x3e0
5247 #define AUDIO_CLK_SRC_SHIFT             28
5248 #define AUDIO_CLK_SRC_MASK              (0x0f << AUDIO_CLK_SRC_SHIFT)
5249 #define AUDIO_CLK_SRC_PLLA_OUT0         0x01
5250 #define AUDIO_CLK_SRC_PLLC_OUT0         0x05
5251 #define AUDIO_CLK_SRC_PLLP_OUT0         0x09
5252 #define AUDIO_CLK_SRC_CLKM              0x0d
5253 #define AUDIO_CLK_SRC_DEFAULT (\
5254                 AUDIO_CLK_SRC_CLKM << AUDIO_CLK_SRC_SHIFT)
5255 #define AUDIO_CLK_DIV_SHIFT             0
5256 #define AUDIO_CLK_DIV_MASK              (0xff << AUDIO_CLK_DIV_SHIFT)
5257 #define AUDIO_CLK_DIV_DEFAULT (\
5258                 (0 << AUDIO_CLK_DIV_SHIFT))
5259
5260 #define VCLK_SRC_SHIFT                  30
5261 #define VCLK_SRC_MASK                   (0x3 << VCLK_SRC_SHIFT)
5262 #define VCLK_SRC_PLLM_OUT0              0
5263 #define VCLK_SRC_PLLC_OUT0              1
5264 #define VCLK_SRC_PLLP_OUT0              2
5265 #define VCLK_SRC_PLLA_OUT0              3
5266 #define VCLK_SRC_DEFAULT                (VCLK_SRC_PLLM_OUT0 << VCLK_SRC_SHIFT)
5267 #define VCLK_IDLE_DIV_SHIFT             8
5268 #define VCLK_IDLE_DIV_MASK              (0xff << VCLK_IDLE_DIV_SHIFT)
5269 #define VCLK_IDLE_DIV_DEFAULT           (0 << VCLK_IDLE_DIV_SHIFT)
5270 #define VCLK_DIV_SHIFT                  0
5271 #define VCLK_DIV_MASK                   (0xff << VCLK_DIV_SHIFT)
5272 #define VCLK_DIV_DEFAULT                (0xa << VCLK_DIV_SHIFT)
5273
5274 #define VI_CLK_REG_OFFSET               0x148
5275 #define  VI_CLK_SEL_VI_SENSOR_CLK       (1 << 25)
5276 #define  VI_CLK_SEL_EXTERNAL_CLK        (1 << 24)
5277 #define  VI_SENSOR_CLK_REG_OFFSET       0x1a8
5278 #define G3D_CLK_REG_OFFSET              0x158
5279 #define G2D_CLK_REG_OFFSET              0x15c
5280 #define EPP_CLK_REG_OFFSET              0x16c
5281 #define MPE_CLK_REG_OFFSET              0x170
5282 #define VDE_CLK_REG_OFFSET              0x170
5283 #define G3D2_CLK_REG_OFFSET             0x3b0
5284
5285 static void __init clk_setbit(u32 reg, u32 bit)
5286 {
5287         u32 val = clk_readl(reg);
5288
5289         if ((val & bit) == bit)
5290                 return;
5291         val |= bit;
5292         clk_writel(val, reg);
5293         udelay(2);
5294 }
5295
5296 static void __init clk_clrbit(u32 reg, u32 bit)
5297 {
5298         u32 val = clk_readl(reg);
5299
5300         if ((val & bit) == 0)
5301                 return;
5302         val &= ~bit;
5303         clk_writel(val, reg);
5304         udelay(2);
5305 }
5306
5307 static void __init clk_setbits(u32 reg, u32 bits, u32 mask)
5308 {
5309         u32 val = clk_readl(reg);
5310
5311         if ((val & mask) == bits)
5312                 return;
5313         val &= ~mask;
5314         val |= bits;
5315         clk_writel(val, reg);
5316         udelay(2);
5317 }
5318
5319 static void __init vclk_init(int tag, u32 src, u32 rebit)
5320 {
5321         u32 rst, enb;
5322
5323         switch (tag) {
5324         case 'L':
5325                 rst = RST_DEVICES_L;
5326                 enb = CLK_OUT_ENB_L;
5327                 break;
5328         case 'H':
5329                 rst = RST_DEVICES_H;
5330                 enb = CLK_OUT_ENB_H;
5331                 break;
5332         case 'U':
5333                 rst = RST_DEVICES_U;
5334                 enb = CLK_OUT_ENB_U;
5335                 break;
5336         case 'V':
5337                 rst = RST_DEVICES_V;
5338                 enb = CLK_OUT_ENB_V;
5339                 break;
5340         case 'W':
5341                 rst = RST_DEVICES_W;
5342                 enb = CLK_OUT_ENB_W;
5343                 break;
5344         default:
5345                 /* Quietly ignore. */
5346                 return;
5347         }
5348
5349         clk_setbit(rst, rebit);
5350         clk_clrbit(enb, rebit);
5351         clk_setbits(src, VCLK_SRC_DEFAULT, VCLK_SRC_MASK);
5352         clk_setbits(src, VCLK_DIV_DEFAULT, VCLK_DIV_MASK);
5353         clk_clrbit(rst, rebit);
5354 }
5355
5356 static int __init tegra_soc_preinit_clocks(void)
5357 {
5358         /*
5359          * Make sure host1x clock configuration has:
5360          *      HOST1X_CLK_SRC    : PLLP_OUT0.
5361          *      HOST1X_CLK_DIVISOR: >2 to start from safe enough frequency.
5362          */
5363         clk_setbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_HOST1X_BIT);
5364         clk_setbit(CLK_OUT_ENB_L, CLK_RSTENB_DEV_L_0_HOST1X_BIT);
5365         clk_setbits(HOST1X_CLK_REG_OFFSET,
5366                     HOST1X_CLK_DIV_DEFAULT, HOST1X_CLK_DIV_MASK);
5367         clk_setbits(HOST1X_CLK_REG_OFFSET,
5368                     HOST1X_CLK_IDLE_DIV_DEFAULT, HOST1X_CLK_IDLE_DIV_MASK);
5369         clk_setbits(HOST1X_CLK_REG_OFFSET,
5370                     HOST1X_CLK_SRC_DEFAULT, HOST1X_CLK_SRC_MASK);
5371         clk_clrbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_HOST1X_BIT);
5372
5373         /*
5374          *  Make sure disp1 clock configuration ha:
5375          *      DISP1_CLK_SRC:  DISP1_CLK_SRC_PLLP_OUT0
5376          */
5377         clk_setbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_DISP1_BIT);
5378         clk_setbit(CLK_OUT_ENB_L, CLK_RSTENB_DEV_L_0_DISP1_BIT);
5379         clk_setbits(DISP1_CLK_REG_OFFSET,
5380                     DISP1_CLK_SRC_DEFAULT, DISP1_CLK_SRC_MASK);
5381         clk_clrbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_DISP1_BIT);
5382
5383         /*
5384          *  Make sure dam2 clock configuration has:
5385          *      DAM2_CLK_SRC:   AUDIO_CLK_SRC_CLKM
5386          */
5387         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM2_BIT);
5388         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_DAM2_BIT);
5389         clk_setbits(DAM2_CLK_REG_OFFSET,
5390                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5391         clk_setbits(DAM2_CLK_REG_OFFSET,
5392                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5393         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM2_BIT);
5394
5395         /*
5396          *  Make sure dam1 clock configuration has:
5397          *      DAM1_CLK_SRC:   AUDIO_CLK_SRC_CLKM
5398          */
5399         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM1_BIT);
5400         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_DAM1_BIT);
5401         clk_setbits(DAM1_CLK_REG_OFFSET,
5402                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5403         clk_setbits(DAM1_CLK_REG_OFFSET,
5404                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5405         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM1_BIT);
5406
5407         /*
5408          *  Make sure dam0 clock configuration has:
5409          *      DAM0_CLK_SRC:   AUDIO_CLK_SRC_CLKM
5410          */
5411         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM0_BIT);
5412         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_DAM0_BIT);
5413         clk_setbits(DAM0_CLK_REG_OFFSET,
5414                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5415         clk_setbits(DAM0_CLK_REG_OFFSET,
5416                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5417         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM0_BIT);
5418
5419         /*
5420          *  Make sure d_audio clock configuration has:
5421          *      AUDIO_CLK_SRC:  AUDIO_CLK_SRC_CLKM
5422          */
5423         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_AUDIO_BIT);
5424         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_AUDIO_BIT);
5425         clk_setbits(AUDIO_CLK_REG_OFFSET,
5426                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5427         clk_setbits(AUDIO_CLK_REG_OFFSET,
5428                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5429         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_AUDIO_BIT);
5430
5431         /* Pre-initialize Video clocks. */
5432         vclk_init('L', G3D_CLK_REG_OFFSET, CLK_RSTENB_DEV_L_0_3D_BIT);
5433         vclk_init('L', G2D_CLK_REG_OFFSET, CLK_RSTENB_DEV_L_0_2D_BIT);
5434         vclk_init('L', VI_CLK_REG_OFFSET, CLK_RSTENB_DEV_L_0_VI_BIT);
5435         vclk_init('L', EPP_CLK_REG_OFFSET, CLK_RSTENB_DEV_L_0_EPP_BIT);
5436         vclk_init('H', VDE_CLK_REG_OFFSET, CLK_RSTENB_DEV_H_0_VDE_BIT);
5437         vclk_init('H', MPE_CLK_REG_OFFSET, CLK_RSTENB_DEV_H_0_MPE_BIT);
5438         vclk_init('V', G3D2_CLK_REG_OFFSET, CLK_RSTENB_DEV_V_0_3D2_BIT);
5439
5440         return 0;
5441 }
5442 #endif /* CONFIG_TEGRA_PREINIT_CLOCKS */
5443
5444 void __init tegra_soc_init_clocks(void)
5445 {
5446         int i;
5447         struct clk *c;
5448
5449 #ifdef CONFIG_TEGRA_PREINIT_CLOCKS
5450         tegra_soc_preinit_clocks();
5451 #endif /* CONFIG_TEGRA_PREINIT_CLOCKS */
5452
5453         for (i = 0; i < ARRAY_SIZE(tegra_ptr_clks); i++)
5454                 tegra3_init_one_clock(tegra_ptr_clks[i]);
5455
5456         for (i = 0; i < ARRAY_SIZE(tegra_list_clks); i++)
5457                 tegra3_init_one_clock(&tegra_list_clks[i]);
5458
5459         for (i = 0; i < ARRAY_SIZE(tegra_clk_duplicates); i++) {
5460                 c = tegra_get_clock_by_name(tegra_clk_duplicates[i].name);
5461                 if (!c) {
5462                         pr_err("%s: Unknown duplicate clock %s\n", __func__,
5463                                 tegra_clk_duplicates[i].name);
5464                         continue;
5465                 }
5466
5467                 tegra_clk_duplicates[i].lookup.clk = c;
5468                 clkdev_add(&tegra_clk_duplicates[i].lookup);
5469         }
5470
5471         for (i = 0; i < ARRAY_SIZE(tegra_sync_source_list); i++)
5472                 tegra3_init_one_clock(&tegra_sync_source_list[i]);
5473         for (i = 0; i < ARRAY_SIZE(tegra_clk_audio_list); i++)
5474                 tegra3_init_one_clock(&tegra_clk_audio_list[i]);
5475         for (i = 0; i < ARRAY_SIZE(tegra_clk_audio_2x_list); i++)
5476                 tegra3_init_one_clock(&tegra_clk_audio_2x_list[i]);
5477
5478         init_clk_out_mux();
5479         for (i = 0; i < ARRAY_SIZE(tegra_clk_out_list); i++)
5480                 tegra3_init_one_clock(&tegra_clk_out_list[i]);
5481
5482         emc_bridge = &tegra_clk_emc_bridge;
5483         cpu_mode_sclk = tegra_get_clock_by_name("cpu_mode.sclk");
5484
5485         /* Initialize to default */
5486         tegra_init_cpu_edp_limits(0);
5487
5488         register_syscore_ops(&tegra_clk_syscore_ops);
5489 }