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