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