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