ARM: tegra: resolve compilation time warnings
[linux-2.6.git] / arch / arm / mach-tegra / tegra30_clocks.c
1 /*
2  * arch/arm/mach-tegra/tegra3_clocks.c
3  *
4  * Copyright (C) 2010-2012 NVIDIA Corporation
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; version 2 of the License.
9  *
10  * This program is distributed in the hope that it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
18  *
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/list.h>
24 #include <linux/spinlock.h>
25 #include <linux/delay.h>
26 #include <linux/err.h>
27 #include <linux/io.h>
28 #include <linux/clk.h>
29 #include <linux/cpufreq.h>
30 #include <linux/syscore_ops.h>
31
32 #include <asm/clkdev.h>
33
34 #include <mach/iomap.h>
35 #include <mach/edp.h>
36 #include <mach/hardware.h>
37
38 #include "clock.h"
39 #include "fuse.h"
40 #include "dvfs.h"
41 #include "pm.h"
42 #include "sleep.h"
43 #include "tegra3_emc.h"
44
45 #define RST_DEVICES_L                   0x004
46 #define RST_DEVICES_H                   0x008
47 #define RST_DEVICES_U                   0x00C
48 #define RST_DEVICES_V                   0x358
49 #define RST_DEVICES_W                   0x35C
50 #define RST_DEVICES_SET_L               0x300
51 #define RST_DEVICES_CLR_L               0x304
52 #define RST_DEVICES_SET_V               0x430
53 #define RST_DEVICES_CLR_V               0x434
54 #define RST_DEVICES_NUM                 5
55
56 #define CLK_OUT_ENB_L                   0x010
57 #define CLK_OUT_ENB_H                   0x014
58 #define CLK_OUT_ENB_U                   0x018
59 #define CLK_OUT_ENB_V                   0x360
60 #define CLK_OUT_ENB_W                   0x364
61 #define CLK_OUT_ENB_SET_L               0x320
62 #define CLK_OUT_ENB_CLR_L               0x324
63 #define CLK_OUT_ENB_SET_V               0x440
64 #define CLK_OUT_ENB_CLR_V               0x444
65 #define CLK_OUT_ENB_NUM                 5
66
67 #define RST_DEVICES_V_SWR_CPULP_RST_DIS (0x1 << 1)
68 #define CLK_OUT_ENB_V_CLK_ENB_CPULP_EN  (0x1 << 1)
69
70 #define PERIPH_CLK_TO_BIT(c)            (1 << (c->u.periph.clk_num % 32))
71 #define PERIPH_CLK_TO_RST_REG(c)        \
72         periph_clk_to_reg((c), RST_DEVICES_L, RST_DEVICES_V, 4)
73 #define PERIPH_CLK_TO_RST_SET_REG(c)    \
74         periph_clk_to_reg((c), RST_DEVICES_SET_L, RST_DEVICES_SET_V, 8)
75 #define PERIPH_CLK_TO_RST_CLR_REG(c)    \
76         periph_clk_to_reg((c), RST_DEVICES_CLR_L, RST_DEVICES_CLR_V, 8)
77
78 #define PERIPH_CLK_TO_ENB_REG(c)        \
79         periph_clk_to_reg((c), CLK_OUT_ENB_L, CLK_OUT_ENB_V, 4)
80 #define PERIPH_CLK_TO_ENB_SET_REG(c)    \
81         periph_clk_to_reg((c), CLK_OUT_ENB_SET_L, CLK_OUT_ENB_SET_V, 8)
82 #define PERIPH_CLK_TO_ENB_CLR_REG(c)    \
83         periph_clk_to_reg((c), CLK_OUT_ENB_CLR_L, CLK_OUT_ENB_CLR_V, 8)
84
85 #define CLK_MASK_ARM                    0x44
86 #define MISC_CLK_ENB                    0x48
87
88 #define OSC_CTRL                        0x50
89 #define OSC_CTRL_OSC_FREQ_MASK          (0xF<<28)
90 #define OSC_CTRL_OSC_FREQ_13MHZ         (0x0<<28)
91 #define OSC_CTRL_OSC_FREQ_19_2MHZ       (0x4<<28)
92 #define OSC_CTRL_OSC_FREQ_12MHZ         (0x8<<28)
93 #define OSC_CTRL_OSC_FREQ_26MHZ         (0xC<<28)
94 #define OSC_CTRL_OSC_FREQ_16_8MHZ       (0x1<<28)
95 #define OSC_CTRL_OSC_FREQ_38_4MHZ       (0x5<<28)
96 #define OSC_CTRL_OSC_FREQ_48MHZ         (0x9<<28)
97 #define OSC_CTRL_MASK                   (0x3f2 | OSC_CTRL_OSC_FREQ_MASK)
98
99 #define OSC_CTRL_PLL_REF_DIV_MASK       (3<<26)
100 #define OSC_CTRL_PLL_REF_DIV_1          (0<<26)
101 #define OSC_CTRL_PLL_REF_DIV_2          (1<<26)
102 #define OSC_CTRL_PLL_REF_DIV_4          (2<<26)
103
104 #define PERIPH_CLK_SOURCE_I2S1          0x100
105 #define PERIPH_CLK_SOURCE_EMC           0x19c
106 #define PERIPH_CLK_SOURCE_OSC           0x1fc
107 #define PERIPH_CLK_SOURCE_NUM1 \
108         ((PERIPH_CLK_SOURCE_OSC - PERIPH_CLK_SOURCE_I2S1) / 4)
109
110 #define PERIPH_CLK_SOURCE_G3D2          0x3b0
111 #define PERIPH_CLK_SOURCE_SE            0x42c
112 #define PERIPH_CLK_SOURCE_NUM2 \
113         ((PERIPH_CLK_SOURCE_SE - PERIPH_CLK_SOURCE_G3D2) / 4 + 1)
114
115 #define AUDIO_DLY_CLK                   0x49c
116 #define AUDIO_SYNC_CLK_SPDIF            0x4b4
117 #define PERIPH_CLK_SOURCE_NUM3 \
118         ((AUDIO_SYNC_CLK_SPDIF - AUDIO_DLY_CLK) / 4 + 1)
119
120 #define PERIPH_CLK_SOURCE_NUM           (PERIPH_CLK_SOURCE_NUM1 + \
121                                          PERIPH_CLK_SOURCE_NUM2 + \
122                                          PERIPH_CLK_SOURCE_NUM3)
123
124 #define CPU_SOFTRST_CTRL                0x380
125
126 #define PERIPH_CLK_SOURCE_DIVU71_MASK   0xFF
127 #define PERIPH_CLK_SOURCE_DIVU16_MASK   0xFFFF
128 #define PERIPH_CLK_SOURCE_DIV_SHIFT     0
129 #define PERIPH_CLK_SOURCE_DIVIDLE_SHIFT 8
130 #define PERIPH_CLK_SOURCE_DIVIDLE_VAL   50
131 #define PERIPH_CLK_UART_DIV_ENB         (1<<24)
132 #define PERIPH_CLK_VI_SEL_EX_SHIFT      24
133 #define PERIPH_CLK_VI_SEL_EX_MASK       (0x3<<PERIPH_CLK_VI_SEL_EX_SHIFT)
134 #define PERIPH_CLK_NAND_DIV_EX_ENB      (1<<8)
135 #define PERIPH_CLK_DTV_POLARITY_INV     (1<<25)
136
137 #define AUDIO_SYNC_SOURCE_MASK          0x0F
138 #define AUDIO_SYNC_DISABLE_BIT          0x10
139 #define AUDIO_SYNC_TAP_NIBBLE_SHIFT(c)  ((c->reg_shift - 24) * 4)
140
141 #define PLL_BASE                        0x0
142 #define PLL_BASE_BYPASS                 (1<<31)
143 #define PLL_BASE_ENABLE                 (1<<30)
144 #define PLL_BASE_REF_ENABLE             (1<<29)
145 #define PLL_BASE_OVERRIDE               (1<<28)
146 #define PLL_BASE_LOCK                   (1<<27)
147 #define PLL_BASE_DIVP_MASK              (0x7<<20)
148 #define PLL_BASE_DIVP_SHIFT             20
149 #define PLL_BASE_DIVN_MASK              (0x3FF<<8)
150 #define PLL_BASE_DIVN_SHIFT             8
151 #define PLL_BASE_DIVM_MASK              (0x1F)
152 #define PLL_BASE_DIVM_SHIFT             0
153
154 #define PLL_OUT_RATIO_MASK              (0xFF<<8)
155 #define PLL_OUT_RATIO_SHIFT             8
156 #define PLL_OUT_OVERRIDE                (1<<2)
157 #define PLL_OUT_CLKEN                   (1<<1)
158 #define PLL_OUT_RESET_DISABLE           (1<<0)
159
160 #define PLL_MISC(c)                     \
161         (((c)->flags & PLL_ALT_MISC_REG) ? 0x4 : 0xc)
162 #define PLL_MISC_LOCK_ENABLE(c) \
163         (((c)->flags & (PLLU | PLLD)) ? (1<<22) : (1<<18))
164
165 #define PLL_MISC_DCCON_SHIFT            20
166 #define PLL_MISC_CPCON_SHIFT            8
167 #define PLL_MISC_CPCON_MASK             (0xF<<PLL_MISC_CPCON_SHIFT)
168 #define PLL_MISC_LFCON_SHIFT            4
169 #define PLL_MISC_LFCON_MASK             (0xF<<PLL_MISC_LFCON_SHIFT)
170 #define PLL_MISC_VCOCON_SHIFT           0
171 #define PLL_MISC_VCOCON_MASK            (0xF<<PLL_MISC_VCOCON_SHIFT)
172 #define PLLD_MISC_CLKENABLE             (1<<30)
173
174 #define PLLU_BASE_POST_DIV              (1<<20)
175
176 #define PLLD_BASE_DSIB_MUX_SHIFT        25
177 #define PLLD_BASE_DSIB_MUX_MASK         (1<<PLLD_BASE_DSIB_MUX_SHIFT)
178 #define PLLD_BASE_CSI_CLKENABLE         (1<<26)
179 #define PLLD_MISC_DSI_CLKENABLE         (1<<30)
180 #define PLLD_MISC_DIV_RST               (1<<23)
181 #define PLLD_MISC_DCCON_SHIFT           12
182
183 #define PLLDU_LFCON_SET_DIVN            600
184
185 /* FIXME: OUT_OF_TABLE_CPCON per pll */
186 #define OUT_OF_TABLE_CPCON              0x8
187
188 #define SUPER_CLK_MUX                   0x00
189 #define SUPER_STATE_SHIFT               28
190 #define SUPER_STATE_MASK                (0xF << SUPER_STATE_SHIFT)
191 #define SUPER_STATE_STANDBY             (0x0 << SUPER_STATE_SHIFT)
192 #define SUPER_STATE_IDLE                (0x1 << SUPER_STATE_SHIFT)
193 #define SUPER_STATE_RUN                 (0x2 << SUPER_STATE_SHIFT)
194 #define SUPER_STATE_IRQ                 (0x3 << SUPER_STATE_SHIFT)
195 #define SUPER_STATE_FIQ                 (0x4 << SUPER_STATE_SHIFT)
196 #define SUPER_LP_DIV2_BYPASS            (0x1 << 16)
197 #define SUPER_SOURCE_MASK               0xF
198 #define SUPER_FIQ_SOURCE_SHIFT          12
199 #define SUPER_IRQ_SOURCE_SHIFT          8
200 #define SUPER_RUN_SOURCE_SHIFT          4
201 #define SUPER_IDLE_SOURCE_SHIFT         0
202
203 #define SUPER_CLK_DIVIDER               0x04
204 #define SUPER_CLOCK_SKIP_ENABLE         (0x1 << 31)
205 #define SUPER_CLOCK_DIV_U71_SHIFT       16
206 #define SUPER_CLOCK_DIV_U71_MASK        (0xff << SUPER_CLOCK_DIV_U71_SHIFT)
207 #define SUPER_CLOCK_SKIP_MUL_SHIFT      8
208 #define SUPER_CLOCK_SKIP_MUL_MASK       (0xff << SUPER_CLOCK_SKIP_MUL_SHIFT)
209 #define SUPER_CLOCK_SKIP_DIV_SHIFT      0
210 #define SUPER_CLOCK_SKIP_DIV_MASK       (0xff << SUPER_CLOCK_SKIP_DIV_SHIFT)
211 #define SUPER_CLOCK_SKIP_MASK           \
212         (SUPER_CLOCK_SKIP_MUL_MASK | SUPER_CLOCK_SKIP_DIV_MASK)
213 #define SUPER_CLOCK_SKIP_TERM_MAX       256
214
215 #define BUS_CLK_DISABLE                 (1<<3)
216 #define BUS_CLK_DIV_MASK                0x3
217
218 #define PMC_CTRL                        0x0
219  #define PMC_CTRL_BLINK_ENB             (1 << 7)
220
221 #define PMC_DPD_PADS_ORIDE              0x1c
222  #define PMC_DPD_PADS_ORIDE_BLINK_ENB   (1 << 20)
223
224 #define PMC_BLINK_TIMER_DATA_ON_SHIFT   0
225 #define PMC_BLINK_TIMER_DATA_ON_MASK    0x7fff
226 #define PMC_BLINK_TIMER_ENB             (1 << 15)
227 #define PMC_BLINK_TIMER_DATA_OFF_SHIFT  16
228 #define PMC_BLINK_TIMER_DATA_OFF_MASK   0xffff
229
230 #define PMC_PLLP_WB0_OVERRIDE                           0xf8
231 #define PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE               (1 << 12)
232
233 #define UTMIP_PLL_CFG2                                  0x488
234 #define UTMIP_PLL_CFG2_STABLE_COUNT(x)                  (((x) & 0xfff) << 6)
235 #define UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(x)              (((x) & 0x3f) << 18)
236 #define UTMIP_PLL_CFG2_FORCE_PD_SAMP_A_POWERDOWN        (1 << 0)
237 #define UTMIP_PLL_CFG2_FORCE_PD_SAMP_B_POWERDOWN        (1 << 2)
238 #define UTMIP_PLL_CFG2_FORCE_PD_SAMP_C_POWERDOWN        (1 << 4)
239
240 #define UTMIP_PLL_CFG1                                  0x484
241 #define UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(x)              (((x) & 0x1f) << 27)
242 #define UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(x)               (((x) & 0xfff) << 0)
243 #define UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN       (1 << 14)
244 #define UTMIP_PLL_CFG1_FORCE_PLL_ACTIVE_POWERDOWN       (1 << 12)
245 #define UTMIP_PLL_CFG1_FORCE_PLLU_POWERDOWN             (1 << 16)
246
247 #define PLLE_BASE_CML_ENABLE            (1<<31)
248 #define PLLE_BASE_ENABLE                (1<<30)
249 #define PLLE_BASE_DIVCML_SHIFT          24
250 #define PLLE_BASE_DIVCML_MASK           (0xf<<PLLE_BASE_DIVCML_SHIFT)
251 #define PLLE_BASE_DIVP_SHIFT            16
252 #define PLLE_BASE_DIVP_MASK             (0x3f<<PLLE_BASE_DIVP_SHIFT)
253 #define PLLE_BASE_DIVN_SHIFT            8
254 #define PLLE_BASE_DIVN_MASK             (0xFF<<PLLE_BASE_DIVN_SHIFT)
255 #define PLLE_BASE_DIVM_SHIFT            0
256 #define PLLE_BASE_DIVM_MASK             (0xFF<<PLLE_BASE_DIVM_SHIFT)
257 #define PLLE_BASE_DIV_MASK              \
258         (PLLE_BASE_DIVCML_MASK | PLLE_BASE_DIVP_MASK | \
259          PLLE_BASE_DIVN_MASK | PLLE_BASE_DIVM_MASK)
260 #define PLLE_BASE_DIV(m, n, p, cml)             \
261          (((cml)<<PLLE_BASE_DIVCML_SHIFT) | ((p)<<PLLE_BASE_DIVP_SHIFT) | \
262           ((n)<<PLLE_BASE_DIVN_SHIFT) | ((m)<<PLLE_BASE_DIVM_SHIFT))
263
264 #define PLLE_MISC_SETUP_BASE_SHIFT      16
265 #define PLLE_MISC_SETUP_BASE_MASK       (0xFFFF<<PLLE_MISC_SETUP_BASE_SHIFT)
266 #define PLLE_MISC_READY                 (1<<15)
267 #define PLLE_MISC_LOCK                  (1<<11)
268 #define PLLE_MISC_LOCK_ENABLE           (1<<9)
269 #define PLLE_MISC_SETUP_EX_SHIFT        2
270 #define PLLE_MISC_SETUP_EX_MASK         (0x3<<PLLE_MISC_SETUP_EX_SHIFT)
271 #define PLLE_MISC_SETUP_MASK            \
272           (PLLE_MISC_SETUP_BASE_MASK | PLLE_MISC_SETUP_EX_MASK)
273 #define PLLE_MISC_SETUP_VALUE           \
274           ((0x7<<PLLE_MISC_SETUP_BASE_SHIFT) | (0x0<<PLLE_MISC_SETUP_EX_SHIFT))
275
276 #define PLLE_SS_CTRL                    0x68
277 #define PLLE_SS_INCINTRV_SHIFT          24
278 #define PLLE_SS_INCINTRV_MASK           (0x3f<<PLLE_SS_INCINTRV_SHIFT)
279 #define PLLE_SS_INC_SHIFT               16
280 #define PLLE_SS_INC_MASK                (0xff<<PLLE_SS_INC_SHIFT)
281 #define PLLE_SS_MAX_SHIFT               0
282 #define PLLE_SS_MAX_MASK                (0x1ff<<PLLE_SS_MAX_SHIFT)
283 #define PLLE_SS_COEFFICIENTS_MASK       \
284         (PLLE_SS_INCINTRV_MASK | PLLE_SS_INC_MASK | PLLE_SS_MAX_MASK)
285 #define PLLE_SS_COEFFICIENTS_12MHZ      \
286         ((0x18<<PLLE_SS_INCINTRV_SHIFT) | (0x1<<PLLE_SS_INC_SHIFT) | \
287          (0x24<<PLLE_SS_MAX_SHIFT))
288 #define PLLE_SS_DISABLE                 ((1<<12) | (1<<11) | (1<<10))
289
290 #define PLLE_AUX                        0x48c
291 #define PLLE_AUX_PLLP_SEL               (1<<2)
292 #define PLLE_AUX_CML_SATA_ENABLE        (1<<1)
293 #define PLLE_AUX_CML_PCIE_ENABLE        (1<<0)
294
295 #define PMC_SATA_PWRGT                  0x1ac
296 #define PMC_SATA_PWRGT_PLLE_IDDQ_VALUE  (1<<5)
297 #define PMC_SATA_PWRGT_PLLE_IDDQ_SWCTL  (1<<4)
298
299 #define ROUND_DIVIDER_UP        0
300 #define ROUND_DIVIDER_DOWN      1
301
302 /* PLLP default fixed rate in h/w controlled mode */
303 #define PLLP_DEFAULT_FIXED_RATE         216000000
304
305 /* Threshold to engage CPU clock skipper during CPU rate change */
306 #define SKIPPER_ENGAGE_RATE              800000000
307
308 static void tegra3_pllp_init_dependencies(unsigned long pllp_rate);
309 static int tegra3_clk_shared_bus_update(struct clk *bus);
310
311 static unsigned long cpu_stay_on_backup_max;
312 static struct clk *emc_bridge;
313
314 static bool detach_shared_bus;
315 module_param(detach_shared_bus, bool, 0644);
316
317 static int skipper_delay = 10;
318 module_param(skipper_delay, int, 0644);
319
320 void tegra3_set_cpu_skipper_delay(int delay)
321 {
322         skipper_delay = delay;
323 }
324
325 /**
326 * Structure defining the fields for USB UTMI clocks Parameters.
327 */
328 struct utmi_clk_param
329 {
330         /* Oscillator Frequency in KHz */
331         u32 osc_frequency;
332         /* UTMIP PLL Enable Delay Count  */
333         u8 enable_delay_count;
334         /* UTMIP PLL Stable count */
335         u8 stable_count;
336         /*  UTMIP PLL Active delay count */
337         u8 active_delay_count;
338         /* UTMIP PLL Xtal frequency count */
339         u8 xtal_freq_count;
340 };
341
342 static const struct utmi_clk_param utmi_parameters[] =
343 {
344 /*      OSC_FREQUENCY,  ENABLE_DLY,     STABLE_CNT,     ACTIVE_DLY,     XTAL_FREQ_CNT */
345         {13000000,      0x02,           0x33,           0x05,           0x7F},
346         {19200000,      0x03,           0x4B,           0x06,           0xBB},
347         {12000000,      0x02,           0x2F,           0x04,           0x76},
348         {26000000,      0x04,           0x66,           0x09,           0xFE},
349         {16800000,      0x03,           0x41,           0x0A,           0xA4},
350 };
351
352 static void __iomem *reg_clk_base = IO_ADDRESS(TEGRA_CLK_RESET_BASE);
353 static void __iomem *reg_pmc_base = IO_ADDRESS(TEGRA_PMC_BASE);
354 static void __iomem *misc_gp_hidrev_base = IO_ADDRESS(TEGRA_APB_MISC_BASE);
355
356 #define MISC_GP_HIDREV                  0x804
357
358 /*
359  * Some peripheral clocks share an enable bit, so refcount the enable bits
360  * in registers CLK_ENABLE_L, ... CLK_ENABLE_W, and protect refcount updates
361  * with lock
362  */
363 static DEFINE_SPINLOCK(periph_refcount_lock);
364 static int tegra_periph_clk_enable_refcount[CLK_OUT_ENB_NUM * 32];
365
366 #define clk_writel(value, reg) \
367         __raw_writel(value, reg_clk_base + (reg))
368 #define clk_readl(reg) \
369         __raw_readl(reg_clk_base + (reg))
370 #define pmc_writel(value, reg) \
371         __raw_writel(value, reg_pmc_base + (reg))
372 #define pmc_readl(reg) \
373         __raw_readl(reg_pmc_base + (reg))
374 #define chipid_readl() \
375         __raw_readl(misc_gp_hidrev_base + MISC_GP_HIDREV)
376
377 #define clk_writel_delay(value, reg)                                    \
378         do {                                                            \
379                 __raw_writel((value), reg_clk_base + (reg));    \
380                 udelay(2);                                              \
381         } while (0)
382
383
384 static inline int clk_set_div(struct clk *c, u32 n)
385 {
386         return clk_set_rate(c, (clk_get_rate(c->parent) + n-1) / n);
387 }
388
389 static inline u32 periph_clk_to_reg(
390         struct clk *c, u32 reg_L, u32 reg_V, int offs)
391 {
392         u32 reg = c->u.periph.clk_num / 32;
393         BUG_ON(reg >= RST_DEVICES_NUM);
394         if (reg < 3) {
395                 reg = reg_L + (reg * offs);
396         } else {
397                 reg = reg_V + ((reg - 3) * offs);
398         }
399         return reg;
400 }
401
402 static int clk_div_x1_get_divider(unsigned long parent_rate, unsigned long rate,
403                         u32 max_x, u32 flags, u32 round_mode)
404 {
405         s64 divider_ux1 = parent_rate;
406         if (!rate)
407                 return -EINVAL;
408
409         if (!(flags & DIV_U71_INT))
410                 divider_ux1 *= 2;
411
412         if (round_mode == ROUND_DIVIDER_UP)
413                 divider_ux1 += rate - 1;
414         do_div(divider_ux1, rate);
415
416         if (flags & DIV_U71_INT)
417                 divider_ux1 *= 2;
418
419         if (divider_ux1 - 2 < 0)
420                 return 0;
421
422         if (divider_ux1 - 2 > max_x)
423                 return -EINVAL;
424
425         return divider_ux1 - 2;
426 }
427
428 static int clk_div71_get_divider(unsigned long parent_rate, unsigned long rate,
429                                  u32 flags, u32 round_mode)
430 {
431         return clk_div_x1_get_divider(parent_rate, rate, 0xFF,
432                         flags, round_mode);
433 }
434
435 static int clk_div151_get_divider(unsigned long parent_rate, unsigned long rate,
436                                  u32 flags, u32 round_mode)
437 {
438         return clk_div_x1_get_divider(parent_rate, rate, 0xFFFF,
439                         flags, round_mode);
440 }
441
442 static int clk_div16_get_divider(unsigned long parent_rate, unsigned long rate)
443 {
444         s64 divider_u16;
445
446         divider_u16 = parent_rate;
447         if (!rate)
448                 return -EINVAL;
449         divider_u16 += rate - 1;
450         do_div(divider_u16, rate);
451
452         if (divider_u16 - 1 < 0)
453                 return 0;
454
455         if (divider_u16 - 1 > 0xFFFF)
456                 return -EINVAL;
457
458         return divider_u16 - 1;
459 }
460
461 /* clk_m functions */
462 static unsigned long tegra3_clk_m_autodetect_rate(struct clk *c)
463 {
464         u32 osc_ctrl = clk_readl(OSC_CTRL);
465         u32 auto_clock_control = osc_ctrl & ~OSC_CTRL_OSC_FREQ_MASK;
466         u32 pll_ref_div = osc_ctrl & OSC_CTRL_PLL_REF_DIV_MASK;
467
468         c->rate = tegra_clk_measure_input_freq();
469         switch (c->rate) {
470         case 12000000:
471                 auto_clock_control |= OSC_CTRL_OSC_FREQ_12MHZ;
472                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
473                 break;
474         case 13000000:
475                 auto_clock_control |= OSC_CTRL_OSC_FREQ_13MHZ;
476                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
477                 break;
478         case 19200000:
479                 auto_clock_control |= OSC_CTRL_OSC_FREQ_19_2MHZ;
480                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
481                 break;
482         case 26000000:
483                 auto_clock_control |= OSC_CTRL_OSC_FREQ_26MHZ;
484                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
485                 break;
486         case 16800000:
487                 auto_clock_control |= OSC_CTRL_OSC_FREQ_16_8MHZ;
488                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_1);
489                 break;
490         case 38400000:
491                 auto_clock_control |= OSC_CTRL_OSC_FREQ_38_4MHZ;
492                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_2);
493                 break;
494         case 48000000:
495                 auto_clock_control |= OSC_CTRL_OSC_FREQ_48MHZ;
496                 BUG_ON(pll_ref_div != OSC_CTRL_PLL_REF_DIV_4);
497                 break;
498         default:
499                 pr_err("%s: Unexpected clock rate %ld", __func__, c->rate);
500                 BUG();
501         }
502         clk_writel(auto_clock_control, OSC_CTRL);
503         return c->rate;
504 }
505
506 static void tegra3_clk_m_init(struct clk *c)
507 {
508         pr_debug("%s on clock %s\n", __func__, c->name);
509         tegra3_clk_m_autodetect_rate(c);
510 }
511
512 static int tegra3_clk_m_enable(struct clk *c)
513 {
514         pr_debug("%s on clock %s\n", __func__, c->name);
515         return 0;
516 }
517
518 static void tegra3_clk_m_disable(struct clk *c)
519 {
520         pr_debug("%s on clock %s\n", __func__, c->name);
521         WARN(1, "Attempting to disable main SoC clock\n");
522 }
523
524 static struct clk_ops tegra_clk_m_ops = {
525         .init           = tegra3_clk_m_init,
526         .enable         = tegra3_clk_m_enable,
527         .disable        = tegra3_clk_m_disable,
528 };
529
530 static struct clk_ops tegra_clk_m_div_ops = {
531         .enable         = tegra3_clk_m_enable,
532 };
533
534 /* PLL reference divider functions */
535 static void tegra3_pll_ref_init(struct clk *c)
536 {
537         u32 pll_ref_div = clk_readl(OSC_CTRL) & OSC_CTRL_PLL_REF_DIV_MASK;
538         pr_debug("%s on clock %s\n", __func__, c->name);
539
540         switch (pll_ref_div) {
541         case OSC_CTRL_PLL_REF_DIV_1:
542                 c->div = 1;
543                 break;
544         case OSC_CTRL_PLL_REF_DIV_2:
545                 c->div = 2;
546                 break;
547         case OSC_CTRL_PLL_REF_DIV_4:
548                 c->div = 4;
549                 break;
550         default:
551                 pr_err("%s: Invalid pll ref divider %d", __func__, pll_ref_div);
552                 BUG();
553         }
554         c->mul = 1;
555         c->state = ON;
556 }
557
558 static struct clk_ops tegra_pll_ref_ops = {
559         .init           = tegra3_pll_ref_init,
560         .enable         = tegra3_clk_m_enable,
561         .disable        = tegra3_clk_m_disable,
562 };
563
564 /* super clock functions */
565 /* "super clocks" on tegra3 have two-stage muxes, fractional 7.1 divider and
566  * clock skipping super divider.  We will ignore the clock skipping divider,
567  * since we can't lower the voltage when using the clock skip, but we can if
568  * we lower the PLL frequency. We will use 7.1 divider for CPU super-clock
569  * only when its parent is a fixed rate PLL, since we can't change PLL rate
570  * in this case.
571  */
572 static void tegra3_super_clk_init(struct clk *c)
573 {
574         u32 val;
575         int source;
576         int shift;
577         const struct clk_mux_sel *sel;
578
579         val = clk_readl(c->reg + SUPER_CLK_MUX);
580         c->state = ON;
581         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
582                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
583         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
584                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
585         source = (val >> shift) & SUPER_SOURCE_MASK;
586         if (c->flags & DIV_2)
587                 source |= val & SUPER_LP_DIV2_BYPASS;
588         for (sel = c->inputs; sel->input != NULL; sel++) {
589                 if (sel->value == source)
590                         break;
591         }
592         BUG_ON(sel->input == NULL);
593         c->parent = sel->input;
594
595         if (c->flags & DIV_U71) {
596                 /* Init safe 7.1 divider value (does not affect PLLX path).
597                    Super skipper is enabled to be ready for emergency throttle,
598                    but set 1:1 */
599                 c->mul = 2;
600                 c->div = 2;
601                 if (!(c->parent->flags & PLLX)) {
602                         val = clk_readl(c->reg + SUPER_CLK_DIVIDER);
603                         val &= SUPER_CLOCK_DIV_U71_MASK;
604                         val >>= SUPER_CLOCK_DIV_U71_SHIFT;
605                         val = max(val, c->u.cclk.div71);
606                         c->u.cclk.div71 = val;
607                         c->div += val;
608                 }
609                 val = SUPER_CLOCK_SKIP_ENABLE +
610                         (c->u.cclk.div71 << SUPER_CLOCK_DIV_U71_SHIFT);
611                 clk_writel(val, c->reg + SUPER_CLK_DIVIDER);
612         }
613         else
614                 clk_writel(0, c->reg + SUPER_CLK_DIVIDER);
615 }
616
617 static int tegra3_super_clk_enable(struct clk *c)
618 {
619         return 0;
620 }
621
622 static void tegra3_super_clk_disable(struct clk *c)
623 {
624         /* since tegra 3 has 2 CPU super clocks - low power lp-mode clock and
625            geared up g-mode super clock - mode switch may request to disable
626            either of them; accept request with no affect on h/w */
627 }
628
629 static int tegra3_super_clk_set_parent(struct clk *c, struct clk *p)
630 {
631         u32 val;
632         const struct clk_mux_sel *sel;
633         int shift;
634
635         val = clk_readl(c->reg + SUPER_CLK_MUX);;
636         BUG_ON(((val & SUPER_STATE_MASK) != SUPER_STATE_RUN) &&
637                 ((val & SUPER_STATE_MASK) != SUPER_STATE_IDLE));
638         shift = ((val & SUPER_STATE_MASK) == SUPER_STATE_IDLE) ?
639                 SUPER_IDLE_SOURCE_SHIFT : SUPER_RUN_SOURCE_SHIFT;
640         for (sel = c->inputs; sel->input != NULL; sel++) {
641                 if (sel->input == p) {
642                         /* For LP mode super-clock switch between PLLX direct
643                            and divided-by-2 outputs is allowed only when other
644                            than PLLX clock source is current parent */
645                         if ((c->flags & DIV_2) && (p->flags & PLLX) &&
646                             ((sel->value ^ val) & SUPER_LP_DIV2_BYPASS)) {
647                                 if (c->parent->flags & PLLX)
648                                         return -EINVAL;
649                                 val ^= SUPER_LP_DIV2_BYPASS;
650                                 clk_writel_delay(val, c->reg);
651                         }
652                         val &= ~(SUPER_SOURCE_MASK << shift);
653                         val |= (sel->value & SUPER_SOURCE_MASK) << shift;
654
655                         /* 7.1 divider for CPU super-clock does not affect
656                            PLLX path */
657                         if (c->flags & DIV_U71) {
658                                 u32 div = 0;
659                                 if (!(p->flags & PLLX)) {
660                                         div = clk_readl(c->reg +
661                                                         SUPER_CLK_DIVIDER);
662                                         div &= SUPER_CLOCK_DIV_U71_MASK;
663                                         div >>= SUPER_CLOCK_DIV_U71_SHIFT;
664                                 }
665                                 c->div = div + 2;
666                                 c->mul = 2;
667                         }
668
669                         if (c->refcnt)
670                                 clk_enable(p);
671
672                         clk_writel_delay(val, c->reg);
673
674                         if (c->refcnt && c->parent)
675                                 clk_disable(c->parent);
676
677                         clk_reparent(c, p);
678                         return 0;
679                 }
680         }
681         return -EINVAL;
682 }
683
684 static DEFINE_SPINLOCK(super_divider_lock);
685
686 static void tegra3_super_clk_divider_update(struct clk *c, u8 div)
687 {
688         u32 val;
689         unsigned long flags;
690
691         spin_lock_irqsave(&super_divider_lock, flags);
692         val = clk_readl(c->reg + SUPER_CLK_DIVIDER);
693         val &= ~SUPER_CLOCK_DIV_U71_MASK;
694         val |= div << SUPER_CLOCK_DIV_U71_SHIFT;
695         clk_writel(val, c->reg + SUPER_CLK_DIVIDER);
696         spin_unlock_irqrestore(&super_divider_lock, flags);
697         udelay(2);
698 }
699
700 static void tegra3_super_clk_skipper_update(struct clk *c, u8 mul, u8 div)
701 {
702         u32 val;
703         unsigned long flags;
704
705         spin_lock_irqsave(&super_divider_lock, flags);
706         val = clk_readl(c->reg + SUPER_CLK_DIVIDER);
707
708         /* multiplier or divider value = the respective field + 1 */
709         if (mul && div) {
710                 u32 old_mul = ((val & SUPER_CLOCK_SKIP_MUL_MASK) >>
711                                SUPER_CLOCK_SKIP_MUL_SHIFT) + 1;
712                 u32 old_div = ((val & SUPER_CLOCK_SKIP_DIV_MASK) >>
713                                SUPER_CLOCK_SKIP_DIV_SHIFT) + 1;
714
715                 if (mul >= div) {
716                         /* improper fraction is only used to reciprocate the
717                            previous proper one - the division below is exact */
718                         old_mul /= div;
719                         old_div /= mul;
720                 } else {
721                         old_mul *= mul;
722                         old_div *= div;
723                 }
724                 mul = (old_mul <= SUPER_CLOCK_SKIP_TERM_MAX) ?
725                         old_mul : SUPER_CLOCK_SKIP_TERM_MAX;
726                 div = (old_div <= SUPER_CLOCK_SKIP_TERM_MAX) ?
727                         old_div : SUPER_CLOCK_SKIP_TERM_MAX;
728         }
729
730         if (!mul || (mul >= div)) {
731                 mul = 1;
732                 div = 1;
733         }
734         val &= ~SUPER_CLOCK_SKIP_MASK;
735         val |= SUPER_CLOCK_SKIP_ENABLE |
736                 ((mul - 1) << SUPER_CLOCK_SKIP_MUL_SHIFT) |
737                 ((div - 1) << SUPER_CLOCK_SKIP_DIV_SHIFT);
738
739         clk_writel(val, c->reg + SUPER_CLK_DIVIDER);
740         spin_unlock_irqrestore(&super_divider_lock, flags);
741 }
742
743 /*
744  * Do not use super clocks "skippers", since dividing using a clock skipper
745  * does not allow the voltage to be scaled down. Instead adjust the rate of
746  * the parent clock. This requires that the parent of a super clock have no
747  * other children, otherwise the rate will change underneath the other
748  * children. Special case: if fixed rate PLL is CPU super clock parent the
749  * rate of this PLL can't be changed, and it has many other children. In
750  * this case use 7.1 fractional divider to adjust the super clock rate.
751  */
752 static int tegra3_super_clk_set_rate(struct clk *c, unsigned long rate)
753 {
754         if ((c->flags & DIV_U71) && (c->parent->flags & PLL_FIXED)) {
755                 int div = clk_div71_get_divider(c->parent->u.pll.fixed_rate,
756                                         rate, c->flags, ROUND_DIVIDER_DOWN);
757                 if (div < 0)
758                         return div;
759
760                 tegra3_super_clk_divider_update(c, div);
761                 c->u.cclk.div71 = div;
762                 c->div = div + 2;
763                 c->mul = 2;
764                 return 0;
765         }
766         return clk_set_rate(c->parent, rate);
767 }
768
769 static struct clk_ops tegra_super_ops = {
770         .init                   = tegra3_super_clk_init,
771         .enable                 = tegra3_super_clk_enable,
772         .disable                = tegra3_super_clk_disable,
773         .set_parent             = tegra3_super_clk_set_parent,
774         .set_rate               = tegra3_super_clk_set_rate,
775 };
776
777 static int tegra3_twd_clk_set_rate(struct clk *c, unsigned long rate)
778 {
779         /* The input value 'rate' is the clock rate of the CPU complex. */
780         c->rate = (rate * c->mul) / c->div;
781         return 0;
782 }
783
784 static struct clk_ops tegra3_twd_ops = {
785         .set_rate       = tegra3_twd_clk_set_rate,
786 };
787
788 static struct clk tegra3_clk_twd = {
789         /* NOTE: The twd clock must have *NO* parent. It's rate is directly
790                  updated by tegra3_cpu_cmplx_clk_set_rate() because the
791                  frequency change notifer for the twd is called in an
792                  atomic context which cannot take a mutex. */
793         .name     = "twd",
794         .ops      = &tegra3_twd_ops,
795         .max_rate = 1400000000, /* Same as tegra_clk_cpu_cmplx.max_rate */
796         .mul      = 1,
797         .div      = 2,
798 };
799
800 /* virtual cpu clock functions */
801 /* some clocks can not be stopped (cpu, memory bus) while the SoC is running.
802    To change the frequency of these clocks, the parent pll may need to be
803    reprogrammed, so the clock must be moved off the pll, the pll reprogrammed,
804    and then the clock moved back to the pll. Clock skipper maybe temporarily
805    engaged during the switch to limit frequency jumps. To hide this sequence,
806    a virtual clock handles it.
807  */
808 static void tegra3_cpu_clk_init(struct clk *c)
809 {
810         c->state = (!is_lp_cluster() == (c->u.cpu.mode == MODE_G))? ON : OFF;
811 }
812
813 static int tegra3_cpu_clk_enable(struct clk *c)
814 {
815         return 0;
816 }
817
818 static void tegra3_cpu_clk_disable(struct clk *c)
819 {
820         /* since tegra 3 has 2 virtual CPU clocks - low power lp-mode clock
821            and geared up g-mode clock - mode switch may request to disable
822            either of them; accept request with no affect on h/w */
823 }
824
825 static int tegra3_cpu_clk_set_rate(struct clk *c, unsigned long rate)
826 {
827         int ret = 0;
828         bool skipped = false;
829         bool skip = (c->u.cpu.mode == MODE_G) && skipper_delay;
830         bool skip_from_backup = skip && (rate >= SKIPPER_ENGAGE_RATE);
831         bool skip_to_backup =
832                 skip && (clk_get_rate_all_locked(c) >= SKIPPER_ENGAGE_RATE);
833
834         if (c->dvfs) {
835                 if (!c->dvfs->dvfs_rail)
836                         return -ENOSYS;
837                 else if ((!c->dvfs->dvfs_rail->reg) &&
838                           (clk_get_rate_locked(c) < rate)) {
839                         WARN(1, "Increasing CPU rate while regulator is not"
840                                 " ready may overclock CPU\n");
841                         return -ENOSYS;
842                 }
843         }
844
845         /*
846          * Take an extra reference to the main pll so it doesn't turn
847          * off when we move the cpu off of it
848          */
849         clk_enable(c->u.cpu.main);
850
851         if (c->parent->parent != c->u.cpu.backup) {
852                 if (skip_to_backup) {
853                         /* on G CPU use 1/2 skipper step for main <=> backup */
854                         skipped = true;
855                         tegra3_super_clk_skipper_update(c->parent, 1, 2);
856                         udelay(skipper_delay);
857                 }
858
859                 ret = clk_set_parent(c->parent, c->u.cpu.backup);
860                 if (ret) {
861                         pr_err("Failed to switch cpu to clock %s\n",
862                                c->u.cpu.backup->name);
863                         goto out;
864                 }
865
866                 if (skipped && !skip_from_backup) {
867                         skipped = false;
868                         tegra3_super_clk_skipper_update(c->parent, 2, 1);
869                 }
870         }
871
872         if (rate <= cpu_stay_on_backup_max) {
873                 ret = clk_set_rate(c->parent, rate);
874                 if (ret)
875                         pr_err("Failed to set cpu rate %lu on backup source\n",
876                                rate);
877                 goto out;
878         } else {
879                 ret = clk_set_rate(c->parent, c->u.cpu.backup_rate);
880                 if (ret) {
881                         pr_err("Failed to set cpu rate %lu on backup source\n",
882                                c->u.cpu.backup_rate);
883                         goto out;
884                 }
885         }
886
887         if (rate != clk_get_rate(c->u.cpu.main)) {
888                 ret = clk_set_rate(c->u.cpu.main, rate);
889                 if (ret) {
890                         pr_err("Failed to change cpu pll to %lu\n", rate);
891                         goto out;
892                 }
893         }
894
895         if (!skipped && skip_from_backup) {
896                 skipped = true;
897                 tegra3_super_clk_skipper_update(c->parent, 1, 2);
898         }
899
900         ret = clk_set_parent(c->parent, c->u.cpu.main);
901         if (ret) {
902                 pr_err("Failed to switch cpu to clock %s\n", c->u.cpu.main->name);
903                 goto out;
904         }
905
906 out:
907         if (skipped) {
908                 udelay(skipper_delay);
909                 tegra3_super_clk_skipper_update(c->parent, 2, 1);
910         }
911         clk_disable(c->u.cpu.main);
912         return ret;
913 }
914
915 static struct clk_ops tegra_cpu_ops = {
916         .init     = tegra3_cpu_clk_init,
917         .enable   = tegra3_cpu_clk_enable,
918         .disable  = tegra3_cpu_clk_disable,
919         .set_rate = tegra3_cpu_clk_set_rate,
920 };
921
922
923 static void tegra3_cpu_cmplx_clk_init(struct clk *c)
924 {
925         int i = !!is_lp_cluster();
926
927         BUG_ON(c->inputs[0].input->u.cpu.mode != MODE_G);
928         BUG_ON(c->inputs[1].input->u.cpu.mode != MODE_LP);
929         c->parent = c->inputs[i].input;
930 }
931
932 /* cpu complex clock provides second level vitualization (on top of
933    cpu virtual cpu rate control) in order to hide the CPU mode switch
934    sequence */
935 #if PARAMETERIZE_CLUSTER_SWITCH
936 static unsigned int switch_delay;
937 static unsigned int switch_flags;
938 static DEFINE_SPINLOCK(parameters_lock);
939
940 void tegra_cluster_switch_set_parameters(unsigned int us, unsigned int flags)
941 {
942         spin_lock(&parameters_lock);
943         switch_delay = us;
944         switch_flags = flags;
945         spin_unlock(&parameters_lock);
946 }
947 #endif
948
949 static int tegra3_cpu_cmplx_clk_enable(struct clk *c)
950 {
951         return 0;
952 }
953
954 static void tegra3_cpu_cmplx_clk_disable(struct clk *c)
955 {
956         pr_debug("%s on clock %s\n", __func__, c->name);
957
958         /* oops - don't disable the CPU complex clock! */
959         BUG();
960 }
961
962 static int tegra3_cpu_cmplx_clk_set_rate(struct clk *c, unsigned long rate)
963 {
964         unsigned long flags;
965         int ret;
966         struct clk *parent = c->parent;
967
968         if (!parent->ops || !parent->ops->set_rate)
969                 return -ENOSYS;
970
971         clk_lock_save(parent, &flags);
972
973         ret = clk_set_rate_locked(parent, rate);
974
975         /* We can't parent the twd to directly to the CPU complex because
976            the TWD frequency update notifier is called in an atomic context
977            and the CPU frequency update requires a mutex. Update the twd
978            clock rate with the new CPU complex rate. */
979         clk_set_rate(&tegra3_clk_twd, clk_get_rate_locked(parent));
980
981         clk_unlock_restore(parent, &flags);
982
983         return ret;
984 }
985
986 static int tegra3_cpu_cmplx_clk_set_parent(struct clk *c, struct clk *p)
987 {
988         int ret;
989         unsigned int flags, delay;
990         const struct clk_mux_sel *sel;
991         unsigned long rate = clk_get_rate(c->parent);
992
993         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
994         BUG_ON(c->parent->u.cpu.mode != (is_lp_cluster() ? MODE_LP : MODE_G));
995
996         for (sel = c->inputs; sel->input != NULL; sel++) {
997                 if (sel->input == p)
998                         break;
999         }
1000         if (!sel->input)
1001                 return -EINVAL;
1002
1003 #if PARAMETERIZE_CLUSTER_SWITCH
1004         spin_lock(&parameters_lock);
1005         flags = switch_flags;
1006         delay = switch_delay;
1007         switch_flags = 0;
1008         spin_unlock(&parameters_lock);
1009
1010         if (flags) {
1011                 /* over/under-clocking after switch - allow, but update rate */
1012                 if ((rate > p->max_rate) || (rate < p->min_rate)) {
1013                         unsigned long fl;
1014
1015                         rate = rate > p->max_rate ? p->max_rate : p->min_rate;
1016                         ret = clk_set_rate(c->parent, rate);
1017                         if (ret) {
1018                                 pr_err("%s: Failed to set rate %lu for %s\n",
1019                                         __func__, rate, p->name);
1020                                 return ret;
1021                         }
1022                         clk_lock_save(c->parent, &fl);
1023                         clk_set_rate(&tegra3_clk_twd, clk_get_rate_locked(c->parent));
1024                         clk_unlock_restore(c->parent, &fl);
1025                 }
1026         } else
1027 #endif
1028         {
1029                 if (p == c->parent)             /* already switched - exit*/
1030                         return 0;
1031
1032                 if (rate > p->max_rate) {       /* over-clocking - no switch */
1033                         pr_warn("%s: No %s mode switch to %s at rate %lu\n",
1034                                  __func__, c->name, p->name, rate);
1035                         return -ECANCELED;
1036                 }
1037                 flags = TEGRA_POWER_CLUSTER_IMMEDIATE;
1038                 delay = 0;
1039         }
1040         flags |= (p->u.cpu.mode == MODE_LP) ? TEGRA_POWER_CLUSTER_LP :
1041                 TEGRA_POWER_CLUSTER_G;
1042
1043         /* Since in both LP and G mode CPU main and backup sources are the
1044            same, set rate on the new parent just synchronizes super-clock
1045            muxes before mode switch with no PLL re-locking */
1046         ret = clk_set_rate(p, rate);
1047         if (ret) {
1048                 pr_err("%s: Failed to set rate %lu for %s\n",
1049                        __func__, rate, p->name);
1050                 return ret;
1051         }
1052
1053         /* Enabling new parent scales new mode voltage rail in advanvce
1054            before the switch happens*/
1055         if (c->refcnt)
1056                 clk_enable(p);
1057
1058         /* switch CPU mode */
1059         ret = tegra_cluster_control(delay, flags);
1060         if (ret) {
1061                 if (c->refcnt)
1062                         clk_disable(p);
1063                 pr_err("%s: Failed to switch %s mode to %s\n",
1064                        __func__, c->name, p->name);
1065                 return ret;
1066         }
1067
1068         /* Disabling old parent scales old mode voltage rail */
1069         if (c->refcnt && c->parent)
1070                 clk_disable(c->parent);
1071
1072         clk_reparent(c, p);
1073         return 0;
1074 }
1075
1076 static long tegra3_cpu_cmplx_round_rate(struct clk *c,
1077         unsigned long rate)
1078 {
1079         if (rate > c->parent->max_rate)
1080                 rate = c->parent->max_rate;
1081         else if (rate < c->parent->min_rate)
1082                 rate = c->parent->min_rate;
1083         return rate;
1084 }
1085
1086 static struct clk_ops tegra_cpu_cmplx_ops = {
1087         .init     = tegra3_cpu_cmplx_clk_init,
1088         .enable   = tegra3_cpu_cmplx_clk_enable,
1089         .disable  = tegra3_cpu_cmplx_clk_disable,
1090         .set_rate = tegra3_cpu_cmplx_clk_set_rate,
1091         .set_parent = tegra3_cpu_cmplx_clk_set_parent,
1092         .round_rate = tegra3_cpu_cmplx_round_rate,
1093 };
1094
1095 /* virtual cop clock functions. Used to acquire the fake 'cop' clock to
1096  * reset the COP block (i.e. AVP) */
1097 static void tegra3_cop_clk_reset(struct clk *c, bool assert)
1098 {
1099         unsigned long reg = assert ? RST_DEVICES_SET_L : RST_DEVICES_CLR_L;
1100
1101         pr_debug("%s %s\n", __func__, assert ? "assert" : "deassert");
1102         clk_writel(1 << 1, reg);
1103 }
1104
1105 static struct clk_ops tegra_cop_ops = {
1106         .reset    = tegra3_cop_clk_reset,
1107 };
1108
1109 /* bus clock functions */
1110 static void tegra3_bus_clk_init(struct clk *c)
1111 {
1112         u32 val = clk_readl(c->reg);
1113         c->state = ((val >> c->reg_shift) & BUS_CLK_DISABLE) ? OFF : ON;
1114         c->div = ((val >> c->reg_shift) & BUS_CLK_DIV_MASK) + 1;
1115         c->mul = 1;
1116 }
1117
1118 static int tegra3_bus_clk_enable(struct clk *c)
1119 {
1120         u32 val = clk_readl(c->reg);
1121         val &= ~(BUS_CLK_DISABLE << c->reg_shift);
1122         clk_writel(val, c->reg);
1123         return 0;
1124 }
1125
1126 static void tegra3_bus_clk_disable(struct clk *c)
1127 {
1128         u32 val = clk_readl(c->reg);
1129         val |= BUS_CLK_DISABLE << c->reg_shift;
1130         clk_writel(val, c->reg);
1131 }
1132
1133 static int tegra3_bus_clk_set_rate(struct clk *c, unsigned long rate)
1134 {
1135         u32 val = clk_readl(c->reg);
1136         unsigned long parent_rate = clk_get_rate(c->parent);
1137         int i;
1138         for (i = 1; i <= 4; i++) {
1139                 if (rate >= parent_rate / i) {
1140                         val &= ~(BUS_CLK_DIV_MASK << c->reg_shift);
1141                         val |= (i - 1) << c->reg_shift;
1142                         clk_writel(val, c->reg);
1143                         c->div = i;
1144                         c->mul = 1;
1145                         return 0;
1146                 }
1147         }
1148         return -EINVAL;
1149 }
1150
1151 static struct clk_ops tegra_bus_ops = {
1152         .init                   = tegra3_bus_clk_init,
1153         .enable                 = tegra3_bus_clk_enable,
1154         .disable                = tegra3_bus_clk_disable,
1155         .set_rate               = tegra3_bus_clk_set_rate,
1156 };
1157
1158 /* Virtual system bus complex clock is used to hide the sequence of
1159    changing sclk/hclk/pclk parents and dividers to configure requested
1160    sclk target rate. */
1161 static void tegra3_sbus_cmplx_init(struct clk *c)
1162 {
1163         unsigned long rate;
1164
1165         c->max_rate = c->parent->max_rate;
1166         c->min_rate = c->parent->min_rate;
1167
1168         /* Threshold must be an exact proper factor of low range parent,
1169            and both low/high range parents have 7.1 fractional dividers */
1170         rate = clk_get_rate(c->u.system.sclk_low->parent);
1171         if (c->u.system.threshold) {
1172                 BUG_ON(c->u.system.threshold > rate) ;
1173                 BUG_ON((rate % c->u.system.threshold) != 0);
1174         }
1175         BUG_ON(!(c->u.system.sclk_low->flags & DIV_U71));
1176         BUG_ON(!(c->u.system.sclk_high->flags & DIV_U71));
1177 }
1178
1179 /* This special sbus round function is implemented because:
1180  *
1181  * (a) fractional dividers can not be used to derive system bus clock with one
1182  * exception: 1 : 2.5 divider is allowed at 1.2V and above (and we do need this
1183  * divider to reach top sbus frequencies from high frequency source).
1184  *
1185  * (b) since sbus is a shared bus, and its frequency is set to the highest
1186  * enabled shared_bus_user clock, the target rate should be rounded up divider
1187  * ladder (if max limit allows it) - for pll_div and peripheral_div common is
1188  * rounding down - special case again.
1189  *
1190  * Note that final rate is trimmed (not rounded up) to avoid spiraling up in
1191  * recursive calls. Lost 1Hz is added in tegra3_sbus_cmplx_set_rate before
1192  * actually setting divider rate.
1193  */
1194 static unsigned long sclk_high_2_5_rate;
1195 static bool sclk_high_2_5_valid;
1196
1197 static long tegra3_sbus_cmplx_round_rate(struct clk *c, unsigned long rate)
1198 {
1199         int i, divider;
1200         unsigned long source_rate, round_rate;
1201         struct clk *new_parent;
1202
1203         rate = max(rate, c->min_rate);
1204
1205         if (!sclk_high_2_5_rate) {
1206                 source_rate = clk_get_rate(c->u.system.sclk_high->parent);
1207                 sclk_high_2_5_rate = 2 * source_rate / 5;
1208                 i = tegra_dvfs_predict_millivolts(c, sclk_high_2_5_rate);
1209                 if (!IS_ERR_VALUE(i) && (i >= 1200) &&
1210                     (sclk_high_2_5_rate <= c->max_rate))
1211                         sclk_high_2_5_valid = true;
1212         }
1213
1214         new_parent = (rate <= c->u.system.threshold) ?
1215                 c->u.system.sclk_low : c->u.system.sclk_high;
1216         source_rate = clk_get_rate(new_parent->parent);
1217
1218         divider = clk_div71_get_divider(source_rate, rate,
1219                 new_parent->flags | DIV_U71_INT, ROUND_DIVIDER_DOWN);
1220         if (divider < 0)
1221                 return divider;
1222
1223         round_rate = source_rate * 2 / (divider + 2);
1224         if (round_rate > c->max_rate) {
1225                 divider += 2;
1226                 round_rate = source_rate * 2 / (divider + 2);
1227         }
1228
1229         if (new_parent == c->u.system.sclk_high) {
1230                 /* Check if 1 : 2.5 ratio provides better approximation */
1231                 if (sclk_high_2_5_valid) {
1232                         if (((sclk_high_2_5_rate < round_rate) &&
1233                             (sclk_high_2_5_rate >= rate)) ||
1234                             ((round_rate < sclk_high_2_5_rate) &&
1235                              (round_rate < rate)))
1236                                 round_rate = sclk_high_2_5_rate;
1237                 }
1238
1239                 if (round_rate <= c->u.system.threshold)
1240                         round_rate = c->u.system.threshold;
1241         }
1242         return round_rate;
1243 }
1244
1245 static int tegra3_sbus_cmplx_set_rate(struct clk *c, unsigned long rate)
1246 {
1247         int ret;
1248         struct clk *new_parent;
1249
1250         /* - select the appropriate sclk parent
1251            - keep hclk at the same rate as sclk
1252            - set pclk at 1:2 rate of hclk unless pclk minimum is violated,
1253              in the latter case switch to 1:1 ratio */
1254
1255         if (rate >= c->u.system.pclk->min_rate * 2) {
1256                 ret = clk_set_div(c->u.system.pclk, 2);
1257                 if (ret) {
1258                         pr_err("Failed to set 1 : 2 pclk divider\n");
1259                         return ret;
1260                 }
1261         }
1262
1263         new_parent = (rate <= c->u.system.threshold) ?
1264                 c->u.system.sclk_low : c->u.system.sclk_high;
1265
1266         ret = clk_set_rate(new_parent, rate + 1);
1267         if (ret) {
1268                 pr_err("Failed to set sclk source %s to %lu\n",
1269                        new_parent->name, rate);
1270                 return ret;
1271         }
1272
1273         if (new_parent != clk_get_parent(c->parent)) {
1274                 ret = clk_set_parent(c->parent, new_parent);
1275                 if (ret) {
1276                         pr_err("Failed to switch sclk source to %s\n",
1277                                new_parent->name);
1278                         return ret;
1279                 }
1280         }
1281
1282         if (rate < c->u.system.pclk->min_rate * 2) {
1283                 ret = clk_set_div(c->u.system.pclk, 1);
1284                 if (ret) {
1285                         pr_err("Failed to set 1 : 1 pclk divider\n");
1286                         return ret;
1287                 }
1288         }
1289
1290         return 0;
1291 }
1292
1293 static struct clk_ops tegra_sbus_cmplx_ops = {
1294         .init = tegra3_sbus_cmplx_init,
1295         .set_rate = tegra3_sbus_cmplx_set_rate,
1296         .round_rate = tegra3_sbus_cmplx_round_rate,
1297         .shared_bus_update = tegra3_clk_shared_bus_update,
1298 };
1299
1300 /* Blink output functions */
1301
1302 static void tegra3_blink_clk_init(struct clk *c)
1303 {
1304         u32 val;
1305
1306         val = pmc_readl(PMC_CTRL);
1307         c->state = (val & PMC_CTRL_BLINK_ENB) ? ON : OFF;
1308         c->mul = 1;
1309         val = pmc_readl(c->reg);
1310
1311         if (val & PMC_BLINK_TIMER_ENB) {
1312                 unsigned int on_off;
1313
1314                 on_off = (val >> PMC_BLINK_TIMER_DATA_ON_SHIFT) &
1315                         PMC_BLINK_TIMER_DATA_ON_MASK;
1316                 val >>= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
1317                 val &= PMC_BLINK_TIMER_DATA_OFF_MASK;
1318                 on_off += val;
1319                 /* each tick in the blink timer is 4 32KHz clocks */
1320                 c->div = on_off * 4;
1321         } else {
1322                 c->div = 1;
1323         }
1324 }
1325
1326 static int tegra3_blink_clk_enable(struct clk *c)
1327 {
1328         u32 val;
1329
1330         val = pmc_readl(PMC_DPD_PADS_ORIDE);
1331         pmc_writel(val | PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
1332
1333         val = pmc_readl(PMC_CTRL);
1334         pmc_writel(val | PMC_CTRL_BLINK_ENB, PMC_CTRL);
1335
1336         return 0;
1337 }
1338
1339 static void tegra3_blink_clk_disable(struct clk *c)
1340 {
1341         u32 val;
1342
1343         val = pmc_readl(PMC_CTRL);
1344         pmc_writel(val & ~PMC_CTRL_BLINK_ENB, PMC_CTRL);
1345
1346         val = pmc_readl(PMC_DPD_PADS_ORIDE);
1347         pmc_writel(val & ~PMC_DPD_PADS_ORIDE_BLINK_ENB, PMC_DPD_PADS_ORIDE);
1348 }
1349
1350 static int tegra3_blink_clk_set_rate(struct clk *c, unsigned long rate)
1351 {
1352         unsigned long parent_rate = clk_get_rate(c->parent);
1353         if (rate >= parent_rate) {
1354                 c->div = 1;
1355                 pmc_writel(0, c->reg);
1356         } else {
1357                 unsigned int on_off;
1358                 u32 val;
1359
1360                 on_off = DIV_ROUND_UP(parent_rate / 8, rate);
1361                 c->div = on_off * 8;
1362
1363                 val = (on_off & PMC_BLINK_TIMER_DATA_ON_MASK) <<
1364                         PMC_BLINK_TIMER_DATA_ON_SHIFT;
1365                 on_off &= PMC_BLINK_TIMER_DATA_OFF_MASK;
1366                 on_off <<= PMC_BLINK_TIMER_DATA_OFF_SHIFT;
1367                 val |= on_off;
1368                 val |= PMC_BLINK_TIMER_ENB;
1369                 pmc_writel(val, c->reg);
1370         }
1371
1372         return 0;
1373 }
1374
1375 static struct clk_ops tegra_blink_clk_ops = {
1376         .init                   = &tegra3_blink_clk_init,
1377         .enable                 = &tegra3_blink_clk_enable,
1378         .disable                = &tegra3_blink_clk_disable,
1379         .set_rate               = &tegra3_blink_clk_set_rate,
1380 };
1381
1382 /* PLL Functions */
1383 static int tegra3_pll_clk_wait_for_lock(struct clk *c, u32 lock_reg, u32 lock_bit)
1384 {
1385 #if USE_PLL_LOCK_BITS
1386         int i;
1387         for (i = 0; i < c->u.pll.lock_delay; i++) {
1388                 if (clk_readl(lock_reg) & lock_bit) {
1389                         udelay(PLL_POST_LOCK_DELAY);
1390                         return 0;
1391                 }
1392                 udelay(2);              /* timeout = 2 * lock time */
1393         }
1394         pr_err("Timed out waiting for lock bit on pll %s", c->name);
1395         return -1;
1396 #endif
1397         udelay(c->u.pll.lock_delay);
1398
1399         return 0;
1400 }
1401
1402
1403 static void tegra3_utmi_param_configure(struct clk *c)
1404 {
1405         u32 reg;
1406         int i;
1407         unsigned long main_rate =
1408                 clk_get_rate(c->parent->parent);
1409
1410         for (i = 0; i < ARRAY_SIZE(utmi_parameters); i++) {
1411                 if (main_rate == utmi_parameters[i].osc_frequency) {
1412                         break;
1413                 }
1414         }
1415
1416         if (i >= ARRAY_SIZE(utmi_parameters)) {
1417                 pr_err("%s: Unexpected main rate %lu\n", __func__, main_rate);
1418                 return;
1419         }
1420
1421         reg = clk_readl(UTMIP_PLL_CFG2);
1422
1423         /* Program UTMIP PLL stable and active counts */
1424         /* [FIXME] arclk_rst.h says WRONG! This should be 1ms -> 0x50 Check! */
1425         reg &= ~UTMIP_PLL_CFG2_STABLE_COUNT(~0);
1426         reg |= UTMIP_PLL_CFG2_STABLE_COUNT(
1427                         utmi_parameters[i].stable_count);
1428
1429         reg &= ~UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(~0);
1430
1431         reg |= UTMIP_PLL_CFG2_ACTIVE_DLY_COUNT(
1432                         utmi_parameters[i].active_delay_count);
1433
1434         /* Remove power downs from UTMIP PLL control bits */
1435         reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_A_POWERDOWN;
1436         reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_B_POWERDOWN;
1437         reg &= ~UTMIP_PLL_CFG2_FORCE_PD_SAMP_C_POWERDOWN;
1438
1439         clk_writel(reg, UTMIP_PLL_CFG2);
1440
1441         /* Program UTMIP PLL delay and oscillator frequency counts */
1442         reg = clk_readl(UTMIP_PLL_CFG1);
1443         reg &= ~UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(~0);
1444
1445         reg |= UTMIP_PLL_CFG1_ENABLE_DLY_COUNT(
1446                 utmi_parameters[i].enable_delay_count);
1447
1448         reg &= ~UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(~0);
1449         reg |= UTMIP_PLL_CFG1_XTAL_FREQ_COUNT(
1450                 utmi_parameters[i].xtal_freq_count);
1451
1452         /* Remove power downs from UTMIP PLL control bits */
1453         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ENABLE_POWERDOWN;
1454         reg &= ~UTMIP_PLL_CFG1_FORCE_PLL_ACTIVE_POWERDOWN;
1455         reg &= ~UTMIP_PLL_CFG1_FORCE_PLLU_POWERDOWN;
1456
1457         clk_writel(reg, UTMIP_PLL_CFG1);
1458 }
1459
1460 static void tegra3_pll_clk_init(struct clk *c)
1461 {
1462         u32 val = clk_readl(c->reg + PLL_BASE);
1463
1464         c->state = (val & PLL_BASE_ENABLE) ? ON : OFF;
1465
1466         if (c->flags & PLL_FIXED && !(val & PLL_BASE_OVERRIDE)) {
1467                 const struct clk_pll_freq_table *sel;
1468                 unsigned long input_rate = clk_get_rate(c->parent);
1469                 c->u.pll.fixed_rate = PLLP_DEFAULT_FIXED_RATE;
1470
1471                 for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
1472                         if (sel->input_rate == input_rate &&
1473                                 sel->output_rate == c->u.pll.fixed_rate) {
1474                                 c->mul = sel->n;
1475                                 c->div = sel->m * sel->p;
1476                                 return;
1477                         }
1478                 }
1479                 pr_err("Clock %s has unknown fixed frequency\n", c->name);
1480                 BUG();
1481         } else if (val & PLL_BASE_BYPASS) {
1482                 c->mul = 1;
1483                 c->div = 1;
1484         } else {
1485                 c->mul = (val & PLL_BASE_DIVN_MASK) >> PLL_BASE_DIVN_SHIFT;
1486                 c->div = (val & PLL_BASE_DIVM_MASK) >> PLL_BASE_DIVM_SHIFT;
1487                 if (c->flags & PLLU)
1488                         c->div *= (val & PLLU_BASE_POST_DIV) ? 1 : 2;
1489                 else
1490                         c->div *= (0x1 << ((val & PLL_BASE_DIVP_MASK) >>
1491                                         PLL_BASE_DIVP_SHIFT));
1492         }
1493
1494         if (c->flags & PLL_FIXED) {
1495                 c->u.pll.fixed_rate = clk_get_rate_locked(c);
1496         }
1497
1498         if (c->flags & PLLU) {
1499                 tegra3_utmi_param_configure(c);
1500         }
1501 }
1502
1503 static int tegra3_pll_clk_enable(struct clk *c)
1504 {
1505         u32 val;
1506         pr_debug("%s on clock %s\n", __func__, c->name);
1507
1508 #if USE_PLL_LOCK_BITS
1509         val = clk_readl(c->reg + PLL_MISC(c));
1510         val |= PLL_MISC_LOCK_ENABLE(c);
1511         clk_writel(val, c->reg + PLL_MISC(c));
1512 #endif
1513         val = clk_readl(c->reg + PLL_BASE);
1514         val &= ~PLL_BASE_BYPASS;
1515         val |= PLL_BASE_ENABLE;
1516         clk_writel(val, c->reg + PLL_BASE);
1517
1518         if (c->flags & PLLM) {
1519                 val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
1520                 val |= PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE;
1521                 pmc_writel(val, PMC_PLLP_WB0_OVERRIDE);
1522         }
1523
1524         tegra3_pll_clk_wait_for_lock(c, c->reg + PLL_BASE, PLL_BASE_LOCK);
1525
1526         return 0;
1527 }
1528
1529 static void tegra3_pll_clk_disable(struct clk *c)
1530 {
1531         u32 val;
1532         pr_debug("%s on clock %s\n", __func__, c->name);
1533
1534         val = clk_readl(c->reg);
1535         val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
1536         clk_writel(val, c->reg);
1537
1538         if (c->flags & PLLM) {
1539                 val = pmc_readl(PMC_PLLP_WB0_OVERRIDE);
1540                 val &= ~PMC_PLLP_WB0_OVERRIDE_PLLM_ENABLE;
1541                 pmc_writel(val, PMC_PLLP_WB0_OVERRIDE);
1542         }
1543 }
1544
1545 static int tegra3_pll_clk_set_rate(struct clk *c, unsigned long rate)
1546 {
1547         u32 val, p_div, old_base;
1548         unsigned long input_rate;
1549         const struct clk_pll_freq_table *sel;
1550         struct clk_pll_freq_table cfg;
1551
1552         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
1553
1554         if (c->flags & PLL_FIXED) {
1555                 int ret = 0;
1556                 if (rate != c->u.pll.fixed_rate) {
1557                         pr_err("%s: Can not change %s fixed rate %lu to %lu\n",
1558                                __func__, c->name, c->u.pll.fixed_rate, rate);
1559                         ret = -EINVAL;
1560                 }
1561                 return ret;
1562         }
1563
1564         if (c->flags & PLLM) {
1565                 if (rate != clk_get_rate_locked(c)) {
1566                         pr_err("%s: Can not change memory %s rate in flight\n",
1567                                __func__, c->name);
1568                         return -EINVAL;
1569                 }
1570                 return 0;
1571         }
1572
1573         p_div = 0;
1574         input_rate = clk_get_rate(c->parent);
1575
1576         /* Check if the target rate is tabulated */
1577         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
1578                 if (sel->input_rate == input_rate && sel->output_rate == rate) {
1579                         if (c->flags & PLLU) {
1580                                 BUG_ON(sel->p < 1 || sel->p > 2);
1581                                 if (sel->p == 1)
1582                                         p_div = PLLU_BASE_POST_DIV;
1583                         } else {
1584                                 BUG_ON(sel->p < 1);
1585                                 for (val = sel->p; val > 1; val >>= 1, p_div++);
1586                                 p_div <<= PLL_BASE_DIVP_SHIFT;
1587                         }
1588                         break;
1589                 }
1590         }
1591
1592         /* Configure out-of-table rate */
1593         if (sel->input_rate == 0) {
1594                 unsigned long cfreq;
1595                 BUG_ON(c->flags & PLLU);
1596                 sel = &cfg;
1597
1598                 switch (input_rate) {
1599                 case 12000000:
1600                 case 26000000:
1601                         cfreq = (rate <= 1000000 * 1000) ? 1000000 : 2000000;
1602                         break;
1603                 case 13000000:
1604                         cfreq = (rate <= 1000000 * 1000) ? 1000000 : 2600000;
1605                         break;
1606                 case 16800000:
1607                 case 19200000:
1608                         cfreq = (rate <= 1200000 * 1000) ? 1200000 : 2400000;
1609                         break;
1610                 default:
1611                         if (c->parent->flags & DIV_U71_FIXED) {
1612                                 /* PLLP_OUT1 rate is not in PLLA table */
1613                                 pr_warn("%s: failed %s ref/out rates %lu/%lu\n",
1614                                         __func__, c->name, input_rate, rate);
1615                                 cfreq = input_rate/(input_rate/1000000);
1616                                 break;
1617                         }
1618                         pr_err("%s: Unexpected reference rate %lu\n",
1619                                __func__, input_rate);
1620                         BUG();
1621                 }
1622
1623                 /* Raise VCO to guarantee 0.5% accuracy */
1624                 for (cfg.output_rate = rate; cfg.output_rate < 200 * cfreq;
1625                       cfg.output_rate <<= 1, p_div++);
1626
1627                 cfg.p = 0x1 << p_div;
1628                 cfg.m = input_rate / cfreq;
1629                 cfg.n = cfg.output_rate / cfreq;
1630                 cfg.cpcon = OUT_OF_TABLE_CPCON;
1631
1632                 if ((cfg.m > (PLL_BASE_DIVM_MASK >> PLL_BASE_DIVM_SHIFT)) ||
1633                     (cfg.n > (PLL_BASE_DIVN_MASK >> PLL_BASE_DIVN_SHIFT)) ||
1634                     (p_div > (PLL_BASE_DIVP_MASK >> PLL_BASE_DIVP_SHIFT)) ||
1635                     (cfg.output_rate > c->u.pll.vco_max)) {
1636                         pr_err("%s: Failed to set %s out-of-table rate %lu\n",
1637                                __func__, c->name, rate);
1638                         return -EINVAL;
1639                 }
1640                 p_div <<= PLL_BASE_DIVP_SHIFT;
1641         }
1642
1643         c->mul = sel->n;
1644         c->div = sel->m * sel->p;
1645
1646         old_base = val = clk_readl(c->reg + PLL_BASE);
1647         val &= ~(PLL_BASE_DIVM_MASK | PLL_BASE_DIVN_MASK |
1648                  ((c->flags & PLLU) ? PLLU_BASE_POST_DIV : PLL_BASE_DIVP_MASK));
1649         val |= (sel->m << PLL_BASE_DIVM_SHIFT) |
1650                 (sel->n << PLL_BASE_DIVN_SHIFT) | p_div;
1651         if (val == old_base)
1652                 return 0;
1653
1654         if (c->state == ON) {
1655                 tegra3_pll_clk_disable(c);
1656                 val &= ~(PLL_BASE_BYPASS | PLL_BASE_ENABLE);
1657         }
1658         clk_writel(val, c->reg + PLL_BASE);
1659
1660         if (c->flags & PLL_HAS_CPCON) {
1661                 val = clk_readl(c->reg + PLL_MISC(c));
1662                 val &= ~PLL_MISC_CPCON_MASK;
1663                 val |= sel->cpcon << PLL_MISC_CPCON_SHIFT;
1664                 if (c->flags & (PLLU | PLLD)) {
1665                         val &= ~PLL_MISC_LFCON_MASK;
1666                         if (sel->n >= PLLDU_LFCON_SET_DIVN)
1667                                 val |= 0x1 << PLL_MISC_LFCON_SHIFT;
1668                 } else if (c->flags & (PLLX | PLLM)) {
1669                         val &= ~(0x1 << PLL_MISC_DCCON_SHIFT);
1670                         if (rate >= (c->u.pll.vco_max >> 1))
1671                                 val |= 0x1 << PLL_MISC_DCCON_SHIFT;
1672                 }
1673                 clk_writel(val, c->reg + PLL_MISC(c));
1674         }
1675
1676         if (c->state == ON)
1677                 tegra3_pll_clk_enable(c);
1678
1679         return 0;
1680 }
1681
1682 static struct clk_ops tegra_pll_ops = {
1683         .init                   = tegra3_pll_clk_init,
1684         .enable                 = tegra3_pll_clk_enable,
1685         .disable                = tegra3_pll_clk_disable,
1686         .set_rate               = tegra3_pll_clk_set_rate,
1687 };
1688
1689 static void tegra3_pllp_clk_init(struct clk *c)
1690 {
1691         tegra3_pll_clk_init(c);
1692         tegra3_pllp_init_dependencies(c->u.pll.fixed_rate);
1693 }
1694
1695 #if defined(CONFIG_PM_SLEEP)
1696 static void tegra3_pllp_clk_resume(struct clk *c)
1697 {
1698         unsigned long rate = c->u.pll.fixed_rate;
1699         tegra3_pll_clk_init(c);
1700         BUG_ON(rate != c->u.pll.fixed_rate);
1701 }
1702 #endif
1703
1704 static struct clk_ops tegra_pllp_ops = {
1705         .init                   = tegra3_pllp_clk_init,
1706         .enable                 = tegra3_pll_clk_enable,
1707         .disable                = tegra3_pll_clk_disable,
1708         .set_rate               = tegra3_pll_clk_set_rate,
1709 };
1710
1711 static int
1712 tegra3_plld_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
1713 {
1714         u32 val, mask, reg;
1715
1716         switch (p) {
1717         case TEGRA_CLK_PLLD_CSI_OUT_ENB:
1718                 mask = PLLD_BASE_CSI_CLKENABLE;
1719                 reg = c->reg + PLL_BASE;
1720                 break;
1721         case TEGRA_CLK_PLLD_DSI_OUT_ENB:
1722                 mask = PLLD_MISC_DSI_CLKENABLE;
1723                 reg = c->reg + PLL_MISC(c);
1724                 break;
1725         case TEGRA_CLK_PLLD_MIPI_MUX_SEL:
1726                 if (!(c->flags & PLL_ALT_MISC_REG)) {
1727                         mask = PLLD_BASE_DSIB_MUX_MASK;
1728                         reg = c->reg + PLL_BASE;
1729                         break;
1730                 }
1731         /* fall through - error since PLLD2 does not have MUX_SEL control */
1732         default:
1733                 return -EINVAL;
1734         }
1735
1736         val = clk_readl(reg);
1737         if (setting)
1738                 val |= mask;
1739         else
1740                 val &= ~mask;
1741         clk_writel(val, reg);
1742         return 0;
1743 }
1744
1745 static struct clk_ops tegra_plld_ops = {
1746         .init                   = tegra3_pll_clk_init,
1747         .enable                 = tegra3_pll_clk_enable,
1748         .disable                = tegra3_pll_clk_disable,
1749         .set_rate               = tegra3_pll_clk_set_rate,
1750         .clk_cfg_ex             = tegra3_plld_clk_cfg_ex,
1751 };
1752
1753 static void tegra3_plle_clk_init(struct clk *c)
1754 {
1755         u32 val;
1756
1757         val = clk_readl(PLLE_AUX);
1758         c->parent = (val & PLLE_AUX_PLLP_SEL) ?
1759                 tegra_get_clock_by_name("pll_p") :
1760                 tegra_get_clock_by_name("pll_ref");
1761
1762         val = clk_readl(c->reg + PLL_BASE);
1763         c->state = (val & PLLE_BASE_ENABLE) ? ON : OFF;
1764         c->mul = (val & PLLE_BASE_DIVN_MASK) >> PLLE_BASE_DIVN_SHIFT;
1765         c->div = (val & PLLE_BASE_DIVM_MASK) >> PLLE_BASE_DIVM_SHIFT;
1766         c->div *= (val & PLLE_BASE_DIVP_MASK) >> PLLE_BASE_DIVP_SHIFT;
1767 }
1768
1769 static void tegra3_plle_clk_disable(struct clk *c)
1770 {
1771         u32 val;
1772         pr_debug("%s on clock %s\n", __func__, c->name);
1773
1774         val = clk_readl(c->reg + PLL_BASE);
1775         val &= ~(PLLE_BASE_CML_ENABLE | PLLE_BASE_ENABLE);
1776         clk_writel(val, c->reg + PLL_BASE);
1777 }
1778
1779 static void tegra3_plle_training(struct clk *c)
1780 {
1781         u32 val;
1782
1783         /* PLLE is already disabled, and setup cleared;
1784          * create falling edge on PLLE IDDQ input */
1785         val = pmc_readl(PMC_SATA_PWRGT);
1786         val |= PMC_SATA_PWRGT_PLLE_IDDQ_VALUE;
1787         pmc_writel(val, PMC_SATA_PWRGT);
1788
1789         val = pmc_readl(PMC_SATA_PWRGT);
1790         val |= PMC_SATA_PWRGT_PLLE_IDDQ_SWCTL;
1791         pmc_writel(val, PMC_SATA_PWRGT);
1792
1793         val = pmc_readl(PMC_SATA_PWRGT);
1794         val &= ~PMC_SATA_PWRGT_PLLE_IDDQ_VALUE;
1795         pmc_writel(val, PMC_SATA_PWRGT);
1796
1797         do {
1798                 val = clk_readl(c->reg + PLL_MISC(c));
1799         } while (!(val & PLLE_MISC_READY));
1800 }
1801
1802 static int tegra3_plle_configure(struct clk *c, bool force_training)
1803 {
1804         u32 val;
1805         const struct clk_pll_freq_table *sel;
1806         unsigned long rate = c->u.pll.fixed_rate;
1807         unsigned long input_rate = clk_get_rate(c->parent);
1808
1809         for (sel = c->u.pll.freq_table; sel->input_rate != 0; sel++) {
1810                 if (sel->input_rate == input_rate && sel->output_rate == rate)
1811                         break;
1812         }
1813
1814         if (sel->input_rate == 0)
1815                 return -ENOSYS;
1816
1817         /* disable PLLE, clear setup fiels */
1818         tegra3_plle_clk_disable(c);
1819
1820         val = clk_readl(c->reg + PLL_MISC(c));
1821         val &= ~(PLLE_MISC_LOCK_ENABLE | PLLE_MISC_SETUP_MASK);
1822         clk_writel(val, c->reg + PLL_MISC(c));
1823
1824         /* training */
1825         val = clk_readl(c->reg + PLL_MISC(c));
1826         if (force_training || (!(val & PLLE_MISC_READY)))
1827                 tegra3_plle_training(c);
1828
1829         /* configure dividers, setup, disable SS */
1830         val = clk_readl(c->reg + PLL_BASE);
1831         val &= ~PLLE_BASE_DIV_MASK;
1832         val |= PLLE_BASE_DIV(sel->m, sel->n, sel->p, sel->cpcon);
1833         clk_writel(val, c->reg + PLL_BASE);
1834         c->mul = sel->n;
1835         c->div = sel->m * sel->p;
1836
1837         val = clk_readl(c->reg + PLL_MISC(c));
1838         val |= PLLE_MISC_SETUP_VALUE;
1839         val |= PLLE_MISC_LOCK_ENABLE;
1840         clk_writel(val, c->reg + PLL_MISC(c));
1841
1842         val = clk_readl(PLLE_SS_CTRL);
1843         val |= PLLE_SS_DISABLE;
1844         clk_writel(val, PLLE_SS_CTRL);
1845
1846         /* enable and lock PLLE*/
1847         val = clk_readl(c->reg + PLL_BASE);
1848         val |= (PLLE_BASE_CML_ENABLE | PLLE_BASE_ENABLE);
1849         clk_writel(val, c->reg + PLL_BASE);
1850
1851         tegra3_pll_clk_wait_for_lock(c, c->reg + PLL_MISC(c), PLLE_MISC_LOCK);
1852
1853 #if USE_PLLE_SS
1854         /* configure spread spectrum coefficients */
1855         /* FIXME: coefficients for 216MHZ input? */
1856 #ifdef CONFIG_TEGRA_SILICON_PLATFORM
1857         if (input_rate == 12000000)
1858 #endif
1859         {
1860                 val = clk_readl(PLLE_SS_CTRL);
1861                 val &= ~(PLLE_SS_COEFFICIENTS_MASK | PLLE_SS_DISABLE);
1862                 val |= PLLE_SS_COEFFICIENTS_12MHZ;
1863                 clk_writel(val, PLLE_SS_CTRL);
1864         }
1865 #endif
1866         return 0;
1867 }
1868
1869 static int tegra3_plle_clk_enable(struct clk *c)
1870 {
1871         pr_debug("%s on clock %s\n", __func__, c->name);
1872         return tegra3_plle_configure(c, !c->set);
1873 }
1874
1875 static struct clk_ops tegra_plle_ops = {
1876         .init                   = tegra3_plle_clk_init,
1877         .enable                 = tegra3_plle_clk_enable,
1878         .disable                = tegra3_plle_clk_disable,
1879 };
1880
1881 /* Clock divider ops (non-atomic shared register access) */
1882 static DEFINE_SPINLOCK(pll_div_lock);
1883
1884 static int tegra3_pll_div_clk_set_rate(struct clk *c, unsigned long rate);
1885 static void tegra3_pll_div_clk_init(struct clk *c)
1886 {
1887         if (c->flags & DIV_U71) {
1888                 u32 divu71;
1889                 u32 val = clk_readl(c->reg);
1890                 val >>= c->reg_shift;
1891                 c->state = (val & PLL_OUT_CLKEN) ? ON : OFF;
1892                 if (!(val & PLL_OUT_RESET_DISABLE))
1893                         c->state = OFF;
1894
1895                 if (c->u.pll_div.default_rate) {
1896                         int ret = tegra3_pll_div_clk_set_rate(
1897                                         c, c->u.pll_div.default_rate);
1898                         if (!ret)
1899                                 return;
1900                 }
1901                 divu71 = (val & PLL_OUT_RATIO_MASK) >> PLL_OUT_RATIO_SHIFT;
1902                 c->div = (divu71 + 2);
1903                 c->mul = 2;
1904         } else if (c->flags & DIV_2) {
1905                 c->state = ON;
1906                 if (c->flags & (PLLD | PLLX)) {
1907                         c->div = 2;
1908                         c->mul = 1;
1909                 }
1910                 else
1911                         BUG();
1912         } else {
1913                 c->state = ON;
1914                 c->div = 1;
1915                 c->mul = 1;
1916         }
1917 }
1918
1919 static int tegra3_pll_div_clk_enable(struct clk *c)
1920 {
1921         u32 val;
1922         u32 new_val;
1923         unsigned long flags;
1924
1925         pr_debug("%s: %s\n", __func__, c->name);
1926         if (c->flags & DIV_U71) {
1927                 spin_lock_irqsave(&pll_div_lock, flags);
1928                 val = clk_readl(c->reg);
1929                 new_val = val >> c->reg_shift;
1930                 new_val &= 0xFFFF;
1931
1932                 new_val |= PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
1933
1934                 val &= ~(0xFFFF << c->reg_shift);
1935                 val |= new_val << c->reg_shift;
1936                 clk_writel_delay(val, c->reg);
1937                 spin_unlock_irqrestore(&pll_div_lock, flags);
1938                 return 0;
1939         } else if (c->flags & DIV_2) {
1940                 return 0;
1941         }
1942         return -EINVAL;
1943 }
1944
1945 static void tegra3_pll_div_clk_disable(struct clk *c)
1946 {
1947         u32 val;
1948         u32 new_val;
1949         unsigned long flags;
1950
1951         pr_debug("%s: %s\n", __func__, c->name);
1952         if (c->flags & DIV_U71) {
1953                 spin_lock_irqsave(&pll_div_lock, flags);
1954                 val = clk_readl(c->reg);
1955                 new_val = val >> c->reg_shift;
1956                 new_val &= 0xFFFF;
1957
1958                 new_val &= ~(PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE);
1959
1960                 val &= ~(0xFFFF << c->reg_shift);
1961                 val |= new_val << c->reg_shift;
1962                 clk_writel_delay(val, c->reg);
1963                 spin_unlock_irqrestore(&pll_div_lock, flags);
1964         }
1965 }
1966
1967 static int tegra3_pll_div_clk_set_rate(struct clk *c, unsigned long rate)
1968 {
1969         u32 val;
1970         u32 new_val;
1971         int divider_u71;
1972         unsigned long parent_rate = clk_get_rate(c->parent);
1973         unsigned long flags;
1974
1975         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
1976         if (c->flags & DIV_U71) {
1977                 divider_u71 = clk_div71_get_divider(
1978                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
1979                 if (divider_u71 >= 0) {
1980                         spin_lock_irqsave(&pll_div_lock, flags);
1981                         val = clk_readl(c->reg);
1982                         new_val = val >> c->reg_shift;
1983                         new_val &= 0xFFFF;
1984                         if (c->flags & DIV_U71_FIXED)
1985                                 new_val |= PLL_OUT_OVERRIDE;
1986                         new_val &= ~PLL_OUT_RATIO_MASK;
1987                         new_val |= divider_u71 << PLL_OUT_RATIO_SHIFT;
1988
1989                         val &= ~(0xFFFF << c->reg_shift);
1990                         val |= new_val << c->reg_shift;
1991                         clk_writel_delay(val, c->reg);
1992                         c->div = divider_u71 + 2;
1993                         c->mul = 2;
1994                         spin_unlock_irqrestore(&pll_div_lock, flags);
1995                         return 0;
1996                 }
1997         } else if (c->flags & DIV_2)
1998                 return clk_set_rate(c->parent, rate * 2);
1999
2000         return -EINVAL;
2001 }
2002
2003 static long tegra3_pll_div_clk_round_rate(struct clk *c, unsigned long rate)
2004 {
2005         int divider;
2006         unsigned long parent_rate = clk_get_rate(c->parent);
2007         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
2008
2009         if (c->flags & DIV_U71) {
2010                 divider = clk_div71_get_divider(
2011                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
2012                 if (divider < 0)
2013                         return divider;
2014                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
2015         } else if (c->flags & DIV_2)
2016                 /* no rounding - fixed DIV_2 dividers pass rate to parent PLL */
2017                 return rate;
2018
2019         return -EINVAL;
2020 }
2021
2022 static struct clk_ops tegra_pll_div_ops = {
2023         .init                   = tegra3_pll_div_clk_init,
2024         .enable                 = tegra3_pll_div_clk_enable,
2025         .disable                = tegra3_pll_div_clk_disable,
2026         .set_rate               = tegra3_pll_div_clk_set_rate,
2027         .round_rate             = tegra3_pll_div_clk_round_rate,
2028 };
2029
2030 /* Periph clk ops */
2031 static inline u32 periph_clk_source_mask(struct clk *c)
2032 {
2033         if (c->flags & MUX8)
2034                  return 7 << 29;
2035         else if (c->flags & MUX_PWM)
2036                 return 3 << 28;
2037         else if (c->flags & MUX_CLK_OUT)
2038                 return 3 << (c->u.periph.clk_num + 4);
2039         else if (c->flags & PLLD)
2040                 return PLLD_BASE_DSIB_MUX_MASK;
2041         else
2042                 return 3 << 30;
2043 }
2044
2045 static inline u32 periph_clk_source_shift(struct clk *c)
2046 {
2047         if (c->flags & MUX8)
2048                  return 29;
2049         else if (c->flags & MUX_PWM)
2050                 return 28;
2051         else if (c->flags & MUX_CLK_OUT)
2052                 return c->u.periph.clk_num + 4;
2053         else if (c->flags & PLLD)
2054                 return PLLD_BASE_DSIB_MUX_SHIFT;
2055         else
2056                 return 30;
2057 }
2058
2059 static void tegra3_periph_clk_init(struct clk *c)
2060 {
2061         u32 val = clk_readl(c->reg);
2062         const struct clk_mux_sel *mux = 0;
2063         const struct clk_mux_sel *sel;
2064         if (c->flags & MUX) {
2065                 for (sel = c->inputs; sel->input != NULL; sel++) {
2066                         if (((val & periph_clk_source_mask(c)) >>
2067                             periph_clk_source_shift(c)) == sel->value)
2068                                 mux = sel;
2069                 }
2070                 BUG_ON(!mux);
2071
2072                 c->parent = mux->input;
2073         } else {
2074                 c->parent = c->inputs[0].input;
2075         }
2076
2077         if (c->flags & DIV_U71) {
2078                 u32 divu71 = val & PERIPH_CLK_SOURCE_DIVU71_MASK;
2079                 if (c->flags & DIV_U71_IDLE) {
2080                         val &= ~(PERIPH_CLK_SOURCE_DIVU71_MASK <<
2081                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
2082                         val |= (PERIPH_CLK_SOURCE_DIVIDLE_VAL <<
2083                                 PERIPH_CLK_SOURCE_DIVIDLE_SHIFT);
2084                         clk_writel(val, c->reg);
2085                 }
2086                 c->div = divu71 + 2;
2087                 c->mul = 2;
2088         } else if (c->flags & DIV_U151) {
2089                 u32 divu151 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
2090                 if ((c->flags & DIV_U151_UART) &&
2091                     (!(val & PERIPH_CLK_UART_DIV_ENB))) {
2092                         divu151 = 0;
2093                 }
2094                 c->div = divu151 + 2;
2095                 c->mul = 2;
2096         } else if (c->flags & DIV_U16) {
2097                 u32 divu16 = val & PERIPH_CLK_SOURCE_DIVU16_MASK;
2098                 c->div = divu16 + 1;
2099                 c->mul = 1;
2100         } else {
2101                 c->div = 1;
2102                 c->mul = 1;
2103         }
2104
2105         c->state = ON;
2106
2107         if (c->flags & PERIPH_NO_ENB)
2108                 return;
2109
2110         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
2111                 c->state = OFF;
2112         if (!(c->flags & PERIPH_NO_RESET))
2113                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c))
2114                         c->state = OFF;
2115 }
2116
2117 static int tegra3_periph_clk_enable(struct clk *c)
2118 {
2119         unsigned long flags;
2120         pr_debug("%s on clock %s\n", __func__, c->name);
2121
2122         if (c->flags & PERIPH_NO_ENB)
2123                 return 0;
2124
2125         spin_lock_irqsave(&periph_refcount_lock, flags);
2126
2127         tegra_periph_clk_enable_refcount[c->u.periph.clk_num]++;
2128         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] > 1) {
2129                 spin_unlock_irqrestore(&periph_refcount_lock, flags);
2130                 return 0;
2131         }
2132
2133         clk_writel_delay(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_SET_REG(c));
2134         if (!(c->flags & PERIPH_NO_RESET) && !(c->flags & PERIPH_MANUAL_RESET)) {
2135                 if (clk_readl(PERIPH_CLK_TO_RST_REG(c)) & PERIPH_CLK_TO_BIT(c)) {
2136                         udelay(5);      /* reset propagation delay */
2137                         clk_writel(PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_RST_CLR_REG(c));
2138                 }
2139         }
2140         spin_unlock_irqrestore(&periph_refcount_lock, flags);
2141         return 0;
2142 }
2143
2144 static void tegra3_periph_clk_disable(struct clk *c)
2145 {
2146         unsigned long val, flags;
2147         pr_debug("%s on clock %s\n", __func__, c->name);
2148
2149         if (c->flags & PERIPH_NO_ENB)
2150                 return;
2151
2152         spin_lock_irqsave(&periph_refcount_lock, flags);
2153
2154         if (c->refcnt)
2155                 tegra_periph_clk_enable_refcount[c->u.periph.clk_num]--;
2156
2157         if (tegra_periph_clk_enable_refcount[c->u.periph.clk_num] == 0) {
2158                 /* If peripheral is in the APB bus then read the APB bus to
2159                  * flush the write operation in apb bus. This will avoid the
2160                  * peripheral access after disabling clock*/
2161                 if (c->flags & PERIPH_ON_APB)
2162                         val = chipid_readl();
2163
2164                 clk_writel_delay(
2165                         PERIPH_CLK_TO_BIT(c), PERIPH_CLK_TO_ENB_CLR_REG(c));
2166         }
2167         spin_unlock_irqrestore(&periph_refcount_lock, flags);
2168 }
2169
2170 static void tegra3_periph_clk_reset(struct clk *c, bool assert)
2171 {
2172         unsigned long val;
2173         pr_debug("%s %s on clock %s\n", __func__,
2174                  assert ? "assert" : "deassert", c->name);
2175
2176         if (c->flags & PERIPH_NO_ENB)
2177                 return;
2178
2179         if (!(c->flags & PERIPH_NO_RESET)) {
2180                 if (assert) {
2181                         /* If peripheral is in the APB bus then read the APB
2182                          * bus to flush the write operation in apb bus. This
2183                          * will avoid the peripheral access after disabling
2184                          * clock */
2185                         if (c->flags & PERIPH_ON_APB)
2186                                 val = chipid_readl();
2187
2188                         clk_writel(PERIPH_CLK_TO_BIT(c),
2189                                    PERIPH_CLK_TO_RST_SET_REG(c));
2190                 } else
2191                         clk_writel(PERIPH_CLK_TO_BIT(c),
2192                                    PERIPH_CLK_TO_RST_CLR_REG(c));
2193         }
2194 }
2195
2196 static int tegra3_periph_clk_set_parent(struct clk *c, struct clk *p)
2197 {
2198         u32 val;
2199         const struct clk_mux_sel *sel;
2200         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
2201
2202         if (!(c->flags & MUX))
2203                 return (p == c->parent) ? 0 : (-EINVAL);
2204
2205         for (sel = c->inputs; sel->input != NULL; sel++) {
2206                 if (sel->input == p) {
2207                         val = clk_readl(c->reg);
2208                         val &= ~periph_clk_source_mask(c);
2209                         val |= (sel->value << periph_clk_source_shift(c));
2210
2211                         if (c->refcnt)
2212                                 clk_enable(p);
2213
2214                         clk_writel_delay(val, c->reg);
2215
2216                         if (c->refcnt && c->parent)
2217                                 clk_disable(c->parent);
2218
2219                         clk_reparent(c, p);
2220                         return 0;
2221                 }
2222         }
2223
2224         return -EINVAL;
2225 }
2226
2227 static int tegra3_periph_clk_set_rate(struct clk *c, unsigned long rate)
2228 {
2229         u32 val;
2230         int divider;
2231         unsigned long parent_rate = clk_get_rate(c->parent);
2232
2233         if (c->flags & DIV_U71) {
2234                 divider = clk_div71_get_divider(
2235                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
2236                 if (divider >= 0) {
2237                         val = clk_readl(c->reg);
2238                         val &= ~PERIPH_CLK_SOURCE_DIVU71_MASK;
2239                         val |= divider;
2240                         clk_writel_delay(val, c->reg);
2241                         c->div = divider + 2;
2242                         c->mul = 2;
2243                         return 0;
2244                 }
2245         } else if (c->flags & DIV_U151) {
2246                 divider = clk_div151_get_divider(
2247                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
2248                 if (divider >= 0) {
2249                         val = clk_readl(c->reg);
2250                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
2251                         val |= divider;
2252                         if (c->flags & DIV_U151_UART) {
2253                                 if (divider)
2254                                         val |= PERIPH_CLK_UART_DIV_ENB;
2255                                 else
2256                                         val &= ~PERIPH_CLK_UART_DIV_ENB;
2257                         }
2258                         clk_writel_delay(val, c->reg);
2259                         c->div = divider + 2;
2260                         c->mul = 2;
2261                         return 0;
2262                 }
2263         } else if (c->flags & DIV_U16) {
2264                 divider = clk_div16_get_divider(parent_rate, rate);
2265                 if (divider >= 0) {
2266                         val = clk_readl(c->reg);
2267                         val &= ~PERIPH_CLK_SOURCE_DIVU16_MASK;
2268                         val |= divider;
2269                         clk_writel_delay(val, c->reg);
2270                         c->div = divider + 1;
2271                         c->mul = 1;
2272                         return 0;
2273                 }
2274         } else if (parent_rate <= rate) {
2275                 c->div = 1;
2276                 c->mul = 1;
2277                 return 0;
2278         }
2279         return -EINVAL;
2280 }
2281
2282 static long tegra3_periph_clk_round_rate(struct clk *c,
2283         unsigned long rate)
2284 {
2285         int divider;
2286         unsigned long parent_rate = clk_get_rate(c->parent);
2287         pr_debug("%s: %s %lu\n", __func__, c->name, rate);
2288
2289         if (c->flags & DIV_U71) {
2290                 divider = clk_div71_get_divider(
2291                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
2292                 if (divider < 0)
2293                         return divider;
2294
2295                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
2296         } else if (c->flags & DIV_U151) {
2297                 divider = clk_div151_get_divider(
2298                         parent_rate, rate, c->flags, ROUND_DIVIDER_UP);
2299                 if (divider < 0)
2300                         return divider;
2301
2302                 return DIV_ROUND_UP(parent_rate * 2, divider + 2);
2303         } else if (c->flags & DIV_U16) {
2304                 divider = clk_div16_get_divider(parent_rate, rate);
2305                 if (divider < 0)
2306                         return divider;
2307                 return DIV_ROUND_UP(parent_rate, divider + 1);
2308         }
2309         return -EINVAL;
2310 }
2311
2312 static struct clk_ops tegra_periph_clk_ops = {
2313         .init                   = &tegra3_periph_clk_init,
2314         .enable                 = &tegra3_periph_clk_enable,
2315         .disable                = &tegra3_periph_clk_disable,
2316         .set_parent             = &tegra3_periph_clk_set_parent,
2317         .set_rate               = &tegra3_periph_clk_set_rate,
2318         .round_rate             = &tegra3_periph_clk_round_rate,
2319         .reset                  = &tegra3_periph_clk_reset,
2320 };
2321
2322
2323 /* Periph extended clock configuration ops */
2324 static int
2325 tegra3_vi_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
2326 {
2327         if (p == TEGRA_CLK_VI_INP_SEL) {
2328                 u32 val = clk_readl(c->reg);
2329                 val &= ~PERIPH_CLK_VI_SEL_EX_MASK;
2330                 val |= (setting << PERIPH_CLK_VI_SEL_EX_SHIFT) &
2331                         PERIPH_CLK_VI_SEL_EX_MASK;
2332                 clk_writel(val, c->reg);
2333                 return 0;
2334         }
2335         return -EINVAL;
2336 }
2337
2338 static struct clk_ops tegra_vi_clk_ops = {
2339         .init                   = &tegra3_periph_clk_init,
2340         .enable                 = &tegra3_periph_clk_enable,
2341         .disable                = &tegra3_periph_clk_disable,
2342         .set_parent             = &tegra3_periph_clk_set_parent,
2343         .set_rate               = &tegra3_periph_clk_set_rate,
2344         .round_rate             = &tegra3_periph_clk_round_rate,
2345         .clk_cfg_ex             = &tegra3_vi_clk_cfg_ex,
2346         .reset                  = &tegra3_periph_clk_reset,
2347 };
2348
2349 static int
2350 tegra3_nand_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
2351 {
2352         if (p == TEGRA_CLK_NAND_PAD_DIV2_ENB) {
2353                 u32 val = clk_readl(c->reg);
2354                 if (setting)
2355                         val |= PERIPH_CLK_NAND_DIV_EX_ENB;
2356                 else
2357                         val &= ~PERIPH_CLK_NAND_DIV_EX_ENB;
2358                 clk_writel(val, c->reg);
2359                 return 0;
2360         }
2361         return -EINVAL;
2362 }
2363
2364 static struct clk_ops tegra_nand_clk_ops = {
2365         .init                   = &tegra3_periph_clk_init,
2366         .enable                 = &tegra3_periph_clk_enable,
2367         .disable                = &tegra3_periph_clk_disable,
2368         .set_parent             = &tegra3_periph_clk_set_parent,
2369         .set_rate               = &tegra3_periph_clk_set_rate,
2370         .round_rate             = &tegra3_periph_clk_round_rate,
2371         .clk_cfg_ex             = &tegra3_nand_clk_cfg_ex,
2372         .reset                  = &tegra3_periph_clk_reset,
2373 };
2374
2375
2376 static int
2377 tegra3_dtv_clk_cfg_ex(struct clk *c, enum tegra_clk_ex_param p, u32 setting)
2378 {
2379         if (p == TEGRA_CLK_DTV_INVERT) {
2380                 u32 val = clk_readl(c->reg);
2381                 if (setting)
2382                         val |= PERIPH_CLK_DTV_POLARITY_INV;
2383                 else
2384                         val &= ~PERIPH_CLK_DTV_POLARITY_INV;
2385                 clk_writel(val, c->reg);
2386                 return 0;
2387         }
2388         return -EINVAL;
2389 }
2390
2391 static struct clk_ops tegra_dtv_clk_ops = {
2392         .init                   = &tegra3_periph_clk_init,
2393         .enable                 = &tegra3_periph_clk_enable,
2394         .disable                = &tegra3_periph_clk_disable,
2395         .set_parent             = &tegra3_periph_clk_set_parent,
2396         .set_rate               = &tegra3_periph_clk_set_rate,
2397         .round_rate             = &tegra3_periph_clk_round_rate,
2398         .clk_cfg_ex             = &tegra3_dtv_clk_cfg_ex,
2399         .reset                  = &tegra3_periph_clk_reset,
2400 };
2401
2402 static int tegra3_dsib_clk_set_parent(struct clk *c, struct clk *p)
2403 {
2404         const struct clk_mux_sel *sel;
2405         struct clk *d = tegra_get_clock_by_name("pll_d");
2406
2407         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
2408
2409         for (sel = c->inputs; sel->input != NULL; sel++) {
2410                 if (sel->input == p) {
2411                         if (c->refcnt)
2412                                 clk_enable(p);
2413
2414                         /* The DSIB parent selection bit is in PLLD base
2415                            register - can not do direct r-m-w, must be
2416                            protected by PLLD lock */
2417                         tegra_clk_cfg_ex(
2418                                 d, TEGRA_CLK_PLLD_MIPI_MUX_SEL, sel->value);
2419
2420                         if (c->refcnt && c->parent)
2421                                 clk_disable(c->parent);
2422
2423                         clk_reparent(c, p);
2424                         return 0;
2425                 }
2426         }
2427
2428         return -EINVAL;
2429 }
2430
2431 static struct clk_ops tegra_dsib_clk_ops = {
2432         .init                   = &tegra3_periph_clk_init,
2433         .enable                 = &tegra3_periph_clk_enable,
2434         .disable                = &tegra3_periph_clk_disable,
2435         .set_parent             = &tegra3_dsib_clk_set_parent,
2436         .set_rate               = &tegra3_periph_clk_set_rate,
2437         .round_rate             = &tegra3_periph_clk_round_rate,
2438         .reset                  = &tegra3_periph_clk_reset,
2439 };
2440
2441 /* pciex clock support only reset function */
2442 static struct clk_ops tegra_pciex_clk_ops = {
2443         .reset    = tegra3_periph_clk_reset,
2444 };
2445
2446 /* Output clock ops (non-atomic shared register access) */
2447
2448 static DEFINE_SPINLOCK(clk_out_lock);
2449
2450 static void tegra3_clk_out_init(struct clk *c)
2451 {
2452         const struct clk_mux_sel *mux = 0;
2453         const struct clk_mux_sel *sel;
2454         u32 val = pmc_readl(c->reg);
2455
2456         c->state = (val & (0x1 << c->u.periph.clk_num)) ? ON : OFF;
2457         c->mul = 1;
2458         c->div = 1;
2459
2460         for (sel = c->inputs; sel->input != NULL; sel++) {
2461                 if (((val & periph_clk_source_mask(c)) >>
2462                      periph_clk_source_shift(c)) == sel->value)
2463                         mux = sel;
2464         }
2465         BUG_ON(!mux);
2466         c->parent = mux->input;
2467 }
2468
2469 static int tegra3_clk_out_enable(struct clk *c)
2470 {
2471         u32 val;
2472         unsigned long flags;
2473
2474         pr_debug("%s on clock %s\n", __func__, c->name);
2475
2476         spin_lock_irqsave(&clk_out_lock, flags);
2477         val = pmc_readl(c->reg);
2478         val |= (0x1 << c->u.periph.clk_num);
2479         pmc_writel(val, c->reg);
2480         spin_unlock_irqrestore(&clk_out_lock, flags);
2481
2482         return 0;
2483 }
2484
2485 static void tegra3_clk_out_disable(struct clk *c)
2486 {
2487         u32 val;
2488         unsigned long flags;
2489
2490         pr_debug("%s on clock %s\n", __func__, c->name);
2491
2492         spin_lock_irqsave(&clk_out_lock, flags);
2493         val = pmc_readl(c->reg);
2494         val &= ~(0x1 << c->u.periph.clk_num);
2495         pmc_writel(val, c->reg);
2496         spin_unlock_irqrestore(&clk_out_lock, flags);
2497 }
2498
2499 static int tegra3_clk_out_set_parent(struct clk *c, struct clk *p)
2500 {
2501         u32 val;
2502         unsigned long flags;
2503         const struct clk_mux_sel *sel;
2504
2505         pr_debug("%s: %s %s\n", __func__, c->name, p->name);
2506
2507         for (sel = c->inputs; sel->input != NULL; sel++) {
2508                 if (sel->input == p) {
2509                         if (c->refcnt)
2510                                 clk_enable(p);
2511
2512                         spin_lock_irqsave(&clk_out_lock, flags);
2513                         val = pmc_readl(c->reg);
2514                         val &= ~periph_clk_source_mask(c);
2515                         val |= (sel->value << periph_clk_source_shift(c));
2516                         pmc_writel(val, c->reg);
2517                         spin_unlock_irqrestore(&clk_out_lock, flags);
2518
2519                         if (c->refcnt && c->parent)
2520                                 clk_disable(c->parent);
2521
2522                         clk_reparent(c, p);
2523                         return 0;
2524                 }
2525         }
2526         return -EINVAL;
2527 }
2528
2529 static struct clk_ops tegra_clk_out_ops = {
2530         .init                   = &tegra3_clk_out_init,
2531         .enable                 = &tegra3_clk_out_enable,
2532         .disable                = &tegra3_clk_out_disable,
2533         .set_parent             = &tegra3_clk_out_set_parent,
2534 };
2535
2536
2537 /* External memory controller clock ops */
2538 static void tegra3_emc_clk_init(struct clk *c)
2539 {
2540         tegra3_periph_clk_init(c);
2541         tegra_emc_dram_type_init(c);
2542
2543         /* On A01 limit EMC maximum rate to boot frequency;
2544            starting with A02 full PLLM range should be supported */
2545         if (tegra_revision == TEGRA_REVISION_A01)
2546                 c->max_rate = clk_get_rate_locked(c);
2547         else
2548                 c->max_rate = clk_get_rate(c->parent);
2549 }
2550
2551 static long tegra3_emc_clk_round_rate(struct clk *c, unsigned long rate)
2552 {
2553         long new_rate = max(rate, c->min_rate);
2554
2555         new_rate = tegra_emc_round_rate(new_rate);
2556         if (new_rate < 0)
2557                 new_rate = c->max_rate;
2558
2559         return new_rate;
2560 }
2561
2562 static int tegra3_emc_clk_set_rate(struct clk *c, unsigned long rate)
2563 {
2564         int ret;
2565         u32 div_value;
2566         struct clk *p;
2567
2568         /* The tegra3 memory controller has an interlock with the clock
2569          * block that allows memory shadowed registers to be updated,
2570          * and then transfer them to the main registers at the same
2571          * time as the clock update without glitches. During clock change
2572          * operation both clock parent and divider may change simultaneously
2573          * to achieve requested rate. */
2574         p = tegra_emc_predict_parent(rate, &div_value);
2575         div_value += 2;         /* emc has fractional DIV_U71 divider */
2576         if (!p)
2577                 return -EINVAL;
2578
2579         if (p == c->parent) {
2580                 if (div_value == c->div)
2581                         return 0;
2582         } else if (c->refcnt)
2583                 clk_enable(p);
2584
2585         ret = tegra_emc_set_rate(rate);
2586         if (ret < 0)
2587                 return ret;
2588
2589         if (p != c->parent) {
2590                 if(c->refcnt && c->parent)
2591                         clk_disable(c->parent);
2592                 clk_reparent(c, p);
2593         }
2594         c->div = div_value;
2595         c->mul = 2;
2596         return 0;
2597 }
2598
2599 static struct clk_ops tegra_emc_clk_ops = {
2600         .init                   = &tegra3_emc_clk_init,
2601         .enable                 = &tegra3_periph_clk_enable,
2602         .disable                = &tegra3_periph_clk_disable,
2603         .set_rate               = &tegra3_emc_clk_set_rate,
2604         .round_rate             = &tegra3_emc_clk_round_rate,
2605         .reset                  = &tegra3_periph_clk_reset,
2606         .shared_bus_update      = &tegra3_clk_shared_bus_update,
2607 };
2608
2609 /* Clock doubler ops (non-atomic shared register access) */
2610 static DEFINE_SPINLOCK(doubler_lock);
2611
2612 static void tegra3_clk_double_init(struct clk *c)
2613 {
2614         u32 val = clk_readl(c->reg);
2615         c->mul = val & (0x1 << c->reg_shift) ? 1 : 2;
2616         c->div = 1;
2617         c->state = ON;
2618         if (!(clk_readl(PERIPH_CLK_TO_ENB_REG(c)) & PERIPH_CLK_TO_BIT(c)))
2619                 c->state = OFF;
2620 };
2621
2622 static int tegra3_clk_double_set_rate(struct clk *c, unsigned long rate)
2623 {
2624         u32 val;
2625         unsigned long parent_rate = clk_get_rate(c->parent);
2626         unsigned long flags;
2627
2628         if (rate == parent_rate) {
2629                 spin_lock_irqsave(&doubler_lock, flags);
2630                 val = clk_readl(c->reg) | (0x1 << c->reg_shift);
2631                 clk_writel(val, c->reg);
2632                 c->mul = 1;
2633                 c->div = 1;
2634                 spin_unlock_irqrestore(&doubler_lock, flags);
2635                 return 0;
2636         } else if (rate == 2 * parent_rate) {
2637                 spin_lock_irqsave(&doubler_lock, flags);
2638                 val = clk_readl(c->reg) & (~(0x1 << c->reg_shift));
2639                 clk_writel(val, c->reg);
2640                 c->mul = 2;
2641                 c->div = 1;
2642                 spin_unlock_irqrestore(&doubler_lock, flags);
2643                 return 0;
2644         }
2645         return -EINVAL;
2646 }
2647
2648 static struct clk_ops tegra_clk_double_ops = {
2649         .init                   = &tegra3_clk_double_init,
2650         .enable                 = &tegra3_periph_clk_enable,
2651         .disable                = &tegra3_periph_clk_disable,
2652         .set_rate               = &tegra3_clk_double_set_rate,
2653 };
2654
2655 /* Audio sync clock ops */
2656 static int tegra3_sync_source_set_rate(struct clk *c, unsigned long rate)
2657 {
2658         c->rate = rate;
2659         return 0;
2660 }
2661
2662 static struct clk_ops tegra_sync_source_ops = {
2663         .set_rate               = &tegra3_sync_source_set_rate,
2664 };
2665
2666 static void tegra3_audio_sync_clk_init(struct clk *c)
2667 {
2668         int source;
2669         const struct clk_mux_sel *sel;
2670         u32 val = clk_readl(c->reg);
2671         c->state = (val & AUDIO_SYNC_DISABLE_BIT) ? OFF : ON;
2672         source = val & AUDIO_SYNC_SOURCE_MASK;
2673         for (sel = c->inputs; sel->input != NULL; sel++)
2674                 if (sel->value == source)
2675                         break;
2676         BUG_ON(sel->input == NULL);
2677         c->parent = sel->input;
2678 }
2679
2680 static int tegra3_audio_sync_clk_enable(struct clk *c)
2681 {
2682         u32 val = clk_readl(c->reg);
2683         clk_writel((val & (~AUDIO_SYNC_DISABLE_BIT)), c->reg);
2684         return 0;
2685 }
2686
2687 static void tegra3_audio_sync_clk_disable(struct clk *c)
2688 {
2689         u32 val = clk_readl(c->reg);
2690         clk_writel((val | AUDIO_SYNC_DISABLE_BIT), c->reg);
2691 }
2692
2693 static int tegra3_audio_sync_clk_set_parent(struct clk *c, struct clk *p)
2694 {
2695         u32 val;
2696         const struct clk_mux_sel *sel;
2697         for (sel = c->inputs; sel->input != NULL; sel++) {
2698                 if (sel->input == p) {
2699                         val = clk_readl(c->reg);
2700                         val &= ~AUDIO_SYNC_SOURCE_MASK;
2701                         val |= sel->value;
2702
2703                         if (c->refcnt)
2704                                 clk_enable(p);
2705
2706                         clk_writel(val, c->reg);
2707
2708                         if (c->refcnt && c->parent)
2709                                 clk_disable(c->parent);
2710
2711                         clk_reparent(c, p);
2712                         return 0;
2713                 }
2714         }
2715
2716         return -EINVAL;
2717 }
2718
2719 static struct clk_ops tegra_audio_sync_clk_ops = {
2720         .init       = tegra3_audio_sync_clk_init,
2721         .enable     = tegra3_audio_sync_clk_enable,
2722         .disable    = tegra3_audio_sync_clk_disable,
2723         .set_parent = tegra3_audio_sync_clk_set_parent,
2724 };
2725
2726 /* cml0 (pcie), and cml1 (sata) clock ops (non-atomic shared register access) */
2727 static DEFINE_SPINLOCK(cml_lock);
2728
2729 static void tegra3_cml_clk_init(struct clk *c)
2730 {
2731         u32 val = clk_readl(c->reg);
2732         c->state = val & (0x1 << c->u.periph.clk_num) ? ON : OFF;
2733 }
2734
2735 static int tegra3_cml_clk_enable(struct clk *c)
2736 {
2737         u32 val;
2738         unsigned long flags;
2739
2740         spin_lock_irqsave(&cml_lock, flags);
2741         val = clk_readl(c->reg);
2742         val |= (0x1 << c->u.periph.clk_num);
2743         clk_writel(val, c->reg);
2744         spin_unlock_irqrestore(&cml_lock, flags);
2745         return 0;
2746 }
2747
2748 static void tegra3_cml_clk_disable(struct clk *c)
2749 {
2750         u32 val;
2751         unsigned long flags;
2752
2753         spin_lock_irqsave(&cml_lock, flags);
2754         val = clk_readl(c->reg);
2755         val &= ~(0x1 << c->u.periph.clk_num);
2756         clk_writel(val, c->reg);
2757         spin_unlock_irqrestore(&cml_lock, flags);
2758 }
2759
2760 static struct clk_ops tegra_cml_clk_ops = {
2761         .init                   = &tegra3_cml_clk_init,
2762         .enable                 = &tegra3_cml_clk_enable,
2763         .disable                = &tegra3_cml_clk_disable,
2764 };
2765
2766
2767 /* cbus ops */
2768 /*
2769  * Some clocks require dynamic re-locking of source PLL in order to
2770  * achieve frequency scaling granularity that matches characterized
2771  * core voltage steps. The cbus clock creates a shared bus that
2772  * provides a virtual root for such clocks to hide and synchronize
2773  * parent PLL re-locking as well as backup operations.
2774 */
2775
2776 static void tegra3_clk_cbus_init(struct clk *c)
2777 {
2778         c->state = OFF;
2779         c->set = true;
2780 }
2781
2782 static int tegra3_clk_cbus_enable(struct clk *c)
2783 {
2784         return 0;
2785 }
2786
2787 static long tegra3_clk_cbus_round_rate(struct clk *c, unsigned long rate)
2788 {
2789         int i;
2790
2791         if (!c->dvfs)
2792                 return rate;
2793
2794         /* update min now, since no dvfs table was available during init
2795            (skip placeholder entries set to 1 kHz) */
2796         if (!c->min_rate) {
2797                 for (i = 0; i < (c->dvfs->num_freqs - 1); i++) {
2798                         if (c->dvfs->freqs[i] > 1 * c->dvfs->freqs_mult) {
2799                                 c->min_rate = c->dvfs->freqs[i];
2800                                 break;
2801                         }
2802                 }
2803                 BUG_ON(!c->min_rate);
2804         }
2805         rate = max(rate, c->min_rate);
2806
2807         for (i = 0; i < (c->dvfs->num_freqs - 1); i++) {
2808                 unsigned long f = c->dvfs->freqs[i];
2809                 if (f >= rate)
2810                         break;
2811         }
2812         return c->dvfs->freqs[i];
2813 }
2814
2815 static int cbus_switch_one(struct clk *c, struct clk *p, u32 div, bool abort)
2816 {
2817         int ret = 0;
2818
2819         /* set new divider if it is bigger than the current one */
2820         if (c->div < c->mul * div) {
2821                 ret = clk_set_div(c, div);
2822                 if (ret) {
2823                         pr_err("%s: failed to set %s clock divider %u: %d\n",
2824                                __func__, c->name, div, ret);
2825                         if (abort)
2826                                 return ret;
2827                 }
2828         }
2829
2830         ret = clk_set_parent(c, p);
2831         if (ret) {
2832                 pr_err("%s: failed to set %s clock parent %s: %d\n",
2833                        __func__, c->name, p->name, ret);
2834                 if (abort)
2835                         return ret;
2836         }
2837
2838         /* set new divider if it is smaller than the current one */
2839         if (c->div > c->mul * div) {
2840                 ret = clk_set_div(c, div);
2841                 if (ret)
2842                         pr_err("%s: failed to set %s clock divider %u: %d\n",
2843                                __func__, c->name, div, ret);
2844         }
2845
2846         return ret;
2847 }
2848
2849 static int cbus_backup(struct clk *c)
2850 {
2851         int ret;
2852         struct clk *user;
2853
2854         list_for_each_entry(user, &c->shared_bus_list,
2855                         u.shared_bus_user.node) {
2856                 bool enabled = user->u.shared_bus_user.client &&
2857                         (user->u.shared_bus_user.enabled ||
2858                         user->u.shared_bus_user.client->refcnt);
2859                 if (enabled) {
2860                         ret = cbus_switch_one(user->u.shared_bus_user.client,
2861                                               c->shared_bus_backup.input,
2862                                               c->shared_bus_backup.value *
2863                                               user->div, true);
2864                         if (ret)
2865                                 return ret;
2866                 }
2867         }
2868         return 0;
2869 }
2870
2871 static void cbus_restore(struct clk *c)
2872 {
2873         struct clk *user;
2874
2875         list_for_each_entry(user, &c->shared_bus_list,
2876                         u.shared_bus_user.node) {
2877                 bool back = user->u.shared_bus_user.client && (c->parent !=
2878                         user->u.shared_bus_user.client->parent);
2879                 if (back)
2880                         cbus_switch_one(user->u.shared_bus_user.client,
2881                                         c->parent, c->div * user->div, false);
2882         }
2883 }
2884
2885 static int tegra3_clk_cbus_set_rate(struct clk *c, unsigned long rate)
2886 {
2887         int ret;
2888
2889         if (rate == 0)
2890                 return 0;
2891
2892         ret = clk_enable(c->parent);
2893         if (ret) {
2894                 pr_err("%s: failed to enable %s clock: %d\n",
2895                        __func__, c->name, ret);
2896                 return ret;
2897         }
2898
2899         ret = cbus_backup(c);
2900         if (ret)
2901                 goto out;
2902
2903         ret = clk_set_rate(c->parent, rate * c->div);
2904         if (ret) {
2905                 pr_err("%s: failed to set %s clock rate %lu: %d\n",
2906                        __func__, c->name, rate, ret);
2907                 goto out;
2908         }
2909
2910         cbus_restore(c);
2911
2912 out:
2913         clk_disable(c->parent);
2914         return ret;
2915 }
2916
2917 static struct clk_ops tegra_clk_cbus_ops = {
2918         .init = tegra3_clk_cbus_init,
2919         .enable = tegra3_clk_cbus_enable,
2920         .set_rate = tegra3_clk_cbus_set_rate,
2921         .round_rate = tegra3_clk_cbus_round_rate,
2922         .shared_bus_update = tegra3_clk_shared_bus_update,
2923 };
2924
2925 /* shared bus ops */
2926 /*
2927  * Some clocks may have multiple downstream users that need to request a
2928  * higher clock rate.  Shared bus clocks provide a unique shared_bus_user
2929  * clock to each user.  The frequency of the bus is set to the highest
2930  * enabled shared_bus_user clock, with a minimum value set by the
2931  * shared bus.
2932  */
2933
2934 static noinline int shared_bus_set_rate(struct clk *bus, unsigned long rate,
2935                                         unsigned long old_rate)
2936 {
2937         int ret, mv, old_mv;
2938         unsigned long bridge_rate = emc_bridge->u.shared_bus_user.rate;
2939
2940         /* If bridge is not needed (LPDDR2) just set bus rate */
2941         if (tegra_emc_get_dram_type() == DRAM_TYPE_LPDDR2)
2942                 return clk_set_rate_locked(bus, rate);
2943
2944         mv = tegra_dvfs_predict_millivolts(bus, rate);
2945         old_mv = tegra_dvfs_predict_millivolts(bus, old_rate);
2946         if (IS_ERR_VALUE(mv) || IS_ERR_VALUE(old_mv)) {
2947                 pr_err("%s: Failed to predict %s voltage for %lu => %lu\n",
2948                        __func__, bus->name, old_rate, rate);
2949                 return -EINVAL;
2950         }
2951
2952         /* emc bus: set bridge rate as intermediate step when crossing
2953          * bridge threshold in any direction
2954          */
2955         if (bus->flags & PERIPH_EMC_ENB) {
2956                 if (((mv > TEGRA_EMC_BRIDGE_MVOLTS_MIN) &&
2957                      (old_rate < bridge_rate)) ||
2958                     ((old_mv > TEGRA_EMC_BRIDGE_MVOLTS_MIN) &&
2959                      (rate < bridge_rate))) {
2960                         ret = clk_set_rate_locked(bus, bridge_rate);
2961                         if (ret) {
2962                                 pr_err("%s: Failed to set emc bridge rate %lu\n",
2963                                         __func__, bridge_rate);
2964                                 return ret;
2965                         }
2966                 }
2967                 return clk_set_rate_locked(bus, rate);
2968         }
2969
2970         /* sbus and cbus: enable/disable emc bridge user when crossing voltage
2971          * threshold up/down respectively; hence, emc rate is kept above the
2972          * bridge rate as long as any sbus or cbus user requires high voltage
2973          */
2974         if ((mv > TEGRA_EMC_BRIDGE_MVOLTS_MIN) &&
2975             (old_mv <= TEGRA_EMC_BRIDGE_MVOLTS_MIN)) {
2976                 ret = clk_enable(emc_bridge);
2977                 if (ret) {
2978                         pr_err("%s: Failed to enable emc bridge\n", __func__);
2979                         return ret;
2980                 }
2981         }
2982
2983         ret = clk_set_rate_locked(bus, rate);
2984         if (ret)
2985                 return ret;
2986
2987         if ((mv <= TEGRA_EMC_BRIDGE_MVOLTS_MIN) &&
2988             (old_mv > TEGRA_EMC_BRIDGE_MVOLTS_MIN))
2989                 clk_disable(emc_bridge);
2990
2991         return 0;
2992 }
2993
2994 static int tegra3_clk_shared_bus_update(struct clk *bus)
2995 {
2996         struct clk *c;
2997         unsigned long old_rate;
2998         unsigned long rate = bus->min_rate;
2999         unsigned long bw = 0;
3000         unsigned long ceiling = bus->max_rate;
3001
3002         if (detach_shared_bus)
3003                 return 0;
3004
3005         list_for_each_entry(c, &bus->shared_bus_list,
3006                         u.shared_bus_user.node) {
3007                 /* Ignore requests from disabled floor and bw users, and from
3008                  * auto-users riding the bus. Always honor ceiling users, even
3009                  * if they are disabled - we do not want to keep enabled parent
3010                  * bus just because ceiling is set.
3011                  */
3012                 if (c->u.shared_bus_user.enabled ||
3013                     (c->u.shared_bus_user.mode == SHARED_CEILING)) {
3014                         switch (c->u.shared_bus_user.mode) {
3015                         case SHARED_BW:
3016                                 if (bw < bus->max_rate)
3017                                         bw += c->u.shared_bus_user.rate;
3018                                 break;
3019                         case SHARED_CEILING:
3020                                 ceiling = min(c->u.shared_bus_user.rate,
3021                                                ceiling);
3022                                 break;
3023                         case SHARED_AUTO:
3024                         case SHARED_FLOOR:
3025                         default:
3026                                 rate = max(c->u.shared_bus_user.rate, rate);
3027                         }
3028                 }
3029         }
3030         if (bw) {
3031                 if (bus->flags & PERIPH_EMC_ENB) {
3032                         bw = tegra_emc_bw_efficiency ?
3033                                 (bw / tegra_emc_bw_efficiency) : bus->max_rate;
3034                         bw = (bw < bus->max_rate / 100) ?
3035                                 (bw * 100) : bus->max_rate;
3036                 }
3037                 bw = clk_round_rate_locked(bus, bw);
3038         }
3039         rate = min(max(rate, bw), ceiling);
3040
3041         old_rate = clk_get_rate_locked(bus);
3042         if (rate == old_rate)
3043                 return 0;
3044
3045         return shared_bus_set_rate(bus, rate, old_rate);
3046 };
3047
3048 static void tegra_clk_shared_bus_init(struct clk *c)
3049 {
3050         c->max_rate = c->parent->max_rate;
3051         c->u.shared_bus_user.rate = c->parent->max_rate;
3052         c->state = OFF;
3053         c->set = true;
3054
3055         if (c->u.shared_bus_user.client_id) {
3056                 c->u.shared_bus_user.client =
3057                         tegra_get_clock_by_name(c->u.shared_bus_user.client_id);
3058                 if (!c->u.shared_bus_user.client) {
3059                         pr_err("%s: could not find clk %s\n", __func__,
3060                                c->u.shared_bus_user.client_id);
3061                         return;
3062                 }
3063                 c->u.shared_bus_user.client->flags |=
3064                         c->parent->flags & PERIPH_ON_CBUS;
3065                 c->flags |= c->parent->flags & PERIPH_ON_CBUS;
3066                 c->div = c->u.shared_bus_user.client_div ? : 1;
3067                 c->mul = 1;
3068         }
3069
3070         list_add_tail(&c->u.shared_bus_user.node,
3071                 &c->parent->shared_bus_list);
3072 }
3073
3074 static int tegra_clk_shared_bus_set_rate(struct clk *c, unsigned long rate)
3075 {
3076         c->u.shared_bus_user.rate = rate;
3077         tegra_clk_shared_bus_update(c->parent);
3078         return 0;
3079 }
3080
3081 static long tegra_clk_shared_bus_round_rate(struct clk *c, unsigned long rate)
3082 {
3083         /* auto user follow others, by itself it run at minimum bus rate */
3084         if (c->u.shared_bus_user.mode == SHARED_AUTO)
3085                 rate = 0;
3086
3087         /* BW users should not be rounded until aggregated */
3088         if (c->u.shared_bus_user.mode == SHARED_BW)
3089                 return rate;
3090
3091         return clk_round_rate(c->parent, rate);
3092 }
3093
3094 static int tegra_clk_shared_bus_enable(struct clk *c)
3095 {
3096         c->u.shared_bus_user.enabled = true;
3097         tegra_clk_shared_bus_update(c->parent);
3098         if (c->u.shared_bus_user.client) {
3099                 return clk_enable(c->u.shared_bus_user.client);
3100         }
3101         return 0;
3102 }
3103
3104 static void tegra_clk_shared_bus_disable(struct clk *c)
3105 {
3106         if (c->u.shared_bus_user.client)
3107                 clk_disable(c->u.shared_bus_user.client);
3108         c->u.shared_bus_user.enabled = false;
3109         tegra_clk_shared_bus_update(c->parent);
3110 }
3111
3112 static void tegra_clk_shared_bus_reset(struct clk *c, bool assert)
3113 {
3114         if (c->u.shared_bus_user.client) {
3115                 if (c->u.shared_bus_user.client->ops &&
3116                     c->u.shared_bus_user.client->ops->reset)
3117                         c->u.shared_bus_user.client->ops->reset(
3118                                 c->u.shared_bus_user.client, assert);
3119         }
3120 }
3121
3122 static struct clk_ops tegra_clk_shared_bus_ops = {
3123         .init = tegra_clk_shared_bus_init,
3124         .enable = tegra_clk_shared_bus_enable,
3125         .disable = tegra_clk_shared_bus_disable,
3126         .set_rate = tegra_clk_shared_bus_set_rate,
3127         .round_rate = tegra_clk_shared_bus_round_rate,
3128         .reset = tegra_clk_shared_bus_reset,
3129 };
3130
3131 /* emc bridge ops */
3132 /* On Tegra3 platforms emc configurations for DDR3 low rates can not work
3133  * at high core voltage; the intermediate step (bridge) is mandatory whenever
3134  * core voltage is crossing the threshold: TEGRA_EMC_BRIDGE_MVOLTS_MIN (fixed
3135  * for the entire Tegra3 arch); also emc must run above the bridge rate if any
3136  * other than emc clock requires high voltage. LP CPU, memory, sbus and cbus
3137  * together include all clocks that may require core voltage above threshold
3138  * (other peripherals can reach their maximum rates below threshold). LP CPU
3139  * dependency is taken care of via tegra_emc_to_cpu_ratio() api. Memory clock
3140  * transitions are forced to step through bridge rate; sbus and cbus control
3141  * emc bridge to set emc clock floor as necessary.
3142  *
3143  * EMC bridge is implemented as a special emc shared bus user: initialized at
3144  * minimum rate until updated once by emc dvfs setup; then it is only enabled
3145  * or disabled when sbus and/or cbus voltage is crossing the threshold.
3146  */
3147 static void tegra3_clk_emc_bridge_init(struct clk *c)
3148 {
3149         tegra_clk_shared_bus_init(c);
3150         c->u.shared_bus_user.rate = 0;
3151 }
3152
3153 static int tegra3_clk_emc_bridge_set_rate(struct clk *c, unsigned long rate)
3154 {
3155         if (c->u.shared_bus_user.rate == 0)
3156                 c->u.shared_bus_user.rate = rate;
3157         return 0;
3158 }
3159
3160 static struct clk_ops tegra_clk_emc_bridge_ops = {
3161         .init = tegra3_clk_emc_bridge_init,
3162         .enable = tegra_clk_shared_bus_enable,
3163         .disable = tegra_clk_shared_bus_disable,
3164         .set_rate = tegra3_clk_emc_bridge_set_rate,
3165         .round_rate = tegra_clk_shared_bus_round_rate,
3166 };
3167
3168 /* Clock definitions */
3169 static struct clk tegra_clk_32k = {
3170         .name = "clk_32k",
3171         .rate = 32768,
3172         .ops  = NULL,
3173         .max_rate = 32768,
3174 };
3175
3176 static struct clk tegra_clk_m = {
3177         .name      = "clk_m",
3178         .flags     = ENABLE_ON_INIT,
3179         .ops       = &tegra_clk_m_ops,
3180         .reg       = 0x1fc,
3181         .reg_shift = 28,
3182         .max_rate  = 48000000,
3183 };
3184
3185 static struct clk tegra_clk_m_div2 = {
3186         .name      = "clk_m_div2",
3187         .ops       = &tegra_clk_m_div_ops,
3188         .parent    = &tegra_clk_m,
3189         .mul       = 1,
3190         .div       = 2,
3191         .state     = ON,
3192         .max_rate  = 24000000,
3193 };
3194
3195 static struct clk tegra_clk_m_div4 = {
3196         .name      = "clk_m_div4",
3197         .ops       = &tegra_clk_m_div_ops,
3198         .parent    = &tegra_clk_m,
3199         .mul       = 1,
3200         .div       = 4,
3201         .state     = ON,
3202         .max_rate  = 12000000,
3203 };
3204
3205 static struct clk tegra_pll_ref = {
3206         .name      = "pll_ref",
3207         .flags     = ENABLE_ON_INIT,
3208         .ops       = &tegra_pll_ref_ops,
3209         .parent    = &tegra_clk_m,
3210         .max_rate  = 26000000,
3211 };
3212
3213 static struct clk_pll_freq_table tegra_pll_c_freq_table[] = {
3214         { 12000000, 1200000000, 600,  6, 1, 8},
3215         { 13000000, 1200000000, 923, 10, 1, 8},         /* actual: 1199.9 MHz */
3216         { 16800000, 1200000000, 500,  7, 1, 8},
3217         { 19200000, 1200000000, 500,  8, 1, 8},
3218         { 26000000, 1200000000, 600, 13, 1, 8},
3219
3220         { 12000000, 1040000000, 520,  6, 1, 8},
3221         { 13000000, 1040000000, 480,  6, 1, 8},
3222         { 16800000, 1040000000, 495,  8, 1, 8},         /* actual: 1039.5 MHz */
3223         { 19200000, 1040000000, 325,  6, 1, 6},
3224         { 26000000, 1040000000, 520, 13, 1, 8},
3225
3226         { 12000000, 832000000, 416,  6, 1, 8},
3227         { 13000000, 832000000, 832, 13, 1, 8},
3228         { 16800000, 832000000, 396,  8, 1, 8},          /* actual: 831.6 MHz */
3229         { 19200000, 832000000, 260,  6, 1, 8},
3230         { 26000000, 832000000, 416, 13, 1, 8},
3231
3232         { 12000000, 624000000, 624, 12, 1, 8},
3233         { 13000000, 624000000, 624, 13, 1, 8},
3234         { 16800000, 624000000, 520, 14, 1, 8},
3235         { 19200000, 624000000, 520, 16, 1, 8},
3236         { 26000000, 624000000, 624, 26, 1, 8},
3237
3238         { 12000000, 600000000, 600, 12, 1, 8},
3239         { 13000000, 600000000, 600, 13, 1, 8},
3240         { 16800000, 600000000, 500, 14, 1, 8},
3241         { 19200000, 600000000, 375, 12, 1, 6},
3242         { 26000000, 600000000, 600, 26, 1, 8},
3243
3244         { 12000000, 520000000, 520, 12, 1, 8},
3245         { 13000000, 520000000, 520, 13, 1, 8},
3246         { 16800000, 520000000, 495, 16, 1, 8},          /* actual: 519.75 MHz */
3247         { 19200000, 520000000, 325, 12, 1, 6},
3248         { 26000000, 520000000, 520, 26, 1, 8},
3249
3250         { 12000000, 416000000, 416, 12, 1, 8},
3251         { 13000000, 416000000, 416, 13, 1, 8},
3252         { 16800000, 416000000, 396, 16, 1, 8},          /* actual: 415.8 MHz */
3253         { 19200000, 416000000, 260, 12, 1, 6},
3254         { 26000000, 416000000, 416, 26, 1, 8},
3255         { 0, 0, 0, 0, 0, 0 },
3256 };
3257
3258 static struct clk tegra_pll_c = {
3259         .name      = "pll_c",
3260         .flags     = PLL_HAS_CPCON,
3261         .ops       = &tegra_pll_ops,
3262         .reg       = 0x80,
3263         .parent    = &tegra_pll_ref,
3264         .max_rate  = 1400000000,
3265         .u.pll = {
3266                 .input_min = 2000000,
3267                 .input_max = 31000000,
3268                 .cf_min    = 1000000,
3269                 .cf_max    = 6000000,
3270                 .vco_min   = 20000000,
3271                 .vco_max   = 1400000000,
3272                 .freq_table = tegra_pll_c_freq_table,
3273                 .lock_delay = 300,
3274         },
3275 };
3276
3277 static struct clk tegra_pll_c_out1 = {
3278         .name      = "pll_c_out1",
3279         .ops       = &tegra_pll_div_ops,
3280         .flags     = DIV_U71 | PERIPH_ON_CBUS,
3281         .parent    = &tegra_pll_c,
3282         .reg       = 0x84,
3283         .reg_shift = 0,
3284         .max_rate  = 700000000,
3285 };
3286
3287 static struct clk_pll_freq_table tegra_pll_m_freq_table[] = {
3288         { 12000000, 666000000, 666, 12, 1, 8},
3289         { 13000000, 666000000, 666, 13, 1, 8},
3290         { 16800000, 666000000, 555, 14, 1, 8},
3291         { 19200000, 666000000, 555, 16, 1, 8},
3292         { 26000000, 666000000, 666, 26, 1, 8},
3293         { 12000000, 600000000, 600, 12, 1, 8},
3294         { 13000000, 600000000, 600, 13, 1, 8},
3295         { 16800000, 600000000, 500, 14, 1, 8},
3296         { 19200000, 600000000, 375, 12, 1, 6},
3297         { 26000000, 600000000, 600, 26, 1, 8},
3298         { 0, 0, 0, 0, 0, 0 },
3299 };
3300
3301 static struct clk tegra_pll_m = {
3302         .name      = "pll_m",
3303         .flags     = PLL_HAS_CPCON | PLLM,
3304         .ops       = &tegra_pll_ops,
3305         .reg       = 0x90,
3306         .parent    = &tegra_pll_ref,
3307         .max_rate  = 900000000,
3308         .u.pll = {
3309                 .input_min = 2000000,
3310                 .input_max = 31000000,
3311                 .cf_min    = 1000000,
3312                 .cf_max    = 6000000,
3313                 .vco_min   = 20000000,
3314                 .vco_max   = 1200000000,
3315                 .freq_table = tegra_pll_m_freq_table,
3316                 .lock_delay = 300,
3317         },
3318 };
3319
3320 static struct clk tegra_pll_m_out1 = {
3321         .name      = "pll_m_out1",
3322         .ops       = &tegra_pll_div_ops,
3323         .flags     = DIV_U71,
3324         .parent    = &tegra_pll_m,
3325         .reg       = 0x94,
3326         .reg_shift = 0,
3327         .max_rate  = 600000000,
3328 };
3329
3330 static struct clk_pll_freq_table tegra_pll_p_freq_table[] = {
3331         { 12000000, 216000000, 432, 12, 2, 8},
3332         { 13000000, 216000000, 432, 13, 2, 8},
3333         { 16800000, 216000000, 360, 14, 2, 8},
3334         { 19200000, 216000000, 360, 16, 2, 8},
3335         { 26000000, 216000000, 432, 26, 2, 8},
3336         { 0, 0, 0, 0, 0, 0 },
3337 };
3338
3339 static struct clk tegra_pll_p = {
3340         .name      = "pll_p",
3341         .flags     = ENABLE_ON_INIT | PLL_FIXED | PLL_HAS_CPCON,
3342         .ops       = &tegra_pllp_ops,
3343         .reg       = 0xa0,
3344         .parent    = &tegra_pll_ref,
3345         .max_rate  = 432000000,
3346         .u.pll = {
3347                 .input_min = 2000000,
3348                 .input_max = 31000000,
3349                 .cf_min    = 1000000,
3350                 .cf_max    = 6000000,
3351                 .vco_min   = 20000000,
3352                 .vco_max   = 1400000000,
3353                 .freq_table = tegra_pll_p_freq_table,
3354                 .lock_delay = 300,
3355         },
3356 };
3357
3358 static struct clk tegra_pll_p_out1 = {
3359         .name      = "pll_p_out1",
3360         .ops       = &tegra_pll_div_ops,
3361         .flags     = DIV_U71 | DIV_U71_FIXED,
3362         .parent    = &tegra_pll_p,
3363         .reg       = 0xa4,
3364         .reg_shift = 0,
3365         .max_rate  = 432000000,
3366 };
3367
3368 static struct clk tegra_pll_p_out2 = {
3369         .name      = "pll_p_out2",
3370         .ops       = &tegra_pll_div_ops,
3371         .flags     = DIV_U71 | DIV_U71_FIXED,
3372         .parent    = &tegra_pll_p,
3373         .reg       = 0xa4,
3374         .reg_shift = 16,
3375         .max_rate  = 432000000,
3376 };
3377
3378 static struct clk tegra_pll_p_out3 = {
3379         .name      = "pll_p_out3",
3380         .ops       = &tegra_pll_div_ops,
3381         .flags     = DIV_U71 | DIV_U71_FIXED,
3382         .parent    = &tegra_pll_p,
3383         .reg       = 0xa8,
3384         .reg_shift = 0,
3385         .max_rate  = 432000000,
3386 };
3387
3388 static struct clk tegra_pll_p_out4 = {
3389         .name      = "pll_p_out4",
3390         .ops       = &tegra_pll_div_ops,
3391         .flags     = ENABLE_ON_INIT | DIV_U71 | DIV_U71_FIXED,
3392         .parent    = &tegra_pll_p,
3393         .reg       = 0xa8,
3394         .reg_shift = 16,
3395         .max_rate  = 432000000,
3396 };
3397
3398 static struct clk_pll_freq_table tegra_pll_a_freq_table[] = {
3399         { 9600000, 564480000, 294, 5, 1, 4},
3400         { 9600000, 552960000, 288, 5, 1, 4},
3401         { 9600000, 24000000,  5,   2, 1, 1},
3402
3403         { 28800000, 56448000, 49, 25, 1, 1},
3404         { 28800000, 73728000, 64, 25, 1, 1},
3405         { 28800000, 24000000,  5,  6, 1, 1},
3406         { 0, 0, 0, 0, 0, 0 },
3407 };
3408
3409 static struct clk tegra_pll_a = {
3410         .name      = "pll_a",
3411         .flags     = PLL_HAS_CPCON,
3412         .ops       = &tegra_pll_ops,
3413         .reg       = 0xb0,
3414         .parent    = &tegra_pll_p_out1,
3415         .max_rate  = 700000000,
3416         .u.pll = {
3417                 .input_min = 2000000,
3418                 .input_max = 31000000,
3419                 .cf_min    = 1000000,
3420                 .cf_max    = 6000000,
3421                 .vco_min   = 20000000,
3422                 .vco_max   = 1400000000,
3423                 .freq_table = tegra_pll_a_freq_table,
3424                 .lock_delay = 300,
3425         },
3426 };
3427
3428 static struct clk tegra_pll_a_out0 = {
3429         .name      = "pll_a_out0",
3430         .ops       = &tegra_pll_div_ops,
3431         .flags     = DIV_U71,
3432         .parent    = &tegra_pll_a,
3433         .reg       = 0xb4,
3434         .reg_shift = 0,
3435         .max_rate  = 100000000,
3436 };
3437
3438 static struct clk_pll_freq_table tegra_pll_d_freq_table[] = {
3439         { 12000000, 216000000, 216, 12, 1, 4},
3440         { 13000000, 216000000, 216, 13, 1, 4},
3441         { 16800000, 216000000, 180, 14, 1, 4},
3442         { 19200000, 216000000, 180, 16, 1, 4},
3443         { 26000000, 216000000, 216, 26, 1, 4},
3444
3445         { 12000000, 594000000, 594, 12, 1, 8},
3446         { 13000000, 594000000, 594, 13, 1, 8},
3447         { 16800000, 594000000, 495, 14, 1, 8},
3448         { 19200000, 594000000, 495, 16, 1, 8},
3449         { 26000000, 594000000, 594, 26, 1, 8},
3450
3451         { 12000000, 1000000000, 1000, 12, 1, 12},
3452         { 13000000, 1000000000, 1000, 13, 1, 12},
3453         { 19200000, 1000000000, 625,  12, 1, 8},
3454         { 26000000, 1000000000, 1000, 26, 1, 12},
3455
3456         { 0, 0, 0, 0, 0, 0 },
3457 };
3458
3459 static struct clk tegra_pll_d = {
3460         .name      = "pll_d",
3461         .flags     = PLL_HAS_CPCON | PLLD,
3462         .ops       = &tegra_plld_ops,
3463         .reg       = 0xd0,
3464         .parent    = &tegra_pll_ref,
3465         .max_rate  = 1000000000,
3466         .u.pll = {
3467                 .input_min = 2000000,
3468                 .input_max = 40000000,
3469                 .cf_min    = 1000000,
3470                 .cf_max    = 6000000,
3471                 .vco_min   = 40000000,
3472                 .vco_max   = 1000000000,
3473                 .freq_table = tegra_pll_d_freq_table,
3474                 .lock_delay = 1000,
3475         },
3476 };
3477
3478 static struct clk tegra_pll_d_out0 = {
3479         .name      = "pll_d_out0",
3480         .ops       = &tegra_pll_div_ops,
3481         .flags     = DIV_2 | PLLD,
3482         .parent    = &tegra_pll_d,
3483         .max_rate  = 500000000,
3484 };
3485
3486 static struct clk tegra_pll_d2 = {
3487         .name      = "pll_d2",
3488         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG | PLLD,
3489         .ops       = &tegra_plld_ops,
3490         .reg       = 0x4b8,
3491         .parent    = &tegra_pll_ref,
3492         .max_rate  = 1000000000,
3493         .u.pll = {
3494                 .input_min = 2000000,
3495                 .input_max = 40000000,
3496                 .cf_min    = 1000000,
3497                 .cf_max    = 6000000,
3498                 .vco_min   = 40000000,
3499                 .vco_max   = 1000000000,
3500                 .freq_table = tegra_pll_d_freq_table,
3501                 .lock_delay = 1000,
3502         },
3503 };
3504
3505 static struct clk tegra_pll_d2_out0 = {
3506         .name      = "pll_d2_out0",
3507         .ops       = &tegra_pll_div_ops,
3508         .flags     = DIV_2 | PLLD,
3509         .parent    = &tegra_pll_d2,
3510         .max_rate  = 500000000,
3511 };
3512
3513 static struct clk_pll_freq_table tegra_pll_u_freq_table[] = {
3514         { 12000000, 480000000, 960, 12, 2, 12},
3515         { 13000000, 480000000, 960, 13, 2, 12},
3516         { 16800000, 480000000, 400, 7,  2, 5},
3517         { 19200000, 480000000, 200, 4,  2, 3},
3518         { 26000000, 480000000, 960, 26, 2, 12},
3519         { 0, 0, 0, 0, 0, 0 },
3520 };
3521
3522 static struct clk tegra_pll_u = {
3523         .name      = "pll_u",
3524         .flags     = PLL_HAS_CPCON | PLLU,
3525         .ops       = &tegra_pll_ops,
3526         .reg       = 0xc0,
3527         .parent    = &tegra_pll_ref,
3528         .max_rate  = 480000000,
3529         .u.pll = {
3530                 .input_min = 2000000,
3531                 .input_max = 40000000,
3532                 .cf_min    = 1000000,
3533                 .cf_max    = 6000000,
3534                 .vco_min   = 480000000,
3535                 .vco_max   = 960000000,
3536                 .freq_table = tegra_pll_u_freq_table,
3537                 .lock_delay = 1000,
3538         },
3539 };
3540
3541 static struct clk_pll_freq_table tegra_pll_x_freq_table[] = {
3542         /* 1.7 GHz */
3543         { 12000000, 1700000000, 850,  6,  1, 8},
3544         { 13000000, 1700000000, 915,  7,  1, 8},        /* actual: 1699.2 MHz */
3545         { 16800000, 1700000000, 708,  7,  1, 8},        /* actual: 1699.2 MHz */
3546         { 19200000, 1700000000, 885,  10, 1, 8},        /* actual: 1699.2 MHz */
3547         { 26000000, 1700000000, 850,  13, 1, 8},
3548
3549         /* 1.6 GHz */
3550         { 12000000, 1600000000, 800,  6,  1, 8},
3551         { 13000000, 1600000000, 738,  6,  1, 8},        /* actual: 1599.0 MHz */
3552         { 16800000, 1600000000, 857,  9,  1, 8},        /* actual: 1599.7 MHz */
3553         { 19200000, 1600000000, 500,  6,  1, 8},
3554         { 26000000, 1600000000, 800,  13, 1, 8},
3555
3556         /* 1.5 GHz */
3557         { 12000000, 1500000000, 750,  6,  1, 8},
3558         { 13000000, 1500000000, 923,  8,  1, 8},        /* actual: 1499.8 MHz */
3559         { 16800000, 1500000000, 625,  7,  1, 8},
3560         { 19200000, 1500000000, 625,  8,  1, 8},
3561         { 26000000, 1500000000, 750,  13, 1, 8},
3562
3563         /* 1.4 GHz */
3564         { 12000000, 1400000000, 700,  6,  1, 8},
3565         { 13000000, 1400000000, 969,  9,  1, 8},        /* actual: 1399.7 MHz */
3566         { 16800000, 1400000000, 1000, 12, 1, 8},
3567         { 19200000, 1400000000, 875,  12, 1, 8},
3568         { 26000000, 1400000000, 700,  13, 1, 8},
3569
3570         /* 1.3 GHz */
3571         { 12000000, 1300000000, 975,  9,  1, 8},
3572         { 13000000, 1300000000, 1000, 10, 1, 8},
3573         { 16800000, 1300000000, 928,  12, 1, 8},        /* actual: 1299.2 MHz */
3574         { 19200000, 1300000000, 812,  12, 1, 8},        /* actual: 1299.2 MHz */
3575         { 26000000, 1300000000, 650,  13, 1, 8},
3576
3577         /* 1.2 GHz */
3578         { 12000000, 1200000000, 1000, 10, 1, 8},
3579         { 13000000, 1200000000, 923,  10, 1, 8},        /* actual: 1199.9 MHz */
3580         { 16800000, 1200000000, 1000, 14, 1, 8},
3581         { 19200000, 1200000000, 1000, 16, 1, 8},
3582         { 26000000, 1200000000, 600,  13, 1, 8},
3583
3584         /* 1.1 GHz */
3585         { 12000000, 1100000000, 825,  9,  1, 8},
3586         { 13000000, 1100000000, 846,  10, 1, 8},        /* actual: 1099.8 MHz */
3587         { 16800000, 1100000000, 982,  15, 1, 8},        /* actual: 1099.8 MHz */
3588         { 19200000, 1100000000, 859,  15, 1, 8},        /* actual: 1099.5 MHz */
3589         { 26000000, 1100000000, 550,  13, 1, 8},
3590
3591         /* 1 GHz */
3592         { 12000000, 1000000000, 1000, 12, 1, 8},
3593         { 13000000, 1000000000, 1000, 13, 1, 8},
3594         { 16800000, 1000000000, 833,  14, 1, 8},        /* actual: 999.6 MHz */
3595         { 19200000, 1000000000, 625,  12, 1, 8},
3596         { 26000000, 1000000000, 1000, 26, 1, 8},
3597
3598         { 0, 0, 0, 0, 0, 0 },
3599 };
3600
3601 static struct clk tegra_pll_x = {
3602         .name      = "pll_x",
3603         .flags     = PLL_HAS_CPCON | PLL_ALT_MISC_REG | PLLX,
3604         .ops       = &tegra_pll_ops,
3605         .reg       = 0xe0,
3606         .parent    = &tegra_pll_ref,
3607         .max_rate  = 1700000000,
3608         .u.pll = {
3609                 .input_min = 2000000,
3610                 .input_max = 31000000,
3611                 .cf_min    = 1000000,
3612                 .cf_max    = 6000000,
3613                 .vco_min   = 20000000,
3614                 .vco_max   = 1700000000,
3615                 .freq_table = tegra_pll_x_freq_table,
3616                 .lock_delay = 300,
3617         },
3618 };
3619
3620 static struct clk tegra_pll_x_out0 = {
3621         .name      = "pll_x_out0",
3622         .ops       = &tegra_pll_div_ops,
3623         .flags     = DIV_2 | PLLX,
3624         .parent    = &tegra_pll_x,
3625         .max_rate  = 850000000,
3626 };
3627
3628
3629 static struct clk_pll_freq_table tegra_pll_e_freq_table[] = {
3630         /* PLLE special case: use cpcon field to store cml divider value */
3631         { 12000000,  100000000, 150, 1,  18, 11},
3632         { 216000000, 100000000, 200, 18, 24, 13},
3633 #ifndef CONFIG_TEGRA_SILICON_PLATFORM
3634         { 13000000,  100000000, 200, 1,  26, 13},
3635 #endif
3636         { 0, 0, 0, 0, 0, 0 },
3637 };
3638
3639 static struct clk tegra_pll_e = {
3640         .name      = "pll_e",
3641         .flags     = PLL_ALT_MISC_REG,
3642         .ops       = &tegra_plle_ops,
3643         .reg       = 0xe8,
3644         .max_rate  = 100000000,
3645         .u.pll = {
3646                 .input_min = 12000000,
3647                 .input_max = 216000000,
3648                 .cf_min    = 12000000,
3649                 .cf_max    = 12000000,
3650                 .vco_min   = 1200000000,
3651                 .vco_max   = 2400000000U,
3652                 .freq_table = tegra_pll_e_freq_table,
3653                 .lock_delay = 300,
3654                 .fixed_rate = 100000000,
3655         },
3656 };
3657
3658 static struct clk tegra_cml0_clk = {
3659         .name      = "cml0",
3660         .parent    = &tegra_pll_e,
3661         .ops       = &tegra_cml_clk_ops,
3662         .reg       = PLLE_AUX,
3663         .max_rate  = 100000000,
3664         .u.periph  = {
3665                 .clk_num = 0,
3666         },
3667 };
3668
3669 static struct clk tegra_cml1_clk = {
3670         .name      = "cml1",
3671         .parent    = &tegra_pll_e,
3672         .ops       = &tegra_cml_clk_ops,
3673         .reg       = PLLE_AUX,
3674         .max_rate  = 100000000,
3675         .u.periph  = {
3676                 .clk_num   = 1,
3677         },
3678 };
3679
3680 static struct clk tegra_pciex_clk = {
3681         .name      = "pciex",
3682         .parent    = &tegra_pll_e,
3683         .ops       = &tegra_pciex_clk_ops,
3684         .max_rate  = 100000000,
3685         .u.periph  = {
3686                 .clk_num   = 74,
3687         },
3688 };
3689
3690 /* Audio sync clocks */
3691 #define SYNC_SOURCE(_id, _dev)                          \
3692         {                                               \
3693                 .name      = #_id "_sync",              \
3694                 .lookup    = {                          \
3695                         .dev_id    = #_dev ,            \
3696                         .con_id    = "ext_audio_sync",  \
3697                 },                                      \
3698                 .rate      = 24000000,                  \
3699                 .max_rate  = 24000000,                  \
3700                 .ops       = &tegra_sync_source_ops     \
3701         }
3702 static struct clk tegra_sync_source_list[] = {
3703         SYNC_SOURCE(spdif_in, tegra30-spdif),
3704         SYNC_SOURCE(i2s0, tegra30-i2s.0),
3705         SYNC_SOURCE(i2s1, tegra30-i2s.1),
3706         SYNC_SOURCE(i2s2, tegra30-i2s.2),
3707         SYNC_SOURCE(i2s3, tegra30-i2s.3),
3708         SYNC_SOURCE(i2s4, tegra30-i2s.4),
3709         SYNC_SOURCE(vimclk, vimclk),
3710 };
3711
3712 static struct clk_mux_sel mux_audio_sync_clk[] =
3713 {
3714         { .input = &tegra_sync_source_list[0],  .value = 0},
3715         { .input = &tegra_sync_source_list[1],  .value = 1},
3716         { .input = &tegra_sync_source_list[2],  .value = 2},
3717         { .input = &tegra_sync_source_list[3],  .value = 3},
3718         { .input = &tegra_sync_source_list[4],  .value = 4},
3719         { .input = &tegra_sync_source_list[5],  .value = 5},
3720         { .input = &tegra_pll_a_out0,           .value = 6},
3721         { .input = &tegra_sync_source_list[6],  .value = 7},
3722         { 0, 0 }
3723 };
3724
3725 #define AUDIO_SYNC_CLK(_id, _dev, _index)               \
3726         {                                               \
3727                 .name      = #_id,                      \
3728                 .lookup    = {                          \
3729                         .dev_id    = #_dev,             \
3730                         .con_id    = "audio_sync",      \
3731                 },                                      \
3732                 .inputs    = mux_audio_sync_clk,        \
3733                 .reg       = 0x4A0 + (_index) * 4,      \
3734                 .max_rate  = 24000000,                  \
3735                 .ops       = &tegra_audio_sync_clk_ops  \
3736         }
3737 static struct clk tegra_clk_audio_list[] = {
3738         AUDIO_SYNC_CLK(audio0, tegra30-i2s.0, 0),
3739         AUDIO_SYNC_CLK(audio1, tegra30-i2s.1, 1),
3740         AUDIO_SYNC_CLK(audio2, tegra30-i2s.2, 2),
3741         AUDIO_SYNC_CLK(audio3, tegra30-i2s.3, 3),
3742         AUDIO_SYNC_CLK(audio4, tegra30-i2s.4, 4),
3743         AUDIO_SYNC_CLK(audio, tegra30-spdif, 5),
3744 };
3745
3746 #define AUDIO_SYNC_2X_CLK(_id, _dev, _index)                    \
3747         {                                                       \
3748                 .name      = #_id "_2x",                        \
3749                 .lookup    = {                                  \
3750                         .dev_id    = #_dev,                     \
3751                         .con_id    = "audio_sync_2x"            \
3752                 },                                              \
3753                 .flags     = PERIPH_NO_RESET,                   \
3754                 .max_rate  = 48000000,                          \
3755                 .ops       = &tegra_clk_double_ops,             \
3756                 .reg       = 0x49C,                             \
3757                 .reg_shift = 24 + (_index),                     \
3758                 .parent    = &tegra_clk_audio_list[(_index)],   \
3759                 .u.periph = {                                   \
3760                         .clk_num = 113 + (_index),              \
3761                 },                                              \
3762         }
3763 static struct clk tegra_clk_audio_2x_list[] = {
3764         AUDIO_SYNC_2X_CLK(audio0, tegra30-i2s.0, 0),
3765         AUDIO_SYNC_2X_CLK(audio1, tegra30-i2s.1, 1),
3766         AUDIO_SYNC_2X_CLK(audio2, tegra30-i2s.2, 2),
3767         AUDIO_SYNC_2X_CLK(audio3, tegra30-i2s.3, 3),
3768         AUDIO_SYNC_2X_CLK(audio4, tegra30-i2s.4, 4),
3769         AUDIO_SYNC_2X_CLK(audio, tegra30-spdif, 5),
3770 };
3771
3772 #define MUX_I2S_SPDIF(_id, _index)                                      \
3773 static struct clk_mux_sel mux_pllaout0_##_id##_2x_pllp_clkm[] = {       \
3774         {.input = &tegra_pll_a_out0, .value = 0},                       \
3775         {.input = &tegra_clk_audio_2x_list[(_index)], .value = 1},      \
3776         {.input = &tegra_pll_p, .value = 2},                            \
3777         {.input = &tegra_clk_m, .value = 3},                            \
3778         { 0, 0},                                                        \
3779 }
3780 MUX_I2S_SPDIF(audio0, 0);
3781 MUX_I2S_SPDIF(audio1, 1);
3782 MUX_I2S_SPDIF(audio2, 2);
3783 MUX_I2S_SPDIF(audio3, 3);
3784 MUX_I2S_SPDIF(audio4, 4);
3785 MUX_I2S_SPDIF(audio, 5);                /* SPDIF */
3786
3787 /* External clock outputs (through PMC) */
3788 #define MUX_EXTERN_OUT(_id)                                             \
3789 static struct clk_mux_sel mux_clkm_clkm2_clkm4_extern##_id[] = {        \
3790         {.input = &tegra_clk_m,         .value = 0},                    \
3791         {.input = &tegra_clk_m_div2,    .value = 1},                    \
3792         {.input = &tegra_clk_m_div4,    .value = 2},                    \
3793         {.input = NULL,                 .value = 3}, /* placeholder */  \
3794         { 0, 0},                                                        \
3795 }
3796 MUX_EXTERN_OUT(1);
3797 MUX_EXTERN_OUT(2);
3798 MUX_EXTERN_OUT(3);
3799
3800 static struct clk_mux_sel *mux_extern_out_list[] = {
3801         mux_clkm_clkm2_clkm4_extern1,
3802         mux_clkm_clkm2_clkm4_extern2,
3803         mux_clkm_clkm2_clkm4_extern3,
3804 };
3805
3806 #define CLK_OUT_CLK(_id)                                        \
3807         {                                                       \
3808                 .name      = "clk_out_" #_id,                   \
3809                 .lookup    = {                                  \
3810                         .dev_id    = "clk_out_" #_id,           \
3811                         .con_id    = "extern" #_id,             \
3812                 },                                              \
3813                 .ops       = &tegra_clk_out_ops,                \
3814                 .reg       = 0x1a8,                             \
3815                 .inputs    = mux_clkm_clkm2_clkm4_extern##_id,  \
3816                 .flags     = MUX_CLK_OUT,                       \
3817                 .max_rate  = 216000000,                         \
3818                 .u.periph = {                                   \
3819                         .clk_num   = (_id - 1) * 8 + 2,         \
3820                 },                                              \
3821         }
3822 static struct clk tegra_clk_out_list[] = {
3823         CLK_OUT_CLK(1),
3824         CLK_OUT_CLK(2),
3825         CLK_OUT_CLK(3),
3826 };
3827
3828 /* called after peripheral external clocks are initialized */
3829 static void init_clk_out_mux(void)
3830 {
3831         int i;
3832         struct clk *c;
3833
3834         /* output clock con_id is the name of peripheral
3835            external clock connected to input 3 of the output mux */
3836         for (i = 0; i < ARRAY_SIZE(tegra_clk_out_list); i++) {
3837                 c = tegra_get_clock_by_name(
3838                         tegra_clk_out_list[i].lookup.con_id);
3839                 if (!c)
3840                         pr_err("%s: could not find clk %s\n", __func__,
3841                                tegra_clk_out_list[i].lookup.con_id);
3842                 mux_extern_out_list[i][3].input = c;
3843         }
3844 }
3845
3846 /* Peripheral muxes */
3847 static struct clk_mux_sel mux_cclk_g[] = {
3848         { .input = &tegra_clk_m,        .value = 0},
3849         { .input = &tegra_pll_c,        .value = 1},
3850         { .input = &tegra_clk_32k,      .value = 2},
3851         { .input = &tegra_pll_m,        .value = 3},
3852         { .input = &tegra_pll_p,        .value = 4},
3853         { .input = &tegra_pll_p_out4,   .value = 5},
3854         { .input = &tegra_pll_p_out3,   .value = 6},
3855         /* { .input = &tegra_clk_d,     .value = 7}, - no use on tegra3 */
3856         { .input = &tegra_pll_x,        .value = 8},
3857         { 0, 0},
3858 };
3859
3860 static struct clk_mux_sel mux_cclk_lp[] = {
3861         { .input = &tegra_clk_m,        .value = 0},
3862         { .input = &tegra_pll_c,        .value = 1},
3863         { .input = &tegra_clk_32k,      .value = 2},
3864         { .input = &tegra_pll_m,        .value = 3},
3865         { .input = &tegra_pll_p,        .value = 4},
3866         { .input = &tegra_pll_p_out4,   .value = 5},
3867         { .input = &tegra_pll_p_out3,   .value = 6},
3868         /* { .input = &tegra_clk_d,     .value = 7}, - no use on tegra3 */
3869         { .input = &tegra_pll_x_out0,   .value = 8},
3870         { .input = &tegra_pll_x,        .value = 8 | SUPER_LP_DIV2_BYPASS},
3871         { 0, 0},
3872 };
3873
3874 static struct clk_mux_sel mux_sclk[] = {
3875         { .input = &tegra_clk_m,        .value = 0},
3876         { .input = &tegra_pll_c_out1,   .value = 1},
3877         { .input = &tegra_pll_p_out4,   .value = 2},
3878         { .input = &tegra_pll_p_out3,   .value = 3},
3879         { .input = &tegra_pll_p_out2,   .value = 4},
3880         /* { .input = &tegra_clk_d,     .value = 5}, - no use on tegra3 */
3881         { .input = &tegra_clk_32k,      .value = 6},
3882         { .input = &tegra_pll_m_out1,   .value = 7},
3883         { 0, 0},
3884 };
3885
3886 static struct clk tegra_clk_cclk_g = {
3887         .name   = "cclk_g",
3888         .flags  = DIV_U71 | DIV_U71_INT,
3889         .inputs = mux_cclk_g,
3890         .reg    = 0x368,
3891         .ops    = &tegra_super_ops,
3892         .max_rate = 1700000000,
3893 };
3894
3895 static struct clk tegra_clk_cclk_lp = {
3896         .name   = "cclk_lp",
3897         .flags  = DIV_2 | DIV_U71 | DIV_U71_INT,
3898         .inputs = mux_cclk_lp,
3899         .reg    = 0x370,
3900         .ops    = &tegra_super_ops,
3901         .max_rate = 620000000,
3902 };
3903
3904 static struct clk tegra_clk_sclk = {
3905         .name   = "sclk",
3906         .inputs = mux_sclk,
3907         .reg    = 0x28,
3908         .ops    = &tegra_super_ops,
3909         .max_rate = 378000000,
3910         .min_rate = 12000000,
3911 };
3912
3913 static struct clk tegra_clk_virtual_cpu_g = {
3914         .name      = "cpu_g",
3915         .parent    = &tegra_clk_cclk_g,
3916         .ops       = &tegra_cpu_ops,
3917         .max_rate  = 1700000000,
3918         .u.cpu = {
3919                 .main      = &tegra_pll_x,
3920                 .backup    = &tegra_pll_p,
3921                 .mode      = MODE_G,
3922         },
3923 };
3924
3925 static struct clk tegra_clk_virtual_cpu_lp = {
3926         .name      = "cpu_lp",
3927         .parent    = &tegra_clk_cclk_lp,
3928         .ops       = &tegra_cpu_ops,
3929         .max_rate  = 620000000,
3930         .u.cpu = {
3931                 .main      = &tegra_pll_x,
3932                 .backup    = &tegra_pll_p,
3933                 .mode      = MODE_LP,
3934         },
3935 };
3936
3937 static struct clk_mux_sel mux_cpu_cmplx[] = {
3938         { .input = &tegra_clk_virtual_cpu_g,    .value = 0},
3939         { .input = &tegra_clk_virtual_cpu_lp,   .value = 1},
3940         { 0, 0},
3941 };
3942
3943 static struct clk tegra_clk_cpu_cmplx = {
3944         .name      = "cpu",
3945         .inputs    = mux_cpu_cmplx,
3946         .ops       = &tegra_cpu_cmplx_ops,
3947         .max_rate  = 1700000000,
3948 };
3949
3950 static struct clk tegra_clk_cop = {
3951         .name      = "cop",
3952         .parent    = &tegra_clk_sclk,
3953         .ops       = &tegra_cop_ops,
3954         .max_rate  = 378000000,
3955 };
3956
3957 static struct clk tegra_clk_hclk = {
3958         .name           = "hclk",
3959         .flags          = DIV_BUS,
3960         .parent         = &tegra_clk_sclk,
3961         .reg            = 0x30,
3962         .reg_shift      = 4,
3963         .ops            = &tegra_bus_ops,
3964         .max_rate       = 378000000,
3965         .min_rate       = 12000000,
3966 };
3967
3968 static struct clk tegra_clk_pclk = {
3969         .name           = "pclk",
3970         .flags          = DIV_BUS,
3971         .parent         = &tegra_clk_hclk,
3972         .reg            = 0x30,
3973         .reg_shift      = 0,
3974         .ops            = &tegra_bus_ops,
3975         .max_rate       = 167000000,
3976         .min_rate       = 12000000,
3977 };
3978
3979 static struct raw_notifier_head sbus_rate_change_nh;
3980
3981 static struct clk tegra_clk_sbus_cmplx = {
3982         .name      = "sbus",
3983         .parent    = &tegra_clk_sclk,
3984         .ops       = &tegra_sbus_cmplx_ops,
3985         .u.system  = {
3986                 .pclk = &tegra_clk_pclk,
3987                 .hclk = &tegra_clk_hclk,
3988                 .sclk_low = &tegra_pll_p_out4,
3989                 .sclk_high = &tegra_pll_m_out1,
3990         },
3991         .rate_change_nh = &sbus_rate_change_nh,
3992 };
3993
3994 static struct clk tegra_clk_blink = {
3995         .name           = "blink",
3996         .parent         = &tegra_clk_32k,
3997         .reg            = 0x40,
3998         .ops            = &tegra_blink_clk_ops,
3999         .max_rate       = 32768,
4000 };
4001
4002 static struct clk_mux_sel mux_pllm_pllc_pllp_plla[] = {
4003         { .input = &tegra_pll_m, .value = 0},
4004         { .input = &tegra_pll_c, .value = 1},
4005         { .input = &tegra_pll_p, .value = 2},
4006         { .input = &tegra_pll_a_out0, .value = 3},
4007         { 0, 0},
4008 };
4009
4010 static struct clk_mux_sel mux_pllm_pllc_pllp_clkm[] = {
4011         { .input = &tegra_pll_m, .value = 0},
4012         /* { .input = &tegra_pll_c, .value = 1}, not used on tegra3 */
4013         { .input = &tegra_pll_p, .value = 2},
4014         { .input = &tegra_clk_m, .value = 3},
4015         { 0, 0},
4016 };
4017
4018 static struct clk_mux_sel mux_pllp_pllc_pllm_clkm[] = {
4019         { .input = &tegra_pll_p, .value = 0},
4020         { .input = &tegra_pll_c, .value = 1},
4021 #ifndef CONFIG_TEGRA_PLLM_RESTRICTED
4022         { .input = &tegra_pll_m, .value = 2},
4023 #endif
4024         { .input = &tegra_clk_m, .value = 3},
4025         { 0, 0},
4026 };
4027
4028 static struct clk_mux_sel mux_pllp_clkm[] = {
4029         { .input = &tegra_pll_p, .value = 0},
4030         { .input = &tegra_clk_m, .value = 3},
4031         { 0, 0},
4032 };
4033
4034 static struct clk_mux_sel mux_pllp_plld_pllc_clkm[] = {
4035         {.input = &tegra_pll_p, .value = 0},
4036         {.input = &tegra_pll_d_out0, .value = 1},
4037         {.input = &tegra_pll_c, .value = 2},
4038         {.input = &tegra_clk_m, .value = 3},
4039         { 0, 0},
4040 };
4041
4042 static struct clk_mux_sel mux_pllp_pllm_plld_plla_pllc_plld2_clkm[] = {
4043         {.input = &tegra_pll_p, .value = 0},
4044 #ifndef CONFIG_TEGRA_PLLM_RESTRICTED
4045         {.input = &tegra_pll_m, .value = 1},
4046 #endif
4047         {.input = &tegra_pll_d_out0, .value = 2},
4048         {.input = &tegra_pll_a_out0, .value = 3},
4049         {.input = &tegra_pll_c, .value = 4},
4050         {.input = &tegra_pll_d2_out0, .value = 5},
4051         {.input = &tegra_clk_m, .value = 6},
4052         { 0, 0},
4053 };
4054
4055 static struct clk_mux_sel mux_plla_pllc_pllp_clkm[] = {
4056         { .input = &tegra_pll_a_out0, .value = 0},
4057         /* { .input = &tegra_pll_c, .value = 1}, no use on tegra3 */
4058         { .input = &tegra_pll_p, .value = 2},
4059         { .input = &tegra_clk_m, .value = 3},
4060         { 0, 0},
4061 };
4062
4063 static struct clk_mux_sel mux_pllp_pllc_clk32_clkm[] = {
4064         {.input = &tegra_pll_p,     .value = 0},
4065         {.input = &tegra_pll_c,     .value = 1},
4066         {.input = &tegra_clk_32k,   .value = 2},
4067         {.input = &tegra_clk_m,     .value = 3},
4068         { 0, 0},
4069 };
4070
4071 static struct clk_mux_sel mux_pllp_pllc_clkm_clk32[] = {
4072         {.input = &tegra_pll_p,     .value = 0},
4073         {.input = &tegra_pll_c,     .value = 1},
4074         {.input = &tegra_clk_m,     .value = 2},
4075         {.input = &tegra_clk_32k,   .value = 3},
4076         { 0, 0},
4077 };
4078
4079 static struct clk_mux_sel mux_pllp_pllc_pllm[] = {
4080         {.input = &tegra_pll_p,     .value = 0},
4081         {.input = &tegra_pll_c,     .value = 1},
4082 #ifndef CONFIG_TEGRA_PLLM_RESTRICTED
4083         {.input = &tegra_pll_m,     .value = 2},
4084 #endif
4085         { 0, 0},
4086 };
4087
4088 static struct clk_mux_sel mux_clk_m[] = {
4089         { .input = &tegra_clk_m, .value = 0},
4090         { 0, 0},
4091 };
4092
4093 static struct clk_mux_sel mux_pllp_out3[] = {
4094         { .input = &tegra_pll_p_out3, .value = 0},
4095         { 0, 0},
4096 };
4097
4098 static struct clk_mux_sel mux_plld_out0[] = {
4099         { .input = &tegra_pll_d_out0, .value = 0},
4100         { 0, 0},
4101 };
4102
4103 static struct clk_mux_sel mux_plld_out0_plld2_out0[] = {
4104         { .input = &tegra_pll_d_out0,  .value = 0},
4105         { .input = &tegra_pll_d2_out0, .value = 1},
4106         { 0, 0},
4107 };
4108
4109 static struct clk_mux_sel mux_clk_32k[] = {
4110         { .input = &tegra_clk_32k, .value = 0},
4111         { 0, 0},
4112 };
4113
4114 static struct clk_mux_sel mux_plla_clk32_pllp_clkm_plle[] = {
4115         { .input = &tegra_pll_a_out0, .value = 0},
4116         { .input = &tegra_clk_32k,    .value = 1},
4117         { .input = &tegra_pll_p,      .value = 2},
4118         { .input = &tegra_clk_m,      .value = 3},
4119         { .input = &tegra_pll_e,      .value = 4},
4120         { 0, 0},
4121 };
4122
4123 static struct raw_notifier_head emc_rate_change_nh;
4124
4125 static struct clk tegra_clk_emc = {
4126         .name = "emc",
4127         .ops = &tegra_emc_clk_ops,
4128         .reg = 0x19c,
4129         .max_rate = 900000000,
4130         .min_rate = 12000000,
4131         .inputs = mux_pllm_pllc_pllp_clkm,
4132         .flags = MUX | DIV_U71 | PERIPH_EMC_ENB,
4133         .u.periph = {
4134                 .clk_num = 57,
4135         },
4136         .rate_change_nh = &emc_rate_change_nh,
4137 };
4138
4139 static struct clk tegra_clk_emc_bridge = {
4140         .name      = "bridge.emc",
4141         .ops       = &tegra_clk_emc_bridge_ops,
4142         .parent    = &tegra_clk_emc,
4143 };
4144
4145 static struct clk tegra_clk_cbus = {
4146         .name      = "cbus",
4147         .parent    = &tegra_pll_c,
4148         .ops       = &tegra_clk_cbus_ops,
4149         .max_rate  = 700000000,
4150         .mul       = 1,
4151         .div       = 2,
4152         .flags     = PERIPH_ON_CBUS,
4153         .shared_bus_backup = {
4154                 .input = &tegra_pll_p,
4155                 .value = 2,
4156         }
4157 };
4158
4159 #define PERIPH_CLK(_name, _dev, _con, _clk_num, _reg, _max, _inputs, _flags) \
4160         {                                               \
4161                 .name      = _name,                     \
4162                 .lookup    = {                          \
4163                         .dev_id    = _dev,              \
4164                         .con_id    = _con,              \
4165                 },                                      \
4166                 .ops       = &tegra_periph_clk_ops,     \
4167                 .reg       = _reg,                      \
4168                 .inputs    = _inputs,                   \
4169                 .flags     = _flags,                    \
4170                 .max_rate  = _max,                      \
4171                 .u.periph = {                           \
4172                         .clk_num   = _clk_num,          \
4173                 },                                      \
4174         }
4175
4176 #define PERIPH_CLK_EX(_name, _dev, _con, _clk_num, _reg, _max, _inputs, \
4177                         _flags, _ops)                                   \
4178         {                                               \
4179                 .name      = _name,                     \
4180                 .lookup    = {                          \
4181                         .dev_id    = _dev,              \
4182                         .con_id    = _con,              \
4183                 },                                      \
4184                 .ops       = _ops,                      \
4185                 .reg       = _reg,                      \
4186                 .inputs    = _inputs,                   \
4187                 .flags     = _flags,                    \
4188                 .max_rate  = _max,                      \
4189                 .u.periph = {                           \
4190                         .clk_num   = _clk_num,          \
4191                 },                                      \
4192         }
4193
4194 #define SHARED_CLK(_name, _dev, _con, _parent, _id, _div, _mode)\
4195         {                                               \
4196                 .name      = _name,                     \
4197                 .lookup    = {                          \
4198                         .dev_id    = _dev,              \
4199                         .con_id    = _con,              \
4200                 },                                      \
4201                 .ops       = &tegra_clk_shared_bus_ops, \
4202                 .parent = _parent,                      \
4203                 .u.shared_bus_user = {                  \
4204                         .client_id = _id,               \
4205                         .client_div = _div,             \
4206                         .mode = _mode,                  \
4207                 },                                      \
4208         }
4209 struct clk tegra_list_clks[] = {
4210         PERIPH_CLK("apbdma",    "tegra-dma",            NULL,   34,     0,      26000000,  mux_clk_m,                   0),
4211         PERIPH_CLK("rtc",       "rtc-tegra",            NULL,   4,      0,      32768,     mux_clk_32k,                 PERIPH_NO_RESET | PERIPH_ON_APB),
4212         PERIPH_CLK("kbc",       "tegra-kbc",            NULL,   36,     0,      32768,     mux_clk_32k,                 PERIPH_NO_RESET | PERIPH_ON_APB),
4213         PERIPH_CLK("timer",     "timer",                NULL,   5,      0,      26000000,  mux_clk_m,                   0),
4214         PERIPH_CLK("kfuse",     "kfuse-tegra",          NULL,   40,     0,      26000000,  mux_clk_m,                   0),
4215         PERIPH_CLK("fuse",      "fuse-tegra",           "fuse", 39,     0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
4216         PERIPH_CLK("fuse_burn", "fuse-tegra",           "fuse_burn",    39,     0,      26000000,  mux_clk_m,           PERIPH_ON_APB),
4217         PERIPH_CLK("apbif",     "tegra30-ahub",         "apbif", 107,   0,      26000000,  mux_clk_m,                   PERIPH_ON_APB),
4218         PERIPH_CLK("i2s0",      "tegra30-i2s.0",        "i2s",  30,     0x1d8,  26000000,  mux_pllaout0_audio0_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4219         PERIPH_CLK("i2s1",      "tegra30-i2s.1",        "i2s",  11,     0x100,  26000000,  mux_pllaout0_audio1_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4220         PERIPH_CLK("i2s2",      "tegra30-i2s.2",        "i2s",  18,     0x104,  26000000,  mux_pllaout0_audio2_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4221         PERIPH_CLK("i2s3",      "tegra30-i2s.3",        "i2s",  101,    0x3bc,  26000000,  mux_pllaout0_audio3_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4222         PERIPH_CLK("i2s4",      "tegra30-i2s.4",        "i2s",  102,    0x3c0,  26000000,  mux_pllaout0_audio4_2x_pllp_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4223         PERIPH_CLK("spdif_out", "tegra30-spdif",        "spdif_out",    10,     0x108,  26000000, mux_pllaout0_audio_2x_pllp_clkm,      MUX | DIV_U71 | PERIPH_ON_APB),
4224         PERIPH_CLK("spdif_in",  "tegra30-spdif",        "spdif_in",     10,     0x10c,  100000000, mux_pllp_pllc_pllm,          MUX | DIV_U71 | PERIPH_ON_APB),
4225         PERIPH_CLK("pwm",       "pwm",                  NULL,   17,     0x110,  408000000, mux_pllp_pllc_clk32_clkm,    MUX | MUX_PWM | DIV_U71 | PERIPH_ON_APB),
4226         PERIPH_CLK("d_audio",   "tegra30-ahub",         "d_audio", 106, 0x3d0,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4227         PERIPH_CLK("dam0",      "tegra30-dam.0",        NULL,   108,    0x3d8,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71),
4228         PERIPH_CLK("dam1",      "tegra30-dam.1",        NULL,   109,    0x3dc,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71),
4229         PERIPH_CLK("dam2",      "tegra30-dam.2",        NULL,   110,    0x3e0,  48000000,  mux_plla_pllc_pllp_clkm,     MUX | DIV_U71),
4230         PERIPH_CLK("hda",       "tegra30-hda",          "hda",   125,   0x428,  108000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4231         PERIPH_CLK("hda2codec_2x",      "tegra30-hda",  "hda2codec",   111,     0x3e4,  48000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4232         PERIPH_CLK("hda2hdmi",  "tegra30-hda",          "hda2hdmi",     128,    0,      48000000,  mux_clk_m,                   PERIPH_ON_APB),
4233         PERIPH_CLK("sbc1",      "spi_tegra.0",          "spi",  41,     0x134,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4234         PERIPH_CLK("sbc2",      "spi_tegra.1",          "spi",  44,     0x118,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4235         PERIPH_CLK("sbc3",      "spi_tegra.2",          "spi",  46,     0x11c,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4236         PERIPH_CLK("sbc4",      "spi_tegra.3",          "spi",  68,     0x1b4,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4237         PERIPH_CLK("sbc5",      "spi_tegra.4",          "spi",  104,    0x3c8,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4238         PERIPH_CLK("sbc6",      "spi_tegra.5",          "spi",  105,    0x3cc,  160000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4239         PERIPH_CLK("sata_oob",  "tegra_sata_oob",       NULL,   123,    0x420,  216000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
4240         PERIPH_CLK("sata",      "tegra_sata",           NULL,   124,    0x424,  216000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
4241         PERIPH_CLK("sata_cold", "tegra_sata_cold",      NULL,   129,    0,      48000000,  mux_clk_m,                   0),
4242         PERIPH_CLK_EX("ndflash","tegra_nand",           NULL,   13,     0x160,  240000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71,  &tegra_nand_clk_ops),
4243         PERIPH_CLK("ndspeed",   "tegra_nand_speed",     NULL,   80,     0x3f8,  240000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
4244         PERIPH_CLK("vfir",      "vfir",                 NULL,   7,      0x168,  72000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4245         PERIPH_CLK("sdmmc1",    "sdhci-tegra.0",        NULL,   14,     0x150,  208000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4246         PERIPH_CLK("sdmmc2",    "sdhci-tegra.1",        NULL,   9,      0x154,  104000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4247         PERIPH_CLK("sdmmc3",    "sdhci-tegra.2",        NULL,   69,     0x1bc,  208000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4248         PERIPH_CLK("sdmmc4",    "sdhci-tegra.3",        NULL,   15,     0x164,  104000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* scales with voltage */
4249         PERIPH_CLK("vcp",       "tegra-avp",            "vcp",  29,     0,      250000000, mux_clk_m,                   0),
4250         PERIPH_CLK("bsea",      "tegra-avp",            "bsea", 62,     0,      250000000, mux_clk_m,                   0),
4251         PERIPH_CLK("bsev",      "tegra-aes",            "bsev", 63,     0,      250000000, mux_clk_m,                   0),
4252         PERIPH_CLK("vde",       "vde",                  NULL,   61,     0x1c8,  600000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | DIV_U71_INT),
4253         PERIPH_CLK("csite",     "csite",                NULL,   73,     0x1d4,  144000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* max rate ??? */
4254         PERIPH_CLK("la",        "la",                   NULL,   76,     0x1f8,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71),
4255         PERIPH_CLK("owr",       "tegra_w1",             NULL,   71,     0x1cc,  26000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB),
4256         PERIPH_CLK("nor",       "tegra-nor",            NULL,   42,     0x1d0,  127000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71), /* requires min voltage */
4257         PERIPH_CLK("mipi",      "mipi",                 NULL,   50,     0x174,  60000000,  mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | PERIPH_ON_APB), /* scales with voltage */
4258         PERIPH_CLK("i2c1",      "tegra-i2c.0",          "i2c-div",      12,     0x124,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4259         PERIPH_CLK("i2c2",      "tegra-i2c.1",          "i2c-div",      54,     0x198,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4260         PERIPH_CLK("i2c3",      "tegra-i2c.2",          "i2c-div",      67,     0x1b8,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4261         PERIPH_CLK("i2c4",      "tegra-i2c.3",          "i2c-div",      103,    0x3c4,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4262         PERIPH_CLK("i2c5",      "tegra-i2c.4",          "i2c-div",      47,     0x128,  26000000,  mux_pllp_clkm,       MUX | DIV_U16 | PERIPH_ON_APB),
4263         PERIPH_CLK("i2c1-fast", "tegra-i2c.0",          "i2c-fast",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4264         PERIPH_CLK("i2c2-fast", "tegra-i2c.1",          "i2c-fast",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4265         PERIPH_CLK("i2c3-fast", "tegra-i2c.2",          "i2c-fast",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4266         PERIPH_CLK("i2c4-fast", "tegra-i2c.3",          "i2c-fast",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4267         PERIPH_CLK("i2c5-fast", "tegra-i2c.4",          "i2c-fast",     0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4268         PERIPH_CLK("uarta",     "tegra_uart.0",         NULL,   6,      0x178,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4269         PERIPH_CLK("uartb",     "tegra_uart.1",         NULL,   7,      0x17c,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4270         PERIPH_CLK("uartc",     "tegra_uart.2",         NULL,   55,     0x1a0,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4271         PERIPH_CLK("uartd",     "tegra_uart.3",         NULL,   65,     0x1c0,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4272         PERIPH_CLK("uarte",     "tegra_uart.4",         NULL,   66,     0x1c4,  900000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4273         PERIPH_CLK("uarta_dbg", "serial8250.0",         "uarta", 6,     0x178,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4274         PERIPH_CLK("uartb_dbg", "serial8250.0",         "uartb", 7,     0x17c,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4275         PERIPH_CLK("uartc_dbg", "serial8250.0",         "uartc", 55,    0x1a0,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4276         PERIPH_CLK("uartd_dbg", "serial8250.0",         "uartd", 65,    0x1c0,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4277         PERIPH_CLK("uarte_dbg", "serial8250.0",         "uarte", 66,    0x1c4,  900000000, mux_pllp_clkm,               MUX | DIV_U151 | DIV_U151_UART | PERIPH_ON_APB),
4278         PERIPH_CLK_EX("vi",     "tegra_camera",         "vi",   20,     0x148,  470000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT,    &tegra_vi_clk_ops),
4279         PERIPH_CLK("vi_sensor", "tegra_camera",         "vi_sensor",    20,     0x1a8,  150000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | PERIPH_NO_RESET),
4280         PERIPH_CLK("3d",        "3d",                   NULL,   24,     0x158,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT | DIV_U71_IDLE | PERIPH_MANUAL_RESET),
4281         PERIPH_CLK("3d2",       "3d2",                  NULL,   98,     0x3b0,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT | DIV_U71_IDLE | PERIPH_MANUAL_RESET),
4282         PERIPH_CLK("2d",        "2d",                   NULL,   21,     0x15c,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT | DIV_U71_IDLE),
4283         PERIPH_CLK("epp",       "epp",                  NULL,   19,     0x16c,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT),
4284         PERIPH_CLK("mpe",       "mpe",                  NULL,   60,     0x170,  600000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT),
4285         PERIPH_CLK("host1x",    "host1x",               NULL,   28,     0x180,  300000000, mux_pllm_pllc_pllp_plla,     MUX | DIV_U71 | DIV_U71_INT),
4286         PERIPH_CLK("cve",       "cve",                  NULL,   49,     0x140,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
4287         PERIPH_CLK("tvo",       "tvo",                  NULL,   49,     0x188,  250000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
4288         PERIPH_CLK_EX("dtv",    "dtv",                  NULL,   79,     0x1dc,  250000000, mux_clk_m,                   0,              &tegra_dtv_clk_ops),
4289         PERIPH_CLK("hdmi",      "hdmi",                 NULL,   51,     0x18c,  148500000, mux_pllp_pllm_plld_plla_pllc_plld2_clkm,     MUX | MUX8 | DIV_U71),
4290         PERIPH_CLK("tvdac",     "tvdac",                NULL,   53,     0x194,  220000000, mux_pllp_plld_pllc_clkm,     MUX | DIV_U71), /* requires min voltage */
4291         PERIPH_CLK("disp1",     "tegradc.0",            NULL,   27,     0x138,  600000000, mux_pllp_pllm_plld_plla_pllc_plld2_clkm,     MUX | MUX8),
4292         PERIPH_CLK("disp2",     "tegradc.1",            NULL,   26,     0x13c,  600000000, mux_pllp_pllm_plld_plla_pllc_plld2_clkm,     MUX | MUX8),
4293         PERIPH_CLK("usbd",      "tegra-udc.0",          NULL,   22,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
4294         PERIPH_CLK("usb2",      "tegra-ehci.1",         NULL,   58,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
4295         PERIPH_CLK("usb3",      "tegra-ehci.2",         NULL,   59,     0,      480000000, mux_clk_m,                   0), /* requires min voltage */
4296         PERIPH_CLK("dsia",      "tegradc.0",            "dsia", 48,     0,      500000000, mux_plld_out0,               0),
4297         PERIPH_CLK_EX("dsib",   "tegradc.1",            "dsib", 82,     0xd0,   500000000, mux_plld_out0_plld2_out0,    MUX | PLLD,     &tegra_dsib_clk_ops),
4298         PERIPH_CLK("dsi1-fixed", "tegradc.0",           "dsi-fixed",    0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4299         PERIPH_CLK("dsi2-fixed", "tegradc.1",           "dsi-fixed",    0,      0,      108000000, mux_pllp_out3,       PERIPH_NO_ENB),
4300         PERIPH_CLK("csi",       "tegra_camera",         "csi",  52,     0,      102000000, mux_pllp_out3,               0),
4301         PERIPH_CLK("isp",       "tegra_camera",         "isp",  23,     0,      150000000, mux_clk_m,                   0), /* same frequency as VI */
4302         PERIPH_CLK("csus",      "tegra_camera",         "csus", 92,     0,      150000000, mux_clk_m,                   PERIPH_NO_RESET),
4303
4304         PERIPH_CLK("tsensor",   "tegra-tsensor",        NULL,   100,    0x3b8,  216000000, mux_pllp_pllc_clkm_clk32,    MUX | DIV_U71),
4305         PERIPH_CLK("actmon",    "actmon",               NULL,   119,    0x3e8,  216000000, mux_pllp_pllc_clk32_clkm,    MUX | DIV_U71),
4306         PERIPH_CLK("extern1",   "extern1",              NULL,   120,    0x3ec,  216000000, mux_plla_clk32_pllp_clkm_plle,       MUX | MUX8 | DIV_U71),
4307         PERIPH_CLK("extern2",   "extern2",              NULL,   121,    0x3f0,  216000000, mux_plla_clk32_pllp_clkm_plle,       MUX | MUX8 | DIV_U71),
4308         PERIPH_CLK("extern3",   "extern3",              NULL,   122,    0x3f4,  216000000, mux_plla_clk32_pllp_clkm_plle,       MUX | MUX8 | DIV_U71),
4309         PERIPH_CLK("i2cslow",   "i2cslow",              NULL,   81,     0x3fc,  26000000,  mux_pllp_pllc_clk32_clkm,    MUX | DIV_U71 | PERIPH_ON_APB),
4310         PERIPH_CLK("pcie",      "tegra-pcie",           "pcie", 70,     0,      250000000, mux_clk_m,                   0),
4311         PERIPH_CLK("afi",       "tegra-pcie",           "afi",  72,     0,      250000000, mux_clk_m,                   0),
4312         PERIPH_CLK("se",        "se",                   NULL,   127,    0x42c,  625000000, mux_pllp_pllc_pllm_clkm,     MUX | DIV_U71 | DIV_U71_INT),
4313         PERIPH_CLK("mselect",   "mselect",              NULL,   99,     0x3b4,  108000000, mux_pllp_clkm,               MUX | DIV_U71),
4314
4315         SHARED_CLK("avp.sclk",  "tegra-avp",            "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4316         SHARED_CLK("bsea.sclk", "tegra-aes",            "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4317         SHARED_CLK("usbd.sclk", "tegra-udc.0",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4318         SHARED_CLK("usb1.sclk", "tegra-ehci.0",         "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4319         SHARED_CLK("usb2.sclk", "tegra-ehci.1",         "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4320         SHARED_CLK("usb3.sclk", "tegra-ehci.2",         "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4321         SHARED_CLK("wake.sclk", "wake_sclk",            "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4322         SHARED_CLK("mon.avp",   "tegra_actmon",         "avp",  &tegra_clk_sbus_cmplx, NULL, 0, 0),
4323         SHARED_CLK("cap.sclk",  "cap_sclk",             NULL,   &tegra_clk_sbus_cmplx, NULL, 0, SHARED_CEILING),
4324         SHARED_CLK("floor.sclk", "floor_sclk",          NULL,   &tegra_clk_sbus_cmplx, NULL, 0, 0),
4325         SHARED_CLK("sbc1.sclk", "spi_tegra.0",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4326         SHARED_CLK("sbc2.sclk", "spi_tegra.1",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4327         SHARED_CLK("sbc3.sclk", "spi_tegra.2",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4328         SHARED_CLK("sbc4.sclk", "spi_tegra.3",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4329         SHARED_CLK("sbc5.sclk", "spi_tegra.4",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4330         SHARED_CLK("sbc6.sclk", "spi_tegra.5",          "sclk", &tegra_clk_sbus_cmplx, NULL, 0, 0),
4331
4332         SHARED_CLK("avp.emc",   "tegra-avp",            "emc",  &tegra_clk_emc, NULL, 0, 0),
4333         SHARED_CLK("cpu.emc",   "cpu",                  "emc",  &tegra_clk_emc, NULL, 0, 0),
4334         SHARED_CLK("disp1.emc", "tegradc.0",            "emc",  &tegra_clk_emc, NULL, 0, SHARED_BW),
4335         SHARED_CLK("disp2.emc", "tegradc.1",            "emc",  &tegra_clk_emc, NULL, 0, SHARED_BW),
4336         SHARED_CLK("hdmi.emc",  "hdmi",                 "emc",  &tegra_clk_emc, NULL, 0, 0),
4337         SHARED_CLK("usbd.emc",  "tegra-udc.0",          "emc",  &tegra_clk_emc, NULL, 0, 0),
4338         SHARED_CLK("usb1.emc",  "tegra-ehci.0",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4339         SHARED_CLK("usb2.emc",  "tegra-ehci.1",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4340         SHARED_CLK("usb3.emc",  "tegra-ehci.2",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4341         SHARED_CLK("mon.emc",   "tegra_actmon",         "emc",  &tegra_clk_emc, NULL, 0, 0),
4342         SHARED_CLK("cap.emc",   "cap.emc",              NULL,   &tegra_clk_emc, NULL, 0, SHARED_CEILING),
4343         SHARED_CLK("3d.emc",    "tegra_gr3d",           "emc",  &tegra_clk_emc, NULL, 0, 0),
4344         SHARED_CLK("2d.emc",    "tegra_gr2d",           "emc",  &tegra_clk_emc, NULL, 0, 0),
4345         SHARED_CLK("mpe.emc",   "tegra_mpe",            "emc",  &tegra_clk_emc, NULL, 0, 0),
4346         SHARED_CLK("camera.emc", "tegra_camera",        "emc",  &tegra_clk_emc, NULL, 0, SHARED_BW),
4347         SHARED_CLK("sdmmc4.emc", "sdhci-tegra.3",       "emc",  &tegra_clk_emc, NULL, 0, 0),
4348         SHARED_CLK("floor.emc", "floor.emc",            NULL,   &tegra_clk_emc, NULL, 0, 0),
4349
4350         SHARED_CLK("host1x.cbus", "tegra_host1x",       "host1x", &tegra_clk_cbus, "host1x", 2, SHARED_AUTO),
4351         SHARED_CLK("3d.cbus",   "tegra_gr3d",           "gr3d", &tegra_clk_cbus, "3d",  0, 0),
4352         SHARED_CLK("3d2.cbus",  "tegra_gr3d",           "gr3d2", &tegra_clk_cbus, "3d2", 0, 0),
4353         SHARED_CLK("2d.cbus",   "tegra_gr2d",           "gr2d", &tegra_clk_cbus, "2d",  0, 0),
4354         SHARED_CLK("epp.cbus",  "tegra_gr2d",           "epp",  &tegra_clk_cbus, "epp", 0, 0),
4355         SHARED_CLK("mpe.cbus",  "tegra_mpe",            "mpe",  &tegra_clk_cbus, "mpe", 0, 0),
4356         SHARED_CLK("vde.cbus",  "tegra-avp",            "vde",  &tegra_clk_cbus, "vde", 0, 0),
4357         SHARED_CLK("se.cbus",   "tegra-se",             NULL,   &tegra_clk_cbus, "se",  0, 0),
4358         SHARED_CLK("cap.cbus",  "cap.cbus",             NULL,   &tegra_clk_cbus, NULL,  0, SHARED_CEILING),
4359         SHARED_CLK("floor.cbus", "floor.cbus",          NULL,   &tegra_clk_cbus, NULL,  0, 0),
4360 };
4361
4362 #define CLK_DUPLICATE(_name, _dev, _con)                \
4363         {                                               \
4364                 .name   = _name,                        \
4365                 .lookup = {                             \
4366                         .dev_id = _dev,                 \
4367                         .con_id         = _con,         \
4368                 },                                      \
4369         }
4370
4371 /* Some clocks may be used by different drivers depending on the board
4372  * configuration.  List those here to register them twice in the clock lookup
4373  * table under two names.
4374  */
4375 struct clk_duplicate tegra_clk_duplicates[] = {
4376         CLK_DUPLICATE("usbd", "utmip-pad", NULL),
4377         CLK_DUPLICATE("usbd", "tegra-ehci.0", NULL),
4378         CLK_DUPLICATE("usbd", "tegra-otg", NULL),
4379         CLK_DUPLICATE("hdmi", "tegradc.0", "hdmi"),
4380         CLK_DUPLICATE("hdmi", "tegradc.1", "hdmi"),
4381         CLK_DUPLICATE("dsib", "tegradc.0", "dsib"),
4382         CLK_DUPLICATE("dsia", "tegradc.1", "dsia"),
4383         CLK_DUPLICATE("pwm", "tegra_pwm.0", NULL),
4384         CLK_DUPLICATE("pwm", "tegra_pwm.1", NULL),
4385         CLK_DUPLICATE("pwm", "tegra_pwm.2", NULL),
4386         CLK_DUPLICATE("pwm", "tegra_pwm.3", NULL),
4387         CLK_DUPLICATE("cop", "tegra-avp", "cop"),
4388         CLK_DUPLICATE("bsev", "tegra-avp", "bsev"),
4389         CLK_DUPLICATE("cop", "nvavp", "cop"),
4390         CLK_DUPLICATE("bsev", "nvavp", "bsev"),
4391         CLK_DUPLICATE("vde", "tegra-aes", "vde"),
4392         CLK_DUPLICATE("bsea", "tegra-aes", "bsea"),
4393         CLK_DUPLICATE("bsea", "nvavp", "bsea"),
4394         CLK_DUPLICATE("cml1", "tegra_sata_cml", NULL),
4395         CLK_DUPLICATE("cml0", "tegra_pcie", "cml"),
4396         CLK_DUPLICATE("pciex", "tegra_pcie", "pciex"),
4397         CLK_DUPLICATE("i2c1", "tegra-i2c-slave.0", NULL),
4398         CLK_DUPLICATE("i2c2", "tegra-i2c-slave.1", NULL),
4399         CLK_DUPLICATE("i2c3", "tegra-i2c-slave.2", NULL),
4400         CLK_DUPLICATE("i2c4", "tegra-i2c-slave.3", NULL),
4401         CLK_DUPLICATE("i2c5", "tegra-i2c-slave.4", NULL),
4402         CLK_DUPLICATE("sbc1", "spi_slave_tegra.0", NULL),
4403         CLK_DUPLICATE("sbc2", "spi_slave_tegra.1", NULL),
4404         CLK_DUPLICATE("sbc3", "spi_slave_tegra.2", NULL),
4405         CLK_DUPLICATE("sbc4", "spi_slave_tegra.3", NULL),
4406         CLK_DUPLICATE("sbc5", "spi_slave_tegra.4", NULL),
4407         CLK_DUPLICATE("sbc6", "spi_slave_tegra.5", NULL),
4408         CLK_DUPLICATE("twd", "smp_twd", NULL),
4409         CLK_DUPLICATE("vcp", "nvavp", "vcp"),
4410         CLK_DUPLICATE("avp.sclk", "nvavp", "sclk"),
4411         CLK_DUPLICATE("avp.emc", "nvavp", "emc"),
4412         CLK_DUPLICATE("vde.cbus", "nvavp", "vde"),
4413 };
4414
4415 struct clk *tegra_ptr_clks[] = {
4416         &tegra_clk_32k,
4417         &tegra_clk_m,
4418         &tegra_clk_m_div2,
4419         &tegra_clk_m_div4,
4420         &tegra_pll_ref,
4421         &tegra_pll_m,
4422         &tegra_pll_m_out1,
4423         &tegra_pll_c,
4424         &tegra_pll_c_out1,
4425         &tegra_pll_p,
4426         &tegra_pll_p_out1,
4427         &tegra_pll_p_out2,
4428         &tegra_pll_p_out3,
4429         &tegra_pll_p_out4,
4430         &tegra_pll_a,
4431         &tegra_pll_a_out0,
4432         &tegra_pll_d,
4433         &tegra_pll_d_out0,
4434         &tegra_pll_d2,
4435         &tegra_pll_d2_out0,
4436         &tegra_pll_u,
4437         &tegra_pll_x,
4438         &tegra_pll_x_out0,
4439         &tegra_pll_e,
4440         &tegra_cml0_clk,
4441         &tegra_cml1_clk,
4442         &tegra_pciex_clk,
4443         &tegra_clk_cclk_g,
4444         &tegra_clk_cclk_lp,
4445         &tegra_clk_sclk,
4446         &tegra_clk_hclk,
4447         &tegra_clk_pclk,
4448         &tegra_clk_virtual_cpu_g,
4449         &tegra_clk_virtual_cpu_lp,
4450         &tegra_clk_cpu_cmplx,
4451         &tegra_clk_blink,
4452         &tegra_clk_cop,
4453         &tegra_clk_sbus_cmplx,
4454         &tegra_clk_emc,
4455         &tegra3_clk_twd,
4456         &tegra_clk_emc_bridge,
4457         &tegra_clk_cbus,
4458 };
4459
4460 /*
4461  * Backup rate targets for each CPU mode is selected below Fmax(Vmin), and
4462  * high enough to avoid voltage droop when CPU clock is switched between
4463  * backup and main clock sources. Actual backup rates will be rounded based
4464  * on backup source fixed frequency. Maximum stay-on-backup rate will be set
4465  * as a minimum of G and LP backup rates to be supported in both modes.
4466  *
4467  * Sbus threshold must be exact factor of pll_p rate.
4468  */
4469 #define CPU_G_BACKUP_RATE_TARGET        440000000
4470 #define CPU_LP_BACKUP_RATE_TARGET       220000000
4471
4472 static void tegra3_pllp_init_dependencies(unsigned long pllp_rate)
4473 {
4474         u32 div;
4475         unsigned long backup_rate;
4476
4477         switch (pllp_rate) {
4478         case 216000000:
4479                 tegra_pll_p_out1.u.pll_div.default_rate = 28800000;
4480                 tegra_pll_p_out3.u.pll_div.default_rate = 72000000;
4481                 tegra_clk_sbus_cmplx.u.system.threshold = 108000000;
4482                 break;
4483         case 408000000:
4484                 tegra_pll_p_out1.u.pll_div.default_rate = 9600000;
4485                 tegra_pll_p_out3.u.pll_div.default_rate = 102000000;
4486                 tegra_clk_sbus_cmplx.u.system.threshold = 204000000;
4487                 break;
4488         case 204000000:
4489                 tegra_pll_p_out1.u.pll_div.default_rate = 4800000;
4490                 tegra_pll_p_out3.u.pll_div.default_rate = 102000000;
4491                 tegra_clk_sbus_cmplx.u.system.threshold = 204000000;
4492                 break;
4493         default:
4494                 pr_err("tegra: PLLP rate: %lu is not supported\n", pllp_rate);
4495                 BUG();
4496         }
4497         pr_info("tegra: PLLP fixed rate: %lu\n", pllp_rate);
4498
4499         div = DIV_ROUND_UP(pllp_rate, CPU_G_BACKUP_RATE_TARGET);
4500         backup_rate = pllp_rate / div;
4501         tegra_clk_cclk_g.u.cclk.div71 = 2 * div - 2;
4502         tegra_clk_virtual_cpu_g.u.cpu.backup_rate = backup_rate;
4503         cpu_stay_on_backup_max = backup_rate;
4504
4505         div = DIV_ROUND_UP(pllp_rate, CPU_LP_BACKUP_RATE_TARGET);
4506         backup_rate = pllp_rate / div;
4507         tegra_clk_cclk_lp.u.cclk.div71 = 2 * div - 2;
4508         tegra_clk_virtual_cpu_lp.u.cpu.backup_rate = backup_rate;
4509         cpu_stay_on_backup_max = min(cpu_stay_on_backup_max, backup_rate);
4510 }
4511
4512 bool tegra_clk_is_parent_allowed(struct clk *c, struct clk *p)
4513 {
4514         if (c->flags & PERIPH_ON_CBUS)
4515                 return p != &tegra_pll_m;
4516         else
4517                 return p != &tegra_pll_c;
4518
4519         return true;
4520 }
4521
4522 static void tegra3_init_one_clock(struct clk *c)
4523 {
4524         clk_init(c);
4525         INIT_LIST_HEAD(&c->shared_bus_list);
4526         if (!c->lookup.dev_id && !c->lookup.con_id)
4527                 c->lookup.con_id = c->name;
4528         c->lookup.clk = c;
4529         clkdev_add(&c->lookup);
4530 }
4531
4532 /*
4533  * Emergency throttle of G-CPU by setting G-super clock skipper underneath
4534  * clock framework, dvfs, and cpufreq driver s/w layers. Can be called in
4535  * ISR context for EDP events. When releasing throttle, LP-divider is cleared
4536  * just in case it was set as a result of save/restore operations across
4537  * cluster switch (should not happen)
4538  */
4539 void tegra_edp_throttle_cpu_now(u8 factor)
4540 {
4541         if (factor > 1) {
4542                 if (!is_lp_cluster())
4543                         tegra3_super_clk_skipper_update(
4544                                 &tegra_clk_cclk_g, 1, factor);
4545         } else if (factor == 0) {
4546                 tegra3_super_clk_skipper_update(&tegra_clk_cclk_g, 0, 0);
4547                 tegra3_super_clk_skipper_update(&tegra_clk_cclk_lp, 0, 0);
4548         }
4549 }
4550
4551 #ifdef CONFIG_CPU_FREQ
4552
4553 /*
4554  * Frequency table index must be sequential starting at 0 and frequencies
4555  * must be ascending. Re-configurable PLLX is used as a source for rates
4556  * above 204MHz. Rates 204MHz and below are divided down from fixed frequency
4557  * PLLP that may run either at 408MHz or at 204MHz on Tegra3 silicon platforms
4558  * (on FPGA platform PLLP output is reported as 216MHz, but no respective
4559  * tables are provided, since there is no clock scaling on FPGA at all).
4560  */
4561
4562 static struct cpufreq_frequency_table freq_table_300MHz[] = {
4563         { 0, 204000 },
4564         { 1, 300000 },
4565         { 2, CPUFREQ_TABLE_END },
4566 };
4567
4568 static struct cpufreq_frequency_table freq_table_1p0GHz[] = {
4569         { 0,  51000 },
4570         { 1, 102000 },
4571         { 2, 204000 },
4572         { 3, 312000 },
4573         { 4, 456000 },
4574         { 5, 608000 },
4575         { 6, 760000 },
4576         { 7, 816000 },
4577         { 8, 912000 },
4578         { 9, 1000000 },
4579         {10, CPUFREQ_TABLE_END },
4580 };
4581
4582 static struct cpufreq_frequency_table freq_table_1p3GHz[] = {
4583         { 0,   51000 },
4584         { 1,  102000 },
4585         { 2,  204000 },
4586         { 3,  340000 },
4587         { 4,  475000 },
4588         { 5,  640000 },
4589         { 6,  760000 },
4590         { 7,  860000 },
4591         { 8, 1000000 },
4592         { 9, 1100000 },
4593         {10, 1200000 },
4594         {11, 1300000 },
4595         {12, CPUFREQ_TABLE_END },
4596 };
4597
4598 static struct cpufreq_frequency_table freq_table_1p4GHz[] = {
4599         { 0,   51000 },
4600         { 1,  102000 },
4601         { 2,  204000 },
4602         { 3,  370000 },
4603         { 4,  475000 },
4604         { 5,  620000 },
4605         { 6,  760000 },
4606         { 7,  860000 },
4607         { 8, 1000000 },
4608         { 9, 1100000 },
4609         {10, 1200000 },
4610         {11, 1300000 },
4611         {12, 1400000 },
4612         {13, CPUFREQ_TABLE_END },
4613 };
4614
4615 static struct cpufreq_frequency_table freq_table_1p5GHz[] = {
4616         { 0,   51000 },
4617         { 1,  102000 },
4618         { 2,  204000 },
4619         { 3,  340000 },
4620         { 4,  475000 },
4621         { 5,  640000 },
4622         { 6,  760000 },
4623         { 7,  860000 },
4624         { 8, 1000000 },
4625         { 9, 1100000 },
4626         {10, 1200000 },
4627         {11, 1300000 },
4628         {12, 1400000 },
4629         {13, 1500000 },
4630         {14, CPUFREQ_TABLE_END },
4631 };
4632
4633 static struct cpufreq_frequency_table freq_table_1p7GHz[] = {
4634         { 0,   51000 },
4635         { 1,  102000 },
4636         { 2,  204000 },
4637         { 3,  370000 },
4638         { 4,  475000 },
4639         { 5,  620000 },
4640         { 6,  760000 },
4641         { 7,  910000 },
4642         { 8, 1150000 },
4643         { 9, 1300000 },
4644         {10, 1400000 },
4645         {11, 1500000 },
4646         {12, 1600000 },
4647         {13, 1700000 },
4648         {14, CPUFREQ_TABLE_END },
4649 };
4650
4651 static struct tegra_cpufreq_table_data cpufreq_tables[] = {
4652         { freq_table_300MHz, 0,  1 },
4653         { freq_table_1p0GHz, 2,  8 },
4654         { freq_table_1p3GHz, 2, 10 },
4655         { freq_table_1p4GHz, 2, 11 },
4656         { freq_table_1p5GHz, 2, 12 },
4657         { freq_table_1p7GHz, 2, 12 },
4658 };
4659
4660 static int clip_cpu_rate_limits(
4661         struct tegra_cpufreq_table_data *data,
4662         struct cpufreq_policy *policy,
4663         struct clk *cpu_clk_g,
4664         struct clk *cpu_clk_lp)
4665 {
4666         int idx, ret;
4667         struct cpufreq_frequency_table *freq_table = data->freq_table;
4668
4669         /* clip CPU G mode maximum frequency to table entry */
4670         ret = cpufreq_frequency_table_target(policy, freq_table,
4671                 cpu_clk_g->max_rate / 1000, CPUFREQ_RELATION_H, &idx);
4672         if (ret) {
4673                 pr_err("%s: G CPU max rate %lu outside of cpufreq table",
4674                        __func__, cpu_clk_g->max_rate);
4675                 return ret;
4676         }
4677         cpu_clk_g->max_rate = freq_table[idx].frequency * 1000;
4678         if (cpu_clk_g->max_rate < cpu_clk_lp->max_rate) {
4679                 pr_err("%s: G CPU max rate %lu is below LP CPU max rate %lu",
4680                        __func__, cpu_clk_g->max_rate, cpu_clk_lp->max_rate);
4681                 return -EINVAL;
4682         }
4683
4684         /* clip CPU LP mode maximum frequency to table entry, and
4685            set CPU G mode minimum frequency one table step below */
4686         ret = cpufreq_frequency_table_target(policy, freq_table,
4687                 cpu_clk_lp->max_rate / 1000, CPUFREQ_RELATION_H, &idx);
4688         if (ret || !idx) {
4689                 pr_err("%s: LP CPU max rate %lu %s of cpufreq table", __func__,
4690                        cpu_clk_lp->max_rate, ret ? "outside" : "at the bottom");
4691                 return ret;
4692         }
4693         cpu_clk_lp->max_rate = freq_table[idx].frequency * 1000;
4694         cpu_clk_g->min_rate = freq_table[idx-1].frequency * 1000;
4695         data->suspend_index = idx;
4696         return 0;
4697 }
4698
4699 struct tegra_cpufreq_table_data *tegra_cpufreq_table_get(void)
4700 {
4701         int i, ret;
4702         unsigned long selection_rate;
4703         struct clk *cpu_clk_g = tegra_get_clock_by_name("cpu_g");
4704         struct clk *cpu_clk_lp = tegra_get_clock_by_name("cpu_lp");
4705
4706         /* For table selection use top cpu_g rate in dvfs ladder; selection
4707            rate may exceed cpu max_rate (e.g., because of edp limitations on
4708            cpu voltage) - in any case max_rate will be clipped to the table */
4709         if (cpu_clk_g->dvfs && cpu_clk_g->dvfs->num_freqs)
4710                 selection_rate =
4711                         cpu_clk_g->dvfs->freqs[cpu_clk_g->dvfs->num_freqs - 1];
4712         else
4713                 selection_rate = cpu_clk_g->max_rate;
4714
4715         for (i = 0; i < ARRAY_SIZE(cpufreq_tables); i++) {
4716                 struct cpufreq_policy policy;
4717                 policy.cpu = 0; /* any on-line cpu */
4718                 ret = cpufreq_frequency_table_cpuinfo(
4719                         &policy, cpufreq_tables[i].freq_table);
4720                 if (!ret) {
4721                         if ((policy.max * 1000) == selection_rate) {
4722                                 ret = clip_cpu_rate_limits(
4723                                         &cpufreq_tables[i],
4724                                         &policy, cpu_clk_g, cpu_clk_lp);
4725                                 if (!ret)
4726                                         return &cpufreq_tables[i];
4727                         }
4728                 }
4729         }
4730         WARN(1, "%s: No cpufreq table matching G & LP cpu ranges", __func__);
4731         return NULL;
4732 }
4733
4734 /* On DDR3 platforms there is an implicit dependency in this mapping: when cpu
4735  * exceeds max dvfs level for LP CPU clock at TEGRA_EMC_BRIDGE_MVOLTS_MIN, the
4736  * respective emc rate should be above TEGRA_EMC_BRIDGE_RATE_MIN
4737  */
4738 /* FIXME: explicitly check this dependency */
4739 unsigned long tegra_emc_to_cpu_ratio(unsigned long cpu_rate)
4740 {
4741         static unsigned long emc_max_rate = 0;
4742
4743         if (emc_max_rate == 0)
4744                 emc_max_rate = clk_round_rate(
4745                         tegra_get_clock_by_name("emc"), ULONG_MAX);
4746
4747         /* Vote on memory bus frequency based on cpu frequency;
4748            cpu rate is in kHz, emc rate is in Hz */
4749         if (cpu_rate >= 750000)
4750                 return emc_max_rate;    /* cpu >= 750 MHz, emc max */
4751         else if (cpu_rate >= 450000)
4752                 return emc_max_rate/2;  /* cpu >= 500 MHz, emc max/2 */
4753         else if (cpu_rate >= 250000)
4754                 return 100000000;       /* cpu >= 250 MHz, emc 100 MHz */
4755         else
4756                 return 0;               /* emc min */
4757 }
4758
4759 int tegra_update_mselect_rate(unsigned long cpu_rate)
4760 {
4761         static struct clk *mselect = NULL;
4762
4763         unsigned long mselect_rate;
4764
4765         if (!mselect) {
4766                 mselect = tegra_get_clock_by_name("mselect");
4767                 if (!mselect)
4768                         return -ENODEV;
4769         }
4770
4771         /* Vote on mselect frequency based on cpu frequency:
4772            keep mselect at half of cpu rate up to 102 MHz;
4773            cpu rate is in kHz, mselect rate is in Hz */
4774         mselect_rate = DIV_ROUND_UP(cpu_rate, 2) * 1000;
4775         mselect_rate = min(mselect_rate, 102000000UL);
4776
4777         if (mselect_rate != clk_get_rate(mselect))
4778                 return clk_set_rate(mselect, mselect_rate);
4779
4780         return 0;
4781 }
4782 #endif
4783
4784 #ifdef CONFIG_PM_SLEEP
4785 static u32 clk_rst_suspend[RST_DEVICES_NUM + CLK_OUT_ENB_NUM +
4786                            PERIPH_CLK_SOURCE_NUM + 24];
4787
4788 static int tegra_clk_suspend(void)
4789 {
4790         unsigned long off;
4791         u32 *ctx = clk_rst_suspend;
4792
4793         *ctx++ = clk_readl(OSC_CTRL) & OSC_CTRL_MASK;
4794         *ctx++ = clk_readl(CPU_SOFTRST_CTRL);
4795
4796         *ctx++ = clk_readl(tegra_pll_p_out1.reg);
4797         *ctx++ = clk_readl(tegra_pll_p_out3.reg);
4798
4799         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_BASE);
4800         *ctx++ = clk_readl(tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
4801         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_BASE);
4802         *ctx++ = clk_readl(tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
4803         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_BASE);
4804         *ctx++ = clk_readl(tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
4805         *ctx++ = clk_readl(tegra_pll_d2.reg + PLL_BASE);
4806         *ctx++ = clk_readl(tegra_pll_d2.reg + PLL_MISC(&tegra_pll_d2));
4807
4808         *ctx++ = clk_readl(tegra_pll_m_out1.reg);
4809         *ctx++ = clk_readl(tegra_pll_a_out0.reg);
4810         *ctx++ = clk_readl(tegra_pll_c_out1.reg);
4811
4812         *ctx++ = clk_readl(tegra_clk_cclk_g.reg);
4813         *ctx++ = clk_readl(tegra_clk_cclk_g.reg + SUPER_CLK_DIVIDER);
4814         *ctx++ = clk_readl(tegra_clk_cclk_lp.reg);
4815         *ctx++ = clk_readl(tegra_clk_cclk_lp.reg + SUPER_CLK_DIVIDER);
4816
4817         *ctx++ = clk_readl(tegra_clk_sclk.reg);
4818         *ctx++ = clk_readl(tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
4819         *ctx++ = clk_readl(tegra_clk_pclk.reg);
4820
4821         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
4822                         off += 4) {
4823                 if (off == PERIPH_CLK_SOURCE_EMC)
4824                         continue;
4825                 *ctx++ = clk_readl(off);
4826         }
4827         for (off = PERIPH_CLK_SOURCE_G3D2; off <= PERIPH_CLK_SOURCE_SE;
4828                         off+=4) {
4829                 *ctx++ = clk_readl(off);
4830         }
4831         for (off = AUDIO_DLY_CLK; off <= AUDIO_SYNC_CLK_SPDIF; off+=4) {
4832                 *ctx++ = clk_readl(off);
4833         }
4834
4835         *ctx++ = clk_readl(RST_DEVICES_L);
4836         *ctx++ = clk_readl(RST_DEVICES_H);
4837         *ctx++ = clk_readl(RST_DEVICES_U);
4838         *ctx++ = clk_readl(RST_DEVICES_V);
4839         *ctx++ = clk_readl(RST_DEVICES_W);
4840
4841         *ctx++ = clk_readl(CLK_OUT_ENB_L);
4842         *ctx++ = clk_readl(CLK_OUT_ENB_H);
4843         *ctx++ = clk_readl(CLK_OUT_ENB_U);
4844         *ctx++ = clk_readl(CLK_OUT_ENB_V);
4845         *ctx++ = clk_readl(CLK_OUT_ENB_W);
4846
4847         *ctx++ = clk_readl(MISC_CLK_ENB);
4848         *ctx++ = clk_readl(CLK_MASK_ARM);
4849
4850         return 0;
4851 }
4852
4853 static void tegra_clk_resume(void)
4854 {
4855         unsigned long off;
4856         const u32 *ctx = clk_rst_suspend;
4857         u32 val;
4858         u32 pllc_base;
4859         u32 plla_base;
4860         u32 plld_base;
4861         u32 plld2_base;
4862         u32 pll_p_out12, pll_p_out34;
4863         u32 pll_a_out0, pll_m_out1, pll_c_out1;
4864         struct clk *p;
4865
4866         val = clk_readl(OSC_CTRL) & ~OSC_CTRL_MASK;
4867         val |= *ctx++;
4868         clk_writel(val, OSC_CTRL);
4869         clk_writel(*ctx++, CPU_SOFTRST_CTRL);
4870
4871         /* Since we are going to reset devices and switch clock sources in this
4872          * function, plls and secondary dividers is required to be enabled. The
4873          * actual value will be restored back later. Note that boot plls: pllm,
4874          * pllp, and pllu are already configured and enabled.
4875          */
4876         val = PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
4877         val |= val << 16;
4878         pll_p_out12 = *ctx++;
4879         clk_writel(pll_p_out12 | val, tegra_pll_p_out1.reg);
4880         pll_p_out34 = *ctx++;
4881         clk_writel(pll_p_out34 | val, tegra_pll_p_out3.reg);
4882
4883         pllc_base = *ctx++;
4884         clk_writel(pllc_base | PLL_BASE_ENABLE, tegra_pll_c.reg + PLL_BASE);
4885         clk_writel(*ctx++, tegra_pll_c.reg + PLL_MISC(&tegra_pll_c));
4886
4887         plla_base = *ctx++;
4888         clk_writel(plla_base | PLL_BASE_ENABLE, tegra_pll_a.reg + PLL_BASE);
4889         clk_writel(*ctx++, tegra_pll_a.reg + PLL_MISC(&tegra_pll_a));
4890
4891         plld_base = *ctx++;
4892         clk_writel(plld_base | PLL_BASE_ENABLE, tegra_pll_d.reg + PLL_BASE);
4893         clk_writel(*ctx++, tegra_pll_d.reg + PLL_MISC(&tegra_pll_d));
4894
4895         plld2_base = *ctx++;
4896         clk_writel(plld2_base | PLL_BASE_ENABLE, tegra_pll_d2.reg + PLL_BASE);
4897         clk_writel(*ctx++, tegra_pll_d2.reg + PLL_MISC(&tegra_pll_d2));
4898
4899         udelay(1000);
4900
4901         val = PLL_OUT_CLKEN | PLL_OUT_RESET_DISABLE;
4902         pll_m_out1 = *ctx++;
4903         clk_writel(pll_m_out1 | val, tegra_pll_m_out1.reg);
4904         pll_a_out0 = *ctx++;
4905         clk_writel(pll_a_out0 | val, tegra_pll_a_out0.reg);
4906         pll_c_out1 = *ctx++;
4907         clk_writel(pll_c_out1 | val, tegra_pll_c_out1.reg);
4908
4909         clk_writel(*ctx++, tegra_clk_cclk_g.reg);
4910         clk_writel(*ctx++, tegra_clk_cclk_g.reg + SUPER_CLK_DIVIDER);
4911         clk_writel(*ctx++, tegra_clk_cclk_lp.reg);
4912         clk_writel(*ctx++, tegra_clk_cclk_lp.reg + SUPER_CLK_DIVIDER);
4913
4914         clk_writel(*ctx++, tegra_clk_sclk.reg);
4915         clk_writel(*ctx++, tegra_clk_sclk.reg + SUPER_CLK_DIVIDER);
4916         clk_writel(*ctx++, tegra_clk_pclk.reg);
4917
4918         /* enable all clocks before configuring clock sources */
4919         clk_writel(0xfdfffff1ul, CLK_OUT_ENB_L);
4920         clk_writel(0xfefff7f7ul, CLK_OUT_ENB_H);
4921         clk_writel(0x75f79bfful, CLK_OUT_ENB_U);
4922         clk_writel(0xfffffffful, CLK_OUT_ENB_V);
4923         clk_writel(0x00003ffful, CLK_OUT_ENB_W);
4924         wmb();
4925
4926         for (off = PERIPH_CLK_SOURCE_I2S1; off <= PERIPH_CLK_SOURCE_OSC;
4927                         off += 4) {
4928                 if (off == PERIPH_CLK_SOURCE_EMC)
4929                         continue;
4930                 clk_writel(*ctx++, off);
4931         }
4932         for (off = PERIPH_CLK_SOURCE_G3D2; off <= PERIPH_CLK_SOURCE_SE;
4933                         off += 4) {
4934                 clk_writel(*ctx++, off);
4935         }
4936         for (off = AUDIO_DLY_CLK; off <= AUDIO_SYNC_CLK_SPDIF; off+=4) {
4937                 clk_writel(*ctx++, off);
4938         }
4939         wmb();
4940
4941         clk_writel(*ctx++, RST_DEVICES_L);
4942         clk_writel(*ctx++, RST_DEVICES_H);
4943         clk_writel(*ctx++, RST_DEVICES_U);
4944
4945         /* For LP0 resume, don't reset lpcpu, since we are running from it */
4946         val = *ctx++;
4947         val &= ~RST_DEVICES_V_SWR_CPULP_RST_DIS;
4948         clk_writel(val, RST_DEVICES_V);
4949
4950         clk_writel(*ctx++, RST_DEVICES_W);
4951         wmb();
4952
4953         clk_writel(*ctx++, CLK_OUT_ENB_L);
4954         clk_writel(*ctx++, CLK_OUT_ENB_H);
4955         clk_writel(*ctx++, CLK_OUT_ENB_U);
4956
4957         /* For LP0 resume, clk to lpcpu is required to be on */
4958         val = *ctx++;
4959         val |= CLK_OUT_ENB_V_CLK_ENB_CPULP_EN;
4960         clk_writel(val, CLK_OUT_ENB_V);
4961
4962         clk_writel(*ctx++, CLK_OUT_ENB_W);
4963         wmb();
4964
4965         clk_writel(*ctx++, MISC_CLK_ENB);
4966         clk_writel(*ctx++, CLK_MASK_ARM);
4967
4968         /* Restore back the actual pll and secondary divider values */
4969         /* FIXME: need to root cause why pllc is required to be on
4970          * clk_writel(pllc_base, tegra_pll_c.reg + PLL_BASE);
4971          */
4972         clk_writel(pll_p_out12, tegra_pll_p_out1.reg);
4973         clk_writel(pll_p_out34, tegra_pll_p_out3.reg);
4974
4975         clk_writel(plla_base, tegra_pll_a.reg + PLL_BASE);
4976         clk_writel(plld_base, tegra_pll_d.reg + PLL_BASE);
4977         clk_writel(plld2_base, tegra_pll_d2.reg + PLL_BASE);
4978
4979         clk_writel(pll_m_out1, tegra_pll_m_out1.reg);
4980         clk_writel(pll_a_out0, tegra_pll_a_out0.reg);
4981         clk_writel(pll_c_out1, tegra_pll_c_out1.reg);
4982
4983         /* Since EMC clock is not restored, and may not preserve parent across
4984            suspend, update current state, and mark EMC DFS as out of sync */
4985         p = tegra_clk_emc.parent;
4986         tegra3_periph_clk_init(&tegra_clk_emc);
4987
4988         if (p != tegra_clk_emc.parent) {
4989                 /* FIXME: old parent is left enabled here even if EMC was its
4990                    only child before suspend (never happens on Tegra3) */
4991                 pr_debug("EMC parent(refcount) across suspend: %s(%d) : %s(%d)",
4992                         p->name, p->refcnt, tegra_clk_emc.parent->name,
4993                         tegra_clk_emc.parent->refcnt);
4994
4995                 BUG_ON(!p->refcnt);
4996                 p->refcnt--;
4997
4998                 /* the new parent is enabled by low level code, but ref count
4999                    need to be updated up to the root */
5000                 p = tegra_clk_emc.parent;
5001                 while (p && ((p->refcnt++) == 0))
5002                         p = p->parent;
5003         }
5004         tegra_emc_timing_invalidate();
5005
5006         tegra3_pll_clk_init(&tegra_pll_u); /* Re-init utmi parameters */
5007         tegra3_pllp_clk_resume(&tegra_pll_p); /* Fire a bug if not restored */
5008 }
5009 #else
5010 #define tegra_clk_suspend NULL
5011 #define tegra_clk_resume NULL
5012 #endif
5013
5014 static struct syscore_ops tegra_clk_syscore_ops = {
5015         .suspend = tegra_clk_suspend,
5016         .resume = tegra_clk_resume,
5017 };
5018
5019 #ifdef CONFIG_TEGRA_PREINIT_CLOCKS
5020
5021 #define CLK_RSTENB_DEV_V_0_DAM2_BIT     (1 << 14)
5022 #define CLK_RSTENB_DEV_V_0_DAM1_BIT     (1 << 13)
5023 #define CLK_RSTENB_DEV_V_0_DAM0_BIT     (1 << 12)
5024 #define CLK_RSTENB_DEV_V_0_AUDIO_BIT    (1 << 10)
5025
5026 #define CLK_RSTENB_DEV_L_0_HOST1X_BIT   (1 << 28)
5027 #define CLK_RSTENB_DEV_L_0_DISP1_BIT    (1 << 27)
5028
5029 #define DISP1_CLK_REG_OFFSET            0x138
5030 #define DISP1_CLK_SRC_SHIFT             29
5031 #define DISP1_CLK_SRC_MASK              (0x7 << DISP1_CLK_SRC_SHIFT)
5032 #define DISP1_CLK_SRC_PLLP_OUT0         0
5033 #define DISP1_CLK_SRC_PLLM_OUT0         1
5034 #define DISP1_CLK_SRC_PLLD_OUT0         2
5035 #define DISP1_CLK_SRC_PLLA_OUT0         3
5036 #define DISP1_CLK_SRC_PLLC_OUT0         4
5037 #define DISP1_CLK_SRC_PLLD2_OUT0        5
5038 #define DISP1_CLK_SRC_CLKM              6
5039 #define DISP1_CLK_SRC_DEFAULT (DISP1_CLK_SRC_PLLP_OUT0 << DISP1_CLK_SRC_SHIFT)
5040
5041 #define HOST1X_CLK_REG_OFFSET           0x180
5042 #define HOST1X_CLK_SRC_SHIFT            30
5043 #define HOST1X_CLK_SRC_MASK             (0x3 << HOST1X_CLK_SRC_SHIFT)
5044 #define HOST1X_CLK_SRC_PLLM_OUT0        0
5045 #define HOST1X_CLK_SRC_PLLC_OUT0        1
5046 #define HOST1X_CLK_SRC_PLLP_OUT0        2
5047 #define HOST1X_CLK_SRC_PLLA_OUT0        3
5048 #define HOST1X_CLK_SRC_DEFAULT (\
5049                 HOST1X_CLK_SRC_PLLP_OUT0 << HOST1X_CLK_SRC_SHIFT)
5050 #define HOST1X_CLK_IDLE_DIV_SHIFT       8
5051 #define HOST1X_CLK_IDLE_DIV_MASK        (0xff << HOST1X_CLK_IDLE_DIV_SHIFT)
5052 #define HOST1X_CLK_IDLE_DIV_DEFAULT     (0 << HOST1X_CLK_IDLE_DIV_SHIFT)
5053 #define HOST1X_CLK_DIV_SHIFT            0
5054 #define HOST1X_CLK_DIV_MASK             (0xff << HOST1X_CLK_DIV_SHIFT)
5055 #define HOST1X_CLK_DIV_DEFAULT          (3 << HOST1X_CLK_DIV_SHIFT)
5056
5057 #define AUDIO_CLK_REG_OFFSET            0x3d0
5058 #define DAM0_CLK_REG_OFFSET             0x3d8
5059 #define DAM1_CLK_REG_OFFSET             0x3dc
5060 #define DAM2_CLK_REG_OFFSET             0x3e0
5061 #define AUDIO_CLK_SRC_SHIFT             28
5062 #define AUDIO_CLK_SRC_MASK              (0x0f << AUDIO_CLK_SRC_SHIFT)
5063 #define AUDIO_CLK_SRC_PLLA_OUT0         0x01
5064 #define AUDIO_CLK_SRC_PLLC_OUT0         0x05
5065 #define AUDIO_CLK_SRC_PLLP_OUT0         0x09
5066 #define AUDIO_CLK_SRC_CLKM              0x0d
5067 #define AUDIO_CLK_SRC_DEFAULT (\
5068                 AUDIO_CLK_SRC_CLKM << AUDIO_CLK_SRC_SHIFT)
5069 #define AUDIO_CLK_DIV_SHIFT             0
5070 #define AUDIO_CLK_DIV_MASK              (0xff << AUDIO_CLK_DIV_SHIFT)
5071 #define AUDIO_CLK_DIV_DEFAULT (\
5072                 (0 << AUDIO_CLK_DIV_SHIFT))
5073
5074 static void __init clk_setbit(u32 reg, u32 bit)
5075 {
5076         u32 val = clk_readl(reg);
5077
5078         if ((val & bit) == bit)
5079                 return;
5080         val |= bit;
5081         clk_writel(val, reg);
5082         udelay(2);
5083 }
5084
5085 static void __init clk_clrbit(u32 reg, u32 bit)
5086 {
5087         u32 val = clk_readl(reg);
5088
5089         if ((val & bit) == 0)
5090                 return;
5091         val &= ~bit;
5092         clk_writel(val, reg);
5093         udelay(2);
5094 }
5095
5096 static void __init clk_setbits(u32 reg, u32 bits, u32 mask)
5097 {
5098         u32 val = clk_readl(reg);
5099
5100         if ((val & mask) == bits)
5101                 return;
5102         val &= ~mask;
5103         val |= bits;
5104         clk_writel(val, reg);
5105         udelay(2);
5106 }
5107
5108 static int __init tegra_soc_preinit_clocks(void)
5109 {
5110         /*
5111          * Make sure host1x clock configuration has:
5112          *      HOST1X_CLK_SRC    : PLLP_OUT0.
5113          *      HOST1X_CLK_DIVISOR: >2 to start from safe enough frequency.
5114          */
5115         clk_setbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_HOST1X_BIT);
5116         clk_setbit(CLK_OUT_ENB_L, CLK_RSTENB_DEV_L_0_HOST1X_BIT);
5117         clk_setbits(HOST1X_CLK_REG_OFFSET,
5118                     HOST1X_CLK_DIV_DEFAULT, HOST1X_CLK_DIV_MASK);
5119         clk_setbits(HOST1X_CLK_REG_OFFSET,
5120                     HOST1X_CLK_IDLE_DIV_DEFAULT, HOST1X_CLK_IDLE_DIV_MASK);
5121         clk_setbits(HOST1X_CLK_REG_OFFSET,
5122                     HOST1X_CLK_SRC_DEFAULT, HOST1X_CLK_SRC_MASK);
5123         clk_clrbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_HOST1X_BIT);
5124
5125         /*
5126          *  Make sure disp1 clock configuration ha:
5127          *      DISP1_CLK_SRC:  DISP1_CLK_SRC_PLLP_OUT0
5128          */
5129         clk_setbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_DISP1_BIT);
5130         clk_setbit(CLK_OUT_ENB_L, CLK_RSTENB_DEV_L_0_DISP1_BIT);
5131         clk_setbits(DISP1_CLK_REG_OFFSET,
5132                     DISP1_CLK_SRC_DEFAULT, DISP1_CLK_SRC_MASK);
5133         clk_clrbit(RST_DEVICES_L, CLK_RSTENB_DEV_L_0_DISP1_BIT);
5134
5135         /*
5136          *  Make sure dam2 clock configuration has:
5137          *      DAM2_CLK_SRC:   AUDIO_CLK_SRC_CLKM
5138          */
5139         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM2_BIT);
5140         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_DAM2_BIT);
5141         clk_setbits(DAM2_CLK_REG_OFFSET,
5142                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5143         clk_setbits(DAM2_CLK_REG_OFFSET,
5144                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5145         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM2_BIT);
5146
5147         /*
5148          *  Make sure dam1 clock configuration has:
5149          *      DAM1_CLK_SRC:   AUDIO_CLK_SRC_CLKM
5150          */
5151         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM1_BIT);
5152         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_DAM1_BIT);
5153         clk_setbits(DAM1_CLK_REG_OFFSET,
5154                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5155         clk_setbits(DAM1_CLK_REG_OFFSET,
5156                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5157         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM1_BIT);
5158
5159         /*
5160          *  Make sure dam0 clock configuration has:
5161          *      DAM0_CLK_SRC:   AUDIO_CLK_SRC_CLKM
5162          */
5163         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM0_BIT);
5164         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_DAM0_BIT);
5165         clk_setbits(DAM0_CLK_REG_OFFSET,
5166                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5167         clk_setbits(DAM0_CLK_REG_OFFSET,
5168                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5169         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_DAM0_BIT);
5170
5171         /*
5172          *  Make sure d_audio clock configuration has:
5173          *      AUDIO_CLK_SRC:  AUDIO_CLK_SRC_CLKM
5174          */
5175         clk_setbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_AUDIO_BIT);
5176         clk_setbit(CLK_OUT_ENB_V, CLK_RSTENB_DEV_V_0_AUDIO_BIT);
5177         clk_setbits(AUDIO_CLK_REG_OFFSET,
5178                     AUDIO_CLK_DIV_DEFAULT, AUDIO_CLK_DIV_MASK);
5179         clk_setbits(AUDIO_CLK_REG_OFFSET,
5180                     AUDIO_CLK_SRC_DEFAULT, AUDIO_CLK_SRC_MASK);
5181         clk_clrbit(RST_DEVICES_V, CLK_RSTENB_DEV_V_0_AUDIO_BIT);
5182
5183         return 0;
5184 }
5185 #endif /* CONFIG_TEGRA_PREINIT_CLOCKS */
5186
5187 void __init tegra30_init_clocks(void)
5188 {
5189         int i;
5190         struct clk *c;
5191
5192 #ifdef CONFIG_TEGRA_PREINIT_CLOCKS
5193         tegra_soc_preinit_clocks();
5194 #endif /* CONFIG_TEGRA_PREINIT_CLOCKS */
5195
5196         for (i = 0; i < ARRAY_SIZE(tegra_ptr_clks); i++)
5197                 tegra3_init_one_clock(tegra_ptr_clks[i]);
5198
5199         for (i = 0; i < ARRAY_SIZE(tegra_list_clks); i++)
5200                 tegra3_init_one_clock(&tegra_list_clks[i]);
5201
5202         for (i = 0; i < ARRAY_SIZE(tegra_clk_duplicates); i++) {
5203                 c = tegra_get_clock_by_name(tegra_clk_duplicates[i].name);
5204                 if (!c) {
5205                         pr_err("%s: Unknown duplicate clock %s\n", __func__,
5206                                 tegra_clk_duplicates[i].name);
5207                         continue;
5208                 }
5209
5210                 tegra_clk_duplicates[i].lookup.clk = c;
5211                 clkdev_add(&tegra_clk_duplicates[i].lookup);
5212         }
5213
5214         for (i = 0; i < ARRAY_SIZE(tegra_sync_source_list); i++)
5215                 tegra3_init_one_clock(&tegra_sync_source_list[i]);
5216         for (i = 0; i < ARRAY_SIZE(tegra_clk_audio_list); i++)
5217                 tegra3_init_one_clock(&tegra_clk_audio_list[i]);
5218         for (i = 0; i < ARRAY_SIZE(tegra_clk_audio_2x_list); i++)
5219                 tegra3_init_one_clock(&tegra_clk_audio_2x_list[i]);
5220
5221         init_clk_out_mux();
5222         for (i = 0; i < ARRAY_SIZE(tegra_clk_out_list); i++)
5223                 tegra3_init_one_clock(&tegra_clk_out_list[i]);
5224
5225         emc_bridge = &tegra_clk_emc_bridge;
5226
5227         /* Initialize to default */
5228         tegra_init_cpu_edp_limits(0);
5229
5230         register_syscore_ops(&tegra_clk_syscore_ops);
5231 }