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