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