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