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