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