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