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