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