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