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