ARM: tegra11: clock: Remove ISO BW double scaling
[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 val, divu71;
3732                 if (c->parent->state == OFF)
3733                         c->ops->disable(c);
3734
3735                 val = clk_readl(c->reg);
3736                 val >>= c->reg_shift;
3737                 c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
3738                 if (!(val & PLL_OUT_RESET_DISABLE))
3739                         c->state = OFF;
3740
3741                 if (c->u.pll_div.default_rate) {
3742                         int ret = tegra11_pll_div_clk_set_rate(
3743                                         c, c->u.pll_div.default_rate);
3744                         if (!ret)
3745                                 return;
3746                 }
3747                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
3748                 c->div = (divu71 + 2);
3749                 c->mul = 2;
3750         } else if (c->flags & DIV_2) {
3751                 c->state = ON;
3752                 if (c->flags & (PLLD | PLLX)) {
3753                         c->div = 2;
3754                         c->mul = 1;
3755                 }
3756                 else
3757                         BUG();
3758         } else if (c->flags & PLLU) {
3759                 u32 val = clk_readl(c->reg);
3760                 c->state = val & (0x1 << c->reg_shift) ? ON : OFF;
3761         } else {
3762                 c->state = ON;
3763                 c->div = 1;
3764                 c->mul = 1;
3765         }
3766 }
3767
3768 static int tegra11_pll_div_clk_enable(struct clk *c)
3769 {
3770         u32 val;
3771         u32 new_val;
3772         unsigned long flags;
3773
3774         pr_debug("%s: %s\n", __func__, c->name);
3775         if (c->flags & DIV_U71) {
3776                 spin_lock_irqsave(&pll_div_lock, flags);
3777                 val = clk_readl(c->reg);
3778                 new_val = val >> c->reg_shift;
3779                 new_val &= 0xFFFF;
3780
3781                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
3782
3783                 val &= ~(0xFFFF << c->reg_shift);
3784                 val |= new_val << c->reg_shift;
3785                 clk_writel_delay(val, c->reg);
3786                 spin_unlock_irqrestore(&pll_div_lock, flags);
3787                 return 0;
3788         } else if (c->flags & DIV_2) {
3789                 return 0;
3790         } else if (c->flags & PLLU) {
3791                 clk_lock_save(c->parent, &flags);
3792                 val = clk_readl(c->reg) | (0x1 << c->reg_shift);
3793                 clk_writel_delay(val, c->reg);
3794                 clk_unlock_restore(c->parent, &flags);
3795                 return 0;
3796         }
3797         return -EINVAL;
3798 }
3799
3800 static void tegra11_pll_div_clk_disable(struct clk *c)
3801 {
3802         u32 val;
3803         u32 new_val;
3804         unsigned long flags;
3805
3806         pr_debug("%s: %s\n", __func__, c->name);
3807         if (c->flags & DIV_U71) {
3808                 spin_lock_irqsave(&pll_div_lock, flags);
3809                 val = clk_readl(c->reg);
3810                 new_val = val >> c->reg_shift;
3811                 new_val &= 0xFFFF;
3812
3813                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
3814
3815                 val &= ~(0xFFFF << c->reg_shift);
3816                 val |= new_val << c->reg_shift;
3817                 clk_writel_delay(val, c->reg);
3818                 spin_unlock_irqrestore(&pll_div_lock, flags);
3819         } else if (c->flags & PLLU) {
3820                 clk_lock_save(c->parent, &flags);
3821                 val = clk_readl(c->reg) & (~(0x1 << c->reg_shift));
3822                 clk_writel_delay(val, c->reg);
3823                 clk_unlock_restore(c->parent, &flags);
3824         }
3825 }
3826
3827 static int tegra11_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
3828 {
3829         u32 val;
3830         u32 new_val;
3831         int divider_u71;
3832         unsigned long parent_rate = clk_get_rate(c->parent);
3833         unsigned long flags;
3834
3835         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3836         if (c->flags & DIV_U71) {
3837                 divider_u71 = clk_div71_get_divider(
3838                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3839                 if (divider_u71 >= 0) {
3840                         spin_lock_irqsave(&pll_div_lock, flags);
3841                         val = clk_readl(c->reg);
3842                         new_val = val >> c->reg_shift;
3843                         new_val &= 0xFFFF;
3844                         if (c->flags & DIV_U71_FIXED)
3845                                 new_val |= PLL_OUT_OVERRIDE;
3846                         new_val &= ~PLL_OUT_RATIO_MASK;
3847                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
3848
3849                         val &= ~(0xFFFF << c->reg_shift);
3850                         val |= new_val << c->reg_shift;
3851                         clk_writel_delay(val, c->reg);
3852                         c->div = divider_u71 + 2;
3853                         c->mul = 2;
3854                         spin_unlock_irqrestore(&pll_div_lock, flags);
3855                         return 0;
3856                 }
3857         } else if (c->flags & DIV_2)
3858                 return clk_set_rate(c->parent, rate * 2);
3859
3860         return -EINVAL;
3861 }
3862
3863 static long tegra11_pll_div_clk_round_rate(struct clk *c, unsigned long rate)
3864 {
3865         int divider;
3866         unsigned long parent_rate = clk_get_rate(c->parent);
3867         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3868
3869         if (c->flags & DIV_U71) {
3870                 divider = clk_div71_get_divider(
3871                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3872                 if (divider < 0)
3873                         return divider;
3874                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
3875         } else if (c->flags & DIV_2)
3876                 /* no rounding - fixed DIV_2 dividers pass rate to parent PLL */
3877                 return rate;
3878
3879         return -EINVAL;
3880 }
3881
3882 static struct clk_ops tegra_pll_div_ops = {
3883         .init                   = tegra11_pll_div_clk_init,
3884         .enable                 = tegra11_pll_div_clk_enable,
3885         .disable                = tegra11_pll_div_clk_disable,
3886         .set_rate               = tegra11_pll_div_clk_set_rate,
3887         .round_rate             = tegra11_pll_div_clk_round_rate,
3888 };
3889
3890 /* Periph clk ops */
3891 static inline u32 periph_clk_source_mask(struct clk *c)
3892 {
3893         if (c->u.periph.src_mask)
3894                 return c->u.periph.src_mask;
3895         else if (c->flags & MUX8)
3896                 return 7 << 29;
3897         else if (c->flags & MUX_PWM)
3898                 return 3 << 28;
3899         else if (c->flags & MUX_CLK_OUT)
3900                 return 3 << (c->u.periph.clk_num + 4);
3901         else if (c->flags & PLLD)
3902                 return PLLD_BASE_DSI_MUX_MASK;
3903         else
3904                 return 3 << 30;
3905 }
3906
3907 static inline u32 periph_clk_source_shift(struct clk *c)
3908 {
3909         if (c->u.periph.src_shift)
3910                 return c->u.periph.src_shift;
3911         else if (c->flags & MUX8)
3912                 return 29;
3913         else if (c->flags & MUX_PWM)
3914                 return 28;
3915         else if (c->flags & MUX_CLK_OUT)
3916                 return c->u.periph.clk_num + 4;
3917         else if (c->flags & PLLD)
3918                 return PLLD_BASE_DSI_MUX_SHIFT;
3919         else
3920                 return 30;
3921 }
3922
3923 static void tegra11_periph_clk_init(struct clk *c)
3924 {
3925         u32 val = clk_readl(c->reg);
3926         const struct clk_mux_sel *mux = 0;
3927         const struct clk_mux_sel *sel;
3928         if (c->flags & MUX) {
3929                 for (sel = c->inputs; sel->input != NULL; sel++) {
3930                         if (((val & periph_clk_source_mask(c)) >>
3931                             periph_clk_source_shift(c)) == sel->value)
3932                                 mux = sel;
3933                 }
3934                 BUG_ON(!mux);
3935
3936                 c->parent = mux->input;
3937         } else {
3938                 if (c->flags & PLLU) {
3939                         /* for xusb_hs clock enforce PLLU source during init */
3940                         val &= ~periph_clk_source_mask(c);
3941                         val |= c->inputs[0].value << periph_clk_source_shift(c);
3942                         clk_writel_delay(val, c->reg);
3943                 }
3944                 c->parent = c->inputs[0].input;
3945         }
3946
3947         if (c->flags & DIV_U71) {
3948                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
3949                 if (c->flags & DIV_U71_IDLE) {
3950                         val &= ~(PERIPH_CLK_SOURCE_DIVU71_MASK <<
3951                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
3952                         val |= (PERIPH_CLK_SOURCE_DIVIDLE_VAL <<
3953                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
3954                         clk_writel(val, c->reg);
3955                 }
3956                 c->div = divu71 + 2;
3957                 c->mul = 2;
3958         } else if (c->flags & DIV_U151) {
3959                 u32 divu151 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
3960                 if ((c->flags & DIV_U151_UART) &&
3961                     (!(val & PERIPH_CLK_UART_DIV_ENB))) {
3962                         divu151 = 0;
3963                 }
3964                 c->div = divu151 + 2;
3965                 c->mul = 2;
3966         } else if (c->flags & DIV_U16) {
3967                 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
3968                 c->div = divu16 + 1;
3969                 c->mul = 1;
3970         } else {
3971                 c->div = 1;
3972                 c->mul = 1;
3973         }
3974
3975         if (c->flags & PERIPH_NO_ENB) {
3976                 c->state = c->parent->state;
3977                 return;
3978         }
3979
3980         c->state = ON;
3981
3982         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
3983                 c->state = OFF;
3984         if (!(c->flags & PERIPH_NO_RESET))
3985                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c))
3986                         c->state = OFF;
3987 }
3988
3989 static int tegra11_periph_clk_enable(struct clk *c)
3990 {
3991         unsigned long flags;
3992         pr_debug("%s on clock %s\n", __func__, c->name);
3993
3994         if (c->flags & PERIPH_NO_ENB)
3995                 return 0;
3996
3997         spin_lock_irqsave(&periph_refcount_lock, flags);
3998
3999         tegra_periph_clk_enable_refcount[c->u.periph.clk_num]++;
4000         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] > 1) {
4001                 spin_unlock_irqrestore(&periph_refcount_lock, flags);
4002                 return 0;
4003         }
4004
4005         clk_writel_delay(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_SET_REG(c));
4006         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET)) {
4007                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c)) {
4008                         udelay(5);      /* reset propagation delay */
4009                         clk_writel(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_RST_CLR_REG(c));
4010                 }
4011         }
4012         spin_unlock_irqrestore(&periph_refcount_lock, flags);
4013         return 0;
4014 }
4015
4016 static void tegra11_periph_clk_disable(struct clk *c)
4017 {
4018         unsigned long val, flags;
4019         pr_debug("%s on clock %s\n", __func__, c->name);
4020
4021         if (c->flags & PERIPH_NO_ENB)
4022                 return;
4023
4024         spin_lock_irqsave(&periph_refcount_lock, flags);
4025
4026         if (c->refcnt)
4027                 tegra_periph_clk_enable_refcount[c->u.periph.clk_num]--;
4028
4029         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] == 0) {
4030                 /* If peripheral is in the APB bus then read the APB bus to
4031                  * flush the write operation in apb bus. This will avoid the
4032                  * peripheral access after disabling clock*/
4033                 if (c->flags & PERIPH_ON_APB)
4034                         val = chipid_readl();
4035
4036                 clk_writel_delay(
4037                         PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_CLR_REG(c));
4038         }
4039         spin_unlock_irqrestore(&periph_refcount_lock, flags);
4040 }
4041
4042 static void tegra11_periph_clk_reset(struct clk *c, bool assert)
4043 {
4044         unsigned long val;
4045         pr_debug("%s %s on clock %s\n", __func__,
4046                  assert ? "assert" : "deassert", c->name);
4047
4048         if (c->flags & PERIPH_NO_ENB)
4049                 return;
4050
4051         if (!(c->flags & PERIPH_NO_RESET)) {
4052                 if (assert) {
4053                         /* If peripheral is in the APB bus then read the APB
4054                          * bus to flush the write operation in apb bus. This
4055                          * will avoid the peripheral access after disabling
4056                          * clock */
4057                         if (c->flags & PERIPH_ON_APB)
4058                                 val = chipid_readl();
4059
4060                         clk_writel(PERIPH_CLK_TO_BIT(c),
4061                                    PERIPH_CLK_TO_RST_SET_REG(c));
4062                 } else
4063                         clk_writel(PERIPH_CLK_TO_BIT(c),
4064                                    PERIPH_CLK_TO_RST_CLR_REG(c));
4065         }
4066 }
4067
4068 static int tegra11_periph_clk_set_parent(struct clk *c, struct clk *p)
4069 {
4070         u32 val;
4071         const struct clk_mux_sel *sel;
4072         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
4073
4074         if (!(c->flags & MUX))
4075                 return (p == c->parent) ? 0 : (-EINVAL);
4076
4077         for (sel = c->inputs; sel->input != NULL; sel++) {
4078                 if (sel->input == p) {
4079                         val = clk_readl(c->reg);
4080                         val &= ~periph_clk_source_mask(c);
4081                         val |= (sel->value << periph_clk_source_shift(c));
4082
4083                         if (c->refcnt)
4084                                 clk_enable(p);
4085
4086                         clk_writel_delay(val, c->reg);
4087
4088                         if (c->refcnt && c->parent)
4089                                 clk_disable(c->parent);
4090
4091                         clk_reparent(c, p);
4092                         return 0;
4093                 }
4094         }
4095
4096         return -EINVAL;
4097 }
4098
4099 static int tegra11_periph_clk_set_rate(struct clk *c, unsigned long rate)
4100 {
4101         u32 val;
4102         int divider;
4103         unsigned long parent_rate = clk_get_rate(c->parent);
4104
4105         if (c->flags & DIV_U71) {
4106                 divider = clk_div71_get_divider(
4107                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
4108                 if (divider >= 0) {
4109                         val = clk_readl(c->reg);
4110                         val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
4111                         val |= divider;
4112                         clk_writel_delay(val, c->reg);
4113                         c->div = divider + 2;
4114                         c->mul = 2;
4115                         return 0;
4116                 }
4117         } else if (c->flags & DIV_U151) {
4118                 divider = clk_div151_get_divider(
4119                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
4120                 if (divider >= 0) {
4121                         val = clk_readl(c->reg);
4122                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
4123                         val |= divider;
4124                         if (c->flags & DIV_U151_UART) {
4125                                 if (divider)
4126                                         val |= PERIPH_CLK_UART_DIV_ENB;
4127                                 else
4128                                         val &= ~PERIPH_CLK_UART_DIV_ENB;
4129                         }
4130                         clk_writel_delay(val, c->reg);
4131                         c->div = divider + 2;
4132                         c->mul = 2;
4133                         return 0;
4134                 }
4135         } else if (c->flags & DIV_U16) {
4136                 divider = clk_div16_get_divider(parent_rate, rate);
4137                 if (divider >= 0) {
4138                         val = clk_readl(c->reg);
4139                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
4140                         val |= divider;
4141                         clk_writel_delay(val, c->reg);
4142                         c->div = divider + 1;
4143                         c->mul = 1;
4144                         return 0;
4145                 }
4146         } else if (parent_rate <= rate) {
4147                 c->div = 1;
4148                 c->mul = 1;
4149                 return 0;
4150         }
4151         return -EINVAL;
4152 }
4153
4154 static long tegra11_periph_clk_round_rate(struct clk *c,
4155         unsigned long rate)
4156 {
4157         int divider;
4158         unsigned long parent_rate = clk_get_rate(c->parent);
4159         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
4160
4161         if (c->flags & DIV_U71) {
4162                 divider = clk_div71_get_divider(
4163                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
4164                 if (divider < 0)
4165                         return divider;
4166
4167                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
4168         } else if (c->flags & DIV_U151) {
4169                 divider = clk_div151_get_divider(
4170                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
4171                 if (divider < 0)
4172                         return divider;
4173
4174                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
4175         } else if (c->flags & DIV_U16) {
4176                 divider = clk_div16_get_divider(parent_rate, rate);
4177                 if (divider < 0)
4178                         return divider;
4179                 return DIV_ROUND_UP(parent_rate, divider + 1);
4180         }
4181         return -EINVAL;
4182 }
4183
4184 static struct clk_ops tegra_periph_clk_ops = {
4185         .init                   = &tegra11_periph_clk_init,
4186         .enable                 = &tegra11_periph_clk_enable,
4187         .disable                = &tegra11_periph_clk_disable,
4188         .set_parent             = &tegra11_periph_clk_set_parent,
4189         .set_rate               = &tegra11_periph_clk_set_rate,
4190         .round_rate             = &tegra11_periph_clk_round_rate,
4191         .reset                  = &tegra11_periph_clk_reset,
4192 };
4193
4194
4195 #if !defined(CONFIG_TEGRA_SIMULATION_PLATFORM)
4196 /* msenc clock propagation WAR for bug 1005168 */
4197 static int tegra11_msenc_clk_enable(struct clk *c)
4198 {
4199         int ret = tegra11_periph_clk_enable(c);
4200         if (ret)
4201                 return ret;
4202
4203         clk_writel(0, LVL2_CLK_GATE_OVRE);
4204         clk_writel(0x00400000, LVL2_CLK_GATE_OVRE);
4205         udelay(1);
4206         clk_writel(0, LVL2_CLK_GATE_OVRE);
4207         return 0;
4208 }
4209
4210 static struct clk_ops tegra_msenc_clk_ops = {
4211         .init                   = &tegra11_periph_clk_init,
4212         .enable                 = &tegra11_msenc_clk_enable,
4213         .disable                = &tegra11_periph_clk_disable,
4214         .set_parent             = &tegra11_periph_clk_set_parent,
4215         .set_rate               = &tegra11_periph_clk_set_rate,
4216         .round_rate             = &tegra11_periph_clk_round_rate,
4217         .reset                  = &tegra11_periph_clk_reset,
4218 };
4219 #endif
4220 /* Periph extended clock configuration ops */
4221 static int
4222 tegra11_vi_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
4223 {
4224         if (p == TEGRA_CLK_VI_INP_SEL) {
4225                 u32 val = clk_readl(c->reg);
4226                 val &= ~PERIPH_CLK_VI_SEL_EX_MASK;
4227                 val |= (setting << PERIPH_CLK_VI_SEL_EX_SHIFT) &
4228                         PERIPH_CLK_VI_SEL_EX_MASK;
4229                 clk_writel(val, c->reg);
4230                 return 0;
4231         }
4232         return -EINVAL;
4233 }
4234
4235 static struct clk_ops tegra_vi_clk_ops = {
4236         .init                   = &tegra11_periph_clk_init,
4237         .enable                 = &tegra11_periph_clk_enable,
4238         .disable                = &tegra11_periph_clk_disable,
4239         .set_parent             = &tegra11_periph_clk_set_parent,
4240         .set_rate               = &tegra11_periph_clk_set_rate,
4241         .round_rate             = &tegra11_periph_clk_round_rate,
4242         .clk_cfg_ex             = &tegra11_vi_clk_cfg_ex,
4243         .reset                  = &tegra11_periph_clk_reset,
4244 };
4245
4246 static int
4247 tegra11_nand_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
4248 {
4249         if (p == TEGRA_CLK_NAND_PAD_DIV2_ENB) {
4250                 u32 val = clk_readl(c->reg);
4251                 if (setting)
4252                         val |= PERIPH_CLK_NAND_DIV_EX_ENB;
4253                 else
4254                         val &= ~PERIPH_CLK_NAND_DIV_EX_ENB;
4255                 clk_writel(val, c->reg);
4256                 return 0;
4257         }
4258         return -EINVAL;
4259 }
4260
4261 static struct clk_ops tegra_nand_clk_ops = {
4262         .init                   = &tegra11_periph_clk_init,
4263         .enable                 = &tegra11_periph_clk_enable,
4264         .disable                = &tegra11_periph_clk_disable,
4265         .set_parent             = &tegra11_periph_clk_set_parent,
4266         .set_rate               = &tegra11_periph_clk_set_rate,
4267         .round_rate             = &tegra11_periph_clk_round_rate,
4268         .clk_cfg_ex             = &tegra11_nand_clk_cfg_ex,
4269         .reset                  = &tegra11_periph_clk_reset,
4270 };
4271
4272
4273 static int
4274 tegra11_dtv_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
4275 {
4276         if (p == TEGRA_CLK_DTV_INVERT) {
4277                 u32 val = clk_readl(c->reg);
4278                 if (setting)
4279                         val |= PERIPH_CLK_DTV_POLARITY_INV;
4280                 else
4281                         val &= ~PERIPH_CLK_DTV_POLARITY_INV;
4282                 clk_writel(val, c->reg);
4283                 return 0;
4284         }
4285         return -EINVAL;
4286 }
4287
4288 static struct clk_ops tegra_dtv_clk_ops = {
4289         .init                   = &tegra11_periph_clk_init,
4290         .enable                 = &tegra11_periph_clk_enable,
4291         .disable                = &tegra11_periph_clk_disable,
4292         .set_parent             = &tegra11_periph_clk_set_parent,
4293         .set_rate               = &tegra11_periph_clk_set_rate,
4294         .round_rate             = &tegra11_periph_clk_round_rate,
4295         .clk_cfg_ex             = &tegra11_dtv_clk_cfg_ex,
4296         .reset                  = &tegra11_periph_clk_reset,
4297 };
4298
4299 static int tegra11_dsi_clk_set_parent(struct clk *c, struct clk *p)
4300 {
4301         const struct clk_mux_sel *sel;
4302         struct clk *d = tegra_get_clock_by_name("pll_d");
4303         if (c->reg != d->reg)
4304                 d = tegra_get_clock_by_name("pll_d2");
4305
4306         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
4307
4308         for (sel = c->inputs; sel->input != NULL; sel++) {
4309                 if (sel->input == p) {
4310                         if (c->refcnt)
4311                                 clk_enable(p);
4312
4313                         /* The DSI parent selection bit is in PLLD base
4314                            register - can not do direct r-m-w, must be
4315                            protected by PLLD lock */
4316                         tegra_clk_cfg_ex(
4317                                 d, TEGRA_CLK_PLLD_MIPI_MUX_SEL, sel->value);
4318
4319                         if (c->refcnt && c->parent)
4320                                 clk_disable(c->parent);
4321
4322                         clk_reparent(c, p);
4323                         return 0;
4324                 }
4325         }
4326
4327         return -EINVAL;
4328 }
4329
4330 static struct clk_ops tegra_dsi_clk_ops = {
4331         .init                   = &tegra11_periph_clk_init,
4332         .enable                 = &tegra11_periph_clk_enable,
4333         .disable                = &tegra11_periph_clk_disable,
4334         .set_parent             = &tegra11_dsi_clk_set_parent,
4335         .set_rate               = &tegra11_periph_clk_set_rate,
4336         .round_rate             = &tegra11_periph_clk_round_rate,
4337         .reset                  = &tegra11_periph_clk_reset,
4338 };
4339
4340 /* xusb common clock gate - enabled on init and never disabled */
4341 static void tegra11_xusb_gate_clk_init(struct clk *c)
4342 {
4343         tegra11_periph_clk_enable(c);
4344 }
4345
4346 static struct clk_ops tegra_xusb_gate_clk_ops = {
4347         .init    = tegra11_xusb_gate_clk_init,
4348 };
4349
4350 /* pciex clock support only reset function */
4351 static struct clk_ops tegra_pciex_clk_ops = {
4352         .reset    = tegra11_periph_clk_reset,
4353 };
4354
4355 /* Output clock ops */
4356
4357 static DEFINE_SPINLOCK(clk_out_lock);
4358
4359 static void tegra11_clk_out_init(struct clk *c)
4360 {
4361         const struct clk_mux_sel *mux = 0;
4362         const struct clk_mux_sel *sel;
4363         u32 val = pmc_readl(c->reg);
4364
4365         c->state = (val & (0x1 << c->u.periph.clk_num)) ? ON : OFF;
4366         c->mul = 1;
4367         c->div = 1;
4368
4369         for (sel = c->inputs; sel->input != NULL; sel++) {
4370                 if (((val & periph_clk_source_mask(c)) >>
4371                      periph_clk_source_shift(c)) == sel->value)
4372                         mux = sel;
4373         }
4374         BUG_ON(!mux);
4375         c->parent = mux->input;
4376 }
4377
4378 static int tegra11_clk_out_enable(struct clk *c)
4379 {
4380         u32 val;
4381         unsigned long flags;
4382
4383         pr_debug("%s on clock %s\n", __func__, c->name);
4384
4385         spin_lock_irqsave(&clk_out_lock, flags);
4386         val = pmc_readl(c->reg);
4387         val |= (0x1 << c->u.periph.clk_num);
4388         pmc_writel(val, c->reg);
4389         spin_unlock_irqrestore(&clk_out_lock, flags);
4390
4391         return 0;
4392 }
4393
4394 static void tegra11_clk_out_disable(struct clk *c)
4395 {
4396         u32 val;
4397         unsigned long flags;
4398
4399         pr_debug("%s on clock %s\n", __func__, c->name);
4400
4401         spin_lock_irqsave(&clk_out_lock, flags);
4402         val = pmc_readl(c->reg);
4403         val &= ~(0x1 << c->u.periph.clk_num);
4404         pmc_writel(val, c->reg);
4405         spin_unlock_irqrestore(&clk_out_lock, flags);
4406 }
4407
4408 static int tegra11_clk_out_set_parent(struct clk *c, struct clk *p)
4409 {
4410         u32 val;
4411         unsigned long flags;
4412         const struct clk_mux_sel *sel;
4413
4414         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
4415
4416         for (sel = c->inputs; sel->input != NULL; sel++) {
4417                 if (sel->input == p) {
4418                         if (c->refcnt)
4419                                 clk_enable(p);
4420
4421                         spin_lock_irqsave(&clk_out_lock, flags);
4422                         val = pmc_readl(c->reg);
4423                         val &= ~periph_clk_source_mask(c);
4424                         val |= (sel->value << periph_clk_source_shift(c));
4425                         pmc_writel(val, c->reg);
4426                         spin_unlock_irqrestore(&clk_out_lock, flags);
4427
4428                         if (c->refcnt && c->parent)
4429                                 clk_disable(c->parent);
4430
4431                         clk_reparent(c, p);
4432                         return 0;
4433                 }
4434         }
4435         return -EINVAL;
4436 }
4437
4438 static struct clk_ops tegra_clk_out_ops = {
4439         .init                   = &tegra11_clk_out_init,
4440         .enable                 = &tegra11_clk_out_enable,
4441         .disable                = &tegra11_clk_out_disable,
4442         .set_parent             = &tegra11_clk_out_set_parent,
4443 };
4444
4445
4446 /* External memory controller clock ops */
4447 static void tegra11_emc_clk_init(struct clk *c)
4448 {
4449         tegra11_periph_clk_init(c);
4450         tegra_emc_dram_type_init(c);
4451 }
4452
4453 static long tegra11_emc_clk_round_updown(struct clk *c, unsigned long rate,
4454                                          bool up)
4455 {
4456         unsigned long new_rate = max(rate, c->min_rate);
4457
4458         new_rate = tegra_emc_round_rate_updown(new_rate, up);
4459         if (IS_ERR_VALUE(new_rate))
4460                 new_rate = c->max_rate;
4461
4462         return new_rate;
4463 }
4464
4465 static long tegra11_emc_clk_round_rate(struct clk *c, unsigned long rate)
4466 {
4467         return tegra11_emc_clk_round_updown(c, rate, true);
4468 }
4469
4470 static int tegra11_emc_clk_set_rate(struct clk *c, unsigned long rate)
4471 {
4472         int ret;
4473         u32 div_value;
4474         struct clk *p;
4475
4476         /* The tegra11x memory controller has an interlock with the clock
4477          * block that allows memory shadowed registers to be updated,
4478          * and then transfer them to the main registers at the same
4479          * time as the clock update without glitches. During clock change
4480          * operation both clock parent and divider may change simultaneously
4481          * to achieve requested rate. */
4482         p = tegra_emc_predict_parent(rate, &div_value);
4483         div_value += 2;         /* emc has fractional DIV_U71 divider */
4484         if (IS_ERR_OR_NULL(p)) {
4485                 pr_err("%s: Failed to predict emc parent for rate %lu\n",
4486                        __func__, rate);
4487                 return -EINVAL;
4488         }
4489
4490         if (p == c->parent) {
4491                 if (div_value == c->div)
4492                         return 0;
4493         } else if (c->refcnt)
4494                 clk_enable(p);
4495
4496         ret = tegra_emc_set_rate(rate);
4497         if (ret < 0)
4498                 return ret;
4499
4500         if (p != c->parent) {
4501                 if(c->refcnt && c->parent)
4502                         clk_disable(c->parent);
4503                 clk_reparent(c, p);
4504         }
4505         c->div = div_value;
4506         c->mul = 2;
4507         return 0;
4508 }
4509
4510 static int tegra11_clk_emc_bus_update(struct clk *bus)
4511 {
4512         struct clk *p = NULL;
4513         unsigned long rate, old_rate, parent_rate, backup_rate;
4514
4515         if (detach_shared_bus)
4516                 return 0;
4517
4518         rate = tegra11_clk_shared_bus_update(bus, NULL, NULL, NULL);
4519
4520         old_rate = clk_get_rate_locked(bus);
4521         if (rate == old_rate)
4522                 return 0;
4523
4524         if (!tegra_emc_is_parent_ready(rate, &p, &parent_rate, &backup_rate)) {
4525                 if (bus->parent == p) {
4526                         /* need backup to re-lock current parent */
4527                         int ret;
4528                         if (IS_ERR_VALUE(backup_rate)) {
4529                                 pr_err("%s: No backup for %s rate %lu\n",
4530                                        __func__, bus->name, rate);
4531                                 return -EINVAL;
4532                         }
4533
4534                         /* set volatge for backup rate if going up */
4535                         if (backup_rate > old_rate) {
4536                                 ret = tegra_dvfs_set_rate(bus, backup_rate);
4537                                 if (ret) {
4538                                         pr_err("%s: dvfs failed on %s rate %lu\n",
4539                                               __func__, bus->name, backup_rate);
4540                                         return -EINVAL;
4541                                 }
4542                         }
4543
4544                         trace_clock_set_rate(bus->name, backup_rate, 0);
4545                         ret = bus->ops->set_rate(bus, backup_rate);
4546                         if (ret) {
4547                                 pr_err("%s: Failed to backup %s for rate %lu\n",
4548                                        __func__, bus->name, rate);
4549                                 return -EINVAL;
4550                         }
4551                         clk_rate_change_notify(bus, backup_rate);
4552                 }
4553                 if (p->refcnt) {
4554                         pr_err("%s: %s has other than emc child\n",
4555                                __func__, p->name);
4556                         return -EINVAL;
4557                 }
4558
4559                 if (clk_set_rate(p, parent_rate)) {
4560                         pr_err("%s: Failed to set %s rate %lu\n",
4561                                __func__, p->name, parent_rate);
4562                         return -EINVAL;
4563                 }
4564         }
4565
4566         return clk_set_rate_locked(bus, rate);
4567 }
4568
4569 static struct clk_ops tegra_emc_clk_ops = {
4570         .init                   = &tegra11_emc_clk_init,
4571         .enable                 = &tegra11_periph_clk_enable,
4572         .disable                = &tegra11_periph_clk_disable,
4573         .set_rate               = &tegra11_emc_clk_set_rate,
4574         .round_rate             = &tegra11_emc_clk_round_rate,
4575         .round_rate_updown      = &tegra11_emc_clk_round_updown,
4576         .reset                  = &tegra11_periph_clk_reset,
4577         .shared_bus_update      = &tegra11_clk_emc_bus_update,
4578 };
4579
4580 /* Clock doubler ops (non-atomic shared register access) */
4581 static DEFINE_SPINLOCK(doubler_lock);
4582
4583 static void tegra11_clk_double_init(struct clk *c)
4584 {
4585         u32 val = clk_readl(c->reg);
4586         c->mul = val & (0x1 << c->reg_shift) ? 1 : 2;
4587         c->div = 1;
4588         c->state = ON;
4589         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
4590                 c->state = OFF;
4591 };
4592
4593 static int tegra11_clk_double_set_rate(struct clk *c, unsigned long rate)
4594 {
4595         u32 val;
4596         unsigned long parent_rate = clk_get_rate(c->parent);
4597         unsigned long flags;
4598
4599         if (rate == parent_rate) {
4600                 spin_lock_irqsave(&doubler_lock, flags);
4601                 val = clk_readl(c->reg) | (0x1 << c->reg_shift);
4602                 clk_writel(val, c->reg);
4603                 c->mul = 1;
4604                 c->div = 1;
4605                 spin_unlock_irqrestore(&doubler_lock, flags);
4606                 return 0;
4607         } else if (rate == 2 * parent_rate) {
4608                 spin_lock_irqsave(&doubler_lock, flags);
4609                 val = clk_readl(c->reg) & (~(0x1 << c->reg_shift));
4610                 clk_writel(val, c->reg);
4611                 c->mul = 2;
4612                 c->div = 1;
4613                 spin_unlock_irqrestore(&doubler_lock, flags);
4614                 return 0;
4615         }
4616         return -EINVAL;
4617 }
4618
4619 static struct clk_ops tegra_clk_double_ops = {
4620         .init                   = &tegra11_clk_double_init,
4621         .enable                 = &tegra11_periph_clk_enable,
4622         .disable                = &tegra11_periph_clk_disable,
4623         .set_rate               = &tegra11_clk_double_set_rate,
4624 };
4625
4626 /* Audio sync clock ops */
4627 static int tegra11_sync_source_set_rate(struct clk *c, unsigned long rate)
4628 {
4629         c->rate = rate;
4630         return 0;
4631 }
4632
4633 static struct clk_ops tegra_sync_source_ops = {
4634         .set_rate               = &tegra11_sync_source_set_rate,
4635 };
4636
4637 static void tegra11_audio_sync_clk_init(struct clk *c)
4638 {
4639         int source;
4640         const struct clk_mux_sel *sel;
4641         u32 val = clk_readl(c->reg);
4642         c->state = (val & AUDIO_SYNC_DISABLE_BIT) ? OFF : ON;
4643         source = val & AUDIO_SYNC_SOURCE_MASK;
4644         for (sel = c->inputs; sel->input != NULL; sel++)
4645                 if (sel->value == source)
4646                         break;
4647         BUG_ON(sel->input == NULL);
4648         c->parent = sel->input;
4649 }
4650
4651 static int tegra11_audio_sync_clk_enable(struct clk *c)
4652 {
4653         u32 val = clk_readl(c->reg);
4654         clk_writel((val & (~AUDIO_SYNC_DISABLE_BIT)), c->reg);
4655         return 0;
4656 }
4657
4658 static void tegra11_audio_sync_clk_disable(struct clk *c)
4659 {
4660         u32 val = clk_readl(c->reg);
4661         clk_writel((val | AUDIO_SYNC_DISABLE_BIT), c->reg);
4662 }
4663
4664 static int tegra11_audio_sync_clk_set_parent(struct clk *c, struct clk *p)
4665 {
4666         u32 val;
4667         const struct clk_mux_sel *sel;
4668         for (sel = c->inputs; sel->input != NULL; sel++) {
4669                 if (sel->input == p) {
4670                         val = clk_readl(c->reg);
4671                         val &= ~AUDIO_SYNC_SOURCE_MASK;
4672                         val |= sel->value;
4673
4674                         if (c->refcnt)
4675                                 clk_enable(p);
4676
4677                         clk_writel(val, c->reg);
4678
4679                         if (c->refcnt && c->parent)
4680                                 clk_disable(c->parent);
4681
4682                         clk_reparent(c, p);
4683                         return 0;
4684                 }
4685         }
4686
4687         return -EINVAL;
4688 }
4689
4690 static struct clk_ops tegra_audio_sync_clk_ops = {
4691         .init       = tegra11_audio_sync_clk_init,
4692         .enable     = tegra11_audio_sync_clk_enable,
4693         .disable    = tegra11_audio_sync_clk_disable,
4694         .set_parent = tegra11_audio_sync_clk_set_parent,
4695 };
4696
4697
4698 /* cbus ops */
4699 /*
4700  * Some clocks require dynamic re-locking of source PLL in order to
4701  * achieve frequency scaling granularity that matches characterized
4702  * core voltage steps. The cbus clock creates a shared bus that
4703  * provides a virtual root for such clocks to hide and synchronize
4704  * parent PLL re-locking as well as backup operations.
4705 */
4706
4707 static void tegra11_clk_cbus_init(struct clk *c)
4708 {
4709         c->state = OFF;
4710         c->set = true;
4711 }
4712
4713 static int tegra11_clk_cbus_enable(struct clk *c)
4714 {
4715         return 0;
4716 }
4717
4718 static long tegra11_clk_cbus_round_updown(struct clk *c, unsigned long rate,
4719                                           bool up)
4720 {
4721         int i;
4722
4723         if (!c->dvfs) {
4724                 if (!c->min_rate)
4725                         c->min_rate = c->parent->min_rate;
4726                 rate = max(rate, c->min_rate);
4727                 return rate;
4728         }
4729
4730         /* update min now, since no dvfs table was available during init
4731            (skip placeholder entries set to 1 kHz) */
4732         if (!c->min_rate) {
4733                 for (i = 0; i < (c->dvfs->num_freqs - 1); i++) {
4734                         if (c->dvfs->freqs[i] > 1 * c->dvfs->freqs_mult) {
4735                                 c->min_rate = c->dvfs->freqs[i];
4736                                 break;
4737                         }
4738                 }
4739                 BUG_ON(!c->min_rate);
4740         }
4741         rate = max(rate, c->min_rate);
4742
4743         for (i = 0; ; i++) {
4744                 unsigned long f = c->dvfs->freqs[i];
4745                 int mv = c->dvfs->millivolts[i];
4746                 if ((f >= rate) || (mv >= c->dvfs->max_millivolts) ||
4747                     ((i + 1) >=  c->dvfs->num_freqs)) {
4748                         if (!up && i && (f > rate))
4749                                 i--;
4750                         break;
4751                 }
4752         }
4753         return c->dvfs->freqs[i];
4754 }
4755
4756 static long tegra11_clk_cbus_round_rate(struct clk *c, unsigned long rate)
4757 {
4758         return tegra11_clk_cbus_round_updown(c, rate, true);
4759 }
4760
4761 static int cbus_switch_one(struct clk *c, struct clk *p, u32 div, bool abort)
4762 {
4763         int ret = 0;
4764
4765         /* set new divider if it is bigger than the current one */
4766         if (c->div < c->mul * div) {
4767                 ret = clk_set_div(c, div);
4768                 if (ret) {
4769                         pr_err("%s: failed to set %s clock divider %u: %d\n",
4770                                __func__, c->name, div, ret);
4771                         if (abort)
4772                                 return ret;
4773                 }
4774         }
4775
4776         if (c->parent != p) {
4777                 ret = clk_set_parent(c, p);
4778                 if (ret) {
4779                         pr_err("%s: failed to set %s clock parent %s: %d\n",
4780                                __func__, c->name, p->name, ret);
4781                         if (abort)
4782                                 return ret;
4783                 }
4784         }
4785
4786         /* set new divider if it is smaller than the current one */
4787         if (c->div > c->mul * div) {
4788                 ret = clk_set_div(c, div);
4789                 if (ret)
4790                         pr_err("%s: failed to set %s clock divider %u: %d\n",
4791                                __func__, c->name, div, ret);
4792         }
4793
4794         return ret;
4795 }
4796
4797 static int cbus_backup(struct clk *c)
4798 {
4799         int ret;
4800         struct clk *user;
4801
4802         list_for_each_entry(user, &c->shared_bus_list,
4803                         u.shared_bus_user.node) {
4804                 struct clk *client = user->u.shared_bus_user.client;
4805                 if (client && (client->state == ON) &&
4806                     (client->parent == c->parent)) {
4807                         ret = cbus_switch_one(client,
4808                                               c->shared_bus_backup.input,
4809                                               c->shared_bus_backup.value *
4810                                               user->div, true);
4811                         if (ret)
4812                                 return ret;
4813                 }
4814         }
4815         return 0;
4816 }
4817
4818 static int cbus_dvfs_set_rate(struct clk *c, unsigned long rate)
4819 {
4820         int ret;
4821         struct clk *user;
4822
4823         list_for_each_entry(user, &c->shared_bus_list,
4824                         u.shared_bus_user.node) {
4825                 struct clk *client =  user->u.shared_bus_user.client;
4826                 if (client && client->refcnt && (client->parent == c->parent)) {
4827                         ret = tegra_dvfs_set_rate(c, rate);
4828                         if (ret)
4829                                 return ret;
4830                 }
4831         }
4832         return 0;
4833 }
4834
4835 static void cbus_restore(struct clk *c)
4836 {
4837         struct clk *user;
4838
4839         list_for_each_entry(user, &c->shared_bus_list,
4840                         u.shared_bus_user.node) {
4841                 if (user->u.shared_bus_user.client)
4842                         cbus_switch_one(user->u.shared_bus_user.client,
4843                                         c->parent, c->div * user->div, false);
4844         }
4845 }
4846
4847 static int get_next_backup_div(struct clk *c, unsigned long rate)
4848 {
4849         u32 div = c->div;
4850         unsigned long backup_rate = clk_get_rate(c->shared_bus_backup.input);
4851
4852         rate = max(rate, clk_get_rate_locked(c));
4853         rate = rate - (rate >> 2);      /* 25% margin for backup rate */
4854         if ((u64)rate * div < backup_rate)
4855                 div = DIV_ROUND_UP(backup_rate, rate);
4856
4857         BUG_ON(!div);
4858         return div;
4859 }
4860
4861 static int tegra11_clk_cbus_set_rate(struct clk *c, unsigned long rate)
4862 {
4863         int ret;
4864         bool dramp;
4865
4866         if (rate == 0)
4867                 return 0;
4868
4869         ret = clk_enable(c->parent);
4870         if (ret) {
4871                 pr_err("%s: failed to enable %s clock: %d\n",
4872                        __func__, c->name, ret);
4873                 return ret;
4874         }
4875
4876         dramp = tegra11_is_dyn_ramp(c->parent, rate * c->div, false);
4877         if (!dramp) {
4878                 c->shared_bus_backup.value = get_next_backup_div(c, rate);
4879                 ret = cbus_backup(c);
4880                 if (ret)
4881                         goto out;
4882         }
4883
4884         ret = clk_set_rate(c->parent, rate * c->div);
4885         if (ret) {
4886                 pr_err("%s: failed to set %s clock rate %lu: %d\n",
4887                        __func__, c->name, rate, ret);
4888                 goto out;
4889         }
4890
4891         /* Safe voltage setting is taken care of by cbus clock dvfs; the call
4892          * below only records requirements for each enabled client.
4893          */
4894         if (dramp)
4895                 ret = cbus_dvfs_set_rate(c, rate);
4896
4897         cbus_restore(c);
4898
4899 out:
4900         clk_disable(c->parent);
4901         return ret;
4902 }
4903
4904 static inline void cbus_move_enabled_user(
4905         struct clk *user, struct clk *dst, struct clk *src)
4906 {
4907         clk_enable(dst);
4908         list_move_tail(&user->u.shared_bus_user.node, &dst->shared_bus_list);
4909         clk_disable(src);
4910         clk_reparent(user, dst);
4911 }
4912
4913 #ifdef CONFIG_TEGRA_DYNAMIC_CBUS
4914 static int tegra11_clk_cbus_update(struct clk *bus)
4915 {
4916         int ret, mv;
4917         struct clk *slow = NULL;
4918         struct clk *top = NULL;
4919         unsigned long rate;
4920         unsigned long old_rate;
4921         unsigned long ceiling;
4922
4923         if (detach_shared_bus)
4924                 return 0;
4925
4926         rate = tegra11_clk_shared_bus_update(bus, &top, &slow, &ceiling);
4927
4928         /* use dvfs table of the slowest enabled client as cbus dvfs table */
4929         if (bus->dvfs && slow && (slow != bus->u.cbus.slow_user)) {
4930                 int i;
4931                 unsigned long *dest = &bus->dvfs->freqs[0];
4932                 unsigned long *src =
4933                         &slow->u.shared_bus_user.client->dvfs->freqs[0];
4934                 if (slow->div > 1)
4935                         for (i = 0; i < bus->dvfs->num_freqs; i++)
4936                                 dest[i] = src[i] * slow->div;
4937                 else
4938                         memcpy(dest, src, sizeof(*dest) * bus->dvfs->num_freqs);
4939         }
4940
4941         /* update bus state variables and rate */
4942         bus->u.cbus.slow_user = slow;
4943         bus->u.cbus.top_user = top;
4944
4945         rate = tegra11_clk_cap_shared_bus(bus, rate, ceiling);
4946         mv = tegra_dvfs_predict_millivolts(bus, rate);
4947         if (IS_ERR_VALUE(mv))
4948                 return -EINVAL;
4949
4950         if (bus->dvfs) {
4951                 mv -= bus->dvfs->cur_millivolts;
4952                 if (bus->refcnt && (mv > 0)) {
4953                         ret = tegra_dvfs_set_rate(bus, rate);
4954                         if (ret)
4955                                 return ret;
4956                 }
4957         }
4958
4959         old_rate = clk_get_rate_locked(bus);
4960         if (IS_ENABLED(CONFIG_TEGRA_MIGRATE_CBUS_USERS) || (old_rate != rate)) {
4961                 ret = bus->ops->set_rate(bus, rate);
4962                 if (ret)
4963                         return ret;
4964         }
4965
4966         if (bus->dvfs) {
4967                 if (bus->refcnt && (mv <= 0)) {
4968                         ret = tegra_dvfs_set_rate(bus, rate);
4969                         if (ret)
4970                                 return ret;
4971                 }
4972         }
4973
4974         clk_rate_change_notify(bus, rate);
4975         return 0;
4976 };
4977 #else
4978 static int tegra11_clk_cbus_update(struct clk *bus)
4979 {
4980         unsigned long rate, old_rate;
4981
4982         if (detach_shared_bus)
4983                 return 0;
4984
4985         rate = tegra11_clk_shared_bus_update(bus, NULL, NULL, NULL);
4986
4987         old_rate = clk_get_rate_locked(bus);
4988         if (rate == old_rate)
4989                 return 0;
4990
4991         return clk_set_rate_locked(bus, rate);
4992 }
4993 #endif
4994
4995 static int tegra11_clk_cbus_migrate_users(struct clk *user)
4996 {
4997 #ifdef CONFIG_TEGRA_MIGRATE_CBUS_USERS
4998         struct clk *src_bus, *dst_bus, *top_user, *c;
4999         struct list_head *pos, *n;
5000
5001         if (!user->u.shared_bus_user.client || !user->inputs)
5002                 return 0;
5003
5004         /* Dual cbus on Tegra11 */
5005         src_bus = user->inputs[0].input;
5006         dst_bus = user->inputs[1].input;
5007
5008         if (!src_bus->u.cbus.top_user && !dst_bus->u.cbus.top_user)
5009                 return 0;
5010
5011         /* Make sure top user on the source bus is requesting highest rate */
5012         if (!src_bus->u.cbus.top_user || (dst_bus->u.cbus.top_user &&
5013                 bus_user_request_is_lower(src_bus->u.cbus.top_user,
5014                                            dst_bus->u.cbus.top_user)))
5015                 swap(src_bus, dst_bus);
5016
5017         /* If top user is the slow one on its own (source) bus, do nothing */
5018         top_user = src_bus->u.cbus.top_user;
5019         BUG_ON(!top_user->u.shared_bus_user.client);
5020         if (!bus_user_is_slower(src_bus->u.cbus.slow_user, top_user))
5021                 return 0;
5022
5023         /* If source bus top user is slower than all users on destination bus,
5024            move top user; otherwise move all users slower than the top one */
5025         if (!dst_bus->u.cbus.slow_user ||
5026             !bus_user_is_slower(dst_bus->u.cbus.slow_user, top_user)) {
5027                 cbus_move_enabled_user(top_user, dst_bus, src_bus);
5028         } else {
5029                 list_for_each_safe(pos, n, &src_bus->shared_bus_list) {
5030                         c = list_entry(pos, struct clk, u.shared_bus_user.node);
5031                         if (c->u.shared_bus_user.enabled &&
5032                             c->u.shared_bus_user.client &&
5033                             bus_user_is_slower(c, top_user))
5034                                 cbus_move_enabled_user(c, dst_bus, src_bus);
5035                 }
5036         }
5037
5038         /* Update destination bus 1st (move clients), then source */
5039         tegra_clk_shared_bus_update(dst_bus);
5040         tegra_clk_shared_bus_update(src_bus);
5041 #endif
5042         return 0;
5043 }
5044
5045 static struct clk_ops tegra_clk_cbus_ops = {
5046         .init = tegra11_clk_cbus_init,
5047         .enable = tegra11_clk_cbus_enable,
5048         .set_rate = tegra11_clk_cbus_set_rate,
5049         .round_rate = tegra11_clk_cbus_round_rate,
5050         .round_rate_updown = tegra11_clk_cbus_round_updown,
5051         .shared_bus_update = tegra11_clk_cbus_update,
5052 };
5053
5054 /* shared bus ops */
5055 /*
5056  * Some clocks may have multiple downstream users that need to request a
5057  * higher clock rate.  Shared bus clocks provide a unique shared_bus_user
5058  * clock to each user.  The frequency of the bus is set to the highest
5059  * enabled shared_bus_user clock, with a minimum value set by the
5060  * shared bus.
5061  *
5062  * Optionally shared bus may support users migration. Since shared bus and
5063  * its * children (users) have reversed rate relations: user rates determine
5064  * bus rate, * switching user from one parent/bus to another may change rates
5065  * of both parents. Therefore we need a cross-bus lock on top of individual
5066  * user and bus locks. For now, limit bus switch support to cbus only if
5067  * CONFIG_TEGRA_MIGRATE_CBUS_USERS is set.
5068  */
5069
5070 static unsigned long tegra11_clk_shared_bus_update(struct clk *bus,
5071         struct clk **bus_top, struct clk **bus_slow, unsigned long *rate_cap)
5072 {
5073         struct clk *c;
5074         struct clk *slow = NULL;
5075         struct clk *top = NULL;
5076
5077         unsigned long override_rate = 0;
5078         unsigned long top_rate = 0;
5079         unsigned long rate = bus->min_rate;
5080         unsigned long bw = 0;
5081         unsigned long iso_bw = 0;
5082         unsigned long ceiling = bus->max_rate;
5083         u32 usage_flags = 0;
5084
5085         list_for_each_entry(c, &bus->shared_bus_list,
5086                         u.shared_bus_user.node) {
5087                 /*
5088                  * Ignore requests from disabled floor and bw users, and from
5089                  * auto-users riding the bus. Always honor ceiling users, even
5090                  * if they are disabled - we do not want to keep enabled parent
5091                  * bus just because ceiling is set.
5092                  */
5093                 if (c->u.shared_bus_user.enabled ||
5094                     (c->u.shared_bus_user.mode == SHARED_CEILING)) {
5095                         unsigned long request_rate = c->u.shared_bus_user.rate *
5096                                 (c->div ? : 1);
5097                         usage_flags |= c->u.shared_bus_user.usage_flag;
5098
5099                         switch (c->u.shared_bus_user.mode) {
5100                         case SHARED_ISO_BW:
5101                                 iso_bw += request_rate;
5102                                 if (iso_bw > bus->max_rate)
5103                                         iso_bw = bus->max_rate;
5104                                 /* fall thru */
5105                         case SHARED_BW:
5106                                 bw += request_rate;
5107                                 if (bw > bus->max_rate)
5108                                         bw = bus->max_rate;
5109                                 break;
5110                         case SHARED_CEILING:
5111                                 ceiling = min(request_rate, ceiling);
5112                                 break;
5113                         case SHARED_OVERRIDE:
5114                                 if (override_rate == 0)
5115                                         override_rate = request_rate;
5116                                 break;
5117                         case SHARED_AUTO:
5118                                 break;
5119                         case SHARED_FLOOR:
5120                         default:
5121                                 rate = max(request_rate, rate);
5122                                 if (c->u.shared_bus_user.client
5123                                                         && request_rate) {
5124                                         if (top_rate < request_rate) {
5125                                                 top_rate = request_rate;
5126                                                 top = c;
5127                                         } else if ((top_rate == request_rate) &&
5128                                                 bus_user_is_slower(c, top)) {
5129                                                 top = c;
5130                                         }
5131                                 }
5132                         }
5133                         if (c->u.shared_bus_user.client &&
5134                                 (!slow || bus_user_is_slower(c, slow)))
5135                                 slow = c;
5136                 }
5137         }
5138
5139         if (bus->flags & PERIPH_EMC_ENB) {
5140                 u8 efficiency = tegra_emc_get_iso_share(usage_flags);
5141                 if (iso_bw && efficiency && (efficiency < 100)) {
5142                         iso_bw /= efficiency;
5143                         iso_bw = (iso_bw < bus->max_rate / 100) ?
5144                                         (iso_bw * 100) : bus->max_rate;
5145                 }
5146                 efficiency = tegra_emc_bw_efficiency;
5147                 if (bw && efficiency && (efficiency < 100)) {
5148                         bw = bw / efficiency;
5149                         bw = (bw < bus->max_rate / 100) ?
5150                                 (bw * 100) : bus->max_rate;
5151                 }
5152                 bw = max(bw, iso_bw);
5153         }
5154
5155         rate = override_rate ? : max(rate, bw);
5156         ceiling = override_rate ? bus->max_rate : ceiling;
5157
5158         if (bus_top && bus_slow && rate_cap) {
5159                 /* If dynamic bus dvfs table, let the caller to complete
5160                    rounding and aggregation */
5161                 *bus_top = top;
5162                 *bus_slow = slow;
5163                 *rate_cap = ceiling;
5164         } else {
5165                 /* If satic bus dvfs table, complete rounding and aggregation */
5166                 rate = tegra11_clk_cap_shared_bus(bus, rate, ceiling);
5167         }
5168
5169         return rate;
5170 };
5171
5172 static unsigned long tegra11_clk_cap_shared_bus(struct clk *bus,
5173         unsigned long rate, unsigned long ceiling)
5174 {
5175         if (bus->ops && bus->ops->round_rate_updown)
5176                 ceiling = bus->ops->round_rate_updown(bus, ceiling, false);
5177
5178         rate = min(rate, ceiling);
5179
5180         if (bus->ops && bus->ops->round_rate)
5181                 rate = bus->ops->round_rate(bus, rate);
5182
5183         return rate;
5184 }
5185
5186 static int tegra_clk_shared_bus_migrate_users(struct clk *user)
5187 {
5188         if (detach_shared_bus)
5189                 return 0;
5190
5191         /* Only cbus migration is supported */
5192         if (user->flags & PERIPH_ON_CBUS)
5193                 return tegra11_clk_cbus_migrate_users(user);
5194         return -ENOSYS;
5195 }
5196
5197 static void tegra_clk_shared_bus_user_init(struct clk *c)
5198 {
5199         c->max_rate = c->parent->max_rate;
5200         c->u.shared_bus_user.rate = c->parent->max_rate;
5201         c->state = OFF;
5202         c->set = true;
5203
5204         if (c->u.shared_bus_user.mode == SHARED_CEILING) {
5205                 c->state = ON;
5206                 c->refcnt++;
5207         }
5208
5209         if (c->u.shared_bus_user.client_id) {
5210                 c->u.shared_bus_user.client =
5211                         tegra_get_clock_by_name(c->u.shared_bus_user.client_id);
5212                 if (!c->u.shared_bus_user.client) {
5213                         pr_err("%s: could not find clk %s\n", __func__,
5214                                c->u.shared_bus_user.client_id);
5215                         return;
5216                 }
5217                 c->u.shared_bus_user.client->flags |=
5218                         c->parent->flags & PERIPH_ON_CBUS;
5219                 c->flags |= c->parent->flags & PERIPH_ON_CBUS;
5220                 c->div = c->u.shared_bus_user.client_div ? : 1;
5221                 c->mul = 1;
5222         }
5223
5224         list_add_tail(&c->u.shared_bus_user.node,
5225                 &c->parent->shared_bus_list);
5226 }
5227
5228 static int tegra_clk_shared_bus_user_set_parent(struct clk *c, struct clk *p)
5229 {
5230         int ret;
5231         const struct clk_mux_sel *sel;
5232
5233         if (detach_shared_bus)
5234                 return 0;
5235
5236         if (c->parent == p)
5237                 return 0;
5238
5239         if (!(c->inputs && c->cross_clk_mutex && clk_cansleep(c)))
5240                 return -ENOSYS;
5241
5242         for (sel = c->inputs; sel->input != NULL; sel++) {
5243                 if (sel->input == p)
5244                         break;
5245         }
5246         if (!sel->input)
5247                 return -EINVAL;
5248
5249         if (c->refcnt)
5250                 clk_enable(p);
5251
5252         list_move_tail(&c->u.shared_bus_user.node, &p->shared_bus_list);
5253         ret = tegra_clk_shared_bus_update(p);
5254         if (ret) {
5255                 list_move_tail(&c->u.shared_bus_user.node,
5256                                &c->parent->shared_bus_list);
5257                 tegra_clk_shared_bus_update(c->parent);
5258                 clk_disable(p);
5259                 return ret;
5260         }
5261
5262         tegra_clk_shared_bus_update(c->parent);
5263
5264         if (c->refcnt)
5265                 clk_disable(c->parent);
5266
5267         clk_reparent(c, p);
5268
5269         return 0;
5270 }
5271
5272 static int tegra_clk_shared_bus_user_set_rate(struct clk *c, unsigned long rate)
5273 {
5274         int ret;
5275
5276         c->u.shared_bus_user.rate = rate;
5277         ret = tegra_clk_shared_bus_update(c->parent);
5278
5279         if (!ret && c->cross_clk_mutex && clk_cansleep(c))
5280                 tegra_clk_shared_bus_migrate_users(c);
5281
5282         return ret;
5283 }
5284
5285 static long tegra_clk_shared_bus_user_round_rate(
5286         struct clk *c, unsigned long rate)
5287 {
5288         /* Defer rounding requests until aggregated. BW users must not be
5289            rounded at all, others just clipped to bus range (some clients
5290            may use round api to find limits) */
5291         if ((c->u.shared_bus_user.mode != SHARED_BW) &&
5292             (c->u.shared_bus_user.mode != SHARED_ISO_BW)) {
5293                 if (c->div > 1)
5294                         rate *= c->div;
5295
5296                 if (rate > c->parent->max_rate)
5297                         rate = c->parent->max_rate;
5298                 else if (rate < c->parent->min_rate)
5299                         rate = c->parent->min_rate;
5300
5301                 if (c->div > 1)
5302                         rate /= c->div;
5303         }
5304         return rate;
5305 }
5306
5307 static int tegra_clk_shared_bus_user_enable(struct clk *c)
5308 {
5309         int ret;
5310
5311         c->u.shared_bus_user.enabled = true;
5312         ret = tegra_clk_shared_bus_update(c->parent);
5313         if (!ret && c->u.shared_bus_user.client)
5314                 ret = clk_enable(c->u.shared_bus_user.client);
5315
5316         if (!ret && c->cross_clk_mutex && clk_cansleep(c))
5317                 tegra_clk_shared_bus_migrate_users(c);
5318
5319         return ret;
5320 }
5321
5322 static void tegra_clk_shared_bus_user_disable(struct clk *c)
5323 {
5324         if (c->u.shared_bus_user.client)
5325                 clk_disable(c->u.shared_bus_user.client);
5326         c->u.shared_bus_user.enabled = false;
5327         tegra_clk_shared_bus_update(c->parent);
5328
5329         if (c->cross_clk_mutex && clk_cansleep(c))
5330                 tegra_clk_shared_bus_migrate_users(c);
5331 }
5332
5333 static void tegra_clk_shared_bus_user_reset(struct clk *c, bool assert)
5334 {
5335         if (c->u.shared_bus_user.client) {
5336                 if (c->u.shared_bus_user.client->ops &&
5337                     c->u.shared_bus_user.client->ops->reset)
5338                         c->u.shared_bus_user.client->ops->reset(
5339                                 c->u.shared_bus_user.client, assert);
5340         }
5341 }
5342
5343 static struct clk_ops tegra_clk_shared_bus_user_ops = {
5344         .init = tegra_clk_shared_bus_user_init,
5345         .enable = tegra_clk_shared_bus_user_enable,
5346         .disable = tegra_clk_shared_bus_user_disable,
5347         .set_parent = tegra_clk_shared_bus_user_set_parent,
5348         .set_rate = tegra_clk_shared_bus_user_set_rate,
5349         .round_rate = tegra_clk_shared_bus_user_round_rate,
5350         .reset = tegra_clk_shared_bus_user_reset,
5351 };
5352
5353 /* coupled gate ops */
5354 /*
5355  * Some clocks may have common enable/disable control, but run at different
5356  * rates, and have different dvfs tables. Coupled gate clock synchronize
5357  * enable/disable operations for such clocks.
5358  */
5359
5360 static int tegra11_clk_coupled_gate_enable(struct clk *c)
5361 {
5362         int ret;
5363         const struct clk_mux_sel *sel;
5364
5365         BUG_ON(!c->inputs);
5366         pr_debug("%s on clock %s\n", __func__, c->name);
5367
5368         for (sel = c->inputs; sel->input != NULL; sel++) {
5369                 if (sel->input == c->parent)
5370                         continue;
5371
5372                 ret = clk_enable(sel->input);
5373                 if (ret) {
5374                         while(sel != c->inputs) {
5375                                 sel--;
5376                                 if (sel->input == c->parent)
5377                                         continue;
5378                                 clk_disable(sel->input);
5379                         }
5380                         return ret;
5381                 }
5382         }
5383
5384         return tegra11_periph_clk_enable(c);
5385 }
5386
5387 static void tegra11_clk_coupled_gate_disable(struct clk *c)
5388 {
5389         const struct clk_mux_sel *sel;
5390
5391         BUG_ON(!c->inputs);
5392         pr_debug("%s on clock %s\n", __func__, c->name);
5393
5394         tegra11_periph_clk_disable(c);
5395
5396         if (!c->refcnt) /* happens only on boot clean-up: don't propagate */
5397                 return;
5398
5399         for (sel = c->inputs; sel->input != NULL; sel++) {
5400                 if (sel->input == c->parent)
5401                         continue;
5402
5403                 if (sel->input->set)    /* enforce coupling after boot only */
5404                         clk_disable(sel->input);
5405         }
5406 }
5407
5408 static struct clk_ops tegra_clk_coupled_gate_ops = {
5409         .init                   = tegra11_periph_clk_init,
5410         .enable                 = tegra11_clk_coupled_gate_enable,
5411         .disable                = tegra11_clk_coupled_gate_disable,
5412         .reset                  = &tegra11_periph_clk_reset,
5413 };
5414
5415
5416 /* Clock definitions */
5417 static struct clk tegra_clk_32k = {
5418         .name = "clk_32k",
5419         .rate = 32768,
5420         .ops  = NULL,
5421         .max_rate = 32768,
5422 };
5423
5424 static struct clk tegra_clk_m = {
5425         .name      = "clk_m",
5426         .flags     = ENABLE_ON_INIT,
5427         .ops       = &tegra_clk_m_ops,
5428         .reg       = 0x1fc,
5429         .reg_shift = 28,
5430         .max_rate  = 48000000,
5431 };
5432
5433 static struct clk tegra_clk_m_div2 = {
5434         .name      = "clk_m_div2",
5435         .ops       = &tegra_clk_m_div_ops,
5436         .parent    = &tegra_clk_m,
5437         .mul       = 1,
5438         .div       = 2,
5439         .state     = ON,
5440         .max_rate  = 24000000,
5441 };
5442
5443 static struct clk tegra_clk_m_div4 = {
5444         .name      = "clk_m_div4",
5445         .ops       = &tegra_clk_m_div_ops,
5446         .parent    = &tegra_clk_m,
5447         .mul       = 1,
5448         .div       = 4,
5449         .state     = ON,
5450         .max_rate  = 12000000,
5451 };
5452
5453 static struct clk tegra_pll_ref = {
5454         .name      = "pll_ref",
5455         .flags     = ENABLE_ON_INIT,
5456         .ops       = &tegra_pll_ref_ops,
5457         .parent    = &tegra_clk_m,
5458         .max_rate  = 26000000,
5459 };
5460
5461 static struct clk_pll_freq_table tegra_pll_c_freq_table[] = {
5462         { 12000000, 624000000, 104, 1, 2},
5463         { 12000000, 600000000, 100, 1, 2},
5464         { 13000000, 600000000,  92, 1, 2},      /* actual: 598.0 MHz */
5465         { 16800000, 600000000,  71, 1, 2},      /* actual: 596.4 MHz */
5466         { 19200000, 600000000,  62, 1, 2},      /* actual: 595.2 MHz */
5467         { 26000000, 600000000,  92, 2, 2},      /* actual: 598.0 MHz */
5468         { 0, 0, 0, 0, 0, 0 },
5469 };
5470
5471 static struct clk tegra_pll_c = {
5472         .name      = "pll_c",
5473         .ops       = &tegra_pllxc_ops,
5474         .reg       = 0x80,
5475         .parent    = &tegra_pll_ref,
5476         .max_rate  = 1400000000,
5477         .u.pll = {
5478                 .input_min = 12000000,
5479                 .input_max = 800000000,
5480                 .cf_min    = 12000000,
5481                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
5482                 .vco_min   = 600000000,
5483                 .vco_max   = 1400000000,
5484                 .freq_table = tegra_pll_c_freq_table,
5485                 .lock_delay = 300,
5486                 .misc1 = 0x88 - 0x80,
5487                 .round_p_to_pdiv = pllxc_round_p_to_pdiv,
5488         },
5489 };
5490
5491 static struct clk tegra_pll_c_out1 = {
5492         .name      = "pll_c_out1",
5493         .ops       = &tegra_pll_div_ops,
5494 #ifdef CONFIG_TEGRA_DUAL_CBUS
5495         .flags     = DIV_U71 | DIV_U71_INT,
5496 #else
5497         .flags     = DIV_U71 | DIV_U71_INT | PERIPH_ON_CBUS,
5498 #endif
5499         .parent    = &tegra_pll_c,
5500         .reg       = 0x84,
5501         .reg_shift = 0,
5502         .max_rate  = 700000000,
5503 };
5504
5505 static struct clk_pll_freq_table tegra_pll_cx_freq_table[] = {
5506         { 12000000, 600000000, 100, 1, 2},
5507         { 13000000, 600000000,  92, 1, 2},      /* actual: 598.0 MHz */
5508         { 16800000, 600000000,  71, 1, 2},      /* actual: 596.4 MHz */
5509         { 19200000, 600000000,  62, 1, 2},      /* actual: 595.2 MHz */
5510         { 26000000, 600000000,  92, 2, 2},      /* actual: 598.0 MHz */
5511         { 0, 0, 0, 0, 0, 0 },
5512 };
5513
5514 static struct clk tegra_pll_c2 = {
5515         .name      = "pll_c2",
5516         .ops       = &tegra_pllcx_ops,
5517         .flags     = PLL_ALT_MISC_REG,
5518         .reg       = 0x4e8,
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 = 0x4f0 - 0x4e8,
5531                 .round_p_to_pdiv = pllcx_round_p_to_pdiv,
5532         },
5533 };
5534
5535 static struct clk tegra_pll_c3 = {
5536         .name      = "pll_c3",
5537         .ops       = &tegra_pllcx_ops,
5538         .flags     = PLL_ALT_MISC_REG,
5539         .reg       = 0x4fc,
5540         .parent    = &tegra_pll_ref,
5541         .max_rate  = 1200000000,
5542         .u.pll = {
5543                 .input_min = 12000000,
5544                 .input_max = 48000000,
5545                 .cf_min    = 12000000,
5546                 .cf_max    = 19200000,
5547                 .vco_min   = 624000000,
5548                 .vco_max   = 1248000000,
5549                 .freq_table = tegra_pll_cx_freq_table,
5550                 .lock_delay = 300,
5551                 .misc1 = 0x504 - 0x4fc,
5552                 .round_p_to_pdiv = pllcx_round_p_to_pdiv,
5553         },
5554 };
5555
5556 static struct clk_pll_freq_table tegra_pll_m_freq_table[] = {
5557         { 12000000, 800000000, 66, 1, 1},       /* actual: 792.0 MHz */
5558         { 13000000, 800000000, 61, 1, 1},       /* actual: 793.0 MHz */
5559         { 16800000, 800000000, 47, 1, 1},       /* actual: 789.6 MHz */
5560         { 19200000, 800000000, 41, 1, 1},       /* actual: 787.2 MHz */
5561         { 26000000, 800000000, 61, 2, 1},       /* actual: 793.0 MHz */
5562         { 0, 0, 0, 0, 0, 0 },
5563 };
5564
5565 static struct clk tegra_pll_m = {
5566         .name      = "pll_m",
5567         .flags     = PLLM,
5568         .ops       = &tegra_pllm_ops,
5569         .reg       = 0x90,
5570         .parent    = &tegra_pll_ref,
5571         .max_rate  = 1066000000,
5572         .u.pll = {
5573                 .input_min = 12000000,
5574                 .input_max = 500000000,
5575                 .cf_min    = 12000000,
5576                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
5577                 .vco_min   = 400000000,
5578                 .vco_max   = 1066000000,
5579                 .freq_table = tegra_pll_m_freq_table,
5580                 .lock_delay = 300,
5581                 .misc1 = 0x98 - 0x90,
5582                 .round_p_to_pdiv = pllm_round_p_to_pdiv,
5583         },
5584 };
5585
5586 static struct clk tegra_pll_m_out1 = {
5587         .name      = "pll_m_out1",
5588         .ops       = &tegra_pll_div_ops,
5589         .flags     = DIV_U71 | DIV_U71_INT,
5590         .parent    = &tegra_pll_m,
5591         .reg       = 0x94,
5592         .reg_shift = 0,
5593         .max_rate  = 1066000000,
5594 };
5595
5596 static struct clk_pll_freq_table tegra_pll_p_freq_table[] = {
5597         { 12000000, 216000000, 432, 12, 2, 8},
5598         { 13000000, 216000000, 432, 13, 2, 8},
5599         { 16800000, 216000000, 360, 14, 2, 8},
5600         { 19200000, 216000000, 360, 16, 2, 8},
5601         { 26000000, 216000000, 432, 26, 2, 8},
5602         { 0, 0, 0, 0, 0, 0 },
5603 };
5604
5605 static struct clk tegra_pll_p = {
5606         .name      = "pll_p",
5607         .flags     = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
5608         .ops       = &tegra_pllp_ops,
5609         .reg       = 0xa0,
5610         .parent    = &tegra_pll_ref,
5611         .max_rate  = 432000000,
5612         .u.pll = {
5613                 .input_min = 2000000,
5614                 .input_max = 31000000,
5615                 .cf_min    = 1000000,
5616                 .cf_max    = 6000000,
5617                 .vco_min   = 200000000,
5618                 .vco_max   = 700000000,
5619                 .freq_table = tegra_pll_p_freq_table,
5620                 .lock_delay = 300,
5621         },
5622 };
5623
5624 static struct clk tegra_pll_p_out1 = {
5625         .name      = "pll_p_out1",
5626         .ops       = &tegra_pll_div_ops,
5627         .flags     = DIV_U71 | DIV_U71_FIXED,
5628         .parent    = &tegra_pll_p,
5629         .reg       = 0xa4,
5630         .reg_shift = 0,
5631         .max_rate  = 432000000,
5632 };
5633
5634 static struct clk tegra_pll_p_out2 = {
5635         .name      = "pll_p_out2",
5636         .ops       = &tegra_pll_div_ops,
5637         .flags     = DIV_U71 | DIV_U71_FIXED | DIV_U71_INT,
5638         .parent    = &tegra_pll_p,
5639         .reg       = 0xa4,
5640         .reg_shift = 16,
5641         .max_rate  = 432000000,
5642 };
5643
5644 static struct clk tegra_pll_p_out3 = {
5645         .name      = "pll_p_out3",
5646         .ops       = &tegra_pll_div_ops,
5647         .flags     = DIV_U71 | DIV_U71_FIXED,
5648         .parent    = &tegra_pll_p,
5649         .reg       = 0xa8,
5650         .reg_shift = 0,
5651         .max_rate  = 432000000,
5652 };
5653
5654 static struct clk tegra_pll_p_out4 = {
5655         .name      = "pll_p_out4",
5656         .ops       = &tegra_pll_div_ops,
5657         .flags     = DIV_U71 | DIV_U71_FIXED,
5658         .parent    = &tegra_pll_p,
5659         .reg       = 0xa8,
5660         .reg_shift = 16,
5661         .max_rate  = 432000000,
5662 };
5663
5664 static struct clk_pll_freq_table tegra_pll_a_freq_table[] = {
5665         {  9600000, 282240000, 147,  5, 1, 4},
5666         {  9600000, 368640000, 192,  5, 1, 4},
5667         {  9600000, 240000000, 200,  8, 1, 8},
5668
5669         { 28800000, 282240000, 245, 25, 1, 8},
5670         { 28800000, 368640000, 320, 25, 1, 8},
5671         { 28800000, 240000000, 200, 24, 1, 8},
5672         { 0, 0, 0, 0, 0, 0 },
5673 };
5674
5675 static struct clk tegra_pll_a = {
5676         .name      = "pll_a",
5677         .flags     = PLL_HAS_CPCON,
5678         .ops       = &tegra_pll_ops,
5679         .reg       = 0xb0,
5680         .parent    = &tegra_pll_p_out1,
5681         .max_rate  = 700000000,
5682         .u.pll = {
5683                 .input_min = 2000000,
5684                 .input_max = 31000000,
5685                 .cf_min    = 1000000,
5686                 .cf_max    = 6000000,
5687                 .vco_min   = 200000000,
5688                 .vco_max   = 700000000,
5689                 .freq_table = tegra_pll_a_freq_table,
5690                 .lock_delay = 300,
5691         },
5692 };
5693
5694 static struct clk tegra_pll_a_out0 = {
5695         .name      = "pll_a_out0",
5696         .ops       = &tegra_pll_div_ops,
5697         .flags     = DIV_U71,
5698         .parent    = &tegra_pll_a,
5699         .reg       = 0xb4,
5700         .reg_shift = 0,
5701         .max_rate  = 100000000,
5702 };
5703
5704 static struct clk_pll_freq_table tegra_pll_d_freq_table[] = {
5705         { 12000000, 216000000, 864, 12, 4, 12},
5706         { 13000000, 216000000, 864, 13, 4, 12},
5707         { 16800000, 216000000, 720, 14, 4, 12},
5708         { 19200000, 216000000, 720, 16, 4, 12},
5709         { 26000000, 216000000, 864, 26, 4, 12},
5710
5711         { 12000000, 594000000,  99,  2, 1, 15},
5712         { 13000000, 594000000, 594, 13, 1, 12},
5713         { 16800000, 594000000, 495, 14, 1, 12},
5714         { 19200000, 594000000, 495, 16, 1, 12},
5715         { 26000000, 594000000, 594, 26, 1, 12},
5716
5717         { 12000000, 1000000000, 1000, 12, 1, 12},
5718         { 13000000, 1000000000, 1000, 13, 1, 12},
5719         { 19200000, 1000000000, 625,  12, 1, 12},
5720         { 26000000, 1000000000, 1000, 26, 1, 12},
5721
5722         { 0, 0, 0, 0, 0, 0 },
5723 };
5724
5725 static struct clk tegra_pll_d = {
5726         .name      = "pll_d",
5727         .flags     = PLL_HAS_CPCON | PLLD,
5728         .ops       = &tegra_plld_ops,
5729         .reg       = 0xd0,
5730         .parent    = &tegra_pll_ref,
5731         .max_rate  = 1000000000,
5732         .u.pll = {
5733                 .input_min = 2000000,
5734                 .input_max = 40000000,
5735                 .cf_min    = 1000000,
5736                 .cf_max    = 6000000,
5737                 .vco_min   = 500000000,
5738                 .vco_max   = 1000000000,
5739                 .freq_table = tegra_pll_d_freq_table,
5740                 .lock_delay = 1000,
5741         },
5742 };
5743
5744 static struct clk tegra_pll_d_out0 = {
5745         .name      = "pll_d_out0",
5746         .ops       = &tegra_pll_div_ops,
5747         .flags     = DIV_2 | PLLD,
5748         .parent    = &tegra_pll_d,
5749         .max_rate  = 500000000,
5750 };
5751
5752 static struct clk tegra_pll_d2 = {
5753         .name      = "pll_d2",
5754         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG | PLLD,
5755         .ops       = &tegra_plld_ops,
5756         .reg       = 0x4b8,
5757         .parent    = &tegra_pll_ref,
5758         .max_rate  = 1000000000,
5759         .u.pll = {
5760                 .input_min = 2000000,
5761                 .input_max = 40000000,
5762                 .cf_min    = 1000000,
5763                 .cf_max    = 6000000,
5764                 .vco_min   = 500000000,
5765                 .vco_max   = 1000000000,
5766                 .freq_table = tegra_pll_d_freq_table,
5767                 .lock_delay = 1000,
5768         },
5769 };
5770
5771 static struct clk tegra_pll_d2_out0 = {
5772         .name      = "pll_d2_out0",
5773         .ops       = &tegra_pll_div_ops,
5774         .flags     = DIV_2 | PLLD,
5775         .parent    = &tegra_pll_d2,
5776         .max_rate  = 500000000,
5777 };
5778
5779 static struct clk_pll_freq_table tegra_pll_u_freq_table[] = {
5780         { 12000000, 480000000, 960, 12, 2, 12},
5781         { 13000000, 480000000, 960, 13, 2, 12},
5782         { 16800000, 480000000, 400, 7,  2, 5},
5783         { 19200000, 480000000, 200, 4,  2, 3},
5784         { 26000000, 480000000, 960, 26, 2, 12},
5785         { 0, 0, 0, 0, 0, 0 },
5786 };
5787
5788 static struct clk tegra_pll_u = {
5789         .name      = "pll_u",
5790         .flags     = PLL_HAS_CPCON | PLLU,
5791         .ops       = &tegra_pll_ops,
5792         .reg       = 0xc0,
5793         .parent    = &tegra_pll_ref,
5794         .max_rate  = 480000000,
5795         .u.pll = {
5796                 .input_min = 2000000,
5797                 .input_max = 40000000,
5798                 .cf_min    = 1000000,
5799                 .cf_max    = 6000000,
5800                 .vco_min   = 480000000,
5801                 .vco_max   = 960000000,
5802                 .freq_table = tegra_pll_u_freq_table,
5803                 .lock_delay = 1000,
5804                 .cpcon_default = 12,
5805         },
5806 };
5807
5808 static struct clk tegra_pll_u_480M = {
5809         .name      = "pll_u_480M",
5810         .flags     = PLLU,
5811         .ops       = &tegra_pll_div_ops,
5812         .reg       = 0xc0,
5813         .reg_shift = 22,
5814         .parent    = &tegra_pll_u,
5815         .mul       = 1,
5816         .div       = 1,
5817         .max_rate  = 480000000,
5818 };
5819
5820 static struct clk tegra_pll_u_60M = {
5821         .name      = "pll_u_60M",
5822         .flags     = PLLU,
5823         .ops       = &tegra_pll_div_ops,
5824         .reg       = 0xc0,
5825         .reg_shift = 23,
5826         .parent    = &tegra_pll_u,
5827         .mul       = 1,
5828         .div       = 8,
5829         .max_rate  = 60000000,
5830 };
5831
5832 static struct clk tegra_pll_u_48M = {
5833         .name      = "pll_u_48M",
5834         .flags     = PLLU,
5835         .ops       = &tegra_pll_div_ops,
5836         .reg       = 0xc0,
5837         .reg_shift = 25,
5838         .parent    = &tegra_pll_u,
5839         .mul       = 1,
5840         .div       = 10,
5841         .max_rate  = 48000000,
5842 };
5843
5844 static struct clk tegra_pll_u_12M = {
5845         .name      = "pll_u_12M",
5846         .flags     = PLLU,
5847         .ops       = &tegra_pll_div_ops,
5848         .reg       = 0xc0,
5849         .reg_shift = 21,
5850         .parent    = &tegra_pll_u,
5851         .mul       = 1,
5852         .div       = 40,
5853         .max_rate  = 12000000,
5854 };
5855
5856 static struct clk_pll_freq_table tegra_pll_x_freq_table[] = {
5857         /* 1 GHz */
5858         { 12000000, 1000000000, 83, 1, 1},      /* actual: 996.0 MHz */
5859         { 13000000, 1000000000, 76, 1, 1},      /* actual: 988.0 MHz */
5860         { 16800000, 1000000000, 59, 1, 1},      /* actual: 991.2 MHz */
5861         { 19200000, 1000000000, 52, 1, 1},      /* actual: 998.4 MHz */
5862         { 26000000, 1000000000, 76, 2, 1},      /* actual: 988.0 MHz */
5863
5864         { 0, 0, 0, 0, 0, 0 },
5865 };
5866
5867 static struct clk tegra_pll_x = {
5868         .name      = "pll_x",
5869         .flags     = PLL_ALT_MISC_REG | PLLX,
5870         .ops       = &tegra_pllxc_ops,
5871         .reg       = 0xe0,
5872         .parent    = &tegra_pll_ref,
5873         .max_rate  = 1800000000,
5874         .u.pll = {
5875                 .input_min = 12000000,
5876                 .input_max = 800000000,
5877                 .cf_min    = 12000000,
5878                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
5879                 .vco_min   = 700000000,
5880                 .vco_max   = 2400000000U,
5881                 .freq_table = tegra_pll_x_freq_table,
5882                 .lock_delay = 300,
5883                 .misc1 = 0x510 - 0xe0,
5884                 .round_p_to_pdiv = pllxc_round_p_to_pdiv,
5885         },
5886 };
5887
5888 static struct clk tegra_pll_x_out0 = {
5889         .name      = "pll_x_out0",
5890         .ops       = &tegra_pll_div_ops,
5891         .flags     = DIV_2 | PLLX,
5892         .parent    = &tegra_pll_x,
5893         .max_rate  = 700000000,
5894 };
5895
5896 /* FIXME: remove; for now, should be always checked-in as "0" */
5897 #define USE_LP_CPU_TO_TEST_DFLL         0
5898
5899 static struct clk tegra_dfll_cpu = {
5900         .name      = "dfll_cpu",
5901         .flags     = DFLL,
5902         .ops       = &tegra_dfll_ops,
5903         .reg       = 0x2f4,
5904         .max_rate  = 2000000000,
5905 };
5906
5907 static struct clk tegra_pll_re_vco = {
5908         .name      = "pll_re_vco",
5909         .flags     = PLL_ALT_MISC_REG,
5910         .ops       = &tegra_pllre_ops,
5911         .reg       = 0x4c4,
5912         .parent    = &tegra_pll_ref,
5913         .max_rate  = 672000000,
5914         .u.pll = {
5915                 .input_min = 12000000,
5916                 .input_max = 1000000000,
5917                 .cf_min    = 12000000,
5918                 .cf_max    = 19200000,  /* s/w policy, h/w capability 38 MHz */
5919                 .vco_min   = 300000000,
5920                 .vco_max   = 672000000,
5921                 .lock_delay = 300,
5922                 .round_p_to_pdiv = pllre_round_p_to_pdiv,
5923         },
5924 };
5925
5926 static struct clk tegra_pll_re_out = {
5927         .name      = "pll_re_out",
5928         .ops       = &tegra_pllre_out_ops,
5929         .parent    = &tegra_pll_re_vco,
5930         .reg       = 0x4c4,
5931         .max_rate  = 672000000,
5932 };
5933
5934 static struct clk_pll_freq_table tegra_pll_e_freq_table[] = {
5935         /* PLLE special case: use cpcon field to store cml divider value */
5936         { 336000000, 100000000, 100, 21,  16, 11},
5937         { 312000000, 100000000, 200, 26,  24, 13},
5938         {  12000000, 100000000, 200,  1,  24, 13},
5939         { 0, 0, 0, 0, 0, 0 },
5940 };
5941
5942 static struct clk tegra_pll_e = {
5943         .name      = "pll_e",
5944         .flags     = PLL_ALT_MISC_REG,
5945         .ops       = &tegra_plle_ops,
5946         .reg       = 0xe8,
5947         .max_rate  = 100000000,
5948         .u.pll = {
5949                 .input_min = 12000000,
5950                 .input_max = 1000000000,
5951                 .cf_min    = 12000000,
5952                 .cf_max    = 75000000,
5953                 .vco_min   = 1600000000,
5954                 .vco_max   = 2400000000U,
5955                 .freq_table = tegra_pll_e_freq_table,
5956                 .lock_delay = 300,
5957                 .fixed_rate = 100000000,
5958         },
5959 };
5960
5961 static struct clk tegra_pciex_clk = {
5962         .name      = "pciex",
5963         .parent    = &tegra_pll_e,
5964         .ops       = &tegra_pciex_clk_ops,
5965         .max_rate  = 100000000,
5966         .u.periph  = {
5967                 .clk_num   = 74,
5968         },
5969 };
5970
5971 /* Audio sync clocks */
5972 #define SYNC_SOURCE(_id, _dev)                          \
5973         {                                               \
5974                 .name      = #_id "_sync",              \
5975                 .lookup    = {                          \
5976                         .dev_id    = #_dev ,            \
5977                         .con_id    = "ext_audio_sync",  \
5978                 },                                      \
5979                 .rate      = 24000000,                  \
5980                 .max_rate  = 24000000,                  \
5981                 .ops       = &tegra_sync_source_ops     \
5982         }
5983 static struct clk tegra_sync_source_list[] = {
5984         SYNC_SOURCE(spdif_in, tegra30-spdif),
5985         SYNC_SOURCE(i2s0, tegra30-i2s.0),
5986         SYNC_SOURCE(i2s1, tegra30-i2s.1),
5987         SYNC_SOURCE(i2s2, tegra30-i2s.2),
5988         SYNC_SOURCE(i2s3, tegra30-i2s.3),
5989         SYNC_SOURCE(i2s4, tegra30-i2s.4),
5990         SYNC_SOURCE(vimclk, vimclk),
5991 };
5992
5993 static struct clk_mux_sel mux_d_audio_clk[] = {
5994         { .input = &tegra_pll_a_out0,           .value = 0},
5995         { .input = &tegra_pll_p,                .value = 0x8000},
5996         { .input = &tegra_clk_m,                .value = 0xc000},
5997         { .input = &tegra_sync_source_list[0],  .value = 0xE000},
5998         { .input = &tegra_sync_source_list[1],  .value = 0xE001},
5999         { .input = &tegra_sync_source_list[2],  .value = 0xE002},
6000         { .input = &tegra_sync_source_list[3],  .value = 0xE003},
6001         { .input = &tegra_sync_source_list[4],  .value = 0xE004},
6002         { .input = &tegra_sync_source_list[5],  .value = 0xE005},
6003         { .input = &tegra_pll_a_out0,           .value = 0xE006},
6004         { .input = &tegra_sync_source_list[6],  .value = 0xE007},
6005         { 0, 0 }
6006 };
6007
6008 static struct clk_mux_sel mux_audio_sync_clk[] =
6009 {
6010         { .input = &tegra_sync_source_list[0],  .value = 0},
6011         { .input = &tegra_sync_source_list[1],  .value = 1},
6012         { .input = &tegra_sync_source_list[2],  .value = 2},
6013         { .input = &tegra_sync_source_list[3],  .value = 3},
6014         { .input = &tegra_sync_source_list[4],  .value = 4},
6015         { .input = &tegra_sync_source_list[5],  .value = 5},
6016         { .input = &tegra_pll_a_out0,           .value = 6},
6017         { .input = &tegra_sync_source_list[6],  .value = 7},
6018         { 0, 0 }
6019 };
6020
6021 #define AUDIO_SYNC_CLK(_id, _dev, _index)                       \
6022         {                                               \
6023                 .name      = #_id,                      \
6024                 .lookup    = {                          \
6025                         .dev_id    = #_dev,             \
6026                         .con_id    = "audio_sync",      \
6027                 },                                      \
6028                 .inputs    = mux_audio_sync_clk,        \
6029                 .reg       = 0x4A0 + (_index) * 4,      \
6030                 .max_rate  = 24000000,                  \
6031                 .ops       = &tegra_audio_sync_clk_ops  \
6032         }
6033 static struct clk tegra_clk_audio_list[] = {
6034         AUDIO_SYNC_CLK(audio0, tegra30-i2s.0, 0),
6035         AUDIO_SYNC_CLK(audio1, tegra30-i2s.1, 1),
6036         AUDIO_SYNC_CLK(audio2, tegra30-i2s.2, 2),
6037         AUDIO_SYNC_CLK(audio3, tegra30-i2s.3, 3),
6038         AUDIO_SYNC_CLK(audio4, tegra30-i2s.4, 4),
6039         AUDIO_SYNC_CLK(audio, tegra30-spdif, 5),        /* SPDIF */
6040 };
6041
6042 #define AUDIO_SYNC_2X_CLK(_id, _dev, _index)                            \
6043         {                                                       \
6044                 .name      = #_id "_2x",                        \
6045                 .lookup    = {                                  \
6046                         .dev_id    = #_dev,                     \
6047                         .con_id    = "audio_sync_2x"            \
6048                 },                                              \
6049                 .flags     = PERIPH_NO_RESET,                   \
6050                 .max_rate  = 48000000,                          \
6051                 .ops       = &tegra_clk_double_ops,             \
6052                 .reg       = 0x49C,                             \
6053                 .reg_shift = 24 + (_index),                     \
6054                 .parent    = &tegra_clk_audio_list[(_index)],   \
6055                 .u.periph = {                                   \