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