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