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