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