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