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