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