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