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