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