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