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