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