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