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