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