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