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