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