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