c8df2e84e307908dcf81954ddee13d971b1aadf1
[linux-2.6.git] / arch / arm / mach-tegra / tegra11_clocks.c
1 /*
2  * arch/arm/mach-tegra/tegra11_clocks.c
3  *
4  * Copyright (C) 2011-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 #include <linux/platform_device.h>
32
33 #include <asm/clkdev.h>
34
35 #include <mach/iomap.h>
36 #include <mach/edp.h>
37 #include <mach/hardware.h>
38 #include <mach/mc.h>
39
40 #include "clock.h"
41 #include "fuse.h"
42 #include "dvfs.h"
43 #include "pm.h"
44 #include "sleep.h"
45 #include "devices.h"
46 #include "tegra11_emc.h"
47 #include "tegra_cl_dvfs.h"
48
49 #define RST_DEVICES_L                   0x004
50 #define RST_DEVICES_H                   0x008
51 #define RST_DEVICES_U                   0x00C
52 #define RST_DEVICES_V                   0x358
53 #define RST_DEVICES_W                   0x35C
54 #define RST_DEVICES_X                   0x28C
55 #define RST_DEVICES_SET_L               0x300
56 #define RST_DEVICES_CLR_L               0x304
57 #define RST_DEVICES_SET_V               0x430
58 #define RST_DEVICES_CLR_V               0x434
59 #define RST_DEVICES_SET_X               0x290
60 #define RST_DEVICES_CLR_X               0x294
61 #define RST_DEVICES_NUM                 6
62
63 #define CLK_OUT_ENB_L                   0x010
64 #define CLK_OUT_ENB_H                   0x014
65 #define CLK_OUT_ENB_U                   0x018
66 #define CLK_OUT_ENB_V                   0x360
67 #define CLK_OUT_ENB_W                   0x364
68 #define CLK_OUT_ENB_X                   0x280
69 #define CLK_OUT_ENB_SET_L               0x320
70 #define CLK_OUT_ENB_CLR_L               0x324
71 #define CLK_OUT_ENB_SET_V               0x440
72 #define CLK_OUT_ENB_CLR_V               0x444
73 #define CLK_OUT_ENB_SET_X               0x284
74 #define CLK_OUT_ENB_CLR_X               0x288
75 #define CLK_OUT_ENB_NUM                 6
76
77 #define RST_DEVICES_V_SWR_CPULP_RST_DIS (0x1 << 1) /* Reserved on Tegra11 */
78 #define CLK_OUT_ENB_V_CLK_ENB_CPULP_EN  (0x1 << 1)
79
80 #define PERIPH_CLK_TO_BIT(c)            (1 << (c->u.periph.clk_num % 32))
81 #define PERIPH_CLK_TO_RST_REG(c)        \
82         periph_clk_to_reg((c), RST_DEVICES_L, RST_DEVICES_V, RST_DEVICES_X, 4)
83 #define PERIPH_CLK_TO_RST_SET_REG(c)    \
84         periph_clk_to_reg((c), RST_DEVICES_SET_L, RST_DEVICES_SET_V, \
85                 RST_DEVICES_SET_X, 8)
86 #define PERIPH_CLK_TO_RST_CLR_REG(c)    \
87         periph_clk_to_reg((c), RST_DEVICES_CLR_L, RST_DEVICES_CLR_V, \
88                 RST_DEVICES_CLR_X, 8)
89
90 #define PERIPH_CLK_TO_ENB_REG(c)        \
91         periph_clk_to_reg((c), CLK_OUT_ENB_L, CLK_OUT_ENB_V, CLK_OUT_ENB_X, 4)
92 #define PERIPH_CLK_TO_ENB_SET_REG(c)    \
93         periph_clk_to_reg((c), CLK_OUT_ENB_SET_L, CLK_OUT_ENB_SET_V, \
94                 CLK_OUT_ENB_SET_X, 8)
95 #define PERIPH_CLK_TO_ENB_CLR_REG(c)    \
96         periph_clk_to_reg((c), CLK_OUT_ENB_CLR_L, CLK_OUT_ENB_CLR_V, \
97                 CLK_OUT_ENB_CLR_X, 8)
98
99 #define CLK_MASK_ARM                    0x44
100 #define MISC_CLK_ENB                    0x48
101
102 #define OSC_CTRL                        0x50
103 #define OSC_CTRL_OSC_FREQ_MASK          (0xF<<28)
104 #define OSC_CTRL_OSC_FREQ_13MHZ         (0x0<<28)
105 #define OSC_CTRL_OSC_FREQ_19_2MHZ       (0x4<<28)
106 #define OSC_CTRL_OSC_FREQ_12MHZ         (0x8<<28)
107 #define OSC_CTRL_OSC_FREQ_26MHZ         (0xC<<28)
108 #define OSC_CTRL_OSC_FREQ_16_8MHZ       (0x1<<28)
109 #define OSC_CTRL_OSC_FREQ_38_4MHZ       (0x5<<28)
110 #define OSC_CTRL_OSC_FREQ_48MHZ         (0x9<<28)
111 #define OSC_CTRL_MASK                   (0x3f2 | OSC_CTRL_OSC_FREQ_MASK)
112
113 #define OSC_CTRL_PLL_REF_DIV_MASK       (3<<26)
114 #define OSC_CTRL_PLL_REF_DIV_1          (0<<26)
115 #define OSC_CTRL_PLL_REF_DIV_2          (1<<26)
116 #define OSC_CTRL_PLL_REF_DIV_4          (2<<26)
117
118 #define PERIPH_CLK_SOURCE_I2S1          0x100
119 #define PERIPH_CLK_SOURCE_EMC           0x19c
120 #define PERIPH_CLK_SOURCE_OSC           0x1fc
121 #define PERIPH_CLK_SOURCE_NUM1 \
122         ((PERIPH_CLK_SOURCE_OSC - PERIPH_CLK_SOURCE_I2S1) / 4)
123
124 #define PERIPH_CLK_SOURCE_G3D2          0x3b0
125 #define PERIPH_CLK_SOURCE_SE            0x42c
126 #define PERIPH_CLK_SOURCE_NUM2 \
127         ((PERIPH_CLK_SOURCE_SE - PERIPH_CLK_SOURCE_G3D2) / 4 + 1)
128
129 #define AUDIO_DLY_CLK                   0x49c
130 #define AUDIO_SYNC_CLK_SPDIF            0x4b4
131 #define PERIPH_CLK_SOURCE_NUM3 \
132         ((AUDIO_SYNC_CLK_SPDIF - AUDIO_DLY_CLK) / 4 + 1)
133
134 #define SPARE_REG                       0x55c
135 #define PERIPH_CLK_SOURCE_XUSB_HOST     0x600
136 #define PERIPH_CLK_SOURCE_SOC_THERM     0x644
137 #define PERIPH_CLK_SOURCE_NUM4 \
138         ((PERIPH_CLK_SOURCE_SOC_THERM - PERIPH_CLK_SOURCE_XUSB_HOST) / 4 + 1)
139
140 #define PERIPH_CLK_SOURCE_NUM           (PERIPH_CLK_SOURCE_NUM1 + \
141                                          PERIPH_CLK_SOURCE_NUM2 + \
142                                          PERIPH_CLK_SOURCE_NUM3 + \
143                                          PERIPH_CLK_SOURCE_NUM4)
144
145 #define CPU_SOFTRST_CTRL                0x380
146 #define CPU_SOFTRST_CTRL1               0x384
147 #define CPU_SOFTRST_CTRL2               0x388
148
149 #define PERIPH_CLK_SOURCE_DIVU71_MASK   0xFF
150 #define PERIPH_CLK_SOURCE_DIVU16_MASK   0xFFFF
151 #define PERIPH_CLK_SOURCE_DIV_SHIFT     0
152 #define PERIPH_CLK_SOURCE_DIVIDLE_SHIFT 8
153 #define PERIPH_CLK_SOURCE_DIVIDLE_VAL   50
154 #define PERIPH_CLK_UART_DIV_ENB         (1<<24)
155 #define PERIPH_CLK_VI_SEL_EX_SHIFT      24
156 #define PERIPH_CLK_VI_SEL_EX_MASK       (0x3<<PERIPH_CLK_VI_SEL_EX_SHIFT)
157 #define PERIPH_CLK_NAND_DIV_EX_ENB      (1<<8)
158 #define PERIPH_CLK_DTV_POLARITY_INV     (1<<25)
159
160 #define AUDIO_SYNC_SOURCE_MASK          0x0F
161 #define AUDIO_SYNC_DISABLE_BIT          0x10
162 #define AUDIO_SYNC_TAP_NIBBLE_SHIFT(c)  ((c->reg_shift - 24) * 4)
163
164 /* PLL common */
165 #define PLL_BASE                        0x0
166 #define PLL_BASE_BYPASS                 (1<<31)
167 #define PLL_BASE_ENABLE                 (1<<30)
168 #define PLL_BASE_REF_ENABLE             (1<<29)
169 #define PLL_BASE_OVERRIDE               (1<<28)
170 #define PLL_BASE_LOCK                   (1<<27)
171 #define PLL_BASE_DIVP_MASK              (0x7<<20)
172 #define PLL_BASE_DIVP_SHIFT             20
173 #define PLL_BASE_DIVN_MASK              (0x3FF<<8)
174 #define PLL_BASE_DIVN_SHIFT             8
175 #define PLL_BASE_DIVM_MASK              (0x1F)
176 #define PLL_BASE_DIVM_SHIFT             0
177
178 #define PLL_BASE_PARSE(pll, cfg, b)                                            \
179         do {                                                                   \
180                 (cfg).m = ((b) & pll##_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT; \
181                 (cfg).n = ((b) & pll##_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT; \
182                 (cfg).p = ((b) & pll##_BASE_DIVP_MASK) >> PLL_BASE_DIVP_SHIFT; \
183         } while (0)
184
185 #define PLL_OUT_RATIO_MASK              (0xFF<<8)
186 #define PLL_OUT_RATIO_SHIFT             8
187 #define PLL_OUT_OVERRIDE                (1<<2)
188 #define PLL_OUT_CLKEN                   (1<<1)
189 #define PLL_OUT_RESET_DISABLE           (1<<0)
190
191 #define PLL_MISC(c)                     \
192         (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
193 #define PLL_MISCN(c, n)         \
194         ((c)->u.pll.misc1 + ((n) - 1) * PLL_MISC(c))
195 #define PLL_MISC_LOCK_ENABLE(c) \
196         (((c)->flags & (PLLU | PLLD)) ? (1<<22) : (1<<18))
197
198 #define PLL_MISC_DCCON_SHIFT            20
199 #define PLL_MISC_CPCON_SHIFT            8
200 #define PLL_MISC_CPCON_MASK             (0xF<<PLL_MISC_CPCON_SHIFT)
201 #define PLL_MISC_LFCON_SHIFT            4
202 #define PLL_MISC_LFCON_MASK             (0xF<<PLL_MISC_LFCON_SHIFT)
203 #define PLL_MISC_VCOCON_SHIFT           0
204 #define PLL_MISC_VCOCON_MASK            (0xF<<PLL_MISC_VCOCON_SHIFT)
205
206 #define PLL_FIXED_MDIV(c, ref)          ((ref) > (c)->u.pll.cf_max ? 2 : 1)
207
208 /* PLLU */
209 #define PLLU_BASE_OVERRIDE              (1<<24)
210 #define PLLU_BASE_POST_DIV              (1<<20)
211
212 /* PLLD */
213 #define PLLD_BASE_CSI_CLKENABLE         (1<<26)
214 #define PLLD_BASE_DSI_MUX_SHIFT         25
215 #define PLLD_BASE_DSI_MUX_MASK          (1<<PLLD_BASE_DSI_MUX_SHIFT)
216 #define PLLD_BASE_CSI_CLKSOURCE         (1<<24)
217
218 #define PLLD_MISC_DSI_CLKENABLE         (1<<30)
219 #define PLLD_MISC_DIV_RST               (1<<23)
220 #define PLLD_MISC_DCCON_SHIFT           12
221
222 #define PLLDU_LFCON                     2
223
224 /* PLLC2 and PLLC3 (PLLCX) */
225 #define PLLCX_USE_DYN_RAMP              0
226 #define PLLCX_BASE_PHASE_LOCK           (1<<26)
227 #define PLLCX_BASE_DIVP_MASK            (0x7<<PLL_BASE_DIVP_SHIFT)
228 #define PLLCX_BASE_DIVN_MASK            (0xFF<<PLL_BASE_DIVN_SHIFT)
229 #define PLLCX_BASE_DIVM_MASK            (0x3<<PLL_BASE_DIVM_SHIFT)
230 #define PLLCX_PDIV_MAX  ((PLLCX_BASE_DIVP_MASK >> PLL_BASE_DIVP_SHIFT))
231 #define PLLCX_IS_DYN(new_p, old_p)      (((new_p) <= 8) && ((old_p) <= 8))
232
233 #define PLLCX_MISC_STROBE               (1<<31)
234 #define PLLCX_MISC_RESET                (1<<30)
235 #define PLLCX_MISC_SDM_DIV_SHIFT        28
236 #define PLLCX_MISC_SDM_DIV_MASK         (0x3 << PLLCX_MISC_SDM_DIV_SHIFT)
237 #define PLLCX_MISC_FILT_DIV_SHIFT       26
238 #define PLLCX_MISC_FILT_DIV_MASK        (0x3 << PLLCX_MISC_FILT_DIV_SHIFT)
239 #define PLLCX_MISC_ALPHA_SHIFT          18
240 #define PLLCX_MISC_ALPHA_MASK           (0xFF << PLLCX_MISC_ALPHA_SHIFT)
241 #define PLLCX_MISC_KB_SHIFT             9
242 #define PLLCX_MISC_KB_MASK              (0x1FF << PLLCX_MISC_KB_SHIFT)
243 #define PLLCX_MISC_KA_SHIFT             2
244 #define PLLCX_MISC_KA_MASK              (0x7F << PLLCX_MISC_KA_SHIFT)
245 #define PLLCX_MISC_VCO_GAIN_SHIFT       0
246 #define PLLCX_MISC_VCO_GAIN_MASK        (0x3 << PLLCX_MISC_VCO_GAIN_SHIFT)
247
248 #define PLLCX_MISC_KOEF_LOW_RANGE       \
249         ((0x14 << PLLCX_MISC_KA_SHIFT) | (0x38 << PLLCX_MISC_KB_SHIFT))
250 #define PLLCX_MISC_KOEF_HIGH_RANGE      \
251         ((0x10 << PLLCX_MISC_KA_SHIFT) | (0xA0 << PLLCX_MISC_KB_SHIFT))
252
253 #define PLLCX_MISC_DEFAULT_VALUE        ((0x0 << PLLCX_MISC_VCO_GAIN_SHIFT) | \
254                                         PLLCX_MISC_KOEF_LOW_RANGE | \
255                                         (0x19 << PLLCX_MISC_ALPHA_SHIFT) | \
256                                         (0x2 << PLLCX_MISC_SDM_DIV_SHIFT) | \
257                                         (0x2 << PLLCX_MISC_FILT_DIV_SHIFT) | \
258                                         PLLCX_MISC_RESET)
259 #define PLLCX_MISC1_DEFAULT_VALUE       0x000d2308
260 #define PLLCX_MISC2_DEFAULT_VALUE       0x31211200
261 #define PLLCX_MISC3_DEFAULT_VALUE       0x0
262
263 /* PLLX and PLLC (PLLXC)*/
264 #define PLLXC_USE_DYN_RAMP              0
265 #define PLLXC_BASE_DIVP_MASK            (0xF<<PLL_BASE_DIVP_SHIFT)
266 #define PLLXC_BASE_DIVN_MASK            (0xFF<<PLL_BASE_DIVN_SHIFT)
267 #define PLLXC_BASE_DIVM_MASK            (0xFF<<PLL_BASE_DIVM_SHIFT)
268
269 /* PLLXC has 4-bit PDIV, but entry 15 is not allowed in h/w,
270    and s/w usage is limited to 5 */
271 #define PLLXC_PDIV_MAX                  14
272 #define PLLXC_SW_PDIV_MAX               5
273
274 /* PLLX */
275 #define PLLX_MISC2_DYNRAMP_STEPB_SHIFT  24
276 #define PLLX_MISC2_DYNRAMP_STEPB_MASK   (0xFF << PLLX_MISC2_DYNRAMP_STEPB_SHIFT)
277 #define PLLX_MISC2_DYNRAMP_STEPA_SHIFT  16
278 #define PLLX_MISC2_DYNRAMP_STEPA_MASK   (0xFF << PLLX_MISC2_DYNRAMP_STEPA_SHIFT)
279 #define PLLX_MISC2_NDIV_NEW_SHIFT       8
280 #define PLLX_MISC2_NDIV_NEW_MASK        (0xFF << PLLX_MISC2_NDIV_NEW_SHIFT)
281 #define PLLX_MISC2_LOCK_OVERRIDE        (0x1 << 4)
282 #define PLLX_MISC2_DYNRAMP_DONE         (0x1 << 2)
283 #define PLLX_MISC2_CLAMP_NDIV           (0x1 << 1)
284 #define PLLX_MISC2_EN_DYNRAMP           (0x1 << 0)
285
286 #define PLLX_MISC3_IDDQ                 (0x1 << 3)
287
288 #define PLLX_HW_CTRL_CFG                0x548
289 #define PLLX_HW_CTRL_CFG_SWCTRL         (0x1 << 0)
290
291 /* PLLC */
292 #define PLLC_BASE_LOCK_OVERRIDE         (1<<28)
293
294 #define PLLC_MISC_IDDQ                  (0x1 << 26)
295 #define PLLC_MISC_LOCK_ENABLE           (0x1 << 24)
296
297 #define PLLC_MISC1_CLAMP_NDIV           (0x1 << 26)
298 #define PLLC_MISC1_EN_DYNRAMP           (0x1 << 25)
299 #define PLLC_MISC1_DYNRAMP_STEPA_SHIFT  17
300 #define PLLC_MISC1_DYNRAMP_STEPA_MASK   (0xFF << PLLC_MISC1_DYNRAMP_STEPA_SHIFT)
301 #define PLLC_MISC1_DYNRAMP_STEPB_SHIFT  9
302 #define PLLC_MISC1_DYNRAMP_STEPB_MASK   (0xFF << PLLC_MISC1_DYNRAMP_STEPB_SHIFT)
303 #define PLLC_MISC1_NDIV_NEW_SHIFT       1
304 #define PLLC_MISC1_NDIV_NEW_MASK        (0xFF << PLLC_MISC1_NDIV_NEW_SHIFT)
305 #define PLLC_MISC1_DYNRAMP_DONE         (0x1 << 0)
306
307 /* PLLM */
308 #define PLLM_BASE_DIVP_MASK             (0x1 << PLL_BASE_DIVP_SHIFT)
309 #define PLLM_BASE_DIVN_MASK             (0xFF << PLL_BASE_DIVN_SHIFT)
310 #define PLLM_BASE_DIVM_MASK             (0xFF << PLL_BASE_DIVM_SHIFT)
311 #define PLLM_PDIV_MAX                   1
312
313 #define PLLM_MISC_FSM_SW_OVERRIDE       (0x1 << 10)
314 #define PLLM_MISC_IDDQ                  (0x1 << 5)
315 #define PLLM_MISC_LOCK_DISABLE          (0x1 << 4)
316 #define PLLM_MISC_LOCK_OVERRIDE         (0x1 << 3)
317
318 #define PMC_PLLP_WB0_OVERRIDE                   0xf8
319 #define PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE       (1 << 12)
320 #define PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE     (1 << 11)
321
322 /* M, N layout for PLLM override and base registers are the same */
323 #define PMC_PLLM_WB0_OVERRIDE                   0x1dc
324
325 #define PMC_PLLM_WB0_OVERRIDE_2                 0x2b0
326 #define PMC_PLLM_WB0_OVERRIDE_2_DIVP_MASK       (0x1 << 27)
327
328 /* PLLRE */
329 #define PLLRE_BASE_DIVP_SHIFT           16
330 #define PLLRE_BASE_DIVP_MASK            (0xF << PLLRE_BASE_DIVP_SHIFT)
331 #define PLLRE_BASE_DIVN_MASK            (0xFF << PLL_BASE_DIVN_SHIFT)
332 #define PLLRE_BASE_DIVM_MASK            (0xFF << PLL_BASE_DIVM_SHIFT)
333
334 /* PLLRE has 4-bit PDIV, but entry 15 is not allowed in h/w,
335    and s/w usage is limited to 5 */
336 #define PLLRE_PDIV_MAX                  14
337 #define PLLRE_SW_PDIV_MAX               5
338
339 #define PLLRE_MISC_LOCK_ENABLE          (0x1 << 30)
340 #define PLLRE_MISC_LOCK_OVERRIDE        (0x1 << 29)
341 #define PLLRE_MISC_LOCK                 (0x1 << 24)
342 #define PLLRE_MISC_IDDQ                 (0x1 << 16)
343
344 #define OUT_OF_TABLE_CPCON              0x8
345
346 #define SUPER_CLK_MUX                   0x00
347 #define SUPER_STATE_SHIFT               28
348 #define SUPER_STATE_MASK                (0xF << SUPER_STATE_SHIFT)
349 #define SUPER_STATE_STANDBY             (0x0 << SUPER_STATE_SHIFT)
350 #define SUPER_STATE_IDLE                (0x1 << SUPER_STATE_SHIFT)
351 #define SUPER_STATE_RUN                 (0x2 << SUPER_STATE_SHIFT)
352 #define SUPER_STATE_IRQ                 (0x3 << SUPER_STATE_SHIFT)
353 #define SUPER_STATE_FIQ                 (0x4 << SUPER_STATE_SHIFT)
354 #define SUPER_LP_DIV2_BYPASS            (0x1 << 16)
355 #define SUPER_SOURCE_MASK               0xF
356 #define SUPER_FIQ_SOURCE_SHIFT          12
357 #define SUPER_IRQ_SOURCE_SHIFT          8
358 #define SUPER_RUN_SOURCE_SHIFT          4
359 #define SUPER_IDLE_SOURCE_SHIFT         0
360
361 #define SUPER_CLK_DIVIDER               0x04
362 #define SUPER_CLOCK_DIV_U71_SHIFT       16
363 #define SUPER_CLOCK_DIV_U71_MASK        (0xff << SUPER_CLOCK_DIV_U71_SHIFT)
364
365 #define BUS_CLK_DISABLE                 (1<<3)
366 #define BUS_CLK_DIV_MASK                0x3
367
368 #define PMC_CTRL                        0x0
369  #define PMC_CTRL_BLINK_ENB             (1 << 7)
370
371 #define PMC_DPD_PADS_ORIDE              0x1c
372  #define PMC_DPD_PADS_ORIDE_BLINK_ENB   (1 << 20)
373
374 #define PMC_BLINK_TIMER_DATA_ON_SHIFT   0
375 #define PMC_BLINK_TIMER_DATA_ON_MASK    0x7fff
376 #define PMC_BLINK_TIMER_ENB             (1 << 15)
377 #define PMC_BLINK_TIMER_DATA_OFF_SHIFT  16
378 #define PMC_BLINK_TIMER_DATA_OFF_MASK   0xffff
379
380 #define UTMIP_PLL_CFG2                                  0x488
381 #define UTMIP_PLL_CFG2_STABLE_COUNT(x)                  (((x) & 0xfff) << 6)
382 #define UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(x)              (((x) & 0x3f) << 18)
383 #define UTMIP_PLL_CFG2_FORCE_PD_SAMP_A_POWERDOWN        (1 << 0)
384 #define UTMIP_PLL_CFG2_FORCE_PD_SAMP_B_POWERDOWN        (1 << 2)
385 #define UTMIP_PLL_CFG2_FORCE_PD_SAMP_C_POWERDOWN        (1 << 4)
386
387 #define UTMIP_PLL_CFG1                                  0x484
388 #define UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(x)              (((x) & 0x1f) << 27)
389 #define UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(x)               (((x) & 0xfff) << 0)
390 #define UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERUP (1 << 15)
391 #define UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN       (1 << 14)
392 #define UTMIP_PLL_CFG1_FORCE_PLL_ACTIVE_POWERDOWN       (1 << 12)
393 #define UTMIP_PLL_CFG1_FORCE_PLLU_POWERUP               (1 << 17)
394 #define UTMIP_PLL_CFG1_FORCE_PLLU_POWERDOWN             (1 << 16)
395
396 /* PLLE */
397 #define PLLE_BASE_LOCK_OVERRIDE         (0x1 << 29)
398 #define PLLE_BASE_DIVCML_SHIFT          24
399 #define PLLE_BASE_DIVCML_MASK           (0xf<<PLLE_BASE_DIVCML_SHIFT)
400 #define PLLE_BASE_DIVN_MASK             (0xFF<<PLL_BASE_DIVN_SHIFT)
401 #define PLLE_BASE_DIVM_MASK             (0xFF<<PLL_BASE_DIVM_SHIFT)
402
403 /* PLLE has 4-bit CMLDIV, but entry 15 is not allowed in h/w */
404 #define PLLE_CMLDIV_MAX                 14
405
406 #define PLLE_MISC_READY                 (1<<15)
407 #define PLLE_MISC_IDDQ_SW_CTRL          (1<<14)
408 #define PLLE_MISC_IDDQ_SW_VALUE         (1<<13)
409 #define PLLE_MISC_LOCK                  (1<<11)
410 #define PLLE_MISC_LOCK_ENABLE           (1<<9)
411 #define PLLE_MISC_PLLE_PTS              (1<<8)
412 #define PLLE_MISC_VREG_BG_CTRL_SHIFT    4
413 #define PLLE_MISC_VREG_BG_CTRL_MASK     (0x3<<PLLE_MISC_VREG_BG_CTRL_SHIFT)
414 #define PLLE_MISC_VREG_CTRL_SHIFT       2
415 #define PLLE_MISC_VREG_CTRL_MASK        (0x3<<PLLE_MISC_VREG_CTRL_SHIFT)
416
417 #define PLLE_SS_CTRL                    0x68
418 #define PLLE_SS_CNTL_SSC_BYP            (0x1 << 12)
419 #define PLLE_SS_CNTL_INTERP_RESET       (0x1 << 11)
420 #define PLLE_SS_CNTL_BYPASS_SS          (0x1 << 10)
421 #define PLLE_SS_DISABLE                 (PLLE_SS_CNTL_SSC_BYP |\
422         PLLE_SS_CNTL_INTERP_RESET | PLLE_SS_CNTL_BYPASS_SS)
423 #define PLLE_SS_COEFFICIENTS_MASK       (~PLLE_SS_DISABLE)
424
425 #define PLLE_AUX                        0x48c
426 #define PLLE_AUX_PLLRE_SEL              (1<<28)
427 #define PLLE_AUX_SEQ_STATE_SHIFT        26
428 #define PLLE_AUX_SEQ_STATE_MASK         (0x3<<PLLE_AUX_SEQ_STATE_SHIFT)
429 #define PLLE_AUX_SEQ_ENABLE             (1<<24)
430 #define PLLE_AUX_ENABLE_SWCTL           (1<<4)
431 #define PLLE_AUX_USE_LOCKDET            (1<<3)
432 #define PLLE_AUX_PLLP_SEL               (1<<2)
433
434 /* USB PLLs PD HW controls */
435 #define XUSBIO_PLL_CFG0                         0x51c
436 #define XUSBIO_PLL_CFG0_SEQ_ENABLE              (1<<24)
437 #define XUSBIO_PLL_CFG0_PADPLL_USE_LOCKDET      (1<<6)
438 #define XUSBIO_PLL_CFG0_CLK_ENABLE_SWCTL        (1<<2)
439 #define XUSBIO_PLL_CFG0_PADPLL_RESET_SWCTL      (1<<0)
440
441 #define UTMIPLL_HW_PWRDN_CFG0                   0x52c
442 #define UTMIPLL_HW_PWRDN_CFG0_SEQ_START_STATE   (1<<25)
443 #define UTMIPLL_HW_PWRDN_CFG0_SEQ_ENABLE        (1<<24)
444 #define UTMIPLL_HW_PWRDN_CFG0_USE_LOCKDET       (1<<6)
445 #define UTMIPLL_HW_PWRDN_CFG0_SEQ_RESET_INPUT_VALUE     (1<<5)
446 #define UTMIPLL_HW_PWRDN_CFG0_SEQ_IN_SWCTL      (1<<4)
447 #define UTMIPLL_HW_PWRDN_CFG0_CLK_ENABLE_SWCTL  (1<<2)
448 #define UTMIPLL_HW_PWRDN_CFG0_IDDQ_OVERRIDE     (1<<1)
449 #define UTMIPLL_HW_PWRDN_CFG0_IDDQ_SWCTL        (1<<0)
450
451 #define PLLU_HW_PWRDN_CFG0                      0x530
452 #define PLLU_HW_PWRDN_CFG0_SEQ_ENABLE           (1<<24)
453 #define PLLU_HW_PWRDN_CFG0_USE_LOCKDET          (1<<6)
454 #define PLLU_HW_PWRDN_CFG0_CLK_ENABLE_SWCTL     (1<<2)
455 #define PLLU_HW_PWRDN_CFG0_CLK_SWITCH_SWCTL     (1<<0)
456
457 #define USB_PLLS_SEQ_START_STATE                (1<<25)
458 #define USB_PLLS_SEQ_ENABLE                     (1<<24)
459 #define USB_PLLS_USE_LOCKDET                    (1<<6)
460 #define USB_PLLS_ENABLE_SWCTL                   ((1<<2) | (1<<0))
461
462 /* DFLL */
463 #define DFLL_BASE                               0x2f4
464 #define DFLL_BASE_RESET                         (1<<0)
465
466 #define LVL2_CLK_GATE_OVRE                      0x554
467
468 #define ROUND_DIVIDER_UP        0
469 #define ROUND_DIVIDER_DOWN      1
470
471 /* PLLP default fixed rate in h/w controlled mode */
472 #define PLLP_DEFAULT_FIXED_RATE         216000000
473
474 static bool tegra11_is_dyn_ramp(struct clk *c,
475                                 unsigned long rate, bool from_vco_min);
476 static void tegra11_pllp_init_dependencies(unsigned long pllp_rate);
477 static unsigned long tegra11_clk_shared_bus_update(
478         struct clk *bus, struct clk **bus_top, struct clk **bus_slow);
479
480 static bool detach_shared_bus;
481 module_param(detach_shared_bus, bool, 0644);
482
483 static int use_dfll;
484
485 /**
486 * Structure defining the fields for USB UTMI clocks Parameters.
487 */
488 struct utmi_clk_param
489 {
490         /* Oscillator Frequency in KHz */
491         u32 osc_frequency;
492         /* UTMIP PLL Enable Delay Count  */
493         u8 enable_delay_count;
494         /* UTMIP PLL Stable count */
495         u8 stable_count;
496         /*  UTMIP PLL Active delay count */
497         u8 active_delay_count;
498         /* UTMIP PLL Xtal frequency count */
499         u8 xtal_freq_count;
500 };
501
502 static const struct utmi_clk_param utmi_parameters[] =
503 {
504 /*      OSC_FREQUENCY,  ENABLE_DLY,     STABLE_CNT,     ACTIVE_DLY,     XTAL_FREQ_CNT */
505         {13000000,      0x02,           0x33,           0x05,           0x7F},
506         {19200000,      0x03,           0x4B,           0x06,           0xBB},
507         {12000000,      0x02,           0x2F,           0x04,           0x76},
508         {26000000,      0x04,           0x66,           0x09,           0xFE},
509         {16800000,      0x03,           0x41,           0x0A,           0xA4},
510 };
511
512 static void __iomem *reg_clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
513 static void __iomem *reg_pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
514 static void __iomem *misc_gp_base = IO_ADDRESS(TEGRA_APB_MISC_BASE);
515
516 #define MISC_GP_HIDREV                          0x804
517 #define MISC_GP_TRANSACTOR_SCRATCH_0            0x864
518 #define MISC_GP_TRANSACTOR_SCRATCH_LA_ENABLE    (0x1 << 1)
519 #define MISC_GP_TRANSACTOR_SCRATCH_DDS_ENABLE   (0x1 << 2)
520 #define MISC_GP_TRANSACTOR_SCRATCH_DP2_ENABLE   (0x1 << 3)
521
522 /*
523  * Some peripheral clocks share an enable bit, so refcount the enable bits
524  * in registers CLK_ENABLE_L, ... CLK_ENABLE_W, and protect refcount updates
525  * with lock
526  */
527 static DEFINE_SPINLOCK(periph_refcount_lock);
528 static int tegra_periph_clk_enable_refcount[CLK_OUT_ENB_NUM * 32];
529
530 #define clk_writel(value, reg) \
531         __raw_writel(value, (u32)reg_clk_base + (reg))
532 #define clk_readl(reg) \
533         __raw_readl((u32)reg_clk_base + (reg))
534 #define pmc_writel(value, reg) \
535         __raw_writel(value, (u32)reg_pmc_base + (reg))
536 #define pmc_readl(reg) \
537         __raw_readl((u32)reg_pmc_base + (reg))
538 #define chipid_readl() \
539         __raw_readl((u32)misc_gp_base + MISC_GP_HIDREV)
540
541 #define clk_writel_delay(value, reg)                                    \
542         do {                                                            \
543                 __raw_writel((value), (u32)reg_clk_base + (reg));       \
544                 udelay(2);                                              \
545         } while (0)
546
547 #define pll_writel_delay(value, reg)                                    \
548         do {                                                            \
549                 __raw_writel((value), (u32)reg_clk_base + (reg));       \
550                 udelay(1);                                              \
551         } while (0)
552
553
554 static inline int clk_set_div(struct clk *c, u32 n)
555 {
556         return clk_set_rate(c, (clk_get_rate(c->parent) + n-1) / n);
557 }
558
559 static inline u32 periph_clk_to_reg(
560         struct clk *c, u32 reg_L, u32 reg_V, u32 reg_X, int offs)
561 {
562         u32 reg = c->u.periph.clk_num / 32;
563         BUG_ON(reg >= RST_DEVICES_NUM);
564         if (reg < 3)
565                 reg = reg_L + (reg * offs);
566         else if (reg < 5)
567                 reg = reg_V + ((reg - 3) * offs);
568         else
569                 reg = reg_X;
570         return reg;
571 }
572
573 static int clk_div_x1_get_divider(unsigned long parent_rate, unsigned long rate,
574                         u32 max_x,
575                                  u32 flags, u32 round_mode)
576 {
577         s64 divider_ux1 = parent_rate;
578         if (!rate)
579                 return -EINVAL;
580
581         if (!(flags & DIV_U71_INT))
582                 divider_ux1 *= 2;
583         if (round_mode == ROUND_DIVIDER_UP)
584                 divider_ux1 += rate - 1;
585         do_div(divider_ux1, rate);
586         if (flags & DIV_U71_INT)
587                 divider_ux1 *= 2;
588
589         if (divider_ux1 - 2 < 0)
590                 return 0;
591
592         if (divider_ux1 - 2 > max_x)
593                 return -EINVAL;
594
595         return divider_ux1 - 2;
596 }
597
598 static int clk_div71_get_divider(unsigned long parent_rate, unsigned long rate,
599                                  u32 flags, u32 round_mode)
600 {
601         return clk_div_x1_get_divider(parent_rate, rate, 0xFF,
602                         flags, round_mode);
603 }
604
605 static int clk_div151_get_divider(unsigned long parent_rate, unsigned long rate,
606                                  u32 flags, u32 round_mode)
607 {
608         return clk_div_x1_get_divider(parent_rate, rate, 0xFFFF,
609                         flags, round_mode);
610 }
611
612 static int clk_div16_get_divider(unsigned long parent_rate, unsigned long rate)
613 {
614         s64 divider_u16;
615
616         divider_u16 = parent_rate;
617         if (!rate)
618                 return -EINVAL;
619         divider_u16 += rate - 1;
620         do_div(divider_u16, rate);
621
622         if (divider_u16 - 1 < 0)
623                 return 0;
624
625         if (divider_u16 - 1 > 0xFFFF)
626                 return -EINVAL;
627
628         return divider_u16 - 1;
629 }
630
631 /* clk_m functions */
632 static unsigned long tegra11_clk_m_autodetect_rate(struct clk *c)
633 {
634         u32 osc_ctrl = clk_readl(OSC_CTRL);
635         u32 auto_clock_control = osc_ctrl & ~OSC_CTRL_OSC_FREQ_MASK;
636         u32 pll_ref_div = osc_ctrl & OSC_CTRL_PLL_REF_DIV_MASK;
637
638         c->rate = tegra_clk_measure_input_freq();
639         switch (c->rate) {
640         case 12000000:
641                 auto_clock_control |= OSC_CTRL_OSC_FREQ_12MHZ;
642                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
643                 break;
644         case 13000000:
645                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
646                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
647                 break;
648         case 19200000:
649                 auto_clock_control |= OSC_CTRL_OSC_FREQ_19_2MHZ;
650                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
651                 break;
652         case 26000000:
653                 auto_clock_control |= OSC_CTRL_OSC_FREQ_26MHZ;
654                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
655                 break;
656         case 16800000:
657                 auto_clock_control |= OSC_CTRL_OSC_FREQ_16_8MHZ;
658                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
659                 break;
660         case 38400000:
661                 auto_clock_control |= OSC_CTRL_OSC_FREQ_38_4MHZ;
662                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_2);
663                 break;
664         case 48000000:
665                 auto_clock_control |= OSC_CTRL_OSC_FREQ_48MHZ;
666                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_4);
667                 break;
668         case 115200:    /* fake 13M for QT */
669         case 230400:    /* fake 13M for QT */
670                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
671                 c->rate = 13000000;
672                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
673                 break;
674         default:
675                 pr_err("%s: Unexpected clock rate %ld", __func__, c->rate);
676                 BUG();
677         }
678         clk_writel(auto_clock_control, OSC_CTRL);
679         return c->rate;
680 }
681
682 static void tegra11_clk_m_init(struct clk *c)
683 {
684         pr_debug("%s on clock %s\n", __func__, c->name);
685         tegra11_clk_m_autodetect_rate(c);
686 }
687
688 static int tegra11_clk_m_enable(struct clk *c)
689 {
690         pr_debug("%s on clock %s\n", __func__, c->name);
691         return 0;
692 }
693
694 static void tegra11_clk_m_disable(struct clk *c)
695 {
696         pr_debug("%s on clock %s\n", __func__, c->name);
697         WARN(1, "Attempting to disable main SoC clock\n");
698 }
699
700 static struct clk_ops tegra_clk_m_ops = {
701         .init           = tegra11_clk_m_init,
702         .enable         = tegra11_clk_m_enable,
703         .disable        = tegra11_clk_m_disable,
704 };
705
706 static struct clk_ops tegra_clk_m_div_ops = {
707         .enable         = tegra11_clk_m_enable,
708 };
709
710 /* PLL reference divider functions */
711 static void tegra11_pll_ref_init(struct clk *c)
712 {
713         u32 pll_ref_div = clk_readl(OSC_CTRL) & OSC_CTRL_PLL_REF_DIV_MASK;
714         pr_debug("%s on clock %s\n", __func__, c->name);
715
716         switch (pll_ref_div) {
717         case OSC_CTRL_PLL_REF_DIV_1:
718                 c->div = 1;
719                 break;
720         case OSC_CTRL_PLL_REF_DIV_2:
721                 c->div = 2;
722                 break;
723         case OSC_CTRL_PLL_REF_DIV_4:
724                 c->div = 4;
725                 break;
726         default:
727                 pr_err("%s: Invalid pll ref divider %d", __func__, pll_ref_div);
728                 BUG();
729         }
730         c->mul = 1;
731         c->state = ON;
732 }
733
734 static struct clk_ops tegra_pll_ref_ops = {
735         .init           = tegra11_pll_ref_init,
736         .enable         = tegra11_clk_m_enable,
737         .disable        = tegra11_clk_m_disable,
738 };
739
740 /* super clock functions */
741 /* "super clocks" on tegra11x have two-stage muxes, fractional 7.1 divider and
742  * clock skipping super divider.  We will ignore the clock skipping divider,
743  * since we can't lower the voltage when using the clock skip, but we can if
744  * we lower the PLL frequency. Note that skipping divider can and will be used
745  * by thermal control h/w for automatic throttling. There is also a 7.1 divider
746  * that most CPU super-clock inputs can be routed through. We will not use it
747  * as well (keep default 1:1 state), to avoid high jitter on PLLX and DFLL path
748  * and possible concurrency access issues with thermal h/w (7.1 divider setting
749  * share register with clock skipping divider)
750  */
751 static void tegra11_super_clk_init(struct clk *c)
752 {
753         u32 val;
754         int source;
755         int shift;
756         const struct clk_mux_sel *sel;
757         val = clk_readl(c->reg + SUPER_CLK_MUX);
758         c->state = ON;
759         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
760                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
761         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
762                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
763         source = (val >> shift) & SUPER_SOURCE_MASK;
764
765         /*
766          * Enforce PLLX DIV2 bypass setting as early as possible. It is always
767          * safe to do for both cclk_lp and cclk_g when booting on G CPU. (In
768          * case of booting on LP CPU, cclk_lp will be updated during the cpu
769          * rate change after boot, and cclk_g after the cluster switch.)
770          */
771         if ((c->flags & DIV_U71) && (!is_lp_cluster())) {
772                 val |= SUPER_LP_DIV2_BYPASS;
773                 clk_writel_delay(val, c->reg);
774         }
775
776         for (sel = c->inputs; sel->input != NULL; sel++) {
777                 if (sel->value == source)
778                         break;
779         }
780         BUG_ON(sel->input == NULL);
781         c->parent = sel->input;
782
783         /* Update parent in case when LP CPU PLLX DIV2 bypassed */
784         if ((c->flags & DIV_2) && (c->parent->flags & PLLX) &&
785             (val & SUPER_LP_DIV2_BYPASS))
786                 c->parent = c->parent->parent;
787
788         if (c->flags & DIV_U71) {
789                 c->mul = 2;
790                 c->div = 2;
791
792                 /* Make sure 7.1 divider is 1:1, clear s/w skipper control */
793                 /* FIXME: set? preserve? thermal h/w skipper control */
794                 val = clk_readl(c->reg + SUPER_CLK_DIVIDER);
795                 BUG_ON(val & SUPER_CLOCK_DIV_U71_MASK);
796                 val = 0;
797                 clk_writel(val, c->reg + SUPER_CLK_DIVIDER);
798         }
799         else
800                 clk_writel(0, c->reg + SUPER_CLK_DIVIDER);
801 }
802
803 static int tegra11_super_clk_enable(struct clk *c)
804 {
805         return 0;
806 }
807
808 static void tegra11_super_clk_disable(struct clk *c)
809 {
810         /* since tegra 3 has 2 CPU super clocks - low power lp-mode clock and
811            geared up g-mode super clock - mode switch may request to disable
812            either of them; accept request with no affect on h/w */
813 }
814
815 static int tegra11_super_clk_set_parent(struct clk *c, struct clk *p)
816 {
817         u32 val;
818         const struct clk_mux_sel *sel;
819         int shift;
820
821         val = clk_readl(c->reg + SUPER_CLK_MUX);
822         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
823                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
824         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
825                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
826         for (sel = c->inputs; sel->input != NULL; sel++) {
827                 if (sel->input == p) {
828                         /* For LP mode super-clock switch between PLLX direct
829                            and divided-by-2 outputs is allowed only when other
830                            than PLLX clock source is current parent */
831                         if ((c->flags & DIV_2) && (p->flags & PLLX) &&
832                             ((sel->value ^ val) & SUPER_LP_DIV2_BYPASS)) {
833                                 if (c->parent->flags & PLLX)
834                                         return -EINVAL;
835                                 val ^= SUPER_LP_DIV2_BYPASS;
836                                 clk_writel_delay(val, c->reg);
837                         }
838                         val &= ~(SUPER_SOURCE_MASK << shift);
839                         val |= (sel->value & SUPER_SOURCE_MASK) << shift;
840
841                         if (c->flags & DIV_U71) {
842                                 /* Make sure 7.1 divider is 1:1 */
843                                 u32 div = clk_readl(c->reg + SUPER_CLK_DIVIDER);
844                                 BUG_ON(div & SUPER_CLOCK_DIV_U71_MASK);
845                         }
846
847                         if (c->refcnt)
848                                 clk_enable(p);
849
850                         clk_writel_delay(val, c->reg);
851
852                         if (c->refcnt && c->parent)
853                                 clk_disable(c->parent);
854
855                         clk_reparent(c, p);
856                         return 0;
857                 }
858         }
859         return -EINVAL;
860 }
861
862 /*
863  * Do not use super clocks "skippers", since dividing using a clock skipper
864  * does not allow the voltage to be scaled down. Instead adjust the rate of
865  * the parent clock. This requires that the parent of a super clock have no
866  * other children, otherwise the rate will change underneath the other
867  * children.
868  */
869 static int tegra11_super_clk_set_rate(struct clk *c, unsigned long rate)
870 {
871         /* In tegra11_cpu_clk_set_plls() and  tegra11_sbus_cmplx_set_rate()
872          * this call is skipped by directly setting rate of source plls. If we
873          * ever use 7.1 divider at other than 1:1 setting, or exercise s/w
874          * skipper control, not only this function, but cpu and sbus set_rate
875          * APIs should be changed accordingly.
876          */
877         return clk_set_rate(c->parent, rate);
878 }
879
880 #ifdef CONFIG_PM_SLEEP
881 static void tegra11_super_clk_resume(struct clk *c, struct clk *backup,
882                                      u32 setting)
883 {
884         u32 val;
885         const struct clk_mux_sel *sel;
886         int shift;
887
888         /* For sclk and cclk_g super clock just restore saved value */
889         if (!(c->flags & DIV_2)) {
890                 clk_writel_delay(setting, c->reg);
891                 return;
892         }
893
894         /*
895          * For cclk_lp supper clock: switch to backup (= not PLLX) source,
896          * safely restore PLLX DIV2 bypass, and only then restore full
897          * setting
898          */
899         val = clk_readl(c->reg);
900         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
901                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
902         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
903                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
904         for (sel = c->inputs; sel->input != NULL; sel++) {
905                 if (sel->input == backup) {
906                         val &= ~(SUPER_SOURCE_MASK << shift);
907                         val |= (sel->value & SUPER_SOURCE_MASK) << shift;
908
909                         BUG_ON(backup->flags & PLLX);
910                         clk_writel_delay(val, c->reg);
911
912                         val &= ~SUPER_LP_DIV2_BYPASS;
913                         val |= (setting & SUPER_LP_DIV2_BYPASS);
914                         clk_writel_delay(val, c->reg);
915                         clk_writel_delay(setting, c->reg);
916                         return;
917                 }
918         }
919         BUG();
920 }
921 #endif
922
923 static struct clk_ops tegra_super_ops = {
924         .init                   = tegra11_super_clk_init,
925         .enable                 = tegra11_super_clk_enable,
926         .disable                = tegra11_super_clk_disable,
927         .set_parent             = tegra11_super_clk_set_parent,
928         .set_rate               = tegra11_super_clk_set_rate,
929 };
930
931 /* virtual cpu clock functions */
932 /* some clocks can not be stopped (cpu, memory bus) while the SoC is running.
933    To change the frequency of these clocks, the parent pll may need to be
934    reprogrammed, so the clock must be moved off the pll, the pll reprogrammed,
935    and then the clock moved back to the pll.  To hide this sequence, a virtual
936    clock handles it.
937  */
938 static void tegra11_cpu_clk_init(struct clk *c)
939 {
940         c->state = (!is_lp_cluster() == (c->u.cpu.mode == MODE_G))? ON : OFF;
941 }
942
943 static int tegra11_cpu_clk_enable(struct clk *c)
944 {
945         return 0;
946 }
947
948 static void tegra11_cpu_clk_disable(struct clk *c)
949 {
950         /* since tegra 3 has 2 virtual CPU clocks - low power lp-mode clock
951            and geared up g-mode clock - mode switch may request to disable
952            either of them; accept request with no affect on h/w */
953 }
954
955 static int tegra11_cpu_clk_set_plls(struct clk *c, unsigned long rate,
956                                     unsigned long old_rate)
957 {
958         int ret = 0;
959         bool on_main = false;
960         unsigned long backup_rate, main_rate;
961         unsigned long vco_min = c->u.cpu.main->u.pll.vco_min;
962
963         /*
964          * Take an extra reference to the main pll so it doesn't turn off when
965          * we move the cpu off of it. If possible, use main pll dynamic ramp
966          * to reach target rate in one shot. Otherwise, use dynamic ramp to
967          * lower current rate to pll VCO minimum level before switching to
968          * backup source.
969          */
970         if (c->parent->parent == c->u.cpu.main) {
971                 bool dramp = (rate > c->u.cpu.backup_rate) &&
972                         tegra11_is_dyn_ramp(c->u.cpu.main, rate, false);
973                 clk_enable(c->u.cpu.main);
974                 on_main = true;
975
976                 if (dramp ||
977                     ((old_rate > vco_min) &&
978                      tegra11_is_dyn_ramp(c->u.cpu.main, vco_min, false))) {
979                         main_rate = dramp ? rate : vco_min;
980                         ret = clk_set_rate(c->u.cpu.main, main_rate);
981                         if (ret) {
982                                 pr_err("Failed to set cpu rate %lu on source"
983                                        " %s\n", main_rate, c->u.cpu.main->name);
984                                 goto out;
985                         }
986                         if (dramp)
987                                 goto out;
988                 } else if (old_rate > vco_min) {
989 #if PLLXC_USE_DYN_RAMP
990                         pr_warn("No dynamic ramp down: %s: %lu to %lu\n",
991                                 c->u.cpu.main->name, old_rate, vco_min);
992 #endif
993                 }
994         }
995
996         /* Switch to back-up source, and stay on it if target rate is below
997            backup rate */
998         if (c->parent->parent != c->u.cpu.backup) {
999                 ret = clk_set_parent(c->parent, c->u.cpu.backup);
1000                 if (ret) {
1001                         pr_err("Failed to switch cpu to %s\n",
1002                                c->u.cpu.backup->name);
1003                         goto out;
1004                 }
1005         }
1006
1007         backup_rate = min(rate, c->u.cpu.backup_rate);
1008         if (backup_rate != clk_get_rate_locked(c)) {
1009                 ret = clk_set_rate(c->u.cpu.backup, backup_rate);
1010                 if (ret) {
1011                         pr_err("Failed to set cpu rate %lu on backup source\n",
1012                                backup_rate);
1013                         goto out;
1014                 }
1015         }
1016         if (rate == backup_rate)
1017                 goto out;
1018
1019         /* Switch from backup source to main at rate not exceeding pll VCO
1020            minimum. Use dynamic ramp to reach target rate if it is above VCO
1021            minimum. */
1022         main_rate = rate;
1023         if (rate > vco_min) {
1024                 if (tegra11_is_dyn_ramp(c->u.cpu.main, rate, true))
1025                         main_rate = vco_min;
1026 #if PLLXC_USE_DYN_RAMP
1027                 else
1028                         pr_warn("No dynamic ramp up: %s: %lu to %lu\n",
1029                                 c->u.cpu.main->name, vco_min, rate);
1030 #endif
1031         }
1032
1033         ret = clk_set_rate(c->u.cpu.main, main_rate);
1034         if (ret) {
1035                 pr_err("Failed to set cpu rate %lu on source"
1036                        " %s\n", main_rate, c->u.cpu.main->name);
1037                 goto out;
1038         }
1039         ret = clk_set_parent(c->parent, c->u.cpu.main);
1040         if (ret) {
1041                 pr_err("Failed to switch cpu to %s\n", c->u.cpu.main->name);
1042                 goto out;
1043         }
1044         if (rate != main_rate) {
1045                 ret = clk_set_rate(c->u.cpu.main, rate);
1046                 if (ret) {
1047                         pr_err("Failed to set cpu rate %lu on source"
1048                                " %s\n", rate, c->u.cpu.main->name);
1049                         goto out;
1050                 }
1051         }
1052
1053 out:
1054         if (on_main)
1055                 clk_disable(c->u.cpu.main);
1056
1057         return ret;
1058 }
1059
1060 static int tegra11_cpu_clk_dfll_on(struct clk *c, unsigned long rate,
1061                                    unsigned long old_rate)
1062 {
1063         int ret;
1064         struct clk *dfll = c->u.cpu.dynamic;
1065         unsigned long dfll_rate_min = c->dvfs->dfll_data.use_dfll_rate_min;
1066
1067         /* dfll rate request */
1068         ret = clk_set_rate(dfll, rate);
1069         if (ret) {
1070                 pr_err("Failed to set cpu rate %lu on source"
1071                        " %s\n", rate, dfll->name);
1072                 return ret;
1073         }
1074
1075         /* 1st time - switch to dfll */
1076         if (c->parent->parent != dfll) {
1077                 if (max(old_rate, rate) < dfll_rate_min) {
1078                         /* set interim cpu dvfs rate at dfll_rate_min to
1079                            prevent voltage drop below dfll Vmin */
1080                         ret = tegra_dvfs_set_rate(c, dfll_rate_min);
1081                         if (ret) {
1082                                 pr_err("Failed to set cpu dvfs rate %lu\n",
1083                                        dfll_rate_min);
1084                                 return ret;
1085                         }
1086                 }
1087
1088                 ret = clk_set_parent(c->parent, dfll);
1089                 if (ret) {
1090                         pr_err("Failed to switch cpu to %s\n", dfll->name);
1091                         return ret;
1092                 }
1093                 ret = tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 1);
1094                 WARN(ret, "Failed to lock %s at rate %lu\n", dfll->name, rate);
1095
1096                 /* prevent legacy dvfs voltage scaling */
1097                 tegra_dvfs_dfll_mode_set(c->dvfs, rate);
1098         }
1099         return 0;
1100 }
1101
1102 static int tegra11_cpu_clk_dfll_off(struct clk *c, unsigned long rate,
1103                                     unsigned long old_rate)
1104 {
1105         int ret;
1106         struct clk *pll;
1107         struct clk *dfll = c->u.cpu.dynamic;
1108         unsigned long dfll_rate_min = c->dvfs->dfll_data.use_dfll_rate_min;
1109
1110         rate = min(rate, c->max_rate - c->dvfs->dfll_data.max_rate_boost);
1111         pll = (rate <= c->u.cpu.backup_rate) ? c->u.cpu.backup : c->u.cpu.main;
1112
1113         ret = tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 0);
1114         if (ret) {
1115                 pr_err("Failed to unlock %s\n", dfll->name);
1116                 goto back_to_dfll;
1117         }
1118
1119         /* restore legacy dvfs operations and set appropriate voltage */
1120         ret = tegra_dvfs_dfll_mode_clear(c->dvfs, max(rate, dfll_rate_min));
1121         if (ret) {
1122                 pr_err("Failed to set cpu rail for rate %lu\n", rate);
1123                 goto back_to_dfll;
1124         }
1125
1126         /* set pll to target rate and return to pll source */
1127         ret = clk_set_rate(pll, rate);
1128         if (ret) {
1129                 pr_err("Failed to set cpu rate %lu on source"
1130                        " %s\n", rate, pll->name);
1131                 goto back_to_dfll;
1132         }
1133         ret = clk_set_parent(c->parent, pll);
1134         if (ret) {
1135                 pr_err("Failed to switch cpu to %s\n", pll->name);
1136                 goto back_to_dfll;
1137         }
1138
1139         /* If going up, adjust voltage here (down path is taken care of by the
1140            framework after set rate exit) */
1141         if (old_rate <= rate)
1142                 tegra_dvfs_set_rate(c, rate);
1143
1144         return 0;
1145
1146 back_to_dfll:
1147         tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 1);
1148         tegra_dvfs_dfll_mode_set(c->dvfs, old_rate);
1149         return ret;
1150 }
1151
1152 static int tegra11_cpu_clk_set_rate(struct clk *c, unsigned long rate)
1153 {
1154         unsigned long old_rate = clk_get_rate_locked(c);
1155         bool has_dfll = c->u.cpu.dynamic &&
1156                 (c->u.cpu.dynamic->state != UNINITIALIZED);
1157         bool is_dfll = c->parent->parent == c->u.cpu.dynamic;
1158
1159         /* On SILICON allow CPU rate change only if cpu regulator is connected.
1160            Ignore regulator connection on FPGA and SIMULATION platforms. */
1161 #ifdef CONFIG_TEGRA_SILICON_PLATFORM
1162         if (c->dvfs) {
1163                 if (!c->dvfs->dvfs_rail)
1164                         return -ENOSYS;
1165                 else if ((!c->dvfs->dvfs_rail->reg) && (old_rate < rate)) {
1166                         WARN(1, "Increasing CPU rate while regulator is not"
1167                                 " ready is not allowed\n");
1168                         return -ENOSYS;
1169                 }
1170         }
1171 #endif
1172         if (has_dfll && c->dvfs && c->dvfs->dvfs_rail) {
1173                 if (tegra_dvfs_is_dfll_range(c->dvfs, rate))
1174                         return tegra11_cpu_clk_dfll_on(c, rate, old_rate);
1175                 else if (is_dfll)
1176                         return tegra11_cpu_clk_dfll_off(c, rate, old_rate);
1177         }
1178         return tegra11_cpu_clk_set_plls(c, rate, old_rate);
1179 }
1180
1181 static long tegra11_cpu_clk_round_rate(struct clk *c, unsigned long rate)
1182 {
1183         unsigned long max_rate = c->max_rate;
1184
1185         /* Remove dfll boost to maximum rate when running on PLL */
1186         if (!c->dvfs || !tegra_dvfs_is_dfll_scale(c->dvfs, rate))
1187                 max_rate -= c->dvfs->dfll_data.max_rate_boost;
1188
1189         if (rate > max_rate)
1190                 rate = max_rate;
1191         else if (rate < c->min_rate)
1192                 rate = c->min_rate;
1193         return rate;
1194 }
1195
1196 static struct clk_ops tegra_cpu_ops = {
1197         .init     = tegra11_cpu_clk_init,
1198         .enable   = tegra11_cpu_clk_enable,
1199         .disable  = tegra11_cpu_clk_disable,
1200         .set_rate = tegra11_cpu_clk_set_rate,
1201         .round_rate = tegra11_cpu_clk_round_rate,
1202 };
1203
1204
1205 static void tegra11_cpu_cmplx_clk_init(struct clk *c)
1206 {
1207         int i = !!is_lp_cluster();
1208
1209         BUG_ON(c->inputs[0].input->u.cpu.mode != MODE_G);
1210         BUG_ON(c->inputs[1].input->u.cpu.mode != MODE_LP);
1211         c->parent = c->inputs[i].input;
1212 }
1213
1214 /* cpu complex clock provides second level vitualization (on top of
1215    cpu virtual cpu rate control) in order to hide the CPU mode switch
1216    sequence */
1217 #if PARAMETERIZE_CLUSTER_SWITCH
1218 static unsigned int switch_delay;
1219 static unsigned int switch_flags;
1220 static DEFINE_SPINLOCK(parameters_lock);
1221
1222 void tegra_cluster_switch_set_parameters(unsigned int us, unsigned int flags)
1223 {
1224         spin_lock(&parameters_lock);
1225         switch_delay = us;
1226         switch_flags = flags;
1227         spin_unlock(&parameters_lock);
1228 }
1229 #endif
1230
1231 static int tegra11_cpu_cmplx_clk_enable(struct clk *c)
1232 {
1233         return 0;
1234 }
1235
1236 static void tegra11_cpu_cmplx_clk_disable(struct clk *c)
1237 {
1238         pr_debug("%s on clock %s\n", __func__, c->name);
1239
1240         /* oops - don't disable the CPU complex clock! */
1241         BUG();
1242 }
1243
1244 static int tegra11_cpu_cmplx_clk_set_rate(struct clk *c, unsigned long rate)
1245 {
1246         unsigned long flags;
1247         int ret;
1248         struct clk *parent = c->parent;
1249
1250         if (!parent->ops || !parent->ops->set_rate)
1251                 return -ENOSYS;
1252
1253         clk_lock_save(parent, &flags);
1254
1255         ret = clk_set_rate_locked(parent, rate);
1256
1257         clk_unlock_restore(parent, &flags);
1258
1259         return ret;
1260 }
1261
1262 static int tegra11_cpu_cmplx_clk_set_parent(struct clk *c, struct clk *p)
1263 {
1264         int ret;
1265         unsigned int flags, delay;
1266         const struct clk_mux_sel *sel;
1267         unsigned long rate = clk_get_rate(c->parent);
1268         struct clk *dfll = c->parent->u.cpu.dynamic ? : p->u.cpu.dynamic;
1269         struct clk *p_source;
1270
1271         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
1272         BUG_ON(c->parent->u.cpu.mode != (is_lp_cluster() ? MODE_LP : MODE_G));
1273
1274         for (sel = c->inputs; sel->input != NULL; sel++) {
1275                 if (sel->input == p)
1276                         break;
1277         }
1278         if (!sel->input)
1279                 return -EINVAL;
1280
1281 #if PARAMETERIZE_CLUSTER_SWITCH
1282         spin_lock(&parameters_lock);
1283         flags = switch_flags;
1284         delay = switch_delay;
1285         switch_flags = 0;
1286         spin_unlock(&parameters_lock);
1287
1288         if (flags) {
1289                 /* over-clocking after the switch - allow, but lower rate */
1290                 if (rate > p->max_rate) {
1291                         rate = p->max_rate;
1292                         ret = clk_set_rate(c->parent, rate);
1293                         if (ret) {
1294                                 pr_err("%s: Failed to set rate %lu for %s\n",
1295                                         __func__, rate, p->name);
1296                                 return ret;
1297                         }
1298                 }
1299         } else
1300 #endif
1301         {
1302                 if (rate > p->max_rate) {       /* over-clocking - no switch */
1303                         pr_warn("%s: No %s mode switch to %s at rate %lu\n",
1304                                  __func__, c->name, p->name, rate);
1305                         return -ECANCELED;
1306                 }
1307                 flags = TEGRA_POWER_CLUSTER_IMMEDIATE;
1308                 flags |= TEGRA_POWER_CLUSTER_PART_DEFAULT;
1309                 delay = 0;
1310         }
1311         flags |= (p->u.cpu.mode == MODE_LP) ? TEGRA_POWER_CLUSTER_LP :
1312                 TEGRA_POWER_CLUSTER_G;
1313
1314         if (p == c->parent) {
1315                 if (flags & TEGRA_POWER_CLUSTER_FORCE) {
1316                         /* Allow parameterized switch to the same mode */
1317                         ret = tegra_cluster_control(delay, flags);
1318                         if (ret)
1319                                 pr_err("%s: Failed to force %s mode to %s\n",
1320                                        __func__, c->name, p->name);
1321                         return ret;
1322                 }
1323                 return 0;       /* already switched - exit */
1324         }
1325
1326         if (c->parent->parent->parent == dfll) {
1327                 /* G (DFLL selected as clock source) => LP switch:
1328                  * turn DFLL into open loop mode ("release" VDD_CPU rail)
1329                  * select target p_source for LP, and get its rate ready
1330                  */
1331                 ret = tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 0);
1332                 if (ret)
1333                         goto abort;
1334
1335                 p_source = rate <= p->u.cpu.backup_rate ?
1336                         p->u.cpu.backup : p->u.cpu.main;
1337                 ret = clk_set_rate(p_source, rate);
1338                 if (ret)
1339                         goto abort;
1340         } else if (p->parent->parent == dfll) {
1341                 /* LP => G (DFLL selected as clock source) switch:
1342                  * set DFLL rate ready (DFLL is still disabled)
1343                  * (set target p_source as dfll, G source is already selected)
1344                  */
1345                 p_source = dfll;
1346                 ret = clk_set_rate(p_source, rate);
1347                 if (ret)
1348                         goto abort;
1349         } else
1350                 /* DFLL is not selcted on either side of the switch:
1351                  * set target p_source equal to current clock source
1352                  */
1353                 p_source = c->parent->parent->parent;
1354
1355         /* Switch new parent to target clock source if necessary */
1356         if (p->parent->parent != p_source) {
1357                 ret = clk_set_parent(p->parent, p_source);
1358                 if (ret) {
1359                         pr_err("%s: Failed to set parent %s for %s\n",
1360                                __func__, p_source->name, p->name);
1361                         goto abort;
1362                 }
1363         }
1364
1365         /* Enabling new parent scales new mode voltage rail in advanvce
1366            before the switch happens (if p_source is DFLL: open loop mode) */
1367         if (c->refcnt)
1368                 clk_enable(p);
1369
1370         /* switch CPU mode */
1371         ret = tegra_cluster_control(delay, flags);
1372         if (ret) {
1373                 if (c->refcnt)
1374                         clk_disable(p);
1375                 pr_err("%s: Failed to switch %s mode to %s\n",
1376                        __func__, c->name, p->name);
1377                 goto abort;
1378         }
1379
1380         /* Disabling old parent scales old mode voltage rail */
1381         if (c->refcnt && c->parent)
1382                 clk_disable(c->parent);
1383
1384         clk_reparent(c, p);
1385
1386         /* Lock DFLL now (resume closed loop VDD_CPU control) */
1387         if (p_source == dfll)
1388                 tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 1);
1389
1390         return 0;
1391
1392 abort:
1393         /* Re-lock DFLL if necessary after aborted switch */
1394         if (c->parent->parent->parent == dfll)
1395                 tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 1);
1396         return ret;
1397 }
1398
1399 static long tegra11_cpu_cmplx_round_rate(struct clk *c,
1400         unsigned long rate)
1401 {
1402         return clk_round_rate(c->parent, rate);
1403 }
1404
1405 static struct clk_ops tegra_cpu_cmplx_ops = {
1406         .init     = tegra11_cpu_cmplx_clk_init,
1407         .enable   = tegra11_cpu_cmplx_clk_enable,
1408         .disable  = tegra11_cpu_cmplx_clk_disable,
1409         .set_rate = tegra11_cpu_cmplx_clk_set_rate,
1410         .set_parent = tegra11_cpu_cmplx_clk_set_parent,
1411         .round_rate = tegra11_cpu_cmplx_round_rate,
1412 };
1413
1414 /* virtual cop clock functions. Used to acquire the fake 'cop' clock to
1415  * reset the COP block (i.e. AVP) */
1416 static void tegra11_cop_clk_reset(struct clk *c, bool assert)
1417 {
1418         unsigned long reg = assert ? RST_DEVICES_SET_L : RST_DEVICES_CLR_L;
1419
1420         pr_debug("%s %s\n", __func__, assert ? "assert" : "deassert");
1421         clk_writel(1 << 1, reg);
1422 }
1423
1424 static struct clk_ops tegra_cop_ops = {
1425         .reset    = tegra11_cop_clk_reset,
1426 };
1427
1428 /* bus clock functions */
1429 static void tegra11_bus_clk_init(struct clk *c)
1430 {
1431         u32 val = clk_readl(c->reg);
1432         c->state = ((val >> c->reg_shift) & BUS_CLK_DISABLE) ? OFF : ON;
1433         c->div = ((val >> c->reg_shift) & BUS_CLK_DIV_MASK) + 1;
1434         c->mul = 1;
1435 }
1436
1437 static int tegra11_bus_clk_enable(struct clk *c)
1438 {
1439         u32 val = clk_readl(c->reg);
1440         val &= ~(BUS_CLK_DISABLE << c->reg_shift);
1441         clk_writel(val, c->reg);
1442         return 0;
1443 }
1444
1445 static void tegra11_bus_clk_disable(struct clk *c)
1446 {
1447         u32 val = clk_readl(c->reg);
1448         val |= BUS_CLK_DISABLE << c->reg_shift;
1449         clk_writel(val, c->reg);
1450 }
1451
1452 static int tegra11_bus_clk_set_rate(struct clk *c, unsigned long rate)
1453 {
1454         u32 val = clk_readl(c->reg);
1455         unsigned long parent_rate = clk_get_rate(c->parent);
1456         int i;
1457         for (i = 1; i <= 4; i++) {
1458                 if (rate >= parent_rate / i) {
1459                         val &= ~(BUS_CLK_DIV_MASK << c->reg_shift);
1460                         val |= (i - 1) << c->reg_shift;
1461                         clk_writel(val, c->reg);
1462                         c->div = i;
1463                         c->mul = 1;
1464                         return 0;
1465                 }
1466         }
1467         return -EINVAL;
1468 }
1469
1470 static struct clk_ops tegra_bus_ops = {
1471         .init                   = tegra11_bus_clk_init,
1472         .enable                 = tegra11_bus_clk_enable,
1473         .disable                = tegra11_bus_clk_disable,
1474         .set_rate               = tegra11_bus_clk_set_rate,
1475 };
1476
1477 /* Virtual system bus complex clock is used to hide the sequence of
1478    changing sclk/hclk/pclk parents and dividers to configure requested
1479    sclk target rate. */
1480 static void tegra11_sbus_cmplx_init(struct clk *c)
1481 {
1482         unsigned long rate;
1483
1484         c->max_rate = c->parent->max_rate;
1485         c->min_rate = c->parent->min_rate;
1486
1487         /* Threshold must be an exact proper factor of low range parent,
1488            and both low/high range parents have 7.1 fractional dividers */
1489         rate = clk_get_rate(c->u.system.sclk_low->parent);
1490         if (c->u.system.threshold) {
1491                 BUG_ON(c->u.system.threshold > rate) ;
1492                 BUG_ON((rate % c->u.system.threshold) != 0);
1493         }
1494         BUG_ON(!(c->u.system.sclk_low->flags & DIV_U71));
1495         BUG_ON(!(c->u.system.sclk_high->flags & DIV_U71));
1496 }
1497
1498 /* This special sbus round function is implemented because:
1499  *
1500  * (a) fractional 1 : 1.5 divider can not be used to derive system bus clock
1501  *
1502  * (b) since sbus is a shared bus, and its frequency is set to the highest
1503  * enabled shared_bus_user clock, the target rate should be rounded up divider
1504  * ladder (if max limit allows it) - for pll_div and peripheral_div common is
1505  * rounding down - special case again.
1506  *
1507  * Note that final rate is trimmed (not rounded up) to avoid spiraling up in
1508  * recursive calls. Lost 1Hz is added in tegra11_sbus_cmplx_set_rate before
1509  * actually setting divider rate.
1510  */
1511 static long tegra11_sbus_cmplx_round_rate(struct clk *c, unsigned long rate)
1512 {
1513         int divider;
1514         unsigned long source_rate, round_rate;
1515         struct clk *new_parent;
1516
1517         rate = max(rate, c->min_rate);
1518
1519         new_parent = (rate <= c->u.system.threshold) ?
1520                 c->u.system.sclk_low : c->u.system.sclk_high;
1521         source_rate = clk_get_rate(new_parent->parent);
1522
1523         divider = clk_div71_get_divider(source_rate, rate,
1524                 new_parent->flags, ROUND_DIVIDER_DOWN);
1525         if (divider < 0)
1526                 return divider;
1527
1528         if (divider == 1)
1529                 divider = 0;
1530
1531         round_rate = source_rate * 2 / (divider + 2);
1532         if (round_rate > c->max_rate) {
1533                 divider = max(2, (divider + 1));
1534                 round_rate = source_rate * 2 / (divider + 2);
1535         }
1536
1537         if (new_parent == c->u.system.sclk_high) {
1538                 /* Prevent oscillation across threshold */
1539                 if (round_rate <= c->u.system.threshold)
1540                         round_rate = c->u.system.threshold;
1541         }
1542         return round_rate;
1543 }
1544
1545 static int tegra11_sbus_cmplx_set_rate(struct clk *c, unsigned long rate)
1546 {
1547         int ret;
1548         struct clk *new_parent;
1549
1550         /* - select the appropriate sclk parent
1551            - keep hclk at the same rate as sclk
1552            - set pclk at 1:2 rate of hclk unless pclk minimum is violated,
1553              in the latter case switch to 1:1 ratio */
1554
1555         if (rate >= c->u.system.pclk->min_rate * 2) {
1556                 ret = clk_set_div(c->u.system.pclk, 2);
1557                 if (ret) {
1558                         pr_err("Failed to set 1 : 2 pclk divider\n");
1559                         return ret;
1560                 }
1561         }
1562
1563         new_parent = (rate <= c->u.system.threshold) ?
1564                 c->u.system.sclk_low : c->u.system.sclk_high;
1565
1566         ret = clk_set_rate(new_parent, rate + 1);
1567         if (ret) {
1568                 pr_err("Failed to set sclk source %s to %lu\n",
1569                        new_parent->name, rate);
1570                 return ret;
1571         }
1572
1573         if (new_parent != clk_get_parent(c->parent)) {
1574                 ret = clk_set_parent(c->parent, new_parent);
1575                 if (ret) {
1576                         pr_err("Failed to switch sclk source to %s\n",
1577                                new_parent->name);
1578                         return ret;
1579                 }
1580         }
1581
1582         if (rate < c->u.system.pclk->min_rate * 2) {
1583                 ret = clk_set_div(c->u.system.pclk, 1);
1584                 if (ret) {
1585                         pr_err("Failed to set 1 : 1 pclk divider\n");
1586                         return ret;
1587                 }
1588         }
1589
1590         return 0;
1591 }
1592
1593 static int tegra11_clk_sbus_update(struct clk *bus)
1594 {
1595         unsigned long rate, old_rate;
1596
1597         if (detach_shared_bus)
1598                 return 0;
1599
1600         rate = tegra11_clk_shared_bus_update(bus, NULL, NULL);
1601         rate = clk_round_rate_locked(bus, rate);
1602
1603         old_rate = clk_get_rate_locked(bus);
1604         if (rate == old_rate)
1605                 return 0;
1606
1607         return clk_set_rate_locked(bus, rate);
1608 }
1609
1610 static struct clk_ops tegra_sbus_cmplx_ops = {
1611         .init = tegra11_sbus_cmplx_init,
1612         .set_rate = tegra11_sbus_cmplx_set_rate,
1613         .round_rate = tegra11_sbus_cmplx_round_rate,
1614         .shared_bus_update = tegra11_clk_sbus_update,
1615 };
1616
1617 /* Blink output functions */
1618
1619 static void tegra11_blink_clk_init(struct clk *c)
1620 {
1621         u32 val;
1622
1623         val = pmc_readl(PMC_CTRL);
1624         c->state = (val & PMC_CTRL_BLINK_ENB) ? ON : OFF;
1625         c->mul = 1;
1626         val = pmc_readl(c->reg);
1627
1628         if (val & PMC_BLINK_TIMER_ENB) {
1629                 unsigned int on_off;
1630
1631                 on_off = (val >> PMC_BLINK_TIMER_DATA_ON_SHIFT) &
1632                         PMC_BLINK_TIMER_DATA_ON_MASK;
1633                 val >>= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
1634                 val &= PMC_BLINK_TIMER_DATA_OFF_MASK;
1635                 on_off += val;
1636                 /* each tick in the blink timer is 4 32KHz clocks */
1637                 c->div = on_off * 4;
1638         } else {
1639                 c->div = 1;
1640         }
1641 }
1642
1643 static int tegra11_blink_clk_enable(struct clk *c)
1644 {
1645         u32 val;
1646
1647         val = pmc_readl(PMC_DPD_PADS_ORIDE);
1648         pmc_writel(val | PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
1649
1650         val = pmc_readl(PMC_CTRL);
1651         pmc_writel(val | PMC_CTRL_BLINK_ENB, PMC_CTRL);
1652
1653         return 0;
1654 }
1655
1656 static void tegra11_blink_clk_disable(struct clk *c)
1657 {
1658         u32 val;
1659
1660         val = pmc_readl(PMC_CTRL);
1661         pmc_writel(val & ~PMC_CTRL_BLINK_ENB, PMC_CTRL);
1662
1663         val = pmc_readl(PMC_DPD_PADS_ORIDE);
1664         pmc_writel(val & ~PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
1665 }
1666
1667 static int tegra11_blink_clk_set_rate(struct clk *c, unsigned long rate)
1668 {
1669         unsigned long parent_rate = clk_get_rate(c->parent);
1670         if (rate >= parent_rate) {
1671                 c->div = 1;
1672                 pmc_writel(0, c->reg);
1673         } else {
1674                 unsigned int on_off;
1675                 u32 val;
1676
1677                 on_off = DIV_ROUND_UP(parent_rate / 8, rate);
1678                 c->div = on_off * 8;
1679
1680                 val = (on_off & PMC_BLINK_TIMER_DATA_ON_MASK) <<
1681                         PMC_BLINK_TIMER_DATA_ON_SHIFT;
1682                 on_off &= PMC_BLINK_TIMER_DATA_OFF_MASK;
1683                 on_off <<= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
1684                 val |= on_off;
1685                 val |= PMC_BLINK_TIMER_ENB;
1686                 pmc_writel(val, c->reg);
1687         }
1688
1689         return 0;
1690 }
1691
1692 static struct clk_ops tegra_blink_clk_ops = {
1693         .init                   = &tegra11_blink_clk_init,
1694         .enable                 = &tegra11_blink_clk_enable,
1695         .disable                = &tegra11_blink_clk_disable,
1696         .set_rate               = &tegra11_blink_clk_set_rate,
1697 };
1698
1699 /* PLL Functions */
1700 static int tegra11_pll_clk_wait_for_lock(
1701         struct clk *c, u32 lock_reg, u32 lock_bits)
1702 {
1703 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
1704 #if USE_PLL_LOCK_BITS
1705         int i;
1706         for (i = 0; i < (c->u.pll.lock_delay / PLL_PRE_LOCK_DELAY + 1); i++) {
1707                 udelay(PLL_PRE_LOCK_DELAY);
1708                 if ((clk_readl(lock_reg) & lock_bits) == lock_bits) {
1709                         udelay(PLL_POST_LOCK_DELAY);
1710                         return 0;
1711                 }
1712         }
1713         pr_err("Timed out waiting for lock bit on pll %s\n", c->name);
1714         return -1;
1715 #endif
1716         udelay(c->u.pll.lock_delay);
1717 #endif
1718         return 0;
1719 }
1720
1721 static void usb_plls_hw_control_enable(u32 reg)
1722 {
1723         u32 val = clk_readl(reg);
1724         val |= USB_PLLS_USE_LOCKDET;
1725         val &= ~USB_PLLS_ENABLE_SWCTL;
1726         val |= USB_PLLS_SEQ_START_STATE;
1727         pll_writel_delay(val, reg);
1728
1729         val |= USB_PLLS_SEQ_ENABLE;
1730         pll_writel_delay(val, reg);
1731 }
1732
1733 static void tegra11_utmi_param_configure(struct clk *c)
1734 {
1735         u32 reg;
1736         int i;
1737         unsigned long main_rate =
1738                 clk_get_rate(c->parent->parent);
1739
1740         for (i = 0; i < ARRAY_SIZE(utmi_parameters); i++) {
1741                 if (main_rate == utmi_parameters[i].osc_frequency) {
1742                         break;
1743                 }
1744         }
1745
1746         if (i >= ARRAY_SIZE(utmi_parameters)) {
1747                 pr_err("%s: Unexpected main rate %lu\n", __func__, main_rate);
1748                 return;
1749         }
1750
1751         reg = clk_readl(UTMIP_PLL_CFG2);
1752
1753         /* Program UTMIP PLL stable and active counts */
1754         /* [FIXME] arclk_rst.h says WRONG! This should be 1ms -> 0x50 Check! */
1755         reg &= ~UTMIP_PLL_CFG2_STABLE_COUNT(~0);
1756         reg |= UTMIP_PLL_CFG2_STABLE_COUNT(
1757                         utmi_parameters[i].stable_count);
1758
1759         reg &= ~UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(~0);
1760
1761         reg |= UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(
1762                         utmi_parameters[i].active_delay_count);
1763
1764         /* Remove power downs from UTMIP PLL control bits */
1765         reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_A_POWERDOWN;
1766         reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_B_POWERDOWN;
1767         reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_C_POWERDOWN;
1768
1769         clk_writel(reg, UTMIP_PLL_CFG2);
1770
1771         /* Program UTMIP PLL delay and oscillator frequency counts */
1772         reg = clk_readl(UTMIP_PLL_CFG1);
1773         reg &= ~UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(~0);
1774
1775         reg |= UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(
1776                 utmi_parameters[i].enable_delay_count);
1777
1778         reg &= ~UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(~0);
1779         reg |= UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(
1780                 utmi_parameters[i].xtal_freq_count);
1781
1782         /* Remove power downs from UTMIP PLL control bits */
1783         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN;
1784         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ACTIVE_POWERDOWN;
1785         reg &= ~UTMIP_PLL_CFG1_FORCE_PLLU_POWERUP;
1786         reg &= ~UTMIP_PLL_CFG1_FORCE_PLLU_POWERDOWN;
1787         clk_writel(reg, UTMIP_PLL_CFG1);
1788
1789         /* Setup HW control of UTMIPLL */
1790         reg = clk_readl(UTMIPLL_HW_PWRDN_CFG0);
1791         reg |= UTMIPLL_HW_PWRDN_CFG0_USE_LOCKDET;
1792         reg &= ~UTMIPLL_HW_PWRDN_CFG0_CLK_ENABLE_SWCTL;
1793         reg |= UTMIPLL_HW_PWRDN_CFG0_SEQ_START_STATE;
1794         clk_writel(reg, UTMIPLL_HW_PWRDN_CFG0);
1795
1796         reg = clk_readl(UTMIP_PLL_CFG1);
1797         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERUP;
1798         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN;
1799         clk_writel(reg, UTMIP_PLL_CFG1);
1800
1801         udelay(1);
1802
1803         /* Setup SW override of UTMIPLL assuming USB2.0
1804            ports are assigned to USB2 */
1805         reg = clk_readl(UTMIPLL_HW_PWRDN_CFG0);
1806         reg |= UTMIPLL_HW_PWRDN_CFG0_IDDQ_SWCTL;
1807         reg &= ~UTMIPLL_HW_PWRDN_CFG0_IDDQ_OVERRIDE;
1808         clk_writel(reg, UTMIPLL_HW_PWRDN_CFG0);
1809
1810         udelay(1);
1811
1812         /* Enable HW control UTMIPLL */
1813         reg = clk_readl(UTMIPLL_HW_PWRDN_CFG0);
1814         reg |= UTMIPLL_HW_PWRDN_CFG0_SEQ_ENABLE;
1815         clk_writel(reg, UTMIPLL_HW_PWRDN_CFG0);
1816 }
1817
1818 static void tegra11_pll_clk_init(struct clk *c)
1819 {
1820         u32 val = clk_readl(c->reg + PLL_BASE);
1821
1822         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
1823
1824         if (c->flags & PLL_FIXED && !(val & PLL_BASE_OVERRIDE)) {
1825                 const struct clk_pll_freq_table *sel;
1826                 unsigned long input_rate = clk_get_rate(c->parent);
1827                 c->u.pll.fixed_rate = PLLP_DEFAULT_FIXED_RATE;
1828
1829                 for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
1830                         if (sel->input_rate == input_rate &&
1831                                 sel->output_rate == c->u.pll.fixed_rate) {
1832                                 c->mul = sel->n;
1833                                 c->div = sel->m * sel->p;
1834                                 return;
1835                         }
1836                 }
1837                 pr_err("Clock %s has unknown fixed frequency\n", c->name);
1838                 BUG();
1839         } else if (val & PLL_BASE_BYPASS) {
1840                 c->mul = 1;
1841                 c->div = 1;
1842         } else {
1843                 c->mul = (val & PLL_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
1844                 c->div = (val & PLL_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
1845                 if (c->flags & PLLU)
1846                         c->div *= (val & PLLU_BASE_POST_DIV) ? 1 : 2;
1847                 else
1848                         c->div *= (0x1 << ((val & PLL_BASE_DIVP_MASK) >>
1849                                         PLL_BASE_DIVP_SHIFT));
1850         }
1851
1852         if (c->flags & PLL_FIXED) {
1853                 c->u.pll.fixed_rate = clk_get_rate_locked(c);
1854         }
1855
1856         if (c->flags & PLLU) {
1857                 /* Configure UTMI PLL power management */
1858                 tegra11_utmi_param_configure(c);
1859
1860                 /* Put PLLU under h/w control */
1861                 usb_plls_hw_control_enable(PLLU_HW_PWRDN_CFG0);
1862
1863                 val = clk_readl(c->reg + PLL_BASE);
1864                 val &= ~PLLU_BASE_OVERRIDE;
1865                 clk_writel(val, c->reg + PLL_BASE);
1866         }
1867 }
1868
1869 static int tegra11_pll_clk_enable(struct clk *c)
1870 {
1871         u32 val;
1872         pr_debug("%s on clock %s\n", __func__, c->name);
1873
1874 #if USE_PLL_LOCK_BITS
1875         val = clk_readl(c->reg + PLL_MISC(c));
1876         val |= PLL_MISC_LOCK_ENABLE(c);
1877         clk_writel(val, c->reg + PLL_MISC(c));
1878 #endif
1879         val = clk_readl(c->reg + PLL_BASE);
1880         val &= ~PLL_BASE_BYPASS;
1881         val |= PLL_BASE_ENABLE;
1882         clk_writel(val, c->reg + PLL_BASE);
1883
1884         tegra11_pll_clk_wait_for_lock(c, c->reg + PLL_BASE, PLL_BASE_LOCK);
1885
1886         return 0;
1887 }
1888
1889 static void tegra11_pll_clk_disable(struct clk *c)
1890 {
1891         u32 val;
1892         pr_debug("%s on clock %s\n", __func__, c->name);
1893
1894         val = clk_readl(c->reg);
1895         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
1896         clk_writel(val, c->reg);
1897 }
1898
1899 static int tegra11_pll_clk_set_rate(struct clk *c, unsigned long rate)
1900 {
1901         u32 val, p_div, old_base;
1902         unsigned long input_rate;
1903         const struct clk_pll_freq_table *sel;
1904         struct clk_pll_freq_table cfg;
1905
1906         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
1907
1908         if (c->flags & PLL_FIXED) {
1909                 int ret = 0;
1910                 if (rate != c->u.pll.fixed_rate) {
1911                         pr_err("%s: Can not change %s fixed rate %lu to %lu\n",
1912                                __func__, c->name, c->u.pll.fixed_rate, rate);
1913                         ret = -EINVAL;
1914                 }
1915                 return ret;
1916         }
1917
1918         p_div = 0;
1919         input_rate = clk_get_rate(c->parent);
1920
1921         /* Check if the target rate is tabulated */
1922         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
1923                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
1924                         if (c->flags & PLLU) {
1925                                 BUG_ON(sel->p < 1 || sel->p > 2);
1926                                 if (sel->p == 1)
1927                                         p_div = PLLU_BASE_POST_DIV;
1928                         } else {
1929                                 BUG_ON(sel->p < 1);
1930                                 for (val = sel->p; val > 1; val >>= 1, p_div++);
1931                                 p_div <<= PLL_BASE_DIVP_SHIFT;
1932                         }
1933                         break;
1934                 }
1935         }
1936
1937         /* Configure out-of-table rate */
1938         if (sel->input_rate == 0) {
1939                 unsigned long cfreq, vco;
1940                 BUG_ON(c->flags & PLLU);
1941                 sel = &cfg;
1942
1943                 switch (input_rate) {
1944                 case 12000000:
1945                 case 26000000:
1946                         cfreq = (rate <= 1000000 * 1000) ? 1000000 : 2000000;
1947                         break;
1948                 case 13000000:
1949                         cfreq = (rate <= 1000000 * 1000) ? 1000000 : 2600000;
1950                         break;
1951                 case 16800000:
1952                 case 19200000:
1953                         cfreq = (rate <= 1200000 * 1000) ? 1200000 : 2400000;
1954                         break;
1955                 default:
1956                         if (c->parent->flags & DIV_U71_FIXED) {
1957                                 /* PLLP_OUT1 rate is not in PLLA table */
1958                                 pr_warn("%s: failed %s ref/out rates %lu/%lu\n",
1959                                         __func__, c->name, input_rate, rate);
1960                                 cfreq = input_rate/(input_rate/1000000);
1961                                 break;
1962                         }
1963                         pr_err("%s: Unexpected reference rate %lu\n",
1964                                __func__, input_rate);
1965                         BUG();
1966                 }
1967
1968                 /* Raise VCO to guarantee 0.5% accuracy, and vco min boundary */
1969                 vco = max(200 * cfreq, c->u.pll.vco_min);
1970                 for (cfg.output_rate = rate; cfg.output_rate < vco; p_div++)
1971                         cfg.output_rate <<= 1;
1972
1973                 cfg.p = 0x1 << p_div;
1974                 cfg.m = input_rate / cfreq;
1975                 cfg.n = cfg.output_rate / cfreq;
1976                 cfg.cpcon = c->u.pll.cpcon_default ? : OUT_OF_TABLE_CPCON;
1977
1978                 if ((cfg.m > (PLL_BASE_DIVM_MASK >> PLL_BASE_DIVM_SHIFT)) ||
1979                     (cfg.n > (PLL_BASE_DIVN_MASK >> PLL_BASE_DIVN_SHIFT)) ||
1980                     (p_div > (PLL_BASE_DIVP_MASK >> PLL_BASE_DIVP_SHIFT)) ||
1981                     (cfg.output_rate > c->u.pll.vco_max)) {
1982                         pr_err("%s: Failed to set %s out-of-table rate %lu\n",
1983                                __func__, c->name, rate);
1984                         return -EINVAL;
1985                 }
1986                 p_div <<= PLL_BASE_DIVP_SHIFT;
1987         }
1988
1989         c->mul = sel->n;
1990         c->div = sel->m * sel->p;
1991
1992         old_base = val = clk_readl(c->reg + PLL_BASE);
1993         val &= ~(PLL_BASE_DIVM_MASK | PLL_BASE_DIVN_MASK |
1994                  ((c->flags & PLLU) ? PLLU_BASE_POST_DIV : PLL_BASE_DIVP_MASK));
1995         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
1996                 (sel->n << PLL_BASE_DIVN_SHIFT) | p_div;
1997         if (val == old_base)
1998                 return 0;
1999
2000         if (c->state == ON) {
2001                 tegra11_pll_clk_disable(c);
2002                 val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
2003         }
2004         clk_writel(val, c->reg + PLL_BASE);
2005
2006         if (c->flags & PLL_HAS_CPCON) {
2007                 val = clk_readl(c->reg + PLL_MISC(c));
2008                 val &= ~PLL_MISC_CPCON_MASK;
2009                 val |= sel->cpcon << PLL_MISC_CPCON_SHIFT;
2010                 if (c->flags & (PLLU | PLLD)) {
2011                         val &= ~PLL_MISC_LFCON_MASK;
2012                         val |= PLLDU_LFCON << PLL_MISC_LFCON_SHIFT;
2013                 }
2014                 clk_writel(val, c->reg + PLL_MISC(c));
2015         }
2016
2017         if (c->state == ON)
2018                 tegra11_pll_clk_enable(c);
2019
2020         return 0;
2021 }
2022
2023 static struct clk_ops tegra_pll_ops = {
2024         .init                   = tegra11_pll_clk_init,
2025         .enable                 = tegra11_pll_clk_enable,
2026         .disable                = tegra11_pll_clk_disable,
2027         .set_rate               = tegra11_pll_clk_set_rate,
2028 };
2029
2030 static void tegra11_pllp_clk_init(struct clk *c)
2031 {
2032         tegra11_pll_clk_init(c);
2033         tegra11_pllp_init_dependencies(c->u.pll.fixed_rate);
2034 }
2035
2036 #ifdef CONFIG_PM_SLEEP
2037 static void tegra11_pllp_clk_resume(struct clk *c)
2038 {
2039         unsigned long rate = c->u.pll.fixed_rate;
2040         tegra11_pll_clk_init(c);
2041         BUG_ON(rate != c->u.pll.fixed_rate);
2042 }
2043 #endif
2044
2045 static struct clk_ops tegra_pllp_ops = {
2046         .init                   = tegra11_pllp_clk_init,
2047         .enable                 = tegra11_pll_clk_enable,
2048         .disable                = tegra11_pll_clk_disable,
2049         .set_rate               = tegra11_pll_clk_set_rate,
2050 };
2051
2052 static int
2053 tegra11_plld_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
2054 {
2055         u32 val, mask, reg;
2056
2057         switch (p) {
2058         case TEGRA_CLK_PLLD_CSI_OUT_ENB:
2059                 mask = PLLD_BASE_CSI_CLKENABLE | PLLD_BASE_CSI_CLKSOURCE;
2060                 reg = c->reg + PLL_BASE;
2061                 break;
2062         case TEGRA_CLK_PLLD_DSI_OUT_ENB:
2063                 mask = PLLD_MISC_DSI_CLKENABLE;
2064                 reg = c->reg + PLL_MISC(c);
2065                 break;
2066         case TEGRA_CLK_PLLD_MIPI_MUX_SEL:
2067                 mask = PLLD_BASE_DSI_MUX_MASK;
2068                 reg = c->reg + PLL_BASE;
2069                 break;
2070         default:
2071                 return -EINVAL;
2072         }
2073
2074         val = clk_readl(reg);
2075         if (setting)
2076                 val |= mask;
2077         else
2078                 val &= ~mask;
2079         clk_writel(val, reg);
2080         return 0;
2081 }
2082
2083 static struct clk_ops tegra_plld_ops = {
2084         .init                   = tegra11_pll_clk_init,
2085         .enable                 = tegra11_pll_clk_enable,
2086         .disable                = tegra11_pll_clk_disable,
2087         .set_rate               = tegra11_pll_clk_set_rate,
2088         .clk_cfg_ex             = tegra11_plld_clk_cfg_ex,
2089 };
2090
2091 /*
2092  * Dynamic ramp PLLs:
2093  *  PLLC2 and PLLC3 (PLLCX)
2094  *  PLLX and PLLC (PLLXC)
2095  *
2096  * When scaling PLLC and PLLX, dynamic ramp is allowed for any transition that
2097  * changes NDIV only. As a matter of policy we will make sure that switching
2098  * between output rates above VCO minimum is always dynamic. The pre-requisite
2099  * for the above guarantee is the following configuration convention:
2100  * - pll configured with fixed MDIV
2101  * - when output rate is above VCO minimum PDIV = 0 (p-value = 1)
2102  * Switching between output rates below VCO minimum may or may not be dynamic,
2103  * and switching across VCO minimum is never dynamic.
2104  *
2105  * PLLC2 and PLLC3 in addition to dynamic ramp mechanism have also glitchless
2106  * output dividers. However dynamic ramp without overshoot is guaranteed only
2107  * when output divisor is less or equal 8.
2108  *
2109  * Of course, dynamic ramp is applied provided PLL is already enabled.
2110  */
2111
2112 /*
2113  * Common configuration policy for dynamic ramp PLLs:
2114  * - always set fixed M-value based on the reference rate
2115  * - always set P-value value 1:1 for output rates above VCO minimum, and
2116  *   choose minimum necessary P-value for output rates below VCO minimum
2117  * - calculate N-value based on selected M and P
2118  */
2119 static int pll_dyn_ramp_cfg(struct clk *c, struct clk_pll_freq_table *cfg,
2120         unsigned long rate, unsigned long input_rate, u32 *pdiv)
2121 {
2122         u32 p;
2123
2124         if (!rate)
2125                 return -EINVAL;
2126
2127         p = DIV_ROUND_UP(c->u.pll.vco_min, rate);
2128         p = c->u.pll.round_p_to_pdiv(p, pdiv);
2129         if (IS_ERR_VALUE(p))
2130                 return -EINVAL;
2131
2132         cfg->m = PLL_FIXED_MDIV(c, input_rate);
2133         cfg->p = p;
2134         cfg->output_rate = rate * cfg->p;
2135         cfg->n = cfg->output_rate * cfg->m / input_rate;
2136
2137         /* can use PLLCX N-divider field layout for all dynamic ramp PLLs */
2138         if ((cfg->n > (PLLCX_BASE_DIVN_MASK >> PLL_BASE_DIVN_SHIFT)) ||
2139             (cfg->output_rate > c->u.pll.vco_max))
2140                 return -EINVAL;
2141
2142         return 0;
2143 }
2144
2145 static int pll_dyn_ramp_find_cfg(struct clk *c, struct clk_pll_freq_table *cfg,
2146         unsigned long rate, unsigned long input_rate, u32 *pdiv)
2147 {
2148         const struct clk_pll_freq_table *sel;
2149
2150         /* Check if the target rate is tabulated */
2151         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
2152                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
2153                         u32 p = c->u.pll.round_p_to_pdiv(sel->p, pdiv);
2154                         BUG_ON(IS_ERR_VALUE(p));
2155                         BUG_ON(sel->m != PLL_FIXED_MDIV(c, input_rate));
2156                         *cfg = *sel;
2157                         return 0;
2158                 }
2159         }
2160
2161         /* Configure out-of-table rate */
2162         if (pll_dyn_ramp_cfg(c, cfg, rate, input_rate, pdiv)) {
2163                 pr_err("%s: Failed to set %s out-of-table rate %lu\n",
2164                        __func__, c->name, rate);
2165                 return -EINVAL;
2166         }
2167         return 0;
2168 }
2169
2170 static inline void pll_do_iddq(struct clk *c, u32 offs, u32 iddq_bit, bool set)
2171 {
2172         u32 val = clk_readl(c->reg + offs);
2173         if (set)
2174                 val |= iddq_bit;
2175         else
2176                 val &= ~iddq_bit;
2177         clk_writel_delay(val, c->reg + offs);
2178 }
2179
2180
2181 static u8 pllcx_p[PLLCX_PDIV_MAX + 1] = {
2182 /* PDIV: 0, 1, 2, 3, 4, 5,  6,  7 */
2183 /* p: */ 1, 2, 3, 4, 6, 8, 12, 16 };
2184
2185 static u32 pllcx_round_p_to_pdiv(u32 p, u32 *pdiv)
2186 {
2187         int i;
2188
2189         if (p) {
2190                 for (i = 0; i <= PLLCX_PDIV_MAX; i++) {
2191                         /* Do not use DIV3 p values - mapped to even PDIV */
2192                         if (i && ((i & 0x1) == 0))
2193                                 continue;
2194
2195                         if (p <= pllcx_p[i]) {
2196                                 if (pdiv)
2197                                         *pdiv = i;
2198                                 return pllcx_p[i];
2199                         }
2200                 }
2201         }
2202         return -EINVAL;
2203 }
2204
2205 static void pllcx_update_dynamic_koef(struct clk *c, unsigned long input_rate,
2206                                         u32 n)
2207 {
2208         u32 val, n_threshold;
2209
2210         switch (input_rate) {
2211         case 12000000:
2212                 n_threshold = 77;
2213                 break;
2214         case 13000000:
2215         case 26000000:
2216                 n_threshold = 71;
2217                 break;
2218         case 16800000:
2219                 n_threshold = 55;
2220                 break;
2221         case 19200000:
2222                 n_threshold = 48;
2223                 break;
2224         default:
2225                 pr_err("%s: Unexpected reference rate %lu\n",
2226                         __func__, input_rate);
2227                 BUG();
2228                 return;
2229         }
2230
2231         val = clk_readl(c->reg + PLL_MISC(c));
2232         val &= ~(PLLCX_MISC_KA_MASK | PLLCX_MISC_KB_MASK);
2233         val |= n <= n_threshold ?
2234                 PLLCX_MISC_KOEF_LOW_RANGE : PLLCX_MISC_KOEF_HIGH_RANGE;
2235         clk_writel(val, c->reg + PLL_MISC(c));
2236 }
2237
2238 static void pllcx_strobe(struct clk *c)
2239 {
2240         u32 reg = c->reg + PLL_MISC(c);
2241         u32 val = clk_readl(reg);
2242
2243         val |= PLLCX_MISC_STROBE;
2244         pll_writel_delay(val, reg);
2245
2246         val &= ~PLLCX_MISC_STROBE;
2247         clk_writel(val, reg);
2248 }
2249
2250 static void pllcx_set_defaults(struct clk *c, unsigned long input_rate, u32 n)
2251 {
2252         clk_writel(PLLCX_MISC_DEFAULT_VALUE, c->reg + PLL_MISC(c));
2253         clk_writel(PLLCX_MISC1_DEFAULT_VALUE, c->reg + PLL_MISCN(c, 1));
2254         clk_writel(PLLCX_MISC2_DEFAULT_VALUE, c->reg + PLL_MISCN(c, 2));
2255         clk_writel(PLLCX_MISC3_DEFAULT_VALUE, c->reg + PLL_MISCN(c, 3));
2256
2257         pllcx_update_dynamic_koef(c, input_rate, n);
2258 }
2259
2260 static void tegra11_pllcx_clk_init(struct clk *c)
2261 {
2262         unsigned long input_rate = clk_get_rate(c->parent);
2263         u32 m, n, p, val;
2264
2265         /* clip vco_min to exact multiple of input rate to avoid crossover
2266            by rounding */
2267         c->u.pll.vco_min =
2268                 DIV_ROUND_UP(c->u.pll.vco_min, input_rate) * input_rate;
2269         c->min_rate = DIV_ROUND_UP(c->u.pll.vco_min, pllcx_p[PLLCX_PDIV_MAX]);
2270
2271         val = clk_readl(c->reg + PLL_BASE);
2272         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
2273
2274         /*
2275          * PLLCX is not a boot PLL, it should be left disabled by boot-loader,
2276          * and no enabled module clocks should use it as a source during clock
2277          * init.
2278          */
2279 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
2280         BUG_ON(c->state == ON);
2281 #endif
2282         /*
2283          * Most of PLLCX register fields are shadowed, and can not be read
2284          * directly from PLL h/w. Hence, actual PLLCX boot state is unknown.
2285          * Initialize PLL to default state: disabled, reset; shadow registers
2286          * loaded with default parameters; dividers are preset for half of
2287          * minimum VCO rate (the latter assured that shadowed divider settings
2288          * are within supported range).
2289          */
2290         m = PLL_FIXED_MDIV(c, input_rate);
2291         n = m * c->u.pll.vco_min / input_rate;
2292         p = pllcx_p[1];
2293         val = (m << PLL_BASE_DIVM_SHIFT) | (n << PLL_BASE_DIVN_SHIFT) |
2294                 (1 << PLL_BASE_DIVP_SHIFT);
2295         clk_writel(val, c->reg + PLL_BASE);     /* PLL disabled */
2296
2297         pllcx_set_defaults(c, input_rate, n);
2298
2299         c->mul = n;
2300         c->div = m * p;
2301 }
2302
2303 static int tegra11_pllcx_clk_enable(struct clk *c)
2304 {
2305         u32 val;
2306         pr_debug("%s on clock %s\n", __func__, c->name);
2307
2308         val = clk_readl(c->reg + PLL_BASE);
2309         val &= ~PLL_BASE_BYPASS;
2310         val |= PLL_BASE_ENABLE;
2311         pll_writel_delay(val, c->reg + PLL_BASE);
2312
2313         val = clk_readl(c->reg + PLL_MISC(c));
2314         val &= ~PLLCX_MISC_RESET;
2315         pll_writel_delay(val, c->reg + PLL_MISC(c));
2316
2317         pllcx_strobe(c);
2318         tegra11_pll_clk_wait_for_lock(c, c->reg + PLL_BASE,
2319                         PLL_BASE_LOCK | PLLCX_BASE_PHASE_LOCK);
2320         return 0;
2321 }
2322
2323 static void tegra11_pllcx_clk_disable(struct clk *c)
2324 {
2325         u32 val;
2326         pr_debug("%s on clock %s\n", __func__, c->name);
2327
2328         val = clk_readl(c->reg);
2329         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
2330         clk_writel(val, c->reg);
2331
2332         val = clk_readl(c->reg + PLL_MISC(c));
2333         val |= PLLCX_MISC_RESET;
2334         pll_writel_delay(val, c->reg + PLL_MISC(c));
2335 }
2336
2337 static int tegra11_pllcx_clk_set_rate(struct clk *c, unsigned long rate)
2338 {
2339         u32 val, pdiv;
2340         unsigned long input_rate;
2341         struct clk_pll_freq_table cfg, old_cfg;
2342         const struct clk_pll_freq_table *sel = &cfg;
2343
2344         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
2345
2346         input_rate = clk_get_rate(c->parent);
2347
2348         if (pll_dyn_ramp_find_cfg(c, &cfg, rate, input_rate, &pdiv))
2349                 return -EINVAL;
2350
2351         c->mul = sel->n;
2352         c->div = sel->m * sel->p;
2353
2354         val = clk_readl(c->reg + PLL_BASE);
2355         PLL_BASE_PARSE(PLLCX, old_cfg, val);
2356         old_cfg.p = pllcx_p[old_cfg.p];
2357
2358         BUG_ON(old_cfg.m != sel->m);
2359         if ((sel->n == old_cfg.n) && (sel->p == old_cfg.p))
2360                 return 0;
2361
2362 #if PLLCX_USE_DYN_RAMP
2363         if (c->state == ON && ((sel->n == old_cfg.n) ||
2364                                PLLCX_IS_DYN(sel->p, old_cfg.p))) {
2365                 /*
2366                  * Dynamic ramp if PLL is enabled, and M divider is unchanged:
2367                  * - Change P divider 1st if intermediate rate is below either
2368                  *   old or new rate.
2369                  * - Change N divider with DFS strobe - target rate is either
2370                  *   final new rate or below old rate
2371                  * - If divider has been changed, exit without waiting for lock.
2372                  *   Otherwise, wait for lock and change divider.
2373                  */
2374                 if (sel->p > old_cfg.p) {
2375                         val &= ~PLLCX_BASE_DIVP_MASK;
2376                         val |= pdiv << PLL_BASE_DIVP_SHIFT;
2377                         clk_writel(val, c->reg + PLL_BASE);
2378                 }
2379
2380                 if (sel->n != old_cfg.n) {
2381                         pllcx_update_dynamic_koef(c, input_rate, sel->n);
2382                         val &= ~PLLCX_BASE_DIVN_MASK;
2383                         val |= sel->n << PLL_BASE_DIVN_SHIFT;
2384                         pll_writel_delay(val, c->reg + PLL_BASE);
2385
2386                         pllcx_strobe(c);
2387                         tegra11_pll_clk_wait_for_lock(c, c->reg + PLL_BASE,
2388                                         PLL_BASE_LOCK | PLLCX_BASE_PHASE_LOCK);
2389                 }
2390
2391                 if (sel->p < old_cfg.p) {
2392                         val &= ~PLLCX_BASE_DIVP_MASK;
2393                         val |= pdiv << PLL_BASE_DIVP_SHIFT;
2394                         clk_writel(val, c->reg + PLL_BASE);
2395                 }
2396                 return 0;
2397         }
2398 #endif
2399
2400         val &= ~(PLLCX_BASE_DIVN_MASK | PLLCX_BASE_DIVP_MASK);
2401         val |= (sel->n << PLL_BASE_DIVN_SHIFT) |
2402                 (pdiv << PLL_BASE_DIVP_SHIFT);
2403
2404         if (c->state == ON) {
2405                 tegra11_pllcx_clk_disable(c);
2406                 val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
2407         }
2408         pllcx_update_dynamic_koef(c, input_rate, sel->n);
2409         clk_writel(val, c->reg + PLL_BASE);
2410         if (c->state == ON)
2411                 tegra11_pllcx_clk_enable(c);
2412
2413         return 0;
2414 }
2415
2416 #ifdef CONFIG_PM_SLEEP
2417 static void tegra11_pllcx_clk_resume_enable(struct clk *c)
2418 {
2419         unsigned long rate = clk_get_rate_all_locked(c->parent);
2420         u32 val = clk_readl(c->reg + PLL_BASE);
2421         enum clk_state state = c->state;
2422
2423         if (val & PLL_BASE_ENABLE)
2424                 return;         /* already resumed */
2425
2426         /* Restore input divider */
2427         val &= ~PLLCX_BASE_DIVM_MASK;
2428         val |= PLL_FIXED_MDIV(c, rate) << PLL_BASE_DIVM_SHIFT;
2429         clk_writel(val, c->reg + PLL_BASE);
2430
2431         /* temporarily sync h/w and s/w states, final sync happens
2432            in tegra_clk_resume later */
2433         c->state = OFF;
2434         pllcx_set_defaults(c, rate, c->mul);
2435
2436         rate = clk_get_rate_all_locked(c) + 1;
2437         tegra11_pllcx_clk_set_rate(c, rate);
2438         tegra11_pllcx_clk_enable(c);
2439         c->state = state;
2440 }
2441 #endif
2442
2443 static struct clk_ops tegra_pllcx_ops = {
2444         .init                   = tegra11_pllcx_clk_init,
2445         .enable                 = tegra11_pllcx_clk_enable,
2446         .disable                = tegra11_pllcx_clk_disable,
2447         .set_rate               = tegra11_pllcx_clk_set_rate,
2448 };
2449
2450
2451 /* non-monotonic mapping below is not a typo */
2452 static u8 pllxc_p[PLLXC_PDIV_MAX + 1] = {
2453 /* PDIV: 0, 1, 2, 3, 4, 5, 6,  7,  8,  9, 10, 11, 12, 13, 14 */
2454 /* p: */ 1, 2, 3, 4, 5, 6, 8, 10, 12, 16, 12, 16, 20, 24, 32 };
2455
2456 static u32 pllxc_round_p_to_pdiv(u32 p, u32 *pdiv)
2457 {
2458         if (!p || (p > PLLXC_SW_PDIV_MAX + 1))
2459                 return -EINVAL;
2460
2461         if (pdiv)
2462                 *pdiv = p - 1;
2463         return p;
2464 }
2465
2466 static void pllxc_get_dyn_steps(struct clk *c, unsigned long input_rate,
2467                                 u32 *step_a, u32 *step_b)
2468 {
2469         switch (input_rate) {
2470         case 12000000:
2471         case 13000000:
2472         case 26000000:
2473                 *step_a = 0x2B;
2474                 *step_b = 0x0B;
2475                 return;
2476         case 16800000:
2477                 *step_a = 0x1A;
2478                 *step_b = 0x09;
2479                 return;
2480         case 19200000:
2481                 *step_a = 0x12;
2482                 *step_b = 0x08;
2483                 return;
2484         default:
2485                 pr_err("%s: Unexpected reference rate %lu\n",
2486                         __func__, input_rate);
2487                 BUG();
2488         }
2489 }
2490
2491 static void pllx_set_defaults(struct clk *c, unsigned long input_rate)
2492 {
2493         u32 val;
2494         u32 step_a, step_b;
2495
2496         /* Only s/w dyn ramp control is supported */
2497         val = clk_readl(PLLX_HW_CTRL_CFG);
2498 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
2499         BUG_ON(!(val & PLLX_HW_CTRL_CFG_SWCTRL));
2500 #endif
2501
2502         pllxc_get_dyn_steps(c, input_rate, &step_a, &step_b);
2503         val = step_a << PLLX_MISC2_DYNRAMP_STEPA_SHIFT;
2504         val |= step_b << PLLX_MISC2_DYNRAMP_STEPB_SHIFT;
2505
2506         /* Get ready dyn ramp state machine, disable lock override */
2507         clk_writel(val, c->reg + PLL_MISCN(c, 2));
2508
2509         /* Enable outputs to CPUs and configure lock */
2510         val = 0;
2511 #if USE_PLL_LOCK_BITS
2512         val |= PLL_MISC_LOCK_ENABLE(c);
2513 #endif
2514         clk_writel(val, c->reg + PLL_MISC(c));
2515
2516         /* Check/set IDDQ */
2517         val = clk_readl(c->reg + PLL_MISCN(c, 3));
2518         if (c->state == ON) {
2519 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
2520                 BUG_ON(val & PLLX_MISC3_IDDQ);
2521 #endif
2522         } else {
2523                 val |= PLLX_MISC3_IDDQ;
2524                 clk_writel(val, c->reg + PLL_MISCN(c, 3));
2525         }
2526 }
2527
2528 static void pllc_set_defaults(struct clk *c, unsigned long input_rate)
2529 {
2530         u32 val;
2531         u32 step_a, step_b;
2532
2533         /* Get ready dyn ramp state machine */
2534         pllxc_get_dyn_steps(c, input_rate, &step_a, &step_b);
2535         val = step_a << PLLC_MISC1_DYNRAMP_STEPA_SHIFT;
2536         val |= step_b << PLLC_MISC1_DYNRAMP_STEPB_SHIFT;
2537         clk_writel(val, c->reg + PLL_MISCN(c, 1));
2538
2539         /* Configure lock and check/set IDDQ */
2540         val = clk_readl(c->reg + PLL_BASE);
2541         val &= ~PLLC_BASE_LOCK_OVERRIDE;
2542         clk_writel(val, c->reg + PLL_BASE);
2543
2544         val = clk_readl(c->reg + PLL_MISC(c));
2545 #if USE_PLL_LOCK_BITS
2546         val |= PLLC_MISC_LOCK_ENABLE;
2547 #else
2548         val &= ~PLLC_MISC_LOCK_ENABLE;
2549 #endif
2550         clk_writel(val, c->reg + PLL_MISC(c));
2551
2552         if (c->state == ON) {
2553 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
2554                 BUG_ON(val & PLLC_MISC_IDDQ);
2555 #endif
2556         } else {
2557                 val |= PLLC_MISC_IDDQ;
2558                 clk_writel(val, c->reg + PLL_MISC(c));
2559         }
2560 }
2561
2562 static void tegra11_pllxc_clk_init(struct clk *c)
2563 {
2564         unsigned long input_rate = clk_get_rate(c->parent);
2565         u32 m, p, val;
2566
2567         /* clip vco_min to exact multiple of input rate to avoid crossover
2568            by rounding */
2569         c->u.pll.vco_min =
2570                 DIV_ROUND_UP(c->u.pll.vco_min, input_rate) * input_rate;
2571         c->min_rate =
2572                 DIV_ROUND_UP(c->u.pll.vco_min, pllxc_p[PLLXC_SW_PDIV_MAX]);
2573
2574         val = clk_readl(c->reg + PLL_BASE);
2575         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
2576
2577         m = (val & PLLXC_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
2578         p = (val & PLLXC_BASE_DIVP_MASK) >> PLL_BASE_DIVP_SHIFT;
2579         BUG_ON(p > PLLXC_PDIV_MAX);
2580         p = pllxc_p[p];
2581
2582         c->div = m * p;
2583         c->mul = (val & PLLXC_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
2584
2585         if (c->flags & PLLX)
2586                 pllx_set_defaults(c, input_rate);
2587         else
2588                 pllc_set_defaults(c, input_rate);
2589 }
2590
2591 static int tegra11_pllxc_clk_enable(struct clk *c)
2592 {
2593         u32 val;
2594         pr_debug("%s on clock %s\n", __func__, c->name);
2595
2596         if (c->flags & PLLX)
2597                 pll_do_iddq(c, PLL_MISCN(c, 3), PLLX_MISC3_IDDQ, false);
2598         else
2599                 pll_do_iddq(c, PLL_MISC(c), PLLC_MISC_IDDQ, false);
2600
2601         val = clk_readl(c->reg + PLL_BASE);
2602         val |= PLL_BASE_ENABLE;
2603         clk_writel(val, c->reg + PLL_BASE);
2604
2605         tegra11_pll_clk_wait_for_lock(c, c->reg + PLL_BASE, PLL_BASE_LOCK);
2606
2607         return 0;
2608 }
2609
2610 static void tegra11_pllxc_clk_disable(struct clk *c)
2611 {
2612         u32 val;
2613         pr_debug("%s on clock %s\n", __func__, c->name);
2614
2615         val = clk_readl(c->reg + PLL_BASE);
2616         val &= ~PLL_BASE_ENABLE;
2617         clk_writel(val, c->reg + PLL_BASE);
2618
2619         if (c->flags & PLLX)
2620                 pll_do_iddq(c, PLL_MISCN(c, 3), PLLX_MISC3_IDDQ, true);
2621         else
2622                 pll_do_iddq(c, PLL_MISC(c), PLLC_MISC_IDDQ, true);
2623
2624 }
2625
2626 #define PLLXC_DYN_RAMP(pll_misc, reg)                                   \
2627         do {                                                            \
2628                 u32 misc = clk_readl((reg));                            \
2629                                                                         \
2630                 misc &= ~pll_misc##_NDIV_NEW_MASK;                      \
2631                 misc |= sel->n << pll_misc##_NDIV_NEW_SHIFT;            \
2632                 pll_writel_delay(misc, (reg));                          \
2633                                                                         \
2634                 misc |= pll_misc##_EN_DYNRAMP;                          \
2635                 clk_writel(misc, (reg));                                \
2636                 tegra11_pll_clk_wait_for_lock(c, (reg),                 \
2637                                         pll_misc##_DYNRAMP_DONE);       \
2638                                                                         \
2639                 val &= ~PLLXC_BASE_DIVN_MASK;                           \
2640                 val |= sel->n << PLL_BASE_DIVN_SHIFT;                   \
2641                 pll_writel_delay(val, c->reg + PLL_BASE);               \
2642                                                                         \
2643                 misc &= ~pll_misc##_EN_DYNRAMP;                         \
2644                 pll_writel_delay(misc, (reg));                          \
2645         } while (0)
2646
2647 static int tegra11_pllxc_clk_set_rate(struct clk *c, unsigned long rate)
2648 {
2649         u32 val, pdiv;
2650         unsigned long input_rate;
2651         struct clk_pll_freq_table cfg, old_cfg;
2652         const struct clk_pll_freq_table *sel = &cfg;
2653
2654         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
2655
2656         input_rate = clk_get_rate(c->parent);
2657
2658         if (pll_dyn_ramp_find_cfg(c, &cfg, rate, input_rate, &pdiv))
2659                 return -EINVAL;
2660
2661         c->mul = sel->n;
2662         c->div = sel->m * sel->p;
2663
2664         val = clk_readl(c->reg + PLL_BASE);
2665         PLL_BASE_PARSE(PLLXC, old_cfg, val);
2666         old_cfg.p = pllxc_p[old_cfg.p];
2667
2668         if ((sel->m == old_cfg.m) && (sel->n == old_cfg.n) &&
2669             (sel->p == old_cfg.p))
2670                 return 0;
2671
2672 #if PLLXC_USE_DYN_RAMP
2673         /*
2674          * Dynamic ramp can be used if M, P dividers are unchanged
2675          * (coveres superset of conventional dynamic ramps)
2676          */
2677         if ((c->state == ON) && (sel->m == old_cfg.m) &&
2678             (sel->p == old_cfg.p)) {
2679
2680                 if (c->flags & PLLX) {
2681                         u32 reg = c->reg + PLL_MISCN(c, 2);
2682                         PLLXC_DYN_RAMP(PLLX_MISC2, reg);
2683                 } else {
2684                         u32 reg = c->reg + PLL_MISCN(c, 1);
2685                         PLLXC_DYN_RAMP(PLLC_MISC1, reg);
2686                 }
2687
2688                 return 0;
2689         }
2690 #endif
2691         if (c->state == ON) {
2692                 /* Use "ENABLE" pulse without placing PLL into IDDQ */
2693                 val &= ~PLL_BASE_ENABLE;
2694                 pll_writel_delay(val, c->reg + PLL_BASE);
2695         }
2696
2697         val &= ~(PLLXC_BASE_DIVM_MASK |
2698                  PLLXC_BASE_DIVN_MASK | PLLXC_BASE_DIVP_MASK);
2699         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
2700                 (sel->n << PLL_BASE_DIVN_SHIFT) | (pdiv << PLL_BASE_DIVP_SHIFT);
2701         clk_writel(val, c->reg + PLL_BASE);
2702
2703         if (c->state == ON) {
2704                 val |= PLL_BASE_ENABLE;
2705                 clk_writel(val, c->reg + PLL_BASE);
2706                 tegra11_pll_clk_wait_for_lock(c, c->reg + PLL_BASE,
2707                                               PLL_BASE_LOCK);
2708         }
2709         return 0;
2710 }
2711
2712 #ifdef CONFIG_PM_SLEEP
2713 static void tegra11_pllxc_clk_resume_enable(struct clk *c)
2714 {
2715         unsigned long rate = clk_get_rate_all_locked(c->parent);
2716         enum clk_state state = c->state;
2717
2718         if (clk_readl(c->reg + PLL_BASE) & PLL_BASE_ENABLE)
2719                 return;         /* already resumed */
2720
2721         /* temporarily sync h/w and s/w states, final sync happens
2722            in tegra_clk_resume later */
2723         c->state = OFF;
2724         if (c->flags & PLLX)
2725                 pllx_set_defaults(c, rate);
2726         else
2727                 pllc_set_defaults(c, rate);
2728
2729         rate = clk_get_rate_all_locked(c) + 1;
2730         tegra11_pllxc_clk_set_rate(c, rate);
2731         tegra11_pllxc_clk_enable(c);
2732         c->state = state;
2733 }
2734 #endif
2735
2736 static struct clk_ops tegra_pllxc_ops = {
2737         .init                   = tegra11_pllxc_clk_init,
2738         .enable                 = tegra11_pllxc_clk_enable,
2739         .disable                = tegra11_pllxc_clk_disable,
2740         .set_rate               = tegra11_pllxc_clk_set_rate,
2741 };
2742
2743
2744 /* FIXME: pllm suspend/resume */
2745
2746 static u32 pllm_round_p_to_pdiv(u32 p, u32 *pdiv)
2747 {
2748         if (!p || (p > 2))
2749                 return -EINVAL;
2750
2751         if (pdiv)
2752                 *pdiv = p - 1;
2753         return p;
2754 }
2755
2756 static void pllm_set_defaults(struct clk *c, unsigned long input_rate)
2757 {
2758         u32 val = clk_readl(c->reg + PLL_MISC(c));
2759
2760         val &= ~PLLM_MISC_LOCK_OVERRIDE;
2761 #if USE_PLL_LOCK_BITS
2762         val &= ~PLLM_MISC_LOCK_DISABLE;
2763 #else
2764         val |= PLLM_MISC_LOCK_DISABLE;
2765 #endif
2766
2767         if (c->state != ON)
2768                 val |= PLLM_MISC_IDDQ;
2769 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
2770         else
2771                 BUG_ON(val & PLLM_MISC_IDDQ);
2772 #endif
2773
2774         clk_writel(val, c->reg + PLL_MISC(c));
2775 }
2776
2777 static void tegra11_pllm_clk_init(struct clk *c)
2778 {
2779         unsigned long input_rate = clk_get_rate(c->parent);
2780         u32 m, p, val;
2781
2782         /* clip vco_min to exact multiple of input rate to avoid crossover
2783            by rounding */
2784         c->u.pll.vco_min =
2785                 DIV_ROUND_UP(c->u.pll.vco_min, input_rate) * input_rate;
2786         c->min_rate =
2787                 DIV_ROUND_UP(c->u.pll.vco_min, 2);
2788
2789         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2790         if (val & PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE) {
2791                 c->state = (val & PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE) ? ON : OFF;
2792                 val = pmc_readl(PMC_PLLM_WB0_OVERRIDE_2);
2793                 p = (val & PMC_PLLM_WB0_OVERRIDE_2_DIVP_MASK) ? 2 : 1;
2794
2795                 val = pmc_readl(PMC_PLLM_WB0_OVERRIDE);
2796         } else {
2797                 val = clk_readl(c->reg + PLL_BASE);
2798                 c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
2799                 p = (val & PLLM_BASE_DIVP_MASK) ? 2 : 1;
2800         }
2801
2802         m = (val & PLLM_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
2803         BUG_ON(m != PLL_FIXED_MDIV(c, input_rate));
2804         c->div = m * p;
2805         c->mul = (val & PLLM_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
2806
2807         pllm_set_defaults(c, input_rate);
2808 }
2809
2810 static int tegra11_pllm_clk_enable(struct clk *c)
2811 {
2812         u32 val;
2813         pr_debug("%s on clock %s\n", __func__, c->name);
2814
2815         pll_do_iddq(c, PLL_MISC(c), PLLM_MISC_IDDQ, false);
2816
2817         /* Just enable both base and override - one would work */
2818         val = clk_readl(c->reg + PLL_BASE);
2819         val |= PLL_BASE_ENABLE;
2820         clk_writel(val, c->reg + PLL_BASE);
2821
2822         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2823         val |= PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE;
2824         pmc_writel(val, PMC_PLLP_WB0_OVERRIDE);
2825         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2826
2827         tegra11_pll_clk_wait_for_lock(c, c->reg + PLL_BASE, PLL_BASE_LOCK);
2828         return 0;
2829 }
2830
2831 static void tegra11_pllm_clk_disable(struct clk *c)
2832 {
2833         u32 val;
2834         pr_debug("%s on clock %s\n", __func__, c->name);
2835
2836         /* Just disable both base and override - one would work */
2837         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2838         val &= ~PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE;
2839         pmc_writel(val, PMC_PLLP_WB0_OVERRIDE);
2840         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2841
2842         val = clk_readl(c->reg + PLL_BASE);
2843         val &= ~PLL_BASE_ENABLE;
2844         clk_writel(val, c->reg + PLL_BASE);
2845
2846         pll_do_iddq(c, PLL_MISC(c), PLLM_MISC_IDDQ, true);
2847 }
2848
2849 static int tegra11_pllm_clk_set_rate(struct clk *c, unsigned long rate)
2850 {
2851         u32 val, pdiv;
2852         unsigned long input_rate;
2853         struct clk_pll_freq_table cfg;
2854         const struct clk_pll_freq_table *sel = &cfg;
2855
2856         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
2857
2858         if (c->state == ON) {
2859                 if (rate != clk_get_rate_locked(c)) {
2860                         pr_err("%s: Can not change memory %s rate in flight\n",
2861                                __func__, c->name);
2862                         return -EINVAL;
2863                 }
2864                 return 0;
2865         }
2866
2867         input_rate = clk_get_rate(c->parent);
2868
2869         if (pll_dyn_ramp_find_cfg(c, &cfg, rate, input_rate, &pdiv))
2870                 return -EINVAL;
2871
2872         c->mul = sel->n;
2873         c->div = sel->m * sel->p;
2874
2875         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2876         if (val & PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE) {
2877                 val = pmc_readl(PMC_PLLM_WB0_OVERRIDE_2);
2878                 val = pdiv ? (val | PMC_PLLM_WB0_OVERRIDE_2_DIVP_MASK) :
2879                         (val & ~PMC_PLLM_WB0_OVERRIDE_2_DIVP_MASK);
2880                 pmc_writel(val, PMC_PLLM_WB0_OVERRIDE_2);
2881
2882                 val = pmc_readl(PMC_PLLM_WB0_OVERRIDE);
2883                 val &= ~(PLLM_BASE_DIVM_MASK | PLLM_BASE_DIVN_MASK);
2884                 val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
2885                         (sel->n << PLL_BASE_DIVN_SHIFT);
2886                 pmc_writel(val, PMC_PLLM_WB0_OVERRIDE);
2887         } else {
2888                 val = clk_readl(c->reg + PLL_BASE);
2889                 val &= ~(PLLM_BASE_DIVM_MASK | PLLM_BASE_DIVN_MASK |
2890                          PLLM_BASE_DIVP_MASK);
2891                 val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
2892                         (sel->n << PLL_BASE_DIVN_SHIFT) |
2893                         (pdiv ? PLLM_BASE_DIVP_MASK : 0);
2894                 clk_writel(val, c->reg + PLL_BASE);
2895         }
2896
2897         return 0;
2898 }
2899
2900 static struct clk_ops tegra_pllm_ops = {
2901         .init                   = tegra11_pllm_clk_init,
2902         .enable                 = tegra11_pllm_clk_enable,
2903         .disable                = tegra11_pllm_clk_disable,
2904         .set_rate               = tegra11_pllm_clk_set_rate,
2905 };
2906
2907
2908 /* FIXME: pllre suspend/resume */
2909 /* non-monotonic mapping below is not a typo */
2910 static u8 pllre_p[PLLRE_PDIV_MAX + 1] = {
2911 /* PDIV: 0, 1, 2, 3, 4, 5, 6,  7,  8,  9, 10, 11, 12, 13, 14 */
2912 /* p: */ 1, 2, 3, 4, 5, 6, 8, 10, 12, 16, 12, 16, 20, 24, 32 };
2913
2914 static u32 pllre_round_p_to_pdiv(u32 p, u32 *pdiv)
2915 {
2916         if (!p || (p > PLLRE_SW_PDIV_MAX + 1))
2917                 return -EINVAL;
2918
2919         if (pdiv)
2920                 *pdiv = p - 1;
2921         return p;
2922 }
2923
2924 static void pllre_set_defaults(struct clk *c, unsigned long input_rate)
2925 {
2926         u32 val = clk_readl(c->reg + PLL_MISC(c));
2927
2928         val &= ~PLLRE_MISC_LOCK_OVERRIDE;
2929 #if USE_PLL_LOCK_BITS
2930         val |= PLLRE_MISC_LOCK_ENABLE;
2931 #else
2932         val &= ~PLLRE_MISC_LOCK_ENABLE;
2933 #endif
2934
2935         if (c->state != ON)
2936                 val |= PLLRE_MISC_IDDQ;
2937 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
2938         else
2939                 BUG_ON(val & PLLRE_MISC_IDDQ);
2940 #endif
2941
2942         clk_writel(val, c->reg + PLL_MISC(c));
2943 }
2944
2945 static void tegra11_pllre_clk_init(struct clk *c)
2946 {
2947         unsigned long input_rate = clk_get_rate(c->parent);
2948         u32 m, val;
2949
2950         /* clip vco_min to exact multiple of input rate to avoid crossover
2951            by rounding */
2952         c->u.pll.vco_min =
2953                 DIV_ROUND_UP(c->u.pll.vco_min, input_rate) * input_rate;
2954         c->min_rate = c->u.pll.vco_min;
2955
2956         val = clk_readl(c->reg + PLL_BASE);
2957         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
2958
2959         if (!val) {
2960                 /* overwrite h/w por state with min setting */
2961                 m = PLL_FIXED_MDIV(c, input_rate);
2962                 val = (m << PLL_BASE_DIVM_SHIFT) |
2963                         (c->min_rate / input_rate << PLL_BASE_DIVN_SHIFT);
2964                 clk_writel(val, c->reg + PLL_BASE);
2965         }
2966
2967         m = (val & PLLRE_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
2968         BUG_ON(m != PLL_FIXED_MDIV(c, input_rate));
2969
2970         c->div = m;
2971         c->mul = (val & PLLRE_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
2972
2973         pllre_set_defaults(c, input_rate);
2974 }
2975
2976 static int tegra11_pllre_clk_enable(struct clk *c)
2977 {
2978         u32 val;
2979         pr_debug("%s on clock %s\n", __func__, c->name);
2980
2981         pll_do_iddq(c, PLL_MISC(c), PLLRE_MISC_IDDQ, false);
2982
2983         val = clk_readl(c->reg + PLL_BASE);
2984         val |= PLL_BASE_ENABLE;
2985         clk_writel(val, c->reg + PLL_BASE);
2986
2987         tegra11_pll_clk_wait_for_lock(c, c->reg + PLL_MISC(c), PLLRE_MISC_LOCK);
2988         return 0;
2989 }
2990
2991 static void tegra11_pllre_clk_disable(struct clk *c)
2992 {
2993         u32 val;
2994         pr_debug("%s on clock %s\n", __func__, c->name);
2995
2996         val = clk_readl(c->reg + PLL_BASE);
2997         val &= ~PLL_BASE_ENABLE;
2998         clk_writel(val, c->reg + PLL_BASE);
2999
3000         pll_do_iddq(c, PLL_MISC(c), PLLRE_MISC_IDDQ, true);
3001 }
3002
3003 static int tegra11_pllre_clk_set_rate(struct clk *c, unsigned long rate)
3004 {
3005         u32 val, old_base;
3006         unsigned long input_rate;
3007         struct clk_pll_freq_table cfg;
3008
3009         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3010
3011         if (rate < c->min_rate) {
3012                 pr_err("%s: Failed to set %s rate %lu\n",
3013                        __func__, c->name, rate);
3014                 return -EINVAL;
3015         }
3016
3017         input_rate = clk_get_rate(c->parent);
3018         cfg.m = PLL_FIXED_MDIV(c, input_rate);
3019         cfg.n = rate * cfg.m / input_rate;
3020
3021         c->mul = cfg.n;
3022         c->div = cfg.m;
3023
3024         val = old_base = clk_readl(c->reg + PLL_BASE);
3025         val &= ~(PLLRE_BASE_DIVM_MASK | PLLRE_BASE_DIVN_MASK);
3026         val |= (cfg.m << PLL_BASE_DIVM_SHIFT) | (cfg.n << PLL_BASE_DIVN_SHIFT);
3027         if (val == old_base)
3028                 return 0;
3029
3030         if (c->state == ON) {
3031                 /* Use "ENABLE" pulse without placing PLL into IDDQ */
3032                 val &= ~PLL_BASE_ENABLE;
3033                 old_base &= ~PLL_BASE_ENABLE;
3034                 pll_writel_delay(old_base, c->reg + PLL_BASE);
3035         }
3036
3037         clk_writel(val, c->reg + PLL_BASE);
3038
3039         if (c->state == ON) {
3040                 val |= PLL_BASE_ENABLE;
3041                 clk_writel(val, c->reg + PLL_BASE);
3042                 tegra11_pll_clk_wait_for_lock(
3043                         c, c->reg + PLL_MISC(c), PLLRE_MISC_LOCK);
3044         }
3045         return 0;
3046 }
3047
3048 static struct clk_ops tegra_pllre_ops = {
3049         .init                   = tegra11_pllre_clk_init,
3050         .enable                 = tegra11_pllre_clk_enable,
3051         .disable                = tegra11_pllre_clk_disable,
3052         .set_rate               = tegra11_pllre_clk_set_rate,
3053 };
3054
3055 static void tegra11_pllre_out_clk_init(struct clk *c)
3056 {
3057         u32 p, val;
3058
3059         val = clk_readl(c->reg);
3060         p = (val & PLLRE_BASE_DIVP_MASK) >> PLLRE_BASE_DIVP_SHIFT;
3061         BUG_ON(p > PLLRE_PDIV_MAX);
3062         p = pllre_p[p];
3063
3064         c->div = p;
3065         c->mul = 1;
3066         c->state = c->parent->state;
3067 }
3068
3069 static int tegra11_pllre_out_clk_enable(struct clk *c)
3070 {
3071         return 0;
3072 }
3073
3074 static void tegra11_pllre_out_clk_disable(struct clk *c)
3075 {
3076 }
3077
3078 static int tegra11_pllre_out_clk_set_rate(struct clk *c, unsigned long rate)
3079 {
3080         u32 val, p, pdiv;
3081         unsigned long input_rate, flags;
3082
3083         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3084
3085         clk_lock_save(c->parent, &flags);
3086         input_rate = clk_get_rate_locked(c->parent);
3087
3088         p = DIV_ROUND_UP(input_rate, rate);
3089         p = c->parent->u.pll.round_p_to_pdiv(p, &pdiv);
3090         if (IS_ERR_VALUE(p)) {
3091                 pr_err("%s: Failed to set %s rate %lu\n",
3092                        __func__, c->name, rate);
3093                 clk_unlock_restore(c->parent, &flags);
3094                 return -EINVAL;
3095         }
3096         c->div = p;
3097
3098         val = clk_readl(c->reg);
3099         val &= ~PLLRE_BASE_DIVP_MASK;
3100         val |= pdiv << PLLRE_BASE_DIVP_SHIFT;
3101         clk_writel(val, c->reg);
3102
3103         clk_unlock_restore(c->parent, &flags);
3104         return 0;
3105 }
3106
3107 static struct clk_ops tegra_pllre_out_ops = {
3108         .init                   = tegra11_pllre_out_clk_init,
3109         .enable                 = tegra11_pllre_out_clk_enable,
3110         .disable                = tegra11_pllre_out_clk_disable,
3111         .set_rate               = tegra11_pllre_out_clk_set_rate,
3112 };
3113
3114 /* FIXME: plle suspend/resume */
3115 /* non-monotonic mapping below is not a typo */
3116 static u8 plle_p[PLLE_CMLDIV_MAX + 1] = {
3117 /* CMLDIV: 0, 1, 2, 3, 4, 5, 6,  7,  8,  9, 10, 11, 12, 13, 14 */
3118 /* p: */   1, 2, 3, 4, 5, 6, 8, 10, 12, 16, 12, 16, 20, 24, 32 };
3119
3120 static void tegra11_plle_clk_init(struct clk *c)
3121 {
3122         u32 val, p;
3123         struct clk *ref = tegra_get_clock_by_name("pll_re_vco");
3124
3125         val = clk_readl(c->reg + PLL_BASE);
3126         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
3127         c->mul = (val & PLLE_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
3128         c->div = (val & PLLE_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
3129         p = (val & PLLE_BASE_DIVCML_MASK) >> PLLE_BASE_DIVCML_SHIFT;
3130         c->div *= plle_p[p];
3131
3132         val = clk_readl(PLLE_AUX);
3133         c->parent = (val & PLLE_AUX_PLLRE_SEL) ? ref :
3134                         (val & PLLE_AUX_PLLP_SEL) ?
3135                                 tegra_get_clock_by_name("pll_p") :
3136                                 tegra_get_clock_by_name("pll_ref");
3137         if (c->parent != ref) {
3138                 if (c->state == ON) {
3139                         WARN(1, "%s: pll_e is left enabled with %s input\n",
3140                              __func__, c->parent->name);
3141                 } else {
3142                         c->parent = ref;
3143                         val |= PLLE_AUX_PLLRE_SEL;
3144                         clk_writel(val, PLLE_AUX);
3145                 }
3146         }
3147 }
3148
3149 static void tegra11_plle_clk_disable(struct clk *c)
3150 {
3151         u32 val;
3152         pr_debug("%s on clock %s\n", __func__, c->name);
3153
3154         /* FIXME: do we need to restore other s/w controls ? */
3155         val = clk_readl(c->reg + PLL_BASE);
3156         val &= ~PLL_BASE_ENABLE;
3157         clk_writel(val, c->reg + PLL_BASE);
3158
3159         val = clk_readl(c->reg + PLL_MISC(c));
3160         val |= PLLE_MISC_IDDQ_SW_CTRL | PLLE_MISC_IDDQ_SW_VALUE;
3161         pll_writel_delay(val, c->reg + PLL_MISC(c));
3162 }
3163
3164 static int tegra11_plle_clk_enable(struct clk *c)
3165 {
3166         u32 val;
3167         const struct clk_pll_freq_table *sel;
3168         unsigned long rate = c->u.pll.fixed_rate;
3169         unsigned long input_rate = clk_get_rate(c->parent);
3170
3171         if (c->state == ON) {
3172                 /* BL left plle enabled - don't change configuartion */
3173                 pr_warn("%s: pll_e is already enabled\n", __func__);
3174                 return 0;
3175         }
3176
3177         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
3178                 if (sel->input_rate == input_rate && sel->output_rate == rate)
3179                         break;
3180         }
3181
3182         if (sel->input_rate == 0) {
3183                 pr_err("%s: %s input rate %lu is out-of-table\n",
3184                        __func__, c->name, input_rate);
3185                 return -EINVAL;
3186         }
3187
3188         /* setup locking configuration, s/w control of IDDQ and enable modes,
3189            take pll out of IDDQ via s/w control, setup VREG */
3190         val = clk_readl(c->reg + PLL_BASE);
3191         val &= ~PLLE_BASE_LOCK_OVERRIDE;
3192         clk_writel(val, c->reg + PLL_BASE);
3193
3194         val = clk_readl(PLLE_AUX);
3195         val |= PLLE_AUX_ENABLE_SWCTL;
3196         val &= ~PLLE_AUX_SEQ_ENABLE;
3197         pll_writel_delay(val, PLLE_AUX);
3198
3199         val = clk_readl(c->reg + PLL_MISC(c));
3200         val |= PLLE_MISC_LOCK_ENABLE;
3201         val |= PLLE_MISC_IDDQ_SW_CTRL;
3202         val &= ~PLLE_MISC_IDDQ_SW_VALUE;
3203         val |= PLLE_MISC_PLLE_PTS;
3204         val |= PLLE_MISC_VREG_BG_CTRL_MASK | PLLE_MISC_VREG_CTRL_MASK;
3205         clk_writel(val, c->reg + PLL_MISC(c));
3206         udelay(5);
3207
3208         /* configure dividers, disable SS */
3209         val = clk_readl(PLLE_SS_CTRL);
3210         val |= PLLE_SS_DISABLE;
3211         clk_writel(val, PLLE_SS_CTRL);
3212
3213         val = clk_readl(c->reg + PLL_BASE);
3214         val &= ~(PLLE_BASE_DIVM_MASK | PLLE_BASE_DIVN_MASK |
3215                  PLLE_BASE_DIVCML_MASK);
3216         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
3217                 (sel->n << PLL_BASE_DIVN_SHIFT) |
3218                 (sel->cpcon << PLLE_BASE_DIVCML_SHIFT);
3219         pll_writel_delay(val, c->reg + PLL_BASE);
3220         c->mul = sel->n;
3221         c->div = sel->m * sel->p;
3222
3223         /* enable and lock pll */
3224         val |= PLL_BASE_ENABLE;
3225         clk_writel(val, c->reg + PLL_BASE);
3226         tegra11_pll_clk_wait_for_lock(
3227                 c, c->reg + PLL_MISC(c), PLLE_MISC_LOCK);
3228 #if USE_PLLE_SS
3229         /* FIXME: enable SS if necessary */
3230 #endif
3231 #if !USE_PLLE_SWCTL
3232         /* switch pll under h/w control */
3233         val = clk_readl(c->reg + PLL_MISC(c));
3234         val &= ~PLLE_MISC_IDDQ_SW_CTRL;
3235         clk_writel(val, c->reg + PLL_MISC(c));
3236
3237         val = clk_readl(PLLE_AUX);
3238         val |= PLLE_AUX_USE_LOCKDET;
3239         val &= ~PLLE_AUX_ENABLE_SWCTL;
3240         pll_writel_delay(val, PLLE_AUX);
3241         val |= PLLE_AUX_SEQ_ENABLE;
3242         pll_writel_delay(val, PLLE_AUX);
3243 #endif
3244         /* enable hw control of xusb brick pll */
3245         usb_plls_hw_control_enable(XUSBIO_PLL_CFG0);
3246
3247         return 0;
3248 }
3249
3250 static struct clk_ops tegra_plle_ops = {
3251         .init                   = tegra11_plle_clk_init,
3252         .enable                 = tegra11_plle_clk_enable,
3253         .disable                = tegra11_plle_clk_disable,
3254 };
3255
3256 /*
3257  * Tegra11 includes dynamic frequency lock loop (DFLL) with automatic voltage
3258  * control as possible CPU clock source. It is included in the Tegra11 clock
3259  * tree as "complex PLL" with standard Tegra clock framework APIs. However,
3260  * DFLL locking logic h/w access APIs are separated in the tegra_cl_dvfs.c
3261  * module. Hence, DFLL operations, with the exception of initialization, are
3262  * basically cl-dvfs wrappers.
3263  */
3264
3265 /* DFLL operations */
3266 static void __init tegra11_dfll_cpu_late_init(struct clk *c)
3267 {
3268         int ret;
3269         struct clk *cpu = tegra_get_clock_by_name("cpu");
3270
3271 #ifndef CONFIG_TEGRA_SILICON_PLATFORM
3272         u32 netlist, patchid;
3273         tegra_get_netlist_revision(&netlist, &patchid);
3274         if (netlist < 12) {
3275                 pr_err("%s: CL-DVFS is not available on net %d\n",
3276                        __func__, netlist);
3277                 return;
3278         }
3279 #endif
3280         /* release dfll clock source reset, init cl_dvfs control logic, and
3281            move dfll to initialized state, so it can be used as CPU source */
3282         tegra_periph_reset_deassert(c);
3283         ret = tegra_init_cl_dvfs();
3284         if (!ret) {
3285                 c->state = OFF;
3286                 c->u.dfll.cl_dvfs = platform_get_drvdata(&tegra_cl_dvfs_device);
3287                 pr_info("Tegra CPU DFLL is initialized\n");
3288
3289 #ifdef CONFIG_TEGRA_USE_DFLL
3290                 use_dfll = DFLL_RANGE_ALL_RATES;
3291 #endif
3292                 tegra_dvfs_set_dfll_range(cpu->parent->dvfs, use_dfll);
3293         }
3294 }
3295
3296 static int tegra11_dfll_clk_enable(struct clk *c)
3297 {
3298         return tegra_cl_dvfs_enable(c->u.dfll.cl_dvfs);
3299 }
3300
3301 static void tegra11_dfll_clk_disable(struct clk *c)
3302 {
3303         tegra_cl_dvfs_disable(c->u.dfll.cl_dvfs);
3304 }
3305
3306 static int tegra11_dfll_clk_set_rate(struct clk *c, unsigned long rate)
3307 {
3308         int ret = tegra_cl_dvfs_request_rate(c->u.dfll.cl_dvfs, rate);
3309
3310         if (!ret)
3311                 c->rate = tegra_cl_dvfs_request_get(c->u.dfll.cl_dvfs);
3312
3313         return ret;
3314 }
3315
3316 static void tegra11_dfll_clk_reset(struct clk *c, bool assert)
3317 {
3318         u32 val = assert ? DFLL_BASE_RESET : 0;
3319         clk_writel_delay(val, c->reg);
3320 }
3321
3322 static int
3323 tegra11_dfll_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
3324 {
3325         if (p == TEGRA_CLK_DFLL_LOCK)
3326                 return setting ? tegra_cl_dvfs_lock(c->u.dfll.cl_dvfs) :
3327                                  tegra_cl_dvfs_unlock(c->u.dfll.cl_dvfs);
3328         return -EINVAL;
3329 }
3330
3331 #ifdef CONFIG_PM_SLEEP
3332 static void tegra11_dfll_clk_resume(struct clk *c)
3333 {
3334         if (!(clk_readl(c->reg) & DFLL_BASE_RESET))
3335                 return;         /* already resumed */
3336
3337         tegra_periph_reset_deassert(c);
3338         tegra_cl_dvfs_resume(c->u.dfll.cl_dvfs);
3339 }
3340 #endif
3341
3342 static struct clk_ops tegra_dfll_ops = {
3343         .enable                 = tegra11_dfll_clk_enable,
3344         .disable                = tegra11_dfll_clk_disable,
3345         .set_rate               = tegra11_dfll_clk_set_rate,
3346         .reset                  = tegra11_dfll_clk_reset,
3347         .clk_cfg_ex             = tegra11_dfll_clk_cfg_ex,
3348 };
3349
3350 /* DFLL sysfs interface */
3351 static int tegra11_use_dfll_cb(const char *arg, const struct kernel_param *kp)
3352 {
3353         int ret = 0;
3354         unsigned long c_flags, p_flags;
3355         unsigned int old_use_dfll;
3356         struct clk *c = tegra_get_clock_by_name("cpu");
3357
3358         if (!c->parent || !c->parent->dvfs)
3359                 return -ENOSYS;
3360
3361         clk_lock_save(c, &c_flags);
3362         if (c->parent->u.cpu.mode == MODE_LP) {
3363                 pr_err("%s: DFLL is not used on LP CPU\n", __func__);
3364                 clk_unlock_restore(c, &c_flags);
3365                 return -ENOSYS;
3366         }
3367
3368         clk_lock_save(c->parent, &p_flags);
3369         old_use_dfll = use_dfll;
3370         param_set_int(arg, kp);
3371
3372         if (use_dfll != old_use_dfll) {
3373                 ret = tegra_dvfs_set_dfll_range(c->parent->dvfs, use_dfll);
3374                 if (ret) {
3375                         use_dfll = old_use_dfll;
3376                 } else {
3377                         ret = clk_set_rate_locked(c->parent,
3378                                 clk_get_rate_locked(c->parent));
3379                         if (ret) {
3380                                 use_dfll = old_use_dfll;
3381                                 tegra_dvfs_set_dfll_range(
3382                                         c->parent->dvfs, use_dfll);
3383                         }
3384                 }
3385         }
3386         clk_unlock_restore(c->parent, &p_flags);
3387         clk_unlock_restore(c, &c_flags);
3388         return ret;
3389 }
3390
3391 static struct kernel_param_ops tegra11_use_dfll_ops = {
3392         .set = tegra11_use_dfll_cb,
3393         .get = param_get_int,
3394 };
3395 module_param_cb(use_dfll, &tegra11_use_dfll_ops, &use_dfll, 0644);
3396
3397
3398 /* Clock divider ops (non-atomic shared register access) */
3399 static DEFINE_SPINLOCK(pll_div_lock);
3400
3401 static int tegra11_pll_div_clk_set_rate(struct clk *c, unsigned long rate);
3402 static void tegra11_pll_div_clk_init(struct clk *c)
3403 {
3404         if (c->flags & DIV_U71) {
3405                 u32 divu71;
3406                 u32 val = clk_readl(c->reg);
3407                 val >>= c->reg_shift;
3408                 c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
3409                 if (!(val & PLL_OUT_RESET_DISABLE))
3410                         c->state = OFF;
3411
3412                 if (c->u.pll_div.default_rate) {
3413                         int ret = tegra11_pll_div_clk_set_rate(
3414                                         c, c->u.pll_div.default_rate);
3415                         if (!ret)
3416                                 return;
3417                 }
3418                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
3419                 c->div = (divu71 + 2);
3420                 c->mul = 2;
3421         } else if (c->flags & DIV_2) {
3422                 c->state = ON;
3423                 if (c->flags & (PLLD | PLLX)) {
3424                         c->div = 2;
3425                         c->mul = 1;
3426                 }
3427                 else
3428                         BUG();
3429         } else if (c->flags & PLLU) {
3430                 u32 val = clk_readl(c->reg);
3431                 c->state = val & (0x1 << c->reg_shift) ? ON : OFF;
3432         } else {
3433                 c->state = ON;
3434                 c->div = 1;
3435                 c->mul = 1;
3436         }
3437 }
3438
3439 static int tegra11_pll_div_clk_enable(struct clk *c)
3440 {
3441         u32 val;
3442         u32 new_val;
3443         unsigned long flags;
3444
3445         pr_debug("%s: %s\n", __func__, c->name);
3446         if (c->flags & DIV_U71) {
3447                 spin_lock_irqsave(&pll_div_lock, flags);
3448                 val = clk_readl(c->reg);
3449                 new_val = val >> c->reg_shift;
3450                 new_val &= 0xFFFF;
3451
3452                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
3453
3454                 val &= ~(0xFFFF << c->reg_shift);
3455                 val |= new_val << c->reg_shift;
3456                 clk_writel_delay(val, c->reg);
3457                 spin_unlock_irqrestore(&pll_div_lock, flags);
3458                 return 0;
3459         } else if (c->flags & DIV_2) {
3460                 return 0;
3461         } else if (c->flags & PLLU) {
3462                 clk_lock_save(c->parent, &flags);
3463                 val = clk_readl(c->reg) | (0x1 << c->reg_shift);
3464                 clk_writel_delay(val, c->reg);
3465                 clk_unlock_restore(c->parent, &flags);
3466                 return 0;
3467         }
3468         return -EINVAL;
3469 }
3470
3471 static void tegra11_pll_div_clk_disable(struct clk *c)
3472 {
3473         u32 val;
3474         u32 new_val;
3475         unsigned long flags;
3476
3477         pr_debug("%s: %s\n", __func__, c->name);
3478         if (c->flags & DIV_U71) {
3479                 spin_lock_irqsave(&pll_div_lock, flags);
3480                 val = clk_readl(c->reg);
3481                 new_val = val >> c->reg_shift;
3482                 new_val &= 0xFFFF;
3483
3484                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
3485
3486                 val &= ~(0xFFFF << c->reg_shift);
3487                 val |= new_val << c->reg_shift;
3488                 clk_writel_delay(val, c->reg);
3489                 spin_unlock_irqrestore(&pll_div_lock, flags);
3490         } else if (c->flags & PLLU) {
3491                 clk_lock_save(c->parent, &flags);
3492                 val = clk_readl(c->reg) & (~(0x1 << c->reg_shift));
3493                 clk_writel_delay(val, c->reg);
3494                 clk_unlock_restore(c->parent, &flags);
3495         }
3496 }
3497
3498 static int tegra11_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
3499 {
3500         u32 val;
3501         u32 new_val;
3502         int divider_u71;
3503         unsigned long parent_rate = clk_get_rate(c->parent);
3504         unsigned long flags;
3505
3506         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3507         if (c->flags & DIV_U71) {
3508                 divider_u71 = clk_div71_get_divider(
3509                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3510                 if (divider_u71 >= 0) {
3511                         spin_lock_irqsave(&pll_div_lock, flags);
3512                         val = clk_readl(c->reg);
3513                         new_val = val >> c->reg_shift;
3514                         new_val &= 0xFFFF;
3515                         if (c->flags & DIV_U71_FIXED)
3516                                 new_val |= PLL_OUT_OVERRIDE;
3517                         new_val &= ~PLL_OUT_RATIO_MASK;
3518                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
3519
3520                         val &= ~(0xFFFF << c->reg_shift);
3521                         val |= new_val << c->reg_shift;
3522                         clk_writel_delay(val, c->reg);
3523                         c->div = divider_u71 + 2;
3524                         c->mul = 2;
3525                         spin_unlock_irqrestore(&pll_div_lock, flags);
3526                         return 0;
3527                 }
3528         } else if (c->flags & DIV_2)
3529                 return clk_set_rate(c->parent, rate * 2);
3530
3531         return -EINVAL;
3532 }
3533
3534 static long tegra11_pll_div_clk_round_rate(struct clk *c, unsigned long rate)
3535 {
3536         int divider;
3537         unsigned long parent_rate = clk_get_rate(c->parent);
3538         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3539
3540         if (c->flags & DIV_U71) {
3541                 divider = clk_div71_get_divider(
3542                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3543                 if (divider < 0)
3544                         return divider;
3545                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
3546         } else if (c->flags & DIV_2)
3547                 /* no rounding - fixed DIV_2 dividers pass rate to parent PLL */
3548                 return rate;
3549
3550         return -EINVAL;
3551 }
3552
3553 static struct clk_ops tegra_pll_div_ops = {
3554         .init                   = tegra11_pll_div_clk_init,
3555         .enable                 = tegra11_pll_div_clk_enable,
3556         .disable                = tegra11_pll_div_clk_disable,
3557         .set_rate               = tegra11_pll_div_clk_set_rate,
3558         .round_rate             = tegra11_pll_div_clk_round_rate,
3559 };
3560
3561 /* Periph clk ops */
3562 static inline u32 periph_clk_source_mask(struct clk *c)
3563 {
3564         if (c->u.periph.src_mask)
3565                 return c->u.periph.src_mask;
3566         else if (c->flags & MUX8)
3567                 return 7 << 29;
3568         else if (c->flags & MUX_PWM)
3569                 return 3 << 28;
3570         else if (c->flags & MUX_CLK_OUT)
3571                 return 3 << (c->u.periph.clk_num + 4);
3572         else if (c->flags & PLLD)
3573                 return PLLD_BASE_DSI_MUX_MASK;
3574         else
3575                 return 3 << 30;
3576 }
3577
3578 static inline u32 periph_clk_source_shift(struct clk *c)
3579 {
3580         if (c->u.periph.src_shift)
3581                 return c->u.periph.src_shift;
3582         else if (c->flags & MUX8)
3583                 return 29;
3584         else if (c->flags & MUX_PWM)
3585                 return 28;
3586         else if (c->flags & MUX_CLK_OUT)
3587                 return c->u.periph.clk_num + 4;
3588         else if (c->flags & PLLD)
3589                 return PLLD_BASE_DSI_MUX_SHIFT;
3590         else
3591                 return 30;
3592 }
3593
3594 static void tegra11_periph_clk_init(struct clk *c)
3595 {
3596         u32 val = clk_readl(c->reg);
3597         const struct clk_mux_sel *mux = 0;
3598         const struct clk_mux_sel *sel;
3599         if (c->flags & MUX) {
3600                 for (sel = c->inputs; sel->input != NULL; sel++) {
3601                         if (((val & periph_clk_source_mask(c)) >>
3602                             periph_clk_source_shift(c)) == sel->value)
3603                                 mux = sel;
3604                 }
3605                 BUG_ON(!mux);
3606
3607                 c->parent = mux->input;
3608         } else {
3609                 if (c->flags & PLLU) {
3610                         /* for xusb_hs clock enforce PLLU source during init */
3611                         val &= periph_clk_source_mask(c);
3612                         val |= c->inputs[0].value << periph_clk_source_shift(c);
3613                         clk_writel_delay(val, c->reg);
3614                 }
3615                 c->parent = c->inputs[0].input;
3616         }
3617
3618         if (c->flags & DIV_U71) {
3619                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
3620                 if (c->flags & DIV_U71_IDLE) {
3621                         val &= ~(PERIPH_CLK_SOURCE_DIVU71_MASK <<
3622                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
3623                         val |= (PERIPH_CLK_SOURCE_DIVIDLE_VAL <<
3624                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
3625                         clk_writel(val, c->reg);
3626                 }
3627                 c->div = divu71 + 2;
3628                 c->mul = 2;
3629         } else if (c->flags & DIV_U151) {
3630                 u32 divu151 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
3631                 if ((c->flags & DIV_U151_UART) &&
3632                     (!(val & PERIPH_CLK_UART_DIV_ENB))) {
3633                         divu151 = 0;
3634                 }
3635                 c->div = divu151 + 2;
3636                 c->mul = 2;
3637         } else if (c->flags & DIV_U16) {
3638                 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
3639                 c->div = divu16 + 1;
3640                 c->mul = 1;
3641         } else {
3642                 c->div = 1;
3643                 c->mul = 1;
3644         }
3645
3646         if (c->flags & PERIPH_NO_ENB) {
3647                 c->state = c->parent->state;
3648                 return;
3649         }
3650
3651         c->state = ON;
3652
3653         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
3654                 c->state = OFF;
3655         if (!(c->flags & PERIPH_NO_RESET))
3656                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c))
3657                         c->state = OFF;
3658 }
3659
3660 static int tegra11_periph_clk_enable(struct clk *c)
3661 {
3662         unsigned long flags;
3663         pr_debug("%s on clock %s\n", __func__, c->name);
3664
3665         if (c->flags & PERIPH_NO_ENB)
3666                 return 0;
3667
3668         spin_lock_irqsave(&periph_refcount_lock, flags);
3669
3670         tegra_periph_clk_enable_refcount[c->u.periph.clk_num]++;
3671         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] > 1) {
3672                 spin_unlock_irqrestore(&periph_refcount_lock, flags);
3673                 return 0;
3674         }
3675
3676         clk_writel_delay(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_SET_REG(c));
3677         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET)) {
3678                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c)) {
3679                         udelay(5);      /* reset propagation delay */
3680                         clk_writel(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_RST_CLR_REG(c));
3681                 }
3682         }
3683         spin_unlock_irqrestore(&periph_refcount_lock, flags);
3684         return 0;
3685 }
3686
3687 static void tegra11_periph_clk_disable(struct clk *c)
3688 {
3689         unsigned long val, flags;
3690         pr_debug("%s on clock %s\n", __func__, c->name);
3691
3692         if (c->flags & PERIPH_NO_ENB)
3693                 return;
3694
3695         spin_lock_irqsave(&periph_refcount_lock, flags);
3696
3697         if (c->refcnt)
3698                 tegra_periph_clk_enable_refcount[c->u.periph.clk_num]--;
3699
3700         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] == 0) {
3701                 /* If peripheral is in the APB bus then read the APB bus to
3702                  * flush the write operation in apb bus. This will avoid the
3703                  * peripheral access after disabling clock*/
3704                 if (c->flags & PERIPH_ON_APB)
3705                         val = chipid_readl();
3706
3707                 clk_writel_delay(
3708                         PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_CLR_REG(c));
3709         }
3710         spin_unlock_irqrestore(&periph_refcount_lock, flags);
3711 }
3712
3713 static void tegra11_periph_clk_reset(struct clk *c, bool assert)
3714 {
3715         unsigned long val;
3716         pr_debug("%s %s on clock %s\n", __func__,
3717                  assert ? "assert" : "deassert", c->name);
3718
3719         if (c->flags & PERIPH_NO_ENB)
3720                 return;
3721
3722         if (!(c->flags & PERIPH_NO_RESET)) {
3723                 if (assert) {
3724                         /* If peripheral is in the APB bus then read the APB
3725                          * bus to flush the write operation in apb bus. This
3726                          * will avoid the peripheral access after disabling
3727                          * clock */
3728                         if (c->flags & PERIPH_ON_APB)
3729                                 val = chipid_readl();
3730
3731                         clk_writel(PERIPH_CLK_TO_BIT(c),
3732                                    PERIPH_CLK_TO_RST_SET_REG(c));
3733                 } else
3734                         clk_writel(PERIPH_CLK_TO_BIT(c),
3735                                    PERIPH_CLK_TO_RST_CLR_REG(c));
3736         }
3737 }
3738
3739 static int tegra11_periph_clk_set_parent(struct clk *c, struct clk *p)
3740 {
3741         u32 val;
3742         const struct clk_mux_sel *sel;
3743         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
3744
3745         if (!(c->flags & MUX))
3746                 return (p == c->parent) ? 0 : (-EINVAL);
3747
3748         for (sel = c->inputs; sel->input != NULL; sel++) {
3749                 if (sel->input == p) {
3750                         val = clk_readl(c->reg);
3751                         val &= ~periph_clk_source_mask(c);
3752                         val |= (sel->value << periph_clk_source_shift(c));
3753
3754                         if (c->refcnt)
3755                                 clk_enable(p);
3756
3757                         clk_writel_delay(val, c->reg);
3758
3759                         if (c->refcnt && c->parent)
3760                                 clk_disable(c->parent);
3761
3762                         clk_reparent(c, p);
3763                         return 0;
3764                 }
3765         }
3766
3767         return -EINVAL;
3768 }
3769
3770 static int tegra11_periph_clk_set_rate(struct clk *c, unsigned long rate)
3771 {
3772         u32 val;
3773         int divider;
3774         unsigned long parent_rate = clk_get_rate(c->parent);
3775
3776         if (c->flags & DIV_U71) {
3777                 divider = clk_div71_get_divider(
3778                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3779                 if (divider >= 0) {
3780                         val = clk_readl(c->reg);
3781                         val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
3782                         val |= divider;
3783                         clk_writel_delay(val, c->reg);
3784                         c->div = divider + 2;
3785                         c->mul = 2;
3786                         return 0;
3787                 }
3788         } else if (c->flags & DIV_U151) {
3789                 divider = clk_div151_get_divider(
3790                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3791                 if (divider >= 0) {
3792                         val = clk_readl(c->reg);
3793                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
3794                         val |= divider;
3795                         if (c->flags & DIV_U151_UART) {
3796                                 if (divider)
3797                                         val |= PERIPH_CLK_UART_DIV_ENB;
3798                                 else
3799                                         val &= ~PERIPH_CLK_UART_DIV_ENB;
3800                         }
3801                         clk_writel_delay(val, c->reg);
3802                         c->div = divider + 2;
3803                         c->mul = 2;
3804                         return 0;
3805                 }
3806         } else if (c->flags & DIV_U16) {
3807                 divider = clk_div16_get_divider(parent_rate, rate);
3808                 if (divider >= 0) {
3809                         val = clk_readl(c->reg);
3810                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
3811                         val |= divider;
3812                         clk_writel_delay(val, c->reg);
3813                         c->div = divider + 1;
3814                         c->mul = 1;
3815                         return 0;
3816                 }
3817         } else if (parent_rate <= rate) {
3818                 c->div = 1;
3819                 c->mul = 1;
3820                 return 0;
3821         }
3822         return -EINVAL;
3823 }
3824
3825 static long tegra11_periph_clk_round_rate(struct clk *c,
3826         unsigned long rate)
3827 {
3828         int divider;
3829         unsigned long parent_rate = clk_get_rate(c->parent);
3830         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3831
3832         if (c->flags & DIV_U71) {
3833                 divider = clk_div71_get_divider(
3834                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3835                 if (divider < 0)
3836                         return divider;
3837
3838                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
3839         } else if (c->flags & DIV_U151) {
3840                 divider = clk_div151_get_divider(
3841                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3842                 if (divider < 0)
3843                         return divider;
3844
3845                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
3846         } else if (c->flags & DIV_U16) {
3847                 divider = clk_div16_get_divider(parent_rate, rate);
3848                 if (divider < 0)
3849                         return divider;
3850                 return DIV_ROUND_UP(parent_rate, divider + 1);
3851         }
3852         return -EINVAL;
3853 }
3854
3855 static struct clk_ops tegra_periph_clk_ops = {
3856         .init                   = &tegra11_periph_clk_init,
3857         .enable                 = &tegra11_periph_clk_enable,
3858         .disable                = &tegra11_periph_clk_disable,
3859         .set_parent             = &tegra11_periph_clk_set_parent,
3860         .set_rate               = &tegra11_periph_clk_set_rate,
3861         .round_rate             = &tegra11_periph_clk_round_rate,
3862         .reset                  = &tegra11_periph_clk_reset,
3863 };
3864
3865
3866 #if !defined(CONFIG_TEGRA_SIMULATION_PLATFORM)
3867 /* msenc clock propagation WAR for bug 1005168 */
3868 static int tegra11_msenc_clk_enable(struct clk *c)
3869 {
3870         int ret = tegra11_periph_clk_enable(c);
3871         if (ret)
3872                 return ret;
3873
3874         clk_writel(0, LVL2_CLK_GATE_OVRE);
3875         clk_writel(0x00400000, LVL2_CLK_GATE_OVRE);
3876         udelay(1);
3877         clk_writel(0, LVL2_CLK_GATE_OVRE);
3878         return 0;
3879 }
3880
3881 static struct clk_ops tegra_msenc_clk_ops = {
3882         .init                   = &tegra11_periph_clk_init,
3883         .enable                 = &tegra11_msenc_clk_enable,
3884         .disable                = &tegra11_periph_clk_disable,
3885         .set_parent             = &tegra11_periph_clk_set_parent,
3886         .set_rate               = &tegra11_periph_clk_set_rate,
3887         .round_rate             = &tegra11_periph_clk_round_rate,
3888         .reset                  = &tegra11_periph_clk_reset,
3889 };
3890 #endif
3891 /* Periph extended clock configuration ops */
3892 static int
3893 tegra11_vi_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
3894 {
3895         if (p == TEGRA_CLK_VI_INP_SEL) {
3896                 u32 val = clk_readl(c->reg);
3897                 val &= ~PERIPH_CLK_VI_SEL_EX_MASK;
3898                 val |= (setting << PERIPH_CLK_VI_SEL_EX_SHIFT) &
3899                         PERIPH_CLK_VI_SEL_EX_MASK;
3900                 clk_writel(val, c->reg);
3901                 return 0;
3902         }
3903         return -EINVAL;
3904 }
3905
3906 static struct clk_ops tegra_vi_clk_ops = {
3907         .init                   = &tegra11_periph_clk_init,
3908         .enable                 = &tegra11_periph_clk_enable,
3909         .disable                = &tegra11_periph_clk_disable,
3910         .set_parent             = &tegra11_periph_clk_set_parent,
3911         .set_rate               = &tegra11_periph_clk_set_rate,
3912         .round_rate             = &tegra11_periph_clk_round_rate,
3913         .clk_cfg_ex             = &tegra11_vi_clk_cfg_ex,
3914         .reset                  = &tegra11_periph_clk_reset,
3915 };
3916
3917 static int
3918 tegra11_nand_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
3919 {
3920         if (p == TEGRA_CLK_NAND_PAD_DIV2_ENB) {
3921                 u32 val = clk_readl(c->reg);
3922                 if (setting)
3923                         val |= PERIPH_CLK_NAND_DIV_EX_ENB;
3924                 else
3925                         val &= ~PERIPH_CLK_NAND_DIV_EX_ENB;
3926                 clk_writel(val, c->reg);
3927                 return 0;
3928         }
3929         return -EINVAL;
3930 }
3931
3932 static struct clk_ops tegra_nand_clk_ops = {
3933         .init                   = &tegra11_periph_clk_init,
3934         .enable                 = &tegra11_periph_clk_enable,
3935         .disable                = &tegra11_periph_clk_disable,
3936         .set_parent             = &tegra11_periph_clk_set_parent,
3937         .set_rate               = &tegra11_periph_clk_set_rate,
3938         .round_rate             = &tegra11_periph_clk_round_rate,
3939         .clk_cfg_ex             = &tegra11_nand_clk_cfg_ex,
3940         .reset                  = &tegra11_periph_clk_reset,
3941 };
3942
3943
3944 static int
3945 tegra11_dtv_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
3946 {
3947         if (p == TEGRA_CLK_DTV_INVERT) {
3948                 u32 val = clk_readl(c->reg);
3949                 if (setting)
3950                         val |= PERIPH_CLK_DTV_POLARITY_INV;
3951                 else
3952                         val &= ~PERIPH_CLK_DTV_POLARITY_INV;
3953                 clk_writel(val, c->reg);
3954                 return 0;
3955         }
3956         return -EINVAL;
3957 }
3958
3959 static struct clk_ops tegra_dtv_clk_ops = {
3960         .init                   = &tegra11_periph_clk_init,
3961         .enable                 = &tegra11_periph_clk_enable,
3962         .disable                = &tegra11_periph_clk_disable,
3963         .set_parent             = &tegra11_periph_clk_set_parent,
3964         .set_rate               = &tegra11_periph_clk_set_rate,
3965         .round_rate             = &tegra11_periph_clk_round_rate,
3966         .clk_cfg_ex             = &tegra11_dtv_clk_cfg_ex,
3967         .reset                  = &tegra11_periph_clk_reset,
3968 };
3969
3970 static int tegra11_dsi_clk_set_parent(struct clk *c, struct clk *p)
3971 {
3972         const struct clk_mux_sel *sel;
3973         struct clk *d = tegra_get_clock_by_name("pll_d");
3974         if (c->reg != d->reg)
3975                 d = tegra_get_clock_by_name("pll_d2");
3976
3977         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
3978
3979         for (sel = c->inputs; sel->input != NULL; sel++) {
3980                 if (sel->input == p) {
3981                         if (c->refcnt)
3982                                 clk_enable(p);
3983
3984                         /* The DSI parent selection bit is in PLLD base
3985                            register - can not do direct r-m-w, must be
3986                            protected by PLLD lock */
3987                         tegra_clk_cfg_ex(
3988                                 d, TEGRA_CLK_PLLD_MIPI_MUX_SEL, sel->value);
3989
3990                         if (c->refcnt && c->parent)
3991                                 clk_disable(c->parent);
3992
3993                         clk_reparent(c, p);
3994                         return 0;
3995                 }
3996         }
3997
3998         return -EINVAL;
3999 }
4000
4001 static struct clk_ops tegra_dsi_clk_ops = {
4002         .init                   = &tegra11_periph_clk_init,
4003         .enable                 = &tegra11_periph_clk_enable,
4004         .disable                = &tegra11_periph_clk_disable,
4005         .set_parent             = &tegra11_dsi_clk_set_parent,
4006         .set_rate               = &tegra11_periph_clk_set_rate,
4007         .round_rate             = &tegra11_periph_clk_round_rate,
4008         .reset                  = &tegra11_periph_clk_reset,
4009 };
4010
4011 /* pciex clock support only reset function */
4012 static struct clk_ops tegra_pciex_clk_ops = {
4013         .reset    = tegra11_periph_clk_reset,
4014 };
4015
4016 /* Output clock ops */
4017
4018 static DEFINE_SPINLOCK(clk_out_lock);
4019
4020 static void tegra11_clk_out_init(struct clk *c)
4021 {
4022         const struct clk_mux_sel *mux = 0;
4023         const struct clk_mux_sel *sel;
4024         u32 val = pmc_readl(c->reg);
4025
4026         c->state = (val & (0x1 << c->u.periph.clk_num)) ? ON : OFF;
4027         c->mul = 1;
4028         c->div = 1;
4029
4030         for (sel = c->inputs; sel->input != NULL; sel++) {
4031                 if (((val & periph_clk_source_mask(c)) >>
4032                      periph_clk_source_shift(c)) == sel->value)
4033                         mux = sel;
4034         }
4035         BUG_ON(!mux);
4036         c->parent = mux->input;
4037 }
4038
4039 static int tegra11_clk_out_enable(struct clk *c)
4040 {
4041         u32 val;
4042         unsigned long flags;
4043
4044         pr_debug("%s on clock %s\n", __func__, c->name);
4045
4046         spin_lock_irqsave(&clk_out_lock, flags);
4047         val = pmc_readl(c->reg);
4048         val |= (0x1 << c->u.periph.clk_num);
4049         pmc_writel(val, c->reg);
4050         spin_unlock_irqrestore(&clk_out_lock, flags);
4051
4052         return 0;
4053 }
4054
4055 static void tegra11_clk_out_disable(struct clk *c)
4056 {
4057         u32 val;
4058         unsigned long flags;
4059
4060         pr_debug("%s on clock %s\n", __func__, c->name);
4061
4062         spin_lock_irqsave(&clk_out_lock, flags);
4063         val = pmc_readl(c->reg);
4064         val &= ~(0x1 << c->u.periph.clk_num);
4065         pmc_writel(val, c->reg);
4066         spin_unlock_irqrestore(&clk_out_lock, flags);
4067 }
4068
4069 static int tegra11_clk_out_set_parent(struct clk *c, struct clk *p)
4070 {
4071         u32 val;
4072         unsigned long flags;
4073         const struct clk_mux_sel *sel;
4074
4075         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
4076
4077         for (sel = c->inputs; sel->input != NULL; sel++) {
4078                 if (sel->input == p) {
4079                         if (c->refcnt)
4080                                 clk_enable(p);
4081
4082                         spin_lock_irqsave(&clk_out_lock, flags);
4083                         val = pmc_readl(c->reg);
4084                         val &= ~periph_clk_source_mask(c);
4085                         val |= (sel->value << periph_clk_source_shift(c));
4086                         pmc_writel(val, c->reg);
4087                         spin_unlock_irqrestore(&clk_out_lock, flags);
4088
4089                         if (c->refcnt && c->parent)
4090                                 clk_disable(c->parent);
4091
4092                         clk_reparent(c, p);
4093                         return 0;
4094                 }
4095         }
4096         return -EINVAL;
4097 }
4098
4099 static struct clk_ops tegra_clk_out_ops = {
4100         .init                   = &tegra11_clk_out_init,
4101         .enable                 = &tegra11_clk_out_enable,
4102         .disable                = &tegra11_clk_out_disable,
4103         .set_parent             = &tegra11_clk_out_set_parent,
4104 };
4105
4106
4107 /* External memory controller clock ops */
4108 static void tegra11_emc_clk_init(struct clk *c)
4109 {
4110         tegra11_periph_clk_init(c);
4111         tegra_emc_dram_type_init(c);
4112         c->max_rate = clk_get_rate(c->parent);
4113 }
4114
4115 static long tegra11_emc_clk_round_rate(struct clk *c, unsigned long rate)
4116 {
4117         long new_rate = max(rate, c->min_rate);
4118
4119         new_rate = tegra_emc_round_rate(new_rate);
4120         if (new_rate < 0)
4121                 new_rate = c->max_rate;
4122
4123         return new_rate;
4124 }
4125
4126 static int tegra11_emc_clk_set_rate(struct clk *c, unsigned long rate)
4127 {
4128         int ret;
4129         u32 div_value;
4130         struct clk *p;
4131
4132         /* The tegra11x memory controller has an interlock with the clock
4133          * block that allows memory shadowed registers to be updated,
4134          * and then transfer them to the main registers at the same
4135          * time as the clock update without glitches. During clock change
4136          * operation both clock parent and divider may change simultaneously
4137          * to achieve requested rate. */
4138         p = tegra_emc_predict_parent(rate, &div_value);
4139         div_value += 2;         /* emc has fractional DIV_U71 divider */
4140         if (IS_ERR_OR_NULL(p)) {
4141                 pr_err("%s: Failed to predict emc parent for rate %lu\n",
4142                        __func__, rate);
4143                 return -EINVAL;
4144         }
4145
4146         if (p == c->parent) {
4147                 if (div_value == c->div)
4148                         return 0;
4149         } else if (c->refcnt)
4150                 clk_enable(p);
4151
4152         ret = tegra_emc_set_rate(rate);
4153         if (ret < 0)
4154                 return ret;
4155
4156         if (p != c->parent) {
4157                 if(c->refcnt && c->parent)
4158                         clk_disable(c->parent);
4159                 clk_reparent(c, p);
4160         }
4161         c->div = div_value;
4162         c->mul = 2;
4163         return 0;
4164 }
4165
4166 static int tegra11_clk_emc_bus_update(struct clk *bus)
4167 {
4168         struct clk *p = NULL;
4169         unsigned long rate, parent_rate, backup_rate;
4170
4171         if (detach_shared_bus)
4172                 return 0;
4173
4174         rate = tegra11_clk_shared_bus_update(bus, NULL, NULL);
4175         rate = clk_round_rate_locked(bus, rate);
4176
4177         if (rate == clk_get_rate_locked(bus))
4178                 return 0;
4179
4180         if (!tegra_emc_is_parent_ready(rate, &p, &parent_rate, &backup_rate)) {
4181                 if (bus->parent == p) {
4182                         /* need backup to re-lock current parent */
4183                         if (IS_ERR_VALUE(backup_rate) ||
4184                             clk_set_rate_locked(bus, backup_rate)) {
4185                                 pr_err("%s: Failed to backup %s for rate %lu\n",
4186                                        __func__, bus->name, rate);
4187                                 return -EINVAL;
4188                         }
4189
4190                         if (p->refcnt) {
4191                                 pr_err("%s: %s has other than emc child\n",
4192                                        __func__, p->name);
4193                                 return -EINVAL;
4194                         }
4195                 }
4196                 if (clk_set_rate(p, parent_rate)) {
4197                         pr_err("%s: Failed to set %s rate %lu\n",
4198                                __func__, p->name, parent_rate);
4199                         return -EINVAL;
4200                 }
4201         }
4202
4203         return clk_set_rate_locked(bus, rate);
4204 }
4205
4206 static struct clk_ops tegra_emc_clk_ops = {
4207         .init                   = &tegra11_emc_clk_init,
4208         .enable                 = &tegra11_periph_clk_enable,
4209         .disable                = &tegra11_periph_clk_disable,
4210         .set_rate               = &tegra11_emc_clk_set_rate,
4211         .round_rate             = &tegra11_emc_clk_round_rate,
4212         .reset                  = &tegra11_periph_clk_reset,
4213         .shared_bus_update      = &tegra11_clk_emc_bus_update,
4214 };
4215
4216 /* Clock doubler ops (non-atomic shared register access) */
4217 static DEFINE_SPINLOCK(doubler_lock);
4218
4219 static void tegra11_clk_double_init(struct clk *c)
4220 {
4221         u32 val = clk_readl(c->reg);
4222         c->mul = val & (0x1 << c->reg_shift) ? 1 : 2;
4223         c->div = 1;
4224         c->state = ON;
4225         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
4226                 c->state = OFF;
4227 };
4228
4229 static int tegra11_clk_double_set_rate(struct clk *c, unsigned long rate)
4230 {
4231         u32 val;
4232         unsigned long parent_rate = clk_get_rate(c->parent);
4233         unsigned long flags;
4234
4235         if (rate == parent_rate) {
4236                 spin_lock_irqsave(&doubler_lock, flags);
4237                 val = clk_readl(c->reg) | (0x1 << c->reg_shift);
4238                 clk_writel(val, c->reg);
4239                 c->mul = 1;
4240                 c->div = 1;
4241                 spin_unlock_irqrestore(&doubler_lock, flags);
4242                 return 0;
4243         } else if (rate == 2 * parent_rate) {
4244                 spin_lock_irqsave(&doubler_lock, flags);
4245                 val = clk_readl(c->reg) & (~(0x1 << c->reg_shift));
4246                 clk_writel(val, c->reg);
4247                 c->mul = 2;
4248                 c->div = 1;
4249                 spin_unlock_irqrestore(&doubler_lock, flags);
4250                 return 0;
4251         }
4252         return -EINVAL;
4253 }
4254
4255 static struct clk_ops tegra_clk_double_ops = {
4256         .init                   = &tegra11_clk_double_init,
4257         .enable                 = &tegra11_periph_clk_enable,
4258         .disable                = &tegra11_periph_clk_disable,
4259         .set_rate               = &tegra11_clk_double_set_rate,
4260 };
4261
4262 /* Audio sync clock ops */
4263 static int tegra11_sync_source_set_rate(struct clk *c, unsigned long rate)
4264 {
4265         c->rate = rate;
4266         return 0;
4267 }
4268
4269 static struct clk_ops tegra_sync_source_ops = {
4270         .set_rate               = &tegra11_sync_source_set_rate,
4271 };
4272
4273 static void tegra11_audio_sync_clk_init(struct clk *c)
4274 {
4275         int source;
4276         const struct clk_mux_sel *sel;
4277         u32 val = clk_readl(c->reg);
4278         c->state = (val & AUDIO_SYNC_DISABLE_BIT) ? OFF : ON;
4279         source = val & AUDIO_SYNC_SOURCE_MASK;
4280         for (sel = c->inputs; sel->input != NULL; sel++)
4281                 if (sel->value == source)
4282                         break;
4283         BUG_ON(sel->input == NULL);
4284         c->parent = sel->input;
4285 }
4286
4287 static int tegra11_audio_sync_clk_enable(struct clk *c)
4288 {
4289         u32 val = clk_readl(c->reg);
4290         clk_writel((val & (~AUDIO_SYNC_DISABLE_BIT)), c->reg);
4291         return 0;
4292 }
4293
4294 static void tegra11_audio_sync_clk_disable(struct clk *c)
4295 {
4296         u32 val = clk_readl(c->reg);
4297         clk_writel((val | AUDIO_SYNC_DISABLE_BIT), c->reg);
4298 }
4299
4300 static int tegra11_audio_sync_clk_set_parent(struct clk *c, struct clk *p)
4301 {
4302         u32 val;
4303         const struct clk_mux_sel *sel;
4304         for (sel = c->inputs; sel->input != NULL; sel++) {
4305                 if (sel->input == p) {
4306                         val = clk_readl(c->reg);
4307                         val &= ~AUDIO_SYNC_SOURCE_MASK;
4308                         val |= sel->value;
4309
4310                         if (c->refcnt)
4311                                 clk_enable(p);
4312
4313                         clk_writel(val, c->reg);
4314
4315                         if (c->refcnt && c->parent)
4316                                 clk_disable(c->parent);
4317
4318                         clk_reparent(c, p);
4319                         return 0;
4320                 }
4321         }
4322
4323         return -EINVAL;
4324 }
4325
4326 static struct clk_ops tegra_audio_sync_clk_ops = {
4327         .init       = tegra11_audio_sync_clk_init,
4328         .enable     = tegra11_audio_sync_clk_enable,
4329         .disable    = tegra11_audio_sync_clk_disable,
4330         .set_parent = tegra11_audio_sync_clk_set_parent,
4331 };
4332
4333
4334 /* cbus ops */
4335 /*
4336  * Some clocks require dynamic re-locking of source PLL in order to
4337  * achieve frequency scaling granularity that matches characterized
4338  * core voltage steps. The cbus clock creates a shared bus that
4339  * provides a virtual root for such clocks to hide and synchronize
4340  * parent PLL re-locking as well as backup operations.
4341 */
4342
4343 static void tegra11_clk_cbus_init(struct clk *c)
4344 {
4345         c->state = OFF;
4346         c->set = true;
4347 }
4348
4349 static int tegra11_clk_cbus_enable(struct clk *c)
4350 {
4351         return 0;
4352 }
4353
4354 static long tegra11_clk_cbus_round_rate(struct clk *c, unsigned long rate)
4355 {
4356         int i;
4357
4358         if (!c->dvfs) {
4359                 if (!c->min_rate)
4360                         c->min_rate = c->parent->min_rate;
4361                 rate = max(rate, c->min_rate);
4362                 return rate;
4363         }
4364
4365         /* update min now, since no dvfs table was available during init
4366            (skip placeholder entries set to 1 kHz) */
4367         if (!c->min_rate) {
4368                 for (i = 0; i < (c->dvfs->num_freqs - 1); i++) {
4369                         if (c->dvfs->freqs[i] > 1 * c->dvfs->freqs_mult) {
4370                                 c->min_rate = c->dvfs->freqs[i];
4371                                 break;
4372                         }
4373                 }
4374                 BUG_ON(!c->min_rate);
4375         }
4376         rate = max(rate, c->min_rate);
4377
4378         for (i = 0; i < (c->dvfs->num_freqs - 1); i++) {
4379                 unsigned long f = c->dvfs->freqs[i];
4380                 int mv = c->dvfs->millivolts[i];
4381                 if ((f >= rate) || (mv >= c->dvfs->max_millivolts))
4382                         break;
4383         }
4384         return c->dvfs->freqs[i];
4385 }
4386
4387 static int cbus_switch_one(struct clk *c, struct clk *p, u32 div, bool abort)
4388 {
4389         int ret = 0;
4390
4391         /* set new divider if it is bigger than the current one */
4392         if (c->div < c->mul * div) {
4393                 ret = clk_set_div(c, div);
4394                 if (ret) {
4395                         pr_err("%s: failed to set %s clock divider %u: %d\n",
4396                                __func__, c->name, div, ret);
4397                         if (abort)
4398                                 return ret;
4399                 }
4400         }
4401
4402         if (c->parent != p) {
4403                 ret = clk_set_parent(c, p);
4404                 if (ret) {
4405                         pr_err("%s: failed to set %s clock parent %s: %d\n",
4406                                __func__, c->name, p->name, ret);
4407                         if (abort)
4408                                 return ret;
4409                 }
4410         }
4411
4412         /* set new divider if it is smaller than the current one */
4413         if (c->div > c->mul * div) {
4414                 ret = clk_set_div(c, div);
4415                 if (ret)
4416                         pr_err("%s: failed to set %s clock divider %u: %d\n",
4417                                __func__, c->name, div, ret);
4418         }
4419
4420         return ret;
4421 }
4422
4423 static int cbus_backup(struct clk *c)
4424 {
4425         int ret;
4426         struct clk *user;
4427
4428         list_for_each_entry(user, &c->shared_bus_list,
4429                         u.shared_bus_user.node) {
4430                 struct clk *client = user->u.shared_bus_user.client;
4431                 if (client && (client->state == ON) &&
4432                     (client->parent == c->parent)) {
4433                         ret = cbus_switch_one(client,
4434                                               c->shared_bus_backup.input,
4435                                               c->shared_bus_backup.value *
4436                                               user->div, true);
4437                         if (ret)
4438                                 return ret;
4439                 }
4440         }
4441         return 0;
4442 }
4443
4444 static int cbus_dvfs_set_rate(struct clk *c, unsigned long rate)
4445 {
4446         int ret;
4447         struct clk *user;
4448
4449         list_for_each_entry(user, &c->shared_bus_list,
4450                         u.shared_bus_user.node) {
4451                 struct clk *client =  user->u.shared_bus_user.client;
4452                 if (client && client->refcnt && (client->parent == c->parent)) {
4453                         ret = tegra_dvfs_set_rate(c, rate);
4454                         if (ret)
4455                                 return ret;
4456                 }
4457         }
4458         return 0;
4459 }
4460
4461 static void cbus_restore(struct clk *c)
4462 {
4463         struct clk *user;
4464
4465         list_for_each_entry(user, &c->shared_bus_list,
4466                         u.shared_bus_user.node) {
4467                 if (user->u.shared_bus_user.client)
4468                         cbus_switch_one(user->u.shared_bus_user.client,
4469                                         c->parent, c->div * user->div, false);
4470         }
4471 }
4472
4473 static int get_next_backup_div(struct clk *c, unsigned long rate)
4474 {
4475         u32 div = c->div;
4476         unsigned long backup_rate = clk_get_rate(c->shared_bus_backup.input);
4477
4478         rate = max(rate, clk_get_rate_locked(c));
4479         rate = rate - (rate >> 2);      /* 25% margin for backup rate */
4480         if ((u64)rate * div < backup_rate)
4481                 div = DIV_ROUND_UP(backup_rate, rate);
4482
4483         BUG_ON(!div);
4484         return div;
4485 }
4486
4487 static int tegra11_clk_cbus_set_rate(struct clk *c, unsigned long rate)
4488 {
4489         int ret;
4490         bool dramp;
4491
4492         if (rate == 0)
4493                 return 0;
4494
4495         ret = clk_enable(c->parent);
4496         if (ret) {
4497                 pr_err("%s: failed to enable %s clock: %d\n",
4498                        __func__, c->name, ret);
4499                 return ret;
4500         }
4501
4502         dramp = tegra11_is_dyn_ramp(c->parent, rate * c->div, false);
4503         if (!dramp) {
4504                 c->shared_bus_backup.value = get_next_backup_div(c, rate);
4505                 ret = cbus_backup(c);
4506                 if (ret)
4507                         goto out;
4508         }
4509
4510         ret = clk_set_rate(c->parent, rate * c->div);
4511         if (ret) {
4512                 pr_err("%s: failed to set %s clock rate %lu: %d\n",
4513                        __func__, c->name, rate, ret);
4514                 goto out;
4515         }
4516
4517         /* Safe voltage setting is taken care of by cbus clock dvfs; the call
4518          * below only records requirements for each enabled client.
4519          */
4520         if (dramp)
4521                 ret = cbus_dvfs_set_rate(c, rate);
4522
4523         cbus_restore(c);
4524
4525 out:
4526         clk_disable(c->parent);
4527         return ret;
4528 }
4529
4530 static inline bool cbus_user_is_slower(struct clk *a, struct clk *b)
4531 {
4532         return a->u.shared_bus_user.client->max_rate * a->div <
4533                 b->u.shared_bus_user.client->max_rate * b->div;
4534 }
4535
4536 static inline bool cbus_user_request_is_lower(struct clk *a, struct clk *b)
4537 {
4538         return a->u.shared_bus_user.rate * a->div <
4539                 b->u.shared_bus_user.rate * b->div;
4540 }
4541
4542 static inline void cbus_move_enabled_user(
4543         struct clk *user, struct clk *dst, struct clk *src)
4544 {
4545         clk_enable(dst);
4546         list_move_tail(&user->u.shared_bus_user.node, &dst->shared_bus_list);
4547         clk_disable(src);
4548         clk_reparent(user, dst);
4549 }
4550
4551 #ifdef CONFIG_TEGRA_DYNAMIC_CBUS
4552 static int tegra11_clk_cbus_update(struct clk *bus)
4553 {
4554         int ret, mv;
4555         struct clk *slow = NULL;
4556         struct clk *top = NULL;
4557         unsigned long rate;
4558
4559         if (detach_shared_bus)
4560                 return 0;
4561
4562         rate = tegra11_clk_shared_bus_update(bus, &top, &slow);
4563
4564         /* use dvfs table of the slowest enabled client as cbus dvfs table */
4565         if (bus->dvfs && slow && (slow != bus->u.cbus.slow_user)) {
4566                 int i;
4567                 unsigned long *dest = &bus->dvfs->freqs[0];
4568                 unsigned long *src =
4569                         &slow->u.shared_bus_user.client->dvfs->freqs[0];
4570                 if (slow->div > 1)
4571                         for (i = 0; i < bus->dvfs->num_freqs; i++)
4572                                 dest[i] = src[i] * slow->div;
4573                 else
4574                         memcpy(dest, src, sizeof(*dest) * bus->dvfs->num_freqs);
4575         }
4576
4577         /* update bus state variables and rate */
4578         bus->u.cbus.slow_user = slow;
4579         bus->u.cbus.top_user = top;
4580
4581         rate = bus->ops->round_rate(bus, rate);
4582         mv = tegra_dvfs_predict_millivolts(bus, rate);
4583         if (IS_ERR_VALUE(mv))
4584                 return -EINVAL;
4585
4586         if (bus->dvfs) {
4587                 mv -= bus->dvfs->cur_millivolts;
4588                 if (bus->refcnt && (mv > 0)) {
4589                         ret = tegra_dvfs_set_rate(bus, rate);
4590                         if (ret)
4591                                 return ret;
4592                 }
4593         }
4594
4595         ret = bus->ops->set_rate(bus, rate);
4596         if (ret)
4597                 return ret;
4598
4599         if (bus->dvfs) {
4600                 if (bus->refcnt && (mv <= 0)) {
4601                         ret = tegra_dvfs_set_rate(bus, rate);
4602                         if (ret)
4603                                 return ret;
4604                 }
4605         }
4606
4607         return 0;
4608 };
4609 #else
4610 static int tegra11_clk_cbus_update(struct clk *bus)
4611 {
4612         unsigned long rate, old_rate;
4613
4614         if (detach_shared_bus)
4615                 return 0;
4616
4617         rate = tegra11_clk_shared_bus_update(bus, NULL, NULL);
4618         rate = clk_round_rate_locked(bus, rate);
4619
4620         old_rate = clk_get_rate_locked(bus);
4621         if (rate == old_rate)
4622                 return 0;
4623
4624         return clk_set_rate_locked(bus, rate);
4625 }
4626 #endif
4627
4628 static int tegra11_clk_cbus_migrate_users(struct clk *user)
4629 {
4630 #ifdef CONFIG_TEGRA_MIGRATE_CBUS_USERS
4631         struct clk *src_bus, *dst_bus, *top_user, *c;
4632         struct list_head *pos, *n;
4633
4634         if (!user->u.shared_bus_user.client || !user->inputs)
4635                 return 0;
4636
4637         /* Dual cbus on Tegra11 */
4638         src_bus = user->inputs[0].input;
4639         dst_bus = user->inputs[1].input;
4640
4641         if (!src_bus->u.cbus.top_user && !dst_bus->u.cbus.top_user)
4642                 return 0;
4643
4644         /* Make sure top user on the source bus is requesting highest rate */
4645         if (!src_bus->u.cbus.top_user || (dst_bus->u.cbus.top_user &&
4646                 cbus_user_request_is_lower(src_bus->u.cbus.top_user,
4647                                            dst_bus->u.cbus.top_user)))
4648                 swap(src_bus, dst_bus);
4649
4650         /* If top user is the slow one on its own (source) bus, do nothing */
4651         top_user = src_bus->u.cbus.top_user;
4652         BUG_ON(!top_user->u.shared_bus_user.client);
4653         if (!cbus_user_is_slower(src_bus->u.cbus.slow_user, top_user))
4654                 return 0;
4655
4656         /* If source bus top user is slower than all users on destination bus,
4657            move top user; otherwise move all users slower than the top one */
4658         if (!dst_bus->u.cbus.slow_user ||
4659             !cbus_user_is_slower(dst_bus->u.cbus.slow_user, top_user)) {
4660                 cbus_move_enabled_user(top_user, dst_bus, src_bus);
4661         } else {
4662                 list_for_each_safe(pos, n, &src_bus->shared_bus_list) {
4663                         c = list_entry(pos, struct clk, u.shared_bus_user.node);
4664                         if (c->u.shared_bus_user.enabled &&
4665                             c->u.shared_bus_user.client &&
4666                             cbus_user_is_slower(c, top_user))
4667                                 cbus_move_enabled_user(c, dst_bus, src_bus);
4668                 }
4669         }
4670
4671         /* Update destination bus 1st (move clients), then source */
4672         tegra_clk_shared_bus_update(dst_bus);
4673         tegra_clk_shared_bus_update(src_bus);
4674 #endif
4675         return 0;
4676 }
4677
4678 static struct clk_ops tegra_clk_cbus_ops = {
4679         .init = tegra11_clk_cbus_init,
4680         .enable = tegra11_clk_cbus_enable,
4681         .set_rate = tegra11_clk_cbus_set_rate,
4682         .round_rate = tegra11_clk_cbus_round_rate,
4683         .shared_bus_update = tegra11_clk_cbus_update,
4684 };
4685
4686 /* shared bus ops */
4687 /*
4688  * Some clocks may have multiple downstream users that need to request a
4689  * higher clock rate.  Shared bus clocks provide a unique shared_bus_user
4690  * clock to each user.  The frequency of the bus is set to the highest
4691  * enabled shared_bus_user clock, with a minimum value set by the
4692  * shared bus.
4693  */
4694
4695 static unsigned long tegra11_clk_shared_bus_update(
4696         struct clk *bus, struct clk **bus_top, struct clk **bus_slow)
4697 {
4698         struct clk *c;
4699         struct clk *slow = NULL;
4700         struct clk *top = NULL;
4701
4702         unsigned long top_rate = 0;
4703         unsigned long rate = bus->min_rate;
4704         unsigned long bw = 0;
4705         unsigned long ceiling = bus->max_rate;
4706         u8 emc_bw_efficiency = tegra_emc_bw_efficiency;
4707
4708         list_for_each_entry(c, &bus->shared_bus_list,
4709                         u.shared_bus_user.node) {
4710                 /*
4711                  * Ignore requests from disabled floor and bw users, and from
4712                  * auto-users riding the bus. Always honor ceiling users, even
4713                  * if they are disabled - we do not want to keep enabled parent
4714                  * bus just because ceiling is set.
4715                  */
4716                 if (c->u.shared_bus_user.enabled ||
4717                     (c->u.shared_bus_user.mode == SHARED_CEILING)) {
4718                         unsigned long request_rate = c->u.shared_bus_user.rate *
4719                                 (c->div ? : 1);
4720
4721                         switch (c->u.shared_bus_user.mode) {
4722                         case SHARED_BW:
4723                                 bw += request_rate;
4724                                 if (bw > bus->max_rate)
4725                                         bw = bus->max_rate;
4726                                 break;
4727                         case SHARED_CEILING:
4728                                 ceiling = min(request_rate, ceiling);
4729                                 break;
4730                         case SHARED_AUTO:
4731                                 break;
4732                         case SHARED_FLOOR:
4733                         default:
4734                                 rate = max(request_rate, rate);
4735                                 if (c->u.shared_bus_user.client) {
4736                                         if (top_rate < request_rate) {
4737                                                 top_rate = request_rate;
4738                                                 top = c;
4739                                         } else if ((top_rate == request_rate) &&
4740                                                 cbus_user_is_slower(c, top)) {
4741                                                 top = c;
4742                                         }
4743                                 }
4744                         }
4745                         if (c->u.shared_bus_user.client &&
4746                                 (!slow || cbus_user_is_slower(c, slow)))
4747                                 slow = c;
4748                 }
4749         }
4750
4751         if ((bus->flags & PERIPH_EMC_ENB) && bw && (emc_bw_efficiency < 100)) {
4752                 bw = emc_bw_efficiency ?
4753                         (bw / emc_bw_efficiency) : bus->max_rate;
4754                 bw = (bw < bus->max_rate / 100) ? (bw * 100) : bus->max_rate;
4755         }
4756
4757         rate = min(max(rate, bw), ceiling);
4758
4759         if (bus_top)
4760                 *bus_top = top;
4761         if (bus_slow)
4762                 *bus_slow = slow;
4763         return rate;
4764 };
4765
4766 static int tegra_clk_shared_bus_migrate_users(struct clk *user)
4767 {
4768         if (detach_shared_bus)
4769                 return 0;
4770
4771         /* Only cbus migration is supported */
4772         if (user->flags & PERIPH_ON_CBUS)
4773                 return tegra11_clk_cbus_migrate_users(user);
4774         return -ENOSYS;
4775 }
4776
4777 static void tegra_clk_shared_bus_user_init(struct clk *c)
4778 {
4779         c->max_rate = c->parent->max_rate;
4780         c->u.shared_bus_user.rate = c->parent->max_rate;
4781         c->state = OFF;
4782         c->set = true;
4783
4784         if (c->u.shared_bus_user.client_id) {
4785                 c->u.shared_bus_user.client =
4786                         tegra_get_clock_by_name(c->u.shared_bus_user.client_id);
4787                 if (!c->u.shared_bus_user.client) {
4788                         pr_err("%s: could not find clk %s\n", __func__,
4789                                c->u.shared_bus_user.client_id);
4790                         return;
4791                 }
4792                 c->u.shared_bus_user.client->flags |=
4793                         c->parent->flags & PERIPH_ON_CBUS;
4794                 c->flags |= c->parent->flags & PERIPH_ON_CBUS;
4795                 c->div = c->u.shared_bus_user.client_div ? : 1;
4796                 c->mul = 1;
4797         }
4798
4799         list_add_tail(&c->u.shared_bus_user.node,
4800                 &c->parent->shared_bus_list);
4801 }
4802
4803 /*
4804  * Shared bus and its children/users have reversed rate relations - user rates
4805  * determine bus rate. Hence switching user from one parent/bus to another may
4806  * change rates of both parents. Therefore we need a cross-bus lock on top of
4807  * individual user and bus locks. For now limit bus switch support to cansleep
4808  * users with cross-clock mutex only.
4809  */
4810 static int tegra_clk_shared_bus_user_set_parent(struct clk *c, struct clk *p)
4811 {
4812         const struct clk_mux_sel *sel;
4813
4814         if (detach_shared_bus)
4815                 return 0;
4816
4817         if (c->parent == p)
4818                 return 0;
4819
4820         if (!(c->inputs && c->cross_clk_mutex && clk_cansleep(c)))
4821                 return -ENOSYS;
4822
4823         for (sel = c->inputs; sel->input != NULL; sel++) {
4824                 if (sel->input == p)
4825                         break;
4826         }
4827         if (!sel->input)
4828                 return -EINVAL;
4829
4830         if (c->refcnt)
4831                 clk_enable(p);
4832
4833         list_move_tail(&c->u.shared_bus_user.node, &p->shared_bus_list);
4834         tegra_clk_shared_bus_update(p);
4835         tegra_clk_shared_bus_update(c->parent);
4836
4837         if (c->refcnt && c->parent)
4838                 clk_disable(c->parent);
4839
4840         clk_reparent(c, p);
4841
4842         return 0;
4843 }
4844
4845 static int tegra_clk_shared_bus_user_set_rate(struct clk *c, unsigned long rate)
4846 {
4847         c->u.shared_bus_user.rate = rate;
4848         tegra_clk_shared_bus_update(c->parent);
4849
4850         if (c->cross_clk_mutex && clk_cansleep(c))
4851                 tegra_clk_shared_bus_migrate_users(c);
4852
4853         return 0;
4854 }
4855
4856 static long tegra_clk_shared_bus_user_round_rate(
4857         struct clk *c, unsigned long rate)
4858 {
4859         /* Defer rounding requests until aggregated. BW users must not be
4860            rounded at all, others just clipped to bus range (some clients
4861            may use round api to find limits) */
4862         if (c->u.shared_bus_user.mode != SHARED_BW) {
4863                 if (c->div > 1)
4864                         rate *= c->div;
4865
4866                 if (rate > c->parent->max_rate)
4867                         rate = c->parent->max_rate;
4868                 else if (rate < c->parent->min_rate)
4869                         rate = c->parent->min_rate;
4870
4871                 if (c->div > 1)
4872                         rate /= c->div;
4873         }
4874         return rate;
4875 }
4876
4877 static int tegra_clk_shared_bus_user_enable(struct clk *c)
4878 {
4879         int ret = 0;
4880
4881         c->u.shared_bus_user.enabled = true;
4882         tegra_clk_shared_bus_update(c->parent);
4883         if (c->u.shared_bus_user.client)
4884                 ret = clk_enable(c->u.shared_bus_user.client);
4885
4886         if (c->cross_clk_mutex && clk_cansleep(c))
4887                 tegra_clk_shared_bus_migrate_users(c);
4888
4889         return ret;
4890 }
4891
4892 static void tegra_clk_shared_bus_user_disable(struct clk *c)
4893 {
4894         if (c->u.shared_bus_user.client)
4895                 clk_disable(c->u.shared_bus_user.client);
4896         c->u.shared_bus_user.enabled = false;
4897         tegra_clk_shared_bus_update(c->parent);
4898
4899         if (c->cross_clk_mutex && clk_cansleep(c))
4900                 tegra_clk_shared_bus_migrate_users(c);
4901 }
4902
4903 static void tegra_clk_shared_bus_user_reset(struct clk *c, bool assert)
4904 {
4905         if (c->u.shared_bus_user.client) {
4906                 if (c->u.shared_bus_user.client->ops &&
4907                     c->u.shared_bus_user.client->ops->reset)
4908                         c->u.shared_bus_user.client->ops->reset(
4909                                 c->u.shared_bus_user.client, assert);
4910         }
4911 }
4912
4913 static struct clk_ops tegra_clk_shared_bus_user_ops = {
4914         .init = tegra_clk_shared_bus_user_init,
4915         .enable = tegra_clk_shared_bus_user_enable,
4916         .disable = tegra_clk_shared_bus_user_disable,
4917         .set_parent = tegra_clk_shared_bus_user_set_parent,
4918         .set_rate = tegra_clk_shared_bus_user_set_rate,
4919         .round_rate = tegra_clk_shared_bus_user_round_rate,
4920         .reset = tegra_clk_shared_bus_user_reset,
4921 };
4922
4923 /* coupled gate ops */
4924 /*
4925  * Some clocks may have common enable/disable control, but run at different
4926  * rates, and have different dvfs tables. Coupled gate clock synchronize
4927  * enable/disable operations for such clocks.
4928  */
4929
4930 static int tegra11_clk_coupled_gate_enable(struct clk *c)
4931 {
4932         int ret;
4933         const struct clk_mux_sel *sel;
4934
4935         BUG_ON(!c->inputs);
4936         pr_debug("%s on clock %s\n", __func__, c->name);
4937
4938         for (sel = c->inputs; sel->input != NULL; sel++) {
4939                 if (sel->input == c->parent)
4940                         continue;
4941
4942                 ret = clk_enable(sel->input);
4943                 if (ret) {
4944                         while(sel != c->inputs) {
4945                                 sel--;
4946                                 if (sel->input == c->parent)
4947                                         continue;
4948                                 clk_disable(sel->input);
4949                         }
4950                         return ret;
4951                 }
4952         }
4953
4954         return tegra11_periph_clk_enable(c);
4955 }
4956
4957 static void tegra11_clk_coupled_gate_disable(struct clk *c)
4958 {
4959         const struct clk_mux_sel *sel;
4960
4961         BUG_ON(!c->inputs);
4962         pr_debug("%s on clock %s\n", __func__, c->name);
4963
4964         tegra11_periph_clk_disable(c);
4965
4966         for (sel = c->inputs; sel->input != NULL; sel++) {
4967                 if (sel->input == c->parent)
4968                         continue;
4969
4970                 if (sel->input->set)    /* enforce coupling after boot only */
4971                         clk_disable(sel->input);
4972         }
4973 }
4974
4975 static struct clk_ops tegra_clk_coupled_gate_ops = {
4976         .init                   = tegra11_periph_clk_init,
4977         .enable                 = tegra11_clk_coupled_gate_enable,
4978         .disable                = tegra11_clk_coupled_gate_disable,
4979         .reset                  = &tegra11_periph_clk_reset,
4980 };
4981
4982
4983 /* Clock definitions */
4984 static struct clk tegra_clk_32k = {
4985         .name = "clk_32k",
4986         .rate = 32768,
4987         .ops  = NULL,
4988         .max_rate = 32768,
4989 };
4990
4991 static struct clk tegra_clk_m = {
4992         .name      = "clk_m",
4993         .flags     = ENABLE_ON_INIT,
4994         .ops       = &tegra_clk_m_ops,
4995         .reg       = 0x1fc,
4996         .reg_shift = 28,
4997         .max_rate  = 48000000,
4998 };
4999
5000 static struct clk tegra_clk_m_div2 = {
5001         .name      = "clk_m_div2",
5002         .ops       = &tegra_clk_m_div_ops,
5003         .parent    = &tegra_clk_m,
5004         .mul       = 1,
5005         .div       = 2,
5006         .state     = ON,
5007         .max_rate  = 24000000,
5008 };
5009
5010 static struct clk tegra_clk_m_div4 = {
5011         .name      = "clk_m_div4",
5012         .ops       = &tegra_clk_m_div_ops,
5013         .parent    = &tegra_clk_m,
5014         .mul       = 1,
5015         .div       = 4,
5016         .state     = ON,
5017         .max_rate  = 12000000,
5018 };
5019
5020 static struct clk tegra_pll_ref = {
5021         .name      = "pll_ref",
5022         .flags     = ENABLE_ON_INIT,
5023         .ops       = &tegra_pll_ref_ops,
5024         .parent    = &tegra_clk_m,
5025         .max_rate  = 26000000,
5026 };
5027
5028 static struct clk_pll_freq_table tegra_pll_c_freq_table[] = {
5029         { 12000000, 600000000, 100, 1, 2},
5030         { 13000000, 600000000,  92, 1, 2},      /* actual: 598.0 MHz */
5031         { 16800000, 600000000,  71, 1, 2},      /* actual: 596.4 MHz */
5032         { 19200000, 600000000,  62, 1, 2},      /* actual: 595.2 MHz */
5033         { 26000000, 600000000,  92, 2, 2},      /* actual: 598.0 MHz */
5034         { 0, 0, 0, 0, 0, 0 },
5035 };
5036
5037 static struct clk tegra_pll_c = {
5038         .name      = "pll_c",
5039         .ops       = &tegra_pllxc_ops,
5040         .reg       = 0x80,
5041         .parent    = &tegra_pll_ref,
5042         .max_rate  = 1400000000,
5043         .u.pll = {
5044                 .input_min = 12000000,
5045                 .input_max = 800000000,
5046                 .cf_min    = 12000000,
5047                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
5048                 .vco_min   = 600000000,
5049                 .vco_max   = 1400000000,
5050                 .freq_table = tegra_pll_c_freq_table,
5051                 .lock_delay = 300,
5052                 .misc1 = 0x88 - 0x80,
5053                 .round_p_to_pdiv = pllxc_round_p_to_pdiv,
5054         },
5055 };
5056
5057 static struct clk tegra_pll_c_out1 = {
5058         .name      = "pll_c_out1",
5059         .ops       = &tegra_pll_div_ops,
5060         .flags     = DIV_U71 | PERIPH_ON_CBUS,
5061         .parent    = &tegra_pll_c,
5062         .reg       = 0x84,
5063         .reg_shift = 0,
5064         .max_rate  = 700000000,
5065 };
5066
5067 static struct clk_pll_freq_table tegra_pll_cx_freq_table[] = {
5068         { 12000000, 600000000, 100, 1, 2},
5069         { 13000000, 600000000,  92, 1, 2},      /* actual: 598.0 MHz */
5070         { 16800000, 600000000,  71, 1, 2},      /* actual: 596.4 MHz */
5071         { 19200000, 600000000,  62, 1, 2},      /* actual: 595.2 MHz */
5072         { 26000000, 600000000,  92, 2, 2},      /* actual: 598.0 MHz */
5073         { 0, 0, 0, 0, 0, 0 },
5074 };
5075
5076 static struct clk tegra_pll_c2 = {
5077         .name      = "pll_c2",
5078         .ops       = &tegra_pllcx_ops,
5079         .flags     = PLL_ALT_MISC_REG,
5080         .reg       = 0x4e8,
5081         .parent    = &tegra_pll_ref,
5082         .max_rate  = 1200000000,
5083         .u.pll = {
5084                 .input_min = 12000000,
5085                 .input_max = 48000000,
5086                 .cf_min    = 12000000,
5087                 .cf_max    = 19200000,
5088                 .vco_min   = 600000000,
5089                 .vco_max   = 1200000000,
5090                 .freq_table = tegra_pll_cx_freq_table,
5091                 .lock_delay = 300,
5092                 .misc1 = 0x4f0 - 0x4e8,
5093                 .round_p_to_pdiv = pllcx_round_p_to_pdiv,
5094         },
5095 };
5096
5097 static struct clk tegra_pll_c3 = {
5098         .name      = "pll_c3",
5099         .ops       = &tegra_pllcx_ops,
5100         .flags     = PLL_ALT_MISC_REG,
5101         .reg       = 0x4fc,
5102         .parent    = &tegra_pll_ref,
5103         .max_rate  = 1200000000,
5104         .u.pll = {
5105                 .input_min = 12000000,
5106                 .input_max = 48000000,
5107                 .cf_min    = 12000000,
5108                 .cf_max    = 19200000,
5109                 .vco_min   = 600000000,
5110                 .vco_max   = 1200000000,
5111                 .freq_table = tegra_pll_cx_freq_table,
5112                 .lock_delay = 300,
5113                 .misc1 = 0x504 - 0x4fc,
5114                 .round_p_to_pdiv = pllcx_round_p_to_pdiv,
5115         },
5116 };
5117
5118 static struct clk_pll_freq_table tegra_pll_m_freq_table[] = {
5119         { 12000000, 800000000, 66, 1, 1},       /* actual: 792.0 MHz */
5120         { 13000000, 800000000, 61, 1, 1},       /* actual: 793.0 MHz */
5121         { 16800000, 800000000, 47, 1, 1},       /* actual: 789.6 MHz */
5122         { 19200000, 800000000, 41, 1, 1},       /* actual: 787.2 MHz */
5123         { 26000000, 800000000, 61, 2, 1},       /* actual: 793.0 MHz */
5124         { 0, 0, 0, 0, 0, 0 },
5125 };
5126
5127 static struct clk tegra_pll_m = {
5128         .name      = "pll_m",
5129         .flags     = PLLM,
5130         .ops       = &tegra_pllm_ops,
5131         .reg       = 0x90,
5132         .parent    = &tegra_pll_ref,
5133         .max_rate  = 800000000,
5134         .u.pll = {
5135                 .input_min = 12000000,
5136                 .input_max = 500000000,
5137                 .cf_min    = 12000000,
5138                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
5139                 .vco_min   = 400000000,
5140                 .vco_max   = 800000000,
5141                 .freq_table = tegra_pll_m_freq_table,
5142                 .lock_delay = 300,
5143                 .misc1 = 0x98 - 0x90,
5144                 .round_p_to_pdiv = pllm_round_p_to_pdiv,
5145         },
5146 };
5147
5148 static struct clk tegra_pll_m_out1 = {
5149         .name      = "pll_m_out1",
5150         .ops       = &tegra_pll_div_ops,
5151         .flags     = DIV_U71,
5152         .parent    = &tegra_pll_m,
5153         .reg       = 0x94,
5154         .reg_shift = 0,
5155         .max_rate  = 600000000,
5156 };
5157
5158 static struct clk_pll_freq_table tegra_pll_p_freq_table[] = {
5159         { 12000000, 216000000, 432, 12, 2, 8},
5160         { 13000000, 216000000, 432, 13, 2, 8},
5161         { 16800000, 216000000, 360, 14, 2, 8},
5162         { 19200000, 216000000, 360, 16, 2, 8},
5163         { 26000000, 216000000, 432, 26, 2, 8},
5164         { 0, 0, 0, 0, 0, 0 },
5165 };
5166
5167 static struct clk tegra_pll_p = {
5168         .name      = "pll_p",
5169         .flags     = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
5170         .ops       = &tegra_pllp_ops,
5171         .reg       = 0xa0,
5172         .parent    = &tegra_pll_ref,
5173         .max_rate  = 432000000,
5174         .u.pll = {
5175                 .input_min = 2000000,
5176                 .input_max = 31000000,
5177                 .cf_min    = 1000000,
5178                 .cf_max    = 6000000,
5179                 .vco_min   = 200000000,
5180                 .vco_max   = 700000000,
5181                 .freq_table = tegra_pll_p_freq_table,
5182                 .lock_delay = 300,
5183         },
5184 };
5185
5186 static struct clk tegra_pll_p_out1 = {
5187         .name      = "pll_p_out1",
5188         .ops       = &tegra_pll_div_ops,
5189         .flags     = DIV_U71 | DIV_U71_FIXED,
5190         .parent    = &tegra_pll_p,
5191         .reg       = 0xa4,
5192         .reg_shift = 0,
5193         .max_rate  = 432000000,
5194 };
5195
5196 static struct clk tegra_pll_p_out2 = {
5197         .name      = "pll_p_out2",
5198         .ops       = &tegra_pll_div_ops,
5199         .flags     = DIV_U71 | DIV_U71_FIXED,
5200         .parent    = &tegra_pll_p,
5201         .reg       = 0xa4,
5202         .reg_shift = 16,
5203         .max_rate  = 432000000,
5204 };
5205
5206 static struct clk tegra_pll_p_out3 = {
5207         .name      = "pll_p_out3",
5208         .ops       = &tegra_pll_div_ops,
5209         .flags     = DIV_U71 | DIV_U71_FIXED,
5210         .parent    = &tegra_pll_p,
5211         .reg       = 0xa8,
5212         .reg_shift = 0,
5213         .max_rate  = 432000000,
5214 };
5215
5216 static struct clk tegra_pll_p_out4 = {
5217         .name      = "pll_p_out4",
5218         .ops       = &tegra_pll_div_ops,
5219         .flags     = DIV_U71 | DIV_U71_FIXED,
5220         .parent    = &tegra_pll_p,
5221         .reg       = 0xa8,
5222         .reg_shift = 16,
5223         .max_rate  = 432000000,
5224 };
5225
5226 static struct clk_pll_freq_table tegra_pll_a_freq_table[] = {
5227         {  9600000, 282240000, 147,  5, 1, 4},
5228         {  9600000, 368640000, 192,  5, 1, 4},
5229         {  9600000, 240000000, 200,  8, 1, 8},
5230
5231         { 28800000, 282240000, 245, 25, 1, 8},
5232         { 28800000, 368640000, 320, 25, 1, 8},
5233         { 28800000, 240000000, 200, 24, 1, 8},
5234         { 0, 0, 0, 0, 0, 0 },
5235 };
5236
5237 static struct clk tegra_pll_a = {
5238         .name      = "pll_a",
5239         .flags     = PLL_HAS_CPCON,
5240         .ops       = &tegra_pll_ops,
5241         .reg       = 0xb0,
5242         .parent    = &tegra_pll_p_out1,
5243         .max_rate  = 700000000,
5244         .u.pll = {
5245                 .input_min = 2000000,
5246                 .input_max = 31000000,
5247                 .cf_min    = 1000000,
5248                 .cf_max    = 6000000,
5249                 .vco_min   = 200000000,
5250                 .vco_max   = 700000000,
5251                 .freq_table = tegra_pll_a_freq_table,
5252                 .lock_delay = 300,
5253         },
5254 };
5255
5256 static struct clk tegra_pll_a_out0 = {
5257         .name      = "pll_a_out0",
5258         .ops       = &tegra_pll_div_ops,
5259         .flags     = DIV_U71,
5260         .parent    = &tegra_pll_a,
5261         .reg       = 0xb4,
5262         .reg_shift = 0,
5263         .max_rate  = 100000000,
5264 };
5265
5266 static struct clk_pll_freq_table tegra_pll_d_freq_table[] = {
5267         { 12000000, 216000000, 864, 12, 4, 12},
5268         { 13000000, 216000000, 864, 13, 4, 12},
5269         { 16800000, 216000000, 720, 14, 4, 12},
5270         { 19200000, 216000000, 720, 16, 4, 12},
5271         { 26000000, 216000000, 864, 26, 4, 12},
5272
5273         { 12000000, 594000000, 594, 12, 1, 12},
5274         { 13000000, 594000000, 594, 13, 1, 12},
5275         { 16800000, 594000000, 495, 14, 1, 12},
5276         { 19200000, 594000000, 495, 16, 1, 12},
5277         { 26000000, 594000000, 594, 26, 1, 12},
5278
5279         { 12000000, 1000000000, 1000, 12, 1, 12},
5280         { 13000000, 1000000000, 1000, 13, 1, 12},
5281         { 19200000, 1000000000, 625,  12, 1, 12},
5282         { 26000000, 1000000000, 1000, 26, 1, 12},
5283
5284         { 0, 0, 0, 0, 0, 0 },
5285 };
5286
5287 static struct clk tegra_pll_d = {
5288         .name      = "pll_d",
5289         .flags     = PLL_HAS_CPCON | PLLD,
5290         .ops       = &tegra_plld_ops,
5291         .reg       = 0xd0,
5292         .parent    = &tegra_pll_ref,
5293         .max_rate  = 1000000000,
5294         .u.pll = {
5295                 .input_min = 2000000,
5296                 .input_max = 40000000,
5297                 .cf_min    = 1000000,
5298                 .cf_max    = 6000000,
5299                 .vco_min   = 500000000,
5300                 .vco_max   = 1000000000,
5301                 .freq_table = tegra_pll_d_freq_table,
5302                 .lock_delay = 1000,
5303                 .cpcon_default = 8,
5304         },
5305 };
5306
5307 static struct clk tegra_pll_d_out0 = {
5308         .name      = "pll_d_out0",
5309         .ops       = &tegra_pll_div_ops,
5310         .flags     = DIV_2 | PLLD,
5311         .parent    = &tegra_pll_d,
5312         .max_rate  = 500000000,
5313 };
5314
5315 static struct clk tegra_pll_d2 = {
5316         .name      = "pll_d2",
5317         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG | PLLD,
5318         .ops       = &tegra_plld_ops,
5319         .reg       = 0x4b8,
5320         .parent    = &tegra_pll_ref,
5321         .max_rate  = 1000000000,
5322         .u.pll = {
5323                 .input_min = 2000000,
5324                 .input_max = 40000000,
5325                 .cf_min    = 1000000,
5326                 .cf_max    = 6000000,
5327                 .vco_min   = 500000000,
5328                 .vco_max   = 1000000000,
5329                 .freq_table = tegra_pll_d_freq_table,
5330                 .lock_delay = 1000,
5331                 .cpcon_default = 12,
5332         },
5333 };
5334
5335 static struct clk tegra_pll_d2_out0 = {
5336         .name      = "pll_d2_out0",
5337         .ops       = &tegra_pll_div_ops,
5338         .flags     = DIV_2 | PLLD,
5339         .parent    = &tegra_pll_d2,
5340         .max_rate  = 500000000,
5341 };
5342
5343 static struct clk_pll_freq_table tegra_pll_u_freq_table[] = {
5344         { 12000000, 480000000, 960, 12, 2, 12},
5345         { 13000000, 480000000, 960, 13, 2, 12},
5346         { 16800000, 480000000, 400, 7,  2, 5},
5347         { 19200000, 480000000, 200, 4,  2, 3},
5348         { 26000000, 480000000, 960, 26, 2, 12},
5349         { 0, 0, 0, 0, 0, 0 },
5350 };
5351
5352 static struct clk tegra_pll_u = {
5353         .name      = "pll_u",
5354         .flags     = PLL_HAS_CPCON | PLLU,
5355         .ops       = &tegra_pll_ops,
5356         .reg       = 0xc0,
5357         .parent    = &tegra_pll_ref,
5358         .max_rate  = 480000000,
5359         .u.pll = {
5360                 .input_min = 2000000,
5361                 .input_max = 40000000,
5362                 .cf_min    = 1000000,
5363                 .cf_max    = 6000000,
5364                 .vco_min   = 480000000,
5365                 .vco_max   = 960000000,
5366                 .freq_table = tegra_pll_u_freq_table,
5367                 .lock_delay = 1000,
5368                 .cpcon_default = 12,
5369         },
5370 };
5371
5372 static struct clk tegra_pll_u_480M = {
5373         .name      = "pll_u_480M",
5374         .flags     = PLLU,
5375         .ops       = &tegra_pll_div_ops,
5376         .reg       = 0xc0,
5377         .reg_shift = 22,
5378         .parent    = &tegra_pll_u,
5379         .mul       = 1,
5380         .div       = 1,
5381         .max_rate  = 480000000,
5382 };
5383
5384 static struct clk tegra_pll_u_60M = {
5385         .name      = "pll_u_60M",
5386         .flags     = PLLU,
5387         .ops       = &tegra_pll_div_ops,
5388         .reg       = 0xc0,
5389         .reg_shift = 23,
5390         .parent    = &tegra_pll_u,
5391         .mul       = 1,
5392         .div       = 8,
5393         .max_rate  = 60000000,
5394 };
5395
5396 static struct clk tegra_pll_u_48M = {
5397         .name      = "pll_u_48M",
5398         .flags     = PLLU,
5399         .ops       = &tegra_pll_div_ops,
5400         .reg       = 0xc0,
5401         .reg_shift = 25,
5402         .parent    = &tegra_pll_u,
5403         .mul       = 1,
5404         .div       = 10,
5405         .max_rate  = 48000000,
5406 };
5407
5408 static struct clk tegra_pll_u_12M = {
5409         .name      = "pll_u_12M",
5410         .flags     = PLLU,
5411         .ops       = &tegra_pll_div_ops,
5412         .reg       = 0xc0,
5413         .reg_shift = 21,
5414         .parent    = &tegra_pll_u,
5415         .mul       = 1,
5416         .div       = 40,
5417         .max_rate  = 12000000,
5418 };
5419
5420 static struct clk_pll_freq_table tegra_pll_x_freq_table[] = {
5421         /* 1 GHz */
5422         { 12000000, 1000000000, 83, 1, 1},      /* actual: 996.0 MHz */
5423         { 13000000, 1000000000, 76, 1, 1},      /* actual: 988.0 MHz */
5424         { 16800000, 1000000000, 59, 1, 1},      /* actual: 991.2 MHz */
5425         { 19200000, 1000000000, 52, 1, 1},      /* actual: 998.4 MHz */
5426         { 26000000, 1000000000, 76, 2, 1},      /* actual: 988.0 MHz */
5427
5428         { 0, 0, 0, 0, 0, 0 },
5429 };
5430
5431 static struct clk tegra_pll_x = {
5432         .name      = "pll_x",
5433         .flags     = PLL_ALT_MISC_REG | PLLX,
5434         .ops       = &tegra_pllxc_ops,
5435         .reg       = 0xe0,
5436         .parent    = &tegra_pll_ref,
5437         .max_rate  = 1800000000,
5438         .u.pll = {
5439                 .input_min = 12000000,
5440                 .input_max = 800000000,
5441                 .cf_min    = 12000000,
5442                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
5443                 .vco_min   = 700000000,
5444                 .vco_max   = 2400000000U,
5445                 .freq_table = tegra_pll_x_freq_table,
5446                 .lock_delay = 300,
5447                 .misc1 = 0x510 - 0xe0,
5448                 .round_p_to_pdiv = pllxc_round_p_to_pdiv,
5449         },
5450 };
5451
5452 static struct clk tegra_pll_x_out0 = {
5453         .name      = "pll_x_out0",
5454         .ops       = &tegra_pll_div_ops,
5455         .flags     = DIV_2 | PLLX,
5456         .parent    = &tegra_pll_x,
5457         .max_rate  = 700000000,
5458 };
5459
5460 /* FIXME: remove; for now, should be always checked-in as "0" */
5461 #define USE_LP_CPU_TO_TEST_DFLL         0
5462
5463 static struct clk tegra_dfll_cpu = {
5464         .name      = "dfll_cpu",
5465         .flags     = DFLL,
5466         .ops       = &tegra_dfll_ops,
5467         .reg       = 0x2f4,
5468         .max_rate  = 2000000000,
5469 };
5470
5471 static struct clk tegra_pll_re_vco = {
5472         .name      = "pll_re_vco",
5473         .flags     = PLL_ALT_MISC_REG,
5474         .ops       = &tegra_pllre_ops,
5475         .reg       = 0x4c4,
5476         .parent    = &tegra_pll_ref,
5477         .max_rate  = 600000000,
5478         .u.pll = {
5479                 .input_min = 12000000,
5480                 .input_max = 1000000000,
5481                 .cf_min    = 12000000,
5482                 .cf_max    = 19200000,  /* s/w policy, h/w capability 38 MHz */
5483                 .vco_min   = 300000000,
5484                 .vco_max   = 600000000,
5485                 .lock_delay = 300,
5486                 .round_p_to_pdiv = pllre_round_p_to_pdiv,
5487         },
5488 };
5489
5490 static struct clk tegra_pll_re_out = {
5491         .name      = "pll_re_out",
5492         .ops       = &tegra_pllre_out_ops,
5493         .parent    = &tegra_pll_re_vco,
5494         .reg       = 0x4c4,
5495         .max_rate  = 600000000,
5496 };
5497
5498 static struct clk_pll_freq_table tegra_pll_e_freq_table[] = {
5499         /* PLLE special case: use cpcon field to store cml divider value */
5500         { 336000000, 100000000, 100, 21,  16, 11},
5501         { 312000000, 100000000, 200, 26,  24, 13},
5502         { 0, 0, 0, 0, 0, 0 },
5503 };
5504
5505 static struct clk tegra_pll_e = {
5506         .name      = "pll_e",
5507         .flags     = PLL_ALT_MISC_REG,
5508         .ops       = &tegra_plle_ops,
5509         .reg       = 0xe8,
5510         .max_rate  = 100000000,
5511         .u.pll = {
5512                 .input_min = 12000000,
5513                 .input_max = 1000000000,
5514                 .cf_min    = 12000000,
5515                 .cf_max    = 75000000,
5516                 .vco_min   = 1600000000,
5517                 .vco_max   = 2400000000U,
5518                 .freq_table = tegra_pll_e_freq_table,
5519                 .lock_delay = 300,
5520                 .fixed_rate = 100000000,
5521         },
5522 };
5523
5524 static struct clk tegra_pciex_clk = {
5525         .name      = "pciex",
5526         .parent    = &tegra_pll_e,
5527         .ops       = &tegra_pciex_clk_ops,
5528         .max_rate  = 100000000,
5529         .u.periph  = {
5530                 .clk_num   = 74,
5531         },
5532 };
5533
5534 /* Audio sync clocks */
5535 #define SYNC_SOURCE(_id, _dev)                          \
5536         {                                               \
5537                 .name      = #_id "_sync",              \
5538                 .lookup    = {                          \
5539                         .dev_id    = #_dev ,            \
5540                         .con_id    = "ext_audio_sync",  \
5541                 },                                      \
5542                 .rate      = 24000000,                  \
5543                 .max_rate  = 24000000,                  \
5544                 .ops       = &tegra_sync_source_ops     \
5545         }
5546 static struct clk tegra_sync_source_list[] = {
5547         SYNC_SOURCE(spdif_in, tegra30-spdif),
5548         SYNC_SOURCE(i2s0, tegra30-i2s.0),
5549         SYNC_SOURCE(i2s1, tegra30-i2s.1),
5550         SYNC_SOURCE(i2s2, tegra30-i2s.2),
5551         SYNC_SOURCE(i2s3, tegra30-i2s.3),
5552         SYNC_SOURCE(i2s4, tegra30-i2s.4),
5553         SYNC_SOURCE(vimclk, vimclk),
5554 };
5555
5556 static struct clk_mux_sel mux_d_audio_clk[] = {
5557         { .input = &tegra_pll_a_out0,           .value = 0},
5558         { .input = &tegra_pll_p,                .value = 0x8000},
5559         { .input = &tegra_clk_m,                .value = 0xc000},
5560         { .input = &tegra_sync_source_list[0],  .value = 0xE000},
5561         { .input = &tegra_sync_source_list[1],  .value = 0xE001},
5562         { .input = &tegra_sync_source_list[2],  .value = 0xE002},
5563         { .input = &tegra_sync_source_list[3],  .value = 0xE003},
5564         { .input = &tegra_sync_source_list[4],  .value = 0xE004},
5565         { .input = &tegra_sync_source_list[5],  .value = 0xE005},
5566         { .input = &tegra_pll_a_out0,           .value = 0xE006},
5567         { .input = &tegra_sync_source_list[6],  .value = 0xE007},
5568         { 0, 0 }
5569 };
5570
5571 static struct clk_mux_sel mux_audio_sync_clk[] =
5572 {
5573         { .input = &tegra_sync_source_list[0],  .value = 0},
5574         { .input = &tegra_sync_source_list[1],  .value = 1},
5575         { .input = &tegra_sync_source_list[2],  .value = 2},
5576         { .input = &tegra_sync_source_list[3],  .value = 3},
5577         { .input = &tegra_sync_source_list[4],  .value = 4},
5578         { .input = &tegra_sync_source_list[5],  .value = 5},
5579         { .input = &tegra_pll_a_out0,           .value = 6},
5580         { .input = &tegra_sync_source_list[6],  .value = 7},
5581         { 0, 0 }
5582 };
5583
5584 #define AUDIO_SYNC_CLK(_id, _dev, _index)                       \
5585         {                                               \
5586                 .name      = #_id,                      \
5587                 .lookup    = {                          \
5588                         .dev_id    = #_dev,             \
5589                         .con_id    = "audio_sync",      \
5590                 },                                      \
5591                 .inputs    = mux_audio_sync_clk,        \
5592                 .reg       = 0x4A0 + (_index) * 4,      \
5593                 .max_rate  = 24000000,                  \
5594                 .ops       = &tegra_audio_sync_clk_ops  \
5595         }
5596 static struct clk tegra_clk_audio_list[] = {
5597         AUDIO_SYNC_CLK(audio0, tegra30-i2s.0, 0),
5598         AUDIO_SYNC_CLK(audio1, tegra30-i2s.1, 1),
5599         AUDIO_SYNC_CLK(audio2, tegra30-i2s.2, 2),
5600         AUDIO_SYNC_CLK(audio3, tegra30-i2s.3, 3),
5601         AUDIO_SYNC_CLK(audio4, tegra30-i2s.4, 4),
5602         AUDIO_SYNC_CLK(audio, tegra30-spdif, 5),        /* SPDIF */
5603 };
5604
5605 #define AUDIO_SYNC_2X_CLK(_id, _dev, _index)                            \
5606         {                                                       \
5607                 .name      = #_id "_2x",                        \
5608                 .lookup    = {                                  \
5609                         .dev_id    = #_dev,                     \
5610                         .con_id    = "audio_sync_2x"            \
5611                 },                                              \
5612                 .flags     = PERIPH_NO_RESET,                   \
5613                 .max_rate  = 48000000,                          \
5614                 .ops       = &tegra_clk_double_ops,             \
5615                 .reg       = 0x49C,                             \
5616                 .reg_shift = 24 + (_index),                     \
5617                 .parent    = &tegra_clk_audio_list[(_index)],   \
5618                 .u.periph = {                                   \
5619                         .clk_num = 113 + (_index),              \
5620                 },                                              \
5621         }
5622 static struct clk tegra_clk_audio_2x_list[] = {
5623         AUDIO_SYNC_2X_CLK(audio0, tegra30-i2s.0, 0),
5624         AUDIO_SYNC_2X_CLK(audio1, tegra30-i2s.1, 1),
5625         AUDIO_SYNC_2X_CLK(audio2, tegra30-i2s.2, 2),
5626         AUDIO_SYNC_2X_CLK(audio3, tegra30-i2s.3, 3),
5627         AUDIO_SYNC_2X_CLK(audio4, tegra30-i2s.4, 4),
5628         AUDIO_SYNC_2X_CLK(audio, tegra30-spdif, 5),     /* SPDIF */
5629 };
5630
5631 #define MUX_I2S_SPDIF(_id, _index)                                      \
5632 static struct clk_mux_sel mux_pllaout0_##_id##_2x_pllp_clkm[] = {       \
5633         {.input = &tegra_pll_a_out0, .value = 0},                       \
5634         {.input = &tegra_clk_audio_2x_list[(_index)], .value = 1},      \
5635         {.input = &tegra_pll_p, .value = 2},                            \
5636         {.input = &tegra_clk_m, .value = 3},                            \
5637         { 0, 0},                                                        \
5638 }
5639 MUX_I2S_SPDIF(audio0, 0);
5640 MUX_I2S_SPDIF(audio1, 1);
5641 MUX_I2S_SPDIF(audio2, 2);
5642 MUX_I2S_SPDIF(audio3, 3);
5643 MUX_I2S_SPDIF(audio4, 4);
5644 MUX_I2S_SPDIF(audio, 5);                /* SPDIF */
5645
5646 /* External clock outputs (through PMC) */
5647 #define MUX_EXTERN_OUT(_id)                                             \
5648 static struct clk_mux_sel mux_clkm_clkm2_clkm4_extern##_id[] = {        \
5649         {.input = &tegra_clk_m,         .value = 0},                    \
5650         {.input = &tegra_clk_m_div2,    .value = 1},                    \
5651         {.input = &tegra_clk_m_div4,    .value = 2},                    \
5652         {.input = NULL,                 .value = 3}, /* placeholder */  \
5653         { 0, 0},                                                        \
5654 }
5655 MUX_EXTERN_OUT(1);
5656 MUX_EXTERN_OUT(2);
5657 MUX_EXTERN_OUT(3);
5658
5659 static struct clk_mux_sel *mux_extern_out_list[] = {
5660         mux_clkm_clkm2_clkm4_extern1,
5661         mux_clkm_clkm2_clkm4_extern2,
5662         mux_clkm_clkm2_clkm4_extern3,
5663 };
5664
5665 #define CLK_OUT_CLK(_id, _max_rate)                                     \
5666         {                                                       \
5667                 .name      = "clk_out_" #_id,                   \
5668                 .lookup    = {                                  \
5669                         .dev_id    = "clk_out_" #_id,           \
5670                         .con_id    = "extern" #_id,             \
5671                 },                                              \
5672                 .ops       = &tegra_clk_out_ops,                \
5673                 .reg       = 0x1a8,                             \
5674                 .inputs    = mux_clkm_clkm2_clkm4_extern##_id,  \
5675                 .flags     = MUX_CLK_OUT,                       \
5676                 .max_rate  = _max_rate,                         \
5677                 .u.periph = {                                   \
5678                         .clk_num   = (_id - 1) * 8 + 2,         \
5679                 },                                              \
5680         }
5681 static struct clk tegra_clk_out_list[] = {
5682         CLK_OUT_CLK(1, 12288000),
5683         CLK_OUT_CLK(2, 40800000),
5684         CLK_OUT_CLK(3, 12288000),
5685 };
5686
5687 /* called after peripheral external clocks are initialized */
5688 static void init_clk_out_mux(void)
5689 {
5690         int i;
5691         struct clk *c;
5692
5693         /* output clock con_id is the name of peripheral
5694            external clock connected to input 3 of the output mux */
5695         for (i = 0; i < ARRAY_SIZE(tegra_clk_out_list); i++) {
5696                 c = tegra_get_clock_by_name(
5697                         tegra_clk_out_list[i].lookup.con_id);
5698                 if (!c)
5699                         pr_err("%s: could not find clk %s\n", __func__,
5700                                tegra_clk_out_list[i].lookup.con_id);
5701                 mux_extern_out_list[i][3].input = c;
5702         }
5703 }
5704
5705 /* Peripheral muxes */
5706 static struct clk_mux_sel mux_cclk_g[] = {
5707         { .input = &tegra_clk_m,        .value = 0},
5708         { .input = &tegra_pll_c,        .value = 1},
5709         { .input = &tegra_clk_32k,      .value = 2},
5710         { .input = &tegra_pll_m,        .value = 3},
5711         { .input = &tegra_pll_p,        .value = 4},
5712         { .input = &tegra_pll_p_out4,   .value = 5},
5713         /* { .input = &tegra_pll_c2,    .value = 6}, - no use on tegra11x */
5714         /* { .input = &tegra_clk_c3,    .value = 7}, - no use on tegra11x */
5715         { .input = &tegra_pll_x,        .value = 8},
5716         { .input = &tegra_dfll_cpu,     .value = 15},
5717         { 0, 0},
5718 };
5719
5720 static struct clk_mux_sel mux_cclk_lp[] = {
5721         { .input = &tegra_clk_m,        .value = 0},
5722         { .input = &tegra_pll_c,        .value = 1},
5723         { .input = &tegra_clk_32k,      .value = 2},
5724         { .input = &tegra_pll_m,        .value = 3},
5725         { .input = &tegra_pll_p,        .value = 4},
5726         { .input = &tegra_pll_p_out4,   .value = 5},
5727         /* { .input = &tegra_pll_c2,    .value = 6}, - no use on tegra11x */
5728         /* { .input = &tegra_clk_c3,    .value = 7}, - no use on tegra11x */
5729         { .input = &tegra_pll_x_out0,   .value = 8},
5730 #if USE_LP_CPU_TO_TEST_DFLL
5731         { .input = &tegra_dfll_cpu,     .value = 15},
5732 #endif
5733         { .input = &tegra_pll_x,        .value = 8 | SUPER_LP_DIV2_BYPASS},
5734         { 0, 0},
5735 };
5736
5737 static struct clk_mux_sel mux_sclk[] = {
5738         { .input = &tegra_clk_m,        .value = 0},
5739         { .input = &tegra_pll_c_out1,   .value = 1},
5740         { .input = &tegra_pll_p_out4,   .value = 2},
5741         { .input = &tegra_pll_p_out3,   .value = 3},
5742         { .input = &tegra_pll_p_out2,   .value = 4},
5743         /* { .input = &tegra_clk_d,     .value = 5}, - no use on tegra11x */
5744         { .input = &tegra_clk_32k,      .value = 6},
5745         { .input = &tegra_pll_m_out1,   .value = 7},
5746         { 0, 0},
5747 };
5748
5749 static struct clk tegra_clk_cclk_g = {
5750         .name   = "cclk_g",
5751         .flags  = DIV_U71 | DIV_U71_INT | MUX,
5752         .inputs = mux_cclk_g,
5753         .reg    = 0x368,
5754         .ops    = &tegra_super_ops,
5755         .max_rate = 2000000000,
5756 };
5757
5758 static struct clk tegra_clk_cclk_lp = {
5759         .name   = "cclk_lp",
5760         .flags  = DIV_2 | DIV_U71 | DIV_U71_INT | MUX,
5761         .inputs = mux_cclk_lp,
5762         .reg    = 0x370,
5763         .ops    = &tegra_super_ops,
5764         .max_rate = 700000000,
5765 };
5766
5767 static struct clk tegra_clk_sclk = {
5768         .name   = "sclk",
5769         .inputs = mux_sclk,
5770         .reg    = 0x28,
5771         .ops    = &tegra_super_ops,
5772         .max_rate = 334000000,
5773         .min_rate = 12000000,
5774 };
5775
5776 static struct clk tegra_clk_virtual_cpu_g = {
5777         .name      = "cpu_g",
5778         .parent    = &tegra_clk_cclk_g,
5779         .ops       = &tegra_cpu_ops,
5780         .max_rate  = 2000000000,
5781         .u.cpu = {
5782                 .main      = &tegra_pll_x,
5783                 .backup    = &tegra_pll_p_out4,
5784                 .dynamic   = &tegra_dfll_cpu,
5785                 .mode      = MODE_G,
5786         },
5787 };
5788
5789 static struct clk tegra_clk_virtual_cpu_lp = {
5790         .name      = "cpu_lp",
5791         .parent    = &tegra_clk_cclk_lp,
5792         .ops       = &tegra_cpu_ops,
5793         .max_rate  = 700000000,
5794         .u.cpu = {
5795                 .main      = &tegra_pll_x,
5796                 .backup    = &tegra_pll_p_out4,
5797 #if USE_LP_CPU_TO_TEST_DFLL
5798                 .dynamic   = &tegra_dfll_cpu,
5799 #endif
5800                 .mode      = MODE_LP,
5801         },
5802 };
5803
5804 static struct clk_mux_sel mux_cpu_cmplx[] = {
5805         { .input = &tegra_clk_virtual_cpu_g,    .value = 0},
5806         { .input = &tegra_clk_virtual_cpu_lp,   .value = 1},
5807         { 0, 0},
5808 };
5809
5810 static struct clk tegra_clk_cpu_cmplx = {
5811         .name      = "cpu",
5812         .inputs    = mux_cpu_cmplx,
5813         .ops       = &tegra_cpu_cmplx_ops,
5814         .max_rate  = 2000000000,
5815 };
5816
5817 static struct clk tegra_clk_cop = {
5818         .name      = "cop",
5819         .parent    = &tegra_clk_sclk,
5820         .ops       = &tegra_cop_ops,
5821         .max_rate  = 334000000,
5822 };
5823
5824 static struct clk tegra_clk_hclk = {
5825         .name           = "hclk",
5826         .flags          = DIV_BUS,
5827         .parent         = &tegra_clk_sclk,
5828         .reg            = 0x30,
5829         .reg_shift      = 4,
5830         .ops            = &tegra_bus_ops,
5831         .max_rate       = 334000000,
5832         .min_rate       = 12000000,
5833 };
5834
5835 static struct clk tegra_clk_pclk = {
5836         .name           = "pclk",
5837         .flags          = DIV_BUS,
5838         .parent         = &tegra_clk_hclk,
5839         .reg            = 0x30,
5840         .reg_shift      = 0,
5841         .ops            = &tegra_bus_ops,
5842         .max_rate       = 167000000,
5843         .min_rate       = 12000000,
5844 };
5845
5846 static struct raw_notifier_head sbus_rate_change_nh;
5847
5848 static struct clk tegra_clk_sbus_cmplx = {
5849         .name      = "sbus",
5850         .parent    = &tegra_clk_sclk,
5851         .ops       = &tegra_sbus_cmplx_ops,
5852         .u.system  = {
5853                 .pclk = &tegra_clk_pclk,
5854                 .hclk = &tegra_clk_hclk,
5855                 .sclk_low = &tegra_pll_p_out2,
5856                 .sclk_high = &tegra_pll_m_out1,
5857         },
5858         .rate_change_nh = &sbus_rate_change_nh,
5859 };
5860
5861 static struct clk tegra_clk_blink = {
5862         .name           = "blink",
5863         .parent         = &tegra_clk_32k,
5864         .reg            = 0x40,
5865         .ops            = &tegra_blink_clk_ops,
5866         .max_rate       = 32768,
5867 };
5868
5869
5870 /* Multimedia modules muxes */
5871 static struct clk_mux_sel mux_pllm_pllc2_c_c3_pllp_plla[] = {
5872         { .input = &tegra_pll_m,  .value = 0},
5873         { .input = &tegra_pll_c2, .value = 1},
5874         { .input = &tegra_pll_c,  .value = 2},
5875         { .input = &tegra_pll_c3, .value = 3},
5876         { .input = &tegra_pll_p,  .value = 4},
5877         { .input = &tegra_pll_a_out0, .value = 6},
5878         { 0, 0},
5879 };
5880
5881 static struct clk_mux_sel mux_pllm_pllc_pllp_plla[] = {
5882         { .input = &tegra_pll_m, .value = 0},
5883         { .input = &tegra_pll_c, .value = 1},
5884         { .input = &tegra_pll_p, .value = 2},
5885         { .input = &tegra_pll_a_out0, .value = 3},
5886         { 0, 0},
5887 };
5888
5889 static struct clk_mux_sel mux_plla_pllc_pllp_clkm[] = {
5890         { .input = &tegra_pll_a_out0, .value = 0},
5891         { .input = &tegra_pll_c, .value = 1},
5892         { .input = &tegra_pll_p, .value = 2},
5893         { .input = &tegra_clk_m, .value = 3},
5894         { 0, 0},
5895 };
5896
5897 /* EMC muxes */
5898 /* FIXME: add EMC latency mux */
5899 static struct clk_mux_sel mux_pllm_pllc_pllp_clkm[] = {
5900         { .input = &tegra_pll_m, .value = 0},
5901         { .input = &tegra_pll_c, .value = 1},
5902         { .input = &tegra_pll_p, .value = 2},
5903         { .input = &tegra_clk_m, .value = 3},
5904         { .input = &tegra_pll_m, .value = 4}, /* low jitter PLLM input */
5905         { 0, 0},
5906 };
5907
5908
5909 /* Display subsystem muxes */
5910 static struct clk_mux_sel mux_pllp_pllm_plld_plla_pllc_plld2_clkm[] = {
5911         {.input = &tegra_pll_p, .value = 0},
5912         {.input = &tegra_pll_m, .value = 1},
5913         {.input = &tegra_pll_d_out0, .value = 2},
5914         {.input = &tegra_pll_a_out0, .value = 3},
5915         {.input = &tegra_pll_c, .value = 4},
5916         {.input = &tegra_pll_d2_out0, .value = 5},
5917         {.input = &tegra_clk_m, .value = 6},
5918         { 0, 0},
5919 };
5920
5921 static struct clk_mux_sel mux_plld_out0_plld2_out0[] = {
5922         { .input = &tegra_pll_d_out0,  .value = 0},
5923         { .input = &tegra_pll_d2_out0, .value = 1},
5924         { 0, 0},
5925 };
5926
5927 static struct clk_mux_sel mux_pllp_pllc_clkm[] = {
5928         {.input = &tegra_pll_p,     .value = 0},
5929         {.input = &tegra_pll_c,     .value = 1},
5930         {.input = &tegra_clk_m,     .value = 3},
5931         { 0, 0},
5932 };
5933
5934 /* Peripheral muxes */
5935 static struct clk_mux_sel mux_pllp_pllc2_c_c3_pllm_clkm[] = {
5936         { .input = &tegra_pll_p,  .value = 0},
5937         { .input = &tegra_pll_c2, .value = 1},
5938         { .input = &tegra_pll_c,  .value = 2},
5939         { .input = &tegra_pll_c3, .value = 3},
5940         { .input = &tegra_pll_m,  .value = 4},
5941         { .input = &tegra_clk_m,  .value = 6},
5942         { 0, 0},
5943 };
5944
5945 static struct clk_mux_sel mux_pllp_pllc_pllm_clkm[] = {
5946         { .input = &tegra_pll_p, .value = 0},
5947         { .input = &tegra_pll_c, .value = 1},
5948         { .input = &tegra_pll_m, .value = 2},
5949         { .input = &tegra_clk_m, .value = 3},
5950         { 0, 0},
5951 };
5952
5953 static struct clk_mux_sel mux_pllp_pllc_pllm[] = {
5954         {.input = &tegra_pll_p,     .value = 0},
5955         {.input = &tegra_pll_c,     .value = 1},
5956         {.input = &tegra_pll_m,     .value = 2},
5957         { 0, 0},
5958 };
5959
5960 static struct clk_mux_sel mux_pllp_clkm[] = {
5961         { .input = &tegra_pll_p, .value = 0},
5962         { .input = &tegra_clk_m, .value = 3},
5963         { 0, 0},
5964 };
5965
5966 static struct clk_mux_sel mux_pllp_pllc_clk32_clkm[] = {
5967         {.input = &tegra_pll_p,     .value = 0},
5968         {.input = &tegra_pll_c,     .value = 1},
5969         {.input = &tegra_clk_32k,   .value = 2},
5970         {.input = &tegra_clk_m,     .value = 3},
5971         { 0, 0},
5972 };
5973
5974 static struct clk_mux_sel mux_pllp_pllc_clkm_clk32[] = {
5975         {.input = &tegra_pll_p,     .value = 0},
5976         {.input = &tegra_pll_c,     .value = 1},
5977         {.input = &tegra_clk_m,     .value = 2},
5978         {.input = &tegra_clk_32k,   .value = 3},
5979         { 0, 0},
5980 };
5981
5982 static struct clk_mux_sel mux_plla_clk32_pllp_clkm_plle[] = {
5983         { .input = &tegra_pll_a_out0, .value = 0},
5984         { .input = &tegra_clk_32k,    .value = 1},
5985         { .input = &tegra_pll_p,      .value = 2},
5986         { .input = &tegra_clk_m,      .value = 3},
5987         { .input = &tegra_pll_e,      .value = 4},
5988         { 0, 0},
5989 };
5990
5991 static struct clk_mux_sel mux_clkm_pllp_pllc_pllre[] = {
5992         { .input = &tegra_clk_m,  .value = 0},
5993         { .input = &tegra_pll_p,  .value = 1},
5994         { .input = &tegra_pll_c,  .value = 3},
5995         { .input = &tegra_pll_re_out,  .value = 5},
5996         { 0, 0},
5997 };
5998
5999 static struct clk_mux_sel mux_clkm_48M_pllp_480M[] = {
6000         { .input = &tegra_clk_m,      .value = 0},
6001         { .input = &tegra_pll_u_48M,  .value = 1},
6002         { .input = &tegra_pll_p,      .value = 2},
6003         { .input = &tegra_pll_u_480M, .value = 3},
6004         { 0, 0},
6005 };
6006
6007 static struct clk_mux_sel mux_clkm_pllre_clk32_480M_pllc_ref[] = {
6008         { .input = &tegra_clk_m,      .value = 0},
6009         { .input = &tegra_pll_re_out, .value = 1},
6010         { .input = &tegra_clk_32k,    .value = 2},
6011         { .input = &tegra_pll_u_480M, .value = 3},
6012         { .input = &tegra_pll_c,      .value = 4},
6013         { .input = &tegra_pll_ref,    .value = 7},
6014         { 0, 0},
6015 };
6016
6017 /* Single clock source ("fake") muxes */
6018 static struct clk_mux_sel mux_clk_m[] = {
6019         { .input = &tegra_clk_m, .value = 0},
6020         { 0, 0},
6021 };
6022
6023 static struct clk_mux_sel mux_pllp_out3[] = {
6024         { .input = &tegra_pll_p_out3, .value = 0},
6025         { 0, 0},
6026 };
6027
6028 static struct clk_mux_sel mux_clk_32k[] = {
6029         { .input = &tegra_clk_32k, .value = 0},
6030         { 0, 0},
6031 };
6032
6033 /* xusb_hs has an alternative source, that is not used - therefore, xusb_hs
6034    is modeled as a single source mux */
6035 static struct clk_mux_sel mux_pllu_60M[] = {
6036         { .input = &tegra_pll_u_60M, .value = 1},
6037         { 0, 0},
6038 };
6039
6040 static struct raw_notifier_head emc_rate_change_nh;
6041
6042 static struct clk tegra_clk_emc = {
6043         .name = "emc",
6044         .ops = &tegra_emc_clk_ops,
6045         .reg = 0x19c,
6046         .max_rate = 800000000,
6047         .min_rate = 12750000,
6048         .inputs = mux_pllm_pllc_pllp_clkm,
6049         .flags = MUX | MUX8 | DIV_U71 | PERIPH_EMC_ENB,
6050         .u.periph = {
6051                 .clk_num = 57,
6052         },
6053         .rate_change_nh = &emc_rate_change_nh,
6054 };
6055
6056 #ifdef CONFIG_TEGRA_DUAL_CBUS
6057 static struct clk tegra_clk_c2bus = {
6058         .name      = "c2bus",
6059         .parent    = &tegra_pll_c2,
6060         .ops       = &tegra_clk_cbus_ops,
6061         .max_rate  = 600000000,
6062         .mul       = 1,
6063         .div       = 1,
6064         .flags     = PERIPH_ON_CBUS,
6065         .shared_bus_backup = {
6066                 .input = &tegra_pll_p,
6067        }
6068 };
6069 static struct clk tegra_clk_c3bus = {
6070         .name      = "c3bus",
6071         .parent    = &tegra_pll_c3,
6072         .ops       = &tegra_clk_cbus_ops,
6073         .max_rate  = 600000000,
6074         .mul       = 1,
6075         .div       = 1,
6076         .flags     = PERIPH_ON_CBUS,
6077         .shared_bus_backup = {