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