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