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