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