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