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