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