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