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