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