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