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