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