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