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