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