12bab7b1c687eb29597da76269fe9689a7b87824
[linux-3.10.git] / arch / arm / mach-tegra / tegra14_clocks.c
1 /*
2  * arch/arm/mach-tegra/tegra14_clocks.c
3  *
4  * Copyright (C) 2013 NVIDIA Corporation
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/delay.h>
26 #include <linux/err.h>
27 #include <linux/io.h>
28 #include <linux/clk.h>
29 #include <linux/cpufreq.h>
30 #include <linux/syscore_ops.h>
31 #include <linux/platform_device.h>
32
33 #include <asm/clkdev.h>
34
35 #include <mach/edp.h>
36 #include <mach/hardware.h>
37 #include <mach/mc.h>
38
39 #include "clock.h"
40 #include "fuse.h"
41 #include "dvfs.h"
42 #include "iomap.h"
43 #include "pm.h"
44 #include "sleep.h"
45 #include "devices.h"
46 #include "tegra14_emc.h"
47 #include "tegra_cl_dvfs.h"
48
49 #define RST_DEVICES_L                   0x004
50 #define RST_DEVICES_H                   0x008
51 #define RST_DEVICES_U                   0x00C
52 #define RST_DEVICES_V                   0x358
53 #define RST_DEVICES_W                   0x35C
54 #define RST_DEVICES_X                   0x28C
55 #define RST_DEVICES_SET_L               0x300
56 #define RST_DEVICES_CLR_L               0x304
57 #define RST_DEVICES_SET_V               0x430
58 #define RST_DEVICES_CLR_V               0x434
59 #define RST_DEVICES_SET_X               0x290
60 #define RST_DEVICES_CLR_X               0x294
61 #define RST_DEVICES_NUM                 6
62
63 #define CLK_OUT_ENB_L                   0x010
64 #define CLK_OUT_ENB_H                   0x014
65 #define CLK_OUT_ENB_U                   0x018
66 #define CLK_OUT_ENB_V                   0x360
67 #define CLK_OUT_ENB_W                   0x364
68 #define CLK_OUT_ENB_X                   0x280
69 #define CLK_OUT_ENB_SET_L               0x320
70 #define CLK_OUT_ENB_CLR_L               0x324
71 #define CLK_OUT_ENB_SET_V               0x440
72 #define CLK_OUT_ENB_CLR_V               0x444
73 #define CLK_OUT_ENB_SET_X               0x284
74 #define CLK_OUT_ENB_CLR_X               0x288
75 #define CLK_OUT_ENB_NUM                 6
76
77 #define CLK_OUT_ENB_V_CLK_ENB_CPULP_EN  (0x1 << 1)
78
79 #define PERIPH_CLK_TO_BIT(c)            (1 << (c->u.periph.clk_num % 32))
80 #define PERIPH_CLK_TO_RST_REG(c)        \
81         periph_clk_to_reg((c), RST_DEVICES_L, RST_DEVICES_V, RST_DEVICES_X, 4)
82 #define PERIPH_CLK_TO_RST_SET_REG(c)    \
83         periph_clk_to_reg((c), RST_DEVICES_SET_L, RST_DEVICES_SET_V, \
84                 RST_DEVICES_SET_X, 8)
85 #define PERIPH_CLK_TO_RST_CLR_REG(c)    \
86         periph_clk_to_reg((c), RST_DEVICES_CLR_L, RST_DEVICES_CLR_V, \
87                 RST_DEVICES_CLR_X, 8)
88
89 #define PERIPH_CLK_TO_ENB_REG(c)        \
90         periph_clk_to_reg((c), CLK_OUT_ENB_L, CLK_OUT_ENB_V, CLK_OUT_ENB_X, 4)
91 #define PERIPH_CLK_TO_ENB_SET_REG(c)    \
92         periph_clk_to_reg((c), CLK_OUT_ENB_SET_L, CLK_OUT_ENB_SET_V, \
93                 CLK_OUT_ENB_SET_X, 8)
94 #define PERIPH_CLK_TO_ENB_CLR_REG(c)    \
95         periph_clk_to_reg((c), CLK_OUT_ENB_CLR_L, CLK_OUT_ENB_CLR_V, \
96                 CLK_OUT_ENB_CLR_X, 8)
97
98 #define CLK_MASK_ARM                    0x44
99 #define MISC_CLK_ENB                    0x48
100
101 #define OSC_CTRL                        0x50
102 #define OSC_CTRL_OSC_FREQ_MASK          (0xF<<28)
103 #define OSC_CTRL_OSC_FREQ_13MHZ         (0x0<<28)
104 #define OSC_CTRL_OSC_FREQ_19_2MHZ       (0x4<<28)
105 #define OSC_CTRL_OSC_FREQ_12MHZ         (0x8<<28)
106 #define OSC_CTRL_OSC_FREQ_26MHZ         (0xC<<28)
107 #define OSC_CTRL_OSC_FREQ_16_8MHZ       (0x1<<28)
108 #define OSC_CTRL_OSC_FREQ_38_4MHZ       (0x5<<28)
109 #define OSC_CTRL_OSC_FREQ_48MHZ         (0x9<<28)
110 #define OSC_CTRL_MASK                   (0x3f2 | OSC_CTRL_OSC_FREQ_MASK)
111
112 #define OSC_CTRL_PLL_REF_DIV_MASK       (3<<26)
113 #define OSC_CTRL_PLL_REF_DIV_1          (0<<26)
114 #define OSC_CTRL_PLL_REF_DIV_2          (1<<26)
115 #define OSC_CTRL_PLL_REF_DIV_4          (2<<26)
116
117 #define PERIPH_CLK_SOURCE_I2S1          0x100
118 #define PERIPH_CLK_SOURCE_EMC           0x19c
119 #define PERIPH_CLK_SOURCE_OSC           0x1fc
120 #define PERIPH_CLK_SOURCE_NUM1 \
121         ((PERIPH_CLK_SOURCE_OSC - PERIPH_CLK_SOURCE_I2S1) / 4)
122
123 #define PERIPH_CLK_SOURCE_G3D2          0x3b0
124 #define PERIPH_CLK_SOURCE_SE            0x42c
125 #define PERIPH_CLK_SOURCE_NUM2 \
126         ((PERIPH_CLK_SOURCE_SE - PERIPH_CLK_SOURCE_G3D2) / 4 + 1)
127
128 #define AUDIO_DLY_CLK                   0x49c
129 #define AUDIO_SYNC_CLK_I2S4             0x4b0
130 #define PERIPH_CLK_SOURCE_NUM3 \
131         ((AUDIO_SYNC_CLK_I2S4 - AUDIO_DLY_CLK) / 4 + 1)
132
133 #define SPARE_REG                       0x55c
134 #define SPARE_REG_CLK_M_DIVISOR_SHIFT   2
135 #define SPARE_REG_CLK_M_DIVISOR_MASK    (3 << SPARE_REG_CLK_M_DIVISOR_SHIFT)
136
137 #define PERIPH_CLK_SOURCE_CILAB         0x614
138 #define PERIPH_CLK_SOURCE_CLK72MHZ      0x66c
139 #define PERIPH_CLK_SOURCE_NUM4 \
140         ((PERIPH_CLK_SOURCE_CLK72MHZ - PERIPH_CLK_SOURCE_CILAB) / 4 + 1)
141
142 #define PERIPH_CLK_SOURCE_NUM           (PERIPH_CLK_SOURCE_NUM1 + \
143                                          PERIPH_CLK_SOURCE_NUM2 + \
144                                          PERIPH_CLK_SOURCE_NUM3 + \
145                                          PERIPH_CLK_SOURCE_NUM4)
146
147 #define CPU_SOFTRST_CTRL                0x380
148 #define CPU_SOFTRST_CTRL1               0x384
149 #define CPU_SOFTRST_CTRL2               0x388
150
151 #define PERIPH_CLK_SOURCE_DIVU71_MASK   0xFF
152 #define PERIPH_CLK_SOURCE_DIVU16_MASK   0xFFFF
153 #define PERIPH_CLK_SOURCE_DIV_SHIFT     0
154 #define PERIPH_CLK_SOURCE_DIVIDLE_SHIFT 8
155 #define PERIPH_CLK_SOURCE_DIVIDLE_VAL   50
156 #define PERIPH_CLK_UART_DIV_ENB         (1<<24)
157 #define PERIPH_CLK_VI_SEL_EX_SHIFT      24
158 #define PERIPH_CLK_VI_SEL_EX_MASK       (0x3<<PERIPH_CLK_VI_SEL_EX_SHIFT)
159 #define PERIPH_CLK_NAND_DIV_EX_ENB      (1<<8)
160 #define PERIPH_CLK_DTV_POLARITY_INV     (1<<25)
161
162 #define AUDIO_SYNC_SOURCE_MASK          0x0F
163 #define AUDIO_SYNC_DISABLE_BIT          0x10
164 #define AUDIO_SYNC_TAP_NIBBLE_SHIFT(c)  ((c->reg_shift - 24) * 4)
165
166 /* PLL common */
167 #define PLL_BASE                        0x0
168 #define PLL_BASE_BYPASS                 (1<<31)
169 #define PLL_BASE_ENABLE                 (1<<30)
170 #define PLL_BASE_REF_ENABLE             (1<<29)
171 #define PLL_BASE_OVERRIDE               (1<<28)
172 #define PLL_BASE_LOCK                   (1<<27)
173 #define PLL_BASE_DIVP_MASK              (0x7<<20)
174 #define PLL_BASE_DIVP_SHIFT             20
175 #define PLL_BASE_DIVN_MASK              (0x3FF<<8)
176 #define PLL_BASE_DIVN_SHIFT             8
177 #define PLL_BASE_DIVM_MASK              (0x1F)
178 #define PLL_BASE_DIVM_SHIFT             0
179
180 #define PLL_BASE_PARSE(pll, cfg, b)                                            \
181         do {                                                                   \
182                 (cfg).m = ((b) & pll##_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT; \
183                 (cfg).n = ((b) & pll##_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT; \
184                 (cfg).p = ((b) & pll##_BASE_DIVP_MASK) >> PLL_BASE_DIVP_SHIFT; \
185         } while (0)
186
187 #define PLL_OUT_RATIO_MASK              (0xFF<<8)
188 #define PLL_OUT_RATIO_SHIFT             8
189 #define PLL_OUT_OVERRIDE                (1<<2)
190 #define PLL_OUT_CLKEN                   (1<<1)
191 #define PLL_OUT_RESET_DISABLE           (1<<0)
192
193 #define PLL_MISC(c)                     \
194         (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
195 #define PLL_MISCN(c, n)         \
196         ((c)->u.pll.misc1 + ((n) - 1) * PLL_MISC(c))
197 #define PLL_MISC_LOCK_ENABLE(c) \
198         (((c)->flags & (PLLU | PLLD)) ? (1<<22) : (1<<18))
199
200 #define PLL_MISC_DCCON_SHIFT            20
201 #define PLL_MISC_CPCON_SHIFT            8
202 #define PLL_MISC_CPCON_MASK             (0xF<<PLL_MISC_CPCON_SHIFT)
203 #define PLL_MISC_LFCON_SHIFT            4
204 #define PLL_MISC_LFCON_MASK             (0xF<<PLL_MISC_LFCON_SHIFT)
205 #define PLL_MISC_VCOCON_SHIFT           0
206 #define PLL_MISC_VCOCON_MASK            (0xF<<PLL_MISC_VCOCON_SHIFT)
207
208 #define PLL_FIXED_MDIV(c, ref)          ((ref) > (c)->u.pll.cf_max ? 2 : 1)
209
210 /* PLLU */
211 #define PLLU_BASE_OVERRIDE              (1<<24)
212 #define PLLU_BASE_POST_DIV              (1<<20)
213
214 /* PLLD */
215 #define PLLD_BASE_CSI_CLKENABLE         (1<<26)
216 #define PLLD_BASE_DSI_MUX_SHIFT         25
217 #define PLLD_BASE_DSI_MUX_MASK          (1<<PLLD_BASE_DSI_MUX_SHIFT)
218 #define PLLD_BASE_CSI_CLKSOURCE         (1<<24)
219
220 #define PLLD_MISC_DSI_CLKENABLE         (1<<30)
221 #define PLLD_MISC_DIV_RST               (1<<23)
222 #define PLLD_MISC_DCCON_SHIFT           12
223
224 #define PLLDU_LFCON                     2
225
226 /* PLLC2 and PLLC3 (PLLCX) */
227 #define PLLCX_USE_DYN_RAMP              0
228 #define PLLCX_BASE_PHASE_LOCK           (1<<26)
229 #define PLLCX_BASE_DIVP_MASK            (0x7<<PLL_BASE_DIVP_SHIFT)
230 #define PLLCX_BASE_DIVN_MASK            (0xFF<<PLL_BASE_DIVN_SHIFT)
231 #define PLLCX_BASE_DIVM_MASK            (0x3<<PLL_BASE_DIVM_SHIFT)
232 #define PLLCX_PDIV_MAX  ((PLLCX_BASE_DIVP_MASK >> PLL_BASE_DIVP_SHIFT))
233 #define PLLCX_IS_DYN(new_p, old_p)      (((new_p) <= 8) && ((old_p) <= 8))
234
235 #define PLLCX_MISC_STROBE               (1<<31)
236 #define PLLCX_MISC_RESET                (1<<30)
237 #define PLLCX_MISC_SDM_DIV_SHIFT        28
238 #define PLLCX_MISC_SDM_DIV_MASK         (0x3 << PLLCX_MISC_SDM_DIV_SHIFT)
239 #define PLLCX_MISC_FILT_DIV_SHIFT       26
240 #define PLLCX_MISC_FILT_DIV_MASK        (0x3 << PLLCX_MISC_FILT_DIV_SHIFT)
241 #define PLLCX_MISC_ALPHA_SHIFT          18
242 #define PLLCX_MISC_ALPHA_MASK           (0xFF << PLLCX_MISC_ALPHA_SHIFT)
243 #define PLLCX_MISC_KB_SHIFT             9
244 #define PLLCX_MISC_KB_MASK              (0x1FF << PLLCX_MISC_KB_SHIFT)
245 #define PLLCX_MISC_KA_SHIFT             2
246 #define PLLCX_MISC_KA_MASK              (0x7F << PLLCX_MISC_KA_SHIFT)
247 #define PLLCX_MISC_VCO_GAIN_SHIFT       0
248 #define PLLCX_MISC_VCO_GAIN_MASK        (0x3 << PLLCX_MISC_VCO_GAIN_SHIFT)
249
250 #define PLLCX_MISC1_IDDQ                (1<<27)
251
252 #define PLLCX_MISC_KOEF_LOW_RANGE       \
253         ((0x14 << PLLCX_MISC_KA_SHIFT) | (0x38 << PLLCX_MISC_KB_SHIFT))
254
255 #define PLLCX_MISC_DIV_LOW_RANGE        \
256         ((0x2 << PLLCX_MISC_SDM_DIV_SHIFT) | (0x2 << PLLCX_MISC_FILT_DIV_SHIFT))
257 #define PLLCX_MISC_DIV_HIGH_RANGE       \
258         ((0x1 << PLLCX_MISC_SDM_DIV_SHIFT) | (0x1 << PLLCX_MISC_FILT_DIV_SHIFT))
259
260 #define PLLCX_MISC_DEFAULT_VALUE        ((0x0 << PLLCX_MISC_VCO_GAIN_SHIFT) | \
261                                         PLLCX_MISC_KOEF_LOW_RANGE | \
262                                         (0x19 << PLLCX_MISC_ALPHA_SHIFT) | \
263                                         PLLCX_MISC_DIV_LOW_RANGE | \
264                                         PLLCX_MISC_RESET)
265 #define PLLCX_MISC1_DEFAULT_VALUE       0x080d2308
266 #define PLLCX_MISC2_DEFAULT_VALUE       0x30211200
267 #define PLLCX_MISC3_DEFAULT_VALUE       0x200
268
269 /* PLLX and PLLC (PLLXC)*/
270 #define PLLXC_USE_DYN_RAMP              0
271 #define PLLXC_BASE_DIVP_MASK            (0xF<<PLL_BASE_DIVP_SHIFT)
272 #define PLLXC_BASE_DIVN_MASK            (0xFF<<PLL_BASE_DIVN_SHIFT)
273 #define PLLXC_BASE_DIVM_MASK            (0xFF<<PLL_BASE_DIVM_SHIFT)
274
275 /* PLLXC has 4-bit PDIV, but entry 15 is not allowed in h/w,
276    and s/w usage is limited to 5 */
277 #define PLLXC_PDIV_MAX                  14
278 #define PLLXC_SW_PDIV_MAX               5
279
280 /* PLLX */
281 #define PLLX_MISC2_DYNRAMP_STEPB_SHIFT  24
282 #define PLLX_MISC2_DYNRAMP_STEPB_MASK   (0xFF << PLLX_MISC2_DYNRAMP_STEPB_SHIFT)
283 #define PLLX_MISC2_DYNRAMP_STEPA_SHIFT  16
284 #define PLLX_MISC2_DYNRAMP_STEPA_MASK   (0xFF << PLLX_MISC2_DYNRAMP_STEPA_SHIFT)
285 #define PLLX_MISC2_NDIV_NEW_SHIFT       8
286 #define PLLX_MISC2_NDIV_NEW_MASK        (0xFF << PLLX_MISC2_NDIV_NEW_SHIFT)
287 #define PLLX_MISC2_LOCK_OVERRIDE        (0x1 << 4)
288 #define PLLX_MISC2_DYNRAMP_DONE         (0x1 << 2)
289 #define PLLX_MISC2_CLAMP_NDIV           (0x1 << 1)
290 #define PLLX_MISC2_EN_DYNRAMP           (0x1 << 0)
291
292 #define PLLX_MISC3_IDDQ                 (0x1 << 3)
293
294 #define PLLX_HW_CTRL_CFG                0x548
295 #define PLLX_HW_CTRL_CFG_SWCTRL         (0x1 << 0)
296
297 /* PLLC */
298 #define PLLC_BASE_LOCK_OVERRIDE         (1<<28)
299
300 #define PLLC_MISC_IDDQ                  (0x1 << 26)
301 #define PLLC_MISC_LOCK_ENABLE           (0x1 << 24)
302
303 #define PLLC_MISC1_CLAMP_NDIV           (0x1 << 26)
304 #define PLLC_MISC1_EN_DYNRAMP           (0x1 << 25)
305 #define PLLC_MISC1_DYNRAMP_STEPA_SHIFT  17
306 #define PLLC_MISC1_DYNRAMP_STEPA_MASK   (0xFF << PLLC_MISC1_DYNRAMP_STEPA_SHIFT)
307 #define PLLC_MISC1_DYNRAMP_STEPB_SHIFT  9
308 #define PLLC_MISC1_DYNRAMP_STEPB_MASK   (0xFF << PLLC_MISC1_DYNRAMP_STEPB_SHIFT)
309 #define PLLC_MISC1_NDIV_NEW_SHIFT       1
310 #define PLLC_MISC1_NDIV_NEW_MASK        (0xFF << PLLC_MISC1_NDIV_NEW_SHIFT)
311 #define PLLC_MISC1_DYNRAMP_DONE         (0x1 << 0)
312
313 /* PLLM */
314 #define PLLM_BASE_DIVP_MASK             (0x1 << PLL_BASE_DIVP_SHIFT)
315 #define PLLM_BASE_DIVN_MASK             (0xFF << PLL_BASE_DIVN_SHIFT)
316 #define PLLM_BASE_DIVM_MASK             (0xFF << PLL_BASE_DIVM_SHIFT)
317 #define PLLM_PDIV_MAX                   1
318
319 #define PLLM_MISC_FSM_SW_OVERRIDE       (0x1 << 10)
320 #define PLLM_MISC_IDDQ                  (0x1 << 5)
321 #define PLLM_MISC_LOCK_DISABLE          (0x1 << 4)
322 #define PLLM_MISC_LOCK_OVERRIDE         (0x1 << 3)
323
324 #define PMC_PLLP_WB0_OVERRIDE                   0xf8
325 #define PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE       (1 << 12)
326 #define PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE     (1 << 11)
327
328 /* M, N layout for PLLM override and base registers are the same */
329 #define PMC_PLLM_WB0_OVERRIDE                   0x1dc
330
331 #define PMC_PLLM_WB0_OVERRIDE_2                 0x2b0
332 #define PMC_PLLM_WB0_OVERRIDE_2_DIVP_MASK       (0x1 << 27)
333
334 #define OUT_OF_TABLE_CPCON              0x8
335
336 #define SUPER_CLK_MUX                   0x00
337 #define SUPER_STATE_SHIFT               28
338 #define SUPER_STATE_MASK                (0xF << SUPER_STATE_SHIFT)
339 #define SUPER_STATE_STANDBY             (0x0 << SUPER_STATE_SHIFT)
340 #define SUPER_STATE_IDLE                (0x1 << SUPER_STATE_SHIFT)
341 #define SUPER_STATE_RUN                 (0x2 << SUPER_STATE_SHIFT)
342 #define SUPER_STATE_IRQ                 (0x3 << SUPER_STATE_SHIFT)
343 #define SUPER_STATE_FIQ                 (0x4 << SUPER_STATE_SHIFT)
344 #define SUPER_LP_DIV2_BYPASS            (0x1 << 16)
345 #define SUPER_SOURCE_MASK               0xF
346 #define SUPER_FIQ_SOURCE_SHIFT          12
347 #define SUPER_IRQ_SOURCE_SHIFT          8
348 #define SUPER_RUN_SOURCE_SHIFT          4
349 #define SUPER_IDLE_SOURCE_SHIFT         0
350
351 #define SUPER_CLK_DIVIDER               0x04
352 #define SUPER_CLOCK_DIV_U71_SHIFT       16
353 #define SUPER_CLOCK_DIV_U71_MASK        (0xff << SUPER_CLOCK_DIV_U71_SHIFT)
354
355 #define BUS_CLK_DISABLE                 (1<<3)
356 #define BUS_CLK_DIV_MASK                0x3
357
358 #define PMC_CTRL                        0x0
359  #define PMC_CTRL_BLINK_ENB             (1 << 7)
360
361 #define PMC_DPD_PADS_ORIDE              0x1c
362  #define PMC_DPD_PADS_ORIDE_BLINK_ENB   (1 << 20)
363
364 #define PMC_BLINK_TIMER_DATA_ON_SHIFT   0
365 #define PMC_BLINK_TIMER_DATA_ON_MASK    0x7fff
366 #define PMC_BLINK_TIMER_ENB             (1 << 15)
367 #define PMC_BLINK_TIMER_DATA_OFF_SHIFT  16
368 #define PMC_BLINK_TIMER_DATA_OFF_MASK   0xffff
369
370 #define UTMIP_PLL_CFG2                                  0x488
371 #define UTMIP_PLL_CFG2_STABLE_COUNT(x)                  (((x) & 0xfff) << 6)
372 #define UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(x)              (((x) & 0x3f) << 18)
373 #define UTMIP_PLL_CFG2_FORCE_PD_SAMP_A_POWERDOWN        (1 << 0)
374
375 #define UTMIP_PLL_CFG1                                  0x484
376 #define UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(x)              (((x) & 0x1f) << 27)
377 #define UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(x)               (((x) & 0xfff) << 0)
378 #define UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERUP (1 << 15)
379 #define UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN       (1 << 14)
380 #define UTMIP_PLL_CFG1_FORCE_PLL_ACTIVE_POWERDOWN       (1 << 12)
381 #define UTMIP_PLL_CFG1_FORCE_PLLU_POWERUP               (1 << 17)
382 #define UTMIP_PLL_CFG1_FORCE_PLLU_POWERDOWN             (1 << 16)
383
384 #define UTMIPLL_HW_PWRDN_CFG0                   0x52c
385 #define UTMIPLL_HW_PWRDN_CFG0_SEQ_RESET_INPUT_VALUE     (1<<5)
386 #define UTMIPLL_HW_PWRDN_CFG0_SEQ_IN_SWCTL      (1<<4)
387 #define UTMIPLL_HW_PWRDN_CFG0_IDDQ_OVERRIDE     (1<<1)
388 #define UTMIPLL_HW_PWRDN_CFG0_IDDQ_SWCTL        (1<<0)
389
390 #define USB_PLLS_SEQ_START_STATE                (1<<25)
391 #define USB_PLLS_SEQ_ENABLE                     (1<<24)
392 #define USB_PLLS_USE_LOCKDET                    (1<<6)
393 #define USB_PLLS_ENABLE_SWCTL                   ((1<<2) | (1<<0))
394
395 /* DFLL */
396 #define DFLL_BASE                               0x2f4
397 #define DFLL_BASE_RESET                         (1<<0)
398
399 #define ROUND_DIVIDER_UP        0
400 #define ROUND_DIVIDER_DOWN      1
401 #define DIVIDER_1_5_ALLOWED     0
402
403 /* PLLP default fixed rate in h/w controlled mode */
404 #define PLLP_DEFAULT_FIXED_RATE         408000000
405
406 static bool tegra14_is_dyn_ramp(struct clk *c,
407                                 unsigned long rate, bool from_vco_min);
408 static void tegra14_pllp_init_dependencies(unsigned long pllp_rate);
409 static unsigned long tegra14_clk_shared_bus_update(struct clk *bus,
410         struct clk **bus_top, struct clk **bus_slow, unsigned long *rate_cap);
411 static unsigned long tegra14_clk_cap_shared_bus(struct clk *bus,
412         unsigned long rate, unsigned long ceiling);
413
414 static bool detach_shared_bus;
415 module_param(detach_shared_bus, bool, 0644);
416
417 static int use_dfll;
418
419 /**
420 * Structure defining the fields for USB UTMI clocks Parameters.
421 */
422 struct utmi_clk_param {
423         /* Oscillator Frequency in KHz */
424         u32 osc_frequency;
425         /* UTMIP PLL Enable Delay Count  */
426         u8 enable_delay_count;
427         /* UTMIP PLL Stable count */
428         u8 stable_count;
429         /*  UTMIP PLL Active delay count */
430         u8 active_delay_count;
431         /* UTMIP PLL Xtal frequency count */
432         u8 xtal_freq_count;
433 };
434
435 static const struct utmi_clk_param utmi_parameters[] = {
436 /*      OSC_FREQUENCY,  ENABLE_DLY,     STABLE_CNT,     ACTIVE_DLY,     XTAL_FREQ_CNT */
437         {13000000,      0x02,           0x33,           0x05,           0x7F},
438         {19200000,      0x03,           0x4B,           0x06,           0xBB},
439         {12000000,      0x02,           0x2F,           0x04,           0x76},
440         {26000000,      0x04,           0x66,           0x09,           0xFE},
441         {16800000,      0x03,           0x41,           0x0A,           0xA4},
442         {38400000,      0x03,           0x4B,           0x06,           0xBB},
443 };
444
445 static void __iomem *reg_clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
446 static void __iomem *reg_pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
447 static void __iomem *misc_gp_base = IO_ADDRESS(TEGRA_APB_MISC_BASE);
448
449 #define MISC_GP_HIDREV                          0x804
450 #define MISC_GP_TRANSACTOR_SCRATCH_0            0x864
451 #define MISC_GP_TRANSACTOR_SCRATCH_LA_ENABLE    (0x1 << 1)
452 #define MISC_GP_TRANSACTOR_SCRATCH_DDS_ENABLE   (0x1 << 2)
453 #define MISC_GP_TRANSACTOR_SCRATCH_DP2_ENABLE   (0x1 << 3)
454
455 /*
456  * Some peripheral clocks share an enable bit, so refcount the enable bits
457  * in registers CLK_ENABLE_L, ... CLK_ENABLE_W, and protect refcount updates
458  * with lock
459  */
460 static DEFINE_SPINLOCK(periph_refcount_lock);
461 static int tegra_periph_clk_enable_refcount[CLK_OUT_ENB_NUM * 32];
462
463 #define clk_writel(value, reg) \
464         __raw_writel(value, reg_clk_base + (reg))
465 #define clk_readl(reg) \
466         __raw_readl(reg_clk_base + (reg))
467 #define pmc_writel(value, reg) \
468         __raw_writel(value, reg_pmc_base + (reg))
469 #define pmc_readl(reg) \
470         __raw_readl(reg_pmc_base + (reg))
471 #define chipid_readl() \
472         __raw_readl(misc_gp_base + MISC_GP_HIDREV)
473
474 #define clk_writel_delay(value, reg)                                    \
475         do {                                                            \
476                 __raw_writel((value), reg_clk_base + (reg));    \
477                 udelay(2);                                              \
478         } while (0)
479
480 #define pll_writel_delay(value, reg)                                    \
481         do {                                                            \
482                 __raw_writel((value), reg_clk_base + (reg));    \
483                 udelay(1);                                              \
484         } while (0)
485
486
487 static inline int clk_set_div(struct clk *c, u32 n)
488 {
489         return clk_set_rate(c, (clk_get_rate(c->parent) + n-1) / n);
490 }
491
492 static inline u32 periph_clk_to_reg(
493         struct clk *c, u32 reg_L, u32 reg_V, u32 reg_X, int offs)
494 {
495         u32 reg = c->u.periph.clk_num / 32;
496         BUG_ON(reg >= RST_DEVICES_NUM);
497         if (reg < 3)
498                 reg = reg_L + (reg * offs);
499         else if (reg < 5)
500                 reg = reg_V + ((reg - 3) * offs);
501         else
502                 reg = reg_X;
503         return reg;
504 }
505
506 static int clk_div_x1_get_divider(unsigned long parent_rate, unsigned long rate,
507                         u32 max_x,
508                                  u32 flags, u32 round_mode)
509 {
510         s64 divider_ux1 = parent_rate;
511         if (!rate)
512                 return -EINVAL;
513
514         if (!(flags & DIV_U71_INT))
515                 divider_ux1 *= 2;
516         if (round_mode == ROUND_DIVIDER_UP)
517                 divider_ux1 += rate - 1;
518         do_div(divider_ux1, rate);
519         if (flags & DIV_U71_INT)
520                 divider_ux1 *= 2;
521
522         if (divider_ux1 - 2 < 0)
523                 return 0;
524
525         if (divider_ux1 - 2 > max_x)
526                 return -EINVAL;
527
528 #if !DIVIDER_1_5_ALLOWED
529         if (divider_ux1 == 3)
530                 divider_ux1 = (round_mode == ROUND_DIVIDER_UP) ? 4 : 2;
531 #endif
532         return divider_ux1 - 2;
533 }
534
535 static int clk_div71_get_divider(unsigned long parent_rate, unsigned long rate,
536                                  u32 flags, u32 round_mode)
537 {
538         return clk_div_x1_get_divider(parent_rate, rate, 0xFF,
539                         flags, round_mode);
540 }
541
542 static int clk_div151_get_divider(unsigned long parent_rate, unsigned long rate,
543                                  u32 flags, u32 round_mode)
544 {
545         return clk_div_x1_get_divider(parent_rate, rate, 0xFFFF,
546                         flags, round_mode);
547 }
548
549 static int clk_div16_get_divider(unsigned long parent_rate, unsigned long rate)
550 {
551         s64 divider_u16;
552
553         divider_u16 = parent_rate;
554         if (!rate)
555                 return -EINVAL;
556         divider_u16 += rate - 1;
557         do_div(divider_u16, rate);
558
559         if (divider_u16 - 1 < 0)
560                 return 0;
561
562         if (divider_u16 - 1 > 0xFFFF)
563                 return -EINVAL;
564
565         return divider_u16 - 1;
566 }
567
568 static inline bool bus_user_is_slower(struct clk *a, struct clk *b)
569 {
570         return a->u.shared_bus_user.client->max_rate * a->div <
571                 b->u.shared_bus_user.client->max_rate * b->div;
572 }
573
574 static inline bool bus_user_request_is_lower(struct clk *a, struct clk *b)
575 {
576         return a->u.shared_bus_user.rate * a->div <
577                 b->u.shared_bus_user.rate * b->div;
578 }
579
580 /* osc functions */
581 static unsigned long tegra14_osc_autodetect_rate(struct clk *c)
582 {
583         u32 osc_ctrl = clk_readl(OSC_CTRL);
584         u32 auto_clock_control = osc_ctrl & ~OSC_CTRL_OSC_FREQ_MASK;
585         u32 pll_ref_div = osc_ctrl & OSC_CTRL_PLL_REF_DIV_MASK;
586
587         u32 spare = clk_readl(SPARE_REG);
588         u32 divisor = (spare & SPARE_REG_CLK_M_DIVISOR_MASK)
589                 >> SPARE_REG_CLK_M_DIVISOR_SHIFT;
590         u32 spare_update = spare & ~SPARE_REG_CLK_M_DIVISOR_MASK;
591
592         c->rate = tegra_clk_measure_input_freq();
593         switch (c->rate) {
594         case 12000000:
595                 auto_clock_control |= OSC_CTRL_OSC_FREQ_12MHZ;
596                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
597                 BUG_ON(divisor != 0);
598                 break;
599         case 13000000:
600                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
601                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
602                 BUG_ON(divisor != 0);
603                 break;
604         case 19200000:
605                 auto_clock_control |= OSC_CTRL_OSC_FREQ_19_2MHZ;
606                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
607                 BUG_ON(divisor != 0);
608                 break;
609         case 26000000:
610                 auto_clock_control |= OSC_CTRL_OSC_FREQ_26MHZ;
611                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
612                 BUG_ON(divisor != 0);
613                 break;
614         case 16800000:
615                 auto_clock_control |= OSC_CTRL_OSC_FREQ_16_8MHZ;
616                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
617                 BUG_ON(divisor != 0);
618                 break;
619         case 38400000:
620                 auto_clock_control |= OSC_CTRL_OSC_FREQ_38_4MHZ;
621                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_2);
622                 BUG_ON(divisor != 1);
623                 spare_update |= (1 << SPARE_REG_CLK_M_DIVISOR_SHIFT);
624                 break;
625         case 48000000:
626                 auto_clock_control |= OSC_CTRL_OSC_FREQ_48MHZ;
627                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_4);
628                 BUG_ON(divisor != 3);
629                 spare_update |= (3 << SPARE_REG_CLK_M_DIVISOR_SHIFT);
630                 break;
631         case 115200:    /* fake 13M for QT */
632         case 230400:    /* fake 13M for QT */
633                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
634                 c->rate = 13000000;
635                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
636                 BUG_ON(divisor != 0);
637                 break;
638         default:
639                 pr_err("%s: Unexpected clock rate %ld", __func__, c->rate);
640                 BUG();
641         }
642
643         clk_writel(auto_clock_control, OSC_CTRL);
644         clk_writel(spare_update, SPARE_REG);
645
646         return c->rate;
647 }
648
649 static void tegra14_osc_init(struct clk *c)
650 {
651         pr_debug("%s on clock %s\n", __func__, c->name);
652         tegra14_osc_autodetect_rate(c);
653 }
654
655 static int tegra14_osc_enable(struct clk *c)
656 {
657         pr_debug("%s on clock %s\n", __func__, c->name);
658         return 0;
659 }
660
661 static void tegra14_osc_disable(struct clk *c)
662 {
663         pr_debug("%s on clock %s\n", __func__, c->name);
664         WARN(1, "Attempting to disable main SoC clock\n");
665 }
666
667 static struct clk_ops tegra_osc_ops = {
668         .init           = tegra14_osc_init,
669         .enable         = tegra14_osc_enable,
670         .disable        = tegra14_osc_disable,
671 };
672
673 static struct clk_ops tegra_osc_div_ops = {
674         .enable         = tegra14_osc_enable,
675 };
676
677 static void tegra14_clk_m_init(struct clk *c)
678 {
679         u32 spare = clk_readl(SPARE_REG);
680         u32 divisor = (spare & SPARE_REG_CLK_M_DIVISOR_MASK)
681                 >> SPARE_REG_CLK_M_DIVISOR_SHIFT;
682
683         pr_debug("%s on clock %s\n", __func__, c->name);
684
685         c->div = divisor + 1;
686         c->mul = 1;
687         c->state = ON;
688 }
689
690 static int tegra14_clk_m_enable(struct clk *c)
691 {
692         pr_debug("%s on clock %s\n", __func__, c->name);
693         return 0;
694 }
695
696 static void tegra14_clk_m_disable(struct clk *c)
697 {
698         pr_debug("%s on clock %s\n", __func__, c->name);
699         WARN(1, "Attempting to disable main SoC clock\n");
700 }
701
702 static struct clk_ops tegra_clk_m_ops = {
703         .init           = tegra14_clk_m_init,
704         .enable         = tegra14_clk_m_enable,
705         .disable        = tegra14_clk_m_disable,
706 };
707
708 /* PLL reference divider functions */
709 static void tegra14_pll_ref_init(struct clk *c)
710 {
711         u32 pll_ref_div = clk_readl(OSC_CTRL) & OSC_CTRL_PLL_REF_DIV_MASK;
712         pr_debug("%s on clock %s\n", __func__, c->name);
713
714         switch (pll_ref_div) {
715         case OSC_CTRL_PLL_REF_DIV_1:
716                 c->div = 1;
717                 break;
718         case OSC_CTRL_PLL_REF_DIV_2:
719                 c->div = 2;
720                 break;
721         case OSC_CTRL_PLL_REF_DIV_4:
722                 c->div = 4;
723                 break;
724         default:
725                 pr_err("%s: Invalid pll ref divider %d", __func__, pll_ref_div);
726                 BUG();
727         }
728         c->mul = 1;
729         c->state = ON;
730 }
731
732 static struct clk_ops tegra_pll_ref_ops = {
733         .init           = tegra14_pll_ref_init,
734         .enable         = tegra14_osc_enable,
735         .disable        = tegra14_osc_disable,
736 };
737
738 /* super clock functions */
739 /* "super clocks" on tegra14x have two-stage muxes, fractional 7.1 divider and
740  * clock skipping super divider.  We will ignore the clock skipping divider,
741  * since we can't lower the voltage when using the clock skip, but we can if
742  * we lower the PLL frequency. Note that skipping divider can and will be used
743  * by thermal control h/w for automatic throttling. There is also a 7.1 divider
744  * that most CPU super-clock inputs can be routed through. We will not use it
745  * as well (keep default 1:1 state), to avoid high jitter on PLLX and DFLL path
746  * and possible concurrency access issues with thermal h/w (7.1 divider setting
747  * share register with clock skipping divider)
748  */
749 static void tegra14_super_clk_init(struct clk *c)
750 {
751         u32 val;
752         int source;
753         int shift;
754         const struct clk_mux_sel *sel;
755         val = clk_readl(c->reg + SUPER_CLK_MUX);
756         c->state = ON;
757         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
758                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
759         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
760                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
761         source = (val >> shift) & SUPER_SOURCE_MASK;
762
763         /*
764          * Enforce PLLX DIV2 bypass setting as early as possible. It is always
765          * safe to do for both cclk_lp and cclk_g when booting on G CPU. (In
766          * case of booting on LP CPU, cclk_lp will be updated during the cpu
767          * rate change after boot, and cclk_g after the cluster switch.)
768          */
769         if ((c->flags & DIV_U71) && (!is_lp_cluster())) {
770                 val |= SUPER_LP_DIV2_BYPASS;
771                 clk_writel_delay(val, c->reg);
772         }
773
774         for (sel = c->inputs; sel->input != NULL; sel++) {
775                 if (sel->value == source)
776                         break;
777         }
778         BUG_ON(sel->input == NULL);
779         c->parent = sel->input;
780
781         /* Update parent in case when LP CPU PLLX DIV2 bypassed */
782         if ((c->flags & DIV_2) && (c->parent->flags & PLLX) &&
783             (val & SUPER_LP_DIV2_BYPASS))
784                 c->parent = c->parent->parent;
785
786         if (c->flags & DIV_U71) {
787                 c->mul = 2;
788                 c->div = 2;
789
790                 /* Make sure 7.1 divider is 1:1, clear s/w skipper control */
791                 /* FIXME: set? preserve? thermal h/w skipper control */
792                 val = clk_readl(c->reg + SUPER_CLK_DIVIDER);
793                 BUG_ON(val & SUPER_CLOCK_DIV_U71_MASK);
794                 val = 0;
795                 clk_writel(val, c->reg + SUPER_CLK_DIVIDER);
796         } else
797                 clk_writel(0, c->reg + SUPER_CLK_DIVIDER);
798 }
799
800 static int tegra14_super_clk_enable(struct clk *c)
801 {
802         return 0;
803 }
804
805 static void tegra14_super_clk_disable(struct clk *c)
806 {
807         /* since tegra 3 has 2 CPU super clocks - low power lp-mode clock and
808            geared up g-mode super clock - mode switch may request to disable
809            either of them; accept request with no affect on h/w */
810 }
811
812 static int tegra14_super_clk_set_parent(struct clk *c, struct clk *p)
813 {
814         u32 val;
815         const struct clk_mux_sel *sel;
816         int shift;
817
818         val = clk_readl(c->reg + SUPER_CLK_MUX);
819         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
820                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
821         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
822                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
823         for (sel = c->inputs; sel->input != NULL; sel++) {
824                 if (sel->input == p) {
825                         /* For LP mode super-clock switch between PLLX direct
826                            and divided-by-2 outputs is allowed only when other
827                            than PLLX clock source is current parent */
828                         if ((c->flags & DIV_2) && (p->flags & PLLX) &&
829                             ((sel->value ^ val) & SUPER_LP_DIV2_BYPASS)) {
830                                 if (c->parent->flags & PLLX)
831                                         return -EINVAL;
832                                 val ^= SUPER_LP_DIV2_BYPASS;
833                                 clk_writel_delay(val, c->reg);
834                         }
835                         val &= ~(SUPER_SOURCE_MASK << shift);
836                         val |= (sel->value & SUPER_SOURCE_MASK) << shift;
837
838                         if (c->flags & DIV_U71) {
839                                 /* Make sure 7.1 divider is 1:1 */
840                                 u32 div = clk_readl(c->reg + SUPER_CLK_DIVIDER);
841                                 BUG_ON(div & SUPER_CLOCK_DIV_U71_MASK);
842                         }
843
844                         if (c->refcnt)
845                                 clk_enable(p);
846
847                         clk_writel_delay(val, c->reg);
848
849                         if (c->refcnt && c->parent)
850                                 clk_disable(c->parent);
851
852                         clk_reparent(c, p);
853                         return 0;
854                 }
855         }
856         return -EINVAL;
857 }
858
859 /*
860  * Do not use super clocks "skippers", since dividing using a clock skipper
861  * does not allow the voltage to be scaled down. Instead adjust the rate of
862  * the parent clock. This requires that the parent of a super clock have no
863  * other children, otherwise the rate will change underneath the other
864  * children.
865  */
866 static int tegra14_super_clk_set_rate(struct clk *c, unsigned long rate)
867 {
868         /* In tegra14_cpu_clk_set_plls() and  tegra14_sbus_cmplx_set_rate()
869          * this call is skipped by directly setting rate of source plls. If we
870          * ever use 7.1 divider at other than 1:1 setting, or exercise s/w
871          * skipper control, not only this function, but cpu and sbus set_rate
872          * APIs should be changed accordingly.
873          */
874         return clk_set_rate(c->parent, rate);
875 }
876
877 #ifdef CONFIG_PM_SLEEP
878 static void tegra14_super_clk_resume(struct clk *c, struct clk *backup,
879                                      u32 setting)
880 {
881         u32 val;
882         const struct clk_mux_sel *sel;
883         int shift;
884
885         /* For sclk and cclk_g super clock just restore saved value */
886         if (!(c->flags & DIV_2)) {
887                 clk_writel_delay(setting, c->reg);
888                 return;
889         }
890
891         /*
892          * For cclk_lp supper clock: switch to backup (= not PLLX) source,
893          * safely restore PLLX DIV2 bypass, and only then restore full
894          * setting
895          */
896         val = clk_readl(c->reg);
897         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
898                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
899         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
900                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
901         for (sel = c->inputs; sel->input != NULL; sel++) {
902                 if (sel->input == backup) {
903                         val &= ~(SUPER_SOURCE_MASK << shift);
904                         val |= (sel->value & SUPER_SOURCE_MASK) << shift;
905
906                         BUG_ON(backup->flags & PLLX);
907                         clk_writel_delay(val, c->reg);
908
909                         val &= ~SUPER_LP_DIV2_BYPASS;
910                         val |= (setting & SUPER_LP_DIV2_BYPASS);
911                         clk_writel_delay(val, c->reg);
912                         clk_writel_delay(setting, c->reg);
913                         return;
914                 }
915         }
916         BUG();
917 }
918 #endif
919
920 static struct clk_ops tegra_super_ops = {
921         .init                   = tegra14_super_clk_init,
922         .enable                 = tegra14_super_clk_enable,
923         .disable                = tegra14_super_clk_disable,
924         .set_parent             = tegra14_super_clk_set_parent,
925         .set_rate               = tegra14_super_clk_set_rate,
926 };
927
928 static int tegra14_twd_clk_set_rate(struct clk *c, unsigned long rate)
929 {
930         /* The input value 'rate' is the clock rate of the CPU complex. */
931         c->rate = (rate * c->mul) / c->div;
932         return 0;
933 }
934
935 static struct clk_ops tegra14_twd_ops = {
936         .set_rate       = tegra14_twd_clk_set_rate,
937 };
938
939 static struct clk tegra14_clk_twd = {
940         /* NOTE: The twd clock must have *NO* parent. It's rate is directly
941                  updated by tegra3_cpu_cmplx_clk_set_rate() because the
942                  frequency change notifer for the twd is called in an
943                  atomic context which cannot take a mutex. */
944         .name     = "twd",
945         .ops      = &tegra14_twd_ops,
946         .max_rate = 1400000000, /* Same as tegra_clk_cpu_cmplx.max_rate */
947         .mul      = 1,
948         .div      = 2,
949 };
950
951 /* virtual cpu clock functions */
952 /* some clocks can not be stopped (cpu, memory bus) while the SoC is running.
953    To change the frequency of these clocks, the parent pll may need to be
954    reprogrammed, so the clock must be moved off the pll, the pll reprogrammed,
955    and then the clock moved back to the pll.  To hide this sequence, a virtual
956    clock handles it.
957  */
958 static void tegra14_cpu_clk_init(struct clk *c)
959 {
960         c->state = (!is_lp_cluster() == (c->u.cpu.mode == MODE_G)) ? ON : OFF;
961 }
962
963 static int tegra14_cpu_clk_enable(struct clk *c)
964 {
965         return 0;
966 }
967
968 static void tegra14_cpu_clk_disable(struct clk *c)
969 {
970         /* since tegra 3 has 2 virtual CPU clocks - low power lp-mode clock
971            and geared up g-mode clock - mode switch may request to disable
972            either of them; accept request with no affect on h/w */
973 }
974
975 static int tegra14_cpu_clk_set_plls(struct clk *c, unsigned long rate,
976                                     unsigned long old_rate)
977 {
978         int ret = 0;
979         bool on_main = false;
980         unsigned long backup_rate, main_rate;
981         unsigned long vco_min = c->u.cpu.main->u.pll.vco_min;
982
983         /*
984          * Take an extra reference to the main pll so it doesn't turn off when
985          * we move the cpu off of it. If possible, use main pll dynamic ramp
986          * to reach target rate in one shot. Otherwise, use dynamic ramp to
987          * lower current rate to pll VCO minimum level before switching to
988          * backup source.
989          */
990         if (c->parent->parent == c->u.cpu.main) {
991                 bool dramp = (rate > c->u.cpu.backup_rate) &&
992                         tegra14_is_dyn_ramp(c->u.cpu.main, rate, false);
993                 clk_enable(c->u.cpu.main);
994                 on_main = true;
995
996                 if (dramp ||
997                     ((old_rate > vco_min) &&
998                      tegra14_is_dyn_ramp(c->u.cpu.main, vco_min, false))) {
999                         main_rate = dramp ? rate : vco_min;
1000                         ret = clk_set_rate(c->u.cpu.main, main_rate);
1001                         if (ret) {
1002                                 pr_err("Failed to set cpu rate %lu on source"
1003                                        " %s\n", main_rate, c->u.cpu.main->name);
1004                                 goto out;
1005                         }
1006                         if (dramp)
1007                                 goto out;
1008                 } else if (old_rate > vco_min) {
1009 #if PLLXC_USE_DYN_RAMP
1010                         pr_warn("No dynamic ramp down: %s: %lu to %lu\n",
1011                                 c->u.cpu.main->name, old_rate, vco_min);
1012 #endif
1013                 }
1014         }
1015
1016         /* Switch to back-up source, and stay on it if target rate is below
1017            backup rate */
1018         if (c->parent->parent != c->u.cpu.backup) {
1019                 ret = clk_set_parent(c->parent, c->u.cpu.backup);
1020                 if (ret) {
1021                         pr_err("Failed to switch cpu to %s\n",
1022                                c->u.cpu.backup->name);
1023                         goto out;
1024                 }
1025         }
1026
1027         backup_rate = min(rate, c->u.cpu.backup_rate);
1028         if (backup_rate != clk_get_rate_locked(c)) {
1029                 ret = clk_set_rate(c->u.cpu.backup, backup_rate);
1030                 if (ret) {
1031                         pr_err("Failed to set cpu rate %lu on backup source\n",
1032                                backup_rate);
1033                         goto out;
1034                 }
1035         }
1036         if (rate == backup_rate)
1037                 goto out;
1038
1039         /* Switch from backup source to main at rate not exceeding pll VCO
1040            minimum. Use dynamic ramp to reach target rate if it is above VCO
1041            minimum. */
1042         main_rate = rate;
1043         if (rate > vco_min) {
1044                 if (tegra14_is_dyn_ramp(c->u.cpu.main, rate, true))
1045                         main_rate = vco_min;
1046 #if PLLXC_USE_DYN_RAMP
1047                 else
1048                         pr_warn("No dynamic ramp up: %s: %lu to %lu\n",
1049                                 c->u.cpu.main->name, vco_min, rate);
1050 #endif
1051         }
1052
1053         ret = clk_set_rate(c->u.cpu.main, main_rate);
1054         if (ret) {
1055                 pr_err("Failed to set cpu rate %lu on source"
1056                        " %s\n", main_rate, c->u.cpu.main->name);
1057                 goto out;
1058         }
1059         ret = clk_set_parent(c->parent, c->u.cpu.main);
1060         if (ret) {
1061                 pr_err("Failed to switch cpu to %s\n", c->u.cpu.main->name);
1062                 goto out;
1063         }
1064         if (rate != main_rate) {
1065                 ret = clk_set_rate(c->u.cpu.main, rate);
1066                 if (ret) {
1067                         pr_err("Failed to set cpu rate %lu on source"
1068                                " %s\n", rate, c->u.cpu.main->name);
1069                         goto out;
1070                 }
1071         }
1072
1073 out:
1074         if (on_main)
1075                 clk_disable(c->u.cpu.main);
1076
1077         return ret;
1078 }
1079
1080 static int tegra14_cpu_clk_dfll_on(struct clk *c, unsigned long rate,
1081                                    unsigned long old_rate)
1082 {
1083         int ret;
1084         struct clk *dfll = c->u.cpu.dynamic;
1085         unsigned long dfll_rate_min = c->dvfs->dfll_data.use_dfll_rate_min;
1086
1087         /* dfll rate request */
1088         ret = clk_set_rate(dfll, rate);
1089         if (ret) {
1090                 pr_err("Failed to set cpu rate %lu on source"
1091                        " %s\n", rate, dfll->name);
1092                 return ret;
1093         }
1094
1095         /* 1st time - switch to dfll */
1096         if (c->parent->parent != dfll) {
1097                 if (max(old_rate, rate) < dfll_rate_min) {
1098                         /* set interim cpu dvfs rate at dfll_rate_min to
1099                            prevent voltage drop below dfll Vmin */
1100                         ret = tegra_dvfs_set_rate(c, dfll_rate_min);
1101                         if (ret) {
1102                                 pr_err("Failed to set cpu dvfs rate %lu\n",
1103                                        dfll_rate_min);
1104                                 return ret;
1105                         }
1106                 }
1107
1108                 tegra_dvfs_rail_mode_updating(tegra_cpu_rail, true);
1109                 ret = clk_set_parent(c->parent, dfll);
1110                 if (ret) {
1111                         tegra_dvfs_rail_mode_updating(tegra_cpu_rail, false);
1112                         pr_err("Failed to switch cpu to %s\n", dfll->name);
1113                         return ret;
1114                 }
1115                 ret = tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 1);
1116                 WARN(ret, "Failed to lock %s at rate %lu\n", dfll->name, rate);
1117
1118                 /* prevent legacy dvfs voltage scaling */
1119                 tegra_dvfs_dfll_mode_set(c->dvfs, rate);
1120                 tegra_dvfs_rail_mode_updating(tegra_cpu_rail, false);
1121         }
1122         return 0;
1123 }
1124
1125 static int tegra14_cpu_clk_dfll_off(struct clk *c, unsigned long rate,
1126                                     unsigned long old_rate)
1127 {
1128         int ret;
1129         struct clk *pll;
1130         struct clk *dfll = c->u.cpu.dynamic;
1131         unsigned long dfll_rate_min = c->dvfs->dfll_data.use_dfll_rate_min;
1132
1133         rate = min(rate, c->max_rate - c->dvfs->dfll_data.max_rate_boost);
1134         pll = (rate <= c->u.cpu.backup_rate) ? c->u.cpu.backup : c->u.cpu.main;
1135
1136         tegra_dvfs_rail_mode_updating(tegra_cpu_rail, true);
1137         ret = tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 0);
1138         if (ret) {
1139                 pr_err("Failed to unlock %s\n", dfll->name);
1140                 goto back_to_dfll;
1141         }
1142
1143         /* restore legacy dvfs operations and set appropriate voltage */
1144         ret = tegra_dvfs_dfll_mode_clear(c->dvfs, max(rate, dfll_rate_min));
1145         if (ret) {
1146                 pr_err("Failed to set cpu rail for rate %lu\n", rate);
1147                 goto back_to_dfll;
1148         }
1149
1150         /* set pll to target rate and return to pll source */
1151         ret = clk_set_rate(pll, rate);
1152         if (ret) {
1153                 pr_err("Failed to set cpu rate %lu on source"
1154                        " %s\n", rate, pll->name);
1155                 goto back_to_dfll;
1156         }
1157         ret = clk_set_parent(c->parent, pll);
1158         if (ret) {
1159                 pr_err("Failed to switch cpu to %s\n", pll->name);
1160                 goto back_to_dfll;
1161         }
1162
1163         /* If going up, adjust voltage here (down path is taken care of by the
1164            framework after set rate exit) */
1165         if (old_rate <= rate)
1166                 tegra_dvfs_set_rate(c, rate);
1167
1168         tegra_dvfs_rail_mode_updating(tegra_cpu_rail, false);
1169         return 0;
1170
1171 back_to_dfll:
1172         tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 1);
1173         tegra_dvfs_dfll_mode_set(c->dvfs, old_rate);
1174         tegra_dvfs_rail_mode_updating(tegra_cpu_rail, false);
1175         return ret;
1176 }
1177
1178 static int tegra14_cpu_clk_set_rate(struct clk *c, unsigned long rate)
1179 {
1180         unsigned long old_rate = clk_get_rate_locked(c);
1181         bool has_dfll = c->u.cpu.dynamic &&
1182                 (c->u.cpu.dynamic->state != UNINITIALIZED);
1183         bool is_dfll = c->parent->parent == c->u.cpu.dynamic;
1184
1185         /* On SILICON allow CPU rate change only if cpu regulator is connected.
1186            Ignore regulator connection on FPGA and SIMULATION platforms. */
1187 #ifdef CONFIG_TEGRA_SILICON_PLATFORM
1188         if (c->dvfs) {
1189                 if (!c->dvfs->dvfs_rail)
1190                         return -ENOSYS;
1191                 else if ((!c->dvfs->dvfs_rail->reg) && (old_rate < rate)) {
1192                         WARN(1, "Increasing CPU rate while regulator is not"
1193                                 " ready is not allowed\n");
1194                         return -ENOSYS;
1195                 }
1196         }
1197 #endif
1198         if (has_dfll && c->dvfs && c->dvfs->dvfs_rail) {
1199                 if (tegra_dvfs_is_dfll_range(c->dvfs, rate))
1200                         return tegra14_cpu_clk_dfll_on(c, rate, old_rate);
1201                 else if (is_dfll)
1202                         return tegra14_cpu_clk_dfll_off(c, rate, old_rate);
1203         }
1204         return tegra14_cpu_clk_set_plls(c, rate, old_rate);
1205 }
1206
1207 static long tegra14_cpu_clk_round_rate(struct clk *c, unsigned long rate)
1208 {
1209         unsigned long max_rate = c->max_rate;
1210
1211         /* Remove dfll boost to maximum rate when running on PLL */
1212         if (c->dvfs && !tegra_dvfs_is_dfll_scale(c->dvfs, rate))
1213                 max_rate -= c->dvfs->dfll_data.max_rate_boost;
1214
1215         if (rate > max_rate)
1216                 rate = max_rate;
1217         else if (rate < c->min_rate)
1218                 rate = c->min_rate;
1219         return rate;
1220 }
1221
1222 static struct clk_ops tegra_cpu_ops = {
1223         .init     = tegra14_cpu_clk_init,
1224         .enable   = tegra14_cpu_clk_enable,
1225         .disable  = tegra14_cpu_clk_disable,
1226         .set_rate = tegra14_cpu_clk_set_rate,
1227         .round_rate = tegra14_cpu_clk_round_rate,
1228 };
1229
1230
1231 static void tegra14_cpu_cmplx_clk_init(struct clk *c)
1232 {
1233         int i = !!is_lp_cluster();
1234
1235         BUG_ON(c->inputs[0].input->u.cpu.mode != MODE_G);
1236         BUG_ON(c->inputs[1].input->u.cpu.mode != MODE_LP);
1237         c->parent = c->inputs[i].input;
1238 }
1239
1240 /* cpu complex clock provides second level vitualization (on top of
1241    cpu virtual cpu rate control) in order to hide the CPU mode switch
1242    sequence */
1243 #if PARAMETERIZE_CLUSTER_SWITCH
1244 static unsigned int switch_delay;
1245 static unsigned int switch_flags;
1246 static DEFINE_SPINLOCK(parameters_lock);
1247
1248 void tegra_cluster_switch_set_parameters(unsigned int us, unsigned int flags)
1249 {
1250         spin_lock(&parameters_lock);
1251         switch_delay = us;
1252         switch_flags = flags;
1253         spin_unlock(&parameters_lock);
1254 }
1255 #endif
1256
1257 static int tegra14_cpu_cmplx_clk_enable(struct clk *c)
1258 {
1259         return 0;
1260 }
1261
1262 static void tegra14_cpu_cmplx_clk_disable(struct clk *c)
1263 {
1264         pr_debug("%s on clock %s\n", __func__, c->name);
1265
1266         /* oops - don't disable the CPU complex clock! */
1267         BUG();
1268 }
1269
1270 static int tegra14_cpu_cmplx_clk_set_rate(struct clk *c, unsigned long rate)
1271 {
1272         unsigned long flags;
1273         int ret;
1274         struct clk *parent = c->parent;
1275
1276         if (!parent->ops || !parent->ops->set_rate)
1277                 return -ENOSYS;
1278
1279         clk_lock_save(parent, &flags);
1280
1281         ret = clk_set_rate_locked(parent, rate);
1282
1283         clk_unlock_restore(parent, &flags);
1284
1285         return ret;
1286 }
1287
1288 static int tegra14_cpu_cmplx_clk_set_parent(struct clk *c, struct clk *p)
1289 {
1290         int ret;
1291         unsigned int flags, delay;
1292         const struct clk_mux_sel *sel;
1293         unsigned long rate = clk_get_rate(c->parent);
1294         struct clk *dfll = c->parent->u.cpu.dynamic ? : p->u.cpu.dynamic;
1295         struct clk *p_source;
1296
1297         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
1298         BUG_ON(c->parent->u.cpu.mode != (is_lp_cluster() ? MODE_LP : MODE_G));
1299
1300         for (sel = c->inputs; sel->input != NULL; sel++) {
1301                 if (sel->input == p)
1302                         break;
1303         }
1304         if (!sel->input)
1305                 return -EINVAL;
1306
1307 #if PARAMETERIZE_CLUSTER_SWITCH
1308         spin_lock(&parameters_lock);
1309         flags = switch_flags;
1310         delay = switch_delay;
1311         switch_flags = 0;
1312         spin_unlock(&parameters_lock);
1313
1314         if (flags) {
1315                 /* over/under-clocking after switch - allow, but update rate */
1316                 if ((rate > p->max_rate) || (rate < p->min_rate)) {
1317                         rate = rate > p->max_rate ? p->max_rate : p->min_rate;
1318                         ret = clk_set_rate(c->parent, rate);
1319                         if (ret) {
1320                                 pr_err("%s: Failed to set rate %lu for %s\n",
1321                                         __func__, rate, p->name);
1322                                 return ret;
1323                         }
1324                 }
1325         } else
1326 #endif
1327         {
1328                 if (rate > p->max_rate) {       /* over-clocking - no switch */
1329                         pr_warn("%s: No %s mode switch to %s at rate %lu\n",
1330                                  __func__, c->name, p->name, rate);
1331                         return -ECANCELED;
1332                 }
1333                 flags = TEGRA_POWER_CLUSTER_IMMEDIATE;
1334                 flags |= TEGRA_POWER_CLUSTER_PART_DEFAULT;
1335                 delay = 0;
1336         }
1337         flags |= (p->u.cpu.mode == MODE_LP) ? TEGRA_POWER_CLUSTER_LP :
1338                 TEGRA_POWER_CLUSTER_G;
1339
1340         if (p == c->parent) {
1341                 if (flags & TEGRA_POWER_CLUSTER_FORCE) {
1342                         /* Allow parameterized switch to the same mode */
1343                         ret = tegra_cluster_control(delay, flags);
1344                         if (ret)
1345                                 pr_err("%s: Failed to force %s mode to %s\n",
1346                                        __func__, c->name, p->name);
1347                         return ret;
1348                 }
1349                 return 0;       /* already switched - exit */
1350         }
1351
1352         tegra_dvfs_rail_mode_updating(tegra_cpu_rail, true);
1353         if (c->parent->parent->parent == dfll) {
1354                 /* G (DFLL selected as clock source) => LP switch:
1355                  * turn DFLL into open loop mode ("release" VDD_CPU rail)
1356                  * select target p_source for LP, and get its rate ready
1357                  */
1358                 ret = tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 0);
1359                 if (ret)
1360                         goto abort;
1361
1362                 ret = tegra_dvfs_rail_dfll_mode_set_cold(tegra_cpu_rail);
1363                 if (ret)
1364                         goto abort;
1365
1366                 p_source = rate <= p->u.cpu.backup_rate ?
1367                         p->u.cpu.backup : p->u.cpu.main;
1368                 ret = clk_set_rate(p_source, rate);
1369                 if (ret)
1370                         goto abort;
1371         } else if (p->parent->parent == dfll) {
1372                 /* LP => G (DFLL selected as clock source) switch:
1373                  * set DFLL rate ready (DFLL is still disabled)
1374                  * (set target p_source as dfll, G source is already selected)
1375                  */
1376                 p_source = dfll;
1377                 ret = clk_set_rate(p_source, rate);
1378                 if (ret)
1379                         goto abort;
1380         } else
1381                 /* DFLL is not selcted on either side of the switch:
1382                  * set target p_source equal to current clock source
1383                  */
1384                 p_source = c->parent->parent->parent;
1385
1386         /* Switch new parent to target clock source if necessary */
1387         if (p->parent->parent != p_source) {
1388                 ret = clk_set_parent(p->parent, p_source);
1389                 if (ret) {
1390                         pr_err("%s: Failed to set parent %s for %s\n",
1391                                __func__, p_source->name, p->name);
1392                         goto abort;
1393                 }
1394         }
1395
1396         /* Enabling new parent scales new mode voltage rail in advanvce
1397            before the switch happens (if p_source is DFLL: open loop mode) */
1398         if (c->refcnt)
1399                 clk_enable(p);
1400
1401         /* switch CPU mode */
1402         ret = tegra_cluster_control(delay, flags);
1403         if (ret) {
1404                 if (c->refcnt)
1405                         clk_disable(p);
1406                 pr_err("%s: Failed to switch %s mode to %s\n",
1407                        __func__, c->name, p->name);
1408                 goto abort;
1409         }
1410
1411         /* Disabling old parent scales old mode voltage rail */
1412         if (c->refcnt)
1413                 clk_disable(c->parent);
1414
1415         clk_reparent(c, p);
1416
1417         /* Lock DFLL now (resume closed loop VDD_CPU control) */
1418         if (p_source == dfll)
1419                 tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 1);
1420
1421         tegra_dvfs_rail_mode_updating(tegra_cpu_rail, false);
1422         return 0;
1423
1424 abort:
1425         /* Re-lock DFLL if necessary after aborted switch */
1426         if (c->parent->parent->parent == dfll)
1427                 tegra_clk_cfg_ex(dfll, TEGRA_CLK_DFLL_LOCK, 1);
1428         tegra_dvfs_rail_mode_updating(tegra_cpu_rail, false);
1429
1430         pr_err("%s: aborted switch from %s to %s\n",
1431                __func__, c->parent->name, p->name);
1432         return ret;
1433 }
1434
1435 static long tegra14_cpu_cmplx_round_rate(struct clk *c,
1436         unsigned long rate)
1437 {
1438         return clk_round_rate(c->parent, rate);
1439 }
1440
1441 static struct clk_ops tegra_cpu_cmplx_ops = {
1442         .init     = tegra14_cpu_cmplx_clk_init,
1443         .enable   = tegra14_cpu_cmplx_clk_enable,
1444         .disable  = tegra14_cpu_cmplx_clk_disable,
1445         .set_rate = tegra14_cpu_cmplx_clk_set_rate,
1446         .set_parent = tegra14_cpu_cmplx_clk_set_parent,
1447         .round_rate = tegra14_cpu_cmplx_round_rate,
1448 };
1449
1450 /* virtual cop clock functions. Used to acquire the fake 'cop' clock to
1451  * reset the COP block (i.e. AVP) */
1452 static void tegra14_cop_clk_reset(struct clk *c, bool assert)
1453 {
1454         unsigned long reg = assert ? RST_DEVICES_SET_L : RST_DEVICES_CLR_L;
1455
1456         pr_debug("%s %s\n", __func__, assert ? "assert" : "deassert");
1457         clk_writel(1 << 1, reg);
1458 }
1459
1460 static struct clk_ops tegra_cop_ops = {
1461         .reset    = tegra14_cop_clk_reset,
1462 };
1463
1464 /* bus clock functions */
1465 static void tegra14_bus_clk_init(struct clk *c)
1466 {
1467         u32 val = clk_readl(c->reg);
1468         c->state = ((val >> c->reg_shift) & BUS_CLK_DISABLE) ? OFF : ON;
1469         c->div = ((val >> c->reg_shift) & BUS_CLK_DIV_MASK) + 1;
1470         c->mul = 1;
1471 }
1472
1473 static int tegra14_bus_clk_enable(struct clk *c)
1474 {
1475         u32 val = clk_readl(c->reg);
1476         val &= ~(BUS_CLK_DISABLE << c->reg_shift);
1477         clk_writel(val, c->reg);
1478         return 0;
1479 }
1480
1481 static void tegra14_bus_clk_disable(struct clk *c)
1482 {
1483         u32 val = clk_readl(c->reg);
1484         val |= BUS_CLK_DISABLE << c->reg_shift;
1485         clk_writel(val, c->reg);
1486 }
1487
1488 static int tegra14_bus_clk_set_rate(struct clk *c, unsigned long rate)
1489 {
1490         u32 val = clk_readl(c->reg);
1491         unsigned long parent_rate = clk_get_rate(c->parent);
1492         int i;
1493         for (i = 1; i <= 4; i++) {
1494                 if (rate >= parent_rate / i) {
1495                         val &= ~(BUS_CLK_DIV_MASK << c->reg_shift);
1496                         val |= (i - 1) << c->reg_shift;
1497                         clk_writel(val, c->reg);
1498                         c->div = i;
1499                         c->mul = 1;
1500                         return 0;
1501                 }
1502         }
1503         return -EINVAL;
1504 }
1505
1506 static struct clk_ops tegra_bus_ops = {
1507         .init                   = tegra14_bus_clk_init,
1508         .enable                 = tegra14_bus_clk_enable,
1509         .disable                = tegra14_bus_clk_disable,
1510         .set_rate               = tegra14_bus_clk_set_rate,
1511 };
1512
1513 /* Virtual system bus complex clock is used to hide the sequence of
1514    changing sclk/hclk/pclk parents and dividers to configure requested
1515    sclk target rate. */
1516 static void tegra14_sbus_cmplx_init(struct clk *c)
1517 {
1518         unsigned long rate;
1519
1520         c->max_rate = c->parent->max_rate;
1521         c->min_rate = c->parent->min_rate;
1522
1523         /* Threshold must be an exact proper factor of low range parent,
1524            and both low/high range parents have 7.1 fractional dividers */
1525         rate = clk_get_rate(c->u.system.sclk_low->parent);
1526         if (c->u.system.threshold) {
1527                 BUG_ON(c->u.system.threshold > rate) ;
1528                 BUG_ON((rate % c->u.system.threshold) != 0);
1529         }
1530         BUG_ON(!(c->u.system.sclk_low->flags & DIV_U71));
1531         BUG_ON(!(c->u.system.sclk_high->flags & DIV_U71));
1532 }
1533
1534 /* This special sbus round function is implemented because:
1535  *
1536  * (a) sbus complex clock source is selected automatically based on rate
1537  *
1538  * (b) since sbus is a shared bus, and its frequency is set to the highest
1539  * enabled shared_bus_user clock, the target rate should be rounded up divider
1540  * ladder (if max limit allows it) - for pll_div and peripheral_div common is
1541  * rounding down - special case again.
1542  *
1543  * Note that final rate is trimmed (not rounded up) to avoid spiraling up in
1544  * recursive calls. Lost 1Hz is added in tegra14_sbus_cmplx_set_rate before
1545  * actually setting divider rate.
1546  */
1547 static long tegra14_sbus_cmplx_round_updown(struct clk *c, unsigned long rate,
1548                                             bool up)
1549 {
1550         int divider;
1551         unsigned long source_rate, round_rate;
1552         struct clk *new_parent;
1553
1554         rate = max(rate, c->min_rate);
1555
1556         new_parent = (rate <= c->u.system.threshold) ?
1557                 c->u.system.sclk_low : c->u.system.sclk_high;
1558         source_rate = clk_get_rate(new_parent->parent);
1559
1560         divider = clk_div71_get_divider(source_rate, rate,
1561                 new_parent->flags, up ? ROUND_DIVIDER_DOWN : ROUND_DIVIDER_UP);
1562         if (divider < 0)
1563                 return c->min_rate;
1564
1565         if (divider == 1)
1566                 divider = 0;
1567
1568         round_rate = source_rate * 2 / (divider + 2);
1569         if (round_rate > c->max_rate) {
1570                 divider += new_parent->flags & DIV_U71_INT ? 2 : 1;
1571 #if !DIVIDER_1_5_ALLOWED
1572                 divider = max(2, divider);
1573 #endif
1574                 round_rate = source_rate * 2 / (divider + 2);
1575         }
1576
1577         if (new_parent == c->u.system.sclk_high) {
1578                 /* Prevent oscillation across threshold */
1579                 if (round_rate <= c->u.system.threshold)
1580                         round_rate = c->u.system.threshold;
1581         }
1582         return round_rate;
1583 }
1584
1585 static long tegra14_sbus_cmplx_round_rate(struct clk *c, unsigned long rate)
1586 {
1587         return tegra14_sbus_cmplx_round_updown(c, rate, true);
1588 }
1589
1590 static int tegra14_sbus_cmplx_set_rate(struct clk *c, unsigned long rate)
1591 {
1592         int ret;
1593         struct clk *new_parent;
1594
1595         /* - select the appropriate sclk parent
1596            - keep hclk at the same rate as sclk
1597            - set pclk at 1:2 rate of hclk unless pclk minimum is violated,
1598              in the latter case switch to 1:1 ratio */
1599
1600         if (rate >= c->u.system.pclk->min_rate * 2) {
1601                 ret = clk_set_div(c->u.system.pclk, 2);
1602                 if (ret) {
1603                         pr_err("Failed to set 1 : 2 pclk divider\n");
1604                         return ret;
1605                 }
1606         }
1607
1608         new_parent = (rate <= c->u.system.threshold) ?
1609                 c->u.system.sclk_low : c->u.system.sclk_high;
1610
1611         ret = clk_set_rate(new_parent, rate + 1);
1612         if (ret) {
1613                 pr_err("Failed to set sclk source %s to %lu\n",
1614                        new_parent->name, rate);
1615                 return ret;
1616         }
1617
1618         if (new_parent != clk_get_parent(c->parent)) {
1619                 ret = clk_set_parent(c->parent, new_parent);
1620                 if (ret) {
1621                         pr_err("Failed to switch sclk source to %s\n",
1622                                new_parent->name);
1623                         return ret;
1624                 }
1625         }
1626
1627         if (rate < c->u.system.pclk->min_rate * 2) {
1628                 ret = clk_set_div(c->u.system.pclk, 1);
1629                 if (ret) {
1630                         pr_err("Failed to set 1 : 1 pclk divider\n");
1631                         return ret;
1632                 }
1633         }
1634
1635         return 0;
1636 }
1637
1638 static int tegra14_clk_sbus_update(struct clk *bus)
1639 {
1640         unsigned long rate, old_rate;
1641
1642         if (detach_shared_bus)
1643                 return 0;
1644
1645         rate = tegra14_clk_shared_bus_update(bus, NULL, NULL, NULL);
1646
1647         old_rate = clk_get_rate_locked(bus);
1648         if (rate == old_rate)
1649                 return 0;
1650
1651         return clk_set_rate_locked(bus, rate);
1652 }
1653
1654 static struct clk_ops tegra_sbus_cmplx_ops = {
1655         .init = tegra14_sbus_cmplx_init,
1656         .set_rate = tegra14_sbus_cmplx_set_rate,
1657         .round_rate = tegra14_sbus_cmplx_round_rate,
1658         .round_rate_updown = tegra14_sbus_cmplx_round_updown,
1659         .shared_bus_update = tegra14_clk_sbus_update,
1660 };
1661
1662 /* Blink output functions */
1663
1664 static void tegra14_blink_clk_init(struct clk *c)
1665 {
1666         u32 val;
1667
1668         val = pmc_readl(PMC_CTRL);
1669         c->state = (val & PMC_CTRL_BLINK_ENB) ? ON : OFF;
1670         c->mul = 1;
1671         val = pmc_readl(c->reg);
1672
1673         if (val & PMC_BLINK_TIMER_ENB) {
1674                 unsigned int on_off;
1675
1676                 on_off = (val >> PMC_BLINK_TIMER_DATA_ON_SHIFT) &
1677                         PMC_BLINK_TIMER_DATA_ON_MASK;
1678                 val >>= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
1679                 val &= PMC_BLINK_TIMER_DATA_OFF_MASK;
1680                 on_off += val;
1681                 /* each tick in the blink timer is 4 32KHz clocks */
1682                 c->div = on_off * 4;
1683         } else {
1684                 c->div = 1;
1685         }
1686 }
1687
1688 static int tegra14_blink_clk_enable(struct clk *c)
1689 {
1690         u32 val;
1691
1692         val = pmc_readl(PMC_DPD_PADS_ORIDE);
1693         pmc_writel(val | PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
1694
1695         val = pmc_readl(PMC_CTRL);
1696         pmc_writel(val | PMC_CTRL_BLINK_ENB, PMC_CTRL);
1697
1698         return 0;
1699 }
1700
1701 static void tegra14_blink_clk_disable(struct clk *c)
1702 {
1703         u32 val;
1704
1705         val = pmc_readl(PMC_CTRL);
1706         pmc_writel(val & ~PMC_CTRL_BLINK_ENB, PMC_CTRL);
1707
1708         val = pmc_readl(PMC_DPD_PADS_ORIDE);
1709         pmc_writel(val & ~PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
1710 }
1711
1712 static int tegra14_blink_clk_set_rate(struct clk *c, unsigned long rate)
1713 {
1714         unsigned long parent_rate = clk_get_rate(c->parent);
1715         if (rate >= parent_rate) {
1716                 c->div = 1;
1717                 pmc_writel(0, c->reg);
1718         } else {
1719                 unsigned int on_off;
1720                 u32 val;
1721
1722                 on_off = DIV_ROUND_UP(parent_rate / 8, rate);
1723                 c->div = on_off * 8;
1724
1725                 val = (on_off & PMC_BLINK_TIMER_DATA_ON_MASK) <<
1726                         PMC_BLINK_TIMER_DATA_ON_SHIFT;
1727                 on_off &= PMC_BLINK_TIMER_DATA_OFF_MASK;
1728                 on_off <<= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
1729                 val |= on_off;
1730                 val |= PMC_BLINK_TIMER_ENB;
1731                 pmc_writel(val, c->reg);
1732         }
1733
1734         return 0;
1735 }
1736
1737 static struct clk_ops tegra_blink_clk_ops = {
1738         .init                   = &tegra14_blink_clk_init,
1739         .enable                 = &tegra14_blink_clk_enable,
1740         .disable                = &tegra14_blink_clk_disable,
1741         .set_rate               = &tegra14_blink_clk_set_rate,
1742 };
1743
1744 /* PLL Functions */
1745 static int tegra14_pll_clk_wait_for_lock(
1746         struct clk *c, u32 lock_reg, u32 lock_bits)
1747 {
1748 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
1749 #if USE_PLL_LOCK_BITS
1750         int i;
1751         for (i = 0; i < (c->u.pll.lock_delay / PLL_PRE_LOCK_DELAY + 1); i++) {
1752                 udelay(PLL_PRE_LOCK_DELAY);
1753                 if ((clk_readl(lock_reg) & lock_bits) == lock_bits) {
1754                         udelay(PLL_POST_LOCK_DELAY);
1755                         return 0;
1756                 }
1757         }
1758         pr_err("Timed out waiting for lock bit on pll %s\n", c->name);
1759         return -1;
1760 #endif
1761         udelay(c->u.pll.lock_delay);
1762 #endif
1763         return 0;
1764 }
1765
1766 static void tegra14_utmi_param_configure(struct clk *c)
1767 {
1768         u32 reg;
1769         int i;
1770         unsigned long main_rate =
1771                 clk_get_rate(c->parent->parent);
1772
1773         for (i = 0; i < ARRAY_SIZE(utmi_parameters); i++) {
1774                 if (main_rate == utmi_parameters[i].osc_frequency)
1775                         break;
1776         }
1777
1778         if (i >= ARRAY_SIZE(utmi_parameters)) {
1779                 pr_err("%s: Unexpected main rate %lu\n", __func__, main_rate);
1780                 return;
1781         }
1782
1783         reg = clk_readl(UTMIP_PLL_CFG2);
1784
1785         /* Program UTMIP PLL stable and active counts */
1786         /* [FIXME] arclk_rst.h says WRONG! This should be 1ms -> 0x50 Check! */
1787         reg &= ~UTMIP_PLL_CFG2_STABLE_COUNT(~0);
1788         reg |= UTMIP_PLL_CFG2_STABLE_COUNT(
1789                         utmi_parameters[i].stable_count);
1790
1791         reg &= ~UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(~0);
1792
1793         reg |= UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(
1794                         utmi_parameters[i].active_delay_count);
1795
1796         /* Remove power downs from UTMIP PLL control bits */
1797         reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_A_POWERDOWN;
1798
1799         clk_writel(reg, UTMIP_PLL_CFG2);
1800
1801         /* Program UTMIP PLL delay and oscillator frequency counts */
1802         reg = clk_readl(UTMIP_PLL_CFG1);
1803         reg &= ~UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(~0);
1804
1805         reg |= UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(
1806                 utmi_parameters[i].enable_delay_count);
1807
1808         reg &= ~UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(~0);
1809         reg |= UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(
1810                 utmi_parameters[i].xtal_freq_count);
1811
1812         /* Remove power downs from UTMIP PLL control bits */
1813         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN;
1814         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ACTIVE_POWERDOWN;
1815         reg &= ~UTMIP_PLL_CFG1_FORCE_PLLU_POWERUP;
1816         reg &= ~UTMIP_PLL_CFG1_FORCE_PLLU_POWERDOWN;
1817         clk_writel(reg, UTMIP_PLL_CFG1);
1818
1819         reg = clk_readl(UTMIP_PLL_CFG1);
1820         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERUP;
1821         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN;
1822         clk_writel(reg, UTMIP_PLL_CFG1);
1823
1824         udelay(1);
1825
1826         /* Setup SW override of UTMIPLL assuming USB2.0
1827            ports are assigned to USB2 */
1828         reg = clk_readl(UTMIPLL_HW_PWRDN_CFG0);
1829         reg |= UTMIPLL_HW_PWRDN_CFG0_IDDQ_SWCTL;
1830         reg |= UTMIPLL_HW_PWRDN_CFG0_IDDQ_OVERRIDE;
1831         clk_writel(reg, UTMIPLL_HW_PWRDN_CFG0);
1832
1833         udelay(1);
1834 }
1835
1836 static void tegra14_pll_clk_init(struct clk *c)
1837 {
1838         u32 val = clk_readl(c->reg + PLL_BASE);
1839
1840         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
1841
1842         if (c->flags & PLL_FIXED && !(val & PLL_BASE_OVERRIDE)) {
1843                 const struct clk_pll_freq_table *sel;
1844                 unsigned long input_rate = clk_get_rate(c->parent);
1845                 c->u.pll.fixed_rate = PLLP_DEFAULT_FIXED_RATE;
1846
1847                 for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
1848                         if (sel->input_rate == input_rate &&
1849                                 sel->output_rate == c->u.pll.fixed_rate) {
1850                                 c->mul = sel->n;
1851                                 c->div = sel->m * sel->p;
1852                                 return;
1853                         }
1854                 }
1855                 pr_err("Clock %s has unknown fixed frequency\n", c->name);
1856                 BUG();
1857         } else if (val & PLL_BASE_BYPASS) {
1858                 c->mul = 1;
1859                 c->div = 1;
1860         } else {
1861                 c->mul = (val & PLL_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
1862                 c->div = (val & PLL_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
1863                 if (c->flags & PLLU)
1864                         c->div *= (val & PLLU_BASE_POST_DIV) ? 1 : 2;
1865                 else
1866                         c->div *= (0x1 << ((val & PLL_BASE_DIVP_MASK) >>
1867                                         PLL_BASE_DIVP_SHIFT));
1868         }
1869
1870         if (c->flags & PLL_FIXED)
1871                 c->u.pll.fixed_rate = clk_get_rate_locked(c);
1872
1873         if (c->flags & PLLU) {
1874                 /* Configure UTMI PLL power management */
1875                 tegra14_utmi_param_configure(c);
1876
1877                 val = clk_readl(c->reg + PLL_BASE);
1878                 val &= ~PLLU_BASE_OVERRIDE;
1879                 clk_writel(val, c->reg + PLL_BASE);
1880         }
1881 }
1882
1883 static int tegra14_pll_clk_enable(struct clk *c)
1884 {
1885         u32 val;
1886         pr_debug("%s on clock %s\n", __func__, c->name);
1887
1888 #if USE_PLL_LOCK_BITS
1889         /* toggle lock enable bit to reset lock detection circuit (couple
1890            register reads provide enough duration for reset pulse) */
1891         val = clk_readl(c->reg + PLL_MISC(c));
1892         val &= ~PLL_MISC_LOCK_ENABLE(c);
1893         clk_writel(val, c->reg + PLL_MISC(c));
1894         val = clk_readl(c->reg + PLL_MISC(c));
1895         val = clk_readl(c->reg + PLL_MISC(c));
1896         val |= PLL_MISC_LOCK_ENABLE(c);
1897         clk_writel(val, c->reg + PLL_MISC(c));
1898 #endif
1899         val = clk_readl(c->reg + PLL_BASE);
1900         val &= ~PLL_BASE_BYPASS;
1901         val |= PLL_BASE_ENABLE;
1902         clk_writel(val, c->reg + PLL_BASE);
1903
1904         tegra14_pll_clk_wait_for_lock(c, c->reg + PLL_BASE, PLL_BASE_LOCK);
1905
1906         return 0;
1907 }
1908
1909 static void tegra14_pll_clk_disable(struct clk *c)
1910 {
1911         u32 val;
1912         pr_debug("%s on clock %s\n", __func__, c->name);
1913
1914         val = clk_readl(c->reg);
1915         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
1916         clk_writel(val, c->reg);
1917 }
1918
1919 static u8 get_pll_cpcon(struct clk *c, u16 n)
1920 {
1921         if (c->flags & PLLD) {
1922                 if (n >= 600)
1923                         return 12;
1924                 else if (n >= 300)
1925                         return 8;
1926                 else if (n >= 50)
1927                         return 3;
1928                 else
1929                         return 2;
1930         }
1931         return c->u.pll.cpcon_default ? : OUT_OF_TABLE_CPCON;
1932 }
1933
1934 static int tegra14_pll_clk_set_rate(struct clk *c, unsigned long rate)
1935 {
1936         u32 val, p_div, old_base;
1937         unsigned long input_rate;
1938         const struct clk_pll_freq_table *sel;
1939         struct clk_pll_freq_table cfg;
1940
1941         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
1942
1943         if (c->flags & PLL_FIXED) {
1944                 int ret = 0;
1945                 if (rate != c->u.pll.fixed_rate) {
1946                         pr_err("%s: Can not change %s fixed rate %lu to %lu\n",
1947                                __func__, c->name, c->u.pll.fixed_rate, rate);
1948                         ret = -EINVAL;
1949                 }
1950                 return ret;
1951         }
1952
1953         p_div = 0;
1954         input_rate = clk_get_rate(c->parent);
1955
1956         /* Check if the target rate is tabulated */
1957         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
1958                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
1959                         if (c->flags & PLLU) {
1960                                 BUG_ON(sel->p < 1 || sel->p > 2);
1961                                 if (sel->p == 1)
1962                                         p_div = PLLU_BASE_POST_DIV;
1963                         } else {
1964                                 BUG_ON(sel->p < 1);
1965                                 for (val = sel->p; val > 1; val >>= 1, p_div++)
1966                                         ;
1967                                 p_div <<= PLL_BASE_DIVP_SHIFT;
1968                         }
1969                         break;
1970                 }
1971         }
1972
1973         /* Configure out-of-table rate */
1974         if (sel->input_rate == 0) {
1975                 unsigned long cfreq, vco;
1976                 BUG_ON(c->flags & PLLU);
1977                 sel = &cfg;
1978
1979                 switch (input_rate) {
1980                 case 12000000:
1981                 case 26000000:
1982                         cfreq = (rate <= 1000000 * 1000) ? 1000000 : 2000000;
1983                         break;
1984                 case 13000000:
1985                         cfreq = (rate <= 1000000 * 1000) ? 1000000 : 2600000;
1986                         break;
1987                 case 16800000:
1988                 case 19200000:
1989                         cfreq = (rate <= 1200000 * 1000) ? 1200000 : 2400000;
1990                         break;
1991                 default:
1992                         if (c->parent->flags & DIV_U71_FIXED) {
1993                                 /* PLLP_OUT1 rate is not in PLLA table */
1994                                 pr_warn("%s: failed %s ref/out rates %lu/%lu\n",
1995                                         __func__, c->name, input_rate, rate);
1996                                 cfreq = input_rate/(input_rate/1000000);
1997                                 break;
1998                         }
1999                         pr_err("%s: Unexpected reference rate %lu\n",
2000                                __func__, input_rate);
2001                         BUG();
2002                 }
2003
2004                 /* Raise VCO to guarantee 0.5% accuracy, and vco min boundary */
2005                 vco = max(200 * cfreq, c->u.pll.vco_min);
2006                 for (cfg.output_rate = rate; cfg.output_rate < vco; p_div++)
2007                         cfg.output_rate <<= 1;
2008
2009                 cfg.p = 0x1 << p_div;
2010                 cfg.m = input_rate / cfreq;
2011                 cfg.n = cfg.output_rate / cfreq;
2012                 cfg.cpcon = get_pll_cpcon(c, cfg.n);
2013
2014                 if ((cfg.m > (PLL_BASE_DIVM_MASK >> PLL_BASE_DIVM_SHIFT)) ||
2015                     (cfg.n > (PLL_BASE_DIVN_MASK >> PLL_BASE_DIVN_SHIFT)) ||
2016                     (p_div > (PLL_BASE_DIVP_MASK >> PLL_BASE_DIVP_SHIFT)) ||
2017                     (cfg.output_rate > c->u.pll.vco_max)) {
2018                         pr_err("%s: Failed to set %s out-of-table rate %lu\n",
2019                                __func__, c->name, rate);
2020                         return -EINVAL;
2021                 }
2022                 p_div <<= PLL_BASE_DIVP_SHIFT;
2023         }
2024
2025         c->mul = sel->n;
2026         c->div = sel->m * sel->p;
2027
2028         old_base = val = clk_readl(c->reg + PLL_BASE);
2029         val &= ~(PLL_BASE_DIVM_MASK | PLL_BASE_DIVN_MASK |
2030                  ((c->flags & PLLU) ? PLLU_BASE_POST_DIV : PLL_BASE_DIVP_MASK));
2031         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
2032                 (sel->n << PLL_BASE_DIVN_SHIFT) | p_div;
2033         if (val == old_base)
2034                 return 0;
2035
2036         if (c->state == ON) {
2037                 tegra14_pll_clk_disable(c);
2038                 val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
2039         }
2040         clk_writel(val, c->reg + PLL_BASE);
2041
2042         if (c->flags & PLL_HAS_CPCON) {
2043                 val = clk_readl(c->reg + PLL_MISC(c));
2044                 val &= ~PLL_MISC_CPCON_MASK;
2045                 val |= sel->cpcon << PLL_MISC_CPCON_SHIFT;
2046                 if (c->flags & (PLLU | PLLD)) {
2047                         val &= ~PLL_MISC_LFCON_MASK;
2048                         val |= PLLDU_LFCON << PLL_MISC_LFCON_SHIFT;
2049                 }
2050                 clk_writel(val, c->reg + PLL_MISC(c));
2051         }
2052
2053         if (c->state == ON)
2054                 tegra14_pll_clk_enable(c);
2055
2056         return 0;
2057 }
2058
2059 static struct clk_ops tegra_pll_ops = {
2060         .init                   = tegra14_pll_clk_init,
2061         .enable                 = tegra14_pll_clk_enable,
2062         .disable                = tegra14_pll_clk_disable,
2063         .set_rate               = tegra14_pll_clk_set_rate,
2064 };
2065
2066 static void tegra14_pllp_clk_init(struct clk *c)
2067 {
2068         tegra14_pll_clk_init(c);
2069         tegra14_pllp_init_dependencies(c->u.pll.fixed_rate);
2070 }
2071
2072 #ifdef CONFIG_PM_SLEEP
2073 static void tegra14_pllp_clk_resume(struct clk *c)
2074 {
2075         unsigned long rate = c->u.pll.fixed_rate;
2076         tegra14_pll_clk_init(c);
2077         BUG_ON(rate != c->u.pll.fixed_rate);
2078 }
2079 #endif
2080
2081 static struct clk_ops tegra_pllp_ops = {
2082         .init                   = tegra14_pllp_clk_init,
2083         .enable                 = tegra14_pll_clk_enable,
2084         .disable                = tegra14_pll_clk_disable,
2085         .set_rate               = tegra14_pll_clk_set_rate,
2086 };
2087
2088 static int
2089 tegra14_plld_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
2090 {
2091         u32 val, mask, reg;
2092
2093         switch (p) {
2094         case TEGRA_CLK_PLLD_CSI_OUT_ENB:
2095                 mask = PLLD_BASE_CSI_CLKENABLE | PLLD_BASE_CSI_CLKSOURCE;
2096                 reg = c->reg + PLL_BASE;
2097                 break;
2098         case TEGRA_CLK_PLLD_DSI_OUT_ENB:
2099                 mask = PLLD_MISC_DSI_CLKENABLE;
2100                 reg = c->reg + PLL_MISC(c);
2101                 break;
2102         case TEGRA_CLK_PLLD_MIPI_MUX_SEL:
2103                 mask = PLLD_BASE_DSI_MUX_MASK;
2104                 reg = c->reg + PLL_BASE;
2105                 break;
2106         default:
2107                 return -EINVAL;
2108         }
2109
2110         val = clk_readl(reg);
2111         if (setting)
2112                 val |= mask;
2113         else
2114                 val &= ~mask;
2115         clk_writel(val, reg);
2116         return 0;
2117 }
2118
2119 static struct clk_ops tegra_plld_ops = {
2120         .init                   = tegra14_pll_clk_init,
2121         .enable                 = tegra14_pll_clk_enable,
2122         .disable                = tegra14_pll_clk_disable,
2123         .set_rate               = tegra14_pll_clk_set_rate,
2124         .clk_cfg_ex             = tegra14_plld_clk_cfg_ex,
2125 };
2126
2127 /*
2128  * Dynamic ramp PLLs:
2129  *  PLLC2 and PLLC3 (PLLCX)
2130  *  PLLX and PLLC (PLLXC)
2131  *
2132  * When scaling PLLC and PLLX, dynamic ramp is allowed for any transition that
2133  * changes NDIV only. As a matter of policy we will make sure that switching
2134  * between output rates above VCO minimum is always dynamic. The pre-requisite
2135  * for the above guarantee is the following configuration convention:
2136  * - pll configured with fixed MDIV
2137  * - when output rate is above VCO minimum PDIV = 0 (p-value = 1)
2138  * Switching between output rates below VCO minimum may or may not be dynamic,
2139  * and switching across VCO minimum is never dynamic.
2140  *
2141  * PLLC2 and PLLC3 in addition to dynamic ramp mechanism have also glitchless
2142  * output dividers. However dynamic ramp without overshoot is guaranteed only
2143  * when output divisor is less or equal 8.
2144  *
2145  * Of course, dynamic ramp is applied provided PLL is already enabled.
2146  */
2147
2148 /*
2149  * Common configuration policy for dynamic ramp PLLs:
2150  * - always set fixed M-value based on the reference rate
2151  * - always set P-value value 1:1 for output rates above VCO minimum, and
2152  *   choose minimum necessary P-value for output rates below VCO minimum
2153  * - calculate N-value based on selected M and P
2154  */
2155 static int pll_dyn_ramp_cfg(struct clk *c, struct clk_pll_freq_table *cfg,
2156         unsigned long rate, unsigned long input_rate, u32 *pdiv)
2157 {
2158         u32 p;
2159
2160         if (!rate)
2161                 return -EINVAL;
2162
2163         p = DIV_ROUND_UP(c->u.pll.vco_min, rate);
2164         p = c->u.pll.round_p_to_pdiv(p, pdiv);
2165         if (IS_ERR_VALUE(p))
2166                 return -EINVAL;
2167
2168         cfg->m = PLL_FIXED_MDIV(c, input_rate);
2169         cfg->p = p;
2170         cfg->output_rate = rate * cfg->p;
2171         cfg->n = cfg->output_rate * cfg->m / input_rate;
2172
2173         /* can use PLLCX N-divider field layout for all dynamic ramp PLLs */
2174         if ((cfg->n > (PLLCX_BASE_DIVN_MASK >> PLL_BASE_DIVN_SHIFT)) ||
2175             (cfg->output_rate > c->u.pll.vco_max))
2176                 return -EINVAL;
2177
2178         return 0;
2179 }
2180
2181 static int pll_dyn_ramp_find_cfg(struct clk *c, struct clk_pll_freq_table *cfg,
2182         unsigned long rate, unsigned long input_rate, u32 *pdiv)
2183 {
2184         const struct clk_pll_freq_table *sel;
2185
2186         /* Check if the target rate is tabulated */
2187         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
2188                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
2189                         u32 p = c->u.pll.round_p_to_pdiv(sel->p, pdiv);
2190                         BUG_ON(IS_ERR_VALUE(p));
2191                         BUG_ON(sel->m != PLL_FIXED_MDIV(c, input_rate));
2192                         *cfg = *sel;
2193                         return 0;
2194                 }
2195         }
2196
2197         /* Configure out-of-table rate */
2198         if (pll_dyn_ramp_cfg(c, cfg, rate, input_rate, pdiv)) {
2199                 pr_err("%s: Failed to set %s out-of-table rate %lu\n",
2200                        __func__, c->name, rate);
2201                 return -EINVAL;
2202         }
2203         return 0;
2204 }
2205
2206 static inline void pll_do_iddq(struct clk *c, u32 offs, u32 iddq_bit, bool set)
2207 {
2208         u32 val = clk_readl(c->reg + offs);
2209         if (set)
2210                 val |= iddq_bit;
2211         else
2212                 val &= ~iddq_bit;
2213         clk_writel_delay(val, c->reg + offs);
2214 }
2215
2216
2217 static u8 pllcx_p[PLLCX_PDIV_MAX + 1] = {
2218 /* PDIV: 0, 1, 2, 3, 4, 5,  6,  7 */
2219 /* p: */ 1, 2, 3, 4, 6, 8, 12, 16 };
2220
2221 static u32 pllcx_round_p_to_pdiv(u32 p, u32 *pdiv)
2222 {
2223         int i;
2224
2225         if (p) {
2226                 for (i = 0; i <= PLLCX_PDIV_MAX; i++) {
2227                         /* Do not use DIV3 p values - mapped to even PDIV */
2228                         if (i && ((i & 0x1) == 0))
2229                                 continue;
2230
2231                         if (p <= pllcx_p[i]) {
2232                                 if (pdiv)
2233                                         *pdiv = i;
2234                                 return pllcx_p[i];
2235                         }
2236                 }
2237         }
2238         return -EINVAL;
2239 }
2240
2241 static void pllcx_update_dynamic_koef(struct clk *c, unsigned long input_rate,
2242                                         u32 n)
2243 {
2244         u32 val, n_threshold;
2245
2246         switch (input_rate) {
2247         case 12000000:
2248                 n_threshold = 70;
2249                 break;
2250         case 13000000:
2251         case 26000000:
2252                 n_threshold = 71;
2253                 break;
2254         case 16800000:
2255                 n_threshold = 55;
2256                 break;
2257         case 19200000:
2258                 n_threshold = 48;
2259                 break;
2260         default:
2261                 pr_err("%s: Unexpected reference rate %lu\n",
2262                         __func__, input_rate);
2263                 BUG();
2264                 return;
2265         }
2266
2267         val = clk_readl(c->reg + PLL_MISC(c));
2268         val &= ~(PLLCX_MISC_SDM_DIV_MASK | PLLCX_MISC_FILT_DIV_MASK);
2269         val |= n <= n_threshold ?
2270                 PLLCX_MISC_DIV_LOW_RANGE : PLLCX_MISC_DIV_HIGH_RANGE;
2271         clk_writel(val, c->reg + PLL_MISC(c));
2272 }
2273
2274 static void pllcx_strobe(struct clk *c)
2275 {
2276         u32 reg = c->reg + PLL_MISC(c);
2277         u32 val = clk_readl(reg);
2278
2279         val |= PLLCX_MISC_STROBE;
2280         pll_writel_delay(val, reg);
2281
2282         val &= ~PLLCX_MISC_STROBE;
2283         clk_writel(val, reg);
2284 }
2285
2286 static void pllcx_set_defaults(struct clk *c, unsigned long input_rate, u32 n)
2287 {
2288         clk_writel(PLLCX_MISC_DEFAULT_VALUE, c->reg + PLL_MISC(c));
2289         clk_writel(PLLCX_MISC1_DEFAULT_VALUE, c->reg + PLL_MISCN(c, 1));
2290         clk_writel(PLLCX_MISC2_DEFAULT_VALUE, c->reg + PLL_MISCN(c, 2));
2291         clk_writel(PLLCX_MISC3_DEFAULT_VALUE, c->reg + PLL_MISCN(c, 3));
2292
2293         pllcx_update_dynamic_koef(c, input_rate, n);
2294 }
2295
2296 static void tegra14_pllcx_clk_init(struct clk *c)
2297 {
2298         unsigned long input_rate = clk_get_rate(c->parent);
2299         u32 m, n, p, val;
2300
2301         /* clip vco_min to exact multiple of input rate to avoid crossover
2302            by rounding */
2303         c->u.pll.vco_min =
2304                 DIV_ROUND_UP(c->u.pll.vco_min, input_rate) * input_rate;
2305         c->min_rate = DIV_ROUND_UP(c->u.pll.vco_min, pllcx_p[PLLCX_PDIV_MAX]);
2306
2307         val = clk_readl(c->reg + PLL_BASE);
2308         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
2309
2310         /*
2311          * PLLCX is not a boot PLL, it should be left disabled by boot-loader,
2312          * and no enabled module clocks should use it as a source during clock
2313          * init.
2314          */
2315 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
2316         BUG_ON(c->state == ON);
2317 #endif
2318         /*
2319          * Most of PLLCX register fields are shadowed, and can not be read
2320          * directly from PLL h/w. Hence, actual PLLCX boot state is unknown.
2321          * Initialize PLL to default state: disabled, reset; shadow registers
2322          * loaded with default parameters; dividers are preset for half of
2323          * minimum VCO rate (the latter assured that shadowed divider settings
2324          * are within supported range).
2325          */
2326         m = PLL_FIXED_MDIV(c, input_rate);
2327         n = m * c->u.pll.vco_min / input_rate;
2328         p = pllcx_p[1];
2329         val = (m << PLL_BASE_DIVM_SHIFT) | (n << PLL_BASE_DIVN_SHIFT) |
2330                 (1 << PLL_BASE_DIVP_SHIFT);
2331         clk_writel(val, c->reg + PLL_BASE);     /* PLL disabled */
2332
2333         pllcx_set_defaults(c, input_rate, n);
2334
2335         c->mul = n;
2336         c->div = m * p;
2337 }
2338
2339 static int tegra14_pllcx_clk_enable(struct clk *c)
2340 {
2341         u32 val;
2342         pr_debug("%s on clock %s\n", __func__, c->name);
2343
2344         pll_do_iddq(c, PLL_MISCN(c, 1), PLLCX_MISC1_IDDQ, false);
2345
2346         val = clk_readl(c->reg + PLL_BASE);
2347         val &= ~PLL_BASE_BYPASS;
2348         val |= PLL_BASE_ENABLE;
2349         pll_writel_delay(val, c->reg + PLL_BASE);
2350
2351         val = clk_readl(c->reg + PLL_MISC(c));
2352         val &= ~PLLCX_MISC_RESET;
2353         pll_writel_delay(val, c->reg + PLL_MISC(c));
2354
2355         pllcx_strobe(c);
2356         tegra14_pll_clk_wait_for_lock(c, c->reg + PLL_BASE,
2357                         PLL_BASE_LOCK | PLLCX_BASE_PHASE_LOCK);
2358         return 0;
2359 }
2360
2361 static void tegra14_pllcx_clk_disable(struct clk *c)
2362 {
2363         u32 val;
2364         pr_debug("%s on clock %s\n", __func__, c->name);
2365
2366         val = clk_readl(c->reg);
2367         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
2368         clk_writel(val, c->reg);
2369
2370         val = clk_readl(c->reg + PLL_MISC(c));
2371         val |= PLLCX_MISC_RESET;
2372         pll_writel_delay(val, c->reg + PLL_MISC(c));
2373
2374         pll_do_iddq(c, PLL_MISCN(c, 1), PLLCX_MISC1_IDDQ, true);
2375 }
2376
2377 static int tegra14_pllcx_clk_set_rate(struct clk *c, unsigned long rate)
2378 {
2379         u32 val, pdiv;
2380         unsigned long input_rate;
2381         struct clk_pll_freq_table cfg, old_cfg;
2382         const struct clk_pll_freq_table *sel = &cfg;
2383
2384         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
2385
2386         input_rate = clk_get_rate(c->parent);
2387
2388         if (pll_dyn_ramp_find_cfg(c, &cfg, rate, input_rate, &pdiv))
2389                 return -EINVAL;
2390
2391         c->mul = sel->n;
2392         c->div = sel->m * sel->p;
2393
2394         val = clk_readl(c->reg + PLL_BASE);
2395         PLL_BASE_PARSE(PLLCX, old_cfg, val);
2396         old_cfg.p = pllcx_p[old_cfg.p];
2397
2398         BUG_ON(old_cfg.m != sel->m);
2399         if ((sel->n == old_cfg.n) && (sel->p == old_cfg.p))
2400                 return 0;
2401
2402 #if PLLCX_USE_DYN_RAMP
2403         if (c->state == ON && ((sel->n == old_cfg.n) ||
2404                                PLLCX_IS_DYN(sel->p, old_cfg.p))) {
2405                 /*
2406                  * Dynamic ramp if PLL is enabled, and M divider is unchanged:
2407                  * - Change P divider 1st if intermediate rate is below either
2408                  *   old or new rate.
2409                  * - Change N divider with DFS strobe - target rate is either
2410                  *   final new rate or below old rate
2411                  * - If divider has been changed, exit without waiting for lock.
2412                  *   Otherwise, wait for lock and change divider.
2413                  */
2414                 if (sel->p > old_cfg.p) {
2415                         val &= ~PLLCX_BASE_DIVP_MASK;
2416                         val |= pdiv << PLL_BASE_DIVP_SHIFT;
2417                         clk_writel(val, c->reg + PLL_BASE);
2418                 }
2419
2420                 if (sel->n != old_cfg.n) {
2421                         pllcx_update_dynamic_koef(c, input_rate, sel->n);
2422                         val &= ~PLLCX_BASE_DIVN_MASK;
2423                         val |= sel->n << PLL_BASE_DIVN_SHIFT;
2424                         pll_writel_delay(val, c->reg + PLL_BASE);
2425
2426                         pllcx_strobe(c);
2427                         tegra14_pll_clk_wait_for_lock(c, c->reg + PLL_BASE,
2428                                         PLL_BASE_LOCK | PLLCX_BASE_PHASE_LOCK);
2429                 }
2430
2431                 if (sel->p < old_cfg.p) {
2432                         val &= ~PLLCX_BASE_DIVP_MASK;
2433                         val |= pdiv << PLL_BASE_DIVP_SHIFT;
2434                         clk_writel(val, c->reg + PLL_BASE);
2435                 }
2436                 return 0;
2437         }
2438 #endif
2439
2440         val &= ~(PLLCX_BASE_DIVN_MASK | PLLCX_BASE_DIVP_MASK);
2441         val |= (sel->n << PLL_BASE_DIVN_SHIFT) |
2442                 (pdiv << PLL_BASE_DIVP_SHIFT);
2443
2444         if (c->state == ON) {
2445                 tegra14_pllcx_clk_disable(c);
2446                 val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
2447         }
2448         pllcx_update_dynamic_koef(c, input_rate, sel->n);
2449         clk_writel(val, c->reg + PLL_BASE);
2450         if (c->state == ON)
2451                 tegra14_pllcx_clk_enable(c);
2452
2453         return 0;
2454 }
2455
2456 #ifdef CONFIG_PM_SLEEP
2457 static void tegra14_pllcx_clk_resume_enable(struct clk *c)
2458 {
2459         unsigned long rate = clk_get_rate_all_locked(c->parent);
2460         u32 val = clk_readl(c->reg + PLL_BASE);
2461         enum clk_state state = c->state;
2462
2463         if (val & PLL_BASE_ENABLE)
2464                 return;         /* already resumed */
2465
2466         /* Restore input divider */
2467         val &= ~PLLCX_BASE_DIVM_MASK;
2468         val |= PLL_FIXED_MDIV(c, rate) << PLL_BASE_DIVM_SHIFT;
2469         clk_writel(val, c->reg + PLL_BASE);
2470
2471         /* temporarily sync h/w and s/w states, final sync happens
2472            in tegra_clk_resume later */
2473         c->state = OFF;
2474         pllcx_set_defaults(c, rate, c->mul);
2475
2476         rate = clk_get_rate_all_locked(c) + 1;
2477         tegra14_pllcx_clk_set_rate(c, rate);
2478         tegra14_pllcx_clk_enable(c);
2479         c->state = state;
2480 }
2481 #endif
2482
2483 static struct clk_ops tegra_pllcx_ops = {
2484         .init                   = tegra14_pllcx_clk_init,
2485         .enable                 = tegra14_pllcx_clk_enable,
2486         .disable                = tegra14_pllcx_clk_disable,
2487         .set_rate               = tegra14_pllcx_clk_set_rate,
2488 };
2489
2490
2491 /* non-monotonic mapping below is not a typo */
2492 static u8 pllxc_p[PLLXC_PDIV_MAX + 1] = {
2493 /* PDIV: 0, 1, 2, 3, 4, 5, 6,  7,  8,  9, 10, 11, 12, 13, 14 */
2494 /* p: */ 1, 2, 3, 4, 5, 6, 8, 10, 12, 16, 12, 16, 20, 24, 32 };
2495
2496 static u32 pllxc_round_p_to_pdiv(u32 p, u32 *pdiv)
2497 {
2498         if (!p || (p > PLLXC_SW_PDIV_MAX + 1))
2499                 return -EINVAL;
2500
2501         if (pdiv)
2502                 *pdiv = p - 1;
2503         return p;
2504 }
2505
2506 static void pllxc_get_dyn_steps(struct clk *c, unsigned long input_rate,
2507                                 u32 *step_a, u32 *step_b)
2508 {
2509         switch (input_rate) {
2510         case 12000000:
2511         case 13000000:
2512         case 26000000:
2513                 *step_a = 0x2B;
2514                 *step_b = 0x0B;
2515                 return;
2516         case 16800000:
2517                 *step_a = 0x1A;
2518                 *step_b = 0x09;
2519                 return;
2520         case 19200000:
2521                 *step_a = 0x12;
2522                 *step_b = 0x08;
2523                 return;
2524         default:
2525                 pr_err("%s: Unexpected reference rate %lu\n",
2526                         __func__, input_rate);
2527                 BUG();
2528         }
2529 }
2530
2531 static void pllx_set_defaults(struct clk *c, unsigned long input_rate)
2532 {
2533         u32 val;
2534         u32 step_a, step_b;
2535
2536         /* Only s/w dyn ramp control is supported */
2537         val = clk_readl(PLLX_HW_CTRL_CFG);
2538 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
2539         BUG_ON(!(val & PLLX_HW_CTRL_CFG_SWCTRL));
2540 #endif
2541
2542         pllxc_get_dyn_steps(c, input_rate, &step_a, &step_b);
2543         val = step_a << PLLX_MISC2_DYNRAMP_STEPA_SHIFT;
2544         val |= step_b << PLLX_MISC2_DYNRAMP_STEPB_SHIFT;
2545
2546         /* Get ready dyn ramp state machine, disable lock override */
2547         clk_writel(val, c->reg + PLL_MISCN(c, 2));
2548
2549         /* Enable outputs to CPUs and configure lock */
2550         val = 0;
2551 #if USE_PLL_LOCK_BITS
2552         val |= PLL_MISC_LOCK_ENABLE(c);
2553 #endif
2554         clk_writel(val, c->reg + PLL_MISC(c));
2555
2556         /* Check/set IDDQ */
2557         val = clk_readl(c->reg + PLL_MISCN(c, 3));
2558         if (c->state == ON) {
2559 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
2560                 BUG_ON(val & PLLX_MISC3_IDDQ);
2561 #endif
2562         } else {
2563                 val |= PLLX_MISC3_IDDQ;
2564                 clk_writel(val, c->reg + PLL_MISCN(c, 3));
2565         }
2566 }
2567
2568 static void pllc_set_defaults(struct clk *c, unsigned long input_rate)
2569 {
2570         u32 val;
2571         u32 step_a, step_b;
2572
2573         /* Get ready dyn ramp state machine */
2574         pllxc_get_dyn_steps(c, input_rate, &step_a, &step_b);
2575         val = step_a << PLLC_MISC1_DYNRAMP_STEPA_SHIFT;
2576         val |= step_b << PLLC_MISC1_DYNRAMP_STEPB_SHIFT;
2577         clk_writel(val, c->reg + PLL_MISCN(c, 1));
2578
2579         /* Configure lock and check/set IDDQ */
2580         val = clk_readl(c->reg + PLL_BASE);
2581         val &= ~PLLC_BASE_LOCK_OVERRIDE;
2582         clk_writel(val, c->reg + PLL_BASE);
2583
2584         val = clk_readl(c->reg + PLL_MISC(c));
2585 #if USE_PLL_LOCK_BITS
2586         val |= PLLC_MISC_LOCK_ENABLE;
2587 #else
2588         val &= ~PLLC_MISC_LOCK_ENABLE;
2589 #endif
2590         clk_writel(val, c->reg + PLL_MISC(c));
2591
2592         if (c->state == ON) {
2593 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
2594                 /* FIXME: WAR for bug 1235180 */
2595                 /* BUG_ON(val & PLLC_MISC_IDDQ); */
2596                 pr_err("PLLC_MISC_IDDQ was on. Clearing it.\n");
2597                 val &= ~PLLC_MISC_IDDQ;
2598                 clk_writel(val, c->reg + PLL_MISC(c));
2599 #endif
2600         } else {
2601                 val |= PLLC_MISC_IDDQ;
2602                 clk_writel(val, c->reg + PLL_MISC(c));
2603         }
2604 }
2605
2606 static void tegra14_pllxc_clk_init(struct clk *c)
2607 {
2608         unsigned long input_rate = clk_get_rate(c->parent);
2609         u32 m, p, val;
2610
2611         /* clip vco_min to exact multiple of input rate to avoid crossover
2612            by rounding */
2613         c->u.pll.vco_min =
2614                 DIV_ROUND_UP(c->u.pll.vco_min, input_rate) * input_rate;
2615         c->min_rate =
2616                 DIV_ROUND_UP(c->u.pll.vco_min, pllxc_p[PLLXC_SW_PDIV_MAX]);
2617
2618         val = clk_readl(c->reg + PLL_BASE);
2619         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
2620
2621         m = (val & PLLXC_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
2622         p = (val & PLLXC_BASE_DIVP_MASK) >> PLL_BASE_DIVP_SHIFT;
2623         BUG_ON(p > PLLXC_PDIV_MAX);
2624         p = pllxc_p[p];
2625
2626         c->div = m * p;
2627         c->mul = (val & PLLXC_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
2628
2629         if (c->flags & PLLX)
2630                 pllx_set_defaults(c, input_rate);
2631         else
2632                 pllc_set_defaults(c, input_rate);
2633 }
2634
2635 static int tegra14_pllxc_clk_enable(struct clk *c)
2636 {
2637         u32 val;
2638         pr_debug("%s on clock %s\n", __func__, c->name);
2639
2640         if (c->flags & PLLX)
2641                 pll_do_iddq(c, PLL_MISCN(c, 3), PLLX_MISC3_IDDQ, false);
2642         else
2643                 pll_do_iddq(c, PLL_MISC(c), PLLC_MISC_IDDQ, false);
2644
2645         val = clk_readl(c->reg + PLL_BASE);
2646         val |= PLL_BASE_ENABLE;
2647         clk_writel(val, c->reg + PLL_BASE);
2648
2649         tegra14_pll_clk_wait_for_lock(c, c->reg + PLL_BASE, PLL_BASE_LOCK);
2650
2651         return 0;
2652 }
2653
2654 static void tegra14_pllxc_clk_disable(struct clk *c)
2655 {
2656         u32 val;
2657         pr_debug("%s on clock %s\n", __func__, c->name);
2658
2659         val = clk_readl(c->reg + PLL_BASE);
2660         val &= ~PLL_BASE_ENABLE;
2661         clk_writel(val, c->reg + PLL_BASE);
2662
2663         if (c->flags & PLLX)
2664                 pll_do_iddq(c, PLL_MISCN(c, 3), PLLX_MISC3_IDDQ, true);
2665         else
2666                 pll_do_iddq(c, PLL_MISC(c), PLLC_MISC_IDDQ, true);
2667
2668 }
2669
2670 #define PLLXC_DYN_RAMP(pll_misc, reg)                                   \
2671         do {                                                            \
2672                 u32 misc = clk_readl((reg));                            \
2673                                                                         \
2674                 misc &= ~pll_misc##_NDIV_NEW_MASK;                      \
2675                 misc |= sel->n << pll_misc##_NDIV_NEW_SHIFT;            \
2676                 pll_writel_delay(misc, (reg));                          \
2677                                                                         \
2678                 misc |= pll_misc##_EN_DYNRAMP;                          \
2679                 clk_writel(misc, (reg));                                \
2680                 tegra14_pll_clk_wait_for_lock(c, (reg),                 \
2681                                         pll_misc##_DYNRAMP_DONE);       \
2682                                                                         \
2683                 val &= ~PLLXC_BASE_DIVN_MASK;                           \
2684                 val |= sel->n << PLL_BASE_DIVN_SHIFT;                   \
2685                 pll_writel_delay(val, c->reg + PLL_BASE);               \
2686                                                                         \
2687                 misc &= ~pll_misc##_EN_DYNRAMP;                         \
2688                 pll_writel_delay(misc, (reg));                          \
2689         } while (0)
2690
2691 static int tegra14_pllxc_clk_set_rate(struct clk *c, unsigned long rate)
2692 {
2693         u32 val, pdiv;
2694         unsigned long input_rate;
2695         struct clk_pll_freq_table cfg, old_cfg;
2696         const struct clk_pll_freq_table *sel = &cfg;
2697
2698         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
2699
2700         input_rate = clk_get_rate(c->parent);
2701
2702         if (pll_dyn_ramp_find_cfg(c, &cfg, rate, input_rate, &pdiv))
2703                 return -EINVAL;
2704
2705         c->mul = sel->n;
2706         c->div = sel->m * sel->p;
2707
2708         val = clk_readl(c->reg + PLL_BASE);
2709         PLL_BASE_PARSE(PLLXC, old_cfg, val);
2710         old_cfg.p = pllxc_p[old_cfg.p];
2711
2712         if ((sel->m == old_cfg.m) && (sel->n == old_cfg.n) &&
2713             (sel->p == old_cfg.p))
2714                 return 0;
2715
2716 #if PLLXC_USE_DYN_RAMP
2717         /*
2718          * Dynamic ramp can be used if M, P dividers are unchanged
2719          * (coveres superset of conventional dynamic ramps)
2720          */
2721         if ((c->state == ON) && (sel->m == old_cfg.m) &&
2722             (sel->p == old_cfg.p)) {
2723
2724                 if (c->flags & PLLX) {
2725                         u32 reg = c->reg + PLL_MISCN(c, 2);
2726                         PLLXC_DYN_RAMP(PLLX_MISC2, reg);
2727                 } else {
2728                         u32 reg = c->reg + PLL_MISCN(c, 1);
2729                         PLLXC_DYN_RAMP(PLLC_MISC1, reg);
2730                 }
2731
2732                 return 0;
2733         }
2734 #endif
2735         if (c->state == ON) {
2736                 /* Use "ENABLE" pulse without placing PLL into IDDQ */
2737                 val &= ~PLL_BASE_ENABLE;
2738                 pll_writel_delay(val, c->reg + PLL_BASE);
2739         }
2740
2741         val &= ~(PLLXC_BASE_DIVM_MASK |
2742                  PLLXC_BASE_DIVN_MASK | PLLXC_BASE_DIVP_MASK);
2743         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
2744                 (sel->n << PLL_BASE_DIVN_SHIFT) | (pdiv << PLL_BASE_DIVP_SHIFT);
2745         clk_writel(val, c->reg + PLL_BASE);
2746
2747         if (c->state == ON) {
2748                 val |= PLL_BASE_ENABLE;
2749                 clk_writel(val, c->reg + PLL_BASE);
2750                 tegra14_pll_clk_wait_for_lock(c, c->reg + PLL_BASE,
2751                                               PLL_BASE_LOCK);
2752         }
2753         return 0;
2754 }
2755
2756 #ifdef CONFIG_PM_SLEEP
2757 static void tegra14_pllxc_clk_resume_enable(struct clk *c)
2758 {
2759         unsigned long rate = clk_get_rate_all_locked(c->parent);
2760         enum clk_state state = c->state;
2761
2762         if (clk_readl(c->reg + PLL_BASE) & PLL_BASE_ENABLE)
2763                 return;         /* already resumed */
2764
2765         /* temporarily sync h/w and s/w states, final sync happens
2766            in tegra_clk_resume later */
2767         c->state = OFF;
2768         if (c->flags & PLLX)
2769                 pllx_set_defaults(c, rate);
2770         else
2771                 pllc_set_defaults(c, rate);
2772
2773         rate = clk_get_rate_all_locked(c) + 1;
2774         tegra14_pllxc_clk_set_rate(c, rate);
2775         tegra14_pllxc_clk_enable(c);
2776         c->state = state;
2777 }
2778 #endif
2779
2780 static struct clk_ops tegra_pllxc_ops = {
2781         .init                   = tegra14_pllxc_clk_init,
2782         .enable                 = tegra14_pllxc_clk_enable,
2783         .disable                = tegra14_pllxc_clk_disable,
2784         .set_rate               = tegra14_pllxc_clk_set_rate,
2785 };
2786
2787
2788 /* FIXME: pllm suspend/resume */
2789
2790 static u32 pllm_round_p_to_pdiv(u32 p, u32 *pdiv)
2791 {
2792         if (!p || (p > 2))
2793                 return -EINVAL;
2794
2795         if (pdiv)
2796                 *pdiv = p - 1;
2797         return p;
2798 }
2799
2800 static void pllm_set_defaults(struct clk *c, unsigned long input_rate)
2801 {
2802         u32 val = clk_readl(c->reg + PLL_MISC(c));
2803
2804         val &= ~PLLM_MISC_LOCK_OVERRIDE;
2805 #if USE_PLL_LOCK_BITS
2806         val &= ~PLLM_MISC_LOCK_DISABLE;
2807 #else
2808         val |= PLLM_MISC_LOCK_DISABLE;
2809 #endif
2810
2811         if (c->state != ON)
2812                 val |= PLLM_MISC_IDDQ;
2813 #ifndef CONFIG_TEGRA_SIMULATION_PLATFORM
2814         else
2815                 BUG_ON(val & PLLM_MISC_IDDQ);
2816 #endif
2817
2818         clk_writel(val, c->reg + PLL_MISC(c));
2819 }
2820
2821 static void tegra14_pllm_clk_init(struct clk *c)
2822 {
2823         unsigned long input_rate = clk_get_rate(c->parent);
2824         u32 m, p, val;
2825
2826         /* clip vco_min to exact multiple of input rate to avoid crossover
2827            by rounding */
2828         c->u.pll.vco_min =
2829                 DIV_ROUND_UP(c->u.pll.vco_min, input_rate) * input_rate;
2830         c->min_rate =
2831                 DIV_ROUND_UP(c->u.pll.vco_min, 2);
2832
2833         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2834         if (val & PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE) {
2835                 c->state = (val & PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE) ? ON : OFF;
2836                 val = pmc_readl(PMC_PLLM_WB0_OVERRIDE_2);
2837                 p = (val & PMC_PLLM_WB0_OVERRIDE_2_DIVP_MASK) ? 2 : 1;
2838
2839                 val = pmc_readl(PMC_PLLM_WB0_OVERRIDE);
2840         } else {
2841                 val = clk_readl(c->reg + PLL_BASE);
2842                 c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
2843                 p = (val & PLLM_BASE_DIVP_MASK) ? 2 : 1;
2844         }
2845
2846         m = (val & PLLM_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
2847         BUG_ON(m != PLL_FIXED_MDIV(c, input_rate));
2848         c->div = m * p;
2849         c->mul = (val & PLLM_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
2850
2851         pllm_set_defaults(c, input_rate);
2852 }
2853
2854 static int tegra14_pllm_clk_enable(struct clk *c)
2855 {
2856         u32 val;
2857         pr_debug("%s on clock %s\n", __func__, c->name);
2858
2859         pll_do_iddq(c, PLL_MISC(c), PLLM_MISC_IDDQ, false);
2860
2861         /* Just enable both base and override - one would work */
2862         val = clk_readl(c->reg + PLL_BASE);
2863         val |= PLL_BASE_ENABLE;
2864         clk_writel(val, c->reg + PLL_BASE);
2865
2866         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2867         val |= PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE;
2868         pmc_writel(val, PMC_PLLP_WB0_OVERRIDE);
2869         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2870
2871         tegra14_pll_clk_wait_for_lock(c, c->reg + PLL_BASE, PLL_BASE_LOCK);
2872         return 0;
2873 }
2874
2875 static void tegra14_pllm_clk_disable(struct clk *c)
2876 {
2877         u32 val;
2878         pr_debug("%s on clock %s\n", __func__, c->name);
2879
2880         /* Just disable both base and override - one would work */
2881         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2882         val &= ~PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE;
2883         pmc_writel(val, PMC_PLLP_WB0_OVERRIDE);
2884         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2885
2886         val = clk_readl(c->reg + PLL_BASE);
2887         val &= ~PLL_BASE_ENABLE;
2888         clk_writel(val, c->reg + PLL_BASE);
2889
2890         pll_do_iddq(c, PLL_MISC(c), PLLM_MISC_IDDQ, true);
2891 }
2892
2893 static int tegra14_pllm_clk_set_rate(struct clk *c, unsigned long rate)
2894 {
2895         u32 val, pdiv;
2896         unsigned long input_rate;
2897         struct clk_pll_freq_table cfg;
2898         const struct clk_pll_freq_table *sel = &cfg;
2899
2900         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
2901
2902         if (c->state == ON) {
2903                 if (rate != clk_get_rate_locked(c)) {
2904                         pr_err("%s: Can not change memory %s rate in flight\n",
2905                                __func__, c->name);
2906                         return -EINVAL;
2907                 }
2908                 return 0;
2909         }
2910
2911         input_rate = clk_get_rate(c->parent);
2912
2913         if (pll_dyn_ramp_find_cfg(c, &cfg, rate, input_rate, &pdiv))
2914                 return -EINVAL;
2915
2916         c->mul = sel->n;
2917         c->div = sel->m * sel->p;
2918
2919         val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
2920         if (val & PMC_PLLP_WB0_OVERRIDE_PLLM_OVERRIDE) {
2921                 val = pmc_readl(PMC_PLLM_WB0_OVERRIDE_2);
2922                 val = pdiv ? (val | PMC_PLLM_WB0_OVERRIDE_2_DIVP_MASK) :
2923                         (val & ~PMC_PLLM_WB0_OVERRIDE_2_DIVP_MASK);
2924                 pmc_writel(val, PMC_PLLM_WB0_OVERRIDE_2);
2925
2926                 val = pmc_readl(PMC_PLLM_WB0_OVERRIDE);
2927                 val &= ~(PLLM_BASE_DIVM_MASK | PLLM_BASE_DIVN_MASK);
2928                 val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
2929                         (sel->n << PLL_BASE_DIVN_SHIFT);
2930                 pmc_writel(val, PMC_PLLM_WB0_OVERRIDE);
2931         } else {
2932                 val = clk_readl(c->reg + PLL_BASE);
2933                 val &= ~(PLLM_BASE_DIVM_MASK | PLLM_BASE_DIVN_MASK |
2934                          PLLM_BASE_DIVP_MASK);
2935                 val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
2936                         (sel->n << PLL_BASE_DIVN_SHIFT) |
2937                         (pdiv ? PLLM_BASE_DIVP_MASK : 0);
2938                 clk_writel(val, c->reg + PLL_BASE);
2939         }
2940
2941         return 0;
2942 }
2943
2944 static struct clk_ops tegra_pllm_ops = {
2945         .init                   = tegra14_pllm_clk_init,
2946         .enable                 = tegra14_pllm_clk_enable,
2947         .disable                = tegra14_pllm_clk_disable,
2948         .set_rate               = tegra14_pllm_clk_set_rate,
2949 };
2950
2951 /*
2952  * Tegra14 includes dynamic frequency lock loop (DFLL) with automatic voltage
2953  * control as possible CPU clock source. It is included in the Tegra14 clock
2954  * tree as "complex PLL" with standard Tegra clock framework APIs. However,
2955  * DFLL locking logic h/w access APIs are separated in the tegra_cl_dvfs.c
2956  * module. Hence, DFLL operations, with the exception of initialization, are
2957  * basically cl-dvfs wrappers.
2958  */
2959
2960 #ifdef  CONFIG_ARCH_TEGRA_HAS_CL_DVFS
2961 /* DFLL operations */
2962 static void __init tegra14_dfll_cpu_late_init(struct clk *c)
2963 {
2964 #ifdef CONFIG_ARCH_TEGRA_HAS_CL_DVFS
2965         int ret;
2966         struct clk *cpu = tegra_get_clock_by_name("cpu");
2967
2968 #ifdef CONFIG_TEGRA_FPGA_PLATFORM
2969         u32 netlist, patchid;
2970         tegra_get_netlist_revision(&netlist, &patchid);
2971         if (netlist < 12) {
2972                 pr_err("%s: CL-DVFS is not available on net %d\n",
2973                        __func__, netlist);
2974                 return;
2975         }
2976 #endif
2977         /* release dfll clock source reset, init cl_dvfs control logic, and
2978            move dfll to initialized state, so it can be used as CPU source */
2979         tegra_periph_reset_deassert(c);
2980         ret = tegra_init_cl_dvfs();
2981         if (!ret) {
2982                 c->state = OFF;
2983                 c->u.dfll.cl_dvfs = platform_get_drvdata(&tegra_cl_dvfs_device);
2984
2985                 use_dfll = CONFIG_TEGRA_USE_DFLL_RANGE;
2986                 tegra_dvfs_set_dfll_range(cpu->parent->dvfs, use_dfll);
2987                 pr_info("Tegra CPU DFLL is initialized\n");
2988         }
2989 #endif
2990 }
2991 #endif
2992
2993 static int tegra14_dfll_clk_enable(struct clk *c)
2994 {
2995         return tegra_cl_dvfs_enable(c->u.dfll.cl_dvfs);
2996 }
2997
2998 static void tegra14_dfll_clk_disable(struct clk *c)
2999 {
3000         tegra_cl_dvfs_disable(c->u.dfll.cl_dvfs);
3001 }
3002
3003 static int tegra14_dfll_clk_set_rate(struct clk *c, unsigned long rate)
3004 {
3005         int ret = tegra_cl_dvfs_request_rate(c->u.dfll.cl_dvfs, rate);
3006
3007         if (!ret)
3008                 c->rate = tegra_cl_dvfs_request_get(c->u.dfll.cl_dvfs);
3009
3010         return ret;
3011 }
3012
3013 static void tegra14_dfll_clk_reset(struct clk *c, bool assert)
3014 {
3015         u32 val = assert ? DFLL_BASE_RESET : 0;
3016         clk_writel_delay(val, c->reg);
3017 }
3018
3019 static int
3020 tegra14_dfll_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
3021 {
3022         if (p == TEGRA_CLK_DFLL_LOCK)
3023                 return setting ? tegra_cl_dvfs_lock(c->u.dfll.cl_dvfs) :
3024                                  tegra_cl_dvfs_unlock(c->u.dfll.cl_dvfs);
3025         return -EINVAL;
3026 }
3027
3028 #ifdef CONFIG_PM_SLEEP
3029 static void tegra14_dfll_clk_resume(struct clk *c)
3030 {
3031         if (!(clk_readl(c->reg) & DFLL_BASE_RESET))
3032                 return;         /* already resumed */
3033
3034         if (c->state != UNINITIALIZED) {
3035                 tegra_periph_reset_deassert(c);
3036                 tegra_cl_dvfs_resume(c->u.dfll.cl_dvfs);
3037         }
3038 }
3039 #endif
3040
3041 static struct clk_ops tegra_dfll_ops = {
3042         .enable                 = tegra14_dfll_clk_enable,
3043         .disable                = tegra14_dfll_clk_disable,
3044         .set_rate               = tegra14_dfll_clk_set_rate,
3045         .reset                  = tegra14_dfll_clk_reset,
3046         .clk_cfg_ex             = tegra14_dfll_clk_cfg_ex,
3047 };
3048
3049 /* DFLL sysfs interface */
3050 static int tegra14_use_dfll_cb(const char *arg, const struct kernel_param *kp)
3051 {
3052         int ret = 0;
3053         unsigned long c_flags, p_flags;
3054         unsigned int old_use_dfll;
3055         struct clk *c = tegra_get_clock_by_name("cpu");
3056
3057         if (!c->parent || !c->parent->dvfs)
3058                 return -ENOSYS;
3059
3060         clk_lock_save(c, &c_flags);
3061         if (c->parent->u.cpu.mode == MODE_LP) {
3062                 pr_err("%s: DFLL is not used on LP CPU\n", __func__);
3063                 clk_unlock_restore(c, &c_flags);
3064                 return -ENOSYS;
3065         }
3066
3067         clk_lock_save(c->parent, &p_flags);
3068         old_use_dfll = use_dfll;
3069         param_set_int(arg, kp);
3070
3071         if (use_dfll != old_use_dfll) {
3072                 ret = tegra_dvfs_set_dfll_range(c->parent->dvfs, use_dfll);
3073                 if (ret) {
3074                         use_dfll = old_use_dfll;
3075                 } else {
3076                         ret = clk_set_rate_locked(c->parent,
3077                                 clk_get_rate_locked(c->parent));
3078                         if (ret) {
3079                                 use_dfll = old_use_dfll;
3080                                 tegra_dvfs_set_dfll_range(
3081                                         c->parent->dvfs, use_dfll);
3082                         }
3083                 }
3084         }
3085         clk_unlock_restore(c->parent, &p_flags);
3086         clk_unlock_restore(c, &c_flags);
3087         tegra_recalculate_cpu_edp_limits();
3088         return ret;
3089 }
3090
3091 static struct kernel_param_ops tegra14_use_dfll_ops = {
3092         .set = tegra14_use_dfll_cb,
3093         .get = param_get_int,
3094 };
3095 module_param_cb(use_dfll, &tegra14_use_dfll_ops, &use_dfll, 0644);
3096
3097
3098 /* Clock divider ops (non-atomic shared register access) */
3099 static DEFINE_SPINLOCK(pll_div_lock);
3100
3101 static int tegra14_pll_div_clk_set_rate(struct clk *c, unsigned long rate);
3102 static void tegra14_pll_div_clk_init(struct clk *c)
3103 {
3104         if (c->flags & DIV_U71) {
3105                 u32 divu71;
3106                 u32 val = clk_readl(c->reg);
3107                 val >>= c->reg_shift;
3108                 c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
3109                 if (!(val & PLL_OUT_RESET_DISABLE))
3110                         c->state = OFF;
3111
3112                 if (c->u.pll_div.default_rate) {
3113                         int ret = tegra14_pll_div_clk_set_rate(
3114                                         c, c->u.pll_div.default_rate);
3115                         if (!ret)
3116                                 return;
3117                 }
3118                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
3119                 c->div = (divu71 + 2);
3120                 c->mul = 2;
3121         } else if (c->flags & DIV_2) {
3122                 c->state = ON;
3123                 if (c->flags & (PLLD | PLLX)) {
3124                         c->div = 2;
3125                         c->mul = 1;
3126                 } else
3127                         BUG();
3128         } else if (c->flags & PLLU) {
3129                 u32 val = clk_readl(c->reg);
3130                 c->state = val & (0x1 << c->reg_shift) ? ON : OFF;
3131         } else {
3132                 c->state = ON;
3133                 c->div = 1;
3134                 c->mul = 1;
3135         }
3136 }
3137
3138 static int tegra14_pll_div_clk_enable(struct clk *c)
3139 {
3140         u32 val;
3141         u32 new_val;
3142         unsigned long flags;
3143
3144         pr_debug("%s: %s\n", __func__, c->name);
3145         if (c->flags & DIV_U71) {
3146                 spin_lock_irqsave(&pll_div_lock, flags);
3147                 val = clk_readl(c->reg);
3148                 new_val = val >> c->reg_shift;
3149                 new_val &= 0xFFFF;
3150
3151                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
3152
3153                 val &= ~(0xFFFF << c->reg_shift);
3154                 val |= new_val << c->reg_shift;
3155                 clk_writel_delay(val, c->reg);
3156                 spin_unlock_irqrestore(&pll_div_lock, flags);
3157                 return 0;
3158         } else if (c->flags & DIV_2) {
3159                 return 0;
3160         } else if (c->flags & PLLU) {
3161                 clk_lock_save(c->parent, &flags);
3162                 val = clk_readl(c->reg) | (0x1 << c->reg_shift);
3163                 clk_writel_delay(val, c->reg);
3164                 clk_unlock_restore(c->parent, &flags);
3165                 return 0;
3166         }
3167         return -EINVAL;
3168 }
3169
3170 static void tegra14_pll_div_clk_disable(struct clk *c)
3171 {
3172         u32 val;
3173         u32 new_val;
3174         unsigned long flags;
3175
3176         pr_debug("%s: %s\n", __func__, c->name);
3177         if (c->flags & DIV_U71) {
3178                 spin_lock_irqsave(&pll_div_lock, flags);
3179                 val = clk_readl(c->reg);
3180                 new_val = val >> c->reg_shift;
3181                 new_val &= 0xFFFF;
3182
3183                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
3184
3185                 val &= ~(0xFFFF << c->reg_shift);
3186                 val |= new_val << c->reg_shift;
3187                 clk_writel_delay(val, c->reg);
3188                 spin_unlock_irqrestore(&pll_div_lock, flags);
3189         } else if (c->flags & PLLU) {
3190                 clk_lock_save(c->parent, &flags);
3191                 val = clk_readl(c->reg) & (~(0x1 << c->reg_shift));
3192                 clk_writel_delay(val, c->reg);
3193                 clk_unlock_restore(c->parent, &flags);
3194         }
3195 }
3196
3197 static int tegra14_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
3198 {
3199         u32 val;
3200         u32 new_val;
3201         int divider_u71;
3202         unsigned long parent_rate = clk_get_rate(c->parent);
3203         unsigned long flags;
3204
3205         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3206         if (c->flags & DIV_U71) {
3207                 divider_u71 = clk_div71_get_divider(
3208                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3209                 if (divider_u71 >= 0) {
3210                         spin_lock_irqsave(&pll_div_lock, flags);
3211                         val = clk_readl(c->reg);
3212                         new_val = val >> c->reg_shift;
3213                         new_val &= 0xFFFF;
3214                         if (c->flags & DIV_U71_FIXED)
3215                                 new_val |= PLL_OUT_OVERRIDE;
3216                         new_val &= ~PLL_OUT_RATIO_MASK;
3217                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
3218
3219                         val &= ~(0xFFFF << c->reg_shift);
3220                         val |= new_val << c->reg_shift;
3221                         clk_writel_delay(val, c->reg);
3222                         c->div = divider_u71 + 2;
3223                         c->mul = 2;
3224                         spin_unlock_irqrestore(&pll_div_lock, flags);
3225                         return 0;
3226                 }
3227         } else if (c->flags & DIV_2)
3228                 return clk_set_rate(c->parent, rate * 2);
3229
3230         return -EINVAL;
3231 }
3232
3233 static long tegra14_pll_div_clk_round_rate(struct clk *c, unsigned long rate)
3234 {
3235         int divider;
3236         unsigned long parent_rate = clk_get_rate(c->parent);
3237         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3238
3239         if (c->flags & DIV_U71) {
3240                 divider = clk_div71_get_divider(
3241                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3242                 if (divider < 0)
3243                         return divider;
3244                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
3245         } else if (c->flags & DIV_2)
3246                 /* no rounding - fixed DIV_2 dividers pass rate to parent PLL */
3247                 return rate;
3248
3249         return -EINVAL;
3250 }
3251
3252 static struct clk_ops tegra_pll_div_ops = {
3253         .init                   = tegra14_pll_div_clk_init,
3254         .enable                 = tegra14_pll_div_clk_enable,
3255         .disable                = tegra14_pll_div_clk_disable,
3256         .set_rate               = tegra14_pll_div_clk_set_rate,
3257         .round_rate             = tegra14_pll_div_clk_round_rate,
3258 };
3259
3260 /* Periph clk ops */
3261 static inline u32 periph_clk_source_mask(struct clk *c)
3262 {
3263         if (c->u.periph.src_mask)
3264                 return c->u.periph.src_mask;
3265         else if (c->flags & MUX8)
3266                 return 7 << 29;
3267         else if (c->flags & MUX_PWM)
3268                 return 3 << 28;
3269         else if (c->flags & MUX_CLK_OUT)
3270                 return 3 << (c->u.periph.clk_num + 4);
3271         else if (c->flags & PLLD)
3272                 return PLLD_BASE_DSI_MUX_MASK;
3273         else
3274                 return 3 << 30;
3275 }
3276
3277 static inline u32 periph_clk_source_shift(struct clk *c)
3278 {
3279         if (c->u.periph.src_shift)
3280                 return c->u.periph.src_shift;
3281         else if (c->flags & MUX8)
3282                 return 29;
3283         else if (c->flags & MUX_PWM)
3284                 return 28;
3285         else if (c->flags & MUX_CLK_OUT)
3286                 return c->u.periph.clk_num + 4;
3287         else if (c->flags & PLLD)
3288                 return PLLD_BASE_DSI_MUX_SHIFT;
3289         else
3290                 return 30;
3291 }
3292
3293 static void tegra14_periph_clk_init(struct clk *c)
3294 {
3295         u32 val = clk_readl(c->reg);
3296         const struct clk_mux_sel *mux = 0;
3297         const struct clk_mux_sel *sel;
3298         if (c->flags & MUX) {
3299                 for (sel = c->inputs; sel->input != NULL; sel++) {
3300                         if (((val & periph_clk_source_mask(c)) >>
3301                             periph_clk_source_shift(c)) == sel->value)
3302                                 mux = sel;
3303                 }
3304                 BUG_ON(!mux);
3305
3306                 c->parent = mux->input;
3307         } else {
3308                 c->parent = c->inputs[0].input;
3309         }
3310
3311         if (c->flags & DIV_U71) {
3312                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
3313                 if (c->flags & DIV_U71_IDLE) {
3314                         val &= ~(PERIPH_CLK_SOURCE_DIVU71_MASK <<
3315                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
3316                         val |= (PERIPH_CLK_SOURCE_DIVIDLE_VAL <<
3317                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
3318                         clk_writel(val, c->reg);
3319                 }
3320                 c->div = divu71 + 2;
3321                 c->mul = 2;
3322         } else if (c->flags & DIV_U151) {
3323                 u32 divu151 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
3324                 if ((c->flags & DIV_U151_UART) &&
3325                     (!(val & PERIPH_CLK_UART_DIV_ENB))) {
3326                         divu151 = 0;
3327                 }
3328                 c->div = divu151 + 2;
3329                 c->mul = 2;
3330         } else if (c->flags & DIV_U16) {
3331                 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
3332                 c->div = divu16 + 1;
3333                 c->mul = 1;
3334         } else {
3335                 c->div = 1;
3336                 c->mul = 1;
3337         }
3338
3339         if (c->flags & PERIPH_NO_ENB) {
3340                 c->state = c->parent->state;
3341                 return;
3342         }
3343
3344         c->state = ON;
3345
3346         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
3347                 c->state = OFF;
3348         if (!(c->flags & PERIPH_NO_RESET))
3349                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c))
3350                         c->state = OFF;
3351 }
3352
3353 static int tegra14_periph_clk_enable(struct clk *c)
3354 {
3355         unsigned long flags;
3356         pr_debug("%s on clock %s\n", __func__, c->name);
3357
3358         if (c->flags & PERIPH_NO_ENB)
3359                 return 0;
3360
3361         spin_lock_irqsave(&periph_refcount_lock, flags);
3362
3363         tegra_periph_clk_enable_refcount[c->u.periph.clk_num]++;
3364         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] > 1) {
3365                 spin_unlock_irqrestore(&periph_refcount_lock, flags);
3366                 return 0;
3367         }
3368
3369         clk_writel_delay(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_SET_REG(c));
3370         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET)) {
3371                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c)) {
3372                         udelay(5);      /* reset propagation delay */
3373                         clk_writel(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_RST_CLR_REG(c));
3374                 }
3375         }
3376         spin_unlock_irqrestore(&periph_refcount_lock, flags);
3377         return 0;
3378 }
3379
3380 static void tegra14_periph_clk_disable(struct clk *c)
3381 {
3382         unsigned long val, flags;
3383         pr_debug("%s on clock %s\n", __func__, c->name);
3384
3385         if (c->flags & PERIPH_NO_ENB)
3386                 return;
3387
3388         spin_lock_irqsave(&periph_refcount_lock, flags);
3389
3390         if (c->refcnt)
3391                 tegra_periph_clk_enable_refcount[c->u.periph.clk_num]--;
3392
3393         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] == 0) {
3394                 /* If peripheral is in the APB bus then read the APB bus to
3395                  * flush the write operation in apb bus. This will avoid the
3396                  * peripheral access after disabling clock*/
3397                 if (c->flags & PERIPH_ON_APB)
3398                         val = chipid_readl();
3399
3400                 clk_writel_delay(
3401                         PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_CLR_REG(c));
3402         }
3403         spin_unlock_irqrestore(&periph_refcount_lock, flags);
3404 }
3405
3406 static void tegra14_periph_clk_reset(struct clk *c, bool assert)
3407 {
3408         unsigned long val;
3409         pr_debug("%s %s on clock %s\n", __func__,
3410                  assert ? "assert" : "deassert", c->name);
3411
3412         if (c->flags & PERIPH_NO_ENB)
3413                 return;
3414
3415         if (!(c->flags & PERIPH_NO_RESET)) {
3416                 if (assert) {
3417                         /* If peripheral is in the APB bus then read the APB
3418                          * bus to flush the write operation in apb bus. This
3419                          * will avoid the peripheral access after disabling
3420                          * clock */
3421                         if (c->flags & PERIPH_ON_APB)
3422                                 val = chipid_readl();
3423
3424                         clk_writel(PERIPH_CLK_TO_BIT(c),
3425                                    PERIPH_CLK_TO_RST_SET_REG(c));
3426                 } else
3427                         clk_writel(PERIPH_CLK_TO_BIT(c),
3428                                    PERIPH_CLK_TO_RST_CLR_REG(c));
3429         }
3430 }
3431
3432 static int tegra14_periph_clk_set_parent(struct clk *c, struct clk *p)
3433 {
3434         u32 val;
3435         const struct clk_mux_sel *sel;
3436         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
3437
3438         if (!(c->flags & MUX))
3439                 return (p == c->parent) ? 0 : (-EINVAL);
3440
3441         for (sel = c->inputs; sel->input != NULL; sel++) {
3442                 if (sel->input == p) {
3443                         val = clk_readl(c->reg);
3444                         val &= ~periph_clk_source_mask(c);
3445                         val |= (sel->value << periph_clk_source_shift(c));
3446
3447                         if (c->refcnt)
3448                                 clk_enable(p);
3449
3450                         clk_writel_delay(val, c->reg);
3451
3452                         if (c->refcnt && c->parent)
3453                                 clk_disable(c->parent);
3454
3455                         clk_reparent(c, p);
3456                         return 0;
3457                 }
3458         }
3459
3460         return -EINVAL;
3461 }
3462
3463 static int tegra14_periph_clk_set_rate(struct clk *c, unsigned long rate)
3464 {
3465         u32 val;
3466         int divider;
3467         unsigned long parent_rate = clk_get_rate(c->parent);
3468
3469         if (c->flags & DIV_U71) {
3470                 divider = clk_div71_get_divider(
3471                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3472                 if (divider >= 0) {
3473                         val = clk_readl(c->reg);
3474                         val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
3475                         val |= divider;
3476                         clk_writel_delay(val, c->reg);
3477                         c->div = divider + 2;
3478                         c->mul = 2;
3479                         return 0;
3480                 }
3481         } else if (c->flags & DIV_U151) {
3482                 divider = clk_div151_get_divider(
3483                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3484                 if (divider >= 0) {
3485                         val = clk_readl(c->reg);
3486                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
3487                         val |= divider;
3488                         if (c->flags & DIV_U151_UART) {
3489                                 if (divider)
3490                                         val |= PERIPH_CLK_UART_DIV_ENB;
3491                                 else
3492                                         val &= ~PERIPH_CLK_UART_DIV_ENB;
3493                         }
3494                         clk_writel_delay(val, c->reg);
3495                         c->div = divider + 2;
3496                         c->mul = 2;
3497                         return 0;
3498                 }
3499         } else if (c->flags & DIV_U16) {
3500                 divider = clk_div16_get_divider(parent_rate, rate);
3501                 if (divider >= 0) {
3502                         val = clk_readl(c->reg);
3503                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
3504                         val |= divider;
3505                         clk_writel_delay(val, c->reg);
3506                         c->div = divider + 1;
3507                         c->mul = 1;
3508                         return 0;
3509                 }
3510         } else if (parent_rate <= rate) {
3511                 c->div = 1;
3512                 c->mul = 1;
3513                 return 0;
3514         }
3515         return -EINVAL;
3516 }
3517
3518 static long tegra14_periph_clk_round_rate(struct clk *c,
3519         unsigned long rate)
3520 {
3521         int divider;
3522         unsigned long parent_rate = clk_get_rate(c->parent);
3523         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
3524
3525         if (c->flags & DIV_U71) {
3526                 divider = clk_div71_get_divider(
3527                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3528                 if (divider < 0)
3529                         return divider;
3530
3531                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
3532         } else if (c->flags & DIV_U151) {
3533                 divider = clk_div151_get_divider(
3534                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
3535                 if (divider < 0)
3536                         return divider;
3537
3538                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
3539         } else if (c->flags & DIV_U16) {
3540                 divider = clk_div16_get_divider(parent_rate, rate);
3541                 if (divider < 0)
3542                         return divider;
3543                 return DIV_ROUND_UP(parent_rate, divider + 1);
3544         }
3545         return -EINVAL;
3546 }
3547
3548 static struct clk_ops tegra_periph_clk_ops = {
3549         .init                   = &tegra14_periph_clk_init,
3550         .enable                 = &tegra14_periph_clk_enable,
3551         .disable                = &tegra14_periph_clk_disable,
3552         .set_parent             = &tegra14_periph_clk_set_parent,
3553         .set_rate               = &tegra14_periph_clk_set_rate,
3554         .round_rate             = &tegra14_periph_clk_round_rate,
3555         .reset                  = &tegra14_periph_clk_reset,
3556 };
3557
3558 /* Periph extended clock configuration ops */
3559 static int
3560 tegra14_vi_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
3561 {
3562         if (p == TEGRA_CLK_VI_INP_SEL) {
3563                 u32 val = clk_readl(c->reg);
3564                 val &= ~PERIPH_CLK_VI_SEL_EX_MASK;
3565                 val |= (setting << PERIPH_CLK_VI_SEL_EX_SHIFT) &
3566                         PERIPH_CLK_VI_SEL_EX_MASK;
3567                 clk_writel(val, c->reg);
3568                 return 0;
3569         }
3570         return -EINVAL;
3571 }
3572
3573 static struct clk_ops tegra_vi_clk_ops = {
3574         .init                   = &tegra14_periph_clk_init,
3575         .enable                 = &tegra14_periph_clk_enable,
3576         .disable                = &tegra14_periph_clk_disable,
3577         .set_parent             = &tegra14_periph_clk_set_parent,
3578         .set_rate               = &tegra14_periph_clk_set_rate,
3579         .round_rate             = &tegra14_periph_clk_round_rate,
3580         .clk_cfg_ex             = &tegra14_vi_clk_cfg_ex,
3581         .reset                  = &tegra14_periph_clk_reset,
3582 };
3583
3584 static int
3585 tegra14_dtv_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
3586 {
3587         if (p == TEGRA_CLK_DTV_INVERT) {
3588                 u32 val = clk_readl(c->reg);
3589                 if (setting)
3590                         val |= PERIPH_CLK_DTV_POLARITY_INV;
3591                 else
3592                         val &= ~PERIPH_CLK_DTV_POLARITY_INV;
3593                 clk_writel(val, c->reg);
3594                 return 0;
3595         }
3596         return -EINVAL;
3597 }
3598
3599 static struct clk_ops tegra_dtv_clk_ops = {
3600         .init                   = &tegra14_periph_clk_init,
3601         .enable                 = &tegra14_periph_clk_enable,
3602         .disable                = &tegra14_periph_clk_disable,
3603         .set_parent             = &tegra14_periph_clk_set_parent,
3604         .set_rate               = &tegra14_periph_clk_set_rate,
3605         .round_rate             = &tegra14_periph_clk_round_rate,
3606         .clk_cfg_ex             = &tegra14_dtv_clk_cfg_ex,
3607         .reset                  = &tegra14_periph_clk_reset,
3608 };
3609
3610 static int tegra14_dsi_clk_set_parent(struct clk *c, struct clk *p)
3611 {
3612         const struct clk_mux_sel *sel;
3613         struct clk *d = tegra_get_clock_by_name("pll_d");
3614         if (c->reg != d->reg)
3615                 d = tegra_get_clock_by_name("pll_d2");
3616
3617         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
3618
3619         for (sel = c->inputs; sel->input != NULL; sel++) {
3620                 if (sel->input == p) {
3621                         if (c->refcnt)
3622                                 clk_enable(p);
3623
3624                         /* The DSI parent selection bit is in PLLD base
3625                            register - can not do direct r-m-w, must be
3626                            protected by PLLD lock */
3627                         tegra_clk_cfg_ex(
3628                                 d, TEGRA_CLK_PLLD_MIPI_MUX_SEL, sel->value);
3629
3630                         if (c->refcnt && c->parent)
3631                                 clk_disable(c->parent);
3632
3633                         clk_reparent(c, p);
3634                         return 0;
3635                 }
3636         }
3637
3638         return -EINVAL;
3639 }
3640
3641 static struct clk_ops tegra_dsi_clk_ops = {
3642         .init                   = &tegra14_periph_clk_init,
3643         .enable                 = &tegra14_periph_clk_enable,
3644         .disable                = &tegra14_periph_clk_disable,
3645         .set_parent             = &tegra14_dsi_clk_set_parent,
3646         .set_rate               = &tegra14_periph_clk_set_rate,
3647         .round_rate             = &tegra14_periph_clk_round_rate,
3648         .reset                  = &tegra14_periph_clk_reset,
3649 };
3650
3651 /* Output clock ops */
3652
3653 static DEFINE_SPINLOCK(clk_out_lock);
3654
3655 static void tegra14_clk_out_init(struct clk *c)
3656 {
3657         const struct clk_mux_sel *mux = 0;
3658         const struct clk_mux_sel *sel;
3659         u32 val = pmc_readl(c->reg);
3660
3661         c->state = (val & (0x1 << c->u.periph.clk_num)) ? ON : OFF;
3662         c->mul = 1;
3663         c->div = 1;
3664
3665         for (sel = c->inputs; sel->input != NULL; sel++) {
3666                 if (((val & periph_clk_source_mask(c)) >>
3667                      periph_clk_source_shift(c)) == sel->value)
3668                         mux = sel;
3669         }
3670         BUG_ON(!mux);
3671         c->parent = mux->input;
3672 }
3673
3674 static int tegra14_clk_out_enable(struct clk *c)
3675 {
3676         u32 val;
3677         unsigned long flags;
3678
3679         pr_debug("%s on clock %s\n", __func__, c->name);
3680
3681         spin_lock_irqsave(&clk_out_lock, flags);
3682         val = pmc_readl(c->reg);
3683         val |= (0x1 << c->u.periph.clk_num);
3684         pmc_writel(val, c->reg);
3685         spin_unlock_irqrestore(&clk_out_lock, flags);
3686
3687         return 0;
3688 }
3689
3690 static void tegra14_clk_out_disable(struct clk *c)
3691 {
3692         u32 val;
3693         unsigned long flags;
3694
3695         pr_debug("%s on clock %s\n", __func__, c->name);
3696
3697         spin_lock_irqsave(&clk_out_lock, flags);
3698         val = pmc_readl(c->reg);
3699         val &= ~(0x1 << c->u.periph.clk_num);
3700         pmc_writel(val, c->reg);
3701         spin_unlock_irqrestore(&clk_out_lock, flags);
3702 }
3703
3704 static int tegra14_clk_out_set_parent(struct clk *c, struct clk *p)
3705 {
3706         u32 val;
3707         unsigned long flags;
3708         const struct clk_mux_sel *sel;
3709
3710         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
3711
3712         for (sel = c->inputs; sel->input != NULL; sel++) {
3713                 if (sel->input == p) {
3714                         if (c->refcnt)
3715                                 clk_enable(p);
3716
3717                         spin_lock_irqsave(&clk_out_lock, flags);
3718                         val = pmc_readl(c->reg);
3719                         val &= ~periph_clk_source_mask(c);
3720                         val |= (sel->value << periph_clk_source_shift(c));
3721                         pmc_writel(val, c->reg);
3722                         spin_unlock_irqrestore(&clk_out_lock, flags);
3723
3724                         if (c->refcnt && c->parent)
3725                                 clk_disable(c->parent);
3726
3727                         clk_reparent(c, p);
3728                         return 0;
3729                 }
3730         }
3731         return -EINVAL;
3732 }
3733
3734 static struct clk_ops tegra_clk_out_ops = {
3735         .init                   = &tegra14_clk_out_init,
3736         .enable                 = &tegra14_clk_out_enable,
3737         .disable                = &tegra14_clk_out_disable,
3738         .set_parent             = &tegra14_clk_out_set_parent,
3739 };
3740
3741
3742 /* External memory controller clock ops */
3743 static void tegra14_emc_clk_init(struct clk *c)
3744 {
3745         tegra14_periph_clk_init(c);
3746         tegra_emc_dram_type_init(c);
3747 }
3748
3749 static long tegra14_emc_clk_round_updown(struct clk *c, unsigned long rate,
3750                                          bool up)
3751 {
3752         long new_rate = max(rate, c->min_rate);
3753
3754         /* FIXME: emc updown rounding */
3755         new_rate = tegra_emc_round_rate(new_rate);
3756         if (new_rate < 0)
3757                 new_rate = c->max_rate;
3758
3759         return new_rate;
3760 }
3761
3762 static long tegra14_emc_clk_round_rate(struct clk *c, unsigned long rate)
3763 {
3764         return tegra14_emc_clk_round_updown(c, rate, true);
3765 }
3766
3767 static int tegra14_emc_clk_set_rate(struct clk *c, unsigned long rate)
3768 {
3769         int ret;
3770         u32 div_value;
3771         struct clk *p;
3772
3773         /* The tegra14x memory controller has an interlock with the clock
3774          * block that allows memory shadowed registers to be updated,
3775          * and then transfer them to the main registers at the same
3776          * time as the clock update without glitches. During clock change
3777          * operation both clock parent and divider may change simultaneously
3778          * to achieve requested rate. */
3779         p = tegra_emc_predict_parent(rate, &div_value);
3780         div_value += 2;         /* emc has fractional DIV_U71 divider */
3781         if (IS_ERR_OR_NULL(p)) {
3782                 pr_err("%s: Failed to predict emc parent for rate %lu\n",
3783                        __func__, rate);
3784                 return -EINVAL;
3785         }
3786
3787         if (p == c->parent) {
3788                 if (div_value == c->div)
3789                         return 0;
3790         } else if (c->refcnt)
3791                 clk_enable(p);
3792
3793         ret = tegra_emc_set_rate(rate);
3794         if (ret < 0)
3795                 return ret;
3796
3797         if (p != c->parent) {
3798                 if (c->refcnt && c->parent)
3799                         clk_disable(c->parent);
3800                 clk_reparent(c, p);
3801         }
3802         c->div = div_value;
3803         c->mul = 2;
3804         return 0;
3805 }
3806
3807 static int tegra14_clk_emc_bus_update(struct clk *bus)
3808 {
3809         struct clk *p = NULL;
3810         unsigned long rate, old_rate, parent_rate, backup_rate;
3811
3812         if (detach_shared_bus)
3813                 return 0;
3814
3815         rate = tegra14_clk_shared_bus_update(bus, NULL, NULL, NULL);
3816
3817         old_rate = clk_get_rate_locked(bus);
3818         if (rate == old_rate)
3819                 return 0;
3820
3821         if (!tegra_emc_is_parent_ready(rate, &p, &parent_rate, &backup_rate)) {
3822                 if (bus->parent == p) {
3823                         /* need backup to re-lock current parent */
3824                         int ret;
3825                         if (IS_ERR_VALUE(backup_rate)) {
3826                                 pr_err("%s: No backup for %s rate %lu\n",
3827                                        __func__, bus->name, rate);
3828                                 return -EINVAL;
3829                         }
3830
3831                         if (backup_rate < old_rate) /* skip lowering voltage */
3832                                 bus->auto_dvfs = false;
3833                         ret = clk_set_rate_locked(bus, backup_rate);
3834                         bus->auto_dvfs = true;
3835                         if (ret) {
3836                                 pr_err("%s: Failed to backup %s for rate %lu\n",
3837                                        __func__, bus->name, rate);
3838                                 return -EINVAL;
3839                         }
3840                 }
3841                 if (p->refcnt) {
3842                         pr_err("%s: %s has other than emc child\n",
3843                                __func__, p->name);
3844                         return -EINVAL;
3845                 }
3846
3847                 if (clk_set_rate(p, parent_rate)) {
3848                         pr_err("%s: Failed to set %s rate %lu\n",
3849                                __func__, p->name, parent_rate);
3850                         return -EINVAL;
3851                 }
3852         }
3853
3854         return clk_set_rate_locked(bus, rate);
3855 }
3856
3857 static struct clk_ops tegra_emc_clk_ops = {
3858         .init                   = &tegra14_emc_clk_init,
3859         .enable                 = &tegra14_periph_clk_enable,
3860         .disable                = &tegra14_periph_clk_disable,
3861         .set_rate               = &tegra14_emc_clk_set_rate,
3862         .round_rate             = &tegra14_emc_clk_round_rate,
3863         .round_rate_updown      = &tegra14_emc_clk_round_updown,
3864         .reset                  = &tegra14_periph_clk_reset,
3865         .shared_bus_update      = &tegra14_clk_emc_bus_update,
3866 };
3867
3868 /* Clock doubler ops (non-atomic shared register access) */
3869 static DEFINE_SPINLOCK(doubler_lock);
3870
3871 static void tegra14_clk_double_init(struct clk *c)
3872 {
3873         u32 val = clk_readl(c->reg);
3874         c->mul = val & (0x1 << c->reg_shift) ? 1 : 2;
3875         c->div = 1;
3876         c->state = ON;
3877         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
3878                 c->state = OFF;
3879 };
3880
3881 static int tegra14_clk_double_set_rate(struct clk *c, unsigned long rate)
3882 {
3883         u32 val;
3884         unsigned long parent_rate = clk_get_rate(c->parent);
3885         unsigned long flags;
3886
3887         if (rate == parent_rate) {
3888                 spin_lock_irqsave(&doubler_lock, flags);
3889                 val = clk_readl(c->reg) | (0x1 << c->reg_shift);
3890                 clk_writel(val, c->reg);
3891                 c->mul = 1;
3892                 c->div = 1;
3893                 spin_unlock_irqrestore(&doubler_lock, flags);
3894                 return 0;
3895         } else if (rate == 2 * parent_rate) {
3896                 spin_lock_irqsave(&doubler_lock, flags);
3897                 val = clk_readl(c->reg) & (~(0x1 << c->reg_shift));
3898                 clk_writel(val, c->reg);
3899                 c->mul = 2;
3900                 c->div = 1;
3901                 spin_unlock_irqrestore(&doubler_lock, flags);
3902                 return 0;
3903         }
3904         return -EINVAL;
3905 }
3906
3907 static struct clk_ops tegra_clk_double_ops = {
3908         .init                   = &tegra14_clk_double_init,
3909         .enable                 = &tegra14_periph_clk_enable,
3910         .disable                = &tegra14_periph_clk_disable,
3911         .set_rate               = &tegra14_clk_double_set_rate,
3912 };
3913
3914 /* Audio sync clock ops */
3915 static int tegra14_sync_source_set_rate(struct clk *c, unsigned long rate)
3916 {
3917         c->rate = rate;
3918         return 0;
3919 }
3920
3921 static struct clk_ops tegra_sync_source_ops = {
3922         .set_rate               = &tegra14_sync_source_set_rate,
3923 };
3924
3925 static void tegra14_audio_sync_clk_init(struct clk *c)
3926 {
3927         int source;
3928         const struct clk_mux_sel *sel;
3929         u32 val = clk_readl(c->reg);
3930         c->state = (val & AUDIO_SYNC_DISABLE_BIT) ? OFF : ON;
3931         source = val & AUDIO_SYNC_SOURCE_MASK;
3932         for (sel = c->inputs; sel->input != NULL; sel++)
3933                 if (sel->value == source)
3934                         break;
3935         BUG_ON(sel->input == NULL);
3936         c->parent = sel->input;
3937 }
3938
3939 static int tegra14_audio_sync_clk_enable(struct clk *c)
3940 {
3941         u32 val = clk_readl(c->reg);
3942         clk_writel((val & (~AUDIO_SYNC_DISABLE_BIT)), c->reg);
3943         return 0;
3944 }
3945
3946 static void tegra14_audio_sync_clk_disable(struct clk *c)
3947 {
3948         u32 val = clk_readl(c->reg);
3949         clk_writel((val | AUDIO_SYNC_DISABLE_BIT), c->reg);
3950 }
3951
3952 static int tegra14_audio_sync_clk_set_parent(struct clk *c, struct clk *p)
3953 {
3954         u32 val;
3955         const struct clk_mux_sel *sel;
3956         for (sel = c->inputs; sel->input != NULL; sel++) {
3957                 if (sel->input == p) {
3958                         val = clk_readl(c->reg);
3959                         val &= ~AUDIO_SYNC_SOURCE_MASK;
3960                         val |= sel->value;
3961
3962                         if (c->refcnt)
3963                                 clk_enable(p);
3964
3965                         clk_writel(val, c->reg);
3966
3967                         if (c->refcnt && c->parent)
3968                                 clk_disable(c->parent);
3969
3970                         clk_reparent(c, p);
3971                         return 0;
3972                 }
3973         }
3974
3975         return -EINVAL;
3976 }
3977
3978 static struct clk_ops tegra_audio_sync_clk_ops = {
3979         .init       = tegra14_audio_sync_clk_init,
3980         .enable     = tegra14_audio_sync_clk_enable,
3981         .disable    = tegra14_audio_sync_clk_disable,
3982         .set_parent = tegra14_audio_sync_clk_set_parent,
3983 };
3984
3985
3986 /* cbus ops */
3987 /*
3988  * Some clocks require dynamic re-locking of source PLL in order to
3989  * achieve frequency scaling granularity that matches characterized
3990  * core voltage steps. The cbus clock creates a shared bus that
3991  * provides a virtual root for such clocks to hide and synchronize
3992  * parent PLL re-locking as well as backup operations.
3993 */
3994
3995 static void tegra14_clk_cbus_init(struct clk *c)
3996 {
3997         c->state = OFF;
3998         c->set = true;
3999 }
4000
4001 static int tegra14_clk_cbus_enable(struct clk *c)
4002 {
4003         return 0;
4004 }
4005
4006 static long tegra14_clk_cbus_round_updown(struct clk *c, unsigned long rate,
4007                                           bool up)
4008 {
4009         int i;
4010
4011         if (!c->dvfs) {
4012                 if (!c->min_rate)
4013                         c->min_rate = c->parent->min_rate;
4014                 rate = max(rate, c->min_rate);
4015                 return rate;
4016         }
4017
4018         /* update min now, since no dvfs table was available during init
4019            (skip placeholder entries set to 1 kHz) */
4020         if (!c->min_rate) {
4021                 for (i = 0; i < (c->dvfs->num_freqs - 1); i++) {
4022                         if (c->dvfs->freqs[i] > 1 * c->dvfs->freqs_mult) {
4023                                 c->min_rate = c->dvfs->freqs[i];
4024                                 break;
4025                         }
4026                 }
4027                 BUG_ON(!c->min_rate);
4028         }
4029         rate = max(rate, c->min_rate);
4030
4031         for (i = 0; ; i++) {
4032                 unsigned long f = c->dvfs->freqs[i];
4033                 int mv = c->dvfs->millivolts[i];
4034                 if ((f >= rate) || (mv >= c->dvfs->max_millivolts) ||
4035                     ((i + 1) >=  c->dvfs->num_freqs)) {
4036                         if (!up && i && (f > rate))
4037                                 i--;
4038                         break;
4039                 }
4040         }
4041         return c->dvfs->freqs[i];
4042 }
4043
4044 static long tegra14_clk_cbus_round_rate(struct clk *c, unsigned long rate)
4045 {
4046         return tegra14_clk_cbus_round_updown(c, rate, true);
4047 }
4048
4049 static int cbus_switch_one(struct clk *c, struct clk *p, u32 div, bool abort)
4050 {
4051         int ret = 0;
4052
4053         /* set new divider if it is bigger than the current one */
4054         if (c->div < c->mul * div) {
4055                 ret = clk_set_div(c, div);
4056                 if (ret) {
4057                         pr_err("%s: failed to set %s clock divider %u: %d\n",
4058                                __func__, c->name, div, ret);
4059                         if (abort)
4060                                 return ret;
4061                 }
4062         }
4063
4064         if (c->parent != p) {
4065                 ret = clk_set_parent(c, p);
4066                 if (ret) {
4067                         pr_err("%s: failed to set %s clock parent %s: %d\n",
4068                                __func__, c->name, p->name, ret);
4069                         if (abort)
4070                                 return ret;
4071                 }
4072         }
4073
4074         /* set new divider if it is smaller than the current one */
4075         if (c->div > c->mul * div) {
4076                 ret = clk_set_div(c, div);
4077                 if (ret)
4078                         pr_err("%s: failed to set %s clock divider %u: %d\n",
4079                                __func__, c->name, div, ret);
4080         }
4081
4082         return ret;
4083 }
4084
4085 static int cbus_backup(struct clk *c)
4086 {
4087         int ret;
4088         struct clk *user;
4089
4090         list_for_each_entry(user, &c->shared_bus_list,
4091                         u.shared_bus_user.node) {
4092                 struct clk *client = user->u.shared_bus_user.client;
4093                 if (client && (client->state == ON) &&
4094                     (client->parent == c->parent)) {
4095                         ret = cbus_switch_one(client,
4096                                               c->shared_bus_backup.input,
4097                                               c->shared_bus_backup.value *
4098                                               user->div, true);
4099                         if (ret)
4100                                 return ret;
4101                 }
4102         }
4103         return 0;
4104 }
4105
4106 static int cbus_dvfs_set_rate(struct clk *c, unsigned long rate)
4107 {
4108         int ret;
4109         struct clk *user;
4110
4111         list_for_each_entry(user, &c->shared_bus_list,
4112                         u.shared_bus_user.node) {
4113                 struct clk *client =  user->u.shared_bus_user.client;
4114                 if (client && client->refcnt && (client->parent == c->parent)) {
4115                         ret = tegra_dvfs_set_rate(c, rate);
4116                         if (ret)
4117                                 return ret;
4118                 }
4119         }
4120         return 0;
4121 }
4122
4123 static void cbus_restore(struct clk *c)
4124 {
4125         struct clk *user;
4126
4127         list_for_each_entry(user, &c->shared_bus_list,
4128                         u.shared_bus_user.node) {
4129                 if (user->u.shared_bus_user.client)
4130                         cbus_switch_one(user->u.shared_bus_user.client,
4131                                         c->parent, c->div * user->div, false);
4132         }
4133 }
4134
4135 static int get_next_backup_div(struct clk *c, unsigned long rate)
4136 {
4137         u32 div = c->div;
4138         unsigned long backup_rate = clk_get_rate(c->shared_bus_backup.input);
4139
4140         rate = max(rate, clk_get_rate_locked(c));
4141         rate = rate - (rate >> 2);      /* 25% margin for backup rate */
4142         if ((u64)rate * div < backup_rate)
4143                 div = DIV_ROUND_UP(backup_rate, rate);
4144
4145         BUG_ON(!div);
4146         return div;
4147 }
4148
4149 static int tegra14_clk_cbus_set_rate(struct clk *c, unsigned long rate)
4150 {
4151         int ret;
4152         bool dramp;
4153
4154         if (rate == 0)
4155                 return 0;
4156
4157         ret = clk_enable(c->parent);
4158         if (ret) {
4159                 pr_err("%s: failed to enable %s clock: %d\n",
4160                        __func__, c->name, ret);
4161                 return ret;
4162         }
4163
4164         dramp = tegra14_is_dyn_ramp(c->parent, rate * c->div, false);
4165         if (!dramp) {
4166                 c->shared_bus_backup.value = get_next_backup_div(c, rate);
4167                 ret = cbus_backup(c);
4168                 if (ret)
4169                         goto out;
4170         }
4171
4172         ret = clk_set_rate(c->parent, rate * c->div);
4173         if (ret) {
4174                 pr_err("%s: failed to set %s clock rate %lu: %d\n",
4175                        __func__, c->name, rate, ret);
4176                 goto out;
4177         }
4178
4179         /* Safe voltage setting is taken care of by cbus clock dvfs; the call
4180          * below only records requirements for each enabled client.
4181          */
4182         if (dramp)
4183                 ret = cbus_dvfs_set_rate(c, rate);
4184
4185         cbus_restore(c);
4186
4187 out:
4188         clk_disable(c->parent);
4189         return ret;
4190 }
4191
4192 static inline void cbus_move_enabled_user(
4193         struct clk *user, struct clk *dst, struct clk *src)
4194 {
4195         clk_enable(dst);
4196         list_move_tail(&user->u.shared_bus_user.node, &dst->shared_bus_list);
4197         clk_disable(src);
4198         clk_reparent(user, dst);
4199 }
4200
4201 #ifdef CONFIG_TEGRA_DYNAMIC_CBUS
4202 static int tegra14_clk_cbus_update(struct clk *bus)
4203 {
4204         int ret, mv;
4205         struct clk *slow = NULL;
4206         struct clk *top = NULL;
4207         unsigned long rate;
4208         unsigned long old_rate;
4209         unsigned long ceiling;
4210
4211         if (detach_shared_bus)
4212                 return 0;
4213
4214         rate = tegra14_clk_shared_bus_update(bus, &top, &slow, &ceiling);
4215
4216         /* use dvfs table of the slowest enabled client as cbus dvfs table */
4217         if (bus->dvfs && slow && (slow != bus->u.cbus.slow_user)) {
4218                 int i;
4219                 unsigned long *dest = &bus->dvfs->freqs[0];
4220                 unsigned long *src =
4221                         &slow->u.shared_bus_user.client->dvfs->freqs[0];
4222                 if (slow->div > 1)
4223                         for (i = 0; i < bus->dvfs->num_freqs; i++)
4224                                 dest[i] = src[i] * slow->div;
4225                 else
4226                         memcpy(dest, src, sizeof(*dest) * bus->dvfs->num_freqs);
4227         }
4228
4229         /* update bus state variables and rate */
4230         bus->u.cbus.slow_user = slow;
4231         bus->u.cbus.top_user = top;
4232
4233         rate = tegra14_clk_cap_shared_bus(bus, rate, ceiling);
4234         mv = tegra_dvfs_predict_millivolts(bus, rate);
4235         if (IS_ERR_VALUE(mv))
4236                 return -EINVAL;
4237
4238         if (bus->dvfs) {
4239                 mv -= bus->dvfs->cur_millivolts;
4240                 if (bus->refcnt && (mv > 0)) {
4241                         ret = tegra_dvfs_set_rate(bus, rate);
4242                         if (ret)
4243                                 return ret;
4244                 }
4245         }
4246
4247         old_rate = clk_get_rate_locked(bus);
4248         if (IS_ENABLED(CONFIG_TEGRA_MIGRATE_CBUS_USERS) || (old_rate != rate)) {
4249                 ret = bus->ops->set_rate(bus, rate);
4250                 if (ret)
4251                         return ret;
4252         }
4253
4254         if (bus->dvfs) {
4255                 if (bus->refcnt && (mv <= 0)) {
4256                         ret = tegra_dvfs_set_rate(bus, rate);
4257                         if (ret)
4258                                 return ret;
4259                 }
4260         }
4261
4262         clk_rate_change_notify(bus, rate);
4263         return 0;
4264 };
4265 #else
4266 static int tegra14_clk_cbus_update(struct clk *bus)
4267 {
4268         unsigned long rate, old_rate;
4269
4270         if (detach_shared_bus)
4271                 return 0;
4272
4273         rate = tegra14_clk_shared_bus_update(bus, NULL, NULL, NULL);
4274
4275         old_rate = clk_get_rate_locked(bus);
4276         if (rate == old_rate)
4277                 return 0;
4278
4279         return clk_set_rate_locked(bus, rate);
4280 }
4281 #endif
4282
4283 static int tegra14_clk_cbus_migrate_users(struct clk *user)
4284 {
4285 #ifdef CONFIG_TEGRA_MIGRATE_CBUS_USERS
4286         struct clk *src_bus, *dst_bus, *top_user, *c;
4287         struct list_head *pos, *n;
4288
4289         if (!user->u.shared_bus_user.client || !user->inputs)
4290                 return 0;
4291
4292         /* Dual cbus on Tegra14 */
4293         src_bus = user->inputs[0].input;
4294         dst_bus = user->inputs[1].input;
4295
4296         if (!src_bus->u.cbus.top_user && !dst_bus->u.cbus.top_user)
4297                 return 0;
4298
4299         /* Make sure top user on the source bus is requesting highest rate */
4300         if (!src_bus->u.cbus.top_user || (dst_bus->u.cbus.top_user &&
4301                 bus_user_request_is_lower(src_bus->u.cbus.top_user,
4302                                            dst_bus->u.cbus.top_user)))
4303                 swap(src_bus, dst_bus);
4304
4305         /* If top user is the slow one on its own (source) bus, do nothing */
4306         top_user = src_bus->u.cbus.top_user;
4307         BUG_ON(!top_user->u.shared_bus_user.client);
4308         if (!bus_user_is_slower(src_bus->u.cbus.slow_user, top_user))
4309                 return 0;
4310
4311         /* If source bus top user is slower than all users on destination bus,
4312            move top user; otherwise move all users slower than the top one */
4313         if (!dst_bus->u.cbus.slow_user ||
4314             !bus_user_is_slower(dst_bus->u.cbus.slow_user, top_user)) {
4315                 cbus_move_enabled_user(top_user, dst_bus, src_bus);
4316         } else {
4317                 list_for_each_safe(pos, n, &src_bus->shared_bus_list) {
4318                         c = list_entry(pos, struct clk, u.shared_bus_user.node);
4319                         if (c->u.shared_bus_user.enabled &&
4320                             c->u.shared_bus_user.client &&
4321                             bus_user_is_slower(c, top_user))
4322                                 cbus_move_enabled_user(c, dst_bus, src_bus);
4323                 }
4324         }
4325
4326         /* Update destination bus 1st (move clients), then source */
4327         tegra_clk_shared_bus_update(dst_bus);
4328         tegra_clk_shared_bus_update(src_bus);
4329 #endif
4330         return 0;
4331 }
4332
4333 static struct clk_ops tegra_clk_cbus_ops = {
4334         .init = tegra14_clk_cbus_init,
4335         .enable = tegra14_clk_cbus_enable,
4336         .set_rate = tegra14_clk_cbus_set_rate,
4337         .round_rate = tegra14_clk_cbus_round_rate,
4338         .round_rate_updown = tegra14_clk_cbus_round_updown,
4339         .shared_bus_update = tegra14_clk_cbus_update,
4340 };
4341
4342 /* shared bus ops */
4343 /*
4344  * Some clocks may have multiple downstream users that need to request a
4345  * higher clock rate.  Shared bus clocks provide a unique shared_bus_user
4346  * clock to each user.  The frequency of the bus is set to the highest
4347  * enabled shared_bus_user clock, with a minimum value set by the
4348  * shared bus.
4349  *
4350  * Optionally shared bus may support users migration. Since shared bus and
4351  * its * children (users) have reversed rate relations: user rates determine
4352  * bus rate, * switching user from one parent/bus to another may change rates
4353  * of both parents. Therefore we need a cross-bus lock on top of individual
4354  * user and bus locks. For now, limit bus switch support to cbus only if
4355  * CONFIG_TEGRA_MIGRATE_CBUS_USERS is set.
4356  */
4357
4358 static unsigned long tegra14_clk_shared_bus_update(struct clk *bus,
4359         struct clk **bus_top, struct clk **bus_slow, unsigned long *rate_cap)
4360 {
4361         struct clk *c;
4362         struct clk *slow = NULL;
4363         struct clk *top = NULL;
4364
4365         unsigned long override_rate = 0;
4366         unsigned long top_rate = 0;
4367         unsigned long rate = bus->min_rate;
4368         unsigned long bw = 0;
4369         unsigned long ceiling = bus->max_rate;
4370         u8 emc_bw_efficiency = tegra_emc_bw_efficiency;
4371
4372         list_for_each_entry(c, &bus->shared_bus_list,
4373                         u.shared_bus_user.node) {
4374                 /*
4375                  * Ignore requests from disabled floor and bw users, and from
4376                  * auto-users riding the bus. Always honor ceiling users, even
4377                  * if they are disabled - we do not want to keep enabled parent
4378                  * bus just because ceiling is set.
4379                  */
4380                 if (c->u.shared_bus_user.enabled ||
4381                     (c->u.shared_bus_user.mode == SHARED_CEILING)) {
4382                         unsigned long request_rate = c->u.shared_bus_user.rate *
4383                                 (c->div ? : 1);
4384
4385                         switch (c->u.shared_bus_user.mode) {
4386                         case SHARED_BW:
4387                                 bw += request_rate;
4388                                 if (bw > bus->max_rate)
4389                                         bw = bus->max_rate;
4390                                 break;
4391                         case SHARED_CEILING:
4392                                 ceiling = min(request_rate, ceiling);
4393                                 break;
4394                         case SHARED_OVERRIDE:
4395                                 if (override_rate == 0)
4396                                         override_rate = request_rate;
4397                                 break;
4398                         case SHARED_AUTO:
4399                                 break;
4400                         case SHARED_FLOOR:
4401                         default:
4402                                 rate = max(request_rate, rate);
4403                                 if (c->u.shared_bus_user.client
4404                                                         && request_rate) {
4405                                         if (top_rate < request_rate) {
4406                                                 top_rate = request_rate;
4407                                                 top = c;
4408                                         } else if ((top_rate == request_rate) &&
4409                                                 bus_user_is_slower(c, top)) {
4410                                                 top = c;
4411                                         }
4412                                 }
4413                         }
4414                         if (c->u.shared_bus_user.client &&
4415                                 (!slow || bus_user_is_slower(c, slow)))
4416                                 slow = c;
4417                 }
4418         }
4419
4420         if ((bus->flags & PERIPH_EMC_ENB) && bw && (emc_bw_efficiency < 100)) {
4421                 bw = emc_bw_efficiency ?
4422                         (bw / emc_bw_efficiency) : bus->max_rate;
4423                 bw = (bw < bus->max_rate / 100) ? (bw * 100) : bus->max_rate;
4424         }
4425
4426         rate = override_rate ? : max(rate, bw);
4427         ceiling = override_rate ? bus->max_rate : ceiling;
4428
4429         if (bus_top && bus_slow && rate_cap) {
4430                 /* If dynamic bus dvfs table, let the caller to complete
4431                    rounding and aggregation */
4432                 *bus_top = top;
4433                 *bus_slow = slow;
4434                 *rate_cap = ceiling;
4435         } else {
4436                 /* If satic bus dvfs table, complete rounding and aggregation */
4437                 rate = tegra14_clk_cap_shared_bus(bus, rate, ceiling);
4438         }
4439
4440         return rate;
4441 };
4442
4443 static unsigned long tegra14_clk_cap_shared_bus(struct clk *bus,
4444         unsigned long rate, unsigned long ceiling)
4445 {
4446         if (bus->ops && bus->ops->round_rate_updown)
4447                 ceiling = bus->ops->round_rate_updown(bus, ceiling, false);
4448
4449         rate = min(rate, ceiling);
4450
4451         if (bus->ops && bus->ops->round_rate)
4452                 rate = bus->ops->round_rate(bus, rate);
4453
4454         return rate;
4455 }
4456
4457 static int tegra_clk_shared_bus_migrate_users(struct clk *user)
4458 {
4459         if (detach_shared_bus)
4460                 return 0;
4461
4462         /* Only cbus migration is supported */
4463         if (user->flags & PERIPH_ON_CBUS)
4464                 return tegra14_clk_cbus_migrate_users(user);
4465         return -ENOSYS;
4466 }
4467
4468 static void tegra_clk_shared_bus_user_init(struct clk *c)
4469 {
4470         c->max_rate = c->parent->max_rate;
4471         c->u.shared_bus_user.rate = c->parent->max_rate;
4472         c->state = OFF;
4473         c->set = true;
4474
4475         if (c->u.shared_bus_user.mode == SHARED_CEILING) {
4476                 c->state = ON;
4477                 c->refcnt++;
4478         }
4479
4480         if (c->u.shared_bus_user.client_id) {
4481                 c->u.shared_bus_user.client =
4482                         tegra_get_clock_by_name(c->u.shared_bus_user.client_id);
4483                 if (!c->u.shared_bus_user.client) {
4484                         pr_err("%s: could not find clk %s\n", __func__,
4485                                c->u.shared_bus_user.client_id);
4486                         return;
4487                 }
4488                 c->u.shared_bus_user.client->flags |=
4489                         c->parent->flags & PERIPH_ON_CBUS;
4490                 c->flags |= c->parent->flags & PERIPH_ON_CBUS;
4491                 c->div = c->u.shared_bus_user.client_div ? : 1;
4492                 c->mul = 1;
4493         }
4494
4495         list_add_tail(&c->u.shared_bus_user.node,
4496                 &c->parent->shared_bus_list);
4497 }
4498
4499 static int tegra_clk_shared_bus_user_set_parent(struct clk *c, struct clk *p)
4500 {
4501         int ret;
4502         const struct clk_mux_sel *sel;
4503
4504         if (detach_shared_bus)
4505                 return 0;
4506
4507         if (c->parent == p)
4508                 return 0;
4509
4510         if (!(c->inputs && c->cross_clk_mutex && clk_cansleep(c)))
4511                 return -ENOSYS;
4512
4513         for (sel = c->inputs; sel->input != NULL; sel++) {
4514                 if (sel->input == p)
4515                         break;
4516         }
4517         if (!sel->input)
4518                 return -EINVAL;
4519
4520         if (c->refcnt)
4521                 clk_enable(p);
4522
4523         list_move_tail(&c->u.shared_bus_user.node, &p->shared_bus_list);
4524         ret = tegra_clk_shared_bus_update(p);
4525         if (ret) {
4526                 list_move_tail(&c->u.shared_bus_user.node,
4527                                &c->parent->shared_bus_list);
4528                 tegra_clk_shared_bus_update(c->parent);
4529                 clk_disable(p);
4530                 return ret;
4531         }
4532
4533         tegra_clk_shared_bus_update(c->parent);
4534
4535         if (c->refcnt && c->parent)
4536                 clk_disable(c->parent);
4537
4538         clk_reparent(c, p);
4539
4540         return 0;
4541 }
4542
4543 static int tegra_clk_shared_bus_user_set_rate(struct clk *c, unsigned long rate)
4544 {
4545         int ret;
4546
4547         c->u.shared_bus_user.rate = rate;
4548         ret = tegra_clk_shared_bus_update(c->parent);
4549
4550         if (!ret && c->cross_clk_mutex && clk_cansleep(c))
4551                 tegra_clk_shared_bus_migrate_users(c);
4552
4553         return ret;
4554 }
4555
4556 static long tegra_clk_shared_bus_user_round_rate(
4557         struct clk *c, unsigned long rate)
4558 {
4559         /* Defer rounding requests until aggregated. BW users must not be
4560            rounded at all, others just clipped to bus range (some clients
4561            may use round api to find limits) */
4562         if (c->u.shared_bus_user.mode != SHARED_BW) {
4563                 if (c->div > 1)
4564                         rate *= c->div;
4565
4566                 if (rate > c->parent->max_rate)
4567                         rate = c->parent->max_rate;
4568                 else if (rate < c->parent->min_rate)
4569                         rate = c->parent->min_rate;
4570
4571                 if (c->div > 1)
4572                         rate /= c->div;
4573         }
4574         return rate;
4575 }
4576
4577 static int tegra_clk_shared_bus_user_enable(struct clk *c)
4578 {
4579         int ret;
4580
4581         c->u.shared_bus_user.enabled = true;
4582         ret = tegra_clk_shared_bus_update(c->parent);
4583         if (!ret && c->u.shared_bus_user.client)
4584                 ret = clk_enable(c->u.shared_bus_user.client);
4585
4586         if (!ret && c->cross_clk_mutex && clk_cansleep(c))
4587                 tegra_clk_shared_bus_migrate_users(c);
4588
4589         return ret;
4590 }
4591
4592 static void tegra_clk_shared_bus_user_disable(struct clk *c)
4593 {
4594         if (c->u.shared_bus_user.client)
4595                 clk_disable(c->u.shared_bus_user.client);
4596         c->u.shared_bus_user.enabled = false;
4597         tegra_clk_shared_bus_update(c->parent);
4598
4599         if (c->cross_clk_mutex && clk_cansleep(c))
4600                 tegra_clk_shared_bus_migrate_users(c);
4601 }
4602
4603 static void tegra_clk_shared_bus_user_reset(struct clk *c, bool assert)
4604 {
4605         if (c->u.shared_bus_user.client) {
4606                 if (c->u.shared_bus_user.client->ops &&
4607                     c->u.shared_bus_user.client->ops->reset)
4608                         c->u.shared_bus_user.client->ops->reset(
4609                                 c->u.shared_bus_user.client, assert);
4610         }
4611 }
4612
4613 static struct clk_ops tegra_clk_shared_bus_user_ops = {
4614         .init = tegra_clk_shared_bus_user_init,
4615         .enable = tegra_clk_shared_bus_user_enable,
4616         .disable = tegra_clk_shared_bus_user_disable,
4617         .set_parent = tegra_clk_shared_bus_user_set_parent,
4618         .set_rate = tegra_clk_shared_bus_user_set_rate,
4619         .round_rate = tegra_clk_shared_bus_user_round_rate,
4620         .reset = tegra_clk_shared_bus_user_reset,
4621 };
4622
4623 /* Clock definitions */
4624 static struct clk tegra_clk_32k = {
4625         .name = "clk_32k",
4626         .rate = 32768,
4627         .ops  = NULL,
4628         .max_rate = 32768,
4629 };
4630
4631 static struct clk tegra_osc = {
4632         .name      = "osc",
4633         .flags     = ENABLE_ON_INIT,
4634         .ops       = &tegra_osc_ops,
4635         .reg       = 0x1fc,
4636         .reg_shift = 28,
4637         .max_rate  = 48000000,
4638 };
4639
4640 static struct clk tegra_osc_div2 = {
4641         .name      = "osc_div2",
4642         .ops       = &tegra_osc_div_ops,
4643         .parent    = &tegra_osc,
4644         .mul       = 1,
4645         .div       = 2,
4646         .state     = ON,
4647         .max_rate  = 24000000,
4648 };
4649
4650 static struct clk tegra_osc_div4 = {
4651         .name      = "osc_div4",
4652         .ops       = &tegra_osc_div_ops,
4653         .parent    = &tegra_osc,
4654         .mul       = 1,
4655         .div       = 4,
4656         .state     = ON,
4657         .max_rate  = 12000000,
4658 };
4659
4660 static struct clk tegra_clk_m = {
4661         .name      = "clk_m",
4662         .ops       = &tegra_clk_m_ops,
4663         .parent    = &tegra_osc,
4664         .max_rate  = 48000000,
4665 };
4666
4667 static struct clk tegra_pll_ref = {
4668         .name      = "pll_ref",
4669         .flags     = ENABLE_ON_INIT,
4670         .ops       = &tegra_pll_ref_ops,
4671         .parent    = &tegra_osc,
4672         .max_rate  = 26000000,
4673 };
4674
4675 static struct clk_pll_freq_table tegra_pll_c_freq_table[] = {
4676         { 12000000, 624000000, 104, 1, 2},
4677         { 12000000, 600000000, 100, 1, 2},
4678         { 13000000, 600000000,  92, 1, 2},      /* actual: 598.0 MHz */
4679         { 16800000, 600000000,  71, 1, 2},      /* actual: 596.4 MHz */
4680         { 19200000, 600000000,  62, 1, 2},      /* actual: 595.2 MHz */
4681         { 26000000, 600000000,  92, 2, 2},      /* actual: 598.0 MHz */
4682         { 0, 0, 0, 0, 0, 0 },
4683 };
4684
4685 static struct clk tegra_pll_c = {
4686         .name      = "pll_c",
4687         .ops       = &tegra_pllxc_ops,
4688         .reg       = 0x80,
4689         .parent    = &tegra_pll_ref,
4690         .max_rate  = 1400000000,
4691         .u.pll = {
4692                 .input_min = 12000000,
4693                 .input_max = 800000000,
4694                 .cf_min    = 12000000,
4695                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
4696                 .vco_min   = 600000000,
4697                 .vco_max   = 1400000000,
4698                 .freq_table = tegra_pll_c_freq_table,
4699                 .lock_delay = 300,
4700                 .misc1 = 0x88 - 0x80,
4701                 .round_p_to_pdiv = pllxc_round_p_to_pdiv,
4702         },
4703 };
4704
4705 static struct clk tegra_pll_c_out1 = {
4706         .name      = "pll_c_out1",
4707         .ops       = &tegra_pll_div_ops,
4708 #ifdef CONFIG_TEGRA_DUAL_CBUS
4709         .flags     = DIV_U71 | DIV_U71_INT,
4710 #else
4711         .flags     = DIV_U71 | DIV_U71_INT | PERIPH_ON_CBUS,
4712 #endif
4713         .parent    = &tegra_pll_c,
4714         .reg       = 0x84,
4715         .reg_shift = 0,
4716         .max_rate  = 700000000,
4717 };
4718
4719 static struct clk_pll_freq_table tegra_pll_cx_freq_table[] = {
4720         { 12000000, 600000000, 100, 1, 2},
4721         { 13000000, 600000000,  92, 1, 2},      /* actual: 598.0 MHz */
4722         { 16800000, 600000000,  71, 1, 2},      /* actual: 596.4 MHz */
4723         { 19200000, 600000000,  62, 1, 2},      /* actual: 595.2 MHz */
4724         { 26000000, 600000000,  92, 2, 2},      /* actual: 598.0 MHz */
4725         { 0, 0, 0, 0, 0, 0 },
4726 };
4727
4728 static struct clk tegra_pll_c2 = {
4729         .name      = "pll_c2",
4730         .ops       = &tegra_pllcx_ops,
4731         .flags     = PLL_ALT_MISC_REG,
4732         .reg       = 0x4e8,
4733         .parent    = &tegra_pll_ref,
4734         .max_rate  = 1200000000,
4735         .u.pll = {
4736                 .input_min = 12000000,
4737                 .input_max = 48000000,
4738                 .cf_min    = 12000000,
4739                 .cf_max    = 19200000,
4740                 .vco_min   = 624000000,
4741                 .vco_max   = 1248000000,
4742                 .freq_table = tegra_pll_cx_freq_table,
4743                 .lock_delay = 300,
4744                 .misc1 = 0x4f0 - 0x4e8,
4745                 .round_p_to_pdiv = pllcx_round_p_to_pdiv,
4746         },
4747 };
4748
4749 static struct clk tegra_pll_c3 = {
4750         .name      = "pll_c3",
4751         .ops       = &tegra_pllcx_ops,
4752         .flags     = PLL_ALT_MISC_REG,
4753         .reg       = 0x4fc,
4754         .parent    = &tegra_pll_ref,
4755         .max_rate  = 1200000000,
4756         .u.pll = {
4757                 .input_min = 12000000,
4758                 .input_max = 48000000,
4759                 .cf_min    = 12000000,
4760                 .cf_max    = 19200000,
4761                 .vco_min   = 624000000,
4762                 .vco_max   = 1248000000,
4763                 .freq_table = tegra_pll_cx_freq_table,
4764                 .lock_delay = 300,
4765                 .misc1 = 0x504 - 0x4fc,
4766                 .round_p_to_pdiv = pllcx_round_p_to_pdiv,
4767         },
4768 };
4769
4770 static struct clk_pll_freq_table tegra_pll_m_freq_table[] = {
4771         { 12000000, 800000000, 66, 1, 1},       /* actual: 792.0 MHz */
4772         { 13000000, 800000000, 61, 1, 1},       /* actual: 793.0 MHz */
4773         { 16800000, 800000000, 47, 1, 1},       /* actual: 789.6 MHz */
4774         { 19200000, 800000000, 41, 1, 1},       /* actual: 787.2 MHz */
4775         { 26000000, 800000000, 61, 2, 1},       /* actual: 793.0 MHz */
4776         { 0, 0, 0, 0, 0, 0 },
4777 };
4778
4779 static struct clk tegra_pll_m = {
4780         .name      = "pll_m",
4781         .flags     = PLLM,
4782         .ops       = &tegra_pllm_ops,
4783         .reg       = 0x90,
4784         .parent    = &tegra_pll_ref,
4785         .max_rate  = 1066000000,
4786         .u.pll = {
4787                 .input_min = 12000000,
4788                 .input_max = 500000000,
4789                 .cf_min    = 12000000,
4790                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
4791                 .vco_min   = 400000000,
4792                 .vco_max   = 1066000000,
4793                 .freq_table = tegra_pll_m_freq_table,
4794                 .lock_delay = 300,
4795                 .misc1 = 0x98 - 0x90,
4796                 .round_p_to_pdiv = pllm_round_p_to_pdiv,
4797         },
4798 };
4799
4800 static struct clk tegra_pll_m_out1 = {
4801         .name      = "pll_m_out1",
4802         .ops       = &tegra_pll_div_ops,
4803         .flags     = DIV_U71 | DIV_U71_INT,
4804         .parent    = &tegra_pll_m,
4805         .reg       = 0x94,
4806         .reg_shift = 0,
4807         .max_rate  = 600000000,
4808 };
4809
4810 static struct clk_pll_freq_table tegra_pll_p_freq_table[] = {
4811         /* Parameters below are made up just to satisfy software */
4812         { 12000000, 408000000, 816, 12, 2, 8},
4813         { 13000000, 408000000, 816, 13, 2, 8},
4814         { 16800000, 408000000, 680, 14, 2, 8},
4815         { 19200000, 408000000, 680, 16, 2, 8},
4816         { 26000000, 408000000, 816, 26, 2, 8},
4817         { 0, 0, 0, 0, 0, 0 },
4818 };
4819
4820 static struct clk tegra_pll_p = {
4821         .name      = "pll_p",
4822         .flags     = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
4823         .ops       = &tegra_pllp_ops,
4824         .reg       = 0xa0,
4825         .parent    = &tegra_pll_ref,
4826         .max_rate  = 432000000,
4827         .u.pll = {
4828                 .input_min = 2000000,
4829                 .input_max = 31000000,
4830                 .cf_min    = 1000000,
4831                 .cf_max    = 6000000,
4832                 .vco_min   = 200000000,
4833                 .vco_max   = 700000000,
4834                 .freq_table = tegra_pll_p_freq_table,
4835                 .lock_delay = 300,
4836         },
4837 };
4838
4839 static struct clk tegra_pll_p_out1 = {
4840         .name      = "pll_p_out1",
4841         .ops       = &tegra_pll_div_ops,
4842         .flags     = DIV_U71 | DIV_U71_FIXED,
4843         .parent    = &tegra_pll_p,
4844         .reg       = 0xa4,
4845         .reg_shift = 0,
4846         .max_rate  = 432000000,
4847 };
4848
4849 static struct clk tegra_pll_p_out2 = {
4850         .name      = "pll_p_out2",
4851         .ops       = &tegra_pll_div_ops,
4852         .flags     = DIV_U71 | DIV_U71_FIXED | DIV_U71_INT,
4853         .parent    = &tegra_pll_p,
4854         .reg       = 0xa4,
4855         .reg_shift = 16,
4856         .max_rate  = 432000000,
4857 };
4858
4859 static struct clk tegra_pll_p_out3 = {
4860         .name      = "pll_p_out3",
4861         .ops       = &tegra_pll_div_ops,
4862         .flags     = DIV_U71 | DIV_U71_FIXED,
4863         .parent    = &tegra_pll_p,
4864         .reg       = 0xa8,
4865         .reg_shift = 0,
4866         .max_rate  = 432000000,
4867 };
4868
4869 static struct clk tegra_pll_p_out4 = {
4870         .name      = "pll_p_out4",
4871         .ops       = &tegra_pll_div_ops,
4872         .flags     = DIV_U71 | DIV_U71_FIXED,
4873         .parent    = &tegra_pll_p,
4874         .reg       = 0xa8,
4875         .reg_shift = 16,
4876         .max_rate  = 432000000,
4877 };
4878
4879 static struct clk_pll_freq_table tegra_pll_a_freq_table[] = {
4880         {  9600000, 282240000, 147,  5, 1, 4},
4881         {  9600000, 368640000, 192,  5, 1, 4},
4882         {  9600000, 240000000, 200,  8, 1, 8},
4883
4884         { 28800000, 282240000, 245, 25, 1, 8},
4885         { 28800000, 368640000, 320, 25, 1, 8},
4886         { 28800000, 240000000, 200, 24, 1, 8},
4887         { 0, 0, 0, 0, 0, 0 },
4888 };
4889
4890 static struct clk tegra_pll_a = {
4891         .name      = "pll_a",
4892         .flags     = PLL_HAS_CPCON,
4893         .ops       = &tegra_pll_ops,
4894         .reg       = 0xb0,
4895         .parent    = &tegra_pll_p_out1,
4896         .max_rate  = 700000000,
4897         .u.pll = {
4898                 .input_min = 2000000,
4899                 .input_max = 31000000,
4900                 .cf_min    = 1000000,
4901                 .cf_max    = 6000000,
4902                 .vco_min   = 200000000,
4903                 .vco_max   = 700000000,
4904                 .freq_table = tegra_pll_a_freq_table,
4905                 .lock_delay = 300,
4906         },
4907 };
4908
4909 static struct clk tegra_pll_a_out0 = {
4910         .name      = "pll_a_out0",
4911         .ops       = &tegra_pll_div_ops,
4912         .flags     = DIV_U71,
4913         .parent    = &tegra_pll_a,
4914         .reg       = 0xb4,
4915         .reg_shift = 0,
4916         .max_rate  = 100000000,
4917 };
4918
4919 static struct clk_pll_freq_table tegra_pll_d_freq_table[] = {
4920         { 12000000, 216000000, 864, 12, 4, 12},
4921         { 13000000, 216000000, 864, 13, 4, 12},
4922         { 16800000, 216000000, 720, 14, 4, 12},
4923         { 19200000, 216000000, 720, 16, 4, 12},
4924         { 26000000, 216000000, 864, 26, 4, 12},
4925
4926         { 12000000, 594000000, 594, 12, 1, 12},
4927         { 13000000, 594000000, 594, 13, 1, 12},
4928         { 16800000, 594000000, 495, 14, 1, 12},
4929         { 19200000, 594000000, 495, 16, 1, 12},
4930         { 26000000, 594000000, 594, 26, 1, 12},
4931
4932         { 12000000, 1000000000, 1000, 12, 1, 12},
4933         { 13000000, 1000000000, 1000, 13, 1, 12},
4934         { 19200000, 1000000000, 625,  12, 1, 12},
4935         { 26000000, 1000000000, 1000, 26, 1, 12},
4936
4937         { 0, 0, 0, 0, 0, 0 },
4938 };
4939
4940 static struct clk tegra_pll_d = {
4941         .name      = "pll_d",
4942         .flags     = PLL_HAS_CPCON | PLLD,
4943         .ops       = &tegra_plld_ops,
4944         .reg       = 0xd0,
4945         .parent    = &tegra_pll_ref,
4946         .max_rate  = 1000000000,
4947         .u.pll = {
4948                 .input_min = 2000000,
4949                 .input_max = 40000000,
4950                 .cf_min    = 1000000,
4951                 .cf_max    = 6000000,
4952                 .vco_min   = 500000000,
4953                 .vco_max   = 1000000000,
4954                 .freq_table = tegra_pll_d_freq_table,
4955                 .lock_delay = 1000,
4956         },
4957 };
4958
4959 static struct clk tegra_pll_d_out0 = {
4960         .name      = "pll_d_out0",
4961         .ops       = &tegra_pll_div_ops,
4962         .flags     = DIV_2 | PLLD,
4963         .parent    = &tegra_pll_d,
4964         .max_rate  = 500000000,
4965 };
4966
4967 static struct clk tegra_pll_d2 = {
4968         .name      = "pll_d2",
4969         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG | PLLD,
4970         .ops       = &tegra_plld_ops,
4971         .reg       = 0x4b8,
4972         .parent    = &tegra_pll_ref,
4973         .max_rate  = 1000000000,
4974         .u.pll = {
4975                 .input_min = 2000000,
4976                 .input_max = 40000000,
4977                 .cf_min    = 1000000,
4978                 .cf_max    = 6000000,
4979                 .vco_min   = 500000000,
4980                 .vco_max   = 1000000000,
4981                 .freq_table = tegra_pll_d_freq_table,
4982                 .lock_delay = 1000,
4983         },
4984 };
4985
4986 static struct clk tegra_pll_d2_out0 = {
4987         .name      = "pll_d2_out0",
4988         .ops       = &tegra_pll_div_ops,
4989         .flags     = DIV_2 | PLLD,
4990         .parent    = &tegra_pll_d2,
4991         .max_rate  = 500000000,
4992 };
4993
4994 static struct clk_pll_freq_table tegra_pll_u_freq_table[] = {
4995         { 12000000, 480000000, 960, 12, 2, 12},
4996         { 13000000, 480000000, 960, 13, 2, 12},
4997         { 16800000, 480000000, 400, 7,  2, 5},
4998         { 19200000, 480000000, 200, 4,  2, 3},
4999         { 26000000, 480000000, 960, 26, 2, 12},
5000         { 0, 0, 0, 0, 0, 0 },
5001 };
5002
5003 static struct clk tegra_pll_u = {
5004         .name      = "pll_u",
5005         .flags     = PLL_HAS_CPCON | PLLU,
5006         .ops       = &tegra_pll_ops,
5007         .reg       = 0xc0,
5008         .parent    = &tegra_pll_ref,
5009         .max_rate  = 480000000,
5010         .u.pll = {
5011                 .input_min = 2000000,
5012                 .input_max = 40000000,
5013                 .cf_min    = 1000000,
5014                 .cf_max    = 6000000,
5015                 .vco_min   = 480000000,
5016                 .vco_max   = 960000000,
5017                 .freq_table = tegra_pll_u_freq_table,
5018                 .lock_delay = 1000,
5019                 .cpcon_default = 12,
5020         },
5021 };
5022
5023 static struct clk tegra_pll_u_480M = {
5024         .name      = "pll_u_480M",
5025         .flags     = PLLU,
5026         .ops       = &tegra_pll_div_ops,
5027         .reg       = 0xc0,
5028         .reg_shift = 22,
5029         .parent    = &tegra_pll_u,
5030         .mul       = 1,
5031         .div       = 1,
5032         .max_rate  = 480000000,
5033 };
5034
5035 static struct clk tegra_pll_u_60M = {
5036         .name      = "pll_u_60M",
5037         .flags     = PLLU,
5038         .ops       = &tegra_pll_div_ops,
5039         .reg       = 0xc0,
5040         .reg_shift = 23,
5041         .parent    = &tegra_pll_u,
5042         .mul       = 1,
5043         .div       = 8,
5044         .max_rate  = 60000000,
5045 };
5046
5047 static struct clk tegra_pll_u_48M = {
5048         .name      = "pll_u_48M",
5049         .flags     = PLLU,
5050         .ops       = &tegra_pll_div_ops,
5051         .reg       = 0xc0,
5052         .reg_shift = 25,
5053         .parent    = &tegra_pll_u,
5054         .mul       = 1,
5055         .div       = 10,
5056         .max_rate  = 48000000,
5057 };
5058
5059 static struct clk tegra_pll_u_12M = {
5060         .name      = "pll_u_12M",
5061         .flags     = PLLU,
5062         .ops       = &tegra_pll_div_ops,
5063         .reg       = 0xc0,
5064         .reg_shift = 21,
5065         .parent    = &tegra_pll_u,
5066         .mul       = 1,
5067         .div       = 40,
5068         .max_rate  = 12000000,
5069 };
5070
5071 static struct clk_pll_freq_table tegra_pll_x_freq_table[] = {
5072         /* 1 GHz */
5073         { 12000000, 1000000000, 83, 1, 1},      /* actual: 996.0 MHz */
5074         { 13000000, 1000000000, 76, 1, 1},      /* actual: 988.0 MHz */
5075         { 16800000, 1000000000, 59, 1, 1},      /* actual: 991.2 MHz */
5076         { 19200000, 1000000000, 52, 1, 1},      /* actual: 998.4 MHz */
5077         { 26000000, 1000000000, 76, 2, 1},      /* actual: 988.0 MHz */
5078
5079         { 0, 0, 0, 0, 0, 0 },
5080 };
5081
5082 static struct clk tegra_pll_x = {
5083         .name      = "pll_x",
5084         .flags     = PLL_ALT_MISC_REG | PLLX,
5085         .ops       = &tegra_pllxc_ops,
5086         .reg       = 0xe0,
5087         .parent    = &tegra_pll_ref,
5088         .max_rate  = 1800000000,
5089         .u.pll = {
5090                 .input_min = 12000000,
5091                 .input_max = 800000000,
5092                 .cf_min    = 12000000,
5093                 .cf_max    = 19200000,  /* s/w policy, h/w capability 50 MHz */
5094                 .vco_min   = 700000000,
5095                 .vco_max   = 2600000000U,
5096                 .freq_table = tegra_pll_x_freq_table,
5097                 .lock_delay = 300,
5098                 .misc1 = 0x510 - 0xe0,
5099                 .round_p_to_pdiv = pllxc_round_p_to_pdiv,
5100         },
5101 };
5102
5103 static struct clk tegra_pll_x_out0 = {
5104         .name      = "pll_x_out0",
5105         .ops       = &tegra_pll_div_ops,
5106         .flags     = DIV_2 | PLLX,
5107         .parent    = &tegra_pll_x,
5108         .max_rate  = 700000000,
5109 };
5110
5111 /* FIXME: remove; for now, should be always checked-in as "0" */
5112 #define USE_LP_CPU_TO_TEST_DFLL         0
5113
5114 static struct clk tegra_dfll_cpu = {
5115         .name      = "dfll_cpu",
5116         .flags     = DFLL,
5117         .ops       = &tegra_dfll_ops,
5118         .reg       = 0x2f4,
5119         .max_rate  = 2000000000,
5120 };
5121
5122 /* Audio sync clocks */
5123 #define SYNC_SOURCE(_id, _dev)                          \
5124         {                                               \
5125                 .name      = #_id "_sync",              \
5126                 .lookup    = {                          \
5127                         .dev_id    = #_dev ,            \
5128                         .con_id    = "ext_audio_sync",  \
5129                 },                                      \
5130                 .rate      = 24000000,                  \
5131                 .max_rate  = 24000000,                  \
5132                 .ops       = &tegra_sync_source_ops     \
5133         }
5134 static struct clk tegra_sync_source_list[] = {
5135         SYNC_SOURCE(i2s0, tegra30-i2s.0),
5136         SYNC_SOURCE(i2s1, tegra30-i2s.1),
5137         SYNC_SOURCE(i2s2, tegra30-i2s.2),
5138         SYNC_SOURCE(i2s3, tegra30-i2s.3),
5139         SYNC_SOURCE(i2s4, tegra30-i2s.4),
5140         SYNC_SOURCE(vimclk, vimclk),
5141 };
5142
5143 static struct clk_mux_sel mux_d_audio_clk[] = {
5144         { .input = &tegra_pll_a_out0,           .value = 0x0001},
5145         { .input = &tegra_pll_p,                .value = 0x8001},
5146         { .input = &tegra_clk_m,                .value = 0xc001},
5147         { .input = &tegra_sync_source_list[0],  .value = 0xE001},
5148         { .input = &tegra_sync_source_list[1],  .value = 0xE002},
5149         { .input = &tegra_sync_source_list[2],  .value = 0xE003},
5150         { .input = &tegra_sync_source_list[3],  .value = 0xE004},
5151         { .input = &tegra_sync_source_list[4],  .value = 0xE005},
5152         { .input = &tegra_pll_a_out0,           .value = 0xE006},
5153         { .input = &tegra_sync_source_list[5],  .value = 0xE007},
5154         { 0, 0 }
5155 };
5156
5157 static struct clk_mux_sel mux_audio_sync_clk[] = {
5158         { .input = &tegra_sync_source_list[0],  .value = 1},
5159         { .input = &tegra_sync_source_list[1],  .value = 2},
5160         { .input = &tegra_sync_source_list[2],  .value = 3},
5161         { .input = &tegra_sync_source_list[3],  .value = 4},
5162         { .input = &tegra_sync_source_list[4],  .value = 5},
5163         { .input = &tegra_pll_a_out0,           .value = 6},
5164         { .input = &tegra_sync_source_list[5],  .value = 7},
5165         { 0, 0 }
5166 };
5167
5168 #define AUDIO_SYNC_CLK(_id, _dev, _index)                       \
5169         {                                               \
5170                 .name      = #_id,                      \
5171                 .lookup    = {                          \
5172                         .dev_id    = #_dev,             \
5173                         .con_id    = "audio_sync",      \
5174                 },                                      \
5175                 .inputs    = mux_audio_sync_clk,        \
5176                 .reg       = 0x4A0 + (_index) * 4,      \
5177                 .max_rate  = 24000000,                  \
5178                 .ops       = &tegra_audio_sync_clk_ops  \
5179         }
5180 static struct clk tegra_clk_audio_list[] = {
5181         AUDIO_SYNC_CLK(audio0, tegra30-i2s.0, 0),
5182         AUDIO_SYNC_CLK(audio1, tegra30-i2s.1, 1),
5183         AUDIO_SYNC_CLK(audio2, tegra30-i2s.2, 2),
5184         AUDIO_SYNC_CLK(audio3, tegra30-i2s.3, 3),
5185         AUDIO_SYNC_CLK(audio4, tegra30-i2s.4, 4),
5186 };
5187
5188 #define AUDIO_SYNC_2X_CLK(_id, _dev, _index)                            \
5189         {                                                       \
5190                 .name      = #_id "_2x",                        \
5191                 .lookup    = {                                  \
5192                         .dev_id    = #_dev,                     \
5193                         .con_id    = "audio_sync_2x"            \
5194                 },                                              \
5195                 .flags     = PERIPH_NO_RESET,                   \
5196                 .max_rate  = 48000000,                          \
5197                 .ops       = &tegra_clk_double_ops,             \
5198                 .reg       = 0x49C,                             \
5199                 .reg_shift = 24 + (_index),                     \
5200                 .parent    = &tegra_clk_audio_list[(_index)],   \
5201                 .u.periph = {                                   \
5202                         .clk_num = 113 + (_index),              \
5203                 },                                              \
5204         }
5205 static struct clk tegra_clk_audio_2x_list[] = {
5206         AUDIO_SYNC_2X_CLK(audio0, tegra30-i2s.0, 0),
5207         AUDIO_SYNC_2X_CLK(audio1, tegra30-i2s.1, 1),
5208         AUDIO_SYNC_2X_CLK(audio2, tegra30-i2s.2, 2),
5209         AUDIO_SYNC_2X_CLK(audio3, tegra30-i2s.3, 3),
5210         AUDIO_SYNC_2X_CLK(audio4, tegra30-i2s.4, 4),
5211 };
5212
5213 #define MUX_I2S_SPDIF(_id, _index)                                      \
5214 static struct clk_mux_sel mux_pllaout0_##_id##_2x_pllp_clkm[] = {       \
5215         {.input = &tegra_pll_a_out0, .value = 0},                       \
5216         {.input = &tegra_clk_audio_2x_list[(_index)], .value = 1},      \
5217         {.input = &tegra_pll_p, .value = 2},                            \
5218         {.input = &tegra_clk_m, .value = 3},                            \
5219         { 0, 0},                                                        \
5220 }
5221 MUX_I2S_SPDIF(audio0, 0);
5222 MUX_I2S_SPDIF(audio1, 1);
5223 MUX_I2S_SPDIF(audio2, 2);
5224 MUX_I2S_SPDIF(audio3, 3);
5225 MUX_I2S_SPDIF(audio4, 4);
5226
5227 /* Audio sync dmic clocks */
5228 #define AUDIO_SYNC_DMIC_CLK(_id, _dev, _index)          \
5229         {                                               \
5230                 .name      = #_id "dmic",               \
5231                 .lookup    = {                          \
5232                         .dev_id    = #_dev,             \
5233                         .con_id    = "audio_sync_dmic", \
5234                 },                                      \
5235                 .inputs    = mux_audio_sync_clk,        \
5236                 .reg       = 0x560 + (_index) * 4,      \
5237                 .max_rate  = 24000000,                  \
5238                 .ops       = &tegra_audio_sync_clk_ops  \
5239         }
5240
5241 static struct clk tegra_clk_audio_dmic_list[] = {
5242         AUDIO_SYNC_DMIC_CLK(audio0, tegra30-i2s.0, 0),
5243         AUDIO_SYNC_DMIC_CLK(audio1, tegra30-i2s.1, 1),
5244 };
5245
5246 #define MUX_AUDIO_DMIC(_id, _index)                                     \
5247 static struct clk_mux_sel mux_pllaout0_##_id##_dmic_pllp_clkm[] = {     \
5248         {.input = &tegra_pll_a_out0, .value = 0},                       \
5249         {.input = &tegra_clk_audio_dmic_list[(_index)], .value = 1},    \
5250         {.input = &tegra_pll_p, .value = 2},                            \
5251         {.input = &tegra_clk_m, .value = 3},                            \
5252         { 0, 0},                                                        \
5253 }
5254 MUX_AUDIO_DMIC(audio0, 0);
5255 MUX_AUDIO_DMIC(audio1, 1);
5256
5257
5258 /* External clock outputs (through PMC) */
5259 #define MUX_EXTERN_OUT(_id)                                             \
5260 static struct clk_mux_sel mux_clkm_clkm2_clkm4_extern##_id[] = {        \
5261         {.input = &tegra_osc,           .value = 0},                    \
5262         {.input = &tegra_osc_div2,      .value = 1},                    \
5263         {.input = &tegra_osc_div4,      .value = 2},                    \
5264         {.input = NULL,                 .value = 3}, /* placeholder */  \
5265         { 0, 0},                                                        \
5266 }
5267 MUX_EXTERN_OUT(1);
5268 MUX_EXTERN_OUT(2);
5269 MUX_EXTERN_OUT(3);
5270
5271 static struct clk_mux_sel *mux_extern_out_list[] = {
5272         mux_clkm_clkm2_clkm4_extern1,
5273         mux_clkm_clkm2_clkm4_extern2,
5274         mux_clkm_clkm2_clkm4_extern3,
5275 };
5276
5277 #define CLK_OUT_CLK(_id, _max_rate)                                     \
5278         {                                                       \
5279                 .name      = "clk_out_" #_id,                   \
5280                 .lookup    = {                                  \
5281                         .dev_id    = "clk_out_" #_id,           \
5282                         .con_id    = "extern" #_id,             \
5283                 },                                              \
5284                 .ops       = &tegra_clk_out_ops,                \
5285                 .reg       = 0x1a8,                             \
5286                 .inputs    = mux_clkm_clkm2_clkm4_extern##_id,  \
5287                 .flags     = MUX_CLK_OUT,                       \
5288                 .max_rate  = _max_rate,                         \
5289                 .u.periph = {                                   \
5290                         .clk_num   = (_id - 1) * 8 + 2,         \
5291                 },                                              \
5292         }
5293 static struct clk tegra_clk_out_list[] = {
5294         CLK_OUT_CLK(1, 38400000),
5295         CLK_OUT_CLK(2, 40800000),
5296         CLK_OUT_CLK(3, 38400000),
5297 };
5298
5299 /* called after peripheral external clocks are initialized */
5300 static void init_clk_out_mux(void)
5301 {
5302         int i;
5303         struct clk *c;
5304
5305         /* output clock con_id is the name of peripheral
5306            external clock connected to input 3 of the output mux */
5307         for (i = 0; i < ARRAY_SIZE(tegra_clk_out_list); i++) {
5308                 c = tegra_get_clock_by_name(
5309                         tegra_clk_out_list[i].lookup.con_id);
5310                 if (!c)
5311                         pr_err("%s: could not find clk %s\n", __func__,
5312                                tegra_clk_out_list[i].lookup.con_id);
5313                 mux_extern_out_list[i][3].input = c;
5314         }
5315 }
5316
5317 /* Peripheral muxes */
5318 static struct clk_mux_sel mux_cclk_g[] = {
5319         { .input = &tegra_clk_m,        .value = 0},
5320         { .input = &tegra_pll_c,        .value = 1},
5321         { .input = &tegra_clk_32k,      .value = 2},
5322         { .input = &tegra_pll_m,        .value = 3},
5323         { .input = &tegra_pll_p,        .value = 4},
5324         { .input = &tegra_pll_p_out4,   .value = 5},
5325         /* { .input = &tegra_pll_c2,    .value = 6}, - no use on tegra14x */
5326         /* { .input = &tegra_clk_c3,    .value = 7}, - no use on tegra14x */
5327         { .input = &tegra_pll_x,        .value = 8},
5328         { .input = &tegra_dfll_cpu,     .value = 15},
5329         { 0, 0},
5330 };
5331
5332 static struct clk_mux_sel mux_cclk_lp[] = {
5333         { .input = &tegra_clk_m,        .value = 0},
5334         { .input = &tegra_pll_c,        .value = 1},
5335         { .input = &tegra_clk_32k,      .value = 2},
5336         { .input = &tegra_pll_m,        .value = 3},
5337         { .input = &tegra_pll_p,        .value = 4},
5338         { .input = &tegra_pll_p_out4,   .value = 5},
5339         /* { .input = &tegra_pll_c2,    .value = 6}, - no use on tegra14x */
5340         /* { .input = &tegra_clk_c3,    .value = 7}, - no use on tegra14x */
5341         { .input = &tegra_pll_x_out0,   .value = 8},
5342 #if USE_LP_CPU_TO_TEST_DFLL
5343         { .input = &tegra_dfll_cpu,     .value = 15},
5344 #endif
5345         { .input = &tegra_pll_x,        .value = 8 | SUPER_LP_DIV2_BYPASS},
5346         { 0, 0},
5347 };
5348
5349 static struct clk_mux_sel mux_sclk[] = {
5350         { .input = &tegra_clk_m,        .value = 0},
5351         { .input = &tegra_pll_c_out1,   .value = 1},
5352         { .input = &tegra_pll_p_out4,   .value = 2},
5353         { .input = &tegra_pll_p,        .value = 3},
5354         { .input = &tegra_pll_p_out2,   .value = 4},
5355         { .input = &tegra_pll_c,        .value = 5},
5356         { .input = &tegra_clk_32k,      .value = 6},
5357         { .input = &tegra_pll_m_out1,   .value = 7},
5358         { 0, 0},
5359 };
5360
5361 static struct clk tegra_clk_cclk_g = {
5362         .name   = "cclk_g",
5363         .flags  = DIV_U71 | DIV_U71_INT | MUX,
5364         .inputs = mux_cclk_g,
5365         .reg    = 0x368,
5366         .ops    = &tegra_super_ops,
5367         .max_rate = 2000000000,
5368 };
5369
5370 static struct clk tegra_clk_cclk_lp = {
5371         .name   = "cclk_lp",
5372         .flags  = DIV_2 | DIV_U71 | DIV_U71_INT | MUX,
5373         .inputs = mux_cclk_lp,
5374         .reg    = 0x370,
5375         .ops    = &tegra_super_ops,
5376         .max_rate = 816000000,
5377 };
5378
5379 static struct clk tegra_clk_sclk = {
5380         .name   = "sclk",
5381         .inputs = mux_sclk,
5382         .reg    = 0x28,
5383         .ops    = &tegra_super_ops,
5384         .max_rate = 384000000,
5385         .min_rate = 12000000,
5386 };
5387
5388 static struct clk tegra_clk_virtual_cpu_g = {
5389         .name      = "cpu_g",
5390         .parent    = &tegra_clk_cclk_g,
5391         .ops       = &tegra_cpu_ops,
5392         .max_rate  = 2000000000,
5393         .u.cpu = {
5394                 .main      = &tegra_pll_x,
5395                 .backup    = &tegra_pll_p_out4,
5396                 .dynamic   = &tegra_dfll_cpu,
5397                 .mode      = MODE_G,
5398         },
5399 };
5400
5401 static struct clk tegra_clk_virtual_cpu_lp = {
5402         .name      = "cpu_lp",
5403         .parent    = &tegra_clk_cclk_lp,
5404         .ops       = &tegra_cpu_ops,
5405         .max_rate  = 816000000,
5406         .u.cpu = {
5407                 .main      = &tegra_pll_x,
5408                 .backup    = &tegra_pll_p_out4,
5409 #if USE_LP_CPU_TO_TEST_DFLL
5410                 .dynamic   = &tegra_dfll_cpu,
5411 #endif
5412                 .mode      = MODE_LP,
5413         },
5414 };
5415
5416 static struct clk_mux_sel mux_cpu_cmplx[] = {
5417         { .input = &tegra_clk_virtual_cpu_g,    .value = 0},
5418         { .input = &tegra_clk_virtual_cpu_lp,   .value = 1},
5419         { 0, 0},
5420 };
5421
5422 static struct clk tegra_clk_cpu_cmplx = {
5423         .name      = "cpu",
5424         .inputs    = mux_cpu_cmplx,
5425         .ops       = &tegra_cpu_cmplx_ops,
5426         .max_rate  = 2000000000,
5427 };
5428
5429 static struct clk tegra_clk_cop = {
5430         .name      = "cop",
5431         .parent    = &tegra_clk_sclk,
5432         .ops       = &tegra_cop_ops,
5433         .max_rate  = 384000000,
5434 };
5435
5436 static struct clk tegra_clk_hclk = {
5437         .name           = "hclk",
5438         .flags          = DIV_BUS,
5439         .parent         = &tegra_clk_sclk,
5440         .reg            = 0x30,
5441         .reg_shift      = 4,
5442         .ops            = &tegra_bus_ops,
5443         .max_rate       = 384000000,
5444         .min_rate       = 12000000,
5445 };
5446
5447 static struct clk tegra_clk_pclk = {
5448         .name           = "pclk",
5449         .flags          = DIV_BUS,
5450         .parent         = &tegra_clk_hclk,
5451         .reg            = 0x30,
5452         .reg_shift      = 0,
5453         .ops            = &tegra_bus_ops,
5454         .max_rate       = 192000000,
5455         .min_rate       = 12000000,
5456 };
5457
5458 static struct raw_notifier_head sbus_rate_change_nh;
5459
5460 static struct clk tegra_clk_sbus_cmplx = {
5461         .name      = "sbus",
5462         .parent    = &tegra_clk_sclk,
5463         .ops       = &tegra_sbus_cmplx_ops,
5464         .u.system  = {
5465                 .pclk = &tegra_clk_pclk,
5466                 .hclk = &tegra_clk_hclk,
5467                 .sclk_low = &tegra_pll_p_out2,
5468 #ifdef CONFIG_TEGRA_PLLM_SCALED
5469                 .sclk_high = &tegra_pll_c_out1,
5470 #else
5471                 .sclk_high = &tegra_pll_m_out1,
5472 #endif
5473         },
5474         .rate_change_nh = &sbus_rate_change_nh,
5475 };
5476
5477 static struct clk tegra_clk_blink = {
5478         .name           = "blink",
5479         .parent         = &tegra_clk_32k,
5480         .reg            = 0x40,
5481         .ops            = &tegra_blink_clk_ops,
5482         .max_rate       = 32768,
5483 };
5484
5485
5486 /* Multimedia modules muxes */
5487 static struct clk_mux_sel mux_pllm_pllc2_c_c3_pllp_plla[] = {
5488         { .input = &tegra_pll_m,  .value = 0},
5489         { .input = &tegra_pll_c2, .value = 1},
5490         { .input = &tegra_pll_c,  .value = 2},
5491         { .input = &tegra_pll_c3, .value = 3},
5492         { .input = &tegra_pll_p,  .value = 4},
5493         { .input = &tegra_pll_a_out0, .value = 6},
5494         { 0, 0},
5495 };
5496
5497 static struct clk_mux_sel mux_pllm_pllc_pllp_plla[] = {
5498         { .input = &tegra_pll_m, .value = 0},
5499         { .input = &tegra_pll_c, .value = 1},
5500         { .input = &tegra_pll_p, .value = 2},
5501         { .input = &tegra_pll_a_out0, .value = 3},
5502         { 0, 0},
5503 };
5504
5505 static struct clk_mux_sel mux_plla_pllc_pllp_clkm[] = {
5506         { .input = &tegra_pll_a_out0, .value = 0},
5507         { .input = &tegra_pll_c, .value = 1},
5508         { .input = &tegra_pll_p, .value = 2},
5509         { .input = &tegra_clk_m, .value = 3},
5510         { 0, 0},
5511 };
5512
5513 /* EMC muxes */
5514 /* FIXME: add EMC latency mux */
5515 static struct clk_mux_sel mux_pllm_pllc_pllp_clkm[] = {
5516         { .input = &tegra_pll_m, .value = 0},
5517         { .input = &tegra_pll_c, .value = 1},
5518         { .input = &tegra_pll_p, .value = 2},
5519         { .input = &tegra_clk_m, .value = 3},
5520         { .input = &tegra_pll_m, .value = 4}, /* low jitter PLLM input */
5521         /* { .input = &tegra_pll_c2, .value = 5}, - no use on tegra14x */
5522         /* { .input = &tegra_pll_c3, .value = 6}, - no use on tegra14x */
5523         { .input = &tegra_pll_c, .value = 7}, /* low jitter PLLM input */
5524         { 0, 0},
5525 };
5526
5527
5528 /* Display subsystem muxes */
5529 static struct clk_mux_sel mux_plld2[] = {
5530         {.input = &tegra_pll_d2_out0, .value = 5},
5531         { 0, 0},
5532 };
5533
5534 static struct clk_mux_sel mux_plld_plld2_clkm[] = {
5535         {.input = &tegra_pll_d_out0, .value = 2},
5536         {.input = &tegra_pll_d2_out0, .value = 5},
5537         {.input = &tegra_clk_m, .value = 6},
5538         { 0, 0},
5539 };
5540
5541 static struct clk_mux_sel mux_plld_out0_plld2_out0[] = {
5542         { .input = &tegra_pll_d_out0,  .value = 0},
5543         { .input = &tegra_pll_d2_out0, .value = 1},
5544         { 0, 0},
5545 };
5546
5547 static struct clk_mux_sel mux_pllp_pllc_clkm[] = {
5548         {.input = &tegra_pll_p,     .value = 0},
5549         {.input = &tegra_pll_c,     .value = 1},
5550         {.input = &tegra_clk_m,     .value = 3},
5551         { 0, 0},
5552 };
5553
5554 /* Peripheral muxes */
5555 static struct clk_mux_sel mux_pllp_pllc2_c_c3_pllm_clkm[] = {
5556         { .input = &tegra_pll_p,  .value = 0},
5557         { .input = &tegra_pll_c2, .value = 1},
5558         { .input = &tegra_pll_c,  .value = 2},
5559         { .input = &tegra_pll_c3, .value = 3},
5560         { .input = &tegra_pll_m,  .value = 4},
5561         { .input = &tegra_clk_m,  .value = 6},
5562         { 0, 0},
5563 };
5564
5565 static struct clk_mux_sel mux_pllp_pllc_pllm_clkm[] = {
5566         { .input = &tegra_pll_p, .value = 0},
5567         { .input = &tegra_pll_c, .value = 1},
5568         { .input = &tegra_pll_m, .value = 2},
5569         { .input = &tegra_clk_m, .value = 3},
5570         { 0, 0},
5571 };
5572
5573 static struct clk_mux_sel mux_pllp_clkm[] = {
5574         { .input = &tegra_pll_p, .value = 0},
5575         { .input = &tegra_clk_m, .value = 3},
5576         { 0, 0},
5577 };
5578
5579 static struct clk_mux_sel mux_pllp_pllc_clk32_clkm[] = {
5580         {.input = &tegra_pll_p,     .value = 0},
5581         {.input = &tegra_pll_c,     .value = 1},
5582         {.input = &tegra_clk_32k,   .value = 2},
5583         {.input = &tegra_clk_m,     .value = 3},
5584         { 0, 0},
5585 };
5586
5587 static struct clk_mux_sel mux_pllp_pllc_clkm_clk32[] = {
5588         {.input = &tegra_pll_p,     .value = 0},
5589         {.input = &tegra_pll_c,     .value = 1},
5590         {.input = &tegra_clk_m,     .value = 2},
5591         {.input = &tegra_clk_32k,   .value = 3},
5592         { 0, 0},
5593 };
5594
5595 static struct clk_mux_sel mux_plla_clk32_pllp_clkm[] = {
5596         { .input = &tegra_pll_a_out0, .value = 0},
5597         { .input = &tegra_clk_32k,    .value = 1},
5598         { .input = &tegra_pll_p,      .value = 2},
5599         { .input = &tegra_clk_m,      .value = 3},
5600         { 0, 0},
5601 };
5602
5603 static struct clk_mux_sel mux_pllp3_pllc_clkm[] = {
5604         { .input = &tegra_pll_p_out3, .value = 0},
5605         { .input = &tegra_pll_c,  .value = 1},
5606         { .input = &tegra_clk_m,  .value = 3},
5607         { 0, 0},
5608 };
5609
5610 /* Single clock source ("fake") muxes */
5611 static struct clk_mux_sel mux_clk_m[] = {
5612         { .input = &tegra_clk_m, .value = 0},
5613         { 0, 0},
5614 };
5615
5616 static struct clk_mux_sel mux_pllp_out3[] = {
5617         { .input = &tegra_pll_p_out3, .value = 0},
5618         { 0, 0},
5619 };
5620
5621 static struct clk_mux_sel mux_clk_32k[] = {
5622         { .input = &tegra_clk_32k, .value = 0},
5623         { 0, 0},
5624 };
5625
5626 static struct clk tegra_clk_emc;
5627 static struct clk_mux_sel mux_clk_emc[] = {
5628         { .input = &tegra_clk_emc, .value = 0},
5629         { 0, 0},
5630 };
5631
5632 static struct clk_mux_sel mux_pll_p[] = {
5633         { .input = &tegra_pll_p, .value = 0},
5634         { 0, 0},
5635 };
5636
5637 static struct raw_notifier_head emc_rate_change_nh;
5638
5639 static struct clk tegra_clk_emc = {
5640         .name = "emc",
5641         .ops = &tegra_emc_clk_ops,
5642         .reg = 0x19c,
5643         .max_rate = 1066000000,
5644         .min_rate = 12750000,
5645         .inputs = mux_pllm_pllc_pllp_clkm,
5646         .flags = MUX | MUX8 | DIV_U71 | PERIPH_EMC_ENB,
5647         .u.periph = {
5648                 .clk_num = 57,
5649         },
5650         .rate_change_nh = &emc_rate_change_nh,
5651 };
5652
5653 #ifdef CONFIG_TEGRA_DUAL_CBUS
5654
5655 static struct raw_notifier_head c2bus_rate_change_nh;
5656 static struct raw_notifier_head c3bus_rate_change_nh;
5657
5658 static struct clk tegra_clk_c2bus = {
5659         .name      = "c2bus",
5660         .parent    = &tegra_pll_c2,
5661         .ops       = &tegra_clk_cbus_ops,
5662         .max_rate  = 700000000,
5663         .mul       = 1,
5664         .div       = 1,
5665         .flags     = PERIPH_ON_CBUS,
5666         .shared_bus_backup = {
5667                 .input = &tegra_pll_p,
5668         },
5669         .rate_change_nh = &c2bus_rate_change_nh,
5670 };
5671 static struct clk tegra_clk_c3bus = {
5672         .name      = "c3bus",
5673         .parent    = &tegra_pll_c3,
5674         .ops       = &tegra_clk_cbus_ops,
5675         .max_rate  = 700000000,
5676         .mul       = 1,
5677         .div       = 1,
5678         .flags     = PERIPH_ON_CBUS,
5679         .shared_bus_backup = {
5680                 .input = &tegra_pll_p,
5681         },
5682         .rate_change_nh = &c3bus_rate_change_nh,
5683 };
5684
5685 #ifdef CONFIG_TEGRA_MIGRATE_CBUS_USERS
5686 static DEFINE_MUTEX(cbus_mutex);
5687 #define CROSS_CBUS_MUTEX (&cbus_mutex)
5688 #else
5689 #define CROSS_CBUS_MUTEX NULL
5690 #endif
5691
5692
5693 static struct clk_mux_sel mux_clk_cbus[] = {
5694         { .input = &tegra_clk_c2bus, .value = 0},
5695         { .input = &tegra_clk_c3bus, .value = 1},
5696         { 0, 0},
5697 };
5698
5699 #define DUAL_CBUS_CLK(_name, _dev, _con, _parent, _id, _div, _mode)\
5700         {                                               \
5701                 .name      = _name,                     \
5702                 .lookup    = {                          \
5703                         .dev_id    = _dev,              \
5704                         .con_id    = _con,              \
5705                 },                                      \
5706                 .ops = &tegra_clk_shared_bus_user_ops,  \
5707                 .parent = _parent,                      \
5708                 .inputs = mux_clk_cbus,                 \
5709                 .flags = MUX,                           \
5710                 .u.shared_bus_user = {                  \
5711                         .client_id = _id,               \
5712                         .client_div = _div,             \
5713                         .mode = _mode,                  \
5714                 },                                      \
5715                 .cross_clk_mutex = CROSS_CBUS_MUTEX,    \
5716         }
5717
5718 #else
5719
5720 static struct raw_notifier_head cbus_rate_change_nh;
5721
5722 static struct clk tegra_clk_cbus = {
5723         .name      = "cbus",
5724         .parent    = &tegra_pll_c,
5725         .ops       = &tegra_clk_cbus_ops,
5726         .max_rate  = 700000000,
5727         .mul       = 1,
5728         .div       = 2,
5729         .flags     = PERIPH_ON_CBUS,
5730         .shared_bus_backup = {
5731                 .input = &tegra_pll_p,
5732         },
5733         .rate_change_nh = &cbus_rate_change_nh,
5734 };
5735 #endif
5736
5737 #define PERIPH_CLK(_name, _dev, _con, _clk_num, _reg, _max, _inputs, _flags) \
5738         {                                               \
5739                 .name      = _name,                     \
5740                 .lookup    = {                          \
5741                         .dev_id    = _dev,              \
5742                         .con_id    = _con,              \
5743                 },                                      \
5744                 .ops       = &tegra_periph_clk_ops,     \
5745                 .reg       = _reg,                      \
5746                 .inputs    = _inputs,                   \
5747                 .flags     = _flags,                    \
5748                 .max_rate  = _max,                      \
5749                 .u.periph = {                           \
5750                         .clk_num   = _clk_num,          \
5751                 },                                      \
5752         }
5753
5754 #define PERIPH_CLK_EX(_name, _dev, _con, _clk_num, _reg, _max, _inputs, \
5755                         _flags, _ops)                                   \
5756         {                                               \
5757                 .name      = _name,                     \
5758                 .lookup    = {                          \
5759                         .dev_id    = _dev,              \
5760                         .con_id    = _con,              \
5761                 },                                      \
5762                 .ops       = _ops,                      \
5763                 .reg       = _reg,                      \
5764                 .inputs    = _inputs,                   \
5765                 .flags     = _flags,                    \
5766                 .max_rate  = _max,                      \
5767                 .u.periph = {                           \
5768                         .clk_num   = _clk_num,          \
5769                 },                                      \
5770         }
5771
5772 #define D_AUDIO_CLK(_name, _dev, _con, _clk_num, _reg, _max, _inputs, _flags) \
5773         {                                               \
5774                 .name      = _name,                     \
5775                 .lookup    = {                          \
5776                         .dev_id    = _dev,              \
5777                         .con_id    = _con,              \
5778                 },                                      \
5779                 .ops       = &tegra_periph_clk_ops,     \
5780                 .reg       = _reg,                      \
5781                 .inputs    = _inputs,                   \
5782                 .flags     = _flags,                    \
5783                 .max_rate  = _max,                      \
5784                 .u.periph = {                           \
5785                         .clk_num   = _clk_num,          \
5786                         .src_mask  = 0xE01F << 16,      \
5787                         .src_shift = 16,                \
5788                 },                                      \
5789         }
5790
5791 #define SHARED_CLK(_name, _dev, _con, _parent, _id, _div, _mode)\
5792         {                                               \
5793                 .name      = _name,                     \
5794                 .lookup    = {                          \
5795                         .dev_id    = _dev,              \
5796                         .con_id    = _con,              \
5797                 },                                      \
5798                 .ops = &tegra_clk_shared_bus_user_ops,  \
5799                 .parent = _parent,                      \
5800                 .u.shared_bus_user = {                  \
5801                         .client_id = _id,               \
5802                         .client_div = _div,             \
5803                         .mode = _mode,                  \
5804                 },                                      \
5805         }
5806 struct clk tegra_list_clks[] = {
5807         PERIPH_CLK("apbdma",    "tegra-dma",            NULL,   34,     0,      26000000,  mux_clk_m,                   0),
5808         PERIPH_CLK("rtc",       "rtc-tegra",            NULL,   4,      0,      32768,     mux_clk_32k,                 PERIPH_NO_RESET | PERIPH_ON_APB),
5809         PERIPH_CLK("kbc",       "tegra-kbc",            NULL,   36,     0,      32768,     mux_clk_32k,                 PERIPH_NO_RESET | PERIPH_ON_APB),
5810         PERIPH_CLK("timer",     "timer",                NULL,   5,      0,      26000000,  mux_clk_m,                   0),
5811         PERIPH_CLK("kfuse",     "kfuse-tegra",          NULL,   40,     0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
5812         PERIPH_CLK("fuse",      "fuse-tegra",           "fuse", 39,     0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
5813         PERIPH_CLK("fuse_burn", "fuse-tegra",           "fuse_burn",    39,     0,      26000000,  mux_clk_m,           PERIPH_ON_APB),
5814         PERIPH_CLK("apbif",     "tegra30-ahub",         "apbif", 107,   0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
5815         PERIPH_CLK("i2s0",      "tegra30-i2s.0",        NULL,   30,     0x1d8,  24576000,  mux_pllaout0_audio0_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
5816         PERIPH_CLK("i2s1",      "tegra30-i2s.1",        NULL,   11,     0x100,  24576000,  mux_pllaout0_audio1_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
5817         PERIPH_CLK("i2s2",      "tegra30-i2s.2",        NULL,   18,     0x104,  24576000,  mux_pllaout0_audio2_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
5818         PERIPH_CLK("i2s3",      "tegra30-i2s.3",        NULL,   101,    0x3bc,  24576000,  mux_pllaout0_audio3_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
5819         PERIPH_CLK("i2s4",      "tegra30-i2s.4",        NULL,   102,    0x3c0,  24576000,  mux_pllaout0_audio4_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
5820         PERIPH_CLK("dmic0",     "tegra30-i2s.0",        NULL,   160,    0x64c,  24576000,  mux_pllaout0_audio0_dmic_pllp_clkm,  MUX | DIV_U71 | PERIPH_ON_APB),
5821         PERIPH_CLK("dmic1",     "tegra30-i2s.0",        NULL,   161,    0x650,  24576000,  mux_pllaout0_audio1_dmic_pllp_clkm,  MUX | DIV_U71 | PERIPH_ON_APB),
5822         PERIPH_CLK("pwm",       "tegra-pwm",            NULL,   17,     0x110,  48000000, mux_pllp_pllc_clk32_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5823         D_AUDIO_CLK("d_audio",  "tegra30-ahub",         "d_audio",      106,    0x3d0,  48000000,  mux_d_audio_clk,     MUX | DIV_U71 | PERIPH_ON_APB),
5824         D_AUDIO_CLK("dam0",     "tegra30-dam.0",        NULL,   108,    0x3d8,  19910000,  mux_d_audio_clk,     MUX | DIV_U71 | PERIPH_ON_APB),
5825         D_AUDIO_CLK("dam1",     "tegra30-dam.1",        NULL,   109,    0x3dc,  19910000,  mux_d_audio_clk,     MUX | DIV_U71 | PERIPH_ON_APB),
5826         D_AUDIO_CLK("dam2",     "tegra30-dam.2",        NULL,   110,    0x3e0,  19910000,  mux_d_audio_clk,     MUX | DIV_U71 | PERIPH_ON_APB),
5827         PERIPH_CLK("adx",       "adx",                  NULL,   154,    0x638,  19910000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5828         PERIPH_CLK("amx",       "amx",                  NULL,   153,    0x63c,  19910000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5829         PERIPH_CLK("hda",       "tegra30-hda",          "hda",          125,    0x428,  48000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5830         PERIPH_CLK("hda2codec_2x",      "tegra30-hda",  "hda2codec",    111,    0x3e4,  48000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5831         PERIPH_CLK("hda2hdmi",  "tegra30-hda",          "hda2hdmi",     128,    0,      48000000,  mux_clk_m,                   PERIPH_ON_APB),
5832         PERIPH_CLK("sbc1",      "tegra11-spi.0",        NULL,   41,     0x134,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5833         PERIPH_CLK("sbc2",      "tegra11-spi.1",        NULL,   44,     0x118,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5834         PERIPH_CLK("sbc3",      "tegra11-spi.2",        NULL,   46,     0x11c,  52000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5835         PERIPH_CLK("sdmmc1",    "sdhci-tegra.0",        NULL,   14,     0x150,  208000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
5836         PERIPH_CLK("sdmmc3",    "sdhci-tegra.2",        NULL,   69,     0x1bc,  208000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
5837         PERIPH_CLK("sdmmc4",    "sdhci-tegra.3",        NULL,   15,     0x164,  200000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
5838         PERIPH_CLK("vcp",       "tegra-avp",            "vcp",  29,     0,      250000000, mux_clk_m,                   0),
5839         PERIPH_CLK("bsea",      "tegra-avp",            "bsea", 62,     0,      250000000, mux_clk_m,                   0),
5840         PERIPH_CLK("bsev",      "tegra-aes",            "bsev", 63,     0,      250000000, mux_clk_m,                   0),
5841         PERIPH_CLK("vde",       "vde",                  NULL,   61,     0x1c8,  600000000, mux_pllp_pllc2_c_c3_pllm_clkm,       MUX | MUX8 | DIV_U71 | DIV_U71_INT),
5842         PERIPH_CLK("csite",     "csite",                NULL,   73,     0x1d4,  144000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5843         PERIPH_CLK("la",        "la",                   NULL,   76,     0x1f8,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5844         PERIPH_CLK("trace",     "trace",                NULL,   77,     0x634,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5845         PERIPH_CLK("owr",       "tegra_w1",             NULL,   71,     0x1cc,  38400000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5846         PERIPH_CLK("mipibif",   "tegra-mipi-bif",       NULL,   173,    0x660,  60000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
5847         PERIPH_CLK("i2c1",      "tegra14-i2c.0",        "div-clk",      12,     0x124,  136000000, mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
5848         PERIPH_CLK("i2c2",      "tegra14-i2c.1",        "div-clk",      54,     0x198,  136000000, mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
5849         PERIPH_CLK("i2c3",      "tegra14-i2c.2",        "div-clk",      67,     0x1b8,  136000000, mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
5850         PERIPH_CLK("i2c4",      "tegra14-i2c.3",        "div-clk",      103,    0x3c4,  136000000, mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
5851         PERIPH_CLK("i2c5",      "tegra14-i2c.4",        "div-clk",      47,     0x128,  58300000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
5852         PERIPH_CLK("i2c6",      "tegra14-i2c.5",        "div-clk",      166,    0x65c,  136000000, mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
5853         PERIPH_CLK("mipi-cal",  "mipi-cal",             NULL,   56,     0,      60000000,  mux_clk_m,   0),
5854         PERIPH_CLK("uarta",     "tegra_uart.0",         NULL,   6,      0x178,  800000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
5855         PERIPH_CLK("uartb",     "tegra_uart.1",         NULL,   7,      0x17c,  800000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
5856         PERIPH_CLK("uartc",     "tegra_uart.2",         NULL,   55,     0x1a0,  800000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
5857         PERIPH_CLK("uartd",     "tegra_uart.3",         NULL,   65,     0x1c0,  800000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
5858         PERIPH_CLK("uarta_dbg", "serial8250.0",         "uarta", 6,     0x178,  408000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
5859         PERIPH_CLK("uartb_dbg", "serial8250.0",         "uartb", 7,     0x17c,  408000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
5860         PERIPH_CLK("uartc_dbg", "serial8250.0",         "uartc", 55,    0x1a0,  408000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
5861         PERIPH_CLK("uartd_dbg", "serial8250.0",         "uartd", 65,    0x1c0,  408000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
5862         PERIPH_CLK("3d",        "3d",                   NULL,   24,     0x158,  700000000, mux_pllm_pllc2_c_c3_pllp_plla,       MUX | MUX8 | DIV_U71 | DIV_U71_INT | DIV_U71_IDLE | PERIPH_MANUAL_RESET),
5863         PERIPH_CLK("2d&