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