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