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