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