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