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