bcf1f95314a3d6e7bf930fa1d5f2ad5fde843c19
[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
3672         if (!c->parent || !c->parent->dvfs)
3673                 return -ENOSYS;
3674
3675         clk_lock_save(c, &c_flags);
3676         if (c->parent->u.cpu.mode == MODE_LP) {
3677                 pr_err("%s: DFLL is not used on LP CPU\n", __func__);
3678                 clk_unlock_restore(c, &c_flags);
3679                 return -ENOSYS;
3680         }
3681
3682         clk_lock_save(c->parent, &p_flags);
3683         old_use_dfll = use_dfll;
3684         param_set_int(arg, kp);
3685
3686         if (use_dfll != old_use_dfll) {
3687                 ret = tegra_dvfs_set_dfll_range(c->parent->dvfs, use_dfll);
3688                 if (ret) {
3689                         use_dfll = old_use_dfll;
3690                 } else {
3691                         ret = clk_set_rate_locked(c->parent,
3692                                 clk_get_rate_locked(c->parent));
3693                         if (ret) {
3694                                 use_dfll = old_use_dfll;
3695                                 tegra_dvfs_set_dfll_range(
3696                                         c->parent->dvfs, use_dfll);
3697                         }
3698                 }
3699         }
3700         clk_unlock_restore(c->parent, &p_flags);
3701         clk_unlock_restore(c, &c_flags);
3702         tegra_recalculate_cpu_edp_limits();
3703         return ret;
3704 }
3705
3706 static struct kernel_param_ops tegra11_use_dfll_ops = {
3707         .set = tegra11_use_dfll_cb,
3708         .get = param_get_int,
3709 };
3710 module_param_cb(use_dfll, &tegra11_use_dfll_ops, &use_dfll, 0644);
3711
3712
3713 /* Clock divider ops (non-atomic shared register access) */
3714 static DEFINE_SPINLOCK(pll_div_lock);
3715
3716 static int tegra11_pll_div_clk_set_rate(struct clk *c, unsigned long rate);
3717 static void tegra11_pll_div_clk_init(struct clk *c)
3718 {
3719         if (c->flags & DIV_U71) {
3720                 u32 val, divu71;
3721                 if (c->parent->state == OFF)
3722                         c->ops->disable(c);
3723
3724                 val = clk_readl(c->reg);
3725                 val >>= c->reg_shift;
3726                 c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
3727                 if (!(val & PLL_OUT_RESET_DISABLE))
3728                         c->state = OFF;
3729
3730                 if (c->u.pll_div.default_rate) {
3731                         int ret = tegra11_pll_div_clk_set_rate(
3732                                         c, c->u.pll_div.default_rate);
3733                         if (!ret)
3734                                 return;
3735                 }
3736                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
3737                 c->div = (divu71 + 2);
3738                 c->mul = 2;
3739         } else if (c->flags & DIV_2) {
3740                 c->state = ON;
3741                 if (c->flags & (PLLD | PLLX)) {
3742                         c->div = 2;
3743                         c->mul = 1;
3744                 }
3745                 else
3746                         BUG();
3747         } else if (c->flags & PLLU) {
3748                 u32 val = clk_readl(c->reg);
3749                 c->state = val & (0x1 << c->reg_shift) ? ON : OFF;
3750         } else {
3751                 c->state = ON;
3752                 c->div = 1;
3753                 c->mul = 1;
3754         }
3755 }
3756
3757 static int tegra11_pll_div_clk_enable(struct clk *c)
3758 {
3759         u32 val;
3760         u32 new_val;
3761         unsigned long flags;
3762
3763         pr_debug("%s: %s\n", __func__, c->name);
3764         if (c->flags & DIV_U71) {
3765                 spin_lock_irqsave(&pll_div_lock, flags);
3766                 val = clk_readl(c->reg);
3767                 new_val = val >> c->reg_shift;
3768                 new_val &= 0xFFFF;
3769
3770                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
3771
3772                 val &= ~(0xFFFF << c->reg_shift);
3773                 val |= new_val << c->reg_shift;
3774                 clk_writel_delay(val, c->reg);
3775                 spin_unlock_irqrestore(&pll_div_lock, flags);
3776                 return 0;
3777         } else if (c->flags & DIV_2) {
3778                 return 0;
3779         } else if (c->flags & PLLU) {
3780                 clk_lock_save(c->parent, &flags);
3781                 val = clk_readl(c->reg) | (0x1 << c->reg_shift);
3782                 clk_writel_delay(val, c->reg);
3783                 clk_unlock_restore(c->parent, &flags);
3784                 return 0;
3785         }
3786         return -EINVAL;
3787 }
3788
3789 static void tegra11_pll_div_clk_disable(struct clk *c)
3790 {
3791         u32 val;
3792         u32 new_val;
3793         unsigned long flags;
3794
3795         pr_debug("%s: %s\n", __func__, c->name);
3796         if (c->flags & DIV_U71) {
3797                 spin_lock_irqsave(&pll_div_lock, flags);
3798                 val = clk_readl(c->reg);
3799                 new_val = val >> c->reg_shift;
3800                 new_val &= 0xFFFF;
3801
3802                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
3803
3804                 val &= ~(0xFFFF << c->reg_shift);
3805                 val |= new_val << c->reg_shift;
3806                 clk_writel_delay(val, c->reg);
3807                 spin_unlock_irqrestore(&pll_div_lock, flags);
3808         } else if (c->flags & PLLU) {
3809                 clk_lock_save(c->parent, &flags);
3810                 val = clk_readl(c->reg) & (~(0x1 << c->reg_shift));
3811                 clk_writel_delay(val, c->reg);
3812                 clk_unlock_restore(c->parent, &flags);
3813         }
3814 }
3815
3816 static int tegra11_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
3817 {
3818         u32 val;
3819         u32 new_val;
3820         int divider_u71;
3821         unsigned long parent_rate = clk_get_rate(c->parent);
3822         unsigned long flags;
3823
3824         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3825         if (c->flags & DIV_U71) {
3826                 divider_u71 = clk_div71_get_divider(
3827                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3828                 if (divider_u71 >= 0) {
3829                         spin_lock_irqsave(&pll_div_lock, flags);
3830                         val = clk_readl(c->reg);
3831                         new_val = val >> c->reg_shift;
3832                         new_val &= 0xFFFF;
3833                         if (c->flags & DIV_U71_FIXED)
3834                                 new_val |= PLL_OUT_OVERRIDE;
3835                         new_val &= ~PLL_OUT_RATIO_MASK;
3836                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
3837
3838                         val &= ~(0xFFFF << c->reg_shift);
3839                         val |= new_val << c->reg_shift;
3840                         clk_writel_delay(val, c->reg);
3841                         c->div = divider_u71 + 2;
3842                         c->mul = 2;
3843                         spin_unlock_irqrestore(&pll_div_lock, flags);
3844                         return 0;
3845                 }
3846         } else if (c->flags & DIV_2)
3847                 return clk_set_rate(c->parent, rate * 2);
3848
3849         return -EINVAL;
3850 }
3851
3852 static long tegra11_pll_div_clk_round_rate(struct clk *c, unsigned long rate)
3853 {
3854         int divider;
3855         unsigned long parent_rate = clk_get_rate(c->parent);
3856         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3857
3858         if (c->flags & DIV_U71) {
3859                 divider = clk_div71_get_divider(
3860                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3861                 if (divider < 0)
3862                         return divider;
3863                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
3864         } else if (c->flags & DIV_2)
3865                 /* no rounding - fixed DIV_2 dividers pass rate to parent PLL */
3866                 return rate;
3867
3868         return -EINVAL;
3869 }
3870
3871 static struct clk_ops tegra_pll_div_ops = {
3872         .init                   = tegra11_pll_div_clk_init,
3873         .enable                 = tegra11_pll_div_clk_enable,
3874         .disable                = tegra11_pll_div_clk_disable,
3875         .set_rate               = tegra11_pll_div_clk_set_rate,
3876         .round_rate             = tegra11_pll_div_clk_round_rate,
3877 };
3878
3879 /* Periph clk ops */
3880 static inline u32 periph_clk_source_mask(struct clk *c)
3881 {
3882         if (c->u.periph.src_mask)
3883                 return c->u.periph.src_mask;
3884         else if (c->flags & MUX8)
3885                 return 7 << 29;
3886         else if (c->flags & MUX_PWM)
3887                 return 3 << 28;
3888         else if (c->flags & MUX_CLK_OUT)
3889                 return 3 << (c->u.periph.clk_num + 4);
3890         else if (c->flags & PLLD)
3891                 return PLLD_BASE_DSI_MUX_MASK;
3892         else
3893                 return 3 << 30;
3894 }
3895
3896 static inline u32 periph_clk_source_shift(struct clk *c)
3897 {
3898         if (c->u.periph.src_shift)
3899                 return c->u.periph.src_shift;
3900         else if (c->flags & MUX8)
3901                 return 29;
3902         else if (c->flags & MUX_PWM)
3903                 return 28;
3904         else if (c->flags & MUX_CLK_OUT)
3905                 return c->u.periph.clk_num + 4;
3906         else if (c->flags & PLLD)
3907                 return PLLD_BASE_DSI_MUX_SHIFT;
3908         else
3909                 return 30;
3910 }
3911
3912 static void tegra11_periph_clk_init(struct clk *c)
3913 {
3914         u32 val = clk_readl(c->reg);
3915         const struct clk_mux_sel *mux = 0;
3916         const struct clk_mux_sel *sel;
3917         if (c->flags & MUX) {
3918                 for (sel = c->inputs; sel->input != NULL; sel++) {
3919                         if (((val & periph_clk_source_mask(c)) >>
3920                             periph_clk_source_shift(c)) == sel->value)
3921                                 mux = sel;
3922                 }
3923                 BUG_ON(!mux);
3924
3925                 c->parent = mux->input;
3926         } else {
3927                 if (c->flags & PLLU) {
3928                         /* for xusb_hs clock enforce SS div2 source */
3929                         val &= ~periph_clk_source_mask(c);
3930                         clk_writel_delay(val, c->reg);
3931                 }
3932                 c->parent = c->inputs[0].input;
3933         }
3934
3935         if (c->flags & DIV_U71) {
3936                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
3937                 if (c->flags & DIV_U71_IDLE) {
3938                         val &= ~(PERIPH_CLK_SOURCE_DIVU71_MASK <<
3939                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
3940                         val |= (PERIPH_CLK_SOURCE_DIVIDLE_VAL <<
3941                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
3942                         clk_writel(val, c->reg);
3943                 }
3944                 c->div = divu71 + 2;
3945                 c->mul = 2;
3946         } else if (c->flags & DIV_U151) {
3947                 u32 divu151 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
3948                 if ((c->flags & DIV_U151_UART) &&
3949                     (!(val & PERIPH_CLK_UART_DIV_ENB))) {
3950                         divu151 = 0;
3951                 }
3952                 c->div = divu151 + 2;
3953                 c->mul = 2;
3954         } else if (c->flags & DIV_U16) {
3955                 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
3956                 c->div = divu16 + 1;
3957                 c->mul = 1;
3958         } else {
3959                 c->div = 1;
3960                 c->mul = 1;
3961         }
3962
3963         if (c->flags & PERIPH_NO_ENB) {
3964                 c->state = c->parent->state;
3965                 return;
3966         }
3967
3968         c->state = ON;
3969
3970         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
3971                 c->state = OFF;
3972         if (!(c->flags & PERIPH_NO_RESET))
3973                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c))
3974                         c->state = OFF;
3975 }
3976
3977 static int tegra11_periph_clk_enable(struct clk *c)
3978 {
3979         unsigned long flags;
3980         pr_debug("%s on clock %s\n", __func__, c->name);
3981
3982         if (c->flags & PERIPH_NO_ENB)
3983                 return 0;
3984
3985         spin_lock_irqsave(&periph_refcount_lock, flags);
3986
3987         tegra_periph_clk_enable_refcount[c->u.periph.clk_num]++;
3988         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] > 1) {
3989                 spin_unlock_irqrestore(&periph_refcount_lock, flags);
3990                 return 0;
3991         }
3992
3993         clk_writel_delay(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_SET_REG(c));
3994         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET)) {
3995                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c)) {
3996                         udelay(RESET_PROPAGATION_DELAY);
3997                         clk_writel(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_RST_CLR_REG(c));
3998                 }
3999         }
4000         spin_unlock_irqrestore(&periph_refcount_lock, flags);
4001         return 0;
4002 }
4003
4004 static void tegra11_periph_clk_disable(struct clk *c)
4005 {
4006         unsigned long val, flags;
4007         pr_debug("%s on clock %s\n", __func__, c->name);
4008
4009         if (c->flags & PERIPH_NO_ENB)
4010                 return;
4011
4012         spin_lock_irqsave(&periph_refcount_lock, flags);
4013
4014         if (c->refcnt)
4015                 tegra_periph_clk_enable_refcount[c->u.periph.clk_num]--;
4016
4017         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] == 0) {
4018                 /* If peripheral is in the APB bus then read the APB bus to
4019                  * flush the write operation in apb bus. This will avoid the
4020                  * peripheral access after disabling clock*/
4021                 if (c->flags & PERIPH_ON_APB)
4022                         val = tegra_read_chipid();
4023
4024                 clk_writel_delay(
4025                         PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_CLR_REG(c));
4026         }
4027         spin_unlock_irqrestore(&periph_refcount_lock, flags);
4028 }
4029
4030 static void tegra11_periph_clk_reset(struct clk *c, bool assert)
4031 {
4032         unsigned long val;
4033         pr_debug("%s %s on clock %s\n", __func__,
4034                  assert ? "assert" : "deassert", c->name);
4035
4036         if (c->flags & PERIPH_NO_ENB)
4037                 return;
4038
4039         if (!(c->flags & PERIPH_NO_RESET)) {
4040                 if (assert) {
4041                         /* If peripheral is in the APB bus then read the APB
4042                          * bus to flush the write operation in apb bus. This
4043                          * will avoid the peripheral access after disabling
4044                          * clock */
4045                         if (c->flags & PERIPH_ON_APB)
4046                                 val = tegra_read_chipid();
4047
4048                         clk_writel(PERIPH_CLK_TO_BIT(c),
4049                                    PERIPH_CLK_TO_RST_SET_REG(c));
4050                 } else
4051                         clk_writel(PERIPH_CLK_TO_BIT(c),
4052                                    PERIPH_CLK_TO_RST_CLR_REG(c));
4053         }
4054 }
4055
4056 static int tegra11_periph_clk_set_parent(struct clk *c, struct clk *p)
4057 {
4058         u32 val;
4059         const struct clk_mux_sel *sel;
4060         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
4061
4062         if (!(c->flags & MUX))
4063                 return (p == c->parent) ? 0 : (-EINVAL);
4064
4065         for (sel = c->inputs; sel->input != NULL; sel++) {
4066                 if (sel->input == p) {
4067                         val = clk_readl(c->reg);
4068                         val &= ~periph_clk_source_mask(c);
4069                         val |= (sel->value << periph_clk_source_shift(c));
4070
4071                         if (c->refcnt)
4072                                 clk_enable(p);
4073
4074                         clk_writel_delay(val, c->reg);
4075
4076                         if (c->refcnt && c->parent)
4077                                 clk_disable(c->parent);
4078
4079                         clk_reparent(c, p);
4080                         return 0;
4081                 }
4082         }
4083
4084         return -EINVAL;
4085 }
4086
4087 static int tegra11_periph_clk_set_rate(struct clk *c, unsigned long rate)
4088 {
4089         u32 val;
4090         int divider;
4091         unsigned long parent_rate = clk_get_rate(c->parent);
4092
4093         if (c->flags & DIV_U71) {
4094                 divider = clk_div71_get_divider(
4095                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
4096                 if (divider >= 0) {
4097                         val = clk_readl(c->reg);
4098                         val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
4099                         val |= divider;
4100                         clk_writel_delay(val, c->reg);
4101                         c->div = divider + 2;
4102                         c->mul = 2;
4103                         return 0;
4104                 }
4105         } else if (c->flags & DIV_U151) {
4106                 divider = clk_div151_get_divider(
4107                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
4108                 if (divider >= 0) {
4109                         val = clk_readl(c->reg);
4110                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
4111                         val |= divider;
4112                         if (c->flags & DIV_U151_UART) {
4113                                 if (divider)
4114                                         val |= PERIPH_CLK_UART_DIV_ENB;
4115                                 else
4116                                         val &= ~PERIPH_CLK_UART_DIV_ENB;
4117                         }
4118                         clk_writel_delay(val, c->reg);
4119                         c->div = divider + 2;
4120                         c->mul = 2;
4121                         return 0;
4122                 }
4123         } else if (c->flags & DIV_U16) {
4124                 divider = clk_div16_get_divider(parent_rate, rate);
4125                 if (divider >= 0) {
4126                         val = clk_readl(c->reg);
4127                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
4128                         val |= divider;
4129                         clk_writel_delay(val, c->reg);
4130                         c->div = divider + 1;
4131                         c->mul = 1;
4132                         return 0;
4133                 }
4134         } else if (parent_rate <= rate) {
4135                 c->div = 1;
4136                 c->mul = 1;
4137                 return 0;
4138         }
4139         return -EINVAL;
4140 }
4141
4142 static long tegra11_periph_clk_round_rate(struct clk *c,
4143         unsigned long rate)
4144 {
4145         int divider;
4146         unsigned long parent_rate = clk_get_rate(c->parent);
4147         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
4148
4149         if (c->flags & DIV_U71) {
4150                 divider = clk_div71_get_divider(
4151                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
4152                 if (divider < 0)
4153                         return divider;
4154
4155                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
4156         } else if (c->flags & DIV_U151) {
4157                 divider = clk_div151_get_divider(
4158                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
4159                 if (divider < 0)
4160                         return divider;
4161
4162                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
4163         } else if (c->flags & DIV_U16) {
4164                 divider = clk_div16_get_divider(parent_rate, rate);
4165                 if (divider < 0)
4166                         return divider;
4167                 return DIV_ROUND_UP(parent_rate, divider + 1);
4168         }
4169         return -EINVAL;
4170 }
4171
4172 static struct clk_ops tegra_periph_clk_ops = {
4173         .init                   = &tegra11_periph_clk_init,
4174         .enable                 = &tegra11_periph_clk_enable,
4175         .disable                = &tegra11_periph_clk_disable,
4176         .set_parent             = &tegra11_periph_clk_set_parent,
4177         .set_rate               = &tegra11_periph_clk_set_rate,
4178         .round_rate             = &tegra11_periph_clk_round_rate,
4179         .reset                  = &tegra11_periph_clk_reset,
4180 };
4181
4182 /* 1x shared bus ops */
4183 static long tegra11_1xbus_round_updown(struct clk *c, unsigned long rate,
4184                                             bool up)
4185 {
4186         int divider;
4187         unsigned long source_rate, round_rate;
4188         struct clk *new_parent;
4189
4190         rate = max(rate, c->min_rate);
4191
4192         new_parent = (rate <= c->u.periph.threshold) ?
4193                 c->u.periph.pll_low : c->u.periph.pll_high;
4194         source_rate = clk_get_rate(new_parent);
4195
4196         divider = clk_div71_get_divider(source_rate, rate, c->flags,
4197                 up ? ROUND_DIVIDER_DOWN : ROUND_DIVIDER_UP);
4198
4199         if (divider < 0)
4200                 return c->min_rate;
4201
4202         round_rate = source_rate * 2 / (divider + 2);
4203
4204         if (round_rate > c->max_rate) {
4205                 divider += c->flags & DIV_U71_INT ? 2 : 1;
4206 #if !DIVIDER_1_5_ALLOWED
4207                 divider = max(2, divider);
4208 #endif
4209                 round_rate = source_rate * 2 / (divider + 2);
4210         }
4211
4212         if (new_parent == c->u.periph.pll_high) {
4213                 /* Prevent oscillation across threshold */
4214                 if (round_rate <= c->u.periph.threshold)
4215                         round_rate = c->u.periph.threshold;
4216         }
4217         return round_rate;
4218 }
4219
4220 static long tegra11_1xbus_round_rate(struct clk *c, unsigned long rate)
4221 {
4222         return tegra11_1xbus_round_updown(c, rate, true);
4223 }
4224
4225 static int tegra11_1xbus_set_rate(struct clk *c, unsigned long rate)
4226 {
4227         /* Compensate rate truncating during rounding */
4228         return tegra11_periph_clk_set_rate(c, rate + 1);
4229 }
4230
4231 static int tegra11_clk_1xbus_update(struct clk *c)
4232 {
4233         int ret;
4234         struct clk *new_parent;
4235         unsigned long rate, old_rate;
4236
4237         if (detach_shared_bus)
4238                 return 0;
4239
4240         rate = tegra11_clk_shared_bus_update(c, NULL, NULL, NULL);
4241
4242         old_rate = clk_get_rate_locked(c);
4243         pr_debug("\n1xbus %s: rate %lu on parent %s: new request %lu\n",
4244                  c->name, old_rate, c->parent->name, rate);
4245         if (rate == old_rate)
4246                 return 0;
4247
4248         if (!c->u.periph.min_div_low || !c->u.periph.min_div_high) {
4249                 unsigned long r, m = c->max_rate;
4250                 r = clk_get_rate(c->u.periph.pll_low);
4251                 c->u.periph.min_div_low = DIV_ROUND_UP(r, m) * c->mul;
4252                 r = clk_get_rate(c->u.periph.pll_high);
4253                 c->u.periph.min_div_high = DIV_ROUND_UP(r, m) * c->mul;
4254         }
4255
4256         new_parent = (rate <= c->u.periph.threshold) ?
4257                 c->u.periph.pll_low : c->u.periph.pll_high;
4258
4259         /*
4260          * The transition procedure below is guaranteed to switch to the target
4261          * parent/rate without violation of max clock limits. It would attempt
4262          * to switch without dip in bus rate if it is possible, but this cannot
4263          * be guaranteed (example: switch from 408 MHz : 1 to 624 MHz : 2 with
4264          * maximum bus limit 408 MHz will be executed as 408 => 204 => 312 MHz,
4265          * and there is no way to avoid rate dip in this case).
4266          */
4267         if (new_parent != c->parent) {
4268                 int interim_div = 0;
4269                 /* Switching to pll_high may over-clock bus if current divider
4270                    is too small - increase divider to safe value */
4271                 if ((new_parent == c->u.periph.pll_high) &&
4272                     (c->div < c->u.periph.min_div_high))
4273                         interim_div = c->u.periph.min_div_high;
4274
4275                 /* Switching to pll_low may dip down rate if current divider
4276                    is too big - decrease divider as much as we can */
4277                 if ((new_parent == c->u.periph.pll_low) &&
4278                     (c->div > c->u.periph.min_div_low))
4279                         interim_div = c->u.periph.min_div_low;
4280
4281                 if (interim_div) {
4282                         u64 interim_rate = old_rate * c->div;
4283                         do_div(interim_rate, interim_div);
4284                         ret = clk_set_rate_locked(c, interim_rate);
4285                         if (ret) {
4286                                 pr_err("Failed to set %s rate to %lu\n",
4287                                        c->name, (unsigned long)interim_rate);
4288                                 return ret;
4289                         }
4290                         pr_debug("1xbus %s: rate %lu on parent %s\n", c->name,
4291                                  clk_get_rate_locked(c), c->parent->name);
4292                 }
4293
4294                 ret = clk_set_parent_locked(c, new_parent);
4295                 if (ret) {
4296                         pr_err("Failed to set %s parent %s\n",
4297                                c->name, new_parent->name);
4298                         return ret;
4299                 }
4300
4301                 old_rate = clk_get_rate_locked(c);
4302                 pr_debug("1xbus %s: rate %lu on parent %s\n", c->name,
4303                          old_rate, c->parent->name);
4304                 if (rate == old_rate)
4305                         return 0;
4306         }
4307
4308         ret = clk_set_rate_locked(c, rate);
4309         if (ret) {
4310                 pr_err("Failed to set %s rate to %lu\n", c->name, rate);
4311                 return ret;
4312         }
4313         pr_debug("1xbus %s: rate %lu on parent %s\n", c->name,
4314                  clk_get_rate_locked(c), c->parent->name);
4315         return 0;
4316
4317 }
4318
4319 static struct clk_ops tegra_1xbus_clk_ops = {
4320         .init                   = &tegra11_periph_clk_init,
4321         .enable                 = &tegra11_periph_clk_enable,
4322         .disable                = &tegra11_periph_clk_disable,
4323         .set_parent             = &tegra11_periph_clk_set_parent,
4324         .set_rate               = &tegra11_1xbus_set_rate,
4325         .round_rate             = &tegra11_1xbus_round_rate,
4326         .reset                  = &tegra11_periph_clk_reset,
4327         .shared_bus_update      = &tegra11_clk_1xbus_update,
4328 };
4329
4330 /* msenc clock propagation WAR for bug 1005168 */
4331 static int tegra11_msenc_clk_enable(struct clk *c)
4332 {
4333         int ret = tegra11_periph_clk_enable(c);
4334         if (ret)
4335                 return ret;
4336
4337         clk_writel(0, LVL2_CLK_GATE_OVRE);
4338         clk_writel(0x00400000, LVL2_CLK_GATE_OVRE);
4339         udelay(1);
4340         clk_writel(0, LVL2_CLK_GATE_OVRE);
4341         return 0;
4342 }
4343
4344 static struct clk_ops tegra_msenc_clk_ops = {
4345         .init                   = &tegra11_periph_clk_init,
4346         .enable                 = &tegra11_msenc_clk_enable,
4347         .disable                = &tegra11_periph_clk_disable,
4348         .set_parent             = &tegra11_periph_clk_set_parent,
4349         .set_rate               = &tegra11_periph_clk_set_rate,
4350         .round_rate             = &tegra11_periph_clk_round_rate,
4351         .reset                  = &tegra11_periph_clk_reset,
4352 };
4353 /* Periph extended clock configuration ops */
4354 static int
4355 tegra11_vi_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
4356 {
4357         if (p == TEGRA_CLK_VI_INP_SEL) {
4358                 u32 val = clk_readl(c->reg);
4359                 val &= ~PERIPH_CLK_VI_SEL_EX_MASK;
4360                 val |= (setting << PERIPH_CLK_VI_SEL_EX_SHIFT) &
4361                         PERIPH_CLK_VI_SEL_EX_MASK;
4362                 clk_writel(val, c->reg);
4363                 return 0;
4364         }
4365         return -EINVAL;
4366 }
4367
4368 static struct clk_ops tegra_vi_clk_ops = {
4369         .init                   = &tegra11_periph_clk_init,
4370         .enable                 = &tegra11_periph_clk_enable,
4371         .disable                = &tegra11_periph_clk_disable,
4372         .set_parent             = &tegra11_periph_clk_set_parent,
4373         .set_rate               = &tegra11_periph_clk_set_rate,
4374         .round_rate             = &tegra11_periph_clk_round_rate,
4375         .clk_cfg_ex             = &tegra11_vi_clk_cfg_ex,
4376         .reset                  = &tegra11_periph_clk_reset,
4377 };
4378
4379 static int
4380 tegra11_nand_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
4381 {
4382         if (p == TEGRA_CLK_NAND_PAD_DIV2_ENB) {
4383                 u32 val = clk_readl(c->reg);
4384                 if (setting)
4385                         val |= PERIPH_CLK_NAND_DIV_EX_ENB;
4386                 else
4387                         val &= ~PERIPH_CLK_NAND_DIV_EX_ENB;
4388                 clk_writel(val, c->reg);
4389                 return 0;
4390         }
4391         return -EINVAL;
4392 }
4393
4394 static struct clk_ops tegra_nand_clk_ops = {
4395         .init                   = &tegra11_periph_clk_init,
4396         .enable                 = &tegra11_periph_clk_enable,
4397         .disable                = &tegra11_periph_clk_disable,
4398         .set_parent             = &tegra11_periph_clk_set_parent,
4399         .set_rate               = &tegra11_periph_clk_set_rate,
4400         .round_rate             = &tegra11_periph_clk_round_rate,
4401         .clk_cfg_ex             = &tegra11_nand_clk_cfg_ex,
4402         .reset                  = &tegra11_periph_clk_reset,
4403 };
4404
4405
4406 static int
4407 tegra11_dtv_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
4408 {
4409         if (p == TEGRA_CLK_DTV_INVERT) {
4410                 u32 val = clk_readl(c->reg);
4411                 if (setting)
4412                         val |= PERIPH_CLK_DTV_POLARITY_INV;
4413                 else
4414                         val &= ~PERIPH_CLK_DTV_POLARITY_INV;
4415                 clk_writel(val, c->reg);
4416                 return 0;
4417         }
4418         return -EINVAL;
4419 }
4420
4421 static struct clk_ops tegra_dtv_clk_ops = {
4422         .init                   = &tegra11_periph_clk_init,
4423         .enable                 = &tegra11_periph_clk_enable,
4424         .disable                = &tegra11_periph_clk_disable,
4425         .set_parent             = &tegra11_periph_clk_set_parent,
4426         .set_rate               = &tegra11_periph_clk_set_rate,
4427         .round_rate             = &tegra11_periph_clk_round_rate,
4428         .clk_cfg_ex             = &tegra11_dtv_clk_cfg_ex,
4429         .reset                  = &tegra11_periph_clk_reset,
4430 };
4431
4432 static int tegra11_dsi_clk_set_parent(struct clk *c, struct clk *p)
4433 {
4434         const struct clk_mux_sel *sel;
4435         struct clk *d = tegra_get_clock_by_name("pll_d");
4436         if (c->reg != d->reg)
4437                 d = tegra_get_clock_by_name("pll_d2");
4438
4439         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
4440
4441         for (sel = c->inputs; sel->input != NULL; sel++) {
4442                 if (sel->input == p) {
4443                         if (c->refcnt)
4444                                 clk_enable(p);
4445
4446                         /* The DSI parent selection bit is in PLLD base
4447                            register - can not do direct r-m-w, must be
4448                            protected by PLLD lock */
4449                         tegra_clk_cfg_ex(
4450                                 d, TEGRA_CLK_PLLD_MIPI_MUX_SEL, sel->value);
4451
4452                         if (c->refcnt && c->parent)
4453                                 clk_disable(c->parent);
4454
4455                         clk_reparent(c, p);
4456                         return 0;
4457                 }
4458         }
4459
4460         return -EINVAL;
4461 }
4462
4463 static struct clk_ops tegra_dsi_clk_ops = {
4464         .init                   = &tegra11_periph_clk_init,
4465         .enable                 = &tegra11_periph_clk_enable,
4466         .disable                = &tegra11_periph_clk_disable,
4467         .set_parent             = &tegra11_dsi_clk_set_parent,
4468         .set_rate               = &tegra11_periph_clk_set_rate,
4469         .round_rate             = &tegra11_periph_clk_round_rate,
4470         .reset                  = &tegra11_periph_clk_reset,
4471 };
4472
4473 /* xusb common clock gate - enabled on init and never disabled */
4474 static void tegra11_xusb_gate_clk_init(struct clk *c)
4475 {
4476         tegra11_periph_clk_enable(c);
4477 }
4478
4479 static struct clk_ops tegra_xusb_gate_clk_ops = {
4480         .init    = tegra11_xusb_gate_clk_init,
4481 };
4482
4483 /* pciex clock support only reset function */
4484 static struct clk_ops tegra_pciex_clk_ops = {
4485         .reset    = tegra11_periph_clk_reset,
4486 };
4487
4488 /* Output clock ops */
4489
4490 static DEFINE_SPINLOCK(clk_out_lock);
4491
4492 static void tegra11_clk_out_init(struct clk *c)
4493 {
4494         const struct clk_mux_sel *mux = 0;
4495         const struct clk_mux_sel *sel;
4496         u32 val = pmc_readl(c->reg);
4497
4498         c->state = (val & (0x1 << c->u.periph.clk_num)) ? ON : OFF;
4499         c->mul = 1;
4500         c->div = 1;
4501
4502         for (sel = c->inputs; sel->input != NULL; sel++) {
4503                 if (((val & periph_clk_source_mask(c)) >>
4504                      periph_clk_source_shift(c)) == sel->value)
4505                         mux = sel;
4506         }
4507         BUG_ON(!mux);
4508         c->parent = mux->input;
4509 }
4510
4511 static int tegra11_clk_out_enable(struct clk *c)
4512 {
4513         u32 val;
4514         unsigned long flags;
4515
4516         pr_debug("%s on clock %s\n", __func__, c->name);
4517
4518         spin_lock_irqsave(&clk_out_lock, flags);
4519         val = pmc_readl(c->reg);
4520         val |= (0x1 << c->u.periph.clk_num);
4521         pmc_writel(val, c->reg);
4522         spin_unlock_irqrestore(&clk_out_lock, flags);
4523
4524         return 0;
4525 }
4526
4527 static void tegra11_clk_out_disable(struct clk *c)
4528 {
4529         u32 val;
4530         unsigned long flags;
4531
4532         pr_debug("%s on clock %s\n", __func__, c->name);
4533
4534         spin_lock_irqsave(&clk_out_lock, flags);
4535         val = pmc_readl(c->reg);
4536         val &= ~(0x1 << c->u.periph.clk_num);
4537         pmc_writel(val, c->reg);
4538         spin_unlock_irqrestore(&clk_out_lock, flags);
4539 }
4540
4541 static int tegra11_clk_out_set_parent(struct clk *c, struct clk *p)
4542 {
4543         u32 val;
4544         unsigned long flags;
4545         const struct clk_mux_sel *sel;
4546
4547         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
4548
4549         for (sel = c->inputs; sel->input != NULL; sel++) {
4550                 if (sel->input == p) {
4551                         if (c->refcnt)
4552                                 clk_enable(p);
4553
4554                         spin_lock_irqsave(&clk_out_lock, flags);
4555                         val = pmc_readl(c->reg);
4556                         val &= ~periph_clk_source_mask(c);
4557                         val |= (sel->value << periph_clk_source_shift(c));
4558                         pmc_writel(val, c->reg);
4559                         spin_unlock_irqrestore(&clk_out_lock, flags);
4560
4561                         if (c->refcnt && c->parent)
4562                                 clk_disable(c->parent);
4563
4564                         clk_reparent(c, p);
4565                         return 0;
4566                 }
4567         }
4568         return -EINVAL;
4569 }
4570
4571 static struct clk_ops tegra_clk_out_ops = {
4572         .init                   = &tegra11_clk_out_init,
4573         .enable                 = &tegra11_clk_out_enable,
4574         .disable                = &tegra11_clk_out_disable,
4575         .set_parent             = &tegra11_clk_out_set_parent,
4576 };
4577
4578
4579 /* External memory controller clock ops */
4580 static void tegra11_emc_clk_init(struct clk *c)
4581 {
4582         tegra11_periph_clk_init(c);
4583         tegra_emc_dram_type_init(c);
4584 }
4585
4586 static long tegra11_emc_clk_round_updown(struct clk *c, unsigned long rate,
4587                                          bool up)
4588 {
4589         unsigned long new_rate = max(rate, c->min_rate);
4590
4591         new_rate = tegra_emc_round_rate_updown(new_rate, up);
4592         if (IS_ERR_VALUE(new_rate))
4593                 new_rate = c->max_rate;
4594
4595         return new_rate;
4596 }
4597
4598 static long tegra11_emc_clk_round_rate(struct clk *c, unsigned long rate)
4599 {
4600         return tegra11_emc_clk_round_updown(c, rate, true);
4601 }
4602
4603 static int tegra11_emc_clk_set_rate(struct clk *c, unsigned long rate)
4604 {
4605         int ret;
4606         u32 div_value;
4607         struct clk *p;
4608
4609         /* The tegra11x memory controller has an interlock with the clock
4610          * block that allows memory shadowed registers to be updated,
4611          * and then transfer them to the main registers at the same
4612          * time as the clock update without glitches. During clock change
4613          * operation both clock parent and divider may change simultaneously
4614          * to achieve requested rate. */
4615         p = tegra_emc_predict_parent(rate, &div_value);
4616         div_value += 2;         /* emc has fractional DIV_U71 divider */
4617         if (IS_ERR_OR_NULL(p)) {
4618                 pr_err("%s: Failed to predict emc parent for rate %lu\n",
4619                        __func__, rate);
4620                 return -EINVAL;
4621         }
4622
4623         if (p == c->parent) {
4624                 if (div_value == c->div)
4625                         return 0;
4626         } else if (c->refcnt)
4627                 clk_enable(p);
4628
4629         ret = tegra_emc_set_rate(rate);
4630         if (ret < 0)
4631                 return ret;
4632
4633         if (p != c->parent) {
4634                 if(c->refcnt && c->parent)
4635                         clk_disable(c->parent);
4636                 clk_reparent(c, p);
4637         }
4638         c->div = div_value;
4639         c->mul = 2;
4640         return 0;
4641 }
4642
4643 static int tegra11_clk_emc_bus_update(struct clk *bus)
4644 {
4645         struct clk *p = NULL;
4646         unsigned long rate, old_rate, parent_rate, backup_rate;
4647
4648         if (detach_shared_bus)
4649                 return 0;
4650
4651         rate = tegra11_clk_shared_bus_update(bus, NULL, NULL, NULL);
4652
4653         old_rate = clk_get_rate_locked(bus);
4654         if (rate == old_rate)
4655                 return 0;
4656
4657         if (!tegra_emc_is_parent_ready(rate, &p, &parent_rate, &backup_rate)) {
4658                 if (bus->parent == p) {
4659                         /* need backup to re-lock current parent */
4660                         int ret;
4661                         if (IS_ERR_VALUE(backup_rate)) {
4662                                 pr_err("%s: No backup for %s rate %lu\n",
4663                                        __func__, bus->name, rate);
4664                                 return -EINVAL;
4665                         }
4666
4667                         /* set volatge for backup rate if going up */
4668                         if (backup_rate > old_rate) {
4669                                 ret = tegra_dvfs_set_rate(bus, backup_rate);
4670                                 if (ret) {
4671                                         pr_err("%s: dvfs failed on %s rate %lu\n",
4672                                               __func__, bus->name, backup_rate);
4673                                         return -EINVAL;
4674                                 }
4675                         }
4676
4677                         trace_clock_set_rate(bus->name, backup_rate, 0);
4678                         ret = bus->ops->set_rate(bus, backup_rate);
4679                         if (ret) {
4680                                 pr_err("%s: Failed to backup %s for rate %lu\n",
4681                                        __func__, bus->name, rate);
4682                                 return -EINVAL;
4683                         }
4684                         clk_rate_change_notify(bus, backup_rate);
4685                 }
4686                 if (p->refcnt) {
4687                         pr_err("%s: %s has other than emc child\n",
4688                                __func__, p->name);
4689                         return -EINVAL;
4690                 }
4691
4692                 if (clk_set_rate(p, parent_rate)) {
4693                         pr_err("%s: Failed to set %s rate %lu\n",
4694                                __func__, p->name, parent_rate);
4695                         return -EINVAL;
4696                 }
4697         }
4698
4699         return clk_set_rate_locked(bus, rate);
4700 }
4701
4702 static struct clk_ops tegra_emc_clk_ops = {
4703         .init                   = &tegra11_emc_clk_init,
4704         .enable                 = &tegra11_periph_clk_enable,
4705         .disable                = &tegra11_periph_clk_disable,
4706         .set_rate               = &tegra11_emc_clk_set_rate,
4707         .round_rate             = &tegra11_emc_clk_round_rate,
4708         .round_rate_updown      = &tegra11_emc_clk_round_updown,
4709         .reset                  = &tegra11_periph_clk_reset,
4710         .shared_bus_update      = &tegra11_clk_emc_bus_update,
4711 };
4712
4713 /* Clock doubler ops (non-atomic shared register access) */
4714 static DEFINE_SPINLOCK(doubler_lock);
4715
4716 static void tegra11_clk_double_init(struct clk *c)
4717 {
4718         u32 val = clk_readl(c->reg);
4719         c->mul = val & (0x1 << c->reg_shift) ? 1 : 2;
4720         c->div = 1;
4721         c->state = ON;
4722         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
4723                 c->state = OFF;
4724 };
4725
4726 static int tegra11_clk_double_set_rate(struct clk *c, unsigned long rate)
4727 {
4728         u32 val;
4729         unsigned long parent_rate = clk_get_rate(c->parent);
4730         unsigned long flags;
4731
4732         if (rate == parent_rate) {
4733                 spin_lock_irqsave(&doubler_lock, flags);
4734                 val = clk_readl(c->reg) | (0x1 << c->reg_shift);
4735                 clk_writel(val, c->reg);
4736                 c->mul = 1;
4737                 c->div = 1;
4738                 spin_unlock_irqrestore(&doubler_lock, flags);
4739                 return 0;
4740         } else if (rate == 2 * parent_rate) {
4741                 spin_lock_irqsave(&doubler_lock, flags);
4742                 val = clk_readl(c->reg) & (~(0x1 << c->reg_shift));
4743                 clk_writel(val, c->reg);
4744                 c->mul = 2;
4745                 c->div = 1;
4746                 spin_unlock_irqrestore(&doubler_lock, flags);
4747                 return 0;
4748         }
4749         return -EINVAL;
4750 }
4751
4752 static struct clk_ops tegra_clk_double_ops = {
4753         .init                   = &tegra11_clk_double_init,
4754         .enable                 = &tegra11_periph_clk_enable,
4755         .disable                = &tegra11_periph_clk_disable,
4756         .set_rate               = &tegra11_clk_double_set_rate,
4757 };
4758
4759 /* Audio sync clock ops */
4760 static int tegra11_sync_source_set_rate(struct clk *c, unsigned long rate)
4761 {
4762         c->rate = rate;
4763         return 0;
4764 }
4765
4766 static struct clk_ops tegra_sync_source_ops = {
4767         .set_rate               = &tegra11_sync_source_set_rate,
4768 };
4769
4770 static void tegra11_audio_sync_clk_init(struct clk *c)
4771 {
4772         int source;
4773         const struct clk_mux_sel *sel;
4774         u32 val = clk_readl(c->reg);
4775         c->state = (val & AUDIO_SYNC_DISABLE_BIT) ? OFF : ON;
4776         source = val & AUDIO_SYNC_SOURCE_MASK;
4777         for (sel = c->inputs; sel->input != NULL; sel++)
4778                 if (sel->value == source)
4779                         break;
4780         BUG_ON(sel->input == NULL);
4781         c->parent = sel->input;
4782 }
4783
4784 static int tegra11_audio_sync_clk_enable(struct clk *c)
4785 {
4786         u32 val = clk_readl(c->reg);
4787         clk_writel((val & (~AUDIO_SYNC_DISABLE_BIT)), c->reg);
4788         return 0;
4789 }
4790
4791 static void tegra11_audio_sync_clk_disable(struct clk *c)
4792 {
4793         u32 val = clk_readl(c->reg);
4794         clk_writel((val | AUDIO_SYNC_DISABLE_BIT), c->reg);
4795 }
4796
4797 static int tegra11_audio_sync_clk_set_parent(struct clk *c, struct clk *p)
4798 {
4799         u32 val;
4800         const struct clk_mux_sel *sel;
4801         for (sel = c->inputs; sel->input != NULL; sel++) {
4802                 if (sel->input == p) {
4803                         val = clk_readl(c->reg);
4804                         val &= ~AUDIO_SYNC_SOURCE_MASK;
4805                         val |= sel->value;
4806
4807                         if (c->refcnt)
4808                                 clk_enable(p);
4809
4810                         clk_writel(val, c->reg);
4811
4812                         if (c->refcnt && c->parent)
4813                                 clk_disable(c->parent);
4814
4815                         clk_reparent(c, p);
4816                         return 0;
4817                 }
4818         }
4819
4820         return -EINVAL;
4821 }
4822
4823 static struct clk_ops tegra_audio_sync_clk_ops = {
4824         .init       = tegra11_audio_sync_clk_init,
4825         .enable     = tegra11_audio_sync_clk_enable,
4826         .disable    = tegra11_audio_sync_clk_disable,
4827         .set_parent = tegra11_audio_sync_clk_set_parent,
4828 };
4829
4830
4831 /* cbus ops */
4832 /*
4833  * Some clocks require dynamic re-locking of source PLL in order to
4834  * achieve frequency scaling granularity that matches characterized
4835  * core voltage steps. The cbus clock creates a shared bus that
4836  * provides a virtual root for such clocks to hide and synchronize
4837  * parent PLL re-locking as well as backup operations.
4838 */
4839
4840 static void tegra11_clk_cbus_init(struct clk *c)
4841 {
4842         c->state = OFF;
4843         c->set = true;
4844 }
4845
4846 static int tegra11_clk_cbus_enable(struct clk *c)
4847 {
4848         return 0;
4849 }
4850
4851 /* select 5 steps below top rate as fine granularity region */
4852 #define CBUS_FINE_GRANULARITY           12000000        /* 12 MHz */
4853 #define CBUS_FINE_GRANULARITY_RANGE     (5 * CBUS_FINE_GRANULARITY)
4854
4855 static long tegra11_clk_cbus_round_updown(struct clk *c, unsigned long rate,
4856                                           bool up)
4857 {
4858         int i, n;
4859
4860         if (!c->dvfs) {
4861                 if (!c->min_rate)
4862                         c->min_rate = c->parent->min_rate;
4863                 rate = max(rate, c->min_rate);
4864                 return rate;
4865         }
4866
4867         /* update min now, since no dvfs table was available during init
4868            (skip placeholder entries set to 1 kHz) */
4869         if (!c->min_rate) {
4870                 for (i = 0; i < (c->dvfs->num_freqs - 1); i++) {
4871                         if (c->dvfs->freqs[i] > 1 * c->dvfs->freqs_mult) {
4872                                 c->min_rate = c->dvfs->freqs[i];
4873                                 break;
4874                         }
4875                 }
4876                 BUG_ON(!c->min_rate);
4877         }
4878         rate = max(rate, c->min_rate);
4879
4880         /* for top rates in fine granularity region don't clip to dvfs table */
4881         n = c->dvfs->num_freqs;
4882         if ((n >= 2) && (c->dvfs->millivolts[n-1] <= c->dvfs->max_millivolts) &&
4883             (rate > c->dvfs->freqs[n-2])) {
4884                 unsigned long threshold = max(c->dvfs->freqs[n-1],
4885                         c->dvfs->freqs[n-2] + CBUS_FINE_GRANULARITY_RANGE);
4886                 threshold -= CBUS_FINE_GRANULARITY_RANGE;
4887
4888                 if (rate <= threshold)
4889                         return up ? threshold : c->dvfs->freqs[n-2];
4890
4891                 rate = (up ? DIV_ROUND_UP(rate, CBUS_FINE_GRANULARITY) :
4892                         rate / CBUS_FINE_GRANULARITY) * CBUS_FINE_GRANULARITY;
4893                 rate = clamp(rate, threshold, c->dvfs->freqs[n-1]);
4894                 return rate;
4895         }
4896
4897         /* clip rate to dvfs table steps */
4898         for (i = 0; ; i++) {
4899                 unsigned long f = c->dvfs->freqs[i];
4900                 int mv = c->dvfs->millivolts[i];
4901                 if ((f >= rate) || (mv >= c->dvfs->max_millivolts) ||
4902                     ((i + 1) >=  c->dvfs->num_freqs)) {
4903                         if (!up && i && (f > rate))
4904                                 i--;
4905                         break;
4906                 }
4907         }
4908         return c->dvfs->freqs[i];
4909 }
4910
4911 static long tegra11_clk_cbus_round_rate(struct clk *c, unsigned long rate)
4912 {
4913         return tegra11_clk_cbus_round_updown(c, rate, true);
4914 }
4915
4916 static int cbus_switch_one(struct clk *c, struct clk *p, u32 div, bool abort)
4917 {
4918         int ret = 0;
4919
4920         /* set new divider if it is bigger than the current one */
4921         if (c->div < c->mul * div) {
4922                 ret = clk_set_div(c, div);
4923                 if (ret) {
4924                         pr_err("%s: failed to set %s clock divider %u: %d\n",
4925                                __func__, c->name, div, ret);
4926                         if (abort)
4927                                 return ret;
4928                 }
4929         }
4930
4931         if (c->parent != p) {
4932                 ret = clk_set_parent(c, p);
4933                 if (ret) {
4934                         pr_err("%s: failed to set %s clock parent %s: %d\n",
4935                                __func__, c->name, p->name, ret);
4936                         if (abort)
4937                                 return ret;
4938                 }
4939         }
4940
4941         /* set new divider if it is smaller than the current one */
4942         if (c->div > c->mul * div) {
4943                 ret = clk_set_div(c, div);
4944                 if (ret)
4945                         pr_err("%s: failed to set %s clock divider %u: %d\n",
4946                                __func__, c->name, div, ret);
4947         }
4948
4949         return ret;
4950 }
4951
4952 static int cbus_backup(struct clk *c)
4953 {
4954         int ret;
4955         struct clk *user;
4956
4957         list_for_each_entry(user, &c->shared_bus_list,
4958                         u.shared_bus_user.node) {
4959                 struct clk *client = user->u.shared_bus_user.client;
4960                 if (client && (client->state == ON) &&
4961                     (client->parent == c->parent)) {
4962                         ret = cbus_switch_one(client,
4963                                               c->shared_bus_backup.input,
4964                                               c->shared_bus_backup.value *
4965                                               user->div, true);
4966                         if (ret)
4967                                 return ret;
4968                 }
4969         }
4970         return 0;
4971 }
4972
4973 static int cbus_dvfs_set_rate(struct clk *c, unsigned long rate)
4974 {
4975         int ret;
4976         struct clk *user;
4977
4978         list_for_each_entry(user, &c->shared_bus_list,
4979                         u.shared_bus_user.node) {
4980                 struct clk *client =  user->u.shared_bus_user.client;
4981                 if (client && client->refcnt && (client->parent == c->parent)) {
4982                         ret = tegra_dvfs_set_rate(c, rate);
4983                         if (ret)
4984                                 return ret;
4985                 }
4986         }
4987         return 0;
4988 }
4989
4990 static void cbus_restore(struct clk *c)
4991 {
4992         struct clk *user;
4993
4994         list_for_each_entry(user, &c->shared_bus_list,
4995                         u.shared_bus_user.node) {
4996                 if (user->u.shared_bus_user.client)
4997                         cbus_switch_one(user->u.shared_bus_user.client,
4998                                         c->parent, c->div * user->div, false);
4999         }
5000 }
5001
5002 static int get_next_backup_div(struct clk *c, unsigned long rate)
5003 {
5004         u32 div = c->div;
5005         unsigned long backup_rate = clk_get_rate(c->shared_bus_backup.input);
5006
5007         rate = max(rate, clk_get_rate_locked(c));
5008         rate = rate - (rate >> 2);      /* 25% margin for backup rate */
5009         if ((u64)rate * div < backup_rate)
5010                 div = DIV_ROUND_UP(backup_rate, rate);
5011
5012         BUG_ON(!div);
5013         return div;
5014 }
5015
5016 static int tegra11_clk_cbus_set_rate(struct clk *c, unsigned long rate)
5017 {
5018         int ret;
5019         bool dramp;
5020
5021         if (rate == 0)
5022                 return 0;
5023
5024         ret = clk_enable(c->parent);
5025         if (ret) {
5026                 pr_err("%s: failed to enable %s clock: %d\n",
5027                        __func__, c->name, ret);
5028                 return ret;
5029         }
5030
5031         dramp = tegra11_is_dyn_ramp(c->parent, rate * c->div, false);
5032         if (!dramp) {
5033                 c->shared_bus_backup.value = get_next_backup_div(c, rate);
5034                 ret = cbus_backup(c);
5035                 if (ret)
5036                         goto out;
5037         }
5038
5039         ret = clk_set_rate(c->parent, rate * c->div);
5040         if (ret) {
5041                 pr_err("%s: failed to set %s clock rate %lu: %d\n",
5042                        __func__, c->name, rate, ret);
5043                 goto out;
5044         }
5045
5046         /* Safe voltage setting is taken care of by cbus clock dvfs; the call
5047          * below only records requirements for each enabled client.
5048          */
5049         if (dramp)
5050                 ret = cbus_dvfs_set_rate(c, rate);
5051
5052         cbus_restore(c);
5053
5054 out:
5055         clk_disable(c->parent);
5056         return ret;
5057 }
5058
5059 static inline void cbus_move_enabled_user(
5060         struct clk *user, struct clk *dst, struct clk *src)
5061 {
5062         clk_enable(dst);
5063         list_move_tail(&user->u.shared_bus_user.node, &dst->shared_bus_list);
5064         clk_disable(src);
5065         clk_reparent(user, dst);
5066 }
5067
5068 #ifdef CONFIG_TEGRA_DYNAMIC_CBUS
5069 static int tegra11_clk_cbus_update(struct clk *bus)
5070 {
5071         int ret, mv;
5072         struct clk *slow = NULL;
5073         struct clk *top = NULL;
5074         unsigned long rate;
5075         unsigned long old_rate;
5076         unsigned long ceiling;
5077
5078         if (detach_shared_bus)
5079                 return 0;
5080
5081         rate = tegra11_clk_shared_bus_update(bus, &top, &slow, &ceiling);
5082
5083         /* use dvfs table of the slowest enabled client as cbus dvfs table */
5084         if (bus->dvfs && slow && (slow != bus->u.cbus.slow_user)) {
5085                 int i;
5086                 unsigned long *dest = &bus->dvfs->freqs[0];
5087                 unsigned long *src =
5088                         &slow->u.shared_bus_user.client->dvfs->freqs[0];
5089                 if (slow->div > 1)
5090                         for (i = 0; i < bus->dvfs->num_freqs; i++)
5091                                 dest[i] = src[i] * slow->div;
5092                 else
5093                         memcpy(dest, src, sizeof(*dest) * bus->dvfs->num_freqs);
5094         }
5095
5096         /* update bus state variables and rate */
5097         bus->u.cbus.slow_user = slow;
5098         bus->u.cbus.top_user = top;
5099
5100         rate = tegra11_clk_cap_shared_bus(bus, rate, ceiling);
5101         mv = tegra_dvfs_predict_millivolts(bus, rate);
5102         if (IS_ERR_VALUE(mv))
5103                 return -EINVAL;
5104
5105         if (bus->dvfs) {
5106                 mv -= bus->dvfs->cur_millivolts;
5107                 if (bus->refcnt && (mv > 0)) {
5108                         ret = tegra_dvfs_set_rate(bus, rate);
5109                         if (ret)
5110                                 return ret;
5111                 }
5112         }
5113
5114         old_rate = clk_get_rate_locked(bus);
5115         if (IS_ENABLED(CONFIG_TEGRA_MIGRATE_CBUS_USERS) || (old_rate != rate)) {
5116                 ret = bus->ops->set_rate(bus, rate);
5117                 if (ret)
5118                         return ret;
5119         }
5120
5121         if (bus->dvfs) {
5122                 if (bus->refcnt && (mv <= 0)) {
5123                         ret = tegra_dvfs_set_rate(bus, rate);
5124                         if (ret)
5125                                 return ret;
5126                 }
5127         }
5128
5129         clk_rate_change_notify(bus, rate);
5130         return 0;
5131 };
5132 #else
5133 static int tegra11_clk_cbus_update(struct clk *bus)
5134 {
5135         unsigned long rate, old_rate;
5136
5137         if (detach_shared_bus)
5138                 return 0;
5139
5140         rate = tegra11_clk_shared_bus_update(bus, NULL, NULL, NULL);
5141
5142         old_rate = clk_get_rate_locked(bus);
5143         if (rate == old_rate)
5144                 return 0;
5145
5146         return clk_set_rate_locked(bus, rate);
5147 }
5148 #endif
5149
5150 static int tegra11_clk_cbus_migrate_users(struct clk *user)
5151 {
5152 #ifdef CONFIG_TEGRA_MIGRATE_CBUS_USERS
5153         struct clk *src_bus, *dst_bus, *top_user, *c;
5154         struct list_head *pos, *n;
5155
5156         if (!user->u.shared_bus_user.client || !user->inputs)
5157                 return 0;
5158
5159         /* Dual cbus on Tegra11 */
5160         src_bus = user->inputs[0].input;
5161         dst_bus = user->inputs[1].input;
5162
5163         if (!src_bus->u.cbus.top_user && !dst_bus->u.cbus.top_user)
5164                 return 0;
5165
5166         /* Make sure top user on the source bus is requesting highest rate */
5167         if (!src_bus->u.cbus.top_user || (dst_bus->u.cbus.top_user &&
5168                 bus_user_request_is_lower(src_bus->u.cbus.top_user,
5169                                            dst_bus->u.cbus.top_user)))
5170                 swap(src_bus, dst_bus);
5171
5172         /* If top user is the slow one on its own (source) bus, do nothing */
5173         top_user = src_bus->u.cbus.top_user;
5174         BUG_ON(!top_user->u.shared_bus_user.client);
5175         if (!bus_user_is_slower(src_bus->u.cbus.slow_user, top_user))
5176                 return 0;
5177
5178         /* If source bus top user is slower than all users on destination bus,
5179            move top user; otherwise move all users slower than the top one */
5180         if (!dst_bus->u.cbus.slow_user ||
5181             !bus_user_is_slower(dst_bus->u.cbus.slow_user, top_user)) {
5182                 cbus_move_enabled_user(top_user, dst_bus, src_bus);
5183         } else {
5184                 list_for_each_safe(pos, n, &src_bus->shared_bus_list) {
5185                         c = list_entry(pos, struct clk, u.shared_bus_user.node);
5186                         if (c->u.shared_bus_user.enabled &&
5187                             c->u.shared_bus_user.client &&
5188                             bus_user_is_slower(c, top_user))
5189                                 cbus_move_enabled_user(c, dst_bus, src_bus);
5190                 }
5191         }
5192
5193         /* Update destination bus 1st (move clients), then source */
5194         tegra_clk_shared_bus_update(dst_bus);
5195         tegra_clk_shared_bus_update(src_bus);
5196 #endif
5197         return 0;
5198 }
5199
5200 static struct clk_ops tegra_clk_cbus_ops = {
5201         .init = tegra11_clk_cbus_init,
5202         .enable = tegra11_clk_cbus_enable,
5203         .set_rate = tegra11_clk_cbus_set_rate,
5204         .round_rate = tegra11_clk_cbus_round_rate,
5205         .round_rate_updown = tegra11_clk_cbus_round_updown,
5206         .shared_bus_update = tegra11_clk_cbus_update,
5207 };
5208
5209 /* shared bus ops */
5210 /*
5211  * Some clocks may have multiple downstream users that need to request a
5212  * higher clock rate.  Shared bus clocks provide a unique shared_bus_user
5213  * clock to each user.  The frequency of the bus is set to the highest
5214  * enabled shared_bus_user clock, with a minimum value set by the
5215  * shared bus.
5216  *
5217  * Optionally shared bus may support users migration. Since shared bus and
5218  * its * children (users) have reversed rate relations: user rates determine
5219  * bus rate, * switching user from one parent/bus to another may change rates
5220  * of both parents. Therefore we need a cross-bus lock on top of individual
5221  * user and bus locks. For now, limit bus switch support to cbus only if
5222  * CONFIG_TEGRA_MIGRATE_CBUS_USERS is set.
5223  */
5224
5225 static unsigned long tegra11_clk_shared_bus_update(struct clk *bus,
5226         struct clk **bus_top, struct clk **bus_slow, unsigned long *rate_cap)
5227 {
5228         struct clk *c;
5229         struct clk *slow = NULL;
5230         struct clk *top = NULL;
5231
5232         unsigned long override_rate = 0;
5233         unsigned long top_rate = 0;
5234         unsigned long rate = bus->min_rate;
5235         unsigned long bw = 0;
5236         unsigned long iso_bw = 0;
5237         unsigned long ceiling = bus->max_rate;
5238         unsigned long ceiling_but_iso = bus->max_rate;
5239         u32 usage_flags = 0;
5240
5241         list_for_each_entry(c, &bus->shared_bus_list,
5242                         u.shared_bus_user.node) {
5243                 /*
5244                  * Ignore requests from disabled floor and bw users, and from
5245                  * auto-users riding the bus. Always honor ceiling users, even
5246                  * if they are disabled - we do not want to keep enabled parent
5247                  * bus just because ceiling is set.
5248                  */
5249                 if (c->u.shared_bus_user.enabled ||
5250                     (c->u.shared_bus_user.mode == SHARED_CEILING) ||
5251                     (c->u.shared_bus_user.mode == SHARED_CEILING_BUT_ISO)) {
5252                         unsigned long request_rate = c->u.shared_bus_user.rate *
5253                                 (c->div ? : 1);
5254                         usage_flags |= c->u.shared_bus_user.usage_flag;
5255
5256                         switch (c->u.shared_bus_user.mode) {
5257                         case SHARED_ISO_BW:
5258                                 iso_bw += request_rate;
5259                                 if (iso_bw > bus->max_rate)
5260                                         iso_bw = bus->max_rate;
5261                                 /* fall thru */
5262                         case SHARED_BW:
5263                                 bw += request_rate;
5264                                 if (bw > bus->max_rate)
5265                                         bw = bus->max_rate;
5266                                 break;
5267                         case SHARED_CEILING_BUT_ISO:
5268                                 ceiling_but_iso =
5269                                         min(request_rate, ceiling_but_iso);
5270                                 break;
5271                         case SHARED_CEILING:
5272                                 ceiling = min(request_rate, ceiling);
5273                                 break;
5274                         case SHARED_OVERRIDE:
5275                                 if (override_rate == 0)
5276                                         override_rate = request_rate;
5277                                 break;
5278                         case SHARED_AUTO:
5279                                 break;
5280                         case SHARED_FLOOR:
5281                         default:
5282                                 rate = max(request_rate, rate);
5283                                 if (c->u.shared_bus_user.client
5284                                                         && request_rate) {
5285                                         if (top_rate < request_rate) {
5286                                                 top_rate = request_rate;
5287                                                 top = c;
5288                                         } else if ((top_rate == request_rate) &&
5289                                                 bus_user_is_slower(c, top)) {
5290                                                 top = c;
5291                                         }
5292                                 }
5293                         }
5294                         if (c->u.shared_bus_user.client &&
5295                                 (!slow || bus_user_is_slower(c, slow)))
5296                                 slow = c;
5297                 }
5298         }
5299
5300         if (bus->flags & PERIPH_EMC_ENB)
5301                 bw = tegra_emc_apply_efficiency(
5302                         bw, iso_bw, bus->max_rate, usage_flags, NULL);
5303
5304         rate = override_rate ? : max(rate, bw);
5305         ceiling = min(ceiling, ceiling_but_iso);
5306         ceiling = override_rate ? bus->max_rate : ceiling;
5307
5308         if (bus_top && bus_slow && rate_cap) {
5309                 /* If dynamic bus dvfs table, let the caller to complete
5310                    rounding and aggregation */
5311                 *bus_top = top;
5312                 *bus_slow = slow;
5313                 *rate_cap = ceiling;
5314         } else {
5315                 /* If satic bus dvfs table, complete rounding and aggregation */
5316                 rate = tegra11_clk_cap_shared_bus(bus, rate, ceiling);
5317         }
5318
5319         return rate;
5320 };
5321
5322 static unsigned long tegra11_clk_cap_shared_bus(struct clk *bus,
5323         unsigned long rate, unsigned long ceiling)
5324 {
5325         if (bus->ops && bus->ops->round_rate_updown)
5326                 ceiling = bus->ops->round_rate_updown(bus, ceiling, false);
5327
5328         rate = min(rate, ceiling);
5329
5330         if (bus->ops && bus->ops->round_rate)
5331                 rate = bus->ops->round_rate(bus, rate);
5332
5333         return rate;
5334 }
5335
5336 static int tegra_clk_shared_bus_migrate_users(struct clk *user)
5337 {
5338         if (detach_shared_bus)
5339                 return 0;
5340
5341         /* Only cbus migration is supported */
5342         if (user->flags & PERIPH_ON_CBUS)
5343                 return tegra11_clk_cbus_migrate_users(user);
5344         return -ENOSYS;
5345 }
5346
5347 static void tegra_clk_shared_bus_user_init(struct clk *c)
5348 {
5349         c->max_rate = c->parent->max_rate;
5350         c->u.shared_bus_user.rate = c->parent->max_rate;
5351         c->state = OFF;
5352         c->set = true;
5353
5354         if ((c->u.shared_bus_user.mode == SHARED_CEILING) ||
5355             (c->u.shared_bus_user.mode == SHARED_CEILING_BUT_ISO)) {
5356                 c->state = ON;
5357                 c->refcnt++;
5358         }
5359
5360         if (c->u.shared_bus_user.client_id) {
5361                 c->u.shared_bus_user.client =
5362                         tegra_get_clock_by_name(c->u.shared_bus_user.client_id);
5363                 if (!c->u.shared_bus_user.client) {
5364                         pr_err("%s: could not find clk %s\n", __func__,
5365                                c->u.shared_bus_user.client_id);
5366                         return;
5367                 }
5368                 c->u.shared_bus_user.client->flags |=
5369                         c->parent->flags & PERIPH_ON_CBUS;
5370                 c->flags |= c->parent->flags & PERIPH_ON_CBUS;
5371                 c->div = c->u.shared_bus_user.client_div ? : 1;
5372                 c->mul = 1;
5373         }
5374
5375         list_add_tail(&c->u.shared_bus_user.node,
5376                 &c->parent->shared_bus_list);
5377 }
5378
5379 static int tegra_clk_shared_bus_user_set_parent(struct clk *c, struct clk *p)
5380 {
5381         int ret;
5382         const struct clk_mux_sel *sel;
5383
5384         if (detach_shared_bus)
5385                 return 0;
5386
5387         if (c->parent == p)
5388                 return 0;
5389
5390         if (!(c->inputs && c->cross_clk_mutex && clk_cansleep(c)))
5391                 return -ENOSYS;
5392
5393         for (sel = c->inputs; sel->input != NULL; sel++) {
5394                 if (sel->input == p)
5395                         break;
5396         }
5397         if (!sel->input)
5398                 return -EINVAL;
5399
5400         if (c->refcnt)
5401                 clk_enable(p);
5402
5403         list_move_tail(&c->u.shared_bus_user.node, &p->shared_bus_list);
5404         ret = tegra_clk_shared_bus_update(p);
5405         if (ret) {
5406                 list_move_tail(&c->u.shared_bus_user.node,
5407                                &c->parent->shared_bus_list);
5408                 tegra_clk_shared_bus_update(c->parent);
5409                 clk_disable(p);
5410                 return ret;
5411         }
5412
5413         tegra_clk_shared_bus_update(c->parent);
5414
5415         if (c->refcnt)
5416                 clk_disable(c->parent);
5417
5418         clk_reparent(c, p);
5419
5420         return 0;
5421 }
5422
5423 static int tegra_clk_shared_bus_user_set_rate(struct clk *c, unsigned long rate)
5424 {
5425         int ret;
5426
5427         c->u.shared_bus_user.rate = rate;
5428         ret = tegra_clk_shared_bus_update(c->parent);
5429
5430         if (!ret && c->cross_clk_mutex && clk_cansleep(c))
5431                 tegra_clk_shared_bus_migrate_users(c);
5432
5433         return ret;
5434 }
5435
5436 static long tegra_clk_shared_bus_user_round_rate(
5437         struct clk *c, unsigned long rate)
5438 {
5439         /* Defer rounding requests until aggregated. BW users must not be
5440            rounded at all, others just clipped to bus range (some clients
5441            may use round api to find limits) */
5442         if ((c->u.shared_bus_user.mode != SHARED_BW) &&
5443             (c->u.shared_bus_user.mode != SHARED_ISO_BW)) {
5444                 if (c->div > 1)
5445                         rate *= c->div;
5446
5447                 if (rate > c->parent->max_rate)
5448                         rate = c->parent->max_rate;
5449                 else if (rate < c->parent->min_rate)
5450                         rate = c->parent->min_rate;
5451
5452                 if (c->div > 1)
5453                         rate /= c->div;
5454         }
5455         return rate;
5456 }
5457
5458 static int tegra_clk_shared_bus_user_enable(struct clk *c)
5459 {
5460         int ret;
5461
5462         c->u.shared_bus_user.enabled = true;
5463         ret = tegra_clk_shared_bus_update(c->parent);
5464         if (!ret && c->u.shared_bus_user.client)
5465                 ret = clk_enable(c->u.shared_bus_user.client);
5466
5467         if (!ret && c->cross_clk_mutex && clk_cansleep(c))
5468                 tegra_clk_shared_bus_migrate_users(c);
5469
5470         return ret;
5471 }
5472
5473 static void tegra_clk_shared_bus_user_disable(struct clk *c)
5474 {
5475         if (c->u.shared_bus_user.client)
5476                 clk_disable(c->u.shared_bus_user.client);
5477         c->u.shared_bus_user.enabled = false;
5478         tegra_clk_shared_bus_update(c->parent);
5479
5480         if (c->cross_clk_mutex && clk_cansleep(c))
5481                 tegra_clk_shared_bus_migrate_users(c);
5482 }
5483
5484 static void tegra_clk_shared_bus_user_reset(struct clk *c, bool assert)
5485 {
5486         if (c->u.shared_bus_user.client) {
5487                 if (c->u.shared_bus_user.client->ops &&
5488                     c->u.shared_bus_user.client->ops->reset)
5489                         c->u.shared_bus_user.client->ops->reset(
5490                                 c->u.shared_bus_user.client, assert);
5491         }
5492 }
5493
5494 static struct clk_ops tegra_clk_shared_bus_user_ops = {
5495         .init = tegra_clk_shared_bus_user_init,
5496         .enable = tegra_clk_shared_bus_user_enable,
5497         .disable = tegra_clk_shared_bus_user_disable,
5498         .set_parent = tegra_clk_shared_bus_user_set_parent,
5499         .set_rate = tegra_clk_shared_bus_user_set_rate,
5500         .round_rate = tegra_clk_shared_bus_user_round_rate,
5501         .reset = tegra_clk_shared_bus_user_reset,
5502 };
5503
5504 /* coupled gate ops */
5505 /*
5506  * Some clocks may have common enable/disable control, but run at different
5507  * rates, and have different dvfs tables. Coupled gate clock synchronize
5508  * enable/disable operations for such clocks.
5509  */
5510
5511 static int tegra11_clk_coupled_gate_enable(struct clk *c)
5512 {
5513         int ret;
5514         const struct clk_mux_sel *sel;
5515
5516         BUG_ON(!c->inputs);
5517         pr_debug("%s on clock %s\n", __func__, c->name);
5518
5519         for (sel = c->inputs; sel->input != NULL; sel++) {
5520                 if (sel->input == c->parent)
5521                         continue;
5522
5523                 ret = clk_enable(sel->input);
5524                 if (ret) {
5525                         while(sel != c->inputs) {
5526                                 sel--;
5527                                 if (sel->input == c->parent)
5528                                         continue;
5529                                 clk_disable(sel->input);
5530                         }
5531                         return ret;
5532                 }
5533         }
5534
5535         return tegra11_periph_clk_enable(c);
5536 }
5537
5538 static void tegra11_clk_coupled_gate_disable(struct clk *c)
5539 {
5540         const struct clk_mux_sel *sel;
5541
5542         BUG_ON(!c->inputs);
5543         pr_debug("%s on clock %s\n", __func__, c->name);
5544
5545         tegra11_periph_clk_disable(c);
5546
5547         if (!c->refcnt) /* happens only on boot clean-up: don't propagate */
5548                 return;
5549
5550         for (sel = c->inputs; sel->input != NULL; sel++) {
5551                 if (sel->input == c->parent)
5552                         continue;
5553
5554                 if (sel->input->set)    /* enforce coupling after boot only */
5555                         clk_disable(sel->input);
5556         }
5557 }
5558
5559 static struct clk_ops tegra_clk_coupled_gate_ops = {
5560         .init                   = tegra11_periph_clk_init,
5561         .enable                 = tegra11_clk_coupled_gate_enable,
5562         .disable                = tegra11_clk_coupled_gate_disable,
5563         .reset                  = &tegra11_periph_clk_reset,
5564 };
5565
5566
5567 /* Clock definitions */
5568 static struct clk tegra_clk_32k = {
5569         .name = "clk_32k",
5570         .rate = 32768,
5571         .ops  = NULL,
5572         .max_rate = 32768,
5573 };
5574
5575 static struct clk tegra_clk_m = {
5576         .name      = "clk_m",
5577         .flags     = ENABLE_ON_INIT,
5578         .ops       = &tegra_clk_m_ops,
5579         .reg       = 0x1fc,
5580         .reg_shift = 28,
5581         .max_rate  = 48000000,
5582 };
5583
5584 static struct clk tegra_clk_m_div2 = {
5585         .name      = "clk_m_div2",
5586         .ops       = &tegra_clk_m_div_ops,
5587         .parent    = &tegra_clk_m,
5588         .mul       = 1,
5589         .div       = 2,
5590         .state     = ON,
5591         .max_rate  = 24000000,
5592 };
5593
5594 static struct clk tegra_clk_m_div4 = {
5595         .name      = "clk_m_div4",
5596         .ops       = &tegra_clk_m_div_ops,
5597         .parent    = &tegra_clk_m,
5598         .mul       = 1,
5599         .div       = 4,
5600         .state     = ON,
5601         .max_rate  = 12000000,
5602 };
5603
5604 static struct clk tegra_pll_ref = {
5605         .name      = "pll_ref",
5606         .flags     = ENABLE_ON_INIT,
5607         .ops       = &tegra_pll_ref_ops,
5608         .parent    = &tegra_clk_m,
5609         .max_rate  = 26000000,
5610 };
5611
5612 static struct clk_pll_freq_table tegra_pll_c_freq_table[] = {
5613         { 12000000, 624000000, 104, 1, 2},
5614         { 12000000, 600000000, 100, 1, 2},
5615         { 13000000, 600000000,  92, 1, 2},      /* actual: 598.0 MHz */
5616         { 16800000, 600000000,  71, 1, 2},      /* actual: 596.4 MHz */
5617         { 19200000, 600000000,  62, 1, 2},      /* actual: 595.2 MHz */
5618         { 26000000, 600000000,  92, 2, 2},      /* actual: 598.0 MHz */
5619         { 0, 0, 0, 0, 0, 0 },
5620 };
5621
5622 static struct clk tegra_pll_c = {
5623         .name      = "pll_c",
5624         .ops       = &tegra_pllxc_ops,
5625         .reg       = 0x80,
5626         .parent    = &tegra_pll_ref,
5627         .max_rate  = 1400000000,
5628         .u.pll = {
5629                 .input_min = 12000000,
5630                 .input_max = 800000000,
5631                 .cf_min    = 12000000,
5632                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
5633                 .vco_min   = 600000000,
5634                 .vco_max   = 1400000000,
5635                 .freq_table = tegra_pll_c_freq_table,
5636                 .lock_delay = 300,
5637                 .misc1 = 0x88 - 0x80,
5638                 .round_p_to_pdiv = pllxc_round_p_to_pdiv,
5639         },
5640 };
5641
5642 static struct clk tegra_pll_c_out1 = {
5643         .name      = "pll_c_out1",
5644         .ops       = &tegra_pll_div_ops,
5645 #ifdef CONFIG_TEGRA_DUAL_CBUS
5646         .flags     = DIV_U71 | DIV_U71_INT,
5647 #else
5648         .flags     = DIV_U71 | DIV_U71_INT | PERIPH_ON_CBUS,
5649 #endif
5650         .parent    = &tegra_pll_c,
5651         .reg       = 0x84,
5652         .reg_shift = 0,
5653         .max_rate  = 700000000,
5654 };
5655
5656 static struct clk_pll_freq_table tegra_pll_cx_freq_table[] = {
5657         { 12000000, 600000000, 100, 1, 2},
5658         { 13000000, 600000000,  92, 1, 2},      /* actual: 598.0 MHz */
5659         { 16800000, 600000000,  71, 1, 2},      /* actual: 596.4 MHz */
5660         { 19200000, 600000000,  62, 1, 2},      /* actual: 595.2 MHz */
5661         { 26000000, 600000000,  92, 2, 2},      /* actual: 598.0 MHz */
5662         { 0, 0, 0, 0, 0, 0 },
5663 };
5664
5665 static struct clk tegra_pll_c2 = {
5666         .name      = "pll_c2",
5667         .ops       = &tegra_pllcx_ops,
5668         .flags     = PLL_ALT_MISC_REG,
5669         .reg       = 0x4e8,
5670         .parent    = &tegra_pll_ref,
5671         .max_rate  = 1200000000,
5672         .u.pll = {
5673                 .input_min = 12000000,
5674                 .input_max = 48000000,
5675                 .cf_min    = 12000000,
5676                 .cf_max    = 19200000,
5677                 .vco_min   = 624000000,
5678                 .vco_max   = 1248000000,
5679                 .freq_table = tegra_pll_cx_freq_table,
5680                 .lock_delay = 300,
5681                 .misc1 = 0x4f0 - 0x4e8,
5682                 .round_p_to_pdiv = pllcx_round_p_to_pdiv,
5683         },
5684 };
5685
5686 static struct clk tegra_pll_c3 = {
5687         .name      = "pll_c3",
5688         .ops       = &tegra_pllcx_ops,
5689         .flags     = PLL_ALT_MISC_REG,
5690         .reg       = 0x4fc,
5691         .parent    = &tegra_pll_ref,
5692         .max_rate  = 1200000000,
5693         .u.pll = {
5694                 .input_min = 12000000,
5695                 .input_max = 48000000,
5696                 .cf_min    = 12000000,
5697                 .cf_max    = 19200000,
5698                 .vco_min   = 624000000,
5699                 .vco_max   = 1248000000,
5700                 .freq_table = tegra_pll_cx_freq_table,
5701                 .lock_delay = 300,
5702                 .misc1 = 0x504 - 0x4fc,
5703                 .round_p_to_pdiv = pllcx_round_p_to_pdiv,
5704         },
5705 };
5706
5707 static struct clk_pll_freq_table tegra_pll_m_freq_table[] = {
5708         { 12000000, 800000000, 66, 1, 1},       /* actual: 792.0 MHz */
5709         { 13000000, 800000000, 61, 1, 1},       /* actual: 793.0 MHz */
5710         { 16800000, 800000000, 47, 1, 1},       /* actual: 789.6 MHz */
5711         { 19200000, 800000000, 41, 1, 1},       /* actual: 787.2 MHz */
5712         { 26000000, 800000000, 61, 2, 1},       /* actual: 793.0 MHz */
5713         { 0, 0, 0, 0, 0, 0 },
5714 };
5715
5716 static struct clk tegra_pll_m = {
5717         .name      = "pll_m",
5718         .flags     = PLLM,
5719         .ops       = &tegra_pllm_ops,
5720         .reg       = 0x90,
5721         .parent    = &tegra_pll_ref,
5722         .max_rate  = 1066000000,
5723         .u.pll = {
5724                 .input_min = 12000000,
5725                 .input_max = 500000000,
5726                 .cf_min    = 12000000,
5727                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
5728                 .vco_min   = 400000000,
5729                 .vco_max   = 1066000000,
5730                 .freq_table = tegra_pll_m_freq_table,
5731                 .lock_delay = 300,
5732                 .misc1 = 0x98 - 0x90,
5733                 .round_p_to_pdiv = pllm_round_p_to_pdiv,
5734         },
5735 };
5736
5737 static struct clk tegra_pll_m_out1 = {
5738         .name      = "pll_m_out1",
5739         .ops       = &tegra_pll_div_ops,
5740         .flags     = DIV_U71 | DIV_U71_INT,
5741         .parent    = &tegra_pll_m,
5742         .reg       = 0x94,
5743         .reg_shift = 0,
5744         .max_rate  = 1066000000,
5745 };
5746
5747 static struct clk_pll_freq_table tegra_pll_p_freq_table[] = {
5748         { 12000000, 216000000, 432, 12, 2, 8},
5749         { 13000000, 216000000, 432, 13, 2, 8},
5750         { 16800000, 216000000, 360, 14, 2, 8},
5751         { 19200000, 216000000, 360, 16, 2, 8},
5752         { 26000000, 216000000, 432, 26, 2, 8},
5753         { 0, 0, 0, 0, 0, 0 },
5754 };
5755
5756 static struct clk tegra_pll_p = {
5757         .name      = "pll_p",
5758         .flags     = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
5759         .ops       = &tegra_pllp_ops,
5760         .reg       = 0xa0,
5761         .parent    = &tegra_pll_ref,
5762         .max_rate  = 432000000,
5763         .u.pll = {
5764                 .input_min = 2000000,
5765                 .input_max = 31000000,
5766                 .cf_min    = 1000000,
5767                 .cf_max    = 6000000,
5768                 .vco_min   = 200000000,
5769                 .vco_max   = 700000000,
5770                 .freq_table = tegra_pll_p_freq_table,
5771                 .lock_delay = 300,
5772         },
5773 };
5774
5775 static struct clk tegra_pll_p_out1 = {
5776         .name      = "pll_p_out1",
5777         .ops       = &tegra_pll_div_ops,
5778         .flags     = DIV_U71 | DIV_U71_FIXED,
5779         .parent    = &tegra_pll_p,
5780         .reg       = 0xa4,
5781         .reg_shift = 0,
5782         .max_rate  = 432000000,
5783 };
5784
5785 static struct clk tegra_pll_p_out2 = {
5786         .name      = "pll_p_out2",
5787         .ops       = &tegra_pll_div_ops,
5788         .flags     = DIV_U71 | DIV_U71_FIXED | DIV_U71_INT,
5789         .parent    = &tegra_pll_p,
5790         .reg       = 0xa4,
5791         .reg_shift = 16,
5792         .max_rate  = 432000000,
5793 };
5794
5795 static struct clk tegra_pll_p_out3 = {
5796         .name      = "pll_p_out3",
5797         .ops       = &tegra_pll_div_ops,
5798         .flags     = DIV_U71 | DIV_U71_FIXED,
5799         .parent    = &tegra_pll_p,
5800         .reg       = 0xa8,
5801         .reg_shift = 0,
5802         .max_rate  = 432000000,
5803 };
5804
5805 static struct clk tegra_pll_p_out4 = {
5806         .name      = "pll_p_out4",
5807         .ops       = &tegra_pll_div_ops,
5808         .flags     = DIV_U71 | DIV_U71_FIXED,
5809         .parent    = &tegra_pll_p,
5810         .reg       = 0xa8,
5811         .reg_shift = 16,
5812         .max_rate  = 432000000,
5813 };
5814
5815 static struct clk_pll_freq_table tegra_pll_a_freq_table[] = {
5816         {  9600000, 282240000, 147,  5, 1, 4},
5817         {  9600000, 368640000, 192,  5, 1, 4},
5818         {  9600000, 240000000, 200,  8, 1, 8},
5819
5820         { 28800000, 282240000, 245, 25, 1, 8},
5821         { 28800000, 368640000, 320, 25, 1, 8},
5822         { 28800000, 240000000, 200, 24, 1, 8},
5823         { 0, 0, 0, 0, 0, 0 },
5824 };
5825
5826 static struct clk tegra_pll_a = {
5827         .name      = "pll_a",
5828         .flags     = PLL_HAS_CPCON,
5829         .ops       = &tegra_pll_ops,
5830         .reg       = 0xb0,
5831         .parent    = &tegra_pll_p_out1,
5832         .max_rate  = 700000000,
5833         .u.pll = {
5834                 .input_min = 2000000,
5835                 .input_max = 31000000,
5836                 .cf_min    = 1000000,
5837                 .cf_max    = 6000000,
5838                 .vco_min   = 200000000,
5839                 .vco_max   = 700000000,
5840                 .freq_table = tegra_pll_a_freq_table,
5841                 .lock_delay = 300,
5842         },
5843 };
5844
5845 static struct clk tegra_pll_a_out0 = {
5846         .name      = "pll_a_out0",
5847         .ops       = &tegra_pll_div_ops,
5848         .flags     = DIV_U71,
5849         .parent    = &tegra_pll_a,
5850         .reg       = 0xb4,
5851         .reg_shift = 0,
5852         .max_rate  = 100000000,
5853 };
5854
5855 static struct clk_pll_freq_table tegra_pll_d_freq_table[] = {
5856         { 12000000, 216000000, 864, 12, 4, 12},
5857         { 13000000, 216000000, 864, 13, 4, 12},
5858         { 16800000, 216000000, 720, 14, 4, 12},
5859         { 19200000, 216000000, 720, 16, 4, 12},
5860         { 26000000, 216000000, 864, 26, 4, 12},
5861
5862         { 12000000, 594000000,  99,  1, 2, 15},
5863         { 13000000, 594000000, 594, 13, 1, 12},
5864         { 16800000, 594000000, 495, 14, 1, 12},
5865         { 19200000, 594000000, 495, 16, 1, 12},
5866         { 26000000, 594000000, 594, 26, 1, 12},
5867
5868         { 12000000, 1000000000, 1000, 12, 1, 12},
5869         { 13000000, 1000000000, 1000, 13, 1, 12},
5870         { 19200000, 1000000000, 625,  12, 1, 12},
5871         { 26000000, 1000000000, 1000, 26, 1, 12},
5872
5873         { 0, 0, 0, 0, 0, 0 },
5874 };
5875
5876 static struct clk tegra_pll_d = {
5877         .name      = "pll_d",
5878         .flags     = PLL_HAS_CPCON | PLLD,
5879         .ops       = &tegra_plld_ops,
5880         .reg       = 0xd0,
5881         .parent    = &tegra_pll_ref,
5882         .max_rate  = 1000000000,
5883         .u.pll = {
5884                 .input_min = 2000000,
5885                 .input_max = 40000000,
5886                 .cf_min    = 1000000,
5887                 .cf_max    = 6000000,
5888                 .vco_min   = 500000000,
5889                 .vco_max   = 1000000000,
5890                 .freq_table = tegra_pll_d_freq_table,
5891                 .lock_delay = 1000,
5892         },
5893 };
5894
5895 static struct clk tegra_pll_d_out0 = {
5896         .name      = "pll_d_out0",
5897         .ops       = &tegra_pll_div_ops,
5898         .flags     = DIV_2 | PLLD,
5899         .parent    = &tegra_pll_d,
5900         .max_rate  = 500000000,
5901 };
5902
5903 static struct clk tegra_pll_d2 = {
5904         .name      = "pll_d2",
5905         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG | PLLD,
5906         .ops       = &tegra_plld_ops,
5907         .reg       = 0x4b8,
5908         .parent    = &tegra_pll_ref,
5909         .max_rate  = 1000000000,
5910         .u.pll = {
5911                 .input_min = 2000000,
5912                 .input_max = 40000000,
5913                 .cf_min    = 1000000,
5914                 .cf_max    = 6000000,
5915                 .vco_min   = 500000000,
5916                 .vco_max   = 1000000000,
5917                 .freq_table = tegra_pll_d_freq_table,
5918                 .lock_delay = 1000,
5919         },
5920 };
5921
5922 static struct clk tegra_pll_d2_out0 = {
5923         .name      = "pll_d2_out0",
5924         .ops       = &tegra_pll_div_ops,
5925         .flags     = DIV_2 | PLLD,
5926         .parent    = &tegra_pll_d2,
5927         .max_rate  = 500000000,
5928 };
5929
5930 static struct clk_pll_freq_table tegra_pll_u_freq_table[] = {
5931         { 12000000, 480000000, 960, 12, 2, 12},
5932         { 13000000, 480000000, 960, 13, 2, 12},
5933         { 16800000, 480000000, 400, 7,  2, 5},
5934         { 19200000, 480000000, 200, 4,  2, 3},
5935         { 26000000, 480000000, 960, 26, 2, 12},
5936         { 0, 0, 0, 0, 0, 0 },
5937 };
5938
5939 static struct clk tegra_pll_u = {
5940         .name      = "pll_u",
5941         .flags     = PLL_HAS_CPCON | PLLU,
5942         .ops       = &tegra_pll_ops,
5943         .reg       = 0xc0,
5944         .parent    = &tegra_pll_ref,
5945         .max_rate  = 480000000,
5946         .u.pll = {
5947                 .input_min = 2000000,
5948                 .input_max = 40000000,
5949                 .cf_min    = 1000000,
5950                 .cf_max    = 6000000,
5951                 .vco_min   = 480000000,
5952                 .vco_max   = 960000000,
5953                 .freq_table = tegra_pll_u_freq_table,
5954                 .lock_delay = 1000,
5955                 .cpcon_default = 12,
5956         },
5957 };
5958
5959 static struct clk tegra_pll_u_480M = {
5960         .name      = "pll_u_480M",
5961         .flags     = PLLU,
5962         .ops       = &tegra_pll_div_ops,
5963         .reg       = 0xc0,
5964         .reg_shift = 22,
5965         .parent    = &tegra_pll_u,
5966         .mul       = 1,
5967         .div       = 1,
5968         .max_rate  = 480000000,
5969 };
5970
5971 static struct clk tegra_pll_u_60M = {
5972         .name      = "pll_u_60M",
5973         .flags     = PLLU,
5974         .ops       = &tegra_pll_div_ops,
5975         .reg       = 0xc0,
5976         .reg_shift = 23,
5977         .parent    = &tegra_pll_u,
5978         .mul       = 1,
5979         .div       = 8,
5980         .max_rate  = 60000000,
5981 };
5982
5983 static struct clk tegra_pll_u_48M = {
5984         .name      = "pll_u_48M",
5985         .flags     = PLLU,
5986         .ops       = &tegra_pll_div_ops,
5987         .reg       = 0xc0,
5988         .reg_shift = 25,
5989         .parent    = &tegra_pll_u,
5990         .mul       = 1,
5991         .div       = 10,
5992         .max_rate  = 48000000,
5993 };
5994
5995 static struct clk tegra_pll_u_12M = {
5996         .name      = "pll_u_12M",
5997         .flags     = PLLU,
5998         .ops       = &tegra_pll_div_ops,
5999         .reg       = 0xc0,
6000         .reg_shift = 21,
6001         .parent    = &tegra_pll_u,
6002         .mul       = 1,
6003         .div       = 40,
6004         .max_rate  = 12000000,
6005 };
6006
6007 static struct clk_pll_freq_table tegra_pll_x_freq_table[] = {
6008         /* 1 GHz */
6009         { 12000000, 1000000000, 83, 1, 1},      /* actual: 996.0 MHz */
6010         { 13000000, 1000000000, 76, 1, 1},      /* actual: 988.0 MHz */
6011         { 16800000, 1000000000, 59, 1, 1},      /* actual: 991.2 MHz */
6012         { 19200000, 1000000000, 52, 1, 1},      /* actual: 998.4 MHz */
6013         { 26000000, 1000000000, 76, 2, 1},      /* actual: 988.0 MHz */
6014
6015         { 0, 0, 0, 0, 0, 0 },
6016 };
6017
6018 static struct clk tegra_pll_x = {
6019         .name      = "pll_x",
6020         .flags     = PLL_ALT_MISC_REG | PLLX,
6021         .ops       = &tegra_pllxc_ops,
6022         .reg       = 0xe0,
6023         .parent    = &tegra_pll_ref,
6024         .max_rate  = 1800000000,
6025         .u.pll = {
6026                 .input_min = 12000000,
6027                 .input_max = 800000000,
6028                 .cf_min    = 12000000,
6029                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
6030                 .vco_min   = 700000000,
6031                 .vco_max   = 2400000000U,
6032                 .freq_table = tegra_pll_x_freq_table,
6033                 .lock_delay = 300,
6034                 .misc1 = 0x510 - 0xe0,
6035                 .round_p_to_pdiv = pllxc_round_p_to_pdiv,
6036         },
6037 };
6038
6039 static struct clk tegra_pll_x_out0 = {
6040         .name      = "pll_x_out0",
6041         .ops       = &tegra_pll_div_ops,
6042         .flags     = DIV_2 | PLLX,
6043         .parent    = &tegra_pll_x,
6044         .max_rate  = 700000000,
6045 };
6046
6047 static struct clk tegra_dfll_cpu = {
6048         .name      = "dfll_cpu",
6049         .flags     = DFLL,
6050         .ops       = &tegra_dfll_ops,
6051         .reg       = 0x2f4,
6052         .max_rate  = 2000000000,
6053 };
6054
6055 static struct clk tegra_pll_re_vco = {
6056         .name      = "pll_re_vco",
6057         .flags     = PLL_ALT_MISC_REG,
6058         .ops       = &tegra_pllre_ops,
6059         .reg       = 0x4c4,
6060         .parent    = &tegra_pll_ref,
6061         .max_rate  = 672000000,
6062         .u.pll = {
6063                 .input_min = 12000000,
6064                 .input_max = 1000000000,
6065                 .cf_min    = 12000000,
6066                 .cf_max    = 19200000,  /* s/w policy, h/w capability 38 MHz */
6067                 .vco_min   = 300000000,
6068                 .vco_max   = 672000000,
6069                 .lock_delay = 300,
6070                 .round_p_to_pdiv = pllre_round_p_to_pdiv,
6071         },
6072 };
6073
6074 static struct clk tegra_pll_re_out = {
6075         .name      = "pll_re_out",