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