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