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