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