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