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