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